@pascal-app/core 1.0.3 → 1.0.4

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<{
+            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>>>;
+    provenance: z.ZodOptional<z.ZodObject<{
+        refs: z.ZodArray<z.ZodObject<{
+            ns: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            role: z.ZodOptional<z.ZodEnum<{
+                primary: "primary";
+                piece: "piece";
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+            }>>;
+        }, z.core.$strip>>;
+        lineage: z.ZodOptional<z.ZodObject<{
+            op: z.ZodEnum<{
+                import: "import";
+                split: "split";
+                merge: "merge";
+                duplicate: "duplicate";
+                convert: "convert";
+                promote: "promote";
+                "make-independent": "make-independent";
+                attach: "attach";
+            }>;
+            fromIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    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>;
+    height: z.ZodOptional<z.ZodNumber>;
+    style: z.ZodOptional<z.ZodEnum<{
+        match: "match";
+        slat: "slat";
+        rail: "rail";
+        privacy: "privacy";
+        horizontal: "horizontal";
+        guard: "guard";
+        picket: "picket";
+    }>>;
+    spacing: z.ZodOptional<z.ZodNumber>;
+    thickness: z.ZodOptional<z.ZodNumber>;
+    hinge: z.ZodOptional<z.ZodEnum<{
+        left: "left";
+        right: "right";
+    }>>;
+    matchFenceStyle: z.ZodOptional<z.ZodBoolean>;
+    matchFenceHeight: z.ZodOptional<z.ZodBoolean>;
+    leafType: z.ZodOptional<z.ZodEnum<{
+        double: "double";
+        single: "single";
+    }>>;
+    clearance: z.ZodOptional<z.ZodNumber>;
+    frameWidth: z.ZodOptional<z.ZodNumber>;
+    boardWidth: z.ZodOptional<z.ZodNumber>;
+    swing: z.ZodOptional<z.ZodEnum<{
+        inward: "inward";
+        outward: "outward";
+    }>>;
+    openAngle: z.ZodOptional<z.ZodNumber>;
+    leafSplit: z.ZodOptional<z.ZodNumber>;
+    brace: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        cross: "cross";
+        diagonal: "diagonal";
+    }>>;
+    showHardware: z.ZodOptional<z.ZodBoolean>;
+    showPosts: z.ZodOptional<z.ZodBoolean>;
+}, 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<{
+            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>>>;
+    provenance: z.ZodOptional<z.ZodObject<{
+        refs: z.ZodArray<z.ZodObject<{
+            ns: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            role: z.ZodOptional<z.ZodEnum<{
+                primary: "primary";
+                piece: "piece";
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+            }>>;
+        }, z.core.$strip>>;
+        lineage: z.ZodOptional<z.ZodObject<{
+            op: z.ZodEnum<{
+                import: "import";
+                split: "split";
+                merge: "merge";
+                duplicate: "duplicate";
+                convert: "convert";
+                promote: "promote";
+                "make-independent": "make-independent";
+                attach: "attach";
+            }>;
+            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.d.ts

@@ -1,19 +1,110 @@
 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<{
     slat: "slat";
     rail: "rail";
     privacy: "privacy";
     horizontal: "horizontal";
+    guard: "guard";
+    picket: "picket";
 }>;
+export declare const FenceGuardInfill: z.ZodEnum<{
+    balusters: "balusters";
+    cable: "cable";
+    boards: "boards";
+}>;
+/**
+ * '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";
 }>;
 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<{
+    step: "step";
+    slope: "slope";
+    break: "break";
+}>;
+export declare const FencePatternDistribution: z.ZodEnum<{
+    "maximum-spacing": "maximum-spacing";
+    "fixed-spacing": "fixed-spacing";
+    automatic: "automatic";
+    "fixed-count": "fixed-count";
+    "equal-fit": "equal-fit";
+}>;
+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<{
+        opening: "opening";
+        gate: "gate";
+    }>;
+    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<{
+        match: "match";
+        slat: "slat";
+        rail: "rail";
+        privacy: "privacy";
+        horizontal: "horizontal";
+        guard: "guard";
+        picket: "picket";
+    }>>;
+    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<{
+        none: "none";
+        cross: "cross";
+        diagonal: "diagonal";
+    }>>;
+    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>;
@@ -30,8 +121,35 @@ export declare const FenceNode: z.ZodObject<{
         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<{
+                primary: "primary";
+                piece: "piece";
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+            }>>;
+        }, z.core.$strip>>;
+        lineage: z.ZodOptional<z.ZodObject<{
+            op: z.ZodEnum<{
+                import: "import";
+                split: "split";
+                merge: "merge";
+                duplicate: "duplicate";
+                convert: "convert";
+                promote: "promote";
+                "make-independent": "make-independent";
+                attach: "attach";
+            }>;
+            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<{
@@ -69,14 +187,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<{
+        straight: "straight";
+        curve: "curve";
+    }>>>;
     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<{
+        step: "step";
+        slope: "slope";
+        break: "break";
+    }>>;
+    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<{
+        "maximum-spacing": "maximum-spacing";
+        "fixed-spacing": "fixed-spacing";
+        automatic: "automatic";
+        "fixed-count": "fixed-count";
+        "equal-fit": "equal-fit";
+    }>>;
+    patternAlignment: z.ZodDefault<z.ZodEnum<{
+        center: "center";
+        start: "start";
+        end: "end";
+    }>>;
+    patternCount: z.ZodDefault<z.ZodNumber>;
+    patternRemainder: z.ZodDefault<z.ZodEnum<{
+        leave: "leave";
+        spread: "spread";
+    }>>;
+    picketWidth: z.ZodDefault<z.ZodNumber>;
+    picketTop: z.ZodDefault<z.ZodEnum<{
+        flat: "flat";
+        rounded: "rounded";
+        pointed: "pointed";
+        "dog-ear": "dog-ear";
+    }>>;
+    picketProfile: z.ZodDefault<z.ZodEnum<{
+        arched: "arched";
+        level: "level";
+        scalloped: "scalloped";
+        alternating: "alternating";
+    }>>;
+    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 +259,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";
+        cable: "cable";
+        boards: "boards";
+    }>>;
+    startPost: z.ZodOptional<z.ZodBoolean>;
+    endPost: z.ZodOptional<z.ZodBoolean>;
+    postThrough: z.ZodOptional<z.ZodBoolean>;
+    infillPlacement: z.ZodDefault<z.ZodEnum<{
+        center: "center";
+        front: "front";
+        back: "back";
+    }>>;
     color: z.ZodDefault<z.ZodString>;
     style: z.ZodDefault<z.ZodEnum<{
         slat: "slat";
         rail: "rail";
         privacy: "privacy";
         horizontal: "horizontal";
+        guard: "guard";
+        picket: "picket";
     }>>;
 }, 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;AAIvB;;;;;;;;;GASG;AACH,eAAO,MAAM,UAAU;;;;;;;EAAuE,CAAA;AAC9F,eAAO,MAAM,gBAAgB;;;;EAA2C,CAAA;AACxE;;;;;;GAMG;AACH,eAAO,MAAM,cAAc;;;;EAA6C,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA0FrB,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"}

package/dist/schema/nodes/fence.js

@@ -2,12 +2,69 @@ import dedent from 'dedent';
 import { z } from 'zod';
 import { BaseNode, nodeType, objectId } from '../base.js';
 import { MaterialSchema } from '../material.js';
-export const FenceStyle = z.enum(['slat', 'rail', 'privacy', 'horizontal']);
-export const FenceBaseStyle = z.enum(['floating', 'grounded']);
+/**
+ * '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']);
+export const FenceGuardInfill = z.enum(['balusters', 'cable', 'boards']);
+/**
+ * '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']);
 export const FencePostCap = z.enum(['none', 'flat', 'pyramid']);
+export const FenceSurfaceMode = z.enum(['auto', 'selected', 'level']);
+export const FenceTransitionMode = z.enum(['slope', 'step', 'break']);
+export const FencePatternDistribution = z.enum([
+    'automatic',
+    'fixed-spacing',
+    'fixed-count',
+    'maximum-spacing',
+    'equal-fit',
+]);
+export function maxFencePicketRailProjection(postSize) {
+    return Math.max(0, postSize - 0.001);
+}
+export function clampFencePicketRailProjection(projection, postSize) {
+    return Math.min(Math.max(projection, 0), maxFencePicketRailProjection(postSize));
+}
+export const FenceFeature = z.object({
+    id: z.string(),
+    kind: z.enum(['gate', 'opening']),
+    center: z.number().finite().nonnegative(),
+    width: z.number().finite().positive(),
+    matchFenceStyle: z.boolean().optional(),
+    matchFenceHeight: z.boolean().optional(),
+    leafType: z.enum(['single', 'double']).optional(),
+    style: z.enum(['match', ...FenceStyle.options]).optional(),
+    height: z.number().finite().min(0.3).max(1000).optional(),
+    clearance: z.number().finite().min(0).max(1000).optional(),
+    thickness: z.number().finite().min(0.02).max(0.3).optional(),
+    frameWidth: z.number().finite().min(0.025).max(0.2).optional(),
+    spacing: z.number().finite().min(0.04).max(1000).optional(),
+    boardWidth: z.number().finite().min(0.02).max(0.3).optional(),
+    hinge: z.enum(['left', 'right']).optional(),
+    swing: z.enum(['inward', 'outward']).optional(),
+    openAngle: z.number().finite().min(0).max(170).optional(),
+    leafSplit: z.number().finite().min(0.2).max(0.8).optional(),
+    brace: z.enum(['none', 'diagonal', 'cross']).optional(),
+    showHardware: z.boolean().optional(),
+    showPosts: z.boolean().optional(),
+});
 export const FenceNode = BaseNode.extend({
     id: objectId('fence'),
     type: nodeType('fence'),
+    children: z.array(z.string()).default([]),
     material: MaterialSchema.optional(),
     materialPreset: z.string().optional(),
     // Unified paint-slot refs (`scene:`/`library:` MaterialRef per slot id),
@@ -22,6 +79,7 @@ export const FenceNode = BaseNode.extend({
     // that read endpoints (handles, bbox, miter references) stay valid. Absent =
     // the straight or single-arc fence defined by start/end (+ curveOffset).
     path: z.array(z.tuple([z.number(), z.number()])).optional(),
+    spanModes: z.array(z.enum(['straight', 'curve'])).optional(),
     // Optional per-control-point tangent handles, parallel to `path` (same
     // length when present). Each entry is the OUT-handle offset vector [dx, dy]
     // from its path point, in level meters; the IN handle is its mirror so the
@@ -33,35 +91,62 @@ export const FenceNode = BaseNode.extend({
     // Persisted slab-support host — the fence sits on that slab's walking
     // surface (see ItemNode.supportSlabId for the host rules).
     supportSlabId: z.string().optional(),
-    // Manual vertical offset from the elected slab or level support. This moves
-    // the complete fence body without changing its height.
+    // Top surface selected when drawing on a shaped node. The sampled surface
+    // is resolved again for both preview and committed geometry.
+    supportSurfaceNodeId: z.string().optional(),
+    // Manual vertical offset from the elected slab, shaped surface, or level base.
     supportOffset: z.number().finite().optional(),
+    surfaceMode: FenceSurfaceMode.default('auto'),
+    transitionMode: FenceTransitionMode.default('slope'),
+    transitionWidth: z.number().min(0.2).max(5).default(0.8),
     curveOffset: z.number().optional(),
     baseHeight: z.number().default(0.22),
     postSpacing: z.number().default(2),
+    picketSpacing: z.number().default(0.27),
+    patternDistribution: FencePatternDistribution.default('automatic'),
+    patternAlignment: z.enum(['start', 'center', 'end']).default('center'),
+    patternCount: z.number().int().min(1).max(500).default(4),
+    patternRemainder: z.enum(['leave', 'spread']).default('leave'),
+    picketWidth: z.number().positive().default(0.07),
+    picketTop: z.enum(['flat', 'pointed', 'rounded', 'dog-ear']).default('flat'),
+    picketProfile: z.enum(['level', 'arched', 'scalloped', 'alternating']).default('level'),
+    picketTopClearance: z.number().nonnegative().default(0.2),
+    picketVariation: z.number().nonnegative().default(0.23),
+    picketRailProjection: z.number().positive().default(0.001),
+    picketRailCount: z.number().int().min(2).max(3).default(2),
     postSize: z.number().default(0.1),
     topRailHeight: z.number().default(0.04),
     groundClearance: z.number().default(0),
     edgeInset: z.number().default(0.015),
     // Reveal between the boards of a `horizontal` fence (0 = flush cladding).
     slatGap: z.number().default(0.01),
-    // Topper drawn on each `horizontal`-fence post.
     postCap: FencePostCap.default('pyramid'),
     baseStyle: FenceBaseStyle.default('grounded'),
     showInfill: z.boolean().default(true),
+    // `guard` style only — see FenceStyle.
+    guardInfill: FenceGuardInfill.optional(),
+    startPost: z.boolean().optional(),
+    endPost: z.boolean().optional(),
+    postThrough: z.boolean().optional(),
+    infillPlacement: z.enum(['center', 'front', 'back']).default('center'),
     color: z.string().default('#ffffff'),
     style: FenceStyle.default('slat'),
 }).describe(dedent `
   Fence node - used to represent a fence segment in the building/site level coordinate system
   - start/end: fence endpoints in level coordinate system
   - path: optional list of [x, y] points; when set (>= 2) the centerline is a smooth spline through them
+  - spanModes: straight or curved choice for each path span
+  - children: independently selectable gates and open passages
   - tangents: optional per-point handle vectors (parallel to path); null entries fall back to the automatic tangent
   - height/thickness: overall fence dimensions in meters
   - supportSlabId: optional slab host; the fence stands on that slab's walking surface (elevation)
+  - supportSurfaceNodeId: optional shaped surface whose top the fence follows
   - supportOffset: manual vertical offset from the elected support surface
+  - surfaceMode: auto follows the highest top, selected follows one chosen top, level holds the starting elevation
   - curveOffset: midpoint sagitta offset used to bend the fence into an arc (ignored when path is set)
   - baseHeight/postSpacing/postSize/topRailHeight: exact geometric controls from the plan3D fence model
-  - groundClearance/edgeInset/baseStyle: fence support and inset configuration
+  - groundClearance/edgeInset/baseStyle: fence support and inset configuration ('raised': the base is a bottom rail groundClearance above the ground, posts to the ground) ('raised': the base is a bottom rail groundClearance above the ground, posts to the ground) ('raised': the base is a bottom rail groundClearance above the ground, posts to the ground)
+  - patternDistribution/patternAlignment/patternCount/patternRemainder: repeated-piece layout
   - showInfill: whether to draw intermediate posts/slats between end posts
-  - color/style: visual appearance options
+  - color/style: visual appearance options ('guard': a DCA 6 deck guard — guardInfill balusters | cable | boards, startPost / endPost false where the rails die into a standing post, postThrough for posts past the cap; balusters, both end posts and no postThrough when absent)
   `);

package/dist/schema/nodes/floor-opening.d.ts

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+export declare const FloorOpeningNode: 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>>>;
+    provenance: z.ZodOptional<z.ZodObject<{
+        refs: z.ZodArray<z.ZodObject<{
+            ns: z.ZodOptional<z.ZodString>;
+            id: z.ZodString;
+            role: z.ZodOptional<z.ZodEnum<{
+                primary: "primary";
+                piece: "piece";
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+            }>>;
+        }, z.core.$strip>>;
+        lineage: z.ZodOptional<z.ZodObject<{
+            op: z.ZodEnum<{
+                import: "import";
+                split: "split";
+                merge: "merge";
+                duplicate: "duplicate";
+                convert: "convert";
+                promote: "promote";
+                "make-independent": "make-independent";
+                attach: "attach";
+            }>;
+            fromIds: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    id: z.ZodDefault<z.ZodTemplateLiteral<`floor-opening_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"floor-opening">>;
+    polygon: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    hostZoneId: z.ZodOptional<z.ZodString>;
+    legacyPlateCuts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>>>;
+    legacyCeilingCuts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>>>;
+    source: z.ZodDefault<z.ZodString>;
+    ownerId: z.ZodOptional<z.ZodString>;
+    surfaceId: z.ZodOptional<z.ZodString>;
+    drawnOn: z.ZodDefault<z.ZodEnum<{
+        ceiling: "ceiling";
+        floor: "floor";
+    }>>;
+    cutsPrimary: z.ZodDefault<z.ZodBoolean>;
+    cutsAdjacent: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type FloorOpeningNode = z.infer<typeof FloorOpeningNode>;
+//# sourceMappingURL=floor-opening.d.ts.map

package/dist/schema/nodes/floor-opening.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floor-opening.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/floor-opening.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAe5B,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAA"}

package/dist/schema/nodes/floor-opening.js

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base.js';
+const OpeningRing = z.array(z.tuple([z.number().finite(), z.number().finite()])).min(3);
+export const FloorOpeningNode = BaseNode.extend({
+    id: objectId('floor-opening'),
+    type: nodeType('floor-opening'),
+    polygon: OpeningRing,
+    hostZoneId: z.string().optional(),
+    legacyPlateCuts: z.record(z.string(), z.array(OpeningRing)).optional(),
+    legacyCeilingCuts: z.record(z.string(), z.array(OpeningRing)).optional(),
+    source: z.string().default('manual'),
+    ownerId: z.string().optional(),
+    surfaceId: z.string().optional(),
+    drawnOn: z.enum(['floor', 'ceiling']).default('floor'),
+    cutsPrimary: z.boolean().default(true),
+    cutsAdjacent: z.boolean().default(true),
+}).describe('Level-local opening intent. Floor openings cut the floor and ceiling below; ceiling openings cut the ceiling and floor above. A hosted mezzanine opening cuts only its plate.');