@holoscript/core 6.0.3 → 6.1.1

package/dist/{chunk-NRUB55IT.cjs → chunk-MXJ5SS53.cjs}

@@ -1,12 +1,13 @@
 'use strict';
 
-var chunkHHS6FMOU_cjs = require('./chunk-HHS6FMOU.cjs');
-var chunkQHVVVN47_cjs = require('./chunk-QHVVVN47.cjs');
-var chunkEGIZHYJP_cjs = require('./chunk-EGIZHYJP.cjs');
+var chunkHGVXZDSK_cjs = require('./chunk-HGVXZDSK.cjs');
+var chunkRMHC2VG7_cjs = require('./chunk-RMHC2VG7.cjs');
+var chunkHCCQLAA4_cjs = require('./chunk-HCCQLAA4.cjs');
+var ans = require('@holoscript/core-types/ans');
 
 // src/compiler/WASMCompiler.ts
 var WASMCompiler_exports = {};
-chunkEGIZHYJP_cjs.__export(WASMCompiler_exports, {
+chunkHCCQLAA4_cjs.__export(WASMCompiler_exports, {
   WASMCompiler: () => exports.WASMCompiler,
   compileASTToWASM: () => compileASTToWASM,
   compileToWASM: () => compileToWASM,
@@ -18,19 +19,28 @@ function createWASMCompiler(options) {
 }
 function compileToWASM(composition, options) {
   const compiler = new exports.WASMCompiler(options);
-  return compiler.compile(composition, chunkQHVVVN47_cjs.createTestCompilerToken());
+  return compiler.compile(composition, chunkRMHC2VG7_cjs.createTestCompilerToken());
 }
 function compileASTToWASM(ast, options) {
   const compiler = new exports.WASMCompiler(options);
   return compiler.compileAST(ast);
 }
-exports.WASMCompiler = void 0; exports.WASMCompiler_default = void 0;
-var init_WASMCompiler = chunkEGIZHYJP_cjs.__esm({
+var WASM_WAT_LIMITATIONS, WASM_BINARY_LIMITATIONS; exports.WASMCompiler = void 0; exports.WASMCompiler_default = void 0;
+var init_WASMCompiler = chunkHCCQLAA4_cjs.__esm({
   "src/compiler/WASMCompiler.ts"() {
-    chunkQHVVVN47_cjs.init_CompilerBase();
-    chunkQHVVVN47_cjs.init_ANSNamespace();
-    chunkHHS6FMOU_cjs.init_DomainBlockCompilerMixin();
-    exports.WASMCompiler = class extends chunkQHVVVN47_cjs.CompilerBase {
+    chunkRMHC2VG7_cjs.init_CompilerBase();
+    chunkHGVXZDSK_cjs.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."
+    ];
+    exports.WASMCompiler = class extends chunkRMHC2VG7_cjs.CompilerBase {
       constructor(options = {}) {
         super();
         this.compilerName = "WASMCompiler";
@@ -56,19 +66,22 @@ var init_WASMCompiler = chunkEGIZHYJP_cjs.__esm({
           stringsSize: 0,
           totalSize: 0
         };
+        const { generateDocs, docsOptions, provenanceHash, ...wasmRest } = options;
+        this.docGenerationOptions = { generateDocs, docsOptions, provenanceHash };
+        const w = wasmRest;
         this.options = {
-          format: options.format || "wat",
-          debug: options.debug ?? false,
-          memoryPages: options.memoryPages || 16,
+          format: w.format || "wat",
+          debug: w.debug ?? false,
+          memoryPages: w.memoryPages || 16,
           // 1MB default
-          simd: options.simd ?? false,
-          threads: options.threads ?? false,
-          generateBindings: options.generateBindings ?? true,
-          moduleName: options.moduleName || "holoscript"
+          simd: w.simd ?? false,
+          threads: w.threads ?? false,
+          generateBindings: w.generateBindings ?? true,
+          moduleName: w.moduleName || "holoscript"
         };
       }
       getRequiredCapability() {
-        return chunkQHVVVN47_cjs.ANSCapabilityPath.WASM;
+        return ans.ANSCapabilityPath.WASM;
       }
       // ===========================================================================
       // MAIN COMPILATION
@@ -77,8 +90,6 @@ var init_WASMCompiler = chunkEGIZHYJP_cjs.__esm({
        * Compile HoloComposition AST to WASM
        */
       compile(composition, agentToken, outputPath) {
-        this.validateCompilerAccess(agentToken, outputPath);
-        this.reset();
         this.validateCompilerAccess(agentToken, outputPath);
         this.reset();
         this.analyzeState(composition.state);
@@ -89,11 +100,11 @@ var init_WASMCompiler = chunkEGIZHYJP_cjs.__esm({
         if (domainBlocks.length > 0) {
           this.emit("");
           this.emit("  ;; === v4.2 Domain Blocks ===");
-          chunkHHS6FMOU_cjs.compileDomainBlocks(
+          chunkHGVXZDSK_cjs.compileDomainBlocks(
             domainBlocks,
             {
               material: (block) => {
-                const mat = chunkHHS6FMOU_cjs.compileMaterialBlock(block);
+                const mat = chunkHGVXZDSK_cjs.compileMaterialBlock(block);
                 this.emit(
                   `  ;; Material: "${this.escapeStringValue(mat.name, "TypeScript")}" type=${mat.type}`
                 );
@@ -112,13 +123,19 @@ var init_WASMCompiler = chunkEGIZHYJP_cjs.__esm({
           );
         }
         const bindings = this.options.generateBindings ? this.generateBindings(composition) : "";
-        return {
+        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
+          imports: this.imports,
+          limitations: wasm ? [...WASM_BINARY_LIMITATIONS] : [...WASM_WAT_LIMITATIONS]
         };
+        return this.withTripleOutputIfRequested(composition, result, this.docGenerationOptions);
       }
       /**
        * Compile HSPlusAST to WASM
@@ -130,12 +147,17 @@ var init_WASMCompiler = chunkEGIZHYJP_cjs.__esm({
         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
+          imports: this.imports,
+          limitations: wasm ? [...WASM_BINARY_LIMITATIONS] : [...WASM_WAT_LIMITATIONS]
         };
       }
       reset() {
@@ -418,6 +440,14 @@ var init_WASMCompiler = chunkEGIZHYJP_cjs.__esm({
             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() {
@@ -468,7 +498,8 @@ var init_WASMCompiler = chunkEGIZHYJP_cjs.__esm({
         this.emit(")");
         this.emit("");
       }
-      emitUpdateFunction(_composition) {
+      emitUpdateFunction(composition) {
+        const objectUpdates = this.lowerCompositionObjectUpdates(composition.objects || []);
         this.emit(";; Main update function");
         this.emit('(func $update (export "update") (param $dt f32)');
         this.indent();
@@ -494,13 +525,14 @@ var init_WASMCompiler = chunkEGIZHYJP_cjs.__esm({
           const safeName = this.sanitizeName(obj.id);
           this.emit(`(func $update_object_${i} (param $dt f32)`);
           this.emit(`  ;; Update logic for ${safeName}`);
-          this.emit("  ;; (custom logic would be generated here based on traits/lifecycle)");
+          this.emitLoweredObjectUpdateBody(objectUpdates[i] || [], i);
           this.emit(")");
         }
         this.exports.push({ name: "update", kind: "function", signature: "(f32) -> void" });
         this.emit("");
       }
-      emitUpdateFunctionFromAST(_ast) {
+      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();
@@ -526,11 +558,84 @@ var init_WASMCompiler = chunkEGIZHYJP_cjs.__esm({
           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");
@@ -555,7 +660,9 @@ var init_WASMCompiler = chunkEGIZHYJP_cjs.__esm({
         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(
+          "  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,");
@@ -695,6 +802,317 @@ var init_WASMCompiler = chunkEGIZHYJP_cjs.__esm({
         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) {
@@ -767,5 +1185,5 @@ exports.compileASTToWASM = compileASTToWASM;
 exports.compileToWASM = compileToWASM;
 exports.createWASMCompiler = createWASMCompiler;
 exports.init_WASMCompiler = init_WASMCompiler;
-//# sourceMappingURL=chunk-NRUB55IT.cjs.map
-//# sourceMappingURL=chunk-NRUB55IT.cjs.map
+//# sourceMappingURL=chunk-MXJ5SS53.cjs.map
+//# sourceMappingURL=chunk-MXJ5SS53.cjs.map