@pascal-app/nodes 0.1.1

package/dist/ridge-vent/floorplan.js

@@ -0,0 +1,121 @@
+// Tab pitch for the shingled style — matches SHINGLED_TAB_SIZE in
+// geometry.ts so the plan's divider spacing reads like the 3D ridge cap.
+const SHINGLED_TAB_SIZE = 0.3;
+/**
+ * Floor-plan builder for a ridge vent — a ventilation strip running along
+ * a roof ridge. Seen from above it's a long thin band straddling the
+ * ridge crest, with a centre crest line, end caps where closed, and tab
+ * dividers for the shingled style.
+ *
+ * Coordinate frame mirrors the 3D transform stack
+ * (roof → roof-segment → vent), same as the chimney builder. `position`
+ * is segment-local; the run (`length`) is along local +X and the small
+ * cross-`width` straddles the ridge along local Z (centred at Z = 0).
+ * `rotation` is yaw, negated for the floor plan's y-down convention.
+ */
+export function buildRidgeVentFloorplan(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;
+    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 rot = -(roof.rotation + segment.rotation + node.rotation);
+    const cos = Math.cos(rot);
+    const sin = Math.sin(rot);
+    const toPlan = (lx, lz) => [
+        cx + lx * cos - lz * sin,
+        cz + lx * sin + lz * cos,
+    ];
+    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;
+    const baseInk = '#475569';
+    const stroke = showSelectedChrome && palette
+        ? palette.selectedStroke
+        : isHovered && palette
+            ? palette.wallHoverStroke
+            : baseInk;
+    const fill = showSelectedChrome ? '#fed7aa' : '#dbe1e8';
+    const fillOpacity = showSelectedChrome ? 0.55 : 0.6;
+    const lineWidth = showSelectedChrome ? 0.03 : 0.02;
+    const halfLen = Math.max(node.length, 0.1) / 2;
+    const halfW = Math.max(node.width, 0.04) / 2;
+    const corners = [
+        toPlan(-halfLen, -halfW),
+        toPlan(halfLen, -halfW),
+        toPlan(halfLen, halfW),
+        toPlan(-halfLen, halfW),
+    ];
+    const children = [
+        // Transparent hit-target over the whole strip.
+        {
+            kind: 'polygon',
+            points: corners,
+            fill: stroke,
+            fillOpacity: 0,
+            stroke: 'none',
+            strokeWidth: 0,
+            pointerEvents: 'all',
+        },
+        // Strip fill.
+        {
+            kind: 'polygon',
+            points: corners,
+            fill,
+            fillOpacity,
+            stroke: 'none',
+            strokeWidth: 0,
+            pointerEvents: 'none',
+        },
+    ];
+    const seg = (a, b, w, opacity) => {
+        const pa = toPlan(a[0], a[1]);
+        const pb = toPlan(b[0], b[1]);
+        children.push({
+            kind: 'line',
+            x1: pa[0],
+            y1: pa[1],
+            x2: pb[0],
+            y2: pb[1],
+            stroke,
+            strokeWidth: w,
+            strokeLinecap: 'round',
+            opacity,
+            pointerEvents: 'none',
+        });
+    };
+    // Long edges along the run (always) + end caps (only when closed).
+    seg([-halfLen, -halfW], [halfLen, -halfW], lineWidth);
+    seg([-halfLen, halfW], [halfLen, halfW], lineWidth);
+    if (node.endCaps !== false) {
+        seg([-halfLen, -halfW], [-halfLen, halfW], lineWidth);
+        seg([halfLen, -halfW], [halfLen, halfW], lineWidth);
+    }
+    // Ridge crest line down the centre.
+    seg([-halfLen, 0], [halfLen, 0], lineWidth * 0.8, 0.7);
+    // Shingled style: tab dividers across the width at the cap pitch.
+    if (node.style === 'shingled') {
+        const total = halfLen * 2;
+        const count = Math.max(2, Math.round(total / SHINGLED_TAB_SIZE));
+        const step = total / count;
+        for (let i = 1; i < count; i++) {
+            const x = -halfLen + i * step;
+            seg([x, -halfW], [x, halfW], lineWidth * 0.6, 0.5);
+        }
+    }
+    return { kind: 'group', children };
+}

package/dist/ridge-vent/geometry.d.ts

@@ -0,0 +1,22 @@
+import { type RidgeVentNode, type RoofSegmentNode } from '@pascal-app/core';
+import * as THREE from 'three';
+/**
+ * Pure builder for the ridge vent mesh. Each style is a peaked **band** of
+ * constant thickness `t` that drapes over the ridge like a real ridge cap:
+ * a shaped top surface, a parallel underside offset down by `t`, visible
+ * eave thickness faces along both edges, and end caps.
+ *
+ * This is the middle ground between the two earlier extremes — the original
+ * was a paper-thin shell (no perceptible thickness), then a flat-bottomed
+ * solid (read as a closed box). The band keeps the V / arched cap silhouette
+ * and the open underside (so it sits astride the ridge) while showing real
+ * thickness at the eaves and ends.
+ *
+ *  - `standard`: smooth rounded arch
+ *  - `shingled`: angular peak with raised shingle-course ridges across the top
+ *  - `metal`: bent-metal cap with a wide flat seam and drip lips
+ *
+ * `endCaps` closes both ends. Pure: no React, no scene access, no mutation.
+ */
+export declare function buildRidgeVentGeometry(node: RidgeVentNode, segment?: RoofSegmentNode): THREE.BufferGeometry;
+//# sourceMappingURL=geometry.d.ts.map

package/dist/ridge-vent/geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/ridge-vent/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,aAAa,EAClB,KAAK,eAAe,EACrB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAqC9B;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,aAAa,EACnB,OAAO,CAAC,EAAE,eAAe,GACxB,KAAK,CAAC,cAAc,CAiEtB"}

package/dist/ridge-vent/geometry.js

@@ -0,0 +1,526 @@
+import { getDutchRoofMetrics, getRidgeVentLinesForSegment, normalizeRoofSegmentTrim, } from '@pascal-app/core';
+import * as THREE from 'three';
+import { getRoofTopSurfaceY } from '../shared/roof-surface';
+const ARC_SEGS = 16;
+const SHINGLED_TAB_SIZE = 0.3;
+const DEFAULT_RIDGE_VENT_LENGTH = 2;
+const DEFAULT_RIDGE_VENT_WIDTH = 0.3;
+const DEFAULT_RIDGE_VENT_HEIGHT = 0.1;
+/**
+ * Pure builder for the ridge vent mesh. Each style is a peaked **band** of
+ * constant thickness `t` that drapes over the ridge like a real ridge cap:
+ * a shaped top surface, a parallel underside offset down by `t`, visible
+ * eave thickness faces along both edges, and end caps.
+ *
+ * This is the middle ground between the two earlier extremes — the original
+ * was a paper-thin shell (no perceptible thickness), then a flat-bottomed
+ * solid (read as a closed box). The band keeps the V / arched cap silhouette
+ * and the open underside (so it sits astride the ridge) while showing real
+ * thickness at the eaves and ends.
+ *
+ *  - `standard`: smooth rounded arch
+ *  - `shingled`: angular peak with raised shingle-course ridges across the top
+ *  - `metal`: bent-metal cap with a wide flat seam and drip lips
+ *
+ * `endCaps` closes both ends. Pure: no React, no scene access, no mutation.
+ */
+export function buildRidgeVentGeometry(node, segment) {
+    const length = finitePositive(node.length, DEFAULT_RIDGE_VENT_LENGTH);
+    const width = finitePositive(node.width, DEFAULT_RIDGE_VENT_WIDTH);
+    const h = finitePositive(node.height, DEFAULT_RIDGE_VENT_HEIGHT);
+    const halfLen = length / 2;
+    const halfW = width / 2;
+    // Band thickness. Generous enough to read as a solid cap; the eave faces
+    // are `t` tall, which is the depth the user actually sees from the side.
+    const t = Math.max(0.02, h * 0.4);
+    const centerX = finiteNumber(node.position?.[0], 0);
+    const centerZ = finiteNumber(node.position?.[2], 0);
+    const rotationY = finiteNumber(node.rotation, 0);
+    const sinR = Math.sin(rotationY);
+    const cosR = Math.cos(rotationY);
+    const dutchTopRidgeSupport = getDutchTopRidgeSupport(segment, centerX, centerZ, rotationY);
+    const surfaceYAt = (x, z) => {
+        if (!segment)
+            return 0;
+        let sampleX = centerX + x * cosR + z * sinR;
+        let sampleZ = centerZ - x * sinR + z * cosR;
+        if (dutchTopRidgeSupport) {
+            if (dutchTopRidgeSupport.axis === 'x') {
+                sampleX = clamp(sampleX, -dutchTopRidgeSupport.innerHalfSpan, dutchTopRidgeSupport.innerHalfSpan);
+            }
+            else {
+                sampleZ = clamp(sampleZ, -dutchTopRidgeSupport.innerHalfSpan, dutchTopRidgeSupport.innerHalfSpan);
+            }
+        }
+        return getRoofTopSurfaceY(sampleX, sampleZ, segment);
+    };
+    const ridgeY = surfaceYAt(0, 0);
+    const seatYAt = (x, z) => (segment ? surfaceYAt(x, z) - ridgeY : 0);
+    const top = node.style === 'metal'
+        ? metalTop(halfW, h, t)
+        : node.style === 'shingled'
+            ? shingledTop(halfW, h, t)
+            : standardTop(halfW, h, t);
+    const supportLine = segment ? getSupportLineForVent(segment, node) : null;
+    const endTaper = getRidgeVentEndTaper(supportLine, width, h);
+    const positions = [];
+    const normals = [];
+    const uvs = [];
+    buildBand(positions, normals, uvs, top, seatYAt, -halfLen, halfLen, node.endCaps, endTaper);
+    if (node.style === 'shingled') {
+        addShingledTabs(positions, normals, uvs, -halfLen, halfLen, top, h, seatYAt, endTaper);
+    }
+    const geometry = buildBufferGeometry(positions, normals, uvs);
+    if (!segment)
+        return geometry;
+    const clipped = clipRidgeVentGeometryToSegmentTrim(geometry, node, segment);
+    if (clipped !== geometry)
+        geometry.dispose();
+    return clipped;
+}
+function finiteNumber(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
+}
+function finitePositive(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+function getRidgeVentEndTaper(supportLine, width, height) {
+    if (!supportLine ||
+        (supportLine.name !== 'Hip Ridge Vent' && supportLine.name !== 'Slope Ridge Vent')) {
+        return null;
+    }
+    const lineLength = supportLine.endX - supportLine.startX;
+    const taperLength = Math.min(Math.max(0.07, width * 0.45, height * 0.9), Math.max(0, lineLength / 2 - 0.02));
+    if (!(taperLength > 0.001))
+        return null;
+    return {
+        taperAtStart: supportLine.taperAtStart,
+        taperAtEnd: supportLine.taperAtEnd,
+        taperLength,
+        tipHalfWidth: Math.min(width * 0.34, Math.max(0.04, width * 0.26)),
+    };
+}
+function getDutchTopRidgeSupport(segment, centerX, centerZ, rotationY) {
+    if (segment?.roofType !== 'dutch')
+        return null;
+    const metrics = getDutchRoofMetrics(segment);
+    const onWidthAxisTopRidge = metrics.axis === 'x' && Math.abs(centerZ) <= 1e-4 && Math.abs(Math.sin(rotationY)) <= 1e-4;
+    const onDepthAxisTopRidge = metrics.axis === 'z' && Math.abs(centerX) <= 1e-4 && Math.abs(Math.cos(rotationY)) <= 1e-4;
+    if (onWidthAxisTopRidge) {
+        return { axis: 'x', innerHalfSpan: metrics.waistHalfX };
+    }
+    if (onDepthAxisTopRidge) {
+        return { axis: 'z', innerHalfSpan: metrics.waistHalfZ };
+    }
+    return null;
+}
+// ─── Top profiles (open polylines eave → peak → eave, in [z, y]) ─────────
+// Eaves sit at y = t so that the underside (top − t) lands on y = 0 at the
+// eaves, seating the cap on the roof while leaving a peaked void beneath.
+// Smooth rounded arch.
+function standardTop(halfW, h, t) {
+    const pts = [];
+    for (let i = 0; i <= ARC_SEGS; i++) {
+        const frac = i / ARC_SEGS;
+        const z = -halfW + frac * 2 * halfW;
+        const y = t + (h - t) * Math.sin(frac * Math.PI);
+        pts.push([z, y]);
+    }
+    return pts;
+}
+// Angular peak with a narrow flat ridge at the top.
+function shingledTop(halfW, h, t) {
+    const peakHalf = halfW * 0.12;
+    return [
+        [-halfW, t],
+        [-peakHalf, h],
+        [peakHalf, h],
+        [halfW, t],
+    ];
+}
+// Bent-metal cap: steep folds up to a wide flat standing seam.
+function metalTop(halfW, h, t) {
+    const seamHalf = halfW * 0.5;
+    const shoulderY = t + (h - t) * 0.5;
+    return [
+        [-halfW, t],
+        [-halfW * 0.82, shoulderY],
+        [-seamHalf, h],
+        [seamHalf, h],
+        [halfW * 0.82, shoulderY],
+        [halfW, t],
+    ];
+}
+// ─── Band assembly ───────────────────────────────────────────────────────
+function buildBand(positions, normals, uvs, top, seatYAt, startX, endX, withCaps, endTaper = null) {
+    const n = top.length;
+    const halfWidth = getProfileHalfWidth(top);
+    const stations = getRidgeVentSweepStations(startX, endX, endTaper);
+    const scaledZAt = (x, z) => z * getProfileScaleAtX(x, startX, endX, halfWidth, endTaper);
+    const seatAt = (x, z) => seatYAt(x, scaledZAt(x, z));
+    const topAt = (x, z, capY) => seatAt(x, z) + capY;
+    // Top surface + underside, swept along the ridge length.
+    for (let station = 0; station < stations.length - 1; station += 1) {
+        const x0 = stations[station];
+        const x1 = stations[station + 1];
+        for (let i = 0; i < n - 1; i++) {
+            const [z0, capY0] = top[i];
+            const [z1, capY1] = top[i + 1];
+            const x0z0 = scaledZAt(x0, z0);
+            const x1z0 = scaledZAt(x1, z0);
+            const x1z1 = scaledZAt(x1, z1);
+            const x0z1 = scaledZAt(x0, z1);
+            pushQuad(positions, normals, uvs, [x0, topAt(x0, z0, capY0), x0z0], [x1, topAt(x1, z0, capY0), x1z0], [x1, topAt(x1, z1, capY1), x1z1], [x0, topAt(x0, z1, capY1), x0z1], [0, 1, 0]);
+            pushQuad(positions, normals, uvs, [x0, seatAt(x0, z0), x0z0], [x1, seatAt(x1, z0), x1z0], [x1, seatAt(x1, z1), x1z1], [x0, seatAt(x0, z1), x0z1], [0, -1, 0]);
+        }
+    }
+    // Eave thickness faces (the visible depth along each long edge).
+    for (let station = 0; station < stations.length - 1; station += 1) {
+        const x0 = stations[station];
+        const x1 = stations[station + 1];
+        for (const idx of [0, n - 1]) {
+            const [z, capY] = top[idx];
+            const x0z = scaledZAt(x0, z);
+            const x1z = scaledZAt(x1, z);
+            const hint = [0, 0, z < 0 ? -1 : 1];
+            pushQuad(positions, normals, uvs, [x0, seatAt(x0, z), x0z], [x1, seatAt(x1, z), x1z], [x1, topAt(x1, z, capY), x1z], [x0, topAt(x0, z, capY), x0z], hint);
+        }
+    }
+    // End caps: the band's cross-section ring at each end.
+    if (withCaps) {
+        for (const [x, sign] of [
+            [startX, -1],
+            [endX, 1],
+        ]) {
+            const hint = [sign, 0, 0];
+            for (let i = 0; i < n - 1; i++) {
+                const [z0, capY0] = top[i];
+                const [z1, capY1] = top[i + 1];
+                const scaledZ0 = scaledZAt(x, z0);
+                const scaledZ1 = scaledZAt(x, z1);
+                pushQuad(positions, normals, uvs, [x, topAt(x, z0, capY0), scaledZ0], [x, topAt(x, z1, capY1), scaledZ1], [x, seatAt(x, z1), scaledZ1], [x, seatAt(x, z0), scaledZ0], hint);
+            }
+        }
+    }
+}
+function getProfileHalfWidth(top) {
+    return top.reduce((halfWidth, [z]) => Math.max(halfWidth, Math.abs(z)), 0);
+}
+function getRidgeVentSweepStations(startX, endX, endTaper) {
+    const stations = [startX, endX];
+    if (endTaper?.taperAtStart)
+        stations.push(startX + endTaper.taperLength);
+    if (endTaper?.taperAtEnd)
+        stations.push(endX - endTaper.taperLength);
+    return stations
+        .filter((x) => x >= startX && x <= endX)
+        .sort((a, b) => a - b)
+        .filter((x, index, sorted) => index === 0 || Math.abs(x - sorted[index - 1]) > 1e-5);
+}
+function getProfileScaleAtX(x, startX, endX, halfWidth, endTaper) {
+    if (!endTaper || !(halfWidth > 0.0001))
+        return 1;
+    const tipScale = clamp(endTaper.tipHalfWidth / halfWidth, 0, 1);
+    if (endTaper.taperAtStart && x <= startX + endTaper.taperLength) {
+        const progress = clamp((x - startX) / endTaper.taperLength, 0, 1);
+        return lerp(tipScale, 1, progress);
+    }
+    if (endTaper.taperAtEnd && x >= endX - endTaper.taperLength) {
+        const progress = clamp((endX - x) / endTaper.taperLength, 0, 1);
+        return lerp(tipScale, 1, progress);
+    }
+    return 1;
+}
+// ─── Shingled course ridges ──────────────────────────────────────────────
+// Thin raised lines running across the cap at intervals, suggesting
+// overlapping shingle courses. Sit on the top profile edges.
+function addShingledTabs(positions, normals, uvs, startX, endX, top, h, seatYAt, endTaper = null) {
+    const totalLen = endX - startX;
+    const numTabs = Math.max(2, Math.round(totalLen / SHINGLED_TAB_SIZE));
+    const tabLen = totalLen / numTabs;
+    const ridgeH = h * 0.06;
+    const ridgeD = Math.min(0.01, tabLen * 0.15);
+    for (let tab = 1; tab < numTabs; tab++) {
+        const x = startX + tab * tabLen;
+        if (isInsideEndTaper(x, startX, endX, endTaper))
+            continue;
+        for (let i = 0; i < top.length - 1; i++) {
+            const [z0, capY0] = top[i];
+            const [z1, capY1] = top[i + 1];
+            const y0 = seatYAt(x, z0) + capY0;
+            const y1 = seatYAt(x, z1) + capY1;
+            const dz = z1 - z0;
+            const dy = y1 - y0;
+            const len = Math.sqrt(dz * dz + dy * dy) || 1;
+            const nz = -dy / len;
+            const ny = dz / len;
+            const r0y = y0 + ny * ridgeH;
+            const r0z = z0 + nz * ridgeH;
+            const r1y = y1 + ny * ridgeH;
+            const r1z = z1 + nz * ridgeH;
+            const backX = x - ridgeD;
+            const by0 = seatYAt(backX, z0) + capY0;
+            const by1 = seatYAt(backX, z1) + capY1;
+            const br0y = by0 + ny * ridgeH;
+            const br1y = by1 + ny * ridgeH;
+            pushQuad(positions, normals, uvs, [x, r0y, r0z], [x, r1y, r1z], [x, y1, z1], [x, y0, z0], [1, 0, 0]);
+            pushQuad(positions, normals, uvs, [backX, br0y, r0z], [backX, br1y, r1z], [backX, by1, z1], [backX, by0, z0], [-1, 0, 0]);
+        }
+    }
+}
+function isInsideEndTaper(x, startX, endX, endTaper) {
+    if (!endTaper)
+        return false;
+    return ((endTaper.taperAtStart && x <= startX + endTaper.taperLength) ||
+        (endTaper.taperAtEnd && x >= endX - endTaper.taperLength));
+}
+// ─── Geometry plumbing ───────────────────────────────────────────────────
+function buildBufferGeometry(positions, normals, uvs) {
+    const geo = new THREE.BufferGeometry();
+    if (positions.length === 0) {
+        geo.setAttribute('position', new THREE.Float32BufferAttribute(new Float32Array(9), 3));
+        geo.setAttribute('normal', new THREE.Float32BufferAttribute(new Float32Array(9), 3));
+        geo.setAttribute('uv', new THREE.Float32BufferAttribute(new Float32Array(6), 2));
+        geo.computeBoundingSphere();
+        return geo;
+    }
+    geo.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
+    geo.setAttribute('normal', new THREE.Float32BufferAttribute(normals, 3));
+    geo.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2));
+    geo.computeBoundingSphere();
+    return geo;
+}
+function clipRidgeVentGeometryToSegmentTrim(geometry, node, segment) {
+    const planes = getSegmentTrimClipPlanes(segment);
+    if (planes.length === 0)
+        return geometry;
+    const position = geometry.getAttribute('position');
+    const normal = geometry.getAttribute('normal');
+    const uv = geometry.getAttribute('uv');
+    if (!position || !normal || !uv)
+        return geometry;
+    const positions = [];
+    const normals = [];
+    const uvs = [];
+    for (let i = 0; i < position.count; i += 3) {
+        let polygon = [
+            readGeometryVertex(position, normal, uv, i),
+            readGeometryVertex(position, normal, uv, i + 1),
+            readGeometryVertex(position, normal, uv, i + 2),
+        ];
+        for (const plane of planes) {
+            polygon = clipPolygonToSegmentTrimPlane(polygon, plane, node);
+            if (polygon.length < 3)
+                break;
+        }
+        if (polygon.length < 3)
+            continue;
+        for (let j = 1; j < polygon.length - 1; j += 1) {
+            pushGeometryVertex(positions, normals, uvs, polygon[0]);
+            pushGeometryVertex(positions, normals, uvs, polygon[j]);
+            pushGeometryVertex(positions, normals, uvs, polygon[j + 1]);
+        }
+    }
+    return buildBufferGeometry(positions, normals, uvs);
+}
+function getSupportLineForVent(segment, node) {
+    const lines = getRidgeVentLinesForSegment(segment);
+    if (lines.length === 0)
+        return null;
+    const centerX = finiteNumber(node.position?.[0], 0);
+    const centerZ = finiteNumber(node.position?.[2], 0);
+    const rotationY = finiteNumber(node.rotation, 0);
+    const dirX = Math.cos(rotationY);
+    const dirZ = -Math.sin(rotationY);
+    let best = null;
+    let bestScore = Number.POSITIVE_INFINITY;
+    for (const line of lines) {
+        const [sx, sz] = line.start;
+        const [ex, ez] = line.end;
+        const lineDx = ex - sx;
+        const lineDz = ez - sz;
+        const lineLength = Math.hypot(lineDx, lineDz);
+        if (!(lineLength > 1e-4))
+            continue;
+        const unitX = lineDx / lineLength;
+        const unitZ = lineDz / lineLength;
+        const yawPenalty = 1 - Math.abs(unitX * dirX + unitZ * dirZ);
+        const centerOffsetX = centerX - sx;
+        const centerOffsetZ = centerZ - sz;
+        const t = Math.max(0, Math.min(lineLength, centerOffsetX * unitX + centerOffsetZ * unitZ));
+        const nearestX = sx + unitX * t;
+        const nearestZ = sz + unitZ * t;
+        const distanceSq = (centerX - nearestX) ** 2 + (centerZ - nearestZ) ** 2;
+        const score = distanceSq + yawPenalty * 6;
+        if (score < bestScore) {
+            bestScore = score;
+            const startLocalX = (sx - centerX) * dirX + (sz - centerZ) * dirZ;
+            const endLocalX = (ex - centerX) * dirX + (ez - centerZ) * dirZ;
+            const startRadiusSq = sx * sx + sz * sz;
+            const endRadiusSq = ex * ex + ez * ez;
+            const outerIsStart = startRadiusSq > endRadiusSq;
+            const minIsStart = startLocalX <= endLocalX;
+            best = {
+                startX: Math.min(startLocalX, endLocalX),
+                endX: Math.max(startLocalX, endLocalX),
+                name: line.name,
+                taperAtStart: minIsStart ? outerIsStart : !outerIsStart,
+                taperAtEnd: minIsStart ? !outerIsStart : outerIsStart,
+            };
+        }
+    }
+    return best;
+}
+function readGeometryVertex(position, normal, uv, index) {
+    return {
+        x: position.getX(index),
+        y: position.getY(index),
+        z: position.getZ(index),
+        nx: normal.getX(index),
+        ny: normal.getY(index),
+        nz: normal.getZ(index),
+        u: uv.getX(index),
+        v: uv.getY(index),
+    };
+}
+function pushGeometryVertex(positions, normals, uvs, vertex) {
+    positions.push(vertex.x, vertex.y, vertex.z);
+    normals.push(vertex.nx, vertex.ny, vertex.nz);
+    uvs.push(vertex.u, vertex.v);
+}
+function clipPolygonToSegmentTrimPlane(polygon, plane, node) {
+    const next = [];
+    let previous = polygon[polygon.length - 1];
+    let previousDistance = getTrimClipDistance(previous, plane, node);
+    let previousInside = previousDistance <= 1e-6;
+    for (const current of polygon) {
+        const currentDistance = getTrimClipDistance(current, plane, node);
+        const currentInside = currentDistance <= 1e-6;
+        if (currentInside) {
+            if (!previousInside) {
+                next.push(interpolateGeometryVertex(previous, current, previousDistance, currentDistance));
+            }
+            next.push(current);
+        }
+        else if (previousInside) {
+            next.push(interpolateGeometryVertex(previous, current, previousDistance, currentDistance));
+        }
+        previous = current;
+        previousDistance = currentDistance;
+        previousInside = currentInside;
+    }
+    return next;
+}
+function getTrimClipDistance(vertex, plane, node) {
+    const centerX = finiteNumber(node.position?.[0], 0);
+    const centerZ = finiteNumber(node.position?.[2], 0);
+    const rotationY = finiteNumber(node.rotation, 0);
+    const segmentX = centerX + vertex.x * Math.cos(rotationY) + vertex.z * Math.sin(rotationY);
+    const segmentZ = centerZ - vertex.x * Math.sin(rotationY) + vertex.z * Math.cos(rotationY);
+    return plane.signedDistance(segmentX, segmentZ);
+}
+function interpolateGeometryVertex(a, b, distanceA, distanceB) {
+    const t = distanceA / (distanceA - distanceB || 1);
+    return {
+        x: lerp(a.x, b.x, t),
+        y: lerp(a.y, b.y, t),
+        z: lerp(a.z, b.z, t),
+        nx: lerp(a.nx, b.nx, t),
+        ny: lerp(a.ny, b.ny, t),
+        nz: lerp(a.nz, b.nz, t),
+        u: lerp(a.u, b.u, t),
+        v: lerp(a.v, b.v, t),
+    };
+}
+function lerp(a, b, t) {
+    return a + (b - a) * t;
+}
+function getSegmentTrimClipPlanes(segment) {
+    const trim = normalizeRoofSegmentTrim(segment);
+    const planes = [];
+    const leftX = -segment.width / 2 + trim.left;
+    const rightX = segment.width / 2 - trim.right;
+    const frontZ = segment.depth / 2 - trim.front;
+    const backZ = -segment.depth / 2 + trim.back;
+    if (trim.left > 0)
+        planes.push({ signedDistance: (x) => leftX - x });
+    if (trim.right > 0)
+        planes.push({ signedDistance: (x) => x - rightX });
+    if (trim.front > 0)
+        planes.push({ signedDistance: (_x, z) => z - frontZ });
+    if (trim.back > 0)
+        planes.push({ signedDistance: (_x, z) => backZ - z });
+    const diagonalPlane = (lineA, lineB, outsidePoint) => {
+        const dx = lineB[0] - lineA[0];
+        const dz = lineB[1] - lineA[1];
+        const length = Math.hypot(dx, dz);
+        if (!(length > 0))
+            return null;
+        let nx = -dz / length;
+        let nz = dx / length;
+        const midX = (lineA[0] + lineB[0]) / 2;
+        const midZ = (lineA[1] + lineB[1]) / 2;
+        if (nx * (outsidePoint[0] - midX) + nz * (outsidePoint[1] - midZ) < 0) {
+            nx *= -1;
+            nz *= -1;
+        }
+        return {
+            signedDistance: (x, z) => nx * (x - midX) + nz * (z - midZ),
+        };
+    };
+    const pushDiagonalPlane = (lineA, lineB, outsidePoint) => {
+        const plane = diagonalPlane(lineA, lineB, outsidePoint);
+        if (plane)
+            planes.push(plane);
+    };
+    if (trim.frontLeftX > 0 && trim.frontLeftZ > 0) {
+        pushDiagonalPlane([leftX + trim.frontLeftX, frontZ], [leftX, frontZ - trim.frontLeftZ], [leftX - 1, frontZ + 1]);
+    }
+    if (trim.frontRightX > 0 && trim.frontRightZ > 0) {
+        pushDiagonalPlane([rightX, frontZ - trim.frontRightZ], [rightX - trim.frontRightX, frontZ], [rightX + 1, frontZ + 1]);
+    }
+    if (trim.backLeftX > 0 && trim.backLeftZ > 0) {
+        pushDiagonalPlane([leftX, backZ + trim.backLeftZ], [leftX + trim.backLeftX, backZ], [leftX - 1, backZ - 1]);
+    }
+    if (trim.backRightX > 0 && trim.backRightZ > 0) {
+        pushDiagonalPlane([rightX - trim.backRightX, backZ], [rightX, backZ + trim.backRightZ], [rightX + 1, backZ - 1]);
+    }
+    return planes;
+}
+// Winding-safe quad: triangulates (a,b,c,d) and orients both triangles so
+// the shared flat normal points toward `hint`. UVs are dimension-based so
+// painted presets tile at world scale across the ridge length and the cap.
+function pushQuad(positions, normals, uvs, a, b, c, d, hint) {
+    let nx = (c[1] - a[1]) * (b[2] - a[2]) - (c[2] - a[2]) * (b[1] - a[1]);
+    let ny = (c[2] - a[2]) * (b[0] - a[0]) - (c[0] - a[0]) * (b[2] - a[2]);
+    let nz = (c[0] - a[0]) * (b[1] - a[1]) - (c[1] - a[1]) * (b[0] - a[0]);
+    const flip = nx * hint[0] + ny * hint[1] + nz * hint[2] < 0;
+    if (flip) {
+        nx = -nx;
+        ny = -ny;
+        nz = -nz;
+    }
+    const len = Math.sqrt(nx * nx + ny * ny + nz * nz) || 1;
+    nx /= len;
+    ny /= len;
+    nz /= len;
+    const u = Math.hypot(b[0] - a[0], b[1] - a[1], b[2] - a[2]);
+    const v = Math.hypot(d[0] - a[0], d[1] - a[1], d[2] - a[2]);
+    if (flip) {
+        positions.push(a[0], a[1], a[2], b[0], b[1], b[2], c[0], c[1], c[2]);
+        uvs.push(0, 0, u, 0, u, v);
+        positions.push(a[0], a[1], a[2], c[0], c[1], c[2], d[0], d[1], d[2]);
+        uvs.push(0, 0, u, v, 0, v);
+    }
+    else {
+        positions.push(a[0], a[1], a[2], c[0], c[1], c[2], b[0], b[1], b[2]);
+        uvs.push(0, 0, u, v, u, 0);
+        positions.push(a[0], a[1], a[2], d[0], d[1], d[2], c[0], c[1], c[2]);
+        uvs.push(0, 0, 0, v, u, v);
+    }
+    for (let i = 0; i < 6; i++)
+        normals.push(nx, ny, nz);
+}

package/dist/ridge-vent/index.d.ts

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

package/dist/ridge-vent/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ridge-vent/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAA;AAClD,OAAO,EAAE,sBAAsB,EAAE,MAAM,YAAY,CAAA;AACnD,OAAO,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA"}

package/dist/ridge-vent/index.js

@@ -0,0 +1,3 @@
+export { ridgeVentDefinition } from './definition';
+export { buildRidgeVentGeometry } from './geometry';
+export { RidgeVentNode } from './schema';