@pascal-app/nodes 1.0.7 → 1.1.0

package/dist/gutter/definition.js

@@ -1,176 +1,4 @@
-import { GutterNode as GutterNodeSchema, gutterSlots, } from '@pascal-app/core';
-import { buildGutterFloorplan } from './floorplan.js';
-import { snapLengthToCorner } from './length-snap.js';
-import { gutterPaint } from './paint.js';
-import { gutterParametrics } from './parametrics.js';
-import { GutterNode } from './schema.js';
-// Edge-to-arrow-center offset, matching the box-vent / ridge-vent
-// cadence so a roof's worth of accessories all read at the same scale.
-const SIDE_HANDLE_OFFSET = 0.2;
-// Gutter chevrons sit BELOW the gutter (the trough hangs below the
-// eave); the Y handle places its arrow under the cross-section apex.
-const SIZE_HANDLE_OFFSET = 0.15;
-// Minimums — well below the inspector defaults (2.0 m length, 0.13 m
-// profile) so users can shrink freely without locking.
-const MIN_LENGTH = 0.2;
-const MIN_SIZE = 0.05;
-// Centre of the gutter cross-section in vertical (Y) terms. The gutter
-// hangs from the eave (Y=0 in vent-mesh-local) down to Y=-size; chevrons
-// that want to read "beside the body" sit at -size/2.
-function getBodyMidY(n) {
-    return -Math.max(MIN_SIZE, n.size) / 2;
-}
-// Outward Z midpoint — the gutter's back wall sits at Z=0 and the rim
-// hangs out to Z≈+size (k-style) / +size (half-round / box). Side
-// handles place at Z=0 so they sit ABOVE the eave's fascia line.
-function getRimZ(n) {
-    return Math.max(MIN_SIZE, n.size) / 2;
-}
-// Length arrow on ±X (the eave direction). Asymmetric resize: drag one
-// end outward while the opposite end stays world-fixed by recentering
-// `position` along the gutter's own +X arm in segment frame. Same
-// yaw-aware projection as the box-vent / ridge-vent / chimney width
-// handles.
-//
-// Corner snap: when the dragged endpoint nears the geometric corner it
-// would form with another gutter (the crossing of their length axes),
-// `snapLengthToCorner` is the handle's magnetic snap, so Lines mode lands the
-// endpoint exactly on that corner, Grid mode uses the chosen step, and Off
-// leaves the cursor raw. Only this gutter's length changes.
-function gutterLengthHandle(side) {
-    const sign = side === 'right' ? 1 : -1;
-    return {
-        kind: 'linear-resize',
-        axis: 'x',
-        anchor: side === 'right' ? 'min' : 'max',
-        min: MIN_LENGTH,
-        gridSnap: true,
-        currentValue: (n) => n.length,
-        magneticSnap: (initial, newLength, sceneApi) => {
-            const rotY = initial.rotation ?? 0;
-            const armX = Math.cos(rotY);
-            const armZ = -Math.sin(rotY);
-            const anchorX = initial.position[0] - sign * (initial.length / 2) * armX;
-            const anchorZ = initial.position[2] - sign * (initial.length / 2) * armZ;
-            return snapLengthToCorner(initial, newLength, sign, anchorX, anchorZ, armX, armZ, MIN_LENGTH, sceneApi).length;
-        },
-        apply: (initial, newLength) => {
-            const rotY = initial.rotation ?? 0;
-            const armX = Math.cos(rotY);
-            const armZ = -Math.sin(rotY);
-            const anchorX = initial.position[0] - sign * (initial.length / 2) * armX;
-            const anchorZ = initial.position[2] - sign * (initial.length / 2) * armZ;
-            const newCenterX = anchorX + sign * (newLength / 2) * armX;
-            const newCenterZ = anchorZ + sign * (newLength / 2) * armZ;
-            return {
-                length: newLength,
-                position: [newCenterX, initial.position[1], newCenterZ],
-            };
-        },
-        placement: {
-            position: (n) => [sign * (n.length / 2 + SIDE_HANDLE_OFFSET), getBodyMidY(n), getRimZ(n)],
-            rotationY: () => (side === 'right' ? 0 : Math.PI),
-        },
-    };
-}
-// Profile-size arrow below the rim. axis='y', anchor='max' pins the
-// top of the trough (Y=0, the eave line) and grows the bottom edge
-// downward as the user drags toward -Y. Plain chevron — at typical
-// sizes (5″–6″) a dashed tracker would clutter the eave line.
-function gutterSizeHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'y',
-        // 'max' = +Y edge anchored (top of the trough stays at Y=0); drag
-        // pulls the bottom edge further down. The base linear-resize
-        // factor for `max` is -1, which flips the cursor delta so dragging
-        // downward grows the value 1:1.
-        anchor: 'max',
-        min: MIN_SIZE,
-        gridSnap: true,
-        currentValue: (n) => n.size,
-        apply: (_n, newValue) => ({ size: Math.max(MIN_SIZE, newValue) }),
-        placement: {
-            // Sit at the bottom of the trough, pushed a bit further down so
-            // the chevron clears the rim and reads as a downward indicator.
-            position: (n) => [0, -Math.max(n.size, MIN_SIZE) - SIZE_HANDLE_OFFSET, getRimZ(n)],
-        },
-    };
-}
-const gutterHandles = [
-    gutterLengthHandle('right'),
-    gutterLengthHandle('left'),
-    gutterSizeHandle(),
-];
-/**
- * Gutter — a rain-water channel running along the eave of a roof
- * segment. Parented to a `roof-segment`; position is segment-local.
- *
- * Three-checkbox model — same shape as box-vent / ridge-vent: custom
- * `def.renderer` for the parent-segment transform lookup + live
- * override merge, pure geometry builder in `./geometry` shared with
- * the placement preview, no per-frame system (no animation, no
- * cross-kind cascades).
- *
- * Placement tool snaps to the eave line (segment-local
- * `Z = +depth/2, Y = wallHeight`) wherever the cursor lands on a
- * segment. After commit, the length L/R handles cover trimming and
- * the inspector covers profile + size adjustments.
- */
-export const gutterDefinition = {
-    kind: 'gutter',
-    schemaVersion: 4,
-    schema: GutterNode,
-    category: 'structure',
-    surfaceRole: 'roof',
-    snapProfile: 'item',
-    defaults: () => {
-        const stub = GutterNodeSchema.parse({
-            id: 'gutter_default',
-            type: 'gutter',
-        });
-        const { id: _id, type: _type, ...rest } = stub;
-        return rest;
-    },
-    capabilities: {
-        exterior: true,
-        slots: gutterSlots,
-        selectable: { hitVolume: 'bbox' },
-        duplicable: true,
-        deletable: true,
-        paint: gutterPaint,
-        // Mounts on a roof segment via `roofSegmentId`. Sits ON TOP of the
-        // eave fascia — no `buildCut`, just the dirty cascade so the
-        // parent roof's merged shell rebuilds when the gutter moves /
-        // resizes.
-        roofAccessory: {},
-    },
-    parametrics: gutterParametrics,
-    handles: gutterHandles,
-    floorplan: buildGutterFloorplan,
-    floorplanDependsOnSiblings: true,
-    rendersChildren: false,
-    renderer: {
-        kind: 'parametric',
-        module: () => import('./renderer.js'),
-    },
-    preview: () => import('./preview.js'),
-    tool: () => import('./tool.js'),
-    affordanceTools: {
-        move: () => import('./move-tool.js'),
-    },
-    toolHints: [
-        { key: 'Left click', label: 'Place gutter on roof eave' },
-        { key: 'Esc', label: 'Cancel' },
-    ],
-    presentation: {
-        label: 'Gutter',
-        description: 'Rain-water channel running along the eave of a roof segment.',
-        icon: { kind: 'url', src: '/icons/gutter.webp' },
-        paletteSection: 'structure',
-        paletteOrder: 122,
-    },
-    mcp: {
-        description: 'A gutter strip running along the eave of a roof segment. Three profiles (k-style ogee fascia, half-round, square box), length / size / thickness parametric.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { gutterEditContribution } from './definition.edit.js';
+import { gutterRenderDefinition } from './definition.render.js';
+export const gutterDefinition = composeNodeDefinition(gutterRenderDefinition, gutterEditContribution);

package/dist/gutter/definition.render.d.ts

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

package/dist/gutter/definition.render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/gutter/definition.render.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AACvE,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAErC,eAAO,MAAM,sBAAsB,EAAE,oBAAoB,CAAC,OAAO,UAAU,CAAC,GAAG;IAAE,IAAI,EAAE,QAAQ,CAAA;CA2C5F,CAAA"}

package/dist/gutter/definition.render.js

@@ -0,0 +1,44 @@
+import { GutterNode as GutterNodeSchema, gutterSlots } from '@pascal-app/core';
+import { GutterNode } from './schema.js';
+export const gutterRenderDefinition = {
+    kind: 'gutter',
+    schemaVersion: 4,
+    schema: GutterNode,
+    category: 'structure',
+    surfaceRole: 'roof',
+    defaults: () => {
+        const stub = GutterNodeSchema.parse({
+            id: 'gutter_default',
+            type: 'gutter',
+        });
+        const { id: _id, type: _type, ...rest } = stub;
+        return rest;
+    },
+    capabilities: {
+        exterior: true,
+        slots: gutterSlots,
+        selectable: { hitVolume: 'bbox' },
+        duplicable: true,
+        deletable: true,
+        // Mounts on a roof segment via `roofSegmentId`. Sits ON TOP of the
+        // eave fascia — no `buildCut`, just the dirty cascade so the
+        // parent roof's merged shell rebuilds when the gutter moves /
+        // resizes.
+        roofAccessory: {},
+    },
+    rendersChildren: false,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer.js'),
+    },
+    presentation: {
+        label: 'Gutter',
+        description: 'Rain-water channel running along the eave of a roof segment.',
+        icon: { kind: 'url', src: '/icons/gutter.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 122,
+    },
+    mcp: {
+        description: 'A gutter strip running along the eave of a roof segment. Three profiles (k-style ogee fascia, half-round, square box), length / size / thickness parametric.',
+    },
+};

package/dist/gutter/move-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/gutter/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,UAAU,EAMhB,MAAM,kBAAkB,CAAA;AA2BzB;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,OAAO,UAAU,cAAc,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,sCAmOpE"}
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/gutter/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,UAAU,EAMhB,MAAM,kBAAkB,CAAA;AA6BzB;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,OAAO,UAAU,cAAc,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,sCAoOpE"}

package/dist/gutter/move-tool.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { emitter, sceneRegistry, useScene, } from '@pascal-app/core';
-import { consumePlacementDragRelease, markToolCancelConsumed, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { consumePlacementDragRelease, isGridSnapActive, markToolCancelConsumed, stripPlacementMetadataFlags, triggerSFX, useEditor, } from '@pascal-app/editor';
 import { useCallback, useEffect, useState } from 'react';
 import { createRelativeRoofDrag, snapRelativeRoofDragTarget } from '../shared/relative-roof-drag.js';
 import { clearRoofSurfacePlacementGuides, publishRoofSurfaceNodePlacementGuides, } from '../shared/roof-surface-placement-guides.js';
@@ -58,7 +58,7 @@ export default function MoveGutterTool({ node }) {
             const rawTarget = roofDrag.resolve(event);
             if (!rawTarget)
                 return null;
-            const target = snapRelativeRoofDragTarget(rawTarget, event.nativeEvent?.shiftKey === true);
+            const target = snapRelativeRoofDragTarget(rawTarget, event.nativeEvent?.altKey === true);
             return {
                 segment: target.segment,
                 snap: resolveEaveSnap(target.segment, target.localX, target.localZ),
@@ -80,7 +80,8 @@ export default function MoveGutterTool({ node }) {
             const { snap } = target;
             const sx = Math.round(snap.eaveX * 20) / 20;
             const sz = Math.round(snap.eaveZ * 20) / 20;
-            if (event.nativeEvent?.shiftKey !== true &&
+            if (isGridSnapActive() &&
+                event.nativeEvent?.altKey !== true &&
                 (!lastSnap || lastSnap[0] !== sx || lastSnap[1] !== sz)) {
                 triggerSFX('sfx:grid-snap');
                 lastSnap = [sx, sz];
@@ -138,7 +139,7 @@ export default function MoveGutterTool({ node }) {
                 position: [snap.eaveX, snap.eaveY, snap.eaveZ],
                 rotation: snap.rotation,
                 visible: true,
-                metadata: {},
+                metadata: stripPlacementMetadataFlags(original.metadata),
             });
             useScene.temporal.getState().pause();
             st.dirtyNodes.add(targetSegmentId);

package/dist/hvac-equipment/definition.d.ts

@@ -1,13 +1,73 @@
-import type { NodeDefinition } from '@pascal-app/core';
-import { HvacEquipmentNode } from './schema.js';
-/**
- * Phase 3 of the HVAC node system — equipment cabinets (furnace /
- * air handler / condenser). Furnaces and air handlers expose supply +
- * return ports, giving duct runs a real origin: the duct and fitting
- * tools snap onto these collars like any other port.
- *
- * Composition: `def.geometry` only. Yaw-only rotation, so the editor's
- * default R-rotate works on a selected unit without custom actions.
- */
-export declare const hvacEquipmentDefinition: NodeDefinition<typeof HvacEquipmentNode>;
+export declare const hvacEquipmentDefinition: 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<`hvac-equipment_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"hvac-equipment">>;
+    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>;
+    equipmentType: import("zod").ZodDefault<import("zod").ZodEnum<{
+        "air-handler": "air-handler";
+        condenser: "condenser";
+        furnace: "furnace";
+    }>>;
+    width: import("zod").ZodDefault<import("zod").ZodNumber>;
+    depth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    height: import("zod").ZodDefault<import("zod").ZodNumber>;
+    supplyShape: import("zod").ZodDefault<import("zod").ZodEnum<{
+        oval: "oval";
+        rect: "rect";
+        round: "round";
+    }>>;
+    returnShape: import("zod").ZodDefault<import("zod").ZodEnum<{
+        oval: "oval";
+        rect: "rect";
+        round: "round";
+    }>>;
+    supplyDiameter: import("zod").ZodDefault<import("zod").ZodNumber>;
+    returnDiameter: import("zod").ZodDefault<import("zod").ZodNumber>;
+    supplyWidth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    supplyHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+    returnWidth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    returnHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

package/dist/hvac-equipment/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/hvac-equipment/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAKtD,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAE5C;;;;;;;;GAQG;AACH,eAAO,MAAM,uBAAuB,EAAE,cAAc,CAAC,OAAO,iBAAiB,CAyF5E,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/hvac-equipment/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAGnC,CAAA"}

package/dist/hvac-equipment/definition.edit.d.ts

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

package/dist/hvac-equipment/definition.edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/hvac-equipment/definition.edit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAGvE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAEjD,eAAO,MAAM,6BAA6B,EAAE,oBAAoB,CAAC,OAAO,iBAAiB,CAUxF,CAAA"}

package/dist/hvac-equipment/definition.edit.js

@@ -0,0 +1,13 @@
+import { buildHvacEquipmentFloorplan } from './floorplan.js';
+import { hvacEquipmentParametrics } from './parametrics.js';
+export const hvacEquipmentEditContribution = {
+    snapProfile: 'item',
+    parametrics: hvacEquipmentParametrics,
+    floorplan: buildHvacEquipmentFloorplan,
+    tool: () => import('./tool.js'),
+    toolHints: [
+        { key: 'Click', label: 'Place unit' },
+        { key: 'R / T', label: 'Rotate ±45°' },
+        { key: 'Esc', label: 'Exit' },
+    ],
+};

package/dist/hvac-equipment/definition.js

@@ -1,92 +1,4 @@
-import { buildHvacEquipmentFloorplan } from './floorplan.js';
-import { buildHvacEquipmentGeometry } from './geometry.js';
-import { hvacEquipmentParametrics } from './parametrics.js';
-import { getHvacEquipmentPorts } from './ports.js';
-import { HvacEquipmentNode } from './schema.js';
-/**
- * Phase 3 of the HVAC node system — equipment cabinets (furnace /
- * air handler / condenser). Furnaces and air handlers expose supply +
- * return ports, giving duct runs a real origin: the duct and fitting
- * tools snap onto these collars like any other port.
- *
- * Composition: `def.geometry` only. Yaw-only rotation, so the editor's
- * default R-rotate works on a selected unit without custom actions.
- */
-export const hvacEquipmentDefinition = {
-    kind: 'hvac-equipment',
-    schemaVersion: 1,
-    schema: HvacEquipmentNode,
-    category: 'utility',
-    distributionRole: 'equipment',
-    snapProfile: 'item',
-    defaults: () => ({
-        object: 'node',
-        parentId: null,
-        visible: true,
-        metadata: {},
-        position: [0, 0, 0],
-        rotation: 0,
-        equipmentType: 'furnace',
-        width: 0.56,
-        depth: 0.71,
-        height: 1.1,
-        supplyShape: 'round',
-        returnShape: 'round',
-        supplyDiameter: 8,
-        returnDiameter: 8,
-        supplyWidth: 12,
-        supplyHeight: 8,
-        returnWidth: 14,
-        returnHeight: 8,
-    }),
-    capabilities: {
-        selectable: { hitVolume: 'bbox' },
-        movable: { axes: ['x', 'z'], gridSnap: true },
-        rotatable: { axes: ['y'], snapAngles: [Math.PI / 4] },
-        duplicable: true,
-        deletable: true,
-        floorPlaced: {
-            footprint: (node) => {
-                const n = node;
-                return {
-                    dimensions: [n.width, n.height, n.depth],
-                    rotation: [0, n.rotation, 0],
-                };
-            },
-        },
-    },
-    parametrics: hvacEquipmentParametrics,
-    geometry: buildHvacEquipmentGeometry,
-    geometryKey: (n) => JSON.stringify([
-        n.equipmentType,
-        n.width,
-        n.depth,
-        n.height,
-        n.supplyShape,
-        n.returnShape,
-        n.supplyDiameter,
-        n.returnDiameter,
-        n.supplyWidth,
-        n.supplyHeight,
-        n.returnWidth,
-        n.returnHeight,
-    ]),
-    ports: getHvacEquipmentPorts,
-    floorplan: buildHvacEquipmentFloorplan,
-    tool: () => import('./tool.js'),
-    toolHints: [
-        { key: 'Click', label: 'Place unit' },
-        { key: 'R / T', label: 'Rotate ±45°' },
-        { key: 'Esc', label: 'Exit' },
-    ],
-    presentation: {
-        label: 'HVAC Unit',
-        description: 'Furnace, air handler, or condenser — duct runs connect to its supply/return collars.',
-        icon: { kind: 'url', src: '/icons/HVAC.webp' },
-        paletteSection: 'structure',
-        paletteOrder: 92,
-    },
-    mcp: {
-        description: 'HVAC equipment cabinet (furnace, air handler, or condenser). Furnaces and air handlers have supply/return duct ports; every unit also has a refrigerant service port that a lineset run connects to. Position is level-local meters; rotation is yaw radians.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { hvacEquipmentEditContribution } from './definition.edit.js';
+import { hvacEquipmentRenderDefinition } from './definition.render.js';
+export const hvacEquipmentDefinition = composeNodeDefinition(hvacEquipmentRenderDefinition, hvacEquipmentEditContribution);

package/dist/hvac-equipment/definition.render.d.ts

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

package/dist/hvac-equipment/definition.render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/hvac-equipment/definition.render.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAGvE,OAAO,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAE5C,eAAO,MAAM,6BAA6B,EAAE,oBAAoB,CAAC,OAAO,iBAAiB,CAAC,GAAG;IAC3F,IAAI,EAAE,gBAAgB,CAAA;CAwEvB,CAAA"}

package/dist/hvac-equipment/definition.render.js

@@ -0,0 +1,72 @@
+import { buildHvacEquipmentGeometry } from './geometry.js';
+import { getHvacEquipmentPorts } from './ports.js';
+import { HvacEquipmentNode } from './schema.js';
+export const hvacEquipmentRenderDefinition = {
+    kind: 'hvac-equipment',
+    schemaVersion: 1,
+    schema: HvacEquipmentNode,
+    category: 'utility',
+    distributionRole: 'equipment',
+    defaults: () => ({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        position: [0, 0, 0],
+        rotation: 0,
+        equipmentType: 'furnace',
+        width: 0.56,
+        depth: 0.71,
+        height: 1.1,
+        supplyShape: 'round',
+        returnShape: 'round',
+        supplyDiameter: 8,
+        returnDiameter: 8,
+        supplyWidth: 12,
+        supplyHeight: 8,
+        returnWidth: 14,
+        returnHeight: 8,
+    }),
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        movable: { axes: ['x', 'z'], gridSnap: true },
+        rotatable: { axes: ['y'], snapAngles: [Math.PI / 4] },
+        duplicable: true,
+        deletable: true,
+        floorPlaced: {
+            footprint: (node) => {
+                const n = node;
+                return {
+                    dimensions: [n.width, n.height, n.depth],
+                    rotation: [0, n.rotation, 0],
+                };
+            },
+        },
+    },
+    geometry: buildHvacEquipmentGeometry,
+    geometryKey: (n) => JSON.stringify([
+        n.equipmentType,
+        n.width,
+        n.depth,
+        n.height,
+        n.supplyShape,
+        n.returnShape,
+        n.supplyDiameter,
+        n.returnDiameter,
+        n.supplyWidth,
+        n.supplyHeight,
+        n.returnWidth,
+        n.returnHeight,
+    ]),
+    ports: getHvacEquipmentPorts,
+    presentation: {
+        label: 'HVAC Unit',
+        description: 'Furnace, air handler, or condenser — duct runs connect to its supply/return collars.',
+        icon: { kind: 'url', src: '/icons/HVAC.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 92,
+    },
+    mcp: {
+        description: 'HVAC equipment cabinet (furnace, air handler, or condenser). Furnaces and air handlers have supply/return duct ports; every unit also has a refrigerant service port that a lineset run connects to. Position is level-local meters; rotation is yaw radians.',
+    },
+};

package/dist/hvac-equipment/floorplan.js

@@ -1,4 +1,4 @@
-import { INCHES_TO_METERS } from '../duct-segment/geometry.js';
+import { INCHES_TO_METERS } from '../duct-segment/profile.js';
 import { getHvacEquipmentPorts } from './ports.js';
 const BODY_FILL = '#c7cbd1';
 const BODY_STROKE = '#6b7280';

package/dist/hvac-equipment/geometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/hvac-equipment/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,EAQN,MAAM,OAAO,CAAA;AAOd,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAgCjD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,iBAAiB,GAAG,KAAK,CA+LzE"}
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/hvac-equipment/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,EAQN,MAAM,OAAO,CAAA;AAId,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAgCjD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,iBAAiB,GAAG,KAAK,CA+LzE"}

package/dist/hvac-equipment/geometry.js

@@ -1,5 +1,6 @@
 import { BoxGeometry, CylinderGeometry, ExtrudeGeometry, Group, Matrix4, Mesh, MeshStandardMaterial, Path, Shape, TorusGeometry, Vector3, } from 'three';
-import { createOvalSectionGeometry, INCHES_TO_METERS, rectSectionAxes, } from '../duct-segment/geometry.js';
+import { createOvalSectionGeometry } from '../duct-segment/geometry.js';
+import { INCHES_TO_METERS, rectSectionAxes } from '../duct-segment/profile.js';
 import { localEquipmentPorts, localRefrigerantPorts } from './ports.js';
 const RADIAL_SEGMENTS = 24;
 const SMALL_SEGMENTS = 16;

package/dist/hvac-equipment/parametrics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/hvac-equipment/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAC5D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAEjD,eAAO,MAAM,wBAAwB,EAAE,oBAAoB,CAAC,iBAAiB,CAoG5E,CAAA"}
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/hvac-equipment/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAC5D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AAEjD,eAAO,MAAM,wBAAwB,EAAE,oBAAoB,CAAC,iBAAiB,CAqG5E,CAAA"}

package/dist/hvac-equipment/parametrics.js

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

package/dist/hvac-equipment/ports.js

@@ -1,5 +1,5 @@
 import { Vector3 } from 'three';
-import { equivalentDiameterIn, ovalEquivalentDiameterIn } from '../duct-segment/geometry.js';
+import { equivalentDiameterIn, ovalEquivalentDiameterIn } from '../duct-segment/profile.js';
 /** Area-equivalent round diameter (inches) a shaped collar advertises. */
 function collarDiameterIn(shape, diameter, width, height) {
     if (shape === 'rect')

package/dist/i18n/definition-messages.js

@@ -725,7 +725,7 @@ export const definitionMessages = [
     /* i18n */ { id: "node.measurement.label", message: "Measurement" },
     /* i18n */ { id: "node.pipeFitting.description", message: "DWV joint — elbow bend, 45° wye, or sanitary tee." },
     /* i18n */ { id: "node.pipeFitting.label", message: "Pipe Fitting" },
-    /* i18n */ { id: "node.pipeSegment.description", message: "Drain / waste / vent pipe run — draw level or toggle a ¼″ per foot fall with S." },
+    /* i18n */ { id: "node.pipeSegment.description", message: "Drain / waste / vent pipe run — draw level or choose grade and downhill direction." },
     /* i18n */ { id: "node.pipeSegment.label", message: "DWV Pipe" },
     /* i18n */ { id: "node.pipeTrap.description", message: "DWV P-trap — water seal on the waste line. The trap arm runs to the vent." },
     /* i18n */ { id: "node.pipeTrap.label", message: "Trap" },