@pascal-app/core 1.0.1 → 1.0.4

package/dist/lib/geometry-surfaces.js

@@ -0,0 +1,156 @@
+/** Part types whose tops shelter rather than hold: nothing is placed on a porch roof. */
+const SHELTER_TYPES = new Set(['roof', 'canopy', 'awning', 'ceiling']);
+function receives(manifest, surface) {
+    if (!surface.part)
+        return true;
+    const type = manifest.parts.find((part) => part.id === surface.part)?.type;
+    return !(type && SHELTER_TYPES.has(type));
+}
+function contains(polygon, x, z) {
+    let inside = false;
+    for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+        const [xi, zi] = polygon[i];
+        const [xj, zj] = polygon[j];
+        if (zi > z !== zj > z && x < ((xj - xi) * (z - zi)) / (zj - zi) + xi)
+            inside = !inside;
+    }
+    return inside;
+}
+function area(polygon) {
+    let sum = 0;
+    for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+        sum += (polygon[j][0] + polygon[i][0]) * (polygon[j][1] - polygon[i][1]);
+    }
+    return Math.abs(sum) / 2;
+}
+/** Non-roof surfaces covering at least half the object's footprint: its landing, its top. */
+function mainSurfaces(manifest) {
+    const { min, max } = manifest.bounds;
+    const footprint = (max[0] - min[0]) * (max[2] - min[2]);
+    return manifest.surfaces.filter((surface) => receives(manifest, surface) && area(surface.polygon) >= footprint / 2);
+}
+const highest = (surfaces) => surfaces.reduce((best, s) => (!best || s.y > best.y ? s : best), null);
+/**
+ * Where something dropped at local (x, z) comes to rest on an authored
+ * object: its main surface when the point is over it (a bench anywhere on a
+ * porch lands on the landing, not on the beam), otherwise the highest
+ * non-roof surface under the point. `maxY` caps the search. Null when
+ * nothing is under the point.
+ */
+export function geometrySurfaceAt(manifest, x, z, maxY = Number.POSITIVE_INFINITY) {
+    const under = (surface) => surface.y <= maxY && contains(surface.polygon, x, z);
+    return (highest(mainSurfaces(manifest).filter(under)) ??
+        highest(manifest.surfaces.filter((s) => receives(manifest, s) && under(s))));
+}
+/**
+ * The one height an authored object offers as "where things rest" (the
+ * item's `asset.surface`): its highest main surface, so a porch rests things
+ * on its landing and a table on its top. Null when it has none.
+ */
+export function geometryRestingHeight(manifest) {
+    return highest(mainSurfaces(manifest))?.y ?? null;
+}
+/**
+ * Where a ceiling item hangs from an authored object above local (x, z): the
+ * lowest underside over the point (a beam before the vault plane above it),
+ * with its height there — sloped undersides included. Null when none is over it.
+ */
+export function geometryUndersideAt(manifest, x, z) {
+    let best = null;
+    for (const underside of manifest.undersides) {
+        const [a, b, c, d] = underside.plane;
+        if (b === 0 || !contains(underside.polygon, x, z))
+            continue;
+        const y = -(a * x + c * z + d) / b;
+        if (!best || y < best.y)
+            best = { part: underside.part, y, normal: [a, b, c] };
+    }
+    return best;
+}
+/**
+ * The rotation that seats a flush fixture (a recessed can) on a sloped
+ * underside: its +Y goes into the surface, against the downward `normal`,
+ * then it keeps its own turn `yaw`. Euler XYZ, as items store rotation.
+ */
+export function flushMountRotation(normal, yaw) {
+    // Quaternion turning +Y onto -normal (the direction into the surface).
+    const [vx, vy, vz] = [-normal[0], -normal[1], -normal[2]];
+    let [qx, qy, qz, qw] = [vz, 0, -vx, 1 + vy];
+    const length = Math.hypot(qx, qy, qz, qw) || 1;
+    [qx, qy, qz, qw] = [qx / length, qy / length, qz / length, qw / length];
+    // Then the fixture's own yaw about its local +Y.
+    const [sy, cy] = [Math.sin(yaw / 2), Math.cos(yaw / 2)];
+    const [x, y, z, w] = [qx * cy - qz * sy, qw * sy + qy * cy, qz * cy + qx * sy, qw * cy - qy * sy];
+    const m11 = 1 - 2 * (y * y + z * z);
+    const m12 = 2 * (x * y - w * z);
+    const m13 = 2 * (x * z + w * y);
+    const m22 = 1 - 2 * (x * x + z * z);
+    const m23 = 2 * (y * z - w * x);
+    const m32 = 2 * (y * z + w * x);
+    const m33 = 1 - 2 * (x * x + y * y);
+    const ry = Math.asin(Math.max(-1, Math.min(1, m13)));
+    return Math.abs(m13) < 0.9999999
+        ? [Math.atan2(-m23, m33), ry, Math.atan2(-m12, m11)]
+        : [Math.atan2(m32, m22), ry, 0];
+}
+/** At or under this height a ceiling fixture mounts flush (a can, a surface light) rather than hangs. */
+const FLUSH_MOUNT_MAX_HEIGHT = 0.15;
+/**
+ * Whether a ceiling fixture sits flush on a surface (tilting with a slope)
+ * rather than hanging plumb: flagged `recessed`, or shallow enough that it
+ * can only be a can or a surface light (catalog data often lacks the flag).
+ */
+export function mountsFlush(asset) {
+    return Boolean(asset.recessed) || (asset.dimensions?.[1] ?? 1) <= FLUSH_MOUNT_MAX_HEIGHT;
+}
+/** The closest point to (x, z) inside a convex outline (itself when inside). */
+export function nearestPointIn(polygon, x, z) {
+    if (contains(polygon, x, z))
+        return [x, z];
+    let best = [x, z];
+    let bestDistance = Number.POSITIVE_INFINITY;
+    for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+        const [ax, az] = polygon[j];
+        const [bx, bz] = polygon[i];
+        const dx = bx - ax;
+        const dz = bz - az;
+        const t = Math.max(0, Math.min(1, ((x - ax) * dx + (z - az) * dz) / (dx * dx + dz * dz || 1)));
+        const px = ax + t * dx;
+        const pz = az + t * dz;
+        const distance = Math.hypot(px - x, pz - z);
+        if (distance < bestDistance) {
+            bestDistance = distance;
+            best = [px, pz];
+        }
+    }
+    return best;
+}
+/**
+ * Where a child item of an authored object sits after the object is rebuilt:
+ * a resting item back on the surface under it (moved onto the main surface
+ * when that shrank away from it), a hanging one from the underside above it.
+ * Positions are in the object's frame; `scale` is the object's. Null when
+ * nothing applies (wall-mounted children, objects without surfaces).
+ */
+export function resettledPosition(manifest, child, scale) {
+    const [sx, sy, sz] = scale;
+    const x = child.position[0] / sx;
+    const z = child.position[2] / sz;
+    if (child.asset.attachTo === 'ceiling') {
+        const underside = geometryUndersideAt(manifest, x, z);
+        if (!underside)
+            return null;
+        const drop = mountsFlush(child.asset) ? 0.02 : (child.asset.dimensions?.[1] ?? 0);
+        return [child.position[0], underside.y * sy - drop, child.position[2]];
+    }
+    if (child.asset.attachTo)
+        return null;
+    const surface = geometrySurfaceAt(manifest, x, z);
+    if (surface)
+        return [child.position[0], surface.y * sy, child.position[2]];
+    const main = mainSurfaces(manifest).sort((a, b) => b.y - a.y)[0];
+    if (!main)
+        return null;
+    const [nx, nz] = nearestPointIn(main.polygon, x, z);
+    return [nx * sx, main.y * sy, nz * sz];
+}

package/dist/lib/item-slab-support.d.ts

@@ -0,0 +1,14 @@
+import type { SlabNode } from '../schema/index.js';
+type Footprint = {
+    position: [number, number, number];
+    dimensions: [number, number, number];
+    rotation: [number, number, number];
+};
+export declare function slabSupportsItemFootprint(slab: SlabNode, footprint: Footprint, renderedPolygon: [number, number][]): boolean;
+/** Rendered polygons may come from the placement cache or a headless scene snapshot. */
+export declare function selectSlabSupportForItem(slabs: Iterable<SlabNode>, footprint: Footprint, renderedPolygon: (slab: SlabNode) => [number, number][], options?: {
+    maxElevation?: number | null;
+    preferredSlabId?: string | null;
+}): SlabNode | undefined;
+export {};
+//# sourceMappingURL=item-slab-support.d.ts.map

package/dist/lib/item-slab-support.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"item-slab-support.d.ts","sourceRoot":"","sources":["../../src/lib/item-slab-support.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAIzC,KAAK,SAAS,GAAG;IACf,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IACpC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CACnC,CAAA;AAED,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,QAAQ,EACd,SAAS,EAAE,SAAS,EACpB,eAAe,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,GAClC,OAAO,CAST;AAED,wFAAwF;AACxF,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,QAAQ,CAAC,QAAQ,CAAC,EACzB,SAAS,EAAE,SAAS,EACpB,eAAe,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,EACvD,OAAO,GAAE;IAAE,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAAC,eAAe,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;CAAO,GAC9E,QAAQ,GAAG,SAAS,CAsBtB"}

package/dist/lib/item-slab-support.js

@@ -0,0 +1,40 @@
+import { pointInPolygon, SUPPORT_ELEVATION_EPSILON } from '../systems/slab/slab-support.js';
+import { itemOverlapsPolygon } from './item-polygon-overlap.js';
+export function slabSupportsItemFootprint(slab, footprint, renderedPolygon) {
+    const { position, dimensions, rotation } = footprint;
+    return (slab.polygon.length >= 3 &&
+        itemOverlapsPolygon(position, dimensions, rotation, renderedPolygon, 0.01) &&
+        !(slab.holes ?? []).some((hole) => hole.length >= 3 && pointInPolygon(position[0], position[2], hole)));
+}
+/** Rendered polygons may come from the placement cache or a headless scene snapshot. */
+export function selectSlabSupportForItem(slabs, footprint, renderedPolygon, options = {}) {
+    const { maxElevation, preferredSlabId } = options;
+    if (maxElevation == null && preferredSlabId === 'ground')
+        return;
+    let highest;
+    let preferred;
+    let covering;
+    let prefersBase = false;
+    for (const slab of slabs) {
+        if (slab.id === preferredSlabId && slab.plateRole === 'base')
+            prefersBase = true;
+        const elevation = slab.elevation ?? 0.05;
+        if (maxElevation != null && elevation > maxElevation + SUPPORT_ELEVATION_EPSILON)
+            continue;
+        if (!slabSupportsItemFootprint(slab, footprint, renderedPolygon(slab)))
+            continue;
+        if (!highest || elevation > (highest.elevation ?? 0.05))
+            highest = slab;
+        if (slab.id === preferredSlabId)
+            preferred = slab;
+        if (slab.plateRole === 'platform' && (!covering || elevation > (covering.elevation ?? 0.05)))
+            covering = slab;
+    }
+    if (maxElevation == null) {
+        if (prefersBase && covering)
+            return covering;
+        if (preferred)
+            return preferred;
+    }
+    return highest;
+}

package/dist/lib/level-footprints.d.ts

@@ -0,0 +1,23 @@
+import type { WallNode } from '../schema/index.js';
+import { type MultiPolygon } from './polygon-boolean.js';
+import type { LevelFootprintContext, TopologyRoom } from './room-topology-index.js';
+export declare function roomWallFootprints(rooms: readonly TopologyRoom[]): MultiPolygon;
+export declare function roomClearPolygon(room: TopologyRoom): MultiPolygon;
+/** Rooms must belong to the same immutable level topology revision. */
+export declare function plateFootprint(rooms: readonly TopologyRoom[]): MultiPolygon;
+export type ExposedInterval = {
+    covered?: boolean;
+    polygonIndex: number;
+    edgeIndex: number;
+    t0: number;
+    t1: number;
+    start: [number, number];
+    end: [number, number];
+};
+/** Passing a topology context reuses its joined footprints across every plate in that revision. */
+export declare function exposedIntervals(plate: MultiPolygon, walls: readonly WallNode[] | LevelFootprintContext, cover?: MultiPolygon, options?: {
+    includeCovered?: boolean;
+    splitAt?: MultiPolygon;
+}): ExposedInterval[];
+export declare function clearLevelFootprintCaches(): void;
+//# sourceMappingURL=level-footprints.d.ts.map

package/dist/lib/level-footprints.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"level-footprints.d.ts","sourceRoot":"","sources":["../../src/lib/level-footprints.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAKzC,OAAO,EAIL,KAAK,YAAY,EAGlB,MAAM,mBAAmB,CAAA;AAE1B,OAAO,KAAK,EAAE,qBAAqB,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAmLhF,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,SAAS,YAAY,EAAE,GAAG,YAAY,CAE/E;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,YAAY,GAAG,YAAY,CASjE;AAED,uEAAuE;AACvE,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,YAAY,EAAE,GAAG,YAAY,CA8F3E;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,YAAY,EAAE,MAAM,CAAA;IACpB,SAAS,EAAE,MAAM,CAAA;IACjB,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACvB,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACtB,CAAA;AA2ED,mGAAmG;AACnG,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,YAAY,EACnB,KAAK,EAAE,SAAS,QAAQ,EAAE,GAAG,qBAAqB,EAClD,KAAK,CAAC,EAAE,YAAY,EACpB,OAAO,CAAC,EAAE;IAAE,cAAc,CAAC,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,YAAY,CAAA;CAAE,GAC7D,eAAe,EAAE,CA2EnB;AAED,wBAAgB,yBAAyB,IAAI,IAAI,CAEhD"}

package/dist/lib/level-footprints.js

@@ -0,0 +1,398 @@
+import { getWallSurfacePolygon, isCurvedWall } from '../systems/wall/wall-curve.js';
+import { calculateLevelMiters, getWallPlanFootprint } from '../systems/wall/wall-footprint.js';
+import { getWallFaceLine } from '../systems/wall/wall-frame.js';
+import { getWallMiterBoundaryPoints } from '../systems/wall/wall-mitering.js';
+import { area, containsPoint, difference, union, } from './polygon-boolean.js';
+import { WALL_JUNCTION_TOLERANCE } from './room-graph.js';
+const sharedPlateCache = new Map();
+const clearCache = new WeakMap();
+const plateCache = new WeakMap();
+const plateContexts = new WeakMap();
+const miterCache = new WeakMap();
+function clipWallSpan(polygon, wall, t0, t1) {
+    let result = polygon;
+    const dx = wall.end[0] - wall.start[0], dz = wall.end[1] - wall.start[1];
+    const length = Math.hypot(dx, dz);
+    const tangent = { x: dx / length, y: dz / length };
+    for (const [t, sign] of [
+        [t0, 1],
+        [t1, -1],
+    ]) {
+        // Spans use chord parameters, and topology can snap a junction up to 8 cm
+        // from an endpoint. Keep the real miter at those terminal spans.
+        if ((sign === 1 && t * length <= WALL_JUNCTION_TOLERANCE) ||
+            (sign === -1 && (1 - t) * length <= WALL_JUNCTION_TOLERANCE))
+            continue;
+        const point = { x: wall.start[0] + dx * t, y: wall.start[1] + dz * t };
+        const distance = ([x, z]) => sign * ((x - point.x) * tangent.x + (z - point.y) * tangent.y);
+        const clipped = [];
+        for (const [i, end] of result.entries()) {
+            const start = result[(i + result.length - 1) % result.length];
+            const a = distance(start), b = distance(end);
+            if (a >= 0 !== b >= 0) {
+                const u = a / (a - b);
+                clipped.push([start[0] + u * (end[0] - start[0]), start[1] + u * (end[1] - start[1])]);
+            }
+            if (b >= 0)
+                clipped.push(end);
+        }
+        result = clipped;
+    }
+    return result;
+}
+function boundaryFootprints(rooms) {
+    const context = rooms[0]?.context;
+    if (!context)
+        return [];
+    let miters = miterCache.get(context);
+    if (!miters) {
+        miters = calculateLevelMiters([...context.walls.values()]);
+        miterCache.set(context, miters);
+    }
+    const intervals = new Map();
+    for (const room of rooms)
+        for (const span of room.spans) {
+            if (span.kind !== 'wall')
+                continue;
+            const list = intervals.get(span.boundaryId) ?? [];
+            list.push(span);
+            intervals.set(span.boundaryId, list);
+        }
+    return [...intervals].flatMap(([id, spans]) => {
+        const wall = context?.walls.get(id), polygon = context?.wallFootprints.get(id);
+        if (!(wall && polygon))
+            return [];
+        const merged = [];
+        for (const span of spans.sort((a, b) => a.t0 - b.t0)) {
+            const last = merged.at(-1);
+            if (last && span.t0 <= last.t1 + 1e-8)
+                last.t1 = Math.max(last.t1, span.t1);
+            else
+                merged.push({ t0: span.t0, t1: span.t1 });
+        }
+        const boundary = getWallMiterBoundaryPoints(wall, miters);
+        const dx = wall.end[0] - wall.start[0], dz = wall.end[1] - wall.start[1];
+        const lengthSq = dx * dx + dz * dz;
+        const segments = isCurvedWall(wall) ? 24 : 1;
+        const surface = boundary ? getWallSurfacePolygon(wall, segments, boundary) : [];
+        const lines = [surface.slice(0, segments + 1), surface.slice(segments + 1).reverse()];
+        const faceParameters = (t) => boundary
+            ? lines.map((line) => {
+                const index = Math.min(Math.floor(t * segments), segments - 1);
+                const fraction = t * segments - index;
+                const start = line[index], end = line[index + 1];
+                return (((start.x + (end.x - start.x) * fraction - wall.start[0]) * dx +
+                    (start.y + (end.y - start.y) * fraction - wall.start[1]) * dz) /
+                    lengthSq);
+            })
+            : [t];
+        return merged.map(({ t0, t1 }) => {
+            // Mitered face endpoints can lie beyond the reference segment. Retain the
+            // owned face interval as well as its perpendicular reference-line cut.
+            const stations = [
+                t0,
+                t1,
+                ...Array.from({ length: segments + 1 }, (_, i) => i / segments).filter((t) => t > t0 && t < t1),
+            ];
+            const parameters = stations.flatMap(faceParameters);
+            const from = Math.min(t0, ...parameters);
+            const to = Math.max(t1, ...parameters);
+            return { id, t0: from, t1: to, polygon: clipWallSpan(polygon, wall, from, to) };
+        });
+    });
+}
+const coverageCache = new WeakMap();
+function coversFootprint(plate, footprint) {
+    const cache = coverageCache.get(plate) ?? new WeakMap();
+    const cached = cache.get(footprint);
+    if (cached !== undefined)
+        return cached;
+    try {
+        const covered = area(difference(footprint, plate, { throwOnError: true })) < 1e-6;
+        cache.set(footprint, covered);
+        coverageCache.set(plate, cache);
+        return covered;
+    }
+    catch {
+        return false;
+    }
+}
+function rawWallRectangle(wall) {
+    const a = getWallFaceLine(wall, 'a');
+    const b = getWallFaceLine(wall, 'b');
+    const dx = wall.end[0] - wall.start[0];
+    const dz = wall.end[1] - wall.start[1];
+    const length = Math.hypot(dx, dz);
+    const tx = dx / length;
+    const tz = dz / length;
+    // Two clipping-grid steps keep re-quantized intersections inside the fallback.
+    const padding = 0.0002;
+    return [
+        [a.start.x + padding * (-tx - tz), a.start.y + padding * (-tz + tx)],
+        [b.start.x + padding * (-tx + tz), b.start.y + padding * (-tz - tx)],
+        [b.end.x + padding * (tx + tz), b.end.y + padding * (tz - tx)],
+        [a.end.x + padding * (tx - tz), a.end.y + padding * (tz + tx)],
+    ];
+}
+function recoverWallFootprint(plate, footprint, context) {
+    const wall = context.walls.get(footprint.id);
+    const diagnostic = { levelId: wall?.parentId, wallId: footprint.id };
+    const cleaned = union([footprint.polygon]);
+    if (cleaned.length) {
+        const combined = union([plate, cleaned]);
+        if (combined.length && coversFootprint(combined, footprint.polygon))
+            return combined;
+    }
+    if (wall) {
+        const combined = union([
+            plate,
+            clipWallSpan(rawWallRectangle(wall), wall, footprint.t0, footprint.t1),
+        ]);
+        if (combined.length && coversFootprint(combined, footprint.polygon))
+            return combined;
+        if (combined.length && cleaned.length) {
+            const joined = union([combined, cleaned]);
+            if (joined.length && coversFootprint(joined, footprint.polygon))
+                return joined;
+        }
+    }
+    const padded = union([-0.0002, 0, 0.0002].flatMap((dx) => [-0.0002, 0, 0.0002].map((dz) => footprint.polygon.map(([x, z]) => [x + dx, z + dz]))));
+    const combined = union([plate, padded]);
+    if (combined.length && coversFootprint(combined, footprint.polygon))
+        return combined;
+    throw new Error(`Cannot cover boundary wall ${diagnostic.wallId} on level ${diagnostic.levelId}`);
+}
+export function roomWallFootprints(rooms) {
+    return union(boundaryFootprints(rooms).map(({ polygon }) => polygon));
+}
+export function roomClearPolygon(room) {
+    const cached = clearCache.get(room);
+    if (cached)
+        return cached;
+    const result = difference({ outer: room.polygon, holes: room.holes }, union(boundaryFootprints([room]).map(({ polygon }) => polygon)));
+    clearCache.set(room, result);
+    return result;
+}
+/** Rooms must belong to the same immutable level topology revision. */
+export function plateFootprint(rooms) {
+    const context = rooms[0]?.context;
+    if (!context)
+        return [];
+    if (rooms.some((room) => room.context !== context))
+        throw new Error('Plate rooms must share a level topology revision');
+    const key = JSON.stringify([...new Set(rooms.map((room) => room.id))].sort());
+    const cache = plateCache.get(context) ?? new Map();
+    const cached = cache.get(key);
+    if (cached)
+        return cached;
+    const signature = JSON.stringify([
+        rooms
+            .map(({ id, polygon, holes, spans }) => [id, polygon, holes, spans])
+            .sort((a, b) => String(a[0]).localeCompare(String(b[0]))),
+        [...context.wallFootprints],
+        [...context.walls.values()].map(({ id, start, end, thickness, justification, curveOffset }) => [
+            id,
+            start,
+            end,
+            thickness,
+            justification,
+            curveOffset,
+        ]),
+    ]);
+    const shared = sharedPlateCache.get(signature);
+    if (shared) {
+        cache.set(key, shared);
+        plateCache.set(context, cache);
+        plateContexts.set(shared, context);
+        return shared;
+    }
+    // Only half-edges in closed faces contribute: dangling T-stems are not room boundaries.
+    const faces = rooms.map((room) => ({ outer: room.polygon, holes: room.holes }));
+    const footprints = boundaryFootprints(rooms);
+    let result = union([...faces, ...footprints.map(({ polygon }) => polygon)]);
+    if (!result.length) {
+        // A combined sweep can fail even when both sets union separately. Preserve
+        // the room surface while isolating additions that the clipper cannot handle.
+        result = union(faces);
+        if (!result.length) {
+            result = faces.flatMap((face) => {
+                const cleaned = union([face]);
+                return cleaned.length ? cleaned : [face];
+            });
+        }
+        for (const footprint of footprints) {
+            const combined = union([result, footprint.polygon]);
+            result = combined.length ? combined : recoverWallFootprint(result, footprint, context);
+        }
+    }
+    for (const footprint of footprints) {
+        if (!coversFootprint(result, footprint.polygon))
+            result = recoverWallFootprint(result, footprint, context);
+    }
+    if (result.length > 1) {
+        const rectangles = footprints.flatMap(({ id, t0, t1 }) => {
+            const wall = context.walls.get(id);
+            return wall && !wall.curveOffset ? [clipWallSpan(rawWallRectangle(wall), wall, t0, t1)] : [];
+        });
+        const joined = union([result, ...rectangles]);
+        if (joined.length)
+            result = joined;
+    }
+    // Quantization in a later union can reopen a sliver at an earlier wall.
+    for (let pass = 0; pass < 3; pass++) {
+        const missing = footprints.filter((footprint) => !coversFootprint(result, footprint.polygon));
+        if (!missing.length)
+            break;
+        for (const footprint of missing)
+            result = recoverWallFootprint(result, footprint, context);
+    }
+    if (footprints.some((footprint) => !coversFootprint(result, footprint.polygon))) {
+        // Recover all seams together: repairing one wall at a time can repeatedly
+        // reopen the preceding wall's intersection on the clipping grid.
+        const padded = footprints.flatMap(({ polygon }) => [-0.0002, 0, 0.0002].flatMap((dx) => [-0.0002, 0, 0.0002].map((dz) => polygon.map(([x, z]) => [x + dx, z + dz]))));
+        const covered = union([result, ...padded]);
+        if (covered.length)
+            result = covered;
+    }
+    // Later unions re-quantize earlier intersections; never cache a plate that
+    // lost coverage during a subsequent recovery.
+    for (const footprint of footprints) {
+        if (!coversFootprint(result, footprint.polygon)) {
+            const levelId = context.walls.get(footprint.id)?.parentId;
+            throw new Error(`Cannot cover boundary wall ${footprint.id} on level ${levelId}`);
+        }
+    }
+    sharedPlateCache.set(signature, result);
+    if (sharedPlateCache.size > 64)
+        sharedPlateCache.delete(sharedPlateCache.keys().next().value);
+    plateContexts.set(result, context);
+    cache.set(key, result);
+    plateCache.set(context, cache);
+    return result;
+}
+const exposureCache = new WeakMap();
+const wallExposureCache = new WeakMap();
+const plateEdgeCache = new WeakMap();
+function edges(ring) {
+    return ring.map((start, i) => {
+        const end = ring[(i + 1) % ring.length];
+        return { start, end, dx: end[0] - start[0], dz: end[1] - start[1] };
+    });
+}
+function prepareFootprints(rings) {
+    const polygons = union(rings);
+    return {
+        polygons,
+        edges: polygons.flatMap(({ outer, holes }) => [outer, ...holes].flatMap(edges)),
+    };
+}
+function exposureFootprints(plate, source) {
+    let context;
+    if ('wallFootprints' in source)
+        context = source;
+    else {
+        const candidate = plateContexts.get(plate);
+        if (candidate &&
+            candidate.walls.size === source.length &&
+            source.every((wall) => candidate.walls.get(wall.id) === wall))
+            context = candidate;
+    }
+    if (context) {
+        let prepared = exposureCache.get(context);
+        if (!prepared) {
+            prepared = prepareFootprints([...context.wallFootprints.values()]);
+            exposureCache.set(context, prepared);
+        }
+        return prepared;
+    }
+    const walls = source;
+    const signature = JSON.stringify(walls.map(({ id, start, end, thickness, justification, curveOffset }) => [
+        id,
+        start,
+        end,
+        thickness,
+        justification,
+        curveOffset,
+    ]));
+    const cached = wallExposureCache.get(walls);
+    if (cached?.signature === signature)
+        return cached.prepared;
+    const miters = calculateLevelMiters([...walls]);
+    const prepared = prepareFootprints(walls.map((wall) => getWallPlanFootprint(wall, miters).map(({ x, y }) => [x, y])));
+    wallExposureCache.set(walls, { signature, prepared });
+    return prepared;
+}
+/** Passing a topology context reuses its joined footprints across every plate in that revision. */
+export function exposedIntervals(plate, walls, cover, options) {
+    if (!plate.length)
+        return [];
+    const footprints = cover
+        ? {
+            polygons: cover,
+            edges: cover.flatMap(({ outer, holes }) => [outer, ...holes].flatMap(edges)),
+        }
+        : exposureFootprints(plate, walls);
+    const cuttingEdges = [
+        ...footprints.edges,
+        ...(options?.splitAt ?? []).flatMap(({ outer, holes }) => [outer, ...holes].flatMap(edges)),
+    ];
+    let plateEdges = plateEdgeCache.get(plate);
+    if (!plateEdges) {
+        plateEdges = plate.flatMap(({ outer, holes }, polygonIndex) => [outer, ...holes]
+            .flatMap(edges)
+            .map((edge, edgeIndex) => ({ ...edge, polygonIndex, edgeIndex })));
+        plateEdgeCache.set(plate, plateEdges);
+    }
+    const result = [];
+    for (const { start, dx, dz, polygonIndex, edgeIndex } of plateEdges) {
+        const lengthSq = dx * dx + dz * dz;
+        if (!lengthSq)
+            continue;
+        const at = (t) => [start[0] + t * dx, start[1] + t * dz];
+        const cuts = [0, 1];
+        for (const { start: a, end: b, dx: ex, dz: ez } of cuttingEdges) {
+            const ax = a[0] - start[0], az = a[1] - start[1];
+            const cross = dx * ez - dz * ex;
+            if (Math.abs(cross) < 1e-12) {
+                if (Math.abs(ax * dz - az * dx) < 1e-12) {
+                    for (const p of [a, b])
+                        cuts.push(Math.max(0, Math.min(1, ((p[0] - start[0]) * dx + (p[1] - start[1]) * dz) / lengthSq)));
+                }
+                continue;
+            }
+            const t = (ax * ez - az * ex) / cross;
+            const u = (ax * dz - az * dx) / cross;
+            if (t > 0 && t < 1 && u >= 0 && u <= 1)
+                cuts.push(t);
+        }
+        const ordered = [...new Set(cuts)].sort((a, b) => a - b);
+        for (let i = 0; i < ordered.length - 1; i++) {
+            const t0 = ordered[i], t1 = ordered[i + 1];
+            const covered = containsPoint(footprints.polygons, at((t0 + t1) / 2));
+            if (t1 - t0 <= 1e-12 || (covered && !options?.includeCovered))
+                continue;
+            const previous = result.at(-1);
+            if (previous?.polygonIndex === polygonIndex &&
+                previous.edgeIndex === edgeIndex &&
+                previous.t1 === t0 &&
+                !options?.includeCovered) {
+                previous.t1 = t1;
+                previous.end = at(t1);
+            }
+            else
+                result.push({
+                    polygonIndex,
+                    edgeIndex,
+                    t0,
+                    t1,
+                    start: at(t0),
+                    end: at(t1),
+                    ...(options?.includeCovered ? { covered } : {}),
+                });
+        }
+    }
+    return result;
+}
+export function clearLevelFootprintCaches() {
+    sharedPlateCache.clear();
+}

package/dist/lib/level-name.d.ts

@@ -1,4 +1,11 @@
 import type { LevelNode } from '../schema/index.js';
+/** What an unnamed level is called: Ground floor, Floor 1, Floor 2…, Basement, Basement 2… */
 export declare function getDefaultLevelName(level: number): string;
+/**
+ * The one way a level's name is shown. A name the user gave wins; a level
+ * without one — or still carrying the "Level N" an older build stamped on
+ * every new level — reads by its place in the building. Display only: the
+ * stored name is never rewritten.
+ */
 export declare function getLevelDisplayName(level: Pick<LevelNode, 'name' | 'level'>): string;
 //# sourceMappingURL=level-name.d.ts.map

package/dist/lib/level-name.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"level-name.d.ts","sourceRoot":"","sources":["../../src/lib/level-name.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAE1C,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAIzD;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,MAAM,CAEpF"}
+{"version":3,"file":"level-name.d.ts","sourceRoot":"","sources":["../../src/lib/level-name.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAE1C,8FAA8F;AAC9F,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAIzD;AAED;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,MAAM,CAGpF"}