@ai-ecoverse/slicc-kernel 1.64.2 → 1.65.1

package/dist/kernel-worker.js

@@ -1,18 +1,99 @@
+// src/fs/path-map.ts
+function parentOf(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 = parentOf(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 = parentOf(parent);
+    }
+  }
+  prune(path) {
+    for (let child = path, parent = parentOf(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 = parentOf(parent);
+    }
+  }
+};
+
 // src/fs/meta.ts
 var META_DB = "slicc-kernel";
 var META_VERSION = 1;
 var META_STORE = "entries";
-function parentOf(path) {
+function parentOf2(path) {
   return path.slice(0, path.lastIndexOf("/")) || "/";
 }
 function moved(entry, path) {
-  return entry.link === void 0 ? { ...entry, path } : { ...entry, path, dir: parentOf(path) };
+  return entry.link === void 0 ? { ...entry, path } : { ...entry, path, dir: parentOf2(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));
   }
@@ -25,7 +106,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);
@@ -34,18 +115,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);
   }
 };
 function descendants(path) {
@@ -59,7 +138,7 @@ function settle(transaction, value) {
 }
 var IndexedDbMeta = class {
   db;
-  cache = /* @__PURE__ */ new Map();
+  cache = new PathMap();
   channel;
   generation = 0;
   constructor(db) {
@@ -72,9 +151,7 @@ var IndexedDbMeta = class {
   drop({ paths = [], trees = [] }) {
     this.generation++;
     for (const path of paths) this.cache.delete(path);
-    for (const key of [...this.cache.keys()]) {
-      if (trees.some((tree2) => under(key, tree2))) this.cache.delete(key);
-    }
+    for (const tree2 of trees) this.cache.deleteTree(tree2);
   }
   changed(invalidation2) {
     this.drop(invalidation2);
@@ -327,7 +404,7 @@ function missing(err) {
 function split(path) {
   return path.split("/").filter(Boolean);
 }
-function parentOf2(path) {
+function parentOf3(path) {
   return path.slice(0, path.lastIndexOf("/")) || "/";
 }
 function baseOf(path) {
@@ -400,7 +477,7 @@ function isHandle(child) {
 var OpfsFs = class {
   root;
   meta;
-  dirs = /* @__PURE__ */ new Map();
+  dirs = new PathMap();
   checked = /* @__PURE__ */ new WeakMap();
   channel;
   ranged;
@@ -449,7 +526,7 @@ var OpfsFs = class {
   async ownerAt(path, entry) {
     const own = ownOf(entry);
     if (own) return own;
-    return path === "/" ? { ...ROOT_OWNER } : this.handedTo(parentOf2(path));
+    return path === "/" ? { ...ROOT_OWNER } : this.handedTo(parentOf3(path));
   }
   async owned(stat, path, entry) {
     return this.owners ? { ...stat, ...await this.ownerAt(path, entry) } : stat;
@@ -479,7 +556,7 @@ var OpfsFs = class {
   async chown(path, change) {
     if (!this.owners) return;
     if (change.kind === "new") {
-      const at = resolvePath((await this.locate(parentOf2(path), true)).path, baseOf(path));
+      const at = resolvePath((await this.locate(parentOf3(path), true)).path, baseOf(path));
       const { uid = 0, gid = 0, mode } = change;
       return this.stampNew(at, { uid, gid, ...mode !== void 0 ? { mode } : {} }, false);
     }
@@ -543,7 +620,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);
@@ -590,7 +667,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(parentOf2(entry.path))) return entry;
+      if (!await this.real(entry.path) && await this.real(parentOf3(entry.path))) return entry;
     }
     return void 0;
   }
@@ -605,7 +682,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(parentOf2(link2.path), target, hops + 1) : resolvePath(parentOf2(link2.path), target);
+        current = target.split("/").includes("..") ? await this.physical(parentOf3(link2.path), target, hops + 1) : resolvePath(parentOf3(link2.path), target);
       }
     }
     throw fsError("ELOOP", path);
@@ -795,8 +872,8 @@ var OpfsFs = class {
       if (!missing(err)) throw err;
     }
     const [entry] = await this.meta.get([path]);
-    const wanted = entry?.link === void 0 ? path : resolvePath(parentOf2(path), entry.link);
-    return [resolvePath((await this.locate(parentOf2(wanted), true)).path, baseOf(wanted)), false];
+    const wanted = entry?.link === void 0 ? path : resolvePath(parentOf3(path), entry.link);
+    return [resolvePath((await this.locate(parentOf3(wanted), true)).path, baseOf(wanted)), false];
   }
   async fileFor(path) {
     const [target, existed] = await this.writeTarget(path);
@@ -806,7 +883,7 @@ var OpfsFs = class {
         dir,
         (parent) => parent.getFileHandle(name2, { create: true })
       );
-      if (!existed) this.touch(parentOf2(target));
+      if (!existed) this.touch(parentOf3(target));
       return [handle, existed, target];
     } catch (err) {
       const code = err?.name === "TypeMismatchError" ? "EISDIR" : null;
@@ -876,9 +953,9 @@ var OpfsFs = class {
         gid: owner.gid,
         ...mode ? { mode, parents: mode } : {}
       };
-      await this.mkdir(parentOf2(path), { recursive: true, ...above ? { owner: above } : {} });
+      await this.mkdir(parentOf3(path), { recursive: true, ...above ? { owner: above } : {} });
     }
-    const parent = await this.locate(parentOf2(path), true);
+    const parent = await this.locate(parentOf3(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)}`;
@@ -907,7 +984,7 @@ var OpfsFs = class {
       this.changed(found.path);
     }
     await this.meta.remove([found.path]);
-    this.touch(parentOf2(found.path));
+    this.touch(parentOf3(found.path));
   }
   links() {
     return false;
@@ -919,7 +996,7 @@ var OpfsFs = class {
     if (from === to) return;
     const source = await this.locate(from, false);
     this.forget(source.path);
-    const parent = await this.locate(parentOf2(to), true);
+    const parent = await this.locate(parentOf3(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);
@@ -947,7 +1024,7 @@ var OpfsFs = class {
     if (source.link) {
       if (target?.handle) await this.rm(destination);
       await this.meta.move(source.path, destination, carry);
-      this.touch(parentOf2(source.path), parent.path);
+      this.touch(parentOf3(source.path), parent.path);
       return;
     }
     const dir = parent.handle;
@@ -969,7 +1046,7 @@ var OpfsFs = class {
     }
     if (copied) await this.restamp(destination, timed2);
     this.changed(source.path, destination);
-    this.touch(parentOf2(source.path), parent.path);
+    this.touch(parentOf3(source.path), parent.path);
   }
   async modified(path) {
     const handle = await this.handle(path);
@@ -1015,7 +1092,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(parentOf2(path), true);
+    const parent = await this.locate(parentOf3(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(
@@ -1091,7 +1168,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(parentOf2(entry.path));
+      const stale = entry.link === void 0 ? !real : real || !await this.real(parentOf3(entry.path));
       if (!stale) continue;
       await this.meta.update(entry.path, () => void 0);
       removed++;
@@ -1262,7 +1339,7 @@ function versionError(theirs) {
 
 // src/fs/walk.ts
 var MAX_LINKS2 = 40;
-function parentOf3(path) {
+function parentOf4(path) {
   return path.slice(0, path.lastIndexOf("/")) || "/";
 }
 async function mustBeDir(fs, path) {
@@ -1280,7 +1357,7 @@ async function realDir(fs, dir, budget = { hops: 0 }) {
     const part = queue.shift();
     if (part === ".") continue;
     if (part === "..") {
-      at = parentOf3(at);
+      at = parentOf4(at);
       continue;
     }
     const next2 = at === "/" ? `/${part}` : `${at}/${part}`;
@@ -1302,7 +1379,7 @@ function joinName(dir, name2) {
 }
 async function realTarget(fs, path) {
   const budget = { hops: 0 };
-  let dir = await realDir(fs, parentOf3(path), budget);
+  let dir = await realDir(fs, parentOf4(path), budget);
   let name2 = path.slice(path.lastIndexOf("/") + 1);
   for (; ; ) {
     const link2 = await linkOf(fs, joinName(dir, name2));
@@ -1310,7 +1387,7 @@ async function realTarget(fs, path) {
     if (budget.hops >= MAX_LINKS2) throw fsError("ELOOP", path);
     budget.hops++;
     const target = link2.startsWith("/") ? link2 : joinName(dir, link2);
-    dir = await realDir(fs, parentOf3(target), budget);
+    dir = await realDir(fs, parentOf4(target), budget);
     name2 = target.slice(target.lastIndexOf("/") + 1);
   }
   return joinName(dir, name2);
@@ -1384,7 +1461,7 @@ async function walk(fs, cred, path, follow2) {
     if (!dir) return { path: joinName(at, [part, ...queue].join("/")), perm: void 0 };
     if (!permits(cred, dir, X_OK)) return { path, perm: void 0, denied: at };
     if (part === "..") {
-      at = parentOf3(at);
+      at = parentOf4(at);
       continue;
     }
     const next2 = joinName(at, part);
@@ -1506,17 +1583,17 @@ async function stickyEntry(g, op, path, dir) {
 }
 async function inParent(g, op, path, old = false) {
   if (old === "replaced") {
-    const dir2 = await need(g, op, parentOf3(path), W_OK | X_OK, DIR, path);
+    const dir2 = await need(g, op, parentOf4(path), W_OK | X_OK, DIR, path);
     return dir2.denied === void 0 ? stickyEntry(g, op, path, dir2) : void 0;
   }
-  if (!old) return void await need(g, op, parentOf3(path), W_OK | X_OK, DIR, path);
-  const dir = await access(g.fs, g.cred, parentOf3(path), W_OK | X_OK, DIR);
+  if (!old) return void await need(g, op, parentOf4(path), W_OK | X_OK, DIR, path);
+  const dir = await access(g.fs, g.cred, parentOf4(path), W_OK | X_OK, DIR);
   if (dir.denied === void 0) return stickyEntry(g, op, path, dir);
   const lookup = dir.denied === dir.path && dir.perm && permits(g.cred, dir.perm, X_OK);
   if (!lookup || await present(g.fs, entryIn(dir, path), false)) deny(g, op, path);
 }
 async function makeIn(g, op, path) {
-  for (let dir = parentOf3(path); ; dir = parentOf3(dir)) {
+  for (let dir = parentOf4(path); ; dir = parentOf4(dir)) {
     const walked = await access(g.fs, g.cred, dir, W_OK | X_OK, DIR);
     if (walked.denied !== void 0) {
       if (!await present(g.fs, path, true)) deny(g, op, path);
@@ -1544,7 +1621,7 @@ async function renamable(g, from, to) {
   if (from === to) return void await need(g, "rename", from, 0, { follow: false });
   await inParent(g, "rename", from, true);
   await inParent(g, "rename", to, "replaced");
-  if (g.cred.euid === 0 || parentOf3(from) === parentOf3(to)) return;
+  if (g.cred.euid === 0 || parentOf4(from) === parentOf4(to)) return;
   const st = await g.fs.lstat(from).catch(() => void 0);
   if (st?.isDirectory && !permits(g.cred, permOf(st), W_OK)) deny(g, "rename", from);
 }
@@ -1598,7 +1675,7 @@ async function writable(g, op, path) {
 }
 async function creatable(g, op, path) {
   const target = await need(g, op, path, 0);
-  if (target.denied === void 0) await need(g, op, parentOf3(target.path), W_OK | X_OK, DIR, path);
+  if (target.denied === void 0) await need(g, op, parentOf4(target.path), W_OK | X_OK, DIR, path);
 }
 async function openable(g, op, path, want, create) {
   const st = create ? await g.fs.stat(path).catch(() => void 0) : void 0;
@@ -3516,7 +3593,7 @@ function cdpRegistry(send, gone) {
 function visibleTo(g, notify) {
   if (!g?.dac.enforcing) return notify;
   let queue = Promise.resolve();
-  const seen = async (path) => (await access(g.fs, g.cred, parentOf3(path), R_OK | X_OK, { directory: true })).denied === void 0;
+  const seen = async (path) => (await access(g.fs, g.cred, parentOf4(path), R_OK | X_OK, { directory: true })).denied === void 0;
   return (change) => {
     queue = queue.then(async () => {
       if (!("paths" in change)) return notify(change);
@@ -6504,7 +6581,7 @@ function webLocks() {
   return globalThis.navigator?.locks;
 }
 var within3 = (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 {
@@ -6637,7 +6714,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();
@@ -6678,7 +6755,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;
@@ -6723,10 +6800,10 @@ var UnlinkedKeeper = class {
 // 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 {
@@ -6839,6 +6916,23 @@ var CONTINUED_STATUS = 65535;
 function waitStatus(code, termsig) {
   return termsig ? termsig & 127 : (code & 255) << 8;
 }
+function capturing(chunks, 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) chunks.push(bytes.slice(0, room));
+      size = max;
+      overflow?.();
+      return;
+    }
+    chunks.push(bytes);
+    size += bytes.length;
+  };
+}
 function concat3(chunks) {
   const out = new Uint8Array(chunks.reduce((n, c) => n + c.length, 0));
   let offset = 0;
@@ -6872,15 +6966,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();
@@ -6921,15 +7015,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 chunks = [];
       captured.set(n, chunks);
-      return sinkFile((bytes) => chunks.push(bytes));
+      return sinkFile(capturing(chunks, slot2.max, slot2.overflow));
     }
     return deviceFile("null");
   }
@@ -6996,11 +7090,11 @@ var ChildTable = class {
   pids() {
     return [...this.children.keys()];
   }
-  captured(pid, slot) {
+  captured(pid, slot2) {
     const slots = this.leftovers.get(pid);
-    const chunks = slots?.get(slot);
+    const chunks = slots?.get(slot2);
     if (!slots || !chunks) return new Uint8Array(0);
-    slots.delete(slot);
+    slots.delete(slot2);
     if (slots.size === 0) this.leftovers.delete(pid);
     return concat3(chunks);
   }
@@ -7286,7 +7380,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;
@@ -7566,7 +7660,7 @@ var MountTable = class {
     mount.epoch++;
     for (const key of [...mount.attrs.keys()]) if (within4(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 (within4(key, path)) mount.lists.delete(key);
   }
   async getattr(mount, path, rel2, settled = false) {
@@ -7642,7 +7736,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({
@@ -7658,8 +7752,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;
@@ -7998,7 +8092,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);
@@ -9234,6 +9328,7 @@ var HOST_OPS = [
   "async-resolve",
   "async-hold",
   "async-cancel",
+  "async-settle",
   "async-close"
 ];
 var json3 = (value) => ({ ok: true, kind: "json", json: value });
@@ -9265,12 +9360,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;
@@ -9280,6 +9379,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(
@@ -9303,9 +9403,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);
   }
@@ -9381,6 +9498,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));
@@ -9393,6 +9511,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;
@@ -9900,8 +10020,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;
@@ -10256,6 +10376,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 failure2;
+  let pid = 0;
+  const kill = () => void Promise.allSettled([deps.kill(pid, req.killSignal)]);
+  const stop = (code) => {
+    if (failure2 !== void 0) return;
+    failure2 = 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 (failure2 !== 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 } : {},
+    ...failure2 !== void 0 ? { error: { code: failure2 } } : {},
+    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();
@@ -10632,7 +10830,7 @@ var VfsNodes = class {
     return run2;
   }
   async entryKey(path) {
-    const parent = parentOf3(path);
+    const parent = parentOf4(path);
     const dir = await this.real(parent, true, () => realDir(this.fs, parent));
     return joinName(dir, path.slice(path.lastIndexOf("/") + 1));
   }
@@ -10834,7 +11032,7 @@ function errCode(err) {
   return err?.code;
 }
 async function targetDir(fs, path) {
-  return parentOf3(await realTarget(fs, path).catch(() => path));
+  return parentOf4(await realTarget(fs, path).catch(() => path));
 }
 async function refuseReadonly(fs, path, flags, opts = {}) {
   const writes = (flags & O_ACCMODE) !== 0 || opts.truncate === true;
@@ -11052,6 +11250,8 @@ var SYSCALL_OPS = /* @__PURE__ */ new Set([
   "proc-spawn",
   "proc-wait",
   "proc-captured",
+  "proc-run",
+  "proc-exit",
   "proc-fork",
   "proc-kill",
   "thread-kill",
@@ -11172,6 +11372,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());
@@ -11720,6 +11928,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": {
@@ -12126,6 +12340,7 @@ function processOptions(opts, header3, hooks, created3) {
     hasPending: () => Atomics.load(header3, SAB_I_SIGNALS) !== 0 || Atomics.load(header3, 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(header3, SAB_I_SIGNALS) } : {}
   };
 }
@@ -12142,7 +12357,8 @@ function spawnWasmProcess(opts) {
       header3,
       {
         raise: (sig) => signal(sig),
-        threadKill: (tid, sig) => killThread(threadSignals.get(tid), process.signalMasks().caught, sig)
+        threadKill: (tid, sig) => killThread(threadSignals.get(tid), process.signalMasks().caught, sig),
+        ...opts.program.abi === "js" ? { exitNow: (code) => exitNow(code) } : {}
       },
       created3
     )
@@ -12183,6 +12399,9 @@ function spawnWasmProcess(opts) {
       () => settle3(code)
     );
   };
+  const exitNow = (code) => {
+    queueMicrotask(() => finish(...dying.status(code)));
+  };
   const handle = (data) => {
     if (data?.type === WASM_PROCESS_EXIT) {
       finish(...dying.status(data.code));
@@ -12918,15 +13137,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
   };
 }
 
@@ -13710,7 +13929,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()
   );
@@ -13723,7 +13942,7 @@ async function openHostfs(spec, connect, timing = {}) {
   });
   const served = serveFilesystem(
     port2,
-    { ...slot.handlers, mount: ranged2 },
+    { ...slot2.handlers, mount: ranged2 },
     {
       symlinks: true,
       chmod: true,
@@ -13737,12 +13956,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
@@ -13752,7 +13971,7 @@ async function openHostfs(spec, connect, timing = {}) {
   await watching.ready;
   return {
     port: port1,
-    present: slot.present,
+    present: slot2.present,
     dispose() {
       stop.abort();
       port1.close();
@@ -15025,7 +15244,7 @@ var Launcher = class {
   async realLayoutPath(path) {
     if (!await this.base.exists(path)) return void 0;
     if (path === "/") return path;
-    return joinName(await realDir(this.base, parentOf3(path)), baseName(path));
+    return joinName(await realDir(this.base, parentOf4(path)), baseName(path));
   }
   async provisionPnpmHome() {
     await this.base.mkdir(this.pnpmHome, { recursive: true }).catch(() => void 0);
@@ -15046,16 +15265,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) {