@woosh/meep-engine 3.64.1 → 3.65.0

package/src/core/geom/3d/topology/struct/binary/query/bt_mesh_face_find_path_polyanya.js

@@ -29,8 +29,11 @@ import { NULL_POINTER } from "../BinaryTopology.js";
  * by UNFOLDING. Each node carries the 2D positions of its entry edge in a frame accumulated along its
  * own corridor; expanding a node flattens the next triangle into that frame by placing the apex from the
  * two 3D edge lengths |edge-vertex .. apex| (an isometry of the triangle), on the side fixed by the
- * face's winding. So distances in the frame are true geodesic distances and the cost `g` is exact on a
- * curved/folded surface, not just a planar one. Turning corners are detected from the 3D incident-angle
+ * face's winding. So distances in the frame are true distances along the corridor, and the result is
+ * exact wherever the surface unfolds flat -- a floor, a ramp, a fold along mesh edges -- not just in one
+ * plane. Where it does not (a hill), the result is a path on the surface but not always the shortest,
+ * and ground behind a saddle vertex can go unreached: paths turn at boundary corners only. Every face
+ * must be wound the same way round the surface. Turning corners are detected from the 3D incident-angle
  * sum (also intrinsic). The goal has no fixed position across frames, so the A* heuristic is the exact
  * shortest root->interval->goal measured with straight 3D chords (a lower bound on the geodesic, hence
  * admissible); the terminal node's *exact* cost unfolds the goal into the node's frame instead.
@@ -45,7 +48,6 @@ import { NULL_POINTER } from "../BinaryTopology.js";
  */
 
 const EPS = 1e-9;            // area-sign slack (cone inside/outside tests)
-const COLLINEAR_EPS = 1e-4;  // drop a path point whose perpendicular offset from its neighbours / span is below this
 
 /**
  * Relative spacing between adjacent float32 values: an axis holding `a` rounds by up to `|a| * FLOAT32_STEP`.
@@ -79,13 +81,33 @@ function dedup_tolerance_sqr(x, y, z) {
     return (x * x + y * y + z * z) * FLOAT32_STEP_SQR;
 }
 
-// Parameter-space tolerance for edge fractions, interval coverage and vertex snapping. Vertices are
-// stored as float32, so a point that is geometrically on an edge endpoint or already-covered carries
-// ~coord*2^-23 quantization noise in its edge fraction -- far above 1e-9. Tolerating less re-covers the
-// same edge stretches as slivers and the wavefront floods without converging. 1e-4 covers coordinates
-// into the thousands while staying far below any real feature size, and never moves a waypoint (corners
-// are exact vertex positions).
-const PEPS = 1e-4;
+/**
+ * Relative spacing between adjacent float64 values -- what the unfolded frame is kept in.
+ * @readonly
+ * @type {number}
+ */
+const FLOAT64_STEP = 2 ** -52;
+
+/**
+ * Parameter-space tolerance: two fractions of an edge closer than this are one fraction. It decides
+ * whether a cone's ray passes through the end of a far edge or splits the edge, which stretches are too
+ * narrow to become a node, and when two covered stretches touch.
+ *
+ * It is held between two things that both scale with a face's aspect A (its length over its altitude),
+ * in opposite directions. Rounding in the frame reaches an edge fraction multiplied by about A, so the
+ * tolerance must stay above FLOAT64_STEP * A, or noise splits an edge a hair from its end and the
+ * stretch that should end on a corner no longer does. And a turn of angle theta round a corner appears
+ * on the first edge past it as a stretch of only tan(theta) / A, so the tolerance must stay below that,
+ * or the turn is dropped -- and with it everything that is reached only round that corner. The widest
+ * range of A that satisfies both belongs to the tolerance midway between them, the square root of the
+ * step: it serves faces up to 2^26 times longer than they are thin, where float32 vertices cannot
+ * describe one beyond 2^24. What it still drops is a turn shallower than PEPS * A.
+ *
+ * It never moves a waypoint (corners are exact vertex positions).
+ * @readonly
+ * @type {number}
+ */
+const PEPS = Math.sqrt(FLOAT64_STEP);
 
 // ---- 2D primitives in the unfolded frame -----------------------------------------------------------
 
@@ -171,7 +193,13 @@ function unfold_apex(topology, face, e0v, e1v, e0x, e0y, e1x, e1y) {
     return apex;
 }
 
-/** Barycentric weights (for va,vb,vc, in order) of a 3D point projected onto their plane, into `out`. */
+/**
+ * Barycentric weights (for va,vb,vc, in order) of a 3D point projected onto their plane, into `out`.
+ *
+ * Taken as ratios of cross products against the face normal, whose error grows with the face's aspect.
+ * (Solving the two dot-product equations for them squares it: a face 9 long and 10 microns thin placed
+ * its point a millimetre out.)
+ */
 function barycentric_3d(topology, va, vb, vc, px, py, pz, out) {
     topology.vertex_read_coordinate(_va, 0, va);
     topology.vertex_read_coordinate(_vb, 0, vb);
@@ -179,11 +207,12 @@ function barycentric_3d(topology, va, vb, vc, px, py, pz, out) {
     const e0x = _vb[0] - _va[0], e0y = _vb[1] - _va[1], e0z = _vb[2] - _va[2];
     const e1x = _vc[0] - _va[0], e1y = _vc[1] - _va[1], e1z = _vc[2] - _va[2];
     const v2x = px - _va[0], v2y = py - _va[1], v2z = pz - _va[2];
-    const d00 = e0x * e0x + e0y * e0y + e0z * e0z, d01 = e0x * e1x + e0y * e1y + e0z * e1z, d11 = e1x * e1x + e1y * e1y + e1z * e1z;
-    const d20 = v2x * e0x + v2y * e0y + v2z * e0z, d21 = v2x * e1x + v2y * e1y + v2z * e1z;
-    const denom = d00 * d11 - d01 * d01;
-    if (Math.abs(denom) < 1e-18) { out[0] = 1; out[1] = 0; out[2] = 0; return; }
-    const v = (d11 * d20 - d01 * d21) / denom, w = (d00 * d21 - d01 * d20) / denom;
+    // n = e0 x e1; then (p - a) x e1 = v * n and e0 x (p - a) = w * n
+    const nx = e0y * e1z - e0z * e1y, ny = e0z * e1x - e0x * e1z, nz = e0x * e1y - e0y * e1x;
+    const nn = nx * nx + ny * ny + nz * nz;
+    if (nn === 0) { out[0] = 1; out[1] = 0; out[2] = 0; return; } // no area at all: any corner will do
+    const v = ((v2y * e1z - v2z * e1y) * nx + (v2z * e1x - v2x * e1z) * ny + (v2x * e1y - v2y * e1x) * nz) / nn;
+    const w = ((e0y * v2z - e0z * v2y) * nx + (e0z * v2x - e0x * v2z) * ny + (e0x * v2y - e0y * v2x) * nz) / nn;
     out[0] = 1 - v - w; out[1] = v; out[2] = w;
 }
 
@@ -248,8 +277,8 @@ function is_corner(topology, vid) {
 
 // ---- node storage ----------------------------------------------------------------------------------
 
-// Search nodes are fixed 16-word records packed into one flat ArrayBuffer, addressed by id*NODE_WORDS,
-// so the open list is a Uint32Heap4 (id + score) rather than an object heap -- NO per-node object
+// Search nodes are fixed 104-byte records packed into one flat ArrayBuffer, addressed by id, so the
+// open list is a Uint32Heap4 (id + score) rather than an object heap -- NO per-node object
 // allocation, so the hot path produces no garbage and never triggers a GC pause (which would otherwise
 // jitter the rest of the engine). Allocation is a monotonic bump counter reset per query; nodes are
 // never released mid-query, so there is no free list and no occupancy bookkeeping. The buffer only ever
@@ -257,25 +286,35 @@ function is_corner(topology, vid) {
 // after a grow. (A pooled allocator with a free list + occupancy bitset degenerates to exactly this
 // under a never-free, bump-allocated access pattern, so a raw buffer is the honest, lighter shape.)
 //
+// A record is 13 float64 words. The first three are read as six uint32 fields (N_*, at
+// id*NODE_U32 + field); the other ten are float64 fields (F_*, at id*NODE_F64 + field).
+//
 // A node stores its entry edge as vertex ids (E0V,E1V) AND its 2D positions in the node's unfolded frame
 // (E0X,E0Y,E1X,E1Y), the root (ROOTVID + RX,RY in the frame; ROOTVID==NULL_ID is the start point), and
 // the interval as the fractions [T0,T1] along the edge. 3D is recovered at reconstruction from vertex
-// ids; a terminal node stores the goal edge (E0V,E1V) and the final bend's fraction along it (N_FCT,
+// ids; a terminal node stores the goal edge (E0V,E1V) and the final bend's fraction along it (F_FCT,
 // -1 == a straight shot, since a real bend fraction is in [0,1]).
+//
+// The frame is float64 because unfolding multiplies whatever it is off by: an apex of altitude h over
+// an entry edge of length L moves by L/h times the error in that edge's frame position, once for every
+// face the corridor crosses. A frame kept at the vertices' own float32 resolution therefore places the
+// apex of a face thinner than sqrt(L * that resolution) on the wrong side of its entry edge.
 const N_FACE = 0, N_E0V = 1, N_E1V = 2;
-const N_E0X = 3, N_E0Y = 4, N_E1X = 5, N_E1Y = 6;
-const N_ROOTVID = 7, N_RX = 8, N_RY = 9;
-const N_T0 = 10, N_T1 = 11;
-const N_G = 12, N_PARENT = 13, N_TERMINAL = 14, N_FCT = 15;
-const NODE_WORDS = 16;
+const N_ROOTVID = 3, N_PARENT = 4, N_TERMINAL = 5;
+const F_E0X = 3, F_E0Y = 4, F_E1X = 5, F_E1Y = 6;
+const F_RX = 7, F_RY = 8;
+const F_T0 = 9, F_T1 = 10;
+const F_G = 11, F_FCT = 12;
+const NODE_F64 = 13;
+const NODE_U32 = NODE_F64 * 2;
 const NULL_ID = 0xFFFFFFFF;
 
 const _open = new Uint32Heap4();
 
-// node records: uint32 and float32 views overlaid on one ArrayBuffer (_node_df aliases _node_du's bytes)
+// node records: float64 and uint32 views overlaid on one ArrayBuffer (_node_du aliases _node_df's bytes)
 let _node_capacity = 1024;                            // capacity in nodes; grows by doubling
-let _node_du = new Uint32Array(_node_capacity * NODE_WORDS);
-let _node_df = new Float32Array(_node_du.buffer);
+let _node_df = new Float64Array(_node_capacity * NODE_F64);
+let _node_du = new Uint32Array(_node_df.buffer);
 let _node_count = 0;
 
 /** Reserve the next node slot, growing (and re-caching the views) only when the buffer is full. */
@@ -283,14 +322,15 @@ function alloc_node() {
     const id = _node_count++;
     if (id >= _node_capacity) {
         _node_capacity *= 2;
-        const grown = new Uint32Array(_node_capacity * NODE_WORDS);
+        const grown = new Uint32Array(_node_capacity * NODE_U32);
         grown.set(_node_du); // copy the existing records into the larger buffer
         _node_du = grown;
-        _node_df = new Float32Array(grown.buffer);
+        _node_df = new Float64Array(grown.buffer);
     }
     return id;
 }
 
+
 // the start/goal 3D points (for the heuristic and for lifting the path back to 3D)
 let _sx = 0, _sy = 0, _sz = 0;
 let _gx = 0, _gy = 0, _gz = 0;
@@ -368,7 +408,7 @@ export function bt_mesh_face_find_path_polyanya(output, topology, sx, sy, sz, st
     let guard = 0;
     while (!_open.is_empty()) {
         const id = _open.pop_min();
-        if (_node_du[id * NODE_WORDS + N_TERMINAL] === 1) { best = id; break; }
+        if (_node_du[id * NODE_U32 + N_TERMINAL] === 1) { best = id; break; }
         if (++guard > 5_000_000) break;
         expand(topology, id, goal_face);
     }
@@ -382,26 +422,26 @@ export function bt_mesh_face_find_path_polyanya(output, topology, sx, sy, sz, st
     // its 3D edge keeps every output segment inside one face (i.e. on the surface). Crossings that fall on
     // a straight (flat) stretch collapse away in push_point, so flat meshes still yield minimal paths.
     const du = _node_du, df = _node_df;
-    const bb = best * NODE_WORDS;
+    const bu = best * NODE_U32, bf = best * NODE_F64;
 
     // the goal's position in the shared frame: unfold the goal-face apex from the terminal's entry edge
-    const t_e0v = du[bb + N_E0V], t_e1v = du[bb + N_E1V];
-    const t_e0x = df[bb + N_E0X], t_e0y = df[bb + N_E0Y], t_e1x = df[bb + N_E1X], t_e1y = df[bb + N_E1Y];
+    const t_e0v = du[bu + N_E0V], t_e1v = du[bu + N_E1V];
+    const t_e0x = df[bf + F_E0X], t_e0y = df[bf + F_E0Y], t_e1x = df[bf + F_E1X], t_e1y = df[bf + F_E1Y];
     const g_apex = unfold_apex(topology, goal_face, t_e0v, t_e1v, t_e0x, t_e0y, t_e1x, t_e1y);
     const goal_u = goal_weight(t_e0v) * t_e0x + goal_weight(t_e1v) * t_e1x + goal_weight(g_apex) * _apex[0];
     const goal_v = goal_weight(t_e0v) * t_e0y + goal_weight(t_e1v) * t_e1y + goal_weight(g_apex) * _apex[1];
-    const t_fct = df[bb + N_FCT];
+    const t_fct = df[bf + F_FCT];
 
     // walk the chain (goal end -> start), recording each entry-edge crossing in reverse path order
     _recon.length = 0;
     let next_u = goal_u, next_v = goal_v;     // the next waypoint toward the goal, in the shared frame
-    let prev_root = du[bb + N_ROOTVID];
-    let prev_rx = df[bb + N_RX], prev_ry = df[bb + N_RY];
+    let prev_root = du[bu + N_ROOTVID];
+    let prev_rx = df[bf + F_RX], prev_ry = df[bf + F_RY];
 
-    for (let n = best; n !== NULL_ID; n = du[n * NODE_WORDS + N_PARENT]) {
-        const base = n * NODE_WORDS;
-        const rootVid = du[base + N_ROOTVID];
-        const rx = df[base + N_RX], ry = df[base + N_RY];
+    for (let n = best; n !== NULL_ID; n = du[n * NODE_U32 + N_PARENT]) {
+        const base_u = n * NODE_U32, base_f = n * NODE_F64;
+        const rootVid = du[base_u + N_ROOTVID];
+        const rx = df[base_f + F_RX], ry = df[base_f + F_RY];
 
         // a change of root means the route turned at the previous corridor's root: emit that corner
         // (an exact mesh vertex -- the turning point) and aim subsequent crossings at it
@@ -414,23 +454,37 @@ export function bt_mesh_face_find_path_polyanya(output, topology, sx, sy, sz, st
             prev_root = rootVid;
         }
 
-        const e0v = du[base + N_E0V], e1v = du[base + N_E1V];
-        const e0x = df[base + N_E0X], e0y = df[base + N_E0Y], e1x = df[base + N_E1X], e1y = df[base + N_E1Y];
+        const e0v = du[base_u + N_E0V], e1v = du[base_u + N_E1V];
+        const e0x = df[base_f + F_E0X], e0y = df[base_f + F_E0Y], e1x = df[base_f + F_E1X], e1y = df[base_f + F_E1Y];
 
         // fraction along the entry edge where the route root->next crosses it (the terminal's goal-edge
-        // bend is exact and pre-computed as N_FCT)
+        // bend is exact and pre-computed as F_FCT)
         let u;
         if (n === best && t_fct !== -1) {
             u = t_fct;
+
+            // the route turns here, on the goal edge: what comes before heads for this bend, not the goal
+            next_u = e0x + (e1x - e0x) * u;
+            next_v = e0y + (e1y - e0y) * u;
         } else {
             u = line2_segment_intersection_fraction_2d(rx, ry, next_u, next_v, e0x, e0y, e1x, e1y);
             if (u === -1) {
-                // the route line grazes a shared vertex (passes through / just outside an edge endpoint,
-                // common when the geodesic runs along a row of grid vertices): snap to the nearer endpoint
                 const dx = next_u - rx, dy = next_v - ry;
-                const s0 = Math.abs(dx * (e0y - ry) - dy * (e0x - rx));
-                const s1 = Math.abs(dx * (e1y - ry) - dy * (e1x - rx));
-                u = s0 <= s1 ? 0 : 1;
+                if (dx === 0 && dy === 0) {
+                    // the root already stands where the route is headed (a start or goal placed on a
+                    // mesh vertex), so there is no line to cross the edge with: the root is at one of
+                    // the edge's ends, and that end is the crossing
+                    const d0 = (e0x - rx) * (e0x - rx) + (e0y - ry) * (e0y - ry);
+                    const d1 = (e1x - rx) * (e1x - rx) + (e1y - ry) * (e1y - ry);
+                    u = d0 <= d1 ? 0 : 1;
+                } else {
+                    // the route line grazes a shared vertex (passes through / just outside an edge
+                    // endpoint, common when the geodesic runs along a row of grid vertices): snap to the
+                    // nearer endpoint
+                    const s0 = Math.abs(dx * (e0y - ry) - dy * (e0x - rx));
+                    const s1 = Math.abs(dx * (e1y - ry) - dy * (e1x - rx));
+                    u = s0 <= s1 ? 0 : 1;
+                }
             }
         }
 
@@ -465,8 +519,11 @@ export function bt_mesh_face_find_path_polyanya(output, topology, sx, sy, sz, st
  * Append a 3D point, dropping it when it says nothing new:
  *
  * - it repeats the previous point, to within that position's storage resolution ({@link dedup_tolerance_sqr});
- * - or the previous point lies (within {@link COLLINEAR_EPS}) on the segment between the one before it
- *   and the new point, so it is a redundant middle of a straight run.
+ * - or the previous point is the redundant middle of a straight run: it lies on the line through the one
+ *   before it and the new point, as nearly as float32 storage can tell. Each of the three is only known
+ *   to its own storage step, so the middle one is on the line when it is within the largest of those
+ *   steps of it. Nothing coarser will do: a bend round a corner that a thin face makes a few microns
+ *   deep is still a bend, and a path that skips it passes through the obstacle.
  *
  * Either way the previous slot is overwritten rather than kept, so of two renditions of one place it is
  * the newer that survives -- which keeps the path ending on the caller's goal verbatim rather than on the
@@ -485,8 +542,11 @@ function push_point(output, count, x, y, z) {
             const abx = bx - ax, aby = by - ay, abz = bz - az;
             const acx = x - ax, acy = y - ay, acz = z - az;
             const cross_x = aby * acz - abz * acy, cross_y = abz * acx - abx * acz, cross_z = abx * acy - aby * acx;
-            const ac_len = Math.hypot(acx, acy, acz);
-            if (same_place || Math.hypot(cross_x, cross_y, cross_z) <= COLLINEAR_EPS * ac_len) {
+            // |ab x ac|^2 = |ac|^2 * (distance of b from the line through a and c)^2
+            const cross_sqr = cross_x * cross_x + cross_y * cross_y + cross_z * cross_z;
+            const ac_sqr = acx * acx + acy * acy + acz * acz;
+            const step_sqr = Math.max(dedup_tolerance_sqr(ax, ay, az), dedup_tolerance_sqr(bx, by, bz), dedup_tolerance_sqr(x, y, z));
+            if (same_place || cross_sqr <= ac_sqr * step_sqr) {
                 output[count - 3] = x; output[count - 2] = y; output[count - 1] = z;
                 return count;
             }
@@ -505,24 +565,24 @@ function start_edge(topology, su, sv, start_face, ea, eb, eax, eay, ebx, eby, go
 
 function expand(topology, id, goal_face) {
     const du = _node_du, df = _node_df;
-    const base = id * NODE_WORDS;
-
-    const face = du[base + N_FACE];
-    const e0v = du[base + N_E0V], e1v = du[base + N_E1V];
-    const e0x = df[base + N_E0X], e0y = df[base + N_E0Y];
-    const e1x = df[base + N_E1X], e1y = df[base + N_E1Y];
-    const rv = du[base + N_ROOTVID]; const rootVid = rv === NULL_ID ? -1 : rv;
-    const rx = df[base + N_RX], ry = df[base + N_RY];
-    const t0 = df[base + N_T0], t1 = df[base + N_T1];
-    const g = df[base + N_G];
-
-    // interval endpoints + their edge vertex ids, ordered so i1 is left of the ray root->i0
-    let i0x = e0x + t0 * (e1x - e0x), i0y = e0y + t0 * (e1y - e0y), i0v = t0 <= PEPS ? e0v : (t0 >= 1 - PEPS ? e1v : -1);
-    let i1x = e0x + t1 * (e1x - e0x), i1y = e0y + t1 * (e1y - e0y), i1v = t1 <= PEPS ? e0v : (t1 >= 1 - PEPS ? e1v : -1);
-    if (tri2_signed_area(rx, ry, i0x, i0y, i1x, i1y) < 0) {
-        const sxx = i0x, syy = i0y, svv = i0v;
-        i0x = i1x; i0y = i1y; i0v = i1v; i1x = sxx; i1y = syy; i1v = svv;
-    }
+    const base_u = id * NODE_U32, base_f = id * NODE_F64;
+
+    const face = du[base_u + N_FACE];
+    const e0v = du[base_u + N_E0V], e1v = du[base_u + N_E1V];
+    const e0x = df[base_f + F_E0X], e0y = df[base_f + F_E0Y];
+    const e1x = df[base_f + F_E1X], e1y = df[base_f + F_E1Y];
+    const rv = du[base_u + N_ROOTVID]; const rootVid = rv === NULL_ID ? -1 : rv;
+    const rx = df[base_f + F_RX], ry = df[base_f + F_RY];
+    const t0 = df[base_f + F_T0], t1 = df[base_f + F_T1];
+    const g = df[base_f + F_G];
+
+    // Interval endpoints + their edge vertex ids. i0, the end nearer e0, is the cone's right ray and i1
+    // its left: the entry edge runs e0 -> e1 with the entered face on its right and the root on its left
+    // or on its line, which is how every node is built (see add_successor). The order is never read back
+    // off the root's position -- a root that has just turned at e0 or e1 lies ON the edge, where the cone
+    // has no area and so no sign to read.
+    const i0x = e0x + t0 * (e1x - e0x), i0y = e0y + t0 * (e1y - e0y), i0v = t0 <= PEPS ? e0v : (t0 >= 1 - PEPS ? e1v : -1);
+    const i1x = e0x + t1 * (e1x - e0x), i1y = e0y + t1 * (e1y - e0y), i1v = t1 <= PEPS ? e0v : (t1 >= 1 - PEPS ? e1v : -1);
 
     // unfold the apex into this node's frame, giving the two far edges (e0v,apex) and (apex,e1v)
     const apex = unfold_apex(topology, face, e0v, e1v, e0x, e0y, e1x, e1y);
@@ -570,15 +630,29 @@ function process_far_edge(topology, from_face, Pv, Px, Py, Qv, Qx, Qy, rx, ry, r
 }
 
 /**
- * Per (entered edge, root) interval coverage. A fixed root implies a fixed g, so the first node to
- * cover a stretch of an edge is optimal there -- later nodes are clipped to the still-uncovered part
- * (or dropped). This is what makes the wavefront terminate instead of re-flooding the same edges.
+ * Per (entered edge, root) interval coverage: which arrival holds each stretch of the edge.
+ *
+ * Nodes that share a root reach a stretch of an edge along the same lines from that root, so they
+ * differ only in what reaching the root cost them. The cheapest to arrive holds the stretch, and one
+ * that cost the same finds it taken. A node is clipped to what it does not find held at its own cost or
+ * less -- which is what makes the wavefront terminate instead of re-flooding the same edges -- and it
+ * takes over what it finds held at more.
+ *
+ * A root does not fix its cost: A* pops by f, so a corner can be reached by a dearer route before the
+ * cheapest one, and what the dearer one covered must not shut the cheaper one out. Nor is the dearer
+ * one discarded, only clipped: on a surface that does not unfold flat, two routes to one corner can
+ * open different ground beyond it, and the dearer may be the only way into some of it.
+ *
+ * A list holds the covered stretches of one edge for one root as [lo, hi, g] triples, ascending and
+ * disjoint. {@link reserve} writes the stretches of [lo, hi] the caller takes into {@link _uncovered}
+ * as [lo, hi] pairs and returns how many numbers it wrote.
  */
 const _covered = new Map();
 const ROOT_STRIDE = 0x1000000;
-const _uncovered = new Float64Array(256);
+const _uncovered = []; // reused across calls, like _rebuilt: a list has no fixed number of gaps
+const _rebuilt = [];   // the list being rewritten
 
-function reserve(from_face, neighbour, root_vid, lo, hi) {
+function reserve(from_face, neighbour, root_vid, g, lo, hi) {
     let by_root = _covered.get(from_face);
     if (by_root === undefined) { by_root = new Map(); _covered.set(from_face, by_root); }
 
@@ -586,41 +660,88 @@ function reserve(from_face, neighbour, root_vid, lo, hi) {
     let ranges = by_root.get(inner_key);
     if (ranges === undefined) { ranges = []; by_root.set(inner_key, ranges); }
 
+    const n = ranges.length;
     let out = 0;
-    let cur = lo;
-    for (let i = 0; i < ranges.length; i += 2) {
-        const r_lo = ranges[i], r_hi = ranges[i + 1];
-        if (r_hi <= cur) continue;
-        if (r_lo >= hi) break;
-        if (r_lo > cur) { _uncovered[out++] = cur; _uncovered[out++] = r_lo < hi ? r_lo : hi; }
-        if (r_hi > cur) cur = r_hi;
-        if (cur >= hi) break;
+    let k = 0;
+    let i = 0;
+
+    // stretches wholly below lo stay as they are
+    for (; i < n && ranges[i + 1] <= lo; i += 3) {
+        _rebuilt[k++] = ranges[i]; _rebuilt[k++] = ranges[i + 1]; _rebuilt[k++] = ranges[i + 2];
     }
-    if (cur < hi) { _uncovered[out++] = cur; _uncovered[out++] = hi; }
 
-    let i = 0;
-    while (i < ranges.length && ranges[i + 1] < lo - PEPS) i += 2;
-    let merge_lo = lo, merge_hi = hi, j = i;
-    while (j < ranges.length && ranges[j] <= hi + PEPS) {
-        if (ranges[j] < merge_lo) merge_lo = ranges[j];
-        if (ranges[j + 1] > merge_hi) merge_hi = ranges[j + 1];
-        j += 2;
+    let pos = lo;        // [lo, pos) is decided
+    let mine = -1;       // where the stretch being taken began; -1 while none is open
+    let tail_hi = -1;    // a dearer stretch reached past hi: what of it remains, [hi, tail_hi] at tail_g
+    let tail_g = 0;
+
+    for (; i < n && ranges[i] < hi; i += 3) {
+        const r_lo = ranges[i], r_hi = ranges[i + 1], r_g = ranges[i + 2];
+
+        if (r_g <= g) {
+            // held at this cost or less: it stays, and ends the stretch being taken before it
+            if (mine === -1 && r_lo > pos) mine = pos;
+            if (mine !== -1) {
+                if (r_lo > mine) {
+                    _uncovered[out++] = mine; _uncovered[out++] = r_lo;
+                    _rebuilt[k++] = mine; _rebuilt[k++] = r_lo; _rebuilt[k++] = g;
+                }
+                mine = -1;
+            }
+            _rebuilt[k++] = r_lo; _rebuilt[k++] = r_hi; _rebuilt[k++] = r_g;
+            if (r_hi > pos) pos = r_hi;
+        } else {
+            // held at more: taken over, but for what of it lies outside [lo, hi]
+            if (r_lo < lo) { _rebuilt[k++] = r_lo; _rebuilt[k++] = lo; _rebuilt[k++] = r_g; }
+            if (mine === -1) mine = pos;
+            if (r_hi > hi) { tail_hi = r_hi; tail_g = r_g; pos = hi; } else { pos = r_hi; }
+        }
     }
-    ranges.splice(i, j - i, merge_lo, merge_hi);
+
+    if (pos < hi) {
+        if (mine === -1) mine = pos;
+        pos = hi;
+    }
+    if (mine !== -1 && hi > mine) {
+        _uncovered[out++] = mine; _uncovered[out++] = hi;
+        _rebuilt[k++] = mine; _rebuilt[k++] = hi; _rebuilt[k++] = g;
+    }
+    if (tail_hi !== -1) { _rebuilt[k++] = hi; _rebuilt[k++] = tail_hi; _rebuilt[k++] = tail_g; }
+
+    for (; i < n; i += 3) {
+        _rebuilt[k++] = ranges[i]; _rebuilt[k++] = ranges[i + 1]; _rebuilt[k++] = ranges[i + 2];
+    }
+
+    // write the list back, joining neighbours held at one cost that touch to within PEPS
+    let w = 0;
+    for (let r = 0; r < k; r += 3) {
+        if (w > 0 && ranges[w - 1] === _rebuilt[r + 2] && _rebuilt[r] - ranges[w - 2] <= PEPS) {
+            if (_rebuilt[r + 1] > ranges[w - 2]) ranges[w - 2] = _rebuilt[r + 1];
+        } else {
+            ranges[w++] = _rebuilt[r]; ranges[w++] = _rebuilt[r + 1]; ranges[w++] = _rebuilt[r + 2];
+        }
+    }
+    ranges.length = w;
 
     return out;
 }
 
 /**
  * Clip the interval (edge fractions [lo,hi] along Pv->Qv) against what has already been reached on this
- * edge from `rootVid`, then emit a search node (or terminal, if the entered face holds the goal) for
- * each still-uncovered piece.
+ * edge from `rootVid` at cost `g` or less, then emit a search node (or terminal, if the entered face
+ * holds the goal) for each piece that is left.
+ *
+ * Orientation, which every node carries: the edge runs Pv -> Qv with `from_face` on its left and the
+ * entered face `neighbour` on its right, and the root is on its left or on its line. The start face is
+ * laid out counter-clockwise and unfolding keeps each face's winding, so a face's own edges always run
+ * with it on their left; the root either looks at the edge through `from_face` or is one of that face's
+ * vertices.
  */
 function add_successor(topology, neighbour, from_face, Pv, Qv, Px, Py, Qx, Qy, rx, ry, rootVid, g, parent, lo, hi, goal_face) {
     if (neighbour === NULL_POINTER) return; // boundary far edge -- nothing to enter
     if (hi - lo < PEPS) return;
 
-    const out = reserve(from_face, neighbour, rootVid, lo, hi);
+    const out = reserve(from_face, neighbour, rootVid, g, lo, hi);
     for (let i = 0; i < out; i += 2) {
         const ulo = _uncovered[i], uhi = _uncovered[i + 1];
         if (uhi - ulo < PEPS) continue;
@@ -635,11 +756,8 @@ function emit_node(topology, neighbour, Pv, Qv, Px, Py, Qx, Qy, rx, ry, rootVid,
         const ggx = goal_weight(Pv) * Px + goal_weight(Qv) * Qx + goal_weight(apex) * _apex[0];
         const ggy = goal_weight(Pv) * Py + goal_weight(Qv) * Qy + goal_weight(apex) * _apex[1];
 
-        let i0x = Px + t0 * (Qx - Px), i0y = Py + t0 * (Qy - Py), i0p = t0;
-        let i1x = Px + t1 * (Qx - Px), i1y = Py + t1 * (Qy - Py), i1p = t1;
-        if (tri2_signed_area(rx, ry, i0x, i0y, i1x, i1y) < 0) {
-            const sxx = i0x, syy = i0y, sp = i0p; i0x = i1x; i0y = i1y; i0p = i1p; i1x = sxx; i1y = syy; i1p = sp;
-        }
+        const i0x = Px + t0 * (Qx - Px), i0y = Py + t0 * (Qy - Py);
+        const i1x = Px + t1 * (Qx - Px), i1y = Py + t1 * (Qy - Py);
 
         const fcost = g + touch_distance(rx, ry, i0x, i0y, i1x, i1y, ggx, ggy);
 
@@ -652,19 +770,19 @@ function emit_node(topology, neighbour, Pv, Qv, Px, Py, Qx, Qy, rx, ry, rootVid,
         if (t < -PEPS || t > 1 + PEPS) { // -1 (no crossing) is caught by `< -PEPS`
             const d0 = v2_distance(rx, ry, i0x, i0y) + v2_distance(i0x, i0y, ggx, ggy);
             const d1 = v2_distance(rx, ry, i1x, i1y) + v2_distance(i1x, i1y, ggx, ggy);
-            fct = d0 <= d1 ? i0p : i1p;
+            fct = d0 <= d1 ? t0 : t1;
         }
 
         const id = alloc_node();
         const du = _node_du, df = _node_df;
-        const b = id * NODE_WORDS;
-        du[b + N_TERMINAL] = 1;
-        du[b + N_ROOTVID] = rootVid === -1 ? NULL_ID : rootVid;
-        du[b + N_E0V] = Pv; du[b + N_E1V] = Qv;
-        df[b + N_E0X] = Px; df[b + N_E0Y] = Py; df[b + N_E1X] = Qx; df[b + N_E1Y] = Qy;
-        df[b + N_RX] = rx; df[b + N_RY] = ry;
-        du[b + N_PARENT] = parent;
-        df[b + N_FCT] = fct;
+        const bu = id * NODE_U32, bf = id * NODE_F64;
+        du[bu + N_TERMINAL] = 1;
+        du[bu + N_ROOTVID] = rootVid === -1 ? NULL_ID : rootVid;
+        du[bu + N_E0V] = Pv; du[bu + N_E1V] = Qv;
+        df[bf + F_E0X] = Px; df[bf + F_E0Y] = Py; df[bf + F_E1X] = Qx; df[bf + F_E1Y] = Qy;
+        df[bf + F_RX] = rx; df[bf + F_RY] = ry;
+        du[bu + N_PARENT] = parent;
+        df[bf + F_FCT] = fct;
         _open.insert(id, fcost);
         return;
     }
@@ -683,15 +801,15 @@ function emit_node(topology, neighbour, Pv, Qv, Px, Py, Qx, Qy, rx, ry, rootVid,
 
     const id = alloc_node();
     const du = _node_du, df = _node_df;
-    const b = id * NODE_WORDS;
-    du[b + N_TERMINAL] = 0;
-    du[b + N_FACE] = neighbour;
-    du[b + N_E0V] = Pv; du[b + N_E1V] = Qv;
-    df[b + N_E0X] = Px; df[b + N_E0Y] = Py; df[b + N_E1X] = Qx; df[b + N_E1Y] = Qy;
-    du[b + N_ROOTVID] = rootVid === -1 ? NULL_ID : rootVid;
-    df[b + N_RX] = rx; df[b + N_RY] = ry;
-    df[b + N_T0] = t0; df[b + N_T1] = t1;
-    df[b + N_G] = g;
-    du[b + N_PARENT] = parent;
+    const bu = id * NODE_U32, bf = id * NODE_F64;
+    du[bu + N_TERMINAL] = 0;
+    du[bu + N_FACE] = neighbour;
+    du[bu + N_E0V] = Pv; du[bu + N_E1V] = Qv;
+    df[bf + F_E0X] = Px; df[bf + F_E0Y] = Py; df[bf + F_E1X] = Qx; df[bf + F_E1Y] = Qy;
+    du[bu + N_ROOTVID] = rootVid === -1 ? NULL_ID : rootVid;
+    df[bf + F_RX] = rx; df[bf + F_RY] = ry;
+    df[bf + F_T0] = t0; df[bf + F_T1] = t1;
+    df[bf + F_G] = g;
+    du[bu + N_PARENT] = parent;
     _open.insert(id, g + h);
 }