@ai-ecoverse/slicc-kernel 1.31.2 → 1.32.1

package/dist/node-process-worker.js

@@ -1593,6 +1593,8 @@ var init_kernel_streams = __esm({
       refs = /* @__PURE__ */ new Map();
       socketRoot;
       sockets = 0;
+      descriptions = /* @__PURE__ */ new Map();
+      described = 0;
       Fs;
       sys;
       options;
@@ -1673,6 +1675,32 @@ var init_kernel_streams = __esm({
           })
         };
       }
+      sizeFromKernel(stream, kfd) {
+        const { size } = this.sys;
+        if (!size) return;
+        const node = stream.node;
+        this.describe(stream, `${stream.path ?? ""}:${++this.described}`, () => ({
+          ...node.node_ops?.getattr?.(node),
+          size: this.call(() => size.call(this.sys, kfd))
+        }));
+      }
+      describe(stream, name, getattr) {
+        if (this.descriptions.size === 0) this.useDescriptions();
+        this.descriptions.set(name, getattr);
+        stream.path = name;
+        stream.stream_ops = { ...stream.stream_ops, getattr };
+      }
+      useDescriptions() {
+        const fs = this.Fs;
+        for (const name of ["stat", "lstat"]) {
+          const original = fs[name];
+          if (typeof original !== "function") continue;
+          fs[name] = (path, ...rest) => {
+            const getattr = this.descriptions.get(path);
+            return getattr ? getattr() : original.call(fs, path, ...rest);
+          };
+        }
+      }
       useControllingTerminal() {
         if (typeof this.Fs.open !== "function") return;
         this.usePtyPaths();
@@ -1868,252 +1896,6 @@ var init_kernel_streams = __esm({
   }
 });
 
-// src/process/process-children.ts
-function status(r) {
-  return r.ok ? 0 : -wasiErrno(r.errno);
-}
-function number(r) {
-  if (!r.ok) return -wasiErrno(r.errno);
-  return r.kind === "json" && typeof r.json === "number" ? r.json : -wasiErrno("EIO");
-}
-function flushed(beforeSpawn) {
-  try {
-    beforeSpawn();
-    return 0;
-  } catch (err) {
-    const errno2 = err?.errno;
-    if (typeof errno2 !== "number") throw err;
-    return -errno2;
-  }
-}
-function drain(Fs, stream) {
-  const chunks = [];
-  const buffer = new Uint8Array(65536);
-  try {
-    for (let n = Fs.read(stream, buffer, 0, buffer.length); n > 0; ) {
-      chunks.push(buffer.slice(0, n));
-      n = Fs.read(stream, buffer, 0, buffer.length);
-    }
-  } catch {
-  }
-  const out = new Uint8Array(chunks.reduce((n, c) => n + c.length, 0));
-  let offset = 0;
-  for (const chunk of chunks) {
-    out.set(chunk, offset);
-    offset += chunk.length;
-  }
-  return out;
-}
-function kernelSelect(Fs, transport, read, write, timeoutMs) {
-  const kernel = (fd) => Fs.getStream(fd)?.sliccKernelFd;
-  const kr = read.map(kernel);
-  const kw = write.map(kernel);
-  const r = transport.call({ op: "fd-select", read: kr, write: kw, timeoutMs }, Infinity, "select");
-  if (!r.ok) return -wasiErrno(r.errno);
-  const got = r.kind === "json" ? r.json : { read: [], write: [] };
-  return {
-    read: read.filter((_, i) => got.read.includes(kr[i])),
-    write: write.filter((_, i) => got.write.includes(kw[i]))
-  };
-}
-function ownReady(Fs, read, write) {
-  const flags = (fd) => {
-    const stream = Fs.getStream(fd);
-    if (!stream) return POLLNVAL;
-    return stream.stream_ops.poll ? stream.stream_ops.poll(stream) : POLLIN2 | POLLOUT2;
-  };
-  return {
-    read: read.filter((fd) => flags(fd) & (POLLIN2 | POLLHUP2 | POLLERR2 | POLLNVAL)),
-    write: write.filter((fd) => flags(fd) & (POLLOUT2 | POLLERR2 | POLLNVAL))
-  };
-}
-function anySelect(Fs, transport, read, write, timeoutMs) {
-  const kernel = (fd) => Fs.getStream(fd)?.sliccKernelFd;
-  const own = (fd) => kernel(fd) === void 0;
-  if (![...read, ...write].some(own)) return kernelSelect(Fs, transport, read, write, timeoutMs);
-  const deadline = timeoutMs < 0 ? Number.POSITIVE_INFINITY : Date.now() + timeoutMs;
-  const kernelRead = read.filter((fd) => !own(fd));
-  const kernelWrite = write.filter((fd) => !own(fd));
-  for (; ; ) {
-    const local = ownReady(Fs, read.filter(own), write.filter(own));
-    const pending = local.read.length > 0 || local.write.length > 0;
-    const slice = pending ? 0 : Math.min(SELECT_SLICE_MS, Math.max(0, deadline - Date.now()));
-    const got = kernelSelect(Fs, transport, kernelRead, kernelWrite, slice);
-    if (typeof got === "number") return got;
-    const ready = { read: [...local.read, ...got.read], write: [...local.write, ...got.write] };
-    if (ready.read.length > 0 || ready.write.length > 0 || Date.now() >= deadline) {
-      return ready;
-    }
-  }
-}
-function createProcessKernel(deps) {
-  const { transport, Fs } = 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 stream = fd >= 0 ? Fs.getStream(fd) : null;
-    if (!stream) return { none: true };
-    promote?.(stream);
-    if (stream.sliccKernelFd !== void 0) return { fd: stream.sliccKernelFd };
-    if (stream.path === "/dev/null") return { none: true };
-    return n === 0 ? { input: drain(Fs, stream) } : { capture: true };
-  };
-  const kernelWait = (pid, nohang, options = 0) => {
-    const req = {
-      op: "proc-wait",
-      pid,
-      nohang,
-      ...options & WUNTRACED ? { untraced: true } : {},
-      ...options & WCONTINUED ? { continued: true } : {}
-    };
-    let r = transport.call(req, Infinity, `proc-wait ${pid}`);
-    while (!r.ok && r.errno === "EINTR" && deps.restartable?.()) {
-      r = transport.call(req, Infinity, `proc-wait ${pid}`);
-    }
-    if (!r.ok) return -wasiErrno(r.errno);
-    const waited = r.kind === "json" ? r.json : [0, 0];
-    if (waited[0] > 0) deps.afterChild();
-    return [waited[0], waited[1]];
-  };
-  const deliver = (pid, n, fd) => {
-    const r = transport.call(
-      { op: "proc-captured", pid, slot: n },
-      Infinity,
-      `proc-captured ${pid}`
-    );
-    const stream = Fs.getStream(fd);
-    if (r.ok && r.kind === "bytes" && r.bytes.length > 0 && stream) {
-      Fs.write(stream, r.bytes, 0, r.bytes.length);
-    }
-  };
-  const execCaptures = /* @__PURE__ */ new Map();
-  const execWait = (pid) => {
-    const r = transport.call({ op: "proc-exec", pid }, Infinity, `exec ${pid}`);
-    if (!r.ok) return -wasiErrno(r.errno);
-    deps.afterChild();
-    return r.kind === "json" ? r.json[1] : 0;
-  };
-  const spawnChild = (file, argv, env, cwd, fds, actions, exec) => {
-    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 inherit = deps.inherit?.(actions) ?? [];
-    const r = transport.call(
-      {
-        op: "proc-spawn",
-        file,
-        argv,
-        env: env ?? deps.env,
-        cwd: cwd ?? Fs.cwd(),
-        stdio,
-        ...inherit.length > 0 ? { inherit } : {},
-        ...exec ? { exec } : {}
-      },
-      Infinity,
-      `proc-spawn ${file}`
-    );
-    if (!r.ok) return -wasiErrno(r.errno);
-    const pid = r.kind === "json" ? r.json : 0;
-    const captures = [1, 2].filter((n) => "capture" in stdio[n]);
-    if (captures.length === 0) return pid;
-    if (exec) {
-      execCaptures.set(pid, () => {
-        for (const n of captures) deliver(pid, n, fds[n]);
-      });
-      return pid;
-    }
-    const waited = kernelWait(pid, false);
-    if (typeof waited === "number") return waited;
-    for (const n of captures) deliver(pid, n, fds[n]);
-    reaped.set(pid, waited[1]);
-    return pid;
-  };
-  return {
-    spawn(file, argv, env, cwd, fds, actions) {
-      return spawnChild(file, argv, env, cwd, fds, actions, false);
-    },
-    fork(state) {
-      const unflushed = flushed(deps.beforeSpawn);
-      if (unflushed < 0) return unflushed;
-      const streams = deps.describeFork();
-      const r = transport.call(
-        { op: "proc-fork", state: { ...state, streams, cwd: Fs.cwd() } },
-        Infinity,
-        "proc-fork"
-      );
-      if (!r.ok) return -wasiErrno(r.errno);
-      return r.kind === "json" ? r.json : -wasiErrno("EIO");
-    },
-    select: (read, write, timeoutMs) => anySelect(Fs, transport, read, write, timeoutMs),
-    execWait,
-    execve(file, argv, env, cwd) {
-      const pid = spawnChild(file, argv, env, cwd, [0, 1, 2], void 0, true);
-      if (pid < 0) return pid;
-      const status2 = execWait(pid);
-      execCaptures.get(pid)?.();
-      execCaptures.delete(pid);
-      return status2;
-    },
-    pause() {
-      return status(call2({ op: "sig-pause" }, "pause"));
-    },
-    mount(source, target, type, flags, data) {
-      const req = { op: "mount", source, target: at(target), type, flags, data };
-      return status(call2(req, `mount ${target}`));
-    },
-    umount2(target, flags) {
-      return status(call2({ op: "umount", target: at(target), flags }, `umount ${target}`));
-    },
-    kill(pid, sig) {
-      if (pid === deps.pid) {
-        if (sig !== 0) deps.raise?.(sig);
-        return 0;
-      }
-      return status(call2({ op: "proc-kill", pid, sig }, `kill ${pid}`));
-    },
-    setpgid: (pid, pgid) => status(call2({ op: "proc-setpgid", pid, pgid }, "setpgid")),
-    setsid: () => number(call2({ op: "proc-setsid" }, "setsid")),
-    getpgid: (pid) => number(call2({ op: "proc-getpgid", pid }, "getpgid")),
-    getsid: (pid) => number(call2({ op: "proc-getsid", pid }, "getsid")),
-    tcgetpgrp(fd) {
-      const kfd = Fs.getStream(fd)?.sliccKernelFd;
-      if (kfd === void 0) return -wasiErrno("ENOTTY");
-      return number(call2({ op: "tty-pgrp-get", fd: kfd }, "tcgetpgrp"));
-    },
-    tcsetpgrp(fd, pgrp) {
-      const kfd = Fs.getStream(fd)?.sliccKernelFd;
-      if (kfd === void 0) return -wasiErrno("ENOTTY");
-      return status(call2({ op: "tty-pgrp-set", fd: kfd, pgrp }, "tcsetpgrp"));
-    },
-    wait(pid, nohang, options) {
-      const key = pid > 0 ? reaped.has(pid) ? pid : void 0 : reaped.keys().next().value;
-      if (key !== void 0) {
-        const status2 = reaped.get(key);
-        reaped.delete(key);
-        return [key, status2];
-      }
-      return kernelWait(pid, nohang, options);
-    }
-  };
-}
-var POLLIN2, POLLOUT2, POLLERR2, POLLHUP2, POLLNVAL, SELECT_SLICE_MS, WUNTRACED, WCONTINUED;
-var init_process_children = __esm({
-  "src/process/process-children.ts"() {
-    "use strict";
-    init_wasi_errno();
-    POLLIN2 = 1;
-    POLLOUT2 = 4;
-    POLLERR2 = 8;
-    POLLHUP2 = 16;
-    POLLNVAL = 32;
-    SELECT_SLICE_MS = 20;
-    WUNTRACED = 2;
-    WCONTINUED = 8;
-  }
-});
-
 // src/process/process-pty.ts
 function failed(e) {
   const code2 = e?.code;
@@ -2487,7 +2269,46 @@ function describeFdDir(Fs) {
       };
       return entry;
     }
-  };
+  };
+}
+function useZeroDevices(Fs) {
+  const { analyzePath, registerDevice, mkdev, makedev } = Fs;
+  if (!analyzePath || !registerDevice || !mkdev || !makedev) return;
+  const zeros = (_s, buffer, offset, length) => {
+    buffer.fill(0, offset, offset + length);
+    return length;
+  };
+  const devices = [
+    ["/dev/zero", 5, (_s, _b, _o, length) => length],
+    [
+      "/dev/full",
+      7,
+      (_s, _b, _o, length) => {
+        if (length > 0) throw new Fs.ErrnoError(wasiErrno("ENOSPC"));
+        return 0;
+      }
+    ]
+  ];
+  for (const [path, minor, write] of devices) {
+    if (analyzePath.call(Fs, path).exists) continue;
+    const dev = makedev.call(Fs, 1, minor);
+    registerDevice.call(Fs, dev, { read: zeros, write, llseek: () => 0 });
+    mkdev.call(Fs, path, CHAR_DEVICE, dev);
+  }
+}
+function linkStdio(Fs) {
+  const { unlink, symlink } = Fs;
+  if (!unlink || !symlink) return;
+  for (const [fd, name] of ["stdin", "stdout", "stderr"].entries()) {
+    try {
+      unlink.call(Fs, `/dev/${name}`);
+    } catch {
+    }
+    try {
+      symlink.call(Fs, `/proc/self/fd/${fd}`, `/dev/${name}`);
+    } catch {
+    }
+  }
 }
 function useDevFd(Fs) {
   if (typeof Fs.open !== "function") return;
@@ -2495,6 +2316,7 @@ function useDevFd(Fs) {
     Fs.symlink?.("/proc/self/fd", "/dev/fd");
   } catch {
   }
+  linkStdio(Fs);
   describeFdDir(Fs);
   const fdOf = (path) => typeof path === "string" ? fdOfPath(path, Fs.cwd()) : void 0;
   const target = (fd) => {
@@ -2581,7 +2403,7 @@ function useMounts(Fs, env = {}, live = false) {
     }
   };
 }
-var O_CLOEXEC, FD_CLOEXEC, F_DUPFD, F_GETFD, F_SETFD, F_GETFL, F_DUPFD_CLOEXEC, tracked, IMPORT_NAMES, EBADF, AT_SYMLINK_NOFOLLOW, EMSCRIPTEN_EPERM, DIR_MODE, LINK_MODE, O_ACCMODE, O_CREAT2, field, NAME;
+var O_CLOEXEC, FD_CLOEXEC, F_DUPFD, F_GETFD, F_SETFD, F_GETFL, F_DUPFD_CLOEXEC, tracked, IMPORT_NAMES, EBADF, AT_SYMLINK_NOFOLLOW, EMSCRIPTEN_EPERM, DIR_MODE, LINK_MODE, CHAR_DEVICE, O_ACCMODE, O_CREAT2, field, NAME;
 var init_process_fds = __esm({
   "src/process/process-fds.ts"() {
     "use strict";
@@ -2610,6 +2432,7 @@ var init_process_fds = __esm({
     EMSCRIPTEN_EPERM = 63;
     DIR_MODE = 16749;
     LINK_MODE = 41408;
+    CHAR_DEVICE = 8630;
     O_ACCMODE = 3;
     O_CREAT2 = 64;
     field = (text) => (text || "none").replace(/[\s\\]/g, (c) => `\\${c.charCodeAt(0).toString(8).padStart(3, "0")}`);
@@ -2696,12 +2519,16 @@ function describeInherited(Fs, sys, streams, livePath, actions = []) {
   }
   return out;
 }
+function deviceOfStream(stream) {
+  const device = stream.path === void 0 ? void 0 : DEVICES[stream.path];
+  if (!device || stream.sliccKernelFd !== void 0) return void 0;
+  const access = ACCESS[stream.flags & O_ACCMODE2];
+  return { device, ...access ? { access } : {} };
+}
 function inheritedSlot(fd, stream) {
   if (stream.sliccKernelFd === void 0) {
-    const device = stream.path === void 0 ? void 0 : DEVICES[stream.path];
-    if (!device) return void 0;
-    const access = ACCESS[stream.flags & O_ACCMODE2];
-    return { fd, device, ...access ? { access } : {} };
+    const device = deviceOfStream(stream);
+    return device ? { fd, ...device } : void 0;
   }
   const flags = stream.sliccKernelSocket ? { flags: stream.flags } : {};
   return { fd, kernel: stream.sliccKernelFd, ...flags };
@@ -2725,15 +2552,19 @@ function asFifo(stream, streams, identity) {
   const fixed = inos.get(identity) ?? nextStreamIno++;
   inos.set(identity, fixed);
   const node = stream.node;
-  stream.stream_ops = {
-    ...stream.stream_ops,
-    getattr: () => ({ ...node.node_ops?.getattr?.(node), mode: FIFO_MODE, ino: fixed, size: 0 })
-  };
+  streams.describe(stream, `pipe:[${fixed}]`, () => ({
+    ...node.node_ops?.getattr?.(node),
+    mode: FIFO_MODE,
+    ino: fixed,
+    size: 0
+  }));
 }
 function placeKernelStream(Fs, streams, entry) {
   const stream = place(Fs, placeholder(Fs, streams, entry), entry.fd);
-  if (entry.kind === "file") streams.attachFile(stream, entry.kernel);
-  else if (entry.kind === "socket") streams.attachSocket(stream, entry.kernel);
+  if (entry.kind === "file") {
+    streams.attachFile(stream, entry.kernel);
+    streams.sizeFromKernel(stream, entry.kernel);
+  } else if (entry.kind === "socket") streams.attachSocket(stream, entry.kernel);
   else streams.attach(stream, entry.kernel, entry.kind === "tty");
   if (entry.kind === "tty") streams.nameTerminal(stream);
   if (entry.kind === "stream") {
@@ -2775,6 +2606,7 @@ var init_process_fork = __esm({
     DEVICES = {
       "/dev/null": "null",
       "/dev/zero": "zero",
+      "/dev/full": "full",
       "/dev/urandom": "urandom",
       "/dev/random": "urandom"
     };
@@ -2784,6 +2616,255 @@ var init_process_fork = __esm({
   }
 });
 
+// src/process/process-children.ts
+function status(r) {
+  return r.ok ? 0 : -wasiErrno(r.errno);
+}
+function number(r) {
+  if (!r.ok) return -wasiErrno(r.errno);
+  return r.kind === "json" && typeof r.json === "number" ? r.json : -wasiErrno("EIO");
+}
+function flushed(beforeSpawn) {
+  try {
+    beforeSpawn();
+    return 0;
+  } catch (err) {
+    const errno2 = err?.errno;
+    if (typeof errno2 !== "number") throw err;
+    return -errno2;
+  }
+}
+function drain(Fs, stream) {
+  const chunks = [];
+  const buffer = new Uint8Array(65536);
+  try {
+    for (let n = Fs.read(stream, buffer, 0, buffer.length); n > 0; ) {
+      chunks.push(buffer.slice(0, n));
+      n = Fs.read(stream, buffer, 0, buffer.length);
+    }
+  } catch {
+  }
+  const out = new Uint8Array(chunks.reduce((n, c) => n + c.length, 0));
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return out;
+}
+function kernelSelect(Fs, transport, read, write, timeoutMs) {
+  const kernel = (fd) => Fs.getStream(fd)?.sliccKernelFd;
+  const kr = read.map(kernel);
+  const kw = write.map(kernel);
+  const r = transport.call({ op: "fd-select", read: kr, write: kw, timeoutMs }, Infinity, "select");
+  if (!r.ok) return -wasiErrno(r.errno);
+  const got = r.kind === "json" ? r.json : { read: [], write: [] };
+  return {
+    read: read.filter((_, i) => got.read.includes(kr[i])),
+    write: write.filter((_, i) => got.write.includes(kw[i]))
+  };
+}
+function ownReady(Fs, read, write) {
+  const flags = (fd) => {
+    const stream = Fs.getStream(fd);
+    if (!stream) return POLLNVAL;
+    return stream.stream_ops.poll ? stream.stream_ops.poll(stream) : POLLIN2 | POLLOUT2;
+  };
+  return {
+    read: read.filter((fd) => flags(fd) & (POLLIN2 | POLLHUP2 | POLLERR2 | POLLNVAL)),
+    write: write.filter((fd) => flags(fd) & (POLLOUT2 | POLLERR2 | POLLNVAL))
+  };
+}
+function anySelect(Fs, transport, read, write, timeoutMs) {
+  const kernel = (fd) => Fs.getStream(fd)?.sliccKernelFd;
+  const own = (fd) => kernel(fd) === void 0;
+  if (![...read, ...write].some(own)) return kernelSelect(Fs, transport, read, write, timeoutMs);
+  const deadline = timeoutMs < 0 ? Number.POSITIVE_INFINITY : Date.now() + timeoutMs;
+  const kernelRead = read.filter((fd) => !own(fd));
+  const kernelWrite = write.filter((fd) => !own(fd));
+  for (; ; ) {
+    const local = ownReady(Fs, read.filter(own), write.filter(own));
+    const pending = local.read.length > 0 || local.write.length > 0;
+    const slice = pending ? 0 : Math.min(SELECT_SLICE_MS, Math.max(0, deadline - Date.now()));
+    const got = kernelSelect(Fs, transport, kernelRead, kernelWrite, slice);
+    if (typeof got === "number") return got;
+    const ready = { read: [...local.read, ...got.read], write: [...local.write, ...got.write] };
+    if (ready.read.length > 0 || ready.write.length > 0 || Date.now() >= deadline) {
+      return ready;
+    }
+  }
+}
+function createProcessKernel(deps) {
+  const { transport, Fs } = 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 stream = fd >= 0 ? Fs.getStream(fd) : null;
+    if (!stream) return { none: true };
+    promote?.(stream);
+    if (stream.sliccKernelFd !== void 0) return { fd: stream.sliccKernelFd };
+    if (stream.path === "/dev/null") return { none: true };
+    const device = deviceOfStream(stream);
+    if (device) return device;
+    return n === 0 ? { input: drain(Fs, stream) } : { capture: true };
+  };
+  const kernelWait = (pid, nohang, options = 0) => {
+    const req = {
+      op: "proc-wait",
+      pid,
+      nohang,
+      ...options & WUNTRACED ? { untraced: true } : {},
+      ...options & WCONTINUED ? { continued: true } : {}
+    };
+    let r = transport.call(req, Infinity, `proc-wait ${pid}`);
+    while (!r.ok && r.errno === "EINTR" && deps.restartable?.()) {
+      r = transport.call(req, Infinity, `proc-wait ${pid}`);
+    }
+    if (!r.ok) return -wasiErrno(r.errno);
+    const waited = r.kind === "json" ? r.json : [0, 0];
+    if (waited[0] > 0) deps.afterChild();
+    return [waited[0], waited[1]];
+  };
+  const deliver = (pid, n, fd) => {
+    const r = transport.call(
+      { op: "proc-captured", pid, slot: n },
+      Infinity,
+      `proc-captured ${pid}`
+    );
+    const stream = Fs.getStream(fd);
+    if (r.ok && r.kind === "bytes" && r.bytes.length > 0 && stream) {
+      Fs.write(stream, r.bytes, 0, r.bytes.length);
+    }
+  };
+  const execCaptures = /* @__PURE__ */ new Map();
+  const execWait = (pid) => {
+    const r = transport.call({ op: "proc-exec", pid }, Infinity, `exec ${pid}`);
+    if (!r.ok) return -wasiErrno(r.errno);
+    deps.afterChild();
+    return r.kind === "json" ? r.json[1] : 0;
+  };
+  const spawnChild = (file, argv, env, cwd, fds, actions, exec) => {
+    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 inherit = deps.inherit?.(actions) ?? [];
+    const r = transport.call(
+      {
+        op: "proc-spawn",
+        file,
+        argv,
+        env: env ?? deps.env,
+        cwd: cwd ?? Fs.cwd(),
+        stdio,
+        ...inherit.length > 0 ? { inherit } : {},
+        ...exec ? { exec } : {}
+      },
+      Infinity,
+      `proc-spawn ${file}`
+    );
+    if (!r.ok) return -wasiErrno(r.errno);
+    const pid = r.kind === "json" ? r.json : 0;
+    const captures = [1, 2].filter((n) => "capture" in stdio[n]);
+    if (captures.length === 0) return pid;
+    if (exec) {
+      execCaptures.set(pid, () => {
+        for (const n of captures) deliver(pid, n, fds[n]);
+      });
+      return pid;
+    }
+    const waited = kernelWait(pid, false);
+    if (typeof waited === "number") return waited;
+    for (const n of captures) deliver(pid, n, fds[n]);
+    reaped.set(pid, waited[1]);
+    return pid;
+  };
+  return {
+    spawn(file, argv, env, cwd, fds, actions) {
+      return spawnChild(file, argv, env, cwd, fds, actions, false);
+    },
+    fork(state) {
+      const unflushed = flushed(deps.beforeSpawn);
+      if (unflushed < 0) return unflushed;
+      const streams = deps.describeFork();
+      const r = transport.call(
+        { op: "proc-fork", state: { ...state, streams, cwd: Fs.cwd() } },
+        Infinity,
+        "proc-fork"
+      );
+      if (!r.ok) return -wasiErrno(r.errno);
+      return r.kind === "json" ? r.json : -wasiErrno("EIO");
+    },
+    select: (read, write, timeoutMs) => anySelect(Fs, transport, read, write, timeoutMs),
+    execWait,
+    execve(file, argv, env, cwd) {
+      const pid = spawnChild(file, argv, env, cwd, [0, 1, 2], void 0, true);
+      if (pid < 0) return pid;
+      const status2 = execWait(pid);
+      execCaptures.get(pid)?.();
+      execCaptures.delete(pid);
+      return status2;
+    },
+    pause() {
+      return status(call2({ op: "sig-pause" }, "pause"));
+    },
+    mount(source, target, type, flags, data) {
+      const req = { op: "mount", source, target: at(target), type, flags, data };
+      return status(call2(req, `mount ${target}`));
+    },
+    umount2(target, flags) {
+      return status(call2({ op: "umount", target: at(target), flags }, `umount ${target}`));
+    },
+    kill(pid, sig) {
+      if (pid === deps.pid) {
+        if (sig !== 0) deps.raise?.(sig);
+        return 0;
+      }
+      return status(call2({ op: "proc-kill", pid, sig }, `kill ${pid}`));
+    },
+    setpgid: (pid, pgid) => status(call2({ op: "proc-setpgid", pid, pgid }, "setpgid")),
+    setsid: () => number(call2({ op: "proc-setsid" }, "setsid")),
+    getpgid: (pid) => number(call2({ op: "proc-getpgid", pid }, "getpgid")),
+    getsid: (pid) => number(call2({ op: "proc-getsid", pid }, "getsid")),
+    tcgetpgrp(fd) {
+      const kfd = Fs.getStream(fd)?.sliccKernelFd;
+      if (kfd === void 0) return -wasiErrno("ENOTTY");
+      return number(call2({ op: "tty-pgrp-get", fd: kfd }, "tcgetpgrp"));
+    },
+    tcsetpgrp(fd, pgrp) {
+      const kfd = Fs.getStream(fd)?.sliccKernelFd;
+      if (kfd === void 0) return -wasiErrno("ENOTTY");
+      return status(call2({ op: "tty-pgrp-set", fd: kfd, pgrp }, "tcsetpgrp"));
+    },
+    wait(pid, nohang, options) {
+      const key = pid > 0 ? reaped.has(pid) ? pid : void 0 : reaped.keys().next().value;
+      if (key !== void 0) {
+        const status2 = reaped.get(key);
+        reaped.delete(key);
+        return [key, status2];
+      }
+      return kernelWait(pid, nohang, options);
+    }
+  };
+}
+var POLLIN2, POLLOUT2, POLLERR2, POLLHUP2, POLLNVAL, SELECT_SLICE_MS, WUNTRACED, WCONTINUED;
+var init_process_children = __esm({
+  "src/process/process-children.ts"() {
+    "use strict";
+    init_process_fork();
+    init_wasi_errno();
+    POLLIN2 = 1;
+    POLLOUT2 = 4;
+    POLLERR2 = 8;
+    POLLHUP2 = 16;
+    POLLNVAL = 32;
+    SELECT_SLICE_MS = 20;
+    WUNTRACED = 2;
+    WCONTINUED = 8;
+  }
+});
+
 // src/process/process-http.ts
 function createHttpKernel(transport) {
   const call2 = (req) => {
@@ -3468,6 +3549,12 @@ function kernelSys(transport) {
     ttyName(fd) {
       return json(call2({ op: "fd-info", fd }, `fd-info ${fd}`))?.name;
     },
+    kind(fd) {
+      return json(call2({ op: "fd-info", fd }, `fd-info ${fd}`))?.kind;
+    },
+    size(fd) {
+      return json(call2({ op: "fd-vfs-stat", fd }, `fd-vfs-stat ${fd}`)).size;
+    },
     openTty(name) {
       const req = name === void 0 ? { op: "fd-open-tty" } : { op: "fd-open-tty", name };
       return json(call2(req, `fd-open-tty ${name ?? ""}`));
@@ -3535,10 +3622,18 @@ function openDevice(Fs, fd, meta) {
   }
   return true;
 }
-function wireKernelStdio(Fs, streams) {
+function wireKernelStdio(Fs, streams, sys) {
   for (const fd of [0, 1, 2]) {
     const stream = Fs.getStream(fd);
     if (!stream) continue;
+    const kind = sys?.kind?.(fd);
+    if (kind && PLACED.has(kind)) {
+      const { flags } = stream;
+      Fs.closeStream(fd);
+      const kernel = { fd, kernel: fd, kind, flags };
+      placeKernelStream(Fs, streams, kernel).flags = flags;
+      continue;
+    }
     streams.attach(stream, fd);
     streams.nameTerminal(stream);
   }
@@ -3679,10 +3774,11 @@ async function runWasmProcess(init, port2, deps = {}) {
   trackCloseOnExec(running.FS);
   quietQuit(running.FS);
   useMounts(running.FS, init.env, true);
+  useZeroDevices(running.FS);
   useProcfs(running.FS, sys, init.pid);
   if (init.fork) restoreForkedStreams(running.FS, streams, init.fork.streams ?? []);
   else {
-    wireKernelStdio(running.FS, streams);
+    wireKernelStdio(running.FS, streams, sys);
     for (const entry of init.fds ?? []) wireKernelFd(running.FS, streams, entry);
   }
   const pipefs = ownValue(running, "PIPEFS");
@@ -3760,7 +3856,7 @@ function runMain(running, init) {
     return status2;
   }
 }
-var O_RDONLY, O_WRONLY2, O_RDWR3, GLUE_TRAILER, evaluateGlue, EVAL_BLOCKED;
+var O_RDONLY, O_WRONLY2, O_RDWR3, PLACED, GLUE_TRAILER, evaluateGlue, EVAL_BLOCKED;
 var init_process_runtime = __esm({
   "src/process/process-runtime.ts"() {
     "use strict";
@@ -3783,6 +3879,7 @@ var init_process_runtime = __esm({
     O_RDONLY = 0;
     O_WRONLY2 = 1;
     O_RDWR3 = 2;
+    PLACED = /* @__PURE__ */ new Set(["stream", "file", "socket"]);
     GLUE_TRAILER = [
       "if (typeof ENV !== 'undefined') Object.assign(ENV, Module.sliccEnv);",
       "const __sliccTake = (name, value) => {",
@@ -4262,6 +4359,7 @@ var init_wasi_fds = __esm({
     DEVICES2 = {
       "/dev/null": "null",
       "/dev/zero": "zero",
+      "/dev/full": "full",
       "/dev/urandom": "urandom",
       "/dev/random": "urandom"
     };
@@ -5299,6 +5397,7 @@ var init_wasi_host = __esm({
         }
         if (e.type === "device") {
           if (e.access === "read") throw new WasiError("EBADF");
+          if (e.device === "full" && data.length > 0) throw new WasiError("ENOSPC");
           return data.length;
         }
         return this.file(fd, "write").write(data);
@@ -5312,7 +5411,7 @@ var init_wasi_host = __esm({
           if (e.access === "write") throw new WasiError("EBADF");
           if (e.device === "null") return new Uint8Array(0);
           const out = new Uint8Array(Math.min(max, 65536));
-          return e.device === "zero" ? out : crypto.getRandomValues(out);
+          return e.device === "urandom" ? crypto.getRandomValues(out) : out;
         }
         return this.file(fd, "read").read(max);
       }