@pascal-app/core 1.0.1 → 1.0.4

package/dist/systems/stair/stair-opening-preview.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stair-opening-preview.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-opening-preview.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAC7E,OAA6B,EAAE,KAAK,iBAAiB,EAAE,MAAM,qCAAqC,CAAA;AAClG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAA;AAGpE,KAAK,oBAAoB,GAAG;IAC1B,EAAE,EAAE,SAAS,CAAA;IACb,IAAI,EAAE,OAAO,CAAC,QAAQ,GAAG,WAAW,CAAC,CAAA;CACtC,CAAA;AAoBD,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,EAClD,aAAa,EAAE,WAAW,CAAC,MAAM,EAAE,iBAAiB,CAAC,EACrD,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAAC,WAYvC;AAED,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,EAClD,aAAa,EAAE,WAAW,CAAC,MAAM,EAAE,iBAAiB,CAAC,EACrD,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwBvC;AAED,wBAAgB,qCAAqC;;mBAUlC,oBAAoB,EAAE;;EAiCxC"}
+{"version":3,"file":"stair-opening-preview.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-opening-preview.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAC7E,OAA6B,EAAE,KAAK,iBAAiB,EAAE,MAAM,qCAAqC,CAAA;AAClG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAA;AAGpE,KAAK,oBAAoB,GAAG;IAC1B,EAAE,EAAE,SAAS,CAAA;IACb,IAAI,EAAE,OAAO,CAAC,QAAQ,GAAG,WAAW,CAAC,CAAA;CACtC,CAAA;AAoBD,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,EAClD,aAAa,EAAE,WAAW,CAAC,MAAM,EAAE,iBAAiB,CAAC,EACrD,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAAC,WAYvC;AAED,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,EAClD,aAAa,EAAE,WAAW,CAAC,MAAM,EAAE,iBAAiB,CAAC,EACrD,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwBvC;AAED,wBAAgB,qCAAqC;;mBAUlC,oBAAoB,EAAE;;EAiCxC"}

package/dist/systems/stair/stair-opening-sync.d.ts

@@ -1,6 +1,12 @@
-import type { AnyNode, AnyNodeId, CeilingNode, SlabNode } from '../../schema/index.js';
-export declare function syncAutoStairOpenings(nodes: Record<string, AnyNode>): {
+import type { AnyNode, AnyNodeId, CeilingNode, SlabNode, StairNode } from '../../schema/index.js';
+/** Existing cuts are user data: only an edit to the stair itself or the levels it spans re-cuts them. */
+export declare function changedStairOpeningOwners(before: Record<string, AnyNode>, after: Record<string, AnyNode>): Set<string>;
+declare function getStairOpeningPolygons(stair: StairNode, nodes: Record<string, AnyNode>, targetElevation: number, openingOffset: number, thickness: number): import("../../index.js").Ring[] | null;
+type OpeningResolver = typeof getStairOpeningPolygons;
+/** A load migration supplies its historical resolver; live edits use clearance geometry. */
+export declare function syncAutoStairOpenings(nodes: Record<string, AnyNode>, resolveOpening?: OpeningResolver): {
     id: AnyNodeId;
     data: Partial<SlabNode | CeilingNode>;
 }[];
+export {};
 //# sourceMappingURL=stair-opening-sync.d.ts.map

package/dist/systems/stair/stair-opening-sync.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stair-opening-sync.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-opening-sync.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EACT,WAAW,EACX,QAAQ,EAIT,MAAM,cAAc,CAAA;AA8qBrB,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;QAQvC,SAAS;UAAQ,OAAO,CAAC,QAAQ,GAAG,WAAW,CAAC;IAqG5E"}
+{"version":3,"file":"stair-opening-sync.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-opening-sync.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EACT,WAAW,EACX,QAAQ,EACR,SAAS,EAEV,MAAM,cAAc,CAAA;AAiLrB,yGAAyG;AACzG,wBAAgB,yBAAyB,CACvC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,GAAG,CAAC,MAAM,CAAC,CA6Cb;AAQD,iBAAS,uBAAuB,CAC9B,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,eAAe,EAAE,MAAM,EACvB,aAAa,EAAE,MAAM,EACrB,SAAS,EAAE,MAAM,iCASlB;AAED,KAAK,eAAe,GAAG,OAAO,uBAAuB,CAAA;AA2HrD,4FAA4F;AAC5F,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,cAAc,GAAE,eAAyC;QAS9B,SAAS;UAAQ,OAAO,CAAC,QAAQ,GAAG,WAAW,CAAC;IA4I5E"}

package/dist/systems/stair/stair-opening-sync.js

@@ -1,15 +1,12 @@
-import { resolveBuildingForLevel, resolveLevelId } from '../../hooks/spatial-grid/spatial-grid-sync.js';
+import { resolveBuildingForLevel, resolveLevelId } from '../../lib/node-ancestry.js';
+import { area, difference, union } from '../../lib/polygon-boolean.js';
 import { polygonContainsPolygon, polygonsOverlap } from '../../lib/polygon-relations.js';
 import { resolveCeilingHeight } from '../../services/level-height.js';
 import { getLevelElevations } from '../../services/storey.js';
-import { computeSegmentTransforms, rotateXZ } from './stair-footprint.js';
-import { resolveStairTotalRise } from './stair-rise.js';
-const CURVED_STAIR_SLAB_OPENING_RATIO = 0.8;
-const STRAIGHT_STAIR_TARGET_THRESHOLD_MIN = 0.35;
-const STAIR_SLAB_OPENING_TIGHTENING = 0;
-function clamp(value, min, max) {
-    return Math.min(max, Math.max(min, value));
-}
+import { stairClearanceOpening } from './stair-clearance.js';
+import { resolveStairTotalRise } from './stair-rise-query.js';
+const buildingLevelsMemo = new WeakMap();
+const stairLevelsMemo = new WeakMap();
 function pointsEqual(a, b, tolerance = 1e-5) {
     const dx = a[0] - b[0];
     const dz = a[1] - b[1];
@@ -35,17 +32,15 @@ function metadataEqual(left, right) {
         return false;
     return left.every((entry, index) => entry.source === right[index]?.source &&
         (entry.elevatorId ?? null) === (right[index]?.elevatorId ?? null) &&
-        (entry.stairId ?? null) === (right[index]?.stairId ?? null));
+        (entry.stairId ?? null) === (right[index]?.stairId ?? null) &&
+        (entry.openingId ?? null) === (right[index]?.openingId ?? null));
 }
 function normalizeExistingMetadata(holes, metadata) {
     return holes.map((_, index) => metadata?.[index] ?? { source: 'manual' });
 }
-// (Removing expandPolygonRadially in favor of geometric expansion inside the polygon generators)
-// `rotateXZ` + `computeSegmentTransforms` are shared with the alignment-anchor
-// footprint via `./stair-footprint` so both derive the chain identically.
 function getLevelNumber(levelId, nodes) {
     if (!levelId)
-        return undefined;
+        return;
     const node = nodes[levelId];
     return node?.type === 'level' ? node.level : undefined;
 }
@@ -63,6 +58,14 @@ function getBuildingLevels(buildingId, nodes) {
     const building = buildingId ? nodes[buildingId] : null;
     if (building?.type !== 'building')
         return [];
+    let cache = buildingLevelsMemo.get(nodes);
+    if (!cache) {
+        cache = new Map();
+        buildingLevelsMemo.set(nodes, cache);
+    }
+    const cached = cache.get(building.id);
+    if (cached)
+        return cached;
     const levels = new Map();
     for (const childId of building.children ?? []) {
         const child = nodes[childId];
@@ -74,7 +77,9 @@ function getBuildingLevels(buildingId, nodes) {
             levels.set(candidate.id, candidate);
         }
     }
-    return Array.from(levels.values()).sort((left, right) => left.level - right.level);
+    const sorted = Array.from(levels.values()).sort((left, right) => left.level - right.level);
+    cache.set(building.id, sorted);
+    return sorted;
 }
 function inferSourceLevelForDestination(destinationLevelId, nodes) {
     if (!destinationLevelId)
@@ -117,6 +122,14 @@ function isInStairBuildingScope(stair, surfaceLevelId, nodes) {
     return true;
 }
 function getResolvedStairLevelIds(stair, nodes) {
+    let cache = stairLevelsMemo.get(nodes);
+    if (!cache) {
+        cache = new WeakMap();
+        stairLevelsMemo.set(nodes, cache);
+    }
+    const cached = cache.get(stair);
+    if (cached)
+        return cached;
     const parentLevelId = normalizeLevelId(resolveLevelId(stair, nodes), nodes);
     const explicitToLevelId = normalizeLevelId(stair.toLevelId, nodes);
     const fromLevelId = normalizeLevelId(stair.fromLevelId, nodes) ??
@@ -128,295 +141,76 @@ function getResolvedStairLevelIds(stair, nodes) {
     const toLevelId = explicitToLevelIsUsable
         ? explicitToLevelId
         : inferDestinationLevelForSource(fromLevelId, nodes);
-    return { fromLevelId, toLevelId };
-}
-function resolveStraightSegments(stair, nodes) {
-    return (stair.children ?? [])
-        .map((childId) => nodes[childId])
-        .filter((segment) => segment?.type === 'stair-segment' && segment.visible !== false);
-}
-function toWorldPlanPoint(stair, localX, localZ) {
-    const [worldX, worldZ] = rotateXZ(localX, localZ, stair.rotation ?? 0);
-    return [stair.position[0] + worldX, stair.position[2] + worldZ];
-}
-function getStraightStairLayouts(stair, nodes) {
-    const segments = resolveStraightSegments(stair, nodes);
-    const transforms = computeSegmentTransforms(segments);
-    return segments.map((segment, index) => {
-        const transform = transforms[index] ?? {
-            position: [0, 0, 0],
-            rotation: 0,
-        };
-        return {
-            segment,
-            transform,
-            topElevation: transform.position[1] + (segment.segmentType === 'stair' ? segment.height : 0),
-        };
-    });
-}
-function getStraightSegmentFootprintPolygon(stair, layout) {
-    return getStraightSegmentSlicePolygon(stair, layout, 0, layout.segment.length);
-}
-function getStraightSegmentLocalSlicePolygon(layout, startAlong, endAlong) {
-    const { segment, transform } = layout;
-    const clampedStart = clamp(startAlong, 0, segment.length);
-    const clampedEnd = clamp(endAlong, clampedStart, segment.length);
-    const sliceLength = Math.max(clampedEnd - clampedStart, 1e-4);
-    const sliceCenterAlong = clampedStart + sliceLength / 2;
-    const [centerOffsetX, centerOffsetZ] = rotateXZ(0, sliceCenterAlong, transform.rotation);
-    const centerX = transform.position[0] + centerOffsetX;
-    const centerZ = transform.position[2] + centerOffsetZ;
-    const halfWidth = segment.width / 2;
-    const halfLength = sliceLength / 2;
-    const corners = [
-        [-halfWidth, -halfLength],
-        [halfWidth, -halfLength],
-        [halfWidth, halfLength],
-        [-halfWidth, halfLength],
-    ];
-    return corners.map(([localWidth, localLength]) => {
-        const [offsetX, offsetZ] = rotateXZ(localWidth, localLength, transform.rotation);
-        return [centerX + offsetX, centerZ + offsetZ];
-    });
-}
-function getStraightSegmentSlicePolygon(stair, layout, startAlong, endAlong) {
-    return getStraightSegmentLocalSlicePolygon(layout, startAlong, endAlong).map(([x, z]) => toWorldPlanPoint(stair, x, z));
-}
-function getStraightFlightOpeningDepth(stair, segment) {
-    const treadDepth = Math.max(0.2, segment.length / Math.max(segment.stepCount || stair.stepCount || 10, 1));
-    return Math.min(segment.length, Math.max(treadDepth * 10, segment.length * 0.8, 3.0));
-}
-function polygonArea(points) {
-    let area = 0;
-    for (let index = 0; index < points.length; index += 1) {
-        const current = points[index];
-        const next = points[(index + 1) % points.length];
-        if (!(current && next))
-            continue;
-        area += current[0] * next[1] - next[0] * current[1];
-    }
-    return area / 2;
-}
-function isCoveredByExistingHole(existingHoles, autoHole) {
-    return existingHoles.some((existingHole) => polygonContainsPolygon(existingHole, autoHole));
-}
-function getAxisAlignedRectFromPolygon(polygon) {
-    if (polygon.length < 4)
-        return null;
-    const xs = polygon.map(([x]) => x);
-    const zs = polygon.map(([, z]) => z);
-    const minX = Math.min(...xs);
-    const maxX = Math.max(...xs);
-    const minZ = Math.min(...zs);
-    const maxZ = Math.max(...zs);
-    if (!(maxX > minX && maxZ > minZ))
-        return null;
-    return { minX, maxX, minZ, maxZ };
-}
-function expandRect(rect, offset) {
-    if (offset <= 1e-6) {
-        return rect;
-    }
-    return {
-        minX: rect.minX - offset,
-        maxX: rect.maxX + offset,
-        minZ: rect.minZ - offset,
-        maxZ: rect.maxZ + offset,
+    const resolved = { fromLevelId, toLevelId };
+    cache.set(stair, resolved);
+    return resolved;
+}
+/** Existing cuts are user data: only an edit to the stair itself or the levels it spans re-cuts them. */
+export function changedStairOpeningOwners(before, after) {
+    const owners = new Set();
+    const beforeElevations = getLevelElevations(before);
+    const afterElevations = getLevelElevations(after);
+    const span = (stair, nodes, elevations) => {
+        const { fromLevelId, toLevelId } = getResolvedStairLevelIds(stair, nodes);
+        const from = elevations.get(fromLevelId ?? '');
+        const to = elevations.get(toLevelId ?? '');
+        return JSON.stringify([
+            fromLevelId,
+            toLevelId,
+            from?.height,
+            to?.height,
+            from && to
+                ? [...elevations]
+                    .filter(([, level]) => level.buildingId === from.buildingId &&
+                    level.ordinal >= Math.min(from.ordinal, to.ordinal) &&
+                    level.ordinal <= Math.max(from.ordinal, to.ordinal))
+                    .map(([id, level]) => [id, level.height, level.baseY - from.baseY])
+                : null,
+        ]);
     };
-}
-function buildUnionPolygonsFromRects(rects) {
-    if (rects.length === 0)
-        return [];
-    const xs = Array.from(new Set(rects.flatMap((rect) => [rect.minX, rect.maxX]).map((value) => Number(value.toFixed(6))))).sort((a, b) => a - b);
-    const zs = Array.from(new Set(rects.flatMap((rect) => [rect.minZ, rect.maxZ]).map((value) => Number(value.toFixed(6))))).sort((a, b) => a - b);
-    if (xs.length < 2 || zs.length < 2)
-        return [];
-    const occupied = new Set();
-    for (let xi = 0; xi < xs.length - 1; xi += 1) {
-        for (let zi = 0; zi < zs.length - 1; zi += 1) {
-            const cx = (xs[xi] + xs[xi + 1]) / 2;
-            const cz = (zs[zi] + zs[zi + 1]) / 2;
-            if (rects.some((rect) => cx > rect.minX && cx < rect.maxX && cz > rect.minZ && cz < rect.maxZ)) {
-                occupied.add(`${xi}:${zi}`);
-            }
-        }
-    }
-    const edgeMap = new Map();
-    const addEdge = (start, end) => {
-        edgeMap.set(`${start[0]},${start[1]}`, end);
-    };
-    for (let xi = 0; xi < xs.length - 1; xi += 1) {
-        for (let zi = 0; zi < zs.length - 1; zi += 1) {
-            if (!occupied.has(`${xi}:${zi}`))
-                continue;
-            const x0 = xs[xi];
-            const x1 = xs[xi + 1];
-            const z0 = zs[zi];
-            const z1 = zs[zi + 1];
-            if (!occupied.has(`${xi}:${zi - 1}`))
-                addEdge([x0, z0], [x1, z0]);
-            if (!occupied.has(`${xi + 1}:${zi}`))
-                addEdge([x1, z0], [x1, z1]);
-            if (!occupied.has(`${xi}:${zi + 1}`))
-                addEdge([x1, z1], [x0, z1]);
-            if (!occupied.has(`${xi - 1}:${zi}`))
-                addEdge([x0, z1], [x0, z0]);
-        }
-    }
-    const polygons = [];
-    while (edgeMap.size > 0) {
-        const firstEntry = edgeMap.entries().next().value;
-        if (!firstEntry)
-            break;
-        const [startKey] = firstEntry;
-        const startParts = startKey.split(',').map(Number);
-        const sx = startParts[0];
-        const sz = startParts[1];
-        if (sx === undefined || sz === undefined) {
-            edgeMap.delete(startKey);
+    for (const id of new Set([...Object.keys(before), ...Object.keys(after)])) {
+        const previous = before[id];
+        const current = after[id];
+        if (previous?.type !== 'stair' && current?.type !== 'stair')
             continue;
-        }
-        const start = [sx, sz];
-        const polygon = [start];
-        let current = start;
-        while (true) {
-            const currentKey = `${current[0]},${current[1]}`;
-            const next = edgeMap.get(currentKey);
-            if (!next)
-                break;
-            edgeMap.delete(currentKey);
-            if (pointsEqual(next, start)) {
-                break;
-            }
-            polygon.push(next);
-            current = next;
-        }
-        if (polygon.length >= 3) {
-            polygons.push(polygonArea(polygon) < 0 ? [...polygon].reverse() : polygon);
+        if (previous?.type !== 'stair' ||
+            current?.type !== 'stair' ||
+            previous !== current ||
+            current.children.some((childId) => before[childId] !== after[childId]) ||
+            span(previous, before, beforeElevations) !== span(current, after, afterElevations) ||
+            resolveStairTotalRise(previous, before) !== resolveStairTotalRise(current, after)) {
+            owners.add(id);
         }
     }
-    return polygons;
+    return owners;
 }
-function getCurvedOpeningPolygon(stair, offset = 0) {
-    const width = Math.max(stair.width ?? 1, 0.4);
-    const innerRadius = Math.max(0.01, (stair.innerRadius ?? 0.9) - offset);
-    const outerRadius = (stair.innerRadius ?? 0.9) + width + offset;
-    const totalSweep = stair.sweepAngle ?? Math.PI / 2;
-    const baseOpeningSweep = Math.abs(totalSweep) *
-        Math.max(CURVED_STAIR_SLAB_OPENING_RATIO, 1 / Math.max(stair.stepCount ?? 1, 1));
-    const angleOffset = offset / Math.max(innerRadius, 0.1);
-    const openingSweep = Math.sign(totalSweep || 1) * Math.min(Math.abs(totalSweep), baseOpeningSweep + angleOffset * 2);
-    const startAngle = totalSweep / 2 - openingSweep;
-    const endAngle = totalSweep / 2;
-    const segmentCount = Math.max(10, Math.min(32, Math.ceil(Math.abs(openingSweep) / (Math.PI / 24) + Math.max(stair.stepCount ?? 1, 1) * 0.5)));
-    const outerPoints = [];
-    const innerPoints = [];
-    for (let index = 0; index <= segmentCount; index++) {
-        const t = index / segmentCount;
-        const angle = startAngle + (endAngle - startAngle) * t;
-        outerPoints.push(toWorldPlanPoint(stair, Math.cos(angle) * outerRadius, Math.sin(angle) * outerRadius));
-    }
-    for (let index = segmentCount; index >= 0; index--) {
-        const t = index / segmentCount;
-        const angle = startAngle + (endAngle - startAngle) * t;
-        innerPoints.push(toWorldPlanPoint(stair, Math.cos(angle) * innerRadius, Math.sin(angle) * innerRadius));
-    }
-    return [...outerPoints, ...innerPoints];
-}
-function getSpiralOpeningPolygon(stair, offset = 0) {
-    const radius = Math.max(0.05, stair.innerRadius ?? 0.9) + Math.max(stair.width ?? 1, 0.4) + offset;
-    const segmentCount = 48;
-    return Array.from({ length: segmentCount }).map((_, index) => {
-        const angle = (index / segmentCount) * Math.PI * 2;
-        return toWorldPlanPoint(stair, Math.cos(angle) * radius, Math.sin(angle) * radius);
-    });
-}
-function getStraightOpeningPolygonsForSurface(stair, nodes, targetElevation, openingOffsetOverride) {
-    const layouts = getStraightStairLayouts(stair, nodes);
-    if (layouts.length === 0)
-        return [];
-    const riserHeight = resolveStairTotalRise(stair, nodes) / Math.max(stair.stepCount ?? 10, 1);
-    const targetThreshold = Math.max(riserHeight * 2, STRAIGHT_STAIR_TARGET_THRESHOLD_MIN);
-    const openingOffset = Math.max(openingOffsetOverride ?? stair.openingOffset ?? 0, 0);
-    const openingRects = [];
-    for (let index = 0; index < layouts.length; index += 1) {
-        const layout = layouts[index];
-        if (!layout)
-            continue;
-        const { segment, transform } = layout;
-        const segmentStartElevation = transform.position[1];
-        const segmentTopElevation = layout.topElevation;
-        if (segment.segmentType === 'stair') {
-            if (Math.abs(targetElevation - segmentTopElevation) <= targetThreshold) {
-                const openingDepth = getStraightFlightOpeningDepth(stair, segment);
-                const flightRect = getAxisAlignedRectFromPolygon(getStraightSegmentLocalSlicePolygon(layout, Math.max(0, segment.length - openingDepth), segment.length));
-                if (flightRect)
-                    openingRects.push(expandRect(flightRect, openingOffset));
-            }
-            continue;
-        }
-        if (Math.abs(targetElevation - segmentStartElevation) > targetThreshold) {
-            continue;
-        }
-        const landingRects = [];
-        const landingRect = getAxisAlignedRectFromPolygon(getStraightSegmentLocalSlicePolygon(layout, 0, layout.segment.length));
-        if (landingRect)
-            landingRects.push(expandRect(landingRect, openingOffset));
-        const previous = layouts[index - 1];
-        if (previous?.segment.segmentType === 'stair') {
-            const previousTopElevation = previous.topElevation;
-            if (Math.abs(targetElevation - previousTopElevation) <= targetThreshold) {
-                const previousDepth = getStraightFlightOpeningDepth(stair, previous.segment);
-                const previousRect = getAxisAlignedRectFromPolygon(getStraightSegmentLocalSlicePolygon(previous, Math.max(0, previous.segment.length - previousDepth), previous.segment.length));
-                if (previousRect)
-                    landingRects.push(expandRect(previousRect, openingOffset));
-            }
-        }
-        openingRects.push(...landingRects);
-    }
-    if (openingRects.length > 0) {
-        const unionPolygons = buildUnionPolygonsFromRects(openingRects).map((polygon) => polygon.map(([x, z]) => toWorldPlanPoint(stair, x, z)));
-        if (unionPolygons.length > 0) {
-            return unionPolygons;
-        }
-    }
-    let fallbackLayout = layouts[layouts.length - 1];
-    for (let index = layouts.length - 1; index >= 0; index -= 1) {
-        const layout = layouts[index];
-        if (layout?.segment.segmentType === 'stair') {
-            fallbackLayout = layout;
-            break;
-        }
-    }
-    return fallbackLayout ? [getStraightSegmentFootprintPolygon(stair, fallbackLayout)] : [];
+function isCoveredByExistingHole(existingHoles, autoHole) {
+    if (existingHoles.some((existingHole) => polygonContainsPolygon(existingHole, autoHole)))
+        return true;
+    return area(difference(autoHole, union(existingHoles))) <= 1e-6;
 }
-function getStairOpeningPolygons(stair, nodes, targetElevation, openingOffsetOverride) {
-    if ((stair.slabOpeningMode ?? 'none') !== 'destination') {
+function getStairOpeningPolygons(stair, nodes, targetElevation, openingOffset, thickness) {
+    if ((stair.slabOpeningMode ?? 'none') !== 'destination')
         return [];
-    }
-    const openingOffset = Math.max(openingOffsetOverride ?? stair.openingOffset ?? 0, 0);
-    if (stair.stairType === 'curved') {
-        return [
-            getCurvedOpeningPolygon(stair, Math.max(openingOffset - STAIR_SLAB_OPENING_TIGHTENING, 0)),
-        ];
-    }
-    if (stair.stairType === 'spiral') {
-        const offset = Math.max(openingOffset - STAIR_SLAB_OPENING_TIGHTENING, 0);
-        return [getSpiralOpeningPolygon(stair, offset)];
-    }
-    if (typeof targetElevation === 'number') {
-        return getStraightOpeningPolygonsForSurface(stair, nodes, targetElevation, openingOffset);
-    }
-    return getStraightOpeningPolygonsForSurface(stair, nodes, Math.max(...getStraightStairLayouts(stair, nodes).map((layout) => layout.topElevation), 0), openingOffset);
+    const { fromLevelId } = getResolvedStairLevelIds(stair, nodes);
+    const source = fromLevelId
+        ? getLevelElevations(nodes).get(fromLevelId)
+        : undefined;
+    const underside = (source?.baseY ?? 0) + stair.position[1] + targetElevation - thickness;
+    return stairClearanceOpening(stair, nodes, underside, openingOffset, underside + thickness);
 }
-function getApplicableStairOpeningPolygons(stair, nodes, targetElevation, surfacePolygon) {
+function getApplicableStairOpeningPolygons(stair, nodes, targetElevation, surfacePolygon, thickness = 0, resolveOpening = getStairOpeningPolygons) {
     const configuredOffset = Math.max(stair.openingOffset ?? 0, 0);
-    const polygons = getStairOpeningPolygons(stair, nodes, targetElevation, configuredOffset);
+    const polygons = resolveOpening(stair, nodes, targetElevation, configuredOffset, thickness);
+    if (polygons === null)
+        return null;
     const overlappingPolygons = polygons.filter((polygon) => polygonsOverlap(surfacePolygon, polygon));
     if (overlappingPolygons.length === polygons.length || configuredOffset <= 1e-6) {
         return overlappingPolygons;
     }
-    const fallbackPolygons = getStairOpeningPolygons(stair, nodes, targetElevation, 0);
+    const fallbackPolygons = resolveOpening(stair, nodes, targetElevation, 0, thickness);
+    if (fallbackPolygons === null)
+        return null;
     const overlappingFallbackPolygons = fallbackPolygons.filter((polygon) => polygonsOverlap(surfacePolygon, polygon));
     return overlappingFallbackPolygons.length === fallbackPolygons.length
         ? overlappingFallbackPolygons
@@ -427,7 +221,7 @@ function getTargetSlabElevationForStair(stair, slab, slabLevelId, nodes) {
     const elevations = getLevelElevations(nodes);
     const fromElevation = fromLevelId ? elevations.get(fromLevelId) : undefined;
     const slabElevation = elevations.get(slabLevelId);
-    if (!fromElevation || !slabElevation || fromElevation.buildingId !== slabElevation.buildingId) {
+    if (!(fromElevation && slabElevation) || fromElevation.buildingId !== slabElevation.buildingId) {
         return slab.elevation ?? 0.05;
     }
     return (slabElevation.baseY - fromElevation.baseY + (slab.elevation ?? 0.05) - (stair.position[1] ?? 0));
@@ -438,8 +232,7 @@ function getTargetCeilingElevationForStair(stair, ceiling, ceilingLevelId, nodes
     const fromElevation = fromLevelId ? elevations.get(fromLevelId) : undefined;
     const ceilingElevation = elevations.get(ceilingLevelId);
     const ceilingHeight = resolveCeilingHeight(ceiling, nodes);
-    if (!fromElevation ||
-        !ceilingElevation ||
+    if (!(fromElevation && ceilingElevation) ||
         fromElevation.buildingId !== ceilingElevation.buildingId) {
         return ceilingHeight;
     }
@@ -479,11 +272,25 @@ function shouldApplyStairToCeiling(stair, ceilingLevelId, nodes) {
     const maxLevel = Math.max(fromLevel, toLevel);
     return ceilingLevel >= minLevel && ceilingLevel < maxLevel;
 }
-export function syncAutoStairOpenings(nodes) {
+/** A load migration supplies its historical resolver; live edits use clearance geometry. */
+export function syncAutoStairOpenings(nodes, resolveOpening = getStairOpeningPolygons) {
     const stairs = Object.values(nodes).filter((node) => node.type === 'stair' && node.visible !== false);
     const slabs = Object.values(nodes).filter((node) => node.type === 'slab');
     const ceilings = Object.values(nodes).filter((node) => node.type === 'ceiling');
     const updates = [];
+    const slabStairsByLevel = new Map();
+    const ceilingStairsByLevel = new Map();
+    const stairsFor = (levelId, ceiling) => {
+        const cache = ceiling ? ceilingStairsByLevel : slabStairsByLevel;
+        let selected = cache.get(levelId);
+        if (!selected) {
+            selected = stairs.filter((stair) => ceiling
+                ? shouldApplyStairToCeiling(stair, levelId, nodes)
+                : shouldApplyStairToSlab(stair, levelId, nodes));
+            cache.set(levelId, selected);
+        }
+        return selected;
+    };
     for (const slab of slabs) {
         const slabLevelId = resolveLevelId(slab, nodes);
         const existingHoles = slab.holes ?? [];
@@ -492,16 +299,23 @@ export function syncAutoStairOpenings(nodes) {
             .map((polygon, index) => ({ metadata: existingMetadata[index], polygon }))
             .filter((entry) => entry.metadata.source !== 'stair');
         const preservedHolePolygons = preservedHoles.map((entry) => entry.polygon);
-        const stairHoles = stairs
-            .filter((stair) => shouldApplyStairToSlab(stair, slabLevelId, nodes))
-            .flatMap((stair) => getApplicableStairOpeningPolygons(stair, nodes, getTargetSlabElevationForStair(stair, slab, slabLevelId, nodes), slab.polygon).map((polygon) => ({
-            polygon,
-            metadata: {
-                source: 'stair',
-                stairId: stair.id,
-            },
-        })))
-            .filter((hole) => !isCoveredByExistingHole(preservedHolePolygons, hole.polygon));
+        const unresolved = new Set();
+        const stairHoles = stairsFor(slabLevelId, false)
+            .flatMap((stair) => {
+            const polygons = getApplicableStairOpeningPolygons(stair, nodes, getTargetSlabElevationForStair(stair, slab, slabLevelId, nodes), slab.polygon, slab.thickness, resolveOpening);
+            if (polygons === null) {
+                unresolved.add(stair.id);
+                return existingHoles
+                    .map((polygon, index) => ({ polygon, metadata: existingMetadata[index] }))
+                    .filter((hole) => hole.metadata.source === 'stair' && hole.metadata.stairId === stair.id);
+            }
+            return polygons.map((polygon) => ({
+                polygon,
+                metadata: { source: 'stair', stairId: stair.id },
+            }));
+        })
+            .filter((hole) => unresolved.has(hole.metadata.stairId ?? '') ||
+            !isCoveredByExistingHole(preservedHolePolygons, hole.polygon));
         const nextHoles = [
             ...preservedHoles.map((hole) => hole.polygon),
             ...stairHoles.map((hole) => hole.polygon),
@@ -528,16 +342,23 @@ export function syncAutoStairOpenings(nodes) {
             .map((polygon, index) => ({ metadata: existingMetadata[index], polygon }))
             .filter((entry) => entry.metadata.source !== 'stair');
         const preservedHolePolygons = preservedHoles.map((entry) => entry.polygon);
-        const stairHoles = stairs
-            .filter((stair) => shouldApplyStairToCeiling(stair, ceilingLevelId, nodes))
-            .flatMap((stair) => getApplicableStairOpeningPolygons(stair, nodes, getTargetCeilingElevationForStair(stair, ceiling, ceilingLevelId, nodes), ceiling.polygon).map((polygon) => ({
-            polygon,
-            metadata: {
-                source: 'stair',
-                stairId: stair.id,
-            },
-        })))
-            .filter((hole) => !isCoveredByExistingHole(preservedHolePolygons, hole.polygon));
+        const unresolved = new Set();
+        const stairHoles = stairsFor(ceilingLevelId, true)
+            .flatMap((stair) => {
+            const polygons = getApplicableStairOpeningPolygons(stair, nodes, getTargetCeilingElevationForStair(stair, ceiling, ceilingLevelId, nodes), ceiling.polygon, 0, resolveOpening);
+            if (polygons === null) {
+                unresolved.add(stair.id);
+                return existingHoles
+                    .map((polygon, index) => ({ polygon, metadata: existingMetadata[index] }))
+                    .filter((hole) => hole.metadata.source === 'stair' && hole.metadata.stairId === stair.id);
+            }
+            return polygons.map((polygon) => ({
+                polygon,
+                metadata: { source: 'stair', stairId: stair.id },
+            }));
+        })
+            .filter((hole) => unresolved.has(hole.metadata.stairId ?? '') ||
+            !isCoveredByExistingHole(preservedHolePolygons, hole.polygon));
         const nextHoles = [
             ...preservedHoles.map((hole) => hole.polygon),
             ...stairHoles.map((hole) => hole.polygon),

package/dist/systems/stair/stair-opening-system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stair-opening-system.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-opening-system.tsx"],"names":[],"mappings":"AA6CA,wBAAgB,0BAA0B,eAsGzC;AAED,eAAO,MAAM,kBAAkB,YAG9B,CAAA"}
+{"version":3,"file":"stair-opening-system.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-opening-system.tsx"],"names":[],"mappings":"AAiDA,wBAAgB,0BAA0B,eAoIzC;AAED,eAAO,MAAM,kBAAkB,YAG9B,CAAA"}