@ai-ecoverse/slicc-kernel 1.107.0 → 1.108.0

package/dist/process-worker.js

@@ -2491,7 +2491,7 @@ var KERNEL_VERSION, OS_RELEASE;
 var init_version = __esm({
   "src/version.ts"() {
     "use strict";
-    KERNEL_VERSION = true ? "1.107.0" : "0.0.0-dev";
+    KERNEL_VERSION = true ? "1.108.0" : "0.0.0-dev";
     OS_RELEASE = "6.0.0-slicc";
   }
 });
@@ -4721,7 +4721,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;
@@ -4774,10 +4774,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) {
@@ -6395,7 +6403,7 @@ function cachingBridge(bridge, now = () => performance.now(), shared) {
     symlink: (target, link) => mutating(() => bridge.symlink(target, link), ...entry(link)),
     chmod: (p, mode) => rewriting(p, () => bridge.chmod(p, mode)),
     utimes: (p, a, m, now2) => rewriting(p, () => bridge.utimes(p, a, m, now2)),
-    lutimes: (p, a, m, now2) => mutating(() => bridge.lutimes(p, a, m, now2), p),
+    lutimes: (p, a, m, now2) => mutating(() => bridge.lutimes(p, a, m, now2)),
     ...bridge.hold ? { hold: bridge.hold.bind(bridge) } : {},
     ...bridge.access ? { access: bridge.access.bind(bridge) } : {},
     ...bridge.kept ? { kept: bridge.kept.bind(bridge) } : {},
@@ -6436,7 +6444,7 @@ function pinnedIo2(bridge, handle, rewriting) {
     } : {}
   };
 }
-var WasiError, FileBuffer, LocalFile, MAX_LINKS, MISS_TTL_MS, FS_GEN, CRED_GEN, RING2, RING_SIZE2, SLOT2, SHARED_IDS_BYTES, StatCache;
+var WasiError, FileBuffer, LocalFile, MAX_LINKS, MISS_TTL_MS, CACHE_CAP, FS_GEN, CRED_GEN, RING2, RING_SIZE2, SLOT2, SHARED_IDS_BYTES, StatCache;
 var init_wasi_files = __esm({
   "src/process/wasi/wasi-files.ts"() {
     "use strict";
@@ -6657,6 +6665,7 @@ var init_wasi_files = __esm({
     };
     MAX_LINKS = 40;
     MISS_TTL_MS = 20;
+    CACHE_CAP = 8192;
     FS_GEN = 4;
     CRED_GEN = 5;
     RING2 = 8;
@@ -6668,6 +6677,7 @@ var init_wasi_files = __esm({
       lstats = /* @__PURE__ */ new Map();
       byHash = /* @__PURE__ */ new Map();
       byIno = /* @__PURE__ */ new Map();
+      missed = /* @__PURE__ */ new Map();
       shared;
       seen;
       constructor(shared) {
@@ -6675,7 +6685,14 @@ var init_wasi_files = __esm({
         this.seen = shared ? Atomics.load(shared, FS_GEN) : 0;
       }
       put(map, path, entry) {
+        if (this.stats.size + this.lstats.size + this.byHash.size + this.byIno.size >= CACHE_CAP)
+          this.clear();
         map.set(path, entry);
+        if ("until" in entry) {
+          const paths = this.missed.get(map) ?? /* @__PURE__ */ new Set();
+          paths.add(path);
+          this.missed.set(map, paths);
+        }
         if (!this.shared) return;
         index(this.byHash, pathHash(path), path);
         const ino = inoKey(entry);
@@ -6702,12 +6719,21 @@ var init_wasi_files = __esm({
         this.lstats.delete(path);
       }
       mutated(paths, ino = 0) {
-        this.clear();
-        if (!this.shared) return;
         const key = ino % 4294967296 | 0;
+        if (paths.length === 0 || !this.shared) this.clear();
+        if (!this.shared) return;
         for (const [i, hash] of (paths.length > 0 ? paths.map(pathHash) : [0]).entries()) {
-          this.seen = this.publish(this.shared, hash, i === 0 ? key : 0);
+          const g = this.publish(this.shared, hash, i === 0 ? key : 0);
+          if (paths.length > 0) this.replay(g - 1);
+          this.seen = g;
         }
+        if (paths.length === 0) return;
+        for (const [i, path] of paths.entries()) {
+          this.stats.delete(path);
+          this.lstats.delete(path);
+          this.drop(pathHash(path), i === 0 ? key : 0);
+        }
+        this.forgetMisses();
       }
       inoOf(path, look) {
         if (!this.shared) return 0;
@@ -6755,7 +6781,14 @@ var init_wasi_files = __esm({
         this.byHash.delete(hash);
         if (ino !== 0) this.byIno.delete(ino);
       }
+      forgetMisses() {
+        for (const [map, paths] of this.missed) {
+          for (const path of paths) if ("until" in (map.get(path) ?? {})) map.delete(path);
+        }
+        this.missed.clear();
+      }
       clear() {
+        this.missed.clear();
         this.stats.clear();
         this.lstats.clear();
         this.byHash.clear();
@@ -7934,6 +7967,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);
@@ -8012,8 +8175,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) {
@@ -8074,7 +8237,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";
@@ -8084,9 +8247,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;
@@ -8481,7 +8644,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) {
@@ -8531,7 +8694,7 @@ function wrap(table) {
   }
   return out;
 }
-var WasiExit, IDS, NS_PER_MS3, AT_SYMLINK_NOFOLLOW2, AT_EACCESS2, 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_NOFOLLOW2, AT_EACCESS2, 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";
@@ -8548,6 +8711,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();
@@ -8559,14 +8723,14 @@ var init_wasi_host = __esm({
       }
     };
     IDS = ["ruid", "euid", "suid", "rgid", "egid", "sgid"];
-    NS_PER_MS3 = 1000000n;
+    NS_PER_MS4 = 1000000n;
     AT_SYMLINK_NOFOLLOW2 = 1;
     AT_EACCESS2 = 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;
@@ -8843,6 +9007,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);
@@ -8922,7 +9091,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));
         }
@@ -9463,7 +9632,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,
@@ -10463,138 +10632,8 @@ var init_wasi_procfs = __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";
@@ -10605,6 +10644,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;
@@ -10621,6 +10661,7 @@ var init_wasi_signals = __esm({
       ignoring = 0;
       restarting = 0;
       defaults = 0;
+      nocldwait = false;
       fallBack;
       onKilled;
       constructor(fallBack, onKilled) {
@@ -10646,6 +10687,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() {
@@ -10655,7 +10697,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) {
@@ -10665,13 +10708,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 };