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

package/dist/lib/geom/walls.js

@@ -1,71 +0,0 @@
-import { cleanPolylineRuns } from './normalize.js';
-/**
- * Order two points by x, then by y.
- * @param a One point.
- * @param b The other.
- * @returns Negative when `a` comes first.
- */
-function comparePoints(a, b) {
-    return a[0] - b[0] || a[1] - b[1];
-}
-/**
- * A run in canonical direction: open from its smaller end; closed from its smallest vertex towards the
- * smaller neighbor.
- * @param run The run.
- * @returns The run in canonical direction.
- */
-function canonicalRun(run) {
-    const { points, closed } = run;
-    if (!closed)
-        return comparePoints(points[points.length - 1], points[0]) < 0
-            ? { points: [...points].reverse(), closed }
-            : run;
-    let start = 0;
-    for (let i = 1; i < points.length; i++)
-        if (comparePoints(points[i], points[start]) < 0)
-            start = i;
-    const n = points.length;
-    const forward = comparePoints(points[(start + 1) % n], points[(start + n - 1) % n]) <= 0;
-    return { points: points.map((_, i) => points[(start + (forward ? i : n - i)) % n]), closed };
-}
-/**
- * Order two runs point by point; on a shared prefix, the shorter first, then the open one.
- * @param a One run.
- * @param b The other.
- * @returns Negative when `a` comes first.
- */
-function compareRuns(a, b) {
-    for (let i = 0; i < a.points.length && i < b.points.length; i++) {
-        const order = comparePoints(a.points[i], b.points[i]);
-        if (order)
-            return order;
-    }
-    return a.points.length - b.points.length || Number(a.closed) - Number(b.closed);
-}
-/**
- * Reads a layer's raw walls once for every stage. Runs are canonicalized and sorted, so wall order and
- * drawing direction do not change the network.
- * @param walls Raw walls as flat `[x0, y0, …]` runs.
- * @returns The runs and their segments.
- */
-export function prepareWalls(walls) {
-    const cleaned = walls.map((flat) => cleanPolylineRuns(flat));
-    const entries = cleaned
-        .map((entryRuns, entry) => ({
-        entry,
-        runs: entryRuns.length,
-        oddTail: walls[entry].length % 2 === 1,
-    }))
-        .filter(({ entry, runs, oddTail }) => runs > 1 || oddTail || (runs === 0 && walls[entry].length > 0));
-    const runs = cleaned.flat().map(canonicalRun).sort(compareRuns);
-    const segments = [];
-    for (const run of runs) {
-        const n = run.closed ? run.points.length : run.points.length - 1;
-        for (let i = 0; i < n; i++) {
-            const a = run.points[i];
-            const b = run.points[(i + 1) % run.points.length];
-            segments.push([a[0], a[1], b[0], b[1]]);
-        }
-    }
-    return { runs, segments, entries };
-}

package/dist/lib/graph-invariants.d.ts

@@ -1,49 +0,0 @@
-import type { SourceDestination, WfV1Graph } from './types.js';
-type Seg = [number, number, number, number];
-type Pt = readonly [number, number];
-/** What a finding breaches. */
-type InvariantCode = 
-/** A network segment or a dock crosses a wall of its layer. */
-'line-crosses-wall'
-/** Two network segments cross, or one ends inside another, with no node at the meeting. */
-/** A segment or a dock passes through a solid footprint it is not serving. */
- | 'line-crosses-poi'
-/** A dock's tip lies inside no ring a destination is bound by. */
- | 'dock-outside-ring';
-/** One breach of a graph invariant, in plan units. */
-export interface InvariantFinding {
-    /** What is breached. */
-    readonly code: InvariantCode;
-    /** The layer it is on. */
-    readonly layer: string;
-    /** Indices into `graph.lines` of the offending segments. */
-    readonly lines: readonly number[];
-    /** The dock's tip, when the offending segment is a dock. */
-    readonly at?: Pt;
-}
-/**
- * Do two segments properly cross — endpoints and collinear touching excluded?
- * @param a One segment.
- * @param b The other.
- * @returns True when each passes strictly through the other.
- */
-export declare function crosses(a: Seg, b: Seg): boolean;
-/** What one layer carries into the checks, as `LayerDebug` already holds it. */
-export interface InvariantLayer {
-    /** The layer id. */
-    readonly layer: string;
-    /** The wall polylines as given (flat `[x0, y0, …]`). */
-    readonly rawWalls: readonly (readonly number[])[];
-    /** The destinations as the stages saw them. */
-    readonly destinations: readonly SourceDestination[];
-}
-/**
- * Checks the emitted graph against the geometric invariants, layer by layer. Reads only; computes
- * no geometry the checks themselves do not need.
- * @param graph The emitted graph, in plan units.
- * @param layers The layers' raw walls and destinations, as `LayerDebug` carries them.
- * @returns Every breach found, in layer order, walls → crossings → footprints → rings.
- */
-export declare function checkGraphInvariants(graph: WfV1Graph, layers: readonly InvariantLayer[]): InvariantFinding[];
-export {};
-//# sourceMappingURL=graph-invariants.d.ts.map

package/dist/lib/graph-invariants.js

@@ -1,129 +0,0 @@
-// The geometric promises the emitted graph is held to, as pure functions over what the compile
-// already computed: no line through a wall, no line through a destination it is not serving, every
-// dock ending inside its ring. Lines may cross or end on one another: the converter that builds
-// wf.data.js cuts them there. The debug compile runs them.
-import { cleanPolylineRuns } from './geom/normalize.js';
-/**
- * Do two segments properly cross — endpoints and collinear touching excluded?
- * @param a One segment.
- * @param b The other.
- * @returns True when each passes strictly through the other.
- */
-export function crosses(a, b) {
-    const side = (s, px, py) => Math.sign((s[2] - s[0]) * (py - s[1]) - (s[3] - s[1]) * (px - s[0]));
-    const d1 = side(a, b[0], b[1]);
-    const d2 = side(a, b[2], b[3]);
-    const d3 = side(b, a[0], a[1]);
-    const d4 = side(b, a[2], a[3]);
-    return d1 !== d2 && d3 !== d4 && d1 !== 0 && d2 !== 0 && d3 !== 0 && d4 !== 0;
-}
-/**
- * Ray-cast even-odd point-in-ring test, matching the engine's own containment check.
- * @param ring The ring.
- * @param p The point.
- * @returns True inside.
- */
-function ringContains(ring, p) {
-    let inside = false;
-    for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
-        const [xi, yi] = ring[i];
-        const [xj, yj] = ring[j];
-        if (yi > p[1] !== yj > p[1] && p[0] < ((xj - xi) * (p[1] - yi)) / (yj - yi) + xi)
-            inside = !inside;
-    }
-    return inside;
-}
-/**
- * Every wall of a layer, segment by segment.
- * @param flats The layer's wall runs as flat coordinate lists.
- * @returns The segments.
- */
-function wallsOf(flats) {
-    const walls = [];
-    for (const flat of flats)
-        for (const run of cleanPolylineRuns(flat)) {
-            const points = run.closed ? [...run.points, run.points[0]] : run.points;
-            for (let i = 0; i + 1 < points.length; i++)
-                walls.push([points[i][0], points[i][1], points[i + 1][0], points[i + 1][1]]);
-        }
-    return walls;
-}
-/**
- * The edges of a ring.
- * @param ring The ring.
- * @returns One segment per edge.
- */
-function edgesOf(ring) {
-    return ring.map((a, i) => {
-        const b = ring[(i + 1) % ring.length];
-        return [a[0], a[1], b[0], b[1]];
-    });
-}
-/**
- * One floor as the engine sees it: its route lines, and its docks — the lines that end in a
- * `lineEnd` — each with its index into `graph.lines`.
- * @param graph The emitted graph.
- * @param layer The floor.
- * @returns The lines, split so.
- */
-function floorOf(graph, layer) {
-    const nodeId = (x, y, l) => `${l}_${x}_${y}`;
-    const ends = new Set(graph.lineEnds.map((end) => nodeId(end.x, end.y, end.layer)));
-    const net = [];
-    const docks = [];
-    graph.lines.forEach(({ p0, p1 }, index) => {
-        if (p0.layer !== layer || p1.layer !== layer)
-            return;
-        const seg = [p0.x, p0.y, p1.x, p1.y];
-        if (ends.has(nodeId(p1.x, p1.y, layer)))
-            docks.push({ seg, to: [p1.x, p1.y], index });
-        else if (ends.has(nodeId(p0.x, p0.y, layer)))
-            docks.push({ seg, to: [p0.x, p0.y], index });
-        else
-            net.push({ seg, index });
-    });
-    return { net, docks };
-}
-/**
- * Checks the emitted graph against the geometric invariants, layer by layer. Reads only; computes
- * no geometry the checks themselves do not need.
- * @param graph The emitted graph, in plan units.
- * @param layers The layers' raw walls and destinations, as `LayerDebug` carries them.
- * @returns Every breach found, in layer order, walls → crossings → footprints → rings.
- */
-export function checkGraphInvariants(graph, layers) {
-    const out = [];
-    for (const { layer, rawWalls, destinations } of layers) {
-        const { net, docks } = floorOf(graph, layer);
-        const walls = wallsOf(rawWalls);
-        // An entrance's dock is the way through the wall it stands across or beside: it may cross one.
-        const entrances = destinations
-            .filter((d) => d.entrance && (d.dock ?? d.polygon).length >= 3)
-            .map((d) => d.dock ?? d.polygon);
-        for (const { seg, index } of net)
-            if (walls.some((wall) => crosses(seg, wall)))
-                out.push({ code: 'line-crosses-wall', layer, lines: [index] });
-        for (const { seg, to, index } of docks)
-            if (!entrances.some((ring) => ringContains(ring, to)) &&
-                walls.some((wall) => crosses(seg, wall)))
-                out.push({ code: 'line-crosses-wall', layer, lines: [index], at: to });
-        const solid = destinations
-            .filter((d) => !d.crossable && d.polygon.length >= 3)
-            .map((d) => ({ id: d.id, edges: edgesOf(d.polygon) }));
-        const ownersOf = (to) => destinations
-            .filter((d) => (d.dock ?? d.polygon).length >= 3 && ringContains(d.dock ?? d.polygon, to))
-            .map((d) => d.id);
-        for (const { seg, index } of net)
-            if (solid.some((poi) => poi.edges.some((edge) => crosses(seg, edge))))
-                out.push({ code: 'line-crosses-poi', layer, lines: [index] });
-        for (const { seg, to, index } of docks) {
-            const owners = ownersOf(to);
-            if (solid.some((poi) => !owners.includes(poi.id) && poi.edges.some((edge) => crosses(seg, edge))))
-                out.push({ code: 'line-crosses-poi', layer, lines: [index], at: to });
-        }
-        for (const { to, index } of docks)
-            if (!destinations.some((d) => (d.dock ?? d.polygon).length >= 3 && ringContains(d.dock ?? d.polygon, to)))
-                out.push({ code: 'dock-outside-ring', layer, lines: [index], at: to });
-    }
-    return out;
-}

package/dist/lib/graph-types.d.ts

@@ -1,143 +0,0 @@
-import type { Ring, Vec2 } from './geom/types.js';
-/**
- * Distance at which two network points are one node, in meters. The network welds ends at it before
- * the emit, since the graph joins nodes only at exact coordinates.
- */
-export declare const NODE_SNAP = 0.05;
-/** A destination a route must reach, as the network stage sees it. */
-export interface RouteNetworkDestination {
-    /** Stable identifier; labels docks. */
-    readonly id: string;
-    /** Footprint polygon; an obstacle unless {@link crossable}. */
-    readonly polygon: Ring;
-    /** Convex ring the dock lands in; see `SourceDestination.dock`. */
-    readonly dock?: Ring;
-    /** A route may pass THROUGH it. */
-    readonly crossable?: boolean;
-    /** One connection is the whole approach; see `SourceDestination.terminal`. */
-    readonly terminal?: boolean;
-    /** A way into the building; see `SourceDestination.entrance`. */
-    readonly entrance?: boolean;
-}
-/** A short stub from the route network into a destination. */
-export interface RouteNetworkDock {
-    /** The destination it reaches. */
-    readonly id: string;
-    /** Where it meets the route network. */
-    readonly from: Vec2;
-    /** Its tip, inside the destination. */
-    readonly to: Vec2;
-}
-/** Why a destination has no dock a route can end at. */
-export type UnreachedReason = 
-/** No open face and no doorway: walled in on every side. */
-'no-way-in'
-/** Every way in breaks a dock rule: a wall, another outline, or no end inside the ring. */
- | 'way-in-blocked'
-/** Outside the building, or its ways in end on no routable floor. */
- | 'no-floor'
-/** Its tip is on floor no network reaches. */
- | 'cut-off'
-/** Attached, then lost to a later pass (pruned, moved off its line, or its dock broke a rule). */
- | 'detached';
-/** Which check at the emit took a `detached` destination's whisker away. */
-type DetachedBy = 
-/** The whisker's tip is no vertex of the final network: a later pass moved its line. */
-'not-a-vertex'
-/** From the final tip, no lawful dock reaches the destination. */
- | 'dock-unlawful';
-/** A destination without a dock a route can end at, with the facts the stage proved. */
-export interface Unreached {
-    /** The destination's id, as it compiled. */
-    readonly id: string;
-    /** Why. */
-    readonly reason: UnreachedReason;
-    /** `no-floor` only: true when the destination stands outside the building outline. */
-    readonly outside?: boolean;
-    /** An entrance outside the building only: how far the nearest wall stands, in meters. */
-    readonly nearestWall?: number;
-    /** An entrance outside the building only: false when no wall in reach has floor behind it. */
-    readonly floorBehind?: boolean;
-    /** Where the failing way in ends: the stub tip, in the network's units. Absent when no way in exists. */
-    readonly at?: Vec2;
-    /** `detached` only: which check removed the whisker. */
-    readonly by?: DetachedBy;
-}
-/** The build's entities, for the debug overlay. */
-export interface RouteNetworkAnatomy {
-    /** Plan units per meter, so markers are sized alike on every plan. */
-    readonly unit?: number;
-    /** Every doorway: its gap, jamb to jamb, and its middle. */
-    readonly doors: readonly {
-        readonly gap: readonly [Vec2, Vec2];
-        readonly mid: Vec2;
-    }[];
-    /** Growth targets: the destination id and the stub tip no row reached, that growth had to. */
-    readonly anchors: readonly {
-        readonly id: string;
-        readonly at: Vec2;
-    }[];
-    /** Ways in, each with its foot and outward normal. */
-    readonly ways: readonly {
-        readonly id: string;
-        readonly kind: string;
-        readonly foot: Vec2;
-        readonly normal: Vec2;
-    }[];
-    /** Whiskers laid, foot to tip. */
-    readonly whiskers: readonly {
-        readonly id: string;
-        readonly kind: string;
-        readonly foot: Vec2;
-        readonly tip: Vec2;
-    }[];
-    /**
-     * The turned directions that got a grid of their own: the angle of the first axis (radians, from the
-     * plan's x), the grid's outline, and the destinations drawn in that direction.
-     */
-    readonly frames: readonly {
-        readonly angle: number;
-        readonly box: readonly Vec2[];
-        readonly ids: readonly string[];
-    }[];
-    /**
-     * Turned destinations with no grid — alone, or in a hall drawn square: reached on the plan's grid,
-     * never framed.
-     */
-    readonly loose: readonly string[];
-    /**
-     * The aisle axes the stub tips define: the angle of the line's direction (radians, from the
-     * plan's x), and the line's two ends.
-     */
-    readonly axes: readonly {
-        readonly angle: number;
-        readonly from: Vec2;
-        readonly to: Vec2;
-    }[];
-}
-/** The route network: polylines, docks and stats. */
-export interface RouteNetwork {
-    /** Polylines. */
-    readonly paths: Vec2[][];
-    /** One dock per way in that reached a destination. */
-    readonly docks: RouteNetworkDock[];
-    /** Doorways, growth anchors, ways in and whiskers, for the overlay. */
-    readonly anatomy?: RouteNetworkAnatomy;
-    /** Counts, for diagnostics. */
-    readonly stats: {
-        /** Destinations without a dock, with the reason, in input order: no route reaches them. */
-        readonly unreached: readonly Unreached[];
-        /** Connected components of the network; > 1 means parts of the plan never link up. */
-        readonly components?: number;
-        /** Doorways the walls leave, as found. */
-        readonly doorways?: number;
-        /** Shortcut links cut in by the detour pass. */
-        readonly shortcuts?: number;
-        /** Network pieces the growth and the ties could not join; present only when > 0. */
-        readonly untiedPieces?: number;
-        /** Walkable floor pieces no destination or doorway serves, left out of the network. */
-        readonly unservedFloorPieces?: number;
-    };
-}
-export {};
-//# sourceMappingURL=graph-types.d.ts.map

package/dist/lib/graph-types.js

@@ -1,7 +0,0 @@
-// The route network contract: the steiner network produces a {@link RouteNetwork}, `emit-v1` turns
-// it into the v1 graph.
-/**
- * Distance at which two network points are one node, in meters. The network welds ends at it before
- * the emit, since the graph joins nodes only at exact coordinates.
- */
-export const NODE_SNAP = 0.05;

package/dist/lib/mask.d.ts

@@ -1,54 +0,0 @@
-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

@@ -1,210 +0,0 @@
-// 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;
-        }
-}