@pascal-app/core 0.9.1 → 0.9.2

package/dist/schema/nodes/roof-segment-shape.js

@@ -0,0 +1,318 @@
+import { ROOF_SHAPE_DEFAULTS } from './roof-segment';
+export function getRoofShapeRatios(input) {
+    return {
+        gambrelLowerWidthRatio: input.gambrelLowerWidthRatio ?? ROOF_SHAPE_DEFAULTS.gambrelLowerWidthRatio,
+        mansardSteepWidthRatio: input.mansardSteepWidthRatio ?? ROOF_SHAPE_DEFAULTS.mansardSteepWidthRatio,
+        dutchHipWidthRatio: input.dutchHipWidthRatio ?? ROOF_SHAPE_DEFAULTS.dutchHipWidthRatio,
+        dutchHipHeightRatio: input.dutchHipHeightRatio ?? ROOF_SHAPE_DEFAULTS.dutchHipHeightRatio,
+        dutchWaistLengthRatio: input.dutchWaistLengthRatio ?? ROOF_SHAPE_DEFAULTS.dutchWaistLengthRatio,
+        dutchGabletRake: input.dutchGabletRake ?? ROOF_SHAPE_DEFAULTS.dutchGabletRake,
+    };
+}
+export function getDutchRoofShapeMetrics(input) {
+    const fallbackInset = Math.min(input.baseW, input.baseD) * input.shapeRatios.dutchHipWidthRatio;
+    const maxI = Math.max(0, Math.min(input.w, input.d) / 2 - 0.005);
+    const inset = Math.min(Math.max(0, input.dutchI ?? fallbackInset), maxI);
+    const peakHeight = input.wh + Math.max(0.001, input.rh);
+    const middleHeight = input.wh + input.rh * input.shapeRatios.dutchHipHeightRatio;
+    if (!(inset > 0.001) || !(peakHeight > middleHeight + 0.001))
+        return null;
+    if (input.w >= input.d) {
+        const innerWaistHalfX = Math.max(0, (input.w / 2 - inset) * input.shapeRatios.dutchWaistLengthRatio);
+        const innerWaistHalfZ = Math.max(0, input.d / 2 - inset);
+        if (!(innerWaistHalfX > 0.001 && innerWaistHalfZ > 0.001))
+            return null;
+        const rakeReach = Math.min(Math.max(0, input.shapeRatios.dutchGabletRake), Math.max(0, input.w / 2 - innerWaistHalfX) * 0.98);
+        return {
+            axis: 'width',
+            inset,
+            middleHeight,
+            peakHeight,
+            rakeReach,
+            innerWaistHalfX,
+            innerWaistHalfZ,
+            outerWaistHalfX: innerWaistHalfX + rakeReach,
+            outerWaistHalfZ: innerWaistHalfZ,
+        };
+    }
+    const innerWaistHalfX = Math.max(0, input.w / 2 - inset);
+    const innerWaistHalfZ = Math.max(0, (input.d / 2 - inset) * input.shapeRatios.dutchWaistLengthRatio);
+    if (!(innerWaistHalfX > 0.001 && innerWaistHalfZ > 0.001))
+        return null;
+    const rakeReach = Math.min(Math.max(0, input.shapeRatios.dutchGabletRake), Math.max(0, input.d / 2 - innerWaistHalfZ) * 0.98);
+    return {
+        axis: 'depth',
+        inset,
+        middleHeight,
+        peakHeight,
+        rakeReach,
+        innerWaistHalfX,
+        innerWaistHalfZ,
+        outerWaistHalfX: innerWaistHalfX,
+        outerWaistHalfZ: innerWaistHalfZ + rakeReach,
+    };
+}
+export function getRoofShapeInsets(input) {
+    let inset = (input.wh - input.baseY) * input.tanTheta;
+    const maxSafeInset = Math.min(input.brushW, input.brushD) / 2 - 0.005;
+    if (inset > maxSafeInset)
+        inset = maxSafeInset;
+    let iF = 0;
+    let iB = 0;
+    let iL = 0;
+    let iR = 0;
+    if (input.roofType === 'hip' || input.roofType === 'mansard' || input.roofType === 'dutch') {
+        iF = inset;
+        iB = inset;
+        iL = inset;
+        iR = inset;
+    }
+    else if (input.roofType === 'gable' || input.roofType === 'gambrel') {
+        iF = inset;
+        iB = inset;
+    }
+    else if (input.roofType === 'shed') {
+        iF = inset;
+    }
+    let dutchI = Math.min(input.width, input.depth) * input.dutchHipWidthRatio;
+    if (input.isVoid)
+        dutchI += input.shingleThickness;
+    return { iF, iB, iL, iR, dutchI };
+}
+export function getDutchEndSlopeFaces(input) {
+    const dutch = getDutchRoofShapeMetrics({
+        w: input.w,
+        d: input.d,
+        wh: input.wh,
+        rh: input.rh,
+        dutchI: input.insets.dutchI,
+        baseW: input.baseW,
+        baseD: input.baseD,
+        shapeRatios: input.shapeRatios,
+    });
+    if (!dutch)
+        return [];
+    const v = (x, y, z) => ({ x, y, z });
+    const e1 = v(-input.w / 2, input.wh, input.d / 2);
+    const e2 = v(input.w / 2, input.wh, input.d / 2);
+    const e3 = v(input.w / 2, input.wh, -input.d / 2);
+    const e4 = v(-input.w / 2, input.wh, -input.d / 2);
+    // The hip end slope is constructed only up to the outer waist (rake) line.
+    // Extend its top edge inward along the same hip rulings until it reaches the
+    // gablet's inner triangle (the inner waist line), continuing each
+    // eave→outer-waist ridge line so the face stays planar and the pitch is
+    // unchanged — the edge climbs past middleHeight and meets the gablet face.
+    const lerp = (a, b, t) => v(a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t, a.z + (b.z - a.z) * t);
+    const lowerAlongY = (point) => v(point.x, point.y - Math.max(0, input.dutchTopRakeThickness ?? 0), point.z);
+    if (dutch.axis === 'width') {
+        const o1 = v(-dutch.outerWaistHalfX, dutch.middleHeight, dutch.innerWaistHalfZ);
+        const o2 = v(dutch.outerWaistHalfX, dutch.middleHeight, dutch.innerWaistHalfZ);
+        const o3 = v(dutch.outerWaistHalfX, dutch.middleHeight, -dutch.innerWaistHalfZ);
+        const o4 = v(-dutch.outerWaistHalfX, dutch.middleHeight, -dutch.innerWaistHalfZ);
+        const m1 = v(-dutch.innerWaistHalfX, dutch.middleHeight, dutch.innerWaistHalfZ);
+        const m2 = v(dutch.innerWaistHalfX, dutch.middleHeight, dutch.innerWaistHalfZ);
+        const m3 = v(dutch.innerWaistHalfX, dutch.middleHeight, -dutch.innerWaistHalfZ);
+        const m4 = v(-dutch.innerWaistHalfX, dutch.middleHeight, -dutch.innerWaistHalfZ);
+        const r1 = v(-dutch.innerWaistHalfX, input.wh + input.rh, 0);
+        const r2 = v(dutch.innerWaistHalfX, input.wh + input.rh, 0);
+        const projectWidthAxisPointToEndSlope = (point, side) => {
+            const denomY = dutch.middleHeight - input.wh;
+            const tPlane = Math.abs(denomY) > 1e-9 ? (point.y - input.wh) / denomY : 0;
+            const x = side * (input.w / 2 + (dutch.outerWaistHalfX - input.w / 2) * tPlane);
+            return v(x, point.y, point.z);
+        };
+        const top2 = projectWidthAxisPointToEndSlope(lowerAlongY(lerp(m2, r2, 0.5)), 1);
+        const top3 = projectWidthAxisPointToEndSlope(lowerAlongY(lerp(m3, r2, 0.5)), 1);
+        const top1 = projectWidthAxisPointToEndSlope(lowerAlongY(lerp(m1, r1, 0.5)), -1);
+        const top4 = projectWidthAxisPointToEndSlope(lowerAlongY(lerp(m4, r1, 0.5)), -1);
+        return [
+            [e2, e3, o3, top3, top2, o2],
+            [e4, e1, o1, top1, top4, o4],
+        ];
+    }
+    const o1 = v(-dutch.innerWaistHalfX, dutch.middleHeight, dutch.outerWaistHalfZ);
+    const o2 = v(dutch.innerWaistHalfX, dutch.middleHeight, dutch.outerWaistHalfZ);
+    const o3 = v(dutch.innerWaistHalfX, dutch.middleHeight, -dutch.outerWaistHalfZ);
+    const o4 = v(-dutch.innerWaistHalfX, dutch.middleHeight, -dutch.outerWaistHalfZ);
+    const m1 = v(-dutch.innerWaistHalfX, dutch.middleHeight, dutch.innerWaistHalfZ);
+    const m2 = v(dutch.innerWaistHalfX, dutch.middleHeight, dutch.innerWaistHalfZ);
+    const m3 = v(dutch.innerWaistHalfX, dutch.middleHeight, -dutch.innerWaistHalfZ);
+    const m4 = v(-dutch.innerWaistHalfX, dutch.middleHeight, -dutch.innerWaistHalfZ);
+    const r1 = v(0, input.wh + input.rh, dutch.innerWaistHalfZ);
+    const r2 = v(0, input.wh + input.rh, -dutch.innerWaistHalfZ);
+    const projectDepthAxisPointToEndSlope = (point, side) => {
+        const denomY = dutch.middleHeight - input.wh;
+        const tPlane = Math.abs(denomY) > 1e-9 ? (point.y - input.wh) / denomY : 0;
+        const z = side * (input.d / 2 + (dutch.outerWaistHalfZ - input.d / 2) * tPlane);
+        return v(point.x, point.y, z);
+    };
+    const top2 = projectDepthAxisPointToEndSlope(lowerAlongY(lerp(m2, r1, 0.5)), 1);
+    const top1 = projectDepthAxisPointToEndSlope(lowerAlongY(lerp(m1, r1, 0.5)), 1);
+    const top4 = projectDepthAxisPointToEndSlope(lowerAlongY(lerp(m4, r2, 0.5)), -1);
+    const top3 = projectDepthAxisPointToEndSlope(lowerAlongY(lerp(m3, r2, 0.5)), -1);
+    return [
+        [e1, e2, o2, top2, top1, o1],
+        [e3, e4, o4, top4, top3, o3],
+    ];
+}
+export function getRoofModuleFaces(input) {
+    const v = (x, y, z) => ({ x, y, z });
+    const { iF = 0, iB = 0, iL = 0, iR = 0 } = input.insets;
+    const b1 = v(-input.w / 2 + iL, input.baseY, input.d / 2 - iF);
+    const b2 = v(input.w / 2 - iR, input.baseY, input.d / 2 - iF);
+    const b3 = v(input.w / 2 - iR, input.baseY, -input.d / 2 + iB);
+    const b4 = v(-input.w / 2 + iL, input.baseY, -input.d / 2 + iB);
+    const bottom = [b4, b3, b2, b1];
+    const e1 = v(-input.w / 2, input.wh, input.d / 2);
+    const e2 = v(input.w / 2, input.wh, input.d / 2);
+    const e3 = v(input.w / 2, input.wh, -input.d / 2);
+    const e4 = v(-input.w / 2, input.wh, -input.d / 2);
+    const faces = [];
+    faces.push([b1, b2, e2, e1], [b2, b3, e3, e2], [b3, b4, e4, e3], [b4, b1, e1, e4], bottom);
+    const h = input.wh + Math.max(0.001, input.rh);
+    if (input.type === 'flat' || input.rh === 0) {
+        faces.push([e1, e2, e3, e4]);
+    }
+    else if (input.type === 'gable') {
+        const r1 = v(-input.w / 2, h, 0);
+        const r2 = v(input.w / 2, h, 0);
+        faces.push([e4, e1, r1], [e2, e3, r2], [e1, e2, r2, r1], [e3, e4, r1, r2]);
+    }
+    else if (input.type === 'hip') {
+        if (Math.abs(input.w - input.d) < 0.01) {
+            const r = v(0, h, 0);
+            faces.push([e4, e1, r], [e1, e2, r], [e2, e3, r], [e3, e4, r]);
+        }
+        else if (input.w >= input.d) {
+            const r1 = v(-input.w / 2 + input.d / 2, h, 0);
+            const r2 = v(input.w / 2 - input.d / 2, h, 0);
+            faces.push([e4, e1, r1], [e2, e3, r2], [e1, e2, r2, r1], [e3, e4, r1, r2]);
+        }
+        else {
+            const r1 = v(0, h, input.d / 2 - input.w / 2);
+            const r2 = v(0, h, -input.d / 2 + input.w / 2);
+            faces.push([e1, e2, r1], [e3, e4, r2], [e2, e3, r2, r1], [e4, e1, r1, r2]);
+        }
+    }
+    else if (input.type === 'shed') {
+        const t1 = v(-input.w / 2, h, -input.d / 2);
+        const t2 = v(input.w / 2, h, -input.d / 2);
+        faces.push([e1, e2, t2, t1], [e2, e3, t2], [e3, e4, t1, t2], [e4, e1, t1]);
+    }
+    else if (input.type === 'gambrel') {
+        const mz = (input.baseD / 2) * input.shapeRatios.gambrelLowerWidthRatio;
+        const dist = input.d / 2 - mz;
+        const mh = input.wh + dist * (input.tanTheta || 0);
+        const m1 = v(-input.w / 2, mh, mz);
+        const m2 = v(input.w / 2, mh, mz);
+        const m3 = v(input.w / 2, mh, -mz);
+        const m4 = v(-input.w / 2, mh, -mz);
+        const r1 = v(-input.w / 2, h, 0);
+        const r2 = v(input.w / 2, h, 0);
+        faces.push([e4, e1, m1, r1, m4], [e2, e3, m3, r2, m2], [e1, e2, m2, m1], [m1, m2, r2, r1], [e3, e4, m4, m3], [m3, m4, r1, r2]);
+    }
+    else if (input.type === 'mansard') {
+        const i = Math.min(input.baseW, input.baseD) * input.shapeRatios.mansardSteepWidthRatio;
+        const mh = input.wh + i * (input.tanTheta || 0);
+        const m1 = v(-input.w / 2 + i, mh, input.d / 2 - i);
+        const m2 = v(input.w / 2 - i, mh, input.d / 2 - i);
+        const m3 = v(input.w / 2 - i, mh, -input.d / 2 + i);
+        const m4 = v(-input.w / 2 + i, mh, -input.d / 2 + i);
+        const topW = input.w - i * 2;
+        const topD = input.d - i * 2;
+        faces.push([e1, e2, m2, m1], [e2, e3, m3, m2], [e3, e4, m4, m3], [e4, e1, m1, m4]);
+        if (Math.abs(topW - topD) < 0.01) {
+            const r = v(0, h, 0);
+            faces.push([m4, m1, r], [m1, m2, r], [m2, m3, r], [m3, m4, r]);
+        }
+        else if (topW >= topD) {
+            const r1 = v(-topW / 2 + topD / 2, h, 0);
+            const r2 = v(topW / 2 - topD / 2, h, 0);
+            faces.push([m4, m1, r1], [m2, m3, r2], [m1, m2, r2, r1], [m3, m4, r1, r2]);
+        }
+        else {
+            const r1 = v(0, h, topD / 2 - topW / 2);
+            const r2 = v(0, h, -topD / 2 + topW / 2);
+            faces.push([m1, m2, r1], [m3, m4, r2], [m2, m3, r2, r1], [m4, m1, r1, r2]);
+        }
+    }
+    else if (input.type === 'dutch') {
+        const dutch = getDutchRoofShapeMetrics({
+            w: input.w,
+            d: input.d,
+            wh: input.wh,
+            rh: input.rh,
+            dutchI: input.insets.dutchI,
+            baseW: input.baseW,
+            baseD: input.baseD,
+            shapeRatios: input.shapeRatios,
+        });
+        if (!dutch)
+            return faces;
+        const m1 = v(-dutch.innerWaistHalfX, dutch.middleHeight, dutch.innerWaistHalfZ);
+        const m2 = v(dutch.innerWaistHalfX, dutch.middleHeight, dutch.innerWaistHalfZ);
+        const m3 = v(dutch.innerWaistHalfX, dutch.middleHeight, -dutch.innerWaistHalfZ);
+        const m4 = v(-dutch.innerWaistHalfX, dutch.middleHeight, -dutch.innerWaistHalfZ);
+        if (dutch.axis === 'width') {
+            const o1 = v(-dutch.outerWaistHalfX, dutch.middleHeight, dutch.innerWaistHalfZ);
+            const o2 = v(dutch.outerWaistHalfX, dutch.middleHeight, dutch.innerWaistHalfZ);
+            const o3 = v(dutch.outerWaistHalfX, dutch.middleHeight, -dutch.innerWaistHalfZ);
+            const o4 = v(-dutch.outerWaistHalfX, dutch.middleHeight, -dutch.innerWaistHalfZ);
+            const r1 = v(-dutch.innerWaistHalfX, h, 0);
+            const r2 = v(dutch.innerWaistHalfX, h, 0);
+            const endSlopes = input.excludeDutchEndSlopes
+                ? []
+                : getDutchEndSlopeFaces({
+                    w: input.w,
+                    d: input.d,
+                    wh: input.wh,
+                    rh: input.rh,
+                    insets: input.insets,
+                    baseW: input.baseW,
+                    baseD: input.baseD,
+                    shapeRatios: input.shapeRatios,
+                    dutchTopRakeThickness: input.dutchTopRakeThickness,
+                });
+            faces.push([e1, e2, o2, m2, m1, o1], [e3, e4, o4, m4, m3, o3]);
+            if (endSlopes.length === 2) {
+                faces.push(...endSlopes);
+            }
+            else if (!input.excludeDutchEndSlopes) {
+                faces.push([e2, e3, o3, o2], [e4, e1, o1, o4]);
+            }
+            faces.push([m1, m2, r2, r1], [m3, m4, r1, r2]);
+            faces.push([m4, m1, r1], [m2, m3, r2]);
+        }
+        else {
+            const o1 = v(-dutch.innerWaistHalfX, dutch.middleHeight, dutch.outerWaistHalfZ);
+            const o2 = v(dutch.innerWaistHalfX, dutch.middleHeight, dutch.outerWaistHalfZ);
+            const o3 = v(dutch.innerWaistHalfX, dutch.middleHeight, -dutch.outerWaistHalfZ);
+            const o4 = v(-dutch.innerWaistHalfX, dutch.middleHeight, -dutch.outerWaistHalfZ);
+            const r1 = v(0, h, dutch.innerWaistHalfZ);
+            const r2 = v(0, h, -dutch.innerWaistHalfZ);
+            const endSlopes = input.excludeDutchEndSlopes
+                ? []
+                : getDutchEndSlopeFaces({
+                    w: input.w,
+                    d: input.d,
+                    wh: input.wh,
+                    rh: input.rh,
+                    insets: input.insets,
+                    baseW: input.baseW,
+                    baseD: input.baseD,
+                    shapeRatios: input.shapeRatios,
+                    dutchTopRakeThickness: input.dutchTopRakeThickness,
+                });
+            faces.push([e2, e3, o3, m3, m2, o2], [e4, e1, o1, m1, m4, o4]);
+            if (endSlopes.length === 2) {
+                faces.push(...endSlopes);
+            }
+            else if (!input.excludeDutchEndSlopes) {
+                faces.push([e1, e2, o2, o1], [e3, e4, o4, o3]);
+            }
+            faces.push([m2, m3, r2, r1], [m4, m1, r1, r2]);
+            faces.push([m1, m2, r1], [m3, m4, r2]);
+        }
+    }
+    return faces;
+}

package/dist/schema/nodes/roof-segment-shape.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=roof-segment-shape.test.d.ts.map

package/dist/schema/nodes/roof-segment-shape.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roof-segment-shape.test.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/roof-segment-shape.test.ts"],"names":[],"mappings":""}

package/dist/schema/nodes/roof-segment-shape.test.js

@@ -0,0 +1,175 @@
+import { describe, expect, test } from 'bun:test';
+import { getDutchEndSlopeFaces, getDutchRoofShapeMetrics, getRoofModuleFaces, getRoofShapeRatios, } from './roof-segment-shape';
+describe('roof segment shape', () => {
+    test('dutch shell is built as one complete non-duplicated face set', () => {
+        const wh = 3;
+        const rh = 2;
+        const faces = getRoofModuleFaces({
+            type: 'dutch',
+            w: 8,
+            d: 6,
+            wh,
+            rh,
+            baseY: 0,
+            insets: { dutchI: 1.5 },
+            baseW: 8,
+            baseD: 6,
+            tanTheta: 1,
+            shapeRatios: getRoofShapeRatios({
+                dutchHipWidthRatio: 0.25,
+                dutchHipHeightRatio: 0.5,
+                dutchWaistLengthRatio: 1,
+                dutchGabletRake: 0.25,
+            }),
+        });
+        const peakY = wh + rh;
+        const peakFaces = faces.filter((face) => face.some((vertex) => Math.abs(vertex.y - peakY) < 1e-6));
+        const signatures = new Set(faces.map((face) => face
+            .map((vertex) => `${vertex.x.toFixed(3)},${vertex.y.toFixed(3)},${vertex.z.toFixed(3)}`)
+            .sort()
+            .join('|')));
+        expect(faces).toHaveLength(13);
+        expect(peakFaces).toHaveLength(4);
+        expect(signatures.size).toBe(faces.length);
+        const lowerRightHip = faces.find((face) => face.some((vertex) => Math.abs(vertex.x - 2.75) < 1e-6 &&
+            Math.abs(vertex.y - 4) < 1e-6 &&
+            Math.abs(vertex.z - 1.5) < 1e-6));
+        const gableTriangle = faces.find((face) => face.length === 3 &&
+            face.some((vertex) => vertex.x === 2.5 && vertex.y === 5) &&
+            face.some((vertex) => vertex.x === 2.5 && vertex.z === 1.5));
+        expect(lowerRightHip).toBeDefined();
+        expect(gableTriangle?.some((vertex) => vertex.x === 2.75)).toBe(false);
+    });
+    test('dutch depth-axis shell rotates the upper gable correctly', () => {
+        const faces = getRoofModuleFaces({
+            type: 'dutch',
+            w: 6,
+            d: 8,
+            wh: 3,
+            rh: 2,
+            baseY: 0,
+            insets: { dutchI: 1.5 },
+            baseW: 6,
+            baseD: 8,
+            tanTheta: 1,
+            shapeRatios: getRoofShapeRatios({
+                dutchHipWidthRatio: 0.25,
+                dutchHipHeightRatio: 0.5,
+                dutchWaistLengthRatio: 1,
+                dutchGabletRake: 0.25,
+            }),
+        });
+        const peakFaces = faces.filter((face) => face.some((vertex) => vertex.y === 5));
+        const ridgeOnlyOnZAxis = peakFaces
+            .flat()
+            .filter((vertex) => vertex.y === 5)
+            .every((vertex) => vertex.x === 0);
+        expect(peakFaces).toHaveLength(4);
+        expect(ridgeOnlyOnZAxis).toBe(true);
+    });
+    test('dutch end hip slope extends inward until it meets the gable triangle', () => {
+        const ratios = getRoofShapeRatios({
+            dutchHipWidthRatio: 0.25,
+            dutchHipHeightRatio: 0.5,
+            dutchWaistLengthRatio: 1,
+            dutchGabletRake: 0.75,
+        });
+        const metrics = getDutchRoofShapeMetrics({
+            w: 8,
+            d: 6,
+            wh: 3,
+            rh: 2,
+            dutchI: 1.5,
+            baseW: 8,
+            baseD: 6,
+            shapeRatios: ratios,
+        });
+        const faces = getRoofModuleFaces({
+            type: 'dutch',
+            w: 8,
+            d: 6,
+            wh: 3,
+            rh: 2,
+            baseY: 0,
+            insets: { dutchI: 1.5 },
+            baseW: 8,
+            baseD: 6,
+            tanTheta: 1,
+            shapeRatios: ratios,
+            dutchTopRakeThickness: 0.21,
+        });
+        expect(metrics?.innerWaistHalfX).toBe(2.5);
+        expect(metrics?.outerWaistHalfX).toBe(3.25);
+        // The end slope now clips against the rake's lower inner edge and is
+        // reprojected back onto the end-slope plane, so the shorter top edge stays
+        // planar instead of twisting.
+        const hipTopFace = faces.find((face) => face.some((vertex) => Math.abs(vertex.x - 4) < 1e-6 &&
+            Math.abs(vertex.y - 3) < 1e-6 &&
+            Math.abs(vertex.z - 3) < 1e-6) &&
+            face.some((vertex) => Math.abs(vertex.x - 3.0325) < 1e-6 &&
+                Math.abs(vertex.y - 4.29) < 1e-6 &&
+                Math.abs(vertex.z - 0.75) < 1e-6) &&
+            face.some((vertex) => Math.abs(vertex.x - 3.0325) < 1e-6 &&
+                Math.abs(vertex.y - 4.29) < 1e-6 &&
+                Math.abs(vertex.z + 0.75) < 1e-6));
+        const gableTriangle = faces.find((face) => face.length === 3 &&
+            face.some((vertex) => vertex.x === 2.5 && vertex.y === 5) &&
+            face.some((vertex) => vertex.x === 2.5 && vertex.z === 1.5));
+        expect(hipTopFace).toBeDefined();
+        expect(gableTriangle?.some((vertex) => vertex.x === 3.25)).toBe(false);
+    });
+    test('excludeDutchEndSlopes pulls the end slopes out into getDutchEndSlopeFaces', () => {
+        const ratios = getRoofShapeRatios({
+            dutchHipWidthRatio: 0.25,
+            dutchHipHeightRatio: 0.5,
+            dutchWaistLengthRatio: 1,
+            dutchGabletRake: 0.75,
+        });
+        const args = {
+            type: 'dutch',
+            w: 8,
+            d: 6,
+            wh: 3,
+            rh: 2,
+            baseY: 0,
+            insets: { dutchI: 1.5 },
+            baseW: 8,
+            baseD: 6,
+            tanTheta: 1,
+            shapeRatios: ratios,
+            dutchTopRakeThickness: 0.21,
+        };
+        const full = getRoofModuleFaces(args);
+        const shell = getRoofModuleFaces({ ...args, excludeDutchEndSlopes: true });
+        const endSlopes = getDutchEndSlopeFaces({
+            w: 8,
+            d: 6,
+            wh: 3,
+            rh: 2,
+            insets: { dutchI: 1.5 },
+            baseW: 8,
+            baseD: 6,
+            shapeRatios: ratios,
+            dutchTopRakeThickness: 0.21,
+        });
+        // The two end slopes leave the shell and reappear in the standalone set.
+        expect(shell).toHaveLength(full.length - 2);
+        expect(endSlopes).toHaveLength(2);
+        // The standalone end slopes are 6-point polygons whose shorter top edge is
+        // clipped to the rake's lower inner edge and then kept on the end-slope
+        // plane.
+        const endIsEndSlope = endSlopes.every((face) => face.length === 6 &&
+            face.some((vertex) => Math.abs(Math.abs(vertex.x) - 3.25) < 1e-6) &&
+            face.some((vertex) => Math.abs(Math.abs(vertex.x) - 3.0325) < 1e-6) &&
+            face.some((vertex) => Math.abs(Math.abs(vertex.x) - 4) < 1e-6));
+        expect(endIsEndSlope).toBe(true);
+        // The removed faces are exactly the end slopes — the shell keeps every
+        // other face the full module produced.
+        const signature = (face) => face
+            .map((vertex) => `${vertex.x.toFixed(3)},${vertex.y.toFixed(3)},${vertex.z.toFixed(3)}`)
+            .join('|');
+        const shellSigs = new Set(shell.map(signature));
+        const removed = full.filter((face) => !shellSigs.has(signature(face)));
+        expect(removed).toHaveLength(2);
+    });
+});

package/dist/schema/nodes/roof-segment-surface.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=roof-segment-surface.test.d.ts.map

package/dist/schema/nodes/roof-segment-surface.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roof-segment-surface.test.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/roof-segment-surface.test.ts"],"names":[],"mappings":""}

package/dist/schema/nodes/roof-segment-surface.test.js

@@ -0,0 +1,48 @@
+import { describe, expect, test } from 'bun:test';
+import { getRoofSegmentSurfaceY, ROOF_SHAPE_DEFAULTS, RoofSegmentNode } from './roof-segment';
+describe('getRoofSegmentSurfaceY', () => {
+    test('keeps the Dutch width-axis rake on the upper gable slope', () => {
+        const segment = RoofSegmentNode.parse({
+            roofType: 'dutch',
+            width: 8,
+            depth: 6,
+            wallHeight: 3,
+            pitch: 40,
+        });
+        const activeRh = getRoofSegmentSurfaceY(segment, 0, 0) - segment.wallHeight;
+        const upperRise = activeRh * (1 - segment.dutchHipHeightRatio);
+        const waistHalfZ = segment.depth / 2 - Math.min(segment.width, segment.depth) * segment.dutchHipWidthRatio;
+        const availableRake = Math.max(0, segment.width / 2 -
+            (segment.width / 2 - Math.min(segment.width, segment.depth) * segment.dutchHipWidthRatio) *
+                segment.dutchWaistLengthRatio);
+        const rakeReach = Math.min(segment.dutchGabletRake, availableRake * 0.98);
+        const localX = (segment.width / 2 - Math.min(segment.width, segment.depth) * segment.dutchHipWidthRatio) *
+            segment.dutchWaistLengthRatio +
+            rakeReach * 0.5;
+        const localZ = waistHalfZ * 0.5;
+        const expected = segment.wallHeight + activeRh - localZ * (upperRise / waistHalfZ);
+        expect(localX).toBeGreaterThan((segment.width / 2 - Math.min(segment.width, segment.depth) * segment.dutchHipWidthRatio) *
+            segment.dutchWaistLengthRatio);
+        expect(getRoofSegmentSurfaceY(segment, localX, localZ)).toBeCloseTo(expected, 6);
+    });
+    test('keeps the Dutch depth-axis rake on the upper gable slope', () => {
+        const segment = RoofSegmentNode.parse({
+            roofType: 'dutch',
+            width: 6,
+            depth: 8,
+            wallHeight: 3,
+            pitch: 40,
+        });
+        const activeRh = getRoofSegmentSurfaceY(segment, 0, 0) - segment.wallHeight;
+        const upperRise = activeRh * (1 - segment.dutchHipHeightRatio);
+        const waistHalfX = segment.width / 2 - Math.min(segment.width, segment.depth) * segment.dutchHipWidthRatio;
+        const innerWaistHalfZ = (segment.depth / 2 - Math.min(segment.width, segment.depth) * segment.dutchHipWidthRatio) *
+            segment.dutchWaistLengthRatio;
+        const rakeReach = Math.min(segment.dutchGabletRake ?? ROOF_SHAPE_DEFAULTS.dutchGabletRake, Math.max(0, segment.depth / 2 - innerWaistHalfZ) * 0.98);
+        const localX = waistHalfX * 0.5;
+        const localZ = innerWaistHalfZ + rakeReach * 0.5;
+        const expected = segment.wallHeight + activeRh - localX * (upperRise / waistHalfX);
+        expect(localZ).toBeGreaterThan(innerWaistHalfZ);
+        expect(getRoofSegmentSurfaceY(segment, localX, localZ)).toBeCloseTo(expected, 6);
+    });
+});

package/dist/schema/nodes/roof-segment-trim.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=roof-segment-trim.test.d.ts.map

package/dist/schema/nodes/roof-segment-trim.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roof-segment-trim.test.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/roof-segment-trim.test.ts"],"names":[],"mappings":""}

package/dist/schema/nodes/roof-segment-trim.test.js

@@ -0,0 +1,107 @@
+import { describe, expect, test } from 'bun:test';
+import { getRoofSegmentVisibleTopBounds, normalizeRoofSegmentTrim, RoofSegmentNode, } from './roof-segment';
+describe('roof segment trim', () => {
+    test('defaults legacy segments to no trim', () => {
+        const segment = RoofSegmentNode.parse({
+            id: 'rseg_test',
+            type: 'roof-segment',
+        });
+        expect(segment.trim).toEqual({
+            left: 0,
+            right: 0,
+            front: 0,
+            back: 0,
+            frontLeft: 0,
+            frontRight: 0,
+            backLeft: 0,
+            backRight: 0,
+            frontLeftX: 0,
+            frontLeftZ: 0,
+            frontRightX: 0,
+            frontRightZ: 0,
+            backLeftX: 0,
+            backLeftZ: 0,
+            backRightX: 0,
+            backRightZ: 0,
+        });
+    });
+    test('normalizes impossible side totals without inverting the footprint', () => {
+        const trim = normalizeRoofSegmentTrim({
+            width: 4,
+            depth: 3,
+            trim: { left: 3, right: 3, front: 2, back: 2 },
+        });
+        expect(trim.left + trim.right).toBeCloseTo(3.9);
+        expect(trim.front + trim.back).toBeCloseTo(2.9);
+    });
+    test('visible top bounds respect asymmetric trims', () => {
+        const segment = RoofSegmentNode.parse({
+            id: 'rseg_test',
+            type: 'roof-segment',
+            width: 8,
+            depth: 6,
+            overhang: 0,
+            wallThickness: 0,
+            shingleThickness: 0,
+            trim: { left: 1, right: 2, front: 0, back: 0 },
+        });
+        const bounds = getRoofSegmentVisibleTopBounds(segment);
+        expect(bounds.minX).toBeCloseTo(-3);
+        expect(bounds.maxX).toBeCloseTo(2);
+        expect(bounds.width).toBeCloseTo(5);
+    });
+    test('visible top bounds stay finite for legacy partial segments', () => {
+        const bounds = getRoofSegmentVisibleTopBounds({
+            id: 'rseg_legacy',
+            type: 'roof-segment',
+            roofType: 'gable',
+            trim: { left: 1 },
+        });
+        expect(Number.isFinite(bounds.minX)).toBe(true);
+        expect(Number.isFinite(bounds.maxX)).toBe(true);
+        expect(Number.isFinite(bounds.minZ)).toBe(true);
+        expect(Number.isFinite(bounds.maxZ)).toBe(true);
+        expect(Number.isFinite(bounds.width)).toBe(true);
+        expect(Number.isFinite(bounds.depth)).toBe(true);
+    });
+    test('diagonal trims can shorten the ridge span', () => {
+        const segment = RoofSegmentNode.parse({
+            id: 'rseg_test',
+            type: 'roof-segment',
+            width: 8,
+            depth: 6,
+            overhang: 0,
+            wallThickness: 0,
+            shingleThickness: 0,
+            trim: { left: 0, right: 0, front: 0, back: 0, frontLeft: 4, backRight: 4 },
+        });
+        const bounds = getRoofSegmentVisibleTopBounds(segment);
+        expect(bounds.minX).toBeCloseTo(-3);
+        expect(bounds.maxX).toBeCloseTo(3);
+        expect(bounds.width).toBeCloseTo(6);
+    });
+    test('diagonal trims support independent width and depth endpoints', () => {
+        const segment = RoofSegmentNode.parse({
+            id: 'rseg_test',
+            type: 'roof-segment',
+            width: 8,
+            depth: 6,
+            overhang: 0,
+            wallThickness: 0,
+            shingleThickness: 0,
+            trim: {
+                frontLeftX: 5,
+                frontLeftZ: 2,
+                backRightX: 2,
+                backRightZ: 5,
+            },
+        });
+        const trim = normalizeRoofSegmentTrim(segment);
+        const bounds = getRoofSegmentVisibleTopBounds(segment);
+        expect(trim.frontLeft).toBeCloseTo(2);
+        expect(trim.frontLeftX).toBeCloseTo(5);
+        expect(trim.frontLeftZ).toBeCloseTo(2);
+        expect(bounds.maxZ).toBeCloseTo(2.6);
+        expect(bounds.maxX).toBeCloseTo(3.2);
+    });
+});