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

package/dist/lib/compile-layer.js

@@ -1,241 +0,0 @@
-// One layer's pipeline: the destinations read as the stages see them — rings normalized, footprints
-// carved back to the walls, zones and blocking stands read crossable — then the walkable area and the
-// route network over it.
-import { blockersOf } from './blockers.js';
-import { doorOwners, doorwaySides, findDoorways } from './doorways.js';
-import { dockFor, standingBefore, stubLength, waysInto } from './entries.js';
-import { footprintOf } from './geom/footprint.js';
-import { cleanRing } from './geom/normalize.js';
-import { boundsOf, pointInRing, signedArea, vertexMean } from './geom/primitives.js';
-import { prepareWalls } from './geom/walls.js';
-import { NETWORK_SIZES } from './network-sizes.js';
-import { entranceOpenings } from './openings.js';
-import { buildSteinerNetwork } from './steiner-network.js';
-import { buildWalkableArea, carveFootprints, inBuilding, outerContoursOf, WALL_HALF_WIDTH, wallStripsOf, } from './walkable.js';
-/**
- * One layer's pipeline: walkable area, then route network.
- * @param source One layer's walls and destinations.
- * @param ops Polygon boolean backend.
- * @param options A ready walkable area and the stage callback.
- * @returns The layer's walkable area and route network.
- */
-export function compileLayer(source, ops, options) {
-    // Walls first: the building's outline is theirs alone. The walls are read and offset once and shared
-    // by every stage below.
-    const prepared = prepareWalls(source.walls);
-    const contours = options?.walkable ? undefined : outerContoursOf(prepared.runs);
-    const outline = options?.walkable?.outline ?? ops.union(contours ?? []);
-    // A destination with neither its middle nor a corner inside the building never reaches the network:
-    // it is reported off the floor without being traced, carved or entered.
-    const offFloor = (d) => {
-        const ring = cleanRing(d.dock ?? d.polygon);
-        return outline.length > 0 && ![vertexMean(ring), ...ring].some((p) => inBuilding(outline, p));
-    };
-    const sorted = inCanonicalOrder(source.destinations);
-    // Entrances go through the walls they stand across, or the nearest wall when they stand outside;
-    // the walls stay whole. An entrance that got an opening is on the floor.
-    const opened = entranceOpenings(prepared, outline, sorted, offFloor);
-    const openedIds = new Set(opened.openings.map((o) => o.id));
-    const outside = sorted.filter((d) => offFloor(d) && !openedIds.has(d.id));
-    const shapes = [];
-    const zones = [];
-    let sized;
-    // Normalize rings once so docking grows one stub per real face; a ring that normalizes below 3
-    // vertices stays raw, visible to diagnostics. `parts` become the footprint and are dropped from
-    // the artifacts.
-    const destinations = sorted
-        .filter((d) => !outside.includes(d))
-        .map((d) => {
-        const { parts, ...rest } = d;
-        const shape = parts?.length
-            ? footprintOf(parts, ops, rest.dock)
-            : { ring: null, drawn: [] };
-        const polygon = shape.ring ?? cleanRing(rest.polygon);
-        const dock = rest.dock ? cleanRing(rest.dock) : undefined;
-        const cleaned = dock && dock.length >= 3 ? { ...rest, dock } : rest;
-        const drawn = shape.drawn.length ? { ...cleaned, drawnShape: shape.drawn } : cleaned;
-        if (parts?.length && shape.how)
-            shapes.push({ id: d.id, how: shape.how, parts: parts.length });
-        return polygon.length >= 3 ? { ...drawn, polygon } : drawn;
-    })
-        .map((d, index, all) => {
-        sized ??= all.map(sizeOf);
-        if (d.crossable || !holdsAnother(sized[index], sized))
-            return d;
-        zones.push(d.id);
-        return { ...d, crossable: true };
-    });
-    // Footprints are carved back to their walls here, and every later stage sees the carved shape.
-    const shared = {
-        walls: prepared,
-        strips: wallStripsOf(ops, prepared.segments, WALL_HALF_WIDTH),
-        ...(contours && { contours }),
-    };
-    // Every piece of a solid destination is carved: footprints first, so carved rings pair back by
-    // position, then the rest of the drawing. Owners are positions, not ids: ids may repeat or be
-    // blank.
-    const solid = [];
-    const rings = [];
-    const owner = [];
-    destinations.forEach((d, index) => {
-        if (d.crossable)
-            return;
-        solid.push(index);
-        rings.push(d.polygon);
-        owner.push(index);
-    });
-    // A piece of the drawing another destination stands in is ground around it, not a block.
-    const holdsOther = (block, index) => destinations.some((other, k) => k !== index && other.polygon.length >= 3 && pointInRing(block, vertexMean(other.polygon)));
-    for (const index of solid)
-        for (const block of destinations[index].drawnShape ?? []) {
-            rings.push(block);
-            owner.push(index);
-        }
-    const { rings: obstacles, clipped } = carveFootprints(rings, shared.strips, ops);
-    // The rest of the drawing is input only; it stays off the artifacts, which are in plan units.
-    let next = 0;
-    const carved = destinations.map(({ drawnShape: _block, ...rest }) => rest.crossable ? rest : { ...rest, polygon: obstacles[next++] });
-    // The rest of each drawing blocks ways in.
-    const drawnOf = (index) => (destinations[index].drawnShape ?? [])
-        .filter((ring) => !holdsOther(ring, index))
-        .map((ring) => ({ id: destinations[index].id, ring }));
-    // Read on the carved outlines, as every later stage sees them. A destination named here stops
-    // being an obstacle: its ring leaves the floor, without re-carving.
-    const passable = crossableByStanding(carved, prepared, NETWORK_SIZES, solid.flatMap(drawnOf));
-    const open = carved.map((d, index) => (passable.has(index) ? { ...d, crossable: true } : d));
-    const standing = obstacles.filter((_, index) => !passable.has(owner[index]));
-    const walkable = options?.walkable ??
-        buildWalkableArea({ walls: source.walls, obstacles: standing }, ops, WALL_HALF_WIDTH, shared);
-    options?.onStage?.('walkable', options.walkable != null);
-    // Raw walls too: doorways and ways in use their exact geometry.
-    const drawnBlocks = solid.filter((index) => !passable.has(index)).flatMap(drawnOf);
-    const network = buildSteinerNetwork(walkable.rings, open, source.walls, prepared, drawnBlocks, opened.openings);
-    options?.onStage?.('network', false);
-    const off = outside.map(({ parts: _parts, ...d }) => d);
-    // An entrance outside that opened no wall keeps what the search found.
-    const noFloor = new Map(opened.unreached.map((u) => [u.id, u]));
-    const byEntrance = new Map();
-    for (const { id, at, by, distance } of opened.openings) {
-        const entry = byEntrance.get(id) ?? {
-            id,
-            by,
-            at: [],
-            ...(distance !== undefined && { distance }),
-        };
-        // A wall open to both sides is one place.
-        const seen = entry.at.some(([x, y]) => x === at[0] && y === at[1]);
-        byEntrance.set(id, seen ? entry : { ...entry, at: [...entry.at, at] });
-    }
-    const facts = {
-        wallEntries: prepared.entries,
-        shapes,
-        // Footprint rings only: a clipped auxiliary drawn block is not the footprint being cut back.
-        clipped: clipped
-            .slice(0, solid.length)
-            .flatMap((cut, index) => (cut ? [destinations[owner[index]].id] : [])),
-        crossable: [
-            ...zones.map((id) => ({ id, by: 'holds-another' })),
-            ...[...passable].map(([index, victims]) => ({
-                id: carved[index].id,
-                by: 'stands-before',
-                victims,
-            })),
-        ],
-        openings: [...byEntrance.values()],
-        entrancesUnopened: open.flatMap((d) => (d.entrance && !openedIds.has(d.id) ? [d.id] : [])),
-    };
-    return {
-        layer: source.layer,
-        destinations: [...open, ...off],
-        walkable,
-        network: {
-            ...network,
-            stats: {
-                ...network.stats,
-                unreached: [
-                    ...network.stats.unreached,
-                    ...off.map((d) => noFloor.get(d.id) ?? { id: d.id, reason: 'no-floor', outside: true }),
-                ],
-            },
-        },
-        facts,
-    };
-}
-/**
- * Destinations a route must cross because they stand in front of another destination's only way in.
- * Only when that destination has no way in at all, and the one in front is reachable itself.
- * @param destinations The layer's destinations, footprints already carved.
- * @param prepared The layer's walls as drawn, already read: the doorways are theirs.
- * @param cfg Network sizes.
- * @param drawn The rest of each destination's drawing, as the network will see it.
- * @returns The positions of the destinations to walk through, each with the ids it walled in.
- */
-function crossableByStanding(destinations, prepared, cfg, drawn) {
-    // Every gap in the walls, including ones a footprint stands across.
-    const doors = findDoorways(prepared);
-    const owners = doorOwners(doors, destinations, prepared.segments, cfg);
-    const blockers = blockersOf(destinations, [...prepared.segments, ...doorwaySides(doors, cfg)], doors, drawn);
-    // Usable as the network judges it: a person fits in front, and its stub docks lawfully.
-    const usable = (d, ways) => ways.some((way) => {
-        const run = stubLength(way, cfg);
-        return (way.depth >= cfg.clear &&
-            dockFor(d, way, [way.mx + way.nx * run, way.my + way.ny * run], blockers) !== null);
-    });
-    const ways = destinations.map((d) => waysInto(d, owners, blockers, cfg));
-    const reachable = destinations.map((d, index) => usable(d, ways[index]));
-    // A repeated id names none of its destinations (-1).
-    const at = new Map();
-    destinations.forEach((d, index) => at.set(d.id, at.has(d.id) ? -1 : index));
-    const passable = new Map();
-    for (const [index, victim] of destinations.entries()) {
-        if (victim.crossable || reachable[index])
-            continue;
-        // Whoever stands in the strip a person needs in front of a way in closed it.
-        for (const way of ways[index])
-            for (const id of standingBefore(way, victim.id, blockers, cfg.clear)) {
-                const who = at.get(id) ?? -1;
-                if (who < 0 || !reachable[who])
-                    continue;
-                const victims = passable.get(who) ?? [];
-                if (!victims.includes(victim.id))
-                    passable.set(who, [...victims, victim.id]);
-            }
-    }
-    return passable;
-}
-/**
- * Destinations sorted by id, then outline, so input order does not change the network.
- * @param destinations The destinations as given.
- * @returns A sorted copy.
- */
-export function inCanonicalOrder(destinations) {
-    const outline = (d) => JSON.stringify([d.polygon, d.parts ?? [], d.dock ?? []]);
-    const compare = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
-    return [...destinations].sort((a, b) => compare(a.id, b.id) || compare(outline(a), outline(b)));
-}
-function sizeOf({ polygon }) {
-    return {
-        polygon,
-        area: polygon.length < 3 ? 0 : Math.abs(signedArea(polygon)),
-        box: boundsOf(polygon),
-        middle: polygon.length < 3 ? [NaN, NaN] : vertexMean(polygon),
-    };
-}
-/**
- * Whether a smaller destination's centroid lies inside this one (a pavilion, a hall of stands).
- * Such a destination is a zone people walk in, not an obstacle.
- * @param d The destination.
- * @param all Every destination on the layer.
- * @returns True when `d` holds another destination.
- */
-function holdsAnother(d, all) {
-    if (d.polygon.length < 3)
-        return false;
-    const [x0, y0, x1, y1] = d.box;
-    return all.some((other) => {
-        if (other === d || other.polygon.length < 3 || other.area >= d.area)
-            return false;
-        const [x, y] = other.middle;
-        return x >= x0 && x <= x1 && y >= y0 && y <= y1 && pointInRing(d.polygon, other.middle);
-    });
-}

package/dist/lib/compile-wayfinding.d.ts

@@ -1,90 +0,0 @@
-import { type Diagnostic } from './diagnostics.js';
-import type { RouteNetwork } from './graph-types.js';
-import { type Reachability } from './reachability.js';
-import { type CompileReport } from './report.js';
-import type { SourceDestination, WayfindingSource, WfV1Graph } from './types.js';
-import type { WalkableArea } from './walkable.js';
-/** Progress of a compile, reported as each stage finishes. */
-export interface CompileProgress {
-    /** The stage just finished. */
-    readonly stage: 'walkable' | 'network' | 'transitions';
-    /** The layer it belongs to; empty for whole-plan stages. */
-    readonly layer: string;
-    /** Stages completed so far, out of {@link total}. */
-    readonly done: number;
-    /** Stages this compile will run in all. */
-    readonly total: number;
-    /** True when the caller handed the stage its artifact and it did not run. */
-    readonly cached: boolean;
-}
-/** What a compile may be given besides the plan. */
-export interface CompileOptions {
-    /** Called as each stage finishes. */
-    readonly onProgress?: (progress: CompileProgress) => void;
-    /**
-     * Walkable areas to reuse, by layer id, from an earlier compile of the same geometry: only the
-     * route network is then built. A layer with no entry builds its own.
-     */
-    readonly walkable?: Readonly<Record<string, WalkableArea>>;
-}
-/** One layer's stage artifacts and raw inputs, as plain serializable data. */
-export interface LayerDebug {
-    /** Globally unique 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, carved. */
-    readonly destinations: readonly SourceDestination[];
-    /** Walkable area. */
-    readonly walkable: WalkableArea;
-    /** Route network. */
-    readonly network: RouteNetwork;
-}
-/** What a compile returns: the graph and the report on it. Plain serializable data. */
-export interface CompileResult {
-    /** The emitted graph, lines not cut where they meet; empty, never null, when nothing was built. */
-    readonly graph: WfV1Graph;
-    /** Outcome, counts, and which POI are not connected and why. */
-    readonly report: CompileReport;
-}
-/**
- * `compileWayfinding(source, { debug: true })`: the result plus stage artifacts; JSON-serializable.
- */
-export interface WayfindingDebugResult extends CompileResult {
-    /** Per-layer stage artifacts. */
-    readonly layers: LayerDebug[];
-    /** What the emitted graph connects: its parts, and the part every POI is bound to. */
-    readonly reachability: Reachability;
-    /** Every technical fact of the compile, stage by stage. */
-    readonly diagnostics: readonly Diagnostic[];
-}
-/**
- * Compile plan geometry into a routing graph in the shape of the v1 format, with a report on the
- * result. Its lines are not cut where they meet: the converter that builds wf.data.js cuts them.
- *
- * Pure and deterministic. Per layer: walkable area, route network, v1 emit. A plan it cannot read
- * comes back `not-built` with the reason in the report; it never throws over the plan.
- * @param source Per-layer walls and destinations.
- * @param options What the compile may be given besides the plan.
- * @param options.onProgress Called as each stage finishes.
- * @param options.walkable Walkable areas by layer, to reuse instead of rebuilding.
- * @returns The compiled graph and its report.
- */
-export declare function compileWayfinding(source: WayfindingSource, options?: CompileOptions): CompileResult;
-/**
- * Debug mode: the same pass also returns {@link WayfindingDebugResult}.
- * @param source Per-layer walls and destinations.
- * @param options `debug: true` and the usual options.
- * @param options.debug Return the stage artifacts. `{ invariants: true }` also checks the emitted
- * graph against the geometric invariants (`graph-invariants.ts`) — a pairwise sweep that costs a
- * sizable share of the compile on a large plan, so it is opted into, not implied by `debug`.
- * @param options.onProgress Called as each stage finishes.
- * @param options.walkable Walkable areas by layer, to reuse instead of rebuilding.
- * @returns The compiled graph and its report, plus the stage artifacts and facts.
- */
-export declare function compileWayfinding(source: WayfindingSource, options: CompileOptions & {
-    debug: true | {
-        invariants?: boolean;
-    };
-}): WayfindingDebugResult;
-//# sourceMappingURL=compile-wayfinding.d.ts.map

package/dist/lib/compile-wayfinding.js

@@ -1,203 +0,0 @@
-import { CellsRefusedError } from './cell-array.js';
-import { compileLayer, inCanonicalOrder } from './compile-layer.js';
-import { fromEmit, fromGraphInvariants, fromNetwork, fromNormalize, fromOversize, fromReachability, fromScale, fromSourceIssues, fromStops, fromTransitions, fromWalkable, } from './diagnostics.js';
-import { emitLayerV1 } from './emit-v1.js';
-import { createClipper2Ops } from './geom/clipper2-ops.js';
-import { boundsOf } from './geom/primitives.js';
-import { checkGraphInvariants } from './graph-invariants.js';
-import { NETWORK_SIZES } from './network-sizes.js';
-import { readReachability } from './reachability.js';
-import { buildReport } from './report.js';
-import { destinationsInPlanUnits, graphInPlanUnits, networkInPlanUnits, orphansInPlanUnits, sourceInMeters, walkableScaled, } from './scale.js';
-import { emitTransitionEdges, planTransitions } from './transitions.js';
-import { destinationFinite, validateWayfindingSource, wallsFinite } from './validate-source.js';
-/**
- * Most raster cells a floor's extent may take: six times the largest plan known, and well short of
- * what a browser tab holds. A larger floor is drawn in the wrong units or holds a stray drawing.
- */
-const MAX_FLOOR_CELLS = 40e6;
-/**
- * The box a layer's drawing spans: walls and every destination ring.
- * @param layer One layer, in meters.
- * @returns Its bounds; infinite when nothing is drawn.
- */
-function extentOf(layer) {
-    const points = [];
-    for (const run of layer.walls)
-        for (let i = 0; i + 1 < run.length; i += 2)
-            points.push([run[i], run[i + 1]]);
-    for (const d of layer.destinations)
-        points.push(...d.polygon, ...(d.parts ?? []).flat(), ...(d.dock ?? []));
-    return boundsOf(points);
-}
-/**
- * A layer's destinations in canonical order, each under an id no other one on the layer shares: a blank
- * or repeated id gets its rank among its namesakes, so every destination docks by its own geometry.
- * @param destinations The layer's destinations, in source order.
- * @returns The destinations in canonical order, and the id each source position compiles under.
- */
-function uniquelyNamed(destinations) {
-    const sorted = inCanonicalOrder(destinations);
-    const count = new Map();
-    const rank = new Map();
-    const idOf = new Map();
-    for (const d of destinations)
-        count.set(d.id, (count.get(d.id) ?? 0) + 1);
-    for (const d of sorted) {
-        const n = rank.get(d.id) ?? 0;
-        rank.set(d.id, n + 1);
-        idOf.set(d, d.id && count.get(d.id) === 1 ? d.id : `${d.id}\u0000${n}`);
-    }
-    return {
-        destinations: sorted.map((d) => ({ ...d, id: idOf.get(d) })),
-        ids: destinations.map((d) => idOf.get(d)),
-    };
-}
-/**
- * Shared implementation of both overloads.
- * @param source Per-layer walls and destinations.
- * @param options Compile options.
- * @param options.debug Return the stage artifacts; `{ invariants: true }` also checks the graph.
- * @param options.onProgress Called as each stage finishes.
- * @param options.walkable Walkable areas by layer, to reuse instead of rebuilding.
- * @returns The compiled graph and its report, plus the stage artifacts and facts in debug mode.
- */
-export function compileWayfinding(source, options) {
-    const issues = validateWayfindingSource(source);
-    const input = [...fromSourceIssues(issues), ...fromScale(source.unitsPerMeter)];
-    // An unreadable plan is reported, not thrown. An error naming a layer stops that floor alone.
-    if (issues.some(({ severity, layer }) => severity === 'error' && layer === undefined)) {
-        const graph = { lines: [], lineEnds: [] };
-        const reachability = { parts: [], poi: [], unownedEnds: [], sharedEnds: [] };
-        const report = buildReport(input, reachability, source);
-        return options?.debug
-            ? { graph, report, layers: [], reachability, diagnostics: input }
-            : { graph, report };
-    }
-    // What the input stage proved unreadable is left out and stays in the report as the input fact:
-    // a broken wall skips its floor, a broken destination or transition is dropped alone. Keyed by
-    // position, not id — two layers may share an id, and only the broken one is touched.
-    const layerBroken = source.layers.map((layer) => !wallsFinite(layer.walls));
-    const poiBroken = source.layers.map((layer) => layer.destinations.flatMap((d, index) => (destinationFinite(d) ? [] : [index])));
-    const brokenTransitions = new Set(issues.flatMap(({ code, index }) => code === 'transition-coordinate-not-finite' && index !== undefined ? [index] : []));
-    const ops = createClipper2Ops();
-    const graph = { lines: [], lineEnds: [] };
-    const layers = [];
-    // Stages work in meters: one conversion in here, one back to plan units on the way out.
-    const unit = source.unitsPerMeter ?? 1;
-    // Canonical order and unique ids before transition stops resolve: a stop takes the smallest
-    // destination it stands in, the first of equals.
-    const scaled = sourceInMeters(source, unit);
-    const named = scaled.layers.map((layer) => uniquelyNamed(layer.destinations));
-    const metric = {
-        ...scaled,
-        ...(scaled.transitions && {
-            transitions: scaled.transitions.filter((_, index) => !brokenTransitions.has(index)),
-        }),
-        layers: scaled.layers.map((layer, index) => {
-            const broken = poiBroken[index];
-            if (!broken.length)
-                return { ...layer, destinations: named[index].destinations };
-            const left = new Set(broken.map((at) => named[index].ids[at]));
-            return {
-                ...layer,
-                destinations: named[index].destinations.filter(({ id }) => !left.has(id)),
-            };
-        }),
-    };
-    // Stops resolve to footprints before the layers compile: a stop in the open gets a pad to dock
-    // from.
-    const plan = planTransitions(metric);
-    const networks = new Map();
-    const stages = [];
-    // Two stages per layer plus the transition pass.
-    const total = plan.layers.length * 2 + 1;
-    let done = 0;
-    const progress = (stage, layer, cached) => {
-        done++;
-        options?.onProgress?.({ stage, layer, done, total, cached });
-    };
-    for (const [index, layerSource] of plan.layers.entries()) {
-        // Counted against the plan's own POI, without transition pads; the plan's layers come in order.
-        const own = source.layers[index];
-        // A wall coordinate that is not a number: the input fact carries the reason, the floor is skipped.
-        if (layerBroken[index]) {
-            progress('walkable', layerSource.layer, false);
-            progress('network', layerSource.layer, false);
-            continue;
-        }
-        const [x0, y0, x1, y1] = extentOf(layerSource);
-        const cells = ((x1 - x0 + 2) / NETWORK_SIZES.cs) * ((y1 - y0 + 2) / NETWORK_SIZES.cs);
-        // Too large to rasterize: reported and skipped, as a floor with no floor is.
-        if (Number.isFinite(cells) && cells > MAX_FLOOR_CELLS) {
-            stages.push(...fromOversize(layerSource.layer, x1 - x0, y1 - y0, own.destinations.length));
-            progress('walkable', layerSource.layer, false);
-            progress('network', layerSource.layer, false);
-            continue;
-        }
-        // A caller's walkable area is in plan units.
-        const cached = options?.walkable?.[layerSource.layer];
-        const reported = new Set();
-        let compiled;
-        try {
-            compiled = compileLayer(layerSource, ops, {
-                ...(cached && { walkable: walkableScaled(cached, 1 / unit, false) }),
-                onStage: (stage, ready) => {
-                    reported.add(stage);
-                    progress(stage, layerSource.layer, ready);
-                },
-            });
-        }
-        catch (error) {
-            if (!(error instanceof CellsRefusedError))
-                throw error;
-            // Under the cell limit, yet more than this device holds: reported like any floor too large.
-            stages.push(...fromOversize(layerSource.layer, x1 - x0, y1 - y0, own.destinations.length));
-            for (const stage of ['walkable', 'network'])
-                if (!reported.has(stage))
-                    progress(stage, layerSource.layer, false);
-            continue;
-        }
-        const collapsed = emitLayerV1(compiled.network, compiled.layer, graph);
-        networks.set(compiled.layer, compiled.network);
-        stages.push(...fromNormalize(own, compiled.facts, named[index].ids, unit), ...fromWalkable(compiled.layer, compiled.walkable.stats, own.destinations.length), ...fromNetwork(own, compiled.network.stats, unit, named[index].ids), ...fromEmit(own, collapsed, named[index].ids));
-        if (options?.debug) {
-            layers.push({
-                layer: compiled.layer,
-                rawWalls: own.walls,
-                destinations: destinationsInPlanUnits(compiled.destinations, unit),
-                walkable: walkableScaled(compiled.walkable, unit, true),
-                network: networkInPlanUnits(compiled.network, unit),
-            });
-        }
-    }
-    const shafts = emitTransitionEdges(plan, networks, graph);
-    // Orphans in plan units, like everything emitted.
-    const transitionOrphans = orphansInPlanUnits([...plan.orphans, ...shafts.orphans], unit);
-    progress('transitions', '', false);
-    const emitted = graphInPlanUnits(graph, unit);
-    // Read off the emitted graph and the plan as given, in plan units, as they are handed out.
-    const reachability = readReachability(emitted, source);
-    const diagnostics = [
-        ...input,
-        ...stages,
-        ...fromStops(plan, unit),
-        ...fromTransitions(transitionOrphans, shafts.singleFloor, unit),
-        ...fromReachability(reachability, [...input, ...stages]),
-    ];
-    // The report folds the compile's facts; the graph invariants are debug-only and stay out of it.
-    const report = buildReport(diagnostics, reachability, source);
-    if (!options?.debug)
-        return { graph: emitted, report };
-    // The pairwise sweep costs a sizable share of the compile on a large plan: opted into alone.
-    const invariants = typeof options.debug === 'object' && options.debug.invariants
-        ? fromGraphInvariants(checkGraphInvariants(emitted, layers))
-        : [];
-    return {
-        graph: emitted,
-        report,
-        layers,
-        reachability,
-        diagnostics: [...diagnostics, ...invariants],
-    };
-}

package/dist/lib/connect.d.ts

@@ -1,35 +0,0 @@
-import type { Segment } from './geom/types.js';
-import type { NetworkSizes } from './network-sizes.js';
-import type { NetworkStore } from './network-store.js';
-import { type LayPath, type TipTarget } from './place-path.js';
-import type { Router } from './router.js';
-import type { Placement } from './runs.js';
-/** Lays raster paths into the network and grows the pieces together. */
-export interface Connector {
-    /** Adds a segment and claims the cells it passes. */
-    add(seg: Segment): void;
-    /** 1 for each router cell a network line passes: where a raster path may end. */
-    readonly onNetwork: Uint8Array;
-    /** Lays a path of cells, `head` first, its ends tied to what stands at them. */
-    readonly layPath: LayPath;
-    /**
-     * One growth from the largest piece to every other piece and every lone tip the floor connects
-     * to it; what the largest piece cannot reach grows a tree of its own.
-     * @param tips Tips no line stands at yet.
-     * @returns How many pieces the growth and the ties could not join: the pieces left beyond the
-     * first, 0 when all are one.
-     */
-    connect(tips: readonly TipTarget[]): {
-        untied: number;
-    };
-}
-/**
- * Builds the connector.
- * @param store The network.
- * @param router The raster router.
- * @param cfg Network sizes.
- * @param place What the runs are laid on.
- * @returns The connector.
- */
-export declare function createConnector(store: NetworkStore, router: Router, cfg: NetworkSizes, place: Placement): Connector;
-//# sourceMappingURL=connect.d.ts.map