@ai-ecoverse/slicc-kernel 1.42.1 → 1.42.3

package/README.md

@@ -499,7 +499,7 @@ npm run test:unit
 
 `npm test` builds `dist/` and runs the integration tests in Chromium from `playwright-core`, over raw CDP through the [harness from slicc-shared-web](https://github.com/ai-ecoverse/slicc-shared-web#integration-test-harness), against a cross-origin isolated test page that installs bash and coreutils into OPFS. Each test writes screenshots, console logs and CPU profiles to `artifacts/`; V8 coverage from the page and every worker, mapped back to `src/` through the source maps, goes to `coverage/`, and `artifacts/hotspots.md` lists where the time went.
 
-Unit tests live in `test/unit/`, which stays out of git. They run real wasm bash and coreutils through the whole stack in Node `worker_threads` against an in-memory OPFS. The pre-commit hook runs them under coverage and requires every changed line in `src/` to be covered.
+Unit tests live in `test/unit/`, which stays out of git. They run real wasm bash and coreutils through the whole stack in Node `worker_threads` against an in-memory OPFS. The pre-commit hook runs them under coverage and requires every changed line in `src/` to be covered. `tools/heavy.sh` runs them two files at a time, holding the lock `/tmp/slicc-heavy.lock` (`SLICC_HEAVY_LOCK`) that the Chromium tests take too, and stops the run if its processes use more than 3,000,000 KB together or 2,000,000 KB in one process, or run longer than 900 s once they hold the lock (`SLICC_HEAVY_TIMEOUT`; each test also has 180 s) (`SLICC_HEAVY_REPORT=1` prints the peak). `SLICC_HEAVY_TREE_KB` and `SLICC_HEAVY_PROC_KB` raise the caps, but only for measuring a run under a higher ceiling that still stops a runaway, never to get a commit through. The guard follows the command's process group and every process it has seen, including children that leave the group, but a process that forks, calls `setsid` and whose parent exits within one 0.25 s sample can escape: macOS has no unprivileged containment, and a test that daemonizes is a bug. The compiler tests (zig, rustc and cargo), each a few GB, are integration tests in `test/integration/compilers.test.mjs`, which CI runs.
 
 The Biome, TypeScript, lefthook, Renovate and CI configuration comes from [slicc-shared-web](https://github.com/ai-ecoverse/slicc-shared-web), which also provides the `slicc-lint-comments` (no comments anywhere), `slicc-no-unit-tests` (no unit tests in git) and `slicc-diff-cover` (100% coverage of changed lines) commands that `npm run lint` and the pre-commit hook use.
 

package/dist/node-process-worker.js

@@ -5480,6 +5480,7 @@ var init_wasi_host = __esm({
       startCwd;
       interruptWakes = false;
       onRaise;
+      muted;
       listening;
       o;
       constructor(o) {
@@ -5828,6 +5829,7 @@ var init_wasi_host = __esm({
         return this.o.kernel.call({ op: "fd-vfs-stat", fd });
       }
       write(fd, data) {
+        if (this.muted?.(fd, data)) return data.length;
         const e = this.fds.get(fd);
         if (e.type === "kernel") {
           try {
@@ -6223,18 +6225,22 @@ var init_wasi_module = __esm({
 });
 
 // src/process/wasi/wasi-signals.ts
-var DELIVERED_MASK, WasiSignals;
+var DELIVERED_MASK, LIBC_DEFAULT_EXIT, WASIX_LIBC_DEFAULT_LINE, WasiSignals;
 var init_wasi_signals = __esm({
   "src/process/wasi/wasi-signals.ts"() {
     "use strict";
     init_signals();
+    init_wasi_host();
     DELIVERED_MASK = Object.values(SIG).filter((sig) => sig !== SIG.KILL && sig !== SIG.STOP).reduce((m, sig) => m | sigbit(sig), 0);
+    LIBC_DEFAULT_EXIT = 127;
+    WASIX_LIBC_DEFAULT_LINE = /^Program recieved (?:stop|termination|fatal) signal: [^\n]+\n$/;
     WasiSignals = class {
       exports;
       callback;
       uncaught = 0;
       delivering;
       defaulted = false;
+      libcDefault = false;
       fallBack;
       onKilled;
       constructor(fallBack, onKilled) {
@@ -6257,19 +6263,28 @@ var init_wasi_signals = __esm({
       raise(sig) {
         const handler = this.handler();
         if (!handler) return;
-        const outer = { sig: this.delivering, defaulted: this.defaulted };
+        const outer = { sig: this.delivering, defaulted: this.defaulted, libc: this.libcDefault };
         this.delivering = sig;
         this.defaulted = false;
+        this.libcDefault = false;
         try {
           handler(sig);
         } catch (e) {
-          if (!(e instanceof WebAssembly.RuntimeError)) throw e;
+          const libcExit = e instanceof WasiExit && e.code === LIBC_DEFAULT_EXIT && this.libcDefault;
+          if (!(libcExit && !this.defaulted) && !(e instanceof WebAssembly.RuntimeError)) throw e;
           if (!this.defaulted) this.defaultAction(sig);
         } finally {
           this.delivering = outer.sig;
           this.defaulted = outer.defaulted;
+          this.libcDefault = outer.libc;
         }
       }
+      muted(fd, data) {
+        if (fd !== 2 || this.delivering === void 0) return false;
+        if (!WASIX_LIBC_DEFAULT_LINE.test(new TextDecoder().decode(data))) return false;
+        this.libcDefault = true;
+        return true;
+      }
       raised(sig) {
         if (sig !== SIG.ABRT || this.delivering === void 0) return false;
         if (!this.defaulted) this.defaultAction(this.delivering);
@@ -8119,6 +8134,7 @@ async function runWasiProcess(init, port3) {
   publishMemory(init.sab, sizeOf(main)());
   signals.bind(instance.exports);
   host.onRaise = (sig) => signals.raised(sig);
+  host.muted = (fd, data) => signals.muted(fd, data);
   const exports = instance.exports;
   driver.bind(instance.exports);
   try {