@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/door/definition.js

@@ -1,314 +1,4 @@
-import { doorSlots } from '@pascal-app/core';
-import { curtainOpeningResizeMax } from '../shared/curtain-opening-limits.js';
-import { doorBatchable } from '../shared/node-batch/batchable.js';
-import { buildDoorFloorplanSchedule, computeDoorFloorplanLevelData, } from '../shared/opening-documentation.js';
-import { publishOpeningResizeGuides } from '../shared/opening-guides-runtime.js';
-import { createOpeningPropertyPreview } from '../shared/opening-property-preview.js';
-import { openingPropertyPreviewHost } from '../shared/opening-property-preview-host.js';
-import { readRoofFaceHeightMax, readRoofFaceWidthMax } from '../shared/roof-opening-host.js';
-import { buildRoofWallOpeningCut } from '../shared/roof-wall-opening-cut.js';
-import { scriptedOpeningHandles } from '../shared/scripted-opening-handles.js';
-import { readHostWallCeiling } from '../shared/wall-opening-ceiling.js';
-import { openingSeenFromOutside } from '../wall/exterior.js';
-import { wallFloorplanSiblingOverrides } from '../wall/floorplan-overrides.js';
-import { buildDoorContextualDimensions } from './contextual-dimensions.js';
-import { scaleHandleHeight } from './door-math.js';
-import { buildDoorFloorplan } from './floorplan.js';
-import { doorWidthAffordance } from './floorplan-affordances.js';
-import { doorFloorplanMoveTarget } from './floorplan-move.js';
-import { doorMechanism } from './mechanism.js';
-import { doorPaint } from './paint.js';
-import { doorParametrics } from './parametrics.js';
-import { DOOR_PLACEMENT_HINTS } from './placement.js';
-import { DoorNode } from './schema.js';
-const SIDE_HANDLE_OFFSET = 0.24;
-const HEIGHT_HANDLE_OFFSET = 0.24;
-const MIN_DOOR_HEIGHT = 0.5;
-const MIN_DOOR_WIDTH = 0.3;
-// How far the move cross floats off the wall face (+Z, the door's facing
-// normal) so it's grabbable instead of buried in the leaf/frame.
-const MOVE_HANDLE_LIFT = 0.12;
-function readWallLength(door, scene) {
-    if (!door.wallId)
-        return Number.POSITIVE_INFINITY;
-    const wall = scene.get(door.wallId);
-    if (!wall)
-        return Number.POSITIVE_INFINITY;
-    return Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
-}
-// Width arrow on the door-local +X (right) or -X (left) side. Drag grows
-// the door from the anchored OPPOSITE edge; the door's wall-local center
-// re-centers so the anchored edge stays put.
-function doorWidthHandle(side) {
-    const sign = side === 'right' ? 1 : -1;
-    return {
-        kind: 'linear-resize',
-        axis: 'x',
-        // 'min' = -X edge anchored (right arrow grows the +X edge outward).
-        // 'max' = +X edge anchored (left arrow grows the -X edge outward).
-        anchor: side === 'right' ? 'min' : 'max',
-        min: MIN_DOOR_WIDTH,
-        max: (n, scene) => {
-            // Roof-hosted doors clamp against the face profile (the wall-based
-            // limits read Infinity when wallId is unset).
-            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);
-        },
-        currentValue: (n) => n.width,
-        onDrag: (node) => publishOpeningResizeGuides(node, false),
-        apply: (initial, newWidth) => {
-            // Anchored edge stays fixed in wall-local coords. Door rotation is
-            // applied by the inner ride group (the renderer mounts a nested
-            // <group> at the door's pose), so the apply math here is in
-            // door-local coords AND the patch.position must be in wall-local
-            // coords. We compute the anchored wall-local point from the
-            // initial node, then derive the new wall-local center from it.
-            const rotY = initial.rotation[1];
-            const armX = Math.cos(rotY);
-            const armZ = -Math.sin(rotY);
-            const anchorX = initial.position[0] - sign * (initial.width / 2) * armX;
-            const anchorZ = initial.position[2] - sign * (initial.width / 2) * armZ;
-            const newCenterX = anchorX + sign * (newWidth / 2) * armX;
-            const newCenterZ = anchorZ + sign * (newWidth / 2) * armZ;
-            return {
-                width: newWidth,
-                position: [newCenterX, initial.position[1], newCenterZ],
-            };
-        },
-        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],
-            rotationY: () => (side === 'right' ? 0 : Math.PI),
-        },
-        portal: 'grandparent',
-    };
-}
-function doorHeightHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'y',
-        anchor: 'min', // bottom anchored at wall-local Y = position[1] - height/2
-        min: MIN_DOOR_HEIGHT,
-        max: (n, scene) => {
-            const roofMax = readRoofFaceHeightMax(n, scene, 1);
-            if (roofMax !== null)
-                return Math.max(MIN_DOOR_HEIGHT, roofMax);
-            const curtainMax = curtainOpeningResizeMax(n, scene.nodes(), 'y', 1);
-            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);
-        },
-        currentValue: (n) => n.height,
-        onDrag: (node) => publishOpeningResizeGuides(node, false),
-        apply: (initial, newHeight) => {
-            const bottom = initial.position[1] - initial.height / 2;
-            // Scale the handle so it tracks the door instead of staying glued to a
-            // fixed floor height (shared with the panel's Height slider).
-            return {
-                height: newHeight,
-                position: [initial.position[0], bottom + newHeight / 2, initial.position[2]],
-                handleHeight: scaleHandleHeight(initial.handleHeight, initial.height, newHeight),
-            };
-        },
-        placement: {
-            position: (n) => [0, n.height / 2 + HEIGHT_HANDLE_OFFSET, 0],
-        },
-        portal: 'grandparent',
-    };
-}
-// Press-drag move grip at the door centre, standing in the wall face. Routes
-// through the same move tool as the floating Move button (3D
-// `affordanceTools.move`, 2D `floorplanMoveTarget`) — wall slide + re-host onto
-// another wall — but `engageMoveDrag` commits on release, with no second click.
-function doorMoveHandle() {
-    return {
-        kind: 'tap-action',
-        shape: 'move-cross',
-        plane: 'node-normal',
-        portal: 'grandparent',
-        cursor: 'move',
-        onActivate: (node, _scene, editor) => editor.engageMoveDrag(node),
-        placement: {
-            position: () => [0, 0, MOVE_HANDLE_LIFT],
-        },
-    };
-}
-function doorRadiusHandle(index) {
-    const sign = index === 0 ? -1 : 1;
-    return {
-        kind: 'corner-radius',
-        corner: [sign, 1],
-        width: (node) => node.width,
-        height: (node) => node.height,
-        currentValue: (node) => node.openingRadiusMode === 'individual'
-            ? (node.openingTopRadii[index] ?? 0)
-            : node.cornerRadius,
-        max: (node) => Math.min(node.width / 2, node.height),
-        apply: (node, radius, _scene, modifiers) => {
-            if (!modifiers.shiftKey) {
-                return { openingShape: 'rounded', openingRadiusMode: 'all', cornerRadius: radius };
-            }
-            const radii = node.openingRadiusMode === 'individual'
-                ? [...node.openingTopRadii]
-                : [node.cornerRadius, node.cornerRadius];
-            radii[index] = radius;
-            return {
-                openingShape: 'rounded',
-                openingRadiusMode: 'individual',
-                openingTopRadii: radii,
-            };
-        },
-        createPreview: (node) => createOpeningPropertyPreview(node.id, openingPropertyPreviewHost),
-        visible: (node) => node.openingShape !== 'arch',
-        portal: 'grandparent',
-    };
-}
-const doorHandles = [
-    doorMoveHandle(),
-    doorWidthHandle('left'),
-    doorWidthHandle('right'),
-    doorHeightHandle(),
-    doorRadiusHandle(0),
-    doorRadiusHandle(1),
-];
-/**
- * Door — Phase 5 batch kind. Hosted on walls, cuts holes in them,
- * animated open/close state.
- *
- * Capabilities:
- *  - **No `movable`**: door's move is bespoke wall-bound drag (slide
- *    along the wall, snap to wall start/end). Capability-driven dispatch
- *    keeps legacy `MoveDoorTool`.
- *  - `selectable`, `duplicable`, `deletable` standard.
- *
- * Stages:
- *  - A: registered.
- *  - B: deferred — door geometry (frame / leaf / glass / hardware /
- *    segments) is ~800 lines in DoorSystem; extraction is a focused
- *    session. `def.renderer` (wrap-export of legacy DoorRenderer) +
- *    `def.system` (DoorSystem + DoorAnimationSystem bundle) hold parity.
- *  - C: `def.floorplan` polygon sits in parent wall's cutout. Legacy
- *    `openingPolygons` short-circuits door entries when registered.
- */
-export const doorDefinition = {
-    kind: 'door',
-    snapProfile: 'item',
-    facingIndicator: true,
-    schemaVersion: 2,
-    schema: DoorNode,
-    category: 'structure',
-    extensions: {
-        'pascal:editor/floorplan': {
-            contextualDimensions: buildDoorContextualDimensions,
-            schedule: buildDoorFloorplanSchedule,
-        },
-    },
-    surfaceRole: 'joinery',
-    // Leverage the schema's zod `.default()` annotations to compute the
-    // 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 { id: _id, type: _type, ...rest } = stub;
-        return rest;
-    },
-    capabilities: {
-        reveal: { phase: 'openings', style: 'cut' },
-        exterior: openingSeenFromOutside,
-        revealOnEdit: ['position', 'width', 'height', 'openingShape', 'openingKind', 'doorType'],
-        batchable: doorBatchable,
-        selectable: { hitVolume: 'bbox' },
-        duplicable: true,
-        deletable: true,
-        wallOpeningPlacement: true,
-        // Doors also host on roof-segment wall faces (base walls under the
-        // roof, gable ends). `buildCut` punches the opening into the
-        // segment's wall brush; `dirtyHandledByOwnSystem` keeps the roof-merge
-        // loop from consuming door dirty marks (DoorSystem owns them and
-        // already cascades to the host via parentId).
-        roofAccessory: {
-            buildCut: (node, hostSegment) => buildRoofWallOpeningCut(node, hostSegment),
-            cutScope: 'wall',
-            dirtyHandledByOwnSystem: true,
-        },
-        // `wallId` / `roofSegmentId` tie the door to its host and are
-        // re-derived from the surface under the cursor when a preset is
-        // placed. Host apps strip these at preset-save time via
-        // `getHostRefFields(def)`.
-        hostRefFields: ['wallId', 'roofSegmentId', 'roofFace'],
-        // Panel / glass slots painted through the registry. The door system tags
-        // each mesh with its `userData.slotId`; paint writes `node.slots`.
-        slots: () => doorSlots(),
-        paint: doorPaint,
-        mechanism: doorMechanism,
-    },
-    parametrics: doorParametrics,
-    handles: (node) => node.source
-        ? [doorMoveHandle(), ...scriptedOpeningHandles(node, doorWidthHandle, doorHeightHandle)]
-        : doorHandles,
-    rendersChildren: false,
-    renderer: {
-        kind: 'parametric',
-        module: () => import('./renderer.js'),
-    },
-    preview: () => import('./preview.js'),
-    system: {
-        module: () => import('./system.js'),
-        // Priority 3 mirrors the legacy DoorSystem (after animation at 2,
-        // before wall mitering at 4).
-        priority: 3,
-    },
-    // Stage C: floor-plan polygon. Needs ctx.parent (the wall) to compute
-    // direction + perpendicular for the cutout footprint.
-    floorplan: buildDoorFloorplan,
-    computeFloorplanLevelData: computeDoorFloorplanLevelData,
-    floorplanDependsOnSiblings: true,
-    // Opening symbols position from `ctx.parent` (the host wall); merge the
-    // walls' live drag overrides so the symbol tracks a wall / group drag in
-    // realtime instead of jumping on commit.
-    floorplanSiblingOverrides: wallFloorplanSiblingOverrides,
-    // Stage D — placement (`def.tool`) + move-on-wall (`def.
-    // affordanceTools.move`). Both ports of the legacy tools at
-    // `editor/components/tools/door/`, relocated into the kind folder and
-    // wired through ToolManager's registry-first dispatch (`def.tool` for
-    // build-mode placement, `getRegistryAffordanceTool` for the move-on-
-    // pick flow). Same legacy semantics: wall-event-driven snap, clamped
-    // wall-local coords, hasWallChildOverlap guard, live mesh updates.
-    tool: () => import('./tool.js'),
-    affordanceTools: {
-        move: () => import('./move-tool.js'),
-    },
-    // 2D move-on-floorplan handler. When `useEditor.movingNode` is a
-    // door and the floor plan is active, `FloorplanRegistryMoveOverlay`
-    // dispatches to this instead of the generic translate path — pointer
-    // snaps to the nearest wall, projects onto the wall axis, snaps
-    // local-X to 0.5m, clamps inside wall bounds.
-    floorplanMoveTarget: doorFloorplanMoveTarget,
-    // 2D drag affordances. `resize-width` drives the door's two side
-    // arrows — pointer-down on either arrow starts an anchored width drag
-    // (opposite edge stays fixed, clamped to wall bounds).
-    floorplanAffordances: {
-        'resize-width': doorWidthAffordance,
-    },
-    toolHints: [
-        { key: 'Left click', label: 'Place door on wall' },
-        ...DOOR_PLACEMENT_HINTS,
-        { key: 'R', label: 'Flip side' },
-        { key: 'Alt', label: 'Force place' },
-        { key: 'Esc', label: 'Cancel' },
-    ],
-    presentation: {
-        label: 'Door',
-        description: 'A door cut into a wall. Animated open/close state.',
-        icon: { kind: 'url', src: '/icons/door.webp' },
-        paletteSection: 'structure',
-        paletteOrder: 50,
-    },
-    mcp: {
-        description: 'A door mounted on a wall, with type / dimensions / hardware options.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { doorEditContribution } from './definition.edit.js';
+import { doorRenderDefinition } from './definition.render.js';
+export const doorDefinition = composeNodeDefinition(doorRenderDefinition, doorEditContribution);

package/dist/door/definition.render.d.ts

@@ -0,0 +1,6 @@
+import type { NodeRenderDefinition } from '../definition-contributions.js';
+import { DoorNode } from './schema.js';
+export declare const doorRenderDefinition: NodeRenderDefinition<typeof DoorNode> & {
+    kind: 'door';
+};
+//# sourceMappingURL=definition.render.d.ts.map

package/dist/door/definition.render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/door/definition.render.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAKvE,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAEnC,eAAO,MAAM,oBAAoB,EAAE,oBAAoB,CAAC,OAAO,QAAQ,CAAC,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAiFxF,CAAA"}

package/dist/door/definition.render.js

@@ -0,0 +1,88 @@
+import { doorSlots } from '@pascal-app/core';
+import { NEW_DOOR_FRAME_THICKNESS } from '@pascal-app/core/building';
+import { doorBatchable } from '../shared/node-batch/batchable.js';
+import { buildRoofWallOpeningCut } from '../shared/roof-wall-opening-cut.js';
+import { openingSeenFromOutside } from '../wall/exterior.js';
+import { doorMechanism } from './mechanism.js';
+import { DoorNode } from './schema.js';
+export const doorRenderDefinition = {
+    kind: 'door',
+    schemaVersion: 2,
+    schema: DoorNode,
+    category: 'structure',
+    surfaceRole: 'joinery',
+    // Leverage the schema's zod `.default()` annotations to compute the
+    // 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',
+            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',
+            'sidelightLeft',
+            'sidelightRight',
+            'transomHeight',
+            'openingShape',
+            'openingKind',
+            'doorType',
+        ],
+        batchable: doorBatchable,
+        selectable: { hitVolume: 'bbox' },
+        duplicable: true,
+        deletable: true,
+        wallOpeningPlacement: true,
+        // Doors also host on roof-segment wall faces (base walls under the
+        // roof, gable ends). `buildCut` punches the opening into the
+        // segment's wall brush; `dirtyHandledByOwnSystem` keeps the roof-merge
+        // loop from consuming door dirty marks (DoorSystem owns them and
+        // already cascades to the host via parentId).
+        roofAccessory: {
+            buildCut: (node, hostSegment) => buildRoofWallOpeningCut(node, hostSegment),
+            cutScope: 'wall',
+            dirtyHandledByOwnSystem: true,
+        },
+        // `wallId` / `roofSegmentId` tie the door to its host and are
+        // re-derived from the surface under the cursor when a preset is
+        // placed. Host apps strip these at preset-save time via
+        // `getHostRefFields(def)`.
+        hostRefFields: ['wallId', 'roofSegmentId', 'roofFace'],
+        // Panel / glass slots painted through the registry. The door system tags
+        // each mesh with its `userData.slotId`; paint writes `node.slots`.
+        slots: () => doorSlots(),
+        mechanism: doorMechanism,
+    },
+    rendersChildren: false,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer.js'),
+    },
+    system: {
+        module: () => import('./system.js'),
+        // Priority 3 mirrors the legacy DoorSystem (after animation at 2,
+        // before wall mitering at 4).
+        priority: 3,
+    },
+    presentation: {
+        label: 'Door',
+        description: 'A door cut into a wall. Animated open/close state.',
+        icon: { kind: 'url', src: '/icons/door.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 50,
+    },
+    mcp: {
+        description: 'A door mounted on a wall, with type / dimensions / hardware options.',
+    },
+};

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,CA+RjE,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';
@@ -60,6 +61,7 @@ export const doorFloorplanMoveTarget = ({ node }) => {
     // the cursor as a ghost (like the 3D move) and is NOT committable — a door
     // needs a wall. Starts true so a click before any move keeps the door put.
     let onWall = true;
+    let lastFits = true;
     // Alt force-place (last apply's modifier) — lets `canCommit` allow an
     // overlapping placement, matching the 3D move. Read in `canCommit` so an Alt-
     // held commit over a collision lands instead of reverting.
@@ -158,23 +160,38 @@ 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, fits, transomHeight } = clampToWall(hit.wall, snappedLocalX, node.width, node.height, {
+                ...node,
+                rotation: [0, hit.itemRotation + (flipped ? Math.PI : 0), 0],
+            }, nodes);
+            lastFits = fits;
             // 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 +204,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 +214,8 @@ export const doorFloorplanMoveTarget = ({ node }) => {
                 roofSegmentId: undefined,
                 roofFace: undefined,
                 visible: true,
+                ...casing,
+                ...(transomHeight === undefined ? {} : { transomHeight }),
             });
             useLiveTransforms.getState().set(nodeId, {
                 position: lastValid.position,
@@ -212,10 +233,14 @@ export const doorFloorplanMoveTarget = ({ node }) => {
             const live = useScene.getState().nodes[nodeId];
             if (live?.type !== 'door')
                 return false;
-            // 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);
+            // Block commit if the door does not fit under the wall's top or overlaps
+            // another wall child — UNLESS Alt force-places (same `placeable` rule as
+            // the 3D move + the shared `resolveOpeningPlacement`).
+            const collides = !lastFits ||
+                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"}