@ai-ecoverse/slicc-kernel 1.82.0 → 1.84.0

package/dist/node.js

@@ -28,7 +28,7 @@ function serveCdpPort(port, hook, request, onDone) {
     }
   });
   port.start?.();
-  new Promise((resolve) => resolve(hook(request))).then(
+  new Promise((resolve2) => resolve2(hook(request))).then(
     (opened2) => {
       conn = opened2;
       if (done4) return opened2.close();
@@ -51,7 +51,7 @@ function serveCdpPort(port, hook, request, onDone) {
   };
 }
 function portCdpHook(ask, gone) {
-  return (request) => new Promise((resolve, reject) => {
+  return (request) => new Promise((resolve2, reject) => {
     const { port1, port2 } = new MessageChannel();
     let closed = false;
     const conn = {
@@ -69,7 +69,7 @@ function portCdpHook(ask, gone) {
     };
     port1.addEventListener("message", ({ data }) => {
       if ("m" in data) conn.onmessage?.(data.m);
-      else if ("open" in data) resolve(conn);
+      else if ("open" in data) resolve2(conn);
       else if ("error" in data) {
         closed = true;
         port1.close();
@@ -448,8 +448,8 @@ async function inParent(g, op, path, old = false) {
   if (!old) return void await need(g, op, parentOf(path), W_OK | X_OK, DIR, path);
   const dir = await access(g.fs, g.cred, parentOf(path), W_OK | X_OK, DIR);
   if (dir.denied === void 0) return stickyEntry(g, op, path, dir);
-  const lookup2 = dir.denied === dir.path && dir.perm && permits(g.cred, dir.perm, X_OK);
-  if (!lookup2 || await present(g.fs, entryIn(dir, path), false)) deny(g, op, path);
+  const lookup3 = dir.denied === dir.path && dir.perm && permits(g.cred, dir.perm, X_OK);
+  if (!lookup3 || await present(g.fs, entryIn(dir, path), false)) deny(g, op, path);
 }
 async function makeIn(g, op, path) {
   for (let dir = parentOf(path); ; dir = parentOf(dir)) {
@@ -671,9 +671,9 @@ var KernelPipe = class {
     let filled = 0;
     for (const chunk2 of this.chunks) {
       if (filled === out.length) break;
-      const count = Math.min(chunk2.length, out.length - filled);
-      out.set(chunk2.subarray(0, count), filled);
-      filled += count;
+      const count2 = Math.min(chunk2.length, out.length - filled);
+      out.set(chunk2.subarray(0, count2), filled);
+      filled += count2;
     }
     return out;
   }
@@ -704,25 +704,25 @@ var KernelPipe = class {
     let filled = 0;
     while (filled < n) {
       const head = this.chunks[0];
-      const count = Math.min(head.length, n - filled);
-      out.set(head.subarray(0, count), filled);
-      filled += count;
-      if (count === head.length) this.chunks.shift();
-      else this.chunks[0] = head.subarray(count);
+      const count2 = Math.min(head.length, n - filled);
+      out.set(head.subarray(0, count2), filled);
+      filled += count2;
+      if (count2 === head.length) this.chunks.shift();
+      else this.chunks[0] = head.subarray(count2);
     }
     this.size -= n;
     return out;
   }
   changed(signal) {
     if (signal?.aborted) return Promise.reject(new PipeError("EINTR"));
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const onAbort = () => {
         this.waiters = this.waiters.filter((w) => w !== waiter);
         reject(new PipeError("EINTR"));
       };
       const waiter = () => {
         signal?.removeEventListener("abort", onAbort);
-        resolve();
+        resolve2();
       };
       this.waiters.push(waiter);
       signal?.addEventListener("abort", onAbort, { once: true });
@@ -731,7 +731,7 @@ var KernelPipe = class {
   wake() {
     const waiters = this.waiters;
     this.waiters = [];
-    for (const resolve of waiters) resolve();
+    for (const resolve2 of waiters) resolve2();
   }
 };
 
@@ -1192,14 +1192,14 @@ var Changes = class {
   waiters = [];
   wait(signal) {
     if (signal?.aborted) return Promise.reject(new KernelError("EINTR"));
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const onAbort = () => {
         this.waiters = this.waiters.filter((w) => w !== waiter);
         reject(new KernelError("EINTR"));
       };
       const waiter = () => {
         signal?.removeEventListener("abort", onAbort);
-        resolve();
+        resolve2();
       };
       this.waiters.push(waiter);
       signal?.addEventListener("abort", onAbort, { once: true });
@@ -1208,7 +1208,7 @@ var Changes = class {
   wake() {
     const waiters = this.waiters;
     this.waiters = [];
-    for (const resolve of waiters) resolve();
+    for (const resolve2 of waiters) resolve2();
   }
 };
 function link(a, b) {
@@ -1376,7 +1376,7 @@ var KernelSocket = class _KernelSocket {
     });
     const { host, port } = addr;
     const dialled = new Promise(
-      (resolve) => resolve(route.uplink.dial({ network: "tcp", host, port, signal: abort.signal }))
+      (resolve2) => resolve2(route.uplink.dial({ network: "tcp", host, port, signal: abort.signal }))
     );
     dialled.then(
       (conn) => abort.signal.aborted && conn.close(),
@@ -1747,8 +1747,8 @@ var MessageQueue = class {
     this.overflow = overflow;
     this.limit = limit;
     this.taken = taken;
-    this.closed = new Promise((resolve) => {
-      this.settle = resolve;
+    this.closed = new Promise((resolve2) => {
+      this.settle = resolve2;
     });
   }
   push(message3) {
@@ -1787,8 +1787,8 @@ var MessageQueue = class {
         continue;
       }
       if (this.ended) return;
-      await new Promise((resolve) => {
-        this.waiter = resolve;
+      await new Promise((resolve2) => {
+        this.waiter = resolve2;
       });
     }
   }
@@ -1837,7 +1837,7 @@ function openWebSocket(Socket, request, withHeaders) {
   }
   socket.binaryType = "arraybuffer";
   const queue = new MessageQueue(() => socket.close(1e3, "too many waiting messages"));
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     let open = false;
     let settled = false;
     const fail3 = (error) => {
@@ -1856,7 +1856,7 @@ function openWebSocket(Socket, request, withHeaders) {
       open = true;
       settled = true;
       signal.removeEventListener("abort", abort);
-      resolve({
+      resolve2({
         protocol: socket.protocol,
         get buffered() {
           return socket.bufferedAmount;
@@ -2047,8 +2047,8 @@ function serveTransport(peer, transport, { closeWaitMs = CLOSE_WAIT_MS } = {}) {
   const relay = async (nid, socket) => {
     let ending;
     let late;
-    const unanswered = new Promise((resolve) => {
-      late = () => resolve("late");
+    const unanswered = new Promise((resolve2) => {
+      late = () => resolve2("late");
     });
     const flow = {
       inflight: 0,
@@ -2076,8 +2076,8 @@ function serveTransport(peer, transport, { closeWaitMs = CLOSE_WAIT_MS } = {}) {
         }
         flow.inflight += payloadSize(data);
         while (flow.inflight > INBOUND_LIMIT && !flow.closing) {
-          await new Promise((resolve) => {
-            flow.wake = resolve;
+          await new Promise((resolve2) => {
+            flow.wake = resolve2;
           });
         }
       }
@@ -2096,7 +2096,7 @@ function serveTransport(peer, transport, { closeWaitMs = CLOSE_WAIT_MS } = {}) {
     if (!socket) return;
     socket.send(call.data);
     while (socket.buffered > SEND_BUFFER && sockets.has(call.nid)) {
-      await new Promise((resolve) => setTimeout(resolve, 10));
+      await new Promise((resolve2) => setTimeout(resolve2, 10));
     }
     peer.postMessage({ net: "ws-acked", nid: call.nid, n: payloadSize(call.data) });
   };
@@ -3404,11 +3404,11 @@ var RemoteWatch = class {
     const seq2 = ++this.seq;
     this.channel.postMessage({ tab: this.tab, paths: this.mine, seq: seq2 });
     if (this.peers.size === 0) return Promise.resolve();
-    return new Promise((resolve) => {
+    return new Promise((resolve2) => {
       const done4 = () => {
         clearTimeout(timer);
         this.waiting.delete(seq2);
-        resolve();
+        resolve2();
       };
       const timer = setTimeout(() => {
         done4();
@@ -3467,10 +3467,10 @@ function translate(err, path, op = "lookup", mapped = true) {
 var META_OPS = ["get", "update", "move", "remove", "links", "under", "all"];
 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);
   });
-  return Object.fromEntries(META_OPS.map((op) => [op, guarded2(op)]));
+  return Object.fromEntries(META_OPS.map((op) => [op, guarded3(op)]));
 }
 function missing2(err) {
   const code = err?.code;
@@ -3504,7 +3504,7 @@ async function openSync(handle) {
       const delay = SYNC_BACKOFF_MS[attempt];
       if (!LOCKED.has(err?.name)) throw err;
       if (delay === void 0) return void 0;
-      await new Promise((resolve) => setTimeout(resolve, delay));
+      await new Promise((resolve2) => setTimeout(resolve2, delay));
     }
   }
 }
@@ -3957,7 +3957,7 @@ var OpfsFs = class {
         const again = name2 === "NotReadableError" || locks && LOCKED.has(name2);
         if (!again || attempt >= READ_ATTEMPTS)
           throw translate(err, path, locks ? "write" : "read");
-        await new Promise((resolve) => setTimeout(resolve, attempt * 10));
+        await new Promise((resolve2) => setTimeout(resolve2, attempt * 10));
       }
     }
   }
@@ -4014,8 +4014,8 @@ var OpfsFs = class {
   }
   async truncate(path, size) {
     const handle = await this.existing(path, true);
-    const resolve = this.ranged || this.remote?.watched();
-    const target = resolve ? (await this.locate(path, true)).path : path;
+    const resolve2 = this.ranged || this.remote?.watched();
+    const target = resolve2 ? (await this.locate(path, true)).path : path;
     await this.retrying(path, () => positioned(handle, (io) => io.truncate(size)), true);
     this.written(target);
   }
@@ -4455,12 +4455,12 @@ var PathGate = class {
   tails = /* @__PURE__ */ new Map();
   async acquire(path) {
     const prev = this.tails.get(path) ?? Promise.resolve();
-    const { promise, resolve } = Promise.withResolvers();
+    const { promise, resolve: resolve2 } = Promise.withResolvers();
     const tail = prev.then(() => promise);
     this.tails.set(path, tail);
     await prev;
     return () => {
-      resolve();
+      resolve2();
       if (this.tails.get(path) === tail) this.tails.delete(path);
     };
   }
@@ -5224,7 +5224,7 @@ var CdpFacade = class {
     const conn = await this.host(runtime);
     try {
       const reply = await new Promise(
-        (resolve, reject) => {
+        (resolve2, reject) => {
           const timer = setTimeout(
             () => reject(new HttpError(504, "the CDP host did not answer Target.getTargets")),
             this.options.listTimeout ?? LIST_TIMEOUT
@@ -5237,7 +5237,7 @@ var CdpFacade = class {
             const parsed2 = JSON.parse(message3);
             if (parsed2.id !== 1) return;
             clearTimeout(timer);
-            resolve(parsed2);
+            resolve2(parsed2);
           };
           conn.send(JSON.stringify({ id: 1, method: "Target.getTargets" }));
         }
@@ -5297,9 +5297,9 @@ var Relay = class {
   }
   async start(head) {
     await this.send(head);
-    const hostGone = new Promise((resolve) => {
+    const hostGone = new Promise((resolve2) => {
       this.host.onclose = (reason) => {
-        void this.end(reason ? CLOSE.error : CLOSE.normal, reason ?? "").then(() => resolve());
+        void this.end(reason ? CLOSE.error : CLOSE.normal, reason ?? "").then(() => resolve2());
       };
     });
     this.host.onmessage = (message3) => {
@@ -5313,8 +5313,8 @@ var Relay = class {
     await Promise.race([pumping, hostGone]);
     await this.writes;
     let timer;
-    const waited = new Promise((resolve) => {
-      timer = setTimeout(resolve, this.closeWaitMs);
+    const waited = new Promise((resolve2) => {
+      timer = setTimeout(resolve2, this.closeWaitMs);
     });
     await Promise.race([pumping, waited]);
     clearTimeout(timer);
@@ -5907,9 +5907,13 @@ function withCommandDirs(fs, names, userDir = async () => void 0, owners = false
 // src/fs/fresh-modules.ts
 var MAGIC = [0, 97, 115, 109];
 var MAX_FRESH = 65536;
+var DEFAULT_UMASK = 18;
 function isModule(bytes) {
   return MAGIC.every((b, i) => bytes[i] === b);
 }
+function within4(path, dir) {
+  return path.startsWith(dir === "/" ? "/" : `${dir}/`);
+}
 var FreshModules = class {
   fresh = /* @__PURE__ */ new Map();
   add(path, umask, pid) {
@@ -5917,17 +5921,40 @@ var FreshModules = class {
     this.fresh.delete(key);
     const oldest = this.fresh.size >= MAX_FRESH ? this.fresh.keys().next().value : void 0;
     if (oldest !== void 0) this.fresh.delete(oldest);
-    this.fresh.set(key, { umask: umask & 511, pid, added: 0 });
+    const mask = umask & 511;
+    this.fresh.set(key, { umask: mask, pid, added: 0, setup: mask !== DEFAULT_UMASK });
   }
   forget(pid) {
     for (const [path, fresh2] of this.fresh) if (fresh2.pid === pid) this.fresh.delete(path);
   }
+  drop(fresh2) {
+    for (const [key, note] of [...this.fresh]) if (note === fresh2) this.fresh.delete(key);
+  }
+  moved(from, to) {
+    const source = normalizePath(from);
+    const target = normalizePath(to);
+    if (source === target) return;
+    for (const key of [...this.fresh.keys()]) {
+      if (key === target || within4(key, target)) this.fresh.delete(key);
+    }
+    for (const [key, fresh2] of [...this.fresh]) {
+      if (key !== source && !within4(key, source)) continue;
+      this.fresh.delete(key);
+      this.fresh.set(target + key.slice(source.length), fresh2);
+    }
+  }
   wrap(fs) {
-    const decide = async (given, bytes) => {
+    const head = async (path) => {
+      if (fs.pread) return fs.pread(path, 0, MAGIC.length);
+      return (await fs.readFileBuffer(path)).subarray(0, MAGIC.length);
+    };
+    const decide = async (given, known) => {
       const path = normalizePath(given);
       const fresh2 = this.fresh.get(path);
-      if (!fresh2 || typeof bytes === "string" || bytes.length < MAGIC.length) return;
+      if (!fresh2) return;
+      const bytes = known && known.length >= MAGIC.length ? known : await head(path);
       const want = isModule(bytes) ? 73 & ~fresh2.umask : 0;
+      fresh2.setup = false;
       if (want === fresh2.added) return;
       const mode = (await fs.stat(path)).mode & 4095;
       await fs.chmod(path, mode & ~fresh2.added | want);
@@ -5936,44 +5963,59 @@ var FreshModules = class {
     const overrides = {
       writeFile: async (path, content, owner) => {
         await fs.writeFile(path, content, owner);
-        await decide(path, content);
+        if (this.fresh.has(normalizePath(path))) {
+          await decide(
+            path,
+            typeof content === "string" ? new TextEncoder().encode(content) : content
+          );
+        }
       },
       chmod: async (path, mode) => {
         const fresh2 = this.fresh.get(normalizePath(path));
-        const creating = fresh2?.added === 0 && (mode & 4095) === (438 & ~fresh2.umask);
-        if (!creating) this.fresh.delete(normalizePath(path));
+        if (fresh2?.setup && (mode & 4095) === (438 & ~fresh2.umask)) fresh2.setup = false;
+        else if (fresh2) this.drop(fresh2);
         await fs.chmod(path, mode);
       },
       rm: async (path, options) => {
-        this.fresh.delete(normalizePath(path));
         await fs.rm(path, options);
+        const at = normalizePath(path);
+        for (const key of [...this.fresh.keys()]) {
+          if (key === at || within4(key, at)) this.fresh.delete(key);
+        }
       },
       rename: async (from, to) => {
         await fs.rename(from, to);
-        const fresh2 = this.fresh.get(normalizePath(from));
-        this.fresh.delete(normalizePath(from));
-        this.fresh.delete(normalizePath(to));
+        this.moved(from, to);
+      },
+      link: async (from, to, follow2) => {
+        await fs.link(from, to, follow2);
+        const source = follow2 && fs.realpath ? await fs.realpath(from, true) : from;
+        const fresh2 = this.fresh.get(normalizePath(source));
         if (fresh2) this.fresh.set(normalizePath(to), fresh2);
       }
     };
     const ranged2 = rangedOps(fs);
     if (ranged2) {
       overrides.pwrite = async (path, at, bytes, transfer) => {
-        const head = at === 0 && this.fresh.has(normalizePath(path)) ? bytes.slice(0, 4) : void 0;
+        const touches2 = at < MAGIC.length && this.fresh.has(normalizePath(path));
         await ranged2.pwrite(path, at, bytes, transfer);
-        if (head) await decide(path, head);
+        if (touches2) await decide(path);
+      };
+      overrides.truncate = async (path, size) => {
+        await ranged2.truncate(path, size);
+        if (size < MAGIC.length && this.fresh.has(normalizePath(path))) await decide(path);
       };
     }
-    const bound = /* @__PURE__ */ new WeakMap();
+    const bound2 = /* @__PURE__ */ new WeakMap();
     return new Proxy(fs, {
       get(target, key, receiver) {
         if (Object.hasOwn(overrides, key)) return overrides[key];
         const value = Reflect.get(target, key, receiver);
         if (typeof value !== "function") return value;
-        let method = bound.get(value);
+        let method = bound2.get(value);
         if (method === void 0) {
           method = value.bind(target);
-          bound.set(value, method);
+          bound2.set(value, method);
         }
         return method;
       }
@@ -6302,7 +6344,7 @@ var ChildTable = class {
   }
   async nextChange(candidates, flags2, interrupt) {
     let wake;
-    const stateChange = new Promise((resolve) => wake = resolve);
+    const stateChange = new Promise((resolve2) => wake = resolve2);
     const watching = flags2.untraced || flags2.continued;
     if (watching && wake) this.stateChanged.push(wake);
     try {
@@ -6516,6 +6558,65 @@ var ClipboardBroker = class {
   }
 };
 
+// src/kernel/exec-ticket.ts
+var TICKET_ENV = "SLICC_SEALED_TICKET";
+var TICKET_TTL_MS = 3e4;
+var MAX_TICKETS = 256;
+var TICKET = /^[0-9a-f]{32}$/;
+async function argvDigest(argv) {
+  const bytes = new TextEncoder().encode(JSON.stringify(argv));
+  const hash = new Uint8Array(await crypto.subtle.digest("SHA-256", bytes));
+  return [...hash].map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function isStrings(value) {
+  return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+function stringRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return void 0;
+  const entries = Object.entries(value);
+  return entries.every(([, v]) => typeof v === "string") ? Object.fromEntries(entries) : void 0;
+}
+var TicketBook = class {
+  booked = /* @__PURE__ */ new Map();
+  now;
+  normalise = async (path) => path;
+  constructor(now = Date.now) {
+    this.now = now;
+  }
+  get size() {
+    return this.booked.size;
+  }
+  async record(req, reply, pid) {
+    const { ticket, error } = reply;
+    if (error !== void 0 || typeof ticket !== "string" || !TICKET.test(ticket)) return;
+    const { path, argv, cwd } = req;
+    const entry = {
+      pid,
+      path: await this.normalise(path),
+      requested: path,
+      requestedCwd: cwd,
+      argv: await argvDigest(argv),
+      cwd: await this.normalise(cwd),
+      at: this.now()
+    };
+    this.prune();
+    while (this.booked.size >= MAX_TICKETS)
+      this.booked.delete(this.booked.keys().next().value);
+    this.booked.set(ticket, entry);
+  }
+  take(ticket) {
+    const booked = this.booked.get(ticket);
+    this.booked.delete(ticket);
+    return booked && this.now() - booked.at < TICKET_TTL_MS ? booked : void 0;
+  }
+  prune() {
+    const now = this.now();
+    for (const [ticket, booked] of this.booked) {
+      if (now - booked.at >= TICKET_TTL_MS) this.booked.delete(ticket);
+    }
+  }
+};
+
 // src/mount/protocol.ts
 var DRIVER_PROTOCOL = [1, 2];
 function driverVersionError(theirs) {
@@ -6586,7 +6687,7 @@ var DriverConnection = class _DriverConnection {
   call(call, transfer = []) {
     if (this.failure) return Promise.reject(this.failure);
     const id2 = ++this.nextId;
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const timer = unref(
         setTimeout(() => {
           this.waiting.delete(id2);
@@ -6599,7 +6700,7 @@ var DriverConnection = class _DriverConnection {
           this.onFail?.(error);
         }, this.timeoutMs)
       );
-      this.waiting.set(id2, { resolve, reject, timer });
+      this.waiting.set(id2, { resolve: resolve2, reject, timer });
       this.port.postMessage({ ...call, id: id2 }, transfer);
     });
   }
@@ -6642,7 +6743,7 @@ function parseSize(text) {
   if (!match) throw errnoError("EINVAL", `not a size: ${text}`);
   return Math.floor(Number(match[1]) * UNITS[match[2].toLowerCase()]);
 }
-var within4 = (path, target) => path === target || target === "/" || path.startsWith(`${target}/`);
+var within5 = (path, target) => path === target || target === "/" || path.startsWith(`${target}/`);
 var HeldSet = class extends Set {
   idle;
   constructor(idle) {
@@ -6661,7 +6762,7 @@ var HeldSet = class extends Set {
   }
 };
 function heldUnder(held, target) {
-  for (const paths of held) for (const path of paths.keys()) if (within4(path, target)) return true;
+  for (const paths of held) for (const path of paths.keys()) if (within5(path, target)) return true;
   return false;
 }
 var HeldPaths = class extends Map {
@@ -6742,8 +6843,8 @@ var HeldPaths = class extends Map {
       this.keptHandles.delete(handle);
       if (kept) this.letGo(kept);
     }
-    const count = (this.opens.get(key) ?? 0) + (on ? 1 : -1);
-    if (count > 0) this.opens.set(key, count);
+    const count2 = (this.opens.get(key) ?? 0) + (on ? 1 : -1);
+    if (count2 > 0) this.opens.set(key, count2);
     else {
       this.opens.delete(key);
       for (const id2 of this.handlesAt(key)) this.handles.delete(id2);
@@ -6757,8 +6858,8 @@ var HeldPaths = class extends Map {
     return this.lastHandle;
   }
   holdWrite(path, on) {
-    const count = (this.get(path) ?? 0) + (on ? 1 : -1);
-    if (count > 0) this.set(path, count);
+    const count2 = (this.get(path) ?? 0) + (on ? 1 : -1);
+    if (count2 > 0) this.set(path, count2);
     else {
       this.delete(path);
       this.revoked.delete(path);
@@ -6777,24 +6878,24 @@ var HeldPaths = class extends Map {
     return this.owning === path;
   }
   revoke(prefix) {
-    for (const path of this.keys()) if (within4(path, prefix)) this.revoked.add(path);
+    for (const path of this.keys()) if (within5(path, prefix)) this.revoked.add(path);
   }
   renamed(from, to) {
-    for (const [path, count] of [...this]) {
-      if (!within4(path, from)) continue;
+    for (const [path, count2] of [...this]) {
+      if (!within5(path, from)) continue;
       const moved2 = to + path.slice(from.length);
       this.delete(path);
-      this.set(moved2, (this.get(moved2) ?? 0) + count);
+      this.set(moved2, (this.get(moved2) ?? 0) + count2);
       if (this.revoked.delete(path)) this.revoked.add(moved2);
     }
-    for (const [path, count] of [...this.opens]) {
-      if (!within4(path, from)) continue;
+    for (const [path, count2] of [...this.opens]) {
+      if (!within5(path, from)) continue;
       const moved2 = to + path.slice(from.length);
       this.opens.delete(path);
-      this.opens.set(moved2, (this.opens.get(moved2) ?? 0) + count);
+      this.opens.set(moved2, (this.opens.get(moved2) ?? 0) + count2);
     }
     for (const [id2, key] of this.handles) {
-      if (within4(key, from)) this.handles.set(id2, to + key.slice(from.length));
+      if (within5(key, from)) this.handles.set(id2, to + key.slice(from.length));
     }
   }
   isRevoked(path) {
@@ -6901,7 +7002,7 @@ var MountTable = class {
   locate(path) {
     let best;
     for (const mount of this.mounts.values()) {
-      if (within4(path, mount.target) && (!best || mount.target.length > best.target.length))
+      if (within5(path, mount.target) && (!best || mount.target.length > best.target.length))
         best = mount;
     }
     if (!best) return void 0;
@@ -7044,7 +7145,7 @@ var MountTable = class {
   async commitUnder(prefix) {
     const at = normalizePath(prefix);
     await Promise.all(
-      [...this.sessions.keys()].filter((p) => within4(p, at)).map((p) => this.commit(p))
+      [...this.sessions.keys()].filter((p) => within5(p, at)).map((p) => this.commit(p))
     );
   }
   async commitOverlapping(real, offset, length2) {
@@ -7079,10 +7180,10 @@ var MountTable = class {
   }
   forget(mount, path) {
     mount.epoch++;
-    for (const key of [...mount.attrs.keys()]) if (within4(key, path)) mount.attrs.delete(key);
+    for (const key of [...mount.attrs.keys()]) if (within5(key, path)) mount.attrs.delete(key);
     mount.lists.delete(path);
     mount.lists.delete(parentOf7(path));
-    for (const key of [...mount.lists.keys()]) if (within4(key, path)) mount.lists.delete(key);
+    for (const key of [...mount.lists.keys()]) if (within5(key, path)) mount.lists.delete(key);
   }
   async getattr(mount, path, rel2, settled = false) {
     for (let round = 1; ; round++) {
@@ -7717,6 +7818,11 @@ function statJson(s) {
 async function readdirStat(fs, dir) {
   return (await fs.readdirStat(dir)).map(([name2, stat]) => [name2, stat && statJson(stat)]);
 }
+async function usageAt(entry, path) {
+  if (!entry.statfs) return void 0;
+  const real = await realTarget(entry.fs, path).catch(() => path);
+  return entry.statfs(real);
+}
 async function storageUsage() {
   const estimate = await globalThis.navigator?.storage?.estimate?.();
   if (typeof estimate?.quota !== "number") return null;
@@ -7937,8 +8043,8 @@ async function guarded(entry, path, req) {
     await guard(g, path, req, entry.cwd);
     return void 0;
   } catch (err) {
-    const refusal = err.code === "EACCES";
-    return req.op === "exists" && refusal ? json2(false) : toErrno(err);
+    const refusal2 = err.code === "EACCES";
+    return req.op === "exists" && refusal2 ? json2(false) : toErrno(err);
   }
 }
 async function createExclusive(fs, path, owner) {
@@ -8033,7 +8139,7 @@ async function dispatchOne(entry, req) {
     if (req.op === "hold") return await holdOp(entry, path, req);
     const refused2 = await guarded(entry, path, req);
     if (refused2) return refused2;
-    if (req.op === "statfs") return json2(await entry.statfs?.(path) ?? await storageUsage());
+    if (req.op === "statfs") return json2(await usageAt(entry, path) ?? await storageUsage());
     if (entry.revoked?.(path)) return { ok: false, errno: "EIO", message: `${path} was unmounted` };
     if (req.op === "write" && req.mode === 1 || UNLINKED_OPS.has(req.op)) {
       const serve = async () => run(entry, await keptOr(entry, path, req.handle), req);
@@ -9112,7 +9218,7 @@ var AsyncOps = class {
     this.wake();
   }
   sleep(timeoutMs, signal) {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       let timer;
       const cleanup = () => {
         clearTimeout(timer);
@@ -9121,7 +9227,7 @@ var AsyncOps = class {
       };
       const wake = () => {
         cleanup();
-        resolve(true);
+        resolve2(true);
       };
       const abort = () => {
         cleanup();
@@ -9132,7 +9238,7 @@ var AsyncOps = class {
       if (timeoutMs !== void 0) {
         timer = setTimeout(() => {
           cleanup();
-          resolve(false);
+          resolve2(false);
         }, timeoutMs);
       }
     });
@@ -9216,10 +9322,10 @@ var Budget = class {
   async acquire(n, signal) {
     while (this.free < n) {
       signal.throwIfAborted();
-      await new Promise((resolve) => {
+      await new Promise((resolve2) => {
         const done4 = () => {
           signal.removeEventListener("abort", done4);
-          resolve();
+          resolve2();
         };
         this.waiters.push(done4);
         signal.addEventListener("abort", done4, { once: true });
@@ -9361,14 +9467,14 @@ async function watchHangup(conn, abort, until) {
   }
 }
 function untilAborted(response, signal) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const onAbort = () => {
       reject(signal.reason ?? new KernelError("EINTR"));
       response.then((late) => late.cancel()).catch(() => void 0);
     };
     if (signal.aborted) return onAbort();
     signal.addEventListener("abort", onAbort, { once: true });
-    response.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+    response.then(resolve2, reject).finally(() => signal.removeEventListener("abort", onAbort));
   });
 }
 function plainResponse(status, message3) {
@@ -9401,8 +9507,8 @@ function wireCode(code) {
   return sendableCode(code) ? code : 1011;
 }
 function quietly(ms) {
-  return new Promise((resolve) => {
-    AbortSignal.timeout(ms).addEventListener("abort", () => resolve(), { once: true });
+  return new Promise((resolve2) => {
+    AbortSignal.timeout(ms).addEventListener("abort", () => resolve2(), { once: true });
   });
 }
 var RealmProxy = class {
@@ -9500,7 +9606,7 @@ var RealmProxy = class {
       return false;
     }
     const url = ctx.origin ? tunnelRequestUrl(req, ctx.origin) : requestUrl(req);
-    const keep = keepsAlive(req);
+    const keep2 = keepsAlive(req);
     const framing = requestFraming(req.headers);
     const reserve = framing.kind === "length" ? framing.length : framing.kind === "chunked" ? this.cap() : 0;
     if (reserve > this.cap()) throw new HttpError(413, `request body over ${this.cap()} bytes`);
@@ -9523,7 +9629,7 @@ var RealmProxy = class {
       } finally {
         this.bodies.release(reserve);
       }
-      return await this.relay(conn, req.method, req.minor, response, keep);
+      return await this.relay(conn, req.method, req.minor, response, keep2);
     } finally {
       this.stop.signal.removeEventListener("abort", stopExchange);
       abort.abort();
@@ -9571,8 +9677,8 @@ var RealmProxy = class {
       bodiless: bodiless2
     });
     const chunked2 = !bodiless2 && minor >= 1;
-    const keep = keepAlive && (bodiless2 || chunked2);
-    headers.push(["Connection", keep ? "keep-alive" : "close"]);
+    const keep2 = keepAlive && (bodiless2 || chunked2);
+    headers.push(["Connection", keep2 ? "keep-alive" : "close"]);
     if (chunked2) headers.push(["Transfer-Encoding", "chunked"]);
     const signal = this.stop.signal;
     await conn.write(
@@ -9581,7 +9687,7 @@ var RealmProxy = class {
     );
     if (bodiless2) {
       await response.cancel();
-      return keep;
+      return keep2;
     }
     try {
       for await (const piece of response.body) {
@@ -9592,7 +9698,7 @@ var RealmProxy = class {
       return false;
     }
     if (chunked2) await conn.write(LAST_CHUNK, signal);
-    return keep;
+    return keep2;
   }
   async connect(conn, incoming, req, idle) {
     const target = tunnelTarget(req);
@@ -9815,10 +9921,10 @@ function header(der, at) {
   let len = der[at + 1];
   let start2 = at + 2;
   if (len & 128) {
-    const count = len & 127;
+    const count2 = len & 127;
     len = 0;
-    for (let i = 0; i < count; i++) len = len * 256 + der[start2 + i];
-    start2 += count;
+    for (let i = 0; i < count2; i++) len = len * 256 + der[start2 + i];
+    start2 += count2;
   }
   if (start2 + len > der.length) throw new Error("truncated DER");
   return [tag, start2, start2 + len];
@@ -10717,7 +10823,7 @@ function parsePrefix(text) {
   if (length2 < 0 || length2 > max) return void 0;
   return { ...parsed2, length: length2 };
 }
-function within5(prefix, addr) {
+function within6(prefix, addr) {
   if (prefix.v6 !== addr.v6) return false;
   const shift = BigInt((prefix.v6 ? 128 : 32) - prefix.length);
   return addr.bits >> shift === prefix.bits >> shift;
@@ -10757,9 +10863,9 @@ var Routes = class {
     if (!addr) return "unreachable";
     if (addr.v6 && addr.bits === 1n) return "loopback";
     if (!addr.v6 && addr.bits >> 24n === 127n) return "loopback";
-    if (RESERVED.some((p) => within5(p, addr))) return "reserved";
+    if (RESERVED.some((p) => within6(p, addr))) return "reserved";
     if (addr.v6 && !this.ipv6) return "unreachable";
-    if (this.exit || this.table.some((p) => within5(p, addr))) return "uplink";
+    if (this.exit || this.table.some((p) => within6(p, addr))) return "uplink";
     return "unreachable";
   }
 };
@@ -10825,14 +10931,14 @@ var Resolver = class {
     if (hit && hit.expires > this.now()) return hit.addresses;
     const signal = blocking?.();
     if (signal?.aborted) throw new KernelError("EINTR");
-    let lookup2 = this.pending.get(id2);
-    if (!lookup2) {
+    let lookup3 = this.pending.get(id2);
+    if (!lookup3) {
       const abort = new AbortController();
-      lookup2 = { work: this.lookup(key, asked, id2, abort.signal), abort, waiters: 0 };
-      this.pending.set(id2, lookup2);
-      void lookup2.work.then(() => this.pending.delete(id2));
+      lookup3 = { work: this.lookup(key, asked, id2, abort.signal), abort, waiters: 0 };
+      this.pending.set(id2, lookup3);
+      void lookup3.work.then(() => this.pending.delete(id2));
     }
-    return waitFor(lookup2, signal);
+    return waitFor(lookup3, signal);
   }
   async lookup(name2, family, id2, abandoned) {
     const uplink = this.uplink;
@@ -10873,19 +10979,19 @@ var Resolver = class {
     }
   }
 };
-function waitFor(lookup2, signal) {
-  lookup2.waiters++;
-  return new Promise((resolve, reject) => {
+function waitFor(lookup3, signal) {
+  lookup3.waiters++;
+  return new Promise((resolve2, reject) => {
     const abort = () => {
-      if (--lookup2.waiters === 0) lookup2.abort.abort(new KernelError("EINTR"));
+      if (--lookup3.waiters === 0) lookup3.abort.abort(new KernelError("EINTR"));
       reject(new KernelError("EINTR"));
     };
     signal?.addEventListener("abort", abort, { once: true });
-    void lookup2.work.then((value) => {
+    void lookup3.work.then((value) => {
       if (signal?.aborted) return;
-      lookup2.waiters--;
+      lookup3.waiters--;
       signal?.removeEventListener("abort", abort);
-      resolve(value);
+      resolve2(value);
     });
   });
 }
@@ -11066,8 +11172,8 @@ var KernelTty = class {
   }
   rubOut(n) {
     const dropped2 = this.line.splice(this.line.length - n, n);
-    const utf82 = (this.termios.c_iflag & IUTF8) !== 0;
-    const cells = utf82 ? dropped2.filter((b) => !isContinuation(b)).length : dropped2.length;
+    const utf83 = (this.termios.c_iflag & IUTF8) !== 0;
+    const cells = utf83 ? dropped2.filter((b) => !isContinuation(b)).length : dropped2.length;
     if (cells > 0 && this.termios.c_lflag & ECHO) {
       this.output(encoder3.encode("\b \b".repeat(cells)), false);
     }
@@ -11137,14 +11243,14 @@ var KernelTty = class {
   }
   changed(signal) {
     if (signal?.aborted) return Promise.reject(new KernelError("EINTR"));
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const onAbort = () => {
         this.waiters = this.waiters.filter((w) => w !== waiter);
         reject(new KernelError("EINTR"));
       };
       const waiter = () => {
         signal?.removeEventListener("abort", onAbort);
-        resolve();
+        resolve2();
       };
       this.waiters.push(waiter);
       signal?.addEventListener("abort", onAbort, { once: true });
@@ -11153,7 +11259,7 @@ var KernelTty = class {
   wake() {
     const waiters = this.waiters;
     this.waiters = [];
-    for (const resolve of waiters) resolve();
+    for (const resolve2 of waiters) resolve2();
   }
 };
 
@@ -11252,14 +11358,14 @@ var PtyPair = class {
   }
   changed(signal) {
     if (signal?.aborted) return Promise.reject(new KernelError("EINTR"));
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const onAbort = () => {
         this.waiters = this.waiters.filter((w) => w !== waiter);
         reject(new KernelError("EINTR"));
       };
       const waiter = () => {
         signal?.removeEventListener("abort", onAbort);
-        resolve();
+        resolve2();
       };
       this.waiters.push(waiter);
       signal?.addEventListener("abort", onAbort, { once: true });
@@ -11268,7 +11374,7 @@ var PtyPair = class {
   wake() {
     const waiters = this.waiters;
     this.waiters = [];
-    for (const resolve of waiters) resolve();
+    for (const resolve2 of waiters) resolve2();
   }
 };
 var PtyTable = class {
@@ -11333,7 +11439,8 @@ function ptySyscall(req, ctx) {
       if (!ctx.ptys) throw new KernelError("ENOENT");
       const pair = ctx.ptys.get(req.n);
       ttyOpenable(ctx.guard, pair.slave);
-      const fd = ctx.fds.install(pair.openSlave(), 3);
+      const slave = pair.openSlave();
+      const fd = ctx.fds.install(ctx.ttyFilter?.(slave) ?? slave, 3);
       if (!req.noctty) ctx.jobs?.acquireTerminal(ctx.pid, pair.slave);
       return json4(fd);
     }
@@ -11406,8 +11513,8 @@ async function runChild(req, deps) {
   };
   const controls = [];
   const capture = () => {
-    const { promise, resolve } = Promise.withResolvers();
-    const control = { shut: false, ended: resolve, eof: promise };
+    const { promise, resolve: resolve2 } = Promise.withResolvers();
+    const control = { shut: false, ended: resolve2, eof: promise };
     controls.push(control);
     return { capture: true, max, overflow: () => stop("ENOBUFS"), control };
   };
@@ -11500,7 +11607,7 @@ async function waitReady(fds, read, write, deadline, interrupted2) {
       return file.changed === void 0 ? [] : [file.changed(round.signal).catch(() => void 0)];
     });
     let timer;
-    const expiry = deadline === Number.POSITIVE_INFINITY ? [] : [new Promise((resolve) => timer = setTimeout(resolve, deadline - Date.now()))];
+    const expiry = deadline === Number.POSITIVE_INFINITY ? [] : [new Promise((resolve2) => timer = setTimeout(resolve2, deadline - Date.now()))];
     try {
       await Promise.race([...changes, ...expiry, interrupted2]);
     } finally {
@@ -11584,10 +11691,10 @@ async function socketSyscall(req, proc) {
   }
 }
 function interruptible2(dialing, signal) {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const abort = () => reject(new KernelError("EINTR"));
     signal.addEventListener("abort", abort, { once: true });
-    dialing.then(resolve, reject).finally(() => signal.removeEventListener("abort", abort));
+    dialing.then(resolve2, reject).finally(() => signal.removeEventListener("abort", abort));
   });
 }
 function unnamed(domain) {
@@ -11614,7 +11721,7 @@ function isMissing(err) {
   if (err?.code === "ENOENT") return true;
   return err instanceof Error && err.message.startsWith("ENOENT");
 }
-function within6(path, root) {
+function within7(path, root) {
   return path === root || path.startsWith(root.endsWith("/") ? root : `${root}/`);
 }
 var VfsNode = class {
@@ -11935,12 +12042,12 @@ var VfsNodes = class {
     return node;
   }
   holds(prefix) {
-    for (const path of this.byPath.keys()) if (within6(path, prefix)) return true;
+    for (const path of this.byPath.keys()) if (within7(path, prefix)) return true;
     return false;
   }
   writes(prefix) {
     for (const [path, node] of this.byPath)
-      if (node.writers > 0 && within6(path, prefix)) return true;
+      if (node.writers > 0 && within7(path, prefix)) return true;
     return false;
   }
   closed(node, writable2 = false) {
@@ -11984,11 +12091,11 @@ var VfsNodes = class {
     this.kept.delete(node);
   }
   async flush(path) {
-    for (const [p, node] of this.byPath) if (within6(p, path)) await node.serial(() => node.flush());
+    for (const [p, node] of this.byPath) if (within7(p, path)) await node.serial(() => node.flush());
   }
   async unlinking(path) {
     for (const [held, node] of [...this.byPath]) {
-      if (!within6(held, path)) continue;
+      if (!within7(held, path)) continue;
       await node.serial(async () => {
         await Promise.all([this.keepsOnDisk || node.keep(), node.limit()]);
       });
@@ -11996,14 +12103,14 @@ var VfsNodes = class {
   }
   revoke(prefix) {
     for (const [path, node] of [...this.byPath]) {
-      if (!within6(path, prefix)) continue;
+      if (!within7(path, prefix)) continue;
       node.revoke();
       this.forget(node);
     }
   }
   unlinked(path) {
     for (const [held, node] of [...this.byPath]) {
-      if (!within6(held, path) || this.byPath.get(held) !== node) continue;
+      if (!within7(held, path) || this.byPath.get(held) !== node) continue;
       if (!this.dropName(held, node)) this.orphan(node);
     }
   }
@@ -12011,8 +12118,8 @@ var VfsNodes = class {
     if (from === to) return;
     const moved2 = [];
     for (const [p, node] of [...this.byPath]) {
-      if (within6(p, from)) moved2.push([p, node]);
-      else if (within6(p, to) && this.byPath.get(p) === node && !this.dropName(p, node)) {
+      if (within7(p, from)) moved2.push([p, node]);
+      else if (within7(p, to) && this.byPath.get(p) === node && !this.dropName(p, node)) {
         this.orphan(node);
       }
     }
@@ -12291,7 +12398,7 @@ function isWasmSyscall(req) {
 var MAX_READ = 1024 * 1024;
 var WRITE_ACCESS = 3;
 var KEYBOARD = /* @__PURE__ */ new Set([SIG.INT, SIG.QUIT, SIG.TSTP]);
-var DEFAULT_UMASK = 18;
+var DEFAULT_UMASK2 = 18;
 function words(value) {
   if (!Array.isArray(value) || !value.every((w) => typeof w === "string")) {
     throw new KernelError("EINVAL");
@@ -12319,7 +12426,7 @@ var WasmProcess = class {
   interrupt = new AbortController();
   gone = new AbortController();
   dying = false;
-  umask = DEFAULT_UMASK;
+  umask = DEFAULT_UMASK2;
   cred;
   execChild;
   killed = false;
@@ -12341,7 +12448,7 @@ var WasmProcess = class {
     this.fds = fds;
     this.options = options;
     this.inherited = options.ignored ?? 0;
-    this.umask = options.umask ?? DEFAULT_UMASK;
+    this.umask = options.umask ?? DEFAULT_UMASK2;
     this.cred = copyCred(options.cred ?? ROOT);
     this.children = new ChildTable(fds, options.spawner, options.forker);
     this.nodes = options.nodes ?? new VfsNodes(options.fs);
@@ -12434,7 +12541,7 @@ var WasmProcess = class {
     if (this.stopped) return "stop";
     this.stopped = sig;
     this.stops++;
-    this.resumed = new Promise((resolve) => this.wake = resolve);
+    this.resumed = new Promise((resolve2) => this.wake = resolve2);
     const blocked = this.interrupt;
     this.interrupt = new AbortController();
     blocked.abort();
@@ -12499,7 +12606,9 @@ var WasmProcess = class {
         const { ptys, jobs } = this.options;
         const owner = this.options.owners ? this.ttyOwner() : void 0;
         const guard2 = this.guarded();
-        return ptySyscall(req, { pid: this.pid, fds: this.fds, ptys, jobs, guard: guard2, owner });
+        const { ttyFilter } = this.options;
+        const ctx = { pid: this.pid, fds: this.fds, ptys, jobs, guard: guard2, owner, ttyFilter };
+        return ptySyscall(req, ctx);
       }
       return await this.procSyscall(req, cancelled);
     } catch (e) {
@@ -12674,7 +12783,8 @@ var WasmProcess = class {
     const tty = name2 === void 0 ? this.controllingTerminal() : this.options.jobs?.terminalNamed(name2);
     if (!tty) throw new KernelError("ENXIO");
     if (name2 !== void 0) ttyOpenable(this.guarded(), tty);
-    return this.fds.install(tty.file(), 3);
+    const file = tty.file();
+    return this.fds.install(this.options.ttyFilter?.(file) ?? file, 3);
   }
   openSealed() {
     const broker = this.options.sealed;
@@ -12714,15 +12824,8 @@ var WasmProcess = class {
   async sealedCaller() {
     const shown = await this.options.identity?.();
     const broker = this.options.sealed;
-    const tag = broker.tagOf(this.pid);
-    return {
-      pid: shown?.pid ?? this.pid,
-      ppid: shown?.ppid ?? 0,
-      uid: this.cred.euid,
-      gid: this.cred.egid,
-      ...tag !== void 0 ? { tag } : {},
-      users: broker.users
-    };
+    const ids = { pid: shown?.pid ?? this.pid, ppid: shown?.ppid ?? 0 };
+    return broker.stamp(ids, this.cred, broker.tagOf(this.pid));
   }
   guarded() {
     const { guard: guard2 } = this.options;
@@ -13230,13 +13333,13 @@ var WasmProcess = class {
     while (this.dlLock.depth > 0 && this.dlLock.owner !== owner) {
       if (this.dying) throw new KernelError("EINTR");
       const interrupt = this.interrupt.signal;
-      const gone = await new Promise((resolve) => {
+      const gone = await new Promise((resolve2) => {
         const waiter = {
           owner,
           wake: (ended) => {
             this.dlLock.waiters.delete(waiter);
             interrupt.removeEventListener("abort", recheck);
-            resolve(ended);
+            resolve2(ended);
           }
         };
         const recheck = () => waiter.wake(false);
@@ -13492,6 +13595,7 @@ function processOptions(opts, header4, hooks, created3) {
     ...inherited(opts),
     ...opts.owners ? { owners: true } : {},
     ...opts.sealed ? { sealed: opts.sealed } : {},
+    ...opts.ttyFilter ? { ttyFilter: opts.ttyFilter } : {},
     ...opts.clipboard ? { clipboard: opts.clipboard, ...clipboardName(opts) } : {},
     ...opts.readonlyAt ? { readonlyAt: opts.readonlyAt } : {},
     ...opts.dac ? { guard: { dac: opts.dac, fs: opts.fs, created: created3 } } : {},
@@ -13986,6 +14090,523 @@ function replayingHops(inner, heldMs = HELD_MS) {
   };
 }
 
+// node_modules/@ai-ecoverse/slicc-scrub/dist/index.js
+var FRAGMENT = 16;
+var MIN_VALUE = 8;
+var MIN_BASE64 = 8;
+var encoder4 = new TextEncoder();
+var STD = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function utf82(text) {
+  return encoder4.encode(text);
+}
+function base642(bytes, padded = true) {
+  let out = "";
+  for (let i = 0; i < bytes.length; i += 3) {
+    const a = bytes[i];
+    const b = i + 1 < bytes.length ? bytes[i + 1] : 0;
+    const c = i + 2 < bytes.length ? bytes[i + 2] : 0;
+    const triple = a << 16 | b << 8 | c;
+    const left = bytes.length - i;
+    out += STD[triple >> 18 & 63] + STD[triple >> 12 & 63];
+    out += left > 1 ? STD[triple >> 6 & 63] : padded ? "=" : "";
+    out += left > 2 ? STD[triple & 63] : padded ? "=" : "";
+  }
+  return out;
+}
+function urlSafe(text) {
+  return text.replace(/\+/g, "-").replace(/\//g, "_");
+}
+function hex2(bytes) {
+  let out = "";
+  for (const byte of bytes) out += byte.toString(16).padStart(2, "0");
+  return out;
+}
+function embedded(bytes, offset) {
+  const shifted = new Uint8Array(offset + bytes.length);
+  shifted.set(bytes, offset);
+  const encoded = base642(shifted);
+  const first = Math.ceil(8 * offset / 6);
+  const last = Math.floor(8 * (offset + bytes.length) / 6);
+  return encoded.slice(first, last);
+}
+function unicode(value, upper) {
+  let out = "";
+  for (let i = 0; i < value.length; i++) {
+    const unit = value.charCodeAt(i);
+    if (unit === 34) out += '\\"';
+    else if (unit === 92) out += "\\\\";
+    else if (unit < 32 || unit > 126) {
+      const code = unit.toString(16).padStart(4, "0");
+      out += `\\u${upper ? code.toUpperCase() : code}`;
+    } else out += value[i];
+  }
+  return out;
+}
+function percent(value) {
+  let component;
+  try {
+    component = encodeURIComponent(value);
+  } catch {
+    return [];
+  }
+  const lower = component.replace(/%[0-9A-F]{2}/g, (escape) => escape.toLowerCase());
+  const plus = component.replace(/%20/g, "+");
+  let form = "";
+  for (const byte of utf82(value)) {
+    const char = String.fromCharCode(byte);
+    if (/[A-Za-z0-9*\-._]/.test(char)) form += char;
+    else if (byte === 32) form += "+";
+    else form += `%${byte.toString(16).toUpperCase().padStart(2, "0")}`;
+  }
+  return [component, lower, plus, form];
+}
+function html(value, apostrophe) {
+  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, apostrophe);
+}
+function encodings(bytes) {
+  const standard = [base642(bytes), base642(bytes, false)];
+  for (const offset of [0, 1, 2]) {
+    const run2 = embedded(bytes, offset);
+    if (run2.length >= MIN_BASE64) standard.push(run2);
+  }
+  return [...standard, ...standard.map(urlSafe)];
+}
+function shapes(value) {
+  const raw = utf82(value);
+  const seen = /* @__PURE__ */ new Set([value]);
+  const out = [];
+  if (raw.length < FRAGMENT) out.push({ bytes: raw, form: "raw" });
+  for (let offset = 0; raw.length >= FRAGMENT && offset + FRAGMENT <= raw.length; offset++) {
+    out.push({ bytes: raw.subarray(offset, offset + FRAGMENT), form: "fragment", offset });
+  }
+  const add = (text, form) => {
+    if (seen.has(text)) return;
+    seen.add(text);
+    out.push({ bytes: utf82(text), form });
+  };
+  const json5 = JSON.stringify(value).slice(1, -1);
+  for (const text of [
+    json5,
+    json5.replace(/\//g, "\\/"),
+    unicode(value, false),
+    unicode(value, true)
+  ]) {
+    add(text, "json");
+  }
+  for (const text of percent(value)) add(text, "percent");
+  for (const text of [html(value, "&#39;"), html(value, "&#x27;")]) add(text, "html");
+  for (const text of encodings(raw)) add(text, "base64");
+  add(hex2(raw), "hex");
+  add(hex2(raw).toUpperCase(), "hex");
+  return out;
+}
+function wrappable(form) {
+  return form === "base64" || form === "hex";
+}
+var Automaton = class {
+  edges = /* @__PURE__ */ new Map();
+  fail = [0];
+  depth = [0];
+  children = [0];
+  out = [[]];
+  dict = [-1];
+  lengths = [];
+  add(bytes) {
+    let node = 0;
+    for (const byte of bytes) {
+      const key = node * 256 + byte;
+      let next2 = this.edges.get(key);
+      if (next2 === void 0) {
+        next2 = this.depth.length;
+        this.edges.set(key, next2);
+        this.fail.push(0);
+        this.depth.push(this.depth[node] + 1);
+        this.children.push(0);
+        this.children[node] += 1;
+        this.out.push([]);
+        this.dict.push(-1);
+      }
+      node = next2;
+    }
+    const id2 = this.lengths.length;
+    this.lengths.push(bytes.length);
+    this.out[node].push(id2);
+    return id2;
+  }
+  build() {
+    const queue = [];
+    const byNode = /* @__PURE__ */ new Map();
+    for (const [key, child] of this.edges) {
+      const parent = Math.floor(key / 256);
+      const list = byNode.get(parent) ?? [];
+      list.push([key % 256, child]);
+      byNode.set(parent, list);
+    }
+    for (const [, child] of byNode.get(0) ?? []) queue.push(child);
+    for (let head = 0; head < queue.length; head++) {
+      const node = queue[head];
+      const fallback = this.fail[node];
+      this.dict[node] = this.out[fallback].length > 0 ? fallback : this.dict[fallback];
+      for (const [byte, child] of byNode.get(node) ?? []) {
+        let state = fallback;
+        let target = this.edges.get(state * 256 + byte);
+        while (target === void 0 && state > 0) {
+          state = this.fail[state];
+          target = this.edges.get(state * 256 + byte);
+        }
+        this.fail[child] = target ?? 0;
+        queue.push(child);
+      }
+    }
+  }
+  step(state, byte) {
+    let current = state;
+    for (; ; ) {
+      const next2 = this.edges.get(current * 256 + byte);
+      if (next2 !== void 0) return next2;
+      if (current === 0) return 0;
+      current = this.fail[current];
+    }
+  }
+  matches(state, visit) {
+    for (let node = state; node > 0; node = this.dict[node]) {
+      for (const id2 of this.out[node]) visit(id2);
+    }
+  }
+  partials(state, length2, visit) {
+    for (let node = state; node > 0; node = this.fail[node]) {
+      if (this.children[node] > 0) visit(length2 - this.depth[node]);
+    }
+  }
+};
+var RANK = {
+  raw: 0,
+  fragment: 1,
+  json: 2,
+  percent: 3,
+  html: 4,
+  base64: 5,
+  hex: 6,
+  wrapped: 7
+};
+var CR2 = 13;
+var LF2 = 10;
+var EMPTY2 = new Uint8Array(0);
+function register(automaton, sources, ids, bytes, source) {
+  const key = Array.from(bytes).join(",");
+  let id2 = ids.get(key);
+  if (id2 === void 0) {
+    id2 = automaton.add(bytes);
+    ids.set(key, id2);
+    sources[id2] = [];
+  }
+  sources[id2].push(source);
+}
+function prepare(secrets) {
+  const main = new Automaton();
+  const wrap = new Automaton();
+  const sources = [];
+  const wrapSources = [];
+  const ids = /* @__PURE__ */ new Map();
+  const wrapIds = /* @__PURE__ */ new Map();
+  const values = secrets.map((secret) => utf82(secret.value));
+  secrets.forEach((secret, index) => {
+    if (typeof secret.value !== "string" || values[index].length < MIN_VALUE) {
+      throw new RangeError(`the value of ${secret.name} is shorter than ${MIN_VALUE} bytes`);
+    }
+    for (const shape of shapes(secret.value)) {
+      const source = { secret: index, form: shape.form, offset: shape.offset };
+      register(main, sources, ids, shape.bytes, source);
+      if (wrappable(shape.form)) register(wrap, wrapSources, wrapIds, shape.bytes, source);
+    }
+  });
+  main.build();
+  wrap.build();
+  const replacements = secrets.map((secret) => [
+    utf82(secret.placeholder),
+    utf82(`[redacted:${secret.name}]`)
+  ]);
+  return { secrets, values, main, wrap, sources, wrapSources, replacements };
+}
+function better(a, b) {
+  if (!b) return true;
+  if (a.end !== b.end) return a.end > b.end;
+  if (a.rank !== b.rank) return a.rank < b.rank;
+  return a.secret < b.secret;
+}
+function resolve(c, input, start2, end, source) {
+  if (source.form !== "fragment") {
+    return {
+      start: start2,
+      end,
+      secret: source.secret,
+      form: source.form,
+      rank: RANK[source.form],
+      growing: false
+    };
+  }
+  const value = c.values[source.secret];
+  let stop = end;
+  let at = source.offset + FRAGMENT;
+  while (stop < input.length && at < value.length && input[stop] === value[at]) {
+    stop++;
+    at++;
+  }
+  const form = source.offset === 0 && at === value.length ? "raw" : "fragment";
+  const growing = stop === input.length && at < value.length;
+  return { start: start2, end: stop, secret: source.secret, form, rank: RANK[form], growing };
+}
+function keep(best, candidate) {
+  if (better(candidate, best.get(candidate.start))) best.set(candidate.start, candidate);
+}
+function scanMain(c, input, best, partials) {
+  let state = 0;
+  for (let i = 0; i < input.length; i++) {
+    state = c.main.step(state, input[i]);
+    c.main.matches(state, (id2) => {
+      const start2 = i + 1 - c.main.lengths[id2];
+      for (const source of c.sources[id2]) {
+        const candidate = resolve(c, input, start2, i + 1, source);
+        if (candidate.growing) partials.push(candidate.start);
+        keep(best, candidate);
+      }
+    });
+  }
+  c.main.partials(state, input.length, (start2) => partials.push(start2));
+}
+function scanWrapped(c, input, best, partials) {
+  const map = [];
+  for (let i = 0; i < input.length; i++) if (input[i] !== CR2 && input[i] !== LF2) map.push(i);
+  if (map.length === input.length) return;
+  let state = 0;
+  for (let v = 0; v < map.length; v++) {
+    state = c.wrap.step(state, input[map[v]]);
+    c.wrap.matches(state, (id2) => {
+      const first = v + 1 - c.wrap.lengths[id2];
+      const start2 = map[first];
+      const end = map[v] + 1;
+      const wrapped = end - start2 !== c.wrap.lengths[id2];
+      for (const source of c.wrapSources[id2]) {
+        const form = wrapped ? "wrapped" : source.form;
+        keep(best, { start: start2, end, secret: source.secret, form, rank: RANK[form], growing: false });
+      }
+    });
+  }
+  c.wrap.partials(state, map.length, (start2) => partials.push(map[start2]));
+}
+function count(c, hits, candidate) {
+  const name2 = c.secrets[candidate.secret].name;
+  const key = `${name2}\0${candidate.form}`;
+  const hit = hits.get(key) ?? { name: name2, form: candidate.form, count: 0 };
+  hit.count += 1;
+  hits.set(key, hit);
+}
+function concat5(parts2) {
+  let length2 = 0;
+  for (const part of parts2) length2 += part.length;
+  const out = new Uint8Array(length2);
+  let at = 0;
+  for (const part of parts2) {
+    out.set(part, at);
+    at += part.length;
+  }
+  return out;
+}
+function pass(c, input, final) {
+  const best = /* @__PURE__ */ new Map();
+  const partials = [];
+  scanMain(c, input, best, partials);
+  scanWrapped(c, input, best, partials);
+  const holds = 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();
+  let pos = 0;
+  let cut = input.length;
+  let s = 0;
+  let h = 0;
+  for (; ; ) {
+    while (s < starts.length && starts[s] < pos) s++;
+    while (h < holds.length && holds[h] < pos) h++;
+    const hold = h < holds.length ? holds[h] : Infinity;
+    const next2 = s < starts.length ? starts[s] : Infinity;
+    if (hold <= next2) {
+      cut = Math.min(hold, input.length);
+      break;
+    }
+    const candidate = best.get(next2);
+    parts2.push(
+      input.subarray(pos, next2),
+      c.replacements[candidate.secret][candidate.form === "raw" ? 0 : 1]
+    );
+    count(c, hits, candidate);
+    pos = candidate.end;
+  }
+  parts2.push(input.subarray(pos, cut));
+  return { output: concat5(parts2), cut, hits };
+}
+function merge(into, from) {
+  for (const [key, hit] of from) {
+    const known = into.get(key);
+    if (known) known.count += hit.count;
+    else into.set(key, { ...hit });
+  }
+}
+function compile(secrets, options = {}) {
+  const c = prepare(secrets.map((secret) => ({ ...secret })));
+  const decoder4 = new TextDecoder();
+  const idleMs = options.idleMs ?? 250;
+  const scrubBytes = (input) => {
+    if (c.secrets.length === 0) return { bytes: input.slice(), hits: [] };
+    const result = pass(c, input, true);
+    return { bytes: result.output, hits: [...result.hits.values()] };
+  };
+  return {
+    version: options.version ?? 0,
+    idleMs,
+    size: c.main.lengths.length,
+    bytes: scrubBytes,
+    text(input) {
+      const { bytes, hits } = scrubBytes(utf82(input));
+      return { text: decoder4.decode(bytes), hits };
+    },
+    stream() {
+      let pending = EMPTY2;
+      const hits = /* @__PURE__ */ new Map();
+      const run2 = (final) => {
+        if (c.secrets.length === 0 || pending.length === 0) {
+          const out = pending;
+          pending = EMPTY2;
+          return out;
+        }
+        const result = pass(c, pending, final);
+        merge(hits, result.hits);
+        pending = pending.slice(result.cut);
+        return result.output;
+      };
+      return {
+        push(chunk2) {
+          pending = concat5([pending, chunk2]);
+          return run2(false);
+        },
+        idle() {
+          return pending.length < FRAGMENT ? run2(true) : EMPTY2;
+        },
+        end() {
+          return run2(true);
+        },
+        get hits() {
+          return [...hits.values()];
+        }
+      };
+    }
+  };
+}
+
+// src/kernel/scrub-file.ts
+var SCRUB_IDLE_MS = 50;
+var encoder5 = new TextEncoder();
+function scrubberOf(secrets) {
+  const usable = secrets.filter((s) => encoder5.encode(s.value).length >= MIN_VALUE);
+  return usable.length > 0 ? compile(usable, { idleMs: SCRUB_IDLE_MS }) : void 0;
+}
+async function writeAll2(file, bytes, signal) {
+  const write = file.write;
+  for (let at = 0; at < bytes.length; ) {
+    at += await write.call(file, bytes.subarray(at), at === 0 ? signal : void 0);
+  }
+}
+function bound(file, key) {
+  const method = file[key];
+  return typeof method === "function" ? { [key]: method.bind(file) } : {};
+}
+function scrubbed(inner, scrubber, idleMs = SCRUB_IDLE_MS) {
+  const file = inner.file;
+  const stream2 = scrubber.stream();
+  let queue = Promise.resolve();
+  let timer;
+  let failed3;
+  const raise = () => {
+    if (failed3 === void 0) return;
+    const err = failed3;
+    failed3 = void 0;
+    throw err;
+  };
+  const enqueue = (bytes, signal) => {
+    const next2 = queue.then(() => bytes.length > 0 ? writeAll2(file, bytes, signal) : void 0);
+    queue = next2.catch(() => void 0);
+    return next2;
+  };
+  const release = () => {
+    timer = void 0;
+    enqueue(stream2.idle()).catch((err) => {
+      failed3 = err;
+    });
+  };
+  return new OpenFile({
+    ...bound(file, "read"),
+    ...bound(file, "peek"),
+    ...bound(file, "poll"),
+    ...bound(file, "changed"),
+    ...bound(file, "stat"),
+    ...file.tty ? { tty: file.tty } : {},
+    ...file.clipboard ? { clipboard: file.clipboard } : {},
+    ...file.write ? {
+      write: async (bytes, signal) => {
+        if (timer !== void 0) clearTimeout(timer);
+        raise();
+        await enqueue(stream2.push(bytes), signal);
+        timer = setTimeout(release, idleMs);
+        return bytes.length;
+      }
+    } : {},
+    flush: async () => {
+      await queue;
+      raise();
+      await file.flush?.();
+    },
+    close: async () => {
+      if (timer !== void 0) clearTimeout(timer);
+      let failure;
+      try {
+        await enqueue(stream2.end());
+        raise();
+      } catch (err) {
+        failure = { err };
+      }
+      await inner.release();
+      if (failure) throw failure.err;
+    }
+  });
+}
+function scrubbedAll(file, scrubbers) {
+  return scrubbers.reduce((inner, scrubber) => scrubbed(inner, scrubber), file);
+}
+function stdioFiles(fds) {
+  const files = /* @__PURE__ */ new Set();
+  for (const fd of [1, 2]) {
+    try {
+      files.add(fds.get(fd));
+    } catch {
+    }
+  }
+  return files;
+}
+function scrubStdio(fds, scrubber) {
+  const wrapped = /* @__PURE__ */ new Map();
+  const stdio = stdioFiles(fds);
+  for (const fd of fds.numbers()) {
+    const original = fds.get(fd);
+    if (!stdio.has(original) && !original.file.tty) continue;
+    const known = wrapped.get(original);
+    const flags2 = fds.statusFlags(fd);
+    const wrapper = known ? known.retain() : scrubbed(original.retain(), scrubber);
+    wrapped.set(original, wrapper);
+    fds.installAt(fd, wrapper);
+    if (flags2 !== void 0) fds.setStatusFlags(fd, flags2);
+  }
+}
+
 // src/kernel/sealed.ts
 var SEALED_MAX_BYTES = 64 * 1024;
 var SEALED_TIMEOUT_MS = 1e4;
@@ -13999,7 +14620,7 @@ var SEALED_OPS = /* @__PURE__ */ new Set([
   "cancel",
   "materialize"
 ]);
-var encoder4 = new TextEncoder();
+var encoder6 = new TextEncoder();
 var decoder3 = new TextDecoder("utf-8", { fatal: true });
 function parseSealed(bytes) {
   try {
@@ -14015,11 +14636,16 @@ function parseSealed(bytes) {
     const req = parsed2;
     if (req.v !== 1 || typeof req.op !== "string" || !SEALED_OPS.has(req.op))
       throw new KernelError("EINVAL");
+    if (req.op === "materialize" && !materializable(req)) throw new KernelError("EINVAL");
     return req;
   } finally {
     bytes.fill(0);
   }
 }
+function materializable(req) {
+  if (req.shellGrants !== true && !isStrings(req.names)) return false;
+  return isStrings(req.argv) && typeof req.path === "string" && typeof req.cwd === "string";
+}
 function errorReply(code, message3) {
   return { v: 1, error: { code, message: message3 } };
 }
@@ -14063,12 +14689,14 @@ var SealedChannel = class {
     const timer = setTimeout(() => control.abort("timeout"), this.broker.timeoutMs);
     const req = { ...fields, v: 1, op: fields.op, caller };
     const flight = { control, done: Promise.resolve() };
-    flight.done = this.answer(req, control.signal).then((reply) => {
+    flight.done = this.answer(req, control.signal).then(async (reply) => {
       clearTimeout(timer);
       gone.removeEventListener("abort", withdraw);
+      if (reply && req.op === "materialize")
+        await this.broker.tickets.record(req, reply, caller.pid);
       if (this.inflight !== flight) return;
       this.inflight = void 0;
-      if (reply) this.reply = encoder4.encode(serialized(reply));
+      if (reply) this.reply = encoder6.encode(serialized(reply));
     });
     this.inflight = flight;
     return length2;
@@ -14076,8 +14704,8 @@ var SealedChannel = class {
   async answer(req, signal) {
     const hook = this.broker.hook;
     if (!hook) return errorReply("ENOTCONN", "no vault is connected");
-    const stopped = new Promise((resolve) => {
-      signal.addEventListener("abort", () => resolve(void 0), { once: true });
+    const stopped = new Promise((resolve2) => {
+      signal.addEventListener("abort", () => resolve2(void 0), { once: true });
     });
     if (signal.aborted) return void 0;
     const asked = Promise.resolve().then(() => hook(req, { signal })).then(
@@ -14132,17 +14760,60 @@ var SealedChannel = class {
     this.reply = void 0;
   }
 };
+function swapOf(reply) {
+  if (!isRecord(reply) || reply.error !== void 0) return void 0;
+  const values = stringRecord(reply.values);
+  const placeholders = stringRecord(reply.placeholders);
+  return values && placeholders ? { values, placeholders } : void 0;
+}
 var SealedBroker = class {
   hook;
   users;
   timeoutMs;
   tagOf;
+  tickets = new TicketBook();
+  userOf = async () => void 0;
   constructor(hook, users, timeoutMs = SEALED_TIMEOUT_MS, tagOf = () => void 0) {
     this.hook = hook;
     this.users = users;
     this.timeoutMs = timeoutMs;
     this.tagOf = tagOf;
   }
+  async stamp(ids, cred, tag) {
+    const user = await this.userOf(cred.euid).catch(() => void 0);
+    return {
+      pid: ids.pid,
+      ppid: ids.ppid,
+      uid: cred.euid,
+      gid: cred.egid,
+      ...user !== void 0 ? { user } : {},
+      groups: [...cred.groups],
+      users: this.users,
+      ...tag !== void 0 ? { tag } : {}
+    };
+  }
+  async consume(fields) {
+    const { hook } = this;
+    if (!hook) return void 0;
+    const control = new AbortController();
+    const timer = setTimeout(() => control.abort("timeout"), this.timeoutMs);
+    const stopped = new Promise((resolve2) => {
+      control.signal.addEventListener("abort", () => resolve2(void 0), { once: true });
+    });
+    const req = {
+      ...fields,
+      v: 1,
+      op: "materializeConsume",
+      caller: fields.stamp
+    };
+    try {
+      const asked = Promise.resolve().then(() => hook(req, { signal: control.signal })).then(swapOf, () => void 0);
+      return await Promise.race([asked, stopped]);
+    } finally {
+      clearTimeout(timer);
+      control.abort("done");
+    }
+  }
   open() {
     const channel = new SealedChannel(this);
     return new OpenFile({
@@ -14641,11 +15312,11 @@ function codeOf3(err) {
 }
 function wait(ms, signal) {
   if (signal.aborted) return Promise.resolve();
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const done4 = () => {
       clearTimeout(timer);
       signal.removeEventListener("abort", done4);
-      resolve();
+      resolve2();
     };
     const timer = setTimeout(done4, ms);
     signal.addEventListener("abort", done4, { once: true });
@@ -14972,11 +15643,11 @@ async function resize(h, path, size) {
   }
 }
 function sleep(ms, signal) {
-  return new Promise((resolve) => {
+  return new Promise((resolve2) => {
     const done4 = () => {
       clearTimeout(timer);
       signal.removeEventListener("abort", done4);
-      resolve();
+      resolve2();
     };
     const timer = setTimeout(done4, ms);
     signal.addEventListener("abort", done4);
@@ -15059,7 +15730,7 @@ var PORT_DEAD_MS = 1e4;
 var PORT_LINGER_MS = 1e3;
 function timed(transport, ms) {
   const inflight = /* @__PURE__ */ new Set();
-  const guard2 = (name2, run2, late, expire) => new Promise((resolve, reject) => {
+  const guard2 = (name2, run2, late, expire) => new Promise((resolve2, reject) => {
     let expired = false;
     const running = run2();
     inflight.add(running);
@@ -15076,7 +15747,7 @@ function timed(transport, ms) {
       (value) => {
         clearTimeout(timer);
         if (expired) late?.(value);
-        resolve(value);
+        resolve2(value);
       },
       (err) => {
         clearTimeout(timer);
@@ -15211,7 +15882,7 @@ var PortTransport = class {
   ask(message3, bytes = 0, transfer = []) {
     const id2 = ++this.next;
     if (this.dead) return Promise.reject(fsError2("ENOTCONN", this.dead));
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const timer = setTimeout(
         () => {
           this.waiting.delete(id2);
@@ -15225,7 +15896,7 @@ var PortTransport = class {
         clearTimeout(timer);
         this.waiting.delete(id2);
         if (reply.error) reject(fsError2(reply.error.code ?? "EIO", reply.error.message ?? ""));
-        else resolve(reply);
+        else resolve2(reply);
       });
       try {
         this.port.postMessage({ id: id2, ...message3 }, transfer);
@@ -15254,7 +15925,7 @@ var PortTransport = class {
       this.fail("the folder's watch ended");
       return Promise.resolve();
     }
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve2, reject) => {
       const finish = () => {
         this.waiting.delete(id2);
         signal.removeEventListener("abort", stop);
@@ -15265,7 +15936,7 @@ var PortTransport = class {
           this.port.postMessage({ id: id2, op: "unwatch" });
         } catch {
         }
-        resolve();
+        resolve2();
       };
       this.watchBeat();
       this.waiting.set(id2, (reply) => {
@@ -15273,7 +15944,7 @@ var PortTransport = class {
         if (reply.event) return onEvent(reply.event);
         finish();
         if (reply.error) reject(fsError2(reply.error.code ?? "ENOTCONN", reply.error.message ?? ""));
-        else resolve();
+        else resolve2();
       });
       signal.addEventListener("abort", stop, { once: true });
       try {
@@ -15489,10 +16160,10 @@ var ChunkedBytes = class {
   }
   truncate(size) {
     if (size < this.size) {
-      const keep = Math.ceil(size / CHUNK3);
-      this.chunks.length = Math.min(this.chunks.length, keep);
-      const tail = this.chunks[keep - 1];
-      const from = size - (keep - 1) * CHUNK3;
+      const keep2 = Math.ceil(size / CHUNK3);
+      this.chunks.length = Math.min(this.chunks.length, keep2);
+      const tail = this.chunks[keep2 - 1];
+      const from = size - (keep2 - 1) * CHUNK3;
       if (tail && from < tail.length) tail.fill(0, from);
     }
     this.size = size;
@@ -15737,8 +16408,8 @@ function importedMemory(bytes) {
       at = end;
       continue;
     }
-    const count = u32();
-    for (let i = 0; i < count; i++) {
+    const count2 = u32();
+    for (let i = 0; i < count2; i++) {
       const module = name2();
       const field3 = name2();
       const kind = bytes[at++];
@@ -16167,7 +16838,7 @@ ${lines2}
     const withdraw = () => control.abort("withdrawn");
     requester.addEventListener("abort", withdraw, { once: true });
     const aborted2 = new Promise(
-      (resolve) => control.signal.addEventListener("abort", () => resolve("aborted"), { once: true })
+      (resolve2) => control.signal.addEventListener("abort", () => resolve2("aborted"), { once: true })
     );
     try {
       const answered = Promise.resolve().then(() => approve(req, { signal: control.signal })).catch(() => "deny");
@@ -16293,7 +16964,7 @@ var LAYOUT = [
 ];
 var LOAD_SAMPLE_MS = 5e3;
 var LOAD_WINDOWS_MS = [6e4, 3e5, 9e5];
-var encoder5 = new TextEncoder();
+var encoder7 = new TextEncoder();
 var USERS_MODES = ["off", "report", "enforce"];
 function usersMode(mode = "off") {
   if (USERS_MODES.includes(mode)) return mode;
@@ -16324,6 +16995,30 @@ function shebang(head) {
   if (head[0] !== 35 || head[1] !== 33) return void 0;
   return new TextDecoder().decode(head.subarray(0, SHEBANG_MAX)).slice(2).split("\n")[0].trim().split(/[ \t]+/);
 }
+async function rootOnly(fs, path) {
+  const names = chain(path);
+  for (const [i, at] of names.entries()) {
+    const st = await fs.lstat(at).catch(() => void 0);
+    const kind = i === names.length - 1 ? st?.isFile : st?.isDirectory;
+    if (!kind || st?.uid !== 0 || (st.mode & 18) !== 0) return false;
+  }
+  return true;
+}
+function plainEnv(words2) {
+  const next2 = words2[1];
+  if (baseName(words2[0] ?? "") !== "env" || next2 === void 0) return false;
+  return next2 === "-S" || !next2.startsWith("-") && !next2.includes("=");
+}
+function shebangCommand(words2) {
+  if (!plainEnv(words2)) {
+    const arg2 = words2.slice(1).join(" ");
+    return { interp: words2[0], args: arg2 ? [arg2] : [] };
+  }
+  const split2 = words2[1] === "-S";
+  const [interp, ...rest2] = words2.slice(split2 ? 2 : 1);
+  const arg = rest2.join(" ");
+  return { interp, args: split2 ? rest2 : arg ? [arg] : [] };
+}
 function interpreter(head) {
   const words2 = shebang(head);
   if (!words2) return "node";
@@ -16377,7 +17072,7 @@ function childHandle(handle) {
     onState: (listener) => handle.onState(listener)
   };
 }
-function concat5(chunks2) {
+function concat6(chunks2) {
   const out = new Uint8Array(chunks2.reduce((n, chunk2) => n + chunk2.length, 0));
   let offset = 0;
   for (const chunk2 of chunks2) {
@@ -16463,6 +17158,7 @@ var Launcher = class {
   usersMode;
   dac;
   sealed;
+  scrubs = /* @__PURE__ */ new Map();
   clipboard;
   rootFs;
   fileWatches;
@@ -16486,6 +17182,8 @@ var Launcher = class {
       void 0,
       (pid) => this.tagOf(pid)
     );
+    this.sealed.tickets.normalise = (path) => physicalPathAsync(this.base, path);
+    this.sealed.userOf = async (uid) => (await this.users.lookup(uid))?.name;
     if (this.owners) options.fs.trackOwners?.();
     this.mounts = new MountTable({
       open: (type, spec) => this.driver(type, spec),
@@ -16734,13 +17432,12 @@ var Launcher = class {
     const binfmt = isWasm(head) ? void 0 : binfmtOf(await this.interpreters(scope), script);
     const words2 = shebang(head) ?? (binfmt ? [binfmt] : void 0);
     if (!words2) return void 0;
-    if (baseName(words2[0]) === "env") words2.shift();
-    const [interp, ...rest2] = words2;
-    const arg = rest2.join(" ");
-    const passed = [...arg ? [arg] : [], command ? script : file, ...argv.slice(1)];
-    const found = interp ? await this.resolve(interp, interp, cwd, scope) : void 0;
+    const { interp, args } = shebangCommand(words2);
+    const passed = [...args, command ? script : file, ...argv.slice(1)];
+    if (!interp) return void 0;
+    const found = await this.resolve(interp, interp, cwd, scope);
     if (!found) {
-      if (!interp || depth >= MAX_INTERPRETERS || !await this.scriptCommand(interp, cwd, scope)) {
+      if (depth >= MAX_INTERPRETERS || !await this.scriptCommand(interp, cwd, scope)) {
         return void 0;
       }
       const inner = await this.interpreted(interp, [interp, ...passed], cwd, scope, depth + 1);
@@ -16780,6 +17477,99 @@ var Launcher = class {
       await need(g, "exec", this.fs.resolvePath(req.cwd, file), want);
     }
   }
+  async checkedPlan(req, { ppid, cred, scope }, fds) {
+    const planned = await this.plan(req.file, req.argv, req.cwd, scope, req.argv0);
+    try {
+      await this.mayExec(cred, { ...req, pid: ppid }, planned);
+    } catch (err) {
+      await fds.closeAll();
+      throw err.code === "EACCES" ? new SpawnError("EACCES") : err;
+    }
+    if (planned) return planned;
+    await fds.closeAll();
+    throw new SpawnError(await this.unrunnable(req.file, req.cwd, scope));
+  }
+  async ticketFile(req, fds) {
+    if (req.file.startsWith("/")) return physicalPathAsync(this.base, req.file);
+    await fds.closeAll();
+    throw new SpawnError("EACCES");
+  }
+  takeTicket(req) {
+    if (!(TICKET_ENV in req.env)) return void 0;
+    return this.sealed.tickets.take(req.env[TICKET_ENV] ?? "") ?? null;
+  }
+  async redeemed(req, who, planned, fds) {
+    if (who.booked === void 0) return { env: req.env };
+    try {
+      const redeemed = await this.redeem(req, who, planned);
+      if (redeemed.scrub) scrubStdio(fds, redeemed.scrub);
+      return redeemed;
+    } catch {
+      await fds.closeAll();
+      throw new SpawnError("EACCES");
+    }
+  }
+  async redeem(req, { ppid, cred, scope, booked }, planned) {
+    const { [TICKET_ENV]: ticket = "", ...env } = req.env;
+    const caller = this.jobs.shown(ppid);
+    const named = typeof req.argv0 === "string" && !planned.script && !planned.target.fixed;
+    const argv = named ? [req.argv0, ...req.argv.slice(1)] : req.argv;
+    const exact = booked?.pid === caller && req.file === booked.path && await physicalPathAsync(this.base, req.cwd) === booked.cwd && await argvDigest(argv) === booked.argv;
+    if (!exact) throw new SpawnError("EACCES");
+    const { requested: path, requestedCwd: cwd, path: resolved2 } = booked;
+    const pid = this.nextPid++;
+    const ids = { pid: req.exec ? caller : pid, ppid: caller };
+    const stamp = await this.sealed.stamp(ids, cred, this.tagOf(ppid));
+    const interpreters = await this.interpreterChain(planned, booked.cwd, scope);
+    const trusted = this.usersMode === "enforce" && await this.trustedFiles(planned, req.file, booked.cwd, scope);
+    const swap = await this.sealed.consume({
+      ticket,
+      stamp,
+      path,
+      resolved: resolved2,
+      argv,
+      cwd,
+      interpreters,
+      trusted
+    });
+    if (!swap) throw new SpawnError("EACCES");
+    const secrets = [];
+    for (const [name2, placeholder] of Object.entries(swap.placeholders)) {
+      const value = swap.values[name2];
+      if (value === void 0 || env[name2] !== placeholder) continue;
+      env[name2] = value;
+      secrets.push({ name: name2, value, placeholder });
+    }
+    const scrub = scrubberOf(secrets);
+    return { env, pid, cwd: booked.cwd, ...scrub ? { scrub } : {} };
+  }
+  async interpreterChain(planned, cwd, scope) {
+    const out = [];
+    for (const entry of planned.via ?? []) {
+      if (entry.includes("/")) {
+        out.push(await physicalPathAsync(this.base, this.fs.resolvePath(cwd, entry)));
+        continue;
+      }
+      const script = (await this.scriptCommand(entry, cwd, scope))?.script;
+      out.push(
+        await physicalPathAsync(this.base, script ?? await this.commandFile(entry, cwd, scope))
+      );
+    }
+    return out;
+  }
+  async commandFile(name2, cwd, scope) {
+    const scoped = await this.resolve(name2, name2, cwd, scope);
+    const system = scope === "" ? scoped : await this.resolve(name2, name2, cwd, "");
+    if (!scoped || system?.glue === scoped.glue) return `/usr/bin/${name2}`;
+    return scoped.glue;
+  }
+  async trustedFiles(planned, file, cwd, scope) {
+    const files = await this.backingOf(planned, file, cwd, scope);
+    for (const at of files) {
+      if (!await rootOnly(this.base, await physicalPathAsync(this.base, at))) return false;
+    }
+    return true;
+  }
   async grantedCwd(caller, cwd) {
     const real = await physicalPathAsync(this.base, cwd).catch(() => void 0);
     return real === cwd && await this.sudoer.reachable(caller, cwd);
@@ -16798,13 +17588,15 @@ var Launcher = class {
   }
   async backing(file, cwd) {
     const planned = await this.plan(file, [file], cwd, "");
-    if (!planned) return void 0;
+    return planned && this.backingOf(planned, file, cwd, "");
+  }
+  async backingOf(planned, file, cwd, scope) {
     const { glue, wasm, imports } = planned.target;
     const files = [glue, wasm, ...imports ? [imports] : []];
     const scripts = [];
     for (const name2 of [file, ...planned.via ?? []]) {
       if (name2.includes("/") && !COMMAND2.test(name2)) scripts.push(this.fs.resolvePath(cwd, name2));
-      const script = (await this.scriptCommand(name2, cwd, ""))?.script;
+      const script = (await this.scriptCommand(name2, cwd, scope))?.script;
       if (script) scripts.push(script);
     }
     files.push(...scripts, ...await this.binfmtManifests(scripts));
@@ -16933,6 +17725,7 @@ var Launcher = class {
     const seen = { ...req.env, HOSTNAME: this.hostname, cwd };
     const env = { ...expandDefaults(target.env, seen), ...req.env };
     for (const key of target.unset ?? []) delete env[key];
+    delete env[TICKET_ENV];
     env.HOSTNAME = this.hostname;
     let program;
     try {
@@ -16948,16 +17741,23 @@ var Launcher = class {
   groupSession(pgid) {
     return this.jobs.sessionOf(pgid);
   }
+  treeScrubs(pid, req) {
+    const inherited2 = req.ppid !== void 0 ? this.scrubs.get(req.ppid) : void 0;
+    const scrubs = req.scrub ? [...inherited2 ?? [], req.scrub] : inherited2;
+    if (scrubs) this.scrubs.set(pid, scrubs);
+    return scrubs;
+  }
   start(req) {
     this.sampling();
     if (req.pgid !== void 0 && this.jobs.sessionOf(req.pgid) === void 0) {
       throw new SpawnError("ESRCH");
     }
-    const pid = this.nextPid++;
+    const pid = req.pid ?? this.nextPid++;
+    const scrubs = this.treeScrubs(pid, req);
     const stack = this.stackFor(req.tag);
     const terminal = req.fds.stdioTerminal();
     const decided = req.decided ?? Promise.resolve(true);
-    const count = (byParent) => {
+    const count2 = (byParent) => {
       this.identities.asked++;
       if (!byParent) this.identities.timedOut++;
     };
@@ -16965,7 +17765,7 @@ var Launcher = class {
     const handle = spawnWasmProcess({
       pid,
       identity: async () => {
-        await (asked ??= decided.then(count));
+        await (asked ??= decided.then(count2));
         return this.identityOf(pid);
       },
       onSyscall: (call) => {
@@ -16979,6 +17779,7 @@ var Launcher = class {
       ...this.owners && req.program.abi === "wasi" ? { fresh: (path, umask) => this.freshModules.add(path, umask, pid) } : {},
       ...this.owners ? { owners: true } : {},
       sealed: this.sealed,
+      ...scrubs ? { ttyFilter: (file) => scrubbedAll(file, scrubs) } : {},
       clipboard: this.clipboard,
       ...this.dac ? { dac: this.dac } : {},
       program: req.program,
@@ -17045,6 +17846,7 @@ var Launcher = class {
       if (spent) addTimes(this.imageTimes, this.jobs.shown(pid), spent);
       this.stopped.delete(pid);
       this.processes.delete(pid);
+      this.scrubs.delete(pid);
       if (this.processes.size === 0) {
         clearInterval(this.sampler);
         this.sampler = void 0;
@@ -17216,6 +18018,7 @@ var Launcher = class {
   }
   spawner(ppid, report) {
     return async (req, fds, grant) => {
+      const booked = this.takeTicket(req);
       if (grant && !await this.grantedCwd(grant.caller, req.cwd)) {
         await fds.closeAll();
         throw new SpawnError("EACCES");
@@ -17227,23 +18030,20 @@ var Launcher = class {
       }
       const cred = grant ? grant.cred : this.credOf(ppid);
       const scope = grant ? "" : await this.scopeOf(cred.euid);
-      const planned = await this.plan(req.file, req.argv, req.cwd, scope, req.argv0);
-      try {
-        await this.mayExec(cred, { ...req, pid: ppid }, planned);
-      } catch (err) {
-        await fds.closeAll();
-        throw err.code === "EACCES" ? new SpawnError("EACCES") : err;
-      }
-      if (!planned) {
-        await fds.closeAll();
-        throw new SpawnError(await this.unrunnable(req.file, req.cwd, scope));
-      }
+      const file = booked === void 0 ? req.file : await this.ticketFile(req, fds);
+      const planned = await this.checkedPlan({ ...req, file }, { ppid, cred, scope }, fds);
+      const redeemed = await this.redeemed(
+        { ...req, file },
+        { ppid, cred, scope, booked },
+        planned,
+        fds
+      );
       const exec = req.exec ? { exec: true } : {};
       const deciding = req.exec ? void 0 : this.undecided(ppid);
       const handle = await this.launch(planned, {
         ...deciding ? { decided: deciding.promise } : {},
-        env: req.env,
         cwd: req.cwd,
+        ...redeemed,
         fds,
         report,
         ppid,
@@ -17296,11 +18096,11 @@ var Launcher = class {
     if (!waiting) return;
     this.deciding.delete(ppid);
     setTimeout(() => {
-      for (const resolve of waiting) resolve(true);
+      for (const resolve2 of waiting) resolve2(true);
     }, 0);
   }
   forker(ppid, parent) {
-    const { exec: _exec, pgid: _pgid, group: _group, ...image } = parent;
+    const { exec: _exec, pgid: _pgid, group: _group, pid: _pid, scrub: _scrub, ...image } = parent;
     return async (state, fds) => childHandle(
       this.start({
         ...image,
@@ -17334,7 +18134,7 @@ var Launcher = class {
     }
   }
   umaskOf(pid) {
-    return this.processes.get(pid)?.umask?.() ?? DEFAULT_UMASK;
+    return this.processes.get(pid)?.umask?.() ?? DEFAULT_UMASK2;
   }
   imageOf(pid) {
     const members = this.jobs.list();
@@ -17677,7 +18477,14 @@ var Launcher = class {
     );
   }
   environment(cwd, extra, account) {
-    return { ...this.env, ...userEnv(account, this.pnpmHome), PWD: cwd, ...extra };
+    const env = {
+      ...this.env,
+      ...userEnv(account, this.pnpmHome),
+      PWD: cwd,
+      ...extra
+    };
+    delete env[TICKET_ENV];
+    return env;
   }
   async account(user) {
     if (typeof user === "object") return user;
@@ -17773,7 +18580,7 @@ var Launcher = class {
       },
       account
     );
-    const report = (message3) => options.onData(encoder5.encode(`${message3}\r
+    const report = (message3) => options.onData(encoder7.encode(`${message3}\r
 `));
     const handle = await this.launch(planned, {
       env,
@@ -17804,18 +18611,18 @@ var Launcher = class {
     const env = this.environment(cwd, options.env, account);
     const out = [];
     const err = [];
-    const keep = options.collect !== false;
+    const keep2 = options.collect !== false;
     const collect = (chunks2, tee) => (bytes) => {
-      if (keep) chunks2.push(bytes);
+      if (keep2) chunks2.push(bytes);
       tee?.(bytes);
     };
     const stdout = collect(out, options.onStdout);
     const stderr = collect(err, options.onStderr);
-    const report = (message3) => stderr(encoder5.encode(`${message3}
+    const report = (message3) => stderr(encoder7.encode(`${message3}
 `));
     if (!planned) {
       report(`${file}: command not found`);
-      return { status: NOT_FOUND, stdout: concat5(out), stderr: concat5(err) };
+      return { status: NOT_FOUND, stdout: concat6(out), stderr: concat6(err) };
     }
     const fds = new FdTable();
     fds.installAt(0, options.stdin ? bytesSource(options.stdin) : deviceFile("null"));
@@ -17833,10 +18640,115 @@ var Launcher = class {
     options.onStarted?.(handle.pid);
     const status = await handle.exited;
     const signal = handle.termsig();
-    return { status, ...signal ? { signal } : {}, stdout: concat5(out), stderr: concat5(err) };
+    return { status, ...signal ? { signal } : {}, stdout: concat6(out), stderr: concat6(err) };
   }
 };
 
+// src/node/loopback.ts
+import { lookup } from "node:dns/promises";
+import { isIP } from "node:net";
+var DEVTOOLS_PORTS = [9222, 9223, 9224, 9225, 9226, 9227, 9228, 9229];
+var METADATA_V6 = [64768, 3778, 0, 0, 0, 0, 0, 596].join(":");
+var resolveHost = async (host) => (await lookup(host, { all: true, verbatim: true })).map((a) => a.address);
+function ipv4Place(address) {
+  const [a, b] = address.split(".").map(Number);
+  if (a === 127 || a === 0) return "loopback";
+  if (a === 169 && b === 254) return "link-local";
+  return void 0;
+}
+function placeOf(address) {
+  const plain = address.replace(/^\[(.*)\]$/, "$1").toLowerCase();
+  const kind = isIP(plain);
+  if (kind === 4) return ipv4Place(plain);
+  if (kind !== 6) return void 0;
+  const words2 = hextets2(plain);
+  const embedded2 = words2.slice(0, 5).every((w) => w === 0) && (words2[5] === 65535 || words2[5] === 0);
+  if (embedded2 && (words2[5] === 65535 || words2[6] !== 0)) return ipv4Place(ipv4Of(words2));
+  if (words2.slice(0, 7).every((w) => w === 0) && (words2[7] ?? 0) <= 1) return "loopback";
+  if (((words2[0] ?? 0) & 65472) === 65152) return "link-local";
+  if (words2.join(":") === METADATA_V6) return "link-local";
+  return void 0;
+}
+function ipv4Of(words2) {
+  const [high = 0, low = 0] = words2.slice(6);
+  return [high >> 8, high & 255, low >> 8, low & 255].join(".");
+}
+function hextets2(address) {
+  const dotted = /(\d+\.\d+\.\d+\.\d+)$/.exec(address)?.[1];
+  let text = address;
+  if (dotted) {
+    const [a, b, c, d] = dotted.split(".").map(Number);
+    text = `${address.slice(0, -dotted.length)}${(a << 8 | b).toString(16)}:${(c << 8 | d).toString(16)}`;
+  }
+  const [head = "", tail] = text.split("::");
+  const part = (side) => side ? side.split(":").map((w) => Number.parseInt(w, 16)) : [];
+  const left = part(head);
+  const right = tail === void 0 ? [] : part(tail);
+  const gap = Array(8 - left.length - right.length).fill(0);
+  return [...left, ...gap, ...right];
+}
+function loopbackName2(host) {
+  const name2 = host.toLowerCase().replace(/\.$/, "");
+  return name2 === "localhost" || name2.endsWith(".localhost");
+}
+function portOf(url) {
+  if (url.port) return Number(url.port);
+  return url.protocol === "https:" || url.protocol === "wss:" ? 443 : 80;
+}
+function allows(policy, port) {
+  if (Array.isArray(policy)) return policy.includes(port);
+  return policy === true && !DEVTOOLS_PORTS.includes(port);
+}
+function refusal(url, address, place) {
+  const where = `${address}:${portOf(url)}`;
+  const why = place === "link-local" ? `nodeTransport refuses link-local ${where}` : `nodeTransport refuses the host's loopback ${where} (see nodeTransport({ hostLoopback }))`;
+  return Object.assign(new Error(why), { status: 403, code: "EACCES" });
+}
+async function addressesOf(host, resolve2) {
+  const plain = host.replace(/^\[(.*)\]$/, "$1");
+  if (isIP(plain)) return [plain];
+  if (loopbackName2(plain)) return ["127.0.0.1"];
+  return resolve2(plain).catch(() => []);
+}
+async function checkDestination(target, policy, resolve2 = resolveHost) {
+  const url = new URL(target);
+  for (const address of await addressesOf(url.hostname, resolve2)) {
+    const place = placeOf(address);
+    if (!place) continue;
+    if (place === "loopback" && allows(policy, portOf(url))) continue;
+    throw refusal(url, address, place);
+  }
+}
+function guarded2(check, signal) {
+  if (!signal) return check;
+  signal.throwIfAborted();
+  let stop = () => {
+  };
+  const aborted2 = new Promise((_, reject) => {
+    stop = () => reject(signal.reason);
+    signal.addEventListener("abort", stop, { once: true });
+  });
+  return Promise.race([check, aborted2]).finally(() => signal.removeEventListener("abort", stop));
+}
+function guardedLoopback(transport, policy, resolve2) {
+  const open = transport.websocket?.bind(transport);
+  return {
+    get traits() {
+      return transport.traits;
+    },
+    fetch: async (request, owner) => {
+      await guarded2(checkDestination(request.url, policy, resolve2), request.signal);
+      return transport.fetch(request, owner);
+    },
+    ...open ? {
+      websocket: async (request) => {
+        await guarded2(checkDestination(request.url, policy, resolve2), request.signal);
+        return open(request);
+      }
+    } : {}
+  };
+}
+
 // src/node/memory-root.ts
 var fail2 = (name2) => {
   throw new DOMException(name2, name2);
@@ -17902,10 +18814,10 @@ var Chunks = class {
       this.grow(size);
       return;
     }
-    const keep = Math.ceil(size / CHUNK4);
-    this.blobs.length = keep;
-    if (keep > 0)
-      this.blobs[keep - 1] = this.blobs[keep - 1].slice(0, size - (keep - 1) * CHUNK4);
+    const keep2 = Math.ceil(size / CHUNK4);
+    this.blobs.length = keep2;
+    if (keep2 > 0)
+      this.blobs[keep2 - 1] = this.blobs[keep2 - 1].slice(0, size - (keep2 - 1) * CHUNK4);
     this.size = size;
   }
 };
@@ -18043,8 +18955,8 @@ function isMemoryRoot(handle) {
 }
 
 // src/node/ws-diagnose.ts
-import { lookup } from "node:dns/promises";
-import { isIP, connect as tcp } from "node:net";
+import { lookup as lookup2 } from "node:dns/promises";
+import { isIP as isIP2, connect as tcp } from "node:net";
 import { connect as tls } from "node:tls";
 var PROBE_MS = 3e3;
 var PASSED = /* @__PURE__ */ new Set(["ECONNREFUSED", "EHOSTUNREACH", "ENETUNREACH", "ETIMEDOUT", "ECONNRESET"]);
@@ -18054,12 +18966,12 @@ function codeOf5(e) {
   return typeof code === "string" ? code : void 0;
 }
 function probe(secure, host, port, ms) {
-  return new Promise((resolve) => {
-    const socket = secure ? tls({ host, port, ...isIP(host) ? {} : { servername: host } }) : tcp({ host, port });
+  return new Promise((resolve2) => {
+    const socket = secure ? tls({ host, port, ...isIP2(host) ? {} : { servername: host } }) : tcp({ host, port });
     const done4 = (code) => {
       clearTimeout(timer);
       socket.destroy();
-      resolve(code);
+      resolve2(code);
     };
     const timer = setTimeout(() => done4("ETIMEDOUT"), ms);
     socket.once(secure ? "secureConnect" : "connect", () => done4("EPROTO"));
@@ -18075,7 +18987,7 @@ async function diagnose(url, ms = PROBE_MS) {
   const secure = at.protocol === "wss:";
   const port = Number(at.port) || (secure ? 443 : 80);
   try {
-    await lookup(host);
+    await lookup2(host);
   } catch (e) {
     return NO_NAME.has(codeOf5(e) ?? "") ? "EAI_NONAME" : void 0;
   }
@@ -18151,8 +19063,8 @@ var RemoteTransport = class {
   }
   ask(call) {
     if (this.failure) return Promise.reject(this.failure);
-    return new Promise((resolve, reject) => {
-      this.waiting.set(call.nid, { resolve, reject });
+    return new Promise((resolve2, reject) => {
+      this.waiting.set(call.nid, { resolve: resolve2, reject });
       this.port.postMessage(call);
     });
   }
@@ -18332,7 +19244,7 @@ function dialStream(port, onClose) {
     write(chunk2) {
       if (closed) throw errorWithCode("EPIPE: the connection is closed");
       const copy = fresh(chunk2);
-      const acked = new Promise((resolve, reject) => acks.push({ resolve, reject }));
+      const acked = new Promise((resolve2, reject) => acks.push({ resolve: resolve2, reject }));
       port.postMessage(copy, [copy.buffer]);
       return acked;
     },
@@ -18352,7 +19264,7 @@ function dialStream(port, onClose) {
 
 // src/client/loopback-fetch.ts
 var OWN_HEADERS = /* @__PURE__ */ new Set(["host", "connection", "content-length", "transfer-encoding"]);
-var encoder6 = new TextEncoder();
+var encoder8 = new TextEncoder();
 var latin12 = new TextDecoder("latin1");
 var ByteSource = class {
   buffered = new Uint8Array(0);
@@ -18370,7 +19282,7 @@ var ByteSource = class {
     return true;
   }
   async until(marker) {
-    const needle = encoder6.encode(marker);
+    const needle = encoder8.encode(marker);
     for (; ; ) {
       const at = indexOf(this.buffered, needle);
       if (at >= 0) return this.take(at + needle.length);
@@ -18381,13 +19293,13 @@ var ByteSource = class {
     if (this.buffered.length === 0 && !await this.more()) return void 0;
     return this.take(Math.min(max, this.buffered.length));
   }
-  async exactly(count) {
-    while (this.buffered.length < count) if (!await this.more()) return void 0;
-    return this.take(count);
+  async exactly(count2) {
+    while (this.buffered.length < count2) if (!await this.more()) return void 0;
+    return this.take(count2);
   }
-  take(count) {
-    const out = this.buffered.slice(0, count);
-    this.buffered = this.buffered.slice(count);
+  take(count2) {
+    const out = this.buffered.slice(0, count2);
+    this.buffered = this.buffered.slice(count2);
     return out;
   }
 };
@@ -18478,7 +19390,7 @@ async function requestBytes(request) {
   });
   if (body) lines2.push(`Content-Length: ${body.length}`);
   lines2.push("Connection: close", "", "");
-  const head = encoder6.encode(lines2.join("\r\n"));
+  const head = encoder8.encode(lines2.join("\r\n"));
   const out = new Uint8Array(head.length + (body?.length ?? 0));
   out.set(head);
   if (body) out.set(body, head.length);
@@ -18532,8 +19444,8 @@ var KernelCallError = class extends Error {
     this.code = code;
   }
 };
-var encoder7 = new TextEncoder();
-var bytesOf2 = (data) => typeof data === "string" ? encoder7.encode(data) : data;
+var encoder9 = new TextEncoder();
+var bytesOf2 = (data) => typeof data === "string" ? encoder9.encode(data) : data;
 var UNAVAILABLE = {
   manualRedirects: false,
   encodedBodies: false,
@@ -18553,7 +19465,7 @@ async function holdLock(locks) {
   await granted2.promise;
   return { name: name2, release: () => held.resolve() };
 }
-function concat6(chunks2) {
+function concat7(chunks2) {
   const out = new Uint8Array(chunks2.reduce((n, c) => n + c.length, 0));
   let at = 0;
   for (const chunk2 of chunks2) {
@@ -18604,8 +19516,8 @@ var Channel = class {
     const id2 = ++this.nextId;
     const { failure } = this;
     if (failure) return { id: id2, done: Promise.reject(failure) };
-    const done4 = new Promise((resolve, reject) => {
-      this.pending.set(id2, { resolve, reject, ...handlers });
+    const done4 = new Promise((resolve2, reject) => {
+      this.pending.set(id2, { resolve: resolve2, reject, ...handlers });
       this.port.postMessage({ ...call, id: id2 });
     });
     return { id: id2, done: done4 };
@@ -18743,7 +19655,7 @@ async function runOn(channel, argv, opts) {
     onStderr: tee(2, onStderr)
   });
   const { status, signal } = await child.ended;
-  const text = (fd) => new TextDecoder().decode(concat6(chunks2[fd]));
+  const text = (fd) => new TextDecoder().decode(concat7(chunks2[fd]));
   return {
     pid: child.pid,
     status,
@@ -18924,9 +19836,10 @@ function hostfsFetchOf(options) {
     }
   };
 }
-function nodeTransport() {
+function nodeTransport(options = {}) {
   const transport = fetchTransport({ webSocket: true, webSocketHeaders: true, redirect: "manual" });
-  return diagnosing({ ...transport, traits: { ...transport.traits, crossOrigin: "any" } });
+  const open = { ...transport, traits: { ...transport.traits, crossOrigin: "any" } };
+  return diagnosing(guardedLoopback(open, options.hostLoopback ?? false));
 }
 var TERMINATED = "the kernel is terminated";
 var EXIT_GRACE_MS = 50;
@@ -19022,10 +19935,10 @@ async function createNodeKernel(options = {}) {
     ...options.approve ? { approve: options.approve } : {}
   });
   await launcher.prepare();
-  const guard2 = (work) => new Promise((resolve, reject) => {
+  const guard2 = (work) => new Promise((resolve2, reject) => {
     if (terminated) return reject(new Error(TERMINATED));
     pending.add(reject);
-    work().then(resolve, reject).finally(() => pending.delete(reject));
+    work().then(resolve2, reject).finally(() => pending.delete(reject));
   });
   const decoder4 = new TextDecoder();
   return {