@ai-ecoverse/slicc-kernel 1.46.0 → 1.47.0

package/dist/node-process-worker.js

@@ -2159,9 +2159,9 @@ function trackCloseOnExec(Fs) {
   if (typeof Fs.dupStream === "function") {
     const dupStream = Fs.dupStream.bind(Fs);
     Fs.dupStream = (stream, fd) => {
-      const copy = dupStream(stream, fd);
-      setCloseOnExec(copy, false);
-      return copy;
+      const copy2 = dupStream(stream, fd);
+      setCloseOnExec(copy2, false);
+      return copy2;
     };
   }
   if (typeof Fs.open === "function") {
@@ -2184,9 +2184,9 @@ function cloexecFcntl(fcntl, deps) {
   const mark = marker(deps);
   return (fd, cmd, varargs) => {
     if (cmd === F_DUPFD_CLOEXEC) {
-      const copy = fcntl(fd, F_DUPFD, varargs);
-      if (copy >= 0) mark(copy, true);
-      return copy;
+      const copy2 = fcntl(fd, F_DUPFD, varargs);
+      if (copy2 >= 0) mark(copy2, true);
+      return copy2;
     }
     if (cmd === F_GETFL) {
       const flags = fcntl(fd, cmd, varargs);
@@ -2596,9 +2596,9 @@ function useDevFd(Fs) {
   Fs.open = (path, flags, mode) => {
     const fd = fdOf(path);
     if (fd === void 0) return open(path, flags, mode);
-    const copy = Fs.dupStream(target(fd), -1);
-    setCloseOnExec(copy, typeof flags === "number" && (flags & O_CLOEXEC) !== 0);
-    return copy;
+    const copy2 = Fs.dupStream(target(fd), -1);
+    setCloseOnExec(copy2, typeof flags === "number" && (flags & O_CLOEXEC) !== 0);
+    return copy2;
   };
   const { stat, fstat } = Fs;
   if (typeof stat !== "function" || typeof fstat !== "function") return;
@@ -3280,6 +3280,13 @@ var init_process_signals = __esm({
           this.quieted--;
         }
       }
+      interrupt() {
+        const header = this.header;
+        const pending = Atomics.load(header, SAB_I_SIGNALS) | Atomics.load(header, SAB_I_TIMERS) | Atomics.load(header, SAB_I_KILLED);
+        if (pending === 0) return false;
+        this.deliver();
+        return true;
+      }
       deliver() {
         if (this.quieted > 0) return;
         const killed = Atomics.load(this.header, SAB_I_KILLED);
@@ -5539,6 +5546,7 @@ var init_wasi_host = __esm({
       onRaise;
       muted;
       signals;
+      interrupted;
       listening;
       o;
       constructor(o) {
@@ -6644,7 +6652,7 @@ var init_wasi_module = __esm({
 });
 
 // src/process/wasi/wasi-signals.ts
-var DELIVERED_MASK, STOP_DEFAULTS, LIBC_DEFAULT_EXIT, SA_RESTART, DISPOSITION_IGNORE, DISPOSITION_HANDLER, withBit, WASIX_LIBC_DEFAULT_LINE, WasiSignals;
+var DELIVERED_MASK, KERNEL_DEFAULTS, LIBC_DEFAULT_EXIT, SA_RESTART, DISPOSITION_IGNORE, DISPOSITION_HANDLER, withBit, WASIX_LIBC_DEFAULT_LINE, WasiSignals;
 var init_wasi_signals = __esm({
   "src/process/wasi/wasi-signals.ts"() {
     "use strict";
@@ -6652,7 +6660,7 @@ var init_wasi_signals = __esm({
     init_wasi_abi();
     init_wasi_host();
     DELIVERED_MASK = Object.values(SIG).filter((sig) => sig !== SIG.KILL && sig !== SIG.STOP).reduce((m, sig) => m | sigbit(sig), 0);
-    STOP_DEFAULTS = sigbit(SIG.TSTP) | sigbit(SIG.TTIN) | sigbit(SIG.TTOU);
+    KERNEL_DEFAULTS = [SIG.TSTP, SIG.TTIN, SIG.TTOU, SIG.CHLD, SIG.CONT, SIG.URG, SIG.WINCH].map(sigbit).reduce((m, bit) => m | bit, 0);
     LIBC_DEFAULT_EXIT = 127;
     SA_RESTART = 268435456;
     DISPOSITION_IGNORE = 1;
@@ -6724,7 +6732,7 @@ var init_wasi_signals = __esm({
           return { caught, ignored: this.ignoring, restart: this.restarting, defaults };
         }
         if (!this.handler()) return null;
-        return { caught: DELIVERED_MASK & ~this.uncaught & ~STOP_DEFAULTS, ignored: 0, restart: 0 };
+        return { caught: DELIVERED_MASK & ~this.uncaught & ~KERNEL_DEFAULTS, ignored: 0, restart: 0 };
       }
       raise(sig) {
         const handler = this.handler();
@@ -7545,6 +7553,16 @@ var init_wasix_sockets = __esm({
 });
 
 // src/process/wasi/wasix-host.ts
+function futexWait(view, index2, expected, ms, interrupted) {
+  const deadline = performance.now() + ms;
+  for (; ; ) {
+    const slice = interrupted ? Math.min(FUTEX_SLICE_MS, ms) : ms;
+    if (Atomics.wait(view, index2, expected, slice) !== "timed-out") return true;
+    if (interrupted?.()) return true;
+    ms = deadline - performance.now();
+    if (ms <= 0) return false;
+  }
+}
 function posixSignal(sig) {
   const posix = wasixSignal(sig);
   if (posix === void 0) throw new WasiError("EINVAL");
@@ -7553,7 +7571,7 @@ function posixSignal(sig) {
 function nsToMs(ns) {
   return Math.ceil(Number(ns) / 1e6);
 }
-var FDFLAGSEXT_CLOEXEC, SPAWN_OP_SIZE, SPAWN_OPS, RIGHTS_FD_WRITE, ICANON, ECHO, WasixHost;
+var FDFLAGSEXT_CLOEXEC, SPAWN_OP_SIZE, SPAWN_OPS, RIGHTS_FD_WRITE, ICANON, ECHO, FUTEX_SLICE_MS, WasixHost;
 var init_wasix_host = __esm({
   "src/process/wasi/wasix-host.ts"() {
     "use strict";
@@ -7570,6 +7588,7 @@ var init_wasix_host = __esm({
     RIGHTS_FD_WRITE = 1n << 6n;
     ICANON = 2;
     ECHO = 8;
+    FUTEX_SLICE_MS = 50;
     WasixHost = class _WasixHost {
       process;
       threads;
@@ -7856,7 +7875,7 @@ var init_wasix_host = __esm({
             if (!(this.threads?.known(tid) ?? tid === MAIN_TID)) throw new WasiError("ESRCH");
             const posix = posixSignal(sig);
             if (host.onRaise?.(posix)) return;
-            host.o.kernel.call({ op: "proc-kill", pid: host.o.pid, sig: posix });
+            host.o.kernel.call({ op: "thread-kill", tid, sig: posix });
           },
           thread_spawn_v2: (startPtr, tidPtr) => {
             if (!this.threads) return E.NOTSUP;
@@ -7871,7 +7890,7 @@ var init_wasix_host = __esm({
             const ms = timed ? Number(v.getBigUint64(timeoutPtr + 8, true)) / 1e6 : Number.POSITIVE_INFINITY;
             v.setUint8(
               wokenPtr,
-              Atomics.wait(i32(), ptr >> 2, expected | 0, ms) === "timed-out" ? 0 : 1
+              futexWait(i32(), ptr >> 2, expected | 0, ms, host.interrupted) ? 1 : 0
             );
           },
           futex_wake: (ptr, wokenPtr) => {
@@ -8092,20 +8111,20 @@ function newImportedMemory(spec) {
     });
   }
 }
-function createImportedMemory(spec, copy) {
+function createImportedMemory(spec, copy2) {
   if (!spec) return void 0;
   const memory = newImportedMemory(spec);
-  if (copy) fillMemory(memory, copy);
+  if (copy2) fillMemory(memory, copy2);
   return memory;
 }
 function restoreExportedMemory(instance, imported, init) {
   if (imported || !init.fork?.wasi) return;
   fillMemory(instance.exports.memory, init.fork.memory);
 }
-function fillMemory(memory, copy) {
-  const pages2 = copy.byteLength / 65536 - memory.buffer.byteLength / 65536;
+function fillMemory(memory, copy2) {
+  const pages2 = copy2.byteLength / 65536 - memory.buffer.byteLength / 65536;
   if (pages2 > 0) memory.grow(pages2);
-  new Uint8Array(memory.buffer).set(copy);
+  new Uint8Array(memory.buffer).set(copy2);
 }
 function sizeOf(main) {
   return () => main.memory?.buffer.byteLength ?? 0;
@@ -8115,11 +8134,12 @@ function memoryOf(instance, imported) {
 }
 function kernelOf(init, port3, hooks = { masks: () => null, raise: () => {
 } }, memory) {
-  const transport = new SignalGate(
+  const gate = new SignalGate(
     createSyncSabTransport(init.sab, port3, memory ? { memory } : {}),
     new Int32Array(init.sab, 0, SAB_HEADER_I32),
     hooks
-  ).transport();
+  );
+  const transport = gate.transport();
   const sys = kernelSys(transport);
   const call2 = (req) => {
     const r = transport.call(req, Number.POSITIVE_INFINITY, req.op);
@@ -8128,7 +8148,7 @@ function kernelOf(init, port3, hooks = { masks: () => null, raise: () => {
   };
   const say = (text) => sys.write(2, new TextEncoder().encode(`${init.argv0}: ${text}
 `));
-  return { transport, sys, call: call2, say };
+  return { transport, sys, call: call2, say, gate };
 }
 function traced(stats, tag, table) {
   return stats ? stats.wrap(tag, table) : table;
@@ -8243,16 +8263,19 @@ function descriptors(init, fork, threads) {
 async function runWasiProcess(init, port3) {
   captureBacktraces(init.env);
   const signals = new WasiSignals(
-    (sig) => {
-      call2({ op: "proc-kill", pid: init.pid, sig });
-      if (defaultAction(sig) === "terminate") throw new WasiExit(128 + sig);
-    },
+    takeDefault((req) => call2(req), init.pid),
     (code2) => {
       throw new WasiExit(code2);
     }
   );
   const main = {};
-  const { transport, sys, call: kernelCall, say } = kernelOf(init, port3, signals, sizeOf(main));
+  const {
+    transport,
+    sys,
+    call: kernelCall,
+    say,
+    gate
+  } = kernelOf(init, port3, 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;
@@ -8300,6 +8323,7 @@ async function runWasiProcess(init, port3) {
   if (importsSigactionHook(module)) signals.useHook();
   if (fork?.signals) signals.restore(fork.signals);
   host.signals = signals;
+  host.interrupted = () => gate.interrupt();
   host.onRaise = (sig) => signals.raised(sig);
   host.muted = (fd, data) => signals.muted(fd, data);
   const exports = instance.exports;
@@ -8350,8 +8374,12 @@ function captureBacktraces(env) {
 }
 async function runWasiThread(init, port3) {
   captureBacktraces(init.env);
-  const { transport, sys, call: call2, say } = kernelOf(init, port3);
   const { thread } = init;
+  const { transport, sys, call: call2, say, gate } = kernelOf(init, port3, {
+    masks: () => null,
+    raise: (sig) => signals.raise(sig)
+  });
+  const signals = new WasiSignals(takeDefault(call2, init.pid));
   const threads = new WasiThreads(port3, thread.memory, threadCap(init.env), thread.tid, thread.ids);
   threads.received = thread.modules;
   const id = identify(transport, init);
@@ -8372,6 +8400,10 @@ async function runWasiThread(init, port3) {
     foreign: init.program.foreign,
     ...program ? { program } : {}
   });
+  signals.bind(instance.exports);
+  signals.register(SIGNAL_CALLBACK);
+  host.interrupted = () => gate.interrupt();
+  host.onRaise = (sig) => signals.raised(sig);
   const start2 = instance.exports.wasi_thread_start;
   try {
     start2(thread.tid, thread.arg);
@@ -8396,7 +8428,7 @@ async function runWasiThread(init, port3) {
     throw e;
   }
 }
-var TRAPPED, PREVIEW1, WASIX, SLICC, SLICC_FS, RESERVED2, importsSigactionHook, noErrno, FALLBACK_MAXIMUM_PAGES, LinkSync, DL_GEN, BACKTRACE_FRAMES;
+var TRAPPED, PREVIEW1, WASIX, SLICC, SIGNAL_CALLBACK, takeDefault, SLICC_FS, RESERVED2, importsSigactionHook, noErrno, FALLBACK_MAXIMUM_PAGES, LinkSync, DL_GEN, BACKTRACE_FRAMES;
 var init_wasi_runtime = __esm({
   "src/process/wasi/wasi-runtime.ts"() {
     "use strict";
@@ -8423,6 +8455,11 @@ var init_wasi_runtime = __esm({
     PREVIEW1 = "wasi_snapshot_preview1";
     WASIX = "wasix_32v1";
     SLICC = "slicc";
+    SIGNAL_CALLBACK = "__wasm_signal";
+    takeDefault = (call2, pid) => (sig) => {
+      call2({ op: "proc-kill", pid, sig });
+      if (defaultAction(sig) === "terminate") throw new WasiExit(128 + sig);
+    };
     SLICC_FS = "slicc_fs";
     RESERVED2 = RESERVED_NAMESPACES;
     importsSigactionHook = (module) => WebAssembly.Module.imports(module).some((i) => i.module === SLICC && i.name === "sigaction_set");
@@ -9503,6 +9540,77 @@ var init_js_sync = __esm({
   }
 });
 
+// src/process/js/js-tty.ts
+function copy(termios) {
+  return { ...termios, c_cc: [...termios.c_cc] };
+}
+function rawOf(termios) {
+  const raw = copy(termios);
+  raw.c_iflag &= ~(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
+  raw.c_oflag |= ONLCR;
+  raw.c_cflag |= CS8;
+  raw.c_lflag &= ~(ECHO2 | ICANON2 | IEXTEN | ISIG);
+  raw.c_cc[VMIN] = 1;
+  raw.c_cc[VTIME] = 0;
+  return raw;
+}
+function ttyOps(kernel) {
+  const saved = /* @__PURE__ */ new Map();
+  const getAttr = async (fd) => await kernel.json({ op: "tty-get", fd });
+  const setAttr = async (fd, termios) => {
+    await kernel.call({ op: "tty-set", fd, termios: copy(termios) });
+  };
+  const tty = {
+    getAttr,
+    setAttr,
+    async setRaw(fd, raw) {
+      if (!raw) {
+        const original = saved.get(fd);
+        saved.delete(fd);
+        if (original) await setAttr(fd, original);
+        return;
+      }
+      const current = await getAttr(fd);
+      if (!saved.has(fd)) saved.set(fd, current);
+      await setAttr(fd, rawOf(current));
+    },
+    async size(fd) {
+      const [rows, columns] = await kernel.json({ op: "tty-winsz", fd });
+      return { columns, rows };
+    },
+    foreground: async (fd) => await kernel.json({ op: "tty-pgrp-get", fd }),
+    async setForeground(fd, pgrp) {
+      await kernel.call({ op: "tty-pgrp-set", fd, pgrp });
+    }
+  };
+  const restore = async () => {
+    for (const [fd, original] of [...saved]) {
+      saved.delete(fd);
+      await setAttr(fd, original).catch(() => void 0);
+    }
+  };
+  return { tty, restore };
+}
+var BRKINT, INPCK, ISTRIP, ICRNL, IXON, ONLCR, CS8, ISIG, ICANON2, ECHO2, IEXTEN, VTIME, VMIN;
+var init_js_tty = __esm({
+  "src/process/js/js-tty.ts"() {
+    "use strict";
+    BRKINT = 2;
+    INPCK = 16;
+    ISTRIP = 32;
+    ICRNL = 256;
+    IXON = 1024;
+    ONLCR = 4;
+    CS8 = 48;
+    ISIG = 1;
+    ICANON2 = 2;
+    ECHO2 = 8;
+    IEXTEN = 32768;
+    VTIME = 5;
+    VMIN = 6;
+  }
+});
+
 // src/process/js/js-websocket.ts
 function failed3(err) {
   return new TypeError("websocket failed", { cause: err });
@@ -9626,13 +9734,16 @@ function websocketOp(kernel) {
     const writable2 = new WritableStream({
       async write(chunk, controller) {
         stop.signal.throwIfAborted();
-        const body = typeof chunk === "string" ? { text: chunk } : { body: chunk };
-        let buffered = await kernel.json({ op: "net-ws-send", handle, ...body });
+        const send = async (body) => {
+          if (settled) throw new JsCallError("EPIPE", "the websocket is closed");
+          return await kernel.json({ op: "net-ws-send", handle, ...body });
+        };
+        let buffered = await send(typeof chunk === "string" ? { text: chunk } : { body: chunk });
         while (buffered > SEND_BUFFER) {
           await wait(10);
           stop.signal.throwIfAborted();
           controller.signal.throwIfAborted();
-          buffered = await kernel.json({ op: "net-ws-send", handle });
+          buffered = await send({});
         }
       },
       close: () => close(),
@@ -9772,6 +9883,7 @@ function createContext(o) {
     infos,
     handles
   });
+  const terminal = ttyOps(kernel);
   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 = {
@@ -9820,14 +9932,16 @@ function createContext(o) {
     ...children,
     net: netOps(kernel, io),
     websocket: websocketOp(kernel),
+    tty: terminal.tty,
     exit
   };
   const drain2 = async () => {
     for (; ; ) {
       await Promise.all([...pending]);
       await new Promise((resolve2) => setTimeout(resolve2, 0));
-      if (pending.size === 0) return;
+      if (pending.size === 0) break;
     }
+    await terminal.restore();
   };
   return { ctx, drain: drain2 };
 }
@@ -9958,6 +10072,7 @@ var init_js_context = __esm({
     init_js_kernel();
     init_js_net();
     init_js_sync();
+    init_js_tty();
     init_js_websocket();
     JsExit = class extends Error {
       status;