@pascal-app/nodes 1.0.7 → 1.1.0

package/dist/duct-segment/tool.js

@@ -1,9 +1,9 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { DuctSegmentNode } from '@pascal-app/core';
+import { DuctSegmentNode, nodeRegistry } from '@pascal-app/core';
 import { EDITOR_LAYER, triggerSFX, useEditor, usePathDraftPreview, useRegistryToolContext, } from '@pascal-app/editor';
 import { collectScenePorts, createRunWallAttachment, DistributionRunCursor, runDistanceSquared as dist2, findNearestRunBody3D, findRunBodyCrossingSurface, stepNominalRunSize, useDistributionRunTool, } from '@pascal-app/editor/distribution';
-import { useEffect, useMemo, useRef, useState } from 'react';
+import { useEffect, useMemo, useRef } from 'react';
 import { Euler, Vector3 } from 'three';
 import { getDuctFittingPorts } from '../duct-fitting/ports.js';
 import { planCrossAtRunBody, planElbowAtPort, planElbowRealign, planTeeAtRunBody, } from '../shared/auto-fitting.js';
@@ -16,9 +16,10 @@ import { DuctSegmentGhost, FittingGhost } from '../shared/mep-ghost.js';
 import { DUCT_PORT_SYSTEMS, runSectionHalfSizeM } from '../shared/port-systems.js';
 import { RunHangerPreview } from '../shared/run-hanger-controls.js';
 import { useRunHangerMode } from '../shared/run-hanger-mode.js';
+import { clearRunContinuation, updateRunDefaults } from '../shared/run-tool-options.js';
 import { currentDuctContinuationSeed, ductEndpointPort } from './continuation.js';
 import { ductSegmentDefinition } from './definition.js';
-import { rectSectionAxes, rollToContinueAcrossElbow } from './geometry.js';
+import { rectSectionAxes, rollToContinueAcrossElbow } from './profile.js';
 /**
  * Continuous placement tool for duct segments.
  *
@@ -245,6 +246,30 @@ export function planDuctDraw(start, end, startPort, startBody, endPort, endBody,
         updates: [],
         delete: [],
     });
+    const system = toolDefaults.system ?? startPort?.system ?? endPort?.system ?? 'supply';
+    for (const [port, away] of [
+        [startPort, dir],
+        [endPort, [-dir[0], -dir[1], -dir[2]]],
+    ]) {
+        if (!port)
+            continue;
+        const owner = nodes[port.nodeId];
+        if (!owner || owner.type === 'duct-segment' || owner.type === 'duct-fitting')
+            continue;
+        const occupied = Object.values(nodes).some((node) => node.id !== owner.id &&
+            node.parentId === owner.parentId &&
+            (nodeRegistry.get(node.type)?.ports?.(node) ?? []).some((other) => other.system === port.system &&
+                dist2([...other.position], [...port.position]) < 0.005 ** 2));
+        const message = port.system !== system
+            ? 'Use the same supply or return system as the collar.'
+            : occupied
+                ? 'This collar is already connected.'
+                : new Vector3(...away).dot(new Vector3(...port.direction).normalize()) < 0.9999
+                    ? 'Draw the first section straight out of the collar, then add a bend from the new duct endpoint.'
+                    : null;
+        if (message)
+            return { ...invalidPlan(), validationMessage: message };
+    }
     if (startPlan?.hasClearance === false || endPlan?.hasClearance === false)
         return invalidPlan();
     const startRealign = startPlan ? null : realignPlanFor(startPort, dir, nodes);
@@ -306,7 +331,7 @@ export function planDuctDraw(start, end, startPort, startBody, endPort, endBody,
     if (!endTee && endTeePlan)
         ductEnd = endRealign?.collarPoint ?? end;
     const realigns = [startRealign, endRealign].filter((p) => p !== null);
-    const crossHit = surface
+    const crossHit = surface && toolDefaults.crossingMode !== 'cross'
         ? findRunBodyCrossingSurface(start, end, BODY_SNAP_RADIUS_M, surface, {
             kinds: ['duct-segment'],
         })
@@ -336,6 +361,7 @@ export function planDuctDraw(start, end, startPort, startBody, endPort, endBody,
     const makeDuct = (from, to) => DuctSegmentNode.parse({
         ...defaults,
         ...toolDefaults,
+        system,
         autoHangers,
         hangerStyle,
         name: profile.shape === 'rect' ? 'Trunk' : 'Duct run',
@@ -406,27 +432,47 @@ const DuctSegmentTool = () => {
     const autoHangersRef = useRef(autoHangers);
     autoHangersRef.current = autoHangers;
     const pendingPromotionRef = useRef(continuationSeed?.promotedFitting ?? null);
-    const [profile, setProfile] = useState(() => {
-        const defaults = ductSegmentDefinition.defaults();
-        const seeded = useEditor.getState().toolDefaults['duct-segment'];
-        return {
-            shape: continuationSeed?.duct.shape ?? seeded?.shape ?? defaults.shape,
-            diameter: continuationSeed?.duct.diameter ?? seeded?.diameter ?? defaults.diameter,
-            width: continuationSeed?.duct.width ?? seeded?.width ?? defaults.width,
-            height: continuationSeed?.duct.height ?? seeded?.height ?? defaults.height,
-        };
-    });
+    const initialProfile = useRef(null);
+    if (!initialProfile.current)
+        initialProfile.current = (() => {
+            const defaults = ductSegmentDefinition.defaults();
+            const seeded = useEditor.getState().toolDefaults['duct-segment'];
+            return {
+                shape: continuationSeed?.duct.shape ?? seeded?.shape ?? defaults.shape,
+                diameter: continuationSeed?.duct.diameter ?? seeded?.diameter ?? defaults.diameter,
+                width: continuationSeed?.duct.width ?? seeded?.width ?? defaults.width,
+                height: continuationSeed?.duct.height ?? seeded?.height ?? defaults.height,
+            };
+        })();
+    const profile = useMemo(() => ({
+        shape: toolDefaults?.shape ?? initialProfile.current.shape,
+        diameter: toolDefaults?.diameter ?? initialProfile.current.diameter,
+        width: toolDefaults?.width ?? initialProfile.current.width,
+        height: toolDefaults?.height ?? initialProfile.current.height,
+    }), [toolDefaults?.shape, toolDefaults?.diameter, toolDefaults?.width, toolDefaults?.height]);
+    const setProfile = (value) => updateRunDefaults('duct-segment', typeof value === 'function' ? value(profile) : value);
     const profileRef = useRef(profile);
     profileRef.current = profile;
     useEffect(() => {
         const mode = useRunHangerMode.getState();
         mode.setEnabled('duct-segment', initialAutoHangersRef.current);
-        return () => mode.setEnabled('duct-segment', false);
+        return () => {
+            updateRunDefaults('duct-segment', {
+                autoHangers: useRunHangerMode.getState().enabled['duct-segment'],
+            });
+            mode.setEnabled('duct-segment', false);
+        };
     }, []);
     const run = useDistributionRunTool({
         active: !!activeLevelId,
         levelId: activeLevelId,
         toolName: 'duct-segment',
+        routingMode: hangerDefaults?.routingMode === 'horizontal' || hangerDefaults?.routingMode === 'vertical'
+            ? hangerDefaults.routingMode
+            : 'surface',
+        elevation: typeof hangerDefaults?.elevation === 'number' ? hangerDefaults.elevation : 0,
+        targetElevation: typeof hangerDefaults?.targetElevation === 'number' ? hangerDefaults.targetElevation : 3,
+        connectCrossings: hangerDefaults?.crossingMode !== 'cross',
         initialStart: continuationSeed
             ? [...(continuationSeed.port?.position ?? continuationSeed.body?.point ?? [0, 0, 0])]
             : null,
@@ -440,6 +486,15 @@ const DuctSegmentTool = () => {
         }),
         surfaceClearance: (surface) => surface ? ductSurfaceClearanceM(profileRef.current, surface.kind === 'wall') : 0,
         minimumSegmentLength: 0.08,
+        resolveFreeEnd: (start, end, connection) => {
+            const port = connection.port;
+            const owner = port ? sceneApi.get(port.nodeId) : null;
+            if (!port || !owner || owner.type === 'duct-segment' || owner.type === 'duct-fitting')
+                return end;
+            const axis = new Vector3(...port.direction).normalize();
+            const distance = Math.max(0, new Vector3(...end).sub(new Vector3(...start)).dot(axis));
+            return new Vector3(...start).addScaledVector(axis, distance).toArray();
+        },
         inheritFromConnection: ({ port }) => {
             if (!port)
                 return;
@@ -493,6 +548,14 @@ const DuctSegmentTool = () => {
                 delete: plan.delete,
             });
             pendingPromotionRef.current = null;
+            const startOwner = startConnection.port && !promotedFitting ? sceneApi.get(startConnection.port.nodeId) : null;
+            // A riser out of a fixed collar reaches the target; staying vertical would aim the
+            // next section at the riser's own top.
+            if (hangerDefaults?.routingMode === 'vertical' &&
+                startOwner &&
+                startOwner.type !== 'duct-segment' &&
+                startOwner.type !== 'duct-fitting')
+                updateRunDefaults('duct-segment', { routingMode: 'horizontal' });
             const nextDuct = plan.ducts.at(-1);
             const nextStart = nextDuct ? nextDuct.path[nextDuct.path.length - 1] : end;
             const nextPort = nextDuct ? ductEndpointPort(nextDuct, 'end') : endConnection.port;
@@ -529,15 +592,8 @@ const DuctSegmentTool = () => {
         },
     });
     useEffect(() => {
-        if (!toolDefaults)
-            return;
-        setProfile((current) => ({
-            shape: toolDefaults.shape ?? current.shape,
-            diameter: toolDefaults.diameter ?? current.diameter,
-            width: toolDefaults.width ?? current.width,
-            height: toolDefaults.height ?? current.height,
-        }));
-    }, [toolDefaults]);
+        updateRunDefaults('duct-segment', initialProfile.current);
+    }, []);
     const previewPlan = useMemo(() => {
         if (!(activeLevelId && run.start && run.cursor))
             return null;
@@ -555,6 +611,11 @@ const DuctSegmentTool = () => {
         run.surfaceTarget,
         sceneApi,
     ]);
+    // Profile changes alter the centreline clearance even with a stationary pointer.
+    // biome-ignore lint/correctness/useExhaustiveDependencies: the resolver reads the profile through a ref
+    useEffect(() => {
+        run.refreshCursor();
+    }, [profile, run.refreshCursor]);
     const ghostFittings = useMemo(() => previewPlan?.fittings ?? [], [previewPlan]);
     useEffect(() => {
         usePathDraftPreview
@@ -562,7 +623,7 @@ const DuctSegmentTool = () => {
             .setDraft('duct-segment', run.start ? [run.start] : [], run.cursor, { ...profile, autoHangers, hangerStyle }, ghostFittings);
     }, [autoHangers, hangerStyle, ghostFittings, profile, run.cursor, run.start]);
     useEffect(() => () => usePathDraftPreview.getState().clear('duct-segment'), []);
-    useEffect(() => () => useEditor.getState().setToolDefaults('duct-segment', null), []);
+    useEffect(() => () => clearRunContinuation('duct-segment'), []);
     if (!activeLevelId)
         return null;
     const extraParts = profile.shape === 'round'
@@ -571,9 +632,24 @@ const DuctSegmentTool = () => {
             { key: 'trunk-w', prefix: 'W', value: profile.width * 0.0254 },
             { key: 'trunk-h', prefix: 'H', value: profile.height * 0.0254 },
         ];
-    return (_jsxs(LevelOffsetGroup, { children: [_jsx(ConnectionFeedback, { point: run.cursor, target: run.endConnection.port, levelId: activeLevelId, profile: {
+    return (_jsxs(LevelOffsetGroup, { children: [_jsx(ConnectionFeedback, { detail: ghostFittings
+                    .filter((fitting) => ['reducer', 'transition'].includes(fitting.fittingType))
+                    .map((fitting) => {
+                    const size = (outlet) => {
+                        const shape = outlet
+                            ? (fitting.outletShape ?? fitting.shape2)
+                            : (fitting.inletShape ?? fitting.shape);
+                        return shape === 'round'
+                            ? `Ø${outlet ? fitting.diameter2 : fitting.diameter} in`
+                            : `${outlet ? fitting.width2 : fitting.width} × ${outlet ? fitting.height2 : fitting.height} in ${shape}`;
+                    };
+                    const ports = getDuctFittingPorts(fitting);
+                    const length = new Vector3(...ports[0].position).distanceTo(new Vector3(...ports[1].position));
+                    return `${size(false)} → ${size(true)} · ${length.toFixed(2)} m long`;
+                })
+                    .join('; ') || undefined, point: run.cursor, target: run.endConnection.port, screen: run.snapScreen ?? run.cursorScreen, error: run.cursorScreen ? (previewPlan?.validationMessage ?? run.validationMessage) : undefined, levelId: activeLevelId, profile: {
                     ...profile,
                     system: String(hangerDefaults?.system ?? ductSegmentDefinition.defaults().system),
-                } }), _jsx(DistributionRunCursor, { altActive: run.altActive, cursor: run.cursor, cursorRef: cursorRef, directionMode: run.directionMode, extraParts: extraParts, lengthInput: run.lengthInput, onLengthInputChange: run.onLengthInputChange, onDirectionSelect: run.onDirectionSelect, validationMessage: previewPlan?.validationMessage ?? run.validationMessage, snapTarget: run.snapTarget, snapScreen: run.snapScreen, start: run.start, startDirection: run.startConnection.port?.direction ?? null, unit: unit }), run.start && (_jsxs("mesh", { layers: EDITOR_LAYER, position: run.start, children: [_jsx("sphereGeometry", { args: [0.07, 16, 12] }), _jsx("meshBasicMaterial", { color: "#818cf8", depthTest: false })] })), previewPlan?.ducts.map((duct, index) => (_jsx(DuctSegmentGhost, { duct: duct }, index))), previewPlan?.ducts.map((duct, index) => (_jsx(RunHangerPreview, { run: duct, levelId: activeLevelId }, `hanger-${index}`))), ghostFittings.map((fitting) => (_jsx(FittingGhost, { fitting: fitting }, fitting.id)))] }));
+                } }), _jsx(DistributionRunCursor, { altActive: run.altActive, cursor: run.cursor, cursorRef: cursorRef, directionMode: run.directionMode, routingMode: run.routingMode, extraParts: extraParts, lengthInput: run.lengthInput, onLengthInputChange: run.onLengthInputChange, onDirectionSelect: run.onDirectionSelect, validationMessage: previewPlan?.validationMessage ?? run.validationMessage, snapTarget: run.snapTarget, snapScreen: run.snapScreen, start: run.start, startDirection: run.startConnection.port?.direction ?? null, unit: unit }), run.start && (_jsxs("mesh", { layers: EDITOR_LAYER, position: run.start, children: [_jsx("sphereGeometry", { args: [0.07, 16, 12] }), _jsx("meshBasicMaterial", { color: "#818cf8", depthTest: false })] })), previewPlan?.ducts.map((duct, index) => (_jsx(DuctSegmentGhost, { duct: duct }, index))), previewPlan?.ducts.map((duct, index) => (_jsx(RunHangerPreview, { run: duct, levelId: activeLevelId }, `hanger-${index}`))), ghostFittings.map((fitting) => (_jsx(FittingGhost, { fitting: fitting }, fitting.id)))] }));
 };
 export default DuctSegmentTool;

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

@@ -1,13 +1,69 @@
-import type { NodeDefinition } from '@pascal-app/core';
-import { DuctTerminalNode } from './schema.js';
-/**
- * Phase 3 of the HVAC node system — duct terminals: supply registers,
- * ceiling diffusers, return grilles. The end of the air loop. One typed
- * port at the collar (mount-aware direction) so duct runs end onto a
- * terminal like any other port.
- *
- * Composition: `def.geometry` only. Yaw-only rotation — the editor's
- * default R-rotate works on a selected terminal.
- */
-export declare const ductTerminalDefinition: NodeDefinition<typeof DuctTerminalNode>;
+export declare const ductTerminalDefinition: 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-terminal_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"duct-terminal">>;
+    position: import("zod").ZodDefault<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    rotation: import("zod").ZodDefault<import("zod").ZodNumber>;
+    supportSlabId: import("zod").ZodOptional<import("zod").ZodString>;
+    terminalType: import("zod").ZodDefault<import("zod").ZodEnum<{
+        diffuser: "diffuser";
+        "return-grille": "return-grille";
+        "supply-register": "supply-register";
+    }>>;
+    mount: import("zod").ZodDefault<import("zod").ZodEnum<{
+        ceiling: "ceiling";
+        floor: "floor";
+        wall: "wall";
+    }>>;
+    width: import("zod").ZodDefault<import("zod").ZodNumber>;
+    depth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    collarShape: import("zod").ZodDefault<import("zod").ZodEnum<{
+        oval: "oval";
+        rect: "rect";
+        round: "round";
+    }>>;
+    collarDiameter: import("zod").ZodDefault<import("zod").ZodNumber>;
+    collarWidth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    collarHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/duct-terminal/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAKtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAE3C;;;;;;;;GAQG;AACH,eAAO,MAAM,sBAAsB,EAAE,cAAc,CAAC,OAAO,gBAAgB,CAoF1E,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/duct-terminal/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAGlC,CAAA"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/duct-terminal/definition.edit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAGvE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAEhD,eAAO,MAAM,4BAA4B,EAAE,oBAAoB,CAAC,OAAO,gBAAgB,CAWtF,CAAA"}

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

@@ -0,0 +1,14 @@
+import { buildDuctTerminalFloorplan } from './floorplan.js';
+import { ductTerminalParametrics } from './parametrics.js';
+export const ductTerminalEditContribution = {
+    snapProfile: 'item',
+    parametrics: ductTerminalParametrics,
+    floorplan: buildDuctTerminalFloorplan,
+    tool: () => import('./tool.js'),
+    toolHints: [
+        { key: 'Click', label: 'Place register' },
+        { key: 'M', label: 'Mount: floor / ceiling / wall' },
+        { key: 'R / T', label: 'Rotate ±45° (floor / ceiling)' },
+        { key: 'Esc', label: 'Exit' },
+    ],
+};

package/dist/duct-terminal/definition.js

@@ -1,87 +1,4 @@
-import { buildDuctTerminalFloorplan } from './floorplan.js';
-import { buildDuctTerminalGeometry } from './geometry.js';
-import { ductTerminalParametrics } from './parametrics.js';
-import { getDuctTerminalPorts } from './ports.js';
-import { DuctTerminalNode } from './schema.js';
-/**
- * Phase 3 of the HVAC node system — duct terminals: supply registers,
- * ceiling diffusers, return grilles. The end of the air loop. One typed
- * port at the collar (mount-aware direction) so duct runs end onto a
- * terminal like any other port.
- *
- * Composition: `def.geometry` only. Yaw-only rotation — the editor's
- * default R-rotate works on a selected terminal.
- */
-export const ductTerminalDefinition = {
-    kind: 'duct-terminal',
-    schemaVersion: 1,
-    schema: DuctTerminalNode,
-    category: 'utility',
-    distributionRole: 'terminal',
-    snapProfile: 'item',
-    defaults: () => ({
-        object: 'node',
-        parentId: null,
-        visible: true,
-        metadata: {},
-        position: [0, 0, 0],
-        rotation: 0,
-        terminalType: 'supply-register',
-        mount: 'floor',
-        width: 0.3,
-        depth: 0.15,
-        collarShape: 'round',
-        collarDiameter: 6,
-        collarWidth: 10,
-        collarHeight: 6,
-    }),
-    capabilities: {
-        selectable: { hitVolume: 'bbox' },
-        movable: { axes: ['x', 'z'], gridSnap: true, portSnap: { systems: ['supply', 'return'] } },
-        rotatable: { axes: ['y'], snapAngles: [Math.PI / 4] },
-        duplicable: true,
-        deletable: true,
-        // A floor register rests on top of whatever slab is under it — the
-        // generic FloorElevationSystem lifts its mesh Y by the slab's elevation
-        // so the face sits on the slab surface instead of sinking into it.
-        // Ceiling / wall mounts derive their Y elsewhere, so `applies` skips them.
-        floorPlaced: {
-            footprint: (node) => {
-                const t = node;
-                return { dimensions: [t.width, 0, t.depth], rotation: [0, t.rotation, 0] };
-            },
-            applies: (node) => node.mount === 'floor',
-        },
-    },
-    parametrics: ductTerminalParametrics,
-    geometry: buildDuctTerminalGeometry,
-    geometryKey: (n) => JSON.stringify([
-        n.terminalType,
-        n.mount,
-        n.width,
-        n.depth,
-        n.collarShape,
-        n.collarDiameter,
-        n.collarWidth,
-        n.collarHeight,
-    ]),
-    ports: getDuctTerminalPorts,
-    floorplan: buildDuctTerminalFloorplan,
-    tool: () => import('./tool.js'),
-    toolHints: [
-        { key: 'Click', label: 'Place register' },
-        { key: 'M', label: 'Mount: floor / ceiling / wall' },
-        { key: 'R / T', label: 'Rotate ±45° (floor / ceiling)' },
-        { key: 'Esc', label: 'Exit' },
-    ],
-    presentation: {
-        label: 'Register',
-        description: 'Duct terminal — supply register, ceiling diffuser, or return grille. Duct runs end at its collar.',
-        icon: { kind: 'url', src: '/icons/registers.webp' },
-        paletteSection: 'structure',
-        paletteOrder: 93,
-    },
-    mcp: {
-        description: 'A duct terminal (supply register, ceiling diffuser, or return grille) with a single collar port. Mount (floor/ceiling/wall) drives the face orientation and collar direction.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { ductTerminalEditContribution } from './definition.edit.js';
+import { ductTerminalRenderDefinition } from './definition.render.js';
+export const ductTerminalDefinition = composeNodeDefinition(ductTerminalRenderDefinition, ductTerminalEditContribution);

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/duct-terminal/definition.render.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAGvE,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAE3C,eAAO,MAAM,4BAA4B,EAAE,oBAAoB,CAAC,OAAO,gBAAgB,CAAC,GAAG;IACzF,IAAI,EAAE,eAAe,CAAA;CAkEtB,CAAA"}

package/dist/duct-terminal/definition.render.js

@@ -0,0 +1,66 @@
+import { buildDuctTerminalGeometry } from './geometry.js';
+import { getDuctTerminalPorts } from './ports.js';
+import { DuctTerminalNode } from './schema.js';
+export const ductTerminalRenderDefinition = {
+    kind: 'duct-terminal',
+    schemaVersion: 1,
+    schema: DuctTerminalNode,
+    category: 'utility',
+    distributionRole: 'terminal',
+    defaults: () => ({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        position: [0, 0, 0],
+        rotation: 0,
+        terminalType: 'supply-register',
+        mount: 'floor',
+        width: 0.3,
+        depth: 0.15,
+        collarShape: 'round',
+        collarDiameter: 6,
+        collarWidth: 10,
+        collarHeight: 6,
+    }),
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        movable: { axes: ['x', 'z'], gridSnap: true, portSnap: { systems: ['supply', 'return'] } },
+        rotatable: { axes: ['y'], snapAngles: [Math.PI / 4] },
+        duplicable: true,
+        deletable: true,
+        // A floor register rests on top of whatever slab is under it — the
+        // generic FloorElevationSystem lifts its mesh Y by the slab's elevation
+        // so the face sits on the slab surface instead of sinking into it.
+        // Ceiling / wall mounts derive their Y elsewhere, so `applies` skips them.
+        floorPlaced: {
+            footprint: (node) => {
+                const t = node;
+                return { dimensions: [t.width, 0, t.depth], rotation: [0, t.rotation, 0] };
+            },
+            applies: (node) => node.mount === 'floor',
+        },
+    },
+    geometry: buildDuctTerminalGeometry,
+    geometryKey: (n) => JSON.stringify([
+        n.terminalType,
+        n.mount,
+        n.width,
+        n.depth,
+        n.collarShape,
+        n.collarDiameter,
+        n.collarWidth,
+        n.collarHeight,
+    ]),
+    ports: getDuctTerminalPorts,
+    presentation: {
+        label: 'Register',
+        description: 'Duct terminal — supply register, ceiling diffuser, or return grille. Duct runs end at its collar.',
+        icon: { kind: 'url', src: '/icons/registers.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 93,
+    },
+    mcp: {
+        description: 'A duct terminal (supply register, ceiling diffuser, or return grille) with a single collar port. Mount (floor/ceiling/wall) drives the face orientation and collar direction.',
+    },
+};

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

@@ -1 +1 @@
-{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/duct-terminal/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,EAIN,MAAM,OAAO,CAAA;AAGd,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAchD;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,gBAAgB,GAAG,KAAK,CAqEvE"}
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/duct-terminal/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,EAIN,MAAM,OAAO,CAAA;AAId,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAchD;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,gBAAgB,GAAG,KAAK,CAqEvE"}

package/dist/duct-terminal/geometry.js

@@ -1,5 +1,6 @@
 import { BoxGeometry, CylinderGeometry, Group, Mesh, MeshStandardMaterial, Vector3, } from 'three';
-import { createOvalSectionGeometry, INCHES_TO_METERS } from '../duct-segment/geometry.js';
+import { createOvalSectionGeometry } from '../duct-segment/geometry.js';
+import { INCHES_TO_METERS } from '../duct-segment/profile.js';
 import { COLLAR_LENGTH, mountQuaternion, terminalSystem } from './ports.js';
 const RADIAL_SEGMENTS = 20;
 /** Radial clearance (meters) the collar sleeve carries over the duct's

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

@@ -1 +1 @@
-{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/duct-terminal/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAC5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAEhD,eAAO,MAAM,uBAAuB,EAAE,oBAAoB,CAAC,gBAAgB,CAoE1E,CAAA"}
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/duct-terminal/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAC5D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AAEhD,eAAO,MAAM,uBAAuB,EAAE,oBAAoB,CAAC,gBAAgB,CAqE1E,CAAA"}

package/dist/duct-terminal/parametrics.js

@@ -1,4 +1,5 @@
 export const ductTerminalParametrics = {
+    trailingSection: () => import('../shared/duct-collar-inspector.js'),
     groups: [
         {
             label: 'Terminal',

package/dist/duct-terminal/ports.js

@@ -1,5 +1,5 @@
 import { Euler, Quaternion, Vector3 } from 'three';
-import { equivalentDiameterIn, ovalEquivalentDiameterIn } from '../duct-segment/geometry.js';
+import { equivalentDiameterIn, ovalEquivalentDiameterIn } from '../duct-segment/profile.js';
 /** Collar stub length in meters behind the face. */
 export const COLLAR_LENGTH = 0.12;
 /**

package/dist/elevator/__bench__/runtime.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=runtime.d.ts.map

package/dist/elevator/__bench__/runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime.d.ts","sourceRoot":"","sources":["../../../src/elevator/__bench__/runtime.ts"],"names":[],"mappings":""}

package/dist/elevator/__bench__/runtime.js

@@ -0,0 +1,38 @@
+import { BlockNode, BuildingNode, ElevatorNode, LevelNode, stepElevatorRuntimes, useInteractive, useScene, } from '@pascal-app/core';
+const building = BuildingNode.parse({});
+const levels = [0, 1].map((level) => LevelNode.parse({ parentId: building.id, level, height: 3 }));
+const elevators = Array.from({ length: 20 }, () => ElevatorNode.parse({
+    parentId: building.id,
+    fromLevelId: levels[0].id,
+    toLevelId: levels[1].id,
+}));
+building.children = [
+    ...levels.map((level) => level.id),
+    ...elevators.map((elevator) => elevator.id),
+];
+const values = [
+    building,
+    ...levels,
+    ...elevators,
+    ...Array.from({ length: 2000 }, () => BlockNode.parse({ parentId: levels[0].id })),
+];
+let scans = 0;
+const nodes = new Proxy(Object.fromEntries(values.map((node) => [node.id, node])), {
+    ownKeys(target) {
+        scans++;
+        return Reflect.ownKeys(target);
+    },
+});
+useScene.setState({ nodes });
+useInteractive.setState({ elevators: {} });
+stepElevatorRuntimes(0, 1 / 60);
+const warmupScans = scans;
+for (let frame = 1; frame <= 100; frame++)
+    stepElevatorRuntimes((frame * 1000) / 60, 1 / 60);
+console.log(JSON.stringify({
+    nodes: values.length,
+    elevators: elevators.length,
+    idleFrames: 100,
+    warmupSceneScans: warmupScans,
+    idleSceneScans: scans - warmupScans,
+}));