@holoscript/core 7.0.0 → 8.0.1

package/dist/chunk-5NWINHR5.cjs

@@ -0,0 +1,689 @@
+'use strict';
+
+var chunkHKEXJUWS_cjs = require('./chunk-HKEXJUWS.cjs');
+var chunkKKP7JKN4_cjs = require('./chunk-KKP7JKN4.cjs');
+var chunkHCCQLAA4_cjs = require('./chunk-HCCQLAA4.cjs');
+var ans = require('@holoscript/core-types/ans');
+
+// src/compiler/godot-acoustic-bus.ts
+function compileAcousticTrait(traitName, config, varName) {
+  const bus = `${varName}_acoustic_bus`;
+  const effects = [];
+  const body = [];
+  if (traitName === "audio_material") {
+    const preset = String(config.preset || "default");
+    const room = preset === "metal" ? 0.85 : preset === "glass" ? 0.35 : 0.6;
+    const damping = preset === "metal" ? 0.1 : preset === "glass" ? 0.55 : 0.3;
+    body.push(`var ${varName}_reverb = AudioEffectReverb.new()`);
+    body.push(`${varName}_reverb.room_size = ${room}`);
+    body.push(`${varName}_reverb.damping = ${damping}`);
+    body.push(`AudioServer.add_bus_effect(${bus}_idx, ${varName}_reverb)`);
+    effects.push("AudioEffectReverb");
+  } else if (traitName === "audio_occlusion") {
+    const attenuation = Math.min(1, Math.max(0, num(config.attenuation, 0.3)));
+    const cutoff = Math.round(2e3 - attenuation * 1500);
+    body.push(`var ${varName}_lowpass = AudioEffectLowPassFilter.new()`);
+    body.push(`${varName}_lowpass.cutoff_hz = ${cutoff}`);
+    body.push(`AudioServer.add_bus_effect(${bus}_idx, ${varName}_lowpass)`);
+    effects.push("AudioEffectLowPassFilter");
+  } else if (traitName === "audio_portal") {
+    const wet = Math.min(1, Math.max(0, num(config.wet, 0.5)));
+    body.push(`var ${varName}_portal = AudioEffectReverb.new()`);
+    body.push(`${varName}_portal.wet = ${wet}`);
+    body.push(`AudioServer.add_bus_effect(${bus}_idx, ${varName}_portal)`);
+    effects.push("AudioEffectReverb");
+  } else {
+    return null;
+  }
+  const lines = [
+    `# @${traitName} \u2014 real Godot acoustic bus (E-G16)`,
+    `AudioServer.add_bus()`,
+    `var ${bus}_idx = AudioServer.bus_count - 1`,
+    `AudioServer.set_bus_name(${bus}_idx, "${bus}")`,
+    ...body
+  ];
+  return { lines, effects, busName: bus };
+}
+var num;
+var init_godot_acoustic_bus = chunkHCCQLAA4_cjs.__esm({
+  "src/compiler/godot-acoustic-bus.ts"() {
+    num = (v, fallback) => typeof v === "number" && Number.isFinite(v) ? v : fallback;
+  }
+});
+
+// src/compiler/GodotCompiler.ts
+var GodotCompiler_exports = {};
+chunkHCCQLAA4_cjs.__export(GodotCompiler_exports, {
+  GodotCompiler: () => exports.GodotCompiler
+});
+exports.GodotCompiler = void 0;
+var init_GodotCompiler = chunkHCCQLAA4_cjs.__esm({
+  "src/compiler/GodotCompiler.ts"() {
+    chunkKKP7JKN4_cjs.init_CompilerBase();
+    init_godot_acoustic_bus();
+    chunkHKEXJUWS_cjs.init_DomainBlockCompilerMixin();
+    exports.GodotCompiler = class extends chunkKKP7JKN4_cjs.CompilerBase {
+      constructor(options = {}) {
+        super();
+        this.compilerName = "GodotCompiler";
+        this.lines = [];
+        this.indentLevel = 0;
+        this.options = {
+          className: options.className || "GeneratedScene",
+          indent: options.indent || "	",
+          godotVersion: options.godotVersion || "4.3",
+          provenanceHash: options.provenanceHash ?? ""
+        };
+      }
+      getRequiredCapability() {
+        return ans.ANSCapabilityPath.GODOT;
+      }
+      compile(composition, agentToken, outputPath) {
+        this.validateCompilerAccess(agentToken, outputPath);
+        this.lines = [];
+        this.indentLevel = 0;
+        this.emit(`# Auto-generated by HoloScript GodotCompiler`);
+        this.emit(
+          `# Source: composition "${this.escapeStringValue(composition.name, "GDScript")}"`
+        );
+        this.emit(`# Target: Godot ${this.options.godotVersion}`);
+        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("extends Node3D");
+        this.emit(`class_name ${this.options.className}`);
+        this.emit("");
+        if (composition.state) {
+          this.emit("# === State ===");
+          for (const prop of composition.state.properties) {
+            const gdVal = this.toGDScriptValue(prop.value);
+            this.emit(`var ${this.escapeStringValue(prop.key, "GDScript")} = ${gdVal}`);
+          }
+          this.emit("");
+        }
+        this.emit("func _ready():");
+        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, "self");
+          }
+        }
+        if (composition.spatialGroups) {
+          for (const group of composition.spatialGroups) {
+            this.compileSpatialGroup(group, "self");
+          }
+        }
+        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(`_play_${this.sanitizeName(tl.name)}()`);
+            }
+          }
+        }
+        if (composition.ui) {
+          this.compileUI(composition.ui);
+        }
+        this.indentLevel--;
+        this.emit("");
+        if (composition.timelines) {
+          for (const tl of composition.timelines) {
+            this.compileTimeline(tl);
+          }
+        }
+        if (composition.transitions) {
+          for (const tr of composition.transitions) {
+            this.compileTransition(tr);
+          }
+        }
+        if (composition.effects) {
+          this.compileEffects(composition.effects);
+        }
+        this.compileGodotDomainBlocks(composition);
+        return this.lines.join("\n");
+      }
+      compileGodotDomainBlocks(composition) {
+        const domainBlocks = composition.domainBlocks ?? [];
+        if (domainBlocks.length === 0) return;
+        this.emit("");
+        this.emit("# === v4.2 Domain Blocks ===");
+        let blockIdx = 0;
+        const compiled = chunkHKEXJUWS_cjs.compileDomainBlocks(
+          domainBlocks,
+          {
+            material: (block) => {
+              const mat = chunkHKEXJUWS_cjs.compileMaterialBlock(block);
+              return chunkHKEXJUWS_cjs.materialToGodot(mat, `db${blockIdx++}`);
+            },
+            physics: (block) => {
+              const phys = chunkHKEXJUWS_cjs.compilePhysicsBlock(block);
+              return chunkHKEXJUWS_cjs.physicsToGodot(phys, `db${blockIdx++}`);
+            },
+            vfx: (block) => {
+              const ps = chunkHKEXJUWS_cjs.compileParticleBlock(block);
+              return chunkHKEXJUWS_cjs.particlesToGodot(ps, `db${blockIdx++}`);
+            },
+            postfx: (block) => {
+              const pp = chunkHKEXJUWS_cjs.compilePostProcessingBlock(block);
+              return chunkHKEXJUWS_cjs.postProcessingToGodot(pp);
+            },
+            audio: (block) => {
+              const audio = chunkHKEXJUWS_cjs.compileAudioSourceBlock(block);
+              return chunkHKEXJUWS_cjs.audioSourceToGodot(audio, `db${blockIdx++}`);
+            },
+            weather: (block) => {
+              const weather = chunkHKEXJUWS_cjs.compileWeatherBlock(block);
+              return chunkHKEXJUWS_cjs.weatherToGodot(weather);
+            },
+            narrative: (block) => {
+              const narr = chunkHKEXJUWS_cjs.compileNarrativeBlock(block);
+              return chunkHKEXJUWS_cjs.narrativeToGodot(narr);
+            },
+            payment: (block) => {
+              const pay = chunkHKEXJUWS_cjs.compilePaymentBlock(block);
+              return chunkHKEXJUWS_cjs.paymentToGodot(pay);
+            },
+            healthcare: (block) => {
+              const h = chunkHKEXJUWS_cjs.compileHealthcareBlock(block);
+              return chunkHKEXJUWS_cjs.healthcareToGodot(h);
+            },
+            robotics: (block) => {
+              const r = chunkHKEXJUWS_cjs.compileRoboticsBlock(block);
+              return chunkHKEXJUWS_cjs.roboticsToGodot(r);
+            },
+            iot: (block) => chunkHKEXJUWS_cjs.iotToGodot(chunkHKEXJUWS_cjs.compileIoTBlock(block)),
+            dataviz: (block) => chunkHKEXJUWS_cjs.datavizToGodot(chunkHKEXJUWS_cjs.compileDataVizBlock(block)),
+            education: (block) => chunkHKEXJUWS_cjs.educationToGodot(chunkHKEXJUWS_cjs.compileEducationBlock(block)),
+            music: (block) => chunkHKEXJUWS_cjs.musicToGodot(chunkHKEXJUWS_cjs.compileMusicBlock(block)),
+            architecture: (block) => chunkHKEXJUWS_cjs.architectureToGodot(chunkHKEXJUWS_cjs.compileArchitectureBlock(block)),
+            web3: (block) => chunkHKEXJUWS_cjs.web3ToGodot(chunkHKEXJUWS_cjs.compileWeb3Block(block)),
+            procedural: (block) => chunkHKEXJUWS_cjs.proceduralToGodot(chunkHKEXJUWS_cjs.compileProceduralBlock(block)),
+            rendering: (block) => chunkHKEXJUWS_cjs.renderingToGodot(chunkHKEXJUWS_cjs.compileRenderingBlock(block)),
+            navigation: (block) => chunkHKEXJUWS_cjs.navigationToGodot(chunkHKEXJUWS_cjs.compileNavigationBlock(block)),
+            input: (block) => chunkHKEXJUWS_cjs.inputToGodot(chunkHKEXJUWS_cjs.compileInputBlock(block))
+          },
+          (block) => `# Domain block: ${block.domain}/${block.keyword} "${this.escapeStringValue(block.name, "GDScript")}"`
+        );
+        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(`var env = WorldEnvironment.new()`);
+            this.emit(`env.environment = Environment.new()`);
+            this.emit(`env.environment.background_mode = Environment.BG_SKY`);
+            this.emit(`add_child(env)`);
+          } else if (prop.key === "fog" && typeof prop.value === "object") {
+            const fog = prop.value;
+            this.emit(`# Fog settings`);
+            if (fog.color) this.emit(`# fog_color: ${fog.color}`);
+            if (fog.near !== void 0) this.emit(`# fog_near: ${fog.near}`);
+            if (fog.far !== void 0) this.emit(`# fog_far: ${fog.far}`);
+          } else if (prop.key === "ambient_light") {
+            this.emit(`# Ambient light intensity: ${prop.value}`);
+          }
+        }
+        this.emit("");
+      }
+      compileLight(light) {
+        const varName = this.sanitizeName(light.name);
+        this.emit(`# Light: ${this.escapeStringValue(light.name, "GDScript")}`);
+        const typeMap = {
+          directional: "DirectionalLight3D",
+          point: "OmniLight3D",
+          spot: "SpotLight3D"
+        };
+        const gdType = typeMap[light.lightType] || "DirectionalLight3D";
+        this.emit(`var ${varName} = ${gdType}.new()`);
+        this.emit(`${varName}.name = "${this.escapeStringValue(light.name, "GDScript")}"`);
+        for (const prop of light.properties) {
+          if (prop.key === "color") {
+            this.emit(`${varName}.light_color = ${this.toColor(prop.value)}`);
+          } else if (prop.key === "intensity") {
+            this.emit(`${varName}.light_energy = ${prop.value}`);
+          } else if (prop.key === "position" && Array.isArray(prop.value)) {
+            this.emit(`${varName}.position = ${this.toVector3(prop.value)}`);
+          } else if (prop.key === "cast_shadow" || prop.key === "castShadow") {
+            this.emit(`${varName}.shadow_enabled = ${prop.value}`);
+          } else if (prop.key === "distance") {
+            this.emit(`${varName}.omni_range = ${prop.value}`);
+          }
+        }
+        this.emit(`add_child(${varName})`);
+        this.emit("");
+      }
+      compileCamera(camera) {
+        this.emit("# === Camera ===");
+        this.emit("var cam = Camera3D.new()");
+        const fov = this.findProp(camera.properties, "fov");
+        if (fov) this.emit(`cam.fov = ${fov}`);
+        const pos = this.findProp(camera.properties, "position");
+        if (pos) this.emit(`cam.position = ${this.toVector3(pos)}`);
+        const lookAt = this.findProp(camera.properties, "look_at") || this.findProp(camera.properties, "lookAt");
+        if (lookAt) this.emit(`cam.look_at(${this.toVector3(lookAt)})`);
+        const near = this.findProp(camera.properties, "near");
+        if (near) this.emit(`cam.near = ${near}`);
+        const far = this.findProp(camera.properties, "far");
+        if (far) this.emit(`cam.far = ${far}`);
+        this.emit("cam.current = true");
+        this.emit("add_child(cam)");
+        this.emit("");
+      }
+      compileObject(obj, parentVar) {
+        const varName = this.sanitizeName(obj.name);
+        const meshType = this.findObjProp(obj, "mesh") || this.findObjProp(obj, "type") || "cube";
+        const isText = meshType === "text";
+        const isModel = !!this.findObjProp(obj, "model") || !!this.findObjProp(obj, "src");
+        const isSparkles = meshType === "sparkles";
+        const isLight = ["directional", "point", "spot", "hemisphere", "ambient", "area"].includes(
+          meshType
+        );
+        this.emit(`# Object: ${this.escapeStringValue(obj.name, "GDScript")}`);
+        if (isLight) {
+          const lightMap = {
+            directional: "DirectionalLight3D",
+            point: "OmniLight3D",
+            spot: "SpotLight3D"
+          };
+          this.emit(`var ${varName} = ${lightMap[meshType] || "DirectionalLight3D"}.new()`);
+        } else if (isText) {
+          this.emit(`var ${varName} = Label3D.new()`);
+          const text = this.findObjProp(obj, "text");
+          if (text) this.emit(`${varName}.text = "${text}"`);
+          const fontSize = this.findObjProp(obj, "font_size");
+          if (fontSize) this.emit(`${varName}.font_size = ${Math.round(fontSize * 100)}`);
+          const color = this.findObjProp(obj, "color");
+          if (color) this.emit(`${varName}.modulate = ${this.toColor(color)}`);
+        } else if (isModel) {
+          const src = this.findObjProp(obj, "model") || this.findObjProp(obj, "src");
+          this.emit(`var ${varName} = load("res://models/${src}.glb").instantiate()`);
+        } else if (isSparkles) {
+          this.emit(`var ${varName} = GPUParticles3D.new()`);
+        } else {
+          const hasPhysics2 = obj.traits?.some((t) => t.name === "physics" || t.name === "grabbable");
+          if (hasPhysics2) {
+            this.emit(`var ${varName}_body = RigidBody3D.new()`);
+            this.emit(
+              `${varName}_body.name = "${this.escapeStringValue(obj.name, "GDScript")}"`
+            );
+          }
+          this.emit(`var ${varName} = MeshInstance3D.new()`);
+          const meshMap = {
+            sphere: "SphereMesh",
+            box: "BoxMesh",
+            cube: "BoxMesh",
+            cylinder: "CylinderMesh",
+            cone: "CylinderMesh",
+            plane: "PlaneMesh",
+            torus: "TorusMesh",
+            capsule: "CapsuleMesh"
+          };
+          const gdMesh = meshMap[meshType] || "BoxMesh";
+          this.emit(`${varName}.mesh = ${gdMesh}.new()`);
+          const size = this.findObjProp(obj, "size");
+          if (size && gdMesh === "BoxMesh" && Array.isArray(size)) {
+            this.emit(`${varName}.mesh.size = ${this.toVector3(size)}`);
+          } else if (typeof size === "number" && gdMesh === "PlaneMesh") {
+            this.emit(`${varName}.mesh.size = Vector2(${size}, ${size})`);
+          }
+          const material = this.findObjProp(obj, "material");
+          if (material && typeof material === "object") {
+            const mat = material;
+            this.emit(`var ${varName}_mat = StandardMaterial3D.new()`);
+            if (mat.color) this.emit(`${varName}_mat.albedo_color = ${this.toColor(mat.color)}`);
+            if (mat.roughness !== void 0) this.emit(`${varName}_mat.roughness = ${mat.roughness}`);
+            if (mat.metalness !== void 0) this.emit(`${varName}_mat.metallic = ${mat.metalness}`);
+            if (mat.emissive) {
+              this.emit(`${varName}_mat.emission_enabled = true`);
+              this.emit(`${varName}_mat.emission = ${this.toColor(mat.emissive)}`);
+            }
+            if (mat.transmission) {
+              this.emit(`${varName}_mat.transparency = BaseMaterial3D.TRANSPARENCY_ALPHA`);
+            }
+            this.emit(`${varName}.material_override = ${varName}_mat`);
+          }
+          const hasCollider = obj.traits?.some(
+            (t) => t.name === "collidable" || t.name === "physics" || t.name === "grabbable"
+          );
+          if (hasCollider && !hasPhysics2) {
+            this.emit(`var ${varName}_static = StaticBody3D.new()`);
+            this.emit(`var ${varName}_shape = CollisionShape3D.new()`);
+            this.emit(`${varName}_shape.shape = ${varName}.mesh.create_convex_shape()`);
+            this.emit(`${varName}_static.add_child(${varName}_shape)`);
+            this.emit(`${varName}_static.add_child(${varName})`);
+          }
+          if (hasPhysics2) {
+            this.emit(`var ${varName}_shape = CollisionShape3D.new()`);
+            this.emit(`${varName}_shape.shape = ${varName}.mesh.create_convex_shape()`);
+            this.emit(`${varName}_body.add_child(${varName}_shape)`);
+            this.emit(`${varName}_body.add_child(${varName})`);
+          }
+        }
+        this.emit(`${varName}.name = "${this.escapeStringValue(obj.name, "GDScript")}"`);
+        const pos = this.findObjProp(obj, "position");
+        if (pos) this.emit(`${varName}.position = ${this.toVector3(pos)}`);
+        const rot = this.findObjProp(obj, "rotation");
+        if (rot && Array.isArray(rot)) {
+          this.emit(`${varName}.rotation_degrees = ${this.toVector3(rot)}`);
+        }
+        const scale = this.findObjProp(obj, "scale");
+        if (scale) this.emit(`${varName}.scale = ${this.toVector3(scale)}`);
+        const hasPhysics = obj.traits?.some((t) => t.name === "physics" || t.name === "grabbable");
+        if (hasPhysics) {
+          this.emit(`${parentVar}.add_child(${varName}_body)`);
+        } else {
+          this.emit(`${parentVar}.add_child(${varName})`);
+        }
+        if (obj.traits) {
+          for (const trait of obj.traits) {
+            const tn = trait.name;
+            if (tn === "collidable" || tn === "physics" || tn === "grabbable") continue;
+            if (tn === "plane_detection") {
+              this.emit(`# @plane_detection \u2014 use XRServer plane detection`);
+            } else if (tn === "mesh_detection") {
+              this.emit(`# @mesh_detection \u2014 use XRServer mesh tracking`);
+            } else if (tn === "anchor" || tn === "persistent_anchor" || tn === "shared_anchor") {
+              this.emit(`# @${tn} \u2014 XRAnchor3D`);
+            } else if (tn === "occlusion") {
+              this.emit(`# @occlusion \u2014 Environment3D occlusion`);
+            } else if (tn === "light_estimation") {
+              this.emit(`# @light_estimation \u2014 XR light estimation`);
+            } else if (tn === "cloth") {
+              this.emit(`var ${varName}_soft = SoftBody3D.new()`);
+              this.emit(
+                `${varName}_soft.name = "${this.escapeStringValue(obj.name, "GDScript")}_cloth"`
+              );
+              this.emit(`# @cloth \u2014 configure SoftBody3D stiffness/damping`);
+            } else if (tn === "wind") {
+              this.emit(`# @wind \u2014 use GPUParticles3D attractor or custom force`);
+            } else if (tn === "fluid") {
+              this.emit(`# @fluid \u2014 custom SPH/particle fluid simulation`);
+            } else if (tn === "destruction") {
+              this.emit(`# @destruction \u2014 pre-fractured mesh swap on impact`);
+            } else if (tn === "rope" || tn === "chain") {
+              this.emit(`# @${tn} \u2014 use PinJoint3D chain or custom solver`);
+            } else if (tn === "reverb_zone") {
+              this.emit(`var ${varName}_reverb = AudioEffectReverb.new()`);
+              this.emit(`# @reverb_zone \u2014 add to AudioBus`);
+            } else if (tn === "audio_material" || tn === "audio_occlusion" || tn === "audio_portal") {
+              const acoustic = compileAcousticTrait(tn, trait.config || {}, varName);
+              if (acoustic) {
+                for (const line of acoustic.lines) this.emit(line);
+              }
+            } else if (tn === "ambisonics" || tn === "hrtf" || tn === "head_tracked_audio") {
+              this.emit(`# @${tn} \u2014 spatial audio: ${JSON.stringify(trait.config || {})}`);
+            } else if (tn === "gaussian_splat" || tn === "nerf" || tn === "volumetric_video" || tn === "point_cloud" || tn === "photogrammetry") {
+              this.emit(`# @${tn} \u2014 volumetric renderer: ${JSON.stringify(trait.config || {})}`);
+            } else if (tn === "accessible" || tn === "alt_text" || tn === "screen_reader" || tn === "high_contrast" || tn === "motion_reduced" || tn === "magnifiable") {
+              this.emit(`# @${tn} \u2014 accessibility: ${JSON.stringify(trait.config || {})}`);
+            } else if (tn === "eye_tracking" || tn === "hand_tracking" || tn === "body_tracking" || tn === "face_tracking" || tn === "controller") {
+              this.emit(`# @${tn} \u2014 XR input: ${JSON.stringify(trait.config || {})}`);
+            } else if (tn === "spatial_persona") {
+              this.emit(`# @spatial_persona \u2014 visionOS-specific; use custom avatar scene for Godot`);
+            } else if (tn === "shareplay") {
+              this.emit(`# @shareplay \u2014 multiplayer via ENetMultiplayerPeer or WebSocketPeer`);
+            } else if (tn === "object_tracking") {
+              this.emit(`# @object_tracking \u2014 use XRTracker or custom vision-based tracker`);
+            } else if (tn === "scene_reconstruction") {
+              this.emit(`# @scene_reconstruction \u2014 use XRServer environment mesh`);
+            } else if (tn === "eye_tracked" || tn === "eye_hand_fusion") {
+              this.emit(`# @${tn} \u2014 use XRPositionalTracker for eye/hand data`);
+            } else if (tn === "controlnet" || tn === "ai_texture_gen" || tn === "diffusion_realtime" || tn === "ai_upscaling" || tn === "ai_inpainting") {
+              this.emit(`# @${tn} \u2014 AI generation: route to external inference or GDExtension`);
+            } else if (tn === "neural_link" || tn === "neural_forge") {
+              this.emit(`# @${tn} \u2014 neural interface: ${JSON.stringify(trait.config || {})}`);
+            } else if (tn === "embedding_search" || tn === "ai_npc_brain" || tn === "vector_db") {
+              this.emit(`# @${tn} \u2014 knowledge/AI: integrate via HTTP or GDExtension`);
+            } else if (tn === "vision" || tn === "ai_vision" || tn === "spatial_awareness") {
+              this.emit(`# @${tn} \u2014 computer vision: use OpenCV GDExtension or XRServer`);
+            } else if (tn === "neural_animation") {
+              this.emit(`# @neural_animation \u2014 motion matching via AnimationTree + custom solver`);
+            } else {
+              this.emit(`# @${tn}: ${JSON.stringify(trait.config || {})}`);
+            }
+          }
+        }
+        if (obj.children) {
+          for (const child of obj.children) {
+            this.compileObject(child, varName);
+          }
+        }
+        this.emit("");
+      }
+      compileSpatialGroup(group, parentVar) {
+        const varName = this.sanitizeName(group.name);
+        this.emit(`# Spatial Group: ${this.escapeStringValue(group.name, "GDScript")}`);
+        this.emit(`var ${varName} = Node3D.new()`);
+        this.emit(`${varName}.name = "${this.escapeStringValue(group.name, "GDScript")}"`);
+        for (const prop of group.properties) {
+          if (prop.key === "position" && Array.isArray(prop.value)) {
+            this.emit(`${varName}.position = ${this.toVector3(prop.value)}`);
+          }
+        }
+        this.emit(`${parentVar}.add_child(${varName})`);
+        for (const obj of group.objects) {
+          this.compileObject(obj, varName);
+        }
+        if (group.groups) {
+          for (const sub of group.groups) {
+            this.compileSpatialGroup(sub, varName);
+          }
+        }
+        this.emit("");
+      }
+      compileAudio(audio) {
+        const varName = this.sanitizeName(audio.name);
+        const spatial = audio.properties.find((p) => p.key === "spatial")?.value;
+        this.emit(`# Audio: ${this.escapeStringValue(audio.name, "GDScript")}`);
+        if (spatial) {
+          this.emit(`var ${varName} = AudioStreamPlayer3D.new()`);
+        } else {
+          this.emit(`var ${varName} = AudioStreamPlayer.new()`);
+        }
+        this.emit(`${varName}.name = "${this.escapeStringValue(audio.name, "GDScript")}"`);
+        for (const prop of audio.properties) {
+          if (prop.key === "src" || prop.key === "source") {
+            this.emit(`${varName}.stream = load("res://audio/${prop.value}")`);
+          } else if (prop.key === "volume") {
+            this.emit(`${varName}.volume_db = linear_to_db(${prop.value})`);
+          } else if (prop.key === "position" && Array.isArray(prop.value)) {
+            this.emit(`${varName}.position = ${this.toVector3(prop.value)}`);
+          } else if (prop.key === "distance") {
+            this.emit(`${varName}.max_distance = ${prop.value}`);
+          }
+        }
+        const loop = audio.properties.find((p) => p.key === "loop")?.value;
+        this.emit(`add_child(${varName})`);
+        this.emit(`${varName}.play()`);
+        if (loop) {
+          this.emit(`${varName}.finished.connect(func(): ${varName}.play())`);
+        }
+        this.emit("");
+      }
+      compileZone(zone) {
+        const varName = this.sanitizeName(zone.name);
+        this.emit(`# Zone: ${this.escapeStringValue(zone.name, "GDScript")}`);
+        this.emit(`var ${varName} = Area3D.new()`);
+        this.emit(`${varName}.name = "${this.escapeStringValue(zone.name, "GDScript")}"`);
+        const shape = zone.properties.find((p) => p.key === "shape")?.value;
+        this.emit(`var ${varName}_shape = CollisionShape3D.new()`);
+        if (shape === "box") {
+          this.emit(`${varName}_shape.shape = BoxShape3D.new()`);
+          const size = zone.properties.find((p) => p.key === "size")?.value;
+          if (size && Array.isArray(size)) {
+            this.emit(`${varName}_shape.shape.size = ${this.toVector3(size)}`);
+          }
+        } else if (shape === "sphere") {
+          this.emit(`${varName}_shape.shape = SphereShape3D.new()`);
+          const radius = zone.properties.find((p) => p.key === "radius")?.value;
+          if (radius) this.emit(`${varName}_shape.shape.radius = ${radius}`);
+        }
+        this.emit(`${varName}.add_child(${varName}_shape)`);
+        const pos = zone.properties.find((p) => p.key === "position")?.value;
+        if (pos) this.emit(`${varName}.position = ${this.toVector3(pos)}`);
+        for (const handler of zone.handlers) {
+          if (handler.event === "on_enter") {
+            this.emit(
+              `${varName}.body_entered.connect(func(body): print("${this.escapeStringValue(zone.name, "GDScript")}: enter"))`
+            );
+          } else if (handler.event === "on_exit") {
+            this.emit(
+              `${varName}.body_exited.connect(func(body): print("${this.escapeStringValue(zone.name, "GDScript")}: exit"))`
+            );
+          }
+        }
+        this.emit(`add_child(${varName})`);
+        this.emit("");
+      }
+      compileTimeline(tl) {
+        const varName = this.sanitizeName(tl.name);
+        this.emit(`func _play_${varName}():`);
+        this.indentLevel++;
+        this.emit(`var tween = create_tween()`);
+        if (tl.loop) {
+          this.emit(`tween.set_loops()`);
+        }
+        for (const entry of tl.entries) {
+          if (entry.action.kind === "animate") {
+            this.emit(
+              `tween.tween_callback(func(): pass) # animate "${entry.action.target}" at ${entry.time}s`
+            );
+            for (const [key, value] of Object.entries(entry.action.properties)) {
+              this.emit(`# ${key}: ${JSON.stringify(value)}`);
+            }
+          } else if (entry.action.kind === "emit") {
+            this.emit(
+              `tween.tween_callback(func(): print("Event: ${entry.action.event}")).set_delay(${entry.time})`
+            );
+          } else if (entry.action.kind === "call") {
+            this.emit(
+              `tween.tween_callback(func(): ${entry.action.method}()).set_delay(${entry.time})`
+            );
+          }
+        }
+        this.indentLevel--;
+        this.emit("");
+      }
+      compileTransition(tr) {
+        const varName = this.sanitizeName(tr.name);
+        this.emit(`func ${varName}():`);
+        this.indentLevel++;
+        const target = tr.properties.find((p) => p.key === "target")?.value;
+        const effect = tr.properties.find((p) => p.key === "effect")?.value;
+        const duration = tr.properties.find((p) => p.key === "duration")?.value;
+        this.emit(`# Transition: ${effect} (${duration}s)`);
+        if (target) {
+          this.emit(`get_tree().change_scene_to_file("res://scenes/${target}.tscn")`);
+        }
+        this.indentLevel--;
+        this.emit("");
+      }
+      compileEffects(effects) {
+        this.emit("# === Post-Processing (configure via WorldEnvironment) ===");
+        for (const effect of effects.effects) {
+          this.emit(`# Effect: ${effect.effectType} \u2014 ${JSON.stringify(effect.properties)}`);
+        }
+        this.emit("");
+      }
+      compileUI(ui) {
+        this.emit("# === UI Overlay ===");
+        this.emit("var ui_layer = CanvasLayer.new()");
+        this.emit('ui_layer.name = "HoloUI"');
+        this.emit("add_child(ui_layer)");
+        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: ${this.escapeStringValue(el.name, "GDScript")} (${elType})`);
+          if (elType === "text") {
+            this.emit(`var ${varName} = Label.new()`);
+            const text = el.properties.find((p) => p.key === "text")?.value;
+            if (text) this.emit(`${varName}.text = "${text}"`);
+          } else if (elType === "progress") {
+            this.emit(`var ${varName} = ProgressBar.new()`);
+          } else if (elType === "panel") {
+            this.emit(`var ${varName} = Panel.new()`);
+          } else {
+            this.emit(`var ${varName} = Control.new()`);
+          }
+          this.emit(`${varName}.name = "${this.escapeStringValue(el.name, "GDScript")}"`);
+          const pos = el.properties.find((p) => p.key === "position")?.value;
+          if (pos && Array.isArray(pos)) {
+            this.emit(`${varName}.position = Vector2(${pos[0]}, ${pos[1]})`);
+          }
+          const size = el.properties.find((p) => p.key === "size")?.value;
+          if (size && Array.isArray(size)) {
+            this.emit(`${varName}.size = Vector2(${size[0]}, ${size[1]})`);
+          }
+          this.emit(`ui_layer.add_child(${varName})`);
+          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 `Vector3(${arr[0]}, ${arr[1]}, ${arr[2]})`;
+        }
+        return `Vector3(${arr}, ${arr}, ${arr})`;
+      }
+      toColor(value) {
+        if (typeof value === "string" && value.startsWith("#")) {
+          return `Color.html("${value}")`;
+        }
+        return `Color.WHITE`;
+      }
+      toGDScriptValue(value) {
+        if (typeof value === "number") return `${value}`;
+        if (typeof value === "boolean") return value ? "true" : "false";
+        if (typeof value === "string") return `"${this.escapeStringValue(value, "GDScript")}"`;
+        if (value === null) return "null";
+        if (Array.isArray(value)) return `[${value.map((v) => this.toGDScriptValue(v)).join(", ")}]`;
+        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.GodotCompiler_exports = GodotCompiler_exports;
+exports.init_GodotCompiler = init_GodotCompiler;
+//# sourceMappingURL=chunk-5NWINHR5.cjs.map
+//# sourceMappingURL=chunk-5NWINHR5.cjs.map