virtual-machine 0.0.36 → 0.0.37

package/build/node-worker.js

@@ -0,0 +1,120 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node-worker.ts
+var import_node_worker_threads = require("worker_threads");
+var import_node_fs = __toESM(require("fs"));
+var WorkerStepResult = {
+  Continue: 0,
+  Halted: 1,
+  Shutdown: 2,
+  Error: 3
+};
+var CTRL_HALT_REQUESTED = 0;
+var controlView = null;
+var workerState = null;
+var BATCH_SIZE = 1e5;
+var BATCHES_PER_YIELD = 10;
+function postMessage(msg) {
+  import_node_worker_threads.parentPort?.postMessage(msg);
+}
+function runLoop(hartId) {
+  if (!workerState || !controlView) {
+    console.error("[Worker] runLoop called without workerState or controlView");
+    return;
+  }
+  let shouldContinue = true;
+  let batchCount = 0;
+  while (shouldContinue) {
+    const result = workerState.step_batch(BATCH_SIZE);
+    switch (result) {
+      case WorkerStepResult.Continue:
+        batchCount++;
+        if (batchCount >= BATCHES_PER_YIELD) {
+          batchCount = 0;
+          try {
+            Atomics.wait(controlView, CTRL_HALT_REQUESTED, 0, 0);
+          } catch {
+          }
+        }
+        break;
+      case WorkerStepResult.Halted:
+        console.log(`[Worker ${hartId}] Halted after ${workerState.step_count()} steps`);
+        postMessage({ type: "halted", hartId, stepCount: Number(workerState.step_count()) });
+        cleanup();
+        shouldContinue = false;
+        break;
+      case WorkerStepResult.Shutdown:
+        console.log(`[Worker ${hartId}] Shutdown after ${workerState.step_count()} steps`);
+        postMessage({ type: "halted", hartId, stepCount: Number(workerState.step_count()) });
+        cleanup();
+        shouldContinue = false;
+        break;
+      case WorkerStepResult.Error:
+        console.error(`[Worker ${hartId}] Error after ${workerState.step_count()} steps`);
+        postMessage({ type: "error", hartId, error: "Execution error" });
+        cleanup();
+        shouldContinue = false;
+        break;
+    }
+  }
+}
+function cleanup() {
+  workerState = null;
+  controlView = null;
+}
+async function main() {
+  const { hartId, sharedMem, entryPc, wasmPath } = import_node_worker_threads.workerData;
+  console.log(`[Worker ${hartId}] Starting with WASM from ${wasmPath}`);
+  try {
+    const wasmBytes = import_node_fs.default.readFileSync(wasmPath);
+    const jsPath = wasmPath.replace("_bg.wasm", ".js");
+    const wasmModule = await import(jsPath);
+    wasmModule.initSync(wasmBytes);
+    console.log(`[Worker ${hartId}] WASM initialized`);
+    if (!(sharedMem instanceof SharedArrayBuffer)) {
+      throw new Error("sharedMem must be a SharedArrayBuffer");
+    }
+    postMessage({ type: "ready", hartId });
+    const pc = BigInt(Math.floor(entryPc));
+    console.log(`[Worker ${hartId}] Starting execution at PC=0x${pc.toString(16)}`);
+    controlView = new Int32Array(sharedMem);
+    workerState = new wasmModule.WorkerState(hartId, sharedMem, pc);
+    runLoop(hartId);
+  } catch (e) {
+    console.error(`[Worker ${hartId}] Error:`, e);
+    postMessage({
+      type: "error",
+      hartId,
+      error: String(e)
+    });
+  }
+}
+main().catch((e) => {
+  console.error("[Worker] Fatal error:", e);
+  postMessage({
+    type: "error",
+    error: String(e)
+  });
+});

package/build/{riscv_vm-HSOJGHGR.mjs → riscv_vm-RB3UJCQZ.mjs}

@@ -7,7 +7,7 @@ import {
   riscv_vm_default,
   worker_check_interrupts,
   worker_entry
-} from "./chunk-YJ5P3VGQ.mjs";
+} from "./chunk-ASAZFOYQ.mjs";
 export {
   NetworkStatus,
   WasmVm,