@holoscript/core 7.0.0 → 8.0.0

package/dist/chunk-25IQCHTO.cjs

@@ -0,0 +1,781 @@
+'use strict';
+
+var chunkAIA52I7T_cjs = require('./chunk-AIA52I7T.cjs');
+var chunkXUUVDHIF_cjs = require('./chunk-XUUVDHIF.cjs');
+var chunkKKP7JKN4_cjs = require('./chunk-KKP7JKN4.cjs');
+var chunkHCCQLAA4_cjs = require('./chunk-HCCQLAA4.cjs');
+var ans = require('@holoscript/core-types/ans');
+
+// src/compiler/UnityCompiler.ts
+var UnityCompiler_exports = {};
+chunkHCCQLAA4_cjs.__export(UnityCompiler_exports, {
+  UnityCompiler: () => exports.UnityCompiler
+});
+exports.UnityCompiler = void 0;
+var init_UnityCompiler = chunkHCCQLAA4_cjs.__esm({
+  "src/compiler/UnityCompiler.ts"() {
+    chunkKKP7JKN4_cjs.init_CompilerBase();
+    chunkXUUVDHIF_cjs.init_DomainBlockCompilerMixin();
+    chunkAIA52I7T_cjs.init_PlatformConditionalCompilerMixin();
+    exports.UnityCompiler = class extends chunkKKP7JKN4_cjs.CompilerBase {
+      constructor(options = {}) {
+        super();
+        this.compilerName = "UnityCompiler";
+        this.lines = [];
+        this.indentLevel = 0;
+        this.options = {
+          namespace: options.namespace || "HoloScene",
+          className: options.className || "GeneratedScene",
+          useURP: options.useURP ?? true,
+          indent: options.indent || "    ",
+          provenanceHash: options.provenanceHash ?? "",
+          holomapPointCloud: options.holomapPointCloud
+        };
+        if (options.platformTarget) {
+          this._platformTarget = typeof options.platformTarget === "string" ? chunkAIA52I7T_cjs.createPlatformTarget(options.platformTarget) : options.platformTarget;
+        }
+      }
+      getRequiredCapability() {
+        return ans.ANSCapabilityPath.UNITY;
+      }
+      compile(composition, agentToken, outputPath) {
+        this.validateCompilerAccess(agentToken, outputPath);
+        if (this._platformTarget) {
+          const platformMixin = new chunkAIA52I7T_cjs.PlatformConditionalCompilerMixin();
+          composition = platformMixin.filterForPlatform(composition, this._platformTarget);
+        }
+        this.lines = [];
+        this.indentLevel = 0;
+        this.emit("// Auto-generated by HoloScript UnityCompiler");
+        this.emit(
+          `// Source: composition "${this.escapeStringValue(composition.name, "CSharp")}"`
+        );
+        this.emit("// Do not edit manually \u2014 regenerate from .holo source");
+        if (this.options.provenanceHash) {
+          this.emit(`// Provenance Hash: ${this.options.provenanceHash}`);
+        }
+        this.emit("");
+        this.emit("using UnityEngine;");
+        this.emit("using UnityEngine.UI;");
+        if (composition.timelines?.length) this.emit("using System.Collections;");
+        this.emit("");
+        this.emit(`namespace ${this.options.namespace}`);
+        this.emit("{");
+        this.indentLevel++;
+        this.emit(`public class ${this.options.className} : MonoBehaviour`);
+        this.emit("{");
+        this.indentLevel++;
+        if (composition.state) {
+          this.emit("// === State ===");
+          for (const prop of composition.state.properties) {
+            const csType = this.toCSharpType(prop.value);
+            const csVal = this.toCSharpValue(prop.value);
+            this.emit(
+              `private ${csType} ${this.escapeStringValue(prop.key, "CSharp")} = ${csVal};`
+            );
+          }
+          this.emit("");
+        }
+        this.emit("private void Awake()");
+        this.emit("{");
+        this.indentLevel++;
+        if (composition.environment) {
+          this.compileEnvironment(composition.environment);
+        }
+        if (composition.lights) {
+          for (const light of composition.lights) {
+            this.compileLight(light);
+          }
+        }
+        if (composition.camera) {
+          this.compileCamera(composition.camera);
+        }
+        if (composition.objects) {
+          for (const obj of composition.objects) {
+            this.compileObject(obj, "transform");
+          }
+        }
+        if (composition.spatialGroups) {
+          for (const group of composition.spatialGroups) {
+            this.compileSpatialGroup(group, "transform");
+          }
+        }
+        if (composition.audio) {
+          for (const audio of composition.audio) {
+            this.compileAudio(audio);
+          }
+        }
+        if (composition.zones) {
+          for (const zone of composition.zones) {
+            this.compileZone(zone);
+          }
+        }
+        if (composition.timelines) {
+          for (const tl of composition.timelines) {
+            if (tl.autoplay) {
+              this.emit(`StartCoroutine(${this.sanitizeName(tl.name)}Routine());`);
+            }
+          }
+        }
+        this.emitHolomapPointCloudLoader();
+        this.indentLevel--;
+        this.emit("}");
+        this.emit("");
+        if (composition.timelines) {
+          for (const tl of composition.timelines) {
+            this.compileTimeline(tl);
+          }
+        }
+        if (composition.effects) {
+          this.compileEffects(composition.effects);
+        }
+        if (composition.transitions) {
+          for (const tr of composition.transitions) {
+            this.compileTransition(tr);
+          }
+        }
+        if (composition.ui) {
+          this.compileUI(composition.ui);
+        }
+        this.compileDomainBlocks(composition);
+        this.indentLevel--;
+        this.emit("}");
+        this.indentLevel--;
+        this.emit("}");
+        return this.lines.join("\n");
+      }
+      emitHolomapPointCloudLoader() {
+        const h = this.options.holomapPointCloud;
+        if (!h || h.pointCount < 1) return;
+        this.emit("    // --- HoloMap point cloud (base64 \u2192 Mesh topology Points) ---");
+        this.emit("    {");
+        const posLit = this.chunkBase64CSharpLiteral(h.positionsB64);
+        const colLit = this.chunkBase64CSharpLiteral(h.colorsB64);
+        this.emit(`      string holomapPosB64 = ${posLit};`);
+        this.emit(`      string holomapColB64 = ${colLit};`);
+        this.emit(`      int holomapN = ${h.pointCount};`);
+        this.emit(
+          "      byte[] holomapPos = System.Convert.FromBase64String(holomapPosB64);"
+        );
+        this.emit(
+          "      byte[] holomapCol = System.Convert.FromBase64String(holomapColB64);"
+        );
+        this.emit("      if (holomapPos.Length >= holomapN * 12 && holomapCol.Length >= holomapN * 3)");
+        this.emit("      {");
+        this.emit(
+          '        var holomapGo = new GameObject("HoloMapReconstructionPoints");'
+        );
+        this.emit("        holomapGo.transform.SetParent(transform, false);");
+        this.emit("        var mesh = new Mesh();");
+        this.emit(
+          "        mesh.indexFormat = UnityEngine.Rendering.IndexFormat.UInt32;"
+        );
+        this.emit("        var verts = new Vector3[holomapN];");
+        this.emit("        var cols = new Color32[holomapN];");
+        this.emit("        var idx = new int[holomapN];");
+        this.emit("        for (int i = 0; i < holomapN; i++)");
+        this.emit("        {");
+        this.emit(
+          "          int p = i * 12; int c = i * 3;"
+        );
+        this.emit(
+          "          verts[i] = new Vector3(System.BitConverter.ToSingle(holomapPos, p), System.BitConverter.ToSingle(holomapPos, p + 4), System.BitConverter.ToSingle(holomapPos, p + 8));"
+        );
+        this.emit(
+          "          cols[i] = new Color32(holomapCol[c], holomapCol[c + 1], holomapCol[c + 2], 255);"
+        );
+        this.emit("          idx[i] = i;");
+        this.emit("        }");
+        this.emit("        mesh.vertices = verts;");
+        this.emit("        mesh.colors32 = cols;");
+        this.emit("        mesh.SetIndices(idx, MeshTopology.Points, 0, true);");
+        this.emit("        mesh.RecalculateBounds();");
+        this.emit("        var mf = holomapGo.AddComponent<MeshFilter>();");
+        this.emit("        mf.sharedMesh = mesh;");
+        this.emit("        var mr = holomapGo.AddComponent<MeshRenderer>();");
+        this.emit(
+          '        var sh = Shader.Find("Universal Render Pipeline/Unlit");'
+        );
+        this.emit(
+          '        if (sh == null) sh = Shader.Find("Unlit/Color");'
+        );
+        this.emit('        mr.sharedMaterial = sh != null ? new Material(sh) : new Material(Shader.Find("Hidden/InternalErrorShader"));');
+        this.emit("      }");
+        this.emit("    }");
+      }
+      /** Concatenated string literals so very large MCP payloads stay valid C#. */
+      chunkBase64CSharpLiteral(b64) {
+        const chunk = 4096;
+        if (b64.length <= chunk) return `"${b64}"`;
+        const parts = [];
+        for (let i = 0; i < b64.length; i += chunk) {
+          parts.push(`"${b64.slice(i, i + chunk)}"`);
+        }
+        return parts.join(" + ");
+      }
+      compileDomainBlocks(composition) {
+        const domainBlocks = composition.domainBlocks ?? [];
+        if (domainBlocks.length === 0) return;
+        this.emit("");
+        this.emit("// === v4.2 Domain Blocks ===");
+        let blockIdx = 0;
+        const compiled = chunkXUUVDHIF_cjs.compileDomainBlocks(
+          domainBlocks,
+          {
+            material: (block) => {
+              const mat = chunkXUUVDHIF_cjs.compileMaterialBlock(block);
+              const prefix = `db${blockIdx++}`;
+              return chunkXUUVDHIF_cjs.materialToUnity(mat, prefix);
+            },
+            physics: (block) => {
+              const phys = chunkXUUVDHIF_cjs.compilePhysicsBlock(block);
+              const prefix = `db${blockIdx++}`;
+              return chunkXUUVDHIF_cjs.physicsToUnity(phys, prefix);
+            },
+            vfx: (block) => {
+              const ps = chunkXUUVDHIF_cjs.compileParticleBlock(block);
+              const prefix = `db${blockIdx++}`;
+              return chunkXUUVDHIF_cjs.particlesToUnity(ps, prefix);
+            },
+            postfx: (block) => {
+              const pp = chunkXUUVDHIF_cjs.compilePostProcessingBlock(block);
+              return chunkXUUVDHIF_cjs.postProcessingToUnity(pp);
+            },
+            audio: (block) => {
+              const audio = chunkXUUVDHIF_cjs.compileAudioSourceBlock(block);
+              const prefix = `db${blockIdx++}`;
+              return chunkXUUVDHIF_cjs.audioSourceToUnity(audio, prefix);
+            },
+            weather: (block) => {
+              const weather = chunkXUUVDHIF_cjs.compileWeatherBlock(block);
+              return chunkXUUVDHIF_cjs.weatherToUnity(weather);
+            },
+            narrative: (block) => {
+              const narr = chunkXUUVDHIF_cjs.compileNarrativeBlock(block);
+              return chunkXUUVDHIF_cjs.narrativeToUnity(narr);
+            },
+            payment: (block) => {
+              const pay = chunkXUUVDHIF_cjs.compilePaymentBlock(block);
+              return chunkXUUVDHIF_cjs.paymentToUnity(pay);
+            },
+            healthcare: (block) => {
+              const h = chunkXUUVDHIF_cjs.compileHealthcareBlock(block);
+              return chunkXUUVDHIF_cjs.healthcareToUnity(h);
+            },
+            robotics: (block) => {
+              const r = chunkXUUVDHIF_cjs.compileRoboticsBlock(block);
+              return chunkXUUVDHIF_cjs.roboticsToUnity(r);
+            },
+            iot: (block) => chunkXUUVDHIF_cjs.iotToUnity(chunkXUUVDHIF_cjs.compileIoTBlock(block)),
+            dataviz: (block) => chunkXUUVDHIF_cjs.datavizToUnity(chunkXUUVDHIF_cjs.compileDataVizBlock(block)),
+            education: (block) => chunkXUUVDHIF_cjs.educationToUnity(chunkXUUVDHIF_cjs.compileEducationBlock(block)),
+            music: (block) => chunkXUUVDHIF_cjs.musicToUnity(chunkXUUVDHIF_cjs.compileMusicBlock(block)),
+            architecture: (block) => chunkXUUVDHIF_cjs.architectureToUnity(chunkXUUVDHIF_cjs.compileArchitectureBlock(block)),
+            web3: (block) => chunkXUUVDHIF_cjs.web3ToUnity(chunkXUUVDHIF_cjs.compileWeb3Block(block)),
+            procedural: (block) => chunkXUUVDHIF_cjs.proceduralToUnity(chunkXUUVDHIF_cjs.compileProceduralBlock(block)),
+            rendering: (block) => chunkXUUVDHIF_cjs.renderingToUnity(chunkXUUVDHIF_cjs.compileRenderingBlock(block)),
+            navigation: (block) => chunkXUUVDHIF_cjs.navigationToUnity(chunkXUUVDHIF_cjs.compileNavigationBlock(block)),
+            input: (block) => chunkXUUVDHIF_cjs.inputToUnity(chunkXUUVDHIF_cjs.compileInputBlock(block))
+          },
+          (block) => `// Domain block: ${block.domain}/${block.keyword} "${this.escapeStringValue(block.name, "CSharp")}"`
+        );
+        for (const line of compiled) {
+          for (const l of line.split("\n")) {
+            this.emit(l);
+          }
+        }
+      }
+      compileEnvironment(env) {
+        this.emit("// === Environment ===");
+        for (const prop of env.properties) {
+          if (prop.key === "preset" || prop.key === "skybox") {
+            this.emit(`RenderSettings.skybox = Resources.Load<Material>("Skybox/${prop.value}");`);
+          } else if (prop.key === "fog" && typeof prop.value === "object") {
+            const fog = prop.value;
+            this.emit("RenderSettings.fog = true;");
+            if (fog.color) this.emit(`RenderSettings.fogColor = ${this.toColor(fog.color)};`);
+            if (fog.near !== void 0) this.emit(`RenderSettings.fogStartDistance = ${fog.near}f;`);
+            if (fog.far !== void 0) this.emit(`RenderSettings.fogEndDistance = ${fog.far}f;`);
+          } else if (prop.key === "ambient_light") {
+            this.emit(`RenderSettings.ambientIntensity = ${prop.value}f;`);
+          }
+        }
+        this.emit("");
+      }
+      compileLight(light) {
+        const varName = this.sanitizeName(light.name);
+        this.emit(`// Light: ${this.escapeStringValue(light.name, "CSharp")}`);
+        this.emit(
+          `var ${varName}GO = new GameObject("${this.escapeStringValue(light.name, "CSharp")}");`
+        );
+        this.emit(`${varName}GO.transform.SetParent(transform);`);
+        this.emit(`var ${varName} = ${varName}GO.AddComponent<Light>();`);
+        const typeMap = {
+          directional: "LightType.Directional",
+          point: "LightType.Point",
+          spot: "LightType.Spot",
+          area: "LightType.Area"
+        };
+        this.emit(`${varName}.type = ${typeMap[light.lightType] || "LightType.Directional"};`);
+        for (const prop of light.properties) {
+          if (prop.key === "color") {
+            this.emit(`${varName}.color = ${this.toColor(prop.value)};`);
+          } else if (prop.key === "intensity") {
+            this.emit(`${varName}.intensity = ${prop.value}f;`);
+          } else if (prop.key === "position" && Array.isArray(prop.value)) {
+            this.emit(`${varName}GO.transform.position = ${this.toVector3(prop.value)};`);
+          } else if (prop.key === "cast_shadow" || prop.key === "castShadow") {
+            this.emit(
+              `${varName}.shadows = ${prop.value ? "LightShadows.Soft" : "LightShadows.None"};`
+            );
+          } else if (prop.key === "angle") {
+            this.emit(`${varName}.spotAngle = ${prop.value * (180 / Math.PI)}f;`);
+          } else if (prop.key === "distance") {
+            this.emit(`${varName}.range = ${prop.value}f;`);
+          }
+        }
+        this.emit("");
+      }
+      compileCamera(camera) {
+        this.emit("// === Camera ===");
+        this.emit("var cam = Camera.main;");
+        this.emit(`cam.fieldOfView = ${this.findProp(camera.properties, "fov") || 60}f;`);
+        const pos = this.findProp(camera.properties, "position");
+        if (pos) this.emit(`cam.transform.position = ${this.toVector3(pos)};`);
+        const lookAt = this.findProp(camera.properties, "look_at") || this.findProp(camera.properties, "lookAt");
+        if (lookAt) this.emit(`cam.transform.LookAt(${this.toVector3(lookAt)});`);
+        const near = this.findProp(camera.properties, "near");
+        if (near) this.emit(`cam.nearClipPlane = ${near}f;`);
+        const far = this.findProp(camera.properties, "far");
+        if (far) this.emit(`cam.farClipPlane = ${far}f;`);
+        this.emit("");
+      }
+      compileObject(obj, parentVar) {
+        const varName = this.sanitizeName(obj.name);
+        const meshType = this.findObjProp(obj, "geometry") || this.findObjProp(obj, "mesh") || this.findObjProp(obj, "type") || "cube";
+        const isText = meshType === "text";
+        const isSparkles = meshType === "sparkles";
+        const isModel = meshType === "model" || !!this.findObjProp(obj, "model") || !!this.findObjProp(obj, "src") || !!this.findObjProp(obj, "source");
+        this.emit(`// Object: ${this.escapeStringValue(obj.name, "CSharp")}`);
+        if (isText) {
+          this.emit(
+            `var ${varName}GO = new GameObject("${this.escapeStringValue(obj.name, "CSharp")}");`
+          );
+          this.emit(`${varName}GO.transform.SetParent(${parentVar});`);
+          this.emit(`var ${varName}TM = ${varName}GO.AddComponent<TextMesh>();`);
+          const text = this.findObjProp(obj, "text");
+          if (text) this.emit(`${varName}TM.text = "${text}";`);
+          const fontSize = this.findObjProp(obj, "font_size");
+          if (fontSize) this.emit(`${varName}TM.fontSize = ${Math.round(fontSize * 100)};`);
+          const color = this.findObjProp(obj, "color");
+          if (color) this.emit(`${varName}TM.color = ${this.toColor(color)};`);
+        } else if (isModel) {
+          const src = this.findObjProp(obj, "model") || this.findObjProp(obj, "src") || this.findObjProp(obj, "source");
+          if (src) {
+            this.emit(`var ${varName}GO = Instantiate(Resources.Load<GameObject>("Models/${src}"));`);
+          } else {
+            this.emit(`// WARNING: geometry "model" without source \u2014 placeholder cube`);
+            this.emit(`var ${varName}GO = GameObject.CreatePrimitive(PrimitiveType.Cube);`);
+          }
+          this.emit(`${varName}GO.name = "${this.escapeStringValue(obj.name, "CSharp")}";`);
+          this.emit(`${varName}GO.transform.SetParent(${parentVar});`);
+        } else if (isSparkles) {
+          this.emit(
+            `// Sparkles: use ParticleSystem for "${this.escapeStringValue(obj.name, "CSharp")}"`
+          );
+          this.emit(
+            `var ${varName}GO = new GameObject("${this.escapeStringValue(obj.name, "CSharp")}");`
+          );
+          this.emit(`${varName}GO.transform.SetParent(${parentVar});`);
+          this.emit(`${varName}GO.AddComponent<ParticleSystem>();`);
+        } else {
+          const primitiveMap = {
+            cube: "PrimitiveType.Cube",
+            box: "PrimitiveType.Cube",
+            sphere: "PrimitiveType.Sphere",
+            cylinder: "PrimitiveType.Cylinder",
+            plane: "PrimitiveType.Plane",
+            capsule: "PrimitiveType.Capsule"
+          };
+          const primitive = primitiveMap[meshType] || "PrimitiveType.Cube";
+          this.emit(`var ${varName}GO = GameObject.CreatePrimitive(${primitive});`);
+          this.emit(`${varName}GO.name = "${this.escapeStringValue(obj.name, "CSharp")}";`);
+          this.emit(`${varName}GO.transform.SetParent(${parentVar});`);
+        }
+        const pos = this.findObjProp(obj, "position");
+        if (pos) this.emit(`${varName}GO.transform.localPosition = ${this.toVector3(pos)};`);
+        const rot = this.findObjProp(obj, "rotation");
+        if (rot) this.emit(`${varName}GO.transform.localEulerAngles = ${this.toVector3(rot)};`);
+        const scale = this.findObjProp(obj, "scale");
+        if (scale) this.emit(`${varName}GO.transform.localScale = ${this.toVector3(scale)};`);
+        const size = this.findObjProp(obj, "size");
+        if (size && !isText) {
+          if (Array.isArray(size)) {
+            this.emit(`${varName}GO.transform.localScale = ${this.toVector3(size)};`);
+          } else {
+            this.emit(`${varName}GO.transform.localScale = Vector3.one * ${size}f;`);
+          }
+        }
+        const material = this.findObjProp(obj, "material");
+        if (material && typeof material === "object" && !isText && !isModel) {
+          this.emit(`var ${varName}Mat = ${varName}GO.GetComponent<Renderer>().material;`);
+          const mat = material;
+          if (mat.color) this.emit(`${varName}Mat.color = ${this.toColor(mat.color)};`);
+          if (mat.roughness !== void 0)
+            this.emit(`${varName}Mat.SetFloat("_Smoothness", ${1 - mat.roughness}f);`);
+          if (mat.metalness !== void 0)
+            this.emit(`${varName}Mat.SetFloat("_Metallic", ${mat.metalness}f);`);
+          if (mat.emissive) {
+            this.emit(`${varName}Mat.EnableKeyword("_EMISSION");`);
+            this.emit(`${varName}Mat.SetColor("_EmissionColor", ${this.toColor(mat.emissive)});`);
+          }
+        }
+        if (obj.traits) {
+          for (const trait of obj.traits) {
+            if (trait.name === "collidable") {
+              this.emit(`// Collider already present from primitive`);
+            } else if (trait.name === "physics" || trait.name === "grabbable") {
+              this.emit(`var ${varName}RB = ${varName}GO.AddComponent<Rigidbody>();`);
+              if (trait.config?.mass) this.emit(`${varName}RB.mass = ${trait.config.mass}f;`);
+            } else if (trait.name === "portal") {
+              this.emit(
+                `// Portal: "${trait.config?.destination}" \u2014 implement via SceneManager.LoadScene()`
+              );
+            } else if (trait.name === "plane_detection") {
+              this.emit(`// @plane_detection \u2014 AR Foundation: ARPlaneManager`);
+              this.emit(`// ${varName}GO.AddComponent<UnityEngine.XR.ARFoundation.ARPlaneManager>();`);
+            } else if (trait.name === "mesh_detection") {
+              this.emit(`// @mesh_detection \u2014 AR Foundation: ARMeshManager`);
+            } else if (trait.name === "anchor") {
+              this.emit(`// @anchor \u2014 AR Foundation: ARAnchorManager`);
+            } else if (trait.name === "persistent_anchor" || trait.name === "shared_anchor") {
+              this.emit(
+                `// @${this.escapeStringValue(trait.name, "CSharp")} \u2014 Azure Spatial Anchors or AR Foundation`
+              );
+            } else if (trait.name === "occlusion") {
+              this.emit(`// @occlusion \u2014 AR Foundation: AROcclusionManager`);
+            } else if (trait.name === "light_estimation") {
+              this.emit(
+                `// @light_estimation \u2014 AR Foundation: ARCameraManager.requestedLightEstimation`
+              );
+            } else if (trait.name === "geospatial" || trait.name === "geospatial_anchor" || trait.name === "terrain_anchor" || trait.name === "rooftop_anchor") {
+              this.emit(
+                `// @${this.escapeStringValue(trait.name, "CSharp")} \u2014 ARCore Geospatial API`
+              );
+            } else if (trait.name === "cloth") {
+              this.emit(`var ${varName}Cloth = ${varName}GO.AddComponent<Cloth>();`);
+              if (trait.config?.stiffness)
+                this.emit(`${varName}Cloth.stretchingStiffness = ${trait.config.stiffness}f;`);
+              if (trait.config?.damping)
+                this.emit(`${varName}Cloth.damping = ${trait.config.damping}f;`);
+            } else if (trait.name === "wind") {
+              this.emit(`var ${varName}Wind = ${varName}GO.AddComponent<WindZone>();`);
+              if (trait.config?.strength)
+                this.emit(`${varName}Wind.windMain = ${trait.config.strength}f;`);
+              if (trait.config?.turbulence)
+                this.emit(`${varName}Wind.windTurbulence = ${trait.config.turbulence}f;`);
+            } else if (trait.name === "fluid" || trait.name === "soft_body" || trait.name === "rope" || trait.name === "chain" || trait.name === "buoyancy" || trait.name === "destruction") {
+              this.emit(
+                `// @${this.escapeStringValue(trait.name, "CSharp")} \u2014 custom physics: ${JSON.stringify(trait.config || {})}`
+              );
+            } else if (trait.name === "reverb_zone") {
+              this.emit(`var ${varName}Reverb = ${varName}GO.AddComponent<AudioReverbZone>();`);
+              if (trait.config?.decay_time)
+                this.emit(`${varName}Reverb.decayTime = ${trait.config.decay_time}f;`);
+            } else if (trait.name === "audio_occlusion") {
+              this.emit(`${varName}GO.AddComponent<AudioLowPassFilter>();`);
+              this.emit(`// @audio_occlusion \u2014 raycast-based low-pass filter`);
+            } else if (trait.name === "ambisonics" || trait.name === "hrtf" || trait.name === "audio_portal" || trait.name === "audio_material" || trait.name === "head_tracked_audio") {
+              this.emit(
+                `// @${this.escapeStringValue(trait.name, "CSharp")} \u2014 spatial audio: ${JSON.stringify(trait.config || {})}`
+              );
+            } else if (trait.name === "gaussian_splat" || trait.name === "nerf" || trait.name === "volumetric_video" || trait.name === "point_cloud" || trait.name === "photogrammetry") {
+              this.emit(
+                `// @${this.escapeStringValue(trait.name, "CSharp")} \u2014 volumetric renderer: ${JSON.stringify(trait.config || {})}`
+              );
+            } else if (trait.name === "eye_tracking") {
+              this.emit(`// @eye_tracking \u2014 XR Interaction Toolkit: XREyeInteractor`);
+            } else if (trait.name === "hand_tracking") {
+              this.emit(`// @hand_tracking \u2014 XR Hands: XRHandTrackingSubsystem`);
+            } else if (trait.name === "body_tracking") {
+              this.emit(`// @body_tracking \u2014 XR Body Tracking subsystem`);
+            } else if (trait.name === "face_tracking") {
+              this.emit(`// @face_tracking \u2014 AR Foundation: ARFaceManager`);
+            } else if (trait.name === "accessible") {
+              this.emit(
+                `// @accessible(role: "${trait.config?.role || "generic"}") \u2014 Unity Accessibility`
+              );
+            } else if (trait.name === "spatial_persona" || trait.name === "shareplay") {
+              this.emit(
+                `// @${this.escapeStringValue(trait.name, "CSharp")} \u2014 visionOS-specific; use Mirror/Photon for Unity multiplayer`
+              );
+            } else if (trait.name === "object_tracking") {
+              this.emit(`// @object_tracking \u2014 AR Foundation: ARTrackedObjectManager`);
+            } else if (trait.name === "scene_reconstruction") {
+              this.emit(`// @scene_reconstruction \u2014 AR Foundation: ARMeshManager`);
+            } else if (trait.name === "eye_tracked") {
+              this.emit(`// @eye_tracked \u2014 XR Interaction Toolkit: XREyeInteractor`);
+            } else if (trait.name === "eye_hand_fusion") {
+              this.emit(`// @eye_hand_fusion \u2014 combine XREyeInteractor + XRHandInteractorController`);
+            } else if (trait.name === "controlnet") {
+              const model = trait.config?.model || "canny";
+              this.emit(`// @controlnet(model: "${model}") \u2014 route to inference API or Unity Sentis`);
+            } else if (trait.name === "ai_texture_gen") {
+              const style = trait.config?.style || "photorealistic";
+              this.emit(`// @ai_texture_gen(style: "${style}") \u2014 Unity Sentis or external API`);
+            } else if (trait.name === "diffusion_realtime") {
+              this.emit(`// @diffusion_realtime \u2014 Unity Sentis real-time diffusion pipeline`);
+            } else if (trait.name === "ai_upscaling") {
+              const factor = trait.config?.factor || 2;
+              this.emit(`// @ai_upscaling(${factor}x) \u2014 Unity Sentis super-resolution model`);
+            } else if (trait.name === "ai_inpainting") {
+              this.emit(`// @ai_inpainting \u2014 Unity Sentis or API-based inpainting`);
+            } else if (trait.name === "neural_link" || trait.name === "neural_forge") {
+              this.emit(
+                `// @${this.escapeStringValue(trait.name, "CSharp")} \u2014 ${JSON.stringify(trait.config || {})}`
+              );
+            } else if (trait.name === "embedding_search" || trait.name === "ai_npc_brain" || trait.name === "vector_db") {
+              this.emit(
+                `// @${this.escapeStringValue(trait.name, "CSharp")} \u2014 AI knowledge: use external service or on-device model`
+              );
+            } else if (trait.name === "vision" || trait.name === "ai_vision") {
+              this.emit(
+                `// @${this.escapeStringValue(trait.name, "CSharp")} \u2014 Unity Barracuda / Sentis vision model`
+              );
+            } else if (trait.name === "spatial_awareness") {
+              this.emit(`// @spatial_awareness \u2014 AR Foundation scene understanding`);
+            } else if (trait.name === "neural_animation") {
+              this.emit(`// @neural_animation \u2014 Motion Matching (com.unity.animation.rigging)`);
+            } else {
+              this.emit(
+                `// @${this.escapeStringValue(trait.name, "CSharp")}: ${JSON.stringify(trait.config || {})}`
+              );
+            }
+          }
+        }
+        if (obj.children) {
+          for (const child of obj.children) {
+            this.compileObject(child, `${varName}GO.transform`);
+          }
+        }
+        this.emit("");
+      }
+      compileSpatialGroup(group, parentVar) {
+        const varName = this.sanitizeName(group.name);
+        this.emit(`// Spatial Group: ${this.escapeStringValue(group.name, "CSharp")}`);
+        this.emit(
+          `var ${varName}GO = new GameObject("${this.escapeStringValue(group.name, "CSharp")}");`
+        );
+        this.emit(`${varName}GO.transform.SetParent(${parentVar});`);
+        for (const prop of group.properties) {
+          if (prop.key === "position" && Array.isArray(prop.value)) {
+            this.emit(`${varName}GO.transform.localPosition = ${this.toVector3(prop.value)};`);
+          }
+        }
+        for (const obj of group.objects) {
+          this.compileObject(obj, `${varName}GO.transform`);
+        }
+        if (group.groups) {
+          for (const sub of group.groups) {
+            this.compileSpatialGroup(sub, `${varName}GO.transform`);
+          }
+        }
+        this.emit("");
+      }
+      compileAudio(audio) {
+        const varName = this.sanitizeName(audio.name);
+        this.emit(`// Audio: ${this.escapeStringValue(audio.name, "CSharp")}`);
+        this.emit(
+          `var ${varName}GO = new GameObject("${this.escapeStringValue(audio.name, "CSharp")}");`
+        );
+        this.emit(`${varName}GO.transform.SetParent(transform);`);
+        this.emit(`var ${varName}AS = ${varName}GO.AddComponent<AudioSource>();`);
+        for (const prop of audio.properties) {
+          if (prop.key === "src" || prop.key === "source") {
+            this.emit(`${varName}AS.clip = Resources.Load<AudioClip>("Audio/${prop.value}");`);
+          } else if (prop.key === "volume") {
+            this.emit(`${varName}AS.volume = ${prop.value}f;`);
+          } else if (prop.key === "loop") {
+            this.emit(`${varName}AS.loop = ${prop.value};`);
+          } else if (prop.key === "spatial") {
+            this.emit(`${varName}AS.spatialBlend = ${prop.value ? "1.0f" : "0.0f"};`);
+          } else if (prop.key === "position" && Array.isArray(prop.value)) {
+            this.emit(`${varName}GO.transform.position = ${this.toVector3(prop.value)};`);
+          } else if (prop.key === "distance") {
+            this.emit(`${varName}AS.maxDistance = ${prop.value}f;`);
+          }
+        }
+        this.emit(`${varName}AS.Play();`);
+        this.emit("");
+      }
+      compileZone(zone) {
+        const varName = this.sanitizeName(zone.name);
+        this.emit(`// Zone: ${this.escapeStringValue(zone.name, "CSharp")}`);
+        this.emit(
+          `var ${varName}GO = new GameObject("${this.escapeStringValue(zone.name, "CSharp")}");`
+        );
+        this.emit(`${varName}GO.transform.SetParent(transform);`);
+        for (const prop of zone.properties) {
+          if (prop.key === "position" && Array.isArray(prop.value)) {
+            this.emit(`${varName}GO.transform.position = ${this.toVector3(prop.value)};`);
+          } else if (prop.key === "shape" && prop.value === "box") {
+            this.emit(`var ${varName}Col = ${varName}GO.AddComponent<BoxCollider>();`);
+            this.emit(`${varName}Col.isTrigger = true;`);
+          } else if (prop.key === "shape" && prop.value === "sphere") {
+            this.emit(`var ${varName}Col = ${varName}GO.AddComponent<SphereCollider>();`);
+            this.emit(`${varName}Col.isTrigger = true;`);
+          } else if (prop.key === "size" && Array.isArray(prop.value)) {
+            this.emit(
+              `${varName}GO.GetComponent<Collider>().bounds.size == ${this.toVector3(prop.value)}; // Set via scale`
+            );
+          } else if (prop.key === "radius") {
+            this.emit(`${varName}GO.GetComponent<SphereCollider>().radius = ${prop.value}f;`);
+          }
+        }
+        if (zone.handlers?.length) {
+          this.emit(
+            `// Zone handlers: ${zone.handlers.map((h) => h.event).join(", ")} \u2014 implement via OnTriggerEnter/Exit`
+          );
+        }
+        this.emit("");
+      }
+      compileTimeline(timeline) {
+        const varName = this.sanitizeName(timeline.name);
+        this.emit(`private IEnumerator ${varName}Routine()`);
+        this.emit("{");
+        this.indentLevel++;
+        let lastTime = 0;
+        for (const entry of timeline.entries) {
+          const delay = entry.time - lastTime;
+          if (delay > 0) {
+            this.emit(`yield return new WaitForSeconds(${delay}f);`);
+          }
+          if (entry.action.kind === "animate") {
+            this.emit(`// Animate "${entry.action.target}" \u2014 use DOTween or AnimationCurve`);
+            const props = entry.action.properties;
+            for (const [key, value] of Object.entries(props)) {
+              this.emit(`// ${key}: ${JSON.stringify(value)}`);
+            }
+          } else if (entry.action.kind === "emit") {
+            this.emit(`// Emit event: "${entry.action.event}"`);
+          } else if (entry.action.kind === "call") {
+            this.emit(`// Call: ${entry.action.method}(${entry.action.args?.join(", ") || ""})`);
+          }
+          lastTime = entry.time;
+        }
+        if (timeline.loop) {
+          this.emit(`StartCoroutine(${varName}Routine()); // loop`);
+        }
+        this.indentLevel--;
+        this.emit("}");
+        this.emit("");
+      }
+      compileEffects(effects) {
+        this.emit("// === Post-Processing (configure via URP Volume) ===");
+        for (const effect of effects.effects) {
+          this.emit(`// Effect: ${effect.effectType} \u2014 ${JSON.stringify(effect.properties)}`);
+        }
+        this.emit("");
+      }
+      compileTransition(tr) {
+        const varName = this.sanitizeName(tr.name);
+        this.emit(`public void ${varName}()`);
+        this.emit("{");
+        this.indentLevel++;
+        for (const prop of tr.properties) {
+          if (prop.key === "target") {
+            this.emit(`// Load scene: "${prop.value}"`);
+            this.emit(`UnityEngine.SceneManagement.SceneManager.LoadScene("${prop.value}");`);
+          } else if (prop.key === "effect") {
+            this.emit(`// Transition effect: ${prop.value}`);
+          } else if (prop.key === "duration") {
+            this.emit(`// Duration: ${prop.value}s`);
+          }
+        }
+        this.indentLevel--;
+        this.emit("}");
+        this.emit("");
+      }
+      compileUI(ui) {
+        this.emit("// === UI Setup ===");
+        this.emit("// Create Canvas for HUD overlay");
+        this.emit('var canvasGO = new GameObject("HoloUI");');
+        this.emit("canvasGO.transform.SetParent(transform);");
+        this.emit("var canvas = canvasGO.AddComponent<Canvas>();");
+        this.emit("canvas.renderMode = RenderMode.ScreenSpaceOverlay;");
+        this.emit("canvasGO.AddComponent<CanvasScaler>();");
+        this.emit("");
+        for (const el of ui.elements) {
+          const varName = this.sanitizeName(el.name);
+          const elType = el.properties.find((p) => p.key === "type")?.value;
+          this.emit(
+            `// UI Element: ${this.escapeStringValue(el.name, "CSharp")} (${elType})`
+          );
+          this.emit(
+            `var ${varName}GO = new GameObject("${this.escapeStringValue(el.name, "CSharp")}");`
+          );
+          this.emit(`${varName}GO.transform.SetParent(canvasGO.transform);`);
+          if (elType === "text") {
+            this.emit(`var ${varName}Text = ${varName}GO.AddComponent<Text>();`);
+            const text = el.properties.find((p) => p.key === "text")?.value;
+            if (text) this.emit(`${varName}Text.text = "${text}";`);
+          } else if (elType === "progress") {
+            this.emit(`var ${varName}Slider = ${varName}GO.AddComponent<Slider>();`);
+          }
+          this.emit("");
+        }
+      }
+      // ─── Helpers ───────────────────────────────────────────────────────────
+      emit(line) {
+        this.lines.push(this.options.indent.repeat(this.indentLevel) + line);
+      }
+      sanitizeName(name) {
+        return name.replace(/[^a-zA-Z0-9_]/g, "_");
+      }
+      toVector3(arr) {
+        if (Array.isArray(arr) && arr.length >= 3) {
+          return `new Vector3(${arr[0]}f, ${arr[1]}f, ${arr[2]}f)`;
+        }
+        if (Array.isArray(arr) && arr.length === 2) {
+          return `new Vector2(${arr[0]}f, ${arr[1]}f)`;
+        }
+        return `new Vector3(${arr}f, ${arr}f, ${arr}f)`;
+      }
+      toColor(value) {
+        if (typeof value === "string" && value.startsWith("#")) {
+          const hex = value.slice(1);
+          const r = parseInt(hex.substring(0, 2), 16) / 255;
+          const g = parseInt(hex.substring(2, 4), 16) / 255;
+          const b = parseInt(hex.substring(4, 6), 16) / 255;
+          return `new Color(${r.toFixed(3)}f, ${g.toFixed(3)}f, ${b.toFixed(3)}f)`;
+        }
+        return `Color.white`;
+      }
+      toCSharpType(value) {
+        if (typeof value === "number") return Number.isInteger(value) ? "int" : "float";
+        if (typeof value === "boolean") return "bool";
+        if (typeof value === "string") return "string";
+        if (Array.isArray(value)) return "object[]";
+        return "object";
+      }
+      toCSharpValue(value) {
+        if (typeof value === "number") return Number.isInteger(value) ? `${value}` : `${value}f`;
+        if (typeof value === "boolean") return value ? "true" : "false";
+        if (typeof value === "string") return `"${this.escapeStringValue(value, "CSharp")}"`;
+        if (value === null) return "null";
+        return "null";
+      }
+      findProp(props, key) {
+        return props?.find((p) => p.key === key)?.value;
+      }
+      findObjProp(obj, key) {
+        return obj.properties?.find((p) => p.key === key)?.value;
+      }
+    };
+  }
+});
+
+exports.UnityCompiler_exports = UnityCompiler_exports;
+exports.init_UnityCompiler = init_UnityCompiler;
+//# sourceMappingURL=chunk-25IQCHTO.cjs.map
+//# sourceMappingURL=chunk-25IQCHTO.cjs.map