@pascal-app/core 0.9.1 → 1.0.0-beta.1

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

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

package/dist/schema/nodes/door.js

@@ -13,6 +13,13 @@ export const DoorSegment = z.object({
     panelInset: z.number().default(0.04),
 });
 export const DoorCategory = z.enum(['interior', 'garage']);
+export const OpeningConstructionType = z.enum(['framed', 'masonry']);
+export const OpeningDimensionReference = z.enum([
+    'nominal',
+    'rough-opening',
+    'masonry-opening',
+    'finish-opening',
+]);
 export const DoorType = z.enum([
     'hinged',
     'double',
@@ -30,13 +37,38 @@ export const DoorNode = BaseNode.extend({
     id: objectId('door'),
     type: nodeType('door'),
     material: MaterialSchema.optional(),
+    // Per-slot material overrides on the unified slot model. Keys: `panel` (the
+    // door body), `glass`. Value = a `MaterialRef` (`library:<id>` / `scene:<id>`).
+    // Absent = the body/glass default. Mirrors `ShelfNode.slots`.
+    slots: z.record(z.string(), z.string()).optional(),
     position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
     rotation: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
     side: z.enum(['front', 'back']).optional(),
     wallId: z.string().optional(),
+    // Alternative host: a roof-segment's generated wall face (base wall
+    // under the roof or a coplanar gable end). When set, `position` is
+    // FACE-LOCAL — [u along the face, v height, z from the wall mid-plane]
+    // — exactly the wall-child convention; the renderer mounts the node
+    // inside the face frame (`getRoofWallFaceFrame`), which is what makes
+    // hosted children track segment resizes live.
+    roofSegmentId: z.string().optional(),
+    roofFace: z.enum(['front', 'back', 'right', 'left']).optional(),
     // Overall dimensions
     width: z.number().default(0.9),
     height: z.number().default(2.1),
+    // Construction-document identity. `mark` overrides the deterministic
+    // level fallback (101, 102, ...). Rough-opening dimensions stay optional
+    // because they are manufacturer/framing inputs, not safe derivations from
+    // the nominal modeled size.
+    mark: z.string().trim().max(16).optional(),
+    constructionType: OpeningConstructionType.default('framed'),
+    dimensionReference: OpeningDimensionReference.default('nominal'),
+    roughOpeningWidth: z.number().positive().optional(),
+    roughOpeningHeight: z.number().positive().optional(),
+    masonryOpeningWidth: z.number().positive().optional(),
+    masonryOpeningHeight: z.number().positive().optional(),
+    finishOpeningWidth: z.number().positive().optional(),
+    finishOpeningHeight: z.number().positive().optional(),
     // Door family
     doorCategory: DoorCategory.default('interior'),
     doorType: DoorType.default('hinged'),

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

@@ -49,7 +49,7 @@ export declare const DormerNode: z.ZodObject<{
     type: z.ZodDefault<z.ZodLiteral<"dormer">>;
     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";
@@ -60,7 +60,7 @@ export declare const DormerNode: z.ZodObject<{
             plaster: "plaster";
             tile: "tile";
             marble: "marble";
-        }>>;
+        }>>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
             roughness: z.ZodDefault<z.ZodNumber>;
@@ -82,7 +82,7 @@ export declare const DormerNode: z.ZodObject<{
     materialPreset: z.ZodOptional<z.ZodString>;
     topMaterial: 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";
@@ -93,7 +93,7 @@ export declare const DormerNode: z.ZodObject<{
             plaster: "plaster";
             tile: "tile";
             marble: "marble";
-        }>>;
+        }>>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
             roughness: z.ZodDefault<z.ZodNumber>;
@@ -115,7 +115,7 @@ export declare const DormerNode: z.ZodObject<{
     topMaterialPreset: z.ZodOptional<z.ZodString>;
     sideMaterial: 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";
@@ -126,7 +126,7 @@ export declare const DormerNode: z.ZodObject<{
             plaster: "plaster";
             tile: "tile";
             marble: "marble";
-        }>>;
+        }>>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
             roughness: z.ZodDefault<z.ZodNumber>;
@@ -148,7 +148,7 @@ export declare const DormerNode: z.ZodObject<{
     sideMaterialPreset: z.ZodOptional<z.ZodString>;
     wallMaterial: 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";
@@ -159,7 +159,7 @@ export declare const DormerNode: 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/dormer.js

@@ -76,7 +76,7 @@ export const DormerNode = BaseNode.extend({
     windowCornerRadii: z
         .tuple([z.number(), z.number(), z.number(), z.number()])
         .default(DEFAULT_CORNER_RADII),
-    windowSill: z.boolean().default(true),
+    windowSill: z.boolean().default(false),
     windowSillDepth: z.number().default(DORMER_DEFAULTS.WINDOW_SILL_DEPTH),
     windowSillThickness: z.number().default(DORMER_DEFAULTS.WINDOW_SILL_THICKNESS),
 }).describe(dedent `

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

@@ -19,7 +19,7 @@ export declare const DownspoutNode: z.ZodObject<{
     type: z.ZodDefault<z.ZodLiteral<"downspout">>;
     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 DownspoutNode: 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/duct-fitting.d.ts

@@ -0,0 +1,91 @@
+import { z } from 'zod';
+/**
+ * Duct fitting — the junction pieces that connect round duct segments:
+ * elbows (direction change), tees (branch takeoff), reducers (diameter
+ * transition).
+ *
+ * Phase 2 of the HVAC node system. Fittings are the first kind to expose
+ * typed ports (`def.ports`) — placement tools snap duct endpoints onto a
+ * fitting's collars, and the future system graph walks ports to decide
+ * connectivity.
+ *
+ * `position` is level-local meters; `rotation` is an XYZ euler in radians
+ * so a fitting can turn a horizontal run vertical (riser elbows).
+ *
+ * Local-frame conventions (before `rotation` is applied):
+ *   - elbow:   inlet faces -X, outlet turned by `angle` degrees in the
+ *              XZ plane (90° → +Z).
+ *   - tee:     run along the X axis (ports face -X and +X), branch
+ *              collar at `branchAngle`° from the +X (outlet) axis in the
+ *              XZ plane — 90° a square straight tee, <90° a lateral
+ *              leaning downstream toward the outlet, >90° leaning upstream
+ *              toward the inlet — sized at `diameter2`.
+ *   - cross:   four-way junction — run along the X axis (ports face -X
+ *              and +X) at the run profile, two opposed branches square to
+ *              the run along ±Z (branch faces +Z, branch2 faces -Z) at the
+ *              branch profile (`shape2` / `diameter2`).
+ *   - reducer: inlet at `diameter` faces -X, outlet at `diameter2`
+ *              faces +X.
+ *   - transition: square-to-round — rect end at `width` × `height` faces
+ *              -X, round end at `diameter2` faces +X. `diameter` carries
+ *              the rect end's area-equivalent round size.
+ */
+export declare const DuctFittingNode: 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-fitting_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"duct-fitting">>;
+    position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    rotation: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    fittingType: z.ZodDefault<z.ZodEnum<{
+        elbow: "elbow";
+        tee: "tee";
+        cross: "cross";
+        reducer: "reducer";
+        transition: "transition";
+    }>>;
+    shape: z.ZodDefault<z.ZodEnum<{
+        round: "round";
+        rect: "rect";
+        oval: "oval";
+    }>>;
+    width: z.ZodDefault<z.ZodNumber>;
+    height: z.ZodDefault<z.ZodNumber>;
+    shape2: z.ZodDefault<z.ZodEnum<{
+        round: "round";
+        rect: "rect";
+        oval: "oval";
+    }>>;
+    width2: z.ZodDefault<z.ZodNumber>;
+    height2: z.ZodDefault<z.ZodNumber>;
+    angle: z.ZodDefault<z.ZodNumber>;
+    branchAngle: z.ZodDefault<z.ZodNumber>;
+    diameter: z.ZodDefault<z.ZodNumber>;
+    diameter2: z.ZodDefault<z.ZodNumber>;
+    ductMaterial: z.ZodDefault<z.ZodEnum<{
+        "sheet-metal": "sheet-metal";
+        flex: "flex";
+        "duct-board": "duct-board";
+    }>>;
+    system: z.ZodDefault<z.ZodEnum<{
+        supply: "supply";
+        return: "return";
+    }>>;
+    slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export type DuctFittingNode = z.infer<typeof DuctFittingNode>;
+export type DuctFittingNodeId = DuctFittingNode['id'];
+//# sourceMappingURL=duct-fitting.d.ts.map

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

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

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

@@ -0,0 +1,92 @@
+import dedent from 'dedent';
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base';
+/**
+ * Duct fitting — the junction pieces that connect round duct segments:
+ * elbows (direction change), tees (branch takeoff), reducers (diameter
+ * transition).
+ *
+ * Phase 2 of the HVAC node system. Fittings are the first kind to expose
+ * typed ports (`def.ports`) — placement tools snap duct endpoints onto a
+ * fitting's collars, and the future system graph walks ports to decide
+ * connectivity.
+ *
+ * `position` is level-local meters; `rotation` is an XYZ euler in radians
+ * so a fitting can turn a horizontal run vertical (riser elbows).
+ *
+ * Local-frame conventions (before `rotation` is applied):
+ *   - elbow:   inlet faces -X, outlet turned by `angle` degrees in the
+ *              XZ plane (90° → +Z).
+ *   - tee:     run along the X axis (ports face -X and +X), branch
+ *              collar at `branchAngle`° from the +X (outlet) axis in the
+ *              XZ plane — 90° a square straight tee, <90° a lateral
+ *              leaning downstream toward the outlet, >90° leaning upstream
+ *              toward the inlet — sized at `diameter2`.
+ *   - cross:   four-way junction — run along the X axis (ports face -X
+ *              and +X) at the run profile, two opposed branches square to
+ *              the run along ±Z (branch faces +Z, branch2 faces -Z) at the
+ *              branch profile (`shape2` / `diameter2`).
+ *   - reducer: inlet at `diameter` faces -X, outlet at `diameter2`
+ *              faces +X.
+ *   - transition: square-to-round — rect end at `width` × `height` faces
+ *              -X, round end at `diameter2` faces +X. `diameter` carries
+ *              the rect end's area-equivalent round size.
+ */
+export const DuctFittingNode = BaseNode.extend({
+    id: objectId('duct-fitting'),
+    type: nodeType('duct-fitting'),
+    // Level-local meters.
+    position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
+    // XYZ euler radians.
+    rotation: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
+    fittingType: z.enum(['elbow', 'tee', 'cross', 'reducer', 'transition']).default('elbow'),
+    // Run-leg cross-section: round collars, or a rect / flat-oval profile
+    // matching the trunk the fitting sits in. Reducers ignore the shape.
+    // When non-round, `diameter` carries the area-equivalent round size
+    // (drives leg lengths + advertised ports).
+    shape: z.enum(['round', 'rect', 'oval']).default('rect'),
+    // Rect / oval run-leg profile in inches (used when shape ≠ 'round').
+    width: z.number().min(4).max(60).default(14),
+    height: z.number().min(3).max(40).default(8),
+    // Tee / cross BRANCH cross-section: a round collar at `diameter2` or a
+    // rect / oval profile matching the duct drawn off the tap. When
+    // non-round, `diameter2` carries the branch's area-equivalent round
+    // size. A cross's two opposed branches share this one profile.
+    shape2: z.enum(['round', 'rect', 'oval']).default('rect'),
+    // Rect / oval branch profile in inches (used when shape2 ≠ 'round').
+    width2: z.number().min(4).max(60).default(14),
+    height2: z.number().min(3).max(40).default(8),
+    // Elbow turn angle in degrees. Residential sheet-metal elbows come in
+    // 90° and 45°; adjustable elbows cover the range between. 0° is a
+    // straight coupling — what an elbow flattens to when its run is dragged
+    // into line with the fixed collar.
+    angle: z.number().min(0).max(90).default(90),
+    // Tee branch angle in degrees, measured off the +X (outlet) axis: 90°
+    // is a square straight tee, <90° a lateral whose branch sweeps
+    // downstream toward the outlet (flow merges), >90° leans the branch
+    // upstream toward the inlet. Ignored by every other fitting type.
+    branchAngle: z.number().min(45).max(135).default(90),
+    // Main (run/inlet) nominal diameter in inches.
+    diameter: z.number().min(2).max(48).default(6),
+    // Secondary diameter in inches — tee branch collar, reducer outlet.
+    // Ignored by elbows.
+    diameter2: z.number().min(2).max(48).default(6),
+    ductMaterial: z.enum(['sheet-metal', 'flex', 'duct-board']).default('sheet-metal'),
+    system: z.enum(['supply', 'return']).default('supply'),
+    slots: z.record(z.string(), z.string()).optional(),
+}).describe(dedent `
+  Duct fitting - elbow, tee, cross, reducer, or square-to-round transition between duct runs.
+  - position: [x, y, z] level-local meters
+  - rotation: [x, y, z] euler radians
+  - fittingType: elbow | tee | cross | reducer | transition (rect end -X, round end +X)
+  - shape: round | rect | oval run legs (matches the trunk; ignored by reducer / transition)
+  - width / height: rect / oval run-leg profile in inches (transition: the rect end)
+  - shape2: round | rect | oval tee / cross branch (matches the duct drawn off the tap)
+  - width2 / height2: rect / oval branch profile in inches
+  - angle: elbow turn in degrees (45 or 90 typical)
+  - branchAngle: tee branch angle off the outlet axis (90 straight tee, 45 downstream lateral, 135 upstream); cross branches are always square
+  - diameter: main nominal diameter in inches
+  - diameter2: tee / cross branch / reducer outlet / transition round-end diameter in inches
+  - ductMaterial: sheet-metal | flex | duct-board
+  - system: supply | return
+  `);

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

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+/**
+ * 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 declare const DuctSegmentNode: 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-segment_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"duct-segment">>;
+    path: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    shape: z.ZodDefault<z.ZodEnum<{
+        round: "round";
+        rect: "rect";
+        oval: "oval";
+    }>>;
+    diameter: z.ZodDefault<z.ZodNumber>;
+    width: z.ZodDefault<z.ZodNumber>;
+    height: z.ZodDefault<z.ZodNumber>;
+    roll: z.ZodDefault<z.ZodNumber>;
+    ductMaterial: z.ZodDefault<z.ZodEnum<{
+        spiral: "spiral";
+        "sheet-metal": "sheet-metal";
+        flex: "flex";
+        "duct-board": "duct-board";
+    }>>;
+    seamDetail: z.ZodDefault<z.ZodBoolean>;
+    insulated: z.ZodDefault<z.ZodBoolean>;
+    insulationR: z.ZodDefault<z.ZodNumber>;
+    system: z.ZodDefault<z.ZodEnum<{
+        supply: "supply";
+        return: "return";
+    }>>;
+    slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export type DuctSegmentNode = z.infer<typeof DuctSegmentNode>;
+export type DuctSegmentNodeId = DuctSegmentNode['id'];
+//# sourceMappingURL=duct-segment.d.ts.map

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

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

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,58 @@
+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>;
+    supportSlabId: z.ZodOptional<z.ZodString>;
+    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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuC5B,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,53 @@
+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),
+    // Persisted slab-support host — see ItemNode.supportSlabId for the rules.
+    supportSlabId: z.string().optional(),
+    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),