@holoscript/core 7.0.0 → 8.0.0

package/dist/chunk-ZBQXLH2L.js

@@ -0,0 +1,756 @@
+import { init_TraitCompositor, TraitCompositor } from './chunk-4C57PR42.js';
+import { init_DomainBlockCompilerMixin, compileDomainBlocks, compileWeatherBlock, compileAudioSourceBlock, audioSourceToPlayCanvas, compilePostProcessingBlock, compileParticleBlock, particlesToPlayCanvas, compilePhysicsBlock, physicsToPlayCanvas, compileMaterialBlock, materialToPlayCanvas } from './chunk-JCLBKPMX.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/PlayCanvasCompiler.ts
+var PlayCanvasCompiler_exports = {};
+__export(PlayCanvasCompiler_exports, {
+  PlayCanvasCompiler: () => PlayCanvasCompiler
+});
+var SHAPE_TO_PRIMITIVE, PlayCanvasCompiler;
+var init_PlayCanvasCompiler = __esm({
+  "src/compiler/PlayCanvasCompiler.ts"() {
+    init_TraitCompositor();
+    init_CompilerBase();
+    init_DomainBlockCompilerMixin();
+    SHAPE_TO_PRIMITIVE = {
+      sphere: "sphere",
+      orb: "sphere",
+      cube: "box",
+      box: "box",
+      cylinder: "cylinder",
+      cone: "cone",
+      pyramid: "cone",
+      plane: "plane",
+      ground: "plane",
+      torus: "torus",
+      ring: "torus",
+      capsule: "capsule",
+      disc: "plane"
+    };
+    PlayCanvasCompiler = class extends CompilerBase {
+      constructor(options = {}) {
+        super();
+        this.compilerName = "PlayCanvasCompiler";
+        this.lines = [];
+        this.indentLevel = 0;
+        this.options = {
+          className: options.className || "GeneratedScene",
+          enablePhysics: options.enablePhysics ?? true,
+          enableXR: options.enableXR ?? false,
+          indent: options.indent || "  ",
+          provenanceHash: options.provenanceHash ?? ""
+        };
+      }
+      getRequiredCapability() {
+        return ANSCapabilityPath.PLAYCANVAS;
+      }
+      compile(composition, agentToken, outputPath) {
+        this.validateCompilerAccess(agentToken, outputPath);
+        this.lines = [];
+        this.indentLevel = 0;
+        this.emit("// Auto-generated by HoloScript PlayCanvasCompiler");
+        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 app: pc.Application;");
+        this.emit("private canvas: HTMLCanvasElement;");
+        this.emit("");
+        this.emit("constructor(canvas: HTMLCanvasElement) {");
+        this.indent();
+        this.emit("this.canvas = canvas;");
+        this.emit("this.app = new pc.Application(canvas, {");
+        this.indent();
+        this.emit("mouse: new pc.Mouse(canvas),");
+        this.emit("touch: new pc.TouchDevice(canvas),");
+        this.emit("keyboard: new pc.Keyboard(window),");
+        this.dedent();
+        this.emit("});");
+        this.emit("this.app.setCanvasFillMode(pc.FILLMODE_FILL_WINDOW);");
+        this.emit("this.app.setCanvasResolution(pc.RESOLUTION_AUTO);");
+        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("// Default light");
+          this.emit('const defaultLight = new pc.Entity("defaultLight");');
+          this.emit('defaultLight.addComponent("light", {');
+          this.indent();
+          this.emit('type: "directional",');
+          this.emit("color: new pc.Color(1, 1, 1),");
+          this.emit("intensity: 0.7,");
+          this.emit("castShadows: true,");
+          this.dedent();
+          this.emit("});");
+          this.emit("defaultLight.setEulerAngles(45, 30, 0);");
+          this.emit("this.app.root.addChild(defaultLight);");
+          this.emit("");
+        }
+        if (composition.camera) this.emitCamera(composition.camera);
+        else {
+          this.emit("// Default camera");
+          this.emit('const camera = new pc.Entity("defaultCamera");');
+          this.emit('camera.addComponent("camera", {');
+          this.indent();
+          this.emit("clearColor: new pc.Color(0.05, 0.05, 0.1),");
+          this.dedent();
+          this.emit("});");
+          this.emit("camera.setPosition(0, 5, 10);");
+          this.emit("camera.lookAt(0, 0, 0);");
+          this.emit("this.app.root.addChild(camera);");
+          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.compilePlayCanvasDomainBlocks(composition);
+        this.emitStartApp();
+        this.dedent();
+        this.emit("}");
+        this.emit("");
+        this.emit("dispose(): void { this.app.destroy(); }");
+        this.dedent();
+        this.emit("}");
+        return this.lines.join("\n");
+      }
+      compilePlayCanvasDomainBlocks(composition) {
+        const domainBlocks = composition.domainBlocks ?? [];
+        if (domainBlocks.length === 0) return;
+        this.emit("");
+        this.emit("// === v4.2 Domain Blocks ===");
+        let blockIdx = 0;
+        const compiled = compileDomainBlocks(
+          // @ts-expect-error During migration
+          domainBlocks,
+          {
+            material: (block) => {
+              const mat = compileMaterialBlock(block);
+              return materialToPlayCanvas(mat, `db${blockIdx++}`);
+            },
+            physics: (block) => {
+              const phys = compilePhysicsBlock(block);
+              return physicsToPlayCanvas(phys, `db${blockIdx++}`);
+            },
+            vfx: (block) => {
+              const ps = compileParticleBlock(block);
+              return particlesToPlayCanvas(ps, `db${blockIdx++}`);
+            },
+            postfx: (block) => {
+              const pp = compilePostProcessingBlock(block);
+              return `// Post-Processing: ${pp.keyword} \u2014 configure via PlayCanvas PostEffects
+` + pp.effects.map((e) => `// Effect: ${e.type} \u2014 ${JSON.stringify(e.properties)}`).join("\n");
+            },
+            audio: (block) => {
+              const audio = compileAudioSourceBlock(block);
+              return audioSourceToPlayCanvas(audio, `db${blockIdx++}`);
+            },
+            weather: (block) => {
+              const weather = compileWeatherBlock(block);
+              return `// Weather: ${weather.keyword} "${weather.name || ""}" \u2014 implement via PlayCanvas particle system
+` + weather.layers.map((l) => `// Layer: ${l.type} \u2014 ${JSON.stringify(l.properties)}`).join("\n");
+            }
+          },
+          (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 pc from "playcanvas";');
+      }
+      // --- Scene Setup ---
+      emitSceneSetup(_composition) {
+        if (this.options.enablePhysics) {
+          this.emit("this.app.systems.rigidbody?.setGravity(0, -9.81, 0);");
+        }
+        this.emit("");
+      }
+      // --- Environment ---
+      emitEnvironment(env) {
+        for (const prop of env.properties) {
+          if (prop.key === "skybox" || prop.key === "preset") {
+            this.emit(`this.app.scene.setSkybox(null); // Skybox: "${prop.value}"`);
+            this.emit(`this.app.scene.skyboxIntensity = 1.0;`);
+          } else if (prop.key === "fog" && typeof prop.value === "object") {
+            const fog = prop.value;
+            this.emit(`this.app.scene.fog = pc.FOG_LINEAR;`);
+            if (fog.color) this.emit(`this.app.scene.fogColor = ${this.toPlayCanvasColor(fog.color)};`);
+            if (fog.near !== void 0) this.emit(`this.app.scene.fogStart = ${fog.near};`);
+            if (fog.far !== void 0) this.emit(`this.app.scene.fogEnd = ${fog.far};`);
+          } else if (prop.key === "ambient_light") {
+            this.emit(
+              `this.app.scene.ambientLight = new pc.Color(${prop.value}, ${prop.value}, ${prop.value});`
+            );
+          } else if (prop.key === "ground") {
+            this.emit('const ground = new pc.Entity("ground");');
+            this.emit('ground.addComponent("render", { type: "plane" });');
+            this.emit("ground.setLocalScale(100, 1, 100);");
+            if (typeof prop.value === "object" && prop.value !== null) {
+              const g = prop.value;
+              if (g.color) {
+                this.emit("const groundMat = new pc.StandardMaterial();");
+                this.emit(`groundMat.diffuse = ${this.toPlayCanvasColor(g.color)};`);
+                this.emit("groundMat.update();");
+                this.emit("ground.render!.meshInstances[0].material = groundMat;");
+              }
+            }
+            this.emit("this.app.root.addChild(ground);");
+          }
+        }
+        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":
+              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")}`);
+        this.emit(
+          `const ${v} = new pc.Entity("${this.escapeStringValue(obj.name, "TypeScript")}");`
+        );
+        if (modelSrc) {
+          this.emit(`// Model: ${modelSrc} \u2014 load via asset registry`);
+          this.emit(`${v}.addComponent("render", { type: "asset" });`);
+        } else if (geom === "text" || textContent) {
+          this.emit(`${v}.addComponent("element", {`);
+          this.indent();
+          this.emit(`type: "text",`);
+          this.emit(`text: "${textContent || ""}",`);
+          this.emit(`fontSize: 48,`);
+          this.emit(`color: new pc.Color(1, 1, 1),`);
+          this.emit(`anchor: new pc.Vec4(0.5, 0.5, 0.5, 0.5),`);
+          this.dedent();
+          this.emit("});");
+        } else {
+          const prim = this.mapShapeToPrimitive(geom);
+          this.emit(`${v}.addComponent("render", { type: "${prim}" });`);
+          if (Object.keys(mat).length > 0) {
+            this.emit(`const ${v}Mat = new pc.StandardMaterial();`);
+            if (mat.color) this.emit(`${v}Mat.diffuse = ${this.toPlayCanvasColor(mat.color)};`);
+            if (mat.roughness !== void 0)
+              this.emit(`${v}Mat.shininess = ${(1 - mat.roughness) * 100};`);
+            if (mat.metalness !== void 0) this.emit(`${v}Mat.metalness = ${mat.metalness};`);
+            if (mat.opacity !== void 0 && mat.opacity < 1) {
+              this.emit(`${v}Mat.opacity = ${mat.opacity};`);
+              this.emit(`${v}Mat.blendType = pc.BLEND_NORMAL;`);
+            }
+            if (mat.emissive) this.emit(`${v}Mat.emissive = ${this.toPlayCanvasColor(mat.emissive)};`);
+            if (mat.emissiveIntensity !== void 0)
+              this.emit(`${v}Mat.emissiveIntensity = ${mat.emissiveIntensity};`);
+            this.emit(`${v}Mat.update();`);
+            this.emit(`${v}.render!.meshInstances[0].material = ${v}Mat;`);
+          }
+        }
+        if (position) this.emit(`${v}.setPosition(${position[0]}, ${position[1]}, ${position[2]});`);
+        if (rotation) this.emit(`${v}.setEulerAngles(${rotation[0]}, ${rotation[1]}, ${rotation[2]});`);
+        if (scale) {
+          if (Array.isArray(scale))
+            this.emit(`${v}.setLocalScale(${scale[0]}, ${scale[1]}, ${scale[2]});`);
+          else this.emit(`${v}.setLocalScale(${scale}, ${scale}, ${scale});`);
+        }
+        if (size) {
+          const s = typeof size === "number" ? size : 1;
+          this.emit(`${v}.setLocalScale(${s}, ${s}, ${s});`);
+        }
+        for (const trait of obj.traits || []) {
+          if (trait.name === "grabbable") {
+            this.emit(`${v}.addComponent("button", { active: true });`);
+            this.emit(
+              `${v}.button!.on("click", () => { console.log("Picked: ${this.escapeStringValue(obj.name, "TypeScript")}"); });`
+            );
+          } else if (trait.name === "physics" || trait.name === "collidable") {
+            const mt = (trait.config?.type || "dynamic") === "static" ? "static" : "dynamic";
+            this.emit(`${v}.addComponent("rigidbody", {`);
+            this.indent();
+            this.emit(`type: "${mt}",`);
+            this.emit(`mass: ${trait.config?.mass ?? 1},`);
+            if (trait.config?.restitution !== void 0)
+              this.emit(`restitution: ${trait.config.restitution},`);
+            if (trait.config?.friction !== void 0) this.emit(`friction: ${trait.config.friction},`);
+            this.dedent();
+            this.emit("});");
+            this.emit(`${v}.addComponent("collision", { type: "${this.mapShapeToPrimitive(geom)}" });`);
+          } else if (trait.name === "hoverable") {
+            this.emit(`${v}.addComponent("button", { active: true });`);
+            this.emit(`${v}.button!.on("mouseenter", () => { /* hover enter */ });`);
+            this.emit(`${v}.button!.on("mouseleave", () => { /* hover exit */ });`);
+          } else if (trait.name === "accessible") {
+            this.emit(
+              `// @accessible: role="${trait.config?.role || "generic"}" for "${this.escapeStringValue(obj.name, "TypeScript")}"`
+            );
+          } else if (trait.name === "shadow") {
+            this.emit(`${v}.render!.castShadows = true;`);
+            this.emit(`${v}.render!.receiveShadows = true;`);
+          } 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} = new pc.StandardMaterial();`);
+            if (composed.color)
+              this.emit(`${matVar}.diffuse = ${this.toPlayCanvasColor(composed.color)};`);
+            if (composed.roughness !== void 0)
+              this.emit(`${matVar}.shininess = ${(1 - composed.roughness) * 100};`);
+            if (composed.metalness !== void 0)
+              this.emit(`${matVar}.metalness = ${composed.metalness};`);
+            if (composed.opacity !== void 0 && composed.opacity < 1) {
+              this.emit(`${matVar}.opacity = ${composed.opacity};`);
+              this.emit(`${matVar}.blendType = pc.BLEND_NORMAL;`);
+            }
+            if (composed.emissive)
+              this.emit(`${matVar}.emissive = ${this.toPlayCanvasColor(composed.emissive)};`);
+            if (composed.emissiveIntensity !== void 0)
+              this.emit(`${matVar}.emissiveIntensity = ${composed.emissiveIntensity};`);
+            this.emit(`${matVar}.update();`);
+            this.emit(`${v}.render!.meshInstances[0].material = ${matVar};`);
+          }
+        }
+        const parent = parentVar || "this.app.root";
+        this.emit(`${parent}.addChild(${v});`);
+        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 pc.Entity("${this.escapeStringValue(group.name, "TypeScript")}");`
+        );
+        for (const p of group.properties) {
+          if (p.key === "position" && Array.isArray(p.value))
+            this.emit(`${v}.setPosition(${p.value[0]}, ${p.value[1]}, ${p.value[2]});`);
+          else if (p.key === "rotation" && Array.isArray(p.value))
+            this.emit(`${v}.setEulerAngles(${p.value[0]}, ${p.value[1]}, ${p.value[2]});`);
+          else if (p.key === "scale") {
+            if (Array.isArray(p.value))
+              this.emit(`${v}.setLocalScale(${p.value[0]}, ${p.value[1]}, ${p.value[2]});`);
+            else this.emit(`${v}.setLocalScale(${p.value}, ${p.value}, ${p.value});`);
+          }
+        }
+        const parent = parentVar || "this.app.root";
+        this.emit(`${parent}.addChild(${v});`);
+        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 pcType = this.mapLightType(light.lightType);
+        this.emit(
+          `const ${v} = new pc.Entity("${this.escapeStringValue(light.name, "TypeScript")}");`
+        );
+        this.emit(`${v}.addComponent("light", {`);
+        this.indent();
+        this.emit(`type: "${pcType}",`);
+        if (color) this.emit(`color: ${this.toPlayCanvasColor(color)},`);
+        if (intensity !== void 0) this.emit(`intensity: ${intensity},`);
+        if (castShadow) this.emit("castShadows: true,");
+        if (dist !== void 0) this.emit(`range: ${dist},`);
+        if (angle !== void 0 && pcType === "spot")
+          this.emit(`outerConeAngle: ${angle * (180 / Math.PI)},`);
+        this.dedent();
+        this.emit("});");
+        if (pos) this.emit(`${v}.setPosition(${pos[0]}, ${pos[1]}, ${pos[2]});`);
+        if (dir) this.emit(`${v}.setEulerAngles(${this.directionToEuler(dir)});`);
+        this.emit("this.app.root.addChild(" + v + ");");
+        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;
+        }
+        this.emit('const camera = new pc.Entity("camera");');
+        this.emit('camera.addComponent("camera", {');
+        this.indent();
+        this.emit("clearColor: new pc.Color(0.05, 0.05, 0.1),");
+        if (cam.cameraType === "orthographic") {
+          this.emit("projection: pc.PROJECTION_ORTHOGRAPHIC,");
+        }
+        if (fov !== void 0) this.emit(`fov: ${fov},`);
+        if (near !== void 0) this.emit(`nearClip: ${near},`);
+        if (far !== void 0) this.emit(`farClip: ${far},`);
+        this.dedent();
+        this.emit("});");
+        if (pos) this.emit(`camera.setPosition(${pos[0]}, ${pos[1]}, ${pos[2]});`);
+        else this.emit("camera.setPosition(0, 5, 10);");
+        if (lookAt) this.emit(`camera.lookAt(${lookAt[0]}, ${lookAt[1]}, ${lookAt[2]});`);
+        else this.emit("camera.lookAt(0, 0, 0);");
+        this.emit("this.app.root.addChild(camera);");
+        this.emit("");
+      }
+      // --- Timeline ---
+      emitTimeline(timeline) {
+        this.sanitizeName(timeline.name);
+        this.emit(`// Timeline: "${this.escapeStringValue(timeline.name, "TypeScript")}"`);
+        for (const entry of timeline.entries) {
+          const a = entry.action;
+          if (a.kind === "animate") {
+            this.emit(`// @${entry.time}s: animate ${a.target} ${JSON.stringify(a.properties)}`);
+          } 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(`// autoplay: ${timeline.loop ? "loop" : "once"}`);
+        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;
+        }
+        this.emit(
+          `const ${v} = new pc.Entity("${this.escapeStringValue(audio.name, "TypeScript")}");`
+        );
+        this.emit(`${v}.addComponent("sound");`);
+        this.emit(`${v}.sound!.addSlot("default", {`);
+        this.indent();
+        this.emit(`asset: null, // Load "${src}" via asset registry`);
+        this.emit(`loop: ${loop},`);
+        this.emit(`volume: ${volume},`);
+        this.emit(`autoPlay: true,`);
+        if (dist !== void 0) this.emit(`maxDistance: ${dist},`);
+        if (spatial) this.emit("positional: true,");
+        this.dedent();
+        this.emit("});");
+        if (position) this.emit(`${v}.setPosition(${position[0]}, ${position[1]}, ${position[2]});`);
+        this.emit(`this.app.root.addChild(${v});`);
+        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;
+        }
+        this.emit(
+          `const ${v} = new pc.Entity("${this.escapeStringValue(zone.name, "TypeScript")}");`
+        );
+        if (shape === "sphere") {
+          this.emit(`${v}.addComponent("collision", { type: "sphere", radius: ${radius || 5} });`);
+        } else {
+          const s = Array.isArray(size) ? size : [size || 5, size || 5, size || 5];
+          this.emit(
+            `${v}.addComponent("collision", { type: "box", halfExtents: new pc.Vec3(${s[0] / 2}, ${s[1] / 2}, ${s[2] / 2}) });`
+          );
+        }
+        this.emit(`${v}.addComponent("rigidbody", { type: "static" });`);
+        if (position) this.emit(`${v}.setPosition(${position[0]}, ${position[1]}, ${position[2]});`);
+        if (zone.handlers?.length) {
+          for (const h of zone.handlers) {
+            const event = h.event === "on_enter" ? "triggerenter" : h.event === "on_exit" ? "triggerleave" : h.event;
+            this.emit(
+              `${v}.collision!.on("${event}", (result: unknown) => { /* ${this.escapeStringValue(h.event, "TypeScript")} */ });`
+            );
+          }
+        }
+        this.emit(`this.app.root.addChild(${v});`);
+        this.emit("");
+      }
+      // --- UI ---
+      emitUI(ui) {
+        this.emit('const screenEntity = new pc.Entity("screen");');
+        this.emit(
+          'screenEntity.addComponent("screen", { screenSpace: true, referenceResolution: new pc.Vec2(1280, 720) });'
+        );
+        this.emit("this.app.root.addChild(screenEntity);");
+        for (const el of ui.elements) {
+          const v = this.sanitizeName(el.name);
+          let elType = "text", text = "", fontSize = 24, color = "#ffffff";
+          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") String(p.value);
+          }
+          this.emit(
+            `const ${v} = new pc.Entity("${this.escapeStringValue(el.name, "TypeScript")}");`
+          );
+          if (elType === "button") {
+            this.emit(`${v}.addComponent("element", {`);
+            this.indent();
+            this.emit(`type: "text",`);
+            this.emit(`text: "${text}",`);
+            this.emit(`fontSize: ${fontSize},`);
+            this.emit(`color: ${this.toPlayCanvasColor(color)},`);
+            this.emit(`anchor: new pc.Vec4(0.5, 0.5, 0.5, 0.5),`);
+            this.emit(`pivot: new pc.Vec2(0.5, 0.5),`);
+            this.emit(`width: 150,`);
+            this.emit(`height: 40,`);
+            this.dedent();
+            this.emit("});");
+            this.emit(`${v}.addComponent("button", { active: true });`);
+          } else if (elType === "progress") {
+            this.emit(`${v}.addComponent("element", {`);
+            this.indent();
+            this.emit('type: "image",');
+            this.emit("anchor: new pc.Vec4(0.5, 0.5, 0.5, 0.5),");
+            this.emit("width: 200,");
+            this.emit("height: 20,");
+            this.dedent();
+            this.emit("});");
+          } else {
+            this.emit(`${v}.addComponent("element", {`);
+            this.indent();
+            this.emit(`type: "text",`);
+            this.emit(`text: "${text}",`);
+            this.emit(`fontSize: ${fontSize},`);
+            this.emit(`color: ${this.toPlayCanvasColor(color)},`);
+            this.emit(`anchor: new pc.Vec4(0.5, 0.5, 0.5, 0.5),`);
+            this.dedent();
+            this.emit("});");
+          }
+          this.emit(`screenEntity.addChild(${v});`);
+        }
+        this.emit("");
+      }
+      // --- Effects ---
+      emitEffects(effects) {
+        for (const fx of effects.effects) {
+          const p = fx.properties;
+          switch (fx.effectType) {
+            case "bloom":
+              this.emit("// Post-processing: Bloom");
+              this.emit("this.app.scene.rendering.toneMapping = pc.TONEMAP_ACES;");
+              if (p.intensity !== void 0) this.emit(`// bloom intensity: ${p.intensity}`);
+              break;
+            case "ssao":
+              this.emit("// Post-processing: SSAO");
+              if (p.radius !== void 0) this.emit(`// ssao radius: ${p.radius}`);
+              break;
+            case "vignette":
+              this.emit("// Post-processing: Vignette");
+              if (p.weight !== void 0) this.emit(`// vignette weight: ${p.weight}`);
+              break;
+            case "tone_mapping":
+              this.emit("this.app.scene.rendering.toneMapping = pc.TONEMAP_ACES;");
+              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("if (this.app.xr.supported) {");
+        this.indent();
+        this.emit(
+          'this.app.xr.start(this.app.root.findByName("camera")?.camera!, pc.XRTYPE_VR, pc.XRSPACE_LOCAL);'
+        );
+        this.dedent();
+        this.emit("}");
+        this.emit("");
+      }
+      // --- Start App ---
+      emitStartApp() {
+        this.emit("this.app.start();");
+        this.emit('window.addEventListener("resize", () => { this.app.resizeCanvas(); });');
+      }
+      // --- Value Conversion Helpers ---
+      toPlayCanvasColor(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 pc.Color(${r.toFixed(3)}, ${g.toFixed(3)}, ${b.toFixed(3)})`;
+        }
+        if (typeof value === "object" && value !== null && "r" in value) {
+          const c = value;
+          const rVal = Number(c.r);
+          const gVal = Number(c.g);
+          const bVal = Number(c.b);
+          const r = rVal > 1 ? rVal / 255 : rVal;
+          const g = gVal > 1 ? gVal / 255 : gVal;
+          const b = bVal > 1 ? bVal / 255 : bVal;
+          return `new pc.Color(${r.toFixed(3)}, ${g.toFixed(3)}, ${b.toFixed(3)})`;
+        }
+        return "new pc.Color(1, 1, 1)";
+      }
+      mapShapeToPrimitive(type) {
+        return SHAPE_TO_PRIMITIVE[type] || "box";
+      }
+      mapLightType(type) {
+        switch (type) {
+          case "hemisphere":
+          case "ambient":
+            return "directional";
+          case "directional":
+            return "directional";
+          case "point":
+            return "point";
+          case "spot":
+            return "spot";
+          case "area":
+            return "point";
+          default:
+            return "directional";
+        }
+      }
+      directionToEuler(dir) {
+        const x = Number(dir[0]) || 0, y = Number(dir[1]) || 0, z = Number(dir[2]) || 0;
+        const pitch = Math.atan2(-y, Math.sqrt(x * x + z * z)) * (180 / Math.PI);
+        const yaw = Math.atan2(x, z) * (180 / Math.PI);
+        return `${pitch.toFixed(1)}, ${yaw.toFixed(1)}, 0`;
+      }
+      // --- 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 { PlayCanvasCompiler, PlayCanvasCompiler_exports, init_PlayCanvasCompiler };
+//# sourceMappingURL=chunk-ZBQXLH2L.js.map
+//# sourceMappingURL=chunk-ZBQXLH2L.js.map