@pascal-app/core 0.9.1 → 0.9.2

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

@@ -0,0 +1,73 @@
+import dedent from 'dedent';
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base';
+/**
+ * Round duct segment — a polyline of 3D points connected by cylindrical
+ * duct sections. Forced-air HVAC supply/return runs in US residential.
+ *
+ * Phase 1 of the HVAC node system: just the geometry primitive. Fittings,
+ * terminals, equipment, and typed ports come in later slices.
+ *
+ * Path coordinates are level-local meters: [x, y, z] tuples. y is height
+ * above the level floor. A duct hung at ceiling height through three points
+ * is e.g. `[[0, 2.6, 0], [3, 2.6, 0], [3, 2.6, 4]]`.
+ *
+ * Diameters are nominal US round-duct sizes in inches; the geometry
+ * builder converts to meters for the cylinder radius.
+ */
+export const DuctSegmentNode = BaseNode.extend({
+    id: objectId('duct-segment'),
+    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),
+    // 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
+    // by flat sides) used where round won't fit a joist bay.
+    shape: z.enum(['round', 'rect', 'oval']).default('round'),
+    // Nominal inner diameter in inches (round shape). Common residential
+    // sizes 4"–14"; we accept any positive number so the inspector slider
+    // stays ergonomic and larger commercial sizes load without a schema bump.
+    diameter: z.number().min(2).max(48).default(6),
+    // Rect / oval cross-section in inches: width is the horizontal face,
+    // height the vertical. Typical residential trunks 12×8 – 24×10. For
+    // oval, height is also the end-cap semicircle diameter (width ≥ height).
+    width: z.number().min(4).max(60).default(14),
+    height: z.number().min(3).max(40).default(8),
+    // Cross-section roll (radians) about the run direction. 0 = width
+    // horizontal / height vertical (the natural orientation the geometry
+    // derives from direction). Non-zero only on a rect riser turned out of
+    // the horizontal plane, so its profile stays continuous through the
+    // elbow it left instead of snapping to the world-axis fallback.
+    roll: z.number().default(0),
+    // Construction material. Spiral is round rigid sheet metal with the
+    // helical lock seam drawn on the body (round shape only — rect / oval
+    // runs render it as plain sheet metal).
+    ductMaterial: z.enum(['sheet-metal', 'spiral', 'flex', 'duct-board']).default('flex'),
+    // Whether to draw the construction body detail (spiral lock seam /
+    // flex wire corrugation) on round runs. Off renders a smooth body —
+    // lighter on the eyes and the GPU in dense scenes.
+    seamDetail: z.boolean().default(false),
+    // Whether the run wears its external insulation wrap (drawn as a
+    // translucent shell). Off by default — bare duct.
+    insulated: z.boolean().default(false),
+    // External insulation R-value (used when insulated). Common flex-duct
+    // values are R-4.2, R-6, R-8.
+    insulationR: z.number().min(0).max(12).default(0.5),
+    // Which side of the air loop this segment belongs to. Drives visual tint
+    // and (in later slices) System graph membership.
+    system: z.enum(['supply', 'return']).default('supply'),
+    slots: z.record(z.string(), z.string()).optional(),
+}).describe(dedent `
+  Duct segment - polyline of 3D points connected by duct sections.
+  - 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)
+  - width / height: rect / oval cross-section in inches (typ. 12x8 - 24x10 trunks)
+  - roll: cross-section roll in radians (0 = upright; set on risers to stay continuous through their elbow)
+  - ductMaterial: sheet-metal | spiral (round rigid, helical seam) | flex | duct-board
+  - seamDetail: draw the spiral seam / flex corrugation on round runs (default off)
+  - insulated: whether the run wears its external insulation wrap (default off)
+  - insulationR: external insulation R-value when insulated (4, 6, 8 typical)
+  - system: supply | return (drives visual tint)
+  `);

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

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+/**
+ * Duct terminal — where the air loop meets the room: supply registers,
+ * ceiling diffusers, return grilles.
+ *
+ * Phase 3 of the HVAC node system. Each terminal exposes a single typed
+ * port at its collar (behind/above/below the face depending on mount),
+ * so duct runs end onto it like any other port.
+ *
+ * `position` is the center of the visible face in level-local meters —
+ * floor registers at y≈0, ceiling diffusers at ceiling height, wall
+ * registers at their height on the wall. `rotation` is yaw radians.
+ */
+export declare const DuctTerminalNode: 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<`duct-terminal_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"duct-terminal">>;
+    position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    rotation: z.ZodDefault<z.ZodNumber>;
+    terminalType: z.ZodDefault<z.ZodEnum<{
+        "supply-register": "supply-register";
+        diffuser: "diffuser";
+        "return-grille": "return-grille";
+    }>>;
+    mount: z.ZodDefault<z.ZodEnum<{
+        wall: "wall";
+        ceiling: "ceiling";
+        floor: "floor";
+    }>>;
+    width: z.ZodDefault<z.ZodNumber>;
+    depth: z.ZodDefault<z.ZodNumber>;
+    collarShape: z.ZodDefault<z.ZodEnum<{
+        round: "round";
+        rect: "rect";
+        oval: "oval";
+    }>>;
+    collarDiameter: z.ZodDefault<z.ZodNumber>;
+    collarWidth: z.ZodDefault<z.ZodNumber>;
+    collarHeight: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type DuctTerminalNode = z.infer<typeof DuctTerminalNode>;
+export type DuctTerminalNodeId = DuctTerminalNode['id'];
+//# sourceMappingURL=duct-terminal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"duct-terminal.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/duct-terminal.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAqC5B,CAAA;AACD,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAC/D,MAAM,MAAM,kBAAkB,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAA"}

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

@@ -0,0 +1,51 @@
+import dedent from 'dedent';
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base';
+/**
+ * Duct terminal — where the air loop meets the room: supply registers,
+ * ceiling diffusers, return grilles.
+ *
+ * Phase 3 of the HVAC node system. Each terminal exposes a single typed
+ * port at its collar (behind/above/below the face depending on mount),
+ * so duct runs end onto it like any other port.
+ *
+ * `position` is the center of the visible face in level-local meters —
+ * floor registers at y≈0, ceiling diffusers at ceiling height, wall
+ * registers at their height on the wall. `rotation` is yaw radians.
+ */
+export const DuctTerminalNode = BaseNode.extend({
+    id: objectId('duct-terminal'),
+    type: nodeType('duct-terminal'),
+    // Level-local meters — center of the face.
+    position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
+    // Yaw in radians.
+    rotation: z.number().default(0),
+    terminalType: z.enum(['supply-register', 'diffuser', 'return-grille']).default('supply-register'),
+    // Which surface the terminal mounts on. Drives face orientation and
+    // which way the collar (and its port) points.
+    mount: z.enum(['floor', 'ceiling', 'wall']).default('floor'),
+    // Face dimensions in meters. Typical floor register ~0.30 × 0.15;
+    // ceiling diffusers are square (0.6 × 0.6); return grilles run large.
+    width: z.number().min(0.1).max(1.5).default(0.3),
+    depth: z.number().min(0.05).max(1.5).default(0.15),
+    // Collar cross-section on the duct side. Round is the default; rect and
+    // oval (flat-oval) match the duct shapes a run might end with.
+    collarShape: z.enum(['round', 'rect', 'oval']).default('round'),
+    // Round collar diameter in inches on the duct side.
+    collarDiameter: z.number().min(4).max(20).default(6),
+    // 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).
+    collarWidth: z.number().min(4).max(20).default(10),
+    collarHeight: z.number().min(3).max(20).default(6),
+}).describe(dedent `
+  Duct terminal - supply register, ceiling diffuser, or return grille.
+  - position: [x, y, z] level-local meters, center of the face
+  - rotation: yaw radians
+  - terminalType: supply-register | diffuser | return-grille (grille = return side)
+  - mount: floor | ceiling | wall - face orientation + collar direction
+  - width / depth: face size in meters
+  - collarShape: round | rect | oval - duct-side collar cross-section
+  - collarDiameter: round collar diameter in inches
+  - collarWidth / collarHeight: rect / oval collar cross-section in inches
+  `);

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

@@ -36,7 +36,7 @@ export declare const ElevatorNode: z.ZodObject<{
     type: z.ZodDefault<z.ZodLiteral<"elevator">>;
     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";
@@ -47,7 +47,7 @@ export declare const ElevatorNode: z.ZodObject<{
             plaster: "plaster";
             tile: "tile";
             marble: "marble";
-        }>>;
+        }>>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
             roughness: z.ZodDefault<z.ZodNumber>;
@@ -67,6 +67,7 @@ export declare const ElevatorNode: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>>;
     materialPreset: z.ZodOptional<z.ZodString>;
+    slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     rotation: z.ZodDefault<z.ZodNumber>;
     width: z.ZodDefault<z.ZodNumber>;

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

@@ -1 +1 @@
-{"version":3,"file":"elevator.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/elevator.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,iBAAiB;;;;EAA4D,CAAA;AAC1F,eAAO,MAAM,sBAAsB;;;;EAA4D,CAAA;AAC/F,eAAO,MAAM,kBAAkB;;;EAA6B,CAAA;AAE5D,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAC3E,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AACjE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAEnE,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgDxB,CAAA;AAED,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA"}
+{"version":3,"file":"elevator.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/elevator.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,iBAAiB;;;;EAA4D,CAAA;AAC1F,eAAO,MAAM,sBAAsB;;;;EAA4D,CAAA;AAC/F,eAAO,MAAM,kBAAkB;;;EAA6B,CAAA;AAE5D,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAA;AAC3E,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AACjE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AAEnE,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmDxB,CAAA;AAED,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA"}

package/dist/schema/nodes/elevator.js

@@ -10,6 +10,9 @@ export const ElevatorNode = BaseNode.extend({
     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),

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

@@ -19,7 +19,7 @@ export declare const EyebrowVentNode: z.ZodObject<{
     type: z.ZodDefault<z.ZodLiteral<"eyebrow-vent">>;
     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";
@@ -30,7 +30,7 @@ export declare const EyebrowVentNode: z.ZodObject<{
             plaster: "plaster";
             tile: "tile";
             marble: "marble";
-        }>>;
+        }>>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
             roughness: z.ZodDefault<z.ZodNumber>;

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,6 +79,12 @@ 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";
@@ -80,6 +95,7 @@ export declare const FenceNode: z.ZodObject<{
         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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA+BrB,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,6 +37,10 @@ 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'),
@@ -27,8 +48,10 @@ export const FenceNode = BaseNode.extend({
 }).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

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

@@ -25,7 +25,7 @@ export declare const GutterNode: z.ZodObject<{
     type: z.ZodDefault<z.ZodLiteral<"gutter">>;
     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";
@@ -36,7 +36,7 @@ export declare const GutterNode: z.ZodObject<{
             plaster: "plaster";
             tile: "tile";
             marble: "marble";
-        }>>;
+        }>>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
             roughness: z.ZodDefault<z.ZodNumber>;

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

@@ -241,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;

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}

package/dist/schema/nodes/item.js

@@ -108,8 +108,19 @@ export const ItemNode = BaseNode.extend({
     // Wall attachment properties (only used when asset.attachTo is "wall" or "wall-side")
     wallId: z.string().optional(),
     wallT: z.number().optional(), // 0-1 parametric position along wall
+    // Alternative wall host: a roof-segment's generated wall face. When
+    // set, `position` is FACE-LOCAL — [u along the face, v = bottom edge,
+    // z from the wall mid-plane] — exactly the wall-child convention
+    // (ItemSystem's wall-side push applies the same way); the renderer
+    // mounts the node inside the face frame (`getRoofWallFaceFrame`).
+    roofSegmentId: z.string().optional(),
+    roofFace: z.enum(['front', 'back', 'right', 'left']).optional(),
     // Denormalized references to collections this node belongs to
     collectionIds: z.array(z.custom()).optional(),
+    // Per-slot material overrides. Key = slot id (see deriveSlotId), value = a
+    // MaterialRef string ('library:<id>' or 'scene:<id>'). Absent = authored /
+    // registry default. A dangling ref renders the default (never blocks).
+    slots: z.record(z.string(), z.string()).optional(),
     asset: assetSchema,
 }).describe(dedent `Item node - used to represent a item in the building
   - position: position in level coordinate system (or parent coordinate system if attached)

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

@@ -17,7 +17,7 @@ export declare const LevelNode: z.ZodObject<{
     metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`level_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"level">>;
-    children: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodDefault<z.ZodTemplateLiteral<`wall_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`fence_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`column_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`item_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`zone_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`slab_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`ceiling_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`roof_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`stair_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`scan_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`guide_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`spawn_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`shelf_${string}`>>]>>>;
+    children: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodDefault<z.ZodTemplateLiteral<`wall_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`fence_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`column_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`item_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`zone_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`slab_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`ceiling_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`roof_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`stair_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`scan_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`guide_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`measurement_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`spawn_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`shelf_${string}`>>]>>>;
     level: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
 export type LevelNode = z.infer<typeof LevelNode>;

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

@@ -1 +1 @@
-{"version":3,"file":"level.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/level.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAgBvB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;iBA8BrB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}
+{"version":3,"file":"level.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/level.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAiBvB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;iBA+BrB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}

package/dist/schema/nodes/level.js

@@ -6,6 +6,7 @@ import { ColumnNode } from './column';
 import { FenceNode } from './fence';
 import { GuideNode } from './guide';
 import { ItemNode } from './item';
+import { MeasurementNode } from './measurement';
 import { RoofNode } from './roof';
 import { ScanNode } from './scan';
 import { ShelfNode } from './shelf';
@@ -30,6 +31,7 @@ export const LevelNode = BaseNode.extend({
         StairNode.shape.id,
         ScanNode.shape.id,
         GuideNode.shape.id,
+        MeasurementNode.shape.id,
         SpawnNode.shape.id,
         ShelfNode.shape.id,
     ]))