@pascal-app/nodes 0.1.1

package/dist/gutter/geometry.js

@@ -0,0 +1,532 @@
+import { Brush, csgEvaluator, csgGeometry, prepareBrushForCSG, SUBTRACTION, } from '@pascal-app/viewer';
+import * as THREE from 'three';
+import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+import { NO_MITRES } from './corner-mitre';
+import { OUTLET_STUB_LENGTH, OUTLET_WALL_THICKNESS, outletDims, outletShapeForProfile, profileFloorMidZ, } from './profile-geometry';
+/**
+ * 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 function buildGutterGeometry(node, mitres = NO_MITRES) {
+    const len = Math.max(0.05, node.length);
+    const size = Math.max(0.04, node.size);
+    const t = Math.min(Math.max(0.001, node.thickness), size * 0.4);
+    const capLeft = (node.endCapLeft ?? true) && mitres.left === 0;
+    const capRight = (node.endCapRight ?? true) && mitres.right === 0;
+    // Reserve cap slices at each capped end. Each cap is `t` thick
+    // (matches the wall thickness — a real end cap is a stamped plate
+    // welded onto the gutter). Clamp so a tiny gutter doesn't end up
+    // all-cap-no-channel.
+    const reserved = (capLeft ? t : 0) + (capRight ? t : 0);
+    const channelLen = Math.max(len * 0.1, len - reserved);
+    const totalCap = len - channelLen;
+    const capLeftLen = capLeft ? (capRight ? totalCap / 2 : totalCap) : 0;
+    const capRightLen = capRight ? (capLeft ? totalCap / 2 : totalCap) : 0;
+    let channelCross;
+    let capCross;
+    if (node.profile === 'half-round') {
+        channelCross = buildHalfRoundCross(size, t);
+        capCross = buildHalfRoundOuterOnly(size);
+    }
+    else if (node.profile === 'box') {
+        channelCross = buildBoxCross(size, t);
+        capCross = buildBoxOuterOnly(size);
+    }
+    else {
+        channelCross = buildKStyleCross(size, t);
+        capCross = buildKStyleOuterOnly(size);
+    }
+    // Each extrude below uses the same orient-and-recenter recipe:
+    // ExtrudeGeometry produces (mesh-X = cross-X, mesh-Y = cross-Y,
+    // mesh-Z = extrusion axis); we rotateY(-π/2) so the LENGTH lands
+    // along mesh-+X and the OUTWARD direction lands along mesh-+Z, then
+    // translate so the piece sits in its slot of the gutter's overall
+    // [-len/2, +len/2] span. Z_cs = 0 maps to mesh-+X (right end);
+    // Z_cs = depth maps to mesh--X (left end).
+    const pieces = [];
+    let channel = new THREE.ExtrudeGeometry(channelCross, {
+        depth: channelLen,
+        bevelEnabled: false,
+        curveSegments: 16,
+        steps: 1,
+    });
+    // Apply the corner-mitre skew while we're still in the source frame.
+    // Source axes (pre-rotation): X_cs = outward, Y_cs = vertical,
+    // Z_cs = length (0 at right end of mesh, `channelLen` at left end).
+    // After rotateY(-π/2): mesh-X = -Z_cs, mesh-Z = X_cs.
+    //
+    // Corner mitre rule: the back wall (X_cs = 0) stays at the original
+    // end (mesh-X = ±len/2); the front rim (X_cs = +outward) is SKEWED
+    // along the gutter's length to reach the eave intersection of the L.
+    // The mitre is SIGNED — positive (convex / outer corner) extends the
+    // rim past the end; negative (concave / inner corner) retracts it to
+    // the inner intersection. `Math.tan` carries the sign, so the same
+    // formula handles both. In mesh coords:
+    //   right end: Δmesh-X = +mesh-Z · tan(mitreRight)
+    //   left  end: Δmesh-X = −mesh-Z · tan(mitreLeft)
+    // Mapped back to source coords (Δmesh-X = −ΔZ_cs, mesh-Z = X_cs):
+    //   right end (Z_cs = 0):           new Z_cs = −X_cs · tan(mitreRight)
+    //   left  end (Z_cs = channelLen):  new Z_cs = channelLen + X_cs · tan(mitreLeft)
+    if (mitres.right !== 0 || mitres.left !== 0) {
+        // Drop the cross-section CAP at each mitred end first. Both gutters
+        // at a corner skew their end faces onto the SAME mitre plane, so the
+        // thin metal-section caps land coincident and z-fight into the stray
+        // seam lines visible at the joint (and the ink-edge pass outlines
+        // them). With the caps gone the open troughs flow into each other and
+        // the side walls carry the corner — a clean seam. Done before the
+        // skew so the end planes are still the clean z=0 / z=channelLen.
+        const stripped = stripEndCaps(channel, channelLen, mitres.right !== 0, mitres.left !== 0);
+        channel.dispose();
+        channel = stripped;
+        const tanRight = Math.tan(mitres.right);
+        const tanLeft = Math.tan(mitres.left);
+        const eps = 1e-5;
+        const pos = channel.attributes.position;
+        for (let i = 0; i < pos.count; i++) {
+            const x = pos.getX(i);
+            const z = pos.getZ(i);
+            if (mitres.right !== 0 && Math.abs(z) < eps) {
+                pos.setZ(i, -x * tanRight);
+            }
+            else if (mitres.left !== 0 && Math.abs(z - channelLen) < eps) {
+                pos.setZ(i, channelLen + x * tanLeft);
+            }
+        }
+        pos.needsUpdate = true;
+        channel.computeVertexNormals();
+    }
+    channel.rotateY(-Math.PI / 2);
+    // Channel spans [-len/2 + capLeftLen, +len/2 - capRightLen]: shift
+    // the recentered extrude so its right end butts against the right cap.
+    channel.translate(len / 2 - capRightLen, 0, 0);
+    pieces.push(channel);
+    if (capLeft) {
+        const leftCap = new THREE.ExtrudeGeometry(capCross, {
+            depth: capLeftLen,
+            bevelEnabled: false,
+            curveSegments: 16,
+            steps: 1,
+        });
+        leftCap.rotateY(-Math.PI / 2);
+        // Left cap spans [-len/2, -len/2 + capLeftLen]: translate by
+        // -len/2 + capLeftLen so Z_cs=0 (mesh-+X end of the cap slice)
+        // sits at -len/2 + capLeftLen and Z_cs=depth at -len/2.
+        leftCap.translate(-len / 2 + capLeftLen, 0, 0);
+        pieces.push(leftCap);
+    }
+    if (capRight) {
+        const rightCap = new THREE.ExtrudeGeometry(capCross, {
+            depth: capRightLen,
+            bevelEnabled: false,
+            curveSegments: 16,
+            steps: 1,
+        });
+        rightCap.rotateY(-Math.PI / 2);
+        // Right cap spans [+len/2 - capRightLen, +len/2].
+        rightCap.translate(len / 2, 0, 0);
+        pieces.push(rightCap);
+    }
+    // Hangers: thin metal straps spanning the rim from the back wall to
+    // the front rim, repeated along the length. Each strap is a small
+    // box centered on Y=0 (the eave line, where the rim sits) with its
+    // top ~3mm above the rim — so it reads as a clip resting on the
+    // gutter rather than buried in it.
+    if ((node.hangerStyle ?? 'strap') !== 'none') {
+        for (const hanger of buildHangers(node, len, size, capLeftLen, capRightLen, mitres)) {
+            pieces.push(hanger);
+        }
+    }
+    // Downspout outlets: short drop-tube collars hanging off the gutter
+    // floor at each outlet's position. Each collar is solid at the outer
+    // (bore + wall) cross-section; the bore is then drilled through both
+    // the floor and the collar via CSG, so the result is a real hole in
+    // the trough floor and a hollow tube descending from it. CSG only
+    // runs when at least one outlet exists — an empty `outlets` keeps the
+    // fast merge path.
+    const placements = resolveOutletPlacements(node, len, size, capLeftLen, capRightLen);
+    for (const p of placements) {
+        pieces.push(buildOutletStub(p, size));
+        // Flared funnel lip at the floor so the drop reads as a real drop
+        // outlet rather than a bare tube; the same bore drill cuts it open.
+        pieces.push(buildOutletFunnel(p, size));
+    }
+    const merged = pieces.length === 1 ? pieces[0] : (mergeGeometries(pieces, false) ?? pieces[0]);
+    // Free the intermediate pieces when merge returned a new geometry.
+    if (merged !== pieces[0]) {
+        for (const p of pieces)
+            p.dispose();
+    }
+    merged.computeVertexNormals();
+    // CSG drill — punches each bore through the merged geometry. Runs
+    // last so the floor + collars are already in one mesh; each drill
+    // cuts both at once, subtracted sequentially.
+    if (placements.length > 0) {
+        let workingBrush = new Brush(merged);
+        prepareBrushForCSG(workingBrush);
+        for (const p of placements) {
+            const drill = buildOutletDrill(p, size);
+            const drillBrush = new Brush(drill);
+            prepareBrushForCSG(drillBrush);
+            const next = csgEvaluator.evaluate(workingBrush, drillBrush, SUBTRACTION);
+            prepareBrushForCSG(next);
+            // Free the previous step's intermediate result (but not `merged`,
+            // which is disposed once below).
+            if (workingBrush.geometry !== merged)
+                workingBrush.geometry.dispose();
+            workingBrush = next;
+            drill.dispose();
+        }
+        const cutGeometry = csgGeometry(workingBrush);
+        merged.dispose();
+        return cutGeometry;
+    }
+    return merged;
+}
+// Remove the extrude's cross-section CAP triangles at a mitred end so two
+// gutters meeting at a corner don't leave coincident, z-fighting end
+// faces (the seam lines at the joint). A cap triangle is one whose three
+// vertices ALL lie on an end plane — z≈0 (right end) or z≈channelLen
+// (left end). Wall triangles always span the two planes, so this cleanly
+// separates caps from walls without depending on ExtrudeGeometry's
+// internal vertex order. Input is non-indexed (ExtrudeGeometry), so every
+// three positions is one triangle; we copy through the survivors and let
+// the caller recompute normals.
+function stripEndCaps(geo, channelLen, removeRight, removeLeft) {
+    const src = geo.index ? geo.toNonIndexed() : geo;
+    const pos = src.attributes.position;
+    const uv = src.attributes.uv;
+    const eps = 1e-4;
+    const keepPos = [];
+    const keepUv = uv ? [] : null;
+    const triCount = Math.floor(pos.count / 3);
+    for (let t = 0; t < triCount; t++) {
+        const a = t * 3;
+        const za = pos.getZ(a);
+        const zb = pos.getZ(a + 1);
+        const zc = pos.getZ(a + 2);
+        const allRight = Math.abs(za) < eps && Math.abs(zb) < eps && Math.abs(zc) < eps;
+        const allLeft = Math.abs(za - channelLen) < eps &&
+            Math.abs(zb - channelLen) < eps &&
+            Math.abs(zc - channelLen) < eps;
+        if ((removeRight && allRight) || (removeLeft && allLeft))
+            continue;
+        for (let k = 0; k < 3; k++) {
+            const idx = a + k;
+            keepPos.push(pos.getX(idx), pos.getY(idx), pos.getZ(idx));
+            if (keepUv && uv)
+                keepUv.push(uv.getX(idx), uv.getY(idx));
+        }
+    }
+    if (src !== geo)
+        src.dispose();
+    const out = new THREE.BufferGeometry();
+    out.setAttribute('position', new THREE.Float32BufferAttribute(keepPos, 3));
+    if (keepUv)
+        out.setAttribute('uv', new THREE.Float32BufferAttribute(keepUv, 2));
+    return out;
+}
+// Each cross-section below is authored as a single closed polygon that
+// traces the U-channel's MATERIAL — outer wall down → bottom → outer
+// wall up → rim across → inner wall down → inner bottom → inner wall
+// up → closing rim. The interior of the U (where rainwater sits) is
+// empty space, not a hole — so the extrude has an OPEN TOP, which is
+// what makes the geometry read as a gutter rather than a sealed box
+// with a tunnel through it.
+//
+// Cross-section authoring frame: X is the gutter's outward direction
+// (X=0 against the fascia, X=+w hanging outward); Y is vertical (Y=0
+// at the eave line, Y=-size at the bottom of the trough). After the
+// rotateY(-π/2) in the parent builder, +X maps to segment-outward (+Z)
+// and the extrude axis (length) maps to segment-+X.
+function buildKStyleCross(size, t) {
+    const wBot = size * 0.8; // bottom outer width — narrower than the rim
+    const wTop = size * 0.95;
+    const ogeeY = -size * 0.65; // S-curve inflection on the fascia
+    const shape = new THREE.Shape();
+    // Outer trace — top-back → down the back → across the bottom → up
+    // the ogee fascia.
+    shape.moveTo(0, 0);
+    shape.lineTo(0, -size);
+    shape.lineTo(wBot, -size);
+    shape.bezierCurveTo(wBot + size * 0.15, ogeeY, wTop - size * 0.15, ogeeY * 0.4, wTop, 0);
+    // Front rim (thin top of the front wall): step inward by `t`.
+    shape.lineTo(wTop - t, 0);
+    // Inner trace — back down the ogee, across the inner bottom, up the
+    // inner back wall. Same bezier control points pushed inward by `t`.
+    shape.bezierCurveTo(wTop - size * 0.15 - t, ogeeY * 0.4, wBot + size * 0.15 - t, ogeeY, wBot - t, -size + t);
+    shape.lineTo(t, -size + t);
+    shape.lineTo(t, 0);
+    // closePath draws the back rim (t, 0) → (0, 0) — the thin top of
+    // the back wall, sealing the cross-section.
+    shape.closePath();
+    return shape;
+}
+// Half-round trough — a semicircular cross-section with a smaller
+// concentric semicircle carved out. Single closed trace: outer half
+// from (0,0) sweeping down and back up to (2r, 0), front rim across by
+// `t`, inner half from (2r-t, 0) sweeping back to (t, 0), back rim
+// closes the loop.
+function buildHalfRoundCross(size, t) {
+    const r = size; // radius == size: half-circle drops `size` below the eave
+    const ri = r - t; // inner radius
+    const segs = 24;
+    const shape = new THREE.Shape();
+    shape.moveTo(0, 0);
+    // Outer semicircle, lower half (angle π → 2π). At i=0 we'd be at
+    // (0,0) — already there from moveTo — so start at i=1.
+    for (let i = 1; i <= segs; i++) {
+        const angle = Math.PI + (Math.PI * i) / segs;
+        shape.lineTo(r + r * Math.cos(angle), r * Math.sin(angle));
+    }
+    // Front rim — step inward by `t` to start the inner trace.
+    shape.lineTo(2 * r - t, 0);
+    // Inner semicircle, traced BACK toward the back wall (angle 2π → π).
+    for (let i = 1; i <= segs; i++) {
+        const angle = 2 * Math.PI - (Math.PI * i) / segs;
+        shape.lineTo(r + ri * Math.cos(angle), ri * Math.sin(angle));
+    }
+    // closePath draws (t, 0) → (0, 0) — back rim.
+    shape.closePath();
+    return shape;
+}
+// Square / rectangular box U-channel. Width equals size (deep-and-
+// narrow ratio reads as commercial). Traced as outer rect → front rim
+// → inner rect (reverse) → back rim.
+function buildBoxCross(size, t) {
+    const w = size;
+    const shape = new THREE.Shape();
+    shape.moveTo(0, 0);
+    shape.lineTo(0, -size);
+    shape.lineTo(w, -size);
+    shape.lineTo(w, 0);
+    // Front rim.
+    shape.lineTo(w - t, 0);
+    // Inner rect, reversed so the polygon doesn't self-intersect.
+    shape.lineTo(w - t, -size + t);
+    shape.lineTo(t, -size + t);
+    shape.lineTo(t, 0);
+    // closePath draws the back rim (t, 0) → (0, 0).
+    shape.closePath();
+    return shape;
+}
+// Solid-outer outlines used for the end-cap slices: same outer
+// boundary as the channel cross-sections above but without the inner
+// trough carved out, so the extruded slice is a solid plug that closes
+// the open end of the trough.
+function buildKStyleOuterOnly(size) {
+    const wBot = size * 0.8;
+    const wTop = size * 0.95;
+    const ogeeY = -size * 0.65;
+    const shape = new THREE.Shape();
+    shape.moveTo(0, 0);
+    shape.lineTo(0, -size);
+    shape.lineTo(wBot, -size);
+    shape.bezierCurveTo(wBot + size * 0.15, ogeeY, wTop - size * 0.15, ogeeY * 0.4, wTop, 0);
+    // closePath draws (wTop, 0) → (0, 0) — the cap's rim line across
+    // the top of the gutter cross-section.
+    shape.closePath();
+    return shape;
+}
+function buildHalfRoundOuterOnly(size) {
+    const r = size;
+    const segs = 24;
+    const shape = new THREE.Shape();
+    shape.moveTo(0, 0);
+    for (let i = 1; i <= segs; i++) {
+        const angle = Math.PI + (Math.PI * i) / segs;
+        shape.lineTo(r + r * Math.cos(angle), r * Math.sin(angle));
+    }
+    shape.closePath();
+    return shape;
+}
+function buildBoxOuterOnly(size) {
+    const w = size;
+    const shape = new THREE.Shape();
+    shape.moveTo(0, 0);
+    shape.lineTo(0, -size);
+    shape.lineTo(w, -size);
+    shape.lineTo(w, 0);
+    shape.closePath();
+    return shape;
+}
+// ─── Hangers ───────────────────────────────────────────────────────
+// Strap dimensions — a residential hidden hanger reads as a flat band
+// roughly 25mm wide along the gutter, 3mm thick, sitting on the rim.
+const HANGER_BAR_LEN = 0.025;
+const HANGER_BAR_THICKNESS = 0.003;
+// Extra spread past the rim's outward extent — so the strap looks like
+// it "wraps over" both edges rather than ending flush.
+const HANGER_OVERHANG = 0.005;
+// Distance from each gutter end where a strap is allowed to sit; keeps
+// straps from clashing with end caps and from looking pinned to the
+// very edge.
+const HANGER_END_MARGIN = 0.05;
+/** Outward Z extent of each profile, used to size the strap. */
+function profileRimWidth(profile, size) {
+    if (profile === 'half-round')
+        return 2 * size;
+    if (profile === 'box')
+        return size;
+    return size * 0.95; // k-style wTop
+}
+function buildHangers(node, len, size, capLeftLen, capRightLen, mitres) {
+    const spacing = Math.max(0.2, node.hangerSpacing ?? 0.6);
+    const profile = node.profile ?? 'k-style';
+    const rimWidth = profileRimWidth(profile, size);
+    const strapDepth = rimWidth + HANGER_OVERHANG * 2;
+    // At an INNER (concave) corner the two gutters' troughs fold into the
+    // same notch, so a strap sitting near that end overlaps the neighbour
+    // gutter's end strap — the two perpendicular straps read as an X across
+    // the corner. Pull the run's bound back by a full strap depth at a
+    // concave end so the nearest strap clears the joint. OUTER (convex)
+    // corners diverge outward and never overlap, so they keep the tight
+    // margin (`mitre > 0` and non-mitred ends → no extra inset).
+    const concaveInset = (mitre) => (mitre < 0 ? strapDepth : 0);
+    // Inset by margin AND any cap so straps don't punch into the cap slab,
+    // plus the concave-corner clearance above.
+    const leftBound = -len / 2 + capLeftLen + HANGER_END_MARGIN + concaveInset(mitres.left);
+    const rightBound = len / 2 - capRightLen - HANGER_END_MARGIN - concaveInset(mitres.right);
+    const usable = rightBound - leftBound;
+    if (usable <= 0)
+        return [];
+    // Span the usable run with straps at `spacing` between centers, plus
+    // one at each end. Symmetric layout for any length, including very
+    // short gutters where two straps land at the bounds.
+    const count = Math.max(1, Math.floor(usable / spacing) + 1);
+    const stride = count > 1 ? usable / (count - 1) : 0;
+    const pieces = [];
+    for (let i = 0; i < count; i++) {
+        const x = count > 1 ? leftBound + i * stride : (leftBound + rightBound) / 2;
+        // BoxGeometry is indexed; the channel + cap ExtrudeGeometries are
+        // not. `mergeGeometries` rejects mixed-index sets, so flatten the
+        // box to non-indexed before pushing.
+        const bar = new THREE.BoxGeometry(HANGER_BAR_LEN, HANGER_BAR_THICKNESS, strapDepth).toNonIndexed();
+        // Center the bar at X = position, Y just above the rim line, Z
+        // straddling 0 so the strap covers the full back-to-front span.
+        bar.translate(x, HANGER_BAR_THICKNESS / 2 + 0.001, rimWidth / 2);
+        pieces.push(bar);
+    }
+    return pieces;
+}
+// ─── Outlet ────────────────────────────────────────────────────────
+// Radial subdivisions — 24 reads as smooth at typical outlet
+// diameters; lower and the 3″ tube starts looking faceted from below.
+const OUTLET_RADIAL_SEGMENTS = 24;
+// Drill overshoot past the floor and past the stub bottom — keeps the
+// CSG cut planes from coinciding with merged-geometry surfaces
+// (coplanar cuts produce degenerate output in three-bvh-csg).
+const OUTLET_DRILL_OVERSHOOT = 0.01;
+// Funnel lip at the drop outlet — flares this much wider than the collar
+// over this height, just below the trough floor. The bore drill cuts it
+// open along with the collar.
+const OUTLET_FLARE_SCALE = 1.6;
+const OUTLET_FLARE_HEIGHT = 0.02;
+/**
+ * One placement per `node.outlets` entry that fits between the caps. The
+ * shape follows the gutter profile (`outletShapeForProfile`): round
+ * leader on half-round, rectangular on k-style / box. Each outlet's
+ * `offset` (signed from center) is clamped inside the trough-floor span
+ * using the OUTER along-length half-extent so the collar can't poke into
+ * a cap. Outlets that can't fit at all are dropped.
+ */
+function resolveOutletPlacements(node, len, size, capLeftLen, capRightLen) {
+    const outlets = node.outlets ?? [];
+    if (outlets.length === 0)
+        return [];
+    const shape = outletShapeForProfile(node.profile);
+    const z = profileFloorMidZ(node.profile ?? 'k-style', size);
+    const placements = [];
+    for (const outlet of outlets) {
+        const inner = outletDims(shape, outlet.diameter ?? 0.07);
+        const outer = {
+            shape,
+            halfX: inner.halfX + OUTLET_WALL_THICKNESS,
+            halfZ: inner.halfZ + OUTLET_WALL_THICKNESS,
+        };
+        const minX = -len / 2 + capLeftLen + outer.halfX;
+        const maxX = len / 2 - capRightLen - outer.halfX;
+        if (maxX <= minX)
+            continue;
+        const x = Math.max(minX, Math.min(maxX, outlet.offset ?? 0));
+        placements.push({ x, z, shape, inner, outer });
+    }
+    return placements;
+}
+/** Cylinder (round) or box (rect) sized to `dims`, height `h` along Y. */
+function outletSolid(dims, h) {
+    if (dims.shape === 'round') {
+        return new THREE.CylinderGeometry(dims.halfX, dims.halfX, h, OUTLET_RADIAL_SEGMENTS).toNonIndexed();
+    }
+    return new THREE.BoxGeometry(2 * dims.halfX, h, 2 * dims.halfZ).toNonIndexed();
+}
+/**
+ * Solid collar at the OUTER cross-section; the CSG drill hollows out the
+ * bore and leaves a tube wall. Top sits flush with the gutter floor
+ * (Y = −size). Flattened to match the ExtrudeGeometries.
+ */
+function buildOutletStub(p, size) {
+    const stub = outletSolid(p.outer, OUTLET_STUB_LENGTH);
+    stub.translate(p.x, -size - OUTLET_STUB_LENGTH / 2, p.z);
+    return stub;
+}
+/**
+ * Flared funnel lip just below the trough floor — wide at the floor,
+ * tapering to the collar below (round → a cone; rect → a stepped wider
+ * lip). Sits in the bore drill's span so it gets cut open too.
+ */
+function buildOutletFunnel(p, size) {
+    const centerY = -size - OUTLET_FLARE_HEIGHT / 2;
+    let funnel;
+    if (p.shape === 'round') {
+        funnel = new THREE.CylinderGeometry(p.outer.halfX * OUTLET_FLARE_SCALE, p.outer.halfX, OUTLET_FLARE_HEIGHT, OUTLET_RADIAL_SEGMENTS).toNonIndexed();
+    }
+    else {
+        funnel = new THREE.BoxGeometry(2 * p.outer.halfX * OUTLET_FLARE_SCALE, OUTLET_FLARE_HEIGHT, 2 * p.outer.halfZ * OUTLET_FLARE_SCALE).toNonIndexed();
+    }
+    funnel.translate(p.x, centerY, p.z);
+    return funnel;
+}
+/**
+ * Bore drill — spans from slightly above the trough floor to slightly
+ * below the collar's bottom; the overshoots keep CSG cut planes from
+ * sitting coplanar with merged-geometry faces.
+ */
+function buildOutletDrill(p, size) {
+    const top = -size + OUTLET_DRILL_OVERSHOOT;
+    const bottom = -size - OUTLET_STUB_LENGTH - OUTLET_DRILL_OVERSHOOT;
+    const height = top - bottom;
+    const centerY = (top + bottom) / 2;
+    const drill = outletSolid(p.inner, height);
+    drill.translate(p.x, centerY, p.z);
+    return drill;
+}

package/dist/gutter/index.d.ts

@@ -0,0 +1,4 @@
+export { gutterDefinition } from './definition';
+export { buildGutterGeometry } from './geometry';
+export { GutterNode } from './schema';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/gutter/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAC/C,OAAO,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAA;AAChD,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA"}

package/dist/gutter/index.js

@@ -0,0 +1,3 @@
+export { gutterDefinition } from './definition';
+export { buildGutterGeometry } from './geometry';
+export { GutterNode } from './schema';

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

@@ -0,0 +1,16 @@
+import type { GutterNode, SceneApi } from '@pascal-app/core';
+export type GutterLengthSnap = {
+    /** Length to apply to the dragged gutter. */
+    length: number;
+};
+/**
+ * @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 declare function snapLengthToCorner(initial: GutterNode, proposedLength: number, sign: 1 | -1, anchorX: number, anchorZ: number, armX: number, armZ: number, minLength: number, sceneApi: SceneApi): GutterLengthSnap;
+//# sourceMappingURL=length-snap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"length-snap.d.ts","sourceRoot":"","sources":["../../src/gutter/length-snap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAa,UAAU,EAAmB,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAoDxF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,6CAA6C;IAC7C,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,UAAU,EACnB,cAAc,EAAE,MAAM,EACtB,IAAI,EAAE,CAAC,GAAG,CAAC,CAAC,EACZ,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,QAAQ,GACjB,gBAAgB,CAgHlB"}