fix: mixed-mode area exit targets the real next waypoint, not an arbitrary geometric corner (#64)

The coverage trail's chosen endpoint always used the "farthest box/
lasso corner from the approach start" — even when the caller already
knows the real destination (a subsequent manual waypoint / exitRoute).
Picking a geometrically arbitrary corner that has no relation to
where the route is actually headed forces the exit bridge to travel
further than necessary, increasing the chance it retraces the
coverage trail's own tail. Now targets the real next waypoint
directly when one exists, falling back to the geometric-corner
heuristic only for a one-shot sweep with no known destination.

Caveat: a synthetic 2-odd-node test topology couldn't discriminate
old vs new behavior (both converge to the same trail when there are
only two candidate natural endpoints) — validated by code review and
the full suite instead. Needs live confirmation on a real dense-grid
case.

Author: chadbeaudin

lib/graph.test.ts

@@ -432,6 +432,50 @@ describe('StreetGraph', () => {
         }
     });
 
+    test('#64 (exit side): mixed-mode area targets a real subsequent waypoint instead of an arbitrary geometric corner', () => {
+        // Grid:  A(0,0) - B(0,0.001) - C(0,0.002)
+        //         |            |            |
+        //        D(0.001,0)-E(0.001,0.001)-F(0.001,0.002)
+        // B and E are the only natural odd-degree (3) nodes. Approach enters near A
+        // (top-left). The real 2nd waypoint (endPoint) sits right next to B — the
+        // OPPOSITE side of the grid from the geometric far corner (near F/C), which
+        // the old code would've blindly targeted regardless of where the route
+        // actually needs to go next.
+        const mockData: OverpassResponse = {
+            version: 0.6,
+            generator: 'test',
+            osm3s: { timestamp_osm_base: '', copyright: '' },
+            elements: [
+                { type: 'node', id: 1, lat: 0, lon: 0 },        // A
+                { type: 'node', id: 2, lat: 0, lon: 0.001 },    // B — odd
+                { type: 'node', id: 3, lat: 0, lon: 0.002 },    // C
+                { type: 'node', id: 4, lat: 0.001, lon: 0 },     // D
+                { type: 'node', id: 5, lat: 0.001, lon: 0.001 }, // E — odd
+                { type: 'node', id: 6, lat: 0.001, lon: 0.002 }, // F
+                { type: 'way', id: 100, nodes: [1, 2, 3], tags: { highway: 'residential' } },
+                { type: 'way', id: 101, nodes: [4, 5, 6], tags: { highway: 'residential' } },
+                { type: 'way', id: 102, nodes: [1, 4], tags: { highway: 'residential' } },
+                { type: 'way', id: 103, nodes: [2, 5], tags: { highway: 'residential' } },
+                { type: 'way', id: 104, nodes: [3, 6], tags: { highway: 'residential' } },
+            ]
+        };
+
+        graph.buildFromOSM(mockData);
+
+        const manualRoute: [number, number][] = [[-0.001, 0], [0, 0]]; // approach arrives at A
+        const selectionBoxes = [{ north: 0.0011, south: -0.0001, east: 0.0021, west: -0.0001 }];
+        const realExitTarget = { lat: 0.0001, lon: 0.001 }; // right next to B
+
+        const result = graph.solveCPP(undefined, realExitTarget, manualRoute, selectionBoxes);
+
+        // The route should end near the real exit target (B), not the geometric far
+        // corner on the opposite side of the grid (near C/F).
+        const end = result[result.length - 1];
+        const distToB = Math.hypot(end.lat - 0, end.lon - 0.001);
+        const distToFarCorner = Math.hypot(end.lat - 0.0011, end.lon - 0.0021);
+        expect(distToB).toBeLessThan(distToFarCorner);
+    });
+
     describe('trimBridgeOverlap', () => {
         const p = (lat: number, lon: number) => ({ lat, lon });
 

lib/graph.ts

@@ -1172,26 +1172,42 @@ export class StreetGraph {
             // approach→post-area segment would otherwise route around the area instead of through it.
             const approachStart = startPoint ?? { lat: manualRoute[0][1], lon: manualRoute[0][0] };
 
-            // Find the corner of the selection area farthest from approachStart.
-            // Passing it as endPoint forces the CPP to produce an open Euler path
-            // (entry → cover all streets → far corner) instead of a circuit.
-            // Consider both box corners and polygon (lasso) vertices so lasso areas
-            // get the same open-path treatment as boxes.
-            const areaCorners: { lat: number; lon: number }[] = [];
-            for (const box of (selectionBoxes ?? [])) {
-                areaCorners.push(
-                    { lat: box.north, lon: box.west }, { lat: box.north, lon: box.east },
-                    { lat: box.south, lon: box.west }, { lat: box.south, lon: box.east },
-                );
-            }
-            for (const poly of (selectionPolygons ?? [])) {
-                for (const [lat, lon] of poly) areaCorners.push({ lat, lon });
-            }
-            let farCorner = { lat: 0, lon: 0 };
-            let maxCornerDist = -Infinity;
-            for (const c of areaCorners) {
-                const d = this.haversine(approachStart.lat, approachStart.lon, c.lat, c.lon);
-                if (d > maxCornerDist) { maxCornerDist = d; farCorner = c; }
+            // If the caller already knows where the route goes after the area (a real
+            // subsequent waypoint / exitRoute, or an explicit endPoint), target the
+            // coverage trail's end AT that real destination instead of an arbitrary
+            // geometric corner — this directly minimizes the exit bridge's distance
+            // (and thus its risk of retracing the trail's own tail, see #64). Only
+            // fall back to the "farthest corner from approach" heuristic when there's
+            // no real destination to aim for (a one-shot sweep that ends wherever).
+            const realExitTarget = (exitRoute && exitRoute.length > 0)
+                ? { lat: exitRoute[0][1], lon: exitRoute[0][0] }
+                : endPoint;
+
+            let farCorner: { lat: number; lon: number };
+            if (realExitTarget) {
+                farCorner = realExitTarget;
+            } else {
+                // Find the corner of the selection area farthest from approachStart.
+                // Passing it as endPoint forces the CPP to produce an open Euler path
+                // (entry → cover all streets → far corner) instead of a circuit.
+                // Consider both box corners and polygon (lasso) vertices so lasso areas
+                // get the same open-path treatment as boxes.
+                const areaCorners: { lat: number; lon: number }[] = [];
+                for (const box of (selectionBoxes ?? [])) {
+                    areaCorners.push(
+                        { lat: box.north, lon: box.west }, { lat: box.north, lon: box.east },
+                        { lat: box.south, lon: box.west }, { lat: box.south, lon: box.east },
+                    );
+                }
+                for (const poly of (selectionPolygons ?? [])) {
+                    for (const [lat, lon] of poly) areaCorners.push({ lat, lon });
+                }
+                farCorner = { lat: 0, lon: 0 };
+                let maxCornerDist = -Infinity;
+                for (const c of areaCorners) {
+                    const d = this.haversine(approachStart.lat, approachStart.lon, c.lat, c.lon);
+                    if (d > maxCornerDist) { maxCornerDist = d; farCorner = c; }
+                }
             }
 
             let areaPath = this.solveCPP(approachStart, farCorner, undefined, selectionBoxes, undefined, undefined, false, riddenPenalty, selectionPolygons, boxElasticityMeters, true);

package-lock.json

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