@ai-ecoverse/slicc-kernel 1.86.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;
@@ -1984,12 +1988,10 @@ var init_wasi_fds = __esm({
         let fd;
         let kind;
         if (path === SEALED_PATH && openSealed) {
-          if (oflags & OFLAGS.DIRECTORY) throw new WasiError("ENOTDIR");
-          if (oflags & OFLAGS.CREAT && oflags & OFLAGS.EXCL) throw new WasiError("EEXIST");
-          fd = openSealed.call(this.kernel.sys);
+          fd = this.openCharDevice(openSealed, oflags, rights);
           kind = "sealed";
         } else if (path === CLIPBOARD_PATH && openClipboard) {
-          fd = this.openClipboard(openClipboard, oflags, rights);
+          fd = this.openCharDevice(openClipboard, oflags, rights);
           kind = "clipboard";
         } else if (path === "/dev/tty" || /^\/dev\/tty\d+$/.test(path)) {
           fd = openTty?.call(this.kernel.sys, path === "/dev/tty" ? void 0 : path);
@@ -2000,12 +2002,12 @@ var init_wasi_fds = __esm({
         this.bump();
         return fd;
       }
-      openClipboard(openClipboard, oflags, rights) {
+      openCharDevice(openDevice2, oflags, rights) {
         if (oflags & OFLAGS.DIRECTORY) throw new WasiError("ENOTDIR");
         if (oflags & OFLAGS.CREAT && oflags & OFLAGS.EXCL) throw new WasiError("EEXIST");
         const want = wantOf(oflags, rights);
         const flags = want === 6 ? O_RDWR : want === 2 ? O_WRONLY : 0;
-        return openClipboard.call(this.kernel.sys, flags);
+        return openDevice2.call(this.kernel.sys, flags);
       }
       open(path, oflags, rights, fdflags) {
         const device2 = deviceOf(path);
@@ -2057,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);
@@ -2072,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);
@@ -2091,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, {
@@ -2494,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";
@@ -2525,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();
@@ -2536,6 +2539,7 @@ var init_wasi_host = __esm({
       onRaise;
       muted;
       signals;
+      sigmask;
       interrupted;
       quietly = (fn) => fn();
       listening;
@@ -2727,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() {
@@ -3621,7 +3641,7 @@ function importsContext({
 }
 function processes(host, call2, inThread) {
   const close = (fd) => void call2({ op: "fd-close", fd });
-  const slot = (n, how, mine, theirs) => {
+  const slot2 = (n, how, mine, theirs) => {
     if (how === "inherit") return { fd: n };
     if (how === "null") return { none: true };
     const [read2, write2] = call2({ op: "fd-pipe" });
@@ -3635,7 +3655,7 @@ function processes(host, call2, inThread) {
       const theirs = [];
       host.fds.promoteFiles();
       try {
-        const stdio = STDIO.map((name2, n) => slot(n, o[name2] ?? "inherit", mine, theirs));
+        const stdio = STDIO.map((name2, n) => slot2(n, o[name2] ?? "inherit", mine, theirs));
         const req = {
           op: "proc-spawn",
           file: o.argv[0],
@@ -3821,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) {
@@ -4081,7 +4115,7 @@ function writable(io, fd) {
     abort: () => io.close(fd)
   });
 }
-function childOps(kernel, io, defaults) {
+function childOps(kernel, io, defaults, sync) {
   const wait2 = async (pid) => {
     const r = await kernel.blocking({ op: "proc-wait", pid, nohang: false });
     const [, status2] = r.ok && r.kind === "json" ? r.json : [0, 0];
@@ -4101,25 +4135,45 @@ function childOps(kernel, io, defaults) {
       kill: (signal) => kill(pid, signal)
     };
   };
-  const spawn = async (o) => {
+  const request = (o) => {
     const [file] = o.argv;
     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,
+      argv: [...o.argv],
+      ...named,
+      env: { ...o.env ?? defaults.env },
+      cwd: o.cwd ?? defaults.cwd,
+      stdio,
+      ...group,
+      ...death
+    });
+  };
+  const spawnSync = (o) => {
+    const spawning = request(o);
+    const mine = [];
+    const theirs = [];
+    try {
+      const stdio = slotsSync(sync, o, mine, theirs);
+      return childOf(sync.json(spawning(stdio)), mine);
+    } catch (err) {
+      closeAllSync(sync, mine);
+      throw err;
+    } finally {
+      closeAllSync(sync, theirs);
+    }
+  };
+  const spawn = async (o) => {
+    const spawning = request(o);
     const mine = [];
     const theirs = [];
     try {
       const stdio = await slots2(kernel, o, mine, theirs);
-      const pid = await kernel.json({
-        op: "proc-spawn",
-        file,
-        argv: [...o.argv],
-        ...named,
-        env: { ...o.env ?? defaults.env },
-        cwd: o.cwd ?? defaults.cwd,
-        stdio,
-        ...group
-      });
+      const pid = await kernel.json(spawning(stdio));
       return childOf(pid, mine);
     } catch (err) {
       await closeAll(io, mine);
@@ -4128,7 +4182,7 @@ function childOps(kernel, io, defaults) {
       await closeAll(io, theirs);
     }
   };
-  return { spawn, wait: wait2, kill };
+  return { spawn, wait: wait2, kill, spawnSync };
 }
 function groupOf(o, call2) {
   const { pgid, session } = o;
@@ -4139,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);
@@ -4147,27 +4208,43 @@ function argv0Of(argv0, call2) {
 async function closeAll(io, fds) {
   for (const fd of fds) if (fd !== void 0) await io.close(fd).catch(() => void 0);
 }
-async function preflight(kernel, hows) {
+function closeAllSync(sync, fds) {
+  for (const fd of fds) if (fd !== void 0) sync.raw({ op: "fd-close", fd });
+}
+function checked(hows) {
+  const fds = [];
   for (const [n, how] of hows.entries()) {
     if (how === "pipe" || how === "null") continue;
     if (how !== "inherit" && typeof how !== "number") throw new JsCallError("EINVAL", "spawn");
-    await kernel.json({ op: "fd-info", fd: how === "inherit" ? n : how });
+    fds.push(how === "inherit" ? n : how);
   }
+  return fds;
+}
+async function preflight(kernel, hows) {
+  for (const fd of checked(hows)) await kernel.json({ op: "fd-info", fd });
+}
+function slot(n, how, pipe, mine, theirs) {
+  if (how === "inherit") return { fd: n };
+  if (how === "null") return { none: true };
+  if (typeof how === "number") return { fd: how };
+  const [read2, write2] = pipe();
+  mine[n] = n === 0 ? write2 : read2;
+  theirs.push(n === 0 ? read2 : write2);
+  return { fd: n === 0 ? read2 : write2 };
+}
+function slotsSync(sync, o, mine, theirs) {
+  const hows = STDIO2.map((name2) => o[name2] ?? "inherit");
+  for (const fd of checked(hows)) sync.json({ op: "fd-info", fd });
+  const pipe = () => sync.json({ op: "fd-pipe" });
+  return hows.map((how, n) => slot(n, how, pipe, mine, theirs));
 }
 async function slots2(kernel, o, mine, theirs) {
   const hows = STDIO2.map((name2) => o[name2] ?? "inherit");
   await preflight(kernel, hows);
   const stdio = [];
   for (const [n, how] of hows.entries()) {
-    if (how === "inherit") stdio.push({ fd: n });
-    else if (how === "null") stdio.push({ none: true });
-    else if (typeof how === "number") stdio.push({ fd: how });
-    else {
-      const [read2, write2] = await kernel.json({ op: "fd-pipe" });
-      mine[n] = n === 0 ? write2 : read2;
-      theirs.push(n === 0 ? read2 : write2);
-      stdio.push({ fd: n === 0 ? read2 : write2 });
-    }
+    const pair = how === "pipe" ? await kernel.json({ op: "fd-pipe" }) : [];
+    stdio.push(slot(n, how, () => pair, mine, theirs));
   }
   return stdio;
 }
@@ -4433,6 +4510,10 @@ function* aliasOf(fd, abs, o) {
   }
   return { fd: copy2, file };
 }
+function accessFlags(o) {
+  const write2 = o.write === true || o.append === true || o.truncate === true;
+  return write2 ? o.read === true ? 2 : 1 : 0;
+}
 function* opened(abs, o) {
   const node = yield* lookup(abs);
   if (isExclusive(o)) throw new JsCallError("EEXIST", abs);
@@ -4441,13 +4522,13 @@ function* opened(abs, o) {
       return { fd: yield openRequest(abs, { ...o, create: false }), file: false };
     case "tty":
       return { fd: yield { op: "fd-open-tty" }, file: false };
-    case "clipboard": {
-      const write2 = o.write === true || o.append === true || o.truncate === true;
-      const flags = write2 ? o.read === true ? 2 : 1 : 0;
-      return { fd: yield { op: "fd-open-clipboard", flags }, file: false };
-    }
+    case "clipboard":
+      return {
+        fd: yield { op: "fd-open-clipboard", flags: accessFlags(o) },
+        file: false
+      };
     case "sealed":
-      return { fd: yield { op: "fd-open-sealed" }, file: false };
+      return { fd: yield { op: "fd-open-sealed", flags: accessFlags(o) }, file: false };
     case "terminal": {
       const req = node.pts === void 0 ? { op: "fd-open-tty", name: node.name } : { op: "pty-slave-open", n: node.pts, noctty: true };
       return { fd: yield req, file: false };
@@ -5078,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);
@@ -5094,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;
@@ -5928,7 +6009,7 @@ function websocketOp(kernel) {
         reason: closeReason(how.reason)
       });
     };
-    const readable2 = new ReadableStream(
+    const readable3 = new ReadableStream(
       {
         async pull(controller) {
           let r;
@@ -5978,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;
@@ -6011,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 = [];
@@ -6083,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();
@@ -6163,8 +6258,10 @@ 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),
     exit: (status2 = 0) => {
       exiting ??= status2 & 255;
       return exitAtOnce(lane, [...writes], terminal.modes(), exiting);
@@ -6179,9 +6276,11 @@ function createContext(o) {
     }
   };
   const io = { read: read2, send: writeAll, close: (fd) => ctx.close(fd) };
-  const children = childOps(kernel, io, { env: o.env, cwd: o.cwd, signal: signalNumber });
+  const defaults = { env: o.env, cwd: o.cwd, signal: signalNumber };
+  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,
@@ -6189,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,
@@ -6407,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();
@@ -6424,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) {
@@ -7901,7 +7993,7 @@ var init_kernel_streams = __esm({
       openSealed(open, path, flags, mode) {
         const { openSealed } = this.sys;
         if (path !== SEALED_PATH2 || !openSealed) return void 0;
-        const kfd = this.call(() => openSealed.call(this.sys));
+        const kfd = this.call(() => openSealed.call(this.sys, flags & 3));
         return this.vessel(open, kfd, { path, flags, mode }, false);
       }
       openClipboard(open, path, flags, mode) {
@@ -8953,8 +9045,8 @@ function describeInherited(Fs, sys, streams, livePath, actions = []) {
   const out = [];
   for (const [fd, stream] of slots3) {
     promote(stream);
-    const slot = inheritedSlot(fd, stream);
-    if (slot) out.push(slot);
+    const slot2 = inheritedSlot(fd, stream);
+    if (slot2) out.push(slot2);
   }
   return out;
 }
@@ -9172,7 +9264,7 @@ function createProcessKernel(deps) {
   const reaped = /* @__PURE__ */ new Map();
   const call2 = (req, label) => transport.call(req, Infinity, label);
   const at = (path) => path === "" || path.startsWith("/") ? path : `${Fs.cwd()}/${path}`;
-  const slot = (fd, n, promote) => {
+  const slot2 = (fd, n, promote) => {
     const stream = fd >= 0 ? Fs.getStream(fd) : null;
     if (!stream) return { none: true };
     promote?.(stream);
@@ -9221,7 +9313,7 @@ function createProcessKernel(deps) {
     const unflushed = flushed(deps.beforeSpawn);
     if (unflushed < 0) return unflushed;
     const promote = deps.stdioPromoter?.();
-    const stdio = [0, 1, 2].map((n) => slot(fds[n] ?? -1, n, promote));
+    const stdio = [0, 1, 2].map((n) => slot2(fds[n] ?? -1, n, promote));
     const inherit = deps.inherit?.(actions) ?? [];
     const req = {
       op: "proc-spawn",
@@ -9460,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;
@@ -9473,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++) {
@@ -9651,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);
@@ -9735,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)}`,
     ""
@@ -9771,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)}
 `;
@@ -9887,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);
@@ -9911,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];
   };
@@ -9923,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,
@@ -9986,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;
@@ -10002,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")}`;
@@ -10146,8 +10264,8 @@ function kernelSys(transport) {
     openPts(n, noctty) {
       return json2(call2({ op: "pty-slave-open", n, noctty }, `pty-slave-open ${n}`));
     },
-    openSealed() {
-      return json2(call2({ op: "fd-open-sealed" }, "fd-open-sealed"));
+    openSealed(flags) {
+      return json2(call2({ op: "fd-open-sealed", flags }, "fd-open-sealed"));
     },
     openClipboard(flags) {
       return json2(call2({ op: "fd-open-clipboard", flags }, "fd-open-clipboard"));
@@ -10976,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;
         }
@@ -11064,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({
@@ -11149,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;
@@ -13026,6 +13211,7 @@ __export(wasi_runtime_exports, {
   delivering: () => delivering,
   runWasiProcess: () => runWasiProcess,
   runWasiThread: () => runWasiThread,
+  sigmaskOf: () => sigmaskOf,
   trapMessage: () => trapMessage,
   unsupportedImport: () => unsupportedImport,
   wireSignals: () => wireSignals
@@ -13062,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}`));
@@ -13375,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);
@@ -13469,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,
@@ -13504,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";
@@ -13522,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();
@@ -13548,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 {