@pascal-app/nodes 1.0.7 → 1.1.0

package/dist/eyebrow-vent/definition.render.js

@@ -0,0 +1,43 @@
+import { EyebrowVentNode as EyebrowVentNodeSchema, eyebrowVentSlots } from '@pascal-app/core';
+import { EyebrowVentNode } from './schema.js';
+export const eyebrowVentRenderDefinition = {
+    kind: 'eyebrow-vent',
+    schemaVersion: 3,
+    schema: EyebrowVentNode,
+    category: 'structure',
+    surfaceRole: 'roof',
+    defaults: () => {
+        const stub = EyebrowVentNodeSchema.parse({
+            id: 'eyebrow-vent_default',
+            type: 'eyebrow-vent',
+        });
+        const { id: _id, type: _type, ...rest } = stub;
+        return rest;
+    },
+    capabilities: {
+        exterior: true,
+        slots: eyebrowVentSlots,
+        selectable: { hitVolume: 'bbox' },
+        duplicable: true,
+        deletable: true,
+        // Mounts on a roof segment via `roofSegmentId`. Sits ON TOP of the slope —
+        // no `buildCut`, just the dirty cascade so the parent roof's merged shell
+        // rebuilds when the vent moves / resizes.
+        roofAccessory: {},
+    },
+    rendersChildren: false,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer.js'),
+    },
+    presentation: {
+        label: 'Eyebrow Vent',
+        description: 'Low curved lens-shaped roof vent with a louvered front.',
+        icon: { kind: 'url', src: '/icons/eyebrow-vent.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 123,
+    },
+    mcp: {
+        description: 'A low curved eyebrow vent on a roof segment — a lens-shaped hood with an optional louvered front. Parametric width (span) / depth / height.',
+    },
+};

package/dist/eyebrow-vent/move-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/eyebrow-vent/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,eAAe,EAOrB,MAAM,kBAAkB,CAAA;AAuBzB;;;;;;;GAOG;AACH,MAAM,CAAC,OAAO,UAAU,mBAAmB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,sCAwN9E"}
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/eyebrow-vent/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,eAAe,EAOrB,MAAM,kBAAkB,CAAA;AA0BzB;;;;;;;GAOG;AACH,MAAM,CAAC,OAAO,UAAU,mBAAmB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,eAAe,CAAA;CAAE,sCAyN9E"}

package/dist/eyebrow-vent/move-tool.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { emitter, sceneRegistry, useScene, } from '@pascal-app/core';
-import { consumePlacementDragRelease, markToolCancelConsumed, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { consumePlacementDragRelease, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, stripPlacementMetadataFlags, triggerSFX, useEditor, } from '@pascal-app/editor';
 import { useCallback, useEffect, useState } from 'react';
 import * as THREE from 'three';
 import { createRelativeRoofDrag, roofSegmentLocalToBuildingLocal, snapRelativeRoofDragTarget, } from '../shared/relative-roof-drag.js';
@@ -55,9 +55,9 @@ export default function MoveEyebrowVentTool({ node }) {
             if (!rawTarget)
                 return null;
             return snapRoofSurfaceNodeTarget({
-                target: snapRelativeRoofDragTarget(rawTarget, event.nativeEvent?.shiftKey === true),
+                target: snapRelativeRoofDragTarget(rawTarget, event.nativeEvent?.altKey === true),
                 node,
-                bypass: event.nativeEvent?.shiftKey === true,
+                bypass: !isMagneticSnapActive() || event.nativeEvent?.altKey === true,
             });
         };
         const updatePreview = (event) => {
@@ -69,7 +69,8 @@ export default function MoveEyebrowVentTool({ node }) {
             lastTarget = target;
             const sx = Math.round(target.localX * 20) / 20;
             const sz = Math.round(target.localZ * 20) / 20;
-            if (event.nativeEvent?.shiftKey !== true &&
+            if (isGridSnapActive() &&
+                event.nativeEvent?.altKey !== true &&
                 (!lastSnap || lastSnap[0] !== sx || lastSnap[1] !== sz)) {
                 triggerSFX('sfx:grid-snap');
                 lastSnap = [sx, sz];
@@ -122,7 +123,7 @@ export default function MoveEyebrowVentTool({ node }) {
                 position: [target.localX, target.localY, target.localZ],
                 rotation: original.rotation,
                 visible: true,
-                metadata: {},
+                metadata: stripPlacementMetadataFlags(original.metadata),
             });
             useScene.temporal.getState().pause();
             st.dirtyNodes.add(targetSegmentId);

package/dist/fence/definition.d.ts

@@ -1,18 +1,187 @@
-import { type FenceNode as FenceNodeType, type NodeDefinition, type SceneApi } from '@pascal-app/core';
-import { FenceNode } from './schema.js';
-export declare function fenceBaseElevation(n: FenceNodeType, sceneApi?: SceneApi, point?: readonly [number, number]): number;
-/**
- * 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>;
+export declare const fenceDefinition: import("@pascal-app/core").NodeDefinition<import("zod").ZodObject<{
+    object: import("zod").ZodDefault<import("zod").ZodLiteral<"node">>;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+    parentId: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodString>>;
+    visible: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+    camera: import("zod").ZodOptional<import("zod").ZodObject<{
+        position: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        target: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        mode: import("zod").ZodDefault<import("zod").ZodEnum<{
+            orthographic: "orthographic";
+            perspective: "perspective";
+        }>>;
+        fov: import("zod").ZodOptional<import("zod").ZodNumber>;
+        zoom: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>>;
+    metadata: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+    provenance: import("zod").ZodOptional<import("zod").ZodObject<{
+        refs: import("zod").ZodArray<import("zod").ZodObject<{
+            ns: import("zod").ZodOptional<import("zod").ZodString>;
+            id: import("zod").ZodString;
+            role: import("zod").ZodOptional<import("zod").ZodEnum<{
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+                piece: "piece";
+                primary: "primary";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+        lineage: import("zod").ZodOptional<import("zod").ZodObject<{
+            op: import("zod").ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
+                import: "import";
+                "make-independent": "make-independent";
+                merge: "merge";
+                promote: "promote";
+                split: "split";
+            }>;
+            fromIds: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    id: import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`fence_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"fence">>;
+    children: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+    material: import("zod").ZodOptional<import("zod").ZodObject<{
+        id: import("zod").ZodOptional<import("zod").ZodString>;
+        preset: import("zod").ZodOptional<import("zod").ZodCatch<import("zod").ZodEnum<{
+            brick: "brick";
+            concrete: "concrete";
+            custom: "custom";
+            glass: "glass";
+            marble: "marble";
+            metal: "metal";
+            plaster: "plaster";
+            tile: "tile";
+            white: "white";
+            wood: "wood";
+        }>>>;
+        properties: import("zod").ZodOptional<import("zod").ZodObject<{
+            color: import("zod").ZodDefault<import("zod").ZodString>;
+            roughness: import("zod").ZodDefault<import("zod").ZodNumber>;
+            metalness: import("zod").ZodDefault<import("zod").ZodNumber>;
+            opacity: import("zod").ZodDefault<import("zod").ZodNumber>;
+            transparent: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            side: import("zod").ZodDefault<import("zod").ZodEnum<{
+                back: "back";
+                double: "double";
+                front: "front";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+        texture: import("zod").ZodOptional<import("zod").ZodObject<{
+            url: import("zod").ZodString;
+            repeat: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+            scale: import("zod").ZodOptional<import("zod").ZodNumber>;
+            offset: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+            normalMap: import("zod").ZodOptional<import("zod").ZodString>;
+            normalScale: import("zod").ZodOptional<import("zod").ZodNumber>;
+            bumpMap: import("zod").ZodOptional<import("zod").ZodString>;
+            bumpScale: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    materialPreset: import("zod").ZodOptional<import("zod").ZodString>;
+    slots: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+    start: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>;
+    end: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>;
+    path: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>>;
+    spanModes: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodEnum<{
+        curve: "curve";
+        straight: "straight";
+    }>>>;
+    tangents: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodNullable<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>>>;
+    height: import("zod").ZodDefault<import("zod").ZodNumber>;
+    thickness: import("zod").ZodDefault<import("zod").ZodNumber>;
+    supportSlabId: import("zod").ZodOptional<import("zod").ZodString>;
+    supportSurfaceNodeId: import("zod").ZodOptional<import("zod").ZodString>;
+    supportOffset: import("zod").ZodOptional<import("zod").ZodNumber>;
+    surfaceMode: import("zod").ZodDefault<import("zod").ZodEnum<{
+        auto: "auto";
+        level: "level";
+        selected: "selected";
+    }>>;
+    transitionMode: import("zod").ZodDefault<import("zod").ZodEnum<{
+        break: "break";
+        slope: "slope";
+        step: "step";
+    }>>;
+    transitionWidth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    curveOffset: import("zod").ZodOptional<import("zod").ZodNumber>;
+    baseHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+    postSpacing: import("zod").ZodDefault<import("zod").ZodNumber>;
+    picketSpacing: import("zod").ZodDefault<import("zod").ZodNumber>;
+    patternDistribution: import("zod").ZodDefault<import("zod").ZodEnum<{
+        automatic: "automatic";
+        "equal-fit": "equal-fit";
+        "fixed-count": "fixed-count";
+        "fixed-spacing": "fixed-spacing";
+        "maximum-spacing": "maximum-spacing";
+    }>>;
+    patternAlignment: import("zod").ZodDefault<import("zod").ZodEnum<{
+        center: "center";
+        end: "end";
+        start: "start";
+    }>>;
+    patternCount: import("zod").ZodDefault<import("zod").ZodNumber>;
+    patternRemainder: import("zod").ZodDefault<import("zod").ZodEnum<{
+        leave: "leave";
+        spread: "spread";
+    }>>;
+    picketWidth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    picketTop: import("zod").ZodDefault<import("zod").ZodEnum<{
+        "dog-ear": "dog-ear";
+        flat: "flat";
+        pointed: "pointed";
+        rounded: "rounded";
+    }>>;
+    picketProfile: import("zod").ZodDefault<import("zod").ZodEnum<{
+        alternating: "alternating";
+        arched: "arched";
+        level: "level";
+        scalloped: "scalloped";
+    }>>;
+    picketTopClearance: import("zod").ZodDefault<import("zod").ZodNumber>;
+    picketVariation: import("zod").ZodDefault<import("zod").ZodNumber>;
+    picketRailProjection: import("zod").ZodDefault<import("zod").ZodNumber>;
+    picketRailCount: import("zod").ZodDefault<import("zod").ZodNumber>;
+    postSize: import("zod").ZodDefault<import("zod").ZodNumber>;
+    topRailHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+    groundClearance: import("zod").ZodDefault<import("zod").ZodNumber>;
+    edgeInset: import("zod").ZodDefault<import("zod").ZodNumber>;
+    slatGap: import("zod").ZodDefault<import("zod").ZodNumber>;
+    postCap: import("zod").ZodDefault<import("zod").ZodEnum<{
+        flat: "flat";
+        none: "none";
+        pyramid: "pyramid";
+    }>>;
+    baseStyle: import("zod").ZodDefault<import("zod").ZodEnum<{
+        floating: "floating";
+        grounded: "grounded";
+        raised: "raised";
+    }>>;
+    showInfill: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    guardInfill: import("zod").ZodOptional<import("zod").ZodEnum<{
+        balusters: "balusters";
+        boards: "boards";
+        cable: "cable";
+    }>>;
+    startPost: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    endPost: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    postThrough: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    infillPlacement: import("zod").ZodDefault<import("zod").ZodEnum<{
+        back: "back";
+        center: "center";
+        front: "front";
+    }>>;
+    color: import("zod").ZodDefault<import("zod").ZodString>;
+    style: import("zod").ZodDefault<import("zod").ZodEnum<{
+        guard: "guard";
+        horizontal: "horizontal";
+        picket: "picket";
+        privacy: "privacy";
+        rail: "rail";
+        slat: "slat";
+    }>>;
+}, import("zod/v4/core").$strip>>;
+export { fenceBaseElevation } from './definition.render.js';
 //# sourceMappingURL=definition.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/fence/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,SAAS,IAAI,aAAa,EAS/B,KAAK,cAAc,EACnB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AA2BzB,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AASpC,wBAAgB,kBAAkB,CAChC,CAAC,EAAE,aAAa,EAChB,QAAQ,CAAC,EAAE,QAAQ,EACnB,KAAK,GAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAW,GACzC,MAAM,CA+BR;AA4OD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CAiK5D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/fence/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAAsE,CAAA;AAClG,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA"}

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

@@ -0,0 +1,4 @@
+import type { NodeEditContribution } from '../definition-contributions.js';
+import type { FenceNode } from './schema.js';
+export declare const fenceEditContribution: NodeEditContribution<typeof FenceNode>;
+//# sourceMappingURL=definition.edit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/fence/definition.edit.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAevE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAwPzC,eAAO,MAAM,qBAAqB,EAAE,oBAAoB,CAAC,OAAO,SAAS,CA2DxE,CAAA"}

package/dist/fence/definition.edit.js

@@ -0,0 +1,282 @@
+import { getFenceControlHandle, getFenceSpanMode, isSplineFence, } from '@pascal-app/core';
+import { clearStructuralElevationGuide, PANEL_MODEL_EXTENSION, publishStructuralElevationGuide, REGISTERED_DRAFT_SNAP_EXTENSION, resolveStructuralElevationSnap, } from '@pascal-app/editor';
+import { fenceBaseElevation } from './definition.render.js';
+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 { fencePaint } from './paint.js';
+import { fencePanelModel } from './panel-model.js';
+import { fenceParametrics } from './parametrics.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;
+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'),
+    ];
+};
+export const fenceEditContribution = {
+    snapProfile: 'structural',
+    extensions: {
+        [PANEL_MODEL_EXTENSION]: fencePanelModel,
+        [REGISTERED_DRAFT_SNAP_EXTENSION]: snapFenceDraftPoint,
+    },
+    capabilities: {
+        paint: fencePaint,
+    },
+    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'),
+    floorplanDependencies: (node) => (node.children ?? []),
+    // 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' },
+    ],
+};