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

package/dist/schema/nodes/imported-mesh.d.ts

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+export declare const ImportedMeshPrimitive: z.ZodObject<{
+    positions: z.ZodArray<z.ZodNumber>;
+    normals: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+    indices: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+    color: z.ZodDefault<z.ZodString>;
+    opacity: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type ImportedMeshPrimitive = z.infer<typeof ImportedMeshPrimitive>;
+/** Triangle geometry retained when an import has no native Pascal shape. */
+export declare const ImportedMeshNode: 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.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    id: z.ZodDefault<z.ZodTemplateLiteral<`imesh_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"imported-mesh">>;
+    position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    rotation: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    primitives: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        positions: z.ZodArray<z.ZodNumber>;
+        normals: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        indices: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+        color: z.ZodDefault<z.ZodString>;
+        opacity: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type ImportedMeshNode = z.infer<typeof ImportedMeshNode>;
+//# sourceMappingURL=imported-mesh.d.ts.map

package/dist/schema/nodes/imported-mesh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"imported-mesh.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/imported-mesh.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAQvB,eAAO,MAAM,qBAAqB;;;;;;iBAMhC,CAAA;AAEF,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEzE,4EAA4E;AAC5E,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAa5B,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA"}

package/dist/schema/nodes/imported-mesh.js

@@ -0,0 +1,27 @@
+import dedent from 'dedent';
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base.js';
+const finiteNumber = z.number().finite();
+const vector3Array = z
+    .array(finiteNumber)
+    .refine((values) => values.length % 3 === 0, 'Expected XYZ triples');
+export const ImportedMeshPrimitive = z.object({
+    positions: vector3Array,
+    normals: vector3Array.optional(),
+    indices: z.array(z.number().int().nonnegative()).default([]),
+    color: z.string().default('#94a3b8'),
+    opacity: z.number().min(0).max(1).default(1),
+});
+/** Triangle geometry retained when an import has no native Pascal shape. */
+export const ImportedMeshNode = BaseNode.extend({
+    id: objectId('imesh'),
+    type: nodeType('imported-mesh'),
+    position: z.tuple([finiteNumber, finiteNumber, finiteNumber]).default([0, 0, 0]),
+    rotation: z.tuple([finiteNumber, finiteNumber, finiteNumber]).default([0, 0, 0]),
+    primitives: z.array(ImportedMeshPrimitive).default([]),
+}).describe(dedent `
+  Imported mesh node - triangle geometry preserved from an external model
+  - position / rotation: transform in the parent coordinate system
+  - primitives: indexed triangle buffers in meters with source display colors
+  - metadata: source-format identity and properties
+  `);

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

@@ -228,7 +228,7 @@ export declare const ItemNode: z.ZodObject<{
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
-    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`item_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"item">>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
@@ -238,7 +238,7 @@ export declare const ItemNode: z.ZodObject<{
         front: "front";
         back: "back";
     }>>;
-    children: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodTemplateLiteral<`item_${string}`>>>>;
+    children: z.ZodDefault<z.ZodArray<z.ZodString>>;
     wallId: z.ZodOptional<z.ZodString>;
     wallT: z.ZodOptional<z.ZodNumber>;
     roofSegmentId: z.ZodOptional<z.ZodString>;
@@ -248,6 +248,7 @@ export declare const ItemNode: z.ZodObject<{
         right: "right";
         left: "left";
     }>>;
+    blockFaceId: z.ZodOptional<z.ZodString>;
     supportSlabId: z.ZodOptional<z.ZodString>;
     collectionIds: z.ZodOptional<z.ZodArray<z.ZodCustom<`collection_${string}`, `collection_${string}`>>>;
     slots: z.ZodOptional<z.ZodRecord<z.ZodString, 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuDnB,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4DnB,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

@@ -1,7 +1,7 @@
 import dedent from 'dedent';
 import { z } from 'zod';
-import { AssetUrl } from '../asset-url';
-import { BaseNode, nodeType, objectId } from '../base';
+import { AssetUrl } from '../asset-url.js';
+import { BaseNode, nodeType, objectId } from '../base.js';
 // --- Control descriptors ---
 const toggleControlSchema = z.object({
     kind: z.literal('toggle'),
@@ -104,7 +104,7 @@ export const ItemNode = BaseNode.extend({
     rotation: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
     scale: z.tuple([z.number(), z.number(), z.number()]).default([1, 1, 1]),
     side: z.enum(['front', 'back']).optional(),
-    children: z.array(objectId('item')).default([]),
+    children: z.array(z.string()).default([]),
     // 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
@@ -115,6 +115,11 @@ export const ItemNode = BaseNode.extend({
     // mounts the node inside the face frame (`getRoofWallFaceFrame`).
     roofSegmentId: z.string().optional(),
     roofFace: z.enum(['front', 'back', 'right', 'left']).optional(),
+    // Alternative wall-like host: a planar block face. Position is
+    // FACE-LOCAL [u, v, normal offset], relative to the live face centroid.
+    // The renderer rebuilds the frame from the face normal so the item follows
+    // later edits that translate or slope the face.
+    blockFaceId: z.string().optional(),
     // Persisted floor-support host (canonical doc — the same field on other
     // floor-placed kinds and walls follows these rules). Written at
     // placement/commit ONLY when overlapping slabs disagree on elevation

package/dist/schema/nodes/lean-to-extension.d.ts

@@ -0,0 +1,212 @@
+import { z } from 'zod';
+export declare const LeanToConnectionMode: z.ZodEnum<{
+    manual: "manual";
+    auto: "auto";
+}>;
+export declare const LeanToCanopyForm: z.ZodEnum<{
+    gable: "gable";
+    mono: "mono";
+    butterfly: "butterfly";
+}>;
+export declare const LeanToHostKind: z.ZodEnum<{
+    wall: "wall";
+    "slab-edge": "slab-edge";
+    freestanding: "freestanding";
+    "conical-roof": "conical-roof";
+}>;
+export declare const LeanToRoofEdge: z.ZodEnum<{
+    "+X": "+X";
+    "-X": "-X";
+    "+Z": "+Z";
+    "-Z": "-Z";
+}>;
+export declare const LeanToResizeLock: z.ZodEnum<{
+    "preserve-high-edge": "preserve-high-edge";
+    "preserve-low-edge": "preserve-low-edge";
+    "preserve-pitch": "preserve-pitch";
+}>;
+export declare const LeanToEndCondition: z.ZodEnum<{
+    open: "open";
+    "wall-abutment": "wall-abutment";
+    joined: "joined";
+}>;
+export declare const LeanToFramingStrategy: z.ZodEnum<{
+    hidden: "hidden";
+    rafters: "rafters";
+    purlins: "purlins";
+    "covering-specific": "covering-specific";
+}>;
+export declare const LeanToHighSideMode: z.ZodEnum<{
+    "wall-ledger": "wall-ledger";
+    "independent-high-beam": "independent-high-beam";
+}>;
+export declare const LeanToPostLayoutMode: z.ZodEnum<{
+    count: "count";
+    "target-spacing": "target-spacing";
+}>;
+export declare const LeanToFootingStyle: z.ZodEnum<{
+    none: "none";
+    "base-plate": "base-plate";
+    "concrete-pad": "concrete-pad";
+}>;
+export declare const LeanToCoveringType: z.ZodEnum<{
+    generic: "generic";
+    shingle: "shingle";
+    "metal-panel": "metal-panel";
+}>;
+export type LeanToConnectionMode = z.infer<typeof LeanToConnectionMode>;
+export type LeanToCanopyForm = z.infer<typeof LeanToCanopyForm>;
+export type LeanToRoofEdge = z.infer<typeof LeanToRoofEdge>;
+export declare const LeanToExtensionNode: 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.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    id: z.ZodDefault<z.ZodTemplateLiteral<`leanto_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"lean-to-extension">>;
+    position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    rotation: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    children: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodDefault<z.ZodTemplateLiteral<`column_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`roof_${string}`>>]>>>;
+    canopyForm: z.ZodDefault<z.ZodEnum<{
+        gable: "gable";
+        mono: "mono";
+        butterfly: "butterfly";
+    }>>;
+    hostKind: z.ZodDefault<z.ZodEnum<{
+        wall: "wall";
+        "slab-edge": "slab-edge";
+        freestanding: "freestanding";
+        "conical-roof": "conical-roof";
+    }>>;
+    hostHeightOffset: z.ZodDefault<z.ZodNumber>;
+    hostSlabId: z.ZodOptional<z.ZodDefault<z.ZodTemplateLiteral<`slab_${string}`>>>;
+    hostSlabEdgeIndex: z.ZodOptional<z.ZodNumber>;
+    hostSlabEdgeT: z.ZodOptional<z.ZodNumber>;
+    span: z.ZodDefault<z.ZodNumber>;
+    autoSpan: z.ZodDefault<z.ZodBoolean>;
+    projection: z.ZodDefault<z.ZodNumber>;
+    spanArcCenterZ: z.ZodOptional<z.ZodNumber>;
+    spanArcRadius: z.ZodOptional<z.ZodNumber>;
+    highEdgeHeight: z.ZodDefault<z.ZodNumber>;
+    lowEdgeHeight: z.ZodDefault<z.ZodNumber>;
+    pitch: z.ZodDefault<z.ZodNumber>;
+    resizeLock: z.ZodDefault<z.ZodEnum<{
+        "preserve-high-edge": "preserve-high-edge";
+        "preserve-low-edge": "preserve-low-edge";
+        "preserve-pitch": "preserve-pitch";
+    }>>;
+    leftEndCondition: z.ZodDefault<z.ZodEnum<{
+        open: "open";
+        "wall-abutment": "wall-abutment";
+        joined: "joined";
+    }>>;
+    rightEndCondition: z.ZodDefault<z.ZodEnum<{
+        open: "open";
+        "wall-abutment": "wall-abutment";
+        joined: "joined";
+    }>>;
+    autoMiterCorners: z.ZodDefault<z.ZodBoolean>;
+    sideFlashing: z.ZodDefault<z.ZodBoolean>;
+    flashingProjection: z.ZodDefault<z.ZodNumber>;
+    flashingHeight: z.ZodDefault<z.ZodNumber>;
+    slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    highSideMode: z.ZodDefault<z.ZodEnum<{
+        "wall-ledger": "wall-ledger";
+        "independent-high-beam": "independent-high-beam";
+    }>>;
+    ledgerVerticalOffset: z.ZodDefault<z.ZodNumber>;
+    lowBeamInset: z.ZodDefault<z.ZodNumber>;
+    gutterEnabled: z.ZodDefault<z.ZodBoolean>;
+    gutterProfile: z.ZodDefault<z.ZodEnum<{
+        box: "box";
+        "k-style": "k-style";
+        "half-round": "half-round";
+    }>>;
+    gutterSize: z.ZodDefault<z.ZodNumber>;
+    downspoutEnabled: z.ZodDefault<z.ZodBoolean>;
+    downspoutPosition: z.ZodDefault<z.ZodNumber>;
+    connectionMode: z.ZodDefault<z.ZodEnum<{
+        manual: "manual";
+        auto: "auto";
+    }>>;
+    hostRoofId: z.ZodOptional<z.ZodDefault<z.ZodTemplateLiteral<`roof_${string}`>>>;
+    hostRoofSegmentId: z.ZodOptional<z.ZodString>;
+    hostRoofEdge: z.ZodOptional<z.ZodEnum<{
+        "+X": "+X";
+        "-X": "-X";
+        "+Z": "+Z";
+        "-Z": "-Z";
+    }>>;
+    hostRoofEdgeRange: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    connectionOffset: z.ZodDefault<z.ZodNumber>;
+    connectionInset: z.ZodDefault<z.ZodNumber>;
+    matchHostRoofMaterial: z.ZodDefault<z.ZodBoolean>;
+    matchHostRoofStructure: z.ZodDefault<z.ZodBoolean>;
+    roofThickness: z.ZodDefault<z.ZodNumber>;
+    shingleThickness: z.ZodDefault<z.ZodNumber>;
+    highOverhang: z.ZodDefault<z.ZodNumber>;
+    lowOverhang: z.ZodDefault<z.ZodNumber>;
+    leftOverhang: z.ZodDefault<z.ZodNumber>;
+    rightOverhang: z.ZodDefault<z.ZodNumber>;
+    coveringType: z.ZodDefault<z.ZodEnum<{
+        generic: "generic";
+        shingle: "shingle";
+        "metal-panel": "metal-panel";
+    }>>;
+    beamWidth: z.ZodDefault<z.ZodNumber>;
+    beamHeight: z.ZodDefault<z.ZodNumber>;
+    ledgerDepth: z.ZodDefault<z.ZodNumber>;
+    ledgerHeight: z.ZodDefault<z.ZodNumber>;
+    rafterWidth: z.ZodDefault<z.ZodNumber>;
+    rafterHeight: z.ZodDefault<z.ZodNumber>;
+    rafterSpacing: z.ZodDefault<z.ZodNumber>;
+    rafterEndInset: z.ZodDefault<z.ZodNumber>;
+    framingStrategy: z.ZodDefault<z.ZodEnum<{
+        hidden: "hidden";
+        rafters: "rafters";
+        purlins: "purlins";
+        "covering-specific": "covering-specific";
+    }>>;
+    purlinWidth: z.ZodDefault<z.ZodNumber>;
+    purlinHeight: z.ZodDefault<z.ZodNumber>;
+    purlinSpacing: z.ZodDefault<z.ZodNumber>;
+    postWidth: z.ZodDefault<z.ZodNumber>;
+    postDepth: z.ZodDefault<z.ZodNumber>;
+    postCount: z.ZodDefault<z.ZodNumber>;
+    postLayoutMode: z.ZodDefault<z.ZodEnum<{
+        count: "count";
+        "target-spacing": "target-spacing";
+    }>>;
+    postSpacing: z.ZodDefault<z.ZodNumber>;
+    postInset: z.ZodDefault<z.ZodNumber>;
+    omittedPostSlots: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        side: z.ZodEnum<{
+            low: "low";
+            high: "high";
+        }>;
+        index: z.ZodNumber;
+        layoutCount: z.ZodNumber;
+    }, z.core.$strip>>>;
+    postBracing: z.ZodDefault<z.ZodEnum<{
+        none: "none";
+        knee: "knee";
+    }>>;
+    footingStyle: z.ZodDefault<z.ZodEnum<{
+        none: "none";
+        "base-plate": "base-plate";
+        "concrete-pad": "concrete-pad";
+    }>>;
+}, z.core.$strip>;
+export type LeanToExtensionNode = z.infer<typeof LeanToExtensionNode>;
+//# sourceMappingURL=lean-to-extension.d.ts.map

package/dist/schema/nodes/lean-to-extension.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lean-to-extension.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/lean-to-extension.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB,eAAO,MAAM,oBAAoB;;;EAA6B,CAAA;AAC9D,eAAO,MAAM,gBAAgB;;;;EAAyC,CAAA;AACtE,eAAO,MAAM,cAAc;;;;;EAAgE,CAAA;AAC3F,eAAO,MAAM,cAAc;;;;;EAAmC,CAAA;AAC9D,eAAO,MAAM,gBAAgB;;;;EAI3B,CAAA;AACF,eAAO,MAAM,kBAAkB;;;;EAA8C,CAAA;AAC7E,eAAO,MAAM,qBAAqB;;;;;EAAgE,CAAA;AAClG,eAAO,MAAM,kBAAkB;;;EAAmD,CAAA;AAClF,eAAO,MAAM,oBAAoB;;;EAAsC,CAAA;AACvE,eAAO,MAAM,kBAAkB;;;;EAAiD,CAAA;AAChF,eAAO,MAAM,kBAAkB;;;;EAAgD,CAAA;AAQ/E,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AACvE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAC/D,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAE3D,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgG/B,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA"}

package/dist/schema/nodes/lean-to-extension.js

@@ -0,0 +1,114 @@
+import dedent from 'dedent';
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base.js';
+import { ColumnNode } from './column.js';
+import { RoofNode } from './roof.js';
+import { SlabNode } from './slab.js';
+export const LeanToConnectionMode = z.enum(['auto', 'manual']);
+export const LeanToCanopyForm = z.enum(['mono', 'gable', 'butterfly']);
+export const LeanToHostKind = z.enum(['wall', 'slab-edge', 'freestanding', 'conical-roof']);
+export const LeanToRoofEdge = z.enum(['+X', '-X', '+Z', '-Z']);
+export const LeanToResizeLock = z.enum([
+    'preserve-high-edge',
+    'preserve-low-edge',
+    'preserve-pitch',
+]);
+export const LeanToEndCondition = z.enum(['open', 'wall-abutment', 'joined']);
+export const LeanToFramingStrategy = z.enum(['hidden', 'rafters', 'purlins', 'covering-specific']);
+export const LeanToHighSideMode = z.enum(['wall-ledger', 'independent-high-beam']);
+export const LeanToPostLayoutMode = z.enum(['count', 'target-spacing']);
+export const LeanToFootingStyle = z.enum(['none', 'base-plate', 'concrete-pad']);
+export const LeanToCoveringType = z.enum(['generic', 'shingle', 'metal-panel']);
+const LeanToOmittedPostSlot = z.object({
+    side: z.enum(['low', 'high']),
+    index: z.number().int(),
+    layoutCount: z.number().int().min(1),
+});
+const DEFAULT_LOW_EDGE_HEIGHT = 2.7 - 3 * Math.tan((5 * Math.PI) / 180);
+const DEFAULT_LEAN_TO_POST_SPACING = 3;
+export const LeanToExtensionNode = BaseNode.extend({
+    id: objectId('leanto'),
+    type: nodeType('lean-to-extension'),
+    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]),
+    children: z.array(z.union([ColumnNode.shape.id, RoofNode.shape.id])).default([]),
+    canopyForm: LeanToCanopyForm.default('mono'),
+    hostKind: LeanToHostKind.default('wall'),
+    hostHeightOffset: z.number().min(-10).max(10).default(0),
+    hostSlabId: SlabNode.shape.id.optional(),
+    hostSlabEdgeIndex: z.number().int().min(0).optional(),
+    hostSlabEdgeT: z.number().min(0).max(1).optional(),
+    span: z.number().min(0.5).max(100).default(4),
+    autoSpan: z.boolean().default(true),
+    projection: z.number().min(0.5).max(10).default(2.5),
+    spanArcCenterZ: z
+        .number()
+        .optional()
+        .describe('Local-Z of the host wall arc center in the lean-to local frame (the crown sits on the local Z axis, so center X = 0). Derived from the host wall arc; absent for straight walls.'),
+    spanArcRadius: z
+        .number()
+        .optional()
+        .describe("The host wall's true arc radius, in metres. Derived from the host wall arc; absent for straight walls."),
+    highEdgeHeight: z.number().min(0.8).max(10).default(2.8),
+    lowEdgeHeight: z.number().min(0.2).max(10).default(DEFAULT_LOW_EDGE_HEIGHT),
+    pitch: z.number().min(1).max(45).default(10),
+    resizeLock: LeanToResizeLock.default('preserve-high-edge'),
+    leftEndCondition: LeanToEndCondition.default('open'),
+    rightEndCondition: LeanToEndCondition.default('open'),
+    autoMiterCorners: z.boolean().default(true),
+    sideFlashing: z.boolean().default(true),
+    flashingProjection: z.number().min(0.01).max(0.5).default(0.025),
+    flashingHeight: z.number().min(0.03).max(0.5).default(0.14),
+    slots: z.record(z.string(), z.string()).optional(),
+    highSideMode: LeanToHighSideMode.default('wall-ledger'),
+    ledgerVerticalOffset: z.number().min(-1).max(1).default(0),
+    lowBeamInset: z.number().min(0).max(2).default(0),
+    gutterEnabled: z.boolean().default(true),
+    gutterProfile: z.enum(['k-style', 'half-round', 'box']).default('k-style'),
+    gutterSize: z.number().min(0.04).max(0.3).default(0.13),
+    downspoutEnabled: z.boolean().default(true),
+    downspoutPosition: z.number().min(-1).max(1).default(1),
+    connectionMode: LeanToConnectionMode.default('auto'),
+    hostRoofId: RoofNode.shape.id.optional(),
+    hostRoofSegmentId: z.string().optional(),
+    hostRoofEdge: LeanToRoofEdge.optional(),
+    hostRoofEdgeRange: z.tuple([z.number().min(0).max(1), z.number().min(0).max(1)]).optional(),
+    connectionOffset: z.number().min(-1).max(1).default(0),
+    connectionInset: z.number().min(0).max(10).default(0),
+    matchHostRoofMaterial: z.boolean().default(true),
+    matchHostRoofStructure: z.boolean().default(true),
+    roofThickness: z.number().min(0.02).max(0.5).default(0.1),
+    shingleThickness: z.number().min(0).max(0.5).default(0.025),
+    highOverhang: z.number().min(0).max(1.5).default(0),
+    lowOverhang: z.number().min(0).max(1.5).default(0.25),
+    leftOverhang: z.number().min(0).max(1.5).default(0.15),
+    rightOverhang: z.number().min(0).max(1.5).default(0.15),
+    coveringType: LeanToCoveringType.default('generic'),
+    beamWidth: z.number().min(0.05).max(0.6).default(0.16),
+    beamHeight: z.number().min(0.05).max(0.8).default(0.24),
+    ledgerDepth: z.number().min(0.03).max(0.5).default(0.1),
+    ledgerHeight: z.number().min(0.05).max(0.8).default(0.18),
+    rafterWidth: z.number().min(0.03).max(0.4).default(0.08),
+    rafterHeight: z.number().min(0.03).max(0.5).default(0.14),
+    rafterSpacing: z.number().min(0.2).max(3).default(1.2),
+    rafterEndInset: z.number().min(0).max(3).default(0),
+    framingStrategy: LeanToFramingStrategy.default('rafters'),
+    purlinWidth: z.number().min(0.03).max(0.4).default(0.08),
+    purlinHeight: z.number().min(0.03).max(0.5).default(0.1),
+    purlinSpacing: z.number().min(0.2).max(3).default(0.8),
+    postWidth: z.number().min(0.05).max(0.6).default(0.16),
+    postDepth: z.number().min(0.05).max(0.6).default(0.16),
+    postCount: z.number().int().min(2).max(20).default(3),
+    postLayoutMode: LeanToPostLayoutMode.default('target-spacing'),
+    postSpacing: z.number().min(0.3).max(10).default(DEFAULT_LEAN_TO_POST_SPACING),
+    postInset: z.number().min(0).max(3).default(0),
+    omittedPostSlots: z.array(LeanToOmittedPostSlot).default([]),
+    postBracing: z.enum(['none', 'knee']).default('none'),
+    footingStyle: LeanToFootingStyle.default('none'),
+}).describe(dedent `
+  Open parametric canopy.
+  The high edge can attach to a wall, attach to an upper slab edge, stand on an independent
+  high beam, or wrap around a conical roof's cylindrical base. Attached canopies use a mono-pitch
+  roof. Freestanding canopies can use a mono-pitch, gable, or butterfly roof with managed columns,
+  framing, gutters, and downspouts.
+  `);

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

@@ -16,10 +16,10 @@ export declare const LevelNode: z.ZodObject<{
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
-    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`level_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"level">>;
-    children: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`item_${string}` | `ceiling_${string}` | `column_${string}` | `wall_${string}` | `fence_${string}` | `construction-dimension_${string}` | `structural-grid_${string}` | `zone_${string}` | `slab_${string}` | `roof_${string}` | `stair_${string}` | `scan_${string}` | `guide_${string}` | `measurement_${string}` | `spawn_${string}` | `shelf_${string}` | `duct-segment_${string}` | `duct-fitting_${string}` | `duct-terminal_${string}` | `hvac-equipment_${string}` | `lineset_${string}` | `liquid-line_${string}` | `pipe-segment_${string}` | `pipe-fitting_${string}` | `pipe-trap_${string}`, string>>>>;
+    children: z.ZodDefault<z.ZodArray<z.ZodPipe<z.ZodString, z.ZodTransform<`block_${string}` | `ceiling_${string}` | `item_${string}` | `procedural-item_${string}` | `column_${string}` | `construction-dimension_${string}` | `wall_${string}` | `roof_${string}` | `slab_${string}` | `fence_${string}` | `structural-grid_${string}` | `imesh_${string}` | `zone_${string}` | `stair_${string}` | `scan_${string}` | `guide_${string}` | `measurement_${string}` | `spawn_${string}` | `shelf_${string}` | `duct-segment_${string}` | `duct-fitting_${string}` | `duct-terminal_${string}` | `hvac-equipment_${string}` | `lineset_${string}` | `liquid-line_${string}` | `pipe-segment_${string}` | `pipe-fitting_${string}` | `pipe-trap_${string}`, string>>>>;
     level: z.ZodDefault<z.ZodNumber>;
     baseElevation: z.ZodDefault<z.ZodNumber>;
     height: z.ZodOptional<z.ZodNumber>;

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;AAyDvB,eAAO,MAAM,4BAA4B,IAAI,CAAA;AAE7C,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAElE;AAED,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;iBA0BrB,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;AA+DvB,eAAO,MAAM,4BAA4B,IAAI,CAAA;AAE7C,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAElE;AAED,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;iBA0BrB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}

package/dist/schema/nodes/level.js

@@ -1,6 +1,6 @@
 import dedent from 'dedent';
 import { z } from 'zod';
-import { BaseNode, nodeType, objectId } from '../base';
+import { BaseNode, nodeType, objectId } from '../base.js';
 const LevelChildId = z.string().transform((id) => id);
 export const DEFAULT_LEVEL_BASE_ELEVATION = 0;
 export function normalizeLevelBaseElevation(value) {

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

@@ -29,7 +29,7 @@ export declare const LinesetNode: z.ZodObject<{
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
-    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`lineset_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"lineset">>;
     path: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;

package/dist/schema/nodes/lineset.js

@@ -1,6 +1,6 @@
 import dedent from 'dedent';
 import { z } from 'zod';
-import { BaseNode, nodeType, objectId } from '../base';
+import { BaseNode, nodeType, objectId } from '../base.js';
 /**
  * Refrigerant lineset — the copper pipe pair that links the outdoor
  * condenser to the indoor coil (furnace / air handler) of a split system.

package/dist/schema/nodes/liquid-line.d.ts

@@ -23,7 +23,7 @@ export declare const LiquidLineNode: z.ZodObject<{
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
-    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`liquid-line_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"liquid-line">>;
     path: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;

package/dist/schema/nodes/liquid-line.js

@@ -1,6 +1,6 @@
 import dedent from 'dedent';
 import { z } from 'zod';
-import { BaseNode, nodeType, objectId } from '../base';
+import { BaseNode, nodeType, objectId } from '../base.js';
 /**
  * Standalone refrigerant liquid line — the thin bare-copper line that carries
  * warm liquid out to the indoor coil. It is the line that used to be drawn as

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

@@ -206,7 +206,7 @@ export declare const MeasurementNode: z.ZodObject<{
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
-    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`measurement_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"measurement">>;
     measurement: z.ZodDiscriminatedUnion<[z.ZodObject<{

package/dist/schema/nodes/measurement.js

@@ -1,7 +1,7 @@
 import dedent from 'dedent';
 import { z } from 'zod';
-import { areMeasurementPointsCoplanar, MEASUREMENT_PLANAR_TOLERANCE, measurementNormal, } from '../../lib/measurement-geometry';
-import { BaseNode, nodeType, objectId } from '../base';
+import { areMeasurementPointsCoplanar, MEASUREMENT_PLANAR_TOLERANCE, measurementNormal, } from '../../lib/measurement-geometry.js';
+import { BaseNode, nodeType, objectId } from '../base.js';
 const FiniteCoordinate = z.number().finite();
 export const MeasurementPoint = z.tuple([FiniteCoordinate, FiniteCoordinate, FiniteCoordinate]);
 export const MeasurementFeatureParameter = z.union([z.string(), z.boolean(), FiniteCoordinate]);

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

@@ -27,7 +27,7 @@ export declare const PipeFittingNode: z.ZodObject<{
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
-    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`pipe-fitting_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"pipe-fitting">>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
@@ -35,15 +35,23 @@ export declare const PipeFittingNode: z.ZodObject<{
     fittingType: z.ZodDefault<z.ZodEnum<{
         elbow: "elbow";
         cross: "cross";
+        reducer: "reducer";
+        "end-cap": "end-cap";
+        coupling: "coupling";
         wye: "wye";
         "sanitary-tee": "sanitary-tee";
+        cleanout: "cleanout";
     }>>;
     angle: z.ZodDefault<z.ZodNumber>;
     diameter: z.ZodDefault<z.ZodNumber>;
     diameter2: z.ZodDefault<z.ZodNumber>;
+    cleanoutStyle: z.ZodDefault<z.ZodEnum<{
+        end: "end";
+        inline: "inline";
+    }>>;
     pipeMaterial: z.ZodDefault<z.ZodEnum<{
-        pvc: "pvc";
         abs: "abs";
+        pvc: "pvc";
         "cast-iron": "cast-iron";
     }>>;
     system: z.ZodDefault<z.ZodEnum<{

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

@@ -1 +1 @@
-{"version":3,"file":"pipe-fitting.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/pipe-fitting.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8B3B,CAAA;AACD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAA;AAC7D,MAAM,MAAM,iBAAiB,GAAG,eAAe,CAAC,IAAI,CAAC,CAAA"}
+{"version":3,"file":"pipe-fitting.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/pipe-fitting.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAkC3B,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/pipe-fitting.js

@@ -1,6 +1,6 @@
 import dedent from 'dedent';
 import { z } from 'zod';
-import { BaseNode, nodeType, objectId } from '../base';
+import { BaseNode, nodeType, objectId } from '../base.js';
 /**
  * DWV pipe fitting — the joints drain systems are actually built from:
  * elbows (bends), wyes (45° branch entries, the code-preferred way to
@@ -21,7 +21,9 @@ export const PipeFittingNode = BaseNode.extend({
     position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
     // XYZ euler radians.
     rotation: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
-    fittingType: z.enum(['elbow', 'wye', 'sanitary-tee', 'cross']).default('elbow'),
+    fittingType: z
+        .enum(['elbow', 'wye', 'sanitary-tee', 'cross', 'end-cap', 'cleanout', 'reducer', 'coupling'])
+        .default('elbow'),
     // Elbow turn in degrees — DWV bends ship as 22.5 / 45 / 90 ("long
     // sweep" for drains); adjustable range matches the duct elbow. 0° is a
     // straight coupling — what an elbow flattens to when its run is dragged
@@ -31,13 +33,15 @@ export const PipeFittingNode = BaseNode.extend({
     diameter: z.number().min(1.25).max(8).default(2),
     // Branch collar size (wye / sanitary-tee).
     diameter2: z.number().min(1.25).max(8).default(2),
+    cleanoutStyle: z.enum(['end', 'inline']).default('end'),
     pipeMaterial: z.enum(['pvc', 'abs', 'cast-iron']).default('pvc'),
     system: z.enum(['waste', 'vent']).default('waste'),
 }).describe(dedent `
   DWV pipe fitting - elbow (bend), wye (45° branch), sanitary tee (square branch), or cross (two opposed branches).
   - position: [x, y, z] level-local meters
   - rotation: [x, y, z] euler radians
-  - fittingType: elbow | wye | sanitary-tee | cross
+  - fittingType: elbow | wye | sanitary-tee | cross | end-cap | cleanout | reducer | coupling
+  - cleanoutStyle: end (one flow port) or inline (two flow ports with a capped service branch)
   - angle: elbow turn in degrees (22.5 / 45 / 90 typical)
   - diameter: run size in inches; diameter2: branch collar size (both branches for a cross)
   - pipeMaterial: pvc | abs | cast-iron