virtual-machine 0.1.0 → 0.1.3

package/build/index.d.ts

@@ -1,6 +1,36 @@
 /* tslint:disable */
 /* eslint-disable */
 
+declare class JitWorkerContext {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * 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
+   */
+  static newWithConfig(min_block_size: number, debug_wat: boolean): JitWorkerContext;
+  /**
+   * Create a new JIT worker context with default configuration.
+   */
+  constructor();
+  /**
+   * 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' }`
+   */
+  compile(request_bytes: Uint8Array): any;
+}
+
 /**
  * Network connection status for the WASM VM.
  */
@@ -16,7 +46,7 @@ declare class WasmVm {
   [Symbol.dispose](): void;
   /**
    * Get a byte from the UART output buffer, if available.
-   * 
+   *
    * In SMP mode, this checks both the shared UART output buffer (for worker output)
    * and the local UART buffer (for hart 0 output).
    */
@@ -30,6 +60,18 @@ declare class WasmVm {
    * Print a status message to UART output (visible in browser).
    */
   print_status(message: string): void;
+  /**
+   * Re-enable JIT after it was disabled by errors.
+   */
+  reenableJit(): void;
+  /**
+   * Get JIT statistics as JSON string.
+   */
+  getJitStats(): string;
+  /**
+   * Enable or disable JIT debug WAT output.
+   */
+  setJitDebug(debug: boolean): void;
   /**
    * Start worker threads for secondary harts (1..num_harts).
    *
@@ -40,6 +82,14 @@ declare class WasmVm {
    * * `worker_url` - URL to the worker script (e.g., "/worker.js")
    */
   start_workers(worker_url: string): void;
+  /**
+   * Dump recent JIT trace events to console.
+   */
+  dumpJitTrace(count?: number | null): void;
+  /**
+   * Check if JIT is currently enabled.
+   */
+  isJitEnabled(): boolean;
   /**
    * Get the current network connection status.
    * This checks the actual connection state by seeing if an IP was assigned.
@@ -53,15 +103,39 @@ declare class WasmVm {
    * * `num_harts` - Number of harts (0 = auto-detect)
    */
   static new_with_harts(kernel: Uint8Array, num_harts: number): WasmVm;
+  /**
+   * Clear JIT cache.
+   */
+  clearJitCache(): void;
+  /**
+   * Enable or disable JIT compilation.
+   */
+  setJitEnabled(enabled: boolean): void;
+  /**
+   * Enable or disable JIT execution tracing.
+   */
+  setJitTracing(enabled: boolean): void;
   /**
    * Get current memory usage (DRAM size) in bytes.
    */
   get_memory_usage(): bigint;
+  /**
+   * Reset all JIT error tracking.
+   */
+  resetJitErrors(): void;
+  /**
+   * Get current JIT compilation threshold.
+   */
+  getJitThreshold(): number;
   /**
    * Get the SharedArrayBuffer for external worker management.
    * Returns None if not in SMP mode.
    */
   get_shared_buffer(): SharedArrayBuffer | undefined;
+  /**
+   * Set JIT compilation threshold (min exec_count before compiling).
+   */
+  setJitThreshold(threshold: number): void;
   /**
    * Terminate all workers.
    */
@@ -70,6 +144,22 @@ declare class WasmVm {
    * Disconnect from the network.
    */
   disconnect_network(): void;
+  /**
+   * Get number of cached JIT blocks.
+   */
+  getJitCacheSize(): number;
+  /**
+   * Add a PC to the JIT blacklist.
+   */
+  blacklistJitBlock(pc: bigint): void;
+  /**
+   * Clear the JIT blacklist.
+   */
+  clearJitBlacklist(): void;
+  /**
+   * Get JIT diagnostics as JSON string.
+   */
+  getJitDiagnostics(): string;
   /**
    * Check how many bytes are pending in the UART output buffer.
    * Useful for debugging output issues.
@@ -85,6 +175,10 @@ declare class WasmVm {
    * Called from JavaScript when the native WebTransport addon receives a packet.
    */
   inject_network_packet(packet: Uint8Array): boolean;
+  /**
+   * Enable TLB fast-path optimization.
+   */
+  setJitTlbFastPath(enabled: boolean): void;
   /**
    * Signal that workers can start executing.
    * Called by the main thread after hart 0 has finished initializing
@@ -96,19 +190,44 @@ declare class WasmVm {
    * Returns the packet data or null if no packet is pending.
    */
   extract_network_packet(): Uint8Array | undefined;
+  /**
+   * Check if JIT tracing is enabled.
+   */
+  isJitTracingEnabled(): boolean;
+  /**
+   * Set maximum block size for JIT compilation.
+   */
+  setJitMaxBlockSize(size: number): void;
   /**
    * Set up an external network backend for packet bridging.
    * This is used by the Node.js CLI to bridge packets between the native
    * WebTransport addon and the WASM VM.
-   * 
+   *
    * @param mac_bytes - MAC address as 6 bytes [0x52, 0x54, 0x00, 0x12, 0x34, 0x56]
    */
   setup_external_network(mac_bytes: Uint8Array): void;
+  /**
+   * Get JIT cache hit ratio.
+   */
+  getJitCacheHitRatio(): number;
+  /**
+   * Get JIT execution ratio (JIT executions / total executions).
+   * Calculated from CPU's block cache statistics.
+   */
+  getJitExecutionRatio(): number;
+  /**
+   * Invalidate JIT cache for a specific address.
+   */
+  invalidateJitCacheAt(pc: bigint): boolean;
   /**
    * Set the assigned IP address for the external network.
    * Called when the native WebTransport addon receives an IP assignment.
    */
   set_external_network_ip(ip_bytes: Uint8Array): boolean;
+  /**
+   * Get JIT cache memory usage in bytes.
+   */
+  getJitCacheMemoryUsage(): number;
   /**
    * Get the number of pending RX packets.
    */
@@ -126,6 +245,10 @@ declare class WasmVm {
    * Check if external network is connected (has IP assigned).
    */
   is_external_network_connected(): boolean;
+  /**
+   * Set interrupt check interval (0 = disabled).
+   */
+  setJitInterruptCheckInterval(interval: number): void;
   /**
    * Create a new VM instance and load a kernel (ELF or raw binary).
    *
@@ -191,7 +314,7 @@ declare class WorkerState {
   [Symbol.dispose](): void;
   /**
    * Execute a batch of instructions and return.
-   * 
+   *
    * This is designed to be called repeatedly from JavaScript, allowing
    * the event loop to yield between batches. This prevents the worker
    * from blocking indefinitely and allows it to respond to messages.
@@ -251,7 +374,7 @@ declare function worker_check_interrupts(hart_id: number, shared_mem: any): bigi
 
 /**
  * Legacy worker entry point - DEPRECATED.
- * 
+ *
  * This function runs a blocking infinite loop. Use WorkerState + step_batch instead
  * for cooperative scheduling that doesn't block the worker's event loop.
  */
@@ -261,22 +384,39 @@ type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Modul
 
 interface InitOutput {
   readonly memory: WebAssembly.Memory;
+  readonly __wbg_jitworkercontext_free: (a: number, b: number) => void;
   readonly __wbg_wasmvm_free: (a: number, b: number) => void;
   readonly __wbg_workerstate_free: (a: number, b: number) => void;
+  readonly jitworkercontext_compile: (a: number, b: number, c: number) => any;
+  readonly jitworkercontext_new: () => number;
+  readonly jitworkercontext_newWithConfig: (a: number, b: number) => number;
   readonly wasmvm_allow_workers_to_start: (a: number) => void;
+  readonly wasmvm_blacklistJitBlock: (a: number, b: bigint) => void;
+  readonly wasmvm_clearJitBlacklist: (a: number) => void;
+  readonly wasmvm_clearJitCache: (a: number) => void;
   readonly wasmvm_connect_webtransport: (a: number, b: number, c: number, d: number, e: number) => [number, number];
   readonly wasmvm_disconnect_network: (a: number) => void;
+  readonly wasmvm_dumpJitTrace: (a: number, b: number) => void;
   readonly wasmvm_entry_pc: (a: number) => bigint;
   readonly wasmvm_external_network_rx_pending: (a: number) => number;
   readonly wasmvm_external_network_tx_pending: (a: number) => number;
   readonly wasmvm_extract_all_network_packets: (a: number) => any;
   readonly wasmvm_extract_network_packet: (a: number) => any;
+  readonly wasmvm_getJitCacheHitRatio: (a: number) => number;
+  readonly wasmvm_getJitCacheMemoryUsage: (a: number) => number;
+  readonly wasmvm_getJitCacheSize: (a: number) => number;
+  readonly wasmvm_getJitDiagnostics: (a: number) => [number, number];
+  readonly wasmvm_getJitStats: (a: number) => [number, number];
+  readonly wasmvm_getJitThreshold: (a: number) => number;
   readonly wasmvm_get_memory_usage: (a: number) => bigint;
   readonly wasmvm_get_output: (a: number) => number;
   readonly wasmvm_get_shared_buffer: (a: number) => any;
   readonly wasmvm_halt_code: (a: number) => bigint;
   readonly wasmvm_inject_network_packet: (a: number, b: any) => number;
   readonly wasmvm_input: (a: number, b: number) => void;
+  readonly wasmvm_invalidateJitCacheAt: (a: number, b: bigint) => number;
+  readonly wasmvm_isJitEnabled: (a: number) => number;
+  readonly wasmvm_isJitTracingEnabled: (a: number) => number;
   readonly wasmvm_is_external_network_connected: (a: number) => number;
   readonly wasmvm_is_halted: (a: number) => number;
   readonly wasmvm_is_smp: (a: number) => number;
@@ -287,6 +427,15 @@ interface InitOutput {
   readonly wasmvm_num_harts: (a: number) => number;
   readonly wasmvm_print_banner: (a: number) => void;
   readonly wasmvm_print_status: (a: number, b: number, c: number) => void;
+  readonly wasmvm_reenableJit: (a: number) => void;
+  readonly wasmvm_resetJitErrors: (a: number) => void;
+  readonly wasmvm_setJitDebug: (a: number, b: number) => void;
+  readonly wasmvm_setJitEnabled: (a: number, b: number) => void;
+  readonly wasmvm_setJitInterruptCheckInterval: (a: number, b: number) => void;
+  readonly wasmvm_setJitMaxBlockSize: (a: number, b: number) => void;
+  readonly wasmvm_setJitThreshold: (a: number, b: number) => void;
+  readonly wasmvm_setJitTlbFastPath: (a: number, b: number) => void;
+  readonly wasmvm_setJitTracing: (a: number, b: number) => void;
   readonly wasmvm_set_external_network_ip: (a: number, b: any) => number;
   readonly wasmvm_setup_external_network: (a: number, b: any) => [number, number];
   readonly wasmvm_start_workers: (a: number, b: number, c: number) => [number, number];
@@ -300,12 +449,13 @@ interface InitOutput {
   readonly workerstate_new: (a: number, b: any, c: bigint) => number;
   readonly workerstate_step_batch: (a: number, b: number) => number;
   readonly workerstate_step_count: (a: number) => bigint;
-  readonly wasm_bindgen__convert__closures_____invoke__h8a077b496ee6a629: (a: number, b: number) => void;
-  readonly wasm_bindgen__closure__destroy__h54a2706e25dd10b8: (a: number, b: number) => void;
-  readonly wasm_bindgen__convert__closures_____invoke__h38b3d5c42439bcf4: (a: number, b: number) => void;
-  readonly wasm_bindgen__convert__closures_____invoke__he860240c5b649134: (a: number, b: number, c: any) => void;
+  readonly wasmvm_getJitExecutionRatio: (a: number) => number;
+  readonly wasm_bindgen__convert__closures_____invoke__ha9a06e4d93c772bf: (a: number, b: number) => void;
+  readonly wasm_bindgen__closure__destroy__h1292c9e7657b72ef: (a: number, b: number) => void;
+  readonly wasm_bindgen__convert__closures_____invoke__h3eb569f20d255f19: (a: number, b: number) => void;
   readonly wasm_bindgen__convert__closures_____invoke__h39d3e89751b07765: (a: number, b: number, c: any) => void;
   readonly wasm_bindgen__closure__destroy__hf225e18fc5ab9bc1: (a: number, b: number) => void;
+  readonly wasm_bindgen__convert__closures_____invoke__h320e929207365995: (a: number, b: number, c: any) => void;
   readonly __wbindgen_malloc: (a: number, b: number) => number;
   readonly __wbindgen_realloc: (a: number, b: number, c: number, d: number) => number;
   readonly __wbindgen_exn_store: (a: number) => void;
@@ -340,6 +490,8 @@ declare function __wbg_init (module_or_path?: { module_or_path: InitInput | Prom
 
 type __pkg_riscv_vm_InitInput = InitInput;
 type __pkg_riscv_vm_InitOutput = InitOutput;
+type __pkg_riscv_vm_JitWorkerContext = JitWorkerContext;
+declare const __pkg_riscv_vm_JitWorkerContext: typeof JitWorkerContext;
 type __pkg_riscv_vm_NetworkStatus = NetworkStatus;
 declare const __pkg_riscv_vm_NetworkStatus: typeof NetworkStatus;
 type __pkg_riscv_vm_SyncInitInput = SyncInitInput;
@@ -353,7 +505,7 @@ declare const __pkg_riscv_vm_initSync: typeof initSync;
 declare const __pkg_riscv_vm_worker_check_interrupts: typeof worker_check_interrupts;
 declare const __pkg_riscv_vm_worker_entry: typeof worker_entry;
 declare namespace __pkg_riscv_vm {
-  export { type __pkg_riscv_vm_InitInput as InitInput, type __pkg_riscv_vm_InitOutput as InitOutput, __pkg_riscv_vm_NetworkStatus as NetworkStatus, type __pkg_riscv_vm_SyncInitInput as SyncInitInput, __pkg_riscv_vm_WasmVm as WasmVm, __pkg_riscv_vm_WorkerState as WorkerState, __pkg_riscv_vm_WorkerStepResult as WorkerStepResult, __wbg_init as default, __pkg_riscv_vm_initSync as initSync, __pkg_riscv_vm_worker_check_interrupts as worker_check_interrupts, __pkg_riscv_vm_worker_entry as worker_entry };
+  export { type __pkg_riscv_vm_InitInput as InitInput, type __pkg_riscv_vm_InitOutput as InitOutput, __pkg_riscv_vm_JitWorkerContext as JitWorkerContext, __pkg_riscv_vm_NetworkStatus as NetworkStatus, type __pkg_riscv_vm_SyncInitInput as SyncInitInput, __pkg_riscv_vm_WasmVm as WasmVm, __pkg_riscv_vm_WorkerState as WorkerState, __pkg_riscv_vm_WorkerStepResult as WorkerStepResult, __wbg_init as default, __pkg_riscv_vm_initSync as initSync, __pkg_riscv_vm_worker_check_interrupts as worker_check_interrupts, __pkg_riscv_vm_worker_entry as worker_entry };
 }
 
 /**
@@ -406,6 +558,209 @@ declare function isHalted(sharedMem: SharedArrayBuffer): boolean;
 
 declare function WasmInternal(): Promise<typeof __pkg_riscv_vm>;
 
+/**
+ * Message sent to JIT worker to request compilation.
+ */
+interface JitCompileRequest {
+    type: "compile";
+    /** Starting PC of the block */
+    pc: number;
+    /** Bincode-serialized CompileRequest bytes */
+    requestBytes: ArrayBuffer;
+}
+/**
+ *
+ *
+ * Message received from JIT worker with compilation result.
+ */
+interface JitCompileResponse {
+    type: "compiled";
+    /** Starting PC of the compiled block */
+    pc: number;
+    /** Whether compilation succeeded */
+    success: boolean;
+    /** Compiled WASM bytes (if successful) */
+    wasmBytes?: Uint8Array;
+    /** Status if not successful */
+    status?: "unsuitable" | "error";
+    /** Compilation time in microseconds */
+    compileTimeUs?: number;
+}
+/**
+ * JIT worker ready message.
+ */
+interface JitWorkerReadyMessage {
+    type: "ready";
+}
+/**
+ * JIT worker error message.
+ */
+interface JitWorkerErrorMessage {
+    type: "error";
+    message: string;
+}
+/**
+ * All possible JIT worker outbound messages.
+ */
+type JitWorkerOutboundMessage = JitCompileResponse | JitWorkerReadyMessage | JitWorkerErrorMessage;
+/**
+ * All possible JIT worker inbound messages.
+ */
+type JitWorkerInboundMessage = JitCompileRequest;
+/**
+ * Cache statistics from the JIT system.
+ */
+interface JitCacheStats {
+    /** Number of cache hits */
+    hits: number;
+    /** Number of cache misses */
+    misses: number;
+    /** Number of blocks inserted into cache */
+    insertions: number;
+    /** Number of blocks evicted from cache */
+    evictions: number;
+    /** Total bytes of WASM compiled */
+    bytesCompiled: number;
+    /** Number of cache invalidations */
+    invalidations: number;
+}
+/**
+ * Execution trace statistics.
+ */
+interface JitTraceStats {
+    /** Number of JIT block executions */
+    jitExecutions: number;
+    /** Number of interpreter block executions */
+    interpExecutions: number;
+    /** Number of successful compilations */
+    compilations: number;
+    /** Number of failed compilations */
+    compilationFailures: number;
+    /** Total WASM bytes compiled */
+    totalWasmBytes: number;
+    /** Total compilation time in microseconds */
+    totalCompileTimeUs: number;
+    /** Number of traps during JIT execution */
+    traps: number;
+    /** Number of cache invalidations */
+    invalidations: number;
+    /** Number of cache hits */
+    cacheHits: number;
+    /** Number of cache misses */
+    cacheMisses: number;
+    /** Number of interrupt-triggered exits */
+    interruptExits: number;
+}
+/**
+ * Complete JIT diagnostics information.
+ */
+interface JitDiagnostics {
+    /** Whether JIT is currently enabled and operational */
+    enabled: boolean;
+    /** Whether JIT was disabled due to errors */
+    disabledByError: boolean;
+    /** Reason JIT was disabled (if applicable) */
+    disabledReason: string | null;
+    /** Number of consecutive compilation failures */
+    consecutiveFailures: number;
+    /** Total number of compilation failures */
+    totalFailures: number;
+    /** Total number of successful compilations */
+    successfulCompilations: number;
+    /** Number of blocks that failed to compile (blacklisted) */
+    failedBlocksCount: number;
+    /** Number of blocks currently in cache */
+    cacheEntries: number;
+    /** Current cache memory usage in bytes */
+    cacheBytes: number;
+    /** Cache statistics */
+    cacheStats: JitCacheStats;
+    /** Trace statistics */
+    traceStats: JitTraceStats;
+}
+/**
+ * JIT configuration options.
+ */
+interface JitConfig {
+    /** Enable JIT compilation (default: true) */
+    enabled?: boolean;
+    /** Minimum execution count before compiling (default: 50) */
+    compileThreshold?: number;
+    /** Maximum block size in ops (default: 256) */
+    maxBlockSize?: number;
+    /** Maximum WASM module size in bytes (default: 65536) */
+    maxWasmSize?: number;
+    /** Maximum cache entries (default: 1024) */
+    cacheMaxEntries?: number;
+    /** Maximum cache size in bytes (default: 16MB) */
+    cacheMaxBytes?: number;
+    /** Enable debug WAT output to console (default: false) */
+    debugWat?: boolean;
+    /** Enable execution tracing (default: false) */
+    traceEnabled?: boolean;
+    /** Compilation timeout in ms (default: 100, 0=no timeout) */
+    compileTimeoutMs?: number;
+    /** Max consecutive failures before disabling (default: 10) */
+    maxConsecutiveFailures?: number;
+    /** Enable TLB fast-path optimization (default: false) */
+    enableTlbFastPath?: boolean;
+    /** Interrupt check interval in ops (default: 32, 0=disabled) */
+    interruptCheckInterval?: number;
+}
+/**
+ * Extended WasmVm interface with JIT methods.
+ *
+ * This interface extends the base WasmVm class exported from the WASM module
+ * with type definitions for all JIT-related methods.
+ */
+interface WasmVmJitMethods {
+    /** Enable or disable JIT compilation */
+    setJitEnabled(enabled: boolean): void;
+    /** Check if JIT is currently enabled and operational */
+    isJitEnabled(): boolean;
+    /** Re-enable JIT after it was disabled by errors */
+    reenableJit(): void;
+    /** Enable/disable JIT debug WAT output to console */
+    setJitDebug(debug: boolean): void;
+    /** Enable/disable JIT execution tracing */
+    setJitTracing(enabled: boolean): void;
+    /** Check if JIT tracing is enabled */
+    isJitTracingEnabled(): boolean;
+    /** Get JIT diagnostics as JSON string */
+    getJitDiagnostics(): string;
+    /** Get JIT statistics as JSON string */
+    getJitStats(): string;
+    /** Dump recent JIT trace events to console */
+    dumpJitTrace(count?: number): void;
+    /** Clear all entries from JIT cache */
+    clearJitCache(): void;
+    /** Invalidate JIT cache for a specific PC */
+    invalidateJitCacheAt(pc: bigint): boolean;
+    /** Get number of cached JIT blocks */
+    getJitCacheSize(): number;
+    /** Get JIT cache memory usage in bytes */
+    getJitCacheMemoryUsage(): number;
+    /** Set JIT compilation threshold */
+    setJitThreshold(threshold: number): void;
+    /** Get current JIT compilation threshold */
+    getJitThreshold(): number;
+    /** Set maximum block size for JIT compilation */
+    setJitMaxBlockSize(size: number): void;
+    /** Add a PC to the JIT blacklist */
+    blacklistJitBlock(pc: bigint): void;
+    /** Clear the JIT blacklist */
+    clearJitBlacklist(): void;
+    /** Reset all JIT error tracking */
+    resetJitErrors(): void;
+    /** Enable TLB fast-path optimization */
+    setJitTlbFastPath(enabled: boolean): void;
+    /** Set interrupt check interval (0 = disabled) */
+    setJitInterruptCheckInterval(interval: number): void;
+    /** Get JIT execution ratio (0.0 to 1.0) */
+    getJitExecutionRatio(): number;
+    /** Get JIT cache hit ratio (0.0 to 1.0) */
+    getJitCacheHitRatio(): number;
+}
 interface VmOptions {
     /** Number of harts (auto-detected if not specified) */
     harts?: number;
@@ -493,5 +848,35 @@ interface WorkerManager {
  * Create a worker manager for manual worker control.
  */
 declare function createWorkerManager(): WorkerManager;
+/**
+ * Parse JIT diagnostics from the VM.
+ *
+ * @param vm - WasmVm instance with JIT methods
+ * @returns Parsed JIT diagnostics object
+ */
+declare function parseJitDiagnostics(vm: WasmVmJitMethods): JitDiagnostics;
+/**
+ * Parse JIT trace statistics from the VM.
+ *
+ * @param vm - WasmVm instance with JIT methods
+ * @returns Parsed JIT trace statistics object
+ */
+declare function parseJitStats(vm: WasmVmJitMethods): JitTraceStats;
+/**
+ * Configure JIT with a partial configuration object.
+ *
+ * @param vm - WasmVm instance with JIT methods
+ * @param config - Partial JIT configuration
+ */
+declare function configureJit(vm: WasmVmJitMethods, config: JitConfig): void;
+/**
+ * Print JIT diagnostic summary to console.
+ *
+ * Displays a formatted summary of JIT status, compilations,
+ * cache statistics, and hit ratios.
+ *
+ * @param vm - WasmVm instance with JIT methods
+ */
+declare function printJitSummary(vm: WasmVmJitMethods): void;
 
-export { NetworkStatus, REQUIRED_HEADERS, type SharedMemorySupport, type VmOptions, WasmInternal, WasmVm, type WorkerErrorMessage, type WorkerHaltedMessage, type WorkerInitMessage, type WorkerManager, type WorkerOutboundMessage, type WorkerReadyMessage, checkSharedMemorySupport, createVM, createWorkerManager, isCrossOriginIsolated, isHaltRequested, isHalted, requestHalt, runVM };
+export { type JitCacheStats, type JitCompileRequest, type JitCompileResponse, type JitConfig, type JitDiagnostics, type JitTraceStats, type JitWorkerErrorMessage, type JitWorkerInboundMessage, type JitWorkerOutboundMessage, type JitWorkerReadyMessage, NetworkStatus, REQUIRED_HEADERS, type SharedMemorySupport, type VmOptions, WasmInternal, WasmVm, type WasmVmJitMethods, type WorkerErrorMessage, type WorkerHaltedMessage, type WorkerInitMessage, type WorkerManager, type WorkerOutboundMessage, type WorkerReadyMessage, checkSharedMemorySupport, configureJit, createVM, createWorkerManager, isCrossOriginIsolated, isHaltRequested, isHalted, parseJitDiagnostics, parseJitStats, printJitSummary, requestHalt, runVM };