@ai-ecoverse/slicc-kernel 1.41.3 → 1.42.0

package/dist/process-worker.js

@@ -69,6 +69,11 @@ var init_loopback_names = __esm({
 });
 
 // src/kernel/signals.ts
+function defaultAction(sig) {
+  if (sig === SIG.CONT) return "continue";
+  if (STOPPING.has(sig)) return "stop";
+  return IGNORED_BY_DEFAULT.has(sig) ? "ignore" : "terminate";
+}
 function sigbit(sig) {
   return 1 << sig;
 }
@@ -417,6 +422,9 @@ function wasiErrnoOf(code2) {
   if (name === "NOMEDIUM") return E.NODEV;
   return E[name] ?? E.IO;
 }
+function wasixSignal(sig) {
+  return Number.isInteger(sig) && sig >= 1 && sig <= 31 ? sig : void 0;
+}
 var E, FILETYPE, RIGHTS, OFLAGS, FDFLAGS, LOOKUP_SYMLINK_FOLLOW, WHENCE, CLOCK, FSTFLAGS, EVENTTYPE, SUBCLOCK_ABSTIME, EVENT_FD_READWRITE_HANGUP, RIFLAGS, SDFLAGS, PREOPENTYPE_DIR, SIZE, WASI_SIGNAL_TO_POSIX;
 var init_wasi_abi = __esm({
   "src/process/wasi/wasi-abi.ts"() {
@@ -1454,7 +1462,7 @@ var init_sync_sab_wire = __esm({
 });
 
 // src/realm/sync-sab-bridge.ts
-function createSyncSabTransport(sab, port, deps = {}) {
+function createSyncSabTransport(sab, port2, deps = {}) {
   const views = sabViews(sab);
   const { header, window } = views;
   const wait = deps.wait ?? ((a, i, v, t) => Atomics.wait(a, i, v, t));
@@ -1485,8 +1493,8 @@ function createSyncSabTransport(sab, port, deps = {}) {
           Atomics.store(header, SAB_I_STATE, SAB_STATE_PENDING);
           const msg = offset === 0 ? { type: SYNC_SAB_REQ_MSG, id, req } : { type: SYNC_SAB_NEXT_MSG, id, offset };
           try {
-            if (offset === 0 && transfer.length > 0) port.postMessage(msg, transfer);
-            else port.postMessage(msg);
+            if (offset === 0 && transfer.length > 0) port2.postMessage(msg, transfer);
+            else port2.postMessage(msg);
           } catch {
             throw syncError("EIO", label);
           }
@@ -3962,9 +3970,9 @@ function reportGrowth(imports, publish) {
     return grown;
   };
 }
-async function runWasmProcess(init, port, deps = {}) {
+async function runWasmProcess(init, port2, deps = {}) {
   const signals = new SignalGate(
-    createSyncSabTransport(init.sab, port, {
+    createSyncSabTransport(init.sab, port2, {
       memory: () => memory?.buffer.byteLength ?? 0
     }),
     new Int32Array(init.sab, 0, SAB_HEADER_I32),
@@ -6207,18 +6215,18 @@ var init_wasi_module = __esm({
 });
 
 // src/process/wasi/wasi-signals.ts
-var DELIVERED, DELIVERED_MASK, WasiSignals;
+var DELIVERED_MASK, WasiSignals;
 var init_wasi_signals = __esm({
   "src/process/wasi/wasi-signals.ts"() {
     "use strict";
     init_signals();
-    DELIVERED = [SIG.HUP, SIG.INT, SIG.QUIT, SIG.USR1, SIG.USR2, SIG.ALRM, SIG.TERM];
-    DELIVERED_MASK = DELIVERED.reduce((m, sig) => m | sigbit(sig), 0);
+    DELIVERED_MASK = Object.values(SIG).filter((sig) => sig !== SIG.KILL && sig !== SIG.STOP).reduce((m, sig) => m | sigbit(sig), 0);
     WasiSignals = class {
       exports;
       callback;
       uncaught = 0;
       delivering;
+      defaulted = false;
       fallBack;
       onKilled;
       constructor(fallBack, onKilled) {
@@ -6241,25 +6249,29 @@ var init_wasi_signals = __esm({
       raise(sig) {
         const handler = this.handler();
         if (!handler) return;
-        const outer = this.delivering;
+        const outer = { sig: this.delivering, defaulted: this.defaulted };
         this.delivering = sig;
+        this.defaulted = false;
         try {
           handler(sig);
         } catch (e) {
           if (!(e instanceof WebAssembly.RuntimeError)) throw e;
-          this.defaultAction(sig);
+          if (!this.defaulted) this.defaultAction(sig);
         } finally {
-          this.delivering = outer;
+          this.delivering = outer.sig;
+          this.defaulted = outer.defaulted;
         }
       }
       raised(sig) {
         if (sig !== SIG.ABRT || this.delivering === void 0) return false;
-        this.defaultAction(this.delivering);
+        if (!this.defaulted) this.defaultAction(this.delivering);
         return true;
       }
       defaultAction(sig) {
+        this.defaulted = true;
         this.uncaught |= sigbit(sig);
         this.fallBack(sig);
+        if (defaultAction(sig) !== "terminate") this.uncaught &= ~sigbit(sig);
       }
       handler() {
         const fn = this.callback ? this.exports?.[this.callback] : void 0;
@@ -6350,8 +6362,8 @@ var init_wasi_threads = __esm({
       memory;
       cap;
       tid;
-      constructor(port, memory, cap, tid, ids) {
-        this.port = port;
+      constructor(port2, memory, cap, tid, ids) {
+        this.port = port2;
         this.memory = memory;
         this.cap = cap;
         this.tid = tid;
@@ -6900,17 +6912,13 @@ var init_physical_path = __esm({
 function resolveFrom(cwd, path) {
   return normalize(path.startsWith("/") ? path : `${cwd}/${path}`);
 }
-var POSIX_TO_WASI_SIGNAL, O_WRONLY5, O_RDWR5, O_APPEND2, OFLAG_CREAT, OFLAG_TRUNC, WasixProcess;
+var O_WRONLY5, O_RDWR5, O_APPEND2, OFLAG_CREAT, OFLAG_TRUNC, WasixProcess;
 var init_wasix_process = __esm({
   "src/process/wasi/wasix-process.ts"() {
     "use strict";
     init_physical_path();
-    init_wasi_abi();
     init_wasi_files();
     init_wasi_host();
-    POSIX_TO_WASI_SIGNAL = Object.fromEntries(
-      Object.entries(WASI_SIGNAL_TO_POSIX).map(([wasi, posix]) => [posix, Number(wasi)])
-    );
     O_WRONLY5 = 1;
     O_RDWR5 = 2;
     O_APPEND2 = 1024;
@@ -7046,7 +7054,7 @@ var init_wasix_process = __esm({
         const sig = status2 & 127;
         if (sig) {
           v.setUint8(statusPtr, 2);
-          v.setUint8(statusPtr + 4, POSIX_TO_WASI_SIGNAL[sig] ?? sig);
+          v.setUint8(statusPtr + 4, sig);
         } else {
           v.setUint8(statusPtr, 1);
           v.setUint16(statusPtr + 2, status2 >> 8 & 255, true);
@@ -7153,13 +7161,13 @@ function readAddr(view, ptr) {
     );
     return { family: "unix", path };
   }
-  const port = view.getUint16(ptr + 2, true);
+  const port2 = view.getUint16(ptr + 2, true);
   if (tag === INET4) {
     const host = [0, 1, 2, 3].map((i) => view.getUint8(ptr + 4 + i)).join(".");
-    return { family: "inet", host, port };
+    return { family: "inet", host, port: port2 };
   }
   if (tag === INET6) {
-    return { family: "inet", host: ipv6Host(new Uint8Array(view.buffer, ptr + 4, 16)), port };
+    return { family: "inet", host: ipv6Host(new Uint8Array(view.buffer, ptr + 4, 16)), port: port2 };
   }
   throw new WasiError("EAFNOSUPPORT");
 }
@@ -7355,7 +7363,7 @@ var init_wasix_sockets = __esm({
 
 // src/process/wasi/wasix-host.ts
 function posixSignal(sig) {
-  const posix = WASI_SIGNAL_TO_POSIX[sig];
+  const posix = wasixSignal(sig);
   if (posix === void 0) throw new WasiError("EINVAL");
   return posix;
 }
@@ -7558,7 +7566,7 @@ var init_wasix_host = __esm({
           stack_restore: (snapPtr, val) => void this.driver.restore(snapPtr, val),
           proc_join: (pidPtr, flags, statusPtr) => void process.join(pidPtr, flags, statusPtr),
           proc_signal: (pid, sig) => {
-            const posix = sig === 0 ? 0 : WASI_SIGNAL_TO_POSIX[sig];
+            const posix = sig === 0 ? 0 : wasixSignal(sig);
             if (posix === void 0) throw new WasiError("EINVAL");
             if (pid === this.host.o.pid && posix !== 0 && this.host.onRaise?.(posix)) return;
             this.host.o.kernel.call({ op: "proc-kill", pid, sig: posix });
@@ -7659,8 +7667,7 @@ var init_wasix_host = __esm({
           },
           thread_signal: (tid, sig) => {
             if (!(this.threads?.known(tid) ?? tid === MAIN_TID)) throw new WasiError("ESRCH");
-            const posix = WASI_SIGNAL_TO_POSIX[sig];
-            if (posix === void 0) throw new WasiError("EINVAL");
+            const posix = posixSignal(sig);
             if (host.onRaise?.(posix)) return;
             host.o.kernel.call({ op: "proc-kill", pid: host.o.pid, sig: posix });
           },
@@ -7919,10 +7926,10 @@ function sizeOf(main) {
 function memoryOf(instance, imported) {
   return imported ?? instance.exports.memory;
 }
-function kernelOf(init, port, hooks = { masks: () => null, raise: () => {
+function kernelOf(init, port2, hooks = { masks: () => null, raise: () => {
 } }, memory) {
   const transport = new SignalGate(
-    createSyncSabTransport(init.sab, port, memory ? { memory } : {}),
+    createSyncSabTransport(init.sab, port2, memory ? { memory } : {}),
     new Int32Array(init.sab, 0, SAB_HEADER_I32),
     hooks
   ).transport();
@@ -8046,19 +8053,19 @@ function descriptors(init, fork, threads) {
   if (fork) return { forked: { fds: fork.fds, cloexec: fork.cloexec } };
   return { inherited: init.fds ?? [], ...init.program.preopenRoot ? { preopenRoot: true } : {} };
 }
-async function runWasiProcess(init, port) {
+async function runWasiProcess(init, port2) {
   captureBacktraces(init.env);
   const signals = new WasiSignals(
     (sig) => {
       call2({ op: "proc-kill", pid: init.pid, sig });
-      throw new WasiExit(128 + sig);
+      if (defaultAction(sig) === "terminate") throw new WasiExit(128 + sig);
     },
     (code2) => {
       throw new WasiExit(code2);
     }
   );
   const main = {};
-  const { transport, sys, call: kernelCall, say } = kernelOf(init, port, signals, sizeOf(main));
+  const { transport, sys, call: kernelCall, say } = kernelOf(init, port2, signals, sizeOf(main));
   const id = identify(transport, init);
   const stats = init.env.SLICC_WASI_STATS === "1" ? new WasiStats() : void 0;
   const call2 = stats ? timedCalls(stats, kernelCall) : kernelCall;
@@ -8075,7 +8082,7 @@ async function runWasiProcess(init, port) {
   }
   const fork = init.fork?.wasi;
   const memory = createImportedMemory(init.program.memory, fork ? init.fork?.memory : void 0);
-  const threads = memory?.buffer instanceof SharedArrayBuffer && spawnsThreads(module) ? new WasiThreads(port, memory, threadCap(init.env), MAIN_TID) : void 0;
+  const threads = memory?.buffer instanceof SharedArrayBuffer && spawnsThreads(module) ? new WasiThreads(port2, memory, threadCap(init.env), MAIN_TID) : void 0;
   const host = new WasiHost({
     args: [init.argv0, ...init.args],
     env: init.env,
@@ -8150,11 +8157,11 @@ function captureBacktraces(env) {
   const v8 = Error;
   v8.stackTraceLimit = Math.max(v8.stackTraceLimit ?? 0, BACKTRACE_FRAMES + 20);
 }
-async function runWasiThread(init, port) {
+async function runWasiThread(init, port2) {
   captureBacktraces(init.env);
-  const { transport, sys, call: call2, say } = kernelOf(init, port);
+  const { transport, sys, call: call2, say } = kernelOf(init, port2);
   const { thread } = init;
-  const threads = new WasiThreads(port, thread.memory, threadCap(init.env), thread.tid, thread.ids);
+  const threads = new WasiThreads(port2, thread.memory, threadCap(init.env), thread.tid, thread.ids);
   threads.received = thread.modules;
   const id = identify(transport, init);
   const host = new WasiHost({
@@ -8184,7 +8191,7 @@ async function runWasiThread(init, port) {
       return;
     }
     if (e instanceof WasiExit) {
-      port.postMessage({ type: WASM_PROCESS_EXIT, code: e.code });
+      port2.postMessage({ type: WASM_PROCESS_EXIT, code: e.code });
       return;
     }
     if (e instanceof WebAssembly.RuntimeError) {
@@ -8192,7 +8199,7 @@ async function runWasiThread(init, port) {
         say(trapMessage(e, init.env, ` in thread ${thread.tid}`, programNames(host, init.program)));
       } catch {
       }
-      port.postMessage({ type: WASM_PROCESS_EXIT, code: TRAPPED });
+      port2.postMessage({ type: WASM_PROCESS_EXIT, code: TRAPPED });
       return;
     }
     throw e;
@@ -8203,6 +8210,7 @@ var init_wasi_runtime = __esm({
   "src/process/wasi/wasi-runtime.ts"() {
     "use strict";
     init_protocol();
+    init_signals();
     init_sync_sab_bridge();
     init_sync_sab_wire();
     init_kernel_streams();
@@ -8279,7 +8287,7 @@ async function changed(header, index2, seen, waitAsync = defaultWaitAsync) {
   const waited = waitAsync(header, index2, seen);
   if (waited.async) await waited.value;
 }
-function createAsyncSabTransport(sab, port, waitAsync = defaultWaitAsync) {
+function createAsyncSabTransport(sab, port2, waitAsync = defaultWaitAsync) {
   const { header, window } = sabViews(sab);
   let seq = 0;
   let tail = Promise.resolve();
@@ -8301,7 +8309,7 @@ function createAsyncSabTransport(sab, port, waitAsync = defaultWaitAsync) {
     try {
       for (; ; ) {
         Atomics.store(header, SAB_I_STATE, SAB_STATE_PENDING);
-        port.postMessage(
+        port2.postMessage(
           offset === 0 ? { type: SYNC_SAB_REQ_MSG, id, req } : { type: SYNC_SAB_NEXT_MSG, id, offset }
         );
         await ready(id);
@@ -8706,6 +8714,145 @@ var init_js_io = __esm({
   }
 });
 
+// src/process/js/js-net.ts
+function errnoName(errno2) {
+  const found = Object.entries(E).find(([, n]) => n === errno2);
+  return found ? `E${found[0]}` : "EIO";
+}
+function addressOf(addr) {
+  const inet = addr;
+  return { host: inet.host, port: inet.port };
+}
+function port(n) {
+  if (!Number.isInteger(n) || n < 0 || n > 65535) throw new JsCallError("EINVAL", `port ${n}`);
+  return n;
+}
+function netOps(kernel, io) {
+  const name = async (fd, peer) => addressOf(await kernel.json({ op: "sock-name", fd, peer }));
+  const connection = async (fd) => {
+    const [local, remote] = [await name(fd, false), await name(fd, true)];
+    const stop = new AbortController();
+    let closed;
+    const close = () => {
+      stop.abort(new JsCallError("EBADF", "socket closed"));
+      closed ??= io.close(fd);
+      return closed;
+    };
+    const shut = (how) => kernel.raw({ op: "sock-shutdown", fd, how });
+    const readable2 = new ReadableStream(
+      {
+        async pull(controller) {
+          const chunk = await io.read(fd, void 0, stop.signal);
+          if (chunk.length > 0) controller.enqueue(chunk);
+          else controller.close();
+        },
+        cancel: async () => void await shut(SHUT_RD)
+      },
+      { highWaterMark: 0 }
+    );
+    const writable2 = new WritableStream({
+      write: (chunk, controller) => io.send(fd, chunk, AbortSignal.any([controller.signal, stop.signal])),
+      close: async () => void await shut(SHUT_WR),
+      abort: () => close()
+    });
+    return { fd, local, remote, readable: readable2, writable: writable2, close };
+  };
+  const resolve = async (host, signal) => {
+    if (IPV4.test(host)) return host;
+    const r = await kernel.blocking({ op: "sock-resolve", name: host, family: 4 }, signal);
+    return (r.ok && r.kind === "json" ? r.json : [])[0];
+  };
+  const opened = async (use) => {
+    const fd = await kernel.json({ op: "sock-open", domain: "inet" });
+    try {
+      return await use(fd);
+    } catch (err) {
+      await io.close(fd);
+      throw err;
+    }
+  };
+  const listener = (fd, at) => {
+    const stop = new AbortController();
+    const accept = async (options = {}) => {
+      const signal = AbortSignal.any([options.signal ?? NEVER, stop.signal]);
+      for (; ; ) {
+        signal.throwIfAborted();
+        const r = await kernel.raw({ op: "sock-accept", fd, nonblock: true });
+        if (r.ok) return connection((r.kind === "json" ? r.json : {}).fd);
+        if (r.errno !== "EAGAIN") throw new JsCallError(r.errno, "accept");
+        await kernel.blocking({ op: "fd-select", read: [fd], write: [], timeoutMs: -1 }, signal);
+      }
+    };
+    return {
+      fd,
+      ...at,
+      accept,
+      async close() {
+        stop.abort(new JsCallError("EBADF", "listener closed"));
+        await io.close(fd);
+      },
+      async *[Symbol.asyncIterator]() {
+        for (; ; ) {
+          try {
+            yield await accept();
+          } catch (err) {
+            if (stop.signal.aborted) return;
+            throw err;
+          }
+        }
+      }
+    };
+  };
+  return {
+    listen: (options = {}) => opened(async (fd) => {
+      const addr = {
+        family: "inet",
+        host: options.host ?? "127.0.0.1",
+        port: port(options.port ?? 0)
+      };
+      await kernel.call({ op: "sock-bind", fd, addr });
+      await kernel.call({ op: "sock-listen", fd, backlog: options.backlog ?? 128 });
+      return listener(fd, await name(fd, false));
+    }),
+    connect: async (options) => {
+      const signal = options.signal ?? NEVER;
+      signal.throwIfAborted();
+      const addr = {
+        family: "inet",
+        host: await resolve(options.host, signal),
+        port: port(options.port)
+      };
+      return opened(async (fd) => {
+        const r = await kernel.raw({ op: "sock-connect", fd, addr, nonblock: true });
+        if (!r.ok && r.errno !== "EINPROGRESS") throw new JsCallError(r.errno, "connect");
+        await kernel.blocking({ op: "fd-select", read: [], write: [fd], timeoutMs: -1 }, signal);
+        const failed2 = await kernel.json({
+          op: "sock-getopt",
+          fd,
+          level: SOL_SOCKET,
+          name: SO_ERROR
+        });
+        if (failed2 !== 0) throw new JsCallError(errnoName(failed2), "connect");
+        return connection(fd);
+      });
+    }
+  };
+}
+var SHUT_RD, SHUT_WR, IPV4, NEVER, SOL_SOCKET, SO_ERROR;
+var init_js_net = __esm({
+  "src/process/js/js-net.ts"() {
+    "use strict";
+    init_wasi_abi();
+    init_js_kernel();
+    SHUT_RD = 0;
+    SHUT_WR = 1;
+    IPV4 = /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/;
+    NEVER = new AbortController().signal;
+    SOL_SOCKET = 1;
+    SO_ERROR = 4;
+  }
+});
+
 // src/process/js/js-sync.ts
 function laneOf(lane) {
   if (!lane) return () => ({ ok: false, errno: "ENOSYS", message: "no sync lane" });
@@ -9048,11 +9195,8 @@ function createContext(o) {
     infos,
     handles
   });
-  const children = childOps(
-    kernel,
-    { read, send: writeAll, close: (fd) => ctx.close(fd) },
-    { env: o.env, cwd: o.cwd, signal: signalNumber }
-  );
+  const io = { read, send: writeAll, close: (fd) => ctx.close(fd) };
+  const children = childOps(kernel, io, { env: o.env, cwd: o.cwd, signal: signalNumber });
   const ctx = {
     argv: o.argv,
     env: o.env,
@@ -9096,6 +9240,7 @@ function createContext(o) {
     },
     sync,
     ...children,
+    net: netOps(kernel, io),
     exit
   };
   const drain2 = async () => {
@@ -9231,6 +9376,7 @@ var init_js_context = __esm({
     init_js_children();
     init_js_io();
     init_js_kernel();
+    init_js_net();
     init_js_sync();
     JsExit = class extends Error {
       status;
@@ -9338,8 +9484,8 @@ function mainOf(module) {
   const main = typeof module.default === "function" ? module.default : module.main;
   return typeof main === "function" ? main : void 0;
 }
-async function runJsProcess(init, port, deps = {}) {
-  const transport = createAsyncSabTransport(init.sab, port, deps.waitAsync);
+async function runJsProcess(init, port2, deps = {}) {
+  const transport = createAsyncSabTransport(init.sab, port2, deps.waitAsync);
   let resolveExit;
   const exit = new Promise((resolve) => resolveExit = resolve);
   let exitedWith;
@@ -9418,29 +9564,29 @@ init_protocol();
 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));
-function started(init, port, run, wasi, js) {
+function started(init, port2, run, wasi, js) {
   if (init.program?.abi === "js") {
     const jsInit = init;
-    return js().then((m) => m.runJsProcess(jsInit, port));
+    return js().then((m) => m.runJsProcess(jsInit, port2));
   }
   const wasmInit = init;
-  if (wasmInit.program?.abi === "wasi") return wasi().then((m) => m.runWasiProcess(wasmInit, port));
-  return run(wasmInit, port);
+  if (wasmInit.program?.abi === "wasi") return wasi().then((m) => m.runWasiProcess(wasmInit, port2));
+  return run(wasmInit, port2);
 }
-function processEntry(port, run = runWasmProcess, wasi = loadWasi, js = loadJs) {
-  const failed2 = (err) => port.postMessage({
+function processEntry(port2, run = runWasmProcess, wasi = loadWasi, js = loadJs) {
+  const failed2 = (err) => port2.postMessage({
     type: WASM_PROCESS_ERROR,
     message: err instanceof Error ? err.stack ?? err.message : String(err)
   });
   return (data) => {
     const type = data?.type;
     if (type === WASM_THREAD_INIT) {
-      wasi().then((m) => m.runWasiThread(data, port)).catch(failed2);
+      wasi().then((m) => m.runWasiThread(data, port2)).catch(failed2);
       return;
     }
     if (type !== WASM_PROCESS_INIT) return;
-    started(data, port, run, wasi, js).then(
-      (code2) => port.postMessage({ type: WASM_PROCESS_EXIT, code: code2 }),
+    started(data, port2, run, wasi, js).then(
+      (code2) => port2.postMessage({ type: WASM_PROCESS_EXIT, code: code2 }),
       failed2
     );
   };