@pascal-app/core 0.9.1 → 0.9.2

package/dist/schema/nodes/measurement.test.js

@@ -0,0 +1,139 @@
+import { describe, expect, test } from 'bun:test';
+import { MeasurementNode } from './measurement';
+const parseMeasurement = (measurement) => MeasurementNode.safeParse({
+    id: 'measurement_test',
+    type: 'measurement',
+    measurement,
+});
+describe('MeasurementNode', () => {
+    test('accepts exactly two finite distance points', () => {
+        expect(parseMeasurement({
+            kind: 'distance',
+            points: [
+                [0, 1, 2],
+                [3, 4, 5],
+            ],
+        }).success).toBe(true);
+        expect(parseMeasurement({
+            kind: 'distance',
+            points: [
+                [0, 1, 2],
+                [3, 4, 5],
+                [6, 7, 8],
+            ],
+        }).success).toBe(false);
+        expect(parseMeasurement({
+            kind: 'distance',
+            points: [
+                [0, 1, 2],
+                [Number.POSITIVE_INFINITY, 4, 5],
+            ],
+        }).success).toBe(false);
+    });
+    test('accepts semantic feature anchors with finite fallbacks', () => {
+        expect(parseMeasurement({
+            kind: 'distance',
+            points: [
+                {
+                    kind: 'feature',
+                    reference: {
+                        nodeId: 'wall_a',
+                        featureId: 'wall:centerline',
+                        parameters: { t: 0.25, side: 'center' },
+                    },
+                    fallback: [1, 0, 2],
+                },
+                [3, 0, 2],
+            ],
+        }).success).toBe(true);
+    });
+    test('accepts angle and perimeter measurements', () => {
+        expect(parseMeasurement({
+            kind: 'angle',
+            points: [
+                [1, 0, 0],
+                [0, 0, 0],
+                [0, 0, 1],
+            ],
+        }).success).toBe(true);
+        expect(parseMeasurement({
+            kind: 'perimeter',
+            base: [
+                [0, 0, 0],
+                [1, 0, 0],
+                [0, 0, 1],
+            ],
+        }).success).toBe(true);
+    });
+    test('requires at least three area base points', () => {
+        expect(parseMeasurement({
+            kind: 'area',
+            base: [
+                [0, 0, 0],
+                [1, 0, 0],
+                [0, 0, 1],
+            ],
+        }).success).toBe(true);
+        expect(parseMeasurement({
+            kind: 'area',
+            base: [
+                [0, 0, 0],
+                [1, 0, 0],
+            ],
+        }).success).toBe(false);
+        expect(parseMeasurement({
+            kind: 'area',
+            base: [
+                [0, 0, 0],
+                [1, 0, 0],
+                [2, 0, 0],
+            ],
+        }).success).toBe(false);
+        expect(parseMeasurement({
+            kind: 'area',
+            base: [
+                [0, 0, 0],
+                [1, 0, 0],
+                [1, 0, 1],
+                [0, 0.1, 1],
+            ],
+        }).success).toBe(false);
+    });
+    test('requires a finite extrusion and at least three volume base points', () => {
+        expect(parseMeasurement({
+            kind: 'volume',
+            base: [
+                [0, 0, 0],
+                [1, 0, 0],
+                [0, 0, 1],
+            ],
+            extrusion: [0, 2, 0],
+        }).success).toBe(true);
+        expect(parseMeasurement({
+            kind: 'volume',
+            base: [
+                [0, 0, 0],
+                [1, 0, 0],
+            ],
+            extrusion: [0, 2, 0],
+        }).success).toBe(false);
+        expect(parseMeasurement({
+            kind: 'volume',
+            base: [
+                [0, 0, 0],
+                [1, 0, 0],
+                [0, 0, 1],
+            ],
+            extrusion: [0, Number.NaN, 0],
+        }).success).toBe(false);
+        expect(parseMeasurement({
+            kind: 'volume',
+            base: [
+                [0, 0, 0],
+                [1, 0, 0],
+                [0, 0, 1],
+            ],
+            extrusion: [2, 0, 0],
+        }).success).toBe(false);
+    });
+});

package/dist/schema/nodes/pipe-fitting.d.ts

@@ -0,0 +1,56 @@
+import { z } from 'zod';
+/**
+ * DWV pipe fitting — the joints drain systems are actually built from:
+ * elbows (bends), wyes (45° branch entries, the code-preferred way to
+ * join horizontal drains), sanitary tees (square branch entries), and
+ * crosses (two opposed branches where a run passes straight through).
+ *
+ * Local-frame conventions (before `rotation`):
+ *   - elbow:        inlet faces -X, outlet turned `angle`° in XZ.
+ *   - wye:          run along X (inlet -X, outlet +X), branch collar at
+ *                   45° between +X and +Z.
+ *   - sanitary-tee: run along X, branch collar faces +Z.
+ *   - cross:        run along X, two opposed branch collars on ±Z.
+ */
+export declare const PipeFittingNode: z.ZodObject<{
+    object: z.ZodDefault<z.ZodLiteral<"node">>;
+    name: z.ZodOptional<z.ZodString>;
+    parentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    visible: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    camera: z.ZodOptional<z.ZodObject<{
+        position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        target: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        mode: z.ZodDefault<z.ZodEnum<{
+            perspective: "perspective";
+            orthographic: "orthographic";
+        }>>;
+        fov: z.ZodOptional<z.ZodNumber>;
+        zoom: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    id: z.ZodDefault<z.ZodTemplateLiteral<`pipe-fitting_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"pipe-fitting">>;
+    position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    rotation: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    fittingType: z.ZodDefault<z.ZodEnum<{
+        elbow: "elbow";
+        cross: "cross";
+        wye: "wye";
+        "sanitary-tee": "sanitary-tee";
+    }>>;
+    angle: z.ZodDefault<z.ZodNumber>;
+    diameter: z.ZodDefault<z.ZodNumber>;
+    diameter2: z.ZodDefault<z.ZodNumber>;
+    pipeMaterial: z.ZodDefault<z.ZodEnum<{
+        pvc: "pvc";
+        abs: "abs";
+        "cast-iron": "cast-iron";
+    }>>;
+    system: z.ZodDefault<z.ZodEnum<{
+        waste: "waste";
+        vent: "vent";
+    }>>;
+}, z.core.$strip>;
+export type PipeFittingNode = z.infer<typeof PipeFittingNode>;
+export type PipeFittingNodeId = PipeFittingNode['id'];
+//# sourceMappingURL=pipe-fitting.d.ts.map

package/dist/schema/nodes/pipe-fitting.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipe-fitting.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/pipe-fitting.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8B3B,CAAA;AACD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAC7D,MAAM,MAAM,iBAAiB,GAAG,eAAe,CAAC,IAAI,CAAC,CAAA"}

package/dist/schema/nodes/pipe-fitting.js

@@ -0,0 +1,45 @@
+import dedent from 'dedent';
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base';
+/**
+ * DWV pipe fitting — the joints drain systems are actually built from:
+ * elbows (bends), wyes (45° branch entries, the code-preferred way to
+ * join horizontal drains), sanitary tees (square branch entries), and
+ * crosses (two opposed branches where a run passes straight through).
+ *
+ * Local-frame conventions (before `rotation`):
+ *   - elbow:        inlet faces -X, outlet turned `angle`° in XZ.
+ *   - wye:          run along X (inlet -X, outlet +X), branch collar at
+ *                   45° between +X and +Z.
+ *   - sanitary-tee: run along X, branch collar faces +Z.
+ *   - cross:        run along X, two opposed branch collars on ±Z.
+ */
+export const PipeFittingNode = BaseNode.extend({
+    id: objectId('pipe-fitting'),
+    type: nodeType('pipe-fitting'),
+    // Level-local meters.
+    position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
+    // XYZ euler radians.
+    rotation: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
+    fittingType: z.enum(['elbow', 'wye', 'sanitary-tee', 'cross']).default('elbow'),
+    // Elbow turn in degrees — DWV bends ship as 22.5 / 45 / 90 ("long
+    // sweep" for drains); adjustable range matches the duct elbow. 0° is a
+    // straight coupling — what an elbow flattens to when its run is dragged
+    // into line with the fixed collar.
+    angle: z.number().min(0).max(90).default(90),
+    // Run nominal size in inches.
+    diameter: z.number().min(1.25).max(8).default(2),
+    // Branch collar size (wye / sanitary-tee).
+    diameter2: z.number().min(1.25).max(8).default(2),
+    pipeMaterial: z.enum(['pvc', 'abs', 'cast-iron']).default('pvc'),
+    system: z.enum(['waste', 'vent']).default('waste'),
+}).describe(dedent `
+  DWV pipe fitting - elbow (bend), wye (45° branch), sanitary tee (square branch), or cross (two opposed branches).
+  - position: [x, y, z] level-local meters
+  - rotation: [x, y, z] euler radians
+  - fittingType: elbow | wye | sanitary-tee | cross
+  - angle: elbow turn in degrees (22.5 / 45 / 90 typical)
+  - diameter: run size in inches; diameter2: branch collar size (both branches for a cross)
+  - pipeMaterial: pvc | abs | cast-iron
+  - system: waste | vent
+  `);

package/dist/schema/nodes/pipe-segment.d.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+/**
+ * DWV pipe segment — drain / waste / vent runs in US residential
+ * plumbing. Phase 2 of the distribution-system effort: the plumbing
+ * sibling of `duct-segment`, sharing the polyline model and the typed
+ * port machinery.
+ *
+ * The defining difference from ducts is SLOPE: drains must fall
+ * (IPC: ¼" per foot for pipes under 3", ⅛" allowed at 3"+). Slope is
+ * stored implicitly in the path's Y coordinates — the draw tool drops
+ * Y as you draw a waste run; vents run level or vertical.
+ *
+ * Path coordinates are level-local meters. Y may be negative (drains
+ * drop below the floor into the joist / crawl space).
+ */
+export declare const PipeSegmentNode: z.ZodObject<{
+    object: z.ZodDefault<z.ZodLiteral<"node">>;
+    name: z.ZodOptional<z.ZodString>;
+    parentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    visible: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    camera: z.ZodOptional<z.ZodObject<{
+        position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        target: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        mode: z.ZodDefault<z.ZodEnum<{
+            perspective: "perspective";
+            orthographic: "orthographic";
+        }>>;
+        fov: z.ZodOptional<z.ZodNumber>;
+        zoom: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    id: z.ZodDefault<z.ZodTemplateLiteral<`pipe-segment_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"pipe-segment">>;
+    path: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    diameter: z.ZodDefault<z.ZodNumber>;
+    pipeMaterial: z.ZodDefault<z.ZodEnum<{
+        pvc: "pvc";
+        abs: "abs";
+        "cast-iron": "cast-iron";
+    }>>;
+    system: z.ZodDefault<z.ZodEnum<{
+        waste: "waste";
+        vent: "vent";
+    }>>;
+}, z.core.$strip>;
+export type PipeSegmentNode = z.infer<typeof PipeSegmentNode>;
+export type PipeSegmentNodeId = PipeSegmentNode['id'];
+//# sourceMappingURL=pipe-segment.d.ts.map

package/dist/schema/nodes/pipe-segment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipe-segment.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/pipe-segment.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoB3B,CAAA;AACD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAC7D,MAAM,MAAM,iBAAiB,GAAG,eAAe,CAAC,IAAI,CAAC,CAAA"}

package/dist/schema/nodes/pipe-segment.js

@@ -0,0 +1,36 @@
+import dedent from 'dedent';
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base';
+/**
+ * DWV pipe segment — drain / waste / vent runs in US residential
+ * plumbing. Phase 2 of the distribution-system effort: the plumbing
+ * sibling of `duct-segment`, sharing the polyline model and the typed
+ * port machinery.
+ *
+ * The defining difference from ducts is SLOPE: drains must fall
+ * (IPC: ¼" per foot for pipes under 3", ⅛" allowed at 3"+). Slope is
+ * stored implicitly in the path's Y coordinates — the draw tool drops
+ * Y as you draw a waste run; vents run level or vertical.
+ *
+ * Path coordinates are level-local meters. Y may be negative (drains
+ * drop below the floor into the joist / crawl space).
+ */
+export const PipeSegmentNode = BaseNode.extend({
+    id: objectId('pipe-segment'),
+    type: nodeType('pipe-segment'),
+    // Polyline path in level-local meters. Minimum two points.
+    path: z.array(z.tuple([z.number(), z.number(), z.number()])).min(2),
+    // Nominal pipe size in inches. Residential DWV: 1¼ (lav tailpiece) to
+    // 4 (building drain); 6 covers oversized mains.
+    diameter: z.number().min(1.25).max(8).default(2),
+    pipeMaterial: z.enum(['pvc', 'abs', 'cast-iron']).default('pvc'),
+    // Which DWV role the run plays. Waste carries water (sloped); vent
+    // carries air (level or vertical, dashed in plan).
+    system: z.enum(['waste', 'vent']).default('waste'),
+}).describe(dedent `
+  DWV pipe segment - drain / waste / vent run as a polyline of 3D points.
+  - path: list of [x, y, z] points in level-local meters (min 2; y may go below the floor)
+  - diameter: nominal size in inches (1.5 / 2 / 3 / 4 typical residential)
+  - pipeMaterial: pvc | abs | cast-iron
+  - system: waste (sloped drains) | vent (level / vertical air pipes)
+  `);

package/dist/schema/nodes/pipe-trap.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+/**
+ * DWV trap — the P-trap between a fixture and the waste system. Holds a
+ * water seal that blocks sewer gas; every drained fixture has exactly
+ * one. Modeled as an explicit fitting (not folded into the fixture) so
+ * the trap-arm rule (IPC 909.1 max developed length to the vent) has a
+ * node to attach to and the inspector can edit size + arm length.
+ *
+ * Local-frame convention (before `rotation`): inlet faces +Y (up, to
+ * the fixture tailpiece), outlet faces +X (the horizontal trap arm
+ * toward the vented waste line).
+ */
+export declare const PipeTrapNode: z.ZodObject<{
+    object: z.ZodDefault<z.ZodLiteral<"node">>;
+    name: z.ZodOptional<z.ZodString>;
+    parentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    visible: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    camera: z.ZodOptional<z.ZodObject<{
+        position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        target: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        mode: z.ZodDefault<z.ZodEnum<{
+            perspective: "perspective";
+            orthographic: "orthographic";
+        }>>;
+        fov: z.ZodOptional<z.ZodNumber>;
+        zoom: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    id: z.ZodDefault<z.ZodTemplateLiteral<`pipe-trap_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"pipe-trap">>;
+    position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    rotation: z.ZodDefault<z.ZodNumber>;
+    diameter: z.ZodDefault<z.ZodNumber>;
+    pipeMaterial: z.ZodDefault<z.ZodEnum<{
+        pvc: "pvc";
+        abs: "abs";
+        "cast-iron": "cast-iron";
+    }>>;
+    armLengthM: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type PipeTrapNode = z.infer<typeof PipeTrapNode>;
+export type PipeTrapNodeId = PipeTrapNode['id'];
+//# sourceMappingURL=pipe-trap.d.ts.map

package/dist/schema/nodes/pipe-trap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipe-trap.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/pipe-trap.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB;;;;;;;;;;GAUG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuBxB,CAAA;AACD,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AACvD,MAAM,MAAM,cAAc,GAAG,YAAY,CAAC,IAAI,CAAC,CAAA"}

package/dist/schema/nodes/pipe-trap.js

@@ -0,0 +1,36 @@
+import dedent from 'dedent';
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base';
+/**
+ * DWV trap — the P-trap between a fixture and the waste system. Holds a
+ * water seal that blocks sewer gas; every drained fixture has exactly
+ * one. Modeled as an explicit fitting (not folded into the fixture) so
+ * the trap-arm rule (IPC 909.1 max developed length to the vent) has a
+ * node to attach to and the inspector can edit size + arm length.
+ *
+ * Local-frame convention (before `rotation`): inlet faces +Y (up, to
+ * the fixture tailpiece), outlet faces +X (the horizontal trap arm
+ * toward the vented waste line).
+ */
+export const PipeTrapNode = BaseNode.extend({
+    id: objectId('pipe-trap'),
+    type: nodeType('pipe-trap'),
+    // Level-local meters.
+    position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
+    // Yaw in radians (the arm direction in plan).
+    rotation: z.number().default(0),
+    // Trap size in inches — matches the fixture drain it serves.
+    diameter: z.number().min(1.25).max(4).default(2),
+    pipeMaterial: z.enum(['pvc', 'abs', 'cast-iron']).default('pvc'),
+    // Developed length of the trap arm (trap weir → vent) in meters. The
+    // draw tool measures it when the arm is drawn; editable in the
+    // inspector. Drives the IPC 909.1 max-trap-arm check.
+    armLengthM: z.number().min(0).default(0),
+}).describe(dedent `
+  DWV trap (P-trap) - the water-seal fitting between a fixture and the waste line.
+  - position: [x, y, z] level-local meters
+  - rotation: yaw radians (trap-arm direction in plan)
+  - diameter: trap size in inches (matches the fixture drain)
+  - pipeMaterial: pvc | abs | cast-iron
+  - armLengthM: developed length from trap to vent in meters (IPC 909.1 limited by size)
+  `);

package/dist/schema/nodes/ridge-vent-defaults.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ridge-vent-defaults.test.d.ts.map

package/dist/schema/nodes/ridge-vent-defaults.test.d.ts.map

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

package/dist/schema/nodes/ridge-vent-defaults.test.js

@@ -0,0 +1,205 @@
+import { describe, expect, test } from 'bun:test';
+import { createDefaultRidgeVentsForSegment, getRidgeVentLinesForSegment, isAutoRidgeVentEnabled, isDefaultRidgeVentNode, RidgeVentNode, } from './ridge-vent';
+import { getDutchRoofMetrics, getRoofSegmentVisibleTopBounds, ROOF_SHAPE_DEFAULTS, RoofSegmentNode, } from './roof-segment';
+describe('createDefaultRidgeVentsForSegment', () => {
+    test('creates one shingled default ridge vent for gable roofs', () => {
+        const segment = RoofSegmentNode.parse({
+            roofType: 'gable',
+            width: 8,
+            depth: 6,
+        });
+        const vents = createDefaultRidgeVentsForSegment(segment);
+        expect(vents).toHaveLength(1);
+        expect(vents[0]?.name).toBe('Ridge Vent');
+        expect(vents[0]?.style).toBe('shingled');
+        expect(vents[0]?.roofSegmentId).toBe(segment.id);
+        expect(isDefaultRidgeVentNode(vents[0], segment.id)).toBe(true);
+    });
+    test('keeps generated gable ridge vents anchored to the untrimmed ridge', () => {
+        const segment = RoofSegmentNode.parse({
+            roofType: 'gable',
+            width: 8,
+            depth: 6,
+            overhang: 0,
+            wallThickness: 0,
+            shingleThickness: 0,
+            trim: { left: 1, right: 2, front: 0, back: 0 },
+        });
+        const vents = createDefaultRidgeVentsForSegment(segment);
+        expect(vents).toHaveLength(1);
+        expect(vents[0]?.length).toBeCloseTo(8);
+        expect(vents[0]?.position[0]).toBeCloseTo(0);
+    });
+    test('creates top ridge plus four hip vents for rectangular hip roofs', () => {
+        const segment = RoofSegmentNode.parse({
+            roofType: 'hip',
+            width: 8,
+            depth: 6,
+        });
+        const vents = createDefaultRidgeVentsForSegment(segment);
+        expect(vents).toHaveLength(5);
+        expect(vents.filter((vent) => vent.name === 'Ridge Vent')).toHaveLength(1);
+        expect(vents.filter((vent) => vent.name === 'Hip Ridge Vent')).toHaveLength(4);
+        for (const vent of vents) {
+            expect(vent.style).toBe('shingled');
+            expect(vent.length).toBeGreaterThan(0.4);
+            expect(isDefaultRidgeVentNode(vent, segment.id)).toBe(true);
+        }
+    });
+    test('omits the collapsed top ridge on square hip roofs', () => {
+        const segment = RoofSegmentNode.parse({
+            roofType: 'hip',
+            width: 6,
+            depth: 6,
+        });
+        const vents = createDefaultRidgeVentsForSegment(segment);
+        expect(vents).toHaveLength(4);
+        expect(vents.every((vent) => vent.name === 'Hip Ridge Vent')).toBe(true);
+    });
+    test('creates a top ridge plus four hip vents for width-axis Dutch roofs', () => {
+        const segment = RoofSegmentNode.parse({
+            roofType: 'dutch',
+            width: 8,
+            depth: 6,
+            overhang: 0,
+            wallThickness: 0,
+            shingleThickness: 0,
+        });
+        const vents = createDefaultRidgeVentsForSegment(segment);
+        expect(vents.filter((vent) => vent.name === 'Ridge Vent')).toHaveLength(1);
+        expect(vents.filter((vent) => vent.name === 'Hip Ridge Vent')).toHaveLength(4);
+        // Width-axis Dutch ridge runs along X (constant Z = 0).
+        const metrics = getDutchRoofMetrics(segment);
+        const ridge = vents.find((vent) => vent.name === 'Ridge Vent');
+        const frontRightHip = vents.find((vent) => vent.name === 'Hip Ridge Vent' &&
+            (vent.position[0] ?? 0) > 0 &&
+            (vent.position[2] ?? 0) > 0);
+        const expectedRakeReach = Math.min(segment.dutchGabletRake, Math.max(0, segment.width / 2 - metrics.waistHalfX) * 0.98);
+        expect(ridge?.position[2]).toBeCloseTo(0);
+        expect(ridge?.length).toBeCloseTo((metrics.waistHalfX + expectedRakeReach) * 2, 2);
+        expect(frontRightHip?.position[0]).toBeCloseTo((4 + 2.93) / 2, 2);
+        expect(frontRightHip?.position[2]).toBeCloseTo((3 + 1.5) / 2, 2);
+        for (const vent of vents) {
+            expect(vent.style).toBe('shingled');
+            expect(vent.length).toBeGreaterThan(0.4);
+            expect(isDefaultRidgeVentNode(vent, segment.id)).toBe(true);
+        }
+    });
+    test('treats legacy segments with generated ridge vents as auto-enabled', () => {
+        const segment = RoofSegmentNode.parse({
+            roofType: 'gable',
+            width: 8,
+            depth: 6,
+        });
+        const vents = createDefaultRidgeVentsForSegment(segment);
+        const nodes = Object.fromEntries(vents.map((vent) => [vent.id, vent]));
+        expect(isAutoRidgeVentEnabled({
+            id: segment.id,
+            children: vents.map((vent) => vent.id),
+            metadata: {},
+        }, nodes)).toBe(true);
+    });
+    test('treats legacy preset-white ridge vents as generated defaults', () => {
+        const segment = RoofSegmentNode.parse({
+            id: 'rseg_test',
+            roofType: 'gable',
+            width: 8,
+            depth: 6,
+        });
+        const legacyVent = RidgeVentNode.parse({
+            id: 'rvent_legacy',
+            roofSegmentId: segment.id,
+            name: 'Ridge Vent',
+            style: 'shingled',
+            materialPreset: 'preset-white',
+            position: [0, 0, 0],
+            length: 8,
+        });
+        expect(isDefaultRidgeVentNode(legacyVent, segment.id)).toBe(true);
+    });
+    test('creates a Z-oriented ridge plus four hip lines for depth-axis Dutch roofs', () => {
+        const segment = RoofSegmentNode.parse({
+            roofType: 'dutch',
+            width: 6,
+            depth: 8,
+            overhang: 0,
+            wallThickness: 0,
+            shingleThickness: 0,
+        });
+        const lines = getRidgeVentLinesForSegment(segment);
+        const metrics = getDutchRoofMetrics(segment);
+        const expectedRakeReach = Math.min(segment.dutchGabletRake, Math.max(0, segment.depth / 2 - metrics.waistHalfZ) * 0.98);
+        const ridges = lines.filter((line) => line.name === 'Ridge Vent');
+        const hips = lines.filter((line) => line.name === 'Hip Ridge Vent');
+        expect(ridges).toHaveLength(1);
+        expect(hips).toHaveLength(4);
+        // Depth-axis Dutch ridge runs along Z (constant X = 0).
+        expect(ridges[0]?.start[0]).toBeCloseTo(0);
+        expect(ridges[0]?.end[0]).toBeCloseTo(0);
+        expect(Math.abs(ridges[0]?.start[1] ?? 0)).toBeCloseTo(metrics.waistHalfZ + expectedRakeReach, 2);
+    });
+    test('keeps Dutch hip lines on the rendered arris when the roof has overhang', () => {
+        // Overhang + shingle thickness expand the rendered roof; the eave corners
+        // and the waist must share that expanded frame, otherwise the hip lines
+        // tilt off the arris and the vents sink into the slope.
+        const segment = RoofSegmentNode.parse({
+            roofType: 'dutch',
+            width: 8,
+            depth: 6,
+            overhang: 0.5,
+            wallThickness: 0.2,
+            shingleThickness: 0.05,
+        });
+        const lines = getRidgeVentLinesForSegment(segment);
+        const hips = lines.filter((line) => line.name === 'Hip Ridge Vent');
+        const ridge = lines.find((line) => line.name === 'Ridge Vent');
+        expect(hips).toHaveLength(4);
+        expect(ridge).toBeDefined();
+        const bounds = getRoofSegmentVisibleTopBounds(segment);
+        const { axis, inset } = getDutchRoofMetrics(segment);
+        const waistLengthRatio = segment.dutchWaistLengthRatio;
+        // width 8 >= depth 6 -> axis 'x': the ridge runs along X (waist scaled by
+        // waistLengthRatio), and Z is the clean hipped axis (inset exactly).
+        expect(axis).toBe('x');
+        const halfWExpanded = bounds.maxX;
+        const halfDExpanded = bounds.maxZ;
+        const expectedWaistX = (halfWExpanded - inset) * waistLengthRatio;
+        const expectedWaistZ = halfDExpanded - inset;
+        const expectedRakeReach = Math.min(segment.dutchGabletRake ?? ROOF_SHAPE_DEFAULTS.dutchGabletRake, Math.max(0, halfWExpanded - expectedWaistX) * 0.98);
+        for (const hip of hips) {
+            const [ex, ez] = hip.start;
+            const [wx, wz] = hip.end;
+            // Eave end on an expanded-bounds corner; upper end at the rendered rake
+            // termination where the lower slope starts, derived from the SAME
+            // expanded frame (not the base-dim inner waist).
+            expect(Math.abs(ex)).toBeCloseTo(halfWExpanded);
+            expect(Math.abs(ez)).toBeCloseTo(halfDExpanded);
+            expect(Math.abs(wx)).toBeCloseTo(expectedWaistX + expectedRakeReach);
+            expect(Math.abs(wz)).toBeCloseTo(expectedWaistZ);
+        }
+    });
+    test('creates top ridge plus four upper hip vents plus four lower-slope vents for mansard roofs', () => {
+        const segment = RoofSegmentNode.parse({
+            roofType: 'mansard',
+            width: 8,
+            depth: 6,
+        });
+        const vents = createDefaultRidgeVentsForSegment(segment);
+        expect(vents).toHaveLength(9);
+        expect(vents.filter((vent) => vent.name === 'Ridge Vent')).toHaveLength(1);
+        expect(vents.filter((vent) => vent.name === 'Hip Ridge Vent')).toHaveLength(4);
+        expect(vents.filter((vent) => vent.name === 'Slope Ridge Vent')).toHaveLength(4);
+        expect(vents.find((vent) => vent.name === 'Ridge Vent')?.length).toBeLessThan(segment.width);
+        const slopeVents = vents.filter((vent) => vent.name === 'Slope Ridge Vent');
+        const slopeRotations = slopeVents.map((vent) => Math.abs(vent.rotation));
+        expect(slopeRotations.every((rotation) => rotation > 0.1)).toBe(true);
+        expect(slopeRotations.every((rotation) => Math.abs(rotation - Math.PI / 2) > 0.1)).toBe(true);
+        expect(slopeVents.every((vent) => Math.abs(vent.position[0]) > segment.width / 2 - 0.8 &&
+            Math.abs(vent.position[2]) > segment.depth / 2 - 0.8)).toBe(true);
+        expect(new Set(slopeVents.map((vent) => `${Math.sign(vent.position[0])},${Math.sign(vent.position[2])}`)).size).toBe(4);
+        for (const vent of vents) {
+            expect(vent.style).toBe('shingled');
+            expect(isDefaultRidgeVentNode(vent, segment.id)).toBe(true);
+        }
+    });
+});