@pascal-app/nodes 0.1.1

package/dist/gutter/preview.js

@@ -0,0 +1,57 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useMemo } from 'react';
+import * as THREE from 'three';
+import { INVALID_GHOST_COLOR } from '../shared/ghost-materials';
+import { buildGutterGeometry } from './geometry';
+/**
+ * Translucent ghost of a gutter — built from the same `buildGutterGeometry`
+ * the renderer commits, so the shape on screen during placement is the
+ * shape that lands on click.
+ *
+ * No internal transform wrapper. Callers (placement tool + move tool)
+ * mirror the GutterRenderer's transform chain around this component
+ * (roof → segment → snap), so the ghost shares one bulletproof chain
+ * with the committed mesh instead of a flattened-yaw shortcut that can
+ * drift in edge cases.
+ *
+ * FrontSide matches the renderer; DoubleSide would render the inside
+ * of the trough walls and visually thicken the ghost relative to the
+ * placed gutter.
+ */
+const GutterPreview = ({ node, invalid }) => {
+    // biome-ignore lint/correctness/useExhaustiveDependencies: deps deliberately list the build inputs; depending on the whole object would rebuild on unrelated field changes.
+    const geometry = useMemo(() => buildGutterGeometry(node), [
+        node.length,
+        node.size,
+        node.thickness,
+        node.profile,
+        node.endCapLeft,
+        node.endCapRight,
+        node.hangerStyle,
+        node.hangerSpacing,
+        JSON.stringify(node.outlets),
+    ]);
+    const material = useMemo(() => new THREE.MeshStandardMaterial({
+        color: invalid ? INVALID_GHOST_COLOR : 0xff_ff_ff,
+        emissive: invalid ? INVALID_GHOST_COLOR : 0xff_ff_ff,
+        emissiveIntensity: 0.12,
+        roughness: 0.7,
+        metalness: 0.2,
+        transparent: true,
+        opacity: invalid ? 0.4 : 0.55,
+        depthWrite: false,
+        side: THREE.FrontSide,
+    }), [invalid]);
+    const edgesGeometry = useMemo(() => new THREE.EdgesGeometry(geometry, 25), [geometry]);
+    useEffect(() => () => {
+        geometry.dispose();
+        edgesGeometry.dispose();
+        material.dispose();
+    }, [geometry, edgesGeometry, material]);
+    return (_jsxs(_Fragment, { children: [_jsx("mesh", { geometry: geometry, material: material, 
+                // See box-vent preview note — never let the preview swallow
+                // roof events meant for the placement tool's hit-tester.
+                raycast: () => { } }), _jsx("lineSegments", { geometry: edgesGeometry, renderOrder: 1000, children: _jsx("lineBasicMaterial", { color: 0x6c_a3_ff, depthTest: false, opacity: 0.9, transparent: true }) })] }));
+};
+export default GutterPreview;

package/dist/gutter/profile-geometry.d.ts

@@ -0,0 +1,44 @@
+import type { GutterNode } from '@pascal-app/core';
+/**
+ * Shared outlet/profile geometry constants + math used by the gutter
+ * mesh builder, the outlet lookup the downspout mounts against, and the
+ * downspout's own routing. Kept in one place so the trough-floor probe
+ * and the collar dimensions can't drift between the three call sites
+ * (they did before this file — `profileFloorMidZ` was copied verbatim
+ * into both `geometry.ts` and `outlet-lookup.ts`).
+ */
+export declare const OUTLET_WALL_THICKNESS = 0.003;
+export declare const OUTLET_STUB_LENGTH = 0.06;
+/**
+ * Z (outward) coordinate of the trough floor's midpoint per profile —
+ * where a drop outlet drills through. k-style bottom is `wBot = 0.8 ·
+ * size` wide so its midpoint sits at `0.4 · size`; box bottom is `size`
+ * wide → `size / 2`; half-round's lowest point is the centre of the
+ * semicircle at Z = r = size.
+ */
+export declare function profileFloorMidZ(profile: GutterNode['profile'], size: number): number;
+export type OutletShape = 'round' | 'rect';
+/**
+ * Which cross-section a gutter's drop outlet (and the downspout that
+ * plugs into it) takes. Half-round gutters use a round leader; the
+ * flat-bottomed profiles (k-style, box) use a rectangular one — matching
+ * real residential hardware (round leaders on half-round, 2×3 / 3×4
+ * rectangular leaders on k-style / commercial box).
+ */
+export declare function outletShapeForProfile(profile: GutterNode['profile']): OutletShape;
+export declare const RECT_OUTLET_DEPTH_RATIO = 0.7;
+export type OutletDims = {
+    shape: OutletShape;
+    /** Half-extent along the gutter length (X). Round: = radius. */
+    halfX: number;
+    /** Half-extent outward (Z). Round: = radius. */
+    halfZ: number;
+};
+/**
+ * Cross-section half-extents for a `nominalDiameter`-sized outlet of the
+ * given shape. Round → a circle of that diameter (halfX = halfZ =
+ * radius); rect → that diameter wide along the run, `RECT_OUTLET_DEPTH_
+ * RATIO` as deep outward.
+ */
+export declare function outletDims(shape: OutletShape, nominalDiameter: number): OutletDims;
+//# sourceMappingURL=profile-geometry.d.ts.map

package/dist/gutter/profile-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"profile-geometry.d.ts","sourceRoot":"","sources":["../../src/gutter/profile-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAElD;;;;;;;GAOG;AAKH,eAAO,MAAM,qBAAqB,QAAQ,CAAA;AAK1C,eAAO,MAAM,kBAAkB,OAAO,CAAA;AAEtC;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,UAAU,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAIrF;AAID,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,MAAM,CAAA;AAE1C;;;;;;GAMG;AACH,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,UAAU,CAAC,SAAS,CAAC,GAAG,WAAW,CAEjF;AAKD,eAAO,MAAM,uBAAuB,MAAM,CAAA;AAE1C,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,WAAW,CAAA;IAClB,gEAAgE;IAChE,KAAK,EAAE,MAAM,CAAA;IACb,gDAAgD;IAChD,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,GAAG,UAAU,CAIlF"}

package/dist/gutter/profile-geometry.js

@@ -0,0 +1,56 @@
+/**
+ * Shared outlet/profile geometry constants + math used by the gutter
+ * mesh builder, the outlet lookup the downspout mounts against, and the
+ * downspout's own routing. Kept in one place so the trough-floor probe
+ * and the collar dimensions can't drift between the three call sites
+ * (they did before this file — `profileFloorMidZ` was copied verbatim
+ * into both `geometry.ts` and `outlet-lookup.ts`).
+ */
+// Wall thickness of the drop-tube collar — 3 mm matches typical
+// residential gauge. After the CSG drill the stub becomes a tube with
+// outer radius = bore + wall and inner radius = bore.
+export const OUTLET_WALL_THICKNESS = 0.003;
+// Collar length — how far the drop-tube stub hangs below the trough
+// floor. 6 cm reads as "drop outlet" without poking conspicuously far
+// below the eave; the downspout slip-fits up into this collar.
+export const OUTLET_STUB_LENGTH = 0.06;
+/**
+ * Z (outward) coordinate of the trough floor's midpoint per profile —
+ * where a drop outlet drills through. k-style bottom is `wBot = 0.8 ·
+ * size` wide so its midpoint sits at `0.4 · size`; box bottom is `size`
+ * wide → `size / 2`; half-round's lowest point is the centre of the
+ * semicircle at Z = r = size.
+ */
+export function profileFloorMidZ(profile, size) {
+    if (profile === 'half-round')
+        return size;
+    if (profile === 'box')
+        return size / 2;
+    return size * 0.4;
+}
+/**
+ * Which cross-section a gutter's drop outlet (and the downspout that
+ * plugs into it) takes. Half-round gutters use a round leader; the
+ * flat-bottomed profiles (k-style, box) use a rectangular one — matching
+ * real residential hardware (round leaders on half-round, 2×3 / 3×4
+ * rectangular leaders on k-style / commercial box).
+ */
+export function outletShapeForProfile(profile) {
+    return (profile ?? 'k-style') === 'half-round' ? 'round' : 'rect';
+}
+// Outward (Z) depth of a rectangular outlet as a fraction of its
+// along-length (X) width — a 2×3 leader is ~0.66; 0.7 reads cleanly and
+// still fits inside the k-style trough floor.
+export const RECT_OUTLET_DEPTH_RATIO = 0.7;
+/**
+ * Cross-section half-extents for a `nominalDiameter`-sized outlet of the
+ * given shape. Round → a circle of that diameter (halfX = halfZ =
+ * radius); rect → that diameter wide along the run, `RECT_OUTLET_DEPTH_
+ * RATIO` as deep outward.
+ */
+export function outletDims(shape, nominalDiameter) {
+    const half = Math.max(0.01, nominalDiameter / 2);
+    if (shape === 'round')
+        return { shape, halfX: half, halfZ: half };
+    return { shape, halfX: half, halfZ: half * RECT_OUTLET_DEPTH_RATIO };
+}

package/dist/gutter/renderer.d.ts

@@ -0,0 +1,22 @@
+import { type GutterNode } from '@pascal-app/core';
+/**
+ * Gutter renderer. Mounts at the eave of the host roof-segment — the
+ * gutter hangs level off the eave line (gravity wins; no slope tilt).
+ * Transform stack:
+ *
+ *   segment.position → segment.rotation (Y) → gutter.position
+ *     → gutter.rotation (Y) → mesh
+ *
+ * The registered ref sits on the inner group that applies position +
+ * rotation, so `NodeArrowHandles` reads gutter-mesh-local coords for
+ * its chevron placements (same pattern as ridge-vent).
+ *
+ * `useLiveNodeOverrides` merges in-flight handle drags onto the store
+ * node so the mesh tracks the drag without flushing zustand each
+ * frame.
+ */
+declare const GutterRenderer: ({ node: storeNode }: {
+    node: GutterNode;
+}) => import("react").JSX.Element | null;
+export default GutterRenderer;
+//# sourceMappingURL=renderer.d.ts.map

package/dist/gutter/renderer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/gutter/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,UAAU,EAKhB,MAAM,kBAAkB,CAAA;AAwBzB;;;;;;;;;;;;;;;GAeG;AACH,QAAA,MAAM,cAAc,GAAI,qBAAqB;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,uCAmNhE,CAAA;AAED,eAAe,cAAc,CAAA"}

package/dist/gutter/renderer.js

@@ -0,0 +1,202 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useLiveNodeOverrides, useRegistry, useScene, } from '@pascal-app/core';
+import { createMaterial, createMaterialFromPresetRef, createSurfaceRoleMaterial, useNodeEvents, useViewer, } from '@pascal-app/viewer';
+import { useEffect, useMemo, useRef } from 'react';
+import * as THREE from 'three';
+import { useShallow } from 'zustand/react/shallow';
+import { useSegmentTrimClippedGeometry } from '../shared/use-segment-trim-clip';
+import { computeGutterMitres, NO_MITRES } from './corner-mitre';
+import { computeSharedEaveY } from './eave-align';
+import { computeEaveY } from './eave-snap';
+import { buildGutterGeometry } from './geometry';
+const defaultMaterial = new THREE.MeshStandardMaterial({
+    color: 0xff_ff_ff,
+    roughness: 0.7,
+    metalness: 0.25,
+});
+/**
+ * Gutter renderer. Mounts at the eave of the host roof-segment — the
+ * gutter hangs level off the eave line (gravity wins; no slope tilt).
+ * Transform stack:
+ *
+ *   segment.position → segment.rotation (Y) → gutter.position
+ *     → gutter.rotation (Y) → mesh
+ *
+ * The registered ref sits on the inner group that applies position +
+ * rotation, so `NodeArrowHandles` reads gutter-mesh-local coords for
+ * its chevron placements (same pattern as ridge-vent).
+ *
+ * `useLiveNodeOverrides` merges in-flight handle drags onto the store
+ * node so the mesh tracks the drag without flushing zustand each
+ * frame.
+ */
+const GutterRenderer = ({ node: storeNode }) => {
+    const ref = useRef(null);
+    useRegistry(storeNode.id, 'gutter', ref);
+    const handlers = useNodeEvents(storeNode, 'gutter');
+    const shading = useViewer((s) => s.shading);
+    const textures = useViewer((s) => s.textures);
+    const colorPreset = useViewer((s) => s.colorPreset);
+    const sceneTheme = useViewer((s) => s.sceneTheme);
+    const overrides = useLiveNodeOverrides((s) => s.get(storeNode.id));
+    const node = overrides ? { ...storeNode, ...overrides } : storeNode;
+    const segment = useScene((state) => node.roofSegmentId
+        ? state.nodes[node.roofSegmentId]
+        : undefined);
+    // While the user is dragging the segment's wall-height / overhang /
+    // pitch handle, the drag pipeline writes to useLiveNodeOverrides
+    // instead of the scene store — the scene entry above stays at the
+    // pre-drag value until pointer-up. Subscribing to the segment's live
+    // overrides too lets the gutter's `computeEaveY` see the in-flight
+    // height and slide up/down on every frame of the drag.
+    const segmentOverrides = useLiveNodeOverrides((s) => node.roofSegmentId
+        ? s.get(node.roofSegmentId)
+        : undefined);
+    const effectiveSegment = segment
+        ? segmentOverrides
+            ? { ...segment, ...segmentOverrides }
+            : segment
+        : undefined;
+    // Corner-mitre inputs: every other gutter under the SAME ROOF, plus
+    // the roof's segments (for the frame lift). A flat array of node refs
+    // keeps `useShallow` stable — it only re-renders when one of those
+    // nodes actually changes. Cross-segment so gutters on different
+    // segments mitre where their segments meet (the mitres useMemo pairs
+    // each gutter back to its segment).
+    const mitreNodes = useScene(useShallow((state) => {
+        const segmentId = node.roofSegmentId;
+        const seg = segmentId ? state.nodes[segmentId] : undefined;
+        const roofId = seg?.parentId;
+        const roof = roofId
+            ? state.nodes[roofId]
+            : undefined;
+        if (!roof)
+            return [];
+        const out = [];
+        for (const sid of roof.children ?? []) {
+            const s = state.nodes[sid];
+            if (s?.type !== 'roof-segment')
+                continue;
+            out.push(s);
+            for (const gid of s.children ?? []) {
+                const g = state.nodes[gid];
+                if (g?.type === 'gutter' && g.id !== storeNode.id)
+                    out.push(g);
+            }
+        }
+        return out;
+    }));
+    // Mitres AND the run's shared eave height come from the same sibling
+    // walk: both key off which gutters meet at corners. `siblings` carries
+    // the FULL host segment (the alignment needs wallHeight / overhang /
+    // pitch / roofType to derive each eave Y), which is a superset of what
+    // the mitre detector reads — so one list feeds both.
+    // biome-ignore lint/correctness/useExhaustiveDependencies: deps deliberately list the build inputs; depending on the whole object would rebuild on unrelated field changes.
+    const { mitres, sharedEaveY } = useMemo(() => {
+        if (!effectiveSegment)
+            return { mitres: NO_MITRES, sharedEaveY: undefined };
+        const segById = new Map();
+        for (const n of mitreNodes) {
+            if (n.type === 'roof-segment')
+                segById.set(n.id, n);
+        }
+        const siblings = [];
+        for (const n of mitreNodes) {
+            if (n.type !== 'gutter')
+                continue;
+            const g = n;
+            const seg = g.roofSegmentId ? segById.get(g.roofSegmentId) : undefined;
+            if (seg)
+                siblings.push({ gutter: g, segment: seg });
+        }
+        return {
+            mitres: computeGutterMitres(node, effectiveSegment, siblings),
+            // `siblings` is typed for the mitre detector (position/rotation),
+            // but the segment objects are the full RoofSegmentNodes from
+            // `mitreNodes`, so `computeSharedEaveY` gets the eave-Y inputs it
+            // needs at runtime.
+            sharedEaveY: computeSharedEaveY(node, effectiveSegment, siblings),
+        };
+    }, [
+        node.position[0],
+        node.position[1],
+        node.position[2],
+        node.rotation,
+        node.length,
+        effectiveSegment?.position?.[0],
+        effectiveSegment?.position?.[2],
+        effectiveSegment?.rotation,
+        effectiveSegment?.wallHeight,
+        effectiveSegment?.overhang,
+        effectiveSegment?.pitch,
+        effectiveSegment?.roofType,
+        mitreNodes,
+    ]);
+    // biome-ignore lint/correctness/useExhaustiveDependencies: deps deliberately list the build inputs; depending on the whole object would rebuild on unrelated field changes.
+    const geometry = useMemo(() => buildGutterGeometry(node, mitres), [
+        node.length,
+        node.size,
+        node.thickness,
+        node.profile,
+        node.endCapLeft,
+        node.endCapRight,
+        node.hangerStyle,
+        node.hangerSpacing,
+        // Value-compare the outlets array so the CSG drills only rebuild
+        // when an outlet's offset / diameter changes or one is added.
+        JSON.stringify(node.outlets),
+        mitres.left,
+        mitres.right,
+    ]);
+    useEffect(() => () => geometry.dispose(), [geometry]);
+    // Paint surface: explicit material wins, then preset, then the cached
+    // default. FrontSide everywhere — DoubleSide on any NodeMaterial inside
+    // the MRT scenePass compiles a back-face shader variant that doesn't
+    // declare outputs for every MRT target and poisons the render context
+    // (see `materials.ts` line 77, and the glazing FrontSide fix in
+    // 9400f1c5). The U-channel cross-section in `geometry.ts` is traced as
+    // a single closed polygon around the material — both the exterior shell
+    // and the interior trough walls are part of the same outward-wound
+    // boundary, so ExtrudeGeometry produces outward-facing normals on every
+    // visible face. FrontSide is therefore sufficient and DoubleSide is not
+    // needed.
+    const material = useMemo(() => {
+        if (!textures || (!node.material && !node.materialPreset)) {
+            return createSurfaceRoleMaterial('roof', colorPreset, THREE.FrontSide, sceneTheme);
+        }
+        return node.material
+            ? createMaterial(node.material, shading)
+            : (createMaterialFromPresetRef(node.materialPreset, shading) ?? defaultMaterial);
+    }, [textures, colorPreset, sceneTheme, shading, node.material, node.materialPreset]);
+    // Map gutter-local geometry into the host segment's local frame (where the
+    // trim cut prisms live) — same pose the inner mesh group is mounted with
+    // (position [x, liveEaveY, z] + yaw). Computed before the early return so the
+    // hook order stays stable.
+    const liveEaveYForClip = sharedEaveY ?? (effectiveSegment ? computeEaveY(effectiveSegment) : 0);
+    const localToSegment = useMemo(() => new THREE.Matrix4().compose(new THREE.Vector3(node.position[0] ?? 0, liveEaveYForClip, node.position[2] ?? 0), new THREE.Quaternion().setFromAxisAngle(new THREE.Vector3(0, 1, 0), node.rotation ?? 0), new THREE.Vector3(1, 1, 1)), [node.position[0], node.position[2], node.rotation, liveEaveYForClip]);
+    const clippedGeometry = useSegmentTrimClippedGeometry(geometry, effectiveSegment, localToSegment);
+    if (!segment || !effectiveSegment)
+        return null;
+    // `node.position` is segment-local — the placement tool resolves the
+    // eave click via `segObj.worldToLocal`. The renderer mounts under
+    // `roof-elements` (only the roof transform inherited), so we
+    // re-apply the segment's roof-local transform here. Mirrors the
+    // ridge-vent / box-vent pattern; without this gutters on rotated
+    // segments would land on the first segment instead.
+    //
+    // Y is derived live from `effectiveSegment` (scene + drag overrides)
+    // instead of trusting `node.position[1]` — so changing wallHeight,
+    // overhang, or pitch on the parent segment moves the gutter on the
+    // very next frame, including while a segment-height handle is
+    // mid-drag. Matches the chimney/box-vent pattern of pulling host-
+    // segment geometry at draw time rather than caching it at placement.
+    const segPos = segment.position ?? [0, 0, 0];
+    const segRotY = segment.rotation ?? 0;
+    // Prefer the connected run's shared height (aligns gutters meeting at
+    // a corner whose segments derive different eave Ys); fall back to this
+    // segment's own eave Y for an isolated gutter.
+    const liveEaveY = sharedEaveY ?? computeEaveY(effectiveSegment);
+    return (_jsx("group", { position: segPos, "rotation-y": segRotY, children: _jsx("group", { position: [node.position[0] ?? 0, liveEaveY, node.position[2] ?? 0], ref: ref, "rotation-y": node.rotation ?? 0, visible: node.visible, children: _jsx("mesh", { castShadow: true, geometry: clippedGeometry ?? geometry, material: material, name: "gutter-surface", receiveShadow: true, ...handlers }) }) }));
+};
+export default GutterRenderer;

package/dist/gutter/schema.d.ts

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

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

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

package/dist/gutter/schema.js

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

package/dist/gutter/tool.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Gutter placement tool. Cursor preview snaps to the OUTER eave — the
+ * drip edge of the roof, NOT the wall line. The eave sits at
+ * `Z = ±(depth/2 + overhang)` in segment-local frame; the gutter
+ * mounts against the fascia there, hanging outward from the building.
+ *
+ * Which eave: `eave-snap.ts` picks the side closest to the cursor
+ * (roof-type aware — 4-way for hip/flat, low side only for shed, ±Z
+ * for the rest) and returns the segment-local snap pose. The same
+ * snap drives the ghost AND the commit, so picking-up + putting-down
+ * land at identical world coordinates.
+ *
+ * Ghost transform: we mount the GutterPreview under the exact same
+ * chain the GutterRenderer applies — roof.position + roof.rotation →
+ * segment.position + segment.rotation → snap.eave + snap.rotation.
+ * No `worldToBuildingLocal` + `previewYaw`-sum shortcut: that
+ * collapses three Y rotations into one scalar and converts world
+ * coords back into building-local, which is mathematically
+ * equivalent for pure-Y stacks but drifts under any future non-Y
+ * roof/segment transform. Sharing the renderer's chain means the
+ * ghost and the placed mesh are guaranteed pixel-identical.
+ */
+declare const GutterTool: () => import("react").JSX.Element;
+export default GutterTool;
+//# sourceMappingURL=tool.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/gutter/tool.tsx"],"names":[],"mappings":"AA8BA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,QAAA,MAAM,UAAU,mCAmIf,CAAA;AAED,eAAe,UAAU,CAAA"}

package/dist/gutter/tool.js

@@ -0,0 +1,124 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { emitter, GutterNode, useScene, } from '@pascal-app/core';
+import { triggerSFX } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { RoofAttachmentFallbackPreview } from '../shared/roof-attachment-fallback-preview';
+import { resolveRoofSegmentHit } from '../shared/roof-segment-hit';
+import { clearRoofSurfacePlacementGuides, publishRoofSurfacePlacementGuides, roofSurfaceFootprintFromNode, } from '../shared/roof-surface-placement-guides';
+import { gutterDefinition } from './definition';
+import { resolveEaveSnap } from './eave-snap';
+import GutterPreview from './preview';
+/**
+ * Gutter placement tool. Cursor preview snaps to the OUTER eave — the
+ * drip edge of the roof, NOT the wall line. The eave sits at
+ * `Z = ±(depth/2 + overhang)` in segment-local frame; the gutter
+ * mounts against the fascia there, hanging outward from the building.
+ *
+ * Which eave: `eave-snap.ts` picks the side closest to the cursor
+ * (roof-type aware — 4-way for hip/flat, low side only for shed, ±Z
+ * for the rest) and returns the segment-local snap pose. The same
+ * snap drives the ghost AND the commit, so picking-up + putting-down
+ * land at identical world coordinates.
+ *
+ * Ghost transform: we mount the GutterPreview under the exact same
+ * chain the GutterRenderer applies — roof.position + roof.rotation →
+ * segment.position + segment.rotation → snap.eave + snap.rotation.
+ * No `worldToBuildingLocal` + `previewYaw`-sum shortcut: that
+ * collapses three Y rotations into one scalar and converts world
+ * coords back into building-local, which is mathematically
+ * equivalent for pure-Y stacks but drifts under any future non-Y
+ * roof/segment transform. Sharing the renderer's chain means the
+ * ghost and the placed mesh are guaranteed pixel-identical.
+ */
+const GutterTool = () => {
+    const activeBuildingId = useViewer((s) => s.selection.buildingId);
+    const setSelection = useViewer((s) => s.setSelection);
+    const [target, setTarget] = useState(null);
+    const lastSnapRef = useRef(null);
+    const previewNode = useMemo(() => GutterNode.parse({
+        ...gutterDefinition.defaults(),
+        name: 'Gutter',
+        position: [0, 0, 0],
+        rotation: 0,
+    }), []);
+    useEffect(() => {
+        if (!activeBuildingId)
+            return;
+        const updatePreview = (event) => {
+            const roof = event.node;
+            const hit = resolveRoofSegmentHit(roof, event.position[0], event.position[1], event.position[2]);
+            if (!hit)
+                return;
+            const snap = resolveEaveSnap(hit.segment, hit.localX, hit.localZ);
+            // Grid-snap chime fires when the segment-local snap moves to a
+            // new 5 cm cell along the eave — keeps SFX in lockstep with what
+            // the commit will actually store.
+            const sx = Math.round(snap.eaveX * 20) / 20;
+            const sz = Math.round(snap.eaveZ * 20) / 20;
+            const prev = lastSnapRef.current;
+            if (event.nativeEvent?.shiftKey !== true && (!prev || prev[0] !== sx || prev[1] !== sz)) {
+                triggerSFX('sfx:grid-snap');
+                lastSnapRef.current = [sx, sz];
+            }
+            setTarget({
+                roof: {
+                    position: (roof.position ?? [0, 0, 0]),
+                    rotation: roof.rotation ?? 0,
+                },
+                segment: {
+                    position: (hit.segment.position ?? [0, 0, 0]),
+                    rotation: hit.segment.rotation ?? 0,
+                },
+                snap,
+            });
+            publishRoofSurfacePlacementGuides({
+                roof,
+                segment: hit.segment,
+                center: [snap.eaveX, snap.eaveY, snap.eaveZ],
+                footprint: roofSurfaceFootprintFromNode({ ...previewNode, rotation: snap.rotation }),
+                mode: 'linear-edge',
+            });
+            event.stopPropagation();
+        };
+        const onClick = (event) => {
+            const hit = resolveRoofSegmentHit(event.node, event.position[0], event.position[1], event.position[2]);
+            if (!hit)
+                return;
+            const state = useScene.getState();
+            const snap = resolveEaveSnap(hit.segment, hit.localX, hit.localZ);
+            const gutter = GutterNode.parse({
+                ...gutterDefinition.defaults(),
+                name: 'Gutter',
+                roofSegmentId: hit.segment.id,
+                // (X, Y, Z) all come from the eave snap — on ±Z eaves X stays
+                // free along the cursor; on ±X eaves Z stays free instead.
+                // Rotation orients the gutter's outward axis away from the
+                // building on whichever side the click landed.
+                position: [snap.eaveX, snap.eaveY, snap.eaveZ],
+                rotation: snap.rotation,
+            });
+            state.createNode(gutter, hit.segment.id);
+            state.dirtyNodes.add(hit.segment.id);
+            setSelection({ selectedIds: [gutter.id] });
+            triggerSFX('sfx:item-place');
+            clearRoofSurfacePlacementGuides();
+            event.stopPropagation();
+        };
+        emitter.on('roof:move', updatePreview);
+        emitter.on('roof:enter', updatePreview);
+        emitter.on('roof:click', onClick);
+        return () => {
+            emitter.off('roof:move', updatePreview);
+            emitter.off('roof:enter', updatePreview);
+            emitter.off('roof:click', onClick);
+            clearRoofSurfacePlacementGuides();
+        };
+    }, [activeBuildingId, setSelection, previewNode]);
+    return (_jsxs(_Fragment, { children: [_jsx(RoofAttachmentFallbackPreview, { activeBuildingId: activeBuildingId, ghost: _jsx(GutterPreview, { node: previewNode, invalid: true }), onInvalidTarget: () => {
+                    setTarget(null);
+                    clearRoofSurfacePlacementGuides();
+                } }), activeBuildingId && target && (_jsx("group", { position: target.roof.position, "rotation-y": target.roof.rotation, children: _jsx("group", { position: target.segment.position, "rotation-y": target.segment.rotation, children: _jsx("group", { position: [target.snap.eaveX, target.snap.eaveY, target.snap.eaveZ], "rotation-y": target.snap.rotation, children: _jsx(GutterPreview, { node: previewNode }) }) }) }))] }));
+};
+export default GutterTool;

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

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

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

@@ -0,0 +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"}