@pascal-app/nodes 1.0.3 → 1.0.5

package/dist/wall/selection-hit-owner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"selection-hit-owner.d.ts","sourceRoot":"","sources":["../../src/wall/selection-hit-owner.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,MAAM,mBAAmB,GAAG,WAAW,GAAG,YAAY,GAAG,YAAY,GAAG,SAAS,CAAA;AA2BvF,8EAA8E;AAC9E,MAAM,MAAM,YAAY,GAAG;IACzB,0EAA0E;IAC1E,gBAAgB,EAAE,MAAM,MAAM,CAAA;IAC9B,oDAAoD;IACpD,iBAAiB,EAAE,MAAM,QAAQ,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IACnD,2EAA2E;IAC3E,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAA;IAC1C,2DAA2D;IAC3D,wBAAwB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAA;CACpD,CAAA;AAWD,KAAK,UAAU,GAAG;IAAE,MAAM,CAAC,EAAE,UAAU,GAAG,IAAI,CAAA;CAAE,CAAA;AA8BhD;;;GAGG;AACH,eAAO,MAAM,0BAA0B,GACrC,YAAY,MAAM,EAClB,OAAM,YAAuB,KAC5B,CAAC,CAAC,MAAM,EAAE,UAAU,KAAK,mBAAmB,CAW9C,CAAA"}
+{"version":3,"file":"selection-hit-owner.d.ts","sourceRoot":"","sources":["../../src/wall/selection-hit-owner.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,MAAM,mBAAmB,GAAG,WAAW,GAAG,YAAY,GAAG,YAAY,GAAG,SAAS,CAAA;AA2BvF,8EAA8E;AAC9E,MAAM,MAAM,YAAY,GAAG;IACzB,0EAA0E;IAC1E,gBAAgB,EAAE,MAAM,MAAM,CAAA;IAC9B,oDAAoD;IACpD,iBAAiB,EAAE,MAAM,QAAQ,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IACnD,2EAA2E;IAC3E,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAA;IAC1C,2DAA2D;IAC3D,wBAAwB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAA;CACpD,CAAA;AAWD,KAAK,UAAU,GAAG;IAAE,MAAM,CAAC,EAAE,UAAU,GAAG,IAAI,CAAA;CAAE,CAAA;AA8BhD;;;GAGG;AACH,eAAO,MAAM,0BAA0B,eACzB,MAAM,SACZ,YAAY,KACjB,CAAC,CAAC,MAAM,EAAE,UAAU,KAAK,mBAAmB,CAW9C,CAAA"}

package/dist/wall/split-floorplan-layer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"split-floorplan-layer.d.ts","sourceRoot":"","sources":["../../src/wall/split-floorplan-layer.tsx"],"names":[],"mappings":"AAQA,OAAO,EAGL,KAAK,oBAAoB,EAG1B,MAAM,oBAAoB,CAAA;AAO3B,iGAAiG;AACjG,MAAM,CAAC,OAAO,UAAU,uBAAuB,CAAC,MAAM,EAAE,oBAAoB,sCAgG3E"}
+{"version":3,"file":"split-floorplan-layer.d.ts","sourceRoot":"","sources":["../../src/wall/split-floorplan-layer.tsx"],"names":[],"mappings":"AASA,OAAO,EAGL,KAAK,oBAAoB,EAG1B,MAAM,oBAAoB,CAAA;AAO3B,iGAAiG;AACjG,MAAM,CAAC,OAAO,UAAU,uBAAuB,CAAC,MAAM,EAAE,oBAAoB,sCAgG3E"}

package/dist/wall/split-floorplan-layer.js

@@ -1,12 +1,12 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { getWallCurveFrameAt, getWallCurveLength, getWallThickness, useScene, } from '@pascal-app/core';
-import { clientToPlan, FloorplanDraftWallMeasurement, formatLinearMeasurement, useFloorplanRender, } from '@pascal-app/editor';
+import { getWallCurveFrameAt, getWallCurveLength, getWallFaceOffsets, useScene, } from '@pascal-app/core';
+import { clientToPlan, FloorplanDraftMeasurement, formatLinearMeasurement, useFloorplanRender, } from '@pascal-app/editor';
 import { getSceneTheme, useViewer } from '@pascal-app/viewer';
 import { useEffect } from 'react';
-import { bindWallSplitPointer } from './split-pointer';
-import { wallSplitDistance, wallSplitMarkerColor, wallSplitSegmentLabels } from './split-preview';
-import { useWallSplit } from './split-store';
+import { bindWallSplitPointer } from './split-pointer.js';
+import { wallSplitDistance, wallSplitMarkerColor, wallSplitSegmentLabels } from './split-preview.js';
+import { useWallSplit } from './split-store.js';
 /** The plan side of the wall's `split` reshape (`reshapeLayers.split`): the same draft as 3D. */
 export default function WallSplitFloorplanLayer(_props) {
     const draft = useWallSplit((s) => s.draft);
@@ -26,7 +26,7 @@ export default function WallSplitFloorplanLayer(_props) {
         if (!surface)
             return;
         return bindWallSplitPointer(surface, (event) => {
-            if (!(event.target instanceof Node) || !surface.contains(event.target))
+            if (!(event.target instanceof Node && surface.contains(event.target)))
                 return null;
             const point = clientToPlan(event.clientX, event.clientY);
             const current = useScene.getState().nodes[wallId];
@@ -46,15 +46,15 @@ export default function WallSplitFloorplanLayer(_props) {
     const half = hitHalfWidth(wall, upp);
     const color = wallSplitMarkerColor(preview.valid);
     const cut = preview.frames[0]?.point;
-    return (_jsxs("g", { pointerEvents: "none", "data-testid": "pascal-split-marker-2d", children: [snap?.kind === 'alignment' && cut && (_jsx("line", { stroke: "#818cf8", strokeDasharray: `${4 * upp} ${3 * upp}`, strokeOpacity: 0.8, strokeWidth: upp, x1: snap.anchor[0], x2: cut.x, y1: snap.anchor[1], y2: cut.y })), preview.frames.map(({ point, normal }, index) => {
+    return (_jsxs("g", { "data-testid": "pascal-split-marker-2d", pointerEvents: "none", children: [snap?.kind === 'alignment' && cut && (_jsx("line", { stroke: "#818cf8", strokeDasharray: `${4 * upp} ${3 * upp}`, strokeOpacity: 0.8, strokeWidth: upp, x1: snap.anchor[0], x2: cut.x, y1: snap.anchor[1], y2: cut.y })), preview.frames.map(({ point, normal }, index) => {
                 const line = {
                     x1: point.x - normal.x * half,
                     y1: point.y - normal.y * half,
                     x2: point.x + normal.x * half,
                     y2: point.y + normal.y * half,
                 };
-                return (_jsxs("g", { children: [_jsx("line", { ...line, stroke: "#f7f3ed", strokeWidth: 7 * upp, strokeLinecap: "round" }), _jsx("line", { ...line, stroke: color, strokeWidth: 3 * upp, strokeLinecap: "round" })] }, index));
-            }), !preview.valid && cut ? (_jsx("text", { fill: color, fontSize: 12 * upp, paintOrder: "stroke", stroke: isDark ? '#0f172a' : '#ffffff', strokeWidth: 3 * upp, textAnchor: "middle", x: cut.x, y: cut.y - half - 6 * upp, children: preview.message })) : (wallSplitSegmentLabels(wall, preview).map((segment, index) => (_jsx(FloorplanDraftWallMeasurement, { labelBackground: isDark ? '#0f172a' : '#ffffff', labelText: isDark ? '#e2e8f0' : '#171717', measurement: {
+                return (_jsxs("g", { children: [_jsx("line", { ...line, stroke: "#f7f3ed", strokeLinecap: "round", strokeWidth: 7 * upp }), _jsx("line", { ...line, stroke: color, strokeLinecap: "round", strokeWidth: 3 * upp })] }, index));
+            }), !preview.valid && cut ? (_jsx("text", { fill: color, fontSize: 12 * upp, paintOrder: "stroke", stroke: isDark ? '#0f172a' : '#ffffff', strokeWidth: 3 * upp, textAnchor: "middle", x: cut.x, y: cut.y - half - 6 * upp, children: preview.message })) : (wallSplitSegmentLabels(wall, preview).map((segment, index) => (_jsx(FloorplanDraftMeasurement, { labelBackground: isDark ? '#0f172a' : '#ffffff', labelText: isDark ? '#e2e8f0' : '#171717', measurement: {
                     lengthLabel: `${formatLinearMeasurement(segment.length, unit, metricNotation)}${segment.count > 1 ? ` × ${segment.count}` : ''}`,
                     midpoint: segment.midpoint,
                     direction: segment.direction,
@@ -63,7 +63,7 @@ export default function WallSplitFloorplanLayer(_props) {
 }
 /** The wall's stroke plus a finger's width, so the cut can be grabbed at any zoom. */
 function hitHalfWidth(wall, upp) {
-    return getWallThickness(wall) / 2 + 8 * upp;
+    return Math.max(getWallFaceOffsets(wall).a, -getWallFaceOffsets(wall).b) + 8 * upp;
 }
 function frameAt(wall, distance) {
     const length = getWallCurveLength(wall);

package/dist/wall/split-pointer.js

@@ -1,5 +1,5 @@
-import { commitWallSplit, hoverWallSplit, setWallSplitCuts } from './split-session';
-import { useWallSplit } from './split-store';
+import { commitWallSplit, hoverWallSplit, setWallSplitCuts } from './split-session.js';
+import { useWallSplit } from './split-store.js';
 // Pixels of continuous wheel travel per cut: a short trackpad swipe.
 const WHEEL_STEP_PX = 60;
 // A wheel event after this pause is a new notch or gesture and steps at once,

package/dist/wall/split-preview.d.ts

@@ -1,7 +1,7 @@
 import { type AnyNode, type AnyNodeId, type WallNode, type WallPlanPoint } from '@pascal-app/core';
 export declare const WALL_SPLIT_MAX_CUTS = 32;
 /** Cut markers in both views: warm when the cuts can commit, red when they can't. */
-export declare function wallSplitMarkerColor(valid: boolean): "#c86f45" | "#a63d2e";
+export declare function wallSplitMarkerColor(valid: boolean): "#a63d2e" | "#c86f45";
 /** The pointer projected onto the wall, as a distance from its start; curved walls included. */
 export declare function wallSplitDistance(wall: WallNode, point: readonly [number, number]): number;
 /** Like a loop cut: one cut follows the pointer, more cuts divide the wall evenly. */

package/dist/wall/split-session.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"split-session.d.ts","sourceRoot":"","sources":["../../src/wall/split-session.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAuCzB;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,QA6C3C;AAED,wBAAgB,cAAc,SAQ7B;AAED,oEAAoE;AACpE,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,UAAQ,QAevD;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,QAQ5C;AAED,kEAAkE;AAClE,wBAAgB,gBAAgB,SAM/B;AAED,wBAAgB,eAAe,SAY9B"}
+{"version":3,"file":"split-session.d.ts","sourceRoot":"","sources":["../../src/wall/split-session.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AA4CzB;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,QA8C3C;AAED,wBAAgB,cAAc,SAS7B;AAED,oEAAoE;AACpE,wBAAgB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,UAAQ,QAevD;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,QAQ5C;AAED,kEAAkE;AAClE,wBAAgB,gBAAgB,SAM/B;AAED,wBAAgB,eAAe,SAc9B"}

package/dist/wall/split-session.js

@@ -1,7 +1,7 @@
 import { getWallCurveLength, planWallDivisions, runAsSingleSceneHistoryStep, useScene, } from '@pascal-app/core';
-import { isGridSnapActive, isMagneticSnapActive, triggerSFX, useEditor, useInteractionScope, } from '@pascal-app/editor';
-import { snapWallSplitDistance, WALL_SPLIT_MAX_CUTS, wallSplitAnchors, wallSplitDistances, wallSplitPreview, } from './split-preview';
-import { useWallSplit } from './split-store';
+import { captureElementActionOrigin, completeElementAction, isGridSnapActive, isMagneticSnapActive, triggerSFX, useEditor, useInteractionScope, } from '@pascal-app/editor';
+import { snapWallSplitDistance, WALL_SPLIT_MAX_CUTS, wallSplitAnchors, wallSplitDistances, wallSplitPreview, } from './split-preview.js';
+import { useWallSplit } from './split-store.js';
 // Pointer distance (m) within which a 'lines' alignment target catches the cut.
 const ALIGNMENT_TOLERANCE = 0.2;
 const ownsSplit = () => {
@@ -17,6 +17,8 @@ const withPreview = (draft, wall) => ({
     preview: wallSplitPreview(useScene.getState().nodes, wall, wallSplitDistances(getWallCurveLength(wall), draft.cuts, draft.distance)),
 });
 let teardown = null;
+// The room the wall was drilled from: a committed split lands back on it.
+let origin = null;
 /**
  * A split session: the wall's `reshaping` scope (so the snapping chip and the
  * kind's HUD hints resolve), one centred cut, and the watchers that end it —
@@ -27,6 +29,7 @@ export function openWallSplit(wall) {
     if (useScene.getState().readOnly)
         return;
     closeWallSplit();
+    origin = captureElementActionOrigin([wall.id]);
     useEditor.getState().setMode('select');
     useInteractionScope
         .getState()
@@ -72,6 +75,7 @@ export function openWallSplit(wall) {
 export function closeWallSplit() {
     const stop = teardown;
     teardown = null;
+    origin = null;
     stop?.();
     useWallSplit.getState().setDraft(null);
     useInteractionScope
@@ -132,7 +136,9 @@ export function commitWallSplit() {
     if (!checked.preview.valid)
         return useWallSplit.getState().setDraft(checked);
     const plan = planWallDivisions(current.nodes, wall.id, checked.preview.distances);
+    const from = origin;
     runAsSingleSceneHistoryStep(useScene, () => current.applyNodeChanges(plan.changes));
     closeWallSplit();
     triggerSFX('sfx:structure-build');
+    completeElementAction(from);
 }

package/dist/wall/split-store.d.ts

@@ -1,5 +1,5 @@
 import type { WallNode } from '@pascal-app/core';
-import type { WallSplitPreview, WallSplitSnap } from './split-preview';
+import type { WallSplitPreview, WallSplitSnap } from './split-preview.js';
 export type WallSplitDraft = {
     wallId: WallNode['id'];
     cuts: number;

package/dist/wall/split-tool.js

@@ -6,9 +6,9 @@ import { BATCHED_LAYER, getSceneTheme, SCENE_LAYER, useViewer } from '@pascal-ap
 import { useFrame, useThree } from '@react-three/fiber';
 import { useEffect, useRef } from 'react';
 import { Raycaster, Vector2 } from 'three';
-import { bindWallSplitPointer } from './split-pointer';
-import { wallSplitDistance, wallSplitMarkerColor, wallSplitSegmentLabels } from './split-preview';
-import { useWallSplit } from './split-store';
+import { bindWallSplitPointer } from './split-pointer.js';
+import { wallSplitDistance, wallSplitMarkerColor, wallSplitSegmentLabels } from './split-preview.js';
+import { useWallSplit } from './split-store.js';
 /**
  * The wall's `split` affordance (3D): cut markers, segment lengths and the
  * pointer binding. The session (`split-session.ts`) owns the scope and draft;

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

@@ -1 +1 @@
-{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/wall/system.tsx"],"names":[],"mappings":"AAoCA,wBAAgB,wBAAwB,IAAI,IAAI,CAO/C;AAED,wBAAgB,yBAAyB,IAAI,IAAI,CAyChD;AASD;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,WAAW,mCAShB,CAAA;AAED,eAAe,WAAW,CAAA"}
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/wall/system.tsx"],"names":[],"mappings":"AAuDA,wBAAgB,wBAAwB,IAAI,IAAI,CAO/C;AAED,wBAAgB,yBAAyB,IAAI,IAAI,CA0FhD;AASD;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,WAAW,mCAShB,CAAA;eAEc,WAAW"}

package/dist/wall/system.js

@@ -1,14 +1,14 @@
 'use client';
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import { useLiveNodeOverrides, useScene } from '@pascal-app/core';
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { spatialGridManager, useLiveNodeOverrides, useLiveTerrain, useScene, } from '@pascal-app/core';
 import { timeSpan, WallCutout, WallSystem } from '@pascal-app/viewer';
 import { useFrame } from '@react-three/fiber';
 import { useEffect } from 'react';
-import { curtainWallGeometryAdapter } from './curtain-wall-adapter';
-import { getCurtainAwareWallMaterials } from './curtain-wall-materials';
-import { buildWallTreatmentLevelData, clearWallTreatmentMiterCache, sameTreatmentWalls, treatmentProudKeys, useWallTreatmentLevelData, } from './treatment-level-data';
-import { wallTreatmentProudOffsets } from './treatments';
-import { WallBatchSystem } from './wall-batch-system';
+import { curtainWallGeometryAdapter } from './curtain-wall-adapter.js';
+import { getCurtainAwareWallMaterials } from './curtain-wall-materials.js';
+import { buildWallTreatmentLevelData, clearWallTreatmentMiterCache, sameTreatmentWalls, treatmentProudKeys, useWallTreatmentLevelData, } from './treatment-level-data.js';
+import { wallTreatmentProudOffsets } from './treatments.js';
+import { WallBatchSystem } from './wall-batch-system.js';
 const levelInputs = new Map();
 let effectiveWalls = new WeakMap();
 let previousNodes;
@@ -50,6 +50,10 @@ export function updateWallTreatmentLevels() {
         previousNodes = nodes;
         previousOverrides = overrides;
     }
+    const terrain = useLiveTerrain.getState();
+    const ancestors = dirtyLevelIds.size
+        ? Object.values(nodes).filter((node) => node.type === 'site' || node.type === 'building' || node.type === 'level')
+        : [];
     for (const levelId of dirtyLevelIds) {
         const level = nodes[levelId];
         if (level?.type !== 'level') {
@@ -65,13 +69,41 @@ export function updateWallTreatmentLevels() {
         const proudOffsets = walls.flatMap(wallTreatmentProudOffsets);
         const proudKey = treatmentProudKeys(proudOffsets).join(',');
         const previous = levelInputs.get(levelId);
-        if (previous?.proudKey === proudKey && sameTreatmentWalls(previous.walls, walls))
+        const sameWalls = previous?.proudKey === proudKey && sameTreatmentWalls(previous.walls, walls);
+        const supportInputs = [
+            ...ancestors,
+            ...level.children.flatMap((id) => {
+                const node = nodes[id];
+                return node && (node.type === 'slab' || node.type === 'zone' || node.type === 'separator')
+                    ? [node, overrides.get(id)]
+                    : [];
+            }),
+        ];
+        const sameSupportInputs = previous?.supportInputs.length === supportInputs.length &&
+            supportInputs.every((input, i) => input === previous.supportInputs[i]);
+        const sameTerrain = previous?.terrain === terrain;
+        if (sameWalls && sameSupportInputs && sameTerrain)
+            continue;
+        const supports = new Map(walls.map((wall) => {
+            const cached = sameSupportInputs &&
+                (sameTerrain || !dirtyNodes.has(wall.id)) &&
+                previous?.walls.includes(wall)
+                ? previous.supports.get(wall.id)
+                : undefined;
+            return [
+                wall.id,
+                cached ??
+                    spatialGridManager.getSlabSupportForWall(levelId, wall.start, wall.end, wall.curveOffset ?? 0, wall.thickness, wall.supportSlabId, undefined, wall.supportOffset, wall.justification),
+            ];
+        }));
+        const supportKey = JSON.stringify([...supports].map(([id, support]) => [id, support.elevation, support.faceDatum]));
+        levelInputs.set(levelId, { walls, proudKey, supportKey, supportInputs, supports, terrain });
+        if (sameWalls && previous.supportKey === supportKey)
             continue;
         timeSpan('wall-treatment-level', () => {
             useWallTreatmentLevelData
                 .getState()
-                .setLevelData(levelId, buildWallTreatmentLevelData(levelId, walls, proudOffsets));
-            levelInputs.set(levelId, { walls, proudKey });
+                .setLevelData(levelId, buildWallTreatmentLevelData(levelId, walls, proudOffsets, supports));
         });
     }
 }

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

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/wall/tool.tsx"],"names":[],"mappings":"AAs7BA,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,EAS5B,CAAA;AAED,eAAe,QAAQ,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/wall/tool.tsx"],"names":[],"mappings":"AAqhCA,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,EAe5B,CAAA;eAEc,QAAQ"}

package/dist/wall/tool.js

@@ -1,13 +1,12 @@
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { calculateLevelMiters, collectAlignmentAnchors, DEFAULT_LEVEL_HEIGHT, emitter, GROUND_SUPPORT_ID, getWallMiterBoundaryPoints, resolveAlignment, resolveBuildingForLevel, sceneRegistry, useScene, wallClosesRoom, } from '@pascal-app/core';
-import { CursorSphere, chainEndJoinsExistingWall, clearPlacementSurface, createWallOnCurrentLevel, DraftMeasurementLabel, EDITOR_LAYER, formatAngleRadians, formatLinearMeasurement, getAngleArcToSegmentReference, getAngleToSegmentReference, getSegmentAngleReferenceAtPoint, isAlignmentGuideActive, isAngleSnapActive, isMagneticSnapActive, markToolCancelConsumed, publishHorizontalConstructionPlane, publishPlacementSurface, resampleTerrainConstructionPlane, resolveEventConstructionPlane, resolvePointerSupportSurface, snapWallDraftPointDetailed, triggerSFX, useAlignmentGuides, useEditor, useFloorplanDraftPreview, useSegmentDraftChain, useWallSnapIndicator, WALL_CONNECT_SNAP_RADIUS, WALL_JOIN_SNAP_RADIUS, } from '@pascal-app/editor';
+import { addWallPolygonDraftCorner, CursorSphere, chainEndJoinsExistingWall, clearPlacementSurface, commitWallPolygonDraft, createWallOnCurrentLevel, DraftMeasurementLabel, discardWallPolygonDraft, EDITOR_LAYER, formatAngleRadians, formatLinearMeasurement, getAngleArcToSegmentReference, getAngleToSegmentReference, getSegmentAngleReferenceAtPoint, getWallDrawVariant, isAlignmentGuideActive, isAngleSnapActive, isMagneticSnapActive, markToolCancelConsumed, publishHorizontalConstructionPlane, publishPlacementSurface, resampleTerrainConstructionPlane, resolveEventConstructionPlane, resolvePointerSupportSurface, snapWallDraftPointDetailed, startWallPolygonDraft, triggerSFX, useAlignmentGuides, useEditor, useFloorplanDraftPreview, useSegmentDraftChain, useWallDrawVariant, useWallSnapIndicator, visibleScene, WALL_CONNECT_SNAP_RADIUS, WALL_JOIN_SNAP_RADIUS, wallPolygonDraftWalls, } from '@pascal-app/editor';
 import { getSceneTheme, useViewer } from '@pascal-app/viewer';
 import { useThree } from '@react-three/fiber';
 import { useEffect, useRef, useState } from 'react';
 import { DoubleSide, Vector3 } from 'three';
-import { DraftAngleArc, DraftAxisGuides, getNearestAxisAngleLabel, } from '../shared/draft-axis-guides';
-import { useWallDrawingMode, useWallDrawingModeKeys } from './drawing-mode';
-import RectangleWallTool from './rectangle-tool';
+import { DraftAngleArc, DraftAxisGuides, getNearestAxisAngleLabel, } from '../shared/draft-axis-guides.js';
+import RectangleWallTool from './rectangle-tool.js';
 /**
  * Phase 5 Stage D — wall placement tool (kind-owned).
  *
@@ -330,6 +329,8 @@ const LineWallTool = () => {
     const flatConstructionBase = useRef(false);
     const buildingState = useRef(0);
     const [draftMeasurement, setDraftMeasurement] = useState(null);
+    // Base Y of an open Polygon room's ghost sides (its construction plane).
+    const [polygonGhostY, setPolygonGhostY] = useState(0);
     const [axisGuide, setAxisGuide] = useState(null);
     const measurementColor = isDark ? '#ffffff' : '#111111';
     const measurementShadowColor = isDark ? '#111111' : '#ffffff';
@@ -430,7 +431,10 @@ const LineWallTool = () => {
             }
             return resolved;
         };
+        // Stopping without committing drops an open Polygon room — its corners
+        // were never written. Completing paths commit before they stop.
         const stopDrafting = () => {
+            discardWallPolygonDraft();
             buildingState.current = 0;
             constructionPlane.current = null;
             flatConstructionBase.current = false;
@@ -449,8 +453,12 @@ const LineWallTool = () => {
             useSegmentDraftChain.getState().clear('wall');
             clearPlacementSurface();
         };
+        // In 2D-only view the plan owns wall drafting; this tool stays mounted
+        // behind the hidden canvas and still hears the plan's grid events, so it
+        // must not also draft (it would add every corner twice).
+        const planOwnsInput = () => visibleScene(useEditor.getState()) === '2d';
         const onGridMove = (event) => {
-            if (!(cursorRef.current && wallPreviewRef.current))
+            if (!(cursorRef.current && wallPreviewRef.current) || planOwnsInput())
                 return;
             // Ride the grid event plane on the pointed surface: aiming at an
             // elevated deck lifts the plane to the deck top, so the draft's XZ
@@ -468,7 +476,7 @@ const LineWallTool = () => {
             // Add walls on the floor below as extra snap references so the new wall
             // can align with the level beneath it. Kept separate from `walls` so the
             // measurement HUD only reports against the active level.
-            const snapWalls = [...walls, ...getBelowLevelWalls()];
+            const snapWalls = [...walls, ...getBelowLevelWalls(), ...wallPolygonDraftWalls()];
             const localPoint = pointed?.localPoint
                 ? [pointed.localPoint[0], pointed.localPoint[2]]
                 : [event.localPosition[0], event.localPosition[2]];
@@ -521,14 +529,16 @@ const LineWallTool = () => {
             }
         };
         const onGridClick = (event) => {
-            if (!wallPreviewRef.current)
+            if (!wallPreviewRef.current || planOwnsInput())
                 return;
             if (buildingState.current === 1 && event.nativeEvent.detail >= 2) {
+                // A double-click finishes the chain and keeps an open Polygon room.
+                commitWallPolygonDraft();
                 stopDrafting();
                 return;
             }
             const walls = getCurrentLevelWalls();
-            const snapWalls = [...walls, ...getBelowLevelWalls()];
+            const snapWalls = [...walls, ...getBelowLevelWalls(), ...wallPolygonDraftWalls()];
             const pointed = buildingState.current === 0 ? pointedSurfaceFor(event) : null;
             const localClick = pointed?.localPoint
                 ? [pointed.localPoint[0], pointed.localPoint[2]]
@@ -564,6 +574,18 @@ const LineWallTool = () => {
                     angleLabel: null,
                 });
                 triggerSFX('sfx:structure-build-start');
+                const levelId = useViewer.getState().selection.levelId;
+                if (getWallDrawVariant() === 'polygon' && levelId) {
+                    startWallPolygonDraft(levelId, snappedStart, {
+                        supportCap: plane.elevation ?? null,
+                        preferredSupportSlabId: plane.supportSlabId ?? null,
+                        constructionElevation: plane.elevation ?? null,
+                        constructionHeight: previewHeightRef.current,
+                        constructionSourceNodeId: plane.sourceNodeId ?? null,
+                        flatConstructionBase: flatConstructionBase.current,
+                    });
+                    setPolygonGhostY(plane.localY);
+                }
                 // Visibility is owned by `updateWallPreview`. Leave the
                 // unit box hidden until the first pointer move scales and
                 // positions it for the active segment.
@@ -586,47 +608,63 @@ const LineWallTool = () => {
                 // any other chain re-resolves the aimed surface per commit so a later
                 // segment can still elect the slab it visibly crosses instead of
                 // being capped at the first click's elevation.
-                const draftPlane = constructionPlane.current;
-                const commitPointed = draftPlane?.supportSlabId === GROUND_SUPPORT_ID ? null : pointedSurfaceFor(event);
-                // Both start and end are building-local ✓
-                const createdWall = createWallOnCurrentLevel([startingPoint.current.x, startingPoint.current.z], snappedEnd, {
-                    supportCap: commitPointed ? commitPointed.elevation : (draftPlane?.elevation ?? null),
-                    preferredSupportSlabId: draftPlane?.supportSlabId ?? null,
-                    constructionElevation: draftPlane?.elevation ?? null,
-                    constructionHeight: previewHeightRef.current,
-                    constructionSourceNodeId: constructionPlane.current?.sourceNodeId ?? null,
-                    flatConstructionBase: flatConstructionBase.current,
-                });
-                if (!createdWall)
-                    return;
-                chainWallIds.current.push(createdWall.id);
-                // The new segment is now a real node — make it an alignment target
-                // for the next segment, and drop the just-shown guide.
-                refreshAlignmentCandidates();
-                useAlignmentGuides.getState().clear();
-                useWallSnapIndicator.getState().clear();
-                if (useEditor.getState().getContinuation('wall') === 'single') {
-                    stopDrafting();
-                    return;
+                let nextStart;
+                if (getWallDrawVariant() === 'polygon') {
+                    // A Polygon room writes nothing until it completes: the corner joins
+                    // the draft, and closing / sealing / teeing commits every wall at once.
+                    const outcome = addWallPolygonDraftCorner(snappedEnd);
+                    useAlignmentGuides.getState().clear();
+                    useWallSnapIndicator.getState().clear();
+                    if (outcome !== 'open') {
+                        commitWallPolygonDraft();
+                        stopDrafting();
+                        return;
+                    }
+                    nextStart = snappedEnd;
                 }
-                const closedToChainStart = chainFirstVertex.current &&
-                    isWithinWallJoinSnapRadius(createdWall.end, chainFirstVertex.current);
-                // Auto-close also fires when the segment seals a room against the
-                // existing wall network (e.g. a bay closed onto the middle of another
-                // wall), not just when the chain loops back to its own start. Shares the
-                // room graph with auto slab/ceiling detection so the two never disagree.
-                // A resolved end that tees into wall geometry outside the chain also
-                // terminates even without an enclosed room — nobody continues drawing
-                // from a T-junction into an existing wall; a dead end in free space
-                // keeps the chain going.
-                const levelWalls = getCurrentLevelWalls();
-                if (closedToChainStart ||
-                    chainEndJoinsExistingWall(createdWall.end, levelWalls, chainWallIds.current) ||
-                    wallClosesRoom(levelWalls, createdWall)) {
-                    stopDrafting();
-                    return;
+                else {
+                    const draftPlane = constructionPlane.current;
+                    const commitPointed = draftPlane?.supportSlabId === GROUND_SUPPORT_ID ? null : pointedSurfaceFor(event);
+                    // Both start and end are building-local ✓
+                    const createdWall = createWallOnCurrentLevel([startingPoint.current.x, startingPoint.current.z], snappedEnd, {
+                        supportCap: commitPointed ? commitPointed.elevation : (draftPlane?.elevation ?? null),
+                        preferredSupportSlabId: draftPlane?.supportSlabId ?? null,
+                        constructionElevation: draftPlane?.elevation ?? null,
+                        constructionHeight: previewHeightRef.current,
+                        constructionSourceNodeId: constructionPlane.current?.sourceNodeId ?? null,
+                        flatConstructionBase: flatConstructionBase.current,
+                    });
+                    if (!createdWall)
+                        return;
+                    chainWallIds.current.push(createdWall.id);
+                    // The new segment is now a real node — make it an alignment target
+                    // for the next segment, and drop the just-shown guide.
+                    refreshAlignmentCandidates();
+                    useAlignmentGuides.getState().clear();
+                    useWallSnapIndicator.getState().clear();
+                    if (useEditor.getState().getContinuation('wall') === 'single') {
+                        stopDrafting();
+                        return;
+                    }
+                    const closedToChainStart = chainFirstVertex.current &&
+                        isWithinWallJoinSnapRadius(createdWall.end, chainFirstVertex.current);
+                    // Auto-close also fires when the segment seals a room against the
+                    // existing wall network (e.g. a bay closed onto the middle of another
+                    // wall), not just when the chain loops back to its own start. Shares the
+                    // room graph with auto slab/ceiling detection so the two never disagree.
+                    // A resolved end that tees into wall geometry outside the chain also
+                    // terminates even without an enclosed room — nobody continues drawing
+                    // from a T-junction into an existing wall; a dead end in free space
+                    // keeps the chain going.
+                    const levelWalls = getCurrentLevelWalls();
+                    if (closedToChainStart ||
+                        chainEndJoinsExistingWall(createdWall.end, levelWalls, chainWallIds.current) ||
+                        wallClosesRoom(levelWalls, createdWall)) {
+                        stopDrafting();
+                        return;
+                    }
+                    nextStart = createdWall.end;
                 }
-                const nextStart = createdWall.end;
                 // Publish the resolved chain start so the 2D floor-plan draft
                 // chains its next segment from the same point (its own snap
                 // pipeline can resolve a slightly different endpoint).
@@ -665,6 +703,8 @@ const LineWallTool = () => {
         emitter.on('grid:click', onGridClick);
         emitter.on('tool:cancel', onCancel);
         return () => {
+            // Leaving the tool mid-polygon abandons it (nothing was written).
+            discardWallPolygonDraft();
             emitter.off('grid:move', onGridMove);
             emitter.off('grid:click', onGridClick);
             emitter.off('tool:cancel', onCancel);
@@ -677,14 +717,35 @@ const LineWallTool = () => {
             draftPreview.setWallDraftEnd(null);
         };
     }, [unit, metricNotation]);
-    return (_jsxs("group", { children: [_jsx(DraftAxisGuides, { guide: axisGuide, labelColor: measurementColor, labelShadowColor: measurementShadowColor }), _jsx(CursorSphere, { height: previewHeight, ref: cursorRef }), _jsxs("mesh", { layers: EDITOR_LAYER, ref: wallPreviewRef, renderOrder: 1, visible: false, children: [_jsx("boxGeometry", {}), _jsx("meshBasicMaterial", { color: "#818cf8", depthTest: false, depthWrite: false, opacity: 0.5, side: DoubleSide, transparent: true })] }), draftMeasurement && (_jsxs(_Fragment, { children: [_jsx(DraftMeasurementLabel, { color: measurementColor, label: draftMeasurement.lengthLabel, position: draftMeasurement.lengthPosition, shadowColor: measurementShadowColor }), draftMeasurement.angleLabels.map((angleLabel) => (_jsxs("group", { children: [_jsx(DraftAngleArc, { arc: angleLabel.arc, color: measurementColor }), _jsx(DraftMeasurementLabel, { color: measurementColor, label: angleLabel.label, position: angleLabel.position, shadowColor: measurementShadowColor })] }, angleLabel.id)))] }))] }));
+    return (_jsxs("group", { children: [_jsx(DraftAxisGuides, { guide: axisGuide, labelColor: measurementColor, labelShadowColor: measurementShadowColor }), _jsx(CursorSphere, { height: previewHeight, ref: cursorRef }), _jsx(PolygonDraftGhosts, { height: previewHeight, thickness: previewThickness, y: polygonGhostY }), _jsxs("mesh", { layers: EDITOR_LAYER, ref: wallPreviewRef, renderOrder: 1, visible: false, children: [_jsx("boxGeometry", {}), _jsx("meshBasicMaterial", { color: "#818cf8", depthTest: false, depthWrite: false, opacity: 0.5, side: DoubleSide, transparent: true })] }), draftMeasurement && (_jsxs(_Fragment, { children: [_jsx(DraftMeasurementLabel, { color: measurementColor, label: draftMeasurement.lengthLabel, position: draftMeasurement.lengthPosition, shadowColor: measurementShadowColor }), draftMeasurement.angleLabels.map((angleLabel) => (_jsxs("group", { children: [_jsx(DraftAngleArc, { arc: angleLabel.arc, color: measurementColor }), _jsx(DraftMeasurementLabel, { color: measurementColor, label: angleLabel.label, position: angleLabel.position, shadowColor: measurementShadowColor })] }, angleLabel.id)))] }))] }));
 };
+/**
+ * The placed sides of an open Polygon room, drawn like the live segment's
+ * preview. They are draft state (`wallPolygonDraftPoints`), not scene walls.
+ */
+function PolygonDraftGhosts({ height, thickness, y, }) {
+    const corners = useFloorplanDraftPreview((state) => state.wallPolygonDraftPoints);
+    return (_jsx(_Fragment, { children: corners.slice(1).map((end, index) => {
+            const start = corners[index];
+            const dx = end[0] - start[0];
+            const dz = end[1] - start[1];
+            const length = Math.hypot(dx, dz);
+            if (length < 0.01)
+                return null;
+            return (_jsxs("mesh", { layers: EDITOR_LAYER, position: [(start[0] + end[0]) / 2, y + height / 2, (start[1] + end[1]) / 2], renderOrder: 1, rotation: [0, -Math.atan2(dz, dx), 0], scale: [length, height, thickness], children: [_jsx("boxGeometry", {}), _jsx("meshBasicMaterial", { color: "#818cf8", depthTest: false, depthWrite: false, opacity: 0.5, side: DoubleSide, transparent: true })] }, `${index}:${start[0]},${start[1]}`));
+        }) }));
+}
 export const WallTool = () => {
     // Clear preset-seeded defaults on deactivation so a later manual wall draw
     // isn't built with a stale preset's parameters. Unmount-only.
-    useEffect(() => () => useEditor.getState().setToolDefaults('wall', null), []);
-    useWallDrawingModeKeys();
-    const mode = useWallDrawingMode((s) => s.mode);
-    return mode === 'rectangle' ? _jsx(RectangleWallTool, {}) : _jsx(LineWallTool, {});
+    useEffect(() => () => {
+        const editor = useEditor.getState();
+        // Remounts keep the active preset; leaving the wall tool releases it.
+        if (editor.tool !== 'wall')
+            editor.setToolDefaults('wall', null);
+    }, []);
+    // The drawing variant is picked in the Build panel's Rooms group.
+    const variant = useWallDrawVariant();
+    return variant === 'rectangle' ? _jsx(RectangleWallTool, {}) : _jsx(LineWallTool, {});
 };
 export default WallTool;

package/dist/wall/treatment-level-data.d.ts

@@ -1,12 +1,13 @@
-import { type WallMiterData, type WallNode } from '@pascal-app/core';
+import { type WallMiterData, type WallNode, type WallSlabSupport } from '@pascal-app/core';
 export declare function treatmentProudKeys(proudOffsets: readonly number[]): number[];
 export declare function sameTreatmentWalls(a: readonly WallNode[], b: readonly WallNode[]): boolean;
 export type WallTreatmentLevelData = {
     walls: readonly WallNode[];
+    supports?: ReadonlyMap<string, WallSlabSupport>;
     miterDataByProud: ReadonlyMap<number, WallMiterData>;
 };
 export declare function clearWallTreatmentMiterCache(levelId?: string): void;
-export declare function buildWallTreatmentLevelData(levelId: string, walls: readonly WallNode[], proudOffsets: readonly number[]): WallTreatmentLevelData;
+export declare function buildWallTreatmentLevelData(levelId: string, walls: readonly WallNode[], proudOffsets: readonly number[], supports?: ReadonlyMap<string, WallSlabSupport>): WallTreatmentLevelData;
 export declare function treatmentMiterDataForProud(levelData: WallTreatmentLevelData, proud: number): WallMiterData | undefined;
 type WallTreatmentLevelDataState = {
     byLevelId: ReadonlyMap<string, WallTreatmentLevelData>;

package/dist/wall/treatment-level-data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"treatment-level-data.d.ts","sourceRoot":"","sources":["../../src/wall/treatment-level-data.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,aAAa,EAClB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAUzB,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAE5E;AAED,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,SAAS,QAAQ,EAAE,EAAE,CAAC,EAAE,SAAS,QAAQ,EAAE,GAAG,OAAO,CAE1F;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,KAAK,EAAE,SAAS,QAAQ,EAAE,CAAA;IAC1B,gBAAgB,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;CACrD,CAAA;AAID,wBAAgB,4BAA4B,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAGnE;AAED,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,YAAY,EAAE,SAAS,MAAM,EAAE,GAC9B,sBAAsB,CAwBxB;AAED,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,sBAAsB,EACjC,KAAK,EAAE,MAAM,GACZ,aAAa,GAAG,SAAS,CAE3B;AAED,KAAK,2BAA2B,GAAG;IACjC,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAA;IACtD,YAAY,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,sBAAsB,KAAK,IAAI,CAAA;IACrE,eAAe,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;CAC3C,CAAA;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,QAAQ,EAAE,YAAY,EAAE,SAAS,MAAM,EAAE,IASjF,OAAO,2BAA2B,KAAG,sBAAsB,GAAG,SAAS,CAqChF;AAED,eAAO,MAAM,yBAAyB,0FAenC,CAAA"}
+{"version":3,"file":"treatment-level-data.d.ts","sourceRoot":"","sources":["../../src/wall/treatment-level-data.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,aAAa,EAClB,KAAK,QAAQ,EACb,KAAK,eAAe,EACrB,MAAM,kBAAkB,CAAA;AAUzB,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAE5E;AAED,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,SAAS,QAAQ,EAAE,EAAE,CAAC,EAAE,SAAS,QAAQ,EAAE,GAAG,OAAO,CAE1F;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,KAAK,EAAE,SAAS,QAAQ,EAAE,CAAA;IAC1B,QAAQ,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,eAAe,CAAC,CAAA;IAC/C,gBAAgB,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;CACrD,CAAA;AAID,wBAAgB,4BAA4B,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAGnE;AAED,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,YAAY,EAAE,SAAS,MAAM,EAAE,EAC/B,QAAQ,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,eAAe,CAAC,GAC9C,sBAAsB,CAiBxB;AAED,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,sBAAsB,EACjC,KAAK,EAAE,MAAM,GACZ,aAAa,GAAG,SAAS,CAE3B;AAED,KAAK,2BAA2B,GAAG;IACjC,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAA;IACtD,YAAY,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,sBAAsB,KAAK,IAAI,CAAA;IACrE,eAAe,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;CAC3C,CAAA;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,QAAQ,EAAE,YAAY,EAAE,SAAS,MAAM,EAAE,WAS1E,2BAA2B,KAAG,sBAAsB,GAAG,SAAS,CA+ChF;AAED,eAAO,MAAM,yBAAyB,0FAenC,CAAA"}

package/dist/wall/treatment-level-data.js

@@ -1,4 +1,4 @@
-import { calculateLevelMiters, getWallThickness, isCurvedWall, pointToKey, } from '@pascal-app/core';
+import { calculateLevelMiters, isCurvedWall, pointToKey, } from '@pascal-app/core';
 import { create } from 'zustand';
 import { shallow } from 'zustand/vanilla/shallow';
 const PROUD_KEY_PRECISION = 1e6;
@@ -18,7 +18,7 @@ export function clearWallTreatmentMiterCache(levelId) {
     else
         levelMiterCache.delete(levelId);
 }
-export function buildWallTreatmentLevelData(levelId, walls, proudOffsets) {
+export function buildWallTreatmentLevelData(levelId, walls, proudOffsets, supports) {
     const cached = levelMiterCache.get(levelId);
     const reusable = cached && sameTreatmentWalls(cached.walls, walls) ? cached : undefined;
     const miterDataByProud = new Map();
@@ -28,15 +28,9 @@ export function buildWallTreatmentLevelData(levelId, walls, proudOffsets) {
             miterDataByProud.set(proud, previous);
             continue;
         }
-        const adjustedWalls = proud === 0
-            ? [...walls]
-            : walls.map((wall) => ({
-                ...wall,
-                thickness: getWallThickness(wall) + proud * 2,
-            }));
-        miterDataByProud.set(proud, calculateLevelMiters(adjustedWalls));
+        miterDataByProud.set(proud, calculateLevelMiters([...walls], proud));
     }
-    const data = { walls, miterDataByProud };
+    const data = { walls, miterDataByProud, supports };
     levelMiterCache.set(levelId, data);
     return data;
 }
@@ -59,9 +53,15 @@ export function createWallTreatmentSelector(node, proudOffsets) {
         if (!level) {
             previousSlice = undefined;
             previousInputs = [];
-            return undefined;
+            return;
+        }
+        const support = level.supports?.get(node.id);
+        const inputs = [support?.elevation];
+        for (const face of ['a', 'b']) {
+            inputs.push(support?.faceDatum[face].length);
+            for (const segment of support?.faceDatum[face] ?? [])
+                inputs.push(segment.start, segment.end, segment.elevation, segment.endElevation);
         }
-        const inputs = [];
         for (const proud of prouds) {
             const data = level.miterDataByProud.get(proud);
             inputs.push(!!data);
@@ -87,7 +87,11 @@ export function createWallTreatmentSelector(node, proudOffsets) {
             miterDataByProud.set(proud, { junctionData, junctions: new Map() });
         }
         previousInputs = inputs;
-        previousSlice = { walls: [node], miterDataByProud };
+        previousSlice = {
+            walls: [node],
+            miterDataByProud,
+            supports: support ? new Map([[node.id, support]]) : undefined,
+        };
         return previousSlice;
     };
 }