@pascal-app/nodes 0.1.1

package/dist/gutter/eave-align.d.ts

@@ -0,0 +1,33 @@
+import type { GutterNode, RoofSegmentNode } from '@pascal-app/core';
+/**
+ * Shared eave-Y for a connected run of gutters.
+ *
+ * Each gutter normally derives its mount height independently from its
+ * own host segment via `computeEaveY` (wallHeight − overhang·tan(pitch)
+ * + tuck, or wallHeight on a flat deck). Two segments that read as the
+ * same height in the inspector can still land at different eave Ys when
+ * their pitch / overhang / roofType differ — so gutters that meet at a
+ * corner inherit two heights and the run visibly steps at the joint.
+ *
+ * This walks the connected component of gutters that meet at corners
+ * (same plan-space endpoint test the mitre detector uses — Y is
+ * deliberately ignored, so the grouping survives the very height drift
+ * we're correcting) and returns ONE height for the whole run: the
+ * HIGHEST member eave. Aligning up means no gutter ever sinks into a
+ * roof surface; a lower roof gets a small fascia gap, which reads
+ * cleaner than a gutter clipping through its slope.
+ *
+ * Deterministic + symmetric: every gutter in the run computes the same
+ * component and the same max, so they all converge on the identical Y
+ * without any shared coordinator or store write. Isolated gutters (no
+ * corner neighbour) get their own eave Y unchanged.
+ *
+ * Pure: no React, no scene access, no store mutation.
+ */
+/** A sibling gutter paired with its FULL host segment (needs the eave-Y inputs). */
+export type GutterWithSegment = {
+    gutter: GutterNode;
+    segment: RoofSegmentNode;
+};
+export declare function computeSharedEaveY(subject: GutterNode, subjectSegment: RoofSegmentNode, siblings: readonly GutterWithSegment[]): number;
+//# sourceMappingURL=eave-align.d.ts.map

package/dist/gutter/eave-align.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eave-align.d.ts","sourceRoot":"","sources":["../../src/gutter/eave-align.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAInE;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,oFAAoF;AACpF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,MAAM,EAAE,UAAU,CAAA;IAClB,OAAO,EAAE,eAAe,CAAA;CACzB,CAAA;AA2BD,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,UAAU,EACnB,cAAc,EAAE,eAAe,EAC/B,QAAQ,EAAE,SAAS,iBAAiB,EAAE,GACrC,MAAM,CA+BR"}

package/dist/gutter/eave-align.js

@@ -0,0 +1,50 @@
+import { CORNER_EPSILON_SQ, gutterEndpointsInFrame, planDistSq } from './corner-mitre';
+import { computeEaveY } from './eave-snap';
+function guttersMeet(a, aSeg, b, bSeg) {
+    const ea = gutterEndpointsInFrame(a, aSeg);
+    const eb = gutterEndpointsInFrame(b, bSeg);
+    return (planDistSq(ea.minus.pos, eb.plus.pos) <= CORNER_EPSILON_SQ ||
+        planDistSq(ea.minus.pos, eb.minus.pos) <= CORNER_EPSILON_SQ ||
+        planDistSq(ea.plus.pos, eb.plus.pos) <= CORNER_EPSILON_SQ ||
+        planDistSq(ea.plus.pos, eb.minus.pos) <= CORNER_EPSILON_SQ);
+}
+// Each gutter mounts at `segment.position[1] + computeEaveY(segment)` in
+// the roof frame (the renderer adds the segment-local eave Y under the
+// segment's group). Segments can sit at different Y offsets, so the run
+// has to be compared — and the answer returned — in the SHARED roof
+// frame, not raw segment-local eave Ys.
+function worldEaveY(segment) {
+    return (segment.position?.[1] ?? 0) + computeEaveY(segment);
+}
+export function computeSharedEaveY(subject, subjectSegment, siblings) {
+    const subjectBaseY = subjectSegment.position?.[1] ?? 0;
+    if (siblings.length === 0)
+        return computeEaveY(subjectSegment);
+    // Index 0 is the subject; the rest are candidates. BFS the corner
+    // graph from the subject and keep the tallest eave in its component.
+    const nodes = [{ gutter: subject, segment: subjectSegment }, ...siblings];
+    const visited = new Array(nodes.length).fill(false);
+    visited[0] = true;
+    const queue = [0];
+    let maxWorldEaveY = worldEaveY(subjectSegment);
+    while (queue.length > 0) {
+        const i = queue.pop();
+        const cur = nodes[i];
+        for (let j = 0; j < nodes.length; j++) {
+            if (visited[j])
+                continue;
+            const other = nodes[j];
+            if (guttersMeet(cur.gutter, cur.segment, other.gutter, other.segment)) {
+                visited[j] = true;
+                queue.push(j);
+                const eaveY = worldEaveY(other.segment);
+                if (eaveY > maxWorldEaveY)
+                    maxWorldEaveY = eaveY;
+            }
+        }
+    }
+    // Back to the SUBJECT's segment-local frame — the renderer applies the
+    // returned value under the subject segment's group, which already adds
+    // `subjectBaseY`.
+    return maxWorldEaveY - subjectBaseY;
+}

package/dist/gutter/eave-snap.d.ts

@@ -0,0 +1,45 @@
+import type { RoofSegmentNode } from '@pascal-app/core';
+/**
+ * Shared eave-snap math for the gutter's placement + move tools.
+ *
+ * `resolveEaveSnap` finds the drip edge of the eave closest to a
+ * cursor hit in segment-local coords. It supports every roof type the
+ * segment renderer can produce; the difference vs the original
+ * `±Z`-only resolver is hip/flat awareness (4-way eave instead of 2)
+ * and shed's single low eave.
+ *
+ * Why this lives outside the tools: the two tool files used to inline
+ * an identical copy of the resolver + the tuck constants, with a
+ * "keep in sync" comment that becomes a landmine as soon as the
+ * resolver grows non-trivial. Hip's 4-way picker pushed it past that
+ * threshold.
+ */
+export declare const EAVE_TUCK_INWARD = 0.04;
+export declare const EAVE_TUCK_UP = 0.04;
+export type EaveSide = '+X' | '-X' | '+Z' | '-Z';
+export type EaveSnap = {
+    /** Segment-local X of the snapped gutter position. */
+    eaveX: number;
+    /** Segment-local Y of the snapped gutter position (drip-edge Y). */
+    eaveY: number;
+    /** Segment-local Z of the snapped gutter position. */
+    eaveZ: number;
+    /**
+     * Gutter's segment-local Y rotation: orients gutter's outward axis
+     * (+Z local) toward the side picked. Length axis (+X local) falls
+     * out along the eave direction (±X or ±Z depending on the side).
+     */
+    rotation: number;
+    /** Which side of the segment the snap landed on. */
+    side: EaveSide;
+};
+/**
+ * Live eave Y from a segment's wallHeight + overhang + pitch. Pulled
+ * out as a shared helper because the renderer derives Y from this same
+ * formula on every frame (the gutter tracks the segment's height
+ * instead of trusting `node.position[1]` from placement time), and
+ * `resolveEaveSnap` uses the same formula at placement.
+ */
+export declare function computeEaveY(segment: Pick<RoofSegmentNode, 'wallHeight' | 'overhang' | 'pitch' | 'roofType'>): number;
+export declare function resolveEaveSnap(segment: RoofSegmentNode, localX: number, localZ: number): EaveSnap;
+//# sourceMappingURL=eave-snap.d.ts.map

package/dist/gutter/eave-snap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eave-snap.d.ts","sourceRoot":"","sources":["../../src/gutter/eave-snap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAY,MAAM,kBAAkB,CAAA;AAEjE;;;;;;;;;;;;;;GAcG;AAOH,eAAO,MAAM,gBAAgB,OAAO,CAAA;AACpC,eAAO,MAAM,YAAY,OAAO,CAAA;AAEhC,MAAM,MAAM,QAAQ,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAA;AAEhD,MAAM,MAAM,QAAQ,GAAG;IACrB,sDAAsD;IACtD,KAAK,EAAE,MAAM,CAAA;IACb,oEAAoE;IACpE,KAAK,EAAE,MAAM,CAAA;IACb,sDAAsD;IACtD,KAAK,EAAE,MAAM,CAAA;IACb;;;;OAIG;IACH,QAAQ,EAAE,MAAM,CAAA;IAChB,oDAAoD;IACpD,IAAI,EAAE,QAAQ,CAAA;CACf,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,YAAY,GAAG,UAAU,GAAG,OAAO,GAAG,UAAU,CAAC,GAC/E,MAAM,CAYR;AA2CD,wBAAgB,eAAe,CAC7B,OAAO,EAAE,eAAe,EACxB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,QAAQ,CAqDV"}

package/dist/gutter/eave-snap.js

@@ -0,0 +1,128 @@
+/**
+ * Shared eave-snap math for the gutter's placement + move tools.
+ *
+ * `resolveEaveSnap` finds the drip edge of the eave closest to a
+ * cursor hit in segment-local coords. It supports every roof type the
+ * segment renderer can produce; the difference vs the original
+ * `±Z`-only resolver is hip/flat awareness (4-way eave instead of 2)
+ * and shed's single low eave.
+ *
+ * Why this lives outside the tools: the two tool files used to inline
+ * an identical copy of the resolver + the tuck constants, with a
+ * "keep in sync" comment that becomes a landmine as soon as the
+ * resolver grows non-trivial. Hip's 4-way picker pushed it past that
+ * threshold.
+ */
+// Real gutters mount on the fascia (slightly inside the drip edge),
+// with the rim at the deck-top line rather than the slope-surface-at-
+// drip-edge. These tuck the snap so the gutter reads as "attached to
+// the fascia" rather than "floating at the very tip of the overhang".
+// Tuned by feel — bump them up if the gutter looks too low / outboard.
+export const EAVE_TUCK_INWARD = 0.04;
+export const EAVE_TUCK_UP = 0.04;
+/**
+ * Live eave Y from a segment's wallHeight + overhang + pitch. Pulled
+ * out as a shared helper because the renderer derives Y from this same
+ * formula on every frame (the gutter tracks the segment's height
+ * instead of trusting `node.position[1]` from placement time), and
+ * `resolveEaveSnap` uses the same formula at placement.
+ */
+export function computeEaveY(segment) {
+    const wallHeight = segment.wallHeight ?? 0;
+    // Flat roofs have no slope drop and no slope-surface-vs-deck-top
+    // offset — the deck top IS the eave line. EAVE_TUCK_UP is a
+    // correction that lifts a SLOPED gutter from the slope-surface up to
+    // the deck-top line; applying it to a flat deck floats the gutter
+    // above the roof and leaves a visible gap between the edge and the
+    // gutter. So mount flat gutters right at the deck top.
+    if ((segment.roofType ?? 'gable') === 'flat')
+        return wallHeight;
+    const overhang = segment.overhang ?? 0;
+    const pitchRad = ((segment.pitch ?? 0) * Math.PI) / 180;
+    return wallHeight - overhang * Math.tan(pitchRad) + EAVE_TUCK_UP;
+}
+/**
+ * Pick which of the segment's eaves is closest to the cursor.
+ *
+ *  - `shed`: low side only. The segment-hit's analytical surface for
+ *    a shed has `t = (lz + depth/2)/depth`, so the eave is at +Z
+ *    regardless of which side the cursor is on — clicking on the high
+ *    side still rolls the gutter down to the low eave.
+ *
+ *  - `hip` / `flat` / `dutch`: 4-way. The slope the user is standing
+ *    on is determined by whichever of `|lx|/halfW` or `|lz|/halfD` is
+ *    larger — same `max(fx, fz)` discriminator the segment-hit's
+ *    `analyticalSurfaceY` uses for hip. Sign of the dominant axis
+ *    picks +/-. Dutch is a hip base with a gablet on top, so its
+ *    lower run has all four eaves at the eave line — it gets the same
+ *    4-way snap as hip.
+ *
+ *  - `gable` / `gambrel` / `mansard`: 2-way `±Z`. Mansard has real
+ *    4-side eaves in plan, but the segment-hit formula approximates it
+ *    as 2-slope (depth-only), so we stay consistent here — the user
+ *    can re-place the gutter manually on a side eave if mansard
+ *    becomes important.
+ */
+function pickEaveSide(roofType, localX, localZ, halfW, halfD) {
+    if (roofType === 'shed')
+        return '+Z';
+    if (roofType === 'hip' || roofType === 'flat' || roofType === 'dutch') {
+        const fx = halfW > 0 ? Math.abs(localX) / halfW : 0;
+        const fz = halfD > 0 ? Math.abs(localZ) / halfD : 0;
+        if (fx > fz)
+            return localX < 0 ? '-X' : '+X';
+        return localZ < 0 ? '-Z' : '+Z';
+    }
+    return localZ < 0 ? '-Z' : '+Z';
+}
+export function resolveEaveSnap(segment, localX, localZ) {
+    const halfW = (segment.width ?? 0) / 2;
+    const halfD = (segment.depth ?? 0) / 2;
+    const overhang = segment.overhang ?? 0;
+    // The slope keeps descending past the wall edge by the overhang
+    // span; same drop on every eave (pitch is the segment-wide primary
+    // slope). EAVE_TUCK_UP raises the rim back toward the deck-top line.
+    // Shared formula with the renderer so placement and live tracking
+    // agree exactly.
+    const eaveY = computeEaveY(segment);
+    const side = pickEaveSide(segment.roofType ?? 'gable', localX, localZ, halfW, halfD);
+    // For `±Z` eaves the eave runs along ±X so the parallel axis stays
+    // free (snapped to cursor's X), and Z pins to the drip edge. `±X`
+    // eaves swap which axis is free vs pinned. Rotation aligns the
+    // gutter's outward (+Z local) with the picked side; length (+X
+    // local) then falls along the eave.
+    switch (side) {
+        case '+Z':
+            return {
+                eaveX: localX,
+                eaveY,
+                eaveZ: Math.max(halfD, halfD + overhang - EAVE_TUCK_INWARD),
+                rotation: 0,
+                side,
+            };
+        case '-Z':
+            return {
+                eaveX: localX,
+                eaveY,
+                eaveZ: -Math.max(halfD, halfD + overhang - EAVE_TUCK_INWARD),
+                rotation: Math.PI,
+                side,
+            };
+        case '+X':
+            return {
+                eaveX: Math.max(halfW, halfW + overhang - EAVE_TUCK_INWARD),
+                eaveY,
+                eaveZ: localZ,
+                rotation: Math.PI / 2,
+                side,
+            };
+        case '-X':
+            return {
+                eaveX: -Math.max(halfW, halfW + overhang - EAVE_TUCK_INWARD),
+                eaveY,
+                eaveZ: localZ,
+                rotation: -Math.PI / 2,
+                side,
+            };
+    }
+}

package/dist/gutter/floorplan.d.ts

@@ -0,0 +1,18 @@
+import type { FloorplanGeometry, GeometryContext, GutterNode } from '@pascal-app/core';
+/**
+ * Floor-plan builder for a gutter. A gutter is a thin rain-water channel
+ * hosted on a roof segment, running along an eave. In plan it reads as a
+ * narrow metal strip just outboard of the eave line: the trough (two long
+ * edges), end caps where the trough is closed, hanger straps across the
+ * run, and a downspout outlet symbol where one is fitted.
+ *
+ * The coordinate frame mirrors the 3D transform stack
+ * (roof → roof-segment → gutter). The gutter's `position` is
+ * segment-local and the segment's is roof-local, so we compose
+ *   world = roof.pos + R(roof) · (seg.pos + R(seg) · gutter.pos)
+ * using the floor-plan's negated-rotation convention (see
+ * `buildRoofSegmentFloorplan`). Gutter-local +X is the run (along the
+ * eave); +Z hangs outward, away from the building.
+ */
+export declare function buildGutterFloorplan(node: GutterNode, ctx: GeometryContext): FloorplanGeometry | null;
+//# sourceMappingURL=floorplan.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/gutter/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,iBAAiB,EAEjB,eAAe,EACf,UAAU,EAGX,MAAM,kBAAkB,CAAA;AAKzB;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CA4Q1B"}

package/dist/gutter/floorplan.js

@@ -0,0 +1,274 @@
+import { computeGutterMitres } from './corner-mitre';
+import { EAVE_TUCK_INWARD } from './eave-snap';
+import { outletDims, outletShapeForProfile, profileFloorMidZ } from './profile-geometry';
+/**
+ * Floor-plan builder for a gutter. A gutter is a thin rain-water channel
+ * hosted on a roof segment, running along an eave. In plan it reads as a
+ * narrow metal strip just outboard of the eave line: the trough (two long
+ * edges), end caps where the trough is closed, hanger straps across the
+ * run, and a downspout outlet symbol where one is fitted.
+ *
+ * The coordinate frame mirrors the 3D transform stack
+ * (roof → roof-segment → gutter). The gutter's `position` is
+ * segment-local and the segment's is roof-local, so we compose
+ *   world = roof.pos + R(roof) · (seg.pos + R(seg) · gutter.pos)
+ * using the floor-plan's negated-rotation convention (see
+ * `buildRoofSegmentFloorplan`). Gutter-local +X is the run (along the
+ * eave); +Z hangs outward, away from the building.
+ */
+export function buildGutterFloorplan(node, ctx) {
+    const segment = ctx.parent;
+    if (segment?.type !== 'roof-segment')
+        return null;
+    const roofId = segment.parentId;
+    const roof = roofId ? ctx.resolve(roofId) : undefined;
+    if (roof?.type !== 'roof')
+        return null;
+    // Compose roof → segment → gutter in plan coords. Each rotation is
+    // negated so SVG's y-down CW matches Three.js' top-down CCW — the same
+    // convention the roof-segment builder establishes.
+    const cosR = Math.cos(-roof.rotation);
+    const sinR = Math.sin(-roof.rotation);
+    const segCx = roof.position[0] + segment.position[0] * cosR - segment.position[2] * sinR;
+    const segCz = roof.position[2] + segment.position[0] * sinR + segment.position[2] * cosR;
+    const segRot = -(roof.rotation + segment.rotation);
+    const cosS = Math.cos(segRot);
+    const sinS = Math.sin(segRot);
+    const cx = segCx + node.position[0] * cosS - node.position[2] * sinS;
+    const cz = segCz + node.position[0] * sinS + node.position[2] * cosS;
+    const gutterRot = -(roof.rotation + segment.rotation + node.rotation);
+    const cos = Math.cos(gutterRot);
+    const sin = Math.sin(gutterRot);
+    const toPlan = (lx, lz) => [
+        cx + lx * cos - lz * sin,
+        cz + lx * sin + lz * cos,
+    ];
+    const halfLen = Math.max(node.length, 0.1) / 2;
+    const width = Math.max(node.size, 0.05); // outward extent of the trough
+    // The gutter's stored position is the eave drip edge — `halfD + overhang`
+    // out from the segment centre (resolveEaveSnap). The roof floor plan
+    // draws only the structural footprint (no overhang), so to seat the
+    // trough on the drawn roof edge we shift it inward by that overhang
+    // excess. Local Z then reads: `backZ` = back/fascia edge (on the roof
+    // edge), `rimZ` = outward lip.
+    //
+    // A plain inward shift would break mitred corners — the two meeting
+    // gutters lie on perpendicular eaves, so each shifts a different way and
+    // their ends part (they cross). We compensate in the corner math below
+    // by also retracting each MITRED end along the run by the same inset:
+    // the net move at a corner is then identical for both gutters, so they
+    // still meet — now at the structural corner. Exact for right-angle
+    // (hip / rectangular) corners.
+    const eaveInset = Math.max(0, (segment.overhang ?? 0) - EAVE_TUCK_INWARD);
+    const backZ = -eaveInset;
+    const rimZ = width - eaveInset;
+    const view = ctx.viewState;
+    const palette = view?.palette;
+    const isSelected = view?.selected ?? false;
+    const isHighlighted = view?.highlighted ?? false;
+    const isHovered = view?.hovered ?? false;
+    const showSelectedChrome = isSelected || isHighlighted;
+    // Gutters are a metal accessory — read them in a cooler grey than the
+    // roof's black structural ink, accent on select, light blue on hover.
+    const baseInk = '#475569';
+    const stroke = showSelectedChrome && palette
+        ? palette.selectedStroke
+        : isHovered && palette
+            ? palette.wallHoverStroke
+            : baseInk;
+    const fill = showSelectedChrome ? '#fed7aa' : '#cbd5e1';
+    const fillOpacity = showSelectedChrome ? 0.5 : 0.4;
+    const lineWidth = showSelectedChrome ? 0.03 : 0.022;
+    // Corner mitres — when a sibling gutter meets this one at a roof
+    // corner, that shared end is open: the back wall stays at the corner
+    // while the rim extends outward to the mitre, and the cap is
+    // suppressed. Mirrors the 3D builder's rule (`endCap* && mitre === 0`).
+    // `left` = −X end, `right` = +X end.
+    //
+    // Cross-segment: collect every other gutter on the roof paired with its
+    // host segment (mirrors the renderer's `mitreNodes` walk) so gutters
+    // meeting where two segments join still mitre, not just same-segment.
+    const mitreSiblings = [];
+    for (const segId of roof.children ?? []) {
+        const sib = ctx.resolve(segId);
+        if (sib?.type !== 'roof-segment')
+            continue;
+        for (const gid of sib.children ?? []) {
+            const g = ctx.resolve(gid);
+            if (g && g.type === 'gutter' && g.id !== node.id) {
+                mitreSiblings.push({ gutter: g, segment: sib });
+            }
+        }
+    }
+    const mitres = computeGutterMitres(node, segment, mitreSiblings);
+    const capRight = node.endCapRight && mitres.right === 0;
+    const capLeft = node.endCapLeft && mitres.left === 0;
+    // Footprint corners. Back edge sits on the roof edge (lz = backZ); the
+    // rim hangs outward (lz = rimZ). A mitred end (a) retracts along the run
+    // by `eaveInset` so its back corner lands on the structural corner, then
+    // (b) skews its rim corner by the SIGNED mitre (`Math.tan` carries the
+    // sign: convex extends, concave retracts) so adjacent gutters' rims meet
+    // at the corner. Non-mitred ends (mitre === 0) keep the full run.
+    const backRightX = halfLen - (mitres.right !== 0 ? eaveInset : 0);
+    const backLeftX = -(halfLen - (mitres.left !== 0 ? eaveInset : 0));
+    const backLeft = toPlan(backLeftX, backZ);
+    const backRight = toPlan(backRightX, backZ);
+    const rimRight = toPlan(backRightX + width * Math.tan(mitres.right), rimZ);
+    const rimLeft = toPlan(backLeftX - width * Math.tan(mitres.left), rimZ);
+    const children = [
+        // Transparent hit-target across the whole channel so the thin strip
+        // is easy to click-select in plan.
+        {
+            kind: 'polygon',
+            points: [backLeft, backRight, rimRight, rimLeft],
+            fill: stroke,
+            fillOpacity: 0,
+            stroke: 'none',
+            strokeWidth: 0,
+            pointerEvents: 'all',
+        },
+        // Channel fill.
+        {
+            kind: 'polygon',
+            points: [backLeft, backRight, rimRight, rimLeft],
+            fill,
+            fillOpacity,
+            stroke: 'none',
+            strokeWidth: 0,
+            pointerEvents: 'none',
+        },
+        // Long edges — the back (fascia) line and the front lip. These two
+        // parallel lines are the gutter's signature read in plan.
+        {
+            kind: 'line',
+            x1: backLeft[0],
+            y1: backLeft[1],
+            x2: backRight[0],
+            y2: backRight[1],
+            stroke,
+            strokeWidth: lineWidth,
+            strokeLinecap: 'round',
+            pointerEvents: 'none',
+        },
+        {
+            kind: 'line',
+            x1: rimLeft[0],
+            y1: rimLeft[1],
+            x2: rimRight[0],
+            y2: rimRight[1],
+            stroke,
+            strokeWidth: lineWidth,
+            strokeLinecap: 'round',
+            pointerEvents: 'none',
+        },
+    ];
+    // End edges. A capped end gets a square closure line; a mitred end gets
+    // the slanted mitre seam (so the joint shows in plan); an open, uncapped
+    // end gets nothing. `cap*` already excludes mitred ends, so an end never
+    // draws both a cap and a seam.
+    if (capLeft || mitres.left !== 0) {
+        children.push({
+            kind: 'line',
+            x1: backLeft[0],
+            y1: backLeft[1],
+            x2: rimLeft[0],
+            y2: rimLeft[1],
+            stroke,
+            strokeWidth: lineWidth,
+            strokeLinecap: 'round',
+            pointerEvents: 'none',
+        });
+    }
+    if (capRight || mitres.right !== 0) {
+        children.push({
+            kind: 'line',
+            x1: backRight[0],
+            y1: backRight[1],
+            x2: rimRight[0],
+            y2: rimRight[1],
+            stroke,
+            strokeWidth: lineWidth,
+            strokeLinecap: 'round',
+            pointerEvents: 'none',
+        });
+    }
+    // Hanger straps — short ticks across the trough at the real hanger
+    // spacing, so the strip reads as a gutter rather than a thin wall.
+    if (node.hangerStyle === 'strap') {
+        const spacing = Math.max(node.hangerSpacing, 0.2);
+        const inset = width * 0.15;
+        // Span the (possibly retracted) run between the two end corners.
+        const mid = (backLeftX + backRightX) / 2;
+        const runLen = backRightX - backLeftX;
+        const count = Math.max(1, Math.floor(runLen / spacing));
+        const span = count * spacing;
+        for (let i = 0; i < count; i++) {
+            const x = mid - span / 2 + spacing / 2 + i * spacing;
+            if (x <= backLeftX + 0.02 || x >= backRightX - 0.02)
+                continue;
+            const a = toPlan(x, backZ + inset);
+            const b = toPlan(x, rimZ - inset);
+            children.push({
+                kind: 'line',
+                x1: a[0],
+                y1: a[1],
+                x2: b[0],
+                y2: b[1],
+                stroke,
+                strokeWidth: lineWidth * 0.7,
+                strokeLinecap: 'round',
+                opacity: 0.6,
+                pointerEvents: 'none',
+            });
+        }
+    }
+    // Downspout outlets — a leader symbol per outlet (round for half-round
+    // gutters, rectangular for k-style / box, following the profile) at each
+    // outlet's along-run position. The strongest "this is a gutter" cue in a
+    // roof plan. `offset` is signed from the gutter centre along +X.
+    // `outlets` is a recent schema addition — gutters persisted before it
+    // existed deserialize without the field (the schema default only fills
+    // on a fresh parse), so guard against `undefined`.
+    const outlets = node.outlets ?? [];
+    if (outlets.length > 0) {
+        const floorZ = Math.min(Math.max(profileFloorMidZ(node.profile, width), width * 0.25), width * 0.85);
+        const outletZ = backZ + floorZ;
+        const shape = outletShapeForProfile(node.profile);
+        const outStroke = showSelectedChrome && palette ? palette.selectedStroke : '#1e293b';
+        for (const outlet of outlets) {
+            // Clamp inside the run so the symbol never rides out onto a cap line
+            // (the 3D builder clamps the drill the same way).
+            const outletX = Math.max(-halfLen * 0.9, Math.min(halfLen * 0.9, outlet.offset));
+            const dims = outletDims(shape, outlet.diameter);
+            if (shape === 'round') {
+                const center = toPlan(outletX, outletZ);
+                children.push({
+                    kind: 'circle',
+                    cx: center[0],
+                    cy: center[1],
+                    r: Math.max(dims.halfX, 0.03),
+                    fill: 'none',
+                    stroke: outStroke,
+                    strokeWidth: lineWidth,
+                    pointerEvents: 'none',
+                });
+            }
+            else {
+                children.push({
+                    kind: 'polygon',
+                    points: [
+                        toPlan(outletX - dims.halfX, outletZ - dims.halfZ),
+                        toPlan(outletX + dims.halfX, outletZ - dims.halfZ),
+                        toPlan(outletX + dims.halfX, outletZ + dims.halfZ),
+                        toPlan(outletX - dims.halfX, outletZ + dims.halfZ),
+                    ],
+                    fill: 'none',
+                    stroke: outStroke,
+                    strokeWidth: lineWidth,
+                    pointerEvents: 'none',
+                });
+            }
+        }
+    }
+    return { kind: 'group', children };
+}

package/dist/gutter/geometry.d.ts

@@ -0,0 +1,39 @@
+import type { GutterNode } from '@pascal-app/core';
+import * as THREE from 'three';
+import { type GutterMitres } from './corner-mitre';
+/**
+ * Pure builder for the gutter mesh. The gutter is a hollow trough that
+ * runs along the eave; we build its cross-section as a closed 2D Shape
+ * in the (Z, Y) plane with the channel cavity carved out as a Path
+ * hole, then extrude along the gutter's local +X (length direction).
+ *
+ * Three profiles share the same outer-outline-minus-cavity recipe; they
+ * differ only in the OUTLINE shape:
+ *
+ *  - `k-style`:    flat back + flat bottom + ogee (S-curve) fascia.
+ *                  Most common modern residential profile.
+ *  - `half-round`: half-cylinder (semicircle cross-section).
+ *  - `box`:        square / rectangular u-channel; reads as commercial.
+ *
+ * The gutter mounts at the eave line (gutter-local Y=0) and drops
+ * downward (negative Y) by `size`. +Z is "away from the building" —
+ * positive Z is the outer face that hangs over the eave.
+ *
+ * End caps: when `endCapLeft` / `endCapRight` is true, the matching
+ * end gets a thin SOLID slice (depth = wall thickness) instead of the
+ * hollow U-channel. The solid slice's end face closes the trough so
+ * water can't run out the side. Caps subtract from the user-set
+ * `length` so the gutter's total span stays constant — capping doesn't
+ * silently grow the geometry past what the inspector reads.
+ *
+ * Corner mitres: when a sibling gutter meets this gutter at a roof
+ * corner, the corner-mitre detector passes a mitre angle for the
+ * affected end. The end-face vertices are skewed (back wall held in
+ * place, front rim extended outward) so two perpendicular gutters'
+ * front rims meet at the outer eave intersection. A mitred end's cap
+ * is force-suppressed — capping a corner would wall off the L.
+ *
+ * Pure: no React, no scene access, no store mutation.
+ */
+export declare function buildGutterGeometry(node: GutterNode, mitres?: GutterMitres): THREE.BufferGeometry;
+//# sourceMappingURL=geometry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/gutter/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAQlD,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,EAAE,KAAK,YAAY,EAAa,MAAM,gBAAgB,CAAA;AAW7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,UAAU,EAChB,MAAM,GAAE,YAAwB,GAC/B,KAAK,CAAC,cAAc,CAsLtB"}