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

package/dist/shared/opening-documentation.js

@@ -0,0 +1,300 @@
+import { withFloorplanGeometryMetadata } from '@pascal-app/editor';
+import { formatConstructionLength, } from './construction-length';
+export function computeDoorFloorplanLevelData(args) {
+    return resolveOpeningMarks(args.siblings, args.nodes, 'door');
+}
+export function computeWindowFloorplanLevelData(args) {
+    return resolveOpeningMarks(args.siblings, args.nodes, 'window');
+}
+export function buildDoorFloorplanSchedule(args) {
+    if (args.siblings.length === 0)
+        return null;
+    const marks = resolveOpeningMarks(args.siblings, args.nodes, 'door', args.levelId);
+    return {
+        id: 'doors',
+        title: 'DOOR SCHEDULE',
+        columns: [
+            { key: 'mark', label: 'MARK', weight: 0.65 },
+            { key: 'type', label: 'TYPE', weight: 1.25 },
+            { key: 'size', label: 'NOMINAL SIZE', weight: 1.35 },
+            { key: 'roughOpening', label: 'ROUGH OPENING', weight: 1.35 },
+            { key: 'operation', label: 'OPERATION', weight: 1.35 },
+            { key: 'frame', label: 'FRAME T / D', weight: 1.25 },
+            { key: 'hardware', label: 'HARDWARE', weight: 1.35 },
+        ],
+        rows: args.siblings.map((door) => ({
+            id: door.id,
+            cells: {
+                mark: marks.markById.get(door.id) ?? '—',
+                type: door.openingKind === 'opening' ? 'Opening' : titleCase(door.doorType),
+                size: formatSize(door.width, door.height, args.unit, args.profile ?? 'document'),
+                roughOpening: formatRoughOpening(door, args.unit, args.profile ?? 'document'),
+                operation: doorOperation(door),
+                frame: `${formatConstructionLength(door.frameThickness, args.unit, args.profile ?? 'document')} / ${formatConstructionLength(door.frameDepth, args.unit, args.profile ?? 'document')}`,
+                hardware: doorHardware(door),
+            },
+        })),
+        issues: marks.issues,
+    };
+}
+export function buildWindowFloorplanSchedule(args) {
+    if (args.siblings.length === 0)
+        return null;
+    const marks = resolveOpeningMarks(args.siblings, args.nodes, 'window', args.levelId);
+    return {
+        id: 'windows',
+        title: 'WINDOW SCHEDULE',
+        columns: [
+            { key: 'mark', label: 'MARK', weight: 0.65 },
+            { key: 'type', label: 'TYPE', weight: 1.2 },
+            { key: 'size', label: 'NOMINAL SIZE', weight: 1.35 },
+            { key: 'roughOpening', label: 'ROUGH OPENING', weight: 1.35 },
+            { key: 'sill', label: 'SILL', weight: 0.9 },
+            { key: 'head', label: 'HEAD', weight: 0.9 },
+            { key: 'operation', label: 'OPERATION', weight: 1.35 },
+        ],
+        rows: args.siblings.map((window) => ({
+            id: window.id,
+            cells: {
+                mark: marks.markById.get(window.id) ?? '—',
+                type: window.openingKind === 'opening' ? 'Opening' : titleCase(window.windowType),
+                size: formatSize(window.width, window.height, args.unit, args.profile ?? 'document'),
+                roughOpening: formatRoughOpening(window, args.unit, args.profile ?? 'document'),
+                sill: formatConstructionLength(Math.max(0, window.position[1] - window.height / 2), args.unit, args.profile ?? 'document'),
+                head: formatConstructionLength(window.position[1] + window.height / 2, args.unit, args.profile ?? 'document'),
+                operation: windowOperation(window),
+            },
+        })),
+        issues: marks.issues,
+    };
+}
+export function buildOpeningMarkAnnotation(opening, wall, levelData, { preferredSide = -1, stroke = '#334155', } = {}) {
+    const dx = wall.end[0] - wall.start[0];
+    const dz = wall.end[1] - wall.start[1];
+    const wallLength = Math.hypot(dx, dz);
+    if (wallLength < 1e-6)
+        return null;
+    const dirX = dx / wallLength;
+    const dirZ = dz / wallLength;
+    const normalX = -dirZ;
+    const normalZ = dirX;
+    const side = interiorSide(wall, preferredSide);
+    const openingCenterX = wall.start[0] + dirX * opening.position[0];
+    const openingCenterZ = wall.start[1] + dirZ * opening.position[0];
+    const halfDepth = (wall.thickness ?? 0.1) / 2;
+    const bubbleOffset = halfDepth + 0.5;
+    const bubbleX = openingCenterX + normalX * bubbleOffset * side;
+    const bubbleZ = openingCenterZ + normalZ * bubbleOffset * side;
+    const explicitMark = opening.mark?.trim();
+    const mark = levelData?.markById.get(opening.id) ?? (explicitMark || fallbackMark(opening));
+    const bubbleWidth = Math.max(0.38, mark.length * 0.105 + 0.18);
+    const bubbleHeight = 0.32;
+    const leaderEndOffset = bubbleOffset - bubbleHeight / 2;
+    return withFloorplanGeometryMetadata({
+        kind: 'group',
+        children: [
+            {
+                kind: 'line',
+                x1: openingCenterX + normalX * halfDepth * side,
+                y1: openingCenterZ + normalZ * halfDepth * side,
+                x2: openingCenterX + normalX * leaderEndOffset * side,
+                y2: openingCenterZ + normalZ * leaderEndOffset * side,
+                stroke,
+                strokeWidth: 0.018,
+            },
+            {
+                kind: 'rect',
+                x: bubbleX - bubbleWidth / 2,
+                y: bubbleZ - bubbleHeight / 2,
+                width: bubbleWidth,
+                height: bubbleHeight,
+                rx: bubbleHeight / 2,
+                ry: bubbleHeight / 2,
+                fill: '#ffffff',
+                stroke,
+                strokeWidth: 0.02,
+            },
+            {
+                kind: 'text',
+                x: bubbleX,
+                y: bubbleZ,
+                text: mark,
+                fontSize: 0.15,
+                fill: stroke,
+                fontWeight: 700,
+                fontFamily: 'ui-monospace, SFMono-Regular, Menlo, monospace',
+                textAnchor: 'middle',
+                dominantBaseline: 'middle',
+                upright: true,
+            },
+        ],
+    }, { annotationRole: 'opening-mark' });
+}
+export function resolveOpeningDimensionDocumentation(opening) {
+    const constructionType = opening.constructionType ?? 'framed';
+    const requestedReference = constructionType === 'masonry' &&
+        opening.dimensionReference === 'nominal' &&
+        opening.masonryOpeningWidth !== undefined
+        ? 'masonry-opening'
+        : (opening.dimensionReference ?? 'nominal');
+    const dimensions = openingDocumentationDimensions(opening, requestedReference);
+    return {
+        constructionType,
+        reference: requestedReference,
+        locationPolicy: constructionType === 'masonry' ? 'edge-to-edge' : 'centerline',
+        width: dimensions.width,
+        height: dimensions.height,
+        prefix: openingDimensionPrefix(requestedReference),
+        verified: requestedReference === 'nominal' || dimensions.width !== null,
+    };
+}
+function resolveOpeningMarks(openings, nodes, kind, explicitLevelId) {
+    const markById = new Map();
+    const explicitMarks = new Map();
+    const used = new Set();
+    for (const opening of openings) {
+        const mark = opening.mark?.trim();
+        if (!mark)
+            continue;
+        markById.set(opening.id, mark);
+        used.add(mark.toLocaleUpperCase());
+        const normalized = mark.toLocaleUpperCase();
+        const ids = explicitMarks.get(normalized);
+        if (ids)
+            ids.push(opening.id);
+        else
+            explicitMarks.set(normalized, [opening.id]);
+    }
+    const level = resolveLevel(openings[0], nodes, explicitLevelId);
+    let sequence = 1;
+    for (const opening of openings) {
+        if (markById.has(opening.id))
+            continue;
+        let candidate = automaticMark(kind, level?.level ?? 0, sequence);
+        while (used.has(candidate.toLocaleUpperCase())) {
+            sequence++;
+            candidate = automaticMark(kind, level?.level ?? 0, sequence);
+        }
+        markById.set(opening.id, candidate);
+        used.add(candidate.toLocaleUpperCase());
+        sequence++;
+    }
+    const issues = [...explicitMarks.entries()]
+        .filter(([, ids]) => ids.length > 1)
+        .map(([mark, ids]) => `Duplicate ${kind} mark ${mark} (${ids.length} instances)`);
+    return { markById, issues };
+}
+function resolveLevel(opening, nodes, explicitLevelId) {
+    const explicit = explicitLevelId ? nodes[explicitLevelId] : undefined;
+    if (explicit?.type === 'level')
+        return explicit;
+    let current = opening;
+    const visited = new Set();
+    while (current?.parentId && !visited.has(current.parentId)) {
+        visited.add(current.parentId);
+        current = nodes[current.parentId];
+        if (current?.type === 'level')
+            return current;
+    }
+    return undefined;
+}
+function automaticMark(kind, level, sequence) {
+    if (kind === 'door')
+        return String((Math.max(0, level) + 1) * 100 + sequence);
+    return `W${String(sequence).padStart(2, '0')}`;
+}
+function fallbackMark(opening) {
+    return opening.type === 'door' ? 'D?' : 'W?';
+}
+function interiorSide(wall, fallback) {
+    if (wall.frontSide === 'exterior' && wall.backSide !== 'exterior')
+        return -1;
+    if (wall.backSide === 'exterior' && wall.frontSide !== 'exterior')
+        return 1;
+    return fallback;
+}
+function formatSize(width, height, unit, profile) {
+    return `${formatConstructionLength(width, unit, profile)} x ${formatConstructionLength(height, unit, profile)}`;
+}
+function formatRoughOpening(opening, unit, profile) {
+    if (opening.roughOpeningWidth === undefined || opening.roughOpeningHeight === undefined) {
+        return 'VERIFY';
+    }
+    return formatSize(opening.roughOpeningWidth, opening.roughOpeningHeight, unit, profile);
+}
+function openingDocumentationDimensions(opening, reference) {
+    switch (reference) {
+        case 'nominal':
+            return { width: opening.width, height: opening.height };
+        case 'rough-opening':
+            return {
+                width: opening.roughOpeningWidth ?? null,
+                height: opening.roughOpeningHeight ?? null,
+            };
+        case 'masonry-opening':
+            return {
+                width: opening.masonryOpeningWidth ?? null,
+                height: opening.masonryOpeningHeight ?? null,
+            };
+        case 'finish-opening':
+            return {
+                width: opening.finishOpeningWidth ?? null,
+                height: opening.finishOpeningHeight ?? null,
+            };
+    }
+}
+function openingDimensionPrefix(reference) {
+    switch (reference) {
+        case 'nominal':
+            return '';
+        case 'rough-opening':
+            return 'RO';
+        case 'masonry-opening':
+            return 'MO';
+        case 'finish-opening':
+            return 'FO';
+    }
+}
+function doorOperation(door) {
+    if (door.openingKind === 'opening')
+        return 'None';
+    if (door.doorType === 'hinged')
+        return `${titleCase(door.hingesSide)} / ${titleCase(door.swingDirection)}`;
+    if (door.doorType === 'sliding' || door.doorType === 'pocket' || door.doorType === 'barn') {
+        return `Slide ${titleCase(door.slideDirection)}`;
+    }
+    return titleCase(door.doorType);
+}
+function doorHardware(door) {
+    if (door.openingKind === 'opening')
+        return 'None';
+    const hardware = [];
+    if (door.doorCloser)
+        hardware.push('Closer');
+    if (door.panicBar)
+        hardware.push('Panic bar');
+    if (door.threshold)
+        hardware.push('Threshold');
+    return hardware.length > 0 ? hardware.join(', ') : 'Standard';
+}
+function windowOperation(window) {
+    if (window.openingKind === 'opening')
+        return 'None';
+    if (window.windowType === 'fixed')
+        return 'Fixed';
+    if (window.windowType === 'casement') {
+        return window.casementStyle === 'french'
+            ? 'French casement'
+            : `${titleCase(window.hingesSide)} hinge`;
+    }
+    if (window.windowType === 'awning' || window.windowType === 'hopper') {
+        return titleCase(window.awningDirection);
+    }
+    return titleCase(window.windowType);
+}
+function titleCase(value) {
+    return value
+        .split('-')
+        .map((part) => part.charAt(0).toLocaleUpperCase() + part.slice(1))
+        .join(' ');
+}

package/dist/shared/opening-guides-runtime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"opening-guides-runtime.d.ts","sourceRoot":"","sources":["../../src/shared/opening-guides-runtime.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,KAAK,OAAO,EAIZ,KAAK,WAAW,EAIhB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AASzB;;qFAEqF;AACrF,KAAK,OAAO,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAEjE,sEAAsE;AACtE,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,WAAW,EAAE,CAgBf;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE;IACpC,IAAI,EAAE,QAAQ,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B,GAAG,MAAM,GAAG,IAAI,CAchB;AAED,2EAA2E;AAC3E,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAC3C,IAAI,EAAE,QAAQ,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,eAAe,EAAE,OAAO,CAAA;IACxB,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B,GAAG,IAAI,CA2EP;AAED,wBAAgB,oBAAoB,IAAI,IAAI,CAE3C;AAiBD;yEACyE;AACzE,wBAAgB,WAAW,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CASnD;AAED;;;;;GAKG;AACH,wBAAgB,gCAAgC,CAAC,IAAI,EAAE;IACrD,IAAI,EAAE,QAAQ,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,eAAe,EAAE,OAAO,CAAA;IACxB,YAAY,EAAE,MAAM,CAAA;IACpB,aAAa,EAAE,MAAM,CAAA;CACtB,GAAG,IAAI,CAQP;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE;IACJ,EAAE,EAAE,MAAM,CAAA;IACV,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,QAAQ,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC3C,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf,EACD,eAAe,EAAE,OAAO,GACvB,IAAI,CAeN"}
+{"version":3,"file":"opening-guides-runtime.d.ts","sourceRoot":"","sources":["../../src/shared/opening-guides-runtime.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,KAAK,OAAO,EAIZ,KAAK,WAAW,EAIhB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAUzB;;qFAEqF;AACrF,KAAK,OAAO,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;AAEjE,sEAAsE;AACtE,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,QAAQ,EACd,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,WAAW,EAAE,CAgBf;AAED;;;;;GAKG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE;IACpC,IAAI,EAAE,QAAQ,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B,GAAG,MAAM,GAAG,IAAI,CAchB;AAED,2EAA2E;AAC3E,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAC3C,IAAI,EAAE,QAAQ,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,eAAe,EAAE,OAAO,CAAA;IACxB,OAAO,EAAE,OAAO,CAAA;IAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B,GAAG,IAAI,CA2EP;AAED,wBAAgB,oBAAoB,IAAI,IAAI,CAE3C;AAiBD;yEACyE;AACzE,wBAAgB,WAAW,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAYnD;AAED;;;;;GAKG;AACH,wBAAgB,gCAAgC,CAAC,IAAI,EAAE;IACrD,IAAI,EAAE,QAAQ,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;IACd,eAAe,EAAE,OAAO,CAAA;IACxB,YAAY,EAAE,MAAM,CAAA;IACpB,aAAa,EAAE,MAAM,CAAA;CACtB,GAAG,IAAI,CAQP;AAED;;;;;GAKG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE;IACJ,EAAE,EAAE,MAAM,CAAA;IACV,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACxB,QAAQ,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC3C,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf,EACD,eAAe,EAAE,OAAO,GACvB,IAAI,CAeN"}

package/dist/shared/opening-guides-runtime.js

@@ -4,6 +4,7 @@
 // tool's per-tick hook is a single call.
 import { computeOpeningGuides, detectVerticalAlignment, sceneRegistry, spatialGridManager, useScene, } from '@pascal-app/core';
 import { useOpeningGuides } from '@pascal-app/editor';
+import { resolveWallOpeningCeiling } from './wall-opening-ceiling';
 // Parity with `snapLocalXToNeighbors`' along-wall threshold.
 const SILL_SNAP_THRESHOLD_M = 0.08;
 // Hide a dimension that has collapsed to nothing (sill flush to the floor, or
@@ -50,7 +51,7 @@ export function resolveSillSnap(args) {
 export function publishOpeningGuides3D(args) {
     const { wall, centerS, centerY, width, toWorld } = args;
     const wallLength = Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
-    const wallHeight = wall.height ?? 2.5;
+    const wallHeight = resolveWallOpeningCeiling(wall, args.nodes);
     const siblings = collectOpeningSiblings(wall, args.movingId, args.nodes);
     const guides = computeOpeningGuides({
         moving: { id: args.movingId, centerS, width, centerY, height: args.height },
@@ -139,7 +140,7 @@ function makeWallToWorld(wall, levelYOffset, slabElevation) {
 export function wallToWorld(wall) {
     const levelId = wall.parentId;
     const levelYOffset = levelId ? (sceneRegistry.nodes.get(levelId)?.position.y ?? 0) : 0;
-    const slabElevation = spatialGridManager.getSlabElevationForWall(wall.parentId ?? '', wall.start, wall.end);
+    const slabElevation = spatialGridManager.getSlabElevationForWall(wall.parentId ?? '', wall.start, wall.end, wall.curveOffset ?? 0, wall.thickness, wall.supportSlabId);
     return makeWallToWorld(wall, levelYOffset, slabElevation);
 }
 /**

package/dist/shared/opening-placement-dimensions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"opening-placement-dimensions.d.ts","sourceRoot":"","sources":["../../src/shared/opening-placement-dimensions.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,QAAQ,EACb,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAIpB,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAEzB;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,QAAQ,GAAG,UAAU,EAC9B,GAAG,EAAE,eAAe,GACnB,iBAAiB,EAAE,CAsGrB"}
+{"version":3,"file":"opening-placement-dimensions.d.ts","sourceRoot":"","sources":["../../src/shared/opening-placement-dimensions.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,QAAQ,EACb,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAKpB,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAKzB;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,QAAQ,GAAG,UAAU,EAC9B,GAAG,EAAE,eAAe,GACnB,iBAAiB,EAAE,CA4GrB"}

package/dist/shared/opening-placement-dimensions.js

@@ -1,4 +1,7 @@
-import { computeOpeningGuides, isCurvedWall, } from '@pascal-app/core';
+import { computeOpeningGuides, isCurvedWall, useScene, } from '@pascal-app/core';
+import { readFloorplanContext } from '@pascal-app/editor';
+import { formatConstructionLength } from './construction-length';
+import { resolveWallOpeningCeiling } from './wall-opening-ceiling';
 /**
  * Build placement-measurement dimension lines for a door / window
  * being moved on a wall. Mirrors the legacy
@@ -46,7 +49,8 @@ export function buildOpeningPlacementDimensions(opening, ctx) {
         z1 + dirZ * along + outwardNormal[1] * halfThickness,
     ];
     const centrePoint = (along) => [x1 + dirX * along, z1 + dirZ * along];
-    const round = (value) => Number.parseFloat(value.toFixed(2));
+    const unit = ctx.viewState?.unit ?? 'metric';
+    const metricNotation = readFloorplanContext(ctx).metricNotation;
     // This wall's OTHER openings as wall-local spans. `ctx.siblings` only includes
     // same-kind nodes; doors and windows need each other, so resolve the wall's
     // children directly.
@@ -76,7 +80,10 @@ export function buildOpeningPlacementDimensions(opening, ctx) {
             height: opening.height,
         },
         siblings,
-        wall: { length: wallLength, height: wall.height ?? 2.5 },
+        wall: {
+            length: wallLength,
+            height: resolveWallOpeningCeiling(wall, useScene.getState().nodes),
+        },
         // The 2D plan is top-down: sill/head height and vertical alignment aren't
         // representable here — those belong to the 3D viewport.
         includeVertical: false,
@@ -93,14 +100,16 @@ export function buildOpeningPlacementDimensions(opening, ctx) {
             offsetNormal: outwardNormal,
             offsetDistance: FLOORPLAN_WALL_OUTER_MEASUREMENT_OFFSET,
             extensionOvershoot: 0.12,
-            text: `${round(gap.distance)}m`,
+            text: formatConstructionLength(gap.distance, unit, 'editor', { metricNotation }),
             stroke: '#f97316',
         });
     }
     // Equal-spacing rhythm — a "=" badge per equal gap, on the wall centreline.
     if (guides.equalSpacing) {
         const wallAngle = Math.atan2(dz, dx);
-        const text = `${round(guides.equalSpacing.gap)}m`;
+        const text = formatConstructionLength(guides.equalSpacing.gap, unit, 'editor', {
+            metricNotation,
+        });
         for (const seg of guides.equalSpacing.segments) {
             out.push({
                 kind: 'equal-spacing-badge',

package/dist/shared/wall-opening-ceiling.d.ts

@@ -0,0 +1,30 @@
+import { type AnyNode, type AnyNodeId, type WallNode } from '@pascal-app/core';
+/**
+ * Structural subset of `SceneApi` the opening-cap readers need — matches
+ * both handle-descriptor callbacks (which receive the full SceneApi) and
+ * tools holding a nodes snapshot.
+ */
+export type WallCeilingSceneReader = {
+    get: (id: AnyNodeId) => unknown;
+    nodes: () => Readonly<Record<AnyNodeId, AnyNode>>;
+};
+/**
+ * Available wall-local Y span for an opening hosted on `wall`: the wall's
+ * resolved top (storey plane for plane-bound walls, stored height for
+ * explicit ones) minus the wall's elected slab base. Wall-local Y = 0 sits
+ * at the elected base (where the viewer positions the wall mesh), so this
+ * is the ceiling an opening's top edge must stay under.
+ *
+ * Uses the same slab election as the viewer's WallSystem
+ * (`spatialGridManager.getSlabSupportForWall`) so the cap agrees with the
+ * rendered wall; headless callers with an empty spatial grid elect base 0
+ * and fall back to the full storey height.
+ */
+export declare function resolveWallOpeningCeiling(wall: WallNode, nodes: Readonly<Record<AnyNodeId, AnyNode>>): number;
+/**
+ * Height cap for a wall-hosted opening's resize handles. Infinity only when
+ * the opening is unhosted (no wallId, or the wall is gone) — roof-hosted
+ * openings clamp elsewhere.
+ */
+export declare function readHostWallCeiling(wallId: string | null | undefined, scene: WallCeilingSceneReader): number;
+//# sourceMappingURL=wall-opening-ceiling.d.ts.map

package/dist/shared/wall-opening-ceiling.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-opening-ceiling.d.ts","sourceRoot":"","sources":["../../src/shared/wall-opening-ceiling.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAEd,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAEzB;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,GAAG,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,OAAO,CAAA;IAC/B,KAAK,EAAE,MAAM,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAA;CAClD,CAAA;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,GAC1C,MAAM,CAER;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACjC,KAAK,EAAE,sBAAsB,GAC5B,MAAM,CAKR"}

package/dist/shared/wall-opening-ceiling.js

@@ -0,0 +1,29 @@
+import { getWallEffectiveHeightForNodes, } from '@pascal-app/core';
+/**
+ * Available wall-local Y span for an opening hosted on `wall`: the wall's
+ * resolved top (storey plane for plane-bound walls, stored height for
+ * explicit ones) minus the wall's elected slab base. Wall-local Y = 0 sits
+ * at the elected base (where the viewer positions the wall mesh), so this
+ * is the ceiling an opening's top edge must stay under.
+ *
+ * Uses the same slab election as the viewer's WallSystem
+ * (`spatialGridManager.getSlabSupportForWall`) so the cap agrees with the
+ * rendered wall; headless callers with an empty spatial grid elect base 0
+ * and fall back to the full storey height.
+ */
+export function resolveWallOpeningCeiling(wall, nodes) {
+    return getWallEffectiveHeightForNodes(wall, nodes);
+}
+/**
+ * Height cap for a wall-hosted opening's resize handles. Infinity only when
+ * the opening is unhosted (no wallId, or the wall is gone) — roof-hosted
+ * openings clamp elsewhere.
+ */
+export function readHostWallCeiling(wallId, scene) {
+    if (!wallId)
+        return Number.POSITIVE_INFINITY;
+    const wall = scene.get(wallId);
+    if (!wall)
+        return Number.POSITIVE_INFINITY;
+    return resolveWallOpeningCeiling(wall, scene.nodes());
+}

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/shelf/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EACxB,KAAK,SAAS,EAEf,MAAM,kBAAkB,CAAA;AAQzB,MAAM,MAAM,kBAAkB,GAAG;IAC/B,GAAG,EAAE,OAAO,GAAG,OAAO,CAAA;IAGtB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC3B,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,EAAE,mBAAmB,CAAC,SAAS,CAiChE,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,qBAAqB,EAAE,mBAAmB,CAAC,SAAS,CA+BhE,CAAA"}
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/shelf/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EACxB,KAAK,SAAS,EAGf,MAAM,kBAAkB,CAAA;AASzB,MAAM,MAAM,kBAAkB,GAAG;IAC/B,GAAG,EAAE,OAAO,GAAG,OAAO,CAAA;IAGtB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAC3B,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,EAAE,mBAAmB,CAAC,SAAS,CAmChE,CAAA;AAED;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,qBAAqB,EAAE,mBAAmB,CAAC,SAAS,CAiChE,CAAA"}

package/dist/shelf/floorplan-affordances.js

@@ -1,4 +1,5 @@
-import { useScene, } from '@pascal-app/core';
+import { useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { isAngleSnapActive } from '@pascal-app/editor';
 import { rotateAffordanceDelta } from '../shared/rotate-affordance';
 // Mirror the 3D handles in `shelf/definition.ts` so a drag can't push a
 // value past what the renderer / geometry builder accepts.
@@ -30,13 +31,15 @@ export const shelfResizeAffordance = {
                 else {
                     lastPatch = { depth: Math.max(MIN_SHELF_DEPTH, initialDepth + 2 * projDelta) };
                 }
-                useScene.getState().updateNode(shelfId, lastPatch);
+                useLiveNodeOverrides.getState().set(shelfId, lastPatch);
+                useScene.getState().markDirty(shelfId);
             },
             canCommit() {
                 return true;
             },
             commit() {
                 if (Object.keys(lastPatch).length > 0) {
+                    useLiveNodeOverrides.getState().clear(shelfId);
                     useScene.getState().updateNode(shelfId, lastPatch);
                 }
             },
@@ -66,21 +69,23 @@ export const shelfRotateAffordance = {
         let lastRotation = [r[0], initialRotationY, r[2]];
         return {
             affectedIds: [shelfId],
-            apply({ planPoint, modifiers }) {
+            apply({ planPoint }) {
                 const delta = rotateAffordanceDelta({
                     center: [cx, cz],
                     initialAngle,
                     planPoint,
-                    free: modifiers.shiftKey,
+                    free: !isAngleSnapActive(),
                 });
                 const newRotationY = initialRotationY - delta;
                 lastRotation = [r[0], newRotationY, r[2]];
-                useScene.getState().updateNode(shelfId, { rotation: lastRotation });
+                useLiveNodeOverrides.getState().set(shelfId, { rotation: lastRotation });
+                useScene.getState().markDirty(shelfId);
             },
             canCommit() {
                 return true;
             },
             commit() {
+                useLiveNodeOverrides.getState().clear(shelfId);
                 useScene.getState().updateNode(shelfId, { rotation: lastRotation });
             },
         };

package/dist/shelf/floorplan-move.d.ts

@@ -4,22 +4,8 @@ import { type FloorplanMoveTarget, type ShelfNode } from '@pascal-app/core';
  * because shelf is a `position`-field kind (it carries its location in
  * `node.position`, not in polygon vertices):
  *
- *   - Each pointermove writes the absolute world-plan position straight
- *     to `useScene` (history is paused by the overlay). This is the single
- *     source of truth: the 2D `FloorplanRegistryLayer` and the 3D
- *     `ParametricNodeRenderer` group transform both follow it reactively,
- *     so 2D and 3D can never diverge.
- *   - On commit, the overlay's snapshot-diff reverts to baseline, resumes
- *     history, and re-applies the final position as one undoable step.
- *     `canCommit` only validates.
- *
- * Earlier this used the `useLiveTransforms` + imperative-mesh pattern that
- * `slab` / `ceiling` use. That works for polygon kinds because their commit
- * rebuilds geometry (the vertices change), which forces the 3D group to
- * reconcile. Shelf's `geometryKey` excludes `position`, so its commit
- * `markDirty` is a no-op and nothing reconciled the 3D group off the cleared
- * live transform — the 2D SVG moved but the 3D mesh stayed put. Writing the
- * scene directly removes that second source of truth entirely.
+ *   - Each pointermove previews through `useLiveNodeOverrides`.
+ *   - On commit, the final position is written once as one undoable step.
  */
 export declare const shelfFloorplanMoveTarget: FloorplanMoveTarget<ShelfNode>;
 //# sourceMappingURL=floorplan-move.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/shelf/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,mBAAmB,EAGxB,KAAK,SAAS,EAEf,MAAM,kBAAkB,CAAA;AAWzB;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,wBAAwB,EAAE,mBAAmB,CAAC,SAAS,CA2EnE,CAAA"}
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/shelf/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,mBAAmB,EAGxB,KAAK,SAAS,EAGf,MAAM,kBAAkB,CAAA;AAYzB;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB,EAAE,mBAAmB,CAAC,SAAS,CAqEnE,CAAA"}

package/dist/shelf/floorplan-move.js

@@ -1,27 +1,13 @@
-import { collectAlignmentAnchors, movingFootprintAnchors, useScene, } from '@pascal-app/core';
-import { applyFloorplanAlignment, getFloorStackPreviewPosition, isMagneticSnapActive, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { collectAlignmentAnchors, movingFootprintAnchors, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { applyFloorplanAlignment, getFloorStackPreviewPosition, getSegmentGridStep, isGridSnapActive, isMagneticSnapActive, triggerSFX, } from '@pascal-app/editor';
 import { createFloorplanCursorResolver } from '../shared/floorplan-cursor';
 /**
  * 2D floor-plan move handler for shelf — mirrors `itemFloorplanMoveTarget`,
  * because shelf is a `position`-field kind (it carries its location in
  * `node.position`, not in polygon vertices):
  *
- *   - Each pointermove writes the absolute world-plan position straight
- *     to `useScene` (history is paused by the overlay). This is the single
- *     source of truth: the 2D `FloorplanRegistryLayer` and the 3D
- *     `ParametricNodeRenderer` group transform both follow it reactively,
- *     so 2D and 3D can never diverge.
- *   - On commit, the overlay's snapshot-diff reverts to baseline, resumes
- *     history, and re-applies the final position as one undoable step.
- *     `canCommit` only validates.
- *
- * Earlier this used the `useLiveTransforms` + imperative-mesh pattern that
- * `slab` / `ceiling` use. That works for polygon kinds because their commit
- * rebuilds geometry (the vertices change), which forces the 3D group to
- * reconcile. Shelf's `geometryKey` excludes `position`, so its commit
- * `markDirty` is a no-op and nothing reconciled the 3D group off the cleared
- * live transform — the 2D SVG moved but the 3D mesh stayed put. Writing the
- * scene directly removes that second source of truth entirely.
+ *   - Each pointermove previews through `useLiveNodeOverrides`.
+ *   - On commit, the final position is written once as one undoable step.
  */
 export const shelfFloorplanMoveTarget = ({ node, nodes }) => {
     const shelfId = node.id;
@@ -32,6 +18,7 @@ export const shelfFloorplanMoveTarget = ({ node, nodes }) => {
         metadata: node.metadata,
     });
     let lastPosition = originalPosition;
+    let lastVisualPosition = originalPosition;
     let lastSnapKey = null;
     // Alignment candidates — corner/edge/segment anchors of every OTHER node
     // (incl. wall faces). Gathered once: the scene is stable during the drag
@@ -39,25 +26,21 @@ export const shelfFloorplanMoveTarget = ({ node, nodes }) => {
     const candidates = collectAlignmentAnchors(nodes, shelfId);
     const session = {
         affectedIds: [shelfId],
-        apply({ planPoint, modifiers }) {
-            const snap = (value) => {
-                if (modifiers.shiftKey)
-                    return value;
-                const step = useEditor.getState().gridSnapStep;
-                return Math.round(value / step) * step;
-            };
+        apply({ planPoint }) {
+            const gridSnapActive = isGridSnapActive();
+            const step = gridSnapActive ? getSegmentGridStep() : 0;
+            const snap = (value) => (step > 0 ? Math.round(value / step) * step : value);
             const gridSnapped = resolveCursor(planPoint, { snap });
             // Figma-style alignment layered on the grid snap — the shelf footprint
-            // edges snap to neighbours / wall faces and a guide is published. Alt
-            // bypasses alignment; Shift bypasses all snap.
-            const { point: snapped } = applyFloorplanAlignment(gridSnapped, movingFootprintAnchors(node, gridSnapped[0], gridSnapped[1], originalRotationY), candidates, { applySnap: isMagneticSnapActive(), bypass: modifiers.altKey || modifiers.shiftKey });
+            // edges snap to neighbours / wall faces and a guide is published.
+            const { point: snapped } = applyFloorplanAlignment(gridSnapped, movingFootprintAnchors(node, gridSnapped[0], gridSnapped[1], originalRotationY), candidates, { applySnap: isMagneticSnapActive() });
             const next = [snapped[0], originalPosition[1], snapped[1]];
             lastPosition = next;
             // Grid-snap SFX on cell crossings — matches the 3D `MoveSlabTool`
             // and the placement coordinators. Item / slab / wall flows fire
             // the same cue, so the shelf following along is the expected UX.
             const snapKey = `${snapped[0]},${snapped[1]}`;
-            if (!modifiers.shiftKey && snapKey !== lastSnapKey) {
+            if (gridSnapActive && snapKey !== lastSnapKey) {
                 triggerSFX('sfx:grid-snap');
                 lastSnapKey = snapKey;
             }
@@ -67,17 +50,9 @@ export const shelfFloorplanMoveTarget = ({ node, nodes }) => {
                 rotation: node.rotation,
                 levelId: node.parentId ?? null,
             });
-            // Single source of truth — write the absolute position straight to
-            // the scene (history is paused by the overlay). Both the 2D SVG and
-            // the 3D group transform read `node.position` reactively, so they
-            // stay in lockstep. The overlay's snapshot-diff turns the whole drag
-            // into one undoable step on commit.
-            useScene.getState().updateNodes([
-                {
-                    id: shelfId,
-                    data: { position: visualPosition },
-                },
-            ]);
+            lastVisualPosition = visualPosition;
+            useLiveNodeOverrides.getState().set(shelfId, { position: visualPosition });
+            useScene.getState().markDirty(shelfId);
         },
         canCommit() {
             const live = useScene.getState().nodes[shelfId];
@@ -85,6 +60,10 @@ export const shelfFloorplanMoveTarget = ({ node, nodes }) => {
                 return false;
             return !(lastPosition[0] === originalPosition[0] && lastPosition[2] === originalPosition[2]);
         },
+        commit() {
+            useLiveNodeOverrides.getState().clear(shelfId);
+            useScene.getState().updateNodes([{ id: shelfId, data: { position: lastVisualPosition } }]);
+        },
     };
     return session;
 };

package/dist/shelf/tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/shelf/tool.tsx"],"names":[],"mappings":"AAgCA,QAAA,MAAM,SAAS,0CA0Id,CAAA;AAED,eAAe,SAAS,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/shelf/tool.tsx"],"names":[],"mappings":"AAiCA,QAAA,MAAM,SAAS,0CA+Id,CAAA;AAED,eAAe,SAAS,CAAA"}