@expofp/wayfinding-compiler 0.0.0-experimental.3b0db16 → 0.0.0-stage

package/dist/lib/min-heap.d.ts

@@ -1,24 +0,0 @@
-/**
- * Allocation-free binary min-heap of (key, value) numbers: `pop` returns the value and leaves the key in
- * {@link poppedKey}.
- */
-export declare class MinHeap {
-    private readonly k;
-    private readonly v;
-    /** Key of the last popped entry. */
-    poppedKey: number;
-    /** Entry count. */
-    get size(): number;
-    /**
-     * Add an entry.
-     * @param key What the heap orders by.
-     * @param val The value carried with it.
-     */
-    push(key: number, val: number): void;
-    /**
-     * Remove the smallest-key entry.
-     * @returns Its value; the key goes to {@link poppedKey}.
-     */
-    pop(): number;
-}
-//# sourceMappingURL=min-heap.d.ts.map

package/dist/lib/min-heap.js

@@ -1,73 +0,0 @@
-/**
- * Allocation-free binary min-heap of (key, value) numbers: `pop` returns the value and leaves the key in
- * {@link poppedKey}.
- */
-export class MinHeap {
-    k = [];
-    v = [];
-    /** Key of the last popped entry. */
-    poppedKey = 0;
-    /** Entry count. */
-    get size() {
-        return this.k.length;
-    }
-    /**
-     * Add an entry.
-     * @param key What the heap orders by.
-     * @param val The value carried with it.
-     */
-    push(key, val) {
-        const { k, v } = this;
-        let i = k.length;
-        k.push(key);
-        v.push(val);
-        while (i > 0) {
-            const p = (i - 1) >> 1;
-            if (k[p] <= k[i])
-                break;
-            const tk = k[p];
-            const tv = v[p];
-            k[p] = k[i];
-            v[p] = v[i];
-            k[i] = tk;
-            v[i] = tv;
-            i = p;
-        }
-    }
-    /**
-     * Remove the smallest-key entry.
-     * @returns Its value; the key goes to {@link poppedKey}.
-     */
-    pop() {
-        const { k, v } = this;
-        const topK = k[0];
-        const topV = v[0];
-        const lk = k.pop();
-        const lv = v.pop();
-        if (k.length) {
-            k[0] = lk;
-            v[0] = lv;
-            let i = 0;
-            for (;;) {
-                const l = 2 * i + 1;
-                const r = l + 1;
-                let m = i;
-                if (l < k.length && k[l] < k[m])
-                    m = l;
-                if (r < k.length && k[r] < k[m])
-                    m = r;
-                if (m === i)
-                    break;
-                const tk = k[m];
-                const tv = v[m];
-                k[m] = k[i];
-                v[m] = v[i];
-                k[i] = tk;
-                v[i] = tv;
-                i = m;
-            }
-        }
-        this.poppedKey = topK;
-        return topV;
-    }
-}

package/dist/lib/network-build.d.ts

@@ -1,21 +0,0 @@
-import type { Blockers } from './blockers.js';
-import type { Frame } from './geom/frames.js';
-import type { RouteNetworkDestination, Unreached, UnreachedReason } from './graph-types.js';
-import type { NetworkSizes } from './network-sizes.js';
-/** The layer as every pass of the network build reads it. */
-export interface NetworkBuild {
-    /** Network sizes. */
-    readonly cfg: NetworkSizes;
-    /** The directions the layer is drawn in, the plan's first. */
-    readonly frames: readonly Frame[];
-    /** What a line or a dock may not cross. */
-    readonly blockers: Blockers;
-    /** The layer's destinations, by id. */
-    readonly destinationOf: ReadonlyMap<string, RouteNetworkDestination>;
-    /**
-     * Records why a destination has no dock yet, with where and by which check; the most informative
-     * reason is kept, with its facts.
-     */
-    readonly note: (id: string, reason: UnreachedReason, facts?: Omit<Unreached, 'id' | 'reason'>) => void;
-}
-//# sourceMappingURL=network-build.d.ts.map

package/dist/lib/network-build.js

@@ -1,4 +0,0 @@
-// What every pass of the network build reads about its layer: the sizes, the directions the layer
-// is drawn in, what a line may not cross, the destinations by id, and where to note a destination
-// the build could not serve.
-export {};

package/dist/lib/network-graph.d.ts

@@ -1,80 +0,0 @@
-import { type Frame } from './geom/frames.js';
-import type { Segment } from './geom/types.js';
-/** A run of network points: a chain of segments through vertices no third segment meets. */
-export interface Chain {
-    /** Its points, in order. */
-    pts: [number, number][];
-}
-/**
- * Reads a segment soup as chains: every maximal run through vertices of degree two, straightened
- * where it runs straight through a point.
- * @param soup The segments.
- * @param protect Keys of points a chain keeps as vertices however straight it runs through them.
- * @returns The chains, coordinates on the centimeter grid.
- */
-export declare function chainsFromEdges(soup: readonly Segment[], protect?: ReadonlySet<string>): Chain[];
-/** What the joining may read of the floor. */
-interface JoinOptions {
-    /** The directions the layer is drawn in. */
-    readonly frames?: readonly Frame[];
-    /** Whether a segment lies on free floor: across no wall or stand. Everything is free by default. */
-    readonly free?: (seg: Segment) => boolean;
-    /**
-     * How far aside, and how far ahead, the run continuing another may start: a stub's length. Without
-     * it no run is pulled over.
-     */
-    readonly lane?: number;
-}
-/** The lines joined into straight runs, and where that moved a point. */
-interface JoinedRuns {
-    /** The runs, each straight stretch one chord. */
-    readonly chains: Chain[];
-    /** Every vertex a chord replaced, by its key, and where it now lies on the chord. */
-    readonly moved: Map<string, [number, number]>;
-}
-/**
- * Joins the chains that continue one another through a shared end, and makes each straight stretch
- * one chord: an aisle is one line from end to end, the stubs meeting it end on its span, and two aisles
- * cross whole. Two pieces continue one another when they run along the same axis of the same frame
- * in opposite senses, or, off every axis, when the joint lies on the chord between its neighbors.
- * Every vertex a chord replaces is moved onto the chord, and so are the ends of the lines that stood
- * on it. A run then continues through the next run along its axis when nothing stands between them
- * on the floor: that run is pulled onto its line, longest runs first, so a line never starts where the
- * one before it could go on. The converter that builds wf.data.js cuts a line where another ends on
- * it or crosses it.
- * @param chains The chains, ends on shared vertices.
- * @param options The layer's directions and its free floor.
- * @returns The joined runs, and where the vertices they replaced now lie.
- */
-export declare function joinStraightRuns(chains: readonly Chain[], options?: JoinOptions): JoinedRuns;
-/** The network as a graph of its vertices. */
-export interface Graph {
-    /** Vertex positions, by vertex id. */
-    readonly nodes: [number, number][];
-    /** Neighbors of each vertex: vertex, length, edge id. */
-    readonly adj: [number, number, number][][];
-    /** Edge ends, by edge id. */
-    readonly edges: [number, number][];
-    /** Vertex id by point key. */
-    readonly nodeId: Map<string, number>;
-}
-/**
- * Chains as segments, one per pair of neighboring points.
- * @param chains The chains.
- * @returns Their segments, in chain order.
- */
-export declare function chainSegments(chains: readonly Chain[]): Segment[];
-/**
- * Reads segments as a graph; vertices merge by point key.
- * @param segments The segments.
- * @returns The graph.
- */
-export declare function graphOf(segments: readonly Segment[]): Graph;
-/**
- * The connected pieces of a graph.
- * @param graph The graph.
- * @returns Each vertex's piece, by vertex id.
- */
-export declare function components(graph: Graph): Int32Array;
-export {};
-//# sourceMappingURL=network-graph.d.ts.map

package/dist/lib/network-graph.js

@@ -1,467 +0,0 @@
-// The network read as a graph: its segments joined into chains, the chains as vertices and edges,
-// and the connected pieces.
-import { nearestFrame, toFrame } from './geom/frames.js';
-import { POINT_EPS, pointKey } from './geom/point-key.js';
-/**
- * Reads a segment soup as chains: every maximal run through vertices of degree two, straightened
- * where it runs straight through a point.
- * @param soup The segments.
- * @param protect Keys of points a chain keeps as vertices however straight it runs through them.
- * @returns The chains, coordinates on the centimeter grid.
- */
-export function chainsFromEdges(soup, protect) {
-    const nodePos = new Map();
-    const adjK = new Map();
-    const ek = (a, b) => (a < b ? `${a}|${b}` : `${b}|${a}`);
-    const edgeSet = new Set();
-    for (const [x0, y0, x1, y1] of soup) {
-        const a = pointKey(x0, y0);
-        const b = pointKey(x1, y1);
-        if (a === b || edgeSet.has(ek(a, b)))
-            continue;
-        edgeSet.add(ek(a, b));
-        nodePos.set(a, [x0, y0]);
-        nodePos.set(b, [x1, y1]);
-        if (!adjK.has(a))
-            adjK.set(a, []);
-        if (!adjK.has(b))
-            adjK.set(b, []);
-        adjK.get(a).push(b);
-        adjK.get(b).push(a);
-    }
-    const used = new Set();
-    const chains = [];
-    const trace = (start, next) => {
-        const pts = [nodePos.get(start), nodePos.get(next)];
-        used.add(ek(start, next));
-        let prev = start;
-        let cur = next;
-        while (adjK.get(cur).length === 2) {
-            const nxt = adjK.get(cur).find((k) => k !== prev);
-            if (nxt === undefined || used.has(ek(cur, nxt)))
-                break;
-            used.add(ek(cur, nxt));
-            pts.push(nodePos.get(nxt));
-            prev = cur;
-            cur = nxt;
-        }
-        return pts;
-    };
-    for (const [k, nb] of adjK) {
-        if (nb.length === 2)
-            continue;
-        for (const n of nb)
-            if (!used.has(ek(k, n)))
-                chains.push({ pts: trace(k, n) });
-    }
-    for (const [k, nb] of adjK)
-        for (const n of nb)
-            if (!used.has(ek(k, n)))
-                chains.push({ pts: trace(k, n) });
-    for (const c of chains) {
-        const out = [c.pts[0]];
-        for (let i = 1; i + 1 < c.pts.length; i++) {
-            const [ax, ay] = out[out.length - 1];
-            const [bx, by] = c.pts[i];
-            const [cx, cy] = c.pts[i + 1];
-            const kept = protect?.has(pointKey(bx, by));
-            const cross = Math.abs((bx - ax) * (cy - ay) - (by - ay) * (cx - ax));
-            const len = Math.hypot(cx - ax, cy - ay) || 1;
-            // Drop a point only where the chain runs straight through it (within POINT_EPS): a few-cm jog
-            // is a corner, and a chord across it would be off every axis.
-            if (kept || cross / len > POINT_EPS)
-                out.push(c.pts[i]);
-        }
-        out.push(c.pts[c.pts.length - 1]);
-        c.pts = out.map((p) => [+p[0].toFixed(2), +p[1].toFixed(2)]);
-    }
-    return chains.filter((c) => c.pts.length >= 2);
-}
-/** How far off a frame axis a line may point and still run along it: about two degrees. */
-const AXIS_TAN = 0.035;
-/**
- * Which frame axis a direction runs along, if any.
- * @param frames The directions the layer is drawn in.
- * @param dx Direction x.
- * @param dy Direction y.
- * @returns The axis, or null off every axis.
- */
-function axisOf(frames, dx, dy) {
-    if (!frames.length)
-        return null;
-    const frame = nearestFrame(frames, dx, dy);
-    const [u, v] = toFrame(frames[frame], dx, dy);
-    if (Math.abs(v) <= AXIS_TAN * Math.abs(u))
-        return { frame, axis: 0, sign: Math.sign(u) };
-    if (Math.abs(u) <= AXIS_TAN * Math.abs(v))
-        return { frame, axis: 1, sign: Math.sign(v) };
-    return null;
-}
-/**
- * Joins the chains that continue one another through a shared end, and makes each straight stretch
- * one chord: an aisle is one line from end to end, the stubs meeting it end on its span, and two aisles
- * cross whole. Two pieces continue one another when they run along the same axis of the same frame
- * in opposite senses, or, off every axis, when the joint lies on the chord between its neighbors.
- * Every vertex a chord replaces is moved onto the chord, and so are the ends of the lines that stood
- * on it. A run then continues through the next run along its axis when nothing stands between them
- * on the floor: that run is pulled onto its line, longest runs first, so a line never starts where the
- * one before it could go on. The converter that builds wf.data.js cuts a line where another ends on
- * it or crosses it.
- * @param chains The chains, ends on shared vertices.
- * @param options The layer's directions and its free floor.
- * @returns The joined runs, and where the vertices they replaced now lie.
- */
-export function joinStraightRuns(chains, options = {}) {
-    const frames = options.frames ?? [];
-    const free = options.free ?? (() => true);
-    const runs = chains.map((c) => c.pts.map((p) => [p[0], p[1]]));
-    const owner = runs.map((_, i) => i);
-    const find = (i) => {
-        while (owner[i] !== i)
-            i = owner[i];
-        return i;
-    };
-    const meetings = new Map();
-    runs.forEach((pts, i) => {
-        if (!pts || pts.length < 2)
-            return;
-        for (const p of [pts[0], pts[pts.length - 1]]) {
-            const key = pointKey(p[0], p[1]);
-            meetings.set(key, [...(meetings.get(key) ?? []), i]);
-        }
-    });
-    // A run turned to end at `key`, and its point next to that end.
-    const endAt = (i, key) => {
-        const pts = runs[i];
-        const last = pts[pts.length - 1];
-        if (pointKey(last[0], last[1]) === key)
-            return { pts, next: pts[pts.length - 2] };
-        const first = pts[0];
-        if (pointKey(first[0], first[1]) === key)
-            return { pts: [...pts].reverse(), next: pts[1] };
-        return null;
-    };
-    // How far from straight two pieces meeting at a joint are: the angle between them, or Infinity.
-    const bend = (joint, a, c) => {
-        const [ax, ay] = [a[0] - joint[0], a[1] - joint[1]];
-        const [cx, cy] = [c[0] - joint[0], c[1] - joint[1]];
-        const la = Math.hypot(ax, ay);
-        const lc = Math.hypot(cx, cy);
-        if (!la || !lc)
-            return Infinity;
-        const sameAxis = (p, q) => p !== null && q !== null && p.frame === q.frame && p.axis === q.axis && p.sign === -q.sign;
-        const angle = Math.acos(Math.max(-1, Math.min(1, -(ax * cx + ay * cy) / (la * lc))));
-        if (sameAxis(axisOf(frames, ax, ay), axisOf(frames, cx, cy)))
-            return angle;
-        // Off the axes: straight through within a centimeter of the chord.
-        const len = Math.hypot(c[0] - a[0], c[1] - a[1]) || 1;
-        const off = Math.abs((joint[0] - a[0]) * (c[1] - a[1]) - (joint[1] - a[1]) * (c[0] - a[0])) / len;
-        const between = ax * cx + ay * cy < 0;
-        return off <= POINT_EPS && between ? angle : Infinity;
-    };
-    for (const key of [...meetings.keys()].sort()) {
-        // Every continuing pair at the meeting joins, straightest first: a crossing keeps both lines whole.
-        for (;;) {
-            const incident = [...new Set(meetings.get(key).map(find))];
-            let best = null;
-            for (let a = 0; a < incident.length; a++)
-                for (let b = a + 1; b < incident.length; b++) {
-                    const i = incident[a];
-                    const j = incident[b];
-                    const ei = endAt(i, key);
-                    const ej = endAt(j, key);
-                    if (!ei || !ej)
-                        continue;
-                    const angle = bend(ei.pts[ei.pts.length - 1], ei.next, ej.next);
-                    if (!isFinite(angle))
-                        continue;
-                    if (!best || angle < best.angle)
-                        best = { angle, i, j };
-                }
-            if (!best)
-                break;
-            const ei = endAt(best.i, key);
-            const ej = endAt(best.j, key);
-            runs[best.i] = [...ei.pts, ...[...ej.pts].reverse().slice(1)];
-            runs[best.j] = null;
-            owner[best.j] = best.i;
-        }
-    }
-    // Each straight stretch of a run becomes its chord; the vertices on it move onto the chord.
-    const moved = new Map();
-    const round = (p) => [+p[0].toFixed(2), +p[1].toFixed(2)];
-    // Each straight stretch of a run becomes its chord, a run of its own; the vertices on it move onto
-    // the chord, and the stretch carries their keys.
-    const stretches = [];
-    const onRun = [];
-    const straighten = (pts) => {
-        let from = 0;
-        for (let i = 1; i < pts.length; i++) {
-            const last = i === pts.length - 1;
-            if (!last && isFinite(bend(pts[i], pts[i - 1], pts[i + 1])))
-                continue;
-            const [ax, ay] = pts[from];
-            const [cx, cy] = pts[i];
-            const len2 = (cx - ax) ** 2 + (cy - ay) ** 2 || 1;
-            const keys = [];
-            for (let k = from + 1; k < i; k++) {
-                const [px, py] = pts[k];
-                const t = ((px - ax) * (cx - ax) + (py - ay) * (cy - ay)) / len2;
-                moved.set(pointKey(px, py), round([ax + t * (cx - ax), ay + t * (cy - ay)]));
-                keys.push(pointKey(px, py));
-            }
-            stretches.push([pts[from], pts[i]]);
-            onRun.push(keys);
-            from = i;
-        }
-    };
-    for (const pts of runs)
-        if (pts && pts.length >= 2)
-            straighten(pts);
-    const lanes = options.lane
-        ? mergeLanes(stretches, onRun, frames, free, options.lane, moved)
-        : stretches;
-    // A run's own ends may have stood on another run's chord; a run both ends meet at is gone.
-    const at = (p) => moved.get(pointKey(p[0], p[1])) ?? p;
-    return {
-        chains: lanes
-            .map((pts) => ({ pts: pts.map(at) }))
-            .filter(({ pts }) => Math.hypot(pts[1][0] - pts[0][0], pts[1][1] - pts[0][1]) > POINT_EPS),
-        moved,
-    };
-}
-/**
- * Pulls each straight run onto the line of the run it continues: the next run along the same axis,
- * when the floor between them is free. Longest runs first, so the longer line keeps its place and the
- * shorter one moves, together with every point that stood on it. Runs keep their authored points as
- * keys; where a point lies now is always read through `moved`.
- * @param runs The straight runs, two points each.
- * @param onRun The keys of the vertices each run's chords replaced.
- * @param frames The directions the layer is drawn in.
- * @param free Whether a segment lies on free floor.
- * @param lane How far aside, and how far ahead, a continuing run may start.
- * @param moved Where the vertices replaced so far lie; extended with every point pulled over.
- * @returns The runs left, the pulled ones merged into the lines they continue, ends where they lie now.
- */
-function mergeLanes(runs, onRun, frames, free, lane, moved) {
-    const keyOf = (p) => pointKey(p[0], p[1]);
-    const at = (p) => moved.get(keyOf(p)) ?? p;
-    // Each run's ends: the authored point (its key) and where it lies now.
-    const ends = runs.map((pts) => [pts[0], pts[pts.length - 1]].map((p) => ({ key: keyOf(p), raw: p })));
-    const now = (i) => ends[i].map((e) => at(e.raw));
-    const axis = runs.map((_, i) => {
-        const [a, c] = now(i);
-        return axisOf(frames, c[0] - a[0], c[1] - a[1]);
-    });
-    const length = (i) => {
-        const [a, c] = now(i);
-        return Math.hypot(c[0] - a[0], c[1] - a[1]);
-    };
-    const alive = runs.map(() => true);
-    const order = runs.map((_, i) => i).sort((a, b) => length(b) - length(a) || a - b);
-    const round = (p) => [+p[0].toFixed(2), +p[1].toFixed(2)];
-    // The keys of the points on each run's chords, carried along when the run is pulled over.
-    const carried = onRun.map((keys) => [...keys]);
-    // Runs by the keys of their ends, and by the keys on their chords: what a run takes along when it
-    // is pulled over.
-    const atKey = new Map();
-    const carriedBy = new Map();
-    ends.forEach((pair, i) => {
-        for (const e of pair)
-            atKey.set(e.key, [...(atKey.get(e.key) ?? []), i]);
-    });
-    carried.forEach((keys, i) => {
-        for (const key of keys)
-            carriedBy.set(key, [...(carriedBy.get(key) ?? []), i]);
-    });
-    // Whether everything B takes along can follow it onto A's line. A run ending on one of B's points
-    // follows only when it meets B square, and when the move lengthens it or it carries nothing: a run
-    // shortened could end before the points that stand on it. A run that carries one of B's ends on
-    // its chord would lose that point, so B stays.
-    const detachable = (b, project) => {
-        const [b0, b1] = now(b);
-        const follows = (was, r) => {
-            const [p, q] = now(r);
-            const dot = (q[0] - p[0]) * (b1[0] - b0[0]) + (q[1] - p[1]) * (b1[1] - b0[1]);
-            const lens = Math.hypot(q[0] - p[0], q[1] - p[1]) * Math.hypot(b1[0] - b0[0], b1[1] - b0[1]);
-            if (lens === 0 || Math.abs(dot) > AXIS_TAN * lens)
-                return false;
-            const other = keyOf(p) === keyOf(was) ? q : p;
-            const to = project(was);
-            const [wx, wy] = [was[0] - other[0], was[1] - other[1]];
-            const [tx, ty] = [to[0] - other[0], to[1] - other[1]];
-            if (tx * wx + ty * wy >= wx * wx + wy * wy)
-                return true;
-            return carried[r].length === 0 && tx * wx + ty * wy >= 0;
-        };
-        for (const e of ends[b]) {
-            if ((carriedBy.get(e.key) ?? []).some((r) => r !== b && alive[r]))
-                return false;
-            if (!(atKey.get(e.key) ?? []).every((r) => r === b || !alive[r] || follows(at(e.raw), r)))
-                return false;
-        }
-        for (const key of carried[b]) {
-            const was = moved.get(key);
-            if (!was)
-                continue;
-            if (!(atKey.get(key) ?? []).every((r) => r === b || !alive[r] || follows(was, r)))
-                return false;
-        }
-        return true;
-    };
-    let settled = false;
-    while (!settled) {
-        settled = true;
-        for (const a of order) {
-            if (!alive[a] || !axis[a])
-                continue;
-            for (;;) {
-                let merged = false;
-                for (const endIdx of [0, 1]) {
-                    const [p0, p1] = now(a);
-                    const end = endIdx === 1 ? p1 : p0;
-                    const start = endIdx === 1 ? p0 : p1;
-                    const len = Math.hypot(end[0] - start[0], end[1] - start[1]) || 1;
-                    const ux = (end[0] - start[0]) / len;
-                    const uy = (end[1] - start[1]) / len;
-                    const along = (p) => (p[0] - end[0]) * ux + (p[1] - end[1]) * uy;
-                    const aside = (p) => Math.abs((p[0] - end[0]) * uy - (p[1] - end[1]) * ux);
-                    const onLine = (s) => round([end[0] + ux * s, end[1] + uy * s]);
-                    let best = null;
-                    for (const b of order) {
-                        if (b === a || !alive[b] || !axis[b])
-                            continue;
-                        if (axis[b].frame !== axis[a].frame || axis[b].axis !== axis[a].axis)
-                            continue;
-                        const [q0, q1] = now(b);
-                        const near = Math.min(along(q0), along(q1));
-                        const far = Math.max(along(q0), along(q1));
-                        // B continues A: it starts at A's end or within a lane ahead, no farther aside than a lane,
-                        // and goes on from there. A run alongside A is a twin, not a continuation.
-                        if (near < -POINT_EPS || near > lane || far <= near)
-                            continue;
-                        if (Math.max(aside(q0), aside(q1)) > lane)
-                            continue;
-                        if (!detachable(b, (p) => onLine(along(p))))
-                            continue;
-                        if (!best || near < best.near)
-                            best = { b, near, far };
-                    }
-                    if (!best)
-                        continue;
-                    const [q0, q1] = now(best.b);
-                    const nearQ = along(q0) <= along(q1) ? q0 : q1;
-                    const farQ = nearQ === q0 ? q1 : q0;
-                    const nearP = onLine(Math.max(0, best.near));
-                    const farP = onLine(best.far);
-                    const seg = (p, q) => [
-                        p[0],
-                        p[1],
-                        q[0],
-                        q[1],
-                    ];
-                    // Free floor between the two: from B's ends across to A's line, along the gap, and along B
-                    // once pulled over.
-                    if (!free(seg(nearQ, onLine(best.near))) || !free(seg(farQ, farP)))
-                        continue;
-                    if (best.near > 0 && !free(seg(end, nearP)))
-                        continue;
-                    if (!free(seg(nearP, farP)))
-                        continue;
-                    // B's own ends and everything on its chord move onto A's line, keeping their keys.
-                    for (const key of [...ends[best.b].map((e) => e.key), ...carried[best.b]]) {
-                        const was = moved.get(key) ?? ends[best.b].find((e) => e.key === key).raw;
-                        moved.set(key, onLine(along(was)));
-                        carried[a].push(key);
-                        carriedBy.set(key, [...(carriedBy.get(key) ?? []).filter((r) => r !== best.b), a]);
-                    }
-                    // A now reaches B's far end: that end's key becomes A's, so later moves follow it.
-                    const farEnd = ends[best.b].find((e) => keyOf(at(e.raw)) === keyOf(farP)) ??
-                        ends[best.b][along(ends[best.b][0].raw) >= along(ends[best.b][1].raw) ? 0 : 1];
-                    atKey.set(ends[a][endIdx].key, (atKey.get(ends[a][endIdx].key) ?? []).filter((r) => r !== a));
-                    ends[a][endIdx] = farEnd;
-                    atKey.set(farEnd.key, [...(atKey.get(farEnd.key) ?? []), a]);
-                    moved.set(farEnd.key, farP);
-                    alive[best.b] = false;
-                    merged = true;
-                    settled = false;
-                }
-                if (!merged)
-                    break;
-            }
-        }
-    }
-    return runs.flatMap((_, i) => (alive[i] ? [now(i)] : []));
-}
-/**
- * Chains as segments, one per pair of neighboring points.
- * @param chains The chains.
- * @returns Their segments, in chain order.
- */
-export function chainSegments(chains) {
-    const segs = [];
-    for (const ch of chains)
-        for (let i = 0; i + 1 < ch.pts.length; i++)
-            segs.push([ch.pts[i][0], ch.pts[i][1], ch.pts[i + 1][0], ch.pts[i + 1][1]]);
-    return segs;
-}
-/**
- * Reads segments as a graph; vertices merge by point key.
- * @param segments The segments.
- * @returns The graph.
- */
-export function graphOf(segments) {
-    const nodeId = new Map();
-    const nodes = [];
-    const adj = [];
-    const edges = [];
-    const getNode = (x, y) => {
-        const k = pointKey(x, y);
-        let id = nodeId.get(k);
-        if (id === undefined) {
-            id = nodes.length;
-            nodeId.set(k, id);
-            nodes.push([x, y]);
-            adj.push([]);
-        }
-        return id;
-    };
-    const link = (u, v) => {
-        if (u === v)
-            return;
-        const d = Math.hypot(nodes[u][0] - nodes[v][0], nodes[u][1] - nodes[v][1]);
-        const eid = edges.length;
-        edges.push([u, v]);
-        adj[u].push([v, d, eid]);
-        adj[v].push([u, d, eid]);
-    };
-    for (const [x0, y0, x1, y1] of segments)
-        link(getNode(x0, y0), getNode(x1, y1));
-    return { nodes, adj, edges, nodeId };
-}
-/**
- * The connected pieces of a graph.
- * @param graph The graph.
- * @returns Each vertex's piece, by vertex id.
- */
-export function components(graph) {
-    const comp = new Int32Array(graph.nodes.length).fill(-1);
-    const stack = [];
-    let c = 0;
-    for (let s = 0; s < graph.nodes.length; s++) {
-        if (comp[s] >= 0)
-            continue;
-        stack.push(s);
-        comp[s] = c;
-        while (stack.length) {
-            const u = stack.pop();
-            for (const [v] of graph.adj[u])
-                if (comp[v] < 0) {
-                    comp[v] = c;
-                    stack.push(v);
-                }
-        }
-        c++;
-    }
-    return comp;
-}