@ai-ecoverse/slicc-kernel 1.136.2 → 1.136.3

package/README.md

@@ -327,7 +327,7 @@ On top of preview1 a WASI program gets:
   A kernel without the imports answers `ENOSYS`, and the libc reports `SI_USER` with pid and uid 0, as before. **SIGCHLD:** with `SIGCHLD` set to `SIG_IGN` (by the program, or inherited), or with `SA_NOCLDWAIT` in the flags `slicc.sigaction_set` gets for `SIGCHLD`, an exited child is reaped at once and never stays a zombie: `waitpid` for it is `ECHILD`, and `wait` blocks until every child has exited, then fails with `ECHILD`, as on Linux. `SIGCHLD` is still sent. An explicit `SIG_DFL` turns it back off. A child that a process waits on for `exec`, or that `kernel.run` and the run calls collect, is never reaped that way.
 - **Pipes** have no file type for WASI and WASIX programs' `fstat` (`st_mode` type 0), because WASI has no FIFO file type. A socket type, as kernels 1.47.3 to 1.48.1 gave them, made Ruby treat a `popen` pipe as a socket (`close_write` then never ends the child's input). The kernel's `slicc_fs.fd_mode` answers `S_IFIFO | 0600` (Linux numbering) for a pipe, and wasix-sysroot 2025.9.30-21 and later take the type from it, so programs built on it see a FIFO (`S_ISFIFO`); older libcs keep only the permission bits. Until then Python's asyncio refuses a pipe for a subprocess (`Pipe transport is only for pipes, sockets and character devices`). They are read and written as pipes; socket calls on them fail with `ENOTSOCK`, and `isatty()` is false. Emscripten programs, bash included, see a FIFO. The same holds for any kernel descriptor that is neither seekable nor a terminal or device, such as captured output.
 - **Sockets**: the WASIX socket calls (`sock_open`, `sock_pair` for an `AF_UNIX` stream or datagram pair, `bind`, `listen`, `connect`, `accept`, options, local and peer names) are the kernel's loopback sockets, and preview1's `sock_recv` / `sock_send` / `sock_shutdown` work on them and on inherited ones. Writing to a socket whose peer is gone fails with `EPIPE`, through `fd_write` as through `sock_send`, as if `MSG_NOSIGNAL` were set. A write to a pipe, FIFO or terminal whose reader is gone follows the program's `SIGPIPE` disposition, as the kernel knows it (#810): at the default it ends the program with status 141; ignored (also an ignore inherited across `exec` and spawn, as bash's `trap '' PIPE` passes on), the write fails with `EPIPE`; with a handler, the handler runs on the thread that wrote and then the write fails with `EPIPE` (#820); blocked, `SIGPIPE` stays pending and the write fails with `EPIPE`. An Emscripten program's write to a pipe, and its `send` without `MSG_NOSIGNAL`, follow the same rules, except that the kernel doesn't see an Emscripten program's signal mask, so a blocked `SIGPIPE` there still ends it. A WASIX program's libc reads an inherited ignore back through `slicc.sigaction_inherited` (wasix-sysroot -32 and later; see below). An Emscripten program's shim reads it from `Module.sliccKernel.sigInherited()` (#965, homescoop#973). That's a mask with bit n set for signal n (not bit n-1, as the WASIX import has it) holding only inherited `SIG_IGN`s, never `SIGKILL` or `SIGSTOP`. The shim seeds its `sigaction` table from it in a constructor that runs before any user constructor. The kernel puts the function on `Module.sliccKernel` before the glue runs constructors, ahead of the rest of `sliccKernel`. On a kernel without the function it is undefined, and the shim keeps the defaults. HTTP and HTTPS leave through the realm proxy that `https_proxy` names, as for any other program; `resolve` answers `/etc/hosts` names and literal addresses, and the [uplink](#uplink)'s names. `sock_open(SOCK_DGRAM)` on `AF_INET`/`AF_INET6` gives a [datagram socket](#datagram-sockets-udp); `sock_send_to` and `sock_recv_from` carry its addresses, and `RECV_DATA_TRUNCATED` is set in `ro_flags` when a datagram did not fit.
-- **Diagnostics**: a trap ends the program with 134 and its message on stderr; with `SLICC_WASM_BACKTRACE=1` the wasm frames follow, named from the module's name section, or from a sidecar for a module shipped without one (`<module>.names` beside it, or the same path in a `<package>-names` package). `SLICC_WASI_STATS=1` makes a program print its calls, counted and timed, as it ends.
+- **Diagnostics**: a trap ends the program with 134 and its message on stderr; a program that crashes its worker otherwise (a JS stack overflow, `RangeError: Maximum call stack size exceeded`, or any other uncaught error) ends with 70, and its message goes to the process's own fd 2 too, so `2>` catches it (#1237), or to the session's stderr when it has no fd 2 to write; with `SLICC_WASM_BACKTRACE=1` the wasm frames follow, named from the module's name section, or from a sidecar for a module shipped without one (`<module>.names` beside it, or the same path in a `<package>-names` package). `SLICC_WASI_STATS=1` makes a program print its calls, counted and timed, as it ends.
 
 ### Program imports
 

package/dist/kernel-worker.js

@@ -7098,7 +7098,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.136.2" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.136.3" : "0.0.0-dev";
 var OS_RELEASE = "6.0.0-slicc";
 function procVersion() {
   return `Linux version ${OS_RELEASE} (slicc-kernel ${KERNEL_VERSION}) #1 SMP PREEMPT_DYNAMIC
@@ -22291,6 +22291,18 @@ var WasmProcess = class {
       throw err;
     }
   }
+  async complain(line) {
+    const stderr = this.fds.has(2) ? this.fds.get(2).file : void 0;
+    if (!stderr?.write || stderr.sealed || stderr.clipboard) return false;
+    const bytes = new TextEncoder().encode(`${line}
+`);
+    const timeout = new Promise((r) => setTimeout(() => r(0), 1e3));
+    const sent = await Promise.race([stderr.write(bytes, AbortSignal.timeout(1e3)), timeout]).then(
+      (n) => n,
+      () => 0
+    );
+    return sent > 0;
+  }
   async clipboardComplaint(err) {
     const name2 = this.options.clipboardName;
     if (name2 === void 0 || !(err instanceof KernelError) || err.detail === void 0) return;
@@ -23766,6 +23778,29 @@ function outOfMemory(opts, data) {
   }
   return true;
 }
+function workerError(event) {
+  return String(event.message ?? "worker error");
+}
+var CrashSlot = class {
+  status;
+  reported = false;
+  report;
+  constructor(report) {
+    this.report = report;
+  }
+  take(status, message3, finish) {
+    if (this.status) return;
+    this.status = status;
+    const done5 = () => {
+      this.reported = true;
+      finish(...status);
+    };
+    void this.report(message3).then(done5, done5);
+  }
+};
+async function crashReport(process, onError, message3) {
+  if (!await process.complain(message3)) onError?.(message3);
+}
 function spawnWasmProcess(opts) {
   const { promise: ready2, resolve: started } = readiness(opts.program.abi);
   const sab = new SharedArrayBuffer(SAB_HEADER_BYTES + SAB_DEFAULT_WINDOW_BYTES);
@@ -23816,9 +23851,11 @@ function spawnWasmProcess(opts) {
   const jsThreads = jsThreadsOf(opts, process, token, dispatch2, clocks, header3);
   const { promise: exited, resolve: settle3 } = Promise.withResolvers();
   let done5 = false;
+  const crash = new CrashSlot((message3) => crashReport(process, opts.onError, message3));
   let endedBy;
   const finish = (code, sig) => {
     if (done5) return;
+    if (crash.status && !crash.reported) return;
     done5 = true;
     started(true);
     clocks.freeze();
@@ -23847,8 +23884,9 @@ function spawnWasmProcess(opts) {
     } else if (data?.type === WASM_PROCESS_EXIT) {
       finish(...dying.status(data.code));
     } else if (data?.type === WASM_PROCESS_ERROR) {
-      if (!dying.ending) opts.onError?.(String(data.message));
-      finish(...dying.status(data.code));
+      const status = dying.status(data.code);
+      if (dying.ending) finish(...status);
+      else crash.take(status, String(data.message), finish);
     } else if (data?.type === WASM_THREAD_SPAWN && data.thread) {
       spawnThread(data.thread);
     } else if (data?.type === JS_THREAD_SPAWN && jsThreads) {
@@ -23858,8 +23896,7 @@ function spawnWasmProcess(opts) {
   const onMessage = (event) => handle(event.data);
   const onError = (event) => {
     event.preventDefault();
-    opts.onError?.(String(event.message ?? "worker error"));
-    finish(CRASHED);
+    crash.take([CRASHED], workerError(event), finish);
   };
   worker.addEventListener("message", onMessage);
   worker.addEventListener("error", onError);