@pascal-app/nodes 1.0.0 → 1.0.3

package/dist/wall/drawing-mode.js

@@ -0,0 +1,38 @@
+import { emitter } from '@pascal-app/core';
+import { isEditableKeyboardTarget } from '@pascal-app/editor';
+import { useEffect } from 'react';
+import { create } from 'zustand';
+export const useWallDrawingMode = create((set, get) => ({
+    mode: 'line',
+    toggle: () => {
+        emitter.emit('tool:cancel');
+        set({ mode: get().mode === 'rectangle' ? 'line' : 'rectangle' });
+    },
+}));
+const onKeyDown = (e) => {
+    if (e.repeat || e.metaKey || e.ctrlKey || e.altKey)
+        return;
+    if (e.key !== 'r' && e.key !== 'R')
+        return;
+    if (isEditableKeyboardTarget(e.target))
+        return;
+    e.preventDefault();
+    useWallDrawingMode.getState().toggle();
+};
+let owners = 0;
+/**
+ * R toggles line / rectangle drawing (the HUD's Shape chip cycles the same
+ * store). Both wall tools mount this: the 3D tool only exists once the canvas
+ * does, and split view mounts both, so one listener serves whichever is up.
+ * The mode outlives the tool: re-arming walls resumes the last shape used.
+ */
+export function useWallDrawingModeKeys() {
+    useEffect(() => {
+        if (owners++ === 0)
+            window.addEventListener('keydown', onKeyDown);
+        return () => {
+            if (--owners === 0)
+                window.removeEventListener('keydown', onKeyDown);
+        };
+    }, []);
+}

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

@@ -0,0 +1,4 @@
+import { type FloorplanToolContext } from '@pascal-app/editor';
+/** The wall's plan tool: line drafting stays with the panel; rectangle mode mounts its own tool. */
+export default function WallFloorplanTool(props: FloorplanToolContext): import("react").JSX.Element | null;
+//# sourceMappingURL=floorplan-tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-tool.d.ts","sourceRoot":"","sources":["../../src/wall/floorplan-tool.tsx"],"names":[],"mappings":"AAOA,OAAO,EACL,KAAK,oBAAoB,EAO1B,MAAM,oBAAoB,CAAA;AAK3B,oGAAoG;AACpG,MAAM,CAAC,OAAO,UAAU,iBAAiB,CAAC,KAAK,EAAE,oBAAoB,sCAIpE"}

package/dist/wall/floorplan-tool.js

@@ -0,0 +1,107 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { emitter, resolveTerrainWallConstructionOptions, useScene, } from '@pascal-app/core';
+import { markToolCancelConsumed, triggerSFX, useEditor, useFloorplanDraftPreview, useFloorplanRender, useInteractionScope, } from '@pascal-app/editor';
+import { useEffect, useRef, useState } from 'react';
+import { useWallDrawingMode, useWallDrawingModeKeys } from './drawing-mode';
+import { createWallRectangle } from './rectangle-command';
+/** The wall's plan tool: line drafting stays with the panel; rectangle mode mounts its own tool. */
+export default function WallFloorplanTool(props) {
+    useWallDrawingModeKeys();
+    const mode = useWallDrawingMode((s) => s.mode);
+    return mode === 'rectangle' ? _jsx(RectangleFloorplanTool, { ...props }) : null;
+}
+/**
+ * Rectangle mode in the floor plan. Pointer moves stay with the panel, so the
+ * cursor, snapping, alignment guides and snap beacon are the line wall's own;
+ * this tool only claims clicks and publishes the first corner, and the panel's
+ * linear draft layer draws the four draft walls from it.
+ */
+function RectangleFloorplanTool({ activeLevelId }) {
+    const group = useRef(null);
+    const renderContext = useFloorplanRender();
+    const [error, setError] = useState(null);
+    useEffect(() => {
+        const svg = group.current?.ownerSVGElement;
+        if (!svg || !activeLevelId)
+            return;
+        const draft = useFloorplanDraftPreview.getState;
+        let down = null;
+        let construction;
+        useInteractionScope.getState().begin({ kind: 'drafting', tool: 'wall' });
+        const claim = (e) => {
+            e.preventDefault();
+            e.stopImmediatePropagation();
+        };
+        const onDown = (e) => {
+            if (e.button !== 0 || e.metaKey || e.ctrlKey)
+                return;
+            claim(e);
+            down = [e.clientX, e.clientY];
+        };
+        const cancel = () => {
+            if (draft().wallRectangleDraftStart)
+                markToolCancelConsumed();
+            draft().setWallRectangleDraftStart(null);
+            down = null;
+            setError(null);
+        };
+        const onClick = (e) => {
+            if (e.button !== 0 || e.metaKey || e.ctrlKey)
+                return;
+            claim(e);
+            if (!down || Math.hypot(e.clientX - down[0], e.clientY - down[1]) > 5) {
+                down = null;
+                return;
+            }
+            down = null;
+            // The panel's snapped cursor, exactly where a line wall would land.
+            const point = draft().cursorPoint;
+            if (!point)
+                return;
+            const start = draft().wallRectangleDraftStart;
+            if (!start) {
+                construction = resolveTerrainWallConstructionOptions(useScene.getState().nodes, activeLevelId, point, useEditor.getState().toolDefaults.wall);
+                draft().setWallRectangleDraftStart(point);
+                setError(null);
+                triggerSFX('sfx:structure-build-start');
+                return;
+            }
+            try {
+                createWallRectangle(activeLevelId, start, point, useEditor.getState().toolDefaults.wall ?? {}, construction);
+                cancel();
+                triggerSFX('sfx:structure-build');
+            }
+            catch (e) {
+                setError({ message: e.message, at: point });
+            }
+        };
+        const stopDouble = (e) => {
+            if (e.button === 0)
+                claim(e);
+        };
+        // The panel publishes the snapped cursor only when it moves to a new
+        // point, so each change while a corner is down is the line draft's tick.
+        const stopTick = useFloorplanDraftPreview.subscribe((state, previous) => {
+            if (state.wallRectangleDraftStart &&
+                state.cursorPoint &&
+                state.cursorPoint !== previous.cursorPoint)
+                triggerSFX('sfx:grid-snap');
+        });
+        svg.addEventListener('pointerdown', onDown, true);
+        svg.addEventListener('click', onClick, true);
+        svg.addEventListener('dblclick', stopDouble, true);
+        emitter.on('tool:cancel', cancel);
+        return () => {
+            stopTick();
+            svg.removeEventListener('pointerdown', onDown, true);
+            svg.removeEventListener('click', onClick, true);
+            svg.removeEventListener('dblclick', stopDouble, true);
+            emitter.off('tool:cancel', cancel);
+            draft().setWallRectangleDraftStart(null);
+            useInteractionScope.getState().endIf((s) => s.kind === 'drafting' && s.tool === 'wall');
+        };
+    }, [activeLevelId]);
+    const unitsPerPixel = renderContext?.unitsPerPixel ?? 0.01;
+    return (_jsx("g", { ref: group, pointerEvents: "none", children: error && (_jsx("text", { x: error.at[0], y: error.at[1] - 0.2, fill: "#ef4444", fontSize: 12 * unitsPerPixel, children: error.message })) }));
+}

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/wall/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAEZ,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAOpB,KAAK,aAAa,EAClB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAKL,KAAK,6BAA6B,EACnC,MAAM,2BAA2B,CAAA;AAYlC,QAAA,MAAM,yBAAyB,yDAA0D,CAAA;AAEzF,KAAK,sBAAsB,GAAG,CAAC,OAAO,yBAAyB,CAAC,CAAC,MAAM,CAAC,CAAA;AAexE,MAAM,MAAM,sBAAsB,GAAG;IACnC,MAAM,EAAE,aAAa,CAAA;IACrB,cAAc,EAAE,aAAa,CAAA;IAC7B,iCAAiC,EAAE,MAAM,CAAC,sBAAsB,EAAE,6BAA6B,CAAC,CAAA;CACjG,CAAA;AAED,wBAAgB,6BAA6B,CAAC,EAC5C,QAAQ,EACR,KAAK,GACN,EAAE;IACD,QAAQ,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAA;IACjC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B,GAAG,sBAAsB,CAqCzB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAkNjG"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/wall/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAEZ,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAQpB,KAAK,aAAa,EAClB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAKL,KAAK,6BAA6B,EACnC,MAAM,2BAA2B,CAAA;AAalC,QAAA,MAAM,yBAAyB,yDAA0D,CAAA;AAEzF,KAAK,sBAAsB,GAAG,CAAC,OAAO,yBAAyB,CAAC,CAAC,MAAM,CAAC,CAAA;AAexE,MAAM,MAAM,sBAAsB,GAAG;IACnC,MAAM,EAAE,aAAa,CAAA;IACrB,cAAc,EAAE,aAAa,CAAA;IAC7B,iCAAiC,EAAE,MAAM,CAAC,sBAAsB,EAAE,6BAA6B,CAAC,CAAA;CACjG,CAAA;AAED,wBAAgB,6BAA6B,CAAC,EAC5C,QAAQ,EACR,KAAK,GACN,EAAE;IACD,QAAQ,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAA;IACjC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B,GAAG,sBAAsB,CAqCzB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CA8NjG"}

package/dist/wall/floorplan.js

@@ -1,7 +1,8 @@
-import { calculateLevelMiters, getWallCurveFrameAt, getWallCurveLength, getWallMidpointHandlePoint, getWallPlanFootprint, getWallThickness, isCurvedWall, } from '@pascal-app/core';
+import { calculateLevelMiters, getWallCurveFrameAt, getWallCurveLength, getWallEffectiveHeightForNodes, getWallMidpointHandlePoint, getWallPlanFootprint, getWallThickness, isCurvedWall, } from '@pascal-app/core';
 import { floorplanGeometryMetadata, readFloorplanContext } from '@pascal-app/editor';
 import { constructionDimensionStandard } from '../shared/construction-dimension-standards';
 import { buildCurvedWallConstructionDimensions, buildLevelWallConstructionDimensionPlan, buildWallConstructionDimensions, renderPlannedConstructionDimensions, } from './construction-dimensions';
+import { buildCurtainWallFloorplan } from './curtain-wall-floorplan';
 import { hasWallCurveBlockingChildren } from './curve-eligibility';
 // Same constants the legacy `getFloorplanWall` uses (editor/lib/floorplan/walls.ts).
 // Slightly exaggerates thin walls so the 2D plan stays legible without
@@ -103,7 +104,7 @@ export function buildWallFloorplan(node, ctx) {
         : isHovered && palette
             ? palette.wallHoverStroke
             : '#1f2937';
-    const fill = showSelectedChrome ? '#ffffff' : '#374151';
+    const fill = node.wallType === 'curtain' ? 'transparent' : showSelectedChrome ? '#ffffff' : '#374151';
     const children = [
         {
             kind: 'polygon',
@@ -121,6 +122,9 @@ export function buildWallFloorplan(node, ctx) {
             cursor: isSelected ? 'default' : undefined,
         },
     ];
+    if (node.wallType === 'curtain') {
+        children.push(...buildCurtainWallFloorplan(node, getWallEffectiveHeightForNodes(node, ctx.sceneNodes ?? {}), stroke, ctx.children));
+    }
     if (automaticDimensions) {
         const dimensionStroke = isSelected && palette ? palette.selectedStroke : (palette?.measurementStroke ?? '#334155');
         const dimensionStandard = constructionDimensionStandard({

package/dist/wall/length-patch.d.ts

@@ -0,0 +1,3 @@
+import { type WallNode } from '@pascal-app/core';
+export declare function buildWallLengthPatch(node: WallNode, nextLength: number): Partial<WallNode>;
+//# sourceMappingURL=length-patch.d.ts.map

package/dist/wall/length-patch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"length-patch.d.ts","sourceRoot":"","sources":["../../src/wall/length-patch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiD,KAAK,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAE/F,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC,CAW1F"}

package/dist/wall/length-patch.js

@@ -0,0 +1,14 @@
+import { getClampedWallCurveOffset, getWallCurveLength } from '@pascal-app/core';
+export function buildWallLengthPatch(node, nextLength) {
+    const length = getWallCurveLength(node);
+    if (!length || !Number.isFinite(nextLength) || nextLength <= 0)
+        return {};
+    const ratio = nextLength / length;
+    return {
+        end: [
+            node.start[0] + (node.end[0] - node.start[0]) * ratio,
+            node.start[1] + (node.end[1] - node.start[1]) * ratio,
+        ],
+        ...(node.curveOffset ? { curveOffset: getClampedWallCurveOffset(node) * ratio } : {}),
+    };
+}

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

@@ -1 +1 @@
-{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/wall/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAwBL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAqIzB,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CA4iBrD,CAAA;AAED,eAAe,YAAY,CAAA"}
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/wall/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAwBL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAqIzB,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CA+jBrD,CAAA;AAED,eAAe,YAAY,CAAA"}

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"}