@pascal-app/nodes 1.0.7 → 1.1.1

package/dist/door/definition.js

@@ -1,341 +1,4 @@
-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';
-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) - (getDoorOpeningSize(n).width - n.width));
-        },
-        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) => [
-                -getDoorOpeningSize(n).leafOffsetX +
-                    sign * (getDoorOpeningSize(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 -
-                (getDoorOpeningSize(n).height - n.height));
-        },
-        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, getDoorOpeningSize(n).height - 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,
-            // Swap hinge / swing side from the action bar, in 2D and 3D.
-            actionMenu: { actions: () => import('./actions.js') },
-        },
-    },
-    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(),
-        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;AAOvE,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAEnC,eAAO,MAAM,oBAAoB,EAAE,oBAAoB,CAAC,OAAO,QAAQ,CAAC,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAqFxF,CAAA"}

package/dist/door/definition.render.js

@@ -0,0 +1,94 @@
+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 { computeDoorFloorplanLevelData } from '../shared/opening-documentation.js';
+import { buildRoofWallOpeningCut } from '../shared/roof-wall-opening-cut.js';
+import { openingSeenFromOutside } from '../wall/exterior.js';
+import { buildDoorFloorplan } from './floorplan.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,
+    },
+    // Stage C: floor-plan polygon. Needs ctx.parent (the wall) to compute
+    // direction + perpendicular for the cutout footprint.
+    floorplan: buildDoorFloorplan,
+    computeFloorplanLevelData: computeDoorFloorplanLevelData,
+    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-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,EAEb,KAAK,mBAAmB,EASzB,MAAM,kBAAkB,CAAA;AAqBzB;;;;;;;;;;;;;;GAcG;AAEH,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,QAAQ,CA2RjE,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

@@ -61,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.
@@ -178,10 +179,11 @@ export const doorFloorplanMoveTarget = ({ node }) => {
                 : 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, {
+            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);
@@ -231,13 +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] -
-                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);
+            // 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.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;AAezB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CA+1BjG"}
+{"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;AAiBzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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,4 @@
-import { getDoorOpeningSize, getWallBodyCenterOffset, openingHostFacing } from '@pascal-app/core';
-import { readFloorplanContext, readFloorplanGeometryMetadata, withFloorplanGeometryMetadata, } from '@pascal-app/editor';
+import { getDoorOpeningSize, getWallBodyCenterOffset, openingHostFacing, readFloorplanContext, readFloorplanGeometryMetadata, withFloorplanGeometryMetadata, } from '@pascal-app/core';
 import { buildOpeningCasingPlan } from '../shared/opening-casing.js';
 import { buildOpeningMarkAnnotation, } from '../shared/opening-documentation.js';
 import { buildOpeningPlacementDimensions } from '../shared/opening-placement-dimensions.js';

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,EAqBT,MAAM,kBAAkB,CAAA;AAqDzB,QAAA,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CA8mC9C,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

@@ -237,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;
@@ -268,16 +268,17 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
                 // component lives in `snapToHalf` (itself mode-aware).
                 applySnap: isMagneticSnapActive(),
             });
-            const { clampedX, clampedY, transomHeight } = clampToWall(event.node, localX +
+            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 = !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);
+            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,
@@ -291,6 +292,9 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
             };
         };
         const applyPreview = (target) => {
+            useLiveNodeOverrides
+                .getState()
+                .clearFields(movingDoorNode.id, ['position', 'rotation', 'roofFace']);
             if (target.transomHeight !== undefined)
                 useLiveNodeOverrides
                     .getState()
@@ -585,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;
@@ -602,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({
@@ -694,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],
@@ -715,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();
         };
@@ -790,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');
@@ -800,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();
@@ -809,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);
@@ -950,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) {