@ai-ecoverse/slicc-kernel 1.129.0 → 1.130.0

package/dist/process-worker.js

@@ -254,7 +254,7 @@ var init_cpu_clock = __esm({
 });
 
 // src/kernel/protocol.ts
-var WASM_PROCESS_INIT, WASM_PROCESS_EXIT, WASM_PROCESS_ERROR, WASM_PROCESS_READY, WASM_THREAD_SPAWN, WASM_THREAD_INIT, WASM_THREAD_EXIT, WASM_MAX_THREADS, WASM_DEFAULT_THREADS;
+var WASM_PROCESS_INIT, WASM_PROCESS_EXIT, WASM_PROCESS_ERROR, WASM_PROCESS_READY, WASM_THREAD_SPAWN, WASM_THREAD_INIT, WASM_THREAD_EXIT, WASM_MAX_THREADS, WASM_DEFAULT_THREADS, JS_THREAD_SPAWN, JS_THREAD_INIT, JS_THREAD_EXIT, JS_THREAD_NO_MEMORY, JS_THREAD_CRASHED;
 var init_protocol = __esm({
   "src/kernel/protocol.ts"() {
     "use strict";
@@ -267,6 +267,11 @@ var init_protocol = __esm({
     WASM_THREAD_EXIT = "wasm-thread-exit";
     WASM_MAX_THREADS = 256;
     WASM_DEFAULT_THREADS = 64;
+    JS_THREAD_SPAWN = "js-thread-spawn";
+    JS_THREAD_INIT = "js-thread-init";
+    JS_THREAD_EXIT = "js-thread-exit";
+    JS_THREAD_NO_MEMORY = 256;
+    JS_THREAD_CRASHED = 257;
   }
 });
 
@@ -2659,7 +2664,7 @@ var KERNEL_VERSION, OS_RELEASE;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    KERNEL_VERSION = true ? "1.129.0" : "0.0.0-dev";
+    KERNEL_VERSION = true ? "1.130.0" : "0.0.0-dev";
     OS_RELEASE = "6.0.0-slicc";
   }
 });
@@ -17280,9 +17285,7 @@ function createContext(o) {
     argv: o.argv,
     env: o.env,
     pid: o.pid,
-    async ppid() {
-      return identityOf(await kernel.json({ op: "proc-identity" }), o).ppid;
-    },
+    ppid: async () => identityOf(await kernel.json({ op: "proc-identity" }), o).ppid,
     cwd: o.cwd,
     stdin: readable2(read2),
     stdout: writable2(1),
@@ -17327,6 +17330,7 @@ function createContext(o) {
     websocket: websocketOp(kernel),
     tty: terminal.tty,
     exit,
+    thread: o.thread,
     onUncaught: (listener) => listen(strays.exception, listener),
     onUnhandledRejection: (listener) => listen(strays.rejection, listener)
   };
@@ -17558,11 +17562,100 @@ var init_js_context = __esm({
   }
 });
 
+// src/process/js/js-thread.ts
+function outOfMemory(err) {
+  return err instanceof RangeError && OOM.test(err.message);
+}
+function optionsOf(options) {
+  if (options === void 0) return {};
+  if (typeof options !== "object" || options === null || Array.isArray(options)) {
+    throw new JsCallError("EINVAL", "thread.spawn");
+  }
+  const { transfer } = options;
+  if (transfer !== void 0 && !Array.isArray(transfer)) {
+    throw new JsCallError("EINVAL", "thread.spawn");
+  }
+  return options;
+}
+function started(port2, control) {
+  const exited = Promise.withResolvers();
+  return new Promise((resolve, reject) => {
+    const thread = (tid) => Object.freeze({
+      tid,
+      port: port2,
+      exited: exited.promise,
+      async terminate() {
+        control.postMessage({ terminate: true });
+        await exited.promise;
+      }
+    });
+    control.onmessage = (event) => {
+      const said = event.data;
+      if ("tid" in said) resolve(thread(said.tid));
+      else if ("errno" in said) {
+        control.close();
+        port2.close();
+        reject(new JsCallError(said.errno, "thread.spawn", said.message));
+      } else if ("exited" in said) {
+        control.close();
+        exited.resolve(said.exited);
+      }
+    };
+  });
+}
+function threadContext(post2, start2) {
+  const spawn = (options) => {
+    let asked;
+    try {
+      asked = optionsOf(options);
+    } catch (err) {
+      return Promise.reject(err);
+    }
+    const channel = new NativeChannel();
+    const control = new NativeChannel();
+    const transfer = [...asked.transfer ?? []];
+    const msg = {
+      type: JS_THREAD_SPAWN,
+      data: asked.data,
+      port: channel.port2,
+      control: control.port2,
+      transfer
+    };
+    try {
+      post2.postMessage(msg, [channel.port2, control.port2, ...transfer]);
+    } catch (err) {
+      channel.port1.close();
+      control.port1.close();
+      return Promise.reject(err);
+    }
+    return started(channel.port1, control.port1);
+  };
+  return Object.freeze({
+    tid: start2?.tid ?? 0,
+    port: start2?.port,
+    data: start2?.data,
+    NO_MEMORY: JS_THREAD_NO_MEMORY,
+    CRASHED: JS_THREAD_CRASHED,
+    spawn
+  });
+}
+var NativeChannel, OOM;
+var init_js_thread = __esm({
+  "src/process/js/js-thread.ts"() {
+    "use strict";
+    init_protocol();
+    init_js_kernel();
+    NativeChannel = globalThis.MessageChannel;
+    OOM = /out of memory|Array buffer allocation failed|Cannot allocate Wasm memory/i;
+  }
+});
+
 // src/process/js/js-runtime.ts
 var js_runtime_exports = {};
 __export(js_runtime_exports, {
   mainOf: () => mainOf,
   runJsProcess: () => runJsProcess,
+  runJsThread: () => runJsThread,
   trapStrays: () => trapStrays
 });
 function trapStrays(scope2, stray) {
@@ -17593,7 +17686,15 @@ function mainOf(module) {
   const main = typeof module.default === "function" ? module.default : module.main;
   return typeof main === "function" ? main : void 0;
 }
-async function runJsProcess(init, port2, deps = {}) {
+function runJsProcess(init, port2, deps = {}) {
+  return runJs(init, port2, deps, void 0);
+}
+function runJsThread(init, port2, deps = {}) {
+  const { thread, ...rest2 } = init;
+  return runJs(rest2, port2, deps, thread);
+}
+async function runJs(init, port2, deps, thread) {
+  const failed5 = (err) => thread && outOfMemory(err) ? JS_THREAD_NO_MEMORY : 1;
   const transport = createAsyncSabTransport(init.sab, port2, deps.waitAsync);
   let resolveExit;
   const exit = new Promise((resolve) => resolveExit = resolve);
@@ -17605,7 +17706,7 @@ async function runJsProcess(init, port2, deps = {}) {
   let failing;
   const fail = (err) => {
     if (err instanceof JsExit) return;
-    failing ??= say(message(err)).then(() => exited(1));
+    failing ??= (thread ? Promise.resolve() : say(message(err))).then(() => exited(failed5(err)));
   };
   const kernel = new JsKernel({
     sab: init.sab,
@@ -17626,7 +17727,8 @@ async function runJsProcess(init, port2, deps = {}) {
     cwd: init.cwd,
     exit: (status3) => exited(statusOf(status3)),
     lane: laneOf(init.lane),
-    strays
+    strays,
+    thread: threadContext(port2, thread)
   });
   const say = (text) => ctx.write(2, `${init.argv0}: ${text}
 `).catch(() => void 0);
@@ -17657,8 +17759,8 @@ async function runJsProcess(init, port2, deps = {}) {
   const program = main;
   const ran = Promise.resolve().then(() => program(ctx)).then(statusOf, async (err) => {
     if (err instanceof JsExit) return err.status;
-    await say(message(err));
-    return 1;
+    if (!thread) await say(message(err));
+    return failed5(err);
   });
   const status2 = await Promise.race([ran, exit]);
   await drain2();
@@ -17671,11 +17773,13 @@ var NOT_RUNNABLE;
 var init_js_runtime = __esm({
   "src/process/js/js-runtime.ts"() {
     "use strict";
+    init_protocol();
     init_wasi_imports();
     init_async_sab();
     init_js_context();
     init_js_kernel();
     init_js_sync();
+    init_js_thread();
     init_lockdown();
     NOT_RUNNABLE = 126;
   }
@@ -17691,7 +17795,7 @@ init_process_runtime();
 var loadWasi = () => Promise.resolve().then(() => (init_wasi_runtime(), wasi_runtime_exports));
 var loadJs = () => Promise.resolve().then(() => (init_js_runtime(), js_runtime_exports));
 var NOT_RUNNABLE2 = 126;
-function started(init, port2, run, wasi, js) {
+function started2(init, port2, run, wasi, js) {
   if (init.program?.abi === "js") {
     const jsInit = init;
     return js().then((m) => m.runJsProcess(jsInit, port2));
@@ -17721,8 +17825,19 @@ function processEntry(port2, run = runWasmProcess, wasi = loadWasi, js = loadJs,
   };
   return (data) => {
     const type = data?.type;
-    if (type !== WASM_THREAD_INIT && type !== WASM_PROCESS_INIT) return;
+    if (type !== WASM_THREAD_INIT && type !== WASM_PROCESS_INIT && type !== JS_THREAD_INIT) return;
     const refusal2 = sealOnce();
+    if (type === JS_THREAD_INIT) {
+      if (refusal2) return failed5(refusal2.error);
+      js().then((m) => {
+        if (!m.runJsThread) throw new Error("this process worker runs no JS threads");
+        return m.runJsThread(data, port2);
+      }).then(
+        (code2) => port2.postMessage({ type: JS_THREAD_EXIT, code: code2 }),
+        failed5
+      );
+      return;
+    }
     const init = data;
     if (type === WASM_THREAD_INIT || init?.program?.abi !== "js") useLocalClock(init?.sab);
     if (type === WASM_THREAD_INIT) {
@@ -17731,7 +17846,7 @@ function processEntry(port2, run = runWasmProcess, wasi = loadWasi, js = loadJs,
       return;
     }
     if (refusal2) return failed5(refusal2.error, NOT_RUNNABLE2);
-    started(data, port2, run, wasi, js).then(
+    started2(data, port2, run, wasi, js).then(
       (code2) => port2.postMessage({ type: WASM_PROCESS_EXIT, code: code2 }),
       failed5
     );
@@ -17743,7 +17858,7 @@ init_process_fds();
 var scope = globalThis;
 var post = scope.postMessage.bind(scope);
 var onMessage = processEntry(
-  { postMessage: (message2) => post(message2) },
+  { postMessage: (message2, transfer) => post(message2, transfer ?? []) },
   void 0,
   void 0,
   void 0,