@pascal-app/nodes 0.1.1

package/dist/gutter/length-snap.js

@@ -0,0 +1,177 @@
+/**
+ * Length-handle snap. When the user drags a gutter's ±X length handle
+ * and the proposed endpoint lands within `SNAP_RADIUS` of the geometric
+ * CORNER it would form with another gutter — the intersection of their
+ * two length-axis lines — the dragged gutter's length is pulled so its
+ * end lands exactly on that corner. The corner-mitre detector's match
+ * window then fires reliably without a pixel-perfect drag.
+ *
+ * ONLY the dragged gutter moves. The corner is the axis crossing — a
+ * fixed point in plan, independent of where the other gutter currently
+ * ends — so each gutter snaps onto the SAME shared corner on its own as
+ * it's dragged in, and the L meets there without ever reaching over to
+ * reposition a gutter the user placed deliberately. (An earlier version
+ * adjusted both gutters at once; that yanked an already-placed gutter
+ * whenever its corner-mate was dragged, which is the bug this avoids.)
+ *
+ * Cross-segment: the search covers every gutter under the SAME ROOF
+ * (not just the dragged gutter's segment-mates), and all the geometry
+ * runs in the shared ROOF frame — each gutter's endpoints are lifted
+ * out of its own segment-local frame by that segment's position +
+ * Y-rotation. So an L-shaped plan whose two eaves live on different
+ * roof segments snaps + mitres at the corner where the segments meet,
+ * exactly like a same-segment hip corner (which is the degenerate case
+ * where both gutters share one segment transform).
+ *
+ * Pure: no React, no THREE. Reads through SceneApi; returns the snapped
+ * length for the caller to apply.
+ */
+// 10 cm catch radius — wide enough that the user doesn't need pixel-
+// perfect dragging, narrow enough that unrelated gutters on the
+// opposite eave don't accidentally bind.
+const SNAP_RADIUS = 0.1;
+const SNAP_RADIUS_SQ = SNAP_RADIUS * SNAP_RADIUS;
+// Cross product below this counts as parallel axes — no intersection,
+// fall back to snapping A onto B's current endpoint without modifying B.
+const AXIS_PARALLEL_EPSILON = 1e-3;
+// How far a corner-mate's own nearer endpoint may sit from the corner
+// and still bind the dragged gutter to it. The corner is the crossing
+// of the two axis LINES, which can lie well beyond where a gutter ends —
+// at an inner/concave corner the mate's end is a full eave overhang
+// short of the crossing, so the bound has to clear a generous overhang.
+// It also stops a far perpendicular gutter, whose infinite axis happens
+// to cross near the dragged end, from binding by coincidence: a real
+// corner-mate is within reach, an unrelated run is metres away.
+const CORNER_MATE_REACH = 1.5;
+const CORNER_MATE_REACH_SQ = CORNER_MATE_REACH * CORNER_MATE_REACH;
+/**
+ * @param initial          gutter at drag start (rotation, length, position)
+ * @param proposedLength   length the linear-resize pipeline computed
+ * @param sign             +1 for the gutter-local +X end being dragged, −1 for −X
+ * @param anchorX,anchorZ  the held-fixed endpoint (opposite of `sign`)
+ * @param armX,armZ        gutter +X direction in segment frame (cos r, −sin r)
+ * @param minLength        floor — typically the descriptor's `min` value
+ * @param sceneApi         scene access for corner-mate lookup
+ */
+export function snapLengthToCorner(initial, proposedLength, sign, anchorX, anchorZ, armX, armZ, minLength, sceneApi) {
+    const segmentId = initial.roofSegmentId;
+    if (!segmentId)
+        return { length: proposedLength };
+    const seg = sceneApi.get(segmentId);
+    if (!seg)
+        return { length: proposedLength };
+    // Everything runs in the ROOF frame so gutters on different segments
+    // can meet. The dragged gutter's anchor/arm come in segment-local
+    // (the caller computes them from `initial`); lift them into the roof
+    // frame with the dragged segment's transform.
+    const selfTf = segmentTransform(seg);
+    const anchorR = applyTf(selfTf, anchorX, anchorZ);
+    const armR = applyTfDir(selfTf, armX, armZ);
+    const aAnchorX = anchorR.x;
+    const aAnchorZ = anchorR.z;
+    const aArmX = armR.x;
+    const aArmZ = armR.z;
+    const proposedEndX = aAnchorX + sign * proposedLength * aArmX;
+    const proposedEndZ = aAnchorZ + sign * proposedLength * aArmZ;
+    const candidates = [];
+    const roofId = seg.parentId;
+    const roof = roofId ? sceneApi.get(roofId) : undefined;
+    const roofChildren = roof?.children;
+    for (const sid of roofChildren ?? []) {
+        const s = sceneApi.get(sid);
+        if (s?.type !== 'roof-segment')
+            continue;
+        const tf = segmentTransform(s);
+        for (const gid of s.children ?? []) {
+            const g = sceneApi.get(gid);
+            if (g?.type === 'gutter' && g.id !== initial.id) {
+                candidates.push({ gutter: g, tf });
+            }
+        }
+    }
+    // Find the corner-mate whose CORNER with the dragged gutter lands
+    // closest to the proposed dragged endpoint. The corner is the
+    // intersection of the two length-axis LINES (roof frame) — NOT the
+    // proximity of the two endpoints. That distinction is what unlocks
+    // inner/concave corners: there the two eave drip-lines meet out in the
+    // notch, a full overhang away from where either gutter naturally ends,
+    // so the old endpoint-to-endpoint catch never fired. Keying off the
+    // axis crossing treats convex and concave identically. Parallel axes
+    // (a straight collinear run) have no crossing, so there we fall back to
+    // the mate's nearer endpoint (flush join). Only the dragged gutter's
+    // own length is snapped to the corner — the mate is never moved.
+    let bestTargetX = 0;
+    let bestTargetZ = 0;
+    let bestDistSq = SNAP_RADIUS_SQ;
+    let found = false;
+    for (const { gutter: mateG, tf } of candidates) {
+        const mateRot = mateG.rotation ?? 0;
+        const arm = applyTfDir(tf, Math.cos(mateRot), -Math.sin(mateRot));
+        const mateHalf = mateG.length / 2;
+        const center = applyTf(tf, mateG.position[0], mateG.position[2]);
+        const plusX = center.x + arm.x * mateHalf;
+        const plusZ = center.z + arm.z * mateHalf;
+        const minusX = center.x - arm.x * mateHalf;
+        const minusZ = center.z - arm.z * mateHalf;
+        // Corner target T: axis intersection when the runs cross, else the
+        // mate's endpoint nearest the dragged end (collinear extension).
+        const crossDirs = aArmX * arm.z - aArmZ * arm.x;
+        let targetX;
+        let targetZ;
+        if (Math.abs(crossDirs) < AXIS_PARALLEL_EPSILON) {
+            const dPlus = (plusX - proposedEndX) ** 2 + (plusZ - proposedEndZ) ** 2;
+            const dMinus = (minusX - proposedEndX) ** 2 + (minusZ - proposedEndZ) ** 2;
+            if (dPlus <= dMinus) {
+                targetX = plusX;
+                targetZ = plusZ;
+            }
+            else {
+                targetX = minusX;
+                targetZ = minusZ;
+            }
+        }
+        else {
+            const dx = center.x - aAnchorX;
+            const dz = center.z - aAnchorZ;
+            const t = (dx * arm.z - dz * arm.x) / crossDirs;
+            targetX = aAnchorX + t * aArmX;
+            targetZ = aAnchorZ + t * aArmZ;
+        }
+        // Reject a mate whose own ends are nowhere near the crossing — its
+        // infinite axis lines up by coincidence, it's not a real corner-mate.
+        const dPlusT = (plusX - targetX) ** 2 + (plusZ - targetZ) ** 2;
+        const dMinusT = (minusX - targetX) ** 2 + (minusZ - targetZ) ** 2;
+        if (Math.min(dPlusT, dMinusT) > CORNER_MATE_REACH_SQ)
+            continue;
+        const score = (targetX - proposedEndX) ** 2 + (targetZ - proposedEndZ) ** 2;
+        if (score < bestDistSq) {
+            bestDistSq = score;
+            bestTargetX = targetX;
+            bestTargetZ = targetZ;
+            found = true;
+        }
+    }
+    if (!found)
+        return { length: proposedLength };
+    // Snap the dragged gutter's own end onto the corner: project
+    // (corner − anchor) onto its roof-frame axis. Length is frame-invariant
+    // (a scalar along the run), so the projection is the same in roof or
+    // segment frame — no need to map back. The mate is left untouched.
+    const projected = sign * ((bestTargetX - aAnchorX) * aArmX + (bestTargetZ - aAnchorZ) * aArmZ);
+    return { length: Math.max(minLength, projected) };
+}
+function segmentTransform(seg) {
+    const r = seg.rotation ?? 0;
+    return {
+        x: seg.position?.[0] ?? 0,
+        z: seg.position?.[2] ?? 0,
+        cos: Math.cos(r),
+        sin: Math.sin(r),
+    };
+}
+function applyTf(tf, x, z) {
+    return { x: tf.x + (x * tf.cos + z * tf.sin), z: tf.z + (-x * tf.sin + z * tf.cos) };
+}
+function applyTfDir(tf, x, z) {
+    return { x: x * tf.cos + z * tf.sin, z: -x * tf.sin + z * tf.cos };
+}

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

@@ -0,0 +1,21 @@
+import { type GutterNode } from '@pascal-app/core';
+/**
+ * Gutter move tool. Mirrors the ridge-vent move flow — ghost follows
+ * the cursor over any roof segment, click commits the new position +
+ * parent segment in one undoable step. The eave-snap math from the
+ * placement tool runs again on the new segment so the gutter lands on
+ * the correct side of the new ridge.
+ *
+ * On commit the gutter rotation may flip from 0 ↔ π if the user moves
+ * it from the front eave to the back eave (or vice versa). The
+ * pre-drag rotation is restored on cancel.
+ *
+ * Ghost transform: mirrors the GutterRenderer chain (roof → segment →
+ * snap), so the cursor preview lands at the exact world coords the
+ * commit will store. GutterPreview applies no internal rotation, so
+ * the gutter's CURRENT `rotation` doesn't bleed into the new snap.
+ */
+export default function MoveGutterTool({ node }: {
+    node: GutterNode;
+}): import("react").JSX.Element | null;
+//# sourceMappingURL=move-tool.d.ts.map

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

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

package/dist/gutter/move-tool.js

@@ -0,0 +1,223 @@
+'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 { useCallback, useEffect, useState } from 'react';
+import { createRelativeRoofDrag, snapRelativeRoofDragTarget } from '../shared/relative-roof-drag';
+import { clearRoofSurfacePlacementGuides, publishRoofSurfaceNodePlacementGuides, } from '../shared/roof-surface-placement-guides';
+import { resolveEaveSnap } from './eave-snap';
+import GutterPreview from './preview';
+/**
+ * Gutter move tool. Mirrors the ridge-vent move flow — ghost follows
+ * the cursor over any roof segment, click commits the new position +
+ * parent segment in one undoable step. The eave-snap math from the
+ * placement tool runs again on the new segment so the gutter lands on
+ * the correct side of the new ridge.
+ *
+ * On commit the gutter rotation may flip from 0 ↔ π if the user moves
+ * it from the front eave to the back eave (or vice versa). The
+ * pre-drag rotation is restored on cancel.
+ *
+ * Ghost transform: mirrors the GutterRenderer chain (roof → segment →
+ * snap), so the cursor preview lands at the exact world coords the
+ * commit will store. GutterPreview applies no internal rotation, so
+ * the gutter's CURRENT `rotation` doesn't bleed into the new snap.
+ */
+export default function MoveGutterTool({ node }) {
+    const exitMoveMode = useCallback(() => {
+        useEditor.getState().setMovingNode(null);
+    }, []);
+    const [target, setTarget] = useState(null);
+    useEffect(() => {
+        useScene.temporal.getState().pause();
+        const original = {
+            position: [...node.position],
+            rotation: node.rotation ?? 0,
+            roofSegmentId: node.roofSegmentId,
+            parentId: node.parentId,
+            metadata: node.metadata,
+        };
+        const meta = typeof node.metadata === 'object' && node.metadata !== null
+            ? node.metadata
+            : {};
+        const isNew = !!meta.isNew;
+        const gutterObj = sceneRegistry.nodes.get(node.id);
+        if (gutterObj)
+            gutterObj.visible = false;
+        let lastSnap = null;
+        let lastTarget = null;
+        let committed = false;
+        const roofDrag = createRelativeRoofDrag(original);
+        const clearTarget = () => {
+            lastTarget = null;
+            lastSnap = null;
+            setTarget(null);
+            clearRoofSurfacePlacementGuides();
+        };
+        const resolveTarget = (event) => {
+            const rawTarget = roofDrag.resolve(event);
+            if (!rawTarget)
+                return null;
+            const target = snapRelativeRoofDragTarget(rawTarget, event.nativeEvent?.shiftKey === true);
+            return {
+                segment: target.segment,
+                snap: resolveEaveSnap(target.segment, target.localX, target.localZ),
+            };
+        };
+        const updatePreview = (event) => {
+            const roof = event.node;
+            const target = resolveTarget(event);
+            if (!target) {
+                clearTarget();
+                return;
+            }
+            lastTarget = target;
+            // Same snap math as the placement tool — picking-up and putting-
+            // down round-trip identically. roofType-aware: hip/flat picks
+            // ±X or ±Z based on which slope the cursor is on; shed always
+            // snaps to its low (+Z) eave; gable / gambrel / mansard / dutch
+            // stay on ±Z.
+            const { snap } = target;
+            const sx = Math.round(snap.eaveX * 20) / 20;
+            const sz = Math.round(snap.eaveZ * 20) / 20;
+            if (event.nativeEvent?.shiftKey !== true &&
+                (!lastSnap || lastSnap[0] !== sx || lastSnap[1] !== sz)) {
+                triggerSFX('sfx:grid-snap');
+                lastSnap = [sx, sz];
+            }
+            setTarget({
+                roof: {
+                    position: (roof.position ?? [0, 0, 0]),
+                    rotation: roof.rotation ?? 0,
+                },
+                segment: {
+                    position: (target.segment.position ?? [0, 0, 0]),
+                    rotation: target.segment.rotation ?? 0,
+                },
+                snap,
+            });
+            publishRoofSurfaceNodePlacementGuides({
+                roof,
+                segment: target.segment,
+                center: [snap.eaveX, snap.eaveY, snap.eaveZ],
+                node: { ...node, rotation: snap.rotation },
+                mode: 'linear-edge',
+            });
+            event.stopPropagation();
+        };
+        const onRoofClick = (event) => {
+            if (committed)
+                return;
+            const target = lastTarget ?? resolveTarget(event);
+            if (!target)
+                return;
+            committed = true;
+            const targetSegmentId = target.segment.id;
+            const { snap } = target;
+            const st = useScene.getState();
+            const prevSegmentId = original.roofSegmentId;
+            if (prevSegmentId && prevSegmentId !== targetSegmentId) {
+                const oldSeg = st.nodes[prevSegmentId];
+                if (oldSeg) {
+                    st.updateNode(prevSegmentId, {
+                        children: (oldSeg.children ?? []).filter((id) => id !== node.id),
+                    });
+                }
+                const newSeg = st.nodes[targetSegmentId];
+                if (newSeg && !(newSeg.children ?? []).includes(node.id)) {
+                    st.updateNode(targetSegmentId, {
+                        children: [...(newSeg.children ?? []), node.id],
+                    });
+                }
+                st.dirtyNodes.add(prevSegmentId);
+            }
+            useScene.temporal.getState().resume();
+            st.updateNode(node.id, {
+                roofSegmentId: targetSegmentId,
+                parentId: targetSegmentId,
+                position: [snap.eaveX, snap.eaveY, snap.eaveZ],
+                rotation: snap.rotation,
+                visible: true,
+                metadata: {},
+            });
+            useScene.temporal.getState().pause();
+            st.dirtyNodes.add(targetSegmentId);
+            st.dirtyNodes.add(node.id);
+            const obj = sceneRegistry.nodes.get(node.id);
+            if (obj)
+                obj.visible = true;
+            triggerSFX('sfx:item-place');
+            clearRoofSurfacePlacementGuides();
+            exitMoveMode();
+            event.stopPropagation();
+        };
+        const onCancel = () => {
+            if (isNew) {
+                const parentId = original.roofSegmentId;
+                if (parentId) {
+                    const parent = useScene.getState().nodes[parentId];
+                    if (parent) {
+                        useScene.getState().updateNode(parentId, {
+                            children: (parent.children ?? []).filter((id) => id !== node.id),
+                        });
+                    }
+                }
+                useScene.getState().deleteNode(node.id);
+                useScene.temporal.getState().resume();
+                markToolCancelConsumed();
+                clearRoofSurfacePlacementGuides();
+                exitMoveMode();
+                return;
+            }
+            useScene.getState().updateNode(node.id, {
+                position: original.position,
+                rotation: original.rotation,
+                roofSegmentId: original.roofSegmentId,
+                parentId: original.parentId,
+                metadata: original.metadata,
+            });
+            if (original.roofSegmentId) {
+                useScene.getState().dirtyNodes.add(original.roofSegmentId);
+            }
+            const obj = sceneRegistry.nodes.get(node.id);
+            if (obj)
+                obj.visible = true;
+            useScene.temporal.getState().resume();
+            markToolCancelConsumed();
+            clearRoofSurfacePlacementGuides();
+            exitMoveMode();
+        };
+        const onPlacementDragPointerUp = (event) => {
+            if (!consumePlacementDragRelease(event))
+                return;
+            if (!lastTarget)
+                return;
+            onRoofClick({
+                nativeEvent: event,
+                stopPropagation: () => event.stopPropagation(),
+            });
+        };
+        emitter.on('roof:move', updatePreview);
+        emitter.on('roof:enter', updatePreview);
+        emitter.on('roof:click', onRoofClick);
+        emitter.on('roof:leave', clearTarget);
+        emitter.on('tool:cancel', onCancel);
+        window.addEventListener('pointerup', onPlacementDragPointerUp);
+        return () => {
+            emitter.off('roof:move', updatePreview);
+            emitter.off('roof:enter', updatePreview);
+            emitter.off('roof:click', onRoofClick);
+            emitter.off('roof:leave', clearTarget);
+            emitter.off('tool:cancel', onCancel);
+            window.removeEventListener('pointerup', onPlacementDragPointerUp);
+            const obj = sceneRegistry.nodes.get(node.id);
+            if (obj)
+                obj.visible = true;
+            clearRoofSurfacePlacementGuides();
+            useScene.temporal.getState().resume();
+        };
+    }, [exitMoveMode, node]);
+    if (!target)
+        return null;
+    return (_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: node }) }) }) }));
+}

package/dist/gutter/outlet-lookup.d.ts

@@ -0,0 +1,43 @@
+import type { GutterNode } from '@pascal-app/core';
+import { type OutletShape } from './profile-geometry';
+/**
+ * Outlet position lookup — used by the downspout (renderer / tool /
+ * routing) to mount a pipe at one of the gutter's outlets without
+ * walking the gutter's geometry pipeline.
+ *
+ * Returns the outlet's center in GUTTER-MESH-LOCAL frame (i.e. after
+ * the gutter's own `position` + `rotation` have already been applied
+ * by the renderer chain): X is along the gutter length, Y is the
+ * gutter's vertical extent (−size, the trough floor), Z is outward
+ * (the profile-dependent floor midpoint).
+ *
+ * The clamp mirrors the geometry's `resolveOutletPlacements` so the
+ * lookup and the drilled hole agree on X. Ignores mitres — when a
+ * gutter end is mitred its cap collapses, which shifts the clamp bound
+ * by ≤ 6 mm; the drift is below what reads visually, and the gutter's
+ * own CSG drill still cuts in the exact spot since it sees the full
+ * mitre context.
+ */
+export type GutterOutletPlacement = {
+    /** Gutter-mesh-local X — along the length axis, signed from center. */
+    x: number;
+    /** Gutter-mesh-local Y — the trough floor at −size. */
+    y: number;
+    /** Gutter-mesh-local Z — profile-dependent floor midpoint. */
+    z: number;
+    /** Nominal bore radius (= halfX); `bore * 2` is the outlet diameter. */
+    bore: number;
+    /** Outlet cross-section — round on half-round, rect on k-style / box. */
+    shape: OutletShape;
+    /** Bore half-extent along the gutter length (X) — the pipe nests just inside this. */
+    innerHalfX: number;
+    /** Bore half-extent outward (Z) — the pipe nests just inside this. */
+    innerHalfZ: number;
+};
+/** Placement of the gutter's outlet with the given id, or null if absent / doesn't fit. */
+export declare function resolveGutterOutletById(gutter: GutterNode, outletId: string | undefined): GutterOutletPlacement | null;
+/** Placements for every fitting outlet, tagged with its id. */
+export declare function resolveGutterOutlets(gutter: GutterNode): Array<GutterOutletPlacement & {
+    id: string;
+}>;
+//# sourceMappingURL=outlet-lookup.d.ts.map

package/dist/gutter/outlet-lookup.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"outlet-lookup.d.ts","sourceRoot":"","sources":["../../src/gutter/outlet-lookup.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAgB,MAAM,kBAAkB,CAAA;AAChE,OAAO,EAEL,KAAK,WAAW,EAIjB,MAAM,oBAAoB,CAAA;AAE3B;;;;;;;;;;;;;;;;;GAiBG;AAEH,MAAM,MAAM,qBAAqB,GAAG;IAClC,uEAAuE;IACvE,CAAC,EAAE,MAAM,CAAA;IACT,uDAAuD;IACvD,CAAC,EAAE,MAAM,CAAA;IACT,8DAA8D;IAC9D,CAAC,EAAE,MAAM,CAAA;IACT,wEAAwE;IACxE,IAAI,EAAE,MAAM,CAAA;IACZ,yEAAyE;IACzE,KAAK,EAAE,WAAW,CAAA;IAClB,sFAAsF;IACtF,UAAU,EAAE,MAAM,CAAA;IAClB,sEAAsE;IACtE,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAwCD,2FAA2F;AAC3F,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,UAAU,EAClB,QAAQ,EAAE,MAAM,GAAG,SAAS,GAC3B,qBAAqB,GAAG,IAAI,CAM9B;AAED,+DAA+D;AAC/D,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,UAAU,GACjB,KAAK,CAAC,qBAAqB,GAAG;IAAE,EAAE,EAAE,MAAM,CAAA;CAAE,CAAC,CAQ/C"}

package/dist/gutter/outlet-lookup.js

@@ -0,0 +1,50 @@
+import { OUTLET_WALL_THICKNESS, outletDims, outletShapeForProfile, profileFloorMidZ, } from './profile-geometry';
+function placeOutlet(gutter, outlet, len, size, t) {
+    const shape = outletShapeForProfile(gutter.profile);
+    const inner = outletDims(shape, outlet.diameter ?? 0.07);
+    const outerHalfX = inner.halfX + OUTLET_WALL_THICKNESS;
+    // Default-cap reservation — no mitre awareness here; see header note.
+    const capLeftLen = (gutter.endCapLeft ?? true) ? t : 0;
+    const capRightLen = (gutter.endCapRight ?? true) ? t : 0;
+    const minX = -len / 2 + capLeftLen + outerHalfX;
+    const maxX = len / 2 - capRightLen - outerHalfX;
+    if (maxX <= minX)
+        return null;
+    const x = Math.max(minX, Math.min(maxX, outlet.offset ?? 0));
+    return {
+        x,
+        y: -size,
+        z: profileFloorMidZ(gutter.profile ?? 'k-style', size),
+        bore: inner.halfX,
+        shape,
+        innerHalfX: inner.halfX,
+        innerHalfZ: inner.halfZ,
+    };
+}
+function gutterDims(gutter) {
+    const len = Math.max(0.05, gutter.length);
+    const size = Math.max(0.04, gutter.size);
+    const t = Math.min(Math.max(0.001, gutter.thickness), size * 0.4);
+    return { len, size, t };
+}
+/** Placement of the gutter's outlet with the given id, or null if absent / doesn't fit. */
+export function resolveGutterOutletById(gutter, outletId) {
+    if (!outletId)
+        return null;
+    const outlet = (gutter.outlets ?? []).find((o) => o.id === outletId);
+    if (!outlet)
+        return null;
+    const { len, size, t } = gutterDims(gutter);
+    return placeOutlet(gutter, outlet, len, size, t);
+}
+/** Placements for every fitting outlet, tagged with its id. */
+export function resolveGutterOutlets(gutter) {
+    const { len, size, t } = gutterDims(gutter);
+    const out = [];
+    for (const outlet of gutter.outlets ?? []) {
+        const p = placeOutlet(gutter, outlet, len, size, t);
+        if (p)
+            out.push({ ...p, id: outlet.id });
+    }
+    return out;
+}

package/dist/gutter/parametrics.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/gutter/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAC5D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAE1C,eAAO,MAAM,iBAAiB,EAAE,oBAAoB,CAAC,UAAU,CA6D9D,CAAA"}

package/dist/gutter/parametrics.js

@@ -0,0 +1,62 @@
+export const gutterParametrics = {
+    groups: [
+        {
+            label: 'Profile',
+            fields: [
+                {
+                    key: 'profile',
+                    kind: 'enum',
+                    options: ['k-style', 'half-round', 'box'],
+                    display: 'segmented',
+                },
+            ],
+        },
+        {
+            label: 'Dimensions',
+            fields: [
+                { key: 'length', kind: 'number', unit: 'm', min: 0.2, max: 12, step: 0.05 },
+                { key: 'size', kind: 'number', unit: 'm', min: 0.05, max: 0.3, step: 0.005 },
+                {
+                    key: 'thickness',
+                    kind: 'number',
+                    unit: 'm',
+                    min: 0.001,
+                    max: 0.02,
+                    step: 0.001,
+                },
+            ],
+        },
+        {
+            label: 'End caps',
+            fields: [
+                { key: 'endCapLeft', kind: 'boolean' },
+                { key: 'endCapRight', kind: 'boolean' },
+            ],
+        },
+        {
+            label: 'Hangers',
+            fields: [
+                {
+                    key: 'hangerStyle',
+                    kind: 'enum',
+                    options: ['strap', 'none'],
+                    display: 'segmented',
+                },
+                {
+                    key: 'hangerSpacing',
+                    kind: 'number',
+                    unit: 'm',
+                    min: 0.2,
+                    max: 2.0,
+                    step: 0.05,
+                    visibleIf: (n) => (n.hangerStyle ?? 'strap') !== 'none',
+                },
+            ],
+        },
+    ],
+    // Lazy-loaded section that lists every downspout attached to this
+    // gutter and offers an Add button at the bottom. Outlets are created
+    // and removed through this panel (and the downspout placement tool) —
+    // one outlet per downspout — so there's no separate outlet field group.
+    trailingSection: () => import('./downspouts-panel'),
+};

package/dist/gutter/preview.d.ts

@@ -0,0 +1,22 @@
+import type { GutterNode } from './schema';
+/**
+ * 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.
+ */
+declare const GutterPreview: ({ node, invalid }: {
+    node: GutterNode;
+    invalid?: boolean;
+}) => import("react").JSX.Element;
+export default GutterPreview;
+//# sourceMappingURL=preview.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"preview.d.ts","sourceRoot":"","sources":["../../src/gutter/preview.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAE1C;;;;;;;;;;;;;;GAcG;AACH,QAAA,MAAM,aAAa,GAAI,mBAAmB;IAAE,IAAI,EAAE,UAAU,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,gCA0DhF,CAAA;AAED,eAAe,aAAa,CAAA"}