@pascal-app/nodes 0.1.1

package/dist/fence/definition.js

@@ -0,0 +1,281 @@
+import { getFenceControlHandle, isSplineFence, } from '@pascal-app/core';
+import { buildFenceFloorplan } from './floorplan';
+import { fenceControlPointAffordance, fenceCurveAffordance, fenceMoveEndpointAffordance, fenceTangentAffordance, } from './floorplan-affordances';
+import { fenceFloorplanMoveTarget } from './floorplan-move';
+import { buildFenceGeometry } from './geometry';
+import { fencePaint } from './paint';
+import { fenceParametrics } from './parametrics';
+import { FenceNode } from './schema';
+import { fenceSlots } from './slots';
+const SIDE_HANDLE_OFFSET = 0.27;
+const SIDE_HANDLE_MIN_OFFSET = 0.33;
+const SIDE_HANDLE_TOP_INSET = 0.08;
+const SIDE_HANDLE_MIN_HEIGHT = 0.4;
+const HEIGHT_HANDLE_OFFSET = 0.45;
+const MIN_FENCE_HEIGHT = 0.3;
+function fenceMidpointFrame(n) {
+    const dx = n.end[0] - n.start[0];
+    const dz = n.end[1] - n.start[1];
+    const len = Math.max(Math.hypot(dx, dz), 1e-6);
+    return {
+        midX: (n.start[0] + n.end[0]) / 2,
+        midZ: (n.start[1] + n.end[1]) / 2,
+        normalX: -dz / len,
+        normalZ: dx / len,
+    };
+}
+// Side-move arrows: click to hand the fence to its move tool. Same shape
+// as wall — front + back faces, positioned past the fence thickness near
+// the top so they don't compete with endpoint pickers in the floating
+// menu (which is where fence endpoint move lives today).
+function fenceSideMoveHandle(side) {
+    const sign = side === 'front' ? 1 : -1;
+    return {
+        kind: 'tap-action',
+        onActivate: (node, _scene, editor) => editor.engageMove(node),
+        placement: {
+            position: (n) => {
+                const { midX, midZ, normalX, normalZ } = fenceMidpointFrame(n);
+                const offset = Math.max((n.thickness ?? 0.1) / 2 + SIDE_HANDLE_OFFSET, SIDE_HANDLE_MIN_OFFSET);
+                const h = n.height ?? 1.8;
+                const handleY = Math.max(h - SIDE_HANDLE_TOP_INSET, SIDE_HANDLE_MIN_HEIGHT);
+                return [midX + sign * normalX * offset, handleY, midZ + sign * normalZ * offset];
+            },
+            rotationY: (n) => {
+                const { normalX, normalZ } = fenceMidpointFrame(n);
+                return Math.atan2(-sign * normalZ, sign * normalX);
+            },
+        },
+        // The move itself is constrained by `MoveFenceTool`; keep the visual as a
+        // one-direction chevron instead of the generic four-way move cross.
+        cursor: 'ew-resize',
+    };
+}
+// Height arrow — anchored at the floor (Y=0), grows upward. Sits over
+// the fence midpoint at the top edge with enough clearance to clear the
+// side-move arrows that hug the rail. `rotationY` orients the chevron's
+// broad face along the fence's perpendicular (same direction the front
+// side-move arrow points), so the chevron reads frontally when viewing
+// the fence from either side rather than going edge-on.
+function fenceHeightHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'min',
+        min: MIN_FENCE_HEIGHT,
+        // Drives the floating dimension pill (H · L · T) and suppresses the
+        // arrow's own inline chip, matching the wall height handle.
+        measureLabel: 'height',
+        currentValue: (n) => n.height ?? 1.8,
+        apply: (_n, newHeight) => ({ height: newHeight }),
+        placement: {
+            position: (n) => {
+                const { midX, midZ } = fenceMidpointFrame(n);
+                return [midX, (n.height ?? 1.8) + HEIGHT_HANDLE_OFFSET, midZ];
+            },
+            rotationY: (n) => {
+                const { normalX, normalZ } = fenceMidpointFrame(n);
+                return Math.atan2(-normalZ, normalX);
+            },
+        },
+    };
+}
+// Corner picker — dashed vertical leader + billboarded hex disc at the
+// endpoint. Tap engages the endpoint-move flow (sister to the wall
+// pickers). nodeHeight controls the leader's vertical reach so the
+// dashes span the full fence height.
+function fenceCornerPicker(endpoint) {
+    return {
+        kind: 'tap-action',
+        shape: 'corner-picker',
+        cursor: 'move',
+        nodeHeight: (n) => n.height ?? 1.8,
+        onActivate: (node, _scene, editor) => editor.engageEndpointMove(node, endpoint),
+        placement: {
+            position: (n) => {
+                const corner = endpoint === 'start' ? n.start : n.end;
+                return [corner[0], 0, corner[1]];
+            },
+        },
+    };
+}
+const TANGENT_HANDLE_ARM_SCALE = 3;
+function fenceControlPointPicker(index) {
+    return {
+        kind: 'tap-action',
+        shape: 'corner-picker',
+        cursor: 'move',
+        nodeHeight: (n) => n.height ?? 1.8,
+        onActivate: (node, _scene, editor) => editor.engageControlPointMove(node, index),
+        placement: {
+            position: (n) => {
+                const point = n.path?.[index] ?? n.start;
+                return [point[0], 0, point[1]];
+            },
+        },
+    };
+}
+function fenceTangentPicker(index, side) {
+    const sign = side === 'out' ? 1 : -1;
+    return {
+        kind: 'tap-action',
+        shape: 'corner-picker',
+        round: true,
+        cursor: 'move',
+        nodeHeight: (n) => (n.height ?? 1.8) * 0.6,
+        onActivate: (node, _scene, editor) => editor.engageTangentMove(node, index, side),
+        placement: {
+            position: (n) => {
+                const point = n.path?.[index] ?? n.start;
+                if (!n.path)
+                    return [point[0], 0, point[1]];
+                const handle = getFenceControlHandle(n.path, n.tangents, index);
+                return [
+                    point[0] + sign * handle.x * TANGENT_HANDLE_ARM_SCALE,
+                    0,
+                    point[1] + sign * handle.y * TANGENT_HANDLE_ARM_SCALE,
+                ];
+            },
+        },
+    };
+}
+const fenceHandles = (node) => {
+    if (isSplineFence(node) && node.path) {
+        return [
+            fenceHeightHandle(),
+            ...node.path.flatMap((_, index) => [
+                fenceControlPointPicker(index),
+                fenceTangentPicker(index, 'out'),
+                fenceTangentPicker(index, 'in'),
+            ]),
+        ];
+    }
+    return [
+        fenceSideMoveHandle('front'),
+        fenceSideMoveHandle('back'),
+        fenceHeightHandle(),
+        fenceCornerPicker('start'),
+        fenceCornerPicker('end'),
+    ];
+};
+/**
+ * Fence — Phase 5 batch kind. Stage B complete: `def.geometry` drives
+ * the rebuild via the generic `<GeometrySystem>`; `<ParametricNodeRenderer>`
+ * mounts the empty group. No per-kind renderer or system file.
+ *
+ * Capabilities:
+ *  - **No `movable`**: fence move is bespoke endpoint-drag. Capability-
+ *    driven dispatch keeps the legacy MoveFenceTool until the
+ *    affordance port (Stage D).
+ *  - `surfaces.sides`, `selectable`, `duplicable`, `deletable` standard.
+ *
+ * Relations: `linkedBy: 'endpoint-match'` for corner cascade.
+ */
+export const fenceDefinition = {
+    kind: 'fence',
+    snapProfile: 'structural',
+    schemaVersion: 1,
+    schema: FenceNode,
+    category: 'structure',
+    surfaceRole: 'wall',
+    defaults: () => ({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        start: [0, 0],
+        end: [3, 0],
+        height: 1.8,
+        thickness: 0.08,
+        baseHeight: 0.22,
+        postSpacing: 2,
+        postSize: 0.1,
+        topRailHeight: 0.04,
+        groundClearance: 0,
+        edgeInset: 0.015,
+        slatGap: 0.01,
+        postCap: 'pyramid',
+        baseStyle: 'grounded',
+        showInfill: true,
+        color: '#ffffff',
+        style: 'slat',
+    }),
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        surfaces: { sides: { faces: 'all' } },
+        duplicable: true,
+        deletable: true,
+        slots: (node) => fenceSlots(node),
+        paint: fencePaint,
+        // Placed by drawing the span with the two-click tool; a saved preset
+        // seeds its build parameters via `toolDefaults.fence` (see `tool.tsx`
+        // and `createFenceOnCurrentLevel`).
+        drawTool: true,
+    },
+    relations: {
+        linkedBy: 'endpoint-match',
+        cascadeDelete: 'none',
+    },
+    parametrics: fenceParametrics,
+    handles: fenceHandles,
+    // Stage D: kind-owned placement tool. Two-click flow (start → end)
+    // with live preview, length / angle HUD, snap to walls / fences /
+    // grid. Mounted by ToolManager when `useEditor.tool === 'fence'`
+    // via the registry's getRegistryTool() — falls back to the legacy
+    // tools[phase][tool] map when missing.
+    tool: () => import('./tool'),
+    // Stage B: pure geometry function. Generic <GeometrySystem> rebuilds
+    // on dirtyNodes; <ParametricNodeRenderer> mounts the empty group.
+    // `renderer` + `system` fields dropped along with their files.
+    geometry: buildFenceGeometry,
+    // Stage C: floor-plan rendering. FloorplanRegistryLayer iterates kinds
+    // with `floorplan` set and renders via FloorplanGeometryRenderer.
+    // Legacy `floorplanFenceEntries` short-circuits to [] when fence is
+    // registered (see floorplan-panel.tsx).
+    floorplan: buildFenceFloorplan,
+    // 2D drag affordances — sister to `actions/move-endpoint.ts`. The 3D
+    // DragAction drives R3F grid events through `createDragSession`; these
+    // drive SVG pointer events through the floor-plan registry
+    // dispatcher's snapshot + single-undo dance. `move-endpoint` keeps the
+    // legacy fence endpoint semantics; `curve` mirrors the wall sagitta
+    // drag (publishes `curveOffset` overrides per tick, commits on
+    // pointer-up).
+    floorplanAffordances: {
+        'move-endpoint': fenceMoveEndpointAffordance,
+        'move-control-point': fenceControlPointAffordance,
+        'move-tangent': fenceTangentAffordance,
+        curve: fenceCurveAffordance,
+    },
+    // Body move on the fence is driven by the two `move-arrow` chevrons
+    // the floor-plan builder emits at the midpoint. Pointer-down enters
+    // movingNode mode; the registry overlay routes through this target
+    // for the live preview + commit. Translates the dragged fence and
+    // cascades the shared endpoints of any linked fences, ALT detaches.
+    floorplanMoveTarget: fenceFloorplanMoveTarget,
+    // Stage D — all four fence drag-affordances live in this folder.
+    // curve / move-endpoint / move are 1:1 ports of the legacy tools
+    // (same snap pipeline, same history dance, same cursor render),
+    // relocated under `@pascal-app/nodes` and dispatched via
+    // `def.affordanceTools`. Placement lives in `def.tool` (see below).
+    affordanceTools: {
+        curve: () => import('./curve-tool'),
+        'move-endpoint': () => import('./move-endpoint-tool'),
+        'move-control-point': () => import('./move-control-point-tool'),
+        'move-tangent': () => import('./move-tangent-tool'),
+        move: () => import('./move-tool'),
+    },
+    toolHints: [
+        { key: 'Left click', label: 'Set fence start / end' },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+    presentation: {
+        label: 'Fence',
+        description: 'A straight or curved fence segment with configurable posts and infill.',
+        icon: { kind: 'url', src: '/icons/fence.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 20,
+    },
+    mcp: {
+        description: 'A fence segment defined by start + end points, with optional curve sagitta.',
+    },
+};

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

@@ -0,0 +1,31 @@
+import { type FenceNode, type FloorplanAffordance } from '@pascal-app/core';
+/**
+ * Fence curve sagitta drag — 1:1 mirror of `wallCurveAffordance`. Drag
+ * projects the pointer onto the chord normal to compute `curveOffset`,
+ * snaps to grid when that mode is active, clamps to `getMaxWallCurveOffset`,
+ * normalizes via `normalizeWallCurveOffset`. Same single-undo dance — the
+ * dispatcher handles snapshot / pause / resume around `apply`. Lives in
+ * the same file as the endpoint affordance to keep the two fence
+ * floor-plan drags side-by-side (both publish to `useLiveNodeOverrides`,
+ * both committed on pointer-up).
+ */
+export declare const fenceCurveAffordance: FloorplanAffordance<FenceNode>;
+/**
+ * Spline control-point drag — reshapes one point of the fence `path`. Grid
+ * snap follows the active mode; start/end stay pinned to the path ends so endpoint-
+ * dependent code stays valid. Publishes a live override per tick, commits the
+ * final path as one tracked change. No linked-fence cascade: a spline's shape
+ * is self-contained.
+ */
+export declare const fenceControlPointAffordance: FloorplanAffordance<FenceNode>;
+/**
+ * Spline tangent-handle drag — bends the curve through one control point. The
+ * dragged end (in / out) gives the OUT-handle vector (negated for the IN end);
+ * the IN handle is always the mirror so the curve stays smooth (symmetric).
+ * The visual arm is `TANGENT_HANDLE_ARM_SCALE`× the stored vector, so we divide
+ * that factor out before storing. Writes `tangents[index]`, padding the array
+ * to the path length with nulls so untouched points keep their auto tangent.
+ */
+export declare const fenceTangentAffordance: FloorplanAffordance<FenceNode>;
+export declare const fenceMoveEndpointAffordance: FloorplanAffordance<FenceNode>;
+//# sourceMappingURL=floorplan-affordances.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/fence/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,SAAS,EACd,KAAK,mBAAmB,EAQzB,MAAM,kBAAkB,CAAA;AAoFzB;;;;;;;;;GASG;AACH,eAAO,MAAM,oBAAoB,EAAE,mBAAmB,CAAC,SAAS,CAsC/D,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,2BAA2B,EAAE,mBAAmB,CAAC,SAAS,CAqCtE,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,EAAE,mBAAmB,CAAC,SAAS,CAoDjE,CAAA;AAED,eAAO,MAAM,2BAA2B,EAAE,mBAAmB,CAAC,SAAS,CAkFtE,CAAA"}

package/dist/fence/floorplan-affordances.js

@@ -0,0 +1,271 @@
+import { getMaxWallCurveOffset, getWallChordFrame, normalizeWallCurveOffset, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { alignFloorplanDraftPoint, getSegmentGridStep, isAlignmentGuideActive, isAngleSnapActive, isGridSnapActive, isMagneticSnapActive, isSegmentLongEnough, snapBuildingLocalToWorldGrid, snapFenceDraftPoint, snapScalarToGrid, useAlignmentGuides, } from '@pascal-app/editor';
+/**
+ * Floor-plan 2D drag affordances for fence — sister to the 3D
+ * `actions/move-endpoint.ts` `DragAction`. Same legacy interaction
+ * (endpoint snap pipeline + linked-fence cascade via `endpoint-match`
+ * with an epsilon, ALT-detach), driven from SVG pointer events instead
+ * of R3F grid events.
+ *
+ * Why not share the `DragAction`? The 3D code goes through
+ * `createDragSession` which assumes a `SceneApi`-style helper bag
+ * (snapshot, restoreAll, pauseHistory, resumeHistory). The 2D registry
+ * layer owns those semantics directly via the dispatcher's snapshot +
+ * pause/resume dance, so the affordance only needs the pure mutation
+ * logic. The shape is intentionally close to the legacy fence drag —
+ * 1:1 behaviorally.
+ */
+const LINKED_FENCE_ENDPOINT_EPSILON = 0.025;
+// Must match the floorplan builder's TANGENT_HANDLE_ARM_SCALE: the on-screen
+// arm is this many times the raw tangent vector, so dividing the dragged
+// offset back out recovers the stored tangent.
+const TANGENT_HANDLE_ARM_SCALE = 3;
+function pointsNearlyEqual(a, b) {
+    return (Math.abs(a[0] - b[0]) <= LINKED_FENCE_ENDPOINT_EPSILON &&
+        Math.abs(a[1] - b[1]) <= LINKED_FENCE_ENDPOINT_EPSILON);
+}
+function collectLevel(nodes, parentId) {
+    const walls = [];
+    const fences = [];
+    for (const node of Object.values(nodes)) {
+        if (!node)
+            continue;
+        if ((node.parentId ?? null) !== parentId)
+            continue;
+        if (node.type === 'wall')
+            walls.push(node);
+        else if (node.type === 'fence')
+            fences.push(node);
+    }
+    return { walls, fences };
+}
+function collectLinkedFences(fences, draggedFenceId, linkedPoint) {
+    const out = [];
+    for (const fence of fences) {
+        if (fence.id === draggedFenceId)
+            continue;
+        if (!pointsNearlyEqual(fence.start, linkedPoint) && !pointsNearlyEqual(fence.end, linkedPoint))
+            continue;
+        out.push({
+            id: fence.id,
+            start: [fence.start[0], fence.start[1]],
+            end: [fence.end[0], fence.end[1]],
+        });
+    }
+    return out;
+}
+/**
+ * Fence curve sagitta drag — 1:1 mirror of `wallCurveAffordance`. Drag
+ * projects the pointer onto the chord normal to compute `curveOffset`,
+ * snaps to grid when that mode is active, clamps to `getMaxWallCurveOffset`,
+ * normalizes via `normalizeWallCurveOffset`. Same single-undo dance — the
+ * dispatcher handles snapshot / pause / resume around `apply`. Lives in
+ * the same file as the endpoint affordance to keep the two fence
+ * floor-plan drags side-by-side (both publish to `useLiveNodeOverrides`,
+ * both committed on pointer-up).
+ */
+export const fenceCurveAffordance = {
+    start({ node }) {
+        const chord = getWallChordFrame(node);
+        const maxOffset = getMaxWallCurveOffset(node);
+        const fenceId = node.id;
+        let lastCurveOffset = node.curveOffset ?? 0;
+        return {
+            affectedIds: [node.id],
+            apply({ planPoint, modifiers }) {
+                const snapStep = isGridSnapActive() ? getSegmentGridStep() : 0;
+                const x = snapStep > 0 ? snapScalarToGrid(planPoint[0], snapStep) : planPoint[0];
+                const y = snapStep > 0 ? snapScalarToGrid(planPoint[1], snapStep) : planPoint[1];
+                const offsetFromMidpoint = -((x - chord.midpoint.x) * chord.normal.x +
+                    (y - chord.midpoint.y) * chord.normal.y);
+                const snappedOffset = snapStep > 0 ? snapScalarToGrid(offsetFromMidpoint, snapStep) : offsetFromMidpoint;
+                const nextCurveOffset = normalizeWallCurveOffset(node, Math.max(-maxOffset, Math.min(maxOffset, snappedOffset)));
+                lastCurveOffset = nextCurveOffset;
+                useLiveNodeOverrides.getState().set(fenceId, { curveOffset: nextCurveOffset });
+                useScene.getState().markDirty(fenceId);
+            },
+            canCommit() {
+                return true;
+            },
+            commit() {
+                useScene.getState().updateNodes([{ id: fenceId, data: { curveOffset: lastCurveOffset } }]);
+                useLiveNodeOverrides.getState().clear(fenceId);
+            },
+        };
+    },
+};
+/**
+ * Spline control-point drag — reshapes one point of the fence `path`. Grid
+ * snap follows the active mode; start/end stay pinned to the path ends so endpoint-
+ * dependent code stays valid. Publishes a live override per tick, commits the
+ * final path as one tracked change. No linked-fence cascade: a spline's shape
+ * is self-contained.
+ */
+export const fenceControlPointAffordance = {
+    start({ node, payload }) {
+        const { index } = payload;
+        const fenceId = node.id;
+        const originalPath = (node.path ?? []).map((p) => [p[0], p[1]]);
+        let lastPath = originalPath;
+        const buildPatch = (point) => {
+            const nextPath = originalPath.map((p, i) => (i === index ? point : p));
+            lastPath = nextPath;
+            const patch = { path: nextPath };
+            if (index === 0)
+                patch.start = point;
+            if (index === nextPath.length - 1)
+                patch.end = point;
+            return patch;
+        };
+        return {
+            affectedIds: [fenceId],
+            apply({ planPoint, modifiers }) {
+                const snapStep = isGridSnapActive() ? getSegmentGridStep() : 0;
+                const x = snapStep > 0 ? snapScalarToGrid(planPoint[0], snapStep) : planPoint[0];
+                const y = snapStep > 0 ? snapScalarToGrid(planPoint[1], snapStep) : planPoint[1];
+                useLiveNodeOverrides.getState().set(fenceId, buildPatch([x, y]));
+                useScene.getState().markDirty(fenceId);
+            },
+            canCommit() {
+                return lastPath.length >= 2;
+            },
+            commit() {
+                const data = { path: lastPath };
+                data.start = lastPath[0];
+                data.end = lastPath[lastPath.length - 1];
+                useScene.getState().updateNodes([{ id: fenceId, data }]);
+                useLiveNodeOverrides.getState().clear(fenceId);
+            },
+        };
+    },
+};
+/**
+ * Spline tangent-handle drag — bends the curve through one control point. The
+ * dragged end (in / out) gives the OUT-handle vector (negated for the IN end);
+ * the IN handle is always the mirror so the curve stays smooth (symmetric).
+ * The visual arm is `TANGENT_HANDLE_ARM_SCALE`× the stored vector, so we divide
+ * that factor out before storing. Writes `tangents[index]`, padding the array
+ * to the path length with nulls so untouched points keep their auto tangent.
+ */
+export const fenceTangentAffordance = {
+    start({ node, payload }) {
+        const { index, side } = payload;
+        const fenceId = node.id;
+        const path = node.path ?? [];
+        const anchor = path[index] ?? node.start;
+        let lastTangents = (node.tangents ?? []).map((t) => t ? [t[0], t[1]] : null);
+        const buildTangents = (vec) => {
+            const next = Array.from({ length: path.length }, (_, i) => lastTangents[i] ?? null);
+            next[index] = vec;
+            lastTangents = next;
+            return next;
+        };
+        return {
+            affectedIds: [fenceId],
+            apply({ planPoint, modifiers }) {
+                const snapStep = isGridSnapActive() ? getSegmentGridStep() : 0;
+                const px = snapStep > 0 ? snapScalarToGrid(planPoint[0], snapStep) : planPoint[0];
+                const py = snapStep > 0 ? snapScalarToGrid(planPoint[1], snapStep) : planPoint[1];
+                // Arm vector from the anchor to the dragged handle, in plan meters.
+                let armX = px - anchor[0];
+                let armY = py - anchor[1];
+                // The IN end is the mirror, so its drag describes the negated OUT vector.
+                if (side === 'in') {
+                    armX = -armX;
+                    armY = -armY;
+                }
+                const vec = [
+                    armX / TANGENT_HANDLE_ARM_SCALE,
+                    armY / TANGENT_HANDLE_ARM_SCALE,
+                ];
+                useLiveNodeOverrides.getState().set(fenceId, { tangents: buildTangents(vec) });
+                useScene.getState().markDirty(fenceId);
+            },
+            canCommit() {
+                return true;
+            },
+            commit() {
+                useScene
+                    .getState()
+                    .updateNodes([{ id: fenceId, data: { tangents: lastTangents } }]);
+                useLiveNodeOverrides.getState().clear(fenceId);
+            },
+        };
+    },
+};
+export const fenceMoveEndpointAffordance = {
+    start({ node, payload, nodes }) {
+        const { endpoint } = payload;
+        const originalStart = [node.start[0], node.start[1]];
+        const originalEnd = [node.end[0], node.end[1]];
+        const originalMovingPoint = endpoint === 'start' ? originalStart : originalEnd;
+        const fixedPoint = endpoint === 'start' ? originalEnd : originalStart;
+        const parentId = node.parentId ?? null;
+        const { walls, fences } = collectLevel(nodes, parentId);
+        const linkedOriginals = collectLinkedFences(fences, node.id, originalMovingPoint);
+        const affectedIds = [node.id, ...linkedOriginals.map((l) => l.id)];
+        return {
+            affectedIds,
+            apply({ planPoint, modifiers }) {
+                // Re-collect siblings each tick: the user might be dragging a
+                // fence whose sibling positions changed (the dragged fence
+                // itself is excluded via `ignoreFenceIds`).
+                const sceneNodes = useScene.getState().nodes;
+                const { walls: nextWalls, fences: nextFences } = collectLevel(sceneNodes, parentId);
+                // 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 — matching the wall
+                // endpoint affordance. In `'angles'` mode the endpoint angle-locks off
+                // the fixed corner (free length); the angle path ignores `gridSnap`.
+                const angleLocked = isAngleSnapActive();
+                const snapped = snapFenceDraftPoint({
+                    point: planPoint,
+                    walls: nextWalls,
+                    fences: nextFences,
+                    ignoreFenceIds: [node.id],
+                    start: angleLocked ? fixedPoint : undefined,
+                    angleSnap: angleLocked,
+                    magnetic: isMagneticSnapActive(),
+                    gridSnap: (p) => snapBuildingLocalToWorldGrid(p, getSegmentGridStep()),
+                });
+                // Figma-style alignment on the dragged endpoint — snaps it onto
+                // another object's edge / wall face and publishes a guide, matching
+                // the 3D fence endpoint action. The guide is DISPLAYED in every mode
+                // except Off (isAlignmentGuideActive); the magnetic pull onto it is
+                // applied only in 'lines' mode (isMagneticSnapActive). The dragged fence
+                // and its linked siblings (which cascade with the endpoint) are excluded
+                // from the candidate pool. Alt is reserved for detach here, NOT bypass.
+                const aligned = alignFloorplanDraftPoint(snapped, {
+                    applySnap: isMagneticSnapActive(),
+                    bypass: !isAlignmentGuideActive(),
+                    excludeIds: [node.id, ...linkedOriginals.map((l) => l.id)],
+                });
+                const nextStart = endpoint === 'start' ? aligned : fixedPoint;
+                const nextEnd = endpoint === 'end' ? aligned : fixedPoint;
+                const linkedUpdates = modifiers.altKey
+                    ? []
+                    : linkedOriginals.map((l) => ({
+                        id: l.id,
+                        start: pointsNearlyEqual(l.start, originalMovingPoint) ? aligned : l.start,
+                        end: pointsNearlyEqual(l.end, originalMovingPoint) ? aligned : l.end,
+                    }));
+                useScene.getState().updateNodes([
+                    { id: node.id, data: { start: nextStart, end: nextEnd } },
+                    ...linkedUpdates.map((u) => ({
+                        id: u.id,
+                        data: { start: u.start, end: u.end },
+                    })),
+                ]);
+            },
+            canCommit() {
+                // Pointer-up always runs canCommit — drop the alignment guide here
+                // so it doesn't linger after a commit / reject.
+                useAlignmentGuides.getState().clear();
+                const finalFence = useScene.getState().nodes[node.id];
+                return (!!finalFence &&
+                    finalFence.type === 'fence' &&
+                    isSegmentLongEnough(finalFence.start, finalFence.end));
+            },
+        };
+    },
+};

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

@@ -0,0 +1,10 @@
+import { type FenceNode, type FloorplanMoveTarget } from '@pascal-app/core';
+/**
+ * 2D floor-plan body move for fence. Mirrors `wallFloorplanMoveTarget`
+ * but without bridge-wall planning: fence corners cascade through
+ * shared endpoints, ALT detaches them, and there's no perpendicular
+ * branch logic to chase. Tick publishes endpoint overrides; commit
+ * folds them into a single tracked update.
+ */
+export declare const fenceFloorplanMoveTarget: FloorplanMoveTarget<FenceNode>;
+//# sourceMappingURL=floorplan-move.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/fence/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,SAAS,EACd,KAAK,mBAAmB,EAIzB,MAAM,kBAAkB,CAAA;AAuDzB;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,EAAE,mBAAmB,CAAC,SAAS,CAiJnE,CAAA"}