@expofp/wayfinding-compiler 0.0.0-bootstrap.0 → 0.0.0-stage

package/dist/lib/doorways.d.ts

@@ -1,78 +0,0 @@
-import type { Ring, Segment, Vec2 } from './geom/types.js';
-import type { PreparedWalls } from './geom/walls.js';
-import { type RouteNetworkDestination } from './graph-types.js';
-import { type NetworkSizes } from './network-sizes.js';
-/** How close two readings of one doorway may lie: its middles, or a jamb and a wall end. */
-export declare const DOOR_WELD = 0.12;
-/** How far off a wall's line a piece may lie and still continue that wall. */
-export declare const ON_WALL_LINE = 0.12;
-/** A gap in a wall, with the wall's normal — the way through it. */
-export interface Doorway {
-    /** The gap, jamb to jamb. */
-    readonly gap: Segment;
-    /** The middle of the gap. */
-    readonly mid: Vec2;
-    /** Normal of the wall the gap is in, x. */
-    readonly nx: number;
-    /** Normal of the wall the gap is in, y. */
-    readonly ny: number;
-    /** The room's outline, when the gap is the way into a room drawn as one polyline. */
-    readonly room?: Ring;
-}
-/**
- * The closed sides of the doorways: only `MIN_PASS` plus one cell either side of the middle stays open,
- * the rest is closed like the wall. A doorway no wider than that is all middle.
- * @param doors The doorways.
- * @param cfg Network sizes.
- * @returns Each wider doorway's two closed sides, jamb to the edge of its middle.
- */
-export declare function doorwaySides(doors: readonly Doorway[], cfg: NetworkSizes): Segment[];
-/**
- * The doorways a plan draws as gaps in its walls, at any width.
- *
- * From each free wall end, the first wall piece ahead on the same line is the other jamb. A gap is dropped
- * when a wall or a non-crossable destination's outline crosses it — unless the gap opens into that
- * destination (see `doorOwners`). An open run turning more than half a turn is a room, and the gap between
- * its ends is its door.
- * @param walls The layer's walls, read once.
- * @param destinations The layer's destinations.
- * @returns One doorway per gap found.
- */
-export declare function findDoorways(walls: PreparedWalls, destinations?: readonly RouteNetworkDestination[]): Doorway[];
-/**
- * How far a ray travels before it meets one of `blockers`, and which one it met.
- * @param from Where the ray starts.
- * @param dx Ray direction x.
- * @param dy Ray direction y.
- * @param blockers What it may meet.
- * @returns The distance and the blocker's index, or null.
- */
-export declare function rayHit(from: Vec2, dx: number, dy: number, blockers: readonly Segment[]): {
-    at: number;
-    index: number;
-} | null;
-/** One side of a doorway that opens straight into a destination, with the outward normal of that side. */
-export interface DoorSide {
-    /** The doorway. */
-    readonly door: Doorway;
-    /** Normal pointing out of the destination, x. */
-    readonly nx: number;
-    /** Normal pointing out of the destination, y. */
-    readonly ny: number;
-}
-/**
- * Which destinations each doorway opens straight into, by id — the first case that applies:
- * - the gap's middle is on a destination's outline;
- * - the middle is inside a footprint that overshoots its wall — it opens where the footprint ends sooner;
- * - the gap is a room's way in — the room's destination, when it holds one that is not walked through
- *   (an exit, a stair or a pad beside it does not count): a room holding more is a hall, and its door
- *   a way into the space the network reaches, not into each of them;
- * - else the first outline straight in, closer than `cfg.clear` and with no wall before it.
- * @param doors Every doorway on the layer.
- * @param destinations Every destination on the layer.
- * @param walls The layer's wall segments.
- * @param cfg Network sizes.
- * @returns The doorway sides opening into each destination.
- */
-export declare function doorOwners(doors: readonly Doorway[], destinations: readonly RouteNetworkDestination[], walls: readonly Segment[], cfg: NetworkSizes): Map<string, DoorSide[]>;
-//# sourceMappingURL=doorways.d.ts.map

package/dist/lib/doorways.js

@@ -1,331 +0,0 @@
-// Doorways: gaps in the walls, and the destinations each one opens into.
-import { blockersNear, blockersOf } from './blockers.js';
-import { boundsOf, onOutline, pointInRing, pointSegmentDistance, rayVsSegment, segmentsCross, signedArea, } from './geom/primitives.js';
-import { NODE_SNAP } from './graph-types.js';
-import { MIN_PASS } from './network-sizes.js';
-import { WALL_HALF_WIDTH } from './walkable.js';
-/** How close two readings of one doorway may lie: its middles, or a jamb and a wall end. */
-export const DOOR_WELD = 0.12;
-/** How far off a wall's line a piece may lie and still continue that wall. */
-export const ON_WALL_LINE = 0.12;
-/**
- * Whether a wall crosses the open span of a gap: the gap inset by a wall half-width at each jamb, one wall
- * thick across. A jamb's own wall touches only the span's end, so it never counts.
- * @param gap The gap, jamb to jamb.
- * @param walls Wall segments.
- * @returns True when something is drawn across the gap.
- */
-function spanBlocked(gap, walls) {
-    const width = Math.hypot(gap[2] - gap[0], gap[3] - gap[1]);
-    const lo = WALL_HALF_WIDTH;
-    const hi = width - WALL_HALF_WIDTH;
-    if (hi <= lo)
-        return false;
-    const ux = (gap[2] - gap[0]) / width;
-    const uy = (gap[3] - gap[1]) / width;
-    return walls.some(([x0, y0, x1, y1]) => {
-        // The segment in the gap's own frame: how far along it runs, and how far to the side.
-        const a0 = (x0 - gap[0]) * ux + (y0 - gap[1]) * uy;
-        const a1 = (x1 - gap[0]) * ux + (y1 - gap[1]) * uy;
-        const o0 = -(x0 - gap[0]) * uy + (y0 - gap[1]) * ux;
-        const o1 = -(x1 - gap[0]) * uy + (y1 - gap[1]) * ux;
-        let t0 = 0;
-        let t1 = 1;
-        // Clipped to the span's rectangle a side at a time; anything left crosses the gap.
-        const clip = (p, q) => {
-            if (Math.abs(p) < 1e-12)
-                return q >= 0;
-            const r = q / p;
-            if (p < 0)
-                t0 = Math.max(t0, r);
-            else
-                t1 = Math.min(t1, r);
-            return t0 < t1;
-        };
-        return (clip(a0 - a1, a0 - lo) &&
-            clip(a1 - a0, hi - a0) &&
-            clip(o0 - o1, o0 + WALL_HALF_WIDTH) &&
-            clip(o1 - o0, WALL_HALF_WIDTH - o0));
-    });
-}
-/**
- * How far a wall run turns: the signed angles at its vertices, summed.
- * @param points The run's vertices.
- * @returns The total turn in radians; positive counter-clockwise.
- */
-function turnOf(points) {
-    let turn = 0;
-    for (let i = 1; i + 1 < points.length; i++) {
-        const [ax, ay] = points[i - 1];
-        const [bx, by] = points[i];
-        const [cx, cy] = points[i + 1];
-        turn += Math.atan2((bx - ax) * (cy - by) - (by - ay) * (cx - bx), (bx - ax) * (cx - bx) + (by - ay) * (cy - by));
-    }
-    return turn;
-}
-/**
- * The closed sides of the doorways: only `MIN_PASS` plus one cell either side of the middle stays open,
- * the rest is closed like the wall. A doorway no wider than that is all middle.
- * @param doors The doorways.
- * @param cfg Network sizes.
- * @returns Each wider doorway's two closed sides, jamb to the edge of its middle.
- */
-export function doorwaySides(doors, cfg) {
-    const middle = MIN_PASS + cfg.cs;
-    const sides = [];
-    for (const door of doors) {
-        const [ax, ay, bx, by] = door.gap;
-        const width = Math.hypot(bx - ax, by - ay);
-        if (width <= 2 * middle)
-            continue;
-        const ux = (bx - ax) / width;
-        const uy = (by - ay) / width;
-        const [mx, my] = door.mid;
-        sides.push([ax, ay, mx - ux * middle, my - uy * middle], [mx + ux * middle, my + uy * middle, bx, by]);
-    }
-    return sides;
-}
-/**
- * Whether every vertex of a destination's outline is inside a room's ring.
- * @param d The destination.
- * @param room The room's ring.
- * @returns True when it stands inside.
- */
-function standsIn(d, room) {
-    return d.polygon.every((p) => pointInRing(room, p));
-}
-/**
- * The doorways a plan draws as gaps in its walls, at any width.
- *
- * From each free wall end, the first wall piece ahead on the same line is the other jamb. A gap is dropped
- * when a wall or a non-crossable destination's outline crosses it — unless the gap opens into that
- * destination (see `doorOwners`). An open run turning more than half a turn is a room, and the gap between
- * its ends is its door.
- * @param walls The layer's walls, read once.
- * @param destinations The layer's destinations.
- * @returns One doorway per gap found.
- */
-export function findDoorways(walls, destinations = []) {
-    const segs = walls.segments;
-    const solid = blockersOf(destinations, [], []);
-    const byId = new Map();
-    for (const d of destinations)
-        byId.set(d.id, [...(byId.get(d.id) ?? []), d]);
-    /**
-     * Whether a non-crossable destination's outline crosses the gap, other than one the gap opens into.
-     * @param gap The gap, jamb to jamb.
-     * @param room The room the gap closes, if any.
-     * @returns True when such an outline crosses it.
-     */
-    const standsAcross = (gap, room) => {
-        const [ax, ay, bx, by] = gap;
-        const mx = (ax + bx) / 2;
-        const my = (ay + by) / 2;
-        // A footprint over the middle that also reaches a jamb has overshot its own wall: the gap is its door.
-        const opensInto = (d) => onOutline(d.polygon, mx, my, NODE_SNAP) ||
-            (room !== undefined && standsIn(d, room)) ||
-            (pointInRing(d.polygon, [mx, my]) &&
-                [
-                    [ax, ay],
-                    [bx, by],
-                ].some(([x, y]) => pointInRing(d.polygon, [x, y]) || onOutline(d.polygon, x, y, NODE_SNAP)));
-        return blockersNear(solid, boundsOf([
-            [ax, ay],
-            [bx, by],
-        ])).some(({ seg, owner }) => segmentsCross(gap, seg) && !(byId.get(owner ?? '') ?? []).some(opensInto));
-    };
-    const doorways = [];
-    const add = (gap, nx, ny, room) => {
-        if (spanBlocked(gap, segs) || standsAcross(gap, room))
-            return;
-        const mid = [+((gap[0] + gap[2]) / 2).toFixed(2), +((gap[1] + gap[3]) / 2).toFixed(2)];
-        // The same door read from both of its jambs is one door.
-        if (doorways.some((d) => Math.hypot(d.mid[0] - mid[0], d.mid[1] - mid[1]) <= DOOR_WELD))
-            return;
-        doorways.push({ gap, mid, nx, ny, ...(room && { room }) });
-    };
-    // Straight doors: a free end of an open run, closed by the next piece on its own line.
-    for (const run of walls.runs) {
-        if (run.closed || run.points.length < 2)
-            continue;
-        for (const [tip, inward] of [
-            [run.points[0], run.points[1]],
-            [run.points[run.points.length - 1], run.points[run.points.length - 2]],
-        ]) {
-            const len = Math.hypot(tip[0] - inward[0], tip[1] - inward[1]) || 1;
-            const ox = (tip[0] - inward[0]) / len;
-            const oy = (tip[1] - inward[1]) / len;
-            let gap = Infinity;
-            for (const [x0, y0, x1, y1] of segs) {
-                // Only pieces on this wall's own line count; a ray misses collinear pieces, so project instead.
-                const off0 = -(x0 - tip[0]) * oy + (y0 - tip[1]) * ox;
-                const off1 = -(x1 - tip[0]) * oy + (y1 - tip[1]) * ox;
-                if (Math.abs(off0) > ON_WALL_LINE || Math.abs(off1) > ON_WALL_LINE)
-                    continue;
-                const along0 = (x0 - tip[0]) * ox + (y0 - tip[1]) * oy;
-                const along1 = (x1 - tip[0]) * ox + (y1 - tip[1]) * oy;
-                const near = Math.min(along0, along1);
-                const far = Math.max(along0, along1);
-                if (far <= 1e-6)
-                    continue;
-                gap = Math.min(gap, Math.max(near, 0));
-            }
-            if (!isFinite(gap) || gap <= 1e-6)
-                continue;
-            add([tip[0], tip[1], tip[0] + ox * gap, tip[1] + oy * gap], -oy, ox);
-        }
-    }
-    // Room doors: an open run turning more than half a turn encloses a room, and the gap between its ends is
-    // the way in; its ends need not line up. A bent wall (a quarter turn) or a three-sided screen (a half)
-    // stays open. Read after the straight doors: a gap already found takes the room, a jamb end is skipped.
-    const straight = doorways.length;
-    const isJamb = (p) => doorways
-        .slice(0, straight)
-        .some(({ gap }) => Math.hypot(gap[0] - p[0], gap[1] - p[1]) <= DOOR_WELD ||
-        Math.hypot(gap[2] - p[0], gap[3] - p[1]) <= DOOR_WELD);
-    for (const run of walls.runs) {
-        if (run.closed || run.points.length < 4)
-            continue;
-        const first = run.points[0];
-        const last = run.points[run.points.length - 1];
-        const dx = first[0] - last[0];
-        const dy = first[1] - last[1];
-        const width = Math.hypot(dx, dy);
-        if (width < 1e-6 || Math.abs(turnOf(run.points)) <= Math.PI + 1e-9)
-            continue;
-        const mid = [
-            +((first[0] + last[0]) / 2).toFixed(2),
-            +((first[1] + last[1]) / 2).toFixed(2),
-        ];
-        const same = doorways.findIndex((d) => Math.hypot(d.mid[0] - mid[0], d.mid[1] - mid[1]) <= DOOR_WELD);
-        if (same >= 0)
-            doorways[same] = { ...doorways[same], room: run.points };
-        else if (!isJamb(first) && !isJamb(last))
-            add([last[0], last[1], first[0], first[1]], -dy / width, dx / width, run.points);
-    }
-    return doorways;
-}
-/**
- * How far a ray travels before it meets one of `blockers`, and which one it met.
- * @param from Where the ray starts.
- * @param dx Ray direction x.
- * @param dy Ray direction y.
- * @param blockers What it may meet.
- * @returns The distance and the blocker's index, or null.
- */
-export function rayHit(from, dx, dy, blockers) {
-    let nearest = Infinity;
-    let index = -1;
-    const hit = [0, 0];
-    blockers.forEach(([x0, y0, x1, y1], i) => {
-        if (!rayVsSegment(hit, from[0], from[1], dx, dy, x0, y0, x1, y1))
-            return;
-        const [t, u] = hit;
-        if (t > 1e-6 && u >= -1e-9 && u <= 1 + 1e-9 && t < nearest) {
-            nearest = t;
-            index = i;
-        }
-    });
-    return index < 0 ? null : { at: nearest, index };
-}
-/**
- * Which destinations each doorway opens straight into, by id — the first case that applies:
- * - the gap's middle is on a destination's outline;
- * - the middle is inside a footprint that overshoots its wall — it opens where the footprint ends sooner;
- * - the gap is a room's way in — the room's destination, when it holds one that is not walked through
- *   (an exit, a stair or a pad beside it does not count): a room holding more is a hall, and its door
- *   a way into the space the network reaches, not into each of them;
- * - else the first outline straight in, closer than `cfg.clear` and with no wall before it.
- * @param doors Every doorway on the layer.
- * @param destinations Every destination on the layer.
- * @param walls The layer's wall segments.
- * @param cfg Network sizes.
- * @returns The doorway sides opening into each destination.
- */
-export function doorOwners(doors, destinations, walls, cfg) {
-    // A room's way in opens into the one destination standing in it; the outline rules read non-crossable
-    // ones only.
-    const outlined = destinations.filter((d) => d.polygon.length >= 3);
-    const solid = outlined.filter((d) => !d.crossable);
-    const edges = [];
-    const edgeOwner = [];
-    const edgeInward = [];
-    for (const d of solid) {
-        const ccw = signedArea(d.polygon) > 0;
-        for (let i = 0; i < d.polygon.length; i++) {
-            const a = d.polygon[i];
-            const b = d.polygon[(i + 1) % d.polygon.length];
-            const len = Math.hypot(b[0] - a[0], b[1] - a[1]) || 1;
-            // Left of a→b is inside a counter-clockwise ring.
-            const left = [-(b[1] - a[1]) / len, (b[0] - a[0]) / len];
-            edges.push([a[0], a[1], b[0], b[1]]);
-            edgeOwner.push(d.id);
-            edgeInward.push(ccw ? left : [-left[0], -left[1]]);
-        }
-    }
-    const owners = new Map();
-    const claim = (id, door, nx, ny) => {
-        const sides = owners.get(id) ?? [];
-        if (!sides.some((side) => side.door === door && side.nx === nx && side.ny === ny))
-            sides.push({ door, nx, ny });
-        owners.set(id, sides);
-    };
-    for (const door of doors) {
-        let onOutline = false;
-        for (let e = 0; e < edges.length; e++) {
-            const [x0, y0, x1, y1] = edges[e];
-            if (pointSegmentDistance(door.mid[0], door.mid[1], x0, y0, x1, y1) > NODE_SNAP)
-                continue;
-            const inward = edgeInward[e];
-            const s = Math.sign(-(door.nx * inward[0] + door.ny * inward[1]));
-            if (!s)
-                continue;
-            claim(edgeOwner[e], door, door.nx * s, door.ny * s);
-            onOutline = true;
-        }
-        if (onOutline)
-            continue;
-        const host = solid.find((d) => pointInRing(d.polygon, door.mid));
-        if (host) {
-            const own = host.polygon.map((a, i) => {
-                const b = host.polygon[(i + 1) % host.polygon.length];
-                return [a[0], a[1], b[0], b[1]];
-            });
-            const ahead = rayHit(door.mid, door.nx, door.ny, own)?.at ?? Infinity;
-            const behind = rayHit(door.mid, -door.nx, -door.ny, own)?.at ?? Infinity;
-            const s = ahead <= behind ? 1 : -1;
-            claim(host.id, door, door.nx * s, door.ny * s);
-            continue;
-        }
-        if (door.room) {
-            const room = door.room;
-            // The gap closes the room from its last vertex to its first; outward is right of it in a CCW ring.
-            const out = signedArea(room) > 0 ? 1 : -1;
-            const [ax, ay] = room[room.length - 1];
-            const [bx, by] = room[0];
-            const len = Math.hypot(bx - ax, by - ay);
-            const nx = (out * (by - ay)) / len;
-            const ny = (out * -(bx - ax)) / len;
-            const inside = outlined.filter((d) => standsIn(d, room));
-            // Destinations walked through — an exit, a stair, a transition's pad — make no room a hall.
-            const solidInside = inside.filter((d) => !d.crossable);
-            const owner = solidInside.length === 1 ? solidInside[0] : inside.length === 1 ? inside[0] : null;
-            if (owner)
-                claim(owner.id, door, nx, ny);
-            if (inside.length)
-                continue;
-        }
-        for (const s of [1, -1]) {
-            const nx = door.nx * s;
-            const ny = door.ny * s;
-            const hit = rayHit(door.mid, -nx, -ny, edges);
-            if (!hit || hit.at >= cfg.clear)
-                continue;
-            const wall = rayHit(door.mid, -nx, -ny, walls);
-            if (wall && wall.at < hit.at)
-                continue;
-            claim(edgeOwner[hit.index], door, nx, ny);
-        }
-    }
-    return owners;
-}

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

@@ -1,47 +0,0 @@
-import type { Doorway } from './doorways.js';
-import { type Whisker } from './entries.js';
-import type { Vec2 } from './geom/types.js';
-import { type RouteNetwork, type RouteNetworkDestination, type RouteNetworkDock, type Unreached } from './graph-types.js';
-import type { NetworkBuild } from './network-build.js';
-import type { NetworkStore } from './network-store.js';
-/**
- * Turns each doorway dock that ends toward a side of its ring: the stub runs to the doorway's middle
- * as a line of the network, and the dock turns inside from there.
- * @param whiskers The attached stubs; a turned one's tip moves to its foot.
- * @param build The layer as the build reads it.
- * @param store The network; extended in place.
- */
-export declare function turnDoorwayDocks(whiskers: readonly Whisker[], build: NetworkBuild, store: NetworkStore): void;
-/** What the emit reads. */
-interface Emitting extends NetworkBuild {
-    /** The finished network. */
-    readonly store: NetworkStore;
-    /** The attached stubs; a tip merged by the noding moves with it. */
-    readonly whiskers: readonly Whisker[];
-    /** The layer's destinations. */
-    readonly destinations: readonly RouteNetworkDestination[];
-    /** Why each destination without a whisker has none, as the stages noted it. */
-    readonly failed: ReadonlyMap<string, Unreached>;
-    /** The layer's doorways: a line through one keeps its place. */
-    readonly doors: readonly Doorway[];
-}
-/** The emitted network: its paths and docks, and what it leaves unreached. */
-interface EmittedNetwork {
-    /** The polylines of the pieces kept. */
-    readonly paths: Vec2[][];
-    /** One dock per whisker on a kept piece. */
-    readonly docks: RouteNetworkDock[];
-    /** Destinations without a dock, with the reason. */
-    readonly unreached: RouteNetwork['stats']['unreached'];
-    /** Connected pieces of the network, kept or not. */
-    readonly components: number;
-}
-/**
- * Nodes the network, docks every whisker on it, and keeps the pieces that serve: routes turn only at
- * shared vertices, so crossings become vertices and ends within `NODE_SNAP` merge.
- * @param emitting What the emit reads.
- * @returns The paths, the docks, the unreached destinations and the piece count.
- */
-export declare function emitNetwork(emitting: Emitting): EmittedNetwork;
-export {};
-//# sourceMappingURL=emit-network.d.ts.map

package/dist/lib/emit-network.js

@@ -1,105 +0,0 @@
-// Emit: the finished network as the {@link RouteNetwork} artifact. A doorway dock that turns for a
-// side of its ring gets a line of the network from its tip to the doorway's middle and leaves from
-// there; every meeting becomes a vertex; the docks are drawn from the tips into the destinations. Of
-// the network's pieces, the one with most docks is emitted, and each further piece only when it
-// docks a destination no emitted piece does. A straight run is emitted as one line through every
-// meeting on it, so an aisle is one line and what meets it ends on its span.
-import { crossesBlocker } from './blockers.js';
-import { dockFor, followTips, tipPoints, turnsInDoorway } from './entries.js';
-import { pointKey } from './geom/point-key.js';
-import { segmentsCross } from './geom/primitives.js';
-import { splitCrossings } from './geom/split-crossings.js';
-import { NODE_SNAP, } from './graph-types.js';
-import { chainSegments, chainsFromEdges, components, graphOf, joinStraightRuns, } from './network-graph.js';
-/**
- * Turns each doorway dock that ends toward a side of its ring: the stub runs to the doorway's middle
- * as a line of the network, and the dock turns inside from there.
- * @param whiskers The attached stubs; a turned one's tip moves to its foot.
- * @param build The layer as the build reads it.
- * @param store The network; extended in place.
- */
-export function turnDoorwayDocks(whiskers, build, store) {
-    const { destinationOf, blockers } = build;
-    for (const w of whiskers) {
-        const d = destinationOf.get(w.id);
-        if (!d || !turnsInDoorway(d, w, [w.tx, w.ty], w.to) || !dockFor(d, w, [w.tx, w.ty], blockers))
-            continue;
-        store.add(w.tx, w.ty, w.mx, w.my);
-        w.tx = w.mx;
-        w.ty = w.my;
-    }
-}
-/**
- * Nodes the network, docks every whisker on it, and keeps the pieces that serve: routes turn only at
- * shared vertices, so crossings become vertices and ends within `NODE_SNAP` merge.
- * @param emitting What the emit reads.
- * @returns The paths, the docks, the unreached destinations and the piece count.
- */
-export function emitNetwork(emitting) {
-    const { store, whiskers, destinations, destinationOf, blockers, failed, note } = emitting;
-    /** Docking-ring sides already taken, per destination: one stub per side. */
-    const usedEdges = new Map();
-    const joined = new Map();
-    const pieces = splitCrossings(store.toArray(), NODE_SNAP, tipPoints(whiskers), joined);
-    followTips(whiskers, joined);
-    const chains = chainsFromEdges(pieces, new Set(whiskers.map((w) => pointKey(w.tx, w.ty))));
-    const graph = graphOf(chainSegments(chains));
-    const comp = components(graph);
-    const lawful = [];
-    for (const wsk of whiskers) {
-        const n = graph.nodeId.get(pointKey(wsk.tx, wsk.ty));
-        // A later pass moved the tip's line.
-        if (n === undefined) {
-            note(wsk.id, 'detached', { at: [wsk.tx, wsk.ty], by: 'not-a-vertex' });
-            continue;
-        }
-        const dest = destinationOf.get(wsk.id);
-        // Recheck with the final foot and tip.
-        const stub = dest
-            ? dockFor(dest, { ...wsk, kind: wsk.kind }, [wsk.tx, wsk.ty], blockers, usedEdges.get(wsk.id))
-            : null;
-        // No lawful dock here; unreached unless another whisker docks.
-        if (!stub) {
-            note(wsk.id, 'detached', { at: [wsk.tx, wsk.ty], by: 'dock-unlawful' });
-            continue;
-        }
-        if (stub.edge !== undefined)
-            usedEdges.set(wsk.id, (usedEdges.get(wsk.id) ?? new Set()).add(stub.edge));
-        // The ring side only shares sides out; the emit carries just the dock's ends.
-        lawful.push({ dock: { id: wsk.id, from: [wsk.tx, wsk.ty], to: stub.to }, piece: comp[n] });
-    }
-    // The pieces emitted: most docks first, each next piece only when it docks a destination no
-    // kept piece does — a piece the floor cuts off serves what nothing else can, and nothing else.
-    const dockCount = new Map();
-    for (const { piece } of lawful)
-        dockCount.set(piece, (dockCount.get(piece) ?? 0) + 1);
-    const serving = new Set();
-    const docked = new Set();
-    for (const [piece] of [...dockCount.entries()].sort((a, b) => b[1] - a[1] || a[0] - b[0])) {
-        const ids = lawful.filter((l) => l.piece === piece).map((l) => l.dock.id);
-        if (!ids.some((id) => !docked.has(id)))
-            continue;
-        serving.add(piece);
-        for (const id of ids)
-            docked.add(id);
-    }
-    const runs = joinStraightRuns(chains.filter((c) => serving.has(comp[graph.nodeId.get(pointKey(c.pts[0][0], c.pts[0][1]))])), {
-        frames: emitting.frames,
-        // Free floor: across no wall or stand, and through no doorway, where a line stays at the middle.
-        free: (seg) => !crossesBlocker(blockers, seg) && !emitting.doors.some((d) => segmentsCross(seg, d.gap)),
-        lane: emitting.cfg.stub,
-    });
-    const paths = runs.chains.map((c) => c.pts.map((p) => [p[0], p[1]]));
-    // A dock whose tip stood on a chord now starts where the tip moved to.
-    const docks = lawful
-        .filter((l) => serving.has(l.piece))
-        .map(({ dock }) => {
-        const to = runs.moved.get(pointKey(dock.from[0], dock.from[1]));
-        return to ? { ...dock, from: to } : dock;
-    });
-    // Unreached: no dock left for any of its ways in.
-    const unreached = destinations
-        .filter((d) => !docked.has(d.id))
-        .map((d) => failed.get(d.id) ?? { id: d.id, reason: 'detached' });
-    return { paths, docks, unreached, components: new Set(comp).size };
-}

package/dist/lib/emit-v1.d.ts

@@ -1,31 +0,0 @@
-import type { RouteNetwork } from './graph-types.js';
-import type { WfV1Graph, WfV1Line, WfV1Point } from './types.js';
-/**
- * A v1 graph point on the network's centimeter grid.
- * @param x Plan x.
- * @param y Plan y.
- * @param layer Layer id.
- * @returns The point.
- */
-export declare function point(x: number, y: number, layer: string): WfV1Point;
-/**
- * A plain walking edge of the v1 graph.
- * @param p0 One end.
- * @param p1 The other end.
- * @returns The edge.
- */
-export declare function line(p0: WfV1Point, p1: WfV1Point): WfV1Line;
-/**
- * Appends one layer's route network to `out` as v1 edges — one per path segment and per dock — plus
- * a `lineEnd` at each dock's inner end, the point a destination is reached at.
- * @param network The layer's route network.
- * @param layer Layer id carried onto every point.
- * @param out The graph accumulated across layers; mutated.
- * @returns What collapsed on the centimeter grid: segments skipped, and the docks whose line is
- * lost while their `lineEnd` still stands.
- */
-export declare function emitLayerV1(network: RouteNetwork, layer: string, out: WfV1Graph): {
-    collapsedSegments: number;
-    collapsedDocks: string[];
-};
-//# sourceMappingURL=emit-v1.d.ts.map

package/dist/lib/emit-v1.js

@@ -1,56 +0,0 @@
-import { snapCm } from './geom/point-key.js';
-/**
- * A v1 graph point on the network's centimeter grid.
- * @param x Plan x.
- * @param y Plan y.
- * @param layer Layer id.
- * @returns The point.
- */
-export function point(x, y, layer) {
-    return { x: snapCm(x), y: snapCm(y), layer };
-}
-function sameNode(a, b) {
-    return a.x === b.x && a.y === b.y;
-}
-/**
- * A plain walking edge of the v1 graph.
- * @param p0 One end.
- * @param p1 The other end.
- * @returns The edge.
- */
-export function line(p0, p1) {
-    return { p0, p1, virtual: false, unaccessible: false, unidirection: false, weight: 0 };
-}
-/**
- * Appends one layer's route network to `out` as v1 edges — one per path segment and per dock — plus
- * a `lineEnd` at each dock's inner end, the point a destination is reached at.
- * @param network The layer's route network.
- * @param layer Layer id carried onto every point.
- * @param out The graph accumulated across layers; mutated.
- * @returns What collapsed on the centimeter grid: segments skipped, and the docks whose line is
- * lost while their `lineEnd` still stands.
- */
-export function emitLayerV1(network, layer, out) {
-    let collapsedSegments = 0;
-    const collapsedDocks = [];
-    for (const path of network.paths) {
-        for (let i = 0; i + 1 < path.length; i++) {
-            const p0 = point(path[i][0], path[i][1], layer);
-            const p1 = point(path[i + 1][0], path[i + 1][1], layer);
-            if (!sameNode(p0, p1))
-                out.lines.push(line(p0, p1));
-            else
-                collapsedSegments++;
-        }
-    }
-    for (const dock of network.docks) {
-        const from = point(dock.from[0], dock.from[1], layer);
-        const to = point(dock.to[0], dock.to[1], layer);
-        if (!sameNode(from, to))
-            out.lines.push(line(from, to));
-        else
-            collapsedDocks.push(dock.id);
-        out.lineEnds.push(to);
-    }
-    return { collapsedSegments, collapsedDocks };
-}