@pascal-app/nodes 0.1.1

package/dist/wall/curve-tool.js

@@ -0,0 +1,123 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { emitter, getClampedWallCurveOffset, getMaxWallCurveOffset, getWallChordFrame, getWallMidpointHandlePoint, normalizeWallCurveOffset, useScene, } from '@pascal-app/core';
+import { CursorSphere, getSegmentGridStep, markToolCancelConsumed, snapBuildingLocalToWorldGrid, snapScalarToGrid, triggerSFX, useInteractionScope, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useCallback, useEffect, useRef, useState } from 'react';
+/**
+ * Phase 5 Stage D — wall curve tool (kind-owned).
+ *
+ * 1:1 port of the legacy `CurveWallTool`. Same snap pipeline,
+ * history dance, activation grace. The wall variant uses
+ * `useScene.temporal.getState().pause()` / `.resume()` directly rather
+ * than the depth-counted `pauseSceneHistory` helpers — matches legacy.
+ */
+export const CurveWallTool = ({ node }) => {
+    const activatedAtRef = useRef(Date.now());
+    const originalCurveOffsetRef = useRef(getClampedWallCurveOffset(node));
+    const previousCurveOffsetRef = useRef(null);
+    const previewOffsetRef = useRef(originalCurveOffsetRef.current);
+    const initialHandle = getWallMidpointHandlePoint(node);
+    const [cursorLocalPos, setCursorLocalPos] = useState([
+        initialHandle.x,
+        0,
+        initialHandle.y,
+    ]);
+    const exitCurveMode = useCallback(() => {
+        useInteractionScope
+            .getState()
+            .endIf((scope) => scope.kind === 'reshaping' && scope.reshape === 'curve');
+    }, []);
+    useEffect(() => {
+        const nodeId = node.id;
+        const originalCurveOffset = originalCurveOffsetRef.current;
+        const chord = getWallChordFrame(node);
+        const maxCurveOffset = getMaxWallCurveOffset(node);
+        useScene.temporal.getState().pause();
+        let wasCommitted = false;
+        const applyPreview = (curveOffset) => {
+            if (previewOffsetRef.current === curveOffset) {
+                return;
+            }
+            previewOffsetRef.current = curveOffset;
+            const nextNode = {
+                ...node,
+                curveOffset,
+            };
+            const handlePoint = getWallMidpointHandlePoint(nextNode);
+            setCursorLocalPos([handlePoint.x, 0, handlePoint.y]);
+            useScene.getState().updateNode(nodeId, { curveOffset });
+            useScene.getState().markDirty(nodeId);
+        };
+        const restoreOriginal = () => {
+            if (previewOffsetRef.current === originalCurveOffset) {
+                return;
+            }
+            previewOffsetRef.current = originalCurveOffset;
+            useScene.getState().updateNode(nodeId, { curveOffset: originalCurveOffset });
+            useScene.getState().markDirty(nodeId);
+        };
+        const onGridMove = (event) => {
+            const snapStep = getSegmentGridStep();
+            // Snap the cursor on the WORLD XZ grid (still in building-local
+            // coords for the rest of the math) so a rotated building doesn't
+            // pull the curve handle off the visible grid lines.
+            const [snappedLocalX, snappedLocalZ] = snapBuildingLocalToWorldGrid([event.localPosition[0], event.localPosition[2]], snapStep);
+            const localX = snappedLocalX;
+            const localZ = snappedLocalZ;
+            const offsetFromMidpoint = -((localX - chord.midpoint.x) * chord.normal.x +
+                (localZ - chord.midpoint.y) * chord.normal.y);
+            const snappedOffset = snapScalarToGrid(offsetFromMidpoint, snapStep);
+            const nextCurveOffset = normalizeWallCurveOffset(node, Math.max(-maxCurveOffset, Math.min(maxCurveOffset, snappedOffset)));
+            if (previousCurveOffsetRef.current !== null &&
+                nextCurveOffset !== previousCurveOffsetRef.current) {
+                triggerSFX('sfx:grid-snap');
+            }
+            previousCurveOffsetRef.current = nextCurveOffset;
+            applyPreview(nextCurveOffset);
+        };
+        const onGridClick = (event) => {
+            if (Date.now() - activatedAtRef.current < 150) {
+                event.nativeEvent?.stopPropagation?.();
+                return;
+            }
+            const curveOffset = previewOffsetRef.current;
+            wasCommitted = true;
+            if (curveOffset !== originalCurveOffset) {
+                // Restore original baseline while paused so the next resume+update
+                // registers as a single tracked change (undo reverts to original).
+                useScene.getState().updateNode(nodeId, { curveOffset: originalCurveOffset });
+                useScene.getState().markDirty(nodeId);
+                useScene.temporal.getState().resume();
+                useScene.getState().updateNode(nodeId, { curveOffset });
+                useScene.getState().markDirty(nodeId);
+                useScene.temporal.getState().pause();
+            }
+            triggerSFX('sfx:item-place');
+            useViewer.getState().setSelection({ selectedIds: [nodeId] });
+            exitCurveMode();
+            event.nativeEvent?.stopPropagation?.();
+        };
+        const onCancel = () => {
+            restoreOriginal();
+            useViewer.getState().setSelection({ selectedIds: [nodeId] });
+            useScene.temporal.getState().resume();
+            markToolCancelConsumed();
+            exitCurveMode();
+        };
+        emitter.on('grid:move', onGridMove);
+        emitter.on('grid:click', onGridClick);
+        emitter.on('tool:cancel', onCancel);
+        return () => {
+            if (!wasCommitted) {
+                restoreOriginal();
+            }
+            useScene.temporal.getState().resume();
+            emitter.off('grid:move', onGridMove);
+            emitter.off('grid:click', onGridClick);
+            emitter.off('tool:cancel', onCancel);
+        };
+    }, [exitCurveMode, node]);
+    return (_jsx("group", { children: _jsx(CursorSphere, { position: cursorLocalPos, showTooltip: false }) }));
+};
+export default CurveWallTool;

package/dist/wall/definition.d.ts

@@ -0,0 +1,19 @@
+import type { NodeDefinition } from '@pascal-app/core';
+import { WallNode } from './schema';
+/**
+ * Wall — the Phase 3 stress test of the registry-driven node model.
+ *
+ * Stage A: registered (capabilities, relations, parametrics, presentation).
+ * Stage B: deferred — wall geometry depends on level-batch miter data that
+ *   doesn't fit the generic `(node, ctx) => Group` shape without `ctx.
+ *   levelData?.miters`. See plan's "GeometryContext" extension note.
+ *   `renderer` + `system` keep wrap-exporting legacy WallRenderer +
+ *   WallSystem + WallCutout.
+ * Stage C: `def.floorplan` builder produces the mitered plan footprint
+ *   polygon from shared floor-plan level data, with `ctx.siblings` as the
+ *   direct-caller fallback.
+ *   floorplan-panel.tsx's `wallPolygons` short-circuits to [] when
+ *   wall is registered.
+ */
+export declare const wallDefinition: NodeDefinition<typeof WallNode>;
+//# sourceMappingURL=definition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/wall/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAatD,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAGnC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAoH1D,CAAA"}

package/dist/wall/definition.js

@@ -0,0 +1,132 @@
+import { buildWallFloorplan, computeWallFloorplanLevelData } from './floorplan';
+import { wallCurveAffordance, wallMoveEndpointAffordance } from './floorplan-affordances';
+import { wallFloorplanMoveTarget } from './floorplan-move';
+import { wallFloorplanSiblingOverrides } from './floorplan-overrides';
+import { matchWallMeasurementFeature, resolveWallMeasurementFeature, wallMeasurementFeatures, } from './measurement';
+import { wallPaint } from './paint';
+import { wallParametrics } from './parametrics';
+import { wallQuickMeasurement } from './quick-measurement';
+import { WallNode } from './schema';
+import { wallSlots } from './slots';
+/**
+ * Wall — the Phase 3 stress test of the registry-driven node model.
+ *
+ * Stage A: registered (capabilities, relations, parametrics, presentation).
+ * Stage B: deferred — wall geometry depends on level-batch miter data that
+ *   doesn't fit the generic `(node, ctx) => Group` shape without `ctx.
+ *   levelData?.miters`. See plan's "GeometryContext" extension note.
+ *   `renderer` + `system` keep wrap-exporting legacy WallRenderer +
+ *   WallSystem + WallCutout.
+ * Stage C: `def.floorplan` builder produces the mitered plan footprint
+ *   polygon from shared floor-plan level data, with `ctx.siblings` as the
+ *   direct-caller fallback.
+ *   floorplan-panel.tsx's `wallPolygons` short-circuits to [] when
+ *   wall is registered.
+ */
+export const wallDefinition = {
+    kind: 'wall',
+    snapProfile: 'structural',
+    schemaVersion: 5,
+    schema: WallNode,
+    category: 'structure',
+    surfaceRole: 'wall',
+    defaults: () => ({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        children: [],
+        start: [0, 0],
+        end: [3, 0],
+        frontSide: 'unknown',
+        backSide: 'unknown',
+    }),
+    capabilities: {
+        // Wall move is bespoke (endpoint drag, linked-wall corner cascade,
+        // ALT-detach). Omitting `movable` keeps the legacy MoveWallTool via
+        // capability-driven dispatch.
+        selectable: { hitVolume: 'bbox' },
+        // Front + back faces host items (paintings, shelves, switches).
+        surfaces: {
+            sides: { faces: 'all' },
+        },
+        duplicable: true,
+        deletable: true,
+        // Paint dispatch for the interior / exterior side split. The
+        // editor's selection-manager routes paint hover / click /
+        // preview through this entry rather than carrying a kind-name
+        // arm.
+        paint: wallPaint,
+        // Declared paintable slots with their default appearance — the same
+        // `{ slotId, label, default }` contract every other paintable kind exposes.
+        // Paint still writes the legacy inline fields for base faces via
+        // `wallPaint`; migrating those fully into `node.slots` is a later step.
+        slots: () => wallSlots(),
+    },
+    relations: {
+        hosts: ['door', 'window', 'item'],
+        affectsSpatial: ['slab', 'ceiling', 'zone'],
+        linkedBy: 'endpoint-match',
+        cascadeDelete: 'descendants',
+    },
+    parametrics: wallParametrics,
+    // Height arrow + side-move arrows + corner pickers all live in the legacy
+    // `wall-move-side-handles.tsx` component. The registry handle path didn't
+    // render correctly for walls specifically; revisit once that's diagnosed.
+    // Stage D — all four wall drag affordances live in this folder.
+    // curve / move-endpoint / move are 1:1 ports of the legacy tools
+    // (same snap pipelines, linked-wall corner cascade with
+    // `planWallMoveJunctions`, ALT-detach, bridge wall previews,
+    // auto-slab live preview, history dances). Placement is wired via
+    // `def.tool`.
+    tool: () => import('./tool'),
+    affordanceTools: {
+        curve: () => import('./curve-tool'),
+        'move-endpoint': () => import('./move-endpoint-tool'),
+        move: () => import('./move-tool'),
+    },
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer'),
+    },
+    system: {
+        module: () => import('./system'),
+        // Priority 4 mirrors the legacy WallSystem's useFrame priority.
+        priority: 4,
+    },
+    // Stage C: floor-plan rendering. Precomputes the level miter graph once
+    // per render pass, then the builder reads its own junctions by wall id.
+    computeFloorplanLevelData: computeWallFloorplanLevelData,
+    floorplan: buildWallFloorplan,
+    measurement: {
+        features: (node) => wallMeasurementFeatures(node),
+        quickMeasure: (node) => wallQuickMeasurement(node),
+        match: (node, _ctx, point, maxDistance) => matchWallMeasurementFeature(node, point, maxDistance),
+        resolve: (node, _ctx, reference) => resolveWallMeasurementFeature(node, reference),
+    },
+    floorplanDependsOnSiblings: true,
+    // 2D drag affordances triggered by `endpoint-handle` primitives in
+    // `def.floorplan`'s output. Sister to `affordanceTools` (3D) — the
+    // same legacy `MoveWallEndpointTool` flow, reachable from both the
+    // R3F canvas and the floor-plan SVG.
+    floorplanAffordances: {
+        'move-endpoint': wallMoveEndpointAffordance,
+        curve: wallCurveAffordance,
+    },
+    floorplanMoveTarget: wallFloorplanMoveTarget,
+    floorplanSiblingOverrides: wallFloorplanSiblingOverrides,
+    toolHints: [
+        { key: 'Left click', label: 'Set wall start / end' },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+    presentation: {
+        label: 'Wall',
+        description: 'A straight or curved wall segment. Hosts doors, windows, and wall-mounted items.',
+        icon: { kind: 'url', src: '/icons/wall.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 10,
+    },
+    mcp: {
+        description: 'A wall segment defined by start + end points, with optional curve sagitta.',
+    },
+};

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

@@ -0,0 +1,13 @@
+import { type FloorplanAffordance, type WallNode } from '@pascal-app/core';
+/**
+ * Wall curve sagitta drag — 1:1 port of the legacy
+ * `handleWallCurvePointerDown` + commit flow. Drag projects the pointer
+ * onto the chord normal to compute a `curveOffset`, snapped to the
+ * grid step, clamped to `getMaxWallCurveOffset`,
+ * normalized via `normalizeWallCurveOffset`. Same single-undo dance as
+ * the move-endpoint affordance — the dispatcher handles snapshot /
+ * pause / resume around `apply`.
+ */
+export declare const wallCurveAffordance: FloorplanAffordance<WallNode>;
+export declare const wallMoveEndpointAffordance: FloorplanAffordance<WallNode>;
+//# sourceMappingURL=floorplan-affordances.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/wall/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,mBAAmB,EAQxB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAoFzB;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,EAAE,mBAAmB,CAAC,QAAQ,CAuD7D,CAAA;AAED,eAAO,MAAM,0BAA0B,EAAE,mBAAmB,CAAC,QAAQ,CA2JpE,CAAA"}

package/dist/wall/floorplan-affordances.js

@@ -0,0 +1,241 @@
+import { getMaxWallCurveOffset, getWallChordFrame, normalizeWallCurveOffset, runAsSingleSceneHistoryStep, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { alignFloorplanDraftPoint, getSegmentGridStep, isAlignmentGuideActive, isAngleSnapActive, isMagneticSnapActive, isSegmentLongEnough, resolveEndpointWallSplit, snapBuildingLocalToWorldGrid, snapScalarToGrid, snapWallDraftPoint, useAlignmentGuides, } from '@pascal-app/editor';
+function pointsEqual(a, b) {
+    return a[0] === b[0] && a[1] === b[1];
+}
+function collectLevelWalls(nodes, excludeWallId) {
+    const out = [];
+    for (const node of Object.values(nodes)) {
+        if (node?.type === 'wall' && node.id !== excludeWallId)
+            out.push(node);
+    }
+    return out;
+}
+function collectLinkedWalls(nodes, draggedWallId, originalStart, originalEnd) {
+    const linked = [];
+    for (const node of Object.values(nodes)) {
+        if (node?.type !== 'wall')
+            continue;
+        if (node.id === draggedWallId)
+            continue;
+        const wall = node;
+        if (pointsEqual(wall.start, originalStart) ||
+            pointsEqual(wall.start, originalEnd) ||
+            pointsEqual(wall.end, originalStart) ||
+            pointsEqual(wall.end, originalEnd)) {
+            linked.push({
+                id: wall.id,
+                start: [...wall.start],
+                end: [...wall.end],
+            });
+        }
+    }
+    return linked;
+}
+/**
+ * Wall curve sagitta drag — 1:1 port of the legacy
+ * `handleWallCurvePointerDown` + commit flow. Drag projects the pointer
+ * onto the chord normal to compute a `curveOffset`, snapped to the
+ * grid step, clamped to `getMaxWallCurveOffset`,
+ * normalized via `normalizeWallCurveOffset`. Same single-undo dance as
+ * the move-endpoint affordance — the dispatcher handles snapshot /
+ * pause / resume around `apply`.
+ */
+export const wallCurveAffordance = {
+    start({ node }) {
+        // Chord frame is fixed for the duration of the drag — only the
+        // pointer projection along its normal changes.
+        const chord = getWallChordFrame(node);
+        const maxOffset = getMaxWallCurveOffset(node);
+        const wallId = node.id;
+        let lastCurveOffset = node.curveOffset ?? 0;
+        return {
+            affectedIds: [node.id],
+            apply({ planPoint }) {
+                const snapStep = getSegmentGridStep();
+                // World-grid snap so a rotated building doesn't drag the curve
+                // handle off the visible grid.
+                const [x, y] = snapBuildingLocalToWorldGrid([planPoint[0], planPoint[1]], snapStep);
+                // Signed projection of (snappedPoint - chord midpoint) onto the
+                // chord normal. Legacy negates because the SVG y-axis flips
+                // relative to plan y; the registry layer doesn't apply that flip
+                // so the projection runs against the same normal the 3D tool
+                // uses (which also has no flip). The result matches the 3D port
+                // in `nodes/src/wall/curve-tool.tsx`.
+                const offsetFromMidpoint = -((x - chord.midpoint.x) * chord.normal.x +
+                    (y - chord.midpoint.y) * chord.normal.y);
+                const snappedOffset = snapScalarToGrid(offsetFromMidpoint, snapStep);
+                const nextCurveOffset = normalizeWallCurveOffset(node, Math.max(-maxOffset, Math.min(maxOffset, snappedOffset)));
+                lastCurveOffset = nextCurveOffset;
+                // Publish the curve preview as a live override so renderers see
+                // it without zustand churn. Mark the wall dirty so `WallSystem`
+                // rebuilds the geometry next frame using the override-merged
+                // node.
+                useLiveNodeOverrides.getState().set(wallId, { curveOffset: nextCurveOffset });
+                useScene.getState().markDirty(wallId);
+            },
+            canCommit() {
+                // Curve drag is always commit-eligible — the offset is already
+                // clamped + normalized so we never end up in an invalid state.
+                return true;
+            },
+            commit() {
+                // Atomic, tracked write of the final curve offset, then drop
+                // the override so the scene state is the single source of
+                // truth again.
+                useScene.getState().updateNodes([{ id: wallId, data: { curveOffset: lastCurveOffset } }]);
+                useLiveNodeOverrides.getState().clear(wallId);
+            },
+        };
+    },
+};
+export const wallMoveEndpointAffordance = {
+    start({ node, payload, nodes }) {
+        const { endpoint } = payload;
+        const fixedPoint = endpoint === 'start' ? [...node.end] : [...node.start];
+        const originalStart = [...node.start];
+        const originalEnd = [...node.end];
+        const linkedWalls = collectLinkedWalls(nodes, node.id, originalStart, originalEnd);
+        const affectedIds = [node.id, ...linkedWalls.map((w) => w.id)];
+        // Remember the latest preview so `commit()` can write it tracked.
+        let lastPrimaryStart = originalStart;
+        let lastPrimaryEnd = originalEnd;
+        let lastLinkedUpdates = [];
+        return {
+            affectedIds,
+            apply({ planPoint, modifiers }) {
+                // Re-collect walls every tick so the snap pipeline sees fresh
+                // positions (matters when the user releases + re-grabs without
+                // unmounting the layer). Snap reads from scene — which holds
+                // the pre-drag positions throughout — so the linked-wall snap
+                // targets stay anchored to where corners *were*, exactly like
+                // the legacy flow.
+                const sceneNodes = useScene.getState().nodes;
+                const walls = collectLevelWalls(sceneNodes, node.id);
+                // The grid step follows the active snapping mode (`getSegmentGridStep()`
+                // is 0 outside grid mode), so `'lines' / 'angles' / 'off'` no longer
+                // force a grid snap the mode chip says is inactive. In `'angles'` mode
+                // the endpoint angle-locks off the fixed corner (free length), matching
+                // the draft tool — the angle path ignores the `gridSnap` override.
+                const angleLocked = isAngleSnapActive();
+                const snapped = snapWallDraftPoint({
+                    point: planPoint,
+                    walls,
+                    ignoreWallIds: [node.id],
+                    start: angleLocked ? fixedPoint : undefined,
+                    angleSnap: angleLocked,
+                    magnetic: isMagneticSnapActive(),
+                    gridSnap: (p) => snapBuildingLocalToWorldGrid(p, getSegmentGridStep()),
+                });
+                // Figma-style alignment on the dragged corner — snaps it onto another
+                // object's edge / wall face and publishes a guide. The guide is
+                // DISPLAYED in every mode except Off (isAlignmentGuideActive); the
+                // magnetic pull onto it is applied only in 'lines' mode
+                // (isMagneticSnapActive), like the draft tool does. The dragged wall and
+                // its linked siblings (which cascade with the corner) are excluded from
+                // the candidate pool. Alt is detach, NOT bypass.
+                const aligned = alignFloorplanDraftPoint(snapped, {
+                    applySnap: isMagneticSnapActive(),
+                    bypass: !isAlignmentGuideActive(),
+                    excludeIds: [node.id, ...linkedWalls.map((w) => w.id)],
+                });
+                const primaryStart = endpoint === 'start' ? aligned : fixedPoint;
+                const primaryEnd = endpoint === 'end' ? aligned : fixedPoint;
+                // ALT detaches: the linked walls keep their original endpoints,
+                // and only the dragged wall moves.
+                const linkedUpdates = modifiers.altKey
+                    ? []
+                    : linkedWalls.map((w) => ({
+                        id: w.id,
+                        start: pointsEqual(w.start, originalStart)
+                            ? primaryStart
+                            : pointsEqual(w.start, originalEnd)
+                                ? primaryEnd
+                                : w.start,
+                        end: pointsEqual(w.end, originalStart)
+                            ? primaryStart
+                            : pointsEqual(w.end, originalEnd)
+                                ? primaryEnd
+                                : w.end,
+                    }));
+                lastPrimaryStart = primaryStart;
+                lastPrimaryEnd = primaryEnd;
+                lastLinkedUpdates = linkedUpdates;
+                // Publish overrides instead of writing to scene. WallSystem +
+                // 2D layer + sidebar panel merge these in. Marking dirty
+                // wakes the system's `useFrame` rebuild pass.
+                const overrides = useLiveNodeOverrides.getState();
+                const sceneState = useScene.getState();
+                overrides.set(node.id, { start: primaryStart, end: primaryEnd });
+                sceneState.markDirty(node.id);
+                if (modifiers.altKey) {
+                    // Attach→detach transition: linked walls dragged on earlier attached
+                    // ticks still carry overrides — drop them so their corners snap back
+                    // to the scene originals (untouched during the drag).
+                    for (const linked of linkedWalls) {
+                        if (overrides.get(linked.id)) {
+                            overrides.clear(linked.id);
+                            sceneState.markDirty(linked.id);
+                        }
+                    }
+                }
+                for (const upd of linkedUpdates) {
+                    overrides.set(upd.id, { start: upd.start, end: upd.end });
+                    sceneState.markDirty(upd.id);
+                }
+            },
+            canCommit() {
+                // Pointer-up always runs canCommit — drop the alignment guide here
+                // so it doesn't linger after a commit / reject.
+                useAlignmentGuides.getState().clear();
+                // The dragged wall must still be long enough at the preview
+                // length — checked against `lastPrimary*`, not scene, because
+                // scene holds baseline values until commit().
+                return isSegmentLongEnough(lastPrimaryStart, lastPrimaryEnd);
+            },
+            commit() {
+                // Atomic tracked write of the final endpoints, then drop the
+                // overrides so the scene state is the single source of truth
+                // again. Parity with the 3D move-endpoint tool: a drop on another
+                // wall's interior splits that host (create halves, migrate
+                // attachments, delete host) inside the same single history step as
+                // the endpoint write. Linked walls updated here share the drop point
+                // as an endpoint (a corner join, not a split) so they're excluded
+                // with the dragged wall; a zero-move drop skips the resolution
+                // entirely.
+                const movingPoint = endpoint === 'start' ? lastPrimaryStart : lastPrimaryEnd;
+                const originalMovingPoint = endpoint === 'start' ? originalStart : originalEnd;
+                runAsSingleSceneHistoryStep(useScene, () => {
+                    const resolved = pointsEqual(movingPoint, originalMovingPoint)
+                        ? null
+                        : resolveEndpointWallSplit({
+                            point: movingPoint,
+                            levelId: (node.parentId ?? null),
+                            ignoreWallIds: [node.id, ...lastLinkedUpdates.map((u) => String(u.id))],
+                        });
+                    const finalPoint = resolved ?? movingPoint;
+                    useScene.getState().updateNodes([
+                        {
+                            id: node.id,
+                            data: {
+                                start: endpoint === 'start' ? finalPoint : lastPrimaryStart,
+                                end: endpoint === 'end' ? finalPoint : lastPrimaryEnd,
+                            },
+                        },
+                        ...lastLinkedUpdates.map((u) => ({
+                            id: u.id,
+                            data: {
+                                start: pointsEqual(u.start, movingPoint) ? finalPoint : u.start,
+                                end: pointsEqual(u.end, movingPoint) ? finalPoint : u.end,
+                            },
+                        })),
+                    ]);
+                });
+                const overrides = useLiveNodeOverrides.getState();
+                overrides.clear(node.id);
+                for (const upd of lastLinkedUpdates)
+                    overrides.clear(upd.id);
+            },
+        };
+    },
+};

package/dist/wall/floorplan-move.d.ts

@@ -0,0 +1,32 @@
+import { type FloorplanMoveTarget, type WallNode } from '@pascal-app/core';
+/**
+ * 2D floor-plan move handler for wall.
+ *
+ * Mirrors the 3D `MoveWallTool` junction-plan behavior so dragging a
+ * wall in the floor plan produces the same scene topology as dragging
+ * it in 3D: linked corners cascade, same-direction collapsed walls
+ * delete, off-axis branches stay rectilinear with a new bridge wall
+ * inserted between the original and new corner.
+ *
+ * Tick (`apply`) — publishes per-frame `{ start, end }` overrides to
+ * `useLiveNodeOverrides` for the moved wall + every linked wall.
+ * `useScene` stays at the pre-drag values throughout the drag; the
+ * `WallSystem` and the 2D floor-plan layer fold the overrides in when
+ * reading endpoints, so the visual preview updates without churning
+ * zustand. Bridge creates and wall deletes are still deferred to
+ * commit so the live preview doesn't churn the scene graph either.
+ *
+ * Commit (`commit`) — recomputes the plan at the final cursor position
+ * and emits one atomic `applyNodeChanges` covering the moved walls,
+ * the bridge wall creates, and the collapsed wall deletes — so a
+ * single Ctrl-Z rolls the entire operation back. Clears the live
+ * overrides after the write lands so the system reads from the new
+ * committed scene state.
+ *
+ * Auto-slab live preview and ghost bridge SVG previews — visible in
+ * the 3D tool — are deliberately deferred. Slab polygons re-derive on
+ * commit through the normal scene reactions; bridges appear at commit
+ * time. Follow-up work to surface them mid-drag is tracked separately.
+ */
+export declare const wallFloorplanMoveTarget: FloorplanMoveTarget<WallNode>;
+//# sourceMappingURL=floorplan-move.d.ts.map

package/dist/wall/floorplan-move.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/wall/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,mBAAmB,EAOxB,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAmBzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,QAAQ,CAiRjE,CAAA"}