@ai-ecoverse/slicc-kernel 1.170.4 → 1.172.0

package/dist/node.js

@@ -2362,9 +2362,9 @@ var KernelSocket = class _KernelSocket {
         case SO_TYPE:
           return SOCK_STREAM;
         case SO_ERROR: {
-          const failed3 = this.failed;
+          const failed5 = this.failed;
           this.failed = void 0;
-          return failed3 ? wasiErrno(failed3) : 0;
+          return failed5 ? wasiErrno(failed5) : 0;
         }
         case SO_ACCEPTCONN:
           return this.state === "listening" ? 1 : 0;
@@ -2444,6 +2444,7 @@ var LoopbackNet = class {
   internal = /* @__PURE__ */ new Set();
   reserved = /* @__PURE__ */ new Set();
   facades = /* @__PURE__ */ new Map();
+  proxyStamped;
   nextEphemeral = EPHEMERAL_FIRST;
   route;
   origins;
@@ -2518,9 +2519,15 @@ var LoopbackNet = class {
     this.kernelOnly(port, true);
     this.facades.set(port, name2);
   }
-  facadeAt(addr) {
-    if (addr.family !== "inet" || !isLoopback(canonicalHost(addr.host))) return void 0;
-    return this.facades.get(addr.port);
+  stampProxy(port) {
+    this.proxyStamped = port;
+  }
+  get originsStamped() {
+    return this.proxyStamped !== void 0;
+  }
+  stampsPeers(addr) {
+    if (addr.family !== "inet" || !isLoopback(canonicalHost(addr.host))) return false;
+    return this.facades.has(addr.port) || this.proxyStamped === addr.port;
   }
   activate(addr, start2) {
     this.activators.set(keyOf(addr), start2);
@@ -3695,7 +3702,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.170.4" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.172.0" : "0.0.0-dev";
 var OS_RELEASE = "6.0.0-slicc";
 function procVersion() {
   return `Linux version ${OS_RELEASE} (slicc-kernel ${KERNEL_VERSION}) #1 SMP PREEMPT_DYNAMIC
@@ -3987,10 +3994,10 @@ async function tierPackages(fs, physical, roots, bins, kernel, global) {
       const own = commandsOf(pkg, manifest);
       const named = new Set(own.map((command) => command.name));
       const extra = bins ? await binCommandsOf(physical, pkg, manifest, named) : [];
-      const refused3 = engineRefusal(manifest, kernel);
+      const refused4 = engineRefusal(manifest, kernel);
       const name2 = pkg.slice(root.length + 1);
       const dependency = direct?.has(name2) === false;
-      const marks = { ...refused3 ? { refused: refused3 } : {}, ...dependency ? { dependency } : {} };
+      const marks = { ...refused4 ? { refused: refused4 } : {}, ...dependency ? { dependency } : {} };
       out.push({
         name: name2,
         pkg,
@@ -4022,7 +4029,7 @@ function winners(tier) {
   }
   return out;
 }
-async function scanCommands(fs, modules, binsFrom = Number.POSITIVE_INFINITY, kernel = KERNEL_VERSION, refused3, global = /* @__PURE__ */ new Set()) {
+async function scanCommands(fs, modules, binsFrom = Number.POSITIVE_INFINITY, kernel = KERNEL_VERSION, refused4, global = /* @__PURE__ */ new Set()) {
   const found = /* @__PURE__ */ new Map();
   const physical = physicalResolver(fs);
   const tiers = (typeof modules === "string" ? [modules] : modules).map(
@@ -4036,7 +4043,7 @@ async function scanCommands(fs, modules, binsFrom = Number.POSITIVE_INFINITY, ke
   const dependencies = [];
   for (const [index, roots] of tiers.entries()) {
     const tier = await tierPackages(fs, physical, roots, index >= binsFrom, kernel, global);
-    if (refused3) refused3.push(...tier.flatMap((entry) => entry.commands.filter((c) => c.refused)));
+    if (refused4) refused4.push(...tier.flatMap((entry) => entry.commands.filter((c) => c.refused)));
     await take(tier.filter((entry) => !entry.dependency));
     dependencies.push(tier.filter((entry) => entry.dependency));
   }
@@ -4352,32 +4359,32 @@ function nextFire(schedule, after, utc = false) {
   }
   return null;
 }
-function missedFires(schedule, from, until, utc = false, cap = MISSED_CAP) {
+function missedFires(schedule, from, until2, utc = false, cap = MISSED_CAP) {
   let count2 = 0;
   let last = null;
   let at = from;
   while (count2 < cap) {
     at = nextFire(schedule, at, utc);
-    if (at === null || at > until) return { count: count2, last, more: false };
+    if (at === null || at > until2) return { count: count2, last, more: false };
     last = at;
     count2++;
   }
   const next3 = nextFire(schedule, last, utc);
-  if (next3 === null || next3 > until) return { count: count2, last, more: false };
-  return { count: count2, last: latestFire(schedule, last, until, utc), more: true };
+  if (next3 === null || next3 > until2) return { count: count2, last, more: false };
+  return { count: count2, last: latestFire(schedule, last, until2, utc), more: true };
 }
-function latestFire(schedule, from, until, utc = false) {
+function latestFire(schedule, from, until2, utc = false) {
   let found = from;
   for (let span = 6e4; ; span *= 2) {
-    const start2 = Math.max(from, until - span);
+    const start2 = Math.max(from, until2 - span);
     const first = nextFire(schedule, start2, utc);
-    if (first !== null && first <= until) {
+    if (first !== null && first <= until2) {
       found = first;
       break;
     }
     if (start2 === from) return from;
   }
-  for (let at = nextFire(schedule, found, utc); at !== null && at <= until; ) {
+  for (let at = nextFire(schedule, found, utc); at !== null && at <= until2; ) {
     found = at;
     at = nextFire(schedule, at, utc);
   }
@@ -5102,12 +5109,12 @@ var UnlinkedKeeper = class {
     return this.locks;
   }
   async undoing(op, peers, sends, heard, shared2 = []) {
-    let failed3;
+    let failed5;
     let out;
     try {
       out = await op();
     } catch (err) {
-      failed3 = err ?? new Error("failed");
+      failed5 = err ?? new Error("failed");
       await this.rollBackAsides(sends, shared2);
     }
     const hiddenShared = new Set(shared2.map((one) => one.hidden));
@@ -5128,7 +5135,7 @@ var UnlinkedKeeper = class {
       const done4 = () => one.release().then(() => this.dropIfLast(one.hidden));
       void Promise.all(waits.map(({ told }) => told)).then(done4, done4);
     }
-    if (failed3 !== void 0) throw failed3;
+    if (failed5 !== void 0) throw failed5;
     return out;
   }
   async rollBackAsides(sends, shared2) {
@@ -5275,7 +5282,7 @@ var UnlinkedKeeper = class {
 // src/cron/clock.ts
 var systemCronClock = {
   now: () => Date.now(),
-  sleep(until, signal) {
+  sleep(until2, signal) {
     if (signal.aborted) return Promise.resolve();
     return new Promise((resolve2) => {
       const done4 = () => {
@@ -5283,7 +5290,7 @@ var systemCronClock = {
         signal.removeEventListener("abort", done4);
         resolve2();
       };
-      const timer = setTimeout(done4, Math.max(0, until - Date.now()));
+      const timer = setTimeout(done4, Math.max(0, until2 - Date.now()));
       timer.unref?.();
       signal.addEventListener("abort", done4, { once: true });
     });
@@ -5387,15 +5394,15 @@ var CronService = class {
   async pass() {
     if (this.wake.signal.aborted) this.wake = new AbortController();
     const wake = this.wake;
-    let until;
+    let until2;
     try {
-      until = await this.tick();
+      until2 = await this.tick();
     } catch (err) {
       await this.error(`cron: ${messageOf(err)}`);
-      until = this.clock.now() + WAKE_MS;
+      until2 = this.clock.now() + WAKE_MS;
     }
     if (this.stopping.signal.aborted) return;
-    await this.clock.sleep(until, wake.signal);
+    await this.clock.sleep(until2, wake.signal);
   }
   async provision() {
     const { fs, owners } = this.host;
@@ -5612,14 +5619,17 @@ var PLACEHOLDER_REFUSED = "refused: this request has a sealed placeholder in its
 var PlaceholderRefused = class extends Error {
   status = 403;
   code = "EACCES";
-  constructor() {
-    super(PLACEHOLDER_REFUSED);
+  constructor(reason = PLACEHOLDER_REFUSED) {
+    super(reason);
   }
 };
-function carries(text) {
+function holds2(text, known) {
+  return PLACEHOLDER.test(text) || known.some((placeholder) => text.includes(placeholder));
+}
+function carries(text, known) {
   let layer = text;
   for (let i = 0; i < PERCENT_LAYERS; i++) {
-    if (PLACEHOLDER.test(layer)) return true;
+    if (holds2(layer, known)) return true;
     const next3 = layer.replace(
       ESCAPE,
       (_, hex4) => String.fromCharCode(Number.parseInt(hex4, 16))
@@ -5627,35 +5637,36 @@ function carries(text) {
     if (next3 === layer) return false;
     layer = next3;
   }
-  return PLACEHOLDER.test(layer);
+  return holds2(layer, known);
 }
-function basicCarries(value2) {
+function basicCarries(value2, known) {
   const credential = BASIC.exec(value2)?.[1];
   if (credential === void 0) return false;
   const letters = credential.replace(/[^A-Za-z0-9+/_-]/g, "").replaceAll("-", "+").replaceAll("_", "/");
   for (let shift = 0; shift < BASE64_GROUP; shift++) {
     const part = letters.slice(shift);
     const whole = part.length % BASE64_GROUP === 1 ? part.slice(0, -1) : part;
-    if (carries(atob(whole))) return true;
+    if (carries(atob(whole), known)) return true;
   }
   return false;
 }
-function headersCarry(headers) {
+function headersCarry(headers, known) {
   return headers.some(
-    ([name2, value2]) => carries(name2.toLowerCase()) || carries(value2) || basicCarries(value2)
+    ([name2, value2]) => carries(name2, known) || carries(name2.toLowerCase(), known) || carries(value2, known) || basicCarries(value2, known)
   );
 }
-function urlCarries(url) {
-  return carries(url) || URL.canParse(url) && carries(new URL(url).href);
+function urlCarries(url, known) {
+  return carries(url, known) || URL.canParse(url) && carries(new URL(url).href, known);
 }
-function refuse(request) {
-  if (urlCarries(request.url) || headersCarry(request.headers)) throw new PlaceholderRefused();
+function detected(request, known) {
+  return urlCarries(request.url, known) || headersCarry(request.headers, known);
 }
-function refuseSocket(request) {
-  refuse(request);
-  if (request.protocols.some(carries)) throw new PlaceholderRefused();
+function refuseSocket(request, known) {
+  if (detected(request, known) || request.protocols.some((p) => carries(p, known))) {
+    throw new PlaceholderRefused();
+  }
 }
-function placeholderFloor(inner) {
+function placeholderFloor(inner, { known = () => [], fill: fill2 } = {}) {
   const open = inner.websocket?.bind(inner);
   return {
     get traits() {
@@ -5663,13 +5674,14 @@ function placeholderFloor(inner) {
     },
     ...open ? {
       websocket: async (request) => {
-        refuseSocket(request);
+        refuseSocket(request, known());
         return open(request);
       }
     } : {},
-    async fetch(request, owner) {
-      refuse(request);
-      return inner.fetch(request, owner);
+    async fetch(request, owner, stamp) {
+      if (!detected(request, known())) return inner.fetch(request, owner, stamp);
+      if (!fill2 || !stamp) throw new PlaceholderRefused();
+      return fill2(request, stamp);
     }
   };
 }
@@ -5910,14 +5922,14 @@ function tunnelTarget(req) {
   }
   return { host, port };
 }
-async function watchHangup(conn, abort, until) {
-  while (!until.aborted && !abort.signal.aborted) {
+async function watchHangup(conn, abort, until2) {
+  while (!until2.aborted && !abort.signal.aborted) {
     if (conn.poll().hangup) {
       abort.abort(new KernelError("EPIPE"));
       return;
     }
     try {
-      await conn.changed(until);
+      await conn.changed(until2);
     } catch {
       return;
     }
@@ -6108,7 +6120,7 @@ var RealmProxy = class {
         const waiting = new AbortController();
         void watchHangup(ctx.socket, abort, waiting.signal);
         try {
-          response = await this.upstream(req, url, body, abort.signal, ctx.socket.peerCred?.pid);
+          response = await this.upstream(req, url, body, abort.signal, ctx.socket);
         } finally {
           waiting.abort();
         }
@@ -6135,7 +6147,7 @@ var RealmProxy = class {
       await conn.write(latin1Bytes("HTTP/1.1 100 Continue\r\n\r\n"), this.stop.signal);
     }
   }
-  async upstream(req, url, body, signal, owner) {
+  async upstream(req, url, body, signal, socket) {
     const sent = BODILESS_METHODS.has(req.method) ? void 0 : body;
     try {
       const fetching = this.options.transport.fetch(
@@ -6146,7 +6158,8 @@ var RealmProxy = class {
           ...sent instanceof Uint8Array ? { body: sent } : sent ? { bodyStream: sent } : {},
           signal
         },
-        owner
+        socket.peerCred?.pid,
+        socket.peerStamp
       );
       return await untilAborted(fetching, signal);
     } catch (e) {
@@ -6190,8 +6203,8 @@ var RealmProxy = class {
   }
   async connect(conn, incoming, req, idle2) {
     const target = tunnelTarget(req);
-    const refused3 = target.port === 443 ? await this.tunnelReady(target) : void 0;
-    if (refused3) throw refused3;
+    const refused4 = target.port === 443 ? await this.tunnelReady(target) : void 0;
+    if (refused4) throw refused4;
     await conn.write(latin1Bytes("HTTP/1.1 200 Connection Established\r\n\r\n"), this.stop.signal);
     try {
       const first = await incoming.peek(this.stop.signal);
@@ -6463,7 +6476,7 @@ async function relay(socket, conn) {
 // src/fs/attest.ts
 var ATTEST_MAX = 1024 * 1024;
 var UNOWNED = 1e3;
-function refuse2(code, path, why) {
+function refuse(code, path, why) {
   throw Object.assign(new Error(`attest ${path}: ${why}`), { code });
 }
 function chainOf(path) {
@@ -6505,39 +6518,49 @@ async function trustedParents(fs, path, o) {
   const parents = [];
   for (const dir of chainOf(path).slice(0, -1)) {
     const st = await fs.lstat(dir);
-    if (st.isSymbolicLink) refuse2("EACCES", path, `${dir} is a symlink`);
-    if (!st.isDirectory) refuse2("ENOTDIR", path, `${dir} is not a directory`);
+    if (st.isSymbolicLink) refuse("EACCES", path, `${dir} is a symlink`);
+    if (!st.isDirectory) refuse("ENOTDIR", path, `${dir} is not a directory`);
     const perm = owned(dir, st);
     if (o.users !== "off" && (perm.uid !== 0 || (perm.mode & 18) !== 0)) {
-      refuse2("EACCES", path, `${dir} is not root-owned or is writable by group or others`);
+      refuse("EACCES", path, `${dir} is not root-owned or is writable by group or others`);
     }
     parents.push(perm);
   }
   return parents;
 }
+function missing(e) {
+  return e?.code === "ENOENT";
+}
 async function attest(fs, asked, o) {
+  if (o.absent !== void 0 && o.absent !== "allow") {
+    refuse("EINVAL", String(asked), "absent takes only allow");
+  }
   if (typeof asked !== "string" || !asked.startsWith("/")) {
-    refuse2("EINVAL", String(asked), "not an absolute path");
+    refuse("EINVAL", String(asked), "not an absolute path");
   }
   const path = normalizePath(asked);
   const mount = o.mounts.find((target) => {
     const at = normalizePath(target);
     return at === "/" || under(path, at);
   });
-  if (mount !== void 0) refuse2("EACCES", path, `under the mount ${mount}`);
+  if (mount !== void 0) refuse("EACCES", path, `under the mount ${mount}`);
   const parents = await trustedParents(fs, path, o);
   for (let tries = 0; ; tries++) {
-    const before = await fs.lstat(path);
-    if (before.isSymbolicLink) refuse2("EACCES", path, "is a symlink");
+    const before = await fs.lstat(path).catch((e) => {
+      if (o.absent === "allow" && missing(e)) return void 0;
+      throw e;
+    });
+    if (!before) return { path, absent: true, users: o.users, onRootFs: true, parents };
+    if (before.isSymbolicLink) refuse("EACCES", path, "is a symlink");
     if (!before.isFile)
-      refuse2(before.isDirectory ? "EISDIR" : "EINVAL", path, "is not a regular file");
-    if (before.size > ATTEST_MAX) refuse2("EFBIG", path, `is over ${ATTEST_MAX} bytes`);
+      refuse(before.isDirectory ? "EISDIR" : "EINVAL", path, "is not a regular file");
+    if (before.size > ATTEST_MAX) refuse("EFBIG", path, `is over ${ATTEST_MAX} bytes`);
     const bytes = (await fs.readFileBuffer(path)).slice();
     const after = await fs.lstat(path);
     if (unchanged(before, after, bytes)) {
       return attested(path, after, bytes, await sha256(bytes), o, parents);
     }
-    if (tries >= 1) refuse2("EAGAIN", path, "changed while it was read");
+    if (tries >= 1) refuse("EAGAIN", path, "changed while it was read");
   }
 }
 var WATCH_DEBOUNCE_MS = 50;
@@ -6708,7 +6731,7 @@ var S_IFREG = 32768;
 var COMMAND = /^\/(?:usr\/)?bin\/([^/]+)$/;
 var MAX_LINKS3 = 40;
 var BIN_ENTRY = /\/bin\/[^/]+$/;
-function missing(err) {
+function missing2(err) {
   return err?.code === "ENOENT";
 }
 function synthetic(directory, path) {
@@ -6812,7 +6835,7 @@ function withCommandDirs(fs, names2, userDir = async () => void 0, owners = fals
   }
   async function entryTarget(path) {
     if (!BIN_ENTRY.test(path) || !(await virtual(path))?.isFile) return void 0;
-    if (!await fs.lstat(path).then(() => false, missing)) return void 0;
+    if (!await fs.lstat(path).then(() => false, missing2)) return void 0;
     const target = await targetOf2(path);
     return target?.path === path ? void 0 : target;
   }
@@ -6824,11 +6847,11 @@ function withCommandDirs(fs, names2, userDir = async () => void 0, owners = fals
     return target?.path;
   }
   const absent2 = (err) => {
-    if (missing(err)) return EMPTY2;
+    if (missing2(err)) return EMPTY2;
     throw err;
   };
   async function content(path, err) {
-    if (!missing(err) || !(await linked2(path))?.isFile) throw err;
+    if (!missing2(err) || !(await linked2(path))?.isFile) throw err;
     const target = await redirected2(path);
     return target === void 0 ? EMPTY2 : fs.readFileBuffer(target).catch(absent2);
   }
@@ -6837,7 +6860,7 @@ function withCommandDirs(fs, names2, userDir = async () => void 0, owners = fals
     try {
       return await real(path);
     } catch (err) {
-      const found = missing(err) ? await linked2(path) : void 0;
+      const found = missing2(err) ? await linked2(path) : void 0;
       if (found) return found;
       throw err;
     }
@@ -6862,7 +6885,7 @@ function withCommandDirs(fs, names2, userDir = async () => void 0, owners = fals
       const extra = await children3(path);
       if (!extra) return fs.readdir(path);
       const real = await fs.readdir(path).catch((err) => {
-        if (missing(err)) return [];
+        if (missing2(err)) return [];
         throw err;
       });
       return [.../* @__PURE__ */ new Set([...real, ...extra])].sort();
@@ -6871,7 +6894,7 @@ function withCommandDirs(fs, names2, userDir = async () => void 0, owners = fals
       const extra = await children3(path);
       if (!extra) return fs.readdirStat(path);
       const real = await fs.readdirStat(path).catch((err) => {
-        if (missing(err)) return [];
+        if (missing2(err)) return [];
         throw err;
       });
       const seen = new Set(real.map(([name2]) => name2));
@@ -6905,7 +6928,7 @@ function withCommandDirs(fs, names2, userDir = async () => void 0, owners = fals
     ...ranged2 ? {
       ...ranged2,
       pread: (path, offset, length2, version) => ranged2.pread(path, offset, length2, version).catch(async (err) => {
-        const target = missing(err) ? await redirected2(path) : void 0;
+        const target = missing2(err) ? await redirected2(path) : void 0;
         if (target === void 0) throw err;
         return ranged2.pread(target, offset, length2).catch(absent2);
       })
@@ -6936,7 +6959,7 @@ var S_IFREG2 = 32768;
 var MAX_HOPS2 = 40;
 var parentOf3 = (path) => path.slice(0, path.lastIndexOf("/")) || "/";
 var baseOf = (path) => path.slice(path.lastIndexOf("/") + 1);
-function missing2(err) {
+function missing3(err) {
   return err?.code === "ENOENT";
 }
 function statOf(path, bytes) {
@@ -6989,11 +7012,11 @@ function withEtcFiles(fs, files) {
     const text = files.get(path)?.();
     return text === void 0 ? void 0 : new TextEncoder().encode(text);
   };
-  const absent2 = (path) => fs.lstat(path).then(() => false, missing2);
+  const absent2 = (path) => fs.lstat(path).then(() => false, missing3);
   const follow2 = linkFollower(fs, files);
   const listedAbsent = async (path) => files.has(path) && await absent2(path) ? bytesOf5(path) : void 0;
   const fallback = (path, make) => async (err) => {
-    const at = missing2(err) ? await follow2(path) : void 0;
+    const at = missing3(err) ? await follow2(path) : void 0;
     const bytes = at === void 0 ? void 0 : await listedAbsent(at);
     if (bytes === void 0 || at === void 0) throw err;
     return make(bytes, at);
@@ -7203,7 +7226,7 @@ var MAX_LINKS4 = 40;
 function partsOf(path) {
   return path.split("/").filter((p) => p !== "" && p !== ".");
 }
-function missing3(err) {
+function missing4(err) {
   const code = err?.code;
   return code === "ENOENT" || code === "ENOTDIR";
 }
@@ -7222,7 +7245,7 @@ async function resolved(fs, path, follow2, hops = []) {
     }
     const at = `/${[...done4, part].join("/")}`;
     const st = await fs.lstat(at).catch((err) => {
-      if (missing3(err)) return void 0;
+      if (missing4(err)) return void 0;
       throw err;
     });
     if (!st) {
@@ -9366,8 +9389,8 @@ var DriverConnection = class _DriverConnection {
     } finally {
       clearTimeout(timer);
     }
-    const refused3 = driverVersionError(hello.protocol);
-    if (refused3) throw errnoError("EPROTO", refused3);
+    const refused4 = driverVersionError(hello.protocol);
+    if (refused4) throw errnoError("EPROTO", refused4);
     if (hello.error) throw errnoError(hello.errno ?? "EIO", hello.error);
     return new _DriverConnection(port, hello.capabilities ?? {}, waiting, timeoutMs, options);
   }
@@ -9451,29 +9474,29 @@ var HeldSet = class extends Set {
     this.idle = idle2;
     this.moved = moved2;
   }
-  add(holds2) {
-    holds2.onIdle = this.idle;
-    holds2.onMoved = this.moved;
-    return super.add(holds2);
+  add(holds3) {
+    holds3.onIdle = this.idle;
+    holds3.onMoved = this.moved;
+    return super.add(holds3);
   }
   doubt(paths, over) {
-    for (const holds2 of this) {
-      for (const path of paths) holds2.doubt(path, true);
-      if (over !== void 0) holds2.doubt(over);
+    for (const holds3 of this) {
+      for (const path of paths) holds3.doubt(path, true);
+      if (over !== void 0) holds3.doubt(over);
     }
   }
   async bindIds(id2) {
-    for (const holds2 of [...this]) await holds2.bindIds(id2);
+    for (const holds3 of [...this]) await holds3.bindIds(id2);
   }
   heldIds() {
     const out = /* @__PURE__ */ new Map();
-    for (const holds2 of this) for (const [path, fid] of holds2.heldIds()) out.set(path, fid);
+    for (const holds3 of this) for (const [path, fid] of holds3.heldIds()) out.set(path, fid);
     return [...out];
   }
-  delete(holds2) {
-    const removed = super.delete(holds2);
-    for (const path of /* @__PURE__ */ new Set([...holds2.keys(), ...holds2.opens.keys()])) this.idle(path);
-    holds2.releaseAll();
+  delete(holds3) {
+    const removed = super.delete(holds3);
+    for (const path of /* @__PURE__ */ new Set([...holds3.keys(), ...holds3.opens.keys()])) this.idle(path);
+    holds3.releaseAll();
     return removed;
   }
 };
@@ -11391,8 +11414,8 @@ async function guarded(entry, path, req) {
     return { paths };
   } catch (err) {
     const refusal3 = err.code === "EACCES";
-    const refused3 = req.op === "exists" && refusal3 ? json2(false) : toErrno(err);
-    return { refused: refused3 };
+    const refused4 = req.op === "exists" && refusal3 ? json2(false) : toErrno(err);
+    return { refused: refused4 };
   }
 }
 async function copyOp(entry, path, req) {
@@ -11588,13 +11611,13 @@ async function created(entry, req) {
   return seen === void 0 ? looked : json2({ ...looked.json, seen });
 }
 var DENIED = /* @__PURE__ */ new Set(["EACCES", "EPERM"]);
-async function rmPermitted(entry, path, req, refused3) {
+async function rmPermitted(entry, path, req, refused4) {
   const st = await entry.fs.lstat(path).catch(() => void 0);
-  if (!st?.isDirectory) return refused3;
+  if (!st?.isDirectory) return refused4;
   const unlisted = await guarded(entry, path, { ...req, op: "readdir" });
   if ("refused" in unlisted) return unlisted.refused;
   const names2 = await entry.fs.readdir(path).catch(() => void 0);
-  if (!names2) return refused3;
+  if (!names2) return refused4;
   let first;
   for (const name2 of names2) {
     const child = await dispatchOne(entry, {
@@ -11645,14 +11668,14 @@ async function newDevName(entry, path, req) {
   const named = NAMING.has(req.op);
   if (!named && !CREATIONS.has(req.op)) return void 0;
   const target = named ? entry.fs.resolvePath(entry.cwd, req.arg2 ?? "") : path;
-  const refused3 = devCreation(target, entry.cred?.());
-  if (!refused3) return void 0;
+  const refused4 = devCreation(target, entry.cred?.());
+  if (!refused4) return void 0;
   const there = await entry.fs.lstat(target).then(
     () => true,
     () => false
   );
   if (there) return void 0;
-  return { ok: false, errno: refused3, message: `${target}: no new names in /dev or /proc` };
+  return { ok: false, errno: refused4, message: `${target}: no new names in /dev or /proc` };
 }
 var MISS_OPS = /* @__PURE__ */ new Set(["stat", "lstat"]);
 async function linkFree(fs, path) {
@@ -12364,9 +12387,9 @@ var SYS_TREE = {
 `,
     slicc_file_ids: (listing) => `${listing.fileIds ?? 0}
 `,
-    slicc_peer_holds: ({ holds: holds2 }) => `${holds2?.mine ?? 0} ${holds2?.peers ?? 0} ${holds2?.sent ?? 0}
+    slicc_peer_holds: ({ holds: holds3 }) => `${holds3?.mine ?? 0} ${holds3?.peers ?? 0} ${holds3?.sent ?? 0}
 `,
-    slicc_peer_held: ({ holds: holds2 }) => (holds2?.held ?? []).map((path) => `${path}
+    slicc_peer_held: ({ holds: holds3 }) => (holds3?.held ?? []).map((path) => `${path}
 `).join(""),
     slicc_rename_acks: (listing) => {
       const samples = [...listing.renameAcks?.ackMs ?? []].sort((a, b) => a - b);
@@ -13107,11 +13130,11 @@ var EpollFile = class _EpollFile {
       const round = new AbortController();
       const stop = () => round.abort();
       signal.addEventListener("abort", stop, { once: true });
-      let failed3 = false;
+      let failed5 = false;
       try {
         await file.changed(round.signal);
       } catch {
-        failed3 = true;
+        failed5 = true;
       } finally {
         round.abort();
         signal.removeEventListener("abort", stop);
@@ -13119,7 +13142,7 @@ var EpollFile = class _EpollFile {
       if (signal.aborted) return;
       reg.gen++;
       this.changes.wake();
-      if (failed3) await pause(RETRY_MS, signal);
+      if (failed5) await pause(RETRY_MS, signal);
     }
   }
 };
@@ -13755,8 +13778,8 @@ var KernelLoopback = class {
       );
     } catch (err) {
       socket.close();
-      const refused3 = err instanceof KernelError && err.code === "ECONNREFUSED";
-      throw refused3 ? errno2("ECONNREFUSED", `nothing listens on the kernel's port ${port}`) : err;
+      const refused4 = err instanceof KernelError && err.code === "ECONNREFUSED";
+      throw refused4 ? errno2("ECONNREFUSED", `nothing listens on the kernel's port ${port}`) : err;
     }
     signal.addEventListener("abort", () => socket.close(), { once: true });
     return socket;
@@ -14100,11 +14123,11 @@ function ipv6(host) {
   const back = halves.length === 2 ? groups(halves[1]) : [];
   if (![...head, ...back].every((g) => /^[0-9A-Fa-f]{1,4}$/.test(g))) return void 0;
   const words2 = [...head, ...back].map((g) => Number.parseInt(g, 16));
-  const missing5 = 8 - words2.length - tail2.length;
-  if (halves.length === 2 ? missing5 < 1 : missing5 !== 0) return void 0;
+  const missing6 = 8 - words2.length - tail2.length;
+  if (halves.length === 2 ? missing6 < 1 : missing6 !== 0) return void 0;
   const all = [
     ...head.map((g) => Number.parseInt(g, 16)),
-    ...new Array(halves.length === 2 ? missing5 : 0).fill(0),
+    ...new Array(halves.length === 2 ? missing6 : 0).fill(0),
     ...back.map((g) => Number.parseInt(g, 16)),
     ...tail2
   ];
@@ -15101,10 +15124,12 @@ var HttpHandles = class {
   ws;
   owner;
   local;
-  constructor(transport, owner, local2) {
+  stamp;
+  constructor(transport, owner, local2, stamp) {
     this.transport = transport;
     this.owner = owner;
     this.local = local2;
+    this.stamp = stamp;
     this.ws = new WsHandles(transport, () => ++this.nextHandle, local2);
   }
   syscall(req) {
@@ -15180,7 +15205,7 @@ var HttpHandles = class {
         ...entry.upload ? { bodyStream: entry.upload } : req.body ? { body: req.body } : {},
         signal: entry.abort.signal
       };
-      const response = port === void 0 ? await this.transport.fetch(request, this.owner) : await this.local.fetch(request, port);
+      const response = port === void 0 ? await this.transport.fetch(request, this.owner, await this.stamp?.()) : await this.local.fetch(request, port);
       entry.body = response.body[Symbol.asyncIterator]();
       entry.cancel = () => response.cancel();
       if (!this.open.has(handle)) await entry.cancel().catch(() => void 0);
@@ -15202,8 +15227,8 @@ var HttpHandles = class {
     if (text === NO_TRANSPORT || typeof status !== "number" || status === 502) {
       const code = codeOf2(e);
       const errno3 = text === NO_TRANSPORT ? "ENETUNREACH" : code !== "EIO" ? code : "ECONNREFUSED";
-      const failed3 = e.detail === "transport";
-      return { ok: false, errno: errno3, message: text, ...failed3 ? { detail: "transport" } : {} };
+      const failed5 = e.detail === "transport";
+      return { ok: false, errno: errno3, message: text, ...failed5 ? { detail: "transport" } : {} };
     }
     entry.body = once(new TextEncoder().encode(text))[Symbol.asyncIterator]();
     return this.headOf(handle, req.url, {
@@ -16998,7 +17023,7 @@ function pass(c, input, final) {
   const partials = [];
   scanMain(c, input, best, partials);
   scanWrapped(c, input, best, partials);
-  const holds2 = final ? [] : [...new Set(partials)].sort((a, b) => a - b);
+  const holds3 = final ? [] : [...new Set(partials)].sort((a, b) => a - b);
   const starts = [...best.keys()].sort((a, b) => a - b);
   const parts2 = [];
   const hits = /* @__PURE__ */ new Map();
@@ -17008,8 +17033,8 @@ function pass(c, input, final) {
   let h = 0;
   for (; ; ) {
     while (s < starts.length && starts[s] < pos) s++;
-    while (h < holds2.length && holds2[h] < pos) h++;
-    const hold = h < holds2.length ? holds2[h] : Infinity;
+    while (h < holds3.length && holds3[h] < pos) h++;
+    const hold = h < holds3.length ? holds3[h] : Infinity;
     const next3 = s < starts.length ? starts[s] : Infinity;
     if (hold <= next3) {
       cut = Math.min(hold, input.length);
@@ -17111,23 +17136,23 @@ function scrubbed(inner, scrubber, idleMs = SCRUB_IDLE_MS) {
   let pending = 0;
   let busy = false;
   let timer;
-  let failed3;
+  let failed5;
   const waiters = /* @__PURE__ */ new Set();
   const quiet3 = () => !busy && pending === 0;
   const wake = () => {
     for (const waiter of [...waiters]) waiter();
   };
   const raise = () => {
-    if (failed3 === void 0) return;
-    const err = failed3;
-    failed3 = void 0;
+    if (failed5 === void 0) return;
+    const err = failed5;
+    failed5 = void 0;
     throw err;
   };
   const later = (bytes) => {
     if (bytes.length === 0) return;
     pending += 1;
     tail2 = tail2.then(() => writeAll2(file, bytes)).catch((err) => {
-      if (failed3 === void 0) failed3 = err;
+      if (failed5 === void 0) failed5 = err;
     }).finally(() => {
       pending -= 1;
       if (quiet3()) wake();
@@ -20202,7 +20227,7 @@ async function connect(req, proc) {
   }
   const path = filePath(req.addr);
   const name2 = path !== void 0 ? await proc.names?.find(path) : void 0;
-  const stamp = proc.net.facadeAt(req.addr) && await proc.stamp?.();
+  const stamp = proc.net.stampsPeers(req.addr) && await proc.stamp?.();
   const dialing = target.connect(req.addr, true, proc.cred?.(), stamp || void 0, true, name2);
   if (req.nonblock) {
     dialing?.catch(() => void 0);
@@ -20324,7 +20349,7 @@ async function secureConnect(req, proc) {
       delete req.clientCert;
       throw new KernelError("ENOTSUP");
     }
-    return { ...tlsOverTransport(req, proc), path: "transport", substitutes: true };
+    return { ...await tlsOverTransport(req, proc), path: "transport", substitutes: true };
   }
   const socket = proc.net.socket("inet");
   const fd = proc.fds.install(new OpenFile(socket), 3);
@@ -20343,7 +20368,7 @@ async function uplinked(proc, host) {
     return false;
   }
 }
-function tlsOverTransport(req, proc) {
+async function tlsOverTransport(req, proc) {
   if (req.ca) throw new KernelError("ENOTSUP");
   if (req.alpn && req.alpn.length > 0 && !req.alpn.includes("http/1.1")) {
     throw new KernelError("EPROTONOSUPPORT");
@@ -20356,7 +20381,9 @@ function tlsOverTransport(req, proc) {
   if (isLoopbackHost(servername) || isLoopbackHost(req.host)) throw new KernelError("ENOTSUP");
   const host = servername.includes(":") && !servername.startsWith("[") ? `[${servername}]` : servername;
   const origin = req.port === 443 ? `https://${host}` : `https://${host}:${req.port}`;
+  const stamp = proc.net.originsStamped ? await proc.stamp?.() : void 0;
   const [mine, theirs] = KernelSocket.pair(proc.net, "inet", proc.cred?.());
+  theirs.peerStamp = stamp;
   mine.peer = { family: "inet", host: req.host, port: req.port };
   try {
     proc.net.serveOrigin(theirs, origin);
@@ -23515,13 +23542,13 @@ function inherited(opts) {
     ...opts.cred ? { cred: opts.cred } : {}
   };
 }
-function heldBy(process2, holds2, replacements) {
-  process2.keptPath = (path) => holds2.keptAt(path)?.hidden;
-  process2.keptHandle = (handle) => holds2.keptFor(handle)?.hidden;
-  process2.holdsHandle = (handle) => holds2.holdsHandle(handle);
+function heldBy(process2, holds3, replacements) {
+  process2.keptPath = (path) => holds3.keptAt(path)?.hidden;
+  process2.keptHandle = (handle) => holds3.keptFor(handle)?.hidden;
+  process2.holdsHandle = (handle) => holds3.holdsHandle(handle);
   if (replacements) process2.replacements = replacements;
 }
-function holdingToken(opts, holds2, caller) {
+function holdingToken(opts, holds3, caller) {
   return mintSyncFsToken({
     ...opts.owners ? caller : { umask: caller.umask },
     ...opts.dac ? { dac: opts.dac, pid: opts.pid, created: caller.created } : {},
@@ -23538,16 +23565,16 @@ function holdingToken(opts, holds2, caller) {
     ...opts.fileId ? { fileId: opts.fileId } : {},
     ...opts.announceHold ? { announceHold: opts.announceHold } : {},
     ...opts.renameSeq ? { renameSeq: opts.renameSeq } : {},
-    hold: (path, on, open, real, handle, ino, fid) => holds2.hold(path, on, open, real, handle, ino, fid),
-    boundIno: holds2.boundIno.bind(holds2),
-    trust: holds2.trust.bind(holds2),
-    keptFor: (handle) => holds2.keptFor(handle),
-    heldAt: (handle) => holds2.pathOf(handle),
-    unlinked: (path) => holds2.keptAt(path),
-    gate: (path, op) => opts.unlinkGate && holds2.holding(path) ? opts.unlinkGate.run(holds2.keyOf(path), op) : op(),
-    own: (path, op) => holds2.own(path, op),
-    revoked: (path) => holds2.isRevoked(path),
-    renamed: (from, to) => holds2.renamed(from, to)
+    hold: (path, on, open, real, handle, ino, fid) => holds3.hold(path, on, open, real, handle, ino, fid),
+    boundIno: holds3.boundIno.bind(holds3),
+    trust: holds3.trust.bind(holds3),
+    keptFor: (handle) => holds3.keptFor(handle),
+    heldAt: (handle) => holds3.pathOf(handle),
+    unlinked: (path) => holds3.keptAt(path),
+    gate: (path, op) => opts.unlinkGate && holds3.holding(path) ? opts.unlinkGate.run(holds3.keyOf(path), op) : op(),
+    own: (path, op) => holds3.own(path, op),
+    revoked: (path) => holds3.isRevoked(path),
+    renamed: (from, to) => holds3.renamed(from, to)
   });
 }
 function linksOf(opts) {
@@ -23704,15 +23731,15 @@ function spawnWasmProcess(opts) {
     )
   );
   publishStops(process2, header5);
-  const holds2 = new HeldPaths();
-  opts.held?.add(holds2);
-  const token = holdingToken(opts, holds2, {
+  const holds3 = new HeldPaths();
+  opts.held?.add(holds3);
+  const token = holdingToken(opts, holds3, {
     cred: () => process2.cred,
     umask: () => process2.umask,
     created: created4,
-    holdsKept: async (path) => path.includes(`/${UNLINKED_DIR}/`) && (holds2.keeps(path) || await process2.holds(path))
+    holdsKept: async (path) => path.includes(`/${UNLINKED_DIR}/`) && (holds3.keeps(path) || await process2.holds(path))
   });
-  heldBy(process2, holds2, opts.replacements);
+  heldBy(process2, holds3, opts.replacements);
   const worker = opts.createWorker();
   const dying = new Dying();
   const dispatch2 = (req, block) => dying.serve(
@@ -23744,7 +23771,7 @@ function spawnWasmProcess(opts) {
     responder.dispose();
     lane?.dispose();
     revokeSyncFsToken(token);
-    opts.held?.delete(holds2);
+    opts.held?.delete(holds3);
     worker.terminate();
     settleExit(process2.exit(), settle, code);
   };
@@ -24310,10 +24337,10 @@ var RemoteWatch = class {
       });
     }
   }
-  heldBy({ tab, holds: holds2, seq: seq2 }) {
+  heldBy({ tab, holds: holds3, seq: seq2 }) {
     const from = tab;
-    const { add, drop } = holds2;
-    if (holds2?.instance !== void 0) this.instances.set(from, holds2.instance);
+    const { add, drop } = holds3;
+    if (holds3?.instance !== void 0) this.instances.set(from, holds3.instance);
     const held = this.peerHolds.get(from) ?? /* @__PURE__ */ new Map();
     for (const path of drop) held.delete(path);
     for (const [path, fid] of add) held.set(path, fid);
@@ -25258,6 +25285,236 @@ function enableDnsStub(net, stub) {
   });
 }
 
+// src/kernel/net/remote-transport.ts
+var TransportError = class extends Error {
+  status;
+  code;
+  detail;
+  constructor(message3, status, code, detail) {
+    super(message3);
+    this.status = status;
+    this.code = code;
+    this.detail = detail === "transport" ? detail : void 0;
+  }
+};
+function unfollowed2(redirect) {
+  return redirect !== void 0 && redirect !== "follow";
+}
+function honors(traits, redirect) {
+  if (traits.redirectPolicy === true) return true;
+  const hops = traits.redirectHops;
+  const raw2 = traits.manualRedirects === true && (hops === void 0 || hops === false);
+  return redirect === "manual" && raw2;
+}
+function refused3(message3) {
+  return new TransportError(message3, 502, void 0, "transport");
+}
+var RemoteTransport = class {
+  traits;
+  port;
+  waiting = /* @__PURE__ */ new Map();
+  nextId = 0;
+  sockets = /* @__PURE__ */ new Map();
+  uploads = /* @__PURE__ */ new Map();
+  failure;
+  constructor(port, traits) {
+    this.port = port;
+    this.traits = traits;
+  }
+  receive(reply) {
+    if (reply.net === "body-pull") {
+      void this.pull(reply.nid);
+      return;
+    }
+    const socket = this.sockets.get(reply.nid);
+    if (socket && this.toSocket(reply, socket)) return;
+    const waiter = this.waiting.get(reply.nid);
+    if (!waiter) return;
+    this.waiting.delete(reply.nid);
+    if (reply.net === "error") {
+      waiter.reject(new TransportError(reply.message, reply.status, reply.code, reply.detail));
+    } else waiter.resolve(reply);
+  }
+  toSocket(reply, socket) {
+    if (reply.net === "ws-message") socket.queue.push(reply.data);
+    else if (reply.net === "ws-acked") socket.acked(reply.n);
+    else if (reply.net === "ws-closed") {
+      this.sockets.delete(reply.nid);
+      socket.queue.end({ code: reply.code, reason: reply.reason });
+    } else return false;
+    return true;
+  }
+  async pull(nid) {
+    const upload = this.uploads.get(nid);
+    if (!upload) {
+      this.port.postMessage({ net: "body-error", nid, message: "the request body is gone" });
+      return;
+    }
+    try {
+      const next3 = await upload.next();
+      if (next3.done) {
+        this.uploads.delete(nid);
+        this.port.postMessage({ net: "body-end", nid });
+      } else this.port.postMessage({ net: "body-chunk", nid, bytes: next3.value });
+    } catch (e) {
+      this.uploads.delete(nid);
+      this.port.postMessage({
+        net: "body-error",
+        nid,
+        message: e instanceof Error ? e.message : String(e)
+      });
+    }
+  }
+  dropUpload(nid) {
+    const upload = this.uploads.get(nid);
+    this.uploads.delete(nid);
+    void upload?.return?.().catch(() => void 0);
+  }
+  fail(error) {
+    this.failure = error;
+    for (const nid of [...this.uploads.keys()]) this.dropUpload(nid);
+    for (const waiter of this.waiting.values()) waiter.reject(error);
+    this.waiting.clear();
+    for (const socket of this.sockets.values())
+      socket.queue.end({ code: 1011, reason: error.message });
+    this.sockets.clear();
+  }
+  ask(call) {
+    if (this.failure) return Promise.reject(this.failure);
+    return new Promise((resolve2, reject) => {
+      this.waiting.set(call.nid, { resolve: resolve2, reject });
+      this.port.postMessage(call);
+    });
+  }
+  cancel(nid) {
+    const waiter = this.waiting.get(nid);
+    this.waiting.delete(nid);
+    waiter?.reject(new TransportError("the request was cancelled"));
+    this.port.postMessage({ net: "cancel", nid });
+  }
+  async fetch(request, owner, stamp) {
+    const nid = ++this.nextId;
+    const { signal, redirect } = request;
+    signal.throwIfAborted();
+    if (unfollowed2(redirect) && !honors(this.traits, redirect)) {
+      throw refused3(`this transport cannot honor redirect: ${redirect}`);
+    }
+    let finished = false;
+    const abort = () => {
+      finished = true;
+      this.dropUpload(nid);
+      this.cancel(nid);
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    const finish = () => {
+      this.dropUpload(nid);
+      if (finished) return;
+      finished = true;
+      signal.removeEventListener("abort", abort);
+    };
+    if (request.bodyStream) this.uploads.set(nid, request.bodyStream[Symbol.asyncIterator]());
+    let head;
+    try {
+      head = await this.ask({
+        net: "fetch",
+        nid,
+        url: request.url,
+        method: request.method,
+        headers: request.headers,
+        ...request.bodyStream ? { streamed: true } : request.body ? { body: request.body } : {},
+        ...redirect !== void 0 ? { redirect } : {},
+        ...owner !== void 0 ? { owner } : {},
+        ...stamp ? { stamp } : {}
+      });
+    } catch (e) {
+      finish();
+      throw e;
+    }
+    const { status, statusText, headers, url, redirected: redirected2, redirects, opaqueRedirect } = head;
+    const read = async () => {
+      if (finished) return void 0;
+      const reply = await this.ask({ net: "read", nid }).catch((e) => {
+        finish();
+        throw e;
+      });
+      if (reply.net === "chunk") return reply.bytes;
+      finish();
+      return void 0;
+    };
+    const cancel = async () => {
+      if (finished) return;
+      finish();
+      this.cancel(nid);
+    };
+    if (unfollowed2(redirect) && (redirected2 || redirects?.length)) {
+      await cancel();
+      throw refused3(`this transport followed a redirect despite redirect: ${redirect}`);
+    }
+    return {
+      ...url !== void 0 ? { url } : {},
+      ...redirected2 !== void 0 ? { redirected: redirected2 } : {},
+      ...redirects ? { redirects } : {},
+      ...opaqueRedirect ? { opaqueRedirect } : {},
+      status,
+      statusText,
+      headers,
+      cancel,
+      body: {
+        [Symbol.asyncIterator]: () => ({
+          next: async () => {
+            const bytes = await read();
+            return bytes ? { value: bytes, done: false } : { value: void 0, done: true };
+          },
+          return: async () => {
+            await cancel();
+            return { value: void 0, done: true };
+          }
+        })
+      }
+    };
+  }
+  async websocket(request) {
+    const nid = ++this.nextId;
+    const { signal } = request;
+    signal.throwIfAborted();
+    const abort = () => this.cancel(nid);
+    signal.addEventListener("abort", abort, { once: true });
+    let opened2;
+    try {
+      opened2 = await this.ask({
+        net: "ws-open",
+        nid,
+        url: request.url,
+        protocols: request.protocols,
+        headers: request.headers
+      });
+    } finally {
+      signal.removeEventListener("abort", abort);
+    }
+    const close = (code, reason) => this.port.postMessage({ net: "ws-close", nid, code, reason });
+    const queue = new MessageQueue(
+      () => close(1e3, "a message is too big"),
+      Number.POSITIVE_INFINITY,
+      (n) => this.port.postMessage({ net: "ws-consumed", nid, n })
+    );
+    let unacked = 0;
+    this.sockets.set(nid, { queue, acked: (n) => void (unacked -= n) });
+    return {
+      protocol: opened2.protocol,
+      get buffered() {
+        return unacked;
+      },
+      send: (data) => {
+        unacked += payloadSize(data);
+        this.port.postMessage({ net: "ws-send", nid, data });
+      },
+      messages: queue,
+      close,
+      closed: queue.closed
+    };
+  }
+};
+
 // src/kernel/net/redirect-hops.ts
 var HELD_MS = 3e4;
 var HELD_MAX2 = 64;
@@ -25333,7 +25590,9 @@ function replayingHops(inner, heldMs = HELD_MS) {
       return { ...inner.traits, manualRedirects: true };
     },
     ...inner.websocket ? { websocket: inner.websocket.bind(inner) } : {},
-    async fetch(request, caller) {
+    async fetch(request, ...rest2) {
+      if (unfollowed2(request.redirect)) return inner.fetch(request, ...rest2);
+      const [caller] = rest2;
       const owner = caller ?? KERNEL;
       const key = keyOf3(owner, request.method, request.url);
       const waiting = held.get(key);
@@ -25343,7 +25602,7 @@ function replayingHops(inner, heldMs = HELD_MS) {
         return replay(waiting);
       }
       if (waiting) drop(key);
-      const response = await inner.fetch(request, caller);
+      const response = await inner.fetch(request, ...rest2);
       if (!response.redirects?.length) return response;
       return replay({
         owner,
@@ -25356,6 +25615,173 @@ function replayingHops(inner, heldMs = HELD_MS) {
   };
 }
 
+// src/body-idle.ts
+var BODY_IDLE_MS = 5 * 60 * 1e3;
+function idleFailure(ms) {
+  return Object.assign(new Error(`the response body sent no data for ${ms} ms`), {
+    code: "ETIMEDOUT"
+  });
+}
+async function readWithin(reader, ms) {
+  if (!(ms > 0 && ms < Number.POSITIVE_INFINITY)) return reader.read();
+  let timer;
+  const idle2 = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(idleFailure(ms)), ms);
+  });
+  try {
+    return await Promise.race([reader.read(), idle2]);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+// src/kernel/net/sealed-fetch.ts
+var SEALED_FETCH_VERSION = 1;
+var UNSAFE_FIELD = /[\r\n\0]/;
+function sealedHooks(option) {
+  if (!option) return {};
+  if (typeof option === "function") return { request: option };
+  const { request, fetch: fetch2 } = option;
+  if (typeof request !== "function" || fetch2 !== void 0 && typeof fetch2 !== "function") {
+    throw new TypeError("sealed takes a function or { request, fetch? }");
+  }
+  return { request, ...fetch2 ? { fetch: fetch2 } : {} };
+}
+function headerList(headers) {
+  return Array.isArray(headers) && headers.every(
+    (field4) => Array.isArray(field4) && field4.length === 2 && field4.every((text) => typeof text === "string" && !UNSAFE_FIELD.test(text))
+  );
+}
+function sealedReplyValid(reply) {
+  if (typeof reply !== "object" || reply === null) return false;
+  const { redirects, redirected: redirected2, status, statusText, headers, url, body, cancel } = reply;
+  return redirects === void 0 && redirected2 !== true && Number.isInteger(status) && status >= 100 && status <= 599 && typeof statusText === "string" && !UNSAFE_FIELD.test(statusText) && headerList(headers) && (url === void 0 || typeof url === "string") && typeof body?.[Symbol.asyncIterator] === "function" && typeof cancel === "function";
+}
+function dropSealedReply(reply) {
+  const { cancel } = reply ?? {};
+  if (typeof cancel !== "function") return;
+  void Promise.resolve().then(() => cancel.call(reply)).catch(() => void 0);
+}
+function failed2(reason) {
+  const text = reason instanceof Error ? reason.message : String(reason);
+  return new PlaceholderRefused(
+    `refused: the request with a sealed placeholder was not completed: ${text}`
+  );
+}
+var Stall = class {
+  idle = new AbortController();
+  ms;
+  timer;
+  signal;
+  constructor(signals, ms) {
+    this.ms = ms;
+    this.signal = AbortSignal.any([...signals, this.idle.signal]);
+  }
+  arm() {
+    clearTimeout(this.timer);
+    this.timer = setTimeout(() => this.idle.abort("timeout"), this.ms);
+    this.timer.unref?.();
+  }
+  touch() {
+    if (this.timer !== void 0) this.arm();
+  }
+  rest() {
+    clearTimeout(this.timer);
+    this.timer = void 0;
+  }
+};
+async function until(work, signal) {
+  const stopped = Promise.withResolvers();
+  const stop = () => stopped.reject(signal.reason);
+  if (signal.aborted) stop();
+  else signal.addEventListener("abort", stop, { once: true });
+  try {
+    return await Promise.race([work, stopped.promise]);
+  } finally {
+    signal.removeEventListener("abort", stop);
+  }
+}
+async function* ticking(stream2, stall) {
+  for await (const chunk2 of stream2) {
+    stall.touch();
+    yield chunk2;
+  }
+}
+function sealedRequest(request, stamp, stall) {
+  const { method, url, headers, body, bodyStream: bodyStream2 } = request;
+  return {
+    v: 1,
+    caller: structuredClone(stamp),
+    method,
+    url,
+    headers: headers.map(([name2, value2]) => [name2, value2]),
+    redirect: "manual",
+    ...bodyStream2 ? { bodyStream: ticking(bodyStream2, stall) } : body ? { body } : {}
+  };
+}
+function guarded2(reply, stall) {
+  let finished = false;
+  const cancel = async () => {
+    stall.signal.removeEventListener("abort", dropped2);
+    stall.rest();
+    if (finished) return;
+    finished = true;
+    await reply.cancel().catch(() => void 0);
+  };
+  const dropped2 = () => void cancel();
+  stall.signal.addEventListener("abort", dropped2, { once: true });
+  const source = reply.body[Symbol.asyncIterator]();
+  const body = (async function* () {
+    try {
+      for (; ; ) {
+        stall.arm();
+        const next3 = await until(source.next(), stall.signal);
+        stall.rest();
+        if (next3.done) {
+          finished = true;
+          return;
+        }
+        if (!(next3.value instanceof Uint8Array)) throw failed2("a body chunk is not bytes");
+        if (next3.value.byteLength > 0) yield next3.value;
+      }
+    } finally {
+      await cancel();
+    }
+  })();
+  return {
+    ...reply.url !== void 0 ? { url: reply.url } : {},
+    status: reply.status,
+    statusText: reply.statusText,
+    headers: reply.headers,
+    body,
+    cancel
+  };
+}
+function sealedFetcher(hook, stop, idleMs = BODY_IDLE_MS) {
+  return async (request, stamp) => {
+    const stall = new Stall([request.signal, stop], idleMs);
+    const { signal } = stall;
+    if (signal.aborted) throw failed2(signal.reason);
+    stall.arm();
+    const asked = Promise.resolve().then(() => {
+      signal.throwIfAborted();
+      return hook(sealedRequest(request, stamp, stall), { signal });
+    });
+    let reply;
+    try {
+      reply = await until(asked, signal);
+    } catch (e) {
+      void asked.then(dropSealedReply, () => void 0);
+      throw failed2(e);
+    } finally {
+      stall.rest();
+    }
+    if (sealedReplyValid(reply)) return guarded2(reply, stall);
+    dropSealedReply(reply);
+    throw failed2("the reply is not a scrubbed response");
+  };
+}
+
 // src/kernel/package-swaps.ts
 var SWAP_GAP_MS = 2e3;
 var STAGES = ["_tmp_", "_pacquet-stage_"];
@@ -25528,11 +25954,11 @@ var PackageLocks = class {
     if (!locks) return Promise.resolve(() => {
     });
     const { promise: held, resolve: release } = Promise.withResolvers();
-    return new Promise((granted2, failed3) => {
+    return new Promise((granted2, failed5) => {
       locks.request(replacingLock(this.metadata, root), { mode: "exclusive" }, () => {
         granted2(() => release());
         return held;
-      }).catch(failed3);
+      }).catch(failed5);
     });
   }
 };
@@ -25782,9 +26208,9 @@ function serveFilesystem(port, handlers, capabilities = {}, options = {}) {
   let open = false;
   const reply = (message3, transfer = []) => port.postMessage(message3, transfer);
   async function hello(message3) {
-    const refused3 = driverVersionError(message3.protocol);
-    if (refused3) {
-      reply({ hello: { protocol: DRIVER_PROTOCOL, error: refused3, errno: "EPROTO" } });
+    const refused4 = driverVersionError(message3.protocol);
+    if (refused4) {
+      reply({ hello: { protocol: DRIVER_PROTOCOL, error: refused4, errno: "EPROTO" } });
       return;
     }
     try {
@@ -25916,11 +26342,11 @@ var META_OPS = ["get", "update", "move", "remove", "links", "under", "all"];
 var FILE_ID_TRIES = 3;
 function sidecar(meta) {
   const pathOf = ([first]) => [first, "/"].flat().find((p) => typeof p === "string");
-  const guarded3 = (op) => (...args) => meta[op].apply(meta, args).catch((err) => {
+  const guarded4 = (op) => (...args) => meta[op].apply(meta, args).catch((err) => {
     throw translate(err, pathOf(args), "sidecar", false);
   });
   const names2 = meta.fresh ? [...META_OPS, "fresh"] : META_OPS;
-  const ops = Object.fromEntries(names2.map((op) => [op, guarded3(op)]));
+  const ops = Object.fromEntries(names2.map((op) => [op, guarded4(op)]));
   const { updateMany } = meta;
   ops.updateMany = updateMany ? (changes) => updateMany.call(meta, changes).catch((err) => {
     throw translate(err, changes[0]?.path ?? "/", "sidecar", false);
@@ -25944,7 +26370,7 @@ function occupied(entry) {
 function vacatedAt(path) {
   return { path, ino: inodeOf(`${path}\0${crypto.randomUUID()}`), vacated: true };
 }
-function missing4(err) {
+function missing5(err) {
   const code = err?.code;
   return code === "ENOENT" || code === "ENOTDIR";
 }
@@ -26187,7 +26613,7 @@ var OpfsFs = class {
     if (there) return (await this.meta.get([found.path]))[0]?.fid ?? fid;
     const gone = await this.locate(found.path, true).then(
       () => false,
-      (err) => missing4(err)
+      (err) => missing5(err)
     );
     if (gone) {
       await this.meta.update(found.path, (now) => {
@@ -26630,7 +27056,7 @@ var OpfsFs = class {
       try {
         return await op();
       } catch (err) {
-        if (attempt >= REPLACED_ATTEMPTS || !missing4(err)) throw err;
+        if (attempt >= REPLACED_ATTEMPTS || !missing5(err)) throw err;
         await this.replacing;
         if (this.replacements === seen) throw err;
       }
@@ -26642,7 +27068,7 @@ var OpfsFs = class {
       try {
         return { path: current, handle: await this.handle(current) };
       } catch (err) {
-        if (!missing4(err)) throw err;
+        if (!missing5(err)) throw err;
         const link2 = await this.linkAlong(current);
         if (!link2) throw err;
         if (link2.path === current && !follow2) return { path: current, link: link2 };
@@ -26878,7 +27304,7 @@ var OpfsFs = class {
     return this.locate(path, true).then(
       () => true,
       (err) => {
-        if (missing4(err)) return false;
+        if (missing5(err)) return false;
         throw err;
       }
     );
@@ -27175,7 +27601,7 @@ var OpfsFs = class {
     try {
       return [(await this.locate(path, true)).path, true];
     } catch (err) {
-      if (!missing4(err)) throw err;
+      if (!missing5(err)) throw err;
     }
     const [entry] = await this.meta.get([path]);
     const wanted = entry?.link === void 0 ? path : resolvePath(parentOf9(path), entry.link);
@@ -27267,7 +27693,7 @@ var OpfsFs = class {
     try {
       found = await this.exactly(() => this.locate(path, true));
     } catch (err) {
-      if (!missing4(err)) throw err;
+      if (!missing5(err)) throw err;
     }
     if (found) {
       const directory = found.handle?.kind === "directory";
@@ -27403,7 +27829,7 @@ var OpfsFs = class {
     const taken = await this.exactly(() => this.lstat(to)).then(
       () => true,
       (err) => {
-        if (missing4(err)) return false;
+        if (missing5(err)) return false;
         throw err;
       }
     );
@@ -27435,7 +27861,7 @@ var OpfsFs = class {
     const sourceStat = await this.describe(source);
     if (sourceStat.isDirectory && within9(destination, source.path)) throw fsError("EINVAL", to);
     const target = await this.exactly(() => this.locate(destination, false)).catch((err) => {
-      if (missing4(err)) return null;
+      if (missing5(err)) return null;
       throw err;
     });
     const targetStat = target && await this.describe(target);
@@ -28026,12 +28452,12 @@ var OpfsFs = class {
     if (!move) return false;
     for (let attempt = 0; ; attempt++) {
       this.others++;
-      const failed3 = await move.call(handle, dir, name2).then(
+      const failed5 = await move.call(handle, dir, name2).then(
         () => void 0,
         (err) => ({ err })
       );
-      if (!failed3) return true;
-      const error = failed3.err?.name;
+      if (!failed5) return true;
+      const error = failed5.err?.name;
       if (handle.kind !== "file" || !LOCKED.has(error)) return false;
       const delay2 = SYNC_BACKOFF_MS[attempt];
       if (delay2 === void 0) throw fsError("EBUSY", name2);
@@ -28072,7 +28498,7 @@ var OpfsFs = class {
     this.refuse(at);
     if (await this.exactly(() => this.locate(at, false)).then(
       () => true,
-      (err) => !missing4(err)
+      (err) => !missing5(err)
     )) {
       throw fsError("EEXIST", path);
     }
@@ -28594,22 +29020,22 @@ async function mountFstab(lines2, mount, signal, retries = FSTAB_RETRIES, discar
   );
 }
 async function mountLine({ line, spec, invalid }, mount, signal, retries, discard) {
-  let failed3 = invalid;
+  let failed5 = invalid;
   for (let attempt = 0; !invalid && attempt <= retries.length && !signal.aborted; attempt++) {
     try {
       const entry = await mount(spec);
       if (!signal.aborted) return { line, target: spec.target, entry };
       discard(entry);
-      failed3 = Object.assign(new Error("the kernel stopped"), { code: "ECANCELED" });
+      failed5 = Object.assign(new Error("the kernel stopped"), { code: "ECANCELED" });
       break;
     } catch (err) {
-      failed3 = err;
+      failed5 = err;
       if (FINAL.has(codeOf6(err)) || attempt === retries.length) break;
       await wait(retries[attempt], signal);
     }
   }
-  const code = codeOf6(failed3);
-  return { line, target: spec.target, code, error: String(failed3?.message ?? code) };
+  const code = codeOf6(failed5);
+  return { line, target: spec.target, code, error: String(failed5?.message ?? code) };
 }
 
 // src/mount/hostfs.ts
@@ -30211,7 +30637,7 @@ var RULE = new RegExp(
 var TERM = /^[A-Za-z0-9._+-]+$/;
 var PLAIN3 = /^[A-Za-z0-9_@%+=:,./-]+$/;
 var USAGE = "usage: sudo [-n] [-u user] [--] command [args...]\n       sudo -l";
-function failed2(errno3, error) {
+function failed3(errno3, error) {
   return { error, errno: errno3 };
 }
 function unescaped(double) {
@@ -30390,10 +30816,10 @@ var Sudo = class {
   }
   async untrusted(path, cwd, word) {
     const files = this.o.backing ? await this.o.backing(path, cwd) : [];
-    if (!files) return failed2("ENOENT", `sudo: ${word}: command not found`);
+    if (!files) return failed3("ENOENT", `sudo: ${word}: command not found`);
     for (const file of [path, ...files]) {
       if (!await this.trusted(file)) {
-        return failed2("EPERM", `sudo: ${file} must be root's, and writable by root only`);
+        return failed3("EPERM", `sudo: ${file} must be root's, and writable by root only`);
       }
     }
     return void 0;
@@ -30410,7 +30836,7 @@ var Sudo = class {
   }
   async request(caller, call, signal) {
     const parsed2 = parseArgs(call.args);
-    if (typeof parsed2 === "string") return failed2("EINVAL", parsed2);
+    if (typeof parsed2 === "string") return failed3("EINVAL", parsed2);
     if (this.o.mode !== "enforce") {
       const mode = this.o.mode;
       if (parsed2.list) return { list: `sudo: users are '${mode}': commands run as the caller
@@ -30419,9 +30845,9 @@ var Sudo = class {
     }
     const { cred } = caller;
     const self = await this.o.users.lookup(cred.ruid);
-    if (!self) return failed2("EPERM", `sudo: uid ${cred.ruid} is not in the passwd database`);
+    if (!self) return failed3("EPERM", `sudo: uid ${cred.ruid} is not in the passwd database`);
     const target = await this.lookup(parsed2.user);
-    if (!target) return failed2("ENOENT", `sudo: unknown user ${parsed2.user}`);
+    if (!target) return failed3("ENOENT", `sudo: unknown user ${parsed2.user}`);
     const root = cred.euid === 0;
     const rules = root ? [] : await this.policy();
     const applies = await this.applies(self, cred);
@@ -30429,13 +30855,13 @@ var Sudo = class {
     const [word = "", ...args] = parsed2.command;
     const cwd = await this.canonical(call.cwd);
     if (cwd === void 0 || !await this.reachable(cred, cwd)) {
-      return failed2(
+      return failed3(
         "EACCES",
         `sudo: cannot run in ${call.cwd}: it isn't a directory you can enter`
       );
     }
     const path = await this.locate(word, cwd);
-    if (!path) return failed2("ENOENT", `sudo: ${word}: command not found`);
+    if (!path) return failed3("ENOENT", `sudo: ${word}: command not found`);
     const untrusted2 = await this.untrusted(path, cwd, word);
     if (untrusted2) return untrusted2;
     const argv = [path, ...args];
@@ -30446,24 +30872,24 @@ var Sudo = class {
     if (root || matching.some((rule) => rule.nopasswd)) return grant();
     const quoted = argv.map(quoteWord).join(" ");
     if (matching.length === 0) {
-      return failed2(
+      return failed3(
         "EPERM",
         `sudo: ${self.name} is not allowed to run ${quoted} as ${target.name}`
       );
     }
-    if (parsed2.nonInteractive) return failed2("EPERM", "sudo: a password is required");
-    if (this.pending.has(cred.ruid)) return failed2("EBUSY", "sudo: another request is pending");
+    if (parsed2.nonInteractive) return failed3("EPERM", "sudo: a password is required");
+    if (this.pending.has(cred.ruid)) return failed3("EBUSY", "sudo: another request is pending");
     this.pending.add(cred.ruid);
     try {
       const answer2 = await this.ask(caller, self, target, parsed2.command, path, cwd, signal);
       if (typeof answer2 !== "string") return answer2;
       if (await this.canonical(call.cwd) !== cwd || !await this.reachable(cred, cwd)) {
-        return failed2("EACCES", `sudo: ${call.cwd} changed while the request waited`);
+        return failed3("EACCES", `sudo: ${call.cwd} changed while the request waited`);
       }
       const changed = await this.untrusted(path, cwd, word);
       if (changed) return changed;
       if (answer2 === "always" && !await this.remember(self, target, cwd, argv)) {
-        return failed2("EIO", "sudo: the rule could not be recorded");
+        return failed3("EIO", "sudo: the rule could not be recorded");
       }
       return grant();
     } finally {
@@ -30480,7 +30906,7 @@ var Sudo = class {
       };
     }
     if (rules.length === 0) {
-      return failed2("EPERM", `User ${self.name} is not allowed to run sudo on ${host}.`);
+      return failed3("EPERM", `User ${self.name} is not allowed to run sudo on ${host}.`);
     }
     const lines2 = rules.map(described).join("\n");
     return { list: `User ${self.name} may run the following commands on ${host}:
@@ -30489,7 +30915,7 @@ ${lines2}
   }
   async ask(caller, self, target, argv, path, cwd, requester) {
     const { approve } = this.o;
-    if (!approve || requester.aborted) return failed2("EACCES", "sudo: approval denied");
+    if (!approve || requester.aborted) return failed3("EACCES", "sudo: approval denied");
     const createdAt = Date.now();
     const timeout = this.o.timeoutMs ?? SUDO_TIMEOUT_MS;
     const req = {
@@ -30519,9 +30945,9 @@ ${lines2}
       const answered = Promise.resolve().then(() => approve(req, { signal: control.signal })).catch(() => "deny");
       const answer2 = await Promise.race([answered, aborted3]);
       if (answer2 === "aborted" || control.signal.aborted) {
-        return control.signal.reason === "expired" ? failed2("ETIMEDOUT", "sudo: the request expired") : failed2("EINTR", "sudo: the request was withdrawn");
+        return control.signal.reason === "expired" ? failed3("ETIMEDOUT", "sudo: the request expired") : failed3("EINTR", "sudo: the request was withdrawn");
       }
-      return answer2 === "once" || answer2 === "always" ? answer2 : failed2("EACCES", "sudo: approval denied");
+      return answer2 === "once" || answer2 === "always" ? answer2 : failed3("EACCES", "sudo: approval denied");
     } finally {
       clearTimeout(timer);
       requester.removeEventListener("abort", withdraw);
@@ -30808,13 +31234,13 @@ function interpreter(head) {
 function expandDefaults(defaults2, env) {
   const out = {};
   for (const [key, value2] of Object.entries(defaults2 ?? {})) {
-    let missing5 = false;
+    let missing6 = false;
     const expanded = value2.replace(ENV_REFERENCE, (_, name2) => {
       const set3 = Object.hasOwn(env, name2) ? env[name2] : void 0;
-      if (set3 === void 0) missing5 = true;
+      if (set3 === void 0) missing6 = true;
       return set3 ?? "";
     });
-    if (!missing5) out[key] = expanded;
+    if (!missing6) out[key] = expanded;
   }
   return out;
 }
@@ -30989,6 +31415,9 @@ var Launcher = class {
   usersMode;
   dac;
   sealed;
+  fill;
+  fills = new AbortController();
+  placeholders = [];
   scrubs = /* @__PURE__ */ new Map();
   clipboard;
   embedder;
@@ -31070,7 +31499,7 @@ var Launcher = class {
       ...options.env
     };
     this.ca = kernelCa(options.caStore ?? memoryCaStore());
-    this.transport = placeholderFloor(replayingHops(options.transport ?? missingTransport()));
+    this.transport = this.floored(options);
     this.announcedTraits = JSON.stringify(this.transport.traits);
     this.uplink = options.uplink;
     this.routes = new Routes(options.uplink?.traits.ipv6 === true);
@@ -31225,16 +31654,16 @@ var Launcher = class {
     if (!found) {
       found = this.swaps.settled().then(() => this.trustedAppended()).then(async (appended2) => {
         const tiers = await this.tiers(scope, appended2);
-        const refused3 = [];
+        const refused4 = [];
         const commands = await scanCommands(
           this.scanned,
           tiers,
           tiers.length - appended2.length,
           void 0,
-          refused3,
+          refused4,
           await this.globalRoots(scope)
         );
-        this.refusedOf.set(commands, refused3.map(refusing));
+        this.refusedOf.set(commands, refused4.map(refusing));
         return commands;
       }).then(
         (commands) => this.refusals(commands).set(SUDO_COMMAND.name, SUDO_COMMAND).set(CRONTAB_COMMAND.name, CRONTAB_COMMAND)
@@ -31440,14 +31869,14 @@ var Launcher = class {
     return await this.commandAt(path, scope) ?? await this.refusedAt(path, name2, scope);
   }
   async refusedAt(path, name2, scope) {
-    const refused3 = this.refusedOf.get(await this.commands(scope)) ?? [];
-    if (refused3.length === 0) return void 0;
+    const refused4 = this.refusedOf.get(await this.commands(scope)) ?? [];
+    if (refused4.length === 0) return void 0;
     const st = await this.base.stat(path).catch(() => void 0);
     if (!st?.isFile) return void 0;
     const real = await physicalPathAsync(this.base, path).catch(() => path);
     const same2 = async (own) => own === path || await physicalPathAsync(this.base, own).catch(() => own) === real;
     const owners = [];
-    for (const c of refused3) {
+    for (const c of refused4) {
       const origin = c.origin;
       for (const own of [origin.glue, origin.wasm, ...origin.variants ?? []]) {
         if (!await same2(own)) continue;
@@ -31457,11 +31886,11 @@ var Launcher = class {
     }
     const stem = name2.replace(/\.wasm$/, "");
     const named = owners.find((c) => c.name === name2) ?? owners.find((c) => c.name === stem);
-    return named ?? owners[0] ?? await this.refusedCopy(real, name2, refused3);
+    return named ?? owners[0] ?? await this.refusedCopy(real, name2, refused4);
   }
-  async refusedCopy(real, name2, refused3) {
+  async refusedCopy(real, name2, refused4) {
     const dir = real.slice(0, real.lastIndexOf("/"));
-    for (const c of refused3) {
+    for (const c of refused4) {
       const origin = c.origin;
       if (origin.abi !== "emscripten" || origin.script || c.name !== name2) continue;
       const own = await physicalPathAsync(this.base, origin.glue).catch(() => origin.glue);
@@ -31669,12 +32098,12 @@ var Launcher = class {
     return void 0;
   }
   async planOne(req, { ppid, cred, scope }, catalogOnly = false) {
-    const refused3 = (err) => {
+    const refused4 = (err) => {
       throw codeOf8(err) === "EACCES" ? new SpawnError("EACCES") : err;
     };
-    const file = await this.execFile(req.file, req.cwd, this.execGuard(cred, ppid)).catch(refused3);
+    const file = await this.execFile(req.file, req.cwd, this.execGuard(cred, ppid)).catch(refused4);
     const planned = await this.plan(file, req.argv, req.cwd, scope, req.argv0, catalogOnly);
-    await this.mayExec(cred, { ...req, file, pid: ppid }, planned).catch(refused3);
+    await this.mayExec(cred, { ...req, file, pid: ppid }, planned).catch(refused4);
     if (planned) return planned;
     throw new SpawnError(catalogOnly ? "ENOENT" : await this.unrunnable(file, req.cwd, scope));
   }
@@ -32132,6 +32561,19 @@ var Launcher = class {
   groupSession(pgid) {
     return this.jobs.sessionOf(pgid);
   }
+  floored(options) {
+    const { sealedFetch } = options;
+    this.fill = sealedFetch && this.usersMode === "enforce" ? sealedFetcher(sealedFetch, this.fills.signal) : void 0;
+    if (this.fill) this.net.stampProxy(REALM_PROXY_PORT);
+    return placeholderFloor(replayingHops(options.transport ?? missingTransport()), {
+      known: () => this.placeholders,
+      ...this.fill ? { fill: this.fill } : {}
+    });
+  }
+  httpFor(pid) {
+    const stamp = this.fill ? () => this.liveStamp(pid) : void 0;
+    return new HttpHandles(this.transport, pid, this.loopbackFor(pid), stamp);
+  }
   loopbackFor(pid) {
     return new KernelLoopback(
       this.net,
@@ -32139,7 +32581,7 @@ var Launcher = class {
         const cred = this.credOf(pid);
         return { pid, uid: cred.euid, gid: cred.egid };
       },
-      () => this.connectorStamp(pid)
+      () => this.liveStamp(pid)
     );
   }
   sourceCheck(pid, writer) {
@@ -32304,7 +32746,7 @@ var Launcher = class {
       jobs: this.jobs,
       ptys: this.ptys,
       net: this.net,
-      http: new HttpHandles(this.transport, pid, this.loopbackFor(pid)),
+      http: this.httpFor(pid),
       locks: this.locks,
       fifos: this.fifos,
       sems: this.sems,
@@ -32619,6 +33061,19 @@ var Launcher = class {
   connectorStamp(pid) {
     return this.sealed.stamp(this.identityOf(pid), this.credOf(pid), this.tagsOf(pid));
   }
+  async liveStamp(pid) {
+    if (!this.creds.has(pid) || this.zombies.has(pid)) return void 0;
+    return this.connectorStamp(pid);
+  }
+  setPlaceholders(list) {
+    if (!Array.isArray(list) || !list.every((p) => typeof p === "string" && p !== "")) {
+      throw fsError("EINVAL", "setPlaceholders takes a list of non-empty strings");
+    }
+    this.placeholders = [...list];
+  }
+  endFills() {
+    this.fills.abort("terminated");
+  }
   identityOf(pid) {
     const parent = this.jobs.shownParent(pid);
     const alive = parent !== void 0 && this.running(parent);
@@ -32741,7 +33196,7 @@ var Launcher = class {
     const at = normalizePath(path);
     this.unlinked.closed(at);
     this.writers?.unlinked.closed(at);
-    const holding = [...this.held].some((holds2) => holds2.holding(at)) || [...this.openFiles].some((open2) => open2.holdsAt(at));
+    const holding = [...this.held].some((holds3) => holds3.holding(at)) || [...this.openFiles].some((open2) => open2.holdsAt(at));
     if (!holding) void this.rootFs.announceHolds?.([], [at], false);
     const open = [...this.openFiles].some((nodes) => nodes.writes(at)) || heldUnder(this.held, at);
     if (!open) void this.mounts.commit(at).catch(() => void 0);
@@ -32904,8 +33359,9 @@ var Launcher = class {
     for (const root of roots) this.integrity.forget(root);
     this.resetCatalogs();
   }
-  attest(path) {
+  attest(path, options = {}) {
     return attest(this.rootFs, path, {
+      ...options,
       users: this.usersMode,
       mounts: this.mounts.list().map((entry) => entry.target).filter((target) => this.mounts.mounted(target) !== void 0)
     });
@@ -32962,8 +33418,8 @@ var Launcher = class {
       for (const name2 of names2 ?? []) {
         const path = joinName(real, name2);
         if (await this.base.hasOwner(path)) continue;
-        const failed3 = this.inUse(path) ? "busy" : await this.base.rm(path, { recursive: true, force: true }).catch(String);
-        if (failed3 === void 0) removed++;
+        const failed5 = this.inUse(path) ? "busy" : await this.base.rm(path, { recursive: true, force: true }).catch(String);
+        if (failed5 === void 0) removed++;
         else left++;
       }
       if (removed > 0) {
@@ -33058,7 +33514,7 @@ var Launcher = class {
     this.pnpmStale();
     if (!detach) return;
     for (const nodes of this.openFiles) nodes.revoke(at);
-    for (const holds2 of this.held) holds2.revoke(at);
+    for (const holds3 of this.held) holds3.revoke(at);
   }
   unmountAll() {
     this.cron.stop();
@@ -33269,9 +33725,9 @@ var Launcher = class {
   }
   boundTo(path, hidden, fids) {
     const keeping = [...this.held].map(
-      (holds2) => [
-        holds2,
-        fids.flatMap((fid) => [...holds2.boundAt(path, fid), ...holds2.boundAt(hidden, fid)])
+      (holds3) => [
+        holds3,
+        fids.flatMap((fid) => [...holds3.boundAt(path, fid), ...holds3.boundAt(hidden, fid)])
       ]
     ).filter(([, ids]) => ids.length > 0);
     const nodes = [...this.openFiles].filter(
@@ -33282,7 +33738,7 @@ var Launcher = class {
         (open) => fids.some((fid) => open.keepBound([hidden, path], fid, file))
       ).length;
       for (let i = kept; i < nodes.length; i++) file.release();
-      for (const [holds2, ids] of keeping) holds2.keepBound(ids, path, file);
+      for (const [holds3, ids] of keeping) holds3.keepBound(ids, path, file);
       void this.rootFs.announceHolds?.([], [path, hidden], false);
     };
     return { keeping, nodes, keep: keep2 };
@@ -33442,7 +33898,7 @@ var Launcher = class {
   }
   moved(from, to, source) {
     this.renameLog.add(from, to);
-    for (const holds2 of this.held) holds2.renamed(from, to);
+    for (const holds3 of this.held) holds3.renamed(from, to);
     if (source) return;
     for (const nodes of this.openFiles) nodes.renamed(from, to);
     this.watchers.moved(from, to);
@@ -33587,26 +34043,6 @@ function codeOf8(err) {
   return err?.code;
 }
 
-// src/body-idle.ts
-var BODY_IDLE_MS = 5 * 60 * 1e3;
-function idleFailure(ms) {
-  return Object.assign(new Error(`the response body sent no data for ${ms} ms`), {
-    code: "ETIMEDOUT"
-  });
-}
-async function readWithin(reader, ms) {
-  if (!(ms > 0 && ms < Number.POSITIVE_INFINITY)) return reader.read();
-  let timer;
-  const idle2 = new Promise((_, reject) => {
-    timer = setTimeout(() => reject(idleFailure(ms)), ms);
-  });
-  try {
-    return await Promise.race([reader.read(), idle2]);
-  } finally {
-    clearTimeout(timer);
-  }
-}
-
 // src/websocket-transport.ts
 var SENT_HEADERS_DROP = /* @__PURE__ */ new Set([
   "host",
@@ -33756,10 +34192,11 @@ function fetchTransport(options = {}) {
   const send2 = options.fetch ?? globalThis.fetch.bind(globalThis);
   const Socket = options.webSocket === true ? globalThis.WebSocket : options.webSocket || void 0;
   const headers = options.webSocketHeaders === true;
-  const redirect = options.redirect ?? "follow";
+  const instance = options.redirect ?? "follow";
   return {
     traits: {
-      manualRedirects: redirect === "manual",
+      manualRedirects: instance === "manual",
+      redirectPolicy: true,
       encodedBodies: false,
       maxRequestBody: options.maxRequestBody ?? MAX_REQUEST_BODY,
       crossOrigin: "cors",
@@ -33775,7 +34212,7 @@ function fetchTransport(options = {}) {
           headers: joinHeaders(request.headers),
           ...requestBody(request),
           signal: request.signal,
-          redirect,
+          redirect: request.redirect ?? instance,
           credentials: "omit",
           mode: "cors"
         });
@@ -33799,6 +34236,7 @@ function fetchTransport(options = {}) {
       const body = chunks(response.body, options.bodyIdleMs ?? BODY_IDLE_MS);
       return {
         ...response.redirected ? { url: response.url, redirected: true } : {},
+        ...response.type === "opaqueredirect" ? { opaqueRedirect: true } : {},
         status: response.status,
         statusText: response.statusText,
         headers: headers2,
@@ -33834,7 +34272,34 @@ function uploadsFor(peer) {
   });
   return { of, answer: (call) => pulls.get(call.nid)?.(call) };
 }
-function serveTransport(peer, transport, { closeWaitMs = CLOSE_WAIT_MS3 } = {}) {
+function headOf(nid, response) {
+  return {
+    net: "head",
+    nid,
+    ...response.url !== void 0 ? { url: response.url } : {},
+    ...response.redirected !== void 0 ? { redirected: response.redirected } : {},
+    ...response.redirects ? { redirects: response.redirects } : {},
+    ...response.opaqueRedirect ? { opaqueRedirect: true } : {},
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  };
+}
+function requestOf(call, signal, uploads) {
+  const { url, method, headers, streamed, body, redirect, nid } = call;
+  return {
+    url,
+    method,
+    headers,
+    ...streamed ? { bodyStream: uploads.of(nid, signal) } : body ? { body } : {},
+    ...redirect !== void 0 ? { redirect } : {},
+    signal
+  };
+}
+function serveTransport(peer, transport, {
+  closeWaitMs = CLOSE_WAIT_MS3,
+  attributed = false
+} = {}) {
   const open = /* @__PURE__ */ new Map();
   const fail3 = (nid, e) => {
     open.delete(nid);
@@ -33854,27 +34319,17 @@ function serveTransport(peer, transport, { closeWaitMs = CLOSE_WAIT_MS3 } = {})
     const entry = { abort };
     open.set(call.nid, entry);
     try {
-      const response = await transport.fetch({
-        url: call.url,
-        method: call.method,
-        headers: call.headers,
-        ...call.streamed ? { bodyStream: uploads.of(call.nid, abort.signal) } : call.body ? { body: call.body } : {},
-        signal: abort.signal
-      });
+      const response = await transport.fetch(
+        requestOf(call, abort.signal, uploads),
+        attributed ? call.owner : void 0,
+        attributed ? call.stamp : void 0
+      );
       if (!open.has(call.nid)) {
         await response.cancel();
         return;
       }
       open.set(call.nid, { abort, body: response.body[Symbol.asyncIterator](), response });
-      peer.postMessage({
-        net: "head",
-        nid: call.nid,
-        ...response.redirected ? { url: response.url, redirected: true } : {},
-        ...response.redirects ? { redirects: response.redirects } : {},
-        status: response.status,
-        statusText: response.statusText,
-        headers: response.headers
-      });
+      peer.postMessage(headOf(call.nid, response));
     } catch (e) {
       fail3(call.nid, e);
     }
@@ -34374,9 +34829,9 @@ function serveClient(port, host) {
     ended.resolve();
   }
   async function hello(message3) {
-    const refused3 = versionError(message3.protocol) ?? await hosts.requests.accept(host, message3);
-    if (refused3) {
-      send2({ hello: { protocol: PROTOCOL, error: refused3 } });
+    const refused4 = versionError(message3.protocol) ?? await hosts.requests.accept(host, message3);
+    if (refused4) {
+      send2({ hello: { protocol: PROTOCOL, error: refused4 } });
       detach();
       return;
     }
@@ -34520,6 +34975,60 @@ import { AsyncLocalStorage } from "node:async_hooks";
 import { subscribe } from "node:diagnostics_channel";
 import { lookup as lookup2 } from "node:dns/promises";
 import { isIP as isIP3 } from "node:net";
+
+// src/node/follow.ts
+var MAX_REDIRECTS = 20;
+var REDIRECTS = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
+var BODY_HEADERS = /* @__PURE__ */ new Set([
+  "content-encoding",
+  "content-language",
+  "content-length",
+  "content-location",
+  "content-type"
+]);
+var CREDENTIALS = /* @__PURE__ */ new Set(["authorization", "proxy-authorization", "cookie", "cookie2"]);
+function failed4(message3) {
+  return Object.assign(new Error(message3), { status: 502, detail: "transport" });
+}
+function locationOf(headers) {
+  return headers.find(([name2]) => name2.toLowerCase() === "location")?.[1];
+}
+function nextHop(hop, status, location) {
+  if (!URL.canParse(location, hop.url)) throw failed4(`a bad redirect from ${hop.url}`);
+  const next3 = new URL(location, hop.url);
+  if (next3.protocol !== "http:" && next3.protocol !== "https:") {
+    throw failed4(`a redirect from ${hop.url} to ${next3.protocol}`);
+  }
+  next3.hash = "";
+  const toGet = (status === 301 || status === 302) && hop.method === "POST" || status === 303 && hop.method !== "GET" && hop.method !== "HEAD";
+  if (hop.bodyStream && !toGet) throw failed4(`a ${status} redirect would resend a streamed body`);
+  const crossOrigin = next3.origin !== new URL(hop.url).origin;
+  const { body, bodyStream: bodyStream2, ...rest2 } = hop;
+  return {
+    ...rest2,
+    ...body && !toGet ? { body } : {},
+    url: next3.href,
+    method: toGet ? "GET" : hop.method,
+    headers: hop.headers.filter(
+      ([name2]) => !(toGet && BODY_HEADERS.has(name2.toLowerCase())) && !(crossOrigin && CREDENTIALS.has(name2.toLowerCase()))
+    )
+  };
+}
+async function followRedirects(send2, request) {
+  let hop = { ...request, redirect: "manual" };
+  for (let hops = 0; ; hops++) {
+    const response = await send2(hop);
+    const location = locationOf(response.headers);
+    if (!REDIRECTS.has(response.status) || location === void 0) {
+      return hops > 0 ? { ...response, url: hop.url, redirected: true } : response;
+    }
+    await response.cancel();
+    if (hops >= MAX_REDIRECTS) throw failed4(`too many redirects from ${request.url}`);
+    hop = nextHop(hop, response.status, location);
+  }
+}
+
+// src/node/loopback.ts
 var DEVTOOLS_PORTS = [9222, 9223, 9224, 9225, 9226, 9227, 9228, 9229];
 var METADATA_V6 = [64768, 3778, 0, 0, 0, 0, 0, 596].join(":");
 var resolveHost = async (host) => (await lookup2(host, { all: true, verbatim: true })).map((a) => a.address);
@@ -34597,7 +35106,7 @@ async function checkDestination(target, policy, resolve2 = resolveHost) {
     throw refusal2(url, address, place);
   }
 }
-function guarded2(check, signal) {
+function guarded3(check, signal) {
   if (!signal) return check;
   signal.throwIfAborted();
   let stop = () => {
@@ -34684,22 +35193,23 @@ function ensureSubscribed() {
 function guardedLoopback(transport, policy, resolve2) {
   ensureSubscribed();
   const open = transport.websocket?.bind(transport);
+  const send2 = async (request, owner, stamp) => {
+    await guarded3(checkDestination(request.url, policy, resolve2), request.signal);
+    const entry = { policy };
+    try {
+      return await loopbackStore.run(entry, () => transport.fetch(request, owner, stamp));
+    } catch (err) {
+      throw entry.refused ?? err;
+    }
+  };
   return {
     get traits() {
       return transport.traits;
     },
-    fetch: async (request, owner) => {
-      await guarded2(checkDestination(request.url, policy, resolve2), request.signal);
-      const entry = { policy };
-      try {
-        return await loopbackStore.run(entry, () => transport.fetch(request, owner));
-      } catch (err) {
-        throw entry.refused ?? err;
-      }
-    },
+    fetch: (request, owner, stamp) => request.redirect === "follow" ? followRedirects((hop) => send2(hop, owner, stamp), request) : send2(request, owner, stamp),
     ...open ? {
       websocket: async (request) => {
-        await guarded2(checkDestination(request.url, policy, resolve2), request.signal);
+        await guarded3(checkDestination(request.url, policy, resolve2), request.signal);
         const entry = { policy };
         try {
           return await loopbackStore.run(entry, () => open(request));
@@ -35082,212 +35592,6 @@ function diagnosing(transport, check = byDefault) {
   };
 }
 
-// src/kernel/net/remote-transport.ts
-var TransportError = class extends Error {
-  status;
-  code;
-  detail;
-  constructor(message3, status, code, detail) {
-    super(message3);
-    this.status = status;
-    this.code = code;
-    this.detail = detail === "transport" ? detail : void 0;
-  }
-};
-var RemoteTransport = class {
-  traits;
-  port;
-  waiting = /* @__PURE__ */ new Map();
-  nextId = 0;
-  sockets = /* @__PURE__ */ new Map();
-  uploads = /* @__PURE__ */ new Map();
-  failure;
-  constructor(port, traits) {
-    this.port = port;
-    this.traits = traits;
-  }
-  receive(reply) {
-    if (reply.net === "body-pull") {
-      void this.pull(reply.nid);
-      return;
-    }
-    const socket = this.sockets.get(reply.nid);
-    if (socket && this.toSocket(reply, socket)) return;
-    const waiter = this.waiting.get(reply.nid);
-    if (!waiter) return;
-    this.waiting.delete(reply.nid);
-    if (reply.net === "error") {
-      waiter.reject(new TransportError(reply.message, reply.status, reply.code, reply.detail));
-    } else waiter.resolve(reply);
-  }
-  toSocket(reply, socket) {
-    if (reply.net === "ws-message") socket.queue.push(reply.data);
-    else if (reply.net === "ws-acked") socket.acked(reply.n);
-    else if (reply.net === "ws-closed") {
-      this.sockets.delete(reply.nid);
-      socket.queue.end({ code: reply.code, reason: reply.reason });
-    } else return false;
-    return true;
-  }
-  async pull(nid) {
-    const upload = this.uploads.get(nid);
-    if (!upload) {
-      this.port.postMessage({ net: "body-error", nid, message: "the request body is gone" });
-      return;
-    }
-    try {
-      const next3 = await upload.next();
-      if (next3.done) {
-        this.uploads.delete(nid);
-        this.port.postMessage({ net: "body-end", nid });
-      } else this.port.postMessage({ net: "body-chunk", nid, bytes: next3.value });
-    } catch (e) {
-      this.uploads.delete(nid);
-      this.port.postMessage({
-        net: "body-error",
-        nid,
-        message: e instanceof Error ? e.message : String(e)
-      });
-    }
-  }
-  dropUpload(nid) {
-    const upload = this.uploads.get(nid);
-    this.uploads.delete(nid);
-    void upload?.return?.().catch(() => void 0);
-  }
-  fail(error) {
-    this.failure = error;
-    for (const nid of [...this.uploads.keys()]) this.dropUpload(nid);
-    for (const waiter of this.waiting.values()) waiter.reject(error);
-    this.waiting.clear();
-    for (const socket of this.sockets.values())
-      socket.queue.end({ code: 1011, reason: error.message });
-    this.sockets.clear();
-  }
-  ask(call) {
-    if (this.failure) return Promise.reject(this.failure);
-    return new Promise((resolve2, reject) => {
-      this.waiting.set(call.nid, { resolve: resolve2, reject });
-      this.port.postMessage(call);
-    });
-  }
-  cancel(nid) {
-    const waiter = this.waiting.get(nid);
-    this.waiting.delete(nid);
-    waiter?.reject(new TransportError("the request was cancelled"));
-    this.port.postMessage({ net: "cancel", nid });
-  }
-  async fetch(request) {
-    const nid = ++this.nextId;
-    const { signal } = request;
-    signal.throwIfAborted();
-    let finished = false;
-    const abort = () => {
-      finished = true;
-      this.dropUpload(nid);
-      this.cancel(nid);
-    };
-    signal.addEventListener("abort", abort, { once: true });
-    const finish = () => {
-      this.dropUpload(nid);
-      if (finished) return;
-      finished = true;
-      signal.removeEventListener("abort", abort);
-    };
-    if (request.bodyStream) this.uploads.set(nid, request.bodyStream[Symbol.asyncIterator]());
-    let head;
-    try {
-      head = await this.ask({
-        net: "fetch",
-        nid,
-        url: request.url,
-        method: request.method,
-        headers: request.headers,
-        ...request.bodyStream ? { streamed: true } : request.body ? { body: request.body } : {}
-      });
-    } catch (e) {
-      finish();
-      throw e;
-    }
-    const { status, statusText, headers, url, redirected: redirected2, redirects } = head;
-    const read = async () => {
-      if (finished) return void 0;
-      const reply = await this.ask({ net: "read", nid }).catch((e) => {
-        finish();
-        throw e;
-      });
-      if (reply.net === "chunk") return reply.bytes;
-      finish();
-      return void 0;
-    };
-    const cancel = async () => {
-      if (finished) return;
-      finish();
-      this.cancel(nid);
-    };
-    return {
-      ...redirected2 ? { url, redirected: redirected2 } : {},
-      ...redirects ? { redirects } : {},
-      status,
-      statusText,
-      headers,
-      cancel,
-      body: {
-        [Symbol.asyncIterator]: () => ({
-          next: async () => {
-            const bytes = await read();
-            return bytes ? { value: bytes, done: false } : { value: void 0, done: true };
-          },
-          return: async () => {
-            await cancel();
-            return { value: void 0, done: true };
-          }
-        })
-      }
-    };
-  }
-  async websocket(request) {
-    const nid = ++this.nextId;
-    const { signal } = request;
-    signal.throwIfAborted();
-    const abort = () => this.cancel(nid);
-    signal.addEventListener("abort", abort, { once: true });
-    let opened2;
-    try {
-      opened2 = await this.ask({
-        net: "ws-open",
-        nid,
-        url: request.url,
-        protocols: request.protocols,
-        headers: request.headers
-      });
-    } finally {
-      signal.removeEventListener("abort", abort);
-    }
-    const close = (code, reason) => this.port.postMessage({ net: "ws-close", nid, code, reason });
-    const queue = new MessageQueue(
-      () => close(1e3, "a message is too big"),
-      Number.POSITIVE_INFINITY,
-      (n) => this.port.postMessage({ net: "ws-consumed", nid, n })
-    );
-    let unacked = 0;
-    this.sockets.set(nid, { queue, acked: (n) => void (unacked -= n) });
-    return {
-      protocol: opened2.protocol,
-      get buffered() {
-        return unacked;
-      },
-      send: (data) => {
-        unacked += payloadSize(data);
-        this.port.postMessage({ net: "ws-send", nid, data });
-      },
-      messages: queue,
-      close,
-      closed: queue.closed
-    };
-  }
-};
-
 // src/serve.ts
 function signalNumber(name2) {
   const key = name2.slice(3);
@@ -35921,9 +36225,9 @@ async function greet(channel, lock, timeoutMs, requests) {
   } finally {
     clearTimeout(timer);
   }
-  const refused3 = hello.error ?? versionError(hello.protocol);
-  if (refused3) {
-    const error = new Error(refused3);
+  const refused4 = hello.error ?? versionError(hello.protocol);
+  if (refused4) {
+    const error = new Error(refused4);
     channel.end(error);
     throw error;
   }
@@ -36289,6 +36593,7 @@ function checkedRequests(hook) {
   return { kinds, handle: (request) => hook.handle(request) };
 }
 async function createNodeKernel(options = {}) {
+  const hooks = sealedHooks(options.sealed);
   const root = options.root ?? memoryRoot();
   const fs = new OpfsFs(root, void 0, void 0, { ranged: isMemoryRoot(root) });
   await fs.reconcile();
@@ -36327,7 +36632,8 @@ async function createNodeKernel(options = {}) {
     users: options.users === void 0 ? DEFAULT_USERS : options.users,
     ...options.onDenial ? { onDenial: options.onDenial } : {},
     ...options.protect ? { protect: options.protect } : {},
-    ...options.sealed ? { sealed: options.sealed } : {},
+    ...hooks.request ? { sealed: hooks.request } : {},
+    ...hooks.fetch ? { sealedFetch: hooks.fetch } : {},
     ...options.clipboard ? { clipboard: options.clipboard } : {},
     ...options.requests ? { embedder: checkedRequests(options.requests) } : {},
     ...options.approve ? { approve: options.approve } : {},
@@ -36403,6 +36709,8 @@ async function createNodeKernel(options = {}) {
     },
     chmod: async (path, mode) => launcher.fs.chmod(path, modeOption(mode)),
     integrity: { revoke: (path) => guard2(() => launcher.revokeIntegrity(path)) },
+    sealed: { setPlaceholders: (list) => guard2(async () => launcher.setPlaceholders(list)) },
+    attest: ((path, attestOptions) => guard2(() => launcher.attest(path, attestOptions))),
     readFile: async (path) => launcher.fs.readFileBuffer(path),
     mount: (spec) => guard2(() => launcher.mount(spec)),
     umount: (target) => guard2(async () => launcher.umount(target)),
@@ -36435,6 +36743,7 @@ async function createNodeKernel(options = {}) {
       for (const reject of [...pending]) reject(new Error(TERMINATED));
       for (const kill of [...live]) kill();
       launcher.cdp.close();
+      launcher.endFills();
       launcher.unmountAll();
       dropCache(cache);
     }
@@ -36444,6 +36753,7 @@ export {
   KernelCallError,
   KernelGoneError,
   MAX_WARM_WORKERS,
+  SEALED_FETCH_VERSION,
   WARM_IDLE_MS,
   attachKernel,
   createNodeKernel,