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

package/dist/lib/runs.js

@@ -1,232 +0,0 @@
-// The straight runs of a raster path, and the line each one is laid on: the doorway's middle where
-// it passes one, its aisle's axis, else the middle of its corridor.
-import { alongAcross } from './axes.js';
-import { blockersNear } from './blockers.js';
-import { placeIn, toFrame } from './geom/frames.js';
-import { snapCm } from './geom/point-key.js';
-import { boundsOf } from './geom/primitives.js';
-/**
- * How far across a run may be pulled onto a line: a tip stands within the clearance of its aisle's
- * axis, and a run's cells are centered within half a pitch of what they pass.
- * @param cfg Network sizes.
- * @returns The distance.
- */
-export function pullOf(cfg) {
-    return cfg.clear + cfg.pitch / 2;
-}
-/**
- * A point in a run's coordinates.
- * @param run The run.
- * @param x Plan x.
- * @param y Plan y.
- * @returns Along the run, and across it.
- */
-export function runCoords(run, x, y) {
-    return alongAcross(run.frame, run.horiz, x, y);
-}
-/**
- * The point at a run's coordinates, on the centimeter grid.
- * @param run The run.
- * @param along Coordinate along the run.
- * @param across Coordinate across it.
- * @returns The point.
- */
-export function onRun(run, along, across) {
-    return run.horiz ? placeIn(run.frame, along, across) : placeIn(run.frame, across, along);
-}
-/**
- * The run's line at an across coordinate, from its first cell's center to its last's.
- * @param run The run.
- * @param c The across coordinate.
- * @returns The segment.
- */
-export function runLine(run, c) {
-    return [...onRun(run, run.lo, c), ...onRun(run, run.hi, c)];
-}
-/**
- * The unit direction the run was walked in.
- * @param run The run.
- * @returns The direction.
- */
-export function runDirection(run) {
-    const [x0, y0, x1, y1] = runLine(run, run.c);
-    const len = Math.hypot(x1 - x0, y1 - y0) || 1;
-    return [((x1 - x0) / len) * run.sign, ((y1 - y0) / len) * run.sign];
-}
-/**
- * The straight runs of a path: consecutive cells of one grid stepping the same way.
- * @param router The raster router the path was walked on.
- * @param cells The path.
- * @returns The runs.
- */
-export function runsOf(router, cells) {
-    const runs = [];
-    let cur = null;
-    for (let i = 0; i + 1 < cells.length; i++) {
-        const same = router.frameOf(cells[i]) === router.frameOf(cells[i + 1]);
-        const step = cells[i + 1] - cells[i];
-        // A grid change is no step: the run ends and the next starts on the other grid.
-        if (!same || Math.abs(step) === 0) {
-            cur = null;
-            continue;
-        }
-        if (cur?.step === step)
-            cur.cells.push(cells[i + 1]);
-        else {
-            cur = { grid: router.frameOf(cells[i]), step, cells: [cells[i], cells[i + 1]] };
-            runs.push(toRun(router, cur.grid, cur.cells));
-            runs[runs.length - 1].cells = cur.cells;
-        }
-    }
-    // Read again once the cells are complete.
-    return runs.map((run) => toRun(router, run.frame, run.cells));
-}
-/**
- * A run read from its cells: its frame, where it was walked across, and its reach along.
- * @param router The raster router.
- * @param frame The frame of the cells' grid.
- * @param cells The cells walked.
- * @returns The run.
- */
-function toRun(router, frame, cells) {
-    const [ux, uy] = router.worldOf(cells[0]);
-    const [vx, vy] = router.worldOf(cells[cells.length - 1]);
-    const [u0, v0] = toFrame(frame, ux, uy);
-    const [u1, v1] = toFrame(frame, vx, vy);
-    const horiz = Math.abs(u1 - u0) >= Math.abs(v1 - v0);
-    const walked = snapCm(horiz ? (v0 + v1) / 2 : (u0 + u1) / 2);
-    const a = horiz ? u0 : v0;
-    const b = horiz ? u1 : v1;
-    return {
-        frame,
-        horiz,
-        walked,
-        c: walked,
-        lo: Math.min(a, b),
-        hi: Math.max(a, b),
-        sign: b >= a ? 1 : -1,
-        cells,
-    };
-}
-/**
- * The doorway's middle a run passes through, as an across coordinate.
- * @param run The run.
- * @param doors The layer's doorways.
- * @param cfg Network sizes.
- * @param pull How far across a run may be pulled onto a line.
- * @returns The coordinate, or null when the run passes no doorway square on.
- */
-function doorMiddle(run, doors, cfg, pull) {
-    const seg = runLine(run, run.walked);
-    const box = [
-        Math.min(seg[0], seg[2]) - cfg.pitch,
-        Math.min(seg[1], seg[3]) - cfg.pitch,
-        Math.max(seg[0], seg[2]) + cfg.pitch,
-        Math.max(seg[1], seg[3]) + cfg.pitch,
-    ];
-    for (const door of doors) {
-        // The doorway's normal runs along the run, as the raster can tell over the doorway's width.
-        const width = Math.hypot(door.gap[2] - door.gap[0], door.gap[3] - door.gap[1]);
-        const [nu, nv] = toFrame(run.frame, door.nx, door.ny);
-        if ((run.horiz ? Math.abs(nv) : Math.abs(nu)) > cfg.cs / width)
-            continue;
-        const [mx, my] = door.mid;
-        if (mx < box[0] || mx > box[2] || my < box[1] || my > box[3])
-            continue;
-        const [at, c] = runCoords(run, mx, my);
-        if (at < run.lo - cfg.pitch || at > run.hi + cfg.pitch || Math.abs(c - run.walked) > pull)
-            continue;
-        return snapCm(c);
-    }
-    return null;
-}
-/**
- * The axis of the aisle a run lies in.
- * @param run The run.
- * @param axes The aisle axes the stub tips define.
- * @param pull How far across a run may be pulled onto a line.
- * @returns Its across coordinate, or null when the run lies in no aisle.
- */
-function aisleAxis(run, axes, pull) {
-    let best = null;
-    for (const axis of axes) {
-        if (axis.frame !== run.frame || axis.horiz !== run.horiz)
-            continue;
-        if (Math.abs(axis.c - run.walked) > pull)
-            continue;
-        if (axis.lo > run.hi || run.lo > axis.hi)
-            continue;
-        if (!best || Math.abs(axis.c - run.walked) < Math.abs(best.c - run.walked))
-            best = axis;
-    }
-    return best && snapCm(best.c);
-}
-/**
- * The middle of the corridor a run passes: between the nearest blockers either side along its
- * whole length. An open hall wider than the run is long has none.
- * @param run The run.
- * @param blockers Walls and solid outlines: a corridor's sides.
- * @param cfg Network sizes.
- * @returns The across coordinate, or null.
- */
-function corridorMiddle(run, blockers, cfg) {
-    const reach = run.hi - run.lo;
-    if (reach < 2 * cfg.clear)
-        return null;
-    const box = boundsOf([
-        onRun(run, run.lo, run.walked - reach),
-        onRun(run, run.lo, run.walked + reach),
-        onRun(run, run.hi, run.walked - reach),
-        onRun(run, run.hi, run.walked + reach),
-    ]);
-    let left = -Infinity;
-    let right = Infinity;
-    for (const { seg } of blockersNear(blockers, box)) {
-        const [a0, p0] = runCoords(run, seg[0], seg[1]);
-        const [a1, p1] = runCoords(run, seg[2], seg[3]);
-        let from = 0;
-        let to = 1;
-        if (a1 === a0) {
-            if (a0 <= run.lo || a0 >= run.hi)
-                continue;
-        }
-        else {
-            const t0 = (run.lo - a0) / (a1 - a0);
-            const t1 = (run.hi - a0) / (a1 - a0);
-            from = Math.max(0, Math.min(t0, t1));
-            to = Math.min(1, Math.max(t0, t1));
-            if (from >= to)
-                continue;
-        }
-        const q0 = p0 + (p1 - p0) * from;
-        const q1 = p0 + (p1 - p0) * to;
-        if (Math.max(q0, q1) < run.walked)
-            left = Math.max(left, Math.max(q0, q1));
-        else if (Math.min(q0, q1) > run.walked)
-            right = Math.min(right, Math.min(q0, q1));
-    }
-    return right - left > reach ? null : snapCm((left + right) / 2);
-}
-/**
- * Lays a run where its place says: a doorway's middle, its aisle's axis, its corridor's middle,
- * else where it was walked.
- * @param run The run; `c` is set.
- * @param place What the runs are laid on.
- * @param cfg Network sizes.
- * @param mayLay Whether a line may be laid.
- */
-export function placeRun(run, place, cfg, mayLay) {
-    const pull = pullOf(cfg);
-    for (const c of [
-        doorMiddle(run, place.doors, cfg, pull),
-        aisleAxis(run, place.axes, pull),
-        corridorMiddle(run, place.blockers, cfg),
-    ]) {
-        if (c === null)
-            continue;
-        if (c === run.walked || mayLay(runLine(run, c))) {
-            run.c = c;
-            return;
-        }
-    }
-}

package/dist/lib/scale.d.ts

@@ -1,58 +0,0 @@
-import type { RouteNetwork } from './graph-types.js';
-import type { TransitionOrphan } from './transitions.js';
-import type { SourceDestination, WayfindingSource, WfV1Graph } from './types.js';
-import type { WalkableArea } from './walkable.js';
-/**
- * Decimals of an emitted plan coordinate: two — 1 cm in meters, 3 mm in feet — and more where a plan
- * unit is longer than a meter, so a step is never coarser than the centimeter node grid and rounding
- * only merges points the network already merged. At most twenty: a double holds no more, and
- * `toFixed` throws past a hundred.
- * @param unitsPerMeter Plan units per meter.
- * @returns The decimals to keep.
- */
-export declare function planDecimals(unitsPerMeter: number): number;
-/**
- * The plan in meters. Every threshold is in meters, so the plan is converted once on the way in and once
- * on the way out. A plan already in meters is rounded the same way.
- * @param source The plan in its own units.
- * @param unitsPerMeter Plan coordinates in one meter.
- * @returns The same plan with every coordinate in meters.
- */
-export declare function sourceInMeters(source: WayfindingSource, unitsPerMeter: number): WayfindingSource;
-/**
- * A walkable area in the other measure. Its `area` stat is a surface, so it moves by the square.
- * @param area The artifact to convert.
- * @param factor Coordinates in the target measure per coordinate in the current one.
- * @param round Round to plan precision — true on the way out.
- * @returns The converted artifact.
- */
-export declare function walkableScaled(area: WalkableArea, factor: number, round: boolean): WalkableArea;
-/**
- * A route network back in the plan's own units.
- * @param network The artifact to convert.
- * @param unitsPerMeter Plan coordinates in one meter.
- * @returns The converted artifact.
- */
-export declare function networkInPlanUnits(network: RouteNetwork, unitsPerMeter: number): RouteNetwork;
-/**
- * The destinations as the stages saw them, back in the plan's own units.
- * @param destinations The carved footprints.
- * @param unitsPerMeter Plan coordinates in one meter.
- * @returns The converted destinations.
- */
-export declare function destinationsInPlanUnits(destinations: readonly SourceDestination[], unitsPerMeter: number): SourceDestination[];
-/**
- * Transition stops that never reached the graph, back in plan units.
- * @param orphans The stops, in meters.
- * @param unitsPerMeter Plan coordinates in one meter.
- * @returns The stops in plan coordinates.
- */
-export declare function orphansInPlanUnits(orphans: readonly TransitionOrphan[], unitsPerMeter: number): readonly TransitionOrphan[];
-/**
- * The emitted graph back in the plan's own units — what the host snaps its POI to.
- * @param graph The graph as compiled, in meters.
- * @param unitsPerMeter Plan coordinates in one meter.
- * @returns The graph in plan coordinates.
- */
-export declare function graphInPlanUnits(graph: WfV1Graph, unitsPerMeter: number): WfV1Graph;
-//# sourceMappingURL=scale.d.ts.map

package/dist/lib/scale.js

@@ -1,185 +0,0 @@
-/** The most decimals a plan coordinate keeps. */
-const MAX_PLAN_DECIMALS = 20;
-/**
- * Decimals of an emitted plan coordinate: two — 1 cm in meters, 3 mm in feet — and more where a plan
- * unit is longer than a meter, so a step is never coarser than the centimeter node grid and rounding
- * only merges points the network already merged. At most twenty: a double holds no more, and
- * `toFixed` throws past a hundred.
- * @param unitsPerMeter Plan units per meter.
- * @returns The decimals to keep.
- */
-export function planDecimals(unitsPerMeter) {
-    return Math.min(MAX_PLAN_DECIMALS, Math.max(2, Math.ceil(2 - Math.log10(unitsPerMeter))));
-}
-/**
- * Decimals kept in meters — a micron. Rounding off the division's last bits makes the same drawing in feet
- * and in meters reach the stages as identical numbers, so boundary comparisons agree.
- */
-const METER_DECIMALS = 6;
-function place(v, factor, round) {
-    const scaled = v * factor;
-    return +scaled.toFixed(round ? planDecimals(factor) : METER_DECIMALS);
-}
-function scaleRing(ring, factor, round) {
-    return ring.map(([x, y]) => [place(x, factor, round), place(y, factor, round)]);
-}
-function scaleFlat(flat, factor, round) {
-    return flat.map((v) => place(v, factor, round));
-}
-function scaleDestination(d, factor, round) {
-    return {
-        ...d,
-        polygon: scaleRing(d.polygon, factor, round),
-        ...(d.parts && { parts: d.parts.map((part) => scaleRing(part, factor, round)) }),
-        ...(d.dock && { dock: scaleRing(d.dock, factor, round) }),
-    };
-}
-function scaleLayer(layer, factor) {
-    return {
-        ...layer,
-        walls: layer.walls.map((flat) => scaleFlat(flat, factor, false)),
-        destinations: layer.destinations.map((d) => scaleDestination(d, factor, false)),
-    };
-}
-function scaleTransition(transition, factor) {
-    return {
-        ...transition,
-        points: transition.points.map((point) => ({
-            ...point,
-            x: place(point.x, factor, false),
-            y: place(point.y, factor, false),
-        })),
-    };
-}
-/**
- * The plan in meters. Every threshold is in meters, so the plan is converted once on the way in and once
- * on the way out. A plan already in meters is rounded the same way.
- * @param source The plan in its own units.
- * @param unitsPerMeter Plan coordinates in one meter.
- * @returns The same plan with every coordinate in meters.
- */
-export function sourceInMeters(source, unitsPerMeter) {
-    const factor = 1 / unitsPerMeter;
-    return {
-        ...source,
-        layers: source.layers.map((layer) => scaleLayer(layer, factor)),
-        ...(source.transitions && {
-            transitions: source.transitions.map((t) => scaleTransition(t, factor)),
-        }),
-    };
-}
-/**
- * A walkable area in the other measure. Its `area` stat is a surface, so it moves by the square.
- * @param area The artifact to convert.
- * @param factor Coordinates in the target measure per coordinate in the current one.
- * @param round Round to plan precision — true on the way out.
- * @returns The converted artifact.
- */
-export function walkableScaled(area, factor, round) {
-    if (factor === 1)
-        return area;
-    const line = (wall) => ({
-        ...wall,
-        points: scaleRing([...wall.points], factor, round),
-    });
-    return {
-        rings: area.rings.map((ring) => scaleRing(ring, factor, round)),
-        outline: area.outline.map((ring) => scaleRing(ring, factor, round)),
-        wallStrips: area.wallStrips.map((ring) => scaleRing(ring, factor, round)),
-        wallLines: area.wallLines.map(line),
-        stats: {
-            ...area.stats,
-            area: +(area.stats.area * factor * factor).toFixed(1),
-            ...(area.stats.areaExact !== undefined && {
-                areaExact: area.stats.areaExact * factor * factor,
-            }),
-        },
-    };
-}
-/**
- * A route network back in the plan's own units.
- * @param network The artifact to convert.
- * @param unitsPerMeter Plan coordinates in one meter.
- * @returns The converted artifact.
- */
-export function networkInPlanUnits(network, unitsPerMeter) {
-    if (unitsPerMeter === 1)
-        return network;
-    const at = ([x, y]) => [x * unitsPerMeter, y * unitsPerMeter];
-    const anatomy = network.anatomy && {
-        unit: unitsPerMeter,
-        doors: network.anatomy.doors.map((d) => ({
-            gap: [at(d.gap[0]), at(d.gap[1])],
-            mid: at(d.mid),
-        })),
-        anchors: network.anatomy.anchors.map((a) => ({ ...a, at: at(a.at) })),
-        ways: network.anatomy.ways.map((w) => ({ ...w, foot: at(w.foot) })),
-        whiskers: network.anatomy.whiskers.map((w) => ({ ...w, foot: at(w.foot), tip: at(w.tip) })),
-        frames: network.anatomy.frames.map((f) => ({ ...f, box: f.box.map(at) })),
-        loose: network.anatomy.loose,
-        axes: network.anatomy.axes.map((a) => ({ ...a, from: at(a.from), to: at(a.to) })),
-    };
-    const point = ([x, y]) => [
-        place(x, unitsPerMeter, true),
-        place(y, unitsPerMeter, true),
-    ];
-    return {
-        ...network,
-        ...(anatomy && { anatomy }),
-        paths: network.paths.map((path) => path.map(point)),
-        docks: network.docks.map((dock) => ({
-            ...dock,
-            from: point(dock.from),
-            to: point(dock.to),
-        })),
-        stats: {
-            ...network.stats,
-            unreached: network.stats.unreached.map((u) => (u.at ? { ...u, at: point(u.at) } : u)),
-        },
-    };
-}
-/**
- * The destinations as the stages saw them, back in the plan's own units.
- * @param destinations The carved footprints.
- * @param unitsPerMeter Plan coordinates in one meter.
- * @returns The converted destinations.
- */
-export function destinationsInPlanUnits(destinations, unitsPerMeter) {
-    if (unitsPerMeter === 1)
-        return [...destinations];
-    return destinations.map((d) => scaleDestination(d, unitsPerMeter, true));
-}
-/**
- * Transition stops that never reached the graph, back in plan units.
- * @param orphans The stops, in meters.
- * @param unitsPerMeter Plan coordinates in one meter.
- * @returns The stops in plan coordinates.
- */
-export function orphansInPlanUnits(orphans, unitsPerMeter) {
-    if (unitsPerMeter === 1)
-        return orphans;
-    return orphans.map((orphan) => ({
-        ...orphan,
-        x: place(orphan.x, unitsPerMeter, true),
-        y: place(orphan.y, unitsPerMeter, true),
-    }));
-}
-/**
- * The emitted graph back in the plan's own units — what the host snaps its POI to.
- * @param graph The graph as compiled, in meters.
- * @param unitsPerMeter Plan coordinates in one meter.
- * @returns The graph in plan coordinates.
- */
-export function graphInPlanUnits(graph, unitsPerMeter) {
-    if (unitsPerMeter === 1)
-        return graph;
-    const point = (p) => ({
-        ...p,
-        x: place(p.x, unitsPerMeter, true),
-        y: place(p.y, unitsPerMeter, true),
-    });
-    return {
-        lines: graph.lines.map((line) => ({ ...line, p0: point(line.p0), p1: point(line.p1) })),
-        lineEnds: graph.lineEnds.map(point),
-    };
-}

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

@@ -1,19 +0,0 @@
-import type { Ring } from './geom/types.js';
-import { type PreparedWalls } from './geom/walls.js';
-import { type RouteNetwork, type RouteNetworkDestination } from './graph-types.js';
-import type { Opening } from './openings.js';
-/**
- * Builds the steiner route network for one layer.
- * @param walkableRings The layer's walkable polygon (outer rings + holes).
- * @param destinations Footprints the network must reach.
- * @param walls Raw wall polylines as flat `[x0, y0, …]` runs, for exact thin-wall blocking.
- * @param prepared The same walls already prepared, when the caller has them.
- * @param drawn The rest of each destination's drawing; ways in may not cross it.
- * @param openings The openings the entrances make: the ways in they own, through the walls.
- * @returns Paths, docks and stats for `emit-v1`.
- */
-export declare function buildSteinerNetwork(walkableRings: readonly Ring[], destinations: readonly RouteNetworkDestination[], walls: readonly (readonly number[])[], prepared?: PreparedWalls, drawn?: readonly {
-    readonly id: string;
-    readonly ring: Ring;
-}[], openings?: readonly Opening[]): RouteNetwork;
-//# sourceMappingURL=steiner-network.d.ts.map

package/dist/lib/steiner-network.js

@@ -1,183 +0,0 @@
-// The "steiner" route-network generator: the network of a layer, along the directions the plan is
-// drawn in. A square stub per open face ends in the middle of the aisle ahead; the tips of an aisle
-// define its axis, and the aisle's line is laid through them. One demand growth over an eroded raster
-// then joins the pieces and the lone tips across the floor, each path laid on the lines its place
-// defines; dangling ends run on to the line ahead, and a link cuts across where the network would
-// send a visitor the long way round. Produces the {@link RouteNetwork} for `emit-v1`.
-import { attachStubs } from './attach.js';
-import { blockersOf, crossesBlocker } from './blockers.js';
-import { createConnector } from './connect.js';
-import { DOOR_WELD, doorOwners, doorwaySides, findDoorways } from './doorways.js';
-import { emitNetwork, turnDoorwayDocks } from './emit-network.js';
-import { followTips, tipPoints } from './entries.js';
-import { floorGrids, servedFloor } from './floor-grids.js';
-import { frameTips } from './framing.js';
-import { placeIn } from './geom/frames.js';
-import { pointKey } from './geom/point-key.js';
-import { boundsOf } from './geom/primitives.js';
-import { prepareWalls } from './geom/walls.js';
-import { NETWORK_SIZES } from './network-sizes.js';
-import { NetworkStore } from './network-store.js';
-import { completeLines, dropDeadEnds, shortcutDetours } from './post-passes.js';
-import { makeRouter } from './router.js';
-import { defineAxes, planStubs, runStubsToAxes } from './stubs.js';
-/**
- * Builds the steiner route network for one layer.
- * @param walkableRings The layer's walkable polygon (outer rings + holes).
- * @param destinations Footprints the network must reach.
- * @param walls Raw wall polylines as flat `[x0, y0, …]` runs, for exact thin-wall blocking.
- * @param prepared The same walls already prepared, when the caller has them.
- * @param drawn The rest of each destination's drawing; ways in may not cross it.
- * @param openings The openings the entrances make: the ways in they own, through the walls.
- * @returns Paths, docks and stats for `emit-v1`.
- */
-export function buildSteinerNetwork(walkableRings, destinations, walls, prepared, drawn = [], openings = []) {
-    const cfg = NETWORK_SIZES;
-    const prep = prepared ?? prepareWalls(walls);
-    const wallLines = prep.segments;
-    const doors = findDoorways(prep, destinations);
-    const owners = doorOwners(doors, destinations, wallLines, cfg);
-    // An entrance owns its openings and is reached through them alone. An opening on a doorway the
-    // walls already leave is that doorway; any other stands on the floor past the wall, and the dock
-    // from it crosses the wall inside the opening's span.
-    const opened = new Set();
-    const passes = new Map();
-    for (const { id, at, span, door } of openings) {
-        const same = doors.find((d) => Math.hypot(d.mid[0] - at[0], d.mid[1] - at[1]) <= DOOR_WELD);
-        const flip = same && same.nx * door.nx + same.ny * door.ny < 0 ? -1 : 1;
-        const sides = owners.get(id) ?? [];
-        sides.push(same
-            ? { door: same, nx: same.nx * flip, ny: same.ny * flip }
-            : { door, nx: door.nx, ny: door.ny });
-        owners.set(id, sides);
-        opened.add(id);
-        passes.set(id, [...(passes.get(id) ?? []), span]);
-    }
-    const { rings: floor, dropped: unservedFloorPieces } = servedFloor(walkableRings, destinations, owners);
-    // Only a doorway's middle stays open, so every pass draws lines through it there.
-    const doorSides = doorwaySides(doors, cfg);
-    const { grids, frames, frameOfDest } = floorGrids(floor, doorSides, destinations, wallLines, doors, cfg);
-    // On-floor tests use the plan's grid.
-    const ctx = grids[0].ctx;
-    const router = makeRouter(grids, cfg);
-    const store = new NetworkStore();
-    // A doorway's closed sides block stubs and docks like walls.
-    const blockers = blockersOf(destinations, [...wallLines, ...doorSides], doors, drawn, new Set(owners.keys()), passes);
-    const destinationOf = new Map(destinations.map((d) => [d.id, d]));
-    // The floor's own size: nothing on the layer reaches farther.
-    const floorBounds = boundsOf(floor.flat());
-    const floorSpan = isFinite(floorBounds[0])
-        ? Math.hypot(floorBounds[2] - floorBounds[0], floorBounds[3] - floorBounds[1])
-        : cfg.stub;
-    /** Why a destination has no stub yet: the furthest stage any of its ways in reached. */
-    const failed = new Map();
-    // Reasons from least to most informative; a destination keeps the most informative one.
-    const REACHED = [
-        'no-way-in',
-        'no-floor',
-        'cut-off',
-        'way-in-blocked',
-        'detached',
-    ];
-    const note = (id, reason, facts) => {
-        const known = failed.get(id);
-        if (known === undefined || REACHED.indexOf(reason) > REACHED.indexOf(known.reason))
-            failed.set(id, { id, reason, ...facts });
-    };
-    const build = { cfg, frames, blockers, destinationOf, note };
-    /* ---- stubs: one per open side of each destination, ending mid-aisle ---- */
-    const plan = planStubs({ ...build, destinations, owners, ctx, frameOfDest, opened });
-    const { stubs } = plan;
-    /* ---- aisle axes: the lines the tips define; each stub runs to its aisle's axis ---- */
-    // Crossable destinations frame nothing: their stubs join whatever line is there.
-    const through = new Set(destinations.filter((d) => d.crossable).map((d) => d.id));
-    const { axes, axisOf } = defineAxes(plan, build, through, floorSpan);
-    runStubsToAxes(axisOf, build, ctx);
-    // Where a line may go: on the floor, across no wall or outline, and — once the stubs are attached —
-    // across no stub short of its tip: a route would walk past that destination and back.
-    let attached = null;
-    const mayLay = (seg) => ctx.lineFree(seg[0], seg[1], seg[2], seg[3]) &&
-        !crossesBlocker(blockers, seg) &&
-        (attached === null || !crossesBlocker(attached, seg));
-    /* ---- rows along the axes, perimeters and corners: the block grids ---- */
-    frameTips(store, stubs.filter((s) => !through.has(s.id)), destinations, mayLay, frames, axisOf, cfg.cs, 2 * cfg.clear);
-    followTips(stubs, store.node(tipPoints(stubs)));
-    /* ---- growth: every piece and every lone tip joined across the floor ---- */
-    const connector = createConnector(store, router, cfg, { frames, axes, doors, blockers, mayLay });
-    const lone = stubs.filter((s) => !store.hasNode(s.tx, s.ty));
-    const targets = new Map(lone.map((s) => [s, { at: [s.tx, s.ty], normal: [s.nx, s.ny], frame: s.frame ?? frames[0] }]));
-    const { untied } = connector.connect([...targets.values()]);
-    // Anatomy for the debug overlay.
-    const anatomyDoors = doors.map((d) => ({
-        gap: [
-            [d.gap[0], d.gap[1]],
-            [d.gap[2], d.gap[3]],
-        ],
-        mid: [d.mid[0], d.mid[1]],
-    }));
-    const anatomyAnchors = [...targets].map(([s, t]) => ({ id: s.id, at: t.at }));
-    const anatomyWays = [];
-    for (const [id, list] of plan.ways)
-        for (const w of list)
-            anatomyWays.push({ id, kind: w.kind, foot: [w.mx, w.my], normal: [w.nx, w.ny] });
-    // Each turned grid's outline and who is drawn in its direction; the rest turned alone.
-    const anatomyFrames = grids.slice(1).map(({ frame, ctx: grid }) => {
-        const [u0, v0] = [grid.ox, grid.oy];
-        const [u1, v1] = [grid.ox + grid.w * grid.cs, grid.oy + grid.h * grid.cs];
-        return {
-            angle: Math.atan2(frame.sin, frame.cos),
-            box: [
-                placeIn(frame, u0, v0),
-                placeIn(frame, u1, v0),
-                placeIn(frame, u1, v1),
-                placeIn(frame, u0, v1),
-            ],
-            ids: destinations.filter((d) => frameOfDest(d) === frame).map((d) => d.id),
-        };
-    });
-    const anatomyLoose = destinations.filter((d) => !frameOfDest(d)).map((d) => d.id);
-    const anatomyAxes = axes.map((axis) => {
-        const put = (along) => axis.horiz ? placeIn(axis.frame, along, axis.c) : placeIn(axis.frame, axis.c, along);
-        const angle = Math.atan2(axis.frame.sin, axis.frame.cos) + (axis.horiz ? 0 : Math.PI / 2);
-        return { angle, from: put(axis.lo), to: put(axis.hi) };
-    });
-    /* ---- attach: each stub ends where it first meets the network, or a link takes it there ---- */
-    const whiskers = attachStubs({ ...build, plan, store, connector, router, mayLay });
-    followTips(whiskers, store.node(tipPoints(whiskers)));
-    // A line that ends nowhere serves nothing: growth reached tips whose stubs then met a nearer line.
-    dropDeadEnds(store, new Set(whiskers.map((w) => pointKey(w.tx, w.ty))));
-    attached = blockersOf([], whiskers.map((w) => [w.mx, w.my, w.tx, w.ty]), []);
-    /* ---- dangling ends run on to the line ahead; links cut across detours ---- */
-    completeLines(store, connector, mayLay, frames);
-    const shortcuts = shortcutDetours(store, router, connector);
-    turnDoorwayDocks(whiskers, build, store);
-    const anatomyWhiskers = whiskers.map((w) => ({
-        id: w.id,
-        kind: w.kind,
-        foot: [w.mx, w.my],
-        tip: [w.tx, w.ty],
-    }));
-    /* ---- emit the RouteNetwork artifact ---- */
-    const emitted = emitNetwork({ ...build, store, whiskers, destinations, failed, doors });
-    return {
-        paths: emitted.paths,
-        docks: emitted.docks,
-        anatomy: {
-            doors: anatomyDoors,
-            anchors: anatomyAnchors,
-            ways: anatomyWays,
-            whiskers: anatomyWhiskers,
-            frames: anatomyFrames,
-            loose: anatomyLoose,
-            axes: anatomyAxes,
-        },
-        stats: {
-            unreached: emitted.unreached,
-            components: emitted.components,
-            doorways: doors.length,
-            shortcuts,
-            ...(untied > 0 && { untiedPieces: untied }),
-            ...(unservedFloorPieces > 0 && { unservedFloorPieces }),
-        },
-    };
-}