@pascal-app/nodes 1.0.7 → 1.1.1

package/dist/duct-segment/continuation-handle.js

@@ -0,0 +1,36 @@
+import { resolveDuctContinuationHandle, } from '../shared/elbow-branch-continuation.js';
+import { ductPortDiameterIn } from './profile.js';
+export function ductEndpointPort(duct, endpoint) {
+    if (duct.path.length < 2)
+        return null;
+    const index = endpoint === 'start' ? 0 : duct.path.length - 1;
+    const neighborIndex = endpoint === 'start' ? 1 : duct.path.length - 2;
+    const position = duct.path[index];
+    const neighbor = duct.path[neighborIndex];
+    const dx = position[0] - neighbor[0];
+    const dy = position[1] - neighbor[1];
+    const dz = position[2] - neighbor[2];
+    const length = Math.hypot(dx, dy, dz);
+    return {
+        id: endpoint,
+        nodeId: duct.id,
+        position,
+        direction: length < 1e-9 ? [1, 0, 0] : [dx / length, dy / length, dz / length],
+        diameter: ductPortDiameterIn(duct),
+        system: duct.system,
+    };
+}
+export function ductContinuationHandlePoint(duct, endpoint, gap = 0.28) {
+    const port = ductEndpointPort(duct, endpoint);
+    if (!port)
+        return null;
+    return [
+        port.position[0] + port.direction[0] * gap,
+        port.position[1] + port.direction[1] * gap,
+        port.position[2] + port.direction[2] * gap,
+    ];
+}
+export function ductContinuationHandlePlan(duct, endpoint, nodes, gap = 0.28) {
+    const port = ductEndpointPort(duct, endpoint);
+    return port ? resolveDuctContinuationHandle(port, nodes, gap) : null;
+}

package/dist/duct-segment/continuation.d.ts

@@ -1,20 +1,16 @@
-import { type AnyNode, type AnyNodeId, type DuctFittingNode, type FloorplanAffordance } from '@pascal-app/core';
+import { type AnyNode, type AnyNodeId, type DuctFittingNode, DuctSegmentNode, type FloorplanAffordance, type NodePort } from '@pascal-app/core';
 import type { RunBodyHit, ScenePort } from '@pascal-app/editor/distribution';
-import { type RunContinuationHandlePlan } from '../shared/elbow-branch-continuation.js';
-import type { DuctSegmentNode } from './schema.js';
-export type DuctEndpoint = 'start' | 'end';
+import { type DuctEndpoint } from './continuation-handle.js';
 export type DuctContinuationSeed = {
     duct: DuctSegmentNode;
     port: ScenePort | null;
     body: RunBodyHit | null;
     promotedFitting?: DuctFittingNode;
 };
-export declare function ductEndpointPort(duct: DuctSegmentNode, endpoint: DuctEndpoint): ScenePort | null;
-export declare function ductContinuationHandlePoint(duct: DuctSegmentNode, endpoint: DuctEndpoint, gap?: number): [number, number, number] | null;
-export declare function ductContinuationHandlePlan(duct: DuctSegmentNode, endpoint: DuctEndpoint, nodes: Readonly<Record<string, AnyNode>>, gap?: number): RunContinuationHandlePlan | null;
 export declare function resolveDuctContinuationSeed(defaults: unknown, nodes: Record<string, AnyNode>): DuctContinuationSeed | null;
 export declare function activateDuctBranch(duct: DuctSegmentNode, segmentIndex: number, point: [number, number, number]): void;
 export declare function activateDuctContinuation(duct: DuctSegmentNode, endpoint: DuctEndpoint, fittingId?: AnyNodeId): void;
+export declare function activateDuctCollarContinuation(node: AnyNode, port: NodePort): void;
 export declare const ductContinuationAffordance: FloorplanAffordance<DuctSegmentNode>;
 export declare const ductBranchAffordance: FloorplanAffordance<DuctSegmentNode>;
 export declare function currentDuctContinuationSeed(): DuctContinuationSeed | null;

package/dist/duct-segment/continuation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"continuation.d.ts","sourceRoot":"","sources":["../../src/duct-segment/continuation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,eAAe,EACpB,KAAK,mBAAmB,EAEzB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAA;AAE5E,OAAO,EAIL,KAAK,yBAAyB,EAE/B,MAAM,qCAAqC,CAAA;AAE5C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE/C,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,KAAK,CAAA;AAE1C,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,eAAe,CAAA;IACrB,IAAI,EAAE,SAAS,GAAG,IAAI,CAAA;IACtB,IAAI,EAAE,UAAU,GAAG,IAAI,CAAA;IACvB,eAAe,CAAC,EAAE,eAAe,CAAA;CAClC,CAAA;AAYD,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,eAAe,EAAE,QAAQ,EAAE,YAAY,GAAG,SAAS,GAAG,IAAI,CAkBhG;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,eAAe,EACrB,QAAQ,EAAE,YAAY,EACtB,GAAG,SAAO,GACT,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI,CAQjC;AAED,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,eAAe,EACrB,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,GAAG,SAAO,GACT,yBAAyB,GAAG,IAAI,CAGlC;AAED,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,OAAO,EACjB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,oBAAoB,GAAG,IAAI,CAiD7B;AAED,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,eAAe,EACrB,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAC9B,IAAI,CAmBN;AAED,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,eAAe,EACrB,QAAQ,EAAE,YAAY,EACtB,SAAS,CAAC,EAAE,SAAS,GACpB,IAAI,CAiBN;AAED,eAAO,MAAM,0BAA0B,EAAE,mBAAmB,CAAC,eAAe,CAiB3E,CAAA;AAED,eAAO,MAAM,oBAAoB,EAAE,mBAAmB,CAAC,eAAe,CAiBrE,CAAA;AAED,wBAAgB,2BAA2B,IAAI,oBAAoB,GAAG,IAAI,CAKzE"}
+{"version":3,"file":"continuation.d.ts","sourceRoot":"","sources":["../../src/duct-segment/continuation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,eAAe,EACpB,eAAe,EACf,KAAK,mBAAmB,EACxB,KAAK,QAAQ,EAGd,MAAM,kBAAkB,CAAA;AAEzB,OAAO,KAAK,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAA;AAO5E,OAAO,EAAE,KAAK,YAAY,EAAoB,MAAM,uBAAuB,CAAA;AAE3E,MAAM,MAAM,oBAAoB,GAAG;IACjC,IAAI,EAAE,eAAe,CAAA;IACrB,IAAI,EAAE,SAAS,GAAG,IAAI,CAAA;IACtB,IAAI,EAAE,UAAU,GAAG,IAAI,CAAA;IACvB,eAAe,CAAC,EAAE,eAAe,CAAA;CAClC,CAAA;AAaD,wBAAgB,2BAA2B,CACzC,QAAQ,EAAE,OAAO,EACjB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,oBAAoB,GAAG,IAAI,CA2E7B;AAED,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,eAAe,EACrB,YAAY,EAAE,MAAM,EACpB,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAC9B,IAAI,CAsBN;AAED,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,eAAe,EACrB,QAAQ,EAAE,YAAY,EACtB,SAAS,CAAC,EAAE,SAAS,GACpB,IAAI,CAoBN;AAED,wBAAgB,8BAA8B,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,GAAG,IAAI,CAmBlF;AAED,eAAO,MAAM,0BAA0B,EAAE,mBAAmB,CAAC,eAAe,CAiB3E,CAAA;AAED,eAAO,MAAM,oBAAoB,EAAE,mBAAmB,CAAC,eAAe,CAiBrE,CAAA;AAED,wBAAgB,2BAA2B,IAAI,oBAAoB,GAAG,IAAI,CAKzE"}

package/dist/duct-segment/continuation.js

@@ -1,44 +1,36 @@
-import { useScene, } from '@pascal-app/core';
+import { DuctSegmentNode, nodeRegistry, useScene, } from '@pascal-app/core';
 import { useEditor } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
-import { findMatedScenePorts, planDuctElbowBranchPromotion, planDuctTeeCrossPromotion, resolveDuctContinuationHandle, } from '../shared/elbow-branch-continuation.js';
-import { ductPortDiameterIn } from './geometry.js';
-export function ductEndpointPort(duct, endpoint) {
-    if (duct.path.length < 2)
-        return null;
-    const index = endpoint === 'start' ? 0 : duct.path.length - 1;
-    const neighborIndex = endpoint === 'start' ? 1 : duct.path.length - 2;
-    const position = duct.path[index];
-    const neighbor = duct.path[neighborIndex];
-    const dx = position[0] - neighbor[0];
-    const dy = position[1] - neighbor[1];
-    const dz = position[2] - neighbor[2];
-    const length = Math.hypot(dx, dy, dz);
-    return {
-        id: endpoint,
-        nodeId: duct.id,
-        position,
-        direction: length < 1e-9 ? [1, 0, 0] : [dx / length, dy / length, dz / length],
-        diameter: ductPortDiameterIn(duct),
-        system: duct.system,
-    };
-}
-export function ductContinuationHandlePoint(duct, endpoint, gap = 0.28) {
-    const port = ductEndpointPort(duct, endpoint);
-    if (!port)
-        return null;
-    return [
-        port.position[0] + port.direction[0] * gap,
-        port.position[1] + port.direction[1] * gap,
-        port.position[2] + port.direction[2] * gap,
-    ];
-}
-export function ductContinuationHandlePlan(duct, endpoint, nodes, gap = 0.28) {
-    const port = ductEndpointPort(duct, endpoint);
-    return port ? resolveDuctContinuationHandle(port, nodes, gap) : null;
-}
+import { findMatedScenePorts, planDuctElbowBranchPromotion, planDuctTeeCrossPromotion, } from '../shared/elbow-branch-continuation.js';
+import { ductEndpointPort } from './continuation-handle.js';
 export function resolveDuctContinuationSeed(defaults, nodes) {
     const continuation = defaults?.continuation;
+    if (typeof continuation?.portId === 'string' && typeof continuation.nodeId === 'string') {
+        const source = nodes[continuation.nodeId];
+        const port = source &&
+            nodeRegistry
+                .get(source.type)
+                ?.ports?.(source)
+                .find((p) => p.id === continuation.portId);
+        if (!port || (port.system !== 'supply' && port.system !== 'return'))
+            return null;
+        return {
+            duct: DuctSegmentNode.parse({
+                parentId: source.parentId,
+                path: [
+                    [...port.position],
+                    port.position.map((value, index) => value + port.direction[index]),
+                ],
+                shape: port.shape ?? 'round',
+                diameter: port.diameter,
+                width: port.width ?? 14,
+                height: port.height ?? 8,
+                system: port.system,
+            }),
+            port: { ...port, nodeId: source.id },
+            body: null,
+        };
+    }
     const endpoint = continuation?.endpoint;
     const nodeId = continuation?.nodeId;
     if (endpoint === 'branch' && typeof nodeId === 'string') {
@@ -95,6 +87,9 @@ export function activateDuctBranch(duct, segmentIndex, point) {
         return;
     const editor = useEditor.getState();
     editor.setToolDefaults('duct-segment', {
+        ...editor.toolDefaults['duct-segment'],
+        routingMode: 'surface',
+        crossingMode: 'connect',
         continuation: { nodeId: duct.id, endpoint: 'branch', segmentIndex, point },
         shape: duct.shape,
         diameter: duct.diameter,
@@ -114,6 +109,9 @@ export function activateDuctContinuation(duct, endpoint, fittingId) {
         return;
     const editor = useEditor.getState();
     editor.setToolDefaults('duct-segment', {
+        ...editor.toolDefaults['duct-segment'],
+        routingMode: 'surface',
+        crossingMode: 'connect',
         continuation: { nodeId: duct.id, endpoint, ...(fittingId ? { fittingId } : {}) },
         shape: duct.shape,
         diameter: duct.diameter,
@@ -128,6 +126,25 @@ export function activateDuctContinuation(duct, endpoint, fittingId) {
     useViewer.getState().setSelection({ selectedIds: [] });
     editor.setTool('duct-segment');
 }
+export function activateDuctCollarContinuation(node, port) {
+    const editor = useEditor.getState();
+    editor.setToolDefaults('duct-segment', {
+        ...editor.toolDefaults['duct-segment'],
+        continuation: { nodeId: node.id, portId: port.id },
+        shape: port.shape ?? 'round',
+        diameter: port.diameter,
+        width: port.width ?? 14,
+        height: port.height ?? 8,
+        system: port.system,
+        ductMaterial: 'sheet-metal',
+        elevation: port.position[1],
+        routingMode: Math.hypot(port.direction[0], port.direction[2]) < 1e-6 ? 'vertical' : 'horizontal',
+        targetElevation: port.position[1] + Math.sign(port.direction[1] || 1),
+        crossingMode: 'connect',
+    });
+    useViewer.getState().setSelection({ selectedIds: [] });
+    editor.setTool('duct-segment');
+}
 export const ductContinuationAffordance = {
     start({ node, payload }) {
         const data = payload;

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

@@ -1,4 +1,92 @@
-import { type NodeDefinition } from '@pascal-app/core';
-import { DuctSegmentNode } from './schema.js';
-export declare const ductSegmentDefinition: NodeDefinition<typeof DuctSegmentNode>;
+export declare const ductSegmentDefinition: 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-segment_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"duct-segment">>;
+    path: import("zod").ZodArray<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    autoHangers: import("zod").ZodOptional<import("zod").ZodBoolean>;
+    hangerOverrides: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
+        fraction: import("zod").ZodOptional<import("zod").ZodNumber>;
+        skipped: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        hostId: import("zod").ZodOptional<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>>>;
+    hangerStyle: import("zod").ZodOptional<import("zod").ZodEnum<{
+        double: "double";
+        single: "single";
+    }>>;
+    hangerSpacing: import("zod").ZodOptional<import("zod").ZodNumber>;
+    hangerMaxReach: import("zod").ZodOptional<import("zod").ZodNumber>;
+    wallAttachment: import("zod").ZodOptional<import("zod").ZodObject<{
+        wallId: import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`wall_${string}`>>;
+        side: import("zod").ZodEnum<{
+            back: "back";
+            front: "front";
+        }>;
+        startUV: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        endUV: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        offset: import("zod").ZodNumber;
+    }, import("zod/v4/core").$strip>>;
+    shape: import("zod").ZodDefault<import("zod").ZodEnum<{
+        oval: "oval";
+        rect: "rect";
+        round: "round";
+    }>>;
+    diameter: import("zod").ZodDefault<import("zod").ZodNumber>;
+    width: import("zod").ZodDefault<import("zod").ZodNumber>;
+    height: import("zod").ZodDefault<import("zod").ZodNumber>;
+    roll: import("zod").ZodDefault<import("zod").ZodNumber>;
+    ductMaterial: import("zod").ZodDefault<import("zod").ZodEnum<{
+        "duct-board": "duct-board";
+        flex: "flex";
+        "sheet-metal": "sheet-metal";
+        spiral: "spiral";
+    }>>;
+    seamDetail: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    insulated: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    insulationR: import("zod").ZodDefault<import("zod").ZodNumber>;
+    system: import("zod").ZodDefault<import("zod").ZodEnum<{
+        return: "return";
+        supply: "supply";
+    }>>;
+    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-segment/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/duct-segment/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAA+B,KAAK,cAAc,EAAY,MAAM,kBAAkB,CAAA;AAS7F,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAoC1C,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,OAAO,eAAe,CAyJxE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/duct-segment/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAGjC,CAAA"}

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

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

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

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

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

@@ -0,0 +1,98 @@
+import { useScene } from '@pascal-app/core';
+import { ductBodyPaint } from '../shared/duct-body-paint.js';
+import { createPathPointMoveAffordance } from '../shared/path-point-affordance.js';
+import { createSegmentMoveAffordance } from '../shared/path-segment-affordance.js';
+import { createRunHangerToolHint } from '../shared/run-hanger-mode.js';
+import { ductRunToolOptions } from '../shared/run-tool-options.js';
+import { ductBranchAffordance, ductContinuationAffordance } from './continuation.js';
+import { ductSegmentParametrics } from './parametrics.js';
+/**
+ * Phase 1 of the HVAC node system — round duct segment as a polyline.
+ *
+ * Composition: `def.geometry` only. No custom renderer, no per-frame
+ * system. The framework's `<ParametricNodeRenderer>` mounts an empty
+ * group; `<GeometrySystem>` calls `buildDuctSegmentGeometry` whenever
+ * the node is dirty and swaps in the cylinder+sphere meshes.
+ *
+ * Deferred to later slices:
+ *   - Placement tool (polyline draw UX).
+ *   - Fittings (elbow / tee / reducer) — needs typed ports first.
+ *   - Terminals (registers / diffusers) — needs surface-snapping.
+ *   - Equipment (furnace / air-handler / condenser).
+ *   - Floor-plan rendering.
+ *   - Move / endpoint handles.
+ *
+ * The node can be created programmatically today via
+ * `DuctSegmentNode.parse({ path: [...] })` + `useScene.createNode(...)`.
+ */
+/** R / T roll step (radians) — 45°, matching the fitting rotate. */
+const ROLL_STEP_RAD = Math.PI / 4;
+/**
+ * R / T roll a selected rect / oval run's cross-section ±45° around its
+ * drawn line, so a rectangular trunk can be turned on its side after
+ * placement. Round runs look identical at any roll, so the action gates
+ * itself off for them (`appliesTo`) and the editor's default rotation —
+ * a no-op for a node with no `rotation` field — takes over harmlessly.
+ */
+function rollDuctSegment(node, steps) {
+    const duct = node;
+    useScene.getState().updateNode(duct.id, { roll: duct.roll + steps * ROLL_STEP_RAD });
+}
+export const ductSegmentEditContribution = {
+    drafting: { surfaceQuery: true, cancelOnHistoryJump: true },
+    // Directional run: like a wall, drafting sets a direction, so it takes the
+    // structural snapping context (grid / lines / angles / off) with a 45° angle
+    // lock available as a cyclable mode.
+    snapProfile: 'structural',
+    capabilities: {
+        paint: ductBodyPaint,
+    },
+    parametrics: ductSegmentParametrics,
+    // R / T roll a selected rect / oval run ±45° around its drawn line.
+    // `appliesTo` lets round runs fall through to the editor's default
+    // (harmless — duct-segment has no `rotation` field).
+    keyboardActions: {
+        r: {
+            appliesTo: (node) => node.type === 'duct-segment' && node.shape !== 'round',
+            run: (node) => rollDuctSegment(node, 1),
+        },
+        t: {
+            appliesTo: (node) => node.type === 'duct-segment' && node.shape !== 'round',
+            run: (node) => rollDuctSegment(node, -1),
+        },
+    },
+    floorplanDependsOnSiblings: true,
+    // 2D selection-time path-point handles — the floor-plan twin of the 3D
+    // `affordanceTools.selection` handles. The builder emits an
+    // `endpoint-handle` per path vertex; this drags the matching point.
+    floorplanAffordances: {
+        'move-path-point': createPathPointMoveAffordance('duct-segment'),
+        // 2D twin of the 3D side-move arrows: slide a segment perpendicular to
+        // itself. (Length editing stays on the per-vertex hex handles.)
+        'move-segment': createSegmentMoveAffordance('duct-segment'),
+        'continue-run': ductContinuationAffordance,
+        'branch-run': ductBranchAffordance,
+    },
+    // Selection-time path-point handles (drag to edit a committed run).
+    // Editor-only UI (reads gridSnapStep, renders DimensionPill), so it
+    // mounts via the editor's SelectionAffordanceManager — not `def.system`,
+    // which the viewer package mounts for the read-only route.
+    affordanceTools: {
+        selection: () => import('./selection.js'),
+        // Ghost-preview duplicate / move. Duplicate is pure drag-to-place: a
+        // translucent copy of the run follows the cursor and only lands on the
+        // commit click — nothing is inserted into the scene before that.
+        move: () => import('./move-tool.js'),
+    },
+    tool: () => import('./tool.js'),
+    toolOptions: ductRunToolOptions,
+    toolHints: [
+        { key: 'Click', label: 'Start segment' },
+        { key: 'Click again', label: 'Place and continue' },
+        { key: 'Alt + drag', label: 'Go vertical ↕, click to place' },
+        { key: '[ / ]', label: 'Duct diameter down / up' },
+        { key: 'Q', label: 'Round / rectangular / oval' },
+        createRunHangerToolHint('duct-segment'),
+        { key: 'Esc', label: 'Exit drawing' },
+    ],
+};

package/dist/duct-segment/definition.js

@@ -1,181 +1,4 @@
-import { ductBodySlots, useScene } from '@pascal-app/core';
-import { ductBodyPaint } from '../shared/duct-body-paint.js';
-import { createPathPointMoveAffordance } from '../shared/path-point-affordance.js';
-import { createSegmentMoveAffordance } from '../shared/path-segment-affordance.js';
-import { createRunHangerToolHint } from '../shared/run-hanger-mode.js';
-import { ductBranchAffordance, ductContinuationAffordance } from './continuation.js';
-import { buildDuctSegmentFloorplan } from './floorplan.js';
-import { buildDuctSegmentGeometry, ductPortDiameterIn } from './geometry.js';
-import { ductSegmentParametrics } from './parametrics.js';
-import { DuctSegmentNode } from './schema.js';
-/**
- * Phase 1 of the HVAC node system — round duct segment as a polyline.
- *
- * Composition: `def.geometry` only. No custom renderer, no per-frame
- * system. The framework's `<ParametricNodeRenderer>` mounts an empty
- * group; `<GeometrySystem>` calls `buildDuctSegmentGeometry` whenever
- * the node is dirty and swaps in the cylinder+sphere meshes.
- *
- * Deferred to later slices:
- *   - Placement tool (polyline draw UX).
- *   - Fittings (elbow / tee / reducer) — needs typed ports first.
- *   - Terminals (registers / diffusers) — needs surface-snapping.
- *   - Equipment (furnace / air-handler / condenser).
- *   - Floor-plan rendering.
- *   - Move / endpoint handles.
- *
- * The node can be created programmatically today via
- * `DuctSegmentNode.parse({ path: [...] })` + `useScene.createNode(...)`.
- */
-/** R / T roll step (radians) — 45°, matching the fitting rotate. */
-const ROLL_STEP_RAD = Math.PI / 4;
-/**
- * R / T roll a selected rect / oval run's cross-section ±45° around its
- * drawn line, so a rectangular trunk can be turned on its side after
- * placement. Round runs look identical at any roll, so the action gates
- * itself off for them (`appliesTo`) and the editor's default rotation —
- * a no-op for a node with no `rotation` field — takes over harmlessly.
- */
-function rollDuctSegment(node, steps) {
-    const duct = node;
-    useScene.getState().updateNode(duct.id, { roll: duct.roll + steps * ROLL_STEP_RAD });
-}
-export const ductSegmentDefinition = {
-    kind: 'duct-segment',
-    schemaVersion: 2,
-    schema: DuctSegmentNode,
-    category: 'utility',
-    distributionRole: 'run',
-    drafting: { surfaceQuery: true, cancelOnHistoryJump: true },
-    // Directional run: like a wall, drafting sets a direction, so it takes the
-    // structural snapping context (grid / lines / angles / off) with a 45° angle
-    // lock available as a cyclable mode.
-    snapProfile: 'structural',
-    defaults: () => ({
-        object: 'node',
-        parentId: null,
-        visible: true,
-        metadata: {},
-        autoHangers: false,
-        hangerStyle: 'single',
-        hangerSpacing: 1.5,
-        hangerMaxReach: 2,
-        path: [
-            [0, 0, 0],
-            [3, 0, 0],
-        ],
-        shape: 'rect',
-        diameter: 6,
-        width: 14,
-        height: 8,
-        ductMaterial: 'flex',
-        seamDetail: false,
-        insulated: false,
-        insulationR: 0.5,
-        system: 'supply',
-        roll: 0,
-    }),
-    capabilities: {
-        selectable: { hitVolume: 'bbox' },
-        duplicable: true,
-        deletable: true,
-        slots: () => ductBodySlots(),
-        paint: ductBodyPaint,
-    },
-    parametrics: ductSegmentParametrics,
-    // R / T roll a selected rect / oval run ±45° around its drawn line.
-    // `appliesTo` lets round runs fall through to the editor's default
-    // (harmless — duct-segment has no `rotation` field).
-    keyboardActions: {
-        r: {
-            appliesTo: (node) => node.type === 'duct-segment' && node.shape !== 'round',
-            run: (node) => rollDuctSegment(node, 1),
-        },
-        t: {
-            appliesTo: (node) => node.type === 'duct-segment' && node.shape !== 'round',
-            run: (node) => rollDuctSegment(node, -1),
-        },
-    },
-    system: {
-        module: async () => ({
-            default: (await import('../shared/run-hanger-system.js')).DuctHangerSystem,
-        }),
-    },
-    floorplanDependsOnSiblings: true,
-    geometry: buildDuctSegmentGeometry,
-    // Open run ends as typed ports — directions point outward along the
-    // path tangent so fittings mate flush. Path coords are already
-    // level-local, so no transform is needed.
-    ports: (n) => {
-        if (n.path.length < 2)
-            return [];
-        const unit = (a, b) => {
-            const d = [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
-            const len = Math.hypot(d[0], d[1], d[2]);
-            return len < 1e-9 ? [1, 0, 0] : [d[0] / len, d[1] / len, d[2] / len];
-        };
-        const first = n.path[0];
-        const second = n.path[1];
-        const last = n.path[n.path.length - 1];
-        const prev = n.path[n.path.length - 2];
-        return [
-            {
-                id: 'start',
-                position: first,
-                direction: unit(first, second),
-                diameter: ductPortDiameterIn(n),
-                system: n.system,
-            },
-            {
-                id: 'end',
-                position: last,
-                direction: unit(last, prev),
-                diameter: ductPortDiameterIn(n),
-                system: n.system,
-            },
-        ];
-    },
-    floorplan: buildDuctSegmentFloorplan,
-    // 2D selection-time path-point handles — the floor-plan twin of the 3D
-    // `affordanceTools.selection` handles. The builder emits an
-    // `endpoint-handle` per path vertex; this drags the matching point.
-    floorplanAffordances: {
-        'move-path-point': createPathPointMoveAffordance('duct-segment'),
-        // 2D twin of the 3D side-move arrows: slide a segment perpendicular to
-        // itself. (Length editing stays on the per-vertex hex handles.)
-        'move-segment': createSegmentMoveAffordance('duct-segment'),
-        'continue-run': ductContinuationAffordance,
-        'branch-run': ductBranchAffordance,
-    },
-    // Selection-time path-point handles (drag to edit a committed run).
-    // Editor-only UI (reads gridSnapStep, renders DimensionPill), so it
-    // mounts via the editor's SelectionAffordanceManager — not `def.system`,
-    // which the viewer package mounts for the read-only route.
-    affordanceTools: {
-        selection: () => import('./selection.js'),
-        // Ghost-preview duplicate / move. Duplicate is pure drag-to-place: a
-        // translucent copy of the run follows the cursor and only lands on the
-        // commit click — nothing is inserted into the scene before that.
-        move: () => import('./move-tool.js'),
-    },
-    tool: () => import('./tool.js'),
-    toolHints: [
-        { key: 'Click', label: 'Start segment' },
-        { key: 'Click again', label: 'Place and continue' },
-        { key: 'Alt + drag', label: 'Go vertical ↕, click to place' },
-        { key: '[ / ]', label: 'Duct diameter down / up' },
-        { key: 'Q', label: 'Round / rectangular / oval' },
-        createRunHangerToolHint('duct-segment'),
-        { key: 'Esc', label: 'Exit drawing' },
-    ],
-    presentation: {
-        label: 'Duct',
-        description: 'HVAC duct run — polyline of round, rect, or flat-oval sections.',
-        icon: { kind: 'url', src: '/icons/duct.webp' },
-        paletteSection: 'structure',
-        paletteOrder: 90,
-    },
-    mcp: {
-        description: 'An HVAC duct run defined as a polyline — round (branches), rect (trunks/plenums), or flat-oval (tight joist bays). Supply or return, with configurable size, material (incl. spiral seam), and external insulation.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { ductSegmentEditContribution } from './definition.edit.js';
+import { ductSegmentRenderDefinition } from './definition.render.js';
+export const ductSegmentDefinition = composeNodeDefinition(ductSegmentRenderDefinition, ductSegmentEditContribution);

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

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

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

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