@ai-ecoverse/slicc-kernel 1.113.0 → 1.115.0

package/dist/node.js

@@ -473,8 +473,8 @@ async function access(fs, cred, path, want, options = {}) {
   if (await present(fs, walked.path, false)) return { ...walked, denied: walked.path };
   return { ...walked, missing: true };
 }
-function refused(path, errno2 = "EACCES") {
-  return fsError(errno2, path);
+function refused(path, errno3 = "EACCES") {
+  return fsError(errno3, path);
 }
 
 // src/fs/dac.ts
@@ -534,9 +534,9 @@ var Created = class {
 function linked(g, options) {
   return g.links === void 0 ? options : { ...options, links: g.links };
 }
-function deny(g, op, path, errno2 = "EACCES") {
+function deny(g, op, path, errno3 = "EACCES") {
   const tag = g.tag === void 0 ? {} : { tag: g.tag };
-  g.dac.denied({ pid: g.pid, uid: g.cred.euid, op, path, errno: errno2, ...tag });
+  g.dac.denied({ pid: g.pid, uid: g.cred.euid, op, path, errno: errno3, ...tag });
 }
 var TTY_MODE = 400;
 function ttyOpenable(g, tty) {
@@ -1249,7 +1249,7 @@ var WASI_SIGNAL_TO_POSIX = Object.fromEntries(
 
 // src/process/wasi-errno.ts
 var WASI_ERRNO = {
-  ...Object.fromEntries(Object.entries(E).map(([name2, errno2]) => [`E${name2}`, errno2])),
+  ...Object.fromEntries(Object.entries(E).map(([name2, errno3]) => [`E${name2}`, errno3])),
   EWOULDBLOCK: E.AGAIN,
   ENOTSUP: 138,
   EOPNOTSUPP: 138,
@@ -1489,7 +1489,7 @@ function dialError(e, timedOut, closed) {
   if (timedOut) return new KernelError("ETIMEDOUT");
   if (closed) return new KernelError("ECONNABORTED");
   const code = e?.code;
-  const known = DIAL_ERRORS.find((errno2) => errno2 === code);
+  const known = DIAL_ERRORS.find((errno3) => errno3 === code);
   return new KernelError(known ?? "EHOSTUNREACH");
 }
 function isLoopback(host) {
@@ -2129,6 +2129,14 @@ var SIGNAL_BY_NAME = {
   SIGSTOP: SIG.STOP,
   SIGCONT: SIG.CONT
 };
+var SI = { USER: 0, QUEUE: -1, TIMER: -2, TKILL: -6, KERNEL: 128 };
+var CLD = { EXITED: 1, KILLED: 2, DUMPED: 3, STOPPED: 5, CONTINUED: 6 };
+var KERNEL_SIGINFO = Object.freeze({
+  code: SI.KERNEL,
+  pid: 0,
+  uid: 0,
+  status: 0
+});
 
 // src/body-idle.ts
 var BODY_IDLE_MS = 5 * 60 * 1e3;
@@ -4094,6 +4102,7 @@ var S_IFDIR = 16384;
 var S_IFREG = 32768;
 var S_IFLNK = 40960;
 var S_IFSOCK = 49152;
+var S_IFIFO = 4096;
 var PERM_MASK = 4095;
 var S_ISGID3 = 1024;
 var READ_ATTEMPTS = 3;
@@ -4373,7 +4382,10 @@ var OpfsFs = class {
   }
   async stampNew(path, owner, directory) {
     const owned4 = await this.newFields(path, owner, directory);
-    const fields = owner?.socket && !directory ? { ...owned4, socket: true } : owned4;
+    if (owner?.socket && owner.fifo) throw new Error("a new node is a socket or a FIFO, not both");
+    const kind = directory ? void 0 : owner?.socket ? "socket" : owner?.fifo ? "fifo" : void 0;
+    const unique = kind === "fifo" ? { ino: inodeOf(`${path}\0${crypto.randomUUID()}`) } : {};
+    const fields = kind ? { ...owned4, ...unique, [kind]: true } : owned4;
     if (fields) await this.meta.update(path, (entry) => ({ ...entry, path, ...fields }));
   }
   guarded = [];
@@ -4615,7 +4627,7 @@ var OpfsFs = class {
   }
   mode(path, directory, meta) {
     const fallback = directory || EXECUTABLE.test(path) ? 493 : 420;
-    const type = directory ? S_IFDIR : meta?.socket ? S_IFSOCK : S_IFREG;
+    const type = directory ? S_IFDIR : meta?.socket ? S_IFSOCK : meta?.fifo ? S_IFIFO : S_IFREG;
     return type | (meta?.mode ?? fallback);
   }
   id = crypto.randomUUID();
@@ -4716,11 +4728,13 @@ var OpfsFs = class {
     const kept = meta?.mtimeMs !== void 0 && meta.mtimeFor === modified ? meta.mtimeMs : modified;
     const mtime = touched ?? kept;
     const socket = !directory && meta?.socket === true;
+    const fifo = !directory && meta?.fifo === true;
     return {
-      isFile: !directory && !socket,
+      isFile: !directory && !socket && !fifo,
       isDirectory: directory,
       isSymbolicLink: false,
       ...socket ? { isSocket: true } : {},
+      ...fifo ? { isFifo: true } : {},
       size: file?.size ?? 0,
       mode: this.mode(path, directory, meta),
       mtime: new Date(mtime),
@@ -6531,7 +6545,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.113.0" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.115.0" : "0.0.0-dev";
 var OS_RELEASE = "6.0.0-slicc";
 function procVersion() {
   return `Linux version ${OS_RELEASE} (slicc-kernel ${KERNEL_VERSION}) #1 SMP PREEMPT_DYNAMIC
@@ -9185,8 +9199,16 @@ var ChildTable = class {
     void handle.exited.then((code) => {
       child.code = code;
       this.watchers.delete(handle.pid);
+      const termsig = handle.termsig?.();
       if (!this.kept.delete(handle.pid) && this.autoReap?.()) this.reap(handle.pid, code);
-      this.onChildState?.();
+      const uid = handle.uid?.();
+      this.onChildState?.({
+        pid: handle.pid,
+        state: "exited",
+        status: termsig ?? code,
+        termsig,
+        uid
+      });
     });
     handle.onState?.((state, sig) => {
       child.stopReport = state === "stopped" ? sig : void 0;
@@ -9196,7 +9218,7 @@ var ChildTable = class {
       const waiters = this.stateChanged;
       this.stateChanged = [];
       for (const wake of waiters) wake();
-      this.onChildState?.();
+      this.onChildState?.({ pid: handle.pid, state, status: sig, uid: handle.uid?.() });
     });
     this.children.set(handle.pid, child);
     return handle.pid;
@@ -9526,6 +9548,139 @@ var TicketBook = class {
   }
 };
 
+// src/kernel/fifo.ts
+function errno(e) {
+  return e instanceof KernelError ? e : new KernelError(e.code ?? "EIO");
+}
+var FifoTable = class {
+  fifos = /* @__PURE__ */ new Map();
+  size() {
+    return this.fifos.size;
+  }
+  async open(key, path, access2, nonblock, signal) {
+    const fifo = this.entry(key);
+    if (access2 === "write" && nonblock && fifo.readers === 0) {
+      this.drop(key, fifo);
+      throw new KernelError("ENXIO");
+    }
+    const reads = access2 !== "write";
+    const writes = access2 !== "read";
+    const seen = { readOpens: fifo.readOpens, writeOpens: fifo.writeOpens };
+    if (reads) this.count(fifo, "readers", 1);
+    if (writes) this.count(fifo, "writers", 1);
+    this.notify(fifo);
+    try {
+      if (!nonblock && access2 === "read") {
+        while (fifo.writers === 0 && fifo.writeOpens === seen.writeOpens) {
+          await this.changed(fifo, signal);
+        }
+      }
+      if (!nonblock && access2 === "write") {
+        while (fifo.readers === 0 && fifo.readOpens === seen.readOpens) {
+          await this.changed(fifo, signal);
+        }
+      }
+    } catch (e) {
+      this.release(key, fifo, reads, writes);
+      throw errno(e);
+    }
+    return this.end(key, path, fifo, reads, writes);
+  }
+  entry(key) {
+    let fifo = this.fifos.get(key);
+    if (!fifo) {
+      fifo = {
+        pipe: new KernelPipe(),
+        readers: 0,
+        writers: 0,
+        readOpens: 0,
+        writeOpens: 0,
+        waiters: []
+      };
+      this.fifos.set(key, fifo);
+    }
+    return fifo;
+  }
+  count(fifo, side, by) {
+    fifo[side] += by;
+    if (side === "readers") {
+      if (by > 0) {
+        fifo.readOpens += 1;
+        fifo.pipe.openRead();
+      } else fifo.pipe.closeRead();
+    } else if (by > 0) {
+      fifo.writeOpens += 1;
+      fifo.pipe.openWrite();
+    } else fifo.pipe.closeWrite();
+  }
+  notify(fifo) {
+    const waiters = fifo.waiters;
+    fifo.waiters = [];
+    for (const wake of waiters) wake();
+  }
+  changed(fifo, signal) {
+    if (signal.aborted) return Promise.reject(new KernelError("EINTR"));
+    return new Promise((resolve2, reject) => {
+      const onAbort = () => {
+        fifo.waiters = fifo.waiters.filter((w) => w !== wake);
+        reject(new KernelError("EINTR"));
+      };
+      const wake = () => {
+        signal.removeEventListener("abort", onAbort);
+        resolve2();
+      };
+      fifo.waiters.push(wake);
+      signal.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  release(key, fifo, reads, writes) {
+    if (reads) this.count(fifo, "readers", -1);
+    if (writes) this.count(fifo, "writers", -1);
+    this.notify(fifo);
+    this.drop(key, fifo);
+  }
+  drop(key, fifo) {
+    const idle = fifo.readers === 0 && fifo.writers === 0 && fifo.waiters.length === 0;
+    if (idle && this.fifos.get(key) === fifo) this.fifos.delete(key);
+  }
+  end(key, path, fifo, reads, writes) {
+    const { pipe } = fifo;
+    let open = true;
+    return new OpenFile({
+      fifo: path,
+      ...reads ? {
+        read: async (max, signal) => {
+          try {
+            return await pipe.read(max, signal);
+          } catch (e) {
+            throw errno(e);
+          }
+        }
+      } : {},
+      ...writes ? {
+        write: async (bytes, signal) => {
+          try {
+            return await pipe.write(bytes, signal);
+          } catch (e) {
+            throw errno(e);
+          }
+        }
+      } : {},
+      close: () => {
+        if (!open) return;
+        open = false;
+        this.release(key, fifo, reads, writes);
+      },
+      poll: () => ({
+        readable: reads && pipe.readReady,
+        writable: writes && pipe.writeReady,
+        hangup: reads ? pipe.writersGone : pipe.readersGone
+      }),
+      changed: (signal) => pipe.changed(signal)
+    });
+  }
+};
+
 // src/mount/protocol.ts
 var DRIVER_PROTOCOL = [1, 2];
 function driverVersionError(theirs) {
@@ -10386,6 +10541,7 @@ var MountFs = class _MountFs {
     }
     const { mount, rel: rel2 } = found;
     this.writable(mount, real);
+    if (owner?.fifo) throw errnoError("EPERM", `${real}: this mount has no FIFOs`);
     const bytes = typeof content === "string" ? new TextEncoder().encode(content) : content;
     if (mount.maxFile > 0 && bytes.length > mount.maxFile) {
       throw errnoError(
@@ -10991,6 +11147,7 @@ var SYNC_FS_OPS = [
   "statfs",
   "hold",
   "create",
+  "mkfifo",
   "kept",
   "pread",
   "pwrite",
@@ -11023,6 +11180,7 @@ function statJson(s) {
     isFile: s.isFile,
     isSymbolicLink: s.isSymbolicLink,
     ...s.isSocket ? { isSocket: true } : {},
+    ...s.isFifo ? { isFifo: true } : {},
     size: s.size,
     mode: s.mode,
     mtimeMs: s.mtime.getTime(),
@@ -11172,6 +11330,12 @@ async function run(entry, path, req) {
     case "symlink":
       await fs.symlink(req.arg2 ?? "", path, ownerFor2(entry));
       return done;
+    case "mkfifo": {
+      const owner = ownerFor2(entry, req.mode ?? 438) ?? { uid: 0, gid: 0 };
+      await createExclusive(fs, path, { ...owner, fifo: true });
+      entry.fresh?.(path);
+      return done;
+    }
     case "create":
       await createExclusive(fs, path, ownerFor2(entry, req.mode ?? 438));
       if (req.opening) entry.created?.add(path);
@@ -11250,9 +11414,10 @@ async function guard(g, path, req, cwd) {
       return { path: await walkSafe(g, path, false) };
     }
     case "create":
+    case "mkfifo":
     case "symlink":
       await inParent(g, op, path);
-      return { path: await walkSafe(g, path, op === "create") };
+      return { path: await walkSafe(g, path, op !== "symlink") };
     case "unlink":
     case "rmdir": {
       await inParent(g, op, path, true);
@@ -11340,6 +11505,7 @@ async function accessOp(entry, path, req) {
 var CHANGING = /* @__PURE__ */ new Set([
   "mkdir",
   "create",
+  "mkfifo",
   "symlink",
   "unlink",
   "rmdir",
@@ -11534,7 +11700,13 @@ async function guardAndResolve(entry, path, req) {
   };
 }
 var REMOVALS = /* @__PURE__ */ new Set(["unlink", "rmdir", "rm"]);
-var CREATIONS = /* @__PURE__ */ new Set(["write", "mkdir", "symlink", "create"]);
+var CREATIONS = /* @__PURE__ */ new Set([
+  "write",
+  "mkdir",
+  "symlink",
+  "create",
+  "mkfifo"
+]);
 var NAMING = /* @__PURE__ */ new Set(["link", "rename"]);
 async function newDevName(entry, path, req) {
   const named = NAMING.has(req.op);
@@ -13281,16 +13453,16 @@ var TOKEN3 = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
 var SAFE_VALUE = /^[^\r\n\0]*$/;
 var CLOSE_WAIT_MS3 = 5e3;
 var MAX_UNREAD = 16 * 1024 * 1024;
-function errno(code, message3) {
+function errno2(code, message3) {
   return Object.assign(new Error(`${code}: ${message3}`), { code });
 }
 function requestHead(method, url, headers, extra, first = []) {
-  if (!TOKEN3.test(method)) throw errno("EINVAL", `method ${method}`);
+  if (!TOKEN3.test(method)) throw errno2("EINVAL", `method ${method}`);
   const lines2 = [`${method} ${url.pathname}${url.search} HTTP/1.1`, `host: ${url.host}`];
   for (const [name2, value2] of first) lines2.push(`${name2}: ${value2}`);
   for (const [name2, value2] of headers) {
     if (OWN_HEADERS.has(name2.toLowerCase())) continue;
-    if (!TOKEN3.test(name2) || !SAFE_VALUE.test(value2)) throw errno("EINVAL", `header ${name2}`);
+    if (!TOKEN3.test(name2) || !SAFE_VALUE.test(value2)) throw errno2("EINVAL", `header ${name2}`);
     lines2.push(`${name2}: ${value2}`);
   }
   for (const [name2, value2] of extra) lines2.push(`${name2}: ${value2}`);
@@ -13301,7 +13473,7 @@ function requestHead(method, url, headers, extra, first = []) {
 function parseHead(bytes) {
   const [statusLine = "", ...lines2] = latin1(bytes).split(/\r?\n/);
   const match = /^HTTP\/1\.[01] (\d{3})(?: (.*))?$/.exec(statusLine);
-  if (!match) throw errno("EPROTO", `not an HTTP/1.x response: ${statusLine.slice(0, 80)}`);
+  if (!match) throw errno2("EPROTO", `not an HTTP/1.x response: ${statusLine.slice(0, 80)}`);
   const headers = [];
   for (const line of lines2) {
     const colon = line.indexOf(":");
@@ -13316,9 +13488,9 @@ async function readHead(incoming, signal) {
       raw = await incoming.head(MAX_HEAD2, signal);
     } catch (err) {
       if (err instanceof KernelError) throw err;
-      throw errno("EPROTO", "the response head is malformed or too large");
+      throw errno2("EPROTO", "the response head is malformed or too large");
     }
-    if (!raw) throw errno("ECONNRESET", "the connection closed before a response");
+    if (!raw) throw errno2("ECONNRESET", "the connection closed before a response");
     const head = parseHead(raw);
     if (head.status < 100 || head.status >= 200 || head.status === 101) return head;
   }
@@ -13327,20 +13499,20 @@ async function* chunked(incoming, signal) {
   for (; ; ) {
     const line = await incoming.line(4096, signal);
     const size = /^([0-9A-Fa-f]{1,12})[ \t]*(;.*)?$/.exec(line);
-    if (!size) throw errno("EPROTO", "a malformed chunk size");
+    if (!size) throw errno2("EPROTO", "a malformed chunk size");
     const n = Number.parseInt(size[1], 16);
     if (n === 0) {
       while (await incoming.line(MAX_HEAD2, signal) !== "") ;
       return;
     }
     yield await incoming.exactly(n, signal);
-    if (await incoming.line(2, signal) !== "") throw errno("EPROTO", "a malformed chunk");
+    if (await incoming.line(2, signal) !== "") throw errno2("EPROTO", "a malformed chunk");
   }
 }
 async function* counted(incoming, length2, signal) {
   for (let left = length2; left > 0; ) {
     const data = await incoming.some(Math.min(left, 64 * 1024), signal);
-    if (data.length === 0) throw errno("EPROTO", "the body ended early");
+    if (data.length === 0) throw errno2("EPROTO", "the body ended early");
     left -= data.length;
     yield data;
   }
@@ -13361,7 +13533,7 @@ function bodyOf(incoming, head, method, signal) {
   if (lengths.length === 0) return untilClose(incoming, signal);
   const length2 = lengths[0]?.trim() ?? "";
   if (!/^\d{1,15}$/.test(length2) || lengths.some((l) => l.trim() !== length2)) {
-    throw errno("EPROTO", `a malformed Content-Length: ${lengths.join(", ")}`);
+    throw errno2("EPROTO", `a malformed Content-Length: ${lengths.join(", ")}`);
   }
   return counted(incoming, Number(length2), signal);
 }
@@ -13379,7 +13551,7 @@ var KernelLoopback = class {
   }
   async connect(url, port, signal) {
     if (url.protocol === "https:" || url.protocol === "wss:") {
-      throw errno("ENOTSUP", `TLS to the kernel's loopback is not supported: ${url.origin}`);
+      throw errno2("ENOTSUP", `TLS to the kernel's loopback is not supported: ${url.origin}`);
     }
     signal.throwIfAborted();
     const socket = this.net.socket("inet");
@@ -13394,7 +13566,7 @@ var KernelLoopback = class {
     } catch (err) {
       socket.close();
       const refused2 = err instanceof KernelError && err.code === "ECONNREFUSED";
-      throw refused2 ? errno("ECONNREFUSED", `nothing listens on the kernel's port ${port}`) : err;
+      throw refused2 ? errno2("ECONNREFUSED", `nothing listens on the kernel's port ${port}`) : err;
     }
     signal.addEventListener("abort", () => socket.close(), { once: true });
     return socket;
@@ -13440,7 +13612,7 @@ var KernelLoopback = class {
       const incoming = new Incoming(socket);
       const head = await readHead(incoming, req.signal);
       if (head.status !== 101) {
-        throw errno(
+        throw errno2(
           "EPROTO",
           `the server answered the upgrade with ${head.status}${head.statusText ? ` ${head.statusText}` : ""}`
         );
@@ -13448,10 +13620,10 @@ var KernelLoopback = class {
       const upgraded = fieldTokens(head.headers, "upgrade").includes("websocket") && fieldTokens(head.headers, "connection").includes("upgrade");
       const accept2 = fieldValues(head.headers, "sec-websocket-accept")[0];
       if (!upgraded || accept2 !== await acceptFor(key)) {
-        throw errno("EPROTO", "the server did not accept the WebSocket key");
+        throw errno2("EPROTO", "the server did not accept the WebSocket key");
       }
       if (fieldValues(head.headers, "sec-websocket-extensions").length > 0) {
-        throw errno("EPROTO", "the server offered an unsolicited extension");
+        throw errno2("EPROTO", "the server offered an unsolicited extension");
       }
       const protocol = fieldValues(head.headers, "sec-websocket-protocol")[0] ?? "";
       return new LoopbackWebSocket(socket, incoming, protocol);
@@ -13469,7 +13641,7 @@ async function* closing(chunks2, socket) {
     yield* chunks2;
   } catch (err) {
     if (typeof err?.code === "string") throw err;
-    throw errno("EPROTO", err instanceof Error ? err.message : String(err));
+    throw errno2("EPROTO", err instanceof Error ? err.message : String(err));
   } finally {
     socket.close();
   }
@@ -13598,7 +13770,7 @@ var LoopbackWebSocket = class {
     this.write(clientFrame(OP_CLOSE, payload));
   }
   send(data) {
-    if (this.sentClose) throw errno("EPIPE", "the websocket is closing");
+    if (this.sentClose) throw errno2("EPIPE", "the websocket is closing");
     const text = typeof data === "string";
     const payload = text ? new TextEncoder().encode(data) : data;
     this.write(clientFrame(text ? OP_TEXT : OP_BINARY, payload));
@@ -14290,8 +14462,8 @@ function errnoOf(e) {
   const code = e?.code;
   return typeof code === "string" && ERRNO.test(code) ? code : "ECONNREFUSED";
 }
-function fail(errno2, text) {
-  return { ok: false, errno: errno2, message: text };
+function fail(errno3, text) {
+  return { ok: false, errno: errno3, message: text };
 }
 var WsHandles = class {
   transport;
@@ -14565,8 +14737,8 @@ var HttpHandles = class {
       const status = e.status;
       if (text === NO_TRANSPORT || typeof status !== "number" || status === 502) {
         const code = codeOf2(e);
-        const errno2 = text === NO_TRANSPORT ? "ENETUNREACH" : code !== "EIO" ? code : "ECONNREFUSED";
-        return { ok: false, errno: errno2, message: text };
+        const errno3 = text === NO_TRANSPORT ? "ENETUNREACH" : code !== "EIO" ? code : "ECONNREFUSED";
+        return { ok: false, errno: errno3, message: text };
       }
       entry.body = once(new TextEncoder().encode(text))[Symbol.asyncIterator]();
       return this.headOf(handle, req.url, {
@@ -15661,7 +15833,7 @@ var UNREACHABLE = ["EACCES", "ENETUNREACH", "EHOSTUNREACH"];
 function sendError(e) {
   if (e instanceof KernelError) return e;
   const code = e?.code;
-  return new KernelError(SEND_ERRORS.find((errno2) => errno2 === code) ?? "EHOSTUNREACH");
+  return new KernelError(SEND_ERRORS.find((errno3) => errno3 === code) ?? "EHOSTUNREACH");
 }
 function sameAddr(a, b) {
   return a.port === b.port && canonicalHost(a.host) === canonicalHost(b.host);
@@ -15790,7 +15962,7 @@ var KernelDgram = class {
   }
   unreachable(error, from) {
     if (!this.peer || !sameAddr(this.peer, from)) return;
-    this.pending = UNREACHABLE.find((errno2) => errno2 === error) ?? "EHOSTUNREACH";
+    this.pending = UNREACHABLE.find((errno3) => errno3 === error) ?? "EHOSTUNREACH";
     this.changes.wake();
   }
   deliver(datagram2) {
@@ -17108,6 +17280,7 @@ var SYSCALL_OPS = /* @__PURE__ */ new Set([
   "sig-mask",
   "sig-inherited",
   "sig-waiting",
+  "sig-info",
   "sig-pause",
   ...SOCKET_OPS,
   ...EPOLL_OPS,
@@ -17121,6 +17294,7 @@ function isWasmSyscall(req) {
   return typeof op === "string" && SYSCALL_OPS.has(op);
 }
 var MAX_READ = 1024 * 1024;
+var O_NONBLOCK = 2048;
 var WRITE_ACCESS = 3;
 var KEYBOARD = /* @__PURE__ */ new Set([SIG.INT, SIG.QUIT, SIG.TSTP]);
 var DEFAULT_UMASK2 = 18;
@@ -17189,7 +17363,7 @@ var WasmProcess = class {
     this.children = new ChildTable(fds, options.spawner, options.forker);
     this.nodes = options.nodes ?? new VfsNodes(options.fs);
     if (!options.nodes) options.openFiles?.add(this.nodes);
-    this.children.onChildState = () => this.signal(SIG.CHLD);
+    this.children.onChildState = (child) => this.signal(SIG.CHLD, child && this.childInfo(child));
     this.children.autoReap = () => this.reapsChildren();
     this.seedDl(options.dl);
     this.children.onReap = (pid2) => {
@@ -17206,10 +17380,43 @@ var WasmProcess = class {
   inheritable(fork = false) {
     return ((fork ? 0 : this.ignored) | this.inherited) & ~this.caught;
   }
-  signal(sig) {
+  sigInfos = /* @__PURE__ */ new Map();
+  signal(sig, info) {
+    const pending = ((this.options.pendingBits?.() ?? 0) & sigbit(sig)) !== 0;
+    const outcome = this.signalOutcome(sig, info);
+    if (outcome === "deliver" && !(pending && this.sigInfos.has(`0:${sig}`))) {
+      this.sigInfos.set(`0:${sig}`, info ?? KERNEL_SIGINFO);
+    }
+    return outcome;
+  }
+  async threadKill(tid, sig) {
+    const info = await this.threadSender(sig);
+    if (this.options.threadKill?.(tid, sig)) this.sigInfos.set(`${tid}:${sig}`, info);
+    else this.options.raise?.(sig, info);
+  }
+  async threadSender(sig) {
+    const pid = (await this.options.identity?.())?.pid ?? this.pid;
+    const code = sig === SIG.PIPE ? SI.USER : SI.TKILL;
+    return { code, pid, uid: this.cred.ruid, status: 0 };
+  }
+  childInfo(child) {
+    const code = child.state === "stopped" ? CLD.STOPPED : child.state === "continued" ? CLD.CONTINUED : child.termsig ? CLD.KILLED : CLD.EXITED;
+    return { code, pid: child.pid, uid: child.uid ?? this.cred.ruid, status: child.status };
+  }
+  takeSigInfo(sig, tid) {
+    for (const key of [`${tid}:${sig}`, `0:${sig}`]) {
+      const info = this.sigInfos.get(key);
+      if (info) {
+        this.sigInfos.delete(key);
+        return info;
+      }
+    }
+    return null;
+  }
+  signalOutcome(sig, info) {
     if (this.execChild !== void 0) {
       if (sig === SIG.CONT) this.cont();
-      void Promise.resolve(this.options.kill?.(this.execChild, sig)).catch(() => void 0);
+      void Promise.resolve(this.options.kill?.(this.execChild, sig, info)).catch(() => void 0);
       if (sig !== SIG.KILL) return "forward";
       if (!this.options.writesBack?.(this.execChild)) return "terminate";
       this.wake?.();
@@ -17585,7 +17792,7 @@ var WasmProcess = class {
       this.options.hasPending?.() ? AbortSignal.abort() : this.cancelSignal(cancelled)
     );
   }
-  async openVfs(req) {
+  async openVfs(req, cancelled) {
     if (inProc(req.path)) return this.openProc(req, req.path);
     const device = req.orphan ? void 0 : deviceAt(req.path);
     if (device) return this.openDevice(req, device);
@@ -17596,6 +17803,10 @@ var WasmProcess = class {
     await refuseReadonly(this.options.fs, req.path, req.flags, req);
     if (this.writesAt(req)) await this.options.fs.mayChange?.(req.path, !req.exclusive);
     await this.mayOpen(req);
+    if (req.fifo && !req.exclusive) {
+      const opened2 = await this.openFifo(req, cancelled);
+      if (opened2 !== void 0) return opened2;
+    }
     const marked = await this.markedPath(req);
     await this.sourceOpen(marked === void 0 ? req : { ...req, path: marked });
     const fs = marked === void 0 ? this.options.fs : this.options.noLinks;
@@ -17637,6 +17848,19 @@ var WasmProcess = class {
     }
     return fd;
   }
+  async openFifo(req, cancelled) {
+    const fifos = this.options.fifos;
+    const path = await this.nodes.targetKey(req.path);
+    const st = await this.heldFs().stat(path);
+    if (!st.isFifo) return void 0;
+    if (!fifos) throw new KernelError("ENXIO");
+    const access2 = openAccess(req.flags);
+    const nonblock = (req.flags & O_NONBLOCK) !== 0;
+    const blocks = !nonblock && access2 !== "both";
+    const signal = blocks ? this.blockingSignal(cancelled) : cancelled;
+    const end = await fifos.open(`${st.dev ?? 0}:${st.ino}`, path, access2, nonblock, signal);
+    return this.fds.install(end, 3);
+  }
   openDevice(req, device) {
     if (req.exclusive) throw Object.assign(new Error(req.path), { code: "EEXIST" });
     const access2 = req.flags & WRITE_ACCESS;
@@ -17836,7 +18060,7 @@ var WasmProcess = class {
       case "fd-poll":
         return { ok: true, kind: "json", json: pollFile(this.fds.get(req.fd).file) };
       case "fd-open-vfs":
-        return { ok: true, kind: "json", json: await this.openVfs(req) };
+        return { ok: true, kind: "json", json: await this.openVfs(req, cancelled) };
       case "fd-info":
         return { ok: true, kind: "json", json: this.fdInfo(req.fd) };
       case "fd-list":
@@ -18270,8 +18494,10 @@ var WasmProcess = class {
       case "sig-pause":
         return this.pause(cancelled);
       case "thread-kill":
-        if (!this.options.threadKill?.(req.tid, req.sig)) this.options.raise?.(req.sig);
+        await this.threadKill(req.tid, req.sig);
         return { ok: true, kind: "void" };
+      case "sig-info":
+        return { ok: true, kind: "json", json: this.takeSigInfo(req.sig, req.tid ?? 0) };
       case "proc-captured":
         return { ok: true, kind: "bytes", bytes: this.children.captured(req.pid, req.slot) };
       case "proc-sudo":
@@ -18494,7 +18720,8 @@ function inheritedFds(fds) {
       ...kind === "device" && meta && "device" in meta ? { device: meta } : {},
       ...flags2 !== void 0 ? { flags: flags2 } : {},
       ...fds.closesOnExec(fd) ? { cloexec: true } : {},
-      ...kind === "stream" ? { desc: descId(open) } : {}
+      ...kind === "stream" ? { desc: descId(open) } : {},
+      ...open.file.fifo ? { fifo: open.file.fifo } : {}
     };
   });
 }
@@ -18700,6 +18927,7 @@ function processOptions(opts, header4, hooks, created3) {
     net: opts.net,
     http: opts.http,
     locks: opts.locks,
+    fifos: opts.fifos,
     ...opts.sems ? { sems: opts.sems } : {},
     onReap: opts.onReap,
     resolver: opts.resolver,
@@ -18750,7 +18978,7 @@ function spawnWasmProcess(opts) {
       opts,
       header4,
       {
-        raise: (sig) => signal(sig),
+        raise: (sig, info) => signal(sig, info),
         threadKill: (tid, sig) => killThread(threadSignals.get(tid), process2.signalMasks().caught, sig),
         unblockedThread: (sig) => unblockedThread(threadSignals, sig),
         ...opts.program.abi === "js" ? {
@@ -18872,8 +19100,9 @@ function spawnWasmProcess(opts) {
     if (opts.program.abi !== "wasi" || done4) finish(code, sig);
     else dying.start(code, sig, header4, process2, () => finish(code, sig));
   };
-  const signal = (sig) => {
-    if (process2.signal(sig) === "terminate") terminate(sig === SIG.KILL ? 137 : 128 + sig, sig);
+  const signal = (sig, info) => {
+    if (process2.signal(sig, info) === "terminate")
+      terminate(sig === SIG.KILL ? 137 : 128 + sig, sig);
   };
   const kill = (code = 137) => finish(code, code > 128 && code < 160 ? code - 128 : void 0);
   return {
@@ -19043,14 +19272,14 @@ var JobTable = class {
     this.foreground.set(tty, member.pgid);
     return true;
   }
-  killGroup(pgid, sig, may = () => true) {
+  killGroup(pgid, sig, may = () => true, info) {
     const group = [...this.members.values()].filter((m) => m.pgid === pgid);
     const targets = group.filter((m) => may(m.pid));
     if (targets.length === 0 && group.length > 0) throw new KernelError("EPERM");
     const pids = new Set(targets.map((m) => m.pid));
     if (sig !== 0) {
       for (const m of targets)
-        if (m.execParent === void 0 || !pids.has(m.execParent)) m.signal(sig);
+        if (m.execParent === void 0 || !pids.has(m.execParent)) m.signal(sig, info);
     }
     return targets.length > 0;
   }
@@ -20637,9 +20866,9 @@ var HostfsClient = class {
         throw fsError2("ESTALE", "the folder was granted again, so its open files are gone");
       return this.send(path, init, false, true);
     }
-    const errno2 = response.headers.get("X-Hostfs-Errno") ?? "EIO";
+    const errno3 = response.headers.get("X-Hostfs-Errno") ?? "EIO";
     const body = await response.json().catch(() => ({}));
-    throw fsError2(errno2, typeof body.message === "string" ? body.message : errno2);
+    throw fsError2(errno3, typeof body.message === "string" ? body.message : errno3);
   }
   async call(op, body = {}, handle = false) {
     const response = await this.send(
@@ -21796,8 +22025,8 @@ var RULE = new RegExp(
 var TERM = /^[A-Za-z0-9._+-]+$/;
 var PLAIN = /^[A-Za-z0-9_@%+=:,./-]+$/;
 var USAGE = "usage: sudo [-n] [-u user] [--] command [args...]\n       sudo -l";
-function failed2(errno2, error) {
-  return { error, errno: errno2 };
+function failed2(errno3, error) {
+  return { error, errno: errno3 };
 }
 function unescaped(double) {
   return double.replace(/\\(["\\$`])/g, "$1");
@@ -22389,7 +22618,8 @@ function childHandle(handle) {
     pid: handle.pid,
     exited: handle.exited,
     termsig: handle.termsig,
-    onState: (listener) => handle.onState(listener)
+    onState: (listener) => handle.onState(listener),
+    uid: () => handle.cred?.().ruid
   };
 }
 function concat7(chunks2) {
@@ -22453,6 +22683,7 @@ var Launcher = class {
   sudoer;
   jobs = new JobTable();
   locks = new LockTable();
+  fifos = new FifoTable();
   sems = new SemTable();
   settling = new SettlingChildren((pid) => this.jobs.pgidOf(pid));
   ptys = new PtyTable(
@@ -23427,7 +23658,7 @@ var Launcher = class {
       onError: req.report,
       spawner: this.spawner(pid, req.report),
       forker: this.forker(pid, req),
-      kill: (target, sig) => this.kill(target, sig, this.credOf(pid), pid),
+      kill: (target, sig, info) => this.kill(target, sig, this.credOf(pid), pid, info),
       writesBack: (target) => this.processes.get(target)?.writesBack() === true,
       processes: () => ({
         boot: this.boot,
@@ -23450,6 +23681,7 @@ var Launcher = class {
       net: this.net,
       http: new HttpHandles(this.transport, pid, this.loopbackFor(pid)),
       locks: this.locks,
+      fifos: this.fifos,
       sems: this.sems,
       resolver: this.resolver,
       onReap: (child) => this.reaped(child, pid),
@@ -23462,7 +23694,7 @@ var Launcher = class {
     this.creds.set(pid, () => handle.cred?.() ?? copyCred(cred));
     this.marks(pid, req);
     if (req.ppid !== void 0 && this.controlsJobs(req.ppid)) this.settling.started(pid, req.ppid);
-    this.jobs.add(pid, req.ppid, (sig) => handle.signal(sig), terminal);
+    this.jobs.add(pid, req.ppid, (sig, info) => handle.signal(sig, info), terminal);
     if (req.exec && req.ppid !== void 0) this.jobs.exec(req.ppid, pid, true);
     if (req.pgid !== void 0) this.jobs.join(pid, req.pgid);
     if (req.group === "lead") this.jobs.lead(pid);
@@ -23843,21 +24075,26 @@ var Launcher = class {
   ignoredBy(pid, fork = false) {
     return this.processes.get(pid)?.ignoredSignals(fork) ?? 0;
   }
-  kill(pid, sig, sender, from) {
+  kill(pid, sig, sender, from, forwarded) {
+    const info = forwarded ?? this.senderInfo(sender, from);
     const session = from === void 0 ? void 0 : this.jobs.sidOf(from);
     const may = (target) => !sender || maySignal(sender, this.credOf(target)) || sig === SIG.CONT && session !== void 0 && this.jobs.sidOf(target) === session || from !== void 0 && this.imageOf(from) === this.imageOf(target) || from !== void 0 && this.granted.get(this.jobs.shown(target)) === from || from !== void 0 && this.granted.get(this.jobs.pgidOf(target) ?? 0) === from;
     if (pid === -1) {
       const sender2 = from === void 0 ? void 0 : this.imageOf(from);
-      return this.killAll(sig, (member) => this.imageOf(member) !== sender2, may);
+      return this.killAll(sig, (member) => this.imageOf(member) !== sender2, may, info);
     }
-    if (pid < 0) return this.jobs.killGroup(-pid, sig, (member) => may(this.imageOf(member)));
+    if (pid < 0) return this.jobs.killGroup(-pid, sig, (member) => may(this.imageOf(member)), info);
     const handle = this.processes.get(pid);
     if (!handle) return false;
     if (!may(this.imageOf(pid))) throw fsError("EPERM", `pid ${pid}`);
-    if (sig !== 0) handle.signal(sig);
+    if (sig !== 0) handle.signal(sig, info);
     return true;
   }
-  killAll(sig, other, may) {
+  senderInfo(sender, from) {
+    if (from === void 0) return void 0;
+    return { code: SI.USER, pid: this.jobs.shown(from), uid: sender?.ruid ?? 0, status: 0 };
+  }
+  killAll(sig, other, may, info) {
     const candidates = [...this.processes].filter(([pid]) => pid !== 1 && other(pid));
     const targets = candidates.filter(([pid]) => may(this.imageOf(pid)));
     if (targets.length === 0 && candidates.length > 0) throw fsError("EPERM", "kill -1");
@@ -23865,7 +24102,7 @@ var Launcher = class {
     const parents = new Map(this.jobs.list().map((m) => [m.pid, m.execParent]));
     for (const [pid, handle] of targets) {
       const parent = parents.get(pid);
-      if (sig !== 0 && (parent === void 0 || !pids.has(parent))) handle.signal(sig);
+      if (sig !== 0 && (parent === void 0 || !pids.has(parent))) handle.signal(sig, info);
     }
     return targets.length > 0;
   }