@pascal-app/core 0.8.0 → 0.9.1

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

@@ -0,0 +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"}

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

@@ -0,0 +1,93 @@
+import useLiveNodeOverrides, {} from '../../store/use-live-node-overrides';
+import useScene from '../../store/use-scene';
+const SURFACE_OPENING_FIELDS = ['holes', 'holeMetadata'];
+function isSurface(node) {
+    return node?.type === 'slab' || node?.type === 'ceiling';
+}
+function isStairOpeningInputNode(node) {
+    return node?.type === 'stair' || node?.type === 'stair-segment';
+}
+function omitPreviewSurfaceFields(override) {
+    const next = { ...override };
+    for (const field of SURFACE_OPENING_FIELDS) {
+        delete next[field];
+    }
+    return next;
+}
+export function hasLiveStairOpeningInputs(nodes, liveTransforms, liveOverrides, previewSurfaceIds) {
+    for (const nodeId of liveTransforms.keys()) {
+        if (nodes[nodeId]?.type === 'stair')
+            return true;
+    }
+    for (const [nodeId, override] of liveOverrides) {
+        if (previewSurfaceIds.has(nodeId))
+            continue;
+        if (Object.keys(override).length > 0 && isStairOpeningInputNode(nodes[nodeId]))
+            return true;
+    }
+    return false;
+}
+export function getNodesWithLiveStairOpeningInputs(nodes, liveTransforms, liveOverrides, previewSurfaceIds) {
+    const nextNodes = { ...nodes };
+    for (const [nodeId, override] of liveOverrides) {
+        const node = nextNodes[nodeId];
+        if (!node)
+            continue;
+        const values = previewSurfaceIds.has(nodeId) ? omitPreviewSurfaceFields(override) : override;
+        if (Object.keys(values).length === 0)
+            continue;
+        nextNodes[nodeId] = { ...node, ...values };
+    }
+    for (const [nodeId, transform] of liveTransforms) {
+        const node = nextNodes[nodeId];
+        if (node?.type !== 'stair')
+            continue;
+        nextNodes[nodeId] = {
+            ...node,
+            position: transform.position,
+            rotation: transform.rotation,
+        };
+    }
+    return nextNodes;
+}
+export function createSurfaceOpeningPreviewController() {
+    const previewSurfaceIds = new Set();
+    const clearSurface = (id) => {
+        useLiveNodeOverrides.getState().clearFields(id, SURFACE_OPENING_FIELDS);
+        useScene.getState().markDirty(id);
+    };
+    return {
+        previewSurfaceIds,
+        apply(updates) {
+            const scene = useScene.getState();
+            const nextSurfaceIds = new Set();
+            for (const update of updates) {
+                const node = scene.nodes[update.id];
+                if (!isSurface(node))
+                    continue;
+                if (!('holes' in update.data || 'holeMetadata' in update.data))
+                    continue;
+                nextSurfaceIds.add(update.id);
+                useLiveNodeOverrides.getState().set(update.id, {
+                    holes: update.data.holes ?? [],
+                    holeMetadata: update.data.holeMetadata ?? [],
+                });
+                scene.markDirty(update.id);
+            }
+            for (const id of previewSurfaceIds) {
+                if (!nextSurfaceIds.has(id))
+                    clearSurface(id);
+            }
+            previewSurfaceIds.clear();
+            for (const id of nextSurfaceIds) {
+                previewSurfaceIds.add(id);
+            }
+        },
+        clear() {
+            for (const id of previewSurfaceIds) {
+                clearSurface(id);
+            }
+            previewSurfaceIds.clear();
+        },
+    };
+}

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=stair-opening-preview.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stair-opening-preview.test.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-opening-preview.test.ts"],"names":[],"mappings":""}

package/dist/systems/stair/stair-opening-preview.test.js

@@ -0,0 +1,80 @@
+import { describe, expect, test } from 'bun:test';
+import { BuildingNode, LevelNode, SlabNode, StairNode, StairSegmentNode } from '../../schema';
+import { getNodesWithLiveStairOpeningInputs, hasLiveStairOpeningInputs, } from './stair-opening-preview';
+import { syncAutoStairOpenings } from './stair-opening-sync';
+describe('stair opening previews', () => {
+    test('computes auto openings from live stair transforms', () => {
+        const building = BuildingNode.parse({ name: 'Building' });
+        const ground = LevelNode.parse({ name: 'Ground', level: 0, parentId: building.id });
+        const upper = LevelNode.parse({ name: 'Upper', level: 1, parentId: building.id });
+        const slab = SlabNode.parse({
+            name: 'Upper Slab',
+            parentId: upper.id,
+            polygon: [
+                [0, 0],
+                [5, 0],
+                [5, 4],
+                [0, 4],
+            ],
+        });
+        const segment = StairSegmentNode.parse({
+            parentId: 'stair_live',
+            width: 1,
+            length: 3,
+            height: 2.5,
+            stepCount: 12,
+        });
+        const stair = StairNode.parse({
+            id: 'stair_live',
+            name: 'Live Stair',
+            parentId: ground.id,
+            position: [1, 0, 0.2],
+            stairType: 'straight',
+            fromLevelId: ground.id,
+            toLevelId: upper.id,
+            slabOpeningMode: 'destination',
+            children: [segment.id],
+        });
+        const nodes = Object.fromEntries([building, ground, upper, slab, stair, { ...segment, parentId: stair.id }].map((node) => [
+            node.id,
+            node,
+        ]));
+        const liveTransforms = new Map([
+            [stair.id, { position: [3, 0, 0.2], rotation: 0 }],
+        ]);
+        const liveOverrides = new Map();
+        expect(hasLiveStairOpeningInputs(nodes, liveTransforms, liveOverrides, new Set())).toBe(true);
+        const previewNodes = getNodesWithLiveStairOpeningInputs(nodes, liveTransforms, liveOverrides, new Set());
+        const updates = syncAutoStairOpenings(previewNodes);
+        const hole = updates.find((update) => update.id === slab.id)?.data.holes?.[0];
+        expect(hole).toBeDefined();
+        expect(Math.max(...hole.map(([x]) => x))).toBeGreaterThan(3.4);
+    });
+    test('ignores its own live surface overrides as preview inputs', () => {
+        const slab = SlabNode.parse({
+            polygon: [
+                [0, 0],
+                [4, 0],
+                [4, 4],
+                [0, 4],
+            ],
+        });
+        const nodes = { [slab.id]: slab };
+        const liveOverrides = new Map([
+            [
+                slab.id,
+                {
+                    holes: [
+                        [
+                            [1, 1],
+                            [2, 1],
+                            [2, 2],
+                            [1, 2],
+                        ],
+                    ],
+                },
+            ],
+        ]);
+        expect(hasLiveStairOpeningInputs(nodes, new Map(), liveOverrides, new Set([slab.id]))).toBe(false);
+    });
+});

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":"AACA,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EACT,WAAW,EACX,QAAQ,EAGT,MAAM,cAAc,CAAA;AA6pBrB,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;QAQvC,SAAS;UAAQ,OAAO,CAAC,QAAQ,GAAG,WAAW,CAAC;IAuG5E"}
+{"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;AA8rBrB,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;QAQvC,SAAS;UAAQ,OAAO,CAAC,QAAQ,GAAG,WAAW,CAAC;IAqG5E"}

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

@@ -1,5 +1,7 @@
-import { resolveLevelId } from '../../hooks/spatial-grid/spatial-grid-sync';
+import { resolveBuildingForLevel, resolveLevelId } from '../../hooks/spatial-grid/spatial-grid-sync';
+import { polygonContainsPolygon, polygonsOverlap } from '../../lib/polygon-relations';
 import { DEFAULT_WALL_HEIGHT } from '../wall/wall-footprint';
+import { computeSegmentTransforms, rotateXZ } from './stair-footprint';
 const CURVED_STAIR_SLAB_OPENING_RATIO = 0.8;
 const STRAIGHT_STAIR_TARGET_THRESHOLD_MIN = 0.35;
 const STAIR_SLAB_OPENING_TIGHTENING = 0;
@@ -30,99 +32,100 @@ function metadataEqual(left, right) {
     if (left.length !== right.length)
         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));
 }
 function normalizeExistingMetadata(holes, metadata) {
     return holes.map((_, index) => metadata?.[index] ?? { source: 'manual' });
 }
-function expandPolygonFromCentroid(polygon, offset) {
-    if (Math.abs(offset) < 1e-6) {
-        return polygon.map(([x, z]) => [x, z]);
-    }
-    const centroid = polygon.reduce((acc, [x, z]) => {
-        acc.x += x;
-        acc.z += z;
-        return acc;
-    }, { x: 0, z: 0 });
-    centroid.x /= Math.max(polygon.length, 1);
-    centroid.z /= Math.max(polygon.length, 1);
-    return polygon.map(([x, z]) => {
-        const dx = x - centroid.x;
-        const dz = z - centroid.z;
-        const length = Math.hypot(dx, dz);
-        if (length < 1e-6) {
-            return [x, z];
-        }
-        const scale = Math.max(0.1, (length + offset) / length);
-        return [centroid.x + dx * scale, centroid.z + dz * scale];
-    });
-}
-function rotateXZ(x, z, angle) {
-    const cos = Math.cos(angle);
-    const sin = Math.sin(angle);
-    return [x * cos + z * sin, -x * sin + z * cos];
-}
-function computeSegmentTransforms(segments) {
-    const transforms = [];
-    let currentX = 0;
-    let currentY = 0;
-    let currentZ = 0;
-    let currentRot = 0;
-    for (let index = 0; index < segments.length; index++) {
-        const segment = segments[index];
-        if (!segment)
-            continue;
-        if (index === 0) {
-            transforms.push({
-                position: [currentX, currentY, currentZ],
-                rotation: currentRot,
-            });
-            continue;
-        }
-        const previous = segments[index - 1];
-        if (!previous)
-            continue;
-        let attachX = 0;
-        let attachZ = 0;
-        let rotationDelta = 0;
-        switch (segment.attachmentSide) {
-            case 'front':
-                attachX = 0;
-                attachZ = previous.length;
-                break;
-            case 'left':
-                attachX = previous.width / 2;
-                attachZ = previous.length / 2;
-                rotationDelta = Math.PI / 2;
-                break;
-            case 'right':
-                attachX = -previous.width / 2;
-                attachZ = previous.length / 2;
-                rotationDelta = -Math.PI / 2;
-                break;
-        }
-        const [deltaX, deltaZ] = rotateXZ(attachX, attachZ, currentRot);
-        currentX += deltaX;
-        currentY += previous.height;
-        currentZ += deltaZ;
-        currentRot += rotationDelta;
-        transforms.push({
-            position: [currentX, currentY, currentZ],
-            rotation: currentRot,
-        });
-    }
-    return transforms;
-}
+// (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;
     const node = nodes[levelId];
     return node?.type === 'level' ? node.level : undefined;
 }
+function getLevelBuildingId(levelId, nodes) {
+    if (!levelId)
+        return null;
+    return resolveBuildingForLevel(levelId, nodes);
+}
+function normalizeLevelId(levelId, nodes) {
+    if (!levelId)
+        return null;
+    return nodes[levelId]?.type === 'level' ? levelId : null;
+}
+function getBuildingLevels(buildingId, nodes) {
+    const building = buildingId ? nodes[buildingId] : null;
+    if (building?.type !== 'building')
+        return [];
+    const levels = new Map();
+    for (const childId of building.children ?? []) {
+        const child = nodes[childId];
+        if (child?.type === 'level')
+            levels.set(child.id, child);
+    }
+    for (const candidate of Object.values(nodes)) {
+        if (candidate?.type === 'level' && candidate.parentId === building.id) {
+            levels.set(candidate.id, candidate);
+        }
+    }
+    return Array.from(levels.values()).sort((left, right) => left.level - right.level);
+}
+function inferSourceLevelForDestination(destinationLevelId, nodes) {
+    if (!destinationLevelId)
+        return null;
+    const destination = nodes[destinationLevelId];
+    if (destination?.type !== 'level')
+        return null;
+    const buildingId = getLevelBuildingId(destinationLevelId, nodes);
+    return (getBuildingLevels(buildingId, nodes)
+        .filter((level) => level.level < destination.level)
+        .at(-1)?.id ?? null);
+}
+function inferDestinationLevelForSource(sourceLevelId, nodes) {
+    if (!sourceLevelId)
+        return null;
+    const source = nodes[sourceLevelId];
+    if (source?.type !== 'level')
+        return null;
+    const buildingId = getLevelBuildingId(sourceLevelId, nodes);
+    return (getBuildingLevels(buildingId, nodes).find((level) => level.level > source.level)?.id ?? null);
+}
+function levelsShareBuilding(leftLevelId, rightLevelId, nodes) {
+    if (!(leftLevelId && rightLevelId))
+        return true;
+    const leftBuildingId = getLevelBuildingId(leftLevelId, nodes);
+    const rightBuildingId = getLevelBuildingId(rightLevelId, nodes);
+    return !(leftBuildingId && rightBuildingId && leftBuildingId !== rightBuildingId);
+}
+function isInStairBuildingScope(stair, surfaceLevelId, nodes) {
+    const { fromLevelId, toLevelId } = getResolvedStairLevelIds(stair, nodes);
+    const fromBuildingId = getLevelBuildingId(fromLevelId, nodes);
+    const toBuildingId = getLevelBuildingId(toLevelId, nodes);
+    const surfaceBuildingId = getLevelBuildingId(surfaceLevelId, nodes);
+    if (fromBuildingId && toBuildingId && fromBuildingId !== toBuildingId)
+        return false;
+    if (fromBuildingId && surfaceBuildingId && fromBuildingId !== surfaceBuildingId)
+        return false;
+    if (toBuildingId && surfaceBuildingId && toBuildingId !== surfaceBuildingId)
+        return false;
+    return true;
+}
 function getResolvedStairLevelIds(stair, nodes) {
-    const parentLevelId = resolveLevelId(stair, nodes);
-    const fromLevelId = stair.fromLevelId ?? parentLevelId;
-    const toLevelId = stair.toLevelId ?? fromLevelId;
+    const parentLevelId = normalizeLevelId(resolveLevelId(stair, nodes), nodes);
+    const explicitToLevelId = normalizeLevelId(stair.toLevelId, nodes);
+    const fromLevelId = normalizeLevelId(stair.fromLevelId, nodes) ??
+        parentLevelId ??
+        inferSourceLevelForDestination(explicitToLevelId, nodes);
+    const explicitToLevelIsUsable = explicitToLevelId &&
+        explicitToLevelId !== fromLevelId &&
+        levelsShareBuilding(fromLevelId, explicitToLevelId, nodes);
+    const toLevelId = explicitToLevelIsUsable
+        ? explicitToLevelId
+        : inferDestinationLevelForSource(fromLevelId, nodes);
     return { fromLevelId, toLevelId };
 }
 function resolveStraightSegments(stair, nodes) {
@@ -179,7 +182,7 @@ function getStraightSegmentSlicePolygon(stair, layout, startAlong, endAlong) {
 }
 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 * 6, segment.length * 0.62, 1.8));
+    return Math.min(segment.length, Math.max(treadDepth * 10, segment.length * 0.8, 3.0));
 }
 function polygonArea(points) {
     let area = 0;
@@ -192,34 +195,8 @@ function polygonArea(points) {
     }
     return area / 2;
 }
-function pointOnSegment(point, a, b, tolerance = 1e-6) {
-    const cross = (point[1] - a[1]) * (b[0] - a[0]) - (point[0] - a[0]) * (b[1] - a[1]);
-    if (Math.abs(cross) > tolerance)
-        return false;
-    const dot = (point[0] - a[0]) * (b[0] - a[0]) + (point[1] - a[1]) * (b[1] - a[1]);
-    if (dot < -tolerance)
-        return false;
-    const lenSq = (b[0] - a[0]) ** 2 + (b[1] - a[1]) ** 2;
-    return dot <= lenSq + tolerance;
-}
-function pointInPolygon(point, polygon) {
-    if (polygon.length < 3)
-        return false;
-    let inside = false;
-    const [x, z] = point;
-    for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
-        const a = polygon[i];
-        const b = polygon[j];
-        if (pointOnSegment(point, a, b))
-            return true;
-        const intersects = a[1] > z !== b[1] > z && x < ((b[0] - a[0]) * (z - a[1])) / (b[1] - a[1]) + a[0];
-        if (intersects)
-            inside = !inside;
-    }
-    return inside;
-}
-function polygonContainsPolygon(outer, inner) {
-    return inner.every((point) => pointInPolygon(point, outer));
+function isCoveredByExistingHole(existingHoles, autoHole) {
+    return existingHoles.some((existingHole) => polygonContainsPolygon(existingHole, autoHole));
 }
 function getAxisAlignedRectFromPolygon(polygon) {
     if (polygon.length < 4)
@@ -318,13 +295,15 @@ function buildUnionPolygonsFromRects(rects) {
     }
     return polygons;
 }
-function getCurvedOpeningPolygon(stair) {
+function getCurvedOpeningPolygon(stair, offset = 0) {
     const width = Math.max(stair.width ?? 1, 0.4);
-    const innerRadius = Math.max(0.2, stair.innerRadius ?? 0.9);
-    const outerRadius = innerRadius + width;
+    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 openingSweep = Math.sign(totalSweep || 1) *
-        Math.max(Math.abs(totalSweep) * CURVED_STAIR_SLAB_OPENING_RATIO, Math.abs(totalSweep) / Math.max(stair.stepCount ?? 1, 1));
+    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)));
@@ -342,21 +321,34 @@ function getCurvedOpeningPolygon(stair) {
     }
     return [...outerPoints, ...innerPoints];
 }
-function getSpiralOpeningPolygon(stair) {
-    const radius = Math.max(0.05, stair.innerRadius ?? 0.9) + Math.max(stair.width ?? 1, 0.4);
+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) {
+function getSpiralLandingPolygon(stair, offset = 0) {
+    const width = Math.max(stair.width ?? 1, 0.4);
+    const outerRadius = Math.max(0.05, (stair.innerRadius ?? 0.9) + width);
+    const depth = Math.max(stair.topLandingDepth ?? 0.9, 0.1);
+    const halfWidth = width / 2;
+    const localPoints = [
+        [outerRadius - offset, -halfWidth - offset],
+        [outerRadius + depth + offset, -halfWidth - offset],
+        [outerRadius + depth + offset, halfWidth + offset],
+        [outerRadius - offset, halfWidth + offset],
+    ];
+    return localPoints.map(([x, z]) => toWorldPlanPoint(stair, x, z));
+}
+function getStraightOpeningPolygonsForSurface(stair, nodes, targetElevation, openingOffsetOverride) {
     const layouts = getStraightStairLayouts(stair, nodes);
     if (layouts.length === 0)
         return [];
     const riserHeight = (stair.totalRise ?? 2.5) / Math.max(stair.stepCount ?? 10, 1);
     const targetThreshold = Math.max(riserHeight * 2, STRAIGHT_STAIR_TARGET_THRESHOLD_MIN);
-    const openingOffset = Math.max(stair.openingOffset ?? 0, 0);
+    const openingOffset = Math.max(openingOffsetOverride ?? stair.openingOffset ?? 0, 0);
     const openingRects = [];
     for (let index = 0; index < layouts.length; index += 1) {
         const layout = layouts[index];
@@ -409,20 +401,41 @@ function getStraightOpeningPolygonsForSurface(stair, nodes, targetElevation) {
     }
     return fallbackLayout ? [getStraightSegmentFootprintPolygon(stair, fallbackLayout)] : [];
 }
-function getStairOpeningPolygons(stair, nodes, targetElevation) {
+function getStairOpeningPolygons(stair, nodes, targetElevation, openingOffsetOverride) {
     if ((stair.slabOpeningMode ?? 'none') !== 'destination') {
         return [];
     }
+    const openingOffset = Math.max(openingOffsetOverride ?? stair.openingOffset ?? 0, 0);
     if (stair.stairType === 'curved') {
-        return [getCurvedOpeningPolygon(stair)];
+        return [
+            getCurvedOpeningPolygon(stair, Math.max(openingOffset - STAIR_SLAB_OPENING_TIGHTENING, 0)),
+        ];
     }
     if (stair.stairType === 'spiral') {
-        return [getSpiralOpeningPolygon(stair)];
+        const offset = Math.max(openingOffset - STAIR_SLAB_OPENING_TIGHTENING, 0);
+        const polygons = [getSpiralOpeningPolygon(stair, offset)];
+        if (stair.topLandingMode === 'integrated') {
+            polygons.push(getSpiralLandingPolygon(stair, offset));
+        }
+        return polygons;
     }
     if (typeof targetElevation === 'number') {
-        return getStraightOpeningPolygonsForSurface(stair, nodes, targetElevation);
+        return getStraightOpeningPolygonsForSurface(stair, nodes, targetElevation, openingOffset);
     }
-    return getStraightOpeningPolygonsForSurface(stair, nodes, Math.max(...getStraightStairLayouts(stair, nodes).map((layout) => layout.topElevation), 0));
+    return getStraightOpeningPolygonsForSurface(stair, nodes, Math.max(...getStraightStairLayouts(stair, nodes).map((layout) => layout.topElevation), 0), openingOffset);
+}
+function getApplicableStairOpeningPolygons(stair, nodes, targetElevation, surfacePolygon) {
+    const configuredOffset = Math.max(stair.openingOffset ?? 0, 0);
+    const polygons = getStairOpeningPolygons(stair, nodes, targetElevation, configuredOffset);
+    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 overlappingFallbackPolygons = fallbackPolygons.filter((polygon) => polygonsOverlap(surfacePolygon, polygon));
+    return overlappingFallbackPolygons.length === fallbackPolygons.length
+        ? overlappingFallbackPolygons
+        : overlappingPolygons;
 }
 function getTargetSlabElevationForStair(stair, slab, slabLevelId, nodes) {
     const { fromLevelId } = getResolvedStairLevelIds(stair, nodes);
@@ -451,6 +464,8 @@ function shouldApplyStairToSlab(stair, slabLevelId, nodes) {
     const fromLevel = getLevelNumber(fromLevelId, nodes);
     const toLevel = getLevelNumber(toLevelId, nodes);
     const slabLevel = getLevelNumber(slabLevelId, nodes);
+    if (!isInStairBuildingScope(stair, slabLevelId, nodes))
+        return false;
     if (slabLevel === undefined) {
         return toLevelId === slabLevelId;
     }
@@ -466,6 +481,8 @@ function shouldApplyStairToCeiling(stair, ceilingLevelId, nodes) {
     const fromLevel = getLevelNumber(fromLevelId, nodes);
     const toLevel = getLevelNumber(toLevelId, nodes);
     const ceilingLevel = getLevelNumber(ceilingLevelId, nodes);
+    if (!isInStairBuildingScope(stair, ceilingLevelId, nodes))
+        return false;
     if (ceilingLevel === undefined) {
         return fromLevelId === ceilingLevelId;
     }
@@ -485,24 +502,28 @@ export function syncAutoStairOpenings(nodes) {
         const slabLevelId = resolveLevelId(slab, nodes);
         const existingHoles = slab.holes ?? [];
         const existingMetadata = normalizeExistingMetadata(existingHoles, slab.holeMetadata);
-        const manualHoles = existingHoles.filter((_hole, index) => existingMetadata[index]?.source !== 'stair');
-        const manualMetadata = existingMetadata
-            .filter((entry) => entry.source !== 'stair')
-            .map((entry) => ({ ...entry }));
+        const preservedHoles = existingHoles
+            .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) => getStairOpeningPolygons(stair, nodes, getTargetSlabElevationForStair(stair, slab, slabLevelId, nodes)).map((polygon) => ({
-            polygon: stair.stairType === 'straight'
-                ? polygon
-                : expandPolygonFromCentroid(polygon, Math.max((stair.openingOffset ?? 0) - STAIR_SLAB_OPENING_TIGHTENING, 0)),
+            .flatMap((stair) => getApplicableStairOpeningPolygons(stair, nodes, getTargetSlabElevationForStair(stair, slab, slabLevelId, nodes), slab.polygon).map((polygon) => ({
+            polygon,
             metadata: {
                 source: 'stair',
                 stairId: stair.id,
             },
         })))
-            .filter((hole) => polygonContainsPolygon(slab.polygon, hole.polygon));
-        const nextHoles = [...manualHoles, ...stairHoles.map((hole) => hole.polygon)];
-        const nextMetadata = [...manualMetadata, ...stairHoles.map((hole) => hole.metadata)];
+            .filter((hole) => !isCoveredByExistingHole(preservedHolePolygons, hole.polygon));
+        const nextHoles = [
+            ...preservedHoles.map((hole) => hole.polygon),
+            ...stairHoles.map((hole) => hole.polygon),
+        ];
+        const nextMetadata = [
+            ...preservedHoles.map((hole) => ({ ...hole.metadata })),
+            ...stairHoles.map((hole) => hole.metadata),
+        ];
         if (!(polygonsEqual(existingHoles, nextHoles) && metadataEqual(existingMetadata, nextMetadata))) {
             updates.push({
                 id: slab.id,
@@ -517,24 +538,28 @@ export function syncAutoStairOpenings(nodes) {
         const ceilingLevelId = resolveLevelId(ceiling, nodes);
         const existingHoles = ceiling.holes ?? [];
         const existingMetadata = normalizeExistingMetadata(existingHoles, ceiling.holeMetadata);
-        const manualHoles = existingHoles.filter((_hole, index) => existingMetadata[index]?.source !== 'stair');
-        const manualMetadata = existingMetadata
-            .filter((entry) => entry.source !== 'stair')
-            .map((entry) => ({ ...entry }));
+        const preservedHoles = existingHoles
+            .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) => getStairOpeningPolygons(stair, nodes, getTargetCeilingElevationForStair(stair, ceiling, ceilingLevelId, nodes)).map((polygon) => ({
-            polygon: stair.stairType === 'straight'
-                ? polygon
-                : expandPolygonFromCentroid(polygon, Math.max((stair.openingOffset ?? 0) - STAIR_SLAB_OPENING_TIGHTENING, 0)),
+            .flatMap((stair) => getApplicableStairOpeningPolygons(stair, nodes, getTargetCeilingElevationForStair(stair, ceiling, ceilingLevelId, nodes), ceiling.polygon).map((polygon) => ({
+            polygon,
             metadata: {
                 source: 'stair',
                 stairId: stair.id,
             },
         })))
-            .filter((hole) => polygonContainsPolygon(ceiling.polygon, hole.polygon));
-        const nextHoles = [...manualHoles, ...stairHoles.map((hole) => hole.polygon)];
-        const nextMetadata = [...manualMetadata, ...stairHoles.map((hole) => hole.metadata)];
+            .filter((hole) => !isCoveredByExistingHole(preservedHolePolygons, hole.polygon));
+        const nextHoles = [
+            ...preservedHoles.map((hole) => hole.polygon),
+            ...stairHoles.map((hole) => hole.polygon),
+        ];
+        const nextMetadata = [
+            ...preservedHoles.map((hole) => ({ ...hole.metadata })),
+            ...stairHoles.map((hole) => hole.metadata),
+        ];
         if (!(polygonsEqual(existingHoles, nextHoles) && metadataEqual(existingMetadata, nextMetadata))) {
             updates.push({
                 id: ceiling.id,