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

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-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,6 +1,7 @@
 'use client';
-import { useEffect, useRef } from 'react';
+import { useEffect } from 'react';
 import { pauseSceneHistory, resumeSceneHistory } from '../../store/history-control';
+import { queueSceneNormalization } from '../../store/scene-hydration';
 import useLiveNodeOverrides from '../../store/use-live-node-overrides';
 import useLiveTransforms from '../../store/use-live-transforms';
 import useScene from '../../store/use-scene';
@@ -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.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

@@ -5,31 +5,30 @@ 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

@@ -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';
+export { calculateLevelMiters, type Point2D, type WallMiterData } from './wall-mitering';
 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';
+export { calculateLevelMiters } from './wall-mitering';
 export const DEFAULT_WALL_THICKNESS = 0.1;
 export const DEFAULT_WALL_HEIGHT = 2.5;
 const CURVED_WALL_SURFACE_SEGMENTS = 24;

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,CA8JlE;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

@@ -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 &&
@@ -223,6 +235,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') {

package/dist/validation/validate-build-json.d.ts

@@ -1,3 +1,4 @@
+import { SceneMaterial } from '../schema/scene-material';
 import { type AnyNodeType } from '../schema/types';
 export type ValidationSeverity = 'error' | 'warning';
 export type ValidationIssue = {
@@ -18,6 +19,8 @@ export type ParsedBuildJson = {
     nodes: Record<string, unknown>;
     rootNodeIds: string[];
     installedPlugins?: string[];
+    /** Scene materials referenced by node `slots` (`scene:<id>`). */
+    materials?: Record<string, SceneMaterial>;
 };
 export type SchemaIssue = {
     nodeId: string;

package/dist/validation/validate-build-json.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validate-build-json.d.ts","sourceRoot":"","sources":["../../src/validation/validate-build-json.ts"],"names":[],"mappings":"AACA,OAAO,EAAW,KAAK,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAG3D,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,SAAS,CAAA;AAEpD,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,EAAE,kBAAkB,CAAA;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC,CAAA;IAC5C,iFAAiF;IACjF,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACpC,WAAW,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,WAAW,EAAE,MAAM,EAAE,CAAA;IACrB,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC5B,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,uBAAuB,GAAG;IACpC,EAAE,EAAE,OAAO,CAAA;IACX,MAAM,EAAE,eAAe,GAAG,IAAI,CAAA;IAC9B,KAAK,EAAE,UAAU,CAAA;IACjB,MAAM,EAAE,eAAe,EAAE,CAAA;IACzB,QAAQ,EAAE,eAAe,EAAE,CAAA;IAC3B,YAAY,EAAE,WAAW,EAAE,CAAA;IAC3B,gBAAgB,EAAE,MAAM,CAAA;CACzB,CAAA;AA8BD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,uBAAuB,CA8SzE"}
+{"version":3,"file":"validate-build-json.d.ts","sourceRoot":"","sources":["../../src/validation/validate-build-json.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AACxD,OAAO,EAAW,KAAK,WAAW,EAAc,MAAM,iBAAiB,CAAA;AAGvE,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,SAAS,CAAA;AAEpD,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,EAAE,kBAAkB,CAAA;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC,CAAA;IAC5C,iFAAiF;IACjF,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACpC,WAAW,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,WAAW,EAAE,MAAM,EAAE,CAAA;IACrB,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;IAC3B,iEAAiE;IACjE,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;CAC1C,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,uBAAuB,GAAG;IACpC,EAAE,EAAE,OAAO,CAAA;IACX,MAAM,EAAE,eAAe,GAAG,IAAI,CAAA;IAC9B,KAAK,EAAE,UAAU,CAAA;IACjB,MAAM,EAAE,eAAe,EAAE,CAAA;IACzB,QAAQ,EAAE,eAAe,EAAE,CAAA;IAC3B,YAAY,EAAE,WAAW,EAAE,CAAA;IAC3B,gBAAgB,EAAE,MAAM,CAAA;CACzB,CAAA;AA4BD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,uBAAuB,CA4VzE"}

package/dist/validation/validate-build-json.js

@@ -1,7 +1,8 @@
 import { nodeRegistry } from '../registry';
-import { AnyNode } from '../schema/types';
+import { SceneMaterial } from '../schema/scene-material';
+import { AnyNode, nodeKindOf } from '../schema/types';
 import { healSceneNodes } from '../utils/heal-scene-graph';
-const KNOWN_TYPES = new Set(AnyNode.options.map((o) => o.shape.type.parse(undefined)));
+const KNOWN_TYPES = new Set(AnyNode.options.map(nodeKindOf));
 function isPlainObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
@@ -61,6 +62,7 @@ export function validateBuildJson(input) {
     const nodesRaw = input.nodes;
     const rootNodeIdsRaw = input.rootNodeIds;
     const installedPluginsRaw = input.installedPlugins;
+    const materialsRaw = input.materials;
     if (!isPlainObject(nodesRaw)) {
         errors.push({
             severity: 'error',
@@ -102,6 +104,50 @@ export function validateBuildJson(input) {
             message: 'Ignored invalid "installedPlugins" — expected an array of plugin IDs.',
         });
     }
+    // Scene materials ride along with the graph: nodes reference them by
+    // `scene:<id>` slot refs, so dropping the table here silently strips
+    // every custom finish from the imported scene. Invalid entries are
+    // skipped one by one — a bad material must not take the import down.
+    //
+    // DELIBERATE: `safeParse().data` NORMALIZES — defaults are injected
+    // and unknown keys dropped. That is the opposite of the API boundary
+    // (`apiGraphSchema` preserves unknown fields on purpose), and it is
+    // chosen here because import feeds the live scene store, which only
+    // understands schema-shaped materials; a hand-edited file with a
+    // half-formed material should land as something the renderer can
+    // draw, not round-trip garbage.
+    let materials;
+    if (isPlainObject(materialsRaw)) {
+        const skippedIds = [];
+        const kept = {};
+        for (const [id, value] of Object.entries(materialsRaw)) {
+            const result = SceneMaterial.safeParse(value);
+            if (result.success) {
+                kept[id] = result.data;
+            }
+            else {
+                skippedIds.push(id);
+            }
+        }
+        if (Object.keys(kept).length > 0)
+            materials = kept;
+        if (skippedIds.length > 0) {
+            // Name the ids: the audience is hand-edited files, and a count
+            // alone leaves nothing to repair by.
+            warnings.push({
+                severity: 'warning',
+                code: 'invalid_materials',
+                message: `Ignored ${skippedIds.length} invalid scene material${skippedIds.length === 1 ? '' : 's'}: ${skippedIds.join(', ')}.`,
+            });
+        }
+    }
+    else if (materialsRaw !== undefined) {
+        warnings.push({
+            severity: 'warning',
+            code: 'invalid_materials',
+            message: 'Ignored invalid "materials" — expected an object of id → material.',
+        });
+    }
     if (strippedChildRefs > 0 || droppedWallIds.length > 0) {
         warnings.push({
             severity: 'warning',
@@ -301,6 +347,7 @@ export function validateBuildJson(input) {
                 nodes,
                 rootNodeIds,
                 ...(installedPlugins ? { installedPlugins } : {}),
+                ...(materials ? { materials } : {}),
             }
             : null,
         stats,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pascal-app/core",
-  "version": "1.0.0-beta.5",
+  "version": "1.0.0",
   "description": "Core library for Pascal 3D building editor",
   "type": "module",
   "main": "./dist/index.js",
@@ -21,6 +21,11 @@
       "import": "./dist/utils/scene-migrations.js",
       "default": "./dist/utils/scene-migrations.js"
     },
+    "./capture": {
+      "types": "./dist/capture/index.d.ts",
+      "import": "./dist/capture/index.js",
+      "default": "./dist/capture/index.js"
+    },
     "./registry": {
       "types": "./dist/registry/index.d.ts",
       "import": "./dist/registry/index.js",
@@ -66,20 +71,21 @@
     "dev": "tsgo --build --watch",
     "test": "bun test src",
     "bench:registry": "bun run src/registry/__bench__/relations-resolver.bench.ts",
+    "bench:schema": "bun run src/schema/__bench__/node-parsers.bench.ts",
     "prepublishOnly": "npm run build"
   },
   "peerDependencies": {
     "@react-three/drei": "^10",
     "@react-three/fiber": "^9",
     "react": "^18 || ^19",
-    "three": "^0.185"
+    "three": "^0.186"
   },
   "dependencies": {
     "dedent": "^1.7.1",
     "idb-keyval": "^6.2.2",
     "mitt": "^3.0.1",
     "nanoid": "^5.1.6",
-    "zod": "^4.3.5",
+    "zod": ">=4.5.4 <4.6",
     "zundo": "^2.3.0",
     "zustand": "^5"
   },
@@ -88,6 +94,7 @@
     "@types/bun": "^1.3.0",
     "@types/react": "^19.2.2",
     "@types/three": "^0.184.0",
+    "fake-indexeddb": "^6.2.5",
     "typescript": "6.0.3"
   },
   "keywords": [

package/dist/systems/elevator/elevator-runtime-system.d.ts

@@ -1,2 +0,0 @@
-export declare function ElevatorRuntimeSystem(): null;
-//# sourceMappingURL=elevator-runtime-system.d.ts.map

package/dist/systems/elevator/elevator-runtime-system.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"elevator-runtime-system.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-runtime-system.tsx"],"names":[],"mappings":"AAGA,wBAAgB,qBAAqB,SAMpC"}

package/dist/systems/elevator/elevator-runtime-system.js

@@ -1,8 +0,0 @@
-import { useFrame } from '@react-three/fiber';
-import { stepElevatorRuntimes } from './elevator-runtime';
-export function ElevatorRuntimeSystem() {
-    useFrame(({ clock }, delta) => {
-        stepElevatorRuntimes(clock.getElapsedTime() * 1000, delta);
-    }, 2);
-    return null;
-}