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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expofp/wayfinding-compiler",
-  "version": "0.0.0-bootstrap.0",
+  "version": "0.0.0-experimental.3b0db16",
   "type": "module",
   "description": "ExpoFP SDK internal: compiles raw plan geometry into a wayfinding routing graph",
   "homepage": "https://developer.expofp.com/",
@@ -24,7 +24,7 @@
   "dependencies": {
     "clipper2-ts": "2.0.1-18",
     "tslib": "^2.3.0",
-    "@expofp/wayfinding-geometry": "0.0.0-bootstrap.0"
+    "@expofp/wayfinding-geometry": "0.0.0-experimental.3b0db16"
   },
   "files": [
     "dist",

package/dist/lib/centering.d.ts

@@ -1,14 +0,0 @@
-/**
- * How far off the middle of its corridor each cell stands: 0 on the middle row, rising to 1 at the
- * walls — `1 - d / dmax`, where `d` is the cell's clearance and `dmax` the clearance of the ridge the
- * cell climbs to, which is half the corridor's width there. A corridor an even number of cells wide
- * has two middle rows; the one with the greater index is charged half the step to the next row, so
- * the minimum is one row.
- * @param width Grid width in cells.
- * @param height Grid height in cells.
- * @param clearance Meters from each cell to the nearest blocker, row-major.
- * @param ok 1 for a walkable cell.
- * @returns The offset per cell; 0 for a cell that is not walkable.
- */
-export declare function offCenter(width: number, height: number, clearance: Float32Array, ok: Uint8Array): Float32Array;
-//# sourceMappingURL=centering.d.ts.map

package/dist/lib/centering.js

@@ -1,88 +0,0 @@
-// Centering: how far off the middle of its corridor each router cell stands, read off the clearance
-// field alone. The middle is one row of cells, so two paths along one corridor lie on one line.
-/** Clearances are compared by the millimeter: chamfer sums differ by float noise only below it. */
-const QUANTUM = 1000;
-/**
- * How far off the middle of its corridor each cell stands: 0 on the middle row, rising to 1 at the
- * walls — `1 - d / dmax`, where `d` is the cell's clearance and `dmax` the clearance of the ridge the
- * cell climbs to, which is half the corridor's width there. A corridor an even number of cells wide
- * has two middle rows; the one with the greater index is charged half the step to the next row, so
- * the minimum is one row.
- * @param width Grid width in cells.
- * @param height Grid height in cells.
- * @param clearance Meters from each cell to the nearest blocker, row-major.
- * @param ok 1 for a walkable cell.
- * @returns The offset per cell; 0 for a cell that is not walkable.
- */
-export function offCenter(width, height, clearance, ok) {
-    const cells = width * height;
-    const level = new Int32Array(cells);
-    let top = 0;
-    for (let cell = 0; cell < cells; cell++) {
-        if (!ok[cell])
-            continue;
-        level[cell] = Math.round(clearance[cell] * QUANTUM);
-        top = Math.max(top, level[cell]);
-    }
-    // Cells from the highest clearance down, index order among equals: a counting sort.
-    const start = new Int32Array(top + 2);
-    for (let cell = 0; cell < cells; cell++)
-        if (ok[cell])
-            start[top - level[cell] + 1]++;
-    for (let i = 1; i < start.length; i++)
-        start[i] += start[i - 1];
-    const order = new Int32Array(start[top + 1]);
-    for (let cell = 0; cell < cells; cell++)
-        if (ok[cell])
-            order[start[top - level[cell]]++] = cell;
-    // Each cell climbs to its highest neighbor, and takes the ridge that one reached.
-    const ridge = new Int32Array(cells);
-    for (const cell of order) {
-        const x = cell % width;
-        const y = (cell - x) / width;
-        let up = -1;
-        for (let dy = -1; dy <= 1; dy++)
-            for (let dx = -1; dx <= 1; dx++) {
-                const nx = x + dx;
-                const ny = y + dy;
-                if ((!dx && !dy) || nx < 0 || ny < 0 || nx >= width || ny >= height)
-                    continue;
-                const near = ny * width + nx;
-                if (ok[near] && level[near] > level[cell] && (up < 0 || level[near] > level[up]))
-                    up = near;
-            }
-        ridge[cell] = up < 0 ? level[cell] : ridge[up];
-    }
-    const off = new Float32Array(cells);
-    // Whether the cell `step` away from `cell`, at `at` along its row or column, stands lower or is no floor.
-    const lower = (cell, at, limit, step) => at < 0 || at >= limit || !ok[cell + step] || level[cell + step] < level[cell];
-    /**
-     * What the second of two equal rows across a corridor is charged: half the step to the next row.
-     * @param cell The cell.
-     * @param at Its place along the axis across the corridor.
-     * @param limit The grid's size along that axis.
-     * @param step The index step along that axis.
-     * @returns The charge, 0 when the cell is not such a row's.
-     */
-    const secondRow = (cell, at, limit, step) => {
-        const twin = cell - step;
-        if (at < 1 || !ok[twin] || level[twin] !== level[cell])
-            return 0;
-        if (!lower(cell, at + 1, limit, step) || !lower(twin, at - 2, limit, -step))
-            return 0;
-        const next = at + 1 < limit && ok[cell + step] ? level[cell + step] : 0;
-        return (0.5 * (level[cell] - next)) / ridge[cell];
-    };
-    for (const cell of order) {
-        if (!ridge[cell])
-            continue;
-        const x = cell % width;
-        const y = (cell - x) / width;
-        off[cell] =
-            1 -
-                level[cell] / ridge[cell] +
-                secondRow(cell, x, width, 1) +
-                secondRow(cell, y, height, width);
-    }
-    return off;
-}

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

@@ -1,20 +0,0 @@
-import type { Ring } from './geom/types.js';
-import type { PreparedWalls } from './geom/walls.js';
-import type { RouteNetwork, RouteNetworkDestination } from './graph-types.js';
-import type { Opening } from './openings.js';
-/**
- * Builds the grid 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.
- * @param shortcuts Whether links are cut into the tree where it sends a route the long way round.
- * @returns Paths, docks and stats for `emit-v1`.
- */
-export declare function buildGridNetwork(walkableRings: readonly Ring[], destinations: readonly RouteNetworkDestination[], walls: readonly (readonly number[])[], prepared?: PreparedWalls, drawn?: readonly {
-    readonly id: string;
-    readonly ring: Ring;
-}[], openings?: readonly Opening[], shortcuts?: boolean): RouteNetwork;
-//# sourceMappingURL=grid-network.d.ts.map

package/dist/lib/grid-network.js

@@ -1,349 +0,0 @@
-// The "grid" route-network generator: one tree of cheapest paths over the plan's raster. A stub per
-// open face ends on a router cell; a single growing search then joins the tips, nearest first, each
-// path laid along the cell centers and free to walk from then on. What shapes the lines is the cost
-// of a cell alone — a corridor's middle row is the cheapest, a turn costs a length — and a staircase
-// along one corridor is cut to a straight line. On request, links are cut into the tree where it
-// sends a route the long way round. Produces the {@link RouteNetwork} for `emit-v1`.
-import { crossesBlocker } from './blockers.js';
-import { createConnector } from './connect.js';
-import { emitNetwork, turnDoorwayDocks } from './emit-network.js';
-import { dockFor, followTips, tipPoints } from './entries.js';
-import { floorGrids } from './floor-grids.js';
-import { POINT_EPS, pointKey } from './geom/point-key.js';
-import { pointSegmentDistance } from './geom/primitives.js';
-import { chainSegments, chainsFromEdges } from './network-graph.js';
-import { setUpNetwork } from './network-setup.js';
-import { MIN_PASS } from './network-sizes.js';
-import { NetworkStore } from './network-store.js';
-import { shortcutDetours } from './post-passes.js';
-import { makeRouter } from './router.js';
-import { planStubs, sideOf } from './stubs.js';
-/** What a cell at a corridor's wall costs over one on its middle row, as a share of its length. */
-const CENTERING = 1;
-/** The sine of the angle under which a stub counts as running along a line rather than across it. */
-const ALONG = 0.2;
-/**
- * Cuts each staircase to a straight line: along a chain, the farthest vertex a free straight line
- * reaches while every vertex between stays within a lane of it. A stub's tip on the staircase moves
- * along the stub onto the line, so a corridor between two meetings is one line however many stubs
- * end on it; where a dock from there would be unlawful the tip stays, and the line ends at it. A
- * corner with legs longer than the lane stays a corner.
- * @param store The network, every meeting a node; rebuilt in place.
- * @param whiskers The attached stubs; a tip on a cut staircase moves onto the line.
- * @param lane How far off the straight line a staircase's vertices may stand.
- * @param free Whether a straight line may be laid.
- * @param lawful Whether a stub may dock from a point.
- */
-function cutStairs(store, whiskers, lane, free, lawful) {
-    const tipsAt = new Map();
-    for (const stub of whiskers) {
-        const key = pointKey(stub.tx, stub.ty);
-        tipsAt.set(key, [...(tipsAt.get(key) ?? []), stub]);
-    }
-    const chains = chainsFromEdges(store.toArray(), new Set(tipsAt.keys()));
-    for (const chain of chains) {
-        const { pts } = chain;
-        const kept = [pts[0]];
-        /**
-         * Reads the vertices between two of the chain's as a staircase.
-         * @param from Index of the vertex the line starts at.
-         * @param to Index of the vertex it ends at.
-         * @returns The tips between them moved onto the line, or null when a line may not replace them.
-         */
-        const stairs = (from, to) => {
-            const [ax, ay] = pts[from];
-            const [bx, by] = pts[to];
-            const dx = bx - ax;
-            const dy = by - ay;
-            const length = Math.hypot(dx, dy);
-            const moved = [];
-            // A chain that closes on itself has no line between its ends.
-            if (length < POINT_EPS)
-                return null;
-            for (let k = from + 1; k < to; k++)
-                if (pointSegmentDistance(pts[k][0], pts[k][1], ax, ay, bx, by) > lane)
-                    return null;
-            for (let k = from + 1; k < to; k++) {
-                const [px, py] = pts[k];
-                for (const stub of tipsAt.get(pointKey(px, py)) ?? []) {
-                    // Where the stub's own line meets the straight line; a stub running along the line keeps
-                    // its place along it.
-                    const cross = dx * stub.ny - dy * stub.nx;
-                    const along = Math.abs(cross) > ALONG * length
-                        ? ((stub.mx - ax) * stub.ny - (stub.my - ay) * stub.nx) / cross
-                        : ((px - ax) * dx + (py - ay) * dy) / (length * length);
-                    const at = [+(ax + along * dx).toFixed(2), +(ay + along * dy).toFixed(2)];
-                    const run = (at[0] - stub.mx) * stub.nx + (at[1] - stub.my) * stub.ny;
-                    if (along < 0 || along > 1 || run < MIN_PASS || !lawful(stub, at))
-                        return null;
-                    moved.push({ stub, along, at });
-                }
-            }
-            return free([ax, ay, bx, by]) ? moved : null;
-        };
-        // The edge to the next vertex is the network's own: it stays as it is.
-        const cut = (from, to) => to > from + 1 ? stairs(from, to) : [];
-        let from = 0;
-        while (from < pts.length - 1) {
-            let to = pts.length - 1;
-            let moved = cut(from, to);
-            while (!moved)
-                moved = cut(from, --to);
-            for (const { stub, at } of moved.sort((a, b) => a.along - b.along)) {
-                [stub.tx, stub.ty] = at;
-                kept.push([at[0], at[1]]);
-            }
-            kept.push(pts[to]);
-            from = to;
-        }
-        chain.pts = kept;
-    }
-    store.reset(chainSegments(chains));
-}
-/**
- * Builds the grid 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.
- * @param shortcuts Whether links are cut into the tree where it sends a route the long way round.
- * @returns Paths, docks and stats for `emit-v1`.
- */
-export function buildGridNetwork(walkableRings, destinations, walls, prepared, drawn = [], openings = [], shortcuts = false) {
-    const { cfg, wallLines, doors, owners, opened, floor, unservedFloorPieces, doorSides, blockers, destinationOf, failed, note, } = setUpNetwork(walkableRings, destinations, walls, prepared, drawn, openings);
-    // One grid, the plan's: a hall turned its own way is walked on it too.
-    const { grids, frames, frameOfDest } = floorGrids(floor, doorSides, destinations, wallLines, doors, cfg, false);
-    const ctx = grids[0].ctx;
-    const router = makeRouter(grids, cfg, CENTERING);
-    const store = new NetworkStore();
-    const build = { cfg, frames, blockers, destinationOf, note };
-    const mayLay = (seg) => ctx.lineFree(seg[0], seg[1], seg[2], seg[3]) && !crossesBlocker(blockers, seg);
-    /* ---- stubs: one per open side of each destination, as the steiner network plans them ---- */
-    const plan = planStubs({ ...build, destinations, owners, ctx, frameOfDest, opened });
-    const whiskers = [];
-    const anchors = [];
-    /** Sides of each destination a whisker already serves. */
-    const servedSides = new Map();
-    const attach = (stub) => {
-        whiskers.push(stub);
-        if (stub.kind === 'face')
-            servedSides.set(stub.id, (servedSides.get(stub.id) ?? new Set()).add(sideOf(stub.way)));
-    };
-    /**
-     * Moves a stub's tip onto a router cell: the planned tip's, or one a step nearer or farther along
-     * the stub — the cheapest to stand on from which the dock is lawful, the planned one among equals.
-     * Where the floor around the planned tip is too tight to walk, the nearest such cell along the
-     * stub, toward the foot first.
-     * @param stub The stub; its tip moves to the cell's center.
-     * @returns The cell, or -1 when the stub has none (noted).
-     */
-    const seat = (stub) => {
-        const destination = destinationOf.get(stub.id);
-        const farthest = Math.min(stub.way.depth - MIN_PASS, stub.reach + 2 * cfg.stub);
-        let onFloor = false;
-        /**
-         * The cell a number of steps along the stub from its planned tip, when a dock from it is lawful.
-         * @param steps Cells along the stub, toward the foot when negative.
-         * @returns The cell, or -1.
-         */
-        const cellAt = (steps) => {
-            const run = steps * router.pitch;
-            if (stub.reach + run < MIN_PASS || stub.reach + run > farthest)
-                return -1;
-            const cell = router.cellIn(stub.tx + stub.nx * run, stub.ty + stub.ny * run, frames[0]);
-            if (cell < 0 || !router.ok[cell])
-                return -1;
-            onFloor = true;
-            return dockFor(destination, stub.way, router.worldOf(cell), blockers) ? cell : -1;
-        };
-        let best = cellAt(0);
-        for (const steps of [-1, 1]) {
-            const cell = cellAt(steps);
-            if (cell >= 0 && (best < 0 || router.stepCost[cell] < router.stepCost[best]))
-                best = cell;
-        }
-        for (const sign of [-1, 1])
-            for (let steps = 2; best < 0 && Math.abs(steps * router.pitch) <= farthest; steps++)
-                best = cellAt(sign * steps);
-        if (best < 0) {
-            note(stub.id, onFloor ? 'way-in-blocked' : 'no-floor', { at: [stub.tx, stub.ty] });
-            return -1;
-        }
-        [stub.tx, stub.ty] = router.worldOf(best);
-        anchors.push({ id: stub.id, at: [stub.tx, stub.ty] });
-        return best;
-    };
-    const around = Math.round(cfg.stub / router.pitch);
-    /**
-     * How much floor lies around a cell: the walkable cells within a stub's length of it.
-     * @param cell The cell.
-     * @returns The count.
-     */
-    const roomAround = (cell) => {
-        const [x, y] = router.worldOf(cell);
-        let room = 0;
-        for (let dy = -around; dy <= around; dy++)
-            for (let dx = -around; dx <= around; dx++) {
-                const near = router.cellIn(x + dx * router.pitch, y + dy * router.pitch, frames[0]);
-                if (near >= 0 && router.ok[near])
-                    room++;
-            }
-        return room;
-    };
-    /* ---- the tree: every tip joined to the network laid so far, nearest first ---- */
-    /** 1 for each cell a laid path passes. */
-    const laid = new Uint8Array(router.cells);
-    const network = [];
-    /** Stubs whose tip stands on floor no other tip shares. */
-    const stranded = [];
-    let trees = 0;
-    /**
-     * One growth over the stubs: each tip is joined by the cheapest path from the network laid so
-     * far; with no network, or floor it cannot reach, a tree starts from the roomiest tip left.
-     * @param stubs The stubs to join.
-     * @returns The stubs that could not be: no cell to stand on, or alone on their floor.
-     */
-    const grow = (stubs) => {
-        const group = new Int32Array(router.cells).fill(-1);
-        const targets = [];
-        const lost = [];
-        for (const stub of stubs) {
-            const cell = seat(stub);
-            if (cell < 0) {
-                lost.push(stub);
-                continue;
-            }
-            // Already on a laid line: the tip becomes a node of it.
-            if (laid[cell]) {
-                store.splitAt(store.segmentAt(stub.tx, stub.ty), stub.tx, stub.ty);
-                attach(stub);
-                continue;
-            }
-            if (group[cell] < 0) {
-                group[cell] = targets.length;
-                targets.push({ cell, stubs: [], room: roomAround(cell) });
-            }
-            targets[group[cell]].stubs.push(stub);
-        }
-        // Trees start from the tip with most floor around it; the stubs' own order among equals.
-        const order = targets
-            .map((_, index) => index)
-            .sort((a, b) => targets[b].room - targets[a].room || a - b);
-        /** The target a tree started from, by its cell, while nothing has joined it. */
-        const lone = new Map();
-        let next = 0;
-        const reseed = () => {
-            while (next < order.length && group[targets[order[next]].cell] < 0)
-                next++;
-            if (next >= order.length)
-                return null;
-            const { cell } = targets[order[next]];
-            group[cell] = -1;
-            lone.set(cell, order[next]);
-            return [cell];
-        };
-        router.grow(network.length ? network : (reseed() ?? []), group, reseed, (cells, reached) => {
-            const root = cells[cells.length - 1];
-            const seed = lone.get(root);
-            // The first path of a tree: the tip it started from is on the network now.
-            if (seed !== undefined) {
-                lone.delete(root);
-                trees++;
-                targets[seed].stubs.forEach(attach);
-            }
-            for (const [x0, y0, x1, y1] of router.segmentsAlong(cells))
-                store.add(x0, y0, x1, y1);
-            for (const cell of cells) {
-                if (laid[cell])
-                    continue;
-                laid[cell] = 1;
-                network.push(cell);
-            }
-            targets[reached].stubs.forEach(attach);
-            return [];
-        });
-        for (const target of lone.values())
-            for (const stub of targets[target].stubs) {
-                note(stub.id, 'cut-off', { at: [stub.tx, stub.ty] });
-                stranded.push(stub);
-                lost.push(stub);
-            }
-        return lost;
-    };
-    let pending = plan.stubs;
-    // A stub that could not be joined is retried from its destination's next way in.
-    while (pending.length)
-        pending = grow(pending).flatMap((stub) => plan.retry(stub, servedSides, whiskers) ?? []);
-    // No network at all (a plan with one destination): a stub's own run is its line.
-    if (!store.size) {
-        const own = stranded.find((stub) => mayLay([stub.mx, stub.my, stub.tx, stub.ty]));
-        if (own) {
-            store.add(own.mx, own.my, own.tx, own.ty);
-            attach(own);
-        }
-    }
-    followTips(whiskers, store.node(tipPoints(whiskers)));
-    /* ---- shortcuts: links across where the tree sends a route the long way round ---- */
-    let linked = 0;
-    if (shortcuts) {
-        const connector = createConnector(store, router, cfg, {
-            frames,
-            axes: [],
-            doors,
-            blockers,
-            mayLay,
-        });
-        const tree = store.toArray();
-        // Through the connector, so a link ends on the line that claims its last cell.
-        store.reset([]);
-        for (const seg of tree)
-            connector.add(seg);
-        linked = shortcutDetours(store, router, connector);
-        followTips(whiskers, store.node(tipPoints(whiskers)));
-    }
-    /* ---- straighten: every meeting a node, then each staircase one line ---- */
-    cutStairs(store, whiskers, cfg.stub / 2, 
-    // Over cells the router walks, so the line keeps a person's clearance.
-    (seg) => mayLay(seg) && router.cellsAlong(...seg).every((cell) => router.ok[cell] === 1), (stub, at) => dockFor(destinationOf.get(stub.id), stub.way, at, blockers) !== null);
-    turnDoorwayDocks(whiskers, build, store);
-    /* ---- emit the RouteNetwork artifact ---- */
-    const emitted = emitNetwork({ ...build, store, whiskers, destinations, failed, doors });
-    const ways = [];
-    for (const [id, list] of plan.ways)
-        for (const way of list)
-            ways.push({ id, kind: way.kind, foot: [way.mx, way.my], normal: [way.nx, way.ny] });
-    return {
-        paths: emitted.paths,
-        docks: emitted.docks,
-        anatomy: {
-            doors: doors.map((door) => ({
-                gap: [
-                    [door.gap[0], door.gap[1]],
-                    [door.gap[2], door.gap[3]],
-                ],
-                mid: [door.mid[0], door.mid[1]],
-            })),
-            anchors,
-            ways,
-            whiskers: whiskers.map((stub) => ({
-                id: stub.id,
-                kind: stub.kind,
-                foot: [stub.mx, stub.my],
-                tip: [stub.tx, stub.ty],
-            })),
-            frames: [],
-            loose: [],
-            axes: [],
-        },
-        stats: {
-            unreached: emitted.unreached,
-            components: emitted.components,
-            doorways: doors.length,
-            shortcuts: linked,
-            ...(trees > 1 && { untiedPieces: trees - 1 }),
-            ...(unservedFloorPieces > 0 && { unservedFloorPieces }),
-        },
-    };
-}

package/dist/lib/lattice-map.d.ts

@@ -1,19 +0,0 @@
-import type { Lattice, RouteNetworkDock } from './graph-types.js';
-import type { WfGridFloor } from './types.js';
-/**
- * Bytes packed as runs: the value, then the run's length as a little-endian base-128 number, and
- * the whole as base64. A floor's map is long stretches of one value.
- * @param bytes The bytes.
- * @returns The packed text.
- */
-export declare function packRuns(bytes: Uint8Array): string;
-/**
- * One floor's lattice and docks as the map handed to the runtime, in plan units.
- * @param layer The floor's layer id.
- * @param lattice The lattice, in meters.
- * @param docks The docks leaving it, in meters, in the lattice's own order.
- * @param unitsPerMeter Plan coordinates in one meter.
- * @returns The floor's map.
- */
-export declare function latticeMap(layer: string, lattice: Lattice, docks: readonly RouteNetworkDock[], unitsPerMeter: number): WfGridFloor;
-//# sourceMappingURL=lattice-map.d.ts.map

package/dist/lib/lattice-map.js

@@ -1,92 +0,0 @@
-// The lattice as it is handed out: a map of each floor in the plan's own units — where the grid
-// stands, how its cells are spaced, a byte of links per cell — and the docks that leave it.
-import { PLAN_DECIMALS } from './scale.js';
-/** How near a blocker a route starts to pay more to walk, in meters: a wide aisle's half. */
-const NEAR = 1.5;
-const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-/**
- * Bytes as base64 text.
- * @param bytes The bytes.
- * @returns The text, padded.
- */
-function toBase64(bytes) {
-    const chunks = [];
-    let chunk = '';
-    for (let i = 0; i < bytes.length; i += 3) {
-        const triple = (bytes[i] << 16) | ((bytes[i + 1] ?? 0) << 8) | (bytes[i + 2] ?? 0);
-        chunk +=
-            ALPHABET[triple >> 18] +
-                ALPHABET[(triple >> 12) & 63] +
-                (i + 1 < bytes.length ? ALPHABET[(triple >> 6) & 63] : '=') +
-                (i + 2 < bytes.length ? ALPHABET[triple & 63] : '=');
-        // In pieces: one string grown a character at a time over a whole floor is slow to build.
-        if (chunk.length >= 8192) {
-            chunks.push(chunk);
-            chunk = '';
-        }
-    }
-    return chunks.join('') + chunk;
-}
-/**
- * Bytes packed as runs: the value, then the run's length as a little-endian base-128 number, and
- * the whole as base64. A floor's map is long stretches of one value.
- * @param bytes The bytes.
- * @returns The packed text.
- */
-export function packRuns(bytes) {
-    const runs = [];
-    for (let start = 0; start < bytes.length;) {
-        let end = start + 1;
-        while (end < bytes.length && bytes[end] === bytes[start])
-            end++;
-        runs.push(bytes[start]);
-        for (let length = end - start;; length >>>= 7) {
-            if (length < 128) {
-                runs.push(length);
-                break;
-            }
-            runs.push((length & 127) | 128);
-        }
-        start = end;
-    }
-    return toBase64(Uint8Array.from(runs));
-}
-/**
- * One floor's lattice and docks as the map handed to the runtime, in plan units.
- * @param layer The floor's layer id.
- * @param lattice The lattice, in meters.
- * @param docks The docks leaving it, in meters, in the lattice's own order.
- * @param unitsPerMeter Plan coordinates in one meter.
- * @returns The floor's map.
- */
-export function latticeMap(layer, lattice, docks, unitsPerMeter) {
-    const at = (v) => +(v * unitsPerMeter).toFixed(PLAN_DECIMALS);
-    const nodeX = (cell) => lattice.origin[0] + (cell % lattice.width) * lattice.pitch;
-    const nodeY = (cell) => lattice.origin[1] + Math.floor(cell / lattice.width) * lattice.pitch;
-    const turns = [];
-    docks.forEach((dock, index) => {
-        const cell = lattice.dockCells[index];
-        // A dock that leaves from elsewhere than its node turns there on its way: a doorway's middle.
-        if (at(dock.from[0]) !== at(nodeX(cell)) || at(dock.from[1]) !== at(nodeY(cell)))
-            turns.push(index, at(dock.from[0]), at(dock.from[1]));
-    });
-    return {
-        layer,
-        x: at(lattice.origin[0]),
-        y: at(lattice.origin[1]),
-        pitch: +(lattice.pitch * unitsPerMeter).toFixed(6),
-        width: lattice.width,
-        height: lattice.height,
-        links: packRuns(lattice.links),
-        near: +(NEAR * unitsPerMeter).toFixed(6),
-        ...(lattice.sparseFrom !== undefined && {
-            sparseFrom: +(lattice.sparseFrom * unitsPerMeter).toFixed(6),
-        }),
-        docks: docks.flatMap((dock, index) => [
-            at(dock.to[0]),
-            at(dock.to[1]),
-            lattice.dockCells[index],
-        ]),
-        ...(turns.length && { turns }),
-    };
-}

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

@@ -1,32 +0,0 @@
-import type { Ring } from './geom/types.js';
-import type { PreparedWalls } from './geom/walls.js';
-import { type NetworkVariant, type RouteNetwork, type RouteNetworkDestination } from './graph-types.js';
-import type { Opening } from './openings.js';
-/** How a lattice is spaced. */
-export interface LatticeSpacing {
-    /** Distance between neighboring nodes, in meters. */
-    readonly pitch: number;
-    /**
-     * How far from the nearest cell nobody can stand in open floor begins, in meters: there the
-     * reader stands its nodes two cells apart. Absent, a node stands in every cell.
-     */
-    readonly sparseFrom?: number;
-}
-/** The spacing of each lattice network. */
-export declare const LATTICE_SPACING: Readonly<Record<Exclude<NetworkVariant, 'steiner'>, LatticeSpacing>>;
-/**
- * Builds the lattice 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.
- * @param spacing How the lattice is spaced.
- * @returns The docks, the lattice they stand on, and stats.
- */
-export declare function buildLatticeNetwork(walkableRings: readonly Ring[], destinations: readonly RouteNetworkDestination[], walls: readonly (readonly number[])[], prepared: PreparedWalls | undefined, drawn: readonly {
-    readonly id: string;
-    readonly ring: Ring;
-}[], openings: readonly Opening[], spacing: LatticeSpacing): RouteNetwork;
-//# sourceMappingURL=lattice-network.d.ts.map

package/dist/lib/lattice-network.js

@@ -1,289 +0,0 @@
-// The "grid" route-network generators: the walkable floor itself is the graph. Every cell of the
-// raster a person can stand in is a node, joined to its neighbors in eight directions wherever the
-// step crosses nothing; on open floor the reader may stand its nodes two cells apart. A stub per
-// open face ends on a node, and the dock runs from there. Nothing is laid, grown or straightened: the route is
-// found over the lattice at run time. Produces a {@link RouteNetwork} that carries a {@link Lattice}.
-import { crossesBlocker } from './blockers.js';
-import { dockFor, turnsInDoorway } from './entries.js';
-import { floorGrids } from './floor-grids.js';
-import { snapCm } from './geom/point-key.js';
-import { LATTICE_STEPS, } from './graph-types.js';
-import { setUpNetwork } from './network-setup.js';
-import { MIN_PASS } from './network-sizes.js';
-import { makeRouter } from './router.js';
-import { planStubs, sideOf } from './stubs.js';
-/** The spacing of each lattice network. */
-export const LATTICE_SPACING = {
-    grid: { pitch: 0.5, sparseFrom: 0.5 },
-    'grid-fine': { pitch: 0.5 },
-    'grid-coarse': { pitch: 1 },
-};
-/**
- * Builds the lattice 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.
- * @param spacing How the lattice is spaced.
- * @returns The docks, the lattice they stand on, and stats.
- */
-export function buildLatticeNetwork(walkableRings, destinations, walls, prepared, drawn, openings, spacing) {
-    const { cfg, wallLines, doors, owners, opened, floor, unservedFloorPieces, doorSides, blockers, destinationOf, failed, note, } = setUpNetwork(walkableRings, destinations, walls, prepared, drawn, openings);
-    const { grids, frames, frameOfDest } = floorGrids(floor, doorSides, destinations, wallLines, doors, cfg, false);
-    const ctx = grids[0].ctx;
-    const router = makeRouter(grids, { ...cfg, pitch: spacing.pitch });
-    const { pitch, clearance } = router;
-    const { width, height } = router.size;
-    const cells = width * height;
-    const [originX, originY] = router.worldOf(0);
-    const nodeAt = (cell) => [
-        snapCm(originX + (cell % width) * pitch),
-        snapCm(originY + Math.floor(cell / width) * pitch),
-    ];
-    /* ---- the steps: every cell joined to the neighbors a person can step to ---- */
-    /**
-     * The cell one step from another, as the raster walks it. A diagonal step is taken only when both
-     * ways round its corner are open: a route never cuts a corner.
-     * @param cell The cell stepped from.
-     * @param step Which of {@link LATTICE_STEPS}.
-     * @returns The cell stepped onto, or -1.
-     */
-    const stepFrom = (cell, step) => {
-        if (step < 4)
-            return router.stepTo(cell, step);
-        const [dx, dy] = LATTICE_STEPS[step];
-        const across = dx > 0 ? 0 : 1;
-        const along = dy > 0 ? 2 : 3;
-        const side = router.stepTo(cell, across);
-        const ahead = router.stepTo(cell, along);
-        if (side < 0 || ahead < 0)
-            return -1;
-        const corner = router.stepTo(side, along);
-        return corner >= 0 && router.stepTo(ahead, across) === corner ? corner : -1;
-    };
-    // A node stands where a person can: the cell is walkable and its middle is floor.
-    const stands = new Uint8Array(cells);
-    for (let cell = 0; cell < cells; cell++)
-        if (router.ok[cell] && ctx.freeAt(...nodeAt(cell)))
-            stands[cell] = 1;
-    // Far enough from anything that blocks, a step cannot cross it; nearer, the step is read against
-    // the walls and outlines as drawn.
-    const safe = pitch * (Math.SQRT2 + 1);
-    const unit = new Uint8Array(cells);
-    for (let cell = 0; cell < cells; cell++) {
-        if (!stands[cell])
-            continue;
-        // One of each pair of opposite steps: the other is the same step read from its far end.
-        for (let step = 0; step < 8; step += 2) {
-            const next = stepFrom(cell, step);
-            if (next < 0 || !stands[next])
-                continue;
-            if ((clearance[cell] < safe || clearance[next] < safe) &&
-                crossesBlocker(blockers, [...nodeAt(cell), ...nodeAt(next)]))
-                continue;
-            unit[cell] |= 1 << step;
-            unit[next] |= 1 << (step ^ 1);
-        }
-    }
-    const offset = LATTICE_STEPS.map(([dx, dy]) => dy * width + dx);
-    // The connected parts of the lattice, by cell; -1 where no node stands.
-    const part = new Int32Array(cells).fill(-1);
-    let parts = 0;
-    for (let seed = 0; seed < cells; seed++) {
-        if (!unit[seed] || part[seed] >= 0)
-            continue;
-        const queue = [seed];
-        part[seed] = parts;
-        for (let head = 0; head < queue.length; head++) {
-            const cell = queue[head];
-            for (let step = 0; step < 8; step++) {
-                const next = cell + offset[step];
-                if (!(unit[cell] & (1 << step)) || part[next] >= 0)
-                    continue;
-                part[next] = parts;
-                queue.push(next);
-            }
-        }
-        parts++;
-    }
-    /* ---- stubs: one per open side of each destination, as the steiner network plans them ---- */
-    const build = { cfg, frames, blockers, destinationOf, note };
-    const plan = planStubs({ ...build, destinations, owners, ctx, frameOfDest, opened });
-    const whiskers = [];
-    const anchors = [];
-    /** Sides of each destination a whisker already serves. */
-    const servedSides = new Map();
-    /** The cells stubs stand on, by the part of the lattice they are in. */
-    const tipCells = new Map();
-    /**
-     * The node a stub ends on: the one in its planned tip's cell, else the nearest along the stub —
-     * the first a lawful dock runs from.
-     * @param stub The stub; its tip moves to the node.
-     * @returns The node's cell, or -1 when the stub has none (noted).
-     */
-    const seat = (stub) => {
-        const destination = destinationOf.get(stub.id);
-        const farthest = Math.min(stub.way.depth - MIN_PASS, stub.reach + 2 * cfg.stub);
-        let onFloor = false;
-        for (let steps = 0; steps * pitch <= farthest + stub.reach; steps++)
-            for (const sign of steps ? [-1, 1] : [1]) {
-                const run = sign * steps * pitch;
-                if (stub.reach + run < MIN_PASS || stub.reach + run > farthest)
-                    continue;
-                const cell = router.cellIn(stub.tx + stub.nx * run, stub.ty + stub.ny * run, frames[0]);
-                if (cell < 0 || !unit[cell])
-                    continue;
-                onFloor = true;
-                if (!dockFor(destination, stub.way, nodeAt(cell), blockers))
-                    continue;
-                [stub.tx, stub.ty] = nodeAt(cell);
-                anchors.push({ id: stub.id, at: [stub.tx, stub.ty] });
-                return cell;
-            }
-        note(stub.id, onFloor ? 'way-in-blocked' : 'no-floor', { at: [stub.tx, stub.ty] });
-        return -1;
-    };
-    let pending = plan.stubs;
-    // A stub that found no node, or stands alone on its part of the floor, is retried from its
-    // destination's next way in.
-    while (pending.length) {
-        const seated = pending.flatMap((stub) => {
-            const cell = seat(stub);
-            return cell < 0 ? [] : [{ stub, cell }];
-        });
-        const lost = pending.filter((stub) => !seated.some((entry) => entry.stub === stub));
-        const arriving = new Map();
-        for (const { cell } of seated)
-            arriving.set(part[cell], (arriving.get(part[cell]) ?? new Set()).add(cell));
-        for (const entry of seated) {
-            const { stub, cell } = entry;
-            const known = tipCells.get(part[cell]);
-            // A part of the floor only this tip stands on leads nowhere.
-            if (!known && arriving.get(part[cell]).size < 2) {
-                note(stub.id, 'cut-off', { at: [stub.tx, stub.ty] });
-                lost.push(stub);
-                continue;
-            }
-            whiskers.push(entry);
-            if (stub.kind === 'face')
-                servedSides.set(stub.id, (servedSides.get(stub.id) ?? new Set()).add(sideOf(stub.way)));
-        }
-        for (const { cell } of whiskers)
-            tipCells.set(part[cell], (tipCells.get(part[cell]) ?? new Set()).add(cell));
-        pending = lost.flatMap((stub) => plan.retry(stub, servedSides, whiskers.map((entry) => entry.stub)) ?? []);
-    }
-    /* ---- docks: from each stub's node into its destination ---- */
-    /** Docking-ring sides already taken, per destination: one stub per side. */
-    const usedEdges = new Map();
-    const lawful = [];
-    for (const { stub, cell } of whiskers) {
-        const destination = destinationOf.get(stub.id);
-        const tip = [stub.tx, stub.ty];
-        const docked = dockFor(destination, stub.way, tip, blockers, usedEdges.get(stub.id));
-        if (!docked) {
-            note(stub.id, 'detached', { at: tip, by: 'dock-unlawful' });
-            continue;
-        }
-        if (docked.edge !== undefined)
-            usedEdges.set(stub.id, (usedEdges.get(stub.id) ?? new Set()).add(docked.edge));
-        // A doorway dock that ends toward a side of its ring turns at the doorway's middle: a line runs
-        // there from the node, and the dock leaves from the middle.
-        const middle = [stub.mx, stub.my];
-        const turns = turnsInDoorway(destination, stub, tip, docked.to);
-        lawful.push({
-            dock: { id: stub.id, from: turns ? middle : tip, to: docked.to },
-            cell,
-            turn: turns ? [tip, middle] : null,
-        });
-    }
-    // The parts kept: most docks first, each next part only when it docks a destination no kept part
-    // does — a part the floor cuts off serves what nothing else can, and nothing else.
-    const dockCount = new Map();
-    for (const { cell } of lawful)
-        dockCount.set(part[cell], (dockCount.get(part[cell]) ?? 0) + 1);
-    const serving = new Set();
-    const reached = new Set();
-    for (const [label] of [...dockCount.entries()].sort((a, b) => b[1] - a[1] || a[0] - b[0])) {
-        const ids = lawful.filter(({ cell }) => part[cell] === label).map(({ dock }) => dock.id);
-        if (!ids.some((id) => !reached.has(id)))
-            continue;
-        serving.add(label);
-        for (const id of ids)
-            reached.add(id);
-    }
-    const kept = lawful.filter(({ cell }) => serving.has(part[cell]));
-    /* ---- the map: the kept parts' cells, cut to the box that holds them ---- */
-    let minX = width;
-    let minY = height;
-    let maxX = -1;
-    let maxY = -1;
-    for (let cell = 0; cell < cells; cell++) {
-        if (!serving.has(part[cell]))
-            continue;
-        minX = Math.min(minX, cell % width);
-        maxX = Math.max(maxX, cell % width);
-        minY = Math.min(minY, Math.floor(cell / width));
-        maxY = Math.max(maxY, Math.floor(cell / width));
-    }
-    const across = Math.max(0, maxX - minX + 1);
-    const down = Math.max(0, maxY - minY + 1);
-    const links = new Uint8Array(across * down);
-    for (let y = 0; y < down; y++)
-        for (let x = 0; x < across; x++) {
-            const cell = (minY + y) * width + minX + x;
-            if (serving.has(part[cell]))
-                links[y * across + x] = unit[cell];
-        }
-    const cropOf = (cell) => (Math.floor(cell / width) - minY) * across + ((cell % width) - minX);
-    const labels = [...serving].sort((a, b) => a - b);
-    const ways = [];
-    for (const [id, list] of plan.ways)
-        for (const way of list)
-            ways.push({ id, kind: way.kind, foot: [way.mx, way.my], normal: [way.nx, way.ny] });
-    return {
-        paths: kept.flatMap(({ turn }) => (turn ? [turn] : [])),
-        docks: kept.map(({ dock }) => dock),
-        lattice: {
-            origin: across ? nodeAt(minY * width + minX) : [originX, originY],
-            pitch,
-            width: across,
-            height: down,
-            links,
-            ...(spacing.sparseFrom !== undefined && { sparseFrom: spacing.sparseFrom }),
-            dockCells: kept.map(({ cell }) => cropOf(cell)),
-            dockParts: kept.map(({ cell }) => labels.indexOf(part[cell])),
-        },
-        anatomy: {
-            doors: doors.map((door) => ({
-                gap: [
-                    [door.gap[0], door.gap[1]],
-                    [door.gap[2], door.gap[3]],
-                ],
-                mid: [door.mid[0], door.mid[1]],
-            })),
-            anchors,
-            ways,
-            whiskers: whiskers.map(({ stub }) => ({
-                id: stub.id,
-                kind: stub.kind,
-                foot: [stub.mx, stub.my],
-                tip: [stub.tx, stub.ty],
-            })),
-            frames: [],
-            loose: [],
-            axes: [],
-        },
-        stats: {
-            unreached: destinations
-                .filter((d) => !reached.has(d.id))
-                .map((d) => failed.get(d.id) ?? { id: d.id, reason: 'detached' }),
-            components: tipCells.size,
-            doorways: doors.length,
-            shortcuts: 0,
-            ...(tipCells.size > 1 && { untiedPieces: tipCells.size - 1 }),
-            ...(unservedFloorPieces > 0 && { unservedFloorPieces }),
-        },
-    };
-}

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

@@ -1,50 +0,0 @@
-import { type Blockers } from './blockers.js';
-import { type DoorSide, type Doorway } from './doorways.js';
-import type { Ring, Segment } from './geom/types.js';
-import { type PreparedWalls } from './geom/walls.js';
-import type { RouteNetworkDestination, Unreached } from './graph-types.js';
-import type { NetworkBuild } from './network-build.js';
-import { type NetworkSizes } from './network-sizes.js';
-import type { Opening } from './openings.js';
-/** A layer as a route-network generator finds it. */
-export interface NetworkSetup {
-    /** Network sizes. */
-    readonly cfg: NetworkSizes;
-    /** The layer's wall segments. */
-    readonly wallLines: readonly Segment[];
-    /** The doorways the walls leave. */
-    readonly doors: readonly Doorway[];
-    /** Doorway sides by the destination they open into, the entrances' openings included. */
-    readonly owners: ReadonlyMap<string, readonly DoorSide[]>;
-    /** Entrances with openings: reached through their doorways alone, never from a face. */
-    readonly opened: ReadonlySet<string>;
-    /** The floor pieces a route can serve. */
-    readonly floor: readonly Ring[];
-    /** Walkable floor pieces no destination or doorway serves, left out of the network. */
-    readonly unservedFloorPieces: number;
-    /** The closed sides of the doorways: only a doorway's middle stays open. */
-    readonly doorSides: readonly Segment[];
-    /** What a line or a dock may not cross; a doorway's closed sides block like walls. */
-    readonly blockers: Blockers;
-    /** The layer's destinations, by id. */
-    readonly destinationOf: ReadonlyMap<string, RouteNetworkDestination>;
-    /** Why each destination without a dock has none: the most informative reason noted. */
-    readonly failed: ReadonlyMap<string, Unreached>;
-    /** Records why a destination has no dock yet; see {@link NetworkBuild.note}. */
-    readonly note: NetworkBuild['note'];
-}
-/**
- * Reads a layer for a route-network generator.
- * @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 The layer as the generators read it.
- */
-export declare function setUpNetwork(walkableRings: readonly Ring[], destinations: readonly RouteNetworkDestination[], walls: readonly (readonly number[])[], prepared: PreparedWalls | undefined, drawn: readonly {
-    readonly id: string;
-    readonly ring: Ring;
-}[], openings: readonly Opening[]): NetworkSetup;
-//# sourceMappingURL=network-setup.d.ts.map

package/dist/lib/network-setup.js

@@ -1,76 +0,0 @@
-// What every route-network generator reads of a layer before it lays a line: the doorways and who
-// owns them, the openings the entrances make, the floor a route can serve, what a line may not
-// cross, and where a destination the build could not serve is noted. Read once here, so every
-// generator docks the same ways in.
-import { blockersOf } from './blockers.js';
-import { DOOR_WELD, doorOwners, doorwaySides, findDoorways, } from './doorways.js';
-import { servedFloor } from './floor-grids.js';
-import { prepareWalls } from './geom/walls.js';
-import { NETWORK_SIZES } from './network-sizes.js';
-/**
- * Reads a layer for a route-network generator.
- * @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 The layer as the generators read it.
- */
-export function setUpNetwork(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);
-    // A doorway's closed sides block stubs and docks like walls.
-    const blockers = blockersOf(destinations, [...wallLines, ...doorSides], doors, drawn, new Set(owners.keys()), passes);
-    /** 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 });
-    };
-    return {
-        cfg,
-        wallLines,
-        doors,
-        owners,
-        opened,
-        floor,
-        unservedFloorPieces,
-        doorSides,
-        blockers,
-        destinationOf: new Map(destinations.map((d) => [d.id, d])),
-        failed,
-        note,
-    };
-}