@pascal-app/nodes 1.0.7 → 1.1.0

package/dist/fence/definition.js

@@ -1,413 +1,5 @@
-import { fenceSlots, findLevelAncestorId, floorConstructionLift, getFenceControlHandle, getFenceSpanMode, isSplineFence, levelBaseElevationAt, } from '@pascal-app/core';
-import { clearStructuralElevationGuide, PANEL_MODEL_EXTENSION, publishStructuralElevationGuide, REGISTERED_DRAFT_SNAP_EXTENSION, resolveStructuralElevationSnap, } from '@pascal-app/editor';
-import { createNodeTopSurfaceHeightSampler, createSceneSupportHeightSampler, } from '@pascal-app/viewer';
-import { snapFenceDraftPoint } from './drafting.js';
-import { buildFenceFloorplan } from './floorplan.js';
-import { fenceControlPointAffordance, fenceCurveAffordance, fenceMoveEndpointAffordance, fenceTangentAffordance, fenceThicknessAffordance, } from './floorplan-affordances.js';
-import { fenceFloorplanMoveTarget } from './floorplan-move.js';
-import { buildFenceGeometry } from './geometry.js';
-import { resolveFenceLiftElevation, resolveFenceLiftElevationForNodes } from './lift.js';
-import { fencePaint } from './paint.js';
-import { fencePanelModel } from './panel-model.js';
-import { fenceParametrics } from './parametrics.js';
-import { FenceNode } from './schema.js';
-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;
-export function fenceBaseElevation(n, sceneApi, point = n.start) {
-    const nodes = sceneApi?.nodes();
-    if (!nodes)
-        return resolveFenceLiftElevation(n, () => undefined);
-    if (n.supportSlabId)
-        return resolveFenceLiftElevationForNodes(n, nodes);
-    const levelId = findLevelAncestorId(n.id, nodes);
-    if (levelId && ((n.path?.length ?? 0) >= 2 || Math.abs(n.curveOffset ?? 0) > 1e-4)) {
-        const selectedHost = n.surfaceMode === 'selected'
-            ? (n.supportSurfaceNodeId ?? n.supportSlabId)
-            : undefined;
-        const samplePoint = n.surfaceMode === 'level' ? n.start : point;
-        return (Math.max(createSceneSupportHeightSampler(nodes, levelId, selectedHost)(samplePoint[0], samplePoint[1]), levelBaseElevationAt(nodes, levelId, samplePoint[0], samplePoint[1]) +
-            floorConstructionLift(nodes, n)) + (n.supportOffset ?? 0));
-    }
-    if (n.supportSurfaceNodeId && levelId) {
-        const height = createNodeTopSurfaceHeightSampler(n.supportSurfaceNodeId, levelId)?.(point[0], point[1]);
-        if (height !== null && height !== undefined)
-            return height + (n.supportOffset ?? 0);
-    }
-    return resolveFenceLiftElevationForNodes(n, nodes);
-}
-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,
-    };
-}
-function fenceElevationGuideSource(n) {
-    const { midX, midZ } = fenceMidpointFrame(n);
-    return {
-        nodeId: n.id,
-        levelId: n.parentId,
-        anchor: [midX, midZ],
-    };
-}
-// 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, sceneApi) => {
-                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 = fenceBaseElevation(n, sceneApi, [midX, midZ]) +
-                    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, sceneApi) => {
-                const { midX, midZ } = fenceMidpointFrame(n);
-                return [
-                    midX,
-                    fenceBaseElevation(n, sceneApi, [midX, midZ]) + (n.height ?? 1.8) + HEIGHT_HANDLE_OFFSET,
-                    midZ,
-                ];
-            },
-            rotationY: (n) => {
-                const { normalX, normalZ } = fenceMidpointFrame(n);
-                return Math.atan2(-normalZ, normalX);
-            },
-        },
-    };
-}
-function fenceElevationHandle(currentBase) {
-    return {
-        kind: 'linear-resize',
-        axis: 'y',
-        anchor: 'min',
-        shape: 'tracker',
-        gridSnap: true,
-        currentValue: () => currentBase,
-        magneticSnap: (n, newValue, sceneApi) => resolveStructuralElevationSnap(fenceElevationGuideSource(n), newValue, sceneApi.nodes()),
-        onDrag: (n, sceneApi) => publishStructuralElevationGuide(fenceElevationGuideSource(n), fenceBaseElevation(n, sceneApi), sceneApi.nodes()),
-        onDragEnd: (n) => clearStructuralElevationGuide(n.id),
-        apply: (initial, newBase, sceneApi) => {
-            // The offset is measured from the support WITHOUT the current offset —
-            // including the ground, so dragging a fence's base to an absolute height
-            // on a hillside stores the delta from that hillside and the fence keeps
-            // following it.
-            const { midX, midZ } = fenceMidpointFrame(initial);
-            const supportBase = fenceBaseElevation({ ...initial, supportOffset: undefined }, sceneApi, [
-                midX,
-                midZ,
-            ]);
-            const nextOffset = newBase - supportBase;
-            return {
-                supportOffset: Math.abs(nextOffset) < 1e-6 ? undefined : nextOffset,
-            };
-        },
-        placement: {
-            position: (n, sceneApi) => {
-                const { midX, midZ } = fenceMidpointFrame(n);
-                return [midX, fenceBaseElevation(n, sceneApi, [midX, midZ]), midZ];
-            },
-        },
-    };
-}
-// 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, sceneApi) => {
-                const corner = endpoint === 'start' ? n.start : n.end;
-                return [corner[0], fenceBaseElevation(n, sceneApi, corner), 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, sceneApi) => {
-                const point = n.path?.[index] ?? n.start;
-                return [point[0], fenceBaseElevation(n, sceneApi, point), 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, sceneApi) => {
-                const point = n.path?.[index] ?? n.start;
-                const baseElevation = fenceBaseElevation(n, sceneApi, point);
-                if (!n.path)
-                    return [point[0], baseElevation, point[1]];
-                const handle = getFenceControlHandle(n.path, n.tangents, index);
-                return [
-                    point[0] + sign * handle.x * TANGENT_HANDLE_ARM_SCALE,
-                    baseElevation,
-                    point[1] + sign * handle.y * TANGENT_HANDLE_ARM_SCALE,
-                ];
-            },
-        },
-    };
-}
-const fenceHandles = (node, sceneApi) => {
-    const { midX, midZ } = fenceMidpointFrame(node);
-    const elevationHandle = fenceElevationHandle(fenceBaseElevation(node, sceneApi, [midX, midZ]));
-    if (isSplineFence(node) && node.path) {
-        return [
-            elevationHandle,
-            fenceHeightHandle(),
-            ...node.path.flatMap((_, index) => {
-                const path = node.path;
-                return [
-                    fenceControlPointPicker(index),
-                    ...(index < path.length - 1 &&
-                        getFenceSpanMode(path, node.tangents, node.spanModes, index) === 'curve'
-                        ? [fenceTangentPicker(index, 'out')]
-                        : []),
-                    ...(index > 0 &&
-                        getFenceSpanMode(path, node.tangents, node.spanModes, index - 1) === 'curve'
-                        ? [fenceTangentPicker(index, 'in')]
-                        : []),
-                ];
-            }),
-        ];
-    }
-    return [
-        fenceSideMoveHandle('front'),
-        fenceSideMoveHandle('back'),
-        elevationHandle,
-        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: 3,
-    schema: FenceNode,
-    extensions: {
-        [PANEL_MODEL_EXTENSION]: fencePanelModel,
-        [REGISTERED_DRAFT_SNAP_EXTENSION]: snapFenceDraftPoint,
-    },
-    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: 1.98,
-        picketSpacing: 0.27,
-        patternDistribution: 'automatic',
-        patternAlignment: 'center',
-        patternCount: 4,
-        patternRemainder: 'leave',
-        picketWidth: 0.07,
-        picketTop: 'flat',
-        picketRailCount: 2,
-        picketProfile: 'level',
-        picketTopClearance: 0.2,
-        picketVariation: 0.23,
-        picketRailProjection: 0.001,
-        postSize: 0.109,
-        topRailHeight: 0.04,
-        groundClearance: 0.14,
-        edgeInset: 0.015,
-        slatGap: 0.01,
-        postCap: 'pyramid',
-        baseStyle: 'floating',
-        surfaceMode: 'auto',
-        transitionMode: 'slope',
-        transitionWidth: 0.8,
-        showInfill: true,
-        infillPlacement: 'center',
-        color: '#ffffff',
-        style: 'picket',
-        children: [],
-    }),
-    capabilities: {
-        exterior: true,
-        reveal: { phase: 'structure', style: 'rise' },
-        revealOnEdit: [
-            'start',
-            'end',
-            'path',
-            'curveOffset',
-            'height',
-            'thickness',
-            'baseHeight',
-            'postSpacing',
-            'picketSpacing',
-            'style',
-        ],
-        hostRefFields: ['supportSurfaceNodeId'],
-        surfacePlacement: 'floor-only',
-        selectable: { hitVolume: 'bbox' },
-        surfaces: { sides: { faces: 'all' }, hosting: false },
-        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: 'descendants',
-    },
-    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.js'),
-    // Stage B: pure geometry function. Generic <GeometrySystem> rebuilds
-    // on dirtyNodes; <ParametricNodeRenderer> mounts the empty group.
-    geometry: buildFenceGeometry,
-    geometryChildTypes: ['fence-gate', 'fence-opening'],
-    floorplanDependencies: (node) => (node.children ?? []),
-    // Dependency tracker only — a hosted railing (`supportSlabId`) renders at
-    // its slab's elevation, so host elevation edits must re-dirty the fence.
-    system: {
-        module: () => import('./system.js'),
-        priority: 4,
-    },
-    // 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,
-        thickness: fenceThicknessAffordance,
-    },
-    // 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.js'),
-        'move-endpoint': () => import('./move-endpoint-tool.js'),
-        'move-control-point': () => import('./move-control-point-tool.js'),
-        'move-tangent': () => import('./move-tangent-tool.js'),
-        move: () => import('./move-tool.js'),
-    },
-    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.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { fenceEditContribution } from './definition.edit.js';
+import { fenceRenderDefinition } from './definition.render.js';
+export const fenceDefinition = composeNodeDefinition(fenceRenderDefinition, fenceEditContribution);
+export { fenceBaseElevation } from './definition.render.js';

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

@@ -0,0 +1,8 @@
+import { type FenceNode as FenceNodeType, type SceneApi } from '@pascal-app/core';
+import type { NodeRenderDefinition } from '../definition-contributions.js';
+import { FenceNode } from './schema.js';
+export declare function fenceBaseElevation(n: FenceNodeType, sceneApi?: SceneApi, point?: readonly [number, number]): number;
+export declare const fenceRenderDefinition: NodeRenderDefinition<typeof FenceNode> & {
+    kind: 'fence';
+};
+//# sourceMappingURL=definition.render.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/fence/definition.render.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,SAAS,IAAI,aAAa,EAK/B,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAMzB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAGvE,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEpC,wBAAgB,kBAAkB,CAChC,CAAC,EAAE,aAAa,EAChB,QAAQ,CAAC,EAAE,QAAQ,EACnB,KAAK,GAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAW,GACzC,MAAM,CA+BR;AAED,eAAO,MAAM,qBAAqB,EAAE,oBAAoB,CAAC,OAAO,SAAS,CAAC,GAAG;IAAE,IAAI,EAAE,OAAO,CAAA;CAgG3F,CAAA"}

package/dist/fence/definition.render.js

@@ -0,0 +1,124 @@
+import { fenceSlots, findLevelAncestorId, floorConstructionLift, levelBaseElevationAt, } from '@pascal-app/core';
+import { createNodeTopSurfaceHeightSampler, createSceneSupportHeightSampler, } from '@pascal-app/viewer';
+import { buildFenceGeometry } from './geometry.js';
+import { resolveFenceLiftElevation, resolveFenceLiftElevationForNodes } from './lift.js';
+import { FenceNode } from './schema.js';
+export function fenceBaseElevation(n, sceneApi, point = n.start) {
+    const nodes = sceneApi?.nodes();
+    if (!nodes)
+        return resolveFenceLiftElevation(n, () => undefined);
+    if (n.supportSlabId)
+        return resolveFenceLiftElevationForNodes(n, nodes);
+    const levelId = findLevelAncestorId(n.id, nodes);
+    if (levelId && ((n.path?.length ?? 0) >= 2 || Math.abs(n.curveOffset ?? 0) > 1e-4)) {
+        const selectedHost = n.surfaceMode === 'selected'
+            ? (n.supportSurfaceNodeId ?? n.supportSlabId)
+            : undefined;
+        const samplePoint = n.surfaceMode === 'level' ? n.start : point;
+        return (Math.max(createSceneSupportHeightSampler(nodes, levelId, selectedHost)(samplePoint[0], samplePoint[1]), levelBaseElevationAt(nodes, levelId, samplePoint[0], samplePoint[1]) +
+            floorConstructionLift(nodes, n)) + (n.supportOffset ?? 0));
+    }
+    if (n.supportSurfaceNodeId && levelId) {
+        const height = createNodeTopSurfaceHeightSampler(n.supportSurfaceNodeId, levelId)?.(point[0], point[1]);
+        if (height !== null && height !== undefined)
+            return height + (n.supportOffset ?? 0);
+    }
+    return resolveFenceLiftElevationForNodes(n, nodes);
+}
+export const fenceRenderDefinition = {
+    kind: 'fence',
+    schemaVersion: 3,
+    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: 1.98,
+        picketSpacing: 0.27,
+        patternDistribution: 'automatic',
+        patternAlignment: 'center',
+        patternCount: 4,
+        patternRemainder: 'leave',
+        picketWidth: 0.07,
+        picketTop: 'flat',
+        picketRailCount: 2,
+        picketProfile: 'level',
+        picketTopClearance: 0.2,
+        picketVariation: 0.23,
+        picketRailProjection: 0.001,
+        postSize: 0.109,
+        topRailHeight: 0.04,
+        groundClearance: 0.14,
+        edgeInset: 0.015,
+        slatGap: 0.01,
+        postCap: 'pyramid',
+        baseStyle: 'floating',
+        surfaceMode: 'auto',
+        transitionMode: 'slope',
+        transitionWidth: 0.8,
+        showInfill: true,
+        infillPlacement: 'center',
+        color: '#ffffff',
+        style: 'picket',
+        children: [],
+    }),
+    capabilities: {
+        exterior: true,
+        reveal: { phase: 'structure', style: 'rise' },
+        revealOnEdit: [
+            'start',
+            'end',
+            'path',
+            'curveOffset',
+            'height',
+            'thickness',
+            'baseHeight',
+            'postSpacing',
+            'picketSpacing',
+            'style',
+        ],
+        hostRefFields: ['supportSurfaceNodeId'],
+        surfacePlacement: 'floor-only',
+        selectable: { hitVolume: 'bbox' },
+        surfaces: { sides: { faces: 'all' }, hosting: false },
+        duplicable: true,
+        deletable: true,
+        slots: (node) => fenceSlots(node),
+        // 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: 'descendants',
+    },
+    // Stage B: pure geometry function. Generic <GeometrySystem> rebuilds
+    // on dirtyNodes; <ParametricNodeRenderer> mounts the empty group.
+    geometry: buildFenceGeometry,
+    geometryChildTypes: ['fence-gate', 'fence-opening'],
+    // Dependency tracker only — a hosted railing (`supportSlabId`) renders at
+    // its slab's elevation, so host elevation edits must re-dirty the fence.
+    system: {
+        module: () => import('./system.js'),
+        priority: 4,
+    },
+    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/move-endpoint-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"move-endpoint-tool.d.ts","sourceRoot":"","sources":["../../src/fence/move-endpoint-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,SAAS,EAMf,MAAM,kBAAkB,CAAA;AAmBzB;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,SAAS,CAAA;IAChB,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAA;CAC1B,CAAA;AAgDD,eAAO,MAAM,qBAAqB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,MAAM,EAAE,mBAAmB,CAAA;CAAE,CAmN3E,CAAA;eAEc,qBAAqB"}
+{"version":3,"file":"move-endpoint-tool.d.ts","sourceRoot":"","sources":["../../src/fence/move-endpoint-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,SAAS,EAOf,MAAM,kBAAkB,CAAA;AAkBzB;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,SAAS,CAAA;IAChB,QAAQ,EAAE,OAAO,GAAG,KAAK,CAAA;CAC1B,CAAA;AAgDD,eAAO,MAAM,qBAAqB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,MAAM,EAAE,mBAAmB,CAAA;CAAE,CAmN3E,CAAA;eAEc,qBAAqB"}

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

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { emitter, getWallCurveLength, usePascalI18n, useScene, } from '@pascal-app/core';
-import { CursorSphere, formatAngleRadians, getAngleToSegmentReference, getSegmentAngleReferenceAtPoint, isTypingTarget, MeasurementPill, triggerSFX, useAlignmentGuides, useDragAction, useInteractionScope, } from '@pascal-app/editor';
+import { emitter, formatAngleRadians, getWallCurveLength, usePascalI18n, useScene, } from '@pascal-app/core';
+import { CursorSphere, getAngleToSegmentReference, getSegmentAngleReferenceAtPoint, isTypingTarget, MeasurementPill, triggerSFX, useAlignmentGuides, useDragAction, useInteractionScope, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Html } from '@react-three/drei';
 import { useEffect, useMemo, useRef, useState } from 'react';

package/dist/fence/tool.js

@@ -1,7 +1,7 @@
 'use client';
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { calculateLevelMiters, collectAlignmentAnchors, emitter, FenceNode, GROUND_SUPPORT_ID, getWallMiterBoundaryPoints, levelBaseElevationAt, resolveAlignment, sampleFenceSpline, sceneRegistry, spatialGridManager, useScene, } from '@pascal-app/core';
-import { CursorSphere, clearPlacementSurface, DraftMeasurementLabel, EDITOR_LAYER, formatAngleRadians, formatLinearMeasurement, getAngleArcToSegmentReference, getAngleToSegmentReference, getSegmentAngleReferenceAtPoint, isAlignmentGuideActive, isAngleSnapActive, isMagneticSnapActive, isTypingTarget, markToolCancelConsumed, publishPlacementSurface, resolvePointerSupportSurface, triggerSFX, useAlignmentGuides, useEditor, useFenceCurveDraft, useFloorplanDraftPreview, usePlacementPreview, useRegistryToolContext, useSegmentDraftChain, } from '@pascal-app/editor';
+import { calculateLevelMiters, collectAlignmentAnchors, emitter, FenceNode, formatAngleRadians, formatLinearMeasurement, GROUND_SUPPORT_ID, getWallMiterBoundaryPoints, levelBaseElevationAt, resolveAlignment, sampleFenceSpline, sceneRegistry, spatialGridManager, useScene, } from '@pascal-app/core';
+import { CursorSphere, clearPlacementSurface, DraftMeasurementLabel, EDITOR_LAYER, getAngleArcToSegmentReference, getAngleToSegmentReference, getSegmentAngleReferenceAtPoint, isAlignmentGuideActive, isAngleSnapActive, isMagneticSnapActive, isTypingTarget, markToolCancelConsumed, publishPlacementSurface, resolvePointerSupportSurface, triggerSFX, useAlignmentGuides, useEditor, useFenceCurveDraft, useFloorplanDraftPreview, usePlacementPreview, useRegistryToolContext, useSegmentDraftChain, } from '@pascal-app/editor';
 import { createSceneSupportHeightSampler, getLevelPresentationY, getSceneTheme, useViewer, } from '@pascal-app/viewer';
 import { useThree } from '@react-three/fiber';
 import { useEffect, useMemo, useRef, useState } from 'react';