@pascal-app/nodes 1.0.6 → 1.1.0

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
@@ -277,7 +279,10 @@ export function buildWallFloorplan(node, ctx) {
         },
     ];
     if (node.wallType === 'curtain') {
-        children.push(...buildCurtainWallFloorplan(node, getWallEffectiveHeightForNodes(node, ctx.sceneNodes ?? {}), stroke, ctx.children));
+        children.push(...buildCurtainWallFloorplan(node, getWallEffectiveHeightForNodes(node, ctx.sceneNodes ?? {}, 0), 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.
@@ -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/measurement.d.ts.map

@@ -1 +1 @@
-{"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"}
+{"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;AAezB,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,QAAQ,GAAG,kBAAkB,EAAE,CAgG5E;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,CA+ElC;AAED,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,QAAQ,EACd,SAAS,EAAE,2BAA2B,GACrC,kBAAkB,GAAG,IAAI,CAiC3B"}

package/dist/wall/measurement.js

@@ -1,8 +1,19 @@
 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];
+function getWallChordT(wall, worldX, worldZ) {
+    const dx = wall.end[0] - wall.start[0];
+    const dz = wall.end[1] - wall.start[1];
+    const lenSq = dx * dx + dz * dz;
+    if (lenSq < 1e-8)
+        return 0.5;
+    const px = worldX - wall.start[0];
+    const pz = worldZ - wall.start[1];
+    return Math.max(0, Math.min(1, (px * dx + pz * dz) / lenSq));
+}
 export function wallMeasurementFeatures(wall) {
-    const height = resolveWallOpeningCeiling(wall, useScene.getState().nodes);
+    const nodes = useScene.getState().nodes;
+    const midHeight = resolveWallOpeningCeiling(wall, nodes, 0.5);
     const arc = getWallArcData(wall);
     const centerline = sampleWallCenterline(wall).map(({ x, y }) => point(x, 0, y));
     const midpoint = getWallCurveFrameAt(wall, 0.5).point;
@@ -77,7 +88,7 @@ export function wallMeasurementFeatures(wall) {
             geometry: {
                 kind: 'segment',
                 start: point(midpoint.x, 0, midpoint.y),
-                end: point(midpoint.x, height, midpoint.y),
+                end: point(midpoint.x, midHeight, midpoint.y),
             },
         },
         {
@@ -87,7 +98,11 @@ export function wallMeasurementFeatures(wall) {
             priority: 75,
             geometry: {
                 kind: 'path',
-                points: centerline.map(([x, , z]) => point(x, height, z)),
+                points: centerline.map(([x, , z]) => {
+                    const chordT = getWallChordT(wall, x, z);
+                    const h = resolveWallOpeningCeiling(wall, nodes, chordT);
+                    return point(x, h, z);
+                }),
             },
         },
     ];
@@ -145,7 +160,8 @@ export function matchWallMeasurementFeature(wall, hit, maxDistance) {
         const faceDistance = Math.hypot(hit[0] - faceX, hit[2] - faceZ);
         const threshold = Math.max(maxDistance, halfThickness + 0.03);
         if (faceDistance <= threshold && (!best || faceDistance < best.distance)) {
-            const height = Math.max(0, Math.min(resolveWallOpeningCeiling(wall, useScene.getState().nodes), hit[1]));
+            const chordT = getWallChordT(wall, faceX, faceZ);
+            const height = Math.max(0, Math.min(resolveWallOpeningCeiling(wall, useScene.getState().nodes, chordT), hit[1]));
             best = {
                 featureId: side > 0 ? 'wall:face:left' : 'wall:face:right',
                 point: point(faceX, height, faceZ),
@@ -175,7 +191,8 @@ export function resolveWallMeasurementFeature(wall, reference) {
     if (typeof heightValue !== 'number' || feature.geometry.kind !== 'path') {
         return normal ? { ...feature, normal } : feature;
     }
-    const height = Math.max(0, Math.min(resolveWallOpeningCeiling(wall, useScene.getState().nodes), heightValue));
+    const chordT = getWallChordT(wall, frame.point.x, frame.point.y);
+    const height = Math.max(0, Math.min(resolveWallOpeningCeiling(wall, useScene.getState().nodes, chordT), heightValue));
     return {
         ...feature,
         ...(normal ? { normal } : {}),

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

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

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-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 { acquireSceneHistoryPause, collectAlignmentAnchors, emitter, formatAngleRadians, getWallBaseElevationForNodes, getWallCurveLength, getWallThickness, resolveAlignment, resolveMovedWallSupportSlabPatch, runAsSingleSceneHistoryStep, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { CursorSphere, 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';
@@ -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 /
@@ -496,7 +497,7 @@ export const MoveWallEndpointTool = ({ target }) => {
         end: previewEnd,
         curveOffset: target.wall.curveOffset,
     });
-    const wallHeight = resolveWallOpeningCeiling(effectiveWall, nodes);
+    const wallHeight = resolveWallOpeningCeiling(effectiveWall, nodes, 0.5);
     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

package/dist/wall/move-shared.js

@@ -161,7 +161,7 @@ export function buildBridgeWallPreviews(args) {
             start: [...plan.originalPoint],
             end: [...nextPoint],
             color: getWallGhostColor(plan.wall),
-            height: resolveWallOpeningCeiling(plan.wall, useScene.getState().nodes),
+            height: resolveWallOpeningCeiling(plan.wall, useScene.getState().nodes, 0.5),
         };
         previews.push({ ghost, wall });
         wallsForDuplicateCheck.push(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"}