@holoscript/core 7.0.0 → 8.0.0

package/dist/chunk-IZM5VQZD.js

@@ -0,0 +1,714 @@
+import { init_PlatformConditionalCompilerMixin, createPlatformTarget, PlatformConditionalCompilerMixin } from './chunk-GZG4KA4E.js';
+import { init_DomainBlockCompilerMixin, compileDomainBlocks, compileWeatherBlock, weatherToUnreal, compileAudioSourceBlock, audioSourceToUnreal, compilePostProcessingBlock, postProcessingToUnreal, compileParticleBlock, particlesToUnreal, compilePhysicsBlock, physicsToUnreal, compileMaterialBlock, materialToUnreal } from './chunk-JCLBKPMX.js';
+import { createTestCompilerToken, init_CompilerBase, CompilerBase } from './chunk-QPSKHBJP.js';
+import { __export, __esm } from './chunk-OL46QLBJ.js';
+import { ANSCapabilityPath } from '@holoscript/core-types/ans';
+
+// src/compiler/UnrealCompiler.ts
+var UnrealCompiler_exports = {};
+__export(UnrealCompiler_exports, {
+  UnrealCompiler: () => UnrealCompiler,
+  compileToUnreal: () => compileToUnreal
+});
+function compileToUnreal(composition, options) {
+  const compiler = new UnrealCompiler(options);
+  return compiler.compile(composition, createTestCompilerToken());
+}
+var UnrealCompiler;
+var init_UnrealCompiler = __esm({
+  "src/compiler/UnrealCompiler.ts"() {
+    init_CompilerBase();
+    init_DomainBlockCompilerMixin();
+    init_PlatformConditionalCompilerMixin();
+    UnrealCompiler = class extends CompilerBase {
+      constructor(options = {}) {
+        super();
+        this.compilerName = "UnrealCompiler";
+        this.headerLines = [];
+        this.sourceLines = [];
+        this.indentLevel = 0;
+        this.currentFile = "header";
+        this.options = {
+          moduleName: options.moduleName || "HoloWorld",
+          className: options.className || "AGeneratedScene",
+          indent: options.indent || "	",
+          engineVersion: options.engineVersion || "5.4",
+          useEnhancedInput: options.useEnhancedInput ?? true,
+          generateBlueprints: options.generateBlueprints ?? false,
+          provenanceHash: options.provenanceHash ?? "",
+          platformTarget: options.platformTarget ?? ""
+        };
+        if (options.platformTarget) {
+          this._platformTarget = typeof options.platformTarget === "string" ? createPlatformTarget(options.platformTarget) : options.platformTarget;
+        }
+      }
+      getRequiredCapability() {
+        return ANSCapabilityPath.UNREAL;
+      }
+      compile(composition, agentToken, outputPath) {
+        this.validateCompilerAccess(agentToken, outputPath);
+        if (this._platformTarget) {
+          const platformMixin = new PlatformConditionalCompilerMixin();
+          composition = platformMixin.filterForPlatform(composition, this._platformTarget);
+        }
+        this.headerLines = [];
+        this.sourceLines = [];
+        this.indentLevel = 0;
+        const headerFile = this.generateHeader(composition);
+        const sourceFile = this.generateSource(composition);
+        const result = {
+          headerFile,
+          sourceFile
+        };
+        if (this.options.generateBlueprints) {
+          result.blueprintJson = this.generateBlueprintJson(composition);
+        }
+        return result;
+      }
+      generateHeader(composition) {
+        this.headerLines = [];
+        this.currentFile = "header";
+        this.indentLevel = 0;
+        this.emitH("// Auto-generated by HoloScript UnrealCompiler");
+        this.emitH(
+          `// Source: composition "${this.escapeStringValue(composition.name, "TypeScript")}"`
+        );
+        this.emitH(`// Unreal Engine: ${this.options.engineVersion}`);
+        this.emitH("// Do not edit manually \u2014 regenerate from .holo source");
+        if (this.options.provenanceHash) {
+          this.emitH(`// Provenance Hash: ${this.options.provenanceHash}`);
+        }
+        this.emitH("");
+        this.emitH("#pragma once");
+        this.emitH("");
+        this.emitH('#include "CoreMinimal.h"');
+        this.emitH('#include "GameFramework/Actor.h"');
+        this.emitH('#include "Components/StaticMeshComponent.h"');
+        this.emitH('#include "Components/PointLightComponent.h"');
+        this.emitH('#include "Components/SpotLightComponent.h"');
+        this.emitH('#include "Components/DirectionalLightComponent.h"');
+        this.emitH('#include "Components/AudioComponent.h"');
+        this.emitH('#include "Components/BoxComponent.h"');
+        this.emitH('#include "Components/SphereComponent.h"');
+        if (composition.objects?.some((o) => o.traits?.some((t) => t.name === "physics"))) {
+          this.emitH('#include "PhysicsEngine/PhysicsConstraintComponent.h"');
+        }
+        if (this.options.useEnhancedInput) {
+          this.emitH('#include "EnhancedInputComponent.h"');
+          this.emitH('#include "EnhancedInputSubsystems.h"');
+        }
+        this.emitH(`#include "${this.options.className.replace(/^A/, "")}.generated.h"`);
+        this.emitH("");
+        this.emitH("// Forward declarations");
+        this.emitH("class UNiagaraComponent;");
+        this.emitH("class UWidgetComponent;");
+        this.emitH("");
+        this.emitH("UCLASS(Blueprintable, BlueprintType)");
+        this.emitH(
+          `class ${this.options.moduleName.toUpperCase()}_API ${this.options.className} : public AActor`
+        );
+        this.emitH("{");
+        this.indentLevel++;
+        this.emitH("GENERATED_BODY()");
+        this.emitH("");
+        this.emitH("public:");
+        this.emitH(`${this.options.className}();`);
+        this.emitH("");
+        this.emitH("// === Scene Components ===");
+        this.emitH('UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "HoloScript")');
+        this.emitH("USceneComponent* RootSceneComponent;");
+        this.emitH("");
+        for (const obj of this.flattenObjects(composition.objects || [])) {
+          const varName = this.sanitizeName(obj.name);
+          const compType = this.getComponentType(obj);
+          this.emitH(`UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Objects")`);
+          this.emitH(`${compType}* ${varName};`);
+        }
+        this.emitH("");
+        for (const light of composition.lights || []) {
+          const varName = this.sanitizeName(light.name);
+          const lightType = this.getLightComponentType(light.lightType);
+          this.emitH(`UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Lighting")`);
+          this.emitH(`${lightType}* ${varName};`);
+        }
+        this.emitH("");
+        for (const audio of composition.audio || []) {
+          const varName = this.sanitizeName(audio.name);
+          this.emitH(`UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = "Audio")`);
+          this.emitH(`UAudioComponent* ${varName};`);
+        }
+        this.emitH("");
+        if (composition.state) {
+          this.emitH("// === State Properties ===");
+          for (const prop of composition.state.properties) {
+            const cppType = this.toCppType(prop.value);
+            this.emitH(`UPROPERTY(EditAnywhere, BlueprintReadWrite, Replicated, Category = "State")`);
+            this.emitH(`${cppType} ${this.escapeStringValue(prop.key, "TypeScript")};`);
+          }
+          this.emitH("");
+        }
+        this.emitH("protected:");
+        this.emitH("virtual void BeginPlay() override;");
+        this.emitH("virtual void Tick(float DeltaTime) override;");
+        this.emitH(
+          "virtual void GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const override;"
+        );
+        this.emitH("");
+        this.emitH("public:");
+        this.emitH("// === Blueprint Callable Functions ===");
+        if (composition.logic?.actions) {
+          for (const action of composition.logic.actions) {
+            this.emitH(`UFUNCTION(BlueprintCallable, Category = "HoloScript")`);
+            this.emitH(`void ${this.sanitizeName(action.name)}();`);
+          }
+        }
+        this.emitH("");
+        for (const tl of composition.timelines || []) {
+          const name = this.sanitizeName(tl.name);
+          this.emitH(`UFUNCTION(BlueprintCallable, Category = "Timelines")`);
+          this.emitH(`void Play${name}();`);
+        }
+        this.emitH("");
+        for (const tr of composition.transitions || []) {
+          const name = this.sanitizeName(tr.name);
+          this.emitH(`UFUNCTION(BlueprintCallable, Category = "Transitions")`);
+          this.emitH(`void ${name}Transition();`);
+        }
+        if (composition.zones?.length) {
+          this.emitH("");
+          this.emitH("// === Zone Overlap Handlers ===");
+          for (const zone of composition.zones) {
+            const name = this.sanitizeName(zone.name);
+            this.emitH(`UFUNCTION()`);
+            this.emitH(
+              `void On${name}BeginOverlap(UPrimitiveComponent* OverlappedComponent, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult);`
+            );
+            this.emitH(`UFUNCTION()`);
+            this.emitH(
+              `void On${name}EndOverlap(UPrimitiveComponent* OverlappedComponent, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex);`
+            );
+          }
+        }
+        this.emitH("");
+        this.emitH("private:");
+        this.emitH("void SetupComponents();");
+        this.emitH("void SetupEnvironment();");
+        if (composition.zones?.length) {
+          this.emitH("void SetupZones();");
+        }
+        this.indentLevel--;
+        this.emitH("};");
+        return this.headerLines.join("\n");
+      }
+      generateSource(composition) {
+        this.sourceLines = [];
+        this.currentFile = "source";
+        this.indentLevel = 0;
+        const headerName = this.options.className.replace(/^A/, "");
+        this.emitS("// Auto-generated by HoloScript UnrealCompiler");
+        this.emitS(
+          `// Source: composition "${this.escapeStringValue(composition.name, "TypeScript")}"`
+        );
+        this.emitS("");
+        this.emitS(`#include "${headerName}.h"`);
+        this.emitS('#include "Net/UnrealNetwork.h"');
+        this.emitS('#include "Engine/StaticMesh.h"');
+        this.emitS('#include "Materials/MaterialInstanceDynamic.h"');
+        if (composition.audio?.length) {
+          this.emitS('#include "Sound/SoundBase.h"');
+        }
+        this.emitS("");
+        this.emitS(`${this.options.className}::${this.options.className}()`);
+        this.emitS("{");
+        this.indentLevel++;
+        this.emitS("PrimaryActorTick.bCanEverTick = true;");
+        this.emitS("bReplicates = true;");
+        this.emitS("");
+        this.emitS("// Root component");
+        this.emitS(
+          'RootSceneComponent = CreateDefaultSubobject<USceneComponent>(TEXT("RootSceneComponent"));'
+        );
+        this.emitS("RootComponent = RootSceneComponent;");
+        this.emitS("");
+        this.emitS("SetupComponents();");
+        this.indentLevel--;
+        this.emitS("}");
+        this.emitS("");
+        this.emitS(`void ${this.options.className}::SetupComponents()`);
+        this.emitS("{");
+        this.indentLevel++;
+        for (const obj of composition.objects || []) {
+          this.compileObjectSetup(obj);
+        }
+        for (const light of composition.lights || []) {
+          this.compileLightSetup(light);
+        }
+        for (const audio of composition.audio || []) {
+          this.compileAudioSetup(audio);
+        }
+        this.compileUnrealDomainBlocks(composition);
+        this.indentLevel--;
+        this.emitS("}");
+        this.emitS("");
+        this.emitS(`void ${this.options.className}::SetupEnvironment()`);
+        this.emitS("{");
+        this.indentLevel++;
+        if (composition.environment) {
+          this.compileEnvironment(composition.environment);
+        } else {
+          this.emitS("// No environment configuration");
+        }
+        this.indentLevel--;
+        this.emitS("}");
+        this.emitS("");
+        if (composition.zones?.length) {
+          this.emitS(`void ${this.options.className}::SetupZones()`);
+          this.emitS("{");
+          this.indentLevel++;
+          for (const zone of composition.zones) {
+            this.compileZoneSetup(zone);
+          }
+          this.indentLevel--;
+          this.emitS("}");
+          this.emitS("");
+          for (const zone of composition.zones) {
+            this.compileZoneHandlers(zone);
+          }
+        }
+        this.emitS(`void ${this.options.className}::BeginPlay()`);
+        this.emitS("{");
+        this.indentLevel++;
+        this.emitS("Super::BeginPlay();");
+        this.emitS("");
+        this.emitS("SetupEnvironment();");
+        if (composition.zones?.length) {
+          this.emitS("SetupZones();");
+        }
+        this.emitS("");
+        this.emitS(
+          `UE_LOG(LogTemp, Log, TEXT("HoloScript scene '${this.escapeStringValue(composition.name, "TypeScript")}' initialized"));`
+        );
+        for (const tl of composition.timelines || []) {
+          if (tl.autoplay) {
+            this.emitS(`Play${this.sanitizeName(tl.name)}();`);
+          }
+        }
+        this.indentLevel--;
+        this.emitS("}");
+        this.emitS("");
+        this.emitS(`void ${this.options.className}::Tick(float DeltaTime)`);
+        this.emitS("{");
+        this.indentLevel++;
+        this.emitS("Super::Tick(DeltaTime);");
+        this.indentLevel--;
+        this.emitS("}");
+        this.emitS("");
+        this.emitS(
+          `void ${this.options.className}::GetLifetimeReplicatedProps(TArray<FLifetimeProperty>& OutLifetimeProps) const`
+        );
+        this.emitS("{");
+        this.indentLevel++;
+        this.emitS("Super::GetLifetimeReplicatedProps(OutLifetimeProps);");
+        if (composition.state) {
+          this.emitS("");
+          for (const prop of composition.state.properties) {
+            this.emitS(
+              `DOREPLIFETIME(${this.options.className}, ${this.escapeStringValue(prop.key, "TypeScript")});`
+            );
+          }
+        }
+        this.indentLevel--;
+        this.emitS("}");
+        this.emitS("");
+        for (const tl of composition.timelines || []) {
+          this.compileTimelineFunction(tl);
+        }
+        for (const tr of composition.transitions || []) {
+          this.compileTransitionFunction(tr);
+        }
+        if (composition.logic?.actions) {
+          for (const action of composition.logic.actions) {
+            this.compileActionFunction(action);
+          }
+        }
+        return this.sourceLines.join("\n");
+      }
+      compileObjectSetup(obj) {
+        const varName = this.sanitizeName(obj.name);
+        const meshType = this.findObjProp(obj, "mesh") || this.findObjProp(obj, "type") || "cube";
+        const isModel = !!this.findObjProp(obj, "model") || !!this.findObjProp(obj, "src");
+        this.emitS(`// Object: ${this.escapeStringValue(obj.name, "TypeScript")}`);
+        this.emitS(
+          `${varName} = CreateDefaultSubobject<UStaticMeshComponent>(TEXT("${this.escapeStringValue(obj.name, "TypeScript")}"));`
+        );
+        this.emitS(`${varName}->SetupAttachment(RootComponent);`);
+        if (!isModel) {
+          const meshPath = this.getMeshPath(meshType);
+          if (meshPath) {
+            this.emitS(
+              `static ConstructorHelpers::FObjectFinder<UStaticMesh> ${varName}MeshAsset(TEXT("${meshPath}"));`
+            );
+            this.emitS(
+              `if (${varName}MeshAsset.Succeeded()) { ${varName}->SetStaticMesh(${varName}MeshAsset.Object); }`
+            );
+          }
+        }
+        const pos = this.findObjProp(obj, "position");
+        if (pos && Array.isArray(pos)) {
+          this.emitS(
+            `${varName}->SetRelativeLocation(FVector(${pos[0] * 100}f, ${pos[2] * 100}f, ${pos[1] * 100}f));`
+          );
+        }
+        const rot = this.findObjProp(obj, "rotation");
+        if (rot && Array.isArray(rot)) {
+          this.emitS(`${varName}->SetRelativeRotation(FRotator(${rot[0]}f, ${rot[1]}f, ${rot[2]}f));`);
+        }
+        const scale = this.findObjProp(obj, "scale");
+        if (scale) {
+          if (Array.isArray(scale)) {
+            this.emitS(
+              `${varName}->SetRelativeScale3D(FVector(${scale[0]}f, ${scale[1]}f, ${scale[2]}f));`
+            );
+          } else {
+            this.emitS(`${varName}->SetRelativeScale3D(FVector(${scale}f));`);
+          }
+        }
+        if (obj.traits) {
+          for (const trait of obj.traits) {
+            this.compileTraitSetup(varName, trait);
+          }
+        }
+        if (obj.children && obj.children.length > 0) {
+          for (const child of obj.children) {
+            this.compileObjectSetup(child);
+          }
+        }
+        this.emitS("");
+      }
+      compileTraitSetup(varName, trait) {
+        switch (trait.name) {
+          case "physics":
+            this.emitS(`${varName}->SetSimulatePhysics(true);`);
+            if (trait.config?.mass) {
+              this.emitS(`${varName}->SetMassOverrideInKg(NAME_None, ${trait.config.mass}f, true);`);
+            }
+            break;
+          case "collidable":
+            this.emitS(`${varName}->SetCollisionEnabled(ECollisionEnabled::QueryAndPhysics);`);
+            this.emitS(`${varName}->SetCollisionResponseToAllChannels(ECR_Block);`);
+            break;
+          case "grabbable":
+            this.emitS(`// @grabbable \u2014 implement via GrabComponent or VR interaction framework`);
+            this.emitS(`UE_LOG(LogTemp, Warning, TEXT("@grabbable on %s \u2014 trait stubbed, needs GrabComponent implementation"), *GetName());`);
+            break;
+          case "pointable":
+          case "hoverable":
+            this.emitS(
+              `// @${this.escapeStringValue(trait.name, "TypeScript")} \u2014 implement via line trace interaction`
+            );
+            this.emitS(`UE_LOG(LogTemp, Warning, TEXT("@%s on %s \u2014 trait stubbed, needs line trace interaction"), TEXT("${this.escapeStringValue(trait.name, "TypeScript")}"), *GetName());`);
+            break;
+          case "portal":
+            this.emitS(`// @portal \u2014 destination: "${trait.config?.destination || "unknown"}"`);
+            this.emitS(`UE_LOG(LogTemp, Warning, TEXT("@portal on %s \u2014 trait stubbed, needs level streaming/teleport implementation"), *GetName());`);
+            break;
+          case "emissive":
+          case "glowing":
+            this.emitS(
+              `// @${this.escapeStringValue(trait.name, "TypeScript")} \u2014 apply emissive material`
+            );
+            this.emitS(`UE_LOG(LogTemp, Warning, TEXT("@%s on %s \u2014 trait stubbed, needs emissive material"), TEXT("${this.escapeStringValue(trait.name, "TypeScript")}"), *GetName());`);
+            break;
+          case "transparent":
+            this.emitS(`// @transparent \u2014 set material blend mode`);
+            this.emitS(`UE_LOG(LogTemp, Warning, TEXT("@transparent on %s \u2014 trait stubbed, needs translucent material"), *GetName());`);
+            break;
+          default:
+            this.emitS(
+              `// @${this.escapeStringValue(trait.name, "TypeScript")} \u2014 custom trait implementation required`
+            );
+            this.emitS(`UE_LOG(LogTemp, Warning, TEXT("@%s on %s \u2014 unhandled trait, needs custom implementation"), TEXT("${this.escapeStringValue(trait.name, "TypeScript")}"), *GetName());`);
+        }
+      }
+      compileLightSetup(light) {
+        const varName = this.sanitizeName(light.name);
+        const lightType = this.getLightComponentType(light.lightType);
+        this.emitS(`// Light: ${this.escapeStringValue(light.name, "TypeScript")}`);
+        this.emitS(
+          `${varName} = CreateDefaultSubobject<${lightType}>(TEXT("${this.escapeStringValue(light.name, "TypeScript")}"));`
+        );
+        this.emitS(`${varName}->SetupAttachment(RootComponent);`);
+        for (const prop of light.properties) {
+          if (prop.key === "color") {
+            this.emitS(`${varName}->SetLightColor(${this.toLinearColor(prop.value)});`);
+          } else if (prop.key === "intensity") {
+            const intensity = prop.value * 1e4;
+            this.emitS(`${varName}->SetIntensity(${intensity}f);`);
+          } else if (prop.key === "position" && Array.isArray(prop.value)) {
+            const pos = prop.value;
+            this.emitS(
+              `${varName}->SetRelativeLocation(FVector(${pos[0] * 100}f, ${pos[2] * 100}f, ${pos[1] * 100}f));`
+            );
+          } else if (prop.key === "cast_shadow" || prop.key === "castShadow") {
+            this.emitS(`${varName}->SetCastShadows(${prop.value ? "true" : "false"});`);
+          }
+        }
+        this.emitS("");
+      }
+      compileAudioSetup(audio) {
+        const varName = this.sanitizeName(audio.name);
+        this.emitS(`// Audio: ${this.escapeStringValue(audio.name, "TypeScript")}`);
+        this.emitS(
+          `${varName} = CreateDefaultSubobject<UAudioComponent>(TEXT("${this.escapeStringValue(audio.name, "TypeScript")}"));`
+        );
+        this.emitS(`${varName}->SetupAttachment(RootComponent);`);
+        this.emitS(`${varName}->bAutoActivate = false;`);
+        this.emitS("");
+      }
+      compileEnvironment(env) {
+        for (const prop of env.properties) {
+          if (prop.key === "skybox" || prop.key === "preset") {
+            this.emitS(
+              `// Environment preset: "${prop.value}" \u2014 configure via BP_Sky_Sphere or SkyAtmosphere`
+            );
+          } else if (prop.key === "fog" && typeof prop.value === "object") {
+            this.emitS("// Fog settings \u2014 configure via ExponentialHeightFog actor");
+          } else if (prop.key === "ambient_light") {
+            this.emitS(`// Ambient light: ${prop.value} \u2014 configure via SkyLight`);
+          }
+        }
+      }
+      compileZoneSetup(zone) {
+        const varName = this.sanitizeName(zone.name);
+        this.emitS(
+          `// Zone: ${this.escapeStringValue(zone.name, "TypeScript")} \u2014 bind overlap events`
+        );
+        this.emitS(
+          `// ${varName}Trigger->OnComponentBeginOverlap.AddDynamic(this, &${this.options.className}::On${varName}BeginOverlap);`
+        );
+        this.emitS(
+          `// ${varName}Trigger->OnComponentEndOverlap.AddDynamic(this, &${this.options.className}::On${varName}EndOverlap);`
+        );
+      }
+      compileZoneHandlers(zone) {
+        const varName = this.sanitizeName(zone.name);
+        this.emitS(
+          `void ${this.options.className}::On${varName}BeginOverlap(UPrimitiveComponent* OverlappedComponent, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex, bool bFromSweep, const FHitResult& SweepResult)`
+        );
+        this.emitS("{");
+        this.indentLevel++;
+        this.emitS(
+          `UE_LOG(LogTemp, Log, TEXT("Actor entered zone: ${this.escapeStringValue(zone.name, "TypeScript")}"));`
+        );
+        this.indentLevel--;
+        this.emitS("}");
+        this.emitS("");
+        this.emitS(
+          `void ${this.options.className}::On${varName}EndOverlap(UPrimitiveComponent* OverlappedComponent, AActor* OtherActor, UPrimitiveComponent* OtherComp, int32 OtherBodyIndex)`
+        );
+        this.emitS("{");
+        this.indentLevel++;
+        this.emitS(
+          `UE_LOG(LogTemp, Log, TEXT("Actor exited zone: ${this.escapeStringValue(zone.name, "TypeScript")}"));`
+        );
+        this.indentLevel--;
+        this.emitS("}");
+        this.emitS("");
+      }
+      compileTimelineFunction(timeline) {
+        const name = this.sanitizeName(timeline.name);
+        this.emitS(`void ${this.options.className}::Play${name}()`);
+        this.emitS("{");
+        this.indentLevel++;
+        this.emitS(
+          `UE_LOG(LogTemp, Log, TEXT("Playing timeline: ${this.escapeStringValue(timeline.name, "TypeScript")}"));`
+        );
+        this.emitS("// Timeline implementation via FTimeline or native Sequencer");
+        for (const entry of timeline.entries) {
+          this.emitS(`// At ${entry.time}s: ${entry.action.kind}`);
+        }
+        this.indentLevel--;
+        this.emitS("}");
+        this.emitS("");
+      }
+      compileTransitionFunction(transition) {
+        const name = this.sanitizeName(transition.name);
+        this.emitS(`void ${this.options.className}::${name}Transition()`);
+        this.emitS("{");
+        this.indentLevel++;
+        const dest = transition.properties.find((p) => p.key === "destination" || p.key === "to");
+        if (dest) {
+          this.emitS(`UE_LOG(LogTemp, Log, TEXT("Transitioning to: ${dest.value}"));`);
+          this.emitS(`UGameplayStatics::OpenLevel(this, TEXT("${dest.value}"));`);
+        }
+        this.indentLevel--;
+        this.emitS("}");
+        this.emitS("");
+      }
+      compileActionFunction(action) {
+        const name = this.sanitizeName(action.name);
+        this.emitS(`void ${this.options.className}::${name}()`);
+        this.emitS("{");
+        this.indentLevel++;
+        this.emitS(
+          `UE_LOG(LogTemp, Log, TEXT("Action: ${this.escapeStringValue(action.name, "TypeScript")}"));`
+        );
+        this.emitS("// Action implementation");
+        this.indentLevel--;
+        this.emitS("}");
+        this.emitS("");
+      }
+      generateBlueprintJson(composition) {
+        return JSON.stringify(
+          {
+            type: "Blueprint",
+            class: this.options.className,
+            composition: composition.name,
+            objects: composition.objects?.map((o) => ({
+              name: o.name,
+              traits: o.traits?.map((t) => t.name) || []
+            })) || []
+          },
+          null,
+          2
+        );
+      }
+      // === Utility Methods ===
+      emitH(line) {
+        const indent = this.options.indent.repeat(this.indentLevel);
+        this.headerLines.push(indent + line);
+      }
+      emitS(line) {
+        const indent = this.options.indent.repeat(this.indentLevel);
+        this.sourceLines.push(indent + line);
+      }
+      sanitizeName(name) {
+        return name.replace(/[^a-zA-Z0-9_]/g, "_").replace(/^[0-9]/, "_$&");
+      }
+      getComponentType(obj) {
+        const meshType = this.findObjProp(obj, "mesh") || this.findObjProp(obj, "type");
+        if (meshType === "text") return "UTextRenderComponent";
+        return "UStaticMeshComponent";
+      }
+      /** Recursively collect all objects (including children) from a list. */
+      flattenObjects(objects) {
+        const result = [];
+        for (const obj of objects) {
+          result.push(obj);
+          if (obj.children && obj.children.length > 0) {
+            result.push(...this.flattenObjects(obj.children));
+          }
+        }
+        return result;
+      }
+      getLightComponentType(lightType) {
+        const typeMap = {
+          directional: "UDirectionalLightComponent",
+          point: "UPointLightComponent",
+          spot: "USpotLightComponent",
+          area: "URectLightComponent"
+        };
+        return typeMap[lightType] || "UPointLightComponent";
+      }
+      getMeshPath(meshType) {
+        const meshPaths = {
+          cube: "/Engine/BasicShapes/Cube.Cube",
+          box: "/Engine/BasicShapes/Cube.Cube",
+          sphere: "/Engine/BasicShapes/Sphere.Sphere",
+          cylinder: "/Engine/BasicShapes/Cylinder.Cylinder",
+          cone: "/Engine/BasicShapes/Cone.Cone",
+          plane: "/Engine/BasicShapes/Plane.Plane"
+        };
+        return meshPaths[meshType] || null;
+      }
+      findObjProp(obj, key) {
+        return obj.properties?.find((p) => p.key === key)?.value;
+      }
+      toCppType(value) {
+        if (value === null) return "UObject*";
+        if (typeof value === "boolean") return "bool";
+        if (typeof value === "number") return Number.isInteger(value) ? "int32" : "float";
+        if (typeof value === "string") return "FString";
+        if (Array.isArray(value)) {
+          if (value.length === 3 && value.every((v) => typeof v === "number")) return "FVector";
+          if (value.length === 4 && value.every((v) => typeof v === "number")) return "FQuat";
+          return "TArray<float>";
+        }
+        return "UObject*";
+      }
+      compileUnrealDomainBlocks(composition) {
+        const domainBlocks = composition.domainBlocks ?? [];
+        if (domainBlocks.length === 0) return;
+        this.emitS("");
+        this.emitS("// === v4.2 Domain Blocks ===");
+        let blockIdx = 0;
+        const compiled = compileDomainBlocks(
+          domainBlocks,
+          {
+            material: (block) => {
+              const mat = compileMaterialBlock(block);
+              return materialToUnreal(mat, `DB${blockIdx++}`);
+            },
+            physics: (block) => {
+              const phys = compilePhysicsBlock(block);
+              return physicsToUnreal(phys, `DB${blockIdx++}`);
+            },
+            vfx: (block) => {
+              const ps = compileParticleBlock(block);
+              return particlesToUnreal(ps, `DB${blockIdx++}`);
+            },
+            postfx: (block) => {
+              const pp = compilePostProcessingBlock(block);
+              return postProcessingToUnreal(pp, `DB${blockIdx++}`);
+            },
+            audio: (block) => {
+              const audio = compileAudioSourceBlock(block);
+              return audioSourceToUnreal(audio, `DB${blockIdx++}`);
+            },
+            weather: (block) => {
+              const weather = compileWeatherBlock(block);
+              return weatherToUnreal(weather);
+            }
+          },
+          (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.emitS(l);
+          }
+        }
+      }
+      toLinearColor(value) {
+        if (typeof value === "string") {
+          if (value.startsWith("#")) {
+            const hex = value.slice(1);
+            if (hex.length === 6) {
+              const r = parseInt(hex.slice(0, 2), 16) / 255;
+              const g = parseInt(hex.slice(2, 4), 16) / 255;
+              const b = parseInt(hex.slice(4, 6), 16) / 255;
+              return `FLinearColor(${r}f, ${g}f, ${b}f)`;
+            }
+          }
+          const colors = {
+            red: "FLinearColor::Red",
+            green: "FLinearColor::Green",
+            blue: "FLinearColor::Blue",
+            white: "FLinearColor::White",
+            black: "FLinearColor::Black",
+            yellow: "FLinearColor::Yellow"
+          };
+          return colors[value.toLowerCase()] || "FLinearColor::White";
+        }
+        if (Array.isArray(value) && value.length >= 3) {
+          const [r, g, b, a = 1] = value;
+          return `FLinearColor(${r}f, ${g}f, ${b}f, ${a}f)`;
+        }
+        return "FLinearColor::White";
+      }
+    };
+  }
+});
+
+export { UnrealCompiler, UnrealCompiler_exports, compileToUnreal, init_UnrealCompiler };
+//# sourceMappingURL=chunk-IZM5VQZD.js.map
+//# sourceMappingURL=chunk-IZM5VQZD.js.map