@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/fence-feature/definition.edit.js

@@ -0,0 +1,69 @@
+import { findLevelAncestorId, } from '@pascal-app/core';
+import { useViewer } from '@pascal-app/viewer';
+import { buildFenceFeatureFloorplan } from './floorplan.js';
+import { fenceFeatureAffordance } from './floorplan-affordances.js';
+import { fenceFeatureHandles } from './handles.js';
+import { FenceFeatureEditor } from './inspector.js';
+import { toggleFenceGate } from './interaction.js';
+import { createFenceFeatureMoveSession } from './move-session.js';
+const floorplanMoveTarget = ({ node, sceneApi }) => {
+    if (!sceneApi)
+        throw new Error('Fence feature move requires SceneApi');
+    const levelId = findLevelAncestorId(node.id, sceneApi.nodes()) ?? null;
+    const session = createFenceFeatureMoveSession(node, sceneApi, levelId, (id) => useViewer.getState().setSelection({ selectedIds: [id] }));
+    return {
+        affectedIds: session.affectedIds,
+        apply: ({ planPoint }) => session.update(planPoint),
+        canCommit: session.canCommit,
+        commit: session.commit,
+    };
+};
+const parametrics = {
+    groups: [
+        {
+            label: 'Settings',
+            fields: [{ key: 'center', kind: 'custom', component: FenceFeatureEditor }],
+        },
+    ],
+};
+export const fenceGateEditContribution = {
+    floorplan: buildFenceFeatureFloorplan,
+    floorplanDependencies: (node) => node.parentId ? [node.parentId] : [],
+    floorplanAffordances: { 'move-feature': fenceFeatureAffordance },
+    handles: fenceFeatureHandles,
+    floorplanMoveTarget,
+    affordanceTools: { move: () => import('./move-tool.js') },
+    affordanceHints: {
+        move: [
+            { key: 'Left click', label: 'Place on a fence' },
+            { key: 'Esc', label: 'Cancel move' },
+        ],
+    },
+    parametrics,
+    keyboardActions: {
+        e: {
+            appliesTo: (node) => node.type === 'fence-gate',
+            run: (node) => toggleFenceGate(node.id),
+        },
+    },
+    extensions: {
+        'pascal:editor/floorplan': {
+            actionMenu: { actions: () => import('./actions.js') },
+        },
+    },
+};
+export const fenceOpeningEditContribution = {
+    floorplan: buildFenceFeatureFloorplan,
+    floorplanDependencies: (node) => node.parentId ? [node.parentId] : [],
+    floorplanAffordances: { 'move-feature': fenceFeatureAffordance },
+    handles: fenceFeatureHandles,
+    floorplanMoveTarget,
+    affordanceTools: { move: () => import('./move-tool.js') },
+    affordanceHints: {
+        move: [
+            { key: 'Left click', label: 'Place on a fence' },
+            { key: 'Esc', label: 'Cancel move' },
+        ],
+    },
+    parametrics,
+};

package/dist/fence-feature/definition.js

@@ -1,116 +1,5 @@
-import { FenceGateNode, FenceOpeningNode, findLevelAncestorId, } from '@pascal-app/core';
-import { useViewer } from '@pascal-app/viewer';
-import { AnimationClip, QuaternionKeyframeTrack } from 'three';
-import { buildFenceFeatureFloorplan } from './floorplan.js';
-import { fenceFeatureAffordance } from './floorplan-affordances.js';
-import { buildFenceFeatureGeometry } from './geometry.js';
-import { fenceFeatureHandles } from './handles.js';
-import { FenceFeatureEditor } from './inspector.js';
-import { toggleFenceGate } from './interaction.js';
-import { createFenceFeatureMoveSession } from './move-session.js';
-const floorplanMoveTarget = ({ node, sceneApi }) => {
-    if (!sceneApi)
-        throw new Error('Fence feature move requires SceneApi');
-    const levelId = findLevelAncestorId(node.id, sceneApi.nodes()) ?? null;
-    const session = createFenceFeatureMoveSession(node, sceneApi, levelId, (id) => useViewer.getState().setSelection({ selectedIds: [id] }));
-    return {
-        affectedIds: session.affectedIds,
-        apply: ({ planPoint }) => session.update(planPoint),
-        canCommit: session.canCommit,
-        commit: session.commit,
-    };
-};
-const parametrics = {
-    groups: [
-        {
-            label: 'Settings',
-            fields: [{ key: 'center', kind: 'custom', component: FenceFeatureEditor }],
-        },
-    ],
-};
-const shared = {
-    schemaVersion: 1,
-    category: 'structure',
-    capabilities: {
-        exterior: true,
-        selectable: { hitVolume: 'bbox' },
-        deletable: true,
-    },
-    geometry: buildFenceFeatureGeometry,
-    floorplan: buildFenceFeatureFloorplan,
-    floorplanDependencies: (node) => node.parentId ? [node.parentId] : [],
-    floorplanAffordances: { 'move-feature': fenceFeatureAffordance },
-    handles: fenceFeatureHandles,
-    floorplanMoveTarget,
-    affordanceTools: { move: () => import('./move-tool.js') },
-    affordanceHints: {
-        move: [
-            { key: 'Left click', label: 'Place on a fence' },
-            { key: 'Esc', label: 'Cancel move' },
-        ],
-    },
-    parametrics,
-};
-export const fenceGateDefinition = {
-    ...shared,
-    kind: 'fence-gate',
-    keyboardActions: {
-        e: {
-            appliesTo: (node) => node.type === 'fence-gate',
-            run: (node) => toggleFenceGate(node.id),
-        },
-    },
-    schema: FenceGateNode,
-    extensions: {
-        'pascal:editor/floorplan': {
-            actionMenu: { actions: () => import('./actions.js') },
-        },
-    },
-    exportAnimation: ({ node, object }) => node.type === 'fence-gate' ? bakeFenceGateClip(node.id, object) : null,
-    defaults: () => {
-        const { id, type, ...rest } = FenceGateNode.parse({});
-        return rest;
-    },
-    presentation: {
-        label: 'Gate',
-        description: 'A gate hosted by a fence.',
-        icon: { kind: 'url', src: '/icons/fence.webp' },
-        paletteSection: 'structure',
-        hidden: true,
-    },
-};
-function bakeFenceGateClip(id, object) {
-    const tracks = [];
-    object.traverse((part) => {
-        const marker = part.userData.pascalFenceGateLeaf;
-        if (typeof marker?.openRotationY !== 'number' || Math.abs(marker.openRotationY) < 1e-5)
-            return;
-        part.rotation.y = 0;
-        const closed = part.quaternion.clone();
-        part.rotation.y = marker.openRotationY;
-        const open = part.quaternion.clone();
-        part.rotation.y = 0;
-        tracks.push(new QuaternionKeyframeTrack(`${part.uuid}.quaternion`, [0, 1], [...closed.toArray(), ...open.toArray()]));
-    });
-    if (tracks.length === 0)
-        return null;
-    const clip = new AnimationClip(`${id}: open`, 1, tracks);
-    clip.userData = { loop: false };
-    return clip;
-}
-export const fenceOpeningDefinition = {
-    ...shared,
-    kind: 'fence-opening',
-    schema: FenceOpeningNode,
-    defaults: () => {
-        const { id, type, ...rest } = FenceOpeningNode.parse({});
-        return rest;
-    },
-    presentation: {
-        label: 'Open Passage',
-        description: 'An intentional opening in a fence.',
-        icon: { kind: 'url', src: '/icons/door.webp' },
-        paletteSection: 'structure',
-        hidden: true,
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { fenceGateEditContribution, fenceOpeningEditContribution } from './definition.edit.js';
+import { fenceGateRenderDefinition, fenceOpeningRenderDefinition } from './definition.render.js';
+export const fenceGateDefinition = composeNodeDefinition(fenceGateRenderDefinition, fenceGateEditContribution);
+export const fenceOpeningDefinition = composeNodeDefinition(fenceOpeningRenderDefinition, fenceOpeningEditContribution);

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

@@ -0,0 +1,9 @@
+import { FenceGateNode, FenceOpeningNode } from '@pascal-app/core';
+import type { NodeRenderDefinition } from '../definition-contributions.js';
+export declare const fenceGateRenderDefinition: NodeRenderDefinition<typeof FenceGateNode | typeof FenceOpeningNode> & {
+    kind: 'fence-gate';
+};
+export declare const fenceOpeningRenderDefinition: NodeRenderDefinition<typeof FenceGateNode | typeof FenceOpeningNode> & {
+    kind: 'fence-opening';
+};
+//# sourceMappingURL=definition.render.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/fence-feature/definition.render.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AAGlE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AA2BvE,eAAO,MAAM,yBAAyB,EAAE,oBAAoB,CAC1D,OAAO,aAAa,GAAG,OAAO,gBAAgB,CAC/C,GAAG;IAAE,IAAI,EAAE,YAAY,CAAA;CAwBvB,CAAA;AAED,eAAO,MAAM,4BAA4B,EAAE,oBAAoB,CAC7D,OAAO,aAAa,GAAG,OAAO,gBAAgB,CAC/C,GAAG;IAAE,IAAI,EAAE,eAAe,CAAA;CAsB1B,CAAA"}

package/dist/fence-feature/definition.render.js

@@ -0,0 +1,69 @@
+import { FenceGateNode, FenceOpeningNode } from '@pascal-app/core';
+import { AnimationClip, QuaternionKeyframeTrack } from 'three';
+import { buildFenceFeatureGeometry } from './geometry.js';
+function bakeFenceGateClip(id, object) {
+    const tracks = [];
+    object.traverse((part) => {
+        const marker = part.userData.pascalFenceGateLeaf;
+        if (typeof marker?.openRotationY !== 'number' || Math.abs(marker.openRotationY) < 1e-5)
+            return;
+        part.rotation.y = 0;
+        const closed = part.quaternion.clone();
+        part.rotation.y = marker.openRotationY;
+        const open = part.quaternion.clone();
+        part.rotation.y = 0;
+        tracks.push(new QuaternionKeyframeTrack(`${part.uuid}.quaternion`, [0, 1], [...closed.toArray(), ...open.toArray()]));
+    });
+    if (tracks.length === 0)
+        return null;
+    const clip = new AnimationClip(`${id}: open`, 1, tracks);
+    clip.userData = { loop: false };
+    return clip;
+}
+export const fenceGateRenderDefinition = {
+    schemaVersion: 1,
+    category: 'structure',
+    capabilities: {
+        exterior: true,
+        selectable: { hitVolume: 'bbox' },
+        deletable: true,
+    },
+    geometry: buildFenceFeatureGeometry,
+    kind: 'fence-gate',
+    schema: FenceGateNode,
+    exportAnimation: ({ node, object }) => node.type === 'fence-gate' ? bakeFenceGateClip(node.id, object) : null,
+    defaults: () => {
+        const { id, type, ...rest } = FenceGateNode.parse({});
+        return rest;
+    },
+    presentation: {
+        label: 'Gate',
+        description: 'A gate hosted by a fence.',
+        icon: { kind: 'url', src: '/icons/fence.webp' },
+        paletteSection: 'structure',
+        hidden: true,
+    },
+};
+export const fenceOpeningRenderDefinition = {
+    schemaVersion: 1,
+    category: 'structure',
+    capabilities: {
+        exterior: true,
+        selectable: { hitVolume: 'bbox' },
+        deletable: true,
+    },
+    geometry: buildFenceFeatureGeometry,
+    kind: 'fence-opening',
+    schema: FenceOpeningNode,
+    defaults: () => {
+        const { id, type, ...rest } = FenceOpeningNode.parse({});
+        return rest;
+    },
+    presentation: {
+        label: 'Open Passage',
+        description: 'An intentional opening in a fence.',
+        icon: { kind: 'url', src: '/icons/door.webp' },
+        paletteSection: 'structure',
+        hidden: true,
+    },
+};

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

@@ -1 +1 @@
-{"version":3,"file":"inspector.d.ts","sourceRoot":"","sources":["../../src/fence-feature/inspector.tsx"],"names":[],"mappings":"AACA,OAAO,EAIL,KAAK,gBAAgB,EAMtB,MAAM,kBAAkB,CAAA;AAMzB,wBAAgB,kBAAkB,CAAC,EACjC,IAAI,EAAE,KAAK,EACX,QAAQ,GACT,EAAE;IACD,IAAI,EAAE,gBAAgB,CAAA;IACtB,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,gBAAgB,CAAC,KAAK,IAAI,CAAA;CACrD,+BAkTA"}
+{"version":3,"file":"inspector.d.ts","sourceRoot":"","sources":["../../src/fence-feature/inspector.tsx"],"names":[],"mappings":"AACA,OAAO,EAIL,KAAK,gBAAgB,EAOtB,MAAM,kBAAkB,CAAA;AAMzB,wBAAgB,kBAAkB,CAAC,EACjC,IAAI,EAAE,KAAK,EACX,QAAQ,GACT,EAAE;IACD,IAAI,EAAE,gBAAgB,CAAA;IACtB,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,gBAAgB,CAAC,KAAK,IAAI,CAAA;CACrD,+BAubA"}

package/dist/fence-feature/inspector.js

@@ -1,12 +1,13 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { canPlaceFenceFeature, FenceStyle, fenceFeatureData, fenceWithFeatures, getFenceCenterlineLength, useScene, } from '@pascal-app/core';
+import { canPlaceFenceFeature, FenceStyle, fenceFeatureData, fenceWithFeatures, getFenceCenterlineLength, usePascalI18n, useScene, } from '@pascal-app/core';
 import { ActionButton, SliderControl, ToggleControl } from '@pascal-app/editor';
 import { useState } from 'react';
 import { useShallow } from 'zustand/react/shallow';
 import { getFenceFeatureDimensions } from '../fence/geometry-parts.js';
 export function FenceFeatureEditor({ node: child, onUpdate, }) {
-    const [error, setError] = useState('');
+    const i18n = usePascalI18n();
+    const [blocked, setBlocked] = useState(false);
     const parentId = child.parentId;
     const parent = useScene((s) => (parentId ? s.nodes[parentId] : undefined));
     const siblings = useScene(useShallow((s) => {
@@ -16,7 +17,10 @@ export function FenceFeatureEditor({ node: child, onUpdate, }) {
             : [];
     }));
     if (parent?.type !== 'fence')
-        return _jsx("p", { children: "Fence unavailable." });
+        return (_jsx("p", { children: i18n._({
+                id: 'node.fenceFeature.inspector.fenceUnavailable',
+                message: 'Fence unavailable.',
+            }) }));
     const node = fenceWithFeatures(parent, siblings);
     const features = [fenceFeatureData(child)];
     const length = getFenceCenterlineLength(node);
@@ -27,13 +31,16 @@ export function FenceFeatureEditor({ node: child, onUpdate, }) {
         const next = { ...original, ...patch };
         if ((patch.width !== undefined || patch.center !== undefined) &&
             !canPlaceFenceFeature(node, next)) {
-            setError('Keep the opening inside the fence and clear of other gates or passages.');
+            setBlocked(true);
             return;
         }
-        setError('');
+        setBlocked(false);
         onUpdate(patch);
     };
-    return (_jsxs("div", { className: "space-y-2 text-xs", children: [error && (_jsx("p", { role: "status", className: "text-amber-500", children: error })), features.map((feature) => {
+    return (_jsxs("div", { className: "space-y-2 text-xs", children: [blocked && (_jsx("p", { role: "status", className: "text-amber-500", children: i18n._({
+                    id: 'node.fenceFeature.inspector.keepTheOpeningInsideTheFence',
+                    message: 'Keep the opening inside the fence and clear of other gates or passages.',
+                }) })), features.map((feature) => {
                 const gate = feature.kind === 'gate';
                 const { height, bottom } = getFenceFeatureDimensions(node, feature);
                 const selects = [
@@ -41,39 +48,87 @@ export function FenceFeatureEditor({ node: child, onUpdate, }) {
                         ? [
                             {
                                 key: 'leafType',
-                                label: 'Leaves',
+                                label: i18n._({ id: 'node.fenceFeature.inspector.leaves', message: 'Leaves' }),
                                 value: feature.leafType ?? 'single',
                                 options: [
-                                    ['single', 'Single gate'],
-                                    ['double', 'Double gate'],
+                                    [
+                                        'single',
+                                        i18n._({
+                                            id: 'node.fenceFeature.inspector.option.singleGate',
+                                            message: 'Single gate',
+                                        }),
+                                    ],
+                                    [
+                                        'double',
+                                        i18n._({
+                                            id: 'node.fenceFeature.inspector.option.doubleGate',
+                                            message: 'Double gate',
+                                        }),
+                                    ],
                                 ],
                             },
                             {
                                 key: 'hinge',
-                                label: 'Hinge side',
+                                label: i18n._({
+                                    id: 'node.fenceFeature.inspector.hingeSide',
+                                    message: 'Hinge side',
+                                }),
                                 value: feature.hinge ?? 'left',
                                 options: [
-                                    ['left', 'Left'],
-                                    ['right', 'Right'],
+                                    [
+                                        'left',
+                                        i18n._({ id: 'node.fenceFeature.inspector.option.left', message: 'Left' }),
+                                    ],
+                                    [
+                                        'right',
+                                        i18n._({ id: 'node.fenceFeature.inspector.option.right', message: 'Right' }),
+                                    ],
                                 ],
                             },
                             {
                                 key: 'swing',
-                                label: 'Swing direction',
+                                label: i18n._({
+                                    id: 'node.fenceFeature.inspector.swingDirection',
+                                    message: 'Swing direction',
+                                }),
                                 value: feature.swing ?? 'inward',
                                 options: [
-                                    ['inward', 'Inward'],
-                                    ['outward', 'Outward'],
+                                    [
+                                        'inward',
+                                        i18n._({
+                                            id: 'node.fenceFeature.inspector.option.inward',
+                                            message: 'Inward',
+                                        }),
+                                    ],
+                                    [
+                                        'outward',
+                                        i18n._({
+                                            id: 'node.fenceFeature.inspector.option.outward',
+                                            message: 'Outward',
+                                        }),
+                                    ],
                                 ],
                             },
                             {
                                 key: 'brace',
-                                label: 'Bracing',
+                                label: i18n._({ id: 'node.fenceFeature.inspector.bracing', message: 'Bracing' }),
                                 value: feature.brace ?? 'none',
                                 options: [
-                                    ['none', 'None'],
-                                    ['diagonal', 'Diagonal'],
-                                    ['cross', 'Cross'],
+                                    [
+                                        'none',
+                                        i18n._({ id: 'node.fenceFeature.inspector.option.none', message: 'None' }),
+                                    ],
+                                    [
+                                        'diagonal',
+                                        i18n._({
+                                            id: 'node.fenceFeature.inspector.option.diagonal',
+                                            message: 'Diagonal',
+                                        }),
+                                    ],
+                                    [
+                                        'cross',
+                                        i18n._({ id: 'node.fenceFeature.inspector.option.cross', message: 'Cross' }),
+                                    ],
                                 ],
                             },
                         ]
@@ -82,7 +137,10 @@ export function FenceFeatureEditor({ node: child, onUpdate, }) {
                 const numbers = [
                     {
                         key: 'center',
-                        label: 'Distance from start',
+                        label: i18n._({
+                            id: 'node.fenceFeature.inspector.distanceFromStart',
+                            message: 'Distance from start',
+                        }),
                         value: feature.center,
                         min: 0,
                         max: length,
@@ -91,7 +149,10 @@ export function FenceFeatureEditor({ node: child, onUpdate, }) {
                     },
                     {
                         key: 'width',
-                        label: 'Opening width',
+                        label: i18n._({
+                            id: 'node.fenceFeature.inspector.openingWidth',
+                            message: 'Opening width',
+                        }),
                         value: feature.width,
                         min: 0.35,
                         max: length,
@@ -100,7 +161,9 @@ export function FenceFeatureEditor({ node: child, onUpdate, }) {
                     },
                     {
                         key: 'height',
-                        label: gate ? 'Gate height' : 'Post height',
+                        label: gate
+                            ? i18n._({ id: 'node.fenceFeature.inspector.gateHeight', message: 'Gate height' })
+                            : i18n._({ id: 'node.fenceFeature.inspector.postHeight', message: 'Post height' }),
                         value: height,
                         min: 0.3,
                         max: 1000,
@@ -111,7 +174,10 @@ export function FenceFeatureEditor({ node: child, onUpdate, }) {
                         ? [
                             {
                                 key: 'clearance',
-                                label: 'Ground clearance',
+                                label: i18n._({
+                                    id: 'node.fenceFeature.inspector.groundClearance',
+                                    message: 'Ground clearance',
+                                }),
                                 value: bottom,
                                 min: 0,
                                 max: 1000,
@@ -120,7 +186,10 @@ export function FenceFeatureEditor({ node: child, onUpdate, }) {
                             },
                             {
                                 key: 'openAngle',
-                                label: 'Opening angle',
+                                label: i18n._({
+                                    id: 'node.fenceFeature.inspector.openingAngle',
+                                    message: 'Opening angle',
+                                }),
                                 value: feature.openAngle ?? 0,
                                 min: 0,
                                 max: 170,
@@ -129,7 +198,10 @@ export function FenceFeatureEditor({ node: child, onUpdate, }) {
                             },
                             {
                                 key: 'thickness',
-                                label: 'Leaf thickness',
+                                label: i18n._({
+                                    id: 'node.fenceFeature.inspector.leafThickness',
+                                    message: 'Leaf thickness',
+                                }),
                                 value: feature.thickness ?? 0.06,
                                 min: 0.02,
                                 max: 0.3,
@@ -138,7 +210,10 @@ export function FenceFeatureEditor({ node: child, onUpdate, }) {
                             },
                             {
                                 key: 'frameWidth',
-                                label: 'Frame width',
+                                label: i18n._({
+                                    id: 'node.fenceFeature.inspector.frameWidth',
+                                    message: 'Frame width',
+                                }),
                                 value: feature.frameWidth ?? 0.055,
                                 min: 0.025,
                                 max: 0.2,
@@ -147,7 +222,10 @@ export function FenceFeatureEditor({ node: child, onUpdate, }) {
                             },
                             {
                                 key: 'spacing',
-                                label: 'Infill spacing',
+                                label: i18n._({
+                                    id: 'node.fenceFeature.inspector.infillSpacing',
+                                    message: 'Infill spacing',
+                                }),
                                 value: feature.spacing ?? 0.15,
                                 min: 0.04,
                                 max: 1000,
@@ -156,7 +234,10 @@ export function FenceFeatureEditor({ node: child, onUpdate, }) {
                             },
                             {
                                 key: 'boardWidth',
-                                label: 'Board width',
+                                label: i18n._({
+                                    id: 'node.fenceFeature.inspector.boardWidth',
+                                    message: 'Board width',
+                                }),
                                 value: feature.boardWidth ?? 0.055,
                                 min: 0.02,
                                 max: 0.3,
@@ -167,7 +248,10 @@ export function FenceFeatureEditor({ node: child, onUpdate, }) {
                                 ? [
                                     {
                                         key: 'leafSplit',
-                                        label: 'Left leaf proportion',
+                                        label: i18n._({
+                                            id: 'node.fenceFeature.inspector.leftLeafProportion',
+                                            message: 'Left leaf proportion',
+                                        }),
                                         value: feature.leafSplit ?? 0.5,
                                         min: 0.2,
                                         max: 0.8,
@@ -179,20 +263,38 @@ export function FenceFeatureEditor({ node: child, onUpdate, }) {
                         ]
                         : []),
                 ];
-                return (_jsx("div", { children: _jsxs("div", { className: "mt-2 space-y-2", children: [_jsx(ToggleControl, { label: "Match fence style", checked: feature.matchFenceStyle !== false, onChange: (checked) => update(feature.id, {
+                return (_jsx("div", { children: _jsxs("div", { className: "mt-2 space-y-2", children: [_jsx(ToggleControl, { label: i18n._({
+                                    id: 'node.fenceFeature.inspector.matchFenceStyle',
+                                    message: 'Match fence style',
+                                }), checked: feature.matchFenceStyle !== false, onChange: (checked) => update(feature.id, {
                                     matchFenceStyle: checked,
                                     ...(checked
                                         ? { matchFenceHeight: true }
                                         : { style: feature.style === 'match' ? 'picket' : feature.style }),
-                                }) }), _jsx(ToggleControl, { label: "Match fence height", checked: feature.matchFenceHeight ?? feature.matchFenceStyle !== false, onChange: (checked) => update(feature.id, {
+                                }) }), _jsx(ToggleControl, { label: i18n._({
+                                    id: 'node.fenceFeature.inspector.matchFenceHeight',
+                                    message: 'Match fence height',
+                                }), checked: feature.matchFenceHeight ?? feature.matchFenceStyle !== false, onChange: (checked) => update(feature.id, {
                                     matchFenceHeight: checked,
                                     height,
                                     ...(gate ? { clearance: bottom } : {}),
-                                }) }), gate && feature.matchFenceStyle === false && (_jsxs("label", { className: "flex min-h-9 items-center justify-between gap-3 text-xs text-muted-foreground", children: ["Gate style", _jsxs("select", { className: "h-8 min-w-0 max-w-40 rounded-lg border border-border/50 bg-black/4 dark:bg-[#2C2C2E] px-2 text-xs text-foreground outline-none transition-colors hover:bg-black/8 dark:hover:bg-[#3e3e3e] focus-visible:ring-2 focus-visible:ring-ring", value: feature.style && feature.style !== 'match' ? feature.style : 'picket', onChange: (event) => {
+                                }) }), gate && feature.matchFenceStyle === false && (_jsxs("label", { className: "flex min-h-9 items-center justify-between gap-3 text-xs text-muted-foreground", children: [i18n._({ id: 'node.fenceFeature.inspector.gateStyle', message: 'Gate style' }), _jsxs("select", { className: "h-8 min-w-0 max-w-40 rounded-lg border border-border/50 bg-black/4 dark:bg-[#2C2C2E] px-2 text-xs text-foreground outline-none transition-colors hover:bg-black/8 dark:hover:bg-[#3e3e3e] focus-visible:ring-2 focus-visible:ring-ring", value: feature.style && feature.style !== 'match' ? feature.style : 'picket', onChange: (event) => {
                                             const style = FenceStyle.safeParse(event.currentTarget.value);
                                             if (style.success)
                                                 update(feature.id, { style: style.data });
-                                        }, children: [_jsx("option", { value: "picket", children: "Picket" }), _jsx("option", { value: "slat", children: "Vertical slats" }), _jsx("option", { value: "horizontal", children: "Horizontal boards" }), _jsx("option", { value: "privacy", children: "Solid privacy" }), _jsx("option", { value: "rail", children: "Open rails" })] })] })), selects
+                                        }, children: [_jsx("option", { value: "picket", children: i18n._({ id: 'node.fenceFeature.inspector.picket', message: 'Picket' }) }), _jsx("option", { value: "slat", children: i18n._({
+                                                    id: 'node.fenceFeature.inspector.verticalSlats',
+                                                    message: 'Vertical slats',
+                                                }) }), _jsx("option", { value: "horizontal", children: i18n._({
+                                                    id: 'node.fenceFeature.inspector.horizontalBoards',
+                                                    message: 'Horizontal boards',
+                                                }) }), _jsx("option", { value: "privacy", children: i18n._({
+                                                    id: 'node.fenceFeature.inspector.solidPrivacy',
+                                                    message: 'Solid privacy',
+                                                }) }), _jsx("option", { value: "rail", children: i18n._({
+                                                    id: 'node.fenceFeature.inspector.openRails',
+                                                    message: 'Open rails',
+                                                }) })] })] })), selects
                                 .filter((field) => field.key !== 'hinge' || feature.leafType !== 'double')
                                 .map((field) => (_jsxs("label", { className: "flex min-h-9 items-center justify-between gap-3 text-xs text-muted-foreground", children: [field.label, _jsx("select", { className: "h-8 min-w-0 max-w-40 rounded-lg border border-border/50 bg-black/4 dark:bg-[#2C2C2E] px-2 text-xs text-foreground outline-none transition-colors hover:bg-black/8 dark:hover:bg-[#3e3e3e] focus-visible:ring-2 focus-visible:ring-ring", value: field.value, onChange: (event) => update(feature.id, { [field.key]: event.target.value }), children: field.options.map(([value, label]) => (_jsx("option", { value: value, children: label }, value))) })] }, field.key))), numbers
                                 .filter((field) => feature.matchFenceStyle === false ||
@@ -209,6 +311,20 @@ export function FenceFeatureEditor({ node: child, onUpdate, }) {
                                                     : {}),
                                         }
                                         : {}),
-                                }) }, field.key))), _jsx(ToggleControl, { label: "Jamb posts", checked: feature.showPosts !== false, onChange: (checked) => update(feature.id, { showPosts: checked }) }), gate && (_jsx(ToggleControl, { label: "Hinges and latch", checked: feature.showHardware !== false, onChange: (checked) => update(feature.id, { showHardware: checked }) })), _jsx(ActionButton, { type: "button", label: gate ? 'Remove gate' : 'Remove opening', className: "w-full text-destructive hover:text-destructive", onClick: () => useScene.getState().deleteNode(child.id) })] }) }, feature.id));
+                                }) }, field.key))), _jsx(ToggleControl, { label: i18n._({
+                                    id: 'node.fenceFeature.inspector.jambPosts',
+                                    message: 'Jamb posts',
+                                }), checked: feature.showPosts !== false, onChange: (checked) => update(feature.id, { showPosts: checked }) }), gate && (_jsx(ToggleControl, { label: i18n._({
+                                    id: 'node.fenceFeature.inspector.hingesAndLatch',
+                                    message: 'Hinges and latch',
+                                }), checked: feature.showHardware !== false, onChange: (checked) => update(feature.id, { showHardware: checked }) })), _jsx(ActionButton, { type: "button", label: gate
+                                    ? i18n._({
+                                        id: 'node.fenceFeature.inspector.removeGate',
+                                        message: 'Remove gate',
+                                    })
+                                    : i18n._({
+                                        id: 'node.fenceFeature.inspector.removeOpening',
+                                        message: 'Remove opening',
+                                    }), className: "w-full text-destructive hover:text-destructive", onClick: () => useScene.getState().deleteNode(child.id) })] }) }, feature.id));
             })] }));
 }

package/dist/fence-feature/move-session.d.ts

@@ -1,6 +1,6 @@
 import { type AnyNodeId, type FenceFeatureNode, type FenceNode, type GridEvent, type SceneApi } from '@pascal-app/core';
 export declare function createFenceFeatureMoveSession(node: FenceFeatureNode, sceneApi: SceneApi, levelId: AnyNodeId | null, selectNode: (id: AnyNodeId) => void): {
-    affectedIds: (`block_${string}` | `building_${string}` | `bvent_${string}` | `cabinet-module_${string}` | `cabinet_${string}` | `ceiling_${string}` | `chimney_${string}` | `column_${string}` | `construction-dimension_${string}` | `cupola_${string}` | `door_${string}` | `dormer_${string}` | `downspout_${string}` | `duct-fitting_${string}` | `duct-segment_${string}` | `duct-terminal_${string}` | `elevator_${string}` | `eyebrow-vent_${string}` | `fence-gate_${string}` | `fence-opening_${string}` | `fence_${string}` | `floor-opening_${string}` | `guide_${string}` | `gutter_${string}` | `hvac-equipment_${string}` | `imesh_${string}` | `item_${string}` | `leanto_${string}` | `level_${string}` | `lineset_${string}` | `liquid-line_${string}` | `measurement_${string}` | `pipe-fitting_${string}` | `pipe-segment_${string}` | `pipe-trap_${string}` | `procedural-item_${string}` | `roof_${string}` | `rseg_${string}` | `rvent_${string}` | `scan_${string}` | `separator_${string}` | `shelf_${string}` | `site_${string}` | `skylight_${string}` | `slab_${string}` | `solarpanel_${string}` | `spawn_${string}` | `sseg_${string}` | `stair_${string}` | `structural-grid_${string}` | `tvent_${string}` | `unit_${string}` | `wall_${string}` | `window_${string}` | `zone_${string}`)[];
+    affectedIds: (`beam_${string}` | `block_${string}` | `building_${string}` | `bvent_${string}` | `cabinet-module_${string}` | `cabinet_${string}` | `ceiling_${string}` | `chimney_${string}` | `column_${string}` | `construction-dimension_${string}` | `cupola_${string}` | `door_${string}` | `dormer_${string}` | `downspout_${string}` | `duct-fitting_${string}` | `duct-segment_${string}` | `duct-terminal_${string}` | `elevator_${string}` | `eyebrow-vent_${string}` | `fence-gate_${string}` | `fence-opening_${string}` | `fence_${string}` | `floor-opening_${string}` | `guide_${string}` | `gutter_${string}` | `hvac-equipment_${string}` | `imesh_${string}` | `item_${string}` | `leanto_${string}` | `level_${string}` | `lineset_${string}` | `liquid-line_${string}` | `measurement_${string}` | `pipe-fitting_${string}` | `pipe-segment_${string}` | `pipe-trap_${string}` | `procedural-item_${string}` | `roof_${string}` | `rseg_${string}` | `rvent_${string}` | `scan_${string}` | `separator_${string}` | `shelf_${string}` | `site_${string}` | `skylight_${string}` | `slab_${string}` | `solarpanel_${string}` | `spawn_${string}` | `sseg_${string}` | `stair_${string}` | `structural-grid_${string}` | `tvent_${string}` | `unit_${string}` | `wall_${string}` | `window_${string}` | `zone_${string}`)[];
     clear: () => void;
     update(point: readonly [number, number], host?: FenceNode, ray?: GridEvent['localRay']): void;
     canCommit: () => boolean;