@expofp/wayfinding-compiler 0.0.0-bootstrap.0

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

@@ -0,0 +1,80 @@
+import { type Frame } from './geom/frames.js';
+import type { Segment } from './geom/types.js';
+/** A run of network points: a chain of segments through vertices no third segment meets. */
+export interface Chain {
+    /** Its points, in order. */
+    pts: [number, number][];
+}
+/**
+ * Reads a segment soup as chains: every maximal run through vertices of degree two, straightened
+ * where it runs straight through a point.
+ * @param soup The segments.
+ * @param protect Keys of points a chain keeps as vertices however straight it runs through them.
+ * @returns The chains, coordinates on the centimeter grid.
+ */
+export declare function chainsFromEdges(soup: readonly Segment[], protect?: ReadonlySet<string>): Chain[];
+/** What the joining may read of the floor. */
+interface JoinOptions {
+    /** The directions the layer is drawn in. */
+    readonly frames?: readonly Frame[];
+    /** Whether a segment lies on free floor: across no wall or stand. Everything is free by default. */
+    readonly free?: (seg: Segment) => boolean;
+    /**
+     * How far aside, and how far ahead, the run continuing another may start: a stub's length. Without
+     * it no run is pulled over.
+     */
+    readonly lane?: number;
+}
+/** The lines joined into straight runs, and where that moved a point. */
+interface JoinedRuns {
+    /** The runs, each straight stretch one chord. */
+    readonly chains: Chain[];
+    /** Every vertex a chord replaced, by its key, and where it now lies on the chord. */
+    readonly moved: Map<string, [number, number]>;
+}
+/**
+ * Joins the chains that continue one another through a shared end, and makes each straight stretch
+ * one chord: an aisle is one line from end to end, the stubs meeting it end on its span, and two aisles
+ * cross whole. Two pieces continue one another when they run along the same axis of the same frame
+ * in opposite senses, or, off every axis, when the joint lies on the chord between its neighbors.
+ * Every vertex a chord replaces is moved onto the chord, and so are the ends of the lines that stood
+ * on it. A run then continues through the next run along its axis when nothing stands between them
+ * on the floor: that run is pulled onto its line, longest runs first, so a line never starts where the
+ * one before it could go on. The converter that builds wf.data.js cuts a line where another ends on
+ * it or crosses it.
+ * @param chains The chains, ends on shared vertices.
+ * @param options The layer's directions and its free floor.
+ * @returns The joined runs, and where the vertices they replaced now lie.
+ */
+export declare function joinStraightRuns(chains: readonly Chain[], options?: JoinOptions): JoinedRuns;
+/** The network as a graph of its vertices. */
+export interface Graph {
+    /** Vertex positions, by vertex id. */
+    readonly nodes: [number, number][];
+    /** Neighbors of each vertex: vertex, length, edge id. */
+    readonly adj: [number, number, number][][];
+    /** Edge ends, by edge id. */
+    readonly edges: [number, number][];
+    /** Vertex id by point key. */
+    readonly nodeId: Map<string, number>;
+}
+/**
+ * Chains as segments, one per pair of neighboring points.
+ * @param chains The chains.
+ * @returns Their segments, in chain order.
+ */
+export declare function chainSegments(chains: readonly Chain[]): Segment[];
+/**
+ * Reads segments as a graph; vertices merge by point key.
+ * @param segments The segments.
+ * @returns The graph.
+ */
+export declare function graphOf(segments: readonly Segment[]): Graph;
+/**
+ * The connected pieces of a graph.
+ * @param graph The graph.
+ * @returns Each vertex's piece, by vertex id.
+ */
+export declare function components(graph: Graph): Int32Array;
+export {};
+//# sourceMappingURL=network-graph.d.ts.map

package/dist/lib/network-graph.js

@@ -0,0 +1,467 @@
+// The network read as a graph: its segments joined into chains, the chains as vertices and edges,
+// and the connected pieces.
+import { nearestFrame, toFrame } from './geom/frames.js';
+import { POINT_EPS, pointKey } from './geom/point-key.js';
+/**
+ * Reads a segment soup as chains: every maximal run through vertices of degree two, straightened
+ * where it runs straight through a point.
+ * @param soup The segments.
+ * @param protect Keys of points a chain keeps as vertices however straight it runs through them.
+ * @returns The chains, coordinates on the centimeter grid.
+ */
+export function chainsFromEdges(soup, protect) {
+    const nodePos = new Map();
+    const adjK = new Map();
+    const ek = (a, b) => (a < b ? `${a}|${b}` : `${b}|${a}`);
+    const edgeSet = new Set();
+    for (const [x0, y0, x1, y1] of soup) {
+        const a = pointKey(x0, y0);
+        const b = pointKey(x1, y1);
+        if (a === b || edgeSet.has(ek(a, b)))
+            continue;
+        edgeSet.add(ek(a, b));
+        nodePos.set(a, [x0, y0]);
+        nodePos.set(b, [x1, y1]);
+        if (!adjK.has(a))
+            adjK.set(a, []);
+        if (!adjK.has(b))
+            adjK.set(b, []);
+        adjK.get(a).push(b);
+        adjK.get(b).push(a);
+    }
+    const used = new Set();
+    const chains = [];
+    const trace = (start, next) => {
+        const pts = [nodePos.get(start), nodePos.get(next)];
+        used.add(ek(start, next));
+        let prev = start;
+        let cur = next;
+        while (adjK.get(cur).length === 2) {
+            const nxt = adjK.get(cur).find((k) => k !== prev);
+            if (nxt === undefined || used.has(ek(cur, nxt)))
+                break;
+            used.add(ek(cur, nxt));
+            pts.push(nodePos.get(nxt));
+            prev = cur;
+            cur = nxt;
+        }
+        return pts;
+    };
+    for (const [k, nb] of adjK) {
+        if (nb.length === 2)
+            continue;
+        for (const n of nb)
+            if (!used.has(ek(k, n)))
+                chains.push({ pts: trace(k, n) });
+    }
+    for (const [k, nb] of adjK)
+        for (const n of nb)
+            if (!used.has(ek(k, n)))
+                chains.push({ pts: trace(k, n) });
+    for (const c of chains) {
+        const out = [c.pts[0]];
+        for (let i = 1; i + 1 < c.pts.length; i++) {
+            const [ax, ay] = out[out.length - 1];
+            const [bx, by] = c.pts[i];
+            const [cx, cy] = c.pts[i + 1];
+            const kept = protect?.has(pointKey(bx, by));
+            const cross = Math.abs((bx - ax) * (cy - ay) - (by - ay) * (cx - ax));
+            const len = Math.hypot(cx - ax, cy - ay) || 1;
+            // Drop a point only where the chain runs straight through it (within POINT_EPS): a few-cm jog
+            // is a corner, and a chord across it would be off every axis.
+            if (kept || cross / len > POINT_EPS)
+                out.push(c.pts[i]);
+        }
+        out.push(c.pts[c.pts.length - 1]);
+        c.pts = out.map((p) => [+p[0].toFixed(2), +p[1].toFixed(2)]);
+    }
+    return chains.filter((c) => c.pts.length >= 2);
+}
+/** How far off a frame axis a line may point and still run along it: about two degrees. */
+const AXIS_TAN = 0.035;
+/**
+ * Which frame axis a direction runs along, if any.
+ * @param frames The directions the layer is drawn in.
+ * @param dx Direction x.
+ * @param dy Direction y.
+ * @returns The axis, or null off every axis.
+ */
+function axisOf(frames, dx, dy) {
+    if (!frames.length)
+        return null;
+    const frame = nearestFrame(frames, dx, dy);
+    const [u, v] = toFrame(frames[frame], dx, dy);
+    if (Math.abs(v) <= AXIS_TAN * Math.abs(u))
+        return { frame, axis: 0, sign: Math.sign(u) };
+    if (Math.abs(u) <= AXIS_TAN * Math.abs(v))
+        return { frame, axis: 1, sign: Math.sign(v) };
+    return null;
+}
+/**
+ * Joins the chains that continue one another through a shared end, and makes each straight stretch
+ * one chord: an aisle is one line from end to end, the stubs meeting it end on its span, and two aisles
+ * cross whole. Two pieces continue one another when they run along the same axis of the same frame
+ * in opposite senses, or, off every axis, when the joint lies on the chord between its neighbors.
+ * Every vertex a chord replaces is moved onto the chord, and so are the ends of the lines that stood
+ * on it. A run then continues through the next run along its axis when nothing stands between them
+ * on the floor: that run is pulled onto its line, longest runs first, so a line never starts where the
+ * one before it could go on. The converter that builds wf.data.js cuts a line where another ends on
+ * it or crosses it.
+ * @param chains The chains, ends on shared vertices.
+ * @param options The layer's directions and its free floor.
+ * @returns The joined runs, and where the vertices they replaced now lie.
+ */
+export function joinStraightRuns(chains, options = {}) {
+    const frames = options.frames ?? [];
+    const free = options.free ?? (() => true);
+    const runs = chains.map((c) => c.pts.map((p) => [p[0], p[1]]));
+    const owner = runs.map((_, i) => i);
+    const find = (i) => {
+        while (owner[i] !== i)
+            i = owner[i];
+        return i;
+    };
+    const meetings = new Map();
+    runs.forEach((pts, i) => {
+        if (!pts || pts.length < 2)
+            return;
+        for (const p of [pts[0], pts[pts.length - 1]]) {
+            const key = pointKey(p[0], p[1]);
+            meetings.set(key, [...(meetings.get(key) ?? []), i]);
+        }
+    });
+    // A run turned to end at `key`, and its point next to that end.
+    const endAt = (i, key) => {
+        const pts = runs[i];
+        const last = pts[pts.length - 1];
+        if (pointKey(last[0], last[1]) === key)
+            return { pts, next: pts[pts.length - 2] };
+        const first = pts[0];
+        if (pointKey(first[0], first[1]) === key)
+            return { pts: [...pts].reverse(), next: pts[1] };
+        return null;
+    };
+    // How far from straight two pieces meeting at a joint are: the angle between them, or Infinity.
+    const bend = (joint, a, c) => {
+        const [ax, ay] = [a[0] - joint[0], a[1] - joint[1]];
+        const [cx, cy] = [c[0] - joint[0], c[1] - joint[1]];
+        const la = Math.hypot(ax, ay);
+        const lc = Math.hypot(cx, cy);
+        if (!la || !lc)
+            return Infinity;
+        const sameAxis = (p, q) => p !== null && q !== null && p.frame === q.frame && p.axis === q.axis && p.sign === -q.sign;
+        const angle = Math.acos(Math.max(-1, Math.min(1, -(ax * cx + ay * cy) / (la * lc))));
+        if (sameAxis(axisOf(frames, ax, ay), axisOf(frames, cx, cy)))
+            return angle;
+        // Off the axes: straight through within a centimeter of the chord.
+        const len = Math.hypot(c[0] - a[0], c[1] - a[1]) || 1;
+        const off = Math.abs((joint[0] - a[0]) * (c[1] - a[1]) - (joint[1] - a[1]) * (c[0] - a[0])) / len;
+        const between = ax * cx + ay * cy < 0;
+        return off <= POINT_EPS && between ? angle : Infinity;
+    };
+    for (const key of [...meetings.keys()].sort()) {
+        // Every continuing pair at the meeting joins, straightest first: a crossing keeps both lines whole.
+        for (;;) {
+            const incident = [...new Set(meetings.get(key).map(find))];
+            let best = null;
+            for (let a = 0; a < incident.length; a++)
+                for (let b = a + 1; b < incident.length; b++) {
+                    const i = incident[a];
+                    const j = incident[b];
+                    const ei = endAt(i, key);
+                    const ej = endAt(j, key);
+                    if (!ei || !ej)
+                        continue;
+                    const angle = bend(ei.pts[ei.pts.length - 1], ei.next, ej.next);
+                    if (!isFinite(angle))
+                        continue;
+                    if (!best || angle < best.angle)
+                        best = { angle, i, j };
+                }
+            if (!best)
+                break;
+            const ei = endAt(best.i, key);
+            const ej = endAt(best.j, key);
+            runs[best.i] = [...ei.pts, ...[...ej.pts].reverse().slice(1)];
+            runs[best.j] = null;
+            owner[best.j] = best.i;
+        }
+    }
+    // Each straight stretch of a run becomes its chord; the vertices on it move onto the chord.
+    const moved = new Map();
+    const round = (p) => [+p[0].toFixed(2), +p[1].toFixed(2)];
+    // Each straight stretch of a run becomes its chord, a run of its own; the vertices on it move onto
+    // the chord, and the stretch carries their keys.
+    const stretches = [];
+    const onRun = [];
+    const straighten = (pts) => {
+        let from = 0;
+        for (let i = 1; i < pts.length; i++) {
+            const last = i === pts.length - 1;
+            if (!last && isFinite(bend(pts[i], pts[i - 1], pts[i + 1])))
+                continue;
+            const [ax, ay] = pts[from];
+            const [cx, cy] = pts[i];
+            const len2 = (cx - ax) ** 2 + (cy - ay) ** 2 || 1;
+            const keys = [];
+            for (let k = from + 1; k < i; k++) {
+                const [px, py] = pts[k];
+                const t = ((px - ax) * (cx - ax) + (py - ay) * (cy - ay)) / len2;
+                moved.set(pointKey(px, py), round([ax + t * (cx - ax), ay + t * (cy - ay)]));
+                keys.push(pointKey(px, py));
+            }
+            stretches.push([pts[from], pts[i]]);
+            onRun.push(keys);
+            from = i;
+        }
+    };
+    for (const pts of runs)
+        if (pts && pts.length >= 2)
+            straighten(pts);
+    const lanes = options.lane
+        ? mergeLanes(stretches, onRun, frames, free, options.lane, moved)
+        : stretches;
+    // A run's own ends may have stood on another run's chord; a run both ends meet at is gone.
+    const at = (p) => moved.get(pointKey(p[0], p[1])) ?? p;
+    return {
+        chains: lanes
+            .map((pts) => ({ pts: pts.map(at) }))
+            .filter(({ pts }) => Math.hypot(pts[1][0] - pts[0][0], pts[1][1] - pts[0][1]) > POINT_EPS),
+        moved,
+    };
+}
+/**
+ * Pulls each straight run onto the line of the run it continues: the next run along the same axis,
+ * when the floor between them is free. Longest runs first, so the longer line keeps its place and the
+ * shorter one moves, together with every point that stood on it. Runs keep their authored points as
+ * keys; where a point lies now is always read through `moved`.
+ * @param runs The straight runs, two points each.
+ * @param onRun The keys of the vertices each run's chords replaced.
+ * @param frames The directions the layer is drawn in.
+ * @param free Whether a segment lies on free floor.
+ * @param lane How far aside, and how far ahead, a continuing run may start.
+ * @param moved Where the vertices replaced so far lie; extended with every point pulled over.
+ * @returns The runs left, the pulled ones merged into the lines they continue, ends where they lie now.
+ */
+function mergeLanes(runs, onRun, frames, free, lane, moved) {
+    const keyOf = (p) => pointKey(p[0], p[1]);
+    const at = (p) => moved.get(keyOf(p)) ?? p;
+    // Each run's ends: the authored point (its key) and where it lies now.
+    const ends = runs.map((pts) => [pts[0], pts[pts.length - 1]].map((p) => ({ key: keyOf(p), raw: p })));
+    const now = (i) => ends[i].map((e) => at(e.raw));
+    const axis = runs.map((_, i) => {
+        const [a, c] = now(i);
+        return axisOf(frames, c[0] - a[0], c[1] - a[1]);
+    });
+    const length = (i) => {
+        const [a, c] = now(i);
+        return Math.hypot(c[0] - a[0], c[1] - a[1]);
+    };
+    const alive = runs.map(() => true);
+    const order = runs.map((_, i) => i).sort((a, b) => length(b) - length(a) || a - b);
+    const round = (p) => [+p[0].toFixed(2), +p[1].toFixed(2)];
+    // The keys of the points on each run's chords, carried along when the run is pulled over.
+    const carried = onRun.map((keys) => [...keys]);
+    // Runs by the keys of their ends, and by the keys on their chords: what a run takes along when it
+    // is pulled over.
+    const atKey = new Map();
+    const carriedBy = new Map();
+    ends.forEach((pair, i) => {
+        for (const e of pair)
+            atKey.set(e.key, [...(atKey.get(e.key) ?? []), i]);
+    });
+    carried.forEach((keys, i) => {
+        for (const key of keys)
+            carriedBy.set(key, [...(carriedBy.get(key) ?? []), i]);
+    });
+    // Whether everything B takes along can follow it onto A's line. A run ending on one of B's points
+    // follows only when it meets B square, and when the move lengthens it or it carries nothing: a run
+    // shortened could end before the points that stand on it. A run that carries one of B's ends on
+    // its chord would lose that point, so B stays.
+    const detachable = (b, project) => {
+        const [b0, b1] = now(b);
+        const follows = (was, r) => {
+            const [p, q] = now(r);
+            const dot = (q[0] - p[0]) * (b1[0] - b0[0]) + (q[1] - p[1]) * (b1[1] - b0[1]);
+            const lens = Math.hypot(q[0] - p[0], q[1] - p[1]) * Math.hypot(b1[0] - b0[0], b1[1] - b0[1]);
+            if (lens === 0 || Math.abs(dot) > AXIS_TAN * lens)
+                return false;
+            const other = keyOf(p) === keyOf(was) ? q : p;
+            const to = project(was);
+            const [wx, wy] = [was[0] - other[0], was[1] - other[1]];
+            const [tx, ty] = [to[0] - other[0], to[1] - other[1]];
+            if (tx * wx + ty * wy >= wx * wx + wy * wy)
+                return true;
+            return carried[r].length === 0 && tx * wx + ty * wy >= 0;
+        };
+        for (const e of ends[b]) {
+            if ((carriedBy.get(e.key) ?? []).some((r) => r !== b && alive[r]))
+                return false;
+            if (!(atKey.get(e.key) ?? []).every((r) => r === b || !alive[r] || follows(at(e.raw), r)))
+                return false;
+        }
+        for (const key of carried[b]) {
+            const was = moved.get(key);
+            if (!was)
+                continue;
+            if (!(atKey.get(key) ?? []).every((r) => r === b || !alive[r] || follows(was, r)))
+                return false;
+        }
+        return true;
+    };
+    let settled = false;
+    while (!settled) {
+        settled = true;
+        for (const a of order) {
+            if (!alive[a] || !axis[a])
+                continue;
+            for (;;) {
+                let merged = false;
+                for (const endIdx of [0, 1]) {
+                    const [p0, p1] = now(a);
+                    const end = endIdx === 1 ? p1 : p0;
+                    const start = endIdx === 1 ? p0 : p1;
+                    const len = Math.hypot(end[0] - start[0], end[1] - start[1]) || 1;
+                    const ux = (end[0] - start[0]) / len;
+                    const uy = (end[1] - start[1]) / len;
+                    const along = (p) => (p[0] - end[0]) * ux + (p[1] - end[1]) * uy;
+                    const aside = (p) => Math.abs((p[0] - end[0]) * uy - (p[1] - end[1]) * ux);
+                    const onLine = (s) => round([end[0] + ux * s, end[1] + uy * s]);
+                    let best = null;
+                    for (const b of order) {
+                        if (b === a || !alive[b] || !axis[b])
+                            continue;
+                        if (axis[b].frame !== axis[a].frame || axis[b].axis !== axis[a].axis)
+                            continue;
+                        const [q0, q1] = now(b);
+                        const near = Math.min(along(q0), along(q1));
+                        const far = Math.max(along(q0), along(q1));
+                        // B continues A: it starts at A's end or within a lane ahead, no farther aside than a lane,
+                        // and goes on from there. A run alongside A is a twin, not a continuation.
+                        if (near < -POINT_EPS || near > lane || far <= near)
+                            continue;
+                        if (Math.max(aside(q0), aside(q1)) > lane)
+                            continue;
+                        if (!detachable(b, (p) => onLine(along(p))))
+                            continue;
+                        if (!best || near < best.near)
+                            best = { b, near, far };
+                    }
+                    if (!best)
+                        continue;
+                    const [q0, q1] = now(best.b);
+                    const nearQ = along(q0) <= along(q1) ? q0 : q1;
+                    const farQ = nearQ === q0 ? q1 : q0;
+                    const nearP = onLine(Math.max(0, best.near));
+                    const farP = onLine(best.far);
+                    const seg = (p, q) => [
+                        p[0],
+                        p[1],
+                        q[0],
+                        q[1],
+                    ];
+                    // Free floor between the two: from B's ends across to A's line, along the gap, and along B
+                    // once pulled over.
+                    if (!free(seg(nearQ, onLine(best.near))) || !free(seg(farQ, farP)))
+                        continue;
+                    if (best.near > 0 && !free(seg(end, nearP)))
+                        continue;
+                    if (!free(seg(nearP, farP)))
+                        continue;
+                    // B's own ends and everything on its chord move onto A's line, keeping their keys.
+                    for (const key of [...ends[best.b].map((e) => e.key), ...carried[best.b]]) {
+                        const was = moved.get(key) ?? ends[best.b].find((e) => e.key === key).raw;
+                        moved.set(key, onLine(along(was)));
+                        carried[a].push(key);
+                        carriedBy.set(key, [...(carriedBy.get(key) ?? []).filter((r) => r !== best.b), a]);
+                    }
+                    // A now reaches B's far end: that end's key becomes A's, so later moves follow it.
+                    const farEnd = ends[best.b].find((e) => keyOf(at(e.raw)) === keyOf(farP)) ??
+                        ends[best.b][along(ends[best.b][0].raw) >= along(ends[best.b][1].raw) ? 0 : 1];
+                    atKey.set(ends[a][endIdx].key, (atKey.get(ends[a][endIdx].key) ?? []).filter((r) => r !== a));
+                    ends[a][endIdx] = farEnd;
+                    atKey.set(farEnd.key, [...(atKey.get(farEnd.key) ?? []), a]);
+                    moved.set(farEnd.key, farP);
+                    alive[best.b] = false;
+                    merged = true;
+                    settled = false;
+                }
+                if (!merged)
+                    break;
+            }
+        }
+    }
+    return runs.flatMap((_, i) => (alive[i] ? [now(i)] : []));
+}
+/**
+ * Chains as segments, one per pair of neighboring points.
+ * @param chains The chains.
+ * @returns Their segments, in chain order.
+ */
+export function chainSegments(chains) {
+    const segs = [];
+    for (const ch of chains)
+        for (let i = 0; i + 1 < ch.pts.length; i++)
+            segs.push([ch.pts[i][0], ch.pts[i][1], ch.pts[i + 1][0], ch.pts[i + 1][1]]);
+    return segs;
+}
+/**
+ * Reads segments as a graph; vertices merge by point key.
+ * @param segments The segments.
+ * @returns The graph.
+ */
+export function graphOf(segments) {
+    const nodeId = new Map();
+    const nodes = [];
+    const adj = [];
+    const edges = [];
+    const getNode = (x, y) => {
+        const k = pointKey(x, y);
+        let id = nodeId.get(k);
+        if (id === undefined) {
+            id = nodes.length;
+            nodeId.set(k, id);
+            nodes.push([x, y]);
+            adj.push([]);
+        }
+        return id;
+    };
+    const link = (u, v) => {
+        if (u === v)
+            return;
+        const d = Math.hypot(nodes[u][0] - nodes[v][0], nodes[u][1] - nodes[v][1]);
+        const eid = edges.length;
+        edges.push([u, v]);
+        adj[u].push([v, d, eid]);
+        adj[v].push([u, d, eid]);
+    };
+    for (const [x0, y0, x1, y1] of segments)
+        link(getNode(x0, y0), getNode(x1, y1));
+    return { nodes, adj, edges, nodeId };
+}
+/**
+ * The connected pieces of a graph.
+ * @param graph The graph.
+ * @returns Each vertex's piece, by vertex id.
+ */
+export function components(graph) {
+    const comp = new Int32Array(graph.nodes.length).fill(-1);
+    const stack = [];
+    let c = 0;
+    for (let s = 0; s < graph.nodes.length; s++) {
+        if (comp[s] >= 0)
+            continue;
+        stack.push(s);
+        comp[s] = c;
+        while (stack.length) {
+            const u = stack.pop();
+            for (const [v] of graph.adj[u])
+                if (comp[v] < 0) {
+                    comp[v] = c;
+                    stack.push(v);
+                }
+        }
+        c++;
+    }
+    return comp;
+}

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

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

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