@pascal-app/core 1.0.3 → 1.0.5

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

@@ -1 +1 @@
-{"version":3,"file":"spawn.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/spawn.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;iBAOpB,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}
+{"version":3,"file":"spawn.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/spawn.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAOpB,CAAA;AAEF,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}

package/dist/schema/nodes/stair-construction.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+/** Explicit construction details; absence preserves the original stair body. */
+export declare const StairConstruction: z.ZodObject<{
+    mode: z.ZodDefault<z.ZodEnum<{
+        "center-stringer": "center-stringer";
+        open: "open";
+        "side-stringers": "side-stringers";
+        solid: "solid";
+        waist: "waist";
+    }>>;
+    waistThickness: z.ZodDefault<z.ZodNumber>;
+    treadThickness: z.ZodDefault<z.ZodNumber>;
+    riserThickness: z.ZodDefault<z.ZodNumber>;
+    nosing: z.ZodDefault<z.ZodNumber>;
+    finishThickness: z.ZodDefault<z.ZodNumber>;
+    closedRisers: z.ZodDefault<z.ZodBoolean>;
+    stringerWidth: z.ZodDefault<z.ZodNumber>;
+    stringerDepth: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type StairConstruction = z.infer<typeof StairConstruction>;
+//# sourceMappingURL=stair-construction.d.ts.map

package/dist/schema/nodes/stair-construction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stair-construction.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/stair-construction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,gFAAgF;AAChF,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;iBAU5B,CAAA;AACF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA"}

package/dist/schema/nodes/stair-construction.js

@@ -0,0 +1,13 @@
+import { z } from 'zod';
+/** Explicit construction details; absence preserves the original stair body. */
+export const StairConstruction = z.object({
+    mode: z.enum(['solid', 'waist', 'open', 'side-stringers', 'center-stringer']).default('open'),
+    waistThickness: z.number().positive().default(0.25),
+    treadThickness: z.number().positive().default(0.05),
+    riserThickness: z.number().positive().default(0.02),
+    nosing: z.number().nonnegative().default(0.025),
+    finishThickness: z.number().nonnegative().default(0),
+    closedRisers: z.boolean().default(false),
+    stringerWidth: z.number().positive().default(0.08),
+    stringerDepth: z.number().positive().default(0.25),
+});

package/dist/schema/nodes/stair-defaults.d.ts

@@ -0,0 +1,16 @@
+export declare const DEFAULT_STAIR_TYPE: 'straight';
+export declare const DEFAULT_STAIR_WIDTH = 1;
+export declare const DEFAULT_STAIR_ATTACHMENT_SIDE: 'front';
+export declare const DEFAULT_STAIR_FILL_TO_FLOOR = true;
+export declare const DEFAULT_STAIR_THICKNESS = 0.25;
+export declare const DEFAULT_STAIR_OPENING_OFFSET = 0;
+export declare const DEFAULT_CURVED_STAIR_INNER_RADIUS = 0.9;
+export declare const DEFAULT_CURVED_STAIR_SWEEP_ANGLE: number;
+export declare const DEFAULT_SPIRAL_STAIR_SWEEP_ANGLE: number;
+export declare const DEFAULT_SPIRAL_TOP_LANDING_MODE: 'none';
+export declare const DEFAULT_SPIRAL_TOP_LANDING_DEPTH = 0.9;
+export declare const DEFAULT_SPIRAL_SHOW_CENTER_COLUMN = true;
+export declare const DEFAULT_SPIRAL_SHOW_STEP_SUPPORTS = true;
+export declare const DEFAULT_STAIR_RAILING_MODE: 'both';
+export declare const DEFAULT_STAIR_RAILING_HEIGHT = 0.92;
+//# sourceMappingURL=stair-defaults.d.ts.map

package/dist/schema/nodes/stair-defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stair-defaults.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/stair-defaults.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,kBAAkB,EAAG,UAAmB,CAAA;AACrD,eAAO,MAAM,mBAAmB,IAAM,CAAA;AACtC,eAAO,MAAM,6BAA6B,EAAG,OAAgB,CAAA;AAC7D,eAAO,MAAM,2BAA2B,OAAO,CAAA;AAC/C,eAAO,MAAM,uBAAuB,OAAO,CAAA;AAC3C,eAAO,MAAM,4BAA4B,IAAI,CAAA;AAC7C,eAAO,MAAM,iCAAiC,MAAM,CAAA;AACpD,eAAO,MAAM,gCAAgC,QAAc,CAAA;AAC3D,eAAO,MAAM,gCAAgC,QAAwB,CAAA;AACrE,eAAO,MAAM,+BAA+B,EAAG,MAAe,CAAA;AAC9D,eAAO,MAAM,gCAAgC,MAAM,CAAA;AACnD,eAAO,MAAM,iCAAiC,OAAO,CAAA;AACrD,eAAO,MAAM,iCAAiC,OAAO,CAAA;AACrD,eAAO,MAAM,0BAA0B,EAAG,MAAe,CAAA;AACzD,eAAO,MAAM,4BAA4B,OAAO,CAAA"}

package/dist/schema/nodes/stair-defaults.js

@@ -0,0 +1,15 @@
+export const DEFAULT_STAIR_TYPE = 'straight';
+export const DEFAULT_STAIR_WIDTH = 1.0;
+export const DEFAULT_STAIR_ATTACHMENT_SIDE = 'front';
+export const DEFAULT_STAIR_FILL_TO_FLOOR = true;
+export const DEFAULT_STAIR_THICKNESS = 0.25;
+export const DEFAULT_STAIR_OPENING_OFFSET = 0;
+export const DEFAULT_CURVED_STAIR_INNER_RADIUS = 0.9;
+export const DEFAULT_CURVED_STAIR_SWEEP_ANGLE = Math.PI / 2;
+export const DEFAULT_SPIRAL_STAIR_SWEEP_ANGLE = (400 * Math.PI) / 180;
+export const DEFAULT_SPIRAL_TOP_LANDING_MODE = 'none';
+export const DEFAULT_SPIRAL_TOP_LANDING_DEPTH = 0.9;
+export const DEFAULT_SPIRAL_SHOW_CENTER_COLUMN = true;
+export const DEFAULT_SPIRAL_SHOW_STEP_SUPPORTS = true;
+export const DEFAULT_STAIR_RAILING_MODE = 'both';
+export const DEFAULT_STAIR_RAILING_HEIGHT = 0.92;

package/dist/schema/nodes/stair-design-targets.d.ts

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+export declare const StairDesignTargets: z.ZodObject<{
+    maxRiserHeight: z.ZodDefault<z.ZodNumber>;
+    minimumGoing: z.ZodDefault<z.ZodNumber>;
+    targetGoing: z.ZodDefault<z.ZodNumber>;
+    minimumHeadroom: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type StairDesignTargets = z.infer<typeof StairDesignTargets>;
+//# sourceMappingURL=stair-design-targets.d.ts.map

package/dist/schema/nodes/stair-design-targets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stair-design-targets.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/stair-design-targets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,kBAAkB;;;;;iBAK7B,CAAA;AACF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA"}

package/dist/schema/nodes/stair-design-targets.js

@@ -0,0 +1,7 @@
+import { z } from 'zod';
+export const StairDesignTargets = z.object({
+    maxRiserHeight: z.number().positive().default(0.18),
+    minimumGoing: z.number().positive().default(0.25),
+    targetGoing: z.number().positive().default(0.28),
+    minimumHeadroom: z.number().positive().default(2),
+});

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

@@ -1,15 +1,27 @@
 import { z } from 'zod';
 export declare const StairSegmentType: z.ZodEnum<{
-    stair: "stair";
     landing: "landing";
+    stair: "stair";
 }>;
 export type StairSegmentType = z.infer<typeof StairSegmentType>;
 export declare const AttachmentSide: z.ZodEnum<{
     front: "front";
-    right: "right";
     left: "left";
+    right: "right";
 }>;
 export type AttachmentSide = z.infer<typeof AttachmentSide>;
+export declare const StairWinder: z.ZodObject<{
+    turn: z.ZodEnum<{
+        left: "left";
+        right: "right";
+    }>;
+    innerGap: z.ZodDefault<z.ZodNumber>;
+    walkingLineOffset: z.ZodDefault<z.ZodNumber>;
+    division: z.ZodDefault<z.ZodEnum<{
+        "equal-angle": "equal-angle";
+        "equal-going": "equal-going";
+    }>>;
+}, z.core.$strip>;
 export declare const StairSegmentNode: z.ZodObject<{
     object: z.ZodDefault<z.ZodLiteral<"node">>;
     name: z.ZodOptional<z.ZodString>;
@@ -19,28 +31,54 @@ export declare const StairSegmentNode: 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<`sseg_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"stair-segment">>;
     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>;
@@ -49,9 +87,9 @@ export declare const StairSegmentNode: 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<{
@@ -61,11 +99,12 @@ export declare const StairSegmentNode: 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>;
     segmentType: z.ZodDefault<z.ZodEnum<{
-        stair: "stair";
         landing: "landing";
+        stair: "stair";
     }>>;
     width: z.ZodDefault<z.ZodNumber>;
     length: z.ZodDefault<z.ZodNumber>;
@@ -73,10 +112,39 @@ export declare const StairSegmentNode: z.ZodObject<{
     stepCount: z.ZodDefault<z.ZodNumber>;
     attachmentSide: z.ZodDefault<z.ZodEnum<{
         front: "front";
-        right: "right";
         left: "left";
+        right: "right";
     }>>;
     fillToFloor: z.ZodDefault<z.ZodBoolean>;
+    construction: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodDefault<z.ZodEnum<{
+            "center-stringer": "center-stringer";
+            open: "open";
+            "side-stringers": "side-stringers";
+            solid: "solid";
+            waist: "waist";
+        }>>;
+        waistThickness: z.ZodDefault<z.ZodNumber>;
+        treadThickness: z.ZodDefault<z.ZodNumber>;
+        riserThickness: z.ZodDefault<z.ZodNumber>;
+        nosing: z.ZodDefault<z.ZodNumber>;
+        finishThickness: z.ZodDefault<z.ZodNumber>;
+        closedRisers: z.ZodDefault<z.ZodBoolean>;
+        stringerWidth: z.ZodDefault<z.ZodNumber>;
+        stringerDepth: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    winder: z.ZodOptional<z.ZodObject<{
+        turn: z.ZodEnum<{
+            left: "left";
+            right: "right";
+        }>;
+        innerGap: z.ZodDefault<z.ZodNumber>;
+        walkingLineOffset: z.ZodDefault<z.ZodNumber>;
+        division: z.ZodDefault<z.ZodEnum<{
+            "equal-angle": "equal-angle";
+            "equal-going": "equal-going";
+        }>>;
+    }, z.core.$strip>>;
     thickness: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
 export type StairSegmentNode = z.infer<typeof StairSegmentNode>;

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

@@ -1 +1 @@
-{"version":3,"file":"stair-segment.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/stair-segment.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,gBAAgB;;;EAA+B,CAAA;AAE5D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAE/D,eAAO,MAAM,cAAc;;;;EAAqC,CAAA;AAEhE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAE3D,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAsC5B,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA"}
+{"version":3,"file":"stair-segment.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/stair-segment.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,eAAO,MAAM,gBAAgB;;;EAA+B,CAAA;AAE5D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAE/D,eAAO,MAAM,cAAc;;;;EAAqC,CAAA;AAEhE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAA;AAE3D,eAAO,MAAM,WAAW;;;;;;;;;;;iBAKtB,CAAA;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4C5B,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA"}

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

@@ -2,13 +2,21 @@ import dedent from 'dedent';
 import { z } from 'zod';
 import { BaseNode, nodeType, objectId } from '../base.js';
 import { MaterialSchema } from '../material.js';
+import { StairConstruction } from './stair-construction.js';
 export const StairSegmentType = z.enum(['stair', 'landing']);
 export const AttachmentSide = z.enum(['front', 'left', 'right']);
+export const StairWinder = z.object({
+    turn: z.enum(['left', 'right']),
+    innerGap: z.number().finite().nonnegative().default(0),
+    walkingLineOffset: z.number().finite().positive().default(0.5),
+    division: z.enum(['equal-going', 'equal-angle']).default('equal-going'),
+});
 export const StairSegmentNode = BaseNode.extend({
     id: objectId('sseg'),
     type: nodeType('stair-segment'),
     material: MaterialSchema.optional(),
     materialPreset: z.string().optional(),
+    slots: z.record(z.string(), z.string()).optional(),
     position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
     // Rotation around Y axis in radians
     rotation: z.number().default(0),
@@ -26,6 +34,8 @@ export const StairSegmentNode = BaseNode.extend({
     attachmentSide: AttachmentSide.default('front'),
     // Whether to fill the underside down to floor level
     fillToFloor: z.boolean().default(true),
+    construction: StairConstruction.optional(),
+    winder: StairWinder.optional(),
     // Thickness of the stair slab when not filled to floor
     thickness: z.number().default(0.25),
 }).describe(dedent `
@@ -39,5 +49,8 @@ export const StairSegmentNode = BaseNode.extend({
   - stepCount: number of steps (stair type only)
   - attachmentSide: front, left, or right - which side of the previous segment to attach to
   - fillToFloor: whether to fill the underside down to the absolute floor level
+  - construction: optional explicit body, tread, riser, nosing, finish and stringer details; absent inherits the parent setting
+  - winder: optional quarter-turn flight with left/right turn, inner gap, walking-line offset and equal-going/equal-angle division
   - thickness: slab thickness when not filled to floor
+  Parent designTargets, uniformRisers and railingPath apply to the chain. Guards support balusters, post-and-rail, cable, boards, glass and metal.
   `);

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

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+export declare const StairRailingMode: z.ZodEnum<{
+    both: "both";
+    left: "left";
+    none: "none";
+    right: "right";
+}>;
+export type StairRailingMode = z.infer<typeof StairRailingMode>;
+/**
+ * How a straight flight's guard is built: 'balusters' — the round baluster
+ * at every nosing with two round rails (the original); 'post-and-rail' —
+ * the way a deck stair is built: 4x4 posts no more than 4 ft apart (two on a
+ * short flight), a top rail and a bottom rail following the flight, 1½ in
+ * pickets between them at a 4 in-sphere gap (IRC R312.1.3); 'cable' — slim 2 in
+ * posts spaced by run under a flat cap rail, with slender round cables 3 in
+ * apart pulled as straight spans from post to post and a swage sleeve at each
+ * terminal post (the modern cable rail; the cap follows a curve but the taut
+ * cables span straight between the posts).
+ */
+export declare const StairRailingStyle: z.ZodEnum<{
+    balusters: "balusters";
+    boards: "boards";
+    cable: "cable";
+    glass: "glass";
+    metal: "metal";
+    "post-and-rail": "post-and-rail";
+}>;
+export type StairRailingStyle = z.infer<typeof StairRailingStyle>;
+//# sourceMappingURL=stair-types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stair-types.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/stair-types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,eAAO,MAAM,gBAAgB;;;;;EAA4C,CAAA;AACzE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA;AAE/D;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB;;;;;;;EAO5B,CAAA;AACF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA"}

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

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+// Stair railing enums, in a file with no other dependency: agent tool contracts validate against
+// them without loading the node schemas.
+export const StairRailingMode = z.enum(['none', 'left', 'right', 'both']);
+/**
+ * How a straight flight's guard is built: 'balusters' — the round baluster
+ * at every nosing with two round rails (the original); 'post-and-rail' —
+ * the way a deck stair is built: 4x4 posts no more than 4 ft apart (two on a
+ * short flight), a top rail and a bottom rail following the flight, 1½ in
+ * pickets between them at a 4 in-sphere gap (IRC R312.1.3); 'cable' — slim 2 in
+ * posts spaced by run under a flat cap rail, with slender round cables 3 in
+ * apart pulled as straight spans from post to post and a swage sleeve at each
+ * terminal post (the modern cable rail; the cap follows a curve but the taut
+ * cables span straight between the posts).
+ */
+export const StairRailingStyle = z.enum([
+    'balusters',
+    'post-and-rail',
+    'cable',
+    'boards',
+    'glass',
+    'metal',
+]);