@pascal-app/core 0.9.1 → 1.0.0-beta.1

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

@@ -47,6 +47,7 @@ export declare const ShelfNode: z.ZodObject<{
     children: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodTemplateLiteral<`item_${string}`>>>>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     rotation: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    supportSlabId: z.ZodOptional<z.ZodString>;
     width: z.ZodDefault<z.ZodNumber>;
     depth: z.ZodDefault<z.ZodNumber>;
     thickness: z.ZodDefault<z.ZodNumber>;
@@ -69,7 +70,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 +81,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 +101,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiEpB,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}

package/dist/schema/nodes/shelf.js

@@ -42,6 +42,8 @@ export const ShelfNode = BaseNode.extend({
     children: z.array(ItemNode.shape.id).default([]),
     position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
     rotation: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
+    // Persisted slab-support host — see ItemNode.supportSlabId for the rules.
+    supportSlabId: z.string().optional(),
     // Dimensions (meters). Schema-level defaults intentionally reproduce
     // the v1 wall-shelf so existing v1 scenes that omit the v2-introduced
     // fields (style / rows / columns / with*) load with their original
@@ -81,4 +83,10 @@ export const ShelfNode = BaseNode.extend({
     // unchanged once `'shelf'` is added to `MaterialTarget`.
     material: MaterialSchema.optional(),
     materialPreset: z.string().optional(),
+    // Per-slot material overrides, mirroring `ItemNode.slots`. Key = slot id
+    // (`shelves` / `frame` / `back`, see `shelfSlots`), value = a `MaterialRef`
+    // string (`library:<id>` or `scene:<id>`). Absent slot = fall back to the
+    // legacy whole-shelf `material` / `materialPreset`, then the registry slot
+    // default. A dangling ref renders the default (never blocks).
+    slots: z.record(z.string(), z.string()).optional(),
 });

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

@@ -21,6 +21,15 @@ export declare const SiteNode: z.ZodObject<{
         type: z.ZodLiteral<"polygon">;
         points: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
     }, z.core.$strip>>>;
+    terrain: z.ZodOptional<z.ZodObject<{
+        type: z.ZodLiteral<"heightfield">;
+        origin: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+        spacing: z.ZodNumber;
+        cols: z.ZodNumber;
+        rows: z.ZodNumber;
+        step: z.ZodNumber;
+        heights: z.ZodString;
+    }, z.core.$strip>>;
     children: z.ZodDefault<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export type SiteNode = z.infer<typeof SiteNode>;

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

@@ -1 +1 @@
-{"version":3,"file":"site.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/site.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAevB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;iBAsBpB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}
+{"version":3,"file":"site.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/site.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAUvB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4BpB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}

package/dist/schema/nodes/site.js

@@ -2,16 +2,12 @@
 import dedent from 'dedent';
 import { z } from 'zod';
 import { BaseNode, nodeType, objectId } from '../base';
+import { TerrainData } from '../terrain';
 // 2D Polygon
 const PropertyLineData = z.object({
     type: z.literal('polygon'),
     points: z.array(z.tuple([z.number(), z.number()])),
 });
-// 3D Polygon/Mesh
-// const TerrainData = z.object({
-//   type: z.literal('terrain'),
-//   points: z.array(z.tuple([z.number(), z.number(), z.number()])),
-// })
 export const SiteNode = BaseNode.extend({
     id: objectId('site'),
     type: nodeType('site'),
@@ -26,10 +22,16 @@ export const SiteNode = BaseNode.extend({
             [-15, 15],
         ],
     }),
-    // terrain: TerrainData,
+    /**
+     * Sculpted ground. Absent means flat ground at the datum — the state every
+     * scene that predates terrain is in, and the state an untouched site stays in
+     * so ~11 KB of base64 zeroes does not land in every saved scene.
+     */
+    terrain: TerrainData.optional(),
     children: z.array(z.string()).default([]),
 }).describe(dedent `
   Site node - used to represent a site
   - polygon: polygon data
+  - terrain: optional sculpted heightfield; absent means flat ground
   - children: array of child node ids (buildings, items)
   `);

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

@@ -14,15 +14,15 @@ export declare const SkylightType: z.ZodEnum<{
 }>;
 export type SkylightType = (typeof SKYLIGHT_TYPE_ORDER)[number];
 export declare const SkylightOpeningSide: z.ZodEnum<{
+    right: "right";
+    left: "left";
     top: "top";
     bottom: "bottom";
-    left: "left";
-    right: "right";
 }>;
 export type SkylightOpeningSide = z.infer<typeof SkylightOpeningSide>;
 export declare const SkylightSlideDirection: z.ZodEnum<{
-    x: "x";
     z: "z";
+    x: "x";
 }>;
 export type SkylightSlideDirection = z.infer<typeof SkylightSlideDirection>;
 export type SkylightTypePreset = {
@@ -173,7 +173,7 @@ export declare const SkylightNode: z.ZodObject<{
     type: z.ZodDefault<z.ZodLiteral<"skylight">>;
     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";
@@ -184,7 +184,7 @@ export declare const SkylightNode: z.ZodObject<{
             plaster: "plaster";
             tile: "tile";
             marble: "marble";
-        }>>;
+        }>>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
             roughness: z.ZodDefault<z.ZodNumber>;
@@ -206,7 +206,7 @@ export declare const SkylightNode: z.ZodObject<{
     materialPreset: z.ZodOptional<z.ZodString>;
     glassMaterial: 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";
@@ -217,7 +217,7 @@ export declare const SkylightNode: z.ZodObject<{
             plaster: "plaster";
             tile: "tile";
             marble: "marble";
-        }>>;
+        }>>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
             roughness: z.ZodDefault<z.ZodNumber>;
@@ -256,17 +256,17 @@ export declare const SkylightNode: z.ZodObject<{
     lanternTopScale: z.ZodDefault<z.ZodNumber>;
     openingAngle: z.ZodDefault<z.ZodNumber>;
     openingSide: z.ZodDefault<z.ZodEnum<{
+        right: "right";
+        left: "left";
         top: "top";
         bottom: "bottom";
-        left: "left";
-        right: "right";
     }>>;
     operationState: z.ZodDefault<z.ZodNumber>;
     motorHousing: z.ZodDefault<z.ZodBoolean>;
     slideFraction: z.ZodDefault<z.ZodNumber>;
     slideDirection: z.ZodDefault<z.ZodEnum<{
-        x: "x";
         z: "z";
+        x: "x";
     }>>;
     trackWidth: z.ZodDefault<z.ZodNumber>;
     motorHousingSize: z.ZodDefault<z.ZodNumber>;

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

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+export declare const MIN_SLAB_THICKNESS = 0.02;
 export declare const SlabNode: z.ZodObject<{
     object: z.ZodDefault<z.ZodLiteral<"node">>;
     name: z.ZodOptional<z.ZodString>;
@@ -19,7 +20,7 @@ export declare const SlabNode: z.ZodObject<{
     type: z.ZodDefault<z.ZodLiteral<"slab">>;
     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";
@@ -30,7 +31,7 @@ export declare const SlabNode: z.ZodObject<{
             plaster: "plaster";
             tile: "tile";
             marble: "marble";
-        }>>;
+        }>>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
             roughness: z.ZodDefault<z.ZodNumber>;
@@ -50,6 +51,7 @@ export declare const SlabNode: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>>;
     materialPreset: z.ZodOptional<z.ZodString>;
+    slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     polygon: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
     holes: z.ZodDefault<z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>>;
     holeMetadata: z.ZodDefault<z.ZodArray<z.ZodObject<{
@@ -62,6 +64,10 @@ export declare const SlabNode: z.ZodObject<{
         elevatorId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>>;
     elevation: z.ZodDefault<z.ZodNumber>;
+    thickness: z.ZodDefault<z.ZodNumber>;
+    recessed: z.ZodDefault<z.ZodBoolean>;
+    recessedRimElevation: z.ZodOptional<z.ZodNumber>;
+    fillToTerrain: z.ZodOptional<z.ZodBoolean>;
     autoFromWalls: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>;
 export type SlabNode = z.infer<typeof SlabNode>;

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

@@ -1 +1 @@
-{"version":3,"file":"slab.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/slab.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmBpB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}
+{"version":3,"file":"slab.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/slab.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAQvB,eAAO,MAAM,kBAAkB,OAAO,CAAA;AAEtC,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+BpB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}