@pascal-app/nodes 0.1.1 → 1.0.0-beta.1

package/dist/wall/contextual-dimensions.d.ts

@@ -0,0 +1,13 @@
+import { type FloorplanGeometry, type GeometryContext, type WallNode } from '@pascal-app/core';
+type WallHostedOpening = {
+    position: readonly [number, number, number];
+    width: number;
+};
+type OpeningDimensionOptions = {
+    showClearancesWhileMoving: boolean;
+    useExteriorNormal: boolean;
+};
+export declare function buildWallContextualDimensions(node: WallNode, ctx: GeometryContext): FloorplanGeometry | null;
+export declare function buildWallHostedOpeningContextualDimensions(node: WallHostedOpening, ctx: GeometryContext, options: OpeningDimensionOptions): FloorplanGeometry | null;
+export {};
+//# sourceMappingURL=contextual-dimensions.d.ts.map

package/dist/wall/contextual-dimensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contextual-dimensions.d.ts","sourceRoot":"","sources":["../../src/wall/contextual-dimensions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAKpB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAGzB,KAAK,iBAAiB,GAAG;IACvB,QAAQ,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC3C,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,KAAK,uBAAuB,GAAG;IAC7B,yBAAyB,EAAE,OAAO,CAAA;IAClC,iBAAiB,EAAE,OAAO,CAAA;CAC3B,CAAA;AA+ID,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CA8C1B;AAED,wBAAgB,0CAA0C,CACxD,IAAI,EAAE,iBAAiB,EACvB,GAAG,EAAE,eAAe,EACpB,OAAO,EAAE,uBAAuB,GAC/B,iBAAiB,GAAG,IAAI,CAyE1B"}

package/dist/wall/contextual-dimensions.js

@@ -0,0 +1,221 @@
+import { getWallCurveFrameAt, getWallCurveLength, getWallThickness, isCurvedWall, } from '@pascal-app/core';
+import { formatLinearMeasurement, readFloorplanMetricNotationOverride } from '@pascal-app/editor';
+const WALL_CONNECTION_TOLERANCE = 0.03;
+function formatLength(value, ctx) {
+    return formatLinearMeasurement(value, ctx.viewState?.unit ?? 'metric', readFloorplanMetricNotationOverride(ctx) ?? 'meters');
+}
+function selectedStroke(ctx) {
+    return ctx.viewState?.palette?.selectedStroke ?? '#2563eb';
+}
+function contextualWallDimensionNormal(wall, frontNormal, siblings) {
+    const front = [cleanZero(frontNormal[0]), cleanZero(frontNormal[1])];
+    const back = [cleanZero(-front[0]), cleanZero(-front[1])];
+    if (wall.frontSide === 'exterior' && wall.backSide !== 'exterior')
+        return front;
+    if (wall.backSide === 'exterior' && wall.frontSide !== 'exterior')
+        return back;
+    if (wall.frontSide === 'interior' && wall.backSide === 'interior')
+        return front;
+    const walls = [
+        wall,
+        ...siblings.filter((sibling) => sibling.type === 'wall'),
+    ];
+    let centroidX = 0;
+    let centroidY = 0;
+    for (const candidate of walls) {
+        centroidX += candidate.start[0] + candidate.end[0];
+        centroidY += candidate.start[1] + candidate.end[1];
+    }
+    const centroid = [centroidX / (walls.length * 2), centroidY / (walls.length * 2)];
+    const midpoint = [
+        (wall.start[0] + wall.end[0]) / 2,
+        (wall.start[1] + wall.end[1]) / 2,
+    ];
+    const towardFront = (midpoint[0] - centroid[0]) * front[0] + (midpoint[1] - centroid[1]) * front[1];
+    return towardFront >= 0 ? front : back;
+}
+function cleanZero(value) {
+    return Math.abs(value) <= Number.EPSILON ? 0 : value;
+}
+function cross(left, right) {
+    return left[0] * right[1] - left[1] * right[0];
+}
+function pointSegmentDistance(point, start, end) {
+    const dx = end[0] - start[0];
+    const dy = end[1] - start[1];
+    const lengthSquared = dx * dx + dy * dy;
+    if (lengthSquared <= 1e-12)
+        return Math.hypot(point[0] - start[0], point[1] - start[1]);
+    const t = Math.max(0, Math.min(1, ((point[0] - start[0]) * dx + (point[1] - start[1]) * dy) / lengthSquared));
+    return Math.hypot(point[0] - (start[0] + dx * t), point[1] - (start[1] + dy * t));
+}
+function structuralFaceProjections(wallStart, wallTangent, connectedWall) {
+    if (isCurvedWall(connectedWall))
+        return [];
+    const dx = connectedWall.end[0] - connectedWall.start[0];
+    const dy = connectedWall.end[1] - connectedWall.start[1];
+    const length = Math.hypot(dx, dy);
+    if (length <= 1e-6)
+        return [];
+    const direction = [dx / length, dy / length];
+    const denominator = cross(wallTangent, direction);
+    if (Math.abs(denominator) <= 1e-6)
+        return [];
+    const normal = [-direction[1], direction[0]];
+    const halfThickness = getWallThickness(connectedWall) / 2;
+    return [-halfThickness, halfThickness].map((offset) => {
+        const facePoint = [
+            connectedWall.start[0] + normal[0] * offset,
+            connectedWall.start[1] + normal[1] * offset,
+        ];
+        return (cross([facePoint[0] - wallStart[0], facePoint[1] - wallStart[1]], direction) / denominator);
+    });
+}
+function wallStudFaceSpan(wall, siblings) {
+    const dx = wall.end[0] - wall.start[0];
+    const dy = wall.end[1] - wall.start[1];
+    const centerlineLength = Math.hypot(dx, dy);
+    if (centerlineLength <= 1e-6) {
+        return { start: wall.start, end: wall.end, length: centerlineLength };
+    }
+    const tangent = [dx / centerlineLength, dy / centerlineLength];
+    let startProjection = 0;
+    let endProjection = centerlineLength;
+    for (const sibling of siblings) {
+        if (sibling.type !== 'wall' || sibling.id === wall.id)
+            continue;
+        const projections = structuralFaceProjections(wall.start, tangent, sibling);
+        if (pointSegmentDistance(wall.start, sibling.start, sibling.end) <= WALL_CONNECTION_TOLERANCE) {
+            for (const projection of projections) {
+                if (projection > startProjection && projection < endProjection) {
+                    startProjection = projection;
+                }
+            }
+        }
+        if (pointSegmentDistance(wall.end, sibling.start, sibling.end) <= WALL_CONNECTION_TOLERANCE) {
+            for (const projection of projections) {
+                if (projection > startProjection && projection < endProjection) {
+                    endProjection = projection;
+                }
+            }
+        }
+    }
+    const start = [
+        wall.start[0] + tangent[0] * startProjection,
+        wall.start[1] + tangent[1] * startProjection,
+    ];
+    const end = [
+        wall.start[0] + tangent[0] * endProjection,
+        wall.start[1] + tangent[1] * endProjection,
+    ];
+    return { start, end, length: Math.max(0, endProjection - startProjection) };
+}
+export function buildWallContextualDimensions(node, ctx) {
+    const length = getWallCurveLength(node);
+    if (!Number.isFinite(length) || length <= 1e-6)
+        return null;
+    if (isCurvedWall(node)) {
+        const frame = getWallCurveFrameAt(node, 0.5);
+        const offsetNormal = contextualWallDimensionNormal(node, [frame.normal.x, frame.normal.y], ctx.siblings);
+        return {
+            kind: 'dimension-label',
+            appearance: 'outlined',
+            cx: frame.point.x + offsetNormal[0] * 0.38,
+            cy: frame.point.y + offsetNormal[1] * 0.38,
+            text: formatLength(length, ctx),
+            angle: Math.atan2(frame.tangent.y, frame.tangent.x),
+        };
+    }
+    const dx = node.end[0] - node.start[0];
+    const dy = node.end[1] - node.start[1];
+    const chordLength = Math.hypot(dx, dy);
+    if (chordLength <= 1e-6)
+        return null;
+    const offsetNormal = contextualWallDimensionNormal(node, [-dy / chordLength, dx / chordLength], ctx.siblings);
+    const span = node.frontSide === 'interior' && node.backSide === 'interior'
+        ? wallStudFaceSpan(node, ctx.siblings)
+        : { start: node.start, end: node.end, length: chordLength };
+    if (span.length <= 1e-6)
+        return null;
+    return {
+        kind: 'dimension',
+        start: span.start,
+        end: span.end,
+        offsetNormal,
+        offsetDistance: 0.34,
+        extensionOvershoot: 0.08,
+        text: formatLength(span.length, ctx),
+        stroke: selectedStroke(ctx),
+    };
+}
+export function buildWallHostedOpeningContextualDimensions(node, ctx, options) {
+    const wall = ctx.parent;
+    if (wall?.type !== 'wall' || node.width <= 1e-6)
+        return null;
+    const dx = wall.end[0] - wall.start[0];
+    const dy = wall.end[1] - wall.start[1];
+    const wallLength = Math.hypot(dx, dy);
+    if (wallLength <= 1e-6)
+        return null;
+    const dirX = dx / wallLength;
+    const dirY = dy / wallLength;
+    const cx = wall.start[0] + dirX * node.position[0];
+    const cy = wall.start[1] + dirY * node.position[0];
+    const halfWidth = node.width / 2;
+    const openingStart = [cx - dirX * halfWidth, cy - dirY * halfWidth];
+    const openingEnd = [cx + dirX * halfWidth, cy + dirY * halfWidth];
+    if (!options.useExteriorNormal || isCurvedWall(wall)) {
+        return {
+            kind: 'dimension',
+            start: openingStart,
+            end: openingEnd,
+            offsetNormal: [-dirY, dirX],
+            offsetDistance: 0.34,
+            extensionOvershoot: 0.08,
+            text: formatLength(node.width, ctx),
+            stroke: selectedStroke(ctx),
+        };
+    }
+    const offsetNormal = contextualWallDimensionNormal(wall, [-dirY, dirX], ctx.siblings);
+    if (!options.showClearancesWhileMoving || !ctx.viewState?.moving) {
+        return {
+            kind: 'dimension',
+            start: openingStart,
+            end: openingEnd,
+            offsetNormal,
+            offsetDistance: 0.34,
+            extensionOvershoot: 0.08,
+            text: formatLength(node.width, ctx),
+            stroke: selectedStroke(ctx),
+        };
+    }
+    const span = wallStudFaceSpan(wall, ctx.siblings);
+    const spanStart = (span.start[0] - wall.start[0]) * dirX + (span.start[1] - wall.start[1]) * dirY;
+    const spanEnd = (span.end[0] - wall.start[0]) * dirX + (span.end[1] - wall.start[1]) * dirY;
+    const openingStartAlong = node.position[0] - halfWidth;
+    const openingEndAlong = node.position[0] + halfWidth;
+    return {
+        kind: 'dimension-string',
+        segments: [
+            {
+                start: span.start,
+                end: openingStart,
+                text: formatLength(Math.max(0, openingStartAlong - spanStart), ctx),
+            },
+            {
+                start: openingStart,
+                end: openingEnd,
+                text: formatLength(node.width, ctx),
+            },
+            {
+                start: openingEnd,
+                end: span.end,
+                text: formatLength(Math.max(0, spanEnd - openingEndAlong), ctx),
+            },
+        ],
+        offsetNormal,
+        offsetDistance: 0.34,
+        extensionOvershoot: 0.08,
+        stroke: selectedStroke(ctx),
+    };
+}

package/dist/wall/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/wall/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAatD,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAGnC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAoH1D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/wall/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAa,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAejE,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAGnC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAoI1D,CAAA"}

package/dist/wall/definition.js

@@ -1,3 +1,4 @@
+import { buildWallContextualDimensions } from './contextual-dimensions';
 import { buildWallFloorplan, computeWallFloorplanLevelData } from './floorplan';
 import { wallCurveAffordance, wallMoveEndpointAffordance } from './floorplan-affordances';
 import { wallFloorplanMoveTarget } from './floorplan-move';
@@ -26,10 +27,27 @@ import { wallSlots } from './slots';
 export const wallDefinition = {
     kind: 'wall',
     snapProfile: 'structural',
-    schemaVersion: 5,
+    schemaVersion: 7,
     schema: WallNode,
     category: 'structure',
     surfaceRole: 'wall',
+    extensions: {
+        'pascal:editor/floorplan': {
+            contextualDimensions: buildWallContextualDimensions,
+            actionMenu: {
+                canCurve: ({ node, nodes }) => !node.children.some((childId) => {
+                    const child = nodes[childId];
+                    if (!child)
+                        return false;
+                    if (child.type === 'door' || child.type === 'window')
+                        return true;
+                    if (child.type !== 'item')
+                        return false;
+                    return child.asset?.attachTo === 'wall' || child.asset?.attachTo === 'wall-side';
+                }),
+            },
+        },
+    },
     defaults: () => ({
         object: 'node',
         parentId: null,
@@ -80,6 +98,7 @@ export const wallDefinition = {
     // auto-slab live preview, history dances). Placement is wired via
     // `def.tool`.
     tool: () => import('./tool'),
+    preview: () => import('./preview'),
     affordanceTools: {
         curve: () => import('./curve-tool'),
         'move-endpoint': () => import('./move-endpoint-tool'),

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/wall/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,mBAAmB,EAQxB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAoFzB;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,EAAE,mBAAmB,CAAC,QAAQ,CAuD7D,CAAA;AAED,eAAO,MAAM,0BAA0B,EAAE,mBAAmB,CAAC,QAAQ,CA2JpE,CAAA"}
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/wall/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,mBAAmB,EAQxB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAoFzB;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,EAAE,mBAAmB,CAAC,QAAQ,CAuD7D,CAAA;AAED,eAAO,MAAM,0BAA0B,EAAE,mBAAmB,CAAC,QAAQ,CA0KpE,CAAA"}

package/dist/wall/floorplan-affordances.js

@@ -97,6 +97,18 @@ export const wallMoveEndpointAffordance = {
         const originalEnd = [...node.end];
         const linkedWalls = collectLinkedWalls(nodes, node.id, originalStart, originalEnd);
         const affectedIds = [node.id, ...linkedWalls.map((w) => w.id)];
+        const movingOriginal = endpoint === 'start' ? originalStart : originalEnd;
+        // Walls attached to the MOVING corner cascade with the drag, but the snap
+        // pipeline reads the scene store, which keeps their pre-drag coordinates
+        // until commit. Their stale corners would recreate the old junction as a
+        // snap/alignment target: inside the connect radius the endpoint could
+        // never land closer than ~5cm to where it started, making sub-5cm
+        // corrections (e.g. squaring a scan-imported 91° corner) impossible.
+        // Excluded while attached; under Alt-detach they stay put and remain
+        // legitimate targets. Mirrors the 3D move-endpoint tool.
+        const movingLinkedWallIds = linkedWalls
+            .filter((w) => pointsEqual(w.start, movingOriginal) || pointsEqual(w.end, movingOriginal))
+            .map((w) => w.id);
         // Remember the latest preview so `commit()` can write it tracked.
         let lastPrimaryStart = originalStart;
         let lastPrimaryEnd = originalEnd;
@@ -107,11 +119,12 @@ export const wallMoveEndpointAffordance = {
                 // Re-collect walls every tick so the snap pipeline sees fresh
                 // positions (matters when the user releases + re-grabs without
                 // unmounting the layer). Snap reads from scene — which holds
-                // the pre-drag positions throughout — so the linked-wall snap
-                // targets stay anchored to where corners *were*, exactly like
-                // the legacy flow.
+                // the pre-drag positions throughout — so walls that cascade with
+                // the moving corner are excluded (stale coordinates); under
+                // Alt-detach they stay put, so they rejoin the candidate pool.
                 const sceneNodes = useScene.getState().nodes;
                 const walls = collectLevelWalls(sceneNodes, node.id);
+                const staleWallIds = modifiers.altKey ? [node.id] : [node.id, ...movingLinkedWallIds];
                 // The grid step follows the active snapping mode (`getSegmentGridStep()`
                 // is 0 outside grid mode), so `'lines' / 'angles' / 'off'` no longer
                 // force a grid snap the mode chip says is inactive. In `'angles'` mode
@@ -121,7 +134,7 @@ export const wallMoveEndpointAffordance = {
                 const snapped = snapWallDraftPoint({
                     point: planPoint,
                     walls,
-                    ignoreWallIds: [node.id],
+                    ignoreWallIds: staleWallIds,
                     start: angleLocked ? fixedPoint : undefined,
                     angleSnap: angleLocked,
                     magnetic: isMagneticSnapActive(),
@@ -131,13 +144,15 @@ export const wallMoveEndpointAffordance = {
                 // object's edge / wall face and publishes a guide. The guide is
                 // DISPLAYED in every mode except Off (isAlignmentGuideActive); the
                 // magnetic pull onto it is applied only in 'lines' mode
-                // (isMagneticSnapActive), like the draft tool does. The dragged wall and
-                // its linked siblings (which cascade with the corner) are excluded from
-                // the candidate pool. Alt is detach, NOT bypass.
+                // (isMagneticSnapActive), like the draft tool does. Only the dragged
+                // wall and the siblings cascading with the moving corner are excluded
+                // from the candidate pool — walls linked at the FIXED corner don't
+                // move, and their anchors are what let the dragged corner align back
+                // onto a true axis. Alt is detach, NOT bypass.
                 const aligned = alignFloorplanDraftPoint(snapped, {
                     applySnap: isMagneticSnapActive(),
                     bypass: !isAlignmentGuideActive(),
-                    excludeIds: [node.id, ...linkedWalls.map((w) => w.id)],
+                    excludeIds: staleWallIds,
                 });
                 const primaryStart = endpoint === 'start' ? aligned : fixedPoint;
                 const primaryEnd = endpoint === 'end' ? aligned : fixedPoint;

package/dist/wall/floorplan-overrides.d.ts

@@ -1,22 +1,25 @@
-import type { AnyNode, AnyNodeId } from '@pascal-app/core';
+import type { AnyNode, AnyNodeId, LiveTransform } from '@pascal-app/core';
 /**
- * Project per-frame wall drag overrides (`{ start, end, curveOffset }`)
- * from `useLiveNodeOverrides` into a fresh `nodes` snapshot. The 2D drag
+ * Project per-frame wall and opening drag overrides into a fresh `nodes`
+ * snapshot. Wall overrides keep shared miters current; door and window
+ * overrides keep associative construction dimensions current while an
+ * opening moves or changes host. The 2D drag
  * handlers publish overrides for the moved wall plus its linked
  * neighbours; the floor-plan layer hands the merged snapshot to
  * `buildContext` so each wall's `ctx.siblings` (which feeds the
  * miter calculation) reflects the live cursor positions instead of
  * the last committed scene state.
  *
- * Only wall entries are touched; every other node is shared by
- * reference. The allocation cost is one shallow object per overridden
- * wall — the override map is small, so this is cheap. When the
+ * Other node types are shared by reference. The allocation cost is one
+ * shallow object per relevant override — the override map is small, so
+ * this is cheap. When the
  * override map is empty (no live drag) the input is returned
  * unchanged.
  */
 export declare function wallFloorplanSiblingOverrides(args: {
     nodeId: AnyNodeId;
     nodes: Record<AnyNodeId, AnyNode>;
+    liveTransforms?: Map<string, LiveTransform>;
     liveOverrides: Map<string, Record<string, unknown>>;
 }): Record<AnyNodeId, AnyNode>;
 //# sourceMappingURL=floorplan-overrides.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan-overrides.d.ts","sourceRoot":"","sources":["../../src/wall/floorplan-overrides.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAE1D;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,6BAA6B,CAAC,IAAI,EAAE;IAClD,MAAM,EAAE,SAAS,CAAA;IACjB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CACpD,GAAG,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAY7B"}
+{"version":3,"file":"floorplan-overrides.d.ts","sourceRoot":"","sources":["../../src/wall/floorplan-overrides.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA;AAEzE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,6BAA6B,CAAC,IAAI,EAAE;IAClD,MAAM,EAAE,SAAS,CAAA;IACjB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,cAAc,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;IAC3C,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;CACpD,GAAG,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAqB7B"}

package/dist/wall/floorplan-overrides.js

@@ -1,32 +1,41 @@
 /**
- * Project per-frame wall drag overrides (`{ start, end, curveOffset }`)
- * from `useLiveNodeOverrides` into a fresh `nodes` snapshot. The 2D drag
+ * Project per-frame wall and opening drag overrides into a fresh `nodes`
+ * snapshot. Wall overrides keep shared miters current; door and window
+ * overrides keep associative construction dimensions current while an
+ * opening moves or changes host. The 2D drag
  * handlers publish overrides for the moved wall plus its linked
  * neighbours; the floor-plan layer hands the merged snapshot to
  * `buildContext` so each wall's `ctx.siblings` (which feeds the
  * miter calculation) reflects the live cursor positions instead of
  * the last committed scene state.
  *
- * Only wall entries are touched; every other node is shared by
- * reference. The allocation cost is one shallow object per overridden
- * wall — the override map is small, so this is cheap. When the
+ * Other node types are shared by reference. The allocation cost is one
+ * shallow object per relevant override — the override map is small, so
+ * this is cheap. When the
  * override map is empty (no live drag) the input is returned
  * unchanged.
  */
 export function wallFloorplanSiblingOverrides(args) {
-    const { nodes, liveOverrides } = args;
-    if (liveOverrides.size === 0)
+    const { nodes, liveOverrides, liveTransforms } = args;
+    if (liveOverrides.size === 0 && !liveTransforms?.size)
         return nodes;
     let out = null;
-    for (const [id, override] of liveOverrides) {
+    const ids = new Set([...liveOverrides.keys(), ...(liveTransforms?.keys() ?? [])]);
+    for (const id of ids) {
         const existing = nodes[id];
-        if (existing?.type !== 'wall')
+        if (existing?.type !== 'wall' && existing?.type !== 'door' && existing?.type !== 'window') {
             continue;
-        if (Object.keys(override).length === 0)
+        }
+        const override = liveOverrides.get(id);
+        const liveTransform = liveTransforms?.get(id);
+        const livePosition = liveTransform && (existing.type === 'door' || existing.type === 'window')
+            ? { position: liveTransform.position }
+            : undefined;
+        if ((!override || Object.keys(override).length === 0) && !livePosition)
             continue;
         if (!out)
             out = { ...nodes };
-        out[id] = { ...existing, ...override };
+        out[id] = { ...existing, ...override, ...livePosition };
     }
     return out ?? nodes;
 }

package/dist/wall/floorplan.d.ts

@@ -1,8 +1,16 @@
 import { type AnyNode, type FloorplanGeometry, type GeometryContext, type WallMiterData, type WallNode } from '@pascal-app/core';
-export declare function computeWallFloorplanLevelData({ siblings, }: {
+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;
+    constructionDimensionsByReference: Record<WallDimensionReference, WallConstructionDimensionPlan>;
+};
+export declare function computeWallFloorplanLevelData({ siblings, nodes, }: {
     siblings: ReadonlyArray<WallNode>;
     nodes: Record<string, AnyNode>;
-}): WallMiterData;
+}): WallFloorplanLevelData;
 /**
  * Stage C floor-plan builder for wall — emits the full chrome stack the
  * legacy `floorplan-panel.tsx` rendered inline:
@@ -13,11 +21,12 @@ export declare function computeWallFloorplanLevelData({ siblings, }: {
  *      wall body easily.
  *   4. Two endpoint handles (start + end) when selected — the registry
  *      layer hosts the 5-circle stack + hover transitions + 2D drag.
- *   5. A small dimension label at the midpoint when selected.
+ *   5. Exterior facade strings plus interior wall spans and hosted-opening widths.
  *
  * `ctx.levelData` provides the shared level miter graph when the floor-plan
  * dispatcher precomputes it; `ctx.siblings` remains the fallback path for
  * 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,EAEZ,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAKpB,KAAK,aAAa,EAClB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AA0BzB,wBAAgB,6BAA6B,CAAC,EAC5C,QAAQ,GACT,EAAE;IACD,QAAQ,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAA;IACjC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B,GAAG,aAAa,CAEhB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CA+LjG"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/wall/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAEZ,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAOpB,KAAK,aAAa,EAClB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAKL,KAAK,6BAA6B,EACnC,MAAM,2BAA2B,CAAA;AAWlC,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,CAoMjG"}