@ai-ecoverse/slicc-kernel 1.87.0 → 1.88.0

package/dist/node-process-worker.js

@@ -830,9 +830,9 @@ var init_wasi_files = __esm({
       readable;
       writable;
       append;
-      constructor(buffer, readable2, writable2, append) {
+      constructor(buffer, readable3, writable2, append) {
         this.buffer = buffer;
-        this.readable = readable2;
+        this.readable = readable3;
         this.writable = writable2;
         this.append = append;
       }
@@ -1015,6 +1015,7 @@ var init_wasi_threads = __esm({
       beforeSpawn;
       modules;
       received;
+      blocked;
       port;
       memory;
       cap;
@@ -1035,6 +1036,7 @@ var init_wasi_threads = __esm({
         this.beforeSpawn?.();
         const tid = Atomics.add(this.ids, LAST_TID, 1) + 1;
         const modules = this.modules?.();
+        const blocked = this.blocked?.() ?? 0;
         this.port.postMessage({
           type: WASM_THREAD_SPAWN,
           thread: {
@@ -1042,7 +1044,8 @@ var init_wasi_threads = __esm({
             arg,
             memory: this.memory,
             ids: this.ids.buffer,
-            ...modules ? { modules } : {}
+            ...modules ? { modules } : {},
+            ...blocked ? { blocked } : {}
           }
         });
         return tid;
@@ -1160,11 +1163,11 @@ function sabViews(sab) {
     window: new Uint8Array(sab, SAB_HEADER_BYTES)
   };
 }
-var SAB_HEADER_I32, SAB_CLOCK_OFFSET, SAB_CLOCK_I64, SAB_HEADER_BYTES, SAB_I_STATE, SAB_I_SEQ, SAB_I_STATUS, SAB_I_TOTAL, SAB_I_CHUNK, SAB_I_OFFSET, SAB_I_REQ, SAB_I_PUB, SAB_I_SIGNALS, SAB_I_TIMERS, SAB_I_MEMORY, SAB_I_TOTAL_HI, SAB_I_OFFSET_HI, SAB_I_KILLED, SAB_I_ASYNC, SAB_I_STOP, U32, SAB_STATE_IDLE, SAB_STATE_PENDING, SAB_STATE_READY, SAB_STATUS_BYTES, SAB_STATUS_JSON, SAB_STATUS_VOID, SAB_STATUS_ERRNO, SAB_DEFAULT_WINDOW_BYTES, SAB_MIN_BYTES, SYNC_SAB_REQ_MSG, SYNC_SAB_NEXT_MSG, encoder, decoder;
+var SAB_HEADER_I32, SAB_CLOCK_OFFSET, SAB_CLOCK_I64, SAB_HEADER_BYTES, SAB_I_STATE, SAB_I_SEQ, SAB_I_STATUS, SAB_I_TOTAL, SAB_I_CHUNK, SAB_I_OFFSET, SAB_I_REQ, SAB_I_PUB, SAB_I_SIGNALS, SAB_I_TIMERS, SAB_I_MEMORY, SAB_I_TOTAL_HI, SAB_I_OFFSET_HI, SAB_I_KILLED, SAB_I_ASYNC, SAB_I_STOP, SAB_I_BLOCKED, U32, SAB_STATE_IDLE, SAB_STATE_PENDING, SAB_STATE_READY, SAB_STATUS_BYTES, SAB_STATUS_JSON, SAB_STATUS_VOID, SAB_STATUS_ERRNO, SAB_DEFAULT_WINDOW_BYTES, SAB_MIN_BYTES, SYNC_SAB_REQ_MSG, SYNC_SAB_NEXT_MSG, encoder, decoder;
 var init_sync_sab_wire = __esm({
   "src/realm/sync-sab-wire.ts"() {
     "use strict";
-    SAB_HEADER_I32 = 16;
+    SAB_HEADER_I32 = 18;
     SAB_CLOCK_OFFSET = SAB_HEADER_I32 * 4;
     SAB_CLOCK_I64 = 3;
     SAB_HEADER_BYTES = SAB_CLOCK_OFFSET + SAB_CLOCK_I64 * 8;
@@ -1184,6 +1187,7 @@ var init_sync_sab_wire = __esm({
     SAB_I_KILLED = 13;
     SAB_I_ASYNC = 14;
     SAB_I_STOP = 15;
+    SAB_I_BLOCKED = 16;
     U32 = 2 ** 32;
     SAB_STATE_IDLE = 0;
     SAB_STATE_PENDING = 1;
@@ -2055,7 +2059,7 @@ var init_wasi_fds = __esm({
         }
       }
       file(path, existing, oflags, rights, fdflags) {
-        const { readable: readable2, writable: writable2 } = openAccess(existing, oflags, rights);
+        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)) {
           this.buffers.delete(path);
@@ -2070,7 +2074,7 @@ var init_wasi_fds = __esm({
           buffer = this.freshBuffer(path, existing, oflags, want);
         }
         buffer.opens++;
-        return new LocalFile(buffer, readable2, writable2, (fdflags & FDFLAGS.APPEND) !== 0);
+        return new LocalFile(buffer, readable3, writable2, (fdflags & FDFLAGS.APPEND) !== 0);
       }
       freshBuffer(path, existing, oflags, want) {
         const made = !existing && this.createNew(path, oflags);
@@ -2089,9 +2093,9 @@ var init_wasi_fds = __esm({
         return buffer;
       }
       kernelFile(path, existing, oflags, rights, fdflags) {
-        const { readable: readable2, writable: writable2 } = openAccess(existing, oflags, rights);
+        const { readable: readable3, writable: writable2 } = openAccess(existing, oflags, rights);
         const append = (fdflags & FDFLAGS.APPEND) !== 0;
-        const flags = (writable2 ? readable2 ? O_RDWR : O_WRONLY : 0) | (append ? O_APPEND : 0);
+        const flags = (writable2 ? readable3 ? O_RDWR : O_WRONLY : 0) | (append ? O_APPEND : 0);
         const made = !existing && this.createNew(path, oflags);
         const truncate = made || (oflags & OFLAGS.TRUNC) !== 0;
         const fd = this.kernel.sys.openVfs(path, flags, 0, {
@@ -2492,7 +2496,7 @@ function wrap(table) {
   }
   return out;
 }
-var WasiExit, IDS, NS_PER_MS, AT_SYMLINK_NOFOLLOW, AT_EACCESS, ROOT_IDS, GONE, S_IFIFO, DEFAULT_UMASK, MONOTONIC_BASE, MAX_READ, SIGPIPE_EXIT, SEALED_MODE, WasiHost;
+var WasiExit, IDS, NS_PER_MS, 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";
@@ -2523,6 +2527,7 @@ var init_wasi_host = __esm({
     MONOTONIC_BASE = BigInt(Math.round(performance.timeOrigin)) * NS_PER_MS;
     MAX_READ = 1024 * 1024;
     SIGPIPE_EXIT = 141;
+    SIG_IGN = 1;
     SEALED_MODE = 8630;
     WasiHost = class {
       mem = new WasiMemory();
@@ -2534,6 +2539,7 @@ var init_wasi_host = __esm({
       onRaise;
       muted;
       signals;
+      sigmask;
       interrupted;
       quietly = (fn) => fn();
       listening;
@@ -2725,7 +2731,23 @@ var init_wasi_host = __esm({
             const groups = Array.from({ length: n }, (_, i) => view.getUint32(buf + i * 4, true));
             void this.o.kernel.call({ op: "proc-setcred", change: { groups } });
           },
-          sigaction_set: (sig, disposition, flags) => this.signals ? this.signals.disposition(sig, disposition, flags) : E.NOSYS
+          sigaction_set: (sig, disposition, flags) => {
+            if (!this.signals) return E.NOSYS;
+            const errno2 = this.signals.disposition(sig, disposition, flags);
+            if (errno2 === E.SUCCESS && disposition === SIG_IGN) this.sigmask?.discard(sig);
+            return errno2;
+          },
+          sigmask_set: (how, lo, hi, old) => this.sigmask ? this.sigmask.set(how, lo, hi, (oldLo, oldHi) => {
+            if (old === 0) return;
+            const view = mem.view();
+            view.setUint32(old, oldLo, true);
+            view.setUint32(old + 4, oldHi, true);
+          }) : E.NOSYS,
+          sigpending_get: (out) => {
+            if (!this.sigmask) return E.NOSYS;
+            mem.view().setBigUint64(out, BigInt(this.sigmask.pending()), true);
+            return E.SUCCESS;
+          }
         });
       }
       imports() {
@@ -3819,6 +3841,20 @@ var init_signals = __esm({
   }
 });
 
+// src/version.ts
+function procVersion() {
+  return `Linux version ${OS_RELEASE} (slicc-kernel ${KERNEL_VERSION}) #1 SMP PREEMPT_DYNAMIC
+`;
+}
+var KERNEL_VERSION, OS_RELEASE;
+var init_version = __esm({
+  "src/version.ts"() {
+    "use strict";
+    KERNEL_VERSION = true ? "1.88.0" : "0.0.0-dev";
+    OS_RELEASE = "6.0.0-slicc";
+  }
+});
+
 // src/process/js/js-kernel.ts
 function modeOf(mode) {
   if (!Number.isInteger(mode) || mode < 0 || mode > 4095) {
@@ -4104,6 +4140,7 @@ function childOps(kernel, io, defaults, sync) {
     if (file === void 0) throw new JsCallError("EINVAL", "spawn");
     const group = groupOf(o, "spawn");
     const named = argv0Of(o.argv0, "spawn");
+    const death = deathOf(o.parentDeathSignal, defaults);
     return (stdio) => ({
       op: "proc-spawn",
       file,
@@ -4112,7 +4149,8 @@ function childOps(kernel, io, defaults, sync) {
       env: { ...o.env ?? defaults.env },
       cwd: o.cwd ?? defaults.cwd,
       stdio,
-      ...group
+      ...group,
+      ...death
     });
   };
   const spawnSync = (o) => {
@@ -4155,6 +4193,13 @@ function groupOf(o, call2) {
   if (session && pgid !== void 0) throw new JsCallError("EINVAL", call2);
   return session ? { session: true } : pgid !== void 0 ? { pgid } : {};
 }
+function deathOf(signal, defaults) {
+  if (signal === void 0) return {};
+  if (typeof signal !== "number" && typeof signal !== "string") {
+    throw new JsCallError("EINVAL", "spawn");
+  }
+  return { deathSignal: defaults.signal(signal) };
+}
 function argv0Of(argv0, call2) {
   if (argv0 === void 0) return {};
   if (typeof argv0 !== "string") throw new JsCallError("EINVAL", call2);
@@ -5114,7 +5159,7 @@ function netOps(kernel, io) {
       return closed;
     };
     const shut = (how) => kernel.raw({ op: "sock-shutdown", fd, how });
-    const readable2 = new ReadableStream(
+    const readable3 = new ReadableStream(
       {
         async pull(controller) {
           const chunk = await io.read(fd, void 0, stop.signal);
@@ -5130,7 +5175,7 @@ function netOps(kernel, io) {
       close: async () => void await shut(SHUT_WR),
       abort: () => close()
     });
-    return { fd, local: local2, remote, readable: readable2, writable: writable2, close };
+    return { fd, local: local2, remote, readable: readable3, writable: writable2, close };
   };
   const resolve = async (host, signal) => {
     if (IPV4.test(host)) return host;
@@ -5964,7 +6009,7 @@ function websocketOp(kernel) {
         reason: closeReason(how.reason)
       });
     };
-    const readable2 = new ReadableStream(
+    const readable3 = new ReadableStream(
       {
         async pull(controller) {
           let r;
@@ -6014,7 +6059,7 @@ function websocketOp(kernel) {
       close: () => close(),
       abort: () => close({ code: 1e3, reason: "" })
     });
-    return { url, protocol, readable: readable2, writable: writable2, closed, close };
+    return { url, protocol, readable: readable3, writable: writable2, closed, close };
   };
 }
 var SEND_BUFFER, MAX_REASON, NEVER2, wait;
@@ -6047,9 +6092,11 @@ function signalNumber(signal) {
     if (Number.isInteger(signal) && signal >= 1 && signal <= 31) return signal;
     throw new JsCallError("EINVAL", `signal ${signal}`);
   }
-  const n = SIG[signal.slice(3)];
-  if (n === void 0) throw new JsCallError("EINVAL", `signal ${signal}`);
-  return n;
+  const name2 = signal.slice(3);
+  if (!signal.startsWith("SIG") || !Object.hasOwn(SIG, name2)) {
+    throw new JsCallError("EINVAL", `signal ${signal}`);
+  }
+  return SIG[name2];
 }
 function resolvePath(cwd, path) {
   const parts = [];
@@ -6119,6 +6166,18 @@ function writer(kernel, info, pid) {
   };
   return { writes, writeAll };
 }
+function readable2(read2) {
+  return new ReadableStream(
+    {
+      async pull(controller) {
+        const chunk = await read2(0);
+        if (chunk.length === 0) controller.close();
+        else controller.enqueue(chunk);
+      }
+    },
+    { highWaterMark: 0 }
+  );
+}
 function createContext(o) {
   const { kernel } = o;
   const infos = /* @__PURE__ */ new Map();
@@ -6199,6 +6258,7 @@ function createContext(o) {
   const syncKernel = new JsSyncKernel(lane, kernel, unwind);
   const terminal = ttyOps(kernel);
   const sync = {
+    kernel: KERNEL_INFO,
     ...syncOps(syncKernel, { pid: o.pid, resolve, random, infos, handles }),
     run: (options) => runSync(syncKernel, { env: o.env, cwd: o.cwd, resolve, signal: signalNumber }, options),
     spawn: (options) => spawnSync(options),
@@ -6220,6 +6280,7 @@ function createContext(o) {
   const { spawnSync, ...children } = childOps(kernel, io, defaults, syncKernel);
   const strays = o.strays ?? { exception: /* @__PURE__ */ new Set(), rejection: /* @__PURE__ */ new Set() };
   const ctx = {
+    kernel: KERNEL_INFO,
     argv: o.argv,
     env: o.env,
     pid: o.pid,
@@ -6227,16 +6288,7 @@ function createContext(o) {
       return identityOf(await kernel.json({ op: "proc-identity" }), o).ppid;
     },
     cwd: o.cwd,
-    stdin: new ReadableStream(
-      {
-        async pull(controller) {
-          const chunk = await read2(0);
-          if (chunk.length === 0) controller.close();
-          else controller.enqueue(chunk);
-        }
-      },
-      { highWaterMark: 0 }
-    ),
+    stdin: readable2(read2),
     stdout: writable2(1),
     stderr: writable2(2),
     read: read2,
@@ -6445,12 +6497,13 @@ function pathOps(kernel, resolve, statOf, open) {
     }
   };
 }
-var JsExit, encoder4;
+var KERNEL_INFO, JsExit, encoder4;
 var init_js_context = __esm({
   "src/process/js/js-context.ts"() {
     "use strict";
     init_signals();
     init_sync_fs_wire();
+    init_version();
     init_js_children();
     init_js_dev();
     init_js_exit();
@@ -6462,6 +6515,7 @@ var init_js_context = __esm({
     init_js_sync();
     init_js_tty();
     init_js_websocket();
+    KERNEL_INFO = Object.freeze({ version: KERNEL_VERSION });
     JsExit = class extends Error {
       status;
       constructor(status2) {
@@ -9498,7 +9552,7 @@ var init_process_signals = __esm({
       interrupt() {
         this.report();
         const header = this.header;
-        const pending = Atomics.load(header, SAB_I_SIGNALS) | Atomics.load(header, SAB_I_TIMERS) | Atomics.load(header, SAB_I_KILLED);
+        const pending = Atomics.load(header, SAB_I_SIGNALS) & ~Atomics.load(header, SAB_I_BLOCKED) | Atomics.load(header, SAB_I_TIMERS) | Atomics.load(header, SAB_I_KILLED);
         if (pending === 0) return false;
         this.deliver();
         return true;
@@ -9511,7 +9565,8 @@ var init_process_signals = __esm({
           this.hooks.killed(killed);
         }
         const timers = Atomics.exchange(this.header, SAB_I_TIMERS, 0);
-        const pending = Atomics.exchange(this.header, SAB_I_SIGNALS, 0);
+        const blocked = Atomics.load(this.header, SAB_I_BLOCKED);
+        const pending = blocked === 0 ? Atomics.exchange(this.header, SAB_I_SIGNALS, 0) : Atomics.and(this.header, SAB_I_SIGNALS, blocked) & ~blocked;
         if (this.depth <= 1) this.lastDelivered = pending | (timers & 1 ? sigbit(SIG.ALRM) : 0);
         if (pending !== 0 || timers !== 0) this.delivered++;
         for (let which = 0; which < 3; which++) {
@@ -9689,6 +9744,14 @@ var init_process_sockets = __esm({
 });
 
 // src/process/procfs.ts
+function sysEntry(parts) {
+  let at = SYS_TREE;
+  for (const part of parts) {
+    if (typeof at !== "object" || !Object.hasOwn(at, part)) return void 0;
+    at = at[part];
+  }
+  return at;
+}
 function commOf(info) {
   const name2 = info.argv[0] ?? "";
   return name2.slice(name2.lastIndexOf("/") + 1).slice(0, 15);
@@ -9773,7 +9836,7 @@ function pidStatus(info) {
     "SigQ:	0/0",
     "SigPnd:	0000000000000000",
     "ShdPnd:	0000000000000000",
-    "SigBlk:	0000000000000000",
+    `SigBlk:	${sigMask(info.sigBlk)}`,
     `SigIgn:	${sigMask(info.sigIgn)}`,
     `SigCgt:	${sigMask(info.sigCgt)}`,
     ""
@@ -9809,6 +9872,7 @@ function memoryInfo(source, used = 0) {
   ].map(([key, value2]) => `${`${key}:`.padEnd(16)}${value2.padStart(12)}`).concat("").join("\n");
 }
 function systemFile(name2, listing, now, memory) {
+  if (name2 === "version") return procVersion();
   const up = Math.max(0, now - listing.boot) / 1e3;
   if (name2 === "uptime") return `${up.toFixed(2)} ${up.toFixed(2)}
 `;
@@ -9925,6 +9989,16 @@ function useProcfs(Fs, sys, pid, memory = memorySource()) {
     if (!info) throw error();
     return pidFile(name2, info, listing.boot);
   };
+  const sysDir = (parent, name2, tree) => {
+    const dir = fresh(parent, name2, DIR_MODE2);
+    dir.node_ops.lookup = (at, child) => {
+      if (!Object.hasOwn(tree, child)) throw error();
+      const next2 = tree[child];
+      return typeof next2 === "string" ? file(at, child, () => next2) : sysDir(at, child, next2);
+    };
+    dir.node_ops.readdir = () => [".", "..", ...Object.keys(tree)];
+    return dir;
+  };
   const pidNames = (names) => [.../* @__PURE__ */ new Set([...names, ...PID_FILES])];
   const pidDir = (name2, target) => {
     const dir = fresh(proc, name2, DIR_MODE2);
@@ -9949,7 +10023,7 @@ function useProcfs(Fs, sys, pid, memory = memorySource()) {
   const readdir = procOps.readdir?.bind(procOps);
   const listAll = (node) => {
     const names = new Set(readdir ? readdir(node) : [".", ".."]);
-    for (const name2 of [...SYSTEM_FILES, "mounts"]) names.add(name2);
+    for (const name2 of [...SYSTEM_FILES, "mounts", "sys"]) names.add(name2);
     for (const p of procList().processes) names.add(String(p.pid));
     return [...names];
   };
@@ -9961,6 +10035,7 @@ function useProcfs(Fs, sys, pid, memory = memorySource()) {
         return pidDir(name2, Number(name2));
       }
       if (name2 === "mounts") return file(parent, name2, () => mountTable(sys.mountList?.() ?? []));
+      if (name2 === "sys") return sysDir(parent, name2, SYS_TREE);
       if (SYSTEM_FILES.includes(name2)) {
         return file(
           parent,
@@ -10024,11 +10099,12 @@ function useProcfs(Fs, sys, pid, memory = memorySource()) {
     readdir: (node) => pidNames(selfReaddir ? selfReaddir(node) : [".", ".."])
   };
 }
-var HZ, DIR_MODE2, FILE_MODE, LINK_MODE2, ENOENT, EINVAL, UID2, KIB, FALLBACK_MEMORY, PID_FILES, SYSTEM_FILES, sigMask, STATES, tagLine;
+var HZ, DIR_MODE2, FILE_MODE, LINK_MODE2, ENOENT, EINVAL, UID2, KIB, FALLBACK_MEMORY, PID_FILES, SYSTEM_FILES, SYS_TREE, sigMask, STATES, tagLine;
 var init_procfs = __esm({
   "src/process/procfs.ts"() {
     "use strict";
     init_cred();
+    init_version();
     init_process_fds();
     HZ = 100;
     DIR_MODE2 = 16749;
@@ -10040,7 +10116,11 @@ var init_procfs = __esm({
     KIB = 1024;
     FALLBACK_MEMORY = 4 * KIB * KIB * KIB;
     PID_FILES = ["cmdline", "comm", "stat", "statm", "status"];
-    SYSTEM_FILES = ["loadavg", "meminfo", "stat", "uptime"];
+    SYSTEM_FILES = ["loadavg", "meminfo", "stat", "uptime", "version"];
+    SYS_TREE = {
+      kernel: { osrelease: `${OS_RELEASE}
+`, ostype: "Linux\n" }
+    };
     sigMask = (mask = 0) => (mask >>> 1).toString(16).padStart(16, "0");
     STATES = { S: "S (sleeping)", T: "T (stopped)", Z: "Z (zombie)" };
     tagLine = (tag) => `Tag:	${tag.replaceAll("\n", "\\n").replaceAll("	", "\\t").replaceAll("\r", "\\r")}`;
@@ -11014,11 +11094,17 @@ var init_wasi_procfs = __esm({
             names: () => [
               ...SYSTEM_NAMES,
               "mounts",
+              "sys",
               "self",
               ...this.listing().processes.map((p) => String(p.pid))
             ]
           };
         }
+        if (top === "sys") {
+          const entry = sysEntry(parts.slice(1));
+          if (typeof entry === "string") return { kind: "file", content: () => entry };
+          return entry && { kind: "dir", names: () => Object.keys(entry) };
+        }
         if (top === "self") {
           return leaf === void 0 ? { kind: "link", target: String(this.pid) } : void 0;
         }
@@ -11102,6 +11188,63 @@ var init_wasi_procfs = __esm({
   }
 });
 
+// src/process/wasi/wasi-sigmask.ts
+var UNBLOCKABLE, LIBC_UNBLOCKABLE, 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;
+    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 = 0;
+      header;
+      deliver;
+      process;
+      constructor(header, deliver, process) {
+        this.header = header;
+        this.deliver = deliver;
+        this.process = process;
+        this.lo = libcBits(Atomics.load(header, SAB_I_BLOCKED));
+      }
+      static unsupported(header) {
+        Atomics.store(header, SAB_I_BLOCKED, 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);
+        Atomics.store(this.header, SAB_I_BLOCKED, now);
+        if ((Atomics.load(this.header, SAB_I_SIGNALS) & ~now) !== 0) this.deliver();
+        return E.SUCCESS;
+      }
+      discard(sig) {
+        Atomics.and(this.header, SAB_I_SIGNALS, ~sigbit(sig));
+        if (this.process) Atomics.and(this.process, SAB_I_SIGNALS, ~sigbit(sig));
+      }
+      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 init_wasi_signals = __esm({
@@ -11187,7 +11330,11 @@ var init_wasi_signals = __esm({
       }
       raise(sig) {
         const handler = this.handler();
-        if (!handler) return;
+        if (!handler && !this.hooked) return;
+        if (!handler || this.hooked && (this.handlers & sigbit(sig)) === 0) {
+          if ((this.ignoring & sigbit(sig)) === 0) this.defaultAction(sig);
+          return;
+        }
         const outer = { sig: this.delivering, defaulted: this.defaulted, libc: this.libcDefault };
         this.delivering = sig;
         this.defaulted = false;
@@ -13064,6 +13211,7 @@ __export(wasi_runtime_exports, {
   delivering: () => delivering,
   runWasiProcess: () => runWasiProcess,
   runWasiThread: () => runWasiThread,
+  sigmaskOf: () => sigmaskOf,
   trapMessage: () => trapMessage,
   unsupportedImport: () => unsupportedImport,
   wireSignals: () => wireSignals
@@ -13100,6 +13248,16 @@ function delivering(ns, table, host, driver, before) {
   }
   return out;
 }
+function sigmaskOf(module, sab, gate, threads, process) {
+  const header = new Int32Array(sab, 0, SAB_HEADER_I32);
+  if (!importsSlicc(module, "sigmask_set")) {
+    WasiSigmask.unsupported(header);
+    return void 0;
+  }
+  if (threads) threads.blocked = () => Atomics.load(header, SAB_I_BLOCKED);
+  const shared = process && new Int32Array(process, 0, SAB_HEADER_I32);
+  return new WasiSigmask(header, () => gate.deliver(), shared);
+}
 function enosys(module, name2, foreign) {
   const type = foreign?.[module]?.[name2];
   if (type === "other") throw new Error(noErrno(`${module}.${name2}`));
@@ -13413,6 +13571,7 @@ async function runWasiProcess(init, port3) {
     ),
     ...descriptors(init, fork, threads)
   });
+  host.sigmask = sigmaskOf(module, init.sab, gate, threads);
   if (threads) {
     threads.beforeSpawn = () => {
       if (!host.fds.isShared) host.fds.share(threads.ids, false);
@@ -13507,6 +13666,7 @@ async function runWasiThread(init, port3) {
     ),
     shared: threads.ids
   });
+  host.sigmask = sigmaskOf(init.program.module, init.sab, gate, threads, init.signals);
   const program = await programImports(init.program, host, transport, thread.tid);
   const { instance } = await instantiate(host, init.program.module, thread.memory, threads, {
     thread: true,
@@ -13542,7 +13702,7 @@ async function runWasiThread(init, port3) {
     throw e;
   }
 }
-var TRAPPED, PREVIEW1, WASIX, SLICC, SIGNAL_CALLBACK, takeDefault, SLICC_FS, SLICC_TTY, RESERVED2, UNDELIVERED, DELIVERED, importsSigactionHook, noErrno, FALLBACK_MAXIMUM_PAGES, LinkSync, DL_GEN, BACKTRACE_FRAMES;
+var TRAPPED, PREVIEW1, WASIX, SLICC, SIGNAL_CALLBACK, takeDefault, SLICC_FS, SLICC_TTY, RESERVED2, UNDELIVERED, DELIVERED, importsSlicc, importsSigactionHook, noErrno, FALLBACK_MAXIMUM_PAGES, LinkSync, DL_GEN, BACKTRACE_FRAMES;
 var init_wasi_runtime = __esm({
   "src/process/wasi/wasi-runtime.ts"() {
     "use strict";
@@ -13560,6 +13720,7 @@ var init_wasi_runtime = __esm({
     init_wasi_imports();
     init_wasi_module();
     init_wasi_procfs();
+    init_wasi_sigmask();
     init_wasi_signals();
     init_wasi_stats();
     init_wasi_threads();
@@ -13586,7 +13747,8 @@ var init_wasi_runtime = __esm({
       wasi: ["thread-spawn"]
     };
     DELIVERED = [PREVIEW1, WASIX, SLICC, SLICC_FS, SLICC_TTY];
-    importsSigactionHook = (module) => WebAssembly.Module.imports(module).some((i) => i.module === SLICC && i.name === "sigaction_set");
+    importsSlicc = (module, name2) => WebAssembly.Module.imports(module).some((i) => i.module === SLICC && i.name === name2);
+    importsSigactionHook = (module) => importsSlicc(module, "sigaction_set");
     noErrno = (key) => `imports ${key}: its result cannot carry ENOSYS, and this host does not provide it`;
     FALLBACK_MAXIMUM_PAGES = 32768;
     LinkSync = class {