@pascal-app/nodes 0.1.1

package/dist/guide/renderer.js

@@ -0,0 +1,52 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useRegistry } from '@pascal-app/core';
+import { useAssetUrl, useViewer } from '@pascal-app/viewer';
+import { useLoader } from '@react-three/fiber';
+import { Suspense, useEffect, useMemo, useRef } from 'react';
+import { DoubleSide, PlaneGeometry, TextureLoader } from 'three';
+import { float, texture } from 'three/tsl';
+import { MeshBasicNodeMaterial } from 'three/webgpu';
+export const GuideRenderer = ({ node }) => {
+    const showGuides = useViewer((s) => s.showGuides);
+    const ref = useRef(null);
+    useRegistry(node.id, 'guide', ref);
+    const resolvedUrl = useAssetUrl(node.url);
+    return (_jsx("group", { position: node.position, ref: ref, rotation: [0, node.rotation[1], 0], visible: showGuides && node.visible !== false, children: resolvedUrl && (_jsx(Suspense, { children: _jsx(GuidePlane, { opacity: node.opacity, scale: node.scale, url: resolvedUrl }) })) }));
+};
+const GuidePlane = ({ url, scale, opacity }) => {
+    const tex = useLoader(TextureLoader, url);
+    // Pass the geometry as a prop. JSX-child `<planeGeometry>` plus
+    // `frustumCulled={false}` lets the mesh submit a first-frame draw
+    // with R3F's empty placeholder BufferGeometry before the child
+    // attaches — WebGPU then flags "Vertex buffer slot 0 required by
+    // [RenderPipeline renderPipeline_MeshBasicNodeMaterial_NNNN] was
+    // not set." Same fix as wall-move-side-handles.tsx / grid.tsx.
+    const { geometry, material } = useMemo(() => {
+        const img = tex.image;
+        const w = img.width || 1;
+        const h = img.height || 1;
+        const aspect = w / h;
+        // Default: 10 meters wide, height from aspect ratio
+        const planeWidth = 10 * scale;
+        const planeHeight = (10 / aspect) * scale;
+        const normalizedOpacity = opacity / 100;
+        const mat = new MeshBasicNodeMaterial({
+            transparent: true,
+            colorNode: texture(tex),
+            opacityNode: float(normalizedOpacity),
+            side: DoubleSide,
+            depthWrite: false,
+        });
+        const geom = new PlaneGeometry(planeWidth, planeHeight);
+        geom.boundingBox = null;
+        geom.boundingSphere = null;
+        return { geometry: geom, material: mat };
+    }, [tex, scale, opacity]);
+    useEffect(() => () => {
+        geometry.dispose();
+        material.dispose();
+    }, [geometry, material]);
+    return (_jsx("mesh", { frustumCulled: false, geometry: geometry, material: material, raycast: () => { }, rotation: [-Math.PI / 2, 0, 0] }));
+};
+export default GuideRenderer;

package/dist/guide/schema.d.ts

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

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

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

package/dist/guide/schema.js

@@ -0,0 +1 @@
+export { GuideNode } from '@pascal-app/core';

package/dist/guide/system.d.ts

@@ -0,0 +1,3 @@
+import { GuideSystem } from '@pascal-app/viewer';
+export default GuideSystem;
+//# sourceMappingURL=system.d.ts.map

package/dist/guide/system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/guide/system.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAEhD,eAAe,WAAW,CAAA"}

package/dist/guide/system.js

@@ -0,0 +1,3 @@
+'use client';
+import { GuideSystem } from '@pascal-app/viewer';
+export default GuideSystem;

package/dist/gutter/corner-mitre.d.ts

@@ -0,0 +1,88 @@
+import type { GutterNode, RoofSegmentNode } from '@pascal-app/core';
+/**
+ * Auto-mitre detector for two gutters meeting at a roof corner.
+ *
+ * When two gutters' endpoints land within `CORNER_EPSILON` of each
+ * other in plan (ROOF-local X/Z — see `planDistSq`), the renderer
+ * treats them as a single L-junction and skews each end so the back
+ * walls meet at the inner corner while the front rims extend outward to
+ * a clean mitre.
+ *
+ * Why "back wall stays at the corner": the gutter mounts against the
+ * fascia (gutter-local +X is the length, +Z is outward over the eave).
+ * Two perpendicular fascias meet at the eave corner — that's the
+ * fixed point. The rims hang in space past the building, so they're
+ * the parts that need to extend to actually touch each other.
+ *
+ * For 90° (typical hip / rectangular plan) corners the mitre is 45°
+ * each side; arbitrary angles use the standard mitre formula
+ * `(π − interior) / 2`. Aligned gutters (interior ≈ π) → mitre 0 → no
+ * displacement, no cap suppression — they read as a straight run.
+ *
+ * Cross-segment: endpoints + length axes are lifted into the shared
+ * ROOF frame (each gutter's segment position + Y-rotation applied), so
+ * gutters on DIFFERENT roof segments (L-shaped plans, additions) mitre
+ * at the corner where their segments meet — not just gutters sharing a
+ * segment. Same-segment corners fall out of the same path (both gutters
+ * carry the same segment transform). The skew assumes a convex (outer)
+ * corner; a concave inner corner mitres approximately.
+ */
+export type GutterMitres = {
+    /**
+     * SIGNED mitre angle (radians) at the gutter's −X end; 0 = no mitre.
+     * Positive = CONVEX (outer) corner — the front rim EXTENDS past the
+     * end to reach the outer eave intersection. Negative = CONCAVE (inner)
+     * corner — the rim RETRACTS to the inner intersection. The geometry
+     * builder feeds the value straight through `Math.tan`, so the sign
+     * flips the skew direction; `=== 0` still means "no mitre / keep cap".
+     */
+    left: number;
+    /** Signed mitre angle (radians) at the gutter's +X end; see `left`. */
+    right: number;
+};
+export declare const NO_MITRES: GutterMitres;
+export declare const CORNER_EPSILON_SQ: number;
+/** A sibling gutter paired with the segment it sits on, for the frame lift. */
+export type GutterWithSegment = {
+    gutter: GutterNode;
+    segment: Pick<RoofSegmentNode, 'position' | 'rotation'>;
+};
+export type Endpoint = {
+    pos: readonly [number, number, number];
+    /** Length-axis direction in segment frame, pointing from this end toward the other end. */
+    awayDir: readonly [number, number];
+    /** Outward normal (gutter-local +Z, "away from the building") in this frame. */
+    outDir: readonly [number, number];
+};
+/**
+ * Gutter endpoints lifted from segment-local into the shared ROOF frame
+ * by applying the host segment's position + Y-rotation. Two gutters on
+ * different segments can then be compared in one frame. THREE's
+ * rotation-y convention: a point/dir (x, z) rotates to
+ * (x·cos + z·sin, −x·sin + z·cos).
+ */
+export declare function gutterEndpointsInFrame(g: GutterNode, segment: Pick<RoofSegmentNode, 'position' | 'rotation'>): {
+    plus: Endpoint;
+    minus: Endpoint;
+};
+export declare function planDistSq(a: readonly [number, number, number], b: readonly [number, number, number]): number;
+/**
+ * Compute mitres for `subject` against every other gutter under the
+ * same parent.
+ *
+ * A corner is the INTERSECTION of the two gutters' length-axis lines —
+ * not the proximity of their endpoints. This is what makes inner
+ * (concave) corners work: there the two eave drip-lines meet out in the
+ * notch, a full overhang away from where either gutter naturally ends,
+ * so an endpoint-to-endpoint test never fired. Keying off the axis
+ * crossing treats convex and concave identically. The length-snap pulls
+ * both ends out to that shared point, so by the time we mitre the
+ * subject's end AND the sibling's end both sit on the intersection — we
+ * require both to be within `CORNER_EPSILON` of it, which also rejects
+ * runs that merely cross in the middle (a T, not an L).
+ *
+ * First match per end wins; siblings order is the caller's, so the
+ * result is deterministic.
+ */
+export declare function computeGutterMitres(subject: GutterNode, subjectSegment: Pick<RoofSegmentNode, 'position' | 'rotation'>, siblings: readonly GutterWithSegment[]): GutterMitres;
+//# sourceMappingURL=corner-mitre.d.ts.map

package/dist/gutter/corner-mitre.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"corner-mitre.d.ts","sourceRoot":"","sources":["../../src/gutter/corner-mitre.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAEnE;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,MAAM,MAAM,YAAY,GAAG;IACzB;;;;;;;OAOG;IACH,IAAI,EAAE,MAAM,CAAA;IACZ,uEAAuE;IACvE,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,eAAO,MAAM,SAAS,EAAE,YAAoC,CAAA;AAQ5D,eAAO,MAAM,iBAAiB,QAAkC,CAAA;AAYhE,+EAA+E;AAC/E,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,UAAU,CAAA;IAClB,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,UAAU,GAAG,UAAU,CAAC,CAAA;CACxD,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG;IACrB,GAAG,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IACtC,2FAA2F;IAC3F,OAAO,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,gFAAgF;IAChF,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAClC,CAAA;AA6BD;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,CAAC,EAAE,UAAU,EACb,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,UAAU,GAAG,UAAU,CAAC,GACtD;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,QAAQ,CAAA;CAAE,CA4BrC;AAUD,wBAAgB,UAAU,CACxB,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EACpC,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GACnC,MAAM,CAIR;AA2CD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,UAAU,EACnB,cAAc,EAAE,IAAI,CAAC,eAAe,EAAE,UAAU,GAAG,UAAU,CAAC,EAC9D,QAAQ,EAAE,SAAS,iBAAiB,EAAE,GACrC,YAAY,CAqCd"}

package/dist/gutter/corner-mitre.js

@@ -0,0 +1,176 @@
+export const NO_MITRES = { left: 0, right: 0 };
+// Match the length-snap's 10 cm catch radius (`length-snap.ts`): any two
+// endpoints close enough for the corner snap to bind are close enough to
+// read as "they meant to meet". The corner snap pulls them to the exact
+// eave intersection (≈ 0 cm), so this is mostly slack for eyeballed /
+// move-tool corners that never went through the length handle.
+const CORNER_EPSILON = 0.1;
+export const CORNER_EPSILON_SQ = CORNER_EPSILON * CORNER_EPSILON;
+// Mitres beyond this are unphysical (an acute outer corner past 30°
+// interior angle isn't a building corner, it's a CSG artefact). Capping
+// keeps a misplaced gutter from producing a runaway skew that swallows
+// the rest of the trough.
+const MAX_MITRE = (75 * Math.PI) / 180;
+// Cross product below this magnitude counts as parallel length-axes — a
+// straight collinear run, no corner. Matches `length-snap.ts`.
+const AXIS_PARALLEL_EPSILON = 1e-3;
+function gutterEndpoints(g) {
+    const [px, py, pz] = g.position;
+    const r = g.rotation ?? 0;
+    // Gutter-local +X (length axis) rotated by `r` around Y. THREE's
+    // rotation-y convention: local (1, 0, 0) → (cos r, 0, −sin r).
+    const dirX = Math.cos(r);
+    const dirZ = -Math.sin(r);
+    // Gutter-local +Z (outward) rotated by `r`: (0, 0, 1) → (sin r, 0, cos r).
+    const outX = Math.sin(r);
+    const outZ = Math.cos(r);
+    const half = g.length / 2;
+    return {
+        plus: {
+            pos: [px + dirX * half, py, pz + dirZ * half],
+            // From the +X endpoint, the rest of the gutter extends back
+            // toward the −X end — so "away from this end" is −dir.
+            awayDir: [-dirX, -dirZ],
+            outDir: [outX, outZ],
+        },
+        minus: {
+            pos: [px - dirX * half, py, pz - dirZ * half],
+            awayDir: [dirX, dirZ],
+            outDir: [outX, outZ],
+        },
+    };
+}
+/**
+ * Gutter endpoints lifted from segment-local into the shared ROOF frame
+ * by applying the host segment's position + Y-rotation. Two gutters on
+ * different segments can then be compared in one frame. THREE's
+ * rotation-y convention: a point/dir (x, z) rotates to
+ * (x·cos + z·sin, −x·sin + z·cos).
+ */
+export function gutterEndpointsInFrame(g, segment) {
+    const local = gutterEndpoints(g);
+    const sx = segment.position?.[0] ?? 0;
+    const sz = segment.position?.[2] ?? 0;
+    const sr = segment.rotation ?? 0;
+    const c = Math.cos(sr);
+    const s = Math.sin(sr);
+    const liftPos = (p) => [
+        sx + (p[0] * c + p[2] * s),
+        p[1],
+        sz + (-p[0] * s + p[2] * c),
+    ];
+    const liftDir = (d) => [
+        d[0] * c + d[1] * s,
+        -d[0] * s + d[1] * c,
+    ];
+    return {
+        plus: {
+            pos: liftPos(local.plus.pos),
+            awayDir: liftDir(local.plus.awayDir),
+            outDir: liftDir(local.plus.outDir),
+        },
+        minus: {
+            pos: liftPos(local.minus.pos),
+            awayDir: liftDir(local.minus.awayDir),
+            outDir: liftDir(local.minus.outDir),
+        },
+    };
+}
+// Plan-space (X/Z) distance only — deliberately ignores Y. Gutters are
+// pinned to the eave line so they're coplanar in eave-Y, AND the
+// renderer draws them at the LIVE `computeEaveY(segment)`, not the
+// stored `position[1]` (which goes stale if the segment's wallHeight /
+// pitch changed after placement). Folding Y in would reject a real
+// corner whenever two gutters' stored Ys drifted apart even though they
+// visibly meet. The length-snap that feeds this also works purely in
+// plan, so the match must too.
+export function planDistSq(a, b) {
+    const dx = a[0] - b[0];
+    const dz = a[2] - b[2];
+    return dx * dx + dz * dz;
+}
+function mitreBetween(a, b) {
+    // Both `awayDir`s point from the corner toward the FAR end of their
+    // gutter. The interior angle of the joint is the angle between them.
+    // Mitre = half the supplementary angle (standard carpenter formula).
+    const dot = a.awayDir[0] * b.awayDir[0] + a.awayDir[1] * b.awayDir[1];
+    const clamped = Math.max(-1, Math.min(1, dot));
+    const interior = Math.acos(clamped);
+    const mitre = (Math.PI - interior) / 2;
+    // Aligned-or-nearly so → straight run, no mitre needed.
+    if (mitre < 1e-3)
+        return 0;
+    // Convex vs concave. `a.outDir` is THIS gutter's outward normal; `b`'s
+    // body runs from the corner along `b.awayDir`. On a CONVEX (outer)
+    // corner the neighbour's body sits on the INWARD side of our rim, so
+    // `b.awayDir · a.outDir < 0` (it heads away from our outward face) —
+    // the rim must EXTEND (positive). On a CONCAVE (inner) corner the
+    // neighbour's body sits on our OUTWARD side (`· > 0`) and the rim must
+    // RETRACT (negative) to the inner intersection.
+    const concave = b.awayDir[0] * a.outDir[0] + b.awayDir[1] * a.outDir[1] > 0;
+    const signed = concave ? -mitre : mitre;
+    return Math.max(-MAX_MITRE, Math.min(MAX_MITRE, signed));
+}
+// Intersection (in plan X/Z) of two infinite length-axis lines, each
+// given as a point + run direction. Returns null when the runs are
+// parallel (no single crossing — a straight collinear run, not a
+// corner). Mirrors the `length-snap.ts` corner solve.
+function axisIntersectionXZ(aPos, aDir, bPos, bDir) {
+    const cross = aDir[0] * bDir[1] - aDir[1] * bDir[0];
+    if (Math.abs(cross) < AXIS_PARALLEL_EPSILON)
+        return null;
+    const dx = bPos[0] - aPos[0];
+    const dz = bPos[2] - aPos[2];
+    const t = (dx * bDir[1] - dz * bDir[0]) / cross;
+    return [aPos[0] + t * aDir[0], 0, aPos[2] + t * aDir[1]];
+}
+/**
+ * Compute mitres for `subject` against every other gutter under the
+ * same parent.
+ *
+ * A corner is the INTERSECTION of the two gutters' length-axis lines —
+ * not the proximity of their endpoints. This is what makes inner
+ * (concave) corners work: there the two eave drip-lines meet out in the
+ * notch, a full overhang away from where either gutter naturally ends,
+ * so an endpoint-to-endpoint test never fired. Keying off the axis
+ * crossing treats convex and concave identically. The length-snap pulls
+ * both ends out to that shared point, so by the time we mitre the
+ * subject's end AND the sibling's end both sit on the intersection — we
+ * require both to be within `CORNER_EPSILON` of it, which also rejects
+ * runs that merely cross in the middle (a T, not an L).
+ *
+ * First match per end wins; siblings order is the caller's, so the
+ * result is deterministic.
+ */
+export function computeGutterMitres(subject, subjectSegment, siblings) {
+    if (siblings.length === 0)
+        return NO_MITRES;
+    const subj = gutterEndpointsInFrame(subject, subjectSegment);
+    let leftMitre = 0;
+    let rightMitre = 0;
+    for (const sib of siblings) {
+        if (sib.gutter.id === subject.id)
+            continue;
+        const other = gutterEndpointsInFrame(sib.gutter, sib.segment);
+        // `minus.awayDir` runs from the −X end toward +X, i.e. along the
+        // length — so it's a valid direction for either gutter's axis line.
+        const corner = axisIntersectionXZ(subj.minus.pos, subj.minus.awayDir, other.minus.pos, other.minus.awayDir);
+        if (!corner)
+            continue;
+        // The sibling end that sits on the corner is the one we mitre against.
+        const otherPlusAtCorner = planDistSq(other.plus.pos, corner) <= CORNER_EPSILON_SQ;
+        const otherMinusAtCorner = planDistSq(other.minus.pos, corner) <= CORNER_EPSILON_SQ;
+        if (!otherPlusAtCorner && !otherMinusAtCorner)
+            continue;
+        const otherEnd = otherPlusAtCorner ? other.plus : other.minus;
+        if (leftMitre === 0 && planDistSq(subj.minus.pos, corner) <= CORNER_EPSILON_SQ) {
+            leftMitre = mitreBetween(subj.minus, otherEnd);
+        }
+        if (rightMitre === 0 && planDistSq(subj.plus.pos, corner) <= CORNER_EPSILON_SQ) {
+            rightMitre = mitreBetween(subj.plus, otherEnd);
+        }
+        if (leftMitre !== 0 && rightMitre !== 0)
+            break;
+    }
+    return { left: leftMitre, right: rightMitre };
+}

package/dist/gutter/definition.d.ts

@@ -0,0 +1,19 @@
+import { type NodeDefinition } from '@pascal-app/core';
+import { GutterNode } from './schema';
+/**
+ * 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 declare const gutterDefinition: NodeDefinition<typeof GutterNode>;
+//# sourceMappingURL=definition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/gutter/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,cAAc,EACpB,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AA8GrC;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CA2D9D,CAAA"}

package/dist/gutter/definition.js

@@ -0,0 +1,164 @@
+import { GutterNode as GutterNodeSchema, } from '@pascal-app/core';
+import { buildGutterFloorplan } from './floorplan';
+import { snapLengthToCorner } from './length-snap';
+import { gutterParametrics } from './parametrics';
+import { GutterNode } from './schema';
+// 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` overrides the raw newLength so the endpoint lands
+// EXACTLY on that corner — the corner-mitre detector then fires reliably
+// without pixel-perfect dragging. 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,
+        currentValue: (n) => n.length,
+        apply: (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;
+            const snap = snapLengthToCorner(initial, newLength, sign, anchorX, anchorZ, armX, armZ, MIN_LENGTH, sceneApi);
+            // Only the dragged gutter's own length is snapped — `snapLengthToCorner`
+            // never moves the corner-mate, so dragging one gutter can't reset
+            // another the user placed deliberately.
+            const newCenterX = anchorX + sign * (snap.length / 2) * armX;
+            const newCenterZ = anchorZ + sign * (snap.length / 2) * armZ;
+            return {
+                length: snap.length,
+                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,
+        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: 1,
+    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: {
+        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: {},
+    },
+    parametrics: gutterParametrics,
+    handles: gutterHandles,
+    floorplan: buildGutterFloorplan,
+    floorplanDependsOnSiblings: true,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer'),
+    },
+    preview: () => import('./preview'),
+    tool: () => import('./tool'),
+    affordanceTools: {
+        move: () => import('./move-tool'),
+    },
+    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/roof.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/downspouts-panel.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Downspouts subsection at the bottom of the gutter inspector. Lists the
+ * downspouts attached to this gutter (one per outlet); "Add Downspout"
+ * drills a fresh outlet at a spread-out position and drops a downspout
+ * on it, and each row's ✕ removes both the downspout and its outlet.
+ */
+export default function DownspoutsPanel(): import("react").JSX.Element | null;
+//# sourceMappingURL=downspouts-panel.d.ts.map

package/dist/gutter/downspouts-panel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"downspouts-panel.d.ts","sourceRoot":"","sources":["../../src/gutter/downspouts-panel.tsx"],"names":[],"mappings":"AAmDA;;;;;GAKG;AACH,MAAM,CAAC,OAAO,UAAU,eAAe,uCAuGtC"}

package/dist/gutter/downspouts-panel.js

@@ -0,0 +1,111 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { DownspoutNode, generateId, useScene, } from '@pascal-app/core';
+import { ActionButton, ActionGroup, PanelSection, triggerSFX } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useShallow } from 'zustand/react/shallow';
+import { computeEaveY } from './eave-snap';
+import { resolveGutterOutletById } from './outlet-lookup';
+const DEFAULT_OUTLET_DIAMETER = 0.07;
+/**
+ * Pick an along-length offset for a new outlet that doesn't land on an
+ * existing one: the first goes near the right end, the rest drop into
+ * the midpoint of the widest gap (including the gaps to each end). So
+ * "Add Downspout" repeatedly spreads outlets along the run instead of
+ * stacking them.
+ */
+function nextOutletOffset(gutter) {
+    const len = Math.max(0.05, gutter.length);
+    const margin = 0.12;
+    const lo = -len / 2 + margin;
+    const hi = len / 2 - margin;
+    if (hi <= lo)
+        return 0;
+    const existing = (gutter.outlets ?? [])
+        .map((o) => Math.max(lo, Math.min(hi, o.offset ?? 0)))
+        .sort((a, b) => a - b);
+    if (existing.length === 0)
+        return hi;
+    const bounds = [lo, ...existing, hi];
+    let bestMid = (lo + hi) / 2;
+    let bestGap = -1;
+    for (let i = 0; i < bounds.length - 1; i++) {
+        const gap = bounds[i + 1] - bounds[i];
+        if (gap > bestGap) {
+            bestGap = gap;
+            bestMid = (bounds[i] + bounds[i + 1]) / 2;
+        }
+    }
+    return bestMid;
+}
+/**
+ * Downspouts subsection at the bottom of the gutter inspector. Lists the
+ * downspouts attached to this gutter (one per outlet); "Add Downspout"
+ * drills a fresh outlet at a spread-out position and drops a downspout
+ * on it, and each row's ✕ removes both the downspout and its outlet.
+ */
+export default function DownspoutsPanel() {
+    const selectedId = useViewer((s) => s.selection.selectedIds[0]);
+    const setSelection = useViewer((s) => s.setSelection);
+    const gutter = useScene((s) => selectedId ? s.nodes[selectedId] : undefined);
+    const downspouts = useScene(useShallow((s) => {
+        if (!selectedId)
+            return [];
+        const out = [];
+        for (const n of Object.values(s.nodes)) {
+            if (n?.type === 'downspout' && n.gutterId === selectedId) {
+                out.push(n);
+            }
+        }
+        return out;
+    }));
+    if (gutter?.type !== 'gutter')
+        return null;
+    const handleSelectDownspout = (id) => {
+        setSelection({ selectedIds: [id] });
+    };
+    const handleAddDownspout = () => {
+        const segmentId = gutter.roofSegmentId;
+        if (!segmentId)
+            return;
+        const segment = useScene.getState().nodes[segmentId];
+        if (!segment)
+            return;
+        const outletId = generateId('outlet');
+        const outlets = [
+            ...(gutter.outlets ?? []),
+            { id: outletId, offset: nextOutletOffset(gutter), diameter: DEFAULT_OUTLET_DIAMETER },
+        ];
+        const state = useScene.getState();
+        state.updateNode(gutter.id, { outlets });
+        state.dirtyNodes.add(gutter.id);
+        const outlet = resolveGutterOutletById({ ...gutter, outlets }, outletId);
+        const dropLength = Math.max(0.1, computeEaveY(segment) + (outlet?.y ?? -gutter.size));
+        const downspout = DownspoutNode.parse({
+            name: 'Downspout',
+            gutterId: gutter.id,
+            outletId,
+            length: dropLength,
+            diameter: (outlet?.bore ?? DEFAULT_OUTLET_DIAMETER / 2) * 2,
+        });
+        state.createNode(downspout, segmentId);
+        state.dirtyNodes.add(segmentId);
+        setSelection({ selectedIds: [downspout.id] });
+        triggerSFX('sfx:item-place');
+    };
+    const handleRemove = (downspout) => {
+        const state = useScene.getState();
+        // Drop the outlet this downspout drained so its hole closes up.
+        if (downspout.outletId) {
+            state.updateNode(gutter.id, {
+                outlets: (gutter.outlets ?? []).filter((o) => o.id !== downspout.outletId),
+            });
+            state.dirtyNodes.add(gutter.id);
+        }
+        state.deleteNode(downspout.id);
+        if (gutter.roofSegmentId)
+            state.dirtyNodes.add(gutter.roofSegmentId);
+        setSelection({ selectedIds: [gutter.id] });
+    };
+    return (_jsx(PanelSection, { title: "Downspouts", children: _jsxs("div", { className: "flex flex-col gap-1", children: [downspouts.map((d, i) => (_jsxs("div", { className: "flex items-center justify-between rounded-lg border border-border/50 bg-[#2C2C2E] px-3 py-2 text-foreground text-sm", children: [_jsx("button", { className: "flex-1 truncate text-left transition-colors hover:text-white", onClick: () => handleSelectDownspout(d.id), type: "button", children: d.name || `Downspout ${i + 1}` }), _jsx("button", { "aria-label": "Remove downspout", className: "ml-2 text-muted-foreground text-xs transition-colors hover:text-red-400", onClick: () => handleRemove(d), type: "button", children: "\u2715" })] }, d.id))), _jsx(ActionGroup, { children: _jsx(ActionButton, { label: "Add Downspout", onClick: handleAddDownspout }) })] }) }));
+}