@pascal-app/core 1.0.0-beta.5 → 1.0.1

package/dist/schema/nodes/column.js

@@ -1,7 +1,7 @@
 import dedent from 'dedent';
 import { z } from 'zod';
-import { BaseNode, nodeType, objectId } from '../base';
-import { MaterialSchema } from '../material';
+import { BaseNode, nodeType, objectId } from '../base.js';
+import { MaterialSchema } from '../material.js';
 export const ColumnStyle = z.enum([
     'plain',
     'faceted',
@@ -62,6 +62,7 @@ export const ColumnSupportStyle = z.enum([
 export const ColumnNode = BaseNode.extend({
     id: objectId('column'),
     type: nodeType('column'),
+    children: z.array(z.string()).default([]),
     position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
     rotation: z.number().default(0),
     // Persisted slab-support host — see ItemNode.supportSlabId for the rules.

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

@@ -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<{

package/dist/schema/nodes/construction-dimension.js

@@ -1,7 +1,7 @@
 import dedent from 'dedent';
 import { z } from 'zod';
-import { BaseNode, nodeType, objectId } from '../base';
-import { MeasurementAnchor } from './measurement';
+import { BaseNode, nodeType, objectId } from '../base.js';
+import { MeasurementAnchor } from './measurement.js';
 const FiniteCoordinate = z.number().finite();
 export const ConstructionDimensionBaseline = z
     .object({

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

@@ -1,4 +1,11 @@
 import { z } from 'zod';
+export declare const CupolaMaterialRole: z.ZodEnum<{
+    roof: "roof";
+    body: "body";
+    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

@@ -1,11 +1,13 @@
 import dedent from 'dedent';
 import { z } from 'zod';
-import { BaseNode, nodeType, objectId } from '../base';
-import { MaterialSchema } from '../material';
+import { BaseNode, nodeType, objectId } from '../base.js';
+import { MaterialSchema } from '../material.js';
+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/door.js

@@ -1,7 +1,7 @@
 import dedent from 'dedent';
 import { z } from 'zod';
-import { BaseNode, nodeType, objectId } from '../base';
-import { MaterialSchema } from '../material';
+import { BaseNode, nodeType, objectId } from '../base.js';
+import { MaterialSchema } from '../material.js';
 export const DoorSegment = z.object({
     type: z.enum(['panel', 'glass', 'empty']),
     heightRatio: z.number(),

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

@@ -1,10 +1,24 @@
 import { z } from 'zod';
-import { MaterialSchema } from '../material';
+import { MaterialSchema } from '../material.js';
+import { type RoofSegmentNode } from './roof-segment.js';
+import { WindowNode } from './window.js';
 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

@@ -1,8 +1,10 @@
 import dedent from 'dedent';
 import { z } from 'zod';
-import { BaseNode, nodeType, objectId } from '../base';
-import { MaterialSchema } from '../material';
-import { RoofType } from './roof-segment';
+import { BaseNode, nodeType, objectId } from '../base.js';
+import { MaterialSchema } from '../material.js';
+import { getRoofSegmentSurfaceY, RoofType } from './roof-segment.js';
+import { WindowNode } from './window.js';
+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"}

package/dist/schema/nodes/downspout.js

@@ -1,11 +1,13 @@
 import dedent from 'dedent';
 import { z } from 'zod';
-import { BaseNode, nodeType, objectId } from '../base';
-import { MaterialSchema } from '../material';
+import { BaseNode, nodeType, objectId } from '../base.js';
+import { MaterialSchema } from '../material.js';
+const DEFAULT_DOWNSPOUT_GENERATOR = 'default-downspout';
 export const DownspoutNode = BaseNode.extend({
     id: objectId('downspout'),
     type: nodeType('downspout'),
     material: MaterialSchema.optional(),
+    slots: z.record(z.string(), z.string()).optional(),
     // Match the gutter family default — paint inspector reads "White"
     // instead of "no material" on a freshly placed downspout.
     materialPreset: z.string().default('preset-white'),
@@ -26,6 +28,7 @@ export const DownspoutNode = BaseNode.extend({
     // tool can default to the gutter's eave-Y minus building floor on
     // commit so the user doesn't have to set it on every drop.
     length: z.number().default(2.5),
+    lengthMode: z.enum(['to-ground', 'manual']).optional(),
     // Bore diameter, default 0.07 m ≈ 3″ to match the gutter outlet
     // default. Larger downspouts are common on commercial gutters.
     diameter: z.number().default(0.07),
@@ -61,3 +64,24 @@ export const DownspoutNode = BaseNode.extend({
   - strapStyle / strapSpacing: wall straps clamping the run
   - terminal: bottom treatment (splash block, kickout only, or straight down)
   `);
+function metadataRecord(metadata) {
+    if (typeof metadata === 'object' && metadata !== null && !Array.isArray(metadata)) {
+        return metadata;
+    }
+    return {};
+}
+export function defaultDownspoutMetadata() {
+    return { generatedBy: DEFAULT_DOWNSPOUT_GENERATOR };
+}
+export function isDefaultDownspoutNode(node, gutterId) {
+    const parsed = DownspoutNode.safeParse(node);
+    if (!parsed.success)
+        return false;
+    if (gutterId && parsed.data.gutterId !== gutterId)
+        return false;
+    return metadataRecord(parsed.data.metadata).generatedBy === DEFAULT_DOWNSPOUT_GENERATOR;
+}
+export function usesAutomaticDownspoutLength(node) {
+    return (node.lengthMode === 'to-ground' ||
+        (node.lengthMode === undefined && isDefaultDownspoutNode(node)));
+}

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

@@ -45,7 +45,7 @@ export declare const DuctFittingNode: 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<`duct-fitting_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"duct-fitting">>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
@@ -56,12 +56,26 @@ export declare const DuctFittingNode: z.ZodObject<{
         cross: "cross";
         reducer: "reducer";
         transition: "transition";
+        "end-cap": "end-cap";
+        damper: "damper";
+        "access-panel": "access-panel";
+        coupling: "coupling";
     }>>;
     shape: z.ZodDefault<z.ZodEnum<{
         round: "round";
         rect: "rect";
         oval: "oval";
     }>>;
+    inletShape: z.ZodOptional<z.ZodEnum<{
+        round: "round";
+        rect: "rect";
+        oval: "oval";
+    }>>;
+    outletShape: z.ZodOptional<z.ZodEnum<{
+        round: "round";
+        rect: "rect";
+        oval: "oval";
+    }>>;
     width: z.ZodDefault<z.ZodNumber>;
     height: z.ZodDefault<z.ZodNumber>;
     shape2: z.ZodDefault<z.ZodEnum<{
@@ -84,6 +98,9 @@ export declare const DuctFittingNode: z.ZodObject<{
         supply: "supply";
         return: "return";
     }>>;
+    damperAngle: z.ZodDefault<z.ZodNumber>;
+    panelWidth: z.ZodDefault<z.ZodNumber>;
+    panelHeight: z.ZodDefault<z.ZodNumber>;
     slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
 }, z.core.$strip>;
 export type DuctFittingNode = z.infer<typeof DuctFittingNode>;

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

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

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

@@ -1,6 +1,6 @@
 import dedent from 'dedent';
 import { z } from 'zod';
-import { BaseNode, nodeType, objectId } from '../base';
+import { BaseNode, nodeType, objectId } from '../base.js';
 /**
  * Duct fitting — the junction pieces that connect round duct segments:
  * elbows (direction change), tees (branch takeoff), reducers (diameter
@@ -39,12 +39,27 @@ export const DuctFittingNode = BaseNode.extend({
     position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
     // XYZ euler radians.
     rotation: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
-    fittingType: z.enum(['elbow', 'tee', 'cross', 'reducer', 'transition']).default('elbow'),
+    fittingType: z
+        .enum([
+        'elbow',
+        'tee',
+        'cross',
+        'reducer',
+        'transition',
+        'end-cap',
+        'damper',
+        'access-panel',
+        'coupling',
+    ])
+        .default('elbow'),
     // Run-leg cross-section: round collars, or a rect / flat-oval profile
     // matching the trunk the fitting sits in. Reducers ignore the shape.
     // When non-round, `diameter` carries the area-equivalent round size
     // (drives leg lengths + advertised ports).
     shape: z.enum(['round', 'rect', 'oval']).default('rect'),
+    // Adapter end profiles; omitted values use the fitting type's standard profiles.
+    inletShape: z.enum(['round', 'rect', 'oval']).optional(),
+    outletShape: z.enum(['round', 'rect', 'oval']).optional(),
     // Rect / oval run-leg profile in inches (used when shape ≠ 'round').
     width: z.number().min(4).max(60).default(14),
     height: z.number().min(3).max(40).default(8),
@@ -73,16 +88,22 @@ export const DuctFittingNode = BaseNode.extend({
     diameter2: z.number().min(2).max(48).default(6),
     ductMaterial: z.enum(['sheet-metal', 'flex', 'duct-board']).default('sheet-metal'),
     system: z.enum(['supply', 'return']).default('supply'),
+    damperAngle: z.number().finite().min(0).max(90).default(0),
+    panelWidth: z.number().finite().min(0.1).max(1.2).default(0.25),
+    panelHeight: z.number().finite().min(0.1).max(1.2).default(0.15),
     slots: z.record(z.string(), z.string()).optional(),
 }).describe(dedent `
   Duct fitting - elbow, tee, cross, reducer, or square-to-round transition between duct runs.
   - position: [x, y, z] level-local meters
   - rotation: [x, y, z] euler radians
-  - fittingType: elbow | tee | cross | reducer | transition (rect end -X, round end +X)
-  - shape: round | rect | oval run legs (matches the trunk; ignored by reducer / transition)
+  - fittingType: elbow | tee | cross | reducer | transition | end-cap | damper | access-panel | coupling
+  - damperAngle: blade opening in degrees, 0 closed, 90 open
+  - panelWidth / panelHeight: access door dimensions in meters; door lies in local XY with outward normal +Z; no flow ports
+  - inletShape / outletShape: round | rect | oval adapter end profiles; defaults are round-to-round for reducer and rect-to-round for transition
+  - shape: round | rect | oval run legs (matches the trunk)
   - width / height: rect / oval run-leg profile in inches (transition: the rect end)
   - shape2: round | rect | oval tee / cross branch (matches the duct drawn off the tap)
-  - width2 / height2: rect / oval branch profile in inches
+  - width2 / height2: rect / oval branch or adapter outlet profile in inches
   - angle: elbow turn in degrees (45 or 90 typical)
   - branchAngle: tee branch angle off the outlet axis (90 straight tee, 45 downstream lateral, 135 upstream); cross branches are always square
   - diameter: main nominal diameter in inches

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

@@ -28,10 +28,32 @@ export declare const DuctSegmentNode: 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<`duct-segment_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"duct-segment">>;
     path: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    autoHangers: z.ZodOptional<z.ZodBoolean>;
+    hangerOverrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        fraction: z.ZodOptional<z.ZodNumber>;
+        skipped: z.ZodOptional<z.ZodBoolean>;
+        hostId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    hangerStyle: z.ZodOptional<z.ZodEnum<{
+        double: "double";
+        single: "single";
+    }>>;
+    hangerSpacing: z.ZodOptional<z.ZodNumber>;
+    hangerMaxReach: z.ZodOptional<z.ZodNumber>;
+    wallAttachment: z.ZodOptional<z.ZodObject<{
+        wallId: z.ZodDefault<z.ZodTemplateLiteral<`wall_${string}`>>;
+        side: z.ZodEnum<{
+            front: "front";
+            back: "back";
+        }>;
+        startUV: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+        endUV: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+        offset: z.ZodNumber;
+    }, z.core.$strip>>;
     shape: z.ZodDefault<z.ZodEnum<{
         round: "round";
         rect: "rect";

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

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