@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/wall/move-tool.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { beginSceneHistoryPauseSession, createLevelStructurePreview, emitter, getPerpendicularWallMoveAxis, getPlannedLinkedWallUpdates, planWallEndRejoins, planWallMoveJunctions, resolveMovedWallSupportSlabPatch, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
-import { CursorSphere, EDITOR_LAYER, getSegmentGridStep, isSegmentLongEnough, isTypingTarget, markToolCancelConsumed, snapBuildingLocalToWorldGrid, snapScalarToGrid, triggerSFX, useEditor, WALL_CONNECT_SNAP_RADIUS, } from '@pascal-app/editor';
+import { beginSceneHistoryPauseSession, createLevelStructurePreview, emitter, finishWallEdit, generateId, getPerpendicularWallMoveAxis, getPlannedLinkedWallUpdates, planAttachedWallChanges, planAttachedWallUpdates, planWallEndRejoins, planWallMoveJunctions, resolveMovedWallSupportSlabPatch, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { CursorSphere, EDITOR_LAYER, getSegmentGridStep, isSegmentLongEnough, isTypingTarget, isWallRunFree, markToolCancelConsumed, nearestWallParallelTarget, publishWallParallelGuide, snapBuildingLocalToWorldGrid, snapScalarToGrid, triggerSFX, useEditor, WALL_CONNECT_SNAP_RADIUS, wallParallelTargets, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { BufferGeometry, DoubleSide, Float32BufferAttribute } from 'three';
@@ -233,11 +233,43 @@ export const MoveWallTool = ({ node }) => {
             const nextEnd = [center[0] + rotatedHalf[0], center[1] + rotatedHalf[1]];
             return { start: nextStart, end: nextEnd };
         };
+        // The level's other walls, which the moving wall lines up with when parallel
+        // (`wallParallelTargets`). Recomputed when R / T turns the wall.
+        const levelWalls = Object.values(useScene.getState().nodes).filter((entry) => entry?.type === 'wall' && (entry.parentId ?? null) === levelId);
+        const movingWall = levelWalls.find((entry) => entry.id === nodeId);
+        let parallelTargets = null;
+        const getParallelTargets = (axis) => {
+            const rotation = pendingRotationRef.current;
+            if (parallelTargets?.rotation !== rotation) {
+                const turned = buildWallFromCenter(originalCenter);
+                parallelTargets = {
+                    rotation,
+                    targets: movingWall
+                        ? wallParallelTargets({ ...movingWall, ...turned }, axis, levelWalls)
+                        : [],
+                };
+            }
+            return parallelTargets.targets;
+        };
+        let lastLineUp = null;
+        // Alt moves the wall exactly with the pointer, as in the floor plan.
+        let altHeld = false;
+        const onPointerMove = (event) => {
+            altHeld = event.altKey;
+        };
         const getMovePlan = (nextStart, nextEnd) => planWallMoveJunctions(linkedOriginalsRef.current, originalStart, originalEnd, nextStart, nextEnd);
         const getLinkedPreviewUpdates = (plan, nextStart, nextEnd) => {
             const movedUpdates = getPlannedLinkedWallUpdates(plan, originalStart, originalEnd, nextStart, nextEnd);
             const movedById = new Map(movedUpdates.map((entry) => [entry.id, entry]));
-            return linkedOriginalsRef.current.map((wall) => movedById.get(wall.id) ?? { id: wall.id, start: wall.start, end: wall.end });
+            const linkedIds = new Set(linkedOriginalsRef.current.map((wall) => wall.id));
+            // Walls T'd into this one stay on it, stretched along their own line.
+            const attached = isNew
+                ? []
+                : planAttachedWallUpdates(Object.values(dragNodes).filter((entry) => entry.type === 'wall' && entry.id !== nodeId && !linkedIds.has(entry.id)), originalStart, originalEnd, nextStart, nextEnd);
+            return [
+                ...linkedOriginalsRef.current.map((wall) => movedById.get(wall.id) ?? { id: wall.id, start: wall.start, end: wall.end }),
+                ...attached,
+            ];
         };
         const applyPreview = (nextStart, nextEnd) => {
             const previous = previewRef.current ?? { start: originalStart, end: originalEnd };
@@ -309,6 +341,7 @@ export const MoveWallTool = ({ node }) => {
             const rawDeltaZ = rawZ - anchor[1];
             if (!hasDraggedRef.current && Math.hypot(rawDeltaX, rawDeltaZ) < 1e-6)
                 return;
+            const free = isWallRunFree({ altKey: altHeld });
             // 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
@@ -320,31 +353,41 @@ export const MoveWallTool = ({ node }) => {
             // the displacement alone preserves any pre-existing off-grid
             // offset, so the wall could only ever sit at `originalCentre ±
             // k·snapStep` — never on actual grid lines. Snapping the wall's
-            // own perpendicular coordinate fixes that.
+            // own perpendicular coordinate fixes that. A parallel wall the wall
+            // lines up with wins over the grid.
             const axis = moveAxisRef.current;
             let deltaX;
             let deltaZ;
+            let lineUp = null;
             if (axis) {
                 const originalProj = originalCenter[0] * axis[0] + originalCenter[1] * axis[1];
                 const rawProj = originalProj + rawDeltaX * axis[0] + rawDeltaZ * axis[1];
-                const snappedProj = snapScalarToGrid(rawProj, snapStep);
+                lineUp = free ? null : nearestWallParallelTarget(getParallelTargets(axis), rawProj);
+                const snappedProj = lineUp
+                    ? lineUp.position
+                    : snapScalarToGrid(rawProj, free ? 0 : snapStep);
                 const perpDelta = snappedProj - originalProj;
                 deltaX = axis[0] * perpDelta;
                 deltaZ = axis[1] * perpDelta;
             }
             else {
-                // Snap the resulting wall center to the WORLD XZ grid (projected
-                // back into building-local), then express the result as a delta
-                // from the original centre. Without this, a rotated building
-                // dragged the wall along its local axes instead of world ones.
+                // Snap the resulting wall center to the building's own grid lattice
+                // (the one the wall tool drafts on, square to a turned house), then
+                // express the result as a delta from the original centre.
                 const targetLocal = [
                     originalCenter[0] + rawDeltaX,
                     originalCenter[1] + rawDeltaZ,
                 ];
-                const snappedLocal = snapBuildingLocalToWorldGrid(targetLocal, snapStep);
+                const snappedLocal = free
+                    ? targetLocal
+                    : snapBuildingLocalToWorldGrid(targetLocal, snapStep);
                 deltaX = snappedLocal[0] - originalCenter[0];
                 deltaZ = snappedLocal[1] - originalCenter[1];
             }
+            if (lineUp !== lastLineUp) {
+                lastLineUp = lineUp;
+                publishWallParallelGuide(lineUp);
+            }
             const constrainedGridPos = [anchor[0] + deltaX, anchor[1] + deltaZ];
             if (previousGridPosRef.current &&
                 (constrainedGridPos[0] !== previousGridPosRef.current[0] ||
@@ -422,10 +465,28 @@ export const MoveWallTool = ({ node }) => {
             // The drag writes nothing to the store (the preview is live overrides), so history is
             // paused only for this drop. Keyed by the moving wall: in split view the 2D move overlay
             // co-owns the gesture, and commitStep lifts its pause too.
-            const changes = planWallEndRejoins(sceneState.nodes, commitUpdates.map(({ id }) => id), WALL_CONNECT_SNAP_RADIUS, {
-                update: wallUpdates,
+            // The moved and stretched walls and the jogs take over any stretch of a
+            // parallel wall they now run along; jogs on the outline are outside walls.
+            // Walls T'd into this one follow it, what hangs on them staying put.
+            const attachedChanges = isNew
+                ? []
+                : planAttachedWallChanges(sceneState.nodes, nodeId, originalStart, originalEnd, preview.start, preview.end, new Set([
+                    ...linkedOriginalsRef.current.map((wall) => wall.id),
+                    ...collapsedLinkedWallIds,
+                ]));
+            const changes = finishWallEdit(sceneState.nodes, planWallEndRejoins(sceneState.nodes, commitUpdates.map(({ id }) => id), WALL_CONNECT_SNAP_RADIUS, {
+                update: [...wallUpdates, ...attachedChanges],
                 create: wallCreates,
                 delete: Array.from(collapsedLinkedWallIds),
+            }), {
+                winnerIds: [
+                    ...commitUpdates.map(({ id }) => id),
+                    ...attachedChanges.flatMap(({ id }) => sceneState.nodes[id]?.type === 'wall' ? [id] : []),
+                    ...wallCreates.map(({ node }) => node.id),
+                ],
+                movedWallId: nodeId,
+                bridgeIds: wallCreates.map(({ node }) => node.id),
+                mintId: () => generateId('wall'),
             });
             const drop = beginSceneHistoryPauseSession(useScene, { gesture: nodeId });
             try {
@@ -500,9 +561,12 @@ export const MoveWallTool = ({ node }) => {
         };
         emitter.on('grid:move', onGridMove);
         emitter.on('tool:cancel', onCancel);
+        window.addEventListener('pointermove', onPointerMove);
         window.addEventListener('pointerup', onPointerUp);
         window.addEventListener('keydown', onKeyDown);
         return () => {
+            if (lastLineUp)
+                publishWallParallelGuide(null);
             if (shouldRestoreOnCleanup) {
                 // `shouldRestoreOnCleanup` is only true if neither `onPointerUp`
                 // (commit branch) nor `onCancel` ran — i.e., the unmount came
@@ -517,6 +581,7 @@ export const MoveWallTool = ({ node }) => {
             }
             emitter.off('grid:move', onGridMove);
             emitter.off('tool:cancel', onCancel);
+            window.removeEventListener('pointermove', onPointerMove);
             window.removeEventListener('pointerup', onPointerUp);
             window.removeEventListener('keydown', onKeyDown);
         };

package/dist/wall/paint.d.ts

@@ -1,8 +1,8 @@
-import { type AnyNode, type WallPaintRole as CoreWallPaintRole, type PaintCapability, type WallFace, type WallNode, type WallSurfaceSlotId, wallRegionRole, wallRoomFaceRole, wallRoomFinishRole } from '@pascal-app/core';
+import { type AnyNode, type WallPaintRole as CoreWallPaintRole, type PaintCapability, type RailingWallSlotId, type WallFace, type WallNode, type WallSurfaceSlotId, wallRegionRole, wallRoomFaceRole, wallRoomFinishRole } from '@pascal-app/core';
 import { type BufferGeometry, type Ray } from 'three';
 type ResolvedWallPaintRole = {
     kind: 'slot';
-    slotId: WallSurfaceSlotId | CurtainWallRole;
+    slotId: WallSurfaceSlotId | CurtainWallRole | RailingWallSlotId;
 } | Exclude<CoreWallPaintRole, {
     kind: 'slot';
 }>;

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,EACL,KAAK,OAAO,EAGZ,KAAK,aAAa,IAAI,iBAAiB,EAMvC,KAAK,eAAe,EAapB,KAAK,QAAQ,EAEb,KAAK,QAAQ,EACb,KAAK,iBAAiB,EAEtB,cAAc,EACd,gBAAgB,EAChB,kBAAkB,EAEnB,MAAM,kBAAkB,CAAA;AAQzB,OAAO,EACL,KAAK,cAAc,EAInB,KAAK,GAAG,EAGT,MAAM,OAAO,CAAA;AAgBd,KAAK,qBAAqB,GACtB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,iBAAiB,GAAG,eAAe,CAAA;CAAE,GAC7D,OAAO,CAAC,iBAAiB,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAAA;AAIhD,QAAA,MAAM,kBAAkB,YAAI,eAAe,EAAE,eAAe,EAAE,eAAe,CAAU,CAAA;AACvF,KAAK,eAAe,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAA;AAM1D,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,CAAA;AAE/D,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,qBAAqB,GAAG,IAAI,CAK7E;AA6BD;;;;GAIG;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;IACT,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,SAAS,CAAC,CAAC,CAAA;CACtD,GAAG,MAAM,GAAG,IAAI,CAsChB;AA8ID;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,cAAc,EACxB,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,GAChE,cAAc,CAAC,QAAQ,CAAC,GAAG,IAAI,CA4CjC;AA2FD;;;;;GAKG;AACH,eAAO,MAAM,SAAS,EAAE,eAkCvB,CAAA"}
+{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/wall/paint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAGZ,KAAK,aAAa,IAAI,iBAAiB,EAMvC,KAAK,eAAe,EAOpB,KAAK,iBAAiB,EAOtB,KAAK,QAAQ,EAEb,KAAK,QAAQ,EACb,KAAK,iBAAiB,EAEtB,cAAc,EACd,gBAAgB,EAChB,kBAAkB,EAEnB,MAAM,kBAAkB,CAAA;AAQzB,OAAO,EACL,KAAK,cAAc,EAInB,KAAK,GAAG,EAGT,MAAM,OAAO,CAAA;AAiBd,KAAK,qBAAqB,GACtB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,iBAAiB,GAAG,eAAe,GAAG,iBAAiB,CAAA;CAAE,GACjF,OAAO,CAAC,iBAAiB,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAAA;AAIhD,QAAA,MAAM,kBAAkB,YAAI,eAAe,EAAE,eAAe,EAAE,eAAe,CAAU,CAAA;AACvF,KAAK,eAAe,GAAG,CAAC,OAAO,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAA;AAS1D,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,CAAA;AAE/D,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,qBAAqB,GAAG,IAAI,CAK7E;AA6BD;;;;GAIG;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;IACT,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,SAAS,CAAC,CAAC,CAAA;CACtD,GAAG,MAAM,GAAG,IAAI,CAuChB;AAgJD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,cAAc,EACxB,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,CAAC,IAAI,EAAE,QAAQ,EAAE,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,GAAG,IAAI,GAChE,cAAc,CAAC,QAAQ,CAAC,GAAG,IAAI,CA4CjC;AA2FD;;;;;GAKG;AACH,eAAO,MAAM,SAAS,EAAE,eAkCvB,CAAA"}

package/dist/wall/paint.js

@@ -3,14 +3,17 @@ import { getWallFaceBaseAt, getWallFinishData, getWallFinishRefs, hasMaterialsFo
 import { Raycaster, Vector3, } from 'three';
 import { buildSlotPreviewMaterial, createSlotPaintCapability, previewSlotByUserData, resolveSlotPaintMaterialRef, } from '../shared/slot-paint.js';
 import { swapPreviewMaterial } from '../shared/swap-preview-material.js';
+import { RAILING_WALL_SLOTS } from './railing-wall-materials.js';
 const WALL_SLOT_IDS = new Set(Object.keys(WALL_SURFACE_SLOT_DEFAULTS));
 // A curtain wall paints its frame, glass and solid panels (palette 0..2) instead of faces.
 const CURTAIN_WALL_ROLES = ['curtain-frame', 'curtain-glass', 'curtain-solid'];
 const isCurtainWallRole = (role) => CURTAIN_WALL_ROLES.includes(role);
+// A railing paints its posts and rails, and its infill (palette 0..1).
+const isRailingWallRole = (role) => RAILING_WALL_SLOTS.includes(role);
 const FACE_MATERIAL_INDEX = { a: 1, b: 2 };
 export { wallRegionRole, wallRoomFaceRole, wallRoomFinishRole };
 export function parseWallPaintRole(role) {
-    return parseCoreWallPaintRole(role, (slotId) => WALL_SLOT_IDS.has(slotId) || isCurtainWallRole(slotId));
+    return parseCoreWallPaintRole(role, (slotId) => WALL_SLOT_IDS.has(slotId) || isCurtainWallRole(slotId) || isRailingWallRole(slotId));
 }
 const wallSlotRaycaster = new Raycaster();
 setSurfaceRaycastLayers(wallSlotRaycaster.layers);
@@ -45,13 +48,14 @@ function resolveWallSlotByRay(node, ray) {
  */
 export function resolveWallRole(args) {
     const { node, hitObject, localPosition, ray } = args;
-    if (node.wallType === 'curtain') {
+    if (node.wallType === 'curtain' || node.wallType === 'railing') {
         const root = sceneRegistry.nodes.get(node.id);
         if (!(root && ray && hasMaterialsForGroups(root)))
             return null;
         wallSlotRaycaster.ray.copy(ray);
         const hit = wallSlotRaycaster.intersectObject(root, false)[0];
-        return CURTAIN_WALL_ROLES[hit?.face?.materialIndex ?? -1] ?? null;
+        const roles = node.wallType === 'curtain' ? CURTAIN_WALL_ROLES : RAILING_WALL_SLOTS;
+        return roles[hit?.face?.materialIndex ?? -1] ?? null;
     }
     const directSlotId = hitObject?.userData?.slotId;
     if (typeof directSlotId === 'string' && WALL_SLOT_IDS.has(directSlotId)) {
@@ -117,11 +121,14 @@ function refToEffective(ref) {
 /**
  * The wall mesh's palette entry a non-face slot draws with, when it is part of
  * the wall body rather than its own mesh: a curtain wall's frame / glass /
- * solid panels (0..2), or the underpinning's stemwall (a finish ref, 3..).
+ * solid panels (0..2), a railing's frame / infill (0..1), or the underpinning's
+ * stemwall (a finish ref, 3..).
  */
 function wallPaletteSlotIndex(wall, slotId, mesh) {
     if (isCurtainWallRole(slotId))
         return CURTAIN_WALL_ROLES.indexOf(slotId);
+    if (isRailingWallRole(slotId))
+        return RAILING_WALL_SLOTS.indexOf(slotId);
     if (slotId !== 'foundation' || !wall.underpinning)
         return null;
     const ref = wall.slots?.foundation ?? WALL_SURFACE_SLOT_DEFAULTS.foundation;

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

@@ -1,5 +1,5 @@
-import { type AnyNode, type AnyNodeId, type WallNode } from '@pascal-app/core';
-import { type PanelRow } from '@pascal-app/editor';
+import { type AnyNode, type AnyNodeId, type WallAssemblyExteriorFinish, type WallNode } from '@pascal-app/core';
+import { type MultiPanelControl, type PanelRow } from '@pascal-app/editor';
 export type WallReferenceValue = 'outside' | 'center' | 'inside' | 'left' | 'right';
 export type WallReferenceOption = {
     label: string;
@@ -19,4 +19,19 @@ export declare function wallReferenceModel(walls: readonly WallNode[], nodes: Re
     apply: (next: WallReferenceValue) => void;
 };
 export declare function wallSettings(node: WallNode, nodes: Record<AnyNodeId, AnyNode>, update: (patch: Partial<WallNode>) => void, reshape?: () => void): PanelRow[];
+export declare const EXTERIOR_FINISH_OPTIONS: Array<{
+    value: WallAssemblyExteriorFinish;
+    label: string;
+}>;
+/** Cited default thickness for a finish the user just switched to. */
+export declare const EXTERIOR_FINISH_DEFAULT: Record<WallAssemblyExteriorFinish, number>;
+/**
+ * The wall's assembly and thickness controls for a multi-selection, as the
+ * single panel offers them: the Preset (wall type) and the Exterior cladding,
+ * each applied to every selected standard wall in one undo step, and the
+ * thickness of the walls whose assembly sets it, which the selection reads but
+ * cannot type over (the Thickness field edits the others). Curtain walls and
+ * railings take no assembly and are left out of all three.
+ */
+export declare function wallAssemblyMultiControls(selection: readonly WallNode[]): MultiPanelControl[];
 //# sourceMappingURL=panel-model.d.ts.map

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

@@ -1 +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,EAed,KAAK,QAAQ,EAGd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAEL,KAAK,QAAQ,EAGd,MAAM,oBAAoB,CAAA;AAiB3B,MAAM,MAAM,kBAAkB,GAAG,SAAS,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,CAAA;AACnF,MAAM,MAAM,mBAAmB,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,kBAAkB,CAAA;CAAE,CAAA;AAqB9E;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,SAAS,QAAQ,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC;;;kBAsB9E,kBAAkB;EAYnC;AAED,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,CA8LZ"}
+{"version":3,"file":"panel-model.d.ts","sourceRoot":"","sources":["../../src/wall/panel-model.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EA2Bd,KAAK,0BAA0B,EAC/B,KAAK,QAAQ,EAMd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAEL,KAAK,iBAAiB,EACtB,KAAK,QAAQ,EAGd,MAAM,oBAAoB,CAAA;AAkB3B,MAAM,MAAM,kBAAkB,GAAG,SAAS,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,GAAG,OAAO,CAAA;AACnF,MAAM,MAAM,mBAAmB,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,kBAAkB,CAAA;CAAE,CAAA;AAqB9E;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,SAAS,QAAQ,EAAE,EAAE,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC;;;kBAsB9E,kBAAkB;EAYnC;AAED,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,CAiNZ;AAED,eAAO,MAAM,uBAAuB,EAAE,KAAK,CAAC;IAAE,KAAK,EAAE,0BAA0B,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAQ7F,CAAA;AAEH,sEAAsE;AACtE,eAAO,MAAM,uBAAuB,EAAE,MAAM,CAAC,0BAA0B,EAAE,MAAM,CAO9E,CAAA;AAiCD;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,EAAE,SAAS,QAAQ,EAAE,GAAG,iBAAiB,EAAE,CAoF7F"}

package/dist/wall/panel-model.js

@@ -1,9 +1,10 @@
-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 { BRICK_AIR_SPACE, BRICK_VENEER, DEFAULT_WALL_THICKNESS, FIBER_CEMENT, faceOnLine, formatLinearMeasurement, GROUND_SUPPORT_ID, getClampedWallCurveOffset, getMaxWallCurveOffset, getWallCurveLength, justificationForFaceOnLine, normalizeWallCurveOffset, planWallJustification, projectWallTypes, roomSideFaces, runAsSingleSceneHistoryStep, SIDING_LAP, STONE_VENEER_UNVERIFIED, STUCCO_3_COAT, terrainSupportLift, useScene, WALL_ASSEMBLY_PRESETS, WALL_CHAIR_RAIL_DEFAULT, WALL_CROWN_DEFAULT, WALL_SKIRTING_DEFAULT, wallAssemblyFromLegacy, wallAssemblyPatch, wallAssemblyToLegacy, 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.js';
 import { hasWallCurveBlockingChildren } from './curve-eligibility.js';
 import { buildWallLengthPatch } from './length-patch.js';
+import { railingWallRows } from './railing-wall-panel-model.js';
 const profiles = {
     skirting: ['flat', 'base-modern', 'base-colonial', 'base-shoe', 'base-ogee'],
     crown: ['flat', 'crown-cove', 'crown-ogee', 'crown-craftsman', 'crown-layered'],
@@ -78,7 +79,7 @@ export function wallSettings(node, nodes, update, reshape = () => {
     useViewer.getState().setSelection({ selectedIds: [] });
 }) {
     const rows = [];
-    const height = resolveWallOpeningCeiling(node, nodes);
+    const height = resolveWallOpeningCeiling(node, nodes, 0);
     const repairBase = () => ({
         supportOffset: undefined,
         ...(node.supportSlabId === GROUND_SUPPORT_ID &&
@@ -129,17 +130,24 @@ export function wallSettings(node, nodes, update, reshape = () => {
     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 }));
+    // A railing keeps its own height and its posts set its thickness: its rows say so instead.
+    const railing = node.wallType === 'railing';
+    if (railing)
+        rows.push(...railingWallRows(node, update));
+    else {
+        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 }));
+        number('Dimensions', 'end-height-offset', 'End height offset', node.endHeightOffset ?? 0, -(height - 0.01), Infinity, 0.05, (endHeightOffset) => update({ endHeightOffset }));
+        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));
@@ -153,11 +161,15 @@ export function wallSettings(node, nodes, update, reshape = () => {
                 onSelect: reshape,
             });
     }
-    for (const [key, title, defaults] of [
-        ['skirting', 'Skirting', WALL_SKIRTING_DEFAULT],
-        ['crown', 'Crown molding', WALL_CROWN_DEFAULT],
-        ['chairRail', 'Chair rail', WALL_CHAIR_RAIL_DEFAULT],
-    ]) {
+    // A railing has no faces to trim.
+    const trims = railing
+        ? []
+        : [
+            ['skirting', 'Skirting', WALL_SKIRTING_DEFAULT],
+            ['crown', 'Crown molding', WALL_CROWN_DEFAULT],
+            ['chairRail', 'Chair rail', WALL_CHAIR_RAIL_DEFAULT],
+        ];
+    for (const [key, title, defaults] of trims) {
         const trim = { ...defaults, ...node[key] };
         const patch = (value) => update(wallTrimPatch(node, key, value));
         choice(title, `${key}-enabled`, title, trim.enabled ? 'On' : 'Off', () => patch({ enabled: !trim.enabled }));
@@ -173,3 +185,132 @@ export function wallSettings(node, nodes, update, reshape = () => {
     }
     return rows;
 }
+export 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' },
+];
+/** Cited default thickness for a finish the user just switched to. */
+export 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,
+};
+const PLAIN_PRESET = 'none';
+const CUSTOM_PRESET = 'custom';
+/**
+ * The wall types a wall's Preset can be: the cited presets, then the project's own
+ * (`SiteNode.wallTypes`, by label), each applied the same way (`wallAssemblyPatch`).
+ */
+function wallPresetChoices() {
+    const { nodes, rootNodeIds } = useScene.getState();
+    return [...WALL_ASSEMBLY_PRESETS, ...projectWallTypes(nodes, rootNodeIds)];
+}
+/**
+ * The assembly preset a wall shows: its preset or project type, a custom stack
+ * (also one from a project type this project does not have), or none (a single layer).
+ */
+function wallPresetValue(wall, known) {
+    const presetId = wall.assembly?.presetId;
+    if (presetId && known.has(presetId))
+        return presetId;
+    return wall.assembly ? CUSTOM_PRESET : PLAIN_PRESET;
+}
+function shared(values) {
+    return values.length > 0 && values.every((value) => value === values[0]) ? values[0] : null;
+}
+function writeWalls(updates) {
+    if (updates.length === 0)
+        return;
+    runAsSingleSceneHistoryStep(useScene, () => useScene.getState().updateNodes(updates));
+}
+/**
+ * The wall's assembly and thickness controls for a multi-selection, as the
+ * single panel offers them: the Preset (wall type) and the Exterior cladding,
+ * each applied to every selected standard wall in one undo step, and the
+ * thickness of the walls whose assembly sets it, which the selection reads but
+ * cannot type over (the Thickness field edits the others). Curtain walls and
+ * railings take no assembly and are left out of all three.
+ */
+export function wallAssemblyMultiControls(selection) {
+    const walls = selection.filter((wall) => wall.wallType !== 'curtain' && wall.wallType !== 'railing');
+    if (walls.length === 0)
+        return [];
+    const controls = [];
+    const withAssembly = walls.filter((wall) => wall.assembly);
+    if (withAssembly.length > 0) {
+        const { unit, metricNotation } = useViewer.getState();
+        const thickness = shared(withAssembly.map((wall) => Math.round((wall.thickness ?? DEFAULT_WALL_THICKNESS) * 1e6)));
+        // Only the walls with an assembly: the Thickness field edits the rest.
+        const every = withAssembly.length === selection.length;
+        controls.push({
+            id: 'wall-thickness-assembly',
+            kind: 'readout',
+            section: 'Dimensions',
+            label: every ? 'Thickness' : 'Assembly walls',
+            value: thickness === null
+                ? 'Mixed'
+                : formatLinearMeasurement(thickness / 1e6, unit, metricNotation),
+            detail: every
+                ? 'from assembly'
+                : `${withAssembly.length} of ${selection.length}, from assembly`,
+        });
+    }
+    const choices = wallPresetChoices();
+    const known = new Set(choices.map((choice) => choice.id));
+    const preset = shared(walls.map((wall) => wallPresetValue(wall, known)));
+    controls.push({
+        id: 'wall-assembly-preset',
+        kind: 'select',
+        section: 'Assembly',
+        label: 'Preset',
+        options: [
+            { value: PLAIN_PRESET, label: 'None (single layer)' },
+            ...(preset === CUSTOM_PRESET ? [{ value: CUSTOM_PRESET, label: 'Custom' }] : []),
+            ...choices.map((entry) => ({ value: entry.id, label: entry.label })),
+        ],
+        value: preset,
+        onChange: (value) => {
+            if (value === CUSTOM_PRESET)
+                return;
+            const chosen = choices.find((entry) => entry.id === value);
+            writeWalls(walls.map((wall) => ({
+                id: wall.id,
+                data: chosen
+                    ? wallAssemblyPatch(structuredClone(chosen.assembly))
+                    : { assembly: undefined },
+            })));
+        },
+    });
+    // The cladding edit works on the WS5 view of each stack, as the single panel's
+    // Exterior row does; it shows only when every wall has one.
+    const legacy = walls.map((wall) => (wall.assembly ? wallAssemblyToLegacy(wall.assembly) : null));
+    if (legacy.every((entry) => entry !== null)) {
+        controls.push({
+            id: 'wall-assembly-exterior',
+            kind: 'select',
+            section: 'Assembly',
+            label: 'Exterior',
+            options: EXTERIOR_FINISH_OPTIONS,
+            value: shared(legacy.map((entry) => entry.exterior?.finish ?? 'none')),
+            onChange: (value) => {
+                const finish = value;
+                writeWalls(walls.map((wall, index) => ({
+                    id: wall.id,
+                    data: wallAssemblyPatch(wallAssemblyFromLegacy({
+                        ...legacy[index],
+                        exterior: { finish, thickness: EXTERIOR_FINISH_DEFAULT[finish] },
+                        preset: undefined,
+                    })),
+                })));
+            },
+        });
+    }
+    return controls;
+}

package/dist/wall/panel.d.ts

@@ -1,2 +1,10 @@
 export default function WallPanel(): import("react").JSX.Element | null;
+/**
+ * The stud spacings to pick from, the framing list roofs and ceilings use, keeping a stored one
+ * off the list; and the one stored (null for the framer's default).
+ */
+export declare function studSpacingChoices(stored: number | undefined): {
+    sizes: readonly number[];
+    current: number | null;
+};
 //# sourceMappingURL=panel.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/wall/panel.tsx"],"names":[],"mappings":"AAwHA,MAAM,CAAC,OAAO,UAAU,SAAS,uCA4XhC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/wall/panel.tsx"],"names":[],"mappings":"AAoJA,MAAM,CAAC,OAAO,UAAU,SAAS,uCAsdhC;AA4TD;;;GAGG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS;;;EAU5D"}