@pascal-app/nodes 1.0.7 → 1.1.1

package/dist/downspout/definition.edit.js

@@ -0,0 +1,134 @@
+import { 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';
+// 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'),
+];
+export const downspoutEditContribution = {
+    snapProfile: 'item',
+    capabilities: {
+        paint: { ...surfacePaintCapability, materialTarget: 'downspout' },
+    },
+    parametrics: downspoutParametrics,
+    handles: downspoutHandles,
+    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' },
+    ],
+};

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;AAKvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE/C,eAAO,MAAM,2BAA2B,EAAE,oBAAoB,CAAC,OAAO,eAAe,CA0CpF,CAAA"}

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

@@ -0,0 +1,47 @@
+import { ductBodyPaint } from '../shared/duct-body-paint.js';
+import { rotateFittingNode } from '../shared/fitting-rotation.js';
+import { ductFittingToolOptions } from '../shared/fitting-tool-options.js';
+import { ductFittingParametrics } from './parametrics.js';
+export const ductFittingEditContribution = {
+    snapProfile: 'item',
+    capabilities: {
+        paint: ductBodyPaint,
+    },
+    parametrics: ductFittingParametrics,
+    // 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' },
+    ],
+};