@pascal-app/core 0.1.12 → 0.2.0

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

@@ -1,4 +1,143 @@
 import { z } from 'zod';
+declare const toggleControlSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"toggle">;
+    label: z.ZodOptional<z.ZodString>;
+    default: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+declare const sliderControlSchema: 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>;
+declare const temperatureControlSchema: 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>;
+declare const controlSchema: 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">;
+declare const animationEffectSchema: 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>;
+declare const lightEffectSchema: 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>;
+declare const effectSchema: 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">;
+declare const interactiveSchema: 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>;
+export type ToggleControl = z.infer<typeof toggleControlSchema>;
+export type SliderControl = z.infer<typeof sliderControlSchema>;
+export type TemperatureControl = z.infer<typeof temperatureControlSchema>;
+export type Control = z.infer<typeof controlSchema>;
+export type AnimationEffect = z.infer<typeof animationEffectSchema>;
+export type LightEffect = z.infer<typeof lightEffectSchema>;
+export type Effect = z.infer<typeof effectSchema>;
+export type Interactive = z.infer<typeof interactiveSchema>;
 declare const assetSchema: z.ZodObject<{
     id: z.ZodString;
     category: z.ZodString;
@@ -7,13 +146,61 @@ declare const assetSchema: 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>;
 export type AssetInput = z.input<typeof assetSchema>;
 export type Asset = z.infer<typeof assetSchema>;
@@ -37,12 +224,15 @@ export declare const ItemNode: 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;
@@ -51,15 +241,68 @@ export declare const ItemNode: 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>;
 export type ItemNode = z.infer<typeof ItemNode>;
+/**
+ * Returns the effective world-space dimensions of an item after applying its scale.
+ * Use this everywhere item.asset.dimensions is used for spatial calculations.
+ */
+export declare function getScaledDimensions(item: ItemNode): [number, number, number];
 export {};
 //# sourceMappingURL=item.d.ts.map

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;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"}
+{"version":3,"file":"item.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/item.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmBf,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA6BnB,CAAA;AAEF,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA;AAE/C;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAI5E"}

package/dist/schema/nodes/item.js

@@ -1,6 +1,57 @@
 import dedent from 'dedent';
 import { z } from 'zod';
 import { BaseNode, nodeType, objectId } from '../base';
+// --- Control descriptors ---
+const toggleControlSchema = z.object({
+    kind: z.literal('toggle'),
+    label: z.string().optional(),
+    default: z.boolean().optional(),
+});
+const sliderControlSchema = z.object({
+    kind: z.literal('slider'),
+    label: z.string(),
+    min: z.number(),
+    max: z.number(),
+    step: z.number().default(1),
+    unit: z.string().optional(),
+    displayMode: z.enum(['slider', 'stepper', 'dial']).default('slider'),
+    default: z.number().optional(),
+});
+const temperatureControlSchema = z.object({
+    kind: z.literal('temperature'),
+    label: z.string().default('Temperature'),
+    min: z.number().default(16),
+    max: z.number().default(30),
+    unit: z.enum(['C', 'F']).default('C'),
+    default: z.number().optional(),
+});
+const controlSchema = z.discriminatedUnion('kind', [
+    toggleControlSchema,
+    sliderControlSchema,
+    temperatureControlSchema,
+]);
+// --- Effect descriptors ---
+const animationEffectSchema = z.object({
+    kind: z.literal('animation'),
+    clips: z.object({
+        on: z.string().optional(),
+        off: z.string().optional(),
+        loop: z.string().optional(),
+    }),
+});
+const lightEffectSchema = z.object({
+    kind: z.literal('light'),
+    color: z.string().default('#ffffff'),
+    intensityRange: z.tuple([z.number(), z.number()]),
+    distance: z.number().optional(),
+    offset: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
+});
+const effectSchema = z.discriminatedUnion('kind', [animationEffectSchema, lightEffectSchema]);
+// --- Interactive descriptor ---
+const interactiveSchema = z.object({
+    controls: z.array(controlSchema).default([]),
+    effects: z.array(effectSchema).default([]),
+});
 const assetSchema = z.object({
     id: z.string(),
     category: z.string(),
@@ -9,20 +60,31 @@ const assetSchema = z.object({
     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(),
+    tags: z.array(z.string()).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]),
+    surface: z
+        .object({
+        height: z.number(), // where things rest
+    })
+        .optional(), // undefined = can't place things on it
+    interactive: interactiveSchema.optional(),
 });
 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]),
+    scale: z.tuple([z.number(), z.number(), z.number()]).default([1, 1, 1]),
     side: z.enum(['front', 'back']).optional(),
+    children: z.array(objectId('item')).default([]),
     // 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
+    // Denormalized references to collections this node belongs to
+    collectionIds: z.array(z.custom()).optional(),
     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)
@@ -35,4 +97,14 @@ export const ItemNode = BaseNode.extend({
     - offset: corrective position offset for the model
     - rotation: corrective rotation for the model
     - scale: corrective scale for the model
+    - tags: tags associated with the item
 `);
+/**
+ * Returns the effective world-space dimensions of an item after applying its scale.
+ * Use this everywhere item.asset.dimensions is used for spatial calculations.
+ */
+export function getScaledDimensions(item) {
+    const [w, h, d] = item.asset.dimensions;
+    const [sx, sy, sz] = item.scale;
+    return [w * sx, h * sy, d * sz];
+}

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

@@ -1 +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"}
+{"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;;;;;;;;;;;;;;;;;;;;iBAwBrB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,SAAS,CAAC,CAAA"}

package/dist/schema/nodes/level.js

@@ -11,7 +11,17 @@ 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([]),
+    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 `

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

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+export declare const RoofType: z.ZodEnum<{
+    hip: "hip";
+    gable: "gable";
+    shed: "shed";
+    gambrel: "gambrel";
+    dutch: "dutch";
+    mansard: "mansard";
+    flat: "flat";
+}>;
+export type RoofType = z.infer<typeof RoofType>;
+export declare const RoofSegmentNode: 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>;
+export type RoofSegmentNode = z.infer<typeof RoofSegmentNode>;
+//# sourceMappingURL=roof-segment.d.ts.map

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

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

package/dist/schema/nodes/roof-segment.js

@@ -0,0 +1,36 @@
+import dedent from 'dedent';
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base';
+export const RoofType = z.enum(['hip', 'gable', 'shed', 'gambrel', 'dutch', 'mansard', 'flat']);
+export const RoofSegmentNode = BaseNode.extend({
+    id: objectId('rseg'),
+    type: nodeType('roof-segment'),
+    // Position relative to parent roof group
+    position: z.tuple([z.number(), z.number(), z.number()]).default([0, 0, 0]),
+    // Rotation around Y axis in radians
+    rotation: z.number().default(0),
+    // Roof shape type
+    roofType: RoofType.default('gable'),
+    // Footprint dimensions
+    width: z.number().default(8),
+    depth: z.number().default(6),
+    // Vertical dimensions
+    wallHeight: z.number().default(0.5),
+    roofHeight: z.number().default(2.5),
+    // Structure thicknesses
+    wallThickness: z.number().default(0.1),
+    deckThickness: z.number().default(0.1),
+    overhang: z.number().default(0.3),
+    shingleThickness: z.number().default(0.05),
+}).describe(dedent `
+  Roof segment node - an individual roof module within a roof group.
+  Each segment generates a complete architectural volume (walls + roof).
+  Multiple segments can be combined to form complex roof shapes.
+  - roofType: hip, gable, shed, gambrel, dutch, mansard, flat
+  - width/depth: footprint dimensions
+  - wallHeight: height of walls below the roof
+  - roofHeight: height of the roof peak above the walls
+  - wallThickness/deckThickness: structural thicknesses
+  - overhang: eave overhang distance
+  - shingleThickness: outer shingle layer thickness
+  `);

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

@@ -19,10 +19,7 @@ export declare const RoofNode: 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>;
 export type RoofNode = z.infer<typeof RoofNode>;
 //# sourceMappingURL=roof.d.ts.map

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

@@ -1 +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"}
+{"version":3,"file":"roof.d.ts","sourceRoot":"","sources":["../../../src/schema/nodes/roof.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,QAAQ;;;;;;;;;;;;;;;;;;;;;iBAkBpB,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAA"}

package/dist/schema/nodes/roof.js

@@ -1,28 +1,21 @@
 import dedent from 'dedent';
 import { z } from 'zod';
 import { BaseNode, nodeType, objectId } from '../base';
+import { RoofSegmentNode } from './roof-segment';
 export const RoofNode = BaseNode.extend({
     id: objectId('roof'),
     type: nodeType('roof'),
-    // Position of the roof center (Y should typically be 0)
+    // Position of the roof group center
     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),
+    // Child roof segment IDs
+    children: z.array(RoofSegmentNode.shape.id).default([]),
 }).describe(dedent `
-  Roof node - used to represent a gable roof in the building
-  - position: center position of the roof (Y typically 0)
+  Roof node - a container for roof segments.
+  Acts as a group that holds one or more RoofSegmentNodes.
+  When not being edited, segments are visually combined into a single solid.
+  - position: center position of the roof group
   - 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
+  - children: array of RoofSegmentNode IDs
   `);

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

@@ -62,12 +62,15 @@ export declare const SiteNode: 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 SiteNode: 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>;

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

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