@pascal-app/nodes 0.1.1 → 1.0.0-beta.2

package/dist/door/tool.js

@@ -1,6 +1,6 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import { DoorNode, emitter, isCurvedWall, sceneRegistry, spatialGridManager, useScene, } from '@pascal-app/core';
-import { calculateCursorRotation, calculateItemRotation, EDITOR_LAYER, getSideFromNormal, isMagneticSnapActive, isValidWallSideFace, triggerSFX, useAlignmentGuides, useEditor, useFacingPose, } from '@pascal-app/editor';
+import { DoorNode, emitter, isCurvedWall, sceneRegistry, spatialGridManager, useScene, WallNode as WallNodeSchema, } from '@pascal-app/core';
+import { calculateCursorRotation, calculateItemRotation, EDITOR_LAYER, getSideFromNormal, isMagneticSnapActive, isValidWallSideFace, triggerSFX, useAlignmentGuides, useEditor, useFacingPose, usePlacementPreview, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useEffect, useMemo, useRef, useState } from 'react';
 import { BoxGeometry, EdgesGeometry, Vector3 } from 'three';
@@ -53,6 +53,36 @@ const DoorTool = () => {
     const frameDepthRef = useRef(ghostStub.frameDepth);
     useEffect(() => {
         useScene.temporal.getState().pause();
+        const ownedPreviewIds = new Set();
+        const fallbackPreview = DoorNode.parse({
+            position: [0, 0, 0],
+            rotation: [0, 0, 0],
+            side: 'front',
+        });
+        const fallbackWallId = WallNodeSchema.parse({
+            end: [1, 0],
+            start: [0, 0],
+            thickness: 0.1,
+        }).id;
+        const publishPlacementPreview = (node, parentNode) => {
+            ownedPreviewIds.add(node.id);
+            usePlacementPreview.getState().set(node, parentNode);
+        };
+        const clearPlacementPreview = () => {
+            const current = usePlacementPreview.getState().node;
+            if (current && ownedPreviewIds.has(current.id))
+                usePlacementPreview.getState().clear();
+        };
+        const publishDraftPreview = (parentNode) => {
+            const draft = draftRef.current;
+            if (!draft)
+                return;
+            const live = useScene.getState().nodes[draft.id];
+            if (live?.type !== 'door')
+                return;
+            draftRef.current = live;
+            publishPlacementPreview(live, parentNode);
+        };
         let hostKind = null;
         // timeStamp of the most recent wall/roof mesh event. A wall/roof hover and
         // the grid raycast from the SAME pointermove share the source DOM event's
@@ -74,16 +104,20 @@ const DoorTool = () => {
             const id = getLevelId();
             return id ? (sceneRegistry.nodes.get(id)?.position.y ?? 0) : 0;
         };
-        const getSlabElevationForWall = (wall) => spatialGridManager.getSlabElevationForWall(wall.parentId ?? '', wall.start, wall.end);
+        const getSlabElevationForWall = (wall) => spatialGridManager.getSlabElevationForWall(wall.parentId ?? '', wall.start, wall.end, wall.curveOffset ?? 0, wall.thickness, wall.supportSlabId);
         const markHostDirty = (hostId) => {
             useScene.getState().dirtyNodes.add(hostId);
         };
         const destroyDraft = () => {
-            if (!draftRef.current)
+            const draft = draftRef.current;
+            if (!draft) {
+                clearPlacementPreview();
                 return;
-            const wallId = draftRef.current.parentId;
-            useScene.getState().deleteNode(draftRef.current.id);
+            }
+            const wallId = draft.parentId;
+            useScene.getState().deleteNode(draft.id);
             draftRef.current = null;
+            clearPlacementPreview();
             if (wallId)
                 markHostDirty(wallId);
         };
@@ -94,6 +128,7 @@ const DoorTool = () => {
             clearOpeningGuides3D();
             setFallbackPose(null);
             useFacingPose.getState().clear();
+            clearPlacementPreview();
         };
         // Alignment candidates — anchors of every alignable object; refreshed
         // after each placement. A door aligns by the plan position of its centre.
@@ -131,6 +166,23 @@ const DoorTool = () => {
                 rotationY: sideFlip ? Math.PI : 0,
                 side: sideFlip ? 'back' : 'front',
             });
+            const halfWidth = fallbackPreview.width / 2 + 0.5;
+            const wall = WallNodeSchema.parse({
+                end: [position[0] + halfWidth, position[2]],
+                id: fallbackWallId,
+                start: [position[0] - halfWidth, position[2]],
+                thickness: 0.1,
+            });
+            const ghost = DoorNode.parse({
+                ...fallbackPreview,
+                metadata: { isTransient: true },
+                parentId: wall.id,
+                position: [halfWidth, fallbackPreview.height / 2, 0],
+                rotation: [0, sideFlip ? Math.PI : 0, 0],
+                side: sideFlip ? 'back' : 'front',
+                wallId: wall.id,
+            });
+            publishPlacementPreview(ghost, wall);
             useAlignmentGuides.getState().clear();
             clearOpeningGuides3D();
             // Off-host (invalid) floating ghost — no direction triangle.
@@ -202,6 +254,7 @@ const DoorTool = () => {
                     roofFace: undefined,
                 });
             }
+            publishDraftPreview(wall);
             updateCursor(wallLocalToWorld(wall, clampedX, clampedY, getLevelYOffset(), getSlabElevationForWall(wall)), cursorRotationY, valid, -clampedY);
             if (draftRef.current) {
                 publishOpeningGuidesForWallEvent({
@@ -224,6 +277,7 @@ const DoorTool = () => {
             const draft = draftRef.current;
             if (!draft)
                 return;
+            clearPlacementPreview();
             draftRef.current = null;
             hostKind = null;
             useScene.getState().deleteNode(draft.id);
@@ -404,6 +458,7 @@ const DoorTool = () => {
                 useScene.getState().createNode(node, segment.id);
                 draftRef.current = node;
             }
+            publishDraftPreview(segment);
             // Opening guides are wall-specific; clear them while over a roof face.
             clearOpeningGuides3D();
             updateRoofCursor(target, event.node);
@@ -420,6 +475,7 @@ const DoorTool = () => {
                 return;
             const { segment, face, position } = target;
             const draft = draftRef.current;
+            clearPlacementPreview();
             draftRef.current = null;
             hostKind = null;
             useScene.getState().deleteNode(draft.id);
@@ -524,6 +580,7 @@ const DoorTool = () => {
         return () => {
             destroyDraft();
             hideCursor();
+            clearPlacementPreview();
             useAlignmentGuides.getState().clear();
             clearOpeningGuides3D();
             useScene.temporal.getState().resume();

package/dist/dormer/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/dormer/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAKzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAmarC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CAuE9D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/dormer/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAKzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAmarC;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CAwE9D,CAAA"}

package/dist/dormer/definition.js

@@ -472,6 +472,7 @@ export const dormerDefinition = {
         kind: 'parametric',
         module: () => import('./renderer'),
     },
+    preview: () => import('./preview'),
     tool: () => import('./tool'),
     toolHints: [
         { key: 'Left click', label: 'Place dormer on roof' },

package/dist/dormer/tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/dormer/tool.tsx"],"names":[],"mappings":"AA6BA;;;;;;;GAOG;AACH,QAAA,MAAM,UAAU,mCA8Df,CAAA;AAED,eAAe,UAAU,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/dormer/tool.tsx"],"names":[],"mappings":"AA8BA;;;;;;;GAOG;AACH,QAAA,MAAM,UAAU,mCAyFf,CAAA;AAED,eAAe,UAAU,CAAA"}

package/dist/dormer/tool.js

@@ -1,8 +1,9 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { DormerNode, useScene } from '@pascal-app/core';
+import { usePlacementPreview } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
-import { useMemo } from 'react';
+import { useEffect, useMemo } from 'react';
 import { RoofAttachmentFallbackPreview } from '../shared/roof-attachment-fallback-preview';
 import { dormerDefinition } from './definition';
 import { DormerPlacementGuides } from './placement-guides';
@@ -62,8 +63,29 @@ const DormerTool = () => {
             state.createNode(dormer, hit.segment.id);
             state.dirtyNodes.add(hit.segment.id);
             setSelection({ selectedIds: [dormer.id] });
+            usePlacementPreview.getState().clear();
         },
     });
+    useEffect(() => {
+        const placementPreview = usePlacementPreview.getState();
+        if (!(hitSegment && hitLocal)) {
+            if (placementPreview.node?.id === previewNode.id)
+                placementPreview.clear();
+            return;
+        }
+        placementPreview.set(DormerNode.parse({
+            ...previewNode,
+            parentId: hitSegment.id,
+            position: hitLocal,
+            roofSegmentId: hitSegment.id,
+            rotation: ghostRotation,
+        }), hitSegment);
+    }, [ghostRotation, hitLocal, hitSegment, previewNode]);
+    useEffect(() => () => {
+        const placementPreview = usePlacementPreview.getState();
+        if (placementPreview.node?.id === previewNode.id)
+            placementPreview.clear();
+    }, [previewNode.id]);
     return (_jsxs(_Fragment, { children: [_jsx(RoofAttachmentFallbackPreview, { activeBuildingId: activeBuildingId, ghost: _jsx(DormerPreview, { node: previewNode, invalid: true }), onInvalidTarget: clearPreview }), activeBuildingId && segmentXform && hitLocal && (_jsxs("group", { position: segmentXform.position, quaternion: segmentXform.quaternion, children: [hitSegment && (_jsx(DormerPlacementGuides, { center: hitLocal, depth: previewNode.depth, rotation: ghostRotation, segment: hitSegment, width: previewNode.width })), _jsx("group", { position: hitLocal, children: _jsx("group", { "rotation-y": ghostRotation, children: _jsx(DormerPreview, { node: previewNode }) }) })] }))] }));
 };
 export default DormerTool;

package/dist/duct-segment/tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/duct-segment/tool.tsx"],"names":[],"mappings":"AA8eA,QAAA,MAAM,eAAe,0CA0jBpB,CAAA;AAmJD,eAAe,eAAe,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/duct-segment/tool.tsx"],"names":[],"mappings":"AAgfA,QAAA,MAAM,eAAe,0CAukBpB,CAAA;AAmJD,eAAe,eAAe,CAAA"}

package/dist/duct-segment/tool.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
-import { DuctSegmentNode, emitter, getCeilingAt, getCeilingHeightAt, useScene, } from '@pascal-app/core';
-import { CursorSphere, DimensionPill, EDITOR_LAYER, isAngleSnapActive, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { DuctSegmentNode, emitter, getCeilingAt, getCeilingHeightAt, resolveCeilingHeight, useScene, } from '@pascal-app/core';
+import { CursorSphere, DimensionPill, EDITOR_LAYER, isAngleSnapActive, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, triggerSFX, useEditor, usePathDraftPreview, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Html } from '@react-three/drei';
 import { useEffect, useMemo, useRef, useState } from 'react';
@@ -436,6 +436,23 @@ const DuctSegmentTool = () => {
     // Latest mouse clientY from grid:move; used so the Alt anchor knows where
     // the cursor was at key-press time.
     const lastClientYRef = useRef(null);
+    const ghostFittings = useMemo(() => {
+        const last = draftPoints.at(-1);
+        if (!(activeLevelId && last && cursorPos) || altActive)
+            return [];
+        const fittings = planDuctDraw(last, cursorPos, startPortRef.current, startBodyRef.current, endSnap.port, endSnap.body, profile)?.fittings ?? [];
+        return fittings.map((fitting, index) => ({
+            ...fitting,
+            id: `duct-fitting_live-draft-${index}`,
+            parentId: activeLevelId,
+        }));
+    }, [activeLevelId, altActive, cursorPos, draftPoints, endSnap, profile]);
+    useEffect(() => {
+        usePathDraftPreview
+            .getState()
+            .setDraft('duct-segment', draftPoints, cursorPos, profile, ghostFittings);
+    }, [cursorPos, draftPoints, ghostFittings, profile]);
+    useEffect(() => () => usePathDraftPreview.getState().clear('duct-segment'), []);
     useEffect(() => {
         if (!activeLevelId)
             return;
@@ -787,12 +804,6 @@ const DuctSegmentTool = () => {
     if (last && cursorPos) {
         previewSegments.push({ a: last, b: cursorPos });
     }
-    // Ghost the auto-inserted fittings (elbow / tee / cross) the next click
-    // will mint, by running the SAME planner the commit uses against the
-    // in-flight endpoints. Skipped in Alt-vertical mode (no XZ tap there).
-    const ghostFittings = last && cursorPos && !altActive
-        ? (planDuctDraw(last, cursorPos, startPortRef.current, startBodyRef.current, endSnap.port, endSnap.body, profile)?.fittings ?? [])
-        : [];
     // Wall-style dimension pill above the cursor: absolute world coords before
     // the first point, signed per-axis deltas from the last placed point while
     // a segment is in flight. The actively-driven axis is emphasised — Y in
@@ -885,7 +896,7 @@ function CeilingHighlight({ ceiling }) {
     }, [ceiling.polygon]);
     if (!geometry)
         return null;
-    const y = ceiling.height ?? 2.5;
+    const y = resolveCeilingHeight(ceiling, useScene.getState().nodes);
     return (_jsxs("group", { position: [0, y, 0], children: [_jsx("mesh", { geometry: geometry, layers: EDITOR_LAYER, renderOrder: 1, children: _jsx("meshBasicMaterial", { color: "#818cf8", depthWrite: false, opacity: 0.15, side: DoubleSide, transparent: true }) }), outline && (_jsxs("line", { children: [_jsx("bufferGeometry", { ref: (g) => {
                             if (g)
                                 g.setFromPoints(outline);

package/dist/duct-terminal/tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/duct-terminal/tool.tsx"],"names":[],"mappings":"AA4IA;;;;;;;;;GASG;AACH,QAAA,MAAM,gBAAgB,0CAuSrB,CAAA;AAED,eAAe,gBAAgB,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/duct-terminal/tool.tsx"],"names":[],"mappings":"AA6IA;;;;;;;;;GASG;AACH,QAAA,MAAM,gBAAgB,0CAwSrB,CAAA;AAED,eAAe,gBAAgB,CAAA"}

package/dist/duct-terminal/tool.js

@@ -1,6 +1,6 @@
 'use client';
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import { DuctTerminalNode, emitter, pointInPolygon, resolveLevelId, sceneRegistry, useScene, } from '@pascal-app/core';
+import { DuctTerminalNode, emitter, pointInPolygon, resolveCeilingHeight, resolveLevelId, resolveSupportSlabPatch, sceneRegistry, useScene, } from '@pascal-app/core';
 import { CursorSphere, getFloorStackPreviewPosition, isGridSnapActive, isMagneticSnapActive, triggerSFX, useEditor, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Html } from '@react-three/drei';
@@ -16,8 +16,6 @@ import { COLLAR_LENGTH, mountQuaternion } from './ports';
 const PREVIEW_OPACITY = 0.55;
 /** R/T yaw step — 45°. */
 const ROTATE_STEP_RAD = Math.PI / 4;
-/** Fallback height (meters) for a ceiling node that carries no `height`. */
-const DEFAULT_CEILING_HEIGHT = 2.5;
 /** Snap radius (meters) for mating the collar onto a nearby duct port. */
 const PORT_SNAP_RADIUS_M = 0.5;
 const MOUNT_CYCLE = ['floor', 'ceiling', 'wall'];
@@ -177,7 +175,7 @@ const DuctTerminalTool = () => {
                 if (resolveLevelId(node, nodes) !== activeLevelId)
                     continue;
                 const ceiling = node;
-                const height = ceiling.height ?? DEFAULT_CEILING_HEIGHT;
+                const height = resolveCeilingHeight(ceiling, nodes);
                 const hit = hitLocalPlane(nativeEvent, height);
                 if (!hit)
                     continue;
@@ -239,9 +237,14 @@ const DuctTerminalTool = () => {
                 mount: p.mount,
                 position: p.position,
                 rotation: p.yaw,
+                parentId: activeLevelId,
             });
-            useScene.getState().createNode(terminal, activeLevelId);
-            useViewer.getState().setSelection({ selectedIds: [terminal.id] });
+            const committedTerminal = DuctTerminalNode.parse({
+                ...terminal,
+                ...resolveSupportSlabPatch(terminal, useScene.getState().nodes),
+            });
+            useScene.getState().createNode(committedTerminal, activeLevelId);
+            useViewer.getState().setSelection({ selectedIds: [committedTerminal.id] });
             triggerSFX('sfx:item-place');
         };
         // ---- Floor / ceiling: own raycast against a horizontal plane ----

package/dist/elevator/floorplan-affordances.d.ts

@@ -4,18 +4,14 @@ import { type ElevatorNode, type FloorplanAffordance } from '@pascal-app/core';
  * `linear-resize` handles declared in `definition.ts` — `anchor: 'center'`
  * means dragging outward on either +X or -X edge grows `width` by 2×
  * the elevator-local cursor offset while `position` stays put. Same for
- * +Z / -Z and `depth`. Writes directly to scene each tick (door pattern);
- * the registry dispatcher snapshots / pauses history at start so the
- * per-tick writes collapse into one undoable entry on commit.
+ * +Z / -Z and `depth`.
  */
 export declare const elevatorResizeAffordance: FloorplanAffordance<ElevatorNode>;
 /**
  * Elevator rotation drag (floor-plan). Sister to the 3D `arc-resize`
  * handle declared in `definition.ts`. Same `- delta` sign convention as
  * the 3D path so dragging the cursor in the same direction in both views
- * produces the same rotation. Writes directly to scene during the drag;
- * the registry dispatcher captures a snapshot first and re-applies the
- * single tracked update on pointer-up.
+ * produces the same rotation.
  */
 export declare const elevatorRotateAffordance: FloorplanAffordance<ElevatorNode>;
 //# sourceMappingURL=floorplan-affordances.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/elevator/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,mBAAmB,EAEzB,MAAM,kBAAkB,CAAA;AAOzB;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB,EAAE,mBAAmB,CAAC,YAAY,CA4CtE,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB,EAAE,mBAAmB,CAAC,YAAY,CA8BtE,CAAA"}
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/elevator/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,mBAAmB,EAGzB,MAAM,kBAAkB,CAAA;AAQzB;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,EAAE,mBAAmB,CAAC,YAAY,CA8CtE,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,EAAE,mBAAmB,CAAC,YAAY,CAgCtE,CAAA"}

package/dist/elevator/floorplan-affordances.js

@@ -1,4 +1,5 @@
-import { useScene, } from '@pascal-app/core';
+import { useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { isAngleSnapActive } from '@pascal-app/editor';
 import { rotateAffordanceDelta } from '../shared/rotate-affordance';
 const MIN_ELEVATOR_DIM = 0.6;
 /**
@@ -6,9 +7,7 @@ const MIN_ELEVATOR_DIM = 0.6;
  * `linear-resize` handles declared in `definition.ts` — `anchor: 'center'`
  * means dragging outward on either +X or -X edge grows `width` by 2×
  * the elevator-local cursor offset while `position` stays put. Same for
- * +Z / -Z and `depth`. Writes directly to scene each tick (door pattern);
- * the registry dispatcher snapshots / pauses history at start so the
- * per-tick writes collapse into one undoable entry on commit.
+ * +Z / -Z and `depth`.
  */
 export const elevatorResizeAffordance = {
     start({ node, payload, initialPlanPoint }) {
@@ -39,14 +38,16 @@ export const elevatorResizeAffordance = {
                 const delta = (currentLocal - initialLocal) * side;
                 const newValue = Math.max(MIN_ELEVATOR_DIM, initialValue + 2 * delta);
                 lastValue = newValue;
-                useScene
+                useLiveNodeOverrides
                     .getState()
-                    .updateNode(elevatorId, axis === 'x' ? { width: newValue } : { depth: newValue });
+                    .set(elevatorId, axis === 'x' ? { width: newValue } : { depth: newValue });
+                useScene.getState().markDirty(elevatorId);
             },
             canCommit() {
                 return true;
             },
             commit() {
+                useLiveNodeOverrides.getState().clear(elevatorId);
                 useScene
                     .getState()
                     .updateNode(elevatorId, axis === 'x' ? { width: lastValue } : { depth: lastValue });
@@ -58,9 +59,7 @@ export const elevatorResizeAffordance = {
  * Elevator rotation drag (floor-plan). Sister to the 3D `arc-resize`
  * handle declared in `definition.ts`. Same `- delta` sign convention as
  * the 3D path so dragging the cursor in the same direction in both views
- * produces the same rotation. Writes directly to scene during the drag;
- * the registry dispatcher captures a snapshot first and re-applies the
- * single tracked update on pointer-up.
+ * produces the same rotation.
  */
 export const elevatorRotateAffordance = {
     start({ node, initialPlanPoint }) {
@@ -72,21 +71,23 @@ export const elevatorRotateAffordance = {
         let lastRotation = initialRotation;
         return {
             affectedIds: [elevatorId],
-            apply({ planPoint, modifiers }) {
+            apply({ planPoint }) {
                 const delta = rotateAffordanceDelta({
                     center: [cx, cz],
                     initialAngle,
                     planPoint,
-                    free: modifiers.shiftKey,
+                    free: !isAngleSnapActive(),
                 });
                 const newRotation = initialRotation - delta;
                 lastRotation = newRotation;
-                useScene.getState().updateNode(elevatorId, { rotation: newRotation });
+                useLiveNodeOverrides.getState().set(elevatorId, { rotation: newRotation });
+                useScene.getState().markDirty(elevatorId);
             },
             canCommit() {
                 return true;
             },
             commit() {
+                useLiveNodeOverrides.getState().clear(elevatorId);
                 useScene.getState().updateNode(elevatorId, { rotation: lastRotation });
             },
         };

package/dist/fence/actions/move-endpoint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"move-endpoint.d.ts","sourceRoot":"","sources":["../../../src/fence/actions/move-endpoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,eAAe,EAEpB,KAAK,SAAS,EAEd,KAAK,UAAU,EACf,KAAK,SAAS,EAGd,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EACL,KAAK,cAAc,EAOpB,MAAM,oBAAoB,CAAA;AA2C3B,KAAK,mBAAmB,GAAG;IACzB,EAAE,EAAE,SAAS,CAAC,IAAI,CAAC,CAAA;IACnB,KAAK,EAAE,cAAc,CAAA;IACrB,GAAG,EAAE,cAAc,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC,OAAO,EAAE,SAAS,CAAA;IAClB,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAA;IACzB,aAAa,EAAE,cAAc,CAAA;IAC7B,WAAW,EAAE,cAAc,CAAA;IAC3B,mBAAmB,EAAE,cAAc,CAAA;IACnC,UAAU,EAAE,cAAc,CAAA;IAC1B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,eAAe,EAAE,mBAAmB,EAAE,CAAA;IACtC,UAAU,EAAE,QAAQ,EAAE,CAAA;IACtB,WAAW,EAAE,SAAS,EAAE,CAAA;IACxB;4DACwD;IACxD,eAAe,EAAE,eAAe,EAAE,CAAA;CACnC,CAAA;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,WAAW,EAAE,cAAc,CAAA;IAC3B,KAAK,EAAE,cAAc,CAAA;IACrB,GAAG,EAAE,cAAc,CAAA;IACnB,aAAa,EAAE,mBAAmB,EAAE,CAAA;IACpC,QAAQ,EAAE,OAAO,CAAA;CAClB,CAAA;AAmCD,eAAO,MAAM,2BAA2B,EAAE,UAAU,CAAC,oBAAoB,EAAE,sBAAsB,CAkJ9F,CAAA"}
+{"version":3,"file":"move-endpoint.d.ts","sourceRoot":"","sources":["../../../src/fence/actions/move-endpoint.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,eAAe,EAEpB,KAAK,SAAS,EAEd,KAAK,UAAU,EACf,KAAK,SAAS,EAId,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EACL,KAAK,cAAc,EAOpB,MAAM,oBAAoB,CAAA;AA2C3B,KAAK,mBAAmB,GAAG;IACzB,EAAE,EAAE,SAAS,CAAC,IAAI,CAAC,CAAA;IACnB,KAAK,EAAE,cAAc,CAAA;IACrB,GAAG,EAAE,cAAc,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,oBAAoB,GAAG;IACjC,OAAO,EAAE,SAAS,CAAA;IAClB,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAA;IACzB,aAAa,EAAE,cAAc,CAAA;IAC7B,WAAW,EAAE,cAAc,CAAA;IAC3B,mBAAmB,EAAE,cAAc,CAAA;IACnC,UAAU,EAAE,cAAc,CAAA;IAC1B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAA;IACvB,eAAe,EAAE,mBAAmB,EAAE,CAAA;IACtC,UAAU,EAAE,QAAQ,EAAE,CAAA;IACtB,WAAW,EAAE,SAAS,EAAE,CAAA;IACxB;4DACwD;IACxD,eAAe,EAAE,eAAe,EAAE,CAAA;CACnC,CAAA;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,WAAW,EAAE,cAAc,CAAA;IAC3B,KAAK,EAAE,cAAc,CAAA;IACrB,GAAG,EAAE,cAAc,CAAA;IACnB,aAAa,EAAE,mBAAmB,EAAE,CAAA;IACpC,QAAQ,EAAE,OAAO,CAAA;CAClB,CAAA;AAuDD,eAAO,MAAM,2BAA2B,EAAE,UAAU,CAAC,oBAAoB,EAAE,sBAAsB,CA6J9F,CAAA"}

package/dist/fence/actions/move-endpoint.js

@@ -1,4 +1,4 @@
-import { collectAlignmentAnchors, resolveAlignment, useScene, } from '@pascal-app/core';
+import { collectAlignmentAnchors, resolveAlignment, resolveFenceSupportSlabPatch, useScene, } from '@pascal-app/core';
 import { isAlignmentGuideActive, isAngleSnapActive, isMagneticSnapActive, isSegmentLongEnough, snapFenceDraftPoint, useAlignmentGuides, } from '@pascal-app/editor';
 /**
  * Phase 5 Stage D — move-fence-endpoint drag affordance.
@@ -55,6 +55,23 @@ function snapshotLinked(fenceId, parentId, linkedPoint) {
     }
     return out;
 }
+/**
+ * Re-elect the slab lift host for the given fences from their CURRENT
+ * store state (call after the endpoint writes). Only writes when the host
+ * actually changes, so unaffected drags stay patch-free.
+ */
+function applyFenceSupportPatches(ids, scene) {
+    const nodes = useScene.getState().nodes;
+    for (const id of ids) {
+        const fence = nodes[id];
+        if (fence?.type !== 'fence')
+            continue;
+        const patch = resolveFenceSupportSlabPatch(fence, nodes);
+        if (patch.supportSlabId !== fence.supportSlabId) {
+            scene.update(id, patch);
+        }
+    }
+}
 function linkedCascade(linked, origin, next) {
     return linked.map((l) => ({
         id: l.id,
@@ -164,6 +181,10 @@ export const moveFenceEndpointDragAction = {
             });
             dirty.push(linked.id);
         }
+        // Re-elect the lift host live: a fence dragged onto / off an elevated
+        // deck rises or drops with the pointer instead of waiting for commit
+        // (fences run no per-frame election — `supportSlabId` IS the lift).
+        applyFenceSupportPatches(dirty, scene);
         return dirty;
     },
     commit: (draft, ctx, scene) => {
@@ -183,14 +204,21 @@ export const moveFenceEndpointDragAction = {
         scene.restoreAll();
         scene.resumeHistory();
         scene.update(ctx.fenceId, { start: draft.start, end: draft.end });
+        const patched = [ctx.fenceId];
         if (!draft.detached) {
             for (const linked of draft.linkedUpdates) {
                 scene.update(linked.id, {
                     start: linked.start,
                     end: linked.end,
                 });
+                patched.push(linked.id);
             }
         }
+        // The restoreAll above reverted any live host patch — re-run the
+        // election against the final endpoints so the committed fence stands
+        // on (or leaves) its deck. Uncapped: an endpoint drag has no commit
+        // pointer ray worth trusting, matching the wall move commits.
+        applyFenceSupportPatches(patched, scene);
         return true;
     },
     cancel: (_ctx, _scene) => {

package/dist/fence/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/fence/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAYzB,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AA2KpC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CAoH5D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/fence/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,cAAc,EAEpB,MAAM,kBAAkB,CAAA;AAkBzB,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAgPpC;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CAyH5D,CAAA"}