@ai-ecoverse/slicc-kernel 0.0.0 → 1.0.0

package/dist/kernel-worker.js

@@ -0,0 +1,2978 @@
+// src/fs/types.ts
+function fsError(code, path) {
+  return Object.assign(new Error(`${code}: ${path}`), { code });
+}
+function normalizePath(path) {
+  const parts = [];
+  for (const part of path.split("/")) {
+    if (part === "" || part === ".") continue;
+    if (part === "..") parts.pop();
+    else parts.push(part);
+  }
+  return `/${parts.join("/")}`;
+}
+function resolvePath(base, path) {
+  return normalizePath(path.startsWith("/") ? path : `${base}/${path}`);
+}
+
+// src/fs/opfs.ts
+var S_IFDIR = 16384;
+var S_IFREG = 32768;
+var PERM_MASK = 4095;
+var EXECUTABLE = /\/node_modules\/(?:@[^/]+\/)?[^/]+\/bin\//;
+var ERRNO_BY_DOM_ERROR = {
+  NotFoundError: "ENOENT",
+  TypeMismatchError: "ENOTDIR",
+  InvalidModificationError: "ENOTEMPTY",
+  NoModificationAllowedError: "EBUSY",
+  TypeError: "EINVAL"
+};
+function translate(err, path) {
+  if (typeof err?.code === "string") return err;
+  const name = err?.name;
+  return fsError(typeof name === "string" && ERRNO_BY_DOM_ERROR[name] || "EIO", path);
+}
+function split(path) {
+  return path.split("/").filter(Boolean);
+}
+function within(path, root) {
+  return path === root || path.startsWith(`${root}/`);
+}
+var OpfsFs = class {
+  modes = /* @__PURE__ */ new Map();
+  times = /* @__PURE__ */ new Map();
+  root;
+  constructor(root) {
+    this.root = root;
+  }
+  resolvePath(base, path) {
+    return resolvePath(base, path);
+  }
+  async dir(path, create = false) {
+    let dir = this.root;
+    try {
+      for (const part of split(path)) dir = await dir.getDirectoryHandle(part, { create });
+    } catch (err) {
+      throw translate(err, path);
+    }
+    return dir;
+  }
+  async parent(path) {
+    const parts = split(path);
+    const name = parts.pop();
+    if (name === void 0) throw fsError("EBUSY", path);
+    return [await this.dir(`/${parts.join("/")}`), name];
+  }
+  async handle(path) {
+    if (split(path).length === 0) return this.root;
+    const [dir, name] = await this.parent(path);
+    try {
+      return await dir.getFileHandle(name);
+    } catch (err) {
+      if (err?.name !== "TypeMismatchError") throw translate(err, path);
+    }
+    return dir.getDirectoryHandle(name);
+  }
+  mode(path, directory) {
+    const fallback = directory || EXECUTABLE.test(path) ? 493 : 420;
+    return (directory ? S_IFDIR : S_IFREG) | (this.modes.get(path) ?? fallback);
+  }
+  async stat(path) {
+    const handle = await this.handle(path);
+    const directory = handle.kind === "directory";
+    const file = directory ? void 0 : await handle.getFile();
+    return {
+      isFile: !directory,
+      isDirectory: directory,
+      isSymbolicLink: false,
+      size: file?.size ?? 0,
+      mode: this.mode(path, directory),
+      mtime: new Date(this.times.get(path) ?? file?.lastModified ?? 0)
+    };
+  }
+  lstat(path) {
+    return this.stat(path);
+  }
+  async exists(path) {
+    return this.handle(path).then(
+      () => true,
+      () => false
+    );
+  }
+  async readFileBuffer(path) {
+    const handle = await this.handle(path);
+    if (handle.kind === "directory") throw fsError("EISDIR", path);
+    return new Uint8Array(await (await handle.getFile()).arrayBuffer());
+  }
+  async readFile(path) {
+    return new TextDecoder().decode(await this.readFileBuffer(path));
+  }
+  async writeFile(path, content) {
+    const [dir, name] = await this.parent(path);
+    let file;
+    try {
+      file = await dir.getFileHandle(name, { create: true });
+    } catch (err) {
+      const code = err?.name === "TypeMismatchError" ? "EISDIR" : null;
+      throw code ? fsError(code, path) : translate(err, path);
+    }
+    const writable = await file.createWritable();
+    await writable.write(content);
+    await writable.close();
+    this.times.delete(path);
+  }
+  async readdir(path) {
+    const handle = await this.handle(path);
+    if (handle.kind !== "directory") throw fsError("ENOTDIR", path);
+    const names = [];
+    for await (const name of handle.keys()) names.push(name);
+    return names.sort();
+  }
+  async mkdir(path, options = {}) {
+    if (options.recursive) {
+      await this.dir(path, true);
+      return;
+    }
+    if (await this.exists(path)) throw fsError("EEXIST", path);
+    const [dir, name] = await this.parent(path);
+    await dir.getDirectoryHandle(name, { create: true });
+  }
+  async rm(path, options = {}) {
+    try {
+      const [dir, name] = await this.parent(path);
+      await dir.removeEntry(name, { recursive: options.recursive === true });
+    } catch (err) {
+      const error = translate(err, path);
+      if (options.force && error.code === "ENOENT") return;
+      throw error;
+    }
+    this.forget(path);
+  }
+  forget(path) {
+    for (const map of [this.modes, this.times]) {
+      for (const key of [...map.keys()]) if (within(key, path)) map.delete(key);
+    }
+  }
+  carry(from, to) {
+    for (const map of [this.modes, this.times]) {
+      for (const [key, value] of [...map]) {
+        if (!within(key, from)) continue;
+        map.delete(key);
+        map.set(to + key.slice(from.length), value);
+      }
+    }
+  }
+  async rename(from, to) {
+    if (from === to) return;
+    const source = await this.stat(from);
+    if (source.isDirectory && within(to, from)) throw fsError("EINVAL", to);
+    const target = await this.stat(to).catch(() => null);
+    if (target?.isDirectory && !source.isDirectory) throw fsError("EISDIR", to);
+    if (target && !target.isDirectory && source.isDirectory) throw fsError("ENOTDIR", to);
+    if (target?.isDirectory && (await this.readdir(to)).length > 0) {
+      throw fsError("ENOTEMPTY", to);
+    }
+    const [dir, name] = await this.parent(to);
+    const handle = await this.handle(from);
+    const swap = target?.isDirectory === true;
+    const staging = swap ? `.${name}.${crypto.randomUUID()}` : name;
+    const moved = await this.place(handle, dir, staging);
+    if (swap) await this.rm(to, { recursive: true });
+    this.carry(from, to);
+    if (!moved) await this.rm(from, { recursive: true });
+    if (!swap) return;
+    const staged = await dir.getDirectoryHandle(staging);
+    if (!await this.place(staged, dir, name)) await dir.removeEntry(staging, { recursive: true });
+  }
+  async place(handle, dir, name) {
+    const moved = await handle.move?.(dir, name).then(
+      () => true,
+      () => false
+    );
+    if (moved) return true;
+    try {
+      await this.copy(handle, dir, name);
+    } catch (err) {
+      if (handle.kind === "directory") await dir.removeEntry(name, { recursive: true });
+      throw translate(err, name);
+    }
+    return false;
+  }
+  async copy(handle, dir, name) {
+    if (handle.kind === "file") {
+      const writable = await (await dir.getFileHandle(name, { create: true })).createWritable();
+      await writable.write(await handle.getFile());
+      await writable.close();
+      return;
+    }
+    const target = await dir.getDirectoryHandle(name, { create: true });
+    for await (const child of handle.values()) await this.copy(child, target, child.name);
+  }
+  async symlink(_target, path) {
+    throw fsError("ENOSYS", path);
+  }
+  async readlink(path) {
+    await this.handle(path);
+    throw fsError("EINVAL", path);
+  }
+  async chmod(path, mode) {
+    await this.handle(path);
+    this.modes.set(path, mode & PERM_MASK);
+  }
+  async utimes(path, _atime, mtime) {
+    await this.handle(path);
+    this.times.set(path, mtime.getTime());
+  }
+};
+
+// src/commands.ts
+var NAME = /^[A-Za-z0-9._+-]+$/;
+var ENV_KEY = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var PACKAGE = /\$\{package\}/g;
+function inside(pkg, rel) {
+  if (typeof rel !== "string" || rel === "") return void 0;
+  const clean = rel.replace(/^\.\//, "");
+  if (clean.startsWith("/") || clean.split("/").includes("..")) return void 0;
+  return `${pkg}/${clean}`;
+}
+function envOf(pkg, raw) {
+  const env = {};
+  if (!raw || typeof raw !== "object") return env;
+  for (const [key, value] of Object.entries(raw)) {
+    if (ENV_KEY.test(key) && typeof value === "string") env[key] = value.replace(PACKAGE, pkg);
+  }
+  return env;
+}
+function argsOf(pkg, raw) {
+  if (!Array.isArray(raw) || raw.length === 0) return void 0;
+  if (!raw.every((arg) => typeof arg === "string")) return void 0;
+  return raw.map((arg) => arg.replace(PACKAGE, pkg));
+}
+function commandsOf(pkg, manifest) {
+  const slicc = manifest.slicc;
+  if (!slicc || typeof slicc !== "object" || (slicc.abi ?? "emscripten") !== "emscripten")
+    return [];
+  const entries = slicc.commands;
+  if (!entries || typeof entries !== "object") return [];
+  const shared = envOf(pkg, slicc.env);
+  const out = [];
+  for (const [name, raw] of Object.entries(entries)) {
+    if (!NAME.test(name) || name === "." || name === ".." || !raw || typeof raw !== "object") {
+      continue;
+    }
+    const glue = inside(pkg, raw.glue);
+    const wasm = inside(pkg, raw.wasm);
+    if ((raw.abi ?? "emscripten") !== "emscripten" || !glue || !wasm) continue;
+    const argv0 = typeof raw.argv0 === "string" && raw.argv0 ? raw.argv0 : name;
+    const args = argsOf(pkg, raw.args);
+    const env = { ...shared, ...envOf(pkg, raw.env) };
+    out.push({
+      name,
+      glue,
+      wasm,
+      argv0,
+      ...args ? { args } : {},
+      ...Object.keys(env).length > 0 ? { env } : {}
+    });
+  }
+  return out;
+}
+async function packages(fs, modules) {
+  const names = await fs.readdir(modules).catch(() => []);
+  const dirs = [];
+  for (const name of names) {
+    if (name.startsWith(".")) continue;
+    if (!name.startsWith("@")) {
+      dirs.push(`${modules}/${name}`);
+      continue;
+    }
+    for (const inner of await fs.readdir(`${modules}/${name}`).catch(() => [])) {
+      dirs.push(`${modules}/${name}/${inner}`);
+    }
+  }
+  return dirs;
+}
+async function scanCommands(fs, modules) {
+  const found = /* @__PURE__ */ new Map();
+  for (const pkg of await packages(fs, modules)) {
+    let manifest;
+    try {
+      manifest = JSON.parse(await fs.readFile(`${pkg}/package.json`));
+    } catch {
+      continue;
+    }
+    for (const command of commandsOf(pkg, manifest)) {
+      if (!found.has(command.name)) found.set(command.name, command);
+    }
+  }
+  if (!found.has("sh") && found.has("bash")) {
+    found.set("sh", { ...found.get("bash"), name: "sh", argv0: "sh" });
+  }
+  return found;
+}
+
+// src/fs/commands.ts
+var S_IFDIR2 = 16384;
+var S_IFREG2 = 32768;
+var COMMAND = /^\/(?:usr\/)?bin\/([^/]+)$/;
+function missing(err) {
+  return err?.code === "ENOENT";
+}
+function synthetic(directory) {
+  return {
+    isFile: !directory,
+    isDirectory: directory,
+    isSymbolicLink: false,
+    size: 0,
+    mode: (directory ? S_IFDIR2 : S_IFREG2) | 493,
+    mtime: /* @__PURE__ */ new Date(0)
+  };
+}
+function withCommandDirs(fs, names) {
+  async function children(path) {
+    if (path === "/") return ["bin", "usr"];
+    if (path === "/usr") return ["bin"];
+    if (path === "/bin" || path === "/usr/bin") return [...await names()];
+    return void 0;
+  }
+  async function virtual(path) {
+    if (path === "/usr" || path === "/bin" || path === "/usr/bin") return synthetic(true);
+    const name = COMMAND.exec(path)?.[1];
+    return name !== void 0 && (await names()).has(name) ? synthetic(false) : void 0;
+  }
+  async function stat(path, real) {
+    try {
+      return await real(path);
+    } catch (err) {
+      const found = missing(err) ? await virtual(path) : void 0;
+      if (found) return found;
+      throw err;
+    }
+  }
+  return {
+    resolvePath: (base, path) => fs.resolvePath(base, path),
+    readFile: (path) => fs.readFile(path),
+    async readFileBuffer(path) {
+      try {
+        return await fs.readFileBuffer(path);
+      } catch (err) {
+        if (missing(err) && (await virtual(path))?.isFile) return new Uint8Array(0);
+        throw err;
+      }
+    },
+    writeFile: (path, content) => fs.writeFile(path, content),
+    async exists(path) {
+      return await fs.exists(path) || await virtual(path) !== void 0;
+    },
+    stat: (path) => stat(path, (p) => fs.stat(p)),
+    lstat: (path) => stat(path, (p) => fs.lstat(p)),
+    async readdir(path) {
+      const extra = await children(path);
+      if (!extra) return fs.readdir(path);
+      const real = await fs.readdir(path).catch((err) => {
+        if (missing(err)) return [];
+        throw err;
+      });
+      return [.../* @__PURE__ */ new Set([...real, ...extra])].sort();
+    },
+    mkdir: (path, options) => fs.mkdir(path, options),
+    rm: (path, options) => fs.rm(path, options),
+    rename: (from, to) => fs.rename(from, to),
+    symlink: (target, path) => fs.symlink(target, path),
+    readlink: (path) => fs.readlink(path),
+    chmod: (path, mode) => fs.chmod(path, mode),
+    utimes: (path, atime, mtime) => fs.utimes(path, atime, mtime)
+  };
+}
+
+// src/kernel/pipe.ts
+var PIPE_CAPACITY = 64 * 1024;
+var PipeError = class extends Error {
+  code;
+  constructor(code) {
+    super(code);
+    this.code = code;
+  }
+};
+var KernelPipe = class {
+  chunks = [];
+  size = 0;
+  readers = 0;
+  writers = 0;
+  waiters = [];
+  capacity;
+  constructor(capacity = PIPE_CAPACITY) {
+    this.capacity = capacity;
+  }
+  get buffered() {
+    return this.size;
+  }
+  get readReady() {
+    return this.size > 0 || this.writers === 0;
+  }
+  get writeReady() {
+    return this.size < this.capacity || this.readers === 0;
+  }
+  get writersGone() {
+    return this.writers === 0;
+  }
+  get readersGone() {
+    return this.readers === 0;
+  }
+  openRead() {
+    this.readers += 1;
+  }
+  openWrite() {
+    this.writers += 1;
+  }
+  closeRead() {
+    if (this.readers > 0) this.readers -= 1;
+    if (this.readers === 0) {
+      this.chunks = [];
+      this.size = 0;
+    }
+    this.wake();
+  }
+  closeWrite() {
+    if (this.writers > 0) this.writers -= 1;
+    this.wake();
+  }
+  async read(max, signal) {
+    while (this.size === 0) {
+      if (this.writers === 0) return new Uint8Array(0);
+      await this.changed(signal);
+    }
+    const out = this.take(Math.min(max, this.size));
+    this.wake();
+    return out;
+  }
+  async peek(max, signal) {
+    while (this.size === 0) {
+      if (this.writers === 0) return new Uint8Array(0);
+      await this.changed(signal);
+    }
+    const out = new Uint8Array(Math.min(max, this.size));
+    let filled = 0;
+    for (const chunk of this.chunks) {
+      if (filled === out.length) break;
+      const count = Math.min(chunk.length, out.length - filled);
+      out.set(chunk.subarray(0, count), filled);
+      filled += count;
+    }
+    return out;
+  }
+  async write(bytes, signal) {
+    let offset = 0;
+    while (offset < bytes.length) {
+      if (this.readers === 0) throw new PipeError("EPIPE");
+      const room = this.capacity - this.size;
+      if (room === 0) {
+        try {
+          await this.changed(signal);
+        } catch (e) {
+          if (offset > 0) return offset;
+          throw e;
+        }
+        continue;
+      }
+      const n = Math.min(room, bytes.length - offset);
+      this.chunks.push(bytes.slice(offset, offset + n));
+      this.size += n;
+      offset += n;
+      this.wake();
+    }
+    return bytes.length;
+  }
+  take(n) {
+    const out = new Uint8Array(n);
+    let filled = 0;
+    while (filled < n) {
+      const head = this.chunks[0];
+      const count = Math.min(head.length, n - filled);
+      out.set(head.subarray(0, count), filled);
+      filled += count;
+      if (count === head.length) this.chunks.shift();
+      else this.chunks[0] = head.subarray(count);
+    }
+    this.size -= n;
+    return out;
+  }
+  changed(signal) {
+    if (signal?.aborted) return Promise.reject(new PipeError("EINTR"));
+    return new Promise((resolve, reject) => {
+      const onAbort = () => {
+        this.waiters = this.waiters.filter((w) => w !== waiter);
+        reject(new PipeError("EINTR"));
+      };
+      const waiter = () => {
+        signal?.removeEventListener("abort", onAbort);
+        resolve();
+      };
+      this.waiters.push(waiter);
+      signal?.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  wake() {
+    const waiters = this.waiters;
+    this.waiters = [];
+    for (const resolve of waiters) resolve();
+  }
+};
+
+// src/kernel/fd-table.ts
+var KernelError = class extends Error {
+  code;
+  constructor(code) {
+    super(code);
+    this.code = code;
+  }
+};
+function pollFile(file) {
+  return file.poll?.() ?? { readable: !!file.read, writable: !!file.write, hangup: false };
+}
+var OpenFile = class {
+  refs = 1;
+  file;
+  constructor(file) {
+    this.file = file;
+  }
+  retain() {
+    this.refs += 1;
+    return this;
+  }
+  release() {
+    this.refs -= 1;
+    if (this.refs === 0) return this.file.close();
+  }
+};
+function openPipe(capacity) {
+  const pipe = new KernelPipe(capacity);
+  pipe.openRead();
+  pipe.openWrite();
+  return {
+    read: new OpenFile({
+      read: async (max, signal) => {
+        try {
+          return await pipe.read(max, signal);
+        } catch (e) {
+          throw new KernelError(e.code);
+        }
+      },
+      close: () => pipe.closeRead(),
+      poll: () => ({ readable: pipe.readReady, writable: false, hangup: pipe.writersGone }),
+      changed: (signal) => pipe.changed(signal)
+    }),
+    write: new OpenFile({
+      write: async (bytes, signal) => {
+        try {
+          return await pipe.write(bytes, signal);
+        } catch (e) {
+          throw new KernelError(e.code);
+        }
+      },
+      close: () => pipe.closeWrite(),
+      poll: () => ({ readable: false, writable: pipe.writeReady, hangup: pipe.readersGone }),
+      changed: (signal) => pipe.changed(signal)
+    })
+  };
+}
+function bytesSource(data) {
+  let offset = 0;
+  return new OpenFile({
+    read: async (max) => {
+      const out = data.subarray(offset, offset + max);
+      offset += out.length;
+      return out;
+    },
+    close: () => {
+    }
+  });
+}
+function sinkFile(onData) {
+  return new OpenFile({
+    write: async (bytes) => {
+      onData(bytes.slice());
+      return bytes.length;
+    },
+    close: () => {
+    }
+  });
+}
+function nullFile() {
+  return new OpenFile({
+    read: async () => new Uint8Array(0),
+    write: async (bytes) => bytes.length,
+    close: () => {
+    }
+  });
+}
+function deviceFile(device, access) {
+  const read = async (max) => {
+    if (device === "null") return new Uint8Array(0);
+    const out = new Uint8Array(max);
+    if (device === "urandom") {
+      for (let at = 0; at < max; at += 65536) {
+        crypto.getRandomValues(out.subarray(at, Math.min(max, at + 65536)));
+      }
+    }
+    return out;
+  };
+  return new OpenFile({
+    ...access !== "write" ? { read } : {},
+    ...access !== "read" ? { write: async (bytes) => bytes.length } : {},
+    seek: async () => 0,
+    heldMeta: { device, ...access ? { access } : {} },
+    close: () => {
+    }
+  });
+}
+function heldFile(meta) {
+  return new OpenFile({ held: true, ...meta ? { heldMeta: meta } : {}, close: () => {
+  } });
+}
+function kernelFdKind(file) {
+  if (file.held) return "held";
+  if (file.heldMeta && "device" in file.heldMeta) return "device";
+  if (file.tty) return "tty";
+  return file.seek ? "file" : "stream";
+}
+var FdTable = class _FdTable {
+  static MAX_FDS = 1024;
+  fds = /* @__PURE__ */ new Map();
+  cloexec = /* @__PURE__ */ new Set();
+  status = /* @__PURE__ */ new Map();
+  get(fd) {
+    const file = this.fds.get(fd);
+    if (!file) throw new KernelError("EBADF");
+    return file;
+  }
+  stdioTerminal() {
+    for (const fd of [0, 1, 2]) {
+      const tty = this.fds.get(fd)?.file.tty;
+      if (tty) return tty;
+    }
+    return void 0;
+  }
+  numbers() {
+    return [...this.fds.keys()].sort((a, b) => a - b);
+  }
+  has(fd) {
+    return this.fds.has(fd);
+  }
+  setCloseOnExec(fd) {
+    this.get(fd);
+    this.cloexec.add(fd);
+  }
+  clearCloseOnExec(fd) {
+    this.get(fd);
+    this.cloexec.delete(fd);
+  }
+  closesOnExec(fd) {
+    return this.cloexec.has(fd);
+  }
+  setStatusFlags(fd, flags) {
+    this.get(fd);
+    this.status.set(fd, flags);
+  }
+  statusFlags(fd) {
+    return this.status.get(fd);
+  }
+  install(file, min = 0) {
+    for (let fd = min; fd < _FdTable.MAX_FDS; fd++) {
+      if (!this.fds.has(fd)) {
+        this.fds.set(fd, file);
+        return fd;
+      }
+    }
+    void Promise.resolve(file.release()).catch(() => void 0);
+    throw new KernelError("EMFILE");
+  }
+  installAt(fd, file) {
+    if (fd < 0 || fd >= _FdTable.MAX_FDS) {
+      void Promise.resolve(file.release()).catch(() => void 0);
+      throw new KernelError("EBADF");
+    }
+    const previous = this.fds.get(fd);
+    this.fds.set(fd, file);
+    this.cloexec.delete(fd);
+    this.status.delete(fd);
+    void Promise.resolve(previous?.release()).catch(() => void 0);
+  }
+  dup(fd, min = 0) {
+    return this.install(this.get(fd).retain(), min);
+  }
+  dup2(oldFd, newFd) {
+    const file = this.get(oldFd);
+    if (oldFd !== newFd) this.installAt(newFd, file.retain());
+    return newFd;
+  }
+  close(fd) {
+    const file = this.get(fd);
+    this.fds.delete(fd);
+    this.cloexec.delete(fd);
+    this.status.delete(fd);
+    return file.release();
+  }
+  fork() {
+    const child = new _FdTable();
+    for (const [fd, file] of this.fds) child.fds.set(fd, file.retain());
+    for (const fd of this.cloexec) child.cloexec.add(fd);
+    for (const [fd, flags] of this.status) child.status.set(fd, flags);
+    return child;
+  }
+  async closeAll() {
+    const files = [...this.fds.values()];
+    this.fds.clear();
+    this.cloexec.clear();
+    this.status.clear();
+    await Promise.allSettled(files.map((file) => Promise.resolve().then(() => file.release())));
+  }
+};
+
+// src/kernel/children.ts
+var SpawnError = class extends Error {
+  code;
+  constructor(code) {
+    super(code);
+    this.code = code;
+  }
+};
+function interrupted(signal) {
+  const { promise, reject } = Promise.withResolvers();
+  const fail = () => reject(new KernelError("EINTR"));
+  if (signal?.aborted) fail();
+  else signal?.addEventListener("abort", fail, { once: true });
+  return { promise, done: () => signal?.removeEventListener("abort", fail) };
+}
+function stoppedStatus(sig) {
+  return (sig & 255) << 8 | 127;
+}
+var CONTINUED_STATUS = 65535;
+function waitStatus(code, termsig) {
+  return termsig ? termsig & 127 : (code & 255) << 8;
+}
+function concat(chunks) {
+  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;
+}
+var ChildTable = class {
+  children = /* @__PURE__ */ new Map();
+  leftovers = /* @__PURE__ */ new Map();
+  onChildState;
+  onReap;
+  stateChanged = [];
+  watchers = /* @__PURE__ */ new Map();
+  parentFds;
+  spawner;
+  forker;
+  constructor(parentFds, spawner, forker) {
+    this.parentFds = parentFds;
+    this.spawner = spawner;
+    this.forker = forker;
+  }
+  async fork(state) {
+    if (!this.forker) throw new SpawnError("ENOSYS");
+    return this.track(state, this.parentFds.fork(), /* @__PURE__ */ new Map(), this.forker);
+  }
+  async spawn(req, stdio, inherit = []) {
+    if (!this.spawner) throw new SpawnError("ENOSYS");
+    const fds = new FdTable();
+    const captured = /* @__PURE__ */ new Map();
+    try {
+      for (const [n, slot] of stdio.entries()) fds.installAt(n, this.openSlot(slot, n, captured));
+      for (const slot of inherit) {
+        if (slot.fd <= 2) continue;
+        if ("device" in slot) {
+          fds.installAt(slot.fd, deviceFile(slot.device, slot.access));
+          continue;
+        }
+        fds.installAt(slot.fd, this.parentFds.get(slot.kernel).retain());
+        if (slot.flags !== void 0) fds.setStatusFlags(slot.fd, slot.flags);
+      }
+    } catch (e) {
+      await fds.closeAll();
+      throw e;
+    }
+    return this.track(req, fds, captured, this.spawner);
+  }
+  async track(req, fds, captured, start) {
+    let handle;
+    try {
+      handle = await start(req, fds);
+    } catch (e) {
+      await fds.closeAll();
+      throw e;
+    }
+    const child = { exited: handle.exited, termsig: handle.termsig, captured };
+    void handle.exited.then((code) => {
+      child.code = code;
+      this.watchers.delete(handle.pid);
+      this.onChildState?.();
+    });
+    handle.onState?.((state, sig) => {
+      child.stopReport = state === "stopped" ? sig : void 0;
+      child.continueReport = state === "continued";
+      this.watchers.get(handle.pid)?.(state, sig);
+      const waiters = this.stateChanged;
+      this.stateChanged = [];
+      for (const wake of waiters) wake();
+      this.onChildState?.();
+    });
+    this.children.set(handle.pid, child);
+    return handle.pid;
+  }
+  watch(pid, listener) {
+    if (this.children.has(pid)) this.watchers.set(pid, listener);
+  }
+  openSlot(slot, n, captured) {
+    if ("fd" in slot) return this.parentFds.get(slot.fd).retain();
+    if ("input" in slot) return bytesSource(slot.input);
+    if ("capture" in slot) {
+      const chunks = [];
+      captured.set(n, chunks);
+      return sinkFile((bytes) => chunks.push(bytes));
+    }
+    return nullFile();
+  }
+  async wait(pid, nohang, signal, flags = {}) {
+    let interrupt;
+    try {
+      for (; ; ) {
+        const candidates = this.candidates(pid, flags);
+        if (candidates.length === 0) throw new KernelError("ECHILD");
+        const done3 = candidates.find(([, child]) => child.code !== void 0);
+        if (done3) return this.reap(done3[0], done3[1].code);
+        const changed = this.stateReport(candidates, flags);
+        if (changed) return changed;
+        if (nohang) return [0, 0];
+        interrupt ??= interrupted(signal);
+        await this.nextChange(candidates, flags, interrupt.promise);
+      }
+    } finally {
+      interrupt?.done();
+    }
+  }
+  candidates(pid, flags) {
+    const all = [...this.children];
+    if (pid > 0) return all.filter(([p]) => p === pid);
+    const inGroup = flags.inGroup;
+    return pid === -1 || !inGroup ? all : all.filter(([p]) => inGroup(p));
+  }
+  async nextChange(candidates, flags, interrupt) {
+    let wake;
+    const stateChange = new Promise((resolve) => wake = resolve);
+    const watching = flags.untraced || flags.continued;
+    if (watching && wake) this.stateChanged.push(wake);
+    try {
+      await Promise.race([
+        ...candidates.map(([, child]) => child.exited),
+        ...watching ? [stateChange] : [],
+        interrupt
+      ]);
+    } finally {
+      this.stateChanged = this.stateChanged.filter((w) => w !== wake);
+    }
+  }
+  stateReport(candidates, flags) {
+    for (const [p, child] of candidates) {
+      if (flags.untraced && child.stopReport !== void 0) {
+        const sig = child.stopReport;
+        child.stopReport = void 0;
+        return [p, stoppedStatus(sig)];
+      }
+      if (flags.continued && child.continueReport) {
+        child.continueReport = false;
+        return [p, CONTINUED_STATUS];
+      }
+    }
+    return null;
+  }
+  reap(pid, code) {
+    const child = this.children.get(pid);
+    this.children.delete(pid);
+    this.onReap?.(pid);
+    if (child && child.captured.size > 0) this.leftovers.set(pid, child.captured);
+    return [pid, waitStatus(code, child?.termsig?.())];
+  }
+  pids() {
+    return [...this.children.keys()];
+  }
+  captured(pid, slot) {
+    const slots = this.leftovers.get(pid);
+    const chunks = slots?.get(slot);
+    if (!slots || !chunks) return new Uint8Array(0);
+    slots.delete(slot);
+    if (slots.size === 0) this.leftovers.delete(pid);
+    return concat(chunks);
+  }
+};
+
+// src/realm/sync-fs-token-registry.ts
+var registry = /* @__PURE__ */ new Map();
+function mintSyncFsToken(entry) {
+  const token = crypto.randomUUID();
+  registry.set(token, entry);
+  return token;
+}
+function resolveSyncFsToken(token) {
+  return registry.get(token) ?? null;
+}
+function revokeSyncFsToken(token) {
+  registry.delete(token);
+}
+
+// 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 });
+}
+
+// src/realm/sync-fs-dispatch.ts
+function toErrno(err) {
+  const message = err instanceof Error ? err.message : String(err);
+  const code = err?.code;
+  if (typeof code === "string" && /^E[A-Z]+$/.test(code)) {
+    return { ok: false, errno: code, message };
+  }
+  return { ok: false, errno: "EIO", message };
+}
+function statJson(s) {
+  return {
+    isDirectory: s.isDirectory,
+    isFile: s.isFile,
+    isSymbolicLink: s.isSymbolicLink,
+    size: s.size,
+    mode: s.mode,
+    mtimeMs: s.mtime.getTime()
+  };
+}
+async function readdirStat(fs, dir) {
+  const names = await fs.readdir(dir);
+  const base = dir === "/" ? "" : dir;
+  return Promise.all(
+    names.map(async (name) => {
+      try {
+        return [name, statJson(await fs.lstat(`${base}/${name}`))];
+      } catch {
+        return [name, null];
+      }
+    })
+  );
+}
+var done = { ok: true, kind: "void" };
+function json(value) {
+  return { ok: true, kind: "json", json: value };
+}
+async function run(fs, path, req, cwd) {
+  switch (req.op) {
+    case "read":
+      return { ok: true, kind: "bytes", bytes: await fs.readFileBuffer(path) };
+    case "write":
+      await fs.writeFile(path, req.body ?? new Uint8Array(0));
+      return done;
+    case "exists":
+      return json(await fs.exists(path));
+    case "stat":
+      return json(statJson(await fs.stat(path)));
+    case "lstat":
+      return json(statJson(await fs.lstat(path)));
+    case "readdir":
+      return json(await fs.readdir(path));
+    case "readdir-stat":
+      return json(await readdirStat(fs, path));
+    case "mkdir":
+      await fs.mkdir(path, { recursive: true });
+      return done;
+    case "rm":
+      await fs.rm(path, { recursive: true });
+      return done;
+    case "rename":
+      await fs.rename(path, fs.resolvePath(cwd, req.arg2 ?? ""));
+      return done;
+    case "unlink":
+      if ((await fs.lstat(path)).isDirectory) throw syncError("EISDIR", path);
+      await fs.rm(path);
+      return done;
+    case "rmdir":
+      if (!(await fs.lstat(path)).isDirectory) throw syncError("ENOTDIR", path);
+      if ((await fs.readdir(path)).length > 0) throw syncError("ENOTEMPTY", path);
+      await fs.rm(path, { recursive: true });
+      return done;
+    case "symlink":
+      await fs.symlink(req.arg2 ?? "", path);
+      return done;
+    case "readlink":
+      return json(await fs.readlink(path));
+    case "chmod":
+      await fs.chmod(path, req.mode ?? 0);
+      return done;
+    case "utimes":
+      await fs.utimes(path, new Date(req.atimeMs ?? 0), new Date(req.mtimeMs ?? 0));
+      return done;
+    default:
+      return { ok: false, errno: "EINVAL", message: `sync-fs: unknown op '${req.op}'` };
+  }
+}
+async function dispatchSyncFs(req) {
+  const entry = resolveSyncFsToken(req.token);
+  if (!entry) return { ok: false, errno: "EACCES", message: "sync-fs: unknown or revoked token" };
+  const { fs, cwd } = entry;
+  try {
+    return await run(fs, fs.resolvePath(cwd, req.path), req, cwd);
+  } catch (err) {
+    return toErrno(err);
+  }
+}
+
+// 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_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 encodeSabResult(result) {
+  if (!result.ok) {
+    return {
+      status: SAB_STATUS_ERRNO,
+      payload: encoder.encode(JSON.stringify({ errno: result.errno, message: result.message }))
+    };
+  }
+  switch (result.kind) {
+    case "bytes":
+      return { status: SAB_STATUS_BYTES, payload: result.bytes };
+    case "json":
+      return { status: SAB_STATUS_JSON, payload: encoder.encode(JSON.stringify(result.json)) };
+    default:
+      return { status: SAB_STATUS_VOID, payload: new Uint8Array(0) };
+  }
+}
+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-responder.ts
+var PENDING_TTL_MS = SYNC_FS_REQUEST_TIMEOUT_MS + 5e3;
+function attachSyncSabResponder(port, sab, token, opts) {
+  const views = sabViews(sab);
+  const { header, window } = views;
+  const pending = /* @__PURE__ */ new Map();
+  let disposed = false;
+  const { dispatch } = opts;
+  function drop(id) {
+    const entry = pending.get(id);
+    if (!entry) return;
+    clearTimeout(entry.timer);
+    pending.delete(id);
+  }
+  function publish(id, entry, offset) {
+    const chunk = Math.min(window.byteLength, entry.payload.byteLength - offset);
+    if (chunk > 0) window.set(entry.payload.subarray(offset, offset + chunk));
+    Atomics.store(header, SAB_I_STATUS, entry.status);
+    Atomics.store(header, SAB_I_TOTAL, entry.payload.byteLength);
+    Atomics.store(header, SAB_I_CHUNK, chunk);
+    Atomics.store(header, SAB_I_OFFSET, offset);
+    Atomics.store(header, SAB_I_SEQ, id);
+    Atomics.store(header, SAB_I_STATE, SAB_STATE_READY);
+    Atomics.notify(header, SAB_I_STATE);
+    if (offset + chunk >= entry.payload.byteLength) drop(id);
+  }
+  function settle(id, result) {
+    if (disposed) return;
+    const { status, payload } = encodeSabResult(result);
+    drop(id);
+    const entry = {
+      status,
+      payload,
+      timer: setTimeout(() => drop(id), PENDING_TTL_MS)
+    };
+    pending.set(id, entry);
+    publish(id, entry, 0);
+  }
+  const handler = (event) => {
+    const data = event.data;
+    if (!data || typeof data.id !== "number") return;
+    if (data.type === SYNC_SAB_NEXT_MSG) {
+      const entry = pending.get(data.id);
+      const offset = data.offset;
+      if (!entry || typeof offset !== "number" || !Number.isInteger(offset) || offset < 0 || offset > entry.payload.byteLength) {
+        settle(data.id, { ok: false, errno: "EIO", message: "sync-sab: bad continuation" });
+        return;
+      }
+      publish(data.id, entry, offset);
+      return;
+    }
+    if (data.type !== SYNC_SAB_REQ_MSG || !data.req || typeof data.req !== "object") return;
+    const id = data.id;
+    const body = data.req;
+    const req = { ...body, token };
+    let dispatched;
+    try {
+      dispatched = dispatch(req);
+    } catch (err) {
+      settle(id, {
+        ok: false,
+        errno: "EIO",
+        message: err instanceof Error ? err.message : String(err)
+      });
+      return;
+    }
+    void dispatched.then(
+      (result) => settle(id, result),
+      (err) => settle(id, {
+        ok: false,
+        errno: "EIO",
+        message: err instanceof Error ? err.message : String(err)
+      })
+    );
+  };
+  port.addEventListener("message", handler);
+  return {
+    dispose: () => {
+      if (disposed) return;
+      disposed = true;
+      port.removeEventListener("message", handler);
+      for (const id of [...pending.keys()]) drop(id);
+    }
+  };
+}
+
+// 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 defaultAction(sig) {
+  if (sig === SIG.CONT) return "continue";
+  if (STOPPING.has(sig)) return "stop";
+  return IGNORED_BY_DEFAULT.has(sig) ? "ignore" : "terminate";
+}
+function isSignal(sig) {
+  return Number.isInteger(sig) && sig >= 1 && sig <= 31;
+}
+function sigbit(sig) {
+  return 1 << sig;
+}
+var SIGNAL_BY_NAME = {
+  SIGINT: SIG.INT,
+  SIGTERM: SIG.TERM,
+  SIGKILL: SIG.KILL,
+  SIGSTOP: SIG.STOP,
+  SIGCONT: SIG.CONT
+};
+
+// src/kernel/tty.ts
+var ICRNL = 256;
+var IUTF8 = 16384;
+var OPOST = 1;
+var ONLCR = 4;
+var ISIG = 1;
+var ICANON = 2;
+var ECHO = 8;
+var ECHOE = 16;
+var ECHOCTL = 512;
+var NOFLSH = 128;
+var IEXTEN = 32768;
+var VINTR = 0;
+var VQUIT = 1;
+var VERASE = 2;
+var VKILL = 3;
+var VEOF = 4;
+var VSUSP = 10;
+var VWERASE = 14;
+function defaultTermios() {
+  const cCc = new Array(32).fill(0);
+  Object.assign(cCc, { [VINTR]: 3, [VQUIT]: 28, [VERASE]: 127, [VKILL]: 21 });
+  Object.assign(cCc, { [VEOF]: 4, 6: 1, 8: 17, 9: 19, [VSUSP]: 26 });
+  Object.assign(cCc, { 12: 18, 13: 15, [VWERASE]: 23, 15: 22 });
+  return {
+    c_iflag: ICRNL | 1024 | 8192 | IUTF8,
+    c_oflag: OPOST | ONLCR,
+    c_cflag: 15 | 48 | 128,
+    c_lflag: ISIG | ICANON | ECHO | ECHOE | 32 | ECHOCTL | 2048 | IEXTEN,
+    c_cc: cCc
+  };
+}
+var encoder2 = new TextEncoder();
+function isContinuation(byte) {
+  return (byte & 192) === 128;
+}
+var KernelTty = class {
+  termios = defaultTermios();
+  cols = 80;
+  rows = 24;
+  readable = [];
+  line = [];
+  waiters = [];
+  hungUp = false;
+  name;
+  screen;
+  signal;
+  constructor(screen, signal) {
+    this.screen = screen;
+    this.signal = signal;
+  }
+  receive(bytes) {
+    for (const byte of bytes) this.key(byte);
+    this.wake();
+  }
+  resize(cols, rows) {
+    this.setSize(cols, rows);
+    this.signal(SIG.WINCH);
+  }
+  hangup() {
+    this.hungUp = true;
+    this.wake();
+  }
+  signalHangup() {
+    this.signal(SIG.HUP);
+  }
+  setSize(cols, rows) {
+    this.cols = cols;
+    this.rows = rows;
+  }
+  tcgets() {
+    return { ...this.termios, c_cc: [...this.termios.c_cc] };
+  }
+  tcsets(termios) {
+    const wasCanonical = this.canonical;
+    this.termios = { ...termios, c_cc: [...termios.c_cc] };
+    if (wasCanonical && !this.canonical && this.line.length > 0) {
+      this.readable.push(Uint8Array.from(this.line));
+      this.line = [];
+      this.wake();
+    }
+  }
+  winsize() {
+    return [this.rows, this.cols];
+  }
+  file() {
+    return new OpenFile({
+      read: (max, signal) => this.read(max, signal),
+      write: async (bytes) => {
+        if (this.hungUp) throw new KernelError("EIO");
+        this.output(bytes);
+        return bytes.length;
+      },
+      poll: () => ({
+        readable: this.readable.length > 0 || this.hungUp,
+        writable: true,
+        hangup: this.hungUp
+      }),
+      changed: (signal) => this.changed(signal),
+      close: () => {
+      },
+      tty: this
+    });
+  }
+  get canonical() {
+    return (this.termios.c_lflag & ICANON) !== 0;
+  }
+  cc(slot) {
+    return this.termios.c_cc[slot] ?? 0;
+  }
+  key(input) {
+    const { c_iflag, c_lflag } = this.termios;
+    const byte = input === 13 && c_iflag & ICRNL ? 10 : input;
+    if (c_lflag & ISIG && this.signalKey(byte)) return;
+    if (!this.canonical) {
+      this.readable.push(Uint8Array.of(byte));
+      if (c_lflag & ECHO) this.echo(byte);
+      return;
+    }
+    this.edit(byte);
+  }
+  signalKey(byte) {
+    const sig = byte === this.cc(VINTR) ? SIG.INT : byte === this.cc(VQUIT) ? SIG.QUIT : byte === this.cc(VSUSP) ? SIG.TSTP : 0;
+    if (!sig || byte === 0) return false;
+    if (this.termios.c_lflag & ECHO) this.echo(byte);
+    if (!(this.termios.c_lflag & NOFLSH)) {
+      this.line = [];
+      this.readable = [];
+    }
+    this.signal(sig);
+    return true;
+  }
+  edit(byte) {
+    const echo = (this.termios.c_lflag & ECHO) !== 0;
+    if (byte === this.cc(VERASE) || byte === 8) {
+      this.rubOut(this.lastCharLength());
+    } else if (byte === this.cc(VKILL)) {
+      this.rubOut(this.line.length);
+    } else if (byte === this.cc(VWERASE)) {
+      this.rubOut(this.lastWordLength());
+    } else if (byte === this.cc(VEOF)) {
+      this.readable.push(this.line.length > 0 ? Uint8Array.from(this.line) : null);
+      this.line = [];
+    } else if (byte === 10) {
+      this.line.push(byte);
+      if (echo) this.output(encoder2.encode("\n"));
+      this.readable.push(Uint8Array.from(this.line));
+      this.line = [];
+    } else {
+      this.line.push(byte);
+      if (echo) this.echo(byte);
+    }
+  }
+  lastWordLength() {
+    let end = this.line.length;
+    while (end > 0 && this.line[end - 1] === 32) end--;
+    while (end > 0 && this.line[end - 1] !== 32) end--;
+    return this.line.length - end;
+  }
+  lastCharLength() {
+    const { line } = this;
+    let n = Math.min(1, line.length);
+    if (this.termios.c_iflag & IUTF8) {
+      while (n < line.length && isContinuation(line[line.length - n] ?? 0)) n++;
+    }
+    return n;
+  }
+  rubOut(n) {
+    const dropped = this.line.splice(this.line.length - n, n);
+    const utf8 = (this.termios.c_iflag & IUTF8) !== 0;
+    const cells = utf8 ? dropped.filter((b) => !isContinuation(b)).length : dropped.length;
+    if (cells > 0 && this.termios.c_lflag & ECHO) {
+      this.output(encoder2.encode("\b \b".repeat(cells)), false);
+    }
+  }
+  echo(byte) {
+    if (byte < 32 && byte !== 10 && byte !== 9 && this.termios.c_lflag & ECHOCTL) {
+      this.output(Uint8Array.of(94, byte + 64), false);
+      return;
+    }
+    this.output(Uint8Array.of(byte));
+  }
+  output(bytes, translate2 = true) {
+    const { c_oflag } = this.termios;
+    if (!translate2 || !(c_oflag & OPOST && c_oflag & ONLCR) || !bytes.includes(10)) {
+      this.screen.write(bytes);
+      return;
+    }
+    const out = [];
+    for (const byte of bytes) {
+      if (byte === 10) out.push(13);
+      out.push(byte);
+    }
+    this.screen.write(Uint8Array.from(out));
+  }
+  async read(max, signal) {
+    while (this.readable.length === 0) {
+      if (this.hungUp) return new Uint8Array(0);
+      await this.changed(signal);
+    }
+    const head = this.readable[0];
+    if (head === null) {
+      this.readable.shift();
+      return new Uint8Array(0);
+    }
+    if (head === void 0) return new Uint8Array(0);
+    const chunks = [];
+    let n = 0;
+    while (this.readable.length > 0 && n < max) {
+      const next = this.readable[0];
+      if (next === null || next === void 0) break;
+      const take = next.subarray(0, max - n);
+      chunks.push(take);
+      n += take.length;
+      if (take.length < next.length) this.readable[0] = next.subarray(take.length);
+      else this.readable.shift();
+      if (this.canonical) break;
+    }
+    const out = new Uint8Array(n);
+    let at = 0;
+    for (const chunk of chunks) {
+      out.set(chunk, at);
+      at += chunk.length;
+    }
+    return out;
+  }
+  changed(signal) {
+    if (signal?.aborted) return Promise.reject(new KernelError("EINTR"));
+    return new Promise((resolve, reject) => {
+      const onAbort = () => {
+        this.waiters = this.waiters.filter((w) => w !== waiter);
+        reject(new KernelError("EINTR"));
+      };
+      const waiter = () => {
+        signal?.removeEventListener("abort", onAbort);
+        resolve();
+      };
+      this.waiters.push(waiter);
+      signal?.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  wake() {
+    const waiters = this.waiters;
+    this.waiters = [];
+    for (const resolve of waiters) resolve();
+  }
+};
+
+// src/kernel/pty.ts
+var PtyPair = class {
+  slave;
+  locked = true;
+  packet = false;
+  queue = [];
+  waiters = [];
+  masterOpen = true;
+  slaveRefs = 0;
+  slaveSeen = false;
+  index;
+  onFree;
+  constructor(index, signal, onFree) {
+    this.index = index;
+    this.onFree = onFree;
+    this.slave = new KernelTty(
+      { write: (bytes) => this.fromSlave(bytes) },
+      (sig) => signal(this.slave, sig)
+    );
+    this.slave.name = `/dev/pts/${index}`;
+  }
+  master() {
+    return new OpenFile({
+      read: (max, signal) => this.readMaster(max, signal),
+      write: async (bytes) => {
+        this.slave.receive(bytes);
+        return bytes.length;
+      },
+      poll: () => ({
+        readable: this.queue.length > 0 || this.slaveGone,
+        writable: true,
+        hangup: this.slaveGone
+      }),
+      changed: (signal) => this.changed(signal),
+      close: () => this.closeMaster(),
+      pty: this
+    });
+  }
+  openSlave() {
+    if (!this.masterOpen || this.locked) throw new KernelError("EIO");
+    const file = this.slave.file().file;
+    this.slaveRefs += 1;
+    this.slaveSeen = true;
+    return new OpenFile({ ...file, close: () => this.closeSlave() });
+  }
+  get slaveGone() {
+    return this.slaveSeen && this.slaveRefs === 0;
+  }
+  fromSlave(bytes) {
+    if (!this.masterOpen) return;
+    this.queue.push(bytes.slice());
+    this.wake();
+  }
+  async readMaster(max, signal) {
+    while (this.queue.length === 0) {
+      if (this.slaveGone) throw new KernelError("EIO");
+      await this.changed(signal);
+    }
+    const status = this.packet ? 1 : 0;
+    const chunks = [];
+    let n = 0;
+    while (this.queue.length > 0 && n < max - status) {
+      const next = this.queue[0];
+      const take = next.subarray(0, max - status - n);
+      chunks.push(take);
+      n += take.length;
+      if (take.length < next.length) this.queue[0] = next.subarray(take.length);
+      else this.queue.shift();
+    }
+    const out = new Uint8Array(status + n);
+    let at = status;
+    for (const chunk of chunks) {
+      out.set(chunk, at);
+      at += chunk.length;
+    }
+    return out;
+  }
+  closeMaster() {
+    this.masterOpen = false;
+    this.queue = [];
+    this.slave.hangup();
+    this.slave.signalHangup();
+    this.freeIfUnused();
+  }
+  closeSlave() {
+    this.slaveRefs -= 1;
+    this.wake();
+    this.freeIfUnused();
+  }
+  freeIfUnused() {
+    if (!this.masterOpen && this.slaveRefs === 0) this.onFree(this);
+  }
+  changed(signal) {
+    if (signal?.aborted) return Promise.reject(new KernelError("EINTR"));
+    return new Promise((resolve, reject) => {
+      const onAbort = () => {
+        this.waiters = this.waiters.filter((w) => w !== waiter);
+        reject(new KernelError("EINTR"));
+      };
+      const waiter = () => {
+        signal?.removeEventListener("abort", onAbort);
+        resolve();
+      };
+      this.waiters.push(waiter);
+      signal?.addEventListener("abort", onAbort, { once: true });
+    });
+  }
+  wake() {
+    const waiters = this.waiters;
+    this.waiters = [];
+    for (const resolve of waiters) resolve();
+  }
+};
+var PtyTable = class {
+  pairs = /* @__PURE__ */ new Map();
+  signal;
+  constructor(signal) {
+    this.signal = signal;
+  }
+  open() {
+    let index = 0;
+    while (this.pairs.has(index)) index += 1;
+    const pair = new PtyPair(index, this.signal, (p) => this.pairs.delete(p.index));
+    this.pairs.set(index, pair);
+    return { pair, master: pair.master() };
+  }
+  get(index) {
+    const pair = this.pairs.get(index);
+    if (!pair) throw new KernelError("ENOENT");
+    return pair;
+  }
+  numbers() {
+    return [...this.pairs.keys()].sort((a, b) => a - b);
+  }
+};
+var PTY_OPS = [
+  "pty-open",
+  "pty-slave-open",
+  "pty-number",
+  "pty-lock",
+  "pty-ctty",
+  "pty-packet",
+  "pty-list",
+  "pty-winsz-set"
+];
+function masterOf(ctx, fd) {
+  const pair = ctx.fds.get(fd).file.pty;
+  if (!pair) throw new KernelError("ENOTTY");
+  return pair;
+}
+function terminalOf(ctx, fd) {
+  const file = ctx.fds.get(fd).file;
+  const tty = file.tty ?? file.pty?.slave;
+  if (!tty) throw new KernelError("ENOTTY");
+  return tty;
+}
+var json2 = (value) => ({ ok: true, kind: "json", json: value });
+var done2 = { ok: true, kind: "void" };
+function ptySyscall(req, ctx) {
+  switch (req.op) {
+    case "pty-open": {
+      if (!ctx.ptys) throw new KernelError("ENOENT");
+      return json2(ctx.fds.install(ctx.ptys.open().master, 3));
+    }
+    case "pty-slave-open": {
+      if (!ctx.ptys) throw new KernelError("ENOENT");
+      const pair = ctx.ptys.get(req.n);
+      const fd = ctx.fds.install(pair.openSlave(), 3);
+      if (!req.noctty) ctx.jobs?.acquireTerminal(ctx.pid, pair.slave);
+      return json2(fd);
+    }
+    case "pty-number":
+      return json2(masterOf(ctx, req.fd).index);
+    case "pty-lock":
+      masterOf(ctx, req.fd).locked = req.lock;
+      return done2;
+    case "pty-ctty": {
+      const tty = terminalOf(ctx, req.fd);
+      const leader = ctx.jobs?.getsid(ctx.pid, 0) === ctx.pid;
+      if (leader && ctx.jobs?.controllingTerminal(ctx.pid) === tty) return done2;
+      if (!ctx.jobs?.acquireTerminal(ctx.pid, tty)) throw new KernelError("EPERM");
+      return done2;
+    }
+    case "pty-list":
+      return json2(ctx.ptys?.numbers() ?? []);
+    case "pty-packet":
+      masterOf(ctx, req.fd).packet = req.on;
+      return done2;
+    case "pty-winsz-set":
+      terminalOf(ctx, req.fd).resize(req.cols, req.rows);
+      return done2;
+  }
+}
+
+// src/kernel/select.ts
+function ready(fds, read, write) {
+  const hangup = /* @__PURE__ */ new Set();
+  const pick = (list, dir) => list.filter((fd) => {
+    const state = pollFile(fds.get(fd).file);
+    if (state.hangup) hangup.add(fd);
+    return state[dir] || state.hangup;
+  });
+  const out = { read: pick(read, "readable"), write: pick(write, "writable") };
+  if (hangup.size > 0) out.hangup = [...hangup];
+  return out;
+}
+function interruption(signal) {
+  const { promise, reject } = Promise.withResolvers();
+  const fail = () => reject(new KernelError("EINTR"));
+  if (signal.aborted) fail();
+  else signal.addEventListener("abort", fail, { once: true });
+  return { promise, done: () => signal.removeEventListener("abort", fail) };
+}
+async function selectFds(fds, read, write, timeoutMs, interrupt) {
+  const deadline = timeoutMs < 0 ? Number.POSITIVE_INFINITY : Date.now() + timeoutMs;
+  const interrupted2 = interruption(interrupt);
+  interrupted2.promise.catch(() => {
+  });
+  try {
+    return await waitReady(fds, read, write, deadline, interrupted2.promise);
+  } finally {
+    interrupted2.done();
+  }
+}
+async function waitReady(fds, read, write, deadline, interrupted2) {
+  for (; ; ) {
+    const now = ready(fds, read, write);
+    if (now.read.length > 0 || now.write.length > 0 || Date.now() >= deadline) return now;
+    const round = new AbortController();
+    const changes = [.../* @__PURE__ */ new Set([...read, ...write])].flatMap((fd) => {
+      const file = fds.get(fd).file;
+      return file.changed === void 0 ? [] : [file.changed(round.signal).catch(() => void 0)];
+    });
+    let timer;
+    const expiry = deadline === Number.POSITIVE_INFINITY ? [] : [new Promise((resolve) => timer = setTimeout(resolve, deadline - Date.now()))];
+    try {
+      await Promise.race([...changes, ...expiry, interrupted2]);
+    } finally {
+      round.abort();
+      clearTimeout(timer);
+    }
+  }
+}
+
+// src/kernel/vfs-file.ts
+var O_ACCMODE = 3;
+var O_WRONLY = 1;
+var O_RDWR = 2;
+var O_APPEND = 1024;
+var SEEK_SET = 0;
+var SEEK_CUR = 1;
+var SEEK_END = 2;
+var WRITEBACK_MS = 250;
+var WRITEBACK_COST_FACTOR = 10;
+function isMissing(err) {
+  if (err?.code === "ENOENT") return true;
+  return err instanceof Error && err.message.startsWith("ENOENT");
+}
+function within2(path, root) {
+  return path === root || path.startsWith(root.endsWith("/") ? root : `${root}/`);
+}
+var VfsNode = class {
+  data;
+  length = 0;
+  dirty = false;
+  queue = Promise.resolve();
+  writeBack;
+  writeBackCost = 0;
+  opens = 0;
+  missing = false;
+  fs;
+  path;
+  orphaned;
+  constructor(fs, path, contents, orphaned = false, dirty = false) {
+    this.fs = fs;
+    this.path = path;
+    this.orphaned = orphaned;
+    if (contents !== void 0) this.data = new Uint8Array(contents);
+    else if (orphaned) this.data = new Uint8Array(0);
+    this.length = this.data?.length ?? 0;
+    if (dirty && contents !== void 0) this.markDirty();
+  }
+  serial(op) {
+    const next = this.queue.then(op);
+    this.queue = next.catch(() => void 0);
+    return next;
+  }
+  async load() {
+    if (!this.data) {
+      try {
+        this.data = await this.fs.readFileBuffer(this.path);
+      } catch (err) {
+        if (!isMissing(err)) throw err;
+        this.data = new Uint8Array(0);
+        this.missing = true;
+      }
+      this.length = this.data.length;
+    }
+    return this.data;
+  }
+  replace(contents) {
+    this.data = new Uint8Array(contents);
+    this.length = this.data.length;
+    this.missing = false;
+    this.markDirty();
+  }
+  async materialize() {
+    await this.load();
+    if (!this.missing || this.orphaned) return;
+    this.missing = false;
+    await this.fs.writeFile(this.path, this.data?.slice(0, this.length) ?? new Uint8Array(0));
+  }
+  async size() {
+    await this.load();
+    return this.length;
+  }
+  async pread(max, at) {
+    const bytes = await this.load();
+    const n = Math.max(0, Math.min(max, this.length - at));
+    return bytes.slice(at, at + n);
+  }
+  async pwrite(bytes, at) {
+    await this.load();
+    const buf = this.ensure(at + bytes.length);
+    if (at > this.length) buf.fill(0, this.length, at);
+    buf.set(bytes, at);
+    this.length = Math.max(this.length, at + bytes.length);
+    this.markDirty();
+    return bytes.length;
+  }
+  async truncate(size) {
+    await this.load();
+    const buf = this.ensure(size);
+    if (size > this.length) buf.fill(0, this.length, size);
+    this.length = size;
+    this.markDirty();
+  }
+  markDirty() {
+    this.dirty = true;
+    if (this.writeBack !== void 0 || this.orphaned) return;
+    const delay = Math.max(WRITEBACK_MS, this.writeBackCost * WRITEBACK_COST_FACTOR);
+    this.writeBack = setTimeout(() => {
+      this.writeBack = void 0;
+      this.serial(() => this.flush()).catch(() => void 0);
+    }, delay);
+  }
+  ensure(need) {
+    const cur = this.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, this.length));
+    this.data = grown;
+    return grown;
+  }
+  async flush() {
+    if (!this.dirty || !this.data || this.orphaned) return;
+    this.dirty = false;
+    const started = performance.now();
+    try {
+      await this.fs.writeFile(this.path, this.data.slice(0, this.length));
+    } catch (err) {
+      this.dirty = true;
+      throw err;
+    }
+    this.writeBackCost = performance.now() - started;
+  }
+};
+var VfsNodes = class {
+  byPath = /* @__PURE__ */ new Map();
+  fs;
+  constructor(fs) {
+    this.fs = fs;
+  }
+  open(path) {
+    let node = this.byPath.get(path);
+    if (!node) {
+      node = new VfsNode(this.fs, path);
+      this.byPath.set(path, node);
+    }
+    node.opens++;
+    return node;
+  }
+  adopt(path, contents, dirty) {
+    let node = this.byPath.get(path);
+    if (!node) {
+      node = new VfsNode(this.fs, path, contents, false, dirty);
+      this.byPath.set(path, node);
+    } else if (dirty) {
+      node.replace(contents);
+    }
+    node.opens++;
+    return node;
+  }
+  closed(node) {
+    node.opens--;
+    if (node.opens === 0 && this.byPath.get(node.path) === node) this.byPath.delete(node.path);
+  }
+  async flush(path) {
+    for (const [p, node] of this.byPath) if (within2(p, path)) await node.serial(() => node.flush());
+  }
+  async unlinking(path) {
+    const node = this.byPath.get(path);
+    if (node) await node.serial(() => node.load());
+  }
+  unlinked(path) {
+    const node = this.byPath.get(path);
+    if (!node) return;
+    node.orphaned = true;
+    this.byPath.delete(path);
+  }
+  renamed(from, to) {
+    if (from === to) return;
+    const moved = [];
+    for (const [p, node] of this.byPath) {
+      if (within2(p, from)) moved.push(node);
+      else if (within2(p, to)) {
+        node.orphaned = true;
+        this.byPath.delete(p);
+      }
+    }
+    for (const node of moved) {
+      this.byPath.delete(node.path);
+      node.path = to + node.path.slice(from.length);
+      this.byPath.set(node.path, node);
+    }
+  }
+};
+function vfsFile(fs, opts, nodes) {
+  const access = opts.flags & O_ACCMODE;
+  const readable = access !== O_WRONLY;
+  const writable = access === O_WRONLY || access === O_RDWR;
+  const node = !nodes || opts.orphan ? new VfsNode(fs, opts.path, opts.contents, opts.orphan === true, opts.dirty === true) : opts.contents !== void 0 ? nodes.adopt(opts.path, opts.contents, opts.dirty === true) : nodes.open(opts.path);
+  let openError;
+  const atOpen = (op) => {
+    void node.serial(op).catch((err) => {
+      openError ??= { err };
+    });
+  };
+  if (opts.create) atOpen(() => node.materialize());
+  if (opts.truncate) atOpen(() => node.truncate(0));
+  const takeOpenError = () => {
+    if (!openError) return;
+    const { err } = openError;
+    openError = void 0;
+    throw err;
+  };
+  let offset = opts.position;
+  const serial = (op) => node.serial(() => {
+    takeOpenError();
+    return op();
+  });
+  return new OpenFile({
+    read: readable ? (max) => serial(async () => {
+      const out = await node.pread(max, offset);
+      offset += out.length;
+      return out;
+    }) : void 0,
+    write: writable ? (bytes) => serial(async () => {
+      if (opts.flags & O_APPEND) offset = await node.size();
+      offset += await node.pwrite(bytes, offset);
+      return bytes.length;
+    }) : void 0,
+    seek: (to, whence) => serial(async () => {
+      let base = 0;
+      if (whence === SEEK_CUR) base = offset;
+      else if (whence === SEEK_END) base = await node.size();
+      else if (whence !== SEEK_SET) throw new KernelError("EINVAL");
+      if (base + to < 0) throw new KernelError("EINVAL");
+      offset = base + to;
+      return offset;
+    }),
+    pread: (max, at) => serial(() => {
+      if (!readable) throw new KernelError("EBADF");
+      return node.pread(max, at);
+    }),
+    pwrite: (bytes, at) => serial(() => {
+      if (!writable) throw new KernelError("EBADF");
+      return node.pwrite(bytes, at);
+    }),
+    resize: (size) => serial(() => {
+      if (!writable) throw new KernelError("EBADF");
+      return node.truncate(size);
+    }),
+    stat: () => serial(async () => ({
+      path: node.path,
+      size: await node.size(),
+      ...node.orphaned ? { orphan: true } : {}
+    })),
+    flush: () => serial(() => node.flush()),
+    close: () => node.serial(async () => {
+      try {
+        takeOpenError();
+        await node.flush();
+      } finally {
+        nodes?.closed(node);
+      }
+    })
+  });
+}
+
+// src/kernel/process.ts
+var JOB_OPS = /* @__PURE__ */ new Set([
+  "proc-setpgid",
+  "proc-getpgid",
+  "proc-getsid",
+  "proc-setsid"
+]);
+function isJobSyscall(req) {
+  return JOB_OPS.has(req.op);
+}
+function isPtySyscall(req) {
+  return req.op.startsWith("pty-");
+}
+function isVfsSyscall(req) {
+  return req.op.startsWith("fd-path-") || req.op === "fd-pread" || req.op === "fd-pwrite" || req.op === "fd-resize" || req.op === "fd-vfs-stat";
+}
+function isFdSyscall(req) {
+  return req.op.startsWith("fd-");
+}
+function isTtySyscall(req) {
+  return req.op.startsWith("tty-");
+}
+var SYSCALL_OPS = /* @__PURE__ */ new Set([
+  "fd-read",
+  "fd-write",
+  "fd-close",
+  "fd-pipe",
+  "fd-poll",
+  "fd-open-vfs",
+  "fd-seek",
+  "fd-pread",
+  "fd-pwrite",
+  "fd-resize",
+  "fd-vfs-stat",
+  "fd-path-flush",
+  "fd-path-unlinking",
+  "fd-path-unlinked",
+  "fd-path-renamed",
+  "fd-select",
+  "fd-info",
+  "fd-dup",
+  "fd-reserve",
+  "fd-meta",
+  "fd-setfl",
+  "fd-cloexec",
+  "fd-list",
+  "proc-alarm",
+  "fd-renumber",
+  "fd-promote",
+  "fd-open-tty",
+  "tty-get",
+  "tty-set",
+  "tty-winsz",
+  "fd-flush",
+  "proc-spawn",
+  "proc-wait",
+  "proc-captured",
+  "proc-fork",
+  "proc-kill",
+  "proc-exec",
+  "proc-setpgid",
+  "proc-getpgid",
+  "proc-getsid",
+  "proc-setsid",
+  "tty-pgrp-get",
+  "tty-pgrp-set",
+  "sig-mask",
+  "sig-pause",
+  ...PTY_OPS
+]);
+function isWasmSyscall(req) {
+  const op = req.op;
+  return typeof op === "string" && SYSCALL_OPS.has(op);
+}
+var MAX_READ = 1024 * 1024;
+var WasmProcess = class {
+  exited = false;
+  children;
+  caught = 0;
+  ignored = 0;
+  interrupt = new AbortController();
+  execChild;
+  execTermsig;
+  stopped = 0;
+  stops = 0;
+  resumed = Promise.resolve();
+  wake;
+  stateListeners = [];
+  nodes;
+  pid;
+  fds;
+  options;
+  constructor(pid, fds, options) {
+    this.pid = pid;
+    this.fds = fds;
+    this.options = options;
+    this.children = new ChildTable(fds, options.spawner, options.forker);
+    this.nodes = new VfsNodes(options.fs);
+    this.children.onChildState = () => this.signal(SIG.CHLD);
+    this.children.onReap = options.onReap;
+  }
+  signal(sig) {
+    if (this.execChild !== void 0) {
+      void Promise.resolve(this.options.kill?.(this.execChild, sig)).catch(() => void 0);
+      return sig === SIG.KILL ? "terminate" : "forward";
+    }
+    if (sig === SIG.KILL) return "terminate";
+    if (sig === SIG.CONT) this.cont();
+    if (sig === SIG.STOP) return this.stop(sig);
+    const bit = sigbit(sig);
+    if (this.ignored & bit) return "ignore";
+    if (!(this.caught & bit)) {
+      const action = defaultAction(sig);
+      return action === "stop" ? this.stop(sig) : action;
+    }
+    this.options.onPending?.(sig);
+    const blocked = this.interrupt;
+    this.interrupt = new AbortController();
+    blocked.abort();
+    return "deliver";
+  }
+  onState(listener) {
+    this.stateListeners.push(listener);
+  }
+  stop(sig) {
+    if (this.stopped) return "stop";
+    this.stopped = sig;
+    this.stops++;
+    this.resumed = new Promise((resolve) => this.wake = resolve);
+    const blocked = this.interrupt;
+    this.interrupt = new AbortController();
+    blocked.abort();
+    for (const listener of this.stateListeners) listener("stopped", sig);
+    return "stop";
+  }
+  cont() {
+    if (!this.stopped) return;
+    this.stopped = 0;
+    this.wake?.();
+    for (const listener of this.stateListeners) listener("continued", SIG.CONT);
+  }
+  async syscall(req) {
+    for (; ; ) {
+      await this.resumed;
+      const stops = this.stops;
+      const result = await this.dispatch(req);
+      const restart = !result.ok && result.errno === "EINTR" && this.stops !== stops;
+      if (restart && !this.options.hasPending?.()) continue;
+      await this.resumed;
+      return result;
+    }
+  }
+  async dispatch(req) {
+    try {
+      if (isFdSyscall(req)) return await this.fdSyscall(req);
+      if (isTtySyscall(req)) return this.ttySyscall(req);
+      if (isJobSyscall(req)) return this.jobSyscall(req);
+      if (isPtySyscall(req)) {
+        const { ptys, jobs } = this.options;
+        return ptySyscall(req, { pid: this.pid, fds: this.fds, ptys, jobs });
+      }
+      return await this.procSyscall(req);
+    } catch (e) {
+      if (e instanceof KernelError || e instanceof SpawnError) {
+        return { ok: false, errno: e.code, message: e.code };
+      }
+      throw e;
+    }
+  }
+  blockingSignal() {
+    if (this.options.hasPending?.()) throw new KernelError("EINTR");
+    return this.interrupt.signal;
+  }
+  async read(req) {
+    const file = this.fds.get(req.fd).file;
+    const read = req.peek ? file.peek : file.read;
+    if (!read) throw new KernelError(req.peek && file.read ? "EOPNOTSUPP" : "EBADF");
+    if (file.tty) this.checkForeground(file.tty);
+    if (req.max <= 0) return new Uint8Array(0);
+    const ready2 = pollFile(file).readable;
+    if (!ready2 && req.nonblock) throw new KernelError("EAGAIN");
+    const signal = ready2 ? this.interrupt.signal : this.blockingSignal();
+    return read.call(file, Math.max(0, Math.min(req.max, MAX_READ)), signal);
+  }
+  async write(fd, body, nonblock = false) {
+    const file = this.fds.get(fd).file;
+    if (!file.write) throw new KernelError("EBADF");
+    if (!pollFile(file).writable) {
+      if (nonblock) throw new KernelError("EAGAIN");
+      return file.write(body, this.blockingSignal());
+    }
+    if (nonblock) return file.write(body, AbortSignal.abort());
+    return file.write(
+      body,
+      this.options.hasPending?.() ? AbortSignal.abort() : this.interrupt.signal
+    );
+  }
+  openVfsFile(req) {
+    return vfsFile(
+      this.options.fs,
+      {
+        path: req.path,
+        flags: req.flags,
+        position: req.position,
+        ...req.contents !== void 0 ? { contents: req.contents } : {},
+        ...req.orphan ? { orphan: true } : {},
+        ...req.truncate ? { truncate: true } : {},
+        ...req.create ? { create: true } : {}
+      },
+      this.nodes
+    );
+  }
+  async fdSyscall(req) {
+    if (isVfsSyscall(req)) return this.vfsSyscall(req);
+    switch (req.op) {
+      case "fd-read":
+        return { ok: true, kind: "bytes", bytes: await this.read(req) };
+      case "fd-write":
+        return { ok: true, kind: "json", json: await this.write(req.fd, req.body, req.nonblock) };
+      case "fd-close":
+        await Promise.resolve(this.fds.close(req.fd));
+        return { ok: true, kind: "void" };
+      case "fd-pipe": {
+        const pipe = openPipe();
+        const read = this.fds.install(pipe.read, 3);
+        let write;
+        try {
+          write = this.fds.install(pipe.write, 3);
+        } catch (e) {
+          await Promise.resolve(this.fds.close(read));
+          throw e;
+        }
+        return { ok: true, kind: "json", json: [read, write] };
+      }
+      case "fd-poll":
+        return { ok: true, kind: "json", json: pollFile(this.fds.get(req.fd).file) };
+      case "fd-open-vfs":
+        return { ok: true, kind: "json", json: this.fds.install(this.openVfsFile(req), 3) };
+      case "fd-info":
+        return { ok: true, kind: "json", json: this.fdInfo(req.fd) };
+      case "fd-list":
+        return {
+          ok: true,
+          kind: "json",
+          json: this.fds.numbers().map((fd) => ({ fd, ...this.fdInfo(fd) }))
+        };
+      case "fd-meta": {
+        const file = this.fds.get(req.fd).file;
+        if (!file.held) throw new KernelError("EBADF");
+        file.heldMeta = req.meta;
+        return { ok: true, kind: "void" };
+      }
+      case "fd-setfl":
+        this.fds.setStatusFlags(req.fd, req.flags);
+        return { ok: true, kind: "void" };
+      case "fd-cloexec":
+        if (req.on) this.fds.setCloseOnExec(req.fd);
+        else this.fds.clearCloseOnExec(req.fd);
+        return { ok: true, kind: "void" };
+      case "fd-dup":
+        return { ok: true, kind: "json", json: this.fds.dup(req.fd, req.min ?? 3) };
+      case "fd-reserve":
+        return { ok: true, kind: "json", json: this.reserve(req.fd, req.min, req.meta) };
+      case "fd-promote":
+        this.promote(req);
+        return { ok: true, kind: "void" };
+      case "fd-renumber":
+        if (req.from !== req.to) {
+          this.fds.dup2(req.from, req.to);
+          if (!req.keep) await Promise.resolve(this.fds.close(req.from));
+        }
+        return { ok: true, kind: "void" };
+      case "fd-open-tty": {
+        const tty = req.name === void 0 ? this.controllingTerminal() : this.options.jobs?.terminalNamed(req.name);
+        if (!tty) throw new KernelError("ENXIO");
+        return { ok: true, kind: "json", json: this.fds.install(tty.file(), 3) };
+      }
+      case "fd-select": {
+        const { read, write, timeoutMs } = req;
+        const signal = this.blockingSignal();
+        const selected = await selectFds(this.fds, read, write, timeoutMs, signal);
+        return { ok: true, kind: "json", json: selected };
+      }
+      case "fd-seek": {
+        const file = this.fds.get(req.fd).file;
+        if (!file.seek) throw new KernelError("ESPIPE");
+        return { ok: true, kind: "json", json: await file.seek(req.offset, req.whence) };
+      }
+      case "fd-flush": {
+        const file = this.fds.get(req.fd).file;
+        if (file.flush) await file.flush();
+        return { ok: true, kind: "void" };
+      }
+    }
+  }
+  async vfsSyscall(req) {
+    if ("path" in req || "from" in req) {
+      const nodes = this.nodes;
+      if (req.op === "fd-path-flush") await nodes.flush(req.path);
+      else if (req.op === "fd-path-unlinking") await nodes.unlinking(req.path);
+      else if (req.op === "fd-path-unlinked") nodes.unlinked(req.path);
+      else if (req.op === "fd-path-renamed") nodes.renamed(req.from, req.to);
+      return { ok: true, kind: "void" };
+    }
+    const file = this.fds.get(req.fd).file;
+    if (!file.pread || !file.pwrite || !file.resize || !file.stat) throw new KernelError("ESPIPE");
+    switch (req.op) {
+      case "fd-pread":
+        return {
+          ok: true,
+          kind: "bytes",
+          bytes: await file.pread(Math.min(req.max, MAX_READ), req.offset)
+        };
+      case "fd-pwrite":
+        return { ok: true, kind: "json", json: await file.pwrite(req.body, req.offset) };
+      case "fd-resize":
+        await file.resize(req.size);
+        return { ok: true, kind: "void" };
+      case "fd-vfs-stat":
+        return { ok: true, kind: "json", json: await file.stat() };
+    }
+  }
+  promote(req) {
+    if (!this.fds.get(req.fd).file.held) throw new KernelError("EBADF");
+    if (req.share !== void 0) {
+      this.fds.dup2(req.share, req.fd);
+      return;
+    }
+    if (req.path === void 0) throw new KernelError("EINVAL");
+    const file = vfsFile(
+      this.options.fs,
+      {
+        path: req.path,
+        flags: req.flags ?? 0,
+        position: req.position ?? 0,
+        ...req.contents !== void 0 ? { contents: req.contents } : {},
+        ...req.orphan ? { orphan: true } : {},
+        ...req.dirty ? { dirty: true } : {}
+      },
+      this.nodes
+    );
+    this.fds.installAt(req.fd, file);
+  }
+  reserve(fd, min = 3, meta) {
+    if (fd === void 0) return this.fds.install(heldFile(meta), Math.max(3, min));
+    if (this.fds.has(fd)) throw new KernelError("EBADF");
+    this.fds.installAt(fd, heldFile(meta));
+    return fd;
+  }
+  fdInfo(fd) {
+    const file = this.fds.get(fd).file;
+    const flags = this.fds.statusFlags(fd);
+    return {
+      tty: file.tty !== void 0,
+      kind: kernelFdKind(file),
+      ...file.heldMeta ? { meta: file.heldMeta } : {},
+      ...flags !== void 0 ? { flags } : {},
+      ...this.fds.closesOnExec(fd) ? { cloexec: true } : {},
+      ...file.tty?.name ? { name: file.tty.name } : file.pty ? { name: "/dev/ptmx" } : {}
+    };
+  }
+  ttySyscall(req) {
+    const tty = this.tty(req.fd);
+    const jobs = this.options.jobs;
+    switch (req.op) {
+      case "tty-get":
+        return { ok: true, kind: "json", json: tty.tcgets() };
+      case "tty-set":
+        tty.tcsets(req.termios);
+        return { ok: true, kind: "void" };
+      case "tty-winsz":
+        return { ok: true, kind: "json", json: tty.winsize() };
+      case "tty-pgrp-get":
+        return { ok: true, kind: "json", json: jobs ? jobs.tcgetpgrp(tty, this.sid()) : this.pid };
+      case "tty-pgrp-set":
+        if (jobs) jobs.tcsetpgrp(this.pid, tty, req.pgrp);
+        else if (req.pgrp !== this.pid) throw new KernelError("EPERM");
+        return { ok: true, kind: "void" };
+    }
+  }
+  checkForeground(tty) {
+    const jobs = this.options.jobs;
+    if (!jobs) return;
+    const session = jobs.controllingTerminal(this.pid);
+    if (session !== void 0 && session !== tty) return;
+    const pgid = this.pgid();
+    if (jobs.tcgetpgrp(tty, this.sid()) === pgid) return;
+    if (this.ignored & sigbit(SIG.TTIN)) throw new KernelError("EIO");
+    jobs.killGroup(pgid, SIG.TTIN);
+    throw new KernelError("EINTR");
+  }
+  waitGroup(pid) {
+    const jobs = this.options.jobs;
+    if (!jobs || pid > 0 || pid === -1) return void 0;
+    const group = pid === 0 ? this.pgid() : -pid;
+    return (child) => (jobs.pgidOf(child) ?? this.pgid()) === group;
+  }
+  pgid() {
+    return this.options.jobs?.getpgid(this.pid, 0) ?? this.pid;
+  }
+  sid() {
+    return this.options.jobs?.getsid(this.pid, 0) ?? this.pid;
+  }
+  controllingTerminal() {
+    const session = this.options.jobs?.controllingTerminal(this.pid);
+    return session === void 0 ? this.fds.stdioTerminal() : session ?? void 0;
+  }
+  jobSyscall(req) {
+    const jobs = this.options.jobs;
+    const self = (pid) => {
+      if (pid !== 0 && pid !== this.pid) throw new KernelError("ESRCH");
+      return this.pid;
+    };
+    switch (req.op) {
+      case "proc-setpgid":
+        if (jobs) jobs.setpgid(this.pid, req.pid, req.pgid);
+        else if (self(req.pid) !== (req.pgid || this.pid)) throw new KernelError("EPERM");
+        return { ok: true, kind: "void" };
+      case "proc-getpgid":
+        return { ok: true, kind: "json", json: jobs?.getpgid(this.pid, req.pid) ?? self(req.pid) };
+      case "proc-getsid":
+        return { ok: true, kind: "json", json: jobs?.getsid(this.pid, req.pid) ?? self(req.pid) };
+      case "proc-setsid":
+        if (!jobs) throw new KernelError("EPERM");
+        return { ok: true, kind: "json", json: jobs.setsid(this.pid) };
+    }
+  }
+  tty(fd) {
+    const file = this.fds.get(fd).file;
+    const tty = file.tty ?? file.pty?.slave;
+    if (!tty) throw new KernelError("ENOTTY");
+    return tty;
+  }
+  async procSyscall(req) {
+    switch (req.op) {
+      case "proc-fork":
+        return { ok: true, kind: "json", json: await this.children.fork(req.state) };
+      case "proc-spawn": {
+        const { file, argv, env, cwd, stdio, inherit } = req;
+        const pid = await this.children.spawn({ file, argv, env, cwd }, stdio, inherit);
+        return { ok: true, kind: "json", json: pid };
+      }
+      case "proc-wait": {
+        const signal = req.nohang ? this.interrupt.signal : this.blockingSignal();
+        const flags = {
+          untraced: req.untraced,
+          continued: req.continued,
+          inGroup: this.waitGroup(req.pid)
+        };
+        const waited = await this.children.wait(req.pid, req.nohang, signal, flags);
+        return { ok: true, kind: "json", json: waited };
+      }
+      case "proc-exec": {
+        this.execChild = req.pid;
+        this.options.jobs?.exec(this.pid, req.pid);
+        this.children.watch(
+          req.pid,
+          (state, sig) => state === "stopped" ? this.stop(sig) : this.cont()
+        );
+        await this.fds.closeAll();
+        try {
+          const waited = await this.children.wait(req.pid, false);
+          const termsig = waited[1] & 127;
+          if (termsig) this.execTermsig = termsig;
+          return { ok: true, kind: "json", json: waited };
+        } finally {
+          this.execChild = void 0;
+        }
+      }
+      case "proc-kill":
+        if (req.sig !== 0 && !isSignal(req.sig)) throw new KernelError("EINVAL");
+        if (!await this.options.kill?.(req.pid === 0 ? -this.pgid() : req.pid, req.sig)) {
+          throw new KernelError("ESRCH");
+        }
+        return { ok: true, kind: "void" };
+      case "proc-alarm":
+        this.setAlarm(req.sig, req.firstMs ?? req.ms, req.repeat ? req.ms : 0, req.timer);
+        return { ok: true, kind: "void" };
+      case "sig-mask":
+        this.caught = req.caught;
+        this.ignored = req.ignored;
+        return { ok: true, kind: "void" };
+      case "sig-pause":
+        return this.pause();
+      case "proc-captured":
+        return { ok: true, kind: "bytes", bytes: this.children.captured(req.pid, req.slot) };
+    }
+  }
+  pause() {
+    const signal = this.blockingSignal();
+    return new Promise((_, reject) => {
+      signal.addEventListener("abort", () => reject(new KernelError("EINTR")), { once: true });
+    });
+  }
+  alarm;
+  alarmEvery;
+  setAlarm(sig, first, every, timer) {
+    if (!isSignal(sig)) throw new KernelError("EINVAL");
+    this.clearAlarm();
+    if (first <= 0) return;
+    const fire = timer === void 0 ? () => this.options.raise?.(sig) : () => this.timerExpired(timer);
+    this.alarm = setTimeout(() => {
+      this.alarm = void 0;
+      fire();
+      if (every > 0) this.alarmEvery = setInterval(fire, every);
+    }, first);
+  }
+  timerExpired(which) {
+    this.options.onTimer?.(which);
+    const blocked = this.interrupt;
+    this.interrupt = new AbortController();
+    blocked.abort();
+  }
+  clearAlarm() {
+    clearTimeout(this.alarm);
+    clearInterval(this.alarmEvery);
+    this.alarm = void 0;
+    this.alarmEvery = void 0;
+  }
+  async exit() {
+    if (this.exited) return;
+    this.exited = true;
+    this.clearAlarm();
+    for (const pid of this.children.pids()) this.options.onReap?.(pid);
+    await this.fds.closeAll();
+  }
+};
+
+// 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/host.ts
+var CRASHED = 70;
+var descIds = /* @__PURE__ */ new WeakMap();
+var nextDescId = 1;
+function descId(file) {
+  const id = descIds.get(file) ?? nextDescId++;
+  descIds.set(file, id);
+  return id;
+}
+function inheritedFds(fds) {
+  return fds.numbers().filter((fd) => fd > 2 && !fds.get(fd).file.held).map((fd) => {
+    const open = fds.get(fd);
+    const flags = fds.statusFlags(fd);
+    const kind = kernelFdKind(open.file);
+    const meta = open.file.heldMeta;
+    return {
+      fd,
+      kind,
+      ...kind === "device" && meta && "device" in meta ? { device: meta } : {},
+      ...flags !== void 0 ? { flags } : {},
+      ...fds.closesOnExec(fd) ? { cloexec: true } : {},
+      ...kind === "stream" ? { desc: descId(open) } : {}
+    };
+  });
+}
+function spawnWasmProcess(opts) {
+  const sab = new SharedArrayBuffer(SAB_HEADER_BYTES + SAB_DEFAULT_WINDOW_BYTES);
+  const header = new Int32Array(sab, 0, SAB_HEADER_I32);
+  const process = new WasmProcess(opts.pid, opts.fds, {
+    spawner: opts.spawner,
+    forker: opts.forker,
+    fs: opts.fs,
+    kill: opts.kill,
+    jobs: opts.jobs,
+    ptys: opts.ptys,
+    onReap: opts.onReap,
+    onPending: (sig) => void Atomics.or(header, SAB_I_SIGNALS, sigbit(sig)),
+    onTimer: (which) => void Atomics.or(header, SAB_I_TIMERS, 1 << which),
+    hasPending: () => Atomics.load(header, SAB_I_SIGNALS) !== 0 || Atomics.load(header, SAB_I_TIMERS) !== 0,
+    raise: (sig) => signal(sig)
+  });
+  const token = mintSyncFsToken({ fs: opts.fs, cwd: opts.cwd });
+  const worker = opts.createWorker();
+  const dispatch = async (req) => {
+    if (isWasmSyscall(req)) return process.syscall(req);
+    return dispatchSyncFs(req);
+  };
+  const responder = attachSyncSabResponder(worker, sab, token, { dispatch });
+  let settle;
+  const exited = new Promise((resolve) => settle = resolve);
+  let done3 = false;
+  let endedBy;
+  const finish = (code, sig) => {
+    if (done3) return;
+    done3 = true;
+    endedBy = sig ?? process.execTermsig;
+    worker.removeEventListener("message", onMessage);
+    worker.removeEventListener("error", onError);
+    responder.dispose();
+    revokeSyncFsToken(token);
+    worker.terminate();
+    void process.exit().then(
+      () => settle(code),
+      () => settle(code)
+    );
+  };
+  const onMessage = (event) => {
+    const data = event.data;
+    if (data?.type === WASM_PROCESS_EXIT) {
+      finish(typeof data.code === "number" ? data.code : CRASHED);
+    } else if (data?.type === WASM_PROCESS_ERROR) {
+      opts.onError?.(String(data.message));
+      finish(CRASHED);
+    }
+  };
+  const onError = (event) => {
+    event.preventDefault();
+    opts.onError?.(String(event.message ?? "worker error"));
+    finish(CRASHED);
+  };
+  worker.addEventListener("message", onMessage);
+  worker.addEventListener("error", onError);
+  const init = {
+    type: WASM_PROCESS_INIT,
+    pid: opts.pid,
+    program: opts.program,
+    argv0: opts.argv0,
+    args: opts.args,
+    env: opts.env,
+    cwd: opts.cwd,
+    sab,
+    ...opts.ppid !== void 0 ? { ppid: opts.ppid } : {},
+    ...opts.fork ? { fork: opts.fork } : { fds: inheritedFds(opts.fds) }
+  };
+  worker.postMessage(init, opts.fork ? [opts.fork.memory.buffer] : []);
+  const signal = (sig) => {
+    if (process.signal(sig) === "terminate") finish(sig === SIG.KILL ? 137 : 128 + sig, sig);
+  };
+  const kill = (code = 137) => finish(code, code > 128 && code < 160 ? code - 128 : void 0);
+  return {
+    pid: opts.pid,
+    exited,
+    kill,
+    signal,
+    termsig: () => endedBy,
+    onState: (listener) => process.onState(listener)
+  };
+}
+
+// src/kernel/jobs.ts
+var JobTable = class {
+  members = /* @__PURE__ */ new Map();
+  foreground = /* @__PURE__ */ new Map();
+  terminals = /* @__PURE__ */ new Map();
+  add(pid, parentPid, signal, terminal) {
+    const parent = parentPid === void 0 ? void 0 : this.members.get(parentPid);
+    if (!parent && terminal) this.terminals.set(pid, terminal);
+    const member = {
+      pid,
+      ppid: parent?.pid,
+      pgid: parent?.pgid ?? pid,
+      sid: parent?.sid ?? pid,
+      signal
+    };
+    this.members.set(pid, member);
+    return member;
+  }
+  remove(pid) {
+    this.members.delete(pid);
+  }
+  exec(pid, child) {
+    const member = this.members.get(child);
+    if (member) member.execParent = pid;
+    const execer = this.members.get(pid);
+    if (execer) execer.execed = true;
+  }
+  pgidOf(pid) {
+    return this.members.get(pid)?.pgid;
+  }
+  member(pid) {
+    const member = this.members.get(pid);
+    if (!member) throw new KernelError("ESRCH");
+    return member;
+  }
+  setpgid(caller, pid, pgid) {
+    const target = this.member(pid || caller);
+    const group = pgid || target.pid;
+    if (group < 0) throw new KernelError("EINVAL");
+    const self = this.member(caller);
+    if (target.pid !== caller) {
+      if (target.ppid !== caller) throw new KernelError("ESRCH");
+      if (target.execed) throw new KernelError("EACCES");
+    }
+    if (target.sid !== self.sid) throw new KernelError("EPERM");
+    if (target.pid === target.sid) throw new KernelError("EPERM");
+    const exists = [...this.members.values()].some((m) => m.pgid === group && m.sid === target.sid);
+    if (group !== target.pid && !exists) throw new KernelError("EPERM");
+    target.pgid = group;
+  }
+  getpgid(caller, pid) {
+    return this.member(pid || caller).pgid;
+  }
+  getsid(caller, pid) {
+    return this.member(pid || caller).sid;
+  }
+  setsid(pid) {
+    const member = this.member(pid);
+    if (member.pgid === pid) throw new KernelError("EPERM");
+    member.sid = pid;
+    member.pgid = pid;
+    this.terminals.delete(pid);
+    return pid;
+  }
+  terminalNamed(name) {
+    const known = /* @__PURE__ */ new Set([...this.terminals.values(), ...this.foreground.keys()]);
+    return [...known].find((tty) => tty.name === name);
+  }
+  controllingTerminal(pid) {
+    const member = this.members.get(pid);
+    return member && (this.terminals.get(member.sid) ?? null);
+  }
+  acquireTerminal(pid, tty) {
+    const member = this.members.get(pid);
+    if (!member || member.sid !== pid || this.terminals.has(pid)) return false;
+    if ([...this.terminals.values()].includes(tty)) return false;
+    this.terminals.set(pid, tty);
+    this.foreground.set(tty, member.pgid);
+    return true;
+  }
+  killGroup(pgid, sig) {
+    const targets = [...this.members.values()].filter((m) => m.pgid === pgid);
+    const pids = new Set(targets.map((m) => m.pid));
+    if (sig !== 0) {
+      for (const m of targets)
+        if (m.execParent === void 0 || !pids.has(m.execParent)) m.signal(sig);
+    }
+    return targets.length > 0;
+  }
+  tcgetpgrp(tty, fallback) {
+    return this.foreground.get(tty) ?? fallback;
+  }
+  tcsetpgrp(caller, tty, pgid) {
+    const self = this.member(caller);
+    const inSession = [...this.members.values()].some((m) => m.pgid === pgid && m.sid === self.sid);
+    if (!inSession) throw new KernelError("EPERM");
+    this.foreground.set(tty, pgid);
+  }
+  signalOwnedForeground(tty, sig) {
+    const pgid = this.foreground.get(tty);
+    if (pgid !== void 0) this.killGroup(pgid, sig);
+  }
+  signalForeground(tty, fallback, sig) {
+    this.killGroup(this.tcgetpgrp(tty, fallback), sig);
+  }
+};
+
+// src/launcher.ts
+var COMMAND2 = /^\/(?:usr\/)?bin\/([^/]+)$/;
+var SHEBANG_MAX = 256;
+var NOT_FOUND = 127;
+var encoder3 = new TextEncoder();
+function baseName(path) {
+  return path.slice(path.lastIndexOf("/") + 1);
+}
+function modulePath(glue) {
+  return glue.endsWith(".js") ? `${glue.slice(0, -3)}.wasm` : `${glue}.wasm`;
+}
+function targetOf(command) {
+  return {
+    glue: command.glue,
+    wasm: command.wasm,
+    argv0: command.argv0,
+    ...command.args ? { prefix: command.args } : {},
+    ...command.env ? { env: command.env } : {}
+  };
+}
+function childHandle(handle) {
+  return {
+    pid: handle.pid,
+    exited: handle.exited,
+    termsig: handle.termsig,
+    onState: (listener) => handle.onState(listener)
+  };
+}
+function concat2(chunks) {
+  const out = new Uint8Array(chunks.reduce((n, chunk) => n + chunk.length, 0));
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return out;
+}
+var Launcher = class {
+  fs;
+  base;
+  createWorker;
+  modulesDir;
+  env;
+  catalog;
+  compiled = /* @__PURE__ */ new Map();
+  processes = /* @__PURE__ */ new Map();
+  zombies = /* @__PURE__ */ new Set();
+  orphans = /* @__PURE__ */ new Set();
+  jobs = new JobTable();
+  ptys = new PtyTable((tty, sig) => this.jobs.signalOwnedForeground(tty, sig));
+  nextPid = 1e3;
+  constructor(options) {
+    this.base = options.fs;
+    this.createWorker = options.createWorker;
+    this.modulesDir = options.modules ?? "/node_modules";
+    this.env = options.env ?? {};
+    this.fs = withCommandDirs(options.fs, async () => new Set((await this.commands()).keys()));
+  }
+  commands() {
+    this.catalog ??= scanCommands(this.base, this.modulesDir);
+    return this.catalog;
+  }
+  async resolve(file, argv0, cwd) {
+    const name = COMMAND2.exec(file)?.[1] ?? (file.includes("/") ? void 0 : file);
+    if (name !== void 0) {
+      const command = (await this.commands()).get(name);
+      return command && targetOf(command);
+    }
+    const glue = this.fs.resolvePath(cwd, file);
+    const wasm = modulePath(glue);
+    if (!await this.base.exists(glue) || !await this.base.exists(wasm)) return void 0;
+    return { glue, wasm, argv0: baseName(argv0 || file) };
+  }
+  async interpreted(file, argv, cwd) {
+    let head;
+    try {
+      head = (await this.base.readFileBuffer(this.fs.resolvePath(cwd, file))).subarray(
+        0,
+        SHEBANG_MAX
+      );
+    } catch {
+      return void 0;
+    }
+    if (head[0] !== 35 || head[1] !== 33) return void 0;
+    const words = new TextDecoder().decode(head).slice(2).split("\n")[0].trim().split(/[ \t]+/);
+    if (baseName(words[0]) === "env") words.shift();
+    const [interp, ...rest] = words;
+    const target = interp ? await this.resolve(interp, interp, cwd) : void 0;
+    if (!target) return void 0;
+    const arg = rest.join(" ");
+    return {
+      target,
+      args: [...target.prefix ?? [], ...arg ? [arg] : [], file, ...argv.slice(1)]
+    };
+  }
+  async plan(file, argv, cwd) {
+    const direct = await this.resolve(file, argv[0] ?? file, cwd);
+    if (direct) return { target: direct, args: [...direct.prefix ?? [], ...argv.slice(1)] };
+    return this.interpreted(file, argv, cwd);
+  }
+  module(path) {
+    return this.base.stat(path).then((st) => {
+      const key = `${path}:${st.size}:${st.mtime.getTime()}`;
+      let module = this.compiled.get(key);
+      if (!module) {
+        module = this.base.readFileBuffer(path).then((bytes) => WebAssembly.compile(bytes));
+        this.compiled.set(key, module);
+        module.catch(() => this.compiled.delete(key));
+      }
+      return module;
+    });
+  }
+  async launch(planned, req) {
+    const { target, args } = planned;
+    let program;
+    try {
+      const [glue, module] = await Promise.all([
+        this.base.readFile(target.glue),
+        this.module(target.wasm)
+      ]);
+      program = { glue, module };
+    } catch (err) {
+      await req.fds.closeAll();
+      throw err;
+    }
+    return this.start({
+      ...req,
+      program,
+      argv0: target.argv0,
+      args,
+      env: { ...target.env, ...req.env }
+    });
+  }
+  start(req) {
+    const pid = this.nextPid++;
+    const terminal = req.fds.stdioTerminal();
+    const handle = spawnWasmProcess({
+      pid,
+      program: req.program,
+      argv0: req.argv0,
+      args: req.args,
+      env: req.env,
+      cwd: req.cwd,
+      fds: req.fds,
+      fs: this.fs,
+      createWorker: this.createWorker,
+      onError: req.report,
+      spawner: this.spawner(pid, req.report),
+      forker: this.forker(pid, req),
+      kill: (target, sig) => this.kill(target, sig),
+      jobs: this.jobs,
+      ptys: this.ptys,
+      onReap: (child) => this.reaped(child),
+      ...req.fork ? { fork: req.fork } : {},
+      ...req.ppid !== void 0 ? { ppid: req.ppid } : {}
+    });
+    this.processes.set(pid, handle);
+    this.jobs.add(pid, req.ppid, (sig) => handle.signal(sig), terminal);
+    void handle.exited.then(() => {
+      this.processes.delete(pid);
+      if (req.ppid === void 0 || this.orphans.delete(pid)) this.jobs.remove(pid);
+      else this.zombies.add(pid);
+    });
+    return handle;
+  }
+  reaped(pid) {
+    if (this.zombies.delete(pid)) this.jobs.remove(pid);
+    else this.orphans.add(pid);
+  }
+  spawner(ppid, report) {
+    return async (req, fds) => {
+      const planned = await this.plan(req.file, req.argv, req.cwd);
+      if (!planned) {
+        await fds.closeAll();
+        throw new SpawnError("ENOENT");
+      }
+      const handle = await this.launch(planned, { env: req.env, cwd: req.cwd, fds, report, ppid });
+      return childHandle(handle);
+    };
+  }
+  forker(ppid, parent) {
+    return async (state, fds) => childHandle(this.start({ ...parent, cwd: state.cwd ?? parent.cwd, fds, ppid, fork: state }));
+  }
+  kill(pid, sig) {
+    if (pid < 0) return this.jobs.killGroup(-pid, sig);
+    const handle = this.processes.get(pid);
+    if (!handle) return false;
+    if (sig !== 0) handle.signal(sig);
+    return true;
+  }
+  async run(argv, options = {}) {
+    this.catalog = void 0;
+    const cwd = this.fs.resolvePath("/", options.cwd ?? "/");
+    const env = { PATH: "/usr/bin:/bin", HOME: "/", ...this.env, PWD: cwd, ...options.env };
+    const out = [];
+    const err = [];
+    const collect = (chunks, tee) => (bytes) => {
+      chunks.push(bytes);
+      tee?.(bytes);
+    };
+    const stdout = collect(out, options.onStdout);
+    const stderr = collect(err, options.onStderr);
+    const report = (message) => stderr(encoder3.encode(`${message}
+`));
+    const [file = ""] = argv;
+    await this.base.mkdir(cwd, { recursive: true });
+    const planned = await this.plan(file, argv, cwd);
+    if (!planned) {
+      report(`${file}: command not found`);
+      return { status: NOT_FOUND, stdout: concat2(out), stderr: concat2(err) };
+    }
+    const fds = new FdTable();
+    fds.installAt(0, options.stdin ? bytesSource(options.stdin) : nullFile());
+    fds.installAt(1, sinkFile(stdout));
+    fds.installAt(2, sinkFile(stderr));
+    const handle = await this.launch(planned, { env, cwd, fds, report });
+    const status = await handle.exited;
+    return { status, stdout: concat2(out), stderr: concat2(err) };
+  }
+};
+
+// src/serve.ts
+function serveKernel(port, deps) {
+  let launcher;
+  const reply = (id, body) => port.postMessage({ id, ...body });
+  async function handle(req) {
+    if (req.op === "init") {
+      launcher = (req.root ? Promise.resolve(req.root) : deps.storage()).then(
+        (root) => new Launcher({
+          fs: new OpfsFs(root),
+          createWorker: deps.createWorker,
+          ...req.modules ? { modules: req.modules } : {},
+          ...req.env ? { env: req.env } : {}
+        })
+      );
+      await launcher;
+      return true;
+    }
+    if (!launcher) throw new Error("the kernel is not initialized");
+    return (await launcher).run(req.argv, {
+      ...req.options,
+      onStdout: (bytes) => reply(req.id, { fd: 1, bytes }),
+      onStderr: (bytes) => reply(req.id, { fd: 2, bytes })
+    });
+  }
+  port.addEventListener("message", (event) => {
+    const req = event.data;
+    handle(req).then(
+      (result) => reply(req.id, { result }),
+      (err) => reply(req.id, { error: err instanceof Error ? err.message : String(err) })
+    );
+  });
+}
+
+// src/kernel-worker.ts
+var processWorker = new URL("./process-worker.js", import.meta.url);
+serveKernel(globalThis, {
+  storage: () => navigator.storage.getDirectory(),
+  createWorker: () => new Worker(processWorker, { type: "module" })
+});
+//# sourceMappingURL=kernel-worker.js.map