@holoscript/core 7.0.0 → 8.0.0

package/dist/chunk-BE4UJCQT.js

@@ -0,0 +1,623 @@
+import { init_DomainBlockCompilerMixin, compileDomainBlocks, inputToVRChat, compileInputBlock, navigationToVRChat, compileNavigationBlock, renderingToVRChat, compileRenderingBlock, proceduralToVRChat, compileProceduralBlock, web3ToVRChat, compileWeb3Block, architectureToVRChat, compileArchitectureBlock, musicToVRChat, compileMusicBlock, educationToVRChat, compileEducationBlock, datavizToVRChat, compileDataVizBlock, iotToVRChat, compileIoTBlock, compileRoboticsBlock, roboticsToVRChat, compileHealthcareBlock, healthcareToVRChat, compilePaymentBlock, paymentToVRChat, compileNarrativeBlock, narrativeToVRChat, compileWeatherBlock, weatherToUnity, compileAudioSourceBlock, audioSourceToUnity, compilePostProcessingBlock, postProcessingToUnity, compileParticleBlock, particlesToUnity, compilePhysicsBlock, physicsToUnity, compileMaterialBlock, materialToVRChat } from './chunk-JCLBKPMX.js';
+import { init_CompilerBase, CompilerBase } from './chunk-QPSKHBJP.js';
+import { __export, __esm } from './chunk-OL46QLBJ.js';
+import { ANSCapabilityPath } from '@holoscript/core-types/ans';
+
+// src/compiler/VRChatCompiler.ts
+var VRChatCompiler_exports = {};
+__export(VRChatCompiler_exports, {
+  VRChatCompiler: () => VRChatCompiler,
+  compileToVRChat: () => compileToVRChat
+});
+function compileToVRChat(composition, options) {
+  const compiler = new VRChatCompiler(options);
+  return Promise.resolve(compiler.compile(composition, ""));
+}
+var VRChatCompiler;
+var init_VRChatCompiler = __esm({
+  "src/compiler/VRChatCompiler.ts"() {
+    init_CompilerBase();
+    init_DomainBlockCompilerMixin();
+    VRChatCompiler = class extends CompilerBase {
+      constructor(options = {}) {
+        super();
+        this.compilerName = "VRChatCompiler";
+        this.lines = [];
+        this.indentLevel = 0;
+        this.udonScripts = /* @__PURE__ */ new Map();
+        this.interactableObjects = [];
+        this.worldIdCounter = 0;
+        const outputFormat = options.outputFormat ?? (options.useUdonSharp === false ? "udon-assembly" : "udonsharp-csharp");
+        this.options = {
+          namespace: options.namespace || "HoloWorld",
+          className: options.className || "GeneratedWorld",
+          worldName: options.worldName || "HoloScript World",
+          indent: options.indent || "    ",
+          sdkVersion: options.sdkVersion || "3.5",
+          outputFormat,
+          useUdonSharp: options.useUdonSharp ?? outputFormat === "udonsharp-csharp",
+          provenanceHash: options.provenanceHash ?? ""
+        };
+      }
+      getRequiredCapability() {
+        return ANSCapabilityPath.VRCHAT;
+      }
+      compile(composition, agentToken, outputPath) {
+        this.validateCompilerAccess(agentToken, outputPath);
+        this.assertSupportedOutputFormat();
+        this.lines = [];
+        this.udonScripts.clear();
+        this.interactableObjects = [];
+        this.indentLevel = 0;
+        const mainScript = this.generateMainScript(composition);
+        this.generateUdonScripts(composition);
+        const prefabHierarchy = this.generatePrefabHierarchy(composition);
+        const worldDescriptor = this.generateWorldDescriptor(composition);
+        return {
+          outputFormat: this.options.outputFormat,
+          mainScript,
+          udonScripts: this.udonScripts,
+          prefabHierarchy,
+          worldDescriptor
+        };
+      }
+      assertSupportedOutputFormat() {
+        if (this.options.outputFormat === "udonsharp-csharp" && this.options.useUdonSharp) {
+          return;
+        }
+        const requested = this.options.outputFormat === "udonsharp-csharp" ? "non-UdonSharp Udon output" : this.options.outputFormat;
+        throw new Error(
+          `VRChat ${requested} output is gated: founder direction is Byte/Udon output, but the artifact contract must be confirmed before implementation (Udon Assembly text vs serialized Udon bytecode asset). The current compiler only emits legacy UdonSharp C# with outputFormat: 'udonsharp-csharp' and useUdonSharp: true.`
+        );
+      }
+      generateMainScript(composition) {
+        this.lines = [];
+        this.indentLevel = 0;
+        this.emit("// Auto-generated by HoloScript VRChatCompiler");
+        this.emit(
+          `// Source: composition "${this.escapeStringValue(composition.name, "CSharp")}"`
+        );
+        this.emit(`// VRChat SDK: ${this.options.sdkVersion}`);
+        this.emit("// Do not edit manually \xE2\u20AC\u201D regenerate from .holo source");
+        if (this.options.provenanceHash) {
+          this.emit(`// Provenance Hash: ${this.options.provenanceHash}`);
+        }
+        this.emit("");
+        this.emit("using UdonSharp;");
+        this.emit("using UnityEngine;");
+        this.emit("using VRC.SDKBase;");
+        this.emit("using VRC.Udon;");
+        this.emit("using VRC.SDK3.Components;");
+        if (composition.audio?.length) {
+          this.emit("using VRC.SDK3.Components.Audio;");
+        }
+        this.emit("");
+        this.emit(`namespace ${this.options.namespace}`);
+        this.emit("{");
+        this.indentLevel++;
+        this.emit("[UdonBehaviourSyncMode(BehaviourSyncMode.Manual)]");
+        this.emit(`public class ${this.options.className} : UdonSharpBehaviour`);
+        this.emit("{");
+        this.indentLevel++;
+        if (composition.state) {
+          this.emit("// === Synced State ===");
+          for (const prop of composition.state.properties) {
+            const csType = this.toCSharpType(prop.value);
+            const csVal = this.toCSharpValue(prop.value);
+            this.emit(
+              `[UdonSynced] public ${csType} ${this.escapeStringValue(prop.key, "CSharp")} = ${csVal};`
+            );
+          }
+          this.emit("");
+        }
+        this.emit("// === Object References ===");
+        this.emit('[Header("Scene Objects")]');
+        const objects = composition.objects || [];
+        for (const obj of objects) {
+          const varName = this.sanitizeName(obj.name);
+          this.emit(`public GameObject ${varName};`);
+        }
+        this.emit("");
+        this.emit("void Start()");
+        this.emit("{");
+        this.indentLevel++;
+        this.emit('Debug.Log("[HoloWorld] World initialized");');
+        if (composition.environment) {
+          this.compileEnvironment(composition.environment);
+        }
+        this.indentLevel--;
+        this.emit("}");
+        this.emit("");
+        this.emit("public override void OnDeserialization()");
+        this.emit("{");
+        this.indentLevel++;
+        this.emit("// Handle synced state updates");
+        this.emit("UpdateVisuals();");
+        this.indentLevel--;
+        this.emit("}");
+        this.emit("");
+        this.emit("private void UpdateVisuals()");
+        this.emit("{");
+        this.indentLevel++;
+        this.emit("// Update visuals based on synced state");
+        this.indentLevel--;
+        this.emit("}");
+        this.emit("");
+        this.emit("public override void OnPlayerJoined(VRCPlayerApi player)");
+        this.emit("{");
+        this.indentLevel++;
+        this.emit("if (player.isLocal)");
+        this.emit("{");
+        this.indentLevel++;
+        this.emit('Debug.Log($"[HoloWorld] Welcome, {player.displayName}!");');
+        this.indentLevel--;
+        this.emit("}");
+        this.indentLevel--;
+        this.emit("}");
+        this.emit("");
+        if (composition.zones) {
+          for (const zone of composition.zones) {
+            this.compileZoneTriggers(zone);
+          }
+        }
+        if (composition.timelines) {
+          for (const tl of composition.timelines) {
+            this.compileTimeline(tl);
+          }
+        }
+        if (composition.transitions) {
+          for (const tr of composition.transitions) {
+            this.compileTransition(tr);
+          }
+        }
+        this.compileVRChatDomainBlocks(composition);
+        this.indentLevel--;
+        this.emit("}");
+        this.indentLevel--;
+        this.emit("}");
+        return this.lines.join("\n");
+      }
+      compileVRChatDomainBlocks(composition) {
+        const domainBlocks = composition.domainBlocks ?? [];
+        if (domainBlocks.length === 0) return;
+        this.emit("");
+        this.emit("// === v4.2 Domain Blocks (VRChat/Unity) ===");
+        let blockIdx = 0;
+        const compiled = compileDomainBlocks(
+          domainBlocks,
+          {
+            material: (block) => {
+              const mat = compileMaterialBlock(block);
+              return materialToVRChat(mat, `db${blockIdx++}`);
+            },
+            physics: (block) => {
+              const phys = compilePhysicsBlock(block);
+              return physicsToUnity(phys, `db${blockIdx++}`);
+            },
+            vfx: (block) => {
+              const ps = compileParticleBlock(block);
+              return particlesToUnity(ps, `db${blockIdx++}`);
+            },
+            postfx: (block) => {
+              const pp = compilePostProcessingBlock(block);
+              return postProcessingToUnity(pp);
+            },
+            audio: (block) => {
+              const audio = compileAudioSourceBlock(block);
+              return audioSourceToUnity(audio, `db${blockIdx++}`);
+            },
+            weather: (block) => {
+              const weather = compileWeatherBlock(block);
+              return weatherToUnity(weather);
+            },
+            narrative: (block) => {
+              const narr = compileNarrativeBlock(block);
+              return narrativeToVRChat(narr);
+            },
+            payment: (block) => {
+              const pay = compilePaymentBlock(block);
+              return paymentToVRChat(pay);
+            },
+            healthcare: (block) => {
+              const h = compileHealthcareBlock(block);
+              return healthcareToVRChat(h);
+            },
+            robotics: (block) => {
+              const r = compileRoboticsBlock(block);
+              return roboticsToVRChat(r);
+            },
+            iot: (block) => iotToVRChat(compileIoTBlock(block)),
+            dataviz: (block) => datavizToVRChat(compileDataVizBlock(block)),
+            education: (block) => educationToVRChat(compileEducationBlock(block)),
+            music: (block) => musicToVRChat(compileMusicBlock(block)),
+            architecture: (block) => architectureToVRChat(compileArchitectureBlock(block)),
+            web3: (block) => web3ToVRChat(compileWeb3Block(block)),
+            procedural: (block) => proceduralToVRChat(compileProceduralBlock(block)),
+            rendering: (block) => renderingToVRChat(compileRenderingBlock(block)),
+            navigation: (block) => navigationToVRChat(compileNavigationBlock(block)),
+            input: (block) => inputToVRChat(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);
+          }
+        }
+      }
+      generateUdonScripts(composition) {
+        const objects = composition.objects || [];
+        for (const obj of objects) {
+          if (!obj.traits) continue;
+          const hasGrabbable = obj.traits.some((t) => t.name === "grabbable");
+          const hasPointable = obj.traits.some((t) => t.name === "pointable" || t.name === "clickable");
+          const hasNetworked = obj.traits.some((t) => t.name === "networked" || t.name === "synced");
+          const hasPortal = obj.traits.some((t) => t.name === "portal");
+          const hasMirror = obj.traits.some((t) => t.name === "mirror");
+          if (hasGrabbable || hasPointable || hasNetworked || hasPortal || hasMirror) {
+            const script = this.generateObjectUdonScript(obj, {
+              hasGrabbable,
+              hasPointable,
+              hasNetworked,
+              hasPortal,
+              hasMirror
+            });
+            this.udonScripts.set(`${this.sanitizeName(obj.name)}Behaviour.cs`, script);
+            this.interactableObjects.push(obj.name);
+          }
+        }
+      }
+      generateObjectUdonScript(obj, traits) {
+        const lines = [];
+        const varName = this.sanitizeName(obj.name);
+        const className = `${varName}Behaviour`;
+        lines.push("// Auto-generated UdonSharp script");
+        lines.push(`// Object: ${this.escapeStringValue(obj.name, "CSharp")}`);
+        lines.push("");
+        lines.push("using UdonSharp;");
+        lines.push("using UnityEngine;");
+        lines.push("using VRC.SDKBase;");
+        lines.push("using VRC.Udon;");
+        lines.push("");
+        const syncMode = traits.hasNetworked ? "BehaviourSyncMode.Manual" : "BehaviourSyncMode.None";
+        lines.push(`[UdonBehaviourSyncMode(${syncMode})]`);
+        lines.push(`public class ${className} : UdonSharpBehaviour`);
+        lines.push("{");
+        if (obj.state?.properties) {
+          lines.push("    // === State ===");
+          for (const prop of obj.state.properties) {
+            const csType = this.toCSharpType(prop.value);
+            const csVal = this.toCSharpValue(prop.value);
+            const syncAttr = traits.hasNetworked ? "[UdonSynced] " : "";
+            lines.push(
+              `    ${syncAttr}public ${csType} ${this.escapeStringValue(prop.key, "CSharp")} = ${csVal};`
+            );
+          }
+          lines.push("");
+        }
+        if (traits.hasGrabbable) {
+          lines.push("    // VRC_Pickup compatible");
+          lines.push("    public VRC_Pickup pickup;");
+          lines.push("");
+          lines.push("    public override void OnPickup()");
+          lines.push("    {");
+          lines.push('        Debug.Log($"[{gameObject.name}] Picked up");');
+          if (traits.hasNetworked) {
+            lines.push("        Networking.SetOwner(Networking.LocalPlayer, gameObject);");
+            lines.push("        RequestSerialization();");
+          }
+          lines.push("    }");
+          lines.push("");
+          lines.push("    public override void OnDrop()");
+          lines.push("    {");
+          lines.push('        Debug.Log($"[{gameObject.name}] Dropped");');
+          if (traits.hasNetworked) {
+            lines.push("        RequestSerialization();");
+          }
+          lines.push("    }");
+          lines.push("");
+        }
+        if (traits.hasPointable) {
+          lines.push("    public override void Interact()");
+          lines.push("    {");
+          lines.push('        Debug.Log($"[{gameObject.name}] Interacted");');
+          lines.push("        OnInteractHandler();");
+          lines.push("    }");
+          lines.push("");
+          lines.push("    private void OnInteractHandler()");
+          lines.push("    {");
+          lines.push("        // Custom interaction logic based on traits");
+          lines.push("    }");
+          lines.push("");
+        }
+        if (traits.hasPortal) {
+          const portalTrait = obj.traits?.find((t) => t.name === "portal");
+          const destination = portalTrait?.config?.destination || "wrld_unknown";
+          lines.push('    [Header("Portal Settings")]');
+          lines.push(`    public string destinationWorld = "${destination}";`);
+          lines.push("");
+          lines.push("    public override void Interact()");
+          lines.push("    {");
+          lines.push("        // VRChat portal \xE2\u20AC\u201D player will be teleported");
+          lines.push('        Debug.Log($"Portal to {destinationWorld}");');
+          lines.push("    }");
+          lines.push("");
+        }
+        if (traits.hasNetworked) {
+          lines.push("    public override void OnDeserialization()");
+          lines.push("    {");
+          lines.push("        // Handle network sync");
+          lines.push("        UpdateFromNetwork();");
+          lines.push("    }");
+          lines.push("");
+          lines.push("    private void UpdateFromNetwork()");
+          lines.push("    {");
+          lines.push("        // Apply synced state to visuals");
+          lines.push("    }");
+          lines.push("");
+        }
+        lines.push("}");
+        return lines.join("\n");
+      }
+      generatePrefabHierarchy(composition) {
+        const lines = [];
+        lines.push(
+          `# VRChat World Prefab Hierarchy: ${this.escapeStringValue(composition.name, "CSharp")}`
+        );
+        lines.push("# Generated by HoloScript VRChatCompiler");
+        lines.push("");
+        lines.push("World Root");
+        lines.push("\xE2\u201D\u0153\xE2\u201D\u20AC\xE2\u201D\u20AC Environment");
+        if (composition.lights) {
+          lines.push("\xE2\u201D\u0153\xE2\u201D\u20AC\xE2\u201D\u20AC Lighting");
+          for (const light of composition.lights) {
+            lines.push(
+              `\xE2\u201D\u201A   \xE2\u201D\u201D\xE2\u201D\u20AC\xE2\u201D\u20AC ${this.escapeStringValue(light.name, "CSharp")} (${light.lightType})`
+            );
+          }
+        }
+        if (composition.objects) {
+          lines.push("\xE2\u201D\u0153\xE2\u201D\u20AC\xE2\u201D\u20AC Objects");
+          for (const obj of composition.objects) {
+            const traits = obj.traits?.map((t) => `@${this.escapeStringValue(t.name, "CSharp")}`).join(" ") || "";
+            lines.push(
+              `\xE2\u201D\u201A   \xE2\u201D\u201D\xE2\u201D\u20AC\xE2\u201D\u20AC ${this.escapeStringValue(obj.name, "CSharp")} ${traits}`
+            );
+          }
+        }
+        if (composition.spatialGroups) {
+          for (const group of composition.spatialGroups) {
+            lines.push(
+              `\xE2\u201D\u0153\xE2\u201D\u20AC\xE2\u201D\u20AC ${this.escapeStringValue(group.name, "CSharp")} (SpatialGroup)`
+            );
+            for (const child of group.objects || []) {
+              lines.push(`\xE2\u201D\u201A   \xE2\u201D\u201D\xE2\u201D\u20AC\xE2\u201D\u20AC ${this.escapeStringValue(child.name, "CSharp")}`);
+            }
+          }
+        }
+        if (composition.audio) {
+          lines.push("\xE2\u201D\u0153\xE2\u201D\u20AC\xE2\u201D\u20AC Audio");
+          for (const audio of composition.audio) {
+            lines.push(
+              `\xE2\u201D\u201A   \xE2\u201D\u201D\xE2\u201D\u20AC\xE2\u201D\u20AC ${this.escapeStringValue(audio.name, "CSharp")} (VRCSpatialAudioSource)`
+            );
+          }
+        }
+        if (composition.zones) {
+          lines.push("\xE2\u201D\u0153\xE2\u201D\u20AC\xE2\u201D\u20AC Zones");
+          for (const zone of composition.zones) {
+            lines.push(
+              `\xE2\u201D\u201A   \xE2\u201D\u201D\xE2\u201D\u20AC\xE2\u201D\u20AC ${this.escapeStringValue(zone.name, "CSharp")} (Trigger)`
+            );
+          }
+        }
+        lines.push("\xE2\u201D\u0153\xE2\u201D\u20AC\xE2\u201D\u20AC VRCWorld (VRC_World)");
+        lines.push("\xE2\u201D\u0153\xE2\u201D\u20AC\xE2\u201D\u20AC Spawn Points");
+        lines.push("\xE2\u201D\u201A   \xE2\u201D\u201D\xE2\u201D\u20AC\xE2\u201D\u20AC SpawnPoint_0");
+        lines.push("\xE2\u201D\u201D\xE2\u201D\u20AC\xE2\u201D\u20AC Player Mods");
+        return lines.join("\n");
+      }
+      generateWorldDescriptor(composition) {
+        const lines = [];
+        lines.push("// VRC_World Descriptor Settings");
+        lines.push(`// World: ${this.options.worldName}`);
+        lines.push("");
+        lines.push("VRC_SceneDescriptor:");
+        lines.push(`  worldName: "${this.options.worldName}"`);
+        lines.push(`  worldId: "wrld_${this.generateWorldId()}"`);
+        lines.push("  capacity: 32");
+        lines.push("  recommendedCapacity: 16");
+        lines.push("  respawnHeightY: -100");
+        lines.push("  objectBehaviourAtRespawnHeight: Destroy");
+        lines.push("  forbidUserPortals: false");
+        lines.push('  unityVersion: "2022.3.22f1"');
+        lines.push(`  sdkVersion: "${this.options.sdkVersion}"`);
+        lines.push("");
+        lines.push("SpawnPoints:");
+        lines.push("  - position: [0, 0, 0]");
+        lines.push("    rotation: [0, 0, 0]");
+        lines.push("");
+        if (composition.camera) {
+          lines.push("ReferenceCamera:");
+          lines.push("  near: 0.01");
+          lines.push("  far: 1000");
+        }
+        return lines.join("\n");
+      }
+      compileEnvironment(env) {
+        this.emit("// === Environment Setup ===");
+        for (const prop of env.properties) {
+          if (prop.key === "skybox" || prop.key === "preset") {
+            this.emit(`// Skybox: "${prop.value}" \xE2\u20AC\u201D set via VRChat scene settings`);
+          } else if (prop.key === "ambient_light") {
+            this.emit(`RenderSettings.ambientIntensity = ${prop.value}f;`);
+          } 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)};`);
+          }
+        }
+      }
+      compileZoneTriggers(zone) {
+        const varName = this.sanitizeName(zone.name);
+        this.emit(`// Zone: ${this.escapeStringValue(zone.name, "CSharp")}`);
+        this.emit(`public void On${varName}Enter(VRCPlayerApi player)`);
+        this.emit("{");
+        this.indentLevel++;
+        this.emit(
+          `Debug.Log($"Player {player.displayName} entered ${this.escapeStringValue(zone.name, "CSharp")}");`
+        );
+        this.indentLevel--;
+        this.emit("}");
+        this.emit("");
+        this.emit(`public void On${varName}Exit(VRCPlayerApi player)`);
+        this.emit("{");
+        this.indentLevel++;
+        this.emit(
+          `Debug.Log($"Player {player.displayName} exited ${this.escapeStringValue(zone.name, "CSharp")}");`
+        );
+        this.indentLevel--;
+        this.emit("}");
+        this.emit("");
+      }
+      compileTimeline(timeline) {
+        const name = this.sanitizeName(timeline.name);
+        this.emit(`// Timeline: ${this.escapeStringValue(timeline.name, "CSharp")}`);
+        this.emit(`public void Play${name}()`);
+        this.emit("{");
+        this.indentLevel++;
+        this.emit(`SendCustomEventDelayedSeconds("${name}Step0", 0f);`);
+        this.indentLevel--;
+        this.emit("}");
+        this.emit("");
+        for (let i = 0; i < timeline.entries.length; i++) {
+          const entry = timeline.entries[i];
+          const nextDelay = i < timeline.entries.length - 1 ? timeline.entries[i + 1].time - entry.time : 0;
+          this.emit(`public void ${name}Step${i}()`);
+          this.emit("{");
+          this.indentLevel++;
+          if (entry.action.kind === "animate") {
+            this.emit(`// Animate ${entry.action.target}`);
+          } else if (entry.action.kind === "emit") {
+            this.emit(`SendCustomEvent("${entry.action.event}");`);
+          } else if (entry.action.kind === "call") {
+            this.emit(`${entry.action.method}();`);
+          }
+          if (nextDelay > 0) {
+            this.emit(`SendCustomEventDelayedSeconds("${name}Step${i + 1}", ${nextDelay}f);`);
+          } else if (timeline.loop && i === timeline.entries.length - 1) {
+            this.emit(`SendCustomEventDelayedSeconds("${name}Step0", 0.1f);`);
+          }
+          this.indentLevel--;
+          this.emit("}");
+          this.emit("");
+        }
+      }
+      compileTransition(transition) {
+        const name = this.sanitizeName(transition.name);
+        this.emit(`// Transition: ${this.escapeStringValue(transition.name, "CSharp")}`);
+        this.emit(`public void ${name}Transition()`);
+        this.emit("{");
+        this.indentLevel++;
+        const dest = transition.properties.find((p) => p.key === "destination" || p.key === "to");
+        if (dest) {
+          this.emit(`// Transition to: ${dest.value}`);
+        }
+        this.indentLevel--;
+        this.emit("}");
+        this.emit("");
+      }
+      generateWorldId() {
+        const seq = this.worldIdCounter++;
+        const hex = seq.toString(16).padStart(8, "0");
+        return `${hex}-0000-0000-0000-000000000000`;
+      }
+      // === Utility Methods ===
+      emit(line) {
+        const indent = this.options.indent.repeat(this.indentLevel);
+        this.lines.push(indent + line);
+      }
+      sanitizeName(name) {
+        return name.replace(/[^a-zA-Z0-9_]/g, "_").replace(/^[0-9]/, "_$&");
+      }
+      toCSharpType(value) {
+        if (value === null) return "object";
+        if (typeof value === "boolean") return "bool";
+        if (typeof value === "number") return Number.isInteger(value) ? "int" : "float";
+        if (typeof value === "string") return "string";
+        if (Array.isArray(value)) {
+          if (value.length === 3 && value.every((v) => typeof v === "number")) return "Vector3";
+          if (value.length === 4 && value.every((v) => typeof v === "number")) return "Quaternion";
+          return "object[]";
+        }
+        return "object";
+      }
+      toCSharpValue(value) {
+        if (value === null) return "null";
+        if (typeof value === "boolean") return value ? "true" : "false";
+        if (typeof value === "number") return Number.isInteger(value) ? `${value}` : `${value}f`;
+        if (typeof value === "string") return `"${this.escapeStringValue(value, "CSharp")}"`;
+        if (Array.isArray(value)) {
+          if (value.length === 3 && value.every((v) => typeof v === "number")) {
+            return `new Vector3(${value[0]}f, ${value[1]}f, ${value[2]}f)`;
+          }
+          if (value.length === 4 && value.every((v) => typeof v === "number")) {
+            return `new Quaternion(${value[0]}f, ${value[1]}f, ${value[2]}f, ${value[3]}f)`;
+          }
+        }
+        return "null";
+      }
+      toColor(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 `new Color(${r}f, ${g}f, ${b}f)`;
+            }
+          }
+          const colors = {
+            red: "Color.red",
+            green: "Color.green",
+            blue: "Color.blue",
+            white: "Color.white",
+            black: "Color.black",
+            yellow: "Color.yellow",
+            cyan: "Color.cyan",
+            magenta: "Color.magenta"
+          };
+          return colors[value.toLowerCase()] || "Color.white";
+        }
+        if (Array.isArray(value) && value.length >= 3) {
+          const [r, g, b, a = 1] = value;
+          return `new Color(${r}f, ${g}f, ${b}f, ${a}f)`;
+        }
+        return "Color.white";
+      }
+      // Collect all trait names for import optimization
+      collectAllTraits(composition) {
+        const traits = [];
+        const addTraits = (obj) => {
+          if (obj.traits) {
+            for (const t of obj.traits) {
+              if (!traits.includes(t.name)) traits.push(t.name);
+            }
+          }
+        };
+        for (const obj of composition.objects || []) addTraits(obj);
+        for (const group of composition.spatialGroups || []) {
+          for (const child of group.objects || []) {
+            addTraits(child);
+          }
+        }
+        return traits;
+      }
+    };
+  }
+});
+
+export { VRChatCompiler, VRChatCompiler_exports, compileToVRChat, init_VRChatCompiler };
+//# sourceMappingURL=chunk-BE4UJCQT.js.map
+//# sourceMappingURL=chunk-BE4UJCQT.js.map

package/dist/chunk-BRQJKJGT.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var chunkCIWWXYHZ_cjs = require('./chunk-CIWWXYHZ.cjs');
+
+// src/reconstruction/simulationContractBinding.ts
+function assertHoloMapManifestContract(m) {
+  if (m.version !== "1.0.0") {
+    throw new Error(`HoloMap manifest version ${m.version} is not v1.0 contract`);
+  }
+  if (m.simulationContract.kind !== chunkCIWWXYHZ_cjs.HOLOMAP_SIMULATION_CONTRACT_KIND) {
+    throw new Error(`Unexpected SimulationContract kind: ${m.simulationContract.kind}`);
+  }
+  if (!m.simulationContract.replayFingerprint || m.simulationContract.replayFingerprint.length < 8) {
+    throw new Error("HoloMap manifest missing replayFingerprint");
+  }
+}
+
+exports.assertHoloMapManifestContract = assertHoloMapManifestContract;
+//# sourceMappingURL=chunk-BRQJKJGT.cjs.map
+//# sourceMappingURL=chunk-BRQJKJGT.cjs.map