virtual-machine 0.0.37 → 0.1.3

package/build/{chunk-ASAZFOYQ.mjs → chunk-S3CJQKBH.mjs}

@@ -206,25 +206,91 @@ if (!("encodeInto" in cachedTextEncoder)) {
   };
 }
 var WASM_VECTOR_LEN = 0;
-function wasm_bindgen__convert__closures_____invoke__h633c7630e96bf7ba(arg0, arg1) {
-  wasm.wasm_bindgen__convert__closures_____invoke__h633c7630e96bf7ba(arg0, arg1);
+function wasm_bindgen__convert__closures_____invoke__ha9a06e4d93c772bf(arg0, arg1) {
+  wasm.wasm_bindgen__convert__closures_____invoke__ha9a06e4d93c772bf(arg0, arg1);
 }
-function wasm_bindgen__convert__closures_____invoke__h1ead60eaa5163c89(arg0, arg1) {
-  wasm.wasm_bindgen__convert__closures_____invoke__h1ead60eaa5163c89(arg0, arg1);
+function wasm_bindgen__convert__closures_____invoke__h3eb569f20d255f19(arg0, arg1) {
+  wasm.wasm_bindgen__convert__closures_____invoke__h3eb569f20d255f19(arg0, arg1);
 }
 function wasm_bindgen__convert__closures_____invoke__h39d3e89751b07765(arg0, arg1, arg2) {
   wasm.wasm_bindgen__convert__closures_____invoke__h39d3e89751b07765(arg0, arg1, arg2);
 }
-function wasm_bindgen__convert__closures_____invoke__hcefed207e507b803(arg0, arg1, arg2) {
-  wasm.wasm_bindgen__convert__closures_____invoke__hcefed207e507b803(arg0, arg1, arg2);
+function wasm_bindgen__convert__closures_____invoke__h320e929207365995(arg0, arg1, arg2) {
+  wasm.wasm_bindgen__convert__closures_____invoke__h320e929207365995(arg0, arg1, arg2);
 }
 var __wbindgen_enum_WorkerType = ["classic", "module"];
+var JitWorkerContextFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
+}, unregister: () => {
+} } : new FinalizationRegistry((ptr) => wasm.__wbg_jitworkercontext_free(ptr >>> 0, 1));
 var WasmVmFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
 }, unregister: () => {
 } } : new FinalizationRegistry((ptr) => wasm.__wbg_wasmvm_free(ptr >>> 0, 1));
 var WorkerStateFinalization = typeof FinalizationRegistry === "undefined" ? { register: () => {
 }, unregister: () => {
 } } : new FinalizationRegistry((ptr) => wasm.__wbg_workerstate_free(ptr >>> 0, 1));
+var JitWorkerContext = class _JitWorkerContext {
+  static __wrap(ptr) {
+    ptr = ptr >>> 0;
+    const obj = Object.create(_JitWorkerContext.prototype);
+    obj.__wbg_ptr = ptr;
+    JitWorkerContextFinalization.register(obj, obj.__wbg_ptr, obj);
+    return obj;
+  }
+  __destroy_into_raw() {
+    const ptr = this.__wbg_ptr;
+    this.__wbg_ptr = 0;
+    JitWorkerContextFinalization.unregister(this);
+    return ptr;
+  }
+  free() {
+    const ptr = this.__destroy_into_raw();
+    wasm.__wbg_jitworkercontext_free(ptr, 0);
+  }
+  /**
+   * Create a new JIT worker context with custom configuration.
+   *
+   * # Arguments
+   * * `min_block_size` - Minimum number of instructions for JIT compilation
+   * * `debug_wat` - Enable debug WAT output
+   * @param {number} min_block_size
+   * @param {boolean} debug_wat
+   * @returns {JitWorkerContext}
+   */
+  static newWithConfig(min_block_size, debug_wat) {
+    const ret = wasm.jitworkercontext_newWithConfig(min_block_size, debug_wat);
+    return _JitWorkerContext.__wrap(ret);
+  }
+  /**
+   * Create a new JIT worker context with default configuration.
+   */
+  constructor() {
+    const ret = wasm.jitworkercontext_new();
+    this.__wbg_ptr = ret >>> 0;
+    JitWorkerContextFinalization.register(this, this.__wbg_ptr, this);
+    return this;
+  }
+  /**
+   * Compile a block from serialized request bytes.
+   *
+   * # Arguments
+   * * `request_bytes` - Bincode-serialized `CompileRequest`
+   *
+   * # Returns
+   * A JavaScript object with the compilation result:
+   * - On success: `{ success: true, pc: number, wasmBytes: Uint8Array }`
+   * - On unsuitable: `{ success: false, pc: number, status: 'unsuitable' }`
+   * - On error: `{ success: false, pc: number, status: 'error' }`
+   * @param {Uint8Array} request_bytes
+   * @returns {any}
+   */
+  compile(request_bytes) {
+    const ptr0 = passArray8ToWasm0(request_bytes, wasm.__wbindgen_malloc);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.jitworkercontext_compile(this.__wbg_ptr, ptr0, len0);
+    return ret;
+  }
+};
+if (Symbol.dispose) JitWorkerContext.prototype[Symbol.dispose] = JitWorkerContext.prototype.free;
 var NetworkStatus = Object.freeze({
   Disconnected: 0,
   "0": "Disconnected",
@@ -280,6 +346,35 @@ var WasmVm = class _WasmVm {
     const len0 = WASM_VECTOR_LEN;
     wasm.wasmvm_print_status(this.__wbg_ptr, ptr0, len0);
   }
+  /**
+   * Re-enable JIT after it was disabled by errors.
+   */
+  reenableJit() {
+    wasm.wasmvm_reenableJit(this.__wbg_ptr);
+  }
+  /**
+   * Get JIT statistics as JSON string.
+   * @returns {string}
+   */
+  getJitStats() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.wasmvm_getJitStats(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
+  /**
+   * Enable or disable JIT debug WAT output.
+   * @param {boolean} debug
+   */
+  setJitDebug(debug) {
+    wasm.wasmvm_setJitDebug(this.__wbg_ptr, debug);
+  }
   /**
    * Start worker threads for secondary harts (1..num_harts).
    *
@@ -298,6 +393,21 @@ var WasmVm = class _WasmVm {
       throw takeFromExternrefTable0(ret[0]);
     }
   }
+  /**
+   * Dump recent JIT trace events to console.
+   * @param {number | null} [count]
+   */
+  dumpJitTrace(count) {
+    wasm.wasmvm_dumpJitTrace(this.__wbg_ptr, isLikeNone(count) ? 4294967297 : count >>> 0);
+  }
+  /**
+   * Check if JIT is currently enabled.
+   * @returns {boolean}
+   */
+  isJitEnabled() {
+    const ret = wasm.wasmvm_isJitEnabled(this.__wbg_ptr);
+    return ret !== 0;
+  }
   /**
    * Get the current network connection status.
    * This checks the actual connection state by seeing if an IP was assigned.
@@ -326,6 +436,26 @@ var WasmVm = class _WasmVm {
     }
     return _WasmVm.__wrap(ret[0]);
   }
+  /**
+   * Clear JIT cache.
+   */
+  clearJitCache() {
+    wasm.wasmvm_clearJitCache(this.__wbg_ptr);
+  }
+  /**
+   * Enable or disable JIT compilation.
+   * @param {boolean} enabled
+   */
+  setJitEnabled(enabled) {
+    wasm.wasmvm_setJitEnabled(this.__wbg_ptr, enabled);
+  }
+  /**
+   * Enable or disable JIT execution tracing.
+   * @param {boolean} enabled
+   */
+  setJitTracing(enabled) {
+    wasm.wasmvm_setJitTracing(this.__wbg_ptr, enabled);
+  }
   /**
    * Get current memory usage (DRAM size) in bytes.
    * @returns {bigint}
@@ -334,6 +464,20 @@ var WasmVm = class _WasmVm {
     const ret = wasm.wasmvm_get_memory_usage(this.__wbg_ptr);
     return BigInt.asUintN(64, ret);
   }
+  /**
+   * Reset all JIT error tracking.
+   */
+  resetJitErrors() {
+    wasm.wasmvm_resetJitErrors(this.__wbg_ptr);
+  }
+  /**
+   * Get current JIT compilation threshold.
+   * @returns {number}
+   */
+  getJitThreshold() {
+    const ret = wasm.wasmvm_getJitThreshold(this.__wbg_ptr);
+    return ret >>> 0;
+  }
   /**
    * Get the SharedArrayBuffer for external worker management.
    * Returns None if not in SMP mode.
@@ -343,6 +487,13 @@ var WasmVm = class _WasmVm {
     const ret = wasm.wasmvm_get_shared_buffer(this.__wbg_ptr);
     return ret;
   }
+  /**
+   * Set JIT compilation threshold (min exec_count before compiling).
+   * @param {number} threshold
+   */
+  setJitThreshold(threshold) {
+    wasm.wasmvm_setJitThreshold(this.__wbg_ptr, threshold);
+  }
   /**
    * Terminate all workers.
    */
@@ -355,6 +506,43 @@ var WasmVm = class _WasmVm {
   disconnect_network() {
     wasm.wasmvm_disconnect_network(this.__wbg_ptr);
   }
+  /**
+   * Get number of cached JIT blocks.
+   * @returns {number}
+   */
+  getJitCacheSize() {
+    const ret = wasm.wasmvm_getJitCacheSize(this.__wbg_ptr);
+    return ret >>> 0;
+  }
+  /**
+   * Add a PC to the JIT blacklist.
+   * @param {bigint} pc
+   */
+  blacklistJitBlock(pc) {
+    wasm.wasmvm_blacklistJitBlock(this.__wbg_ptr, pc);
+  }
+  /**
+   * Clear the JIT blacklist.
+   */
+  clearJitBlacklist() {
+    wasm.wasmvm_clearJitBlacklist(this.__wbg_ptr);
+  }
+  /**
+   * Get JIT diagnostics as JSON string.
+   * @returns {string}
+   */
+  getJitDiagnostics() {
+    let deferred1_0;
+    let deferred1_1;
+    try {
+      const ret = wasm.wasmvm_getJitDiagnostics(this.__wbg_ptr);
+      deferred1_0 = ret[0];
+      deferred1_1 = ret[1];
+      return getStringFromWasm0(ret[0], ret[1]);
+    } finally {
+      wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+    }
+  }
   /**
    * Check how many bytes are pending in the UART output buffer.
    * Useful for debugging output issues.
@@ -390,6 +578,13 @@ var WasmVm = class _WasmVm {
     const ret = wasm.wasmvm_inject_network_packet(this.__wbg_ptr, packet);
     return ret !== 0;
   }
+  /**
+   * Enable TLB fast-path optimization.
+   * @param {boolean} enabled
+   */
+  setJitTlbFastPath(enabled) {
+    wasm.wasmvm_setJitTlbFastPath(this.__wbg_ptr, enabled);
+  }
   /**
    * Signal that workers can start executing.
    * Called by the main thread after hart 0 has finished initializing
@@ -407,6 +602,21 @@ var WasmVm = class _WasmVm {
     const ret = wasm.wasmvm_extract_network_packet(this.__wbg_ptr);
     return ret;
   }
+  /**
+   * Check if JIT tracing is enabled.
+   * @returns {boolean}
+   */
+  isJitTracingEnabled() {
+    const ret = wasm.wasmvm_isJitTracingEnabled(this.__wbg_ptr);
+    return ret !== 0;
+  }
+  /**
+   * Set maximum block size for JIT compilation.
+   * @param {number} size
+   */
+  setJitMaxBlockSize(size) {
+    wasm.wasmvm_setJitMaxBlockSize(this.__wbg_ptr, size);
+  }
   /**
    * Set up an external network backend for packet bridging.
    * This is used by the Node.js CLI to bridge packets between the native
@@ -421,6 +631,32 @@ var WasmVm = class _WasmVm {
       throw takeFromExternrefTable0(ret[0]);
     }
   }
+  /**
+   * Get JIT cache hit ratio.
+   * @returns {number}
+   */
+  getJitCacheHitRatio() {
+    const ret = wasm.wasmvm_getJitCacheHitRatio(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * Get JIT execution ratio (JIT executions / total executions).
+   * Calculated from CPU's block cache statistics.
+   * @returns {number}
+   */
+  getJitExecutionRatio() {
+    const ret = wasm.wasmvm_getJitCacheHitRatio(this.__wbg_ptr);
+    return ret;
+  }
+  /**
+   * Invalidate JIT cache for a specific address.
+   * @param {bigint} pc
+   * @returns {boolean}
+   */
+  invalidateJitCacheAt(pc) {
+    const ret = wasm.wasmvm_invalidateJitCacheAt(this.__wbg_ptr, pc);
+    return ret !== 0;
+  }
   /**
    * Set the assigned IP address for the external network.
    * Called when the native WebTransport addon receives an IP assignment.
@@ -431,6 +667,14 @@ var WasmVm = class _WasmVm {
     const ret = wasm.wasmvm_set_external_network_ip(this.__wbg_ptr, ip_bytes);
     return ret !== 0;
   }
+  /**
+   * Get JIT cache memory usage in bytes.
+   * @returns {number}
+   */
+  getJitCacheMemoryUsage() {
+    const ret = wasm.wasmvm_getJitCacheMemoryUsage(this.__wbg_ptr);
+    return ret >>> 0;
+  }
   /**
    * Get the number of pending RX packets.
    * @returns {number}
@@ -464,6 +708,13 @@ var WasmVm = class _WasmVm {
     const ret = wasm.wasmvm_is_external_network_connected(this.__wbg_ptr);
     return ret !== 0;
   }
+  /**
+   * Set interrupt check interval (0 = disabled).
+   * @param {number} interval
+   */
+  setJitInterruptCheckInterval(interval) {
+    wasm.wasmvm_setJitInterruptCheckInterval(this.__wbg_ptr, interval);
+  }
   /**
    * Create a new VM instance and load a kernel (ELF or raw binary).
    *
@@ -1066,23 +1317,23 @@ function __wbg_get_imports() {
     const ret = getStringFromWasm0(arg0, arg1);
     return ret;
   };
-  imports.wbg.__wbindgen_cast_705cb87c37628e08 = function(arg0, arg1) {
-    const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h219b6c77d9281450, wasm_bindgen__convert__closures_____invoke__hcefed207e507b803);
+  imports.wbg.__wbindgen_cast_32327f67251393a4 = function(arg0, arg1) {
+    const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h1292c9e7657b72ef, wasm_bindgen__convert__closures_____invoke__ha9a06e4d93c772bf);
     return ret;
   };
-  imports.wbg.__wbindgen_cast_bcc7883475928b3d = function(arg0, arg1) {
-    const ret = makeClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h219b6c77d9281450, wasm_bindgen__convert__closures_____invoke__h1ead60eaa5163c89);
+  imports.wbg.__wbindgen_cast_82c798e194eb44f0 = function(arg0, arg1) {
+    const ret = makeClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h1292c9e7657b72ef, wasm_bindgen__convert__closures_____invoke__h3eb569f20d255f19);
     return ret;
   };
-  imports.wbg.__wbindgen_cast_ce1738ca1cf90a8c = function(arg0, arg1) {
-    const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h219b6c77d9281450, wasm_bindgen__convert__closures_____invoke__h633c7630e96bf7ba);
+  imports.wbg.__wbindgen_cast_a93ea42108a71f00 = function(arg0, arg1) {
+    const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__h1292c9e7657b72ef, wasm_bindgen__convert__closures_____invoke__h320e929207365995);
     return ret;
   };
   imports.wbg.__wbindgen_cast_d6cd19b81560fd6e = function(arg0) {
     const ret = arg0;
     return ret;
   };
-  imports.wbg.__wbindgen_cast_f1c9170db27db6a8 = function(arg0, arg1) {
+  imports.wbg.__wbindgen_cast_dc00c1264d481122 = function(arg0, arg1) {
     const ret = makeMutClosure(arg0, arg1, wasm.wasm_bindgen__closure__destroy__hf225e18fc5ab9bc1, wasm_bindgen__convert__closures_____invoke__h39d3e89751b07765);
     return ret;
   };
@@ -1140,6 +1391,7 @@ async function __wbg_init(module_or_path) {
 var riscv_vm_default = __wbg_init;
 
 export {
+  JitWorkerContext,
   NetworkStatus,
   WasmVm,
   WorkerState,