@pascal-app/core 0.9.1 → 0.9.2

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

@@ -10,6 +10,26 @@ export declare const RoofType: z.ZodEnum<{
     mansard: "mansard";
 }>;
 export type RoofType = z.infer<typeof RoofType>;
+export declare const MIN_ROOF_SEGMENT_TRIM_SPAN = 0.1;
+export declare const RoofSegmentTrim: z.ZodDefault<z.ZodObject<{
+    left: z.ZodDefault<z.ZodNumber>;
+    right: z.ZodDefault<z.ZodNumber>;
+    front: z.ZodDefault<z.ZodNumber>;
+    back: z.ZodDefault<z.ZodNumber>;
+    frontLeft: z.ZodDefault<z.ZodNumber>;
+    frontRight: z.ZodDefault<z.ZodNumber>;
+    backLeft: z.ZodDefault<z.ZodNumber>;
+    backRight: z.ZodDefault<z.ZodNumber>;
+    frontLeftX: z.ZodDefault<z.ZodNumber>;
+    frontLeftZ: z.ZodDefault<z.ZodNumber>;
+    frontRightX: z.ZodDefault<z.ZodNumber>;
+    frontRightZ: z.ZodDefault<z.ZodNumber>;
+    backLeftX: z.ZodDefault<z.ZodNumber>;
+    backLeftZ: z.ZodDefault<z.ZodNumber>;
+    backRightX: z.ZodDefault<z.ZodNumber>;
+    backRightZ: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>>;
+export type RoofSegmentTrim = z.infer<typeof RoofSegmentTrim>;
 export declare const ROOF_SHAPE_DEFAULTS: {
     /** Gambrel: lower (steep) face occupies this fraction of the horizontal half-depth. */
     readonly gambrelLowerWidthRatio: 0.5;
@@ -23,6 +43,17 @@ export declare const ROOF_SHAPE_DEFAULTS: {
     readonly dutchHipWidthRatio: 0.25;
     /** Dutch: hip face rises this fraction of the way to the peak. */
     readonly dutchHipHeightRatio: 0.5;
+    /** Dutch: gable waist span along the ridge axis, as a fraction of the max span. */
+    readonly dutchWaistLengthRatio: 0.98;
+    /**
+     * Dutch: how far the gablet's barge board extends outward past the gablet
+     * end-wall, along the ridge axis, in metres. 0 disables the rake. The board
+     * lies in the gablet's slope planes (coplanar with the main Dutch slopes)
+     * and overhangs the lower hip skirt; the gablet end-wall itself stays put.
+     */
+    readonly dutchGabletRake: 0.48;
+    /** Dutch: thickness of the top gable rake slab. */
+    readonly dutchTopRakeThickness: 0.21;
 };
 export declare const RoofSegmentNode: z.ZodObject<{
     object: z.ZodDefault<z.ZodLiteral<"node">>;
@@ -44,7 +75,7 @@ export declare const RoofSegmentNode: z.ZodObject<{
     type: z.ZodDefault<z.ZodLiteral<"roof-segment">>;
     material: z.ZodOptional<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
-        preset: z.ZodOptional<z.ZodEnum<{
+        preset: z.ZodOptional<z.ZodCatch<z.ZodEnum<{
             custom: "custom";
             white: "white";
             brick: "brick";
@@ -55,7 +86,7 @@ export declare const RoofSegmentNode: z.ZodObject<{
             plaster: "plaster";
             tile: "tile";
             marble: "marble";
-        }>>;
+        }>>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
             roughness: z.ZodDefault<z.ZodNumber>;
@@ -77,7 +108,7 @@ export declare const RoofSegmentNode: z.ZodObject<{
     materialPreset: z.ZodOptional<z.ZodString>;
     topMaterial: z.ZodOptional<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
-        preset: z.ZodOptional<z.ZodEnum<{
+        preset: z.ZodOptional<z.ZodCatch<z.ZodEnum<{
             custom: "custom";
             white: "white";
             brick: "brick";
@@ -88,7 +119,7 @@ export declare const RoofSegmentNode: z.ZodObject<{
             plaster: "plaster";
             tile: "tile";
             marble: "marble";
-        }>>;
+        }>>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
             roughness: z.ZodDefault<z.ZodNumber>;
@@ -110,7 +141,7 @@ export declare const RoofSegmentNode: z.ZodObject<{
     topMaterialPreset: z.ZodOptional<z.ZodString>;
     edgeMaterial: z.ZodOptional<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
-        preset: z.ZodOptional<z.ZodEnum<{
+        preset: z.ZodOptional<z.ZodCatch<z.ZodEnum<{
             custom: "custom";
             white: "white";
             brick: "brick";
@@ -121,7 +152,7 @@ export declare const RoofSegmentNode: z.ZodObject<{
             plaster: "plaster";
             tile: "tile";
             marble: "marble";
-        }>>;
+        }>>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
             roughness: z.ZodDefault<z.ZodNumber>;
@@ -143,7 +174,7 @@ export declare const RoofSegmentNode: z.ZodObject<{
     edgeMaterialPreset: z.ZodOptional<z.ZodString>;
     wallMaterial: z.ZodOptional<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
-        preset: z.ZodOptional<z.ZodEnum<{
+        preset: z.ZodOptional<z.ZodCatch<z.ZodEnum<{
             custom: "custom";
             white: "white";
             brick: "brick";
@@ -154,7 +185,7 @@ export declare const RoofSegmentNode: z.ZodObject<{
             plaster: "plaster";
             tile: "tile";
             marble: "marble";
-        }>>;
+        }>>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
             roughness: z.ZodDefault<z.ZodNumber>;
@@ -187,6 +218,24 @@ export declare const RoofSegmentNode: z.ZodObject<{
     }>>;
     width: z.ZodDefault<z.ZodNumber>;
     depth: z.ZodDefault<z.ZodNumber>;
+    trim: z.ZodDefault<z.ZodObject<{
+        left: z.ZodDefault<z.ZodNumber>;
+        right: z.ZodDefault<z.ZodNumber>;
+        front: z.ZodDefault<z.ZodNumber>;
+        back: z.ZodDefault<z.ZodNumber>;
+        frontLeft: z.ZodDefault<z.ZodNumber>;
+        frontRight: z.ZodDefault<z.ZodNumber>;
+        backLeft: z.ZodDefault<z.ZodNumber>;
+        backRight: z.ZodDefault<z.ZodNumber>;
+        frontLeftX: z.ZodDefault<z.ZodNumber>;
+        frontLeftZ: z.ZodDefault<z.ZodNumber>;
+        frontRightX: z.ZodDefault<z.ZodNumber>;
+        frontRightZ: z.ZodDefault<z.ZodNumber>;
+        backLeftX: z.ZodDefault<z.ZodNumber>;
+        backLeftZ: z.ZodDefault<z.ZodNumber>;
+        backRightX: z.ZodDefault<z.ZodNumber>;
+        backRightZ: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
     wallHeight: z.ZodDefault<z.ZodNumber>;
     pitch: z.ZodDefault<z.ZodNumber>;
     wallThickness: z.ZodDefault<z.ZodNumber>;
@@ -199,9 +248,15 @@ export declare const RoofSegmentNode: z.ZodObject<{
     mansardSteepHeightRatio: z.ZodDefault<z.ZodNumber>;
     dutchHipWidthRatio: z.ZodDefault<z.ZodNumber>;
     dutchHipHeightRatio: z.ZodDefault<z.ZodNumber>;
+    dutchWaistLengthRatio: z.ZodDefault<z.ZodNumber>;
+    dutchGabletRake: z.ZodDefault<z.ZodNumber>;
+    dutchTopRakeThickness: z.ZodDefault<z.ZodNumber>;
     children: z.ZodDefault<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export type RoofSegmentNode = z.infer<typeof RoofSegmentNode>;
+export declare function normalizeRoofSegmentTrim(node: Pick<RoofSegmentNode, 'width' | 'depth'> & {
+    trim?: Partial<RoofSegmentTrim>;
+}): RoofSegmentTrim;
 /** Shape of the per-type ratios consumed by the slope helpers. */
 type ShapeRatios = {
     gambrelLowerWidthRatio: number;
@@ -210,12 +265,24 @@ type ShapeRatios = {
     mansardSteepHeightRatio: number;
     dutchHipWidthRatio: number;
     dutchHipHeightRatio: number;
+    dutchWaistLengthRatio: number;
 };
 type PitchInputs = {
     roofType: RoofType;
     width: number;
     depth: number;
 } & Partial<ShapeRatios>;
+export type DutchRoofMetrics = {
+    axis: 'x' | 'z';
+    inset: number;
+    waistHalfX: number;
+    waistHalfZ: number;
+    ridgeStart: readonly [number, number];
+    ridgeEnd: readonly [number, number];
+    shoulderInsetAlongDepth: number;
+    shoulderInsetAlongWidth: number;
+};
+export declare function getDutchRoofMetrics(input: Pick<RoofSegmentNode, 'width' | 'depth'> & Partial<Pick<RoofSegmentNode, 'dutchHipWidthRatio' | 'dutchWaistLengthRatio'>>): DutchRoofMetrics;
 export type SegmentSlopeFrame = {
     /** Horizontal half-span of the primary slope face (eave-to-ridge). */
     run: number;
@@ -244,6 +311,15 @@ export declare function getSegmentSlopeFrame(node: Pick<RoofSegmentNode, 'roofTy
  * footprint + roofType. Replaces the legacy `roofHeight` field on the node.
  */
 export declare function getActiveRoofHeight(node: Parameters<typeof getSegmentSlopeFrame>[0]): number;
+export type RoofSegmentVisibleTopBounds = {
+    minX: number;
+    maxX: number;
+    minZ: number;
+    maxZ: number;
+    width: number;
+    depth: number;
+};
+export declare function getRoofSegmentVisibleTopBounds(segment: RoofSegmentNode): RoofSegmentVisibleTopBounds;
 /** Segment-local surface height used by roof accessory placement and hit disambiguation. */
 export declare function getRoofSegmentSurfaceY(node: Pick<RoofSegmentNode, 'roofType' | 'width' | 'depth' | 'wallHeight'> & Parameters<typeof getSegmentSlopeFrame>[0], localX: number, localZ: number): number;
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"roof-segment.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/roof-segment.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"roof-segment.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/roof-segment.ts"],"names":[],"mappings":"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"}

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

@@ -3,6 +3,46 @@ import { z } from 'zod';
 import { BaseNode, nodeType, objectId } from '../base';
 import { MaterialSchema } from '../material';
 export const RoofType = z.enum(['hip', 'gable', 'shed', 'gambrel', 'dutch', 'mansard', 'flat']);
+export const MIN_ROOF_SEGMENT_TRIM_SPAN = 0.1;
+const DEFAULT_ROOF_SEGMENT_WIDTH = 8;
+const DEFAULT_ROOF_SEGMENT_DEPTH = 6;
+export const RoofSegmentTrim = z
+    .object({
+    left: z.number().min(0).default(0),
+    right: z.number().min(0).default(0),
+    front: z.number().min(0).default(0),
+    back: z.number().min(0).default(0),
+    frontLeft: z.number().min(0).default(0),
+    frontRight: z.number().min(0).default(0),
+    backLeft: z.number().min(0).default(0),
+    backRight: z.number().min(0).default(0),
+    frontLeftX: z.number().min(0).default(0),
+    frontLeftZ: z.number().min(0).default(0),
+    frontRightX: z.number().min(0).default(0),
+    frontRightZ: z.number().min(0).default(0),
+    backLeftX: z.number().min(0).default(0),
+    backLeftZ: z.number().min(0).default(0),
+    backRightX: z.number().min(0).default(0),
+    backRightZ: z.number().min(0).default(0),
+})
+    .default({
+    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,
+});
 // Default shape ratios. Tuning these used to require editing the geometry
 // code in two places; they are now schema fields with these defaults.
 export const ROOF_SHAPE_DEFAULTS = {
@@ -18,6 +58,17 @@ export const ROOF_SHAPE_DEFAULTS = {
     dutchHipWidthRatio: 0.25,
     /** Dutch: hip face rises this fraction of the way to the peak. */
     dutchHipHeightRatio: 0.5,
+    /** Dutch: gable waist span along the ridge axis, as a fraction of the max span. */
+    dutchWaistLengthRatio: 0.98,
+    /**
+     * Dutch: how far the gablet's barge board extends outward past the gablet
+     * end-wall, along the ridge axis, in metres. 0 disables the rake. The board
+     * lies in the gablet's slope planes (coplanar with the main Dutch slopes)
+     * and overhangs the lower hip skirt; the gablet end-wall itself stays put.
+     */
+    dutchGabletRake: 0.48,
+    /** Dutch: thickness of the top gable rake slab. */
+    dutchTopRakeThickness: 0.21,
 };
 export const RoofSegmentNode = BaseNode.extend({
     id: objectId('rseg'),
@@ -45,6 +96,10 @@ export const RoofSegmentNode = BaseNode.extend({
     // Footprint dimensions
     width: z.number().default(8),
     depth: z.number().default(6),
+    // Segment-local distances trimmed from each footprint side. The trim
+    // boundary is projected vertically through the roof volume, so the
+    // resulting edge follows the actual sloped roof surfaces.
+    trim: RoofSegmentTrim,
     // Wall height beneath the roof
     wallHeight: z.number().default(0.5),
     // Roof pitch in degrees — angle of the primary slope face.
@@ -90,6 +145,17 @@ export const RoofSegmentNode = BaseNode.extend({
         .min(0.1)
         .max(0.9)
         .default(ROOF_SHAPE_DEFAULTS.dutchHipHeightRatio),
+    dutchWaistLengthRatio: z
+        .number()
+        .min(0.1)
+        .max(1)
+        .default(ROOF_SHAPE_DEFAULTS.dutchWaistLengthRatio),
+    dutchGabletRake: z.number().min(0).max(3).default(ROOF_SHAPE_DEFAULTS.dutchGabletRake),
+    dutchTopRakeThickness: z
+        .number()
+        .min(0.01)
+        .max(0.5)
+        .default(ROOF_SHAPE_DEFAULTS.dutchTopRakeThickness),
     // Hosted accessories — chimney, dormer, skylight, box-vent,
     // ridge-vent, solar-panel, gutter. Each accessory's `parentId` points back
     // here; the segment renderer mounts them recursively via
@@ -105,6 +171,7 @@ export const RoofSegmentNode = BaseNode.extend({
   Multiple segments can be combined to form complex roof shapes.
   - roofType: hip, gable, shed, gambrel, dutch, mansard, flat
   - width/depth: footprint dimensions
+  - trim: segment-local side cut distances
   - wallHeight: height of walls below the roof
   - pitch: roof slope in degrees (angle of the primary slope face)
   - wallThickness/deckThickness: structural thicknesses
@@ -113,16 +180,144 @@ export const RoofSegmentNode = BaseNode.extend({
   - gambrelLowerWidthRatio / gambrelLowerHeightRatio: kink position on gambrel roofs
   - mansardSteepWidthRatio / mansardSteepHeightRatio: waist position on mansard roofs
   - dutchHipWidthRatio / dutchHipHeightRatio: hip-to-gable split on dutch roofs
+  - dutchWaistLengthRatio: gable waist span along the ridge axis
+  - dutchGabletRake: gablet barge-board overhang past the gablet end-wall (m, 0 = none)
+  - dutchTopRakeThickness: thickness of the top gable rake slab
   `);
+function finiteNonNegative(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? Math.max(0, value) : 0;
+}
+function finitePositive(value, fallback) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function normalizeTrimAxis(start, end, span) {
+    const maxTotal = Math.max(0, finiteNonNegative(span) - MIN_ROOF_SEGMENT_TRIM_SPAN);
+    let a = Math.min(finiteNonNegative(start), maxTotal);
+    let b = Math.min(finiteNonNegative(end), maxTotal);
+    const total = a + b;
+    if (total > maxTotal && total > 0) {
+        const scale = maxTotal / total;
+        a *= scale;
+        b *= scale;
+    }
+    return [a, b];
+}
+export function normalizeRoofSegmentTrim(node) {
+    const trim = node.trim ?? {};
+    const [left, right] = normalizeTrimAxis(trim.left, trim.right, node.width);
+    const [back, front] = normalizeTrimAxis(trim.back, trim.front, node.depth);
+    const maxWidthDiagonal = Math.max(0, finiteNonNegative(node.width) - left - right);
+    const maxDepthDiagonal = Math.max(0, finiteNonNegative(node.depth) - front - back);
+    const maxWidthPair = Math.max(0, maxWidthDiagonal - MIN_ROOF_SEGMENT_TRIM_SPAN);
+    const maxDepthPair = Math.max(0, maxDepthDiagonal - MIN_ROOF_SEGMENT_TRIM_SPAN);
+    let [frontLeftX, frontLeftZ] = normalizeCornerAxisTrim(trim.frontLeft, trim.frontLeftX, trim.frontLeftZ, maxWidthPair, maxDepthPair);
+    let [frontRightX, frontRightZ] = normalizeCornerAxisTrim(trim.frontRight, trim.frontRightX, trim.frontRightZ, maxWidthPair, maxDepthPair);
+    let [backLeftX, backLeftZ] = normalizeCornerAxisTrim(trim.backLeft, trim.backLeftX, trim.backLeftZ, maxWidthPair, maxDepthPair);
+    let [backRightX, backRightZ] = normalizeCornerAxisTrim(trim.backRight, trim.backRightX, trim.backRightZ, maxWidthPair, maxDepthPair);
+    for (let i = 0; i < 3; i += 1) {
+        ;
+        [frontLeftX, frontRightX] = normalizeTrimPair(frontLeftX, frontRightX, maxWidthPair);
+        [backLeftX, backRightX] = normalizeTrimPair(backLeftX, backRightX, maxWidthPair);
+        [frontLeftZ, backLeftZ] = normalizeTrimPair(frontLeftZ, backLeftZ, maxDepthPair);
+        [frontRightZ, backRightZ] = normalizeTrimPair(frontRightZ, backRightZ, maxDepthPair);
+    }
+    const frontLeft = Math.min(frontLeftX, frontLeftZ);
+    const frontRight = Math.min(frontRightX, frontRightZ);
+    const backLeft = Math.min(backLeftX, backLeftZ);
+    const backRight = Math.min(backRightX, backRightZ);
+    return {
+        left,
+        right,
+        front,
+        back,
+        frontLeft,
+        frontRight,
+        backLeft,
+        backRight,
+        frontLeftX,
+        frontLeftZ,
+        frontRightX,
+        frontRightZ,
+        backLeftX,
+        backLeftZ,
+        backRightX,
+        backRightZ,
+    };
+}
+function normalizeTrimPair(a, b, maxTotal) {
+    const total = a + b;
+    if (total <= maxTotal || total <= 0)
+        return [a, b];
+    const scale = maxTotal / total;
+    return [a * scale, b * scale];
+}
+function normalizeCornerAxisTrim(scalar, axisX, axisZ, maxX, maxZ) {
+    const x = finiteNonNegative(axisX);
+    const z = finiteNonNegative(axisZ);
+    const fallback = finiteNonNegative(scalar);
+    if (x > 0 || z > 0) {
+        return [Math.min(x, maxX), Math.min(z, maxZ)];
+    }
+    return [Math.min(fallback, maxX), Math.min(fallback, maxZ)];
+}
+function getDutchUpperShellBounds(node) {
+    const metrics = getDutchRoofMetrics(node);
+    const width = finitePositive(node.width, DEFAULT_ROOF_SEGMENT_WIDTH);
+    const depth = finitePositive(node.depth, DEFAULT_ROOF_SEGMENT_DEPTH);
+    const rake = node.dutchGabletRake ?? ROOF_SHAPE_DEFAULTS.dutchGabletRake;
+    const rakeReach = metrics.axis === 'x'
+        ? Math.min(Math.max(0, rake), Math.max(0, width / 2 - metrics.waistHalfX) * 0.98)
+        : Math.min(Math.max(0, rake), Math.max(0, depth / 2 - metrics.waistHalfZ) * 0.98);
+    return {
+        ...metrics,
+        upperHalfX: metrics.axis === 'x' ? metrics.waistHalfX + rakeReach : metrics.waistHalfX,
+        upperHalfZ: metrics.axis === 'x' ? metrics.waistHalfZ : metrics.waistHalfZ + rakeReach,
+    };
+}
 function withRatioDefaults(input) {
     return {
         ...input,
+        width: finitePositive(input.width, DEFAULT_ROOF_SEGMENT_WIDTH),
+        depth: finitePositive(input.depth, DEFAULT_ROOF_SEGMENT_DEPTH),
         gambrelLowerWidthRatio: input.gambrelLowerWidthRatio ?? ROOF_SHAPE_DEFAULTS.gambrelLowerWidthRatio,
         gambrelLowerHeightRatio: input.gambrelLowerHeightRatio ?? ROOF_SHAPE_DEFAULTS.gambrelLowerHeightRatio,
         mansardSteepWidthRatio: input.mansardSteepWidthRatio ?? ROOF_SHAPE_DEFAULTS.mansardSteepWidthRatio,
         mansardSteepHeightRatio: input.mansardSteepHeightRatio ?? ROOF_SHAPE_DEFAULTS.mansardSteepHeightRatio,
         dutchHipWidthRatio: input.dutchHipWidthRatio ?? ROOF_SHAPE_DEFAULTS.dutchHipWidthRatio,
         dutchHipHeightRatio: input.dutchHipHeightRatio ?? ROOF_SHAPE_DEFAULTS.dutchHipHeightRatio,
+        dutchWaistLengthRatio: input.dutchWaistLengthRatio ?? ROOF_SHAPE_DEFAULTS.dutchWaistLengthRatio,
+    };
+}
+export function getDutchRoofMetrics(input) {
+    const width = finitePositive(input.width, DEFAULT_ROOF_SEGMENT_WIDTH);
+    const depth = finitePositive(input.depth, DEFAULT_ROOF_SEGMENT_DEPTH);
+    const inset = Math.min(width, depth) * (input.dutchHipWidthRatio ?? ROOF_SHAPE_DEFAULTS.dutchHipWidthRatio);
+    const waistLengthRatio = input.dutchWaistLengthRatio ?? ROOF_SHAPE_DEFAULTS.dutchWaistLengthRatio;
+    if (width >= depth) {
+        const waistHalfX = Math.max(0, (width / 2 - inset) * waistLengthRatio);
+        const waistHalfZ = Math.max(0, depth / 2 - inset);
+        return {
+            axis: 'x',
+            inset,
+            waistHalfX,
+            waistHalfZ,
+            ridgeStart: [-waistHalfX, 0],
+            ridgeEnd: [waistHalfX, 0],
+            shoulderInsetAlongDepth: Math.max(0, depth / 2 - waistHalfZ),
+            shoulderInsetAlongWidth: Math.max(0, width / 2 - waistHalfX),
+        };
+    }
+    const waistHalfX = Math.max(0, width / 2 - inset);
+    const waistHalfZ = Math.max(0, (depth / 2 - inset) * waistLengthRatio);
+    return {
+        axis: 'z',
+        inset,
+        waistHalfX,
+        waistHalfZ,
+        ridgeStart: [0, waistHalfZ],
+        ridgeEnd: [0, -waistHalfZ],
+        shoulderInsetAlongDepth: Math.max(0, depth / 2 - waistHalfZ),
+        shoulderInsetAlongWidth: Math.max(0, width / 2 - waistHalfX),
     };
 }
 function getPrimarySlopeRun(input) {
@@ -188,19 +383,109 @@ export function getSegmentSlopeFrame(node) {
 export function getActiveRoofHeight(node) {
     return getSegmentSlopeFrame(node).activeRh;
 }
+export function getRoofSegmentVisibleTopBounds(segment) {
+    const { activeRh, cosTheta, sinTheta } = getSegmentSlopeFrame(segment);
+    const width = finitePositive(segment.width, DEFAULT_ROOF_SEGMENT_WIDTH);
+    const depth = finitePositive(segment.depth, DEFAULT_ROOF_SEGMENT_DEPTH);
+    const trim = normalizeRoofSegmentTrim({ ...segment, width, depth });
+    const horizontalOverhang = finiteNonNegative(segment.overhang) * cosTheta;
+    const deckExt = finiteNonNegative(segment.wallThickness) / 2 + horizontalOverhang;
+    const shingleOverhang = finiteNonNegative(segment.shingleThickness) * sinTheta;
+    let xExt = deckExt;
+    let frontExt = deckExt;
+    let backExt = deckExt;
+    if (segment.roofType === 'hip' ||
+        segment.roofType === 'mansard' ||
+        segment.roofType === 'dutch') {
+        xExt += shingleOverhang;
+        frontExt += shingleOverhang;
+        backExt += shingleOverhang;
+    }
+    else if (segment.roofType === 'gable' || segment.roofType === 'gambrel') {
+        frontExt += shingleOverhang;
+        backExt += shingleOverhang;
+    }
+    else if (segment.roofType === 'shed' && activeRh > 0) {
+        frontExt += shingleOverhang;
+    }
+    let minX = trim.left > 0 ? -width / 2 + trim.left : -width / 2 - xExt;
+    let maxX = trim.right > 0 ? width / 2 - trim.right : width / 2 + xExt;
+    let minZ = trim.back > 0 ? -depth / 2 + trim.back : -depth / 2 - backExt;
+    let maxZ = trim.front > 0 ? depth / 2 - trim.front : depth / 2 + frontExt;
+    if (trim.frontLeftX > 0 && trim.frontLeftZ > 0 && maxZ - trim.frontLeftZ < 0) {
+        minX = Math.max(minX, minX + (trim.frontLeftX * (trim.frontLeftZ - maxZ)) / trim.frontLeftZ);
+    }
+    if (trim.backLeftX > 0 && trim.backLeftZ > 0 && minZ + trim.backLeftZ > 0) {
+        minX = Math.max(minX, minX + (trim.backLeftX * (trim.backLeftZ + minZ)) / trim.backLeftZ);
+    }
+    if (trim.frontRightX > 0 && trim.frontRightZ > 0 && maxZ - trim.frontRightZ < 0) {
+        maxX = Math.min(maxX, maxX - (trim.frontRightX * (trim.frontRightZ - maxZ)) / trim.frontRightZ);
+    }
+    if (trim.backRightX > 0 && trim.backRightZ > 0 && minZ + trim.backRightZ > 0) {
+        maxX = Math.min(maxX, maxX - (trim.backRightX * (trim.backRightZ + minZ)) / trim.backRightZ);
+    }
+    if (trim.frontLeftX > 0 && trim.frontLeftZ > 0 && minX + trim.frontLeftX > 0) {
+        maxZ = Math.min(maxZ, maxZ - (trim.frontLeftZ * (trim.frontLeftX + minX)) / trim.frontLeftX);
+    }
+    if (trim.frontRightX > 0 && trim.frontRightZ > 0 && maxX - trim.frontRightX < 0) {
+        maxZ = Math.min(maxZ, maxZ - (trim.frontRightZ * (trim.frontRightX - maxX)) / trim.frontRightX);
+    }
+    if (trim.backLeftX > 0 && trim.backLeftZ > 0 && minX + trim.backLeftX > 0) {
+        minZ = Math.max(minZ, minZ + (trim.backLeftZ * (trim.backLeftX + minX)) / trim.backLeftX);
+    }
+    if (trim.backRightX > 0 && trim.backRightZ > 0 && maxX - trim.backRightX < 0) {
+        minZ = Math.max(minZ, minZ + (trim.backRightZ * (trim.backRightX - maxX)) / trim.backRightX);
+    }
+    return {
+        minX,
+        maxX,
+        minZ,
+        maxZ,
+        width: Math.max(0.01, maxX - minX),
+        depth: Math.max(0.01, maxZ - minZ),
+    };
+}
 /** Segment-local surface height used by roof accessory placement and hit disambiguation. */
 export function getRoofSegmentSurfaceY(node, localX, localZ) {
-    const activeRh = getActiveRoofHeight(node);
+    const slopeFrame = getSegmentSlopeFrame(node);
+    const activeRh = slopeFrame.activeRh;
     const peakY = node.wallHeight + activeRh;
     if (activeRh === 0)
         return node.wallHeight;
-    if (node.roofType === 'gable' ||
-        node.roofType === 'gambrel' ||
-        node.roofType === 'mansard' ||
-        node.roofType === 'dutch') {
+    if (node.roofType === 'gable' || node.roofType === 'gambrel' || node.roofType === 'mansard') {
         const t = node.depth > 0 ? Math.abs(localZ) / (node.depth / 2) : 0;
         return peakY - t * activeRh;
     }
+    if (node.roofType === 'dutch') {
+        const hipHeightRatio = node.dutchHipHeightRatio ?? ROOF_SHAPE_DEFAULTS.dutchHipHeightRatio;
+        const metrics = getDutchUpperShellBounds(node);
+        const lowerRise = activeRh * hipHeightRatio;
+        if (metrics.axis === 'x') {
+            const waistHalfZ = Math.max(0.0001, metrics.waistHalfZ);
+            if (Math.abs(localX) <= metrics.upperHalfX && Math.abs(localZ) <= waistHalfZ) {
+                const upperRise = activeRh * (1 - hipHeightRatio);
+                const upperTan = upperRise / waistHalfZ;
+                return peakY - Math.abs(localZ) * upperTan;
+            }
+            const xProgressDenom = Math.max(0.0001, node.width / 2 - metrics.waistHalfX);
+            const zProgressDenom = Math.max(0.0001, node.depth / 2 - waistHalfZ);
+            const xProgress = Math.max(0, Math.abs(localX) - metrics.waistHalfX) / xProgressDenom;
+            const zProgress = Math.max(0, Math.abs(localZ) - waistHalfZ) / zProgressDenom;
+            return node.wallHeight + lowerRise * (1 - Math.min(1, Math.max(xProgress, zProgress)));
+        }
+        const waistHalfX = Math.max(0.0001, metrics.waistHalfX);
+        if (Math.abs(localX) <= waistHalfX && Math.abs(localZ) <= metrics.upperHalfZ) {
+            const upperRise = activeRh * (1 - hipHeightRatio);
+            const upperRun = waistHalfX;
+            const upperTan = upperRise / upperRun;
+            return peakY - Math.abs(localX) * upperTan;
+        }
+        const xProgressDenom = Math.max(0.0001, node.width / 2 - waistHalfX);
+        const zProgressDenom = Math.max(0.0001, node.depth / 2 - metrics.waistHalfZ);
+        const xProgress = Math.max(0, Math.abs(localX) - waistHalfX) / xProgressDenom;
+        const zProgress = Math.max(0, Math.abs(localZ) - metrics.waistHalfZ) / zProgressDenom;
+        return node.wallHeight + lowerRise * (1 - Math.min(1, Math.max(xProgress, zProgress)));
+    }
     if (node.roofType === 'shed') {
         const t = (localZ + node.depth / 2) / (node.depth || 1);
         return peakY - t * activeRh;

package/dist/schema/nodes/roof.d.ts

@@ -25,7 +25,7 @@ export declare const RoofNode: z.ZodObject<{
     type: z.ZodDefault<z.ZodLiteral<"roof">>;
     material: z.ZodOptional<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
-        preset: z.ZodOptional<z.ZodEnum<{
+        preset: z.ZodOptional<z.ZodCatch<z.ZodEnum<{
             custom: "custom";
             white: "white";
             brick: "brick";
@@ -36,7 +36,7 @@ export declare const RoofNode: z.ZodObject<{
             plaster: "plaster";
             tile: "tile";
             marble: "marble";
-        }>>;
+        }>>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
             roughness: z.ZodDefault<z.ZodNumber>;
@@ -58,7 +58,7 @@ export declare const RoofNode: z.ZodObject<{
     materialPreset: z.ZodOptional<z.ZodString>;
     topMaterial: z.ZodOptional<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
-        preset: z.ZodOptional<z.ZodEnum<{
+        preset: z.ZodOptional<z.ZodCatch<z.ZodEnum<{
             custom: "custom";
             white: "white";
             brick: "brick";
@@ -69,7 +69,7 @@ export declare const RoofNode: z.ZodObject<{
             plaster: "plaster";
             tile: "tile";
             marble: "marble";
-        }>>;
+        }>>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
             roughness: z.ZodDefault<z.ZodNumber>;
@@ -91,7 +91,7 @@ export declare const RoofNode: z.ZodObject<{
     topMaterialPreset: z.ZodOptional<z.ZodString>;
     edgeMaterial: z.ZodOptional<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
-        preset: z.ZodOptional<z.ZodEnum<{
+        preset: z.ZodOptional<z.ZodCatch<z.ZodEnum<{
             custom: "custom";
             white: "white";
             brick: "brick";
@@ -102,7 +102,7 @@ export declare const RoofNode: z.ZodObject<{
             plaster: "plaster";
             tile: "tile";
             marble: "marble";
-        }>>;
+        }>>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
             roughness: z.ZodDefault<z.ZodNumber>;
@@ -124,7 +124,7 @@ export declare const RoofNode: z.ZodObject<{
     edgeMaterialPreset: z.ZodOptional<z.ZodString>;
     wallMaterial: z.ZodOptional<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
-        preset: z.ZodOptional<z.ZodEnum<{
+        preset: z.ZodOptional<z.ZodCatch<z.ZodEnum<{
             custom: "custom";
             white: "white";
             brick: "brick";
@@ -135,7 +135,7 @@ export declare const RoofNode: z.ZodObject<{
             plaster: "plaster";
             tile: "tile";
             marble: "marble";
-        }>>;
+        }>>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
             roughness: z.ZodDefault<z.ZodNumber>;

package/dist/schema/nodes/shelf.d.ts

@@ -69,7 +69,7 @@ export declare const ShelfNode: z.ZodObject<{
     }>>;
     material: z.ZodOptional<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
-        preset: z.ZodOptional<z.ZodEnum<{
+        preset: z.ZodOptional<z.ZodCatch<z.ZodEnum<{
             custom: "custom";
             white: "white";
             brick: "brick";
@@ -80,7 +80,7 @@ export declare const ShelfNode: z.ZodObject<{
             plaster: "plaster";
             tile: "tile";
             marble: "marble";
-        }>>;
+        }>>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
             roughness: z.ZodDefault<z.ZodNumber>;
@@ -100,6 +100,7 @@ export declare const ShelfNode: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>>;
     materialPreset: z.ZodOptional<z.ZodString>;
+    slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
 }, z.core.$strip>;
 export type ShelfNode = z.infer<typeof ShelfNode>;
 //# sourceMappingURL=shelf.d.ts.map

package/dist/schema/nodes/shelf.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shelf.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/shelf.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwDpB,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}
+{"version":3,"file":"shelf.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/shelf.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+DpB,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}