@pascal-app/nodes 1.0.7 → 1.1.0

package/dist/downspout/definition.js

@@ -1,188 +1,4 @@
-import { DownspoutNode as DownspoutNodeSchema, downspoutSlots, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
-import { surfacePaintCapability } from '../shared/surface-paint.js';
-import { downspoutParametrics } from './parametrics.js';
-import { computeDownspoutPath, downspoutPipeDims, effectiveWallJog, resolveDownspoutRouting, } from './routing.js';
-import { DownspoutNode } from './schema.js';
-// Mirrors the parametric `min`s so handle drags can't shrink the pipe
-// past what the inspector would accept.
-const MIN_LENGTH = 0.1;
-// The length cube + dashed leader ride the straight WALL RUN, offset
-// outward (+Z, over the eave) past the pipe surface so they float clear
-// of the pipe instead of touching it.
-const LENGTH_HANDLE_PAD = 0.12;
-// Lift the length cube a little up the run from the very bottom so it
-// reads as a height grip rather than sitting at the pipe's end. Clamped
-// to the run top so it never climbs above the straight section.
-const CUBE_LIFT = 0.18;
-// Side-move arrows: how far ±X (along the eave) they sit from the pipe,
-// and how far below the gutter floor — near the top so they read as
-// "grab and slide along the eave".
-const SIDE_MOVE_OFFSET = 0.22;
-const SIDE_MOVE_Y = -0.12;
-/**
- * Length tracker — a dashed vertical leader from the outlet (Y = 0,
- * the gutter floor) down to a small cube near the bottom of the
- * straight wall run, `anchor: 'max'` + `axis: 'y'` so dragging the
- * cube down extends the pipe 1:1.
- *
- * Both the cube and the leader sit on the wall-run line but offset
- * outward (away from the pipe) by `radius + LENGTH_HANDLE_PAD`, so the
- * whole dimension floats clear of the pipe — it reads as "change the
- * height" rather than a box jammed onto the kicked-out mouth. The cube
- * rides the run BOTTOM (above the kickout), not the mouth, so the
- * dimension stays on the straight part.
- */
-function downspoutLengthHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'y',
-        anchor: 'max',
-        shape: 'tracker',
-        min: MIN_LENGTH,
-        gridSnap: true,
-        currentValue: (n) => n.length,
-        apply: (_n, newValue) => ({
-            length: Math.max(MIN_LENGTH, newValue),
-            lengthMode: 'manual',
-        }),
-        placement: {
-            position: (n, scene) => {
-                const routing = resolveDownspoutRouting(n, scene);
-                const path = computeDownspoutPath(n.length, effectiveWallJog(n, routing), (n.terminal ?? 'splash') !== 'straight');
-                const halfZ = downspoutPipeDims(n, routing).halfZ;
-                const y = Math.min(path.wallRunTopY, path.wallRunBottomY + CUBE_LIFT);
-                return [0, y, path.wallRunZ + halfZ + LENGTH_HANDLE_PAD];
-            },
-        },
-        // Leader starts at Y = 0 (outlet / gutter floor) and runs DOWN past
-        // the cube — same tracker the wall / chimney height fields use.
-        trackerBaseY: () => 0,
-    };
-}
-// Usable half-span — keep the outlet a hair inside each end so the
-// collar never lands on a cap (the geometry clamps too; this bounds the
-// drag). Reads the host gutter's length.
-function moveBound(n, gutter) {
-    return Math.max(0.05, Math.max(0.05, gutter?.length ?? 2) / 2 - 0.1);
-}
-// Effective outlet offset for `currentValue` — reads the gutter's live
-// override first (so the dragged value tracks) then the store.
-function readOutletOffset(n) {
-    if (!n.gutterId)
-        return 0;
-    const id = n.gutterId;
-    const override = useLiveNodeOverrides.getState().get(id);
-    const gutter = useScene.getState().nodes[id];
-    const outlets = override?.outlets ?? gutter?.outlets ?? [];
-    return outlets.find((o) => o.id === n.outletId)?.offset ?? 0;
-}
-/**
- * Side-move arrow — one of a ±X pair that slides the downspout along the
- * eave. The position lives on the host gutter's outlet
- * (`gutter.outlets[].offset`), not on the downspout, so `overrideTarget`
- * redirects the drag's live override + commit to the gutter and `apply`
- * returns the gutter's patch. The arrows sit near the top of the pipe
- * and ride its group, which moves with the outlet — so they track the
- * cursor 1:1 (`anchor: 'min'` → factor +1).
- */
-function downspoutMoveHandle(side) {
-    const sign = side === 'right' ? 1 : -1;
-    return {
-        kind: 'linear-resize',
-        axis: 'x',
-        anchor: 'min',
-        cursor: 'ew-resize',
-        gridSnap: true,
-        overrideTarget: (n) => (n.gutterId ? n.gutterId : undefined),
-        currentValue: (n) => readOutletOffset(n),
-        apply: (n, newOffset, scene) => {
-            const gutter = n.gutterId ? scene.get(n.gutterId) : undefined;
-            if (!gutter)
-                return {};
-            const outlets = (gutter.outlets ?? []).map((o) => o.id === n.outletId ? { ...o, offset: newOffset, generatedBy: undefined } : o);
-            // Patch targets the GUTTER (overrideTarget), not the downspout.
-            return { outlets };
-        },
-        min: (n, scene) => -moveBound(n, n.gutterId ? scene.get(n.gutterId) : undefined),
-        max: (n, scene) => moveBound(n, n.gutterId ? scene.get(n.gutterId) : undefined),
-        placement: {
-            // Static ±X beside the top of the pipe; the group it rides moves
-            // with the outlet, so the arrow stays under the cursor as it slides.
-            position: () => [sign * SIDE_MOVE_OFFSET, SIDE_MOVE_Y, 0],
-            rotationY: () => (side === 'right' ? 0 : Math.PI),
-        },
-    };
-}
-const downspoutHandles = [
-    downspoutLengthHandle(),
-    downspoutMoveHandle('left'),
-    downspoutMoveHandle('right'),
-];
-/**
- * Downspout — vertical drop pipe taking water from a gutter outlet to
- * the ground. Scene-graph parent is the same roof-segment the host
- * gutter sits on (so it renders under `roof-elements` like every
- * other accessory); the logical link to the gutter is via the
- * `gutterId` field, which the renderer uses to look up the outlet
- * position.
- *
- * No `handles` yet — the downspout's geometry is anchored to the
- * gutter's outlet. Length (tracker cube at the routed mouth) and
- * diameter (chevron on the wall run) are draggable arrows; the wall
- * standoff lives in the inspector.
- */
-export const downspoutDefinition = {
-    kind: 'downspout',
-    schemaVersion: 3,
-    schema: DownspoutNode,
-    category: 'structure',
-    surfaceRole: 'roof',
-    snapProfile: 'item',
-    defaults: () => {
-        const stub = DownspoutNodeSchema.parse({
-            id: 'downspout_default',
-            type: 'downspout',
-        });
-        const { id: _id, type: _type, ...rest } = stub;
-        return rest;
-    },
-    capabilities: {
-        exterior: true,
-        slots: downspoutSlots,
-        selectable: { hitVolume: 'bbox' },
-        duplicable: true,
-        deletable: true,
-        paint: { ...surfacePaintCapability, materialTarget: 'downspout' },
-        // Logically a roof accessory — registers under the segment, has
-        // no buildCut, just the standard dirty cascade.
-        roofAccessory: {},
-    },
-    parametrics: downspoutParametrics,
-    handles: downspoutHandles,
-    rendersChildren: false,
-    renderer: {
-        kind: 'parametric',
-        module: () => import('./renderer.js'),
-    },
-    system: {
-        module: () => import('./system.js'),
-        priority: 2,
-    },
-    preview: () => import('./preview.js'),
-    tool: () => import('./tool.js'),
-    toolHints: [
-        { key: 'Hover gutter', label: 'Highlight outlet' },
-        { key: 'Left click', label: 'Drop downspout from outlet' },
-        { key: 'Esc', label: 'Cancel' },
-    ],
-    presentation: {
-        label: 'Downspout',
-        description: 'Vertical drop pipe from a gutter outlet to the ground.',
-        icon: { kind: 'url', src: '/icons/downspout.webp' },
-        paletteSection: 'structure',
-        paletteOrder: 123,
-    },
-    mcp: {
-        description: 'A downspout — drop pipe from a gutter outlet that elbows back to the wall, runs down the wall face, and kicks out at the bottom. length / diameter / standoff parametric.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { downspoutEditContribution } from './definition.edit.js';
+import { downspoutRenderDefinition } from './definition.render.js';
+export const downspoutDefinition = composeNodeDefinition(downspoutRenderDefinition, downspoutEditContribution);

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

@@ -0,0 +1,6 @@
+import type { NodeRenderDefinition } from '../definition-contributions.js';
+import { DownspoutNode } from './schema.js';
+export declare const downspoutRenderDefinition: NodeRenderDefinition<typeof DownspoutNode> & {
+    kind: 'downspout';
+};
+//# sourceMappingURL=definition.render.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/downspout/definition.render.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AACvE,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAExC,eAAO,MAAM,yBAAyB,EAAE,oBAAoB,CAAC,OAAO,aAAa,CAAC,GAAG;IACnF,IAAI,EAAE,WAAW,CAAA;CA6ClB,CAAA"}

package/dist/downspout/definition.render.js

@@ -0,0 +1,46 @@
+import { DownspoutNode as DownspoutNodeSchema, downspoutSlots } from '@pascal-app/core';
+import { DownspoutNode } from './schema.js';
+export const downspoutRenderDefinition = {
+    kind: 'downspout',
+    schemaVersion: 3,
+    schema: DownspoutNode,
+    category: 'structure',
+    surfaceRole: 'roof',
+    defaults: () => {
+        const stub = DownspoutNodeSchema.parse({
+            id: 'downspout_default',
+            type: 'downspout',
+        });
+        const { id: _id, type: _type, ...rest } = stub;
+        return rest;
+    },
+    capabilities: {
+        exterior: true,
+        slots: downspoutSlots,
+        selectable: { hitVolume: 'bbox' },
+        duplicable: true,
+        deletable: true,
+        // Logically a roof accessory — registers under the segment, has
+        // no buildCut, just the standard dirty cascade.
+        roofAccessory: {},
+    },
+    rendersChildren: false,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer.js'),
+    },
+    system: {
+        module: () => import('./system.js'),
+        priority: 2,
+    },
+    presentation: {
+        label: 'Downspout',
+        description: 'Vertical drop pipe from a gutter outlet to the ground.',
+        icon: { kind: 'url', src: '/icons/downspout.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 123,
+    },
+    mcp: {
+        description: 'A downspout — drop pipe from a gutter outlet that elbows back to the wall, runs down the wall face, and kicks out at the bottom. length / diameter / standoff parametric.',
+    },
+};

package/dist/duct-fitting/definition.d.ts

@@ -1,12 +1,100 @@
-import type { NodeDefinition } from '@pascal-app/core';
-import { DuctFittingNode } from './schema.js';
-/**
- * Phase 2 of the HVAC node system — duct fittings (elbow / tee / reducer)
- * and the first kind to expose typed ports (`def.ports`).
- *
- * Composition: `def.geometry` only, same as duct-segment. Ports are the
- * architectural payload: placement tools snap onto them, and a later
- * slice walks them to build the supply/return system graph.
- */
-export declare const ductFittingDefinition: NodeDefinition<typeof DuctFittingNode>;
+export declare const ductFittingDefinition: 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<`duct-fitting_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"duct-fitting">>;
+    position: import("zod").ZodDefault<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    rotation: import("zod").ZodDefault<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    fittingType: import("zod").ZodDefault<import("zod").ZodEnum<{
+        "access-panel": "access-panel";
+        coupling: "coupling";
+        cross: "cross";
+        damper: "damper";
+        elbow: "elbow";
+        "end-cap": "end-cap";
+        reducer: "reducer";
+        tee: "tee";
+        transition: "transition";
+    }>>;
+    shape: import("zod").ZodDefault<import("zod").ZodEnum<{
+        oval: "oval";
+        rect: "rect";
+        round: "round";
+    }>>;
+    inletShape: import("zod").ZodOptional<import("zod").ZodEnum<{
+        oval: "oval";
+        rect: "rect";
+        round: "round";
+    }>>;
+    outletShape: import("zod").ZodOptional<import("zod").ZodEnum<{
+        oval: "oval";
+        rect: "rect";
+        round: "round";
+    }>>;
+    width: import("zod").ZodDefault<import("zod").ZodNumber>;
+    height: import("zod").ZodDefault<import("zod").ZodNumber>;
+    shape2: import("zod").ZodDefault<import("zod").ZodEnum<{
+        oval: "oval";
+        rect: "rect";
+        round: "round";
+    }>>;
+    width2: import("zod").ZodDefault<import("zod").ZodNumber>;
+    height2: import("zod").ZodDefault<import("zod").ZodNumber>;
+    angle: import("zod").ZodDefault<import("zod").ZodNumber>;
+    branchAngle: import("zod").ZodDefault<import("zod").ZodNumber>;
+    diameter: import("zod").ZodDefault<import("zod").ZodNumber>;
+    diameter2: import("zod").ZodDefault<import("zod").ZodNumber>;
+    ductMaterial: import("zod").ZodDefault<import("zod").ZodEnum<{
+        "duct-board": "duct-board";
+        flex: "flex";
+        "sheet-metal": "sheet-metal";
+    }>>;
+    system: import("zod").ZodDefault<import("zod").ZodEnum<{
+        return: "return";
+        supply: "supply";
+    }>>;
+    damperAngle: import("zod").ZodDefault<import("zod").ZodNumber>;
+    panelWidth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    panelHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+    slots: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

package/dist/duct-fitting/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/duct-fitting/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAStD,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE1C;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,OAAO,eAAe,CAiIxE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/duct-fitting/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAGjC,CAAA"}

package/dist/duct-fitting/definition.edit.d.ts

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

package/dist/duct-fitting/definition.edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/duct-fitting/definition.edit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAMvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE/C,eAAO,MAAM,2BAA2B,EAAE,oBAAoB,CAAC,OAAO,eAAe,CA2CpF,CAAA"}

package/dist/duct-fitting/definition.edit.js

@@ -0,0 +1,49 @@
+import { ductBodyPaint } from '../shared/duct-body-paint.js';
+import { rotateFittingNode } from '../shared/fitting-rotation.js';
+import { ductFittingToolOptions } from '../shared/fitting-tool-options.js';
+import { buildDuctFittingFloorplan } from './floorplan.js';
+import { ductFittingParametrics } from './parametrics.js';
+export const ductFittingEditContribution = {
+    snapProfile: 'item',
+    capabilities: {
+        paint: ductBodyPaint,
+    },
+    parametrics: ductFittingParametrics,
+    floorplan: buildDuctFittingFloorplan,
+    // R/T rotate a selected fitting ±45° around the shared active axis.
+    // The default editor rotate only knows Y; fittings need X/Z for
+    // risers, so this overrides it. Alt-cycling of the axis + the axis
+    // badge live in `./selection.tsx`.
+    keyboardActions: {
+        r: {
+            appliesTo: (node) => node.type === 'duct-fitting',
+            run: (node) => rotateFittingNode(node, 1),
+        },
+        t: {
+            appliesTo: (node) => node.type === 'duct-fitting',
+            run: (node) => rotateFittingNode(node, -1),
+        },
+        axisCycling: true,
+    },
+    // Alt-cycles the active rotation axis while a fitting is selected.
+    // Editor-only (drives `useEditor.rotationAxis`), so it mounts via the
+    // editor's SelectionAffordanceManager rather than `def.system`.
+    affordanceTools: {
+        selection: () => import('./selection.js'),
+        // Ghost-preview duplicate / move. Duplicate is pure drag-to-place: a
+        // translucent copy of the fitting (built from its real geometry, at its
+        // own rotation, so an elbow / riser stays properly aligned) follows the
+        // cursor and only lands on the commit click. Takes priority over
+        // `capabilities.movable` in the MoveTool dispatcher.
+        move: () => import('./move-tool.js'),
+    },
+    toolOptions: ductFittingToolOptions,
+    tool: () => import('./tool.js'),
+    toolHints: [
+        { key: 'Click', label: 'Place fitting' },
+        { key: 'Hover a duct end', label: 'Snap onto the run' },
+        { key: 'R / T', label: 'Rotate ±45°' },
+        { key: 'Alt', label: 'Switch rotation axis (Y → X → Z)' },
+        { key: 'Esc', label: 'Exit' },
+    ],
+};

package/dist/duct-fitting/definition.js

@@ -1,135 +1,4 @@
-import { ductBodySlots } from '@pascal-app/core';
-import { ductBodyPaint } from '../shared/duct-body-paint.js';
-import { rotateFittingNode } from '../shared/fitting-rotation.js';
-import { ductFittingToolOptions } from '../shared/fitting-tool-options.js';
-import { buildDuctFittingFloorplan } from './floorplan.js';
-import { buildDuctFittingGeometry } from './geometry.js';
-import { ductFittingParametrics } from './parametrics.js';
-import { getDuctFittingPorts } from './ports.js';
-import { DuctFittingNode } from './schema.js';
-/**
- * Phase 2 of the HVAC node system — duct fittings (elbow / tee / reducer)
- * and the first kind to expose typed ports (`def.ports`).
- *
- * Composition: `def.geometry` only, same as duct-segment. Ports are the
- * architectural payload: placement tools snap onto them, and a later
- * slice walks them to build the supply/return system graph.
- */
-export const ductFittingDefinition = {
-    kind: 'duct-fitting',
-    schemaVersion: 3,
-    schema: DuctFittingNode,
-    category: 'utility',
-    distributionRole: 'fitting',
-    snapProfile: 'item',
-    defaults: () => ({
-        object: 'node',
-        parentId: null,
-        visible: true,
-        metadata: {},
-        position: [0, 0, 0],
-        rotation: [0, 0, 0],
-        damperAngle: 0,
-        panelWidth: 0.25,
-        panelHeight: 0.15,
-        fittingType: 'elbow',
-        shape: 'rect',
-        width: 14,
-        height: 8,
-        shape2: 'rect',
-        width2: 14,
-        height2: 8,
-        angle: 90,
-        branchAngle: 90,
-        diameter: 12,
-        diameter2: 12,
-        ductMaterial: 'sheet-metal',
-        system: 'supply',
-    }),
-    capabilities: {
-        selectable: { hitVolume: 'bbox' },
-        // `cursorAttached`: a fitting is a small connector — an offset-
-        // preserving drag reads as the mesh trailing the mouse, so pin its
-        // origin to the cursor instead.
-        movable: { axes: ['x', 'y', 'z'], gridSnap: true, cursorAttached: true },
-        duplicable: true,
-        deletable: true,
-        slots: () => ductBodySlots(),
-        paint: ductBodyPaint,
-    },
-    parametrics: ductFittingParametrics,
-    geometry: buildDuctFittingGeometry,
-    geometryKey: (n) => JSON.stringify([
-        n.fittingType,
-        n.damperAngle,
-        n.panelWidth,
-        n.panelHeight,
-        // The mitered elbow + flange profiles swap width/height roles based
-        // on where world-up sits in the local frame, so orientation is a
-        // geometry input.
-        n.rotation,
-        n.shape,
-        n.inletShape,
-        n.outletShape,
-        n.width,
-        n.height,
-        n.shape2,
-        n.width2,
-        n.height2,
-        n.angle,
-        n.branchAngle,
-        n.diameter,
-        n.diameter2,
-        n.ductMaterial,
-        n.system,
-        n.slots,
-    ]),
-    ports: getDuctFittingPorts,
-    floorplan: buildDuctFittingFloorplan,
-    // R/T rotate a selected fitting ±45° around the shared active axis.
-    // The default editor rotate only knows Y; fittings need X/Z for
-    // risers, so this overrides it. Alt-cycling of the axis + the axis
-    // badge live in `./selection.tsx`.
-    keyboardActions: {
-        r: {
-            appliesTo: (node) => node.type === 'duct-fitting',
-            run: (node) => rotateFittingNode(node, 1),
-        },
-        t: {
-            appliesTo: (node) => node.type === 'duct-fitting',
-            run: (node) => rotateFittingNode(node, -1),
-        },
-        axisCycling: true,
-    },
-    // Alt-cycles the active rotation axis while a fitting is selected.
-    // Editor-only (drives `useEditor.rotationAxis`), so it mounts via the
-    // editor's SelectionAffordanceManager rather than `def.system`.
-    affordanceTools: {
-        selection: () => import('./selection.js'),
-        // Ghost-preview duplicate / move. Duplicate is pure drag-to-place: a
-        // translucent copy of the fitting (built from its real geometry, at its
-        // own rotation, so an elbow / riser stays properly aligned) follows the
-        // cursor and only lands on the commit click. Takes priority over
-        // `capabilities.movable` in the MoveTool dispatcher.
-        move: () => import('./move-tool.js'),
-    },
-    toolOptions: ductFittingToolOptions,
-    tool: () => import('./tool.js'),
-    toolHints: [
-        { key: 'Click', label: 'Place fitting' },
-        { key: 'Hover a duct end', label: 'Snap onto the run' },
-        { key: 'R / T', label: 'Rotate ±45°' },
-        { key: 'Alt', label: 'Switch rotation axis (Y → X → Z)' },
-        { key: 'Esc', label: 'Exit' },
-    ],
-    presentation: {
-        label: 'Duct Fitting',
-        description: 'Elbow, tee, reducer, or square-to-round transition connecting duct runs.',
-        icon: { kind: 'url', src: '/icons/duct-fitting.webp' },
-        paletteSection: 'structure',
-        paletteOrder: 91,
-    },
-    mcp: {
-        description: 'A duct fitting (elbow, tee, reducer, or square-to-round transition) with typed connection ports. Position is level-local meters; rotation is an XYZ euler in radians.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { ductFittingEditContribution } from './definition.edit.js';
+import { ductFittingRenderDefinition } from './definition.render.js';
+export const ductFittingDefinition = composeNodeDefinition(ductFittingRenderDefinition, ductFittingEditContribution);

package/dist/duct-fitting/definition.render.d.ts

@@ -0,0 +1,6 @@
+import type { NodeRenderDefinition } from '../definition-contributions.js';
+import { DuctFittingNode } from './schema.js';
+export declare const ductFittingRenderDefinition: NodeRenderDefinition<typeof DuctFittingNode> & {
+    kind: 'duct-fitting';
+};
+//# sourceMappingURL=definition.render.d.ts.map

package/dist/duct-fitting/definition.render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/duct-fitting/definition.render.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAGvE,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE1C,eAAO,MAAM,2BAA2B,EAAE,oBAAoB,CAAC,OAAO,eAAe,CAAC,GAAG;IACvF,IAAI,EAAE,cAAc,CAAA;CAgFrB,CAAA"}

package/dist/duct-fitting/definition.render.js

@@ -0,0 +1,82 @@
+import { ductBodySlots } from '@pascal-app/core';
+import { buildDuctFittingGeometry } from './geometry.js';
+import { getDuctFittingPorts } from './ports.js';
+import { DuctFittingNode } from './schema.js';
+export const ductFittingRenderDefinition = {
+    kind: 'duct-fitting',
+    schemaVersion: 3,
+    schema: DuctFittingNode,
+    category: 'utility',
+    distributionRole: 'fitting',
+    defaults: () => ({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        position: [0, 0, 0],
+        rotation: [0, 0, 0],
+        damperAngle: 0,
+        panelWidth: 0.25,
+        panelHeight: 0.15,
+        fittingType: 'elbow',
+        shape: 'rect',
+        width: 14,
+        height: 8,
+        shape2: 'rect',
+        width2: 14,
+        height2: 8,
+        angle: 90,
+        branchAngle: 90,
+        diameter: 12,
+        diameter2: 12,
+        ductMaterial: 'sheet-metal',
+        system: 'supply',
+    }),
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        // `cursorAttached`: a fitting is a small connector — an offset-
+        // preserving drag reads as the mesh trailing the mouse, so pin its
+        // origin to the cursor instead.
+        movable: { axes: ['x', 'y', 'z'], gridSnap: true, cursorAttached: true },
+        duplicable: true,
+        deletable: true,
+        slots: () => ductBodySlots(),
+    },
+    geometry: buildDuctFittingGeometry,
+    geometryKey: (n) => JSON.stringify([
+        n.fittingType,
+        n.damperAngle,
+        n.panelWidth,
+        n.panelHeight,
+        // The mitered elbow + flange profiles swap width/height roles based
+        // on where world-up sits in the local frame, so orientation is a
+        // geometry input.
+        n.rotation,
+        n.shape,
+        n.inletShape,
+        n.outletShape,
+        n.width,
+        n.height,
+        n.shape2,
+        n.width2,
+        n.height2,
+        n.angle,
+        n.branchAngle,
+        n.diameter,
+        n.diameter2,
+        n.ductMaterial,
+        n.system,
+        n.slots,
+    ]),
+    ports: getDuctFittingPorts,
+    presentation: {
+        label: 'Duct Fitting',
+        description: 'Elbow, tee, reducer, or square-to-round transition connecting duct runs.',
+        icon: { kind: 'url', src: '/icons/duct-fitting.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 91,
+    },
+    mcp: {
+        description: 'A duct fitting (elbow, tee, reducer, or square-to-round transition) with typed connection ports. Position is level-local meters; rotation is an XYZ euler in radians.',
+    },
+};