@pascal-app/core 0.9.2 → 1.0.0-beta.1

package/dist/systems/stair/stair-opening-preview.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stair-opening-preview.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-opening-preview.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAC7E,OAA6B,EAAE,KAAK,iBAAiB,EAAE,MAAM,qCAAqC,CAAA;AAClG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAA;AAGpE,KAAK,oBAAoB,GAAG;IAC1B,EAAE,EAAE,SAAS,CAAA;IACb,IAAI,EAAE,OAAO,CAAC,QAAQ,GAAG,WAAW,CAAC,CAAA;CACtC,CAAA;AAoBD,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,EAClD,aAAa,EAAE,WAAW,CAAC,MAAM,EAAE,iBAAiB,CAAC,EACrD,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAAC,WAYvC;AAED,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,EAClD,aAAa,EAAE,WAAW,CAAC,MAAM,EAAE,iBAAiB,CAAC,EACrD,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwBvC;AAED,wBAAgB,qCAAqC;;mBAUlC,oBAAoB,EAAE;;EAiCxC"}
+{"version":3,"file":"stair-opening-preview.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-opening-preview.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAC7E,OAA6B,EAAE,KAAK,iBAAiB,EAAE,MAAM,qCAAqC,CAAA;AAClG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAA;AAGpE,KAAK,oBAAoB,GAAG;IAC1B,EAAE,EAAE,SAAS,CAAA;IACb,IAAI,EAAE,OAAO,CAAC,QAAQ,GAAG,WAAW,CAAC,CAAA;CACtC,CAAA;AAoBD,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,EAClD,aAAa,EAAE,WAAW,CAAC,MAAM,EAAE,iBAAiB,CAAC,EACrD,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAAC,WAYvC;AAED,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,EAClD,aAAa,EAAE,WAAW,CAAC,MAAM,EAAE,iBAAiB,CAAC,EACrD,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwBvC;AAED,wBAAgB,qCAAqC;;mBAUlC,oBAAoB,EAAE;;EAiCxC"}

package/dist/systems/stair/stair-opening-sync.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stair-opening-sync.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-opening-sync.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EACT,WAAW,EACX,QAAQ,EAIT,MAAM,cAAc,CAAA;AA0qBrB,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;QAQvC,SAAS;UAAQ,OAAO,CAAC,QAAQ,GAAG,WAAW,CAAC;IAqG5E"}
+{"version":3,"file":"stair-opening-sync.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-opening-sync.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EACT,WAAW,EACX,QAAQ,EAIT,MAAM,cAAc,CAAA;AA8qBrB,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;QAQvC,SAAS;UAAQ,OAAO,CAAC,QAAQ,GAAG,WAAW,CAAC;IAqG5E"}

package/dist/systems/stair/stair-opening-sync.js

@@ -1,7 +1,9 @@
 import { resolveBuildingForLevel, resolveLevelId } from '../../hooks/spatial-grid/spatial-grid-sync';
 import { polygonContainsPolygon, polygonsOverlap } from '../../lib/polygon-relations';
-import { DEFAULT_WALL_HEIGHT } from '../wall/wall-footprint';
+import { resolveCeilingHeight } from '../../services/level-height';
+import { getLevelElevations } from '../../services/storey';
 import { computeSegmentTransforms, rotateXZ } from './stair-footprint';
+import { resolveStairTotalRise } from './stair-rise';
 const CURVED_STAIR_SLAB_OPENING_RATIO = 0.8;
 const STRAIGHT_STAIR_TARGET_THRESHOLD_MIN = 0.35;
 const STAIR_SLAB_OPENING_TIGHTENING = 0;
@@ -333,7 +335,7 @@ function getStraightOpeningPolygonsForSurface(stair, nodes, targetElevation, ope
     const layouts = getStraightStairLayouts(stair, nodes);
     if (layouts.length === 0)
         return [];
-    const riserHeight = (stair.totalRise ?? 2.5) / Math.max(stair.stepCount ?? 10, 1);
+    const riserHeight = resolveStairTotalRise(stair, nodes) / Math.max(stair.stepCount ?? 10, 1);
     const targetThreshold = Math.max(riserHeight * 2, STRAIGHT_STAIR_TARGET_THRESHOLD_MIN);
     const openingOffset = Math.max(openingOffsetOverride ?? stair.openingOffset ?? 0, 0);
     const openingRects = [];
@@ -422,25 +424,26 @@ function getApplicableStairOpeningPolygons(stair, nodes, targetElevation, surfac
 }
 function getTargetSlabElevationForStair(stair, slab, slabLevelId, nodes) {
     const { fromLevelId } = getResolvedStairLevelIds(stair, nodes);
-    const fromLevel = getLevelNumber(fromLevelId, nodes);
-    const slabLevel = getLevelNumber(slabLevelId, nodes);
-    if (fromLevel === undefined || slabLevel === undefined) {
+    const elevations = getLevelElevations(nodes);
+    const fromElevation = fromLevelId ? elevations.get(fromLevelId) : undefined;
+    const slabElevation = elevations.get(slabLevelId);
+    if (!fromElevation || !slabElevation || fromElevation.buildingId !== slabElevation.buildingId) {
         return slab.elevation ?? 0.05;
     }
-    return ((slabLevel - fromLevel) * DEFAULT_WALL_HEIGHT +
-        (slab.elevation ?? 0.05) -
-        (stair.position[1] ?? 0));
+    return (slabElevation.baseY - fromElevation.baseY + (slab.elevation ?? 0.05) - (stair.position[1] ?? 0));
 }
 function getTargetCeilingElevationForStair(stair, ceiling, ceilingLevelId, nodes) {
     const { fromLevelId } = getResolvedStairLevelIds(stair, nodes);
-    const fromLevel = getLevelNumber(fromLevelId, nodes);
-    const ceilingLevel = getLevelNumber(ceilingLevelId, nodes);
-    if (fromLevel === undefined || ceilingLevel === undefined) {
-        return ceiling.height ?? DEFAULT_WALL_HEIGHT;
+    const elevations = getLevelElevations(nodes);
+    const fromElevation = fromLevelId ? elevations.get(fromLevelId) : undefined;
+    const ceilingElevation = elevations.get(ceilingLevelId);
+    const ceilingHeight = resolveCeilingHeight(ceiling, nodes);
+    if (!fromElevation ||
+        !ceilingElevation ||
+        fromElevation.buildingId !== ceilingElevation.buildingId) {
+        return ceilingHeight;
     }
-    return ((ceilingLevel - fromLevel) * DEFAULT_WALL_HEIGHT +
-        (ceiling.height ?? DEFAULT_WALL_HEIGHT) -
-        (stair.position[1] ?? 0));
+    return ceilingElevation.baseY - fromElevation.baseY + ceilingHeight - (stair.position[1] ?? 0);
 }
 function shouldApplyStairToSlab(stair, slabLevelId, nodes) {
     const { fromLevelId, toLevelId } = getResolvedStairLevelIds(stair, nodes);

package/dist/systems/stair/stair-opening-system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stair-opening-system.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-opening-system.tsx"],"names":[],"mappings":"AA2CA,eAAO,MAAM,kBAAkB,YAyF9B,CAAA"}
+{"version":3,"file":"stair-opening-system.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-opening-system.tsx"],"names":[],"mappings":"AA4CA,eAAO,MAAM,kBAAkB,YAoH9B,CAAA"}

package/dist/systems/stair/stair-opening-system.js

@@ -6,6 +6,7 @@ import useLiveTransforms from '../../store/use-live-transforms';
 import useScene from '../../store/use-scene';
 import { createSurfaceOpeningPreviewController, getNodesWithLiveStairOpeningInputs, hasLiveStairOpeningInputs, } from './stair-opening-preview';
 import { syncAutoStairOpenings } from './stair-opening-sync';
+import { syncStairRises } from './stair-rise';
 function isOpeningRelevantNode(node) {
     return (node?.type === 'building' ||
         node?.type === 'ceiling' ||
@@ -77,15 +78,41 @@ export const StairOpeningSystem = () => {
             }
             applyPreviewUpdates(syncAutoStairOpenings(getNodesWithLiveStairOpeningInputs(nodes, liveTransforms, liveOverrides, previewSurfaceIds)));
         };
-        applyUpdates(syncAutoStairOpenings(useScene.getState().nodes));
-        refreshLivePreview();
+        const runAutoSync = () => {
+            // Rise first: straight stairs converge their flight heights to the
+            // resolved rise (level height or deck elevation), and the opening pass
+            // reads those segment heights — so it must run against the post-rise
+            // nodes.
+            applyUpdates(syncStairRises(useScene.getState().nodes));
+            applyUpdates(syncAutoStairOpenings(useScene.getState().nodes));
+        };
+        let disposed = false;
+        let autoSyncQueued = false;
+        const scheduleAutoSync = () => {
+            if (autoSyncQueued)
+                return;
+            autoSyncQueued = true;
+            // One microtask later so every other scene-store listener for the
+            // triggering transition (and, at mount, the editor's spatial-grid
+            // init) runs first — the spatial-grid sync in particular. The
+            // deck-attached rise elects the stair's floor-stack base elevation
+            // through the spatial grid; syncing before the grid listener would
+            // rescale flights against the pre-transition slab state.
+            queueMicrotask(() => {
+                autoSyncQueued = false;
+                if (disposed)
+                    return;
+                runAutoSync();
+                refreshLivePreview();
+            });
+        };
+        scheduleAutoSync();
         const unsubscribeScene = useScene.subscribe((state, prevState) => {
             if (syncingAutoOpeningsRef.current)
                 return;
             if (!hasOpeningRelevantNodeChange(state.nodes, prevState.nodes))
                 return;
-            applyUpdates(syncAutoStairOpenings(state.nodes));
-            refreshLivePreview();
+            scheduleAutoSync();
         });
         const unsubscribeLiveTransforms = useLiveTransforms.subscribe(() => {
             refreshLivePreview();
@@ -94,6 +121,7 @@ export const StairOpeningSystem = () => {
             refreshLivePreview();
         });
         return () => {
+            disposed = true;
             unsubscribeScene();
             unsubscribeLiveTransforms();
             unsubscribeLiveOverrides();

package/dist/systems/stair/stair-rise.d.ts

@@ -0,0 +1,22 @@
+import type { AnyNode, AnyNodeId, StairNode } from '../../schema';
+export declare function resolveStairTotalRise(stair: StairNode, nodes: Record<string, AnyNode>): number;
+/**
+ * Keeps straight stairs' flight segments in step with the resolved rise.
+ * Straight-stair geometry derives from per-segment heights (not from
+ * `resolveStairTotalRise`), so level-height and deck-elevation changes must
+ * write through to the flight segments — curved/spiral stairs read the
+ * resolved rise directly and need no sync.
+ *
+ * Scope: stairs whose total the system owns — follows-mode stairs (absent
+ * `totalRise`, tracking their level or their deck) and deck-attached stairs
+ * (an explicit rise converges to the typed value). A detached stair with an
+ * explicit `totalRise` is the one place hand-edited segment chains are
+ * legitimate, so it is never touched. Flight heights scale proportionally
+ * (landings keep theirs); returns `updateNodes` patches, empty when every
+ * stair is already in step.
+ */
+export declare function syncStairRises(nodes: Record<string, AnyNode>): Array<{
+    id: AnyNodeId;
+    data: Partial<AnyNode>;
+}>;
+//# sourceMappingURL=stair-rise.d.ts.map

package/dist/systems/stair/stair-rise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stair-rise.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-rise.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAoB,MAAM,cAAc,CAAA;AAInF,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CA+B9F;AAID;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,KAAK,CAAC;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,CAAC,CAgClD"}

package/dist/systems/stair/stair-rise.js

@@ -0,0 +1,79 @@
+import { getFloorStackedPosition } from '../../hooks/spatial-grid/floor-placed-elevation';
+import { DEFAULT_LEVEL_HEIGHT } from '../../services/level-height';
+import { getStoredLevelHeight } from '../../services/storey';
+export function resolveStairTotalRise(stair, nodes) {
+    if (stair.totalRise !== undefined)
+        return stair.totalRise;
+    const level = Object.values(nodes).find((node) => node.type === 'level' && node.children.includes(stair.id));
+    if (stair.deckSlabId) {
+        const deck = nodes[stair.deckSlabId];
+        // The deck's `elevation` IS its walking surface (level-local), but the
+        // stair's own base may be lifted onto a floor slab by the floor-stack
+        // (`FloorElevationSystem` / `syncStairGroupElevation` put the group at
+        // `position[1] + elected slab elevation`). The rise is measured from
+        // that base, so subtract it — electing the base exactly the way the
+        // visual systems do (persisted `supportSlabId` honored, uncapped
+        // election otherwise) keeps base + rise landing precisely on the deck's
+        // walking surface. A stale reference (deck gone) falls through to the
+        // level-derived rise.
+        if (deck?.type === 'slab') {
+            const baseElevation = getFloorStackedPosition({
+                node: stair,
+                nodes,
+                position: stair.position,
+                rotation: stair.rotation,
+                levelId: level?.id ?? null,
+            })[1];
+            return (deck.elevation ?? 0.05) - baseElevation;
+        }
+    }
+    return level?.type === 'level' ? getStoredLevelHeight(level) : DEFAULT_LEVEL_HEIGHT;
+}
+const RISE_SYNC_EPSILON = 1e-4;
+/**
+ * Keeps straight stairs' flight segments in step with the resolved rise.
+ * Straight-stair geometry derives from per-segment heights (not from
+ * `resolveStairTotalRise`), so level-height and deck-elevation changes must
+ * write through to the flight segments — curved/spiral stairs read the
+ * resolved rise directly and need no sync.
+ *
+ * Scope: stairs whose total the system owns — follows-mode stairs (absent
+ * `totalRise`, tracking their level or their deck) and deck-attached stairs
+ * (an explicit rise converges to the typed value). A detached stair with an
+ * explicit `totalRise` is the one place hand-edited segment chains are
+ * legitimate, so it is never touched. Flight heights scale proportionally
+ * (landings keep theirs); returns `updateNodes` patches, empty when every
+ * stair is already in step.
+ */
+export function syncStairRises(nodes) {
+    const updates = [];
+    for (const node of Object.values(nodes)) {
+        if (node.type !== 'stair' || node.stairType !== 'straight')
+            continue;
+        const deck = node.deckSlabId ? nodes[node.deckSlabId] : undefined;
+        if (node.totalRise !== undefined && deck?.type !== 'slab')
+            continue;
+        const segments = (node.children ?? [])
+            .map((childId) => nodes[childId])
+            .filter((child) => child?.type === 'stair-segment');
+        const flights = segments.filter((segment) => segment.segmentType === 'stair');
+        if (flights.length === 0)
+            continue;
+        const landingRise = segments
+            .filter((segment) => segment.segmentType !== 'stair')
+            .reduce((sum, segment) => sum + segment.height, 0);
+        const flightRise = flights.reduce((sum, segment) => sum + segment.height, 0);
+        const targetFlightRise = resolveStairTotalRise(node, nodes) - landingRise;
+        if (targetFlightRise <= 0)
+            continue;
+        if (Math.abs(flightRise - targetFlightRise) <= RISE_SYNC_EPSILON)
+            continue;
+        for (const flight of flights) {
+            const height = flightRise > RISE_SYNC_EPSILON
+                ? flight.height * (targetFlightRise / flightRise)
+                : targetFlightRise / flights.length;
+            updates.push({ id: flight.id, data: { height } });
+        }
+    }
+    return updates;
+}

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

@@ -34,6 +34,16 @@ export declare function getWallChordFrame(wall: WallCurveLike): {
     };
     length: number;
 };
+export declare function getWallArcData(wall: WallCurveLike): {
+    center: {
+        x: number;
+        y: number;
+    };
+    radius: number;
+    startAngle: number;
+    delta: number;
+    direction: number;
+} | null;
 export declare function getWallCurveFrameAt(wall: WallCurveLike, t: number): CurveFrame;
 export declare function getWallMidpointHandlePoint(wall: WallCurveLike): Point2D;
 export declare function sampleWallCenterline(wall: WallCurveLike, segments?: number): Point2D[];

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

@@ -1 +1 @@
-{"version":3,"file":"wall-curve.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-curve.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AACvD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AAK9C,KAAK,aAAa,GAAG,IAAI,CAAC,QAAQ,GAAG,SAAS,EAAE,OAAO,GAAG,KAAK,GAAG,aAAa,CAAC,CAAA;AAEhF,KAAK,UAAU,GAAG;IAChB,KAAK,EAAE,OAAO,CAAA;IACd,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,EAAE,OAAO,CAAA;CAChB,CAAA;AAED,KAAK,yBAAyB,GAAG;IAC/B,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,CAAA;AAcD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAE9D;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAE5D;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,aAAa,UAErD;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,aAAa,UAExD;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,aAAa,UAE5D;AAWD,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,UAG3E;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,aAAa,UAI5D;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,aAAa,WAE/C;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,aAAa;;;;;;;;;;;;;EA6BpD;AA+BD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,aAAa,EAAE,CAAC,EAAE,MAAM,GAAG,UAAU,CAwC9E;AAED,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,aAAa,WAE7D;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,aAAa,EAAE,QAAQ,SAA0B,aAM3F;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,aAAa,EAAE,QAAQ,SAA0B,UASzF;AAED,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,IAAI,CAAC,QAAQ,GAAG,SAAS,EAAE,OAAO,GAAG,KAAK,GAAG,aAAa,GAAG,WAAW,CAAC,EAC/E,QAAQ,SAA0B,EAClC,cAAc,CAAC,EAAE,yBAAyB,aA2B3C"}
+{"version":3,"file":"wall-curve.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-curve.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AACvD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AAK9C,KAAK,aAAa,GAAG,IAAI,CAAC,QAAQ,GAAG,SAAS,EAAE,OAAO,GAAG,KAAK,GAAG,aAAa,CAAC,CAAA;AAEhF,KAAK,UAAU,GAAG;IAChB,KAAK,EAAE,OAAO,CAAA;IACd,OAAO,EAAE,OAAO,CAAA;IAChB,MAAM,EAAE,OAAO,CAAA;CAChB,CAAA;AAED,KAAK,yBAAyB,GAAG;IAC/B,SAAS,CAAC,EAAE,OAAO,CAAA;IACnB,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,CAAA;AAcD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAE9D;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAE5D;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,aAAa,UAErD;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,aAAa,UAExD;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,aAAa,UAE5D;AAWD,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,UAG3E;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,aAAa,UAI5D;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,aAAa,WAE/C;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,aAAa;;;;;;;;;;;;;EA6BpD;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,aAAa;;;;;;;;;SA2BjD;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,aAAa,EAAE,CAAC,EAAE,MAAM,GAAG,UAAU,CAwC9E;AAED,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,aAAa,WAE7D;AAED,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,aAAa,EAAE,QAAQ,SAA0B,aAM3F;AAED,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,aAAa,EAAE,QAAQ,SAA0B,UASzF;AAED,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,IAAI,CAAC,QAAQ,GAAG,SAAS,EAAE,OAAO,GAAG,KAAK,GAAG,aAAa,GAAG,WAAW,CAAC,EAC/E,QAAQ,SAA0B,EAClC,cAAc,CAAC,EAAE,yBAAyB,aA2B3C"}

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

@@ -71,7 +71,7 @@ export function getWallChordFrame(wall) {
         length,
     };
 }
-function getWallArcData(wall) {
+export function getWallArcData(wall) {
     const chord = getWallChordFrame(wall);
     const sagitta = getClampedWallCurveOffset(wall);
     if (Math.abs(sagitta) <= CURVE_EPSILON || chord.length < CURVE_EPSILON) {

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

@@ -117,10 +117,8 @@ function getWallBoundaryFrame(wall, endType) {
     const point = endType === 'start'
         ? { x: wall.start[0], y: wall.start[1] }
         : { x: wall.end[0], y: wall.end[1] };
-    const vector = endType === 'start'
-        ? { x: wall.end[0] - wall.start[0], y: wall.end[1] - wall.start[1] }
-        : { x: wall.start[0] - wall.end[0], y: wall.start[1] - wall.end[1] };
-    const length = Math.hypot(vector.x, vector.y);
+    const direction = { x: wall.end[0] - wall.start[0], y: wall.end[1] - wall.start[1] };
+    const length = Math.hypot(direction.x, direction.y);
     if (length < 1e-9) {
         return {
             point,
@@ -130,8 +128,10 @@ function getWallBoundaryFrame(wall, endType) {
     }
     return {
         point,
-        tangent: { x: vector.x / length, y: vector.y / length },
-        normal: { x: -vector.y / length, y: vector.x / length },
+        tangent: endType === 'start'
+            ? { x: direction.x / length, y: direction.y / length }
+            : { x: -direction.x / length, y: -direction.y / length },
+        normal: { x: -direction.y / length, y: direction.x / length },
     };
 }
 function calculateJunctionIntersections(junction, getThickness) {

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

@@ -0,0 +1,40 @@
+import type { WallNode } from '../../schema/nodes/wall';
+/**
+ * Minimum wall body height in meters. Governs both the wall height
+ * arrow's lower drag bound and the slab-elevation clamp: a slab may not
+ * rise past `storeyHeight - MIN_WALL_HEIGHT` while a plane-bound wall
+ * elects it as its base, or the wall's extrusion (plane minus base)
+ * would collapse below this minimum.
+ */
+export declare const MIN_WALL_HEIGHT = 0.5;
+/**
+ * Wall-top inversion (vertical building model): a wall with no stored
+ * `height` is plane-bound — its top sits at the storey plane (level-local
+ * Y = the level's stored height), so a slab lifting the wall's base makes
+ * the wall shorter, never taller, and no gap can open at the top of a
+ * level. A wall WITH `height` is an explicit exception (half wall,
+ * parapet) and keeps the legacy semantics: the top rides a raised elected
+ * base (`electedBase + height`), while a zero or sunken slab base leaves
+ * the top at `height` (the legacy negative-slab constraint). Explicit
+ * ground-hosted walls are the terrain exception: `height` is always body
+ * height, including below datum, so sculpting cannot stretch the wall.
+ *
+ * Returns the top in level-local Y (same frame as `electedBase`).
+ */
+export declare function resolveWallTop(wall: Pick<WallNode, 'height' | 'supportSlabId'>, storeyHeight: number, electedBase: number): number;
+/**
+ * Extruded height of the wall body: {@link resolveWallTop} minus the
+ * elected base. Base convention: the elected slab-support elevation itself
+ * — the viewer computes `effectiveBaseElevation = min(baseElevation,
+ * slabElevation)` and defaults `baseElevation` to the elected elevation,
+ * so with only the election in hand the two coincide. Fill-down below the
+ * elected base (`baseSegments`) is a geometry detail the extruder handles
+ * separately and never changes where the top sits.
+ *
+ * Equivalently: the wall-local Y of the wall's top, measured from the wall
+ * mesh origin (which sits at `electedBase`). May be non-positive when a
+ * slab reaches the storey plane; callers own the degenerate-geometry
+ * policy.
+ */
+export declare function resolveWallEffectiveHeight(wall: Pick<WallNode, 'height' | 'supportSlabId'>, storeyHeight: number, electedBase: number): number;
+//# sourceMappingURL=wall-top.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wall-top.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-top.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAEvD;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,MAAM,CAAA;AAElC;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,QAAQ,GAAG,eAAe,CAAC,EAChD,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM,GAClB,MAAM,CAIR;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,QAAQ,GAAG,eAAe,CAAC,EAChD,YAAY,EAAE,MAAM,EACpB,WAAW,EAAE,MAAM,GAClB,MAAM,CAER"}

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

@@ -0,0 +1,46 @@
+/**
+ * Minimum wall body height in meters. Governs both the wall height
+ * arrow's lower drag bound and the slab-elevation clamp: a slab may not
+ * rise past `storeyHeight - MIN_WALL_HEIGHT` while a plane-bound wall
+ * elects it as its base, or the wall's extrusion (plane minus base)
+ * would collapse below this minimum.
+ */
+export const MIN_WALL_HEIGHT = 0.5;
+/**
+ * Wall-top inversion (vertical building model): a wall with no stored
+ * `height` is plane-bound — its top sits at the storey plane (level-local
+ * Y = the level's stored height), so a slab lifting the wall's base makes
+ * the wall shorter, never taller, and no gap can open at the top of a
+ * level. A wall WITH `height` is an explicit exception (half wall,
+ * parapet) and keeps the legacy semantics: the top rides a raised elected
+ * base (`electedBase + height`), while a zero or sunken slab base leaves
+ * the top at `height` (the legacy negative-slab constraint). Explicit
+ * ground-hosted walls are the terrain exception: `height` is always body
+ * height, including below datum, so sculpting cannot stretch the wall.
+ *
+ * Returns the top in level-local Y (same frame as `electedBase`).
+ */
+export function resolveWallTop(wall, storeyHeight, electedBase) {
+    if (wall.height == null)
+        return storeyHeight;
+    if (wall.supportSlabId === 'ground')
+        return electedBase + wall.height;
+    return electedBase > 0 ? electedBase + wall.height : wall.height;
+}
+/**
+ * Extruded height of the wall body: {@link resolveWallTop} minus the
+ * elected base. Base convention: the elected slab-support elevation itself
+ * — the viewer computes `effectiveBaseElevation = min(baseElevation,
+ * slabElevation)` and defaults `baseElevation` to the elected elevation,
+ * so with only the election in hand the two coincide. Fill-down below the
+ * elected base (`baseSegments`) is a geometry detail the extruder handles
+ * separately and never changes where the top sits.
+ *
+ * Equivalently: the wall-local Y of the wall's top, measured from the wall
+ * mesh origin (which sits at `electedBase`). May be non-positive when a
+ * slab reaches the storey plane; callers own the degenerate-geometry
+ * policy.
+ */
+export function resolveWallEffectiveHeight(wall, storeyHeight, electedBase) {
+    return resolveWallTop(wall, storeyHeight, electedBase) - electedBase;
+}

package/dist/utils/clone-scene-graph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clone-scene-graph.d.ts","sourceRoot":"","sources":["../../src/utils/clone-scene-graph.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAEnD,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAErE,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,WAAW,EAAE,SAAS,EAAE,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC,YAAY,EAAE,UAAU,CAAC,CAAA;IAC9C,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC5B,CAAA;AAUD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,UAAU,GAAG,UAAU,CAmHlE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,OAAO,EAAE,SAAS,GACjB;IAAE,WAAW,EAAE,OAAO,EAAE,CAAC;IAAC,UAAU,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAwF/E;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB,CAAA;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,UAAU,EACtB,OAAO,GAAE,qBAA0B,GAClC,UAAU,CAqEZ"}
+{"version":3,"file":"clone-scene-graph.d.ts","sourceRoot":"","sources":["../../src/utils/clone-scene-graph.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAEnD,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAErE,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,WAAW,EAAE,SAAS,EAAE,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC,YAAY,EAAE,UAAU,CAAC,CAAA;IAC9C,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC5B,CAAA;AAUD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,UAAU,GAAG,UAAU,CAuIlE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,OAAO,EAAE,SAAS,GACjB;IAAE,WAAW,EAAE,OAAO,EAAE,CAAC;IAAC,UAAU,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CAsG/E;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB,CAAA;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,UAAU,EACtB,OAAO,GAAE,qBAA0B,GAClC,UAAU,CAqEZ"}

package/dist/utils/clone-scene-graph.js

@@ -1,4 +1,5 @@
-import { remapMeasurementReferences } from '../lib/measurement-geometry';
+import { GROUND_SUPPORT_ID } from '../hooks/spatial-grid/floor-placed-elevation';
+import { remapConstructionDimensionReferences, remapMeasurementReferences, } from '../lib/measurement-geometry';
 import { generateId } from '../schema/base';
 /**
  * Extracts the type prefix from a node ID (e.g., "wall_abc123" -> "wall")
@@ -29,7 +30,7 @@ export function cloneSceneGraph(sceneGraph) {
     const clonedNodes = {};
     for (const [oldId, node] of Object.entries(nodes)) {
         const newId = idMap.get(oldId);
-        const clonedNode = structuredClone({ ...node, id: newId });
+        let clonedNode = structuredClone({ ...node, id: newId });
         // Remap parentId
         if (clonedNode.parentId && typeof clonedNode.parentId === 'string') {
             clonedNode.parentId = (idMap.get(clonedNode.parentId) ?? null);
@@ -63,9 +64,24 @@ export function cloneSceneGraph(sceneGraph) {
             ;
             clonedNode.roofSegmentId = idMap.get(clonedNode.roofSegmentId);
         }
+        // Remap supportSlabId (persisted slab-support hosts). The 'ground'
+        // sentinel is not a node id — keep it as-is.
+        if ('supportSlabId' in clonedNode &&
+            typeof clonedNode.supportSlabId === 'string' &&
+            clonedNode.supportSlabId !== GROUND_SUPPORT_ID) {
+            ;
+            clonedNode.supportSlabId = idMap.get(clonedNode.supportSlabId);
+        }
+        if ('deckSlabId' in clonedNode && typeof clonedNode.deckSlabId === 'string') {
+            ;
+            clonedNode.deckSlabId = idMap.get(clonedNode.deckSlabId);
+        }
         if (clonedNode.type === 'measurement') {
             clonedNode.measurement = remapMeasurementReferences(clonedNode.measurement, idMap);
         }
+        if (clonedNode.type === 'construction-dimension') {
+            clonedNode = remapConstructionDimensionReferences(clonedNode, idMap);
+        }
         clonedNodes[newId] = clonedNode;
     }
     // Remap root node IDs
@@ -166,7 +182,7 @@ export function cloneLevelSubtree(nodes, levelId) {
             continue;
         const newId = idMap.get(oldId);
         // JSON roundtrip: safely strips functions, Object3D, circular refs, etc.
-        const cloned = JSON.parse(JSON.stringify(node));
+        let cloned = JSON.parse(JSON.stringify(node));
         cloned.id = newId;
         // Remap parentId — but only for descendants, not the level node itself
         // (the level's parentId points to the building, which is outside the subtree)
@@ -201,9 +217,24 @@ export function cloneLevelSubtree(nodes, levelId) {
             cloned.roofSegmentId =
                 idMap.get(cloned.roofSegmentId) ?? cloned.roofSegmentId;
         }
+        // Remap supportSlabId when the host slab is inside the cloned subtree;
+        // preserve it otherwise (like wallId, the reference may point outside).
+        if ('supportSlabId' in cloned && typeof cloned.supportSlabId === 'string') {
+            ;
+            cloned.supportSlabId =
+                idMap.get(cloned.supportSlabId) ?? cloned.supportSlabId;
+        }
+        if ('deckSlabId' in cloned && typeof cloned.deckSlabId === 'string') {
+            ;
+            cloned.deckSlabId =
+                idMap.get(cloned.deckSlabId) ?? cloned.deckSlabId;
+        }
         if (cloned.type === 'measurement') {
             cloned.measurement = remapMeasurementReferences(cloned.measurement, idMap);
         }
+        if (cloned.type === 'construction-dimension') {
+            cloned = remapConstructionDimensionReferences(cloned, idMap);
+        }
         clonedNodes.push(cloned);
     }
     return { clonedNodes, newLevelId, idMap };

package/dist/utils/heal-scene-graph.d.ts

@@ -2,7 +2,7 @@ export interface HealSceneResult {
     nodes: Record<string, unknown>;
     /** Ids of zero-length walls that were dropped. */
     droppedWallIds: string[];
-    /** Count of non-string (e.g. null) entries removed from `children` arrays. */
+    /** Count of invalid non-string (e.g. null) entries removed from `children` arrays. */
     strippedChildRefs: number;
     /**
      * Count of child references removed because the child's `parentId` points at

package/dist/utils/heal-scene-graph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"heal-scene-graph.d.ts","sourceRoot":"","sources":["../../src/utils/heal-scene-graph.ts"],"names":[],"mappings":"AAqBA,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,kDAAkD;IAClD,cAAc,EAAE,MAAM,EAAE,CAAA;IACxB,8EAA8E;IAC9E,iBAAiB,EAAE,MAAM,CAAA;IACzB;;;OAGG;IACH,sBAAsB,EAAE,MAAM,CAAA;CAC/B;AAgBD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,eAAe,CA0D9E"}
+{"version":3,"file":"heal-scene-graph.d.ts","sourceRoot":"","sources":["../../src/utils/heal-scene-graph.ts"],"names":[],"mappings":"AAqBA,MAAM,WAAW,eAAe;IAC9B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,kDAAkD;IAClD,cAAc,EAAE,MAAM,EAAE,CAAA;IACxB,sFAAsF;IACtF,iBAAiB,EAAE,MAAM,CAAA;IACzB;;;OAGG;IACH,sBAAsB,EAAE,MAAM,CAAA;CAC/B;AAgBD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,eAAe,CA2E9E"}

package/dist/utils/heal-scene-graph.js

@@ -54,26 +54,42 @@ export function healSceneNodes(input) {
     const dropped = new Set(droppedWallIds);
     let strippedChildRefs = 0;
     let strippedStaleChildRefs = 0;
-    // Pass 2: clean `children` arrays — drop non-string entries (the `[null]`
-    // bug), references to walls we just removed, same-array duplicates, and
-    // stale references whose child's `parentId` names a different parent.
+    // Pass 2: clean `children` arrays — drop invalid non-string entries (the
+    // `[null]` bug), references to walls we just removed, same-array duplicates,
+    // and stale references whose child's `parentId` names a different parent.
+    // Legacy sites embedded full child objects; keep those for migrateNodes to
+    // flatten after healing instead of disconnecting the entire building.
     const nodes = {};
     for (const [id, node] of Object.entries(kept)) {
         const children = node?.children;
         if (Array.isArray(children)) {
             const seen = new Set();
-            const cleaned = children.filter((c) => {
-                if (typeof c !== 'string' || dropped.has(c)) {
+            const cleaned = children.filter((child) => {
+                const embeddedSiteChildId = node.type === 'site' &&
+                    child &&
+                    typeof child === 'object' &&
+                    typeof child.id === 'string'
+                    ? child.id
+                    : null;
+                if (embeddedSiteChildId) {
+                    if (seen.has(embeddedSiteChildId)) {
+                        strippedStaleChildRefs++;
+                        return false;
+                    }
+                    seen.add(embeddedSiteChildId);
+                    return true;
+                }
+                if (typeof child !== 'string' || dropped.has(child)) {
                     strippedChildRefs++;
                     return false;
                 }
-                if (seen.has(c)) {
+                if (seen.has(child)) {
                     strippedStaleChildRefs++;
                     return false;
                 }
-                seen.add(c);
-                const child = kept[c];
-                if (child && typeof child.parentId === 'string' && child.parentId !== id) {
+                seen.add(child);
+                const childNode = kept[child];
+                if (childNode && typeof childNode.parentId === 'string' && childNode.parentId !== id) {
                     strippedStaleChildRefs++;
                     return false;
                 }

package/dist/validation/validate-build-json.d.ts

@@ -9,6 +9,8 @@ export type ValidationIssue = {
 export type BuildStats = {
     total: number;
     byType: Partial<Record<AnyNodeType, number>>;
+    /** Kinds outside the static schema union but registered at runtime (plugins). */
+    pluginTypes: Record<string, number>;
     unknownTypes: Record<string, number>;
     floorAreaM2: number;
 };

package/dist/validation/validate-build-json.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validate-build-json.d.ts","sourceRoot":"","sources":["../../src/validation/validate-build-json.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAG3D,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,SAAS,CAAA;AAEpD,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,EAAE,kBAAkB,CAAA;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC,CAAA;IAC5C,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACpC,WAAW,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,WAAW,EAAE,MAAM,EAAE,CAAA;IACrB,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC5B,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,uBAAuB,GAAG;IACpC,EAAE,EAAE,OAAO,CAAA;IACX,MAAM,EAAE,eAAe,GAAG,IAAI,CAAA;IAC9B,KAAK,EAAE,UAAU,CAAA;IACjB,MAAM,EAAE,eAAe,EAAE,CAAA;IACzB,QAAQ,EAAE,eAAe,EAAE,CAAA;IAC3B,YAAY,EAAE,WAAW,EAAE,CAAA;IAC3B,gBAAgB,EAAE,MAAM,CAAA;CACzB,CAAA;AA8BD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,uBAAuB,CAwPzE"}
+{"version":3,"file":"validate-build-json.d.ts","sourceRoot":"","sources":["../../src/validation/validate-build-json.ts"],"names":[],"mappings":"AACA,OAAO,EAAW,KAAK,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAG3D,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,SAAS,CAAA;AAEpD,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,EAAE,kBAAkB,CAAA;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC,CAAA;IAC5C,iFAAiF;IACjF,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACpC,WAAW,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,WAAW,EAAE,MAAM,EAAE,CAAA;IACrB,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC5B,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,uBAAuB,GAAG;IACpC,EAAE,EAAE,OAAO,CAAA;IACX,MAAM,EAAE,eAAe,GAAG,IAAI,CAAA;IAC9B,KAAK,EAAE,UAAU,CAAA;IACjB,MAAM,EAAE,eAAe,EAAE,CAAA;IACzB,QAAQ,EAAE,eAAe,EAAE,CAAA;IAC3B,YAAY,EAAE,WAAW,EAAE,CAAA;IAC3B,gBAAgB,EAAE,MAAM,CAAA;CACzB,CAAA;AA8BD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,uBAAuB,CA8SzE"}