@ai-ecoverse/slicc-kernel 1.46.1 → 1.47.1

package/dist/node.js

@@ -9174,6 +9174,7 @@ var SYSCALL_OPS = /* @__PURE__ */ new Set([
   "proc-captured",
   "proc-fork",
   "proc-kill",
+  "thread-kill",
   "proc-list",
   "mount-list",
   "mount",
@@ -9338,14 +9339,14 @@ var WasmProcess = class {
       if (isFdSyscall(req)) return await this.fdSyscall(req, cancelled);
       if (isTtySyscall(req)) return this.ttySyscall(req);
       if (isJobSyscall(req)) return this.jobSyscall(req);
-      if (isSocketSyscall(req)) return await this.socketSyscall(req);
+      if (isSocketSyscall(req)) return await this.socketSyscall(req, cancelled);
       if (isHttpSyscall(req)) return await this.httpSyscall(req);
       if (isHostSyscall(req)) {
         return await hostSyscall(req, {
           pid: this.pid,
           locks: this.options.locks,
           ops: this.asyncOps,
-          blocking: () => this.blockingSignal(),
+          blocking: () => this.blockingSignal(cancelled),
           valid: (inner) => isWasmSyscall(inner) && !isHostSyscall(inner)
         });
       }
@@ -9353,7 +9354,7 @@ var WasmProcess = class {
         const { ptys, jobs } = this.options;
         return ptySyscall(req, { pid: this.pid, fds: this.fds, ptys, jobs });
       }
-      return await this.procSyscall(req);
+      return await this.procSyscall(req, cancelled);
     } catch (e) {
       if (e instanceof KernelError || e instanceof SpawnError) {
         return { ok: false, errno: e.code, message: e.code };
@@ -9368,11 +9369,11 @@ var WasmProcess = class {
   refuseIfPending(restart) {
     if (restart && this.options.hasPending?.()) throw new KernelError("EINTR");
   }
-  blockingSignal() {
-    if (this.options.hasPending?.()) throw new KernelError("EINTR");
-    return this.interrupt.signal;
+  blockingSignal(cancelled) {
+    if (this.options.hasPending?.() || cancelled?.aborted) throw new KernelError("EINTR");
+    return cancelled ? AbortSignal.any([this.interrupt.signal, cancelled]) : this.interrupt.signal;
   }
-  async read(req) {
+  async read(req, cancelled) {
     const file = this.fds.get(req.fd).file;
     const read = req.peek ? file.peek : file.read;
     if (!read) throw new KernelError(req.peek && file.read ? "EOPNOTSUPP" : "EBADF");
@@ -9381,15 +9382,15 @@ var WasmProcess = class {
     if (file instanceof KernelSocket && file.unconnected) throw new KernelError("ENOTCONN");
     const ready2 = pollFile(file).readable;
     if (!ready2 && req.nonblock) throw new KernelError("EAGAIN");
-    const signal = ready2 ? this.interrupt.signal : this.blockingSignal();
+    const signal = ready2 ? this.interrupt.signal : this.blockingSignal(cancelled);
     return read.call(file, Math.max(0, Math.min(req.max, MAX_READ)), signal);
   }
-  async write(fd, body, nonblock = false) {
+  async write(fd, body, nonblock = false, cancelled) {
     const file = this.fds.get(fd).file;
     if (!file.write) throw new KernelError("EBADF");
     if (!pollFile(file).writable) {
       if (nonblock) throw new KernelError("EAGAIN");
-      return file.write(body, this.blockingSignal());
+      return file.write(body, this.blockingSignal(cancelled));
     }
     if (nonblock) return file.write(body, AbortSignal.abort());
     return file.write(
@@ -9444,9 +9445,13 @@ var WasmProcess = class {
     if (isVfsSyscall(req)) return this.vfsSyscall(req);
     switch (req.op) {
       case "fd-read":
-        return { ok: true, kind: "bytes", bytes: await this.read(req) };
+        return { ok: true, kind: "bytes", bytes: await this.read(req, cancelled) };
       case "fd-write":
-        return { ok: true, kind: "json", json: await this.write(req.fd, req.body, req.nonblock) };
+        return {
+          ok: true,
+          kind: "json",
+          json: await this.write(req.fd, req.body, req.nonblock, cancelled)
+        };
       case "fd-close":
         this.options.locks?.closed(this.pid, req.fd);
         await Promise.resolve(this.fds.close(req.fd));
@@ -9511,8 +9516,7 @@ var WasmProcess = class {
         return { ok: true, kind: "json", json: this.options.jobs?.terminalNames() ?? [] };
       case "fd-select": {
         const { read, write, timeoutMs } = req;
-        const blocking = this.blockingSignal();
-        const signal = cancelled ? AbortSignal.any([blocking, cancelled]) : blocking;
+        const signal = this.blockingSignal(cancelled);
         const selected = await selectFds(this.fds, read, write, timeoutMs, signal);
         return { ok: true, kind: "json", json: selected };
       }
@@ -9682,13 +9686,13 @@ var WasmProcess = class {
     if (!http) return Promise.resolve({ ok: false, errno: "ENETUNREACH", message: NO_TRANSPORT });
     return http.syscall(req);
   }
-  socketSyscall(req) {
+  socketSyscall(req, cancelled) {
     this.net ??= this.options.net ?? new LoopbackNet();
     const resolver = this.options.resolver ?? HOSTS_ONLY;
     return socketSyscall(req, {
       fds: this.fds,
       net: this.net,
-      blocking: () => this.blockingSignal(),
+      blocking: () => this.blockingSignal(cancelled),
       resolve: (name2, family, blocking) => resolver.resolve(name2, family, blocking)
     });
   }
@@ -9698,7 +9702,7 @@ var WasmProcess = class {
     if (!tty) throw new KernelError("ENOTTY");
     return tty;
   }
-  async procSyscall(req) {
+  async procSyscall(req, cancelled) {
     switch (req.op) {
       case "proc-fork":
         this.refuseIfPending(req.restart);
@@ -9707,7 +9711,7 @@ var WasmProcess = class {
         this.refuseIfPending(req.restart);
         return { ok: true, kind: "json", json: await this.spawn(req) };
       case "proc-wait": {
-        const signal = req.nohang ? this.interrupt.signal : this.blockingSignal();
+        const signal = req.nohang ? this.interrupt.signal : this.blockingSignal(cancelled);
         const flags = {
           untraced: req.untraced,
           continued: req.continued,
@@ -9767,7 +9771,10 @@ var WasmProcess = class {
         this.inherited &= ~(req.defaults ?? 0);
         return { ok: true, kind: "void" };
       case "sig-pause":
-        return this.pause();
+        return this.pause(cancelled);
+      case "thread-kill":
+        if (!this.options.threadKill?.(req.tid, req.sig)) this.options.raise?.(req.sig);
+        return { ok: true, kind: "void" };
       case "proc-captured":
         return { ok: true, kind: "bytes", bytes: this.children.captured(req.pid, req.slot) };
     }
@@ -9789,8 +9796,8 @@ var WasmProcess = class {
     }
     return { ok: true, kind: "void" };
   }
-  pause() {
-    return aborted(this.blockingSignal());
+  pause(cancelled) {
+    return aborted(this.blockingSignal(cancelled));
   }
   alarm;
   dlLog = [];
@@ -9907,6 +9914,18 @@ var Dying = class {
     return [typeof reported === "number" ? reported : CRASHED, void 0];
   }
 };
+function killThread(thread, caught, sig) {
+  if (!thread || (caught & sigbit(sig)) === 0) return false;
+  Atomics.or(thread.header, SAB_I_SIGNALS, sigbit(sig));
+  Atomics.notify(thread.header, SAB_I_SIGNALS);
+  const blocked = thread.interrupt;
+  thread.interrupt = new AbortController();
+  blocked.abort();
+  return true;
+}
+function threadCancel(thread) {
+  return Atomics.load(thread.header, SAB_I_SIGNALS) !== 0 ? AbortSignal.abort() : thread.interrupt.signal;
+}
 function notifiers(header3) {
   return {
     onPending(sig) {
@@ -9942,7 +9961,7 @@ function openLane(token, dispatch2) {
     }
   };
 }
-function processInit(opts, sab, umask, lane) {
+function processInit(opts, sab, umask, cred, lane) {
   const base = {
     type: WASM_PROCESS_INIT,
     pid: opts.shownPid ?? opts.pid,
@@ -9952,6 +9971,7 @@ function processInit(opts, sab, umask, lane) {
     cwd: opts.cwd,
     sab,
     umask,
+    cred,
     ...opts.ppid !== void 0 ? { ppid: opts.ppid } : {}
   };
   if (opts.program.abi === "js") {
@@ -9989,10 +10009,8 @@ function holdingToken(opts, holds) {
     renamed: (from, to) => holds.renamed(from, to)
   });
 }
-function spawnWasmProcess(opts) {
-  const sab = new SharedArrayBuffer(SAB_HEADER_BYTES + SAB_DEFAULT_WINDOW_BYTES);
-  const header3 = new Int32Array(sab, 0, SAB_HEADER_I32);
-  const process2 = new WasmProcess(opts.pid, opts.fds, {
+function processOptions(opts, header3, hooks) {
+  return {
     ...inherited(opts),
     ...opts.identity ? { identity: opts.identity } : {},
     ...opts.onSyscall ? { onSyscall: opts.onSyscall } : {},
@@ -10017,9 +10035,23 @@ function spawnWasmProcess(opts) {
     ...notifiers(header3),
     onTimer: (which) => void Atomics.or(header3, SAB_I_TIMERS, 1 << which),
     hasPending: () => Atomics.load(header3, SAB_I_SIGNALS) !== 0 || Atomics.load(header3, SAB_I_TIMERS) !== 0,
-    raise: (sig) => signal(sig),
+    raise: hooks.raise,
+    threadKill: hooks.threadKill,
     ...opts.program.abi === "wasi" || opts.program.abi === "js" ? { pendingBits: () => Atomics.load(header3, SAB_I_SIGNALS) } : {}
-  });
+  };
+}
+function spawnWasmProcess(opts) {
+  const sab = new SharedArrayBuffer(SAB_HEADER_BYTES + SAB_DEFAULT_WINDOW_BYTES);
+  const header3 = new Int32Array(sab, 0, SAB_HEADER_I32);
+  const threadSignals = /* @__PURE__ */ new Map();
+  const process2 = new WasmProcess(
+    opts.pid,
+    opts.fds,
+    processOptions(opts, header3, {
+      raise: (sig) => signal(sig),
+      threadKill: (tid, sig) => killThread(threadSignals.get(tid), process2.signalMasks().caught, sig)
+    })
+  );
   publishStops(process2, header3);
   const holds = new HeldPaths();
   opts.held?.add(holds);
@@ -10086,7 +10118,15 @@ function spawnWasmProcess(opts) {
     }
     const tsab = new SharedArrayBuffer(SAB_HEADER_BYTES + SAB_DEFAULT_WINDOW_BYTES);
     const tw = opts.createWorker();
-    const tresponder = attachSyncSabResponder(tw, tsab, token, { dispatch: dispatch2 });
+    const tsignals = {
+      header: new Int32Array(tsab, 0, SAB_HEADER_I32),
+      interrupt: new AbortController()
+    };
+    threadSignals.set(thread.tid, tsignals);
+    const tdispatch = (req) => dying.serving(
+      () => isWasmSyscall(req) ? process2.syscall(req, threadCancel(tsignals)) : dispatchSyncFs(req)
+    );
+    const tresponder = attachSyncSabResponder(tw, tsab, token, { dispatch: tdispatch });
     const onThreadMessage = (event) => {
       const data = event.data;
       if (data?.type === WASM_THREAD_EXIT) endThread(thread.tid);
@@ -10095,6 +10135,7 @@ function spawnWasmProcess(opts) {
     tw.addEventListener("message", onThreadMessage);
     tw.addEventListener("error", onError);
     threads.set(thread.tid, () => {
+      threadSignals.delete(thread.tid);
       tw.removeEventListener("message", onThreadMessage);
       tw.removeEventListener("error", onError);
       tresponder.dispose();
@@ -10109,13 +10150,14 @@ function spawnWasmProcess(opts) {
       env: opts.env,
       cwd: opts.cwd,
       sab: tsab,
+      cred: copyCred(process2.cred),
       ...opts.ppid !== void 0 ? { ppid: opts.ppid } : {},
       thread
     };
     tw.postMessage(tinit);
   };
   worker.postMessage(
-    processInit(opts, sab, process2.umask, lane?.lane),
+    processInit(opts, sab, process2.umask, copyCred(process2.cred), lane?.lane),
     transferOf(opts, lane?.lane)
   );
   const signal = (sig) => {