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

package/dist/store/use-scene.js

@@ -5,9 +5,11 @@ import { parseMaterialRef, toSceneMaterialRef } from '../material-library';
 import { getNodePluginId, isNodeKindEnabled, nodeRegistry } from '../registry/registry';
 import { BuildingNode } from '../schema';
 import { generateCollectionId } from '../schema/collections';
+import { compiledNodeSchema } from '../schema/compiled-node-parsers';
 import { DoorNode as DoorNodeSchema } from '../schema/nodes/door';
+import { createDormerDefaultWindow, DormerNode as DormerNodeSchema, getDormerDefaultWindowFace, } from '../schema/nodes/dormer';
 import { ElevatorNode as ElevatorNodeSchema } from '../schema/nodes/elevator';
-import { LevelNode } from '../schema/nodes/level';
+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';
@@ -18,14 +20,16 @@ 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 { deriveLegacyLevelHeight } from '../services/level-height';
-import { getCeilingClampBound } from '../services/storey';
-import { computeWallSlabSupport } from '../systems/slab/slab-support';
-import { DEFAULT_WALL_HEIGHT } from '../systems/wall/wall-footprint';
+import { syncAutoElevatorOpenings } from '../systems/elevator/elevator-opening-sync';
+import { syncAutoStairOpenings } from '../systems/stair/stair-opening-sync';
+import { syncStairRises } from '../systems/stair/stair-rise';
 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 { areSceneSnapshotsEqual, getSceneHistoryPauseDepth, notifySceneCommit, pauseSceneHistory, resetSceneHistoryPauseDepth, resumeSceneHistory, runWithSceneCommitNodeIds, } from './history-control';
+import { getHistoryDirtyNodeIds } from './history-invalidation';
+import { invalidatePendingHydration, isHydrationNormalization, queueSceneNormalization, runSceneHydration, } from './scene-hydration';
 import useLiveNodeOverrides from './use-live-node-overrides';
 import useLiveTransforms from './use-live-transforms';
 function getFiniteNumber(value, fallback) {
@@ -85,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)
@@ -110,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) {
@@ -142,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) {
@@ -168,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) {
@@ -298,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`):
@@ -485,14 +525,39 @@ function migrateWallAssembly(node) {
     const { assemblyLayers: _assemblyLayers, ...wall } = node;
     return assemblyThickness > 0 ? { ...wall, thickness: assemblyThickness } : wall;
 }
-// Walls whose top lands within this of the storey plane become plane-bound;
-// ceilings whose stored height lands within this of their clamp bound become
-// follows-mode (step 3f) — same census-backed threshold for both.
-// From a prod census: the 0.15-short "hole pattern" (default 2.5 walls next to
-// a taller wall) must snap to the plane, while intentional 0.20-short walls
-// (2.5 under a 2.7 plane, 2.3 under a 2.5 plane) must keep their explicit
-// height — hence 0.20 with a strictly-less-than comparison.
-const PLANE_BOUND_EPSILON = 0.2;
+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.
@@ -501,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
@@ -589,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);
         }
@@ -646,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) {
@@ -749,6 +869,7 @@ function migrateNodes(nodes) {
             const levelNumber = getFiniteNumber(node.level, 0);
             patchedNodes[id] = {
                 ...node,
+                baseElevation: normalizeLevelBaseElevation(node.baseElevation),
                 level: levelNumber,
                 children: validChildren,
             };
@@ -771,155 +892,8 @@ function migrateNodes(nodes) {
             patchedNodes[id] = normalized;
         }
     }
-    // Pass 3: vertical building model.
-    // A level without `height` marks a scene saved before the vertical model
-    // landed. Computed before this pass mutates anything: the stair-rise
-    // cleanup below must never run on already-migrated scenes.
-    const isLegacyScene = Object.values(patchedNodes).some((node) => node?.type === 'level' && !('height' in node));
-    // 3a. Ordinal renumber — always runs, per building (idempotent
-    // self-healing; MCP's create-level historically wrote its elevation PARAM
-    // into the ordinal, so fractional/duplicate ordinals exist in the wild).
-    const buildingNodes = Object.values(patchedNodes).filter((node) => node?.type === 'building');
-    const levelsByBuilding = new Map();
-    for (const [id, node] of Object.entries(patchedNodes)) {
-        if (node?.type !== 'level')
-            continue;
-        // Mirrors the building resolution in services/storey.ts: an explicit
-        // parentId pointing at a building wins, membership in a building's
-        // children array is the legacy fallback, and unresolvable levels share
-        // one orphan bucket.
-        const buildingId = buildingNodes.find((building) => building.id === node.parentId)?.id ??
-            buildingNodes.find((building) => getStringArray(building.children).includes(id))?.id ??
-            null;
-        const bucket = levelsByBuilding.get(buildingId) ?? [];
-        bucket.push({ id, ordinal: getFiniteNumber(node.level, 0) });
-        levelsByBuilding.set(buildingId, bucket);
-    }
-    for (const bucket of levelsByBuilding.values()) {
-        // Anchored at zero on purpose: ordinals are semantic — `level < 0`
-        // renders "Basement N" and `level === 0` is the ground-floor default —
-        // so negatives compact upward toward −1 and non-negatives compact down
-        // to 0. A blind 0..n renumber would rename basements.
-        const sorted = [...bucket].sort((a, b) => a.ordinal - b.ordinal);
-        const negativeCount = sorted.filter((entry) => entry.ordinal < 0).length;
-        sorted.forEach((entry, index) => {
-            const nextOrdinal = index - negativeCount;
-            const current = patchedNodes[entry.id];
-            if (current.level !== nextOrdinal) {
-                patchedNodes[entry.id] = { ...current, level: nextOrdinal };
-            }
-        });
-    }
-    // 3b. Stored storey heights: materialize the legacy stacked height verbatim
-    // (never rounded or snapped — snapping would move existing buildings).
-    // All planes derive before any wall height below mutates.
-    const legacyLevelIds = Object.entries(patchedNodes)
-        .filter(([, node]) => node?.type === 'level' && !('height' in node))
-        .map(([id]) => id);
-    const derivedHeights = new Map();
-    for (const levelId of legacyLevelIds) {
-        derivedHeights.set(levelId, deriveLegacyLevelHeight(levelId, patchedNodes));
-    }
-    for (const levelId of legacyLevelIds) {
-        const plane = derivedHeights.get(levelId);
-        const level = patchedNodes[levelId];
-        patchedNodes[levelId] = { ...level, height: plane };
-        // 3c. Wall-top classification against the just-written plane, using the
-        // same slab-support election as deriveLegacyLevelHeight (call shape
-        // mirrored from services/level-height.ts). Walls whose top meets the
-        // plane drop their explicit height and follow the level from now on;
-        // walls ending short (or tall) keep an explicit height — materializing
-        // the 2.5 default onto absent-height walls that end short of the plane.
-        const children = getStringArray(level.children)
-            .map((childId) => patchedNodes[childId])
-            .filter((child) => child !== undefined);
-        const slabs = children.filter((child) => child.type === 'slab');
-        const walls = children.filter((child) => child.type === 'wall');
-        for (const wall of walls) {
-            const electedBase = computeWallSlabSupport({
-                start: wall.start,
-                end: wall.end,
-                curveOffset: wall.curveOffset,
-                thickness: wall.thickness,
-            }, slabs, walls).elevation;
-            const effectiveHeight = wall.height ?? DEFAULT_WALL_HEIGHT;
-            const top = Math.max(0, electedBase) + effectiveHeight;
-            if (Math.abs(plane - top) < PLANE_BOUND_EPSILON) {
-                if ('height' in wall) {
-                    const { height: _height, ...planeBound } = wall;
-                    patchedNodes[wall.id] = planeBound;
-                }
-            }
-            else {
-                patchedNodes[wall.id] = { ...wall, height: effectiveHeight };
-            }
-        }
-    }
-    // 3d. Stair rise: on legacy scenes a totalRise of exactly 2.5 is the old
-    // schema default, not a user choice — drop it so the rise derives from the
-    // storey height. Gated on isLegacyScene because on a post-migration scene
-    // a stored 2.5 IS a deliberately typed value and must survive reloads.
-    if (isLegacyScene) {
-        for (const [id, node] of Object.entries(patchedNodes)) {
-            if (node?.type !== 'stair')
-                continue;
-            if (node.totalRise !== 2.5)
-                continue;
-            const { totalRise: _totalRise, ...derivedRise } = node;
-            patchedNodes[id] = derivedRise;
-        }
-    }
-    // 3e. Slab placement/thickness split. `elevation` stays the walking surface;
-    // the new `thickness` grows downward so the solid occupies
-    // [elevation − thickness, elevation]. Legacy solids extruded [0, elevation],
-    // so thickness = elevation EXACTLY (including degenerate 0 — MIN_SLAB_THICKNESS
-    // applies to edits only, never here) keeps the occupied interval identical.
-    // Legacy pools (elevation < 0) become explicit `recessed` intent with
-    // elevation unchanged. Gated per slab on a missing `thickness` — the
-    // migration output is cast, so schema defaults never materialize on load.
-    for (const [id, node] of Object.entries(patchedNodes)) {
-        if (node?.type !== 'slab' || 'thickness' in node)
-            continue;
-        const elevation = getFiniteNumber(node.elevation, 0.05);
-        patchedNodes[id] =
-            elevation < 0
-                ? { ...node, thickness: 0.05, recessed: true }
-                : { ...node, thickness: elevation };
-    }
-    // 3f. Ceiling follows-mode classification (the ceiling mirror of 3c; runs
-    // after 3b/3e so the clamp bound sees stored level heights and split slab
-    // thicknesses). A stored ceiling height within PLANE_BOUND_EPSILON of its
-    // clamp bound (min(storey plane, covering-slab underside) − margin, via
-    // getCeilingClampBound) is the legacy default tracking the level top, not
-    // a choice — drop it so the ceiling follows the level from now on.
-    // autoFromWalls ceilings always convert: their height was derived by the
-    // space-detection sync, never user intent. Gated on isLegacyScene, which
-    // is exact — nothing shipped between the level-height migration and this
-    // one — and makes the step idempotent. Known accepted edge: a
-    // post-migration user typing a custom height exactly equal to the bound
-    // keeps it (the gate prevents re-classification on later loads).
-    if (isLegacyScene) {
-        for (const [id, node] of Object.entries(patchedNodes)) {
-            if (node?.type !== 'ceiling' || !('height' in node))
-                continue;
-            const dropHeight = () => {
-                const { height: _height, ...follows } = node;
-                patchedNodes[id] = follows;
-            };
-            if (node.autoFromWalls === true) {
-                dropHeight();
-                continue;
-            }
-            if (typeof node.parentId !== 'string')
-                continue;
-            const bound = getCeilingClampBound(node.parentId, patchedNodes, Array.isArray(node.polygon) ? node.polygon : []);
-            const stored = getFiniteNumber(node.height, Number.NaN);
-            if (Number.isFinite(bound) && Math.abs(stored - bound) < PLANE_BOUND_EPSILON) {
-                dropHeight();
-            }
-        }
-    }
-    return { nodes: patchedNodes, mintedMaterials };
+    const vertical = migrateVerticalSceneNodes(patchedNodes);
+    return { nodes: vertical.nodes, mintedMaterials };
 }
 function getNodeChildIds(node) {
     if (!('children' in node && Array.isArray(node.children))) {
@@ -971,15 +945,170 @@ function collectReachableNodeIds(nodes, rootNodeIds) {
 }
 function sceneHistorySnapshotFromState(state) {
     const { nodes, rootNodeIds, collections, materials, installedPlugins } = state;
-    return { nodes, rootNodeIds, collections, materials, installedPlugins };
+    // Fresh placement nodes are renderable drafts, not document history. Excluding their
+    // entire subtree here protects both local undo and external commit subscribers.
+    const transientNodeIds = new Set();
+    for (const node of Object.values(nodes)) {
+        const metadata = node.metadata;
+        if (metadata &&
+            typeof metadata === 'object' &&
+            !Array.isArray(metadata) &&
+            metadata.isNew === true) {
+            transientNodeIds.add(node.id);
+        }
+    }
+    if (transientNodeIds.size === 0) {
+        return { nodes, rootNodeIds, collections, materials, installedPlugins };
+    }
+    const childIdsByParentId = new Map();
+    const addChild = (parentId, childId) => {
+        const childIds = childIdsByParentId.get(parentId) ?? new Set();
+        childIds.add(childId);
+        childIdsByParentId.set(parentId, childIds);
+    };
+    for (const node of Object.values(nodes)) {
+        if (node.parentId)
+            addChild(node.parentId, node.id);
+        for (const childId of getNodeChildIds(node))
+            addChild(node.id, childId);
+    }
+    const pendingIds = [...transientNodeIds];
+    while (pendingIds.length > 0) {
+        const parentId = pendingIds.pop();
+        if (!parentId)
+            continue;
+        for (const childId of childIdsByParentId.get(parentId) ?? []) {
+            if (transientNodeIds.has(childId))
+                continue;
+            transientNodeIds.add(childId);
+            pendingIds.push(childId);
+        }
+    }
+    const historyNodes = {};
+    for (const [id, node] of Object.entries(nodes)) {
+        if (transientNodeIds.has(id))
+            continue;
+        if (!('children' in node && Array.isArray(node.children))) {
+            historyNodes[id] = node;
+            continue;
+        }
+        const children = node.children.filter((childId) => !transientNodeIds.has(childId));
+        historyNodes[id] =
+            children.length === node.children.length ? node : { ...node, children };
+    }
+    const historyCollections = {};
+    for (const [id, collection] of Object.entries(collections)) {
+        const nodeIds = collection.nodeIds.filter((nodeId) => !transientNodeIds.has(nodeId));
+        if (collection.controlNodeId && transientNodeIds.has(collection.controlNodeId)) {
+            const { controlNodeId: _controlNodeId, ...rest } = collection;
+            historyCollections[id] = { ...rest, nodeIds };
+        }
+        else {
+            historyCollections[id] =
+                nodeIds.length === collection.nodeIds.length ? collection : { ...collection, nodeIds };
+        }
+    }
+    return {
+        nodes: historyNodes,
+        rootNodeIds: rootNodeIds.filter((id) => !transientNodeIds.has(id)),
+        collections: historyCollections,
+        materials,
+        installedPlugins,
+    };
+}
+/**
+ * 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 = create()(temporal((set, get) => ({
+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: {},
@@ -989,10 +1118,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: [],
@@ -1035,26 +1167,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;
@@ -1105,10 +1276,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);
     },
@@ -1258,8 +1428,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;
@@ -1631,6 +1820,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, {
@@ -1643,18 +1834,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
@@ -1666,10 +1854,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)
@@ -1677,40 +1869,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
@@ -1718,10 +1891,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;
 });