@ai-ecoverse/slicc-kernel 1.107.1 → 1.108.1

package/dist/node-process-worker.js

@@ -2497,7 +2497,7 @@ var init_wasi_fds = __esm({
         const flags = want === 6 ? O_RDWR : want === 2 ? O_WRONLY : 0;
         return openDevice2.call(this.kernel.sys, flags);
       }
-      open(path, oflags, rights, fdflags) {
+      open(path, oflags, rights, fdflags, mode) {
         const device2 = deviceOf(path);
         if (device2) return this.install({ type: "device", device: device2 });
         const kernelDevice = this.openKernelDevice(path, oflags, fdflags, rights);
@@ -2518,13 +2518,16 @@ var init_wasi_fds = __esm({
         }
         if (!s && !(oflags & OFLAGS.CREAT)) throw new WasiError("ENOENT");
         refuseWrite(s, oflags, rights);
-        return this.regular(path, s, oflags, rights, fdflags);
+        return this.regular(path, s, oflags, rights, fdflags, mode);
       }
-      regular(path, s, oflags, rights, fdflags) {
+      regular(path, s, oflags, rights, fdflags, mode) {
         if (this.shared || this.kernelHolds(path, s)) {
-          return this.kernelFile(path, s, oflags, rights, fdflags);
+          return this.kernelFile(path, s, oflags, rights, fdflags, mode);
         }
-        return this.install({ type: "file", file: this.file(path, s, oflags, rights, fdflags) });
+        return this.install({
+          type: "file",
+          file: this.file(path, s, oflags, rights, fdflags, mode)
+        });
       }
       kernelHolds(path, st) {
         for (const [fd, e] of this.table) {
@@ -2546,7 +2549,7 @@ var init_wasi_fds = __esm({
         } catch {
         }
       }
-      file(path, existing, oflags, rights, fdflags) {
+      file(path, existing, oflags, rights, fdflags, mode) {
         const { readable: readable3, writable: writable2 } = openAccess(existing, oflags, rights);
         let buffer = this.buffers.get(path);
         if (buffer?.handle !== void 0 && this.fs.kept?.(buffer.handle)) {
@@ -2559,13 +2562,13 @@ var init_wasi_fds = __esm({
           if (this.fs.owners) this.fs.access?.(path, want, "open");
           if (oflags & OFLAGS.TRUNC) buffer.truncate(0);
         } else {
-          buffer = this.freshBuffer(path, existing, oflags, want);
+          buffer = this.freshBuffer(path, existing, oflags, want, mode);
         }
         buffer.opens++;
         return new LocalFile(buffer, readable3, writable2, (fdflags & FDFLAGS.APPEND) !== 0);
       }
-      freshBuffer(path, existing, oflags, want) {
-        const made = !existing && this.createNew(path, oflags);
+      freshBuffer(path, existing, oflags, want, mode) {
+        const made = !existing && this.createNew(path, oflags, mode);
         const empty = made || (oflags & OFLAGS.TRUNC) !== 0;
         if (existing?.ranged) this.fs.invalidate?.();
         const seen = this.fs.changes?.now();
@@ -2595,11 +2598,11 @@ var init_wasi_fds = __esm({
         if (id !== void 0) this.know(buffer, id);
         return buffer;
       }
-      kernelFile(path, existing, oflags, rights, fdflags) {
+      kernelFile(path, existing, oflags, rights, fdflags, mode) {
         const { readable: readable3, writable: writable2 } = openAccess(existing, oflags, rights);
         const append = (fdflags & FDFLAGS.APPEND) !== 0;
         const flags = (writable2 ? readable3 ? O_RDWR : O_WRONLY : 0) | (append ? O_APPEND : 0);
-        const made = !existing && this.createNew(path, oflags);
+        const made = !existing && this.createNew(path, oflags, mode);
         const truncate = made || (oflags & OFLAGS.TRUNC) !== 0;
         const fd = this.kernel.sys.openVfs(path, flags, 0, {
           ...truncate ? { truncate } : {},
@@ -2612,13 +2615,13 @@ var init_wasi_fds = __esm({
         this.bump();
         return fd;
       }
-      createNew(path, oflags) {
+      createNew(path, oflags, mode) {
         if (!this.fs.create) {
           this.fs.writeFile(path, new Uint8Array(0));
           return true;
         }
         try {
-          this.fs.create(path, void 0, true);
+          this.fs.create(path, mode, true);
           return true;
         } catch (err) {
           if (oflags & OFLAGS.EXCL || err.code !== "EEXIST") throw err;
@@ -2856,6 +2859,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 +3067,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 +3129,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 +3139,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 +3582,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 +3632,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 +3649,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 +3661,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 +3945,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 +4029,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 +4570,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,
@@ -4761,13 +4900,15 @@ function importsContext({
   const fds = {
     open(path, o = {}) {
       const abs = host.fds.resolve(3, path);
-      if (o.nofollow && fs.exists(abs) && fs.lstat(abs).isSymbolicLink)
+      const fresh = o.create === true && o.exclusive === true && owners && fs.create !== void 0;
+      if (!fresh && o.nofollow && fs.exists(abs) && fs.lstat(abs).isSymbolicLink)
         throw new WasiError("ELOOP");
-      const existed = fs.exists(abs);
+      const existed = !fresh && fs.exists(abs);
       const oflags = (o.create ? OFLAGS.CREAT : 0) | (o.exclusive ? OFLAGS.EXCL : 0) | (o.truncate ? OFLAGS.TRUNC : 0) | (o.directory ? OFLAGS.DIRECTORY : 0);
       const rights = (o.write ? RIGHTS.FD_WRITE : 0n) | (o.read || !o.write ? RIGHTS.FD_READ : 0n);
-      const fd = host.fds.open(abs, oflags, rights, o.append ? FDFLAGS.APPEND : 0);
-      if (o.mode !== void 0 && !existed) fs.chmod(abs, o.mode);
+      const flags = o.append ? FDFLAGS.APPEND : 0;
+      const fd = host.fds.open(abs, oflags, rights, flags, fresh ? o.mode : void 0);
+      if (o.mode !== void 0 && !existed && !fresh) fs.chmod(abs, o.mode);
       return fd;
     },
     close(fd) {
@@ -5031,7 +5172,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.1" : "0.0.0-dev";
     OS_RELEASE = "6.0.0-slicc";
   }
 });
@@ -12612,7 +12753,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 +12806,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 +13768,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 +13780,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 +13797,7 @@ var init_wasi_signals = __esm({
       ignoring = 0;
       restarting = 0;
       defaults = 0;
+      nocldwait = false;
       fallBack;
       onKilled;
       constructor(fallBack, onKilled) {
@@ -13802,6 +13823,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 +13833,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 +13844,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 };