fix: route collapses to a handful of points when the endpoint closes a loop

The endpoint mid-edge snap logic truncated the route at "the last time
the trail traversed the snap edge" — but the Eulerian circuit's
traversal order isn't dictated by click order. With a long/complex
route, a street shared with an earlier segment (e.g. clicking an
endpoint near the route's own start, a normal way to close a loop)
could appear only once, far from the actual end. That single early
match got truncated as if it were the terminus, discarding the rest
of the route (reported case: 1007 points collapsed to 4).

Now only trusts a match within ~10% of the trail's tail as the real
terminus; otherwise leaves the route untouched rather than risk
destroying most of it. Extracted the endpoint-snap logic into a
standalone applyEndpointSnap() so it's directly testable without
depending on the CPP solver's heuristic ordering.

Author: chadbeaudin

lib/graph.test.ts

@@ -1,4 +1,4 @@
-import { StreetGraph, pointInPolygon, pointInAnyPolygon, pointNearOrInPolygon, getPolygonBounds, trimBridgeOverlap } from './graph';
+import { StreetGraph, pointInPolygon, pointInAnyPolygon, pointNearOrInPolygon, getPolygonBounds, trimBridgeOverlap, applyEndpointSnap } from './graph';
 import { OverpassResponse } from './types';
 
 describe('StreetGraph', () => {
@@ -290,6 +290,71 @@ describe('StreetGraph', () => {
         expect(last.lon).not.toBeCloseTo(0.002, 9);
     });
 
+    describe('applyEndpointSnap', () => {
+        // A straight chain, node ids as letters, ~111m apart (0.001 deg).
+        // A-B is the "shared" edge: it appears once near the start (index 0-1)
+        // and the trail continues on for many more points afterward.
+        const A = { lat: 0, lon: 0 };
+        const B = { lat: 0, lon: 0.001 };
+        const uv = { u: 'A', v: 'B' };
+
+        function longTrailStartingWithAB(tailLength: number) {
+            const coords: { lat: number; lon: number }[] = [A, B];
+            for (let i = 1; i <= tailLength; i++) coords.push({ lat: 0, lon: 0.001 + i * 0.001 });
+            return coords;
+        }
+
+        test('regression: does not collapse a long route when the endpoint snaps onto an edge used only near the start', () => {
+            // User's reported bug: clicked an endpoint close to the route's own
+            // start (a normal way to close a loop) — the snap edge (A-B) was
+            // only traversed once, right at the beginning, with 40 more points
+            // after it. The old code truncated to 3 points; it must not now.
+            const coords = longTrailStartingWithAB(40);
+            const endPoint = { lat: 0, lon: 0.0004 }; // mid-edge on A-B, ~44m from A
+            const snap = { lat: 0.0, lon: 0.0004, ...uv };
+
+            const result = applyEndpointSnap(coords, endPoint, snap, A, B);
+
+            expect(result.length).toBe(coords.length); // untouched — real end lies elsewhere
+        });
+
+        test('still truncates when the snap edge is genuinely at the end of a short route', () => {
+            const coords = [A, B]; // A-B is the entire (short) route
+            const endPoint = { lat: 0, lon: 0.0004 };
+            const snap = { lat: 0.0, lon: 0.0004, ...uv };
+
+            const result = applyEndpointSnap(coords, endPoint, snap, A, B);
+
+            const last = result[result.length - 1];
+            expect(last.lat).toBeCloseTo(endPoint.lat, 9);
+            expect(last.lon).toBeCloseTo(endPoint.lon, 9);
+        });
+
+        test('still truncates when the snap edge is the last edge of a long route', () => {
+            const tail = longTrailStartingWithAB(40);
+            // Put A-B at the very end instead of the start.
+            const coords = [...tail.slice(2), A, B];
+            const endPoint = { lat: 0, lon: 0.0004 };
+            const snap = { lat: 0.0, lon: 0.0004, ...uv };
+
+            const result = applyEndpointSnap(coords, endPoint, snap, A, B);
+
+            const last = result[result.length - 1];
+            expect(last.lat).toBeCloseTo(endPoint.lat, 9);
+            expect(last.lon).toBeCloseTo(endPoint.lon, 9);
+        });
+
+        test('leaves coords untouched when the click is effectively at an intersection, not mid-edge', () => {
+            const coords = longTrailStartingWithAB(10);
+            const endPoint = { lat: 0, lon: 0.0000001 }; // right on node A
+            const snap = { lat: 0, lon: 0.0000001, ...uv };
+
+            const result = applyEndpointSnap(coords, endPoint, snap, A, B);
+
+            expect(result).toBe(coords);
+        });
+    });
+
     test('mixed mode (manualRoute + selectionBox) produces open path ending at far corner, not back at entry', () => {
         // 3x3 grid — approach from outside the NW corner, selection box covers all 9 nodes.
         // NW=1(0.002,0) - 2(0.002,0.001) - NE=3(0.002,0.002)

lib/graph.ts

@@ -5,6 +5,7 @@ import path from 'ngraph.path';
 
 import { OSMWay, OSMNode, OverpassResponse } from './types';
 import { isRoutableHighway } from './highwayFilter';
+import { haversineM } from './geometry';
 
 interface NodeData {
     lat: number;
@@ -131,6 +132,63 @@ export function pointNearOrInAnyPolygon(point: [number, number], polygons: [numb
     return polygons.some(polygon => pointNearOrInPolygon(point, polygon, bufferMeters));
 }
 
+// Projects a mid-edge endpoint click onto its closest edge and trims/extends
+// the trail's coords so the route ends exactly at that point.
+//
+// The Eulerian circuit's traversal order isn't dictated by click order — with
+// a long/complex route, a street shared with an earlier segment (e.g. the
+// endpoint clicked near the route's own start, a normal way to close a loop)
+// can appear only once, and much earlier than the real end. Truncating there
+// would silently discard the rest of the route down to just a handful of
+// points, so a match is only trusted as the true terminus when it's actually
+// near the tail.
+export function applyEndpointSnap(
+    coords: { lat: number; lon: number; hasConstruction?: boolean }[],
+    endPoint: { lat: number; lon: number },
+    snap: { lat: number; lon: number; u: string; v: string },
+    uCoord: { lat: number; lon: number },
+    vCoord: { lat: number; lon: number },
+): { lat: number; lon: number; hasConstruction?: boolean }[] {
+    const distToSnap = haversineM(endPoint.lat, endPoint.lon, snap.lat, snap.lon);
+    const distToU = haversineM(endPoint.lat, endPoint.lon, uCoord.lat, uCoord.lon);
+    const distToV = haversineM(endPoint.lat, endPoint.lon, vCoord.lat, vCoord.lon);
+    const minNodeDist = Math.min(distToU, distToV);
+
+    // Only truncate when the click is genuinely mid-edge, not just slightly
+    // off an intersection due to map rounding. ~5m gap between node and edge snap.
+    const NODE_THRESHOLD_M = 5;
+    if (minNodeDist - distToSnap <= NODE_THRESHOLD_M) return coords;
+
+    const eq = (a: number, b: number) => Math.abs(a - b) < 1e-9;
+    const isU = (c: { lat: number, lon: number }) => eq(c.lat, uCoord.lat) && eq(c.lon, uCoord.lon);
+    const isV = (c: { lat: number, lon: number }) => eq(c.lat, vCoord.lat) && eq(c.lon, vCoord.lon);
+
+    // Find the last time the route traversed the snap edge.
+    let lastIdx = -1;
+    for (let i = 0; i < coords.length - 1; i++) {
+        const a = coords[i], b = coords[i + 1];
+        if ((isU(a) && isV(b)) || (isV(a) && isU(b))) lastIdx = i;
+    }
+
+    const NEAR_END_FRACTION = 0.1;
+    const allowedFromEnd = Math.max(5, Math.ceil(coords.length * NEAR_END_FRACTION));
+    const isNearEnd = lastIdx !== -1 && (coords.length - 1 - lastIdx) <= allowedFromEnd;
+    if (isNearEnd) {
+        // Truncate at the snap point during that traversal.
+        return [...coords.slice(0, lastIdx + 1), { lat: snap.lat, lon: snap.lon }];
+    }
+
+    // The snap edge either wasn't traversed, or only appeared far from the
+    // end. If the trail's final node is one of the snap edge's endpoints,
+    // extend along that edge to the snap point; otherwise leave coords as-is
+    // rather than risk discarding most of the route.
+    const last = coords[coords.length - 1];
+    if (isU(last) || isV(last)) {
+        return [...coords, { lat: snap.lat, lon: snap.lon }];
+    }
+    return coords;
+}
+
 // The entry bridge (approach → area sweep, mixed mode) carries no coverage
 // guarantee — only the area's own CPP-solved path does. So any edge the
 // bridge shares with the path's own leading edges is pure redundant mileage:
@@ -2084,42 +2142,7 @@ export class StreetGraph {
                     const uNode = this.graph.getNode(snap.u);
                     const vNode = this.graph.getNode(snap.v);
                     if (uNode && vNode) {
-                        const distToSnap = this.haversine(endPoint.lat, endPoint.lon, snap.lat, snap.lon);
-                        const distToU = this.haversine(endPoint.lat, endPoint.lon, uNode.data.lat, uNode.data.lon);
-                        const distToV = this.haversine(endPoint.lat, endPoint.lon, vNode.data.lat, vNode.data.lon);
-                        const minNodeDist = Math.min(distToU, distToV);
-
-                        // Only truncate when the click is genuinely mid-edge,
-                        // not just slightly off an intersection due to map
-                        // rounding. ~5m gap between node and edge snap.
-                        const NODE_THRESHOLD_M = 5;
-                        if (minNodeDist - distToSnap > NODE_THRESHOLD_M) {
-                            const eq = (a: number, b: number) => Math.abs(a - b) < 1e-9;
-                            const isU = (c: { lat: number, lon: number }) =>
-                                eq(c.lat, uNode.data.lat) && eq(c.lon, uNode.data.lon);
-                            const isV = (c: { lat: number, lon: number }) =>
-                                eq(c.lat, vNode.data.lat) && eq(c.lon, vNode.data.lon);
-
-                            // Find the last time the route traversed the snap edge.
-                            let lastIdx = -1;
-                            for (let i = 0; i < coords.length - 1; i++) {
-                                const a = coords[i], b = coords[i + 1];
-                                if ((isU(a) && isV(b)) || (isV(a) && isU(b))) lastIdx = i;
-                            }
-
-                            if (lastIdx !== -1) {
-                                // Truncate at the snap point during that traversal.
-                                return [...coords.slice(0, lastIdx + 1), { lat: snap.lat, lon: snap.lon }];
-                            }
-
-                            // The snap edge was not traversed. If the trail's
-                            // final node is one of the snap edge's endpoints,
-                            // extend along that edge to the snap point.
-                            const last = coords[coords.length - 1];
-                            if (isU(last) || isV(last)) {
-                                coords.push({ lat: snap.lat, lon: snap.lon });
-                            }
-                        }
+                        return applyEndpointSnap(coords, endPoint, snap, uNode.data, vNode.data);
                     }
                 }
             }

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "street-sweep",
-  "version": "0.6.50",
+  "version": "0.6.51",
   "private": true,
   "scripts": {
     "dev": "next dev -p 3888",