feat: persist Colab route geometry bundle for CityScope parity

- Add colab_route_geometry_bundle (jsonb) on submission_batches and migration extending submit_unified_submission_write with p_colab_route_geometry_bundle.
- Serialize the painted IntegratedRoute via colabRouteGeometryExport on unified submit (MapPage + unifiedSubmission).
- Return/select the bundle where submission batches are loaded (submissionBatches).
- Add tests for the export helper.

Author: Tuvudel

src/pages/MapPage/index.tsx

@@ -24,6 +24,7 @@ import {
   flattenIntegratedRouteForPersistence,
   parseDefaultLinePaths,
 } from "../../utils/pinkLineRoute";
+import { serializeIntegratedRouteToColabBundle } from "../../utils/colabRouteGeometryExport";
 import { addDetourPaintToMap } from "../../map/pinkDetourLeaflet";
 import { routeLineStylesForDisplayColor } from "./mapLineStyles";
 import {
@@ -1406,6 +1407,11 @@ const MapPage = () => {
 
     setSubmitting(true);
     try {
+      const colabRouteGeometryBundle =
+        includePink && integratedPinkRoute
+          ? serializeIntegratedRouteToColabBundle(integratedPinkRoute)
+          : null;
+
       const useOverwrite = isEditingExistingSubmission && submitEditDisposition === "overwrite";
 
       if (useOverwrite) {
@@ -1427,6 +1433,7 @@ const MapPage = () => {
           pinkNodes,
           pinkRoutePoints: includePink ? pinkRouteForPersistence : [],
           memorialSites: memorialRows,
+          colabRouteGeometryBundle,
           ...overwriteColorPayload,
         });
       } else {
@@ -1444,6 +1451,7 @@ const MapPage = () => {
           pinkNodes,
           pinkRoutePoints: includePink ? pinkRouteForPersistence : [],
           memorialSites: memorialRows,
+          colabRouteGeometryBundle,
           ...newColorPayload,
         });
         selectedSubmissionIdRef.current = submissionId;

src/supabase/submissionBatches.ts

@@ -1,6 +1,7 @@
 import { GeoJSON } from "geojson";
 import supabase from ".";
 import type { PendingSite } from "./memorialSites";
+import type { ColabRouteGeometryBundle } from "../utils/colabRouteGeometryExport";
 
 /** Matches `PendingPinkNode` in MapPage (`tempId` is stable per geo_feature row for hydration). */
 export interface SubmissionBatchPinkNodeState {
@@ -32,6 +33,7 @@ export interface SubmissionBatchDetail {
   pinkNodes: SubmissionBatchPinkNodeState[];
   centralSite: PendingSite | null;
   localSites: PendingSite[];
+  colabRouteGeometryBundle: ColabRouteGeometryBundle | null;
 }
 
 export type MapSubmissionListContext = {
@@ -313,15 +315,23 @@ export async function loadSubmissionBatchMapDetail(
   const { data: batch, error: batchErr } = await supabase
     .from("submission_batches")
     .select(
-      "submission_id, submission_name, display_color, created_by, created_at, updated_at"
+      "submission_id, submission_name, display_color, created_by, created_at, updated_at, colab_route_geometry_bundle"
     )
     .eq("submission_id", submissionId)
     .maybeSingle();
 
   if (batchErr) throw batchErr;
   if (!batch) throw new Error(`Submission batch not found: ${submissionId}`);
 
-  const b = batch as SubmissionBatchRow;
+  const b = batch as SubmissionBatchRow & {
+    colab_route_geometry_bundle?: unknown;
+  };
+  const colabRouteGeometryBundleRaw = b.colab_route_geometry_bundle;
+  const colabRouteGeometryBundle: ColabRouteGeometryBundle | null =
+    colabRouteGeometryBundleRaw != null &&
+    typeof colabRouteGeometryBundleRaw === "object"
+      ? (colabRouteGeometryBundleRaw as ColabRouteGeometryBundle)
+      : null;
 
   type FeatureRow = {
     id: string;
@@ -421,6 +431,7 @@ export async function loadSubmissionBatchMapDetail(
     pinkNodes,
     centralSite,
     localSites,
+    colabRouteGeometryBundle,
   };
 }
 

src/supabase/unifiedSubmission.ts

@@ -3,6 +3,7 @@ import supabase from ".";
 import { MemorialFeatureType } from "./memorialSites";
 import type { MapWorkspaceProjectIds } from "./submissionBatches";
 import { isAllowedSubmissionDisplayColor } from "../submission/submissionDisplayColor";
+import type { ColabRouteGeometryBundle } from "../utils/colabRouteGeometryExport";
 
 export interface PendingPinkNodeSubmission {
   name: string | null;
@@ -31,6 +32,7 @@ type SubmitUnifiedFeaturesParamsBase = {
   pinkRoutePoints?: Array<[number, number]>;
   memorialSites: PendingMemorialSubmission[];
   submissionDisplayColor?: string | null;
+  colabRouteGeometryBundle?: ColabRouteGeometryBundle | null;
 };
 
 /** Create a new submission batch row and insert features (default). */
@@ -207,6 +209,9 @@ export async function submitUnifiedFeatures(params: SubmitUnifiedFeaturesParams)
       p_memorial_project_id: workspace.memorialProjectId,
       p_feature_rows: rowsToRpcPayload(rows),
       p_submission_display_color: params.submissionDisplayColor ?? null,
+      ...(params.colabRouteGeometryBundle != null
+        ? { p_colab_route_geometry_bundle: params.colabRouteGeometryBundle }
+        : {}),
     });
     if (error) throw error;
     await insertPinkRouteLineIfNeeded(
@@ -237,6 +242,9 @@ export async function submitUnifiedFeatures(params: SubmitUnifiedFeaturesParams)
     p_memorial_project_id: params.memorialProjectId,
     p_feature_rows: rowsToRpcPayload(rows),
     p_submission_display_color: params.submissionDisplayColor ?? null,
+    ...(params.colabRouteGeometryBundle != null
+      ? { p_colab_route_geometry_bundle: params.colabRouteGeometryBundle }
+      : {}),
   });
   if (error) throw error;
   await insertPinkRouteLineIfNeeded(

src/utils/colabRouteGeometryExport.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, it } from "vitest";
+import {
+  COLAB_ROUTE_GEOMETRY_EXPORT_VERSION,
+  serializeIntegratedRouteToColabBundle,
+} from "./colabRouteGeometryExport";
+import type { IntegratedRoute } from "./pinkLineRoute";
+
+describe("serializeIntegratedRouteToColabBundle", () => {
+  it("maps LatLng to GeoJSON lng/lat and splits detourPaint kinds", () => {
+    const route: IntegratedRoute = {
+      solid: [
+        [
+          [32.0, 34.9],
+          [32.001, 34.901],
+        ],
+      ],
+      dashed: [],
+      removed: [
+        [
+          [32.01, 34.91],
+          [32.02, 34.92],
+        ],
+      ],
+      detourPaint: [
+        {
+          kind: "road",
+          points: [
+            [32.1, 35.0],
+            [32.11, 35.01],
+          ],
+        },
+        {
+          kind: "offroad",
+          roadEnd: [32.11, 35.01],
+          target: [32.2, 35.1],
+        },
+      ],
+      degradedDashedSegments: 0,
+    };
+
+    const bundle = serializeIntegratedRouteToColabBundle(route);
+
+    expect(bundle.detour_export_version).toBe(COLAB_ROUTE_GEOMETRY_EXPORT_VERSION);
+    expect(bundle.integrated_route.solid[0]!.coordinates[0]).toEqual([34.9, 32.0]);
+    expect(bundle.integrated_route.removed[0]!.coordinates[0]).toEqual([34.91, 32.01]);
+    expect(bundle.detour_paint.road[0]!.coordinates[0]).toEqual([35.0, 32.1]);
+    expect(bundle.detour_paint.offroad[0]!.road_end).toEqual([35.01, 32.11]);
+    expect(bundle.detour_paint.offroad[0]!.target).toEqual([35.1, 32.2]);
+    expect(bundle.detour_paint.junctions).toEqual([[35.01, 32.11]]);
+  });
+
+  it("uses dashed road legs when detourPaint is empty", () => {
+    const route: IntegratedRoute = {
+      solid: [],
+      dashed: [
+        [
+          [32.0, 35.0],
+          [32.1, 35.1],
+        ],
+      ],
+      removed: [],
+      degradedDashedSegments: 0,
+    };
+    const bundle = serializeIntegratedRouteToColabBundle(route);
+    expect(bundle.detour_paint.road).toHaveLength(1);
+    expect(bundle.detour_paint.offroad).toHaveLength(0);
+    expect(bundle.detour_paint.junctions).toEqual([]);
+  });
+});

src/utils/colabRouteGeometryExport.ts

@@ -0,0 +1,79 @@
+import type { DetourPaintPiece, IntegratedRoute, LatLng } from "./pinkLineRoute";
+
+/** GeoJSON position order in exported JSON (RFC 7946). Internal `LatLng` remains [lat, lng]. */
+export type LngLat = [number, number];
+
+export const COLAB_ROUTE_GEOMETRY_EXPORT_VERSION = 1 as const;
+
+export interface ColabRouteGeometryBundle {
+  detour_export_version: typeof COLAB_ROUTE_GEOMETRY_EXPORT_VERSION;
+  integrated_route: {
+    solid: Array<{ coordinates: LngLat[] }>;
+    removed: Array<{ coordinates: LngLat[] }>;
+  };
+  detour_paint: {
+    road: Array<{ coordinates: LngLat[] }>;
+    offroad: Array<{ road_end: LngLat; target: LngLat }>;
+    junctions: LngLat[];
+  };
+}
+
+function toLngLat([lat, lng]: LatLng): LngLat {
+  return [lng, lat];
+}
+
+function ringLngLat(ring: LatLng[]): LngLat[] {
+  return ring.map(toLngLat);
+}
+
+function collectJunctionsFromPaint(pieces: DetourPaintPiece[]): LngLat[] {
+  const out: LngLat[] = [];
+  for (const p of pieces) {
+    if (p.kind === "offroad") {
+      out.push(toLngLat(p.roadEnd));
+    }
+  }
+  return out;
+}
+
+/**
+ * Serializes the same `IntegratedRoute` snapshot used for map painting after routing.
+ * When `detourPaint` is absent, proposed geometry is taken from `dashed` as road polylines.
+ */
+export function serializeIntegratedRouteToColabBundle(
+  route: IntegratedRoute
+): ColabRouteGeometryBundle {
+  const solid = route.solid.map((ring) => ({ coordinates: ringLngLat(ring) }));
+  const removed = route.removed.map((ring) => ({ coordinates: ringLngLat(ring) }));
+
+  const road: Array<{ coordinates: LngLat[] }> = [];
+  const offroad: Array<{ road_end: LngLat; target: LngLat }> = [];
+
+  if (route.detourPaint && route.detourPaint.length > 0) {
+    for (const piece of route.detourPaint) {
+      if (piece.kind === "road") {
+        road.push({ coordinates: ringLngLat(piece.points) });
+      } else {
+        offroad.push({
+          road_end: toLngLat(piece.roadEnd),
+          target: toLngLat(piece.target),
+        });
+      }
+    }
+  } else {
+    for (const seg of route.dashed) {
+      if (seg.length >= 2) road.push({ coordinates: ringLngLat(seg) });
+    }
+  }
+
+  const junctions =
+    route.detourPaint && route.detourPaint.length > 0
+      ? collectJunctionsFromPaint(route.detourPaint)
+      : [];
+
+  return {
+    detour_export_version: COLAB_ROUTE_GEOMETRY_EXPORT_VERSION,
+    integrated_route: { solid, removed },
+    detour_paint: { road, offroad, junctions },
+  };
+}