@pascal-app/nodes 1.0.6 → 1.0.7

package/dist/wall/floorplan-affordances.js

@@ -59,8 +59,8 @@ export const wallCurveAffordance = {
             affectedIds: [node.id],
             apply({ planPoint }) {
                 const snapStep = getSegmentGridStep();
-                // World-grid snap so a rotated building doesn't drag the curve
-                // handle off the visible grid.
+                // Building-grid snap, the lattice the plan draws (it turns with the
+                // building).
                 const [x, y] = snapBuildingLocalToWorldGrid([planPoint[0], planPoint[1]], snapStep);
                 // Signed projection of (snappedPoint - chord midpoint) onto the
                 // chord normal. Legacy negates because the SVG y-axis flips
@@ -167,16 +167,19 @@ export const wallMoveEndpointAffordance = {
                 // is 0 outside grid mode), so `'lines' / 'angles' / 'off'` no longer
                 // force a grid snap the mode chip says is inactive. In `'angles'` mode
                 // the endpoint angle-locks off the fixed corner (free length), matching
-                // the draft tool — the angle path ignores the `gridSnap` override.
-                const angleLocked = isAngleSnapActive();
+                // the draft tool — the angle path ignores the `gridSnap` override. The
+                // fixed corner is the segment's start in every mode, as in the 3D tool:
+                // the body capture slides the end along it, so a wall whose fixed end
+                // is T-joined on another wall can't fold onto that wall's line.
                 const snapped = snapWallDraftPoint({
                     point: planPoint,
                     walls,
                     ignoreWallIds: staleWallIds,
-                    start: angleLocked ? fixedPoint : undefined,
-                    angleSnap: angleLocked,
+                    start: fixedPoint,
+                    angleSnap: isAngleSnapActive(),
                     magnetic: isMagneticSnapActive(),
                     gridSnap: (p) => snapBuildingLocalToWorldGrid(p, getSegmentGridStep()),
+                    captureWallBodies: true,
                 });
                 // Figma-style alignment on the dragged corner — snaps it onto another
                 // object's edge / wall face and publishes a guide. The guide is

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/wall/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,mBAAmB,EAQxB,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAoBzB;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,QAAQ,CAgVjE,CAAA"}
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/wall/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,mBAAmB,EAYxB,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAyBzB;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,QAAQ,CAqajE,CAAA"}

package/dist/wall/floorplan-move.js

@@ -1,5 +1,5 @@
-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 { createLevelStructurePreview, finishWallEdit, generateId, getPerpendicularWallMoveAxis, getPlannedLinkedWallUpdates, planAttachedWallChanges, planAttachedWallUpdates, planWallEndRejoins, planWallMoveJunctions, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { getFloorplanWallThickness, getSegmentGridStep, isSegmentLongEnough, isWallRunFree, nearestWallParallelTarget, publishWallParallelGuide, snapScalarToGrid, useWallMoveGhosts, WALL_CONNECT_SNAP_RADIUS, wallParallelTargets, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { buildBridgeWallCreates, buildBridgeWallPreviews, getLinkedWallSnapshots, getWallsAfterUpdates, stripWallIsNewMetadata, } from './move-shared.js';
 /**
@@ -78,7 +78,22 @@ export const wallFloorplanMoveTarget = ({ node }) => {
     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)];
+    // Lines up with the parallel walls on the level: an outside wall's faces
+    // with the rest of the outside, any other wall's with every wall.
+    const parallelTargets = moveAxis
+        ? wallParallelTargets(node, moveAxis, Object.values(dragNodes).filter((entry) => entry.type === 'wall'))
+        : [];
+    let lastLineUp = null;
+    // Walls T'd into this one stay on it, stretched along their own line.
+    const linkedIds = new Set(linkedOriginals.map((wall) => wall.id));
+    const attachedWalls = isNew
+        ? []
+        : planAttachedWallUpdates(Object.values(dragNodes).filter((entry) => entry.type === 'wall' && entry.id !== wallId && !linkedIds.has(entry.id)), originalStart, originalEnd, originalStart, originalEnd).map(({ id }) => dragNodes[id]);
+    const affectedIds = [
+        wallId,
+        ...linkedOriginals.map((wall) => wall.id),
+        ...attachedWalls.map((wall) => wall.id),
+    ];
     const affectedIdSet = new Set(affectedIds);
     const touchedSurfaceIds = new Set();
     const publishSurfacePreviews = (walls) => {
@@ -121,25 +136,30 @@ export const wallFloorplanMoveTarget = ({ node }) => {
     };
     const session = {
         affectedIds,
-        apply({ planPoint }) {
+        apply({ planPoint, modifiers }) {
             if (!rawAnchor) {
                 rawAnchor = [planPoint[0], planPoint[1]];
                 return;
             }
             const rawDx = planPoint[0] - rawAnchor[0];
             const rawDz = planPoint[1] - rawAnchor[1];
-            const step = getSegmentGridStep();
+            // Alt (or snapping off) moves the wall exactly with the pointer.
+            const free = isWallRunFree(modifiers);
+            const step = free ? 0 : getSegmentGridStep();
             // Axis-lock the move to the wall's perpendicular (normal). Project
             // the original centre + raw cursor delta onto the axis, snap the
-            // absolute projection to a grid multiple, then translate the wall
-            // by `axis * perpDelta`. Matches `MoveWallTool` so 2D and 3D drag
-            // produce identical wall topology.
+            // absolute projection to a parallel wall it lines up with, else to a
+            // grid multiple, then translate the wall by `axis * perpDelta`.
+            // Matches `MoveWallTool` so 2D and 3D drag produce identical wall
+            // topology.
             let dx;
             let dz;
+            let lineUp = null;
             if (moveAxis) {
                 const originalProj = originalCenter[0] * moveAxis[0] + originalCenter[1] * moveAxis[1];
                 const rawProj = originalProj + rawDx * moveAxis[0] + rawDz * moveAxis[1];
-                const snappedProj = snapScalarToGrid(rawProj, step);
+                lineUp = free ? null : nearestWallParallelTarget(parallelTargets, rawProj);
+                const snappedProj = lineUp ? lineUp.position : snapScalarToGrid(rawProj, step);
                 const perpDelta = snappedProj - originalProj;
                 dx = moveAxis[0] * perpDelta;
                 dz = moveAxis[1] * perpDelta;
@@ -148,6 +168,10 @@ export const wallFloorplanMoveTarget = ({ node }) => {
                 dx = snapScalarToGrid(rawDx, step);
                 dz = snapScalarToGrid(rawDz, step);
             }
+            if (lineUp !== lastLineUp) {
+                lastLineUp = lineUp;
+                publishWallParallelGuide(lineUp);
+            }
             if (dx === lastDelta[0] && dz === lastDelta[1])
                 return;
             lastDelta = [dx, dz];
@@ -185,11 +209,14 @@ export const wallFloorplanMoveTarget = ({ node }) => {
             // until the user commits. Batched into a single zustand
             // notification — otherwise each per-wall `.set` would re-render
             // every override subscriber once per linked wall per tick.
+            const attachedById = new Map(planAttachedWallUpdates(attachedWalls, originalStart, originalEnd, nextStart, nextEnd).map((update) => [update.id, update]));
+            // A wall the move carries off this one's ends lets go: back where it was.
+            const attachedUpdates = attachedWalls.map((wall) => attachedById.get(wall.id) ?? { id: wall.id, start: wall.start, end: wall.end });
             useLiveNodeOverrides
                 .getState()
                 .setMany([
                 [wallId, { start: nextStart, end: nextEnd }],
-                ...linkedUpdates.map((upd) => [upd.id, { start: upd.start, end: upd.end }]),
+                ...[...linkedUpdates, ...attachedUpdates].map((upd) => [upd.id, { start: upd.start, end: upd.end }]),
             ]);
             // Surface bridge-wall previews so the floor-plan SVG layer can
             // render dashed outlines of what `commit()` will insert. Mirrors
@@ -199,7 +226,10 @@ export const wallFloorplanMoveTarget = ({ node }) => {
             // overrides we just published (zustand is still on baseline).
             const previewSceneWalls = getWallsAfterUpdates(dragNodes, [
                 { id: wallId, data: { start: nextStart, end: nextEnd } },
-                ...linkedUpdates.map((u) => ({ id: u.id, data: { start: u.start, end: u.end } })),
+                ...[...linkedUpdates, ...attachedUpdates].map((u) => ({
+                    id: u.id,
+                    data: { start: u.start, end: u.end },
+                })),
             ]).filter((wall) => !collapsedIds.has(wall.id));
             const bridgePreviews = buildBridgeWallPreviews({
                 bridgePlans: plan.bridgePlans,
@@ -223,7 +253,7 @@ export const wallFloorplanMoveTarget = ({ node }) => {
             // (override-merged) so the mesh follows the cursor.
             const sceneState = useScene.getState();
             sceneState.markDirty(wallId);
-            for (const upd of linkedUpdates) {
+            for (const upd of [...linkedUpdates, ...attachedUpdates]) {
                 sceneState.markDirty(upd.id);
             }
         },
@@ -235,14 +265,16 @@ export const wallFloorplanMoveTarget = ({ node }) => {
             return dx !== 0 || dz !== 0;
         },
         commit() {
+            publishWallParallelGuide(null);
             const sceneState = useScene.getState();
             const liveWall = sceneState.nodes[wallId];
             if (liveWall?.type !== 'wall') {
                 // Bail without leaving stale overrides behind.
                 const overrides = useLiveNodeOverrides.getState();
                 overrides.clear(wallId);
-                for (const wall of linkedOriginals)
+                for (const wall of [...linkedOriginals, ...attachedWalls]) {
                     overrides.clear(wall.id);
+                }
                 clearSurfacePreviews();
                 return;
             }
@@ -281,10 +313,27 @@ export const wallFloorplanMoveTarget = ({ node }) => {
                 existingWalls,
                 wallCount: Object.values(sceneState.nodes).filter((entry) => entry?.type === 'wall').length,
             });
-            sceneState.applyNodeChanges(planWallEndRejoins(sceneState.nodes, commitUpdates.map(({ id }) => id), WALL_CONNECT_SNAP_RADIUS, {
-                update: commitUpdates,
+            // Walls T'd into this one follow it, what hangs on them staying put.
+            const attachedChanges = planAttachedWallChanges(sceneState.nodes, wallId, originalStart, originalEnd, lastNextStart, lastNextEnd, new Set([...linkedIds, ...collapsedLinkedWallIds]));
+            const attachedWallIds = attachedChanges.flatMap(({ id }) => sceneState.nodes[id]?.type === 'wall' ? [id] : []);
+            // The moved and stretched walls and the jogs take over any stretch of a
+            // parallel wall they now run along; jogs on the outline are outside walls.
+            sceneState.applyNodeChanges(finishWallEdit(sceneState.nodes, planWallEndRejoins(sceneState.nodes, commitUpdates.map(({ id }) => id), WALL_CONNECT_SNAP_RADIUS, {
+                update: [
+                    ...commitUpdates,
+                    ...attachedChanges,
+                ],
                 create: bridgeCreates,
                 delete: Array.from(collapsedLinkedWallIds),
+            }), {
+                winnerIds: [
+                    ...commitUpdates.map(({ id }) => id),
+                    ...attachedWallIds,
+                    ...bridgeCreates.map(({ node }) => node.id),
+                ],
+                movedWallId: wallId,
+                bridgeIds: bridgeCreates.map(({ node }) => node.id),
+                mintId: () => generateId('wall'),
             }));
             // Drop the live overrides now that the committed scene state
             // matches them — leaving them around would keep the system
@@ -293,8 +342,9 @@ export const wallFloorplanMoveTarget = ({ node }) => {
             // next frame reads the new scene state directly.
             const overrides = useLiveNodeOverrides.getState();
             overrides.clear(wallId);
-            for (const wall of linkedOriginals)
+            for (const wall of [...linkedOriginals, ...attachedWalls]) {
                 overrides.clear(wall.id);
+            }
             clearSurfacePreviews();
             // Swap ghosts → real walls: the bridges we just created render
             // through the registry layer, so the dashed previews aren't

package/dist/wall/floorplan.d.ts

@@ -1,13 +1,12 @@
 import { type AnyNode, type FloorplanGeometry, type GeometryContext, type WallLayerMiterData, type WallMiterData, type WallNode } from '@pascal-app/core';
 import { type WallConstructionDimensionPlan } from './construction-dimensions.js';
-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>;
+    /** Built on first read: a level whose plan shows no automatic dimensions never pays for it. */
+    readonly constructionDimensions: WallConstructionDimensionPlan;
 };
 export declare function computeWallFloorplanLevelData({ siblings, nodes, }: {
     siblings: ReadonlyArray<WallNode>;
@@ -22,7 +21,8 @@ export declare function computeWallFloorplanLevelData({ siblings, nodes, }: {
  *   3. A transparent hit-line on the centerline so the user can grab the
  *      wall body easily.
  *   4. Two endpoint handles (start + end) when selected — the registry
- *      layer hosts the 5-circle stack + hover transitions + 2D drag.
+ *      layer hosts the 5-circle stack + hover transitions + 2D drag — and,
+ *      just past each, a "pull to continue" grip that draws the next wall.
  *   5. Exterior facade strings plus interior wall spans and hosted-opening widths.
  *
  * `ctx.levelData` provides the shared level miter graph when the floor-plan
@@ -30,5 +30,4 @@ export declare function computeWallFloorplanLevelData({ siblings, nodes, }: {
  * direct builder callers.
  */
 export declare function buildWallFloorplan(node: WallNode, ctx: GeometryContext): FloorplanGeometry | null;
-export {};
 //# sourceMappingURL=floorplan.d.ts.map

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,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,YAAI,gBAAgB,EAAE,YAAY,EAAE,YAAY,CAAU,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"}
+{"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,EAapB,KAAK,kBAAkB,EAEvB,KAAK,aAAa,EAClB,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAazB,OAAO,EAML,KAAK,6BAA6B,EACnC,MAAM,2BAA2B,CAAA;AA4ClC,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,+FAA+F;IAC/F,QAAQ,CAAC,sBAAsB,EAAE,6BAA6B,CAAA;CAC/D,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,CAoBzB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAoRjG"}

package/dist/wall/floorplan.js

@@ -1,9 +1,10 @@
-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 { calculateLevelLayerMiters, calculateLevelMiters, getWallBodyCenterOffset, getWallCurveFrameAt, getWallCurveLength, getWallEffectiveHeightForNodes, getWallFaceOffsets, getWallLayerPolylines, getWallLocalFaceZ, getWallMidpointHandlePoint, getWallPlanFootprint, getWallThickness, isCurvedWall, isRailingWall, wallLayerBoundaryOffsets, } from '@pascal-app/core';
+import { floorplanGeometryMetadata, readFloorplanContext, WALL_PULL_AFFORDANCE, WALL_PULL_GRIP_TITLE, WALL_PUSH_AFFORDANCE, wallPullSeed, } from '@pascal-app/editor';
 import { constructionDimensionStandard } from '../shared/construction-dimension-standards.js';
-import { buildCurvedWallConstructionDimensions, buildLevelWallConstructionDimensionPlan, buildWallConstructionDimensions, renderPlannedConstructionDimensions, } from './construction-dimensions.js';
+import { buildCurvedWallConstructionDimensions, buildLevelWallConstructionDimensionPlan, buildWallConstructionDimensions, constructionDimensionFace, renderPlannedConstructionDimensions, } from './construction-dimensions.js';
 import { buildCurtainWallFloorplan } from './curtain-wall-floorplan.js';
 import { hasWallCurveBlockingChildren } from './curve-eligibility.js';
+import { buildRailingWallFloorplan } from './railing-wall-floorplan.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.
@@ -12,10 +13,19 @@ const FLOORPLAN_MIN_VISIBLE_WALL_THICKNESS = 0.13;
 const FLOORPLAN_MAX_EXTRA_THICKNESS = 0.035;
 const FLOORPLAN_SELECTION_HATCH_SPACING = 0.12;
 const FLOORPLAN_SELECTED_WALL_STROKE_WIDTH = 0.03;
+const FLOORPLAN_RAILING_STROKE_WIDTH = 0.01;
 const FLOORPLAN_SELECTION_HATCH_STROKE_WIDTH = 0.02;
-const WALL_DIMENSION_REFERENCES = ['finished-faces', 'centerline', 'stud-faces'];
+// The automatic strings measure finished faces; a partition meeting a facade
+// is dimensioned to both of its faces.
+const FINISHED_FACE_DIMENSIONS = {
+    datumPolicy: 'wall-face',
+    intersectionReferencePolicy: 'both-faces',
+};
 function floorplanWallThickness(wall) {
     const baseThickness = getWallThickness(wall);
+    // A railing draws as thin as its posts.
+    if (isRailingWall(wall))
+        return baseThickness;
     const scaledThickness = baseThickness * FLOORPLAN_WALL_THICKNESS_SCALE;
     return Math.min(baseThickness + FLOORPLAN_MAX_EXTRA_THICKNESS, Math.max(baseThickness, scaledThickness, FLOORPLAN_MIN_VISIBLE_WALL_THICKNESS));
 }
@@ -166,38 +176,19 @@ function buildWallAssemblyLayers(wall, source, layerMiters, children, documentMo
 }
 export function computeWallFloorplanLevelData({ siblings, nodes, }) {
     const walls = siblings.map(exaggerateWallThickness);
-    const constructionDimensionsByReference = {};
-    for (const reference of WALL_DIMENSION_REFERENCES) {
-        let cached;
-        Object.defineProperty(constructionDimensionsByReference, reference, {
-            enumerable: true,
-            get: () => {
-                if (cached)
-                    return cached;
-                const datumPolicy = reference === 'finished-faces'
-                    ? 'wall-face'
-                    : reference === 'stud-faces'
-                        ? 'structural-face'
-                        : 'centerline';
-                cached = buildLevelWallConstructionDimensionPlan(siblings, nodes, constructionDimensionStandard({
-                    datumPolicy,
-                    ...(reference === 'finished-faces'
-                        ? { intersectionReferencePolicy: 'both-faces' }
-                        : {}),
-                }));
-                return cached;
-            },
-        });
-    }
     const documentWalls = [...siblings];
     const miters = calculateLevelMiters(walls);
     const documentMiters = calculateLevelMiters(documentWalls);
+    let constructionDimensions;
     return {
         miters,
         documentMiters,
         layerMiters: calculateLevelLayerMiters(walls, miters, wallLayerOffsets),
         documentLayerMiters: calculateLevelLayerMiters(documentWalls, documentMiters, wallLayerOffsets),
-        constructionDimensionsByReference,
+        get constructionDimensions() {
+            constructionDimensions ??= buildLevelWallConstructionDimensionPlan(siblings, nodes, constructionDimensionStandard(FINISHED_FACE_DIMENSIONS));
+            return constructionDimensions;
+        },
     };
 }
 /**
@@ -209,7 +200,8 @@ export function computeWallFloorplanLevelData({ siblings, nodes, }) {
  *   3. A transparent hit-line on the centerline so the user can grab the
  *      wall body easily.
  *   4. Two endpoint handles (start + end) when selected — the registry
- *      layer hosts the 5-circle stack + hover transitions + 2D drag.
+ *      layer hosts the 5-circle stack + hover transitions + 2D drag — and,
+ *      just past each, a "pull to continue" grip that draws the next wall.
  *   5. Exterior facade strings plus interior wall spans and hosted-opening widths.
  *
  * `ctx.levelData` provides the shared level miter graph when the floor-plan
@@ -217,7 +209,7 @@ export function computeWallFloorplanLevelData({ siblings, nodes, }) {
  * direct builder callers.
  */
 export function buildWallFloorplan(node, ctx) {
-    const { automaticDimensions, metricNotation, purpose, wallDimensionReference } = readFloorplanContext(ctx);
+    const { automaticDimensions, metricNotation, purpose, wallDimensionFaces } = readFloorplanContext(ctx);
     const documentMode = purpose === 'document';
     const wallForPurpose = (wall) => (documentMode ? wall : exaggerateWallThickness(wall));
     const self = wallForPurpose(node);
@@ -258,14 +250,24 @@ export function buildWallFloorplan(node, ctx) {
         : isHovered && palette
             ? palette.wallHoverStroke
             : '#1f2937';
-    const fill = node.wallType === 'curtain' ? 'transparent' : showSelectedChrome ? '#ffffff' : '#374151';
+    // A railing is an outline round its posts, with no poché.
+    const railing = isRailingWall(node);
+    const fill = node.wallType === 'curtain' || railing
+        ? 'transparent'
+        : showSelectedChrome
+            ? '#ffffff'
+            : '#374151';
     const children = [
         {
             kind: 'polygon',
             points,
             fill,
             stroke,
-            strokeWidth: showSelectedChrome ? FLOORPLAN_SELECTED_WALL_STROKE_WIDTH : 0.02,
+            strokeWidth: showSelectedChrome
+                ? FLOORPLAN_SELECTED_WALL_STROKE_WIDTH
+                : railing
+                    ? FLOORPLAN_RAILING_STROKE_WIDTH
+                    : 0.02,
             opacity: 0.92,
             metadata: floorplanGeometryMetadata({ annotationObstacle: 'outline' }),
             // Once the wall is selected, the body keeps catching the pointer
@@ -279,6 +281,9 @@ export function buildWallFloorplan(node, ctx) {
     if (node.wallType === 'curtain') {
         children.push(...buildCurtainWallFloorplan(node, getWallEffectiveHeightForNodes(node, ctx.sceneNodes ?? {}), stroke, ctx.children));
     }
+    else if (railing) {
+        children.push(...buildRailingWallFloorplan(node, ctx.children, ctx.siblings.filter((sibling) => sibling.type === 'wall'), stroke));
+    }
     else if (node.assembly) {
         // Assembly layer lines + framing poché, drawn inside the footprint.
         children.push(...buildWallAssemblyLayers(self, node, getLayerMiters(), ctx.children, documentMode));
@@ -286,7 +291,7 @@ export function buildWallFloorplan(node, ctx) {
     if (automaticDimensions) {
         const dimensionStroke = isSelected && palette ? palette.selectedStroke : (palette?.measurementStroke ?? '#334155');
         const dimensionStandard = constructionDimensionStandard({
-            datumPolicy: wallDimensionDatumPolicy(wallDimensionReference),
+            ...FINISHED_FACE_DIMENSIONS,
             metricNotation,
         });
         const exteriorCornerDimensionStandard = constructionDimensionStandard({
@@ -303,11 +308,12 @@ export function buildWallFloorplan(node, ctx) {
             }));
         }
         else {
-            const planned = levelData?.constructionDimensionsByReference[wallDimensionReference].get(node.id);
+            const planned = levelData?.constructionDimensions.get(node.id);
             if (planned) {
-                children.push(...renderPlannedConstructionDimensions(planned, view?.unit ?? 'metric', dimensionStroke, documentMode ? 'document' : 'editor', dimensionStandard));
+                children.push(...renderPlannedConstructionDimensions(planned.filter((entry) => measuresFace(wallDimensionFaces, constructionDimensionFace(entry.tier))), view?.unit ?? 'metric', dimensionStroke, documentMode ? 'document' : 'editor', dimensionStandard));
             }
-            else if (!levelData) {
+            else if (!levelData && measuresFace(wallDimensionFaces, 'exterior')) {
+                // Without the level plan, only the exterior strings are drawn.
                 children.push(...buildWallConstructionDimensions(self, ctx, {
                     unit: view?.unit ?? 'metric',
                     stroke: dimensionStroke,
@@ -353,8 +359,25 @@ export function buildWallFloorplan(node, ctx) {
             affordance: 'move-endpoint',
             payload: { wallId: node.id, endpoint: 'end' },
         });
+        // Pull grips — an arrow just past each end, pointing out along the wall:
+        // drag one to draw the next wall from that end (`startWallPull`).
+        for (const endpoint of ['start', 'end']) {
+            const seed = wallPullSeed(node, endpoint);
+            if (!seed)
+                continue;
+            children.push({
+                kind: 'move-arrow',
+                variant: 'pull',
+                point: seed.start,
+                angle: Math.atan2(seed.reference[1], seed.reference[0]),
+                affordance: WALL_PULL_AFFORDANCE,
+                payload: { wallId: node.id, endpoint },
+                title: WALL_PULL_GRIP_TITLE,
+            });
+        }
         const thicknessFrame = getWallCurveFrameAt(self, 0.5);
-        for (const side of [1, -1]) {
+        // A railing's posts set its thickness (the panel's Post size): it has no thickness handles.
+        for (const side of railing ? [] : [1, -1]) {
             const halfVisibleThickness = getWallLocalFaceZ(self, side > 0 ? 'a' : 'b') * side;
             children.push({
                 kind: 'endpoint-handle',
@@ -442,13 +465,6 @@ function buildSelectedWallHatchLines(wall, stroke) {
     }
     return lines;
 }
-function wallDimensionDatumPolicy(reference) {
-    switch (reference) {
-        case 'centerline':
-            return 'centerline';
-        case 'stud-faces':
-            return 'structural-face';
-        case 'finished-faces':
-            return 'wall-face';
-    }
+function measuresFace(faces, face) {
+    return faces === 'both' || faces === face;
 }

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,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"}
+{"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,CA8hBzE,CAAA;eAkBc,oBAAoB"}

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

@@ -260,6 +260,7 @@ export const MoveWallEndpointTool = ({ target }) => {
                 start: fixedPoint,
                 angleSnap: isAngleSnapActive(),
                 magnetic: isMagneticSnapActive(),
+                captureWallBodies: true,
             });
             const snappedPoint = snapResult.point;
             // Figma-style alignment: nudge the dragged endpoint onto another wall /

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

package/dist/wall/move-tool.js

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