@pascal-app/core 1.0.4 → 1.0.5

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

@@ -1,38 +1,9 @@
 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 { FenceBaseStyle, FenceStyle } from './fence-types.js';
 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";
+    cable: "cable";
 }>;
 export declare const FencePostCap: z.ZodEnum<{
     flat: "flat";
@@ -45,24 +16,24 @@ export declare const FenceSurfaceMode: z.ZodEnum<{
     selected: "selected";
 }>;
 export declare const FenceTransitionMode: z.ZodEnum<{
-    step: "step";
-    slope: "slope";
     break: "break";
+    slope: "slope";
+    step: "step";
 }>;
 export declare const FencePatternDistribution: z.ZodEnum<{
-    "maximum-spacing": "maximum-spacing";
-    "fixed-spacing": "fixed-spacing";
     automatic: "automatic";
-    "fixed-count": "fixed-count";
     "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<{
-        opening: "opening";
         gate: "gate";
+        opening: "opening";
     }>;
     center: z.ZodNumber;
     width: z.ZodNumber;
@@ -73,13 +44,13 @@ export declare const FenceFeature: z.ZodObject<{
         single: "single";
     }>>;
     style: z.ZodOptional<z.ZodEnum<{
-        match: "match";
-        slat: "slat";
-        rail: "rail";
-        privacy: "privacy";
-        horizontal: "horizontal";
         guard: "guard";
+        horizontal: "horizontal";
+        match: "match";
         picket: "picket";
+        privacy: "privacy";
+        rail: "rail";
+        slat: "slat";
     }>>;
     height: z.ZodOptional<z.ZodNumber>;
     clearance: z.ZodOptional<z.ZodNumber>;
@@ -98,9 +69,9 @@ export declare const FenceFeature: z.ZodObject<{
     openAngle: z.ZodOptional<z.ZodNumber>;
     leafSplit: z.ZodOptional<z.ZodNumber>;
     brace: z.ZodOptional<z.ZodEnum<{
-        none: "none";
         cross: "cross";
         diagonal: "diagonal";
+        none: "none";
     }>>;
     showHardware: z.ZodOptional<z.ZodBoolean>;
     showPosts: z.ZodOptional<z.ZodBoolean>;
@@ -114,8 +85,8 @@ 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>;
@@ -126,23 +97,23 @@ export declare const FenceNode: 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";
+                piece: "piece";
+                primary: "primary";
             }>>;
         }, z.core.$strip>>;
         lineage: z.ZodOptional<z.ZodObject<{
             op: z.ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
                 import: "import";
-                split: "split";
+                "make-independent": "make-independent";
                 merge: "merge";
-                duplicate: "duplicate";
-                convert: "convert";
                 promote: "promote";
-                "make-independent": "make-independent";
-                attach: "attach";
+                split: "split";
             }>;
             fromIds: z.ZodArray<z.ZodString>;
         }, z.core.$strip>>;
@@ -153,16 +124,16 @@ export declare const FenceNode: z.ZodObject<{
     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>;
@@ -171,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<{
@@ -188,8 +159,8 @@ export declare const FenceNode: z.ZodObject<{
     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";
+        straight: "straight";
     }>>>;
     tangents: z.ZodOptional<z.ZodArray<z.ZodNullable<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>>;
     height: z.ZodDefault<z.ZodNumber>;
@@ -203,9 +174,9 @@ export declare const FenceNode: z.ZodObject<{
         selected: "selected";
     }>>;
     transitionMode: z.ZodDefault<z.ZodEnum<{
-        step: "step";
-        slope: "slope";
         break: "break";
+        slope: "slope";
+        step: "step";
     }>>;
     transitionWidth: z.ZodDefault<z.ZodNumber>;
     curveOffset: z.ZodOptional<z.ZodNumber>;
@@ -213,16 +184,16 @@ export declare const FenceNode: z.ZodObject<{
     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";
+        "fixed-count": "fixed-count";
+        "fixed-spacing": "fixed-spacing";
+        "maximum-spacing": "maximum-spacing";
     }>>;
     patternAlignment: z.ZodDefault<z.ZodEnum<{
         center: "center";
-        start: "start";
         end: "end";
+        start: "start";
     }>>;
     patternCount: z.ZodDefault<z.ZodNumber>;
     patternRemainder: z.ZodDefault<z.ZodEnum<{
@@ -231,16 +202,16 @@ export declare const FenceNode: z.ZodObject<{
     }>>;
     picketWidth: z.ZodDefault<z.ZodNumber>;
     picketTop: z.ZodDefault<z.ZodEnum<{
+        "dog-ear": "dog-ear";
         flat: "flat";
-        rounded: "rounded";
         pointed: "pointed";
-        "dog-ear": "dog-ear";
+        rounded: "rounded";
     }>>;
     picketProfile: z.ZodDefault<z.ZodEnum<{
+        alternating: "alternating";
         arched: "arched";
         level: "level";
         scalloped: "scalloped";
-        alternating: "alternating";
     }>>;
     picketTopClearance: z.ZodDefault<z.ZodNumber>;
     picketVariation: z.ZodDefault<z.ZodNumber>;
@@ -264,25 +235,25 @@ export declare const FenceNode: z.ZodObject<{
     showInfill: z.ZodDefault<z.ZodBoolean>;
     guardInfill: z.ZodOptional<z.ZodEnum<{
         balusters: "balusters";
-        cable: "cable";
         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";
-        back: "back";
     }>>;
     color: z.ZodDefault<z.ZodString>;
     style: z.ZodDefault<z.ZodEnum<{
-        slat: "slat";
-        rail: "rail";
-        privacy: "privacy";
-        horizontal: "horizontal";
         guard: "guard";
+        horizontal: "horizontal";
         picket: "picket";
+        privacy: "privacy";
+        rail: "rail";
+        slat: "slat";
     }>>;
 }, z.core.$strip>;
 export type FenceGuardInfill = z.infer<typeof FenceGuardInfill>;

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;;;;;;;;;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"}
+{"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"}

package/dist/schema/nodes/fence.js

@@ -2,26 +2,9 @@ import dedent from 'dedent';
 import { z } from 'zod';
 import { BaseNode, nodeType, objectId } from '../base.js';
 import { MaterialSchema } from '../material.js';
-/**
- * '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']);
+import { FenceBaseStyle, FenceStyle } from './fence-types.js';
+export { FenceBaseStyle, FenceStyle } from './fence-types.js';
 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']);
@@ -94,7 +77,8 @@ export const FenceNode = BaseNode.extend({
     // 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.
+    // Manual vertical offset from the elected slab, shaped surface, or level
+    // support. Moves the complete fence body without changing its height.
     supportOffset: z.number().finite().optional(),
     surfaceMode: FenceSurfaceMode.default('auto'),
     transitionMode: FenceTransitionMode.default('slope'),

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

@@ -8,8 +8,8 @@ export declare const FloorOpeningNode: 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>;
@@ -20,23 +20,23 @@ export declare const FloorOpeningNode: 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";
+                piece: "piece";
+                primary: "primary";
             }>>;
         }, z.core.$strip>>;
         lineage: z.ZodOptional<z.ZodObject<{
             op: z.ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
                 import: "import";
-                split: "split";
+                "make-independent": "make-independent";
                 merge: "merge";
-                duplicate: "duplicate";
-                convert: "convert";
                 promote: "promote";
-                "make-independent": "make-independent";
-                attach: "attach";
+                split: "split";
             }>;
             fromIds: z.ZodArray<z.ZodString>;
         }, z.core.$strip>>;

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

@@ -16,8 +16,8 @@ export declare const GuideNode: 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>;
@@ -28,23 +28,23 @@ export declare const GuideNode: 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";
+                piece: "piece";
+                primary: "primary";
             }>>;
         }, z.core.$strip>>;
         lineage: z.ZodOptional<z.ZodObject<{
             op: z.ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
                 import: "import";
-                split: "split";
+                "make-independent": "make-independent";
                 merge: "merge";
-                duplicate: "duplicate";
-                convert: "convert";
                 promote: "promote";
-                "make-independent": "make-independent";
-                attach: "attach";
+                split: "split";
             }>;
             fromIds: z.ZodArray<z.ZodString>;
         }, z.core.$strip>>;

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

@@ -30,8 +30,8 @@ export declare const GutterNode: 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>;
@@ -42,23 +42,23 @@ export declare const GutterNode: 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";
+                piece: "piece";
+                primary: "primary";
             }>>;
         }, z.core.$strip>>;
         lineage: z.ZodOptional<z.ZodObject<{
             op: z.ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
                 import: "import";
-                split: "split";
+                "make-independent": "make-independent";
                 merge: "merge";
-                duplicate: "duplicate";
-                convert: "convert";
                 promote: "promote";
-                "make-independent": "make-independent";
-                attach: "attach";
+                split: "split";
             }>;
             fromIds: z.ZodArray<z.ZodString>;
         }, z.core.$strip>>;
@@ -68,16 +68,16 @@ export declare const GutterNode: z.ZodObject<{
     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>;
@@ -86,9 +86,9 @@ export declare const GutterNode: 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<{
@@ -112,8 +112,8 @@ export declare const GutterNode: z.ZodObject<{
     thickness: z.ZodDefault<z.ZodNumber>;
     profile: z.ZodDefault<z.ZodEnum<{
         box: "box";
-        "k-style": "k-style";
         "half-round": "half-round";
+        "k-style": "k-style";
     }>>;
     endCapLeft: z.ZodDefault<z.ZodBoolean>;
     endCapRight: z.ZodDefault<z.ZodBoolean>;

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

@@ -1 +1 @@
-{"version":3,"file":"gutter.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/gutter.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,OAAO,EAA4B,KAAK,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAO/E,eAAO,MAAM,uBAAuB,OAAO,CAAA;AAC3C,eAAO,MAAM,mBAAmB,OAAO,CAAA;AACvC,MAAM,MAAM,cAAc,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAA;AAEtD,MAAM,MAAM,SAAS,GAAG;IACtB,IAAI,EAAE,cAAc,CAAA;IACpB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,EAAE,cAAc,CAAA;IACpB,IAAI,EAAE,MAAM,CAAA;IACZ,EAAE,EAAE,MAAM,CAAA;CACX,CAAA;AAQD,eAAO,MAAM,YAAY;;;;;iBAWvB,CAAA;AACF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AAEvD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8EtB,CAAA;AAED,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA;AASnD,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,YAAY,GAAG,UAAU,GAAG,OAAO,GAAG,UAAU,CAAC,GAC/E,MAAM,CAKR;AAmND,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,eAAe,EACxB,YAAY,GAAE,SAAS,eAAe,EAAO,EAC7C,UAAU,GAAE,SAAS,mBAAmB,EAAO,GAC9C,SAAS,EAAE,CAkDb;AAED,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,eAAe,EACxB,YAAY,GAAE,SAAS,eAAe,EAAO,EAC7C,UAAU,GAAE,SAAS,mBAAmB,EAAO,GAC9C,UAAU,EAAE,CAcd;AAED,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,OAAO,EACb,aAAa,CAAC,EAAE,eAAe,CAAC,IAAI,CAAC,GACpC,cAAc,GAAG,IAAI,CAQvB;AAED,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,OAAO,EACb,aAAa,CAAC,EAAE,eAAe,CAAC,IAAI,CAAC,GACpC,IAAI,IAAI,UAAU,CAEpB;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,UAAU,CAAC,GAAG,OAAO,IAAI,IAAI,CAChG,eAAe,EACf,UAAU,CACX,GAAG;IACF,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;QAAE,UAAU,EAAE,OAAO,CAAA;KAAE,CAAA;CAC5D,CAEA;AAED,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,IAAI,GAAG,UAAU,GAAG,UAAU,CAAC,EAC9D,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,OAAO,CAKT"}
+{"version":3,"file":"gutter.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/gutter.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,OAAO,EAGL,KAAK,eAAe,EACrB,MAAM,gBAAgB,CAAA;AAOvB,eAAO,MAAM,uBAAuB,OAAO,CAAA;AAC3C,eAAO,MAAM,mBAAmB,OAAO,CAAA;AACvC,MAAM,MAAM,cAAc,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,GAAG,IAAI,CAAA;AAEtD,MAAM,MAAM,SAAS,GAAG;IACtB,IAAI,EAAE,cAAc,CAAA;IACpB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,EAAE,cAAc,CAAA;IACpB,IAAI,EAAE,MAAM,CAAA;IACZ,EAAE,EAAE,MAAM,CAAA;CACX,CAAA;AAQD,eAAO,MAAM,YAAY;;;;;iBAWvB,CAAA;AACF,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AAEvD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8EtB,CAAA;AAED,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA;AASnD,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,YAAY,GAAG,UAAU,GAAG,OAAO,GAAG,UAAU,CAAC,GAC/E,MAAM,CAKR;AAuND,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,eAAe,EACxB,YAAY,GAAE,SAAS,eAAe,EAAO,EAC7C,UAAU,GAAE,SAAS,mBAAmB,EAAO,GAC9C,SAAS,EAAE,CAkDb;AAED,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,eAAe,EACxB,YAAY,GAAE,SAAS,eAAe,EAAO,EAC7C,UAAU,GAAE,SAAS,mBAAmB,EAAO,GAC9C,UAAU,EAAE,CAcd;AAED,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,OAAO,EACb,aAAa,CAAC,EAAE,eAAe,CAAC,IAAI,CAAC,GACpC,cAAc,GAAG,IAAI,CAQvB;AAED,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,OAAO,EACb,aAAa,CAAC,EAAE,eAAe,CAAC,IAAI,CAAC,GACpC,IAAI,IAAI,UAAU,CAEpB;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,UAAU,CAAC,GAAG,OAAO,IAAI,IAAI,CAChG,eAAe,EACf,UAAU,CACX,GAAG;IACF,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG;QAAE,UAAU,EAAE,OAAO,CAAA;KAAE,CAAA;CAC5D,CAEA;AAED,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,IAAI,CAAC,eAAe,EAAE,IAAI,GAAG,UAAU,GAAG,UAAU,CAAC,EAC9D,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC9B,OAAO,CAKT"}

package/dist/schema/nodes/gutter.js

@@ -2,8 +2,8 @@ import dedent from 'dedent';
 import { z } from 'zod';
 import { BaseNode, nodeType, objectId } from '../base.js';
 import { MaterialSchema } from '../material.js';
-import { normalizeRoofSegmentTrim } from './roof-segment.js';
-import { getRoofShapeEaveSides } from './roof-segment-shape.js';
+import { getRoofSegmentEndReach, normalizeRoofSegmentTrim, } from './roof-segment.js';
+import { getRoofShapeEaveOverhang, getRoofShapeEaveSides } from './roof-segment-shape.js';
 const MIN_DEFAULT_GUTTER_LENGTH_M = 0.2;
 const DEFAULT_GUTTER_GENERATOR = 'default-gutter';
 const AUTO_GUTTER_METADATA_KEY = 'autoGutter';
@@ -105,7 +105,7 @@ export function computeGutterEaveY(segment) {
     if ((segment.roofType ?? 'gable') === 'flat')
         return wallHeight;
     const pitchRad = ((segment.pitch ?? 0) * Math.PI) / 180;
-    return wallHeight - (segment.overhang ?? 0) * Math.tan(pitchRad) + GUTTER_EAVE_TUCK_UP;
+    return wallHeight - getRoofShapeEaveOverhang(segment) * Math.tan(pitchRad) + GUTTER_EAVE_TUCK_UP;
 }
 function getDefaultGutterSides(segment) {
     return getRoofShapeEaveSides(segment.roofType);
@@ -113,8 +113,9 @@ function getDefaultGutterSides(segment) {
 function getGutterEnvelope(segment) {
     const halfW = Math.max(0, segment.width) / 2;
     const halfD = Math.max(0, segment.depth) / 2;
-    const overhang = Math.max(0, segment.overhang ?? 0);
-    const outerHalfW = Math.max(halfW, halfW + overhang - GUTTER_EAVE_TUCK_INWARD);
+    const overhang = Math.max(0, getRoofShapeEaveOverhang(segment));
+    // an eave gutter runs out to the rakes, as far as they reach
+    const outerHalfW = Math.max(halfW, halfW + getRoofSegmentEndReach(segment) - GUTTER_EAVE_TUCK_INWARD);
     const outerHalfD = Math.max(halfD, halfD + overhang - GUTTER_EAVE_TUCK_INWARD);
     const trim = normalizeRoofSegmentTrim(segment);
     const minX = trim.left > 0 ? -halfW + trim.left : -outerHalfW;

package/dist/schema/nodes/hvac-equipment.d.ts

@@ -22,8 +22,8 @@ export declare const HvacEquipmentNode: 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>;
@@ -34,23 +34,23 @@ export declare const HvacEquipmentNode: 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";
+                piece: "piece";
+                primary: "primary";
             }>>;
         }, z.core.$strip>>;
         lineage: z.ZodOptional<z.ZodObject<{
             op: z.ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
                 import: "import";
-                split: "split";
+                "make-independent": "make-independent";
                 merge: "merge";
-                duplicate: "duplicate";
-                convert: "convert";
                 promote: "promote";
-                "make-independent": "make-independent";
-                attach: "attach";
+                split: "split";
             }>;
             fromIds: z.ZodArray<z.ZodString>;
         }, z.core.$strip>>;
@@ -61,22 +61,22 @@ export declare const HvacEquipmentNode: z.ZodObject<{
     rotation: z.ZodDefault<z.ZodNumber>;
     supportSlabId: z.ZodOptional<z.ZodString>;
     equipmentType: z.ZodDefault<z.ZodEnum<{
-        furnace: "furnace";
         "air-handler": "air-handler";
         condenser: "condenser";
+        furnace: "furnace";
     }>>;
     width: z.ZodDefault<z.ZodNumber>;
     depth: z.ZodDefault<z.ZodNumber>;
     height: z.ZodDefault<z.ZodNumber>;
     supplyShape: z.ZodDefault<z.ZodEnum<{
-        round: "round";
-        rect: "rect";
         oval: "oval";
+        rect: "rect";
+        round: "round";
     }>>;
     returnShape: z.ZodDefault<z.ZodEnum<{
-        round: "round";
-        rect: "rect";
         oval: "oval";
+        rect: "rect";
+        round: "round";
     }>>;
     supplyDiameter: z.ZodDefault<z.ZodNumber>;
     returnDiameter: z.ZodDefault<z.ZodNumber>;

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

@@ -17,8 +17,8 @@ export declare const ImportedMeshNode: 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>;
@@ -29,23 +29,23 @@ export declare const ImportedMeshNode: 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";
+                piece: "piece";
+                primary: "primary";
             }>>;
         }, z.core.$strip>>;
         lineage: z.ZodOptional<z.ZodObject<{
             op: z.ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
                 import: "import";
-                split: "split";
+                "make-independent": "make-independent";
                 merge: "merge";
-                duplicate: "duplicate";
-                convert: "convert";
                 promote: "promote";
-                "make-independent": "make-independent";
-                attach: "attach";
+                split: "split";
             }>;
             fromIds: z.ZodArray<z.ZodString>;
         }, z.core.$strip>>;