@ai-ecoverse/slicc-kernel 1.107.1 → 1.108.0

package/dist/node-process-worker.js

@@ -2856,6 +2856,136 @@ var init_wasi_poll = __esm({
   }
 });
 
+// src/process/wasi/wasi-sigmask.ts
+var UNBLOCKABLE, LIBC_UNBLOCKABLE, FOREVER, NS_PER_MS2, POLL_MS, SIG_BLOCK, SIG_UNBLOCK, SIG_SETMASK, kernelBits, libcBits, apply, WasiSigmask;
+var init_wasi_sigmask = __esm({
+  "src/process/wasi/wasi-sigmask.ts"() {
+    "use strict";
+    init_signals();
+    init_sync_sab_wire();
+    init_wasi_abi();
+    UNBLOCKABLE = sigbit(SIG.KILL) | sigbit(SIG.STOP);
+    LIBC_UNBLOCKABLE = 1 << SIG.KILL - 1 | 1 << SIG.STOP - 1;
+    FOREVER = 0xffffffffffffffffn;
+    NS_PER_MS2 = 1000000n;
+    POLL_MS = 50;
+    SIG_BLOCK = 0;
+    SIG_UNBLOCK = 1;
+    SIG_SETMASK = 2;
+    kernelBits = (lo) => lo << 1 & ~UNBLOCKABLE;
+    libcBits = (bits) => bits >>> 1 & ~LIBC_UNBLOCKABLE;
+    apply = (how, mask, set) => {
+      if (how === SIG_BLOCK) return mask | set;
+      if (how === SIG_UNBLOCK) return mask & ~set;
+      return set;
+    };
+    WasiSigmask = class {
+      lo;
+      hi;
+      header;
+      deliver;
+      process;
+      tid;
+      constructor(header, deliver, process, tid = 1) {
+        this.header = header;
+        this.deliver = deliver;
+        this.process = process;
+        this.tid = tid;
+        this.lo = libcBits(Atomics.load(header, SAB_I_BLOCKED));
+        this.hi = Atomics.load(header, SAB_I_BLOCKED_HI);
+      }
+      static unsupported(header) {
+        storeBlocked(header, [0, 0]);
+      }
+      set(how, setLo, setHi, old) {
+        if (how !== SIG_BLOCK && how !== SIG_UNBLOCK && how !== SIG_SETMASK) return E.INVAL;
+        old(this.lo >>> 0, this.hi >>> 0);
+        this.lo = apply(how, this.lo, setLo | 0) & ~LIBC_UNBLOCKABLE;
+        this.hi = apply(how, this.hi, setHi | 0);
+        const now = kernelBits(this.lo);
+        storeBlocked(this.header, [now, this.hi]);
+        if ((Atomics.load(this.header, SAB_I_SIGNALS) & ~now) !== 0) this.deliver();
+        return E.SUCCESS;
+      }
+      swap(setLo, setHi) {
+        const old = [this.lo, this.hi];
+        this.lo = setLo & ~LIBC_UNBLOCKABLE;
+        this.hi = setHi | 0;
+        storeBlocked(this.header, [kernelBits(this.lo), this.hi]);
+        return old;
+      }
+      deliverUnblocked() {
+        const now = Atomics.load(this.header, SAB_I_BLOCKED);
+        if ((Atomics.load(this.header, SAB_I_SIGNALS) & ~now) === 0) return false;
+        this.deliver();
+        return true;
+      }
+      restore([lo, hi]) {
+        this.set(SIG_SETMASK, lo, hi, () => {
+        });
+      }
+      blockedBits() {
+        return Atomics.load(this.header, SAB_I_BLOCKED);
+      }
+      blocks(sig) {
+        return (Atomics.load(this.header, SAB_I_BLOCKED) & sigbit(sig)) !== 0;
+      }
+      inherited() {
+        return [kernelBits(this.lo), this.hi];
+      }
+      discard(sig) {
+        Atomics.and(this.header, SAB_I_SIGNALS, ~sigbit(sig));
+        if (this.process) Atomics.and(this.process, SAB_I_SIGNALS, ~sigbit(sig));
+      }
+      sigwait(setLo, timeoutNs, publish, took, entered = false) {
+        const set = kernelBits(setLo | 0);
+        const value2 = BigInt.asUintN(64, timeoutNs);
+        const deadline = value2 === FOREVER ? Number.POSITIVE_INFINITY : performance.now() + Number((value2 + NS_PER_MS2 - 1n) / NS_PER_MS2);
+        publish(set);
+        try {
+          for (; ; ) {
+            const seen = Atomics.load(this.header, SAB_I_SIGNALS);
+            const sig = this.take(set);
+            if (sig !== 0) {
+              took(sig);
+              return E.SUCCESS;
+            }
+            if (entered || this.deliverUnblocked() || this.interrupted()) return E.INTR;
+            const left = deadline - performance.now();
+            if (left <= 0) return E.AGAIN;
+            Atomics.wait(this.header, SAB_I_SIGNALS, seen, Math.min(left, POLL_MS));
+          }
+        } finally {
+          publish(0);
+        }
+      }
+      take(set) {
+        for (const header of this.process ? [this.header, this.process] : [this.header]) {
+          const ready = Atomics.load(header, SAB_I_SIGNALS) & set;
+          if (ready === 0) continue;
+          const bit = ready & -ready;
+          if ((Atomics.and(header, SAB_I_SIGNALS, ~bit) & bit) !== 0) return 31 - Math.clz32(bit);
+        }
+        return 0;
+      }
+      interrupted() {
+        const killed = this.process ?? this.header;
+        if (Atomics.load(killed, SAB_I_KILLED) !== 0) {
+          this.deliver();
+          return true;
+        }
+        if (Atomics.load(killed, SAB_I_STOP) !== 1) return false;
+        while (Atomics.load(killed, SAB_I_STOP) === 1) Atomics.wait(killed, SAB_I_STOP, 1);
+        return true;
+      }
+      pending() {
+        const own = Atomics.load(this.header, SAB_I_SIGNALS);
+        return libcBits(own | (this.process ? Atomics.load(this.process, SAB_I_SIGNALS) : 0));
+      }
+    };
+  }
+});
+
 // src/process/wasi/wasi-termios.ts
 function writeTermios(mem, ptr, termios) {
   mem.bytes(ptr, OSPEED + 4).fill(0);
@@ -2934,8 +3064,8 @@ var init_wasi_termios = __esm({
 // src/process/wasi/wasix-epoll.ts
 function timeoutMs(ns) {
   const value2 = BigInt.asUintN(64, ns);
-  if (value2 === FOREVER) return -1;
-  const ms = (value2 + NS_PER_MS2 - 1n) / NS_PER_MS2;
+  if (value2 === FOREVER2) return -1;
+  const ms = (value2 + NS_PER_MS3 - 1n) / NS_PER_MS3;
   return ms > BigInt(MAX_TIMEOUT_MS) ? -1 : Number(ms);
 }
 function wasixEpollImports(host) {
@@ -2996,7 +3126,7 @@ function wasixEpollImports(host) {
     }
   };
 }
-var EVENT_SIZE, DATA_OFFSET, DATA_SIZE, MAX_EVENTS, FOREVER, MAX_TIMEOUT_MS, NS_PER_MS2, EVENTFD_SEMAPHORE, EVENTFD_NONBLOCK, EVENTFD_MAX, WASIX_OPS, DUAL_OPS;
+var EVENT_SIZE, DATA_OFFSET, DATA_SIZE, MAX_EVENTS, FOREVER2, MAX_TIMEOUT_MS, NS_PER_MS3, EVENTFD_SEMAPHORE, EVENTFD_NONBLOCK, EVENTFD_MAX, WASIX_OPS, DUAL_OPS;
 var init_wasix_epoll = __esm({
   "src/process/wasi/wasix-epoll.ts"() {
     "use strict";
@@ -3006,9 +3136,9 @@ var init_wasix_epoll = __esm({
     DATA_OFFSET = 8;
     DATA_SIZE = 24;
     MAX_EVENTS = 4096;
-    FOREVER = 0xffffffffffffffffn;
+    FOREVER2 = 0xffffffffffffffffn;
     MAX_TIMEOUT_MS = 2147483647;
-    NS_PER_MS2 = 1000000n;
+    NS_PER_MS3 = 1000000n;
     EVENTFD_SEMAPHORE = 1;
     EVENTFD_NONBLOCK = 4;
     EVENTFD_MAX = 0xfffffffffffffffen;
@@ -3449,7 +3579,7 @@ function filestatOf(path, s) {
     size: BigInt(s.size),
     ino: s.ino !== void 0 ? BigInt(s.ino) : pathInode(path),
     ...s.nlink !== void 0 ? { nlink: BigInt(s.nlink) } : {},
-    mtimeNs: BigInt(Math.round(s.mtimeMs ?? 0)) * NS_PER_MS3
+    mtimeNs: BigInt(Math.round(s.mtimeMs ?? 0)) * NS_PER_MS4
   };
 }
 function kernelFiletype(kind) {
@@ -3499,7 +3629,7 @@ function wrap(table) {
   }
   return out;
 }
-var WasiExit, IDS, NS_PER_MS3, AT_SYMLINK_NOFOLLOW, AT_EACCESS, ROOT_IDS, GONE, S_IFIFO, DEFAULT_UMASK, MONOTONIC_BASE, MAX_READ, SIGPIPE_EXIT, SIG_IGN, SEALED_MODE, WasiHost;
+var WasiExit, IDS, NS_PER_MS4, AT_SYMLINK_NOFOLLOW, AT_EACCESS, ROOT_IDS, GONE, S_IFIFO, DEFAULT_UMASK, MONOTONIC_BASE, MAX_READ, SIGPIPE_EXIT, SIG_IGN, SEALED_MODE, WasiHost;
 var init_wasi_host = __esm({
   "src/process/wasi/wasi-host.ts"() {
     "use strict";
@@ -3516,6 +3646,7 @@ var init_wasi_host = __esm({
     init_wasi_files();
     init_wasi_memory();
     init_wasi_poll();
+    init_wasi_sigmask();
     init_wasi_termios();
     init_wasix_epoll();
     init_wasix_sockets();
@@ -3527,14 +3658,14 @@ var init_wasi_host = __esm({
       }
     };
     IDS = ["ruid", "euid", "suid", "rgid", "egid", "sgid"];
-    NS_PER_MS3 = 1000000n;
+    NS_PER_MS4 = 1000000n;
     AT_SYMLINK_NOFOLLOW = 1;
     AT_EACCESS = 2;
     ROOT_IDS = Object.freeze({ uid: 0, gid: 0 });
     GONE = /* @__PURE__ */ new Set(["ENOENT", "ENOTDIR"]);
     S_IFIFO = 4096;
     DEFAULT_UMASK = 18;
-    MONOTONIC_BASE = BigInt(Math.round(performance.timeOrigin)) * NS_PER_MS3;
+    MONOTONIC_BASE = BigInt(Math.round(performance.timeOrigin)) * NS_PER_MS4;
     MAX_READ = 1024 * 1024;
     SIGPIPE_EXIT = 128 + SIG.PIPE;
     SIG_IGN = 1;
@@ -3811,6 +3942,11 @@ var init_wasi_host = __esm({
               this.entered
             );
           },
+          sigaction_inherited: (out) => {
+            const bits = this.o.kernel.call({ op: "sig-inherited" });
+            mem.view().setBigUint64(out, BigInt(libcBits(bits) >>> 0), true);
+            return E.SUCCESS;
+          },
           sigpending_get: (out) => {
             if (!this.sigmask) return E.NOSYS;
             mem.view().setBigUint64(out, BigInt(this.sigmask.pending()), true);
@@ -3890,7 +4026,7 @@ var init_wasi_host = __esm({
         return this.cache;
       }
       now(id) {
-        if (id === CLOCK.REALTIME) return BigInt(Date.now()) * NS_PER_MS3;
+        if (id === CLOCK.REALTIME) return BigInt(Date.now()) * NS_PER_MS4;
         if (id === CLOCK.MONOTONIC) {
           return MONOTONIC_BASE + BigInt(Math.round(performance.now() * 1e6));
         }
@@ -4431,7 +4567,7 @@ var init_wasi_host = __esm({
           current ??= statOf(path);
           return current[field2] ?? current.mtimeMs ?? now;
         };
-        const pick = (set, setNow, value2, field2) => flags & setNow ? now : flags & set ? Number(value2 / NS_PER_MS3) : kept(field2);
+        const pick = (set, setNow, value2, field2) => flags & setNow ? now : flags & set ? Number(value2 / NS_PER_MS4) : kept(field2);
         (follow2 ? this.o.fs.utimes : this.o.fs.lutimes).call(
           this.o.fs,
           path,
@@ -5031,7 +5167,7 @@ var KERNEL_VERSION, OS_RELEASE;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    KERNEL_VERSION = true ? "1.107.1" : "0.0.0-dev";
+    KERNEL_VERSION = true ? "1.108.0" : "0.0.0-dev";
     OS_RELEASE = "6.0.0-slicc";
   }
 });
@@ -12612,7 +12748,7 @@ var init_process_signals = __esm({
     init_signals();
     init_sync_sab_wire();
     SignalGate = class {
-      reported = { caught: 0, ignored: 0 };
+      reported = { caught: 0, ignored: 0, nocldwait: false };
       restart = 0;
       lastDelivered = 0;
       depth = 0;
@@ -12665,10 +12801,18 @@ var init_process_signals = __esm({
         if (!masks) return;
         this.restart = masks.restart;
         const { caught, ignored, defaults = 0 } = masks;
-        const same = caught === this.reported.caught && ignored === this.reported.ignored;
+        const nocldwait = masks.nocldwait === true;
+        const was = this.reported;
+        const same = caught === was.caught && ignored === was.ignored && nocldwait === was.nocldwait;
         if (same && defaults === 0) return;
-        this.reported = { caught, ignored };
-        const req = { op: "sig-mask", caught, ignored, ...defaults ? { defaults } : {} };
+        this.reported = { caught, ignored, nocldwait };
+        const req = {
+          op: "sig-mask",
+          caught,
+          ignored,
+          ...defaults ? { defaults } : {},
+          ...nocldwait ? { nocldwait } : {}
+        };
         this.raw.call(req, Number.POSITIVE_INFINITY, "sig-mask");
       }
       quiet(fn) {
@@ -13619,138 +13763,8 @@ var init_wasi_module = __esm({
   }
 });
 
-// src/process/wasi/wasi-sigmask.ts
-var UNBLOCKABLE, LIBC_UNBLOCKABLE, FOREVER2, NS_PER_MS4, POLL_MS, SIG_BLOCK, SIG_UNBLOCK, SIG_SETMASK, kernelBits, libcBits, apply, WasiSigmask;
-var init_wasi_sigmask = __esm({
-  "src/process/wasi/wasi-sigmask.ts"() {
-    "use strict";
-    init_signals();
-    init_sync_sab_wire();
-    init_wasi_abi();
-    UNBLOCKABLE = sigbit(SIG.KILL) | sigbit(SIG.STOP);
-    LIBC_UNBLOCKABLE = 1 << SIG.KILL - 1 | 1 << SIG.STOP - 1;
-    FOREVER2 = 0xffffffffffffffffn;
-    NS_PER_MS4 = 1000000n;
-    POLL_MS = 50;
-    SIG_BLOCK = 0;
-    SIG_UNBLOCK = 1;
-    SIG_SETMASK = 2;
-    kernelBits = (lo) => lo << 1 & ~UNBLOCKABLE;
-    libcBits = (bits) => bits >>> 1 & ~LIBC_UNBLOCKABLE;
-    apply = (how, mask, set) => {
-      if (how === SIG_BLOCK) return mask | set;
-      if (how === SIG_UNBLOCK) return mask & ~set;
-      return set;
-    };
-    WasiSigmask = class {
-      lo;
-      hi;
-      header;
-      deliver;
-      process;
-      tid;
-      constructor(header, deliver, process, tid = 1) {
-        this.header = header;
-        this.deliver = deliver;
-        this.process = process;
-        this.tid = tid;
-        this.lo = libcBits(Atomics.load(header, SAB_I_BLOCKED));
-        this.hi = Atomics.load(header, SAB_I_BLOCKED_HI);
-      }
-      static unsupported(header) {
-        storeBlocked(header, [0, 0]);
-      }
-      set(how, setLo, setHi, old) {
-        if (how !== SIG_BLOCK && how !== SIG_UNBLOCK && how !== SIG_SETMASK) return E.INVAL;
-        old(this.lo >>> 0, this.hi >>> 0);
-        this.lo = apply(how, this.lo, setLo | 0) & ~LIBC_UNBLOCKABLE;
-        this.hi = apply(how, this.hi, setHi | 0);
-        const now = kernelBits(this.lo);
-        storeBlocked(this.header, [now, this.hi]);
-        if ((Atomics.load(this.header, SAB_I_SIGNALS) & ~now) !== 0) this.deliver();
-        return E.SUCCESS;
-      }
-      swap(setLo, setHi) {
-        const old = [this.lo, this.hi];
-        this.lo = setLo & ~LIBC_UNBLOCKABLE;
-        this.hi = setHi | 0;
-        storeBlocked(this.header, [kernelBits(this.lo), this.hi]);
-        return old;
-      }
-      deliverUnblocked() {
-        const now = Atomics.load(this.header, SAB_I_BLOCKED);
-        if ((Atomics.load(this.header, SAB_I_SIGNALS) & ~now) === 0) return false;
-        this.deliver();
-        return true;
-      }
-      restore([lo, hi]) {
-        this.set(SIG_SETMASK, lo, hi, () => {
-        });
-      }
-      blockedBits() {
-        return Atomics.load(this.header, SAB_I_BLOCKED);
-      }
-      blocks(sig) {
-        return (Atomics.load(this.header, SAB_I_BLOCKED) & sigbit(sig)) !== 0;
-      }
-      inherited() {
-        return [kernelBits(this.lo), this.hi];
-      }
-      discard(sig) {
-        Atomics.and(this.header, SAB_I_SIGNALS, ~sigbit(sig));
-        if (this.process) Atomics.and(this.process, SAB_I_SIGNALS, ~sigbit(sig));
-      }
-      sigwait(setLo, timeoutNs, publish, took, entered = false) {
-        const set = kernelBits(setLo | 0);
-        const value2 = BigInt.asUintN(64, timeoutNs);
-        const deadline = value2 === FOREVER2 ? Number.POSITIVE_INFINITY : performance.now() + Number((value2 + NS_PER_MS4 - 1n) / NS_PER_MS4);
-        publish(set);
-        try {
-          for (; ; ) {
-            const seen = Atomics.load(this.header, SAB_I_SIGNALS);
-            const sig = this.take(set);
-            if (sig !== 0) {
-              took(sig);
-              return E.SUCCESS;
-            }
-            if (entered || this.deliverUnblocked() || this.interrupted()) return E.INTR;
-            const left = deadline - performance.now();
-            if (left <= 0) return E.AGAIN;
-            Atomics.wait(this.header, SAB_I_SIGNALS, seen, Math.min(left, POLL_MS));
-          }
-        } finally {
-          publish(0);
-        }
-      }
-      take(set) {
-        for (const header of this.process ? [this.header, this.process] : [this.header]) {
-          const ready = Atomics.load(header, SAB_I_SIGNALS) & set;
-          if (ready === 0) continue;
-          const bit = ready & -ready;
-          if ((Atomics.and(header, SAB_I_SIGNALS, ~bit) & bit) !== 0) return 31 - Math.clz32(bit);
-        }
-        return 0;
-      }
-      interrupted() {
-        const killed = this.process ?? this.header;
-        if (Atomics.load(killed, SAB_I_KILLED) !== 0) {
-          this.deliver();
-          return true;
-        }
-        if (Atomics.load(killed, SAB_I_STOP) !== 1) return false;
-        while (Atomics.load(killed, SAB_I_STOP) === 1) Atomics.wait(killed, SAB_I_STOP, 1);
-        return true;
-      }
-      pending() {
-        const own = Atomics.load(this.header, SAB_I_SIGNALS);
-        return libcBits(own | (this.process ? Atomics.load(this.process, SAB_I_SIGNALS) : 0));
-      }
-    };
-  }
-});
-
 // src/process/wasi/wasi-signals.ts
-var DELIVERED_MASK, KERNEL_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, SA_NOCLDWAIT, DISPOSITION_IGNORE, DISPOSITION_HANDLER, withBit, WASIX_LIBC_DEFAULT_LINE, WasiSignals;
 var init_wasi_signals = __esm({
   "src/process/wasi/wasi-signals.ts"() {
     "use strict";
@@ -13761,6 +13775,7 @@ var init_wasi_signals = __esm({
     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;
+    SA_NOCLDWAIT = 2;
     DISPOSITION_IGNORE = 1;
     DISPOSITION_HANDLER = 2;
     withBit = (mask, bit, on) => on ? mask | bit : mask & ~bit;
@@ -13777,6 +13792,7 @@ var init_wasi_signals = __esm({
       ignoring = 0;
       restarting = 0;
       defaults = 0;
+      nocldwait = false;
       fallBack;
       onKilled;
       constructor(fallBack, onKilled) {
@@ -13802,6 +13818,7 @@ var init_wasi_signals = __esm({
         this.ignoring = withBit(this.ignoring, bit, disposition === DISPOSITION_IGNORE);
         this.restarting = withBit(this.restarting, bit, (flags & SA_RESTART) !== 0);
         this.defaults = withBit(this.defaults, bit, disposition === 0);
+        if (sig === SIG.CHLD) this.nocldwait = (flags & SA_NOCLDWAIT) !== 0;
         return E.SUCCESS;
       }
       snapshot() {
@@ -13811,7 +13828,8 @@ var init_wasi_signals = __esm({
           handlers: this.handlers,
           ignoring: this.ignoring,
           restarting: this.restarting,
-          uncaught: this.uncaught
+          uncaught: this.uncaught,
+          ...this.nocldwait ? { nocldwait: true } : {}
         };
       }
       restore(state) {
@@ -13821,13 +13839,15 @@ var init_wasi_signals = __esm({
         this.ignoring = state.ignoring;
         this.restarting = state.restarting;
         this.uncaught = state.uncaught;
+        this.nocldwait = state.nocldwait === true;
       }
       masks() {
         if (this.hooked) {
           const caught = this.handler() ? this.handlers : 0;
           const defaults = this.defaults;
           this.defaults = 0;
-          return { caught, ignored: this.ignoring, restart: this.restarting, defaults };
+          const nocldwait = this.nocldwait ? { nocldwait: true } : {};
+          return { caught, ignored: this.ignoring, restart: this.restarting, defaults, ...nocldwait };
         }
         if (!this.handler()) return null;
         return { caught: DELIVERED_MASK & ~this.uncaught & ~KERNEL_DEFAULTS, ignored: 0, restart: 0 };