@ai-ecoverse/slicc-kernel 1.171.0 → 1.172.1

package/dist/node.js

@@ -2362,9 +2362,9 @@ var KernelSocket = class _KernelSocket {
         case SO_TYPE:
           return SOCK_STREAM;
         case SO_ERROR: {
-          const failed4 = this.failed;
+          const failed5 = this.failed;
           this.failed = void 0;
-          return failed4 ? wasiErrno(failed4) : 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.171.0" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.172.1" : "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
@@ -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 failed4;
+    let failed5;
     let out;
     try {
       out = await op();
     } catch (err) {
-      failed4 = 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 (failed4 !== void 0) throw failed4;
+    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) {
@@ -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) {
@@ -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;
   }
 };
@@ -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 failed4 = false;
+      let failed5 = false;
       try {
         await file.changed(round.signal);
       } catch {
-        failed4 = 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 (failed4) await pause(RETRY_MS, signal);
+      if (failed5) await pause(RETRY_MS, signal);
     }
   }
 };
@@ -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 failed4 = e.detail === "transport";
-      return { ok: false, errno: errno3, message: text, ...failed4 ? { 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 failed4;
+  let failed5;
   const waiters = /* @__PURE__ */ new Set();
   const quiet3 = () => !busy && pending === 0;
   const wake = () => {
     for (const waiter of [...waiters]) waiter();
   };
   const raise = () => {
-    if (failed4 === void 0) return;
-    const err = failed4;
-    failed4 = 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 (failed4 === void 0) failed4 = 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);
@@ -25365,7 +25392,7 @@ var RemoteTransport = class {
     waiter?.reject(new TransportError("the request was cancelled"));
     this.port.postMessage({ net: "cancel", nid });
   }
-  async fetch(request) {
+  async fetch(request, owner, stamp) {
     const nid = ++this.nextId;
     const { signal, redirect } = request;
     signal.throwIfAborted();
@@ -25395,7 +25422,9 @@ var RemoteTransport = class {
         method: request.method,
         headers: request.headers,
         ...request.bodyStream ? { streamed: true } : request.body ? { body: request.body } : {},
-        ...redirect !== void 0 ? { redirect } : {}
+        ...redirect !== void 0 ? { redirect } : {},
+        ...owner !== void 0 ? { owner } : {},
+        ...stamp ? { stamp } : {}
       });
     } catch (e) {
       finish();
@@ -25586,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_"];
@@ -25758,11 +25954,11 @@ var PackageLocks = class {
     if (!locks) return Promise.resolve(() => {
     });
     const { promise: held, resolve: release } = Promise.withResolvers();
-    return new Promise((granted2, failed4) => {
+    return new Promise((granted2, failed5) => {
       locks.request(replacingLock(this.metadata, root), { mode: "exclusive" }, () => {
         granted2(() => release());
         return held;
-      }).catch(failed4);
+      }).catch(failed5);
     });
   }
 };
@@ -26146,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);
@@ -26174,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";
 }
@@ -26417,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) => {
@@ -26860,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;
       }
@@ -26872,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 };
@@ -27108,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;
       }
     );
@@ -27405,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);
@@ -27497,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";
@@ -27633,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;
       }
     );
@@ -27665,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);
@@ -28256,12 +28452,12 @@ var OpfsFs = class {
     if (!move) return false;
     for (let attempt = 0; ; attempt++) {
       this.others++;
-      const failed4 = await move.call(handle, dir, name2).then(
+      const failed5 = await move.call(handle, dir, name2).then(
         () => void 0,
         (err) => ({ err })
       );
-      if (!failed4) return true;
-      const error = failed4.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);
@@ -28302,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);
     }
@@ -28824,22 +29020,22 @@ async function mountFstab(lines2, mount, signal, retries = FSTAB_RETRIES, discar
   );
 }
 async function mountLine({ line, spec, invalid }, mount, signal, retries, discard) {
-  let failed4 = 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);
-      failed4 = Object.assign(new Error("the kernel stopped"), { code: "ECANCELED" });
+      failed5 = Object.assign(new Error("the kernel stopped"), { code: "ECANCELED" });
       break;
     } catch (err) {
-      failed4 = err;
+      failed5 = err;
       if (FINAL.has(codeOf6(err)) || attempt === retries.length) break;
       await wait(retries[attempt], signal);
     }
   }
-  const code = codeOf6(failed4);
-  return { line, target: spec.target, code, error: String(failed4?.message ?? code) };
+  const code = codeOf6(failed5);
+  return { line, target: spec.target, code, error: String(failed5?.message ?? code) };
 }
 
 // src/mount/hostfs.ts
@@ -30441,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) {
@@ -30620,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;
@@ -30640,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
@@ -30649,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);
@@ -30659,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];
@@ -30676,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 {
@@ -30710,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}:
@@ -30719,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 = {
@@ -30749,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);
@@ -31038,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;
 }
@@ -31219,6 +31415,9 @@ var Launcher = class {
   usersMode;
   dac;
   sealed;
+  fill;
+  fills = new AbortController();
+  placeholders = [];
   scrubs = /* @__PURE__ */ new Map();
   clipboard;
   embedder;
@@ -31300,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);
@@ -32362,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,
@@ -32369,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) {
@@ -32534,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,
@@ -32849,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);
@@ -32971,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);
@@ -33134,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)
     });
@@ -33192,8 +33418,8 @@ var Launcher = class {
       for (const name2 of names2 ?? []) {
         const path = joinName(real, name2);
         if (await this.base.hasOwner(path)) continue;
-        const failed4 = this.inUse(path) ? "busy" : await this.base.rm(path, { recursive: true, force: true }).catch(String);
-        if (failed4 === 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) {
@@ -33288,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();
@@ -33499,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(
@@ -33512,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 };
@@ -33672,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);
@@ -33817,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",
@@ -33960,6 +34166,11 @@ async function* chunks(body, idleMs) {
     await reader.cancel().catch(() => void 0);
   }
 }
+function sentHeaders(headers, inPage) {
+  const out = joinHeaders(headers);
+  if (inPage) out.delete("user-agent");
+  return out;
+}
 function streamOf(body) {
   const it = body[Symbol.asyncIterator]();
   return new ReadableStream(
@@ -33987,6 +34198,7 @@ function fetchTransport(options = {}) {
   const Socket = options.webSocket === true ? globalThis.WebSocket : options.webSocket || void 0;
   const headers = options.webSocketHeaders === true;
   const instance = options.redirect ?? "follow";
+  const inPage = !options.fetch && "location" in globalThis;
   return {
     traits: {
       manualRedirects: instance === "manual",
@@ -34003,7 +34215,7 @@ function fetchTransport(options = {}) {
       try {
         response = await send2(request.url, {
           method: request.method,
-          headers: joinHeaders(request.headers),
+          headers: sentHeaders(request.headers, inPage),
           ...requestBody(request),
           signal: request.signal,
           redirect: request.redirect ?? instance,
@@ -34079,7 +34291,21 @@ function headOf(nid, response) {
     headers: response.headers
   };
 }
-function serveTransport(peer, transport, { closeWaitMs = CLOSE_WAIT_MS3 } = {}) {
+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);
@@ -34099,14 +34325,11 @@ 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 } : {},
-        ...call.redirect !== void 0 ? { redirect: call.redirect } : {},
-        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;
@@ -34770,21 +34993,21 @@ var BODY_HEADERS = /* @__PURE__ */ new Set([
   "content-type"
 ]);
 var CREDENTIALS = /* @__PURE__ */ new Set(["authorization", "proxy-authorization", "cookie", "cookie2"]);
-function failed3(message3) {
+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 failed3(`a bad redirect from ${hop.url}`);
+  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 failed3(`a redirect from ${hop.url} to ${next3.protocol}`);
+    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 failed3(`a ${status} redirect would resend a streamed body`);
+  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 {
@@ -34806,7 +35029,7 @@ async function followRedirects(send2, request) {
       return hops > 0 ? { ...response, url: hop.url, redirected: true } : response;
     }
     await response.cancel();
-    if (hops >= MAX_REDIRECTS) throw failed3(`too many redirects from ${request.url}`);
+    if (hops >= MAX_REDIRECTS) throw failed4(`too many redirects from ${request.url}`);
     hop = nextHop(hop, response.status, location);
   }
 }
@@ -34889,7 +35112,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 = () => {
@@ -34976,11 +35199,11 @@ function ensureSubscribed() {
 function guardedLoopback(transport, policy, resolve2) {
   ensureSubscribed();
   const open = transport.websocket?.bind(transport);
-  const send2 = async (request, owner) => {
-    await guarded2(checkDestination(request.url, policy, resolve2), request.signal);
+  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));
+      return await loopbackStore.run(entry, () => transport.fetch(request, owner, stamp));
     } catch (err) {
       throw entry.refused ?? err;
     }
@@ -34989,10 +35212,10 @@ function guardedLoopback(transport, policy, resolve2) {
     get traits() {
       return transport.traits;
     },
-    fetch: (request, owner) => request.redirect === "follow" ? followRedirects((hop) => send2(hop, owner), request) : send2(request, owner),
+    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));
@@ -36376,6 +36599,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();
@@ -36414,7 +36638,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 } : {},
@@ -36490,6 +36715,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)),
@@ -36522,6 +36749,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);
     }
@@ -36531,6 +36759,7 @@ export {
   KernelCallError,
   KernelGoneError,
   MAX_WARM_WORKERS,
+  SEALED_FETCH_VERSION,
   WARM_IDLE_MS,
   attachKernel,
   createNodeKernel,