@pascal-app/core 0.1.13 → 0.3.0

package/dist/lib/space-detection.js

@@ -23,7 +23,7 @@ editorStore) {
                 if (!currentWallsByLevel.has(levelId)) {
                     currentWallsByLevel.set(levelId, new Set());
                 }
-                currentWallsByLevel.get(levelId).add(node.id);
+                currentWallsByLevel.get(levelId)?.add(node.id);
             }
         }
         // Check each level for changes
@@ -76,10 +76,12 @@ editorStore) {
         // Run detection for affected levels
         if (levelsToUpdate.size > 0) {
             isProcessing = true;
+            sceneStore.temporal.getState().pause();
             try {
                 runSpaceDetection(Array.from(levelsToUpdate), sceneStore, editorStore, nodes);
             }
             finally {
+                sceneStore.temporal.getState().resume();
                 isProcessing = false;
             }
         }

package/dist/schema/collections.d.ts

@@ -0,0 +1,11 @@
+import type { AnyNodeId } from './types';
+export type CollectionId = `collection_${string}`;
+export type Collection = {
+    id: CollectionId;
+    name: string;
+    color?: string;
+    nodeIds: AnyNodeId[];
+    controlNodeId?: AnyNodeId;
+};
+export declare const generateCollectionId: () => CollectionId;
+//# sourceMappingURL=collections.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"collections.d.ts","sourceRoot":"","sources":["../../src/schema/collections.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAExC,MAAM,MAAM,YAAY,GAAG,cAAc,MAAM,EAAE,CAAA;AAEjD,MAAM,MAAM,UAAU,GAAG;IACvB,EAAE,EAAE,YAAY,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,OAAO,EAAE,SAAS,EAAE,CAAA;IACpB,aAAa,CAAC,EAAE,SAAS,CAAA;CAC1B,CAAA;AAED,eAAO,MAAM,oBAAoB,QAAO,YAAwC,CAAA"}

package/dist/schema/collections.js

@@ -0,0 +1,2 @@
+import { generateId } from './base';
+export const generateCollectionId = () => generateId('collection');

package/dist/schema/index.d.ts

@@ -1,18 +1,21 @@
 export { BaseNode, generateId, Material, nodeType, objectId } from './base';
 export { CameraSchema } from './camera';
-export type { AssetInput } from './nodes/item';
-export { ItemNode } from './nodes/item';
+export { type Collection, type CollectionId, generateCollectionId } from './collections';
+export { BuildingNode } from './nodes/building';
+export { CeilingNode } from './nodes/ceiling';
+export { DoorNode, DoorSegment } from './nodes/door';
+export { GuideNode } from './nodes/guide';
+export type { AnimationEffect, Asset, AssetInput, Control, Effect, Interactive, LightEffect, SliderControl, TemperatureControl, ToggleControl, } from './nodes/item';
+export { getScaledDimensions, ItemNode } from './nodes/item';
 export { LevelNode } from './nodes/level';
+export { RoofNode } from './nodes/roof';
+export { RoofSegmentNode, RoofType } from './nodes/roof-segment';
+export { ScanNode } from './nodes/scan';
 export { SiteNode } from './nodes/site';
 export { SlabNode } from './nodes/slab';
 export { WallNode } from './nodes/wall';
-export { BuildingNode } from './nodes/building';
-export { CeilingNode } from './nodes/ceiling';
+export { WindowNode } from './nodes/window';
 export { ZoneNode } from './nodes/zone';
-export { RoofNode } from './nodes/roof';
-export { ScanNode } from './nodes/scan';
-export { GuideNode } from './nodes/guide';
 export type { AnyNodeId, AnyNodeType } from './types';
-export { WindowNode } from './nodes/window';
 export { AnyNode } from './types';
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAA;AAE3E,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AACvC,YAAY,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAC9C,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AACvC,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAEzC,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AACvC,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAE7C,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AACvC,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AACzC,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AACrD,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAE3C,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/schema/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAA;AAE3E,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAEvC,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,YAAY,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAA;AACxF,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAC7C,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,cAAc,CAAA;AACpD,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AACzC,YAAY,EACV,eAAe,EACf,KAAK,EACL,UAAU,EACV,OAAO,EACP,MAAM,EACN,WAAW,EACX,WAAW,EACX,aAAa,EACb,kBAAkB,EAClB,aAAa,GACd,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,mBAAmB,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAC5D,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AACvC,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAChE,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAEvC,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AACvC,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AACvC,OAAO,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAC3C,OAAO,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AACvC,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAErD,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA"}

package/dist/schema/index.js

@@ -2,18 +2,22 @@
 export { BaseNode, generateId, Material, nodeType, objectId } from './base';
 // Camera
 export { CameraSchema } from './camera';
-export { ItemNode } from './nodes/item';
+// Collections
+export { generateCollectionId } from './collections';
+export { BuildingNode } from './nodes/building';
+export { CeilingNode } from './nodes/ceiling';
+export { DoorNode, DoorSegment } from './nodes/door';
+export { GuideNode } from './nodes/guide';
+export { getScaledDimensions, ItemNode } from './nodes/item';
 export { LevelNode } from './nodes/level';
+export { RoofNode } from './nodes/roof';
+export { RoofSegmentNode, RoofType } from './nodes/roof-segment';
+export { ScanNode } from './nodes/scan';
 // Nodes
 export { SiteNode } from './nodes/site';
 export { SlabNode } from './nodes/slab';
 export { WallNode } from './nodes/wall';
-export { BuildingNode } from './nodes/building';
-export { CeilingNode } from './nodes/ceiling';
-export { ZoneNode } from './nodes/zone';
-export { RoofNode } from './nodes/roof';
-export { ScanNode } from './nodes/scan';
-export { GuideNode } from './nodes/guide';
 export { WindowNode } from './nodes/window';
+export { ZoneNode } from './nodes/zone';
 // Union types
 export { AnyNode } from './types';

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

@@ -0,0 +1,78 @@
+import { z } from 'zod';
+export declare const DoorSegment: 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>;
+export type DoorSegment = z.infer<typeof DoorSegment>;
+export declare const DoorNode: 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>;
+export type DoorNode = z.infer<typeof DoorNode>;
+//# sourceMappingURL=door.d.ts.map

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

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

package/dist/schema/nodes/door.js

@@ -0,0 +1,67 @@
+import dedent from 'dedent';
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../base';
+export const DoorSegment = z.object({
+    type: z.enum(['panel', 'glass', 'empty']),
+    heightRatio: z.number(),
+    // Each segment controls its own column split
+    columnRatios: z.array(z.number()).default([1]),
+    dividerThickness: z.number().default(0.03),
+    // panel-specific
+    panelDepth: z.number().default(0.01), // + raised, - recessed
+    panelInset: z.number().default(0.04),
+});
+export const DoorNode = BaseNode.extend({
+    id: objectId('door'),
+    type: nodeType('door'),
+    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(),
+    wallId: z.string().optional(),
+    // Overall dimensions
+    width: z.number().default(0.9),
+    height: z.number().default(2.1),
+    // Frame
+    frameThickness: z.number().default(0.05),
+    frameDepth: z.number().default(0.07),
+    threshold: z.boolean().default(true),
+    thresholdHeight: z.number().default(0.02),
+    // Swing
+    hingesSide: z.enum(['left', 'right']).default('left'),
+    swingDirection: z.enum(['inward', 'outward']).default('inward'),
+    // Leaf segments — stacked top to bottom, each with its own column split
+    segments: z.array(DoorSegment).default([
+        {
+            type: 'panel',
+            heightRatio: 0.4,
+            columnRatios: [1],
+            dividerThickness: 0.03,
+            panelDepth: 0.01,
+            panelInset: 0.04,
+        },
+        {
+            type: 'panel',
+            heightRatio: 0.6,
+            columnRatios: [1],
+            dividerThickness: 0.03,
+            panelDepth: 0.01,
+            panelInset: 0.04,
+        },
+    ]),
+    // Handle
+    handle: z.boolean().default(true),
+    handleHeight: z.number().default(1.05),
+    handleSide: z.enum(['left', 'right']).default('right'),
+    // Leaf inner margin — space between leaf edge and segment content area [x, y]
+    contentPadding: z.tuple([z.number(), z.number()]).default([0.04, 0.04]),
+    // Emergency / commercial hardware
+    doorCloser: z.boolean().default(false),
+    panicBar: z.boolean().default(false),
+    panicBarHeight: z.number().default(1.0),
+}).describe(dedent `Door node - a parametric door placed on a wall
+  - position: center of the door in wall-local coordinate system (Y = height/2, always at floor)
+  - segments: rows stacked top to bottom, each defining its own columnRatios
+  - type 'empty' = flush flat fill, 'panel' = raised/recessed panel, 'glass' = glazed
+  - hingesSide/swingDirection: which way the door opens
+  - doorCloser/panicBar: commercial and emergency hardware options
+`);

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;
@@ -18,6 +157,50 @@ declare const assetSchema: z.ZodObject<{
     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>;
@@ -41,6 +224,7 @@ 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";
@@ -48,6 +232,7 @@ export declare const ItemNode: z.ZodObject<{
     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;
@@ -67,8 +252,57 @@ export declare const ItemNode: z.ZodObject<{
         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;;;;;;;;;;;;;;;;;;;iBAkBf,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAyBnB,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(),
@@ -16,20 +67,24 @@ const assetSchema = z.object({
     scale: z.tuple([z.number(), z.number(), z.number()]).default([1, 1, 1]),
     surface: z
         .object({
-        height: z.number(), // where things rest 
+        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)
@@ -44,3 +99,12 @@ export const ItemNode = BaseNode.extend({
     - 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 `