@pascal-app/nodes 1.0.1 → 1.0.3

package/dist/wall/move-tool.js

@@ -121,6 +121,7 @@ export const MoveWallTool = ({ node }) => {
         const levelId = node.parentId ?? null;
         pauseSceneHistory(useScene);
         let shouldRestoreOnCleanup = true;
+        let active = true;
         // Wall ids that currently carry a live position override. Cleared on commit
         // (after the final store write lands) and on cancel / external unmount.
         const touchedWallIds = new Set();
@@ -284,6 +285,13 @@ export const MoveWallTool = ({ node }) => {
             return linkedOriginalsRef.current.map((wall) => movedById.get(wall.id) ?? { id: wall.id, start: wall.start, end: wall.end });
         };
         const applyPreview = (nextStart, nextEnd) => {
+            const previous = previewRef.current ?? { start: originalStart, end: originalEnd };
+            if (nextStart[0] === previous.start[0] &&
+                nextStart[1] === previous.start[1] &&
+                nextEnd[0] === previous.end[0] &&
+                nextEnd[1] === previous.end[1])
+                return;
+            hasDraggedRef.current = true;
             previewRef.current = { start: nextStart, end: nextEnd };
             const centerX = (nextStart[0] + nextEnd[0]) / 2;
             const centerZ = (nextStart[1] + nextEnd[1]) / 2;
@@ -324,15 +332,24 @@ export const MoveWallTool = ({ node }) => {
             clearSurfaceOverrides();
         };
         const onGridMove = (event) => {
+            if (!active)
+                return;
             const rawX = event.localPosition[0];
             const rawZ = event.localPosition[2];
             const snapStep = getSegmentGridStep();
             // Anchor at the raw cursor so the displacement is measured in
             // continuous space.
             const anchor = dragAnchorRef.current ?? [rawX, rawZ];
+            const firstMove = dragAnchorRef.current === null;
             dragAnchorRef.current = anchor;
+            // Seeding a controller grab is not movement; don't snap an off-grid wall
+            // to the lattice before the user has moved their hand.
+            if (firstMove)
+                return;
             const rawDeltaX = rawX - anchor[0];
             const rawDeltaZ = rawZ - anchor[1];
+            if (!hasDraggedRef.current && Math.hypot(rawDeltaX, rawDeltaZ) < 1e-6)
+                return;
             // When the move is axis-locked (side-handle drag), snap the wall
             // center's absolute perpendicular offset to a multiple of
             // `snapStep`. For axis-aligned walls this puts the wall on grid
@@ -378,7 +395,6 @@ export const MoveWallTool = ({ node }) => {
             previousGridPosRef.current = constrainedGridPos;
             const nextCenter = [originalCenter[0] + deltaX, originalCenter[1] + deltaZ];
             const nextWall = buildWallFromCenter(nextCenter);
-            hasDraggedRef.current = true;
             applyPreview(nextWall.start, nextWall.end);
         };
         const commitPreview = () => {
@@ -459,6 +475,9 @@ export const MoveWallTool = ({ node }) => {
             exitMoveMode();
         };
         const onPointerUp = () => {
+            if (!active)
+                return;
+            active = false;
             // Press-release without drag: dismiss the tool without committing.
             // This is the same UX as MoveWallEndpointTool / WallHeightArrowHandle
             // — pointer-down on the affordance starts the move, drag updates the
@@ -496,6 +515,9 @@ export const MoveWallTool = ({ node }) => {
             applyPreview(nextWall.start, nextWall.end);
         };
         const onCancel = () => {
+            if (!active)
+                return;
+            active = false;
             shouldRestoreOnCleanup = false;
             restoreOriginal();
             useViewer.getState().setSelection({ selectedIds: [nodeId] });

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

@@ -1 +1 @@
-{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/wall/paint.ts"],"names":[],"mappings":"AAAA,OAAO,EAQL,KAAK,eAAe,EAOpB,KAAK,QAAQ,EAGd,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EAA2C,KAAK,GAAG,EAAa,MAAM,OAAO,CAAA;AAqDpF;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE;IACpC,IAAI,EAAE,QAAQ,CAAA;IACd,SAAS,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE;YAAE,MAAM,CAAC,EAAE,OAAO,CAAA;SAAE,CAAA;KAAE,CAAA;IAC/C,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAA;IACrD,aAAa,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAA;IAC5D,GAAG,CAAC,EAAE,GAAG,CAAA;CACV,GAAG,MAAM,GAAG,IAAI,CA+DhB;AAqCD;;;;;GAKG;AACH,eAAO,MAAM,SAAS,EAAE,eAoCtB,CAAA"}
+{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/wall/paint.ts"],"names":[],"mappings":"AAAA,OAAO,EASL,KAAK,eAAe,EAOpB,KAAK,QAAQ,EAGd,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EAA2C,KAAK,GAAG,EAAa,MAAM,OAAO,CAAA;AAqDpF;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE;IACpC,IAAI,EAAE,QAAQ,CAAA;IACd,SAAS,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE;YAAE,MAAM,CAAC,EAAE,OAAO,CAAA;SAAE,CAAA;KAAE,CAAA;IAC/C,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAA;IACrD,aAAa,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAA;IAC5D,GAAG,CAAC,EAAE,GAAG,CAAA;CACV,GAAG,MAAM,GAAG,IAAI,CAwEhB;AAsCD;;;;;GAKG;AACH,eAAO,MAAM,SAAS,EAAE,eA8DtB,CAAA"}

package/dist/wall/paint.js

@@ -1,4 +1,4 @@
-import { getEffectiveWallSurfaceMaterial, getWallBandSlotId, getWallFaceBandConfig, getWallFaceBandForHeight, getWallSurfaceSideFromBandSlot, parseMaterialRef, sceneRegistry, useScene, WALL_SURFACE_SLOT_DEFAULTS, } from '@pascal-app/core';
+import { getCurtainWallConfig, getEffectiveWallSurfaceMaterial, getWallBandSlotId, getWallFaceBandConfig, getWallFaceBandForHeight, getWallSurfaceSideFromBandSlot, parseMaterialRef, sceneRegistry, useScene, WALL_SURFACE_SLOT_DEFAULTS, } from '@pascal-app/core';
 import { setSurfaceRaycastLayers } from '@pascal-app/viewer';
 import { Raycaster } from 'three';
 import { buildSlotPreviewMaterial, createSlotPaintCapability, previewSlotByUserData, } from '../shared/slot-paint';
@@ -57,6 +57,14 @@ function resolveWallSlotByRay(node, ray) {
  */
 export function resolveWallRole(args) {
     const { node, hitObject, materialIndex, normal, localPosition, ray } = args;
+    if (node.wallType === 'curtain') {
+        const root = sceneRegistry.nodes.get(node.id);
+        if (!(root && ray))
+            return null;
+        wallSlotRaycaster.ray.copy(ray);
+        const hit = wallSlotRaycaster.intersectObject(root, false)[0];
+        return (['curtain-frame', 'curtain-glass', 'curtain-solid'][hit?.face?.materialIndex ?? -1] ?? null);
+    }
     const directSlotId = hitObject?.userData?.slotId;
     if (typeof directSlotId === 'string' && WALL_SLOT_IDS.has(directSlotId)) {
         return directSlotId;
@@ -113,11 +121,12 @@ export function resolveWallRole(args) {
  */
 function applyWallPreview(args) {
     const { role, material, materialPreset } = args;
-    if (!(role in WALL_ARRAY_SLOT_INDEX)) {
+    const curtainIndex = ['curtain-frame', 'curtain-glass', 'curtain-solid'].indexOf(role);
+    if (curtainIndex < 0 && !(role in WALL_ARRAY_SLOT_INDEX)) {
         return previewSlotByUserData(args);
     }
-    const index = WALL_ARRAY_SLOT_INDEX[role];
-    if (!index)
+    const index = curtainIndex >= 0 ? curtainIndex : WALL_ARRAY_SLOT_INDEX[role];
+    if (index === undefined)
         return previewSlotByUserData(args);
     const mesh = sceneRegistry.nodes.get(args.node.id);
     if (!(mesh && mesh.isMesh))
@@ -155,6 +164,32 @@ export const wallPaint = createSlotPaintCapability({
     }),
     applyPreview: applyWallPreview,
     legacyEffective: (node, role) => {
+        if (node.type === 'wall' && node.wallType === 'curtain') {
+            const config = getCurtainWallConfig(node);
+            const color = role === 'curtain-frame'
+                ? config.frameColor
+                : role === 'curtain-glass'
+                    ? config.glassColor
+                    : role === 'curtain-solid'
+                        ? config.solidColor
+                        : undefined;
+            if (!color)
+                return null;
+            return {
+                materialPreset: undefined,
+                material: {
+                    preset: 'custom',
+                    properties: {
+                        color,
+                        roughness: role === 'curtain-glass' ? config.glassRoughness : 0.4,
+                        metalness: role === 'curtain-frame' ? 0.65 : 0,
+                        opacity: role === 'curtain-glass' ? config.glassOpacity : 1,
+                        transparent: role === 'curtain-glass',
+                        side: 'front',
+                    },
+                },
+            };
+        }
         const side = getWallSurfaceSideFromBandSlot(role);
         if (!side && role in WALL_SURFACE_SLOT_DEFAULTS) {
             return {

package/dist/wall/panel-model.d.ts

@@ -0,0 +1,4 @@
+import { type AnyNode, type AnyNodeId, type WallNode } from '@pascal-app/core';
+import { type PanelRow } from '@pascal-app/editor';
+export declare function wallSettings(node: WallNode, nodes: Record<AnyNodeId, AnyNode>, update: (patch: Partial<WallNode>) => void, reshape?: () => void): PanelRow[];
+//# sourceMappingURL=panel-model.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"panel-model.d.ts","sourceRoot":"","sources":["../../src/wall/panel-model.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAad,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAEL,KAAK,QAAQ,EAGd,MAAM,oBAAoB,CAAA;AAiB3B,wBAAgB,YAAY,CAC1B,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,MAAM,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,QAAQ,CAAC,KAAK,IAAI,EAC1C,OAAO,GAAE,MAAM,IAId,GACA,QAAQ,EAAE,CAmNZ"}

package/dist/wall/panel-model.js

@@ -0,0 +1,117 @@
+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 { 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());
+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 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,
+            });
+    }
+    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 } });
+        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 }));
+        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":"AA6FA,MAAM,CAAC,OAAO,UAAU,SAAS,uCAiWhC"}

package/dist/wall/panel.js

@@ -4,9 +4,12 @@ import { buildWallFaceBandCountPatch, GROUND_SUPPORT_ID, getClampedWallCurveOffs
 import { ActionButton, ActionGroup, curveReshapeScope, formatLinearMeasurement, getLinearUnitLabel, linearControlValueToMeters, metersToLinearUnit, PanelSection, PanelWrapper, SegmentedControl, SliderControl, triggerSFX, useInteractionScope, } 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 } 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';
 /**
  * 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
@@ -90,28 +93,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,25 +167,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." })), _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 }), !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 }) }) }))] }));
+                        }), precision: 2, step: 0.1, unit: unitLabel, value: Math.round(displayCurveOffset * 100) / 100 }))] }), node.wallType === 'curtain' ? (_jsx(CurtainWallPanel, { height: height, node: node, onUpdate: handleUpdate, onPreview: handlePreview, onCommit: handleCommit, onCancel: handleCancel, unit: unit }, node.id)) : (_jsxs(_Fragment, { children: [_jsx(WallFaceBandSection, { node: node, onUpdate: handleUpdate, unit: unit, unitLabel: unitLabel, wallHeightMeters: wallHeightMeters }), _jsx(WallTrimSection, { node: node, onUpdate: handleUpdate, title: "Skirting", trimKey: "skirting", trimValue: skirting, unit: unit, unitLabel: unitLabel, wallHeightMeters: wallHeightMeters }), _jsx(WallTrimSection, { node: node, onUpdate: handleUpdate, title: "Crown molding", trimKey: "crown", trimValue: crown, unit: unit, unitLabel: unitLabel, wallHeightMeters: wallHeightMeters }), _jsx(WallTrimSection, { node: node, onUpdate: handleUpdate, title: "Chair rail", trimKey: "chairRail", trimValue: chairRail, unit: unit, unitLabel: unitLabel, wallHeightMeters: wallHeightMeters })] })), !hasWallChildrenBlockingCurve && (_jsx(PanelSection, { title: "Actions", children: _jsx(ActionGroup, { children: _jsx(ActionButton, { icon: _jsx(Spline, { className: "h-3.5 w-3.5" }), label: "Curve", onClick: handleCurve }) }) }))] }));
 }
 function WallFaceBandSection({ node, onUpdate, unit, unitLabel, wallHeightMeters, }) {
     const bandConfig = getWallFaceBandConfig(node, wallHeightMeters);

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,
+    };
+}

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

@@ -0,0 +1,149 @@
+import { type AnyNodeId, type WallConstructionOptions, type WallNode, type WallPlanPoint } from '@pascal-app/core';
+export declare function createWallRectangle(levelId: AnyNodeId, start: WallPlanPoint, end: WallPlanPoint, defaults?: Partial<WallNode>, options?: WallConstructionOptions): {
+    object: "node";
+    parentId: string | null;
+    visible: boolean;
+    metadata: Record<string, unknown>;
+    id: `wall_${string}`;
+    type: "wall";
+    children: (`item_${string}` | `procedural-item_${string}` | `leanto_${string}` | `door_${string}` | `window_${string}`)[];
+    start: [number, number];
+    end: [number, number];
+    frontSide: "unknown" | "interior" | "exterior";
+    backSide: "unknown" | "interior" | "exterior";
+    name?: string | undefined;
+    camera?: {
+        position: [number, number, number];
+        target: [number, number, number];
+        mode: "perspective" | "orthographic";
+        fov?: number | undefined;
+        zoom?: number | undefined;
+    } | undefined;
+    wallType?: "standard" | "curtain" | undefined;
+    curtainWall?: {
+        construction: "stick" | "unitized";
+        framing: "capped" | "vertical-caps" | "horizontal-caps" | "structural-glazing";
+        columns: {
+            layout: "count" | "maximum-spacing" | "fixed-spacing";
+            count: number;
+            spacing: number;
+            alignment: "center" | "start" | "end";
+        };
+        rows: {
+            layout: "count" | "maximum-spacing" | "fixed-spacing";
+            count: number;
+            spacing: number;
+            alignment: "center" | "start" | "end";
+        };
+        mullionWidth: number;
+        transomWidth: number;
+        perimeterWidth: number;
+        jointWidth: number;
+        glassThickness: number;
+        panelType: "glass" | "solid" | "empty";
+        spandrel: "top" | "none" | "bottom";
+        frameColor: string;
+        glassColor: string;
+        solidColor: string;
+        glassOpacity: number;
+        glassRoughness: number;
+        panels: {
+            column: number;
+            row: number;
+            type: "glass" | "solid" | "empty";
+        }[];
+    } | undefined;
+    material?: {
+        id?: string | undefined;
+        preset?: "custom" | "white" | "brick" | "concrete" | "wood" | "glass" | "metal" | "plaster" | "tile" | "marble" | undefined;
+        properties?: {
+            color: string;
+            roughness: number;
+            metalness: number;
+            opacity: number;
+            transparent: boolean;
+            side: "front" | "back" | "double";
+        } | undefined;
+        texture?: {
+            url: string;
+            repeat?: [number, number] | undefined;
+            scale?: number | undefined;
+        } | undefined;
+    } | undefined;
+    materialPreset?: string | undefined;
+    interiorMaterial?: {
+        id?: string | undefined;
+        preset?: "custom" | "white" | "brick" | "concrete" | "wood" | "glass" | "metal" | "plaster" | "tile" | "marble" | undefined;
+        properties?: {
+            color: string;
+            roughness: number;
+            metalness: number;
+            opacity: number;
+            transparent: boolean;
+            side: "front" | "back" | "double";
+        } | undefined;
+        texture?: {
+            url: string;
+            repeat?: [number, number] | undefined;
+            scale?: number | undefined;
+        } | undefined;
+    } | undefined;
+    interiorMaterialPreset?: string | undefined;
+    exteriorMaterial?: {
+        id?: string | undefined;
+        preset?: "custom" | "white" | "brick" | "concrete" | "wood" | "glass" | "metal" | "plaster" | "tile" | "marble" | undefined;
+        properties?: {
+            color: string;
+            roughness: number;
+            metalness: number;
+            opacity: number;
+            transparent: boolean;
+            side: "front" | "back" | "double";
+        } | undefined;
+        texture?: {
+            url: string;
+            repeat?: [number, number] | undefined;
+            scale?: number | undefined;
+        } | undefined;
+    } | undefined;
+    exteriorMaterialPreset?: string | undefined;
+    slots?: Record<string, string> | undefined;
+    thickness?: number | undefined;
+    height?: number | undefined;
+    curveOffset?: number | undefined;
+    supportSlabId?: string | undefined;
+    supportOffset?: number | undefined;
+    fillToTerrain?: boolean | undefined;
+    faceBands?: {
+        enabled: boolean;
+        count: number;
+        lowerHeight: number;
+        middleHeight: number;
+        upperHeight: number;
+    } | undefined;
+    skirting?: {
+        enabled: boolean;
+        sides: "interior" | "exterior" | "both";
+        height: number;
+        proud: number;
+        profile: "flat" | "bevel" | "triangle" | "cove" | "bullnose" | "base-modern" | "base-colonial" | "base-shoe" | "base-ogee" | "crown-cove" | "crown-ogee" | "crown-craftsman" | "crown-layered" | "rail-rounded" | "rail-ogee" | "rail-picture" | "rail-stepped";
+        offsetY?: number | undefined;
+    } | undefined;
+    crown?: {
+        enabled: boolean;
+        sides: "interior" | "exterior" | "both";
+        height: number;
+        proud: number;
+        profile: "flat" | "bevel" | "triangle" | "cove" | "bullnose" | "base-modern" | "base-colonial" | "base-shoe" | "base-ogee" | "crown-cove" | "crown-ogee" | "crown-craftsman" | "crown-layered" | "rail-rounded" | "rail-ogee" | "rail-picture" | "rail-stepped";
+        offsetY?: number | undefined;
+    } | undefined;
+    chairRail?: {
+        enabled: boolean;
+        sides: "interior" | "exterior" | "both";
+        height: number;
+        proud: number;
+        profile: "flat" | "bevel" | "triangle" | "cove" | "bullnose" | "base-modern" | "base-colonial" | "base-shoe" | "base-ogee" | "crown-cove" | "crown-ogee" | "crown-craftsman" | "crown-layered" | "rail-rounded" | "rail-ogee" | "rail-picture" | "rail-stepped";
+        offsetY?: number | undefined;
+    } | undefined;
+}[];
+//# sourceMappingURL=rectangle-command.d.ts.map

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

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

package/dist/wall/rectangle-command.js

@@ -0,0 +1,22 @@
+import { planWallRectangle, resolveWallConstruction, runAsSingleSceneHistoryStep, useScene, } from '@pascal-app/core';
+export function createWallRectangle(levelId, start, end, defaults = {}, options) {
+    const scene = useScene.getState();
+    if (scene.readOnly)
+        throw Error('This scene is read-only.');
+    const plan = planWallRectangle(scene.nodes, { levelId, start, end, wallDefaults: defaults });
+    if (!plan.changes.create.length && !plan.changes.update.length && !plan.changes.delete.length)
+        return [];
+    const construction = resolveWallConstruction(scene.nodes, levelId, plan.walls, options);
+    const walls = new Map(construction.walls.map((w) => [w.id, w]));
+    const changes = {
+        ...plan.changes,
+        create: plan.changes.create.map((op) => ({
+            ...op,
+            node: walls.get(op.node.id) ?? op.node,
+        })),
+    };
+    if (construction.sourceSupportUpdate)
+        changes.update.push(construction.sourceSupportUpdate);
+    runAsSingleSceneHistoryStep(useScene, () => scene.applyNodeChanges(changes));
+    return construction.walls;
+}

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

@@ -0,0 +1,2 @@
+export default function RectangleWallTool(): import("react").JSX.Element;
+//# sourceMappingURL=rectangle-tool.d.ts.map

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

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