@pascal-app/nodes 1.0.1 → 1.0.4

package/dist/wall/panel-model.js

@@ -0,0 +1,175 @@
+import { faceOnLine, GROUND_SUPPORT_ID, getClampedWallCurveOffset, getMaxWallCurveOffset, getWallCurveLength, justificationForFaceOnLine, normalizeWallCurveOffset, planWallJustification, roomSideFaces, terrainSupportLift, useScene, WALL_CHAIR_RAIL_DEFAULT, WALL_CROWN_DEFAULT, WALL_SKIRTING_DEFAULT, } from '@pascal-app/core';
+import { curveReshapeScope, triggerSFX, useInteractionScope, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling';
+import { hasWallCurveBlockingChildren } from './curve-eligibility';
+import { buildWallLengthPatch } from './length-patch';
+const profiles = {
+    skirting: ['flat', 'base-modern', 'base-colonial', 'base-shoe', 'base-ogee'],
+    crown: ['flat', 'crown-cove', 'crown-ogee', 'crown-craftsman', 'crown-layered'],
+    chairRail: ['flat', 'rail-rounded', 'rail-ogee', 'rail-picture', 'rail-stepped'],
+};
+const pretty = (value) => value
+    .replace(/^(base|crown|rail)-/, '')
+    .replace(/(^|[- ])\w/g, (s) => s.replace('-', ' ').toUpperCase());
+const ROOM_REFERENCE_OPTIONS = [
+    { label: 'Outside face', value: 'outside' },
+    { label: 'Center', value: 'center' },
+    { label: 'Inside face', value: 'inside' },
+];
+const DIRECTION_REFERENCE_OPTIONS = [
+    { label: 'Left', value: 'left' },
+    { label: 'Center', value: 'center' },
+    { label: 'Right', value: 'right' },
+];
+/** Faces a wall's reference choices name: its room sides when a room is on exactly one side. */
+function referenceFaces(wall, nodes) {
+    const sides = roomSideFaces(nodes, wall.id);
+    return sides.inside && sides.outside
+        ? { kind: 'room', outside: sides.outside, inside: sides.inside }
+        : { kind: 'direction' };
+}
+/**
+ * The Reference control for one or more walls. The drawn line never moves; the
+ * choice picks which face sits on it. Walls with a room on exactly one side read
+ * Outside face / Center / Inside face; otherwise Left / Center / Right along the
+ * drawing direction (left is face a). A selection shows the room labels only
+ * when every wall has them, applies each choice to each wall's own faces, and
+ * shows no active option when the walls disagree.
+ */
+export function wallReferenceModel(walls, nodes) {
+    const faces = walls.map((wall) => referenceFaces(wall, nodes));
+    const room = faces.length > 0 && faces.every((entry) => entry.kind === 'room');
+    const options = room ? ROOM_REFERENCE_OPTIONS : DIRECTION_REFERENCE_OPTIONS;
+    const faceFor = (index, value) => {
+        if (value === 'center')
+            return 'center';
+        if (value === 'left')
+            return 'a';
+        if (value === 'right')
+            return 'b';
+        const entry = faces[index];
+        return entry.kind === 'room' ? entry[value] : 'center';
+    };
+    const current = walls.map((wall, index) => {
+        const face = faceOnLine(wall);
+        if (face === 'center')
+            return 'center';
+        const entry = faces[index];
+        if (room && entry.kind === 'room')
+            return face === entry.outside ? 'outside' : 'inside';
+        return face === 'a' ? 'left' : 'right';
+    });
+    const value = current.every((entry) => entry === current[0]) ? (current[0] ?? null) : null;
+    return {
+        options,
+        value,
+        apply: (next) => {
+            const scene = useScene.getState();
+            const updates = walls.flatMap((wall, index) => planWallJustification(scene.nodes, wall.id, justificationForFaceOnLine(faceFor(index, next))));
+            if (updates.length > 0)
+                scene.updateNodes(updates);
+        },
+    };
+}
+export function wallSettings(node, nodes, update, reshape = () => {
+    triggerSFX('sfx:item-pick');
+    useInteractionScope.getState().begin(curveReshapeScope(node.id));
+    useViewer.getState().setSelection({ selectedIds: [] });
+}) {
+    const rows = [];
+    const height = resolveWallOpeningCeiling(node, nodes);
+    const repairBase = () => ({
+        supportOffset: undefined,
+        ...(node.supportSlabId === GROUND_SUPPORT_ID &&
+            !(node.parentId && terrainSupportLift(nodes, node.parentId, ...node.start) != null)
+            ? { supportSlabId: undefined }
+            : {}),
+    });
+    const number = (section, id, label, value, min, max, step, onChange, unit = 'm') => rows.push({
+        section,
+        id,
+        kind: 'stepper',
+        label,
+        value,
+        min,
+        max,
+        step,
+        unit,
+        onChange: (next) => onChange(Math.max(min, Math.min(max, next))),
+    });
+    const choice = (section, id, label, value, onSelect) => rows.push({ section, id, kind: 'choice', label, value, onSelect });
+    const cycle = (section, id, label, value, values, onChange) => {
+        const change = (direction) => onChange(values[(Math.max(0, values.indexOf(value)) + direction + values.length) % values.length]);
+        rows.push({
+            section,
+            id,
+            kind: 'cycle',
+            label,
+            value: pretty(value),
+            next: () => change(1),
+            previous: () => change(-1),
+        });
+    };
+    const reference = wallReferenceModel([node], nodes);
+    const step = (by) => {
+        const index = reference.options.findIndex((option) => option.value === reference.value);
+        reference.apply(reference.options[(index + by + 3) % 3].value);
+    };
+    rows.push({
+        section: 'Dimensions',
+        id: 'wall-reference',
+        kind: 'cycle',
+        label: 'Reference',
+        value: reference.options.find((option) => option.value === reference.value)?.label ?? 'Mixed',
+        next: () => step(1),
+        previous: () => step(-1),
+    });
+    const length = getWallCurveLength(node);
+    number('Dimensions', 'wall-length', 'Length', length, 0.1, 1000, 0.05, (next) => {
+        update(buildWallLengthPatch(node, next));
+    });
+    choice('Dimensions', 'wall-top', 'Top', node.height == null ? 'Follows level' : 'Custom height', () => update(node.height == null
+        ? { height: Math.max(0.1, height) }
+        : { height: undefined, ...repairBase() }));
+    if (node.height == null)
+        choice('Dimensions', 'wall-height-auto', 'Current height', `${Number(height.toFixed(3))} m`);
+    else
+        number('Dimensions', 'height', 'Height', node.height, 0.1, 1000, 0.05, (height) => update({ height }));
+    choice('Dimensions', 'wall-bottom', 'Bottom', node.fillToTerrain ? 'Fill to terrain' : 'Auto', () => update(node.fillToTerrain
+        ? { fillToTerrain: undefined, ...repairBase() }
+        : { fillToTerrain: true }));
+    number('Dimensions', 'thickness', 'Thickness', node.thickness ?? 0.1, 0.05, 1000, 0.01, (thickness) => update({ thickness }));
+    const blockedCurve = hasWallCurveBlockingChildren((node.children ?? []).flatMap((id) => nodes[id] ? [nodes[id]] : []));
+    if (!blockedCurve) {
+        const limit = Math.max(0.01, getMaxWallCurveOffset(node));
+        number('Dimensions', 'curveOffset', 'Curve', getClampedWallCurveOffset(node), -limit, limit, 0.05, (next) => update({ curveOffset: normalizeWallCurveOffset(node, next) }));
+        if (reshape)
+            rows.push({
+                section: 'Dimensions',
+                id: 'wall-reshape',
+                kind: 'action',
+                label: 'Reshape curve in scene',
+                onSelect: reshape,
+            });
+    }
+    for (const [key, title, defaults] of [
+        ['skirting', 'Skirting', WALL_SKIRTING_DEFAULT],
+        ['crown', 'Crown molding', WALL_CROWN_DEFAULT],
+        ['chairRail', 'Chair rail', WALL_CHAIR_RAIL_DEFAULT],
+    ]) {
+        const trim = { ...defaults, ...node[key] };
+        const patch = (value) => update({ [key]: { ...trim, ...value } });
+        choice(title, `${key}-enabled`, title, trim.enabled ? 'On' : 'Off', () => patch({ enabled: !trim.enabled }));
+        if (!trim.enabled)
+            continue;
+        const sides = trim.sides === 'interior' ? 'a' : trim.sides === 'exterior' ? 'b' : trim.sides;
+        cycle(title, `${key}-sides`, 'Sides', sides, ['a', 'b', 'both'], (next) => patch({ sides: next }));
+        cycle(title, `${key}-profile`, 'Profile', trim.profile, profiles[key], (profile) => patch({ profile: profile }));
+        number(title, `${key}-height`, 'Height', trim.height, 0.01, Math.max(0.05, height), 0.01, (height) => patch({ height }));
+        number(title, `${key}-proud`, 'Projection', trim.proud, 0.001, 0.2, 0.005, (proud) => patch({ proud }));
+        if (key === 'chairRail')
+            number(title, `${key}-offset`, 'Offset', trim.offsetY ?? 0, 0, Math.max(0.05, height - trim.height), 0.01, (offsetY) => patch({ offsetY }));
+    }
+    return rows;
+}

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

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/wall/panel.tsx"],"names":[],"mappings":"AA0FA,MAAM,CAAC,OAAO,UAAU,SAAS,uCA8ThC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/wall/panel.tsx"],"names":[],"mappings":"AAkHA,MAAM,CAAC,OAAO,UAAU,SAAS,uCA0XhC"}

package/dist/wall/panel.js

@@ -1,12 +1,16 @@
 '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, 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
  * ground host is dropped unless sculpted terrain actually supports it — a
@@ -82,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
@@ -90,28 +96,18 @@ export default function WallPanel() {
     // "Maximum update depth exceeded" cascade. Same fix in fence-panel.tsx.
     const nodeRef = useRef(node);
     nodeRef.current = node;
-    const handleUpdate = useCallback((updates) => {
-        if (!selectedId)
-            return;
-        useScene.getState().updateNode(selectedId, updates);
-    }, [selectedId]);
+    const propertyPreview = useMemo(() => (selectedId ? createWallPropertyPreview(selectedId) : undefined), [selectedId]);
+    useEffect(() => () => propertyPreview?.cancel(), [propertyPreview]);
+    const handleUpdate = useCallback((updates) => propertyPreview?.commit(updates), [propertyPreview]);
+    const handlePreview = useCallback((updates) => propertyPreview?.preview(updates), [propertyPreview]);
+    const handleCommit = useCallback(() => propertyPreview?.commit(), [propertyPreview]);
+    const handleCancel = useCallback(() => propertyPreview?.cancel(), [propertyPreview]);
     const handleUpdateLength = useCallback((newLength) => {
         const n = nodeRef.current;
         if (!n || newLength <= 0)
             return;
-        const dx = n.end[0] - n.start[0];
-        const dz = n.end[1] - n.start[1];
-        const currentLength = Math.sqrt(dx * dx + dz * dz);
-        if (currentLength === 0)
-            return;
-        const dirX = dx / currentLength;
-        const dirZ = dz / currentLength;
-        const newEnd = [
-            n.start[0] + dirX * newLength,
-            n.start[1] + dirZ * newLength,
-        ];
-        handleUpdate({ end: newEnd });
-    }, [handleUpdate]);
+        handlePreview(buildWallLengthPatch(n, newLength));
+    }, [handlePreview]);
     const handleTopModeChange = useCallback((mode) => {
         const n = nodeRef.current;
         if (!n)
@@ -174,57 +170,28 @@ export default function WallPanel() {
     const skirting = { ...WALL_SKIRTING_DEFAULT, ...(node.skirting ?? {}) };
     const crown = { ...WALL_CROWN_DEFAULT, ...(node.crown ?? {}) };
     const chairRail = { ...WALL_CHAIR_RAIL_DEFAULT, ...(node.chairRail ?? {}) };
-    return (_jsxs(PanelWrapper, { icon: "/icons/wall.webp", onClose: handleClose, title: node.name || 'Wall', width: 280, children: [_jsxs(PanelSection, { title: "Dimensions", children: [_jsx(SliderControl, { label: "Length", max: metersToLinearUnit(1000, unit), min: metersToLinearUnit(0.1, unit), onChange: (value) => handleUpdateLength(linearControlValueToMeters(value, unit, { maxMeters: 1000, minMeters: 0.1 })), precision: 2, step: unit === 'imperial' ? 0.1 : 0.01, unit: unitLabel, value: displayLength }), _jsx("div", { className: "px-1 font-medium text-[10px] text-muted-foreground/80 uppercase tracking-wider", children: "Top" }), _jsx(SegmentedControl, { onChange: handleTopModeChange, options: [
+    return (_jsxs(PanelWrapper, { icon: "/icons/wall.webp", onClose: handleClose, title: node.name || 'Wall', width: 280, children: [_jsx(PanelSection, { title: "Wall type", children: _jsx(SegmentedControl, { onChange: (wallType) => handleUpdate({ wallType }), options: [
+                        { label: 'Standard', value: 'standard' },
+                        { label: 'Curtain wall', value: 'curtain' },
+                    ], value: node.wallType ?? 'standard' }) }), _jsxs(PanelSection, { title: "Dimensions", children: [_jsx(SliderControl, { onCommit: handleCommit, onCancel: handleCancel, restoreOnCommit: false, previewWhileTyping: true, label: "Length", max: metersToLinearUnit(1000, unit), min: metersToLinearUnit(0.1, unit), onChange: (value) => handleUpdateLength(linearControlValueToMeters(value, unit, { maxMeters: 1000, minMeters: 0.1 })), precision: 2, step: unit === 'imperial' ? 0.1 : 0.01, unit: unitLabel, value: displayLength }), _jsx("div", { className: "px-1 font-medium text-[10px] text-muted-foreground/80 uppercase tracking-wider", children: "Top" }), _jsx(SegmentedControl, { onChange: handleTopModeChange, options: [
                             { label: 'Follows level', value: 'storey' },
                             { label: 'Custom height', value: 'custom' },
-                        ], value: isPlaneBound ? 'storey' : 'custom' }), isPlaneBound ? (_jsxs("div", { className: "px-1 text-[11px] text-muted-foreground", children: ["Currently ", formatLinearMeasurement(height, unit)] })) : (_jsx(SliderControl, { label: "Height", max: metersToLinearUnit(1000, unit), min: metersToLinearUnit(0.1, unit), onChange: (v) => handleUpdate({
+                        ], value: isPlaneBound ? 'storey' : 'custom' }), isPlaneBound ? (_jsxs("div", { className: "px-1 text-[11px] text-muted-foreground", children: ["Currently ", formatLinearMeasurement(height, unit)] })) : (_jsx(SliderControl, { onCommit: handleCommit, onCancel: handleCancel, restoreOnCommit: false, previewWhileTyping: true, label: "Height", max: metersToLinearUnit(1000, unit), min: metersToLinearUnit(0.1, unit), onChange: (v) => handlePreview({
                             height: linearControlValueToMeters(v, unit, { maxMeters: 1000, minMeters: 0.1 }),
                         }), 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, { label: "Thickness", max: metersToLinearUnit(1000, unit), min: metersToLinearUnit(0.05, unit), onChange: (v) => handleUpdate({
+                        ], 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, { label: "Curve", max: Math.max(metersToLinearUnit(0.01, unit), displayMaxCurveOffset), min: -Math.max(metersToLinearUnit(0.01, unit), displayMaxCurveOffset), onChange: (v) => handleUpdate({
+                        }), 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 }))] }), _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({
@@ -238,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,
@@ -258,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/property-preview.d.ts

@@ -0,0 +1,7 @@
+import { type AnyNodeId, type WallNode } from '@pascal-app/core';
+export declare function createWallPropertyPreview(id: AnyNodeId): {
+    preview(patch: Partial<WallNode>): void;
+    commit(patch?: Partial<WallNode>): void;
+    cancel: () => void;
+};
+//# sourceMappingURL=property-preview.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"property-preview.d.ts","sourceRoot":"","sources":["../../src/wall/property-preview.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAkC,KAAK,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAEhG,wBAAgB,yBAAyB,CAAC,EAAE,EAAE,SAAS;mBASpC,OAAO,CAAC,QAAQ,CAAC;mBAKjB,OAAO,CAAC,QAAQ,CAAC;;EAiBnC"}

package/dist/wall/property-preview.js

@@ -0,0 +1,31 @@
+import { useLiveNodeOverrides, useScene } from '@pascal-app/core';
+export function createWallPropertyPreview(id) {
+    let pending;
+    const clear = () => {
+        if (!pending)
+            return;
+        useLiveNodeOverrides.getState().clearFields(id, Object.keys(pending));
+        pending = undefined;
+        useScene.getState().markDirty(id);
+    };
+    return {
+        preview(patch) {
+            pending = { ...pending, ...patch };
+            useLiveNodeOverrides.getState().set(id, patch);
+            useScene.getState().markDirty(id);
+        },
+        commit(patch) {
+            const live = useLiveNodeOverrides.getState().get(id);
+            const current = pending && live
+                ? Object.fromEntries(Object.keys(pending)
+                    .filter((key) => key in live)
+                    .map((key) => [key, live[key]]))
+                : undefined;
+            const updates = { ...current, ...patch };
+            if (Object.keys(updates).length && useScene.getState().nodes[id]?.type === 'wall')
+                useScene.getState().updateNode(id, updates);
+            clear();
+        },
+        cancel: clear,
+    };
+}