@pascal-app/nodes 1.0.3 → 1.0.4

package/dist/wall/panel.js

@@ -1,14 +1,15 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { buildWallFaceBandCountPatch, GROUND_SUPPORT_ID, getClampedWallCurveOffset, getMaxWallCurveOffset, getWallCurveLength, getWallFaceBandConfig, normalizeWallCurveOffset, terrainSupportLift, useLiveNodeOverrides, useScene, WALL_CHAIR_RAIL_DEFAULT, WALL_CROWN_DEFAULT, WALL_FACE_BAND_DEFAULT, WALL_SKIRTING_DEFAULT, } from '@pascal-app/core';
-import { ActionButton, ActionGroup, curveReshapeScope, formatLinearMeasurement, getLinearUnitLabel, linearControlValueToMeters, metersToLinearUnit, PanelSection, PanelWrapper, SegmentedControl, SliderControl, triggerSFX, useInteractionScope, } from '@pascal-app/editor';
+import { assemblyThickness, BRICK_AIR_SPACE, BRICK_VENEER, FIBER_CEMENT, GROUND_SUPPORT_ID, GYPSUM_HALF, GYPSUM_SHEATHING, getClampedWallCurveOffset, getMaxWallCurveOffset, getWallAssemblyPreset, getWallCurveLength, normalizeWallCurveOffset, resolveWallAssembly, SIDING_LAP, STONE_VENEER_UNVERIFIED, STUCCO_3_COAT, terrainSupportLift, useLiveNodeOverrides, useScene, WALL_ASSEMBLY_PRESETS, WALL_CHAIR_RAIL_DEFAULT, WALL_CROWN_DEFAULT, WALL_SKIRTING_DEFAULT, WSP_SHEATHING, wallAssemblyFromLegacy, wallAssemblyPatch, wallAssemblyToLegacy, wallAssemblyUnverifiedNote, } from '@pascal-app/core';
+import { ActionButton, ActionGroup, curveReshapeScope, formatLinearMeasurement, getLinearUnitLabel, linearControlValueToMeters, metersToLinearUnit, PanelSection, PanelWrapper, SegmentedControl, SliderControl, triggerSFX, useInteractionScope, WallPaintRegionList, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Spline } from 'lucide-react';
-import { useCallback, useEffect, useMemo, useRef } from 'react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling';
 import { CurtainWallPanel } from './curtain-wall-panel';
 import { hasWallCurveBlockingChildren } from './curve-eligibility';
 import { buildWallLengthPatch } from './length-patch';
+import { wallReferenceModel } from './panel-model';
 import { createWallPropertyPreview } from './property-preview';
 /**
  * Base half of the plane-bound repair: a stamped draft offset goes, and a
@@ -85,6 +86,8 @@ export default function WallPanel() {
             return undefined;
         return resolveWallOpeningCeiling(wall, s.nodes);
     });
+    const sceneNodes = useScene((s) => s.nodes);
+    const reference = useMemo(() => (node ? wallReferenceModel([node], sceneNodes) : null), [node, sceneNodes]);
     // 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
@@ -178,49 +181,17 @@ export default function WallPanel() {
                         }), 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: "Bottom" }), _jsx(SegmentedControl, { onChange: handleInfillChange, options: [
                             { label: 'Auto', value: 'auto' },
                             { label: 'Fill to terrain', value: 'terrain' },
-                        ], value: followsTerrain ? 'terrain' : 'auto' }), 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, { onCommit: handleCommit, onCancel: handleCancel, restoreOnCommit: false, previewWhileTyping: true, label: node.wallType === 'curtain' ? 'Frame depth' : 'Thickness', max: metersToLinearUnit(1000, unit), min: metersToLinearUnit(0.05, unit), onChange: (v) => handlePreview({
+                        ], value: followsTerrain ? 'terrain' : 'auto' }), followsTerrain && (_jsx("div", { className: "px-1 text-[11px] text-muted-foreground", children: "Extends downward to meet the terrain. Height and top stay unchanged." })), node.assembly && node.wallType !== 'curtain' ? (_jsxs("div", { className: "flex items-center justify-between px-2 py-1.5", children: [_jsx("span", { className: "font-medium text-[10px] text-muted-foreground uppercase tracking-wider", children: "Thickness" }), _jsxs("span", { className: "text-[11px] text-muted-foreground tabular-nums", children: [formatLinearMeasurement(thickness, unit), " \u00B7 from assembly"] })] })) : (_jsx(SliderControl, { onCommit: handleCommit, onCancel: handleCancel, restoreOnCommit: false, previewWhileTyping: true, label: node.wallType === 'curtain' ? 'Frame depth' : 'Thickness', max: metersToLinearUnit(1000, unit), min: metersToLinearUnit(0.05, unit), onChange: (v) => handlePreview({
                             thickness: linearControlValueToMeters(v, unit, {
                                 maxMeters: 1000,
                                 minMeters: 0.05,
                             }),
-                        }), precision: 3, step: 0.01, unit: unitLabel, value: Math.round(displayThickness * 1000) / 1000 }), !hasWallChildrenBlockingCurve && (_jsx(SliderControl, { onCommit: handleCommit, onCancel: handleCancel, restoreOnCommit: false, previewWhileTyping: true, label: "Curve", max: Math.max(metersToLinearUnit(0.01, unit), displayMaxCurveOffset), min: -Math.max(metersToLinearUnit(0.01, unit), displayMaxCurveOffset), onChange: (v) => handlePreview({
+                        }), precision: 3, step: 0.01, unit: unitLabel, value: Math.round(displayThickness * 1000) / 1000 })), _jsx("div", { className: "px-1 font-medium text-[10px] text-muted-foreground/80", children: "Reference" }), reference && (_jsx(SegmentedControl, { mixed: reference.value === null, onChange: (value) => reference.apply(value), options: reference.options, value: reference.value ?? 'center' })), !hasWallChildrenBlockingCurve && (_jsx(SliderControl, { onCommit: handleCommit, onCancel: handleCancel, restoreOnCommit: false, previewWhileTyping: true, label: "Curve", max: Math.max(metersToLinearUnit(0.01, unit), displayMaxCurveOffset), min: -Math.max(metersToLinearUnit(0.01, unit), displayMaxCurveOffset), onChange: (v) => handlePreview({
                             curveOffset: normalizeWallCurveOffset(node, linearControlValueToMeters(v, unit, {
                                 maxMeters: curveOffsetLimit,
                                 minMeters: -curveOffsetLimit,
                             })),
-                        }), precision: 2, step: 0.1, unit: unitLabel, value: Math.round(displayCurveOffset * 100) / 100 }))] }), node.wallType === 'curtain' ? (_jsx(CurtainWallPanel, { height: height, node: node, onUpdate: handleUpdate, onPreview: handlePreview, onCommit: handleCommit, onCancel: handleCancel, unit: unit }, node.id)) : (_jsxs(_Fragment, { children: [_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, wallHeightMeters);
-    const bandCount = bandConfig.count;
-    const lowerHeight = bandConfig.lowerHeight;
-    const middleHeight = bandConfig.middleHeight;
-    const upperHeight = bandConfig.upperHeight;
-    const updateBands = (patch) => onUpdate({
-        faceBands: {
-            ...WALL_FACE_BAND_DEFAULT,
-            ...(node.faceBands ?? {}),
-            enabled: bandCount > 1,
-            count: bandCount,
-            ...patch,
-        },
-    });
-    return (_jsxs(PanelSection, { title: "Wall bands", children: [_jsx(SliderControl, { label: "Bands", max: 4, min: 1, onChange: (value) => onUpdate(buildWallFaceBandCountPatch(node, Math.round(value))), precision: 0, step: 1, value: bandCount }), bandCount >= 2 && (_jsx(SliderControl, { label: "Lower", max: metersToLinearUnit(wallHeightMeters, unit), min: metersToLinearUnit(0, unit), onChange: (value) => updateBands({
-                    lowerHeight: linearControlValueToMeters(value, unit, {
-                        maxMeters: wallHeightMeters,
-                        minMeters: 0,
-                    }),
-                }), precision: 2, step: 0.01, unit: unitLabel, value: metersToLinearUnit(lowerHeight, unit) })), bandCount >= 3 && (_jsx(SliderControl, { label: "Middle", max: metersToLinearUnit(Math.max(0, wallHeightMeters - lowerHeight), unit), min: metersToLinearUnit(0, unit), onChange: (value) => updateBands({
-                    middleHeight: linearControlValueToMeters(value, unit, {
-                        maxMeters: Math.max(0, wallHeightMeters - lowerHeight),
-                        minMeters: 0,
-                    }),
-                }), precision: 2, step: 0.01, unit: unitLabel, value: metersToLinearUnit(middleHeight, unit) })), bandCount >= 4 && (_jsx(SliderControl, { label: "Upper", max: metersToLinearUnit(Math.max(0, wallHeightMeters - lowerHeight - middleHeight), unit), min: metersToLinearUnit(0, unit), onChange: (value) => updateBands({
-                    upperHeight: linearControlValueToMeters(value, unit, {
-                        maxMeters: Math.max(0, wallHeightMeters - lowerHeight - middleHeight),
-                        minMeters: 0,
-                    }),
-                }), precision: 2, step: 0.01, unit: unitLabel, value: metersToLinearUnit(upperHeight, unit) }))] }));
+                        }), precision: 2, step: 0.1, unit: unitLabel, value: Math.round(displayCurveOffset * 100) / 100 }))] }), node.wallType === 'curtain' ? (_jsx(CurtainWallPanel, { height: height, node: node, onUpdate: handleUpdate, onPreview: handlePreview, onCommit: handleCommit, onCancel: handleCancel, unit: unit }, node.id)) : (_jsxs(_Fragment, { children: [_jsx(WallAssemblySection, { node: node, onUpdate: handleUpdate, unit: unit }), _jsx(WallPaintRegionList, { wallId: node.id }), _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 WallTrimSection({ node, onUpdate, title, trimKey, trimValue, unit, unitLabel, wallHeightMeters, }) {
     const updateTrim = (patch) => onUpdate({
@@ -234,10 +205,14 @@ function WallTrimSection({ node, onUpdate, title, trimKey, trimValue, unit, unit
         ? trimValue.profile
         : profileOptions[0].value;
     return (_jsxs(PanelSection, { title: title, children: [_jsx(ActionGroup, { children: _jsx(ActionButton, { label: trimValue.enabled ? `Hide ${title.toLowerCase()}` : `Show ${title.toLowerCase()}`, onClick: () => updateTrim({ enabled: !trimValue.enabled }) }) }), trimValue.enabled && (_jsxs(_Fragment, { children: [_jsx(SegmentedControl, { onChange: (next) => updateTrim({ sides: next }), options: [
-                            { label: 'Interior', value: 'interior' },
-                            { label: 'Exterior', value: 'exterior' },
+                            { label: 'Side A', value: 'a' },
+                            { label: 'Side B', value: 'b' },
                             { label: 'Both', value: 'both' },
-                        ], value: trimValue.sides }), _jsx(SegmentedControl, { onChange: (next) => updateTrim({ profile: next }), options: profileOptions, value: selectedProfile }), _jsx(SliderControl, { label: "Height", max: metersToLinearUnit(Math.max(0.05, wallHeightMeters), unit), min: metersToLinearUnit(0.01, unit), onChange: (value) => updateTrim({
+                        ], value: trimValue.sides === 'interior'
+                            ? 'a'
+                            : trimValue.sides === 'exterior'
+                                ? 'b'
+                                : trimValue.sides }), _jsx(SegmentedControl, { onChange: (next) => updateTrim({ profile: next }), options: profileOptions, value: selectedProfile }), _jsx(SliderControl, { label: "Height", max: metersToLinearUnit(Math.max(0.05, wallHeightMeters), unit), min: metersToLinearUnit(0.01, unit), onChange: (value) => updateTrim({
                             height: linearControlValueToMeters(value, unit, {
                                 maxMeters: Math.max(0.05, wallHeightMeters),
                                 minMeters: 0.01,
@@ -254,3 +229,204 @@ function WallTrimSection({ node, onUpdate, title, trimKey, trimValue, unit, unit
                             }),
                         }), precision: 2, step: 0.01, unit: unitLabel, value: metersToLinearUnit(trimValue.offsetY ?? 0, unit) }))] }))] }));
 }
+// ---------------------------------------------------------------------------
+// Assembly
+// ---------------------------------------------------------------------------
+//
+// The assembly is the SINGLE SOURCE OF TRUTH for `wall.thickness` — every edit
+// here goes through `wallAssemblyPatch`, which writes the layer stack AND the
+// re-derived total in one `updateNode` call, so the 2D plan and the 3D wall
+// both move on the same store tick.
+const METRES_PER_INCH = 0.0254;
+/**
+ * Imperial-friendly thickness input. Accepts `5/8`, `5/8"`, `7/16 in`,
+ * `1-1/4"`, `1 1/2"`, `12mm`, `0.012m`. A bare number means INCHES in imperial
+ * display and MILLIMETRES in metric — wall layers are millimetre-scale and
+ * typing `0.0127` for half-inch board is nobody's idea of usable.
+ */
+function parseLayerThickness(raw, unit) {
+    const text = raw.trim().toLowerCase().replace(/["”]/g, ' in ');
+    if (!text)
+        return null;
+    const explicit = /(mm|cm|m|in|ft|')\s*$/.exec(text);
+    const suffix = explicit?.[1];
+    const body = (suffix ? text.slice(0, explicit?.index) : text).trim();
+    // `1-1/4` / `1 1/2` / `5/8` / `0.4375`
+    const mixed = /^(\d+(?:\.\d+)?)[\s-]+(\d+)\s*\/\s*(\d+)$/.exec(body);
+    const fraction = /^(\d+)\s*\/\s*(\d+)$/.exec(body);
+    let value;
+    if (mixed) {
+        value = Number(mixed[1]) + Number(mixed[2]) / Number(mixed[3]);
+    }
+    else if (fraction) {
+        value = Number(fraction[1]) / Number(fraction[2]);
+    }
+    else {
+        value = Number(body);
+    }
+    if (!Number.isFinite(value) || value < 0)
+        return null;
+    switch (suffix) {
+        case 'mm':
+            return value / 1000;
+        case 'cm':
+            return value / 100;
+        case 'm':
+            return value;
+        case 'in':
+            return value * METRES_PER_INCH;
+        case 'ft':
+        case "'":
+            return value * 12 * METRES_PER_INCH;
+        default:
+            return unit === 'imperial' ? value * METRES_PER_INCH : value / 1000;
+    }
+}
+/** Nearest common fraction of an inch, so 0.0111 m reads back as `7/16"`. */
+function formatLayerThickness(metres, unit) {
+    if (unit !== 'imperial')
+        return `${Math.round(metres * 1000 * 10) / 10} mm`;
+    const inchValue = metres / METRES_PER_INCH;
+    const sixteenths = Math.round(inchValue * 16);
+    if (Math.abs(inchValue * 16 - sixteenths) > 1e-6)
+        return `${Math.round(inchValue * 1000) / 1000}"`;
+    const whole = Math.floor(sixteenths / 16);
+    let numerator = sixteenths % 16;
+    let denominator = 16;
+    while (numerator % 2 === 0 && numerator > 0) {
+        numerator /= 2;
+        denominator /= 2;
+    }
+    if (numerator === 0)
+        return `${whole}"`;
+    return whole > 0 ? `${whole}-${numerator}/${denominator}"` : `${numerator}/${denominator}"`;
+}
+const SELECT_CLASS = 'h-7 w-full rounded border border-border bg-background px-2 text-[11px] text-foreground outline-none focus:border-primary';
+const INPUT_CLASS = 'h-7 w-full rounded border border-border bg-background px-2 text-[11px] text-foreground outline-none focus:border-primary';
+const ROW_LABEL_CLASS = 'w-[68px] shrink-0 text-[10px] text-muted-foreground uppercase tracking-wide';
+function LayerRow({ label, children }) {
+    return (_jsxs("div", { className: "flex items-center gap-2 px-1 py-0.5", children: [_jsx("span", { className: ROW_LABEL_CLASS, children: label }), _jsx("div", { className: "flex flex-1 items-center gap-1.5", children: children })] }));
+}
+function ThicknessInput({ metres, onCommit, unit, }) {
+    const [draft, setDraft] = useState(null);
+    const display = draft ?? formatLayerThickness(metres, unit);
+    return (_jsx("input", { className: INPUT_CLASS, onBlur: () => {
+            if (draft != null) {
+                const parsed = parseLayerThickness(draft, unit);
+                if (parsed != null)
+                    onCommit(parsed);
+            }
+            setDraft(null);
+        }, onChange: (event) => setDraft(event.target.value), onKeyDown: (event) => {
+            if (event.key === 'Enter')
+                event.currentTarget.blur();
+            if (event.key === 'Escape') {
+                setDraft(null);
+                event.currentTarget.blur();
+            }
+        }, spellCheck: false, value: display }));
+}
+const EXTERIOR_FINISH_OPTIONS = [
+    { value: 'none', label: 'None' },
+    { value: 'siding', label: 'Lap siding' },
+    { value: 'fiber-cement', label: 'Fiber cement' },
+    { value: 'stucco', label: 'Stucco' },
+    { value: 'brick', label: 'Brick veneer' },
+    { value: 'stone', label: 'Stone veneer' },
+];
+const SHEATHING_OPTIONS = [
+    { value: 'none', label: 'None' },
+    { value: 'osb', label: 'OSB' },
+    { value: 'plywood', label: 'Plywood' },
+    { value: 'gypsum', label: 'Gypsum' },
+];
+const FRAMING_OPTIONS = [
+    { value: 'wood', label: 'Wood studs' },
+    { value: 'lgs', label: 'Steel studs' },
+    { value: 'cmu', label: 'CMU' },
+    { value: 'icf', label: 'ICF' },
+];
+const INTERIOR_FINISH_OPTIONS = [
+    { value: 'none', label: 'None' },
+    { value: 'drywall', label: 'Drywall' },
+    { value: 'plaster', label: 'Plaster' },
+];
+/** Cited default thickness for a finish the user just switched to. */
+const EXTERIOR_FINISH_DEFAULT = {
+    none: 0,
+    siding: SIDING_LAP,
+    'fiber-cement': FIBER_CEMENT,
+    stucco: STUCCO_3_COAT,
+    brick: BRICK_VENEER + BRICK_AIR_SPACE,
+    stone: STONE_VENEER_UNVERIFIED,
+};
+function WallAssemblySection({ node, onUpdate, unit, }) {
+    const stack = node.assembly;
+    // The cladding / sheathing / framing / interior editor works on the WS5 view
+    // of the F2 stack; a stack it cannot express is listed read-only.
+    const assembly = stack ? (wallAssemblyToLegacy(stack) ?? undefined) : undefined;
+    const resolved = resolveWallAssembly(node);
+    const presetNote = wallAssemblyUnverifiedNote(node);
+    // Every write goes through wallAssemblyPatch so `thickness` is re-derived.
+    // Changing any layer clears `preset` — the stack is no longer that preset.
+    const apply = (next) => onUpdate(wallAssemblyPatch(wallAssemblyFromLegacy(next)));
+    const edit = (mutate) => {
+        if (!assembly)
+            return;
+        const next = mutate({ ...assembly });
+        apply({ ...next, preset: undefined });
+    };
+    return (_jsxs(PanelSection, { title: "Assembly", children: [_jsx(LayerRow, { label: "Preset", children: _jsxs("select", { className: SELECT_CLASS, onChange: (event) => {
+                        const id = event.target.value;
+                        if (!id) {
+                            onUpdate({ assembly: undefined });
+                            return;
+                        }
+                        const preset = getWallAssemblyPreset(id);
+                        if (preset)
+                            onUpdate(wallAssemblyPatch(preset.assembly));
+                    }, value: stack?.presetId ?? '', children: [_jsx("option", { value: "", children: stack ? 'Custom' : 'None (single layer)' }), WALL_ASSEMBLY_PRESETS.map((preset) => (_jsx("option", { value: preset.id, children: preset.label }, preset.id)))] }) }), assembly && (_jsxs(_Fragment, { children: [_jsxs(LayerRow, { label: "Exterior", children: [_jsx("select", { className: SELECT_CLASS, onChange: (event) => {
+                                    const finish = event.target.value;
+                                    edit((draft) => ({
+                                        ...draft,
+                                        exterior: { finish, thickness: EXTERIOR_FINISH_DEFAULT[finish] },
+                                    }));
+                                }, value: assembly.exterior?.finish ?? 'none', children: EXTERIOR_FINISH_OPTIONS.map((option) => (_jsx("option", { value: option.value, children: option.label }, option.value))) }), assembly.exterior && assembly.exterior.finish !== 'none' && (_jsx(ThicknessInput, { metres: assembly.exterior.thickness, onCommit: (thickness) => edit((draft) => ({
+                                    ...draft,
+                                    exterior: { finish: draft.exterior?.finish ?? 'siding', thickness },
+                                })), unit: unit }))] }), _jsxs(LayerRow, { label: "Sheathing", children: [_jsx("select", { className: SELECT_CLASS, onChange: (event) => {
+                                    const material = event.target.value;
+                                    edit((draft) => ({
+                                        ...draft,
+                                        sheathing: {
+                                            material,
+                                            thickness: material === 'none'
+                                                ? 0
+                                                : material === 'gypsum'
+                                                    ? GYPSUM_SHEATHING
+                                                    : WSP_SHEATHING,
+                                        },
+                                    }));
+                                }, value: assembly.sheathing?.material ?? 'none', children: SHEATHING_OPTIONS.map((option) => (_jsx("option", { value: option.value, children: option.label }, option.value))) }), assembly.sheathing && assembly.sheathing.material !== 'none' && (_jsx(ThicknessInput, { metres: assembly.sheathing.thickness, onCommit: (thickness) => edit((draft) => ({
+                                    ...draft,
+                                    sheathing: { material: draft.sheathing?.material ?? 'osb', thickness },
+                                })), unit: unit }))] }), _jsxs(LayerRow, { label: "Framing", children: [_jsx("select", { className: SELECT_CLASS, onChange: (event) => edit((draft) => ({
+                                    ...draft,
+                                    framing: {
+                                        kind: event.target.value,
+                                        depth: draft.framing.depth,
+                                    },
+                                })), value: assembly.framing.kind, children: FRAMING_OPTIONS.map((option) => (_jsx("option", { value: option.value, children: option.label }, option.value))) }), _jsx(ThicknessInput, { metres: assembly.framing.depth, onCommit: (depth) => edit((draft) => ({ ...draft, framing: { kind: draft.framing.kind, depth } })), unit: unit })] }), _jsxs(LayerRow, { label: "Interior", children: [_jsx("select", { className: SELECT_CLASS, onChange: (event) => {
+                                    const finish = event.target.value;
+                                    edit((draft) => ({
+                                        ...draft,
+                                        interior: {
+                                            finish,
+                                            thickness: finish === 'none' ? 0 : (draft.interior?.thickness ?? GYPSUM_HALF),
+                                        },
+                                    }));
+                                }, value: assembly.interior?.finish ?? 'none', children: INTERIOR_FINISH_OPTIONS.map((option) => (_jsx("option", { value: option.value, children: option.label }, option.value))) }), assembly.interior && assembly.interior.finish !== 'none' && (_jsx(ThicknessInput, { metres: assembly.interior.thickness, onCommit: (thickness) => edit((draft) => ({
+                                    ...draft,
+                                    interior: { finish: draft.interior?.finish ?? 'drywall', thickness },
+                                })), unit: unit }))] }), _jsxs("div", { className: "flex items-center justify-between px-2 py-1.5", children: [_jsx("span", { className: "font-medium text-[10px] text-muted-foreground uppercase tracking-wide", children: "Total thickness" }), _jsx("span", { className: "font-medium text-[11px] text-foreground tabular-nums", children: formatLayerThickness(assemblyThickness(stack), unit) })] }), resolved.kind === 'partition' && (_jsx("div", { className: "px-2 pb-1.5 text-[10px] text-muted-foreground", children: "Partition: the interior finish is applied to both faces." })), resolved.kind === 'envelope' && resolved.exteriorSide == null && (_jsx("div", { className: "px-2 pb-1.5 text-[10px] text-muted-foreground", children: "Which face is outside is undetermined (no room detected on either side) \u2014 the exterior layers are drawn on side B." })), presetNote && (_jsxs("div", { className: "px-2 pb-2 text-[10px] text-amber-600 dark:text-amber-400", children: ["Unverified: ", presetNote] })), _jsx("div", { className: "px-2 pb-2 text-[10px] text-muted-foreground", children: "Layer thicknesses follow the 2021 IRC assembly data. Drafting aid, not engineering \u2014 verify with the authority having jurisdiction." })] })), stack && !assembly && (_jsxs(_Fragment, { children: [resolved.layers.map((layer, index) => (_jsx(LayerRow, { label: layer.material, children: _jsx("span", { className: "text-[11px] text-muted-foreground tabular-nums", children: formatLayerThickness(layer.thickness, unit) }) }, `${layer.role}-${index}`))), _jsxs("div", { className: "flex items-center justify-between px-2 py-1.5", children: [_jsx("span", { className: "font-medium text-[10px] text-muted-foreground uppercase tracking-wide", children: "Total thickness" }), _jsx("span", { className: "font-medium text-[11px] text-foreground tabular-nums", children: formatLayerThickness(assemblyThickness(stack), unit) })] })] }))] }));
+}

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,CAmB1D,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,CAsB1D,CAAA"}

package/dist/wall/parametrics.js

@@ -15,6 +15,9 @@ export const wallParametrics = {
         {
             label: 'Dimensions',
             fields: [
+                // Reference is not a raw field: its labels depend on each wall's rooms
+                // (`wallReferenceModel` in panel-model), so generic inspectors never
+                // show the stored a / b value.
                 { key: 'thickness', kind: 'number', unit: 'm', min: 0.05, max: 1000, 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.

package/dist/wall/rectangle-command.d.ts

@@ -9,8 +9,8 @@ export declare function createWallRectangle(levelId: AnyNodeId, start: WallPlanP
     children: (`item_${string}` | `procedural-item_${string}` | `leanto_${string}` | `door_${string}` | `window_${string}`)[];
     start: [number, number];
     end: [number, number];
-    frontSide: "unknown" | "interior" | "exterior";
-    backSide: "unknown" | "interior" | "exterior";
+    frontSide: "unknown" | "exterior" | "interior";
+    backSide: "unknown" | "exterior" | "interior";
     name?: string | undefined;
     camera?: {
         position: [number, number, number];
@@ -19,6 +19,17 @@ export declare function createWallRectangle(levelId: AnyNodeId, start: WallPlanP
         fov?: number | undefined;
         zoom?: number | undefined;
     } | undefined;
+    provenance?: {
+        refs: {
+            id: string;
+            ns?: string | undefined;
+            role?: "primary" | "piece" | "absorbed" | "alias" | "derived" | undefined;
+        }[];
+        lineage?: {
+            op: "import" | "split" | "merge" | "duplicate" | "convert" | "promote" | "make-independent" | "attach";
+            fromIds: string[];
+        } | undefined;
+    } | undefined;
     wallType?: "standard" | "curtain" | undefined;
     curtainWall?: {
         construction: "stick" | "unitized";
@@ -41,7 +52,7 @@ export declare function createWallRectangle(levelId: AnyNodeId, start: WallPlanP
         jointWidth: number;
         glassThickness: number;
         panelType: "glass" | "solid" | "empty";
-        spandrel: "top" | "none" | "bottom";
+        spandrel: "bottom" | "top" | "none";
         frameColor: string;
         glassColor: string;
         solidColor: string;
@@ -108,22 +119,110 @@ export declare function createWallRectangle(levelId: AnyNodeId, start: WallPlanP
     } | undefined;
     exteriorMaterialPreset?: string | undefined;
     slots?: Record<string, string> | undefined;
+    legacyFaceMaterials?: {
+        a?: {
+            material?: {
+                id?: string | undefined;
+                preset?: "custom" | "white" | "brick" | "concrete" | "wood" | "glass" | "metal" | "plaster" | "tile" | "marble" | undefined;
+                properties?: {
+                    color: string;
+                    roughness: number;
+                    metalness: number;
+                    opacity: number;
+                    transparent: boolean;
+                    side: "front" | "back" | "double";
+                } | undefined;
+                texture?: {
+                    url: string;
+                    repeat?: [number, number] | undefined;
+                    scale?: number | undefined;
+                } | undefined;
+            } | undefined;
+            materialPreset?: string | undefined;
+        } | undefined;
+        b?: {
+            material?: {
+                id?: string | undefined;
+                preset?: "custom" | "white" | "brick" | "concrete" | "wood" | "glass" | "metal" | "plaster" | "tile" | "marble" | undefined;
+                properties?: {
+                    color: string;
+                    roughness: number;
+                    metalness: number;
+                    opacity: number;
+                    transparent: boolean;
+                    side: "front" | "back" | "double";
+                } | undefined;
+                texture?: {
+                    url: string;
+                    repeat?: [number, number] | undefined;
+                    scale?: number | undefined;
+                } | undefined;
+            } | undefined;
+            materialPreset?: string | undefined;
+        } | undefined;
+    } | undefined;
+    faceRegions?: {
+        id: string;
+        face: "a" | "b";
+        finish: string;
+        u0?: number | undefined;
+        u1?: number | undefined;
+        v0?: number | undefined;
+        v1?: number | undefined;
+    }[] | undefined;
     thickness?: number | undefined;
+    assembly?: {
+        layers: {
+            id: string;
+            role: "fill" | "shell" | "finish" | "lining" | "substrate" | "sheathing" | "membrane" | "underlay" | "insulation" | "air" | "furring" | "structure" | "deck" | "covering" | "glazing";
+            thickness: number;
+            core?: true | undefined;
+            material?: string | undefined;
+            slot?: string | undefined;
+            returns?: boolean | undefined;
+            display?: "construction" | "finished" | undefined;
+            inset?: number | undefined;
+            bottom?: number | undefined;
+            lift?: number | undefined;
+            src?: string | undefined;
+        }[];
+        backing?: {
+            id: string;
+            role: "fill" | "shell" | "finish" | "lining" | "substrate" | "sheathing" | "membrane" | "underlay" | "insulation" | "air" | "furring" | "structure" | "deck" | "covering" | "glazing";
+            thickness: number;
+            core?: true | undefined;
+            material?: string | undefined;
+            slot?: string | undefined;
+            returns?: boolean | undefined;
+            display?: "construction" | "finished" | undefined;
+            inset?: number | undefined;
+            bottom?: number | undefined;
+            lift?: number | undefined;
+            src?: string | undefined;
+        }[] | undefined;
+        face?: "front" | "exterior" | undefined;
+        presetId?: string | undefined;
+        cavityInsulation?: string | undefined;
+    } | undefined;
+    justification?: "a" | "b" | undefined;
     height?: number | undefined;
     curveOffset?: number | undefined;
     supportSlabId?: string | undefined;
     supportOffset?: number | undefined;
     fillToTerrain?: boolean | undefined;
-    faceBands?: {
-        enabled: boolean;
-        count: number;
-        lowerHeight: number;
-        middleHeight: number;
-        upperHeight: number;
+    underpinning?: {
+        rim: number;
+        stem: number;
+        openings?: {
+            u: number;
+            width: number;
+            top: number;
+            bottom: number;
+        }[] | undefined;
     } | undefined;
     skirting?: {
         enabled: boolean;
-        sides: "interior" | "exterior" | "both";
+        sides: "a" | "b" | "exterior" | "interior" | "both";
         height: number;
         proud: number;
         profile: "flat" | "bevel" | "triangle" | "cove" | "bullnose" | "base-modern" | "base-colonial" | "base-shoe" | "base-ogee" | "crown-cove" | "crown-ogee" | "crown-craftsman" | "crown-layered" | "rail-rounded" | "rail-ogee" | "rail-picture" | "rail-stepped";
@@ -131,7 +230,7 @@ export declare function createWallRectangle(levelId: AnyNodeId, start: WallPlanP
     } | undefined;
     crown?: {
         enabled: boolean;
-        sides: "interior" | "exterior" | "both";
+        sides: "a" | "b" | "exterior" | "interior" | "both";
         height: number;
         proud: number;
         profile: "flat" | "bevel" | "triangle" | "cove" | "bullnose" | "base-modern" | "base-colonial" | "base-shoe" | "base-ogee" | "crown-cove" | "crown-ogee" | "crown-craftsman" | "crown-layered" | "rail-rounded" | "rail-ogee" | "rail-picture" | "rail-stepped";
@@ -139,7 +238,7 @@ export declare function createWallRectangle(levelId: AnyNodeId, start: WallPlanP
     } | undefined;
     chairRail?: {
         enabled: boolean;
-        sides: "interior" | "exterior" | "both";
+        sides: "a" | "b" | "exterior" | "interior" | "both";
         height: number;
         proud: number;
         profile: "flat" | "bevel" | "triangle" | "cove" | "bullnose" | "base-modern" | "base-colonial" | "base-shoe" | "base-ogee" | "crown-cove" | "crown-ogee" | "crown-craftsman" | "crown-layered" | "rail-rounded" | "rail-ogee" | "rail-picture" | "rail-stepped";

package/dist/wall/rectangle-command.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"rectangle-command.d.ts","sourceRoot":"","sources":["../../src/wall/rectangle-command.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EAKd,KAAK,uBAAuB,EAC5B,KAAK,QAAQ,EACb,KAAK,aAAa,EACnB,MAAM,kBAAkB,CAAA;AAEzB,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,SAAS,EAClB,KAAK,EAAE,aAAa,EACpB,GAAG,EAAE,aAAa,EAClB,QAAQ,GAAE,OAAO,CAAC,QAAQ,CAAM,EAChC,OAAO,CAAC,EAAE,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAmBlC"}
+{"version":3,"file":"rectangle-command.d.ts","sourceRoot":"","sources":["../../src/wall/rectangle-command.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EAKd,KAAK,uBAAuB,EAC5B,KAAK,QAAQ,EACb,KAAK,aAAa,EACnB,MAAM,kBAAkB,CAAA;AAEzB,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,SAAS,EAClB,KAAK,EAAE,aAAa,EACpB,GAAG,EAAE,aAAa,EAClB,QAAQ,GAAE,OAAO,CAAC,QAAQ,CAAM,EAChC,OAAO,CAAC,EAAE,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAmBlC"}

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

@@ -1 +1 @@
-{"version":3,"file":"rectangle-tool.d.ts","sourceRoot":"","sources":["../../src/wall/rectangle-tool.tsx"],"names":[],"mappings":"AAmCA,MAAM,CAAC,OAAO,UAAU,iBAAiB,gCAkMxC"}
+{"version":3,"file":"rectangle-tool.d.ts","sourceRoot":"","sources":["../../src/wall/rectangle-tool.tsx"],"names":[],"mappings":"AAoCA,MAAM,CAAC,OAAO,UAAU,iBAAiB,gCAoNxC"}

package/dist/wall/rectangle-tool.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { emitter, useScene, wallRectangleCorners, } from '@pascal-app/core';
-import { CursorSphere, clearPlacementSurface, DRAFT_LABEL_Y_OFFSET, DraftMeasurementLabel, EDITOR_LAYER, formatLinearMeasurement, isMagneticSnapActive, markToolCancelConsumed, NO_RAYCAST, publishHorizontalConstructionPlane, resolveEventConstructionPlane, snapWallDraftPointDetailed, triggerSFX, useEditor, useInteractionScope, useLinearDisplay, useRegistryToolContext, useWallSnapIndicator, } from '@pascal-app/editor';
+import { CursorSphere, clearPlacementSurface, DRAFT_LABEL_Y_OFFSET, DraftMeasurementLabel, EDITOR_LAYER, formatLinearMeasurement, isMagneticSnapActive, markToolCancelConsumed, NO_RAYCAST, publishHorizontalConstructionPlane, resolveEventConstructionPlane, snapWallDraftPointDetailed, triggerSFX, useEditor, useFloorplanDraftPreview, useInteractionScope, useLinearDisplay, useRegistryToolContext, useWallSnapIndicator, } from '@pascal-app/editor';
 import { getSceneTheme, useViewer } from '@pascal-app/viewer';
 import { useThree } from '@react-three/fiber';
 import { useEffect, useState } from 'react';
@@ -27,7 +27,7 @@ export default function RectangleWallTool() {
         setDraft(null);
         setMessage('');
         let start = null;
-        let end = null;
+        let corner = null;
         let plane = null;
         useInteractionScope.getState().begin({ kind: 'drafting', tool: 'wall' });
         const pointFor = (e) => {
@@ -57,21 +57,26 @@ export default function RectangleWallTool() {
             setMessage('');
             if (!start)
                 return;
-            // The line draft's tick: once per snapped corner position.
-            if (end && (end[0] !== point[0] || end[1] !== point[1]))
+            // The wall draft's tick as the dragged corner steps to a new snapped spot.
+            if (corner && (corner[0] !== point[0] || corner[1] !== point[1]))
                 triggerSFX('sfx:grid-snap');
-            end = point;
+            corner = point;
             setDraft({ start, end: point, y: hoverPlane.localY });
         };
         const leave = () => {
             setCursor(null);
             useWallSnapIndicator.getState().clear();
         };
+        // The first corner is mirrored out of tree, like the wall chain's origin,
+        // for consumers outside the tool (the plan view, onboarding hints).
+        const publishStart = (point) => useFloorplanDraftPreview.getState().setWallRectangleDraftStart(point);
         const cancel = () => {
-            if (start)
+            if (start) {
                 markToolCancelConsumed();
+                publishStart(null);
+            }
             start = null;
-            end = null;
+            corner = null;
             plane = null;
             setDraft(null);
             setMessage('');
@@ -84,10 +89,11 @@ export default function RectangleWallTool() {
             const point = pointFor(e);
             if (!start) {
                 start = point;
-                end = point;
+                publishStart(point);
                 plane = resolveEventConstructionPlane(e, null);
                 publishHorizontalConstructionPlane(e, plane);
                 setCursor([point[0], plane.localY, point[1]]);
+                corner = point;
                 setDraft({ start, end: point, y: plane.localY });
                 setMessage('');
                 triggerSFX('sfx:structure-build-start');
@@ -106,15 +112,27 @@ export default function RectangleWallTool() {
                 setMessage(error.message);
             }
         };
+        // The plan view finishing or dropping the same rectangle (split view) ends it here too.
+        const stopMirror = useFloorplanDraftPreview.subscribe((state, previous) => {
+            if (!start || !previous.wallRectangleDraftStart || state.wallRectangleDraftStart)
+                return;
+            start = null;
+            corner = null;
+            plane = null;
+            setDraft(null);
+        });
         emitter.on('grid:move', move);
         emitter.on('grid:click', click);
         emitter.on('tool:cancel', cancel);
         canvas.addEventListener('pointerleave', leave);
         return () => {
+            stopMirror();
             emitter.off('grid:move', move);
             emitter.off('grid:click', click);
             emitter.off('tool:cancel', cancel);
             canvas.removeEventListener('pointerleave', leave);
+            if (start)
+                publishStart(null);
             useWallSnapIndicator.getState().clear();
             clearPlacementSurface();
             useInteractionScope.getState().endIf((s) => s.kind === 'drafting' && s.tool === '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,EAOL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAuCzB;;;;;;;;;;;;;;;;;;GAkBG;AACH,QAAA,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCAyJjD,CAAA;AAED,eAAe,YAAY,CAAA"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/wall/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAOL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAwCzB;;;;;;;;;;;;;;;;;;GAkBG;AACH,QAAA,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCA4JjD,CAAA;AAED,eAAe,YAAY,CAAA"}

package/dist/wall/renderer.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { hiddenWallPointerEventsHeld, useLiveNodeOverrides, useRegistry, useScene, } from '@pascal-app/core';
-import { NodeRenderer, SHADOW_ONLY_LAYER, useLibraryMaterialsVersion, useNodeEvents, useViewer, } from '@pascal-app/viewer';
+import { getWallFinishRefs, NodeRenderer, SHADOW_ONLY_LAYER, useLibraryMaterialsVersion, 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';
@@ -113,7 +113,9 @@ const WallRenderer = ({ node }) => {
     // register after mount, and a dangling ref cached as the slot default must
     // re-resolve when they land.
     const libraryMaterialsVersion = useLibraryMaterialsVersion();
-    const baseMaterials = getCurtainAwareWallMaterials(treatmentNode, shading, textures, colorPreset, sceneTheme, sceneMaterials).visible;
+    // Built geometry's groups index its finish palette; WallCutout swaps the
+    // array whenever a rebuild changes that palette.
+    const baseMaterials = getCurtainAwareWallMaterials(treatmentNode, shading, textures, colorPreset, sceneTheme, sceneMaterials, getWallFinishRefs(ref.current?.geometry)).visible;
     // biome-ignore lint/correctness/useExhaustiveDependencies: libraryMaterialsVersion invalidates the ref resolution inside createWallExtraSlotMaterials
     const extraMaterials = useMemo(() => createWallExtraSlotMaterials(node, shading, sceneMaterials), [node, sceneMaterials, shading, libraryMaterialsVersion]);
     useEffect(() => () => {