@pascal-app/nodes 0.1.1

package/dist/downspout/routing.d.ts

@@ -0,0 +1,81 @@
+import type { DownspoutNode, GutterNode, RoofSegmentNode, SceneApi } from '@pascal-app/core';
+import { type OutletDims, type OutletShape } from '../gutter/profile-geometry';
+/**
+ * Routing parameters that turn the downspout from a straight drop into
+ * a pipe that actually returns to the wall. Derived from the host
+ * gutter + its roof segment — the geometry builder stays pure (takes
+ * this as data) so the renderer, the placement preview, and the handle
+ * descriptors can all feed it the same numbers.
+ */
+export type DownspoutRouting = {
+    /**
+     * Distance the pipe must travel toward the wall (downspout-local −Z)
+     * to leave the eave overhang and sit flat against the fascia. The
+     * outlet hangs `overhang − tuck` outboard of the wall face, plus the
+     * `floorMidZ` offset of the outlet within the trough — so the offset
+     * elbow at the top steps the pipe back by exactly this much.
+     */
+    wallJog: number;
+    /** Cross-section the pipe takes — round on half-round, rect on k-style / box. */
+    shape: OutletShape;
+    /**
+     * Inner half-extents of the gutter's drilled collar (along-length X,
+     * outward Z). The pipe's cross-section is clamped just under these so
+     * it slip-fits up inside the collar instead of sharing a coincident
+     * surface with it (the old pipe sat at exactly the bore and z-fought
+     * the collar wall).
+     */
+    collarHalfX: number;
+    collarHalfZ: number;
+};
+/**
+ * Pure routing from resolved nodes — used by the renderer / preview /
+ * tool, which already hold the effective gutter + segment.
+ */
+export declare function computeDownspoutRouting(gutter: GutterNode, segment: Pick<RoofSegmentNode, 'overhang'>, outletId: string | undefined): DownspoutRouting | null;
+/**
+ * Routing for the handle descriptors, which only get `(node, sceneApi)`.
+ * Walks downspout → gutter → segment through the scene snapshot.
+ */
+export declare function resolveDownspoutRouting(node: DownspoutNode, sceneApi: SceneApi): DownspoutRouting | null;
+/**
+ * Rendered pipe cross-section — round (halfX = halfZ = radius) or rect,
+ * following the host gutter's profile. Defaults to `diameter`-sized, but
+ * each half-extent that lands within a hair of the collar's matching
+ * bore is nudged just inside so the pipe slip-fits the collar instead of
+ * sharing a coincident wall. A deliberately larger / smaller pipe is
+ * left alone, so the diameter field stays honest.
+ */
+export declare function downspoutPipeDims(node: Pick<DownspoutNode, 'diameter' | 'shape'>, routing?: DownspoutRouting | null): OutletDims;
+/**
+ * The −Z distance the wall run actually sits at. The raw `wallJog`
+ * reaches the wall *face*; we pull back by the pipe's outward half-depth
+ * (so the pipe's surface — not its centerline — meets the wall) plus the
+ * `standoff` (bracket gap / overshoot escape hatch), so the pipe sits
+ * proud of the wall instead of burying into it.
+ */
+export declare function effectiveWallJog(node: Pick<DownspoutNode, 'diameter' | 'standoff' | 'shape'>, routing?: DownspoutRouting | null): number;
+export type DownspoutPath = {
+    /** Centerline points, top → bottom, in downspout-local space. */
+    points: [number, number, number][];
+    /** Bottom mouth — the kicked-out pipe end. */
+    bottom: [number, number, number];
+    /** Z of the vertical wall run (downspout-local; −jog). */
+    wallRunZ: number;
+    /** Y at the top of the straight wall run (just below the offset elbow). */
+    wallRunTopY: number;
+    /** Y at the bottom of the straight wall run (just above the kickout). */
+    wallRunBottomY: number;
+};
+/**
+ * Pure centerline of the routed pipe. Shared by the geometry builder
+ * (sweeps a cylinder along it) and the handle descriptors (place the
+ * length cube at `bottom`), so the dimension chrome can never drift
+ * from the mesh.
+ *
+ * Local frame: Y = 0 at the gutter floor, −Y down, −Z toward the wall.
+ * The four legs are the vertical drop out of the collar, the offset
+ * elbow stepping back to the wall, the wall run, and the kickout.
+ */
+export declare function computeDownspoutPath(length: number, jog: number, allowKick?: boolean): DownspoutPath;
+//# sourceMappingURL=routing.d.ts.map

package/dist/downspout/routing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routing.d.ts","sourceRoot":"","sources":["../../src/downspout/routing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,aAAa,EACb,UAAU,EACV,eAAe,EACf,QAAQ,EACT,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EACL,KAAK,UAAU,EACf,KAAK,WAAW,EAGjB,MAAM,4BAA4B,CAAA;AAEnC;;;;;;GAMG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B;;;;;;OAMG;IACH,OAAO,EAAE,MAAM,CAAA;IACf,iFAAiF;IACjF,KAAK,EAAE,WAAW,CAAA;IAClB;;;;;;OAMG;IACH,WAAW,EAAE,MAAM,CAAA;IACnB,WAAW,EAAE,MAAM,CAAA;CACpB,CAAA;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,UAAU,EAClB,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,UAAU,CAAC,EAC1C,QAAQ,EAAE,MAAM,GAAG,SAAS,GAC3B,gBAAgB,GAAG,IAAI,CAiBzB;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,aAAa,EACnB,QAAQ,EAAE,QAAQ,GACjB,gBAAgB,GAAG,IAAI,CAQzB;AAiBD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,IAAI,CAAC,aAAa,EAAE,UAAU,GAAG,OAAO,CAAC,EAC/C,OAAO,CAAC,EAAE,gBAAgB,GAAG,IAAI,GAChC,UAAU,CAWZ;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,IAAI,CAAC,aAAa,EAAE,UAAU,GAAG,UAAU,GAAG,OAAO,CAAC,EAC5D,OAAO,CAAC,EAAE,gBAAgB,GAAG,IAAI,GAChC,MAAM,CAIR;AAWD,MAAM,MAAM,aAAa,GAAG;IAC1B,iEAAiE;IACjE,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,CAAA;IAClC,8CAA8C;IAC9C,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAChC,0DAA0D;IAC1D,QAAQ,EAAE,MAAM,CAAA;IAChB,2EAA2E;IAC3E,WAAW,EAAE,MAAM,CAAA;IACnB,yEAAyE;IACzE,cAAc,EAAE,MAAM,CAAA;CACvB,CAAA;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,SAAS,UAAO,GAAG,aAAa,CA8BjG"}

package/dist/downspout/routing.js

@@ -0,0 +1,131 @@
+import { EAVE_TUCK_INWARD } from '../gutter/eave-snap';
+import { resolveGutterOutletById } from '../gutter/outlet-lookup';
+import { outletDims, profileFloorMidZ, } from '../gutter/profile-geometry';
+/**
+ * Pure routing from resolved nodes — used by the renderer / preview /
+ * tool, which already hold the effective gutter + segment.
+ */
+export function computeDownspoutRouting(gutter, segment, outletId) {
+    const outlet = resolveGutterOutletById(gutter, outletId);
+    if (!outlet)
+        return null;
+    const overhang = segment.overhang ?? 0;
+    const floorMidZ = profileFloorMidZ(gutter.profile ?? 'k-style', Math.max(0.04, gutter.size));
+    // The gutter rim is tucked `EAVE_TUCK_INWARD` back from the very tip
+    // of the overhang, so the real outboard distance is `overhang − tuck`
+    // (never negative — a flush eave still leaves the floorMidZ offset).
+    const wallJog = Math.max(0, overhang - EAVE_TUCK_INWARD) + floorMidZ;
+    return {
+        wallJog,
+        shape: outlet.shape,
+        collarHalfX: outlet.innerHalfX,
+        collarHalfZ: outlet.innerHalfZ,
+    };
+}
+/**
+ * Routing for the handle descriptors, which only get `(node, sceneApi)`.
+ * Walks downspout → gutter → segment through the scene snapshot.
+ */
+export function resolveDownspoutRouting(node, sceneApi) {
+    if (!node.gutterId)
+        return null;
+    const gutter = sceneApi.get(node.gutterId);
+    if (gutter?.type !== 'gutter')
+        return null;
+    const segment = gutter.roofSegmentId
+        ? sceneApi.get(gutter.roofSegmentId)
+        : undefined;
+    return computeDownspoutRouting(gutter, segment ?? { overhang: 0 }, node.outletId);
+}
+// ─── Pipe cross-section + effective jog ──────────────────────────────
+// Slip-fit clearance — when the pipe lands within this of the collar
+// bore (the placement default, where pipe == hole), nudge it just inside
+// so it doesn't share a coincident wall (the old z-fighting).
+const NEAR_BORE = 0.002;
+const SLIP_CLEARANCE = 0.0005;
+function nestUnder(half, collar) {
+    if (collar !== undefined && Math.abs(half - collar) < NEAR_BORE) {
+        return Math.max(0.005, collar - SLIP_CLEARANCE);
+    }
+    return half;
+}
+/**
+ * Rendered pipe cross-section — round (halfX = halfZ = radius) or rect,
+ * following the host gutter's profile. Defaults to `diameter`-sized, but
+ * each half-extent that lands within a hair of the collar's matching
+ * bore is nudged just inside so the pipe slip-fits the collar instead of
+ * sharing a coincident wall. A deliberately larger / smaller pipe is
+ * left alone, so the diameter field stays honest.
+ */
+export function downspoutPipeDims(node, routing) {
+    // 'auto' follows the gutter profile; 'round' / 'rect' override it.
+    const shape = node.shape && node.shape !== 'auto' ? node.shape : (routing?.shape ?? 'round');
+    const dims = outletDims(shape, node.diameter);
+    if (!routing)
+        return dims;
+    return {
+        shape,
+        halfX: nestUnder(dims.halfX, routing.collarHalfX),
+        halfZ: nestUnder(dims.halfZ, routing.collarHalfZ),
+    };
+}
+/**
+ * The −Z distance the wall run actually sits at. The raw `wallJog`
+ * reaches the wall *face*; we pull back by the pipe's outward half-depth
+ * (so the pipe's surface — not its centerline — meets the wall) plus the
+ * `standoff` (bracket gap / overshoot escape hatch), so the pipe sits
+ * proud of the wall instead of burying into it.
+ */
+export function effectiveWallJog(node, routing) {
+    if (!routing)
+        return 0;
+    const dims = downspoutPipeDims(node, routing);
+    return Math.max(0, routing.wallJog - dims.halfZ - (node.standoff ?? 0));
+}
+// ─── Centerline path ─────────────────────────────────────────────────
+// Vertical drop straight out of the collar before the offset elbow.
+const TOP_DROP = 0.05;
+// Bottom kickout: how far the mouth throws outward (+Z) and how tall
+// the kicked section is. Skipped when the pipe is too short to fit it.
+const KICK_OUT = 0.08;
+const KICK_RISE = 0.1;
+/**
+ * Pure centerline of the routed pipe. Shared by the geometry builder
+ * (sweeps a cylinder along it) and the handle descriptors (place the
+ * length cube at `bottom`), so the dimension chrome can never drift
+ * from the mesh.
+ *
+ * Local frame: Y = 0 at the gutter floor, −Y down, −Z toward the wall.
+ * The four legs are the vertical drop out of the collar, the offset
+ * elbow stepping back to the wall, the wall run, and the kickout.
+ */
+export function computeDownspoutPath(length, jog, allowKick = true) {
+    const len = Math.max(0.1, length);
+    const j = Math.max(0, jog);
+    const drop = Math.min(TOP_DROP, len * 0.15);
+    // Offset elbow runs at ~45° (vertical travel == horizontal jog) but
+    // never eats more than what's left after the drop + a minimum run.
+    const elbowVert = Math.min(j, Math.max(0, len - drop - 0.1));
+    const afterElbow = len - drop - elbowVert;
+    // `allowKick` off (terminal 'straight') runs the pipe straight to the
+    // bottom — no kickout leg.
+    const kick = allowKick && afterElbow > KICK_RISE * 1.5;
+    const kickRise = kick ? Math.min(KICK_RISE, afterElbow * 0.3) : 0;
+    const kickOut = kick ? KICK_OUT : 0;
+    const wallRunTopY = -drop - elbowVert;
+    const wallRunBottomY = -len + kickRise;
+    const bottom = [0, -len, -j + kickOut];
+    return {
+        points: [
+            [0, 0, 0], // collar mouth
+            [0, -drop, 0], // bottom of the first drop
+            [0, wallRunTopY, -j], // offset elbow, now at the wall
+            [0, wallRunBottomY, -j], // bottom of the wall run
+            bottom, // kicked mouth
+        ],
+        bottom,
+        wallRunZ: -j,
+        wallRunTopY,
+        wallRunBottomY,
+    };
+}

package/dist/downspout/schema.d.ts

@@ -0,0 +1,2 @@
+export { DownspoutNode } from '@pascal-app/core';
+//# sourceMappingURL=schema.d.ts.map

package/dist/downspout/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/downspout/schema.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/downspout/schema.js

@@ -0,0 +1,3 @@
+// Schema lives in core (referenced by the AnyNode union). Re-export so
+// every downspout-related import stays inside @pascal-app/nodes/downspout.
+export { DownspoutNode } from '@pascal-app/core';

package/dist/downspout/tool.d.ts

@@ -0,0 +1,3 @@
+declare const DownspoutTool: () => import("react").JSX.Element;
+export default DownspoutTool;
+//# sourceMappingURL=tool.d.ts.map

package/dist/downspout/tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/downspout/tool.tsx"],"names":[],"mappings":"AA+CA,QAAA,MAAM,aAAa,mCA+IlB,CAAA;AAeD,eAAe,aAAa,CAAA"}

package/dist/downspout/tool.js

@@ -0,0 +1,148 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { DownspoutNode, emitter, generateId, sceneRegistry, useScene, } from '@pascal-app/core';
+import { triggerSFX } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useEffect, useMemo, useState } from 'react';
+import { Vector3 } from 'three';
+import { computeEaveY } from '../gutter/eave-snap';
+import { resolveGutterOutletById } from '../gutter/outlet-lookup';
+import { RoofAttachmentFallbackPreview } from '../shared/roof-attachment-fallback-preview';
+import { downspoutDefinition } from './definition';
+import DownspoutPreview from './preview';
+import { computeDownspoutRouting } from './routing';
+const DEFAULT_OUTLET_DIAMETER = 0.07;
+/**
+ * Downspout placement tool. Hovering a gutter previews a downspout at
+ * the cursor's position ALONG the gutter; clicking drills a NEW outlet
+ * there (appended to the gutter's `outlets`) and drops a downspout
+ * linked to it. So multiple downspouts on one gutter land where you
+ * click instead of stacking on a single outlet.
+ *
+ * The cursor's along-length offset is read by projecting the world hit
+ * into the gutter's registered mesh frame (worldToLocal → local X). A
+ * throwaway gutter with a single `preview` outlet feeds the same outlet
+ * lookup + routing the committed pipe uses, so the ghost matches.
+ */
+const _hit = new Vector3();
+const DownspoutTool = () => {
+    const activeBuildingId = useViewer((s) => s.selection.buildingId);
+    const setSelection = useViewer((s) => s.setSelection);
+    const [target, setTarget] = useState(null);
+    const previewNode = useMemo(() => DownspoutNode.parse({
+        ...downspoutDefinition.defaults(),
+        name: 'Downspout',
+    }), []);
+    useEffect(() => {
+        if (!activeBuildingId)
+            return;
+        // Cursor's offset along the gutter length, from the world hit.
+        const cursorOffset = (gutter, world) => {
+            const obj = sceneRegistry.nodes.get(gutter.id);
+            if (!obj)
+                return null;
+            obj.updateWorldMatrix(true, false);
+            return obj.worldToLocal(_hit.set(world[0], world[1], world[2])).x;
+        };
+        const computeTarget = (event) => {
+            const gutter = event.node;
+            const segmentId = gutter.roofSegmentId;
+            if (!segmentId)
+                return null;
+            const segment = useScene.getState().nodes[segmentId];
+            if (!segment)
+                return null;
+            const offset = cursorOffset(gutter, event.position);
+            if (offset === null)
+                return null;
+            // Throwaway single-outlet gutter at the cursor so the lookup +
+            // routing produce the exact pose the commit will store.
+            const ghost = {
+                ...gutter,
+                outlets: [{ id: 'preview', offset, diameter: DEFAULT_OUTLET_DIAMETER }],
+            };
+            const outlet = resolveGutterOutletById(ghost, 'preview');
+            if (!outlet)
+                return null;
+            return {
+                segment: {
+                    position: (segment.position ?? [0, 0, 0]),
+                    rotation: segment.rotation ?? 0,
+                    eaveY: computeEaveY(segment),
+                },
+                gutter: {
+                    position: (gutter.position ?? [0, 0, 0]),
+                    rotation: gutter.rotation ?? 0,
+                },
+                outlet,
+                routing: computeDownspoutRouting(ghost, segment, 'preview'),
+            };
+        };
+        const updatePreview = (event) => {
+            const next = computeTarget(event);
+            if (next) {
+                setTarget(next);
+                event.stopPropagation();
+            }
+        };
+        const onClick = (event) => {
+            const gutter = event.node;
+            const segmentId = gutter.roofSegmentId;
+            if (!segmentId)
+                return;
+            const segment = useScene.getState().nodes[segmentId];
+            if (!segment)
+                return;
+            const offset = cursorOffset(gutter, event.position);
+            if (offset === null)
+                return;
+            // Drill a new outlet at the clicked offset, then drop a downspout
+            // linked to it. Both land in one undoable step.
+            const outletId = generateId('outlet');
+            const outlets = [
+                ...(gutter.outlets ?? []),
+                { id: outletId, offset, diameter: DEFAULT_OUTLET_DIAMETER },
+            ];
+            const state = useScene.getState();
+            state.updateNode(gutter.id, { outlets });
+            state.dirtyNodes.add(gutter.id);
+            const outlet = resolveGutterOutletById({ ...gutter, outlets }, outletId);
+            if (!outlet)
+                return;
+            // Drop from the gutter outlet (at eaveY − size) down to segment Y = 0.
+            const dropLength = Math.max(0.1, computeEaveY(segment) + outlet.y);
+            const downspout = DownspoutNode.parse({
+                ...downspoutDefinition.defaults(),
+                name: 'Downspout',
+                gutterId: gutter.id,
+                outletId,
+                length: dropLength,
+                diameter: outlet.bore * 2,
+            });
+            state.createNode(downspout, segmentId);
+            state.dirtyNodes.add(segmentId);
+            setSelection({ selectedIds: [downspout.id] });
+            triggerSFX('sfx:item-place');
+            event.stopPropagation();
+        };
+        emitter.on('gutter:move', updatePreview);
+        emitter.on('gutter:enter', updatePreview);
+        emitter.on('gutter:click', onClick);
+        return () => {
+            emitter.off('gutter:move', updatePreview);
+            emitter.off('gutter:enter', updatePreview);
+            emitter.off('gutter:click', onClick);
+        };
+    }, [activeBuildingId, setSelection]);
+    return (_jsxs(_Fragment, { children: [_jsx(RoofAttachmentFallbackPreview, { activeBuildingId: activeBuildingId, ghost: _jsx(DownspoutPreview, { node: previewNode, invalid: true }), onInvalidTarget: () => setTarget(null), validTarget: "gutter" }), activeBuildingId && target && (_jsx("group", { position: target.segment.position, "rotation-y": target.segment.rotation, children: _jsx("group", { position: [target.gutter.position[0], target.segment.eaveY, target.gutter.position[2]], "rotation-y": target.gutter.rotation, children: _jsx("group", { position: [target.outlet.x, target.outlet.y, target.outlet.z], children: _jsx(DownspoutPreview, { node: previewNodeWithDefaults(previewNode, target), routing: target.routing }) }) }) }))] }));
+};
+function previewNodeWithDefaults(base, target) {
+    // Snap preview to the same dimensions a commit would use — bore
+    // diameter from the gutter, drop length to the segment Y=0 plane.
+    return {
+        ...base,
+        diameter: target.outlet.bore * 2,
+        length: Math.max(0.1, target.segment.eaveY + target.outlet.y),
+    };
+}
+export default DownspoutTool;

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

@@ -0,0 +1,12 @@
+import type { NodeDefinition } from '@pascal-app/core';
+import { DuctFittingNode } from './schema';
+/**
+ * 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>;
+//# sourceMappingURL=definition.d.ts.map

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

@@ -0,0 +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;AAOtD,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAE1C;;;;;;;GAOG;AACH,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,OAAO,eAAe,CAyHxE,CAAA"}

package/dist/duct-fitting/definition.js

@@ -0,0 +1,124 @@
+import { ductBodyPaint, ductBodySlots } from '../shared/duct-body-paint';
+import { rotateFittingNode } from '../shared/fitting-rotation';
+import { buildDuctFittingFloorplan } from './floorplan';
+import { buildDuctFittingGeometry } from './geometry';
+import { ductFittingParametrics } from './parametrics';
+import { getDuctFittingPorts } from './ports';
+import { DuctFittingNode } from './schema';
+/**
+ * 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: 1,
+    schema: DuctFittingNode,
+    category: 'utility',
+    distributionRole: 'fitting',
+    snapProfile: 'item',
+    defaults: () => ({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        position: [0, 0, 0],
+        rotation: [0, 0, 0],
+        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,
+        // 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.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'),
+        // 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'),
+    },
+    tool: () => import('./tool'),
+    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.',
+    },
+};

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

@@ -0,0 +1,12 @@
+import type { FloorplanGeometry, GeometryContext } from '@pascal-app/core';
+import type { DuctFittingNode } from './schema';
+/**
+ * Floor-plan symbol for a duct fitting: one stub line per port from the
+ * junction center out to the collar (drawn at each collar's real
+ * diameter), plus a junction circle. Ports are computed in level-local
+ * 3D and projected to plan, so a rotated or riser-turned fitting shows
+ * its true plan footprint; a vertical port collapses onto the junction
+ * circle, which is exactly how it should read from above.
+ */
+export declare function buildDuctFittingFloorplan(node: DuctFittingNode, ctx: GeometryContext): FloorplanGeometry | null;
+//# sourceMappingURL=floorplan.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/duct-fitting/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAG1E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAM/C;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,eAAe,EACrB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAgD1B"}

package/dist/duct-fitting/floorplan.js

@@ -0,0 +1,59 @@
+import { INCHES_TO_METERS } from '../duct-segment/geometry';
+import { getDuctFittingPorts } from './ports';
+const SUPPLY_COLOR = '#d4825a';
+const RETURN_COLOR = '#5a8ad4';
+const BODY_COLOR = '#9ca3af';
+/**
+ * Floor-plan symbol for a duct fitting: one stub line per port from the
+ * junction center out to the collar (drawn at each collar's real
+ * diameter), plus a junction circle. Ports are computed in level-local
+ * 3D and projected to plan, so a rotated or riser-turned fitting shows
+ * its true plan footprint; a vertical port collapses onto the junction
+ * circle, which is exactly how it should read from above.
+ */
+export function buildDuctFittingFloorplan(node, ctx) {
+    const [cx, , cz] = node.position;
+    const ports = getDuctFittingPorts(node);
+    const view = ctx.viewState;
+    const palette = view?.palette;
+    const showSelectedChrome = (view?.selected || view?.highlighted) ?? false;
+    const accent = node.system === 'supply' ? SUPPLY_COLOR : RETURN_COLOR;
+    const bodyStroke = showSelectedChrome && palette ? palette.selectedStroke : BODY_COLOR;
+    const children = [];
+    for (const port of ports) {
+        const px = port.position[0];
+        const pz = port.position[2];
+        // Vertical port — projects onto the junction itself; skip the stub.
+        if (Math.hypot(px - cx, pz - cz) < 1e-4)
+            continue;
+        children.push({
+            kind: 'line',
+            x1: cx,
+            y1: cz,
+            x2: px,
+            y2: pz,
+            stroke: bodyStroke,
+            strokeWidth: port.diameter * INCHES_TO_METERS,
+            strokeLinecap: 'round',
+            opacity: showSelectedChrome ? 0.95 : 0.8,
+        });
+    }
+    children.push({
+        kind: 'circle',
+        cx,
+        cy: cz,
+        r: (node.diameter * INCHES_TO_METERS) / 2 + 0.015,
+        fill: bodyStroke,
+        stroke: accent,
+        strokeWidth: 1.5,
+        vectorEffect: 'non-scaling-stroke',
+        opacity: 0.95,
+    });
+    if (showSelectedChrome) {
+        children.push({
+            kind: 'move-handle',
+            point: [cx, cz],
+        });
+    }
+    return { kind: 'group', children };
+}

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

@@ -0,0 +1,26 @@
+import type { GeometryContext } from '@pascal-app/core';
+import type { ColorPreset, RenderShading } from '@pascal-app/viewer';
+import { Group } from 'three';
+import type { DuctFittingNode } from './schema';
+/**
+ * Pure geometry builder for a duct fitting, in the fitting's LOCAL frame —
+ * `<ParametricNodeRenderer>` applies `node.position` / `node.rotation`.
+ *
+ * Strategy: one cylinder stub per port from the junction center outward
+ * (reusing the segment builder's `buildSection`), a sphere at the
+ * junction, and a slightly-oversized crimp collar ring at each port
+ * opening so fittings read as sheet-metal junctions rather than bare
+ * tube ends.
+ *
+ * The reducer is special-cased: instead of equal stubs + sphere it draws
+ * a short inlet stub, a tapered cone, and a short outlet stub inline.
+ *
+ * Non-round shapes (elbow / tee): run legs carry the fitting's
+ * width × height profile — rect prisms or flat-oval stadiums — matching
+ * the trunk they join; a tee's branch leg carries its own `shape2`
+ * profile (width2 × height2, or round at `diameter2`). The profile's
+ * height rides local +Y — for the horizontal-plane orientations trunks
+ * are drawn in, that's world-vertical.
+ */
+export declare function buildDuctFittingGeometry(node: DuctFittingNode, ctx?: GeometryContext, shading?: RenderShading, textures?: boolean, colorPreset?: ColorPreset, sceneTheme?: string): Group;
+//# sourceMappingURL=geometry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/duct-fitting/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AACvD,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AACpE,OAAO,EAML,KAAK,EAMN,MAAM,OAAO,CAAA;AAUd,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AA6K/C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,eAAe,EACrB,GAAG,CAAC,EAAE,eAAe,EACrB,OAAO,GAAE,aAA0B,EACnC,QAAQ,UAAO,EACf,WAAW,GAAE,WAAoB,EACjC,UAAU,CAAC,EAAE,MAAM,GAClB,KAAK,CAoQP"}