@ai-ecoverse/slicc-kernel 0.0.0 → 1.1.0

package/dist/process-worker.js

@@ -0,0 +1,2179 @@
+// src/kernel/protocol.ts
+var WASM_PROCESS_INIT = "wasm-process-init";
+var WASM_PROCESS_EXIT = "wasm-process-exit";
+var WASM_PROCESS_ERROR = "wasm-process-error";
+
+// src/kernel/signals.ts
+var SIG = {
+  HUP: 1,
+  INT: 2,
+  QUIT: 3,
+  ILL: 4,
+  TRAP: 5,
+  ABRT: 6,
+  BUS: 7,
+  FPE: 8,
+  KILL: 9,
+  USR1: 10,
+  SEGV: 11,
+  USR2: 12,
+  PIPE: 13,
+  ALRM: 14,
+  TERM: 15,
+  STKFLT: 16,
+  CHLD: 17,
+  CONT: 18,
+  STOP: 19,
+  TSTP: 20,
+  TTIN: 21,
+  TTOU: 22,
+  URG: 23,
+  XCPU: 24,
+  XFSZ: 25,
+  VTALRM: 26,
+  PROF: 27,
+  WINCH: 28,
+  POLL: 29,
+  PWR: 30,
+  SYS: 31
+};
+var IGNORED_BY_DEFAULT = /* @__PURE__ */ new Set([SIG.CHLD, SIG.URG, SIG.WINCH]);
+var STOPPING = /* @__PURE__ */ new Set([SIG.STOP, SIG.TSTP, SIG.TTIN, SIG.TTOU]);
+function sigbit(sig) {
+  return 1 << sig;
+}
+function signalsIn(mask) {
+  const out = [];
+  for (let sig = 1; sig <= 31; sig++) if (mask & sigbit(sig)) out.push(sig);
+  return out;
+}
+var SIGNAL_BY_NAME = {
+  SIGINT: SIG.INT,
+  SIGTERM: SIG.TERM,
+  SIGKILL: SIG.KILL,
+  SIGSTOP: SIG.STOP,
+  SIGCONT: SIG.CONT
+};
+
+// src/realm/live-vfs-fs.ts
+var ERRNO_BY_CODE = {
+  EACCES: 2,
+  EBADF: 8,
+  EBUSY: 10,
+  EEXIST: 20,
+  EINVAL: 28,
+  EIO: 29,
+  EISDIR: 31,
+  ELOOP: 32,
+  ENAMETOOLONG: 37,
+  ENOENT: 44,
+  ENOSPC: 51,
+  ENOSYS: 52,
+  ENOTDIR: 54,
+  ENOTEMPTY: 55,
+  EPERM: 63,
+  EROFS: 69,
+  ETIMEDOUT: 73,
+  EXDEV: 75
+};
+var EIO = 29;
+var S_IFDIR = 16384;
+var S_IFREG = 32768;
+var S_IFLNK = 40960;
+var PERM_MASK = 4095;
+var DEFAULT_DIR_PERM = 493;
+var UMASK = 18;
+var SEEK_CUR = 1;
+var SEEK_END = 2;
+function toErrno(Fs, err) {
+  if (err?.errno !== void 0 && err instanceof Fs.ErrnoError) {
+    return err;
+  }
+  const code = err?.code;
+  const errno = typeof code === "string" ? ERRNO_BY_CODE[code] ?? EIO : EIO;
+  return new Fs.ErrnoError(errno);
+}
+function liveNodePath(node) {
+  const parts = [];
+  let cur = node;
+  while (cur !== cur.mount.root) {
+    parts.push(cur.name);
+    cur = cur.parent;
+  }
+  const root = node.mount.opts.root.replace(/\/+$/, "");
+  return parts.length === 0 ? root || "/" : `${root}/${parts.reverse().join("/")}`;
+}
+function inodeOf(path) {
+  let h1 = 3735928559;
+  let h2 = 1103547991;
+  for (let i = 0; i < path.length; i++) {
+    const c = path.charCodeAt(i);
+    h1 = Math.imul(h1 ^ c, 2654435761);
+    h2 = Math.imul(h2 ^ c, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ h1 >>> 16, 2246822507) ^ Math.imul(h2 ^ h2 >>> 13, 3266489909);
+  h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
+  return 4294967296 * (2097151 & h2) + (h1 >>> 0) || 1;
+}
+function modeFromStat(st) {
+  const type = st.isSymbolicLink ? S_IFLNK : st.isDirectory ? S_IFDIR : S_IFREG;
+  const fallback = st.isDirectory || st.isSymbolicLink ? 511 : 438;
+  return type | ((st.mode ?? fallback) & PERM_MASK || fallback);
+}
+function toMs(v) {
+  if (v === void 0 || v === null) return void 0;
+  return v instanceof Date ? v.getTime() : v;
+}
+function createHelpers(Fs, ops) {
+  const bridgeOf = (node) => node.mount.opts.bridge;
+  function call(fn) {
+    try {
+      return fn();
+    } catch (err) {
+      throw toErrno(Fs, err);
+    }
+  }
+  function metadataCall(fn) {
+    try {
+      call(fn);
+    } catch (err) {
+      if (err.errno !== ERRNO_BY_CODE.ENOSYS) throw err;
+    }
+  }
+  function freshState(stat) {
+    return { ...stat ? { stat } : {}, len: 0, loaded: false, dirty: false, openCount: 0 };
+  }
+  function makeNode(parent, name, st) {
+    const node = Fs.createNode(parent, name, modeFromStat(st), 0);
+    node.node_ops = ops.node;
+    node.stream_ops = ops.stream;
+    node.live = freshState(st);
+    return node;
+  }
+  function statOf(node) {
+    if (node.live.orphan) {
+      return { ...node.live.stat, size: node.live.len };
+    }
+    if (!node.live.stat) {
+      const st = call(() => bridgeOf(node).lstat(liveNodePath(node)));
+      node.live.stat = st;
+      node.mode = modeFromStat(st);
+    }
+    return node.live.stat;
+  }
+  function childPath(parent, name) {
+    const base = liveNodePath(parent);
+    return base === "/" ? `/${name}` : `${base}/${name}`;
+  }
+  function ensureLoaded(node) {
+    const s = node.live;
+    if (s.loaded) return;
+    const bytes = call(() => bridgeOf(node).readFile(liveNodePath(node)));
+    s.data = bytes;
+    s.len = bytes.length;
+    s.loaded = true;
+  }
+  function ensureCapacity(node, need) {
+    const s = node.live;
+    const cur = s.data ?? new Uint8Array(0);
+    if (cur.length >= need) return cur;
+    const grown = new Uint8Array(Math.max(need, cur.length * 2, 256));
+    grown.set(cur.subarray(0, s.len));
+    s.data = grown;
+    return grown;
+  }
+  function flushNode(node) {
+    const s = node.live;
+    if (!s.dirty || !s.data || s.orphan) return;
+    const bytes = s.data.slice(0, s.len);
+    call(() => bridgeOf(node).writeFile(liveNodePath(node), bytes));
+    s.dirty = false;
+    s.stat = void 0;
+  }
+  function truncate(node, size) {
+    const s = node.live;
+    if (s.openCount > 0) {
+      if (size > 0) ensureLoaded(node);
+      else s.loaded = true;
+      const buf = ensureCapacity(node, size);
+      if (size > s.len) buf.fill(0, s.len, size);
+      s.len = size;
+      s.dirty = true;
+      return;
+    }
+    const path = liveNodePath(node);
+    const bytes = new Uint8Array(size);
+    if (size > 0) {
+      const cur = call(() => bridgeOf(node).readFile(path));
+      bytes.set(cur.subarray(0, Math.min(size, cur.length)));
+    }
+    call(() => bridgeOf(node).writeFile(path, bytes));
+    s.stat = void 0;
+  }
+  return {
+    Fs,
+    bridgeOf,
+    call,
+    metadataCall,
+    makeNode,
+    statOf,
+    childPath,
+    ensureLoaded,
+    ensureCapacity,
+    flushNode,
+    truncate
+  };
+}
+function createNodeOps(h) {
+  const { Fs, bridgeOf, call, metadataCall, makeNode, statOf, childPath, flushNode, truncate } = h;
+  const { ensureLoaded } = h;
+  return {
+    getattr(node) {
+      const st = statOf(node);
+      const s = node.live;
+      const size = Fs.isDir(node.mode) ? 4096 : s.loaded ? s.len : st.size;
+      const mtime = new Date(st.mtimeMs ?? 0);
+      return {
+        dev: 1,
+        ino: st.ino ?? inodeOf(liveNodePath(node)),
+        mode: node.mode,
+        nlink: 1,
+        uid: 0,
+        gid: 0,
+        rdev: 0,
+        size,
+        atime: mtime,
+        mtime,
+        ctime: mtime,
+        blksize: 4096,
+        blocks: Math.ceil(size / 4096)
+      };
+    },
+    setattr(node, attr) {
+      if (node.live.orphan) {
+        if (attr.mode !== void 0 && attr.mode !== null) {
+          node.mode = node.mode & ~PERM_MASK | attr.mode & PERM_MASK;
+        }
+        if (attr.size !== void 0 && attr.size !== null) truncate(node, attr.size);
+        return;
+      }
+      const path = liveNodePath(node);
+      if (attr.mode !== void 0 && attr.mode !== null) {
+        const perm = attr.mode & PERM_MASK;
+        if (perm !== (node.mode & PERM_MASK)) {
+          metadataCall(() => bridgeOf(node).chmod(path, perm));
+          node.mode = node.mode & ~PERM_MASK | perm;
+        }
+      }
+      if (attr.size !== void 0 && attr.size !== null && Fs.isFile(node.mode)) {
+        truncate(node, attr.size);
+      }
+      const mtime = toMs(attr.mtime) ?? attr.timestamp;
+      if (mtime !== void 0) {
+        const atime = toMs(attr.atime) ?? mtime;
+        flushNode(node);
+        metadataCall(() => bridgeOf(node).utimes(path, atime, mtime));
+      }
+      node.live.stat = void 0;
+    },
+    lookup(parent, name) {
+      const st = call(() => bridgeOf(parent).lstat(childPath(parent, name)));
+      return makeNode(parent, name, st);
+    },
+    mknod(parent, name, mode) {
+      const path = childPath(parent, name);
+      if (Fs.isDir(mode)) {
+        call(() => bridgeOf(parent).mkdir(path));
+        const perm = mode & PERM_MASK & ~UMASK;
+        if (perm !== DEFAULT_DIR_PERM) metadataCall(() => bridgeOf(parent).chmod(path, perm));
+      } else if (Fs.isFile(mode)) {
+        call(() => bridgeOf(parent).writeFile(path, new Uint8Array(0)));
+      } else {
+        throw new Fs.ErrnoError(ERRNO_BY_CODE.EPERM);
+      }
+      const node = makeNode(parent, name, {
+        isFile: Fs.isFile(mode),
+        isDirectory: Fs.isDir(mode),
+        isSymbolicLink: false,
+        size: 0,
+        mode,
+        mtimeMs: Date.now()
+      });
+      node.live.stat = void 0;
+      return node;
+    },
+    rename(oldNode, newDir, newName) {
+      const from = liveNodePath(oldNode);
+      const to = childPath(newDir, newName);
+      flushNode(oldNode);
+      call(() => bridgeOf(oldNode).rename(from, to));
+      try {
+        const existing = Fs.lookupNode?.(newDir, newName);
+        if (existing && existing !== oldNode) Fs.hashRemoveNode?.(existing);
+      } catch {
+      }
+      oldNode.name = newName;
+      oldNode.parent = newDir;
+      oldNode.live.stat = void 0;
+    },
+    unlink(parent, name) {
+      let open;
+      try {
+        const node = Fs.lookupNode?.(parent, name);
+        if (node && node.live?.openCount > 0 && Fs.isFile(node.mode)) open = node;
+      } catch {
+      }
+      if (open) {
+        statOf(open);
+        ensureLoaded(open);
+      }
+      call(() => bridgeOf(parent).unlink(childPath(parent, name)));
+      if (open) open.live.orphan = true;
+    },
+    rmdir(parent, name) {
+      call(() => bridgeOf(parent).rmdir(childPath(parent, name)));
+    },
+    readdir(node) {
+      return [".", "..", ...call(() => bridgeOf(node).readdir(liveNodePath(node)))];
+    },
+    symlink(parent, newName, target) {
+      const path = childPath(parent, newName);
+      call(() => bridgeOf(parent).symlink(target, path));
+      return makeNode(parent, newName, {
+        isFile: false,
+        isDirectory: false,
+        isSymbolicLink: true,
+        size: target.length
+      });
+    },
+    readlink(node) {
+      if (!Fs.isLink(node.mode)) throw new Fs.ErrnoError(ERRNO_BY_CODE.EINVAL);
+      return call(() => bridgeOf(node).readlink(liveNodePath(node)));
+    }
+  };
+}
+function createStreamOps(h) {
+  const { Fs, statOf, ensureLoaded, ensureCapacity, flushNode } = h;
+  return {
+    open(stream) {
+      if (!Fs.isFile(stream.node.mode)) return;
+      stream.node.live.openCount++;
+    },
+    dup(stream) {
+      if (!Fs.isFile(stream.node.mode)) return;
+      stream.node.live.openCount++;
+    },
+    close(stream) {
+      const node = stream.node;
+      if (!Fs.isFile(node.mode)) return;
+      const s = node.live;
+      s.openCount = Math.max(0, s.openCount - 1);
+      if (s.openCount > 0) return;
+      try {
+        flushNode(node);
+      } finally {
+        s.data = void 0;
+        s.len = 0;
+        s.loaded = false;
+      }
+    },
+    read(stream, buffer, offset, length, position) {
+      const node = stream.node;
+      if (Fs.isDir(node.mode)) throw new Fs.ErrnoError(ERRNO_BY_CODE.EISDIR);
+      ensureLoaded(node);
+      const s = node.live;
+      if (position >= s.len || length <= 0) return 0;
+      const n = Math.min(length, s.len - position);
+      const out = new Uint8Array(buffer.buffer, buffer.byteOffset + offset, n);
+      out.set(s.data.subarray(position, position + n));
+      return n;
+    },
+    write(stream, buffer, offset, length, position) {
+      const node = stream.node;
+      if (Fs.isDir(node.mode)) throw new Fs.ErrnoError(ERRNO_BY_CODE.EISDIR);
+      if (length <= 0) return 0;
+      ensureLoaded(node);
+      const s = node.live;
+      const end = position + length;
+      const buf = ensureCapacity(node, end);
+      if (position > s.len) buf.fill(0, s.len, position);
+      buf.set(new Uint8Array(buffer.buffer, buffer.byteOffset + offset, length), position);
+      s.len = Math.max(s.len, end);
+      s.dirty = true;
+      return length;
+    },
+    llseek(stream, offset, whence) {
+      let pos = offset;
+      if (whence === SEEK_CUR) pos += stream.position;
+      else if (whence === SEEK_END && Fs.isFile(stream.node.mode)) {
+        const s = stream.node.live;
+        pos += s.loaded ? s.len : statOf(stream.node).size;
+      }
+      if (pos < 0) throw new Fs.ErrnoError(ERRNO_BY_CODE.EINVAL);
+      return pos;
+    },
+    fsync(stream) {
+      flushNode(stream.node);
+    }
+  };
+}
+function createLiveVfsPlugin(Fs) {
+  const mounts = /* @__PURE__ */ new Set();
+  const ops = {};
+  const h = createHelpers(Fs, ops);
+  const nodeOps = createNodeOps(h);
+  const streamOps = createStreamOps(h);
+  ops.node = nodeOps;
+  ops.stream = streamOps;
+  return {
+    mounts,
+    node_ops: nodeOps,
+    stream_ops: streamOps,
+    mount(mount) {
+      const st = h.call(() => mount.opts.bridge.stat(mount.opts.root));
+      if (!st.isDirectory) throw new Fs.ErrnoError(ERRNO_BY_CODE.ENOTDIR);
+      const root = h.makeNode(null, "/", st);
+      mounts.add(mount);
+      return root;
+    }
+  };
+}
+function ownedBy(plugin, node) {
+  return !!node && plugin.mounts.has(node.mount);
+}
+function flushLiveVfs(Fs, plugin) {
+  for (const head of Fs.nameTable ?? []) {
+    for (let node = head; node; node = node.name_next ?? null) {
+      if (!ownedBy(plugin, node) || !node.live.dirty || !node.live.data) continue;
+      try {
+        const bytes = node.live.data.slice(0, node.live.len);
+        node.mount.opts.bridge.writeFile(liveNodePath(node), bytes);
+        node.live.dirty = false;
+      } catch (err) {
+        throw toErrno(Fs, err);
+      }
+    }
+  }
+}
+function invalidateLiveVfs(Fs, plugin) {
+  const table = Fs.nameTable ?? [];
+  const drop = [];
+  for (const head of table) {
+    for (let node = head; node; node = node.name_next ?? null) {
+      if (!ownedBy(plugin, node)) continue;
+      const s = node.live;
+      s.stat = void 0;
+      if (s.openCount === 0) {
+        if (node !== node.mount.root) drop.push(node);
+      } else if (s.loaded && !s.dirty) {
+        s.data = void 0;
+        s.len = 0;
+        s.loaded = false;
+      }
+    }
+  }
+  if (!Fs.hashRemoveNode) return;
+  for (const node of drop) Fs.hashRemoveNode(node);
+}
+function outermostDirs(dirs) {
+  const norm = [...new Set(dirs.map((d) => d.replace(/\/+$/, "") || "/"))].sort();
+  return norm.filter((d) => !norm.some((o) => o !== d && (o === "/" || d.startsWith(`${o}/`))));
+}
+function describeMountError(err) {
+  if (err instanceof Error) return err.message;
+  const errno = err?.errno;
+  return typeof errno === "number" ? `errno ${errno}` : String(err);
+}
+function mountLiveVfsDirs(Fs, bridge, dirs, warn) {
+  if (typeof Fs.filesystems !== "object" || !Fs.filesystems) {
+    throw new Error(
+      "the module was linked without filesystem support, so the VFS cannot be mounted (link it with -sFORCE_FILESYSTEM=1)"
+    );
+  }
+  const plugin = Fs.filesystems.SLICC_LIVE_FS ?? createLiveVfsPlugin(Fs);
+  Fs.filesystems.SLICC_LIVE_FS = plugin;
+  const mounted = [];
+  for (const dir of outermostDirs(dirs)) {
+    if (dir === "/") continue;
+    try {
+      Fs.mkdirTree(dir);
+      Fs.mount(plugin, { root: dir, bridge }, dir);
+      mounted.push(dir);
+    } catch (err) {
+      warn(`live VFS mount of ${dir} failed: ${describeMountError(err)}`);
+    }
+  }
+  return { plugin, mounted };
+}
+
+// src/realm/emscripten-vfs-hook.ts
+var MODULE_OWNED_DIRS = /* @__PURE__ */ new Set(["dev", "proc"]);
+var SYNTHETIC_DIRS = ["/usr", "/bin"];
+function topLevelDirs(bridge, warn) {
+  let names;
+  try {
+    names = bridge.readdir("/");
+  } catch (err) {
+    warn(`cannot list the VFS root, nothing mounted: ${String(err)}`);
+    return [];
+  }
+  const candidates = names.filter((name) => name && !name.includes("/") && !MODULE_OWNED_DIRS.has(name)).map((name) => `/${name}`);
+  for (const dir of SYNTHETIC_DIRS) if (!candidates.includes(dir)) candidates.push(dir);
+  const dirs = [];
+  for (const dir of candidates) {
+    try {
+      if (bridge.stat(dir).isDirectory) dirs.push(dir);
+    } catch {
+    }
+  }
+  return dirs;
+}
+function mountVfsIntoEmscripten(Fs, deps) {
+  const { bridge, warn } = deps;
+  const { plugin, mounted } = mountLiveVfsDirs(Fs, bridge, topLevelDirs(bridge, warn), warn);
+  try {
+    Fs.chdir(deps.cwd);
+  } catch (err) {
+    warn(`cannot chdir to ${deps.cwd}: ${String(err)}`);
+  }
+  return {
+    mounted,
+    flush: () => flushLiveVfs(Fs, plugin),
+    invalidate: () => invalidateLiveVfs(Fs, plugin)
+  };
+}
+
+// src/realm/sync-fs-wire.ts
+var SYNC_FS_REQUEST_TIMEOUT_MS = 25e3;
+function syncError(code, label) {
+  return Object.assign(new Error(`${code}: ${label}`), { code });
+}
+function parseSyncFsStat(json) {
+  const s = json;
+  if (!s || typeof s.isFile !== "boolean" || typeof s.isDirectory !== "boolean" || typeof s.size !== "number") {
+    return null;
+  }
+  return {
+    isFile: s.isFile,
+    isDirectory: s.isDirectory,
+    isSymbolicLink: s.isSymbolicLink,
+    size: s.size,
+    ...typeof s.mode === "number" ? { mode: s.mode } : {},
+    ...typeof s.mtimeMs === "number" ? { mtimeMs: s.mtimeMs } : {},
+    ...typeof s.ino === "number" ? { ino: s.ino } : {}
+  };
+}
+
+// src/realm/sync-sab-wire.ts
+var SAB_HEADER_I32 = 16;
+var SAB_HEADER_BYTES = SAB_HEADER_I32 * 4;
+var SAB_I_STATE = 0;
+var SAB_I_SEQ = 1;
+var SAB_I_STATUS = 2;
+var SAB_I_TOTAL = 3;
+var SAB_I_CHUNK = 4;
+var SAB_I_OFFSET = 5;
+var SAB_I_SIGNALS = 8;
+var SAB_I_TIMERS = 9;
+var SAB_STATE_IDLE = 0;
+var SAB_STATE_PENDING = 1;
+var SAB_STATE_READY = 2;
+var SAB_STATUS_BYTES = 1;
+var SAB_STATUS_JSON = 2;
+var SAB_STATUS_VOID = 3;
+var SAB_STATUS_ERRNO = 4;
+var SAB_DEFAULT_WINDOW_BYTES = 1024 * 1024;
+var SAB_MIN_BYTES = SAB_HEADER_BYTES + 4096;
+var SYNC_SAB_REQ_MSG = "sync-sab-req";
+var SYNC_SAB_NEXT_MSG = "sync-sab-next";
+var encoder = new TextEncoder();
+var decoder = new TextDecoder();
+function decodeSabResult(status2, payload) {
+  switch (status2) {
+    case SAB_STATUS_BYTES:
+      return { ok: true, kind: "bytes", bytes: payload };
+    case SAB_STATUS_VOID:
+      return { ok: true, kind: "void" };
+    case SAB_STATUS_JSON: {
+      try {
+        return { ok: true, kind: "json", json: JSON.parse(decoder.decode(payload)) };
+      } catch {
+        return { ok: false, errno: "EIO", message: "sync-sab: malformed json payload" };
+      }
+    }
+    case SAB_STATUS_ERRNO: {
+      try {
+        const parsed = JSON.parse(decoder.decode(payload));
+        const errno = typeof parsed.errno === "string" && /^E[A-Z]+$/.test(parsed.errno) ? parsed.errno : "EIO";
+        return { ok: false, errno, message: String(parsed.message ?? errno) };
+      } catch {
+        return { ok: false, errno: "EIO", message: "sync-sab: malformed errno payload" };
+      }
+    }
+    default:
+      return { ok: false, errno: "EIO", message: `sync-sab: unknown status ${status2}` };
+  }
+}
+function sabViews(sab) {
+  if (sab.byteLength < SAB_MIN_BYTES) {
+    throw new Error(`sync-sab: buffer too small (${sab.byteLength} < ${SAB_MIN_BYTES})`);
+  }
+  return {
+    header: new Int32Array(sab, 0, SAB_HEADER_I32),
+    window: new Uint8Array(sab, SAB_HEADER_BYTES)
+  };
+}
+
+// src/realm/sync-sab-bridge.ts
+function createSyncSabTransport(sab, port, deps = {}) {
+  const views = sabViews(sab);
+  const { header, window } = views;
+  const wait = deps.wait ?? ((a, i, v, t) => Atomics.wait(a, i, v, t));
+  const now = deps.now ?? (() => performance.now());
+  let seq = 0;
+  function awaitReady(id, deadline, label) {
+    for (; ; ) {
+      const remaining = deadline - now();
+      if (remaining <= 0) throw syncError("ETIMEDOUT", label);
+      wait(header, SAB_I_STATE, SAB_STATE_PENDING, remaining);
+      if (Atomics.load(header, SAB_I_STATE) === SAB_STATE_READY && Atomics.load(header, SAB_I_SEQ) === id) {
+        return;
+      }
+      if (Atomics.load(header, SAB_I_STATE) === SAB_STATE_READY) {
+        Atomics.store(header, SAB_I_STATE, SAB_STATE_PENDING);
+      }
+    }
+  }
+  return {
+    call(req, timeoutMs, label) {
+      const id = ++seq;
+      const deadline = now() + timeoutMs;
+      let out = null;
+      let status2 = 0;
+      let offset = 0;
+      try {
+        for (; ; ) {
+          Atomics.store(header, SAB_I_STATE, SAB_STATE_PENDING);
+          const msg = offset === 0 ? { type: SYNC_SAB_REQ_MSG, id, req } : { type: SYNC_SAB_NEXT_MSG, id, offset };
+          try {
+            port.postMessage(msg);
+          } catch {
+            throw syncError("EIO", label);
+          }
+          awaitReady(id, deadline, label);
+          const total = Atomics.load(header, SAB_I_TOTAL);
+          const chunk = Atomics.load(header, SAB_I_CHUNK);
+          const at = Atomics.load(header, SAB_I_OFFSET);
+          if (at !== offset || chunk < 0 || total < 0 || offset + chunk > total) {
+            throw syncError("EIO", label);
+          }
+          if (out === null) {
+            status2 = Atomics.load(header, SAB_I_STATUS);
+            out = new Uint8Array(total);
+          }
+          out.set(window.subarray(0, chunk), offset);
+          offset += chunk;
+          if (offset >= total) break;
+          if (chunk === 0) throw syncError("EIO", label);
+        }
+      } finally {
+        Atomics.store(header, SAB_I_STATE, SAB_STATE_IDLE);
+      }
+      return decodeSabResult(status2, out);
+    }
+  };
+}
+function errnoError(code, path) {
+  return syncError(code, `sync-sab bridge, '${path}'`);
+}
+function createSyncFsSabBridge(transport, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? SYNC_FS_REQUEST_TIMEOUT_MS;
+  function run(req, path) {
+    const result = transport.call(req, timeoutMs, `sync-sab bridge, '${path}'`);
+    if (!result.ok) throw errnoError(result.errno, path);
+    return result;
+  }
+  function bytes(req, path) {
+    const r = run(req, path);
+    if (r.ok && r.kind === "bytes") return r.bytes;
+    throw errnoError("EIO", path);
+  }
+  function json(req, path) {
+    const r = run(req, path);
+    if (r.ok && r.kind === "json") return r.json;
+    throw errnoError("EIO", path);
+  }
+  return {
+    readFile: (path) => bytes({ op: "read", path }, path),
+    writeFile: (path, data) => {
+      run({ op: "write", path, body: data }, path);
+    },
+    stat: (path) => {
+      const s = parseSyncFsStat(json({ op: "stat", path }, path));
+      if (!s) throw errnoError("EIO", path);
+      return s;
+    },
+    lstat: (path) => {
+      const s = parseSyncFsStat(json({ op: "lstat", path }, path));
+      if (!s) throw errnoError("EIO", path);
+      return s;
+    },
+    readdir: (path) => {
+      const list = json({ op: "readdir", path }, path);
+      if (!Array.isArray(list) || !list.every((s) => typeof s === "string")) {
+        throw errnoError("EIO", path);
+      }
+      return list;
+    },
+    readdirStat: (path) => {
+      const list = json({ op: "readdir-stat", path }, path);
+      if (!Array.isArray(list)) throw errnoError("EIO", path);
+      return list.map((entry) => {
+        if (!Array.isArray(entry) || typeof entry[0] !== "string") throw errnoError("EIO", path);
+        if (entry[1] === null) return [entry[0], null];
+        const stat = parseSyncFsStat(entry[1]);
+        if (!stat) throw errnoError("EIO", path);
+        return [entry[0], stat];
+      });
+    },
+    exists: (path) => {
+      const v = json({ op: "exists", path }, path);
+      if (typeof v !== "boolean") throw errnoError("EIO", path);
+      return v;
+    },
+    mkdir: (path) => {
+      run({ op: "mkdir", path }, path);
+    },
+    rm: (path) => {
+      run({ op: "rm", path }, path);
+    },
+    rename: (from, to) => {
+      run({ op: "rename", path: from, arg2: to }, from);
+    },
+    unlink: (path) => {
+      run({ op: "unlink", path }, path);
+    },
+    rmdir: (path) => {
+      run({ op: "rmdir", path }, path);
+    },
+    symlink: (target, linkPath) => {
+      run({ op: "symlink", path: linkPath, arg2: target }, linkPath);
+    },
+    readlink: (path) => {
+      const target = json({ op: "readlink", path }, path);
+      if (typeof target !== "string") throw errnoError("EIO", path);
+      return target;
+    },
+    chmod: (path, mode) => {
+      run({ op: "chmod", path, mode }, path);
+    },
+    utimes: (path, atimeMs, mtimeMs) => {
+      run({ op: "utimes", path, atimeMs, mtimeMs }, path);
+    }
+  };
+}
+
+// src/process/wasi-errno.ts
+var WASI_ERRNO = {
+  EACCES: 2,
+  EADDRINUSE: 3,
+  EADDRNOTAVAIL: 4,
+  EAFNOSUPPORT: 5,
+  EAGAIN: 6,
+  ECONNREFUSED: 14,
+  EINPROGRESS: 26,
+  EISCONN: 30,
+  ENETUNREACH: 40,
+  ENOTCONN: 53,
+  ENOTSOCK: 57,
+  EPROTONOSUPPORT: 66,
+  EOPNOTSUPP: 138,
+  EBADF: 8,
+  ECHILD: 12,
+  EFAULT: 21,
+  EINTR: 27,
+  EINVAL: 28,
+  EIO: 29,
+  EMFILE: 33,
+  ENOENT: 44,
+  ENOEXEC: 45,
+  ENOSYS: 52,
+  ENOTTY: 59,
+  ENXIO: 60,
+  EPERM: 63,
+  EPIPE: 64,
+  ESPIPE: 70,
+  ESRCH: 71
+};
+var EIO2 = 29;
+function wasiErrno(code) {
+  return WASI_ERRNO[code] ?? EIO2;
+}
+
+// src/process/kernel-streams.ts
+var POLLIN = 1;
+var POLLOUT = 4;
+var POLLERR = 8;
+var POLLHUP = 16;
+var POLLRDNORM = 64;
+var POLLWRNORM = 256;
+var O_NONBLOCK = 2048;
+var PTY_PATH = /^\/dev\/(?:ptmx|pts\/(\d+))$/;
+function isPtyPath(path) {
+  return PTY_PATH.test(path);
+}
+function ptyStat(path) {
+  const n = PTY_PATH.exec(path)?.[1];
+  const now = /* @__PURE__ */ new Date();
+  return {
+    dev: 22,
+    ino: n === void 0 ? 2 : 3 + Number(n),
+    mode: n === void 0 ? 8630 : 8592,
+    nlink: 1,
+    uid: 1e3,
+    gid: 1e3,
+    rdev: n === void 0 ? 5 << 8 | 2 : 136 << 8 | Number(n),
+    size: 0,
+    blksize: 4096,
+    blocks: 0,
+    atime: now,
+    mtime: now,
+    ctime: now
+  };
+}
+var O_CREAT = 64;
+var O_EXCL = 128;
+var O_NOCTTY = 256;
+var O_TRUNC = 512;
+var KILLED_BY_SIGPIPE = 128 + 13;
+var ProcessExit = class extends Error {
+  status;
+  constructor(status2) {
+    super(`exit ${status2}`);
+    this.status = status2;
+  }
+};
+var SyscallError = class extends Error {
+  code;
+  constructor(code) {
+    super(code);
+    this.code = code;
+  }
+};
+function nonblocking(stream) {
+  return (stream.flags & O_NONBLOCK) !== 0 ? { nonblock: true } : void 0;
+}
+var KernelStreams = class {
+  refs = /* @__PURE__ */ new Map();
+  Fs;
+  sys;
+  options;
+  constructor(Fs, sys, options = {}) {
+    this.Fs = Fs;
+    this.sys = sys;
+    this.options = options;
+  }
+  attach(stream, kfd, terminal) {
+    this.refs.set(kfd, (this.refs.get(kfd) ?? 0) + 1);
+    stream.sliccKernelFd = kfd;
+    stream.stream_ops = this.ops(kfd, stream.stream_ops);
+    if (terminal ?? this.sys.isatty?.(kfd) ?? false) stream.tty = this.ttyOps(kfd);
+    else delete stream.tty;
+  }
+  nameTerminal(stream) {
+    const kfd = stream.sliccKernelFd;
+    if (!stream.tty || kfd === void 0) return;
+    const name = this.sys.ttyName?.(kfd);
+    if (name) this.nameStream(stream, name);
+  }
+  nameStream(stream, name) {
+    stream.path = name;
+    if (typeof this.Fs.stat !== "function") return;
+    stream.stream_ops = { ...stream.stream_ops, getattr: () => this.Fs.stat?.(name) ?? {} };
+  }
+  ttyOps(kfd) {
+    return {
+      ops: {
+        ioctl_tcgets: () => this.call(() => this.sys.tcgets?.(kfd)),
+        ioctl_tcsets: (_tty, _op, termios) => this.call(() => {
+          this.sys.tcsets?.(kfd, termios);
+          return 0;
+        }),
+        ioctl_tiocgwinsz: () => this.call(() => this.sys.winsize?.(kfd) ?? [24, 80]),
+        fsync: () => {
+        }
+      }
+    };
+  }
+  attachFile(stream, kfd) {
+    this.attach(stream, kfd, false);
+    stream.sliccKernelFile = true;
+    stream.stream_ops = {
+      ...stream.stream_ops,
+      llseek: (_s, offset, whence) => this.call(() => this.sys.seek(kfd, offset, whence)),
+      fsync: () => this.call(() => {
+        this.sys.flush(kfd);
+        return 0;
+      })
+    };
+  }
+  useControllingTerminal() {
+    if (typeof this.Fs.open !== "function") return;
+    this.usePtyPaths();
+    const open = this.Fs.open.bind(this.Fs);
+    this.Fs.open = (path, flags, mode) => {
+      const pty = this.openPty(open, path, flags, mode);
+      if (pty) return pty;
+      const stream = open(path, flags, mode);
+      if (!stream.tty) return stream;
+      if (stream.path === "/dev/tty" && this.sys.openTty) {
+        let kfd;
+        try {
+          kfd = this.call(() => this.sys.openTty?.());
+        } catch (e) {
+          this.Fs.closeStream(stream.fd);
+          throw e;
+        }
+        this.attach(stream, kfd, true);
+        return stream;
+      }
+      let named;
+      try {
+        named = stream.path ? this.openNamedTerminal(stream.path) : void 0;
+      } catch (e) {
+        this.Fs.closeStream(stream.fd);
+        throw e;
+      }
+      if (named !== void 0) {
+        this.attach(stream, named, true);
+        return stream;
+      }
+      const terminal = this.stdioTerminal();
+      if (terminal !== void 0) this.attach(stream, terminal, true);
+      return stream;
+    };
+  }
+  openPty(open, path, flags, mode) {
+    const pts = /^\/dev\/pts\/(\d+)$/.exec(path);
+    if (path !== "/dev/ptmx" && !pts) return void 0;
+    const { openPty, openPts } = this.sys;
+    if (!openPty || !openPts) return void 0;
+    const kfd = this.call(
+      () => pts ? openPts(Number(pts[1]), (flags & O_NOCTTY) !== 0) : openPty()
+    );
+    let stream;
+    try {
+      stream = open("/dev/null", flags & ~(O_CREAT | O_EXCL | O_TRUNC), mode);
+    } catch (e) {
+      this.sys.close(kfd);
+      throw e;
+    }
+    this.attach(stream, kfd, true);
+    this.nameStream(stream, path);
+    return stream;
+  }
+  usePtyPaths() {
+    const fs = this.Fs;
+    for (const name of ["chown", "lchown", "chmod", "lchmod"]) {
+      const original = fs[name];
+      if (typeof original !== "function") continue;
+      fs[name] = (path, ...rest) => isPtyPath(path) ? this.existingPty(path) : original.call(fs, path, ...rest);
+    }
+    for (const name of ["stat", "lstat"]) {
+      const original = fs[name];
+      if (typeof original !== "function") continue;
+      fs[name] = (path, ...rest) => {
+        if (!isPtyPath(path)) return original.call(fs, path, ...rest);
+        this.existingPty(path);
+        return ptyStat(path);
+      };
+    }
+  }
+  existingPty(path) {
+    const n = PTY_PATH.exec(path)?.[1];
+    const exists = n === void 0 ? this.sys.openPty !== void 0 : this.sys.ptyNumbers?.().includes(Number(n)) ?? false;
+    if (!exists) throw new this.Fs.ErrnoError(wasiErrno("ENOENT"));
+  }
+  openNamedTerminal(path) {
+    const { openTty } = this.sys;
+    if (!openTty) return void 0;
+    try {
+      return openTty.call(this.sys, path);
+    } catch (e) {
+      if (e instanceof SyscallError && e.code === "ENXIO") return void 0;
+      return this.call(() => {
+        throw e;
+      });
+    }
+  }
+  stdioTerminal() {
+    for (const fd of [0, 1, 2]) {
+      const stream = this.Fs.getStream(fd);
+      if (stream?.sliccKernelFd !== void 0 && stream.tty) return stream.sliccKernelFd;
+    }
+    return void 0;
+  }
+  usePipes(pipefs) {
+    const createPipe = pipefs.createPipe.bind(pipefs);
+    pipefs.createPipe = () => {
+      const [read, write] = this.call(() => this.sys.pipe());
+      let fds;
+      try {
+        fds = createPipe();
+      } catch (e) {
+        for (const kfd of [read, write]) {
+          try {
+            this.sys.close(kfd);
+          } catch {
+          }
+        }
+        throw e;
+      }
+      this.attach(this.Fs.getStream(fds.readable_fd), read, false);
+      this.attach(this.Fs.getStream(fds.writable_fd), write, false);
+      return fds;
+    };
+  }
+  restarting(syscall) {
+    for (; ; ) {
+      try {
+        return syscall();
+      } catch (e) {
+        if (!(e instanceof SyscallError && e.code === "EINTR" && this.options.restartable?.())) {
+          throw e;
+        }
+      }
+    }
+  }
+  call(syscall) {
+    try {
+      return syscall();
+    } catch (e) {
+      if (e instanceof SyscallError) throw new this.Fs.ErrnoError(wasiErrno(e.code));
+      throw e;
+    }
+  }
+  ops(kfd, base) {
+    return {
+      ...base,
+      llseek: () => this.call(() => {
+        throw new SyscallError("ESPIPE");
+      }),
+      read: (s, buffer, offset, length) => this.call(() => {
+        const bytes = this.restarting(() => this.sys.read(kfd, length, nonblocking(s)));
+        buffer.set(bytes, offset);
+        return bytes.length;
+      }),
+      write: (s, buffer, offset, length) => {
+        try {
+          const bytes = buffer.slice(offset, offset + length);
+          return this.restarting(() => this.sys.write(kfd, bytes, nonblocking(s)));
+        } catch (e) {
+          if (e instanceof SyscallError && e.code === "EPIPE" && !this.options.sigpipe?.()) {
+            throw new ProcessExit(KILLED_BY_SIGPIPE);
+          }
+          return this.call(() => {
+            throw e;
+          });
+        }
+      },
+      fsync: () => 0,
+      poll: () => {
+        const state = this.call(() => this.sys.poll(kfd));
+        let mask = 0;
+        if (state.readable) mask |= POLLIN | POLLRDNORM;
+        if (state.writable) mask |= POLLOUT | POLLWRNORM;
+        if (state.hangup) mask |= state.readable ? POLLHUP : POLLERR;
+        return mask;
+      },
+      dup: (stream) => {
+        base.dup?.(stream);
+        this.refs.set(kfd, (this.refs.get(kfd) ?? 0) + 1);
+      },
+      close: (stream) => {
+        try {
+          base.close?.(stream);
+        } catch {
+        }
+        const left = (this.refs.get(kfd) ?? 1) - 1;
+        if (left > 0) {
+          this.refs.set(kfd, left);
+          return;
+        }
+        this.refs.delete(kfd);
+        try {
+          this.sys.close(kfd);
+        } catch {
+        }
+      }
+    };
+  }
+};
+
+// src/process/process-children.ts
+var POLLIN2 = 1;
+var POLLOUT2 = 4;
+var POLLERR2 = 8;
+var POLLHUP2 = 16;
+var POLLNVAL = 32;
+var SELECT_SLICE_MS = 20;
+var WUNTRACED = 2;
+var WCONTINUED = 8;
+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 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 createProcessKernel(deps) {
+  const { transport, Fs } = deps;
+  const reaped = /* @__PURE__ */ new Map();
+  const call = (req, label) => transport.call(req, Infinity, label);
+  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);
+    }
+  };
+  return {
+    spawn(file, argv, env, cwd, fds, actions) {
+      deps.beforeSpawn();
+      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 } : {}
+        },
+        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;
+      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;
+    },
+    fork(state) {
+      deps.beforeSpawn();
+      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) {
+      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;
+        }
+      }
+    },
+    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;
+    },
+    pause() {
+      return status(call({ op: "sig-pause" }, "pause"));
+    },
+    kill(pid, sig) {
+      if (pid === deps.pid) {
+        if (sig !== 0) deps.raise?.(sig);
+        return 0;
+      }
+      return status(call({ op: "proc-kill", pid, sig }, `kill ${pid}`));
+    },
+    setpgid: (pid, pgid) => status(call({ op: "proc-setpgid", pid, pgid }, "setpgid")),
+    setsid: () => number(call({ op: "proc-setsid" }, "setsid")),
+    getpgid: (pid) => number(call({ op: "proc-getpgid", pid }, "getpgid")),
+    getsid: (pid) => number(call({ op: "proc-getsid", pid }, "getsid")),
+    tcgetpgrp(fd) {
+      const kfd = Fs.getStream(fd)?.sliccKernelFd;
+      if (kfd === void 0) return -wasiErrno("ENOTTY");
+      return number(call({ 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(call({ 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);
+    }
+  };
+}
+
+// src/process/process-pty.ts
+var TIOCGPTN = 2147767344;
+var TIOCSPTLCK = 1074025521;
+var TIOCSCTTY = 21518;
+var TIOCSWINSZ = 21524;
+var TIOCPKT = 21536;
+function failed(e) {
+  const code = e?.code;
+  if (typeof code === "string") return -wasiErrno(code);
+  throw e;
+}
+function ptyIoctl(ioctl, deps) {
+  return (fd, op, varargs) => {
+    const request = op >>> 0;
+    if (request !== TIOCGPTN && request !== TIOCSPTLCK && request !== TIOCSCTTY && request !== TIOCSWINSZ && request !== TIOCPKT) {
+      return ioctl(fd, op, varargs);
+    }
+    const stream = deps.fs()?.getStream(fd);
+    const kfd = stream?.sliccKernelFd;
+    if (kfd === void 0) return ioctl(fd, op, varargs);
+    const heap = deps.heap();
+    if (!heap) return -wasiErrno("EFAULT");
+    const argp = (heap[varargs >> 2] ?? 0) >>> 0;
+    try {
+      return answer(request, kfd, argp, heap, deps.kernel);
+    } catch (e) {
+      return failed(e);
+    }
+  };
+}
+function answer(request, kfd, argp, heap, kernel) {
+  switch (request) {
+    case TIOCGPTN:
+      heap[argp >> 2] = kernel.ptyNumber(kfd);
+      return 0;
+    case TIOCSPTLCK:
+      kernel.ptyLock(kfd, (heap[argp >> 2] ?? 0) !== 0);
+      return 0;
+    case TIOCSCTTY:
+      kernel.setControllingTerminal(kfd);
+      return 0;
+    case TIOCPKT:
+      kernel.setPacketMode(kfd, (heap[argp >> 2] ?? 0) !== 0);
+      return 0;
+    default: {
+      const word = heap[argp >> 2] ?? 0;
+      kernel.setWinsize(kfd, word & 65535, word >>> 16 & 65535);
+      return 0;
+    }
+  }
+}
+
+// src/process/process-fds.ts
+var O_CLOEXEC = 524288;
+var FD_CLOEXEC = 1;
+var F_DUPFD = 0;
+var F_GETFD = 1;
+var F_SETFD = 2;
+var F_GETFL = 3;
+var F_DUPFD_CLOEXEC = 1030;
+function closesOnExec(stream) {
+  return stream.sliccCloexec === true;
+}
+function setCloseOnExec(stream, on) {
+  if (on) stream.sliccCloexec = true;
+  else delete stream.sliccCloexec;
+}
+var tracked = /* @__PURE__ */ new WeakSet();
+function trackCloseOnExec(Fs) {
+  if (tracked.has(Fs)) return;
+  tracked.add(Fs);
+  if (typeof Fs.dupStream === "function") {
+    const dupStream = Fs.dupStream.bind(Fs);
+    Fs.dupStream = (stream, fd) => {
+      const copy = dupStream(stream, fd);
+      setCloseOnExec(copy, false);
+      return copy;
+    };
+  }
+  if (typeof Fs.open === "function") {
+    const open = Fs.open.bind(Fs);
+    Fs.open = (path, flags, mode) => {
+      const cloexec = typeof flags === "number" && (flags & O_CLOEXEC) !== 0;
+      const stream = open(path, cloexec ? flags & ~O_CLOEXEC : flags, mode);
+      setCloseOnExec(stream, cloexec);
+      return stream;
+    };
+  }
+}
+function marker(deps) {
+  return (fd, on) => {
+    const stream = deps.fs()?.getStream(fd);
+    if (stream) setCloseOnExec(stream, on);
+  };
+}
+function cloexecFcntl(fcntl, deps) {
+  const mark = marker(deps);
+  return (fd, cmd, varargs) => {
+    if (cmd === F_DUPFD_CLOEXEC) {
+      const copy = fcntl(fd, F_DUPFD, varargs);
+      if (copy >= 0) mark(copy, true);
+      return copy;
+    }
+    if (cmd === F_GETFL) {
+      const flags = fcntl(fd, cmd, varargs);
+      return flags < 0 ? flags : flags & ~O_CLOEXEC;
+    }
+    if (cmd !== F_GETFD && cmd !== F_SETFD) return fcntl(fd, cmd, varargs);
+    const stream = deps.fs()?.getStream(fd);
+    if (!stream) return -wasiErrno("EBADF");
+    if (cmd === F_GETFD) return closesOnExec(stream) ? FD_CLOEXEC : 0;
+    const arg = deps.heap()?.[varargs >> 2];
+    if (arg === void 0) return -wasiErrno("EINVAL");
+    setCloseOnExec(stream, (arg & FD_CLOEXEC) !== 0);
+    return 0;
+  };
+}
+function cloexecPipe2(pipe2, deps) {
+  const mark = marker(deps);
+  return (fdPtr, flags) => {
+    const r = pipe2(fdPtr, flags & ~O_CLOEXEC);
+    const heap = deps.heap();
+    if (r === 0 && flags & O_CLOEXEC && heap) {
+      mark(heap[fdPtr >> 2], true);
+      mark(heap[(fdPtr >> 2) + 1], true);
+    }
+    return r;
+  };
+}
+function cloexecByFlag(syscall, flagArg, deps) {
+  const mark = marker(deps);
+  return (...args) => {
+    const cloexec = ((args[flagArg] ?? 0) & O_CLOEXEC) !== 0;
+    if (cloexec) args[flagArg] = args[flagArg] & ~O_CLOEXEC;
+    const fd = syscall(...args);
+    if (fd >= 0) mark(fd, cloexec);
+    return fd;
+  };
+}
+var IMPORT_NAMES = {
+  fcntl: "__syscall_fcntl64",
+  pipe2: "__syscall_pipe2",
+  dup3: "__syscall_dup3",
+  socket: "__syscall_socket",
+  accept4: "__syscall_accept4",
+  ioctl: "__syscall_ioctl",
+  setitimer: "_setitimer_js"
+};
+function wrapperFactories(deps) {
+  const { pty, timer } = deps;
+  return {
+    ...timer ? { setitimer: (f) => kernelTimer(f, timer) } : {},
+    fcntl: (f) => cloexecFcntl(f, deps),
+    pipe2: (f) => cloexecPipe2(f, deps),
+    dup3: (f) => cloexecByFlag(f, 2, deps),
+    socket: (f) => cloexecByFlag(f, 1, deps),
+    accept4: (f) => cloexecByFlag(f, 3, deps),
+    ...pty ? { ioctl: (f) => ptyIoctl(f, { fs: deps.fs, heap: deps.heap, kernel: pty }) } : {}
+  };
+}
+function kernelTimer(setitimer, timer) {
+  return (which, ms) => {
+    if (which !== 0) return setitimer(which, ms);
+    timer.arm(ms ?? 0);
+    return 0;
+  };
+}
+function syscallOf(glue, name, value) {
+  const names = Object.keys(IMPORT_NAMES);
+  const own = names.find((key) => glue[key] !== void 0 && glue[key] === value);
+  if (own) return own;
+  return typeof value === "function" ? names.find((key) => glue[key] !== void 0 && IMPORT_NAMES[key] === name) : void 0;
+}
+function wrapCloexecSyscalls(imports, glue, deps) {
+  if (!glue) return;
+  const factories = wrapperFactories(deps);
+  const seen = /* @__PURE__ */ new Set();
+  for (const namespace of Object.values(imports)) {
+    if (!namespace || typeof namespace !== "object" || seen.has(namespace)) continue;
+    seen.add(namespace);
+    for (const [name, value] of Object.entries(namespace)) {
+      const key = syscallOf(glue, name, value);
+      const wrap = key && factories[key];
+      if (wrap) namespace[name] = wrap(value);
+    }
+  }
+}
+function wasmMemory(instance, imports) {
+  const isMemory = (v) => v instanceof WebAssembly.Memory;
+  const exported = Object.values(instance.exports).find(isMemory);
+  if (exported) return exported;
+  for (const namespace of Object.values(imports)) {
+    const found = Object.values(namespace ?? {}).find(isMemory);
+    if (found) return found;
+  }
+  return void 0;
+}
+function fdOfPath(path, cwd) {
+  const parts = [];
+  for (const part of `${path.startsWith("/") ? "" : cwd}/${path}`.split("/")) {
+    if (part === "" || part === ".") continue;
+    if (part === "..") parts.pop();
+    else parts.push(part);
+  }
+  const abs = `/${parts.join("/")}`;
+  const std = ["/dev/stdin", "/dev/stdout", "/dev/stderr"].indexOf(abs);
+  if (std >= 0) return std;
+  const m = /^\/(?:dev|proc\/self)\/fd\/(\d+)$/.exec(abs);
+  return m ? Number(m[1]) : void 0;
+}
+var DIR_MODE = 16749;
+var LINK_MODE = 41408;
+function syntheticAttr(mode, ino) {
+  const now = /* @__PURE__ */ new Date();
+  return {
+    dev: 1,
+    ino,
+    mode,
+    nlink: 1,
+    uid: 0,
+    gid: 0,
+    rdev: 0,
+    size: 0,
+    atime: now,
+    mtime: now,
+    ctime: now,
+    blksize: 4096,
+    blocks: 0
+  };
+}
+function describeFdDir(Fs) {
+  let dir;
+  try {
+    dir = Fs.lookupPath?.("/proc/self/fd", { follow: true })?.node;
+  } catch {
+    return;
+  }
+  const ops = dir?.node_ops;
+  const lookup = ops?.lookup;
+  if (!dir || !lookup || ops.getattr) return;
+  dir.node_ops = {
+    ...ops,
+    getattr: () => syntheticAttr(DIR_MODE, 1),
+    lookup: (parent, name) => {
+      const entry = lookup(parent, name);
+      entry.node_ops = {
+        ...entry.node_ops,
+        getattr: () => syntheticAttr(LINK_MODE, entry.id ?? 0)
+      };
+      return entry;
+    }
+  };
+}
+function useDevFd(Fs) {
+  if (typeof Fs.open !== "function") return;
+  try {
+    Fs.symlink?.("/proc/self/fd", "/dev/fd");
+  } catch {
+  }
+  describeFdDir(Fs);
+  const fdOf = (path) => typeof path === "string" ? fdOfPath(path, Fs.cwd()) : void 0;
+  const target = (fd) => {
+    const stream = Fs.getStream(fd);
+    if (!stream) throw new Fs.ErrnoError(wasiErrno("EBADF"));
+    return stream;
+  };
+  const open = Fs.open.bind(Fs);
+  Fs.open = (path, flags, mode) => {
+    const fd = fdOf(path);
+    if (fd === void 0) return open(path, flags, mode);
+    const copy = Fs.dupStream(target(fd), -1);
+    setCloseOnExec(copy, typeof flags === "number" && (flags & O_CLOEXEC) !== 0);
+    return copy;
+  };
+  const { stat, fstat } = Fs;
+  if (typeof stat !== "function" || typeof fstat !== "function") return;
+  Fs.stat = (path, dontFollow) => {
+    const fd = dontFollow ? void 0 : fdOf(path);
+    if (fd === void 0) return stat.call(Fs, path, dontFollow);
+    target(fd);
+    return fstat.call(Fs, fd);
+  };
+}
+
+// src/process/process-fork.ts
+var O_RDWR = 2;
+var O_ACCMODE = 3;
+var O_CREAT2 = 64;
+var O_EXCL2 = 128;
+var O_TRUNC2 = 512;
+var PLACEHOLDER_DIR = "/dev/slicc-fd";
+function isVfsFile(Fs, stream) {
+  const node = stream.node;
+  return node.live !== void 0 && Fs.isFile(node.mode);
+}
+function orphanContents(stream) {
+  const live = stream.node.live;
+  if (!live?.orphan) return void 0;
+  return live.data?.slice(0, live.len ?? live.data.length) ?? new Uint8Array(0);
+}
+function vfsPromoter(Fs, sys, streams, livePath) {
+  const promoted = /* @__PURE__ */ new Map();
+  return (stream) => {
+    if (stream.sliccKernelFd !== void 0 || !isVfsFile(Fs, stream)) return;
+    let kfd = promoted.get(stream.shared);
+    if (kfd === void 0) {
+      const contents = orphanContents(stream);
+      kfd = sys.openVfs(
+        livePath(stream),
+        stream.flags,
+        stream.position,
+        contents !== void 0 ? { contents, orphan: true } : void 0
+      );
+      promoted.set(stream.shared, kfd);
+    }
+    streams.attachFile(stream, kfd);
+  };
+}
+function describeForFork(Fs, sys, streams, livePath) {
+  const promote = vfsPromoter(Fs, sys, streams, livePath);
+  const out = [];
+  for (const stream of Fs.streams) {
+    if (!stream) continue;
+    promote(stream);
+    if (stream.sliccKernelFd !== void 0) {
+      out.push(kernelEntry(stream, stream.sliccKernelFd));
+    } else if (stream.path) {
+      const flags = stream.flags | (closesOnExec(stream) ? O_CLOEXEC : 0);
+      out.push({ fd: stream.fd, path: stream.path, flags });
+    }
+  }
+  return out;
+}
+function kernelEntry(stream, kernel) {
+  const cloexec = closesOnExec(stream) ? { cloexec: true } : {};
+  const kind = stream.sliccKernelFile ? "file" : stream.tty ? "tty" : "stream";
+  return { fd: stream.fd, kernel, kind, ...cloexec };
+}
+var ACCESS = { 0: "read", 1: "write" };
+var DEVICES = {
+  "/dev/null": "null",
+  "/dev/zero": "zero",
+  "/dev/urandom": "urandom",
+  "/dev/random": "urandom"
+};
+function describeInherited(Fs, sys, streams, livePath, actions = []) {
+  const table = /* @__PURE__ */ new Map();
+  for (const stream of Fs.streams) {
+    if (stream) table.set(stream.fd, { stream, cloexec: closesOnExec(stream) });
+  }
+  for (const [target, source] of actions) {
+    if (target <= 2) continue;
+    const from = source >= 0 ? table.get(source) : void 0;
+    if (from) table.set(target, { stream: from.stream, cloexec: false });
+    else table.delete(target);
+  }
+  const slots = /* @__PURE__ */ new Map();
+  for (const [fd, { stream, cloexec }] of table) {
+    if (fd > 2 && !cloexec) slots.set(fd, stream);
+  }
+  const promote = vfsPromoter(Fs, sys, streams, livePath);
+  const out = [];
+  for (const [fd, stream] of slots) {
+    promote(stream);
+    const slot = inheritedSlot(fd, stream);
+    if (slot) out.push(slot);
+  }
+  return out;
+}
+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_ACCMODE];
+    return { fd, device, ...access ? { access } : {} };
+  }
+  return { fd, kernel: stream.sliccKernelFd };
+}
+function place(Fs, stream, fd) {
+  if (stream.fd === fd) return stream;
+  const moved = Fs.dupStream(stream, fd);
+  Fs.closeStream(stream.fd);
+  return moved;
+}
+function placeholder(Fs, entry) {
+  if (entry.kind === "tty") return Fs.open("/dev/tty", O_RDWR);
+  if (entry.kind === "stream") return Fs.open("/dev/null", O_RDWR);
+  Fs.mkdirTree(PLACEHOLDER_DIR);
+  return Fs.open(`${PLACEHOLDER_DIR}/${entry.fd}`, O_RDWR | O_CREAT2);
+}
+var FIFO_MODE = 4480;
+var nextStreamIno = 1073741824;
+var streamInos = /* @__PURE__ */ new WeakMap();
+function asFifo(stream, streams, identity) {
+  const inos = streamInos.get(streams) ?? /* @__PURE__ */ new Map();
+  streamInos.set(streams, inos);
+  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 })
+  };
+}
+function placeKernelStream(Fs, streams, entry) {
+  const stream = place(Fs, placeholder(Fs, entry), entry.fd);
+  if (entry.kind === "file") streams.attachFile(stream, entry.kernel);
+  else streams.attach(stream, entry.kernel, entry.kind === "tty");
+  if (entry.kind === "tty") streams.nameTerminal(stream);
+  if (entry.kind === "stream") {
+    asFifo(stream, streams, entry.desc !== void 0 ? `d${entry.desc}` : `k${entry.kernel}`);
+  }
+  setCloseOnExec(stream, entry.cloexec === true);
+  return stream;
+}
+function restoreForkedStreams(Fs, streams, table) {
+  for (const stream of Fs.streams) if (stream) Fs.closeStream(stream.fd);
+  for (const entry of table) {
+    try {
+      if ("kernel" in entry) {
+        placeKernelStream(Fs, streams, entry);
+      } else {
+        const placed = place(
+          Fs,
+          Fs.open(entry.path, entry.flags & ~(O_CREAT2 | O_EXCL2 | O_TRUNC2)),
+          entry.fd
+        );
+        setCloseOnExec(placed, (entry.flags & O_CLOEXEC) !== 0);
+      }
+    } catch {
+    }
+  }
+}
+
+// src/process/process-signals.ts
+var SignalGate = class {
+  reported = { caught: 0, ignored: 0 };
+  restart = 0;
+  lastDelivered = 0;
+  depth = 0;
+  reporting = false;
+  raw;
+  header;
+  hooks;
+  constructor(raw, header, hooks) {
+    this.raw = raw;
+    this.header = header;
+    this.hooks = hooks;
+  }
+  transport() {
+    return {
+      call: (req, timeoutMs, label) => {
+        this.report();
+        this.depth++;
+        try {
+          const result = this.raw.call(req, timeoutMs, label);
+          this.deliver();
+          return result;
+        } finally {
+          this.depth--;
+        }
+      }
+    };
+  }
+  restartable() {
+    return this.lastDelivered !== 0 && (this.lastDelivered & ~this.restart) === 0;
+  }
+  report() {
+    if (this.reporting) return;
+    this.reporting = true;
+    let masks;
+    try {
+      masks = this.hooks.masks();
+    } catch {
+      masks = null;
+    } finally {
+      this.reporting = false;
+    }
+    if (!masks) return;
+    this.restart = masks.restart;
+    const { caught, ignored } = masks;
+    if (caught === this.reported.caught && ignored === this.reported.ignored) return;
+    this.reported = { caught, ignored };
+    this.raw.call({ op: "sig-mask", caught, ignored }, Number.POSITIVE_INFINITY, "sig-mask");
+  }
+  deliver() {
+    const timers = Atomics.exchange(this.header, SAB_I_TIMERS, 0);
+    const pending = Atomics.exchange(this.header, SAB_I_SIGNALS, 0);
+    if (this.depth <= 1) this.lastDelivered = pending | (timers & 1 ? sigbit(SIG.ALRM) : 0);
+    for (let which = 0; which < 3; which++) {
+      if (timers & 1 << which) this.hooks.timer?.(which);
+    }
+    for (const sig of signalsIn(pending)) this.hooks.raise(sig);
+  }
+};
+
+// src/process/realm-user.ts
+var REALM_UID = 1e3;
+var REALM_GID = 1e3;
+function ownByRealmUser(Fs) {
+  const { stat, fstat } = Fs;
+  const owned = (attr) => ({ ...attr, uid: REALM_UID, gid: REALM_GID });
+  if (typeof stat === "function") {
+    Fs.stat = (path, dontFollow) => owned(stat.call(Fs, path, dontFollow));
+  }
+  if (typeof fstat === "function") Fs.fstat = (fd) => owned(fstat.call(Fs, fd));
+}
+
+// src/process/process-runtime.ts
+function kernelSys(transport) {
+  const call = (req, label) => {
+    const r = transport.call(req, Number.POSITIVE_INFINITY, label);
+    if (!r.ok) throw new SyscallError(r.errno);
+    return r;
+  };
+  const json = (r) => r.ok && r.kind === "json" ? r.json : void 0;
+  return {
+    read(fd, max, opts) {
+      const flags = {
+        ...opts?.nonblock ? { nonblock: true } : {},
+        ...opts?.peek ? { peek: true } : {}
+      };
+      const r = call({ op: "fd-read", fd, max, ...flags }, `fd-read ${fd}`);
+      return r.ok && r.kind === "bytes" ? r.bytes : new Uint8Array(0);
+    },
+    write(fd, bytes, opts) {
+      const req = {
+        op: "fd-write",
+        fd,
+        body: bytes,
+        ...opts?.nonblock ? { nonblock: true } : {}
+      };
+      const n = json(call(req, `fd-write ${fd}`));
+      return typeof n === "number" ? n : bytes.length;
+    },
+    close(fd) {
+      call({ op: "fd-close", fd }, `fd-close ${fd}`);
+    },
+    pipe() {
+      return json(call({ op: "fd-pipe" }, "fd-pipe"));
+    },
+    poll(fd) {
+      return json(call({ op: "fd-poll", fd }, `fd-poll ${fd}`));
+    },
+    openVfs(path, flags, position, opts) {
+      return json(
+        call(
+          {
+            op: "fd-open-vfs",
+            path,
+            flags,
+            position,
+            ...opts?.contents !== void 0 ? { contents: opts.contents } : {},
+            ...opts?.orphan ? { orphan: true } : {},
+            ...opts?.truncate ? { truncate: true } : {},
+            ...opts?.create ? { create: true } : {}
+          },
+          `fd-open-vfs ${path}`
+        )
+      );
+    },
+    seek(fd, offset, whence) {
+      return json(call({ op: "fd-seek", fd, offset, whence }, `fd-seek ${fd}`));
+    },
+    flush(fd) {
+      call({ op: "fd-flush", fd }, `fd-flush ${fd}`);
+    },
+    pread(fd, max, at) {
+      const r = call({ op: "fd-pread", fd, max, offset: at }, `fd-pread ${fd}`);
+      return r.ok && r.kind === "bytes" ? r.bytes : new Uint8Array(0);
+    },
+    isatty(fd) {
+      return json(call({ op: "fd-info", fd }, `fd-info ${fd}`))?.tty === true;
+    },
+    ttyName(fd) {
+      return json(call({ op: "fd-info", fd }, `fd-info ${fd}`))?.name;
+    },
+    openTty(name) {
+      const req = name === void 0 ? { op: "fd-open-tty" } : { op: "fd-open-tty", name };
+      return json(call(req, `fd-open-tty ${name ?? ""}`));
+    },
+    tcgets(fd) {
+      return json(call({ op: "tty-get", fd }, `tty-get ${fd}`));
+    },
+    tcsets(fd, termios) {
+      call({ op: "tty-set", fd, termios }, `tty-set ${fd}`);
+    },
+    winsize(fd) {
+      return json(call({ op: "tty-winsz", fd }, `tty-winsz ${fd}`));
+    },
+    openPty() {
+      return json(call({ op: "pty-open" }, "pty-open"));
+    },
+    openPts(n, noctty) {
+      return json(call({ op: "pty-slave-open", n, noctty }, `pty-slave-open ${n}`));
+    },
+    ptyNumbers() {
+      return json(call({ op: "pty-list" }, "pty-list"));
+    },
+    ptyNumber(fd) {
+      return json(call({ op: "pty-number", fd }, `pty-number ${fd}`));
+    },
+    ptyLock(fd, lock) {
+      call({ op: "pty-lock", fd, lock }, `pty-lock ${fd}`);
+    },
+    setControllingTerminal(fd) {
+      call({ op: "pty-ctty", fd }, `pty-ctty ${fd}`);
+    },
+    setPacketMode(fd, on) {
+      call({ op: "pty-packet", fd, on }, `pty-packet ${fd}`);
+    },
+    setWinsize(fd, rows, cols) {
+      call({ op: "pty-winsz-set", fd, rows, cols }, `pty-winsz-set ${fd}`);
+    }
+  };
+}
+function wireKernelFd(Fs, streams, entry) {
+  if (entry.device && openDevice(Fs, entry.fd, entry.device)) return;
+  placeKernelStream(Fs, streams, {
+    ...entry,
+    kind: entry.device ? "stream" : entry.kind,
+    kernel: entry.fd
+  });
+}
+var O_RDONLY = 0;
+var O_WRONLY = 1;
+var O_RDWR2 = 2;
+function openDevice(Fs, fd, meta) {
+  const flags = meta.access === "read" ? O_RDONLY : meta.access === "write" ? O_WRONLY : O_RDWR2;
+  let stream;
+  try {
+    stream = Fs.open(`/dev/${meta.device}`, flags);
+  } catch {
+    return false;
+  }
+  if (stream.fd !== fd) {
+    Fs.dupStream(stream, fd);
+    Fs.closeStream(stream.fd);
+  }
+  return true;
+}
+function wireKernelStdio(Fs, streams) {
+  for (const fd of [0, 1, 2]) {
+    const stream = Fs.getStream(fd);
+    if (!stream) continue;
+    streams.attach(stream, fd);
+    streams.nameTerminal(stream);
+  }
+}
+function glueBody(glue) {
+  return glue.startsWith("#!") ? glue.slice(glue.indexOf("\n") + 1) : glue;
+}
+var GLUE_TRAILER = [
+  "if (typeof ENV !== 'undefined') Object.assign(ENV, Module.sliccEnv);",
+  "const __sliccTake = (name, value) => {",
+  "  const own = Object.getOwnPropertyDescriptor(Module, name);",
+  "  if (own && 'value' in own && own.value != null) return;",
+  "  Object.defineProperty(Module, name, { value, writable: true, configurable: true, enumerable: true });",
+  "};",
+  "if (typeof FS !== 'undefined') __sliccTake('FS', FS);",
+  "if (typeof callMain === 'function') __sliccTake('callMain', callMain);",
+  "if (typeof sliccRunMain === 'function') __sliccTake('sliccRunMain', sliccRunMain);",
+  "if (typeof sliccForkChild === 'function') __sliccTake('sliccForkChild', sliccForkChild);",
+  "if (typeof PIPEFS !== 'undefined') __sliccTake('PIPEFS', PIPEFS);",
+  "Module.sliccSyscalls ??= {",
+  "  fcntl: typeof ___syscall_fcntl64 === 'function' ? ___syscall_fcntl64 : undefined,",
+  "  pipe2: typeof ___syscall_pipe2 === 'function' ? ___syscall_pipe2 : undefined,",
+  "  dup3: typeof ___syscall_dup3 === 'function' ? ___syscall_dup3 : undefined,",
+  "  socket: typeof ___syscall_socket === 'function' ? ___syscall_socket : undefined,",
+  "  accept4: typeof ___syscall_accept4 === 'function' ? ___syscall_accept4 : undefined,",
+  "  ioctl: typeof ___syscall_ioctl === 'function' ? ___syscall_ioctl : undefined,",
+  "  setitimer: typeof __setitimer_js === 'function' ? __setitimer_js : undefined,",
+  "};",
+  "const __sliccUp = () =>",
+  "  (typeof runtimeInitialized === 'undefined' || runtimeInitialized) &&",
+  "  !(typeof runtimeExited !== 'undefined' && runtimeExited) &&",
+  "  !(typeof ABORT !== 'undefined' && ABORT);",
+  "Module.sliccSigpipe ??= () => (__sliccUp() && typeof _slicc_sigpipe === 'function' ? _slicc_sigpipe() : -1);",
+  "Module.sliccSigMask ??= (w) => (__sliccUp() && typeof _slicc_sig_mask === 'function' ? _slicc_sig_mask(w) : -1);",
+  "Module.sliccRaise ??= (sig) => { if (__sliccUp() && typeof _slicc_raise === 'function') _slicc_raise(sig); };",
+  "Module.sliccTimerFire ??= (which) => {",
+  "  if (!__sliccUp() || typeof __emscripten_timeout !== 'function') return false;",
+  "  __emscripten_timeout(which, typeof _emscripten_get_now === 'function' ? _emscripten_get_now() : performance.now());",
+  "  return true;",
+  "};",
+  "if (typeof SliccFork !== 'undefined' && !SliccFork.balancesKeepalive && typeof runtimeKeepalivePop === 'function') {",
+  "  let __sliccForking = SliccFork.forking === true;",
+  "  Object.defineProperty(SliccFork, 'forking', {",
+  "    get: () => __sliccForking,",
+  "    set: (on) => { if (__sliccForking && !on) runtimeKeepalivePop(); __sliccForking = on; },",
+  "    configurable: true,",
+  "  });",
+  "}"
+].join("\n");
+function ownValue(module, name) {
+  const own = Object.getOwnPropertyDescriptor(module, name);
+  return own && "value" in own ? own.value : void 0;
+}
+var evaluateGlue = (glue, module) => {
+  let run;
+  try {
+    run = new Function("Module", `${glueBody(glue)}
+;${GLUE_TRAILER}`);
+  } catch (e) {
+    throw e instanceof EvalError ? new Error(EVAL_BLOCKED) : e;
+  }
+  run(module);
+};
+var EVAL_BLOCKED = "the wasm realm evaluates the program's Emscripten glue, and this page's CSP forbids eval (no 'unsafe-eval')";
+function signalMasks(m) {
+  const mask = m.sliccSigMask;
+  const caught = mask?.(0) ?? -1;
+  if (!mask || caught === -1) return null;
+  return { caught, ignored: mask(1), restart: mask(2) };
+}
+async function runWasmProcess(init, port, deps = {}) {
+  const signals = new SignalGate(
+    createSyncSabTransport(init.sab, port),
+    new Int32Array(init.sab, 0, SAB_HEADER_I32),
+    {
+      masks: () => signalMasks(module),
+      raise: (sig) => module.sliccRaise?.(sig),
+      timer: (which) => {
+        const running2 = module;
+        if (!running2.sliccTimerFire?.(which)) running2.sliccRaise?.(SIG.ALRM);
+      }
+    }
+  );
+  const transport = signals.transport();
+  const sys = kernelSys(transport);
+  const encoder2 = new TextEncoder();
+  const say = (fd) => (text) => sys.write(fd, encoder2.encode(`${text}
+`));
+  let ready;
+  let failed2;
+  let memory;
+  const initialized = new Promise((resolve, reject) => {
+    ready = resolve;
+    failed2 = reject;
+  });
+  const module = {
+    noInitialRun: true,
+    thisProgram: init.argv0,
+    sliccPid: init.pid,
+    ...init.ppid !== void 0 ? { sliccPpid: init.ppid } : {},
+    sliccEnv: init.env,
+    print: say(1),
+    printErr: say(2),
+    instantiateWasm(imports, done) {
+      Promise.resolve().then(() => {
+        wrapCloexecSyscalls(imports, ownValue(module, "sliccSyscalls"), {
+          fs: () => ownValue(module, "FS"),
+          heap: () => memory ? new Int32Array(memory.buffer) : void 0,
+          pty: sys,
+          timer: {
+            arm: (ms) => {
+              transport.call(
+                { op: "proc-alarm", sig: SIG.ALRM, ms, repeat: false, timer: 0 },
+                Number.POSITIVE_INFINITY,
+                "alarm"
+              );
+            }
+          }
+        });
+        return WebAssembly.instantiate(init.program.module, imports);
+      }).then((instance) => {
+        memory = wasmMemory(instance, imports);
+        done(instance, init.program.module);
+      }, failed2);
+      return {};
+    },
+    preRun: [
+      (m) => {
+        if (!hasStreams(m)) return;
+        const fs = m.FS;
+        trackCloseOnExec(fs);
+        try {
+          fs.mkdirTree(init.cwd);
+          fs.chdir(init.cwd);
+        } catch {
+        }
+      }
+    ],
+    onRuntimeInitialized: () => ready()
+  };
+  (deps.evaluate ?? evaluateGlue)(init.program.glue, module);
+  await initialized;
+  const running = module;
+  if (!hasStreams(running)) return runStdioOnly(running, init);
+  const vfs = mountVfsIntoEmscripten(running.FS, {
+    bridge: createSyncFsSabBridge(transport),
+    cwd: init.cwd,
+    warn: deps.warn ?? say(2)
+  });
+  const sigpipe = () => running.sliccSigpipe?.() === 1;
+  const restartable = () => signals.restartable();
+  const streams = new KernelStreams(running.FS, sys, { sigpipe, restartable });
+  trackCloseOnExec(running.FS);
+  if (init.fork) restoreForkedStreams(running.FS, streams, init.fork.streams ?? []);
+  else {
+    wireKernelStdio(running.FS, streams);
+    for (const entry of init.fds ?? []) wireKernelFd(running.FS, streams, entry);
+  }
+  const pipefs = ownValue(running, "PIPEFS");
+  if (pipefs) streams.usePipes(pipefs);
+  streams.useControllingTerminal();
+  useDevFd(running.FS);
+  ownByRealmUser(running.FS);
+  const livePath = (s) => liveNodePath(s.node);
+  running.sliccKernel = createProcessKernel({
+    transport,
+    Fs: running.FS,
+    env: init.env,
+    beforeSpawn: () => vfs.flush(),
+    afterChild: () => vfs.invalidate(),
+    pid: init.pid,
+    raise: (sig) => running.sliccRaise?.(sig),
+    restartable,
+    describeFork: () => describeForFork(running.FS, sys, streams, livePath),
+    inherit: (actions) => describeInherited(running.FS, sys, streams, livePath, actions),
+    stdioPromoter: () => vfsPromoter(running.FS, sys, streams, livePath)
+  });
+  try {
+    return runMain(running, init);
+  } finally {
+    vfs.flush();
+  }
+}
+function hasStreams(module) {
+  return typeof ownValue(module, "FS")?.getStream === "function";
+}
+function runStdioOnly(running, init) {
+  if (init.fork) throw new Error(`${init.argv0} cannot resume a fork: it has no filesystem`);
+  return runMain(running, init);
+}
+function runMain(running, init) {
+  try {
+    if (init.fork) {
+      if (!running.sliccForkChild) throw new Error(`${init.argv0} cannot resume a fork`);
+      return running.sliccForkChild({ ...init.fork, pid: init.pid }) ?? 0;
+    }
+    return (running.sliccRunMain ?? running.callMain)(init.args) ?? 0;
+  } catch (e) {
+    const status2 = e?.status;
+    if (typeof status2 !== "number") throw e;
+    return status2;
+  }
+}
+
+// src/process/process-entry.ts
+function processEntry(port, run = runWasmProcess) {
+  return (data) => {
+    if (data?.type !== WASM_PROCESS_INIT) return;
+    run(data, port).then(
+      (code) => port.postMessage({ type: WASM_PROCESS_EXIT, code }),
+      (err) => port.postMessage({
+        type: WASM_PROCESS_ERROR,
+        message: err instanceof Error ? err.stack ?? err.message : String(err)
+      })
+    );
+  };
+}
+
+// src/process-worker.ts
+var scope = globalThis;
+var onMessage = processEntry({ postMessage: (message) => scope.postMessage(message) });
+scope.addEventListener("message", (event) => onMessage(event.data));
+//# sourceMappingURL=process-worker.js.map