@pascal-app/core 0.1.3

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

@@ -0,0 +1,25 @@
+import { z } from 'zod';
+export declare const CeilingNode: 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<`ceiling_${string}`>>;
+    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>>;
+    height: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type CeilingNode = z.infer<typeof CeilingNode>;
+//# sourceMappingURL=ceiling.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ceiling.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/ceiling.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;iBAavB,CAAA;AAED,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAA"}

package/dist/schema/nodes/ceiling.js

@@ -0,0 +1,16 @@
+import dedent from 'dedent';
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base';
+import { ItemNode } from './item';
+export const CeilingNode = BaseNode.extend({
+    id: objectId('ceiling'),
+    type: nodeType('ceiling'),
+    children: z.array(ItemNode.shape.id).default([]),
+    // Specific props
+    // Polygon boundary - array of [x, z] coordinates defining the ceiling
+    polygon: z.array(z.tuple([z.number(), z.number()])),
+    height: z.number().default(2.5), // Height in meters
+}).describe(dedent `
+  Ceiling node - used to represent a ceiling in the building
+  - polygon: array of [x, z] points defining the ceiling boundary
+  `);

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

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+export declare const GuideNode: 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<`guide_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"guide">>;
+    url: z.ZodString;
+    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.ZodNumber>;
+    opacity: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type GuideNode = z.infer<typeof GuideNode>;
+//# sourceMappingURL=guide.d.ts.map

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

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

package/dist/schema/nodes/guide.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base';
+export const GuideNode = BaseNode.extend({
+    id: objectId('guide'),
+    type: nodeType('guide'),
+    url: z.string(),
+    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]),
+    scale: z.number().default(1),
+    opacity: z.number().min(0).max(100).default(50),
+});

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

@@ -0,0 +1,65 @@
+import { z } from 'zod';
+declare const assetSchema: z.ZodObject<{
+    id: z.ZodString;
+    category: z.ZodString;
+    name: z.ZodString;
+    thumbnail: z.ZodString;
+    src: z.ZodString;
+    dimensions: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    attachTo: z.ZodOptional<z.ZodEnum<{
+        wall: "wall";
+        "wall-side": "wall-side";
+        ceiling: "ceiling";
+    }>>;
+    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>>;
+}, z.core.$strip>;
+export type AssetInput = z.input<typeof assetSchema>;
+export type Asset = z.infer<typeof assetSchema>;
+export declare const ItemNode: 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<`item_${string}`>>;
+    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>>;
+    side: z.ZodOptional<z.ZodEnum<{
+        front: "front";
+        back: "back";
+    }>>;
+    wallId: z.ZodOptional<z.ZodString>;
+    wallT: z.ZodOptional<z.ZodNumber>;
+    asset: z.ZodObject<{
+        id: z.ZodString;
+        category: z.ZodString;
+        name: z.ZodString;
+        thumbnail: z.ZodString;
+        src: z.ZodString;
+        dimensions: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+        attachTo: z.ZodOptional<z.ZodEnum<{
+            wall: "wall";
+            "wall-side": "wall-side";
+            ceiling: "ceiling";
+        }>>;
+        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>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type ItemNode = z.infer<typeof ItemNode>;
+export {};
+//# sourceMappingURL=item.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"item.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/item.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;iBAYf,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuBnB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}

package/dist/schema/nodes/item.js

@@ -0,0 +1,38 @@
+import dedent from 'dedent';
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base';
+const assetSchema = z.object({
+    id: z.string(),
+    category: z.string(),
+    name: z.string(),
+    thumbnail: z.string(),
+    src: z.string(),
+    dimensions: z.tuple([z.number(), z.number(), z.number()]).default([1, 1, 1]), // [w, h, d]
+    attachTo: z.enum(['wall', 'wall-side', 'ceiling']).optional(),
+    // These are "Corrective" transforms to normalize the GLB
+    offset: 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]),
+    scale: z.tuple([z.number(), z.number(), z.number()]).default([1, 1, 1]),
+});
+export const ItemNode = BaseNode.extend({
+    id: objectId('item'),
+    type: nodeType('item'),
+    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 attachment properties (only used when asset.attachTo is "wall" or "wall-side")
+    wallId: z.string().optional(),
+    wallT: z.number().optional(), // 0-1 parametric position along wall
+    asset: assetSchema,
+}).describe(dedent `Item node - used to represent a item in the building
+  - position: position in level coordinate system (or parent coordinate system if attached)
+  - rotation: rotation in level coordinate system (or parent coordinate system if attached)
+  - asset: asset data
+    - category: category of the item
+    - dimensions: size in level coordinate system
+    - src: url of the model
+    - attachTo: where to attach the item (wall, wall-side, ceiling)
+    - offset: corrective position offset for the model
+    - rotation: corrective rotation for the model
+    - scale: corrective scale for the model
+`);

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

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+export declare const LevelNode: 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<`level_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"level">>;
+    children: z.ZodDefault<z.ZodArray<z.ZodUnion<readonly [z.ZodDefault<z.ZodTemplateLiteral<`wall_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`zone_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`slab_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`ceiling_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`roof_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`scan_${string}`>>, z.ZodDefault<z.ZodTemplateLiteral<`guide_${string}`>>]>>>;
+    level: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type LevelNode = z.infer<typeof LevelNode>;
+//# sourceMappingURL=level.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"level.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/level.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAUvB,eAAO,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;iBAYrB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}

package/dist/schema/nodes/level.js

@@ -0,0 +1,21 @@
+import dedent from 'dedent';
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base';
+import { CeilingNode } from './ceiling';
+import { GuideNode } from './guide';
+import { RoofNode } from './roof';
+import { ScanNode } from './scan';
+import { SlabNode } from './slab';
+import { WallNode } from './wall';
+import { ZoneNode } from './zone';
+export const LevelNode = BaseNode.extend({
+    id: objectId('level'),
+    type: nodeType('level'),
+    children: z.array(z.union([WallNode.shape.id, ZoneNode.shape.id, SlabNode.shape.id, CeilingNode.shape.id, RoofNode.shape.id, ScanNode.shape.id, GuideNode.shape.id])).default([]),
+    // Specific props
+    level: z.number().default(0),
+}).describe(dedent `
+  Level node - used to represent a level in the building
+  - children: array of floor, wall, ceiling, roof, item nodes
+  - level: level number
+  `);

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

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+export declare const RoofNode: 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<`roof_${string}`>>;
+    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>;
+}, z.core.$strip>;
+export type RoofNode = z.infer<typeof RoofNode>;
+//# sourceMappingURL=roof.d.ts.map

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

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

package/dist/schema/nodes/roof.js

@@ -0,0 +1,28 @@
+import dedent from 'dedent';
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base';
+export const RoofNode = BaseNode.extend({
+    id: objectId('roof'),
+    type: nodeType('roof'),
+    // Position of the roof center (Y should typically be 0)
+    position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
+    // Rotation around Y axis in radians
+    rotation: z.number().default(0),
+    // Length of the roof along the ridge direction (in meters)
+    length: z.number().default(4),
+    // Height of the roof peak from the base
+    height: z.number().default(1.5),
+    // Width of the left slope (in meters, measured horizontally from ridge)
+    leftWidth: z.number().default(1.5),
+    // Width of the right slope (in meters, measured horizontally from ridge)
+    rightWidth: z.number().default(1.5),
+}).describe(dedent `
+  Roof node - used to represent a gable roof in the building
+  - position: center position of the roof (Y typically 0)
+  - rotation: rotation around Y axis
+  - length: length of the roof along the ridge
+  - height: height of the roof peak
+  - leftWidth: horizontal width of the left slope (from ridge to eave)
+  - rightWidth: horizontal width of the right slope (from ridge to eave)
+  Total width = leftWidth + rightWidth
+  `);

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

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+export declare const ScanNode: 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<`scan_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"scan">>;
+    url: z.ZodString;
+    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.ZodNumber>;
+    opacity: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type ScanNode = z.infer<typeof ScanNode>;
+//# sourceMappingURL=scan.d.ts.map

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

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

package/dist/schema/nodes/scan.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base';
+export const ScanNode = BaseNode.extend({
+    id: objectId('scan'),
+    type: nodeType('scan'),
+    url: z.string(),
+    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]),
+    scale: z.number().default(1),
+    opacity: z.number().min(0).max(100).default(100),
+});

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

@@ -0,0 +1,90 @@
+import { z } from 'zod';
+export declare const SiteNode: 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<`site_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"site">>;
+    polygon: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        type: z.ZodLiteral<"polygon">;
+        points: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    }, z.core.$strip>>>;
+    children: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[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<`building_${string}`>>;
+        type: z.ZodDefault<z.ZodLiteral<"building">>;
+        children: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodTemplateLiteral<`level_${string}`>>>>;
+        position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+        rotation: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    }, 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<`item_${string}`>>;
+        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>>;
+        side: z.ZodOptional<z.ZodEnum<{
+            front: "front";
+            back: "back";
+        }>>;
+        wallId: z.ZodOptional<z.ZodString>;
+        wallT: z.ZodOptional<z.ZodNumber>;
+        asset: z.ZodObject<{
+            id: z.ZodString;
+            category: z.ZodString;
+            name: z.ZodString;
+            thumbnail: z.ZodString;
+            src: z.ZodString;
+            dimensions: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+            attachTo: z.ZodOptional<z.ZodEnum<{
+                wall: "wall";
+                "wall-side": "wall-side";
+                ceiling: "ceiling";
+            }>>;
+            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>>;
+        }, z.core.$strip>;
+    }, z.core.$strip>], "type">>>;
+}, z.core.$strip>;
+export type SiteNode = z.infer<typeof SiteNode>;
+//# sourceMappingURL=site.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"site.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/site.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAiBvB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwBpB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}

package/dist/schema/nodes/site.js

@@ -0,0 +1,39 @@
+// lib/scenegraph/schema/nodes/site.ts
+import dedent from 'dedent';
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base';
+import { BuildingNode } from './building';
+import { ItemNode } from './item';
+// 2D Polygon
+const PropertyLineData = z.object({
+    type: z.literal('polygon'),
+    points: z.array(z.tuple([z.number(), z.number()])),
+});
+// 3D Polygon/Mesh
+// const TerrainData = z.object({
+//   type: z.literal('terrain'),
+//   points: z.array(z.tuple([z.number(), z.number(), z.number()])),
+// })
+export const SiteNode = BaseNode.extend({
+    id: objectId('site'),
+    type: nodeType('site'),
+    // Specific props
+    polygon: PropertyLineData.optional().default({
+        type: 'polygon',
+        // Default 30x30 square matching GRID_SIZE
+        points: [
+            [0, 0],
+            [30, 0],
+            [30, 30],
+            [0, 30],
+        ],
+    }),
+    // terrain: TerrainData,
+    children: z
+        .array(z.discriminatedUnion('type', [BuildingNode, ItemNode]))
+        .default([BuildingNode.parse({})]),
+}).describe(dedent `
+  Site node - used to represent a site
+  - polygon: polygon data
+  - children: array of building and item nodes
+  `);

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

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+export declare const SlabNode: 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<`slab_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"slab">>;
+    polygon: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    elevation: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type SlabNode = z.infer<typeof SlabNode>;
+//# sourceMappingURL=slab.d.ts.map

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

@@ -0,0 +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"}

package/dist/schema/nodes/slab.js

@@ -0,0 +1,15 @@
+import dedent from 'dedent';
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base';
+export const SlabNode = BaseNode.extend({
+    id: objectId('slab'),
+    type: nodeType('slab'),
+    // Specific props
+    // Polygon boundary - array of [x, z] coordinates defining the slab
+    polygon: z.array(z.tuple([z.number(), z.number()])),
+    elevation: z.number().default(0.05), // Elevation in meters
+}).describe(dedent `
+  Slab node - used to represent a slab/floor in the building
+  - polygon: array of [x, z] points defining the slab boundary
+  - elevation: elevation in meters
+  `);

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

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+export declare const WallNode: 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<`wall_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"wall">>;
+    children: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodTemplateLiteral<`item_${string}`>>>>;
+    thickness: z.ZodOptional<z.ZodNumber>;
+    height: z.ZodOptional<z.ZodNumber>;
+    start: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    end: z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>;
+    frontSide: z.ZodDefault<z.ZodEnum<{
+        unknown: "unknown";
+        interior: "interior";
+        exterior: "exterior";
+    }>>;
+    backSide: z.ZodDefault<z.ZodEnum<{
+        unknown: "unknown";
+        interior: "interior";
+        exterior: "exterior";
+    }>>;
+}, z.core.$strip>;
+export type WallNode = z.infer<typeof WallNode>;
+//# sourceMappingURL=wall.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wall.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/wall.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAOvB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwBpB,CAAA;AACD,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}

package/dist/schema/nodes/wall.js

@@ -0,0 +1,30 @@
+import dedent from 'dedent';
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base';
+import { ItemNode } from './item';
+// import { DoorNode } from "./door";
+// import { ItemNode } from "./item";
+// import { WindowNode } from "./window";
+export const WallNode = BaseNode.extend({
+    id: objectId('wall'),
+    type: nodeType('wall'),
+    children: z.array(ItemNode.shape.id).default([]),
+    // Specific props
+    thickness: z.number().optional(),
+    height: z.number().optional(),
+    // e.g., start/end points for path
+    start: z.tuple([z.number(), z.number()]),
+    end: z.tuple([z.number(), z.number()]),
+    // Space detection for cutaway mode
+    frontSide: z.enum(['interior', 'exterior', 'unknown']).default('unknown'),
+    backSide: z.enum(['interior', 'exterior', 'unknown']).default('unknown'),
+}).describe(dedent `
+  Wall node - used to represent a wall in the building
+  - thickness: thickness in meters
+  - height: height in meters
+  - start: start point of the wall in level coordinate system
+  - end: end point of the wall in level coordinate system
+  - size: size of the wall in grid units
+  - frontSide: whether the front side faces interior, exterior, or unknown
+  - backSide: whether the back side faces interior, exterior, or unknown
+  `);

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

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+export declare const ZoneNode: z.ZodObject<{
+    object: z.ZodDefault<z.ZodLiteral<"node">>;
+    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>>;
+    id: z.ZodDefault<z.ZodTemplateLiteral<`zone_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"zone">>;
+    name: z.ZodString;
+    polygon: z.ZodArray<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    color: z.ZodDefault<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodJSONSchema>>;
+}, z.core.$strip>;
+export type ZoneNode = z.infer<typeof ZoneNode>;
+//# sourceMappingURL=zone.d.ts.map

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

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