@ai-ecoverse/slicc-kernel 1.64.2 → 1.65.1

package/dist/node.js

@@ -2848,18 +2848,99 @@ function serveClient(port, host) {
   return { detach, closed: ended.promise };
 }
 
-// src/fs/meta.ts
+// src/fs/path-map.ts
 function parentOf2(path) {
+  if (path === "/" || path === "") return void 0;
+  const at = path.lastIndexOf("/");
+  return at <= 0 ? "/" : path.slice(0, at);
+}
+var PathMap = class {
+  values = /* @__PURE__ */ new Map();
+  children = /* @__PURE__ */ new Map();
+  get size() {
+    return this.values.size;
+  }
+  has(path) {
+    return this.values.has(path);
+  }
+  get(path) {
+    return this.values.get(path);
+  }
+  keys() {
+    return this.values.keys();
+  }
+  set(path, value) {
+    if (!this.values.has(path)) this.link(path);
+    this.values.set(path, value);
+    return this;
+  }
+  delete(path) {
+    if (!this.values.delete(path)) return false;
+    this.prune(path);
+    return true;
+  }
+  subtree(root) {
+    const out = [];
+    const stack = [root];
+    for (let path = stack.pop(); path !== void 0; path = stack.pop()) {
+      if (this.values.has(path)) out.push(path);
+      const below = this.children.get(path);
+      if (below) for (const child of below) stack.push(child);
+    }
+    return out;
+  }
+  entries() {
+    return this.values.entries();
+  }
+  deleteTree(root) {
+    const stack = [root];
+    for (let path = stack.pop(); path !== void 0; path = stack.pop()) {
+      this.values.delete(path);
+      const below = this.children.get(path);
+      if (below) for (const child of below) stack.push(child);
+      this.children.delete(path);
+    }
+    this.prune(root);
+  }
+  clear() {
+    this.values.clear();
+    this.children.clear();
+  }
+  link(path) {
+    for (let child = path, parent = parentOf2(path); parent !== void 0; ) {
+      const set2 = this.children.get(parent);
+      if (set2?.has(child)) return;
+      if (set2) set2.add(child);
+      else this.children.set(parent, /* @__PURE__ */ new Set([child]));
+      child = parent;
+      parent = parentOf2(parent);
+    }
+  }
+  prune(path) {
+    for (let child = path, parent = parentOf2(path); parent !== void 0; ) {
+      if (this.values.has(child) || this.children.has(child)) return;
+      const set2 = this.children.get(parent);
+      set2?.delete(child);
+      if (set2 && set2.size > 0) return;
+      this.children.delete(parent);
+      child = parent;
+      parent = parentOf2(parent);
+    }
+  }
+};
+
+// src/fs/meta.ts
+function parentOf3(path) {
   return path.slice(0, path.lastIndexOf("/")) || "/";
 }
 function moved(entry, path) {
-  return entry.link === void 0 ? { ...entry, path } : { ...entry, path, dir: parentOf2(path) };
+  return entry.link === void 0 ? { ...entry, path } : { ...entry, path, dir: parentOf3(path) };
 }
 function under(path, root) {
   return path === root || path.startsWith(`${root}/`);
 }
 var MemoryMeta = class {
-  entries = /* @__PURE__ */ new Map();
+  entries = new PathMap();
   async get(paths) {
     return paths.map((path) => this.entries.get(path));
   }
@@ -2872,7 +2953,7 @@ var MemoryMeta = class {
   }
   async move(from, to, root) {
     await this.remove([to]);
-    const carried = [...this.entries.values()].filter((entry) => under(entry.path, from));
+    const carried = this.entries.subtree(from).map((path) => this.entries.get(path));
     for (const entry of carried) this.entries.delete(entry.path);
     for (const entry of carried) {
       const path = to + entry.path.slice(from.length);
@@ -2881,18 +2962,16 @@ var MemoryMeta = class {
     this.entries.set(to, moved(root(carried.find((entry) => entry.path === from)), to));
   }
   async remove(paths) {
-    for (const key of [...this.entries.keys()]) {
-      if (paths.some((path) => under(key, path))) this.entries.delete(key);
-    }
+    for (const path of paths) this.entries.deleteTree(path);
   }
   async links(dir) {
-    return [...this.entries.values()].filter((entry) => entry.dir === dir);
+    return [...this.entries.entries()].map(([, e]) => e).filter((entry) => entry.dir === dir);
   }
   async under(path) {
-    return [...this.entries.values()].filter((entry) => under(entry.path, path));
+    return [...this.entries.entries()].map(([, e]) => e).filter((entry) => under(entry.path, path));
   }
   async all() {
-    return [...this.entries.values()];
+    return [...this.entries.entries()].map(([, e]) => e);
   }
 };
 
@@ -2947,7 +3026,7 @@ function missing(err) {
 function split(path) {
   return path.split("/").filter(Boolean);
 }
-function parentOf3(path) {
+function parentOf4(path) {
   return path.slice(0, path.lastIndexOf("/")) || "/";
 }
 function baseOf(path) {
@@ -3016,7 +3095,7 @@ function isHandle(child) {
 var OpfsFs = class {
   root;
   meta;
-  dirs = /* @__PURE__ */ new Map();
+  dirs = new PathMap();
   checked = /* @__PURE__ */ new WeakMap();
   channel;
   ranged;
@@ -3065,7 +3144,7 @@ var OpfsFs = class {
   async ownerAt(path, entry) {
     const own = ownOf(entry);
     if (own) return own;
-    return path === "/" ? { ...ROOT_OWNER } : this.handedTo(parentOf3(path));
+    return path === "/" ? { ...ROOT_OWNER } : this.handedTo(parentOf4(path));
   }
   async owned(stat, path, entry) {
     return this.owners ? { ...stat, ...await this.ownerAt(path, entry) } : stat;
@@ -3095,7 +3174,7 @@ var OpfsFs = class {
   async chown(path, change) {
     if (!this.owners) return;
     if (change.kind === "new") {
-      const at = resolvePath((await this.locate(parentOf3(path), true)).path, baseOf(path));
+      const at = resolvePath((await this.locate(parentOf4(path), true)).path, baseOf(path));
       const { uid = 0, gid = 0, mode } = change;
       return this.stampNew(at, { uid, gid, ...mode !== void 0 ? { mode } : {} }, false);
     }
@@ -3159,7 +3238,7 @@ var OpfsFs = class {
     return true;
   }
   forget(path) {
-    for (const key of [...this.dirs.keys()]) if (within(key, path)) this.dirs.delete(key);
+    this.dirs.deleteTree(path);
   }
   async inDir(path, op) {
     const dir = await this.dir(path);
@@ -3206,7 +3285,7 @@ var OpfsFs = class {
   async linkAlong(path) {
     for (const entry of await this.meta.get(prefixes(path))) {
       if (entry?.link === void 0) continue;
-      if (!await this.real(entry.path) && await this.real(parentOf3(entry.path))) return entry;
+      if (!await this.real(entry.path) && await this.real(parentOf4(entry.path))) return entry;
     }
     return void 0;
   }
@@ -3221,7 +3300,7 @@ var OpfsFs = class {
         if (!link2) throw err;
         if (link2.path === current && !follow2) return { path: current, link: link2 };
         const target = `${link2.link}${current.slice(link2.path.length)}`;
-        current = target.split("/").includes("..") ? await this.physical(parentOf3(link2.path), target, hops + 1) : resolvePath(parentOf3(link2.path), target);
+        current = target.split("/").includes("..") ? await this.physical(parentOf4(link2.path), target, hops + 1) : resolvePath(parentOf4(link2.path), target);
       }
     }
     throw fsError("ELOOP", path);
@@ -3411,8 +3490,8 @@ var OpfsFs = class {
       if (!missing(err)) throw err;
     }
     const [entry] = await this.meta.get([path]);
-    const wanted = entry?.link === void 0 ? path : resolvePath(parentOf3(path), entry.link);
-    return [resolvePath((await this.locate(parentOf3(wanted), true)).path, baseOf(wanted)), false];
+    const wanted = entry?.link === void 0 ? path : resolvePath(parentOf4(path), entry.link);
+    return [resolvePath((await this.locate(parentOf4(wanted), true)).path, baseOf(wanted)), false];
   }
   async fileFor(path) {
     const [target, existed] = await this.writeTarget(path);
@@ -3422,7 +3501,7 @@ var OpfsFs = class {
         dir,
         (parent) => parent.getFileHandle(name2, { create: true })
       );
-      if (!existed) this.touch(parentOf3(target));
+      if (!existed) this.touch(parentOf4(target));
       return [handle, existed, target];
     } catch (err) {
       const code = err?.name === "TypeMismatchError" ? "EISDIR" : null;
@@ -3492,9 +3571,9 @@ var OpfsFs = class {
         gid: owner.gid,
         ...mode ? { mode, parents: mode } : {}
       };
-      await this.mkdir(parentOf3(path), { recursive: true, ...above ? { owner: above } : {} });
+      await this.mkdir(parentOf4(path), { recursive: true, ...above ? { owner: above } : {} });
     }
-    const parent = await this.locate(parentOf3(path), true);
+    const parent = await this.locate(parentOf4(path), true);
     if (parent.handle?.kind !== "directory") throw fsError("ENOTDIR", path);
     await parent.handle.getDirectoryHandle(baseOf(path), { create: true });
     const made2 = `${parent.path === "/" ? "" : parent.path}/${baseOf(path)}`;
@@ -3523,7 +3602,7 @@ var OpfsFs = class {
       this.changed(found.path);
     }
     await this.meta.remove([found.path]);
-    this.touch(parentOf3(found.path));
+    this.touch(parentOf4(found.path));
   }
   links() {
     return false;
@@ -3535,7 +3614,7 @@ var OpfsFs = class {
     if (from === to) return;
     const source = await this.locate(from, false);
     this.forget(source.path);
-    const parent = await this.locate(parentOf3(to), true);
+    const parent = await this.locate(parentOf4(to), true);
     const destination = resolvePath(parent.path, baseOf(to));
     const sourceStat = await this.describe(source);
     if (sourceStat.isDirectory && within(destination, source.path)) throw fsError("EINVAL", to);
@@ -3563,7 +3642,7 @@ var OpfsFs = class {
     if (source.link) {
       if (target?.handle) await this.rm(destination);
       await this.meta.move(source.path, destination, carry);
-      this.touch(parentOf3(source.path), parent.path);
+      this.touch(parentOf4(source.path), parent.path);
       return;
     }
     const dir = parent.handle;
@@ -3585,7 +3664,7 @@ var OpfsFs = class {
     }
     if (copied) await this.restamp(destination, timed2);
     this.changed(source.path, destination);
-    this.touch(parentOf3(source.path), parent.path);
+    this.touch(parentOf4(source.path), parent.path);
   }
   async modified(path) {
     const handle = await this.handle(path);
@@ -3631,7 +3710,7 @@ var OpfsFs = class {
     for await (const child of handle.values()) await this.copy(child, target, child.name);
   }
   async symlink(target, path, owner) {
-    const parent = await this.locate(parentOf3(path), true);
+    const parent = await this.locate(parentOf4(path), true);
     if (parent.handle?.kind !== "directory") throw fsError("ENOTDIR", path);
     const at = resolvePath(parent.path, baseOf(path));
     if (await this.locate(at, false).then(
@@ -3707,7 +3786,7 @@ var OpfsFs = class {
     let removed = 0;
     for (const entry of await this.meta.all()) {
       const real = await this.real(entry.path);
-      const stale = entry.link === void 0 ? !real : real || !await this.real(parentOf3(entry.path));
+      const stale = entry.link === void 0 ? !real : real || !await this.real(parentOf4(entry.path));
       if (!stale) continue;
       await this.meta.update(entry.path, () => void 0);
       removed++;
@@ -3778,7 +3857,7 @@ function webLocks() {
   return globalThis.navigator?.locks;
 }
 var within2 = (path, target) => path === target || target === "/" || path.startsWith(`${target}/`);
-var parentOf4 = (path) => path.slice(0, path.lastIndexOf("/")) || "/";
+var parentOf5 = (path) => path.slice(0, path.lastIndexOf("/")) || "/";
 var lockName = (instance) => `slicc-unlinked:${instance}`;
 var dirOf = (root) => root === "/" ? `/${UNLINKED_DIR}` : `${root}/${UNLINKED_DIR}`;
 var PathGate = class {
@@ -3911,7 +3990,7 @@ var UnlinkedKeeper = class {
           await this.serial(async () => {
             await Promise.allSettled([this.fs.rename(file.hidden, path)]);
             this.unlinkedName(file.hidden);
-            await this.tidy(parentOf4(file.hidden));
+            await this.tidy(parentOf5(file.hidden));
           });
         }
         done4();
@@ -3952,7 +4031,7 @@ var UnlinkedKeeper = class {
     }
     await this.fs.rm(hidden).catch(() => void 0);
     this.unlinkedName(hidden);
-    await this.tidy(parentOf4(hidden));
+    await this.tidy(parentOf5(hidden));
   }
   async linkedName(hidden) {
     if (!mayLink(this.fs, hidden)) return;
@@ -5148,10 +5227,10 @@ async function physicalPathAsync(fs, path) {
 // src/fs/watch.ts
 var WATCH_BATCH_LIMIT = 1e3;
 var under2 = (path, dir) => dir === "/" || path.startsWith(`${dir}/`);
-var parentOf5 = (path) => path.slice(0, path.lastIndexOf("/")) || "/";
+var parentOf6 = (path) => path.slice(0, path.lastIndexOf("/")) || "/";
 function touches(watcher, changed) {
   return watcher.paths.some(
-    (watched) => changed === watched || under2(watched, changed) || (watcher.recursive ? under2(changed, watched) : parentOf5(changed) === watched)
+    (watched) => changed === watched || under2(watched, changed) || (watcher.recursive ? under2(changed, watched) : parentOf6(changed) === watched)
   );
 }
 var FsWatchers = class {
@@ -5264,6 +5343,23 @@ var CONTINUED_STATUS = 65535;
 function waitStatus(code, termsig) {
   return termsig ? termsig & 127 : (code & 255) << 8;
 }
+function capturing(chunks2, max = Number.POSITIVE_INFINITY, overflow) {
+  let size = 0;
+  let over = false;
+  return (bytes) => {
+    if (over) return;
+    const room = max - size;
+    if (bytes.length > room) {
+      over = true;
+      if (room > 0) chunks2.push(bytes.slice(0, room));
+      size = max;
+      overflow?.();
+      return;
+    }
+    chunks2.push(bytes);
+    size += bytes.length;
+  };
+}
 function concat2(chunks2) {
   const out = new Uint8Array(chunks2.reduce((n, c) => n + c.length, 0));
   let offset = 0;
@@ -5297,15 +5393,15 @@ var ChildTable = class {
     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 inherit2) {
-        if (slot.fd <= 2) continue;
-        if ("device" in slot) {
-          fds.installAt(slot.fd, deviceFile(slot.device, slot.access));
+      for (const [n, slot2] of stdio.entries()) fds.installAt(n, this.openSlot(slot2, n, captured));
+      for (const slot2 of inherit2) {
+        if (slot2.fd <= 2) continue;
+        if ("device" in slot2) {
+          fds.installAt(slot2.fd, deviceFile(slot2.device, slot2.access));
           continue;
         }
-        fds.installAt(slot.fd, this.parentFds.get(slot.kernel).retain());
-        if (slot.flags !== void 0) fds.setStatusFlags(slot.fd, slot.flags);
+        fds.installAt(slot2.fd, this.parentFds.get(slot2.kernel).retain());
+        if (slot2.flags !== void 0) fds.setStatusFlags(slot2.fd, slot2.flags);
       }
     } catch (e) {
       await fds.closeAll();
@@ -5346,15 +5442,15 @@ var ChildTable = class {
     this.watchers.set(pid, listener);
     if (child.stoppedBy !== void 0) listener("stopped", child.stoppedBy);
   }
-  openSlot(slot, n, captured) {
-    if ("fd" in slot) return this.parentFds.get(slot.fd).retain();
-    if ("input" in slot) return bytesSource(slot.input);
-    if ("device" in slot) return deviceFile(slot.device, slot.access);
-    if ("dir" in slot) return heldFile({ dir: slot.dir });
-    if ("capture" in slot) {
+  openSlot(slot2, n, captured) {
+    if ("fd" in slot2) return this.parentFds.get(slot2.fd).retain();
+    if ("input" in slot2) return bytesSource(slot2.input);
+    if ("device" in slot2) return deviceFile(slot2.device, slot2.access);
+    if ("dir" in slot2) return heldFile({ dir: slot2.dir });
+    if ("capture" in slot2) {
       const chunks2 = [];
       captured.set(n, chunks2);
-      return sinkFile((bytes) => chunks2.push(bytes));
+      return sinkFile(capturing(chunks2, slot2.max, slot2.overflow));
     }
     return deviceFile("null");
   }
@@ -5421,11 +5517,11 @@ var ChildTable = class {
   pids() {
     return [...this.children.keys()];
   }
-  captured(pid, slot) {
+  captured(pid, slot2) {
     const slots = this.leftovers.get(pid);
-    const chunks2 = slots?.get(slot);
+    const chunks2 = slots?.get(slot2);
     if (!slots || !chunks2) return new Uint8Array(0);
-    slots.delete(slot);
+    slots.delete(slot2);
     if (slots.size === 0) this.leftovers.delete(pid);
     return concat2(chunks2);
   }
@@ -5711,7 +5807,7 @@ var HeldPaths = class extends Map {
     return this.revoked.has(path);
   }
 };
-var parentOf6 = (path) => path.slice(0, path.lastIndexOf("/")) || "/";
+var parentOf7 = (path) => path.slice(0, path.lastIndexOf("/")) || "/";
 var readonly = (mount) => mount.caps.readonly === true || mount.options.ro !== void 0;
 function inodeless(mount, attr2) {
   if (attr2.ino !== void 0) return false;
@@ -5991,7 +6087,7 @@ var MountTable = class {
     mount.epoch++;
     for (const key of [...mount.attrs.keys()]) if (within3(key, path)) mount.attrs.delete(key);
     mount.lists.delete(path);
-    mount.lists.delete(parentOf6(path));
+    mount.lists.delete(parentOf7(path));
     for (const key of [...mount.lists.keys()]) if (within3(key, path)) mount.lists.delete(key);
   }
   async getattr(mount, path, rel2, settled = false) {
@@ -6067,7 +6163,7 @@ var MountFs = class {
     if (attr2.kind !== "symlink") return real;
     if (hops >= MAX_LINKS6) throw errnoError("ELOOP", path);
     const target = await found.mount.conn.call({ op: "readlink", path: found.rel });
-    return this.follow(this.base.resolvePath(parentOf6(real), target), hops + 1, create);
+    return this.follow(this.base.resolvePath(parentOf7(real), target), hops + 1, create);
   }
   async open(mount, rel2, write, owner) {
     return await mount.conn.call({
@@ -6083,8 +6179,8 @@ var MountFs = class {
   async driverOwner(found, real, owner, directory) {
     const { mount, rel: rel2 } = found;
     if (!owner || !mount.owners || !mount.caps.owners) return void 0;
-    const dir = parentOf6(real);
-    const above = statOf(await this.table.getattr(mount, dir, parentOf6(rel2)), dir, mount);
+    const dir = parentOf7(real);
+    const above = statOf(await this.table.getattr(mount, dir, parentOf7(rel2)), dir, mount);
     const setgid = (above.mode & S_ISGID4) !== 0;
     let mode = owner.mode;
     if (directory && setgid) mode = (mode ?? 493) | S_ISGID4;
@@ -6423,7 +6519,7 @@ var MountFs = class {
   }
   async named(path) {
     const at = normalizePath(path);
-    return joinName(await realDir(this, parentOf6(at)), at.slice(at.lastIndexOf("/") + 1));
+    return joinName(await realDir(this, parentOf7(at)), at.slice(at.lastIndexOf("/") + 1));
   }
   async link(source, target, follow2 = false) {
     const from = follow2 ? await realTarget(this, normalizePath(source)) : await this.named(source);
@@ -7686,6 +7782,7 @@ var HOST_OPS = [
   "async-resolve",
   "async-hold",
   "async-cancel",
+  "async-settle",
   "async-close"
 ];
 var json3 = (value) => ({ ok: true, kind: "json", json: value });
@@ -7717,12 +7814,16 @@ var LockTable = class {
     for (const path of [...this.held.keys()]) this.unlock(pid, path);
   }
 };
+var KEPT_OPS = /* @__PURE__ */ new Set(["fd-write"]);
+var unknownSettled = false;
 var AsyncOps = class {
   next = 1;
   results = /* @__PURE__ */ new Map();
   ready = [];
   running = /* @__PURE__ */ new Map();
   waiters = /* @__PURE__ */ new Set();
+  taken = /* @__PURE__ */ new Map();
+  kept = /* @__PURE__ */ new Set();
   closed = false;
   run;
   onReady;
@@ -7732,6 +7833,7 @@ var AsyncOps = class {
   }
   submit(req) {
     const id2 = this.hold();
+    if (KEPT_OPS.has(req.op)) this.kept.add(id2);
     const running = new AbortController();
     this.running.set(id2, running);
     this.run(req, running.signal).then(
@@ -7755,9 +7857,26 @@ var AsyncOps = class {
     const result = this.results.get(id2);
     if (!result) throw new KernelError("EAGAIN");
     this.forget(id2);
+    if (this.kept.delete(id2)) this.taken.set(id2, result);
     return result;
   }
+  ack(ids) {
+    for (const id2 of ids) this.taken.delete(id2);
+  }
+  async settle(ids) {
+    const never = new AbortController().signal;
+    while (ids.some((id2) => this.running.has(id2))) await this.sleep(void 0, never);
+    return ids.map((id2) => {
+      const result = this.results.get(id2) ?? this.taken.get(id2) ?? null;
+      if (!result && !unknownSettled) {
+        unknownSettled = true;
+        console.warn(`async-settle: no result for op ${id2}; its write counts as made`);
+      }
+      return result;
+    });
+  }
   cancel(id2) {
+    this.kept.delete(id2);
     this.running.get(id2)?.abort();
     this.forget(id2);
   }
@@ -7833,6 +7952,7 @@ async function hostSyscall(req, ctx) {
       return done2;
     case "async-submit":
       if (!ctx.valid(req.req)) throw new KernelError("EINVAL");
+      if (req.ack) ctx.ops.ack(req.ack);
       return json3(ctx.ops.submit(req.req));
     case "async-wait":
       return json3(await ctx.ops.wait(req.timeoutMs, ctx.blocking));
@@ -7845,6 +7965,8 @@ async function hostSyscall(req, ctx) {
     case "async-cancel":
       ctx.ops.cancel(req.id);
       return done2;
+    case "async-settle":
+      return json3(await ctx.ops.settle(req.ids));
     case "async-close":
       ctx.ops.close();
       return done2;
@@ -9673,8 +9795,8 @@ var KernelTty = class {
   get canonical() {
     return (this.termios.c_lflag & ICANON) !== 0;
   }
-  cc(slot) {
-    return this.termios.c_cc[slot] ?? 0;
+  cc(slot2) {
+    return this.termios.c_cc[slot2] ?? 0;
   }
   key(input) {
     const { c_iflag, c_lflag } = this.termios;
@@ -10029,6 +10151,84 @@ function ptySyscall(req, ctx) {
   }
 }
 
+// src/kernel/run-child.ts
+var RUN_CAPTURE_CAP = 64 * 1024 * 1024;
+var RUN_MAX_BUFFER = 1024 * 1024;
+function capLimit(maxBuffer) {
+  const asked = maxBuffer === void 0 ? RUN_MAX_BUFFER : maxBuffer;
+  return Math.max(0, Math.min(asked, RUN_CAPTURE_CAP));
+}
+function slot(how, n, extra) {
+  if (how === "inherit") return { fd: n };
+  if (how === "ignore") return { none: true };
+  return extra;
+}
+function frame2(outcome, out, err) {
+  const head = new TextEncoder().encode(JSON.stringify(outcome));
+  const bytes = new Uint8Array(4 + head.length + out.length + err.length);
+  new DataView(bytes.buffer).setUint32(0, head.length, true);
+  bytes.set(head, 4);
+  bytes.set(out, 4 + head.length);
+  bytes.set(err, 4 + head.length + out.length);
+  return bytes;
+}
+async function reaped(deps, pid) {
+  for (; ; ) {
+    try {
+      return (await deps.children.wait(pid, false, deps.interrupt()))[1];
+    } catch (e) {
+      if (!(e instanceof KernelError && e.code === "EINTR") || deps.dying()) throw e;
+    }
+  }
+}
+async function runChild(req, deps) {
+  const max = capLimit(req.maxBuffer);
+  let failure;
+  let pid = 0;
+  const kill = () => void Promise.allSettled([deps.kill(pid, req.killSignal)]);
+  const stop = (code) => {
+    if (failure !== void 0) return;
+    failure = code;
+    if (pid !== 0) kill();
+  };
+  const capture = () => ({ capture: true, max, overflow: () => stop("ENOBUFS") });
+  const stdio = [
+    slot(req.stdin, 0, { input: req.input ?? new Uint8Array(0) }),
+    slot(req.stdout, 1, capture()),
+    slot(req.stderr, 2, capture())
+  ];
+  try {
+    pid = await deps.children.spawn(
+      { file: req.file, argv: req.argv, env: req.env, cwd: req.cwd },
+      stdio
+    );
+  } catch (e) {
+    if (!(e instanceof SpawnError)) throw e;
+    const outcome2 = { pid: 0, status: null, error: { code: e.code }, out: 0, err: 0 };
+    return frame2(outcome2, new Uint8Array(0), new Uint8Array(0));
+  }
+  if (failure !== void 0) kill();
+  const timer = req.timeoutMs !== void 0 && req.timeoutMs > 0 ? setTimeout(() => stop("ETIMEDOUT"), req.timeoutMs) : void 0;
+  let status;
+  try {
+    status = await reaped(deps, pid);
+  } finally {
+    clearTimeout(timer);
+  }
+  const out = deps.children.captured(pid, 1);
+  const err = deps.children.captured(pid, 2);
+  const termsig = status & 127;
+  const outcome = {
+    pid,
+    status: termsig ? null : status >> 8 & 255,
+    ...termsig ? { signal: termsig } : {},
+    ...failure !== void 0 ? { error: { code: failure } } : {},
+    out: out.length,
+    err: err.length
+  };
+  return frame2(outcome, out, err);
+}
+
 // src/kernel/select.ts
 function ready(fds, read, write) {
   const hangup = /* @__PURE__ */ new Set();
@@ -10825,6 +11025,8 @@ var SYSCALL_OPS = /* @__PURE__ */ new Set([
   "proc-spawn",
   "proc-wait",
   "proc-captured",
+  "proc-run",
+  "proc-exit",
   "proc-fork",
   "proc-kill",
   "thread-kill",
@@ -10945,6 +11147,14 @@ var WasmProcess = class {
     else this.adoptExec(pid);
     return pid;
   }
+  run(req) {
+    return runChild(req, {
+      children: this.children,
+      kill: (pid, sig) => this.options.kill?.(pid, sig),
+      interrupt: () => this.interrupt.signal,
+      dying: () => this.dying
+    });
+  }
   adoptExec(pid) {
     this.execChild = pid;
     this.children.watch(pid, (state, sig) => state === "stopped" ? this.stop(sig) : this.cont());
@@ -11493,6 +11703,12 @@ var WasmProcess = class {
         return { ok: true, kind: "json", json: await this.spawn(req) };
       case "proc-wait":
         return { ok: true, kind: "json", json: await this.procWait(req, cancelled) };
+      case "proc-run":
+        return { ok: true, kind: "bytes", bytes: await this.run(req) };
+      case "proc-exit":
+        if (!this.options.exitNow) throw new KernelError("ENOSYS");
+        this.options.exitNow(req.status & 255);
+        return DYING;
       case "proc-identity":
         return { ok: true, kind: "json", json: await this.options.identity?.() ?? null };
       case "proc-exec": {
@@ -11899,6 +12115,7 @@ function processOptions(opts, header4, hooks, created3) {
     hasPending: () => Atomics.load(header4, SAB_I_SIGNALS) !== 0 || Atomics.load(header4, SAB_I_TIMERS) !== 0,
     raise: hooks.raise,
     threadKill: hooks.threadKill,
+    ...hooks.exitNow ? { exitNow: hooks.exitNow } : {},
     ...opts.program.abi === "wasi" || opts.program.abi === "js" ? { pendingBits: () => Atomics.load(header4, SAB_I_SIGNALS) } : {}
   };
 }
@@ -11915,7 +12132,8 @@ function spawnWasmProcess(opts) {
       header4,
       {
         raise: (sig) => signal(sig),
-        threadKill: (tid, sig) => killThread(threadSignals.get(tid), process2.signalMasks().caught, sig)
+        threadKill: (tid, sig) => killThread(threadSignals.get(tid), process2.signalMasks().caught, sig),
+        ...opts.program.abi === "js" ? { exitNow: (code) => exitNow(code) } : {}
       },
       created3
     )
@@ -11956,6 +12174,9 @@ function spawnWasmProcess(opts) {
       () => settle(code)
     );
   };
+  const exitNow = (code) => {
+    queueMicrotask(() => finish(...dying.status(code)));
+  };
   const handle = (data) => {
     if (data?.type === WASM_PROCESS_EXIT) {
       finish(...dying.status(data.code));
@@ -12691,15 +12912,15 @@ function granted(handle) {
   );
 }
 function removableMedium(onLost, open = (handle) => new OpfsFs(handle)) {
-  const slot = mediumSlot(
+  const slot2 = mediumSlot(
     async (err, handle) => denied(err) && !await granted(handle),
     onLost
   );
   return {
-    handlers: slot.handlers,
-    present: slot.present,
-    insert: (handle) => slot.insert(handle, kernelFsHandlers(open(handle))),
-    eject: slot.eject
+    handlers: slot2.handlers,
+    present: slot2.present,
+    insert: (handle) => slot2.insert(handle, kernelFsHandlers(open(handle))),
+    eject: slot2.eject
   };
 }
 
@@ -13577,7 +13798,7 @@ function grantConnect(hook, fetch2, liveness = {}) {
 async function openHostfs(spec, connect, timing = {}) {
   const readonly2 = spec.options?.ro !== void 0;
   const { port1, port2 } = new MessageChannel();
-  const slot = mediumSlot(
+  const slot2 = mediumSlot(
     async (err) => unreachable(err),
     () => watching.kick()
   );
@@ -13590,7 +13811,7 @@ async function openHostfs(spec, connect, timing = {}) {
   });
   const served = serveFilesystem(
     port2,
-    { ...slot.handlers, mount: ranged2 },
+    { ...slot2.handlers, mount: ranged2 },
     {
       symlinks: true,
       chmod: true,
@@ -13604,12 +13825,12 @@ async function openHostfs(spec, connect, timing = {}) {
       connect: () => connect(spec.source, { readonly: readonly2 }),
       up(client) {
         active = timed(client, timing.callMs ?? HOSTFS_CALL_MS);
-        slot.insert(client, handlers);
+        slot2.insert(client, handlers);
         served.invalidate(true);
       },
       event: (event) => served.invalidate(invalidation(event)),
       down() {
-        slot.eject();
+        slot2.eject();
         served.invalidate(true);
       },
       ...timing
@@ -13619,7 +13840,7 @@ async function openHostfs(spec, connect, timing = {}) {
   await watching.ready;
   return {
     port: port1,
-    present: slot.present,
+    present: slot2.present,
     dispose() {
       stop.abort();
       port1.close();
@@ -14922,16 +15143,16 @@ var Launcher = class {
   }
   async insert(target, handle, source) {
     const at = normalizePath(target);
-    const slot = this.removable.get(at);
-    if (!slot) throw fsError("EINVAL", `${at} is not a removable mount`);
-    if (source !== void 0 && source !== `fsa:${slot.id}`) {
+    const slot2 = this.removable.get(at);
+    if (!slot2) throw fsError("EINVAL", `${at} is not a removable mount`);
+    if (source !== void 0 && source !== `fsa:${slot2.id}`) {
       throw fsError("EINVAL", `${at} is no longer the drive ${source}`);
     }
     if (!await granted(handle)) throw fsError("EACCES", `${at}: no permission for this folder`);
-    this.inserted.set(slot.id, handle);
-    await this.media.put(slot.id, handle);
-    slot.medium.insert(handle);
-    slot.served.invalidate(true);
+    this.inserted.set(slot2.id, handle);
+    await this.media.put(slot2.id, handle);
+    slot2.medium.insert(handle);
+    slot2.served.invalidate(true);
     void this.unlinked.sweep(at);
   }
   umount(target, detach = false) {