@pascal-app/nodes 1.0.6 → 1.0.7

package/dist/shared/node-batch/candidates.js

@@ -30,10 +30,6 @@ export function batchableKinds() {
 export function batchableConfig(node) {
     return node ? batchableKinds().get(node.type) : undefined;
 }
-/** A wall-scoped node (door, window) moves with its host wall. */
-export function isWallHosted(node) {
-    return batchableConfig(node)?.scope === 'wall';
-}
 const rootInverse = new Matrix4();
 /** Source meshes currently draw-hidden per node, so reveal needs no candidate. */
 const hiddenMeshesByNode = new Map();
@@ -43,7 +39,9 @@ const hiddenMeshesByNode = new Map();
  * variant, a cutout group) — and at any HOSTED child node's registered group:
  * an item can host other items (a shelf's books), whose groups mount inside
  * the host's. Packing those would freeze the child at the host's join pose
- * with no release of its own (it is not a store member).
+ * with no release of its own (it is not a store member). A ceiling's cap draws
+ * itself: it shows and hides with a viewer flag that rebuilds nothing, so a
+ * batched copy would stay drawn after it hides.
  */
 function collectMeshes(object, out, hostedRoots) {
     if (object.visible === false || hostedRoots.has(object))
@@ -52,33 +50,80 @@ function collectMeshes(object, out, hostedRoots) {
     if (mesh.isMesh &&
         mesh.name !== 'cutout' &&
         mesh.name !== 'ceiling-grid' &&
+        mesh.name !== 'ceiling-cap' &&
         mesh.layers.isEnabled(SCENE_LAYER)) {
         out.push(mesh);
     }
     for (const child of object.children)
         collectMeshes(child, out, hostedRoots);
 }
+/**
+ * The node's hosts between it and its level, nearest first, or null when the
+ * chain does not reach a level or a host is hidden — a hidden host hides its
+ * children through group visibility, while batch instances hang off the level
+ * root and would keep drawing them — or a host draws itself because it moves
+ * (an animating item, a door mid-swing): what it carries moves with it. A host's edits, gestures and tint release
+ * the nodes it carries ({@link hostsBusy}), so a batched copy never stays
+ * behind when the host moves.
+ */
+export function hostChain(node, nodes) {
+    const hosts = [];
+    for (let id = node.parentId; id;) {
+        const host = nodes[id];
+        if (!host)
+            return null;
+        if (host.type === 'level')
+            return { levelId: host.id, hosts };
+        if (host.visible === false)
+            return null;
+        const batchable = batchableConfig(host);
+        if (batchable?.excluded?.(host))
+            return null;
+        if (batchable?.settled) {
+            const group = sceneRegistry.nodes.get(host.id);
+            if (!group || !batchable.settled(group.userData))
+                return null;
+        }
+        hosts.push(host);
+        id = host.parentId;
+    }
+    return null;
+}
 /**
  * The level this node's batches live under, or null when the node is not in
- * batchable scope. Level-scoped kinds qualify directly under a level; doors
- * and windows through a wall that is itself parented to a level. Other
- * hosting shapes (roof faces, blocks, wall-hosted items) move when their host
- * changes without any signal the batch would see — they draw themselves.
+ * batchable scope. Level-scoped kinds qualify anywhere under a level; doors
+ * and windows through a wall that is itself parented to a level.
  */
 function resolveLevelId(node, batchable, nodes) {
-    const parent = node.parentId ? nodes[node.parentId] : undefined;
-    if (!parent)
+    const chain = hostChain(node, nodes);
+    if (!chain)
         return null;
-    if (batchable.scope === 'level') {
-        return parent.type === 'level' ? parent.id : null;
+    if (batchable.scope === 'level')
+        return chain.levelId;
+    return chain.hosts.length === 1 && chain.hosts[0].type === 'wall' ? chain.levelId : null;
+}
+/** Whether any host of `nodeId` (not the node itself) satisfies `busy`. */
+export function hostsBusy(nodeId, nodes, busy) {
+    for (let id = nodes[nodeId]?.parentId; id; id = nodes[id]?.parentId) {
+        const host = nodes[id];
+        if (!host || host.type === 'level')
+            return false;
+        if (busy(id))
+            return true;
+    }
+    return false;
+}
+/** Adds every batchable node carried by `nodeId` (its descendants, at any depth) to `out`. */
+export function addBatchableDescendants(nodeId, nodes, out) {
+    const children = nodes[nodeId]?.children;
+    if (!Array.isArray(children))
+        return;
+    for (const childId of children) {
+        const id = String(childId);
+        if (batchableConfig(nodes[id]))
+            out.add(id);
+        addBatchableDescendants(id, nodes, out);
     }
-    // Wall-hosted: host wall → its level. A hidden wall hides its openings
-    // through group visibility — batch instances hang off the level root and
-    // would keep drawing them.
-    if (parent.type !== 'wall' || parent.visible === false)
-        return null;
-    const level = parent.parentId ? nodes[parent.parentId] : undefined;
-    return level?.type === 'level' ? level.id : null;
 }
 export function collectBatchCandidate(nodeId) {
     const nodes = useScene.getState().nodes;
@@ -102,7 +147,9 @@ export function collectBatchCandidate(nodeId) {
     const overrides = useLiveNodeOverrides.getState();
     if (overrides.get(nodeId) || useLiveTransforms.getState().get(nodeId))
         return null;
-    if (batchable.scope === 'wall' && node.parentId && overrides.get(node.parentId)) {
+    const liveTransforms = useLiveTransforms.getState();
+    if (hostsBusy(nodeId, nodes, (hostId) => overrides.get(hostId) !== undefined ||
+        liveTransforms.get(hostId) !== undefined)) {
         return null;
     }
     const levelRoot = sceneRegistry.nodes.get(levelId);
@@ -188,46 +235,34 @@ export function revealBatchedNode(nodeId) {
     hiddenMeshesByNode.delete(nodeId);
 }
 /**
- * Nodes the viewer is lighting up — plus hosted openings whose host wall is
- * lit or mid-gesture: a dragged wall carries its doors with it through live
- * overrides, and a batched copy would stay behind until commit.
+ * Nodes the viewer is lighting up — plus nodes whose host is lit or
+ * mid-gesture: a dragged wall carries its doors, a moved cabinet run its
+ * modules, through live overrides and transforms, and a batched copy would
+ * stay behind until commit.
  */
 export function collectTintedNodes(nodeIds) {
     const viewer = useViewer.getState();
-    const tinted = new Set();
+    const lit = new Set();
     for (const id of viewer.selection.selectedIds)
-        if (nodeIds.has(id))
-            tinted.add(id);
+        lit.add(id);
     for (const id of viewer.previewSelectedIds)
-        if (nodeIds.has(id))
-            tinted.add(id);
+        lit.add(id);
     for (const id of viewer.externalSelectedIds)
+        lit.add(id);
+    if (viewer.hoveredId)
+        lit.add(viewer.hoveredId);
+    const tinted = new Set();
+    for (const id of lit)
         if (nodeIds.has(id))
             tinted.add(id);
-    const hovered = viewer.hoveredId;
-    if (hovered && nodeIds.has(hovered))
-        tinted.add(hovered);
     const nodes = useScene.getState().nodes;
     const overrides = useLiveNodeOverrides.getState();
-    const wallLit = new Set();
-    for (const id of viewer.selection.selectedIds)
-        wallLit.add(id);
-    for (const id of viewer.previewSelectedIds)
-        wallLit.add(id);
-    for (const id of viewer.externalSelectedIds)
-        wallLit.add(id);
-    if (hovered)
-        wallLit.add(hovered);
+    const liveTransforms = useLiveTransforms.getState();
+    const busy = (hostId) => lit.has(hostId) ||
+        overrides.get(hostId) !== undefined ||
+        liveTransforms.get(hostId) !== undefined;
     for (const id of nodeIds) {
-        if (tinted.has(id))
-            continue;
-        const node = nodes[id];
-        if (!node || !isWallHosted(node))
-            continue;
-        const wallId = node.parentId;
-        if (!wallId)
-            continue;
-        if (wallLit.has(wallId) || overrides.get(wallId))
+        if (!tinted.has(id) && hostsBusy(id, nodes, busy))
             tinted.add(id);
     }
     return tinted;

package/dist/shared/node-batch/system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../../src/shared/node-batch/system.tsx"],"names":[],"mappings":"AA6HA,wBAAgB,mBAAmB,SAmBlC;AAkCD,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CA4B7E;AAED,wBAAgB,mBAAmB,SAgBlC;AAED,wBAAgB,aAAa,CAC3B,UAAU,EAAE,MAAM,IAAI,EACtB,OAAO,EAAE;IAAE,OAAO,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,IAAI,CAAA;CAAE,QAmB3D;AAkQD,eAAO,MAAM,eAAe,0CAG3B,CAAA"}
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../../src/shared/node-batch/system.tsx"],"names":[],"mappings":"AAgIA,wBAAgB,mBAAmB,SAmBlC;AAkCD,wBAAgB,0BAA0B,CAAC,UAAU,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAmC7E;AAED,wBAAgB,mBAAmB,SAalC;AAED,wBAAgB,aAAa,CAC3B,UAAU,EAAE,MAAM,IAAI,EACtB,OAAO,EAAE;IAAE,OAAO,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,IAAI,CAAA;CAAE,QAmB3D;AAwQD,eAAO,MAAM,eAAe,0CAG3B,CAAA"}

package/dist/shared/node-batch/system.js

@@ -5,7 +5,7 @@ import { getPendingWallRebuildCount, isIsolationActive, isNodeRevealing, publish
 import { useFrame, useThree } from '@react-three/fiber';
 import { useEffect, useRef } from 'react';
 import { isSlotPaintPreviewActive, subscribeSlotPaintPreviews } from '../slot-paint.js';
-import { batchableConfig, collectBatchCandidate, collectTintedNodes, getBatchableNodeIds, hideBatchedNode, isWallHosted, revealAllBatchedHolds, revealBatchedNode, } from './candidates.js';
+import { addBatchableDescendants, batchableConfig, collectBatchCandidate, collectTintedNodes, getBatchableNodeIds, hideBatchedNode, hostsBusy, revealAllBatchedHolds, revealBatchedNode, } from './candidates.js';
 import { subscribeBatchReleases } from './release.js';
 import { NodeBatchStore } from './store.js';
 import { MIN_BATCH_ENTRIES, NODE_BATCH_SETTLE_MS } from './types.js';
@@ -21,11 +21,13 @@ const store = new NodeBatchStore((levelId) => sceneRegistry.nodes.get(levelId));
 /**
  * Marks captured before the consuming systems (priority 2+) clear them — the
  * walls' `drainRebuiltWalls` ledger, done from the outside: a priority-1 pass
- * snapshots which nodes this frame touched. A dirty WALL cascades to its
- * hosted doors/windows: the wall edit moves them in level space without
- * marking them.
+ * snapshots which nodes this frame touched. A dirty host cascades to the
+ * batchable nodes it carries: a wall edit moves its doors and windows, a
+ * cabinet run edit its modules, in level space without marking them.
  */
 const changedNodes = new Set();
+/** Scene containers: their children are organised under them, not carried by them. */
+const CONTAINER_TYPES = new Set(['level', 'building', 'site']);
 const surfaceLevelReadyAt = new Map();
 const staleNodes = new Set();
 /**
@@ -131,11 +133,19 @@ function releaseAll() {
     revealAllBatchedHolds();
 }
 export function subscribeBatchInteractions(invalidate) {
+    // A gesture or release on a host moves what it carries too.
     const changed = (nodeId) => {
-        if (!batchableConfig(useScene.getState().nodes[nodeId]))
+        const nodes = useScene.getState().nodes;
+        const ids = new Set();
+        if (batchableConfig(nodes[nodeId]))
+            ids.add(nodeId);
+        addBatchableDescendants(nodeId, nodes, ids);
+        if (ids.size === 0)
             return;
-        releaseNode(nodeId);
-        changedNodes.add(nodeId);
+        for (const id of ids) {
+            releaseNode(id);
+            changedNodes.add(id);
+        }
         invalidate();
     };
     const unsubscribeTransforms = useLiveTransforms.subscribe((state, previous) => {
@@ -174,14 +184,11 @@ export function captureChangedNodes() {
             continue;
         if (batchableConfig(node))
             changedNodes.add(id);
-        else if (node.type === 'wall' && Array.isArray(node.children)) {
-            // The wall edit moved its openings in level space; their own marks may
-            // never come.
-            for (const childId of node.children) {
-                if (isWallHosted(nodes[childId]))
-                    changedNodes.add(childId);
-            }
-        }
+        // The host edit moved what it carries in level space; their own marks may never come. A
+        // level, building or site carries nothing that way: its child list is bookkeeping (it changes
+        // whenever furniture is re-parented), and cascading from it released the whole floor.
+        if (!CONTAINER_TYPES.has(node.type))
+            addBatchableDescendants(id, nodes, changedNodes);
     }
 }
 export function runBatchFrame(invalidate, wakeRef) {
@@ -393,6 +400,8 @@ function processBatchFrame(invalidate, wakeRef) {
             dirty.has(nodeId) ||
             // Still growing in from a construction reveal: its transform moves every frame.
             isNodeRevealing(nodeId) ||
+            // A host still being rebuilt or revealed moves this node with it.
+            hostsBusy(nodeId, sceneNodes, (hostId) => dirty.has(hostId) || isNodeRevealing(hostId)) ||
             overrides.get(nodeId) !== undefined ||
             useLiveTransforms.getState().get(nodeId) !== undefined ||
             isSlotPaintPreviewActive(nodeId)) {

package/dist/shared/opening-casing-move.d.ts

@@ -0,0 +1,16 @@
+import { type AnyNode, type DoorNode, type WindowNode } from '@pascal-app/core';
+type MovedOpening = Pick<DoorNode | WindowNode, 'parentId' | 'roofSegmentId' | 'rotation' | 'casingFaceA' | 'casingFaceB'>;
+type CasingFaces = Pick<DoorNode | WindowNode, 'casingFaceA' | 'casingFaceB'>;
+/**
+ * The casing faces a door or window keeps when a move takes it from its host to `hostId`, the
+ * wall or roof face it lands on turned to `rotation`. Casing is kept per host face, and two hosts
+ * need not name their faces alike: a wall drawn the other way round has its `a` where the first
+ * has its `b`. So each face's casing goes to the matching face of the new host: outside to
+ * outside where both hosts know their outside (an outside wall, as its rooms give it, or a roof
+ * face), else the face the unit's front looks at to the face it looks at there. A slide along its
+ * own host, or a host with no cased faces on either end (a dormer, open floor), keeps them as they
+ * are.
+ */
+export declare function movedOpeningCasingFaces(opening: MovedOpening, hostId: string, rotation: DoorNode['rotation'], nodes: Readonly<Record<string, AnyNode>>): CasingFaces;
+export {};
+//# sourceMappingURL=opening-casing-move.d.ts.map

package/dist/shared/opening-casing-move.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opening-casing-move.d.ts","sourceRoot":"","sources":["../../src/shared/opening-casing-move.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,QAAQ,EAGb,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAEzB,KAAK,YAAY,GAAG,IAAI,CACtB,QAAQ,GAAG,UAAU,EACrB,UAAU,GAAG,eAAe,GAAG,UAAU,GAAG,aAAa,GAAG,aAAa,CAC1E,CAAA;AACD,KAAK,WAAW,GAAG,IAAI,CAAC,QAAQ,GAAG,UAAU,EAAE,aAAa,GAAG,aAAa,CAAC,CAAA;AAS7E;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,YAAY,EACrB,MAAM,EAAE,MAAM,EACd,QAAQ,EAAE,QAAQ,CAAC,UAAU,CAAC,EAC9B,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,WAAW,CAab"}

package/dist/shared/opening-casing-move.js

@@ -0,0 +1,33 @@
+import { openingHostFacing, resolveWallExteriorSide, } from '@pascal-app/core';
+/** The face of a host that looks outdoors: +1 for `a`, -1 for `b`, null when it cannot tell. */
+function hostOutside(host) {
+    if (host.type === 'wall')
+        return resolveWallExteriorSide(host);
+    // A roof face's `a` is its outside, as its casing has it.
+    return host.type === 'roof-segment' ? 1 : null;
+}
+/**
+ * The casing faces a door or window keeps when a move takes it from its host to `hostId`, the
+ * wall or roof face it lands on turned to `rotation`. Casing is kept per host face, and two hosts
+ * need not name their faces alike: a wall drawn the other way round has its `a` where the first
+ * has its `b`. So each face's casing goes to the matching face of the new host: outside to
+ * outside where both hosts know their outside (an outside wall, as its rooms give it, or a roof
+ * face), else the face the unit's front looks at to the face it looks at there. A slide along its
+ * own host, or a host with no cased faces on either end (a dormer, open floor), keeps them as they
+ * are.
+ */
+export function movedOpeningCasingFaces(opening, hostId, rotation, nodes) {
+    const kept = { casingFaceA: opening.casingFaceA, casingFaceB: opening.casingFaceB };
+    const fromId = opening.roofSegmentId ?? opening.parentId;
+    const [from, to] = [nodes[fromId ?? ''], nodes[hostId]];
+    if (fromId === hostId || !from || !to)
+        return kept;
+    const cased = (host) => host.type === 'wall' || host.type === 'roof-segment';
+    if (!(cased(from) && cased(to)))
+        return kept;
+    const [fromOutside, toOutside] = [hostOutside(from), hostOutside(to)];
+    const swapped = fromOutside !== null && toOutside !== null
+        ? fromOutside !== toOutside
+        : openingHostFacing(opening) !== openingHostFacing({ rotation });
+    return swapped ? { casingFaceA: kept.casingFaceB, casingFaceB: kept.casingFaceA } : kept;
+}

package/dist/shared/opening-casing-section.d.ts

@@ -0,0 +1,15 @@
+import { type DoorNode, type WindowNode } from '@pascal-app/core';
+type CasingPatch = Partial<Pick<DoorNode, 'casingFaceA' | 'casingFaceB' | 'casingWidth'>>;
+/**
+ * The door and window panels' Casing section: casing on or off for each face
+ * of the host wall (Exterior and Interior on an outside wall), and the boards'
+ * face width, in inches on an imperial plan (feet would show 2 in as 0.17).
+ * Nothing where the opening takes no casing (a curtain wall, a dormer face, a
+ * unit built from a script).
+ */
+export declare function OpeningCasingSection({ node, onUpdate, }: {
+    node: DoorNode | WindowNode;
+    onUpdate: (patch: CasingPatch) => void;
+}): import("react").JSX.Element | null;
+export {};
+//# sourceMappingURL=opening-casing-section.d.ts.map

package/dist/shared/opening-casing-section.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opening-casing-section.d.ts","sourceRoot":"","sources":["../../src/shared/opening-casing-section.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,QAAQ,EAKb,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAUzB,KAAK,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,QAAQ,EAAE,aAAa,GAAG,aAAa,GAAG,aAAa,CAAC,CAAC,CAAA;AAEzF;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,EACnC,IAAI,EACJ,QAAQ,GACT,EAAE;IACD,IAAI,EAAE,QAAQ,GAAG,UAAU,CAAA;IAC3B,QAAQ,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,CAAA;CACvC,sCAkDA"}

package/dist/shared/opening-casing-section.js

@@ -0,0 +1,38 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { openingCasingWidth, resolveOpeningCasingHost, usePascalI18n, useScene, } from '@pascal-app/core';
+import { PanelSection, SliderControl, ToggleControl } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useMemo } from 'react';
+import { openingCasingFaceLabels } from './opening-casing.js';
+const INCH = 0.0254;
+const MIN_CASING_WIDTH = 0.5 * INCH;
+const MAX_CASING_WIDTH = 8 * INCH;
+/**
+ * The door and window panels' Casing section: casing on or off for each face
+ * of the host wall (Exterior and Interior on an outside wall), and the boards'
+ * face width, in inches on an imperial plan (feet would show 2 in as 0.17).
+ * Nothing where the opening takes no casing (a curtain wall, a dormer face, a
+ * unit built from a script).
+ */
+export function OpeningCasingSection({ node, onUpdate, }) {
+    const i18n = usePascalI18n();
+    // Its own component, so the whole scene it reads for the face names
+    // re-renders this section alone, not the panel around it.
+    const nodes = useScene((state) => state.nodes);
+    const cased = useMemo(() => resolveOpeningCasingHost(node, nodes) !== null, [node, nodes]);
+    const { parentId, roofSegmentId } = node;
+    const labels = useMemo(() => openingCasingFaceLabels(nodes, { parentId, roofSegmentId }), [nodes, parentId, roofSegmentId]);
+    const imperial = useViewer((state) => state.unit) === 'imperial';
+    if (!cased)
+        return null;
+    const faceA = node.casingFaceA === true;
+    const faceB = node.casingFaceB === true;
+    const toShown = (meters) => (imperial ? meters / INCH : meters);
+    return (_jsxs(PanelSection, { title: i18n._({ id: 'node.shared.openingCasingSection.casing', message: 'Casing' }), children: [_jsx(ToggleControl, { checked: faceA, label: labels.a, onChange: (checked) => onUpdate({ casingFaceA: checked }) }), _jsx(ToggleControl, { checked: faceB, label: labels.b, onChange: (checked) => onUpdate({ casingFaceB: checked }) }), (faceA || faceB) && (_jsx(SliderControl, { label: i18n._({ id: 'node.shared.openingCasingSection.width', message: 'Width' }), max: toShown(MAX_CASING_WIDTH), min: toShown(MIN_CASING_WIDTH), onChange: (value) => {
+                    const meters = imperial ? value * INCH : value;
+                    onUpdate({
+                        casingWidth: Math.min(Math.max(meters, MIN_CASING_WIDTH), MAX_CASING_WIDTH),
+                    });
+                }, precision: imperial ? 2 : 3, step: imperial ? 0.25 : 0.005, unit: imperial ? 'in' : 'm', value: toShown(openingCasingWidth(node)) }))] }));
+}

package/dist/shared/opening-casing.d.ts

@@ -0,0 +1,26 @@
+import { type AnyNode, type DoorNode, type FloorplanGeometry, type OpeningCasingHost, type WallFace, type WallNode, type WindowNode } from '@pascal-app/core';
+type CasingPlanStyle = {
+    fill: string;
+    stroke: string;
+    strokeWidth: number;
+    /** Screen-pixel strokes in the editor; plan-metre ink on a drafted sheet. */
+    vectorEffect?: 'non-scaling-stroke';
+};
+/**
+ * The casing a door's or window's plan shows: the legs beside the cutout on
+ * each face of the wall it is cased on, each a short rectangle standing proud
+ * of the finished face, as plans draw trim. Null when there is none to draw (a
+ * curtain wall, a railing, a script-built unit, both faces turned off).
+ * `cornerEnd` is the wall end a corner window runs to, where it has no leg.
+ */
+export declare function buildOpeningCasingPlan(opening: DoorNode | WindowNode, wall: WallNode, style: CasingPlanStyle, cornerEnd?: OpeningCasingHost['cornerEnd']): FloorplanGeometry | null;
+/**
+ * What the door and window panels call the faces an opening can be cased on. A
+ * wall with rooms on one side only (an outside wall, as the wall panel's paint
+ * regions tell it) names them Exterior and Interior, as does a roof face, whose
+ * `a` is its outside; any other wall keeps the wall panel's Side A and Side B.
+ */
+export declare function openingCasingFaceLabels(nodes: Readonly<Record<string, AnyNode>>, opening: Pick<DoorNode | WindowNode, 'parentId' | 'roofSegmentId'>): Record<WallFace, string>;
+export declare function openingCasingPaintLabel(role: string): string | null;
+export {};
+//# sourceMappingURL=opening-casing.d.ts.map

package/dist/shared/opening-casing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opening-casing.d.ts","sourceRoot":"","sources":["../../src/shared/opening-casing.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,QAAQ,EAEb,KAAK,iBAAiB,EAGtB,KAAK,iBAAiB,EAGtB,KAAK,QAAQ,EACb,KAAK,QAAQ,EACb,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAEzB,KAAK,eAAe,GAAG;IACrB,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;IACd,WAAW,EAAE,MAAM,CAAA;IACnB,6EAA6E;IAC7E,YAAY,CAAC,EAAE,oBAAoB,CAAA;CACpC,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,QAAQ,GAAG,UAAU,EAC9B,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,eAAe,EACtB,SAAS,CAAC,EAAE,iBAAiB,CAAC,WAAW,CAAC,GACzC,iBAAiB,GAAG,IAAI,CAuC1B;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,IAAI,CAAC,QAAQ,GAAG,UAAU,EAAE,UAAU,GAAG,eAAe,CAAC,GACjE,MAAM,CAAC,QAAQ,EAAE,MAAM,CAAC,CAiB1B;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAMnE"}

package/dist/shared/opening-casing.js

@@ -0,0 +1,80 @@
+import { defaultI18n, getWallBodyCenterOffset, openingCasingBoards, roomSideFaces, } from '@pascal-app/core';
+/**
+ * The casing a door's or window's plan shows: the legs beside the cutout on
+ * each face of the wall it is cased on, each a short rectangle standing proud
+ * of the finished face, as plans draw trim. Null when there is none to draw (a
+ * curtain wall, a railing, a script-built unit, both faces turned off).
+ * `cornerEnd` is the wall end a corner window runs to, where it has no leg.
+ */
+export function buildOpeningCasingPlan(opening, wall, style, cornerEnd) {
+    if (opening.source || wall.wallType === 'curtain' || wall.wallType === 'railing')
+        return null;
+    const [x1, z1] = wall.start;
+    const dx = wall.end[0] - x1;
+    const dz = wall.end[1] - z1;
+    const length = Math.hypot(dx, dz);
+    if (length < 1e-9)
+        return null;
+    const dir = [dx / length, dz / length];
+    const perp = [-dir[1], dir[0]];
+    const plan = (along, across) => [
+        x1 + dir[0] * along + perp[0] * across,
+        z1 + dir[1] * along + perp[1] * across,
+    ];
+    // Boards are measured from the opening's centre plane, which a justified wall
+    // sets off its reference line and a plane offset sets off the wall's body.
+    const centreAcross = getWallBodyCenterOffset(wall) + (opening.position[2] ?? 0);
+    const host = {
+        thickness: wall.thickness ?? 0.1,
+        ...(cornerEnd ? { cornerEnd } : {}),
+    };
+    const children = openingCasingBoards(opening, host)
+        .filter((board) => board.part === 'leg')
+        .map(({ center, size }) => {
+        const along = opening.position[0] + center[0];
+        const across = centreAcross + center[2];
+        const [halfAlong, halfAcross] = [size[0] / 2, size[2] / 2];
+        return {
+            kind: 'polygon',
+            points: [
+                plan(along - halfAlong, across + halfAcross),
+                plan(along + halfAlong, across + halfAcross),
+                plan(along + halfAlong, across - halfAcross),
+                plan(along - halfAlong, across - halfAcross),
+            ],
+            ...style,
+            strokeLinejoin: 'miter',
+        };
+    });
+    return children.length ? { kind: 'group', children } : null;
+}
+/**
+ * What the door and window panels call the faces an opening can be cased on. A
+ * wall with rooms on one side only (an outside wall, as the wall panel's paint
+ * regions tell it) names them Exterior and Interior, as does a roof face, whose
+ * `a` is its outside; any other wall keeps the wall panel's Side A and Side B.
+ */
+export function openingCasingFaceLabels(nodes, opening) {
+    if (opening.roofSegmentId)
+        return { a: 'Exterior', b: 'Interior' };
+    const wallId = opening.parentId;
+    if (wallId && nodes[wallId]?.type === 'wall') {
+        try {
+            const { inside, outside } = roomSideFaces(nodes, wallId);
+            if (inside && outside) {
+                return { [outside]: 'Exterior', [inside]: 'Interior' };
+            }
+        }
+        catch {
+            // Not a wall (any more): fall through to the neutral labels.
+        }
+    }
+    return { a: 'Side A', b: 'Side B' };
+}
+export function openingCasingPaintLabel(role) {
+    if (role === 'casing-a')
+        return defaultI18n._({ id: 'node.shared.openingCasing.faceA', message: 'Casing A' });
+    if (role === 'casing-b')
+        return defaultI18n._({ id: 'node.shared.openingCasing.faceB', message: 'Casing B' });
+    return null;
+}

package/dist/shared/opening-depth-position.d.ts

@@ -0,0 +1,13 @@
+import { type DoorNode, type WindowNode } from '@pascal-app/core';
+/**
+ * The Frame section's Depth position: where the frame stands across its wall,
+ * the opening's `position[2]` (0 = the wall's centre plane), within half the
+ * wall's thickness either way. In inches on an imperial plan, like the casing
+ * width (feet would show 2 in as 0.17). Nothing where the opening stands in no
+ * wall: a roof face, a curtain wall or railing, a unit built from a script.
+ */
+export declare function OpeningDepthPositionControl({ node, onUpdate, }: {
+    node: DoorNode | WindowNode;
+    onUpdate: (patch: Pick<DoorNode, 'position'>) => void;
+}): import("react").JSX.Element | null;
+//# sourceMappingURL=opening-depth-position.d.ts.map

package/dist/shared/opening-depth-position.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opening-depth-position.d.ts","sourceRoot":"","sources":["../../src/shared/opening-depth-position.tsx"],"names":[],"mappings":"AAEA,OAAO,EACL,KAAK,QAAQ,EAIb,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAMzB;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CAAC,EAC1C,IAAI,EACJ,QAAQ,GACT,EAAE;IACD,IAAI,EAAE,QAAQ,GAAG,UAAU,CAAA;IAC3B,QAAQ,EAAE,CAAC,KAAK,EAAE,IAAI,CAAC,QAAQ,EAAE,UAAU,CAAC,KAAK,IAAI,CAAA;CACtD,sCAkCA"}

package/dist/shared/opening-depth-position.js

@@ -0,0 +1,34 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { resolveOpeningCasingHost, usePascalI18n, useScene, } from '@pascal-app/core';
+import { SliderControl } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+const INCH = 0.0254;
+/**
+ * The Frame section's Depth position: where the frame stands across its wall,
+ * the opening's `position[2]` (0 = the wall's centre plane), within half the
+ * wall's thickness either way. In inches on an imperial plan, like the casing
+ * width (feet would show 2 in as 0.17). Nothing where the opening stands in no
+ * wall: a roof face, a curtain wall or railing, a unit built from a script.
+ */
+export function OpeningDepthPositionControl({ node, onUpdate, }) {
+    const i18n = usePascalI18n();
+    // A number, so only a change to the host wall's thickness re-renders the panel.
+    const thickness = useScene((state) => node.roofSegmentId ? null : (resolveOpeningCasingHost(node, state.nodes)?.thickness ?? null));
+    const imperial = useViewer((state) => state.unit) === 'imperial';
+    if (thickness === null)
+        return null;
+    const offset = node.position[2] ?? 0;
+    // An opening already set further out (a photo-profiled slider) keeps its value in range.
+    const half = Math.max(thickness / 2, Math.abs(offset));
+    const toShown = (meters) => (imperial ? meters / INCH : meters);
+    return (_jsx(SliderControl, { label: i18n._({
+            id: 'node.shared.openingDepthPosition.depthPosition',
+            message: 'Depth position',
+        }), max: toShown(half), min: toShown(-half), onChange: (value) => {
+            const meters = imperial ? value * INCH : value;
+            onUpdate({
+                position: [node.position[0], node.position[1], Math.min(Math.max(meters, -half), half)],
+            });
+        }, precision: imperial ? 2 : 3, step: imperial ? 0.25 : 0.005, unit: imperial ? 'in' : 'm', value: toShown(offset) }));
+}

package/dist/shared/opening-documentation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"opening-documentation.d.ts","sourceRoot":"","sources":["../../src/shared/opening-documentation.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"opening-documentation.d.ts","sourceRoot":"","sources":["../../src/shared/opening-documentation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,QAAQ,EACR,iBAAiB,EAEjB,QAAQ,EACR,UAAU,EACX,MAAM,kBAAkB,CAAA;AASzB,OAAO,EACL,KAAK,iBAAiB,EAGvB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EACL,KAAK,yBAAyB,EAC9B,KAAK,sBAAsB,EAE5B,MAAM,uBAAuB,CAAA;AAE9B,KAAK,WAAW,GAAG,QAAQ,GAAG,UAAU,CAAA;AAGxC,MAAM,MAAM,uBAAuB,GAAG,QAAQ,GAAG,SAAS,CAAA;AAC1D,MAAM,MAAM,yBAAyB,GACjC,SAAS,GACT,eAAe,GACf,iBAAiB,GACjB,gBAAgB,CAAA;AAEpB,MAAM,MAAM,6BAA6B,GAAG;IAC1C,gBAAgB,EAAE,uBAAuB,CAAA;IACzC,SAAS,EAAE,yBAAyB,CAAA;IACpC,cAAc,EAAE,YAAY,GAAG,cAAc,CAAA;IAC7C,KAAK,EAAE,MAAM,GAAG,IAAI,CAAA;IACpB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;IACrB,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,OAAO,CAAA;CAClB,CAAA;AAED,MAAM,MAAM,yBAAyB,GAAG;IACtC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACrC,+FAA+F;IAC/F,gBAAgB,EAAE,MAAM,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CACpD,CAAA;AAsBD,wBAAgB,6BAA6B,CAAC,IAAI,EAAE;IAClD,QAAQ,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAA;IACjC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B,GAAG,yBAAyB,CAE5B;AAED,wBAAgB,+BAA+B,CAAC,IAAI,EAAE;IACpD,QAAQ,EAAE,aAAa,CAAC,UAAU,CAAC,CAAA;IACnC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B,GAAG,yBAAyB,CAE5B;AAED,wBAAgB,0BAA0B,CAAC,IAAI,EAAE;IAC/C,QAAQ,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAA;IACjC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IACxC,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,sBAAsB,CAAA;IAC5B,OAAO,CAAC,EAAE,yBAAyB,CAAA;IACnC,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,GAAG,iBAAiB,GAAG,IAAI,CAwC3B;AAED,wBAAgB,4BAA4B,CAAC,IAAI,EAAE;IACjD,QAAQ,EAAE,aAAa,CAAC,UAAU,CAAC,CAAA;IACnC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IACxC,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,sBAAsB,CAAA;IAC5B,OAAO,CAAC,EAAE,yBAAyB,CAAA;IACnC,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,GAAG,iBAAiB,GAAG,IAAI,CA8C3B;AAwBD,eAAO,MAAM,kBAAkB,QAAmB,CAAA;AAClD,eAAO,MAAM,wBAAwB,QAAqB,CAAA;AAC1D,eAAO,MAAM,qBAAqB,QAAqB,CAAA;AACvD,eAAO,MAAM,wBAAwB,QAAqB,CAAA;AAC1D,qEAAqE;AACrE,eAAO,MAAM,oBAAoB,QAAoB,CAAA;AAErD,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,WAAW,EACpB,IAAI,EAAE,QAAQ,EACd,SAAS,EAAE,yBAAyB,GAAG,SAAS,EAChD,EACE,aAAkB,EAClB,MAAkB,EAClB,QAAgB,GACjB,GAAE;IACD,aAAa,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAA;IACtB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,iGAAiG;IACjG,QAAQ,CAAC,EAAE,OAAO,CAAA;CACd,GACL,iBAAiB,GAAG,IAAI,CA2I1B;AAED,wBAAgB,oCAAoC,CAClD,OAAO,EAAE,WAAW,GACnB,6BAA6B,CAoB/B"}

package/dist/shared/opening-documentation.js

@@ -1,4 +1,4 @@
-import { getOpeningFloorDatum, getWallLocalFaceZ, wallSupportForNodes } from '@pascal-app/core';
+import { doorHandleStyle, getDoorOpeningSize, getOpeningFloorDatum, getWallLocalFaceZ, resolveHostedOpeningFrameDepth, wallSupportForNodes, } from '@pascal-app/core';
 import { resolveMarkDetail, withFloorplanGeometryMetadata, } from '@pascal-app/editor';
 import { formatConstructionLength, } from './construction-length.js';
 function openingLevelData(openings, nodes, kind) {
@@ -38,10 +38,10 @@ export function buildDoorFloorplanSchedule(args) {
             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'),
+                size: formatSize(getDoorOpeningSize(door).width, getDoorOpeningSize(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')}`,
+                frame: `${formatConstructionLength(door.frameThickness, args.unit, args.profile ?? 'document')} / ${formatConstructionLength(resolveHostedOpeningFrameDepth(door, args.nodes), args.unit, args.profile ?? 'document')}`,
                 hardware: doorHardware(door),
             },
         })),
@@ -405,7 +405,7 @@ function formatRoughOpening(opening, unit, profile) {
 function openingDocumentationDimensions(opening, reference) {
     switch (reference) {
         case 'nominal':
-            return { width: opening.width, height: opening.height };
+            return getDoorOpeningSize(opening);
         case 'rough-opening':
             return {
                 width: opening.roughOpeningWidth ?? null,
@@ -449,12 +449,21 @@ function doorHardware(door) {
     if (door.openingKind === 'opening')
         return 'None';
     const hardware = [];
+    if (door.handle) {
+        const swing = ['hinged', 'double', 'french'].includes(door.doorType);
+        const labels = {
+            lever: 'Lever',
+            'lever-curved': 'Curved lever',
+            knob: 'Knob',
+            bar: 'Bar pull',
+            plate: 'Plate lever',
+        };
+        hardware.push(swing ? labels[doorHandleStyle(door)] : 'Pull');
+    }
     if (door.doorCloser)
-        hardware.push('Closer');
+        hardware.push(hardware.length ? 'closer' : 'Closer');
     if (door.panicBar)
-        hardware.push('Panic bar');
-    if (door.threshold)
-        hardware.push('Threshold');
+        hardware.push(hardware.length ? 'panic bar' : 'Panic bar');
     return hardware.length > 0 ? hardware.join(', ') : 'Standard';
 }
 function windowOperation(window) {

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

@@ -1,3 +1,4 @@
+import { type DoorNode } from '@pascal-app/core';
 import { type AnyNode, type OpeningSpan, type WallNode } from '@pascal-app/core';
 /** Maps a wall-local point (s along the wall, y above the wall base) to the move
  *  tool's render frame — the caller passes its own `wallLocalToWorld` closure so
@@ -65,6 +66,6 @@ export declare function publishOpeningResizeGuides(node: {
     position: readonly [number, number, number];
     width: number;
     height: number;
-}, includeVertical: boolean): void;
+} & Partial<Pick<DoorNode, 'rotation' | 'doorType' | 'sidelightLeft' | 'sidelightRight' | 'transomHeight'>>, includeVertical: boolean): void;
 export {};
 //# sourceMappingURL=opening-guides-runtime.d.ts.map