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

package/dist/lib/strip.d.ts

@@ -1,43 +0,0 @@
-import { type Blockers } from './blockers.js';
-import type { Segment, Vec2 } from './geom/types.js';
-/**
- * The longest stretch of an edge with a person's width of free strip outside it, computed exactly from
- * the blockers crossing that strip. The destination's own outline is ignored.
- * @param edge The edge.
- * @param inward Its inward unit normal.
- * @param blockers What stands around it.
- * @param ownId Destination the edge belongs to.
- * @returns `[from, to]` in `[0, 1]`; empty when nothing is free.
- */
-export declare function freeRunOf(edge: Segment, inward: Vec2, blockers: Blockers, ownId: string): [number, number];
-/**
- * How far the aisle in front of an edge reaches: the height, along the outward normal, at which what
- * stands across — other destinations' outlines, and wall lines (their doorways included) that a
- * destination entered through doorways lines within a person's width behind them, a walled booth's or
- * a room row's — covers half the edge's width or more, each counted at its nearest point. A room
- * corner or a gap in the row across before a part of the edge does not set the aisle, and a hall wall
- * has no row across, whatever stands with its back to it.
- * @param edge The edge.
- * @param outward Its outward unit normal.
- * @param blockers What stands around it.
- * @param ownId Destination the edge belongs to.
- * @param limit How far in front to look; the strip ends there.
- * @returns The height and the destinations across, or `Infinity` and none when nothing stands across
- * half the edge within `limit`.
- */
-export declare function frontDepth(edge: Segment, outward: Vec2, blockers: Blockers, ownId: string, limit: number): {
-    depth: number;
-    across: string[];
-};
-/**
- * How far the strip in front of an edge is free: to the nearest wall, outline or doorway gap before any
- * part of it.
- * @param edge The edge.
- * @param outward Its outward unit normal.
- * @param blockers What stands around it.
- * @param ownId Destination the edge belongs to; empty for none.
- * @param limit How far in front to look.
- * @returns The height, or `Infinity` when the strip is free within `limit`.
- */
-export declare function stripDepth(edge: Segment, outward: Vec2, blockers: Blockers, ownId: string, limit: number): number;
-//# sourceMappingURL=strip.d.ts.map

package/dist/lib/strip.js

@@ -1,200 +0,0 @@
-// The strip in front of an edge: how far it is free, and what stands across it.
-import { blockerGrid, BlockerKind } from './blockers.js';
-import { POINT_EPS } from './geom/point-key.js';
-import { boundsOf } from './geom/primitives.js';
-import { NODE_SNAP } from './graph-types.js';
-import { MIN_PASS } from './network-sizes.js';
-/**
- * The longest stretch of an edge with a person's width of free strip outside it, computed exactly from
- * the blockers crossing that strip. The destination's own outline is ignored.
- * @param edge The edge.
- * @param inward Its inward unit normal.
- * @param blockers What stands around it.
- * @param ownId Destination the edge belongs to.
- * @returns `[from, to]` in `[0, 1]`; empty when nothing is free.
- */
-export function freeRunOf(edge, inward, blockers, ownId) {
-    const ex = edge[2] - edge[0];
-    const ey = edge[3] - edge[1];
-    const span = ex * ex + ey * ey;
-    if (!span)
-        return [0, 0];
-    const reach = 2 * MIN_PASS;
-    // Stretches of the edge (as fractions) shaded by a blocker.
-    const shaded = [];
-    // Only blockers within the strip's box can shade the edge.
-    const bx0 = Math.min(edge[0], edge[2]) - reach;
-    const bx1 = Math.max(edge[0], edge[2]) + reach;
-    const by0 = Math.min(edge[1], edge[3]) - reach;
-    const by1 = Math.max(edge[1], edge[3]) + reach;
-    const shade = (seg) => {
-        const ta = ((seg[0] - edge[0]) * ex + (seg[1] - edge[1]) * ey) / span;
-        const tb = ((seg[2] - edge[0]) * ex + (seg[3] - edge[1]) * ey) / span;
-        const ha = -((seg[0] - edge[0]) * inward[0] + (seg[1] - edge[1]) * inward[1]);
-        const hb = -((seg[2] - edge[0]) * inward[0] + (seg[3] - edge[1]) * inward[1]);
-        if ((ha < 0 && hb < 0) || (ha > reach && hb > reach))
-            return;
-        let ua = ta;
-        let ub = tb;
-        // Clip the blocker to the strip.
-        if (ha !== hb) {
-            const at = (h) => ta + ((tb - ta) * (h - ha)) / (hb - ha);
-            ua = at(Math.max(0, Math.min(ha, hb)));
-            ub = at(Math.min(reach, Math.max(ha, hb)));
-        }
-        const lo = Math.max(0, Math.min(ua, ub));
-        const hi = Math.min(1, Math.max(ua, ub));
-        if (hi > lo)
-            shaded.push([lo, hi]);
-    };
-    const grid = blockerGrid(blockers);
-    for (const i of grid.near(bx0, by0, bx1, by1))
-        if (grid.from[i] === BlockerKind.Wall ||
-            (grid.from[i] === BlockerKind.Solid && grid.owner[i] !== ownId))
-            shade(grid.segs[i]);
-    shaded.sort((a, b) => a[0] - b[0]);
-    let walked = 0;
-    let best = [0, 0];
-    for (const [lo, hi] of shaded) {
-        if (lo > walked && lo - walked > best[1] - best[0])
-            best = [walked, lo];
-        walked = Math.max(walked, hi);
-    }
-    if (1 - walked > best[1] - best[0])
-        best = [walked, 1];
-    return best;
-}
-/**
- * The blockers in the strip in front of an edge, each as the share of the edge's width it stands before
- * and its nearest height along the outward normal, nearest first. Exact, from the segments; the edge's
- * own destination's outline, and anything on the edge or behind it, is left out.
- * @param edge The edge.
- * @param outward Its outward unit normal.
- * @param blockers What stands around it.
- * @param ownId Destination the edge belongs to.
- * @param far How far in front the strip reaches.
- * @returns The parts.
- */
-function stripParts(edge, outward, blockers, ownId, far) {
-    const ex = edge[2] - edge[0];
-    const ey = edge[3] - edge[1];
-    const span = ex * ex + ey * ey;
-    if (!span || !(far > 0))
-        return [];
-    const reach = Math.min(far, 1e6);
-    const box = boundsOf([
-        [edge[0], edge[1]],
-        [edge[2], edge[3]],
-        [edge[0] + outward[0] * reach, edge[1] + outward[1] * reach],
-        [edge[2] + outward[0] * reach, edge[3] + outward[1] * reach],
-    ]);
-    const grid = blockerGrid(blockers);
-    const parts = [];
-    for (const i of grid.near(...box)) {
-        if (grid.from[i] === BlockerKind.Solid && grid.owner[i] === ownId)
-            continue;
-        const seg = grid.segs[i];
-        // Along the edge (as a share of its length) and in front of it (as a height), at both ends.
-        const ta = ((seg[0] - edge[0]) * ex + (seg[1] - edge[1]) * ey) / span;
-        const tb = ((seg[2] - edge[0]) * ex + (seg[3] - edge[1]) * ey) / span;
-        const ha = (seg[0] - edge[0]) * outward[0] + (seg[1] - edge[1]) * outward[1];
-        const hb = (seg[2] - edge[0]) * outward[0] + (seg[3] - edge[1]) * outward[1];
-        // Square to the edge, it stands before none of its width.
-        if (ta === tb)
-            continue;
-        // The share of the edge the segment stands before, and the segment's own parameters there:
-        // heights are read over that visible part alone.
-        const s0 = Math.max(0, Math.min(ta, tb));
-        const s1 = Math.min(1, Math.max(ta, tb));
-        if (s0 >= s1)
-            continue;
-        const at = (t) => (t - ta) / (tb - ta);
-        const h0 = ha + (hb - ha) * at(s0);
-        const h1 = ha + (hb - ha) * at(s1);
-        const low = Math.min(h0, h1);
-        // On the edge or behind it, or reaching down to it: the edge of a neighbor, not a stand ahead.
-        if (low <= NODE_SNAP)
-            continue;
-        parts.push({ s0, s1, h: low, from: grid.from[i], owner: grid.owner[i] });
-    }
-    return parts.sort((a, b) => a.h - b.h);
-}
-/**
- * How far the aisle in front of an edge reaches: the height, along the outward normal, at which what
- * stands across — other destinations' outlines, and wall lines (their doorways included) that a
- * destination entered through doorways lines within a person's width behind them, a walled booth's or
- * a room row's — covers half the edge's width or more, each counted at its nearest point. A room
- * corner or a gap in the row across before a part of the edge does not set the aisle, and a hall wall
- * has no row across, whatever stands with its back to it.
- * @param edge The edge.
- * @param outward Its outward unit normal.
- * @param blockers What stands around it.
- * @param ownId Destination the edge belongs to.
- * @param limit How far in front to look; the strip ends there.
- * @returns The height and the destinations across, or `Infinity` and none when nothing stands across
- * half the edge within `limit`.
- */
-export function frontDepth(edge, outward, blockers, ownId, limit) {
-    const lining = 2 * MIN_PASS;
-    const parts = stripParts(edge, outward, blockers, ownId, limit + lining);
-    const liner = (wall) => parts.find((p) => p.from === BlockerKind.Solid &&
-        blockers.walled.has(p.owner) &&
-        p.h >= wall.h &&
-        p.h - wall.h <= lining &&
-        p.s0 < wall.s1 &&
-        wall.s0 < p.s1);
-    const across = [];
-    for (const p of parts) {
-        // The wall the free run stopped at lies exactly at the limit: a hair of float noise may not
-        // hide the aisle's own far side.
-        if (p.h > limit + POINT_EPS)
-            continue;
-        if (p.from === BlockerKind.Solid)
-            across.push(p);
-        else {
-            // A wall line and its doorways: the far side of a corridor of rooms.
-            const room = liner(p);
-            if (room)
-                across.push({ ...p, owner: room.owner });
-        }
-    }
-    // Nearest first, until what stands across covers half the edge.
-    const covered = [];
-    const owners = new Set();
-    for (const part of across) {
-        owners.add(part.owner);
-        const kept = [];
-        let lo = part.s0;
-        let hi = part.s1;
-        let total = 0;
-        for (const span of covered) {
-            if (span[1] < lo || span[0] > hi) {
-                kept.push(span);
-                total += span[1] - span[0];
-            }
-            else {
-                lo = Math.min(lo, span[0]);
-                hi = Math.max(hi, span[1]);
-            }
-        }
-        kept.push([lo, hi]);
-        covered.splice(0, covered.length, ...kept);
-        if (total + hi - lo >= 0.5)
-            return { depth: part.h, across: [...owners] };
-    }
-    return { depth: Infinity, across: [] };
-}
-/**
- * How far the strip in front of an edge is free: to the nearest wall, outline or doorway gap before any
- * part of it.
- * @param edge The edge.
- * @param outward Its outward unit normal.
- * @param blockers What stands around it.
- * @param ownId Destination the edge belongs to; empty for none.
- * @param limit How far in front to look.
- * @returns The height, or `Infinity` when the strip is free within `limit`.
- */
-export function stripDepth(edge, outward, blockers, ownId, limit) {
-    const [nearest] = stripParts(edge, outward, blockers, ownId, limit);
-    return nearest ? nearest.h : Infinity;
-}

package/dist/lib/stubs.d.ts

@@ -1,84 +0,0 @@
-import { type AisleAxis } from './axes.js';
-import type { DoorSide } from './doorways.js';
-import { type WayIn, type Whisker } from './entries.js';
-import { type Frame } from './geom/frames.js';
-import type { RouteNetworkDestination } from './graph-types.js';
-import type { MaskCtx } from './mask.js';
-import type { NetworkBuild } from './network-build.js';
-/** A stub planned for a way in: a whisker before it is attached, with the way it grew from. */
-export interface Stub extends Whisker {
-    /** The way in. */
-    readonly way: WayIn;
-    /** How far the stub runs from its foot: to its aisle's axis, else to the middle of the aisle. */
-    reach: number;
-    /** Half the aisle's width ahead, when the face stands on an aisle: where the stub first ends. */
-    readonly middle?: number;
-}
-/** What planning the stubs reads. */
-interface StubPlanning extends NetworkBuild {
-    /** The layer's destinations. */
-    readonly destinations: readonly RouteNetworkDestination[];
-    /** Doorway sides by the destination they open into. */
-    readonly owners: ReadonlyMap<string, readonly DoorSide[]>;
-    /** The plan's mask: whether a point is on the floor. */
-    readonly ctx: MaskCtx;
-    /** The direction a destination is drawn in, when it has one. */
-    readonly frameOfDest: (d: RouteNetworkDestination) => Frame | undefined;
-    /** Entrances with openings: reached through their doorways alone, never from a face. */
-    readonly opened: ReadonlySet<string>;
-}
-/** The stubs planned, and the planning a retry goes on from once a stub fails to attach. */
-export interface StubPlan {
-    /** Every destination's ways in, by id. */
-    readonly ways: ReadonlyMap<string, readonly WayIn[]>;
-    /** The stubs planned, in destination order. */
-    readonly stubs: Stub[];
-    /**
-     * Whether a stub across the aisle may run that far: within the stretch its row's pitch allows,
-     * or its face's width when it has no row.
-     */
-    readonly mayRunAcross: (run: number, way: WayIn) => boolean;
-    /**
-     * The stub of the next way to try once one failed to attach: the destination's ranked ways go on
-     * where the planning stopped, a face only onto a side no whisker serves.
-     */
-    readonly retry: (failed: Stub, servedSides: ReadonlyMap<string, ReadonlySet<string>>, whiskers: readonly Whisker[]) => Stub | null;
-}
-/**
- * The side of its destination a way in leaves from, by its normal's main axis.
- * @param way The way in.
- * @returns The side's key.
- */
-export declare function sideOf(way: WayIn): string;
-/**
- * Plans one stub per open side of each destination, ending mid-aisle: doorways first (a stub from
- * another face would cross the wall), then the most open face; one face stub per side, and a
- * terminal destination gets only its best way in.
- * @param planning What the planning reads.
- * @returns The stubs and the plan a retry goes on from.
- */
-export declare function planStubs(planning: StubPlanning): StubPlan;
-/**
- * The aisle axes the stubs define, per direction and orientation: the stubs that end mid-aisle
- * define the aisles' lines first; a stub with open floor ahead runs to such a line ahead of it when
- * no corridor fits between the two or its row may run that far, and the rest line up among
- * themselves.
- * @param plan The stubs planned.
- * @param build The layer as the build reads it.
- * @param through Destinations people walk through: they frame nothing.
- * @param floorSpan The floor's own size: nothing on the layer reaches farther.
- * @returns The axes, and each stub's axis.
- */
-export declare function defineAxes(plan: StubPlan, build: NetworkBuild, through: ReadonlySet<string>, floorSpan: number): {
-    axes: AisleAxis[];
-    axisOf: Map<Stub, AisleAxis>;
-};
-/**
- * Runs each stub out to its aisle's axis when its dock stays lawful, over floor only.
- * @param axisOf Each stub's axis.
- * @param build The layer as the build reads it.
- * @param ctx The plan's mask: whether a point is on the floor.
- */
-export declare function runStubsToAxes(axisOf: ReadonlyMap<Stub, AisleAxis>, build: NetworkBuild, ctx: MaskCtx): void;
-export {};
-//# sourceMappingURL=stubs.d.ts.map

package/dist/lib/stubs.js

@@ -1,316 +0,0 @@
-// The stubs: a whisker planned for each way into a destination, before it is attached to the
-// network. A stub ends in the middle of the aisle ahead, where the stubs from both sides meet on one
-// line, when the rows on both sides may run that far; else it is half the free run and its own
-// length at most. The tips that end mid-aisle then define the aisles' axes, and each stub runs out
-// to its aisle's axis.
-import { aisleAxes, tipInFrame } from './axes.js';
-import { dockFor, stubLength, waysInto } from './entries.js';
-import { toFrame } from './geom/frames.js';
-import { POINT_EPS } from './geom/point-key.js';
-import { MAX_STRETCH, MIN_PASS } from './network-sizes.js';
-import { stripDepth } from './strip.js';
-/**
- * The side of its destination a way in leaves from, by its normal's main axis.
- * @param way The way in.
- * @returns The side's key.
- */
-export function sideOf(way) {
-    return Math.abs(way.nx) >= Math.abs(way.ny) ? `x${Math.sign(way.nx)}` : `y${Math.sign(way.ny)}`;
-}
-/**
- * Plans one stub per open side of each destination, ending mid-aisle: doorways first (a stub from
- * another face would cross the wall), then the most open face; one face stub per side, and a
- * terminal destination gets only its best way in.
- * @param planning What the planning reads.
- * @returns The stubs and the plan a retry goes on from.
- */
-export function planStubs(planning) {
-    const { destinations, destinationOf, owners, blockers, ctx, cfg, frames, frameOfDest, opened, note, } = planning;
-    const ways = new Map(destinations.map((d) => [
-        d.id,
-        waysInto(d, owners, blockers, cfg, (x, y) => ctx.freeAt(x, y)).filter((way) => way.kind === 'door' || !opened.has(d.id)),
-    ]));
-    const stubs = [];
-    // Each way in's row: the ways of one direction whose aisle MIDDLES lie on one line — the stands
-    // along one side of one aisle, however their fronts step (staggered fronts share the middle, the
-    // next aisle's stands lie a stand and an aisle away). Two at least: a lone face is no row. The
-    // pitch is the median distance between neighbors along: the walk between two of them.
-    const pitchOf = new Map();
-    {
-        const lines = new Map();
-        for (const d of destinations) {
-            const frame = frameOfDest(d) ?? frames[0];
-            const sides = new Set();
-            for (const way of ways.get(d.id) ?? []) {
-                if (way.front === undefined)
-                    continue;
-                const { horiz, c, along } = tipInFrame(frame, way.mx, way.my, way.nx, way.ny);
-                const [nu, nv] = toFrame(frame, way.nx, way.ny);
-                const sign = Math.sign(horiz ? nv : nu);
-                const key = `${frames.indexOf(frame)}|${horiz}|${sign}`;
-                // One foot per destination and side: a doorway beside a face is the same neighbor.
-                if (sides.has(key))
-                    continue;
-                sides.add(key);
-                lines.set(key, [...(lines.get(key) ?? []), { way, c: c + (sign * way.front) / 2, along }]);
-            }
-        }
-        for (const feet of lines.values())
-            for (const row of aisleAxes(feet, 2 * cfg.clear, 0, () => 0)) {
-                const gaps = row.tips
-                    .slice(1)
-                    .map((foot, i) => foot.along - row.tips[i].along)
-                    .sort((a, b) => a - b);
-                const pitch = gaps[Math.floor((gaps.length - 1) / 2)];
-                if (pitch !== undefined)
-                    for (const { way } of row.tips)
-                        pitchOf.set(way, pitch);
-            }
-    }
-    // A stub may run past its own length to the aisle's line ahead while it is still a stub — at
-    // most MAX_STRETCH more of its own length — and while the detour that adds for two neighbors
-    // along the row, out and back, stays within MAX_STRETCH of the walk along their fronts: the
-    // row's pitch. A lone face has no row to share a line with; the side ACROSS the aisle answers
-    // by its face alone when it has no row — its row is not what is asked.
-    const fits = (run, pitch) => run <= (1 + MAX_STRETCH) * cfg.stub && 2 * (run - cfg.stub) <= (MAX_STRETCH - 1) * pitch;
-    const mayRun = (run, way) => {
-        const pitch = pitchOf.get(way);
-        return pitch !== undefined && fits(run, pitch);
-    };
-    const mayRunAcross = (run, way) => fits(run, pitchOf.get(way) ?? way.width);
-    /** Each destination's ways in, best first; the attach loop retries down this order. */
-    const rankedOf = new Map();
-    /** Ways already planned or found unlawful; a retry never returns to one. */
-    const tried = new Set();
-    /**
-     * Plans the stub of one way in. It ends in the middle of the aisle ahead, where the stubs from
-     * both sides meet on one line, when the rows on both sides may run that far — one line serves the
-     * aisle or none does; wider floor ahead is open floor, and an aisle narrower than a person is
-     * none: its own length at most.
-     * @param d The destination.
-     * @param way Its way in.
-     * @returns The stub, or null when the way in is unlawful (noted).
-     */
-    const planStub = (d, way) => {
-        const tipAt = (run) => [
-            +(way.mx + way.nx * run).toFixed(2),
-            +(way.my + way.ny * run).toFixed(2),
-        ];
-        const facing = (id) => ways.get(id)?.find((other) => other.nx * way.nx + other.ny * way.ny < 0);
-        const middle = way.front !== undefined &&
-            way.front >= 2 * MIN_PASS &&
-            mayRun(way.front / 2, way) &&
-            (way.across ?? []).every((id) => {
-                const other = facing(id);
-                return other !== undefined && mayRunAcross(way.front / 2, other);
-            })
-            ? +(way.front / 2).toFixed(2)
-            : undefined;
-        const onAisle = middle !== undefined &&
-            middle <= way.depth - MIN_PASS &&
-            ctx.freeAt(...tipAt(middle)) &&
-            dockFor(d, way, tipAt(middle), blockers) !== null;
-        const reach = onAisle ? middle : stubLength(way, cfg);
-        const tip = tipAt(reach);
-        // Under half a person of room ahead, or no lawful dock: no way in. The noted point is where
-        // the way really ends: the blocker in front when there is no room, else the tip.
-        if (way.depth - MIN_PASS <= 0 || (!onAisle && !dockFor(d, way, tip, blockers))) {
-            note(d.id, 'way-in-blocked', {
-                at: way.depth - MIN_PASS <= 0 ? tipAt(Math.max(way.depth, 0)) : tip,
-            });
-            return null;
-        }
-        return {
-            id: d.id,
-            kind: way.kind,
-            mx: way.mx,
-            my: way.my,
-            tx: tip[0],
-            ty: tip[1],
-            nx: way.nx,
-            ny: way.ny,
-            to: way.to,
-            edge: way.edge,
-            frame: frameOfDest(d),
-            way,
-            reach,
-            ...(onAisle && { middle }),
-        };
-    };
-    for (const d of destinations) {
-        const list = ways.get(d.id) ?? [];
-        if (!list.length) {
-            note(d.id, 'no-way-in');
-            continue;
-        }
-        // Doorways first (a stub from another face would cross the wall), then the most open face.
-        const ranked = list
-            .map((way, order) => ({ way, order }))
-            .sort((p, q) => Number(q.way.kind !== 'face') - Number(p.way.kind !== 'face') ||
-            q.way.depth - p.way.depth ||
-            p.order - q.order)
-            .map(({ way }) => way);
-        rankedOf.set(d.id, ranked);
-        // One face stub per side (the best-ranked claims it): a many-edged shape gets at most four.
-        const claimed = new Set();
-        for (const way of ranked) {
-            // Doorways never compete for a side.
-            if (way.kind === 'face' && claimed.has(sideOf(way)))
-                continue;
-            tried.add(way);
-            const stub = planStub(d, way);
-            if (!stub)
-                continue;
-            stubs.push(stub);
-            if (way.kind === 'face')
-                claimed.add(sideOf(way));
-            // A terminal destination gets only its best way in.
-            if (d.terminal)
-                break;
-        }
-    }
-    /**
-     * The stub of the next way to try once one failed to attach: the destination's ranked ways go on
-     * where the planning stopped, a face only onto a side no whisker serves.
-     * @param failed The stub that could not attach.
-     * @param servedSides Sides of each destination a whisker already serves.
-     * @param whiskers The stubs attached so far.
-     * @returns The next stub, or null when no way in is left.
-     */
-    const retry = (failed, servedSides, whiskers) => {
-        const d = destinationOf.get(failed.id);
-        if (d.terminal && whiskers.some((w) => w.id === d.id))
-            return null;
-        for (const way of rankedOf.get(d.id) ?? []) {
-            if (tried.has(way))
-                continue;
-            if (way.kind === 'face' && servedSides.get(d.id)?.has(sideOf(way)))
-                continue;
-            tried.add(way);
-            const stub = planStub(d, way);
-            if (stub)
-                return stub;
-        }
-        return null;
-    };
-    return { ways, stubs, mayRunAcross, retry };
-}
-/**
- * The aisle axes the stubs define, per direction and orientation: the stubs that end mid-aisle
- * define the aisles' lines first; a stub with open floor ahead runs to such a line ahead of it when
- * no corridor fits between the two or its row may run that far, and the rest line up among
- * themselves.
- * @param plan The stubs planned.
- * @param build The layer as the build reads it.
- * @param through Destinations people walk through: they frame nothing.
- * @param floorSpan The floor's own size: nothing on the layer reaches farther.
- * @returns The axes, and each stub's axis.
- */
-export function defineAxes(plan, build, through, floorSpan) {
-    const { stubs, mayRunAcross } = plan;
-    const { frames, blockers, cfg } = build;
-    const axes = [];
-    const axisOf = new Map();
-    const groups = new Map();
-    for (const stub of stubs) {
-        if (!stub.frame || through.has(stub.id))
-            continue;
-        const { horiz, c, along } = tipInFrame(stub.frame, stub.tx, stub.ty, stub.nx, stub.ny);
-        const key = `${frames.indexOf(stub.frame)}|${horiz}`;
-        const group = groups.get(key) ?? { frame: stub.frame, horiz, tips: [] };
-        // Where the tip's line may lie across: a comfortable clearance from its face and from what
-        // stands across; in an aisle too narrow for that, where the tip is.
-        const [nu, nv] = toFrame(stub.frame, stub.nx, stub.ny);
-        const out = Math.sign(horiz ? nv : nu);
-        const foot = tipInFrame(stub.frame, stub.mx, stub.my, stub.nx, stub.ny).c;
-        const room = stub.way.depth - cfg.clear;
-        const may = room >= cfg.clear
-            ? [
-                Math.min(foot + out * cfg.clear, foot + out * room),
-                Math.max(foot + out * cfg.clear, foot + out * room),
-            ]
-            : [c, c];
-        group.tips.push({ stub, c, along, may });
-        groups.set(key, group);
-    }
-    for (const { frame, horiz, tips } of groups.values()) {
-        // How far a person walks along the row's line from a tip: the line reaches that far, and no
-        // farther than the floor. The search window grows only as needed — the answer is the same,
-        // a rotated strip's bounding box stays small.
-        const [dx, dy] = horiz ? [frame.cos, frame.sin] : [-frame.sin, frame.cos];
-        const reach = (tip, sign) => {
-            const strip = [
-                tip.stub.tx + dy * MIN_PASS,
-                tip.stub.ty - dx * MIN_PASS,
-                tip.stub.tx - dy * MIN_PASS,
-                tip.stub.ty + dx * MIN_PASS,
-            ];
-            for (let window = 8 * cfg.stub;; window *= 4) {
-                const met = stripDepth(strip, [sign * dx, sign * dy], blockers, '', Math.min(window, floorSpan));
-                if (isFinite(met))
-                    return met;
-                if (window >= floorSpan)
-                    return floorSpan;
-            }
-        };
-        const settle = (list) => aisleAxes(list, cfg.cs, 2 * cfg.clear, reach).map((axis) => {
-            const full = { frame, horiz, c: axis.c, lo: axis.lo, hi: axis.hi };
-            axes.push(full);
-            for (const { stub } of axis.tips)
-                axisOf.set(stub, full);
-            return full;
-        });
-        // The aisles' lines come from the stubs that end mid-aisle. A stub with open floor ahead runs
-        // to such a line ahead of it when no corridor fits between the two, or within the bound its
-        // own face gives (it has no row of its own to ask); the rest line up among themselves.
-        const lines = settle(tips.filter((tip) => tip.stub.middle !== undefined));
-        const loose = [];
-        for (const tip of tips) {
-            if (tip.stub.middle !== undefined)
-                continue;
-            const [nu, nv] = toFrame(frame, tip.stub.nx, tip.stub.ny);
-            const sign = Math.sign(horiz ? nv : nu);
-            let best = null;
-            for (const axis of lines) {
-                if (axis.lo > tip.along || axis.hi < tip.along)
-                    continue;
-                if (axis.c < tip.may[0] || axis.c > tip.may[1])
-                    continue;
-                const move = (axis.c - tip.c) * sign;
-                const run = tip.stub.reach + move;
-                if (run < MIN_PASS || (Math.abs(move) > 2 * cfg.clear && !mayRunAcross(run, tip.stub.way)))
-                    continue;
-                if (!best || Math.abs(move) < Math.abs(best.move))
-                    best = { axis, move };
-            }
-            if (best)
-                axisOf.set(tip.stub, best.axis);
-            else
-                loose.push(tip);
-        }
-        settle(loose);
-    }
-    return { axes, axisOf };
-}
-/**
- * Runs each stub out to its aisle's axis when its dock stays lawful, over floor only.
- * @param axisOf Each stub's axis.
- * @param build The layer as the build reads it.
- * @param ctx The plan's mask: whether a point is on the floor.
- */
-export function runStubsToAxes(axisOf, build, ctx) {
-    const { destinationOf, blockers } = build;
-    for (const [stub, axis] of axisOf) {
-        const d = destinationOf.get(stub.id);
-        const [nu, nv] = toFrame(axis.frame, stub.nx, stub.ny);
-        const foot = tipInFrame(axis.frame, stub.mx, stub.my, stub.nx, stub.ny).c;
-        const t = +((axis.c - foot) / (axis.horiz ? nv : nu)).toFixed(2);
-        if (Math.abs(t - stub.reach) <= POINT_EPS || t < MIN_PASS || t > stub.way.depth - MIN_PASS)
-            continue;
-        const tip = [+(stub.mx + stub.nx * t).toFixed(2), +(stub.my + stub.ny * t).toFixed(2)];
-        if (!ctx.freeAt(tip[0], tip[1]) || !dockFor(d, stub.way, tip, blockers))
-            continue;
-        stub.reach = t;
-        [stub.tx, stub.ty] = tip;
-    }
-}