@pascal-app/nodes 1.0.7 → 1.1.0

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"}

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/floor-opening/definition.d.ts

@@ -1,3 +1,59 @@
-import { FloorOpeningNode, type NodeDefinition } from '@pascal-app/core';
-export declare const floorOpeningDefinition: NodeDefinition<typeof FloorOpeningNode>;
+export declare const floorOpeningDefinition: 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<`floor-opening_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"floor-opening">>;
+    polygon: import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    hostZoneId: import("zod").ZodOptional<import("zod").ZodString>;
+    legacyPlateCuts: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodArray<import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>>>>;
+    legacyCeilingCuts: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodArray<import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>>>>;
+    source: import("zod").ZodDefault<import("zod").ZodString>;
+    ownerId: import("zod").ZodOptional<import("zod").ZodString>;
+    surfaceId: import("zod").ZodOptional<import("zod").ZodString>;
+    drawnOn: import("zod").ZodDefault<import("zod").ZodEnum<{
+        ceiling: "ceiling";
+        floor: "floor";
+    }>>;
+    cutsPrimary: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    cutsAdjacent: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

package/dist/floor-opening/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/floor-opening/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,KAAK,cAAc,EAAE,MAAM,kBAAkB,CAAA;AASxE,eAAO,MAAM,sBAAsB,EAAE,cAAc,CAAC,OAAO,gBAAgB,CA0C1E,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/floor-opening/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAGlC,CAAA"}

package/dist/floor-opening/definition.edit.d.ts

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

package/dist/floor-opening/definition.edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/floor-opening/definition.edit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AACxD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AASvE,eAAO,MAAM,4BAA4B,EAAE,oBAAoB,CAAC,OAAO,gBAAgB,CAStF,CAAA"}