@holoscript/core 7.0.0 → 8.0.1

package/dist/chunk-YVD3CSO3.js

@@ -0,0 +1,1183 @@
+import { init_DomainBlockCompilerMixin, compileDomainBlocks, compileMaterialBlock } from './chunk-BOVPWH4H.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/WASMCompiler.ts
+var WASMCompiler_exports = {};
+__export(WASMCompiler_exports, {
+  WASMCompiler: () => WASMCompiler,
+  compileASTToWASM: () => compileASTToWASM,
+  compileToWASM: () => compileToWASM,
+  createWASMCompiler: () => createWASMCompiler,
+  default: () => WASMCompiler_default
+});
+function createWASMCompiler(options) {
+  return new WASMCompiler(options);
+}
+function compileToWASM(composition, options) {
+  const compiler = new WASMCompiler(options);
+  return compiler.compile(composition, createTestCompilerToken());
+}
+function compileASTToWASM(ast, options) {
+  const compiler = new WASMCompiler(options);
+  return compiler.compileAST(ast);
+}
+var WASM_WAT_LIMITATIONS, WASM_BINARY_LIMITATIONS, WASMCompiler, WASMCompiler_default;
+var init_WASMCompiler = __esm({
+  "src/compiler/WASMCompiler.ts"() {
+    init_CompilerBase();
+    init_DomainBlockCompilerMixin();
+    WASM_WAT_LIMITATIONS = [
+      "Emits WebAssembly Text Format scaffolding only.",
+      'Does not return instantiable bytes unless format is set to "wasm".',
+      "Lowers trait/lifecycle/event hooks to deterministic host event calls, not arbitrary user code."
+    ];
+    WASM_BINARY_LIMITATIONS = [
+      "Returns an instantiable WebAssembly binary for the compiler-supported runtime subset.",
+      "Lowers trait/lifecycle/event hooks to deterministic host event calls, not arbitrary user code.",
+      "Does not run a general-purpose WAT parser for unsupported custom WAT extensions."
+    ];
+    WASMCompiler = class extends CompilerBase {
+      constructor(options = {}) {
+        super();
+        this.compilerName = "WASMCompiler";
+        this.lines = [];
+        this.indentLevel = 0;
+        this.stateVars = [];
+        this.objects = [];
+        this.functions = /* @__PURE__ */ new Map();
+        this.stringPool = /* @__PURE__ */ new Map();
+        this.nextStringOffset = 0;
+        this.imports = [];
+        this.exports = [];
+        // Memory layout
+        this.memoryLayout = {
+          stateOffset: 0,
+          stateSize: 0,
+          objectsOffset: 0,
+          objectsSize: 0,
+          eventsOffset: 0,
+          eventsSize: 1024,
+          // Fixed event queue size
+          stringsOffset: 0,
+          stringsSize: 0,
+          totalSize: 0
+        };
+        const { generateDocs, docsOptions, provenanceHash, ...wasmRest } = options;
+        this.docGenerationOptions = { generateDocs, docsOptions, provenanceHash };
+        const w = wasmRest;
+        this.options = {
+          format: w.format || "wat",
+          debug: w.debug ?? false,
+          memoryPages: w.memoryPages || 16,
+          // 1MB default
+          simd: w.simd ?? false,
+          threads: w.threads ?? false,
+          generateBindings: w.generateBindings ?? true,
+          moduleName: w.moduleName || "holoscript"
+        };
+      }
+      getRequiredCapability() {
+        return ANSCapabilityPath.WASM;
+      }
+      // ===========================================================================
+      // MAIN COMPILATION
+      // ===========================================================================
+      /**
+       * Compile HoloComposition AST to WASM
+       */
+      compile(composition, agentToken, outputPath) {
+        this.validateCompilerAccess(agentToken, outputPath);
+        this.reset();
+        this.analyzeState(composition.state);
+        this.analyzeObjects(composition.objects || []);
+        this.calculateMemoryLayout();
+        this.emitModule(composition);
+        const domainBlocks = composition.domainBlocks ?? [];
+        if (domainBlocks.length > 0) {
+          this.emit("");
+          this.emit("  ;; === v4.2 Domain Blocks ===");
+          compileDomainBlocks(
+            domainBlocks,
+            {
+              material: (block) => {
+                const mat = compileMaterialBlock(block);
+                this.emit(
+                  `  ;; Material: "${this.escapeStringValue(mat.name, "TypeScript")}" type=${mat.type}`
+                );
+                this.emit(
+                  `  ;; baseColor=${mat.baseColor || "none"} roughness=${mat.roughness ?? 0.5} metallic=${mat.metallic ?? 0}`
+                );
+                return "";
+              }
+            },
+            (block) => {
+              this.emit(
+                `  ;; Domain block: ${block.domain}/${block.keyword} "${this.escapeStringValue(block.name, "TypeScript")}"`
+              );
+              return "";
+            }
+          );
+        }
+        const bindings = this.options.generateBindings ? this.generateBindings(composition) : "";
+        const wasm = this.options.format === "wasm" ? this.emitWASMBytes(this.lowerCompositionObjectUpdates(composition.objects || [])) : void 0;
+        const result = {
+          artifactKind: wasm ? "wasm-binary" : "wat-scaffold",
+          format: this.options.format,
+          wat: this.lines.join("\n"),
+          ...wasm ? { wasm } : {},
+          bindings,
+          memoryLayout: this.memoryLayout,
+          exports: this.exports,
+          imports: this.imports,
+          limitations: wasm ? [...WASM_BINARY_LIMITATIONS] : [...WASM_WAT_LIMITATIONS]
+        };
+        return this.withTripleOutputIfRequested(composition, result, this.docGenerationOptions);
+      }
+      /**
+       * Compile HSPlusAST to WASM
+       */
+      compileAST(ast) {
+        this.reset();
+        this.analyzeHSPlusState(ast);
+        this.analyzeHSPlusObjects(ast.root);
+        this.calculateMemoryLayout();
+        this.emitModuleFromAST(ast);
+        const bindings = this.options.generateBindings ? this.generateBindingsFromAST(ast) : "";
+        const wasm = this.options.format === "wasm" ? this.emitWASMBytes(this.lowerASTObjectUpdates(ast.root.children || [])) : void 0;
+        return {
+          artifactKind: wasm ? "wasm-binary" : "wat-scaffold",
+          format: this.options.format,
+          wat: this.lines.join("\n"),
+          ...wasm ? { wasm } : {},
+          bindings,
+          memoryLayout: this.memoryLayout,
+          exports: this.exports,
+          imports: this.imports,
+          limitations: wasm ? [...WASM_BINARY_LIMITATIONS] : [...WASM_WAT_LIMITATIONS]
+        };
+      }
+      reset() {
+        this.lines = [];
+        this.indentLevel = 0;
+        this.stateVars = [];
+        this.objects = [];
+        this.functions.clear();
+        this.stringPool.clear();
+        this.nextStringOffset = 0;
+        this.imports = [];
+        this.exports = [];
+      }
+      // ===========================================================================
+      // ANALYSIS
+      // ===========================================================================
+      analyzeState(state) {
+        if (!state) return;
+        let offset = 0;
+        const stateAny = state;
+        if (stateAny.properties) {
+          for (const prop of stateAny.properties) {
+            const type = this.inferWASMType(prop.value);
+            const size = this.getTypeSize(type);
+            this.stateVars.push({
+              name: prop.key,
+              type,
+              offset,
+              size,
+              initialValue: this.valueToWASM(prop.value, type)
+            });
+            offset += size;
+          }
+        } else if (stateAny.declarations) {
+          for (const [name, value] of Object.entries(stateAny.declarations)) {
+            const type = this.inferWASMType(value);
+            const size = this.getTypeSize(type);
+            this.stateVars.push({
+              name,
+              type,
+              offset,
+              size,
+              initialValue: this.valueToWASM(value, type)
+            });
+            offset += size;
+          }
+        }
+        this.memoryLayout.stateSize = offset;
+      }
+      analyzeHSPlusState(ast) {
+        const stateDirective = ast.root.directives?.find((d) => d.type === "state");
+        if (!stateDirective || stateDirective.type !== "state") return;
+        let offset = 0;
+        const body = stateDirective.body;
+        for (const [name, value] of Object.entries(body)) {
+          const type = this.inferWASMType(value);
+          const size = this.getTypeSize(type);
+          this.stateVars.push({
+            name,
+            type,
+            offset,
+            size,
+            initialValue: this.valueToWASM(value, type)
+          });
+          offset += size;
+        }
+        this.memoryLayout.stateSize = offset;
+      }
+      analyzeObjects(objects) {
+        let offset = 0;
+        for (let i = 0; i < objects.length; i++) {
+          const obj = objects[i];
+          const instance = {
+            id: obj.name,
+            typeIndex: i,
+            offset,
+            properties: /* @__PURE__ */ new Map()
+          };
+          let propOffset = 12;
+          for (const prop of obj.properties || []) {
+            const type = this.inferWASMType(prop.value);
+            const size = this.getTypeSize(type);
+            instance.properties.set(prop.key, { offset: propOffset, type });
+            propOffset += size;
+          }
+          propOffset = Math.ceil(propOffset / 8) * 8;
+          this.objects.push(instance);
+          offset += propOffset;
+        }
+        this.memoryLayout.objectsSize = offset;
+      }
+      analyzeHSPlusObjects(root) {
+        const children = root.children || [];
+        let offset = 0;
+        for (let i = 0; i < children.length; i++) {
+          const node = children[i];
+          const instance = {
+            id: node.id || `obj_${i}`,
+            typeIndex: i,
+            offset,
+            properties: /* @__PURE__ */ new Map()
+          };
+          let propOffset = 12;
+          if (node.properties) {
+            for (const [key, value] of Object.entries(node.properties)) {
+              const type = this.inferWASMType(value);
+              const size = this.getTypeSize(type);
+              instance.properties.set(key, { offset: propOffset, type });
+              propOffset += size;
+            }
+          }
+          propOffset = Math.ceil(propOffset / 8) * 8;
+          this.objects.push(instance);
+          offset += propOffset;
+        }
+        this.memoryLayout.objectsSize = offset;
+      }
+      calculateMemoryLayout() {
+        this.memoryLayout.stateOffset = 0;
+        this.memoryLayout.objectsOffset = this.memoryLayout.stateSize;
+        this.memoryLayout.eventsOffset = this.memoryLayout.objectsOffset + this.memoryLayout.objectsSize;
+        this.memoryLayout.stringsOffset = this.memoryLayout.eventsOffset + this.memoryLayout.eventsSize;
+        this.memoryLayout.totalSize = this.memoryLayout.stringsOffset + this.memoryLayout.stringsSize;
+      }
+      // ===========================================================================
+      // WAT GENERATION
+      // ===========================================================================
+      emitModule(composition) {
+        this.emit("(module");
+        this.indent();
+        if (this.options.debug) {
+          this.emit(`(; Module: ${this.options.moduleName} ;)`);
+        }
+        this.emitImports();
+        this.emitMemory();
+        this.emitGlobals();
+        this.emitFunctionTypes();
+        this.emitInitFunction();
+        this.emitStateAccessors();
+        this.emitObjectFunctions();
+        this.emitEventFunctions();
+        this.emitUpdateFunction(composition);
+        this.emitDataSections();
+        this.emitExports();
+        this.dedent();
+        this.emit(")");
+      }
+      emitModuleFromAST(ast) {
+        this.emit("(module");
+        this.indent();
+        if (this.options.debug) {
+          this.emit(`(; Module: ${this.options.moduleName} (from AST) ;)`);
+        }
+        this.emitImports();
+        this.emitMemory();
+        this.emitGlobals();
+        this.emitFunctionTypes();
+        this.emitInitFunction();
+        this.emitStateAccessors();
+        this.emitObjectFunctions();
+        this.emitEventFunctions();
+        this.emitUpdateFunctionFromAST(ast);
+        this.emitDataSections();
+        this.emitExports();
+        this.dedent();
+        this.emit(")");
+      }
+      emitImports() {
+        this.emit(";; Imports from host");
+        this.emit('(import "env" "log_i32" (func $log_i32 (param i32)))');
+        this.emit('(import "env" "log_f32" (func $log_f32 (param f32)))');
+        this.emit('(import "env" "log_str" (func $log_str (param i32 i32)))');
+        this.imports.push(
+          { module: "env", name: "log_i32", kind: "function", signature: "(i32) -> void" },
+          { module: "env", name: "log_f32", kind: "function", signature: "(f32) -> void" },
+          { module: "env", name: "log_str", kind: "function", signature: "(i32, i32) -> void" }
+        );
+        this.emit('(import "env" "emit_event" (func $emit_event (param i32 i32)))');
+        this.imports.push({
+          module: "env",
+          name: "emit_event",
+          kind: "function",
+          signature: "(event_id: i32, payload_ptr: i32) -> void"
+        });
+        this.emit('(import "env" "get_time" (func $get_time (result f64)))');
+        this.imports.push({
+          module: "env",
+          name: "get_time",
+          kind: "function",
+          signature: "() -> f64"
+        });
+        this.emit("");
+      }
+      emitMemory() {
+        const pages = this.options.memoryPages;
+        this.emit(`;; Memory: ${pages} pages (${pages * 64}KB)`);
+        if (this.options.threads) {
+          this.emit(`(memory (export "memory") ${pages} ${pages * 2} shared)`);
+        } else {
+          this.emit(`(memory (export "memory") ${pages})`);
+        }
+        this.exports.push({ name: "memory", kind: "memory" });
+        this.emit("");
+      }
+      emitGlobals() {
+        this.emit(";; Globals");
+        this.emit("(global $frame_count (mut i32) (i32.const 0))");
+        this.emit("(global $delta_time (mut f32) (f32.const 0.0))");
+        this.emit("(global $last_time (mut f64) (f64.const 0.0))");
+        this.emit(`(global $object_count i32 (i32.const ${this.objects.length}))`);
+        this.emit("");
+      }
+      emitFunctionTypes() {
+        this.emit(";; Function types");
+        this.emit("(type $void_void (func))");
+        this.emit("(type $i32_void (func (param i32)))");
+        this.emit("(type $f32_void (func (param f32)))");
+        this.emit("(type $void_i32 (func (result i32)))");
+        this.emit("(type $void_f32 (func (result f32)))");
+        this.emit("(type $i32_i32 (func (param i32) (result i32)))");
+        this.emit("(type $i32_f32 (func (param i32) (result f32)))");
+        this.emit("(type $i32_i32_void (func (param i32 i32)))");
+        this.emit("(type $update_fn (func (param f32)))");
+        this.emit("");
+      }
+      emitInitFunction() {
+        this.emit(";; Initialize module");
+        this.emit('(func $init (export "init")');
+        this.indent();
+        for (const v of this.stateVars) {
+          const offset = this.memoryLayout.stateOffset + v.offset;
+          this.emit(`  ;; ${this.escapeStringValue(v.name, "TypeScript")}`);
+          switch (v.type) {
+            case "i32":
+              this.emit(`  (i32.store (i32.const ${offset}) (i32.const ${v.initialValue}))`);
+              break;
+            case "i64":
+              this.emit(`  (i64.store (i32.const ${offset}) (i64.const ${v.initialValue}))`);
+              break;
+            case "f32":
+              this.emit(`  (f32.store (i32.const ${offset}) (f32.const ${v.initialValue}))`);
+              break;
+            case "f64":
+              this.emit(`  (f64.store (i32.const ${offset}) (f64.const ${v.initialValue}))`);
+              break;
+          }
+        }
+        for (const obj of this.objects) {
+          const baseOffset = this.memoryLayout.objectsOffset + obj.offset;
+          const safeName = this.sanitizeName(obj.id);
+          this.emit(`  ;; Object: ${safeName}`);
+          this.emit(`  (i32.store (i32.const ${baseOffset}) (i32.const ${obj.typeIndex})) ;; type`);
+          this.emit(`  (i32.store (i32.const ${baseOffset + 4}) (i32.const 1)) ;; active`);
+          this.emit(`  (i32.store (i32.const ${baseOffset + 8}) (i32.const -1)) ;; parent`);
+        }
+        this.dedent();
+        this.emit(")");
+        this.emit("");
+        this.exports.push({ name: "init", kind: "function", signature: "() -> void" });
+      }
+      emitStateAccessors() {
+        this.emit(";; State accessors");
+        for (const v of this.stateVars) {
+          const offset = this.memoryLayout.stateOffset + v.offset;
+          const safeName = this.sanitizeName(v.name);
+          this.emit(`(func $get_${safeName} (export "get_${safeName}") (result ${v.type})`);
+          this.emit(`  (${v.type}.load (i32.const ${offset}))`);
+          this.emit(")");
+          this.emit(`(func $set_${safeName} (export "set_${safeName}") (param $value ${v.type})`);
+          this.emit(`  (${v.type}.store (i32.const ${offset}) (local.get $value))`);
+          this.emit(")");
+          this.exports.push({
+            name: `get_${safeName}`,
+            kind: "function",
+            signature: `() -> ${v.type}`
+          });
+          this.exports.push({
+            name: `set_${safeName}`,
+            kind: "function",
+            signature: `(${v.type}) -> void`
+          });
+        }
+        this.emit('(func $get_frame_count (export "get_frame_count") (result i32)');
+        this.emit("  (global.get $frame_count)");
+        this.emit(")");
+        this.exports.push({
+          name: "get_frame_count",
+          kind: "function",
+          signature: "() -> i32"
+        });
+        this.emit("");
+      }
+      emitObjectFunctions() {
+        this.emit(";; Object functions");
+        this.emit('(func $get_object_count (export "get_object_count") (result i32)');
+        this.emit("  (global.get $object_count)");
+        this.emit(")");
+        this.emit('(func $is_object_active (export "is_object_active") (param $idx i32) (result i32)');
+        this.indent();
+        this.emit("(i32.load");
+        this.emit("  (i32.add");
+        this.emit(`    (i32.const ${this.memoryLayout.objectsOffset})`);
+        this.emit("    (i32.add");
+        this.emit("      (i32.mul (local.get $idx) (i32.const 64)) ;; obj size");
+        this.emit("      (i32.const 4) ;; active offset");
+        this.emit("    )");
+        this.emit("  )");
+        this.emit(")");
+        this.dedent();
+        this.emit(")");
+        this.emit(
+          '(func $set_object_active (export "set_object_active") (param $idx i32) (param $active i32)'
+        );
+        this.indent();
+        this.emit("(i32.store");
+        this.emit("  (i32.add");
+        this.emit(`    (i32.const ${this.memoryLayout.objectsOffset})`);
+        this.emit("    (i32.add");
+        this.emit("      (i32.mul (local.get $idx) (i32.const 64))");
+        this.emit("      (i32.const 4)");
+        this.emit("    )");
+        this.emit("  )");
+        this.emit("  (local.get $active)");
+        this.emit(")");
+        this.dedent();
+        this.emit(")");
+        this.exports.push(
+          { name: "get_object_count", kind: "function", signature: "() -> i32" },
+          { name: "is_object_active", kind: "function", signature: "(i32) -> i32" },
+          { name: "set_object_active", kind: "function", signature: "(i32, i32) -> void" }
+        );
+        this.emit("");
+      }
+      emitEventFunctions() {
+        this.emit(";; Event functions");
+        this.emit("(func $dispatch_event (param $event_id i32) (param $payload i32)");
+        this.emit("  (call $emit_event (local.get $event_id) (local.get $payload))");
+        this.emit(")");
+        this.emit("");
+      }
+      emitUpdateFunction(composition) {
+        const objectUpdates = this.lowerCompositionObjectUpdates(composition.objects || []);
+        this.emit(";; Main update function");
+        this.emit('(func $update (export "update") (param $dt f32)');
+        this.indent();
+        this.emit("(global.set $delta_time (local.get $dt))");
+        this.emit("(global.set $frame_count");
+        this.emit("  (i32.add (global.get $frame_count) (i32.const 1))");
+        this.emit(")");
+        for (let i = 0; i < this.objects.length; i++) {
+          const obj = this.objects[i];
+          const safeObjName = this.sanitizeName(obj.id);
+          this.emit(`  ;; Update ${safeObjName}`);
+          this.emit(`  (if (call $is_object_active (i32.const ${i}))`);
+          this.emit("    (then");
+          this.emit(`      (call $update_object_${i} (local.get $dt))`);
+          this.emit("    )");
+          this.emit("  )");
+        }
+        this.dedent();
+        this.emit(")");
+        this.emit("");
+        for (let i = 0; i < this.objects.length; i++) {
+          const obj = this.objects[i];
+          const safeName = this.sanitizeName(obj.id);
+          this.emit(`(func $update_object_${i} (param $dt f32)`);
+          this.emit(`  ;; Update logic for ${safeName}`);
+          this.emitLoweredObjectUpdateBody(objectUpdates[i] || [], i);
+          this.emit(")");
+        }
+        this.exports.push({ name: "update", kind: "function", signature: "(f32) -> void" });
+        this.emit("");
+      }
+      emitUpdateFunctionFromAST(ast) {
+        const objectUpdates = this.lowerASTObjectUpdates(ast.root.children || []);
+        this.emit(";; Main update function");
+        this.emit('(func $update (export "update") (param $dt f32)');
+        this.indent();
+        this.emit("(global.set $delta_time (local.get $dt))");
+        this.emit("(global.set $frame_count");
+        this.emit("  (i32.add (global.get $frame_count) (i32.const 1))");
+        this.emit(")");
+        for (let i = 0; i < this.objects.length; i++) {
+          const obj = this.objects[i];
+          const safeObjName = this.sanitizeName(obj.id);
+          this.emit(`  ;; Update ${safeObjName}`);
+          this.emit(`  (if (call $is_object_active (i32.const ${i}))`);
+          this.emit("    (then");
+          this.emit(`      (call $update_object_${i} (local.get $dt))`);
+          this.emit("    )");
+          this.emit("  )");
+        }
+        this.dedent();
+        this.emit(")");
+        this.emit("");
+        for (let i = 0; i < this.objects.length; i++) {
+          const obj = this.objects[i];
+          const safeName = this.sanitizeName(obj.id);
+          this.emit(`(func $update_object_${i} (param $dt f32)`);
+          this.emit(`  ;; Update logic for ${safeName}`);
+          this.emitLoweredObjectUpdateBody(objectUpdates[i] || [], i);
+          this.emit(")");
+        }
+        this.exports.push({ name: "update", kind: "function", signature: "(f32) -> void" });
+        this.emit("");
+      }
+      emitLoweredObjectUpdateBody(updates, objectIndex) {
+        if (updates.length === 0) {
+          this.emit("  ;; No WASM-lowerable trait/lifecycle/event hooks for this object");
+          return;
+        }
+        for (const update of updates) {
+          this.emit(`  ;; ${this.escapeStringValue(update.label, "TypeScript")}`);
+          this.emit(`  (call $emit_event (i32.const ${update.eventId}) (i32.const ${objectIndex}))`);
+        }
+      }
+      lowerCompositionObjectUpdates(objects) {
+        return objects.map((obj) => {
+          const events = [];
+          for (const trait of obj.traits || []) {
+            events.push(this.createLoweredUpdate(`trait:${trait.name}`));
+          }
+          for (const eventHandler of this.getUnknownArray(obj, "eventHandlers")) {
+            const event = this.getUnknownString(eventHandler, "event");
+            if (event) events.push(this.createLoweredUpdate(`event:${event}`));
+          }
+          for (const directive of this.getUnknownArray(obj, "directives")) {
+            const directiveType = this.getUnknownString(directive, "type");
+            const hook = this.getUnknownString(directive, "hook") || this.getUnknownString(directive, "name");
+            if (directiveType === "lifecycle" && hook) {
+              events.push(this.createLoweredUpdate(`lifecycle:${hook}`));
+            }
+          }
+          return events;
+        });
+      }
+      lowerASTObjectUpdates(nodes) {
+        return nodes.map((node) => {
+          const events = [];
+          for (const directive of node.directives || []) {
+            const directiveType = this.getUnknownString(directive, "type");
+            const name = this.getUnknownString(directive, "name") || this.getUnknownString(directive, "hook");
+            if (directiveType === "trait" && name) {
+              events.push(this.createLoweredUpdate(`trait:${name}`));
+            } else if (directiveType === "lifecycle" && name) {
+              events.push(this.createLoweredUpdate(`lifecycle:${name}`));
+            }
+          }
+          for (const [key] of Object.entries(node.properties || {})) {
+            if (key.startsWith("on_")) events.push(this.createLoweredUpdate(`event:${key}`));
+          }
+          return events;
+        });
+      }
+      createLoweredUpdate(label) {
+        return {
+          label,
+          eventId: this.stableEventId(label)
+        };
+      }
+      stableEventId(label) {
+        let hash = 2166136261;
+        for (let i = 0; i < label.length; i++) {
+          hash ^= label.charCodeAt(i);
+          hash = Math.imul(hash, 16777619);
+        }
+        return hash >>> 1;
+      }
+      getUnknownArray(source, key) {
+        if (!source || typeof source !== "object") return [];
+        const value = source[key];
+        return Array.isArray(value) ? value : [];
+      }
+      getUnknownString(source, key) {
+        if (!source || typeof source !== "object") return void 0;
+        const value = source[key];
+        return typeof value === "string" ? value : void 0;
+      }
+      emitDataSections() {
+        if (this.stringPool.size === 0) return;
+        this.emit(";; Data sections");
+        for (const [str, offset] of this.stringPool) {
+          const escaped = this.escapeWATString(str);
+          this.emit(`(data (i32.const ${this.memoryLayout.stringsOffset + offset}) "${escaped}")`);
+        }
+        this.emit("");
+      }
+      emitExports() {
+      }
+      // ===========================================================================
+      // JS BINDINGS GENERATION
+      // ===========================================================================
+      generateBindings(_composition) {
+        const lines = [];
+        lines.push("/**");
+        lines.push(` * JavaScript bindings for ${this.options.moduleName}`);
+        lines.push(" * Auto-generated by HoloScript WASMCompiler");
+        lines.push(" */");
+        lines.push("");
+        lines.push("export class HoloScriptWASM {");
+        lines.push("  private instance: WebAssembly.Instance | null = null;");
+        lines.push("  private memory: WebAssembly.Memory | null = null;");
+        lines.push(
+          "  private eventHandlers: Map<string, Set<(payload: unknown) => void>> = new Map();"
+        );
+        lines.push("");
+        lines.push("  private static EVENT_IDS: Record<string, number> = {");
+        lines.push("    'update': 0,");
+        lines.push("    'state_change': 1,");
+        lines.push("    'object_activated': 2,");
+        lines.push("    'object_deactivated': 3,");
+        lines.push("  };");
+        lines.push("");
+        lines.push("  async load(wasmSource: ArrayBuffer | Response): Promise<void> {");
+        lines.push("    const importObject = {");
+        lines.push("      env: {");
+        lines.push('        log_i32: (v: number) => console.log("[WASM i32]", v),');
+        lines.push('        log_f32: (v: number) => console.log("[WASM f32]", v),');
+        lines.push("        log_str: (ptr: number, len: number) => {");
+        lines.push("          const bytes = new Uint8Array(this.memory!.buffer, ptr, len);");
+        lines.push('          console.log("[WASM str]", new TextDecoder().decode(bytes));');
+        lines.push("        },");
+        lines.push("        emit_event: (eventId: number, payloadPtr: number) => {");
+        lines.push("          this.handleEvent(eventId, payloadPtr);");
+        lines.push("        },");
+        lines.push("        get_time: () => performance.now(),");
+        lines.push("      },");
+        lines.push("    };");
+        lines.push("");
+        lines.push("    const result = await WebAssembly.instantiate(wasmSource, importObject);");
+        lines.push("    this.instance = result.instance;");
+        lines.push("    this.memory = this.instance.exports.memory as WebAssembly.Memory;");
+        lines.push("    (this.instance.exports.init as Function)();");
+        lines.push("  }");
+        lines.push("");
+        lines.push("  // State accessors");
+        for (const v of this.stateVars) {
+          const safeName = this.sanitizeName(v.name);
+          const jsType = this.wasmTypeToJS(v.type);
+          lines.push(`  get ${safeName}(): ${jsType} {`);
+          lines.push(`    return (this.instance!.exports.get_${safeName} as Function)();`);
+          lines.push("  }");
+          lines.push(`  set ${safeName}(value: ${jsType}) {`);
+          lines.push(`    (this.instance!.exports.set_${safeName} as Function)(value);`);
+          lines.push("  }");
+        }
+        lines.push("");
+        lines.push("  update(dt: number): void {");
+        lines.push("    (this.instance!.exports.update as Function)(dt);");
+        lines.push("  }");
+        lines.push("");
+        lines.push("  on(event: string, handler: (payload: unknown) => void): () => void {");
+        lines.push("    if (!this.eventHandlers.has(event)) {");
+        lines.push("      this.eventHandlers.set(event, new Set());");
+        lines.push("    }");
+        lines.push("    this.eventHandlers.get(event)!.add(handler);");
+        lines.push("    return () => this.eventHandlers.get(event)?.delete(handler);");
+        lines.push("  }");
+        lines.push("");
+        lines.push("  private handleEvent(eventId: number, payloadPtr: number): void {");
+        lines.push("    const eventName = Object.entries(HoloScriptWASM.EVENT_IDS)");
+        lines.push("      .find(([_, id]) => id === eventId)?.[0];");
+        lines.push("    if (!eventName) return;");
+        lines.push("    const handlers = this.eventHandlers.get(eventName);");
+        lines.push("    if (handlers) {");
+        lines.push("      const payload = this.decodePayload(payloadPtr);");
+        lines.push("      handlers.forEach(h => h(payload));");
+        lines.push("    }");
+        lines.push("  }");
+        lines.push("");
+        lines.push("  private decodePayload(ptr: number): unknown {");
+        lines.push("    if (!this.instance || ptr === 0) return {};");
+        lines.push("    const memory = this.instance.exports.memory as WebAssembly.Memory;");
+        lines.push("    const view = new DataView(memory.buffer);");
+        lines.push("    // Read payload header: [type:u8][length:u32]");
+        lines.push("    const payloadType = view.getUint8(ptr);");
+        lines.push("    const length = view.getUint32(ptr + 1, true);");
+        lines.push("    const dataPtr = ptr + 5;");
+        lines.push("    switch (payloadType) {");
+        lines.push("      case 0: return null; // Null");
+        lines.push("      case 1: return view.getFloat64(dataPtr, true); // Number");
+        lines.push("      case 2: return view.getUint8(dataPtr) !== 0; // Boolean");
+        lines.push("      case 3: { // String");
+        lines.push("        const bytes = new Uint8Array(memory.buffer, dataPtr, length);");
+        lines.push("        return new TextDecoder().decode(bytes);");
+        lines.push("      }");
+        lines.push("      case 4: { // Object (JSON)");
+        lines.push("        const bytes = new Uint8Array(memory.buffer, dataPtr, length);");
+        lines.push("        return JSON.parse(new TextDecoder().decode(bytes));");
+        lines.push("      }");
+        lines.push("      case 5: { // Float32Array");
+        lines.push("        return new Float32Array(memory.buffer, dataPtr, length / 4);");
+        lines.push("      }");
+        lines.push("      default: return { ptr, type: payloadType, length };");
+        lines.push("    }");
+        lines.push("  }");
+        lines.push("");
+        lines.push("  getObjectCount(): number {");
+        lines.push("    return (this.instance!.exports.get_object_count as Function)();");
+        lines.push("  }");
+        lines.push("");
+        lines.push("  isObjectActive(index: number): boolean {");
+        lines.push("    return (this.instance!.exports.is_object_active as Function)(index) !== 0;");
+        lines.push("  }");
+        lines.push("");
+        lines.push("  setObjectActive(index: number, active: boolean): void {");
+        lines.push(
+          "    (this.instance!.exports.set_object_active as Function)(index, active ? 1 : 0);"
+        );
+        lines.push("  }");
+        lines.push("");
+        lines.push("  getMemoryLayout(): object {");
+        lines.push(`    return ${JSON.stringify(this.memoryLayout)};`);
+        lines.push("  }");
+        lines.push("}");
+        return lines.join("\n");
+      }
+      generateBindingsFromAST(ast) {
+        const minimalComposition = {
+          type: "Composition",
+          name: ast.root.id || "scene",
+          objects: [],
+          templates: [],
+          spatialGroups: [],
+          lights: [],
+          imports: [],
+          timelines: [],
+          audio: [],
+          zones: [],
+          transitions: [],
+          conditionals: [],
+          iterators: [],
+          npcs: [],
+          quests: [],
+          abilities: [],
+          dialogues: [],
+          stateMachines: [],
+          achievements: [],
+          talentTrees: [],
+          shapes: []
+        };
+        return this.generateBindings(minimalComposition);
+      }
+      // ===========================================================================
+      // WASM BINARY GENERATION
+      // ===========================================================================
+      emitWASMBytes(objectUpdates) {
+        const types = [];
+        const typeIndexes = /* @__PURE__ */ new Map();
+        const typeIndex = (params, results = []) => {
+          const key = `${params.join(",")}->${results.join(",")}`;
+          const existing = typeIndexes.get(key);
+          if (existing !== void 0) return existing;
+          const next = types.length;
+          types.push({ params, results });
+          typeIndexes.set(key, next);
+          return next;
+        };
+        const imports = [
+          { module: "env", name: "log_i32", typeIndex: typeIndex(["i32"]) },
+          { module: "env", name: "log_f32", typeIndex: typeIndex(["f32"]) },
+          { module: "env", name: "log_str", typeIndex: typeIndex(["i32", "i32"]) },
+          { module: "env", name: "emit_event", typeIndex: typeIndex(["i32", "i32"]) },
+          { module: "env", name: "get_time", typeIndex: typeIndex([], ["f64"]) }
+        ];
+        const functions = [];
+        const functionIndexes = /* @__PURE__ */ new Map();
+        const addFunction = (name, params, results, body) => {
+          functionIndexes.set(name, imports.length + functions.length);
+          functions.push({ name, typeIndex: typeIndex(params, results), body });
+        };
+        addFunction("init", [], [], () => this.binaryInitBody());
+        for (const stateVar of this.stateVars) {
+          const safeName = this.sanitizeName(stateVar.name);
+          addFunction(
+            `get_${safeName}`,
+            [],
+            [stateVar.type],
+            () => this.binaryStateGetterBody(stateVar)
+          );
+          addFunction(
+            `set_${safeName}`,
+            [stateVar.type],
+            [],
+            () => this.binaryStateSetterBody(stateVar)
+          );
+        }
+        addFunction("get_frame_count", [], ["i32"], () => [0, 35, ...this.encodeULEB(0), 11]);
+        addFunction("get_object_count", [], ["i32"], () => [0, 35, ...this.encodeULEB(3), 11]);
+        addFunction("is_object_active", ["i32"], ["i32"], () => this.binaryIsObjectActiveBody());
+        addFunction("set_object_active", ["i32", "i32"], [], () => this.binarySetObjectActiveBody());
+        addFunction(
+          "update",
+          ["f32"],
+          [],
+          () => this.binaryUpdateBody(functionIndexes, objectUpdates.length)
+        );
+        for (let i = 0; i < this.objects.length; i++) {
+          addFunction(
+            `update_object_${i}`,
+            ["f32"],
+            [],
+            () => this.binaryUpdateObjectBody(objectUpdates[i] || [], i)
+          );
+        }
+        const bytes = [
+          0,
+          97,
+          115,
+          109,
+          1,
+          0,
+          0,
+          0,
+          ...this.binarySection(1, this.binaryTypeSection(types)),
+          ...this.binarySection(2, this.binaryImportSection(imports)),
+          ...this.binarySection(3, this.binaryFunctionSection(functions)),
+          ...this.binarySection(5, this.binaryMemorySection()),
+          ...this.binarySection(6, this.binaryGlobalSection()),
+          ...this.binarySection(7, this.binaryExportSection(functions, imports.length)),
+          ...this.binarySection(10, this.binaryCodeSection(functions))
+        ];
+        return new Uint8Array(bytes);
+      }
+      binaryTypeSection(types) {
+        return this.binaryVector(
+          types.map((type) => [
+            96,
+            ...this.binaryVector(type.params.map((param) => [this.wasmBinaryValueType(param)])),
+            ...this.binaryVector(type.results.map((result) => [this.wasmBinaryValueType(result)]))
+          ])
+        );
+      }
+      binaryImportSection(imports) {
+        return this.binaryVector(
+          imports.map((entry) => [
+            ...this.encodeString(entry.module),
+            ...this.encodeString(entry.name),
+            0,
+            ...this.encodeULEB(entry.typeIndex)
+          ])
+        );
+      }
+      binaryFunctionSection(functions) {
+        return this.binaryVector(functions.map((fn) => this.encodeULEB(fn.typeIndex)));
+      }
+      binaryMemorySection() {
+        if (this.options.threads) {
+          return this.binaryVector([
+            [
+              3,
+              ...this.encodeULEB(this.options.memoryPages),
+              ...this.encodeULEB(this.options.memoryPages * 2)
+            ]
+          ]);
+        }
+        return this.binaryVector([[0, ...this.encodeULEB(this.options.memoryPages)]]);
+      }
+      binaryGlobalSection() {
+        return this.binaryVector([
+          [127, 1, 65, ...this.encodeSLEB(0), 11],
+          [125, 1, 67, ...this.f32Bytes(0), 11],
+          [124, 1, 68, ...this.f64Bytes(0), 11],
+          [127, 0, 65, ...this.encodeSLEB(this.objects.length), 11]
+        ]);
+      }
+      binaryExportSection(functions, importedFunctionCount) {
+        const exports$1 = [
+          [...this.encodeString("memory"), 2, ...this.encodeULEB(0)],
+          ...functions.filter((fn) => !fn.name.startsWith("update_object_")).map((fn, index) => [
+            ...this.encodeString(fn.name),
+            0,
+            ...this.encodeULEB(importedFunctionCount + index)
+          ])
+        ];
+        return this.binaryVector(exports$1);
+      }
+      binaryCodeSection(functions) {
+        return this.binaryVector(
+          functions.map((fn) => {
+            const body = fn.body();
+            return [...this.encodeULEB(body.length), ...body];
+          })
+        );
+      }
+      binaryInitBody() {
+        const body = [0];
+        for (const stateVar of this.stateVars) {
+          const offset = this.memoryLayout.stateOffset + stateVar.offset;
+          body.push(65, ...this.encodeSLEB(offset));
+          this.pushWASMConst(body, stateVar.type, stateVar.initialValue);
+          this.pushWASMStore(body, stateVar.type);
+        }
+        for (const obj of this.objects) {
+          const baseOffset = this.memoryLayout.objectsOffset + obj.offset;
+          this.pushI32StoreConst(body, baseOffset, obj.typeIndex);
+          this.pushI32StoreConst(body, baseOffset + 4, 1);
+          this.pushI32StoreConst(body, baseOffset + 8, -1);
+        }
+        body.push(11);
+        return body;
+      }
+      binaryStateGetterBody(stateVar) {
+        const offset = this.memoryLayout.stateOffset + stateVar.offset;
+        const body = [0, 65, ...this.encodeSLEB(offset)];
+        this.pushWASMLoad(body, stateVar.type);
+        body.push(11);
+        return body;
+      }
+      binaryStateSetterBody(stateVar) {
+        const offset = this.memoryLayout.stateOffset + stateVar.offset;
+        const body = [0, 65, ...this.encodeSLEB(offset), 32, 0];
+        this.pushWASMStore(body, stateVar.type);
+        body.push(11);
+        return body;
+      }
+      binaryIsObjectActiveBody() {
+        const body = [0];
+        this.pushObjectActiveAddress(body, 0);
+        body.push(40, 2, 0, 11);
+        return body;
+      }
+      binarySetObjectActiveBody() {
+        const body = [0];
+        this.pushObjectActiveAddress(body, 0);
+        body.push(32, 1, 54, 2, 0, 11);
+        return body;
+      }
+      binaryUpdateBody(functionIndexes, loweredObjectCount) {
+        const body = [0];
+        body.push(32, 0, 36, ...this.encodeULEB(1));
+        body.push(35, ...this.encodeULEB(0), 65, ...this.encodeSLEB(1), 106);
+        body.push(36, ...this.encodeULEB(0));
+        const isActiveIndex = functionIndexes.get("is_object_active");
+        if (isActiveIndex === void 0) throw new Error("missing is_object_active function index");
+        for (let i = 0; i < loweredObjectCount; i++) {
+          const updateObjectIndex = functionIndexes.get(`update_object_${i}`);
+          if (updateObjectIndex === void 0) continue;
+          body.push(65, ...this.encodeSLEB(i), 16, ...this.encodeULEB(isActiveIndex));
+          body.push(4, 64);
+          body.push(32, 0, 16, ...this.encodeULEB(updateObjectIndex));
+          body.push(11);
+        }
+        body.push(11);
+        return body;
+      }
+      binaryUpdateObjectBody(updates, objectIndex) {
+        const body = [0];
+        for (const update of updates) {
+          body.push(
+            65,
+            ...this.encodeSLEB(update.eventId),
+            65,
+            ...this.encodeSLEB(objectIndex),
+            16,
+            ...this.encodeULEB(3)
+          );
+        }
+        body.push(11);
+        return body;
+      }
+      pushObjectActiveAddress(body, localIndex) {
+        body.push(65, ...this.encodeSLEB(this.memoryLayout.objectsOffset));
+        body.push(32, ...this.encodeULEB(localIndex));
+        body.push(65, ...this.encodeSLEB(64), 108);
+        body.push(65, ...this.encodeSLEB(4), 106);
+        body.push(106);
+      }
+      pushI32StoreConst(body, offset, value) {
+        body.push(65, ...this.encodeSLEB(offset), 65, ...this.encodeSLEB(value), 54, 2, 0);
+      }
+      pushWASMConst(body, type, value) {
+        switch (type) {
+          case "i32":
+            body.push(65, ...this.encodeSLEB(Number(value)));
+            break;
+          case "i64":
+            body.push(66, ...this.encodeSLEB(value));
+            break;
+          case "f32":
+            body.push(67, ...this.f32Bytes(Number(value)));
+            break;
+          case "f64":
+            body.push(68, ...this.f64Bytes(Number(value)));
+            break;
+        }
+      }
+      pushWASMLoad(body, type) {
+        const opcode = { i32: 40, i64: 41, f32: 42, f64: 43 }[type];
+        const align = type === "i64" || type === "f64" ? 3 : 2;
+        body.push(opcode, align, 0);
+      }
+      pushWASMStore(body, type) {
+        const opcode = { i32: 54, i64: 55, f32: 56, f64: 57 }[type];
+        const align = type === "i64" || type === "f64" ? 3 : 2;
+        body.push(opcode, align, 0);
+      }
+      binarySection(id, payload) {
+        return [id, ...this.encodeULEB(payload.length), ...payload];
+      }
+      binaryVector(items) {
+        return [...this.encodeULEB(items.length), ...items.flat()];
+      }
+      encodeString(value) {
+        const bytes = Array.from(new TextEncoder().encode(value));
+        return [...this.encodeULEB(bytes.length), ...bytes];
+      }
+      encodeULEB(value) {
+        const bytes = [];
+        let next = value >>> 0;
+        do {
+          let byte = next & 127;
+          next >>>= 7;
+          if (next !== 0) byte |= 128;
+          bytes.push(byte);
+        } while (next !== 0);
+        return bytes;
+      }
+      encodeSLEB(value) {
+        const bytes = [];
+        let next = BigInt(value);
+        let more = true;
+        while (more) {
+          let byte = Number(next & 0x7fn);
+          next >>= 7n;
+          const signBitSet = (byte & 64) !== 0;
+          more = !(next === 0n && !signBitSet || next === -1n && signBitSet);
+          if (more) byte |= 128;
+          bytes.push(byte);
+        }
+        return bytes;
+      }
+      f32Bytes(value) {
+        const bytes = new Uint8Array(4);
+        new DataView(bytes.buffer).setFloat32(0, value, true);
+        return Array.from(bytes);
+      }
+      f64Bytes(value) {
+        const bytes = new Uint8Array(8);
+        new DataView(bytes.buffer).setFloat64(0, value, true);
+        return Array.from(bytes);
+      }
+      wasmBinaryValueType(type) {
+        switch (type) {
+          case "i32":
+            return 127;
+          case "i64":
+            return 126;
+          case "f32":
+            return 125;
+          case "f64":
+            return 124;
+        }
+      }
+      // ===========================================================================
+      // HELPERS
+      // ===========================================================================
+      emit(line) {
+        const indent = "  ".repeat(this.indentLevel);
+        this.lines.push(indent + line);
+      }
+      indent() {
+        this.indentLevel++;
+      }
+      dedent() {
+        this.indentLevel = Math.max(0, this.indentLevel - 1);
+      }
+      inferWASMType(value) {
+        if (typeof value === "boolean") return "i32";
+        if (typeof value === "number") {
+          return Number.isInteger(value) ? "i32" : "f32";
+        }
+        if (typeof value === "bigint") return "i64";
+        if (typeof value === "string") return "i32";
+        if (Array.isArray(value)) return "i32";
+        return "i32";
+      }
+      getTypeSize(type) {
+        switch (type) {
+          case "i32":
+          case "f32":
+            return 4;
+          case "i64":
+          case "f64":
+            return 8;
+        }
+      }
+      valueToWASM(value, _type) {
+        if (typeof value === "boolean") return value ? 1 : 0;
+        if (typeof value === "number") return value;
+        if (typeof value === "bigint") return value;
+        if (typeof value === "string") {
+          if (!this.stringPool.has(value)) {
+            this.stringPool.set(value, this.nextStringOffset);
+            this.nextStringOffset += value.length + 1;
+          }
+          return this.stringPool.get(value);
+        }
+        return 0;
+      }
+      wasmTypeToJS(type) {
+        switch (type) {
+          case "i32":
+          case "f32":
+            return "number";
+          case "i64":
+            return "bigint";
+          case "f64":
+            return "number";
+        }
+      }
+      sanitizeName(name) {
+        return name.replace(/[^a-zA-Z0-9_]/g, "_");
+      }
+      escapeWATString(str) {
+        return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+      }
+    };
+    WASMCompiler_default = WASMCompiler;
+  }
+});
+
+export { WASMCompiler, WASMCompiler_default, WASMCompiler_exports, compileASTToWASM, compileToWASM, createWASMCompiler, init_WASMCompiler };
+//# sourceMappingURL=chunk-YVD3CSO3.js.map
+//# sourceMappingURL=chunk-YVD3CSO3.js.map