@ai-ecoverse/slicc-kernel 1.171.0 → 1.172.2

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);
@@ -2033,11 +2033,11 @@ var OpfsFs = class {
     }
     const found = await this.locate(path, change.follow !== false);
     this.refuse(found.path);
-    const [stored] = found.link ? [found.link] : await this.meta.get([found.path]);
-    const current = await this.ownerAt(found.path, stored);
+    const [stored2] = found.link ? [found.link] : await this.meta.get([found.path]);
+    const current = await this.ownerAt(found.path, stored2);
     const next3 = { uid: change.uid ?? current.uid, gid: change.gid ?? current.gid };
     const handing = found.handle?.kind === "directory" && !sameOwner(next3, current);
-    const heir = change.kind === "adopt" ? void 0 : stored?.heir ?? (handing ? [current.uid, current.gid] : void 0);
+    const heir = change.kind === "adopt" ? void 0 : stored2?.heir ?? (handing ? [current.uid, current.gid] : void 0);
     const ctimeMs = Date.now();
     await this.meta.update(found.path, (entry) => {
       const { heir: _, ...rest2 } = entry ?? found.link ?? { path: found.path };
@@ -2053,8 +2053,8 @@ var OpfsFs = class {
   }
   async movedOwner(source) {
     if (!this.owners) return void 0;
-    const [stored] = source.link ? [source.link] : await this.meta.get([source.path]);
-    return ownOf(stored) ? void 0 : this.ownerAt(source.path, stored);
+    const [stored2] = source.link ? [source.link] : await this.meta.get([source.path]);
+    return ownOf(stored2) ? void 0 : this.ownerAt(source.path, stored2);
   }
   async walk(parts2, from, start2) {
     let dir = start2;
@@ -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);
@@ -3905,6 +3905,38 @@ for (const [names2, op] of [
   }
 }
 
+// src/fs/portable.ts
+var privateTop = () => navigator.storage.getDirectory();
+function clonable(handle) {
+  const { port1, port2 } = new MessageChannel();
+  try {
+    port1.postMessage(handle);
+    return true;
+  } catch (err) {
+    if (err?.name === "DataCloneError") return false;
+    throw err;
+  } finally {
+    port1.close();
+    port2.close();
+  }
+}
+async function portable(handle, top = privateTop) {
+  if (clonable(handle)) return { handle };
+  const path = await (await top()).resolve(handle);
+  if (path === null) {
+    throw new Error(
+      "this browser cannot hand a folder to a worker unless it is in the origin private file system"
+    );
+  }
+  return { path };
+}
+async function directoryAt(top, path) {
+  let dir = top;
+  for (const name2 of path) dir = await dir.getDirectoryHandle(name2);
+  return dir;
+}
+var samePath = (a, b) => a.length === b.length && a.every((name2, at) => name2 === b[at]);
+
 // src/fs/roots.ts
 var ROOTS_DB = "slicc-kernel-roots";
 var ROOTS_STORE = "roots";
@@ -3926,6 +3958,10 @@ async function same(a, b) {
     return false;
   }
 }
+async function matches(record2, root, at) {
+  if (record2.handle) return same(record2.handle, root);
+  return "path" in at && record2.path !== void 0 && samePath(record2.path, at.path);
+}
 var nameOf = (id2) => `${META_DB}:${id2}`;
 function done(tx) {
   return new Promise((resolve2, reject) => {
@@ -3959,18 +3995,19 @@ async function seed(factory, name2) {
     to.close();
   }
 }
-async function rootId(factory, root, locks = globalThis.navigator?.locks) {
+async function rootId(factory, root, locks = globalThis.navigator?.locks, top) {
   const find = async () => {
+    const at = await portable(root, top);
     const db = await open(factory);
     try {
       const all = await request(
         db.transaction(ROOTS_STORE, "readonly").objectStore(ROOTS_STORE).getAll()
       );
-      for (const record2 of all) if (await same(record2.handle, root)) return record2.id;
+      for (const record2 of all) if (await matches(record2, root, at)) return record2.id;
       const id2 = crypto.randomUUID();
       if (await used(root)) await seed(factory, nameOf(id2));
       const tx = db.transaction(ROOTS_STORE, "readwrite");
-      tx.objectStore(ROOTS_STORE).put({ id: id2, handle: root });
+      tx.objectStore(ROOTS_STORE).put({ id: id2, ...at });
       await done(tx);
       return id2;
     } finally {
@@ -6842,9 +6879,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 +6961,7 @@ var LoopbackNet = class {
   internal = /* @__PURE__ */ new Set();
   reserved = /* @__PURE__ */ new Set();
   facades = /* @__PURE__ */ new Map();
+  proxyStamped;
   nextEphemeral = EPHEMERAL_FIRST;
   route;
   origins;
@@ -6998,9 +7036,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);
@@ -7323,7 +7367,21 @@ function headOf(nid, response) {
     headers: response.headers
   };
 }
-function serveTransport(peer, transport, { closeWaitMs = CLOSE_WAIT_MS2 } = {}) {
+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);
@@ -7343,14 +7401,11 @@ 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 } : {},
-        ...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 (!open2.has(call.nid)) {
         await response.cancel();
         return;
@@ -8504,7 +8559,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.2" : "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
@@ -9161,32 +9216,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);
   }
@@ -9552,14 +9607,14 @@ var UnlinkedKeeper = class {
   linked = /* @__PURE__ */ new Map();
   dirOwner;
   peers;
-  constructor(fs, holders, rootOf, options = {}) {
+  constructor(fs, holders, rootOf2, options = {}) {
     this.peers = options.peers;
     this.marks = options.marks ?? new PathMarks();
     const { locks, owner } = options;
     this.dirOwner = options.dirOwner;
     this.fs = fs;
     this.holders = holders;
-    this.rootOf = rootOf;
+    this.rootOf = rootOf2;
     this.locks = locks;
     this.busy = options.busy ?? (() => false);
     this.owner = owner;
@@ -9898,12 +9953,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));
@@ -9924,7 +9979,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) {
@@ -10071,7 +10126,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 = () => {
@@ -10079,7 +10134,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 });
     });
@@ -10183,15 +10238,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;
@@ -10408,14 +10463,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))
@@ -10423,35 +10481,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() {
@@ -10459,13 +10518,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);
     }
   };
 }
@@ -10638,14 +10698,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;
     }
@@ -10836,7 +10896,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();
         }
@@ -10863,7 +10923,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(
@@ -10874,7 +10934,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) {
@@ -11191,7 +11252,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) {
@@ -11233,39 +11294,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;
@@ -11324,7 +11395,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) {
@@ -11428,7 +11499,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;
   }
@@ -11440,11 +11511,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);
   }
@@ -11453,7 +11524,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;
     }
@@ -11478,7 +11549,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();
@@ -11487,7 +11558,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));
@@ -11521,7 +11592,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);
       })
@@ -11552,7 +11623,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) {
@@ -11605,11 +11676,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);
@@ -13509,29 +13580,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;
   }
 };
@@ -15232,7 +15303,7 @@ async function timesOf(entry, path, req) {
   const st = await look.call(entry.fs, path).catch(() => void 0);
   if (!st || (st.uid ?? 0) === g.cred.euid) return given;
   const now = /* @__PURE__ */ new Date();
-  const kept = (ms, stored) => ms === stored.getTime() ? stored : now;
+  const kept = (ms, stored2) => ms === stored2.getTime() ? stored2 : now;
   return [kept(req.atimeMs, st.atime), kept(req.mtimeMs, st.mtime)];
 }
 function guardOf(entry) {
@@ -16422,9 +16493,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);
@@ -17165,11 +17236,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);
@@ -17177,7 +17248,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);
     }
   }
 };
@@ -18158,11 +18229,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
   ];
@@ -18252,19 +18323,19 @@ function indexedDbCaStore(dbName = "slicc-realm-ca") {
     async swap(owner, expected, record2) {
       const tx = (await open2()).transaction("ca", "readwrite");
       const store = tx.objectStore("ca");
-      let stored = record2;
+      let stored2 = record2;
       const read = store.get(owner);
       read.onsuccess = () => {
         const current = read.result;
         const kept = winner(current, expected, record2);
         if (kept === record2) store.put(record2, owner);
-        else stored = kept;
+        else stored2 = kept;
       };
       await new Promise((resolve2, reject) => {
         tx.oncomplete = () => resolve2();
         tx.onerror = () => reject(tx.error);
       });
-      return stored;
+      return stored2;
     }
   };
 }
@@ -18281,10 +18352,10 @@ var RealmCa = class _RealmCa {
     this.record = record2;
   }
   static async open(owner, store, now = Date.now()) {
-    const stored = await store.get(owner).catch(() => void 0);
-    if (stored && stored.notAfter - now > CA_RENEW_BEFORE) return new _RealmCa(stored);
+    const stored2 = await store.get(owner).catch(() => void 0);
+    if (stored2 && stored2.notAfter - now > CA_RENEW_BEFORE) return new _RealmCa(stored2);
     const record2 = await _RealmCa.create(owner, now);
-    return new _RealmCa(await store.swap(owner, stored, record2));
+    return new _RealmCa(await store.swap(owner, stored2, record2));
   }
   static async create(owner, now) {
     const pair = await crypto.subtle.generateKey(ECDSA, false, ["sign", "verify"]);
@@ -19207,10 +19278,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) {
@@ -19286,7 +19359,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);
@@ -19308,8 +19381,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, {
@@ -21216,7 +21289,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();
@@ -21226,8 +21299,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);
@@ -21329,23 +21402,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();
@@ -22727,15 +22800,15 @@ async function scramKeys(password, x) {
     )
   );
   const clientKey = await hmac(salted, encoder9.encode("Client Key"));
-  const stored = new Uint8Array(
+  const stored2 = new Uint8Array(
     await crypto.subtle.digest("SHA-256", clientKey)
   );
   const auth = encoder9.encode(`${x.clientFirstBare},${x.serverFirst},${x.clientFinalBare}`);
-  const signature = await hmac(stored, auth);
+  const signature = await hmac(stored2, auth);
   const proof = clientKey.map((b, i) => b ^ signature[i]);
   const serverKey = await hmac(salted, encoder9.encode("Server Key"));
   const serverSignature = await hmac(serverKey, auth);
-  for (const k of [salted, clientKey, stored, signature, serverKey]) k.fill(0);
+  for (const k of [salted, clientKey, stored2, signature, serverKey]) k.fill(0);
   return { proof, serverSignature };
 }
 var SPACES = /[\u00A0\u1680\u2000-\u200B\u202F\u205F\u3000]/g;
@@ -24420,7 +24493,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);
@@ -24542,7 +24615,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);
@@ -24561,7 +24634,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");
@@ -24574,7 +24647,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);
@@ -27733,13 +27808,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 } : {},
@@ -27756,16 +27831,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) {
@@ -27922,15 +27997,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(
@@ -27962,7 +28037,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);
   };
@@ -29148,7 +29223,7 @@ var RemoteTransport = class {
     waiter?.reject(new TransportError("the request was cancelled"));
     this.port.postMessage({ net: "cancel", nid });
   }
-  async fetch(request3) {
+  async fetch(request3, owner, stamp) {
     const nid = ++this.nextId;
     const { signal, redirect } = request3;
     signal.throwIfAborted();
@@ -29178,7 +29253,9 @@ var RemoteTransport = class {
         method: request3.method,
         headers: request3.headers,
         ...request3.bodyStream ? { streamed: true } : request3.body ? { body: request3.body } : {},
-        ...redirect !== void 0 ? { redirect } : {}
+        ...redirect !== void 0 ? { redirect } : {},
+        ...owner !== void 0 ? { owner } : {},
+        ...stamp ? { stamp } : {}
       });
     } catch (e) {
       finish();
@@ -29369,6 +29446,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_"];
@@ -29541,11 +29755,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);
     });
   }
 };
@@ -30147,22 +30361,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
@@ -30851,18 +31065,28 @@ function settle2(request3, value2) {
     request3.onerror = () => reject(request3.error);
   });
 }
-function openMedia(name2, factory) {
+var privateTop2 = () => navigator.storage.getDirectory();
+async function stored(kept, top) {
+  const path = kept?.path;
+  if (!Array.isArray(path)) return kept;
+  return directoryAt(await top(), path).catch(() => void 0);
+}
+function openMedia(name2, factory, top = privateTop2) {
   const request3 = factory.open(name2, 1);
   request3.onupgradeneeded = () => request3.result.createObjectStore(MEDIA_STORE);
   return settle2(request3, () => {
     const db = request3.result;
     const store = (mode) => db.transaction(MEDIA_STORE, mode).objectStore(MEDIA_STORE);
     return {
-      get: (id2) => {
+      get: async (id2) => {
         const got = store("readonly").get(id2);
-        return settle2(got, () => got.result);
+        return stored(await settle2(got, () => got.result), top);
       },
-      put: (id2, handle) => settle2(store("readwrite").put(handle, id2), () => void 0)
+      put: async (id2, handle) => {
+        const at = await portable(handle, top);
+        const kept = "path" in at ? at : handle;
+        await settle2(store("readwrite").put(kept, id2), () => void 0);
+      }
     };
   });
 }
@@ -31336,7 +31560,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) {
@@ -31515,10 +31739,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;
@@ -31535,7 +31759,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
@@ -31544,9 +31768,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);
@@ -31554,13 +31778,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];
@@ -31571,24 +31795,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 {
@@ -31605,7 +31829,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}:
@@ -31614,7 +31838,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 = {
@@ -31644,9 +31868,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);
@@ -31937,13 +32161,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;
 }
@@ -32118,6 +32342,9 @@ var Launcher = class {
   usersMode;
   dac;
   sealed;
+  fill;
+  fills = new AbortController();
+  placeholders = [];
   scrubs = /* @__PURE__ */ new Map();
   clipboard;
   embedder;
@@ -32199,7 +32426,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);
@@ -33261,6 +33488,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,
@@ -33268,7 +33508,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) {
@@ -33433,7 +33673,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,
@@ -33598,7 +33838,7 @@ var Launcher = class {
   }
   list(viewer = ROOT) {
     const members = new Map(this.jobs.list().map((member) => [member.pid, member]));
-    const rootOf = (member) => {
+    const rootOf2 = (member) => {
       let root = member;
       for (let up = members.get(root.execParent ?? -1); up; up = members.get(up.execParent ?? -1)) {
         root = up;
@@ -33607,7 +33847,7 @@ var Launcher = class {
     };
     const shown = (pid) => {
       const member = pid === void 0 ? void 0 : members.get(pid);
-      const root = member && rootOf(member).pid;
+      const root = member && rootOf2(member).pid;
       return root !== void 0 && this.running(root) ? root : INIT_PID;
     };
     const superseded = new Set([...members.values()].map((m) => m.execParent));
@@ -33617,7 +33857,7 @@ var Launcher = class {
       if (member.execed && superseded.has(member.pid) || !described2) continue;
       const cred = this.credOf(member.pid);
       if (!maySee(viewer, cred)) continue;
-      const root = rootOf(member);
+      const root = rootOf2(member);
       const tags = this.tagsOf(member.pid) ?? this.tagsOf(root.pid);
       listed.push({
         pid: root.pid,
@@ -33748,6 +33988,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);
@@ -33870,7 +34123,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);
@@ -34003,9 +34256,9 @@ var Launcher = class {
     const served2 = serveFilesystem(port2, medium.handlers, FSA_CAPABILITIES);
     const id2 = source.slice("fsa:".length);
     this.removable.set(target, { id: id2, medium, served: served2 });
-    const stored = this.inserted.get(id2) ?? await this.media.get(id2);
-    if (stored && await granted(stored)) medium.insert(stored);
-    else ask(stored);
+    const stored2 = this.inserted.get(id2) ?? await this.media.get(id2);
+    if (stored2 && await granted(stored2)) medium.insert(stored2);
+    else ask(stored2);
     return {
       port: port1,
       present: () => medium.present(),
@@ -34033,8 +34286,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)
     });
@@ -34091,8 +34345,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) {
@@ -34187,7 +34441,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();
@@ -34398,9 +34652,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(
@@ -34411,7 +34665,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 };
@@ -34571,7 +34825,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);
@@ -34784,6 +35038,98 @@ function integrityAsker(port) {
 }
 
 // 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);
+    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 {
+      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 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 (ended) return;
+      near.postMessage({ t: "cancel", reason: "cancelled" });
+      end(new Error("the request was cancelled"));
+    };
+    head.resolve({
+      ...url !== void 0 ? { url } : {},
+      status,
+      statusText,
+      headers,
+      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;
@@ -34807,7 +35153,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
@@ -34825,11 +35171,24 @@ async function inOpfs(deps, root) {
   return await opfs?.resolve(root).catch(() => null) != null;
 }
 async function rootNamed(deps, req, root) {
-  if (req.metadata !== void 0 || !req.root || !deps.rootId) return req;
+  if (req.metadata !== void 0 || !req.root && !req.rootPath || !deps.rootId) return req;
   const top = await deps.storage().catch(() => void 0);
   const name2 = await metadataName(top, root, deps.rootId);
   return name2 === META_DB ? req : { ...req, metadata: name2 };
 }
+async function rootOf(deps, req) {
+  if (req.root) return req.root;
+  const top = await deps.storage();
+  return req.rootPath ? directoryAt(top, req.rootPath) : top;
+}
+async function insertedHandle(deps, req) {
+  return "path" in req ? directoryAt(await deps.storage(), req.path) : req.handle;
+}
+function crossable(medium) {
+  if (!medium.handle || clonable(medium.handle)) return medium;
+  const { handle: _, ...rest2 } = medium;
+  return rest2;
+}
 function workers(deps) {
   return {
     createWorker: deps.createWorker,
@@ -34965,13 +35324,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") {
@@ -35026,7 +35387,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 } : {},
@@ -35035,6 +35396,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) } : {}
   };
@@ -35109,7 +35471,7 @@ function serveKernel(port, deps) {
     }
   }
   async function init(req) {
-    launcher = (req.root ? Promise.resolve(req.root) : deps.storage()).then(async (root) => {
+    launcher = rootOf(deps, req).then(async (root) => {
       req = await rootNamed(deps, req, root);
       const name2 = req.metadata ?? META_DB;
       const { meta, media } = await stores(deps, name2, req.media);
@@ -35125,11 +35487,19 @@ 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 } : {},
-        onMountPending: (medium) => port.postMessage({ medium }),
+        onMountPending: (medium) => port.postMessage({ medium: crossable(medium) }),
         ...req.hostfs ? { hostfs: askGrant } : {},
         ...pageHooks(req, port),
         ...mountPolicy(req.processMounts),
@@ -35145,13 +35515,15 @@ function serveKernel(port, deps) {
     const l = await ready2();
     if (req.op === "mount") return l.mount(req.spec);
     if (req.op === "umount") return l.umount(req.target);
-    if (req.op === "insert") return l.insert(req.target, req.handle, req.source);
+    if (req.op === "insert")
+      return l.insert(req.target, await insertedHandle(deps, req), req.source);
     return l.mounts.listed();
   }
   const attestOp = attestOps(port);
   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);