@expofp/wayfinding-compiler 0.0.0-bootstrap.0

package/dist/lib/lattice-network.js

@@ -0,0 +1,289 @@
+// 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/mask.d.ts

@@ -0,0 +1,54 @@
+import type { Box, Ring } from './geom/types.js';
+import { type NetworkSizes } from './network-sizes.js';
+/** The walkable floor as a grid of cells, with how far each of them is from anything blocked. */
+export interface MaskCtx {
+    /** Cell size. */
+    readonly cs: number;
+    /** Width in cells. */
+    readonly w: number;
+    /** Height in cells. */
+    readonly h: number;
+    /** Grid origin x. */
+    readonly ox: number;
+    /** Grid origin y. */
+    readonly oy: number;
+    /** 1 for floor, row-major. */
+    readonly mask: Uint8Array;
+    /** Meters from each cell to the nearest blocked one. */
+    readonly dist: Float32Array;
+    /**
+     * Whether a point is on the floor.
+     * @param x Point x.
+     * @param y Point y.
+     * @returns True on the floor.
+     */
+    freeAt(x: number, y: number): boolean;
+    /**
+     * Whether a straight line stays on floor (sampled at under a cell).
+     * @param ax Start x.
+     * @param ay Start y.
+     * @param bx End x.
+     * @param by End y.
+     * @returns True when every sample is floor.
+     */
+    lineFree(ax: number, ay: number, bx: number, by: number): boolean;
+}
+/**
+ * Rasterize the walkable rings (walls and footprints already cut out) and their clearance field.
+ * @param rings The walkable polygon (outer rings + holes).
+ * @param cfg Network sizes.
+ * @param within Box to read; the rings' bounds by default.
+ * @returns The mask and its clearance field.
+ */
+export declare function buildMaskCtx(rings: readonly Ring[], cfg: NetworkSizes, within?: Box): MaskCtx;
+/**
+ * Opens a doorway's throat to the router and to the lines laid through it: floor cells within `r`
+ * of the middle count a person's clearance, so a route can pass a doorway narrower than two
+ * clearances. Only cells already free are lifted; the jambs and walls stay closed.
+ * @param ctx The mask, in its own coordinates.
+ * @param mx Doorway middle x.
+ * @param my Doorway middle y.
+ * @param r The throat's radius.
+ */
+export declare function openDoorMiddle(ctx: MaskCtx, mx: number, my: number, r: number): void;
+//# sourceMappingURL=mask.d.ts.map

package/dist/lib/mask.js

@@ -0,0 +1,210 @@
+// The raster mask the route network grows over: the walkable floor as cells, with how far each cell is
+// from anything blocked.
+import { cellArray } from './cell-array.js';
+import { boundsOf } from './geom/primitives.js';
+import { MIN_PASS } from './network-sizes.js';
+/**
+ * Rasterize the walkable rings (walls and footprints already cut out) and their clearance field.
+ * @param rings The walkable polygon (outer rings + holes).
+ * @param cfg Network sizes.
+ * @param within Box to read; the rings' bounds by default.
+ * @returns The mask and its clearance field.
+ */
+export function buildMaskCtx(rings, cfg, within) {
+    let [minx, miny, maxx, maxy] = within ?? boundsOf(rings.flat());
+    if (!isFinite(minx)) {
+        minx = 0;
+        miny = 0;
+        maxx = 1;
+        maxy = 1;
+    }
+    const cs = cfg.cs;
+    const ox = minx - 1;
+    const oy = miny - 1;
+    const w = Math.max(4, Math.ceil((maxx - minx + 2) / cs));
+    const h = Math.max(4, Math.ceil((maxy - miny + 2) / cs));
+    const mask = cellArray(Uint8Array, w * h);
+    // Nonzero-winding scanline fill over an active edge list.
+    const fillPolys = (polys, value) => {
+        const edges = [];
+        for (const poly of polys)
+            for (let i = 0; i < poly.length; i++) {
+                const [ax, ay] = poly[i];
+                const [bx, by] = poly[(i + 1) % poly.length];
+                if (ay !== by)
+                    edges.push({
+                        ax,
+                        ay,
+                        bx,
+                        by,
+                        lo: Math.min(ay, by),
+                        hi: Math.max(ay, by),
+                        dir: by > ay ? 1 : -1,
+                    });
+            }
+        edges.sort((p, q) => p.lo - q.lo);
+        const active = [];
+        let next = 0;
+        for (let gy = 0; gy < h; gy++) {
+            const y = oy + (gy + 0.5) * cs;
+            const xs = [];
+            while (next < edges.length && edges[next].lo <= y)
+                active.push(edges[next++]);
+            for (let k = active.length - 1; k >= 0; k--)
+                if (active[k].hi <= y) {
+                    active[k] = active[active.length - 1];
+                    active.pop();
+                }
+            for (const { ax, ay, bx, by, dir } of active)
+                xs.push([ax + ((bx - ax) * (y - ay)) / (by - ay), dir]);
+            xs.sort((u, v) => u[0] - v[0]);
+            let wind = 0;
+            for (let k = 0; k + 1 < xs.length; k++) {
+                wind += xs[k][1];
+                if (wind === 0)
+                    continue;
+                const i0 = Math.max(0, Math.ceil((xs[k][0] - ox) / cs - 0.5));
+                const i1 = Math.min(w - 1, Math.floor((xs[k + 1][0] - ox) / cs - 0.5));
+                for (let i = i0; i <= i1; i++)
+                    mask[gy * w + i] = value;
+            }
+        }
+    };
+    fillPolys(rings, 1);
+    // A cell is floor only when no boundary edge passes through it, so a strip thinner than a cell still
+    // closes the cells it crosses. Cells are found by exact grid traversal of each edge.
+    const close = (gx, gy) => {
+        if (gx >= 0 && gy >= 0 && gx < w && gy < h)
+            mask[gy * w + gx] = 0;
+    };
+    const cover = (ax, ay, bx, by) => {
+        let gx = Math.floor((ax - ox) / cs);
+        let gy = Math.floor((ay - oy) / cs);
+        const ex = Math.floor((bx - ox) / cs);
+        const ey = Math.floor((by - oy) / cs);
+        const dx = bx - ax;
+        const dy = by - ay;
+        const sx = Math.sign(dx);
+        const sy = Math.sign(dy);
+        const tdx = dx ? cs / Math.abs(dx) : Infinity;
+        const tdy = dy ? cs / Math.abs(dy) : Infinity;
+        let tx = dx ? (ox + (gx + (dx > 0 ? 1 : 0)) * cs - ax) / dx : Infinity;
+        let ty = dy ? (oy + (gy + (dy > 0 ? 1 : 0)) * cs - ay) / dy : Infinity;
+        close(gx, gy);
+        for (let guard = Math.abs(ex - gx) + Math.abs(ey - gy) + 2; guard > 0; guard--) {
+            if (gx === ex && gy === ey)
+                break;
+            if (tx < ty) {
+                gx += sx;
+                tx += tdx;
+            }
+            else if (ty < tx) {
+                gy += sy;
+                ty += tdy;
+            }
+            else {
+                // Through a grid corner: both cells beside it are touched.
+                close(gx + sx, gy);
+                close(gx, gy + sy);
+                gx += sx;
+                gy += sy;
+                tx += tdx;
+                ty += tdy;
+            }
+            close(gx, gy);
+        }
+    };
+    for (const ring of rings)
+        for (let i = 0; i < ring.length; i++) {
+            const a = ring[i];
+            const b = ring[(i + 1) % ring.length];
+            cover(a[0], a[1], b[0], b[1]);
+        }
+    // Chamfer distance (meters) to the nearest blocked cell.
+    const dist = cellArray(Float32Array, w * h).fill(1e9);
+    for (let i = 0; i < w * h; i++)
+        if (!mask[i])
+            dist[i] = 0;
+    const d1 = cs;
+    const d2 = cs * Math.SQRT2;
+    for (let y = 0; y < h; y++)
+        for (let x = 0; x < w; x++) {
+            const i = y * w + x;
+            if (x > 0)
+                dist[i] = Math.min(dist[i], dist[i - 1] + d1);
+            if (y > 0)
+                dist[i] = Math.min(dist[i], dist[i - w] + d1);
+            if (x > 0 && y > 0)
+                dist[i] = Math.min(dist[i], dist[i - w - 1] + d2);
+            if (x < w - 1 && y > 0)
+                dist[i] = Math.min(dist[i], dist[i - w + 1] + d2);
+        }
+    for (let y = h - 1; y >= 0; y--)
+        for (let x = w - 1; x >= 0; x--) {
+            const i = y * w + x;
+            if (x < w - 1)
+                dist[i] = Math.min(dist[i], dist[i + 1] + d1);
+            if (y < h - 1)
+                dist[i] = Math.min(dist[i], dist[i + w] + d1);
+            if (x < w - 1 && y < h - 1)
+                dist[i] = Math.min(dist[i], dist[i + w + 1] + d2);
+            if (x > 0 && y < h - 1)
+                dist[i] = Math.min(dist[i], dist[i + w - 1] + d2);
+        }
+    const cellAt = (x, y) => {
+        const gx = Math.floor((x - ox) / cs);
+        const gy = Math.floor((y - oy) / cs);
+        return gx >= 0 && gy >= 0 && gx < w && gy < h ? gy * w + gx : -1;
+    };
+    const freeAt = (x, y) => {
+        const c = cellAt(x, y);
+        return c >= 0 && mask[c] === 1;
+    };
+    const lineFree = (ax, ay, bx, by) => {
+        const len = Math.hypot(bx - ax, by - ay);
+        const n = Math.max(2, Math.ceil(len / (cs * 0.6)));
+        for (let i = 1; i < n; i++) {
+            const s = i / n;
+            if (!freeAt(ax + (bx - ax) * s, ay + (by - ay) * s))
+                return false;
+        }
+        return true;
+    };
+    return {
+        cs,
+        w,
+        h,
+        ox,
+        oy,
+        mask,
+        dist,
+        freeAt,
+        lineFree,
+    };
+}
+/**
+ * Opens a doorway's throat to the router and to the lines laid through it: floor cells within `r`
+ * of the middle count a person's clearance, so a route can pass a doorway narrower than two
+ * clearances. Only cells already free are lifted; the jambs and walls stay closed.
+ * @param ctx The mask, in its own coordinates.
+ * @param mx Doorway middle x.
+ * @param my Doorway middle y.
+ * @param r The throat's radius.
+ */
+export function openDoorMiddle(ctx, mx, my, r) {
+    const { cs, ox, oy, w, h, mask, dist } = ctx;
+    const gx0 = Math.max(0, Math.floor((mx - r - ox) / cs));
+    const gx1 = Math.min(w - 1, Math.floor((mx + r - ox) / cs));
+    const gy0 = Math.max(0, Math.floor((my - r - oy) / cs));
+    const gy1 = Math.min(h - 1, Math.floor((my + r - oy) / cs));
+    for (let gy = gy0; gy <= gy1; gy++)
+        for (let gx = gx0; gx <= gx1; gx++) {
+            const cx = ox + (gx + 0.5) * cs;
+            const cy = oy + (gy + 0.5) * cs;
+            if (Math.hypot(cx - mx, cy - my) > r)
+                continue;
+            const c = gy * w + gx;
+            if (mask[c] === 1 && dist[c] < MIN_PASS)
+                dist[c] = MIN_PASS;
+        }
+}

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

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

package/dist/lib/min-heap.js

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

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

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

package/dist/lib/network-build.js

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