@pascal-app/nodes 1.0.6 → 1.1.0

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/downspout/inspector-editors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inspector-editors.d.ts","sourceRoot":"","sources":["../../src/downspout/inspector-editors.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,aAAa,EAKnB,MAAM,kBAAkB,CAAA;AAGzB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,uBAAuB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,sCAoExE"}
+{"version":3,"file":"inspector-editors.d.ts","sourceRoot":"","sources":["../../src/downspout/inspector-editors.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,aAAa,EAMnB,MAAM,kBAAkB,CAAA;AAGzB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,uBAAuB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,aAAa,CAAA;CAAE,sCAqExE"}

package/dist/downspout/inspector-editors.js

@@ -1,6 +1,6 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
-import { useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { useLiveNodeOverrides, usePascalI18n, useScene, } from '@pascal-app/core';
 import { SliderControl } from '@pascal-app/editor';
 /**
  * Position-along-the-eave editor for a downspout. The downspout's spot
@@ -23,6 +23,7 @@ import { SliderControl } from '@pascal-app/editor';
  * downspout isn't linked to an outlet.
  */
 export function DownspoutPositionEditor({ node }) {
+    const i18n = usePascalI18n();
     const gutter = useScene((s) => node.gutterId ? s.nodes[node.gutterId] : undefined);
     // Live override on the gutter, so the readout tracks the in-flight drag.
     const override = useLiveNodeOverrides((s) => node.gutterId
@@ -62,7 +63,7 @@ export function DownspoutPositionEditor({ node }) {
         useLiveNodeOverrides.getState().clear(gutterId);
         state.markDirty(gutterId);
     };
-    return (_jsx(SliderControl, { label: "Position", max: bound, min: -bound, onChange: handleChange, onCommit: handleCommit, precision: 2, 
+    return (_jsx(SliderControl, { label: i18n._({ id: 'node.downspout.inspectorEditors.position', message: 'Position' }), max: bound, min: -bound, onChange: handleChange, onCommit: handleCommit, precision: 2, 
         // onChange only touches the override, so there's nothing in the
         // store to restore on release — skip the restore-then-reapply dance.
         restoreOnCommit: false, step: 0.05, unit: "m", value: Math.max(-bound, Math.min(bound, outlet.offset ?? 0)) }));

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.',
+    },
+};

package/dist/duct-fitting/floorplan.js

@@ -1,5 +1,5 @@
 import { MeshStandardMaterial } from 'three';
-import { INCHES_TO_METERS } from '../duct-segment/geometry.js';
+import { INCHES_TO_METERS } from '../duct-segment/profile.js';
 import { accessoryFloorplan } from '../shared/accessory-floorplan.js';
 import { buildDuctAccessory } from './accessory-geometry.js';
 import { buildDuctFittingGeometry } from './geometry.js';

package/dist/duct-fitting/geometry.js

@@ -1,6 +1,7 @@
 import { DUCT_BODY_SLOT_ID } from '@pascal-app/core';
 import { BufferGeometry, CylinderGeometry, DoubleSide, Euler, Float32BufferAttribute, Group, Mesh, SphereGeometry, TorusGeometry, Vector3, } from 'three';
-import { buildOvalSection, buildRectSection, buildSection, createDuctMaterial, INCHES_TO_METERS, } from '../duct-segment/geometry.js';
+import { buildOvalSection, buildRectSection, buildSection, createDuctMaterial, } from '../duct-segment/geometry.js';
+import { INCHES_TO_METERS } from '../duct-segment/profile.js';
 import { buildDuctAccessory } from './accessory-geometry.js';
 import { adapterShape, localFittingPorts } from './ports.js';
 const RADIAL_SEGMENTS = 24;

package/dist/duct-fitting/inspector-editors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"inspector-editors.d.ts","sourceRoot":"","sources":["../../src/duct-fitting/inspector-editors.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAW/C,wBAAgB,yBAAyB,CAAC,EACxC,IAAI,EACJ,QAAQ,GACT,EAAE;IACD,IAAI,EAAE,eAAe,CAAA;IACrB,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,eAAe,CAAC,KAAK,IAAI,CAAA;CACpD,+BAgBA"}
+{"version":3,"file":"inspector-editors.d.ts","sourceRoot":"","sources":["../../src/duct-fitting/inspector-editors.tsx"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAW/C,wBAAgB,yBAAyB,CAAC,EACxC,IAAI,EACJ,QAAQ,GACT,EAAE;IACD,IAAI,EAAE,eAAe,CAAA;IACrB,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,eAAe,CAAC,KAAK,IAAI,CAAA;CACpD,+BAoBA"}

package/dist/duct-fitting/inspector-editors.js

@@ -1,5 +1,6 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
+import { usePascalI18n } from '@pascal-app/core';
 import { ActionButton } from '@pascal-app/editor';
 import { ArrowLeftRight } from 'lucide-react';
 const WIDTH_MIN = 4;
@@ -10,7 +11,11 @@ function clamp(value, min, max) {
     return Math.min(max, Math.max(min, value));
 }
 export function DuctFittingSizeSwapEditor({ node, onUpdate, }) {
+    const i18n = usePascalI18n();
     const nextWidth = clamp(node.height, WIDTH_MIN, WIDTH_MAX);
     const nextHeight = clamp(node.width, HEIGHT_MIN, HEIGHT_MAX);
-    return (_jsx("div", { className: "px-2", children: _jsx(ActionButton, { className: "h-8 w-full flex-none", icon: _jsx(ArrowLeftRight, { className: "h-3.5 w-3.5" }), label: "Swap W/H", onClick: () => onUpdate({ width: nextWidth, height: nextHeight }), title: "Swap width and height", type: "button" }) }));
+    return (_jsx("div", { className: "px-2", children: _jsx(ActionButton, { className: "h-8 w-full flex-none", icon: _jsx(ArrowLeftRight, { className: "h-3.5 w-3.5" }), label: i18n._({ id: 'node.ductFitting.inspectorEditors.swapWH', message: 'Swap W/H' }), onClick: () => onUpdate({ width: nextWidth, height: nextHeight }), title: i18n._({
+                id: 'node.ductFitting.inspectorEditors.swapWidthAndHeight',
+                message: 'Swap width and height',
+            }), type: "button" }) }));
 }

package/dist/duct-fitting/move-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/duct-fitting/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,OAAO,EAOb,MAAM,kBAAkB,CAAA;AAyEzB;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,mBAAmB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CAwQ3D,CAAA;eAEc,mBAAmB"}
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/duct-fitting/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,OAAO,EAOb,MAAM,kBAAkB,CAAA;AAyEzB;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,mBAAmB,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,OAAO,CAAA;CAAE,CA+Q3D,CAAA;eAEc,mBAAmB"}

package/dist/duct-fitting/move-tool.js

@@ -185,16 +185,17 @@ export const MoveDuctFittingTool = ({ node }) => {
             if ((isGridSnapActive() || isMagneticSnapActive()) &&
                 (next[0] !== lastPos[0] || next[2] !== lastPos[2]))
                 triggerSFX('sfx:grid-snap');
+            // Detached: keep the followers at their origin (drop any live overrides
+            // from a prior non-detached frame). Otherwise preview the follow; joints
+            // that cannot follow hold the last shown frame.
+            if (detached)
+                connectivity?.clear();
+            else if (connectivity && !connectivity.preview({ position: next }))
+                return;
             lastPos = next;
             lastDetached = detached;
             hasMoved = true;
             setCursorPos(next);
-            // Detached: keep the followers at their origin (drop any live overrides
-            // from a prior non-detached frame). Otherwise preview the follow.
-            if (detached)
-                connectivity?.clear();
-            else
-                connectivity?.preview({ position: next });
         };
         const commit = (event, fromDragRelease = false) => {
             if (committed)
@@ -210,10 +211,21 @@ export const MoveDuctFittingTool = ({ node }) => {
                 event.nativeEvent?.stopPropagation?.();
                 return;
             }
+            const creating = isNew && !useScene.getState().nodes[nodeId];
+            // Fold connected-duct / sibling-run follow-updates into the SAME batch
+            // as the moved fitting so the whole joint is one undo step. Detached
+            // (Alt on the final frame): the joint is broken, so nothing follows.
+            const followUpdates = creating || lastDetached || !connectivity
+                ? []
+                : connectivity.commitUpdates({ position: lastPos });
+            if (!followUpdates) {
+                event.nativeEvent?.stopPropagation?.();
+                return;
+            }
             committed = true;
             useScene.temporal.getState().resume();
             let selectId = nodeId;
-            if (isNew && !useScene.getState().nodes[nodeId]) {
+            if (creating) {
                 const created = DuctFittingNode.parse({
                     ...node,
                     position: lastPos,
@@ -230,12 +242,6 @@ export const MoveDuctFittingTool = ({ node }) => {
                 selectId = created.id;
             }
             else {
-                // Fold connected-duct / sibling-run follow-updates into the SAME batch
-                // as the moved fitting so the whole joint is one undo step. Detached
-                // (Alt on the final frame): the joint is broken, so nothing follows.
-                const followUpdates = lastDetached
-                    ? []
-                    : (connectivity?.commitUpdates({ position: lastPos }) ?? []);
                 const scene = useScene.getState();
                 scene.updateNodes([
                     { id: nodeId, data: { position: lastPos } },

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

@@ -1 +1 @@
-{"version":3,"file":"selection.d.ts","sourceRoot":"","sources":["../../src/duct-fitting/selection.tsx"],"names":[],"mappings":"AAqQA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,QAAA,MAAM,8BAA8B,0CA8CnC,CAAA;eA4iBc,8BAA8B"}
+{"version":3,"file":"selection.d.ts","sourceRoot":"","sources":["../../src/duct-fitting/selection.tsx"],"names":[],"mappings":"AA6QA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,QAAA,MAAM,8BAA8B,0CAgDnC,CAAA;eA+jBc,8BAA8B"}