@pascal-app/nodes 1.0.3 → 1.0.5

package/dist/door/floorplan-move.js

@@ -1,9 +1,10 @@
 import { 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';
-import { getOpeningHostLevelId, getRoofHostedOpeningPlanPoint } from '../shared/roof-opening-host';
-import { findClosestWallInPlan, projectWallLocalPointToPlan, resolveOpeningPlacement, snapLocalXToNeighbors, } from '../shared/wall-attach-target';
-import { clampToWall, hasWallChildOverlap } from './door-math';
+import { createFloorplanCursorResolver } from '../shared/floorplan-cursor.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';
+import { clampToWall, hasWallChildOverlap } from './door-math.js';
 /**
  * 2D floor-plan move handler for door — kicks in when the user clicks
  * "Move" on the door inspector (or action menu) and the floor-plan
@@ -175,7 +176,8 @@ export const doorFloorplanMoveTarget = ({ node }) => {
             const side = flipped ? (hit.side === 'front' ? 'back' : 'front') : hit.side;
             const itemRotation = hit.itemRotation + (flipped ? Math.PI : 0);
             lastValid = {
-                position: [clampedX, clampedY, 0],
+                // Same-wall moves keep the wall-local plane offset; another host resets it.
+                position: [clampedX, clampedY, openingPlaneOffsetOnWall(node, hit.wall.id)],
                 rotation: [0, itemRotation, 0],
                 side,
                 parentId: hit.wall.id,

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;AAYzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAmvBjG"}
+{"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"}

package/dist/door/floorplan.js

@@ -1,6 +1,8 @@
+import { getWallBodyCenterOffset } from '@pascal-app/core';
 import { readFloorplanContext, readFloorplanGeometryMetadata, withFloorplanGeometryMetadata, } from '@pascal-app/editor';
-import { buildOpeningMarkAnnotation, } from '../shared/opening-documentation';
-import { buildOpeningPlacementDimensions } from '../shared/opening-placement-dimensions';
+import { buildOpeningMarkAnnotation, } from '../shared/opening-documentation.js';
+import { buildOpeningPlacementDimensions } from '../shared/opening-placement-dimensions.js';
+import { resolveOpeningPlanPlane } from '../shared/opening-plane-offset.js';
 /**
  * Stage C floor-plan builder for door. 1:1 visual port of the legacy
  * floorplan-panel door rendering:
@@ -52,9 +54,15 @@ export function buildDoorFloorplan(node, ctx) {
     const perpZ = dirX;
     const distance = node.position[0];
     const width = node.width;
-    const depth = wall.thickness ?? 0.1;
-    const cx = x1 + dirX * distance;
-    const cz = z1 + dirZ * distance;
+    const wallDepth = wall.thickness ?? 0.1;
+    const plane = resolveOpeningPlanPlane(node, wallDepth);
+    const depth = plane.depth;
+    // The plane offset is measured from the body centre, which a justified wall
+    // sets off its reference line.
+    const bodyOffset = getWallBodyCenterOffset(wall);
+    const across = bodyOffset + plane.offset;
+    const cx = x1 + dirX * distance + perpX * across;
+    const cz = z1 + dirZ * distance + perpZ * across;
     const halfWidth = width / 2;
     const halfDepth = depth / 2;
     const isPlanFlipped = isOpeningPlanFlipped(node.rotation);
@@ -79,6 +87,13 @@ export function buildDoorFloorplan(node, ctx) {
         [cx + dirX * halfWidth - perpX * halfDepth, cz + dirZ * halfWidth - perpZ * halfDepth],
         [cx - dirX * halfWidth - perpX * halfDepth, cz - dirZ * halfWidth - 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],
+    ];
     const view = ctx.viewState;
     const palette = view?.palette;
     const isSelected = view?.selected ?? false;
@@ -92,6 +107,21 @@ export function buildDoorFloorplan(node, ctx) {
     const accentMuted = accentColor;
     const fillColor = showSelectedChrome ? '#fed7aa' : '#ffffff';
     const children = [
+        // An offset frame stands clear of the wall centre, but the wall is still
+        // cut through its whole thickness: draw that hole too.
+        ...(plane.offset === 0
+            ? []
+            : [
+                {
+                    kind: 'polygon',
+                    points: openingCutoutPoints(x1 + dirX * distance + perpX * bodyOffset, z1 + dirZ * distance + perpZ * bodyOffset),
+                    fill: fillColor,
+                    stroke: accentMuted,
+                    strokeWidth: showSelectedChrome ? 2 : 1.25,
+                    vectorEffect: 'non-scaling-stroke',
+                    strokeLinejoin: 'round',
+                },
+            ]),
         // Background — the cutout is filled white so the swing arc sits on
         // a clean canvas (the wall hatch shows through otherwise).
         {
@@ -718,24 +748,27 @@ export function buildDoorFloorplan(node, ctx) {
         // direction). Pointer-down on either routes through the door's
         // `resize-width` affordance — anchored at the opposite edge, clamped
         // to wall bounds. Mirrors the 3D `DoorSideArrow` width drag.
-        const startEdgeX = cx - dirX * halfWidth;
-        const startEdgeZ = cz - dirZ * halfWidth;
-        const endEdgeX = cx + dirX * halfWidth;
-        const endEdgeZ = cz + dirZ * halfWidth;
-        children.push({
-            kind: 'move-arrow',
-            point: [startEdgeX, startEdgeZ],
-            angle: Math.atan2(-dirZ, -dirX),
-            affordance: 'resize-width',
-            payload: { side: 'start' },
-        });
-        children.push({
-            kind: 'move-arrow',
-            point: [endEdgeX, endEdgeZ],
-            angle: Math.atan2(dirZ, dirX),
-            affordance: 'resize-width',
-            payload: { side: 'end' },
-        });
+        // A scripted opening's width is its script's: its size arrows live in 3D, on its params.
+        if (!node.source) {
+            const startEdgeX = cx - dirX * halfWidth;
+            const startEdgeZ = cz - dirZ * halfWidth;
+            const endEdgeX = cx + dirX * halfWidth;
+            const endEdgeZ = cz + dirZ * halfWidth;
+            children.push({
+                kind: 'move-arrow',
+                point: [startEdgeX, startEdgeZ],
+                angle: Math.atan2(-dirZ, -dirX),
+                affordance: 'resize-width',
+                payload: { side: 'start' },
+            });
+            children.push({
+                kind: 'move-arrow',
+                point: [endEdgeX, endEdgeZ],
+                angle: Math.atan2(dirZ, dirX),
+                affordance: 'resize-width',
+                payload: { side: 'end' },
+            });
+        }
     }
     // Placement-measurement dimensions — distances to adjacent openings
     // (or wall ends) on each side. Only visible while actively moving
@@ -748,6 +781,7 @@ export function buildDoorFloorplan(node, ctx) {
     const markAnnotation = buildOpeningMarkAnnotation(node, wall, ctx.levelData, {
         preferredSide: swingSign === 1 ? -1 : 1,
         stroke: showSelectedChrome ? '#f97316' : '#334155',
+        drafting: readFloorplanContext(ctx).drafting,
     });
     if (markAnnotation)
         children.push(markAnnotation);

package/dist/door/index.d.ts

@@ -1,3 +1,3 @@
-export { doorDefinition } from './definition';
-export { DoorNode } from './schema';
+export { doorDefinition } from './definition.js';
+export { DoorNode } from './schema.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/door/index.js

@@ -1,2 +1,2 @@
-export { doorDefinition } from './definition';
-export { DoorNode } from './schema';
+export { doorDefinition } from './definition.js';
+export { DoorNode } from './schema.js';

package/dist/door/mechanism.d.ts

@@ -0,0 +1,4 @@
+import { type MechanismCapability } from '@pascal-app/core';
+/** A door's leaf: Play opens it and Stop closes it, without touching the saved open state. */
+export declare const doorMechanism: MechanismCapability;
+//# sourceMappingURL=mechanism.d.ts.map

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

@@ -0,0 +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"}

package/dist/door/mechanism.js

@@ -0,0 +1,24 @@
+import { isOperationDoorType } from '@pascal-app/core';
+import { closeDoorOpenState, getDisplayedDoorValue, openDoorOpenState } from '@pascal-app/editor';
+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 = {
+    verb: 'open',
+    icon: 'door',
+    has: (node) => node.type === 'door' &&
+        (node.source ? scriptedOpening.has(node) : node.openingKind !== 'opening'),
+    isOn: (node) => {
+        if (node.type !== 'door')
+            return false;
+        if (node.source)
+            return scriptedOpening.isOn(node);
+        return isOperationDoorType(node.doorType)
+            ? getDisplayedDoorValue(node.id, 'operationState', node.operationState) > 0
+            : getDisplayedDoorValue(node.id, 'swingAngle', node.swingAngle) > 0;
+    },
+    set: (node, on) => {
+        if (node.type === 'door' && node.source)
+            return scriptedOpening.set(node, on);
+        return (on ? openDoorOpenState : closeDoorOpenState)(node.id, { persist: false });
+    },
+};

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,EAEL,QAAQ,EAYT,MAAM,kBAAkB,CAAA;AAmDzB,QAAA,MAAM,YAAY,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,CAwhC9C,CAAA;AAED,eAAe,YAAY,CAAA"}
+{"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"}

package/dist/door/move-tool.js

@@ -1,19 +1,20 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import { DoorNode, emitter, holdHiddenWallPointerEvents, isCurvedWall, sceneRegistry, spatialGridManager, useLiveTransforms, useScene, } from '@pascal-app/core';
+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 { 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';
-import { clearOpeningGuides3D, publishOpeningGuidesForWallEvent, } from '../shared/opening-guides-runtime';
-import { beginOpeningMoveHistorySession } from '../shared/opening-move-history';
-import { isWallMeshHidden, shouldIgnoreWallEventForOpeningMove, } from '../shared/opening-move-wall-gate';
-import { getRoofWallOpeningCursorPose, resolveRoofWallOpeningTarget, } from '../shared/roof-wall-opening-placement';
-import { resolveOpeningPlacement } from '../shared/wall-attach-target';
-import { collectWallOpeningAlignmentCandidates, resolveWallSlideAlignment, } from '../shared/wall-opening-alignment';
-import { clampToWall, hasWallChildOverlap, wallLocalToWorld } from './door-math';
-import DoorPreview from './preview';
+import { commitOpeningMove } from '../shared/commit-opening-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';
+import { openingPlaneOffsetOnWall } from '../shared/opening-plane-offset.js';
+import { getRoofWallOpeningCursorPose, resolveRoofWallOpeningTarget, } from '../shared/roof-wall-opening-placement.js';
+import { resolveOpeningPlacement } from '../shared/wall-attach-target.js';
+import { collectWallOpeningAlignmentCandidates, resolveWallSlideAlignment, } from '../shared/wall-opening-alignment.js';
+import { clampToWall, hasWallChildOverlap, wallLocalToWorld } from './door-math.js';
+import DoorPreview from './preview.js';
 const edgeMaterial = new LineBasicNodeMaterial({
     color: 0xef_44_44,
     linewidth: 3,
@@ -63,6 +64,8 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
             ? movingDoorNode.metadata
             : {};
         const isNew = !!meta.isNew;
+        const endDraft = isNew ? null : beginSceneHistoryDraft(movingDoorNode.id, movingDoorNode);
+        const updateDraft = (data) => runSceneHistoryDraftWrite(() => useScene.getState().updateNode(movingDoorNode.id, data));
         const original = {
             position: [...movingDoorNode.position],
             rotation: [...movingDoorNode.rotation],
@@ -81,10 +84,12 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
             visible: movingDoorNode.visible,
         };
         if (!isNew) {
-            useScene.getState().updateNode(movingDoorNode.id, {
+            updateDraft({
                 metadata: { ...meta, isTransient: true },
             });
         }
+        // Same-wall moves keep the wall-local plane offset; another host resets it.
+        const planeOffsetOn = (wallId) => openingPlaneOffsetOnWall(movingDoorNode, wallId);
         let currentHostId = movingDoorNode.parentId;
         let dragAnchor = null;
         // The wall the door was grabbed from. Nulled the first time the anchor
@@ -170,7 +175,7 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
             const id = getLevelId();
             return id ? (sceneRegistry.nodes.get(id)?.position.y ?? 0) : 0;
         };
-        const getSlabElevation = (wallEvent) => spatialGridManager.getSlabElevationForWall(wallEvent.node.parentId ?? '', wallEvent.node.start, wallEvent.node.end, wallEvent.node.curveOffset ?? 0, wallEvent.node.thickness, wallEvent.node.supportSlabId);
+        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 = () => {
             if (cursorGroupRef.current)
                 cursorGroupRef.current.visible = false;
@@ -196,7 +201,7 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
         const getPlacementOrientation = (event) => {
             const faceSide = getSideFromNormal(event.normal);
             const side = sideOverride ?? faceSide;
-            const rotationOffset = side !== faceSide ? Math.PI : 0;
+            const rotationOffset = side === faceSide ? 0 : Math.PI;
             return {
                 side,
                 itemRotation: calculateItemRotation(event.normal) + rotationOffset,
@@ -273,9 +278,24 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
             // the free-follow uses, so validity reads at a glance. The node position is
             // still written (so the wall cuts the hole at the right spot) but
             // `visible:false` keeps the pale solid mesh from competing with the ghost.
-            if (currentHostId !== target.wallId) {
-                useScene.getState().updateNode(movingDoorNode.id, {
-                    position: [target.clampedX, target.clampedY, 0],
+            if (currentHostId === target.wallId) {
+                const doorMesh = sceneRegistry.nodes.get(movingDoorNode.id);
+                if (doorMesh) {
+                    // Where the opening system will put it: the body centre plane of a
+                    // justified wall plus the opening's own plane offset, on the arc.
+                    const placement = getOpeningWallPlacement(target.wallNode, {
+                        ...movingDoorNode,
+                        position: [target.clampedX, target.clampedY, planeOffsetOn(target.wallId)],
+                        rotation: [0, target.itemRotation, 0],
+                    }, useScene.getState().nodes);
+                    doorMesh.position.set(...placement.position);
+                    doorMesh.rotation.set(...placement.rotation);
+                    doorMesh.updateMatrixWorld(true);
+                }
+            }
+            else {
+                updateDraft({
+                    position: [target.clampedX, target.clampedY, planeOffsetOn(target.wallId)],
                     rotation: [0, target.itemRotation, 0],
                     side: target.side,
                     parentId: target.wallId,
@@ -287,16 +307,8 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
                 markHostDirty(currentHostId);
                 currentHostId = target.wallId;
             }
-            else {
-                const doorMesh = sceneRegistry.nodes.get(movingDoorNode.id);
-                if (doorMesh) {
-                    doorMesh.position.set(target.clampedX, target.clampedY, 0);
-                    doorMesh.rotation.set(0, target.itemRotation, 0);
-                    doorMesh.updateMatrixWorld(true);
-                }
-            }
             useLiveTransforms.getState().set(movingDoorNode.id, {
-                position: [target.clampedX, target.clampedY, 0],
+                position: [target.clampedX, target.clampedY, planeOffsetOn(target.wallId)],
                 rotation: target.itemRotation,
             });
             markHostDirtyThrottled(target.wallId);
@@ -317,7 +329,7 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
             // `-wallAngle + itemRotation` to face the same way as commit.
             // `cursorRotation` (the old symmetric-wireframe yaw) is π off here.
             const wallAngle = Math.atan2(target.wallNode.end[1] - target.wallNode.start[1], target.wallNode.end[0] - target.wallNode.start[0]);
-            const ghostWorldPos = wallLocalToWorld(target.wallNode, target.clampedX, target.clampedY, getLevelYOffset(), getSlabElevation(target.event));
+            const ghostWorldPos = wallLocalToWorld(target.wallNode, target.clampedX, target.clampedY, getLevelYOffset(), getSlabElevation(target.event), planeOffsetOn(target.wallId));
             const ghostYaw = target.itemRotation - wallAngle;
             setGhostPose({
                 position: ghostWorldPos,
@@ -414,13 +426,15 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
                 // Duplicate mode: delete the transient draft while history is still
                 // paused, then create the real node as the gesture's ONE tracked
                 // write — undo removes the new door entirely.
+                // Read before the delete: the copy joins the collections its draft is in.
+                const collectionIds = collectionIdsOf(useScene.getState().collections, movingDoorNode.id);
                 useScene.getState().deleteNode(movingDoorNode.id);
                 const cloned = structuredClone(movingDoorNode);
                 delete cloned.id;
                 cloned.metadata = stripPlacementMetadataFlags(cloned.metadata);
                 const node = DoorNode.parse({
                     ...cloned,
-                    position: [target.clampedX, target.clampedY, 0],
+                    position: [target.clampedX, target.clampedY, planeOffsetOn(target.wallId)],
                     rotation: [0, target.itemRotation, 0],
                     side: target.side,
                     wallId: target.wallId,
@@ -432,7 +446,9 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
                     visible: true,
                 });
                 history.commitStep(() => {
-                    useScene.getState().createNode(node, target.wallId);
+                    useScene
+                        .getState()
+                        .createNodes([{ node, parentId: target.wallId, collectionIds }]);
                 });
                 placedId = node.id;
             }
@@ -440,7 +456,7 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
                 // Move mode: restore the exact pre-drag state while history is still
                 // paused (the clean undo baseline), then apply the drop as the
                 // gesture's ONE tracked write — undo reverts to the original state.
-                useScene.getState().updateNode(movingDoorNode.id, {
+                updateDraft({
                     position: original.position,
                     rotation: original.rotation,
                     side: original.side,
@@ -453,7 +469,7 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
                 });
                 history.commitStep(() => {
                     commitOpeningMove(movingDoorNode.id, {
-                        position: [target.clampedX, target.clampedY, 0],
+                        position: [target.clampedX, target.clampedY, planeOffsetOn(target.wallId)],
                         rotation: [0, target.itemRotation, 0],
                         side: target.side,
                         parentId: target.wallId,
@@ -472,6 +488,7 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
             triggerSFX('sfx:structure-build');
             hideCursor();
             useViewer.getState().setSelection({ selectedIds: [placedId] });
+            endDraft?.();
             exitMoveMode();
         };
         const onWallClick = (event) => {
@@ -520,7 +537,7 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
             clearPlacementSurface();
             const live = useScene.getState().nodes[movingDoorNode.id];
             if (live && live.visible === false) {
-                useScene.getState().updateNode(movingDoorNode.id, { visible: true });
+                updateDraft({ visible: true });
             }
         };
         // Free-follow: over open floor there's no wall to host the door, so instead
@@ -547,28 +564,28 @@ 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) {
-                if (currentHostId && currentHostId !== levelId)
-                    markHostDirty(currentHostId);
-                useScene.getState().updateNode(movingDoorNode.id, {
+            if (currentHostId === levelId) {
+                updateDraft({
                     position: [localX, y, localZ],
                     rotation: [0, yaw, 0],
                     side: sideOverride,
-                    parentId: levelId ?? undefined,
-                    wallId: undefined,
-                    roofSegmentId: undefined,
-                    roofFace: undefined,
                     visible: false,
                 });
-                currentHostId = levelId;
             }
             else {
-                useScene.getState().updateNode(movingDoorNode.id, {
+                if (currentHostId && currentHostId !== levelId)
+                    markHostDirty(currentHostId);
+                updateDraft({
                     position: [localX, y, localZ],
                     rotation: [0, yaw, 0],
                     side: sideOverride,
+                    parentId: levelId ?? undefined,
+                    wallId: undefined,
+                    roofSegmentId: undefined,
+                    roofFace: undefined,
                     visible: false,
                 });
+                currentHostId = levelId;
             }
             // Float the red (invalid — no wall) ghost at the cursor, level-Y lifted so
             // it stands on the floor, matching the door's chosen facing (sideOverride
@@ -638,8 +655,15 @@ 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) {
-                useScene.getState().updateNode(movingDoorNode.id, {
+            if (currentHostId === target.segment.id) {
+                updateDraft({
+                    position: target.position,
+                    rotation: [0, 0, 0],
+                    roofFace: target.face.id,
+                });
+            }
+            else {
+                updateDraft({
                     position: target.position,
                     rotation: [0, 0, 0],
                     side: 'front',
@@ -652,13 +676,6 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
                 markHostDirty(currentHostId);
                 currentHostId = target.segment.id;
             }
-            else {
-                useScene.getState().updateNode(movingDoorNode.id, {
-                    position: target.position,
-                    rotation: [0, 0, 0],
-                    roofFace: target.face.id,
-                });
-            }
             updateRoofCursor(target, event.node);
             event.stopPropagation();
         };
@@ -677,6 +694,8 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
             if (isNew) {
                 // See commitToWall — delete the draft paused, create as the ONE
                 // tracked write.
+                // Read before the delete: the copy joins the collections its draft is in.
+                const collectionIds = collectionIdsOf(useScene.getState().collections, movingDoorNode.id);
                 useScene.getState().deleteNode(movingDoorNode.id);
                 const cloned = structuredClone(movingDoorNode);
                 delete cloned.id;
@@ -693,14 +712,16 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
                     visible: true,
                 });
                 history.commitStep(() => {
-                    useScene.getState().createNode(node, segmentId);
+                    useScene
+                        .getState()
+                        .createNodes([{ node, parentId: segmentId, collectionIds }]);
                 });
                 placedId = node.id;
             }
             else {
                 // See commitToWall — restore the pre-drag baseline paused, drop as
                 // the ONE tracked write.
-                useScene.getState().updateNode(movingDoorNode.id, {
+                updateDraft({
                     position: original.position,
                     rotation: original.rotation,
                     side: original.side,
@@ -733,6 +754,7 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
             triggerSFX('sfx:structure-build');
             hideCursor();
             useViewer.getState().setSelection({ selectedIds: [placedId] });
+            endDraft?.();
             exitMoveMode();
             event.stopPropagation();
         };
@@ -753,7 +775,7 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
                     markHostDirty(currentHostId);
             }
             else {
-                useScene.getState().updateNode(movingDoorNode.id, {
+                updateDraft({
                     position: original.position,
                     rotation: original.rotation,
                     side: original.side,
@@ -772,6 +794,7 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
             // entirely. `end` is idempotent — the effect cleanup's end() is a no-op.
             history.end();
             hideCursor();
+            endDraft?.();
             exitMoveMode();
         };
         const onPlacementDragPointerUp = (event) => {
@@ -829,7 +852,7 @@ 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.
-                useScene.getState().updateNode(movingDoorNode.id, {
+                updateDraft({
                     side: sideOverride,
                     rotation: [0, sideOverride === 'back' ? Math.PI : 0, 0],
                 });
@@ -873,7 +896,7 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
             if (hostWall?.type === 'wall') {
                 const wallAngle = Math.atan2(hostWall.end[1] - hostWall.start[1], hostWall.end[0] - hostWall.start[0]);
                 const ghostYaw = movingDoorNode.rotation[1] - wallAngle;
-                const seedPos = wallLocalToWorld(hostWall, movingDoorNode.position[0], movingDoorNode.position[1], getLevelYOffset(), spatialGridManager.getSlabElevationForWall(hostWall.parentId ?? '', hostWall.start, hostWall.end, hostWall.curveOffset ?? 0, hostWall.thickness, hostWall.supportSlabId));
+                const seedPos = wallLocalToWorld(hostWall, movingDoorNode.position[0], movingDoorNode.position[1], getLevelYOffset(), spatialGridManager.getSlabElevationForWall(hostWall.parentId ?? '', hostWall.start, hostWall.end, hostWall.curveOffset ?? 0, hostWall.thickness, hostWall.supportSlabId, hostWall.justification), planeOffsetOn(hostWall.id));
                 publishPlacementSurface(new Vector3(...seedPos), new Vector3(Math.sin(ghostYaw), 0, Math.cos(ghostYaw)));
                 // Claim the pointer for the wall so the floor free-follow stands down for
                 // the first frames after grab. Otherwise the first `grid:move` (the door
@@ -893,7 +916,7 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
                         markHostDirty(currentHostId);
                 }
                 else {
-                    useScene.getState().updateNode(movingDoorNode.id, {
+                    updateDraft({
                         position: original.position,
                         rotation: original.rotation,
                         side: original.side,
@@ -914,7 +937,7 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
                 // hidden — reveal it so it never becomes an invisible orphan. (The
                 // `place-preset` movingNode subscription deletes a truly-cancelled
                 // clone separately.)
-                useScene.getState().updateNode(movingDoorNode.id, { visible: true });
+                updateDraft({ visible: true });
             }
             useLiveTransforms.getState().clear(movingDoorNode.id);
             useAlignmentGuides.getState().clear();
@@ -923,6 +946,7 @@ const MoveDoorTool = ({ node: movingDoorNode }) => {
             clearPlacementSurface();
             releaseHiddenWallHold();
             history.end();
+            endDraft?.();
             emitter.off('wall:enter', onWallEnter);
             emitter.off('wall:move', onWallMove);
             emitter.off('wall:click', onWallClick);

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,4CAGpB,CAAA"}
+{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/door/paint.ts"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,eAAO,MAAM,SAAS,4CAOpB,CAAA"}

package/dist/door/paint.js

@@ -1,4 +1,4 @@
-import { createSlotPaintCapability, previewSlotByUserData, resolveSlotByReRaycast, } from '../shared/slot-paint';
+import { createSlotPaintCapability, previewSlotByUserData, resolveSlotByReRaycast, } from '../shared/slot-paint.js';
 /**
  * Door paint on the unified slot model. The door's opening proxy (a proud,
  * invisible cutout) wins the shared scene raycast over the wall in front of the
@@ -8,4 +8,7 @@ import { createSlotPaintCapability, previewSlotByUserData, resolveSlotByReRaycas
 export const doorPaint = createSlotPaintCapability({
     resolveRole: resolveSlotByReRaycast,
     applyPreview: previewSlotByUserData,
+    legacyEffective: (node, role) => node.type === 'door' && !node.source && node.material && (role === 'panel' || role === 'frame')
+        ? { material: node.material, materialPreset: undefined }
+        : null,
 });

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

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