@pascal-app/nodes 1.0.0-beta.5 → 1.0.0

package/dist/duct-segment/selection.js

@@ -1,19 +1,22 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { analyzePortConnectivity, DuctSegmentNode, nodeRegistry, pauseSceneHistory, resolveConnectivityUpdates, resumeSceneHistory, sceneRegistry, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
-import { DimensionPill, swallowNextClick, triggerSFX, useEditor } from '@pascal-app/editor';
+import { clearPlacementSurface, DimensionPill, isAngleSnapActive, isGridSnapActive, swallowNextClick, triggerSFX, useEditor, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Html } from '@react-three/drei';
 import { createPortal, useFrame, useThree } from '@react-three/fiber';
 import { useEffect, useMemo, useRef, useState } from 'react';
 import { Euler, Matrix4, Plane, Quaternion, Raycaster, Vector2, Vector3, } from 'three';
 import { newAutoOffsetGroupId, readAutoOffsetTag, translateAutoOffsetBase, withAutoOffsetTag, withoutAutoOffsetTag, } from '../shared/auto-offset-tag';
+import { planRunEndCapFollowUpdates } from '../shared/automatic-run-end-cap';
 import { detectFittingEndpoint, planFittingEndpointReaim, } from '../shared/fitting-endpoint-reaim';
 import { DuctSegmentGhost, FittingGhost } from '../shared/mep-ghost';
 import { collectScenePorts, DUCT_PORT_SYSTEMS, findNearestPortXZ } from '../shared/ports';
 import { planRunTranslationOffsets } from '../shared/run-translation-offset';
-import { HandleCube, MoveChevron, RotateArc } from '../shared/selection-handles';
+import { ContinuePlusHandle, HandleCube, MoveChevron, RotateArc } from '../shared/selection-handles';
 import { planVerticalOffsets } from '../shared/vertical-offset';
+import { refreshWallRunAttachment } from '../shared/wall-run-move';
+import { activateDuctContinuation, ductContinuationHandlePlan, } from './continuation';
 import { INCHES_TO_METERS } from './geometry';
 /** Port-snap radius for dragged run endpoints (meters, XZ). */
 const PORT_SNAP_RADIUS_M = 0.4;
@@ -21,7 +24,7 @@ const PORT_SNAP_RADIUS_M = 0.4;
 // they clear thick trunks.
 const CORNER_ARROW_GAP = 0.18;
 const CORNER_ARROW_MIN_OFFSET = 0.24;
-/** Roll snap increment — 45°, matching the fitting rotate step. Shift bypasses. */
+/** Roll snap increment — 45°, matching the fitting rotate step. */
 const ROLL_STEP_RAD = Math.PI / 4;
 const UP = new Vector3(0, 1, 0);
 function collectPortsFromNodes(nodes, filter = {}) {
@@ -76,11 +79,10 @@ function runRadiusM(duct) {
  * - **Alt** detaches: the joint breaks for this drag — the elbow does NOT
  *   re-aim and mated fittings / runs do NOT follow; the endpoint moves on its
  *   own (port re-mate still allowed so it can be reattached elsewhere).
- * - **Shift** bypasses grid snapping for a perfectly smooth precision drag.
+ * - Snapping follows the active editor snapping mode.
  *
- * History does the single-undo dance: paused during the drag (the live
- * `updateNode` ticks are untracked), then on release the path is
- * reverted, history resumed, and the final path applied as one tracked
+ * History is paused during the drag while live overrides drive the preview.
+ * On release, history resumes and the final path is applied as one tracked
  * change.
  */
 const DuctSegmentSelectionAffordance = () => {
@@ -126,6 +128,8 @@ const DuctSegmentSelectionAffordance = () => {
 };
 const DuctPointHandles = ({ duct, target }) => {
     const { camera, gl } = useThree();
+    const liveOverride = useLiveNodeOverrides((state) => state.overrides.get(duct.id));
+    const displayDuct = liveOverride ? { ...duct, ...liveOverride } : duct;
     // Outer group mirrors the duct group's local pose so handles placed in
     // node-local path coords land exactly where the duct mesh sits, even though
     // they're mounted in the parent (to stay out of the duct's selection
@@ -259,21 +263,54 @@ const DuctPointHandles = ({ duct, target }) => {
     // leans). Otherwise: the dragged point moves and any mated fittings / runs
     // translate via connectivity.
     const buildDragBatch = (drag, next, detached) => {
+        const wall = duct.wallAttachment
+            ? useScene.getState().nodes[duct.wallAttachment.wallId]
+            : undefined;
+        const attachmentFor = (path) => duct.wallAttachment && wall?.type === 'wall'
+            ? refreshWallRunAttachment(path, duct.wallAttachment, wall)
+            : duct.wallAttachment;
+        const withEndCapFollow = (path, updates) => {
+            if (drag.index !== 0 && drag.index !== drag.initialPath.length - 1)
+                return updates;
+            const endpoint = drag.index === 0 ? 'start' : 'end';
+            const nextDuct = { ...duct, path };
+            const capUpdates = planRunEndCapFollowUpdates(duct, nextDuct, endpoint, useScene.getState().nodes);
+            const capIds = new Set(capUpdates.map((update) => update.id));
+            return [...updates.filter((update) => !capIds.has(update.id)), ...capUpdates];
+        };
         if (!detached && drag.fittingEndpoint) {
             const plan = planFittingEndpointReaim(drag.fittingEndpoint, drag.index, next);
             // Out of the fitting's buildable range — hold this frame.
             if (!plan)
                 return null;
-            return [
-                { id: duct.id, data: { path: plan.path } },
+            return withEndCapFollow(plan.path, [
+                {
+                    id: duct.id,
+                    data: { path: plan.path, wallAttachment: attachmentFor(plan.path) },
+                },
                 { id: plan.fittingUpdate.id, data: plan.fittingUpdate.data },
-            ];
+                ...(drag.jointPartner
+                    ? [
+                        {
+                            id: drag.jointPartner.id,
+                            data: {
+                                path: drag.jointPartner.startPath.map((p, i) => i === (drag.index === 0 ? drag.jointPartner.startPath.length - 1 : 0)
+                                    ? drag.index === 0
+                                        ? plan.path[plan.path.length - 1]
+                                        : plan.path[0]
+                                    : p),
+                            },
+                        },
+                    ]
+                    : []),
+            ]);
         }
-        const path = duct.path.map((p, i) => (i === drag.index ? next : p));
-        return [
-            { id: duct.id, data: { path } },
+        const path = drag.initialPath.map((p, i) => (i === drag.index ? next : p));
+        const updates = [
+            { id: duct.id, data: { path, wallAttachment: attachmentFor(path) } },
             ...(detached ? [] : connectivityUpdatesForPath(drag.connectivity, path)),
         ];
+        return detached ? updates : withEndCapFollow(path, updates);
     };
     /** World-space position of a local path point. */
     const toWorld = (p) => target.localToWorld(new Vector3(p[0], p[1], p[2]));
@@ -301,6 +338,27 @@ const DuctPointHandles = ({ duct, target }) => {
         const startPoint = initialPath[index];
         const connectivity = analyzePortConnectivity(duct, useScene.getState().nodes);
         pauseSceneHistory(useScene);
+        const livePreviewIds = new Set();
+        const publishLivePreview = (updates) => {
+            const scene = useScene.getState();
+            const entries = updates
+                .filter((update) => scene.nodes[update.id])
+                .map((update) => [update.id, update.data]);
+            useLiveNodeOverrides.getState().setMany(entries);
+            for (const [id] of entries) {
+                livePreviewIds.add(id);
+                scene.markDirty(id);
+            }
+        };
+        const clearLivePreview = () => {
+            const scene = useScene.getState();
+            const overrides = useLiveNodeOverrides.getState();
+            for (const id of livePreviewIds) {
+                overrides.clear(id);
+                if (scene.nodes[id])
+                    scene.markDirty(id);
+            }
+        };
         useViewer.getState().setInputDragging(true);
         document.body.style.cursor = kind.axis === 'y' ? 'ns-resize' : 'grabbing';
         setDraggingIndex(index);
@@ -311,7 +369,7 @@ const DuctPointHandles = ({ duct, target }) => {
         // instead of lengthening. The along-run pair keeps the plain lengthen /
         // shorten. The pivot is the adjacent vertex; null when there's no neighbour
         // (a lone point) or the grabbed segment has zero length.
-        const swings = kind.axis === 'y' ? kind.along !== true : !kind.along;
+        const swings = kind.axis === 'y' ? kind.along !== true : kind.axis === 'horizontal' && !kind.along;
         // Pivot only at an endpoint (its single neighbour is the unambiguous "other
         // end"); interior vertices keep the plain per-axis drag.
         const neighborIndex = index === 0 ? 1 : index === initialPath.length - 1 ? index - 1 : null;
@@ -327,15 +385,19 @@ const DuctPointHandles = ({ duct, target }) => {
         const fittingEndpoint = isEndpoint
             ? detectFittingEndpoint('duct-segment', initialPath, index, useScene.getState().nodes)
             : null;
+        const partnerId = fittingEndpoint?.fitting.metadata?.altJoint
+            ? fittingEndpoint.fitting.metadata.partnerIds?.find((id) => id !== duct.id)
+            : undefined;
+        const partner = partnerId ? useScene.getState().nodes[partnerId] : undefined;
         const onMove = (event) => {
             const drag = dragRef.current;
             if (!drag)
                 return;
-            // Shift = precision: bypass grid snapping (snap() is a no-op at step 0).
-            const step = event.shiftKey ? 0 : useEditor.getState().gridSnapStep;
+            // Follow the active snapping mode; Shift cycles that mode globally.
+            const step = isGridSnapActive() ? useEditor.getState().gridSnapStep : 0;
             // Alt = detach: break the joint for this drag (it can still port-snap to
             // re-mate elsewhere). Mirrors the wall corner drag.
-            const detached = event.altKey;
+            const detached = event.altKey && !drag.jointPartner;
             let next = null;
             if (canSwing && pivot) {
                 // Length-preserving swing: aim from the pivot toward the cursor and
@@ -347,8 +409,7 @@ const DuctPointHandles = ({ duct, target }) => {
                     ? swingVertical(event, pivot, startPoint)
                     : swingHorizontal(event, pivot, startPoint);
                 if (aim) {
-                    // The swung endpoint follows the grid snap points by default; Shift
-                    // sets step 0 so it sweeps smoothly. Snapping the landed coords (not
+                    // The swung endpoint follows the active grid snap mode. Snapping the landed coords (not
                     // the arc angle) keeps the endpoint on the grid like every other
                     // arrow, trading a hair of the fixed radius for grid alignment.
                     next = [
@@ -388,7 +449,10 @@ const DuctPointHandles = ({ duct, target }) => {
             // radius yields to the port). Stays available while detaching or
             // free-dragging; suppressed only while a fitting is actively re-aiming.
             if (isEndpoint && (detached || !drag.fittingEndpoint)) {
-                const port = findNearestPortXZ([next[0], next[1], next[2]], collectScenePorts({ excludeNodeId: duct.id, systems: DUCT_PORT_SYSTEMS }), PORT_SNAP_RADIUS_M);
+                const port = findNearestPortXZ([next[0], next[1], next[2]], collectScenePorts({
+                    excludeNodeId: duct.id,
+                    systems: DUCT_PORT_SYSTEMS,
+                }), PORT_SNAP_RADIUS_M);
                 if (port)
                     next = [port.position[0], port.position[1], port.position[2]];
             }
@@ -404,7 +468,7 @@ const DuctPointHandles = ({ duct, target }) => {
             // when the grid is live (step > 0): Shift-precision has nothing to snap.
             if (step > 0)
                 triggerSFX('sfx:grid-snap');
-            useScene.getState().updateNodes(batch);
+            publishLivePreview(batch);
         };
         const onUp = () => {
             const drag = dragRef.current;
@@ -419,30 +483,15 @@ const DuctPointHandles = ({ duct, target }) => {
             drag.cleanup();
             dragRef.current = null;
             setDraggingIndex(null);
-            // Single-undo dance: revert (still paused), resume, re-apply the final
-            // batch as one tracked change. The final batch is built the same way as
+            clearLivePreview();
+            // Resume history and apply the final batch as one tracked change. The
+            // final batch is built the same way as
             // each live frame (elbow re-aim, rigid connectivity follow, or — when
             // detached — just the duct path).
             const detached = drag.detached;
+            const moved = drag.current.some((v, axis) => v !== drag.initialPath[drag.index][axis]);
             const finalBatch = buildDragBatch(drag, drag.current, detached);
-            // Revert the run AND whatever the drag carried to their pre-drag state
-            // while paused so history captures a clean before→after delta. When
-            // detached nothing else moved, so only the run needs reverting.
-            const revertUpdates = detached
-                ? []
-                : drag.fittingEndpoint
-                    ? [drag.fittingEndpoint.revert]
-                    : (drag.connectivity?.connections ?? []).map((conn) => conn.kind === 'rigid-node'
-                        ? { id: conn.nodeId, data: { position: conn.startPosition } }
-                        : { id: conn.nodeId, data: { path: conn.startPath } });
-            useScene
-                .getState()
-                .updateNodes([
-                { id: duct.id, data: { path: drag.initialPath } },
-                ...revertUpdates.filter((u) => useScene.getState().nodes[u.id]),
-            ]);
             resumeSceneHistory(useScene);
-            const moved = drag.current.some((v, axis) => v !== drag.initialPath[drag.index][axis]);
             if (moved && finalBatch) {
                 // A manual corner edit invalidates any stored auto-offset base (the
                 // tag's snapshot no longer matches the geometry), so strip the tag on
@@ -473,6 +522,9 @@ const DuctPointHandles = ({ duct, target }) => {
             cleanup,
             connectivity,
             fittingEndpoint,
+            jointPartner: partner?.type === 'duct-segment'
+                ? { id: partner.id, startPath: partner.path.map((p) => [...p]) }
+                : undefined,
             detached: false,
         };
         window.addEventListener('pointermove', onMove);
@@ -527,23 +579,23 @@ const DuctPointHandles = ({ duct, target }) => {
             const b = bearing(event.clientX, event.clientY);
             if (b === null)
                 return;
-            // Snap the roll to 45° steps; Shift = smooth (no snap).
+            // Snap the roll to 45° steps only in the active angle mode.
             const raw = b - startBearing;
-            const delta = event.shiftKey ? raw : Math.round(raw / ROLL_STEP_RAD) * ROLL_STEP_RAD;
+            const delta = isAngleSnapActive() ? Math.round(raw / ROLL_STEP_RAD) * ROLL_STEP_RAD : raw;
             const next = startRoll + delta;
             if (next === current)
                 return;
             current = next;
-            // Tick the rotate SFX each time a fresh snap step is crossed (snapped
-            // rolls only — a smooth Shift-drag has no discrete steps to mark).
-            if (!event.shiftKey) {
+            // Tick the rotate SFX each time a fresh snapped step is crossed.
+            if (isAngleSnapActive()) {
                 const step = Math.round(raw / ROLL_STEP_RAD);
                 if (step !== lastStep) {
                     lastStep = step;
                     triggerSFX('sfx:item-rotate');
                 }
             }
-            useScene.getState().updateNode(duct.id, { roll: next });
+            useLiveNodeOverrides.getState().set(duct.id, { roll: next });
+            useScene.getState().markDirty(duct.id);
         };
         const onUp = () => {
             swallowNextClick();
@@ -551,12 +603,11 @@ const DuctPointHandles = ({ duct, target }) => {
             window.removeEventListener('pointerup', onUp);
             window.removeEventListener('pointercancel', onUp);
             useViewer.getState().setInputDragging(false);
+            clearPlacementSurface();
             document.body.style.cursor = '';
             setRolling(false);
-            // Single-undo dance: revert to the pre-drag roll while paused, resume,
-            // then re-apply the final roll as one tracked change. A roll edit also
-            // invalidates any stored auto-offset base, so strip the tag on commit.
-            useScene.getState().updateNode(duct.id, { roll: startRoll });
+            useLiveNodeOverrides.getState().clear(duct.id);
+            useScene.getState().markDirty(duct.id);
             resumeSceneHistory(useScene);
             if (current !== startRoll) {
                 useScene.getState().updateNode(duct.id, {
@@ -604,12 +655,7 @@ const DuctPointHandles = ({ duct, target }) => {
         const logicalPath = (runBase?.data?.path?.map((p) => [...p]) ?? initialPath);
         const baseDy = tag?.dy ?? 0;
         const mintedIds = (tag?.minted ?? []);
-        // Snapshots of the existing minted nodes, so the pre-commit revert can
-        // restore the original Z (the single-undo baseline) before the final write.
-        const mintedSnapshots = mintedIds
-            .map((id) => preRewindNodes[id])
-            .filter((n) => Boolean(n));
-        const previewDeletedSnapshots = new Map();
+        const previewHiddenIds = new Set();
         pauseSceneHistory(useScene);
         const ensureSceneObjectsVisible = (ids) => {
             const scene = useScene.getState();
@@ -640,11 +686,32 @@ const DuctPointHandles = ({ duct, target }) => {
             }
         };
         const clearLivePreview = () => {
+            const scene = useScene.getState();
             const overrides = useLiveNodeOverrides.getState();
-            for (const id of livePreviewIds)
+            for (const id of livePreviewIds) {
                 overrides.clear(id);
+                if (scene.nodes[id])
+                    scene.markDirty(id);
+            }
             livePreviewIds.clear();
         };
+        const setPreviewHidden = (ids) => {
+            const next = new Set(ids);
+            for (const id of previewHiddenIds) {
+                if (next.has(id))
+                    continue;
+                const object = sceneRegistry.nodes.get(id);
+                if (object)
+                    object.visible = true;
+                previewHiddenIds.delete(id);
+            }
+            for (const id of next) {
+                const object = sceneRegistry.nodes.get(id);
+                if (object)
+                    object.visible = false;
+                previewHiddenIds.add(id);
+            }
+        };
         // Connectivity + ports are read from an IN-MEMORY post-rewind scene (the
         // logical L), so click-only pointerdown doesn't visually snap the committed
         // offset down to the floor. The real scene is only rewound after the first
@@ -716,10 +783,15 @@ const DuctPointHandles = ({ duct, target }) => {
         const partnerReverts = () => (connectivity?.connections ?? [])
             .map((conn) => {
             if (conn.kind !== 'rigid-node') {
-                return { id: conn.nodeId, data: { path: conn.startPath } };
+                return {
+                    id: conn.nodeId,
+                    data: { path: conn.startPath },
+                };
             }
             const start = nodesById[conn.nodeId];
-            const data = { position: conn.startPosition };
+            const data = {
+                position: conn.startPosition,
+            };
             if (start?.rotation !== undefined)
                 data.rotation = start.rotation;
             if (start?.angle !== undefined)
@@ -732,7 +804,10 @@ const DuctPointHandles = ({ duct, target }) => {
         // start paths / poses. A re-drag carries the existing tag's base forward.
         const freshBase = () => [
             { id: duct.id, data: { path: initialPath } },
-            ...partnerReverts().map((u) => ({ id: u.id, data: u.data })),
+            ...partnerReverts().map((u) => ({
+                id: u.id,
+                data: u.data,
+            })),
         ];
         // Patches restoring partners to their PRE-rewind (original Z) poses — the
         // single-undo baseline. Untagged: same as the L (no rewind happened).
@@ -746,7 +821,10 @@ const DuctPointHandles = ({ duct, target }) => {
                 if (!orig)
                     return null;
                 if ('path' in orig)
-                    return { id: b.id, data: { path: orig.path } };
+                    return {
+                        id: b.id,
+                        data: { path: orig.path },
+                    };
                 const data = {};
                 if (orig.position !== undefined)
                     data.position = orig.position;
@@ -760,47 +838,19 @@ const DuctPointHandles = ({ duct, target }) => {
                 .filter((u) => useScene.getState().nodes[u.id]);
         };
         const restoreOriginalOffsetPreview = () => {
-            const scene = useScene.getState();
             const partnerUpdates = originalPartnerReverts();
             const updates = [
                 {
                     id: duct.id,
-                    data: { path: duct.path, metadata: duct.metadata },
+                    data: {
+                        path: duct.path,
+                        metadata: duct.metadata,
+                    },
                 },
                 ...partnerUpdates,
             ];
             publishLivePreview(updates);
-            scene.applyNodeChanges({
-                create: mintedSnapshots
-                    .filter((n) => !scene.nodes[n.id])
-                    .map((node) => ({ node, parentId })),
-                update: updates,
-            });
-            ensureSceneObjectsVisible([
-                duct.id,
-                ...mintedSnapshots.map((node) => node.id),
-                ...partnerUpdates.map((update) => update.id),
-            ]);
-        };
-        const restorePreviewDeleted = (keepDeleted = []) => {
-            const keep = new Set(keepDeleted);
-            const scene = useScene.getState();
-            const create = [];
-            for (const [id, node] of previewDeletedSnapshots) {
-                if (keep.has(id))
-                    continue;
-                if (!scene.nodes[id]) {
-                    create.push({
-                        node,
-                        parentId: (node.parentId ?? undefined),
-                    });
-                }
-                previewDeletedSnapshots.delete(id);
-            }
-            if (create.length > 0) {
-                scene.applyNodeChanges({ create });
-                ensureSceneObjectsVisible(create.map(({ node }) => node.id));
-            }
+            setPreviewHidden([]);
         };
         const applyLogicalBasePreview = () => {
             if (!tag)
@@ -819,11 +869,7 @@ const DuctPointHandles = ({ duct, target }) => {
                     .map((b) => ({ id: b.id, data: b.data })),
             ];
             publishLivePreview(updates);
-            scene.applyNodeChanges({
-                delete: mintedIds.filter((id) => scene.nodes[id]),
-                update: updates,
-            });
-            ensureSceneObjectsVisible(updates.map((update) => update.id));
+            setPreviewHidden(mintedIds);
         };
         const onMove = (event) => {
             if (startSample === null)
@@ -831,7 +877,7 @@ const DuctPointHandles = ({ duct, target }) => {
             const s = sample(event.clientX, event.clientY);
             if (s === null)
                 return;
-            const step = event.shiftKey ? 0 : useEditor.getState().gridSnapStep;
+            const step = isGridSnapActive() ? useEditor.getState().gridSnapStep : 0;
             const next = snap(s - startSample, step);
             if (next === delta)
                 return;
@@ -865,12 +911,7 @@ const DuctPointHandles = ({ duct, target }) => {
                 const plan = offsetResult.plan;
                 const scene = useScene.getState();
                 const deletePreview = (plan.delete ?? []).filter((id) => scene.nodes[id]);
-                for (const id of deletePreview) {
-                    const node = scene.nodes[id];
-                    if (node)
-                        previewDeletedSnapshots.set(id, node);
-                }
-                restorePreviewDeleted(plan.delete ?? []);
+                setPreviewHidden([...mintedIds, ...deletePreview]);
                 const followUpdates = connectivityUpdatesForPath(connectivity, plan.followPath);
                 const updates = [
                     { id: duct.id, data: { path: plan.ductPath } },
@@ -878,31 +919,29 @@ const DuctPointHandles = ({ duct, target }) => {
                     ...followUpdates,
                 ];
                 publishLivePreview(updates);
-                scene.applyNodeChanges({
-                    delete: deletePreview,
-                    update: updates,
+                setVerticalGhost({
+                    tint: 'valid',
+                    fittings: plan.fittings,
+                    risers: plan.risers,
                 });
-                ensureSceneObjectsVisible(updates.map((update) => update.id));
-                setVerticalGhost({ tint: 'valid', fittings: plan.fittings, risers: plan.risers });
             }
             else if (offsetResult?.status === 'invalid') {
                 // No clean offset at this height. Keep the last committed network
                 // visible (including any prior auto-offset we rewound at drag-start)
                 // and show a RED ghost of the run where it WOULD lift to. Nothing is
                 // committed on release, so the run snaps back to its prior state.
-                restorePreviewDeleted();
                 restoreOriginalOffsetPreview();
-                const lifted = DuctSegmentNode.parse({ ...logicalDuct, path: shiftedPath(next) });
+                const lifted = DuctSegmentNode.parse({
+                    ...logicalDuct,
+                    path: shiftedPath(next),
+                });
                 setVerticalGhost({ tint: 'invalid', fittings: [], risers: [lifted] });
             }
             else {
-                restorePreviewDeleted();
                 applyLogicalBasePreview();
                 setVerticalGhost(null);
                 const updates = batchFor(shiftedPath(next));
                 publishLivePreview(updates);
-                useScene.getState().updateNodes(updates);
-                ensureSceneObjectsVisible(updates.map((update) => update.id));
             }
         };
         const onUp = () => {
@@ -915,35 +954,7 @@ const DuctPointHandles = ({ duct, target }) => {
             setRunMoving(false);
             setVerticalGhost(null);
             clearLivePreview();
-            // Single-undo dance: while paused, revert to the PRE-drag baseline (the
-            // original Z — recreate the minted nodes the rewind deleted and restore
-            // the run + partners), resume, then write the final state as ONE tracked
-            // change so undo jumps straight back to the original.
-            const restore = useScene.getState();
-            const restoredPreviewNodes = Array.from(previewDeletedSnapshots.values()).filter((node) => !restore.nodes[node.id]);
-            const restoredMintedNodes = mintedSnapshots.filter((n) => !restore.nodes[n.id]);
-            const restoreUpdates = [
-                {
-                    id: duct.id,
-                    data: { path: duct.path, metadata: duct.metadata },
-                },
-                ...originalPartnerReverts(),
-            ];
-            restore.applyNodeChanges({
-                create: [
-                    ...restoredMintedNodes.map((node) => ({ node, parentId })),
-                    ...restoredPreviewNodes.map((node) => ({
-                        node,
-                        parentId: (node.parentId ?? undefined),
-                    })),
-                ],
-                update: restoreUpdates,
-            });
-            ensureSceneObjectsVisible([
-                ...restoredMintedNodes.map((node) => node.id),
-                ...restoredPreviewNodes.map((node) => node.id),
-                ...restoreUpdates.map((update) => update.id),
-            ]);
+            setPreviewHidden([]);
             resumeSceneHistory(useScene);
             if (delta === 0)
                 return;
@@ -1036,7 +1047,10 @@ const DuctPointHandles = ({ duct, target }) => {
                 if (translationPlan) {
                     const created = [...translationPlan.fittings, ...translationPlan.connectors];
                     const updates = [
-                        { id: duct.id, data: { path: translationPlan.ductPath } },
+                        {
+                            id: duct.id,
+                            data: { path: translationPlan.ductPath },
+                        },
                         ...translationPlan.updates,
                     ];
                     scene.applyNodeChanges({
@@ -1084,19 +1098,19 @@ const DuctPointHandles = ({ duct, target }) => {
         window.addEventListener('pointerup', onUp);
         window.addEventListener('pointercancel', onUp);
     };
-    const cornerArrows = useMemo(() => getCornerArrows(duct), [duct]);
-    const rollGizmo = useMemo(() => (duct.shape === 'round' ? null : runAxisAndCenter(duct)), [duct]);
+    const cornerArrows = useMemo(() => getCornerArrows(displayDuct), [displayDuct]);
+    const rollGizmo = useMemo(() => (displayDuct.shape === 'round' ? null : runAxisAndCenter(displayDuct)), [displayDuct]);
     // Run-center cube position (centroid centerline). The six whole-run move
     // arrows + the roll arc are revealed on hover, like the per-vertex clusters.
-    const runCenter = useMemo(() => runAxisAndCenter(duct)?.center ?? null, [duct]);
+    const runCenter = useMemo(() => runAxisAndCenter(displayDuct)?.center ?? null, [displayDuct]);
     // Yaw the center cube to the run's horizontal heading so it stays aligned
     // with the run (matching the per-vertex cubes). A pure riser has no heading.
     const runCenterYaw = useMemo(() => {
-        const axis = runAxisAndCenter(duct);
+        const axis = runAxisAndCenter(displayDuct);
         if (!axis || Math.hypot(axis.dir[0], axis.dir[2]) < 1e-6)
             return 0;
         return Math.atan2(-axis.dir[2], axis.dir[0]);
-    }, [duct]);
+    }, [displayDuct]);
     // Six whole-run move arrows offset off the center: four horizontal (along-run
     // ± and across-run ±, aligned to the run's XZ tangent so they track the run
     // instead of world ±X / ±Z) plus the up / down vertical pair. All shift every
@@ -1104,10 +1118,10 @@ const DuctPointHandles = ({ duct, target }) => {
     const centerArrows = useMemo(() => {
         if (!runCenter)
             return [];
-        const base = Math.max(runRadiusM(duct) + CORNER_ARROW_GAP, CORNER_ARROW_MIN_OFFSET);
+        const base = Math.max(runRadiusM(displayDuct) + CORNER_ARROW_GAP, CORNER_ARROW_MIN_OFFSET);
         // Run's horizontal heading (node-local XZ). A pure riser has none → fall
         // back to world +X so the arrows stay usable.
-        const axis = runAxisAndCenter(duct);
+        const axis = runAxisAndCenter(displayDuct);
         const t = axis && Math.hypot(axis.dir[0], axis.dir[2]) > 1e-6
             ? (() => {
                 const len = Math.hypot(axis.dir[0], axis.dir[2]);
@@ -1144,19 +1158,22 @@ const DuctPointHandles = ({ duct, target }) => {
             cursor: 'ns-resize',
         });
         return arrows;
-    }, [duct, runCenter]);
+    }, [displayDuct, runCenter]);
     return (_jsxs("group", { ref: outerRef, children: [verticalGhost?.fittings.map((f) => (_jsx(FittingGhost, { fitting: f, tint: verticalGhost.tint }, `vghost-fit-${f.id}`))), verticalGhost?.risers.map((r) => (_jsx(DuctSegmentGhost, { duct: r, tint: verticalGhost.tint }, `vghost-riser-${r.id}`))), draggingIndex === null &&
                 !rolling &&
                 !runMoving &&
-                duct.path.map((p, i) => (_jsxs("group", { children: [_jsx(HandleCube, { active: openCluster === i, onClick: () => toggleCluster(i), position: p, rotationY: vertexYaw(duct, i) }), openCluster === i &&
+                ['start', 'end'].map((endpoint) => (_jsx(DuctContinuationHandle, { duct: displayDuct, endpoint: endpoint }, endpoint))), draggingIndex === null &&
+                !rolling &&
+                !runMoving &&
+                displayDuct.path.map((p, i) => (_jsxs("group", { children: [_jsx(HandleCube, { active: openCluster === i, onClick: () => toggleCluster(i), position: p, rotationY: vertexYaw(displayDuct, i) }), openCluster === i &&
                             cornerArrows
                                 .filter((a) => a.index === i)
-                                .map((a) => (_jsx(MoveChevron, { cursor: a.cursor, onPointerDown: onHandleDown(a.index, a.kind), position: a.position, rotationY: a.rotationY, vertical: a.vertical }, a.key)))] }, `vtx${i}`))), draggingIndex === null && !rolling && !runMoving && runCenter && (_jsxs("group", { children: [_jsx(HandleCube, { active: openCluster === 'center', onClick: () => toggleCluster('center'), position: runCenter, rotationY: runCenterYaw }), openCluster === 'center' && (_jsxs(_Fragment, { children: [centerArrows.map((a) => (_jsx(MoveChevron, { cursor: a.cursor, onPointerDown: onRunMoveDown(a.kind), position: a.position, rotationY: a.rotationY, vertical: a.vertical }, a.key))), rollGizmo && (_jsx(RollHandle, { center: rollGizmo.center, dir: rollGizmo.dir, onPointerDown: onRollDown, radius: runRadiusM(duct) + CORNER_ARROW_GAP }))] }))] })), draggingIndex !== null &&
-                duct.path[draggingIndex] &&
+                                .map((a) => (_jsx(MoveChevron, { cursor: a.cursor, onPointerDown: onHandleDown(a.index, a.kind), position: a.position, rotationY: a.rotationY, vertical: a.vertical }, a.key)))] }, `vtx${i}`))), draggingIndex === null && !rolling && !runMoving && runCenter && (_jsxs("group", { children: [_jsx(HandleCube, { active: openCluster === 'center', onClick: () => toggleCluster('center'), position: runCenter, rotationY: runCenterYaw }), openCluster === 'center' && (_jsxs(_Fragment, { children: [centerArrows.map((a) => (_jsx(MoveChevron, { cursor: a.cursor, onPointerDown: onRunMoveDown(a.kind), position: a.position, rotationY: a.rotationY, vertical: a.vertical }, a.key))), rollGizmo && (_jsx(RollHandle, { center: rollGizmo.center, dir: rollGizmo.dir, onPointerDown: onRollDown, radius: runRadiusM(displayDuct) + CORNER_ARROW_GAP }))] }))] })), draggingIndex !== null &&
+                displayDuct.path[draggingIndex] &&
                 (() => {
                     // Same pill as the draw tool: signed per-axis deltas from the
                     // drag-start position, dominant axis emphasised.
-                    const point = duct.path[draggingIndex];
+                    const point = displayDuct.path[draggingIndex];
                     const origin = dragRef.current?.initialPath[draggingIndex] ?? point;
                     const deltas = [point[0] - origin[0], point[1] - origin[1], point[2] - origin[2]];
                     const axes = ['x', 'y', 'z'];
@@ -1169,6 +1186,17 @@ const DuctPointHandles = ({ duct, target }) => {
                             })), primary: primary, unit: unit }) }));
                 })()] }));
 };
+function DuctContinuationHandle({ duct, endpoint, }) {
+    const nodes = useScene((state) => state.nodes);
+    const gap = Math.max(0.28, runRadiusM(duct) + 0.18);
+    const plan = ductContinuationHandlePlan(duct, endpoint, nodes, gap);
+    if (!plan)
+        return null;
+    return (_jsx(ContinuePlusHandle, { onActivate: () => {
+            triggerSFX('sfx:item-pick');
+            activateDuctContinuation(duct, endpoint, plan.fittingId);
+        }, position: plan.position }));
+}
 /**
  * Roll gizmo — the shared `RotateArc` re-oriented to wrap the run's length
  * axis, seated at a FIXED corner of the section frame. It does NOT track