@pascal-app/core 0.9.1 → 0.9.2

package/dist/store/use-scene.js

@@ -1,16 +1,23 @@
 '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) {
@@ -93,6 +100,13 @@ 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,
@@ -182,40 +196,127 @@ function migrateElevatorParent(id, node, nodes) {
         parentId: buildingId,
     };
 }
-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,
-    };
-    if (!(hasInterior || hasExterior)) {
-        if (legacyFinish.material === undefined && legacyFinish.materialPreset === undefined) {
-            return node;
+// 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);
         }
-        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 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 (!hasExterior) {
-        return {
-            ...node,
-            exteriorMaterial: node.interiorMaterial,
-            exteriorMaterialPreset: node.interiorMaterialPreset,
+    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 node;
+    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,
+        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';
@@ -334,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)) {
@@ -410,11 +524,18 @@ function migrateNodes(nodes) {
                 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);
@@ -423,20 +544,52 @@ function migrateNodes(nodes) {
             }
         }
         if (node.type === 'wall') {
-            patchedNodes[id] = migrateWallSurfaceMaterials(patchedNodes[id]);
+            patchedNodes[id] = migrateWallSurfaceMaterials(patchedNodes[id], mintedMaterials);
         }
-        if (node.type === 'shelf') {
-            const normalized = normalizeShelfNode(node);
-            if (normalized) {
-                patchedNodes[id] = normalized;
+        // 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 === 'elevator') {
-            const parentMigrated = migrateElevatorParent(id, node, patchedNodes);
-            const normalized = normalizeElevatorNode(parentMigrated);
+        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
@@ -449,6 +602,41 @@ function migrateNodes(nodes) {
         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]);
         }
@@ -476,8 +664,52 @@ function migrateNodes(nodes) {
                 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))) {
@@ -536,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 }),
@@ -545,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)) {
@@ -562,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) {
@@ -578,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
@@ -619,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) => {
@@ -730,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
 }));
@@ -744,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;

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

@@ -51,7 +51,7 @@ export function resolveElevatorServiceLevels(elevator, nodes) {
 }
 export function getElevatorLevelHeight(levelId, nodes) {
     const level = nodes[levelId];
-    if (!level || level.type !== 'level')
+    if (level?.type !== 'level')
         return DEFAULT_ELEVATOR_LEVEL_HEIGHT;
     let maxTop = 0;
     for (const childId of level.children) {

package/dist/systems/fence/fence-centerline.d.ts

@@ -0,0 +1,12 @@
+import type { FenceNode } from '../../schema';
+import type { Point2D } from '../wall/wall-mitering';
+type CurveFrame = {
+    point: Point2D;
+    tangent: Point2D;
+    normal: Point2D;
+};
+export declare function getFenceCenterlineFrameAt(fence: FenceNode, t: number): CurveFrame;
+export declare function sampleFenceCenterline(fence: FenceNode, segments?: number): Point2D[];
+export declare function getFenceCenterlineLength(fence: FenceNode, segments?: number): number;
+export {};
+//# sourceMappingURL=fence-centerline.d.ts.map

package/dist/systems/fence/fence-centerline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fence-centerline.d.ts","sourceRoot":"","sources":["../../../src/systems/fence/fence-centerline.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAE7C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAA;AAqBpD,KAAK,UAAU,GAAG;IAChB,KAAK,EAAE,OAAO,CAAA;IACd,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,EAAE,OAAO,CAAA;CAChB,CAAA;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,SAAS,EAAE,CAAC,EAAE,MAAM,GAAG,UAAU,CAKjF;AAED,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,SAAS,EAChB,QAAQ,SAA0B,GACjC,OAAO,EAAE,CASX;AAED,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,SAAS,EAChB,QAAQ,SAA0B,GACjC,MAAM,CAOR"}

package/dist/systems/fence/fence-centerline.js

@@ -0,0 +1,37 @@
+import { getWallCurveFrameAt, getWallCurveLength, sampleWallCenterline } from '../wall/wall-curve';
+import { getFenceSplineFrameAt, getFenceSplineLength, isSplineFence, sampleFenceSpline, } from './fence-spline';
+/**
+ * Unified fence centerline accessors. A fence is either:
+ *   - a spline fence (`path` of >= 2 control points) → smooth Catmull-Rom, or
+ *   - a straight / single-arc fence (`start`/`end` + optional `curveOffset`).
+ *
+ * These wrappers branch on `isSplineFence` and return the SAME shapes the wall
+ * arc helpers return, so every consumer (3D geometry, 2D floor-plan, length,
+ * handles) can sample the centerline without caring which kind it is. Wall arc
+ * math in `wall-curve.ts` is untouched — walls never carry a `path`.
+ */
+const DEFAULT_SAMPLE_SEGMENTS = 96;
+export function getFenceCenterlineFrameAt(fence, t) {
+    if (isSplineFence(fence) && fence.path) {
+        return getFenceSplineFrameAt(fence.path, t, fence.tangents);
+    }
+    return getWallCurveFrameAt(fence, t);
+}
+export function sampleFenceCenterline(fence, segments = DEFAULT_SAMPLE_SEGMENTS) {
+    if (isSplineFence(fence) && fence.path) {
+        // Spread the requested sample budget across the spans so a long path still
+        // reads smoothly without exploding the point count.
+        const spanCount = Math.max(1, fence.path.length - 1);
+        const perSpan = Math.max(2, Math.ceil(segments / spanCount));
+        return sampleFenceSpline(fence.path, fence.tangents, perSpan);
+    }
+    return sampleWallCenterline(fence, segments);
+}
+export function getFenceCenterlineLength(fence, segments = DEFAULT_SAMPLE_SEGMENTS) {
+    if (isSplineFence(fence) && fence.path) {
+        const spanCount = Math.max(1, fence.path.length - 1);
+        const perSpan = Math.max(2, Math.ceil(segments / spanCount));
+        return getFenceSplineLength(fence.path, fence.tangents, perSpan);
+    }
+    return getWallCurveLength(fence, segments);
+}

package/dist/systems/fence/fence-spline.d.ts

@@ -0,0 +1,39 @@
+import type { FenceNode } from '../../schema';
+import type { Point2D } from '../wall/wall-mitering';
+type FenceSplineLike = Pick<FenceNode, 'path'>;
+type TangentList = ReadonlyArray<readonly [number, number] | null> | undefined;
+export declare function isSplineFence(fence: FenceSplineLike): boolean;
+type CurveFrame = {
+    point: Point2D;
+    tangent: Point2D;
+    normal: Point2D;
+};
+/**
+ * OUT-handle offset vector for control point `index` — the stored tangent if
+ * the user has adjusted it, otherwise the automatic distance-aware tangent
+ * (endpoints duplicate the neighbour so the ends stay tangent to their single
+ * span). The IN handle is the negation of this.
+ *
+ * Exported so the editing UI can draw the tangent line / handle dots at the
+ * right place even before the user has dragged them.
+ */
+export declare function getFenceControlHandle(path: ReadonlyArray<readonly [number, number]>, tangents: TangentList, index: number): Point2D;
+export declare function getTwoPointFenceCurveTangents(path: ReadonlyArray<readonly [number, number]>): Array<[number, number] | null> | undefined;
+/**
+ * Sample the spline centerline into a polyline. Control points are honored as
+ * on-curve anchors; `segmentsPerSpan` controls smoothness between them.
+ * Returns `(segmentsPerSpan * spanCount) + 1` points, first == path[0],
+ * last == path[-1].
+ */
+export declare function sampleFenceSpline(path: ReadonlyArray<readonly [number, number]>, tangents?: TangentList, segmentsPerSpan?: number): Point2D[];
+/**
+ * Frame (point + tangent + normal) at parameter `t` in [0, 1] along the spline
+ * centerline. Same return shape as `getWallCurveFrameAt` so it is a drop-in for
+ * the arc branch. `t` is uniform over the sampled polyline (arc length is not
+ * reparameterised — adequate for marching posts / rails and far cheaper).
+ */
+export declare function getFenceSplineFrameAt(path: ReadonlyArray<readonly [number, number]>, t: number, tangents?: TangentList, segmentsPerSpan?: number): CurveFrame;
+/** Total polyline length of the sampled spline centerline. */
+export declare function getFenceSplineLength(path: ReadonlyArray<readonly [number, number]>, tangents?: TangentList, segmentsPerSpan?: number): number;
+export {};
+//# sourceMappingURL=fence-spline.d.ts.map

package/dist/systems/fence/fence-spline.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fence-spline.d.ts","sourceRoot":"","sources":["../../../src/systems/fence/fence-spline.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAC7C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAA;AA0BpD,KAAK,eAAe,GAAG,IAAI,CAAC,SAAS,EAAE,MAAM,CAAC,CAAA;AAC9C,KAAK,WAAW,GAAG,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,SAAS,CAAA;AAE9E,wBAAgB,aAAa,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAE7D;AAED,KAAK,UAAU,GAAG;IAChB,KAAK,EAAE,OAAO,CAAA;IACd,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,EAAE,OAAO,CAAA;CAChB,CAAA;AAkBD;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAC9C,QAAQ,EAAE,WAAW,EACrB,KAAK,EAAE,MAAM,GACZ,OAAO,CAiCT;AAED,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,GAC7C,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC,GAAG,SAAS,CAyB5C;AAkBD;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAC9C,QAAQ,CAAC,EAAE,WAAW,EACtB,eAAe,SAA4B,GAC1C,OAAO,EAAE,CA0BX;AA4CD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAC9C,CAAC,EAAE,MAAM,EACT,QAAQ,CAAC,EAAE,WAAW,EACtB,eAAe,SAA4B,GAC1C,UAAU,CAEZ;AAED,8DAA8D;AAC9D,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAC9C,QAAQ,CAAC,EAAE,WAAW,EACtB,eAAe,SAA4B,GAC1C,MAAM,CAOR"}