@pascal-app/core 1.0.1 → 1.0.4

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.');

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

@@ -23,6 +23,32 @@ export declare const GuideNode: 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<`guide_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"guide">>;
     url: z.ZodString;

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

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

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

@@ -37,6 +37,32 @@ export declare const GutterNode: 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<`gutter_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"gutter">>;
     material: z.ZodOptional<z.ZodObject<{

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,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"}

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

@@ -29,6 +29,32 @@ export declare const HvacEquipmentNode: 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<`hvac-equipment_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"hvac-equipment">>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;

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

@@ -1 +1 @@
-{"version":3,"file":"hvac-equipment.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/hvac-equipment.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyC7B,CAAA;AACD,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AACjE,MAAM,MAAM,mBAAmB,GAAG,iBAAiB,CAAC,IAAI,CAAC,CAAA"}
+{"version":3,"file":"hvac-equipment.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/hvac-equipment.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyC7B,CAAA;AACD,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AACjE,MAAM,MAAM,mBAAmB,GAAG,iBAAiB,CAAC,IAAI,CAAC,CAAA"}

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

@@ -24,6 +24,32 @@ export declare const ImportedMeshNode: 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<`imesh_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"imported-mesh">>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;

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

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

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

@@ -59,6 +59,11 @@ declare const controlSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
 }, z.core.$strip>], "kind">;
 declare const animationEffectSchema: z.ZodObject<{
     kind: z.ZodLiteral<"animation">;
+    mode: z.ZodOptional<z.ZodEnum<{
+        ambient: "ambient";
+        "open-close": "open-close";
+    }>>;
+    control: z.ZodOptional<z.ZodNumber>;
     clips: z.ZodObject<{
         on: z.ZodOptional<z.ZodString>;
         off: z.ZodOptional<z.ZodString>;
@@ -74,6 +79,11 @@ declare const lightEffectSchema: z.ZodObject<{
 }, z.core.$strip>;
 declare const effectSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"animation">;
+    mode: z.ZodOptional<z.ZodEnum<{
+        ambient: "ambient";
+        "open-close": "open-close";
+    }>>;
+    control: z.ZodOptional<z.ZodNumber>;
     clips: z.ZodObject<{
         on: z.ZodOptional<z.ZodString>;
         off: z.ZodOptional<z.ZodString>;
@@ -117,6 +127,11 @@ declare const interactiveSchema: z.ZodObject<{
     }, z.core.$strip>], "kind">>>;
     effects: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"animation">;
+        mode: z.ZodOptional<z.ZodEnum<{
+            ambient: "ambient";
+            "open-close": "open-close";
+        }>>;
+        control: z.ZodOptional<z.ZodNumber>;
         clips: z.ZodObject<{
             on: z.ZodOptional<z.ZodString>;
             off: z.ZodOptional<z.ZodString>;
@@ -197,6 +212,11 @@ declare const assetSchema: z.ZodObject<{
         }, z.core.$strip>], "kind">>>;
         effects: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
             kind: z.ZodLiteral<"animation">;
+            mode: z.ZodOptional<z.ZodEnum<{
+                ambient: "ambient";
+                "open-close": "open-close";
+            }>>;
+            control: z.ZodOptional<z.ZodNumber>;
             clips: z.ZodObject<{
                 on: z.ZodOptional<z.ZodString>;
                 off: z.ZodOptional<z.ZodString>;
@@ -229,6 +249,32 @@ export declare const ItemNode: 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<`item_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"item">>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
@@ -243,15 +289,115 @@ export declare const ItemNode: z.ZodObject<{
     wallT: z.ZodOptional<z.ZodNumber>;
     roofSegmentId: z.ZodOptional<z.ZodString>;
     roofFace: z.ZodOptional<z.ZodEnum<{
+        left: "left";
+        right: "right";
         front: "front";
         back: "back";
-        right: "right";
-        left: "left";
     }>>;
     blockFaceId: z.ZodOptional<z.ZodString>;
     supportSlabId: z.ZodOptional<z.ZodString>;
     collectionIds: z.ZodOptional<z.ZodArray<z.ZodCustom<`collection_${string}`, `collection_${string}`>>>;
     slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    source: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodLiteral<"script">;
+        meta: z.ZodOptional<z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            category: z.ZodOptional<z.ZodString>;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            parent: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        language: z.ZodDefault<z.ZodEnum<{
+            three: "three";
+            bpy: "bpy";
+        }>>;
+        script: z.ZodString;
+        params: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean, z.ZodString]>>>;
+        artifact: z.ZodString;
+        manifest: z.ZodObject<{
+            bounds: z.ZodObject<{
+                min: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                max: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            }, z.core.$strip>;
+            params: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodOptional<z.ZodString>;
+                kind: z.ZodEnum<{
+                    string: "string";
+                    number: "number";
+                    boolean: "boolean";
+                }>;
+                default: z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean, z.ZodString]>;
+                min: z.ZodOptional<z.ZodNumber>;
+                max: z.ZodOptional<z.ZodNumber>;
+                step: z.ZodOptional<z.ZodNumber>;
+                unit: z.ZodOptional<z.ZodString>;
+                options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>>;
+            parts: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodOptional<z.ZodString>;
+                type: z.ZodOptional<z.ZodString>;
+                bounds: z.ZodOptional<z.ZodObject<{
+                    min: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                    max: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>>;
+            surfaces: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                part: z.ZodOptional<z.ZodString>;
+                y: z.ZodNumber;
+                polygon: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+            }, z.core.$strip>>>;
+            slots: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                label: z.ZodOptional<z.ZodString>;
+                color: z.ZodOptional<z.ZodString>;
+                roughness: z.ZodOptional<z.ZodNumber>;
+                metalness: z.ZodOptional<z.ZodNumber>;
+                transparent: z.ZodOptional<z.ZodBoolean>;
+                emissive: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>>;
+            anchors: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                normal: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+            }, z.core.$strip>>>;
+            lights: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+                color: z.ZodString;
+                intensity: z.ZodNumber;
+                distance: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>>;
+            undersides: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                part: z.ZodOptional<z.ZodString>;
+                polygon: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+                plane: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+            }, z.core.$strip>>>;
+            animations: z.ZodDefault<z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                duration: z.ZodNumber;
+            }, z.core.$strip>>>;
+            cutters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                host: z.ZodEnum<{
+                    wall: "wall";
+                    slab: "slab";
+                    ceiling: "ceiling";
+                    mounted: "mounted";
+                }>;
+                polygon: z.ZodArray<z.ZodArray<z.ZodNumber>>;
+                minY: z.ZodNumber;
+                maxY: z.ZodNumber;
+            }, z.core.$strip>>>;
+            cutout: z.ZodDefault<z.ZodBoolean>;
+            collider: z.ZodDefault<z.ZodBoolean>;
+            triangles: z.ZodNumber;
+        }, z.core.$strip>;
+        images: z.ZodOptional<z.ZodObject<{
+            artifact: z.ZodString;
+            thumbnail: z.ZodString;
+            floorPlan: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
     asset: z.ZodObject<{
         id: z.ZodString;
         category: z.ZodString;
@@ -311,6 +457,11 @@ export declare const ItemNode: z.ZodObject<{
             }, z.core.$strip>], "kind">>>;
             effects: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
                 kind: z.ZodLiteral<"animation">;
+                mode: z.ZodOptional<z.ZodEnum<{
+                    ambient: "ambient";
+                    "open-close": "open-close";
+                }>>;
+                control: z.ZodOptional<z.ZodNumber>;
                 clips: z.ZodObject<{
                     on: z.ZodOptional<z.ZodString>;
                     off: z.ZodOptional<z.ZodString>;

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

@@ -1 +1 @@
-{"version":3,"file":"item.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/item.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAOvB,QAAA,MAAM,mBAAmB;;;;iBAIvB,CAAA;AAEF,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;iBASvB,CAAA;AAEF,QAAA,MAAM,wBAAwB;;;;;;;;;;iBAO5B,CAAA;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAIjB,CAAA;AAIF,QAAA,MAAM,qBAAqB;;;;;;;iBAOzB,CAAA;AAEF,QAAA,MAAM,iBAAiB;;;;;;iBAMrB,CAAA;AAEF,QAAA,MAAM,YAAY;;;;;;;;;;;;;2BAA2E,CAAA;AAI7F,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGrB,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC/D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC/D,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AACzE,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AACnD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AACnE,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAC3D,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AACjD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2Cf,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AACpD,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAE/C,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4DnB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA;AAE/C,eAAO,MAAM,mCAAmC,MAAM,CAAA;AAEtD;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAM/D;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAI5E"}
+{"version":3,"file":"item.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/item.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAQvB,QAAA,MAAM,mBAAmB;;;;iBAIvB,CAAA;AAEF,QAAA,MAAM,mBAAmB;;;;;;;;;;;;;iBASvB,CAAA;AAEF,QAAA,MAAM,wBAAwB;;;;;;;;;;iBAO5B,CAAA;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAIjB,CAAA;AAIF,QAAA,MAAM,qBAAqB;;;;;;;;;;;;iBAezB,CAAA;AAEF,QAAA,MAAM,iBAAiB;;;;;;iBAMrB,CAAA;AAEF,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;2BAA2E,CAAA;AAI7F,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGrB,CAAA;AAEF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC/D,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAC/D,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AACzE,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AACnD,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAA;AACnE,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAC3D,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AACjD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA;AAE3D,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2Cf,CAAA;AAEF,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AACpD,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA;AAE/C,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiEnB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA;AAE/C,eAAO,MAAM,mCAAmC,MAAM,CAAA;AAEtD;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAM/D;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAI5E"}