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

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

@@ -1,6 +1,7 @@
 import dedent from 'dedent';
 import { z } from 'zod';
-import { BaseNode, nodeType, objectId } from '../base';
+import { BaseNode, nodeType, objectId } from '../base.js';
+import { HangerOverrides } from './hanger-overrides.js';
 /**
  * Round duct segment — a polyline of 3D points connected by cylindrical
  * duct sections. Forced-air HVAC supply/return runs in US residential.
@@ -20,6 +21,22 @@ export const DuctSegmentNode = BaseNode.extend({
     type: nodeType('duct-segment'),
     // Polyline path in level-local meters. Minimum two points (start, end).
     path: z.array(z.tuple([z.number(), z.number(), z.number()])).min(2),
+    autoHangers: z.boolean().optional(),
+    hangerOverrides: HangerOverrides.optional(),
+    hangerStyle: z.enum(['single', 'double']).optional(),
+    hangerSpacing: z.number().finite().positive().optional(),
+    hangerMaxReach: z.number().finite().positive().optional(),
+    // Logical wall host for runs drafted on a wall. The path remains
+    // level-local; UV coordinates let wall edits reproject the run later.
+    wallAttachment: z
+        .object({
+        wallId: objectId('wall'),
+        side: z.enum(['front', 'back']),
+        startUV: z.tuple([z.number(), z.number()]),
+        endUV: z.tuple([z.number(), z.number()]),
+        offset: z.number().finite().nonnegative(),
+    })
+        .optional(),
     // Cross-section. Round is the branch default; rect is the trunk /
     // plenum profile (real US systems: rect trunk, round branches); oval
     // is the flat-oval profile (two semicircles of the duct height joined
@@ -60,6 +77,9 @@ export const DuctSegmentNode = BaseNode.extend({
     slots: z.record(z.string(), z.string()).optional(),
 }).describe(dedent `
   Duct segment - polyline of 3D points connected by duct sections.
+  - autoHangers: automatically attach supports to nearby walls or ceilings (off when absent)
+  - hangerSpacing: distance between supports in meters (default 1.5)
+  - hangerMaxReach: maximum centerline-to-host distance in meters (default 2)
   - path: list of [x, y, z] points in level-local meters (min 2)
   - shape: round (branches) | rect (trunks / plenums) | oval (flat-oval, tight joist bays)
   - diameter: nominal inner diameter in inches for round (typ. 4-14 residential)

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

@@ -26,7 +26,7 @@ export declare const DuctTerminalNode: 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-terminal_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"duct-terminal">>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;

package/dist/schema/nodes/duct-terminal.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 terminal — where the air loop meets the room: supply registers,
  * ceiling diffusers, return grilles.

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

@@ -31,7 +31,7 @@ export declare const ElevatorNode: 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<`elevator_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"elevator">>;
     material: z.ZodOptional<z.ZodObject<{

package/dist/schema/nodes/elevator.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 ElevatorDoorStyle = z.enum(['center-opening', 'single-left', 'single-right']);
 export const ElevatorDoorPanelStyle = z.enum(['glass-frame', 'solid-panel', 'segmented-panel']);
 export const ElevatorShaftStyle = z.enum(['solid', 'glass']);

package/dist/schema/nodes/eyebrow-vent.d.ts

@@ -1,4 +1,9 @@
 import { z } from 'zod';
+export declare const EyebrowVentMaterialRole: z.ZodEnum<{
+    front: "front";
+    hood: "hood";
+}>;
+export type EyebrowVentMaterialRole = z.infer<typeof EyebrowVentMaterialRole>;
 export declare const EyebrowVentNode: z.ZodObject<{
     object: z.ZodDefault<z.ZodLiteral<"node">>;
     name: z.ZodOptional<z.ZodString>;
@@ -14,7 +19,7 @@ export declare const EyebrowVentNode: 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<`eyebrow-vent_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"eyebrow-vent">>;
     material: z.ZodOptional<z.ZodObject<{
@@ -49,6 +54,7 @@ export declare const EyebrowVentNode: 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>>;
@@ -57,8 +63,8 @@ export declare const EyebrowVentNode: z.ZodObject<{
     depth: z.ZodDefault<z.ZodNumber>;
     height: z.ZodDefault<z.ZodNumber>;
     style: z.ZodDefault<z.ZodEnum<{
-        scoop: "scoop";
         "half-round": "half-round";
+        scoop: "scoop";
         "slant-box": "slant-box";
     }>>;
     louverCount: z.ZodDefault<z.ZodNumber>;

package/dist/schema/nodes/eyebrow-vent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"eyebrow-vent.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/eyebrow-vent.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2C3B,CAAA;AAED,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA"}
+{"version":3,"file":"eyebrow-vent.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/eyebrow-vent.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,uBAAuB;;;EAA4B,CAAA;AAChE,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAA;AAE7E,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4C3B,CAAA;AAED,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA"}

package/dist/schema/nodes/eyebrow-vent.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 EyebrowVentMaterialRole = z.enum(['hood', 'front']);
 export const EyebrowVentNode = BaseNode.extend({
     id: objectId('eyebrow-vent'),
     type: nodeType('eyebrow-vent'),
     material: MaterialSchema.optional(),
+    slots: z.record(z.string(), z.string()).optional(),
     // Default to the white preset so a freshly-placed vent reads as clean
     // painted metal and the paint inspector shows "White" (matches box-vent).
     materialPreset: z.string().default('preset-white'),

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

@@ -29,7 +29,7 @@ export declare const FenceNode: 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<`fence_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"fence">>;
     material: z.ZodOptional<z.ZodObject<{

package/dist/schema/nodes/fence.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 FenceStyle = z.enum(['slat', 'rail', 'privacy', 'horizontal']);
 export const FenceBaseStyle = z.enum(['floating', 'grounded']);
 export const FencePostCap = z.enum(['none', 'flat', 'pyramid']);

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

@@ -22,7 +22,7 @@ export declare const GuideNode: 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<`guide_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"guide">>;
     url: z.ZodString;

package/dist/schema/nodes/guide.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
-import { AssetUrl } from '../asset-url';
-import { BaseNode, nodeType, objectId } from '../base';
+import { AssetUrl } from '../asset-url.js';
+import { BaseNode, nodeType, objectId } from '../base.js';
 export const GuideScaleReference = z.object({
     start: z.tuple([z.number(), z.number()]),
     end: z.tuple([z.number(), z.number()]),

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

@@ -1,8 +1,24 @@
 import { z } from 'zod';
+import { type RoofSegmentNode } from './roof-segment.js';
+export declare const GUTTER_EAVE_TUCK_INWARD = 0.04;
+export declare const GUTTER_EAVE_TUCK_UP = 0.04;
+export type GutterEaveSide = '+X' | '-X' | '+Z' | '-Z';
+export type GutterRun = {
+    side: GutterEaveSide;
+    position: [number, number, number];
+    rotation: number;
+    length: number;
+};
+export type GutterEdgeExclusion = {
+    side: GutterEaveSide;
+    from: number;
+    to: number;
+};
 export declare const GutterOutlet: z.ZodObject<{
     id: z.ZodString;
     offset: z.ZodDefault<z.ZodNumber>;
     diameter: z.ZodDefault<z.ZodNumber>;
+    generatedBy: z.ZodOptional<z.ZodLiteral<"default-downspout">>;
 }, z.core.$strip>;
 export type GutterOutlet = z.infer<typeof GutterOutlet>;
 export declare const GutterNode: z.ZodObject<{
@@ -20,7 +36,7 @@ export declare const GutterNode: 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<`gutter_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"gutter">>;
     material: z.ZodOptional<z.ZodObject<{
@@ -55,17 +71,23 @@ export declare const GutterNode: 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>>;
     rotation: z.ZodDefault<z.ZodNumber>;
     length: z.ZodDefault<z.ZodNumber>;
+    arc: z.ZodOptional<z.ZodObject<{
+        centerX: z.ZodNumber;
+        centerZ: z.ZodNumber;
+        radius: z.ZodNumber;
+    }, z.core.$strip>>;
     size: z.ZodDefault<z.ZodNumber>;
     thickness: z.ZodDefault<z.ZodNumber>;
     profile: z.ZodDefault<z.ZodEnum<{
         box: "box";
-        "half-round": "half-round";
         "k-style": "k-style";
+        "half-round": "half-round";
     }>>;
     endCapLeft: z.ZodDefault<z.ZodBoolean>;
     endCapRight: z.ZodDefault<z.ZodBoolean>;
@@ -78,7 +100,19 @@ export declare const GutterNode: z.ZodObject<{
         id: z.ZodString;
         offset: z.ZodDefault<z.ZodNumber>;
         diameter: z.ZodDefault<z.ZodNumber>;
+        generatedBy: z.ZodOptional<z.ZodLiteral<"default-downspout">>;
     }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type GutterNode = z.infer<typeof GutterNode>;
+export declare function computeGutterEaveY(segment: Pick<RoofSegmentNode, 'wallHeight' | 'overhang' | 'pitch' | 'roofType'>): number;
+export declare function getGutterRunsForSegment(segment: RoofSegmentNode, roofSegments?: readonly RoofSegmentNode[], exclusions?: readonly GutterEdgeExclusion[]): GutterRun[];
+export declare function createDefaultGuttersForSegment(segment: RoofSegmentNode, roofSegments?: readonly RoofSegmentNode[], exclusions?: readonly GutterEdgeExclusion[]): GutterNode[];
+export declare function getDefaultGutterSide(node: unknown, roofSegmentId?: RoofSegmentNode['id']): GutterEaveSide | null;
+export declare function isDefaultGutterNode(node: unknown, roofSegmentId?: RoofSegmentNode['id']): node is GutterNode;
+export declare function hasAutoGutterMetadata(segment: Pick<RoofSegmentNode, 'metadata'>): segment is Pick<RoofSegmentNode, 'metadata'> & {
+    metadata: Record<string, unknown> & {
+        autoGutter: boolean;
+    };
+};
+export declare function isAutoGutterEnabled(segment: Pick<RoofSegmentNode, 'id' | 'children' | 'metadata'>, nodes?: Record<string, unknown>): boolean;
 //# sourceMappingURL=gutter.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"gutter.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/gutter.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAOvB,eAAO,MAAM,YAAY;;;;iBAUvB,CAAA;AACF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AAEvD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkEtB,CAAA;AAED,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA"}
+{"version":3,"file":"gutter.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/gutter.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,OAAO,EAA4B,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAO/E,eAAO,MAAM,uBAAuB,OAAO,CAAA;AAC3C,eAAO,MAAM,mBAAmB,OAAO,CAAA;AACvC,MAAM,MAAM,cAAc,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAA;AAEtD,MAAM,MAAM,SAAS,GAAG;IACtB,IAAI,EAAE,cAAc,CAAA;IACpB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,EAAE,cAAc,CAAA;IACpB,IAAI,EAAE,MAAM,CAAA;IACZ,EAAE,EAAE,MAAM,CAAA;CACX,CAAA;AAQD,eAAO,MAAM,YAAY;;;;;iBAWvB,CAAA;AACF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AAEvD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8EtB,CAAA;AAED,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA;AASnD,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,YAAY,GAAG,UAAU,GAAG,OAAO,GAAG,UAAU,CAAC,GAC/E,MAAM,CAKR;AAmND,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,eAAe,EACxB,YAAY,GAAE,SAAS,eAAe,EAAO,EAC7C,UAAU,GAAE,SAAS,mBAAmB,EAAO,GAC9C,SAAS,EAAE,CAkDb;AAED,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,eAAe,EACxB,YAAY,GAAE,SAAS,eAAe,EAAO,EAC7C,UAAU,GAAE,SAAS,mBAAmB,EAAO,GAC9C,UAAU,EAAE,CAcd;AAED,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,OAAO,EACb,aAAa,CAAC,EAAE,eAAe,CAAC,IAAI,CAAC,GACpC,cAAc,GAAG,IAAI,CAQvB;AAED,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,OAAO,EACb,aAAa,CAAC,EAAE,eAAe,CAAC,IAAI,CAAC,GACpC,IAAI,IAAI,UAAU,CAEpB;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,UAAU,CAAC,GAAG,OAAO,IAAI,IAAI,CAChG,eAAe,EACf,UAAU,CACX,GAAG;IACF,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;QAAE,UAAU,EAAE,OAAO,CAAA;KAAE,CAAA;CAC5D,CAEA;AAED,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,IAAI,GAAG,UAAU,GAAG,UAAU,CAAC,EAC9D,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,OAAO,CAKT"}

package/dist/schema/nodes/gutter.js

@@ -1,7 +1,14 @@
 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';
+import { normalizeRoofSegmentTrim } from './roof-segment.js';
+import { getRoofShapeEaveSides } from './roof-segment-shape.js';
+const MIN_DEFAULT_GUTTER_LENGTH_M = 0.2;
+const DEFAULT_GUTTER_GENERATOR = 'default-gutter';
+const AUTO_GUTTER_METADATA_KEY = 'autoGutter';
+export const GUTTER_EAVE_TUCK_INWARD = 0.04;
+export const GUTTER_EAVE_TUCK_UP = 0.04;
 // A single drop outlet drilled in the gutter floor. A gutter can carry
 // several so a long run can split between multiple downspouts (each
 // downspout links to one outlet via its `outletId`).
@@ -15,11 +22,13 @@ export const GutterOutlet = z.object({
     // Bore diameter of this drop. Default 0.07 m ≈ 3″. The cross-section
     // SHAPE (round vs rectangular) follows the gutter's profile, not this.
     diameter: z.number().default(0.07),
+    generatedBy: z.literal('default-downspout').optional(),
 });
 export const GutterNode = BaseNode.extend({
     id: objectId('gutter'),
     type: nodeType('gutter'),
     material: MaterialSchema.optional(),
+    slots: z.record(z.string(), z.string()).optional(),
     // White preset by default — matches the rest of the roof accessory
     // family (box-vent / ridge-vent) so the paint inspector reads as
     // "White" instead of "no material" on a freshly-placed gutter.
@@ -35,8 +44,19 @@ export const GutterNode = BaseNode.extend({
     // direction (segment-local +X) — but exposed in case the user wants
     // to tilt for a custom run.
     rotation: z.number().default(0),
-    // Length along the eave (gutter-local +X).
+    // Length along the eave (gutter-local +X). For a curved eave this is the
+    // arc length of the run.
     length: z.number().default(2.0),
+    // Concentric-arc descriptor for a run that follows a curved eave, in
+    // gutter-mesh-local coordinates (center + true radius). Absent for a straight
+    // gutter.
+    arc: z
+        .object({
+        centerX: z.number(),
+        centerZ: z.number(),
+        radius: z.number(),
+    })
+        .optional(),
     // Profile size — the vertical drop of the U-channel below the eave
     // line. 5″ (0.127 m) is the most common residential gutter size; 6″
     // (0.152 m) is the common commercial / heavy-duty size. Default
@@ -74,3 +94,290 @@ export const GutterNode = BaseNode.extend({
   - hangerStyle / hangerSpacing: visible metal straps across the rim
   - outlets: drop-tube outlets (id + along-length offset + bore diameter)
   `);
+function metadataRecord(metadata) {
+    if (typeof metadata === 'object' && metadata !== null && !Array.isArray(metadata)) {
+        return metadata;
+    }
+    return {};
+}
+export function computeGutterEaveY(segment) {
+    const wallHeight = segment.wallHeight ?? 0;
+    if ((segment.roofType ?? 'gable') === 'flat')
+        return wallHeight;
+    const pitchRad = ((segment.pitch ?? 0) * Math.PI) / 180;
+    return wallHeight - (segment.overhang ?? 0) * Math.tan(pitchRad) + GUTTER_EAVE_TUCK_UP;
+}
+function getDefaultGutterSides(segment) {
+    return getRoofShapeEaveSides(segment.roofType);
+}
+function getGutterEnvelope(segment) {
+    const halfW = Math.max(0, segment.width) / 2;
+    const halfD = Math.max(0, segment.depth) / 2;
+    const overhang = Math.max(0, segment.overhang ?? 0);
+    const outerHalfW = Math.max(halfW, halfW + overhang - GUTTER_EAVE_TUCK_INWARD);
+    const outerHalfD = Math.max(halfD, halfD + overhang - GUTTER_EAVE_TUCK_INWARD);
+    const trim = normalizeRoofSegmentTrim(segment);
+    const minX = trim.left > 0 ? -halfW + trim.left : -outerHalfW;
+    const maxX = trim.right > 0 ? halfW - trim.right : outerHalfW;
+    const minZ = trim.back > 0 ? -halfD + trim.back : -outerHalfD;
+    const maxZ = trim.front > 0 ? halfD - trim.front : outerHalfD;
+    return { minX, maxX, minZ, maxZ, outerHalfW, outerHalfD, trim };
+}
+function getGutterEnvelopePolygon(segment) {
+    const { minX, maxX, minZ, maxZ, trim } = getGutterEnvelope(segment);
+    return [
+        [minX + trim.backLeftX, minZ],
+        [maxX - trim.backRightX, minZ],
+        [maxX, minZ + trim.backRightZ],
+        [maxX, maxZ - trim.frontRightZ],
+        [maxX - trim.frontRightX, maxZ],
+        [minX + trim.frontLeftX, maxZ],
+        [minX, maxZ - trim.frontLeftZ],
+        [minX, minZ + trim.backLeftZ],
+    ];
+}
+function segmentLocalToRoof(segment, point) {
+    const rotation = segment.rotation ?? 0;
+    const cos = Math.cos(rotation);
+    const sin = Math.sin(rotation);
+    return [
+        (segment.position?.[0] ?? 0) + point[0] * cos + point[1] * sin,
+        (segment.position?.[2] ?? 0) - point[0] * sin + point[1] * cos,
+    ];
+}
+function pointOnSegment(point, a, b) {
+    const lengthSq = (b[0] - a[0]) ** 2 + (b[1] - a[1]) ** 2;
+    if (lengthSq <= 1e-14) {
+        return (point[0] - a[0]) ** 2 + (point[1] - a[1]) ** 2 <= 1e-14;
+    }
+    const cross = (point[0] - a[0]) * (b[1] - a[1]) - (point[1] - a[1]) * (b[0] - a[0]);
+    if (Math.abs(cross) > 1e-7)
+        return false;
+    const dot = (point[0] - a[0]) * (b[0] - a[0]) + (point[1] - a[1]) * (b[1] - a[1]);
+    if (dot < -1e-7)
+        return false;
+    return dot <= lengthSq + 1e-7;
+}
+function pointStrictlyInsidePolygon(point, polygon) {
+    let inside = false;
+    for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+        const a = polygon[j];
+        const b = polygon[i];
+        if (pointOnSegment(point, a, b))
+            return false;
+        if (a[1] > point[1] !== b[1] > point[1] &&
+            point[0] < ((b[0] - a[0]) * (point[1] - a[1])) / (b[1] - a[1]) + a[0]) {
+            inside = !inside;
+        }
+    }
+    return inside;
+}
+function segmentCrossingT(start, end, a, b) {
+    const rx = end[0] - start[0];
+    const rz = end[1] - start[1];
+    const sx = b[0] - a[0];
+    const sz = b[1] - a[1];
+    const denominator = rx * sz - rz * sx;
+    if (Math.abs(denominator) < 1e-10)
+        return null;
+    const dx = a[0] - start[0];
+    const dz = a[1] - start[1];
+    const t = (dx * sz - dz * sx) / denominator;
+    const u = (dx * rz - dz * rx) / denominator;
+    if (t < -1e-8 || t > 1 + 1e-8 || u < -1e-8 || u > 1 + 1e-8)
+        return null;
+    return Math.max(0, Math.min(1, t));
+}
+function coveredIntervals(start, end, polygon) {
+    const splits = [0, 1];
+    for (let i = 0; i < polygon.length; i++) {
+        const t = segmentCrossingT(start, end, polygon[i], polygon[(i + 1) % polygon.length]);
+        if (t !== null)
+            splits.push(t);
+    }
+    splits.sort((a, b) => a - b);
+    const unique = splits.filter((value, index) => index === 0 || value - splits[index - 1] > 1e-7);
+    const intervals = [];
+    for (let i = 0; i < unique.length - 1; i++) {
+        const from = unique[i];
+        const to = unique[i + 1];
+        if (to - from <= 1e-7)
+            continue;
+        const middle = (from + to) / 2;
+        const point = [
+            start[0] + (end[0] - start[0]) * middle,
+            start[1] + (end[1] - start[1]) * middle,
+        ];
+        if (pointStrictlyInsidePolygon(point, polygon))
+            intervals.push([from, to]);
+    }
+    return intervals;
+}
+function subtractInterval(visible, covered) {
+    const next = [];
+    for (const [from, to] of visible) {
+        if (covered[1] <= from + 1e-7 || covered[0] >= to - 1e-7) {
+            next.push([from, to]);
+            continue;
+        }
+        if (covered[0] > from + 1e-7)
+            next.push([from, Math.min(to, covered[0])]);
+        if (covered[1] < to - 1e-7)
+            next.push([Math.max(from, covered[1]), to]);
+    }
+    return next;
+}
+function clipRunAgainstSegments(run, segment, roofSegments) {
+    const direction = [Math.cos(run.rotation), -Math.sin(run.rotation)];
+    const localStart = [
+        run.position[0] - direction[0] * (run.length / 2),
+        run.position[2] - direction[1] * (run.length / 2),
+    ];
+    const localEnd = [
+        run.position[0] + direction[0] * (run.length / 2),
+        run.position[2] + direction[1] * (run.length / 2),
+    ];
+    const roofStart = segmentLocalToRoof(segment, localStart);
+    const roofEnd = segmentLocalToRoof(segment, localEnd);
+    let visible = [[0, 1]];
+    for (const sibling of roofSegments) {
+        if (sibling.id === segment.id)
+            continue;
+        const polygon = getGutterEnvelopePolygon(sibling).map((point) => segmentLocalToRoof(sibling, point));
+        for (const covered of coveredIntervals(roofStart, roofEnd, polygon)) {
+            visible = subtractInterval(visible, covered);
+        }
+        if (visible.length === 0)
+            break;
+    }
+    return visible
+        .map(([from, to]) => {
+        const length = run.length * (to - from);
+        const middle = (from + to) / 2;
+        return {
+            ...run,
+            position: [
+                localStart[0] + (localEnd[0] - localStart[0]) * middle,
+                run.position[1],
+                localStart[1] + (localEnd[1] - localStart[1]) * middle,
+            ],
+            length,
+        };
+    })
+        .filter((candidate) => candidate.length >= MIN_DEFAULT_GUTTER_LENGTH_M);
+}
+function clipRunAgainstExclusions(run, exclusions) {
+    let visible = [[0, 1]];
+    for (const exclusion of exclusions) {
+        if (exclusion.side !== run.side)
+            continue;
+        const from = Math.max(0, Math.min(1, Math.min(exclusion.from, exclusion.to)));
+        const to = Math.max(0, Math.min(1, Math.max(exclusion.from, exclusion.to)));
+        visible = subtractInterval(visible, [from, to]);
+        if (visible.length === 0)
+            break;
+    }
+    const direction = [Math.cos(run.rotation), -Math.sin(run.rotation)];
+    const start = [
+        run.position[0] - direction[0] * (run.length / 2),
+        run.position[2] - direction[1] * (run.length / 2),
+    ];
+    return visible
+        .map(([from, to]) => {
+        const length = run.length * (to - from);
+        const middle = (from + to) / 2;
+        return {
+            ...run,
+            position: [
+                start[0] + direction[0] * run.length * middle,
+                run.position[1],
+                start[1] + direction[1] * run.length * middle,
+            ],
+            length,
+        };
+    })
+        .filter((candidate) => candidate.length >= MIN_DEFAULT_GUTTER_LENGTH_M);
+}
+export function getGutterRunsForSegment(segment, roofSegments = [], exclusions = []) {
+    const { minX, maxX, minZ, maxZ, outerHalfW, outerHalfD, trim } = getGutterEnvelope(segment);
+    const eaveY = computeGutterEaveY(segment);
+    const runs = {
+        '+Z': trim.front > 0
+            ? null
+            : {
+                side: '+Z',
+                position: [(minX + maxX) / 2, eaveY, outerHalfD],
+                rotation: 0,
+                length: maxX - minX,
+            },
+        '-Z': trim.back > 0
+            ? null
+            : {
+                side: '-Z',
+                position: [(minX + maxX) / 2, eaveY, -outerHalfD],
+                rotation: Math.PI,
+                length: maxX - minX,
+            },
+        '+X': trim.right > 0
+            ? null
+            : {
+                side: '+X',
+                position: [outerHalfW, eaveY, (minZ + maxZ) / 2],
+                rotation: Math.PI / 2,
+                length: maxZ - minZ,
+            },
+        '-X': trim.left > 0
+            ? null
+            : {
+                side: '-X',
+                position: [-outerHalfW, eaveY, (minZ + maxZ) / 2],
+                rotation: -Math.PI / 2,
+                length: maxZ - minZ,
+            },
+    };
+    const candidates = getDefaultGutterSides(segment)
+        .map((side) => runs[side])
+        .filter((run) => run !== null && run.length >= MIN_DEFAULT_GUTTER_LENGTH_M);
+    return candidates
+        .flatMap((run) => clipRunAgainstExclusions(run, exclusions))
+        .flatMap((run) => clipRunAgainstSegments(run, segment, roofSegments));
+}
+export function createDefaultGuttersForSegment(segment, roofSegments = [], exclusions = []) {
+    return getGutterRunsForSegment(segment, roofSegments, exclusions).map((run) => GutterNode.parse({
+        name: 'Gutter',
+        roofSegmentId: segment.id,
+        position: run.position,
+        rotation: run.rotation,
+        length: run.length,
+        metadata: {
+            generatedBy: DEFAULT_GUTTER_GENERATOR,
+            autoGutterSide: run.side,
+        },
+    }));
+}
+export function getDefaultGutterSide(node, roofSegmentId) {
+    const parsed = GutterNode.safeParse(node);
+    if (!parsed.success)
+        return null;
+    if (roofSegmentId && parsed.data.roofSegmentId !== roofSegmentId)
+        return null;
+    const metadata = metadataRecord(parsed.data.metadata);
+    if (metadata.generatedBy !== DEFAULT_GUTTER_GENERATOR)
+        return null;
+    const side = metadata.autoGutterSide;
+    return side === '+X' || side === '-X' || side === '+Z' || side === '-Z' ? side : null;
+}
+export function isDefaultGutterNode(node, roofSegmentId) {
+    return getDefaultGutterSide(node, roofSegmentId) !== null;
+}
+export function hasAutoGutterMetadata(segment) {
+    return typeof metadataRecord(segment.metadata)[AUTO_GUTTER_METADATA_KEY] === 'boolean';
+}
+export function isAutoGutterEnabled(segment, nodes) {
+    const metadataValue = metadataRecord(segment.metadata)[AUTO_GUTTER_METADATA_KEY];
+    if (typeof metadataValue === 'boolean')
+        return metadataValue;
+    if (!nodes)
+        return false;
+    return (segment.children ?? []).some((childId) => isDefaultGutterNode(nodes[childId], segment.id));
+}

package/dist/schema/nodes/hanger-overrides.d.ts

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+export declare const HangerOverrides: z.ZodRecord<z.ZodString, z.ZodObject<{
+    fraction: z.ZodOptional<z.ZodNumber>;
+    skipped: z.ZodOptional<z.ZodBoolean>;
+    hostId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
+//# sourceMappingURL=hanger-overrides.d.ts.map

package/dist/schema/nodes/hanger-overrides.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hanger-overrides.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/hanger-overrides.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,eAAe;;;;kBAO3B,CAAA"}

package/dist/schema/nodes/hanger-overrides.js

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export const HangerOverrides = z.record(z.string(), z.object({
+    fraction: z.number().finite().min(0).max(1).optional(),
+    skipped: z.boolean().optional(),
+    hostId: z.string().optional(),
+}));

package/dist/schema/nodes/hvac-equipment.d.ts

@@ -28,7 +28,7 @@ export declare const HvacEquipmentNode: 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<`hvac-equipment_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"hvac-equipment">>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;

package/dist/schema/nodes/hvac-equipment.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';
 /**
  * HVAC equipment — the boxes duct systems start and end at: furnace,
  * air handler, outdoor condenser.