@pascal-app/core 0.7.0 → 0.9.1

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

@@ -1,9 +1,10 @@
-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';
-const CURVED_STAIR_SLAB_OPENING_RATIO = 0.9;
+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;
-const CURVED_STAIR_OPENING_STEP_PADDING = 3;
 function clamp(value, min, max) {
     return Math.min(max, Math.max(min, value));
 }
@@ -31,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) {
@@ -180,47 +182,21 @@ 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;
     for (let index = 0; index < points.length; index += 1) {
         const current = points[index];
         const next = points[(index + 1) % points.length];
-        if (!current || !next)
+        if (!(current && next))
             continue;
         area += current[0] * next[1] - next[0] * current[1];
     }
     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)
@@ -319,69 +295,60 @@ function buildUnionPolygonsFromRects(rects) {
     }
     return polygons;
 }
-function getCurvedOpeningStepCount(stair, innerRadius, outerRadius, totalSweep) {
-    const stepCount = Math.max(2, Math.round(stair.stepCount ?? 10));
-    const stepSweep = Math.abs(totalSweep) / stepCount;
-    const midRadius = Math.max((innerRadius + outerRadius) * 0.5, 0.01);
-    const treadDepth = Math.max(stepSweep * midRadius, 0.2);
-    return Math.min(stepCount, Math.max(1, Math.ceil(1.8 / treadDepth), Math.ceil(stepCount * CURVED_STAIR_SLAB_OPENING_RATIO)));
-}
-function buildArcOpeningPolygon(stair, innerRadius, outerRadius, startAngle, endAngle) {
-    const sweep = endAngle - startAngle;
-    const segmentCount = Math.max(10, Math.min(32, Math.ceil(Math.abs(sweep) / (Math.PI / 24) + Math.max(stair.stepCount ?? 1, 1) * 0.5)));
+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 + sweep * t;
+        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 + sweep * t;
+        const angle = startAngle + (endAngle - startAngle) * t;
         innerPoints.push(toWorldPlanPoint(stair, Math.cos(angle) * innerRadius, Math.sin(angle) * innerRadius));
     }
     return [...outerPoints, ...innerPoints];
 }
-function getCurvedOpeningPolygon(stair, targetElevation) {
-    const width = Math.max(stair.width ?? 1, 0.4);
-    const innerRadius = Math.max(0.2, stair.innerRadius ?? 0.9);
-    const outerRadius = innerRadius + width;
-    const totalSweep = stair.sweepAngle ?? Math.PI / 2;
-    const stepCount = Math.max(2, Math.round(stair.stepCount ?? 10));
-    const stepHeight = Math.max(stair.totalRise ?? 2.5, 0.1) / stepCount;
-    const stepSweep = totalSweep / stepCount;
-    const targetThreshold = Math.max(stepHeight * 2, STRAIGHT_STAIR_TARGET_THRESHOLD_MIN);
-    const endAngle = totalSweep / 2;
-    const fallbackStartStepIndex = Math.max(0, stepCount - getCurvedOpeningStepCount(stair, innerRadius, outerRadius, totalSweep));
-    let startStepIndex = fallbackStartStepIndex;
-    if (typeof targetElevation === 'number') {
-        for (let index = 0; index < stepCount; index += 1) {
-            const stepTopElevation = stepHeight * (index + 1);
-            if (stepTopElevation >= targetElevation - targetThreshold) {
-                startStepIndex = Math.max(0, Math.min(fallbackStartStepIndex, index - CURVED_STAIR_OPENING_STEP_PADDING));
-                break;
-            }
-        }
-    }
-    const startAngle = -totalSweep / 2 + stepSweep * startStepIndex;
-    return buildArcOpeningPolygon(stair, innerRadius, outerRadius, startAngle, endAngle);
-}
-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];
@@ -434,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, targetElevation)];
+        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), 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;
     }
-    return getStraightOpeningPolygonsForSurface(stair, nodes, Math.max(...getStraightStairLayouts(stair, nodes).map((layout) => layout.topElevation), 0));
+    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);
@@ -476,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;
     }
@@ -491,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;
     }
@@ -510,26 +502,29 @@ 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)];
-        if (!polygonsEqual(existingHoles, nextHoles) ||
-            !metadataEqual(existingMetadata, nextMetadata)) {
+            .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,
                 data: {
@@ -543,26 +538,29 @@ 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)];
-        if (!polygonsEqual(existingHoles, nextHoles) ||
-            !metadataEqual(existingMetadata, nextMetadata)) {
+            .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,
                 data: {