@pascal-app/core 1.0.0-beta.5 → 1.0.1

package/dist/lib/plan-footprint.js

@@ -0,0 +1,58 @@
+/**
+ * Pure plan (XZ) footprint math — one source for spatial-grid collision and
+ * alignment anchors. The `@pascal-app/core/plan-footprint` subpath is the seam
+ * for a follow-up that consolidates MCP layout clearance onto these helpers.
+ *
+ * ## Invariant
+ * Callers share `planFootprintCorners` / `planFootprintAABB`. Do not invent a
+ * third rotation-aware plan AABB path beside this module.
+ *
+ * ## Gap call-site meanings (for the follow-up overlap helper)
+ * When an expand-then-intersect overlap check lands here, treat `gap` as
+ * **minimum free space** (expand each box by `gap`, then intersect):
+ * - Packing / furnish: typically `gap ≈ 0.08` for breathing room between items
+ * - check / verify collision: use `gap = 0` for true interpenetration only
+ * Do not share one default blindly across both questions.
+ *
+ * ## Scope
+ * Foundation only. Does not move door keep-outs, level ancestry, or furnish
+ * search into core. Item-scaled / attach-aware wrappers stay with callers
+ * until the MCP consolidation follow-up.
+ */
+/**
+ * Four XZ corners of a centred footprint at `position`, rotated by Y
+ * rotation. Matches spatial-grid `getItemFootprint` convention:
+ * local +X maps with (cos, sin), local +Z with (-sin, cos) terms as used
+ * in the existing corner formula.
+ */
+export function planFootprintCorners(position, dimensions, rotationY, inset = 0) {
+    const [x, , z] = position;
+    const [w, , d] = dimensions;
+    const halfW = Math.max(0, w / 2 - inset);
+    const halfD = Math.max(0, d / 2 - inset);
+    const cos = Math.cos(rotationY);
+    const sin = Math.sin(rotationY);
+    return [
+        [x + (-halfW * cos + halfD * sin), z + (-halfW * sin - halfD * cos)],
+        [x + (halfW * cos + halfD * sin), z + (halfW * sin - halfD * cos)],
+        [x + (halfW * cos - halfD * sin), z + (halfW * sin + halfD * cos)],
+        [x + (-halfW * cos - halfD * sin), z + (-halfW * sin + halfD * cos)],
+    ];
+}
+/**
+ * Axis-aligned XZ extent of a footprint. Equivalent to the AABB of
+ * `planFootprintCorners` (no inset) and to spatial-grid `footprintBoundsXZ`.
+ */
+export function planFootprintAABB(position, dimensions, rotationY) {
+    const [width, , depth] = dimensions;
+    const cos = Math.abs(Math.cos(rotationY));
+    const sin = Math.abs(Math.sin(rotationY));
+    const rotatedW = width * cos + depth * sin;
+    const rotatedD = width * sin + depth * cos;
+    return {
+        minX: position[0] - rotatedW / 2,
+        maxX: position[0] + rotatedW / 2,
+        minZ: position[2] - rotatedD / 2,
+        maxZ: position[2] + rotatedD / 2,
+    };
+}

package/dist/lib/polygon-union.d.ts

@@ -0,0 +1,4 @@
+export type Point2D = [number, number];
+export declare function unionPolygons(polygons: Point2D[][]): Point2D[][];
+export declare function subtractPolygonsFromPolygon(subject: Point2D[], cutters: Point2D[][]): Point2D[][];
+//# sourceMappingURL=polygon-union.d.ts.map

package/dist/lib/polygon-union.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polygon-union.d.ts","sourceRoot":"","sources":["../../src/lib/polygon-union.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,OAAO,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AA6TtC,wBAAgB,aAAa,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,GAAG,OAAO,EAAE,EAAE,CAShE;AA4CD,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,GAAG,OAAO,EAAE,EAAE,CAkBjG"}

package/dist/lib/polygon-union.js

@@ -0,0 +1,306 @@
+const EPSILON = 1e-7;
+const KEY_SCALE = 1e6;
+function pointsEqual(a, b, tolerance = EPSILON) {
+    return Math.hypot(a[0] - b[0], a[1] - b[1]) <= tolerance;
+}
+function pointKey(point) {
+    return `${Math.round(point[0] * KEY_SCALE)}:${Math.round(point[1] * KEY_SCALE)}`;
+}
+function interpolate(a, b, t) {
+    return [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];
+}
+function cross(ax, ay, bx, by) {
+    return ax * by - ay * bx;
+}
+function polygonArea(points) {
+    let area = 0;
+    for (let i = 0; i < points.length; i++) {
+        const current = points[i];
+        const next = points[(i + 1) % points.length];
+        area += current[0] * next[1] - next[0] * current[1];
+    }
+    return area / 2;
+}
+function pointOnSegment(point, start, end) {
+    const dx = end[0] - start[0];
+    const dz = end[1] - start[1];
+    const crossValue = cross(point[0] - start[0], point[1] - start[1], dx, dz);
+    if (Math.abs(crossValue) > EPSILON)
+        return false;
+    const dot = (point[0] - start[0]) * (point[0] - end[0]) + (point[1] - start[1]) * (point[1] - end[1]);
+    return dot <= EPSILON;
+}
+function pointInPolygonOrOnBoundary(point, polygon) {
+    if (polygon.some((start, index) => pointOnSegment(point, start, polygon[(index + 1) % polygon.length]))) {
+        return true;
+    }
+    return pointInPolygon(point, polygon);
+}
+function pointInPolygon(point, polygon) {
+    let inside = false;
+    for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+        const pi = polygon[i];
+        const pj = polygon[j];
+        if (pointOnSegment(point, pj, pi))
+            return false;
+        const intersects = pi[1] > point[1] !== pj[1] > point[1] &&
+            point[0] < ((pj[0] - pi[0]) * (point[1] - pi[1])) / (pj[1] - pi[1]) + pi[0];
+        if (intersects)
+            inside = !inside;
+    }
+    return inside;
+}
+function normalizeRing(ring) {
+    const normalized = [];
+    for (const [x, z] of ring) {
+        if (!Number.isFinite(x) || !Number.isFinite(z))
+            continue;
+        const point = [x, z];
+        const previous = normalized[normalized.length - 1];
+        if (!previous || !pointsEqual(previous, point)) {
+            normalized.push(point);
+        }
+    }
+    const first = normalized[0];
+    const last = normalized[normalized.length - 1];
+    if (first && last && pointsEqual(first, last)) {
+        normalized.pop();
+    }
+    if (normalized.length < 3 || Math.abs(polygonArea(normalized)) <= EPSILON)
+        return [];
+    return polygonArea(normalized) < 0 ? [...normalized].reverse() : normalized;
+}
+function addSplit(edge, t) {
+    if (t < -EPSILON || t > 1 + EPSILON)
+        return;
+    const clamped = Math.max(0, Math.min(1, t));
+    if (edge.splits.some((split) => Math.abs(split - clamped) <= EPSILON))
+        return;
+    edge.splits.push(clamped);
+}
+function parameterOnEdge(point, edge) {
+    const dx = edge.end[0] - edge.start[0];
+    const dz = edge.end[1] - edge.start[1];
+    const lengthSquared = dx * dx + dz * dz;
+    if (lengthSquared <= EPSILON)
+        return 0;
+    return ((point[0] - edge.start[0]) * dx + (point[1] - edge.start[1]) * dz) / lengthSquared;
+}
+function addIntersectionSplits(left, right) {
+    const rx = left.end[0] - left.start[0];
+    const rz = left.end[1] - left.start[1];
+    const sx = right.end[0] - right.start[0];
+    const sz = right.end[1] - right.start[1];
+    const qpx = right.start[0] - left.start[0];
+    const qpz = right.start[1] - left.start[1];
+    const denominator = cross(rx, rz, sx, sz);
+    const numerator = cross(qpx, qpz, rx, rz);
+    if (Math.abs(denominator) <= EPSILON) {
+        if (Math.abs(numerator) > EPSILON)
+            return;
+        for (const point of [left.start, left.end, right.start, right.end]) {
+            if (pointOnSegment(point, left.start, left.end) &&
+                pointOnSegment(point, right.start, right.end)) {
+                addSplit(left, parameterOnEdge(point, left));
+                addSplit(right, parameterOnEdge(point, right));
+            }
+        }
+        return;
+    }
+    const t = cross(qpx, qpz, sx, sz) / denominator;
+    const u = cross(qpx, qpz, rx, rz) / denominator;
+    if (t < -EPSILON || t > 1 + EPSILON || u < -EPSILON || u > 1 + EPSILON)
+        return;
+    addSplit(left, t);
+    addSplit(right, u);
+}
+function buildEdges(polygons) {
+    const edges = [];
+    polygons.forEach((polygon, polygonIndex) => {
+        for (let i = 0; i < polygon.length; i++) {
+            edges.push({
+                start: polygon[i],
+                end: polygon[(i + 1) % polygon.length],
+                polygonIndex,
+                splits: [0, 1],
+            });
+        }
+    });
+    for (let i = 0; i < edges.length; i++) {
+        for (let j = i + 1; j < edges.length; j++) {
+            const left = edges[i];
+            const right = edges[j];
+            if (left.polygonIndex === right.polygonIndex)
+                continue;
+            addIntersectionSplits(left, right);
+        }
+    }
+    return edges;
+}
+function buildBoundarySegments(edges, polygons) {
+    const segments = [];
+    for (const edge of edges) {
+        const splits = [...edge.splits].sort((a, b) => a - b);
+        for (let i = 0; i < splits.length - 1; i++) {
+            const startT = splits[i];
+            const endT = splits[i + 1];
+            if (endT - startT <= EPSILON)
+                continue;
+            const start = interpolate(edge.start, edge.end, startT);
+            const end = interpolate(edge.start, edge.end, endT);
+            const mid = interpolate(edge.start, edge.end, (startT + endT) / 2);
+            const insideAnother = polygons.some((polygon, index) => index !== edge.polygonIndex && pointInPolygon(mid, polygon));
+            if (!insideAnother) {
+                segments.push({ start, end, used: false });
+            }
+        }
+    }
+    return removeDuplicateInteriorSegments(segments);
+}
+function segmentKey(segment) {
+    const start = pointKey(segment.start);
+    const end = pointKey(segment.end);
+    return start < end ? `${start}|${end}` : `${end}|${start}`;
+}
+function removeDuplicateInteriorSegments(segments) {
+    const groups = new Map();
+    for (const segment of segments) {
+        const key = segmentKey(segment);
+        const group = groups.get(key);
+        if (group) {
+            group.push(segment);
+        }
+        else {
+            groups.set(key, [segment]);
+        }
+    }
+    const result = [];
+    for (const group of groups.values()) {
+        if (group.length === 1) {
+            result.push(group[0]);
+            continue;
+        }
+        const firstStart = pointKey(group[0].start);
+        const firstEnd = pointKey(group[0].end);
+        const hasOppositeDirection = group.some((segment) => pointKey(segment.start) === firstEnd && pointKey(segment.end) === firstStart);
+        if (!hasOppositeDirection) {
+            result.push(group[0]);
+        }
+    }
+    return result;
+}
+function assembleRings(segments) {
+    const byStart = new Map();
+    for (const segment of segments) {
+        const key = pointKey(segment.start);
+        const group = byStart.get(key);
+        if (group) {
+            group.push(segment);
+        }
+        else {
+            byStart.set(key, [segment]);
+        }
+    }
+    const rings = [];
+    const nextBoundarySegment = (ring, candidates) => {
+        const previous = ring[ring.length - 2];
+        const current = ring[ring.length - 1];
+        const incomingX = current[0] - previous[0];
+        const incomingZ = current[1] - previous[1];
+        const reverseIncomingAngle = Math.atan2(-incomingZ, -incomingX);
+        const clockwiseTurn = (segment) => {
+            const outgoingAngle = Math.atan2(segment.end[1] - current[1], segment.end[0] - current[0]);
+            const turn = reverseIncomingAngle - outgoingAngle;
+            return ((turn % (Math.PI * 2)) + Math.PI * 2) % (Math.PI * 2);
+        };
+        return [...candidates].sort((left, right) => {
+            return (clockwiseTurn(left) - clockwiseTurn(right) ||
+                pointKey(left.end).localeCompare(pointKey(right.end)));
+        })[0];
+    };
+    for (const firstSegment of segments) {
+        if (firstSegment.used)
+            continue;
+        firstSegment.used = true;
+        const ring = [firstSegment.start, firstSegment.end];
+        const startKey = pointKey(firstSegment.start);
+        let currentKey = pointKey(firstSegment.end);
+        while (currentKey !== startKey) {
+            const candidates = byStart.get(currentKey)?.filter((segment) => !segment.used) ?? [];
+            const next = nextBoundarySegment(ring, candidates);
+            if (!next)
+                break;
+            next.used = true;
+            ring.push(next.end);
+            currentKey = pointKey(next.end);
+        }
+        if (currentKey !== startKey)
+            continue;
+        const last = ring[ring.length - 1];
+        if (last && pointsEqual(ring[0], last)) {
+            ring.pop();
+        }
+        const normalized = normalizeRing(ring);
+        if (normalized.length >= 3) {
+            rings.push(normalized);
+        }
+    }
+    return rings;
+}
+export function unionPolygons(polygons) {
+    const validPolygons = polygons.map(normalizeRing).filter((polygon) => polygon.length >= 3);
+    if (validPolygons.length <= 1)
+        return validPolygons;
+    const edges = buildEdges(validPolygons);
+    const segments = buildBoundarySegments(edges, validPolygons);
+    const rings = assembleRings(segments);
+    return rings.length > 0 ? rings : validPolygons;
+}
+function buildDifferenceBoundarySegments(edges, polygons) {
+    const subject = polygons[0];
+    const cutters = polygons.slice(1);
+    if (!subject)
+        return [];
+    const segments = [];
+    for (const edge of edges) {
+        const splits = [...edge.splits].sort((a, b) => a - b);
+        for (let i = 0; i < splits.length - 1; i++) {
+            const startT = splits[i];
+            const endT = splits[i + 1];
+            if (endT - startT <= EPSILON)
+                continue;
+            const start = interpolate(edge.start, edge.end, startT);
+            const end = interpolate(edge.start, edge.end, endT);
+            const mid = interpolate(edge.start, edge.end, (startT + endT) / 2);
+            if (edge.polygonIndex === 0) {
+                const insideCutter = cutters.some((cutter) => pointInPolygonOrOnBoundary(mid, cutter));
+                if (!insideCutter) {
+                    segments.push({ start, end, used: false });
+                }
+                continue;
+            }
+            const insideSubject = pointInPolygon(mid, subject);
+            const insideAnotherCutter = cutters.some((cutter, cutterIndex) => cutterIndex !== edge.polygonIndex - 1 && pointInPolygonOrOnBoundary(mid, cutter));
+            if (insideSubject && !insideAnotherCutter) {
+                segments.push({ start: end, end: start, used: false });
+            }
+        }
+    }
+    return removeDuplicateInteriorSegments(segments);
+}
+export function subtractPolygonsFromPolygon(subject, cutters) {
+    const validSubject = normalizeRing(subject);
+    if (validSubject.length < 3)
+        return [];
+    const validCutters = cutters.map(normalizeRing).filter((polygon) => polygon.length >= 3);
+    if (validCutters.length === 0)
+        return [validSubject];
+    const polygons = [validSubject, ...validCutters];
+    const edges = buildEdges(polygons);
+    const segments = buildDifferenceBoundarySegments(edges, polygons);
+    const rings = assembleRings(segments);
+    if (rings.length > 0)
+        return rings;
+    const fullyCovered = validSubject.every((point) => validCutters.some((cutter) => pointInPolygonOrOnBoundary(point, cutter)));
+    return fullyCovered ? [] : [validSubject];
+}

package/dist/lib/roof-overlap.d.ts

@@ -0,0 +1,32 @@
+export type RoofOverlapEntry = {
+    roofId: string;
+    segmentId: string;
+    supportRoofId?: string;
+    supportRoofSegmentId?: string;
+    roofType?: string;
+    width: number;
+    depth: number;
+};
+export type RoofPlanBounds = {
+    minX: number;
+    minZ: number;
+    maxX: number;
+    maxZ: number;
+};
+export type RoofPlanSegment = {
+    position: readonly [number, number, number];
+    rotation?: number;
+    width: number;
+    depth: number;
+};
+export type RoofPlan = {
+    position: readonly [number, number, number];
+    rotation?: number;
+    segments: readonly RoofPlanSegment[];
+};
+export declare function compareRoofOverlapIdentity(a: RoofOverlapEntry, b: RoofOverlapEntry): number;
+export declare function roofOverlapEntryOwns(candidate: RoofOverlapEntry, current: RoofOverlapEntry, epsilon?: number): boolean;
+export declare function roofPlanOverlapEntryOwns(candidate: RoofOverlapEntry, current: RoofOverlapEntry, epsilon?: number): boolean;
+export declare function getRoofPlanBounds(roof: RoofPlan): RoofPlanBounds | null;
+export declare function roofPlanBoundsOverlap(a: RoofPlanBounds, b: RoofPlanBounds, epsilon?: number): boolean;
+//# sourceMappingURL=roof-overlap.d.ts.map

package/dist/lib/roof-overlap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roof-overlap.d.ts","sourceRoot":"","sources":["../../src/lib/roof-overlap.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,MAAM,CAAA;IACjB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,oBAAoB,CAAC,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC3C,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG;IACrB,QAAQ,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC3C,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,SAAS,eAAe,EAAE,CAAA;CACrC,CAAA;AAED,wBAAgB,0BAA0B,CAAC,CAAC,EAAE,gBAAgB,EAAE,CAAC,EAAE,gBAAgB,GAAG,MAAM,CAG3F;AAED,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,gBAAgB,EAC3B,OAAO,EAAE,gBAAgB,EACzB,OAAO,SAAO,GACb,OAAO,CAiBT;AAED,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,gBAAgB,EAC3B,OAAO,EAAE,gBAAgB,EACzB,OAAO,SAAO,GACb,OAAO,CAYT;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,GAAG,cAAc,GAAG,IAAI,CAmCvE;AAED,wBAAgB,qBAAqB,CACnC,CAAC,EAAE,cAAc,EACjB,CAAC,EAAE,cAAc,EACjB,OAAO,SAAO,GACb,OAAO,CAOT"}

package/dist/lib/roof-overlap.js

@@ -0,0 +1,72 @@
+export function compareRoofOverlapIdentity(a, b) {
+    const roofOrder = a.roofId.localeCompare(b.roofId);
+    return roofOrder !== 0 ? roofOrder : a.segmentId.localeCompare(b.segmentId);
+}
+export function roofOverlapEntryOwns(candidate, current, epsilon = 1e-6) {
+    const candidateIsMountedOnCurrent = candidate.supportRoofId === current.roofId ||
+        candidate.supportRoofSegmentId === current.segmentId;
+    if (candidateIsMountedOnCurrent)
+        return false;
+    const currentIsMountedOnCandidate = current.supportRoofId === candidate.roofId ||
+        current.supportRoofSegmentId === candidate.segmentId;
+    if (currentIsMountedOnCandidate)
+        return true;
+    const candidateArea = candidate.width * candidate.depth;
+    const currentArea = current.width * current.depth;
+    return (candidateArea > currentArea + epsilon ||
+        (Math.abs(candidateArea - currentArea) <= epsilon &&
+            compareRoofOverlapIdentity(candidate, current) < 0));
+}
+export function roofPlanOverlapEntryOwns(candidate, current, epsilon = 1e-6) {
+    const candidateIsMountedOnCurrent = candidate.supportRoofId === current.roofId ||
+        candidate.supportRoofSegmentId === current.segmentId;
+    if (candidateIsMountedOnCurrent)
+        return true;
+    const currentIsMountedOnCandidate = current.supportRoofId === candidate.roofId ||
+        current.supportRoofSegmentId === candidate.segmentId;
+    if (currentIsMountedOnCandidate)
+        return false;
+    return roofOverlapEntryOwns(candidate, current, epsilon);
+}
+export function getRoofPlanBounds(roof) {
+    if (roof.segments.length === 0)
+        return null;
+    const roofRotation = roof.rotation ?? 0;
+    const roofCos = Math.cos(roofRotation);
+    const roofSin = Math.sin(roofRotation);
+    const bounds = {
+        minX: Number.POSITIVE_INFINITY,
+        minZ: Number.POSITIVE_INFINITY,
+        maxX: Number.NEGATIVE_INFINITY,
+        maxZ: Number.NEGATIVE_INFINITY,
+    };
+    for (const segment of roof.segments) {
+        const segmentRotation = segment.rotation ?? 0;
+        const segmentCos = Math.cos(segmentRotation);
+        const segmentSin = Math.sin(segmentRotation);
+        const halfWidth = Math.max(0, segment.width) / 2;
+        const halfDepth = Math.max(0, segment.depth) / 2;
+        for (const [x, z] of [
+            [-halfWidth, -halfDepth],
+            [halfWidth, -halfDepth],
+            [halfWidth, halfDepth],
+            [-halfWidth, halfDepth],
+        ]) {
+            const roofX = segment.position[0] + x * segmentCos + z * segmentSin;
+            const roofZ = segment.position[2] - x * segmentSin + z * segmentCos;
+            const worldX = roof.position[0] + roofX * roofCos + roofZ * roofSin;
+            const worldZ = roof.position[2] - roofX * roofSin + roofZ * roofCos;
+            bounds.minX = Math.min(bounds.minX, worldX);
+            bounds.minZ = Math.min(bounds.minZ, worldZ);
+            bounds.maxX = Math.max(bounds.maxX, worldX);
+            bounds.maxZ = Math.max(bounds.maxZ, worldZ);
+        }
+    }
+    return bounds;
+}
+export function roofPlanBoundsOverlap(a, b, epsilon = 1e-6) {
+    return !(a.maxX < b.minX - epsilon ||
+        b.maxX < a.minX - epsilon ||
+        a.maxZ < b.minZ - epsilon ||
+        b.maxZ < a.minZ - epsilon);
+}

package/dist/lib/room-topology-index.d.ts

@@ -1,4 +1,4 @@
-import type { WallNode } from '../schema';
+import type { WallNode } from '../schema/index.js';
 type SceneNodes = Record<string, any>;
 type Point = [number, number];
 type IndexedRoom = {

package/dist/lib/room-topology-index.js

@@ -1,4 +1,4 @@
-import { getClampedWallCurveOffset } from '../systems/wall/wall-curve';
+import { getClampedWallCurveOffset } from '../systems/wall/wall-curve.js';
 const CELL_SIZE = 2;
 function bboxOf(points) {
     let minX = Number.POSITIVE_INFINITY;

package/dist/lib/selection-proxy.d.ts

@@ -1,4 +1,4 @@
-import type { AnyNode, AnyNodeId } from '../schema/types';
+import type { AnyNode, AnyNodeId } from '../schema/types.js';
 export declare function selectionProxyIdFromMetadata(metadata: unknown): AnyNodeId | null;
 export declare function resolveSelectionProxyId(node: AnyNode, nodes: Readonly<Record<string, AnyNode | undefined>>): AnyNodeId;
 //# sourceMappingURL=selection-proxy.d.ts.map

package/dist/lib/slab-polygon.d.ts

@@ -1,18 +1,36 @@
-import type { GeometryContext } from '../registry/types';
-import type { SlabNode, WallNode } from '../schema';
+import type { GeometryContext } from '../registry/types.js';
+import type { AnyNode, AnyNodeId, SlabNode, WallNode } from '../schema/index.js';
 export type SlabPolygonContext = {
     /** Walls on the slab's level. */
     walls: WallNode[];
     /** Other slabs on the same level — the slab itself must be excluded. */
     siblingSlabs: SlabNode[];
 };
+/** [ax, az, bx, bz] segment in plan space. */
+type Segment = [number, number, number, number];
+/** A sibling slab edge and the direction of its polygon interior. */
+type NeighborSegment = {
+    slab: SlabNode;
+    segment: Segment;
+    bounds: Bounds;
+    elevation: number;
+    /** Unit normal pointing into the sibling polygon at this edge. */
+    inwardX: number;
+    inwardZ: number;
+};
 /**
  * Derive a {@link SlabPolygonContext} from a registry `GeometryContext`:
  * sibling slabs come from `ctx.siblings` (same kind, same parent, self
  * excluded) and walls from the parent level's children.
  */
 export declare function slabPolygonContextFromGeometry(ctx: GeometryContext | undefined): SlabPolygonContext;
-export declare function getRenderableSlabPolygon(slabNode: SlabNode, context: SlabPolygonContext): Array<[number, number]>;
+export declare function slabPolygonContextForLevel(parent: AnyNode | null, resolve: (id: AnyNodeId) => AnyNode | undefined, fallbackSlabs?: SlabNode[]): SlabPolygonContext;
+export declare function getRenderableSlabPolygon(slabNode: SlabNode, context: SlabPolygonContext | PreparedSlabPolygonContext): Array<[number, number]>;
+type WallCandidate = {
+    wall: WallNode;
+    segments: Segment[];
+    halfThickness: number;
+};
 export type SlabEdgeWallBandSnap = {
     wallId: WallNode['id'];
     /** The candidate edge translated perpendicular onto the wall centerline. */
@@ -29,4 +47,19 @@ export type SlabEdgeWallBandSnap = {
 export declare function snapSlabEdgeToWallBand(a: [number, number], b: [number, number], walls: readonly WallNode[], options?: {
     maxLateral?: number;
 }): SlabEdgeWallBandSnap | null;
+type Bounds = [number, number, number, number];
+export declare function scopeSlabPolygonContext(slab: SlabNode, context: PreparedSlabPolygonContext): PreparedSlabPolygonContext;
+export declare function slabPolygonContextChanges(before: PreparedSlabPolygonContext, after: PreparedSlabPolygonContext): (slab: SlabNode) => boolean;
+type PreparedWallCandidate = WallCandidate & {
+    bounds: Bounds;
+};
+type PreparedSlabPolygonContext = SlabPolygonContext & {
+    wallCache: WeakMap<WallNode, PreparedWallCandidate>;
+    neighborCache: WeakMap<SlabNode, NeighborSegment[]>;
+    wallCandidates: PreparedWallCandidate[];
+    neighborSegments: NeighborSegment[];
+    siblingBreakTolerance: number;
+};
+export declare function prepareSlabPolygonContext(context: SlabPolygonContext, previous?: PreparedSlabPolygonContext): PreparedSlabPolygonContext;
+export {};
 //# sourceMappingURL=slab-polygon.d.ts.map

package/dist/lib/slab-polygon.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"slab-polygon.d.ts","sourceRoot":"","sources":["../../src/lib/slab-polygon.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACxD,OAAO,KAAK,EAAa,QAAQ,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAwG9D,MAAM,MAAM,kBAAkB,GAAG;IAC/B,iCAAiC;IACjC,KAAK,EAAE,QAAQ,EAAE,CAAA;IACjB,wEAAwE;IACxE,YAAY,EAAE,QAAQ,EAAE,CAAA;CACzB,CAAA;AAuBD;;;;GAIG;AACH,wBAAgB,8BAA8B,CAC5C,GAAG,EAAE,eAAe,GAAG,SAAS,GAC/B,kBAAkB,CAmBpB;AAED,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,kBAAkB,GAC1B,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAgBzB;AAuID,MAAM,MAAM,oBAAoB,GAAG;IACjC,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;IACtB,4EAA4E;IAC5E,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;CAC3C,CAAA;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACpC,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EACnB,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EACnB,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,OAAO,CAAC,EAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,GAChC,oBAAoB,GAAG,IAAI,CA4B7B"}
+{"version":3,"file":"slab-polygon.d.ts","sourceRoot":"","sources":["../../src/lib/slab-polygon.ts"],"names":[],"mappings":"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"}