@pascal-app/core 0.5.1 → 0.7.0

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

@@ -0,0 +1,576 @@
+import { resolveLevelId } from '../../hooks/spatial-grid/spatial-grid-sync';
+import { DEFAULT_WALL_HEIGHT } from '../wall/wall-footprint';
+const CURVED_STAIR_SLAB_OPENING_RATIO = 0.9;
+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));
+}
+function pointsEqual(a, b, tolerance = 1e-5) {
+    const dx = a[0] - b[0];
+    const dz = a[1] - b[1];
+    return dx * dx + dz * dz <= tolerance * tolerance;
+}
+function polygonsEqual(left, right) {
+    if (left.length !== right.length)
+        return false;
+    return left.every((polygon, polygonIndex) => {
+        const other = right[polygonIndex];
+        if (!(other && polygon.length === other.length))
+            return false;
+        return polygon.every((point, pointIndex) => {
+            const otherPoint = other[pointIndex];
+            if (!otherPoint)
+                return false;
+            return pointsEqual(point, otherPoint);
+        });
+    });
+}
+function metadataEqual(left, right) {
+    if (left.length !== right.length)
+        return false;
+    return left.every((entry, index) => entry.source === right[index]?.source &&
+        (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;
+}
+function getLevelNumber(levelId, nodes) {
+    if (!levelId)
+        return undefined;
+    const node = nodes[levelId];
+    return node?.type === 'level' ? node.level : undefined;
+}
+function getResolvedStairLevelIds(stair, nodes) {
+    const parentLevelId = resolveLevelId(stair, nodes);
+    const fromLevelId = stair.fromLevelId ?? parentLevelId;
+    const toLevelId = stair.toLevelId ?? fromLevelId;
+    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 * 6, segment.length * 0.62, 1.8));
+}
+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 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 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,
+    };
+}
+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);
+            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);
+        }
+    }
+    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)));
+    const outerPoints = [];
+    const innerPoints = [];
+    for (let index = 0; index <= segmentCount; index++) {
+        const t = index / segmentCount;
+        const angle = startAngle + sweep * 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;
+        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);
+    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) {
+    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 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 getStairOpeningPolygons(stair, nodes, targetElevation) {
+    if ((stair.slabOpeningMode ?? 'none') !== 'destination') {
+        return [];
+    }
+    if (stair.stairType === 'curved') {
+        return [getCurvedOpeningPolygon(stair, targetElevation)];
+    }
+    if (stair.stairType === 'spiral') {
+        return [getSpiralOpeningPolygon(stair)];
+    }
+    if (typeof targetElevation === 'number') {
+        return getStraightOpeningPolygonsForSurface(stair, nodes, targetElevation);
+    }
+    return getStraightOpeningPolygonsForSurface(stair, nodes, Math.max(...getStraightStairLayouts(stair, nodes).map((layout) => layout.topElevation), 0));
+}
+function getTargetSlabElevationForStair(stair, slab, slabLevelId, nodes) {
+    const { fromLevelId } = getResolvedStairLevelIds(stair, nodes);
+    const fromLevel = getLevelNumber(fromLevelId, nodes);
+    const slabLevel = getLevelNumber(slabLevelId, nodes);
+    if (fromLevel === undefined || slabLevel === undefined) {
+        return slab.elevation ?? 0.05;
+    }
+    return ((slabLevel - fromLevel) * DEFAULT_WALL_HEIGHT +
+        (slab.elevation ?? 0.05) -
+        (stair.position[1] ?? 0));
+}
+function getTargetCeilingElevationForStair(stair, ceiling, ceilingLevelId, nodes) {
+    const { fromLevelId } = getResolvedStairLevelIds(stair, nodes);
+    const fromLevel = getLevelNumber(fromLevelId, nodes);
+    const ceilingLevel = getLevelNumber(ceilingLevelId, nodes);
+    if (fromLevel === undefined || ceilingLevel === undefined) {
+        return ceiling.height ?? DEFAULT_WALL_HEIGHT;
+    }
+    return ((ceilingLevel - fromLevel) * DEFAULT_WALL_HEIGHT +
+        (ceiling.height ?? DEFAULT_WALL_HEIGHT) -
+        (stair.position[1] ?? 0));
+}
+function shouldApplyStairToSlab(stair, slabLevelId, nodes) {
+    const { fromLevelId, toLevelId } = getResolvedStairLevelIds(stair, nodes);
+    const fromLevel = getLevelNumber(fromLevelId, nodes);
+    const toLevel = getLevelNumber(toLevelId, nodes);
+    const slabLevel = getLevelNumber(slabLevelId, nodes);
+    if (slabLevel === undefined) {
+        return toLevelId === slabLevelId;
+    }
+    if (fromLevel === undefined || toLevel === undefined) {
+        return toLevelId === slabLevelId;
+    }
+    const minLevel = Math.min(fromLevel, toLevel);
+    const maxLevel = Math.max(fromLevel, toLevel);
+    return slabLevel > minLevel && slabLevel <= maxLevel;
+}
+function shouldApplyStairToCeiling(stair, ceilingLevelId, nodes) {
+    const { fromLevelId, toLevelId } = getResolvedStairLevelIds(stair, nodes);
+    const fromLevel = getLevelNumber(fromLevelId, nodes);
+    const toLevel = getLevelNumber(toLevelId, nodes);
+    const ceilingLevel = getLevelNumber(ceilingLevelId, nodes);
+    if (ceilingLevel === undefined) {
+        return fromLevelId === ceilingLevelId;
+    }
+    if (fromLevel === undefined || toLevel === undefined) {
+        return fromLevelId === ceilingLevelId;
+    }
+    const minLevel = Math.min(fromLevel, toLevel);
+    const maxLevel = Math.max(fromLevel, toLevel);
+    return ceilingLevel >= minLevel && ceilingLevel < maxLevel;
+}
+export function syncAutoStairOpenings(nodes) {
+    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 = [];
+    for (const slab of slabs) {
+        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 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)),
+            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)) {
+            updates.push({
+                id: slab.id,
+                data: {
+                    holes: nextHoles,
+                    holeMetadata: nextMetadata,
+                },
+            });
+        }
+    }
+    for (const ceiling of ceilings) {
+        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 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)),
+            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)) {
+            updates.push({
+                id: ceiling.id,
+                data: {
+                    holes: nextHoles,
+                    holeMetadata: nextMetadata,
+                },
+            });
+        }
+    }
+    return updates;
+}

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

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

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

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

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

@@ -0,0 +1,65 @@
+// @ts-expect-error — bun:test is provided by the Bun runtime; core does not
+// depend on @types/bun so the import type is unresolved at compile time.
+import { describe, expect, test } from 'bun:test';
+import { BuildingNode, LevelNode, SlabNode, StairNode, StairSegmentNode } from '../../schema';
+import { syncAutoStairOpenings } from './stair-opening-sync';
+describe('syncAutoStairOpenings', () => {
+    test('only applies stair holes to destination slabs that contain the opening', () => {
+        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 landingSlab = SlabNode.parse({
+            name: 'Landing Slab',
+            parentId: upper.id,
+            polygon: [
+                [0, 0],
+                [4, 0],
+                [4, 3],
+                [0, 3],
+            ],
+        });
+        const bedroomSlab = SlabNode.parse({
+            name: 'Bedroom Slab',
+            parentId: upper.id,
+            polygon: [
+                [4, 0],
+                [8, 0],
+                [8, 3],
+                [4, 3],
+            ],
+        });
+        const segment = StairSegmentNode.parse({
+            parentId: 'stair_main',
+            width: 1,
+            length: 2.6,
+            height: 2.5,
+            stepCount: 12,
+        });
+        const stair = StairNode.parse({
+            id: 'stair_main',
+            name: 'Main Stair',
+            parentId: ground.id,
+            position: [2, 0, 0.2],
+            stairType: 'straight',
+            fromLevelId: ground.id,
+            toLevelId: upper.id,
+            slabOpeningMode: 'destination',
+            children: [segment.id],
+        });
+        const nodes = Object.fromEntries([
+            building,
+            ground,
+            upper,
+            landingSlab,
+            bedroomSlab,
+            stair,
+            { ...segment, parentId: stair.id },
+        ].map((node) => [node.id, node]));
+        const updates = syncAutoStairOpenings(nodes);
+        const landingUpdate = updates.find((update) => update.id === landingSlab.id);
+        const bedroomUpdate = updates.find((update) => update.id === bedroomSlab.id);
+        expect(landingUpdate?.data.holes).toHaveLength(1);
+        expect(landingUpdate?.data.holeMetadata).toEqual([{ source: 'stair', stairId: stair.id }]);
+        expect(bedroomUpdate).toBeUndefined();
+    });
+});

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

@@ -1 +1 @@
-{"version":3,"file":"stair-system.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-system.tsx"],"names":[],"mappings":"AAiBA,eAAO,MAAM,WAAW,YA4FvB,CAAA"}
+{"version":3,"file":"stair-system.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-system.tsx"],"names":[],"mappings":"AAuBA,eAAO,MAAM,WAAW,YAgHvB,CAAA"}