@pascal-app/nodes 1.0.3 → 1.0.5

package/dist/wall/panel-model.js

@@ -1,9 +1,9 @@
-import { buildWallFaceBandCountPatch, GROUND_SUPPORT_ID, getClampedWallCurveOffset, getMaxWallCurveOffset, getWallCurveLength, getWallFaceBandConfig, normalizeWallCurveOffset, terrainSupportLift, WALL_CHAIR_RAIL_DEFAULT, WALL_CROWN_DEFAULT, WALL_FACE_BAND_DEFAULT, WALL_SKIRTING_DEFAULT, } from '@pascal-app/core';
+import { faceOnLine, GROUND_SUPPORT_ID, getClampedWallCurveOffset, getMaxWallCurveOffset, getWallCurveLength, justificationForFaceOnLine, normalizeWallCurveOffset, planWallJustification, roomSideFaces, terrainSupportLift, useScene, WALL_CHAIR_RAIL_DEFAULT, WALL_CROWN_DEFAULT, WALL_SKIRTING_DEFAULT, wallTrimPatch, } 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';
+import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling.js';
+import { hasWallCurveBlockingChildren } from './curve-eligibility.js';
+import { buildWallLengthPatch } from './length-patch.js';
 const profiles = {
     skirting: ['flat', 'base-modern', 'base-colonial', 'base-shoe', 'base-ogee'],
     crown: ['flat', 'crown-cove', 'crown-ogee', 'crown-craftsman', 'crown-layered'],
@@ -12,6 +12,66 @@ const profiles = {
 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));
@@ -51,6 +111,20 @@ export function wallSettings(node, nodes, update, reshape = () => {
             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));
@@ -79,37 +153,21 @@ export function wallSettings(node, nodes, update, reshape = () => {
                 onSelect: reshape,
             });
     }
-    const bands = getWallFaceBandConfig(node, height);
-    number('Wall bands', 'wall-band-count', 'Bands', bands.count, 1, 4, 1, (count) => update(buildWallFaceBandCountPatch(node, Math.round(count))), '');
-    const band = (key, label, max) => number('Wall bands', `wall-band-${key}`, label, bands[key], 0, Math.max(0, max), 0.01, (value) => update({
-        faceBands: {
-            ...WALL_FACE_BAND_DEFAULT,
-            ...node.faceBands,
-            enabled: bands.count > 1,
-            count: bands.count,
-            [key]: value,
-        },
-    }));
-    if (bands.count >= 2)
-        band('lowerHeight', 'Lower', height);
-    if (bands.count >= 3)
-        band('middleHeight', 'Middle', height - bands.lowerHeight);
-    if (bands.count >= 4)
-        band('upperHeight', 'Upper', height - bands.lowerHeight - bands.middleHeight);
     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 } });
+        const patch = (value) => update(wallTrimPatch(node, key, value));
         choice(title, `${key}-enabled`, title, trim.enabled ? 'On' : 'Off', () => patch({ enabled: !trim.enabled }));
         if (!trim.enabled)
             continue;
-        cycle(title, `${key}-sides`, 'Sides', trim.sides, ['interior', 'exterior', 'both'], (sides) => patch({ sides: sides }));
+        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 }));
+        number(title, `${key}-proud`, 'Depth', 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 }));
     }

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

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/wall/panel.tsx"],"names":[],"mappings":"AA6FA,MAAM,CAAC,OAAO,UAAU,SAAS,uCAiWhC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/wall/panel.tsx"],"names":[],"mappings":"AAwHA,MAAM,CAAC,OAAO,UAAU,SAAS,uCA4XhC"}

package/dist/wall/panel.js

@@ -1,15 +1,18 @@
 '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 { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { assemblyThickness, BRICK_AIR_SPACE, BRICK_VENEER, FIBER_CEMENT, GROUND_SUPPORT_ID, GYPSUM_HALF, GYPSUM_SHEATHING, getClampedWallCurveOffset, getMaxWallCurveOffset, getWallAssemblyPreset, getWallCurveLength, normalizeWallCurveOffset, resolveWallAssembly, runAsSingleSceneHistoryStep, 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, wallTrimPatch, } from '@pascal-app/core';
+import { setWallFaceScript } from '@pascal-app/core/agent-operations';
+import { ActionButton, ActionGroup, curveReshapeScope, finishScriptCode, 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 { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling';
-import { CurtainWallPanel } from './curtain-wall-panel';
-import { hasWallCurveBlockingChildren } from './curve-eligibility';
-import { buildWallLengthPatch } from './length-patch';
-import { createWallPropertyPreview } from './property-preview';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { useShallow } from 'zustand/react/shallow';
+import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling.js';
+import { CurtainWallPanel } from './curtain-wall-panel.js';
+import { hasWallCurveBlockingChildren } from './curve-eligibility.js';
+import { buildWallLengthPatch } from './length-patch.js';
+import { wallReferenceModel } from './panel-model.js';
+import { createWallPropertyPreview } from './property-preview.js';
 /**
  * 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
@@ -85,6 +88,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,71 +183,74 @@ 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 }) }) }))] }));
+                        }), 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(WallFaceScriptSection, { 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 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) }))] }));
+/**
+ * "Scripted finish": a face a script builds (it owns that face's colours, so Paint leaves it), with
+ * its code to read and a way to take it off, back to the face's own finish.
+ */
+function WallFaceScriptSection({ wallId }) {
+    const shas = useScene(useShallow((scene) => {
+        const wall = scene.nodes[wallId];
+        return wall?.type === 'wall'
+            ? [wall.finishScripts?.a?.script, wall.finishScripts?.b?.script]
+            : [];
+    }));
+    if (!(shas[0] || shas[1]))
+        return null;
+    return (_jsx(PanelSection, { title: "Scripted finish", children: ['a', 'b'].map((face, index) => {
+            const sha = shas[index];
+            return sha ? _jsx(WallFaceScriptRow, { face: face, sha: sha, wallId: wallId }, face) : null;
+        }) }));
+}
+function WallFaceScriptRow({ face, sha, wallId }) {
+    const [code, setCode] = useState(null);
+    const [open, setOpen] = useState(false);
+    const toggleCode = () => {
+        setOpen((shown) => !shown);
+        if (code?.sha === sha)
+            return;
+        finishScriptCode(sha).then((text) => setCode({ sha, text: text ?? 'The script could not be read.' }), () => setCode({ sha, text: 'The script could not be read.' }));
+    };
+    const remove = () => {
+        const { changes } = setWallFaceScript(useScene.getState().nodes, { wallId, face, remove: true }, { activeLevelId: null });
+        runAsSingleSceneHistoryStep(useScene, () => {
+            for (const { id, data } of changes?.update ?? [])
+                useScene.getState().updateNode(id, data);
+        });
+    };
+    return (_jsxs("div", { className: "flex flex-col gap-2", "data-wall-face-script": face, children: [_jsxs("div", { className: "flex min-h-8 items-center justify-between gap-3", children: [_jsxs("span", { className: "text-muted-foreground text-xs", children: ["Side ", face.toUpperCase()] }), _jsxs("div", { className: "flex items-center gap-1.5", children: [_jsx("button", { className: "rounded-full border border-border/50 px-2.5 py-0.5 text-xs transition-colors hover:bg-accent", onClick: toggleCode, type: "button", children: open ? 'Hide code' : 'View code' }), _jsx("button", { className: "rounded-full border border-border/50 px-2.5 py-0.5 text-xs transition-colors hover:bg-accent", onClick: remove, type: "button", children: "Remove" })] })] }), open && (_jsx("pre", { className: "max-h-60 overflow-auto whitespace-pre rounded-lg border border-border/50 p-2 font-mono text-[11px] text-foreground", children: code?.sha === sha ? code.text : 'Loading…' }))] }));
 }
 function WallTrimSection({ node, onUpdate, title, trimKey, trimValue, unit, unitLabel, wallHeightMeters, }) {
-    const updateTrim = (patch) => onUpdate({
-        [trimKey]: {
-            ...trimValue,
-            ...patch,
-        },
-    });
+    const updateTrim = (patch) => onUpdate(wallTrimPatch(node, trimKey, patch));
     const profileOptions = WALL_TRIM_PROFILE_OPTIONS[trimKey];
     const selectedProfile = profileOptions.some((option) => option.value === trimValue.profile)
         ? 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,
                             }),
-                        }), precision: 2, step: 0.01, unit: unitLabel, value: metersToLinearUnit(trimValue.height, unit) }), _jsx(SliderControl, { label: "Proud", max: metersToLinearUnit(0.2, unit), min: metersToLinearUnit(0.001, unit), onChange: (value) => updateTrim({
+                        }), precision: 2, step: 0.01, unit: unitLabel, value: metersToLinearUnit(trimValue.height, unit) }), _jsx(SliderControl, { label: "Depth", max: metersToLinearUnit(0.2, unit), min: metersToLinearUnit(0.001, unit), onChange: (value) => updateTrim({
                             proud: linearControlValueToMeters(value, unit, {
                                 maxMeters: 0.2,
                                 minMeters: 0.001,
@@ -254,3 +262,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

@@ -1,5 +1,5 @@
 import type { ParametricDescriptor } from '@pascal-app/core';
-import type { WallNode } from './schema';
+import type { WallNode } from './schema.js';
 /**
  * Inspector descriptor for wall.
  *

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.
@@ -28,5 +31,5 @@ export const wallParametrics = {
     // aware Curve slider that's only shown when no door / window / wall-
     // attached item lives on the wall. The auto-inspector can't express
     // "derived" or "conditionally visible" yet — kept as a custom panel.
-    customPanel: () => import('./panel'),
+    customPanel: () => import('./panel.js'),
 };

package/dist/wall/pointer-transparency.d.ts

@@ -62,7 +62,7 @@
  * Visible walls never suppress. Pure so the truth table is testable without
  * an R3F rig; the renderer supplies live values per event.
  */
-import type { WallRayHitOwnership } from './selection-hit-owner';
+import type { WallRayHitOwnership } from './selection-hit-owner.js';
 /**
  * Depth tie-break for "at the wall face": in-wall boxes sit flush-to-
  * recessed within a wall thickness (0.09–0.3 m); openings sit inside the

package/dist/wall/pointer-transparency.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pointer-transparency.d.ts","sourceRoot":"","sources":["../../src/wall/pointer-transparency.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAEhE;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B,OAAO,CAAA;AAEjD,+EAA+E;AAC/E,eAAO,MAAM,wBAAwB,mBAAmB,CAAA;AAExD,6DAA6D;AAC7D,MAAM,MAAM,UAAU,GAAG;IACvB,0EAA0E;IAC1E,QAAQ,EAAE,MAAM,CAAA;IAChB,uDAAuD;IACvD,SAAS,EAAE,mBAAmB,CAAA;IAC9B,8EAA8E;IAC9E,gBAAgB,EAAE,OAAO,CAAA;CAC1B,CAAA;AAED,yEAAyE;AACzE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,sDAAsD;IACtD,eAAe,EAAE,MAAM,CAAA;IACvB,2EAA2E;IAC3E,SAAS,EAAE,aAAa,CAAC,UAAU,CAAC,CAAA;CACrC,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,wBAAwB,GACnC,KAAK,gBAAgB,EACrB,UAAS,MAAsC,KAC9C,OAYF,CAAA;AAED,4EAA4E;AAC5E,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,MAAM,CAAC,EAAE,iBAAiB,GAAG,IAAI,CAAA;CAClC,CAAA;AACD,MAAM,MAAM,uBAAuB,GAAG;IACpC,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,iBAAiB,CAAA;CAC1B,CAAA;AAYD;;;;;;;;;GASG;AACH,eAAO,MAAM,uBAAuB,GAClC,OAAO,OAAO,EACd,UAAU,MAAM,GAAG,IAAI,EACvB,UAAU,CAAC,MAAM,EAAE,iBAAiB,KAAK,mBAAmB,KAC3D,gBAAgB,GAAG,SAsBrB,CAAA;AAED,eAAO,MAAM,2BAA2B,GAAI,yEAKzC;IACD,UAAU,EAAE,OAAO,CAAA;IACnB,kBAAkB,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAA;IAC7C,oBAAoB,EAAE,OAAO,CAAA;IAC7B;;;;OAIG;IACH,YAAY,CAAC,EAAE,gBAAgB,CAAA;CAChC,KAAG,OAMH,CAAA"}
+{"version":3,"file":"pointer-transparency.d.ts","sourceRoot":"","sources":["../../src/wall/pointer-transparency.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAEhE;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B,OAAO,CAAA;AAEjD,+EAA+E;AAC/E,eAAO,MAAM,wBAAwB,mBAAmB,CAAA;AAExD,6DAA6D;AAC7D,MAAM,MAAM,UAAU,GAAG;IACvB,0EAA0E;IAC1E,QAAQ,EAAE,MAAM,CAAA;IAChB,uDAAuD;IACvD,SAAS,EAAE,mBAAmB,CAAA;IAC9B,8EAA8E;IAC9E,gBAAgB,EAAE,OAAO,CAAA;CAC1B,CAAA;AAED,yEAAyE;AACzE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,sDAAsD;IACtD,eAAe,EAAE,MAAM,CAAA;IACvB,2EAA2E;IAC3E,SAAS,EAAE,aAAa,CAAC,UAAU,CAAC,CAAA;CACrC,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,wBAAwB,QAC9B,gBAAgB,YACZ,MAAM,KACd,OAYF,CAAA;AAED,4EAA4E;AAC5E,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,MAAM,CAAC,EAAE,iBAAiB,GAAG,IAAI,CAAA;CAClC,CAAA;AACD,MAAM,MAAM,uBAAuB,GAAG;IACpC,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,iBAAiB,CAAA;CAC1B,CAAA;AAYD;;;;;;;;;GASG;AACH,eAAO,MAAM,uBAAuB,UAC3B,OAAO,YACJ,MAAM,GAAG,IAAI,YACb,CAAC,MAAM,EAAE,iBAAiB,KAAK,mBAAmB,KAC3D,gBAAgB,GAAG,SAsBrB,CAAA;AAED,eAAO,MAAM,2BAA2B,4EAKrC;IACD,UAAU,EAAE,OAAO,CAAA;IACnB,kBAAkB,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAA;IAC7C,oBAAoB,EAAE,OAAO,CAAA;IAC7B;;;;OAIG;IACH,YAAY,CAAC,EAAE,gBAAgB,CAAA;CAChC,KAAG,OAMH,CAAA"}

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

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

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

@@ -1 +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"}
+{"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;IASnD,OAAO,QAAQ,OAAO,CAAC,QAAQ,CAAC;IAKhC,MAAM,SAAS,OAAO,CAAC,QAAQ,CAAC;IAehC,MAAM;EAET"}

package/dist/wall/quick-measurement.js

@@ -1,5 +1,5 @@
 import { getWallCurveFrameAt, getWallCurveLength, getWallThickness, useScene, } from '@pascal-app/core';
-import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling';
+import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling.js';
 export function wallQuickMeasurement(node) {
     const length = getWallCurveLength(node);
     const height = resolveWallOpeningCeiling(node, useScene.getState().nodes);