@pascal-app/nodes 1.0.0-beta.5 → 1.0.0

package/dist/turbine-vent/geometry.js

@@ -1,5 +1,6 @@
 import * as THREE from 'three';
 import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+import { copyUvToSecondaryChannel, cumulativeProfileDistances, planarMetricUvs, } from '../shared/primitive-uv';
 function resolveDims(node) {
     const ro = Math.max(0.05, node.diameter / 2);
     const height = Math.max(0.12, node.height);
@@ -136,6 +137,11 @@ function buildVanes(p, n, uv, count, rings, dw, totalTwist, thk) {
 }
 // ─── Primitive builders ──────────────────────────────────────────────
 function cylinderWall(p, n, uv, r, y0, y1, segs) {
+    const ring = Array.from({ length: segs + 1 }, (_, index) => {
+        const angle = (index / segs) * Math.PI * 2;
+        return [r * Math.cos(angle), y0, r * Math.sin(angle)];
+    });
+    const ringU = cumulativeProfileDistances(ring);
     for (let i = 0; i < segs; i++) {
         const a = (i / segs) * Math.PI * 2;
         const b = ((i + 1) / segs) * Math.PI * 2;
@@ -144,7 +150,12 @@ function cylinderWall(p, n, uv, r, y0, y1, segs) {
         const cb = Math.cos(b);
         const sb = Math.sin(b);
         const out = [Math.cos((a + b) / 2), 0, Math.sin((a + b) / 2)];
-        pushQuad(p, n, uv, [r * ca, y0, r * sa], [r * cb, y0, r * sb], [r * cb, y1, r * sb], [r * ca, y1, r * sa], out);
+        pushQuad(p, n, uv, [r * ca, y0, r * sa], [r * cb, y0, r * sb], [r * cb, y1, r * sb], [r * ca, y1, r * sa], out, [
+            [ringU[i], y0],
+            [ringU[i + 1], y0],
+            [ringU[i + 1], y1],
+            [ringU[i], y1],
+        ]);
     }
 }
 function disc(p, n, uv, r, y, hint, segs = 32) {
@@ -152,7 +163,13 @@ function disc(p, n, uv, r, y, hint, segs = 32) {
     for (let i = 0; i < segs; i++) {
         const a = (i / segs) * Math.PI * 2;
         const b = ((i + 1) / segs) * Math.PI * 2;
-        pushTri(p, n, uv, center, polar(a, r, y), polar(b, r, y), hint);
+        const edgeA = polar(a, r, y);
+        const edgeB = polar(b, r, y);
+        pushTri(p, n, uv, center, edgeA, edgeB, hint, [
+            [center.x, center.z],
+            [edgeA.x, edgeA.z],
+            [edgeB.x, edgeB.z],
+        ]);
     }
 }
 // Half-ellipsoid cap: base radius `rb` at `y0`, apex `hd` above it.
@@ -170,6 +187,14 @@ function dome(p, n, uv, rb, y0, hd, lat, lng) {
         grid.push(row);
     }
     const center = new THREE.Vector3(0, y0, 0);
+    const ringU = grid.map((row) => cumulativeProfileDistances(row.map((point) => [point.x, point.y, point.z])));
+    const ringV = [0];
+    for (let i = 1; i <= lat; i++) {
+        let distance = 0;
+        for (let j = 0; j <= lng; j++)
+            distance += grid[i - 1][j].distanceTo(grid[i][j]);
+        ringV.push(ringV[i - 1] + distance / (lng + 1));
+    }
     for (let i = 0; i < lat; i++) {
         for (let j = 0; j < lng; j++) {
             const a = grid[i][j];
@@ -178,7 +203,12 @@ function dome(p, n, uv, rb, y0, hd, lat, lng) {
             const d = grid[i + 1][j];
             const mid = new THREE.Vector3().add(a).add(b).add(c).add(d).multiplyScalar(0.25);
             const hint = mid.clone().sub(center).normalize();
-            pushQuad(p, n, uv, a, b, c, d, [hint.x, hint.y, hint.z]);
+            pushQuad(p, n, uv, a, b, c, d, [hint.x, hint.y, hint.z], [
+                [ringU[i][j], ringV[i]],
+                [ringU[i][j + 1], ringV[i]],
+                [ringU[i + 1][j + 1], ringV[i + 1]],
+                [ringU[i + 1][j], ringV[i + 1]],
+            ]);
         }
     }
 }
@@ -203,7 +233,7 @@ function v(point) {
 // always visible from the intended side under a FrontSide material — no
 // hand-traced winding to get wrong. UVs are dimension-based so painted
 // presets tile at a consistent world density across the body and vanes.
-function pushQuad(positions, normals, uvs, ap, bp, cp, dp, hint) {
+function pushQuad(positions, normals, uvs, ap, bp, cp, dp, hint, authoredUvs) {
     const a = v(ap);
     const b = v(bp);
     const c = v(cp);
@@ -222,32 +252,26 @@ function pushQuad(positions, normals, uvs, ap, bp, cp, dp, hint) {
     nx /= len;
     ny /= len;
     nz /= len;
-    const abx = b[0] - a[0];
-    const aby = b[1] - a[1];
-    const abz = b[2] - a[2];
-    const adx = d[0] - a[0];
-    const ady = d[1] - a[1];
-    const adz = d[2] - a[2];
-    const u = Math.sqrt(abx * abx + aby * aby + abz * abz);
-    const vv = Math.sqrt(adx * adx + ady * ady + adz * adz);
+    const faceUvs = authoredUvs ?? planarMetricUvs([a, b, c, d], [nx, ny, nz]);
+    const [uvA, uvB, uvC, uvD] = faceUvs;
     if (flip) {
         // Reversed winding: (a,b,c) + (a,c,d).
         positions.push(a[0], a[1], a[2], b[0], b[1], b[2], c[0], c[1], c[2]);
-        uvs.push(0, 0, u, 0, u, vv);
+        uvs.push(...uvA, ...uvB, ...uvC);
         positions.push(a[0], a[1], a[2], c[0], c[1], c[2], d[0], d[1], d[2]);
-        uvs.push(0, 0, u, vv, 0, vv);
+        uvs.push(...uvA, ...uvC, ...uvD);
     }
     else {
         // Default winding: (a,c,b) + (a,d,c).
         positions.push(a[0], a[1], a[2], c[0], c[1], c[2], b[0], b[1], b[2]);
-        uvs.push(0, 0, u, vv, u, 0);
+        uvs.push(...uvA, ...uvC, ...uvB);
         positions.push(a[0], a[1], a[2], d[0], d[1], d[2], c[0], c[1], c[2]);
-        uvs.push(0, 0, 0, vv, u, vv);
+        uvs.push(...uvA, ...uvD, ...uvC);
     }
     for (let i = 0; i < 6; i++)
         normals.push(nx, ny, nz);
 }
-function pushTri(positions, normals, uvs, ap, bp, cp, hint) {
+function pushTri(positions, normals, uvs, ap, bp, cp, hint, authoredUvs) {
     const a = v(ap);
     const b = v(bp);
     const c = v(cp);
@@ -264,13 +288,18 @@ function pushTri(positions, normals, uvs, ap, bp, cp, hint) {
     nx /= len;
     ny /= len;
     nz /= len;
+    const faceUvs = authoredUvs ?? planarMetricUvs([a, b, c], [nx, ny, nz]);
+    const uvA = faceUvs[0];
+    const uvB = faceUvs[1];
+    const uvC = faceUvs[2];
     if (flip) {
         positions.push(a[0], a[1], a[2], c[0], c[1], c[2], b[0], b[1], b[2]);
+        uvs.push(...uvA, ...uvC, ...uvB);
     }
     else {
         positions.push(a[0], a[1], a[2], b[0], b[1], b[2], c[0], c[1], c[2]);
+        uvs.push(...uvA, ...uvB, ...uvC);
     }
-    uvs.push(0, 0, 1, 0, 0, 1);
     for (let i = 0; i < 3; i++)
         normals.push(nx, ny, nz);
 }
@@ -279,6 +308,7 @@ function toGeometry(positions, normals, uvs) {
     geo.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
     geo.setAttribute('normal', new THREE.Float32BufferAttribute(normals, 3));
     geo.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2));
+    copyUvToSecondaryChannel(geo);
     geo.computeBoundingSphere();
     return geo;
 }

package/dist/turbine-vent/paint.d.ts

@@ -0,0 +1,4 @@
+import type { TurbineVentMaterialRole } from '@pascal-app/core';
+export declare function resolveTurbineVentMaterialRole(hitObjectName?: string): TurbineVentMaterialRole;
+export declare const turbineVentPaint: import("@pascal-app/core").PaintCapability;
+//# sourceMappingURL=paint.d.ts.map

package/dist/turbine-vent/paint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/turbine-vent/paint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAA2B,uBAAuB,EAAE,MAAM,kBAAkB,CAAA;AAMxF,wBAAgB,8BAA8B,CAAC,aAAa,CAAC,EAAE,MAAM,GAAG,uBAAuB,CAE9F;AAED,eAAO,MAAM,gBAAgB,4CA0B3B,CAAA"}

package/dist/turbine-vent/paint.js

@@ -0,0 +1,35 @@
+import { buildSlotPreviewMaterial, createSlotPaintCapability } from '../shared/slot-paint';
+export function resolveTurbineVentMaterialRole(hitObjectName) {
+    return hitObjectName === 'turbine-vent-head' ? 'head' : 'base';
+}
+export const turbineVentPaint = createSlotPaintCapability({
+    materialTarget: 'turbine-vent',
+    resolveRole: ({ hitObjectName }) => resolveTurbineVentMaterialRole(hitObjectName),
+    applyPreview: ({ role, material, materialPreset, root }) => {
+        const preview = buildSlotPreviewMaterial(material, materialPreset);
+        if (!preview)
+            return null;
+        const targetName = `turbine-vent-${role}`;
+        const restores = [];
+        root.traverse((object) => {
+            const mesh = object;
+            if (!mesh.isMesh || mesh.name !== targetName)
+                return;
+            const previous = mesh.material;
+            mesh.material = preview;
+            restores.push(() => {
+                mesh.material = previous;
+            });
+        });
+        if (restores.length === 0)
+            return null;
+        return () => {
+            for (let index = restores.length - 1; index >= 0; index -= 1)
+                restores[index]?.();
+        };
+    },
+    legacyEffective: (node) => {
+        const legacy = node;
+        return { material: legacy.material, materialPreset: legacy.materialPreset };
+    },
+});

package/dist/turbine-vent/panel.js

@@ -123,5 +123,5 @@ export default function TurbineVentPanel() {
     return (_jsxs(PanelWrapper, { icon: "/icons/roof.webp", onBack: node.roofSegmentId ? handleBack : undefined, onClose: handleClose, title: node.name || 'Turbine Vent', width: 300, children: [_jsx(PanelSection, { title: "Style", children: _jsx(SegmentedControl, { onChange: (v) => handleUpdate({ style: v }), options: [
                         { label: 'Globe', value: 'globe' },
                         { label: 'Cylinder', value: 'cylinder' },
-                    ], value: node.style ?? 'globe' }) }), _jsxs(PanelSection, { title: "Dimensions", children: [_jsx(SliderControl, { label: "Diameter", max: 0.7, min: 0.15, onChange: (v) => previewProp({ diameter: v }), onCommit: (v) => handleUpdate({ diameter: v }), precision: 2, restoreOnCommit: false, step: 0.01, unit: "m", value: Math.round(node.diameter * 100) / 100 }), _jsx(SliderControl, { label: "Height", max: 0.9, min: 0.2, onChange: (v) => previewProp({ height: v }), onCommit: (v) => handleUpdate({ height: v }), precision: 2, restoreOnCommit: false, step: 0.01, unit: "m", value: Math.round(node.height * 100) / 100 }), _jsx(SliderControl, { label: "Neck Height", max: Math.max(0.04, node.height * 0.5), min: 0.02, onChange: (v) => previewProp({ neckHeight: v }), onCommit: (v) => handleUpdate({ neckHeight: v }), precision: 2, restoreOnCommit: false, step: 0.01, unit: "m", value: Math.round((node.neckHeight ?? 0.09) * 100) / 100 }), _jsx(SliderControl, { label: "Vanes", max: 36, min: 6, onChange: (v) => previewProp({ vaneCount: Math.round(v) }), onCommit: (v) => handleUpdate({ vaneCount: Math.round(v) }), precision: 0, restoreOnCommit: false, step: 1, unit: "", value: Math.round(node.vaneCount ?? 20) })] }), _jsxs(PanelSection, { title: "Motion", children: [_jsx(ActionGroup, { children: _jsx(ActionButton, { icon: isSpinning ? _jsx(Pause, { className: "h-3.5 w-3.5" }) : _jsx(Play, { className: "h-3.5 w-3.5" }), label: isSpinning ? 'Pause' : 'Play', onClick: handleToggleSpin }) }), _jsx(SliderControl, { label: "Spin Speed", max: 4, min: 0, onChange: (v) => previewProp({ spinSpeed: v }), onCommit: (v) => handleUpdate({ spinSpeed: v }), precision: 1, restoreOnCommit: false, step: 0.1, unit: "rad/s", value: Math.round((node.spinSpeed ?? 0) * 10) / 10 })] }), _jsxs(PanelSection, { title: "Position", children: [_jsx(SliderControl, { label: "X", max: Math.round(((segment?.width ?? 10) / 2) * 100) / 100, min: -Math.round(((segment?.width ?? 10) / 2) * 100) / 100, onChange: (v) => previewProp({ position: [v, node.position[1] ?? 0, node.position[2] ?? 0] }), onCommit: (v) => handleUpdate({ position: [v, node.position[1] ?? 0, node.position[2] ?? 0] }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round((node.position[0] ?? 0) * 100) / 100 }), _jsx(SliderControl, { label: "Y", max: Math.max((segment?.wallHeight ?? 3) + (segment ? getActiveRoofHeight(segment) : 3) + 2, (node.position[1] ?? 0) + 0.1), min: Math.min(0, (node.position[1] ?? 0) - 0.5), onChange: (v) => previewProp({ position: [node.position[0] ?? 0, v, node.position[2] ?? 0] }), onCommit: (v) => handleUpdate({ position: [node.position[0] ?? 0, v, node.position[2] ?? 0] }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round((node.position[1] ?? 0) * 100) / 100 }), _jsx(SliderControl, { label: "Z", max: Math.round(((segment?.depth ?? 10) / 2) * 100) / 100, min: -Math.round(((segment?.depth ?? 10) / 2) * 100) / 100, onChange: (v) => previewProp({ position: [node.position[0] ?? 0, node.position[1] ?? 0, v] }), onCommit: (v) => handleUpdate({ position: [node.position[0] ?? 0, node.position[1] ?? 0, v] }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round((node.position[2] ?? 0) * 100) / 100 }), _jsx(SliderControl, { label: "Rotation", max: 180, min: -180, onChange: (deg) => previewProp({ rotation: (deg * Math.PI) / 180 }), onCommit: (deg) => handleUpdate({ rotation: (deg * Math.PI) / 180 }), precision: 0, restoreOnCommit: false, step: 1, unit: "\u00B0", value: Math.round(((node.rotation ?? 0) * 180) / Math.PI) })] }), _jsx(PanelSection, { title: "Actions", children: _jsxs(ActionGroup, { children: [_jsx(ActionButton, { icon: _jsx(Move, { className: "h-3.5 w-3.5" }), label: "Move", onClick: handleMove }), _jsx(ActionButton, { icon: _jsx(Copy, { className: "h-3.5 w-3.5" }), label: "Duplicate", onClick: handleDuplicate }), _jsx(ActionButton, { className: "hover:bg-red-500/20", icon: _jsx(Trash2, { className: "h-3.5 w-3.5 text-red-400" }), label: "Delete", onClick: handleDelete })] }) })] }));
+                    ], value: node.style ?? 'globe' }) }), _jsxs(PanelSection, { title: "Dimensions", children: [_jsx(SliderControl, { label: "Diameter", max: 1000, min: 0.15, onChange: (v) => previewProp({ diameter: v }), onCommit: (v) => handleUpdate({ diameter: v }), precision: 2, restoreOnCommit: false, step: 0.01, unit: "m", value: Math.round(node.diameter * 100) / 100 }), _jsx(SliderControl, { label: "Height", max: 1000, min: 0.2, onChange: (v) => previewProp({ height: v }), onCommit: (v) => handleUpdate({ height: v }), precision: 2, restoreOnCommit: false, step: 0.01, unit: "m", value: Math.round(node.height * 100) / 100 }), _jsx(SliderControl, { label: "Neck Height", max: Math.max(0.04, node.height * 0.5), min: 0.02, onChange: (v) => previewProp({ neckHeight: v }), onCommit: (v) => handleUpdate({ neckHeight: v }), precision: 2, restoreOnCommit: false, step: 0.01, unit: "m", value: Math.round((node.neckHeight ?? 0.09) * 100) / 100 }), _jsx(SliderControl, { label: "Vanes", max: 36, min: 6, onChange: (v) => previewProp({ vaneCount: Math.round(v) }), onCommit: (v) => handleUpdate({ vaneCount: Math.round(v) }), precision: 0, restoreOnCommit: false, step: 1, unit: "", value: Math.round(node.vaneCount ?? 20) })] }), _jsxs(PanelSection, { title: "Motion", children: [_jsx(ActionGroup, { children: _jsx(ActionButton, { icon: isSpinning ? _jsx(Pause, { className: "h-3.5 w-3.5" }) : _jsx(Play, { className: "h-3.5 w-3.5" }), label: isSpinning ? 'Pause' : 'Play', onClick: handleToggleSpin }) }), _jsx(SliderControl, { label: "Spin Speed", max: 4, min: 0, onChange: (v) => previewProp({ spinSpeed: v }), onCommit: (v) => handleUpdate({ spinSpeed: v }), precision: 1, restoreOnCommit: false, step: 0.1, unit: "rad/s", value: Math.round((node.spinSpeed ?? 0) * 10) / 10 })] }), _jsxs(PanelSection, { title: "Position", children: [_jsx(SliderControl, { label: "X", max: Math.round(((segment?.width ?? 10) / 2) * 100) / 100, min: -Math.round(((segment?.width ?? 10) / 2) * 100) / 100, onChange: (v) => previewProp({ position: [v, node.position[1] ?? 0, node.position[2] ?? 0] }), onCommit: (v) => handleUpdate({ position: [v, node.position[1] ?? 0, node.position[2] ?? 0] }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round((node.position[0] ?? 0) * 100) / 100 }), _jsx(SliderControl, { label: "Y", max: Math.max((segment?.wallHeight ?? 3) + (segment ? getActiveRoofHeight(segment) : 3) + 2, (node.position[1] ?? 0) + 0.1), min: Math.min(0, (node.position[1] ?? 0) - 0.5), onChange: (v) => previewProp({ position: [node.position[0] ?? 0, v, node.position[2] ?? 0] }), onCommit: (v) => handleUpdate({ position: [node.position[0] ?? 0, v, node.position[2] ?? 0] }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round((node.position[1] ?? 0) * 100) / 100 }), _jsx(SliderControl, { label: "Z", max: Math.round(((segment?.depth ?? 10) / 2) * 100) / 100, min: -Math.round(((segment?.depth ?? 10) / 2) * 100) / 100, onChange: (v) => previewProp({ position: [node.position[0] ?? 0, node.position[1] ?? 0, v] }), onCommit: (v) => handleUpdate({ position: [node.position[0] ?? 0, node.position[1] ?? 0, v] }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: Math.round((node.position[2] ?? 0) * 100) / 100 }), _jsx(SliderControl, { label: "Rotation", max: 180, min: -180, onChange: (deg) => previewProp({ rotation: (deg * Math.PI) / 180 }), onCommit: (deg) => handleUpdate({ rotation: (deg * Math.PI) / 180 }), precision: 0, restoreOnCommit: false, step: 1, unit: "\u00B0", value: Math.round(((node.rotation ?? 0) * 180) / Math.PI) })] }), _jsx(PanelSection, { title: "Actions", children: _jsxs(ActionGroup, { children: [_jsx(ActionButton, { icon: _jsx(Move, { className: "h-3.5 w-3.5" }), label: "Move", onClick: handleMove }), _jsx(ActionButton, { icon: _jsx(Copy, { className: "h-3.5 w-3.5" }), label: "Duplicate", onClick: handleDuplicate }), _jsx(ActionButton, { className: "hover:bg-red-500/20", icon: _jsx(Trash2, { className: "h-3.5 w-3.5 text-red-400" }), label: "Delete", onClick: handleDelete })] }) })] }));
 }

package/dist/turbine-vent/parametrics.js

@@ -20,8 +20,8 @@ export const turbineVentParametrics = {
         {
             label: 'Dimensions',
             fields: [
-                { key: 'diameter', kind: 'number', unit: 'm', min: 0.15, max: 0.7, step: 0.01 },
-                { key: 'height', kind: 'number', unit: 'm', min: 0.2, max: 0.9, step: 0.01 },
+                { key: 'diameter', kind: 'number', unit: 'm', min: 0.15, max: 1000, step: 0.01 },
+                { key: 'height', kind: 'number', unit: 'm', min: 0.2, max: 1000, step: 0.01 },
                 { key: 'neckHeight', kind: 'number', unit: 'm', min: 0.02, max: 0.3, step: 0.01 },
                 { key: 'vaneCount', kind: 'number', unit: '', min: 6, max: 36, step: 1 },
             ],

package/dist/turbine-vent/renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/turbine-vent/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,eAAe,EAIrB,MAAM,kBAAkB,CAAA;AAsBzB;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,mBAAmB,GAAI,qBAAqB;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,uCA4I1E,CAAA;AAED,eAAe,mBAAmB,CAAA"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/turbine-vent/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,eAAe,EAIrB,MAAM,kBAAkB,CAAA;AAuBzB;;;;;;;;;;;GAWG;AACH,QAAA,MAAM,mBAAmB,GAAI,qBAAqB;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,uCA+J1E,CAAA;AAED,eAAe,mBAAmB,CAAA"}

package/dist/turbine-vent/renderer.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useLiveNodeOverrides, useRegistry, useScene, } from '@pascal-app/core';
-import { createMaterial, createMaterialFromPresetRef, createSurfaceRoleMaterial, useNodeEvents, useViewer, } from '@pascal-app/viewer';
+import { createMaterial, createMaterialFromPresetRef, createSurfaceRoleMaterial, resolveMaterialRef, useNodeEvents, useViewer, } from '@pascal-app/viewer';
 import { useFrame } from '@react-three/fiber';
 import { useEffect, useMemo, useRef } from 'react';
 import * as THREE from 'three';
@@ -34,6 +34,7 @@ const TurbineVentRenderer = ({ node: storeNode }) => {
     const textures = useViewer((s) => s.textures);
     const colorPreset = useViewer((s) => s.colorPreset);
     const sceneTheme = useViewer((s) => s.sceneTheme);
+    const sceneMaterials = useScene((s) => s.materials);
     // Merge live overrides (panel slider drags) on top of the store node so
     // the mesh updates frame-by-frame without polluting undo history.
     const overrides = useLiveNodeOverrides((s) => s.get(storeNode.id));
@@ -68,13 +69,34 @@ const TurbineVentRenderer = ({ node: storeNode }) => {
         return surfaceQuatFromNormal(normal, new THREE.Quaternion());
     }, [segment, node.position[0], node.position[2]]);
     const material = useMemo(() => {
-        if (!textures || (!node.material && !node.materialPreset)) {
-            return createSurfaceRoleMaterial('roof', colorPreset, THREE.FrontSide, sceneTheme);
-        }
-        return node.material
-            ? createMaterial(node.material, shading)
-            : (createMaterialFromPresetRef(node.materialPreset, shading) ?? defaultMaterial);
-    }, [textures, colorPreset, sceneTheme, shading, node.material, node.materialPreset]);
+        const roleDefault = createSurfaceRoleMaterial('roof', colorPreset, THREE.FrontSide, sceneTheme);
+        const resolve = (role) => {
+            if (!textures)
+                return roleDefault;
+            const slotMaterial = resolveMaterialRef(node.slots?.[role], sceneMaterials, shading);
+            if (slotMaterial)
+                return slotMaterial;
+            if (node.material)
+                return createMaterial(node.material, shading);
+            if (node.materialPreset) {
+                return createMaterialFromPresetRef(node.materialPreset, shading) ?? defaultMaterial;
+            }
+            return roleDefault;
+        };
+        return {
+            base: resolve('base'),
+            head: resolve('head'),
+        };
+    }, [
+        textures,
+        colorPreset,
+        sceneTheme,
+        shading,
+        node.slots,
+        node.material,
+        node.materialPreset,
+        sceneMaterials,
+    ]);
     // Compose slope tilt + yaw onto a single quaternion so the registered
     // ref's local frame is vent-mesh-local (handles read this frame).
     const yAxis = useMemo(() => new THREE.Vector3(0, 1, 0), []);
@@ -102,6 +124,6 @@ const TurbineVentRenderer = ({ node: storeNode }) => {
     const segPos = segment.position ?? [0, 0, 0];
     const segRotY = segment.rotation ?? 0;
     const neckH = Math.max(0.02, Math.min(node.neckHeight ?? 0.09, Math.max(0.12, node.height) * 0.5));
-    return (_jsx("group", { position: segPos, "rotation-y": segRotY, children: _jsxs("group", { position: [node.position[0] ?? 0, node.position[1] ?? 0, node.position[2] ?? 0], quaternion: composedQuat, ref: ref, visible: node.visible, children: [_jsx("mesh", { castShadow: true, geometry: clippedBase ?? baseGeometry, material: material, name: "turbine-vent-base", receiveShadow: true, ...handlers }), _jsx("group", { position: [0, neckH, 0], ref: headRef, children: _jsx("mesh", { castShadow: true, geometry: clippedHead ?? headGeometry, material: material, name: "turbine-vent-head", receiveShadow: true, ...handlers }) })] }) }));
+    return (_jsx("group", { position: segPos, "rotation-y": segRotY, children: _jsxs("group", { position: [node.position[0] ?? 0, node.position[1] ?? 0, node.position[2] ?? 0], quaternion: composedQuat, ref: ref, visible: node.visible, children: [_jsx("mesh", { castShadow: true, geometry: clippedBase ?? baseGeometry, material: material.base, name: "turbine-vent-base", receiveShadow: true, ...handlers }), _jsx("group", { position: [0, neckH, 0], ref: headRef, children: _jsx("mesh", { castShadow: true, geometry: clippedHead ?? headGeometry, material: material.head, name: "turbine-vent-head", receiveShadow: true, ...handlers }) })] }) }));
 };
 export default TurbineVentRenderer;

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

@@ -0,0 +1,3 @@
+import type { AnyNode } from '@pascal-app/core';
+export declare function hasWallCurveBlockingChildren(children: readonly AnyNode[]): boolean;
+//# sourceMappingURL=curve-eligibility.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"curve-eligibility.d.ts","sourceRoot":"","sources":["../../src/wall/curve-eligibility.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAE/C,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,WAQxE"}

package/dist/wall/curve-eligibility.js

@@ -0,0 +1,10 @@
+export function hasWallCurveBlockingChildren(children) {
+    return children.some((child) => {
+        if (child.type === 'door' || child.type === 'window' || child.type === 'lean-to-extension') {
+            return true;
+        }
+        if (child.type !== 'item')
+            return false;
+        return child.asset?.attachTo === 'wall' || child.asset?.attachTo === 'wall-side';
+    });
+}

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

@@ -1 +1 @@
-{"version":3,"file":"curve-tool.d.ts","sourceRoot":"","sources":["../../src/wall/curve-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAWL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAazB;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAgJtD,CAAA;AAED,eAAe,aAAa,CAAA"}
+{"version":3,"file":"curve-tool.d.ts","sourceRoot":"","sources":["../../src/wall/curve-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAaL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAazB;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAmJtD,CAAA;AAED,eAAe,aAAa,CAAA"}

package/dist/wall/curve-tool.js

@@ -1,6 +1,6 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
-import { acquireSceneHistoryPause, emitter, getClampedWallCurveOffset, getMaxWallCurveOffset, getWallChordFrame, getWallMidpointHandlePoint, normalizeWallCurveOffset, useScene, } from '@pascal-app/core';
+import { acquireSceneHistoryPause, constrainWallCurveOffsetToAvoidIntersections, emitter, getClampedWallCurveOffset, getMaxWallCurveOffset, getWallChordFrame, getWallMidpointHandlePoint, normalizeWallCurveOffset, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { CursorSphere, getSegmentGridStep, markToolCancelConsumed, snapBuildingLocalToWorldGrid, snapScalarToGrid, triggerSFX, useInteractionScope, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useCallback, useEffect, useRef, useState } from 'react';
@@ -32,6 +32,7 @@ export const CurveWallTool = ({ node }) => {
         const originalCurveOffset = originalCurveOffsetRef.current;
         const chord = getWallChordFrame(node);
         const maxCurveOffset = getMaxWallCurveOffset(node);
+        const levelWalls = Object.values(useScene.getState().nodes).filter((candidate) => candidate.type === 'wall' && candidate.parentId === node.parentId);
         let releaseHistory = acquireSceneHistoryPause(useScene);
         let wasFinalized = false;
         const applyPreview = (curveOffset) => {
@@ -45,15 +46,12 @@ export const CurveWallTool = ({ node }) => {
             };
             const handlePoint = getWallMidpointHandlePoint(nextNode);
             setCursorLocalPos([handlePoint.x, 0, handlePoint.y]);
-            useScene.getState().updateNode(nodeId, { curveOffset });
+            useLiveNodeOverrides.getState().set(nodeId, { curveOffset });
             useScene.getState().markDirty(nodeId);
         };
         const restoreOriginal = () => {
-            if (previewOffsetRef.current === originalCurveOffset) {
-                return;
-            }
             previewOffsetRef.current = originalCurveOffset;
-            useScene.getState().updateNode(nodeId, { curveOffset: originalCurveOffset });
+            useLiveNodeOverrides.getState().clear(nodeId);
             useScene.getState().markDirty(nodeId);
         };
         const onGridMove = (event) => {
@@ -67,7 +65,8 @@ export const CurveWallTool = ({ node }) => {
             const offsetFromMidpoint = -((localX - chord.midpoint.x) * chord.normal.x +
                 (localZ - chord.midpoint.y) * chord.normal.y);
             const snappedOffset = snapScalarToGrid(offsetFromMidpoint, snapStep);
-            const nextCurveOffset = normalizeWallCurveOffset(node, Math.max(-maxCurveOffset, Math.min(maxCurveOffset, snappedOffset)));
+            const requestedCurveOffset = normalizeWallCurveOffset(node, Math.max(-maxCurveOffset, Math.min(maxCurveOffset, snappedOffset)));
+            const nextCurveOffset = constrainWallCurveOffsetToAvoidIntersections(node, requestedCurveOffset, levelWalls);
             if (previousCurveOffsetRef.current !== null &&
                 nextCurveOffset !== previousCurveOffsetRef.current) {
                 triggerSFX('sfx:grid-snap');
@@ -84,11 +83,9 @@ export const CurveWallTool = ({ node }) => {
             }
             const curveOffset = previewOffsetRef.current;
             wasFinalized = true;
+            useLiveNodeOverrides.getState().clear(nodeId);
+            useScene.getState().markDirty(nodeId);
             if (curveOffset !== originalCurveOffset) {
-                // Restore original baseline while paused so the next resume+update
-                // registers as a single tracked change (undo reverts to original).
-                useScene.getState().updateNode(nodeId, { curveOffset: originalCurveOffset });
-                useScene.getState().markDirty(nodeId);
                 releaseHistory();
                 useScene.getState().updateNode(nodeId, { curveOffset });
                 useScene.getState().markDirty(nodeId);

package/dist/wall/definition.d.ts

@@ -1,4 +1,4 @@
-import type { NodeDefinition } from '@pascal-app/core';
+import { type NodeDefinition } from '@pascal-app/core';
 import { WallNode } from './schema';
 /**
  * Wall — the Phase 3 stress test of the registry-driven node model.

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/wall/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAa,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAejE,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAGnC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAoI1D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/wall/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,cAAc,EAEpB,MAAM,kBAAkB,CAAA;AAwBzB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAGnC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CA4J1D,CAAA"}

package/dist/wall/definition.js

@@ -1,6 +1,9 @@
+import { getWallBaseElevationForNodes, getWallEffectiveHeightForNodes, } from '@pascal-app/core';
+import { DRAFTING_SURFACE_EXTENSION_KEY, } from '@pascal-app/editor';
 import { buildWallContextualDimensions } from './contextual-dimensions';
+import { hasWallCurveBlockingChildren } from './curve-eligibility';
 import { buildWallFloorplan, computeWallFloorplanLevelData } from './floorplan';
-import { wallCurveAffordance, wallMoveEndpointAffordance } from './floorplan-affordances';
+import { wallCurveAffordance, wallMoveEndpointAffordance, wallThicknessAffordance, } from './floorplan-affordances';
 import { wallFloorplanMoveTarget } from './floorplan-move';
 import { wallFloorplanSiblingOverrides } from './floorplan-overrides';
 import { matchWallMeasurementFeature, resolveWallMeasurementFeature, wallMeasurementFeatures, } from './measurement';
@@ -27,24 +30,37 @@ import { wallSlots } from './slots';
 export const wallDefinition = {
     kind: 'wall',
     snapProfile: 'structural',
-    schemaVersion: 7,
+    schemaVersion: 8,
     schema: WallNode,
     category: 'structure',
     surfaceRole: 'wall',
     extensions: {
+        [DRAFTING_SURFACE_EXTENSION_KEY]: {
+            kind: 'wall',
+            classifyFace: (node, localNormal) => {
+                if (node?.type !== 'wall')
+                    return null;
+                const dx = node.end[0] - node.start[0];
+                const dz = node.end[1] - node.start[1];
+                const length = Math.hypot(dx, dz);
+                if (length <= 1e-9)
+                    return { face: 'unknown' };
+                const sideDot = localNormal[0] * (-dz / length) + localNormal[2] * (dx / length);
+                if (Math.abs(localNormal[1]) > 0.7)
+                    return { face: 'top' };
+                if (Math.abs(localNormal[1]) < 0.25 && Math.abs(sideDot) > 0.7) {
+                    return { face: 'side', side: sideDot >= 0 ? 'front' : 'back' };
+                }
+                return { face: 'end' };
+            },
+        },
         'pascal:editor/floorplan': {
             contextualDimensions: buildWallContextualDimensions,
             actionMenu: {
-                canCurve: ({ node, nodes }) => !node.children.some((childId) => {
+                canCurve: ({ node, nodes }) => !hasWallCurveBlockingChildren(node.children.flatMap((childId) => {
                     const child = nodes[childId];
-                    if (!child)
-                        return false;
-                    if (child.type === 'door' || child.type === 'window')
-                        return true;
-                    if (child.type !== 'item')
-                        return false;
-                    return child.asset?.attachTo === 'wall' || child.asset?.attachTo === 'wall-side';
-                }),
+                    return child ? [child] : [];
+                })),
             },
         },
     },
@@ -66,6 +82,12 @@ export const wallDefinition = {
         selectable: { hitVolume: 'bbox' },
         // Front + back faces host items (paintings, shelves, switches).
         surfaces: {
+            top: {
+                height: (node, { nodes }) => {
+                    const wall = node;
+                    return (getWallBaseElevationForNodes(wall, nodes) + getWallEffectiveHeightForNodes(wall, nodes));
+                },
+            },
             sides: { faces: 'all' },
         },
         duplicable: true,
@@ -82,7 +104,7 @@ export const wallDefinition = {
         slots: () => wallSlots(),
     },
     relations: {
-        hosts: ['door', 'window', 'item'],
+        hosts: ['door', 'window', 'item', 'lean-to-extension'],
         affectsSpatial: ['slab', 'ceiling', 'zone'],
         linkedBy: 'endpoint-match',
         cascadeDelete: 'descendants',
@@ -131,6 +153,7 @@ export const wallDefinition = {
     floorplanAffordances: {
         'move-endpoint': wallMoveEndpointAffordance,
         curve: wallCurveAffordance,
+        thickness: wallThicknessAffordance,
     },
     floorplanMoveTarget: wallFloorplanMoveTarget,
     floorplanSiblingOverrides: wallFloorplanSiblingOverrides,
@@ -140,7 +163,7 @@ export const wallDefinition = {
     ],
     presentation: {
         label: 'Wall',
-        description: 'A straight or curved wall segment. Hosts doors, windows, and wall-mounted items.',
+        description: 'A straight or curved wall segment. Hosts doors, windows, lean-to extensions, and wall-mounted items.',
         icon: { kind: 'url', src: '/icons/wall.webp' },
         paletteSection: 'structure',
         paletteOrder: 10,

package/dist/wall/floorplan-affordances.d.ts

@@ -9,5 +9,6 @@ import { type FloorplanAffordance, type WallNode } from '@pascal-app/core';
  * pause / resume around `apply`.
  */
 export declare const wallCurveAffordance: FloorplanAffordance<WallNode>;
+export declare const wallThicknessAffordance: FloorplanAffordance<WallNode>;
 export declare const wallMoveEndpointAffordance: FloorplanAffordance<WallNode>;
 //# sourceMappingURL=floorplan-affordances.d.ts.map

package/dist/wall/floorplan-affordances.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/wall/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,mBAAmB,EAQxB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAoFzB;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,EAAE,mBAAmB,CAAC,QAAQ,CAuD7D,CAAA;AAED,eAAO,MAAM,0BAA0B,EAAE,mBAAmB,CAAC,QAAQ,CA0KpE,CAAA"}
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/wall/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,mBAAmB,EAUxB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAgGzB;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,EAAE,mBAAmB,CAAC,QAAQ,CAgE7D,CAAA;AAED,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,QAAQ,CAiCjE,CAAA;AAED,eAAO,MAAM,0BAA0B,EAAE,mBAAmB,CAAC,QAAQ,CA4KpE,CAAA"}

package/dist/wall/floorplan-affordances.js

@@ -1,23 +1,29 @@
-import { getMaxWallCurveOffset, getWallChordFrame, normalizeWallCurveOffset, runAsSingleSceneHistoryStep, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { constrainWallCurveOffsetToAvoidIntersections, getMaxWallCurveOffset, getWallChordFrame, getWallCurveFrameAt, getWallThickness, normalizeWallCurveOffset, runAsSingleSceneHistoryStep, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { alignFloorplanDraftPoint, getSegmentGridStep, isAlignmentGuideActive, isAngleSnapActive, isMagneticSnapActive, isSegmentLongEnough, resolveEndpointWallSplit, snapBuildingLocalToWorldGrid, snapScalarToGrid, snapWallDraftPoint, useAlignmentGuides, } from '@pascal-app/editor';
+const MIN_WALL_THICKNESS = 0.05;
 function pointsEqual(a, b) {
     return a[0] === b[0] && a[1] === b[1];
 }
-function collectLevelWalls(nodes, excludeWallId) {
+function collectLevelWalls(nodes, parentId, excludeWallId) {
     const out = [];
     for (const node of Object.values(nodes)) {
-        if (node?.type === 'wall' && node.id !== excludeWallId)
+        if (node?.type === 'wall' &&
+            node.id !== excludeWallId &&
+            (node.parentId ?? null) === parentId) {
             out.push(node);
+        }
     }
     return out;
 }
-function collectLinkedWalls(nodes, draggedWallId, originalStart, originalEnd) {
+function collectLinkedWalls(nodes, draggedWallId, parentId, originalStart, originalEnd) {
     const linked = [];
     for (const node of Object.values(nodes)) {
         if (node?.type !== 'wall')
             continue;
         if (node.id === draggedWallId)
             continue;
+        if ((node.parentId ?? null) !== parentId)
+            continue;
         const wall = node;
         if (pointsEqual(wall.start, originalStart) ||
             pointsEqual(wall.start, originalEnd) ||
@@ -65,7 +71,9 @@ export const wallCurveAffordance = {
                 const offsetFromMidpoint = -((x - chord.midpoint.x) * chord.normal.x +
                     (y - chord.midpoint.y) * chord.normal.y);
                 const snappedOffset = snapScalarToGrid(offsetFromMidpoint, snapStep);
-                const nextCurveOffset = normalizeWallCurveOffset(node, Math.max(-maxOffset, Math.min(maxOffset, snappedOffset)));
+                const requestedCurveOffset = normalizeWallCurveOffset(node, Math.max(-maxOffset, Math.min(maxOffset, snappedOffset)));
+                const sceneNodes = useScene.getState().nodes;
+                const nextCurveOffset = constrainWallCurveOffsetToAvoidIntersections(node, requestedCurveOffset, Object.values(sceneNodes).filter((candidate) => candidate.type === 'wall' && candidate.parentId === node.parentId));
                 lastCurveOffset = nextCurveOffset;
                 // Publish the curve preview as a live override so renderers see
                 // it without zustand churn. Mark the wall dirty so `WallSystem`
@@ -89,13 +97,43 @@ export const wallCurveAffordance = {
         };
     },
 };
+export const wallThicknessAffordance = {
+    start({ node, payload, initialPlanPoint }) {
+        const { side } = payload;
+        const frame = getWallCurveFrameAt(node, 0.5);
+        const outwardX = frame.normal.x * side;
+        const outwardY = frame.normal.y * side;
+        const initialThickness = getWallThickness(node);
+        const wallId = node.id;
+        let lastThickness = initialThickness;
+        return {
+            affectedIds: [wallId],
+            apply({ planPoint }) {
+                const outwardDelta = (planPoint[0] - initialPlanPoint[0]) * outwardX +
+                    (planPoint[1] - initialPlanPoint[1]) * outwardY;
+                const rawThickness = initialThickness + outwardDelta * 2;
+                lastThickness = Math.max(MIN_WALL_THICKNESS, snapScalarToGrid(rawThickness, getSegmentGridStep()));
+                useLiveNodeOverrides.getState().set(wallId, { thickness: lastThickness });
+                useScene.getState().markDirty(wallId);
+            },
+            canCommit() {
+                return true;
+            },
+            commit() {
+                useScene.getState().updateNodes([{ id: wallId, data: { thickness: lastThickness } }]);
+                useLiveNodeOverrides.getState().clear(wallId);
+            },
+        };
+    },
+};
 export const wallMoveEndpointAffordance = {
     start({ node, payload, nodes }) {
         const { endpoint } = payload;
         const fixedPoint = endpoint === 'start' ? [...node.end] : [...node.start];
         const originalStart = [...node.start];
         const originalEnd = [...node.end];
-        const linkedWalls = collectLinkedWalls(nodes, node.id, originalStart, originalEnd);
+        const parentId = (node.parentId ?? null);
+        const linkedWalls = collectLinkedWalls(nodes, node.id, parentId, originalStart, originalEnd);
         const affectedIds = [node.id, ...linkedWalls.map((w) => w.id)];
         const movingOriginal = endpoint === 'start' ? originalStart : originalEnd;
         // Walls attached to the MOVING corner cascade with the drag, but the snap
@@ -123,7 +161,7 @@ export const wallMoveEndpointAffordance = {
                 // the moving corner are excluded (stale coordinates); under
                 // Alt-detach they stay put, so they rejoin the candidate pool.
                 const sceneNodes = useScene.getState().nodes;
-                const walls = collectLevelWalls(sceneNodes, node.id);
+                const walls = collectLevelWalls(sceneNodes, parentId, node.id);
                 const staleWallIds = modifiers.altKey ? [node.id] : [node.id, ...movingLinkedWallIds];
                 // The grid step follows the active snapping mode (`getSegmentGridStep()`
                 // is 0 outside grid mode), so `'lines' / 'angles' / 'off'` no longer
@@ -153,6 +191,7 @@ export const wallMoveEndpointAffordance = {
                     applySnap: isMagneticSnapActive(),
                     bypass: !isAlignmentGuideActive(),
                     excludeIds: staleWallIds,
+                    levelId: parentId,
                 });
                 const primaryStart = endpoint === 'start' ? aligned : fixedPoint;
                 const primaryEnd = endpoint === 'end' ? aligned : fixedPoint;

package/dist/wall/floorplan-move.d.ts

@@ -23,10 +23,9 @@ import { type FloorplanMoveTarget, type WallNode } from '@pascal-app/core';
  * overrides after the write lands so the system reads from the new
  * committed scene state.
  *
- * Auto-slab live preview and ghost bridge SVG previews — visible in
- * the 3D tool — are deliberately deferred. Slab polygons re-derive on
- * commit through the normal scene reactions; bridges appear at commit
- * time. Follow-up work to surface them mid-drag is tracked separately.
+ * Existing automatic slabs and ceilings receive live polygon overrides during
+ * the drag. New surfaces and removals stay deferred until commit because live
+ * overrides cannot represent nodes that do not exist in the scene.
  */
 export declare const wallFloorplanMoveTarget: FloorplanMoveTarget<WallNode>;
 //# sourceMappingURL=floorplan-move.d.ts.map