@pascal-app/nodes 1.0.3 → 1.0.4

package/dist/wall/floorplan-move.js

@@ -1,13 +1,7 @@
-import { detectSpacesForLevel, getCeilingClampBound, getPerpendicularWallMoveAxis, getPlannedLinkedWallUpdates, getStoredLevelHeight, planAutoCeilingsForLevel, planAutoSlabsForLevel, planWallMoveJunctions, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
-import { getFloorplanWallThickness, getSegmentGridStep, isSegmentLongEnough, snapScalarToGrid, useWallMoveGhosts, } from '@pascal-app/editor';
+import { createLevelStructurePreview, getPerpendicularWallMoveAxis, getPlannedLinkedWallUpdates, planWallEndRejoins, planWallMoveJunctions, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { getFloorplanWallThickness, getSegmentGridStep, isSegmentLongEnough, snapScalarToGrid, useWallMoveGhosts, WALL_CONNECT_SNAP_RADIUS, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { buildBridgeWallCreates, buildBridgeWallPreviews, getLinkedWallSnapshots, getWallsAfterUpdates, stripWallIsNewMetadata, } from './move-shared';
-function getLevelSlabs(levelId, nodes) {
-    return Object.values(nodes).filter((entry) => entry?.type === 'slab' && (entry.parentId ?? null) === levelId);
-}
-function getLevelCeilings(levelId, nodes) {
-    return Object.values(nodes).filter((entry) => entry?.type === 'ceiling' && (entry.parentId ?? null) === levelId);
-}
 /**
  * 2D floor-plan move handler for wall.
  *
@@ -32,7 +26,7 @@ function getLevelCeilings(levelId, nodes) {
  * overrides after the write lands so the system reads from the new
  * committed scene state.
  *
- * Existing automatic slabs and ceilings receive live polygon overrides during
+ * Existing slabs, ceilings and zones receive live polygon overrides during
  * the drag. New surfaces and removals stay deferred until commit because live
  * overrides cannot represent nodes that do not exist in the scene.
  */
@@ -78,40 +72,22 @@ export const wallFloorplanMoveTarget = ({ node }) => {
     let lastNextStart = originalStart;
     let lastNextEnd = originalEnd;
     const levelId = node.parentId ?? null;
+    const previewStructure = levelId
+        ? createLevelStructurePreview(levelId, useScene.getState().nodes)
+        : null;
+    const dragNodes = Object.fromEntries(Object.values(useScene.getState().nodes)
+        .filter((node) => node.parentId === levelId)
+        .map((node) => [node.id, node]));
     const affectedIds = [wallId, ...linkedOriginals.map((wall) => wall.id)];
     const affectedIdSet = new Set(affectedIds);
     const touchedSurfaceIds = new Set();
-    let latestSurfacePlans = null;
-    const planSurfaces = (walls) => {
-        if (!levelId)
-            return null;
-        const sceneState = useScene.getState();
-        const levelWalls = walls.filter((wall) => (wall.parentId ?? null) === levelId);
-        const { roomPolygons } = detectSpacesForLevel(levelId, levelWalls);
-        const slabs = planAutoSlabsForLevel(roomPolygons, getLevelSlabs(levelId, sceneState.nodes));
-        const levelNode = sceneState.nodes[levelId];
-        const ceilings = planAutoCeilingsForLevel(roomPolygons, getLevelCeilings(levelId, sceneState.nodes), {
-            storeyHeight: levelNode?.type === 'level' ? getStoredLevelHeight(levelNode) : undefined,
-            ceilingClampBound: (polygon) => getCeilingClampBound(levelId, sceneState.nodes, polygon),
-        });
-        return { slabs, ceilings };
-    };
     const publishSurfacePreviews = (walls) => {
-        const plans = planSurfaces(walls);
-        latestSurfacePlans = plans;
-        if (!plans)
+        if (!previewStructure)
             return;
-        const entries = [];
-        for (const update of plans.slabs.update) {
-            if (update.data.polygon !== undefined) {
-                entries.push([update.id, { polygon: update.data.polygon }]);
-            }
-        }
-        for (const update of plans.ceilings.update) {
-            if (update.data.polygon !== undefined || update.data.height !== undefined) {
-                entries.push([update.id, update.data]);
-            }
-        }
+        const updates = previewStructure(walls);
+        const entries = updates.flatMap((update) => 'polygon' in update.data || 'holes' in update.data
+            ? [[update.id, update.data]]
+            : []);
         const nextIds = new Set(entries.map(([id]) => id));
         const overrides = useLiveNodeOverrides.getState();
         const sceneState = useScene.getState();
@@ -142,7 +118,6 @@ export const wallFloorplanMoveTarget = ({ node }) => {
             sceneState.markDirty(id);
         }
         touchedSurfaceIds.clear();
-        latestSurfacePlans = null;
     };
     const session = {
         affectedIds,
@@ -222,7 +197,7 @@ export const wallFloorplanMoveTarget = ({ node }) => {
             // `existingWalls` snapshot needs the post-drag layout so duplicate
             // detection works; we synthesise it from scene state + the
             // overrides we just published (zustand is still on baseline).
-            const previewSceneWalls = getWallsAfterUpdates(useScene.getState().nodes, [
+            const previewSceneWalls = getWallsAfterUpdates(dragNodes, [
                 { id: wallId, data: { start: nextStart, end: nextEnd } },
                 ...linkedUpdates.map((u) => ({ id: u.id, data: { start: u.start, end: u.end } })),
             ]).filter((wall) => !collapsedIds.has(wall.id));
@@ -306,49 +281,11 @@ export const wallFloorplanMoveTarget = ({ node }) => {
                 existingWalls,
                 wallCount: Object.values(sceneState.nodes).filter((entry) => entry?.type === 'wall').length,
             });
-            const finalWalls = [
-                ...existingWalls,
-                ...bridgeCreates.map((entry) => ({ ...entry.node, parentId: entry.parentId ?? null })),
-            ];
-            const surfacePlans = planSurfaces(finalWalls) ?? latestSurfacePlans;
-            const surfaceUpdates = surfacePlans
-                ? [
-                    ...surfacePlans.slabs.update.map((entry) => ({
-                        id: entry.id,
-                        data: entry.data,
-                    })),
-                    ...surfacePlans.ceilings.update.map((entry) => ({
-                        id: entry.id,
-                        data: entry.data,
-                    })),
-                ]
-                : [];
-            const surfaceCreates = surfacePlans
-                ? [
-                    ...surfacePlans.slabs.create.map((slab) => ({
-                        node: slab,
-                        parentId: levelId,
-                    })),
-                    ...surfacePlans.ceilings.create.map((ceiling) => ({
-                        node: ceiling,
-                        parentId: levelId,
-                    })),
-                ]
-                : [];
-            const surfaceDeletes = surfacePlans
-                ? [
-                    ...surfacePlans.slabs.delete.map((id) => id),
-                    ...surfacePlans.ceilings.delete.map((id) => id),
-                ]
-                : [];
-            sceneState.applyNodeChanges({
-                update: [
-                    ...commitUpdates,
-                    ...surfaceUpdates,
-                ],
-                create: [...bridgeCreates, ...surfaceCreates],
-                delete: Array.from(new Set([...collapsedLinkedWallIds, ...surfaceDeletes])),
-            });
+            sceneState.applyNodeChanges(planWallEndRejoins(sceneState.nodes, commitUpdates.map(({ id }) => id), WALL_CONNECT_SNAP_RADIUS, {
+                update: commitUpdates,
+                create: bridgeCreates,
+                delete: Array.from(collapsedLinkedWallIds),
+            }));
             // Drop the live overrides now that the committed scene state
             // matches them — leaving them around would keep the system
             // double-merging the same values and would shadow any genuine

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

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

package/dist/wall/floorplan-tool.js

@@ -1,15 +1,12 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { emitter, resolveTerrainWallConstructionOptions, useScene, } from '@pascal-app/core';
-import { markToolCancelConsumed, triggerSFX, useEditor, useFloorplanDraftPreview, useFloorplanRender, useInteractionScope, } from '@pascal-app/editor';
+import { markToolCancelConsumed, triggerSFX, useEditor, useFloorplanDraftPreview, useFloorplanRender, useInteractionScope, useWallDrawVariant, } from '@pascal-app/editor';
 import { useEffect, useRef, useState } from 'react';
-import { useWallDrawingMode, useWallDrawingModeKeys } from './drawing-mode';
 import { createWallRectangle } from './rectangle-command';
 /** The wall's plan tool: line drafting stays with the panel; rectangle mode mounts its own tool. */
 export default function WallFloorplanTool(props) {
-    useWallDrawingModeKeys();
-    const mode = useWallDrawingMode((s) => s.mode);
-    return mode === 'rectangle' ? _jsx(RectangleFloorplanTool, { ...props }) : null;
+    return useWallDrawVariant() === 'rectangle' ? _jsx(RectangleFloorplanTool, { ...props }) : null;
 }
 /**
  * Rectangle mode in the floor plan. Pointer moves stay with the panel, so the
@@ -80,12 +77,14 @@ function RectangleFloorplanTool({ activeLevelId }) {
             if (e.button === 0)
                 claim(e);
         };
-        // The panel publishes the snapped cursor only when it moves to a new
-        // point, so each change while a corner is down is the line draft's tick.
-        const stopTick = useFloorplanDraftPreview.subscribe((state, previous) => {
+        // 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 &&
-                state.cursorPoint &&
-                state.cursorPoint !== previous.cursorPoint)
+                now &&
+                before &&
+                (now[0] !== before[0] || now[1] !== before[1]))
                 triggerSFX('sfx:grid-snap');
         });
         svg.addEventListener('pointerdown', onDown, true);
@@ -93,7 +92,7 @@ function RectangleFloorplanTool({ activeLevelId }) {
         svg.addEventListener('dblclick', stopDouble, true);
         emitter.on('tool:cancel', cancel);
         return () => {
-            stopTick();
+            stopTicks();
             svg.removeEventListener('pointerdown', onDown, true);
             svg.removeEventListener('click', onClick, true);
             svg.removeEventListener('dblclick', stopDouble, true);

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,EAQpB,KAAK,aAAa,EAClB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAKL,KAAK,6BAA6B,EACnC,MAAM,2BAA2B,CAAA;AAalC,QAAA,MAAM,yBAAyB,yDAA0D,CAAA;AAEzF,KAAK,sBAAsB,GAAG,CAAC,OAAO,yBAAyB,CAAC,CAAC,MAAM,CAAC,CAAA;AAexE,MAAM,MAAM,sBAAsB,GAAG;IACnC,MAAM,EAAE,aAAa,CAAA;IACrB,cAAc,EAAE,aAAa,CAAA;IAC7B,iCAAiC,EAAE,MAAM,CAAC,sBAAsB,EAAE,6BAA6B,CAAC,CAAA;CACjG,CAAA;AAED,wBAAgB,6BAA6B,CAAC,EAC5C,QAAQ,EACR,KAAK,GACN,EAAE;IACD,QAAQ,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAA;IACjC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B,GAAG,sBAAsB,CAqCzB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CA8NjG"}
+{"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,5 +1,5 @@
-import { calculateLevelMiters, getWallCurveFrameAt, getWallCurveLength, getWallEffectiveHeightForNodes, 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';
@@ -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/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);