@pascal-app/nodes 0.1.1

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

@@ -0,0 +1,302 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { DuctFittingNode, emitter, sceneRegistry, useScene, } from '@pascal-app/core';
+import { consumePlacementDragRelease, DragBoundingBox, EDITOR_LAYER, isAlignmentGuideActive, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, stripPlacementMetadataFlags, triggerSFX, useAlignmentGuides, useEditor, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useEffect, useMemo, useState } from 'react';
+import { Box3, Euler, MeshBasicMaterial, Vector3 } from 'three';
+import { autoOffsetInvalidationUpdates } from '../shared/auto-offset-tag';
+import { collectGhostAlignmentCandidates, resolveGhostAlignment, } from '../shared/ghost-alignment';
+import { startRunMoveConnectivity } from '../shared/run-move-connectivity';
+import { buildDuctFittingGeometry } from './geometry';
+const GHOST_COLOR = '#818cf8';
+const GHOST_OPACITY = 0.5;
+/** Snap a coordinate to the editor's live grid step. */
+function snapToGridStep(value) {
+    const step = useEditor.getState().gridSnapStep;
+    if (step <= 0)
+        return value;
+    return Math.round(value / step) * step;
+}
+/** World-space size + centre offset of `box` after the fitting's euler
+ *  rotation — the footprint box that wraps the oriented geometry. */
+function rotatedBounds(box, rotation) {
+    const euler = new Euler(rotation[0], rotation[1], rotation[2]);
+    const min = box.min;
+    const max = box.max;
+    const corners = [
+        [min.x, min.y, min.z],
+        [max.x, min.y, min.z],
+        [min.x, max.y, min.z],
+        [min.x, min.y, max.z],
+        [max.x, max.y, min.z],
+        [max.x, min.y, max.z],
+        [min.x, max.y, max.z],
+        [max.x, max.y, max.z],
+    ];
+    const lo = [Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY];
+    const hi = [Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY, Number.NEGATIVE_INFINITY];
+    const v = new Vector3();
+    for (const c of corners) {
+        v.set(c[0], c[1], c[2]).applyEuler(euler);
+        lo[0] = Math.min(lo[0], v.x);
+        lo[1] = Math.min(lo[1], v.y);
+        lo[2] = Math.min(lo[2], v.z);
+        hi[0] = Math.max(hi[0], v.x);
+        hi[1] = Math.max(hi[1], v.y);
+        hi[2] = Math.max(hi[2], v.z);
+    }
+    return {
+        size: [hi[0] - lo[0], hi[1] - lo[1], hi[2] - lo[2]],
+        offset: [(lo[0] + hi[0]) / 2, (lo[1] + hi[1]) / 2, (lo[2] + hi[2]) / 2],
+    };
+}
+/**
+ * Ghost-preview duplicate / move tool for duct fittings (elbow / tee /
+ * reducer / transition).
+ *
+ * **Duplicate** (`metadata.isNew`): pure drag-to-place — NOTHING is
+ * inserted into the scene until the commit click. A translucent copy of the
+ * fitting (built from its real geometry, at its own `rotation`, so an elbow
+ * / riser stays properly aligned) rides the cursor inside a footprint
+ * bounding box — the same affordance other items get — and Figma-style
+ * alignment guides snap the box edges to nearby geometry. The commit click
+ * calls `createNode`; Esc discards.
+ *
+ * **Move** (existing fitting): the real node is hidden while the ghost + box
+ * track the cursor; commit writes the new `position` and reveals it.
+ *
+ * Wired via `def.affordanceTools.move`.
+ */
+export const MoveDuctFittingTool = ({ node }) => {
+    const fitting = node;
+    const originalPosition = (fitting.position ?? [0, 0, 0]);
+    const rotation = (fitting.rotation ?? [0, 0, 0]);
+    const isNew = typeof node.metadata === 'object' &&
+        node.metadata !== null &&
+        !Array.isArray(node.metadata) &&
+        node.metadata.isNew === true;
+    const [cursorPos, setCursorPos] = useState(originalPosition);
+    // Translucent stand-in built from the fitting's real geometry. Rotation is
+    // a geometry input (it decides the elbow's profile roles), so the ghost
+    // matches what lands. Rebuilt only if the source changes.
+    const ghost = useMemo(() => {
+        const group = buildDuctFittingGeometry(fitting);
+        group.traverse((obj) => {
+            const mesh = obj;
+            if (mesh.isMesh) {
+                mesh.material = new MeshBasicMaterial({
+                    color: GHOST_COLOR,
+                    transparent: true,
+                    opacity: GHOST_OPACITY,
+                    depthTest: false,
+                });
+                mesh.renderOrder = 999;
+            }
+            obj.layers.set(EDITOR_LAYER);
+        });
+        return group;
+    }, [fitting]);
+    // Footprint box that wraps the oriented geometry (size + centre offset),
+    // measured once from the ghost.
+    const bounds = useMemo(() => {
+        const box = new Box3().setFromObject(ghost);
+        if (box.isEmpty())
+            return { size: [0.3, 0.3, 0.3], offset: [0, 0, 0] };
+        return rotatedBounds(box, rotation);
+    }, [ghost, rotation]);
+    useEffect(() => {
+        return () => {
+            ghost.traverse((obj) => {
+                const mesh = obj;
+                if (mesh.isMesh) {
+                    mesh.geometry?.dispose?.();
+                    const mat = mesh.material;
+                    if (Array.isArray(mat))
+                        for (const m of mat)
+                            m.dispose?.();
+                    else
+                        mat?.dispose?.();
+                }
+            });
+        };
+    }, [ghost]);
+    useEffect(() => {
+        const nodeId = node.id;
+        const [hx, , hz] = [bounds.size[0] / 2, 0, bounds.size[2] / 2];
+        const [ox, , oz] = bounds.offset;
+        useScene.temporal.getState().pause();
+        let committed = false;
+        let hasMoved = false;
+        const activatedAt = Date.now();
+        const candidates = collectGhostAlignmentCandidates(useScene.getState().nodes, nodeId, useViewer.getState().selection.levelId ?? node.parentId);
+        // Moving an existing fitting: hide its 3D MESH imperatively (NOT the
+        // store `visible` flag — the 2D floor plan skips `visible:false` nodes,
+        // so a store hide makes it vanish in 2D / split view). The ghost stands
+        // in until commit; the real mesh is restored on cancel / unmount.
+        const existedAtStart = !isNew && !!useScene.getState().nodes[nodeId];
+        const setMeshHidden = (hidden) => {
+            const obj = sceneRegistry.nodes.get(nodeId);
+            if (obj)
+                obj.visible = !hidden;
+        };
+        if (existedAtStart)
+            setMeshHidden(true);
+        // Carry connected ducts as the fitting slides: the part of the move along
+        // a run's axis stretches it, the part across translates the whole run (and
+        // propagates to its far joint). Snapshot once at drag start; only existing
+        // fittings are mated to anything.
+        const connectivity = existedAtStart
+            ? startRunMoveConnectivity(node)
+            : null;
+        let lastPos = originalPosition;
+        // Tracks whether the last frame held Alt: the fitting is detached from its
+        // connected ducts for the drag, so they stay put (no follow) and the
+        // commit omits their updates. Mirrors the duct endpoint's Alt-detach.
+        let lastDetached = false;
+        const onMove = (event) => {
+            // Alt = detach: drop the connected-duct follow so the fitting moves on
+            // its own, leaving every mated run where it sits.
+            const detached = event.nativeEvent?.altKey === true;
+            const snap = isGridSnapActive() ? snapToGridStep : (v) => v;
+            let x = snap(event.localPosition[0]);
+            let z = snap(event.localPosition[2]);
+            // Magnetic alignment: snap the footprint box edges onto nearby geometry
+            // and publish guides. Grid follows the snapping mode; lines follow
+            // magnetic alignment — the two are independent.
+            if (isAlignmentGuideActive()) {
+                const proposed = {
+                    minX: x + ox - hx,
+                    maxX: x + ox + hx,
+                    minZ: z + oz - hz,
+                    maxZ: z + oz + hz,
+                };
+                const { dx, dz, guides } = resolveGhostAlignment(nodeId, proposed, candidates);
+                if (isMagneticSnapActive()) {
+                    x += dx;
+                    z += dz;
+                }
+                useAlignmentGuides.getState().set(guides);
+            }
+            else {
+                useAlignmentGuides.getState().clear();
+            }
+            const next = [x, lastPos[1], z];
+            if ((isGridSnapActive() || isMagneticSnapActive()) &&
+                (next[0] !== lastPos[0] || next[2] !== lastPos[2]))
+                triggerSFX('sfx:grid-snap');
+            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)
+                return;
+            // The 150ms debounce only guards click-to-place against the arming click
+            // double-firing; a press-drag release is a distinct pointerup gesture, so
+            // it skips the guard (a quick drag-flick still commits).
+            if (!fromDragRelease && Date.now() - activatedAt < 150) {
+                event.nativeEvent?.stopPropagation?.();
+                return;
+            }
+            if (!hasMoved) {
+                event.nativeEvent?.stopPropagation?.();
+                return;
+            }
+            committed = true;
+            useScene.temporal.getState().resume();
+            let selectId = nodeId;
+            if (isNew && !useScene.getState().nodes[nodeId]) {
+                const created = DuctFittingNode.parse({
+                    ...node,
+                    position: lastPos,
+                    metadata: stripPlacementMetadataFlags(node.metadata),
+                    visible: true,
+                });
+                useScene.getState().createNode(created, node.parentId);
+                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 } },
+                    ...followUpdates,
+                    ...autoOffsetInvalidationUpdates(scene.nodes, nodeId),
+                ]);
+                scene.markDirty(nodeId);
+            }
+            useScene.temporal.getState().pause();
+            // Followers are committed to the store — drop their live overrides so
+            // renderers read the canonical path/position.
+            connectivity?.clear();
+            setMeshHidden(false);
+            useAlignmentGuides.getState().clear();
+            triggerSFX('sfx:item-place');
+            useViewer.getState().setSelection({ selectedIds: [selectId] });
+            useEditor.getState().setMovingNodeOrigin('3d');
+            useEditor.getState().setMovingNode(null);
+            event.nativeEvent?.stopPropagation?.();
+        };
+        const onCancel = () => {
+            connectivity?.clear();
+            if (existedAtStart) {
+                setMeshHidden(false);
+                useViewer.getState().setSelection({ selectedIds: [nodeId] });
+            }
+            useAlignmentGuides.getState().clear();
+            useScene.temporal.getState().resume();
+            markToolCancelConsumed();
+            useEditor.getState().setMovingNodeOrigin('3d');
+            useEditor.getState().setMovingNode(null);
+        };
+        // Press-drag-release: when the move was engaged by the drag gesture (the
+        // selection rig's move cross or a future floating drag), `placementDragMode`
+        // is set, so commit on pointer-up at the last previewed position instead of
+        // waiting for a second click — same contract as every other move tool.
+        const onPlacementDragPointerUp = (event) => {
+            if (!consumePlacementDragRelease(event))
+                return;
+            // A press-release that never moved isn't a placement — back out cleanly
+            // (drop the ghost, re-select the fitting) instead of leaving the tool
+            // armed waiting for a click.
+            if (!hasMoved) {
+                onCancel();
+                return;
+            }
+            commit({
+                nativeEvent: event,
+                stopPropagation: () => event.stopPropagation(),
+            }, true);
+        };
+        emitter.on('grid:move', onMove);
+        emitter.on('grid:click', commit);
+        emitter.on('tool:cancel', onCancel);
+        window.addEventListener('pointerup', onPlacementDragPointerUp);
+        return () => {
+            emitter.off('grid:move', onMove);
+            emitter.off('grid:click', commit);
+            emitter.off('tool:cancel', onCancel);
+            window.removeEventListener('pointerup', onPlacementDragPointerUp);
+            connectivity?.clear();
+            useAlignmentGuides.getState().clear();
+            if (existedAtStart)
+                setMeshHidden(false);
+            useScene.temporal.getState().resume();
+        };
+    }, [bounds, isNew, node, originalPosition]);
+    return (_jsxs("group", { children: [_jsx("primitive", { object: ghost, position: cursorPos, rotation: rotation }), _jsx(DragBoundingBox, { centerY: bounds.offset[1], nodeId: node.id, position: [cursorPos[0] + bounds.offset[0], cursorPos[1], cursorPos[2] + bounds.offset[2]], size: bounds.size })] }));
+};
+export default MoveDuctFittingTool;

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

@@ -0,0 +1,4 @@
+import { type ParametricDescriptor } from '@pascal-app/core';
+import type { DuctFittingNode } from './schema';
+export declare const ductFittingParametrics: ParametricDescriptor<DuctFittingNode>;
+//# sourceMappingURL=parametrics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/duct-fitting/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,oBAAoB,EAE1B,MAAM,kBAAkB,CAAA;AASzB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAkF/C,eAAO,MAAM,sBAAsB,EAAE,oBAAoB,CAAC,eAAe,CAoQxE,CAAA"}

package/dist/duct-fitting/parametrics.js

@@ -0,0 +1,328 @@
+import { useScene, } from '@pascal-app/core';
+import { Vector3 } from 'three';
+import { autoOffsetInvalidationUpdates, readAutoOffsetTag, withAutoOffsetTag, } from '../shared/auto-offset-tag';
+import { DuctFittingSizeSwapEditor } from './inspector-editors';
+import { getDuctFittingPorts } from './ports';
+/** Schema bounds for `diameter` / `diameter2`. */
+const clampDiameter = (d) => Math.min(48, Math.max(2, d));
+const equivalentDiameterIn = (widthIn, heightIn) => 2 * Math.sqrt((widthIn * heightIn) / Math.PI);
+const ovalEquivalentDiameterIn = (widthIn, heightIn) => {
+    const minor = Math.min(widthIn, heightIn);
+    const major = Math.max(widthIn, heightIn);
+    const area = (major - minor) * minor + Math.PI * (minor / 2) ** 2;
+    return 2 * Math.sqrt(area / Math.PI);
+};
+const ductPortDiameterIn = (node) => {
+    if (node.shape === 'rect' && node.width && node.height) {
+        return equivalentDiameterIn(node.width, node.height);
+    }
+    if (node.shape === 'oval' && node.width && node.height) {
+        return ovalEquivalentDiameterIn(node.width, node.height);
+    }
+    return node.diameter;
+};
+/** A duct endpoint sitting this close to a collar counts as mated. */
+const MATE_TOL_M = 0.05;
+/**
+ * Ducts whose endpoint sits ON one of the fitting's collars, keyed by
+ * port id. Auto-minted joints place duct ends exactly on the collar, so
+ * a tight distance check is enough — no connectivity graph yet.
+ */
+function matedDucts(fitting, nodes = useScene.getState().nodes) {
+    const mates = new Map();
+    const ports = getDuctFittingPorts(fitting);
+    for (const node of Object.values(nodes)) {
+        if (node.type !== 'duct-segment')
+            continue;
+        const duct = node;
+        for (const endIndex of [0, duct.path.length - 1]) {
+            const p = duct.path[endIndex];
+            if (!p)
+                continue;
+            for (const port of ports) {
+                if (mates.has(port.id))
+                    continue;
+                const dx = p[0] - port.position[0];
+                const dy = p[1] - port.position[1];
+                const dz = p[2] - port.position[2];
+                if (dx * dx + dy * dy + dz * dz <= MATE_TOL_M * MATE_TOL_M) {
+                    mates.set(port.id, { duct, endIndex });
+                }
+            }
+        }
+    }
+    return mates;
+}
+function refreshedAutoOffsetMetadata(duct, endIndex, target) {
+    const tag = readAutoOffsetTag(duct);
+    if (!tag)
+        return null;
+    let changed = false;
+    const base = tag.base.map((patch) => {
+        if (patch.id !== duct.id || !Array.isArray(patch.data.path))
+            return patch;
+        const path = patch.data.path.map((p) => (Array.isArray(p) ? [...p] : p));
+        if (!Array.isArray(path[endIndex]))
+            return patch;
+        path[endIndex] = [...target];
+        changed = true;
+        return { ...patch, data: { ...patch.data, path } };
+    });
+    return changed ? withAutoOffsetTag(duct.metadata, { ...tag, base }) : null;
+}
+export const ductFittingParametrics = {
+    // Switching the run legs round↔rect flips the whole fitting and sizes
+    // the new profile off the ducts actually mated to its collars, so the
+    // fitting lands flush instead of at schema defaults. The tee branch
+    // follows its own mated duct (or the run shape when nothing is mated);
+    // `shape2` stays editable afterwards for mixed taps. Rect profiles
+    // also write their area-equivalent round size back into `diameter` /
+    // `diameter2`, which drive leg lengths + advertised ports — without
+    // this the legs keep the stale round size.
+    derive: (next, patch) => {
+        const out = {};
+        if ('shape' in patch && next.fittingType !== 'reducer') {
+            // `next` still carries the pre-edit diameters, so its ports sit
+            // where the mated ducts end — size off the actual neighbours.
+            const mates = matedDucts(next);
+            const run = (mates.get('inlet') ?? mates.get('outlet'))?.duct;
+            if (next.shape !== 'round' && run?.shape === next.shape) {
+                out.width = run.width;
+                out.height = run.height;
+            }
+            else if (next.shape === 'round' && run && run.shape !== 'rect') {
+                // Oval runs present their area-equivalent round size.
+                out.diameter = clampDiameter(ductPortDiameterIn(run));
+            }
+            if (next.fittingType === 'tee' || next.fittingType === 'cross') {
+                // A cross's two branches share one profile — size off whichever
+                // branch leg has a duct mated (both halves are the same run).
+                const branchDuct = (mates.get('branch') ?? mates.get('branch2'))?.duct;
+                out.shape2 = branchDuct?.shape ?? next.shape;
+                if (branchDuct && branchDuct.shape !== 'round') {
+                    out.width2 = branchDuct.width;
+                    out.height2 = branchDuct.height;
+                }
+                else if (branchDuct) {
+                    out.diameter2 = clampDiameter(ductPortDiameterIn(branchDuct));
+                }
+            }
+        }
+        // Non-round legs write their area-equivalent round size back into the
+        // diameters (leg lengths + advertised ports). A transition's inlet is
+        // always the rect end regardless of `shape`.
+        const runShape = next.fittingType === 'transition' ? 'rect' : next.shape;
+        if (runShape !== 'round' && next.fittingType !== 'reducer') {
+            const equivalent = runShape === 'oval' ? ovalEquivalentDiameterIn : equivalentDiameterIn;
+            out.diameter = clampDiameter(equivalent(out.width ?? next.width, out.height ?? next.height));
+        }
+        const shape2 = out.shape2 ?? next.shape2;
+        if ((next.fittingType === 'tee' || next.fittingType === 'cross') && shape2 !== 'round') {
+            const equivalent2 = shape2 === 'oval' ? ovalEquivalentDiameterIn : equivalentDiameterIn;
+            out.diameter2 = clampDiameter(equivalent2(out.width2 ?? next.width2, out.height2 ?? next.height2));
+        }
+        return out;
+    },
+    // Resizing a fitting moves its collars (leg lengths follow the
+    // diameters) — re-trim each mated duct's endpoint onto the collar's
+    // new position so metal keeps meeting metal instead of overlapping
+    // one neighbour and gapping off another.
+    reconcile: (prev, next) => {
+        const updates = [];
+        const newPorts = new Map(getDuctFittingPorts(next).map((p) => [p.id, p]));
+        const mates = matedDucts(prev);
+        for (const [portId, mate] of mates) {
+            const target = newPorts.get(portId);
+            if (!target)
+                continue;
+            const end = mate.duct.path[mate.endIndex];
+            if (!end)
+                continue;
+            const data = {};
+            const dx = end[0] - target.position[0];
+            const dy = end[1] - target.position[1];
+            const dz = end[2] - target.position[2];
+            if (dx * dx + dy * dy + dz * dz >= 1e-12) {
+                const path = mate.duct.path.map((p) => [...p]);
+                path[mate.endIndex] = [...target.position];
+                data.path = path;
+            }
+            const metadata = refreshedAutoOffsetMetadata(mate.duct, mate.endIndex, target.position);
+            if (metadata)
+                data.metadata = metadata;
+            if (Object.keys(data).length > 0)
+                updates.push({ id: mate.duct.id, data });
+        }
+        return [...updates, ...autoOffsetInvalidationUpdates(useScene.getState().nodes, next.id)];
+    },
+    // Deleting an auto-inserted elbow restores the corner it replaced: both
+    // mated runs were pulled back one leg onto its collars, with the
+    // junction (the fitting's position) sitting exactly on the corner they
+    // originally met at. Re-extend each mated endpoint back to that junction
+    // so the L-shape returns to its pre-fitting length. Scoped to elbows —
+    // tees / crosses split a trunk into two separate nodes, which can't be
+    // re-joined by moving an endpoint.
+    onDelete: (fitting, nodes) => {
+        const invalidations = autoOffsetInvalidationUpdates(nodes, fitting.id);
+        if (fitting.fittingType !== 'elbow')
+            return invalidations;
+        const junction = new Vector3(...fitting.position);
+        const updates = [];
+        for (const mate of matedDucts(fitting, nodes).values()) {
+            const end = mate.duct.path[mate.endIndex];
+            if (!end)
+                continue;
+            const dx = end[0] - junction.x;
+            const dy = end[1] - junction.y;
+            const dz = end[2] - junction.z;
+            if (dx * dx + dy * dy + dz * dz < 1e-12)
+                continue;
+            const path = mate.duct.path.map((p) => [...p]);
+            path[mate.endIndex] = [junction.x, junction.y, junction.z];
+            const data = { path };
+            const metadata = refreshedAutoOffsetMetadata(mate.duct, mate.endIndex, [
+                junction.x,
+                junction.y,
+                junction.z,
+            ]);
+            if (metadata)
+                data.metadata = metadata;
+            updates.push({ id: mate.duct.id, data });
+        }
+        return [...updates, ...invalidations];
+    },
+    groups: [
+        {
+            label: 'Fitting',
+            fields: [
+                {
+                    key: 'fittingType',
+                    kind: 'enum',
+                    options: ['elbow', 'tee', 'cross', 'reducer', 'transition'],
+                    display: 'segmented',
+                },
+                {
+                    key: 'angle',
+                    kind: 'number',
+                    unit: '°',
+                    min: 0,
+                    max: 90,
+                    step: 15,
+                    visibleIf: (n) => n.fittingType === 'elbow',
+                },
+                {
+                    key: 'branchAngle',
+                    kind: 'number',
+                    unit: '°',
+                    min: 45,
+                    max: 135,
+                    step: 15,
+                    visibleIf: (n) => n.fittingType === 'tee',
+                },
+                {
+                    key: 'system',
+                    kind: 'enum',
+                    options: ['supply', 'return'],
+                    display: 'segmented',
+                },
+            ],
+        },
+        {
+            label: 'Connections',
+            fields: [
+                {
+                    key: 'shape',
+                    kind: 'enum',
+                    options: ['round', 'rect', 'oval'],
+                    display: 'segmented',
+                    // Reducers are always round; a transition's ends are fixed
+                    // (rect inlet, round outlet) so there's nothing to pick.
+                    visibleIf: (n) => n.fittingType !== 'reducer' && n.fittingType !== 'transition',
+                },
+                {
+                    key: 'diameter',
+                    kind: 'number',
+                    unit: 'in',
+                    min: 4,
+                    max: 24,
+                    step: 1,
+                    // Hidden when the run legs are rect / oval (transition's inlet
+                    // always is) — `diameter` is then derived as the area equivalent.
+                    visibleIf: (n) => n.fittingType === 'reducer' || (n.fittingType !== 'transition' && n.shape === 'round'),
+                },
+                {
+                    key: 'width',
+                    kind: 'number',
+                    unit: 'in',
+                    min: 4,
+                    max: 60,
+                    step: 1,
+                    visibleIf: (n) => n.fittingType === 'transition' || (n.shape !== 'round' && n.fittingType !== 'reducer'),
+                },
+                {
+                    key: 'height',
+                    kind: 'number',
+                    unit: 'in',
+                    min: 3,
+                    max: 40,
+                    step: 1,
+                    visibleIf: (n) => n.fittingType === 'transition' || (n.shape !== 'round' && n.fittingType !== 'reducer'),
+                },
+                {
+                    key: 'swapWidthHeight',
+                    kind: 'custom',
+                    component: DuctFittingSizeSwapEditor,
+                    visibleIf: (n) => n.fittingType === 'transition' || (n.shape !== 'round' && n.fittingType !== 'reducer'),
+                },
+                {
+                    key: 'shape2',
+                    kind: 'enum',
+                    options: ['round', 'rect', 'oval'],
+                    display: 'segmented',
+                    visibleIf: (n) => n.fittingType === 'tee' || n.fittingType === 'cross',
+                },
+                {
+                    key: 'diameter2',
+                    kind: 'number',
+                    unit: 'in',
+                    min: 4,
+                    max: 24,
+                    step: 1,
+                    visibleIf: (n) => n.fittingType !== 'elbow' &&
+                        (n.fittingType !== 'tee' || n.shape2 === 'round') &&
+                        (n.fittingType !== 'cross' || n.shape2 === 'round'),
+                },
+                {
+                    key: 'width2',
+                    kind: 'number',
+                    unit: 'in',
+                    min: 4,
+                    max: 60,
+                    step: 1,
+                    visibleIf: (n) => (n.fittingType === 'tee' || n.fittingType === 'cross') && n.shape2 !== 'round',
+                },
+                {
+                    key: 'height2',
+                    kind: 'number',
+                    unit: 'in',
+                    min: 3,
+                    max: 40,
+                    step: 1,
+                    visibleIf: (n) => (n.fittingType === 'tee' || n.fittingType === 'cross') && n.shape2 !== 'round',
+                },
+                {
+                    key: 'ductMaterial',
+                    kind: 'enum',
+                    options: ['sheet-metal', 'flex', 'duct-board'],
+                },
+            ],
+        },
+        {
+            label: 'Placement',
+            fields: [
+                { key: 'position', kind: 'vec3' },
+                { key: 'rotation', kind: 'vec3' },
+            ],
+        },
+    ],
+};

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

@@ -0,0 +1,32 @@
+import type { NodePort } from '@pascal-app/core';
+import { Vector3 } from 'three';
+import type { DuctFittingNode } from './schema';
+/**
+ * Collar stub length in meters — how far each port sticks out from the
+ * fitting's junction center. Scales with the duct so big trunks get
+ * proportionally longer collars, with a floor so 4" fittings stay
+ * grabbable.
+ */
+export declare function fittingLegLength(diameterInches: number): number;
+type LocalPort = {
+    id: string;
+    position: Vector3;
+    direction: Vector3;
+    diameter: number;
+};
+/**
+ * Ports in the fitting's LOCAL frame (origin at the junction center,
+ * before `position`/`rotation`). Shared by `def.ports` (which transforms
+ * them to level-local) and the geometry builder (which draws a stub per
+ * port).
+ *
+ * Conventions documented on the schema: elbow inlet -X / outlet turned
+ * `angle`° in XZ; tee run along X with the branch at `branchAngle`° off
+ * the +X outlet axis (90° → +Z square tee, 45° → downstream lateral,
+ * 135° → upstream lateral); reducer -X → +X.
+ */
+export declare function localFittingPorts(node: DuctFittingNode): LocalPort[];
+/** `def.ports` — local ports transformed into level-local space. */
+export declare function getDuctFittingPorts(node: DuctFittingNode): NodePort[];
+export {};
+//# sourceMappingURL=ports.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ports.d.ts","sourceRoot":"","sources":["../../src/duct-fitting/ports.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAChD,OAAO,EAAS,OAAO,EAAE,MAAM,OAAO,CAAA;AACtC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAI/C;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,CAG/D;AAED,KAAK,SAAS,GAAG;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAA;AAExF;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,eAAe,GAAG,SAAS,EAAE,CAoGpE;AAED,oEAAoE;AACpE,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,eAAe,GAAG,QAAQ,EAAE,CAcrE"}