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

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-preview.js

@@ -1,5 +1,5 @@
-import useLiveNodeOverrides, {} from '../../store/use-live-node-overrides';
-import useScene from '../../store/use-scene';
+import useLiveNodeOverrides, {} from '../../store/use-live-node-overrides.js';
+import useScene from '../../store/use-scene.js';
 const SURFACE_OPENING_FIELDS = ['holes', 'holeMetadata'];
 function isSurface(node) {
     return node?.type === 'slab' || node?.type === 'ceiling';

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

@@ -1,4 +1,4 @@
-import type { AnyNode, AnyNodeId, CeilingNode, SlabNode } from '../../schema';
+import type { AnyNode, AnyNodeId, CeilingNode, SlabNode } from '../../schema/index.js';
 export declare function syncAutoStairOpenings(nodes: Record<string, AnyNode>): {
     id: AnyNodeId;
     data: Partial<SlabNode | CeilingNode>;

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

@@ -1,9 +1,9 @@
-import { resolveBuildingForLevel, resolveLevelId } from '../../hooks/spatial-grid/spatial-grid-sync';
-import { polygonContainsPolygon, polygonsOverlap } from '../../lib/polygon-relations';
-import { resolveCeilingHeight } from '../../services/level-height';
-import { getLevelElevations } from '../../services/storey';
-import { computeSegmentTransforms, rotateXZ } from './stair-footprint';
-import { resolveStairTotalRise } from './stair-rise';
+import { resolveBuildingForLevel, resolveLevelId } from '../../hooks/spatial-grid/spatial-grid-sync.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;

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

@@ -1,2 +1,3 @@
+export declare function initializeStairOpeningSync(): () => void;
 export declare const StairOpeningSystem: () => null;
 //# sourceMappingURL=stair-opening-system.d.ts.map

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":"AA4CA,eAAO,MAAM,kBAAkB,YAoH9B,CAAA"}
+{"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"}

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

@@ -1,12 +1,13 @@
 'use client';
-import { useEffect, useRef } from 'react';
-import { pauseSceneHistory, resumeSceneHistory } from '../../store/history-control';
-import useLiveNodeOverrides from '../../store/use-live-node-overrides';
-import useLiveTransforms from '../../store/use-live-transforms';
-import useScene from '../../store/use-scene';
-import { createSurfaceOpeningPreviewController, getNodesWithLiveStairOpeningInputs, hasLiveStairOpeningInputs, } from './stair-opening-preview';
-import { syncAutoStairOpenings } from './stair-opening-sync';
-import { syncStairRises } from './stair-rise';
+import { useEffect } from 'react';
+import { pauseSceneHistory, resumeSceneHistory } from '../../store/history-control.js';
+import { queueSceneNormalization } from '../../store/scene-hydration.js';
+import useLiveNodeOverrides from '../../store/use-live-node-overrides.js';
+import useLiveTransforms from '../../store/use-live-transforms.js';
+import useScene from '../../store/use-scene.js';
+import { createSurfaceOpeningPreviewController, getNodesWithLiveStairOpeningInputs, hasLiveStairOpeningInputs, } from './stair-opening-preview.js';
+import { syncAutoStairOpenings } from './stair-opening-sync.js';
+import { syncStairRises } from './stair-rise.js';
 function isOpeningRelevantNode(node) {
     return (node?.type === 'building' ||
         node?.type === 'ceiling' ||
@@ -29,104 +30,100 @@ function hasOpeningRelevantNodeChange(nextNodes, prevNodes) {
     }
     return false;
 }
-export const StairOpeningSystem = () => {
-    const syncingAutoOpeningsRef = useRef(false);
-    const syncingPreviewOpeningsRef = useRef(false);
-    const previewControllerRef = useRef(createSurfaceOpeningPreviewController());
-    useEffect(() => {
-        const applyUpdates = (updates) => {
-            if (updates.length === 0)
-                return;
-            syncingAutoOpeningsRef.current = true;
-            pauseSceneHistory(useScene);
-            try {
-                useScene.getState().updateNodes(updates);
-            }
-            finally {
-                resumeSceneHistory(useScene);
-            }
-            queueMicrotask(() => {
-                syncingAutoOpeningsRef.current = false;
-            });
-        };
-        const applyPreviewUpdates = (updates) => {
-            syncingPreviewOpeningsRef.current = true;
-            previewControllerRef.current.apply(updates);
-            queueMicrotask(() => {
-                syncingPreviewOpeningsRef.current = false;
-            });
-        };
-        const clearPreviewUpdates = () => {
-            if (previewControllerRef.current.previewSurfaceIds.size === 0)
-                return;
-            syncingPreviewOpeningsRef.current = true;
-            previewControllerRef.current.clear();
-            queueMicrotask(() => {
-                syncingPreviewOpeningsRef.current = false;
-            });
-        };
-        const refreshLivePreview = () => {
-            if (syncingPreviewOpeningsRef.current)
-                return;
-            const nodes = useScene.getState().nodes;
-            const liveTransforms = useLiveTransforms.getState().transforms;
-            const liveOverrides = useLiveNodeOverrides.getState().overrides;
-            const previewSurfaceIds = previewControllerRef.current.previewSurfaceIds;
-            if (!hasLiveStairOpeningInputs(nodes, liveTransforms, liveOverrides, previewSurfaceIds)) {
-                clearPreviewUpdates();
-                return;
-            }
-            applyPreviewUpdates(syncAutoStairOpenings(getNodesWithLiveStairOpeningInputs(nodes, liveTransforms, liveOverrides, previewSurfaceIds)));
-        };
-        const runAutoSync = () => {
-            // Rise first: straight stairs converge their flight heights to the
-            // resolved rise (level height or deck elevation), and the opening pass
-            // reads those segment heights — so it must run against the post-rise
-            // nodes.
-            applyUpdates(syncStairRises(useScene.getState().nodes));
-            applyUpdates(syncAutoStairOpenings(useScene.getState().nodes));
-        };
-        let disposed = false;
-        let autoSyncQueued = false;
-        const scheduleAutoSync = () => {
-            if (autoSyncQueued)
-                return;
-            autoSyncQueued = true;
-            // One microtask later so every other scene-store listener for the
-            // triggering transition (and, at mount, the editor's spatial-grid
-            // init) runs first — the spatial-grid sync in particular. The
-            // deck-attached rise elects the stair's floor-stack base elevation
-            // through the spatial grid; syncing before the grid listener would
-            // rescale flights against the pre-transition slab state.
-            queueMicrotask(() => {
-                autoSyncQueued = false;
-                if (disposed)
-                    return;
-                runAutoSync();
-                refreshLivePreview();
-            });
-        };
-        scheduleAutoSync();
-        const unsubscribeScene = useScene.subscribe((state, prevState) => {
-            if (syncingAutoOpeningsRef.current)
-                return;
-            if (!hasOpeningRelevantNodeChange(state.nodes, prevState.nodes))
-                return;
-            scheduleAutoSync();
+export function initializeStairOpeningSync() {
+    let syncingAutoOpenings = false;
+    let syncingPreviewOpenings = false;
+    const previewController = createSurfaceOpeningPreviewController();
+    const applyUpdates = (updates) => {
+        if (updates.length === 0)
+            return;
+        syncingAutoOpenings = true;
+        pauseSceneHistory(useScene);
+        try {
+            useScene.getState().updateNodes(updates);
+        }
+        finally {
+            resumeSceneHistory(useScene);
+            syncingAutoOpenings = false;
+        }
+    };
+    const applyPreviewUpdates = (updates) => {
+        syncingPreviewOpenings = true;
+        previewController.apply(updates);
+        queueMicrotask(() => {
+            syncingPreviewOpenings = false;
         });
-        const unsubscribeLiveTransforms = useLiveTransforms.subscribe(() => {
-            refreshLivePreview();
+    };
+    const clearPreviewUpdates = () => {
+        if (previewController.previewSurfaceIds.size === 0)
+            return;
+        syncingPreviewOpenings = true;
+        previewController.clear();
+        queueMicrotask(() => {
+            syncingPreviewOpenings = false;
         });
-        const unsubscribeLiveOverrides = useLiveNodeOverrides.subscribe(() => {
+    };
+    const refreshLivePreview = () => {
+        if (syncingPreviewOpenings)
+            return;
+        const nodes = useScene.getState().nodes;
+        const liveTransforms = useLiveTransforms.getState().transforms;
+        const liveOverrides = useLiveNodeOverrides.getState().overrides;
+        const previewSurfaceIds = previewController.previewSurfaceIds;
+        if (!hasLiveStairOpeningInputs(nodes, liveTransforms, liveOverrides, previewSurfaceIds)) {
+            clearPreviewUpdates();
+            return;
+        }
+        applyPreviewUpdates(syncAutoStairOpenings(getNodesWithLiveStairOpeningInputs(nodes, liveTransforms, liveOverrides, previewSurfaceIds)));
+    };
+    const runAutoSync = () => {
+        // Rise first: straight stairs converge their flight heights to the
+        // resolved rise (level height or deck elevation), and the opening pass
+        // reads those segment heights — so it must run against the post-rise
+        // nodes.
+        applyUpdates(syncStairRises(useScene.getState().nodes));
+        applyUpdates(syncAutoStairOpenings(useScene.getState().nodes));
+    };
+    let disposed = false;
+    let syncGeneration = 0;
+    const scheduleAutoSync = () => {
+        const generation = ++syncGeneration;
+        // One microtask later so every other scene-store listener for the
+        // triggering transition (and, at mount, the editor's spatial-grid
+        // init) runs first — the spatial-grid sync in particular. The
+        // deck-attached rise elects the stair's floor-stack base elevation
+        // through the spatial grid; syncing before the grid listener would
+        // rescale flights against the pre-transition slab state.
+        queueSceneNormalization(() => {
+            if (disposed || generation !== syncGeneration)
+                return;
+            runAutoSync();
             refreshLivePreview();
         });
-        return () => {
-            disposed = true;
-            unsubscribeScene();
-            unsubscribeLiveTransforms();
-            unsubscribeLiveOverrides();
-            previewControllerRef.current.clear();
-        };
-    }, []);
+    };
+    scheduleAutoSync();
+    const unsubscribeScene = useScene.subscribe((state, prevState) => {
+        if (syncingAutoOpenings)
+            return;
+        if (!hasOpeningRelevantNodeChange(state.nodes, prevState.nodes))
+            return;
+        scheduleAutoSync();
+    });
+    const unsubscribeLiveTransforms = useLiveTransforms.subscribe(() => {
+        refreshLivePreview();
+    });
+    const unsubscribeLiveOverrides = useLiveNodeOverrides.subscribe(() => {
+        refreshLivePreview();
+    });
+    return () => {
+        disposed = true;
+        unsubscribeScene();
+        unsubscribeLiveTransforms();
+        unsubscribeLiveOverrides();
+        previewController.clear();
+    };
+}
+export const StairOpeningSystem = () => {
+    useEffect(() => initializeStairOpeningSync(), []);
     return null;
 };

package/dist/systems/stair/stair-rise.d.ts

@@ -1,4 +1,4 @@
-import type { AnyNode, AnyNodeId, StairNode } from '../../schema';
+import type { AnyNode, AnyNodeId, StairNode } from '../../schema/index.js';
 export declare function resolveStairTotalRise(stair: StairNode, nodes: Record<string, AnyNode>): number;
 /**
  * Keeps straight stairs' flight segments in step with the resolved rise.

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

@@ -1 +1 @@
-{"version":3,"file":"stair-rise.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-rise.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAoB,MAAM,cAAc,CAAA;AAInF,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAiC9F;AAID;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,KAAK,CAAC;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,CAAC,CAgClD"}
+{"version":3,"file":"stair-rise.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-rise.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAoB,MAAM,cAAc,CAAA;AAInF,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CA+B9F;AAID;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,KAAK,CAAC;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,CAAC,CAgClD"}

package/dist/systems/stair/stair-rise.js

@@ -1,35 +1,34 @@
-import { getFloorStackedPosition } from '../../hooks/spatial-grid/floor-placed-elevation';
-import { DEFAULT_LEVEL_HEIGHT } from '../../services/level-height';
-import { getLevelFloorToFloorHeight } from '../../services/storey';
+import { getFloorStackedPosition } from '../../hooks/spatial-grid/floor-placed-elevation.js';
+import { DEFAULT_LEVEL_HEIGHT } from '../../services/level-height.js';
+import { getLevelFloorToFloorHeight } from '../../services/storey.js';
 export function resolveStairTotalRise(stair, nodes) {
     if (stair.totalRise !== undefined)
         return stair.totalRise;
     const level = Object.values(nodes).find((node) => node.type === 'level' && node.children.includes(stair.id));
+    // Both destinations are absolute level-local heights, while the stair's own
+    // base may be lifted onto a floor slab by the floor-stack
+    // (`FloorElevationSystem` / `syncStairGroupElevation` put the group at
+    // `position[1] + elected slab elevation`). The rise is measured from that
+    // base, so subtract it — electing the base exactly the way the visual
+    // systems do (persisted `supportSlabId` honored, uncapped election
+    // otherwise) keeps base + rise landing precisely on the destination surface.
+    const baseElevation = getFloorStackedPosition({
+        node: stair,
+        nodes,
+        position: stair.position,
+        rotation: stair.rotation,
+        levelId: level?.id ?? null,
+    })[1];
     if (stair.deckSlabId) {
+        // The deck's `elevation` IS its walking surface (level-local). A stale
+        // reference (deck gone) falls through to the level-derived rise.
         const deck = nodes[stair.deckSlabId];
-        // The deck's `elevation` IS its walking surface (level-local), but the
-        // stair's own base may be lifted onto a floor slab by the floor-stack
-        // (`FloorElevationSystem` / `syncStairGroupElevation` put the group at
-        // `position[1] + elected slab elevation`). The rise is measured from
-        // that base, so subtract it — electing the base exactly the way the
-        // visual systems do (persisted `supportSlabId` honored, uncapped
-        // election otherwise) keeps base + rise landing precisely on the deck's
-        // walking surface. A stale reference (deck gone) falls through to the
-        // level-derived rise.
-        if (deck?.type === 'slab') {
-            const baseElevation = getFloorStackedPosition({
-                node: stair,
-                nodes,
-                position: stair.position,
-                rotation: stair.rotation,
-                levelId: level?.id ?? null,
-            })[1];
+        if (deck?.type === 'slab')
             return (deck.elevation ?? 0.05) - baseElevation;
-        }
     }
-    return level?.type === 'level'
-        ? getLevelFloorToFloorHeight(level.id, nodes)
-        : DEFAULT_LEVEL_HEIGHT;
+    if (level?.type !== 'level')
+        return DEFAULT_LEVEL_HEIGHT;
+    return getLevelFloorToFloorHeight(level.id, nodes) - baseElevation;
 }
 const RISE_SYNC_EPSILON = 1e-4;
 /**

package/dist/systems/wall/wall-curve.d.ts

@@ -1,5 +1,5 @@
-import type { FenceNode, WallNode } from '../../schema';
-import type { Point2D } from './wall-mitering';
+import type { FenceNode, WallNode } from '../../schema/index.js';
+import type { Point2D } from './wall-mitering.js';
 type WallCurveLike = Pick<WallNode | FenceNode, 'start' | 'end' | 'curveOffset'>;
 type CurveFrame = {
     point: Point2D;
@@ -47,6 +47,7 @@ export declare function getWallArcData(wall: WallCurveLike): {
 export declare function getWallCurveFrameAt(wall: WallCurveLike, t: number): CurveFrame;
 export declare function getWallMidpointHandlePoint(wall: WallCurveLike): Point2D;
 export declare function sampleWallCenterline(wall: WallCurveLike, segments?: number): Point2D[];
+export declare function constrainWallCurveOffsetToAvoidIntersections(wall: WallNode, proposedOffset: number, walls: readonly WallNode[]): number;
 export declare function getWallCurveLength(wall: WallCurveLike, segments?: number): number;
 export declare function getWallSurfacePolygon(wall: Pick<WallNode | FenceNode, 'start' | 'end' | 'curveOffset' | 'thickness'>, segments?: number, miterOverrides?: WallSurfaceMiterOverrides): Point2D[];
 export {};

package/dist/systems/wall/wall-curve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wall-curve.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-curve.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AACvD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AAK9C,KAAK,aAAa,GAAG,IAAI,CAAC,QAAQ,GAAG,SAAS,EAAE,OAAO,GAAG,KAAK,GAAG,aAAa,CAAC,CAAA;AAEhF,KAAK,UAAU,GAAG;IAChB,KAAK,EAAE,OAAO,CAAA;IACd,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,EAAE,OAAO,CAAA;CAChB,CAAA;AAED,KAAK,yBAAyB,GAAG;IAC/B,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,CAAA;AAcD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAE9D;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAE5D;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,aAAa,UAErD;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,aAAa,UAExD;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,aAAa,UAE5D;AAWD,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,UAG3E;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,aAAa,UAI5D;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,aAAa,WAE/C;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,aAAa;;;;;;;;;;;;;EA6BpD;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,aAAa;;;;;;;;;SA2BjD;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,aAAa,EAAE,CAAC,EAAE,MAAM,GAAG,UAAU,CAwC9E;AAED,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,aAAa,WAE7D;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,aAAa,EAAE,QAAQ,SAA0B,aAM3F;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,aAAa,EAAE,QAAQ,SAA0B,UASzF;AAED,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,IAAI,CAAC,QAAQ,GAAG,SAAS,EAAE,OAAO,GAAG,KAAK,GAAG,aAAa,GAAG,WAAW,CAAC,EAC/E,QAAQ,SAA0B,EAClC,cAAc,CAAC,EAAE,yBAAyB,aA2B3C"}
+{"version":3,"file":"wall-curve.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-curve.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AACvD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AAO9C,KAAK,aAAa,GAAG,IAAI,CAAC,QAAQ,GAAG,SAAS,EAAE,OAAO,GAAG,KAAK,GAAG,aAAa,CAAC,CAAA;AAEhF,KAAK,UAAU,GAAG;IAChB,KAAK,EAAE,OAAO,CAAA;IACd,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,EAAE,OAAO,CAAA;CAChB,CAAA;AAED,KAAK,yBAAyB,GAAG;IAC/B,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,CAAA;AAcD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAE9D;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAE5D;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,aAAa,UAErD;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,aAAa,UAExD;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,aAAa,UAE5D;AAWD,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,UAG3E;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,aAAa,UAI5D;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,aAAa,WAE/C;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,aAAa;;;;;;;;;;;;;EA6BpD;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,aAAa;;;;;;;;;SA2BjD;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,aAAa,EAAE,CAAC,EAAE,MAAM,GAAG,UAAU,CAwC9E;AAED,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,aAAa,WAE7D;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,aAAa,EAAE,QAAQ,SAA0B,aAM3F;AAgED,wBAAgB,4CAA4C,CAC1D,IAAI,EAAE,QAAQ,EACd,cAAc,EAAE,MAAM,EACtB,KAAK,EAAE,SAAS,QAAQ,EAAE,UAoB3B;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,aAAa,EAAE,QAAQ,SAA0B,UASzF;AAED,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,IAAI,CAAC,QAAQ,GAAG,SAAS,EAAE,OAAO,GAAG,KAAK,GAAG,aAAa,GAAG,WAAW,CAAC,EAC/E,QAAQ,SAA0B,EAClC,cAAc,CAAC,EAAE,yBAAyB,aA2B3C"}

package/dist/systems/wall/wall-curve.js

@@ -1,5 +1,7 @@
 const CURVE_EPSILON = 1e-6;
 const DEFAULT_SAMPLE_SEGMENTS = 24;
+const CURVE_INTERSECTION_SEARCH_STEPS = 20;
+const CURVE_INTERSECTION_TOLERANCE = 1e-6;
 function clamp01(value) {
     return Math.max(0, Math.min(1, value));
 }
@@ -142,6 +144,77 @@ export function sampleWallCenterline(wall, segments = DEFAULT_SAMPLE_SEGMENTS) {
     const count = Math.max(1, segments);
     return Array.from({ length: count + 1 }, (_, index) => getWallCurveFrameAt(wall, index / count).point);
 }
+function segmentIntersectionPoint(a, b, c, d) {
+    const abX = b.x - a.x;
+    const abY = b.y - a.y;
+    const cdX = d.x - c.x;
+    const cdY = d.y - c.y;
+    const denominator = abX * cdY - abY * cdX;
+    if (Math.abs(denominator) <= CURVE_INTERSECTION_TOLERANCE)
+        return null;
+    const acX = c.x - a.x;
+    const acY = c.y - a.y;
+    const t = (acX * cdY - acY * cdX) / denominator;
+    const u = (acX * abY - acY * abX) / denominator;
+    if (t < -CURVE_INTERSECTION_TOLERANCE ||
+        t > 1 + CURVE_INTERSECTION_TOLERANCE ||
+        u < -CURVE_INTERSECTION_TOLERANCE ||
+        u > 1 + CURVE_INTERSECTION_TOLERANCE) {
+        return null;
+    }
+    return { x: a.x + t * abX, y: a.y + t * abY };
+}
+function pointMatchesEndpoint(point, wall) {
+    return [getWallStartPoint(wall), getWallEndPoint(wall)].some((endpoint) => distance(point, endpoint) <= CURVE_INTERSECTION_TOLERANCE);
+}
+function wallCurveIntersectsSibling(wall, sibling) {
+    const wallPoints = sampleWallCenterline(wall);
+    const siblingPoints = sampleWallCenterline(sibling);
+    for (let wallIndex = 0; wallIndex < wallPoints.length - 1; wallIndex += 1) {
+        const wallStart = wallPoints[wallIndex];
+        const wallEnd = wallPoints[wallIndex + 1];
+        for (let siblingIndex = 0; siblingIndex < siblingPoints.length - 1; siblingIndex += 1) {
+            const siblingStart = siblingPoints[siblingIndex];
+            const siblingEnd = siblingPoints[siblingIndex + 1];
+            const intersection = segmentIntersectionPoint(wallStart, wallEnd, siblingStart, siblingEnd);
+            if (!intersection)
+                continue;
+            if (pointMatchesEndpoint(intersection, wall) && pointMatchesEndpoint(intersection, sibling)) {
+                continue;
+            }
+            return true;
+        }
+    }
+    return false;
+}
+function wallCurveIntersectsSiblings(wall, walls) {
+    if (!isCurvedWall(wall))
+        return false;
+    return walls.some((sibling) => sibling.id !== wall.id &&
+        sibling.parentId === wall.parentId &&
+        wallCurveIntersectsSibling(wall, sibling));
+}
+export function constrainWallCurveOffsetToAvoidIntersections(wall, proposedOffset, walls) {
+    const currentOffset = normalizeWallCurveOffset(wall, wall.curveOffset ?? 0);
+    const normalizedProposal = normalizeWallCurveOffset(wall, proposedOffset);
+    const proposedWall = { ...wall, curveOffset: normalizedProposal };
+    if (!wallCurveIntersectsSiblings(proposedWall, walls))
+        return normalizedProposal;
+    const currentWall = { ...wall, curveOffset: currentOffset };
+    if (wallCurveIntersectsSiblings(currentWall, walls))
+        return currentOffset;
+    let safeOffset = currentOffset;
+    let blockedOffset = normalizedProposal;
+    for (let index = 0; index < CURVE_INTERSECTION_SEARCH_STEPS; index += 1) {
+        const candidateOffset = (safeOffset + blockedOffset) / 2;
+        const candidateWall = { ...wall, curveOffset: candidateOffset };
+        if (wallCurveIntersectsSiblings(candidateWall, walls))
+            blockedOffset = candidateOffset;
+        else
+            safeOffset = candidateOffset;
+    }
+    return normalizeWallCurveOffset(wall, safeOffset);
+}
 export function getWallCurveLength(wall, segments = DEFAULT_SAMPLE_SEGMENTS) {
     const points = sampleWallCenterline(wall, segments);
     let totalLength = 0;

package/dist/systems/wall/wall-footprint.d.ts

@@ -1,5 +1,6 @@
-import type { WallNode } from '../../schema';
-import { type Point2D, type WallMiterData } from './wall-mitering';
+import type { WallNode } from '../../schema/index.js';
+import { type Point2D, type WallMiterData } from './wall-mitering.js';
+export { calculateLevelMiters, type Point2D, type WallMiterData } from './wall-mitering.js';
 export declare const DEFAULT_WALL_THICKNESS = 0.1;
 export declare const DEFAULT_WALL_HEIGHT = 2.5;
 export declare function getWallThickness(wallNode: WallNode): number;

package/dist/systems/wall/wall-footprint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wall-footprint.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-footprint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAE5C,OAAO,EAEL,KAAK,OAAO,EAEZ,KAAK,aAAa,EACnB,MAAM,iBAAiB,CAAA;AAExB,eAAO,MAAM,sBAAsB,MAAM,CAAA;AACzC,eAAO,MAAM,mBAAmB,MAAM,CAAA;AAGtC,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAE3D;AAED,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,aAAa,GAAG,OAAO,EAAE,CA6D5F"}
+{"version":3,"file":"wall-footprint.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-footprint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAE5C,OAAO,EAEL,KAAK,OAAO,EAEZ,KAAK,aAAa,EACnB,MAAM,iBAAiB,CAAA;AAExB,OAAO,EAAE,oBAAoB,EAAE,KAAK,OAAO,EAAE,KAAK,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAExF,eAAO,MAAM,sBAAsB,MAAM,CAAA;AACzC,eAAO,MAAM,mBAAmB,MAAM,CAAA;AAGtC,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAE3D;AAED,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,EAAE,SAAS,EAAE,aAAa,GAAG,OAAO,EAAE,CA6D5F"}

package/dist/systems/wall/wall-footprint.js

@@ -1,5 +1,6 @@
-import { getWallSurfacePolygon, isCurvedWall } from './wall-curve';
-import { getWallMiterBoundaryPoints, pointToKey, } from './wall-mitering';
+import { getWallSurfacePolygon, isCurvedWall } from './wall-curve.js';
+import { getWallMiterBoundaryPoints, pointToKey, } from './wall-mitering.js';
+export { calculateLevelMiters } from './wall-mitering.js';
 export const DEFAULT_WALL_THICKNESS = 0.1;
 export const DEFAULT_WALL_HEIGHT = 2.5;
 const CURVED_WALL_SURFACE_SEGMENTS = 24;

package/dist/systems/wall/wall-mitering.d.ts

@@ -1,4 +1,4 @@
-import type { WallNode } from '../../schema';
+import type { WallNode } from '../../schema/index.js';
 export interface Point2D {
     x: number;
     y: number;

package/dist/systems/wall/wall-mitering.js

@@ -1,4 +1,4 @@
-import { getWallCurveFrameAt, isCurvedWall } from './wall-curve';
+import { getWallCurveFrameAt, isCurvedWall } from './wall-curve.js';
 // ============================================================================
 // UTILITY FUNCTIONS
 // ============================================================================

package/dist/systems/wall/wall-move.d.ts

@@ -1,4 +1,4 @@
-import type { WallNode } from '../../schema';
+import type { WallNode } from '../../schema/index.js';
 export type WallPlanPoint = [number, number];
 export type WallMoveAxis = [number, number];
 export type WallMoveEndpoint = 'start' | 'end';

package/dist/systems/wall/wall-top.d.ts

@@ -1,4 +1,4 @@
-import type { WallNode } from '../../schema/nodes/wall';
+import type { WallNode } from '../../schema/nodes/wall.js';
 /**
  * Minimum wall body height in meters. Governs both the wall height
  * arrow's lower drag bound and the slab-elevation clamp: a slab may not

package/dist/systems/wall/wall-topology.d.ts

@@ -1,5 +1,5 @@
-import { type AnyNode, type AnyNodeId, type WallNode } from '../../schema';
-import type { WallPlanPoint } from './wall-move';
+import { type AnyNode, type AnyNodeId, type WallNode } from '../../schema/index.js';
+import type { WallPlanPoint } from './wall-move.js';
 export type WallTopologyChanges = {
     create: Array<{
         node: AnyNode;

package/dist/systems/wall/wall-topology.js

@@ -1,7 +1,7 @@
-import { GROUND_SUPPORT_ID } from '../../hooks/spatial-grid/support-host-id';
-import { terrainSupportLift } from '../../lib/terrain-support';
-import { getScaledDimensions, WallNode as WallSchema, } from '../../schema';
-import { getWallArcData, getWallCurveFrameAt, getWallCurveLength, isCurvedWall } from './wall-curve';
+import { GROUND_SUPPORT_ID } from '../../hooks/spatial-grid/support-host-id.js';
+import { terrainSupportLift } from '../../lib/terrain-support.js';
+import { getScaledDimensions, WallNode as WallSchema, } from '../../schema/index.js';
+import { getWallArcData, getWallCurveFrameAt, getWallCurveLength, isCurvedWall } from './wall-curve.js';
 const WALL_MIN_LENGTH = 0.01;
 const WALL_SPLIT_ENDPOINT_EPSILON = 0.02;
 const WALL_INTERSECTION_EPSILON = 1e-6;

package/dist/utils/clone-scene-graph.d.ts

@@ -1,6 +1,6 @@
-import type { AnyNode, AnyNodeId } from '../schema';
-import type { Collection, CollectionId } from '../schema/collections';
-import type { SceneMaterial, SceneMaterialId } from '../schema/scene-material';
+import type { AnyNode, AnyNodeId } from '../schema/index.js';
+import type { Collection, CollectionId } from '../schema/collections.js';
+import type { SceneMaterial, SceneMaterialId } from '../schema/scene-material.js';
 export type SceneGraph = {
     nodes: Record<AnyNodeId, AnyNode>;
     rootNodeIds: AnyNodeId[];

package/dist/utils/clone-scene-graph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clone-scene-graph.d.ts","sourceRoot":"","sources":["../../src/utils/clone-scene-graph.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAEnD,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AACrE,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAE9E,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,WAAW,EAAE,SAAS,EAAE,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC,YAAY,EAAE,UAAU,CAAC,CAAA;IAC9C,SAAS,CAAC,EAAE,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,CAAA;IAClD,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC5B,CAAA;AAUD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,UAAU,GAAG,UAAU,CA6IlE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,OAAO,EAAE,SAAS,GACjB;IAAE,WAAW,EAAE,OAAO,EAAE,CAAC;IAAC,UAAU,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAsG/E;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB,CAAA;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,UAAU,EACtB,OAAO,GAAE,qBAA0B,GAClC,UAAU,CA0EZ"}
+{"version":3,"file":"clone-scene-graph.d.ts","sourceRoot":"","sources":["../../src/utils/clone-scene-graph.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAEnD,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AACrE,OAAO,KAAK,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAA;AAE9E,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,WAAW,EAAE,SAAS,EAAE,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC,YAAY,EAAE,UAAU,CAAC,CAAA;IAC9C,SAAS,CAAC,EAAE,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,CAAA;IAClD,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC5B,CAAA;AAUD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,UAAU,GAAG,UAAU,CAqKlE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,OAAO,EAAE,SAAS,GACjB;IAAE,WAAW,EAAE,OAAO,EAAE,CAAC;IAAC,UAAU,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAqH/E;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB,CAAA;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,UAAU,EACtB,OAAO,GAAE,qBAA0B,GAClC,UAAU,CA0EZ"}

package/dist/utils/clone-scene-graph.js

@@ -1,6 +1,6 @@
-import { GROUND_SUPPORT_ID } from '../hooks/spatial-grid/floor-placed-elevation';
-import { remapConstructionDimensionReferences, remapMeasurementReferences, } from '../lib/measurement-geometry';
-import { generateId } from '../schema/base';
+import { GROUND_SUPPORT_ID } from '../hooks/spatial-grid/floor-placed-elevation.js';
+import { remapConstructionDimensionReferences, remapMeasurementReferences, } from '../lib/measurement-geometry.js';
+import { generateId } from '../schema/base.js';
 /**
  * Extracts the type prefix from a node ID (e.g., "wall_abc123" -> "wall")
  */
@@ -64,6 +64,18 @@ export function cloneSceneGraph(sceneGraph) {
             ;
             clonedNode.roofSegmentId = idMap.get(clonedNode.roofSegmentId);
         }
+        if ('hostRoofId' in clonedNode && typeof clonedNode.hostRoofId === 'string') {
+            ;
+            clonedNode.hostRoofId = idMap.get(clonedNode.hostRoofId);
+        }
+        if ('hostRoofSegmentId' in clonedNode && typeof clonedNode.hostRoofSegmentId === 'string') {
+            ;
+            clonedNode.hostRoofSegmentId = idMap.get(clonedNode.hostRoofSegmentId);
+        }
+        if (clonedNode.type === 'roof' && clonedNode.support?.kind === 'roof') {
+            clonedNode.support.roofSegmentId = (idMap.get(clonedNode.support.roofSegmentId) ??
+                clonedNode.support.roofSegmentId);
+        }
         // Remap supportSlabId (persisted slab-support hosts). The 'ground'
         // sentinel is not a node id — keep it as-is.
         if ('supportSlabId' in clonedNode &&
@@ -72,6 +84,12 @@ export function cloneSceneGraph(sceneGraph) {
             ;
             clonedNode.supportSlabId = idMap.get(clonedNode.supportSlabId);
         }
+        if (clonedNode.type === 'unit') {
+            clonedNode.members = clonedNode.members.flatMap((id) => {
+                const remapped = idMap.get(id);
+                return remapped ? [remapped] : [];
+            });
+        }
         if ('deckSlabId' in clonedNode && typeof clonedNode.deckSlabId === 'string') {
             ;
             clonedNode.deckSlabId = idMap.get(clonedNode.deckSlabId);
@@ -223,6 +241,20 @@ export function cloneLevelSubtree(nodes, levelId) {
             cloned.roofSegmentId =
                 idMap.get(cloned.roofSegmentId) ?? cloned.roofSegmentId;
         }
+        if ('hostRoofId' in cloned && typeof cloned.hostRoofId === 'string') {
+            ;
+            cloned.hostRoofId =
+                idMap.get(cloned.hostRoofId) ?? cloned.hostRoofId;
+        }
+        if ('hostRoofSegmentId' in cloned && typeof cloned.hostRoofSegmentId === 'string') {
+            ;
+            cloned.hostRoofSegmentId =
+                idMap.get(cloned.hostRoofSegmentId) ?? cloned.hostRoofSegmentId;
+        }
+        if (cloned.type === 'roof' && cloned.support?.kind === 'roof') {
+            cloned.support.roofSegmentId = (idMap.get(cloned.support.roofSegmentId) ??
+                cloned.support.roofSegmentId);
+        }
         // Remap supportSlabId when the host slab is inside the cloned subtree;
         // preserve it otherwise (like wallId, the reference may point outside).
         if ('supportSlabId' in cloned && typeof cloned.supportSlabId === 'string') {