@pascal-app/core 0.8.0 → 0.9.2

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

@@ -0,0 +1,66 @@
+import { z } from 'zod';
+export declare const CupolaNode: z.ZodObject<{
+    object: z.ZodDefault<z.ZodLiteral<"node">>;
+    name: z.ZodOptional<z.ZodString>;
+    parentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    visible: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    camera: z.ZodOptional<z.ZodObject<{
+        position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        target: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        mode: z.ZodDefault<z.ZodEnum<{
+            perspective: "perspective";
+            orthographic: "orthographic";
+        }>>;
+        fov: z.ZodOptional<z.ZodNumber>;
+        zoom: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    id: z.ZodDefault<z.ZodTemplateLiteral<`cupola_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"cupola">>;
+    material: z.ZodOptional<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        preset: z.ZodOptional<z.ZodCatch<z.ZodEnum<{
+            custom: "custom";
+            white: "white";
+            brick: "brick";
+            concrete: "concrete";
+            wood: "wood";
+            glass: "glass";
+            metal: "metal";
+            plaster: "plaster";
+            tile: "tile";
+            marble: "marble";
+        }>>>;
+        properties: z.ZodOptional<z.ZodObject<{
+            color: z.ZodDefault<z.ZodString>;
+            roughness: z.ZodDefault<z.ZodNumber>;
+            metalness: z.ZodDefault<z.ZodNumber>;
+            opacity: z.ZodDefault<z.ZodNumber>;
+            transparent: z.ZodDefault<z.ZodBoolean>;
+            side: z.ZodDefault<z.ZodEnum<{
+                front: "front";
+                back: "back";
+                double: "double";
+            }>>;
+        }, z.core.$strip>>;
+        texture: z.ZodOptional<z.ZodObject<{
+            url: z.ZodString;
+            repeat: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            scale: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    materialPreset: z.ZodDefault<z.ZodString>;
+    roofSegmentId: z.ZodOptional<z.ZodString>;
+    position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    rotation: z.ZodDefault<z.ZodNumber>;
+    width: z.ZodDefault<z.ZodNumber>;
+    depth: z.ZodDefault<z.ZodNumber>;
+    height: z.ZodDefault<z.ZodNumber>;
+    roofStyle: z.ZodDefault<z.ZodEnum<{
+        dome: "dome";
+        pyramid: "pyramid";
+    }>>;
+    finial: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type CupolaNode = z.infer<typeof CupolaNode>;
+//# sourceMappingURL=cupola.d.ts.map

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

@@ -0,0 +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"}

package/dist/schema/nodes/cupola.js

@@ -0,0 +1,28 @@
+import dedent from 'dedent';
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base';
+import { MaterialSchema } from '../material';
+export const CupolaNode = BaseNode.extend({
+    id: objectId('cupola'),
+    type: nodeType('cupola'),
+    material: MaterialSchema.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'),
+    roofSegmentId: z.string().optional(),
+    position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
+    rotation: z.number().default(0),
+    // Cupolas are larger than the other vents — a roof lantern, not a cap.
+    width: z.number().default(0.8),
+    depth: z.number().default(0.8),
+    height: z.number().default(1.0),
+    // Roof cap shape: `dome` (round) or `pyramid` (four-sided point).
+    roofStyle: z.enum(['dome', 'pyramid']).default('dome'),
+    // Decorative post + ball at the apex.
+    finial: z.boolean().default(true),
+}).describe(dedent `
+  Cupola — a louvered roof lantern that sits astride a roof ridge or slope:
+  a louvered body topped by a dome or pyramid roof, optionally crowned with
+  a finial. Parented to a roof-segment; position is segment-local. Rotation
+  is around the segment's vertical axis (post-slope tilt).
+  `);

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

@@ -57,7 +57,7 @@ export declare const DoorNode: z.ZodObject<{
     type: z.ZodDefault<z.ZodLiteral<"door">>;
     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";
@@ -68,7 +68,7 @@ export declare const DoorNode: z.ZodObject<{
             plaster: "plaster";
             tile: "tile";
             marble: "marble";
-        }>>;
+        }>>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
             roughness: z.ZodDefault<z.ZodNumber>;
@@ -87,6 +87,7 @@ export declare const DoorNode: z.ZodObject<{
             scale: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
     }, z.core.$strip>>;
+    slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     rotation: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     side: z.ZodOptional<z.ZodEnum<{
@@ -94,6 +95,13 @@ export declare const DoorNode: z.ZodObject<{
         back: "back";
     }>>;
     wallId: z.ZodOptional<z.ZodString>;
+    roofSegmentId: z.ZodOptional<z.ZodString>;
+    roofFace: z.ZodOptional<z.ZodEnum<{
+        front: "front";
+        back: "back";
+        right: "right";
+        left: "left";
+    }>>;
     width: z.ZodDefault<z.ZodNumber>;
     height: z.ZodDefault<z.ZodNumber>;
     doorCategory: z.ZodDefault<z.ZodEnum<{
@@ -115,8 +123,8 @@ export declare const DoorNode: z.ZodObject<{
     leafCount: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>]>>;
     operationState: z.ZodDefault<z.ZodNumber>;
     slideDirection: z.ZodDefault<z.ZodEnum<{
-        left: "left";
         right: "right";
+        left: "left";
     }>>;
     trackStyle: z.ZodDefault<z.ZodEnum<{
         visible: "visible";
@@ -147,8 +155,8 @@ export declare const DoorNode: z.ZodObject<{
     threshold: z.ZodDefault<z.ZodBoolean>;
     thresholdHeight: z.ZodDefault<z.ZodNumber>;
     hingesSide: z.ZodDefault<z.ZodEnum<{
-        left: "left";
         right: "right";
+        left: "left";
     }>>;
     swingDirection: z.ZodDefault<z.ZodEnum<{
         inward: "inward";
@@ -170,8 +178,8 @@ export declare const DoorNode: z.ZodObject<{
     handle: z.ZodDefault<z.ZodBoolean>;
     handleHeight: z.ZodDefault<z.ZodNumber>;
     handleSide: z.ZodDefault<z.ZodEnum<{
-        left: "left";
         right: "right";
+        left: "left";
     }>>;
     contentPadding: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
     doorCloser: z.ZodDefault<z.ZodBoolean>;

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

@@ -1 +1 @@
-{"version":3,"file":"door.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/door.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,WAAW;;;;;;;;;;;iBAWtB,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAErD,eAAO,MAAM,YAAY;;;EAAiC,CAAA;AAC1D,eAAO,MAAM,QAAQ;;;;;;;;;;;EAWnB,CAAA;AACF,eAAO,MAAM,cAAc;;;;;EAAoD,CAAA;AAE/E,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AACvD,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA;AAC/C,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAE3D,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuFnB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}
+{"version":3,"file":"door.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/door.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,WAAW;;;;;;;;;;;iBAWtB,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAErD,eAAO,MAAM,YAAY;;;EAAiC,CAAA;AAC1D,eAAO,MAAM,QAAQ;;;;;;;;;;;EAWnB,CAAA;AACF,eAAO,MAAM,cAAc;;;;;EAAoD,CAAA;AAE/E,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AACvD,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA;AAC/C,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAE3D,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmGnB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}

package/dist/schema/nodes/door.js

@@ -30,10 +30,22 @@ export const DoorNode = BaseNode.extend({
     id: objectId('door'),
     type: nodeType('door'),
     material: MaterialSchema.optional(),
+    // Per-slot material overrides on the unified slot model. Keys: `panel` (the
+    // door body), `glass`. Value = a `MaterialRef` (`library:<id>` / `scene:<id>`).
+    // Absent = the body/glass default. Mirrors `ShelfNode.slots`.
+    slots: z.record(z.string(), z.string()).optional(),
     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]),
     side: z.enum(['front', 'back']).optional(),
     wallId: z.string().optional(),
+    // Alternative host: a roof-segment's generated wall face (base wall
+    // under the roof or a coplanar gable end). When set, `position` is
+    // FACE-LOCAL — [u along the face, v height, z from the wall mid-plane]
+    // — exactly the wall-child convention; the renderer mounts the node
+    // inside the face frame (`getRoofWallFaceFrame`), which is what makes
+    // hosted children track segment resizes live.
+    roofSegmentId: z.string().optional(),
+    roofFace: z.enum(['front', 'back', 'right', 'left']).optional(),
     // Overall dimensions
     width: z.number().default(0.9),
     height: z.number().default(2.1),

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

@@ -0,0 +1,228 @@
+import { z } from 'zod';
+import { MaterialSchema } from '../material';
+export type DormerSurfaceMaterialRole = 'top' | 'side' | 'wall';
+export type DormerSurfaceMaterialSpec = {
+    material?: z.infer<typeof MaterialSchema>;
+    materialPreset?: string;
+};
+/**
+ * Default dormer dimensions and window controls. Values match the
+ * legacy archive so existing scenes don't shift visually.
+ */
+export declare const DORMER_DEFAULTS: {
+    readonly WIDTH: 1.21;
+    readonly DEPTH: 1.55;
+    readonly WALL_HEIGHT: 0;
+    readonly ROOF_HEIGHT: 0.49;
+    readonly WALL_SKIRT_HEIGHT: 2.73;
+    readonly WINDOW_WIDTH: 0.76;
+    readonly WINDOW_HEIGHT: 0.68;
+    readonly WINDOW_OFFSET_X: 0.02;
+    readonly WINDOW_OFFSET_Y: 0.99;
+    readonly WINDOW_FRAME_THICKNESS: 0.05;
+    readonly WINDOW_FRAME_DEPTH: 0.06;
+    readonly WINDOW_COLUMNS: 3;
+    readonly WINDOW_ROWS: 3;
+    readonly WINDOW_DIVIDER_THICKNESS: 0.02;
+    readonly WINDOW_ARCH_HEIGHT: 0.35;
+    readonly WINDOW_CORNER_RADIUS: 0.15;
+    readonly WINDOW_SILL_DEPTH: 0.08;
+    readonly WINDOW_SILL_THICKNESS: 0.03;
+};
+export declare const DormerNode: z.ZodObject<{
+    object: z.ZodDefault<z.ZodLiteral<"node">>;
+    name: z.ZodOptional<z.ZodString>;
+    parentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    visible: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    camera: z.ZodOptional<z.ZodObject<{
+        position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        target: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        mode: z.ZodDefault<z.ZodEnum<{
+            perspective: "perspective";
+            orthographic: "orthographic";
+        }>>;
+        fov: z.ZodOptional<z.ZodNumber>;
+        zoom: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    id: z.ZodDefault<z.ZodTemplateLiteral<`dormer_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"dormer">>;
+    material: z.ZodOptional<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        preset: z.ZodOptional<z.ZodCatch<z.ZodEnum<{
+            custom: "custom";
+            white: "white";
+            brick: "brick";
+            concrete: "concrete";
+            wood: "wood";
+            glass: "glass";
+            metal: "metal";
+            plaster: "plaster";
+            tile: "tile";
+            marble: "marble";
+        }>>>;
+        properties: z.ZodOptional<z.ZodObject<{
+            color: z.ZodDefault<z.ZodString>;
+            roughness: z.ZodDefault<z.ZodNumber>;
+            metalness: z.ZodDefault<z.ZodNumber>;
+            opacity: z.ZodDefault<z.ZodNumber>;
+            transparent: z.ZodDefault<z.ZodBoolean>;
+            side: z.ZodDefault<z.ZodEnum<{
+                front: "front";
+                back: "back";
+                double: "double";
+            }>>;
+        }, z.core.$strip>>;
+        texture: z.ZodOptional<z.ZodObject<{
+            url: z.ZodString;
+            repeat: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            scale: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    materialPreset: z.ZodOptional<z.ZodString>;
+    topMaterial: z.ZodOptional<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        preset: z.ZodOptional<z.ZodCatch<z.ZodEnum<{
+            custom: "custom";
+            white: "white";
+            brick: "brick";
+            concrete: "concrete";
+            wood: "wood";
+            glass: "glass";
+            metal: "metal";
+            plaster: "plaster";
+            tile: "tile";
+            marble: "marble";
+        }>>>;
+        properties: z.ZodOptional<z.ZodObject<{
+            color: z.ZodDefault<z.ZodString>;
+            roughness: z.ZodDefault<z.ZodNumber>;
+            metalness: z.ZodDefault<z.ZodNumber>;
+            opacity: z.ZodDefault<z.ZodNumber>;
+            transparent: z.ZodDefault<z.ZodBoolean>;
+            side: z.ZodDefault<z.ZodEnum<{
+                front: "front";
+                back: "back";
+                double: "double";
+            }>>;
+        }, z.core.$strip>>;
+        texture: z.ZodOptional<z.ZodObject<{
+            url: z.ZodString;
+            repeat: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            scale: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    topMaterialPreset: z.ZodOptional<z.ZodString>;
+    sideMaterial: z.ZodOptional<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        preset: z.ZodOptional<z.ZodCatch<z.ZodEnum<{
+            custom: "custom";
+            white: "white";
+            brick: "brick";
+            concrete: "concrete";
+            wood: "wood";
+            glass: "glass";
+            metal: "metal";
+            plaster: "plaster";
+            tile: "tile";
+            marble: "marble";
+        }>>>;
+        properties: z.ZodOptional<z.ZodObject<{
+            color: z.ZodDefault<z.ZodString>;
+            roughness: z.ZodDefault<z.ZodNumber>;
+            metalness: z.ZodDefault<z.ZodNumber>;
+            opacity: z.ZodDefault<z.ZodNumber>;
+            transparent: z.ZodDefault<z.ZodBoolean>;
+            side: z.ZodDefault<z.ZodEnum<{
+                front: "front";
+                back: "back";
+                double: "double";
+            }>>;
+        }, z.core.$strip>>;
+        texture: z.ZodOptional<z.ZodObject<{
+            url: z.ZodString;
+            repeat: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            scale: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    sideMaterialPreset: z.ZodOptional<z.ZodString>;
+    wallMaterial: z.ZodOptional<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        preset: z.ZodOptional<z.ZodCatch<z.ZodEnum<{
+            custom: "custom";
+            white: "white";
+            brick: "brick";
+            concrete: "concrete";
+            wood: "wood";
+            glass: "glass";
+            metal: "metal";
+            plaster: "plaster";
+            tile: "tile";
+            marble: "marble";
+        }>>>;
+        properties: z.ZodOptional<z.ZodObject<{
+            color: z.ZodDefault<z.ZodString>;
+            roughness: z.ZodDefault<z.ZodNumber>;
+            metalness: z.ZodDefault<z.ZodNumber>;
+            opacity: z.ZodDefault<z.ZodNumber>;
+            transparent: z.ZodDefault<z.ZodBoolean>;
+            side: z.ZodDefault<z.ZodEnum<{
+                front: "front";
+                back: "back";
+                double: "double";
+            }>>;
+        }, z.core.$strip>>;
+        texture: z.ZodOptional<z.ZodObject<{
+            url: z.ZodString;
+            repeat: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            scale: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    wallMaterialPreset: z.ZodOptional<z.ZodString>;
+    roofSegmentId: z.ZodOptional<z.ZodString>;
+    position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    rotation: z.ZodDefault<z.ZodNumber>;
+    width: z.ZodDefault<z.ZodNumber>;
+    depth: z.ZodDefault<z.ZodNumber>;
+    height: z.ZodDefault<z.ZodNumber>;
+    roofType: z.ZodDefault<z.ZodEnum<{
+        flat: "flat";
+        hip: "hip";
+        gable: "gable";
+        shed: "shed";
+        gambrel: "gambrel";
+        dutch: "dutch";
+        mansard: "mansard";
+    }>>;
+    roofHeight: z.ZodDefault<z.ZodNumber>;
+    wallSkirtHeight: z.ZodDefault<z.ZodNumber>;
+    windowWidth: z.ZodDefault<z.ZodNumber>;
+    windowHeight: z.ZodDefault<z.ZodNumber>;
+    windowOffsetX: z.ZodDefault<z.ZodNumber>;
+    windowOffsetY: z.ZodDefault<z.ZodNumber>;
+    windowFrameThickness: z.ZodDefault<z.ZodNumber>;
+    windowFrameDepth: z.ZodDefault<z.ZodNumber>;
+    windowColumns: z.ZodDefault<z.ZodNumber>;
+    windowRows: z.ZodDefault<z.ZodNumber>;
+    windowDividerThickness: z.ZodDefault<z.ZodNumber>;
+    windowShape: z.ZodDefault<z.ZodEnum<{
+        rectangle: "rectangle";
+        rounded: "rounded";
+        arch: "arch";
+    }>>;
+    windowArchHeight: z.ZodDefault<z.ZodNumber>;
+    windowCornerRadii: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    windowSill: z.ZodDefault<z.ZodBoolean>;
+    windowSillDepth: z.ZodDefault<z.ZodNumber>;
+    windowSillThickness: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type DormerNode = z.infer<typeof DormerNode>;
+/**
+ * Per-surface material resolution. Fall-through order:
+ *   top  → topMaterial[Preset]                              → legacy
+ *   side → sideMaterial[Preset] → wallMaterial[Preset]      → legacy
+ *   wall → wallMaterial[Preset] → sideMaterial[Preset]      → legacy
+ * where legacy is `node.material` / `node.materialPreset`.
+ */
+export declare function getEffectiveDormerSurfaceMaterial(node: DormerNode, role: DormerSurfaceMaterialRole): DormerSurfaceMaterialSpec;
+//# sourceMappingURL=dormer.d.ts.map

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

@@ -0,0 +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"}

package/dist/schema/nodes/dormer.js

@@ -0,0 +1,119 @@
+import dedent from 'dedent';
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base';
+import { MaterialSchema } from '../material';
+import { RoofType } from './roof-segment';
+/**
+ * Default dormer dimensions and window controls. Values match the
+ * legacy archive so existing scenes don't shift visually.
+ */
+export const DORMER_DEFAULTS = {
+    WIDTH: 1.21,
+    DEPTH: 1.55,
+    WALL_HEIGHT: 0,
+    ROOF_HEIGHT: 0.49,
+    WALL_SKIRT_HEIGHT: 2.73,
+    WINDOW_WIDTH: 0.76,
+    WINDOW_HEIGHT: 0.68,
+    WINDOW_OFFSET_X: 0.02,
+    WINDOW_OFFSET_Y: 0.99,
+    WINDOW_FRAME_THICKNESS: 0.05,
+    WINDOW_FRAME_DEPTH: 0.06,
+    WINDOW_COLUMNS: 3,
+    WINDOW_ROWS: 3,
+    WINDOW_DIVIDER_THICKNESS: 0.02,
+    WINDOW_ARCH_HEIGHT: 0.35,
+    WINDOW_CORNER_RADIUS: 0.15,
+    WINDOW_SILL_DEPTH: 0.08,
+    WINDOW_SILL_THICKNESS: 0.03,
+};
+const DEFAULT_CORNER_RADII = [
+    DORMER_DEFAULTS.WINDOW_CORNER_RADIUS,
+    DORMER_DEFAULTS.WINDOW_CORNER_RADIUS,
+    DORMER_DEFAULTS.WINDOW_CORNER_RADIUS,
+    DORMER_DEFAULTS.WINDOW_CORNER_RADIUS,
+];
+export const DormerNode = BaseNode.extend({
+    id: objectId('dormer'),
+    type: nodeType('dormer'),
+    material: MaterialSchema.optional(),
+    materialPreset: z.string().optional(),
+    topMaterial: MaterialSchema.optional(),
+    topMaterialPreset: z.string().optional(),
+    sideMaterial: MaterialSchema.optional(),
+    sideMaterialPreset: z.string().optional(),
+    wallMaterial: MaterialSchema.optional(),
+    wallMaterialPreset: z.string().optional(),
+    roofSegmentId: z.string().optional(),
+    position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
+    rotation: z.number().default(0),
+    width: z.number().default(DORMER_DEFAULTS.WIDTH),
+    depth: z.number().default(DORMER_DEFAULTS.DEPTH),
+    height: z.number().default(DORMER_DEFAULTS.WALL_HEIGHT),
+    roofType: RoofType.default('gable'),
+    roofHeight: z.number().default(DORMER_DEFAULTS.ROOF_HEIGHT),
+    // 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.
+    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),
+    windowOffsetY: z.number().default(DORMER_DEFAULTS.WINDOW_OFFSET_Y),
+    windowFrameThickness: z.number().default(DORMER_DEFAULTS.WINDOW_FRAME_THICKNESS),
+    windowFrameDepth: z.number().default(DORMER_DEFAULTS.WINDOW_FRAME_DEPTH),
+    windowColumns: z.number().int().min(1).max(8).default(DORMER_DEFAULTS.WINDOW_COLUMNS),
+    windowRows: z.number().int().min(1).max(8).default(DORMER_DEFAULTS.WINDOW_ROWS),
+    windowDividerThickness: z.number().default(DORMER_DEFAULTS.WINDOW_DIVIDER_THICKNESS),
+    windowShape: z.enum(['rectangle', 'rounded', 'arch']).default('rectangle'),
+    windowArchHeight: z.number().default(DORMER_DEFAULTS.WINDOW_ARCH_HEIGHT),
+    // Single source of truth for the rounded-shape corner radii. Tuple is
+    // [topLeft, topRight, bottomRight, bottomLeft]. "All vs Individual"
+    // is a UI-only view mode derived from whether the tuple is uniform.
+    windowCornerRadii: z
+        .tuple([z.number(), z.number(), z.number(), z.number()])
+        .default(DEFAULT_CORNER_RADII),
+    windowSill: z.boolean().default(false),
+    windowSillDepth: z.number().default(DORMER_DEFAULTS.WINDOW_SILL_DEPTH),
+    windowSillThickness: z.number().default(DORMER_DEFAULTS.WINDOW_SILL_THICKNESS),
+}).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.
+  `);
+/**
+ * Per-surface material resolution. Fall-through order:
+ *   top  → topMaterial[Preset]                              → legacy
+ *   side → sideMaterial[Preset] → wallMaterial[Preset]      → legacy
+ *   wall → wallMaterial[Preset] → sideMaterial[Preset]      → legacy
+ * where legacy is `node.material` / `node.materialPreset`.
+ */
+export function getEffectiveDormerSurfaceMaterial(node, role) {
+    const top = {
+        material: node.topMaterial,
+        materialPreset: node.topMaterialPreset,
+    };
+    const side = {
+        material: node.sideMaterial,
+        materialPreset: node.sideMaterialPreset,
+    };
+    const wall = {
+        material: node.wallMaterial,
+        materialPreset: node.wallMaterialPreset,
+    };
+    const legacy = {
+        material: node.material,
+        materialPreset: node.materialPreset,
+    };
+    const has = (spec) => spec.material !== undefined || typeof spec.materialPreset === 'string';
+    if (role === 'top')
+        return has(top) ? top : legacy;
+    if (role === 'side')
+        return has(side) ? side : has(wall) ? wall : legacy;
+    return has(wall) ? wall : has(side) ? side : legacy;
+}

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

@@ -0,0 +1,75 @@
+import { z } from 'zod';
+export declare const DownspoutNode: z.ZodObject<{
+    object: z.ZodDefault<z.ZodLiteral<"node">>;
+    name: z.ZodOptional<z.ZodString>;
+    parentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    visible: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    camera: z.ZodOptional<z.ZodObject<{
+        position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        target: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        mode: z.ZodDefault<z.ZodEnum<{
+            perspective: "perspective";
+            orthographic: "orthographic";
+        }>>;
+        fov: z.ZodOptional<z.ZodNumber>;
+        zoom: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    id: z.ZodDefault<z.ZodTemplateLiteral<`downspout_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"downspout">>;
+    material: z.ZodOptional<z.ZodObject<{
+        id: z.ZodOptional<z.ZodString>;
+        preset: z.ZodOptional<z.ZodCatch<z.ZodEnum<{
+            custom: "custom";
+            white: "white";
+            brick: "brick";
+            concrete: "concrete";
+            wood: "wood";
+            glass: "glass";
+            metal: "metal";
+            plaster: "plaster";
+            tile: "tile";
+            marble: "marble";
+        }>>>;
+        properties: z.ZodOptional<z.ZodObject<{
+            color: z.ZodDefault<z.ZodString>;
+            roughness: z.ZodDefault<z.ZodNumber>;
+            metalness: z.ZodDefault<z.ZodNumber>;
+            opacity: z.ZodDefault<z.ZodNumber>;
+            transparent: z.ZodDefault<z.ZodBoolean>;
+            side: z.ZodDefault<z.ZodEnum<{
+                front: "front";
+                back: "back";
+                double: "double";
+            }>>;
+        }, z.core.$strip>>;
+        texture: z.ZodOptional<z.ZodObject<{
+            url: z.ZodString;
+            repeat: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            scale: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    materialPreset: z.ZodDefault<z.ZodString>;
+    gutterId: z.ZodOptional<z.ZodString>;
+    outletId: z.ZodOptional<z.ZodString>;
+    length: z.ZodDefault<z.ZodNumber>;
+    diameter: z.ZodDefault<z.ZodNumber>;
+    standoff: z.ZodDefault<z.ZodNumber>;
+    shape: z.ZodDefault<z.ZodEnum<{
+        round: "round";
+        auto: "auto";
+        rect: "rect";
+    }>>;
+    strapStyle: z.ZodDefault<z.ZodEnum<{
+        none: "none";
+        band: "band";
+    }>>;
+    strapSpacing: z.ZodDefault<z.ZodNumber>;
+    terminal: z.ZodDefault<z.ZodEnum<{
+        straight: "straight";
+        splash: "splash";
+        kickout: "kickout";
+    }>>;
+}, z.core.$strip>;
+export type DownspoutNode = z.infer<typeof DownspoutNode>;
+//# sourceMappingURL=downspout.d.ts.map

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

@@ -0,0 +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"}