@holoscript/core 2.0.2 → 2.1.0

package/dist/index.cjs

@@ -1,858 +1,11 @@
 'use strict';
 
-var chunkVMZN4EVR_cjs = require('./chunk-VMZN4EVR.cjs');
-var chunkWFI4T3XB_cjs = require('./chunk-WFI4T3XB.cjs');
-var chunk4OHVW4XR_cjs = require('./chunk-4OHVW4XR.cjs');
-var chunk3N67RLQP_cjs = require('./chunk-3N67RLQP.cjs');
+var chunkMFNO57XL_cjs = require('./chunk-MFNO57XL.cjs');
+var chunkR75MREOS_cjs = require('./chunk-R75MREOS.cjs');
+var chunkT57ZL7KR_cjs = require('./chunk-T57ZL7KR.cjs');
+var chunkL6VLNVKP_cjs = require('./chunk-L6VLNVKP.cjs');
 var chunk3X2EGU7Z_cjs = require('./chunk-3X2EGU7Z.cjs');
-var chunkCZLDE2OZ_cjs = require('./chunk-CZLDE2OZ.cjs');
-
-// src/traits/MaterialTrait.ts
-var MaterialTrait_exports = {};
-chunkCZLDE2OZ_cjs.__export(MaterialTrait_exports, {
-  MATERIAL_PRESETS: () => exports.MATERIAL_PRESETS,
-  MaterialTrait: () => exports.MaterialTrait,
-  createMaterialTrait: () => createMaterialTrait
-});
-function createMaterialTrait(config) {
-  return new exports.MaterialTrait(config);
-}
-exports.MaterialTrait = void 0; exports.MATERIAL_PRESETS = void 0;
-var init_MaterialTrait = chunkCZLDE2OZ_cjs.__esm({
-  "src/traits/MaterialTrait.ts"() {
-    exports.MaterialTrait = class {
-      constructor(config) {
-        this.textureCache = /* @__PURE__ */ new Map();
-        this.material = {
-          ...{ type: "pbr" },
-          ...config
-        };
-      }
-      /**
-       * Get material properties
-       */
-      getMaterial() {
-        return { ...this.material };
-      }
-      /**
-       * Update material property
-       */
-      setProperty(key, value) {
-        this.material[key] = value;
-      }
-      /**
-       * Get PBR properties
-       */
-      getPBRProperties() {
-        return this.material.pbr;
-      }
-      /**
-       * Update PBR material
-       */
-      updatePBR(pbr) {
-        if (!this.material.pbr) {
-          this.material.pbr = {
-            baseColor: { r: 1, g: 1, b: 1 },
-            metallic: 0,
-            roughness: 0.5
-          };
-        }
-        this.material.pbr = { ...this.material.pbr, ...pbr };
-      }
-      /**
-       * Add texture map
-       */
-      addTexture(texture) {
-        if (!this.material.textures) {
-          this.material.textures = [];
-        }
-        this.material.textures.push(texture);
-      }
-      /**
-       * Get all textures
-       */
-      getTextures() {
-        return [...this.material.textures || []];
-      }
-      /**
-       * Clear texture cache (for memory optimization)
-       */
-      clearTextureCache() {
-        this.textureCache.clear();
-      }
-      /**
-       * Get shader code if custom
-       */
-      getCustomShader() {
-        return this.material.customShader;
-      }
-      /**
-       * Set custom shader
-       */
-      setCustomShader(shader) {
-        this.material.customShader = shader;
-      }
-      /**
-       * Get optimization hints
-       */
-      getOptimization() {
-        return this.material.optimization;
-      }
-      /**
-       * Enable/disable texture streaming
-       */
-      setTextureStreaming(enabled) {
-        if (!this.material.optimization) {
-          this.material.optimization = {};
-        }
-        this.material.optimization.streamTextures = enabled;
-      }
-      /**
-       * Set texture compression
-       */
-      setCompression(compression) {
-        if (!this.material.optimization) {
-          this.material.optimization = {};
-        }
-        this.material.optimization.compression = compression;
-      }
-      /**
-       * Enable material instancing for performance
-       */
-      setInstanced(instanced) {
-        if (!this.material.optimization) {
-          this.material.optimization = {};
-        }
-        this.material.optimization.instanced = instanced;
-      }
-      /**
-       * Dispose and cleanup
-       */
-      dispose() {
-        this.textureCache.clear();
-      }
-    };
-    exports.MATERIAL_PRESETS = {
-      /** Shiny metal */
-      chrome: () => ({
-        type: "pbr",
-        pbr: {
-          baseColor: { r: 0.77, g: 0.77, b: 0.77 },
-          metallic: 1,
-          roughness: 0.1
-        }
-      }),
-      /** Rough plastic */
-      plastic: () => ({
-        type: "pbr",
-        pbr: {
-          baseColor: { r: 1, g: 1, b: 1 },
-          metallic: 0,
-          roughness: 0.8
-        }
-      }),
-      /** Wood texture */
-      wood: () => ({
-        type: "pbr",
-        pbr: {
-          baseColor: { r: 0.6, g: 0.4, b: 0.2 },
-          metallic: 0,
-          roughness: 0.4
-        }
-      }),
-      /** Glass */
-      glass: () => ({
-        type: "transparent",
-        blendMode: "blend",
-        pbr: {
-          baseColor: { r: 1, g: 1, b: 1, a: 0.3 },
-          metallic: 0,
-          roughness: 0,
-          ior: 1.5,
-          transmission: 0.9
-        }
-      }),
-      /** Emissive (glowing) */
-      emissive: () => ({
-        type: "pbr",
-        pbr: {
-          baseColor: { r: 0, g: 1, b: 0 },
-          metallic: 0,
-          roughness: 1,
-          emission: {
-            color: { r: 0, g: 1, b: 0 },
-            intensity: 2
-          }
-        }
-      }),
-      /** Skin material */
-      skin: () => ({
-        type: "pbr",
-        pbr: {
-          baseColor: { r: 1, g: 0.8, b: 0.7 },
-          metallic: 0,
-          roughness: 0.5,
-          ambientOcclusion: 0.8
-        }
-      })
-    };
-  }
-});
-
-// src/traits/LightingTrait.ts
-var LightingTrait_exports = {};
-chunkCZLDE2OZ_cjs.__export(LightingTrait_exports, {
-  LIGHTING_PRESETS: () => exports.LIGHTING_PRESETS,
-  LightingTrait: () => exports.LightingTrait,
-  createLightingTrait: () => createLightingTrait
-});
-function createLightingTrait(config) {
-  return new exports.LightingTrait(config);
-}
-exports.LightingTrait = void 0; exports.LIGHTING_PRESETS = void 0;
-var init_LightingTrait = chunkCZLDE2OZ_cjs.__esm({
-  "src/traits/LightingTrait.ts"() {
-    exports.LightingTrait = class {
-      constructor(config) {
-        this.lights = /* @__PURE__ */ new Map();
-        this.lightIdCounter = 0;
-        this.globalIllumination = {
-          enabled: true,
-          intensity: 1,
-          skyColor: { r: 0.5, g: 0.7, b: 1 },
-          skyIntensity: 1,
-          groundColor: { r: 0.4, g: 0.4, b: 0.4 },
-          groundIntensity: 0.5,
-          probes: true,
-          indirectDiffuse: 1,
-          indirectSpecular: 1,
-          aoIntensity: 1,
-          screenSpaceAO: true,
-          ...config
-        };
-      }
-      /**
-       * Add a light to the scene
-       */
-      addLight(light) {
-        const id = light.name || `light_${this.lightIdCounter++}`;
-        this.lights.set(id, light);
-        return id;
-      }
-      /**
-       * Get light by ID
-       */
-      getLight(id) {
-        return this.lights.get(id);
-      }
-      /**
-       * Get all lights
-       */
-      getLights() {
-        return Array.from(this.lights.values());
-      }
-      /**
-       * Get lights by type
-       */
-      getLightsByType(type) {
-        return Array.from(this.lights.values()).filter((l) => l.type === type);
-      }
-      /**
-       * Update light properties
-       */
-      updateLight(id, updates) {
-        const light = this.lights.get(id);
-        if (!light) return false;
-        this.lights.set(id, { ...light, ...updates });
-        return true;
-      }
-      /**
-       * Remove light
-       */
-      removeLight(id) {
-        return this.lights.delete(id);
-      }
-      /**
-       * Clear all lights
-       */
-      clearLights() {
-        this.lights.clear();
-      }
-      /**
-       * Get global illumination config
-       */
-      getGlobalIllumination() {
-        return { ...this.globalIllumination };
-      }
-      /**
-       * Update global illumination
-       */
-      updateGlobalIllumination(updates) {
-        this.globalIllumination = {
-          ...this.globalIllumination,
-          ...updates
-        };
-      }
-      /**
-       * Enable/disable GI
-       */
-      setGIEnabled(enabled) {
-        this.globalIllumination.enabled = enabled;
-      }
-      /**
-       * Set ambient light colors (skybox mode)
-       */
-      setAmbientLight(skyColor, groundColor, intensity = 1) {
-        this.globalIllumination.skyColor = skyColor;
-        this.globalIllumination.groundColor = groundColor;
-        this.globalIllumination.skyIntensity = intensity;
-        this.globalIllumination.groundIntensity = intensity * 0.5;
-      }
-      /**
-       * Enable/disable screen-space ambient occlusion
-       */
-      setScreenSpaceAO(enabled, intensity = 1) {
-        this.globalIllumination.screenSpaceAO = enabled;
-        this.globalIllumination.aoIntensity = intensity;
-      }
-      /**
-       * Create directional light (sun)
-       */
-      createDirectionalLight(direction, color, intensity = 1, castShadows = true) {
-        const light = {
-          type: "directional",
-          name: `sun_${this.lightIdCounter}`,
-          direction,
-          color,
-          intensity,
-          shadow: castShadows ? {
-            type: "soft",
-            resolution: 2048,
-            cascades: 4,
-            softness: 1
-          } : void 0,
-          volumetric: true,
-          priority: 100
-        };
-        return this.addLight(light);
-      }
-      /**
-       * Create point light
-       */
-      createPointLight(position, color, intensity, range, castShadows = false) {
-        const light = {
-          type: "point",
-          name: `point_${this.lightIdCounter}`,
-          position,
-          color,
-          intensity,
-          range,
-          shadow: castShadows ? {
-            type: "soft",
-            resolution: 512,
-            softness: 0.5
-          } : void 0,
-          priority: 50
-        };
-        return this.addLight(light);
-      }
-      /**
-       * Create spot light
-       */
-      createSpotLight(position, direction, color, intensity, range, spotAngle = 45, castShadows = true) {
-        const light = {
-          type: "spot",
-          name: `spot_${this.lightIdCounter}`,
-          position,
-          direction,
-          color,
-          intensity,
-          range,
-          spotAngle,
-          innerSpotAngle: spotAngle * 0.5,
-          shadow: castShadows ? {
-            type: "soft",
-            resolution: 1024,
-            softness: 0.8
-          } : void 0,
-          priority: 75
-        };
-        return this.addLight(light);
-      }
-      /**
-       * Create area light for soft lighting
-       */
-      createAreaLight(position, color, intensity, width, height) {
-        const light = {
-          type: "area",
-          name: `area_${this.lightIdCounter}`,
-          position,
-          color,
-          intensity,
-          range: Math.max(width, height) * 2,
-          priority: 25
-        };
-        return this.addLight(light);
-      }
-      /**
-       * Get shadow-casting lights
-       */
-      getShadowCastingLights() {
-        return Array.from(this.lights.values()).filter((l) => l.shadow && l.shadow.type !== "none");
-      }
-      /**
-       * Get light count by type
-       */
-      getLightCount() {
-        const counts = {
-          directional: 0,
-          point: 0,
-          spot: 0,
-          area: 0,
-          probe: 0
-        };
-        for (const light of this.lights.values()) {
-          counts[light.type]++;
-        }
-        return counts;
-      }
-      /**
-       * Estimate light impact for performance optimization
-       */
-      getPerformanceImpact() {
-        const totalLights = this.lights.size;
-        const shadowCasters = this.getShadowCastingLights().length;
-        let estimatedGPUCost = "low";
-        if (totalLights > 16 || shadowCasters > 4) {
-          estimatedGPUCost = "high";
-        } else if (totalLights > 8 || shadowCasters > 2) {
-          estimatedGPUCost = "medium";
-        }
-        return {
-          totalLights,
-          shadowCasters,
-          estimatedGPUCost
-        };
-      }
-      /**
-       * Get scene complexity info
-       */
-      getSceneInfo() {
-        const counts = this.getLightCount();
-        const impact = this.getPerformanceImpact();
-        return `Lighting: ${counts.directional} dir, ${counts.point} point, ${counts.spot} spot | Shadows: ${impact.shadowCasters} | GPU: ${impact.estimatedGPUCost}`;
-      }
-      /**
-       * Dispose and cleanup
-       */
-      dispose() {
-        this.lights.clear();
-      }
-    };
-    exports.LIGHTING_PRESETS = {
-      /** Neutral studio lighting */
-      studio: () => ({
-        enabled: true,
-        intensity: 1,
-        skyColor: { r: 0.5, g: 0.5, b: 0.5 },
-        skyIntensity: 0.5,
-        groundColor: { r: 0.3, g: 0.3, b: 0.3 },
-        groundIntensity: 0.3
-      }),
-      /** Bright outdoor lighting */
-      outdoor: () => ({
-        enabled: true,
-        intensity: 1.2,
-        skyColor: { r: 0.7, g: 0.85, b: 1 },
-        skyIntensity: 1,
-        groundColor: { r: 0.4, g: 0.4, b: 0.35 },
-        groundIntensity: 0.6,
-        indirectDiffuse: 1.2
-      }),
-      /** Dim interior lighting */
-      interior: () => ({
-        enabled: true,
-        intensity: 0.6,
-        skyColor: { r: 0.3, g: 0.3, b: 0.35 },
-        skyIntensity: 0.4,
-        groundColor: { r: 0.2, g: 0.2, b: 0.2 },
-        groundIntensity: 0.2
-      }),
-      /** Night scene */
-      night: () => ({
-        enabled: true,
-        intensity: 0.3,
-        skyColor: { r: 0.01, g: 0.01, b: 0.02 },
-        skyIntensity: 0.1,
-        groundColor: { r: 0.02, g: 0.02, b: 0.02 },
-        groundIntensity: 0.05,
-        screenSpaceAO: false
-      }),
-      /** Sunset/golden hour */
-      sunset: () => ({
-        enabled: true,
-        intensity: 1.1,
-        skyColor: { r: 1, g: 0.7, b: 0.3 },
-        skyIntensity: 1,
-        groundColor: { r: 0.6, g: 0.4, b: 0.2 },
-        groundIntensity: 0.8
-      })
-    };
-  }
-});
-
-// src/traits/RenderingTrait.ts
-var RenderingTrait_exports = {};
-chunkCZLDE2OZ_cjs.__export(RenderingTrait_exports, {
-  RenderingTrait: () => exports.RenderingTrait,
-  createRenderingTrait: () => createRenderingTrait
-});
-function createRenderingTrait(config) {
-  return new exports.RenderingTrait(config);
-}
-exports.RenderingTrait = void 0;
-var init_RenderingTrait = chunkCZLDE2OZ_cjs.__esm({
-  "src/traits/RenderingTrait.ts"() {
-    exports.RenderingTrait = class {
-      constructor(config) {
-        this.optimization = {
-          lodStrategy: "automatic",
-          culling: {
-            mode: "back",
-            frustum: true,
-            occlusion: true
-          },
-          batching: {
-            static: true,
-            dynamic: true,
-            instancing: true,
-            maxInstanceCount: 1e3
-          },
-          textures: {
-            streaming: true,
-            compression: "auto",
-            mipmaps: true,
-            maxResolution: 2048
-          },
-          shaders: {
-            simplifiedShaders: true,
-            lodBias: 0
-          },
-          targetGPUTier: "high",
-          adaptiveQuality: true,
-          targetFrameRate: 60,
-          ...config
-        };
-      }
-      /**
-       * Get rendering optimization config
-       */
-      getOptimization() {
-        return JSON.parse(JSON.stringify(this.optimization));
-      }
-      /**
-       * Update rendering configuration
-       */
-      updateOptimization(updates) {
-        this.optimization = { ...this.optimization, ...updates };
-      }
-      /**
-       * Setup LOD levels (3 levels is typical)
-       */
-      setupLODLevels(strategy = "automatic") {
-        const levels = [
-          {
-            level: 0,
-            screenRelativeSize: 0.5,
-            polygonReduction: 1,
-            textureScale: 1
-          },
-          {
-            level: 1,
-            screenRelativeSize: 0.25,
-            polygonReduction: 0.6,
-            disabledFeatures: ["specular"],
-            textureScale: 0.5
-          },
-          {
-            level: 2,
-            screenRelativeSize: 0.1,
-            polygonReduction: 0.3,
-            disabledFeatures: ["specular", "normals"],
-            textureScale: 0.25
-          }
-        ];
-        this.optimization.lodStrategy = strategy;
-        this.optimization.lodLevels = levels;
-      }
-      /**
-       * Get LOD levels
-       */
-      getLODLevels() {
-        return [...this.optimization.lodLevels || []];
-      }
-      /**
-       * Configure culling
-       */
-      setCulling(config) {
-        const defaultCulling = { mode: "back" };
-        this.optimization.culling = {
-          ...defaultCulling,
-          ...this.optimization.culling,
-          ...config
-        };
-      }
-      /**
-       * Enable frustum culling
-       */
-      setFrustumCulling(enabled) {
-        if (!this.optimization.culling) {
-          this.optimization.culling = { mode: "back" };
-        }
-        this.optimization.culling.frustum = enabled;
-      }
-      /**
-       * Enable occlusion culling
-       */
-      setOcclusionCulling(enabled, distance) {
-        if (!this.optimization.culling) {
-          this.optimization.culling = { mode: "back" };
-        }
-        this.optimization.culling.occlusion = enabled;
-        if (distance) {
-          this.optimization.culling.occlusionDistance = distance;
-        }
-      }
-      /**
-       * Configure batching
-       */
-      setBatching(config) {
-        this.optimization.batching = {
-          ...this.optimization.batching,
-          ...config
-        };
-      }
-      /**
-       * Enable GPU instancing
-       */
-      setInstancing(enabled, maxInstances) {
-        if (!this.optimization.batching) {
-          this.optimization.batching = {};
-        }
-        this.optimization.batching.instancing = enabled;
-        if (maxInstances) {
-          this.optimization.batching.maxInstanceCount = maxInstances;
-        }
-      }
-      /**
-       * Configure texture optimization
-       */
-      setTextureOptimization(config) {
-        this.optimization.textures = {
-          ...this.optimization.textures,
-          ...config
-        };
-      }
-      /**
-       * Enable texture streaming
-       */
-      setTextureStreaming(enabled, budgetMB) {
-        if (!this.optimization.textures) {
-          this.optimization.textures = {};
-        }
-        this.optimization.textures.streaming = enabled;
-        if (budgetMB) {
-          this.optimization.textures.streamingBudget = budgetMB;
-        }
-      }
-      /**
-       * Set texture compression
-       */
-      setTextureCompression(compression) {
-        if (!this.optimization.textures) {
-          this.optimization.textures = {};
-        }
-        this.optimization.textures.compression = compression;
-      }
-      /**
-       * Set max texture resolution
-       */
-      setMaxTextureResolution(resolution) {
-        if (!this.optimization.textures) {
-          this.optimization.textures = {};
-        }
-        this.optimization.textures.maxResolution = resolution;
-      }
-      /**
-       * Configure shader optimization
-       */
-      setShaderOptimization(config) {
-        this.optimization.shaders = {
-          ...this.optimization.shaders,
-          ...config
-        };
-      }
-      /**
-       * Set target GPU tier
-       */
-      setTargetGPUTier(tier) {
-        this.optimization.targetGPUTier = tier;
-      }
-      /**
-       * Enable adaptive quality (adjust based on frame rate)
-       */
-      setAdaptiveQuality(enabled, targetFrameRate) {
-        this.optimization.adaptiveQuality = enabled;
-        if (targetFrameRate) {
-          this.optimization.targetFrameRate = targetFrameRate;
-        }
-      }
-      /**
-       * Set fixed timestep for VR/AR
-       */
-      setFixedTimestep(timestep) {
-        this.optimization.fixedTimestep = timestep;
-      }
-      /**
-       * Get rendering preset for quality level
-       */
-      getPresetForQuality(quality) {
-        const presets = {
-          low: {
-            targetGPUTier: "low",
-            lodStrategy: "automatic",
-            culling: { mode: "back", frustum: true, occlusion: false },
-            batching: { instancing: true, maxInstanceCount: 500 },
-            textures: {
-              compression: "astc",
-              maxResolution: 512,
-              streaming: true,
-              streamingBudget: 128
-            },
-            adaptiveQuality: true,
-            targetFrameRate: 30
-          },
-          medium: {
-            targetGPUTier: "medium",
-            lodStrategy: "automatic",
-            culling: { mode: "back", frustum: true, occlusion: true },
-            batching: { instancing: true, maxInstanceCount: 1e3 },
-            textures: {
-              compression: "basis",
-              maxResolution: 1024,
-              streaming: true,
-              streamingBudget: 256
-            },
-            adaptiveQuality: true,
-            targetFrameRate: 60
-          },
-          high: {
-            targetGPUTier: "high",
-            lodStrategy: "automatic",
-            culling: { mode: "back", frustum: true, occlusion: true },
-            batching: { instancing: true, maxInstanceCount: 2e3 },
-            textures: {
-              compression: "dxt",
-              maxResolution: 2048,
-              streaming: true,
-              streamingBudget: 512
-            },
-            adaptiveQuality: false,
-            targetFrameRate: 60
-          },
-          ultra: {
-            targetGPUTier: "ultra",
-            lodStrategy: "manual",
-            culling: {
-              mode: "back",
-              frustum: true,
-              occlusion: true,
-              hierarchicalZ: true
-            },
-            batching: { instancing: true, maxInstanceCount: 5e3 },
-            textures: {
-              compression: "none",
-              maxResolution: 4096,
-              virtualTexturing: true,
-              streaming: true,
-              streamingBudget: 1024
-            },
-            adaptiveQuality: false,
-            targetFrameRate: 120
-          }
-        };
-        return { ...this.optimization, ...presets[quality] };
-      }
-      /**
-       * Apply quality preset
-       */
-      applyQualityPreset(quality) {
-        const preset = this.getPresetForQuality(quality);
-        this.optimization = preset;
-      }
-      /**
-       * Estimate GPU memory usage
-       */
-      estimateGPUMemory() {
-        let textureMemory = 0;
-        let vertexBuffers = 0;
-        const maxRes = this.optimization.textures?.maxResolution || 2048;
-        textureMemory = maxRes * maxRes * 4 / (1024 * 1024);
-        const instanceCount = this.optimization.batching?.maxInstanceCount || 1e3;
-        const verticesPerMesh = 1e4;
-        vertexBuffers = verticesPerMesh * 36 * instanceCount / (1024 * 1024) * 0.1;
-        return {
-          textureMemory: Math.round(textureMemory),
-          vertexBuffers: Math.max(1, Math.round(vertexBuffers)),
-          // At least 1MB
-          estimatedTotal: Math.round(textureMemory + Math.max(1, vertexBuffers))
-        };
-      }
-      /**
-       * Get rendering statistics/info
-       */
-      getInfo() {
-        const tier = this.optimization.targetGPUTier;
-        const lod = this.optimization.lodStrategy;
-        const culling = this.optimization.culling?.mode;
-        const instancing = this.optimization.batching?.instancing ? "yes" : "no";
-        const memory = this.estimateGPUMemory();
-        return `Rendering: tier=${tier} | LOD=${lod} | culling=${culling} | instancing=${instancing} | memory=${memory.estimatedTotal}MB`;
-      }
-      /**
-       * Optimize for VR/AR (fixed timestep, fast culling)
-       */
-      optimizeForVRAR(targetFPS = 90) {
-        this.optimization.fixedTimestep = 1 / targetFPS;
-        this.optimization.targetFrameRate = targetFPS;
-        this.setOcclusionCulling(true, 50);
-        this.setInstancing(true, 5e3);
-        this.setAdaptiveQuality(true, targetFPS);
-      }
-      /**
-       * Optimize for mobile (lower resources)
-       */
-      optimizeForMobile() {
-        this.applyQualityPreset("low");
-        this.setTextureCompression("astc");
-        this.setInstancing(true, 256);
-      }
-      /**
-       * Optimize for desktop (higher resources)
-       */
-      optimizeForDesktop() {
-        this.applyQualityPreset("ultra");
-        this.setTextureCompression("none");
-        this.setInstancing(true, 5e3);
-      }
-      /**
-       * Dispose and cleanup
-       */
-      dispose() {
-      }
-    };
-  }
-});
+var chunkJEQ2X3Z6_cjs = require('./chunk-JEQ2X3Z6.cjs');
 
 // src/HoloScript2DParser.ts
 var UI_SECURITY_CONFIG = {
@@ -1089,9 +242,7 @@ var HOLOSCRIPT_SECURITY_CONFIG = {
     "__proto__",
     "fs",
     "child_process",
-    "exec",
     "spawn",
-    "fetch",
     "xmlhttprequest"
   ],
   allowedUIElements: [
@@ -1127,7 +278,7 @@ var HoloScriptParser = class {
       });
       return [];
     }
-    const rawTokens = this.tokenizeCommand(command.command.toLowerCase());
+    const rawTokens = this.tokenizeCommand(command.command);
     const tokens = this.sanitizeTokens(rawTokens);
     if (tokens.length === 0) return [];
     if (tokens.length > HOLOSCRIPT_SECURITY_CONFIG.maxTokens) {
@@ -1137,7 +288,7 @@ var HoloScriptParser = class {
       });
       return [];
     }
-    const commandType = tokens[0];
+    const commandType = tokens[0].toLowerCase();
     if ((commandType === "create" || commandType === "add") && tokens.length > 1) {
       const elementType = tokens[1];
       if (HOLOSCRIPT_SECURITY_CONFIG.allowedUIElements.includes(elementType)) {
@@ -1157,6 +308,21 @@ var HoloScriptParser = class {
         return this.parseDebugCommand(tokens.slice(1));
       case "visualize":
         return this.parseVisualizeCommand(tokens.slice(1));
+      case "composition":
+        return this.parseComposition(tokens.slice(1));
+      case "environment":
+        return this.parseEnvironment(tokens.slice(1));
+      case "template":
+        return this.parseTemplate(tokens.slice(1));
+      case "@state":
+        return this.parseStateDirective(tokens.slice(1));
+      case "every":
+      case "on_user_gesture":
+        return this.parseGlobalHandler(commandType, tokens.slice(1));
+      case "scale":
+        return this.parseScale(tokens.slice(1));
+      case "focus":
+        return this.parseFocus(tokens.slice(1));
       default:
         return this.parseGenericCommand(tokens);
     }
@@ -1195,19 +361,43 @@ var HoloScriptParser = class {
     if (tokens.length < 2) return [];
     const shape = tokens[0];
     const name = tokens[1];
+    let res = [];
     switch (shape) {
       case "orb":
       case "sphere":
-        return [this.createOrbNode(name, position)];
+        res = [this.createOrbNode(name, position)];
+        const orbProps = this.parseProperties(tokens.slice(2));
+        res[0].properties = orbProps;
+        break;
       case "function":
-        return [this.createFunctionNode(name, tokens.slice(2), position)];
+        res = [this.createFunctionNode(name, tokens.slice(2), position)];
+        break;
       case "gate":
-        return [this.createGateNode(name, tokens.slice(2), position)];
+        res = [this.createGateNode(name, tokens.slice(2), position)];
+        break;
       case "stream":
-        return [this.createStreamNode(name, tokens.slice(2), position)];
+        res = [this.createStreamNode(name, tokens.slice(2), position)];
+        break;
+      case "server":
+        res = [this.createServerNode(tokens.slice(1), position)];
+        break;
+      case "database":
+        res = [this.createDatabaseNode(tokens.slice(1), position)];
+        break;
+      case "fetch":
+        res = [this.createFetchNode(tokens.slice(1), position)];
+        break;
       default:
-        return [this.createGenericNode(shape, name, position)];
+        res = [this.createGenericNode(shape, name, position)];
+        break;
+    }
+    if (res.length > 0) {
+      const directives = this.extractDirectives(tokens.slice(2));
+      if (directives.length > 0) {
+        res[0].directives = directives;
+      }
     }
+    return res;
   }
   parseConnectCommand(tokens) {
     if (tokens.length < 3) return [];
@@ -1316,6 +506,61 @@ var HoloScriptParser = class {
       }
     };
   }
+  createServerNode(params, position) {
+    const portIndex = params.indexOf("port");
+    const port = portIndex !== -1 ? parseInt(params[portIndex + 1]) : 3e3;
+    const routesIndex = params.indexOf("routes");
+    const routes = routesIndex !== -1 ? params[routesIndex + 1].split(",") : [];
+    return {
+      type: "server",
+      port,
+      routes,
+      position: position || { x: 0, y: 0, z: 0 },
+      hologram: {
+        shape: "cube",
+        color: "#000000",
+        // Black box
+        size: 2,
+        glow: true,
+        interactive: false
+      }
+    };
+  }
+  createDatabaseNode(params, position) {
+    const queryIndex = params.indexOf("query");
+    const query = queryIndex !== -1 ? params.slice(queryIndex + 1).join(" ") : "";
+    return {
+      type: "database",
+      query,
+      position: position || { x: 0, y: 0, z: 0 },
+      hologram: {
+        shape: "cylinder",
+        color: "#ffd700",
+        // Gold
+        size: 1.5,
+        glow: true,
+        interactive: true
+      }
+    };
+  }
+  createFetchNode(params, position) {
+    const urlIndex = params.indexOf("url");
+    const url = urlIndex !== -1 ? params[urlIndex + 1] : "";
+    return {
+      type: "fetch",
+      url,
+      method: "GET",
+      position: position || { x: 0, y: 0, z: 0 },
+      hologram: {
+        shape: "orb",
+        color: "#00ff00",
+        // Green
+        size: 0.8,
+        glow: true,
+        interactive: true
+      }
+    };
+  }
   parsePinchGesture(gesture) {
     return [{
       type: "create",
@@ -1346,7 +591,7 @@ var HoloScriptParser = class {
     }];
   }
   tokenizeCommand(command) {
-    return command.toLowerCase().replace(/[^\w\s]/g, " ").split(/\s+/).filter((token) => token.length > 0);
+    return command.replace(/[^\w\s.,:/=?&"'*()\[\]@%${}-]/g, " ").split(/\s+/).filter((token) => token.length > 0);
   }
   sanitizeTokens(tokens) {
     return tokens.filter((token) => {
@@ -1388,6 +633,167 @@ var HoloScriptParser = class {
       hologram: { shape: "orb", color: "#808080", size: 0.5, glow: false, interactive: true }
     }];
   }
+  parseComposition(tokens) {
+    const name = tokens[0] || "unnamed_composition";
+    return [{
+      type: "composition",
+      name,
+      children: [],
+      position: { x: 0, y: 0, z: 0 }
+    }];
+  }
+  parseEnvironment(tokens) {
+    const settings = {};
+    if (tokens.includes("fog")) settings.fog = true;
+    if (tokens.includes("audio")) settings.audio = tokens[tokens.indexOf("audio") + 1];
+    if (tokens.includes("theme")) settings.theme = tokens[tokens.indexOf("theme") + 1];
+    return [{
+      type: "environment",
+      settings
+    }];
+  }
+  parseTemplate(tokens) {
+    const name = tokens[0] || "template";
+    const parameters = tokens.slice(1).filter((t) => t !== "with" && t !== "params");
+    return [{
+      type: "template",
+      name,
+      parameters,
+      body: []
+    }];
+  }
+  parseGlobalHandler(type, tokens) {
+    return [{
+      type: "global_handler",
+      handlerType: type === "every" ? "every" : "on_gesture",
+      config: { value: tokens[0] },
+      action: tokens.slice(1).join(" ")
+    }];
+  }
+  parseScale(tokens) {
+    const magnitude = tokens[0] || "standard";
+    const multipliers = {
+      "galactic": 1e6,
+      "macro": 1e3,
+      "standard": 1,
+      "micro": 1e-3,
+      "atomic": 1e-6
+    };
+    return [{
+      type: "scale",
+      magnitude,
+      multiplier: multipliers[magnitude] || 1,
+      body: []
+    }];
+  }
+  parseFocus(tokens) {
+    return [{
+      type: "focus",
+      target: tokens[0] || "origin",
+      body: []
+    }];
+  }
+  // ============================================================================
+  // HS+ Directive Parsing
+  // ============================================================================
+  parseStateDirective(tokens) {
+    const body = {};
+    for (let i = 0; i < tokens.length; i += 2) {
+      if (tokens[i] && tokens[i + 1]) {
+        const key = tokens[i].replace(":", "");
+        const val = this.parseLiteral(tokens[i + 1]);
+        body[key] = val;
+      }
+    }
+    return [{
+      type: "state-declaration",
+      directives: [{ type: "state", body }]
+    }];
+  }
+  extractDirectives(tokens) {
+    const directives = [];
+    for (let i = 0; i < tokens.length; i++) {
+      const token = tokens[i];
+      if (token.startsWith("@")) {
+        const name = token.slice(1);
+        if (this.isTrait(name)) {
+          let config = {};
+          if (tokens[i + 1] === "{") {
+            const closingIndex = this.findClosingBrace(tokens, i + 1);
+            if (closingIndex !== -1) {
+              config = this.parseProperties(tokens.slice(i + 2, closingIndex));
+              i = closingIndex;
+            }
+          }
+          directives.push({
+            type: "trait",
+            name,
+            config
+          });
+        } else if (this.isLifecycleHook(name)) {
+          directives.push({
+            type: "lifecycle",
+            hook: name,
+            body: tokens[i + 1] || ""
+            // Assume next token is body for now
+          });
+          i++;
+        }
+      }
+    }
+    return directives;
+  }
+  isTrait(name) {
+    const traits = ["grabbable", "throwable", "pointable", "hoverable", "scalable", "rotatable", "stackable", "snappable", "breakable"];
+    return traits.includes(name);
+  }
+  isLifecycleHook(name) {
+    const hooks = ["on_mount", "on_unmount", "on_update", "on_data_update", "on_grab", "on_release", "on_click"];
+    return hooks.includes(name);
+  }
+  parseLiteral(val) {
+    if (val === "true") return true;
+    if (val === "false") return false;
+    if (val === "null") return null;
+    if (!isNaN(Number(val))) return Number(val);
+    if (val.startsWith('"') && val.endsWith('"') || val.startsWith("'") && val.endsWith("'")) {
+      return val.slice(1, -1);
+    }
+    return val;
+  }
+  parseProperties(tokens) {
+    const props = {};
+    for (let i = 0; i < tokens.length; i++) {
+      const token = tokens[i];
+      if (token === "{" || token === "}") continue;
+      if (token.startsWith("@")) break;
+      if (token.endsWith(":")) {
+        const key = token.slice(0, -1);
+        const val = tokens[i + 1];
+        if (val) {
+          props[key] = this.parseLiteral(val);
+          i++;
+        }
+      } else if (tokens[i + 1] === ":") {
+        const key = token;
+        const val = tokens[i + 2];
+        if (val) {
+          props[key] = this.parseLiteral(val);
+          i += 2;
+        }
+      }
+    }
+    return props;
+  }
+  findClosingBrace(tokens, startIndex) {
+    let depth = 0;
+    for (let i = startIndex; i < tokens.length; i++) {
+      if (tokens[i] === "{") depth++;
+      else if (tokens[i] === "}") depth--;
+      if (depth === 0) return i;
+    }
+    return -1;
+  }
   getAST() {
     return [...this.ast];
   }
@@ -1417,8 +823,9 @@ var HoloScriptParser = class {
   }
 };
 
-// src/parser/HoloScriptPlusParser.ts
+// src/constants.ts
 var VR_TRAITS = [
+  // Core VR Interaction Traits
   "grabbable",
   "throwable",
   "pointable",
@@ -1427,7 +834,56 @@ var VR_TRAITS = [
   "rotatable",
   "stackable",
   "snappable",
-  "breakable"
+  "breakable",
+  "stretchable",
+  "moldable",
+  // Humanoid/Avatar Traits
+  "skeleton",
+  "body",
+  "face",
+  "expressive",
+  "hair",
+  "clothing",
+  "hands",
+  "character_voice",
+  "locomotion",
+  "poseable",
+  "morph",
+  // Networking & AI
+  "networked",
+  "proactive",
+  // Media Production Traits
+  "recordable",
+  "streamable",
+  "camera",
+  "video",
+  // Analytics & Research Traits
+  "trackable",
+  "survey",
+  "abtest",
+  "heatmap",
+  // Social & Viral Traits
+  "shareable",
+  "embeddable",
+  "qr",
+  "collaborative",
+  // Effects Traits
+  "particle",
+  "transition",
+  "filter",
+  "trail",
+  // Audio Traits
+  "spatial_audio",
+  "voice",
+  "reactive_audio",
+  // AI & Generative Traits
+  "narrator",
+  "responsive",
+  "procedural",
+  "captioned",
+  // Timeline & Choreography Traits
+  "timeline",
+  "choreography"
 ];
 var LIFECYCLE_HOOKS = [
   // Standard lifecycle
@@ -1452,8 +908,152 @@ var LIFECYCLE_HOOKS = [
   "on_trigger_hold",
   "on_trigger_release",
   "on_grip_hold",
-  "on_grip_release"
+  "on_grip_release",
+  // Stretchable/Moldable hooks
+  "on_stretch",
+  "on_sculpt",
+  // Humanoid/Avatar hooks
+  "on_pose_change",
+  "on_expression_change",
+  "on_gesture",
+  "on_speak",
+  "on_pose_save",
+  "on_morph_change",
+  // Media Production hooks
+  "on_record_start",
+  "on_record_stop",
+  "on_record_pause",
+  "on_stream_start",
+  "on_stream_stop",
+  "on_viewer_join",
+  "on_viewer_leave",
+  "on_chat_message",
+  "on_camera_switch",
+  "on_video_end",
+  "on_video_error",
+  // Analytics hooks
+  "on_track_event",
+  "on_survey_start",
+  "on_survey_complete",
+  "on_survey_skip",
+  "on_variant_assigned",
+  "on_conversion",
+  "on_hotspot_detected",
+  // Social hooks
+  "on_share",
+  "on_share_complete",
+  "on_embed",
+  "on_scan",
+  "on_user_join",
+  "on_user_leave",
+  "on_draw_stroke",
+  "on_object_lock",
+  "on_object_unlock",
+  // Effects hooks
+  "on_particle_spawn",
+  "on_particle_death",
+  "on_transition_start",
+  "on_transition_complete",
+  "on_filter_change",
+  // Audio hooks
+  "on_audio_start",
+  "on_audio_end",
+  "on_voice_command",
+  "on_speech_start",
+  "on_speech_end",
+  "on_beat",
+  "on_frequency_peak",
+  // AI hooks
+  "on_narration_start",
+  "on_narration_end",
+  "on_user_question",
+  "on_response_ready",
+  "on_emotion_change",
+  "on_generation_complete",
+  // Timeline hooks
+  "on_timeline_start",
+  "on_timeline_complete",
+  "on_keyframe_hit",
+  "on_keyframe_add",
+  "on_beat_sync",
+  "on_move_complete"
+];
+
+// src/HoloScriptValidator.ts
+var _HoloScriptValidator = class _HoloScriptValidator {
+  constructor() {
+    this.parser = new chunkT57ZL7KR_cjs.HoloScriptCodeParser();
+  }
+  /**
+   * Validates source code and returns a list of errors.
+   */
+  validate(code) {
+    const errors = [];
+    try {
+      this.parser.parse(code);
+    } catch (e) {
+      errors.push({
+        line: e.line || 1,
+        // Fallback if parser doesn't provide line
+        column: e.column || 1,
+        message: e.message || "Syntax Error",
+        severity: "error"
+      });
+      return errors;
+    }
+    const lines = code.split("\n");
+    lines.forEach((line, index) => {
+      const lineNum = index + 1;
+      const trimmed = line.trim();
+      if (!trimmed || trimmed.startsWith("//")) return;
+      if (trimmed.startsWith("@")) {
+        const match = trimmed.match(/^@(\w+)/);
+        if (match) {
+          const directive = match[1];
+          if (!_HoloScriptValidator.VALID_DIRECTIVES.includes(directive)) {
+            errors.push({
+              line: lineNum,
+              column: line.indexOf("@") + 1,
+              message: `Unknown directive '@${directive}'. Allowed: ${_HoloScriptValidator.VALID_DIRECTIVES.join(", ")}`,
+              severity: "warning"
+              // directives might be custom, so warning for now
+            });
+          }
+        }
+      }
+      if (trimmed.endsWith("{")) {
+        const firstWord = trimmed.split(" ")[0];
+        if (line.match(/^[a-z]+\s+[\w#]+\s*\{$/)) {
+          if (!_HoloScriptValidator.VALID_KEYWORDS.includes(firstWord) && !trimmed.startsWith("trait")) ;
+        }
+      }
+    });
+    return errors;
+  }
+};
+// Whitelists
+_HoloScriptValidator.VALID_DIRECTIVES = [
+  "trait",
+  "state",
+  "on_enter",
+  "on_exit",
+  "on_mount",
+  "on_tick",
+  "on_create",
+  "bot_config",
+  "lifecycle"
 ];
+_HoloScriptValidator.VALID_KEYWORDS = [
+  "world",
+  "scene",
+  "prefab",
+  "object",
+  "import",
+  "export"
+];
+var HoloScriptValidator = _HoloScriptValidator;
+
+// src/parser/HoloScriptPlusParser.ts
 var Lexer = class {
   constructor(source) {
     this.pos = 0;
@@ -1847,6 +1447,10 @@ var HoloScriptPlusParser = class {
     this.pos = 0;
     const lexer = new Lexer(source);
     this.tokens = lexer.tokenize();
+    try {
+      chunkJEQ2X3Z6_cjs.__require("fs").writeFileSync("tokens.log", JSON.stringify(this.tokens, null, 2));
+    } catch (e) {
+    }
     const root = this.parseDocument();
     const ast = {
       type: "Program",
@@ -1884,6 +1488,20 @@ var HoloScriptPlusParser = class {
       }
       this.skipNewlines();
     }
+    if (this.check("EOF") && directives.length > 0) {
+      return {
+        type: "fragment",
+        id: "root",
+        properties: {},
+        directives,
+        children: [],
+        traits: /* @__PURE__ */ new Map(),
+        loc: {
+          start: { line: 1, column: 1 },
+          end: { line: this.current().line, column: this.current().column }
+        }
+      };
+    }
     const root = this.parseNode();
     root.directives = [...directives, ...root.directives];
     return root;
@@ -2017,6 +1635,20 @@ var HoloScriptPlusParser = class {
       const body = this.parseControlFlowBody();
       return { type: "for", variable, iterable, body };
     }
+    if (name === "forEach") {
+      this.hasControlFlow = true;
+      const variable = this.expect("IDENTIFIER", "Expected variable name").value;
+      this.expect("IDENTIFIER", 'Expected "in"');
+      const collection = this.parseInlineExpression();
+      const body = this.parseControlFlowBody();
+      return { type: "forEach", variable, collection, body };
+    }
+    if (name === "while") {
+      this.hasControlFlow = true;
+      const condition = this.parseInlineExpression();
+      const body = this.parseControlFlowBody();
+      return { type: "while", condition, body };
+    }
     if (name === "if") {
       this.hasControlFlow = true;
       const condition = this.parseInlineExpression();
@@ -2049,6 +1681,39 @@ var HoloScriptPlusParser = class {
       this.imports.push({ path, alias });
       return { type: "import", path, alias };
     }
+    if (name === "external_api") {
+      const config = this.parseTraitConfig();
+      const url = config.url || "";
+      const method = config.method || "GET";
+      const interval = config.interval || "0s";
+      let body = [];
+      if (this.check("LBRACE")) {
+        body = this.parseControlFlowBody();
+      }
+      return { type: "external_api", url, method, interval, body };
+    }
+    if (name === "generate") {
+      const config = this.parseTraitConfig();
+      const prompt = config.prompt || "";
+      const context = config.context || "";
+      const target = config.target || "children";
+      return { type: "generate", prompt, context, target };
+    }
+    if (name === "npc") {
+      try {
+        chunkJEQ2X3Z6_cjs.__require("fs").appendFileSync("debug_parser.log", `ENTERED NPC BLOCK. Name length: ${name.length}
+`);
+      } catch (e) {
+      }
+      const npcName = this.expect("STRING", "Expected NPC name").value;
+      const props = this.parsePropsBlock();
+      return { type: "npc", name: npcName, props };
+    }
+    if (name === "dialog") {
+      const dialogName = this.expect("STRING", "Expected dialog name").value;
+      const { props, options } = this.parseDialogBlock();
+      return { type: "dialog", name: dialogName, props, options };
+    }
     if (this.options.strict) {
       this.error(`Unknown directive @${name}`);
     } else {
@@ -2056,32 +1721,87 @@ var HoloScriptPlusParser = class {
     }
     return null;
   }
-  parseTraitConfig() {
-    const config = {};
-    if (this.check("LPAREN")) {
+  parsePropsBlock() {
+    this.skipNewlines();
+    const props = {};
+    if (this.check("LBRACE")) {
       this.advance();
-      while (!this.check("RPAREN") && !this.check("EOF")) {
+      this.skipNewlines();
+      while (!this.check("RBRACE") && !this.check("EOF")) {
         const key = this.expect("IDENTIFIER", "Expected property name").value;
         if (this.check("COLON") || this.check("EQUALS")) {
           this.advance();
-          config[key] = this.parseValue();
+          props[key] = this.parseValue();
         } else {
-          config[key] = true;
+          props[key] = true;
         }
-        if (this.check("COMMA")) this.advance();
+        this.skipNewlines();
       }
-      this.expect("RPAREN", "Expected )");
+      this.expect("RBRACE", "Expected }");
     }
-    return config;
+    return props;
   }
-  parseStateBlock() {
-    const state = {};
+  parseDialogBlock() {
+    this.skipNewlines();
+    const props = {};
+    const options = [];
     if (this.check("LBRACE")) {
       this.advance();
       this.skipNewlines();
       while (!this.check("RBRACE") && !this.check("EOF")) {
-        const key = this.expect("IDENTIFIER", "Expected state variable name").value;
-        if (this.check("COLON") || this.check("EQUALS")) {
+        if (this.check("IDENTIFIER") && this.current().value === "option") {
+          this.advance();
+          const text = this.expect("STRING", "Expected option text").value;
+          this.expect("ARROW", "Expected ->");
+          let target;
+          if (this.check("AT")) {
+            const d = this.parseDirective();
+            target = { type: "directive", value: d };
+          } else {
+            target = this.expect("STRING", "Expected target ID").value;
+          }
+          options.push({ text, target });
+        } else {
+          const key = this.expect("IDENTIFIER", "Expected property name").value;
+          if (this.check("COLON") || this.check("EQUALS")) {
+            this.advance();
+            props[key] = this.parseValue();
+          } else {
+            props[key] = true;
+          }
+        }
+        this.skipNewlines();
+      }
+      this.expect("RBRACE", "Expected }");
+    }
+    return { props, options };
+  }
+  parseTraitConfig() {
+    const config = {};
+    if (this.check("LPAREN")) {
+      this.advance();
+      while (!this.check("RPAREN") && !this.check("EOF")) {
+        const key = this.expect("IDENTIFIER", "Expected property name").value;
+        if (this.check("COLON") || this.check("EQUALS")) {
+          this.advance();
+          config[key] = this.parseValue();
+        } else {
+          config[key] = true;
+        }
+        if (this.check("COMMA")) this.advance();
+      }
+      this.expect("RPAREN", "Expected )");
+    }
+    return config;
+  }
+  parseStateBlock() {
+    const state = {};
+    if (this.check("LBRACE")) {
+      this.advance();
+      this.skipNewlines();
+      while (!this.check("RBRACE") && !this.check("EOF")) {
+        const key = this.expect("IDENTIFIER", "Expected state variable name").value;
+        if (this.check("COLON") || this.check("EQUALS")) {
           this.advance();
           state[key] = this.parseValue();
         } else {
@@ -2279,10 +1999,825 @@ function parse(source, options) {
   return parser.parse(source);
 }
 
+// src/traits/MaterialTrait.ts
+var MaterialTrait = class {
+  constructor(config) {
+    this.textureCache = /* @__PURE__ */ new Map();
+    this.material = {
+      ...{ type: "pbr" },
+      ...config
+    };
+  }
+  /**
+   * Get material properties
+   */
+  getMaterial() {
+    return { ...this.material };
+  }
+  /**
+   * Update material property
+   */
+  setProperty(key, value) {
+    this.material[key] = value;
+  }
+  /**
+   * Get PBR properties
+   */
+  getPBRProperties() {
+    return this.material.pbr;
+  }
+  /**
+   * Update PBR material
+   */
+  updatePBR(pbr) {
+    if (!this.material.pbr) {
+      this.material.pbr = {
+        baseColor: { r: 1, g: 1, b: 1 },
+        metallic: 0,
+        roughness: 0.5
+      };
+    }
+    this.material.pbr = { ...this.material.pbr, ...pbr };
+  }
+  /**
+   * Add texture map
+   */
+  addTexture(texture) {
+    if (!this.material.textures) {
+      this.material.textures = [];
+    }
+    this.material.textures.push(texture);
+  }
+  /**
+   * Get all textures
+   */
+  getTextures() {
+    return [...this.material.textures || []];
+  }
+  /**
+   * Clear texture cache (for memory optimization)
+   */
+  clearTextureCache() {
+    this.textureCache.clear();
+  }
+  /**
+   * Get shader code if custom
+   */
+  getCustomShader() {
+    return this.material.customShader;
+  }
+  /**
+   * Set custom shader
+   */
+  setCustomShader(shader) {
+    this.material.customShader = shader;
+  }
+  /**
+   * Get optimization hints
+   */
+  getOptimization() {
+    return this.material.optimization;
+  }
+  /**
+   * Enable/disable texture streaming
+   */
+  setTextureStreaming(enabled) {
+    if (!this.material.optimization) {
+      this.material.optimization = {};
+    }
+    this.material.optimization.streamTextures = enabled;
+  }
+  /**
+   * Set texture compression
+   */
+  setCompression(compression) {
+    if (!this.material.optimization) {
+      this.material.optimization = {};
+    }
+    this.material.optimization.compression = compression;
+  }
+  /**
+   * Enable material instancing for performance
+   */
+  setInstanced(instanced) {
+    if (!this.material.optimization) {
+      this.material.optimization = {};
+    }
+    this.material.optimization.instanced = instanced;
+  }
+  /**
+   * Dispose and cleanup
+   */
+  dispose() {
+    this.textureCache.clear();
+  }
+};
+function createMaterialTrait(config) {
+  return new MaterialTrait(config);
+}
+var MATERIAL_PRESETS = {
+  /** Shiny metal */
+  chrome: () => ({
+    type: "pbr",
+    pbr: {
+      baseColor: { r: 0.77, g: 0.77, b: 0.77 },
+      metallic: 1,
+      roughness: 0.1
+    }
+  }),
+  /** Rough plastic */
+  plastic: () => ({
+    type: "pbr",
+    pbr: {
+      baseColor: { r: 1, g: 1, b: 1 },
+      metallic: 0,
+      roughness: 0.8
+    }
+  }),
+  /** Wood texture */
+  wood: () => ({
+    type: "pbr",
+    pbr: {
+      baseColor: { r: 0.6, g: 0.4, b: 0.2 },
+      metallic: 0,
+      roughness: 0.4
+    }
+  }),
+  /** Glass */
+  glass: () => ({
+    type: "transparent",
+    blendMode: "blend",
+    pbr: {
+      baseColor: { r: 1, g: 1, b: 1, a: 0.3 },
+      metallic: 0,
+      roughness: 0,
+      ior: 1.5,
+      transmission: 0.9
+    }
+  }),
+  /** Emissive (glowing) */
+  emissive: () => ({
+    type: "pbr",
+    pbr: {
+      baseColor: { r: 0, g: 1, b: 0 },
+      metallic: 0,
+      roughness: 1,
+      emission: {
+        color: { r: 0, g: 1, b: 0 },
+        intensity: 2
+      }
+    }
+  }),
+  /** Skin material */
+  skin: () => ({
+    type: "pbr",
+    pbr: {
+      baseColor: { r: 1, g: 0.8, b: 0.7 },
+      metallic: 0,
+      roughness: 0.5,
+      ambientOcclusion: 0.8
+    }
+  })
+};
+
+// src/traits/LightingTrait.ts
+var LightingTrait = class {
+  constructor(config) {
+    this.lights = /* @__PURE__ */ new Map();
+    this.lightIdCounter = 0;
+    this.globalIllumination = {
+      enabled: true,
+      intensity: 1,
+      skyColor: { r: 0.5, g: 0.7, b: 1 },
+      skyIntensity: 1,
+      groundColor: { r: 0.4, g: 0.4, b: 0.4 },
+      groundIntensity: 0.5,
+      probes: true,
+      indirectDiffuse: 1,
+      indirectSpecular: 1,
+      aoIntensity: 1,
+      screenSpaceAO: true,
+      ...config
+    };
+  }
+  /**
+   * Add a light to the scene
+   */
+  addLight(light) {
+    const id = light.name || `light_${this.lightIdCounter++}`;
+    this.lights.set(id, light);
+    return id;
+  }
+  /**
+   * Get light by ID
+   */
+  getLight(id) {
+    return this.lights.get(id);
+  }
+  /**
+   * Get all lights
+   */
+  getLights() {
+    return Array.from(this.lights.values());
+  }
+  /**
+   * Get lights by type
+   */
+  getLightsByType(type) {
+    return Array.from(this.lights.values()).filter((l) => l.type === type);
+  }
+  /**
+   * Update light properties
+   */
+  updateLight(id, updates) {
+    const light = this.lights.get(id);
+    if (!light) return false;
+    this.lights.set(id, { ...light, ...updates });
+    return true;
+  }
+  /**
+   * Remove light
+   */
+  removeLight(id) {
+    return this.lights.delete(id);
+  }
+  /**
+   * Clear all lights
+   */
+  clearLights() {
+    this.lights.clear();
+  }
+  /**
+   * Get global illumination config
+   */
+  getGlobalIllumination() {
+    return { ...this.globalIllumination };
+  }
+  /**
+   * Update global illumination
+   */
+  updateGlobalIllumination(updates) {
+    this.globalIllumination = {
+      ...this.globalIllumination,
+      ...updates
+    };
+  }
+  /**
+   * Enable/disable GI
+   */
+  setGIEnabled(enabled) {
+    this.globalIllumination.enabled = enabled;
+  }
+  /**
+   * Set ambient light colors (skybox mode)
+   */
+  setAmbientLight(skyColor, groundColor, intensity = 1) {
+    this.globalIllumination.skyColor = skyColor;
+    this.globalIllumination.groundColor = groundColor;
+    this.globalIllumination.skyIntensity = intensity;
+    this.globalIllumination.groundIntensity = intensity * 0.5;
+  }
+  /**
+   * Enable/disable screen-space ambient occlusion
+   */
+  setScreenSpaceAO(enabled, intensity = 1) {
+    this.globalIllumination.screenSpaceAO = enabled;
+    this.globalIllumination.aoIntensity = intensity;
+  }
+  /**
+   * Create directional light (sun)
+   */
+  createDirectionalLight(direction, color, intensity = 1, castShadows = true) {
+    const light = {
+      type: "directional",
+      name: `sun_${this.lightIdCounter}`,
+      direction,
+      color,
+      intensity,
+      shadow: castShadows ? {
+        type: "soft",
+        resolution: 2048,
+        cascades: 4,
+        softness: 1
+      } : void 0,
+      volumetric: true,
+      priority: 100
+    };
+    return this.addLight(light);
+  }
+  /**
+   * Create point light
+   */
+  createPointLight(position, color, intensity, range, castShadows = false) {
+    const light = {
+      type: "point",
+      name: `point_${this.lightIdCounter}`,
+      position,
+      color,
+      intensity,
+      range,
+      shadow: castShadows ? {
+        type: "soft",
+        resolution: 512,
+        softness: 0.5
+      } : void 0,
+      priority: 50
+    };
+    return this.addLight(light);
+  }
+  /**
+   * Create spot light
+   */
+  createSpotLight(position, direction, color, intensity, range, spotAngle = 45, castShadows = true) {
+    const light = {
+      type: "spot",
+      name: `spot_${this.lightIdCounter}`,
+      position,
+      direction,
+      color,
+      intensity,
+      range,
+      spotAngle,
+      innerSpotAngle: spotAngle * 0.5,
+      shadow: castShadows ? {
+        type: "soft",
+        resolution: 1024,
+        softness: 0.8
+      } : void 0,
+      priority: 75
+    };
+    return this.addLight(light);
+  }
+  /**
+   * Create area light for soft lighting
+   */
+  createAreaLight(position, color, intensity, width, height) {
+    const light = {
+      type: "area",
+      name: `area_${this.lightIdCounter}`,
+      position,
+      color,
+      intensity,
+      range: Math.max(width, height) * 2,
+      priority: 25
+    };
+    return this.addLight(light);
+  }
+  /**
+   * Get shadow-casting lights
+   */
+  getShadowCastingLights() {
+    return Array.from(this.lights.values()).filter((l) => l.shadow && l.shadow.type !== "none");
+  }
+  /**
+   * Get light count by type
+   */
+  getLightCount() {
+    const counts = {
+      directional: 0,
+      point: 0,
+      spot: 0,
+      area: 0,
+      probe: 0
+    };
+    for (const light of Array.from(this.lights.values())) {
+      counts[light.type]++;
+    }
+    return counts;
+  }
+  /**
+   * Estimate light impact for performance optimization
+   */
+  getPerformanceImpact() {
+    const totalLights = this.lights.size;
+    const shadowCasters = this.getShadowCastingLights().length;
+    let estimatedGPUCost = "low";
+    if (totalLights > 16 || shadowCasters > 4) {
+      estimatedGPUCost = "high";
+    } else if (totalLights > 8 || shadowCasters > 2) {
+      estimatedGPUCost = "medium";
+    }
+    return {
+      totalLights,
+      shadowCasters,
+      estimatedGPUCost
+    };
+  }
+  /**
+   * Get scene complexity info
+   */
+  getSceneInfo() {
+    const counts = this.getLightCount();
+    const impact = this.getPerformanceImpact();
+    return `Lighting: ${counts.directional} dir, ${counts.point} point, ${counts.spot} spot | Shadows: ${impact.shadowCasters} | GPU: ${impact.estimatedGPUCost}`;
+  }
+  /**
+   * Dispose and cleanup
+   */
+  dispose() {
+    this.lights.clear();
+  }
+};
+function createLightingTrait(config) {
+  return new LightingTrait(config);
+}
+var LIGHTING_PRESETS = {
+  /** Neutral studio lighting */
+  studio: () => ({
+    enabled: true,
+    intensity: 1,
+    skyColor: { r: 0.5, g: 0.5, b: 0.5 },
+    skyIntensity: 0.5,
+    groundColor: { r: 0.3, g: 0.3, b: 0.3 },
+    groundIntensity: 0.3
+  }),
+  /** Bright outdoor lighting */
+  outdoor: () => ({
+    enabled: true,
+    intensity: 1.2,
+    skyColor: { r: 0.7, g: 0.85, b: 1 },
+    skyIntensity: 1,
+    groundColor: { r: 0.4, g: 0.4, b: 0.35 },
+    groundIntensity: 0.6,
+    indirectDiffuse: 1.2
+  }),
+  /** Dim interior lighting */
+  interior: () => ({
+    enabled: true,
+    intensity: 0.6,
+    skyColor: { r: 0.3, g: 0.3, b: 0.35 },
+    skyIntensity: 0.4,
+    groundColor: { r: 0.2, g: 0.2, b: 0.2 },
+    groundIntensity: 0.2
+  }),
+  /** Night scene */
+  night: () => ({
+    enabled: true,
+    intensity: 0.3,
+    skyColor: { r: 0.01, g: 0.01, b: 0.02 },
+    skyIntensity: 0.1,
+    groundColor: { r: 0.02, g: 0.02, b: 0.02 },
+    groundIntensity: 0.05,
+    screenSpaceAO: false
+  }),
+  /** Sunset/golden hour */
+  sunset: () => ({
+    enabled: true,
+    intensity: 1.1,
+    skyColor: { r: 1, g: 0.7, b: 0.3 },
+    skyIntensity: 1,
+    groundColor: { r: 0.6, g: 0.4, b: 0.2 },
+    groundIntensity: 0.8
+  })
+};
+
+// src/traits/RenderingTrait.ts
+var RenderingTrait = class {
+  constructor(config) {
+    this.optimization = {
+      lodStrategy: "automatic",
+      culling: {
+        mode: "back",
+        frustum: true,
+        occlusion: true
+      },
+      batching: {
+        static: true,
+        dynamic: true,
+        instancing: true,
+        maxInstanceCount: 1e3
+      },
+      textures: {
+        streaming: true,
+        compression: "auto",
+        mipmaps: true,
+        maxResolution: 2048
+      },
+      shaders: {
+        simplifiedShaders: true,
+        lodBias: 0
+      },
+      targetGPUTier: "high",
+      adaptiveQuality: true,
+      targetFrameRate: 60,
+      ...config
+    };
+  }
+  /**
+   * Get rendering optimization config
+   */
+  getOptimization() {
+    return JSON.parse(JSON.stringify(this.optimization));
+  }
+  /**
+   * Update rendering configuration
+   */
+  updateOptimization(updates) {
+    this.optimization = { ...this.optimization, ...updates };
+  }
+  /**
+   * Setup LOD levels (3 levels is typical)
+   */
+  setupLODLevels(strategy = "automatic") {
+    const levels = [
+      {
+        level: 0,
+        screenRelativeSize: 0.5,
+        polygonReduction: 1,
+        textureScale: 1
+      },
+      {
+        level: 1,
+        screenRelativeSize: 0.25,
+        polygonReduction: 0.6,
+        disabledFeatures: ["specular"],
+        textureScale: 0.5
+      },
+      {
+        level: 2,
+        screenRelativeSize: 0.1,
+        polygonReduction: 0.3,
+        disabledFeatures: ["specular", "normals"],
+        textureScale: 0.25
+      }
+    ];
+    this.optimization.lodStrategy = strategy;
+    this.optimization.lodLevels = levels;
+  }
+  /**
+   * Get LOD levels
+   */
+  getLODLevels() {
+    return [...this.optimization.lodLevels || []];
+  }
+  /**
+   * Configure culling
+   */
+  setCulling(config) {
+    const defaultCulling = { mode: "back" };
+    this.optimization.culling = {
+      ...defaultCulling,
+      ...this.optimization.culling,
+      ...config
+    };
+  }
+  /**
+   * Enable frustum culling
+   */
+  setFrustumCulling(enabled) {
+    if (!this.optimization.culling) {
+      this.optimization.culling = { mode: "back" };
+    }
+    this.optimization.culling.frustum = enabled;
+  }
+  /**
+   * Enable occlusion culling
+   */
+  setOcclusionCulling(enabled, distance) {
+    if (!this.optimization.culling) {
+      this.optimization.culling = { mode: "back" };
+    }
+    this.optimization.culling.occlusion = enabled;
+    if (distance) {
+      this.optimization.culling.occlusionDistance = distance;
+    }
+  }
+  /**
+   * Configure batching
+   */
+  setBatching(config) {
+    this.optimization.batching = {
+      ...this.optimization.batching,
+      ...config
+    };
+  }
+  /**
+   * Enable GPU instancing
+   */
+  setInstancing(enabled, maxInstances) {
+    if (!this.optimization.batching) {
+      this.optimization.batching = {};
+    }
+    this.optimization.batching.instancing = enabled;
+    if (maxInstances) {
+      this.optimization.batching.maxInstanceCount = maxInstances;
+    }
+  }
+  /**
+   * Configure texture optimization
+   */
+  setTextureOptimization(config) {
+    this.optimization.textures = {
+      ...this.optimization.textures,
+      ...config
+    };
+  }
+  /**
+   * Enable texture streaming
+   */
+  setTextureStreaming(enabled, budgetMB) {
+    if (!this.optimization.textures) {
+      this.optimization.textures = {};
+    }
+    this.optimization.textures.streaming = enabled;
+    if (budgetMB) {
+      this.optimization.textures.streamingBudget = budgetMB;
+    }
+  }
+  /**
+   * Set texture compression
+   */
+  setTextureCompression(compression) {
+    if (!this.optimization.textures) {
+      this.optimization.textures = {};
+    }
+    this.optimization.textures.compression = compression;
+  }
+  /**
+   * Set max texture resolution
+   */
+  setMaxTextureResolution(resolution) {
+    if (!this.optimization.textures) {
+      this.optimization.textures = {};
+    }
+    this.optimization.textures.maxResolution = resolution;
+  }
+  /**
+   * Configure shader optimization
+   */
+  setShaderOptimization(config) {
+    this.optimization.shaders = {
+      ...this.optimization.shaders,
+      ...config
+    };
+  }
+  /**
+   * Set target GPU tier
+   */
+  setTargetGPUTier(tier) {
+    this.optimization.targetGPUTier = tier;
+  }
+  /**
+   * Enable adaptive quality (adjust based on frame rate)
+   */
+  setAdaptiveQuality(enabled, targetFrameRate) {
+    this.optimization.adaptiveQuality = enabled;
+    if (targetFrameRate) {
+      this.optimization.targetFrameRate = targetFrameRate;
+    }
+  }
+  /**
+   * Set fixed timestep for VR/AR
+   */
+  setFixedTimestep(timestep) {
+    this.optimization.fixedTimestep = timestep;
+  }
+  /**
+   * Get rendering preset for quality level
+   */
+  getPresetForQuality(quality) {
+    const presets = {
+      low: {
+        targetGPUTier: "low",
+        lodStrategy: "automatic",
+        culling: { mode: "back", frustum: true, occlusion: false },
+        batching: { instancing: true, maxInstanceCount: 500 },
+        textures: {
+          compression: "astc",
+          maxResolution: 512,
+          streaming: true,
+          streamingBudget: 128
+        },
+        adaptiveQuality: true,
+        targetFrameRate: 30
+      },
+      medium: {
+        targetGPUTier: "medium",
+        lodStrategy: "automatic",
+        culling: { mode: "back", frustum: true, occlusion: true },
+        batching: { instancing: true, maxInstanceCount: 1e3 },
+        textures: {
+          compression: "basis",
+          maxResolution: 1024,
+          streaming: true,
+          streamingBudget: 256
+        },
+        adaptiveQuality: true,
+        targetFrameRate: 60
+      },
+      high: {
+        targetGPUTier: "high",
+        lodStrategy: "automatic",
+        culling: { mode: "back", frustum: true, occlusion: true },
+        batching: { instancing: true, maxInstanceCount: 2e3 },
+        textures: {
+          compression: "dxt",
+          maxResolution: 2048,
+          streaming: true,
+          streamingBudget: 512
+        },
+        adaptiveQuality: false,
+        targetFrameRate: 60
+      },
+      ultra: {
+        targetGPUTier: "ultra",
+        lodStrategy: "manual",
+        culling: {
+          mode: "back",
+          frustum: true,
+          occlusion: true,
+          hierarchicalZ: true
+        },
+        batching: { instancing: true, maxInstanceCount: 5e3 },
+        textures: {
+          compression: "none",
+          maxResolution: 4096,
+          virtualTexturing: true,
+          streaming: true,
+          streamingBudget: 1024
+        },
+        adaptiveQuality: false,
+        targetFrameRate: 120
+      }
+    };
+    return { ...this.optimization, ...presets[quality] };
+  }
+  /**
+   * Apply quality preset
+   */
+  applyQualityPreset(quality) {
+    const preset = this.getPresetForQuality(quality);
+    this.optimization = preset;
+  }
+  /**
+   * Estimate GPU memory usage
+   */
+  estimateGPUMemory() {
+    let textureMemory = 0;
+    let vertexBuffers = 0;
+    const maxRes = this.optimization.textures?.maxResolution || 2048;
+    textureMemory = maxRes * maxRes * 4 / (1024 * 1024);
+    const instanceCount = this.optimization.batching?.maxInstanceCount || 1e3;
+    const verticesPerMesh = 1e4;
+    vertexBuffers = verticesPerMesh * 36 * instanceCount / (1024 * 1024) * 0.1;
+    return {
+      textureMemory: Math.round(textureMemory),
+      vertexBuffers: Math.max(1, Math.round(vertexBuffers)),
+      // At least 1MB
+      estimatedTotal: Math.round(textureMemory + Math.max(1, vertexBuffers))
+    };
+  }
+  /**
+   * Get rendering statistics/info
+   */
+  getInfo() {
+    const tier = this.optimization.targetGPUTier;
+    const lod = this.optimization.lodStrategy;
+    const culling = this.optimization.culling?.mode;
+    const instancing = this.optimization.batching?.instancing ? "yes" : "no";
+    const memory = this.estimateGPUMemory();
+    return `Rendering: tier=${tier} | LOD=${lod} | culling=${culling} | instancing=${instancing} | memory=${memory.estimatedTotal}MB`;
+  }
+  /**
+   * Optimize for VR/AR (fixed timestep, fast culling)
+   */
+  optimizeForVRAR(targetFPS = 90) {
+    this.optimization.fixedTimestep = 1 / targetFPS;
+    this.optimization.targetFrameRate = targetFPS;
+    this.setOcclusionCulling(true, 50);
+    this.setInstancing(true, 5e3);
+    this.setAdaptiveQuality(true, targetFPS);
+  }
+  /**
+   * Optimize for mobile (lower resources)
+   */
+  optimizeForMobile() {
+    this.applyQualityPreset("low");
+    this.setTextureCompression("astc");
+    this.setInstancing(true, 256);
+  }
+  /**
+   * Optimize for desktop (higher resources)
+   */
+  optimizeForDesktop() {
+    this.applyQualityPreset("ultra");
+    this.setTextureCompression("none");
+    this.setInstancing(true, 5e3);
+  }
+  /**
+   * Dispose and cleanup
+   */
+  dispose() {
+  }
+};
+function createRenderingTrait(config) {
+  return new RenderingTrait(config);
+}
+
 // src/HoloScriptPlusParser.ts
 var HoloScriptPlusParser2 = class {
   constructor() {
-    this.baseParser = new chunk4OHVW4XR_cjs.HoloScriptCodeParser();
+    this.baseParser = new chunkT57ZL7KR_cjs.HoloScriptCodeParser();
   }
   /**
    * Parse HoloScript+ code with trait annotations
@@ -2530,8 +3065,7 @@ var HoloScriptPlusParser2 = class {
    * Create MaterialTrait from config
    */
   createMaterialTrait(config) {
-    const { MaterialTrait: MaterialTrait2 } = (init_MaterialTrait(), chunkCZLDE2OZ_cjs.__toCommonJS(MaterialTrait_exports));
-    const material = new MaterialTrait2({
+    const material = new MaterialTrait({
       type: config.type || "pbr",
       pbr: config.pbr
     });
@@ -2555,13 +3089,13 @@ var HoloScriptPlusParser2 = class {
    * Create LightingTrait from config
    */
   createLightingTrait(config) {
-    const { LightingTrait: LightingTrait2, LIGHTING_PRESETS: LIGHTING_PRESETS2 } = (init_LightingTrait(), chunkCZLDE2OZ_cjs.__toCommonJS(LightingTrait_exports));
     let lighting;
     if (config.preset) {
-      const preset = LIGHTING_PRESETS2[config.preset];
-      lighting = new LightingTrait2(preset);
+      const presetFactory = LIGHTING_PRESETS[config.preset];
+      const presetConfig = presetFactory ? presetFactory() : void 0;
+      lighting = new LightingTrait(presetConfig);
     } else {
-      lighting = new LightingTrait2();
+      lighting = new LightingTrait();
     }
     if (config.globalIllumination) {
       lighting.setGlobalIllumination(config.globalIllumination);
@@ -2577,8 +3111,7 @@ var HoloScriptPlusParser2 = class {
    * Create RenderingTrait from config
    */
   createRenderingTrait(config) {
-    const { RenderingTrait: RenderingTrait2 } = (init_RenderingTrait(), chunkCZLDE2OZ_cjs.__toCommonJS(RenderingTrait_exports));
-    const rendering = new RenderingTrait2();
+    const rendering = new RenderingTrait();
     if (config.quality) {
       rendering.applyQualityPreset(config.quality);
     }
@@ -2909,6 +3442,25 @@ var ExpressionEvaluator = class {
     };
   }
   evaluate(expression) {
+    const dangerousPatterns = [
+      /\beval\s*\(/,
+      /\brequire\s*\(/,
+      /\bimport\s*\(/,
+      /\bprocess\s*\./,
+      /\bglobal\s*\./,
+      /\b__dirname\b/,
+      /\b__filename\b/,
+      /\bfs\s*\./,
+      /\bchild_process\s*\./,
+      /\bfs\.writeFileSync/,
+      /\bfs\.readFileSync/
+    ];
+    for (const pattern of dangerousPatterns) {
+      if (pattern.test(expression)) {
+        console.warn(`Security: Blocked suspicious expression: ${expression}`);
+        return void 0;
+      }
+    }
     const contextKeys = Object.keys(this.context);
     const contextValues = Object.values(this.context);
     const builtinKeys = Object.keys(this.builtins);
@@ -2988,7 +3540,8 @@ var grabbableHandler = {
         const distance = Math.sqrt(
           Math.pow(handPos[0] - nodePos2[0], 2) + Math.pow(handPos[1] - nodePos2[1], 2) + Math.pow(handPos[2] - nodePos2[2], 2)
         );
-        if (distance > (config.max_grab_distance || 3)) return;
+        const maxDist = (config.max_grab_distance || 3) * context.getScaleMultiplier();
+        if (distance > maxDist) return;
       }
       state.isGrabbed = true;
       state.grabbingHand = event.hand;
@@ -3019,7 +3572,7 @@ var grabbableHandler = {
           ];
           if (node.traits.has("throwable")) {
             const throwConfig = node.traits.get("throwable");
-            const multiplier = throwConfig.velocity_multiplier || 1;
+            const multiplier = (throwConfig.velocity_multiplier || 1) * context.getScaleMultiplier();
             context.physics.applyVelocity(node, [
               velocity[0] * multiplier,
               velocity[1] * multiplier,
@@ -3197,6 +3750,21 @@ var scalableHandler = {
     const scaleFactor = currentDistance / state.initialDistance;
     let newScale = state.initialScale * scaleFactor;
     newScale = Math.max(config.min_scale || 0.1, Math.min(config.max_scale || 10, newScale));
+    const scaleMultiplier = context.getScaleMultiplier();
+    const effectiveScale = newScale * scaleMultiplier;
+    if (effectiveScale > 1e6 && scaleMultiplier < 1e6) {
+      context.setScaleContext("galactic");
+      newScale /= 1e6;
+    } else if (effectiveScale > 1e3 && scaleMultiplier < 1e3) {
+      context.setScaleContext("macro");
+      newScale /= 1e3;
+    } else if (effectiveScale < 1e-3 && scaleMultiplier > 1e-3) {
+      context.setScaleContext("micro");
+      newScale *= 1e3;
+    } else if (effectiveScale < 1e-6 && scaleMultiplier > 1e-6) {
+      context.setScaleContext("atomic");
+      newScale *= 1e6;
+    }
     node.properties.scale = newScale;
     context.emit("scale_update", { node, scale: newScale });
   },
@@ -3372,12 +3940,12 @@ var snappableHandler = {
     snap_rotation: false,
     magnetic: false
   },
-  onUpdate(node, config, _context, _delta) {
+  onUpdate(node, config, context, _delta) {
     if (!config.snap_points || config.snap_points.length === 0) return;
     if (!config.magnetic) return;
     const nodePos = node.properties.position || [0, 0, 0];
     let closestPoint = null;
-    let closestDistance = config.snap_distance || 0.3;
+    let closestDistance = (config.snap_distance || 0.3) * context.getScaleMultiplier();
     for (const snapPoint of config.snap_points) {
       const distance = Math.sqrt(
         Math.pow(nodePos[0] - snapPoint[0], 2) + Math.pow(nodePos[1] - snapPoint[1], 2) + Math.pow(nodePos[2] - snapPoint[2], 2)
@@ -3401,7 +3969,7 @@ var snappableHandler = {
     if (!config.snap_points || config.snap_points.length === 0) return;
     const nodePos = node.properties.position || [0, 0, 0];
     let closestPoint = null;
-    let closestDistance = config.snap_distance || 0.3;
+    let closestDistance = (config.snap_distance || 0.3) * context.getScaleMultiplier();
     for (const snapPoint of config.snap_points) {
       const distance = Math.sqrt(
         Math.pow(nodePos[0] - snapPoint[0], 2) + Math.pow(nodePos[1] - snapPoint[1], 2) + Math.pow(nodePos[2] - snapPoint[2], 2)
@@ -3457,202 +4025,138 @@ var breakableHandler = {
     }
     context.emit("break", { node, impactVelocity, collision });
     if (config.respawn) {
-      const delay = parseDuration(config.respawn_delay || "5s");
-      setTimeout(() => {
-        context.emit("respawn", { node });
-      }, delay);
-    }
-    node.properties.__destroyed = true;
-  }
-};
-function parseDuration(duration) {
-  const match = duration.match(/^(\d+(?:\.\d+)?)(ms|s|m)$/);
-  if (!match) return 0;
-  const value = parseFloat(match[1]);
-  const unit = match[2];
-  switch (unit) {
-    case "ms":
-      return value;
-    case "s":
-      return value * 1e3;
-    case "m":
-      return value * 60 * 1e3;
-    default:
-      return value;
-  }
-}
-var VRTraitRegistry = class {
-  constructor() {
-    this.handlers = /* @__PURE__ */ new Map();
-    this.register(grabbableHandler);
-    this.register(throwableHandler);
-    this.register(pointableHandler);
-    this.register(hoverableHandler);
-    this.register(scalableHandler);
-    this.register(rotatableHandler);
-    this.register(stackableHandler);
-    this.register(snappableHandler);
-    this.register(breakableHandler);
-  }
-  register(handler) {
-    this.handlers.set(handler.name, handler);
-  }
-  getHandler(name) {
-    return this.handlers.get(name);
-  }
-  attachTrait(node, traitName, config, context) {
-    const handler = this.handlers.get(traitName);
-    if (!handler) return;
-    const mergedConfig = { ...handler.defaultConfig, ...config };
-    node.traits.set(traitName, mergedConfig);
-    if (handler.onAttach) {
-      handler.onAttach(node, mergedConfig, context);
-    }
-  }
-  detachTrait(node, traitName, context) {
-    const handler = this.handlers.get(traitName);
-    if (!handler) return;
-    const config = node.traits.get(traitName);
-    if (config && handler.onDetach) {
-      handler.onDetach(node, config, context);
-    }
-    node.traits.delete(traitName);
-  }
-  updateTrait(node, traitName, context, delta) {
-    const handler = this.handlers.get(traitName);
-    if (!handler || !handler.onUpdate) return;
-    const config = node.traits.get(traitName);
-    if (config) {
-      handler.onUpdate(node, config, context, delta);
-    }
-  }
-  handleEvent(node, traitName, context, event) {
-    const handler = this.handlers.get(traitName);
-    if (!handler || !handler.onEvent) return;
-    const config = node.traits.get(traitName);
-    if (config) {
-      handler.onEvent(node, config, context, event);
-    }
-  }
-  updateAllTraits(node, context, delta) {
-    for (const traitName of node.traits.keys()) {
-      this.updateTrait(node, traitName, context, delta);
-    }
-  }
-  handleEventForAllTraits(node, context, event) {
-    for (const traitName of node.traits.keys()) {
-      this.handleEvent(node, traitName, context, event);
-    }
-  }
-};
-var vrTraitRegistry = new VRTraitRegistry();
-
-// src/runtime/HoloScriptPlusRuntime.ts
-function createBuiltins(runtime) {
-  return {
-    Math,
-    range: (start, end, step = 1) => {
-      const result = [];
-      if (step > 0) {
-        for (let i = start; i < end; i += step) {
-          result.push(i);
-        }
-      } else if (step < 0) {
-        for (let i = start; i > end; i += step) {
-          result.push(i);
-        }
-      }
-      return result;
-    },
-    interpolate_color: (t, from, to) => {
-      const parseHex = (hex) => {
-        const clean = hex.replace("#", "");
-        return [
-          parseInt(clean.substring(0, 2), 16),
-          parseInt(clean.substring(2, 4), 16),
-          parseInt(clean.substring(4, 6), 16)
-        ];
-      };
-      const toHex = (r, g, b) => {
-        const clamp = (v) => Math.max(0, Math.min(255, Math.round(v)));
-        return `#${clamp(r).toString(16).padStart(2, "0")}${clamp(g).toString(16).padStart(2, "0")}${clamp(b).toString(16).padStart(2, "0")}`;
-      };
-      const [r1, g1, b1] = parseHex(from);
-      const [r2, g2, b2] = parseHex(to);
-      return toHex(
-        r1 + (r2 - r1) * t,
-        g1 + (g2 - g1) * t,
-        b1 + (b2 - b1) * t
-      );
-    },
-    distance_to: (point) => {
-      const viewer = runtime.vrContext.headset.position;
-      return Math.sqrt(
-        Math.pow(point[0] - viewer[0], 2) + Math.pow(point[1] - viewer[1], 2) + Math.pow(point[2] - viewer[2], 2)
-      );
-    },
-    distance_to_viewer: () => {
-      return 0;
-    },
-    hand_position: (handId) => {
-      const hand = handId === "left" ? runtime.vrContext.hands.left : runtime.vrContext.hands.right;
-      return hand?.position || [0, 0, 0];
-    },
-    hand_velocity: (handId) => {
-      const hand = handId === "left" ? runtime.vrContext.hands.left : runtime.vrContext.hands.right;
-      return hand?.velocity || [0, 0, 0];
-    },
-    dominant_hand: () => {
-      return runtime.vrContext.hands.right || runtime.vrContext.hands.left || {
-        id: "right",
-        position: [0, 0, 0],
-        rotation: [0, 0, 0],
-        velocity: [0, 0, 0],
-        grip: 0,
-        trigger: 0
-      };
-    },
-    play_sound: (source, options) => {
-      runtime.emit("play_sound", { source, ...options });
-    },
-    haptic_feedback: (hand, intensity) => {
-      const handId = typeof hand === "string" ? hand : hand.id;
-      runtime.emit("haptic", { hand: handId, intensity });
-    },
-    haptic_pulse: (intensity) => {
-      runtime.emit("haptic", { hand: "both", intensity });
-    },
-    apply_velocity: (node, velocity) => {
-      runtime.emit("apply_velocity", { node, velocity });
-    },
-    spawn: (template, position) => {
-      return runtime.spawnTemplate(template, position);
-    },
-    destroy: (node) => {
-      runtime.destroyNode(node);
-    },
-    api_call: async (url, method, body) => {
-      const response = await fetch(url, {
-        method,
-        headers: body ? { "Content-Type": "application/json" } : void 0,
-        body: body ? JSON.stringify(body) : void 0
-      });
-      return response.json();
-    },
-    open_modal: (modalId) => {
-      runtime.emit("open_modal", { id: modalId });
-    },
-    close_modal: (modalId) => {
-      runtime.emit("close_modal", { id: modalId });
-    },
-    setTimeout: (callback, delay) => {
-      return window.setTimeout(callback, delay);
-    },
-    clearTimeout: (id) => {
-      window.clearTimeout(id);
+      const delay = parseDuration(config.respawn_delay || "5s");
+      setTimeout(() => {
+        context.emit("respawn", { node });
+      }, delay);
     }
-  };
+    node.properties.__destroyed = true;
+  }
+};
+var proactiveHandler = {
+  name: "proactive",
+  defaultConfig: {
+    intelligence_tier: "basic",
+    observation_range: 5,
+    learning_rate: 0.1,
+    auto_suggest: true,
+    context_window: 10
+  },
+  onAttach(node, config, context) {
+    console.log(`[Proactive] Neural bridge attached to ${node.id || node.type}`);
+    context.emit("proactive_init", { nodeId: node.id, tier: config.intelligence_tier });
+  },
+  onUpdate(node, config, context, delta) {
+    if (!config || !config.auto_suggest) return;
+    const vr = context.vr;
+    const pos = node.properties.position;
+    if (!pos || !vr.headset.position) return;
+    const dx = pos[0] - vr.headset.position[0];
+    const dy = pos[1] - vr.headset.position[1];
+    const dz = pos[2] - vr.headset.position[2];
+    const distanceToHead = Math.sqrt(dx * dx + dy * dy + dz * dz);
+    if (distanceToHead < (config.observation_range || 5)) {
+      if (Math.random() < 0.01 * (config.learning_rate || 0.1) * delta) {
+        context.emit("proactive_suggestion", {
+          nodeId: node.id,
+          type: "interaction_hint",
+          suggestion: "Object is observing your proximity. Suggesting engagement."
+        });
+      }
+    }
+  }
+};
+function parseDuration(duration) {
+  const match = duration.match(/^(\d+(?:\.\d+)?)(ms|s|m)$/);
+  if (!match) return 0;
+  const value = parseFloat(match[1]);
+  const unit = match[2];
+  switch (unit) {
+    case "ms":
+      return value;
+    case "s":
+      return value * 1e3;
+    case "m":
+      return value * 60 * 1e3;
+    default:
+      return value;
+  }
 }
+var VRTraitRegistry = class {
+  constructor() {
+    this.handlers = /* @__PURE__ */ new Map();
+    this.register(grabbableHandler);
+    this.register(throwableHandler);
+    this.register(pointableHandler);
+    this.register(hoverableHandler);
+    this.register(scalableHandler);
+    this.register(rotatableHandler);
+    this.register(stackableHandler);
+    this.register(snappableHandler);
+    this.register(breakableHandler);
+    this.register(proactiveHandler);
+  }
+  register(handler) {
+    this.handlers.set(handler.name, handler);
+  }
+  getHandler(name) {
+    return this.handlers.get(name);
+  }
+  attachTrait(node, traitName, config, context) {
+    const handler = this.handlers.get(traitName);
+    if (!handler) return;
+    const mergedConfig = { ...handler.defaultConfig, ...config };
+    node.traits.set(traitName, mergedConfig);
+    if (handler.onAttach) {
+      handler.onAttach(node, mergedConfig, context);
+    }
+  }
+  detachTrait(node, traitName, context) {
+    const handler = this.handlers.get(traitName);
+    if (!handler) return;
+    const config = node.traits.get(traitName);
+    if (config && handler.onDetach) {
+      handler.onDetach(node, config, context);
+    }
+    node.traits.delete(traitName);
+  }
+  updateTrait(node, traitName, context, delta) {
+    const handler = this.handlers.get(traitName);
+    if (!handler || !handler.onUpdate) return;
+    const config = node.traits.get(traitName);
+    if (config) {
+      handler.onUpdate(node, config, context, delta);
+    }
+  }
+  handleEvent(node, traitName, context, event) {
+    const handler = this.handlers.get(traitName);
+    if (!handler || !handler.onEvent) return;
+    const config = node.traits.get(traitName);
+    if (config) {
+      handler.onEvent(node, config, context, event);
+    }
+  }
+  updateAllTraits(node, context, delta) {
+    for (const traitName of node.traits.keys()) {
+      this.updateTrait(node, traitName, context, delta);
+    }
+  }
+  handleEventForAllTraits(node, context, event) {
+    for (const traitName of node.traits.keys()) {
+      this.handleEvent(node, traitName, context, event);
+    }
+  }
+};
+var vrTraitRegistry = new VRTraitRegistry();
+
+// src/runtime/HoloScriptPlusRuntime.ts
+var StateSync = class {
+  constructor(_options) {
+  }
+  getInterpolatedState(_id) {
+    return null;
+  }
+};
 var HoloScriptPlusRuntimeImpl = class {
   constructor(ast, options = {}) {
     this.rootInstance = null;
@@ -3661,6 +4165,7 @@ var HoloScriptPlusRuntimeImpl = class {
     this.updateLoopId = null;
     this.lastUpdateTime = 0;
     this.mounted = false;
+    this.scaleMultiplier = 1;
     // VR context
     this.vrContext = {
       hands: {
@@ -3676,12 +4181,15 @@ var HoloScriptPlusRuntimeImpl = class {
         right: null
       }
     };
+    this.generatedNodes = /* @__PURE__ */ new Set();
+    this.apiPollingTimers = /* @__PURE__ */ new Map();
     this.ast = ast;
     this.options = options;
     this.state = createState({});
     this.traitRegistry = vrTraitRegistry;
     this.companions = options.companions || {};
     this.builtins = createBuiltins(this);
+    this.networkSync = new StateSync({ interpolation: true });
     this.evaluator = new ExpressionEvaluator(
       this.state.getSnapshot(),
       this.builtins
@@ -3950,6 +4458,20 @@ var HoloScriptPlusRuntimeImpl = class {
     if (instance.destroyed) return;
     const traitContext = this.createTraitContext(instance);
     this.traitRegistry.updateAllTraits(instance.node, traitContext, delta);
+    if (instance.node.type === "avatar") {
+      this.syncAvatarParts(instance);
+    }
+    if (instance.node.traits.has("networked")) {
+      const interpolated = this.networkSync.getInterpolatedState(instance.node.id || "");
+      if (interpolated) {
+        if (interpolated.position) {
+          instance.node.properties.position = [interpolated.position.x, interpolated.position.y, interpolated.position.z];
+        }
+        if (interpolated.rotation) {
+          instance.node.properties.rotation = [interpolated.rotation.x, interpolated.rotation.y, interpolated.rotation.z];
+        }
+      }
+    }
     if (this.options.renderer && instance.renderedNode) {
       const properties = this.evaluateProperties(instance.node.properties);
       this.options.renderer.updateElement(instance.renderedNode, properties);
@@ -3957,6 +4479,91 @@ var HoloScriptPlusRuntimeImpl = class {
     for (const child of instance.children) {
       this.updateInstance(child, delta);
     }
+    this.updateExternalApis(instance, delta);
+    this.processGenerateDirectives(instance);
+  }
+  syncAvatarParts(instance) {
+    const vrHands = this.vrContext.hands;
+    const vrHead = this.vrContext.headset;
+    if (instance.node.id === "local_player") {
+      instance.node.properties.position = vrHead.position;
+      instance.node.properties.rotation = vrHead.rotation;
+      instance.children.forEach((child) => {
+        if (child.node.id === "left_hand" && vrHands.left) {
+          child.node.properties.position = vrHands.left.position;
+          child.node.properties.rotation = vrHands.left.rotation;
+        } else if (child.node.id === "right_hand" && vrHands.right) {
+          child.node.properties.position = vrHands.right.position;
+          child.node.properties.rotation = vrHands.right.rotation;
+        }
+      });
+      if (instance.node.traits.has("networked")) {
+        this.emit("network_snapshot", {
+          objectId: instance.node.id,
+          position: { x: vrHead.position[0], y: vrHead.position[1], z: vrHead.position[2] },
+          rotation: { x: vrHead.rotation[0], y: vrHead.rotation[1], z: vrHead.rotation[2] },
+          timestamp: Date.now()
+        });
+      }
+    }
+  }
+  processGenerateDirectives(instance) {
+    const generateDirectives = instance.node.directives.filter((d) => d.type === "generate");
+    for (const d of generateDirectives) {
+      const directive = d;
+      const genId = `${instance.node.id || "node"}_${directive.prompt.substring(0, 10)}`;
+      if (this.generatedNodes.has(genId)) continue;
+      console.log(`[Generate] AI Bridge Request: "${directive.prompt}"`);
+      this.emit("generate_request", {
+        id: genId,
+        nodeId: instance.node.id,
+        prompt: directive.prompt,
+        context: directive.context,
+        target: directive.target || "children"
+      });
+      this.generatedNodes.add(genId);
+    }
+  }
+  updateExternalApis(instance, _delta) {
+    const apiDirectives = instance.node.directives.filter((d) => d.type === "external_api");
+    for (const d of apiDirectives) {
+      const directive = d;
+      if (directive.type !== "external_api") continue;
+      const intervalStr = directive.interval || "0s";
+      const intervalMs = this.parseDurationToMs(intervalStr);
+      if (intervalMs <= 0) continue;
+      let lastTime = this.apiPollingTimers.get(instance) || 0;
+      const now = performance.now();
+      if (now - lastTime >= intervalMs) {
+        this.apiPollingTimers.set(instance, now);
+        this.executeExternalApi(instance, directive);
+      }
+    }
+  }
+  async executeExternalApi(instance, directive) {
+    try {
+      const data = await this.builtins.api_call(directive.url, directive.method || "GET");
+      this.state.set("api_data", data);
+      this.updateData(data);
+    } catch (error) {
+      console.error(`External API error for ${directive.url}:`, error);
+    }
+  }
+  parseDurationToMs(duration) {
+    const match = duration.match(/^(\d+)(ms|s|m)$/);
+    if (!match) return 0;
+    const value = parseInt(match[1], 10);
+    const unit = match[2];
+    switch (unit) {
+      case "ms":
+        return value;
+      case "s":
+        return value * 1e3;
+      case "m":
+        return value * 6e4;
+      default:
+        return 0;
+    }
   }
   // ==========================================================================
   // TRAIT CONTEXT
@@ -4006,7 +4613,22 @@ var HoloScriptPlusRuntimeImpl = class {
       },
       emit: this.emit.bind(this),
       getState: () => this.state.getSnapshot(),
-      setState: (updates) => this.state.update(updates)
+      setState: (updates) => this.state.update(updates),
+      getScaleMultiplier: () => this.scaleMultiplier,
+      setScaleContext: (magnitude) => {
+        const multipliers = {
+          "galactic": 1e6,
+          "macro": 1e3,
+          "standard": 1,
+          "micro": 1e-3,
+          "atomic": 1e-6
+        };
+        const newMultiplier = multipliers[magnitude] || 1;
+        if (this.scaleMultiplier !== newMultiplier) {
+          this.scaleMultiplier = newMultiplier;
+          this.emit("scale_change", { magnitude, multiplier: newMultiplier });
+        }
+      }
     };
   }
   // ==========================================================================
@@ -4038,6 +4660,54 @@ var HoloScriptPlusRuntimeImpl = class {
   getState() {
     return this.state.getSnapshot();
   }
+  // ==========================================================================
+  // COMPATIBILITY METHODS
+  // ==========================================================================
+  getVariable(name) {
+    return this.state.get(name);
+  }
+  setVariable(name, value) {
+    this.state.set(name, value);
+  }
+  getContext() {
+    const spatialMemory = /* @__PURE__ */ new Map();
+    const hologramState = /* @__PURE__ */ new Map();
+    const traverse = (instance) => {
+      if (instance.node.id) {
+        spatialMemory.set(instance.node.id, instance.node.properties.position || { x: 0, y: 0, z: 0 });
+        hologramState.set(instance.node.id, {
+          shape: instance.node.properties.shape || instance.node.type,
+          color: instance.node.properties.color,
+          size: instance.node.properties.size,
+          glow: instance.node.properties.glow,
+          interactive: instance.node.properties.interactive
+        });
+      }
+      instance.children.forEach(traverse);
+    };
+    if (this.rootInstance) traverse(this.rootInstance);
+    return {
+      spatialMemory,
+      hologramState,
+      state: this.state,
+      builtins: this.builtins,
+      vr: this.vrContext
+    };
+  }
+  reset() {
+    this.unmount();
+    this.state = createState({});
+    this.mounted = false;
+  }
+  updateAnimations() {
+    this.update(1 / 60);
+  }
+  updateParticles(delta) {
+    this.update(delta);
+  }
+  getHologramStates() {
+    return this.getContext().hologramState;
+  }
   setState(updates) {
     this.state.update(updates);
   }
@@ -4053,6 +4723,22 @@ var HoloScriptPlusRuntimeImpl = class {
       });
     }
   }
+  updateEntity(id, properties) {
+    if (!this.rootInstance) return false;
+    let found = false;
+    const traverse = (instance) => {
+      if (instance.node.id === id) {
+        instance.node.properties = { ...instance.node.properties, ...properties };
+        if (this.options.renderer && instance.renderedNode) {
+          this.options.renderer.updateElement(instance.renderedNode, properties);
+        }
+        found = true;
+      }
+      instance.children.forEach(traverse);
+    };
+    traverse(this.rootInstance);
+    return found;
+  }
   on(event, handler) {
     if (!this.eventHandlers.has(event)) {
       this.eventHandlers.set(event, /* @__PURE__ */ new Set());
@@ -4138,6 +4824,114 @@ var HoloScriptPlusRuntimeImpl = class {
     this.destroyInstance(instance);
   }
 };
+function createBuiltins(runtime) {
+  return {
+    Math,
+    range: (start, end, step = 1) => {
+      const result = [];
+      if (step > 0) {
+        for (let i = start; i < end; i += step) {
+          result.push(i);
+        }
+      } else if (step < 0) {
+        for (let i = start; i > end; i += step) {
+          result.push(i);
+        }
+      }
+      return result;
+    },
+    interpolate_color: (t, from, to) => {
+      const parseHex = (hex) => {
+        const clean = hex.replace("#", "");
+        return [
+          parseInt(clean.substring(0, 2), 16),
+          parseInt(clean.substring(2, 4), 16),
+          parseInt(clean.substring(4, 6), 16)
+        ];
+      };
+      const toHex = (r, g, b) => {
+        const clamp = (v) => Math.max(0, Math.min(255, Math.round(v)));
+        return `#${clamp(r).toString(16).padStart(2, "0")}${clamp(g).toString(16).padStart(2, "0")}${clamp(b).toString(16).padStart(2, "0")}`;
+      };
+      const [r1, g1, b1] = parseHex(from);
+      const [r2, g2, b2] = parseHex(to);
+      return toHex(
+        r1 + (r2 - r1) * t,
+        g1 + (g2 - g1) * t,
+        b1 + (b2 - b1) * t
+      );
+    },
+    distance_to: (point) => {
+      const viewer = runtime.vrContext.headset.position;
+      return Math.sqrt(
+        Math.pow(point[0] - viewer[0], 2) + Math.pow(point[1] - viewer[1], 2) + Math.pow(point[2] - viewer[2], 2)
+      );
+    },
+    distance_to_viewer: () => {
+      return 0;
+    },
+    hand_position: (handId) => {
+      const hand = handId === "left" ? runtime.vrContext.hands.left : runtime.vrContext.hands.right;
+      return hand?.position || [0, 0, 0];
+    },
+    hand_velocity: (handId) => {
+      const hand = handId === "left" ? runtime.vrContext.hands.left : runtime.vrContext.hands.right;
+      return hand?.velocity || [0, 0, 0];
+    },
+    dominant_hand: () => {
+      return runtime.vrContext.hands.right || runtime.vrContext.hands.left || {
+        id: "right",
+        position: [0, 0, 0],
+        rotation: [0, 0, 0],
+        velocity: [0, 0, 0],
+        grip: 0,
+        trigger: 0
+      };
+    },
+    play_sound: (source, options) => {
+      runtime.emit("play_sound", { source, ...options });
+    },
+    haptic_feedback: (hand, intensity) => {
+      const handId = typeof hand === "string" ? hand : hand.id;
+      runtime.emit("haptic", { hand: handId, intensity });
+    },
+    haptic_pulse: (intensity) => {
+      runtime.emit("haptic", { hand: "both", intensity });
+    },
+    apply_velocity: (node, velocity) => {
+      runtime.emit("apply_velocity", { node, velocity });
+    },
+    spawn: (template, position) => {
+      return runtime.spawnTemplate(template, position);
+    },
+    assistant_generate: (prompt, context) => {
+      runtime.emit("assistant_generate", { prompt, context });
+    },
+    destroy: (node) => {
+      runtime.destroyNode(node);
+    },
+    api_call: async (url, method, body) => {
+      const response = await fetch(url, {
+        method,
+        headers: body ? { "Content-Type": "application/json" } : void 0,
+        body: body ? JSON.stringify(body) : void 0
+      });
+      return response.json();
+    },
+    open_modal: (modalId) => {
+      runtime.emit("open_modal", { id: modalId });
+    },
+    close_modal: (modalId) => {
+      runtime.emit("close_modal", { id: modalId });
+    },
+    setTimeout: (callback, delay) => {
+      return window.setTimeout(callback, delay);
+    },
+    clearTimeout: (id) => {
+      window.clearTimeout(id);
+    }
+  };
+}
 
 // src/traits/VoiceInputTrait.ts
 var VoiceInputTrait = class {
@@ -4680,11 +5474,6 @@ function createAIDriverTrait(config) {
   return new AIDriverTrait(config);
 }
 
-// src/index.ts
-init_MaterialTrait();
-init_LightingTrait();
-init_RenderingTrait();
-
 // src/runtime/PerformanceTelemetry.ts
 var PerformanceTelemetry = class {
   // Export every 10s
@@ -5909,7 +6698,7 @@ button refreshBtn {
 function createHoloScriptEnvironment() {
   return {
     parser: new HoloScriptParser(),
-    runtime: new chunk3N67RLQP_cjs.HoloScriptRuntime(),
+    runtime: new chunkL6VLNVKP_cjs.HoloScriptRuntime(),
     version: HOLOSCRIPT_VERSION
   };
 }
@@ -5922,27 +6711,27 @@ function isHoloScriptSupported() {
 
 Object.defineProperty(exports, "HoloScriptTypeChecker", {
   enumerable: true,
-  get: function () { return chunkVMZN4EVR_cjs.HoloScriptTypeChecker; }
+  get: function () { return chunkMFNO57XL_cjs.HoloScriptTypeChecker; }
 });
 Object.defineProperty(exports, "createTypeChecker", {
   enumerable: true,
-  get: function () { return chunkVMZN4EVR_cjs.createTypeChecker; }
+  get: function () { return chunkMFNO57XL_cjs.createTypeChecker; }
 });
 Object.defineProperty(exports, "HoloScriptDebugger", {
   enumerable: true,
-  get: function () { return chunkWFI4T3XB_cjs.HoloScriptDebugger; }
+  get: function () { return chunkR75MREOS_cjs.HoloScriptDebugger; }
 });
 Object.defineProperty(exports, "createDebugger", {
   enumerable: true,
-  get: function () { return chunkWFI4T3XB_cjs.createDebugger; }
+  get: function () { return chunkR75MREOS_cjs.createDebugger; }
 });
 Object.defineProperty(exports, "HoloScriptCodeParser", {
   enumerable: true,
-  get: function () { return chunk4OHVW4XR_cjs.HoloScriptCodeParser; }
+  get: function () { return chunkT57ZL7KR_cjs.HoloScriptCodeParser; }
 });
 Object.defineProperty(exports, "HoloScriptRuntime", {
   enumerable: true,
-  get: function () { return chunk3N67RLQP_cjs.HoloScriptRuntime; }
+  get: function () { return chunkL6VLNVKP_cjs.HoloScriptRuntime; }
 });
 Object.defineProperty(exports, "ConsoleLogger", {
   enumerable: true,
@@ -5981,11 +6770,19 @@ exports.HoloScriptParser = HoloScriptParser;
 exports.HoloScriptPlusParser = HoloScriptPlusParser;
 exports.HoloScriptPlusRuntimeImpl = HoloScriptPlusRuntimeImpl;
 exports.HoloScriptTraitAnnotationParser = HoloScriptPlusParser2;
+exports.HoloScriptValidator = HoloScriptValidator;
 exports.HololandGraphicsPipelineService = HololandGraphicsPipelineService;
+exports.LIFECYCLE_HOOKS = LIFECYCLE_HOOKS;
+exports.LIGHTING_PRESETS = LIGHTING_PRESETS;
+exports.LightingTrait = LightingTrait;
+exports.MATERIAL_PRESETS = MATERIAL_PRESETS;
+exports.MaterialTrait = MaterialTrait;
 exports.PerformanceTelemetry = PerformanceTelemetry;
 exports.PlatformPerformanceOptimizer = PlatformPerformanceOptimizer;
 exports.ReactiveState = ReactiveState;
+exports.RenderingTrait = RenderingTrait;
 exports.VRTraitRegistry = VRTraitRegistry;
+exports.VR_TRAITS = VR_TRAITS;
 exports.VoiceInputTrait = VoiceInputTrait;
 exports.bind = bind;
 exports.computed = computed;