@pascal-app/core 1.0.3 → 1.0.5

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

@@ -6,8 +6,8 @@ export declare const ElevatorDoorStyle: z.ZodEnum<{
 }>;
 export declare const ElevatorDoorPanelStyle: z.ZodEnum<{
     "glass-frame": "glass-frame";
-    "solid-panel": "solid-panel";
     "segmented-panel": "segmented-panel";
+    "solid-panel": "solid-panel";
 }>;
 export declare const ElevatorShaftStyle: z.ZodEnum<{
     glass: "glass";
@@ -25,28 +25,54 @@ export declare const ElevatorNode: 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";
+            perspective: "perspective";
         }>>;
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
     metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    provenance: z.ZodOptional<z.ZodObject<{
+        refs: z.ZodArray<z.ZodObject<{
+            ns: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            role: z.ZodOptional<z.ZodEnum<{
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+                piece: "piece";
+                primary: "primary";
+            }>>;
+        }, z.core.$strip>>;
+        lineage: z.ZodOptional<z.ZodObject<{
+            op: z.ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
+                import: "import";
+                "make-independent": "make-independent";
+                merge: "merge";
+                promote: "promote";
+                split: "split";
+            }>;
+            fromIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`elevator_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"elevator">>;
     material: z.ZodOptional<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
         preset: z.ZodOptional<z.ZodCatch<z.ZodEnum<{
-            custom: "custom";
-            white: "white";
             brick: "brick";
             concrete: "concrete";
-            wood: "wood";
+            custom: "custom";
             glass: "glass";
+            marble: "marble";
             metal: "metal";
             plaster: "plaster";
             tile: "tile";
-            marble: "marble";
+            white: "white";
+            wood: "wood";
         }>>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
@@ -55,9 +81,9 @@ export declare const ElevatorNode: z.ZodObject<{
             opacity: z.ZodDefault<z.ZodNumber>;
             transparent: z.ZodDefault<z.ZodBoolean>;
             side: z.ZodDefault<z.ZodEnum<{
-                front: "front";
                 back: "back";
                 double: "double";
+                front: "front";
             }>>;
         }, z.core.$strip>>;
         texture: z.ZodOptional<z.ZodObject<{
@@ -89,8 +115,8 @@ export declare const ElevatorNode: z.ZodObject<{
     }>>;
     doorPanelStyle: z.ZodDefault<z.ZodEnum<{
         "glass-frame": "glass-frame";
-        "solid-panel": "solid-panel";
         "segmented-panel": "segmented-panel";
+        "solid-panel": "solid-panel";
     }>>;
     fromLevelId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
     toLevelId: z.ZodDefault<z.ZodNullable<z.ZodString>>;

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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmDxB,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/eyebrow-vent.d.ts

@@ -13,28 +13,54 @@ export declare const EyebrowVentNode: 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";
+            perspective: "perspective";
         }>>;
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
     metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    provenance: z.ZodOptional<z.ZodObject<{
+        refs: z.ZodArray<z.ZodObject<{
+            ns: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            role: z.ZodOptional<z.ZodEnum<{
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+                piece: "piece";
+                primary: "primary";
+            }>>;
+        }, z.core.$strip>>;
+        lineage: z.ZodOptional<z.ZodObject<{
+            op: z.ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
+                import: "import";
+                "make-independent": "make-independent";
+                merge: "merge";
+                promote: "promote";
+                split: "split";
+            }>;
+            fromIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`eyebrow-vent_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"eyebrow-vent">>;
     material: z.ZodOptional<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
         preset: z.ZodOptional<z.ZodCatch<z.ZodEnum<{
-            custom: "custom";
-            white: "white";
             brick: "brick";
             concrete: "concrete";
-            wood: "wood";
+            custom: "custom";
             glass: "glass";
+            marble: "marble";
             metal: "metal";
             plaster: "plaster";
             tile: "tile";
-            marble: "marble";
+            white: "white";
+            wood: "wood";
         }>>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
@@ -43,9 +69,9 @@ export declare const EyebrowVentNode: z.ZodObject<{
             opacity: z.ZodDefault<z.ZodNumber>;
             transparent: z.ZodDefault<z.ZodBoolean>;
             side: z.ZodDefault<z.ZodEnum<{
-                front: "front";
                 back: "back";
                 double: "double";
+                front: "front";
             }>>;
         }, z.core.$strip>>;
         texture: z.ZodOptional<z.ZodObject<{

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

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

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

@@ -0,0 +1,141 @@
+import { z } from 'zod';
+export declare const FenceGateNode: 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<{
+            orthographic: "orthographic";
+            perspective: "perspective";
+        }>>;
+        fov: z.ZodOptional<z.ZodNumber>;
+        zoom: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    provenance: z.ZodOptional<z.ZodObject<{
+        refs: z.ZodArray<z.ZodObject<{
+            ns: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            role: z.ZodOptional<z.ZodEnum<{
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+                piece: "piece";
+                primary: "primary";
+            }>>;
+        }, z.core.$strip>>;
+        lineage: z.ZodOptional<z.ZodObject<{
+            op: z.ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
+                import: "import";
+                "make-independent": "make-independent";
+                merge: "merge";
+                promote: "promote";
+                split: "split";
+            }>;
+            fromIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    matchFenceStyle: z.ZodOptional<z.ZodBoolean>;
+    matchFenceHeight: z.ZodOptional<z.ZodBoolean>;
+    leafType: z.ZodOptional<z.ZodEnum<{
+        double: "double";
+        single: "single";
+    }>>;
+    style: z.ZodOptional<z.ZodEnum<{
+        guard: "guard";
+        horizontal: "horizontal";
+        match: "match";
+        picket: "picket";
+        privacy: "privacy";
+        rail: "rail";
+        slat: "slat";
+    }>>;
+    height: z.ZodOptional<z.ZodNumber>;
+    clearance: z.ZodOptional<z.ZodNumber>;
+    thickness: z.ZodOptional<z.ZodNumber>;
+    frameWidth: z.ZodOptional<z.ZodNumber>;
+    spacing: z.ZodOptional<z.ZodNumber>;
+    boardWidth: z.ZodOptional<z.ZodNumber>;
+    hinge: z.ZodOptional<z.ZodEnum<{
+        left: "left";
+        right: "right";
+    }>>;
+    swing: z.ZodOptional<z.ZodEnum<{
+        inward: "inward";
+        outward: "outward";
+    }>>;
+    openAngle: z.ZodOptional<z.ZodNumber>;
+    leafSplit: z.ZodOptional<z.ZodNumber>;
+    brace: z.ZodOptional<z.ZodEnum<{
+        cross: "cross";
+        diagonal: "diagonal";
+        none: "none";
+    }>>;
+    showHardware: z.ZodOptional<z.ZodBoolean>;
+    showPosts: z.ZodOptional<z.ZodBoolean>;
+    id: z.ZodDefault<z.ZodTemplateLiteral<`fence-gate_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"fence-gate">>;
+    center: z.ZodDefault<z.ZodNumber>;
+    width: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const FenceOpeningNode: 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<{
+            orthographic: "orthographic";
+            perspective: "perspective";
+        }>>;
+        fov: z.ZodOptional<z.ZodNumber>;
+        zoom: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    provenance: z.ZodOptional<z.ZodObject<{
+        refs: z.ZodArray<z.ZodObject<{
+            ns: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            role: z.ZodOptional<z.ZodEnum<{
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+                piece: "piece";
+                primary: "primary";
+            }>>;
+        }, z.core.$strip>>;
+        lineage: z.ZodOptional<z.ZodObject<{
+            op: z.ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
+                import: "import";
+                "make-independent": "make-independent";
+                merge: "merge";
+                promote: "promote";
+                split: "split";
+            }>;
+            fromIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    center: z.ZodDefault<z.ZodNumber>;
+    width: z.ZodDefault<z.ZodNumber>;
+    matchFenceStyle: z.ZodOptional<z.ZodBoolean>;
+    matchFenceHeight: z.ZodOptional<z.ZodBoolean>;
+    height: z.ZodOptional<z.ZodNumber>;
+    showPosts: z.ZodDefault<z.ZodBoolean>;
+    id: z.ZodDefault<z.ZodTemplateLiteral<`fence-opening_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"fence-opening">>;
+}, z.core.$strip>;
+export type FenceGateNode = z.infer<typeof FenceGateNode>;
+export type FenceOpeningNode = z.infer<typeof FenceOpeningNode>;
+export type FenceFeatureNode = FenceGateNode | FenceOpeningNode;
+//# sourceMappingURL=fence-feature.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fence-feature.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/fence-feature.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMsC,CAAA;AAChE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAS2C,CAAA;AACxE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AACzD,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAC/D,MAAM,MAAM,gBAAgB,GAAG,aAAa,GAAG,gBAAgB,CAAA"}

package/dist/schema/nodes/fence-feature.js

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base.js';
+import { FenceFeature } from './fence.js';
+const fields = FenceFeature.omit({ id: true, kind: true }).shape;
+export const FenceGateNode = BaseNode.extend({
+    ...fields,
+    id: objectId('fence-gate'),
+    type: nodeType('fence-gate'),
+    center: fields.center.default(1.5),
+    width: fields.width.min(0.35).default(1.1),
+}).describe('An individually selectable gate hosted by a fence');
+export const FenceOpeningNode = BaseNode.extend({
+    center: fields.center.default(1.5),
+    width: fields.width.min(0.35).default(1.1),
+    matchFenceStyle: z.boolean().optional(),
+    matchFenceHeight: fields.matchFenceHeight,
+    height: fields.height,
+    showPosts: z.boolean().default(true),
+    id: objectId('fence-opening'),
+    type: nodeType('fence-opening'),
+}).describe('An individually selectable open passage hosted by a fence');

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

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+/**
+ * 'guard' — a deck guard built the way the AWC's Deck Construction Guide
+ * (DCA 6) draws one: 4x4 posts no more than `postSpacing` apart, a 2x6 cap
+ * rail flat on top, a 2x4 top rail on edge under it, and the infill
+ * `guardInfill` chooses — 2x2 balusters on a 2x4 bottom rail at a ≤ 4 in
+ * clear gap (IRC R312.1.3), ½ in cables `slatGap` apart, or horizontal
+ * boards `slatGap` apart. `startPost` / `endPost` false leave that end's
+ * post out so the rails die into a post already standing there (a porch's
+ * 6x6); `postThrough` runs the posts past the cap with a cap of their own.
+ */
+export declare const FenceStyle: z.ZodEnum<{
+    guard: "guard";
+    horizontal: "horizontal";
+    picket: "picket";
+    privacy: "privacy";
+    rail: "rail";
+    slat: "slat";
+}>;
+/**
+ * 'grounded' — a kickboard on the ground; 'floating' — no base, the panel
+ * held `groundClearance` up on posts that reach the ground; 'raised' — the
+ * base is a BOTTOM RAIL held `groundClearance` above the ground with the
+ * infill ending on it, the posts to the ground: a deck guard (IRC R312 —
+ * pickets between a top and a bottom rail, the gap under the rail below 4 in).
+ */
+export declare const FenceBaseStyle: z.ZodEnum<{
+    floating: "floating";
+    grounded: "grounded";
+    raised: "raised";
+}>;
+//# sourceMappingURL=fence-types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fence-types.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/fence-types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB;;;;;;;;;GASG;AACH,eAAO,MAAM,UAAU;;;;;;;EAAuE,CAAA;AAC9F;;;;;;GAMG;AACH,eAAO,MAAM,cAAc;;;;EAA6C,CAAA"}

package/dist/schema/nodes/fence-types.js

@@ -0,0 +1,22 @@
+import { z } from 'zod';
+// Fence enums, in a file with no other dependency: agent tool contracts validate against them
+// without loading the node schemas.
+/**
+ * 'guard' — a deck guard built the way the AWC's Deck Construction Guide
+ * (DCA 6) draws one: 4x4 posts no more than `postSpacing` apart, a 2x6 cap
+ * rail flat on top, a 2x4 top rail on edge under it, and the infill
+ * `guardInfill` chooses — 2x2 balusters on a 2x4 bottom rail at a ≤ 4 in
+ * clear gap (IRC R312.1.3), ½ in cables `slatGap` apart, or horizontal
+ * boards `slatGap` apart. `startPost` / `endPost` false leave that end's
+ * post out so the rails die into a post already standing there (a porch's
+ * 6x6); `postThrough` runs the posts past the cap with a cap of their own.
+ */
+export const FenceStyle = z.enum(['slat', 'rail', 'privacy', 'horizontal', 'guard', 'picket']);
+/**
+ * 'grounded' — a kickboard on the ground; 'floating' — no base, the panel
+ * held `groundClearance` up on posts that reach the ground; 'raised' — the
+ * base is a BOTTOM RAIL held `groundClearance` above the ground with the
+ * infill ending on it, the posts to the ground: a deck guard (IRC R312 —
+ * pickets between a top and a bottom rail, the gap under the rail below 4 in).
+ */
+export const FenceBaseStyle = z.enum(['floating', 'grounded', 'raised']);

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

@@ -1,19 +1,81 @@
 import { z } from 'zod';
-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 { FenceBaseStyle, FenceStyle } from './fence-types.js';
+export declare const FenceGuardInfill: z.ZodEnum<{
+    balusters: "balusters";
+    boards: "boards";
+    cable: "cable";
 }>;
 export declare const FencePostCap: z.ZodEnum<{
     flat: "flat";
     none: "none";
     pyramid: "pyramid";
 }>;
+export declare const FenceSurfaceMode: z.ZodEnum<{
+    auto: "auto";
+    level: "level";
+    selected: "selected";
+}>;
+export declare const FenceTransitionMode: z.ZodEnum<{
+    break: "break";
+    slope: "slope";
+    step: "step";
+}>;
+export declare const FencePatternDistribution: z.ZodEnum<{
+    automatic: "automatic";
+    "equal-fit": "equal-fit";
+    "fixed-count": "fixed-count";
+    "fixed-spacing": "fixed-spacing";
+    "maximum-spacing": "maximum-spacing";
+}>;
+export declare function maxFencePicketRailProjection(postSize: number): number;
+export declare function clampFencePicketRailProjection(projection: number, postSize: number): number;
+export declare const FenceFeature: z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+        gate: "gate";
+        opening: "opening";
+    }>;
+    center: z.ZodNumber;
+    width: z.ZodNumber;
+    matchFenceStyle: z.ZodOptional<z.ZodBoolean>;
+    matchFenceHeight: z.ZodOptional<z.ZodBoolean>;
+    leafType: z.ZodOptional<z.ZodEnum<{
+        double: "double";
+        single: "single";
+    }>>;
+    style: z.ZodOptional<z.ZodEnum<{
+        guard: "guard";
+        horizontal: "horizontal";
+        match: "match";
+        picket: "picket";
+        privacy: "privacy";
+        rail: "rail";
+        slat: "slat";
+    }>>;
+    height: z.ZodOptional<z.ZodNumber>;
+    clearance: z.ZodOptional<z.ZodNumber>;
+    thickness: z.ZodOptional<z.ZodNumber>;
+    frameWidth: z.ZodOptional<z.ZodNumber>;
+    spacing: z.ZodOptional<z.ZodNumber>;
+    boardWidth: z.ZodOptional<z.ZodNumber>;
+    hinge: z.ZodOptional<z.ZodEnum<{
+        left: "left";
+        right: "right";
+    }>>;
+    swing: z.ZodOptional<z.ZodEnum<{
+        inward: "inward";
+        outward: "outward";
+    }>>;
+    openAngle: z.ZodOptional<z.ZodNumber>;
+    leafSplit: z.ZodOptional<z.ZodNumber>;
+    brace: z.ZodOptional<z.ZodEnum<{
+        cross: "cross";
+        diagonal: "diagonal";
+        none: "none";
+    }>>;
+    showHardware: z.ZodOptional<z.ZodBoolean>;
+    showPosts: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
 export declare const FenceNode: z.ZodObject<{
     object: z.ZodDefault<z.ZodLiteral<"node">>;
     name: z.ZodOptional<z.ZodString>;
@@ -23,28 +85,55 @@ export declare const FenceNode: 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";
+            perspective: "perspective";
         }>>;
         fov: z.ZodOptional<z.ZodNumber>;
         zoom: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strip>>;
     metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    provenance: z.ZodOptional<z.ZodObject<{
+        refs: z.ZodArray<z.ZodObject<{
+            ns: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            role: z.ZodOptional<z.ZodEnum<{
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+                piece: "piece";
+                primary: "primary";
+            }>>;
+        }, z.core.$strip>>;
+        lineage: z.ZodOptional<z.ZodObject<{
+            op: z.ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
+                import: "import";
+                "make-independent": "make-independent";
+                merge: "merge";
+                promote: "promote";
+                split: "split";
+            }>;
+            fromIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     id: z.ZodDefault<z.ZodTemplateLiteral<`fence_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"fence">>;
+    children: z.ZodDefault<z.ZodArray<z.ZodString>>;
     material: z.ZodOptional<z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
         preset: z.ZodOptional<z.ZodCatch<z.ZodEnum<{
-            custom: "custom";
-            white: "white";
             brick: "brick";
             concrete: "concrete";
-            wood: "wood";
+            custom: "custom";
             glass: "glass";
+            marble: "marble";
             metal: "metal";
             plaster: "plaster";
             tile: "tile";
-            marble: "marble";
+            white: "white";
+            wood: "wood";
         }>>>;
         properties: z.ZodOptional<z.ZodObject<{
             color: z.ZodDefault<z.ZodString>;
@@ -53,9 +142,9 @@ export declare const FenceNode: z.ZodObject<{
             opacity: z.ZodDefault<z.ZodNumber>;
             transparent: z.ZodDefault<z.ZodBoolean>;
             side: z.ZodDefault<z.ZodEnum<{
-                front: "front";
                 back: "back";
                 double: "double";
+                front: "front";
             }>>;
         }, z.core.$strip>>;
         texture: z.ZodOptional<z.ZodObject<{
@@ -69,14 +158,65 @@ export declare const FenceNode: z.ZodObject<{
     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>>>;
+    spanModes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        curve: "curve";
+        straight: "straight";
+    }>>>;
     tangents: z.ZodOptional<z.ZodArray<z.ZodNullable<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>>;
     height: z.ZodDefault<z.ZodNumber>;
     thickness: z.ZodDefault<z.ZodNumber>;
     supportSlabId: z.ZodOptional<z.ZodString>;
+    supportSurfaceNodeId: z.ZodOptional<z.ZodString>;
     supportOffset: z.ZodOptional<z.ZodNumber>;
+    surfaceMode: z.ZodDefault<z.ZodEnum<{
+        auto: "auto";
+        level: "level";
+        selected: "selected";
+    }>>;
+    transitionMode: z.ZodDefault<z.ZodEnum<{
+        break: "break";
+        slope: "slope";
+        step: "step";
+    }>>;
+    transitionWidth: z.ZodDefault<z.ZodNumber>;
     curveOffset: z.ZodOptional<z.ZodNumber>;
     baseHeight: z.ZodDefault<z.ZodNumber>;
     postSpacing: z.ZodDefault<z.ZodNumber>;
+    picketSpacing: z.ZodDefault<z.ZodNumber>;
+    patternDistribution: z.ZodDefault<z.ZodEnum<{
+        automatic: "automatic";
+        "equal-fit": "equal-fit";
+        "fixed-count": "fixed-count";
+        "fixed-spacing": "fixed-spacing";
+        "maximum-spacing": "maximum-spacing";
+    }>>;
+    patternAlignment: z.ZodDefault<z.ZodEnum<{
+        center: "center";
+        end: "end";
+        start: "start";
+    }>>;
+    patternCount: z.ZodDefault<z.ZodNumber>;
+    patternRemainder: z.ZodDefault<z.ZodEnum<{
+        leave: "leave";
+        spread: "spread";
+    }>>;
+    picketWidth: z.ZodDefault<z.ZodNumber>;
+    picketTop: z.ZodDefault<z.ZodEnum<{
+        "dog-ear": "dog-ear";
+        flat: "flat";
+        pointed: "pointed";
+        rounded: "rounded";
+    }>>;
+    picketProfile: z.ZodDefault<z.ZodEnum<{
+        alternating: "alternating";
+        arched: "arched";
+        level: "level";
+        scalloped: "scalloped";
+    }>>;
+    picketTopClearance: z.ZodDefault<z.ZodNumber>;
+    picketVariation: z.ZodDefault<z.ZodNumber>;
+    picketRailProjection: z.ZodDefault<z.ZodNumber>;
+    picketRailCount: z.ZodDefault<z.ZodNumber>;
     postSize: z.ZodDefault<z.ZodNumber>;
     topRailHeight: z.ZodDefault<z.ZodNumber>;
     groundClearance: z.ZodDefault<z.ZodNumber>;
@@ -90,15 +230,32 @@ export declare const FenceNode: z.ZodObject<{
     baseStyle: z.ZodDefault<z.ZodEnum<{
         floating: "floating";
         grounded: "grounded";
+        raised: "raised";
     }>>;
     showInfill: z.ZodDefault<z.ZodBoolean>;
+    guardInfill: z.ZodOptional<z.ZodEnum<{
+        balusters: "balusters";
+        boards: "boards";
+        cable: "cable";
+    }>>;
+    startPost: z.ZodOptional<z.ZodBoolean>;
+    endPost: z.ZodOptional<z.ZodBoolean>;
+    postThrough: z.ZodOptional<z.ZodBoolean>;
+    infillPlacement: z.ZodDefault<z.ZodEnum<{
+        back: "back";
+        center: "center";
+        front: "front";
+    }>>;
     color: z.ZodDefault<z.ZodString>;
     style: z.ZodDefault<z.ZodEnum<{
-        slat: "slat";
-        rail: "rail";
-        privacy: "privacy";
+        guard: "guard";
         horizontal: "horizontal";
+        picket: "picket";
+        privacy: "privacy";
+        rail: "rail";
+        slat: "slat";
     }>>;
 }, z.core.$strip>;
+export type FenceGuardInfill = z.infer<typeof FenceGuardInfill>;
 export type FenceNode = z.infer<typeof FenceNode>;
 //# sourceMappingURL=fence.d.ts.map

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;;;;;EAAoD,CAAA;AAC3E,eAAO,MAAM,cAAc;;;EAAmC,CAAA;AAC9D,eAAO,MAAM,YAAY;;;;EAAsC,CAAA;AAE/D,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6DrB,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;AAKvB,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,eAAe,CAAA;AAC1D,eAAO,MAAM,gBAAgB;;;;EAA2C,CAAA;AACxE,eAAO,MAAM,YAAY;;;;EAAsC,CAAA;AAC/D,eAAO,MAAM,gBAAgB;;;;EAAwC,CAAA;AACrE,eAAO,MAAM,mBAAmB;;;;EAAqC,CAAA;AACrE,eAAO,MAAM,wBAAwB;;;;;;EAMnC,CAAA;AAEF,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAErE;AAED,wBAAgB,8BAA8B,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE3F;AACD,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsBvB,CAAA;AAEF,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2FrB,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAC/D,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}