@pascal-app/core 1.0.0-beta.4 → 1.0.0

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

@@ -4,6 +4,18 @@ export declare const CabinetFrontStyleSchema: z.ZodEnum<{
     shaker: "shaker";
     "raised-arch": "raised-arch";
 }>;
+export declare const CabinetTopFinishSchema: z.ZodEnum<{
+    trim: "trim";
+    none: "none";
+    "top-cabinet": "top-cabinet";
+}>;
+/** Canonical metric cabinet family used when no regional profile is selected. */
+export declare const CABINET_METRIC_DEFAULTS: {
+    readonly depth: 0.6;
+    readonly carcassHeight: 0.8;
+    readonly plinthHeight: 0.1;
+    readonly countertopThickness: 0.02;
+};
 declare const CabinetCompartment: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"shelf">;
     shelfCount: z.ZodOptional<z.ZodNumber>;
@@ -123,7 +135,7 @@ export declare const CabinetNode: z.ZodObject<{
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
-    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     rotation: z.ZodDefault<z.ZodNumber>;
     supportSlabId: z.ZodOptional<z.ZodString>;
@@ -145,6 +157,7 @@ export declare const CabinetNode: z.ZodObject<{
         shaker: "shaker";
         "raised-arch": "raised-arch";
     }>>;
+    panelReady: z.ZodDefault<z.ZodBoolean>;
     handleStyle: z.ZodDefault<z.ZodEnum<{
         none: "none";
         bar: "bar";
@@ -308,7 +321,7 @@ export declare const CabinetNode: z.ZodObject<{
         base: "base";
         tall: "tall";
     }>>;
-    children: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodTemplateLiteral<`cabinet-module_${string}`>>>>;
+    children: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodDefault<z.ZodTemplateLiteral<`cabinet-module_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`cabinet_${string}`>>]>>>;
     barLedge: z.ZodOptional<z.ZodObject<{
         edge: z.ZodDefault<z.ZodEnum<{
             back: "back";
@@ -319,6 +332,7 @@ export declare const CabinetNode: z.ZodObject<{
         depth: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>>;
     withWaterfall: z.ZodDefault<z.ZodBoolean>;
+    withFinishedEnds: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>;
 export declare const CabinetModuleNode: z.ZodObject<{
     object: z.ZodDefault<z.ZodLiteral<"node">>;
@@ -335,7 +349,7 @@ export declare const CabinetModuleNode: z.ZodObject<{
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
-    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     rotation: z.ZodDefault<z.ZodNumber>;
     supportSlabId: z.ZodOptional<z.ZodString>;
@@ -357,6 +371,7 @@ export declare const CabinetModuleNode: z.ZodObject<{
         shaker: "shaker";
         "raised-arch": "raised-arch";
     }>>;
+    panelReady: z.ZodDefault<z.ZodBoolean>;
     handleStyle: z.ZodDefault<z.ZodEnum<{
         none: "none";
         bar: "bar";
@@ -529,6 +544,13 @@ export declare const CabinetModuleNode: z.ZodObject<{
         left: "left";
     }>>;
     cornerShelf: z.ZodOptional<z.ZodBoolean>;
+    topFinish: z.ZodDefault<z.ZodEnum<{
+        trim: "trim";
+        none: "none";
+        "top-cabinet": "top-cabinet";
+    }>>;
+    topFinishHeight: z.ZodDefault<z.ZodNumber>;
+    topFinishDepth: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
 export type CabinetNode = z.infer<typeof CabinetNode>;
 export type CabinetModuleNode = z.infer<typeof CabinetModuleNode>;

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

@@ -1 +1 @@
-{"version":3,"file":"cabinet.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/cabinet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAgBvB,eAAO,MAAM,uBAAuB;;;;EAA4C,CAAA;AAMhF,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAmDtB,CAAA;AAEF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAqCzE,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiB0B,CAAA;AAElD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgB+B,CAAA;AAE7D,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AACrD,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA"}
+{"version":3,"file":"cabinet.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/cabinet.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAgBvB,eAAO,MAAM,uBAAuB;;;;EAA4C,CAAA;AAChF,eAAO,MAAM,sBAAsB;;;;EAA0C,CAAA;AAE7E,iFAAiF;AACjF,eAAO,MAAM,uBAAuB;;;;;CAK1B,CAAA;AAMV,QAAA,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAmDtB,CAAA;AAEF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AA2CzE,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmB0B,CAAA;AAElD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqB+B,CAAA;AAE7D,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AACrD,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA"}

package/dist/schema/nodes/cabinet.js

@@ -12,6 +12,14 @@ const cooktopFields = {
     cooktopShowGrate: z.boolean().optional(),
 };
 export const CabinetFrontStyleSchema = z.enum(['slab', 'shaker', 'raised-arch']);
+export const CabinetTopFinishSchema = z.enum(['none', 'top-cabinet', 'trim']);
+/** Canonical metric cabinet family used when no regional profile is selected. */
+export const CABINET_METRIC_DEFAULTS = {
+    depth: 0.6,
+    carcassHeight: 0.8,
+    plinthHeight: 0.1,
+    countertopThickness: 0.02,
+};
 // Discriminated on `type` so invalid field combinations (a drawer with a
 // pantry rack style, a fridge with burner state) are unrepresentable. New
 // compartment kinds add a variant here rather than widening a shared bag of
@@ -76,13 +84,17 @@ const cabinetBoxFields = {
     // Persisted slab-support host — see ItemNode.supportSlabId for the rules.
     supportSlabId: z.string().optional(),
     width: z.number().min(0.05).max(3).default(0.5),
-    depth: z.number().min(0.3).max(1.2).default(0.5),
-    carcassHeight: z.number().min(0.4).max(2.4).default(0.72),
+    depth: z.number().min(0.3).max(1.2).default(CABINET_METRIC_DEFAULTS.depth),
+    carcassHeight: z.number().min(0.4).max(2.4).default(CABINET_METRIC_DEFAULTS.carcassHeight),
     operationState: z.number().min(0).max(1).default(0),
-    plinthHeight: z.number().min(0).max(0.3).default(0.1),
+    plinthHeight: z.number().min(0).max(0.3).default(CABINET_METRIC_DEFAULTS.plinthHeight),
     toeKickDepth: z.number().min(0).max(0.2).default(0.075),
     boardThickness: z.number().min(0.01).max(0.08).default(0.018),
-    countertopThickness: z.number().min(0).max(0.08).default(0.02),
+    countertopThickness: z
+        .number()
+        .min(0)
+        .max(0.08)
+        .default(CABINET_METRIC_DEFAULTS.countertopThickness),
     countertopOverhang: z.number().min(0).max(0.12).default(0.02),
     // Extra slab reach off the back edge (island seating side) — up to a
     // 45 cm knee-space overhang, unlike the small uniform front/side overhang.
@@ -91,6 +103,8 @@ const cabinetBoxFields = {
     frontThickness: z.number().min(0.01).max(0.05).default(0.018),
     frontGap: z.number().min(0.001).max(0.02).default(0.003),
     frontStyle: CabinetFrontStyleSchema.default('slab'),
+    // Fridge-only: replace the appliance door face with a cabinet-matched panel.
+    panelReady: z.boolean().default(false),
     handleStyle: z.enum(['none', 'bar', 'cutout', 'hole', 'knob']).default('bar'),
     handlePosition: z.enum(['auto', 'top', 'center']).default('auto'),
     frontOverlay: z.enum(['full', 'inset']).default('full'),
@@ -106,7 +120,7 @@ export const CabinetNode = BaseNode.extend({
     id: objectId('cabinet'),
     type: nodeType('cabinet'),
     runTier: z.enum(['base', 'wall', 'tall']).default('base'),
-    children: z.array(objectId('cabinet-module')).default([]),
+    children: z.array(z.union([objectId('cabinet-module'), objectId('cabinet')])).default([]),
     // Raised bar counter along one run edge: a knee wall topped by a slab at
     // bar height. Run-level because it spans modules like the countertop.
     barLedge: z
@@ -118,6 +132,8 @@ export const CabinetNode = BaseNode.extend({
         .optional(),
     // Countertop material dropping to the floor on exposed run ends.
     withWaterfall: z.boolean().default(false),
+    // Add matching decorative panels to ends that are not joined to another run.
+    withFinishedEnds: z.boolean().default(false),
     ...cabinetBoxFields,
 }).describe('Parametric modular cabinet run node');
 export const CabinetModuleNode = BaseNode.extend({
@@ -135,5 +151,10 @@ export const CabinetModuleNode = BaseNode.extend({
     // Corner-pocket fillers carry a small internal shelf so the dead corner reads
     // as reachable storage instead of an empty boxed void.
     cornerShelf: z.boolean().optional(),
+    // Optional upper termination for wall/tall compositions. It is deliberately
+    // separate from carcassHeight so the main cabinet proportions stay stable.
+    topFinish: CabinetTopFinishSchema.default('none'),
+    topFinishHeight: z.number().min(0).max(1.2).default(0.33),
+    topFinishDepth: z.number().min(0.15).max(1.2).default(0.32),
     ...cabinetBoxFields,
 }).describe('Parametric module inside a modular cabinet run');

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

@@ -14,7 +14,7 @@ export declare const CeilingNode: z.ZodObject<{
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
-    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`ceiling_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"ceiling">>;
     children: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodTemplateLiteral<`item_${string}`>>>>;

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

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 export declare const ChimneyMaterialRole: z.ZodEnum<{
-    top: "top";
     body: "body";
+    top: "top";
 }>;
 export type ChimneyMaterialRole = z.infer<typeof ChimneyMaterialRole>;
 export declare const ChimneyNode: z.ZodObject<{
@@ -19,7 +19,7 @@ export declare const ChimneyNode: z.ZodObject<{
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
-    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`chimney_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"chimney">>;
     material: z.ZodOptional<z.ZodObject<{

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

@@ -58,14 +58,14 @@ export declare const ColumnCapitalStyle: z.ZodEnum<{
     "wood-bracket": "wood-bracket";
 }>;
 export declare const ColumnRingPlacement: z.ZodEnum<{
+    top: "top";
     ends: "ends";
     even: "even";
-    top: "top";
     bottom: "bottom";
 }>;
 export declare const ColumnCarvingPlacement: z.ZodEnum<{
-    shaft: "shaft";
     base: "base";
+    shaft: "shaft";
     capital: "capital";
     all: "all";
 }>;
@@ -107,7 +107,7 @@ export declare const ColumnNode: z.ZodObject<{
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
-    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`column_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"column">>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
@@ -206,9 +206,9 @@ export declare const ColumnNode: z.ZodObject<{
     capitalCarvingLevel: z.ZodDefault<z.ZodNumber>;
     ringCount: z.ZodDefault<z.ZodNumber>;
     ringPlacement: z.ZodDefault<z.ZodEnum<{
+        top: "top";
         ends: "ends";
         even: "even";
-        top: "top";
         bottom: "bottom";
     }>>;
     ringThickness: z.ZodDefault<z.ZodNumber>;
@@ -227,15 +227,15 @@ export declare const ColumnNode: z.ZodObject<{
     }>>;
     latheRingCount: z.ZodDefault<z.ZodNumber>;
     latheRingSpacing: z.ZodDefault<z.ZodEnum<{
+        top: "top";
         ends: "ends";
         even: "even";
-        top: "top";
         bottom: "bottom";
     }>>;
     carvingLevel: z.ZodDefault<z.ZodNumber>;
     carvingPlacement: z.ZodDefault<z.ZodEnum<{
-        shaft: "shaft";
         base: "base";
+        shaft: "shaft";
         capital: "capital";
         all: "all";
     }>>;

package/dist/schema/nodes/construction-dimension.d.ts

@@ -25,8 +25,8 @@ export declare const ConstructionDrawingType: z.ZodEnum<{
     "site-plan": "site-plan";
 }>;
 export declare const ConstructionDimensionDrawingPresentation: z.ZodEnum<{
-    shown: "shown";
     omit: "omit";
+    shown: "shown";
     controlled: "controlled";
 }>;
 export declare const ConstructionDimensionDrawingOverride: z.ZodObject<{
@@ -38,8 +38,8 @@ export declare const ConstructionDimensionDrawingOverride: z.ZodObject<{
         "site-plan": "site-plan";
     }>;
     presentation: z.ZodEnum<{
-        shown: "shown";
         omit: "omit";
+        shown: "shown";
         controlled: "controlled";
     }>;
     suppressedSegmentIndexes: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
@@ -86,7 +86,7 @@ export declare const ConstructionDimensionNode: z.ZodObject<{
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
-    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`construction-dimension_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"construction-dimension">>;
     anchors: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>, z.ZodObject<{
@@ -166,8 +166,8 @@ export declare const ConstructionDimensionNode: z.ZodObject<{
             "site-plan": "site-plan";
         }>;
         presentation: z.ZodEnum<{
-            shown: "shown";
             omit: "omit";
+            shown: "shown";
             controlled: "controlled";
         }>;
         suppressedSegmentIndexes: z.ZodDefault<z.ZodArray<z.ZodNumber>>;

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

@@ -1,4 +1,11 @@
 import { z } from 'zod';
+export declare const CupolaMaterialRole: z.ZodEnum<{
+    body: "body";
+    roof: "roof";
+    base: "base";
+    louvers: "louvers";
+}>;
+export type CupolaMaterialRole = z.infer<typeof CupolaMaterialRole>;
 export declare const CupolaNode: z.ZodObject<{
     object: z.ZodDefault<z.ZodLiteral<"node">>;
     name: z.ZodOptional<z.ZodString>;
@@ -14,7 +21,7 @@ export declare const CupolaNode: z.ZodObject<{
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
-    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`cupola_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"cupola">>;
     material: z.ZodOptional<z.ZodObject<{
@@ -49,6 +56,7 @@ export declare const CupolaNode: z.ZodObject<{
             scale: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
+    slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     materialPreset: z.ZodDefault<z.ZodString>;
     roofSegmentId: z.ZodOptional<z.ZodString>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;

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

@@ -1 +1 @@
-{"version":3,"file":"cupola.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/cupola.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6BtB,CAAA;AAED,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA"}
+{"version":3,"file":"cupola.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/cupola.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,kBAAkB;;;;;EAA8C,CAAA;AAC7E,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAEnE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8BtB,CAAA;AAED,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA"}

package/dist/schema/nodes/cupola.js

@@ -2,10 +2,12 @@ import dedent from 'dedent';
 import { z } from 'zod';
 import { BaseNode, nodeType, objectId } from '../base';
 import { MaterialSchema } from '../material';
+export const CupolaMaterialRole = z.enum(['base', 'body', 'roof', 'louvers']);
 export const CupolaNode = BaseNode.extend({
     id: objectId('cupola'),
     type: nodeType('cupola'),
     material: MaterialSchema.optional(),
+    slots: z.record(z.string(), z.string()).optional(),
     // Default to the white preset so a freshly-placed cupola reads as clean
     // painted metal and the paint inspector shows "White" (matches box-vent).
     materialPreset: z.string().default('preset-white'),

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

@@ -64,7 +64,7 @@ export declare const DoorNode: z.ZodObject<{
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
-    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`door_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"door">>;
     material: z.ZodOptional<z.ZodObject<{

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

@@ -1,10 +1,24 @@
 import { z } from 'zod';
 import { MaterialSchema } from '../material';
+import { type RoofSegmentNode } from './roof-segment';
+import { WindowNode } from './window';
 export type DormerSurfaceMaterialRole = 'top' | 'side' | 'wall';
 export type DormerSurfaceMaterialSpec = {
     material?: z.infer<typeof MaterialSchema>;
     materialPreset?: string;
 };
+export declare const DormerWallFace: z.ZodEnum<{
+    front: "front";
+    back: "back";
+    right: "right";
+    left: "left";
+}>;
+export type DormerWallFace = z.infer<typeof DormerWallFace>;
+export type DormerWallFaceFrame = {
+    origin: [number, number, number];
+    yaw: number;
+    width: number;
+};
 /**
  * Default dormer dimensions and window controls. Values match the
  * legacy archive so existing scenes don't shift visually.
@@ -44,7 +58,7 @@ export declare const DormerNode: z.ZodObject<{
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
-    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`dormer_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"dormer">>;
     material: z.ZodOptional<z.ZodObject<{
@@ -193,8 +207,13 @@ export declare const DormerNode: z.ZodObject<{
         gambrel: "gambrel";
         dutch: "dutch";
         mansard: "mansard";
+        conical: "conical";
     }>>;
     roofHeight: z.ZodDefault<z.ZodNumber>;
+    shedHighSide: z.ZodDefault<z.ZodEnum<{
+        front: "front";
+        back: "back";
+    }>>;
     wallSkirtHeight: z.ZodDefault<z.ZodNumber>;
     windowWidth: z.ZodDefault<z.ZodNumber>;
     windowHeight: z.ZodDefault<z.ZodNumber>;
@@ -215,8 +234,31 @@ export declare const DormerNode: z.ZodObject<{
     windowSill: z.ZodDefault<z.ZodBoolean>;
     windowSillDepth: z.ZodDefault<z.ZodNumber>;
     windowSillThickness: z.ZodDefault<z.ZodNumber>;
+    children: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodTemplateLiteral<`window_${string}`>>>>;
 }, z.core.$strip>;
 export type DormerNode = z.infer<typeof DormerNode>;
+export declare function getDormerWallFaceFrame(dormer: Pick<DormerNode, 'width' | 'depth'>, face: DormerWallFace): DormerWallFaceFrame;
+export declare function dormerWallFacePointToDormer(dormer: Pick<DormerNode, 'width' | 'depth'>, face: DormerWallFace, point: [number, number, number]): [number, number, number];
+export declare function dormerPointToWallFace(dormer: Pick<DormerNode, 'width' | 'depth'>, face: DormerWallFace, point: [number, number, number]): [number, number, number];
+export declare function getDormerWallVerticalBounds(dormer: Pick<DormerNode, 'height' | 'wallSkirtHeight'>): {
+    min: number;
+    max: number;
+};
+type DormerWallProfile = Pick<DormerNode, 'width' | 'depth' | 'height' | 'wallSkirtHeight' | 'roofType' | 'roofHeight' | 'shedHighSide'>;
+export declare function getDormerWallOpeningVerticalBounds(dormer: DormerWallProfile, face: DormerWallFace, centerX: number, width: number): {
+    min: number;
+    max: number;
+};
+export declare function getDormerWallHorizontalBoundsAtHeight(dormer: DormerWallProfile, face: DormerWallFace, height: number): {
+    min: number;
+    max: number;
+};
+export declare function getDormerExposedFaces(dormer: Pick<DormerNode, 'depth' | 'position' | 'rotation' | 'wallSkirtHeight' | 'windowOffsetY'>, hostSegment: RoofSegmentNode): {
+    front: boolean;
+    back: boolean;
+};
+export declare function getDormerDefaultWindowFace(dormer: Pick<DormerNode, 'depth' | 'position' | 'rotation' | 'wallSkirtHeight' | 'windowOffsetY'>, hostSegment?: RoofSegmentNode): Extract<DormerWallFace, 'front' | 'back'>;
+export declare function createDormerDefaultWindow(dormer: Pick<DormerNode, 'id' | 'width' | 'wallSkirtHeight' | 'windowWidth' | 'windowHeight' | 'windowOffsetX' | 'windowOffsetY' | 'windowFrameThickness' | 'windowFrameDepth' | 'windowColumns' | 'windowRows' | 'windowDividerThickness' | 'windowShape' | 'windowArchHeight' | 'windowCornerRadii' | 'windowSill' | 'windowSillDepth' | 'windowSillThickness'>, id: string, face?: Extract<DormerWallFace, 'front' | 'back'>): WindowNode;
 /**
  * Per-surface material resolution. Fall-through order:
  *   top  → topMaterial[Preset]                              → legacy
@@ -225,4 +267,5 @@ export type DormerNode = z.infer<typeof DormerNode>;
  * where legacy is `node.material` / `node.materialPreset`.
  */
 export declare function getEffectiveDormerSurfaceMaterial(node: DormerNode, role: DormerSurfaceMaterialRole): DormerSurfaceMaterialSpec;
+export {};
 //# sourceMappingURL=dormer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"dormer.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/dormer.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAG5C,MAAM,MAAM,yBAAyB,GAAG,KAAK,GAAG,MAAM,GAAG,MAAM,CAAA;AAC/D,MAAM,MAAM,yBAAyB,GAAG;IACtC,QAAQ,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;IACzC,cAAc,CAAC,EAAE,MAAM,CAAA;CACxB,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;CAmBlB,CAAA;AASV,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4DtB,CAAA;AAED,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA;AAEnD;;;;;;GAMG;AACH,wBAAgB,iCAAiC,CAC/C,IAAI,EAAE,UAAU,EAChB,IAAI,EAAE,yBAAyB,GAC9B,yBAAyB,CAuB3B"}
+{"version":3,"file":"dormer.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/dormer.ts"],"names":[],"mappings":"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"}

package/dist/schema/nodes/dormer.js

@@ -2,7 +2,9 @@ import dedent from 'dedent';
 import { z } from 'zod';
 import { BaseNode, nodeType, objectId } from '../base';
 import { MaterialSchema } from '../material';
-import { RoofType } from './roof-segment';
+import { getRoofSegmentSurfaceY, RoofType } from './roof-segment';
+import { WindowNode } from './window';
+export const DormerWallFace = z.enum(['front', 'back', 'right', 'left']);
 /**
  * Default dormer dimensions and window controls. Values match the
  * legacy archive so existing scenes don't shift visually.
@@ -52,13 +54,13 @@ export const DormerNode = BaseNode.extend({
     height: z.number().default(DORMER_DEFAULTS.WALL_HEIGHT),
     roofType: RoofType.default('gable'),
     roofHeight: z.number().default(DORMER_DEFAULTS.ROOF_HEIGHT),
+    shedHighSide: z.enum(['back', 'front']).default('back'),
     // Height of the hung wall (the "skirt") that extends below the eave
     // into the host roof — this is the wall area the window opening is
     // cut through. Larger values let the dormer host taller windows.
     wallSkirtHeight: z.number().default(DORMER_DEFAULTS.WALL_SKIRT_HEIGHT),
-    // Window is rendered as parametric geometry on the dormer's front
-    // face — not a child node. The fields below mirror the legacy panel
-    // controls; geometry beyond the simple opening box is deferred.
+    // Legacy inline-window controls. Existing scenes are promoted to a hosted
+    // WindowNode during scene migration; these fields remain for archive data.
     windowWidth: z.number().default(DORMER_DEFAULTS.WINDOW_WIDTH),
     windowHeight: z.number().default(DORMER_DEFAULTS.WINDOW_HEIGHT),
     windowOffsetX: z.number().default(DORMER_DEFAULTS.WINDOW_OFFSET_X),
@@ -79,13 +81,135 @@ export const DormerNode = BaseNode.extend({
     windowSill: z.boolean().default(false),
     windowSillDepth: z.number().default(DORMER_DEFAULTS.WINDOW_SILL_DEPTH),
     windowSillThickness: z.number().default(DORMER_DEFAULTS.WINDOW_SILL_THICKNESS),
+    // Hosted windows use the same recursive scene-graph contract as walls and
+    // roof segments. Legacy window* fields above are retained for migration.
+    children: z.array(WindowNode.shape.id).default([]),
 }).describe(dedent `
   Dormer — a small house-shaped protrusion sitting on top of a roof
   segment. width × depth × height defines the box base; roofType and
-  roofHeight define the dormer's own roof shape. The window opening
-  is parametric geometry on the dormer's front face, not a hosted
-  child node.
+  roofHeight define the dormer's own roof shape. shedHighSide controls
+  the pitch direction for shed roofs. WindowNode children are hosted on
+  its wall faces and use the regular window item model.
   `);
+export function getDormerWallFaceFrame(dormer, face) {
+    switch (face) {
+        case 'back':
+            return { origin: [0, 0, -dormer.depth / 2], yaw: Math.PI, width: dormer.width };
+        case 'right':
+            return { origin: [dormer.width / 2, 0, 0], yaw: Math.PI / 2, width: dormer.depth };
+        case 'left':
+            return { origin: [-dormer.width / 2, 0, 0], yaw: -Math.PI / 2, width: dormer.depth };
+        default:
+            return { origin: [0, 0, dormer.depth / 2], yaw: 0, width: dormer.width };
+    }
+}
+export function dormerWallFacePointToDormer(dormer, face, point) {
+    const frame = getDormerWallFaceFrame(dormer, face);
+    const cos = Math.cos(frame.yaw);
+    const sin = Math.sin(frame.yaw);
+    const [x, y, z] = point;
+    return [
+        frame.origin[0] + x * cos + z * sin,
+        frame.origin[1] + y,
+        frame.origin[2] - x * sin + z * cos,
+    ];
+}
+export function dormerPointToWallFace(dormer, face, point) {
+    const frame = getDormerWallFaceFrame(dormer, face);
+    const cos = Math.cos(frame.yaw);
+    const sin = Math.sin(frame.yaw);
+    const dx = point[0] - frame.origin[0];
+    const dz = point[2] - frame.origin[2];
+    return [cos * dx - sin * dz, point[1] - frame.origin[1], sin * dx + cos * dz];
+}
+export function getDormerWallVerticalBounds(dormer) {
+    return {
+        min: -(dormer.wallSkirtHeight ?? DORMER_DEFAULTS.WALL_SKIRT_HEIGHT),
+        max: Math.max(0, dormer.height),
+    };
+}
+function getDormerWallCeilingAt(dormer, face, faceX) {
+    const eaveHeight = Math.max(0, dormer.height);
+    if (dormer.roofType !== 'shed')
+        return eaveHeight;
+    const depth = Math.max(dormer.depth, Number.EPSILON);
+    const [, , dormerZ] = dormerWallFacePointToDormer(dormer, face, [faceX, 0, 0]);
+    const frontWeight = Math.max(0, Math.min(1, dormerZ / depth + 0.5));
+    const highSideWeight = dormer.shedHighSide === 'front' ? frontWeight : 1 - frontWeight;
+    return eaveHeight + Math.max(0, dormer.roofHeight) * highSideWeight;
+}
+export function getDormerWallOpeningVerticalBounds(dormer, face, centerX, width) {
+    const halfWidth = width / 2;
+    return {
+        min: -(dormer.wallSkirtHeight ?? DORMER_DEFAULTS.WALL_SKIRT_HEIGHT),
+        max: Math.min(getDormerWallCeilingAt(dormer, face, centerX - halfWidth), getDormerWallCeilingAt(dormer, face, centerX + halfWidth)),
+    };
+}
+export function getDormerWallHorizontalBoundsAtHeight(dormer, face, height) {
+    const halfWidth = getDormerWallFaceFrame(dormer, face).width / 2;
+    const leftCeiling = getDormerWallCeilingAt(dormer, face, -halfWidth);
+    const rightCeiling = getDormerWallCeilingAt(dormer, face, halfWidth);
+    if (height <= Math.min(leftCeiling, rightCeiling)) {
+        return { min: -halfWidth, max: halfWidth };
+    }
+    if (leftCeiling === rightCeiling) {
+        return { min: -halfWidth, max: halfWidth };
+    }
+    const crossing = -halfWidth + ((height - leftCeiling) / (rightCeiling - leftCeiling)) * (halfWidth * 2);
+    if (rightCeiling > leftCeiling) {
+        const min = Math.min(halfWidth, crossing);
+        return { min, max: halfWidth };
+    }
+    const max = Math.max(-halfWidth, crossing);
+    return { min: -halfWidth, max };
+}
+const DORMER_WINDOW_CENTER_MIN_CLEARANCE = 0.01;
+export function getDormerExposedFaces(dormer, hostSegment) {
+    const halfDepth = dormer.depth / 2;
+    const [dormerX, dormerY, dormerZ] = dormer.position;
+    const faceDX = halfDepth * Math.sin(dormer.rotation);
+    const faceDZ = halfDepth * Math.cos(dormer.rotation);
+    const windowCenterY = dormerY - dormer.wallSkirtHeight / 2 + dormer.windowOffsetY;
+    const clears = (faceX, faceZ) => windowCenterY - getRoofSegmentSurfaceY(hostSegment, faceX, faceZ) >
+        DORMER_WINDOW_CENTER_MIN_CLEARANCE;
+    return {
+        front: clears(dormerX + faceDX, dormerZ + faceDZ),
+        back: clears(dormerX - faceDX, dormerZ - faceDZ),
+    };
+}
+export function getDormerDefaultWindowFace(dormer, hostSegment) {
+    if (!hostSegment)
+        return 'front';
+    const exposed = getDormerExposedFaces(dormer, hostSegment);
+    return !exposed.front && exposed.back ? 'back' : 'front';
+}
+export function createDormerDefaultWindow(dormer, id, face = 'front') {
+    const skirt = dormer.wallSkirtHeight ?? DORMER_DEFAULTS.WALL_SKIRT_HEIGHT;
+    const equalRatios = (count) => Array.from({ length: Math.max(1, count) }, () => 1);
+    return WindowNode.parse({
+        id,
+        parentId: dormer.id,
+        dormerId: dormer.id,
+        dormerFace: face,
+        position: [dormer.windowOffsetX, -skirt / 2 + dormer.windowOffsetY, 0],
+        rotation: [0, 0, 0],
+        side: 'front',
+        width: dormer.windowWidth,
+        height: dormer.windowHeight,
+        openingShape: dormer.windowShape,
+        archHeight: dormer.windowArchHeight,
+        openingCornerRadii: dormer.windowCornerRadii,
+        frameThickness: dormer.windowFrameThickness,
+        frameDepth: dormer.windowFrameDepth,
+        columnRatios: equalRatios(dormer.windowColumns),
+        rowRatios: equalRatios(dormer.windowRows),
+        columnDividerThickness: dormer.windowDividerThickness,
+        rowDividerThickness: dormer.windowDividerThickness,
+        sill: dormer.windowSill,
+        sillDepth: dormer.windowSillDepth,
+        sillThickness: dormer.windowSillThickness,
+    });
+}
 /**
  * Per-surface material resolution. Fall-through order:
  *   top  → topMaterial[Preset]                              → legacy

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

@@ -14,7 +14,7 @@ export declare const DownspoutNode: z.ZodObject<{
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
-    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`downspout_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"downspout">>;
     material: z.ZodOptional<z.ZodObject<{
@@ -49,10 +49,15 @@ export declare const DownspoutNode: z.ZodObject<{
             scale: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
+    slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     materialPreset: z.ZodDefault<z.ZodString>;
     gutterId: z.ZodOptional<z.ZodString>;
     outletId: z.ZodOptional<z.ZodString>;
     length: z.ZodDefault<z.ZodNumber>;
+    lengthMode: z.ZodOptional<z.ZodEnum<{
+        manual: "manual";
+        "to-ground": "to-ground";
+    }>>;
     diameter: z.ZodDefault<z.ZodNumber>;
     standoff: z.ZodDefault<z.ZodNumber>;
     shape: z.ZodDefault<z.ZodEnum<{
@@ -72,4 +77,9 @@ export declare const DownspoutNode: z.ZodObject<{
     }>>;
 }, z.core.$strip>;
 export type DownspoutNode = z.infer<typeof DownspoutNode>;
+export declare function defaultDownspoutMetadata(): {
+    generatedBy: string;
+};
+export declare function isDefaultDownspoutNode(node: unknown, gutterId?: string): node is DownspoutNode;
+export declare function usesAutomaticDownspoutLength(node: DownspoutNode): boolean;
 //# sourceMappingURL=downspout.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"downspout.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/downspout.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkEzB,CAAA;AAED,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA"}
+{"version":3,"file":"downspout.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/downspout.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoEzB,CAAA;AAED,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AASzD,wBAAgB,wBAAwB;;EAEvC;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,IAAI,IAAI,aAAa,CAK9F;AAED,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,aAAa,GAAG,OAAO,CAKzE"}