@pascal-app/nodes 0.1.1 → 1.0.0-beta.1

package/dist/wall/paint.js

@@ -1,6 +1,7 @@
 import { getEffectiveWallSurfaceMaterial, getWallBandSlotId, getWallFaceBandConfig, getWallFaceBandForHeight, getWallSurfaceSideFromBandSlot, parseMaterialRef, sceneRegistry, useScene, WALL_SURFACE_SLOT_DEFAULTS, } from '@pascal-app/core';
 import { Raycaster } from 'three';
 import { buildSlotPreviewMaterial, createSlotPaintCapability, previewSlotByUserData, } from '../shared/slot-paint';
+import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling';
 const WALL_SLOT_IDS = new Set(Object.keys(WALL_SURFACE_SLOT_DEFAULTS));
 const WALL_ARRAY_SLOT_INDEX = {
     interior: 1,
@@ -68,10 +69,11 @@ export function resolveWallRole(args) {
         return indexedSlotId;
     }
     if (sideFromIndex && localPosition) {
-        const bands = getWallFaceBandConfig(node);
+        const effectiveWallHeight = resolveWallOpeningCeiling(node, useScene.getState().nodes);
+        const bands = getWallFaceBandConfig(node, effectiveWallHeight);
         if (!bands.enabled)
             return sideFromIndex;
-        return getWallBandSlotId(sideFromIndex, getWallFaceBandForHeight(node, localPosition[1]));
+        return getWallBandSlotId(sideFromIndex, getWallFaceBandForHeight(node, localPosition[1], effectiveWallHeight));
     }
     if (sideFromIndex)
         return sideFromIndex;
@@ -88,16 +90,18 @@ export function resolveWallRole(args) {
     const hitFace = localZ >= 0 ? 'front' : 'back';
     const semantic = hitFace === 'front' ? node.frontSide : node.backSide;
     if (semantic === 'interior' || semantic === 'exterior') {
-        const bands = getWallFaceBandConfig(node);
+        const effectiveWallHeight = resolveWallOpeningCeiling(node, useScene.getState().nodes);
+        const bands = getWallFaceBandConfig(node, effectiveWallHeight);
         if (!bands.enabled)
             return semantic;
-        return getWallBandSlotId(semantic, getWallFaceBandForHeight(node, localPosition[1]));
+        return getWallBandSlotId(semantic, getWallFaceBandForHeight(node, localPosition[1], effectiveWallHeight));
     }
     const side = hitFace === 'front' ? 'interior' : 'exterior';
-    const bands = getWallFaceBandConfig(node);
+    const effectiveWallHeight = resolveWallOpeningCeiling(node, useScene.getState().nodes);
+    const bands = getWallFaceBandConfig(node, effectiveWallHeight);
     if (!bands.enabled)
         return side;
-    return getWallBandSlotId(side, getWallFaceBandForHeight(node, localPosition[1]));
+    return getWallBandSlotId(side, getWallFaceBandForHeight(node, localPosition[1], effectiveWallHeight));
 }
 /**
  * Preview a wall paint by swapping just the painted face's entry in the wall

package/dist/wall/panel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/wall/panel.tsx"],"names":[],"mappings":"AAmEA,MAAM,CAAC,OAAO,UAAU,SAAS,uCA8OhC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/wall/panel.tsx"],"names":[],"mappings":"AAoEA,MAAM,CAAC,OAAO,UAAU,SAAS,uCAwRhC"}

package/dist/wall/panel.js

@@ -5,6 +5,7 @@ import { ActionButton, ActionGroup, curveReshapeScope, getLinearUnitLabel, linea
 import { useViewer } from '@pascal-app/viewer';
 import { Spline } from 'lucide-react';
 import { useCallback, useMemo, useRef } from 'react';
+import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling';
 const WALL_TRIM_PROFILE_OPTIONS = {
     skirting: [
         { label: 'Flat', value: 'flat' },
@@ -63,6 +64,15 @@ export default function WallPanel() {
             return false;
         });
     });
+    // Existing plane-bound walls have no stored height. Resolve their current
+    // body height for display and materialize it if the user edits height or
+    // enables terrain infill.
+    const resolvedHeightMeters = useScene((s) => {
+        const wall = selectedId ? s.nodes[selectedId] : undefined;
+        if (wall?.type !== 'wall')
+            return undefined;
+        return resolveWallOpeningCeiling(wall, s.nodes);
+    });
     // Mirror the latest node into a ref so the slider handlers below have
     // stable identities across re-renders. Without this, every store tick
     // (one per pointermove during a slider drag) rebuilt the handler
@@ -93,6 +103,16 @@ export default function WallPanel() {
         ];
         handleUpdate({ end: newEnd });
     }, [handleUpdate]);
+    const handleBaseModeChange = useCallback((mode) => {
+        const n = nodeRef.current;
+        if (!n)
+            return;
+        const height = n.height ?? resolveWallOpeningCeiling(n, useScene.getState().nodes);
+        handleUpdate({
+            height: Math.max(0.1, height),
+            fillToTerrain: mode === 'terrain' ? true : undefined,
+        });
+    }, [handleUpdate]);
     const handleClose = useCallback(() => {
         setSelection({ selectedIds: [] });
     }, [setSelection]);
@@ -106,7 +126,8 @@ export default function WallPanel() {
     if (!(node && node.type === 'wall' && selectedId))
         return null;
     const length = getWallCurveLength(node);
-    const height = node.height ?? 2.5;
+    const followsTerrain = node.fillToTerrain === true;
+    const height = node.height ?? resolvedHeightMeters ?? 2.5;
     const thickness = node.thickness ?? 0.1;
     const curveOffset = getClampedWallCurveOffset(node);
     const maxCurveOffset = getMaxWallCurveOffset(node);
@@ -117,14 +138,20 @@ export default function WallPanel() {
     const displayCurveOffset = metersToLinearUnit(curveOffset, unit);
     const displayMaxCurveOffset = metersToLinearUnit(maxCurveOffset, unit);
     const curveOffsetLimit = Math.max(0.01, maxCurveOffset);
-    const wallHeightMeters = node.height ?? 2.5;
+    const wallHeightMeters = height;
     const skirting = { ...WALL_SKIRTING_DEFAULT, ...(node.skirting ?? {}) };
     const crown = { ...WALL_CROWN_DEFAULT, ...(node.crown ?? {}) };
     const chairRail = { ...WALL_CHAIR_RAIL_DEFAULT, ...(node.chairRail ?? {}) };
     return (_jsxs(PanelWrapper, { icon: "/icons/wall.webp", onClose: handleClose, title: node.name || 'Wall', width: 280, children: [_jsxs(PanelSection, { title: "Dimensions", children: [_jsx(SliderControl, { label: "Length", max: metersToLinearUnit(20, unit), min: metersToLinearUnit(0.1, unit), onChange: (value) => handleUpdateLength(linearControlValueToMeters(value, unit, { maxMeters: 20, minMeters: 0.1 })), precision: 2, step: unit === 'imperial' ? 0.1 : 0.01, unit: unitLabel, value: displayLength }), _jsx(SliderControl, { label: "Height", max: metersToLinearUnit(6, unit), min: metersToLinearUnit(0.1, unit), onChange: (v) => handleUpdate({
                             height: linearControlValueToMeters(v, unit, { maxMeters: 6, minMeters: 0.1 }),
-                        }), precision: 2, step: 0.1, unit: unitLabel, value: Math.round(displayHeight * 100) / 100 }), _jsx(SliderControl, { label: "Thickness", max: metersToLinearUnit(1, unit), min: metersToLinearUnit(0.05, unit), onChange: (v) => handleUpdate({
-                            thickness: linearControlValueToMeters(v, unit, { maxMeters: 1, minMeters: 0.05 }),
+                        }), precision: 2, step: 0.1, unit: unitLabel, value: Math.round(displayHeight * 100) / 100 }), _jsx("div", { className: "px-1 font-medium text-[10px] text-muted-foreground/80 uppercase tracking-wider", children: "Base" }), _jsx(SegmentedControl, { onChange: handleBaseModeChange, options: [
+                            { label: 'Fixed', value: 'fixed' },
+                            { label: 'Follows level', value: 'terrain' },
+                        ], value: followsTerrain ? 'terrain' : 'fixed' }), followsTerrain && (_jsx("div", { className: "px-1 text-[11px] text-muted-foreground", children: "Extends downward to meet the terrain. Height and top stay unchanged." })), _jsx(SliderControl, { label: "Thickness", max: metersToLinearUnit(1, unit), min: metersToLinearUnit(0.05, unit), onChange: (v) => handleUpdate({
+                            thickness: linearControlValueToMeters(v, unit, {
+                                maxMeters: 1,
+                                minMeters: 0.05,
+                            }),
                         }), precision: 3, step: 0.01, unit: unitLabel, value: Math.round(displayThickness * 1000) / 1000 }), !hasWallChildrenBlockingCurve && (_jsx(SliderControl, { label: "Curve", max: Math.max(metersToLinearUnit(0.01, unit), displayMaxCurveOffset), min: -Math.max(metersToLinearUnit(0.01, unit), displayMaxCurveOffset), onChange: (v) => handleUpdate({
                             curveOffset: normalizeWallCurveOffset(node, linearControlValueToMeters(v, unit, {
                                 maxMeters: curveOffsetLimit,
@@ -133,7 +160,7 @@ export default function WallPanel() {
                         }), precision: 2, step: 0.1, unit: unitLabel, value: Math.round(displayCurveOffset * 100) / 100 }))] }), _jsx(WallFaceBandSection, { node: node, onUpdate: handleUpdate, unit: unit, unitLabel: unitLabel, wallHeightMeters: wallHeightMeters }), _jsx(WallTrimSection, { node: node, onUpdate: handleUpdate, title: "Skirting", trimKey: "skirting", trimValue: skirting, unit: unit, unitLabel: unitLabel, wallHeightMeters: wallHeightMeters }), _jsx(WallTrimSection, { node: node, onUpdate: handleUpdate, title: "Crown molding", trimKey: "crown", trimValue: crown, unit: unit, unitLabel: unitLabel, wallHeightMeters: wallHeightMeters }), _jsx(WallTrimSection, { node: node, onUpdate: handleUpdate, title: "Chair rail", trimKey: "chairRail", trimValue: chairRail, unit: unit, unitLabel: unitLabel, wallHeightMeters: wallHeightMeters }), !hasWallChildrenBlockingCurve && (_jsx(PanelSection, { title: "Actions", children: _jsx(ActionGroup, { children: _jsx(ActionButton, { icon: _jsx(Spline, { className: "h-3.5 w-3.5" }), label: "Curve", onClick: handleCurve }) }) }))] }));
 }
 function WallFaceBandSection({ node, onUpdate, unit, unitLabel, wallHeightMeters, }) {
-    const bandConfig = getWallFaceBandConfig(node);
+    const bandConfig = getWallFaceBandConfig(node, wallHeightMeters);
     const bandCount = bandConfig.count;
     const lowerHeight = bandConfig.lowerHeight;
     const middleHeight = bandConfig.middleHeight;

package/dist/wall/parametrics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/wall/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAC5D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAExC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,EAAE,oBAAoB,CAAC,QAAQ,CAiB1D,CAAA"}
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/wall/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAC5D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAExC;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,eAAe,EAAE,oBAAoB,CAAC,QAAQ,CAmB1D,CAAA"}

package/dist/wall/parametrics.js

@@ -16,6 +16,8 @@ export const wallParametrics = {
             label: 'Dimensions',
             fields: [
                 { key: 'thickness', kind: 'number', unit: 'm', min: 0.05, max: 0.6, step: 0.01 },
+                // `height` may be absent (plane-bound top); the custom panel owns the
+                // Follows storey / Custom height mode switch, so this is metadata only.
                 { key: 'height', kind: 'number', unit: 'm', min: 1.5, max: 6, step: 0.05 },
                 { key: 'curveOffset', kind: 'number', unit: 'm', min: -3, max: 3, step: 0.05 },
             ],

package/dist/wall/preview.d.ts

@@ -0,0 +1,8 @@
+import { type WallNode } from '@pascal-app/core';
+import { ExtrudeGeometry } from 'three';
+export declare function buildWallPreviewGeometry(node: Pick<WallNode, 'start' | 'end' | 'curveOffset' | 'height' | 'thickness'>): ExtrudeGeometry;
+declare const WallPreview: ({ node }: {
+    node: WallNode;
+}) => import("react").JSX.Element;
+export default WallPreview;
+//# sourceMappingURL=preview.d.ts.map

package/dist/wall/preview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"preview.d.ts","sourceRoot":"","sources":["../../src/wall/preview.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAyB,KAAK,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAGvE,OAAO,EAAE,eAAe,EAAS,MAAM,OAAO,CAAA;AAK9C,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,GAAG,KAAK,GAAG,aAAa,GAAG,QAAQ,GAAG,WAAW,CAAC,mBAsB/E;AAED,QAAA,MAAM,WAAW,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCAoBhD,CAAA;AAED,eAAe,WAAW,CAAA"}

package/dist/wall/preview.js

@@ -0,0 +1,39 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { getWallSurfacePolygon } from '@pascal-app/core';
+import { EDITOR_LAYER } from '@pascal-app/editor';
+import { useEffect, useMemo } from 'react';
+import { ExtrudeGeometry, Shape } from 'three';
+const WALL_PREVIEW_HEIGHT = 2.5;
+const WALL_PREVIEW_THICKNESS = 0.1;
+export function buildWallPreviewGeometry(node) {
+    const polygon = getWallSurfacePolygon({
+        start: node.start,
+        end: node.end,
+        curveOffset: node.curveOffset,
+        thickness: node.thickness ?? WALL_PREVIEW_THICKNESS,
+    });
+    const shape = new Shape();
+    polygon.forEach((point, index) => {
+        if (index === 0)
+            shape.moveTo(point.x, -point.y);
+        else
+            shape.lineTo(point.x, -point.y);
+    });
+    shape.closePath();
+    const geometry = new ExtrudeGeometry(shape, {
+        bevelEnabled: false,
+        depth: node.height ?? WALL_PREVIEW_HEIGHT,
+        steps: 1,
+    });
+    geometry.rotateX(-Math.PI / 2);
+    geometry.computeBoundingBox();
+    return geometry;
+}
+const WallPreview = ({ node }) => {
+    const { curveOffset, end, height, start, thickness } = node;
+    const geometry = useMemo(() => buildWallPreviewGeometry({ curveOffset, end, height, start, thickness }), [curveOffset, end, height, start, thickness]);
+    useEffect(() => () => geometry.dispose(), [geometry]);
+    return (_jsx("mesh", { geometry: geometry, layers: EDITOR_LAYER, raycast: () => undefined, renderOrder: 1, children: _jsx("meshBasicMaterial", { color: "#818cf8", depthTest: false, depthWrite: false, opacity: 0.5, transparent: true }) }));
+};
+export default WallPreview;

package/dist/wall/quick-measurement.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"quick-measurement.d.ts","sourceRoot":"","sources":["../../src/wall/quick-measurement.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,sBAAsB,EAC3B,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAEzB,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,GAAG,sBAAsB,CA6B3E"}
+{"version":3,"file":"quick-measurement.d.ts","sourceRoot":"","sources":["../../src/wall/quick-measurement.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,sBAAsB,EAE3B,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAGzB,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,GAAG,sBAAsB,CA6B3E"}

package/dist/wall/quick-measurement.js

@@ -1,7 +1,8 @@
-import { DEFAULT_WALL_HEIGHT, getWallCurveFrameAt, getWallCurveLength, getWallThickness, } from '@pascal-app/core';
+import { getWallCurveFrameAt, getWallCurveLength, getWallThickness, useScene, } from '@pascal-app/core';
+import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling';
 export function wallQuickMeasurement(node) {
     const length = getWallCurveLength(node);
-    const height = node.height ?? DEFAULT_WALL_HEIGHT;
+    const height = resolveWallOpeningCeiling(node, useScene.getState().nodes);
     const frame = getWallCurveFrameAt(node, 0.5);
     return {
         title: node.name ?? 'Wall',

package/dist/wall/renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/wall/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAKL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAOzB;;;;;;;;;;;;;;;;;;GAkBG;AACH,QAAA,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCAgFjD,CAAA;AAED,eAAe,YAAY,CAAA"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/wall/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAKL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AASzB;;;;;;;;;;;;;;;;;;GAkBG;AACH,QAAA,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCAyFjD,CAAA;AAED,eAAe,YAAY,CAAA"}

package/dist/wall/renderer.js

@@ -3,7 +3,9 @@ import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useRegistry, useScene, } from '@pascal-app/core';
 import { getVisibleWallMaterials, NodeRenderer, useNodeEvents, useViewer } from '@pascal-app/viewer';
 import { useEffect, useLayoutEffect, useMemo, useRef } from 'react';
+import { useShallow } from 'zustand/react/shallow';
 import { createPlaceholderGeometry } from '../shared/placeholder-geometry';
+import { useWallTreatmentLevelData } from './treatment-level-data';
 import { createWallExtraSlotMaterials, WallTreatments } from './treatments';
 /**
  * Thin wall renderer.
@@ -43,10 +45,10 @@ const WallRenderer = ({ node }) => {
     const textures = useViewer((s) => s.textures);
     const colorPreset = useViewer((s) => s.colorPreset);
     const sceneTheme = useViewer((s) => s.sceneTheme);
-    const sceneNodes = useScene((state) => state.nodes);
-    const childNodes = useMemo(() => (node.children ?? [])
-        .map((childId) => sceneNodes[childId])
-        .filter((child) => child !== undefined), [node.children, sceneNodes]);
+    const childNodes = useScene(useShallow((state) => (node.children ?? [])
+        .map((childId) => state.nodes[childId])
+        .filter((child) => child !== undefined)));
+    const treatmentLevelData = useWallTreatmentLevelData((state) => node.parentId ? state.byLevelId.get(node.parentId) : undefined);
     // Subscribe to the scene-material palette so editing a `scene:` material a
     // wall slot references re-renders the wall live (the wall-system geometry
     // dirty loop never fires for a material-only edit). `getMaterialsForWall`'s
@@ -60,6 +62,6 @@ const WallRenderer = ({ node }) => {
         for (const entry of owned)
             entry.dispose();
     }, [baseMaterials, extraMaterials]);
-    return (_jsxs("mesh", { castShadow: true, geometry: placeholderGeometry, material: baseMaterials, receiveShadow: true, ref: ref, visible: node.visible, children: [_jsx("mesh", { geometry: collisionPlaceholderGeometry, name: "collision-mesh", visible: false, ...handlers }), _jsx(WallTreatments, { childrenNodes: childNodes, materials: extraMaterials, node: node }), (node.children ?? []).map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, `${node.id}:${childId}`)))] }));
+    return (_jsxs("mesh", { castShadow: true, geometry: placeholderGeometry, material: baseMaterials, receiveShadow: true, ref: ref, visible: node.visible, children: [_jsx("mesh", { geometry: collisionPlaceholderGeometry, name: "collision-mesh", visible: false, ...handlers }), treatmentLevelData && (_jsx(WallTreatments, { childrenNodes: childNodes, levelData: treatmentLevelData, materials: extraMaterials, node: node })), (node.children ?? []).map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, `${node.id}:${childId}`)))] }));
 };
 export default WallRenderer;

package/dist/wall/system.d.ts

@@ -3,7 +3,7 @@
  *
  *  - **`WallSystem`** — reads `dirtyNodes`, batches by level, runs
  *    `calculateLevelMiters(levelWalls)`, rebuilds geometry via
- *    `generateExtrudedWall(node, children, miterData, slabElevation, baseElevation, baseSegments)`,
+ *    `generateExtrudedWall(node, children, miterData, slabElevation, baseElevation, baseSegments, storeyHeight)`,
  *    and cascades to adjacent walls that share a junction. This is the
  *    bulk of the wall runtime (~820 lines in viewer).
  *  - **`WallCutout`** — cutaway-mode hide/show logic based on camera

package/dist/wall/system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/wall/system.tsx"],"names":[],"mappings":"AAIA;;;;;;;;;;GAUG;AACH,QAAA,MAAM,WAAW,mCAOhB,CAAA;AAED,eAAe,WAAW,CAAA"}
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/wall/system.tsx"],"names":[],"mappings":"AAyCA;;;;;;;;;;GAUG;AACH,QAAA,MAAM,WAAW,mCAQhB,CAAA;AAED,eAAe,WAAW,CAAA"}

package/dist/wall/system.js

@@ -1,18 +1,53 @@
 'use client';
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useLiveNodeOverrides, useScene } from '@pascal-app/core';
 import { WallCutout, WallSystem } from '@pascal-app/viewer';
+import { useFrame } from '@react-three/fiber';
+import { buildWallTreatmentLevelData, useWallTreatmentLevelData } from './treatment-level-data';
+import { wallTreatmentProudOffsets } from './treatments';
+function effectiveWall(wall) {
+    const override = useLiveNodeOverrides.getState().get(wall.id);
+    return override ? { ...wall, ...override } : wall;
+}
+const WallTreatmentMiterSystem = () => {
+    useFrame(() => {
+        const { dirtyNodes, nodes } = useScene.getState();
+        if (dirtyNodes.size === 0)
+            return;
+        const dirtyLevelIds = new Set();
+        for (const id of dirtyNodes) {
+            const node = nodes[id];
+            if (node?.type === 'wall' && node.parentId)
+                dirtyLevelIds.add(node.parentId);
+        }
+        for (const levelId of dirtyLevelIds) {
+            const level = nodes[levelId];
+            if (level?.type !== 'level')
+                continue;
+            const walls = level.children
+                .map((id) => nodes[id])
+                .filter((node) => node?.type === 'wall')
+                .map(effectiveWall);
+            const proudOffsets = walls.flatMap(wallTreatmentProudOffsets);
+            useWallTreatmentLevelData
+                .getState()
+                .setLevelData(levelId, buildWallTreatmentLevelData(walls, proudOffsets));
+        }
+    }, -1);
+    return null;
+};
 /**
  * Registry-driven wall system bundle.
  *
  *  - **`WallSystem`** — reads `dirtyNodes`, batches by level, runs
  *    `calculateLevelMiters(levelWalls)`, rebuilds geometry via
- *    `generateExtrudedWall(node, children, miterData, slabElevation, baseElevation, baseSegments)`,
+ *    `generateExtrudedWall(node, children, miterData, slabElevation, baseElevation, baseSegments, storeyHeight)`,
  *    and cascades to adjacent walls that share a junction. This is the
  *    bulk of the wall runtime (~820 lines in viewer).
  *  - **`WallCutout`** — cutaway-mode hide/show logic based on camera
  *    direction and `frontSide` / `backSide` interior/exterior tags.
  */
 const WallSystems = () => {
-    return (_jsxs(_Fragment, { children: [_jsx(WallSystem, {}), _jsx(WallCutout, {})] }));
+    return (_jsxs(_Fragment, { children: [_jsx(WallTreatmentMiterSystem, {}), _jsx(WallSystem, {}), _jsx(WallCutout, {})] }));
 };
 export default WallSystems;

package/dist/wall/tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/wall/tool.tsx"],"names":[],"mappings":"AA+fA,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,EAoW5B,CAAA;AA6HD,eAAe,QAAQ,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/wall/tool.tsx"],"names":[],"mappings":"AAgcA,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,EA+e5B,CAAA;AAED,eAAe,QAAQ,CAAA"}