@ai-ecoverse/slicc-kernel 1.170.4 → 1.172.0

package/dist/kernel-worker.js

@@ -182,13 +182,13 @@ var IndexedDbMeta = class {
     return [transaction, transaction.objectStore(META_STORE)];
   }
   async get(paths) {
-    const missing5 = paths.filter((path) => !this.cache.has(path));
-    if (missing5.length > 0) {
+    const missing6 = paths.filter((path) => !this.cache.has(path));
+    if (missing6.length > 0) {
       this.settleRemoves();
       const generation = this.generation;
       const [transaction, store] = this.transaction("readonly");
       const found = /* @__PURE__ */ new Map();
-      for (const path of missing5) {
+      for (const path of missing6) {
         const request3 = store.get(path);
         request3.onsuccess = () => void found.set(path, request3.result ?? null);
       }
@@ -1237,10 +1237,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);
@@ -1524,11 +1524,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 guarded2 = (op) => (...args) => meta[op].apply(meta, args).catch((err) => {
+  const guarded3 = (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, guarded2(op)]));
+  const ops = Object.fromEntries(names2.map((op) => [op, guarded3(op)]));
   const { updateMany } = meta;
   ops.updateMany = updateMany ? (changes) => updateMany.call(meta, changes).catch((err) => {
     throw translate(err, changes[0]?.path ?? "/", "sidecar", false);
@@ -3638,12 +3638,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 failed4 = await move.call(handle, dir, name2).then(
         () => void 0,
         (err) => ({ err })
       );
-      if (!failed3) return true;
-      const error = failed3.err?.name;
+      if (!failed4) return true;
+      const error = failed4.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);
@@ -6842,9 +6842,9 @@ var KernelSocket = class _KernelSocket {
         case SO_TYPE:
           return SOCK_STREAM;
         case SO_ERROR: {
-          const failed3 = this.failed;
+          const failed4 = this.failed;
           this.failed = void 0;
-          return failed3 ? wasiErrno(failed3) : 0;
+          return failed4 ? wasiErrno(failed4) : 0;
         }
         case SO_ACCEPTCONN:
           return this.state === "listening" ? 1 : 0;
@@ -6924,6 +6924,7 @@ var LoopbackNet = class {
   internal = /* @__PURE__ */ new Set();
   reserved = /* @__PURE__ */ new Set();
   facades = /* @__PURE__ */ new Map();
+  proxyStamped;
   nextEphemeral = EPHEMERAL_FIRST;
   route;
   origins;
@@ -6998,9 +6999,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);
@@ -7310,7 +7317,34 @@ function uploadsFor(peer) {
   });
   return { of, answer: (call) => pulls.get(call.nid)?.(call) };
 }
-function serveTransport(peer, transport, { closeWaitMs = CLOSE_WAIT_MS2 } = {}) {
+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_MS2,
+  attributed = false
+} = {}) {
   const open2 = /* @__PURE__ */ new Map();
   const fail2 = (nid, e) => {
     open2.delete(nid);
@@ -7330,27 +7364,17 @@ function serveTransport(peer, transport, { closeWaitMs = CLOSE_WAIT_MS2 } = {})
     const entry = { abort };
     open2.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 (!open2.has(call.nid)) {
         await response.cancel();
         return;
       }
       open2.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) {
       fail2(call.nid, e);
     }
@@ -8206,9 +8230,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;
     }
@@ -8498,7 +8522,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
@@ -8790,10 +8814,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,
@@ -8825,7 +8849,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(
@@ -8839,7 +8863,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));
   }
@@ -9155,32 +9179,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);
   }
@@ -9892,12 +9916,12 @@ var UnlinkedKeeper = class {
     return this.locks;
   }
   async undoing(op, peers, sends, heard, shared2 = []) {
-    let failed3;
+    let failed4;
     let out;
     try {
       out = await op();
     } catch (err) {
-      failed3 = err ?? new Error("failed");
+      failed4 = err ?? new Error("failed");
       await this.rollBackAsides(sends, shared2);
     }
     const hiddenShared = new Set(shared2.map((one) => one.hidden));
@@ -9918,7 +9942,7 @@ var UnlinkedKeeper = class {
       const done5 = () => one.release().then(() => this.dropIfLast(one.hidden));
       void Promise.all(waits.map(({ told }) => told)).then(done5, done5);
     }
-    if (failed3 !== void 0) throw failed3;
+    if (failed4 !== void 0) throw failed4;
     return out;
   }
   async rollBackAsides(sends, shared2) {
@@ -10065,7 +10089,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 done5 = () => {
@@ -10073,7 +10097,7 @@ var systemCronClock = {
         signal.removeEventListener("abort", done5);
         resolve2();
       };
-      const timer = setTimeout(done5, Math.max(0, until - Date.now()));
+      const timer = setTimeout(done5, Math.max(0, until2 - Date.now()));
       timer.unref?.();
       signal.addEventListener("abort", done5, { once: true });
     });
@@ -10177,15 +10201,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;
@@ -10402,14 +10426,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))
@@ -10417,35 +10444,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(request3) {
-  if (urlCarries(request3.url) || headersCarry(request3.headers)) throw new PlaceholderRefused();
+function detected(request3, known) {
+  return urlCarries(request3.url, known) || headersCarry(request3.headers, known);
 }
-function refuseSocket(request3) {
-  refuse(request3);
-  if (request3.protocols.some(carries)) throw new PlaceholderRefused();
+function refuseSocket(request3, known) {
+  if (detected(request3, known) || request3.protocols.some((p) => carries(p, known))) {
+    throw new PlaceholderRefused();
+  }
 }
-function placeholderFloor(inner) {
+function placeholderFloor(inner, { known = () => [], fill: fill2 } = {}) {
   const open2 = inner.websocket?.bind(inner);
   return {
     get traits() {
@@ -10453,13 +10481,14 @@ function placeholderFloor(inner) {
     },
     ...open2 ? {
       websocket: async (request3) => {
-        refuseSocket(request3);
+        refuseSocket(request3, known());
         return open2(request3);
       }
     } : {},
-    async fetch(request3, owner) {
-      refuse(request3);
-      return inner.fetch(request3, owner);
+    async fetch(request3, owner, stamp) {
+      if (!detected(request3, known())) return inner.fetch(request3, owner, stamp);
+      if (!fill2 || !stamp) throw new PlaceholderRefused();
+      return fill2(request3, stamp);
     }
   };
 }
@@ -10632,14 +10661,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;
     }
@@ -10830,7 +10859,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();
         }
@@ -10857,7 +10886,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(
@@ -10868,7 +10897,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) {
@@ -10912,8 +10942,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);
@@ -11185,7 +11215,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) {
@@ -11227,39 +11257,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 missing3(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 === "/" || under2(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" && missing3(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 sha2562(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;
@@ -11318,7 +11358,7 @@ var S_IFREG2 = 32768;
 var COMMAND = /^\/(?:usr\/)?bin\/([^/]+)$/;
 var MAX_LINKS6 = 40;
 var BIN_ENTRY = /\/bin\/[^/]+$/;
-function missing3(err) {
+function missing4(err) {
   return err?.code === "ENOENT";
 }
 function synthetic(directory, path) {
@@ -11422,7 +11462,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, missing3)) return void 0;
+    if (!await fs.lstat(path).then(() => false, missing4)) return void 0;
     const target = await targetOf2(path);
     return target?.path === path ? void 0 : target;
   }
@@ -11434,11 +11474,11 @@ function withCommandDirs(fs, names2, userDir = async () => void 0, owners = fals
     return target?.path;
   }
   const absent2 = (err) => {
-    if (missing3(err)) return EMPTY2;
+    if (missing4(err)) return EMPTY2;
     throw err;
   };
   async function content(path, err) {
-    if (!missing3(err) || !(await linked2(path))?.isFile) throw err;
+    if (!missing4(err) || !(await linked2(path))?.isFile) throw err;
     const target = await redirected2(path);
     return target === void 0 ? EMPTY2 : fs.readFileBuffer(target).catch(absent2);
   }
@@ -11447,7 +11487,7 @@ function withCommandDirs(fs, names2, userDir = async () => void 0, owners = fals
     try {
       return await real(path);
     } catch (err) {
-      const found = missing3(err) ? await linked2(path) : void 0;
+      const found = missing4(err) ? await linked2(path) : void 0;
       if (found) return found;
       throw err;
     }
@@ -11472,7 +11512,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 (missing3(err)) return [];
+        if (missing4(err)) return [];
         throw err;
       });
       return [.../* @__PURE__ */ new Set([...real, ...extra])].sort();
@@ -11481,7 +11521,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 (missing3(err)) return [];
+        if (missing4(err)) return [];
         throw err;
       });
       const seen = new Set(real.map(([name2]) => name2));
@@ -11515,7 +11555,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 = missing3(err) ? await redirected2(path) : void 0;
+        const target = missing4(err) ? await redirected2(path) : void 0;
         if (target === void 0) throw err;
         return ranged2.pread(target, offset, length2).catch(absent2);
       })
@@ -11546,7 +11586,7 @@ var S_IFREG3 = 32768;
 var MAX_HOPS2 = 40;
 var parentOf6 = (path) => path.slice(0, path.lastIndexOf("/")) || "/";
 var baseOf2 = (path) => path.slice(path.lastIndexOf("/") + 1);
-function missing4(err) {
+function missing5(err) {
   return err?.code === "ENOENT";
 }
 function statOf(path, bytes) {
@@ -11599,11 +11639,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, missing4);
+  const absent2 = (path) => fs.lstat(path).then(() => false, missing5);
   const follow2 = linkFollower(fs, files);
   const listedAbsent = async (path) => files.has(path) && await absent2(path) ? bytesOf2(path) : void 0;
   const fallback = (path, make) => async (err) => {
-    const at = missing4(err) ? await follow2(path) : void 0;
+    const at = missing5(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);
@@ -13418,8 +13458,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);
   }
@@ -13503,29 +13543,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;
   }
 };
@@ -15443,8 +15483,8 @@ async function guarded(entry, path, req) {
     return { paths };
   } catch (err) {
     const refusal2 = err.code === "EACCES";
-    const refused3 = req.op === "exists" && refusal2 ? json2(false) : toErrno(err);
-    return { refused: refused3 };
+    const refused4 = req.op === "exists" && refusal2 ? json2(false) : toErrno(err);
+    return { refused: refused4 };
   }
 }
 async function copyOp(entry, path, req) {
@@ -15640,13 +15680,13 @@ async function created2(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, {
@@ -15697,14 +15737,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) {
@@ -16416,9 +16456,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);
@@ -17159,11 +17199,11 @@ var EpollFile = class _EpollFile {
       const round = new AbortController();
       const stop = () => round.abort();
       signal.addEventListener("abort", stop, { once: true });
-      let failed3 = false;
+      let failed4 = false;
       try {
         await file.changed(round.signal);
       } catch {
-        failed3 = true;
+        failed4 = true;
       } finally {
         round.abort();
         signal.removeEventListener("abort", stop);
@@ -17171,7 +17211,7 @@ var EpollFile = class _EpollFile {
       if (signal.aborted) return;
       reg.gen++;
       this.changes.wake();
-      if (failed3) await pause(RETRY_MS, signal);
+      if (failed4) await pause(RETRY_MS, signal);
     }
   }
 };
@@ -17807,8 +17847,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;
@@ -18152,11 +18192,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
   ];
@@ -19201,10 +19241,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) {
@@ -19280,7 +19322,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(request3, this.owner) : await this.local.fetch(request3, port);
+      const response = port === void 0 ? await this.transport.fetch(request3, this.owner, await this.stamp?.()) : await this.local.fetch(request3, port);
       entry.body = response.body[Symbol.asyncIterator]();
       entry.cancel = () => response.cancel();
       if (!this.open.has(handle)) await entry.cancel().catch(() => void 0);
@@ -19302,8 +19344,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 failed4 = e.detail === "transport";
+      return { ok: false, errno: errno3, message: text, ...failed4 ? { detail: "transport" } : {} };
     }
     entry.body = once(new TextEncoder().encode(text))[Symbol.asyncIterator]();
     return this.headOf(handle, req.url, {
@@ -21210,7 +21252,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();
@@ -21220,8 +21262,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);
@@ -21323,23 +21365,23 @@ function scrubbed(inner, scrubber, idleMs = SCRUB_IDLE_MS) {
   let pending = 0;
   let busy = false;
   let timer;
-  let failed3;
+  let failed4;
   const waiters = /* @__PURE__ */ new Set();
   const quiet2 = () => !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 (failed4 === void 0) return;
+    const err = failed4;
+    failed4 = void 0;
     throw err;
   };
   const later = (bytes) => {
     if (bytes.length === 0) return;
     pending += 1;
     tail2 = tail2.then(() => writeAll3(file, bytes)).catch((err) => {
-      if (failed3 === void 0) failed3 = err;
+      if (failed4 === void 0) failed4 = err;
     }).finally(() => {
       pending -= 1;
       if (quiet2()) wake();
@@ -24414,7 +24456,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);
@@ -24536,7 +24578,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);
@@ -24555,7 +24597,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");
@@ -24568,7 +24610,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);
@@ -27727,13 +27771,13 @@ function inherited(opts) {
     ...opts.cred ? { cred: opts.cred } : {}
   };
 }
-function heldBy(process, holds2, replacements) {
-  process.keptPath = (path) => holds2.keptAt(path)?.hidden;
-  process.keptHandle = (handle) => holds2.keptFor(handle)?.hidden;
-  process.holdsHandle = (handle) => holds2.holdsHandle(handle);
+function heldBy(process, holds3, replacements) {
+  process.keptPath = (path) => holds3.keptAt(path)?.hidden;
+  process.keptHandle = (handle) => holds3.keptFor(handle)?.hidden;
+  process.holdsHandle = (handle) => holds3.holdsHandle(handle);
   if (replacements) process.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 } : {},
@@ -27750,16 +27794,16 @@ function holdingToken(opts, holds2, caller) {
     ...opts.fileId ? { fileId: opts.fileId } : {},
     ...opts.announceHold ? { announceHold: opts.announceHold } : {},
     ...opts.renameSeq ? { renameSeq: opts.renameSeq } : {},
-    hold: (path, on, open2, real, handle, ino, fid) => holds2.hold(path, on, open2, 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, open2, real, handle, ino, fid) => holds3.hold(path, on, open2, 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) {
@@ -27916,15 +27960,15 @@ function spawnWasmProcess(opts) {
     )
   );
   publishStops(process, header4);
-  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: () => process.cred,
     umask: () => process.umask,
     created: created4,
-    holdsKept: async (path) => path.includes(`/${UNLINKED_DIR}/`) && (holds2.keeps(path) || await process.holds(path))
+    holdsKept: async (path) => path.includes(`/${UNLINKED_DIR}/`) && (holds3.keeps(path) || await process.holds(path))
   });
-  heldBy(process, holds2, opts.replacements);
+  heldBy(process, holds3, opts.replacements);
   const worker = opts.createWorker();
   const dying = new Dying();
   const dispatch2 = (req, block) => dying.serve(
@@ -27956,7 +28000,7 @@ function spawnWasmProcess(opts) {
     responder.dispose();
     lane?.dispose();
     revokeSyncFsToken(token);
-    opts.held?.delete(holds2);
+    opts.held?.delete(holds3);
     worker.terminate();
     settleExit(process.exit(), settle3, code);
   };
@@ -29035,6 +29079,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(request3, owner, stamp) {
+    const nid = ++this.nextId;
+    const { signal, redirect } = request3;
+    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 (request3.bodyStream) this.uploads.set(nid, request3.bodyStream[Symbol.asyncIterator]());
+    let head;
+    try {
+      head = await this.ask({
+        net: "fetch",
+        nid,
+        url: request3.url,
+        method: request3.method,
+        headers: request3.headers,
+        ...request3.bodyStream ? { streamed: true } : request3.body ? { body: request3.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(request3) {
+    const nid = ++this.nextId;
+    const { signal } = request3;
+    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: request3.url,
+        protocols: request3.protocols,
+        headers: request3.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;
@@ -29110,7 +29384,9 @@ function replayingHops(inner, heldMs = HELD_MS) {
       return { ...inner.traits, manualRedirects: true };
     },
     ...inner.websocket ? { websocket: inner.websocket.bind(inner) } : {},
-    async fetch(request3, caller) {
+    async fetch(request3, ...rest2) {
+      if (unfollowed2(request3.redirect)) return inner.fetch(request3, ...rest2);
+      const [caller] = rest2;
       const owner = caller ?? KERNEL;
       const key = keyOf3(owner, request3.method, request3.url);
       const waiting = held.get(key);
@@ -29120,7 +29396,7 @@ function replayingHops(inner, heldMs = HELD_MS) {
         return replay(waiting);
       }
       if (waiting) drop(key);
-      const response = await inner.fetch(request3, caller);
+      const response = await inner.fetch(request3, ...rest2);
       if (!response.redirects?.length) return response;
       return replay({
         owner,
@@ -29133,6 +29409,143 @@ function replayingHops(inner, heldMs = HELD_MS) {
   };
 }
 
+// src/kernel/net/sealed-fetch.ts
+var UNSAFE_FIELD = /[\r\n\0]/;
+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(stream, stall) {
+  for await (const chunk2 of stream) {
+    stall.touch();
+    yield chunk2;
+  }
+}
+function sealedRequest(request3, stamp, stall) {
+  const { method, url, headers, body, bodyStream } = request3;
+  return {
+    v: 1,
+    caller: structuredClone(stamp),
+    method,
+    url,
+    headers: headers.map(([name2, value2]) => [name2, value2]),
+    redirect: "manual",
+    ...bodyStream ? { bodyStream: ticking(bodyStream, 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 (request3, stamp) => {
+    const stall = new Stall([request3.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(request3, 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_"];
@@ -29305,11 +29718,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, failed4) => {
       locks.request(replacingLock(this.metadata, root), { mode: "exclusive" }, () => {
         granted2(() => release());
         return held;
-      }).catch(failed3);
+      }).catch(failed4);
     });
   }
 };
@@ -29559,9 +29972,9 @@ function serveFilesystem(port, handlers, capabilities = {}, options = {}) {
   let open2 = 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 {
@@ -29911,22 +30324,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 failed4 = 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" });
+      failed4 = Object.assign(new Error("the kernel stopped"), { code: "ECANCELED" });
       break;
     } catch (err) {
-      failed3 = err;
+      failed4 = 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(failed4);
+  return { line, target: spec.target, code, error: String(failed4?.message ?? code) };
 }
 
 // src/mount/hostfs.ts
@@ -31100,7 +31513,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) {
@@ -31279,10 +31692,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;
@@ -31299,7 +31712,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
@@ -31308,9 +31721,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);
@@ -31318,13 +31731,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];
@@ -31335,24 +31748,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 {
@@ -31369,7 +31782,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}:
@@ -31378,7 +31791,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 = {
@@ -31408,9 +31821,9 @@ ${lines2}
       const answered2 = Promise.resolve().then(() => approve(req, { signal: control.signal })).catch(() => "deny");
       const answer2 = await Promise.race([answered2, 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);
@@ -31701,13 +32114,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;
 }
@@ -31882,6 +32295,9 @@ var Launcher = class {
   usersMode;
   dac;
   sealed;
+  fill;
+  fills = new AbortController();
+  placeholders = [];
   scrubs = /* @__PURE__ */ new Map();
   clipboard;
   embedder;
@@ -31963,7 +32379,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);
@@ -32118,16 +32534,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)
@@ -32333,14 +32749,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 same3 = 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 same3(own)) continue;
@@ -32350,11 +32766,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);
@@ -32562,12 +32978,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));
   }
@@ -33025,6 +33441,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,
@@ -33032,7 +33461,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) {
@@ -33197,7 +33626,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,
@@ -33512,6 +33941,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);
@@ -33634,7 +34076,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((open3) => open3.holdsAt(at));
+    const holding = [...this.held].some((holds3) => holds3.holding(at)) || [...this.openFiles].some((open3) => open3.holdsAt(at));
     if (!holding) void this.rootFs.announceHolds?.([], [at], false);
     const open2 = [...this.openFiles].some((nodes) => nodes.writes(at)) || heldUnder(this.held, at);
     if (!open2) void this.mounts.commit(at).catch(() => void 0);
@@ -33797,8 +34239,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)
     });
@@ -33855,8 +34298,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 failed4 = this.inUse(path) ? "busy" : await this.base.rm(path, { recursive: true, force: true }).catch(String);
+        if (failed4 === void 0) removed++;
         else left++;
       }
       if (removed > 0) {
@@ -33951,7 +34394,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();
@@ -34162,9 +34605,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(
@@ -34175,7 +34618,7 @@ var Launcher = class {
         (open2) => fids.some((fid) => open2.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 };
@@ -34335,7 +34778,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);
@@ -34547,213 +34990,99 @@ function integrityAsker(port) {
   return { lookup: lookup2, answer: answer2 };
 }
 
-// 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);
+// src/sealed-relay.ts
+function textOf(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function sendBytes(port, bytes) {
+  const copy = fresh(bytes);
+  port.postMessage({ t: "chunk", bytes: copy }, [copy.buffer]);
+}
+function askFetch(port, req, signal) {
+  signal.throwIfAborted();
+  const { bodyStream, ...wire } = req;
+  const { port1: near, port2: far } = new MessageChannel();
+  const upload = bodyStream?.[Symbol.asyncIterator]();
+  const head = Promise.withResolvers();
+  let reading;
+  let ended = false;
+  const end = (failure2) => {
+    if (ended) return;
+    ended = true;
+    signal.removeEventListener("abort", abort);
+    near.close();
     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(request3) {
-    const nid = ++this.nextId;
-    const { signal } = request3;
-    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 (request3.bodyStream) this.uploads.set(nid, request3.bodyStream[Symbol.asyncIterator]());
-    let head;
+    head.reject(failure2);
+    reading?.reject(failure2);
+    reading = void 0;
+  };
+  const abort = () => {
+    near.postMessage({ t: "cancel", reason: String(signal.reason) });
+    end(new Error(String(signal.reason)));
+  };
+  const pull = async () => {
     try {
-      head = await this.ask({
-        net: "fetch",
-        nid,
-        url: request3.url,
-        method: request3.method,
-        headers: request3.headers,
-        ...request3.bodyStream ? { streamed: true } : request3.body ? { body: request3.body } : {}
-      });
-    } catch (e) {
-      finish();
-      throw e;
+      const next3 = await upload.next();
+      if (ended) return;
+      if (next3.done) near.postMessage({ t: "end" });
+      else sendBytes(near, next3.value);
+    } catch (err) {
+      if (!ended) near.postMessage({ t: "error", message: textOf(err) });
     }
-    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 respond2 = (message3) => {
+    const { status, statusText, headers, url } = message3;
+    const body = {
+      [Symbol.asyncIterator]: () => ({
+        next: () => {
+          if (ended) return Promise.resolve({ value: void 0, done: true });
+          reading = Promise.withResolvers();
+          near.postMessage({ t: "read" });
+          return reading.promise;
+        },
+        return: async () => {
+          await cancel();
+          return { value: void 0, done: true };
+        }
+      })
     };
     const cancel = async () => {
-      if (finished) return;
-      finish();
-      this.cancel(nid);
+      if (ended) return;
+      near.postMessage({ t: "cancel", reason: "cancelled" });
+      end(new Error("the request was cancelled"));
     };
-    return {
-      ...redirected2 ? { url, redirected: redirected2 } : {},
-      ...redirects ? { redirects } : {},
+    head.resolve({
+      ...url !== void 0 ? { url } : {},
       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(request3) {
-    const nid = ++this.nextId;
-    const { signal } = request3;
-    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: request3.url,
-        protocols: request3.protocols,
-        headers: request3.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/sealed-relay.ts
+      body,
+      cancel
+    });
+  };
+  near.addEventListener("message", ({ data }) => {
+    if (data.t === "pull") void pull();
+    else if (data.t === "stop") void upload?.return?.().catch(() => void 0);
+    else if (data.t === "head") respond2(data);
+    else if (data.t === "chunk") {
+      reading?.resolve({ value: data.bytes, done: false });
+      reading = void 0;
+    } else if (data.t === "end") {
+      reading?.resolve({ value: void 0, done: true });
+      reading = void 0;
+      end(new Error("the response ended"));
+    } else end(new Error(data.message));
+  });
+  near.addEventListener("close", () => end(new Error("the sealed fetch relay closed")));
+  near.start();
+  signal.addEventListener("abort", abort, { once: true });
+  const ask = {
+    req: { ...wire, ...upload ? { streamed: true } : {} },
+    port: far
+  };
+  port.postMessage({ sealedFetch: ask }, [far]);
+  return head.promise;
+}
 function sealedAsker(port) {
   const asks = /* @__PURE__ */ new Map();
   let next3 = 0;
@@ -34777,7 +35106,7 @@ function sealedAsker(port) {
     if (reply) waiting.resolve(reply);
     else waiting.reject(new Error(error ?? "no reply"));
   };
-  return { hook, answer: answer2 };
+  return { hook, fetch: (req, { signal }) => askFetch(port, req, signal), answer: answer2 };
 }
 
 // src/serve.ts
@@ -34935,13 +35264,15 @@ function transferOf2(req, result) {
   if (result instanceof MessagePort) return [result];
   const bound3 = result?.port;
   if (req.op === "connect" && bound3 instanceof MessagePort) return [bound3];
-  if (req.op === "attest") return [result.bytes.buffer];
+  if (req.op === "attest" && "bytes" in result) {
+    return [result.bytes.buffer];
+  }
   return void 0;
 }
 function attestOps(port) {
   const watches = /* @__PURE__ */ new Map();
   return async (l, req) => {
-    if (req.op === "attest") return l.attest(req.path);
+    if (req.op === "attest") return l.attest(req.path, req.options);
     if (req.op === "chmod") return l.fs.chmod(req.path, modeOption(req.mode)).then(() => true);
     if (req.op === "integrity-revoke") return l.revokeIntegrity(req.path).then(() => true);
     if (req.op === "unwatch-files") {
@@ -34996,7 +35327,7 @@ async function connectClient(deps, { user, tag, bind: bind2 }) {
   });
   return unbind ? { port: port2, client } : port2;
 }
-function hostOptions(req, port, sealed, clipboard, lookup2, requests) {
+function hostOptions(req, port, sealed, sealedFetch, clipboard, lookup2, requests) {
   return {
     cron: { lock: `slicc-kernel-cron:${req.metadata ?? META_DB}` },
     ...req.hostname !== void 0 ? { hostname: req.hostname } : {},
@@ -35005,6 +35336,7 @@ function hostOptions(req, port, sealed, clipboard, lookup2, requests) {
     ...req.denials ? { onDenial: (denial) => port.postMessage({ denial }) } : {},
     ...req.protect ? { protect: hostProtect(req.protect, lookup2) } : {},
     ...req.sealed ? { sealed } : {},
+    ...req.sealedFetch ? { sealedFetch } : {},
     ...req.clipboard ? { clipboard } : {},
     ...req.requests ? { embedder: requests.hookFor(0, req.requests) } : {}
   };
@@ -35095,7 +35427,15 @@ function serveKernel(port, deps) {
         ...req.modules ? { modules: req.modules } : {},
         ...req.commands ? { commands: req.commands } : {},
         ...req.env ? { env: req.env } : {},
-        ...hostOptions(req, port, sealed.hook, clipboard.hook, integrity.lookup, requests),
+        ...hostOptions(
+          req,
+          port,
+          sealed.hook,
+          sealed.fetch,
+          clipboard.hook,
+          integrity.lookup,
+          requests
+        ),
         ...req.approve ? { approve: approvals.ask } : {},
         ...net,
         ...media ? { media } : {},
@@ -35122,6 +35462,7 @@ function serveKernel(port, deps) {
   async function handle(req) {
     if (req.op === "init") return init(req);
     if (isAttestRequest(req)) return attestOp(await ready2(), req);
+    if (req.op === "sealed-placeholders") return (await ready2()).setPlaceholders(req.list);
     if (req.op === "open-terminal") return terminal(req);
     if (req.op === "connect") return connect2(req.user, req.tag, req.requests);
     if (isUsersRequest(req)) return usersOp(await ready2(), req);