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

package/dist/lib/geom/footprint.js

@@ -1,203 +0,0 @@
-import { meshOutline } from './mesh-outline.js';
-import { cleanRing } from './normalize.js';
-import { boundsOf, outerRingsOf, signedArea, wound } from './primitives.js';
-/** Most vertices an axis-aligned traced outline may have to be carved as itself (an L or a T fits). */
-const MAX_OUTLINE_VERTICES = 12;
-/** How far an edge may lean off an axis and still count as axis-aligned, in meters. */
-const AXIS_EPS = 0.05;
-/**
- * Most vertices a tilted hull may have to be carved as itself: a rotated stand or a chamfered room fits,
- * a traced circle does not.
- */
-const MAX_TILTED_VERTICES = 6;
-/**
- * Share of its convex hull the pieces must fill to be carved as that hull; an L or a crescent leaves
- * aisle the hull would swallow.
- */
-const HULL_FILL = 0.95;
-/**
- * Most pieces a mesh may have to be traced; a finer mesh is a drawing (lettering, a logo) and is boxed,
- * since tracing it can take minutes. An outline of V corners triangulates into V - 2 pieces.
- */
-const MAX_MESH_PARTS = 64;
-/**
- * The outer rings of a boolean result; holes are dropped, so a footprint is carved solid.
- * @param rings Outers and holes mixed.
- * @returns The outer rings, largest first.
- */
-function outerRings(rings) {
-    return outerRingsOf(rings).sort((a, b) => Math.abs(signedArea(b)) - Math.abs(signedArea(a)));
-}
-/**
- * Whether an outline is a few rectangles joined (an L-shaped lounge): short and axis-aligned.
- * @param ring The normalized outline.
- * @returns True for a short, axis-aligned loop.
- */
-function isRectilinear(ring) {
-    if (ring.length < 4 || ring.length > MAX_OUTLINE_VERTICES)
-        return false;
-    for (let i = 0; i < ring.length; i++) {
-        const [ax, ay] = ring[i];
-        const [bx, by] = ring[(i + 1) % ring.length];
-        if (Math.abs(bx - ax) > AXIS_EPS && Math.abs(by - ay) > AXIS_EPS)
-            return false;
-    }
-    return true;
-}
-/**
- * The convex hull (Andrew's monotone chain). Read instead of the union, whose mesh seams (zero-area
- * spikes, micro-steps) would count as corners.
- * @param points The vertices.
- * @returns The hull, counter-clockwise.
- */
-function convexHull(points) {
-    const sorted = [...points].sort((a, b) => a[0] - b[0] || a[1] - b[1]);
-    if (sorted.length < 3)
-        return sorted;
-    const cross = (o, a, b) => (a[0] - o[0]) * (b[1] - o[1]) - (a[1] - o[1]) * (b[0] - o[0]);
-    const half = (pts) => {
-        const out = [];
-        for (const p of pts) {
-            while (out.length >= 2 && cross(out[out.length - 2], out[out.length - 1], p) <= 0)
-                out.pop();
-            out.push(p);
-        }
-        out.pop();
-        return out;
-    };
-    return [...half(sorted), ...half([...sorted].reverse())];
-}
-/**
- * The axis-aligned bounds of all pieces.
- * @param parts The pieces.
- * @returns A four-vertex ring, or null when the pieces enclose no area.
- */
-function boundsRing(parts) {
-    const [minX, minY, maxX, maxY] = boundsOf(parts.flat());
-    if (!(maxX > minX) || !(maxY > minY))
-        return null;
-    return [
-        [minX, minY],
-        [maxX, minY],
-        [maxX, maxY],
-        [minX, maxY],
-    ];
-}
-/**
- * The ring a route arrives at — the drawing joined with the dock rectangle — and the other drawn blocks.
- *
- * A piece identical to the dock is skipped: its shared edges would cancel out of the mesh outline. When
- * the drawing falls into blocks, the ring is the block the dock stands in; the rest come back in `drawn`
- * for the caller to carve.
- * @param parts The raw pieces, positioned, in meters.
- * @param ops Boolean backend.
- * @param dock The rectangle routes arrive at, if any.
- * @returns The ring to carve, how it was read, and the drawn blocks it does not cover (only with a
- *   dock).
- */
-export function footprintOf(parts, ops, dock) {
-    const drawing = (dock ? parts.filter((part) => !sameRing(part, dock)) : parts).filter((part) => part.length >= 3);
-    const { ring: traced, how, blocks } = tracedRing(drawing, ops);
-    if (!dock)
-        return { ring: traced, ...(traced && { how }), drawn: [] };
-    if (!traced)
-        return { ring: cleanRing(dock), how: 'dock', drawn: [] };
-    // The block the dock stands in is the body.
-    const body = blocks.filter((ring) => shareOf(ops, ring, dock) > 0);
-    const merged = outerRings(cleanedUnion(ops, [wound(dock), ...(body.length ? body : [traced])]));
-    // Union pieces are disjoint: the one holding most of the dock is the one it stands in.
-    const ring = merged.length <= 1
-        ? (merged[0] ?? traced)
-        : merged.reduce((best, r) => (shareOf(ops, r, dock) > shareOf(ops, best, dock) ? r : best));
-    // Blocks outside the ring are still obstacles; blocks inside it would only be carved twice.
-    return { ring, how, drawn: blocks.filter((block) => !covers(ops, ring, block)) };
-}
-/**
- * Whether a ring covers a block whole.
- * @param ops Boolean backend.
- * @param ring The ring.
- * @param block The block.
- * @returns True when nothing of the block lies outside.
- */
-function covers(ops, ring, block) {
-    const outside = ops
-        .difference([wound(block)], [wound(ring)])
-        .map((r) => cleanRing(r))
-        .filter((r) => r.length >= 3);
-    return outside.length === 0;
-}
-/**
- * How much of the dock a ring covers.
- * @param ops Boolean backend.
- * @param ring The ring.
- * @param dock The rectangle.
- * @returns The shared area.
- */
-function shareOf(ops, ring, dock) {
-    return ops.area(ops.intersect([wound(ring)], [wound(dock)]));
-}
-/**
- * A union with the seam vertices it leaves where rings met cleaned away.
- * @param ops Boolean backend.
- * @param rings The rings to union.
- * @returns Outers and holes mixed.
- */
-function cleanedUnion(ops, rings) {
-    return ops
-        .union(rings)
-        .map((ring) => cleanRing(ring))
-        .filter((ring) => ring.length >= 3);
-}
-/**
- * Same vertices in the same order. Exact on purpose: the host scales one array into `dock` and `parts`,
- * so copies match to the bit, and a tolerance would drop pieces that merely resemble the dock.
- * @param a One ring.
- * @param b The other.
- * @returns Whether they are identical.
- */
-function sameRing(a, b) {
-    return a.length === b.length && a.every((p, i) => p[0] === b[i][0] && p[1] === b[i][1]);
-}
-/**
- * The shape the pieces cover: the mesh outline as is, however many corners. A mesh whose outline does
- * not close falls back to its hull when it fills it, a short axis-aligned trace, or its box.
- * @param usable The pieces, at least three vertices each.
- * @param ops Boolean backend.
- * @returns The ring (null when the pieces enclose no area), how it was read, and the blocks the
- *   mesh outline falls into, largest first.
- */
-function tracedRing(usable, ops) {
-    if (usable.length === 0)
-        return { ring: null, how: 'traced', blocks: [] };
-    // Carved exactly: a larger shape would take the aisle beside it.
-    const boundary = meshOutline(usable);
-    const blocks = boundary ? outerRings(cleanedUnion(ops, boundary)) : [];
-    // Several pieces keep the largest: one destination is one place to walk to.
-    if (blocks.length)
-        return { ring: blocks[0], how: 'traced', blocks };
-    return { ...fallbackRing(usable, ops), blocks };
-}
-/**
- * The shape of a mesh whose outline does not close: its hull when it fills it, a short axis-aligned
- * trace, or its box.
- * @param usable The pieces, at least three vertices each.
- * @param ops Boolean backend.
- * @returns The ring (null when the pieces enclose no area) and how it was read.
- */
-function fallbackRing(usable, ops) {
-    // Pieces' area against the hull's settles convex shapes without a boolean; a simple full hull is carved.
-    const hull = convexHull(usable.flat());
-    const hullArea = Math.abs(signedArea(hull));
-    const covered = usable.reduce((sum, part) => sum + Math.abs(signedArea(part)), 0);
-    if (hullArea > 0 && covered >= HULL_FILL * hullArea)
-        return hull.length >= 3 && hull.length <= MAX_TILTED_VERTICES
-            ? { ring: hull, how: 'hull' }
-            : { ring: boundsRing(usable), how: 'bounds' };
-    // Not hull-filling: an L, a T, gapped pieces or a drawing. Traced only while the mesh is small.
-    if (usable.length > MAX_MESH_PARTS)
-        return { ring: boundsRing(usable), how: 'bounds-oversized' };
-    const outers = outerRings(cleanedUnion(ops, usable));
-    if (outers.length === 1 && isRectilinear(outers[0]))
-        return { ring: outers[0], how: 'rectilinear' };
-    return { ring: boundsRing(usable), how: 'bounds' };
-}

package/dist/lib/geom/frames.d.ts

@@ -1,116 +0,0 @@
-import type { Ring, Segment, Vec2 } from './types.js';
-/** A pair of axes: the first as a unit vector, the second a quarter turn on. */
-export interface Frame {
-    /** The first axis's x. */
-    readonly cos: number;
-    /** The first axis's y. */
-    readonly sin: number;
-}
-/** The plan's own axes. */
-export declare const PLAN: Frame;
-/**
- * A point in a frame's coordinates.
- * @param frame The frame.
- * @param x Plan x.
- * @param y Plan y.
- * @returns The point as `[u, v]` along the frame's axes.
- */
-export declare function toFrame(frame: Frame, x: number, y: number): Vec2;
-/**
- * A point of a frame back on the plan.
- * @param frame The frame.
- * @param u Coordinate along the first axis.
- * @param v Coordinate along the second.
- * @returns The point in plan coordinates.
- */
-export declare function fromFrame(frame: Frame, u: number, v: number): Vec2;
-/**
- * A point of a frame in plan coordinates, snapped to the centimeter grid like every network point.
- * @param frame The frame.
- * @param u Coordinate along the first axis.
- * @param v Coordinate along the second.
- * @returns The point, on the centimeter grid.
- */
-export declare function placeIn(frame: Frame, u: number, v: number): Vec2;
-/**
- * Rings turned into a frame's coordinates.
- * @param rings Rings in plan coordinates.
- * @param frame The frame.
- * @returns The rings in frame coordinates.
- */
-export declare function turnedInto(rings: readonly Ring[], frame: Frame): Ring[];
-/**
- * The frame with an axis nearest to a direction.
- * @param frames The frames to choose from.
- * @param dx Direction x.
- * @param dy Direction y.
- * @returns The frame's index.
- */
-export declare function nearestFrame(frames: readonly Frame[], dx: number, dy: number): number;
-/**
- * The nearest frame, if the direction is within what the raster can tell over `reach`; a stand set at
- * its own angle runs along none.
- * @param frames The frames to choose from.
- * @param dx Direction x.
- * @param dy Direction y.
- * @param resolution The raster cell.
- * @param reach The length the direction is read over.
- * @returns The index of that frame, or -1.
- */
-export declare function frameRunning(frames: readonly Frame[], dx: number, dy: number, resolution: number, reach: number): number;
-/**
- * The right-angled way between two points in a frame: one leg when they share an axis within
- * `NODE_SNAP`, else two legs through whichever corner is free. No diagonals: they read as mistakes.
- * @param frame The frame the legs run along.
- * @param a Start.
- * @param b End.
- * @param free Whether a leg may be laid.
- * @returns The legs, or null when neither corner is free.
- */
-export declare function legsBetween(frame: Frame, a: Vec2, b: Vec2, free: (leg: Segment) => boolean): Segment[] | null;
-/**
- * The way from a point onto a network line: one straight leg along a frame axis when it lands within
- * `NODE_SNAP` of the nearest point, else the right-angled way to the nearest point.
- * @param frame The frame the legs run along.
- * @param from Start.
- * @param line The segment to join.
- * @param nearest The point of `line` nearest to `from`.
- * @param free Whether a leg may be laid.
- * @returns The legs and where they meet the line, or null when no way is free.
- */
-export declare function linkOnto(frame: Frame, from: Vec2, line: Segment, nearest: Vec2, free: (leg: Segment) => boolean): {
-    legs: Segment[];
-    at: Vec2;
-} | null;
-/**
- * Where two lines meet.
- * @param a A point of the first line.
- * @param da Its direction.
- * @param b A point of the second line.
- * @param db Its direction.
- * @returns The point and its parameter along each direction, or null when parallel.
- */
-export declare function linesMeet(a: Vec2, da: Vec2, b: Vec2, db: Vec2): {
-    at: Vec2;
-    ta: number;
-    tb: number;
-} | null;
-/** One direction a layer is drawn in, and the outlines drawn in it. */
-export interface Direction {
-    /** Its axes. */
-    readonly frame: Frame;
-    /** The outlines drawn in it. */
-    readonly rings: Ring[];
-}
-/**
- * The directions a layer's destinations are drawn in, {@link PLAN} first.
- *
- * Each destination is read by its longest side, longest sides first. A side joins a direction it is
- * within `resolution / length` of (what the raster can tell apart), else opens a new one. A direction
- * with a single destination is a stand set at an angle and is dropped.
- * @param rings The destinations' outlines.
- * @param resolution The raster cell.
- * @returns The directions, {@link PLAN} first.
- */
-export declare function framesOf(rings: readonly Ring[], resolution: number): Direction[];
-//# sourceMappingURL=frames.d.ts.map

package/dist/lib/geom/frames.js

@@ -1,233 +0,0 @@
-// The directions a layer is drawn in: a turned hall gets axes of its own so the network runs along its
-// aisles instead of stair-stepping across them.
-import { NODE_SNAP } from '../graph-types.js';
-import { snapCm } from './point-key.js';
-import { rayVsSegment } from './primitives.js';
-/** The plan's own axes. */
-export const PLAN = { cos: 1, sin: 0 };
-const QUARTER = Math.PI / 2;
-/**
- * A point in a frame's coordinates.
- * @param frame The frame.
- * @param x Plan x.
- * @param y Plan y.
- * @returns The point as `[u, v]` along the frame's axes.
- */
-export function toFrame(frame, x, y) {
-    return [x * frame.cos + y * frame.sin, y * frame.cos - x * frame.sin];
-}
-/**
- * A point of a frame back on the plan.
- * @param frame The frame.
- * @param u Coordinate along the first axis.
- * @param v Coordinate along the second.
- * @returns The point in plan coordinates.
- */
-export function fromFrame(frame, u, v) {
-    return [u * frame.cos - v * frame.sin, u * frame.sin + v * frame.cos];
-}
-/**
- * A point of a frame in plan coordinates, snapped to the centimeter grid like every network point.
- * @param frame The frame.
- * @param u Coordinate along the first axis.
- * @param v Coordinate along the second.
- * @returns The point, on the centimeter grid.
- */
-export function placeIn(frame, u, v) {
-    const [x, y] = fromFrame(frame, u, v);
-    return [snapCm(x), snapCm(y)];
-}
-/**
- * Rings turned into a frame's coordinates.
- * @param rings Rings in plan coordinates.
- * @param frame The frame.
- * @returns The rings in frame coordinates.
- */
-export function turnedInto(rings, frame) {
-    return rings.map((ring) => ring.map((p) => toFrame(frame, p[0], p[1])));
-}
-/**
- * The frame with an axis nearest to a direction.
- * @param frames The frames to choose from.
- * @param dx Direction x.
- * @param dy Direction y.
- * @returns The frame's index.
- */
-export function nearestFrame(frames, dx, dy) {
-    let best = 0;
-    let least = Infinity;
-    frames.forEach((frame, i) => {
-        const [u, v] = toFrame(frame, dx, dy);
-        const off = Math.min(Math.abs(u), Math.abs(v));
-        if (off < least) {
-            least = off;
-            best = i;
-        }
-    });
-    return best;
-}
-/**
- * The nearest frame, if the direction is within what the raster can tell over `reach`; a stand set at
- * its own angle runs along none.
- * @param frames The frames to choose from.
- * @param dx Direction x.
- * @param dy Direction y.
- * @param resolution The raster cell.
- * @param reach The length the direction is read over.
- * @returns The index of that frame, or -1.
- */
-export function frameRunning(frames, dx, dy, resolution, reach) {
-    const i = nearestFrame(frames, dx, dy);
-    const len = Math.hypot(dx, dy) || 1;
-    const [u, v] = toFrame(frames[i], dx / len, dy / len);
-    return Math.min(Math.abs(u), Math.abs(v)) <= resolution / reach ? i : -1;
-}
-/**
- * Whether the way between two points runs along neither axis of a frame.
- * @param frame The frame.
- * @param a One point.
- * @param b The other.
- * @param eps Tolerance off an axis.
- * @returns True when both coordinates differ by more than `eps`.
- */
-function turnsIn(frame, a, b, eps) {
-    const [au, av] = toFrame(frame, a[0], a[1]);
-    const [bu, bv] = toFrame(frame, b[0], b[1]);
-    return Math.abs(bu - au) > eps && Math.abs(bv - av) > eps;
-}
-/**
- * The right-angled way between two points in a frame: one leg when they share an axis within
- * `NODE_SNAP`, else two legs through whichever corner is free. No diagonals: they read as mistakes.
- * @param frame The frame the legs run along.
- * @param a Start.
- * @param b End.
- * @param free Whether a leg may be laid.
- * @returns The legs, or null when neither corner is free.
- */
-export function legsBetween(frame, a, b, free) {
-    const ways = turnsIn(frame, a, b, NODE_SNAP)
-        ? [cornerOf(frame, a, b), cornerOf(frame, b, a)].map((c) => [
-            [a[0], a[1], c[0], c[1]],
-            [c[0], c[1], b[0], b[1]],
-        ])
-        : [[[a[0], a[1], b[0], b[1]]]];
-    return ways.find((legs) => legs.every(free)) ?? null;
-}
-/**
- * The way from a point onto a network line: one straight leg along a frame axis when it lands within
- * `NODE_SNAP` of the nearest point, else the right-angled way to the nearest point.
- * @param frame The frame the legs run along.
- * @param from Start.
- * @param line The segment to join.
- * @param nearest The point of `line` nearest to `from`.
- * @param free Whether a leg may be laid.
- * @returns The legs and where they meet the line, or null when no way is free.
- */
-export function linkOnto(frame, from, line, nearest, free) {
-    const away = Math.hypot(nearest[0] - from[0], nearest[1] - from[1]);
-    const hit = [0, 0];
-    for (const [dx, dy] of [
-        [frame.cos, frame.sin],
-        [-frame.sin, frame.cos],
-    ]) {
-        if (!rayVsSegment(hit, from[0], from[1], dx, dy, line[0], line[1], line[2], line[3]))
-            continue;
-        const [t, u] = hit;
-        if (u < 0 || u > 1 || Math.abs(Math.abs(t) - away) > NODE_SNAP)
-            continue;
-        const at = [snapCm(from[0] + dx * t), snapCm(from[1] + dy * t)];
-        const leg = [from[0], from[1], at[0], at[1]];
-        if (free(leg))
-            return { legs: [leg], at };
-    }
-    const legs = legsBetween(frame, from, nearest, free);
-    return legs && { legs, at: nearest };
-}
-/**
- * The corner of the way from `a` along the first axis, then the second to `b`.
- * @param frame The frame.
- * @param a Start.
- * @param b End.
- * @returns The corner, on the centimeter grid.
- */
-function cornerOf(frame, a, b) {
-    const [, va] = toFrame(frame, a[0], a[1]);
-    const [ub] = toFrame(frame, b[0], b[1]);
-    return placeIn(frame, ub, va);
-}
-/**
- * Where two lines meet.
- * @param a A point of the first line.
- * @param da Its direction.
- * @param b A point of the second line.
- * @param db Its direction.
- * @returns The point and its parameter along each direction, or null when parallel.
- */
-export function linesMeet(a, da, b, db) {
-    const hit = [0, 0];
-    if (!rayVsSegment(hit, a[0], a[1], da[0], da[1], b[0], b[1], b[0] + db[0], b[1] + db[1]))
-        return null;
-    const [ta, tb] = hit;
-    return { at: [snapCm(a[0] + da[0] * ta), snapCm(a[1] + da[1] * ta)], ta, tb };
-}
-/**
- * The direction of a side, modulo a quarter turn.
- * @param a One end.
- * @param b The other.
- * @returns Its angle in `[0, π/2)`.
- */
-function directionOf(a, b) {
-    return ((Math.atan2(b[1] - a[1], b[0] - a[0]) % QUARTER) + QUARTER) % QUARTER;
-}
-/**
- * The turn between two directions, modulo a quarter turn.
- * @param from One angle.
- * @param to The other.
- * @returns The signed turn `to − from`, in `[−π/4, π/4)`.
- */
-function turn(from, to) {
-    return ((((to - from + QUARTER / 2) % QUARTER) + QUARTER) % QUARTER) - QUARTER / 2;
-}
-/**
- * The directions a layer's destinations are drawn in, {@link PLAN} first.
- *
- * Each destination is read by its longest side, longest sides first. A side joins a direction it is
- * within `resolution / length` of (what the raster can tell apart), else opens a new one. A direction
- * with a single destination is a stand set at an angle and is dropped.
- * @param rings The destinations' outlines.
- * @param resolution The raster cell.
- * @returns The directions, {@link PLAN} first.
- */
-export function framesOf(rings, resolution) {
-    const sides = rings
-        .map((ring) => {
-        let best = { ring, length: 0, angle: 0 };
-        ring.forEach((a, i) => {
-            const b = ring[(i + 1) % ring.length];
-            const length = Math.hypot(b[0] - a[0], b[1] - a[1]);
-            if (length > best.length)
-                best = { ring, length, angle: directionOf(a, b) };
-        });
-        return best;
-    })
-        .filter((side) => side.length > 0)
-        .sort((a, b) => b.length - a.length || a.angle - b.angle);
-    // Infinite weight: the plan's axes never move.
-    const found = [{ angle: 0, weight: Infinity, rings: [], plan: true }];
-    for (const { ring, length, angle } of sides) {
-        const eps = resolution / length;
-        const near = found.find((f) => Math.abs(turn(f.angle, angle)) <= eps);
-        if (!near) {
-            found.push({ angle, weight: length, rings: [ring], plan: false });
-            continue;
-        }
-        // Length-weighted mean: longer sides are known better.
-        const mean = near.angle + (turn(near.angle, angle) * length) / (near.weight + length);
-        near.angle = ((mean % QUARTER) + QUARTER) % QUARTER;
-        near.weight += length;
-        near.rings.push(ring);
-    }
-    return found
-        .filter((f) => f.plan || f.rings.length >= 2)
-        .map((f) => ({ frame: { cos: Math.cos(f.angle), sin: Math.sin(f.angle) }, rings: f.rings }));
-}

package/dist/lib/geom/mesh-outline.d.ts

@@ -1,13 +0,0 @@
-import type { Ring } from './types.js';
-/**
- * The boundary of a mesh: the edges no two pieces share, stitched end to end. One pass instead of a
- * boolean, which takes minutes on fine meshes.
- *
- * The rings are meant to be unioned. A tiling gives its outline plus a ring per hole; overlapping pieces
- * share no edges and come back as themselves. The same shape given twice cancels its own edges, which is
- * why `footprintOf` leaves the dock out of the pieces.
- * @param parts The mesh pieces, wound either way.
- * @returns The boundary rings, or null when they enclose nothing.
- */
-export declare function meshOutline(parts: readonly Ring[]): Ring[] | null;
-//# sourceMappingURL=mesh-outline.d.ts.map

package/dist/lib/geom/mesh-outline.js

@@ -1,90 +0,0 @@
-import { cleanRing } from './normalize.js';
-import { wound } from './primitives.js';
-/**
- * Grid vertices snap to before edges are matched, in meters: shared vertices are written once per piece
- * and may differ in the last bits.
- */
-const WELD = 0.001;
-/**
- * Key of a welded vertex; pieces meeting at a corner get the same one.
- * @param x Vertex x.
- * @param y Vertex y.
- * @returns The key.
- */
-function weld(x, y) {
-    return `${Math.round(x / WELD)}:${Math.round(y / WELD)}`;
-}
-/**
- * The boundary of a mesh: the edges no two pieces share, stitched end to end. One pass instead of a
- * boolean, which takes minutes on fine meshes.
- *
- * The rings are meant to be unioned. A tiling gives its outline plus a ring per hole; overlapping pieces
- * share no edges and come back as themselves. The same shape given twice cancels its own edges, which is
- * why `footprintOf` leaves the dock out of the pieces.
- * @param parts The mesh pieces, wound either way.
- * @returns The boundary rings, or null when they enclose nothing.
- */
-export function meshOutline(parts) {
-    const seen = new Map();
-    for (const part of parts) {
-        if (part.length < 3)
-            continue;
-        // Same winding for all pieces, so a shared edge is walked both ways.
-        const ring = wound(part);
-        for (let i = 0; i < ring.length; i++) {
-            const from = ring[i];
-            const to = ring[(i + 1) % ring.length];
-            const a = weld(from[0], from[1]);
-            const b = weld(to[0], to[1]);
-            if (a === b)
-                continue;
-            const key = a < b ? `${a}|${b}` : `${b}|${a}`;
-            const known = seen.get(key);
-            if (known)
-                known.count++;
-            else
-                seen.set(key, { from, to, count: 1 });
-        }
-    }
-    const edges = [...seen.values()].filter((edge) => edge.count === 1);
-    if (edges.length < 3)
-        return null;
-    // An edge shared by three pieces means overlap: not a tiling, so no outline.
-    for (const edge of seen.values())
-        if (edge.count > 2)
-            return null;
-    const outgoing = new Map();
-    for (const edge of edges) {
-        const key = weld(edge.from[0], edge.from[1]);
-        outgoing.set(key, [...(outgoing.get(key) ?? []), edge]);
-    }
-    const used = new Set();
-    const rings = [];
-    for (const start of edges) {
-        if (used.has(start))
-            continue;
-        const ring = [start.from];
-        let edge = start;
-        for (;;) {
-            used.add(edge);
-            ring.push(edge.to);
-            const next = (outgoing.get(weld(edge.to[0], edge.to[1])) ?? []).find((e) => !used.has(e));
-            if (!next)
-                break;
-            edge = next;
-            // Back at the start: the ring is closed.
-            if (weld(edge.from[0], edge.from[1]) === weld(start.from[0], start.from[1]))
-                break;
-        }
-        // An open chain encloses nothing and is dropped; the closed rings are still the boundary.
-        const closed = weld(ring[ring.length - 1][0], ring[ring.length - 1][1]) ===
-            weld(start.from[0], start.from[1]);
-        if (!closed)
-            continue;
-        ring.pop();
-        const cleaned = cleanRing(ring);
-        if (cleaned.length >= 3)
-            rings.push(cleaned);
-    }
-    return rings.length ? rings : null;
-}

package/dist/lib/geom/normalize.d.ts

@@ -1,28 +0,0 @@
-import type { Vec2 } from './types.js';
-/** A cleaned wall centerline: one continuous run of a raw `walls` entry. */
-export interface WallLine {
-    /** Deduplicated vertices; a closed run does not repeat its first vertex. */
-    readonly points: readonly Vec2[];
-    /** A closed contour, or an open wall (e.g. with a door gap). */
-    readonly closed: boolean;
-}
-/**
- * Splits a raw `walls` entry into the continuous runs it describes.
- *
- * The export stores one segment per vertex pair, joined by repeating the shared vertex; where a pair does
- * not touch the next, a new run starts elsewhere. Read as one polyline, each such gap would become a
- * phantom wall. The joint parity is read off the entry, since exports double from either vertex.
- * @param flat Flat `[x0, y0, x1, y1, …]` coordinates.
- * @param eps Merge tolerance for coincident vertices.
- * @returns The deduplicated runs; runs of fewer than two vertices are dropped.
- */
-export declare function cleanPolylineRuns(flat: readonly number[], eps?: number): WallLine[];
-/**
- * Normalizes a ring: drops coincident vertices (the closing one included) and vertices within `eps` of
- * the segment between their neighbors. Every surviving vertex splits a face, and each face grows a stub.
- * @param ring The ring, open or explicitly closed.
- * @param eps Tolerance for coincidence and collinearity.
- * @returns The ring, implicitly closed.
- */
-export declare function cleanRing(ring: readonly Vec2[], eps?: number): Vec2[];
-//# sourceMappingURL=normalize.d.ts.map