@pascal-app/nodes 1.0.1 → 1.0.4

package/dist/wall/floorplan-tool.js

@@ -0,0 +1,106 @@
+'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, useWallDrawVariant, } from '@pascal-app/editor';
+import { useEffect, useRef, useState } from 'react';
+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) {
+    return useWallDrawVariant() === '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 moves the snapped cursor; the wall draft's tick as the dragged
+        // corner steps to a new spot.
+        const stopTicks = useFloorplanDraftPreview.subscribe((state, previous) => {
+            const [now, before] = [state.cursorPoint, previous.cursorPoint];
+            if (state.wallRectangleDraftStart &&
+                now &&
+                before &&
+                (now[0] !== before[0] || now[1] !== before[1]))
+                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 () => {
+            stopTicks();
+            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

@@ -1,10 +1,12 @@
-import { type AnyNode, type FloorplanGeometry, type GeometryContext, type WallMiterData, type WallNode } from '@pascal-app/core';
+import { type AnyNode, type FloorplanGeometry, type GeometryContext, type WallLayerMiterData, type WallMiterData, type WallNode } from '@pascal-app/core';
 import { type WallConstructionDimensionPlan } from './construction-dimensions';
 declare const WALL_DIMENSION_REFERENCES: readonly ["finished-faces", "centerline", "stud-faces"];
 type WallDimensionReference = (typeof WALL_DIMENSION_REFERENCES)[number];
 export type WallFloorplanLevelData = {
     miters: WallMiterData;
     documentMiters: WallMiterData;
+    layerMiters: WallLayerMiterData;
+    documentLayerMiters: WallLayerMiterData;
     constructionDimensionsByReference: Record<WallDimensionReference, WallConstructionDimensionPlan>;
 };
 export declare function computeWallFloorplanLevelData({ siblings, nodes, }: {

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,EAGZ,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAYpB,KAAK,kBAAkB,EAEvB,KAAK,aAAa,EAClB,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAQzB,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;AAsBxE,MAAM,MAAM,sBAAsB,GAAG;IACnC,MAAM,EAAE,aAAa,CAAA;IACrB,cAAc,EAAE,aAAa,CAAA;IAC7B,WAAW,EAAE,kBAAkB,CAAA;IAC/B,mBAAmB,EAAE,kBAAkB,CAAA;IACvC,iCAAiC,EAAE,MAAM,CAAC,sBAAsB,EAAE,6BAA6B,CAAC,CAAA;CACjG,CAAA;AAqJD,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,CA0CzB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAgPjG"}

package/dist/wall/floorplan.js

@@ -1,7 +1,8 @@
-import { calculateLevelMiters, getWallCurveFrameAt, getWallCurveLength, getWallMidpointHandlePoint, getWallPlanFootprint, getWallThickness, isCurvedWall, } from '@pascal-app/core';
-import { floorplanGeometryMetadata, readFloorplanContext } from '@pascal-app/editor';
+import { calculateLevelLayerMiters, calculateLevelMiters, getWallBodyCenterOffset, getWallCurveFrameAt, getWallCurveLength, getWallEffectiveHeightForNodes, getWallFaceOffsets, getWallLayerPolylines, getWallLocalFaceZ, getWallMidpointHandlePoint, getWallPlanFootprint, getWallThickness, isCurvedWall, wallLayerBoundaryOffsets, } from '@pascal-app/core';
+import { floorplanGeometryMetadata, readFloorplanContext, WALL_PUSH_AFFORDANCE, } 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
@@ -21,6 +22,148 @@ function floorplanWallThickness(wall) {
 function exaggerateWallThickness(wall) {
     return { ...wall, thickness: floorplanWallThickness(wall) };
 }
+// Assembly offsets are measured from the body centre; a justified wall's body
+// sits off its reference line, so the layer lines move with it.
+function wallLayerOffsets(wall) {
+    const centre = getWallBodyCenterOffset(wall);
+    return wallLayerBoundaryOffsets(wall, getWallThickness(wall)).map((offset) => offset + centre);
+}
+// --- Assembly layer lines ---------------------------------------------------
+//
+// The mitered outer footprint is unchanged; these are the boundaries BETWEEN
+// the assembly's layers, offset in from the footprint and mitered at the same
+// corners so they meet cleanly (see `calculateLevelLayerMiters` in
+// `packages/core/src/systems/wall/wall-assembly.ts` for the corner, T-junction
+// and different-assembly rules).
+//
+// In `document` purpose the framing cavity gets the standard poché (a light
+// hatch) and the finish layers are thin solid lines. In `edit` purpose the
+// footprint keeps today's look and the layer lines are drawn at reduced
+// opacity with no poché, so the editor stays readable.
+//
+// Curved walls are skipped: the offset miter is a straight-line construction
+// and a curved wall's layers would need arc offsets. Stated plainly rather
+// than approximated — a curved wall draws exactly as it does today.
+const LAYER_LINE_STROKE = '#1f2937';
+const LAYER_LINE_WIDTH_DOCUMENT = 0.008;
+const LAYER_LINE_WIDTH_EDIT = 0.006;
+const LAYER_LINE_OPACITY_EDIT = 0.35;
+const FRAMING_POCHE_COLOR = '#94a3b8';
+const FRAMING_POCHE_OPACITY = 0.28;
+/** Along-wall spans, measured from `wall.start`, occupied by doors / windows. */
+function openingSpans(wall, children) {
+    const spans = [];
+    for (const child of children) {
+        if (child.type !== 'door' && child.type !== 'window')
+            continue;
+        const distance = child.position?.[0];
+        const width = child.width;
+        if (typeof distance !== 'number' || typeof width !== 'number' || width <= 0)
+            continue;
+        spans.push([distance - width / 2, distance + width / 2]);
+    }
+    return spans.sort((a, b) => a[0] - b[0]);
+}
+/**
+ * Cut one mitered layer boundary at the openings hosted by the wall, so an
+ * opening reads as a hole through EVERY layer and not just the footprint.
+ * Parameterised along the wall direction, which is exact for straight walls.
+ */
+function cutAtOpenings(line, wall, spans) {
+    const segment = {
+        start: [line.start.x, line.start.y],
+        end: [line.end.x, line.end.y],
+    };
+    if (spans.length === 0)
+        return [segment];
+    const dx = wall.end[0] - wall.start[0];
+    const dy = wall.end[1] - wall.start[1];
+    const length = Math.hypot(dx, dy);
+    if (length < 1e-9)
+        return [segment];
+    const ux = dx / length;
+    const uy = dy / length;
+    const along = (p) => (p.x - wall.start[0]) * ux + (p.y - wall.start[1]) * uy;
+    const a0 = along(line.start);
+    const a1 = along(line.end);
+    if (Math.abs(a1 - a0) < 1e-9)
+        return [segment];
+    const at = (t) => [
+        line.start.x + (line.end.x - line.start.x) * t,
+        line.start.y + (line.end.y - line.start.y) * t,
+    ];
+    const toT = (distance) => (distance - a0) / (a1 - a0);
+    const pieces = [];
+    let cursor = 0;
+    for (const [lo, hi] of spans) {
+        const tLo = Math.max(0, Math.min(1, toT(lo)));
+        const tHi = Math.max(0, Math.min(1, toT(hi)));
+        const from = Math.min(tLo, tHi);
+        const to = Math.max(tLo, tHi);
+        if (from > cursor + 1e-6)
+            pieces.push({ start: at(cursor), end: at(from) });
+        cursor = Math.max(cursor, to);
+    }
+    if (cursor < 1 - 1e-6)
+        pieces.push({ start: at(cursor), end: at(1) });
+    return pieces;
+}
+/**
+ * The layer-boundary lines plus the framing poché for one wall.
+ * `wall` is the (possibly exaggerated) wall the footprint was built from, so
+ * the stack is scaled to whatever thickness is actually drawn.
+ */
+function buildWallAssemblyLayers(wall, source, layerMiters, children, documentMode) {
+    if (!source.assembly || isCurvedWall(source))
+        return [];
+    const offsets = wallLayerOffsets(wall);
+    if (offsets.length < 3)
+        return [];
+    const lines = getWallLayerPolylines(wall, layerMiters, offsets);
+    if (lines.length < 3)
+        return [];
+    const spans = openingSpans(source, children);
+    const out = [];
+    // Framing poché first, so the boundary lines sit on top of it.
+    if (documentMode) {
+        for (let i = 0; i < lines.length - 1; i += 1) {
+            if (lines[i + 1].role !== 'framing')
+                continue;
+            const outer = lines[i];
+            const inner = lines[i + 1];
+            out.push({
+                kind: 'hatch',
+                points: [
+                    [outer.start.x, outer.start.y],
+                    [outer.end.x, outer.end.y],
+                    [inner.end.x, inner.end.y],
+                    [inner.start.x, inner.start.y],
+                ],
+                color: FRAMING_POCHE_COLOR,
+                opacity: FRAMING_POCHE_OPACITY,
+            });
+        }
+    }
+    // Interior boundaries only — index 0 and the last index are the two outer
+    // faces, already drawn by the mitered footprint polygon.
+    for (let i = 1; i < lines.length - 1; i += 1) {
+        for (const piece of cutAtOpenings(lines[i], source, spans)) {
+            out.push({
+                kind: 'line',
+                x1: piece.start[0],
+                y1: piece.start[1],
+                x2: piece.end[0],
+                y2: piece.end[1],
+                stroke: LAYER_LINE_STROKE,
+                strokeWidth: documentMode ? LAYER_LINE_WIDTH_DOCUMENT : LAYER_LINE_WIDTH_EDIT,
+                opacity: documentMode ? 1 : LAYER_LINE_OPACITY_EDIT,
+                pointerEvents: 'none',
+                metadata: floorplanGeometryMetadata({ renderPass: 'overlay' }),
+            });
+        }
+    }
+    return out;
+}
 export function computeWallFloorplanLevelData({ siblings, nodes, }) {
     const walls = siblings.map(exaggerateWallThickness);
     const constructionDimensionsByReference = {};
@@ -46,9 +189,14 @@ export function computeWallFloorplanLevelData({ siblings, nodes, }) {
             },
         });
     }
+    const documentWalls = [...siblings];
+    const miters = calculateLevelMiters(walls);
+    const documentMiters = calculateLevelMiters(documentWalls);
     return {
-        miters: calculateLevelMiters(walls),
-        documentMiters: calculateLevelMiters([...siblings]),
+        miters,
+        documentMiters,
+        layerMiters: calculateLevelLayerMiters(walls, miters, wallLayerOffsets),
+        documentLayerMiters: calculateLevelLayerMiters(documentWalls, documentMiters, wallLayerOffsets),
         constructionDimensionsByReference,
     };
 }
@@ -79,11 +227,18 @@ export function buildWallFloorplan(node, ctx) {
     // level-wide miter calc per wall; the dispatcher path is O(1) here, which is
     // what keeps a wall drag from being O(N²) across the level.
     const levelData = ctx.levelData;
-    const miters = (documentMode ? levelData?.documentMiters : levelData?.miters) ??
-        calculateLevelMiters([
+    let purposeWalls;
+    const getPurposeWalls = () => {
+        purposeWalls ??= [
             self,
             ...ctx.siblings.filter((s) => s.type === 'wall').map(wallForPurpose),
-        ]);
+        ];
+        return purposeWalls;
+    };
+    const miters = (documentMode ? levelData?.documentMiters : levelData?.miters) ??
+        calculateLevelMiters(getPurposeWalls());
+    const getLayerMiters = () => (documentMode ? levelData?.documentLayerMiters : levelData?.layerMiters) ??
+        calculateLevelLayerMiters(getPurposeWalls(), miters, wallLayerOffsets);
     const polygon = getWallPlanFootprint(self, miters);
     if (!polygon || polygon.length < 3)
         return null;
@@ -103,7 +258,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 +276,13 @@ export function buildWallFloorplan(node, ctx) {
             cursor: isSelected ? 'default' : undefined,
         },
     ];
+    if (node.wallType === 'curtain') {
+        children.push(...buildCurtainWallFloorplan(node, getWallEffectiveHeightForNodes(node, ctx.sceneNodes ?? {}), stroke, ctx.children));
+    }
+    else if (node.assembly) {
+        // Assembly layer lines + framing poché, drawn inside the footprint.
+        children.push(...buildWallAssemblyLayers(self, node, getLayerMiters(), ctx.children, documentMode));
+    }
     if (automaticDimensions) {
         const dimensionStroke = isSelected && palette ? palette.selectedStroke : (palette?.measurementStroke ?? '#334155');
         const dimensionStandard = constructionDimensionStandard({
@@ -192,8 +354,8 @@ export function buildWallFloorplan(node, ctx) {
             payload: { wallId: node.id, endpoint: 'end' },
         });
         const thicknessFrame = getWallCurveFrameAt(self, 0.5);
-        const halfVisibleThickness = getWallThickness(self) / 2;
         for (const side of [1, -1]) {
+            const halfVisibleThickness = getWallLocalFaceZ(self, side > 0 ? 'a' : 'b') * side;
             children.push({
                 kind: 'endpoint-handle',
                 point: [
@@ -205,11 +367,10 @@ export function buildWallFloorplan(node, ctx) {
                 payload: { wallId: node.id, side },
             });
         }
-        // Side move arrows — two directional arrows at the wall midpoint,
-        // pointing outward perpendicular to the wall. Mirrors the 3D
-        // `WallMoveSideHandles` arrows so users can grab the wall body
-        // from the floor plan. PointerDown on either arrow activates
-        // `wallFloorplanMoveTarget` via the registry-layer dispatcher.
+        // Side push arrows — two directional arrows at the wall midpoint,
+        // pointing outward perpendicular to the wall. They are the 3D side
+        // arrows' push (same handle, drag and commit, run by the floor plan for
+        // `WALL_PUSH_AFFORDANCE`); only their placement is plan-specific.
         {
             const dx = node.end[0] - node.start[0];
             const dz = node.end[1] - node.start[1];
@@ -218,16 +379,22 @@ export function buildWallFloorplan(node, ctx) {
                 const midpoint = getWallMidpointHandlePoint(node);
                 const nx = -dz / wallLength;
                 const nz = dx / wallLength;
-                const offset = floorplanWallThickness(node) / 2 + 0.05;
+                const offsets = getWallFaceOffsets({ ...node, thickness: floorplanWallThickness(node) });
+                const offset = offsets.a + 0.05;
+                const backOffset = -offsets.b + 0.05;
                 children.push({
                     kind: 'move-arrow',
                     point: [midpoint.x + nx * offset, midpoint.y + nz * offset],
                     angle: Math.atan2(nz, nx),
+                    affordance: WALL_PUSH_AFFORDANCE,
+                    payload: { wallId: node.id, side: 'a' },
                 });
                 children.push({
                     kind: 'move-arrow',
-                    point: [midpoint.x - nx * offset, midpoint.y - nz * offset],
+                    point: [midpoint.x - nx * backOffset, midpoint.y - nz * backOffset],
                     angle: Math.atan2(-nz, -nx),
+                    affordance: WALL_PUSH_AFFORDANCE,
+                    payload: { wallId: node.id, side: 'b' },
                 });
             }
         }
@@ -253,8 +420,8 @@ function buildSelectedWallHatchLines(wall, stroke) {
     const length = getWallCurveLength(wall);
     if (length <= 1e-6)
         return [];
-    const halfAcross = getWallThickness(wall) / 2;
-    const halfAlong = halfAcross;
+    const offsets = getWallFaceOffsets(wall);
+    const halfAlong = offsets.a - getWallBodyCenterOffset(wall);
     const count = Math.max(1, Math.floor(length / FLOORPLAN_SELECTION_HATCH_SPACING));
     const spacing = length / count;
     const lines = [];
@@ -263,10 +430,10 @@ function buildSelectedWallHatchLines(wall, stroke) {
         const frame = getWallCurveFrameAt(wall, along / length);
         lines.push({
             kind: 'line',
-            x1: frame.point.x - frame.tangent.x * halfAlong - frame.normal.x * halfAcross,
-            y1: frame.point.y - frame.tangent.y * halfAlong - frame.normal.y * halfAcross,
-            x2: frame.point.x + frame.tangent.x * halfAlong + frame.normal.x * halfAcross,
-            y2: frame.point.y + frame.tangent.y * halfAlong + frame.normal.y * halfAcross,
+            x1: frame.point.x - frame.tangent.x * halfAlong - frame.normal.x * -offsets.b,
+            y1: frame.point.y - frame.tangent.y * halfAlong - frame.normal.y * -offsets.b,
+            x2: frame.point.x + frame.tangent.x * halfAlong + frame.normal.x * offsets.a,
+            y2: frame.point.y + frame.tangent.y * halfAlong + frame.normal.y * offsets.a,
             stroke,
             strokeWidth: FLOORPLAN_SELECTION_HATCH_STROKE_WIDTH,
             pointerEvents: 'none',

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/measurement.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"measurement.d.ts","sourceRoot":"","sources":["../../src/wall/measurement.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,kBAAkB,EACvB,KAAK,yBAAyB,EAC9B,KAAK,2BAA2B,EAGhC,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAKzB,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,QAAQ,GAAG,kBAAkB,EAAE,CAmG5E;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAC7B,WAAW,EAAE,MAAM,GAClB,yBAAyB,GAAG,IAAI,CA8ElC;AAED,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,QAAQ,EACd,SAAS,EAAE,2BAA2B,GACrC,kBAAkB,GAAG,IAAI,CAgC3B"}
+{"version":3,"file":"measurement.d.ts","sourceRoot":"","sources":["../../src/wall/measurement.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,kBAAkB,EACvB,KAAK,yBAAyB,EAC9B,KAAK,2BAA2B,EAGhC,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAKzB,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,QAAQ,GAAG,kBAAkB,EAAE,CA2F5E;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAC7B,WAAW,EAAE,MAAM,GAClB,yBAAyB,GAAG,IAAI,CA8ElC;AAED,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,QAAQ,EACd,SAAS,EAAE,2BAA2B,GACrC,kBAAkB,GAAG,IAAI,CAgC3B"}

package/dist/wall/measurement.js

@@ -1,4 +1,4 @@
-import { getWallArcData, getWallCurveFrameAt, getWallThickness, sampleWallCenterline, useScene, } from '@pascal-app/core';
+import { getWallArcData, getWallCurveFrameAt, getWallFaceOffsets, getWallLocalFaceZ, sampleWallCenterline, useScene, } from '@pascal-app/core';
 import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling';
 const point = (x, y, z) => [x, y, z];
 export function wallMeasurementFeatures(wall) {
@@ -6,14 +6,14 @@ export function wallMeasurementFeatures(wall) {
     const arc = getWallArcData(wall);
     const centerline = sampleWallCenterline(wall).map(({ x, y }) => point(x, 0, y));
     const midpoint = getWallCurveFrameAt(wall, 0.5).point;
-    const halfThickness = getWallThickness(wall) / 2;
+    const { a, b } = getWallFaceOffsets(wall);
     const leftFace = centerline.map((_center, index) => {
         const frame = getWallCurveFrameAt(wall, index / Math.max(1, centerline.length - 1));
-        return point(frame.point.x + frame.normal.x * halfThickness, 0, frame.point.y + frame.normal.y * halfThickness);
+        return point(frame.point.x + frame.normal.x * a, 0, frame.point.y + frame.normal.y * a);
     });
     const rightFace = centerline.map((_center, index) => {
         const frame = getWallCurveFrameAt(wall, index / Math.max(1, centerline.length - 1));
-        return point(frame.point.x - frame.normal.x * halfThickness, 0, frame.point.y - frame.normal.y * halfThickness);
+        return point(frame.point.x - frame.normal.x * -b, 0, frame.point.y - frame.normal.y * -b);
     });
     return [
         {
@@ -139,7 +139,7 @@ export function matchWallMeasurementFeature(wall, hit, maxDistance) {
         const side = (hit[0] - frame.point.x) * frame.normal.x + (hit[2] - frame.point.y) * frame.normal.y >= 0
             ? 1
             : -1;
-        const halfThickness = getWallThickness(wall) / 2;
+        const halfThickness = getWallLocalFaceZ(wall, side > 0 ? 'a' : 'b') * side;
         const faceX = frame.point.x + frame.normal.x * halfThickness * side;
         const faceZ = frame.point.y + frame.normal.y * halfThickness * side;
         const faceDistance = Math.hypot(hit[0] - faceX, hit[2] - faceZ);

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

@@ -1 +1 @@
-{"version":3,"file":"move-endpoint-tool.d.ts","sourceRoot":"","sources":["../../src/wall/move-endpoint-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAeL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AA2BzB;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,QAAQ,CAAA;IACd,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAA;CAC1B,CAAA;AA6HD,eAAO,MAAM,oBAAoB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,MAAM,EAAE,kBAAkB,CAAA;CAAE,CAqhBzE,CAAA;AAkBD,eAAe,oBAAoB,CAAA"}
+{"version":3,"file":"move-endpoint-tool.d.ts","sourceRoot":"","sources":["../../src/wall/move-endpoint-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAcL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AA2BzB;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,IAAI,EAAE,QAAQ,CAAA;IACd,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAA;CAC1B,CAAA;AA6HD,eAAO,MAAM,oBAAoB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,MAAM,EAAE,kBAAkB,CAAA;CAAE,CA+hBzE,CAAA;AAkBD,eAAe,oBAAoB,CAAA"}

package/dist/wall/move-endpoint-tool.js

@@ -1,6 +1,6 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { collectAlignmentAnchors, emitter, getWallBaseElevationForNodes, getWallCurveLength, getWallThickness, pauseSceneHistory, resolveAlignment, resolveMovedWallSupportSlabPatch, resumeSceneHistory, runAsSingleSceneHistoryStep, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { acquireSceneHistoryPause, collectAlignmentAnchors, emitter, getWallBaseElevationForNodes, getWallCurveLength, getWallThickness, resolveAlignment, resolveMovedWallSupportSlabPatch, runAsSingleSceneHistoryStep, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { CursorSphere, formatAngleRadians, getAngleToSegmentReference, getSegmentAngleReferenceAtPoint, isAlignmentGuideActive, isAngleSnapActive, isMagneticSnapActive, isSegmentLongEnough, MeasurementPill, markToolCancelConsumed, resolveEndpointWallSplit, snapWallDraftPointDetailed, triggerSFX, useAlignmentGuides, useInteractionScope, useWallSnapIndicator, WALL_CONNECT_SNAP_RADIUS, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Html } from '@react-three/drei';
@@ -147,8 +147,13 @@ export const MoveWallEndpointTool = ({ target }) => {
         const wallAlignmentCandidates = collectAlignmentAnchors(useScene.getState().nodes, nodeId);
         const movingLinkedIdSet = new Set(movingLinkedWallIds);
         const attachedAlignmentCandidates = wallAlignmentCandidates.filter((anchor) => !movingLinkedIdSet.has(anchor.nodeId));
-        pauseSceneHistory(useScene);
+        // A lease, so a cancel and the unmount that follows it release it once.
+        const releaseHistory = acquireSceneHistoryPause(useScene);
         let wasCommitted = false;
+        // Ends with the drop, the dismiss or the cancel: the window listeners stay
+        // until the unmount, and a release after Escape must not commit the
+        // cancelled preview (nor a late pointer move republish it).
+        let live = true;
         // Last RAW cursor point from `grid:move` — lets the Alt keydown/keyup
         // handlers re-run the FULL snap pipeline immediately on a modifier change
         // instead of waiting for the next mousemove. The raw point (not the
@@ -308,6 +313,8 @@ export const MoveWallEndpointTool = ({ target }) => {
             return alignedPoint;
         };
         const onGridMove = (event) => {
+            if (!live)
+                return;
             const planPoint = [event.localPosition[0], event.localPosition[2]];
             lastRawPoint = planPoint;
             // The keydown listener can't observe an Alt press that predates the
@@ -321,6 +328,8 @@ export const MoveWallEndpointTool = ({ target }) => {
             applyPreview(resolveDragPoint(planPoint), altPressedRef.current);
         };
         const onPointerUp = () => {
+            if (!live)
+                return;
             useAlignmentGuides.getState().clear();
             useWallSnapIndicator.getState().clear();
             // The handle sits on the wall body, so the browser fires a click on the
@@ -343,11 +352,13 @@ export const MoveWallEndpointTool = ({ target }) => {
                     hasReleasedOnce = true;
                     return;
                 }
+                live = false;
                 restoreOriginal();
                 useViewer.getState().setSelection({ selectedIds: [nodeId] });
                 exitMoveMode();
                 return;
             }
+            live = false;
             if (isSegmentLongEnough(preview.start, preview.end)) {
                 wasCommitted = true;
                 const linkedUpdates = altPressedRef.current
@@ -360,7 +371,7 @@ export const MoveWallEndpointTool = ({ target }) => {
                 // ops (create halves, migrate attachments, delete host) would each
                 // push their own entry, so the whole commit runs as one history step.
                 clearPreviewOverrides();
-                resumeSceneHistory(useScene);
+                releaseHistory();
                 runAsSingleSceneHistoryStep(useScene, () => {
                     // Dropping the endpoint on another wall's interior splits that host
                     // like the draw path does. Linked walls updated in this commit share
@@ -404,7 +415,6 @@ export const MoveWallEndpointTool = ({ target }) => {
                         useScene.getState().markDirty(u.id);
                     }
                 });
-                pauseSceneHistory(useScene);
                 triggerSFX('sfx:item-place');
             }
             useViewer.getState().setSelection({ selectedIds: [nodeId] });
@@ -412,11 +422,14 @@ export const MoveWallEndpointTool = ({ target }) => {
             exitMoveMode();
         };
         const onCancel = () => {
+            if (!live)
+                return;
+            live = false;
             useAlignmentGuides.getState().clear();
             useWallSnapIndicator.getState().clear();
             restoreOriginal();
             useViewer.getState().setSelection({ selectedIds: [nodeId] });
-            resumeSceneHistory(useScene);
+            releaseHistory();
             setAngleLabel(null);
             markToolCancelConsumed();
             exitMoveMode();
@@ -427,7 +440,7 @@ export const MoveWallEndpointTool = ({ target }) => {
         // re-snaps against their (now live) corners, re-attach drops them from
         // the candidate set again — without waiting for the next mousemove.
         const setAltState = (pressed) => {
-            if (altPressedRef.current === pressed)
+            if (!live || altPressedRef.current === pressed)
                 return;
             altPressedRef.current = pressed;
             setAltPressed(pressed);
@@ -463,7 +476,7 @@ export const MoveWallEndpointTool = ({ target }) => {
             if (!wasCommitted) {
                 restoreOriginal(false);
             }
-            resumeSceneHistory(useScene);
+            releaseHistory();
             emitter.off('grid:move', onGridMove);
             emitter.off('tool:cancel', onCancel);
             window.removeEventListener('pointerup', onPointerUp);

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

@@ -1 +1 @@
-{"version":3,"file":"move-shared.d.ts","sourceRoot":"","sources":["../../src/wall/move-shared.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EAKd,QAAQ,EACR,KAAK,kBAAkB,EACvB,KAAK,QAAQ,EACb,KAAK,aAAa,EAEnB,MAAM,kBAAkB,CAAA;AAczB,wBAAgB,SAAS,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,WAE3D;AAMD,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,QAAQ,CAAC,UAAU,CAAC,CAQvF;AAED,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CAAA;AAEzC;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAC3C,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;IACtB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,aAAa,EAAE,aAAa,CAAA;IAC5B,WAAW,EAAE,aAAa,CAAA;CAC3B,GAAG,kBAAkB,EAAE,CA2CvB;AA4BD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,UAiB/C;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,UAAU,CAAC,OAAO,QAAQ,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,EACpD,OAAO,EAAE,KAAK,CAAC;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAA;CAAE,CAAC,GACzD,QAAQ,EAAE,CASZ;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAC3C,WAAW,EAAE,KAAK,CAAC,kBAAkB,CAAC,kBAAkB,CAAC,CAAC,CAAA;IAC1D,SAAS,EAAE,aAAa,CAAA;IACxB,OAAO,EAAE,aAAa,CAAA;IACtB,aAAa,EAAE,QAAQ,EAAE,CAAA;IACzB,SAAS,EAAE,MAAM,CAAA;CAClB,GAAG,KAAK,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE,CAAC,CAoClD;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,aAAa,CAAA;IACpB,GAAG,EAAE,aAAa,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE;IAC5C,WAAW,EAAE,KAAK,CAAC,kBAAkB,CAAC,kBAAkB,CAAC,CAAC,CAAA;IAC1D,SAAS,EAAE,aAAa,CAAA;IACxB,OAAO,EAAE,aAAa,CAAA;IACtB,aAAa,EAAE,QAAQ,EAAE,CAAA;CAC1B,GAAG,KAAK,CAAC;IAAE,KAAK,EAAE,gBAAgB,CAAC;IAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC,CAyCrD"}
+{"version":3,"file":"move-shared.d.ts","sourceRoot":"","sources":["../../src/wall/move-shared.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EAMd,QAAQ,EACR,KAAK,kBAAkB,EACvB,KAAK,QAAQ,EACb,KAAK,aAAa,EAEnB,MAAM,kBAAkB,CAAA;AAczB,wBAAgB,SAAS,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,WAE3D;AAMD,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,QAAQ,CAAC,UAAU,CAAC,CAQvF;AAED,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CAAA;AAEzC;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAC3C,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;IACtB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,aAAa,EAAE,aAAa,CAAA;IAC5B,WAAW,EAAE,aAAa,CAAA;CAC3B,GAAG,kBAAkB,EAAE,CA2CvB;AA8BD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,UAiB/C;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,UAAU,CAAC,OAAO,QAAQ,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,EACpD,OAAO,EAAE,KAAK,CAAC;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAA;CAAE,CAAC,GACzD,QAAQ,EAAE,CASZ;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAC3C,WAAW,EAAE,KAAK,CAAC,kBAAkB,CAAC,kBAAkB,CAAC,CAAC,CAAA;IAC1D,SAAS,EAAE,aAAa,CAAA;IACxB,OAAO,EAAE,aAAa,CAAA;IACtB,aAAa,EAAE,QAAQ,EAAE,CAAA;IACzB,SAAS,EAAE,MAAM,CAAA;CAClB,GAAG,KAAK,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE,CAAC,CAoClD;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,aAAa,CAAA;IACpB,GAAG,EAAE,aAAa,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE;IAC5C,WAAW,EAAE,KAAK,CAAC,kBAAkB,CAAC,kBAAkB,CAAC,CAAC,CAAA;IAC1D,SAAS,EAAE,aAAa,CAAA;IACxB,OAAO,EAAE,aAAa,CAAA;IACtB,aAAa,EAAE,QAAQ,EAAE,CAAA;CAC1B,GAAG,KAAK,CAAC;IAAE,KAAK,EAAE,gBAAgB,CAAC;IAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC,CAyCrD"}

package/dist/wall/move-shared.js

@@ -1,4 +1,4 @@
-import { getMaterialPresetByRef, parseMaterialRef, resolveMaterial, useScene, WallNode as WallSchema, } from '@pascal-app/core';
+import { getMaterialPresetByRef, parseMaterialColor, parseMaterialRef, resolveMaterial, useScene, WallNode as WallSchema, } from '@pascal-app/core';
 import { isSegmentLongEnough } from '@pascal-app/editor';
 import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling';
 /**
@@ -66,9 +66,12 @@ function wallSegmentExists(walls, start, end, parentId) {
         ((samePoint(wall.start, start) && samePoint(wall.end, end)) ||
             (samePoint(wall.start, end) && samePoint(wall.end, start))));
 }
-// Resolve a wall slot ref (`library:`/`scene:`) to a swatch colour, or
-// undefined when the ref is absent / dangling / colourless.
+// Resolve a wall slot ref (`library:`/`scene:`) or colour to a swatch colour,
+// or undefined when the ref is absent / dangling / colourless.
 function resolveWallSlotRefColor(ref) {
+    const color = parseMaterialColor(ref);
+    if (color)
+        return color;
     const parsed = parseMaterialRef(ref);
     if (!parsed)
         return undefined;
@@ -79,17 +82,18 @@ function resolveWallSlotRefColor(ref) {
     return sceneMaterial ? resolveMaterial(sceneMaterial.material).color : undefined;
 }
 export function getWallGhostColor(wall) {
-    const slotColor = resolveWallSlotRefColor(wall.slots?.interior) ?? resolveWallSlotRefColor(wall.slots?.exterior);
+    const slotColor = resolveWallSlotRefColor(wall.slots?.a) ?? resolveWallSlotRefColor(wall.slots?.b);
     if (slotColor) {
         return slotColor;
     }
+    const legacy = wall.legacyFaceMaterials;
     const presetColor = getMaterialPresetByRef(wall.materialPreset)?.mapProperties.color ??
-        getMaterialPresetByRef(wall.interiorMaterialPreset)?.mapProperties.color ??
-        getMaterialPresetByRef(wall.exteriorMaterialPreset)?.mapProperties.color;
+        getMaterialPresetByRef(legacy?.a?.materialPreset)?.mapProperties.color ??
+        getMaterialPresetByRef(legacy?.b?.materialPreset)?.mapProperties.color;
     if (presetColor) {
         return presetColor;
     }
-    return resolveMaterial(wall.material ?? wall.interiorMaterial ?? wall.exteriorMaterial).color;
+    return resolveMaterial(wall.material ?? legacy?.a?.material ?? legacy?.b?.material).color;
 }
 export function getWallsAfterUpdates(nodes, updates) {
     const updateById = new Map(updates.map((update) => [update.id, update.data]));