@pascal-app/core 0.8.0 → 0.9.2

package/dist/store/use-scene.js

@@ -1,17 +1,32 @@
 '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 } 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 { StairNode as StairNodeSchema } from '../schema/nodes/stair';
+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, } from '../schema/scene-material';
+import { healSceneNodes } from '../utils/heal-scene-graph';
 import * as nodeActions from './actions/node-actions';
 import { resetSceneHistoryPauseDepth } from './history-control';
 function getFiniteNumber(value, fallback) {
     return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
 }
+function getFiniteNumberInRange(value, fallback, min, max) {
+    const finite = getFiniteNumber(value, fallback);
+    return Math.min(Math.max(finite, min), max);
+}
 function getBoolean(value, fallback) {
     return typeof value === 'boolean' ? value : fallback;
 }
@@ -19,7 +34,7 @@ function getEnumValue(value, allowed, fallback) {
     return typeof value === 'string' && allowed.includes(value) ? value : fallback;
 }
 function getNullableString(value) {
-    return typeof value === 'string' ? value : null;
+    return typeof value === 'string' && value.length > 0 ? value : null;
 }
 function getStringArray(value) {
     return Array.isArray(value)
@@ -81,40 +96,227 @@ function normalizeStairSegmentNode(node) {
     const parsed = StairSegmentNodeSchema.safeParse(sanitized);
     return parsed.success ? parsed.data : null;
 }
-function migrateWallSurfaceMaterials(node) {
-    const hasInterior = node.interiorMaterial !== undefined || typeof node.interiorMaterialPreset === 'string';
-    const hasExterior = node.exteriorMaterial !== undefined || typeof node.exteriorMaterialPreset === 'string';
-    const legacyFinish = {
-        material: node.material,
-        materialPreset: typeof node.materialPreset === 'string' ? node.materialPreset : undefined,
+function normalizeDoorNode(node) {
+    const parsed = 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);
+    return parsed.success ? { ...node, ...parsed.data } : null;
+}
+function normalizeShelfNode(node) {
+    const sanitized = {
+        ...node,
+        children: getStringArray(node.children),
+        position: getVector3(node.position, [0, 0, 0]),
+        rotation: getVector3(node.rotation, [0, 0, 0]),
+        width: getFiniteNumberInRange(node.width, 1.2, 0.3, 3.0),
+        depth: getFiniteNumberInRange(node.depth, 0.3, 0.1, 1.0),
+        thickness: getFiniteNumberInRange(node.thickness, 0.04, 0.01, 0.1),
+        height: getFiniteNumberInRange(node.height, 0.9, 0.05, 2.5),
+        rows: Math.round(getFiniteNumberInRange(node.rows, 1, 1, 8)),
+        columns: Math.round(getFiniteNumberInRange(node.columns, 1, 1, 6)),
+        style: getEnumValue(node.style, ['wall-shelf', 'bookshelf', 'open-rack', 'cubby'], 'wall-shelf'),
+        withBack: getBoolean(node.withBack, false),
+        withSides: getBoolean(node.withSides, true),
+        withBottom: getBoolean(node.withBottom, false),
+        bracketStyle: getEnumValue(node.bracketStyle, ['minimal', 'industrial', 'hidden'], 'minimal'),
     };
-    if (!(hasInterior || hasExterior)) {
-        if (legacyFinish.material === undefined && legacyFinish.materialPreset === undefined) {
-            return node;
+    const parsed = ShelfNodeSchema.safeParse(sanitized);
+    return parsed.success ? parsed.data : null;
+}
+function normalizeElevatorNode(node) {
+    const sanitized = {
+        ...node,
+        position: getVector3(node.position, [0, 0, 0]),
+        rotation: getFiniteNumber(node.rotation, 0),
+        width: getFiniteNumber(node.width, 1.84),
+        depth: getFiniteNumber(node.depth, 1.84),
+        shaftWidth: node.shaftWidth === undefined ? undefined : getFiniteNumber(node.shaftWidth, 1.84),
+        shaftDepth: node.shaftDepth === undefined ? undefined : getFiniteNumber(node.shaftDepth, 1.84),
+        shaftWallThickness: getFiniteNumber(node.shaftWallThickness, 0.09),
+        cabHeight: getFiniteNumber(node.cabHeight, 2.35),
+        doorWidth: getFiniteNumber(node.doorWidth, 0.95),
+        doorHeight: getFiniteNumber(node.doorHeight, 2.1),
+        fromLevelId: getNullableString(node.fromLevelId),
+        toLevelId: getNullableString(node.toLevelId),
+        servedLevelIds: node.servedLevelIds === undefined ? undefined : getStringArray(node.servedLevelIds),
+        disabledLevelIds: getStringArray(node.disabledLevelIds),
+        serviceOnlyLevelIds: getStringArray(node.serviceOnlyLevelIds),
+        defaultLevelId: getNullableString(node.defaultLevelId),
+        speed: getFiniteNumber(node.speed, 2.2),
+        doorDurationMs: getFiniteNumber(node.doorDurationMs, 900),
+        dwellMs: getFiniteNumber(node.dwellMs, 1400),
+    };
+    const parsed = ElevatorNodeSchema.safeParse(sanitized);
+    return parsed.success ? parsed.data : null;
+}
+function findBuildingIdForLevel(levelId, nodes) {
+    const level = nodes[levelId];
+    const directBuildingId = typeof level?.parentId === 'string' ? level.parentId : null;
+    if (directBuildingId && nodes[directBuildingId]?.type === 'building') {
+        return directBuildingId;
+    }
+    for (const [candidateId, candidate] of Object.entries(nodes)) {
+        if (candidate?.type !== 'building')
+            continue;
+        if (getStringArray(candidate.children).includes(levelId)) {
+            return candidateId;
         }
-        return {
-            ...node,
-            interiorMaterial: legacyFinish.material,
-            interiorMaterialPreset: legacyFinish.materialPreset,
-            exteriorMaterial: legacyFinish.material,
-            exteriorMaterialPreset: legacyFinish.materialPreset,
-        };
     }
-    if (!hasInterior) {
-        return {
-            ...node,
-            interiorMaterial: node.exteriorMaterial,
-            interiorMaterialPreset: node.exteriorMaterialPreset,
-        };
+    return null;
+}
+function migrateElevatorParent(id, node, nodes) {
+    const parentId = typeof node.parentId === 'string' ? node.parentId : null;
+    if (!parentId)
+        return node;
+    const parent = parentId ? nodes[parentId] : null;
+    if (parent?.type !== 'level')
+        return node;
+    const buildingId = findBuildingIdForLevel(parentId, nodes);
+    if (!buildingId)
+        return node;
+    const building = buildingId ? nodes[buildingId] : null;
+    if (building?.type !== 'building')
+        return node;
+    nodes[parentId] = {
+        ...parent,
+        children: getStringArray(parent.children).filter((childId) => childId !== id),
+    };
+    const buildingChildren = getStringArray(building.children);
+    nodes[buildingId] = {
+        ...building,
+        children: buildingChildren.includes(id) ? buildingChildren : [...buildingChildren, id],
+    };
+    return {
+        ...node,
+        parentId: buildingId,
+    };
+}
+// Reuse an already-minted scene material for an identical inline legacy
+// material so a whole building painted one custom colour collapses to one
+// shared datablock (mirrors `commitSlotPaint`'s dedupe-on-match).
+function findMintedSceneMaterialRef(material, mintedMaterials) {
+    const target = JSON.stringify(material);
+    for (const sceneMaterial of Object.values(mintedMaterials)) {
+        if (JSON.stringify(sceneMaterial.material) === target) {
+            return toSceneMaterialRef(sceneMaterial.id);
+        }
     }
-    if (!hasExterior) {
-        return {
-            ...node,
-            exteriorMaterial: node.interiorMaterial,
-            exteriorMaterialPreset: node.interiorMaterialPreset,
+    return undefined;
+}
+// Turn a legacy surface spec (`{ material, materialPreset }`) into a
+// `MaterialRef`: a preset that's already a `library:`/`scene:` ref is used
+// as-is; an inline material mints (or reuses) a scene material. Returns
+// undefined when the spec carries no material. Shared by every legacy→slots
+// migration below.
+function legacySpecToMaterialRef(spec, mintedMaterials) {
+    if (typeof spec.materialPreset === 'string' && parseMaterialRef(spec.materialPreset)) {
+        return spec.materialPreset;
+    }
+    if (spec.material !== undefined) {
+        const existing = findMintedSceneMaterialRef(spec.material, mintedMaterials);
+        if (existing)
+            return existing;
+        const id = generateSceneMaterialId();
+        mintedMaterials[id] = {
+            id,
+            name: `Material ${Object.keys(mintedMaterials).length + 1}`,
+            material: spec.material,
         };
+        return toSceneMaterialRef(id);
+    }
+    return undefined;
+}
+// Move the retired inline `material*` / `interiorMaterial*` / `exteriorMaterial*`
+// fields onto the unified `node.slots` model (interior / exterior → a
+// `library:`/`scene:` ref), minting scene materials for inline customs into
+// `mintedMaterials` (merged into the scene material map by the caller). Already
+// slot-modelled walls and walls with no legacy material are left untouched.
+function migrateWallSurfaceMaterials(node, mintedMaterials) {
+    if (node.slots && (node.slots.interior !== undefined || node.slots.exterior !== undefined)) {
+        return node;
+    }
+    const slots = { ...(node.slots ?? {}) };
+    for (const side of ['interior', 'exterior']) {
+        const spec = getEffectiveWallSurfaceMaterial(node, side);
+        const ref = legacySpecToMaterialRef(spec, mintedMaterials);
+        if (ref)
+            slots[side] = ref;
+    }
+    if (Object.keys(slots).length === 0) {
+        return node;
+    }
+    return {
+        ...node,
+        slots,
+        material: undefined,
+        materialPreset: undefined,
+        interiorMaterial: undefined,
+        interiorMaterialPreset: undefined,
+        exteriorMaterial: undefined,
+        exteriorMaterialPreset: undefined,
+    };
+}
+// Move a kind's single legacy `material` / `materialPreset` onto its declared
+// slots. A pre-slot-model node painted one material rendered that material on
+// every part (each slot resolves `node.slots[slot]` → legacy → default), so the
+// migration writes the same ref to every slot id the kind can expose — unused
+// conditional slots are harmless. Already slot-modelled or unpainted nodes are
+// left untouched. Mirrors `migrateWallSurfaceMaterials` for single-surface and
+// whole-object kinds (slab, ceiling, fence, column, shelf).
+function migrateSingleMaterialSlots(node, slotIds, mintedMaterials) {
+    if (node.slots && Object.keys(node.slots).length > 0) {
+        return node;
+    }
+    const ref = legacySpecToMaterialRef({ material: node.material, materialPreset: node.materialPreset }, mintedMaterials);
+    if (!ref) {
+        return node;
+    }
+    const slots = {};
+    for (const slotId of slotIds)
+        slots[slotId] = ref;
+    return { ...node, slots, material: undefined, materialPreset: undefined };
+}
+// 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`):
+// tread→treads, side→body, railing→railing. Runs after
+// `migrateStairSurfaceMaterials` has normalised the legacy fields.
+function migrateStairSurfaceSlots(node, mintedMaterials) {
+    if (node.slots && Object.keys(node.slots).length > 0) {
+        return node;
+    }
+    const roleToSlot = [
+        ['tread', 'treads'],
+        ['side', 'body'],
+        ['railing', 'railing'],
+    ];
+    const slots = {};
+    for (const [role, slotId] of roleToSlot) {
+        const spec = getEffectiveStairSurfaceMaterial(node, role);
+        const ref = legacySpecToMaterialRef(spec, mintedMaterials);
+        if (ref)
+            slots[slotId] = ref;
+    }
+    if (Object.keys(slots).length === 0) {
+        return node;
     }
-    return node;
+    return {
+        ...node,
+        slots,
+        material: undefined,
+        materialPreset: undefined,
+        treadMaterial: undefined,
+        treadMaterialPreset: undefined,
+        sideMaterial: undefined,
+        sideMaterialPreset: undefined,
+        railingMaterial: undefined,
+        railingMaterialPreset: undefined,
+    };
 }
 function migrateStairSurfaceMaterials(node) {
     const hasRailing = node.railingMaterial !== undefined || typeof node.railingMaterialPreset === 'string';
@@ -233,7 +435,20 @@ function migrateRoofSurfaceMaterials(node) {
     return next;
 }
 function migrateNodes(nodes) {
-    const patchedNodes = { ...nodes };
+    // Repair pre-existing corruption (null children, zero-length walls) before
+    // any per-type migration runs, so already-saved scenes load cleanly.
+    const { nodes: healed } = healSceneNodes(nodes);
+    const patchedNodes = { ...healed };
+    // Scene materials minted while moving legacy wall fields onto `node.slots`;
+    // merged into the scene material map by the caller (`setScene`).
+    const mintedMaterials = {};
+    // 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
+    // Object.entries order, the level migration in this same pass would then see
+    // a children array that still contains the elevator ID and filter it out as
+    // "missing" — corrupting the level. Running elevators in a second pass after
+    // all levels are stable avoids the race entirely.
     for (const [id, node] of Object.entries(patchedNodes)) {
         // 1. Item scale migration
         if (node.type === 'item' && !('scale' in node)) {
@@ -244,6 +459,9 @@ function migrateNodes(nodes) {
             const oldRoof = node;
             const suffix = id.includes('_') ? id.split('_')[1] : Math.random().toString(36).slice(2);
             const segmentId = `rseg_${suffix}`;
+            const segWidth = oldRoof.length ?? 8;
+            const segDepth = (oldRoof.leftWidth ?? 2.2) + (oldRoof.rightWidth ?? 2.2);
+            const legacyRoofHeight = oldRoof.height ?? 2.5;
             const segment = {
                 object: 'node',
                 id: segmentId,
@@ -254,10 +472,18 @@ function migrateNodes(nodes) {
                 position: [0, 0, 0],
                 rotation: 0,
                 roofType: 'gable',
-                width: oldRoof.length ?? 8,
-                depth: (oldRoof.leftWidth ?? 2.2) + (oldRoof.rightWidth ?? 2.2),
-                wallHeight: 0,
-                roofHeight: oldRoof.height ?? 2.5,
+                width: segWidth,
+                depth: segDepth,
+                // Schema default (0.5), NOT 0: a zero-height wall builds a flat,
+                // degenerate CSG brush → "Coplanar clip not handled" + NaN geometry, so
+                // the migrated legacy roof never renders. New roofs use 0.5 too.
+                wallHeight: 0.5,
+                pitch: getPitchFromActiveRoofHeight({
+                    roofType: 'gable',
+                    width: segWidth,
+                    depth: segDepth,
+                    roofHeight: legacyRoofHeight,
+                }),
                 wallThickness: 0.1,
                 deckThickness: 0.1,
                 overhang: 0.3,
@@ -269,11 +495,47 @@ function migrateNodes(nodes) {
                 children: [segmentId],
             };
         }
+        // 2b. roof-segment: guarantee a valid positive pitch (degrees).
+        // Saved scenes wrote `roofHeight` in metres; the schema now stores `pitch`
+        // in degrees. Convert the legacy field when present, and — crucially — fall
+        // back to the schema default for any segment that carries no usable pitch or
+        // roofHeight (older/partial saves). Without this, the slope-frame guard
+        // resolves a missing pitch to a FLAT frame, so the roof renders as a slab.
+        // The migration result is cast, not zod-parsed, so the schema default never
+        // applies on its own — this branch is the only place it lands.
+        if (node.type === 'roof-segment') {
+            const currentPitch = node.pitch;
+            const hasValidPitch = typeof currentPitch === 'number' && currentPitch > 0;
+            if (!hasValidPitch) {
+                const { roofHeight, ...rest } = node;
+                const width = typeof node.width === 'number' ? node.width : 8;
+                const depth = typeof node.depth === 'number' ? node.depth : 6;
+                const roofType = (typeof node.roofType === 'string' ? node.roofType : 'gable');
+                const derived = typeof roofHeight === 'number' && roofHeight > 0
+                    ? getPitchFromActiveRoofHeight({ roofType, width, depth, roofHeight })
+                    : 0;
+                // 40° matches the RoofSegmentNode schema default.
+                patchedNodes[id] = { ...rest, pitch: derived > 0 ? derived : 40 };
+            }
+        }
+        if (node.type === 'door') {
+            const normalized = normalizeDoorNode(node);
+            if (normalized) {
+                patchedNodes[id] = normalized;
+            }
+        }
+        if (node.type === 'window') {
+            const normalized = normalizeWindowNode(node);
+            if (normalized) {
+                patchedNodes[id] = normalized;
+            }
+        }
         if (node.type === 'stair') {
             const normalized = normalizeStairNode(migrateStairSurfaceMaterials(node));
             if (normalized) {
                 patchedNodes[id] = normalized;
             }
+            patchedNodes[id] = migrateStairSurfaceSlots(patchedNodes[id], mintedMaterials);
         }
         if (node.type === 'stair-segment') {
             const normalized = normalizeStairSegmentNode(node);
@@ -282,13 +544,172 @@ function migrateNodes(nodes) {
             }
         }
         if (node.type === 'wall') {
-            patchedNodes[id] = migrateWallSurfaceMaterials(patchedNodes[id]);
+            patchedNodes[id] = migrateWallSurfaceMaterials(patchedNodes[id], mintedMaterials);
+        }
+        // Cabinet v2→v3: node-level `doorStyle` was dead (geometry reads only the
+        // per-compartment `doorType`) and was removed from both cabinet schemas;
+        // `handlePosition: 'edge'` behaved identically to 'auto' and was dropped
+        // from the enum; the compartment stack became a discriminated union that
+        // rejects a `cooktopLayout` mismatched to its gas/induction type (the old
+        // loose schema ignored it).
+        if (node.type === 'cabinet' || node.type === 'cabinet-module') {
+            const { doorStyle: _doorStyle, ...rest } = node;
+            const next = rest;
+            if (next.handlePosition === 'edge')
+                next.handlePosition = 'auto';
+            if (Array.isArray(next.stack)) {
+                next.stack = next.stack.map((compartment) => {
+                    if (!compartment || typeof compartment !== 'object')
+                        return compartment;
+                    const layout = compartment.cooktopLayout;
+                    if (typeof layout !== 'string')
+                        return compartment;
+                    if (compartment.type === 'cooktop-gas' && !layout.startsWith('gas-')) {
+                        return { ...compartment, cooktopLayout: 'gas-4burner' };
+                    }
+                    if (compartment.type === 'cooktop-induction' && !layout.startsWith('induction-')) {
+                        return { ...compartment, cooktopLayout: 'induction-4zone' };
+                    }
+                    return compartment;
+                });
+            }
+            patchedNodes[id] = next;
+        }
+        if (node.type === 'slab' || node.type === 'ceiling') {
+            patchedNodes[id] = migrateSingleMaterialSlots(patchedNodes[id], ['surface'], mintedMaterials);
+        }
+        if (node.type === 'fence') {
+            patchedNodes[id] = migrateSingleMaterialSlots(patchedNodes[id], ['posts', 'infill', 'base', 'rail'], mintedMaterials);
+        }
+        if (node.type === 'column') {
+            patchedNodes[id] = migrateSingleMaterialSlots(patchedNodes[id], ['shaft', 'base', 'capital', 'frame'], mintedMaterials);
+        }
+        if (node.type === 'shelf') {
+            const normalized = normalizeShelfNode(node);
+            if (normalized) {
+                patchedNodes[id] = normalized;
+            }
+            patchedNodes[id] = migrateSingleMaterialSlots(patchedNodes[id], ['shelves', 'frame', 'back'], mintedMaterials);
+        }
+        // Roof-segment hosting was added in this migration cycle (the same
+        // pattern as shelf above). Older segments saved before the schema
+        // gained `children` need the field initialised so
+        // `createNode(chimney, segmentId)` finds an array to append to —
+        // without this every "Add Element" click on the roof panel results
+        // in an orphaned accessory (parented in scene state but never
+        // appended to `seg.children`, so the renderer's recursive
+        // `<NodeRenderer>` mount never sees it).
+        if (node.type === 'roof-segment' && !Array.isArray(node.children)) {
+            patchedNodes[id] = { ...node, children: [] };
+        }
+        // Roof-hosted wall children (door / window / item) originally stored
+        // SEGMENT-LOCAL positions with the face yaw in rotation[1]; the
+        // format moved to explicit `roofFace` + FACE-LOCAL coords so the
+        // renderer's face frame can track segment edits live. Convert in
+        // place: face from the old cardinal yaw, u/v from the outer-plane
+        // projection, z re-based from the outer plane to the wall mid-plane.
+        if ((node.type === 'door' || node.type === 'window' || node.type === 'item') &&
+            typeof node.roofSegmentId === 'string' &&
+            node.roofFace === undefined) {
+            const current = patchedNodes[id];
+            const segment = patchedNodes[current.roofSegmentId];
+            if (segment?.type === 'roof-segment') {
+                const tau = Math.PI * 2;
+                const yaw = (((current.rotation?.[1] ?? 0) % tau) + tau) % tau;
+                const eps = 1e-3;
+                const face = yaw < eps || tau - yaw < eps
+                    ? 'front'
+                    : Math.abs(yaw - Math.PI) < eps
+                        ? 'back'
+                        : Math.abs(yaw - Math.PI / 2) < eps
+                            ? 'right'
+                            : Math.abs(yaw - (3 * Math.PI) / 2) < eps
+                                ? 'left'
+                                : null;
+                if (face) {
+                    const { u, v, dist } = segmentPointToRoofWallFace(segment, face, current.position);
+                    patchedNodes[id] = {
+                        ...current,
+                        roofFace: face,
+                        position: [u, v, dist + (segment.wallThickness ?? 0.1) / 2],
+                        rotation: [0, 0, 0],
+                    };
+                }
+            }
         }
         if (node.type === 'roof') {
             patchedNodes[id] = migrateRoofSurfaceMaterials(patchedNodes[id]);
         }
+        // Legacy: site.children used to hold nested BuildingNode / ItemNode
+        // objects (see the SiteNode schema before the children-as-ids fix).
+        // Flatten any leftover nested children into ids, and absorb the
+        // embedded nodes into the flat map so the rest of the loader can
+        // treat the site like every other parent.
+        if (node.type === 'site' && Array.isArray(node.children)) {
+            let needsFlatten = false;
+            const flattened = [];
+            for (const child of node.children) {
+                if (typeof child === 'string') {
+                    flattened.push(child);
+                }
+                else if (child && typeof child === 'object' && typeof child.id === 'string') {
+                    needsFlatten = true;
+                    flattened.push(child.id);
+                    if (!patchedNodes[child.id]) {
+                        patchedNodes[child.id] = { ...child, parentId: id };
+                    }
+                }
+            }
+            if (needsFlatten) {
+                patchedNodes[id] = { ...node, children: flattened };
+            }
+        }
+        // Level children normalization.
+        // Pre-0.9.1 JSONs may carry child IDs that no longer exist in the node
+        // map (e.g. elevator IDs that lived under a level before the elevator
+        // parent migration moved them up to building). If those dangling IDs are
+        // left in place, collectReachableNodeIds marks the level as having
+        // reachable children that don't exist, which corrupts the scene graph
+        // traversal and leaves the LevelNode in a broken state — making floors
+        // impossible to drag or delete after import.
+        // We intentionally do NOT filter by type prefix here; being permissive
+        // about which types are allowed as children prevents data loss when new
+        // child types are added to the schema in the future.
+        if (node.type === 'level') {
+            const rawChildren = getStringArray(node.children);
+            const validChildren = rawChildren.filter((childId) => {
+                const exists = Boolean(patchedNodes[childId]);
+                if (!exists) {
+                    console.warn('[migrateNodes] level', id, 'references missing child', childId, '— dropping');
+                }
+                return exists;
+            });
+            const levelNumber = getFiniteNumber(node.level, 0);
+            patchedNodes[id] = {
+                ...node,
+                level: levelNumber,
+                children: validChildren,
+            };
+        }
+    }
+    // Pass 2: elevator migration.
+    // migrateElevatorParent mutates the parent level's children array (removes
+    // the elevator ID from it). Running this after Pass 1 guarantees that the
+    // level normalization above has already seen a clean children list — if we
+    // ran elevator migration inside Pass 1, the order of Object.entries
+    // iteration would be non-deterministic: processing an elevator before its
+    // parent level would mutate the level's children mid-iteration, potentially
+    // causing the level branch above to see a stale node reference.
+    for (const [id, node] of Object.entries(patchedNodes)) {
+        if (node.type !== 'elevator')
+            continue;
+        const parentMigrated = migrateElevatorParent(id, node, patchedNodes);
+        const normalized = normalizeElevatorNode(parentMigrated);
+        if (normalized) {
+            patchedNodes[id] = normalized;
+        }
     }
-    return patchedNodes;
+    return { nodes: patchedNodes, mintedMaterials };
 }
 function getNodeChildIds(node) {
     if (!('children' in node && Array.isArray(node.children))) {
@@ -347,6 +768,9 @@ const useScene = create()(temporal((set, get) => ({
     dirtyNodes: new Set(),
     // 4. Collections
     collections: {},
+    materials: {},
+    installedPlugins: [],
+    hasExplicitPluginInstallState: false,
     // 5. Read-only lock
     readOnly: false,
     setReadOnly: (readOnly) => set({ readOnly }),
@@ -356,15 +780,25 @@ const useScene = create()(temporal((set, get) => ({
             rootNodeIds: [],
             dirtyNodes: new Set(),
             collections: {},
+            materials: {},
+            installedPlugins: [],
+            hasExplicitPluginInstallState: false,
         });
     },
     clearScene: () => {
+        const installedPlugins = get().installedPlugins;
+        const hasExplicitPluginInstallState = get().hasExplicitPluginInstallState;
         get().unloadScene();
         get().loadScene(); // Default scene
+        set({ installedPlugins, hasExplicitPluginInstallState });
     },
-    setScene: (nodes, rootNodeIds) => {
+    setScene: (nodes, rootNodeIds, extra) => {
         // Apply backward compatibility migrations
-        const patchedNodes = migrateNodes(nodes);
+        const { nodes: patchedNodes, mintedMaterials } = migrateNodes(nodes);
+        // Scene materials minted by the wall legacy→slots migration join the
+        // loaded palette (existing refs win on id collision — there are none,
+        // ids are freshly generated).
+        const materials = { ...mintedMaterials, ...(extra?.materials ?? {}) };
         // Remove orphans: nodes whose parentId points to a non-existent node
         const cleanedNodes = { ...patchedNodes };
         for (const node of Object.values(cleanedNodes)) {
@@ -373,12 +807,6 @@ const useScene = create()(temporal((set, get) => ({
                 delete cleanedNodes[node.id];
             }
         }
-        set({
-            nodes: cleanedNodes,
-            rootNodeIds,
-            dirtyNodes: new Set(),
-            collections: {},
-        });
         const normalizedRootNodeIds = normalizeRootNodeIds(cleanedNodes, rootNodeIds);
         const reachableNodeIds = collectReachableNodeIds(cleanedNodes, normalizedRootNodeIds);
         if (normalizedRootNodeIds.length > 0) {
@@ -389,17 +817,47 @@ const useScene = create()(temporal((set, get) => ({
                 delete cleanedNodes[node.id];
             }
         }
+        // Single tracked `set`: with zundo, every tracked write pushes the
+        // 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: {},
+            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);
         });
     },
+    setInstalledPlugins: (pluginIds, options) => {
+        if (get().readOnly)
+            return;
+        const nextInstalledPlugins = Array.from(new Set(pluginIds));
+        const previousInstalledPlugins = get().installedPlugins;
+        const dirtyNodes = new Set(get().dirtyNodes);
+        for (const node of Object.values(get().nodes)) {
+            if (!getNodePluginId(node.type))
+                continue;
+            if (!isNodeKindEnabled(node.type, nextInstalledPlugins)) {
+                dirtyNodes.delete(node.id);
+            }
+            else if (!isNodeKindEnabled(node.type, previousInstalledPlugins)) {
+                if (nodeRegistry.get(node.type)?.dirtyTracking !== false)
+                    dirtyNodes.add(node.id);
+            }
+        }
+        set({
+            installedPlugins: nextInstalledPlugins,
+            hasExplicitPluginInstallState: options?.explicit ?? get().hasExplicitPluginInstallState,
+            dirtyNodes,
+        });
+    },
     loadScene: () => {
         if (get().rootNodeIds.length > 0) {
             // Assign all nodes as dirty to force re-validation
@@ -417,7 +875,7 @@ const useScene = create()(temporal((set, get) => ({
             children: [level0.id],
         });
         const site = SiteNode.parse({
-            children: [building],
+            children: [building.id],
         });
         // Define all nodes flat
         const nodes = {
@@ -430,6 +888,11 @@ 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)
+            return;
         get().dirtyNodes.add(id);
     },
     clearDirty: (id) => {
@@ -437,6 +900,7 @@ const useScene = create()(temporal((set, get) => ({
     },
     createNodes: (ops) => nodeActions.createNodesAction(set, get, ops),
     createNode: (node, parentId) => nodeActions.createNodesAction(set, get, [{ node, parentId }]),
+    applyNodeChanges: (changes) => nodeActions.applyNodeChangesAction(set, get, changes),
     updateNodes: (updates) => nodeActions.updateNodesAction(set, get, updates),
     updateNode: (id, data) => nodeActions.updateNodesAction(set, get, [{ id, data }]),
     // --- DELETE ---
@@ -540,10 +1004,37 @@ const useScene = create()(temporal((set, get) => ({
             return { collections: nextCollections, nodes: nextNodes };
         });
     },
+    // --- SCENE MATERIALS ---
+    addSceneMaterial: (material) => {
+        if (get().readOnly)
+            return;
+        set((state) => ({
+            materials: { ...state.materials, [material.id]: material },
+        }));
+    },
+    updateSceneMaterial: (id, data) => {
+        if (get().readOnly)
+            return;
+        set((state) => {
+            const material = state.materials[id];
+            if (!material)
+                return state;
+            return { materials: { ...state.materials, [id]: { ...material, ...data } } };
+        });
+    },
+    removeSceneMaterial: (id) => {
+        if (get().readOnly)
+            return;
+        set((state) => {
+            const materials = { ...state.materials };
+            delete materials[id];
+            return { materials };
+        });
+    },
 }), {
     partialize: (state) => {
-        const { nodes, rootNodeIds, collections } = state;
-        return { nodes, rootNodeIds, collections };
+        const { nodes, rootNodeIds, collections, materials, installedPlugins } = state;
+        return { nodes, rootNodeIds, collections, materials, installedPlugins };
     },
     limit: 50, // Limit to last 50 actions
 }));
@@ -554,6 +1045,12 @@ let prevFutureLength = 0;
 let prevNodesSnapshot = null;
 export function clearSceneHistory() {
     resetSceneHistoryPauseDepth();
+    // Resetting the pause-depth counter without resuming would strand the
+    // temporal store in `isTracking: false` if a pause window was active when
+    // the scene was (re)loaded — every edit after the load would then be
+    // invisible to undo. Resume unconditionally so the cleared history starts
+    // tracking from the loaded baseline.
+    useScene.temporal.getState().resume();
     useScene.temporal.getState().clear();
     prevPastLength = 0;
     prevFutureLength = 0;