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

package/dist/store/use-scene.js

@@ -1,30 +1,37 @@
 'use client';
 import { temporal } from 'zundo';
 import { create } from 'zustand';
-import { parseMaterialRef, toSceneMaterialRef } from '../material-library';
-import { getNodePluginId, isNodeKindEnabled, nodeRegistry } from '../registry/registry';
-import { BuildingNode } from '../schema';
-import { generateCollectionId } from '../schema/collections';
-import { DoorNode as DoorNodeSchema } from '../schema/nodes/door';
-import { ElevatorNode as ElevatorNodeSchema } from '../schema/nodes/elevator';
-import { LevelNode, normalizeLevelBaseElevation } from '../schema/nodes/level';
-import { getPitchFromActiveRoofHeight, } from '../schema/nodes/roof-segment';
-import { segmentPointToRoofWallFace } from '../schema/nodes/roof-segment-walls';
-import { ShelfNode as ShelfNodeSchema } from '../schema/nodes/shelf';
-import { SiteNode } from '../schema/nodes/site';
-import { getEffectiveStairSurfaceMaterial, StairNode as StairNodeSchema, } from '../schema/nodes/stair';
-import { StairSegmentNode as StairSegmentNodeSchema } from '../schema/nodes/stair-segment';
-import { getEffectiveWallSurfaceMaterial } from '../schema/nodes/wall';
-import { WindowNode as WindowNodeSchema } from '../schema/nodes/window';
-import { generateSceneMaterialId, SceneMaterial, } from '../schema/scene-material';
-import { AnyNode as AnyNodeSchema } from '../schema/types';
-import { healSceneNodes } from '../utils/heal-scene-graph';
-import { removeRetiredDrawingSheetNodes } from '../utils/retired-scene-nodes';
-import { migrateVerticalSceneNodes } from '../utils/vertical-scene-migration';
-import * as nodeActions from './actions/node-actions';
-import { areSceneSnapshotsEqual, getSceneHistoryPauseDepth, notifySceneCommit, pauseSceneHistory, resetSceneHistoryPauseDepth, resumeSceneHistory, } from './history-control';
-import useLiveNodeOverrides from './use-live-node-overrides';
-import useLiveTransforms from './use-live-transforms';
+import { parseMaterialRef, toSceneMaterialRef } from '../material-library.js';
+import { getNodePluginId, isNodeKindEnabled, nodeRegistry } from '../registry/registry.js';
+import { BuildingNode } from '../schema/index.js';
+import { generateCollectionId } from '../schema/collections.js';
+import { compiledNodeSchema } from '../schema/compiled-node-parsers.js';
+import { DoorNode as DoorNodeSchema } from '../schema/nodes/door.js';
+import { createDormerDefaultWindow, DormerNode as DormerNodeSchema, getDormerDefaultWindowFace, } from '../schema/nodes/dormer.js';
+import { ElevatorNode as ElevatorNodeSchema } from '../schema/nodes/elevator.js';
+import { LevelNode, normalizeLevelBaseElevation } from '../schema/nodes/level.js';
+import { getPitchFromActiveRoofHeight, } from '../schema/nodes/roof-segment.js';
+import { segmentPointToRoofWallFace } from '../schema/nodes/roof-segment-walls.js';
+import { ShelfNode as ShelfNodeSchema } from '../schema/nodes/shelf.js';
+import { SiteNode } from '../schema/nodes/site.js';
+import { getEffectiveStairSurfaceMaterial, StairNode as StairNodeSchema, } from '../schema/nodes/stair.js';
+import { StairSegmentNode as StairSegmentNodeSchema } from '../schema/nodes/stair-segment.js';
+import { getEffectiveWallSurfaceMaterial } from '../schema/nodes/wall.js';
+import { WindowNode as WindowNodeSchema } from '../schema/nodes/window.js';
+import { generateSceneMaterialId, SceneMaterial, } from '../schema/scene-material.js';
+import { AnyNode as AnyNodeSchema } from '../schema/types.js';
+import { syncAutoElevatorOpenings } from '../systems/elevator/elevator-opening-sync.js';
+import { syncAutoStairOpenings } from '../systems/stair/stair-opening-sync.js';
+import { syncStairRises } from '../systems/stair/stair-rise.js';
+import { healSceneNodes } from '../utils/heal-scene-graph.js';
+import { removeRetiredDrawingSheetNodes } from '../utils/retired-scene-nodes.js';
+import { migrateVerticalSceneNodes } from '../utils/vertical-scene-migration.js';
+import * as nodeActions from './actions/node-actions.js';
+import { areSceneSnapshotsEqual, getSceneHistoryPauseDepth, notifySceneCommit, pauseSceneHistory, resetSceneHistoryPauseDepth, resumeSceneHistory, runWithSceneCommitNodeIds, } from './history-control.js';
+import { getHistoryDirtyNodeIds } from './history-invalidation.js';
+import { invalidatePendingHydration, isHydrationNormalization, queueSceneNormalization, runSceneHydration, } from './scene-hydration.js';
+import useLiveNodeOverrides from './use-live-node-overrides.js';
+import useLiveTransforms from './use-live-transforms.js';
 function getFiniteNumber(value, fallback) {
     return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
 }
@@ -82,7 +89,7 @@ function normalizeStairNode(node) {
         railingHeight: getFiniteNumber(node.railingHeight, 0.92),
         children: getStringArray(node.children),
     };
-    const parsed = StairNodeSchema.safeParse(sanitized);
+    const parsed = compiledNodeSchema(StairNodeSchema).safeParse(sanitized);
     if (!parsed.success)
         return null;
     if (hasTotalRise)
@@ -107,18 +114,18 @@ function normalizeStairSegmentNode(node) {
         fillToFloor: getBoolean(node.fillToFloor, true),
         thickness: getFiniteNumber(node.thickness, 0.25),
     };
-    const parsed = StairSegmentNodeSchema.safeParse(sanitized);
+    const parsed = compiledNodeSchema(StairSegmentNodeSchema).safeParse(sanitized);
     return parsed.success ? parsed.data : null;
 }
 function normalizeDoorNode(node) {
-    const parsed = DoorNodeSchema.safeParse(node);
+    const parsed = compiledNodeSchema(DoorNodeSchema).safeParse(node);
     return parsed.success ? { ...node, ...parsed.data } : null;
 }
 // Windows saved before a schema field existed (e.g. `columnRatios`/`rowRatios`/
 // `frameThickness`) load without it; the mesh builder then reads undefined and
 // throws every frame. Zod-parse on load so schema defaults land, like doors.
 function normalizeWindowNode(node) {
-    const parsed = WindowNodeSchema.safeParse(node);
+    const parsed = compiledNodeSchema(WindowNodeSchema).safeParse(node);
     return parsed.success ? { ...node, ...parsed.data } : null;
 }
 function normalizeShelfNode(node) {
@@ -139,7 +146,7 @@ function normalizeShelfNode(node) {
         withBottom: getBoolean(node.withBottom, false),
         bracketStyle: getEnumValue(node.bracketStyle, ['minimal', 'industrial', 'hidden'], 'minimal'),
     };
-    const parsed = ShelfNodeSchema.safeParse(sanitized);
+    const parsed = compiledNodeSchema(ShelfNodeSchema).safeParse(sanitized);
     return parsed.success ? parsed.data : null;
 }
 function normalizeElevatorNode(node) {
@@ -165,7 +172,7 @@ function normalizeElevatorNode(node) {
         doorDurationMs: getFiniteNumber(node.doorDurationMs, 900),
         dwellMs: getFiniteNumber(node.dwellMs, 1400),
     };
-    const parsed = ElevatorNodeSchema.safeParse(sanitized);
+    const parsed = compiledNodeSchema(ElevatorNodeSchema).safeParse(sanitized);
     return parsed.success ? parsed.data : null;
 }
 function findBuildingIdForLevel(levelId, nodes) {
@@ -295,6 +302,42 @@ function migrateSingleMaterialSlots(node, slotIds, mintedMaterials) {
         slots[slotId] = ref;
     return { ...node, slots, material: undefined, materialPreset: undefined };
 }
+function migrateRoleMaterialSlots(node, roles, mintedMaterials) {
+    const slots = { ...(node.slots ?? {}) };
+    const next = { ...node };
+    let changed = false;
+    for (const role of roles) {
+        if (slots[role] === undefined) {
+            const ref = legacySpecToMaterialRef({
+                material: node[`${role}Material`] ?? node.material,
+                materialPreset: node[`${role}MaterialPreset`] ?? node.materialPreset,
+            }, mintedMaterials);
+            if (ref) {
+                slots[role] = ref;
+                changed = true;
+            }
+        }
+        if (`${role}Material` in next || `${role}MaterialPreset` in next)
+            changed = true;
+        delete next[`${role}Material`];
+        delete next[`${role}MaterialPreset`];
+    }
+    return changed ? { ...next, slots } : node;
+}
+function migrateRenamedSlot(node, previousId, nextId) {
+    if (!node.slots || node.slots[previousId] === undefined)
+        return node;
+    const slots = { ...node.slots };
+    if (slots[nextId] === undefined)
+        slots[nextId] = slots[previousId];
+    delete slots[previousId];
+    return { ...node, slots };
+}
+function migrateCupolaLouverSlot(node) {
+    if (!node.slots || node.slots.louvers !== undefined || node.slots.body === undefined)
+        return node;
+    return { ...node, slots: { ...node.slots, louvers: node.slots.body } };
+}
 // Stair carries per-role legacy fields (`treadMaterial*` / `sideMaterial*` /
 // `railingMaterial*`) plus a catch-all. Map each to its slot via the same
 // fallback chain the renderer uses (`getEffectiveStairSurfaceMaterial`):
@@ -482,6 +525,39 @@ function migrateWallAssembly(node) {
     const { assemblyLayers: _assemblyLayers, ...wall } = node;
     return assemblyThickness > 0 ? { ...wall, thickness: assemblyThickness } : wall;
 }
+function migrateBlockRename(id, node, nodes) {
+    if (node.type !== 'custom-mesh')
+        return [id, node];
+    const desiredId = id.startsWith('custom-mesh_') ? `block_${id.slice('custom-mesh_'.length)}` : id;
+    let nextId = desiredId;
+    let suffix = 1;
+    while (nextId !== id && nodes[nextId]) {
+        nextId = `${desiredId}_${suffix}`;
+        suffix += 1;
+    }
+    const nextNode = { ...node, id: nextId, type: 'block' };
+    if (nextId !== id) {
+        for (const candidate of Object.values(nodes)) {
+            if (!candidate || typeof candidate !== 'object')
+                continue;
+            if (candidate.parentId === id)
+                candidate.parentId = nextId;
+            if (Array.isArray(candidate.children)) {
+                candidate.children = candidate.children.map((childId) => childId === id ? nextId : childId);
+            }
+        }
+    }
+    return [nextId, nextNode];
+}
+function migrateBlockHostedItem(node) {
+    if (node.type !== 'item' ||
+        node.blockFaceId !== undefined ||
+        node.customMeshFaceId === undefined) {
+        return node;
+    }
+    const { customMeshFaceId, ...item } = node;
+    return { ...item, blockFaceId: customMeshFaceId };
+}
 function migrateNodes(nodes) {
     // Repair pre-existing corruption (null children, zero-length walls) before
     // any per-type migration runs, so already-saved scenes load cleanly.
@@ -490,6 +566,13 @@ function migrateNodes(nodes) {
     // Scene materials minted while moving legacy wall fields onto `node.slots`;
     // merged into the scene material map by the caller (`setScene`).
     const mintedMaterials = {};
+    for (const [id, node] of Object.entries(patchedNodes)) {
+        const [nextId, nextNode] = migrateBlockRename(id, node, patchedNodes);
+        if (nextId !== id) {
+            delete patchedNodes[id];
+        }
+        patchedNodes[nextId] = migrateBlockHostedItem(nextNode);
+    }
     // Pass 1: all node types except elevator.
     // Elevator migration (migrateElevatorParent) mutates level.children to remove
     // the elevator ID. If the elevator is processed before its parent level in
@@ -578,6 +661,34 @@ function migrateNodes(nodes) {
                 patchedNodes[id] = normalized;
             }
         }
+        // Dormers originally rendered one inline parametric window. Promote that
+        // default to a real hosted WindowNode so additional windows can use the
+        // regular window tool and inspector without changing the old appearance.
+        if (node.type === 'dormer') {
+            const hasLegacyInlineWindow = !Array.isArray(patchedNodes[id].children);
+            if (!hasLegacyInlineWindow)
+                continue;
+            const dormer = DormerNodeSchema.parse({
+                ...patchedNodes[id],
+                children: getStringArray(patchedNodes[id].children),
+            });
+            const children = getStringArray(dormer.children);
+            const hasHostedWindow = children.some((childId) => patchedNodes[childId]?.type === 'window');
+            if (!hasHostedWindow) {
+                const baseWindowId = `window_${id.replace(/^dormer_/, '')}_default`;
+                let windowId = baseWindowId;
+                let suffix = 1;
+                while (patchedNodes[windowId]) {
+                    windowId = `${baseWindowId}_${suffix}`;
+                    suffix += 1;
+                }
+                const host = dormer.roofSegmentId ? patchedNodes[dormer.roofSegmentId] : undefined;
+                const hostSegment = host?.type === 'roof-segment' ? host : undefined;
+                const window = createDormerDefaultWindow(dormer, windowId, getDormerDefaultWindowFace(dormer, hostSegment));
+                patchedNodes[windowId] = window;
+                patchedNodes[id] = { ...dormer, children: [...children, window.id] };
+            }
+        }
         if (node.type === 'construction-dimension') {
             patchedNodes[id] = migrateConstructionDimension(node);
         }
@@ -635,6 +746,26 @@ function migrateNodes(nodes) {
         if (node.type === 'column') {
             patchedNodes[id] = migrateSingleMaterialSlots(patchedNodes[id], ['shaft', 'base', 'capital', 'frame'], mintedMaterials);
         }
+        if (node.type === 'gutter') {
+            patchedNodes[id] = migrateRenamedSlot(patchedNodes[id], 'surface', 'gutter');
+            patchedNodes[id] = migrateSingleMaterialSlots(patchedNodes[id], ['gutter'], mintedMaterials);
+        }
+        if (node.type === 'downspout') {
+            patchedNodes[id] = migrateSingleMaterialSlots(patchedNodes[id], ['surface'], mintedMaterials);
+        }
+        if (node.type === 'box-vent') {
+            patchedNodes[id] = migrateRoleMaterialSlots(patchedNodes[id], ['base', 'top'], mintedMaterials);
+        }
+        if (node.type === 'cupola') {
+            patchedNodes[id] = migrateCupolaLouverSlot(patchedNodes[id]);
+            patchedNodes[id] = migrateRoleMaterialSlots(patchedNodes[id], ['base', 'body', 'roof', 'louvers'], mintedMaterials);
+        }
+        if (node.type === 'eyebrow-vent') {
+            patchedNodes[id] = migrateRoleMaterialSlots(patchedNodes[id], ['hood', 'front'], mintedMaterials);
+        }
+        if (node.type === 'turbine-vent') {
+            patchedNodes[id] = migrateRoleMaterialSlots(patchedNodes[id], ['base', 'head'], mintedMaterials);
+        }
         if (node.type === 'shelf') {
             const normalized = normalizeShelfNode(node);
             if (normalized) {
@@ -743,6 +874,12 @@ function migrateNodes(nodes) {
                 children: validChildren,
             };
         }
+        // These kinds are not all schema-parsed on load, so defaults must also
+        // reach saved hosts that predate their children field.
+        if (['shelf', 'cabinet', 'cabinet-module', 'block', 'item', 'column'].includes(node.type) &&
+            patchedNodes[id].children === undefined) {
+            patchedNodes[id] = { ...patchedNodes[id], children: [] };
+        }
     }
     // Pass 2: elevator migration.
     // migrateElevatorParent mutates the parent level's children array (removes
@@ -885,13 +1022,99 @@ function sceneHistorySnapshotFromState(state) {
         installedPlugins,
     };
 }
-const useScene = create()(temporal((set, get) => ({
+/**
+ * A dirty mark is a promise that some system will rebuild the node and clear
+ * the mark, so marks are only accepted for kinds with a dirty consumer: kinds
+ * with `dirtyTracking: false` (and kinds of disabled plugins) have none, and
+ * a mark for them would sit in the set for the whole session and defeat every
+ * consumer's empty-set early exit. Ids without a node pass: tools mark nodes
+ * they are about to create.
+ */
+function isDirtyTrackable(id, scene) {
+    const node = scene.nodes[id];
+    if (!node)
+        return true;
+    if (!isNodeKindEnabled(node.type, scene.installedPlugins))
+        return false;
+    return nodeRegistry.get(node.type)?.dirtyTracking !== false;
+}
+/**
+ * `markDirty` always applied the consumer-kind guard, but many call sites add
+ * to the raw set directly (that is how stuck `level` marks got in) — enforcing
+ * it in `add` itself keeps them all honest.
+ */
+class GuardedDirtySet extends Set {
+    getScene;
+    constructor(getScene, from) {
+        super();
+        this.getScene = getScene;
+        if (from)
+            for (const id of from)
+                this.add(id);
+    }
+    add(id) {
+        if (!isDirtyTrackable(id, this.getScene()))
+            return this;
+        return super.add(id);
+    }
+}
+function createSceneStore(config) {
+    const hydratedConfig = (set, get, store) => {
+        const setWithHydration = (partial, replace) => {
+            const state = get();
+            let next = typeof partial === 'function' ? partial(state) : partial;
+            const documentChanged = ['nodes', 'rootNodeIds', 'materials', 'collections', 'installedPlugins'].some((key) => (replace || key in next) && next[key] !== state[key]);
+            if (documentChanged && !isHydrationNormalization()) {
+                invalidatePendingHydration();
+                if (state.hydrationToken)
+                    next = { ...next, hydrationToken: null };
+            }
+            if (replace)
+                set(next, true);
+            else
+                set(next);
+        };
+        store.setState = setWithHydration;
+        return config(setWithHydration, get, store);
+    };
+    return create()(hydratedConfig);
+}
+function runTemporalJump(target, jump) {
+    if (!target?.nodes) {
+        jump();
+        return;
+    }
+    const before = useScene.getState().nodes;
+    const changed = new Set();
+    for (const id of new Set([...Object.keys(before), ...Object.keys(target.nodes)])) {
+        const nodeId = id;
+        const previous = before[nodeId];
+        const next = target.nodes[nodeId];
+        if (previous === next)
+            continue;
+        // Structural hierarchy changes keep the full-level reconciliation fallback.
+        if ([previous, next].some((node) => node && ['site', 'building', 'level'].includes(node.type))) {
+            jump();
+            return;
+        }
+        changed.add(nodeId);
+    }
+    runWithSceneCommitNodeIds(changed, jump);
+}
+const useScene = createSceneStore(temporal((set, get) => ({
     // 1. Flat dictionary of all nodes
     nodes: {},
     // 2. Root node IDs
     rootNodeIds: [],
     // 3. Dirty set
-    dirtyNodes: new Set(),
+    dirtyNodes: new GuardedDirtySet(get),
+    hydrationToken: null,
+    hydrationId: null,
+    invalidateHydration: () => {
+        invalidatePendingHydration();
+        if (get().hydrationToken)
+            set({ hydrationToken: null });
+    },
     // 4. Collections
     collections: {},
     materials: {},
@@ -901,10 +1124,13 @@ const useScene = create()(temporal((set, get) => ({
     readOnly: false,
     setReadOnly: (readOnly) => set({ readOnly }),
     unloadScene: () => {
+        invalidatePendingHydration();
         set({
+            hydrationToken: null,
+            hydrationId: null,
             nodes: {},
             rootNodeIds: [],
-            dirtyNodes: new Set(),
+            dirtyNodes: new GuardedDirtySet(get),
             collections: {},
             materials: {},
             installedPlugins: [],
@@ -947,26 +1173,65 @@ const useScene = create()(temporal((set, get) => ({
         // pre-write state onto `pastStates`. Writing the scene in two steps
         // (as this used to) exposed a half-normalized intermediate state —
         // and the pre-load (possibly empty) state — as undo targets.
-        set({
-            nodes: cleanedNodes,
-            rootNodeIds: normalizedRootNodeIds,
-            dirtyNodes: new Set(),
-            collections: extra?.collections ?? {},
-            materials,
-            installedPlugins: Array.from(new Set(extra?.installedPlugins ?? [])),
-            hasExplicitPluginInstallState: extra?.hasExplicitPluginInstallState ?? false,
-        });
-        // Mark all nodes as dirty to trigger re-validation
-        Object.values(cleanedNodes).forEach((node) => {
-            get().markDirty(node.id);
-        });
+        const hydrationId = {};
+        runSceneHydration(() => {
+            set({
+                hydrationToken: null,
+                hydrationId,
+                nodes: cleanedNodes,
+                rootNodeIds: normalizedRootNodeIds,
+                dirtyNodes: new GuardedDirtySet(get),
+                collections: extra?.collections ?? {},
+                materials,
+                installedPlugins: Array.from(new Set(extra?.installedPlugins ?? [])),
+                hasExplicitPluginInstallState: extra?.hasExplicitPluginInstallState ?? false,
+            });
+            const applyNormalization = (updates) => {
+                if (updates.length > 0)
+                    get().updateNodes(updates);
+            };
+            const hydratedNodes = Object.values(get().nodes);
+            if (!get().readOnly) {
+                pauseSceneHistory(useScene);
+                try {
+                    if (hydratedNodes.some((node) => node.type === 'elevator')) {
+                        applyNormalization(syncAutoElevatorOpenings(get().nodes));
+                    }
+                }
+                finally {
+                    resumeSceneHistory(useScene);
+                }
+                if (hydratedNodes.some((node) => node.type === 'stair')) {
+                    // Spatial-grid subscribers must settle first. Owning this pass
+                    // here also covers opening systems that mount after the load.
+                    queueSceneNormalization(() => {
+                        if (get().hydrationId !== hydrationId)
+                            return;
+                        pauseSceneHistory(useScene);
+                        try {
+                            applyNormalization(syncStairRises(get().nodes));
+                            applyNormalization(syncAutoStairOpenings(get().nodes));
+                        }
+                        finally {
+                            resumeSceneHistory(useScene);
+                        }
+                    });
+                }
+            }
+            // Mark all nodes as dirty to trigger re-validation
+            Object.values(get().nodes).forEach((node) => {
+                get().markDirty(node.id);
+            });
+        }, () => set({ hydrationToken: hydrationId }));
     },
     setInstalledPlugins: (pluginIds, options) => {
         if (get().readOnly)
             return;
         const nextInstalledPlugins = Array.from(new Set(pluginIds));
         const previousInstalledPlugins = get().installedPlugins;
-        const dirtyNodes = new Set(get().dirtyNodes);
+        // Guard against the *next* plugin list: the store still holds the old
+        // one, and re-marks for newly enabled kinds must pass the guard.
+        const dirtyNodes = new GuardedDirtySet(() => ({ nodes: get().nodes, installedPlugins: nextInstalledPlugins }), get().dirtyNodes);
         for (const node of Object.values(get().nodes)) {
             if (!getNodePluginId(node.type))
                 continue;
@@ -1017,10 +1282,9 @@ const useScene = create()(temporal((set, get) => ({
         set({ nodes, rootNodeIds });
     },
     markDirty: (id) => {
-        const node = get().nodes[id];
-        if (node && !isNodeKindEnabled(node.type, get().installedPlugins))
-            return;
-        if (node && nodeRegistry.get(node.type)?.dirtyTracking === false)
+        // Guarded here too, not just in GuardedDirtySet.add — tests (and any
+        // setState caller) can swap in a plain Set.
+        if (!isDirtyTrackable(id, get()))
             return;
         get().dirtyNodes.add(id);
     },
@@ -1170,8 +1434,27 @@ const useScene = create()(temporal((set, get) => ({
             current: sceneHistorySnapshotFromState(currentState),
         });
     },
+    wrapTemporal: (config) => (set, get, store) => {
+        const state = config(set, get, store);
+        return {
+            ...state,
+            undo: (steps = 1) => runTemporalJump(get().pastStates.slice().splice(-steps, steps)[0], () => state.undo(steps)),
+            redo: (steps = 1) => runTemporalJump(get().futureStates.slice().splice(-steps, steps)[0], () => state.redo(steps)),
+        };
+    },
     limit: 50, // Limit to last 50 actions
 }));
+// Live state belongs to the hydration owner so even a lazy consumer cannot
+// miss an override that was set and cleared before its first frame.
+const invalidateForLiveState = () => {
+    if (useLiveNodeOverrides.getState().overrides.size ||
+        useLiveTransforms.getState().transforms.size) {
+        useScene.getState().invalidateHydration();
+    }
+};
+useLiveNodeOverrides.subscribe(invalidateForLiveState);
+useLiveTransforms.subscribe(invalidateForLiveState);
+useScene.subscribe(invalidateForLiveState);
 export default useScene;
 let sceneReadOnlyLeaseCount = 0;
 let sceneReadOnlyLeaseBaseline = false;
@@ -1543,6 +1826,8 @@ export function applySceneSnapshot(snapshot, options) {
     if (!temporalState.isTracking || getSceneHistoryPauseDepth() > 0) {
         throw new Error('Cannot replace the scene snapshot during an active interaction');
     }
+    useLiveNodeOverrides.getState().clearAll();
+    useLiveTransforms.getState().clearAll();
     pauseSceneHistory(useScene);
     try {
         useScene.getState().setScene(snapshot.nodes, snapshot.rootNodeIds, {
@@ -1555,18 +1840,15 @@ export function applySceneSnapshot(snapshot, options) {
     finally {
         resumeSceneHistory(useScene);
     }
-    useLiveNodeOverrides.getState().clearAll();
-    useLiveTransforms.getState().clearAll();
     const current = sceneHistorySnapshotFromState(useScene.getState());
     if (areSceneSnapshotsEqual(before, current))
         return false;
     notifySceneCommit({ origin: options.origin, before, current });
     return true;
 }
-// Track previous temporal state lengths and node snapshot for diffing
+// Track previous temporal state lengths for identifying history jumps
 let prevPastLength = 0;
 let prevFutureLength = 0;
-let prevNodesSnapshot = null;
 export function clearSceneHistory() {
     resetSceneHistoryPauseDepth();
     // Resetting the pause-depth counter without resuming would strand the
@@ -1578,10 +1860,14 @@ export function clearSceneHistory() {
     useScene.temporal.getState().clear();
     prevPastLength = 0;
     prevFutureLength = 0;
-    prevNodesSnapshot = null;
 }
 // Subscribe to the temporal store (Undo/Redo events)
-useScene.temporal.subscribe((state) => {
+useScene.temporal.subscribe((state, previousState) => {
+    // Zundo mutates its source stack before writing the scene. Reconciliation's
+    // pause/resume notifications must not advance our pre-jump stack lengths.
+    if (state.pastStates === previousState.pastStates &&
+        state.futureStates === previousState.futureStates)
+        return;
     const currentPastLength = state.pastStates.length;
     const currentFutureLength = state.futureStates.length;
     // Undo: futureStates increases (state moved from past to future)
@@ -1589,40 +1875,21 @@ useScene.temporal.subscribe((state) => {
     const didUndo = currentFutureLength > prevFutureLength;
     const didRedo = currentPastLength > prevPastLength && currentFutureLength < prevFutureLength;
     if (didUndo || didRedo) {
-        // Capture the previous snapshot before RAF fires
-        const snapshotBefore = prevNodesSnapshot;
+        // Capture both layouts before another synchronous jump can replace them.
+        // The state pushed onto the opposite stack includes history-paused derived
+        // writes (such as stair rise), unlike a snapshot saved at the last edit.
+        const snapshotBefore = didUndo
+            ? state.futureStates[prevFutureLength]?.nodes
+            : state.pastStates[prevPastLength]?.nodes;
+        const snapshotAfter = useScene.getState().nodes;
         // Defer to a microtask so the scene store has settled before we diff,
         // but still mark walls/items dirty before the next paint.
         queueMicrotask(() => {
             const currentNodes = useScene.getState().nodes;
             const { markDirty } = useScene.getState();
             if (snapshotBefore) {
-                // Diff: only mark nodes that actually changed
-                for (const [id, node] of Object.entries(currentNodes)) {
-                    if (snapshotBefore[id] !== node) {
-                        markDirty(id);
-                        // Also mark parent so merged geometries update
-                        if (node.parentId)
-                            markDirty(node.parentId);
-                    }
-                }
-                // Nodes that were deleted (exist in prev but not current)
-                for (const [id, node] of Object.entries(snapshotBefore)) {
-                    if (!currentNodes[id]) {
-                        const parentId = node.parentId;
-                        if (parentId) {
-                            markDirty(parentId);
-                            // Mark sibling nodes dirty so they can update their geometry
-                            // (e.g. adjacent walls need to recalculate miter/junction geometry)
-                            const parent = currentNodes[parentId];
-                            if (parent && 'children' in parent && Array.isArray(parent.children)) {
-                                for (const childId of parent.children) {
-                                    markDirty(childId);
-                                }
-                            }
-                        }
-                    }
-                }
+                for (const id of getHistoryDirtyNodeIds(snapshotBefore, snapshotAfter))
+                    markDirty(id);
             }
             else {
                 // No snapshot to diff against — fall back to marking all
@@ -1630,10 +1897,17 @@ useScene.temporal.subscribe((state) => {
                     markDirty(node.id);
                 }
             }
+            // Undo/redo rewrites `nodes` without going through the delete actions,
+            // so marks for nodes that no longer exist would sit in the set for the
+            // rest of the session — no system clears a mark whose node is gone.
+            const { dirtyNodes, clearDirty } = useScene.getState();
+            for (const id of [...dirtyNodes]) {
+                if (!currentNodes[id])
+                    clearDirty(id);
+            }
         });
     }
-    // Update tracked lengths and snapshot
+    // Update tracked lengths
     prevPastLength = currentPastLength;
     prevFutureLength = currentFutureLength;
-    prevNodesSnapshot = useScene.getState().nodes;
 });

package/dist/systems/elevator/elevator-dispatch.d.ts

@@ -1,5 +1,5 @@
-import type { AnyNode, AnyNodeId } from '../../schema';
-import type { ElevatorInteractiveState } from '../../store/use-interactive';
+import type { AnyNode, AnyNodeId } from '../../schema/index.js';
+import type { ElevatorInteractiveState } from '../../store/use-interactive.js';
 type ElevatorRuntimeMap = Record<AnyNodeId, ElevatorInteractiveState>;
 type ResolveElevatorDispatchTargetArgs = {
     elevators: ElevatorRuntimeMap;

package/dist/systems/elevator/elevator-dispatch.js

@@ -1,4 +1,4 @@
-import { resolveElevatorServiceLevels } from './elevator-service';
+import { resolveElevatorServiceLevels } from './elevator-service.js';
 function getRuntimeLevelId(runtime, elevator) {
     return runtime?.currentLevelId ?? elevator.defaultLevelId ?? elevator.fromLevelId ?? null;
 }

package/dist/systems/elevator/elevator-geometry.d.ts

@@ -1,4 +1,4 @@
-import type { ElevatorDoorPanelStyle, ElevatorDoorStyle, ElevatorNode, ElevatorShaftStyle } from '../../schema';
+import type { ElevatorDoorPanelStyle, ElevatorDoorStyle, ElevatorNode, ElevatorShaftStyle } from '../../schema/index.js';
 export type ElevatorDoorSide = 'left' | 'right';
 export declare function getResolvedElevatorDoorStyle(doorStyle: ElevatorNode['doorStyle'] | undefined): ElevatorDoorStyle;
 export declare function getResolvedElevatorDoorPanelStyle(doorPanelStyle: ElevatorNode['doorPanelStyle'] | undefined): ElevatorDoorPanelStyle;

package/dist/systems/elevator/elevator-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 syncAutoElevatorOpenings(nodes: Record<string, AnyNode>): {
     id: AnyNodeId;
     data: Partial<SlabNode | CeilingNode>;