@pascal-app/core 0.1.12 → 0.2.0

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

@@ -18,6 +18,7 @@ export declare const SlabNode: z.ZodObject<{
     id: z.ZodDefault<z.ZodTemplateLiteral<`slab_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"slab">>;
     polygon: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    holes: z.ZodDefault<z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>>;
     elevation: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
 export type SlabNode = z.infer<typeof SlabNode>;

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

@@ -1 +1 @@
-{"version":3,"file":"slab.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/slab.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;iBAapB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}
+{"version":3,"file":"slab.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/slab.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;iBAcpB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}

package/dist/schema/nodes/slab.js

@@ -7,6 +7,7 @@ export const SlabNode = BaseNode.extend({
     // Specific props
     // Polygon boundary - array of [x, z] coordinates defining the slab
     polygon: z.array(z.tuple([z.number(), z.number()])),
+    holes: z.array(z.array(z.tuple([z.number(), z.number()]))).default([]),
     elevation: z.number().default(0.05), // Elevation in meters
 }).describe(dedent `
   Slab node - used to represent a slab/floor in the building

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

@@ -0,0 +1,40 @@
+import { z } from 'zod';
+export declare const WindowNode: 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.ZodJSONSchema>>;
+    id: z.ZodDefault<z.ZodTemplateLiteral<`window_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"window">>;
+    position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    rotation: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    side: z.ZodOptional<z.ZodEnum<{
+        front: "front";
+        back: "back";
+    }>>;
+    wallId: z.ZodOptional<z.ZodString>;
+    width: z.ZodDefault<z.ZodNumber>;
+    height: z.ZodDefault<z.ZodNumber>;
+    frameThickness: z.ZodDefault<z.ZodNumber>;
+    frameDepth: z.ZodDefault<z.ZodNumber>;
+    columnRatios: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+    rowRatios: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+    columnDividerThickness: z.ZodDefault<z.ZodNumber>;
+    rowDividerThickness: z.ZodDefault<z.ZodNumber>;
+    sill: z.ZodDefault<z.ZodBoolean>;
+    sillDepth: z.ZodDefault<z.ZodNumber>;
+    sillThickness: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type WindowNode = z.infer<typeof WindowNode>;
+//# sourceMappingURL=window.d.ts.map

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

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

package/dist/schema/nodes/window.js

@@ -0,0 +1,38 @@
+import dedent from 'dedent';
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base';
+export const WindowNode = BaseNode.extend({
+    id: objectId('window'),
+    type: nodeType('window'),
+    // Position in wall-local coordinate system (center of window)
+    position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
+    rotation: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
+    side: z.enum(['front', 'back']).optional(),
+    // Wall reference
+    wallId: z.string().optional(),
+    // Overall dimensions
+    width: z.number().default(1.5),
+    height: z.number().default(1.5),
+    // Frame
+    frameThickness: z.number().default(0.05),
+    frameDepth: z.number().default(0.07),
+    // Divisions — ratios allow non-uniform panes
+    // [0.5, 0.5] = two equal panes
+    // [0.6, 0.4] = one larger, one smaller
+    // [1] = single pane (no division)
+    columnRatios: z.array(z.number()).default([1]),
+    rowRatios: z.array(z.number()).default([1]),
+    columnDividerThickness: z.number().default(0.03),
+    rowDividerThickness: z.number().default(0.03),
+    // Sill
+    sill: z.boolean().default(true),
+    sillDepth: z.number().default(0.08),
+    sillThickness: z.number().default(0.03),
+}).describe(dedent `Window node - a parametric window placed on a wall
+  - position: center of the window in wall-local coordinate system
+  - width/height: overall outer dimensions
+  - frameThickness: width of the frame members
+  - frameDepth: how deep the frame sits within the wall
+  - columnRatios/rowRatios: pane division ratios
+  - sill: whether to show a window sill
+`);

package/dist/schema/types.d.ts

@@ -62,12 +62,15 @@ export declare const AnyNode: z.ZodDiscriminatedUnion<[z.ZodObject<{
         type: z.ZodDefault<z.ZodLiteral<"item">>;
         position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
         rotation: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+        scale: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
         side: z.ZodOptional<z.ZodEnum<{
             front: "front";
             back: "back";
         }>>;
+        children: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodTemplateLiteral<`item_${string}`>>>>;
         wallId: z.ZodOptional<z.ZodString>;
         wallT: z.ZodOptional<z.ZodNumber>;
+        collectionIds: z.ZodOptional<z.ZodArray<z.ZodCustom<`collection_${string}`, `collection_${string}`>>>;
         asset: z.ZodObject<{
             id: z.ZodString;
             category: z.ZodString;
@@ -76,13 +79,61 @@ export declare const AnyNode: z.ZodDiscriminatedUnion<[z.ZodObject<{
             src: z.ZodString;
             dimensions: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
             attachTo: z.ZodOptional<z.ZodEnum<{
-                ceiling: "ceiling";
                 wall: "wall";
                 "wall-side": "wall-side";
+                ceiling: "ceiling";
             }>>;
+            tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
             offset: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
             rotation: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
             scale: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+            surface: z.ZodOptional<z.ZodObject<{
+                height: z.ZodNumber;
+            }, z.core.$strip>>;
+            interactive: z.ZodOptional<z.ZodObject<{
+                controls: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"toggle">;
+                    label: z.ZodOptional<z.ZodString>;
+                    default: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"slider">;
+                    label: z.ZodString;
+                    min: z.ZodNumber;
+                    max: z.ZodNumber;
+                    step: z.ZodDefault<z.ZodNumber>;
+                    unit: z.ZodOptional<z.ZodString>;
+                    displayMode: z.ZodDefault<z.ZodEnum<{
+                        slider: "slider";
+                        stepper: "stepper";
+                        dial: "dial";
+                    }>>;
+                    default: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"temperature">;
+                    label: z.ZodDefault<z.ZodString>;
+                    min: z.ZodDefault<z.ZodNumber>;
+                    max: z.ZodDefault<z.ZodNumber>;
+                    unit: z.ZodDefault<z.ZodEnum<{
+                        C: "C";
+                        F: "F";
+                    }>>;
+                    default: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>], "kind">>>;
+                effects: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                    kind: z.ZodLiteral<"animation">;
+                    clips: z.ZodObject<{
+                        on: z.ZodOptional<z.ZodString>;
+                        off: z.ZodOptional<z.ZodString>;
+                        loop: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>;
+                }, z.core.$strip>, z.ZodObject<{
+                    kind: z.ZodLiteral<"light">;
+                    color: z.ZodDefault<z.ZodString>;
+                    intensityRange: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+                    distance: z.ZodOptional<z.ZodNumber>;
+                    offset: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+                }, z.core.$strip>], "kind">>>;
+            }, z.core.$strip>>;
         }, z.core.$strip>;
     }, z.core.$strip>], "type">>>;
 }, z.core.$strip>, z.ZodObject<{
@@ -179,12 +230,15 @@ export declare const AnyNode: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodDefault<z.ZodLiteral<"item">>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     rotation: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    scale: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     side: z.ZodOptional<z.ZodEnum<{
         front: "front";
         back: "back";
     }>>;
+    children: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodTemplateLiteral<`item_${string}`>>>>;
     wallId: z.ZodOptional<z.ZodString>;
     wallT: z.ZodOptional<z.ZodNumber>;
+    collectionIds: z.ZodOptional<z.ZodArray<z.ZodCustom<`collection_${string}`, `collection_${string}`>>>;
     asset: z.ZodObject<{
         id: z.ZodString;
         category: z.ZodString;
@@ -193,13 +247,61 @@ export declare const AnyNode: z.ZodDiscriminatedUnion<[z.ZodObject<{
         src: z.ZodString;
         dimensions: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
         attachTo: z.ZodOptional<z.ZodEnum<{
-            ceiling: "ceiling";
             wall: "wall";
             "wall-side": "wall-side";
+            ceiling: "ceiling";
         }>>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
         offset: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
         rotation: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
         scale: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+        surface: z.ZodOptional<z.ZodObject<{
+            height: z.ZodNumber;
+        }, z.core.$strip>>;
+        interactive: z.ZodOptional<z.ZodObject<{
+            controls: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"toggle">;
+                label: z.ZodOptional<z.ZodString>;
+                default: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"slider">;
+                label: z.ZodString;
+                min: z.ZodNumber;
+                max: z.ZodNumber;
+                step: z.ZodDefault<z.ZodNumber>;
+                unit: z.ZodOptional<z.ZodString>;
+                displayMode: z.ZodDefault<z.ZodEnum<{
+                    slider: "slider";
+                    stepper: "stepper";
+                    dial: "dial";
+                }>>;
+                default: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"temperature">;
+                label: z.ZodDefault<z.ZodString>;
+                min: z.ZodDefault<z.ZodNumber>;
+                max: z.ZodDefault<z.ZodNumber>;
+                unit: z.ZodDefault<z.ZodEnum<{
+                    C: "C";
+                    F: "F";
+                }>>;
+                default: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>], "kind">>>;
+            effects: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"animation">;
+                clips: z.ZodObject<{
+                    on: z.ZodOptional<z.ZodString>;
+                    off: z.ZodOptional<z.ZodString>;
+                    loop: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"light">;
+                color: z.ZodDefault<z.ZodString>;
+                intensityRange: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+                distance: z.ZodOptional<z.ZodNumber>;
+                offset: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+            }, z.core.$strip>], "kind">>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
     object: z.ZodDefault<z.ZodLiteral<"node">>;
@@ -240,6 +342,7 @@ export declare const AnyNode: z.ZodDiscriminatedUnion<[z.ZodObject<{
     id: z.ZodDefault<z.ZodTemplateLiteral<`slab_${string}`>>;
     type: z.ZodDefault<z.ZodLiteral<"slab">>;
     polygon: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    holes: z.ZodDefault<z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>>;
     elevation: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>, z.ZodObject<{
     object: z.ZodDefault<z.ZodLiteral<"node">>;
@@ -261,6 +364,7 @@ export declare const AnyNode: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodDefault<z.ZodLiteral<"ceiling">>;
     children: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodTemplateLiteral<`item_${string}`>>>>;
     polygon: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    holes: z.ZodDefault<z.ZodArray<z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>>>;
     height: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>, z.ZodObject<{
     object: z.ZodDefault<z.ZodLiteral<"node">>;
@@ -282,10 +386,44 @@ export declare const AnyNode: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodDefault<z.ZodLiteral<"roof">>;
     position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     rotation: z.ZodDefault<z.ZodNumber>;
-    length: z.ZodDefault<z.ZodNumber>;
-    height: z.ZodDefault<z.ZodNumber>;
-    leftWidth: z.ZodDefault<z.ZodNumber>;
-    rightWidth: z.ZodDefault<z.ZodNumber>;
+    children: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodTemplateLiteral<`rseg_${string}`>>>>;
+}, z.core.$strip>, 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.ZodJSONSchema>>;
+    id: z.ZodDefault<z.ZodTemplateLiteral<`rseg_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"roof-segment">>;
+    position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    rotation: z.ZodDefault<z.ZodNumber>;
+    roofType: z.ZodDefault<z.ZodEnum<{
+        hip: "hip";
+        gable: "gable";
+        shed: "shed";
+        gambrel: "gambrel";
+        dutch: "dutch";
+        mansard: "mansard";
+        flat: "flat";
+    }>>;
+    width: z.ZodDefault<z.ZodNumber>;
+    depth: z.ZodDefault<z.ZodNumber>;
+    wallHeight: z.ZodDefault<z.ZodNumber>;
+    roofHeight: z.ZodDefault<z.ZodNumber>;
+    wallThickness: z.ZodDefault<z.ZodNumber>;
+    deckThickness: z.ZodDefault<z.ZodNumber>;
+    overhang: z.ZodDefault<z.ZodNumber>;
+    shingleThickness: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>, z.ZodObject<{
     object: z.ZodDefault<z.ZodLiteral<"node">>;
     name: z.ZodOptional<z.ZodString>;
@@ -332,6 +470,103 @@ export declare const AnyNode: z.ZodDiscriminatedUnion<[z.ZodObject<{
     rotation: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
     scale: z.ZodDefault<z.ZodNumber>;
     opacity: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>, 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.ZodJSONSchema>>;
+    id: z.ZodDefault<z.ZodTemplateLiteral<`window_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"window">>;
+    position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    rotation: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    side: z.ZodOptional<z.ZodEnum<{
+        front: "front";
+        back: "back";
+    }>>;
+    wallId: z.ZodOptional<z.ZodString>;
+    width: z.ZodDefault<z.ZodNumber>;
+    height: z.ZodDefault<z.ZodNumber>;
+    frameThickness: z.ZodDefault<z.ZodNumber>;
+    frameDepth: z.ZodDefault<z.ZodNumber>;
+    columnRatios: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+    rowRatios: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+    columnDividerThickness: z.ZodDefault<z.ZodNumber>;
+    rowDividerThickness: z.ZodDefault<z.ZodNumber>;
+    sill: z.ZodDefault<z.ZodBoolean>;
+    sillDepth: z.ZodDefault<z.ZodNumber>;
+    sillThickness: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>, 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.ZodJSONSchema>>;
+    id: z.ZodDefault<z.ZodTemplateLiteral<`door_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"door">>;
+    position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    rotation: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    side: z.ZodOptional<z.ZodEnum<{
+        front: "front";
+        back: "back";
+    }>>;
+    wallId: z.ZodOptional<z.ZodString>;
+    width: z.ZodDefault<z.ZodNumber>;
+    height: z.ZodDefault<z.ZodNumber>;
+    frameThickness: z.ZodDefault<z.ZodNumber>;
+    frameDepth: z.ZodDefault<z.ZodNumber>;
+    threshold: z.ZodDefault<z.ZodBoolean>;
+    thresholdHeight: z.ZodDefault<z.ZodNumber>;
+    hingesSide: z.ZodDefault<z.ZodEnum<{
+        left: "left";
+        right: "right";
+    }>>;
+    swingDirection: z.ZodDefault<z.ZodEnum<{
+        inward: "inward";
+        outward: "outward";
+    }>>;
+    segments: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        type: z.ZodEnum<{
+            panel: "panel";
+            glass: "glass";
+            empty: "empty";
+        }>;
+        heightRatio: z.ZodNumber;
+        columnRatios: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+        dividerThickness: z.ZodDefault<z.ZodNumber>;
+        panelDepth: z.ZodDefault<z.ZodNumber>;
+        panelInset: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    handle: z.ZodDefault<z.ZodBoolean>;
+    handleHeight: z.ZodDefault<z.ZodNumber>;
+    handleSide: z.ZodDefault<z.ZodEnum<{
+        left: "left";
+        right: "right";
+    }>>;
+    contentPadding: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    doorCloser: z.ZodDefault<z.ZodBoolean>;
+    panicBar: z.ZodDefault<z.ZodBoolean>;
+    panicBarHeight: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>], "type">;
 export type AnyNode = z.infer<typeof AnyNode>;
 export type AnyNodeType = AnyNode['type'];

package/dist/schema/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/schema/types.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAA;AAanB,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAYlB,CAAA;AAEF,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC,CAAA;AAC7C,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;AACzC,MAAM,MAAM,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/schema/types.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,KAAK,CAAA;AAgBnB,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2BAelB,CAAA;AAEF,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,OAAO,CAAC,CAAA;AAC7C,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;AACzC,MAAM,MAAM,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA"}

package/dist/schema/types.js

@@ -1,14 +1,17 @@
 import z from 'zod';
 import { BuildingNode } from './nodes/building';
 import { CeilingNode } from './nodes/ceiling';
+import { DoorNode } from './nodes/door';
 import { GuideNode } from './nodes/guide';
 import { ItemNode } from './nodes/item';
 import { LevelNode } from './nodes/level';
 import { RoofNode } from './nodes/roof';
+import { RoofSegmentNode } from './nodes/roof-segment';
 import { ScanNode } from './nodes/scan';
 import { SiteNode } from './nodes/site';
 import { SlabNode } from './nodes/slab';
 import { WallNode } from './nodes/wall';
+import { WindowNode } from './nodes/window';
 import { ZoneNode } from './nodes/zone';
 export const AnyNode = z.discriminatedUnion('type', [
     SiteNode,
@@ -20,6 +23,9 @@ export const AnyNode = z.discriminatedUnion('type', [
     SlabNode,
     CeilingNode,
     RoofNode,
+    RoofSegmentNode,
     ScanNode,
     GuideNode,
+    WindowNode,
+    DoorNode,
 ]);

package/dist/store/actions/node-actions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node-actions.d.ts","sourceRoot":"","sources":["../../../src/store/actions/node-actions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AACtD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAI9C,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,KAAK;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE,EAAE,SA2C/C,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,SAAS;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,EAAE,SAoDrD,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,KAAK,SAAS,EAAE,SA2CjB,CAAA"}
+{"version":3,"file":"node-actions.d.ts","sourceRoot":"","sources":["../../../src/store/actions/node-actions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAEtD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAI9C,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,KAAK;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE,EAAE,SA2C/C,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,SAAS;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,EAAE,SAoDrD,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,KAAK,SAAS,EAAE,SA+DjB,CAAA"}

package/dist/store/actions/node-actions.js

@@ -87,6 +87,7 @@ export const deleteNodesAction = (set, get, ids) => {
     const parentsToMarkDirty = new Set();
     set((state) => {
         const nextNodes = { ...state.nodes };
+        const nextCollections = { ...state.collections };
         let nextRootIds = [...state.rootNodeIds];
         for (const id of ids) {
             const node = nextNodes[id];
@@ -106,7 +107,16 @@ export const deleteNodesAction = (set, get, ids) => {
             }
             // 2. Remove from Root list
             nextRootIds = nextRootIds.filter((rid) => rid !== id);
-            // 3. Delete the node itself
+            // 3. Remove from any collections it belongs to
+            if ('collectionIds' in node && node.collectionIds) {
+                for (const cid of node.collectionIds) {
+                    const col = nextCollections[cid];
+                    if (col) {
+                        nextCollections[cid] = { ...col, nodeIds: col.nodeIds.filter((nid) => nid !== id) };
+                    }
+                }
+            }
+            // 4. Delete the node itself
             delete nextNodes[id];
             // Inside the deleteNodes loop
             if ('children' in node && node.children.length > 0) {
@@ -114,8 +124,17 @@ export const deleteNodesAction = (set, get, ids) => {
                 get().deleteNodes(node.children);
             }
         }
-        return { nodes: nextNodes, rootNodeIds: nextRootIds };
+        return { nodes: nextNodes, rootNodeIds: nextRootIds, collections: nextCollections };
+    });
+    // Mark affected nodes dirty: parents of deleted nodes and their remaining children
+    // (e.g. deleting a slab affects sibling walls via level elevation changes)
+    parentsToMarkDirty.forEach((parentId) => {
+        get().markDirty(parentId);
+        const parent = get().nodes[parentId];
+        if (parent && 'children' in parent && Array.isArray(parent.children)) {
+            for (const childId of parent.children) {
+                get().markDirty(childId);
+            }
+        }
     });
-    // Notify systems that the parent has changed (e.g. Wall needs to fill a window hole)
-    parentsToMarkDirty.forEach((pId) => get().markDirty(pId));
 };

package/dist/store/use-interactive.d.ts

@@ -0,0 +1,18 @@
+import type { Interactive } from '../schema/nodes/item';
+import type { AnyNodeId } from '../schema/types';
+export type ControlValue = boolean | number;
+export type ItemInteractiveState = {
+    controlValues: ControlValue[];
+};
+type InteractiveStore = {
+    items: Record<AnyNodeId, ItemInteractiveState>;
+    /** Initialize a node's interactive state from its asset definition (idempotent) */
+    initItem: (itemId: AnyNodeId, interactive: Interactive) => void;
+    /** Set a single control value */
+    setControlValue: (itemId: AnyNodeId, index: number, value: ControlValue) => void;
+    /** Remove a node's state (e.g. on unmount) */
+    removeItem: (itemId: AnyNodeId) => void;
+};
+export declare const useInteractive: import("zustand").UseBoundStore<import("zustand").StoreApi<InteractiveStore>>;
+export {};
+//# sourceMappingURL=use-interactive.d.ts.map

package/dist/store/use-interactive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-interactive.d.ts","sourceRoot":"","sources":["../../src/store/use-interactive.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AACvD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAGhD,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,MAAM,CAAA;AAE3C,MAAM,MAAM,oBAAoB,GAAG;IAEjC,aAAa,EAAE,YAAY,EAAE,CAAA;CAC9B,CAAA;AAED,KAAK,gBAAgB,GAAG;IACtB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,oBAAoB,CAAC,CAAA;IAE9C,mFAAmF;IACnF,QAAQ,EAAE,CAAC,MAAM,EAAE,SAAS,EAAE,WAAW,EAAE,WAAW,KAAK,IAAI,CAAA;IAE/D,iCAAiC;IACjC,eAAe,EAAE,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,KAAK,IAAI,CAAA;IAEhF,8CAA8C;IAC9C,UAAU,EAAE,CAAC,MAAM,EAAE,SAAS,KAAK,IAAI,CAAA;CACxC,CAAA;AAeD,eAAO,MAAM,cAAc,+EAoCxB,CAAA"}

package/dist/store/use-interactive.js

@@ -0,0 +1,50 @@
+'use client';
+import { create } from 'zustand';
+const defaultControlValue = (interactive, index) => {
+    const control = interactive.controls[index];
+    if (!control)
+        return false;
+    switch (control.kind) {
+        case 'toggle':
+            return control.default ?? false;
+        case 'slider':
+            return control.default ?? control.min;
+        case 'temperature':
+            return control.default ?? control.min;
+    }
+};
+export const useInteractive = create((set, get) => ({
+    items: {},
+    initItem: (itemId, interactive) => {
+        const { controls } = interactive;
+        if (controls.length === 0)
+            return;
+        // Don't overwrite existing state (idempotent)
+        if (get().items[itemId])
+            return;
+        set((state) => ({
+            items: {
+                ...state.items,
+                [itemId]: {
+                    controlValues: controls.map((_, i) => defaultControlValue(interactive, i)),
+                },
+            },
+        }));
+    },
+    setControlValue: (itemId, index, value) => {
+        set((state) => {
+            const item = state.items[itemId];
+            if (!item)
+                return state;
+            const next = [...item.controlValues];
+            next[index] = value;
+            return { items: { ...state.items, [itemId]: { controlValues: next } } };
+        });
+    },
+    removeItem: (itemId) => {
+        set((state) => {
+            const { [itemId]: _, ...rest } = state.items;
+            return { items: rest };
+        });
+    },
+}));

package/dist/store/use-scene.d.ts

@@ -1,12 +1,15 @@
 import type { TemporalState } from 'zundo';
 import { type StoreApi, type UseBoundStore } from 'zustand';
+import type { Collection, CollectionId } from '../schema/collections';
 import type { AnyNode, AnyNodeId } from '../schema/types';
 export type SceneState = {
     nodes: Record<AnyNodeId, AnyNode>;
     rootNodeIds: AnyNodeId[];
     dirtyNodes: Set<AnyNodeId>;
+    collections: Record<CollectionId, Collection>;
     loadScene: () => void;
     clearScene: () => void;
+    unloadScene: () => void;
     setScene: (nodes: Record<AnyNodeId, AnyNode>, rootNodeIds: AnyNodeId[]) => void;
     markDirty: (id: AnyNodeId) => void;
     clearDirty: (id: AnyNodeId) => void;
@@ -22,10 +25,16 @@ export type SceneState = {
     }[]) => void;
     deleteNode: (id: AnyNodeId) => void;
     deleteNodes: (ids: AnyNodeId[]) => void;
+    createCollection: (name: string, nodeIds?: AnyNodeId[]) => CollectionId;
+    deleteCollection: (id: CollectionId) => void;
+    updateCollection: (id: CollectionId, data: Partial<Omit<Collection, 'id'>>) => void;
+    addToCollection: (id: CollectionId, nodeId: AnyNodeId) => void;
+    removeFromCollection: (id: CollectionId, nodeId: AnyNodeId) => void;
 };
 type UseSceneStore = UseBoundStore<StoreApi<SceneState>> & {
-    temporal: StoreApi<TemporalState<Pick<SceneState, 'nodes' | 'rootNodeIds'>>>;
+    temporal: StoreApi<TemporalState<Pick<SceneState, 'nodes' | 'rootNodeIds' | 'collections'>>>;
 };
 declare const useScene: UseSceneStore;
 export default useScene;
+export declare function clearSceneHistory(): void;
 //# sourceMappingURL=use-scene.d.ts.map

package/dist/store/use-scene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-scene.d.ts","sourceRoot":"","sources":["../../src/store/use-scene.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAA;AAE1C,OAAO,EAAU,KAAK,QAAQ,EAAE,KAAK,aAAa,EAAE,MAAM,SAAS,CAAA;AAKnE,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAIzD,MAAM,MAAM,UAAU,GAAG;IAEvB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IAGjC,WAAW,EAAE,SAAS,EAAE,CAAA;IAGxB,UAAU,EAAE,GAAG,CAAC,SAAS,CAAC,CAAA;IAG1B,SAAS,EAAE,MAAM,IAAI,CAAA;IACrB,UAAU,EAAE,MAAM,IAAI,CAAA;IACtB,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EAAE,WAAW,EAAE,SAAS,EAAE,KAAK,IAAI,CAAA;IAE/E,SAAS,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,CAAA;IAClC,UAAU,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,CAAA;IAEnC,UAAU,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,SAAS,KAAK,IAAI,CAAA;IACzD,WAAW,EAAE,CAAC,GAAG,EAAE;QAAE,IAAI,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;KAAE,EAAE,KAAK,IAAI,CAAA;IAErE,UAAU,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,KAAK,IAAI,CAAA;IAC3D,WAAW,EAAE,CAAC,OAAO,EAAE;QAAE,EAAE,EAAE,SAAS,CAAC;QAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,EAAE,KAAK,IAAI,CAAA;IAE3E,UAAU,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,CAAA;IACnC,WAAW,EAAE,CAAC,GAAG,EAAE,SAAS,EAAE,KAAK,IAAI,CAAA;CACxC,CAAA;AAID,KAAK,aAAa,GAAG,aAAa,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,GAAG;IACzD,QAAQ,EAAE,QAAQ,CAAC,aAAa,CAAC,IAAI,CAAC,UAAU,EAAE,OAAO,GAAG,aAAa,CAAC,CAAC,CAAC,CAAA;CAC7E,CAAA;AAED,QAAA,MAAM,QAAQ,EAAE,aA6Jf,CAAA;AAED,eAAe,QAAQ,CAAA"}
+{"version":3,"file":"use-scene.d.ts","sourceRoot":"","sources":["../../src/store/use-scene.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAA;AAE1C,OAAO,EAAU,KAAK,QAAQ,EAAE,KAAK,aAAa,EAAE,MAAM,SAAS,CAAA;AAEnE,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAIrE,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AA8CzD,MAAM,MAAM,UAAU,GAAG;IAEvB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IAGjC,WAAW,EAAE,SAAS,EAAE,CAAA;IAGxB,UAAU,EAAE,GAAG,CAAC,SAAS,CAAC,CAAA;IAG1B,WAAW,EAAE,MAAM,CAAC,YAAY,EAAE,UAAU,CAAC,CAAA;IAG7C,SAAS,EAAE,MAAM,IAAI,CAAA;IACrB,UAAU,EAAE,MAAM,IAAI,CAAA;IACtB,WAAW,EAAE,MAAM,IAAI,CAAA;IACvB,QAAQ,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EAAE,WAAW,EAAE,SAAS,EAAE,KAAK,IAAI,CAAA;IAE/E,SAAS,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,CAAA;IAClC,UAAU,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,CAAA;IAEnC,UAAU,EAAE,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,SAAS,KAAK,IAAI,CAAA;IACzD,WAAW,EAAE,CAAC,GAAG,EAAE;QAAE,IAAI,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;KAAE,EAAE,KAAK,IAAI,CAAA;IAErE,UAAU,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,KAAK,IAAI,CAAA;IAC3D,WAAW,EAAE,CAAC,OAAO,EAAE;QAAE,EAAE,EAAE,SAAS,CAAC;QAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;KAAE,EAAE,KAAK,IAAI,CAAA;IAE3E,UAAU,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,IAAI,CAAA;IACnC,WAAW,EAAE,CAAC,GAAG,EAAE,SAAS,EAAE,KAAK,IAAI,CAAA;IAGvC,gBAAgB,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,SAAS,EAAE,KAAK,YAAY,CAAA;IACvE,gBAAgB,EAAE,CAAC,EAAE,EAAE,YAAY,KAAK,IAAI,CAAA;IAC5C,gBAAgB,EAAE,CAAC,EAAE,EAAE,YAAY,EAAE,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,CAAC,KAAK,IAAI,CAAA;IACnF,eAAe,EAAE,CAAC,EAAE,EAAE,YAAY,EAAE,MAAM,EAAE,SAAS,KAAK,IAAI,CAAA;IAC9D,oBAAoB,EAAE,CAAC,EAAE,EAAE,YAAY,EAAE,MAAM,EAAE,SAAS,KAAK,IAAI,CAAA;CACpE,CAAA;AAID,KAAK,aAAa,GAAG,aAAa,CAAC,QAAQ,CAAC,UAAU,CAAC,CAAC,GAAG;IACzD,QAAQ,EAAE,QAAQ,CAAC,aAAa,CAAC,IAAI,CAAC,UAAU,EAAE,OAAO,GAAG,aAAa,GAAG,aAAa,CAAC,CAAC,CAAC,CAAA;CAC7F,CAAA;AAED,QAAA,MAAM,QAAQ,EAAE,aAqMf,CAAA;AAED,eAAe,QAAQ,CAAA;AAOvB,wBAAgB,iBAAiB,SAKhC"}