@holoscript/core 8.0.7 → 8.0.9

package/dist/chunk-VEPGBETF.js

@@ -1,844 +0,0 @@
-import { init_ProvenanceSemiring, ProvenanceSemiring } from './chunk-SLHLXUMO.js';
-import { init_TraitCompositor, TraitCompositor } from './chunk-4C57PR42.js';
-import { init_PlatformConditionalCompilerMixin, createPlatformTarget, PlatformConditionalCompilerMixin } from './chunk-GW3LKD5C.js';
-import { init_DomainBlockCompilerMixin, compileDomainBlocks, compileWeatherBlock, compileAudioSourceBlock, audioSourceToBabylon, compilePostProcessingBlock, postProcessingToBabylon, compileParticleBlock, particlesToBabylon, compilePhysicsBlock, physicsToBabylon, compileMaterialBlock, materialToBabylon } from './chunk-ZA34AN3R.js';
-import { init_CompilerBase, CompilerBase } from './chunk-C7ZBSV2Q.js';
-import { __export, __esm } from './chunk-OL46QLBJ.js';
-import { ANSCapabilityPath } from '@holoscript/core-types/ans';
-
-// src/compiler/BabylonCompiler.ts
-var BabylonCompiler_exports = {};
-__export(BabylonCompiler_exports, {
-  BabylonCompiler: () => BabylonCompiler
-});
-var SHAPE_TO_MESH, BabylonCompiler;
-var init_BabylonCompiler = __esm({
-  "src/compiler/BabylonCompiler.ts"() {
-    init_TraitCompositor();
-    init_ProvenanceSemiring();
-    init_CompilerBase();
-    init_DomainBlockCompilerMixin();
-    init_PlatformConditionalCompilerMixin();
-    SHAPE_TO_MESH = {
-      sphere: "CreateSphere",
-      orb: "CreateSphere",
-      cube: "CreateBox",
-      box: "CreateBox",
-      cylinder: "CreateCylinder",
-      cone: "CreateCylinder",
-      pyramid: "CreateCylinder",
-      plane: "CreateGround",
-      ground: "CreateGround",
-      torus: "CreateTorus",
-      ring: "CreateTorus",
-      capsule: "CreateCapsule",
-      disc: "CreateDisc"
-    };
-    BabylonCompiler = class extends CompilerBase {
-      constructor(options = {}) {
-        super();
-        this.compilerName = "BabylonCompiler";
-        this.lines = [];
-        this.indentLevel = 0;
-        this.options = {
-          className: options.className || "GeneratedScene",
-          useHavok: options.useHavok ?? true,
-          enableXR: options.enableXR ?? false,
-          indent: options.indent || "  ",
-          provenanceHash: options.provenanceHash ?? "",
-          platformTarget: options.platformTarget ?? ""
-        };
-      }
-      getRequiredCapability() {
-        return ANSCapabilityPath.BABYLON;
-      }
-      compile(composition, agentToken, outputPath) {
-        this.validateCompilerAccess(agentToken, outputPath);
-        if (this.options.platformTarget) {
-          const target = typeof this.options.platformTarget === "string" ? createPlatformTarget(this.options.platformTarget) : this.options.platformTarget;
-          const platformMixin = new PlatformConditionalCompilerMixin();
-          composition = platformMixin.filterForPlatform(composition, target);
-        }
-        this.lines = [];
-        this.indentLevel = 0;
-        this.emit("// Auto-generated by HoloScript BabylonCompiler");
-        this.emit(
-          `// Source: composition "${this.escapeStringValue(composition.name, "TypeScript")}"`
-        );
-        if (this.options.provenanceHash) {
-          this.emit(`// Provenance Hash: ${this.options.provenanceHash}`);
-        }
-        this.emit("");
-        this.emitImports(composition);
-        this.emit("");
-        this.emit(`export class ${this.options.className} {`);
-        this.indent();
-        this.emit("private engine: BABYLON.Engine;");
-        this.emit("private scene: BABYLON.Scene;");
-        this.emit("private canvas: HTMLCanvasElement;");
-        this.emit("");
-        this.emit("constructor(canvas: HTMLCanvasElement) {");
-        this.indent();
-        this.emit("this.canvas = canvas;");
-        this.emit(
-          "this.engine = new BABYLON.Engine(canvas, true, { preserveDrawingBuffer: true, stencil: true });"
-        );
-        this.emit("this.scene = new BABYLON.Scene(this.engine);");
-        this.dedent();
-        this.emit("}");
-        this.emit("");
-        this.emit("async build(): Promise<void> {");
-        this.indent();
-        this.emitSceneSetup(composition);
-        if (composition.environment) this.emitEnvironment(composition.environment);
-        if (composition.lights?.length) {
-          for (const light of composition.lights) this.emitLight(light);
-        } else {
-          this.emit(
-            'const defaultLight = new BABYLON.HemisphericLight("defaultLight", new BABYLON.Vector3(0, 1, 0), this.scene);'
-          );
-          this.emit("defaultLight.intensity = 0.7;");
-          this.emit("");
-        }
-        if (composition.camera) this.emitCamera(composition.camera);
-        else {
-          this.emit(
-            'const camera = new BABYLON.ArcRotateCamera("defaultCamera", -Math.PI / 2, Math.PI / 3, 10, BABYLON.Vector3.Zero(), this.scene);'
-          );
-          this.emit("camera.attachControl(this.canvas, true);");
-          this.emit("");
-        }
-        if (composition.objects?.length) for (const obj of composition.objects) this.emitObject(obj);
-        if (composition.spatialGroups?.length)
-          for (const g of composition.spatialGroups) this.emitGroup(g);
-        if (composition.timelines?.length)
-          for (const tl of composition.timelines) this.emitTimeline(tl);
-        if (composition.audio?.length) for (const a of composition.audio) this.emitAudio(a);
-        if (composition.zones?.length) for (const z of composition.zones) this.emitZone(z);
-        if (composition.ui) this.emitUI(composition.ui);
-        if (composition.effects) this.emitEffects(composition.effects);
-        if (composition.transitions?.length)
-          for (const t of composition.transitions) this.emitTransition(t);
-        if (this.options.enableXR) this.emitXRSetup();
-        this.compileBabylonDomainBlocks(composition);
-        this.emitRenderLoop();
-        this.dedent();
-        this.emit("}");
-        this.emit("");
-        this.emit("dispose(): void { this.scene.dispose(); this.engine.dispose(); }");
-        this.dedent();
-        this.emit("}");
-        return this.lines.join("\n");
-      }
-      compileBabylonDomainBlocks(composition) {
-        const domainBlocks = composition.domainBlocks ?? [];
-        if (domainBlocks.length === 0) return;
-        this.emit("");
-        this.emit("// === v4.2 Domain Blocks ===");
-        let blockIdx = 0;
-        const compiled = compileDomainBlocks(
-          domainBlocks,
-          {
-            material: (block) => {
-              const mat = compileMaterialBlock(block);
-              return materialToBabylon(mat, `db${blockIdx++}`);
-            },
-            physics: (block) => {
-              const phys = compilePhysicsBlock(block);
-              return physicsToBabylon(phys, `db${blockIdx++}`);
-            },
-            vfx: (block) => {
-              const ps = compileParticleBlock(block);
-              return particlesToBabylon(ps, `db${blockIdx++}`);
-            },
-            postfx: (block) => {
-              const pp = compilePostProcessingBlock(block);
-              return postProcessingToBabylon(pp);
-            },
-            audio: (block) => {
-              const audio = compileAudioSourceBlock(block);
-              return audioSourceToBabylon(audio, `db${blockIdx++}`);
-            },
-            weather: (block) => {
-              const weather = compileWeatherBlock(block);
-              const layers = weather.layers.map((l) => `// Layer: ${l.type} \u2014 ${JSON.stringify(l.properties)}`).join("\n");
-              return `// Weather: ${weather.keyword} "${weather.name || ""}" \u2014 implement via Babylon.js particle systems
-${layers}`;
-            }
-          },
-          (block) => `// Domain block: ${block.domain}/${block.keyword} "${this.escapeStringValue(block.name, "TypeScript")}"`
-        );
-        for (const line of compiled) {
-          for (const l of line.split("\n")) {
-            this.emit(l);
-          }
-        }
-      }
-      // --- Imports ---
-      emitImports(composition) {
-        this.emit('import * as BABYLON from "@babylonjs/core";');
-        if (composition.ui) this.emit('import * as GUI from "@babylonjs/gui";');
-        if (this.options.useHavok) this.emit('import HavokPhysics from "@babylonjs/havok";');
-        if (this.options.enableXR) this.emit('import "@babylonjs/loaders";');
-      }
-      // --- Scene Setup ---
-      emitSceneSetup(_composition) {
-        this.emit("this.scene.clearColor = new BABYLON.Color4(0.05, 0.05, 0.1, 1);");
-        if (this.options.useHavok) {
-          this.emit("const havokInstance = await HavokPhysics();");
-          this.emit("const havokPlugin = new BABYLON.HavokPlugin(true, havokInstance);");
-          this.emit("this.scene.enablePhysics(new BABYLON.Vector3(0, -9.81, 0), havokPlugin);");
-        }
-        this.emit("");
-      }
-      // --- Environment ---
-      emitEnvironment(env) {
-        for (const prop of env.properties) {
-          if (prop.key === "skybox" || prop.key === "preset") {
-            this.emit(
-              `const skybox = BABYLON.MeshBuilder.CreateBox("skyBox", { size: 1000 }, this.scene);`
-            );
-            this.emit(`const skyMat = new BABYLON.StandardMaterial("skyMat", this.scene);`);
-            this.emit(`skyMat.backFaceCulling = false;`);
-            this.emit(
-              `skyMat.reflectionTexture = new BABYLON.CubeTexture("textures/${prop.value}", this.scene);`
-            );
-            this.emit(`skyMat.reflectionTexture.coordinatesMode = BABYLON.Texture.SKYBOX_MODE;`);
-            this.emit(`skyMat.disableLighting = true;`);
-            this.emit(`skybox.material = skyMat; skybox.infiniteDistance = true;`);
-          } else if (prop.key === "fog" && typeof prop.value === "object") {
-            const fog = prop.value;
-            this.emit(`this.scene.fogMode = BABYLON.Scene.FOGMODE_LINEAR;`);
-            if (fog.color) this.emit(`this.scene.fogColor = ${this.toBabylonColor3(fog.color)};`);
-            if (fog.near !== void 0) this.emit(`this.scene.fogStart = ${fog.near};`);
-            if (fog.far !== void 0) this.emit(`this.scene.fogEnd = ${fog.far};`);
-          } else if (prop.key === "ambient_light") {
-            this.emit(
-              `this.scene.ambientColor = new BABYLON.Color3(${prop.value}, ${prop.value}, ${prop.value});`
-            );
-          } else if (prop.key === "ground") {
-            this.emit(
-              `const ground = BABYLON.MeshBuilder.CreateGround("ground", { width: 100, height: 100 }, this.scene);`
-            );
-            if (typeof prop.value === "object" && prop.value !== null) {
-              const g = prop.value;
-              if (g.color) {
-                this.emit(`const groundMat = new BABYLON.PBRMaterial("groundMat", this.scene);`);
-                this.emit(
-                  `groundMat.albedoColor = ${this.toBabylonColor3(g.color)}; groundMat.roughness = 0.8;`
-                );
-                this.emit(`ground.material = groundMat;`);
-              }
-            }
-            this.emit(`ground.receiveShadows = true;`);
-          }
-        }
-        this.emit("");
-      }
-      // --- Objects ---
-      emitObject(obj, parentVar) {
-        const v = this.sanitizeName(obj.name);
-        let geom = "cube", modelSrc, textContent;
-        let position, rotation, scale, size;
-        const mat = {};
-        for (const p of obj.properties) {
-          switch (p.key) {
-            case "geometry":
-            case "mesh":
-            case "type":
-              if (typeof p.value === "string") geom = p.value;
-              break;
-            case "position":
-              if (Array.isArray(p.value)) position = p.value;
-              break;
-            case "rotation":
-              if (Array.isArray(p.value)) rotation = p.value;
-              break;
-            case "scale":
-              scale = p.value;
-              break;
-            case "size":
-              size = p.value;
-              break;
-            case "color":
-              mat.color = p.value;
-              break;
-            case "roughness":
-              mat.roughness = p.value;
-              break;
-            case "metalness":
-            case "metallic":
-              mat.metalness = p.value;
-              break;
-            case "opacity":
-              mat.opacity = p.value;
-              break;
-            case "emissive":
-              mat.emissive = p.value;
-              break;
-            case "emissive_intensity":
-            case "emissiveIntensity":
-              mat.emissiveIntensity = p.value;
-              break;
-            case "material":
-              if (typeof p.value === "object" && p.value !== null)
-                Object.assign(mat, p.value);
-              break;
-            case "model":
-            case "src":
-            case "source":
-              if (typeof p.value === "string") modelSrc = p.value;
-              break;
-            case "text":
-              if (typeof p.value === "string") textContent = p.value;
-              break;
-          }
-        }
-        this.emit(`// Object: ${this.escapeStringValue(obj.name, "TypeScript")}`);
-        if (modelSrc) {
-          this.emit(
-            `const ${v} = await BABYLON.SceneLoader.ImportMeshAsync("", "${modelSrc}", "", this.scene);`
-          );
-        } else if (geom === "text" || textContent) {
-          this.emit(
-            `const ${v} = BABYLON.MeshBuilder.CreatePlane("${this.escapeStringValue(obj.name, "TypeScript")}", { width: 2, height: 1 }, this.scene);`
-          );
-          this.emit(
-            `const ${v}Tex = new BABYLON.DynamicTexture("${v}Tex", { width: 512, height: 256 }, this.scene);`
-          );
-          this.emit(
-            `${v}Tex.drawText("${textContent || ""}", null, null, "bold 48px Arial", "#ffffff", "#00000000", true);`
-          );
-          this.emit(`const ${v}Mat = new BABYLON.StandardMaterial("${v}Mat", this.scene);`);
-          this.emit(
-            `${v}Mat.diffuseTexture = ${v}Tex; ${v}Mat.emissiveColor = BABYLON.Color3.White();`
-          );
-          this.emit(`${v}.material = ${v}Mat;`);
-        } else {
-          this.emit(
-            `const ${v} = BABYLON.MeshBuilder.${this.mapShapeToMesh(geom)}("${this.escapeStringValue(obj.name, "TypeScript")}", ${this.meshBuilderOptions(geom, size)}, this.scene);`
-          );
-          if (Object.keys(mat).length > 0) {
-            this.emit(`const ${v}Mat = new BABYLON.PBRMaterial("${v}Mat", this.scene);`);
-            if (mat.color) this.emit(`${v}Mat.albedoColor = ${this.toBabylonColor3(mat.color)};`);
-            if (mat.roughness !== void 0) this.emit(`${v}Mat.roughness = ${mat.roughness};`);
-            if (mat.metalness !== void 0) this.emit(`${v}Mat.metallic = ${mat.metalness};`);
-            if (mat.opacity !== void 0 && mat.opacity < 1)
-              this.emit(`${v}Mat.alpha = ${mat.opacity};`);
-            if (mat.emissive)
-              this.emit(`${v}Mat.emissiveColor = ${this.toBabylonColor3(mat.emissive)};`);
-            if (mat.emissiveIntensity !== void 0)
-              this.emit(`${v}Mat.emissiveIntensity = ${mat.emissiveIntensity};`);
-            this.emit(`${v}.material = ${v}Mat;`);
-          }
-        }
-        if (position) this.emit(`${v}.position = ${this.toBabylonVector(position)};`);
-        if (rotation) this.emit(`${v}.rotation = ${this.toBabylonVector(rotation)};`);
-        if (scale) {
-          this.emit(
-            Array.isArray(scale) ? `${v}.scaling = ${this.toBabylonVector(scale)};` : `${v}.scaling = new BABYLON.Vector3(${scale}, ${scale}, ${scale});`
-          );
-        }
-        if (parentVar) this.emit(`${v}.parent = ${parentVar};`);
-        const physicsTraits = (obj.traits || []).filter(
-          (t) => t.name === "physics" || t.name === "collidable"
-        );
-        if (physicsTraits.length > 0) {
-          const semiring = new ProvenanceSemiring();
-          const applications = physicsTraits.map((t) => ({
-            name: t.name,
-            config: t.config || {},
-            context: obj.provenance?.context
-          }));
-          const { config: physicsConfig } = semiring.add(applications);
-          const mt = (physicsConfig.type || "dynamic") === "static" ? "STATIC" : "DYNAMIC";
-          this.emit(
-            `const ${v}Body = new BABYLON.PhysicsBody(${v}, BABYLON.PhysicsMotionType.${mt}, false, this.scene);`
-          );
-          this.emit(`${v}Body.shape = new BABYLON.PhysicsShapeConvexHull(${v}, this.scene);`);
-          this.emit(`${v}Body.setMassProperties({ mass: ${physicsConfig.mass ?? 1} });`);
-        }
-        for (const trait of obj.traits || []) {
-          if (trait.name === "physics" || trait.name === "collidable") {
-            continue;
-          } else if (trait.name === "grabbable") {
-            this.emit(`${v}.actionManager = new BABYLON.ActionManager(this.scene);`);
-            this.emit(
-              `${v}.actionManager.registerAction(new BABYLON.ExecuteCodeAction(BABYLON.ActionManager.OnPickTrigger, () => { console.log("Picked: ${this.escapeStringValue(obj.name, "TypeScript")}"); }));`
-            );
-          } else if (trait.name === "gaussian_splat") {
-            this.emit(`const ${v}PCS = new BABYLON.PointsCloudSystem("${v}PCS", 2, this.scene);`);
-            this.emit(`${v}PCS.addPoints(10000); await ${v}PCS.buildMeshAsync();`);
-          } else if (trait.name === "shadow") {
-            this.emit(`${v}.receiveShadows = true;`);
-          } else if (trait.name === "hoverable") {
-            this.emit(
-              `${v}.actionManager = ${v}.actionManager || new BABYLON.ActionManager(this.scene);`
-            );
-            this.emit(
-              `${v}.actionManager.registerAction(new BABYLON.ExecuteCodeAction(BABYLON.ActionManager.OnPointerOverTrigger, () => { ${v}.renderOverlay = true; ${v}.overlayColor = BABYLON.Color3.White(); }));`
-            );
-            this.emit(
-              `${v}.actionManager.registerAction(new BABYLON.ExecuteCodeAction(BABYLON.ActionManager.OnPointerOutTrigger, () => { ${v}.renderOverlay = false; }));`
-            );
-          } else if (trait.name === "accessible") {
-            this.emit(
-              `${v}.accessibilityTag = { description: "${this.escapeStringValue(obj.name, "TypeScript")}", role: "${trait.config?.role || "generic"}" };`
-            );
-          } else if (trait.name === "object_tracking") {
-            this.emit(
-              `// @object_tracking \u2014 WebXR hit-test or custom tracker for "${this.escapeStringValue(obj.name, "TypeScript")}"`
-            );
-          } else if (trait.name === "scene_reconstruction") {
-            this.emit(
-              `// @scene_reconstruction \u2014 WebXR mesh detection for "${this.escapeStringValue(obj.name, "TypeScript")}"`
-            );
-          } else if (trait.name === "eye_tracked") {
-            this.emit(`// @eye_tracked \u2014 WebXR eye tracking (requires 'eye-tracking' feature)`);
-          } else if (trait.name === "eye_hand_fusion") {
-            this.emit(`// @eye_hand_fusion \u2014 combine WebXR hand + eye tracking`);
-          } else if (trait.name === "controlnet") {
-            this.emit(
-              `// @controlnet(model: "${trait.config?.model || "canny"}") \u2014 route to inference API`
-            );
-          } else if (trait.name === "ai_texture_gen") {
-            this.emit(`// @ai_texture_gen \u2014 apply generated texture to ${v}.material`);
-          } else if (trait.name === "neural_animation") {
-            this.emit(`// @neural_animation \u2014 BabylonJS AnimationGroup + neural pose predictor`);
-          } else if (trait.name === "ai_npc_brain") {
-            this.emit(
-              `// @ai_npc_brain(model: "${trait.config?.model || "llm"}") \u2014 external LLM/NPC API`
-            );
-          } else {
-            this.emit(
-              `// @${this.escapeStringValue(trait.name, "TypeScript")}: ${JSON.stringify(trait.config || {})}`
-            );
-          }
-        }
-        if (obj.traits && Array.isArray(obj.traits) && obj.traits.length > 0) {
-          const traitNames = obj.traits.map((t) => t.name);
-          const compositor = new TraitCompositor();
-          const composed = compositor.compose(traitNames);
-          if (Object.keys(composed).length > 0) {
-            const matVar = `${v}ComposedMat`;
-            this.emit(`// TraitCompositor: composed ${traitNames.join(" + ")}`);
-            this.emit(
-              `const ${matVar} = ${v}.material as BABYLON.PBRMaterial || new BABYLON.PBRMaterial("${matVar}", this.scene);`
-            );
-            if (composed.color)
-              this.emit(`${matVar}.albedoColor = ${this.toBabylonColor3(composed.color)};`);
-            if (composed.roughness !== void 0)
-              this.emit(`${matVar}.roughness = ${composed.roughness};`);
-            if (composed.metalness !== void 0)
-              this.emit(`${matVar}.metallic = ${composed.metalness};`);
-            if (composed.opacity !== void 0 && composed.opacity < 1)
-              this.emit(`${matVar}.alpha = ${composed.opacity};`);
-            if (composed.emissive)
-              this.emit(`${matVar}.emissiveColor = ${this.toBabylonColor3(composed.emissive)};`);
-            if (composed.emissiveIntensity !== void 0)
-              this.emit(`${matVar}.emissiveIntensity = ${composed.emissiveIntensity};`);
-            this.emit(`${v}.material = ${matVar};`);
-          }
-        }
-        if (obj.children?.length) for (const child of obj.children) this.emitObject(child, v);
-        this.emit("");
-      }
-      // --- Groups ---
-      emitGroup(group, parentVar) {
-        const v = this.sanitizeName(group.name);
-        this.emit(
-          `const ${v} = new BABYLON.TransformNode("${this.escapeStringValue(group.name, "TypeScript")}", this.scene);`
-        );
-        for (const p of group.properties) {
-          if (p.key === "position" && Array.isArray(p.value))
-            this.emit(`${v}.position = ${this.toBabylonVector(p.value)};`);
-          else if (p.key === "rotation" && Array.isArray(p.value))
-            this.emit(`${v}.rotation = ${this.toBabylonVector(p.value)};`);
-          else if (p.key === "scale") {
-            this.emit(
-              Array.isArray(p.value) ? `${v}.scaling = ${this.toBabylonVector(p.value)};` : `${v}.scaling = new BABYLON.Vector3(${p.value}, ${p.value}, ${p.value});`
-            );
-          }
-        }
-        if (parentVar) this.emit(`${v}.parent = ${parentVar};`);
-        for (const obj of group.objects) this.emitObject(obj, v);
-        if (group.groups) for (const sub of group.groups) this.emitGroup(sub, v);
-        this.emit("");
-      }
-      // --- Lights ---
-      emitLight(light) {
-        const v = this.sanitizeName(light.name);
-        let pos, color, intensity;
-        let dir, castShadow = false, angle, dist;
-        for (const p of light.properties) {
-          if (p.key === "position" && Array.isArray(p.value)) pos = p.value;
-          else if (p.key === "color") color = p.value;
-          else if (p.key === "intensity") intensity = p.value;
-          else if (p.key === "direction" && Array.isArray(p.value)) dir = p.value;
-          else if (p.key === "cast_shadow" || p.key === "castShadow") castShadow = !!p.value;
-          else if (p.key === "angle") angle = p.value;
-          else if (p.key === "distance") dist = p.value;
-        }
-        const posV = pos ? this.toBabylonVector(pos) : "new BABYLON.Vector3(0, 1, 0)";
-        const dirV = dir ? this.toBabylonVector(dir) : "new BABYLON.Vector3(0, -1, 0)";
-        switch (light.lightType) {
-          case "hemisphere":
-          case "ambient":
-            this.emit(
-              `const ${v} = new BABYLON.HemisphericLight("${this.escapeStringValue(light.name, "TypeScript")}", ${posV}, this.scene);`
-            );
-            break;
-          case "directional":
-            this.emit(
-              `const ${v} = new BABYLON.DirectionalLight("${this.escapeStringValue(light.name, "TypeScript")}", ${dirV}, this.scene);`
-            );
-            if (pos) this.emit(`${v}.position = ${posV};`);
-            break;
-          case "point":
-            this.emit(
-              `const ${v} = new BABYLON.PointLight("${this.escapeStringValue(light.name, "TypeScript")}", ${posV}, this.scene);`
-            );
-            break;
-          case "spot":
-            this.emit(
-              `const ${v} = new BABYLON.SpotLight("${this.escapeStringValue(light.name, "TypeScript")}", ${posV}, ${dirV}, ${angle ?? Math.PI / 4}, 2, this.scene);`
-            );
-            break;
-          case "area":
-            this.emit(`// Area light fallback`);
-            this.emit(
-              `const ${v} = new BABYLON.PointLight("${this.escapeStringValue(light.name, "TypeScript")}", ${posV}, this.scene);`
-            );
-            break;
-          default:
-            this.emit(
-              `const ${v} = new BABYLON.HemisphericLight("${this.escapeStringValue(light.name, "TypeScript")}", ${posV}, this.scene);`
-            );
-            break;
-        }
-        if (color) this.emit(`${v}.diffuse = ${this.toBabylonColor3(color)};`);
-        if (intensity !== void 0) this.emit(`${v}.intensity = ${intensity};`);
-        if (dist !== void 0) this.emit(`${v}.range = ${dist};`);
-        if (castShadow && ["directional", "spot", "point"].includes(light.lightType)) {
-          this.emit(`const ${v}SG = new BABYLON.ShadowGenerator(2048, ${v});`);
-          this.emit(`${v}SG.useBlurExponentialShadowMap = true;`);
-        }
-        this.emit("");
-      }
-      // --- Camera ---
-      emitCamera(cam) {
-        let fov, pos, lookAt;
-        let near, far;
-        for (const p of cam.properties) {
-          if (p.key === "fov" || p.key === "field_of_view") fov = p.value;
-          else if (p.key === "position" && Array.isArray(p.value)) pos = p.value;
-          else if ((p.key === "look_at" || p.key === "lookAt") && Array.isArray(p.value))
-            lookAt = p.value;
-          else if (p.key === "near") near = p.value;
-          else if (p.key === "far") far = p.value;
-        }
-        const target = lookAt ? this.toBabylonVector(lookAt) : "BABYLON.Vector3.Zero()";
-        if (cam.cameraType === "orthographic") {
-          this.emit(
-            `const camera = new BABYLON.FreeCamera("camera", ${pos ? this.toBabylonVector(pos) : "new BABYLON.Vector3(0, 5, -10)"}, this.scene);`
-          );
-          this.emit(`camera.mode = BABYLON.Camera.ORTHOGRAPHIC_CAMERA;`);
-          this.emit(`camera.setTarget(${target});`);
-        } else {
-          this.emit(
-            `const camera = new BABYLON.ArcRotateCamera("camera", -Math.PI / 2, Math.PI / 3, 10, ${target}, this.scene);`
-          );
-          if (pos) this.emit(`camera.setPosition(${this.toBabylonVector(pos)});`);
-        }
-        if (fov !== void 0) this.emit(`camera.fov = ${fov * (Math.PI / 180)};`);
-        if (near !== void 0) this.emit(`camera.minZ = ${near};`);
-        if (far !== void 0) this.emit(`camera.maxZ = ${far};`);
-        this.emit("camera.attachControl(this.canvas, true);");
-        this.emit("");
-      }
-      // --- Timeline ---
-      emitTimeline(timeline) {
-        const v = this.sanitizeName(timeline.name);
-        this.emit(
-          `const ${v}Group = new BABYLON.AnimationGroup("${this.escapeStringValue(timeline.name, "TypeScript")}", this.scene);`
-        );
-        const fps = 30;
-        for (const entry of timeline.entries) {
-          const a = entry.action;
-          if (a.kind === "animate") {
-            const frame = Math.round(entry.time * fps);
-            for (const [key, value] of Object.entries(a.properties)) {
-              const n = `${v}_${this.sanitizeName(a.target)}_${key}`;
-              const animType = Array.isArray(value) ? "ANIMATIONTYPE_VECTOR3" : "ANIMATIONTYPE_FLOAT";
-              const valStr = Array.isArray(value) ? this.toBabylonVector(value) : String(value);
-              this.emit(
-                `const ${n} = new BABYLON.Animation("${n}", "${this.mapAnimProperty(key)}", ${fps}, BABYLON.Animation.${animType}, BABYLON.Animation.ANIMATIONLOOPMODE_CYCLE);`
-              );
-              this.emit(
-                `${n}.setKeys([{ frame: 0, value: ${valStr} }, { frame: ${frame}, value: ${valStr} }]);`
-              );
-            }
-          } else if (a.kind === "emit") {
-            this.emit(
-              `// @${entry.time}s: emit "${this.escapeStringValue(a.event, "TypeScript")}"`
-            );
-          } else if (a.kind === "call") {
-            this.emit(
-              `// @${entry.time}s: call ${this.escapeStringValue(a.method, "TypeScript")}()`
-            );
-          }
-        }
-        if (timeline.autoplay) this.emit(`${v}Group.play(${timeline.loop ? "true" : "false"});`);
-        this.emit("");
-      }
-      // --- Audio ---
-      emitAudio(audio) {
-        const v = this.sanitizeName(audio.name);
-        let src = "", volume = 1, loop = false, spatial = false;
-        let position, dist;
-        for (const p of audio.properties) {
-          if (p.key === "src" || p.key === "source") src = String(p.value);
-          else if (p.key === "volume") volume = p.value;
-          else if (p.key === "loop") loop = !!p.value;
-          else if (p.key === "spatial") spatial = !!p.value;
-          else if (p.key === "position" && Array.isArray(p.value)) position = p.value;
-          else if (p.key === "distance") dist = p.value;
-        }
-        const opts = ["autoplay: true"];
-        if (loop) opts.push("loop: true");
-        if (volume !== 1) opts.push(`volume: ${volume}`);
-        if (spatial) opts.push("spatialSound: true");
-        if (dist !== void 0) opts.push(`maxDistance: ${dist}`);
-        this.emit(
-          `const ${v} = new BABYLON.Sound("${this.escapeStringValue(audio.name, "TypeScript")}", "${src}", this.scene, null, { ${opts.join(", ")} });`
-        );
-        if (spatial && position) this.emit(`${v}.setPosition(${this.toBabylonVector(position)});`);
-        this.emit("");
-      }
-      // --- Zone ---
-      emitZone(zone) {
-        const v = this.sanitizeName(zone.name);
-        let shape = "box", position, size, radius;
-        for (const p of zone.properties) {
-          if (p.key === "shape") shape = String(p.value);
-          else if (p.key === "position" && Array.isArray(p.value)) position = p.value;
-          else if (p.key === "size") size = p.value;
-          else if (p.key === "radius") radius = p.value;
-        }
-        if (shape === "sphere") {
-          this.emit(
-            `const ${v} = BABYLON.MeshBuilder.CreateSphere("${this.escapeStringValue(zone.name, "TypeScript")}", { diameter: ${(radius || 5) * 2} }, this.scene);`
-          );
-        } else {
-          const s = Array.isArray(size) ? size : [size || 5, size || 5, size || 5];
-          this.emit(
-            `const ${v} = BABYLON.MeshBuilder.CreateBox("${this.escapeStringValue(zone.name, "TypeScript")}", { width: ${s[0]}, height: ${s[1]}, depth: ${s[2]} }, this.scene);`
-          );
-        }
-        if (position) this.emit(`${v}.position = ${this.toBabylonVector(position)};`);
-        this.emit(`${v}.isVisible = false; ${v}.checkCollisions = true;`);
-        if (zone.handlers?.length) {
-          this.emit(`${v}.actionManager = new BABYLON.ActionManager(this.scene);`);
-          for (const h of zone.handlers) {
-            const trigger = h.event === "on_enter" ? "OnIntersectionEnterTrigger" : h.event === "on_exit" ? "OnIntersectionExitTrigger" : `NothingTrigger /* ${this.escapeStringValue(h.event, "TypeScript")} */`;
-            this.emit(
-              `${v}.actionManager.registerAction(new BABYLON.ExecuteCodeAction({ trigger: BABYLON.ActionManager.${trigger} }, () => { /* ${this.escapeStringValue(h.event, "TypeScript")} */ }));`
-            );
-          }
-        }
-        this.emit("");
-      }
-      // --- UI ---
-      emitUI(ui) {
-        this.emit('const advancedTexture = GUI.AdvancedDynamicTexture.CreateFullscreenUI("UI");');
-        for (const el of ui.elements) {
-          const v = this.sanitizeName(el.name);
-          let elType = "text", text = "", fontSize = 24, color = "#ffffff", bg;
-          for (const p of el.properties) {
-            if (p.key === "type") elType = String(p.value);
-            else if (p.key === "text") text = String(p.value);
-            else if (p.key === "font_size" || p.key === "fontSize") fontSize = p.value;
-            else if (p.key === "color") color = String(p.value);
-            else if (p.key === "background") bg = String(p.value);
-          }
-          if (elType === "button") {
-            this.emit(
-              `const ${v} = GUI.Button.CreateSimpleButton("${this.escapeStringValue(el.name, "TypeScript")}", "${text}");`
-            );
-            this.emit(
-              `${v}.width = "150px"; ${v}.height = "40px"; ${v}.color = "${color}"; ${v}.fontSize = ${fontSize};`
-            );
-            if (bg) this.emit(`${v}.background = "${bg}";`);
-            this.emit(`advancedTexture.addControl(${v});`);
-          } else if (elType === "progress") {
-            this.emit(
-              `const ${v} = new GUI.StackPanel("${this.escapeStringValue(el.name, "TypeScript")}");`
-            );
-            this.emit(`${v}.width = "200px"; ${v}.height = "20px"; advancedTexture.addControl(${v});`);
-          } else {
-            this.emit(
-              `const ${v} = new GUI.TextBlock("${this.escapeStringValue(el.name, "TypeScript")}", "${text}");`
-            );
-            this.emit(
-              `${v}.color = "${color}"; ${v}.fontSize = ${fontSize}; advancedTexture.addControl(${v});`
-            );
-          }
-        }
-        this.emit("");
-      }
-      // --- Effects ---
-      emitEffects(effects) {
-        this.emit(
-          'const pipeline = new BABYLON.DefaultRenderingPipeline("defaultPipeline", true, this.scene);'
-        );
-        for (const fx of effects.effects) {
-          const p = fx.properties;
-          switch (fx.effectType) {
-            case "bloom":
-              this.emit("pipeline.bloomEnabled = true;");
-              if (p.intensity !== void 0) this.emit(`pipeline.bloomWeight = ${p.intensity};`);
-              if (p.threshold !== void 0) this.emit(`pipeline.bloomThreshold = ${p.threshold};`);
-              break;
-            case "dof":
-              this.emit("pipeline.depthOfFieldEnabled = true;");
-              if (p.focalLength !== void 0)
-                this.emit(`pipeline.depthOfField.focalLength = ${p.focalLength};`);
-              if (p.fStop !== void 0) this.emit(`pipeline.depthOfField.fStop = ${p.fStop};`);
-              break;
-            case "ssao":
-              this.emit(
-                'const ssao = new BABYLON.SSAO2RenderingPipeline("ssao", this.scene, { ssaoRatio: 0.5, blurRatio: 0.5 });'
-              );
-              if (p.radius !== void 0) this.emit(`ssao.radius = ${p.radius};`);
-              break;
-            case "vignette":
-              this.emit("pipeline.imageProcessing.vignetteEnabled = true;");
-              if (p.weight !== void 0)
-                this.emit(`pipeline.imageProcessing.vignetteWeight = ${p.weight};`);
-              break;
-            case "chromatic_aberration":
-              this.emit("pipeline.chromaticAberrationEnabled = true;");
-              if (p.amount !== void 0)
-                this.emit(`pipeline.chromaticAberration.aberrationAmount = ${p.amount};`);
-              break;
-            case "tone_mapping":
-              this.emit("pipeline.imageProcessingEnabled = true;");
-              this.emit("pipeline.imageProcessing.toneMappingEnabled = true;");
-              break;
-            default:
-              this.emit(`// Effect "${fx.effectType}": ${JSON.stringify(p)}`);
-          }
-        }
-        this.emit("");
-      }
-      // --- Transition ---
-      emitTransition(tr) {
-        let target, effect, duration;
-        for (const p of tr.properties) {
-          if (p.key === "target") target = String(p.value);
-          else if (p.key === "effect") effect = String(p.value);
-          else if (p.key === "duration") duration = p.value;
-        }
-        this.emit(
-          `// Transition "${this.escapeStringValue(tr.name, "TypeScript")}": navigate to "${target || "?"}" with ${effect || "fade"} over ${duration || 1}s`
-        );
-      }
-      // --- XR ---
-      emitXRSetup() {
-        this.emit("const xr = await this.scene.createDefaultXRExperienceAsync({");
-        this.indent();
-        this.emit('floorMeshes: this.scene.meshes.filter(m => m.name.includes("ground")),');
-        this.dedent();
-        this.emit("});");
-        this.emit("");
-      }
-      // --- Render Loop ---
-      emitRenderLoop() {
-        this.emit("this.engine.runRenderLoop(() => { this.scene.render(); });");
-        this.emit('window.addEventListener("resize", () => { this.engine.resize(); });');
-      }
-      // --- Value Conversion Helpers ---
-      toBabylonColor3(value) {
-        if (typeof value === "string" && value.startsWith("#")) {
-          const h = value.slice(1);
-          const r = parseInt(h.substring(0, 2), 16) / 255;
-          const g = parseInt(h.substring(2, 4), 16) / 255;
-          const b = parseInt(h.substring(4, 6), 16) / 255;
-          return `new BABYLON.Color3(${r.toFixed(3)}, ${g.toFixed(3)}, ${b.toFixed(3)})`;
-        }
-        if (typeof value === "object" && value !== null && "r" in value) {
-          const c = value;
-          const r = c.r > 1 ? c.r / 255 : c.r;
-          const g = c.g > 1 ? c.g / 255 : c.g;
-          const b = c.b > 1 ? c.b / 255 : c.b;
-          return `new BABYLON.Color3(${r.toFixed(3)}, ${g.toFixed(3)}, ${b.toFixed(3)})`;
-        }
-        return "BABYLON.Color3.White()";
-      }
-      toBabylonVector(arr) {
-        if (arr.length >= 3) return `new BABYLON.Vector3(${arr[0]}, ${arr[1]}, ${arr[2]})`;
-        if (arr.length === 2) return `new BABYLON.Vector2(${arr[0]}, ${arr[1]})`;
-        return `new BABYLON.Vector3(${arr[0]}, ${arr[0]}, ${arr[0]})`;
-      }
-      mapShapeToMesh(type) {
-        return SHAPE_TO_MESH[type] || "CreateBox";
-      }
-      meshBuilderOptions(type, size) {
-        const s = typeof size === "number" ? size : 1;
-        switch (type) {
-          case "sphere":
-          case "orb":
-            return `{ diameter: ${s}, segments: 32 }`;
-          case "cube":
-          case "box":
-            return `{ size: ${s} }`;
-          case "cylinder":
-            return `{ diameter: ${s}, height: ${s * 2}, tessellation: 32 }`;
-          case "cone":
-          case "pyramid":
-            return `{ diameterTop: 0, diameterBottom: ${s}, height: ${s * 2}, tessellation: ${type === "pyramid" ? 4 : 32} }`;
-          case "plane":
-          case "ground":
-            return `{ width: ${s}, height: ${s} }`;
-          case "torus":
-          case "ring":
-            return `{ diameter: ${s}, thickness: ${s * 0.3}, tessellation: 32 }`;
-          case "capsule":
-            return `{ radius: ${s * 0.3}, height: ${s} }`;
-          case "disc":
-            return `{ radius: ${s * 0.5}, tessellation: 32 }`;
-          default:
-            return `{ size: ${s} }`;
-        }
-      }
-      mapAnimProperty(key) {
-        const m = {
-          position: "position",
-          rotation: "rotation",
-          scale: "scaling",
-          color: "material.albedoColor",
-          opacity: "material.alpha",
-          emissive: "material.emissiveColor"
-        };
-        return m[key] || key;
-      }
-      // --- Emit Helpers ---
-      emit(line) {
-        this.lines.push(this.options.indent.repeat(this.indentLevel) + line);
-      }
-      indent() {
-        this.indentLevel++;
-      }
-      dedent() {
-        this.indentLevel = Math.max(0, this.indentLevel - 1);
-      }
-      sanitizeName(name) {
-        return name.replace(/[^a-zA-Z0-9_]/g, "_");
-      }
-    };
-  }
-});
-
-export { BabylonCompiler, BabylonCompiler_exports, init_BabylonCompiler };
-//# sourceMappingURL=chunk-VEPGBETF.js.map
-//# sourceMappingURL=chunk-VEPGBETF.js.map