@pascal-app/nodes 1.0.1 → 1.0.4

package/dist/shared/opening-documentation.js

@@ -1,15 +1,26 @@
-import { withFloorplanGeometryMetadata } from '@pascal-app/editor';
+import { getOpeningFloorDatum, getWallLocalFaceZ, wallSupportForNodes } from '@pascal-app/core';
+import { resolveMarkDetail, withFloorplanGeometryMetadata, } from '@pascal-app/editor';
 import { formatConstructionLength, } from './construction-length';
+function openingLevelData(openings, nodes, kind) {
+    let drafted;
+    return {
+        markById: resolveOpeningMarks(openings, nodes, kind).markById,
+        draftingMarkById: () => {
+            drafted ??= resolveOpeningMarks(openings, nodes, kind, undefined, true).markById;
+            return drafted;
+        },
+    };
+}
 export function computeDoorFloorplanLevelData(args) {
-    return resolveOpeningMarks(args.siblings, args.nodes, 'door');
+    return openingLevelData(args.siblings, args.nodes, 'door');
 }
 export function computeWindowFloorplanLevelData(args) {
-    return resolveOpeningMarks(args.siblings, args.nodes, 'window');
+    return openingLevelData(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);
+    const marks = resolveOpeningMarks(args.siblings, args.nodes, 'door', args.levelId, args.drafting === true);
     return {
         id: 'doors',
         title: 'DOOR SCHEDULE',
@@ -40,7 +51,7 @@ export function buildDoorFloorplanSchedule(args) {
 export function buildWindowFloorplanSchedule(args) {
     if (args.siblings.length === 0)
         return null;
-    const marks = resolveOpeningMarks(args.siblings, args.nodes, 'window', args.levelId);
+    const marks = resolveOpeningMarks(args.siblings, args.nodes, 'window', args.levelId, args.drafting === true);
     return {
         id: 'windows',
         title: 'WINDOW SCHEDULE',
@@ -60,15 +71,42 @@ export function buildWindowFloorplanSchedule(args) {
                 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'),
+                sill: formatConstructionLength(Math.max(0, window.position[1] - window.height / 2 + openingDatumOffset(window, args.nodes)), args.unit, args.profile ?? 'document'),
+                head: formatConstructionLength(window.position[1] + window.height / 2 + openingDatumOffset(window, args.nodes), args.unit, args.profile ?? 'document'),
                 operation: windowOperation(window),
             },
         })),
         issues: marks.issues,
     };
 }
-export function buildOpeningMarkAnnotation(opening, wall, levelData, { preferredSide = -1, stroke = '#334155', } = {}) {
+/**
+ * TAG SIZE — sized for the paper, not for the screen.
+ *
+ * These annotations are emitted in WORLD METRES and printed at the sheet's
+ * drawing scale, so a size only means something once you name the scale it is
+ * read at. The reference is a 1/4" = 1'-0" plan (scale 48, i.e. 48 world
+ * inches per paper inch), which is what a residential floor plan is drawn at,
+ * and the targets are the ones a permit sheet uses:
+ *
+ *   tag height   0.28 in of paper  → 0.28 × 48 / 39.3701 = 0.341 m
+ *   tag stroke   0.02 in of paper  → 0.024 m
+ *   mark text    0.11 in of paper  → 0.134 m, bold
+ *
+ * The previous values (0.32 m tall, 0.02 m stroke, 0.15 m text) drew a tag
+ * that was slightly short with a hairline outline — 0.016 in of paper, under
+ * half the intended weight — and text that overflowed it.
+ */
+const TAG_REFERENCE_SCALE = 48;
+const INCHES_PER_METRE = 39.37007874015748;
+/** Paper inches → world metres at the reference scale. */
+const paperInches = (inches) => (inches * TAG_REFERENCE_SCALE) / INCHES_PER_METRE;
+export const OPENING_TAG_HEIGHT = paperInches(0.3);
+export const OPENING_TAG_STROKE_WIDTH = paperInches(0.028);
+export const OPENING_TAG_FONT_SIZE = paperInches(0.125);
+export const OPENING_TAG_LEADER_WIDTH = paperInches(0.012);
+/** Clear distance from the wall face to the near edge of the tag. */
+export const OPENING_TAG_STANDOFF = paperInches(0.16);
+export function buildOpeningMarkAnnotation(opening, wall, levelData, { preferredSide = -1, stroke = '#334155', drafting = false, } = {}) {
     const dx = wall.end[0] - wall.start[0];
     const dz = wall.end[1] - wall.start[1];
     const wallLength = Math.hypot(dx, dz);
@@ -78,57 +116,120 @@ export function buildOpeningMarkAnnotation(opening, wall, levelData, { preferred
     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 explicitMark = opening.mark?.trim();
+    const marks = drafting ? levelData?.draftingMarkById() : levelData?.markById;
+    const mark = marks?.get(opening.id) ?? (explicitMark || fallbackMark(opening));
+    if (!drafting) {
+        const side = interiorSide(wall, preferredSide);
+        // Distance from the reference line to that face: a justified wall's
+        // faces are not symmetric about it.
+        const halfDepth = getWallLocalFaceZ(wall, side > 0 ? 'a' : 'b') * side;
+        const bubbleOffset = halfDepth + 0.5;
+        const bubbleX = openingCenterX + normalX * bubbleOffset * side;
+        const bubbleZ = openingCenterZ + normalZ * bubbleOffset * side;
+        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' });
+    }
+    // A sheet sets the tag just OUTSIDE the wall on the exterior side, the way
+    // a door/window tag is drawn on a construction document. `preferredSide` is
+    // the fallback when neither face is declared exterior.
+    const side = exteriorSide(wall, preferredSide);
+    const halfDepth = getWallLocalFaceZ(wall, side > 0 ? 'a' : 'b') * side;
+    const bubbleHeight = OPENING_TAG_HEIGHT;
+    // Monospace bold sets at roughly 0.62 em; the tag keeps 0.9 of its own
+    // height as end padding so a four-character mark never touches the outline.
+    const bubbleWidth = Math.max(bubbleHeight * 1.25, mark.length * OPENING_TAG_FONT_SIZE * 0.62 + bubbleHeight * 0.9);
+    // The tag sits just OUTSIDE the wall face on the exterior side.
+    const bubbleOffset = halfDepth + OPENING_TAG_STANDOFF + bubbleHeight / 2;
     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' });
+    const children = [];
+    // A leader only where there is actually a gap to bridge; a leader drawn
+    // under a tag that already touches the wall is just a smudge.
+    if (leaderEndOffset - halfDepth > OPENING_TAG_STROKE_WIDTH) {
+        children.push({
+            kind: 'line',
+            x1: openingCenterX + normalX * halfDepth * side,
+            y1: openingCenterZ + normalZ * halfDepth * side,
+            x2: openingCenterX + normalX * leaderEndOffset * side,
+            y2: openingCenterZ + normalZ * leaderEndOffset * side,
+            stroke,
+            strokeWidth: OPENING_TAG_LEADER_WIDTH,
+        });
+    }
+    // Door tag = hexagon, window tag = ellipse (WS3).
+    children.push(opening.type === 'door'
+        ? {
+            kind: 'polygon',
+            points: hexagonPoints(bubbleX, bubbleZ, bubbleWidth, bubbleHeight),
+            fill: '#ffffff',
+            stroke,
+            strokeWidth: OPENING_TAG_STROKE_WIDTH,
+        }
+        : {
+            kind: 'polygon',
+            points: ellipsePoints(bubbleX, bubbleZ, bubbleWidth / 2, bubbleHeight / 2),
+            fill: '#ffffff',
+            stroke,
+            strokeWidth: OPENING_TAG_STROKE_WIDTH,
+        });
+    children.push({
+        kind: 'text',
+        x: bubbleX,
+        y: bubbleZ,
+        text: mark,
+        fontSize: OPENING_TAG_FONT_SIZE,
+        fill: stroke,
+        fontWeight: 700,
+        fontFamily: 'ui-monospace, SFMono-Regular, Menlo, monospace',
+        textAnchor: 'middle',
+        dominantBaseline: 'middle',
+        upright: true,
+    });
+    return withFloorplanGeometryMetadata({ kind: 'group', children }, { annotationRole: 'opening-mark' });
 }
 export function resolveOpeningDimensionDocumentation(opening) {
     const constructionType = opening.constructionType ?? 'framed';
@@ -148,7 +249,43 @@ export function resolveOpeningDimensionDocumentation(opening) {
         verified: requestedReference === 'nominal' || dimensions.width !== null,
     };
 }
-function resolveOpeningMarks(openings, nodes, kind, explicitLevelId) {
+/**
+ * The editor plan numbers doors 101, 102… and windows W01, W02… in sibling
+ * order. A drafted sheet numbers through `resolveMarkDetail` in the editor
+ * package — D101/W101 per level ordinal, clockwise from the NW-most exterior
+ * wall. When no level can be resolved (a detached opening in a preview
+ * context) both fall back to a local sequence so previews still label
+ * something.
+ */
+function resolveOpeningMarks(openings, nodes, kind, explicitLevelId, drafting = false) {
+    const level = resolveLevel(openings[0], nodes, explicitLevelId);
+    const markFor = drafting ? sheetMark : automaticMark;
+    if (drafting && level) {
+        // Callers pass live sibling snapshots that may not be the objects in
+        // `nodes` (mid-drag overrides, un-committed panel edits). Overlay them so
+        // an explicit `mark` on the snapshot is honoured.
+        const overlaid = { ...nodes };
+        for (const opening of openings)
+            overlaid[opening.id] = opening;
+        const resolution = resolveMarkDetail(overlaid, level.id);
+        const markById = new Map();
+        for (const opening of openings) {
+            const mark = resolution.marks.get(opening.id);
+            if (mark)
+                markById.set(opening.id, mark);
+        }
+        const issues = resolution.issues.filter((issue) => issue.startsWith(`Duplicate ${kind} `));
+        // Openings the level walk did not reach (detached / hidden) still need
+        // a mark so the schedule row is not blank.
+        let fallbackSequence = 1;
+        for (const opening of openings) {
+            if (markById.has(opening.id))
+                continue;
+            const explicit = opening.mark?.trim();
+            markById.set(opening.id, explicit || sheetMark(kind, level.level ?? 0, fallbackSequence++));
+        }
+        return { markById, issues };
+    }
     const markById = new Map();
     const explicitMarks = new Map();
     const used = new Set();
@@ -165,15 +302,14 @@ function resolveOpeningMarks(openings, nodes, kind, explicitLevelId) {
         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);
+        let candidate = markFor(kind, level?.level ?? 0, sequence);
         while (used.has(candidate.toLocaleUpperCase())) {
             sequence++;
-            candidate = automaticMark(kind, level?.level ?? 0, sequence);
+            candidate = markFor(kind, level?.level ?? 0, sequence);
         }
         markById.set(opening.id, candidate);
         used.add(candidate.toLocaleUpperCase());
@@ -196,13 +332,17 @@ function resolveLevel(opening, nodes, explicitLevelId) {
         if (current?.type === 'level')
             return current;
     }
-    return undefined;
+    return;
 }
 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 sheetMark(kind, level, sequence) {
+    const base = (Math.max(0, level) + 1) * 100;
+    return `${kind === 'door' ? 'D' : 'W'}${base + sequence}`;
+}
 function fallbackMark(opening) {
     return opening.type === 'door' ? 'D?' : 'W?';
 }
@@ -213,6 +353,46 @@ function interiorSide(wall, fallback) {
         return 1;
     return fallback;
 }
+/** The face that looks outdoors — where the opening tag is drawn. */
+function exteriorSide(wall, fallback) {
+    if (wall.frontSide === 'exterior' && wall.backSide !== 'exterior')
+        return 1;
+    if (wall.backSide === 'exterior' && wall.frontSide !== 'exterior')
+        return -1;
+    return fallback;
+}
+/**
+ * Window tag outline. The geometry union has no `ellipse` primitive
+ * (`packages/core/src/registry/types.ts:364+`), so the ellipse is emitted as
+ * a 24-gon — indistinguishable at tag size in both SVG and the vector PDF,
+ * and it needs no change to the renderers.
+ */
+function ellipsePoints(cx, cy, rx, ry) {
+    const segments = 24;
+    const points = [];
+    for (let index = 0; index < segments; index++) {
+        const angle = (index / segments) * Math.PI * 2;
+        points.push([cx + Math.cos(angle) * rx, cy + Math.sin(angle) * ry]);
+    }
+    return points;
+}
+/**
+ * A flat-top hexagon inscribed in the tag box: the standard door-tag
+ * outline. `width` is the full span, `height` the full depth.
+ */
+function hexagonPoints(cx, cy, width, height) {
+    const halfWidth = width / 2;
+    const halfHeight = height / 2;
+    const inset = Math.min(halfWidth * 0.42, halfHeight);
+    return [
+        [cx - halfWidth, cy],
+        [cx - halfWidth + inset, cy - halfHeight],
+        [cx + halfWidth - inset, cy - halfHeight],
+        [cx + halfWidth, cy],
+        [cx + halfWidth - inset, cy + halfHeight],
+        [cx - halfWidth + inset, cy + halfHeight],
+    ];
+}
 function formatSize(width, height, unit, profile) {
     return `${formatConstructionLength(width, unit, profile)} x ${formatConstructionLength(height, unit, profile)}`;
 }
@@ -298,3 +478,9 @@ function titleCase(value) {
         .map((part) => part.charAt(0).toLocaleUpperCase() + part.slice(1))
         .join(' ');
 }
+function openingDatumOffset(opening, nodes) {
+    const wall = nodes[opening.parentId ?? ''];
+    return wall?.type === 'wall'
+        ? getOpeningFloorDatum(wall, opening, nodes) - wallSupportForNodes(wall, nodes).elevation
+        : 0;
+}

package/dist/shared/opening-grid-follow.d.ts

@@ -0,0 +1,8 @@
+export declare function shouldFollowOpeningGrid(args: {
+    eventTime: number;
+    hasActiveHost: boolean;
+    lastHostEventTime: number;
+    pointerType?: string;
+}): boolean;
+export declare function shouldHandleOpeningHostLeave(nativeEvent: unknown): boolean;
+//# sourceMappingURL=opening-grid-follow.d.ts.map

package/dist/shared/opening-grid-follow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opening-grid-follow.d.ts","sourceRoot":"","sources":["../../src/shared/opening-grid-follow.ts"],"names":[],"mappings":"AAAA,wBAAgB,uBAAuB,CAAC,IAAI,EAAE;IAC5C,SAAS,EAAE,MAAM,CAAA;IACjB,aAAa,EAAE,OAAO,CAAA;IACtB,iBAAiB,EAAE,MAAM,CAAA;IACzB,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,GAAG,OAAO,CAGV;AAED,wBAAgB,4BAA4B,CAAC,WAAW,EAAE,OAAO,GAAG,OAAO,CAS1E"}

package/dist/shared/opening-grid-follow.js

@@ -0,0 +1,12 @@
+export function shouldFollowOpeningGrid(args) {
+    if (args.pointerType === 'xr' && args.hasActiveHost)
+        return false;
+    return args.eventTime !== args.lastHostEventTime;
+}
+export function shouldHandleOpeningHostLeave(nativeEvent) {
+    if (!nativeEvent || typeof nativeEvent !== 'object')
+        return true;
+    const event = nativeEvent;
+    const isSpatialPointer = event.inputSource != null || event.pointerState?.inputSource != null;
+    return !isSpatialPointer || event.openingHoverBridge === true;
+}

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;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"}
+{"version":3,"file":"opening-guides-runtime.d.ts","sourceRoot":"","sources":["../../src/shared/opening-guides-runtime.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,KAAK,OAAO,EAOZ,KAAK,WAAW,EAGhB,KAAK,QAAQ,EAEd,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,CAmBf;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,CAoBhB;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,CAmFP;AAED,wBAAgB,oBAAoB,IAAI,IAAI,CAE3C;AAcD;yEACyE;AACzE,wBAAgB,WAAW,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAKnD;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

@@ -2,7 +2,7 @@
 // editor's 3D guide store, used by the door/window move + placement tools. Lives
 // in `nodes` (not core) because it talks to the editor store; kept thin so each
 // tool's per-tick hook is a single call.
-import { computeOpeningGuides, detectVerticalAlignment, sceneRegistry, spatialGridManager, useScene, } from '@pascal-app/core';
+import { computeOpeningGuides, detectVerticalAlignment, getOpeningFloorDatum, getWallCurveFrameAt, getWallCurveLength, sceneRegistry, useScene, wallSupportForNodes, } from '@pascal-app/core';
 import { useOpeningGuides } from '@pascal-app/editor';
 import { resolveWallOpeningCeiling } from './wall-opening-ceiling';
 // Parity with `snapLocalXToNeighbors`' along-wall threshold.
@@ -24,7 +24,9 @@ export function collectOpeningSiblings(wall, movingId, nodes) {
             id: node.id,
             centerS: node.position[0],
             width: node.width,
-            centerY: node.position[1],
+            centerY: node.position[1] +
+                getOpeningFloorDatum(wall, node, nodes) -
+                wallSupportForNodes(wall, nodes).elevation,
             height: node.height,
         });
     }
@@ -38,19 +40,23 @@ export function collectOpeningSiblings(wall, movingId, nodes) {
  */
 export function resolveSillSnap(args) {
     const siblings = collectOpeningSiblings(args.wall, args.movingId, args.nodes);
+    const datumOffset = getOpeningFloorDatum(args.wall, { position: [args.localX, args.localY, 0], width: args.width, height: args.height }, args.nodes) - wallSupportForNodes(args.wall, args.nodes).elevation;
     const match = detectVerticalAlignment({
         id: args.movingId,
         centerS: args.localX,
         width: args.width,
-        centerY: args.localY,
+        centerY: args.localY + datumOffset,
         height: args.height,
     }, siblings, SILL_SNAP_THRESHOLD_M);
     return match ? args.localY + match.snap : null;
 }
 /** Compute and publish the 3D opening guides for the current drag tick. */
 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 { wall, centerS, width, toWorld } = args;
+    const centerY = args.centerY +
+        getOpeningFloorDatum(wall, { position: [centerS, args.centerY, 0], width, height: args.height }, args.nodes) -
+        wallSupportForNodes(wall, args.nodes).elevation;
+    const wallLength = getWallCurveLength(wall);
     const wallHeight = resolveWallOpeningCeiling(wall, args.nodes);
     const siblings = collectOpeningSiblings(wall, args.movingId, args.nodes);
     const guides = computeOpeningGuides({
@@ -126,21 +132,18 @@ export function clearOpeningGuides3D() {
  *  publisher (which already has them) and the resize publisher (which derives
  *  them from the scene). Same frame as `wallLocalToWorld`. */
 function makeWallToWorld(wall, levelYOffset, slabElevation) {
-    const angle = Math.atan2(wall.end[1] - wall.start[1], wall.end[0] - wall.start[0]);
-    const cos = Math.cos(angle);
-    const sin = Math.sin(angle);
-    return (s, y) => [
-        wall.start[0] + s * cos,
-        slabElevation + y + levelYOffset,
-        wall.start[1] + s * sin,
-    ];
+    const length = getWallCurveLength(wall);
+    return (s, y) => {
+        const { point } = getWallCurveFrameAt(wall, s / length);
+        return [point.x, slabElevation + y + levelYOffset, point.y];
+    };
 }
 /** Like {@link makeWallToWorld} but derives the level Y + slab elevation from the
  *  scene, for callers without a wall event — i.e. the resize handles. */
 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, wall.curveOffset ?? 0, wall.thickness, wall.supportSlabId);
+    const slabElevation = wallSupportForNodes(wall, useScene.getState().nodes).elevation;
     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,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"}
+{"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,EAMpB,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,CA6GrB"}

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

@@ -1,4 +1,4 @@
-import { computeOpeningGuides, isCurvedWall, useScene, } from '@pascal-app/core';
+import { computeOpeningGuides, getWallFaceOffsets, isCurvedWall, useScene, } from '@pascal-app/core';
 import { readFloorplanContext } from '@pascal-app/editor';
 import { formatConstructionLength } from './construction-length';
 import { resolveWallOpeningCeiling } from './wall-opening-ceiling';
@@ -38,8 +38,8 @@ export function buildOpeningPlacementDimensions(opening, ctx) {
     // land on the same face. Walk wall's siblings (the level's other
     // walls) via ctx.resolve to compute the centroid.
     const outwardNormal = computeOutwardNormal(wall, ctx, dirX, dirZ);
-    const wallThickness = wall.thickness ?? 0.1;
-    const halfThickness = wallThickness / 2;
+    const offsets = getWallFaceOffsets(wall);
+    const halfThickness = outwardNormal[0] * -dirZ + outwardNormal[1] * dirX >= 0 ? offsets.a : -offsets.b;
     const FLOORPLAN_WALL_OUTER_MEASUREMENT_OFFSET = 0.32;
     // Outer-face projection for the placement dimensions (so extension lines stay
     // short and the layout matches the legacy treatment); centreline projection

package/dist/shared/opening-plane-offset.d.ts

@@ -0,0 +1,23 @@
+import type { DoorNode, WindowNode } from '@pascal-app/core';
+type PlanarOpening = Pick<DoorNode | WindowNode, 'position' | 'wallId' | 'parentId'>;
+/**
+ * The wall-local plane offset (`position[2]`) a moved door / window keeps on
+ * `targetWallId`. The offset is measured from the centre plane of the wall the
+ * opening stands on (a photo-profiled slider can sit wholly outside one face),
+ * so it survives a slide along that same wall and resets to the centre plane on
+ * any other host, whose faces it says nothing about.
+ */
+export declare function openingPlaneOffsetOnWall(opening: PlanarOpening, targetWallId: string): number;
+/**
+ * Where an opening's plan symbol sits across its wall. A centred opening keeps
+ * the long-standing symbol: centred in the cutout, as deep as the wall. An
+ * opening offset from the centre plane draws its frame at that offset with its
+ * own `frameDepth`, like the 3D renderer; the builder then also draws the
+ * cutout, because the wall is still cut through its whole thickness.
+ */
+export declare function resolveOpeningPlanPlane(opening: Pick<DoorNode | WindowNode, 'position' | 'frameDepth'>, wallThickness: number): {
+    offset: number;
+    depth: number;
+};
+export {};
+//# sourceMappingURL=opening-plane-offset.d.ts.map

package/dist/shared/opening-plane-offset.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opening-plane-offset.d.ts","sourceRoot":"","sources":["../../src/shared/opening-plane-offset.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAE5D,KAAK,aAAa,GAAG,IAAI,CAAC,QAAQ,GAAG,UAAU,EAAE,UAAU,GAAG,QAAQ,GAAG,UAAU,CAAC,CAAA;AAEpF;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAG7F;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,IAAI,CAAC,QAAQ,GAAG,UAAU,EAAE,UAAU,GAAG,YAAY,CAAC,EAC/D,aAAa,EAAE,MAAM,GACpB;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAInC"}

package/dist/shared/opening-plane-offset.js

@@ -0,0 +1,24 @@
+/**
+ * The wall-local plane offset (`position[2]`) a moved door / window keeps on
+ * `targetWallId`. The offset is measured from the centre plane of the wall the
+ * opening stands on (a photo-profiled slider can sit wholly outside one face),
+ * so it survives a slide along that same wall and resets to the centre plane on
+ * any other host, whose faces it says nothing about.
+ */
+export function openingPlaneOffsetOnWall(opening, targetWallId) {
+    const hostWallId = opening.wallId ?? opening.parentId;
+    return hostWallId === targetWallId ? (opening.position[2] ?? 0) : 0;
+}
+/**
+ * Where an opening's plan symbol sits across its wall. A centred opening keeps
+ * the long-standing symbol: centred in the cutout, as deep as the wall. An
+ * opening offset from the centre plane draws its frame at that offset with its
+ * own `frameDepth`, like the 3D renderer; the builder then also draws the
+ * cutout, because the wall is still cut through its whole thickness.
+ */
+export function resolveOpeningPlanPlane(opening, wallThickness) {
+    const offset = opening.position[2] ?? 0;
+    if (offset === 0 || !(opening.frameDepth > 0))
+        return { offset: 0, depth: wallThickness };
+    return { offset, depth: opening.frameDepth };
+}

package/dist/shared/opening-property-preview-host.d.ts

@@ -0,0 +1,3 @@
+import type { OpeningPropertyPreviewDependencies } from './opening-property-preview';
+export declare const openingPropertyPreviewHost: OpeningPropertyPreviewDependencies;
+//# sourceMappingURL=opening-property-preview-host.d.ts.map

package/dist/shared/opening-property-preview-host.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opening-property-preview-host.d.ts","sourceRoot":"","sources":["../../src/shared/opening-property-preview-host.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kCAAkC,EAAE,MAAM,4BAA4B,CAAA;AAEpF,eAAO,MAAM,0BAA0B,EAAE,kCAiBxC,CAAA"}

package/dist/shared/opening-property-preview-host.js

@@ -0,0 +1,21 @@
+import { useLiveNodeOverrides, useScene } from '@pascal-app/core';
+export const openingPropertyPreviewHost = {
+    nodes: () => useScene.getState().nodes,
+    override: (id) => useLiveNodeOverrides.getState().get(id),
+    setOverride: (id, patch) => useLiveNodeOverrides.getState().set(id, patch),
+    clearOverrideFields: (id, fields) => useLiveNodeOverrides.getState().clearFields(id, fields),
+    markDirty: (id) => useScene.getState().markDirty(id),
+    updateNode: (id, patch) => useScene.getState().updateNode(id, patch),
+    scheduleFrame: (callback) => {
+        if (typeof requestAnimationFrame === 'function')
+            return requestAnimationFrame(callback);
+        callback(0);
+        return 0;
+    },
+    cancelFrame: (handle) => {
+        if (typeof cancelAnimationFrame === 'function')
+            cancelAnimationFrame(handle);
+    },
+    scheduleDelay: (callback, delay) => setTimeout(callback, delay),
+    cancelDelay: (handle) => clearTimeout(handle),
+};

package/dist/shared/opening-property-preview.d.ts

@@ -0,0 +1,19 @@
+import type { AnyNode, AnyNodeId, DoorNode, WindowNode } from '@pascal-app/core';
+export type OpeningPropertyPreviewDependencies = {
+    nodes: () => Readonly<Record<AnyNodeId, AnyNode>>;
+    override: (id: AnyNodeId) => Partial<AnyNode> | undefined;
+    setOverride: (id: AnyNodeId, patch: Partial<AnyNode>) => void;
+    clearOverrideFields: (id: AnyNodeId, fields: string[]) => void;
+    markDirty: (id: AnyNodeId) => void;
+    updateNode: (id: AnyNodeId, patch: Partial<AnyNode>) => void;
+    scheduleFrame: (callback: FrameRequestCallback) => number;
+    cancelFrame: (handle: number) => void;
+    scheduleDelay: (callback: () => void, delay: number) => number;
+    cancelDelay: (handle: number) => void;
+};
+export declare function createOpeningPropertyPreview<T extends DoorNode | WindowNode>(id: AnyNodeId, dependencies: OpeningPropertyPreviewDependencies): {
+    preview(patch: Partial<T>): void;
+    commit(patch?: Partial<T>): void;
+    cancel: () => void;
+};
+//# sourceMappingURL=opening-property-preview.d.ts.map

package/dist/shared/opening-property-preview.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opening-property-preview.d.ts","sourceRoot":"","sources":["../../src/shared/opening-property-preview.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAGhF,MAAM,MAAM,kCAAkC,GAAG;IAC/C,KAAK,EAAE,MAAM,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAA;IACjD,QAAQ,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,OAAO,CAAC,OAAO,CAAC,GAAG,SAAS,CAAA;IACzD,WAAW,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,CAAC,OAAO,CAAC,KAAK,IAAI,CAAA;IAC7D,mBAAmB,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,IAAI,CAAA;IAC9D,SAAS,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,CAAA;IAClC,UAAU,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,CAAC,OAAO,CAAC,KAAK,IAAI,CAAA;IAC5D,aAAa,EAAE,CAAC,QAAQ,EAAE,oBAAoB,KAAK,MAAM,CAAA;IACzD,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;IACrC,aAAa,EAAE,CAAC,QAAQ,EAAE,MAAM,IAAI,EAAE,KAAK,EAAE,MAAM,KAAK,MAAM,CAAA;IAC9D,WAAW,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,IAAI,CAAA;CACtC,CAAA;AAID,wBAAgB,4BAA4B,CAAC,CAAC,SAAS,QAAQ,GAAG,UAAU,EAC1E,EAAE,EAAE,SAAS,EACb,YAAY,EAAE,kCAAkC;mBAsD/B,OAAO,CAAC,CAAC,CAAC;mBAcV,OAAO,CAAC,CAAC,CAAC;;EAyB5B"}