@pascal-app/nodes 1.0.3 → 1.0.5

package/dist/wall/floorplan.js

@@ -1,9 +1,9 @@
-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';
+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.js';
+import { buildCurvedWallConstructionDimensions, buildLevelWallConstructionDimensionPlan, buildWallConstructionDimensions, renderPlannedConstructionDimensions, } from './construction-dimensions.js';
+import { buildCurtainWallFloorplan } from './curtain-wall-floorplan.js';
+import { hasWallCurveBlockingChildren } from './curve-eligibility.js';
 // Same constants the legacy `getFloorplanWall` uses (editor/lib/floorplan/walls.ts).
 // Slightly exaggerates thin walls so the 2D plan stays legible without
 // drifting from BIM data. Inlined to keep nodes/wall self-contained.
@@ -22,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 = {};
@@ -47,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,
     };
 }
@@ -80,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;
@@ -125,6 +279,10 @@ export function buildWallFloorplan(node, ctx) {
     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({
@@ -196,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: [
@@ -209,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];
@@ -222,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' },
                 });
             }
         }
@@ -257,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 = [];
@@ -267,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/index.d.ts

@@ -1,3 +1,3 @@
-export { wallDefinition } from './definition';
-export { WallNode } from './schema';
+export { wallDefinition } from './definition.js';
+export { WallNode } from './schema.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/wall/index.js

@@ -1,2 +1,2 @@
-export { wallDefinition } from './definition';
-export { WallNode } from './schema';
+export { wallDefinition } from './definition.js';
+export { WallNode } from './schema.js';

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,19 +1,19 @@
-import { getWallArcData, getWallCurveFrameAt, getWallThickness, sampleWallCenterline, useScene, } from '@pascal-app/core';
-import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling';
+import { getWallArcData, getWallCurveFrameAt, getWallFaceOffsets, getWallLocalFaceZ, sampleWallCenterline, useScene, } from '@pascal-app/core';
+import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling.js';
 const point = (x, y, z) => [x, y, z];
 export function wallMeasurementFeatures(wall) {
     const height = resolveWallOpeningCeiling(wall, useScene.getState().nodes);
     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;AA4BzB;;;;;;;;;;;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,CA6hBzE,CAAA;eAkBc,oBAAoB"}

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

@@ -1,12 +1,12 @@
 '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 { 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 { acquireSceneHistoryPause, collectAlignmentAnchors, emitter, getWallBaseElevationForNodes, getWallCurveLength, getWallThickness, resolveAlignment, resolveMovedWallSupportSlabPatch, runAsSingleSceneHistoryStep, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { CursorSphere, formatAngleRadians, getAngleToSegmentReference, getSegmentAngleReferenceAtPoint, isAlignmentGuideActive, isAngleSnapActive, isMagneticSnapActive, isSegmentLongEnough, isTypingTarget, 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';
 import { useCallback, useEffect, useRef, useState } from 'react';
-import { LevelOffsetGroup } from '../shared/level-offset-group';
-import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling';
+import { LevelOffsetGroup } from '../shared/level-offset-group.js';
+import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling.js';
 /** Figma-style alignment-snap threshold (meters), matching the item move /
  *  placement tools. 8 cm gives a magnetic pull without fighting grid snap. */
 const ALIGNMENT_THRESHOLD_M = 0.08;
@@ -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);
@@ -436,9 +449,8 @@ export const MoveWallEndpointTool = ({ target }) => {
             }
         };
         const onKeyDown = (event) => {
-            if (event.target instanceof HTMLInputElement || event.target instanceof HTMLTextAreaElement) {
+            if (isTypingTarget(event.target))
                 return;
-            }
             if (event.key === 'Alt') {
                 setAltState(true);
             }
@@ -463,7 +475,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);
@@ -488,7 +500,7 @@ export const MoveWallEndpointTool = ({ target }) => {
     const dimMidX = (previewStart[0] + previewEnd[0]) / 2;
     const dimMidZ = (previewStart[1] + previewEnd[1]) / 2;
     return (_jsx(LevelOffsetGroup, { children: _jsxs("group", { position: [0, wallBaseElevation, 0], children: [_jsx(CursorSphere, { position: cursorLocalPos, showTooltip: false }), _jsx(Html, { center: true, position: [dimMidX, wallHeight + 0.3, dimMidZ], style: { pointerEvents: 'none', touchAction: 'none' }, zIndexRange: [100, 0], children: _jsx(MeasurementPill, { height: wallHeight, length: liveLength, primary: "length", thickness: getWallThickness(effectiveWall), unit: unit }) }), canDetachCorner && (_jsx(Html, { position: [cursorLocalPos[0], 0, cursorLocalPos[2]], style: { pointerEvents: 'none', touchAction: 'none' }, zIndexRange: [100, 0], children: _jsx("div", { className: "translate-y-10", children: _jsx("div", { className: `whitespace-nowrap rounded-full border px-2 py-1 font-medium text-[11px] shadow-lg backdrop-blur-md transition-colors ${altPressed
-                                ? 'border-amber-500/80 bg-amber-500/15 text-amber-100'
+                                ? 'border-amber-500/80 bg-amber-50/95 text-amber-800 dark:bg-amber-500/15 dark:text-amber-100'
                                 : 'border-border bg-background/95 text-muted-foreground'}`, children: altPressed ? 'Detaching corner' : 'Alt to detach' }) }) })), angleLabel && (_jsx(EndpointAngleLabel, { label: angleLabel.label, position: angleLabel.position }))] }) }));
 };
 function EndpointAngleLabel({ label, position, }) {

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,6 +1,6 @@
-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';
+import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling.js';
 /**
  * Pure helpers shared by the 3D `MoveWallTool` and the 2D
  * `wallFloorplanMoveTarget`. Lives in `packages/nodes` because the
@@ -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]));

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,CA+jBrD,CAAA;AAED,eAAe,YAAY,CAAA"}
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/wall/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAgBL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AA2HzB,eAAO,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CA6hBrD,CAAA;eAEc,YAAY"}