@pascal-app/nodes 1.0.6 → 1.0.7

package/dist/door/definition.js

@@ -1,4 +1,5 @@
-import { doorSlots } from '@pascal-app/core';
+import { doorSlots, getDoorOpeningSize } from '@pascal-app/core';
+import { NEW_DOOR_FRAME_THICKNESS } from '@pascal-app/core/building';
 import { curtainOpeningResizeMax } from '../shared/curtain-opening-limits.js';
 import { doorBatchable } from '../shared/node-batch/batchable.js';
 import { buildDoorFloorplanSchedule, computeDoorFloorplanLevelData, } from '../shared/opening-documentation.js';
@@ -54,7 +55,8 @@ function doorWidthHandle(side) {
             const roofMax = readRoofFaceWidthMax(n, scene, sign);
             if (roofMax !== null)
                 return Math.max(MIN_DOOR_WIDTH, roofMax);
-            return curtainOpeningResizeMax(n, scene.nodes(), 'x', sign) ?? readWallLength(n, scene);
+            return (curtainOpeningResizeMax(n, scene.nodes(), 'x', sign) ??
+                readWallLength(n, scene) - (getDoorOpeningSize(n).width - n.width));
         },
         currentValue: (n) => n.width,
         onDrag: (node) => publishOpeningResizeGuides(node, false),
@@ -80,7 +82,12 @@ function doorWidthHandle(side) {
         placement: {
             // door-local: +X axis lives along door's own X. Inner ride group
             // applies door.rotation, so we sit purely on door-local +X / -X.
-            position: (n) => [sign * (n.width / 2 + SIDE_HANDLE_OFFSET), 0, 0],
+            position: (n) => [
+                -getDoorOpeningSize(n).leafOffsetX +
+                    sign * (getDoorOpeningSize(n).width / 2 + SIDE_HANDLE_OFFSET),
+                0,
+                0,
+            ],
             rotationY: () => (side === 'right' ? 0 : Math.PI),
         },
         portal: 'grandparent',
@@ -100,7 +107,9 @@ function doorHeightHandle() {
             if (curtainMax !== undefined)
                 return curtainMax;
             const bottom = n.position[1] - n.height / 2;
-            return Math.max(MIN_DOOR_HEIGHT, readHostWallCeiling(n.wallId, scene, n) - bottom);
+            return Math.max(MIN_DOOR_HEIGHT, readHostWallCeiling(n.wallId, scene, n) -
+                bottom -
+                (getDoorOpeningSize(n).height - n.height));
         },
         currentValue: (n) => n.height,
         onDrag: (node) => publishOpeningResizeGuides(node, false),
@@ -115,7 +124,7 @@ function doorHeightHandle() {
             };
         },
         placement: {
-            position: (n) => [0, n.height / 2 + HEIGHT_HANDLE_OFFSET, 0],
+            position: (n) => [0, getDoorOpeningSize(n).height - n.height / 2 + HEIGHT_HANDLE_OFFSET, 0],
         },
         portal: 'grandparent',
     };
@@ -205,6 +214,8 @@ export const doorDefinition = {
         'pascal:editor/floorplan': {
             contextualDimensions: buildDoorContextualDimensions,
             schedule: buildDoorFloorplanSchedule,
+            // Swap hinge / swing side from the action bar, in 2D and 3D.
+            actionMenu: { actions: () => import('./actions.js') },
         },
     },
     surfaceRole: 'joinery',
@@ -212,14 +223,30 @@ export const doorDefinition = {
     // full default shape — door has 40+ fields, listing them inline would
     // duplicate the schema. Parse a minimal stub, drop id/type, return rest.
     defaults: () => {
-        const stub = DoorNode.parse({ id: 'door_default', type: 'door' });
+        const stub = DoorNode.parse({
+            id: 'door_default',
+            type: 'door',
+            frameThickness: NEW_DOOR_FRAME_THICKNESS,
+            casingFaceA: true,
+            casingFaceB: true,
+        });
         const { id: _id, type: _type, ...rest } = stub;
         return rest;
     },
     capabilities: {
         reveal: { phase: 'openings', style: 'cut' },
         exterior: openingSeenFromOutside,
-        revealOnEdit: ['position', 'width', 'height', 'openingShape', 'openingKind', 'doorType'],
+        revealOnEdit: [
+            'position',
+            'width',
+            'height',
+            'sidelightLeft',
+            'sidelightRight',
+            'transomHeight',
+            'openingShape',
+            'openingKind',
+            'doorType',
+        ],
         batchable: doorBatchable,
         selectable: { hitVolume: 'bbox' },
         duplicable: true,

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/door/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,mBAAmB,EAMzB,MAAM,kBAAkB,CAAA;AAQzB;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,mBAAmB,EAAE,mBAAmB,CAAC,QAAQ,CAkF7D,CAAA"}
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/door/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,mBAAmB,EAQzB,MAAM,kBAAkB,CAAA;AAQzB;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,mBAAmB,EAAE,mBAAmB,CAAC,QAAQ,CAsF7D,CAAA"}

package/dist/door/floorplan-affordances.js

@@ -1,4 +1,4 @@
-import { getWallCurveLength, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { getDoorOpeningSize, getWallCurveLength, openingHostFacing, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { curtainOpeningLimits } from '../shared/curtain-opening-limits.js';
 import { projectPlanPointToWallLocalX } from '../shared/wall-attach-target.js';
 const MIN_DOOR_WIDTH = 0.3;
@@ -37,7 +37,10 @@ export const doorWidthAffordance = {
         // legal width is the headroom on the grow side.
         const limits = curtainOpeningLimits(node, nodes);
         const margin = limits?.margin ?? 0;
-        const maxWidth = growDir > 0 ? (limits?.length ?? wallLength) - margin - anchorX : anchorX - margin;
+        const size = getDoorOpeningSize(node);
+        const sidelight = (size.width - node.width) / 2 - growDir * size.leafOffsetX * openingHostFacing(node);
+        const maxWidth = (growDir > 0 ? (limits?.length ?? wallLength) - margin - anchorX : anchorX - margin) -
+            sidelight;
         const projectToWallLocalX = (planPoint) => {
             return wall ? projectPlanPointToWallLocalX(wall, planPoint) : planPoint[0];
         };

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/door/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,mBAAmB,EAOzB,MAAM,kBAAkB,CAAA;AAoBzB;;;;;;;;;;;;;;GAcG;AAEH,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,QAAQ,CAsPjE,CAAA"}
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/door/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EAEb,KAAK,mBAAmB,EASzB,MAAM,kBAAkB,CAAA;AAqBzB;;;;;;;;;;;;;;GAcG;AAEH,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,QAAQ,CA2RjE,CAAA"}

package/dist/door/floorplan-move.js

@@ -1,6 +1,7 @@
-import { useLiveNodeOverrides, useLiveTransforms, useScene, WallNode as WallNodeSchema, } from '@pascal-app/core';
+import { doorPositionForFacing, getDoorOpeningSize, openingHostFacing, useLiveNodeOverrides, useLiveTransforms, useScene, WallNode as WallNodeSchema, } from '@pascal-app/core';
 import { isGridSnapActive, isMagneticSnapActive, snapToHalf, triggerSFX, useEditor, usePlacementPreview, } from '@pascal-app/editor';
 import { createFloorplanCursorResolver } from '../shared/floorplan-cursor.js';
+import { movedOpeningCasingFaces } from '../shared/opening-casing-move.js';
 import { openingPlaneOffsetOnWall } from '../shared/opening-plane-offset.js';
 import { getOpeningHostLevelId, getRoofHostedOpeningPlanPoint } from '../shared/roof-opening-host.js';
 import { findClosestWallInPlan, projectWallLocalPointToPlan, resolveOpeningPlacement, snapLocalXToNeighbors, } from '../shared/wall-attach-target.js';
@@ -158,23 +159,37 @@ export const doorFloorplanMoveTarget = ({ node }) => {
             // openings / wall ends); it competes with — and wins over — the grid
             // snap. Follows the magnetic ("lines") mode; the grid component lives in
             // `snapToHalf` (mode-aware → raw when grid is off).
+            const facingX = doorPositionForFacing({ ...node, position: [hit.localX, node.position[1], node.position[2]] }, [0, hit.itemRotation + (flipped ? Math.PI : 0), 0])[0];
             const neighborX = !isMagneticSnapActive()
                 ? null
                 : snapLocalXToNeighbors({
                     wall: hit.wall,
-                    localX: hit.localX,
-                    width: node.width,
+                    localX: facingX -
+                        getDoorOpeningSize(node).leafOffsetX *
+                            openingHostFacing({ rotation: [0, hit.itemRotation + (flipped ? Math.PI : 0), 0] }),
+                    width: getDoorOpeningSize(node).width,
                     selfId: nodeId,
                     nodes,
                 });
-            const snappedLocalX = neighborX ?? snapToHalf(hit.localX);
-            const { clampedX, clampedY } = clampToWall(hit.wall, snappedLocalX, node.width, node.height);
+            const offset = getDoorOpeningSize(node).leafOffsetX *
+                openingHostFacing({ rotation: [0, hit.itemRotation + (flipped ? Math.PI : 0), 0] });
+            const snappedLocalX = neighborX === null
+                ? snapToHalf(facingX - offset) + offset
+                : neighborX +
+                    getDoorOpeningSize(node).leafOffsetX *
+                        openingHostFacing({ rotation: [0, hit.itemRotation + (flipped ? Math.PI : 0), 0] });
+            const { clampedX, clampedY, transomHeight } = clampToWall(hit.wall, snappedLocalX, node.width, node.height, {
+                ...node,
+                rotation: [0, hit.itemRotation + (flipped ? Math.PI : 0), 0],
+            }, nodes);
             // One click per real position step, keyed on the SNAPPED along-wall value
             // so it ticks only when the door actually moves to a new cell.
             tickGridStep(clampedX);
             // Apply the R-flip on top of the wall-derived side.
             const side = flipped ? (hit.side === 'front' ? 'back' : 'front') : hit.side;
             const itemRotation = hit.itemRotation + (flipped ? Math.PI : 0);
+            // Another wall may be drawn the other way round: the casing keeps to its side.
+            const casing = movedOpeningCasingFaces(node, hit.wall.id, [0, itemRotation, 0], nodes);
             lastValid = {
                 // Same-wall moves keep the wall-local plane offset; another host resets it.
                 position: [clampedX, clampedY, openingPlaneOffsetOnWall(node, hit.wall.id)],
@@ -187,6 +202,8 @@ export const doorFloorplanMoveTarget = ({ node }) => {
                 roofSegmentId: undefined,
                 roofFace: undefined,
                 visible: true,
+                ...casing,
+                ...(transomHeight === undefined ? {} : { transomHeight }),
             };
             setLiveOverride(`wall:${hit.wall.id}:${side}`, {
                 parentId: hit.wall.id,
@@ -195,6 +212,8 @@ export const doorFloorplanMoveTarget = ({ node }) => {
                 roofSegmentId: undefined,
                 roofFace: undefined,
                 visible: true,
+                ...casing,
+                ...(transomHeight === undefined ? {} : { transomHeight }),
             });
             useLiveTransforms.getState().set(nodeId, {
                 position: lastValid.position,
@@ -215,7 +234,10 @@ export const doorFloorplanMoveTarget = ({ node }) => {
             // Block commit if the door overlaps another wall child — UNLESS Alt
             // force-places (same `placeable` rule as the 3D move + the shared
             // `resolveOpeningPlacement`).
-            const collides = hasWallChildOverlap(lastValid.parentId, useScene.getState().nodes, lastValid.position[0], lastValid.position[1], live.width, live.height, live.id);
+            const collides = hasWallChildOverlap(lastValid.parentId, useScene.getState().nodes, lastValid.position[0] -
+                getDoorOpeningSize({ ...live, ...lastValid }).leafOffsetX *
+                    openingHostFacing({ rotation: lastValid.rotation }), lastValid.position[1] +
+                (getDoorOpeningSize({ ...live, ...lastValid }).height - live.height) / 2, getDoorOpeningSize({ ...live, ...lastValid }).width, getDoorOpeningSize({ ...live, ...lastValid }).height, live.id);
             return resolveOpeningPlacement({ collides, forcePlace }).placeable;
         },
         commit() {

package/dist/door/floorplan.d.ts

@@ -23,6 +23,8 @@ import type { DoorNode, FloorplanGeometry, GeometryContext } from '@pascal-app/c
  * 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

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/door/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,iBAAiB,EAEjB,eAAe,EAEhB,MAAM,kBAAkB,CAAA;AAczB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAuxBjG"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/door/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,QAAQ,EACR,iBAAiB,EAEjB,eAAe,EAEhB,MAAM,kBAAkB,CAAA;AAezB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CA+1BjG"}

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/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,CA8mC9C,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();
@@ -243,19 +248,36 @@ 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, 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 = !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 +286,15 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
                 clampedX,
                 clampedY,
                 valid,
+                transomHeight,
                 event,
             };
         };
         const applyPreview = (target) => {
+            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 +363,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 +471,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 +508,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,
                     });
@@ -625,6 +663,7 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
             width: movingDoorNode.width,
             height: movingDoorNode.height,
             ignoreId: movingDoorNode.id,
+            opening: movingDoorNode,
             vertical: { kind: 'bottom-locked' },
         });
         const updateRoofCursor = (target, roof) => {
@@ -709,6 +748,7 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
                     roofSegmentId: segmentId,
                     roofFace: target.face.id,
                     parentId: segmentId,
+                    ...casingOn(segmentId, [0, 0, 0]),
                     visible: true,
                 });
                 history.commitStep(() => {
@@ -741,6 +781,7 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
                         wallId: undefined,
                         roofSegmentId: segmentId,
                         roofFace: target.face.id,
+                        ...casingOn(segmentId, [0, 0, 0]),
                         visible: true,
                     });
                 });
@@ -852,9 +893,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),
                 });
             }
         };
@@ -940,6 +983,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 +1008,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"}