@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/door/floorplan.js

@@ -1,5 +1,6 @@
-import { getWallBodyCenterOffset } from '@pascal-app/core';
+import { getDoorOpeningSize, getWallBodyCenterOffset, openingHostFacing } from '@pascal-app/core';
 import { readFloorplanContext, readFloorplanGeometryMetadata, withFloorplanGeometryMetadata, } from '@pascal-app/editor';
+import { buildOpeningCasingPlan } from '../shared/opening-casing.js';
 import { buildOpeningMarkAnnotation, } from '../shared/opening-documentation.js';
 import { buildOpeningPlacementDimensions } from '../shared/opening-placement-dimensions.js';
 import { resolveOpeningPlanPlane } from '../shared/opening-plane-offset.js';
@@ -27,6 +28,8 @@ import { resolveOpeningPlanPlane } from '../shared/opening-plane-offset.js';
  * with no swing arc.
  *   4. Center line through the cutout (matches the legacy's
  *      `getOpeningCenterLine` segment for visual continuity).
+ *   5. Casing legs standing proud of each cased wall face beside the
+ *      cutout (`buildOpeningCasingPlan`).
  *
  * Requires `ctx.parent` to be a wall (door.parentId is the wall it's
  * mounted on). Returns null when the parent isn't a wall (orphaned
@@ -54,6 +57,8 @@ export function buildDoorFloorplan(node, ctx) {
     const perpZ = dirX;
     const distance = node.position[0];
     const width = node.width;
+    const opening = getDoorOpeningSize(node);
+    const openingOffset = -opening.leafOffsetX * openingHostFacing(node);
     const wallDepth = wall.thickness ?? 0.1;
     const plane = resolveOpeningPlanPlane(node, wallDepth);
     const depth = plane.depth;
@@ -82,17 +87,41 @@ export function buildDoorFloorplan(node, ctx) {
     const swingAngle = Math.PI / 2;
     // Footprint rectangle in the cutout.
     const points = [
-        [cx - dirX * halfWidth + perpX * halfDepth, cz - dirZ * halfWidth + perpZ * halfDepth],
-        [cx + dirX * halfWidth + perpX * halfDepth, cz + dirZ * halfWidth + perpZ * halfDepth],
-        [cx + dirX * halfWidth - perpX * halfDepth, cz + dirZ * halfWidth - perpZ * halfDepth],
-        [cx - dirX * halfWidth - perpX * halfDepth, cz - dirZ * halfWidth - perpZ * halfDepth],
+        [
+            cx + dirX * openingOffset - dirX * (opening.width / 2) + perpX * halfDepth,
+            cz + dirZ * openingOffset - dirZ * (opening.width / 2) + perpZ * halfDepth,
+        ],
+        [
+            cx + dirX * openingOffset + dirX * (opening.width / 2) + perpX * halfDepth,
+            cz + dirZ * openingOffset + dirZ * (opening.width / 2) + perpZ * halfDepth,
+        ],
+        [
+            cx + dirX * openingOffset + dirX * (opening.width / 2) - perpX * halfDepth,
+            cz + dirZ * openingOffset + dirZ * (opening.width / 2) - perpZ * halfDepth,
+        ],
+        [
+            cx + dirX * openingOffset - dirX * (opening.width / 2) - perpX * halfDepth,
+            cz + dirZ * openingOffset - dirZ * (opening.width / 2) - perpZ * halfDepth,
+        ],
     ];
     const halfWallDepth = wallDepth / 2;
     const openingCutoutPoints = (ox, oz) => [
-        [ox - dirX * halfWidth + perpX * halfWallDepth, oz - dirZ * halfWidth + perpZ * halfWallDepth],
-        [ox + dirX * halfWidth + perpX * halfWallDepth, oz + dirZ * halfWidth + perpZ * halfWallDepth],
-        [ox + dirX * halfWidth - perpX * halfWallDepth, oz + dirZ * halfWidth - perpZ * halfWallDepth],
-        [ox - dirX * halfWidth - perpX * halfWallDepth, oz - dirZ * halfWidth - perpZ * halfWallDepth],
+        [
+            ox + dirX * openingOffset - dirX * (opening.width / 2) + perpX * halfWallDepth,
+            oz + dirZ * openingOffset - dirZ * (opening.width / 2) + perpZ * halfWallDepth,
+        ],
+        [
+            ox + dirX * openingOffset + dirX * (opening.width / 2) + perpX * halfWallDepth,
+            oz + dirZ * openingOffset + dirZ * (opening.width / 2) + perpZ * halfWallDepth,
+        ],
+        [
+            ox + dirX * openingOffset + dirX * (opening.width / 2) - perpX * halfWallDepth,
+            oz + dirZ * openingOffset + dirZ * (opening.width / 2) - perpZ * halfWallDepth,
+        ],
+        [
+            ox + dirX * openingOffset - dirX * (opening.width / 2) - perpX * halfWallDepth,
+            oz + dirZ * openingOffset - dirZ * (opening.width / 2) - perpZ * halfWallDepth,
+        ],
     ];
     const view = ctx.viewState;
     const palette = view?.palette;
@@ -134,6 +163,36 @@ export function buildDoorFloorplan(node, ctx) {
             strokeLinejoin: 'round',
         },
     ];
+    for (const [side, extra] of [
+        [-1, node.sidelightLeft ?? 0],
+        [1, node.sidelightRight ?? 0],
+    ]) {
+        if (!extra || opening.width === width)
+            continue;
+        const sign = side * openingHostFacing(node);
+        const a = (sign * width) / 2;
+        const b = sign * (width / 2 + extra);
+        children.push({
+            kind: 'polyline',
+            points: [
+                [cx + dirX * a, cz + dirZ * a],
+                [cx + dirX * b, cz + dirZ * b],
+            ],
+            fill: 'none',
+            stroke: accentColor,
+            strokeWidth: 2,
+            vectorEffect: 'non-scaling-stroke',
+        });
+    }
+    // Casing legs on the wall faces beside the cutout, as the 3D door has them.
+    const casing = buildOpeningCasingPlan(node, wall, {
+        fill: fillColor,
+        stroke: accentMuted,
+        strokeWidth: showSelectedChrome ? 1.4 : 1,
+        vectorEffect: 'non-scaling-stroke',
+    });
+    if (casing)
+        children.push(casing);
     if (node.openingShape !== 'rectangle') {
         const overheadRise = Math.min(width, node.openingShape === 'arch' ? node.archHeight : node.cornerRadius) * 0.2;
         const overheadSide = swingDirection === 'inward' ? 1 : -1;
@@ -263,8 +322,9 @@ export function buildDoorFloorplan(node, ctx) {
     // fall through to just the opening footprint (the earlier behaviour).
     const isSwingDoor = node.doorType === 'hinged' || isDoubleLeaf;
     // A frameless wall opening — drawn as a bare gap, no leaf / arc / panel
-    // (mirrors the 3D system, which renders only the cutout for openings).
-    const isOpening = node.openingKind === 'opening';
+    // (mirrors the 3D system, which renders only the cutout for openings). A
+    // door on a railing is always one: a gap in the guard.
+    const isOpening = node.openingKind === 'opening' || wall.wallType === 'railing';
     if (isOpening) {
         // Open doorway — a frameless gap in the wall. No leaf, arc, or panel;
         // the cleared footprint above is the whole symbol.
@@ -278,7 +338,7 @@ export function buildDoorFloorplan(node, ctx) {
         // The fold span / depth are fixed so the plan symbol stays static
         // regardless of the live open state.
         const FOLD_SPAN_RATIO = 0.8;
-        const panelCount = node.leafCount === 2 ? 2 : 4;
+        const panelCount = node.leafCount >= 6 ? node.leafCount : node.leafCount === 2 ? 2 : 4;
         const panelLen = (width * FOLD_SPAN_RATIO) / panelCount;
         const peakDepth = panelLen * 0.7;
         // Anchor the accordion's base line on the room-facing wall face (the
@@ -287,7 +347,11 @@ export function buildDoorFloorplan(node, ctx) {
         const baseOffX = perpX * halfDepth * swingSign;
         const baseOffZ = perpZ * halfDepth * swingSign;
         // Start at the hinge edge and step toward the opposite jamb.
-        const hingeTangentSign = hingesSide === 'left' ? 1 : -1;
+        const hingeTangentSign = panelCount > 4
+            ? (node.slideDirection === 'right' ? -1 : 1) * openingHostFacing(node)
+            : hingesSide === 'left'
+                ? 1
+                : -1;
         const startX = cx - dirX * halfWidth * hingeTangentSign + baseOffX;
         const startZ = cz - dirZ * halfWidth * hingeTangentSign + baseOffZ;
         const stepX = dirX * panelLen * hingeTangentSign;
@@ -322,7 +386,8 @@ export function buildDoorFloorplan(node, ctx) {
         // regardless of the live open state.
         const slideSign = node.slideDirection === 'right' ? 1 : -1;
         const panelHalfThick = Math.min(depth * 0.22, 0.03);
-        const panelHalfLen = width * 0.275;
+        const panelCount = Math.max(2, Math.min(4, node.leafCount));
+        const panelHalfLen = panelCount === 2 ? width * 0.275 : width / panelCount / 2 + 0.01;
         const panelRect = (centerAlong, perpSign) => {
             const rcx = cx + dirX * centerAlong + perpX * panelHalfThick * perpSign;
             const rcz = cz + dirZ * centerAlong + perpZ * panelHalfThick * perpSign;
@@ -348,8 +413,16 @@ export function buildDoorFloorplan(node, ctx) {
         });
         // Left panel toward one face, right panel toward the other; they
         // overlap across the centre.
-        pushPanel(panelRect(-halfWidth + panelHalfLen, 1));
-        pushPanel(panelRect(halfWidth - panelHalfLen, -1));
+        for (let index = 0; index < panelCount; index++) {
+            const front = node.slidingStyle === 'bypass'
+                ? index % 2 === (panelCount === 3 || slideSign < 0 ? 1 : 0)
+                : panelCount === 4
+                    ? index === 1 || index === 2
+                    : panelCount === 3
+                        ? index === 1
+                        : index === (slideSign < 0 ? 1 : 0);
+            pushPanel(panelRect(-halfWidth + (width * (index + 0.5)) / panelCount, front ? 1 : -1));
+        }
         // Slide-direction arrow, centred and pushed clear of the wall face
         // so it doesn't overlap the wall or panels.
         const arrowPerp = -(halfDepth + Math.max(panelHalfThick * 4, halfWidth * 0.22));

package/dist/door/mechanism.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mechanism.d.ts","sourceRoot":"","sources":["../../src/door/mechanism.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,KAAK,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AAIhF,8FAA8F;AAC9F,eAAO,MAAM,aAAa,EAAE,mBAiB3B,CAAA"}
+{"version":3,"file":"mechanism.d.ts","sourceRoot":"","sources":["../../src/door/mechanism.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,mBAAmB,EAEzB,MAAM,kBAAkB,CAAA;AAGzB,8FAA8F;AAC9F,eAAO,MAAM,aAAa,EAAE,mBAiB3B,CAAA"}

package/dist/door/mechanism.js

@@ -1,5 +1,4 @@
-import { isOperationDoorType } from '@pascal-app/core';
-import { closeDoorOpenState, getDisplayedDoorValue, openDoorOpenState } from '@pascal-app/editor';
+import { closeDoorOpenState, getDisplayedDoorValue, isOperationDoorType, openDoorOpenState, } from '@pascal-app/core';
 import { scriptedOpening } from '../shared/scripted-opening.js';
 /** A door's leaf: Play opens it and Stop closes it, without touching the saved open state. */
 export const doorMechanism = {

package/dist/door/move-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/door/move-tool.tsx"],"names":[],"mappings":"AAAA,OAAO,EAIL,QAAQ,EAcT,MAAM,kBAAkB,CAAA;AAoDzB,QAAA,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAyjC9C,CAAA;eAEc,YAAY"}
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/door/move-tool.tsx"],"names":[],"mappings":"AAAA,OAAO,EAIL,QAAQ,EAqBT,MAAM,kBAAkB,CAAA;AAqDzB,QAAA,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAknC9C,CAAA;eAEc,YAAY"}

package/dist/door/move-tool.js

@@ -1,11 +1,12 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { beginSceneHistoryDraft, collectionIdsOf, DoorNode, emitter, getOpeningWallPlacement, holdHiddenWallPointerEvents, isCurvedWall, runSceneHistoryDraftWrite, sceneRegistry, spatialGridManager, useLiveTransforms, useScene, } from '@pascal-app/core';
+import { beginSceneHistoryDraft, collectionIdsOf, DoorNode, doorPositionForFacing, emitter, getDoorOpeningSize, getOpeningWallPlacement, getWallThickness, holdHiddenWallPointerEvents, isCurvedWall, openingHostFacing, resolveHostedOpeningFrameDepth, resolveOpeningFrameDepth, runSceneHistoryDraftWrite, sceneRegistry, spatialGridManager, useLiveNodeOverrides, useLiveTransforms, useScene, } from '@pascal-app/core';
 import { calculateItemRotation, clearPlacementSurface, consumePlacementDragRelease, EDITOR_LAYER, getSideFromNormal, isGridSnapActive, isMagneticSnapActive, isValidWallSideFace, publishPlacementSurface, stripPlacementMetadataFlags, triggerSFX, useAlignmentGuides, useEditor, useFacingPose, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { BoxGeometry, EdgesGeometry, Vector3 } from 'three';
 import { LineBasicNodeMaterial } from 'three/webgpu';
 import { commitOpeningMove } from '../shared/commit-opening-move.js';
+import { movedOpeningCasingFaces } from '../shared/opening-casing-move.js';
 import { clearOpeningGuides3D, publishOpeningGuidesForWallEvent, } from '../shared/opening-guides-runtime.js';
 import { beginOpeningMoveHistorySession } from '../shared/opening-move-history.js';
 import { isWallMeshHidden, shouldIgnoreWallEventForOpeningMove, } from '../shared/opening-move-wall-gate.js';
@@ -40,9 +41,10 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
     const ghostNode = useMemo(() => ({
         ...movingDoorNode,
         side: ghostSide,
+        transomHeight: ghostPose?.transomHeight ?? movingDoorNode.transomHeight,
         position: [0, 0, 0],
         rotation: [0, 0, 0],
-    }), [movingDoorNode, ghostSide]);
+    }), [movingDoorNode, ghostSide, ghostPose?.transomHeight]);
     const exitMoveMode = useCallback(() => {
         useEditor.getState().setMovingNode(null);
     }, []);
@@ -90,6 +92,8 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
         }
         // Same-wall moves keep the wall-local plane offset; another host resets it.
         const planeOffsetOn = (wallId) => openingPlaneOffsetOnWall(movingDoorNode, wallId);
+        // Another host may name its faces the other way round: the casing keeps to its side of it.
+        const casingOn = (hostId, rotation) => movedOpeningCasingFaces(movingDoorNode, hostId, rotation, useScene.getState().nodes);
         let currentHostId = movingDoorNode.parentId;
         let dragAnchor = null;
         // The wall the door was grabbed from. Nulled the first time the anchor
@@ -177,6 +181,7 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
         };
         const getSlabElevation = (wallEvent) => spatialGridManager.getSlabElevationForWall(wallEvent.node.parentId ?? '', wallEvent.node.start, wallEvent.node.end, wallEvent.node.curveOffset ?? 0, wallEvent.node.thickness, wallEvent.node.supportSlabId, wallEvent.node.justification);
         const hideCursor = () => {
+            useLiveNodeOverrides.getState().clearFields(movingDoorNode.id, ['transomHeight']);
             if (cursorGroupRef.current)
                 cursorGroupRef.current.visible = false;
             useAlignmentGuides.getState().clear();
@@ -232,8 +237,8 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
             const rawLocalX = event.localPosition[0];
             if (!dragAnchor || dragAnchor.wallId !== event.node.id) {
                 // Grab offset survives only on the original wall and only until the
-                // door anchors on any other host — after that every wall (the
-                // original included) centers the door under the cursor.
+                // door anchors on any other host — after that every wall (the original
+                // included) centers the door under the cursor.
                 const preserveGrab = event.node.id === grabWallId;
                 if (!preserveGrab)
                     grabWallId = null;
@@ -243,19 +248,37 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
                     startX: preserveGrab ? original.position[0] : rawLocalX,
                 };
             }
-            const targetLocalX = dragAnchor.startX + (rawLocalX - dragAnchor.rawX);
+            const targetLocalX = doorPositionForFacing({
+                ...movingDoorNode,
+                position: [
+                    dragAnchor.startX + (rawLocalX - dragAnchor.rawX),
+                    movingDoorNode.position[1],
+                    movingDoorNode.position[2],
+                ],
+            }, [0, itemRotation, 0])[0];
             const localX = resolveWallSlideAlignment({
                 wallNode: event.node,
-                rawLocalX: targetLocalX,
-                width: movingDoorNode.width,
+                rawLocalX: targetLocalX -
+                    getDoorOpeningSize(movingDoorNode).leafOffsetX *
+                        openingHostFacing({ rotation: [0, itemRotation, 0] }),
+                width: getDoorOpeningSize(movingDoorNode).width,
                 candidates: alignmentCandidates,
                 // Along-wall alignment guides display in every snapping mode; the
                 // magnetic pull onto them lands only in "lines" mode. The grid
                 // component lives in `snapToHalf` (itself mode-aware).
                 applySnap: isMagneticSnapActive(),
             });
-            const { clampedX, clampedY } = clampToWall(event.node, localX, movingDoorNode.width, movingDoorNode.height);
-            const valid = !hasWallChildOverlap(event.node.id, useScene.getState().nodes, clampedX, clampedY, movingDoorNode.width, movingDoorNode.height, movingDoorNode.id);
+            const { clampedX, clampedY, fits, transomHeight } = clampToWall(event.node, localX +
+                getDoorOpeningSize(movingDoorNode).leafOffsetX *
+                    openingHostFacing({ rotation: [0, itemRotation, 0] }), movingDoorNode.width, movingDoorNode.height, { ...movingDoorNode, rotation: [0, itemRotation, 0] }, useScene.getState().nodes);
+            const fittedSize = getDoorOpeningSize({
+                ...movingDoorNode,
+                transomHeight: transomHeight ?? movingDoorNode.transomHeight,
+            });
+            const valid = fits &&
+                !hasWallChildOverlap(event.node.id, useScene.getState().nodes, clampedX -
+                    getDoorOpeningSize(movingDoorNode).leafOffsetX *
+                        openingHostFacing({ rotation: [0, itemRotation, 0] }), clampedY + (fittedSize.height - movingDoorNode.height) / 2, fittedSize.width, fittedSize.height, movingDoorNode.id);
             return {
                 wallNode: event.node,
                 wallId: event.node.id,
@@ -264,10 +287,18 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
                 clampedX,
                 clampedY,
                 valid,
+                transomHeight,
                 event,
             };
         };
         const applyPreview = (target) => {
+            useLiveNodeOverrides
+                .getState()
+                .clearFields(movingDoorNode.id, ['position', 'rotation', 'roofFace']);
+            if (target.transomHeight !== undefined)
+                useLiveNodeOverrides
+                    .getState()
+                    .set(movingDoorNode.id, { transomHeight: target.transomHeight });
             // One grid-snap tick per real position step, keyed on the SNAPPED
             // along-wall position so it ticks only when the door actually moves to a
             // new cell (not on every micro mouse-move). Per-frame guard collapses any
@@ -336,29 +367,36 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
                 rotationY: ghostYaw,
                 tint: placement.tint,
                 side: target.side,
+                transomHeight: target.transomHeight,
             });
             // Forward-facing triangle (editor-side overlay), in the same building-local
             // frame the ghost renders in. The door's front is its local +Z. Drop it to
-            // the floor under the wall (the ghost Y is the opening centre, ~1m up).
+            // the door's sill (the ghost Y is the opening centre, ~1m up).
             useFacingPose.getState().set({
                 position: [
                     ghostWorldPos[0],
-                    getLevelYOffset() + getSlabElevation(target.event),
+                    ghostWorldPos[1] - movingDoorNode.height / 2,
                     ghostWorldPos[2],
                 ],
                 rotationY: ghostYaw,
-                depth: movingDoorNode.frameDepth ?? 0.07,
+                depth: resolveOpeningFrameDepth(movingDoorNode, getWallThickness(target.wallNode)),
             });
             // Publish the wall surface so the snap grid tilts into the wall plane at
             // the opening (its outward normal is the door's facing, +Z by `ghostYaw`).
             publishPlacementSurface(new Vector3(...ghostWorldPos), new Vector3(Math.sin(ghostYaw), 0, Math.cos(ghostYaw)));
+            const fittedSize = getDoorOpeningSize({
+                ...movingDoorNode,
+                transomHeight: target.transomHeight ?? movingDoorNode.transomHeight,
+            });
             publishOpeningGuidesForWallEvent({
                 wall: target.wallNode,
                 movingId: movingDoorNode.id,
-                centerS: target.clampedX,
-                centerY: target.clampedY,
-                width: movingDoorNode.width,
-                height: movingDoorNode.height,
+                centerS: target.clampedX -
+                    getDoorOpeningSize(movingDoorNode).leafOffsetX *
+                        openingHostFacing({ rotation: [0, target.itemRotation, 0] }),
+                centerY: target.clampedY + (fittedSize.height - movingDoorNode.height) / 2,
+                width: getDoorOpeningSize(movingDoorNode).width,
+                height: fittedSize.height,
                 // Doors sit on the floor — no sill/head or vertical alignment guides.
                 includeVertical: false,
                 levelYOffset: getLevelYOffset(),
@@ -437,8 +475,10 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
                     position: [target.clampedX, target.clampedY, planeOffsetOn(target.wallId)],
                     rotation: [0, target.itemRotation, 0],
                     side: target.side,
+                    ...(target.transomHeight === undefined ? {} : { transomHeight: target.transomHeight }),
                     wallId: target.wallId,
                     parentId: target.wallId,
+                    ...casingOn(target.wallId, [0, target.itemRotation, 0]),
                     roofSegmentId: undefined,
                     roofFace: undefined,
                     // The moving node is hidden during free-follow; the committed door
@@ -472,8 +512,10 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
                         position: [target.clampedX, target.clampedY, planeOffsetOn(target.wallId)],
                         rotation: [0, target.itemRotation, 0],
                         side: target.side,
+                        ...(target.transomHeight === undefined ? {} : { transomHeight: target.transomHeight }),
                         parentId: target.wallId,
                         wallId: target.wallId,
+                        ...casingOn(target.wallId, [0, target.itemRotation, 0]),
                         roofSegmentId: undefined,
                         visible: true,
                     });
@@ -547,6 +589,7 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
         // later wall-snap / commit has a clean base, but stays `visible:false` until
         // a wall is hovered.
         const freeFollowAt = (localX, localZ) => {
+            useLiveNodeOverrides.getState().clear(movingDoorNode.id);
             freeFollowing = true;
             lastTarget = null;
             lastRoofEvent = null;
@@ -564,15 +607,7 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
             // (back = rotated π) instead of forcing 0, so an R press isn't undone on
             // the next mousemove.
             const yaw = sideOverride === 'back' ? Math.PI : 0;
-            if (currentHostId === levelId) {
-                updateDraft({
-                    position: [localX, y, localZ],
-                    rotation: [0, yaw, 0],
-                    side: sideOverride,
-                    visible: false,
-                });
-            }
-            else {
+            if (currentHostId !== levelId) {
                 if (currentHostId && currentHostId !== levelId)
                     markHostDirty(currentHostId);
                 updateDraft({
@@ -625,6 +660,7 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
             width: movingDoorNode.width,
             height: movingDoorNode.height,
             ignoreId: movingDoorNode.id,
+            opening: movingDoorNode,
             vertical: { kind: 'bottom-locked' },
         });
         const updateRoofCursor = (target, roof) => {
@@ -655,14 +691,8 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
             // On a roof face the real mesh is the preview — drop the free-follow ghost
             // and reveal the node.
             revealRealNode();
-            if (currentHostId === target.segment.id) {
-                updateDraft({
-                    position: target.position,
-                    rotation: [0, 0, 0],
-                    roofFace: target.face.id,
-                });
-            }
-            else {
+            if (currentHostId !== target.segment.id) {
+                useLiveNodeOverrides.getState().clear(movingDoorNode.id);
                 updateDraft({
                     position: target.position,
                     rotation: [0, 0, 0],
@@ -676,6 +706,13 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
                 markHostDirty(currentHostId);
                 currentHostId = target.segment.id;
             }
+            useLiveNodeOverrides.getState().set(movingDoorNode.id, {
+                position: target.position,
+                rotation: [0, 0, 0],
+                roofFace: target.face.id,
+            });
+            useScene.getState().markDirty(movingDoorNode.id);
+            markHostDirtyThrottled(target.segment.id);
             updateRoofCursor(target, event.node);
             event.stopPropagation();
         };
@@ -709,6 +746,7 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
                     roofSegmentId: segmentId,
                     roofFace: target.face.id,
                     parentId: segmentId,
+                    ...casingOn(segmentId, [0, 0, 0]),
                     visible: true,
                 });
                 history.commitStep(() => {
@@ -741,6 +779,7 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
                         wallId: undefined,
                         roofSegmentId: segmentId,
                         roofFace: target.face.id,
+                        ...casingOn(segmentId, [0, 0, 0]),
                         visible: true,
                     });
                 });
@@ -749,6 +788,7 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
                 }
                 placedId = movingDoorNode.id;
             }
+            useLiveNodeOverrides.getState().clear(movingDoorNode.id);
             markHostDirty(segmentId);
             useLiveTransforms.getState().clear(movingDoorNode.id);
             triggerSFX('sfx:structure-build');
@@ -759,6 +799,7 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
             event.stopPropagation();
         };
         const onRoofLeave = () => {
+            useLiveNodeOverrides.getState().clear(movingDoorNode.id);
             // Mirror onWallLeave: don't revert to origin here — onGridMove takes
             // over on the same pointermove (snap to a nearby wall or free-follow).
             hideCursor();
@@ -768,6 +809,7 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
             lastRoofEvent = null;
         };
         const onCancel = () => {
+            useLiveNodeOverrides.getState().clear(movingDoorNode.id);
             useLiveTransforms.getState().clear(movingDoorNode.id);
             if (isNew) {
                 useScene.getState().deleteNode(movingDoorNode.id);
@@ -852,9 +894,11 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
                 // No preview yet (R pressed before the first pointermove at initial
                 // placement): flip the hidden node so the FIRST preview/commit already
                 // reflects the chosen side.
+                const rotation = [0, sideOverride === 'back' ? Math.PI : 0, 0];
                 updateDraft({
                     side: sideOverride,
-                    rotation: [0, sideOverride === 'back' ? Math.PI : 0, 0],
+                    rotation,
+                    position: doorPositionForFacing(movingDoorNode, rotation),
                 });
             }
         };
@@ -907,6 +951,7 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
             }
         }
         return () => {
+            useLiveNodeOverrides.getState().clear(movingDoorNode.id);
             const current = useScene.getState().nodes[movingDoorNode.id];
             const currentMeta = current?.metadata;
             if (currentMeta?.isTransient) {
@@ -940,6 +985,7 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
                 updateDraft({ visible: true });
             }
             useLiveTransforms.getState().clear(movingDoorNode.id);
+            useLiveNodeOverrides.getState().clearFields(movingDoorNode.id, ['transomHeight']);
             useAlignmentGuides.getState().clear();
             clearOpeningGuides3D();
             useFacingPose.getState().clear();
@@ -964,7 +1010,7 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
         };
     }, [movingDoorNode, exitMoveMode]);
     const edgesGeo = useMemo(() => {
-        const boxGeo = new BoxGeometry(movingDoorNode.width, movingDoorNode.height, movingDoorNode.frameDepth ?? 0.07);
+        const boxGeo = new BoxGeometry(movingDoorNode.width, movingDoorNode.height, resolveHostedOpeningFrameDepth(movingDoorNode, useScene.getState().nodes));
         const geo = new EdgesGeometry(boxGeo);
         boxGeo.dispose();
         return geo;

package/dist/door/paint.d.ts

@@ -1,8 +1,3 @@
-/**
- * Door paint on the unified slot model. The door's opening proxy (a proud,
- * invisible cutout) wins the shared scene raycast over the wall in front of the
- * recessed door body, so `resolveSlotByReRaycast` re-raycasts the door's own
- * subtree to find the part (panel / frame / glass / hardware) under the cursor.
- */
-export declare const doorPaint: import("@pascal-app/core").PaintCapability;
+import { type PaintCapability } from '@pascal-app/core';
+export declare const doorPaint: PaintCapability;
 //# sourceMappingURL=paint.d.ts.map

package/dist/door/paint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/door/paint.ts"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,eAAO,MAAM,SAAS,4CAOpB,CAAA"}
+{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/door/paint.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAA+C,MAAM,kBAAkB,CAAA;AAiCpG,eAAO,MAAM,SAAS,EAAE,eAQvB,CAAA"}

package/dist/door/paint.js

@@ -1,14 +1,38 @@
-import { createSlotPaintCapability, previewSlotByUserData, resolveSlotByReRaycast, } from '../shared/slot-paint.js';
+import { slotDefaultPaintMaterial, slotPaintMaterial } from '@pascal-app/core';
+import { openingCasingPaintLabel } from '../shared/opening-casing.js';
+import { createSlotPaintCapability, declaredSlotLook, previewSlotByUserData, resolveSlotByReRaycast, } from '../shared/slot-paint.js';
 /**
  * Door paint on the unified slot model. The door's opening proxy (a proud,
  * invisible cutout) wins the shared scene raycast over the wall in front of the
  * recessed door body, so `resolveSlotByReRaycast` re-raycasts the door's own
  * subtree to find the part (panel / frame / glass / hardware) under the cursor.
  */
-export const doorPaint = createSlotPaintCapability({
+const base = createSlotPaintCapability({
     resolveRole: resolveSlotByReRaycast,
     applyPreview: previewSlotByUserData,
+    erasedLook: ({ node, role, materials = {} }) => {
+        if (role !== 'casing-a' && role !== 'casing-b')
+            return declaredSlotLook(node, role);
+        if (node.type !== 'door' || node.source)
+            return null;
+        const frame = slotPaintMaterial(node.slots?.frame, materials) ?? slotDefaultPaintMaterial(node.slots?.frame);
+        if (frame)
+            return frame;
+        if (node.material)
+            return { material: node.material };
+        return declaredSlotLook(node, 'frame');
+    },
     legacyEffective: (node, role) => node.type === 'door' && !node.source && node.material && (role === 'panel' || role === 'frame')
         ? { material: node.material, materialPreset: undefined }
         : null,
 });
+export const doorPaint = {
+    ...base,
+    roleLabel: (_node, role) => openingCasingPaintLabel(role),
+    getEffectiveMaterial: (args) => {
+        const own = base.getEffectiveMaterial?.(args);
+        if (own || (args.role !== 'casing-a' && args.role !== 'casing-b'))
+            return own ?? null;
+        return base.getEffectiveMaterial?.({ ...args, role: 'frame' }) ?? null;
+    },
+};

package/dist/door/panel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/door/panel.tsx"],"names":[],"mappings":"AAiEA,MAAM,CAAC,OAAO,UAAU,SAAS,uCAogChC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/door/panel.tsx"],"names":[],"mappings":"AA0HA,MAAM,CAAC,OAAO,UAAU,SAAS,uCA2uChC"}