@expofp/wayfinding-compiler 0.0.0-bootstrap.0

package/dist/lib/place-path.js

@@ -0,0 +1,346 @@
+// Laying one raster path into the network: its runs placed on the lines their places define
+// (`runs.ts`), and each end tied to what it joins at a node — the tip standing there, or the
+// network line claiming the cell.
+import { legsBetween, linesMeet, linkOnto, placeIn, toFrame } from './geom/frames.js';
+import { POINT_EPS, snapCm } from './geom/point-key.js';
+import { segmentParam } from './geom/primitives.js';
+import { NODE_SNAP } from './graph-types.js';
+import { onRun, placeRun, pullOf, runCoords, runDirection, runLine, runsOf, } from './runs.js';
+/**
+ * Builds the function that lays one path.
+ * @param shared What it shares with the growth.
+ * @returns The function.
+ */
+export function createPathPlacer(shared) {
+    const { store, router, cfg, place, tipAt, onNetwork, add, claim } = shared;
+    const { frames } = place;
+    const pull = pullOf(cfg);
+    // The rule a path's pieces and ties keep; a caller may tighten it for one path.
+    let mayLay = place.mayLay;
+    /**
+     * Ties a run's end at a cell to the tip standing there: the run passes through the tip, or ends
+     * at its cell with an elbow to the tip.
+     * @param run The run; its line may move to the tip.
+     * @param tip The tip.
+     * @param end The run's end along: its first or last cell's center.
+     * @param hold Whether the run's line is settled and may not move.
+     * @returns The tie, or null when no free way joins them.
+     */
+    const tieTip = (run, tip, end, hold = false) => {
+        const [, c] = runCoords(run, tip.at[0], tip.at[1]);
+        if (Math.abs(c - run.c) <= NODE_SNAP || (!hold && mayLay(runLine(run, c)))) {
+            run.c = c;
+            return { at: tip.at, legs: [] };
+        }
+        // The run cannot pass the tip: it ends at its cell, and an elbow brings the tip to it.
+        const at = onRun(run, end, run.c);
+        const legs = legsBetween(run.frame, tip.at, at, mayLay);
+        return legs && { at, legs };
+    };
+    /**
+     * The point of a segment nearest to a point, on the centimeter grid.
+     * @param seg The segment.
+     * @param p The point.
+     * @returns The nearest point.
+     */
+    const nearestOn = (seg, p) => {
+        const t = segmentParam(p[0], p[1], seg[0], seg[1], seg[2], seg[3]);
+        return [snapCm(seg[0] + t * (seg[2] - seg[0])), snapCm(seg[1] + t * (seg[3] - seg[1]))];
+    };
+    /**
+     * Ties a run's end at a cell to the network there: square across the line the run's own line
+     * meets within the cell, along a line running the same way (the run ends where it meets it, or
+     * at its end), else by an elbow to the nearest line a free way reaches.
+     * @param run The run; its line may move onto a line running the same way.
+     * @param end The run's end along: its first or last cell's center.
+     * @param hold Whether the run's line is settled and may not move.
+     * @returns The tie, or null when nothing near can be reached.
+     */
+    const tieNetwork = (run, end, hold = false) => {
+        const at = onRun(run, end, run.c);
+        const dir = runDirection(run);
+        const near = [];
+        store.forEachNear(at[0] - cfg.pitch, at[1] - cfg.pitch, at[0] + cfg.pitch, at[1] + cfg.pitch, (_, x0, y0, x1, y1) => near.push([x0, y0, x1, y1]));
+        let best = null;
+        const offer = (tie, c) => {
+            const away = Math.hypot(tie.at[0] - at[0], tie.at[1] - at[1]);
+            if (away <= cfg.pitch + NODE_SNAP && (!best || away < best.away))
+                best = { tie, away, c };
+        };
+        for (const held of near) {
+            const [x0, y0, x1, y1] = held;
+            const len = Math.hypot(x1 - x0, y1 - y0);
+            if (len < NODE_SNAP)
+                continue;
+            // Which way the segment runs, as the raster can tell over its length: square across the
+            // run, along it, or neither.
+            const [su, sv] = toFrame(run.frame, (x1 - x0) / len, (y1 - y0) / len);
+            const tell = cfg.cs / len;
+            const across = (run.horiz ? Math.abs(su) : Math.abs(sv)) <= tell;
+            const alongRun = (run.horiz ? Math.abs(sv) : Math.abs(su)) <= tell;
+            if (across) {
+                // Square across: where the run's line meets the segment, or its end within a node of it.
+                const met = linesMeet(at, dir, [x0, y0], [(x1 - x0) / len, (y1 - y0) / len]);
+                if (!met)
+                    continue;
+                const on = nearestOn(held, met.at);
+                if (Math.hypot(on[0] - met.at[0], on[1] - met.at[1]) <= NODE_SNAP)
+                    offer({ at: on, legs: [], cut: held }, run.c);
+            }
+            else if (alongRun) {
+                // Along: the run goes onto the segment's line and ends where it meets the segment.
+                const [, c] = runCoords(run, x0, y0);
+                if (Math.abs(c - run.c) > NODE_SNAP &&
+                    (hold || Math.abs(c - run.walked) > pull || !mayLay(runLine(run, c))))
+                    continue;
+                const on = onRun(run, end, c);
+                const t = segmentParam(on[0], on[1], x0, y0, x1, y1);
+                const nearest = nearestOn(held, on);
+                const inside = t > 0 && t < 1 && Math.hypot(nearest[0] - on[0], nearest[1] - on[1]) <= NODE_SNAP;
+                offer(inside ? { at: on, legs: [], cut: held } : { at: nearest, legs: [] }, c);
+            }
+        }
+        if (best) {
+            const { tie, c } = best;
+            run.c = c;
+            return tie;
+        }
+        // An elbow to the nearest line a free way reaches, nearest first.
+        const byDistance = near
+            .map((held) => ({ held, on: nearestOn(held, at) }))
+            .sort((p, q) => Math.hypot(p.on[0] - at[0], p.on[1] - at[1]) -
+            Math.hypot(q.on[0] - at[0], q.on[1] - at[1]));
+        for (const { held, on } of byDistance) {
+            const link = linkOnto(run.frame, at, held, on, mayLay);
+            if (link)
+                return { at, legs: link.legs, cut: held };
+        }
+        return null;
+    };
+    /**
+     * Cuts a segment where a tie lands, so the meeting is a node.
+     * @param tie The tie.
+     */
+    const cutAt = (tie) => {
+        if (!tie.cut)
+            return;
+        const at = tie.legs.length ? lastPoint(tie.legs) : tie.at;
+        const id = store.segmentAt(at[0], at[1]);
+        if (id >= 0)
+            store.splitAt(id, at[0], at[1]);
+    };
+    const lastPoint = (legs) => {
+        const [, , x, y] = legs[legs.length - 1];
+        return [x, y];
+    };
+    /**
+     * The corner between two consecutive runs: where their lines meet.
+     * @param a The first run.
+     * @param b The next.
+     * @returns The corner, or null when the lines meet nowhere near.
+     */
+    const cornerOf = (a, b) => {
+        if (a.frame === b.frame) {
+            if (a.horiz === b.horiz)
+                return null;
+            return a.horiz ? placeIn(a.frame, b.c, a.c) : placeIn(a.frame, a.c, b.c);
+        }
+        const aEnd = onRun(a, a.sign > 0 ? a.hi : a.lo, a.c);
+        const bEnd = onRun(b, b.sign > 0 ? b.lo : b.hi, b.c);
+        const met = linesMeet(aEnd, runDirection(a), bEnd, runDirection(b));
+        if (!met)
+            return null;
+        const nearA = Math.hypot(...diff(met.at, aEnd));
+        const nearB = Math.hypot(...diff(met.at, bEnd));
+        return nearA <= cfg.pitch && nearB <= cfg.pitch ? met.at : null;
+    };
+    const diff = (p, q) => [p[0] - q[0], p[1] - q[1]];
+    /**
+     * What stands at a path's end cell: the tip there, or the network when a line runs within a
+     * pitch of the cell.
+     * @param cell The cell.
+     * @returns The tip, `'network'`, or null.
+     */
+    const endAt = (cell) => {
+        const tip = tipAt.get(cell);
+        if (tip)
+            return tip;
+        if (onNetwork[cell])
+            return 'network';
+        const [px, py] = router.worldOf(cell);
+        const near = store.nearest(px, py);
+        return near && near.away <= router.pitch ? 'network' : null;
+    };
+    const isTip = (end) => end !== 'network';
+    const layPlaced = (cells, head) => {
+        const runs = runsOf(router, cells);
+        const first = cells[0];
+        const last = cells[cells.length - 1];
+        const headEnd = head ?? endAt(first);
+        const tailEnd = endAt(last);
+        if (!headEnd || !tailEnd)
+            return false;
+        // No run: the two ends stand in one cell, joined by a leg.
+        if (!runs.length) {
+            const a = isTip(headEnd) ? headEnd.at : null;
+            const b = isTip(tailEnd) ? tailEnd.at : null;
+            if (a && b) {
+                const legs = legsBetween(frames[0], a, b, mayLay);
+                if (!legs)
+                    return false;
+                for (const leg of legs)
+                    add(leg);
+                return true;
+            }
+            const tie = elbow(a ?? b ?? router.worldOf(first), router.frameOf(first));
+            if (!tie)
+                return false;
+            layElbow(tie);
+            return true;
+        }
+        for (const run of runs)
+            placeRun(run, place, cfg, mayLay);
+        const headRun = runs[0];
+        const tailRun = runs[runs.length - 1];
+        const headEndAlong = headRun.sign > 0 ? headRun.lo : headRun.hi;
+        const tailEndAlong = tailRun.sign > 0 ? tailRun.hi : tailRun.lo;
+        // Both ties share a single run's line: the first tie settles it and the second holds it, a
+        // tip's tie first — the tip is what the path exists for, so its line wins.
+        const single = runs.length === 1;
+        const tieHead = (hold) => isTip(headEnd)
+            ? tieTip(headRun, headEnd, headEndAlong, hold)
+            : tieNetwork(headRun, headEndAlong, hold);
+        const tieTail = (hold) => isTip(tailEnd)
+            ? tieTip(tailRun, tailEnd, tailEndAlong, hold)
+            : tieNetwork(tailRun, tailEndAlong, hold);
+        const headFirst = !single || isTip(headEnd) || !isTip(tailEnd);
+        const headTie = headFirst ? tieHead(false) : null;
+        const tailTie = headFirst ? headTie && tieTail(single) : tieTail(false);
+        const heldHead = headFirst ? headTie : tailTie && tieHead(true);
+        if (!heldHead || !tailTie)
+            return false;
+        // Each run goes from its start to its end: the head tie, a corner between each two runs, the
+        // tail tie. Runs whose lines meet nowhere near end at their own cells, a jog between them.
+        const headTied = heldHead;
+        const starts = [headTied.at];
+        const ends = [];
+        const jogs = [];
+        for (let i = 0; i + 1 < runs.length; i++) {
+            const corner = cornerOf(runs[i], runs[i + 1]);
+            if (corner) {
+                ends.push(corner);
+                starts.push(corner);
+                continue;
+            }
+            const a = onRun(runs[i], runs[i].sign > 0 ? runs[i].hi : runs[i].lo, runs[i].c);
+            const b = onRun(runs[i + 1], runs[i + 1].sign > 0 ? runs[i + 1].lo : runs[i + 1].hi, runs[i + 1].c);
+            ends.push(a);
+            starts.push(b);
+            jogs.push(...(legsBetween(runs[i].frame, a, b, mayLay) ?? [[a[0], a[1], b[0], b[1]]]));
+        }
+        ends.push(tailTie.at);
+        // A run that turned back on itself is a path the placement bent double.
+        const pieces = [];
+        for (const [i, run] of runs.entries()) {
+            const [px, py] = starts[i];
+            const [qx, qy] = ends[i];
+            const dir = runDirection(run);
+            if ((qx - px) * dir[0] + (qy - py) * dir[1] < -NODE_SNAP)
+                return false;
+            if (Math.hypot(qx - px, qy - py) >= POINT_EPS)
+                pieces.push({ seg: [px, py, qx, qy], run });
+        }
+        if (![...pieces.map((p) => p.seg), ...jogs].every(mayLay))
+            return false;
+        cutAt(headTied);
+        cutAt(tailTie);
+        for (const leg of [...headTied.legs, ...tailTie.legs, ...jogs])
+            add(leg);
+        for (const { seg, run } of pieces) {
+            add(seg);
+            claim(seg, run.cells);
+        }
+        return true;
+    };
+    /**
+     * An elbow from a point to the nearest line a free way reaches.
+     * @param from The point.
+     * @param frame The frame the legs run along.
+     * @returns The elbow, or null when no line can be reached.
+     */
+    const elbow = (from, frame) => {
+        const found = store.nearestLawful(from[0], from[1], (_, qx, qy) => mayLay([from[0], from[1], qx, qy]));
+        if (!found)
+            return null;
+        const link = linkOnto(frame, from, store.coords(found.id), found.at, mayLay);
+        return link && { legs: link.legs, index: found.id, at: link.at };
+    };
+    /**
+     * Lays an elbow: cuts the line it lands on and adds its legs.
+     * @param tie The elbow.
+     */
+    const layElbow = (tie) => {
+        if (tie.index !== undefined && tie.at)
+            store.splitAt(tie.index, tie.at[0], tie.at[1]);
+        for (const leg of tie.legs)
+            add(leg);
+    };
+    /**
+     * Lays a path where it was walked, its ends tied by elbows: the fallback when placement fails.
+     * @param cells The path.
+     * @param head The tip the path starts at, when it starts at one.
+     * @returns False when an end could not be tied; nothing is laid then.
+     */
+    const layPlain = (cells, head) => {
+        const walked = router.segmentsAlong(cells);
+        if (!walked.length)
+            return false;
+        // The fallback keeps the placed path's law: a walked segment that clips something blocked is
+        // replaced by an elbow around it, or the path is not laid at all.
+        const segs = [];
+        for (const seg of walked) {
+            if (mayLay(seg)) {
+                segs.push(seg);
+                continue;
+            }
+            const legs = legsBetween(router.frameOf(cells[0]), [seg[0], seg[1]], [seg[2], seg[3]], mayLay);
+            if (!legs)
+                return false;
+            segs.push(...legs);
+        }
+        const first = [segs[0][0], segs[0][1]];
+        const last = [segs[segs.length - 1][2], segs[segs.length - 1][3]];
+        const headEnd = head ?? endAt(cells[0]);
+        const tailEnd = endAt(cells[cells.length - 1]);
+        if (!headEnd || !tailEnd)
+            return false;
+        // Both ends first: an end that cannot be tied leaves nothing behind.
+        const ties = [];
+        for (const [point, end, cell] of [
+            [first, headEnd, cells[0]],
+            [last, tailEnd, cells[cells.length - 1]],
+        ]) {
+            const frame = router.frameOf(cell);
+            const legs = isTip(end) ? legsBetween(frame, end.at, point, mayLay) : null;
+            const tie = isTip(end) ? legs && { legs } : elbow(point, frame);
+            if (!tie)
+                return false;
+            ties.push(tie);
+        }
+        for (const tie of ties)
+            layElbow(tie);
+        for (const seg of segs)
+            add(seg);
+        return true;
+    };
+    const layPath = (cells, head, free = place.mayLay) => {
+        mayLay = free;
+        try {
+            return layPlaced(cells, head) || layPlain(cells, head);
+        }
+        finally {
+            mayLay = place.mayLay;
+        }
+    };
+    return layPath;
+}

package/dist/lib/post-passes.d.ts

@@ -0,0 +1,31 @@
+import type { Connector } from './connect.js';
+import { type Frame } from './geom/frames.js';
+import type { Segment } from './geom/types.js';
+import type { NetworkStore } from './network-store.js';
+import type { Router } from './router.js';
+/**
+ * Cuts shortcut links into the network where the tree forces a detour.
+ * @param store The network; extended in place.
+ * @param router The raster router that lays each link.
+ * @param connector Lays each link on the lines of its way.
+ * @returns How many links were cut in.
+ */
+export declare function shortcutDetours(store: NetworkStore, router: Router, connector: Connector): number;
+/**
+ * Removes every line that ends nowhere: a dangling end that is no tip goes, and the end it uncovers
+ * is judged the same way, back to the first junction or tip. The one line a tip has stays, whatever
+ * its other end: the tip needs it.
+ * @param store The network; trimmed in place.
+ * @param tips Keys of the tips: the ends a line may stop at.
+ */
+export declare function dropDeadEnds(store: NetworkStore, tips: ReadonlySet<string>): void;
+/**
+ * Extends each axis-aligned dangling end to the first line straight ahead, until no end is left to
+ * extend.
+ * @param store The network; extended in place.
+ * @param connector Lays the extensions.
+ * @param mayLay Whether an extension may be laid.
+ * @param frames The directions the layer is drawn in.
+ */
+export declare function completeLines(store: NetworkStore, connector: Connector, mayLay: (seg: Segment) => boolean, frames: readonly Frame[]): void;
+//# sourceMappingURL=post-passes.d.ts.map

package/dist/lib/post-passes.js

@@ -0,0 +1,305 @@
+// Passes over the laid network: dead ends dropped, dangling ends run on to the line ahead, and links
+// cut across where the network would send a visitor the long way round.
+import { cellArray } from './cell-array.js';
+import { nearestFrame, toFrame } from './geom/frames.js';
+import { pointKey } from './geom/point-key.js';
+import { rayVsSegment } from './geom/primitives.js';
+import { NODE_SNAP } from './graph-types.js';
+import { MinHeap } from './min-heap.js';
+import { chainSegments, chainsFromEdges, graphOf } from './network-graph.js';
+import { MAX_STRETCH } from './network-sizes.js';
+/** Links one pass may cut in, so open floor cannot turn the tree into a mesh. */
+const MAX_SHORTCUTS = 24;
+/** Rounds per pass; each reads the whole floor once (the costly part) and cuts in all it finds. */
+const SHORTCUT_ROUNDS = 3;
+/** Links one round proposes; no two share an endpoint. */
+const SHORTCUTS_PER_ROUND = 8;
+/** Network-walk steps per round, so a dense plan cannot stall the compile. */
+const SHORTCUT_BUDGET = 200_000;
+/**
+ * Network distance from `source` to `target`, abandoned past `limit` so near pairs stay cheap.
+ * @param graph The network graph.
+ * @param source Where to walk from.
+ * @param target Where to walk to.
+ * @param limit Distance past which the answer stops mattering.
+ * @param budget Relaxations left to the whole pass; spent here.
+ * @param budget.left Relaxations left.
+ * @returns The distance, or `Infinity` when past `limit`, on another fragment, or over budget.
+ */
+function walkWithin(graph, source, target, limit, budget) {
+    const dist = new Map([[source, 0]]);
+    const heap = new MinHeap();
+    heap.push(0, source);
+    while (heap.size) {
+        const u = heap.pop();
+        const du = heap.poppedKey;
+        if (du > limit)
+            return Infinity;
+        if (u === target)
+            return du;
+        if (du > (dist.get(u) ?? Infinity))
+            continue;
+        for (const [v, len] of graph.adj[u]) {
+            if (budget.left-- <= 0)
+                return Infinity;
+            const d = du + len;
+            if (d >= (dist.get(v) ?? Infinity))
+                continue;
+            dist.set(v, d);
+            heap.push(d, v);
+        }
+    }
+    return Infinity;
+}
+/**
+ * Where the network sends a visitor the long way round. Each free cell is claimed by its nearest
+ * network vertex across the floor; where two claims meet, the floor walk is compared with the
+ * network walk.
+ * @param soup The network segments.
+ * @param router The raster router, for the walk across open floor.
+ * @param taken Points a link already leaves from (one link per point); picks are added.
+ * @returns Pairs of network points worth joining; empty when every walk is direct enough.
+ */
+function worstDetours(soup, router, taken) {
+    const graph = graphOf(soup);
+    if (graph.nodes.length < 2)
+        return [];
+    const cells = router.cells;
+    const cost = cellArray(Float64Array, cells).fill(Infinity);
+    const label = cellArray(Int32Array, cells).fill(-1);
+    const heap = new MinHeap();
+    for (const [x0, y0, x1, y1] of soup)
+        for (const c of router.cellsAlong(x0, y0, x1, y1)) {
+            if (!router.ok[c])
+                continue;
+            const [cx, cy] = router.worldOf(c);
+            const da = Math.hypot(cx - x0, cy - y0);
+            const db = Math.hypot(cx - x1, cy - y1);
+            const near = da <= db ? pointKey(x0, y0) : pointKey(x1, y1);
+            const d = Math.min(da, db);
+            if (d >= cost[c])
+                continue;
+            cost[c] = d;
+            label[c] = graph.nodeId.get(near) ?? -1;
+            heap.push(d, c);
+        }
+    while (heap.size) {
+        const c = heap.pop();
+        if (heap.poppedKey > cost[c])
+            continue;
+        for (let nd = 0; nd < 4; nd++) {
+            const nc = router.stepTo(c, nd);
+            if (nc < 0)
+                continue;
+            const d = cost[c] + router.pitch;
+            if (d >= cost[nc])
+                continue;
+            cost[nc] = d;
+            label[nc] = label[c];
+            heap.push(d, nc);
+        }
+    }
+    // Each claim boundary is one candidate; right and down only, so a pair is weighed once.
+    const meeting = new Map();
+    for (let c = 0; c < cells; c++) {
+        if (label[c] < 0)
+            continue;
+        for (const nd of [0, 2]) {
+            const nc = router.stepTo(c, nd);
+            if (nc < 0 || label[nc] < 0 || label[nc] === label[c])
+                continue;
+            const u = Math.min(label[c], label[nc]);
+            const v = Math.max(label[c], label[nc]);
+            const free = cost[c] + cost[nc] + router.pitch;
+            const key = `${u}|${v}`;
+            const known = meeting.get(key);
+            if (!known || free < known.free)
+                meeting.set(key, { u, v, free });
+        }
+    }
+    // Longest floor walk first: an accepted pair saves more than its floor walk, so this ranks by
+    // saving, not by ratio (lines half a meter apart have a huge ratio and save nothing).
+    const ranked = [...meeting.values()]
+        .filter(({ free }) => free > 0)
+        .sort((a, b) => b.free - a.free);
+    const budget = { left: SHORTCUT_BUDGET };
+    const picks = [];
+    // The network's direction at a vertex: along its first line.
+    const along = (u) => {
+        const [v] = graph.adj[u][0];
+        return [graph.nodes[v][0] - graph.nodes[u][0], graph.nodes[v][1] - graph.nodes[u][1]];
+    };
+    for (const { u, v, free } of ranked) {
+        if (picks.length >= SHORTCUTS_PER_ROUND || budget.left <= 0)
+            break;
+        const ku = pointKey(graph.nodes[u][0], graph.nodes[u][1]);
+        const kv = pointKey(graph.nodes[v][0], graph.nodes[v][1]);
+        if (taken.has(ku) || taken.has(kv))
+            continue;
+        const limit = MAX_STRETCH * free;
+        if (walkWithin(graph, u, v, limit, budget) <= limit)
+            continue;
+        taken.add(ku);
+        taken.add(kv);
+        picks.push({
+            from: graph.nodes[u],
+            to: graph.nodes[v],
+            fromAlong: along(u),
+            toAlong: along(v),
+        });
+    }
+    return picks;
+}
+/**
+ * Cuts shortcut links into the network where the tree forces a detour.
+ * @param store The network; extended in place.
+ * @param router The raster router that lays each link.
+ * @param connector Lays each link on the lines of its way.
+ * @returns How many links were cut in.
+ */
+export function shortcutDetours(store, router, connector) {
+    const isTarget = cellArray(Uint8Array, router.cells);
+    const taken = new Set();
+    let cut = 0;
+    for (let round = 0; round < SHORTCUT_ROUNDS && cut < MAX_SHORTCUTS; round++) {
+        const fixes = worstDetours(store.toArray(), router, taken);
+        if (!fixes.length)
+            return cut;
+        for (const fix of fixes) {
+            if (cut >= MAX_SHORTCUTS)
+                return cut;
+            cut += cutIn(router, connector, isTarget, fix) ? 1 : 0;
+        }
+    }
+    return cut;
+}
+/**
+ * Lays one link across the floor into the network.
+ * @param router The raster router.
+ * @param connector Lays the link.
+ * @param isTarget Scratch target mask, reused between links.
+ * @param fix The two network points to join.
+ * @returns True when the link was laid.
+ */
+function cutIn(router, connector, isTarget, fix) {
+    // Each end on the grid of the network's direction there, so the link meets it square.
+    const from = router.cellOf(fix.from[0], fix.from[1], fix.fromAlong[0], fix.fromAlong[1]);
+    const to = router.cellOf(fix.to[0], fix.to[1], fix.toAlong[0], fix.toAlong[1]);
+    if (from < 0 || to < 0 || !router.ok[from] || !router.ok[to])
+        return false;
+    isTarget.fill(0);
+    isTarget[to] = 1;
+    const cells = router.route([from], isTarget);
+    return cells !== null && cells.length >= 2 && connector.layPath(cells, null);
+}
+/**
+ * Removes every line that ends nowhere: a dangling end that is no tip goes, and the end it uncovers
+ * is judged the same way, back to the first junction or tip. The one line a tip has stays, whatever
+ * its other end: the tip needs it.
+ * @param store The network; trimmed in place.
+ * @param tips Keys of the tips: the ends a line may stop at.
+ */
+export function dropDeadEnds(store, tips) {
+    for (;;) {
+        const degree = new Map();
+        const at = new Map();
+        const other = new Map();
+        store.forEach((id, x0, y0, x1, y1) => {
+            const keys = [pointKey(x0, y0), pointKey(x1, y1)];
+            other.set(id, keys);
+            for (const key of keys) {
+                degree.set(key, (degree.get(key) ?? 0) + 1);
+                const list = at.get(key);
+                if (list)
+                    list.push(id);
+                else
+                    at.set(key, [id]);
+            }
+        });
+        let dropped = 0;
+        for (const [key, count] of degree) {
+            if (count !== 1 || tips.has(key))
+                continue;
+            for (const id of at.get(key) ?? []) {
+                const far = other.get(id).find((k) => k !== key);
+                if (tips.has(far) && degree.get(far) <= 1)
+                    continue;
+                store.remove(id);
+                degree.set(far, degree.get(far) - 1);
+                degree.set(key, 0);
+                dropped++;
+            }
+        }
+        if (!dropped)
+            return;
+    }
+}
+/**
+ * Extends each axis-aligned dangling end to the first line straight ahead, until no end is left to
+ * extend.
+ * @param store The network; extended in place.
+ * @param connector Lays the extensions.
+ * @param mayLay Whether an extension may be laid.
+ * @param frames The directions the layer is drawn in.
+ */
+export function completeLines(store, connector, mayLay, frames) {
+    const meet = [0, 0];
+    const raySeg = (px, py, dx, dy, seg) => {
+        if (!rayVsSegment(meet, px, py, dx, dy, seg[0], seg[1], seg[2], seg[3]))
+            return Infinity;
+        const [s, u] = meet;
+        return s > 0.1 && u >= 0 && u <= 1 ? s : Infinity;
+    };
+    for (;;) {
+        const chains = chainsFromEdges(store.toArray());
+        const graph = graphOf(chainSegments(chains));
+        const segs = chainSegments(chains);
+        let added = 0;
+        for (let n = 0; n < graph.nodes.length; n++) {
+            if (graph.adj[n].length !== 1)
+                continue;
+            const nb = graph.adj[n][0][0];
+            const [nx, ny] = graph.nodes[n];
+            const [bx, by] = graph.nodes[nb];
+            const len = Math.hypot(nx - bx, ny - by);
+            if (len < 0.05)
+                continue;
+            // Continue along the nearest axis of the nearest direction.
+            const frame = frames[nearestFrame(frames, nx - bx, ny - by)];
+            const [du, dv] = toFrame(frame, (nx - bx) / len, (ny - by) / len);
+            if (Math.abs(du) > 0.1 && Math.abs(dv) > 0.1)
+                continue;
+            const [dx, dy] = Math.abs(du) > Math.abs(dv)
+                ? [frame.cos * Math.sign(du), frame.sin * Math.sign(du)]
+                : [-frame.sin * Math.sign(dv), frame.cos * Math.sign(dv)];
+            let hit = Infinity;
+            let hitSi = -1;
+            for (let si = 0; si < segs.length; si++) {
+                const s = raySeg(nx, ny, dx, dy, segs[si]);
+                if (s < hit) {
+                    hit = s;
+                    hitSi = si;
+                }
+            }
+            if (hitSi < 0)
+                continue;
+            // The ray hits a chain chord whose pruned vertices may sit a snap off the stored lines: the
+            // extension ends on the nearest real segment, or nowhere — a chord anchors no line.
+            const near = store.nearest(nx + dx * hit, ny + dy * hit);
+            if (!near || near.away > NODE_SNAP)
+                continue;
+            const qx = +near.at[0].toFixed(2);
+            const qy = +near.at[1].toFixed(2);
+            if (Math.hypot(qx - nx, qy - ny) <= NODE_SNAP || !mayLay([nx, ny, qx, qy]))
+                continue;
+            // A chain may span several stored segments: cut the one carrying the hit, if any.
+            const carrier = store.segmentAt(qx, qy);
+            if (carrier >= 0)
+                store.splitAt(carrier, qx, qy);
+            connector.add([nx, ny, qx, qy]);
+            added++;
+        }
+        if (!added)
+            break;
+    }
+}