@pascal-app/core 0.9.1 → 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;AA8rBrB,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;
@@ -329,24 +331,11 @@ function getSpiralOpeningPolygon(stair, offset = 0) {
         return toWorldPlanPoint(stair, Math.cos(angle) * radius, Math.sin(angle) * radius);
     });
 }
-function getSpiralLandingPolygon(stair, offset = 0) {
-    const width = Math.max(stair.width ?? 1, 0.4);
-    const outerRadius = Math.max(0.05, (stair.innerRadius ?? 0.9) + width);
-    const depth = Math.max(stair.topLandingDepth ?? 0.9, 0.1);
-    const halfWidth = width / 2;
-    const localPoints = [
-        [outerRadius - offset, -halfWidth - offset],
-        [outerRadius + depth + offset, -halfWidth - offset],
-        [outerRadius + depth + offset, halfWidth + offset],
-        [outerRadius - offset, halfWidth + offset],
-    ];
-    return localPoints.map(([x, z]) => toWorldPlanPoint(stair, x, z));
-}
 function getStraightOpeningPolygonsForSurface(stair, nodes, targetElevation, openingOffsetOverride) {
     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 = [];
@@ -413,11 +402,7 @@ function getStairOpeningPolygons(stair, nodes, targetElevation, openingOffsetOve
     }
     if (stair.stairType === 'spiral') {
         const offset = Math.max(openingOffset - STAIR_SLAB_OPENING_TIGHTENING, 0);
-        const polygons = [getSpiralOpeningPolygon(stair, offset)];
-        if (stair.topLandingMode === 'integrated') {
-            polygons.push(getSpiralLandingPolygon(stair, offset));
-        }
-        return polygons;
+        return [getSpiralOpeningPolygon(stair, offset)];
     }
     if (typeof targetElevation === 'number') {
         return getStraightOpeningPolygonsForSurface(stair, nodes, targetElevation, openingOffset);
@@ -439,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.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wall-mitering.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-mitering.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAO5C,MAAM,WAAW,OAAO;IACtB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAED,MAAM,WAAW,uBAAuB;IACtC,SAAS,EAAE,OAAO,CAAA;IAClB,UAAU,EAAE,OAAO,CAAA;IACnB,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,OAAO,CAAA;CAClB;AASD,KAAK,iBAAiB,GAAG,GAAG,CAAC,MAAM,EAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC,CAAA;AAGzE,KAAK,YAAY,GAAG,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAA;AAQlD,iBAAS,UAAU,CAAC,CAAC,EAAE,OAAO,EAAE,SAAS,SAAY,GAAG,MAAM,CAG7D;AA8CD,UAAU,QAAQ;IAChB,YAAY,EAAE,OAAO,CAAA;IACrB,cAAc,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,QAAQ,CAAC;QAAC,OAAO,EAAE,OAAO,GAAG,KAAK,GAAG,aAAa,CAAA;KAAE,CAAC,CAAA;CACpF;AAoND,MAAM,WAAW,aAAa;IAE5B,YAAY,EAAE,YAAY,CAAA;IAE1B,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;CACjC;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,aAAa,CAWrE;AAED,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,QAAQ,EACd,SAAS,EAAE,aAAa,GACvB,uBAAuB,GAAG,IAAI,CA0BhC;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,EAAE,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CA8C/F;AAGD,OAAO,EAAE,UAAU,EAAE,CAAA"}
+{"version":3,"file":"wall-mitering.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-mitering.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAO5C,MAAM,WAAW,OAAO;IACtB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAED,MAAM,WAAW,uBAAuB;IACtC,SAAS,EAAE,OAAO,CAAA;IAClB,UAAU,EAAE,OAAO,CAAA;IACnB,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,OAAO,CAAA;CAClB;AASD,KAAK,iBAAiB,GAAG,GAAG,CAAC,MAAM,EAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC,CAAA;AAGzE,KAAK,YAAY,GAAG,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAA;AAmBlD,iBAAS,UAAU,CAAC,CAAC,EAAE,OAAO,EAAE,SAAS,SAAY,GAAG,MAAM,CAG7D;AA8CD,UAAU,QAAQ;IAChB,YAAY,EAAE,OAAO,CAAA;IACrB,cAAc,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,QAAQ,CAAC;QAAC,OAAO,EAAE,OAAO,GAAG,KAAK,GAAG,aAAa,CAAA;KAAE,CAAC,CAAA;CACpF;AAkPD,MAAM,WAAW,aAAa;IAE5B,YAAY,EAAE,YAAY,CAAA;IAE1B,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;CACjC;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,aAAa,CAWrE;AAED,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,QAAQ,EACd,SAAS,EAAE,aAAa,GACvB,uBAAuB,GAAG,IAAI,CA0BhC;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,EAAE,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CA8C/F;AAGD,OAAO,EAAE,UAAU,EAAE,CAAA"}

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

@@ -3,6 +3,16 @@ import { getWallCurveFrameAt, isCurvedWall } from './wall-curve';
 // UTILITY FUNCTIONS
 // ============================================================================
 const TOLERANCE = 0.001;
+// Miter joints are line-line intersections, so the joint point sits a distance
+// ≈ halfThickness / sin(θ) from the junction, where θ is the angle between the
+// two walls. As θ → 0 (two walls nearly collinear — e.g. a room-preset preview
+// dragged on top of an existing wall, or a freshly-drawn wall almost parallel
+// to its neighbour) that distance runs away to infinity and the wall renders as
+// an infinite spike. Cap the joint at this multiple of the wall half-thickness;
+// beyond it we fall back to a square (butt) joint, exactly like the existing
+// parallel-walls guard. 10× preserves every realistic corner (a 0.1 m wall keeps
+// mitering down to ~11°) while bounding the pathological near-collinear case.
+const MITER_LIMIT = 10;
 function pointToKey(p, tolerance = TOLERANCE) {
     const snap = 1 / tolerance;
     return `${Math.round(p.x * snap)},${Math.round(p.y * snap)}`;
@@ -107,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,
@@ -120,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) {
@@ -144,7 +154,14 @@ function calculateJunctionIntersections(junction, getThickness) {
                 const edgeA = createLineFromPointAndVector(pA, v);
                 const edgeB = createLineFromPointAndVector(pB, v);
                 const angle = Math.atan2(v.y, v.x);
-                processedWalls.push({ wallId: wall.id, angle, edgeA, edgeB, isPassthrough: true });
+                processedWalls.push({
+                    wallId: wall.id,
+                    angle,
+                    edgeA,
+                    edgeB,
+                    isPassthrough: true,
+                    halfThickness: halfT,
+                });
             }
         }
         else {
@@ -159,7 +176,14 @@ function calculateJunctionIntersections(junction, getThickness) {
             const edgeA = createLineFromPointAndVector(pA, v);
             const edgeB = createLineFromPointAndVector(pB, v);
             const angle = Math.atan2(v.y, v.x);
-            processedWalls.push({ wallId: wall.id, angle, edgeA, edgeB, isPassthrough: false });
+            processedWalls.push({
+                wallId: wall.id,
+                angle,
+                edgeA,
+                edgeB,
+                isPassthrough: false,
+                halfThickness: halfT,
+            });
         }
     }
     // Sort by outgoing angle
@@ -182,6 +206,18 @@ function calculateJunctionIntersections(junction, getThickness) {
             x: (wall1.edgeA.b * wall2.edgeB.c - wall2.edgeB.b * wall1.edgeA.c) / det,
             y: (wall2.edgeB.a * wall1.edgeA.c - wall1.edgeA.a * wall2.edgeB.c) / det,
         };
+        // Miter limit: `det` only catches walls that are *exactly* parallel. Two
+        // walls meeting at a shallow angle have a small-but-nonzero `det`, so `p`
+        // lands far from the junction (∝ 1/sin θ) and the wall renders as an
+        // infinite spike. Reject any joint farther than MITER_LIMIT half-thicknesses
+        // from the meeting point — those walls fall back to a square joint.
+        const maxMiter = MITER_LIMIT * Math.max(wall1.halfThickness, wall2.halfThickness);
+        const dx = p.x - meetingPoint.x;
+        const dy = p.y - meetingPoint.y;
+        if (!(Number.isFinite(p.x) && Number.isFinite(p.y)) ||
+            dx * dx + dy * dy > maxMiter * maxMiter) {
+            continue;
+        }
         // Only assign intersection to non-passthrough walls
         // Passthrough walls don't receive junction data (their geometry doesn't change)
         if (!wall1.isPassthrough) {

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

@@ -4,6 +4,7 @@ export type SceneGraph = {
     nodes: Record<AnyNodeId, AnyNode>;
     rootNodeIds: AnyNodeId[];
     collections?: Record<CollectionId, Collection>;
+    installedPlugins?: string[];
 };
 /**
  * Deep clones a scene graph with all node IDs regenerated while preserving

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":"AAAA,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;CAC/C,CAAA;AAUD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,UAAU,GAAG,UAAU,CAuGlE;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,CA8E/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,CAoEZ"}
+{"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"}