@holoscript/core 7.0.0 → 8.0.1

package/dist/chunk-J7XZV333.js

@@ -0,0 +1,844 @@
+import { init_ProvenanceSemiring, ProvenanceSemiring } from './chunk-TJHVSBP2.js';
+import { init_TraitCompositor, TraitCompositor } from './chunk-4C57PR42.js';
+import { init_PlatformConditionalCompilerMixin, createPlatformTarget, PlatformConditionalCompilerMixin } from './chunk-GZG4KA4E.js';
+import { init_DomainBlockCompilerMixin, compileDomainBlocks, compileWeatherBlock, compileAudioSourceBlock, audioSourceToBabylon, compilePostProcessingBlock, postProcessingToBabylon, compileParticleBlock, particlesToBabylon, compilePhysicsBlock, physicsToBabylon, compileMaterialBlock, materialToBabylon } from './chunk-BOVPWH4H.js';
+import { init_CompilerBase, CompilerBase } from './chunk-QPSKHBJP.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-J7XZV333.js.map
+//# sourceMappingURL=chunk-J7XZV333.js.map