@pascal-app/core 1.0.0-beta.4 → 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.js

@@ -1,33 +1,34 @@
 import { getFloorStackedPosition } from '../../hooks/spatial-grid/floor-placed-elevation';
 import { DEFAULT_LEVEL_HEIGHT } from '../../services/level-height';
-import { getStoredLevelHeight } from '../../services/storey';
+import { getLevelFloorToFloorHeight } from '../../services/storey';
 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' ? getStoredLevelHeight(level) : 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/systems/wall/wall-mitering.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wall-mitering.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-mitering.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAO5C,MAAM,WAAW,OAAO;IACtB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAED,MAAM,WAAW,uBAAuB;IACtC,SAAS,EAAE,OAAO,CAAA;IAClB,UAAU,EAAE,OAAO,CAAA;IACnB,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,OAAO,CAAA;CAClB;AASD,KAAK,iBAAiB,GAAG,GAAG,CAAC,MAAM,EAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC,CAAA;AAGzE,KAAK,YAAY,GAAG,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAA;AAmBlD,iBAAS,UAAU,CAAC,CAAC,EAAE,OAAO,EAAE,SAAS,SAAY,GAAG,MAAM,CAG7D;AA8CD,UAAU,QAAQ;IAChB,YAAY,EAAE,OAAO,CAAA;IACrB,cAAc,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,QAAQ,CAAC;QAAC,OAAO,EAAE,OAAO,GAAG,KAAK,GAAG,aAAa,CAAA;KAAE,CAAC,CAAA;CACpF;AAkPD,MAAM,WAAW,aAAa;IAE5B,YAAY,EAAE,YAAY,CAAA;IAE1B,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;CACjC;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,aAAa,CAWrE;AAED,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,QAAQ,EACd,SAAS,EAAE,aAAa,GACvB,uBAAuB,GAAG,IAAI,CA0BhC;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,EAAE,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CA8C/F;AAGD,OAAO,EAAE,UAAU,EAAE,CAAA"}
+{"version":3,"file":"wall-mitering.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-mitering.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAO5C,MAAM,WAAW,OAAO;IACtB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAED,MAAM,WAAW,uBAAuB;IACtC,SAAS,EAAE,OAAO,CAAA;IAClB,UAAU,EAAE,OAAO,CAAA;IACnB,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,OAAO,CAAA;CAClB;AASD,KAAK,iBAAiB,GAAG,GAAG,CAAC,MAAM,EAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC,CAAA;AAGzE,KAAK,YAAY,GAAG,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAA;AAmBlD,iBAAS,UAAU,CAAC,CAAC,EAAE,OAAO,EAAE,SAAS,SAAY,GAAG,MAAM,CAG7D;AA8CD,UAAU,QAAQ;IAChB,YAAY,EAAE,OAAO,CAAA;IACrB,cAAc,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,QAAQ,CAAC;QAAC,OAAO,EAAE,OAAO,GAAG,KAAK,GAAG,aAAa,CAAA;KAAE,CAAC,CAAA;CACpF;AAyUD,MAAM,WAAW,aAAa;IAE5B,YAAY,EAAE,YAAY,CAAA;IAE1B,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;CACjC;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,aAAa,CAWrE;AAED,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,QAAQ,EACd,SAAS,EAAE,aAAa,GACvB,uBAAuB,GAAG,IAAI,CA0BhC;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,EAAE,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CA8C/F;AAGD,OAAO,EAAE,UAAU,EAAE,CAAA"}

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

@@ -52,6 +52,49 @@ function pointOnWallSegment(point, wall, tolerance = TOLERANCE) {
     const dist = Math.sqrt((point.x - projX) ** 2 + (point.y - projY) ** 2);
     return dist < tolerance;
 }
+// --- Uniform grid used to prefilter T-junction candidates --------------------
+// 2 m cells: small enough that a dense imported floor spreads across many
+// buckets, large enough that an ordinary room wall touches only a few.
+const JUNCTION_GRID_CELL = 2.0;
+// A wall whose AABB would touch more than this many cells (a very long diagonal)
+// is kept in a fallback list checked against every junction. Such walls are rare,
+// and a model made only of them is a model with very few walls — where the naive
+// scan was never the problem.
+const JUNCTION_GRID_MAX_CELLS_PER_WALL = 64;
+function cellKey(x, y) {
+    return `${Math.floor(x / JUNCTION_GRID_CELL)},${Math.floor(y / JUNCTION_GRID_CELL)}`;
+}
+function buildJunctionGrid(walls) {
+    const grid = new Map();
+    const oversized = [];
+    for (const wall of walls) {
+        // Pad by TOLERANCE so a point sitting exactly on the AABB edge still lands
+        // in a covered cell.
+        const minX = Math.min(wall.start[0], wall.end[0]) - TOLERANCE;
+        const maxX = Math.max(wall.start[0], wall.end[0]) + TOLERANCE;
+        const minY = Math.min(wall.start[1], wall.end[1]) - TOLERANCE;
+        const maxY = Math.max(wall.start[1], wall.end[1]) + TOLERANCE;
+        const cx0 = Math.floor(minX / JUNCTION_GRID_CELL);
+        const cx1 = Math.floor(maxX / JUNCTION_GRID_CELL);
+        const cy0 = Math.floor(minY / JUNCTION_GRID_CELL);
+        const cy1 = Math.floor(maxY / JUNCTION_GRID_CELL);
+        if ((cx1 - cx0 + 1) * (cy1 - cy0 + 1) > JUNCTION_GRID_MAX_CELLS_PER_WALL) {
+            oversized.push(wall);
+            continue;
+        }
+        for (let cx = cx0; cx <= cx1; cx++) {
+            for (let cy = cy0; cy <= cy1; cy++) {
+                const key = `${cx},${cy}`;
+                const bucket = grid.get(key);
+                if (bucket)
+                    bucket.push(wall);
+                else
+                    grid.set(key, [wall]);
+            }
+        }
+    }
+    return { grid, oversized };
+}
 function findJunctions(walls) {
     const junctions = new Map();
     // First pass: group walls by their endpoints
@@ -69,17 +112,47 @@ function findJunctions(walls) {
         }
         junctions.get(keyEnd)?.connectedWalls.push({ wall, endType: 'end' });
     }
-    // Second pass: detect T-junctions (walls passing through junction points)
+    // Second pass: detect T-junctions (walls passing through junction points).
+    //
+    // The naive form of this pass is `for each junction: for each wall` — O(J×N).
+    // On a real imported floor (1081 walls, 2047 endpoint keys) that is ~2.2M
+    // pointOnWallSegment calls and measured 584 ms per findJunctions() call, which
+    // WallSystem then repeats every frame while progressively rebuilding.
+    //
+    // A T-junction can only exist where the junction point lies ON the wall
+    // segment, so it must lie inside the wall's AABB. Bucketing walls by the grid
+    // cells their AABB covers therefore loses nothing: the cell containing the
+    // point is always one of the cells the wall was indexed into. With the input
+    // ordering restored below, the result matches the naive pass exactly; measured
+    // 11 ms on the same geometry.
+    const { grid, oversized } = buildJunctionGrid(walls);
+    const wallOrder = new Map(walls.map((wall, index) => [wall.id, index]));
     for (const [_key, junction] of junctions.entries()) {
-        for (const wall of walls) {
-            // Skip if wall already in this junction
-            if (junction.connectedWalls.some((cw) => cw.wall.id === wall.id))
+        const p = junction.meetingPoint;
+        const cellCandidates = grid.get(cellKey(p.x, p.y));
+        const passthrough = [];
+        for (const bucket of [cellCandidates, oversized]) {
+            if (!bucket || bucket.length === 0)
                 continue;
-            // Check if junction point lies on this wall's segment (not at endpoints)
-            if (pointOnWallSegment(junction.meetingPoint, wall)) {
-                junction.connectedWalls.push({ wall, endType: 'passthrough' });
+            for (const wall of bucket) {
+                // Skip if wall already in this junction
+                if (junction.connectedWalls.some((cw) => cw.wall.id === wall.id))
+                    continue;
+                // Check if junction point lies on this wall's segment (not at endpoints)
+                if (pointOnWallSegment(junction.meetingPoint, wall)) {
+                    passthrough.push(wall);
+                }
             }
         }
+        // Append in input order, not bucket order. Two collinear walls overlapping a
+        // junction tie on angle in `calculateJunctionIntersections`, so its stable
+        // sort leaves them in the order they were appended here — and an oversized
+        // wall would otherwise land after a shorter collinear neighbour it precedes
+        // in `walls`, picking the other wall's thickness for the miter.
+        passthrough.sort((a, b) => (wallOrder.get(a.id) ?? 0) - (wallOrder.get(b.id) ?? 0));
+        for (const wall of passthrough) {
+            junction.connectedWalls.push({ wall, endType: 'passthrough' });
+        }
     }
     // Filter to only junctions with 2+ walls
     const actualJunctions = new Map();
@@ -186,8 +259,14 @@ function calculateJunctionIntersections(junction, getThickness) {
             });
         }
     }
-    // Sort by outgoing angle
-    processedWalls.sort((a, b) => a.angle - b.angle);
+    // Sort by outgoing angle, then by wall ID so equal-angle walls produce the
+    // same pairing regardless of scene iteration order.
+    processedWalls.sort((a, b) => {
+        const angleOrder = a.angle - b.angle;
+        if (angleOrder !== 0)
+            return angleOrder;
+        return a.wallId < b.wallId ? -1 : a.wallId > b.wallId ? 1 : 0;
+    });
     const wallIntersections = new Map();
     const n = processedWalls.length;
     if (n < 2)

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

@@ -0,0 +1,53 @@
+import { type AnyNode, type AnyNodeId, type WallNode } from '../../schema';
+import type { WallPlanPoint } from './wall-move';
+export type WallTopologyChanges = {
+    create: Array<{
+        node: AnyNode;
+        parentId?: AnyNodeId;
+    }>;
+    update: Array<{
+        id: AnyNodeId;
+        data: Partial<AnyNode>;
+    }>;
+    delete: AnyNodeId[];
+};
+export type WallInsertionPlan = {
+    changes: WallTopologyChanges;
+    insertedWalls: WallNode[];
+    terminalWallId: WallNode['id'];
+    resolvedStart: WallPlanPoint;
+    resolvedEnd: WallPlanPoint;
+};
+export type WallTopologyRejection = {
+    ok: false;
+    reason: 'covered-existing-wall' | 'segment-too-short';
+};
+export type WallInsertionResult = {
+    ok: true;
+    plan: WallInsertionPlan;
+} | WallTopologyRejection;
+export type WallPointSplitPlan = {
+    changes: WallTopologyChanges;
+    point: WallPlanPoint;
+};
+export type WallPointSplitResult = {
+    ok: true;
+    plan: WallPointSplitPlan;
+} | {
+    ok: false;
+    reason: 'no-host';
+};
+export declare function planWallSplitAtPoint(nodes: Record<AnyNodeId, AnyNode>, args: {
+    levelId: AnyNodeId | null;
+    point: WallPlanPoint;
+    radius: number;
+    ignoreWallIds?: readonly string[];
+}): WallPointSplitResult;
+export declare function planWallInsertion(nodes: Record<AnyNodeId, AnyNode>, args: {
+    levelId: AnyNodeId;
+    start: WallPlanPoint;
+    end: WallPlanPoint;
+    joinRadius: number;
+    wallDefaults?: Partial<WallNode>;
+}): WallInsertionResult;
+//# sourceMappingURL=wall-topology.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wall-topology.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-topology.ts"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAId,KAAK,QAAQ,EAGd,MAAM,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAMhD,MAAM,MAAM,mBAAmB,GAAG;IAChC,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;KAAE,CAAC,CAAA;IACtD,MAAM,EAAE,KAAK,CAAC;QAAE,EAAE,EAAE,SAAS,CAAC;QAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,CAAC,CAAA;IACxD,MAAM,EAAE,SAAS,EAAE,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,mBAAmB,CAAA;IAC5B,aAAa,EAAE,QAAQ,EAAE,CAAA;IACzB,cAAc,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;IAC9B,aAAa,EAAE,aAAa,CAAA;IAC5B,WAAW,EAAE,aAAa,CAAA;CAC3B,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,EAAE,EAAE,KAAK,CAAA;IACT,MAAM,EAAE,uBAAuB,GAAG,mBAAmB,CAAA;CACtD,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,iBAAiB,CAAA;CAAE,GAAG,qBAAqB,CAAA;AAE/F,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,EAAE,mBAAmB,CAAA;IAC5B,KAAK,EAAE,aAAa,CAAA;CACrB,CAAA;AAED,MAAM,MAAM,oBAAoB,GAC5B;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,kBAAkB,CAAA;CAAE,GACtC;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,SAAS,CAAA;CAAE,CAAA;AA8GpC,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,IAAI,EAAE;IACJ,OAAO,EAAE,SAAS,GAAG,IAAI,CAAA;IACzB,KAAK,EAAE,aAAa,CAAA;IACpB,MAAM,EAAE,MAAM,CAAA;IACd,aAAa,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAClC,GACA,oBAAoB,CAqCtB;AA4OD,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,IAAI,EAAE;IACJ,OAAO,EAAE,SAAS,CAAA;IAClB,KAAK,EAAE,aAAa,CAAA;IACpB,GAAG,EAAE,aAAa,CAAA;IAClB,UAAU,EAAE,MAAM,CAAA;IAClB,YAAY,CAAC,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAA;CACjC,GACA,mBAAmB,CAiGrB"}