@pascal-app/nodes 0.1.1

package/dist/eyebrow-vent/tool.js

@@ -0,0 +1,111 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { EyebrowVentNode, emitter, sceneRegistry, useScene, } from '@pascal-app/core';
+import { triggerSFX } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useEffect, useMemo, useRef, useState } from 'react';
+import * as THREE from 'three';
+import { RoofAttachmentFallbackPreview } from '../shared/roof-attachment-fallback-preview';
+import { resolveRoofSegmentHit } from '../shared/roof-segment-hit';
+import { getAnalyticalNormal, getDownSlopeYaw, surfaceQuatFromNormal } from '../shared/roof-surface';
+import { clearRoofSurfacePlacementGuides, publishRoofSurfacePlacementGuides, roofSurfaceFootprintFromNode, } from '../shared/roof-surface-placement-guides';
+import { eyebrowVentDefinition } from './definition';
+import EyebrowVentPreview from './preview';
+const worldPoint = new THREE.Vector3();
+/**
+ * Eyebrow-vent placement tool. Mounts when the palette activates the
+ * eyebrow-vent kind; listens for `roof:*` events; on click commits a new
+ * `EyebrowVentNode` parented to the targeted segment with segment-local
+ * coordinates. Mirrors box-vent / cupola.
+ */
+const EyebrowVentTool = () => {
+    const activeBuildingId = useViewer((s) => s.selection.buildingId);
+    const setSelection = useViewer((s) => s.setSelection);
+    const [previewPos, setPreviewPos] = useState(null);
+    const [previewSurfaceQuat, setPreviewSurfaceQuat] = useState(null);
+    const [previewYaw, setPreviewYaw] = useState(0);
+    const [previewRotation, setPreviewRotation] = useState(0);
+    const lastSnapRef = useRef(null);
+    const previewNode = useMemo(() => EyebrowVentNode.parse({
+        ...eyebrowVentDefinition.defaults(),
+        name: 'Eyebrow Vent',
+        position: [0, 0, 0],
+        rotation: previewRotation,
+    }), [previewRotation]);
+    useEffect(() => {
+        if (!activeBuildingId)
+            return;
+        const worldToBuildingLocal = (wx, wy, wz) => {
+            const buildingObj = sceneRegistry.nodes.get(activeBuildingId);
+            if (!buildingObj)
+                return [wx, wy, wz];
+            worldPoint.set(wx, wy, wz);
+            buildingObj.worldToLocal(worldPoint);
+            return [worldPoint.x, worldPoint.y, worldPoint.z];
+        };
+        const updatePreview = (event) => {
+            const wx = event.position[0];
+            const wy = event.position[1];
+            const wz = event.position[2];
+            const sx = Math.round(wx * 20) / 20;
+            const sz = Math.round(wz * 20) / 20;
+            const prev = lastSnapRef.current;
+            if (event.nativeEvent?.shiftKey !== true && (!prev || prev[0] !== sx || prev[1] !== sz)) {
+                triggerSFX('sfx:grid-snap');
+                lastSnapRef.current = [sx, sz];
+            }
+            const hit = resolveRoofSegmentHit(event.node, wx, wy, wz);
+            if (!hit)
+                return;
+            const normal = getAnalyticalNormal(hit.localX, hit.localZ, hit.segment);
+            setPreviewSurfaceQuat(surfaceQuatFromNormal(normal, new THREE.Quaternion()));
+            setPreviewYaw((event.node.rotation ?? 0) + (hit.segment.rotation ?? 0));
+            setPreviewRotation(getDownSlopeYaw(hit.localX, hit.localZ, hit.segment));
+            setPreviewPos(worldToBuildingLocal(wx, wy, wz));
+            publishRoofSurfacePlacementGuides({
+                roof: event.node,
+                segment: hit.segment,
+                center: [hit.localX, hit.localY, hit.localZ],
+                footprint: roofSurfaceFootprintFromNode({
+                    ...previewNode,
+                    rotation: getDownSlopeYaw(hit.localX, hit.localZ, hit.segment),
+                }),
+            });
+            event.stopPropagation();
+        };
+        const onClick = (event) => {
+            const hit = resolveRoofSegmentHit(event.node, event.position[0], event.position[1], event.position[2]);
+            if (!hit)
+                return;
+            const state = useScene.getState();
+            const vent = EyebrowVentNode.parse({
+                ...eyebrowVentDefinition.defaults(),
+                name: 'Eyebrow Vent',
+                roofSegmentId: hit.segment.id,
+                position: [hit.localX, hit.localY, hit.localZ],
+                rotation: getDownSlopeYaw(hit.localX, hit.localZ, hit.segment),
+            });
+            state.createNode(vent, hit.segment.id);
+            state.dirtyNodes.add(hit.segment.id);
+            setSelection({ selectedIds: [vent.id] });
+            triggerSFX('sfx:item-place');
+            clearRoofSurfacePlacementGuides();
+            event.stopPropagation();
+        };
+        emitter.on('roof:move', updatePreview);
+        emitter.on('roof:enter', updatePreview);
+        emitter.on('roof:click', onClick);
+        return () => {
+            emitter.off('roof:move', updatePreview);
+            emitter.off('roof:enter', updatePreview);
+            emitter.off('roof:click', onClick);
+            clearRoofSurfacePlacementGuides();
+        };
+    }, [activeBuildingId, setSelection, previewNode]);
+    return (_jsxs(_Fragment, { children: [_jsx(RoofAttachmentFallbackPreview, { activeBuildingId: activeBuildingId, ghost: _jsx(EyebrowVentPreview, { node: previewNode, invalid: true }), onInvalidTarget: () => {
+                    setPreviewPos(null);
+                    setPreviewSurfaceQuat(null);
+                    clearRoofSurfacePlacementGuides();
+                } }), activeBuildingId && previewPos && previewSurfaceQuat && (_jsx("group", { position: previewPos, children: _jsx("group", { "rotation-y": previewYaw, children: _jsx("group", { quaternion: previewSurfaceQuat, children: _jsx(EyebrowVentPreview, { node: previewNode }) }) }) }))] }));
+};
+export default EyebrowVentTool;

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

@@ -0,0 +1,32 @@
+import { type AlignmentAnchor, type AnyNodeId, type DragAction, type FenceNode, type WallNode } from '@pascal-app/core';
+import { type FencePlanPoint } from '@pascal-app/editor';
+type LinkedFenceSnapshot = {
+    id: FenceNode['id'];
+    start: FencePlanPoint;
+    end: FencePlanPoint;
+};
+export type MoveFenceEndpointCtx = {
+    fenceId: AnyNodeId;
+    endpoint: 'start' | 'end';
+    originalStart: FencePlanPoint;
+    originalEnd: FencePlanPoint;
+    originalMovingPoint: FencePlanPoint;
+    fixedPoint: FencePlanPoint;
+    parentId: string | null;
+    linkedOriginals: LinkedFenceSnapshot[];
+    levelWalls: WallNode[];
+    levelFences: FenceNode[];
+    /** Alignment anchors (endpoints + midpoints) of every OTHER wall / fence on
+     *  the level (building-local), feeding the resolver. */
+    alignCandidates: AlignmentAnchor[];
+};
+export type MoveFenceEndpointDraft = {
+    movingPoint: FencePlanPoint;
+    start: FencePlanPoint;
+    end: FencePlanPoint;
+    linkedUpdates: LinkedFenceSnapshot[];
+    detached: boolean;
+};
+export declare const moveFenceEndpointDragAction: DragAction<MoveFenceEndpointCtx, MoveFenceEndpointDraft>;
+export {};
+//# sourceMappingURL=move-endpoint.d.ts.map

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

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

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

@@ -0,0 +1,201 @@
+import { collectAlignmentAnchors, resolveAlignment, useScene, } from '@pascal-app/core';
+import { isAlignmentGuideActive, isAngleSnapActive, isMagneticSnapActive, isSegmentLongEnough, snapFenceDraftPoint, useAlignmentGuides, } from '@pascal-app/editor';
+/**
+ * Phase 5 Stage D — move-fence-endpoint drag affordance.
+ *
+ * Pure orchestration of an endpoint drag:
+ *  - **begin**: snapshot originals (start / end / moving point / fixed
+ *    point), look up linked fences (any other fence in the same parent
+ *    whose start or end matches the moving point at activation time),
+ *    cache walls + fences at the level for snap targets.
+ *  - **preview**: snap the pointer (grid + 45° angle + wall/fence corner
+ *    + span snaps via `snapFenceDraftPoint`), compute next start / end
+ *    and the cascade of linked fence endpoint updates. Alt-key detaches
+ *    the cascade for this tick (legacy "detach endpoint" semantics).
+ *  - **apply**: writes the fence + linked fence endpoints into the
+ *    scene. Drag-session paused history captures originals; cascade
+ *    resolver fans dirty marks through `endpoint-match`.
+ *  - **commit**: requires `hasChanged` && `isSegmentLongEnough(next)`.
+ *    Performs the single-undo dance — revert to originals (snapshot),
+ *    resume history, re-apply final draft — so the entire drag is one
+ *    `Ctrl-Z` step. Returns false to reject; `createDragSession.cancel`
+ *    restores all touched nodes.
+ *  - **cancel**: nothing to do — `createDragSession.cancel`'s built-in
+ *    `scene.restoreAll()` puts every touched node back.
+ *
+ * Pure data — no React, no DOM. Tests drive it through
+ * `createDragSession` with a stub `SceneApi` + a `useScene` fixture
+ * pre-populated by the test.
+ */
+const LINKED_FENCE_ENDPOINT_EPSILON = 0.025;
+/** Figma-style alignment-snap threshold (meters), matching the wall / item
+ *  tools. */
+const ALIGNMENT_THRESHOLD_M = 0.08;
+function samePoint(a, b) {
+    return (Math.abs(a[0] - b[0]) <= LINKED_FENCE_ENDPOINT_EPSILON &&
+        Math.abs(a[1] - b[1]) <= LINKED_FENCE_ENDPOINT_EPSILON);
+}
+function snapshotLinked(fenceId, parentId, linkedPoint) {
+    const { nodes } = useScene.getState();
+    const out = [];
+    for (const node of Object.values(nodes)) {
+        if (node?.type !== 'fence')
+            continue;
+        if (node.id === fenceId)
+            continue;
+        if ((node.parentId ?? null) !== parentId)
+            continue;
+        if (!samePoint(node.start, linkedPoint) && !samePoint(node.end, linkedPoint))
+            continue;
+        out.push({
+            id: node.id,
+            start: [node.start[0], node.start[1]],
+            end: [node.end[0], node.end[1]],
+        });
+    }
+    return out;
+}
+function linkedCascade(linked, origin, next) {
+    return linked.map((l) => ({
+        id: l.id,
+        start: samePoint(l.start, origin) ? next : l.start,
+        end: samePoint(l.end, origin) ? next : l.end,
+    }));
+}
+export const moveFenceEndpointDragAction = {
+    begin: (input) => {
+        const fence = input.node;
+        if (!fence)
+            throw new Error('[moveFenceEndpointDragAction] begin requires a fence node');
+        const endpoint = (input.handleId ?? 'end');
+        const parentId = fence.parentId ?? null;
+        const originalStart = [fence.start[0], fence.start[1]];
+        const originalEnd = [fence.end[0], fence.end[1]];
+        const originalMovingPoint = endpoint === 'start' ? originalStart : originalEnd;
+        const fixedPoint = endpoint === 'start' ? originalEnd : originalStart;
+        const { nodes } = useScene.getState();
+        const levelWalls = [];
+        const levelFences = [];
+        for (const node of Object.values(nodes)) {
+            if (!node)
+                continue;
+            if ((node.parentId ?? null) !== parentId)
+                continue;
+            if (node.type === 'wall')
+                levelWalls.push(node);
+            else if (node.type === 'fence')
+                levelFences.push(node);
+        }
+        // Alignment targets — anchors of every other alignable object (walls,
+        // fences, items, slabs, ceilings, columns).
+        const alignCandidates = collectAlignmentAnchors(useScene.getState().nodes, fence.id);
+        return {
+            fenceId: fence.id,
+            endpoint,
+            originalStart,
+            originalEnd,
+            originalMovingPoint,
+            fixedPoint,
+            parentId,
+            linkedOriginals: snapshotLinked(fence.id, parentId, originalMovingPoint),
+            levelWalls,
+            levelFences,
+            alignCandidates,
+        };
+    },
+    preview: (ctx, point, modifiers) => {
+        const planPoint = [point[0], point[1]];
+        // Endpoint move honours the active snapping mode (HUD chip): grid → lattice;
+        // lines → magnetic corner/alignment; angles → lock to 15° rays from the
+        // fixed corner; off → raw. No Shift bypass — Shift cycles the mode; Off is
+        // the bypass.
+        const snapped = snapFenceDraftPoint({
+            point: planPoint,
+            walls: ctx.levelWalls,
+            fences: ctx.levelFences,
+            ignoreFenceIds: [ctx.fenceId],
+            start: ctx.fixedPoint,
+            angleSnap: isAngleSnapActive(),
+            magnetic: isMagneticSnapActive(),
+        });
+        // Figma-style alignment: nudge the dragged endpoint onto another wall /
+        // fence endpoint or midpoint axis when within threshold, and publish a
+        // guide. The resolver connects to the NEAREST real anchor, so the dot
+        // always sits on an actual point. Alt is reserved for detach. The guide is
+        // DISPLAYED in every mode except Off (isAlignmentGuideActive); the
+        // magnetic pull onto it is applied only in 'lines' mode
+        // (isMagneticSnapActive).
+        let aligned = snapped;
+        if (isAlignmentGuideActive() && ctx.alignCandidates.length > 0) {
+            const ar = resolveAlignment({
+                moving: [{ nodeId: ctx.fenceId, kind: 'corner', x: snapped[0], z: snapped[1] }],
+                candidates: ctx.alignCandidates,
+                threshold: ALIGNMENT_THRESHOLD_M,
+            });
+            if (ar.snap && isMagneticSnapActive()) {
+                aligned = [snapped[0] + ar.snap.dx, snapped[1] + ar.snap.dz];
+            }
+            useAlignmentGuides.getState().set(ar.guides);
+        }
+        else {
+            useAlignmentGuides.getState().clear();
+        }
+        const nextStart = ctx.endpoint === 'start' ? aligned : ctx.fixedPoint;
+        const nextEnd = ctx.endpoint === 'end' ? aligned : ctx.fixedPoint;
+        const detached = modifiers.alt;
+        const linkedUpdates = detached
+            ? []
+            : linkedCascade(ctx.linkedOriginals, ctx.originalMovingPoint, aligned);
+        return {
+            movingPoint: aligned,
+            start: nextStart,
+            end: nextEnd,
+            linkedUpdates,
+            detached,
+        };
+    },
+    apply: (draft, ctx, scene) => {
+        scene.update(ctx.fenceId, { start: draft.start, end: draft.end });
+        const dirty = [ctx.fenceId];
+        for (const linked of draft.linkedUpdates) {
+            scene.update(linked.id, {
+                start: linked.start,
+                end: linked.end,
+            });
+            dirty.push(linked.id);
+        }
+        return dirty;
+    },
+    commit: (draft, ctx, scene) => {
+        useAlignmentGuides.getState().clear();
+        // Min-length rejection still matters — too-short fence is invalid
+        // and should bounce back via the cancel path (snapshot restore).
+        // But the "no-change" rejection is removed: see
+        // fence/actions/curve.ts for the rationale (no-op drag must still
+        // push a pastState entry to avoid Ctrl-Z cancelling the fence
+        // creation that preceded the activation).
+        if (!isSegmentLongEnough(draft.start, draft.end))
+            return false;
+        // Single-undo dance: revert to originals (paused history → no
+        // zundo record), resume history, then re-apply the final draft
+        // so zundo captures the entire drag as one undo step. terminate()
+        // calls resumeHistory again — depth-counted, becomes a no-op.
+        scene.restoreAll();
+        scene.resumeHistory();
+        scene.update(ctx.fenceId, { start: draft.start, end: draft.end });
+        if (!draft.detached) {
+            for (const linked of draft.linkedUpdates) {
+                scene.update(linked.id, {
+                    start: linked.start,
+                    end: linked.end,
+                });
+            }
+        }
+        return true;
+    },
+    cancel: (_ctx, _scene) => {
+        useAlignmentGuides.getState().clear();
+        // No-op otherwise — createDragSession.cancel() calls scene.restoreAll()
+        // which puts every touched node back via the snapshot.
+    },
+};

package/dist/fence/curve-tool.d.ts

@@ -0,0 +1,17 @@
+import { type FenceNode } from '@pascal-app/core';
+/**
+ * Phase 5 Stage D — fence curve tool (kind-owned).
+ *
+ * 1:1 port of the legacy `CurveFenceTool` (editor/components/tools/
+ * fence/curve-fence-tool.tsx). Same snap pipeline, same history dance,
+ * same activation grace. Imports adjusted to the
+ * `@pascal-app/editor` public surface (triggerSFX, markToolCancelConsumed,
+ * getSegmentGridStep, snapScalarToGrid). Mounted via
+ * `def.affordanceTools.curve` — ToolManager picks it up at runtime,
+ * legacy fallback is unused when this kind is registered.
+ */
+export declare const CurveFenceTool: React.FC<{
+    node: FenceNode;
+}>;
+export default CurveFenceTool;
+//# sourceMappingURL=curve-tool.d.ts.map

package/dist/fence/curve-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"curve-tool.d.ts","sourceRoot":"","sources":["../../src/fence/curve-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,SAAS,EAUf,MAAM,kBAAkB,CAAA;AAYzB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,CAsIxD,CAAA;AAED,eAAe,cAAc,CAAA"}

package/dist/fence/curve-tool.js

@@ -0,0 +1,122 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { emitter, getClampedWallCurveOffset, getMaxWallCurveOffset, getWallChordFrame, getWallMidpointHandlePoint, normalizeWallCurveOffset, pauseSceneHistory, resumeSceneHistory, useScene, } from '@pascal-app/core';
+import { CursorSphere, getSegmentGridStep, markToolCancelConsumed, snapScalarToGrid, triggerSFX, useInteractionScope, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useCallback, useEffect, useRef, useState } from 'react';
+/**
+ * Phase 5 Stage D — fence curve tool (kind-owned).
+ *
+ * 1:1 port of the legacy `CurveFenceTool` (editor/components/tools/
+ * fence/curve-fence-tool.tsx). Same snap pipeline, same history dance,
+ * same activation grace. Imports adjusted to the
+ * `@pascal-app/editor` public surface (triggerSFX, markToolCancelConsumed,
+ * getSegmentGridStep, snapScalarToGrid). Mounted via
+ * `def.affordanceTools.curve` — ToolManager picks it up at runtime,
+ * legacy fallback is unused when this kind is registered.
+ */
+export const CurveFenceTool = ({ 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);
+        pauseSceneHistory(useScene);
+        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();
+            const localX = snapScalarToGrid(event.localPosition[0], snapStep);
+            const localZ = snapScalarToGrid(event.localPosition[2], snapStep);
+            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);
+                resumeSceneHistory(useScene);
+                useScene.getState().updateNode(nodeId, { curveOffset });
+                useScene.getState().markDirty(nodeId);
+                pauseSceneHistory(useScene);
+            }
+            triggerSFX('sfx:item-place');
+            useViewer.getState().setSelection({ selectedIds: [nodeId] });
+            exitCurveMode();
+            event.nativeEvent?.stopPropagation?.();
+        };
+        const onCancel = () => {
+            restoreOriginal();
+            useViewer.getState().setSelection({ selectedIds: [nodeId] });
+            resumeSceneHistory(useScene);
+            markToolCancelConsumed();
+            exitCurveMode();
+        };
+        emitter.on('grid:move', onGridMove);
+        emitter.on('grid:click', onGridClick);
+        emitter.on('tool:cancel', onCancel);
+        return () => {
+            if (!wasCommitted) {
+                restoreOriginal();
+            }
+            resumeSceneHistory(useScene);
+            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 CurveFenceTool;

package/dist/fence/definition.d.ts

@@ -0,0 +1,17 @@
+import { type NodeDefinition } from '@pascal-app/core';
+import { FenceNode } from './schema';
+/**
+ * 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 declare const fenceDefinition: NodeDefinition<typeof FenceNode>;
+//# sourceMappingURL=definition.d.ts.map

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

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