@pascal-app/core 0.8.0 → 0.9.2

package/dist/schema/nodes/elevator.js

@@ -0,0 +1,57 @@
+import dedent from 'dedent';
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base';
+import { MaterialSchema } from '../material';
+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']);
+export const ElevatorNode = BaseNode.extend({
+    id: objectId('elevator'),
+    type: nodeType('elevator'),
+    material: MaterialSchema.optional(),
+    materialPreset: z.string().optional(),
+    // Unified paint-slot refs (`scene:`/`library:` MaterialRef per slot id),
+    // matching the slot model items/slab/shelf use. Absent = declared default.
+    slots: z.record(z.string(), z.string()).optional(),
+    position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
+    // Rotation around the Y axis in radians.
+    rotation: z.number().default(0),
+    width: z.number().default(1.84),
+    depth: z.number().default(1.84),
+    shaftWidth: z.number().optional(),
+    shaftDepth: z.number().optional(),
+    shaftWallThickness: z.number().default(0.09),
+    shaftStyle: ElevatorShaftStyle.default('solid'),
+    cabHeight: z.number().default(2.35),
+    doorWidth: z.number().default(0.95),
+    doorHeight: z.number().default(2.1),
+    doorStyle: ElevatorDoorStyle.default('center-opening'),
+    doorPanelStyle: ElevatorDoorPanelStyle.default('glass-frame'),
+    fromLevelId: z.string().nullable().default(null),
+    toLevelId: z.string().nullable().default(null),
+    servedLevelIds: z.array(z.string()).optional(),
+    disabledLevelIds: z.array(z.string()).default([]),
+    serviceOnlyLevelIds: z.array(z.string()).default([]),
+    defaultLevelId: z.string().nullable().default(null),
+    speed: z.number().default(2.2),
+    doorDurationMs: z.number().default(900),
+    dwellMs: z.number().default(1400),
+}).describe(dedent `
+  Elevator node - a vertical transport core attached to a building.
+  - parentId: building that owns this elevator
+  - position: building-local shaft center on the X/Z plane
+  - rotation: rotation around the Y axis
+  - width/depth: cab footprint
+  - shaftWidth/shaftDepth: optional clear shaft footprint; falls back to cab footprint
+  - shaftWallThickness: visible shaft shell thickness
+  - shaftStyle: solid or glass shaft shell presentation
+  - cabHeight: visible elevator cab height
+  - doorWidth/doorHeight/doorStyle: landing and cab door movement/opening presentation
+  - doorPanelStyle: visual leaf style for glass-frame, solid-panel, or segmented-panel doors
+  - fromLevelId / toLevelId: source and destination levels used for service range and auto cutouts
+  - servedLevelIds: legacy optional explicit level list; used only when from/to are missing
+  - disabledLevelIds: stops visible in the service range but unavailable for public/cab requests
+  - serviceOnlyLevelIds: stops unavailable from landing calls but available from cab/admin controls
+  - defaultLevelId: starting/resting level, falling back to the lowest served level
+  - speed/doorDurationMs/dwellMs: runtime animation defaults
+  `);

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

@@ -0,0 +1,68 @@
+import { z } from 'zod';
+export declare const EyebrowVentNode: 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<`eyebrow-vent_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"eyebrow-vent">>;
+    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>;
+    style: z.ZodDefault<z.ZodEnum<{
+        scoop: "scoop";
+        "half-round": "half-round";
+        "slant-box": "slant-box";
+    }>>;
+    louverCount: z.ZodDefault<z.ZodNumber>;
+    backRatio: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type EyebrowVentNode = z.infer<typeof EyebrowVentNode>;
+//# sourceMappingURL=eyebrow-vent.d.ts.map

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

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

package/dist/schema/nodes/eyebrow-vent.js

@@ -0,0 +1,40 @@
+import dedent from 'dedent';
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base';
+import { MaterialSchema } from '../material';
+export const EyebrowVentNode = BaseNode.extend({
+    id: objectId('eyebrow-vent'),
+    type: nodeType('eyebrow-vent'),
+    material: MaterialSchema.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'),
+    roofSegmentId: z.string().optional(),
+    position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
+    rotation: z.number().default(0),
+    // `width` is the opening width (left↔right across the louvered face),
+    // `depth` the front-to-back projection along the roof, `height` the rise.
+    width: z.number().default(0.5),
+    depth: z.number().default(0.6),
+    height: z.number().default(0.3),
+    // Body shape:
+    //  - `scoop`      : rounded louvered opening that sweeps back and tapers
+    //                   into the flashing plate (the classic dormer "eyebrow").
+    //  - `half-round` : a D-shaped half-round louver vent (flat louvered face,
+    //                   semicircular curved top, short body).
+    //  - `slant-box`  : a low box with a slanted top and a screened front.
+    style: z.enum(['scoop', 'half-round', 'slant-box']).default('scoop'),
+    // Number of horizontal louver slats across the front opening (0 = open /
+    // screened only).
+    louverCount: z.number().int().min(0).max(8).default(3),
+    // `slant-box` only: the low rear edge as a fraction of the tall front edge.
+    // 1 = flat-topped box, lower = the top slopes down more steeply toward the
+    // back.
+    backRatio: z.number().min(0.15).max(1).default(0.5),
+}).describe(dedent `
+  Eyebrow vent — a low roof ventilator with a rounded, louvered front that
+  sits on a flashing plate. Three styles: a swept "scoop" eyebrow, a D-shaped
+  "half-round" louver vent, and a "slant-box" hood. Parented to a roof-segment;
+  position is segment-local. Rotation is around the segment's vertical axis
+  (post-slope tilt).
+  `);

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

@@ -3,11 +3,17 @@ export declare const FenceStyle: z.ZodEnum<{
     slat: "slat";
     rail: "rail";
     privacy: "privacy";
+    horizontal: "horizontal";
 }>;
 export declare const FenceBaseStyle: z.ZodEnum<{
     floating: "floating";
     grounded: "grounded";
 }>;
+export declare const FencePostCap: z.ZodEnum<{
+    flat: "flat";
+    none: "none";
+    pyramid: "pyramid";
+}>;
 export declare const FenceNode: z.ZodObject<{
     object: z.ZodDefault<z.ZodLiteral<"node">>;
     name: z.ZodOptional<z.ZodString>;
@@ -28,7 +34,7 @@ export declare const FenceNode: z.ZodObject<{
     type: z.ZodDefault<z.ZodLiteral<"fence">>;
     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";
@@ -39,7 +45,7 @@ export declare const FenceNode: z.ZodObject<{
             plaster: "plaster";
             tile: "tile";
             marble: "marble";
-        }>>;
+        }>>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
             roughness: z.ZodDefault<z.ZodNumber>;
@@ -59,8 +65,11 @@ export declare const FenceNode: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>>;
     materialPreset: z.ZodOptional<z.ZodString>;
+    slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     start: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
     end: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    path: z.ZodOptional<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>;
+    tangents: z.ZodOptional<z.ZodArray<z.ZodNullable<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>>;
     height: z.ZodDefault<z.ZodNumber>;
     thickness: z.ZodDefault<z.ZodNumber>;
     curveOffset: z.ZodOptional<z.ZodNumber>;
@@ -70,15 +79,23 @@ export declare const FenceNode: z.ZodObject<{
     topRailHeight: z.ZodDefault<z.ZodNumber>;
     groundClearance: z.ZodDefault<z.ZodNumber>;
     edgeInset: z.ZodDefault<z.ZodNumber>;
+    slatGap: z.ZodDefault<z.ZodNumber>;
+    postCap: z.ZodDefault<z.ZodEnum<{
+        flat: "flat";
+        none: "none";
+        pyramid: "pyramid";
+    }>>;
     baseStyle: z.ZodDefault<z.ZodEnum<{
         floating: "floating";
         grounded: "grounded";
     }>>;
+    showInfill: z.ZodDefault<z.ZodBoolean>;
     color: z.ZodDefault<z.ZodString>;
     style: z.ZodDefault<z.ZodEnum<{
         slat: "slat";
         rail: "rail";
         privacy: "privacy";
+        horizontal: "horizontal";
     }>>;
 }, z.core.$strip>;
 export type FenceNode = z.infer<typeof FenceNode>;

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

@@ -1 +1 @@
-{"version":3,"file":"fence.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/fence.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,UAAU;;;;EAAsC,CAAA;AAC7D,eAAO,MAAM,cAAc;;;EAAmC,CAAA;AAE9D,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6BrB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}
+{"version":3,"file":"fence.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/fence.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,UAAU;;;;;EAAoD,CAAA;AAC3E,eAAO,MAAM,cAAc;;;EAAmC,CAAA;AAC9D,eAAO,MAAM,YAAY;;;;EAAsC,CAAA;AAE/D,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqDrB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}

package/dist/schema/nodes/fence.js

@@ -2,15 +2,32 @@ import dedent from 'dedent';
 import { z } from 'zod';
 import { BaseNode, nodeType, objectId } from '../base';
 import { MaterialSchema } from '../material';
-export const FenceStyle = z.enum(['slat', 'rail', 'privacy']);
+export const FenceStyle = z.enum(['slat', 'rail', 'privacy', 'horizontal']);
 export const FenceBaseStyle = z.enum(['floating', 'grounded']);
+export const FencePostCap = z.enum(['none', 'flat', 'pyramid']);
 export const FenceNode = BaseNode.extend({
     id: objectId('fence'),
     type: nodeType('fence'),
     material: MaterialSchema.optional(),
     materialPreset: z.string().optional(),
+    // Unified paint-slot refs (`scene:`/`library:` MaterialRef per slot id),
+    // matching the slot model items/slab/shelf use. Absent = declared default.
+    slots: z.record(z.string(), z.string()).optional(),
     start: z.tuple([z.number(), z.number()]),
     end: z.tuple([z.number(), z.number()]),
+    // Optional spline control points in level coordinate meters. When present
+    // (>= 2 points) the fence centerline is a smooth Catmull-Rom curve through
+    // these points and start/end/curveOffset no longer define the centerline.
+    // start/end are kept in sync with the first/last path point so consumers
+    // that read endpoints (handles, bbox, miter references) stay valid. Absent =
+    // the straight or single-arc fence defined by start/end (+ curveOffset).
+    path: z.array(z.tuple([z.number(), z.number()])).optional(),
+    // Optional per-control-point tangent handles, parallel to `path` (same
+    // length when present). Each entry is the OUT-handle offset vector [dx, dy]
+    // from its path point, in level meters; the IN handle is its mirror so the
+    // curve stays smooth through the point. `null` = use the automatic
+    // Catmull-Rom tangent for that point. Only meaningful for spline fences.
+    tangents: z.array(z.tuple([z.number(), z.number()]).nullable()).optional(),
     height: z.number().default(1.8),
     thickness: z.number().default(0.08),
     curveOffset: z.number().optional(),
@@ -20,15 +37,23 @@ export const FenceNode = BaseNode.extend({
     topRailHeight: z.number().default(0.04),
     groundClearance: z.number().default(0),
     edgeInset: z.number().default(0.015),
+    // Reveal between the boards of a `horizontal` fence (0 = flush cladding).
+    slatGap: z.number().default(0.01),
+    // Topper drawn on each `horizontal`-fence post.
+    postCap: FencePostCap.default('pyramid'),
     baseStyle: FenceBaseStyle.default('grounded'),
+    showInfill: z.boolean().default(true),
     color: z.string().default('#ffffff'),
     style: FenceStyle.default('slat'),
 }).describe(dedent `
   Fence node - used to represent a fence segment in the building/site level coordinate system
   - start/end: fence endpoints in level coordinate system
+  - path: optional list of [x, y] points; when set (>= 2) the centerline is a smooth spline through them
+  - tangents: optional per-point handle vectors (parallel to path); null entries fall back to the automatic tangent
   - height/thickness: overall fence dimensions in meters
-  - curveOffset: midpoint sagitta offset used to bend the fence into an arc
+  - curveOffset: midpoint sagitta offset used to bend the fence into an arc (ignored when path is set)
   - baseHeight/postSpacing/postSize/topRailHeight: exact geometric controls from the plan3D fence model
   - groundClearance/edgeInset/baseStyle: fence support and inset configuration
+  - showInfill: whether to draw intermediate posts/slats between end posts
   - color/style: visual appearance options
   `);

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

@@ -0,0 +1,84 @@
+import { z } from 'zod';
+export declare const GutterOutlet: z.ZodObject<{
+    id: z.ZodString;
+    offset: z.ZodDefault<z.ZodNumber>;
+    diameter: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type GutterOutlet = z.infer<typeof GutterOutlet>;
+export declare const GutterNode: 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<`gutter_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"gutter">>;
+    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>;
+    length: z.ZodDefault<z.ZodNumber>;
+    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";
+    }>>;
+    endCapLeft: z.ZodDefault<z.ZodBoolean>;
+    endCapRight: z.ZodDefault<z.ZodBoolean>;
+    hangerStyle: z.ZodDefault<z.ZodEnum<{
+        none: "none";
+        strap: "strap";
+    }>>;
+    hangerSpacing: z.ZodDefault<z.ZodNumber>;
+    outlets: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        offset: z.ZodDefault<z.ZodNumber>;
+        diameter: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type GutterNode = z.infer<typeof GutterNode>;
+//# sourceMappingURL=gutter.d.ts.map

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

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

package/dist/schema/nodes/gutter.js

@@ -0,0 +1,76 @@
+import dedent from 'dedent';
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base';
+import { MaterialSchema } from '../material';
+// 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`).
+export const GutterOutlet = z.object({
+    // Stable id the downspout references. Generated with `generateId('outlet')`.
+    id: z.string(),
+    // Position along the gutter length (gutter-local +X), signed from the
+    // CENTER. The geometry clamps it inside the end caps at build time, so
+    // a stored value that no longer fits just rides the nearest bound.
+    offset: z.number().default(0),
+    // 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),
+});
+export const GutterNode = BaseNode.extend({
+    id: objectId('gutter'),
+    type: nodeType('gutter'),
+    material: MaterialSchema.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.
+    materialPreset: z.string().default('preset-white'),
+    roofSegmentId: z.string().optional(),
+    // Segment-local. The placement tool snaps to the eave line (Z =
+    // +depth/2, Y = wallHeight) of the segment under the cursor; X is
+    // wherever the user clicked. After placement the inspector + length
+    // handles can shift X along the eave.
+    position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
+    // Rotation around the gutter's own local Y. Kept at 0 by default
+    // because the gutter's length axis is constrained to the eave
+    // 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: z.number().default(2.0),
+    // 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
+    // rounds the residential value to 0.13 m.
+    size: z.number().default(0.13),
+    // Wall thickness of the U-channel. Visible on the rim from above; too
+    // thin reads as a paper strip, too thick reads as a curb.
+    thickness: z.number().default(0.006),
+    profile: z.enum(['k-style', 'half-round', 'box']).default('k-style'),
+    // End caps close the open ends of the U-channel so water can't run
+    // out the sides. Independent per-end because a downspout typically
+    // joins the gutter at one end while the other stays capped. Default
+    // true on both — matches a freshly-installed residential gutter.
+    endCapLeft: z.boolean().default(true),
+    endCapRight: z.boolean().default(true),
+    // Hangers are the metal straps that hold the gutter onto the
+    // fascia. 'strap' renders periodic bars across the rim; 'none'
+    // hides them (some plastic gutters use hidden clips). Spacing is
+    // metres between hanger centers; real residential code is roughly
+    // 0.6 m for snow-load areas, 0.75 m elsewhere.
+    hangerStyle: z.enum(['strap', 'none']).default('strap'),
+    hangerSpacing: z.number().default(0.6),
+    // Downspout outlets — short drop tubes descending from the gutter
+    // floor where downspouts connect. Empty by default so existing
+    // gutters don't sprout outlets on schema upgrade. Each is drilled
+    // through the trough floor via CSG; a downspout links to one by id.
+    outlets: z.array(GutterOutlet).default([]),
+}).describe(dedent `
+  Gutter — a rain-water channel running along the eave of a roof
+  segment. Parented to a roof-segment; position is segment-local.
+  - length: span along the eave (gutter-local +X)
+  - size:   profile drop below the eave line (vertical extent)
+  - profile: k-style (ogee fascia), half-round, or square box
+  - endCapLeft / endCapRight: close the trough at gutter-local -X / +X
+  - hangerStyle / hangerSpacing: visible metal straps across the rim
+  - outlets: drop-tube outlets (id + along-length offset + bore diameter)
+  `);

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

@@ -0,0 +1,63 @@
+import { z } from 'zod';
+/**
+ * HVAC equipment — the boxes duct systems start and end at: furnace,
+ * air handler, outdoor condenser.
+ *
+ * Phase 3 of the HVAC node system. Furnaces and air handlers expose
+ * typed duct ports (supply plenum on top, return drop on the side) so
+ * duct runs and fittings snap onto them. Every unit also exposes a
+ * refrigerant service port on its valve face — a condenser, the outdoor
+ * half of a split system, carries no duct ports but pipes to the indoor
+ * coil through a `lineset` run mating onto that port.
+ *
+ * Floor-placed: `position` is level-local meters with y at the base,
+ * `rotation` is yaw radians (the editor's default R-rotate applies).
+ */
+export declare const HvacEquipmentNode: 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<`hvac-equipment_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"hvac-equipment">>;
+    position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    rotation: z.ZodDefault<z.ZodNumber>;
+    equipmentType: z.ZodDefault<z.ZodEnum<{
+        furnace: "furnace";
+        "air-handler": "air-handler";
+        condenser: "condenser";
+    }>>;
+    width: z.ZodDefault<z.ZodNumber>;
+    depth: z.ZodDefault<z.ZodNumber>;
+    height: z.ZodDefault<z.ZodNumber>;
+    supplyShape: z.ZodDefault<z.ZodEnum<{
+        round: "round";
+        rect: "rect";
+        oval: "oval";
+    }>>;
+    returnShape: z.ZodDefault<z.ZodEnum<{
+        round: "round";
+        rect: "rect";
+        oval: "oval";
+    }>>;
+    supplyDiameter: z.ZodDefault<z.ZodNumber>;
+    returnDiameter: z.ZodDefault<z.ZodNumber>;
+    supplyWidth: z.ZodDefault<z.ZodNumber>;
+    supplyHeight: z.ZodDefault<z.ZodNumber>;
+    returnWidth: z.ZodDefault<z.ZodNumber>;
+    returnHeight: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type HvacEquipmentNode = z.infer<typeof HvacEquipmentNode>;
+export type HvacEquipmentNodeId = HvacEquipmentNode['id'];
+//# sourceMappingURL=hvac-equipment.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hvac-equipment.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/hvac-equipment.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuC7B,CAAA;AACD,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AACjE,MAAM,MAAM,mBAAmB,GAAG,iBAAiB,CAAC,IAAI,CAAC,CAAA"}

package/dist/schema/nodes/hvac-equipment.js

@@ -0,0 +1,55 @@
+import dedent from 'dedent';
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base';
+/**
+ * HVAC equipment — the boxes duct systems start and end at: furnace,
+ * air handler, outdoor condenser.
+ *
+ * Phase 3 of the HVAC node system. Furnaces and air handlers expose
+ * typed duct ports (supply plenum on top, return drop on the side) so
+ * duct runs and fittings snap onto them. Every unit also exposes a
+ * refrigerant service port on its valve face — a condenser, the outdoor
+ * half of a split system, carries no duct ports but pipes to the indoor
+ * coil through a `lineset` run mating onto that port.
+ *
+ * Floor-placed: `position` is level-local meters with y at the base,
+ * `rotation` is yaw radians (the editor's default R-rotate applies).
+ */
+export const HvacEquipmentNode = BaseNode.extend({
+    id: objectId('hvac-equipment'),
+    type: nodeType('hvac-equipment'),
+    // Level-local meters, y at the unit's base.
+    position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
+    // Yaw in radians.
+    rotation: z.number().default(0),
+    equipmentType: z.enum(['furnace', 'air-handler', 'condenser']).default('furnace'),
+    // Cabinet dimensions in meters. Defaults match a typical upflow
+    // furnace cabinet (~22" × 28" footprint, ~43" tall).
+    width: z.number().min(0.3).max(2).default(0.56),
+    depth: z.number().min(0.3).max(2).default(0.71),
+    height: z.number().min(0.4).max(2.5).default(1.1),
+    // Duct collar cross-section on the supply / return connections. Round is
+    // the default; rect and oval (flat-oval) match the duct shapes a run
+    // might mate with. Condensers carry no duct collars (ignored).
+    supplyShape: z.enum(['round', 'rect', 'oval']).default('round'),
+    returnShape: z.enum(['round', 'rect', 'oval']).default('round'),
+    // Round collar diameters in inches.
+    supplyDiameter: z.number().min(6).max(30).default(8),
+    returnDiameter: z.number().min(6).max(30).default(8),
+    // Rect / oval collar cross-section in inches: width is the horizontal
+    // face, height the vertical. For oval, height is also the end-cap
+    // semicircle diameter (width ≥ height).
+    supplyWidth: z.number().min(6).max(30).default(12),
+    supplyHeight: z.number().min(6).max(30).default(8),
+    returnWidth: z.number().min(6).max(30).default(14),
+    returnHeight: z.number().min(6).max(30).default(8),
+}).describe(dedent `
+  HVAC equipment cabinet - furnace, air handler, or outdoor condenser.
+  - position: [x, y, z] level-local meters (y = base)
+  - rotation: yaw radians
+  - equipmentType: furnace | air-handler | condenser
+  - width / depth / height: cabinet size in meters
+  - supplyShape / returnShape: round | rect | oval duct collar cross-section (ignored by condenser)
+  - supplyDiameter / returnDiameter: round collar sizes in inches
+  - supplyWidth / supplyHeight / returnWidth / returnHeight: rect / oval collar cross-section in inches
+  `);

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

@@ -157,7 +157,9 @@ declare const assetSchema: z.ZodObject<{
         ceiling: "ceiling";
         "wall-side": "wall-side";
     }>>;
+    recessed: z.ZodOptional<z.ZodBoolean>;
     tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    functionTags: z.ZodOptional<z.ZodArray<z.ZodString>>;
     offset: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     rotation: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     scale: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
@@ -239,7 +241,15 @@ export declare const ItemNode: z.ZodObject<{
     children: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodTemplateLiteral<`item_${string}`>>>>;
     wallId: z.ZodOptional<z.ZodString>;
     wallT: z.ZodOptional<z.ZodNumber>;
+    roofSegmentId: z.ZodOptional<z.ZodString>;
+    roofFace: z.ZodOptional<z.ZodEnum<{
+        front: "front";
+        back: "back";
+        right: "right";
+        left: "left";
+    }>>;
     collectionIds: z.ZodOptional<z.ZodArray<z.ZodCustom<`collection_${string}`, `collection_${string}`>>>;
+    slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     asset: z.ZodObject<{
         id: z.ZodString;
         category: z.ZodString;
@@ -259,7 +269,9 @@ export declare const ItemNode: z.ZodObject<{
             ceiling: "ceiling";
             "wall-side": "wall-side";
         }>>;
+        recessed: z.ZodOptional<z.ZodBoolean>;
         tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        functionTags: z.ZodOptional<z.ZodArray<z.ZodString>>;
         offset: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
         rotation: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
         scale: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;

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

@@ -1 +1 @@
-{"version":3,"file":"item.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/item.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAOvB,QAAA,MAAM,mBAAmB;;;;iBAIvB,CAAA;AAEF,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;iBASvB,CAAA;AAEF,QAAA,MAAM,wBAAwB;;;;;;;;;;iBAO5B,CAAA;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAIjB,CAAA;AAIF,QAAA,MAAM,qBAAqB;;;;;;;iBAOzB,CAAA;AAEF,QAAA,MAAM,iBAAiB;;;;;;iBAMrB,CAAA;AAEF,QAAA,MAAM,YAAY;;;;;;;;;;;;;2BAA2E,CAAA;AAI7F,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGrB,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC/D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC/D,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AACzE,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AACnD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AACnE,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAC3D,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AACjD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkCf,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AACpD,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAE/C,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6BnB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA;AAE/C,eAAO,MAAM,mCAAmC,MAAM,CAAA;AAEtD;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAM/D;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAI5E"}
+{"version":3,"file":"item.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/item.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAOvB,QAAA,MAAM,mBAAmB;;;;iBAIvB,CAAA;AAEF,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;iBASvB,CAAA;AAEF,QAAA,MAAM,wBAAwB;;;;;;;;;;iBAO5B,CAAA;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAIjB,CAAA;AAIF,QAAA,MAAM,qBAAqB;;;;;;;iBAOzB,CAAA;AAEF,QAAA,MAAM,iBAAiB;;;;;;iBAMrB,CAAA;AAEF,QAAA,MAAM,YAAY;;;;;;;;;;;;;2BAA2E,CAAA;AAI7F,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGrB,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC/D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC/D,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AACzE,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AACnD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AACnE,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAC3D,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AACjD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2Cf,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AACpD,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAE/C,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyCnB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA;AAE/C,eAAO,MAAM,mCAAmC,MAAM,CAAA;AAEtD;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAM/D;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAI5E"}