@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/fence/inspector-editors.js

@@ -1,20 +1,27 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { clampFencePicketRailProjection, findLevelAncestorId, getClampedWallCurveOffset, getFenceCenterlineLength, getFenceControlHandle, getFenceSpanMode, getMaxWallCurveOffset, getTwoPointFenceCurveTangents, getWallArcData, getWallCurveFrameAt, getWallCurveLength, maxFencePicketRailProjection, nodeRegistry, normalizeWallCurveOffset, sampleFenceSpline, useScene, } from '@pascal-app/core';
+import { clampFencePicketRailProjection, findLevelAncestorId, formatFixed, getClampedWallCurveOffset, getFenceCenterlineLength, getFenceControlHandle, getFenceSpanMode, getMaxWallCurveOffset, getTwoPointFenceCurveTangents, getWallArcData, getWallCurveFrameAt, getWallCurveLength, maxFencePicketRailProjection, nodeRegistry, normalizeWallCurveOffset, sampleFenceSpline, usePascalI18n, useScene, } from '@pascal-app/core';
 import { SliderControl } from '@pascal-app/editor';
 export function FencePatternInfo({ node }) {
-    const subject = node.style === 'picket'
-        ? 'pickets in each bay between posts'
-        : node.style === 'horizontal'
-            ? 'posts along the full fence'
-            : 'infill pieces between the two end posts';
-    return (_jsxs("p", { className: "text-xs text-muted-foreground", children: ["Distribution controls ", subject, ". Spacing is measured between centers. The available width limits the count so pieces do not overlap."] }));
+    const i18n = usePascalI18n();
+    return (_jsx("p", { className: "text-xs text-muted-foreground", children: i18n._({
+            id: 'node.fence.inspectorEditors.distributionInfo',
+            message: '{style, select, picket {Distribution controls pickets in each bay between posts.} horizontal {Distribution controls posts along the full fence.} other {Distribution controls infill pieces between the two end posts.}} Spacing is measured between centers. The available width limits the count so pieces do not overlap.',
+            values: {
+                style: node.style === 'picket' || node.style === 'horizontal' ? node.style : 'other',
+            },
+        }) }));
 }
 export function FencePicketRailProjectionEditor({ node, onUpdate, }) {
+    const i18n = usePascalI18n();
     const max = maxFencePicketRailProjection(node.postSize);
-    return (_jsx(SliderControl, { label: "Picket rail projection", max: max, min: 0.001, onChange: (value) => onUpdate({ picketRailProjection: clampFencePicketRailProjection(value, node.postSize) }), precision: 3, step: 0.002, unit: "m", value: clampFencePicketRailProjection(node.picketRailProjection, node.postSize) }));
+    return (_jsx(SliderControl, { label: i18n._({
+            id: 'node.fence.inspectorEditors.picketRailProjection',
+            message: 'Picket rail projection',
+        }), max: max, min: 0.001, onChange: (value) => onUpdate({ picketRailProjection: clampFencePicketRailProjection(value, node.postSize) }), precision: 3, step: 0.002, unit: "m", value: clampFencePicketRailProjection(node.picketRailProjection, node.postSize) }));
 }
 export function FenceSurfaceEditor({ node, onUpdate, }) {
+    const i18n = usePascalI18n();
     const nodes = useScene((state) => state.nodes);
     const levelId = findLevelAncestorId(node.id, nodes);
     const hosts = Object.values(nodes).filter((candidate) => candidate.id !== node.id &&
@@ -23,7 +30,7 @@ export function FenceSurfaceEditor({ node, onUpdate, }) {
             !!nodeRegistry.get(candidate.type)?.capabilities.surfaces?.top) &&
         findLevelAncestorId(candidate.id, nodes) === levelId);
     const selectedId = node.supportSurfaceNodeId ?? node.supportSlabId ?? '';
-    return (_jsxs("div", { className: "space-y-2 text-xs", children: [_jsxs("label", { className: "flex items-center justify-between gap-2", children: ["Surface behavior", _jsxs("select", { className: "rounded border bg-background p-1", value: node.surfaceMode, onChange: (event) => {
+    return (_jsxs("div", { className: "space-y-2 text-xs", children: [_jsxs("label", { className: "flex items-center justify-between gap-2", children: [i18n._({ id: 'node.fence.inspectorEditors.surfaceBehavior', message: 'Surface behavior' }), _jsxs("select", { className: "rounded border bg-background p-1", value: node.surfaceMode, onChange: (event) => {
                             const mode = event.target.value;
                             if (mode === 'selected' && !selectedId && hosts[0]) {
                                 const host = hosts[0];
@@ -36,13 +43,28 @@ export function FenceSurfaceEditor({ node, onUpdate, }) {
                             else {
                                 onUpdate({ surfaceMode: mode });
                             }
-                        }, children: [_jsx("option", { value: "auto", children: "Follow highest surface" }), _jsx("option", { disabled: hosts.length === 0, value: "selected", children: "Follow selected surface" }), _jsx("option", { value: "level", children: "Hold starting height" })] })] }), node.surfaceMode === 'selected' && (_jsxs("label", { className: "flex items-center justify-between gap-2", children: ["Surface", _jsxs("select", { className: "min-w-0 max-w-40 rounded border bg-background p-1", value: selectedId, onChange: (event) => {
+                        }, children: [_jsx("option", { value: "auto", children: i18n._({
+                                    id: 'node.fence.inspectorEditors.followHighestSurface',
+                                    message: 'Follow highest surface',
+                                }) }), _jsx("option", { disabled: hosts.length === 0, value: "selected", children: i18n._({
+                                    id: 'node.fence.inspectorEditors.followSelectedSurface',
+                                    message: 'Follow selected surface',
+                                }) }), _jsx("option", { value: "level", children: i18n._({
+                                    id: 'node.fence.inspectorEditors.holdStartingHeight',
+                                    message: 'Hold starting height',
+                                }) })] })] }), node.surfaceMode === 'selected' && (_jsxs("label", { className: "flex items-center justify-between gap-2", children: [i18n._({ id: 'node.fence.inspectorEditors.surface', message: 'Surface' }), _jsxs("select", { className: "min-w-0 max-w-40 rounded border bg-background p-1", value: selectedId, onChange: (event) => {
                             const host = nodes[event.target.value];
                             onUpdate({
                                 supportSlabId: host?.type === 'slab' ? host.id : undefined,
                                 supportSurfaceNodeId: host && host.type !== 'slab' ? host.id : undefined,
                             });
-                        }, children: [_jsx("option", { value: "", children: "Choose a surface" }), hosts.map((host) => (_jsxs("option", { value: host.id, children: [host.name || host.type, " (", host.type, ")"] }, host.id)))] })] })), node.surfaceMode === 'selected' && !selectedId && (_jsx("p", { className: "text-muted-foreground", children: "Choose a slab or shaped surface on this level." }))] }));
+                        }, children: [_jsx("option", { value: "", children: i18n._({
+                                    id: 'node.fence.inspectorEditors.chooseASurface',
+                                    message: 'Choose a surface',
+                                }) }), hosts.map((host) => (_jsxs("option", { value: host.id, children: [host.name || host.type, " (", host.type, ")"] }, host.id)))] })] })), node.surfaceMode === 'selected' && !selectedId && (_jsx("p", { className: "text-muted-foreground", children: i18n._({
+                    id: 'node.fence.inspectorEditors.chooseASlabOrShapedSurface',
+                    message: 'Choose a slab or shaped surface on this level.',
+                }) }))] }));
 }
 /**
  * Custom inspector editors for fence fields that don't map to a single
@@ -59,6 +81,7 @@ export function FenceSurfaceEditor({ node, onUpdate, }) {
  * Both are wired through `parametrics.fields[].kind: 'custom'`.
  */
 export function FenceLengthEditor({ node, onUpdate, }) {
+    const i18n = usePascalI18n();
     const length = getWallCurveLength(node);
     const handleChange = (newLength) => {
         if (newLength <= 0)
@@ -76,12 +99,13 @@ export function FenceLengthEditor({ node, onUpdate, }) {
         ];
         onUpdate({ end: newEnd });
     };
-    return (_jsx(SliderControl, { label: "Length", max: 50, min: 0.1, onChange: handleChange, precision: 2, step: 0.01, unit: "m", value: length }));
+    return (_jsx(SliderControl, { label: i18n._({ id: 'node.fence.inspectorEditors.length', message: 'Length' }), max: 50, min: 0.1, onChange: handleChange, precision: 2, step: 0.01, unit: "m", value: length }));
 }
 export function FenceCurveEditor({ node, onUpdate, }) {
+    const i18n = usePascalI18n();
     const curveOffset = getClampedWallCurveOffset(node);
     const maxCurveOffset = getMaxWallCurveOffset(node);
-    return (_jsxs("div", { className: "space-y-2", children: [_jsx(SliderControl, { label: "Curve", max: Math.max(0.01, maxCurveOffset), min: -Math.max(0.01, maxCurveOffset), onChange: (value) => onUpdate({ curveOffset: normalizeWallCurveOffset(node, value) }), precision: 2, step: 0.1, unit: "m", value: curveOffset }), _jsx("button", { type: "button", className: "rounded border px-2 py-1 text-xs", onClick: () => {
+    return (_jsxs("div", { className: "space-y-2", children: [_jsx(SliderControl, { label: i18n._({ id: 'node.fence.inspectorEditors.curve', message: 'Curve' }), max: Math.max(0.01, maxCurveOffset), min: -Math.max(0.01, maxCurveOffset), onChange: (value) => onUpdate({ curveOffset: normalizeWallCurveOffset(node, value) }), precision: 2, step: 0.1, unit: "m", value: curveOffset }), _jsx("button", { type: "button", className: "rounded border px-2 py-1 text-xs", onClick: () => {
                     const arc = getWallArcData(node);
                     const spans = arc ? 4 : 1;
                     const handleLength = arc
@@ -97,9 +121,10 @@ export function FenceCurveEditor({ node, onUpdate, }) {
                         ]),
                         curveOffset: undefined,
                     });
-                }, children: "Edit path" })] }));
+                }, children: i18n._({ id: 'node.fence.inspectorEditors.editPath', message: 'Edit path' }) })] }));
 }
 export function FencePathEditor({ node, onUpdate, }) {
+    const i18n = usePascalI18n();
     const path = node.path ?? [];
     const tangents = path.map((_, i) => node.tangents?.[i] ?? null);
     const spanModes = path
@@ -116,23 +141,38 @@ export function FencePathEditor({ node, onUpdate, }) {
             end: points.at(-1),
         });
     };
-    return (_jsxs("div", { className: "space-y-2 text-xs", children: [_jsxs("p", { children: [path.length, " points \u00B7 ", getFenceCenterlineLength(node).toFixed(2), " m"] }), _jsx("p", { className: "text-muted-foreground", children: "Set each span to straight or curved, then drag its points and curve handles in either view." }), path.map((point, index) => (_jsxs("details", { className: "rounded border p-2", children: [_jsxs("summary", { className: "cursor-pointer", children: ["Point ", index + 1] }), _jsx("div", { className: "mt-2 flex gap-2", children: ['X', 'Z'].map((axis, coordinate) => (_jsxs("label", { className: "min-w-0 flex-1", children: [axis, " (m)", _jsx("input", { type: "number", step: "0.05", className: "w-full rounded border bg-transparent p-1", defaultValue: point[coordinate], onBlur: (event) => {
+    return (_jsxs("div", { className: "space-y-2 text-xs", children: [_jsx("p", { children: i18n._({
+                    id: 'node.fence.inspectorEditors.pathSummary',
+                    message: '{count, plural, one {{number} point} other {{number} points}} · {length} m',
+                    values: {
+                        count: path.length,
+                        number: String(path.length),
+                        length: formatFixed(getFenceCenterlineLength(node), 2, i18n.getLocale()),
+                    },
+                }) }), _jsx("p", { className: "text-muted-foreground", children: i18n._({
+                    id: 'node.fence.inspectorEditors.setEachSpanToStraightOr',
+                    message: 'Set each span to straight or curved, then drag its points and curve handles in either view.',
+                }) }), path.map((point, index) => (_jsxs("details", { className: "rounded border p-2", children: [_jsxs("summary", { className: "cursor-pointer", children: [i18n._({ id: 'node.fence.inspectorEditors.point', message: 'Point' }), " ", index + 1] }), _jsx("div", { className: "mt-2 flex gap-2", children: ['X', 'Z'].map((axis, coordinate) => (_jsxs("label", { className: "min-w-0 flex-1", children: [axis, " (m)", _jsx("input", { type: "number", step: "0.05", className: "w-full rounded border bg-transparent p-1", defaultValue: point[coordinate], onBlur: (event) => {
                                         const value = event.currentTarget.valueAsNumber;
                                         if (!Number.isFinite(value) || value === point[coordinate])
                                             return;
                                         update(path.map((p, i) => i === index ? (coordinate === 0 ? [value, p[1]] : [p[0], value]) : p));
-                                    } }, `${index}-${axis}-${point[coordinate]}`)] }, axis))) }), index < path.length - 1 && (_jsxs("label", { className: "mt-2 flex items-center justify-between", children: ["Span to point ", index + 2, _jsxs("select", { className: "rounded border bg-background p-1", value: spanModes[index], onChange: (event) => {
+                                    } }, `${index}-${axis}-${point[coordinate]}`)] }, axis))) }), index < path.length - 1 && (_jsxs("label", { className: "mt-2 flex items-center justify-between", children: [i18n._({
+                                id: 'node.fence.inspectorEditors.spanToPointNumber',
+                                message: 'Span to point {number}',
+                                values: { number: index + 2 },
+                            }), _jsxs("select", { className: "rounded border bg-background p-1", value: spanModes[index], onChange: (event) => {
                                     const modes = [...spanModes];
                                     modes[index] = event.target.value;
                                     const handles = path.length === 2 && modes[index] === 'curve' && spanModes[index] === 'straight'
                                         ? (getTwoPointFenceCurveTangents(path) ?? tangents)
                                         : tangents;
                                     update(path, handles, modes);
-                                }, children: [_jsx("option", { value: "straight", children: "Straight" }), _jsx("option", { value: "curve", children: "Curved" })] })] })), (spanModes[index - 1] === 'curve' || spanModes[index] === 'curve') && (_jsxs("label", { className: "mt-2 flex items-center justify-between", children: ["Join", _jsxs("select", { className: "rounded border bg-background p-1", value: tangents[index]?.[0] === 0 && tangents[index]?.[1] === 0 ? 'corner' : 'smooth', onChange: (event) => {
+                                }, children: [_jsx("option", { value: "straight", children: i18n._({ id: 'node.fence.inspectorEditors.straight', message: 'Straight' }) }), _jsx("option", { value: "curve", children: i18n._({ id: 'node.fence.inspectorEditors.curved', message: 'Curved' }) })] })] })), (spanModes[index - 1] === 'curve' || spanModes[index] === 'curve') && (_jsxs("label", { className: "mt-2 flex items-center justify-between", children: [i18n._({ id: 'node.fence.inspectorEditors.join', message: 'Join' }), _jsxs("select", { className: "rounded border bg-background p-1", value: tangents[index]?.[0] === 0 && tangents[index]?.[1] === 0 ? 'corner' : 'smooth', onChange: (event) => {
                                     const handles = [...tangents];
                                     handles[index] = event.target.value === 'corner' ? [0, 0] : null;
                                     update(path, handles);
-                                }, children: [_jsx("option", { value: "smooth", children: "Smooth" }), _jsx("option", { value: "corner", children: "Corner" })] })] })), _jsxs("div", { className: "mt-2 flex gap-2", children: [index < path.length - 1 && (_jsx("button", { type: "button", className: "rounded border px-2 py-1", onClick: () => {
+                                }, children: [_jsx("option", { value: "smooth", children: i18n._({ id: 'node.fence.inspectorEditors.smooth', message: 'Smooth' }) }), _jsx("option", { value: "corner", children: i18n._({ id: 'node.fence.inspectorEditors.corner', message: 'Corner' }) })] })] })), _jsxs("div", { className: "mt-2 flex gap-2", children: [index < path.length - 1 && (_jsx("button", { type: "button", className: "rounded border px-2 py-1", onClick: () => {
                                     const a = getFenceControlHandle(path, node.tangents, index);
                                     const b = getFenceControlHandle(path, node.tangents, index + 1);
                                     const samples = sampleFenceSpline([point, path[index + 1]], [
@@ -147,13 +187,16 @@ export function FencePathEditor({ node, onUpdate, }) {
                                     const modes = [...spanModes];
                                     modes.splice(index, 1, spanModes[index], spanModes[index]);
                                     update(points, handles, modes);
-                                }, children: "Add point after" })), index === path.length - 1 && (_jsx("button", { type: "button", className: "rounded border px-2 py-1", onClick: () => {
+                                }, children: i18n._({
+                                    id: 'node.fence.inspectorEditors.addPointAfter',
+                                    message: 'Add point after',
+                                }) })), index === path.length - 1 && (_jsx("button", { type: "button", className: "rounded border px-2 py-1", onClick: () => {
                                     const previous = path[index - 1];
                                     update([
                                         ...path,
                                         [point[0] + point[0] - previous[0], point[1] + point[1] - previous[1]],
                                     ], [...tangents, null], [...spanModes, 'straight']);
-                                }, children: "Extend path" })), _jsx("button", { type: "button", className: "rounded border px-2 py-1 disabled:opacity-40", disabled: path.length <= 2, onClick: () => {
+                                }, children: i18n._({ id: 'node.fence.inspectorEditors.extendPath', message: 'Extend path' }) })), _jsx("button", { type: "button", className: "rounded border px-2 py-1 disabled:opacity-40", disabled: path.length <= 2, onClick: () => {
                                     const modes = [...spanModes];
                                     if (index === 0)
                                         modes.shift();
@@ -164,5 +207,5 @@ export function FencePathEditor({ node, onUpdate, }) {
                                             ? 'straight'
                                             : 'curve');
                                     update(path.filter((_, i) => i !== index), tangents.filter((_, i) => i !== index), modes);
-                                }, children: "Remove point" })] })] }, `curve-editor-${index}`)))] }));
+                                }, children: i18n._({ id: 'node.fence.inspectorEditors.removePoint', message: 'Remove point' }) })] })] }, `curve-editor-${index}`)))] }));
 }

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,EAKf,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,CA0M3E,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, 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';
@@ -40,6 +40,7 @@ function pickAngleLabel(args) {
     return null;
 }
 export const MoveFenceEndpointTool = ({ target }) => {
+    const i18n = usePascalI18n();
     const fenceId = target.fence.id;
     const endpoint = target.endpoint;
     const initialPoint = endpoint === 'start'
@@ -185,6 +186,14 @@ export const MoveFenceEndpointTool = ({ target }) => {
     const dimMidZ = (liveStart[1] + liveEnd[1]) / 2;
     return (_jsxs("group", { children: [_jsx(CursorSphere, { position: cursorPos, showTooltip: false }), _jsx(Html, { center: true, position: [dimMidX, fenceHeight + 0.3, dimMidZ], style: { pointerEvents: 'none', touchAction: 'none' }, zIndexRange: [100, 0], children: _jsx(MeasurementPill, { height: fenceHeight, length: liveLength, primary: "length", thickness: target.fence.thickness ?? 0.08, unit: unit }) }), _jsx(Html, { position: cursorPos, style: { pointerEvents: 'none', touchAction: 'none' }, zIndexRange: [100, 0], children: _jsx("div", { className: "translate-y-10", children: _jsx("div", { className: `whitespace-nowrap rounded-full border px-2 py-1 font-medium text-[11px] shadow-lg backdrop-blur-md transition-colors ${altPressed
                             ? 'border-amber-500/70 bg-amber-50/95 text-amber-800 dark:bg-amber-500/15 dark:text-amber-100'
-                            : 'border-border/70 bg-background/90 text-foreground/80'}`, children: altPressed ? 'Detach endpoint' : 'Drag endpoint' }) }) }), angleLabel && (_jsx(Html, { center: true, position: angleLabel.position, style: { pointerEvents: 'none' }, zIndexRange: [100, 0], children: _jsx("div", { className: "whitespace-nowrap rounded-full border border-border bg-background/95 px-2 py-1 font-mono font-semibold text-[11px] text-foreground shadow-lg backdrop-blur-md", children: angleLabel.label }) }))] }));
+                            : 'border-border/70 bg-background/90 text-foreground/80'}`, children: altPressed
+                            ? i18n._({
+                                id: 'node.fence.moveEndpointTool.detachEndpoint',
+                                message: 'Detach endpoint',
+                            })
+                            : i18n._({
+                                id: 'node.fence.moveEndpointTool.dragEndpoint',
+                                message: 'Drag endpoint',
+                            }) }) }) }), angleLabel && (_jsx(Html, { center: true, position: angleLabel.position, style: { pointerEvents: 'none' }, zIndexRange: [100, 0], children: _jsx("div", { className: "whitespace-nowrap rounded-full border border-border bg-background/95 px-2 py-1 font-mono font-semibold text-[11px] text-foreground shadow-lg backdrop-blur-md", children: angleLabel.label }) }))] }));
 };
 export default MoveFenceEndpointTool;

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

@@ -1 +1 @@
-{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/fence/system.tsx"],"names":[],"mappings":"AA+CA,QAAA,MAAM,YAAY,YAwHjB,CAAA;eAEc,YAAY"}
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/fence/system.tsx"],"names":[],"mappings":"AA+CA,QAAA,MAAM,YAAY,YAwIjB,CAAA;eAEc,YAAY"}

package/dist/fence/system.js

@@ -126,8 +126,21 @@ const FenceSystems = () => {
             outputs.current.clear();
         };
     }, []);
+    const followers = useRef({ nodes: null, any: false });
     useFrame(() => {
         const nodes = useScene.getState().nodes;
+        // Only a fence that follows surfaces cares when their geometry swaps. Without one there is
+        // nothing to watch; a follower added later is marked on creation and builds on what is there.
+        if (followers.current.nodes !== nodes) {
+            followers.current = {
+                nodes,
+                any: Object.values(nodes).some((node) => node.type === 'fence' && followsSurfaces(node)),
+            };
+        }
+        if (!followers.current.any) {
+            outputs.current.clear();
+            return;
+        }
         const changedLevels = new Set();
         for (const [id, level] of levels.current) {
             const root = sceneRegistry.nodes.get(id);

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';

package/dist/fence-feature/actions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../src/fence-feature/actions.tsx"],"names":[],"mappings":"AAOA;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,gBAAgB,uCAqBvC"}
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../src/fence-feature/actions.tsx"],"names":[],"mappings":"AAOA;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,gBAAgB,uCA0BvC"}

package/dist/fence-feature/actions.js

@@ -1,6 +1,6 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
-import { useScene } from '@pascal-app/core';
+import { usePascalI18n, useScene } from '@pascal-app/core';
 import { ActionMenuButton } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { DoorClosed, DoorOpen } from 'lucide-react';
@@ -11,6 +11,7 @@ import { toggleFenceGate } from './interaction.js';
  * never write the node.
  */
 export default function FenceGateActions() {
+    const i18n = usePascalI18n();
     const selected = useViewer((s) => s.selection.selectedIds);
     const gate = useScene((s) => {
         const node = selected.length === 1 ? s.nodes[selected[0]] : undefined;
@@ -19,7 +20,9 @@ export default function FenceGateActions() {
     if (!gate)
         return null;
     const open = (gate.openAngle ?? 0) > 0.01;
-    return (_jsx(ActionMenuButton, { keys: ['E'], label: open ? 'Close' : 'Open', onClick: (event) => {
+    return (_jsx(ActionMenuButton, { keys: ['E'], label: open
+            ? i18n._({ id: 'node.fenceFeature.actions.close', message: 'Close' })
+            : i18n._({ id: 'node.fenceFeature.actions.open', message: 'Open' }), onClick: (event) => {
             event.stopPropagation();
             toggleFenceGate(gate.id);
         }, pressed: open, children: open ? _jsx(DoorClosed, { className: "h-4 w-4" }) : _jsx(DoorOpen, { className: "h-4 w-4" }) }));

package/dist/fence-feature/definition.d.ts

@@ -1,4 +1,271 @@
-import { FenceGateNode, FenceOpeningNode, type NodeDefinition } from '@pascal-app/core';
-export declare const fenceGateDefinition: NodeDefinition<typeof FenceGateNode | typeof FenceOpeningNode>;
-export declare const fenceOpeningDefinition: NodeDefinition<typeof FenceGateNode | typeof FenceOpeningNode>;
+export declare const fenceGateDefinition: 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>>;
+    matchFenceStyle: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    matchFenceHeight: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    leafType: import("zod").ZodOptional<import("zod").ZodEnum<{
+        double: "double";
+        single: "single";
+    }>>;
+    style: import("zod").ZodOptional<import("zod").ZodEnum<{
+        guard: "guard";
+        horizontal: "horizontal";
+        match: "match";
+        picket: "picket";
+        privacy: "privacy";
+        rail: "rail";
+        slat: "slat";
+    }>>;
+    height: import("zod").ZodOptional<import("zod").ZodNumber>;
+    clearance: import("zod").ZodOptional<import("zod").ZodNumber>;
+    thickness: import("zod").ZodOptional<import("zod").ZodNumber>;
+    frameWidth: import("zod").ZodOptional<import("zod").ZodNumber>;
+    spacing: import("zod").ZodOptional<import("zod").ZodNumber>;
+    boardWidth: import("zod").ZodOptional<import("zod").ZodNumber>;
+    hinge: import("zod").ZodOptional<import("zod").ZodEnum<{
+        left: "left";
+        right: "right";
+    }>>;
+    swing: import("zod").ZodOptional<import("zod").ZodEnum<{
+        inward: "inward";
+        outward: "outward";
+    }>>;
+    openAngle: import("zod").ZodOptional<import("zod").ZodNumber>;
+    leafSplit: import("zod").ZodOptional<import("zod").ZodNumber>;
+    brace: import("zod").ZodOptional<import("zod").ZodEnum<{
+        cross: "cross";
+        diagonal: "diagonal";
+        none: "none";
+    }>>;
+    showHardware: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    showPosts: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    id: import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`fence-gate_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"fence-gate">>;
+    center: import("zod").ZodDefault<import("zod").ZodNumber>;
+    width: import("zod").ZodDefault<import("zod").ZodNumber>;
+}, import("zod/v4/core").$strip> | 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>>;
+    center: import("zod").ZodDefault<import("zod").ZodNumber>;
+    width: import("zod").ZodDefault<import("zod").ZodNumber>;
+    matchFenceStyle: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    matchFenceHeight: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    height: import("zod").ZodOptional<import("zod").ZodNumber>;
+    showPosts: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    id: import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`fence-opening_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"fence-opening">>;
+}, import("zod/v4/core").$strip>>;
+export declare const fenceOpeningDefinition: 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>>;
+    matchFenceStyle: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    matchFenceHeight: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    leafType: import("zod").ZodOptional<import("zod").ZodEnum<{
+        double: "double";
+        single: "single";
+    }>>;
+    style: import("zod").ZodOptional<import("zod").ZodEnum<{
+        guard: "guard";
+        horizontal: "horizontal";
+        match: "match";
+        picket: "picket";
+        privacy: "privacy";
+        rail: "rail";
+        slat: "slat";
+    }>>;
+    height: import("zod").ZodOptional<import("zod").ZodNumber>;
+    clearance: import("zod").ZodOptional<import("zod").ZodNumber>;
+    thickness: import("zod").ZodOptional<import("zod").ZodNumber>;
+    frameWidth: import("zod").ZodOptional<import("zod").ZodNumber>;
+    spacing: import("zod").ZodOptional<import("zod").ZodNumber>;
+    boardWidth: import("zod").ZodOptional<import("zod").ZodNumber>;
+    hinge: import("zod").ZodOptional<import("zod").ZodEnum<{
+        left: "left";
+        right: "right";
+    }>>;
+    swing: import("zod").ZodOptional<import("zod").ZodEnum<{
+        inward: "inward";
+        outward: "outward";
+    }>>;
+    openAngle: import("zod").ZodOptional<import("zod").ZodNumber>;
+    leafSplit: import("zod").ZodOptional<import("zod").ZodNumber>;
+    brace: import("zod").ZodOptional<import("zod").ZodEnum<{
+        cross: "cross";
+        diagonal: "diagonal";
+        none: "none";
+    }>>;
+    showHardware: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    showPosts: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    id: import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`fence-gate_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"fence-gate">>;
+    center: import("zod").ZodDefault<import("zod").ZodNumber>;
+    width: import("zod").ZodDefault<import("zod").ZodNumber>;
+}, import("zod/v4/core").$strip> | 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>>;
+    center: import("zod").ZodDefault<import("zod").ZodNumber>;
+    width: import("zod").ZodDefault<import("zod").ZodNumber>;
+    matchFenceStyle: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    matchFenceHeight: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    height: import("zod").ZodOptional<import("zod").ZodNumber>;
+    showPosts: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    id: import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`fence-opening_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"fence-opening">>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/fence-feature/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,aAAa,EACb,gBAAgB,EAGhB,KAAK,cAAc,EAEpB,MAAM,kBAAkB,CAAA;AA2DzB,eAAO,MAAM,mBAAmB,EAAE,cAAc,CAAC,OAAO,aAAa,GAAG,OAAO,gBAAgB,CA4B9F,CAAA;AAyBD,eAAO,MAAM,sBAAsB,EAAE,cAAc,CACjD,OAAO,aAAa,GAAG,OAAO,gBAAgB,CAgB/C,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/fence-feature/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAG/B,CAAA;AACD,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAGlC,CAAA"}

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

@@ -0,0 +1,5 @@
+import { type FenceGateNode, type FenceOpeningNode } from '@pascal-app/core';
+import type { NodeEditContribution } from '../definition-contributions.js';
+export declare const fenceGateEditContribution: NodeEditContribution<typeof FenceGateNode | typeof FenceOpeningNode>;
+export declare const fenceOpeningEditContribution: NodeEditContribution<typeof FenceGateNode | typeof FenceOpeningNode>;
+//# sourceMappingURL=definition.edit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/fence-feature/definition.edit.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,aAAa,EAClB,KAAK,gBAAgB,EAItB,MAAM,kBAAkB,CAAA;AAKzB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAgCvE,eAAO,MAAM,yBAAyB,EAAE,oBAAoB,CAC1D,OAAO,aAAa,GAAG,OAAO,gBAAgB,CA2B/C,CAAA;AAED,eAAO,MAAM,4BAA4B,EAAE,oBAAoB,CAC7D,OAAO,aAAa,GAAG,OAAO,gBAAgB,CAgB/C,CAAA"}