@ai-ecoverse/slicc-kernel 1.89.0 → 1.91.0

package/dist/node.js

@@ -92,6 +92,100 @@ function portCdpHook(ask, gone) {
   });
 }
 
+// src/facade/port.ts
+var FACADE_GONE = "the facade host is gone";
+function serveFacadePort(port, hook, { name: name2, stamp }, onDone) {
+  let conn;
+  let done4 = false;
+  const end = () => {
+    done4 = true;
+    port.close();
+    onDone?.();
+  };
+  const finish = () => {
+    if (done4) return;
+    port.postMessage({ close: true });
+    end();
+  };
+  port.addEventListener(
+    "message",
+    ({ data }) => {
+      if (data.b !== void 0) conn?.send(data.b);
+      else if (data.close && !done4) {
+        end();
+        conn?.close(typeof data.close === "string" ? data.close : void 0);
+      }
+    }
+  );
+  port.start?.();
+  new Promise((resolve2) => resolve2(hook(stamp, { name: name2 }))).then(
+    (opened2) => {
+      conn = opened2;
+      if (done4) return opened2.close();
+      opened2.onmessage = (bytes) => {
+        if (done4) return;
+        const copy = bytes.slice();
+        port.postMessage({ b: copy }, [copy.buffer]);
+      };
+      opened2.onclose = () => finish();
+      port.postMessage({ open: true });
+    },
+    (e) => {
+      if (done4) return;
+      port.postMessage({ error: e instanceof Error ? e.message : String(e) });
+      end();
+    }
+  );
+  return () => {
+    if (done4) return;
+    conn?.close();
+    finish();
+  };
+}
+function portFacadeHook(ask, gone) {
+  return (stamp, { name: name2 }) => new Promise((resolve2, reject) => {
+    const { port1, port2 } = new MessageChannel();
+    let closed = false;
+    const shut = () => {
+      closed = true;
+      port1.close();
+    };
+    const conn = {
+      send: (bytes) => {
+        if (closed) return;
+        const copy = bytes.slice();
+        port1.postMessage({ b: copy }, [copy.buffer]);
+      },
+      onmessage: null,
+      onclose: null,
+      close: (reason) => {
+        if (closed) return;
+        port1.postMessage({ close: reason ?? true });
+        shut();
+      }
+    };
+    port1.addEventListener("message", ({ data }) => {
+      if ("b" in data) conn.onmessage?.(data.b);
+      else if ("open" in data) resolve2(conn);
+      else if ("error" in data) {
+        shut();
+        reject(new Error(data.error));
+      } else if (!closed) {
+        shut();
+        conn.onclose?.();
+      }
+    });
+    port1.start();
+    void gone?.then(() => {
+      if (closed) return;
+      shut();
+      reject(new Error(FACADE_GONE));
+      conn.onclose?.(FACADE_GONE);
+    });
+    ask({ name: name2, stamp }, port2);
+  });
+}
+
 // src/fs/types.ts
 var DEFAULT_USERS = "enforce";
 function rangedOps(fs) {
@@ -376,8 +470,8 @@ async function access(fs, cred, path, want, options = {}) {
   if (await present(fs, walked.path, false)) return { ...walked, denied: walked.path };
   return { ...walked, missing: true };
 }
-function refused(path, errno = "EACCES") {
-  return fsError(errno, path);
+function refused(path, errno2 = "EACCES") {
+  return fsError(errno2, path);
 }
 
 // src/fs/dac.ts
@@ -437,9 +531,9 @@ var Created = class {
 function linked(g, options) {
   return g.links === void 0 ? options : { ...options, links: g.links };
 }
-function deny(g, op, path, errno = "EACCES") {
+function deny(g, op, path, errno2 = "EACCES") {
   const tag = g.tag === void 0 ? {} : { tag: g.tag };
-  g.dac.denied({ pid: g.pid, uid: g.cred.euid, op, path, errno, ...tag });
+  g.dac.denied({ pid: g.pid, uid: g.cred.euid, op, path, errno: errno2, ...tag });
 }
 var TTY_MODE = 400;
 function ttyOpenable(g, tty) {
@@ -1106,7 +1200,7 @@ var WASI_SIGNAL_TO_POSIX = Object.fromEntries(
 
 // src/process/wasi-errno.ts
 var WASI_ERRNO = {
-  ...Object.fromEntries(Object.entries(E).map(([name2, errno]) => [`E${name2}`, errno])),
+  ...Object.fromEntries(Object.entries(E).map(([name2, errno2]) => [`E${name2}`, errno2])),
   EWOULDBLOCK: E.AGAIN,
   ENOTSUP: 138,
   EOPNOTSUPP: 138,
@@ -1203,7 +1297,7 @@ function dialError(e, timedOut, closed) {
   if (timedOut) return new KernelError("ETIMEDOUT");
   if (closed) return new KernelError("ECONNABORTED");
   const code = e?.code;
-  const known = DIAL_ERRORS.find((errno) => errno === code);
+  const known = DIAL_ERRORS.find((errno2) => errno2 === code);
   return new KernelError(known ?? "EHOSTUNREACH");
 }
 function isLoopback(host) {
@@ -1260,6 +1354,7 @@ var KernelSocket = class _KernelSocket {
   local;
   peer;
   peerCred;
+  peerStamp;
   listenerCred;
   link;
   readShut = false;
@@ -1330,10 +1425,10 @@ var KernelSocket = class _KernelSocket {
     for (const wait2 of waits) wait2.catch(() => void 0);
     return pipeCall(() => Promise.race(waits));
   }
-  bind(addr) {
+  bind(addr, kernel = false) {
     if (this.state !== "open" || this.local) throw new KernelError("EINVAL");
     if (addr.family !== this.domain) throw new KernelError("EAFNOSUPPORT");
-    this.local = this.net.bind(this, addr);
+    this.local = this.net.bind(this, addr, kernel);
     this.boundAt = this.local;
   }
   listen(backlog, cred) {
@@ -1362,7 +1457,7 @@ var KernelSocket = class _KernelSocket {
     this.changes.wake();
     return true;
   }
-  connect(addr, viaUplink = true, cred) {
+  connect(addr, viaUplink = true, cred, stamp) {
     if (this.state === "connected") throw new KernelError("EISCONN");
     if (this.state === "connecting") throw new KernelError("EALREADY");
     if (this.state !== "open") throw new KernelError("EINVAL");
@@ -1381,6 +1476,7 @@ var KernelSocket = class _KernelSocket {
     server.local = addr.family === "inet" ? { ...addr, host: canonicalHost(addr.host) } : addr;
     server.peer = this.local;
     server.peerCred = cred;
+    server.peerStamp = stamp;
     this.peer = server.local;
     this.peerCred = target.listenerCred;
     link(this, server);
@@ -1521,6 +1617,8 @@ var LoopbackNet = class {
   bound = /* @__PURE__ */ new Map();
   activators = /* @__PURE__ */ new Map();
   internal = /* @__PURE__ */ new Set();
+  reserved = /* @__PURE__ */ new Set();
+  facades = /* @__PURE__ */ new Map();
   nextEphemeral = EPHEMERAL_FIRST;
   route;
   useUplink(route) {
@@ -1535,6 +1633,18 @@ var LoopbackNet = class {
     if (reserve) this.internal.add(port);
     return this.internal.has(port);
   }
+  reserve(port) {
+    this.reserved.add(port);
+  }
+  facade(port, name2) {
+    this.reserve(port);
+    this.kernelOnly(port, true);
+    this.facades.set(port, name2);
+  }
+  facadeAt(addr) {
+    if (addr.family !== "inet" || !isLoopback(canonicalHost(addr.host))) return void 0;
+    return this.facades.get(addr.port);
+  }
   activate(addr, start2) {
     this.activators.set(keyOf(addr), start2);
   }
@@ -1543,7 +1653,7 @@ var LoopbackNet = class {
   }
   listen(addr, backlog = 128) {
     const socket = this.socket(addr.family);
-    socket.bind(addr);
+    socket.bind(addr, true);
     socket.listen(backlog);
     return socket;
   }
@@ -1552,11 +1662,13 @@ var LoopbackNet = class {
     void socket.connect(addr, false);
     return socket;
   }
-  bind(socket, addr) {
+  bind(socket, addr, kernel = false) {
     if (addr.family === "unix") {
       if (addr.path === "") throw new KernelError("EINVAL");
     } else if (addr.host !== "0.0.0.0" && !isLoopback(addr.host)) {
       throw new KernelError("EADDRNOTAVAIL");
+    } else if (!kernel && this.reserved.has(addr.port)) {
+      throw new KernelError("EADDRINUSE");
     }
     const named = addr.family === "inet" && addr.port === 0 ? { ...addr, port: this.ephemeral() } : addr;
     const key = keyOf(named);
@@ -1583,7 +1695,7 @@ var LoopbackNet = class {
     for (let i = 0; i < span; i++) {
       const port = this.nextEphemeral;
       this.nextEphemeral = port === EPHEMERAL_LAST ? EPHEMERAL_FIRST : port + 1;
-      if (!this.bound.has(`inet:${port}`)) return port;
+      if (!this.bound.has(`inet:${port}`) && !this.reserved.has(port)) return port;
     }
     throw new KernelError("EADDRINUSE");
   }
@@ -2041,11 +2153,11 @@ function serveTransport(peer, transport, { closeWaitMs = CLOSE_WAIT_MS } = {}) {
   };
   const sockets = /* @__PURE__ */ new Map();
   const credit = /* @__PURE__ */ new Map();
-  const refill = (nid, n, closing = false) => {
+  const refill = (nid, n, closing2 = false) => {
     const flow = credit.get(nid);
     if (!flow) return;
     flow.inflight -= n;
-    if (closing && !flow.closing) {
+    if (closing2 && !flow.closing) {
       flow.closing = true;
       flow.deadline();
     }
@@ -2068,12 +2180,12 @@ function serveTransport(peer, transport, { closeWaitMs = CLOSE_WAIT_MS } = {}) {
       }
       sockets.set(call.nid, socket);
       peer.postMessage({ net: "ws-opened", nid: call.nid, protocol: socket.protocol });
-      void relay(call.nid, socket);
+      void relay2(call.nid, socket);
     } catch (e) {
       fail3(call.nid, e);
     }
   };
-  const relay = async (nid, socket) => {
+  const relay2 = async (nid, socket) => {
     let ending;
     let late;
     const unanswered = new Promise((resolve2) => {
@@ -2509,7 +2621,7 @@ var UserDb = class {
 };
 
 // src/client/protocol.ts
-var PROTOCOL = [1, 10];
+var PROTOCOL = [1, 11];
 var FS_METHODS = [
   "readFile",
   "writeFile",
@@ -2734,6 +2846,45 @@ function cdpRegistry(send, gone) {
     }
   };
 }
+function facadeRegistry(send, gone) {
+  const registered = /* @__PURE__ */ new Map();
+  const drop = (id2) => {
+    registered.get(id2)?.();
+    return registered.delete(id2);
+  };
+  return {
+    serve(l, req) {
+      const hook = portFacadeHook(
+        (request, facade) => send({ facadeOpen: { ...request, registration: req.id }, port: facade }, [
+          facade
+        ]),
+        gone
+      );
+      registered.set(req.id, l.facades.register(req.name, hook));
+      return req.id;
+    },
+    drop,
+    close: () => {
+      for (const id2 of [...registered.keys()]) drop(id2);
+    }
+  };
+}
+function hostRegistries(send, gone) {
+  const cdps = cdpRegistry(send, gone);
+  const facades = facadeRegistry(send, gone);
+  return {
+    answer(l, req) {
+      if (req.op === "serve-cdp") return cdps.serve(l, req);
+      if (req.op === "unserve-cdp") return cdps.drop(req.registration);
+      if (req.op === "serve-facade") return facades.serve(l, req);
+      return facades.drop(req.registration);
+    },
+    close() {
+      cdps.close();
+      facades.close();
+    }
+  };
+}
 function visibleTo(g, notify) {
   if (!g?.dac.enforcing) return notify;
   let queue = Promise.resolve();
@@ -2777,7 +2928,7 @@ function serveClient(port, host) {
     if (state !== "closed") port.postMessage(message3, transfer);
   };
   const reply = (id2, body, transfer) => send({ id: id2, ...body }, transfer);
-  const cdps = cdpRegistry(send, ended.promise);
+  const hosts = hostRegistries(send, ended.promise);
   function detach(kill = false, bye = "the slicc-kernel detached this client") {
     if (state === "closed") return;
     send({ bye });
@@ -2785,7 +2936,7 @@ function serveClient(port, host) {
     net?.close();
     for (const unwatch of watches.values()) unwatch();
     watches.clear();
-    cdps.close();
+    hosts.close();
     for (const session of terminals.values()) session.close();
     terminals.clear();
     if (kill) killGroups(host, [...groups]);
@@ -2882,16 +3033,16 @@ function serveClient(port, host) {
       case "mount":
         return { result: await l.mountAs(clientCred(self), req.spec) };
       case "umount":
-        await l.umountAs(clientCred(self), req.target);
-        return { result: true };
+        return { result: await l.umountAs(clientCred(self), req.target).then(() => true) };
       case "mounts":
         return { result: l.mounts.list() };
       case "dial":
         return dialFor(l, req, watches);
       case "serve-cdp":
-        return { result: cdps.serve(l, req) };
       case "unserve-cdp":
-        return { result: cdps.drop(req.registration) };
+      case "serve-facade":
+      case "unserve-facade":
+        return { result: hosts.answer(l, req) };
       case "detach":
         return { result: true };
       default:
@@ -4646,15 +4797,15 @@ var UnlinkedKeeper = class {
   wrap(fs = this.fs) {
     const keeper = this;
     const visible = (names) => names.filter((name2) => name2 !== UNLINKED_DIR);
-    const counted2 = (st) => {
+    const counted3 = (st) => {
       const hidden = keeper.links.get(`${st.dev ?? 0}:${st.ino}`) ?? 0;
       return hidden === 0 || st.nlink === void 0 ? st : { ...st, nlink: Math.max(0, st.nlink - hidden) };
     };
     return {
       ...fs,
       links: (path) => mayLink(fs, path),
-      stat: async (path) => counted2(await fs.stat(path)),
-      lstat: async (path) => counted2(await fs.lstat(path)),
+      stat: async (path) => counted3(await fs.stat(path)),
+      lstat: async (path) => counted3(await fs.lstat(path)),
       async rm(path, options) {
         const target = fs.resolvePath("/", path);
         const pinned = await keeper.pin(target);
@@ -4668,7 +4819,7 @@ var UnlinkedKeeper = class {
         await keeper.settle(pinned, () => fs.rename(from, to));
       },
       readdir: async (path) => visible(await fs.readdir(path)),
-      readdirStat: async (path) => (await fs.readdirStat(path)).filter(([name2]) => name2 !== UNLINKED_DIR).map(([name2, st]) => [name2, st && counted2(st)])
+      readdirStat: async (path) => (await fs.readdirStat(path)).filter(([name2]) => name2 !== UNLINKED_DIR).map(([name2, st]) => [name2, st && counted3(st)])
     };
   }
   async settle(pinned, op) {
@@ -5095,6 +5246,9 @@ async function acceptKey(headers) {
   }
   const key = field(headers, "sec-websocket-key") ?? "";
   if (!/^[A-Za-z0-9+/]{22}==$/.test(key)) throw new HttpError(400, "bad Sec-WebSocket-Key");
+  return acceptFor(key);
+}
+async function acceptFor(key) {
   const digest = await crypto.subtle.digest("SHA-1", new TextEncoder().encode(key + GUID));
   return btoa(String.fromCharCode(...new Uint8Array(digest)));
 }
@@ -5118,6 +5272,19 @@ function frame(opcode, payload) {
   out.set(payload, size);
   return out;
 }
+function clientFrame(opcode, payload) {
+  const plain = frame(opcode, payload);
+  const head = plain.length - payload.length;
+  const mask = crypto.getRandomValues(new Uint8Array(4));
+  const out = new Uint8Array(plain.length + 4);
+  out.set(plain.subarray(0, head));
+  out[1] = out[1] | 128;
+  out.set(mask, head);
+  for (let i = 0; i < payload.length; i++) {
+    out[head + 4 + i] = payload[i] ^ mask[i & 3];
+  }
+  return out;
+}
 function closeFrame(code, reason = "") {
   let bytes = new TextEncoder().encode(reason);
   if (bytes.length > 123) {
@@ -5157,10 +5324,12 @@ var WsReader = class {
   continuing = false;
   binaryMessage = false;
   binary;
-  constructor(incoming, max = MAX_MESSAGE, binary) {
+  fromServer;
+  constructor(incoming, max = MAX_MESSAGE, binary, fromServer = false) {
     this.incoming = incoming;
     this.max = max;
     this.binary = binary;
+    this.fromServer = fromServer;
   }
   async next(signal) {
     for (; ; ) {
@@ -5172,7 +5341,7 @@ var WsReader = class {
       const fin = (head[0] & 128) !== 0;
       const opcode = head[0] & 15;
       if ((head[0] & 112) !== 0) throw new WsError(CLOSE.protocol, "reserved bits are set");
-      if ((head[1] & 128) === 0) throw new WsError(CLOSE.protocol, "client frames must be masked");
+      const masked = this.masking(head[1]);
       const length2 = await this.length(head[1] & 127, signal);
       const control = opcode >= 8;
       if (control && (length2 > 125 || !fin)) {
@@ -5181,15 +5350,19 @@ var WsReader = class {
       if (!control && this.size + length2 > this.max) {
         throw new WsError(CLOSE.tooBig, `a message is over ${this.max} bytes`);
       }
-      const mask = new Uint8Array(4);
-      await fill(this.incoming, mask, signal);
-      const payload = new Uint8Array(length2);
-      await fill(this.incoming, payload, signal);
-      for (let i = 0; i < length2; i++) payload[i] ^= mask[i & 3];
+      const payload = await this.payload(length2, masked, signal);
       const event = this.take(opcode, fin, payload);
       if (event) return event;
     }
   }
+  masking(second) {
+    const masked = (second & 128) !== 0;
+    if (masked !== this.fromServer) return masked;
+    throw new WsError(
+      CLOSE.protocol,
+      this.fromServer ? "server frames must not be masked" : "client frames must be masked"
+    );
+  }
   data(opcode, fin, payload) {
     if (opcode === OP.continuation !== this.continuing) {
       throw new WsError(CLOSE.protocol, "unexpected continuation frame");
@@ -5204,6 +5377,14 @@ var WsReader = class {
     this.size = 0;
     return this.binaryMessage ? { kind: "binary", bytes: whole } : { kind: "text", text: decode(whole) };
   }
+  async payload(length2, masked, signal) {
+    const mask = new Uint8Array(4);
+    if (masked) await fill(this.incoming, mask, signal);
+    const payload = new Uint8Array(length2);
+    await fill(this.incoming, payload, signal);
+    if (masked) for (let i = 0; i < length2; i++) payload[i] ^= mask[i & 3];
+    return payload;
+  }
   async length(short, signal) {
     if (short < 126) return short;
     const ext = new Uint8Array(short === 126 ? 2 : 8);
@@ -5478,6 +5659,7 @@ var Relay = class {
 function enableCdp(net, hosts) {
   let facade;
   net.kernelOnly(CDP_PORT, true);
+  net.reserve(CDP_PORT);
   net.activate({ family: "inet", host: "127.0.0.1", port: CDP_PORT }, () => {
     const started = new CdpFacade({ net, hosts });
     facade = started;
@@ -5792,9 +5974,9 @@ async function scanFilesystems(fs, modules) {
     } catch {
       continue;
     }
-    const declared = manifest.slicc?.filesystems;
-    if (!declared || typeof declared !== "object") continue;
-    for (const [type, entry] of Object.entries(declared)) {
+    const declared2 = manifest.slicc?.filesystems;
+    if (!declared2 || typeof declared2 !== "object") continue;
+    for (const [type, entry] of Object.entries(declared2)) {
       const module = inside(pkg, entry?.module);
       if (NAME2.test(type) && module && !found.has(type)) found.set(type, module);
     }
@@ -5812,9 +5994,9 @@ async function scanBinfmts(fs, modules, warn = () => {
     } catch {
       continue;
     }
-    const declared = manifest.slicc?.binfmt;
-    if (!declared || typeof declared !== "object") continue;
-    for (const [suffix, command] of Object.entries(declared)) {
+    const declared2 = manifest.slicc?.binfmt;
+    if (!declared2 || typeof declared2 !== "object") continue;
+    for (const [suffix, command] of Object.entries(declared2)) {
       if (!SUFFIX.test(suffix) || typeof command !== "string" || !NAME2.test(command)) continue;
       const owner = owners.get(suffix);
       if (owner === void 0) {
@@ -5844,94 +6026,831 @@ function binfmtOf(binfmts, path) {
   return best === void 0 ? void 0 : binfmts.get(best);
 }
 
-// src/fs/attest.ts
-var ATTEST_MAX = 1024 * 1024;
-var UNOWNED = 1e3;
-function refuse(code, path, why) {
-  throw Object.assign(new Error(`attest ${path}: ${why}`), { code });
-}
-function chainOf(path) {
-  const parts2 = path.split("/").filter(Boolean);
-  return ["/", ...parts2.map((_, i) => `/${parts2.slice(0, i + 1).join("/")}`)];
+// src/kernel/net/loopback-names.ts
+var HOST_LOOPBACK = "host.slicc.internal";
+var HOST_LOOPBACK_ADDRESS = [10, 0, 2, 2];
+var PAGE_LOOPBACK = "kernel.localhost";
+var PAGE_LOOPBACK_URL = `http://{port}.${PAGE_LOOPBACK}`;
+function toHostLoopback(href) {
+  const url = new URL(href);
+  if (url.hostname.replace(/\.$/, "").toLowerCase() !== HOST_LOOPBACK) return href;
+  url.hostname = "127.0.0.1";
+  return url.href;
 }
-function under2(path, target) {
-  return path === target || path.startsWith(`${target}/`);
+var LOOPBACK_V4 = /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/;
+var LOOPBACK_V6 = /* @__PURE__ */ new Set(["::1", "::", "0:0:0:0:0:0:0:1"]);
+var MAPPED_V4 = /^::ffff:7f[0-9a-f]{2}:[0-9a-f]{1,4}$/;
+var KERNEL_PORT = /^(\d{1,5})\.kernel\.localhost$/;
+var SCHEMES = {
+  "http:": 80,
+  "ws:": 80,
+  "https:": 443,
+  "wss:": 443
+};
+function isKernelLoopbackHost(hostname) {
+  const host = hostname.replace(/^\[(.*)\]$/, "$1").replace(/\.$/, "").toLowerCase();
+  return host === "localhost" || host.endsWith(".localhost") || host === "0.0.0.0" || LOOPBACK_V4.test(host) || LOOPBACK_V6.has(host) || MAPPED_V4.test(host);
 }
-function owned(path, st) {
-  return { path, uid: st.uid ?? UNOWNED, gid: st.gid ?? UNOWNED, mode: st.mode };
+function kernelLoopbackPort(href) {
+  let url;
+  try {
+    url = new URL(href);
+  } catch {
+    return void 0;
+  }
+  const fallback = SCHEMES[url.protocol];
+  if (fallback === void 0 || !isKernelLoopbackHost(url.hostname)) return void 0;
+  const named = KERNEL_PORT.exec(url.hostname.replace(/\.$/, "").toLowerCase())?.[1];
+  const port = Number(named ?? (url.port || fallback));
+  return port >= 1 && port <= 65535 ? port : void 0;
 }
-function unchanged(a, b, bytes) {
-  return a.ino === b.ino && a.mtime.getTime() === b.mtime.getTime() && a.size === b.size && bytes.length === b.size;
+var DEFAULT_HOSTNAME = "slicc";
+var HOSTNAME_ADDRESS = "127.0.1.1";
+var LIBC_HOSTNAMES = ["emscripten", "wasmer.sh"];
+var LABEL = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/i;
+function reserved(name2) {
+  const lower = name2.toLowerCase();
+  return lower === "localhost" || lower.endsWith(".localhost") || lower === HOST_LOOPBACK || lower === "wasmer.sh" || /^\d+(\.\d+){3}$/.test(lower);
 }
-async function sha2562(bytes) {
-  const digest = new Uint8Array(
-    await crypto.subtle.digest("SHA-256", bytes)
-  );
-  return Array.from(digest, (b) => b.toString(16).padStart(2, "0")).join("");
+function isHostname(name2) {
+  if (typeof name2 !== "string" || name2.length > 253 || reserved(name2)) return false;
+  return name2.split(".").every((l) => LABEL.test(l));
 }
-function attested(path, st, bytes, digest, o, parents) {
-  const { uid, gid, mode } = owned(path, st);
-  return {
-    path,
-    bytes,
-    uid,
-    gid,
-    mode,
-    ino: st.ino,
-    mtimeMs: st.mtime.getTime(),
-    sha256: digest,
-    users: o.users,
-    onRootFs: true,
-    parents
-  };
+function ownNames(hostname) {
+  return [.../* @__PURE__ */ new Set([hostname.toLowerCase(), ...LIBC_HOSTNAMES])];
 }
-async function trustedParents(fs, path, o) {
-  const parents = [];
-  for (const dir of chainOf(path).slice(0, -1)) {
-    const st = await fs.lstat(dir);
-    if (st.isSymbolicLink) refuse("EACCES", path, `${dir} is a symlink`);
-    if (!st.isDirectory) refuse("ENOTDIR", path, `${dir} is not a directory`);
-    const perm = owned(dir, st);
-    if (o.users !== "off" && (perm.uid !== 0 || (perm.mode & 18) !== 0)) {
-      refuse("EACCES", path, `${dir} is not root-owned or is writable by group or others`);
+
+// src/kernel/net/proxy-service.ts
+var SEND_BUFFER2 = 1024 * 1024;
+var TLS_HANDSHAKE = 22;
+var TOKEN2 = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+var NO_WEBSOCKET2 = "WebSocket not supported by this transport (fetchTransport needs { webSocket: true })";
+var REALM_PROXY_PORT = 3128;
+var DEFAULT_LIMITS = {
+  maxConnections: 64,
+  maxHead: 64 * 1024,
+  idleMs: 12e4,
+  bodyBudget: 128 * 1024 * 1024,
+  closeWaitMs: 5e3
+};
+var HOP_BY_HOP = /* @__PURE__ */ new Set([
+  "connection",
+  "keep-alive",
+  "proxy-connection",
+  "proxy-authenticate",
+  "proxy-authorization",
+  "te",
+  "trailer",
+  "transfer-encoding",
+  "upgrade"
+]);
+var REQUEST_OWN = /* @__PURE__ */ new Set(["host", "content-length", "expect"]);
+var Budget = class {
+  free;
+  waiters = [];
+  constructor(free) {
+    this.free = free;
+  }
+  async acquire(n, signal) {
+    while (this.free < n) {
+      signal.throwIfAborted();
+      await new Promise((resolve2) => {
+        const done4 = () => {
+          signal.removeEventListener("abort", done4);
+          resolve2();
+        };
+        this.waiters.push(done4);
+        signal.addEventListener("abort", done4, { once: true });
+      });
     }
-    parents.push(perm);
+    this.free -= n;
   }
-  return parents;
-}
-async function attest(fs, asked, o) {
-  if (typeof asked !== "string" || !asked.startsWith("/")) {
-    refuse("EINVAL", String(asked), "not an absolute path");
+  release(n) {
+    this.free += n;
+    const waiters = this.waiters;
+    this.waiters = [];
+    for (const wake of waiters) wake();
   }
-  const path = normalizePath(asked);
-  const mount = o.mounts.find((target) => {
-    const at = normalizePath(target);
-    return at === "/" || under2(path, at);
-  });
-  if (mount !== void 0) refuse("EACCES", path, `under the mount ${mount}`);
-  const parents = await trustedParents(fs, path, o);
-  for (let tries = 0; ; tries++) {
-    const before = await fs.lstat(path);
-    if (before.isSymbolicLink) refuse("EACCES", path, "is a symlink");
-    if (!before.isFile)
-      refuse(before.isDirectory ? "EISDIR" : "EINVAL", path, "is not a regular file");
-    if (before.size > ATTEST_MAX) refuse("EFBIG", path, `is over ${ATTEST_MAX} bytes`);
-    const bytes = (await fs.readFileBuffer(path)).slice();
-    const after = await fs.lstat(path);
-    if (unchanged(before, after, bytes)) {
-      return attested(path, after, bytes, await sha2562(bytes), o, parents);
-    }
-    if (tries >= 1) refuse("EAGAIN", path, "changed while it was read");
+};
+function canonicalHost2(host) {
+  const bare = host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
+  try {
+    return new URL(`http://${bare}/`).hostname;
+  } catch {
+    return void 0;
   }
 }
-var WATCH_DEBOUNCE_MS = 50;
-var FileWatches = class {
-  live = /* @__PURE__ */ new Set();
-  local;
-  remote;
-  constructor(local, remote) {
-    this.local = local;
-    this.remote = remote;
+function localV4(a, b) {
+  return a === 127 || a === 0 || a === 169 && b === 254;
+}
+function hextets(address) {
+  const [head, tail, extra] = address.split("::");
+  if (extra !== void 0) return void 0;
+  const part = (text) => text ? text.split(":").map((h) => Number.parseInt(h, 16)) : [];
+  const front = part(head);
+  const back = part(tail);
+  const groups = tail === void 0 ? front : [...front, ...new Array(8 - front.length - back.length).fill(0), ...back];
+  return groups.length === 8 && groups.every((g) => g >= 0 && g <= 65535) ? groups : void 0;
+}
+function localV6(address) {
+  const g = hextets(address);
+  if (!g) return true;
+  if ((g[0] & 65472) === 65152) return true;
+  const zeroPrefix = g.slice(0, 5).every((x) => x === 0);
+  if (!zeroPrefix) return false;
+  if (g[5] === 65535 || g[5] === 0 && g[6] !== 0) return localV4(g[6] >> 8, g[6] & 255);
+  return g[5] === 0 && g[6] === 0;
+}
+function isLoopbackHost(hostname) {
+  const canonical = canonicalHost2(hostname);
+  if (canonical === void 0) return false;
+  const host = canonical.replace(/\.+$/, "");
+  if (host === "localhost" || host.endsWith(".localhost")) return true;
+  if (host.startsWith("[")) return localV6(host.slice(1, -1));
+  const v4 = /^(\d+)\.(\d+)\.\d+\.\d+$/.exec(host);
+  return v4 ? localV4(Number(v4[1]), Number(v4[2])) : false;
+}
+function dropped(headers) {
+  return /* @__PURE__ */ new Set([...HOP_BY_HOP, ...fieldTokens(headers, "connection")]);
+}
+function forwardRequestHeaders(headers) {
+  const drop = dropped(headers);
+  return headers.filter(([name2]) => {
+    const lower = name2.toLowerCase();
+    return !drop.has(lower) && !REQUEST_OWN.has(lower);
+  });
+}
+function forwardResponseHeaders(headers, opts) {
+  const drop = dropped(headers);
+  if (!opts.encodedBodies) drop.add("content-encoding");
+  if (!(opts.encodedBodies && opts.bodiless)) drop.add("content-length");
+  return headers.filter(([name2]) => !drop.has(name2.toLowerCase()));
+}
+function keepsAlive(req) {
+  const tokens = fieldTokens(req.headers, "connection");
+  if (tokens.includes("close")) return false;
+  return req.minor >= 1 || tokens.includes("keep-alive");
+}
+function tunnelRequestUrl(req, origin) {
+  const base = new URL(origin);
+  let url;
+  try {
+    url = new URL(req.target, req.target.startsWith("/") ? base : void 0);
+  } catch {
+    throw new HttpError(400, "malformed request target");
+  }
+  const hosts = fieldValues(req.headers, "host");
+  const hostOk = hosts.every(
+    (h) => URL.canParse(`https://${h}`) && new URL(`https://${h}`).host === base.host
+  );
+  if (url.origin !== base.origin || !hostOk) {
+    throw new HttpError(421, `this tunnel is for ${base.host}`);
+  }
+  return url.href;
+}
+function requestUrl(req) {
+  if (req.target.startsWith("/")) {
+    throw new HttpError(400, "this is a proxy: send the absolute URL (GET http://host/path)");
+  }
+  let url;
+  try {
+    url = new URL(req.target);
+  } catch {
+    throw new HttpError(400, "malformed request target");
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new HttpError(400, `unsupported scheme ${url.protocol}`);
+  }
+  if (isLoopbackHost(url.hostname)) {
+    throw new HttpError(
+      403,
+      `${url.hostname} is the realm's own loopback, which the proxy does not reach: list it in no_proxy`
+    );
+  }
+  return url.href;
+}
+function tunnelTarget(req) {
+  const match = /^([A-Za-z0-9.-]+|\[[0-9A-Fa-f:.]+\]):(\d{1,5})$/.exec(req.target);
+  const port = Number(match?.[2]);
+  if (!match || port < 1 || port > 65535) {
+    throw new HttpError(400, "CONNECT needs host:port");
+  }
+  const host = canonicalHost2(match[1]);
+  if (host === void 0) throw new HttpError(400, "CONNECT needs host:port");
+  if (isLoopbackHost(host)) {
+    throw new HttpError(
+      403,
+      `${host} is the realm's own loopback, which the proxy does not reach: list it in no_proxy`
+    );
+  }
+  return { host, port };
+}
+async function watchHangup(conn, abort, until) {
+  while (!until.aborted && !abort.signal.aborted) {
+    if (conn.poll().hangup) {
+      abort.abort(new KernelError("EPIPE"));
+      return;
+    }
+    try {
+      await conn.changed(until);
+    } catch {
+      return;
+    }
+  }
+}
+function untilAborted(response, signal) {
+  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(resolve2, reject).finally(() => signal.removeEventListener("abort", onAbort));
+  });
+}
+function plainResponse(status, message3) {
+  const body = latin1Bytes(`slicc realm proxy: ${message3}
+`);
+  return {
+    status,
+    statusText: REASON[status] ?? "",
+    headers: [["Content-Type", "text/plain; charset=utf-8"]],
+    body: (async function* () {
+      yield body;
+    })(),
+    cancel: async () => void 0
+  };
+}
+function timedSource(conn, idle, stop) {
+  return {
+    read: (max, signal) => {
+      const own = signal ? [stop, signal] : [stop];
+      if (Number.isFinite(idle.ms)) own.push(AbortSignal.timeout(idle.ms));
+      return conn.read(max, AbortSignal.any(own));
+    }
+  };
+}
+function webSocketTarget(req) {
+  return { ...req, target: req.target.replace(/^ws(s?):/i, (_, s) => `http${s.toLowerCase()}:`) };
+}
+function wireCode(code) {
+  if (code === 1005) return 1e3;
+  return sendableCode(code) ? code : 1011;
+}
+function quietly(ms) {
+  return new Promise((resolve2) => {
+    AbortSignal.timeout(ms).addEventListener("abort", () => resolve2(), { once: true });
+  });
+}
+var RealmProxy = class {
+  options;
+  listener;
+  stop = new AbortController();
+  limits;
+  slots;
+  bodies;
+  connections = /* @__PURE__ */ new Set();
+  warnedWebSocket = false;
+  closed;
+  port;
+  constructor(options) {
+    this.options = options;
+    this.limits = { ...DEFAULT_LIMITS, ...options.limits };
+    this.slots = new Budget(this.limits.maxConnections);
+    this.bodies = new Budget(this.limits.bodyBudget);
+    this.listener = options.net.listen({
+      family: "inet",
+      host: options.host ?? "127.0.0.1",
+      port: options.port ?? REALM_PROXY_PORT
+    });
+    this.port = this.listener.local?.family === "inet" ? this.listener.local.port : 0;
+    this.closed = this.acceptLoop();
+  }
+  get stopped() {
+    return this.stop.signal.aborted;
+  }
+  close() {
+    if (this.stop.signal.aborted) return;
+    this.stop.abort();
+    this.listener.close();
+    for (const conn of this.connections) conn.close();
+  }
+  async acceptLoop() {
+    const served = /* @__PURE__ */ new Set();
+    try {
+      for (; ; ) {
+        await this.slots.acquire(1, this.stop.signal);
+        let conn;
+        try {
+          conn = await this.listener.accept(this.stop.signal);
+        } catch {
+          this.slots.release(1);
+          break;
+        }
+        const done4 = this.serve(conn).finally(() => {
+          this.slots.release(1);
+          served.delete(done4);
+        });
+        served.add(done4);
+      }
+    } catch {
+    }
+    await Promise.allSettled([...served]);
+  }
+  async serve(conn) {
+    this.connections.add(conn);
+    const idle = { ms: this.limits.idleMs };
+    const incoming = new Incoming(timedSource(conn, idle, this.stop.signal));
+    try {
+      await this.requests({ sink: conn, incoming, conn, socket: conn, idle });
+    } finally {
+      this.connections.delete(conn);
+      conn.close();
+    }
+  }
+  async requests(ctx) {
+    try {
+      for (; ; ) {
+        const head = await ctx.incoming.head(this.limits.maxHead);
+        if (!head || !await this.exchange(ctx, head)) break;
+      }
+    } catch (e) {
+      if (e instanceof HttpError) await this.refuse(ctx.sink, e);
+    }
+  }
+  async refuse(sink, error) {
+    try {
+      await this.relay(sink, "GET", 1, plainResponse(error.status, error.message), false);
+    } catch {
+    }
+  }
+  async exchange(ctx, head) {
+    const { sink: conn, incoming } = ctx;
+    const req = parseRequestHead(head);
+    if (req.method === "CONNECT") {
+      if (!ctx.conn) throw new HttpError(400, "CONNECT inside a tunnel");
+      await this.connect(ctx.conn, incoming, req, ctx.idle);
+      return false;
+    }
+    if (req.method === "GET" && isUpgrade(req.headers)) {
+      await this.websocket(ctx, req);
+      return false;
+    }
+    const url = ctx.origin ? tunnelRequestUrl(req, ctx.origin) : requestUrl(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`);
+    await this.expectContinue(conn, req, framing.kind !== "none");
+    await this.bodies.acquire(reserve, this.stop.signal);
+    let response;
+    const abort = new AbortController();
+    const stopExchange = () => abort.abort();
+    this.stop.signal.addEventListener("abort", stopExchange, { once: true });
+    try {
+      try {
+        const body = await readBody(incoming, framing, this.cap());
+        const waiting = new AbortController();
+        void watchHangup(ctx.socket, abort, waiting.signal);
+        try {
+          response = await this.upstream(req, url, body, abort.signal, ctx.socket.peerCred?.pid);
+        } finally {
+          waiting.abort();
+        }
+      } finally {
+        this.bodies.release(reserve);
+      }
+      return await this.relay(conn, req.method, req.minor, response, keep2);
+    } finally {
+      this.stop.signal.removeEventListener("abort", stopExchange);
+      abort.abort();
+    }
+  }
+  cap() {
+    return Math.min(this.options.transport.traits.maxRequestBody, this.limits.bodyBudget);
+  }
+  async expectContinue(conn, req, hasBody) {
+    const expect = fieldTokens(req.headers, "expect");
+    if (expect.length === 0) return;
+    if (expect.length !== 1 || expect[0] !== "100-continue") {
+      throw new HttpError(417, `unsupported expectation: ${expect.join(", ")}`);
+    }
+    if (hasBody && req.minor >= 1) {
+      await conn.write(latin1Bytes("HTTP/1.1 100 Continue\r\n\r\n"), this.stop.signal);
+    }
+  }
+  async upstream(req, url, body, signal, owner) {
+    try {
+      const fetching = this.options.transport.fetch(
+        {
+          url: toHostLoopback(url),
+          method: req.method.toUpperCase(),
+          headers: forwardRequestHeaders(req.headers),
+          body: req.method === "GET" || req.method === "HEAD" ? void 0 : body,
+          signal
+        },
+        owner
+      );
+      return await untilAborted(fetching, signal);
+    } catch (e) {
+      if (signal.aborted) throw e;
+      const message3 = e instanceof Error ? e.message : String(e);
+      const status = e?.status;
+      const own = typeof status === "number" && status >= 400 && status <= 599 ? status : 502;
+      return plainResponse(own, message3 || "upstream request failed");
+    }
+  }
+  async relay(conn, method, minor, response, keepAlive) {
+    const status = response.status;
+    const bodiless2 = method === "HEAD" || status === 204 || status === 304 || status < 200;
+    const headers = forwardResponseHeaders(response.headers, {
+      encodedBodies: this.options.transport.traits.encodedBodies,
+      bodiless: bodiless2
+    });
+    const chunked3 = !bodiless2 && minor >= 1;
+    const keep2 = keepAlive && (bodiless2 || chunked3);
+    headers.push(["Connection", keep2 ? "keep-alive" : "close"]);
+    if (chunked3) headers.push(["Transfer-Encoding", "chunked"]);
+    const signal = this.stop.signal;
+    await conn.write(
+      responseHead(status, response.statusText || REASON[status] || "", headers),
+      signal
+    );
+    if (bodiless2) {
+      await response.cancel();
+      return keep2;
+    }
+    try {
+      for await (const piece of response.body) {
+        if (piece.length > 0) await conn.write(chunked3 ? chunk(piece) : piece, signal);
+      }
+    } catch {
+      await response.cancel().catch(() => void 0);
+      return false;
+    }
+    if (chunked3) await conn.write(LAST_CHUNK, signal);
+    return keep2;
+  }
+  async connect(conn, incoming, req, idle) {
+    const target = tunnelTarget(req);
+    const refused2 = target.port === 443 ? await this.tunnelReady(target) : void 0;
+    if (refused2) throw refused2;
+    await conn.write(latin1Bytes("HTTP/1.1 200 Connection Established\r\n\r\n"), this.stop.signal);
+    try {
+      const first = await incoming.peek(this.stop.signal);
+      if (first === void 0) return;
+      if (first !== TLS_HANDSHAKE) {
+        const origin = `http://${target.port === 80 ? target.host : `${target.host}:${target.port}`}`;
+        await this.requests({ sink: conn, incoming, origin, socket: conn, idle });
+        return;
+      }
+      const tunnel = this.options.tunnel;
+      if (!tunnel || target.port !== 443 && await this.tunnelReady(target)) return;
+      await tunnel(
+        conn,
+        incoming,
+        target,
+        this.stop.signal,
+        (source, sink, origin) => this.requests({ sink, incoming: new Incoming(source), origin, socket: conn, idle })
+      );
+    } catch {
+    }
+  }
+  async tunnelReady(target) {
+    const name2 = `CONNECT ${target.host}:${target.port}`;
+    if (!this.options.tunnel) return new HttpError(501, `${name2}: no tunnels through this proxy`);
+    try {
+      await this.options.tunnelReady?.();
+      return void 0;
+    } catch (e) {
+      return new HttpError(501, `${name2}: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+  async websocket(ctx, req) {
+    const href = ctx.origin ? tunnelRequestUrl(req, ctx.origin) : requestUrl(webSocketTarget(req));
+    const { transport } = this.options;
+    if (!transport.traits.websocket || !transport.websocket) {
+      if (!this.warnedWebSocket) {
+        this.warnedWebSocket = true;
+        console.warn(`slicc-kernel: a program asked for a WebSocket: ${NO_WEBSOCKET2}`);
+      }
+      throw new HttpError(501, NO_WEBSOCKET2);
+    }
+    const accept2 = await acceptKey(req.headers);
+    const protocols = fieldValues(req.headers, "sec-websocket-protocol").flatMap((v) => v.split(",")).map((t) => t.trim()).filter((t) => t !== "");
+    const hangup = new AbortController();
+    const waiting = new AbortController();
+    void watchHangup(ctx.socket, hangup, waiting.signal);
+    let socket;
+    try {
+      socket = await transport.websocket({
+        url: toHostLoopback(href).replace(/^http/, "ws"),
+        protocols,
+        headers: forwardRequestHeaders(req.headers),
+        signal: AbortSignal.any([this.stop.signal, hangup.signal])
+      });
+    } catch (e) {
+      waiting.abort();
+      throw new HttpError(502, e instanceof Error ? e.message : String(e));
+    }
+    ctx.idle.ms = Number.POSITIVE_INFINITY;
+    try {
+      if (hangup.signal.aborted) throw hangup.signal.reason;
+      if (socket.protocol && !(protocols.includes(socket.protocol) && TOKEN2.test(socket.protocol))) {
+        throw new HttpError(502, "the far end chose a subprotocol the client did not offer");
+      }
+      await ctx.sink.write(switchingHead(accept2, socket.protocol), this.stop.signal);
+      await this.bridge(ctx, socket, hangup.signal);
+    } catch (e) {
+      socket.close(1001, "the client went away");
+      throw e;
+    } finally {
+      waiting.abort();
+    }
+  }
+  async bridge(ctx, socket, hangup) {
+    const stop = this.stop.signal;
+    let chain2 = Promise.resolve();
+    const toGuest = (bytes) => {
+      chain2 = chain2.then(() => ctx.sink.write(bytes, stop));
+      return chain2;
+    };
+    const done4 = new AbortController();
+    const reading = AbortSignal.any([stop, done4.signal, hangup]);
+    const stopping = () => socket.close(1001, "the proxy is stopping");
+    stop.addEventListener("abort", stopping, { once: true });
+    let guestDone = false;
+    let closeSent = false;
+    const outbound2 = (async () => {
+      for await (const data of socket.messages) {
+        if (guestDone) continue;
+        const text = typeof data === "string";
+        await toGuest(
+          frame(text ? OP_TEXT : OP_BINARY, text ? new TextEncoder().encode(data) : data)
+        );
+      }
+      const closed = await socket.closed;
+      if (guestDone) return;
+      closeSent = true;
+      await toGuest(closeFrame(wireCode(closed.code), closed.reason));
+      AbortSignal.timeout(this.limits.closeWaitMs).addEventListener("abort", () => done4.abort(), {
+        once: true
+      });
+    })().catch(() => done4.abort());
+    const reader = new WsReader(ctx.incoming, MESSAGE_LIMIT, true);
+    try {
+      for (; ; ) {
+        const event = await reader.next(reading);
+        if (!event) break;
+        if (event.kind === "ping") {
+          await toGuest(pongFrame(event.payload));
+          continue;
+        }
+        if (event.kind === "close") {
+          guestDone = true;
+          if (closeSent) break;
+          const code = wireCode(event.code);
+          socket.close(code, event.reason);
+          const reply = await Promise.race([
+            socket.closed,
+            quietly(this.limits.closeWaitMs).then(() => ({ code, reason: event.reason }))
+          ]);
+          await toGuest(closeFrame(wireCode(reply.code), reply.reason));
+          break;
+        }
+        while (socket.buffered > SEND_BUFFER2 && !reading.aborted) await quietly(10);
+        socket.send(event.kind === "text" ? event.text : event.bytes);
+      }
+    } catch (e) {
+      if (e instanceof WsError) {
+        guestDone = true;
+        socket.close(e.code, e.message);
+        await toGuest(closeFrame(e.code, e.message)).catch(() => void 0);
+      }
+    } finally {
+      guestDone = true;
+      socket.close(1e3, "the client went away");
+      stop.removeEventListener("abort", stopping);
+      await Promise.race([outbound2, quietly(this.limits.closeWaitMs)]);
+    }
+  }
+};
+
+// src/facade/types.ts
+var FACADE_NAME = /^[a-z][a-z0-9-]*$/;
+function facadeEnvName(name2) {
+  return `SLICC_${name2.toUpperCase().replaceAll("-", "_")}_URL`;
+}
+function facadeUrl(port) {
+  return `tcp://127.0.0.1:${port}`;
+}
+
+// src/facade/hosts.ts
+var TAKEN_PORTS = /* @__PURE__ */ new Set([CDP_PORT, REALM_PROXY_PORT]);
+var READ_CHUNK = 64 * 1024;
+var FACADE_MAX_PENDING = 16 * 1024 * 1024;
+var FACADE_FLOODED = `slicc-kernel: more than ${FACADE_MAX_PENDING} bytes are waiting for the program to read`;
+function declared(specs) {
+  const out = /* @__PURE__ */ new Map();
+  const ports = /* @__PURE__ */ new Set();
+  for (const [name2, spec] of Object.entries(specs ?? {})) {
+    if (!FACADE_NAME.test(name2)) throw new TypeError(`facades: not a facade name: ${name2}`);
+    const port = spec?.port;
+    if (!Number.isInteger(port) || port < 1 || port > 65535 || TAKEN_PORTS.has(port)) {
+      throw new TypeError(`facades.${name2}: not a free port: ${String(port)}`);
+    }
+    if (ports.has(port)) throw new TypeError(`facades.${name2}: port ${port} is taken twice`);
+    if (spec.hook !== void 0 && typeof spec.hook !== "function") {
+      throw new TypeError(`facades.${name2}: hook must be a function`);
+    }
+    ports.add(port);
+    out.set(name2, { port, embedder: spec.hook, clients: [] });
+  }
+  return out;
+}
+var FacadeHosts = class {
+  facades;
+  constructor(specs) {
+    this.facades = declared(specs);
+  }
+  env() {
+    const env = {};
+    for (const [name2, { port }] of this.facades) env[facadeEnvName(name2)] = facadeUrl(port);
+    return env;
+  }
+  enable(net) {
+    for (const [name2, { port }] of this.facades) {
+      net.facade(port, name2);
+      net.activate({ family: "inet", host: "127.0.0.1", port }, () => {
+        const listener = net.listen({ family: "inet", host: "127.0.0.1", port });
+        void acceptAll(listener, (socket) => this.serve(name2, socket));
+      });
+    }
+  }
+  register(name2, hook) {
+    const entry = this.facades.get(name2);
+    if (!entry || typeof hook !== "function") throw new KernelError("EINVAL");
+    entry.clients.push(hook);
+    return () => {
+      const at = entry.clients.indexOf(hook);
+      if (at >= 0) entry.clients.splice(at, 1);
+    };
+  }
+  async serve(name2, socket) {
+    const entry = this.facades.get(name2);
+    const hook = entry.clients.at(-1) ?? entry.embedder;
+    const stamp = socket.peerStamp;
+    if (!hook || !stamp) return socket.close();
+    let conn;
+    try {
+      conn = await hook(structuredClone(stamp), { name: name2 });
+    } catch {
+      return socket.close();
+    }
+    await relay(socket, conn);
+  }
+};
+async function acceptAll(listener, serve) {
+  for (; ; ) {
+    const socket = await listener.accept();
+    void serve(socket);
+  }
+}
+async function relay(socket, conn) {
+  let ended = false;
+  let pending = 0;
+  let writes = Promise.resolve();
+  const end = () => {
+    if (ended) return;
+    ended = true;
+    socket.close();
+  };
+  conn.onmessage = (bytes) => {
+    if (ended) return;
+    const chunk2 = bytes.slice();
+    pending += chunk2.length;
+    if (pending > FACADE_MAX_PENDING) {
+      end();
+      conn.close(FACADE_FLOODED);
+      return;
+    }
+    writes = writes.then(async () => {
+      if (ended) return;
+      let at = 0;
+      while (at < chunk2.length) at += await socket.write(chunk2.subarray(at));
+      pending -= chunk2.length;
+    });
+    writes.catch(() => {
+      end();
+      conn.close();
+    });
+  };
+  conn.onclose = () => {
+    writes.then(end, end);
+  };
+  try {
+    for (; ; ) {
+      const bytes = await socket.read(READ_CHUNK);
+      if (bytes.length === 0 || ended) break;
+      conn.send(bytes);
+    }
+  } catch {
+  }
+  if (!ended) {
+    end();
+    conn.close();
+  }
+}
+
+// src/fs/attest.ts
+var ATTEST_MAX = 1024 * 1024;
+var UNOWNED = 1e3;
+function refuse(code, path, why) {
+  throw Object.assign(new Error(`attest ${path}: ${why}`), { code });
+}
+function chainOf(path) {
+  const parts2 = path.split("/").filter(Boolean);
+  return ["/", ...parts2.map((_, i) => `/${parts2.slice(0, i + 1).join("/")}`)];
+}
+function under2(path, target) {
+  return path === target || path.startsWith(`${target}/`);
+}
+function owned(path, st) {
+  return { path, uid: st.uid ?? UNOWNED, gid: st.gid ?? UNOWNED, mode: st.mode };
+}
+function unchanged(a, b, bytes) {
+  return a.ino === b.ino && a.mtime.getTime() === b.mtime.getTime() && a.size === b.size && bytes.length === b.size;
+}
+async function sha2562(bytes) {
+  const digest = new Uint8Array(
+    await crypto.subtle.digest("SHA-256", bytes)
+  );
+  return Array.from(digest, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function attested(path, st, bytes, digest, o, parents) {
+  const { uid, gid, mode } = owned(path, st);
+  return {
+    path,
+    bytes,
+    uid,
+    gid,
+    mode,
+    ino: st.ino,
+    mtimeMs: st.mtime.getTime(),
+    sha256: digest,
+    users: o.users,
+    onRootFs: true,
+    parents
+  };
+}
+async function trustedParents(fs, path, o) {
+  const parents = [];
+  for (const dir of chainOf(path).slice(0, -1)) {
+    const st = await fs.lstat(dir);
+    if (st.isSymbolicLink) refuse("EACCES", path, `${dir} is a symlink`);
+    if (!st.isDirectory) refuse("ENOTDIR", path, `${dir} is not a directory`);
+    const perm = owned(dir, st);
+    if (o.users !== "off" && (perm.uid !== 0 || (perm.mode & 18) !== 0)) {
+      refuse("EACCES", path, `${dir} is not root-owned or is writable by group or others`);
+    }
+    parents.push(perm);
+  }
+  return parents;
+}
+async function attest(fs, asked, o) {
+  if (typeof asked !== "string" || !asked.startsWith("/")) {
+    refuse("EINVAL", String(asked), "not an absolute path");
+  }
+  const path = normalizePath(asked);
+  const mount = o.mounts.find((target) => {
+    const at = normalizePath(target);
+    return at === "/" || under2(path, at);
+  });
+  if (mount !== void 0) refuse("EACCES", path, `under the mount ${mount}`);
+  const parents = await trustedParents(fs, path, o);
+  for (let tries = 0; ; tries++) {
+    const before = await fs.lstat(path);
+    if (before.isSymbolicLink) refuse("EACCES", path, "is a symlink");
+    if (!before.isFile)
+      refuse(before.isDirectory ? "EISDIR" : "EINVAL", path, "is not a regular file");
+    if (before.size > ATTEST_MAX) refuse("EFBIG", path, `is over ${ATTEST_MAX} bytes`);
+    const bytes = (await fs.readFileBuffer(path)).slice();
+    const after = await fs.lstat(path);
+    if (unchanged(before, after, bytes)) {
+      return attested(path, after, bytes, await sha2562(bytes), o, parents);
+    }
+    if (tries >= 1) refuse("EAGAIN", path, "changed while it was read");
+  }
+}
+var WATCH_DEBOUNCE_MS = 50;
+var FileWatches = class {
+  live = /* @__PURE__ */ new Set();
+  local;
+  remote;
+  constructor(local, remote) {
+    this.local = local;
+    this.remote = remote;
   }
   announce() {
     return this.remote.announceWatch?.([...new Set([...this.live].flat())]) ?? Promise.resolve();
@@ -8868,58 +9787,31 @@ var ProcessClocks = class {
   }
   freeze() {
     for (const c of this.all()) c.freeze();
-  }
-  times() {
-    if (!this.enabled) return void 0;
-    const sum = { ...this.ended };
-    for (const c of this.all()) {
-      const t = c.times();
-      sum.utime += t.utime;
-      sum.stime += t.stime;
-    }
-    return sum;
-  }
-  running() {
-    return this.enabled ? this.all().filter((c) => c.running()).length : 0;
-  }
-  timed(clock, dispatch2) {
-    const c = clock ?? this.main;
-    return (req) => {
-      c.enter(req.op);
-      return dispatch2(req).finally(() => c.leave());
-    };
-  }
-  all() {
-    return [this.main, ...this.threads.values()];
-  }
-};
-
-// src/kernel/net/loopback-names.ts
-var HOST_LOOPBACK = "host.slicc.internal";
-var HOST_LOOPBACK_ADDRESS = [10, 0, 2, 2];
-var PAGE_LOOPBACK = "kernel.localhost";
-var PAGE_LOOPBACK_URL = `http://{port}.${PAGE_LOOPBACK}`;
-function toHostLoopback(href) {
-  const url = new URL(href);
-  if (url.hostname.replace(/\.$/, "").toLowerCase() !== HOST_LOOPBACK) return href;
-  url.hostname = "127.0.0.1";
-  return url.href;
-}
-var DEFAULT_HOSTNAME = "slicc";
-var HOSTNAME_ADDRESS = "127.0.1.1";
-var LIBC_HOSTNAMES = ["emscripten", "wasmer.sh"];
-var LABEL = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/i;
-function reserved(name2) {
-  const lower = name2.toLowerCase();
-  return lower === "localhost" || lower.endsWith(".localhost") || lower === HOST_LOOPBACK || lower === "wasmer.sh" || /^\d+(\.\d+){3}$/.test(lower);
-}
-function isHostname(name2) {
-  if (typeof name2 !== "string" || name2.length > 253 || reserved(name2)) return false;
-  return name2.split(".").every((l) => LABEL.test(l));
-}
-function ownNames(hostname) {
-  return [.../* @__PURE__ */ new Set([hostname.toLowerCase(), ...LIBC_HOSTNAMES])];
-}
+  }
+  times() {
+    if (!this.enabled) return void 0;
+    const sum = { ...this.ended };
+    for (const c of this.all()) {
+      const t = c.times();
+      sum.utime += t.utime;
+      sum.stime += t.stime;
+    }
+    return sum;
+  }
+  running() {
+    return this.enabled ? this.all().filter((c) => c.running()).length : 0;
+  }
+  timed(clock, dispatch2) {
+    const c = clock ?? this.main;
+    return (req) => {
+      c.enter(req.op);
+      return dispatch2(req).finally(() => c.leave());
+    };
+  }
+  all() {
+    return [this.main, ...this.threads.values()];
+  }
+};
 
 // src/fs/pages.ts
 var PAGE = 64 * 1024;
@@ -9172,7 +10064,7 @@ function mountTable(mounts = []) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.89.0" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.91.0" : "0.0.0-dev";
 var OS_RELEASE = "6.0.0-slicc";
 function procVersion() {
   return `Linux version ${OS_RELEASE} (slicc-kernel ${KERNEL_VERSION}) #1 SMP PREEMPT_DYNAMIC
@@ -9427,893 +10319,669 @@ var ProcTree = class {
     }
     if (leaf === void 0 && top === "mounts") {
       return { kind: "file", content: () => mountTable(this.source.mountList()) };
-    }
-    if (leaf === void 0 && SYSTEM_NAMES.includes(top)) {
-      return {
-        kind: "file",
-        content: () => systemFile(top, this.listing(), Date.now(), this.memory)
-      };
-    }
-    if (!/^[1-9]\d*$/.test(top) || rest2.length > 0 || !this.alive(Number(top))) return void 0;
-    if (leaf === void 0) return { kind: "dir", names: () => [...PID_NAMES] };
-    if (!PID_NAMES.includes(leaf)) return void 0;
-    return {
-      kind: "file",
-      content: () => {
-        const listing = this.listing();
-        const info = listing.processes.find((p) => p.pid === Number(top));
-        if (!info) throw syncError("ENOENT", `/proc/${top}/${leaf}`);
-        return pidFile(leaf, info, listing.boot);
-      }
-    };
-  }
-  parts(path, follow2) {
-    const parts2 = path.split("/").filter((p) => p !== "").slice(1);
-    if (parts2[0] === "self" && (follow2 || parts2.length > 1)) parts2[0] = String(this.pid);
-    return parts2;
-  }
-  find(path, follow2) {
-    const node = this.node(this.parts(path, follow2));
-    if (!node) throw syncError("ENOENT", path);
-    return node;
-  }
-  stat(path, follow2 = true) {
-    const node = this.find(path, follow2);
-    const base = {
-      isFile: false,
-      isDirectory: false,
-      size: 0,
-      mtimeMs: Date.now(),
-      readonly: true
-    };
-    if (node.kind === "dir") return { ...base, isDirectory: true, mode: DIR_MODE };
-    if (node.kind === "link") {
-      return { ...base, isSymbolicLink: true, mode: LINK_MODE, size: node.target.length };
-    }
-    return { ...base, isFile: true, mode: FILE_MODE, size: this.bytes(node).length };
-  }
-  bytes(node) {
-    return new TextEncoder().encode(node.kind === "file" ? node.content() : "");
-  }
-  read(path) {
-    const node = this.find(path, true);
-    if (node.kind !== "file") throw syncError("EISDIR", path);
-    return this.bytes(node);
-  }
-  readdir(path) {
-    const node = this.find(path, true);
-    if (node.kind !== "dir") throw syncError("ENOTDIR", path);
-    return node.names();
-  }
-  readlink(path) {
-    const node = this.find(path, false);
-    if (node.kind !== "link") throw syncError("EINVAL", path);
-    return node.target;
-  }
-  exists(path) {
-    try {
-      this.find(path, true);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-};
-var MAX_HOPS3 = 40;
-function* procWalk(path, follow2) {
-  let done4 = [];
-  let todo = path.split("/").filter((part) => part !== "");
-  let hops = 0;
-  let broken;
-  while (todo.length > 0) {
-    const part = todo.shift();
-    if (part === ".") continue;
-    if (part === "..") {
-      done4.pop();
-      continue;
-    }
-    const at = `/${[...done4, part].join("/")}`;
-    const whole = normalize(`/${[...done4, part, ...todo].join("/")}`);
-    if (inProc(at) && inProc(whole)) return broken ?? whole;
-    if (!follow2 && todo.length === 0) return void 0;
-    const target = yield { at, check: todo.find((next2) => next2 !== ".") === ".." };
-    if (typeof target === "string") {
-      if (++hops > MAX_HOPS3) return void 0;
-      [done4, todo] = throughLink(target, done4, todo);
-    } else {
-      broken ??= refusalOf(target);
-      done4.push(part);
-    }
-  }
-  return void 0;
-}
-function failed(err) {
-  const code = err?.code;
-  return { refused: typeof code === "string" ? code : "ENOENT" };
-}
-function refusalOf(found) {
-  if (found === true) return void 0;
-  return found === false ? { refused: "ENOTDIR" } : found;
-}
-function throughLink(target, done4, todo) {
-  const parts2 = target.split("/").filter((part) => part !== "");
-  return [target.startsWith("/") ? [] : done4, [...parts2, ...todo]];
-}
-async function procAlias(fs, path, follow2) {
-  const { readlink, lstat } = fs;
-  if (!readlink || !lstat) return void 0;
-  const physical = await lstat.call(fs, "/proc").then(
-    () => true,
-    () => false
-  );
-  if (!physical) return void 0;
-  const walk2 = procWalk(path, follow2);
-  let step = walk2.next();
-  while (!step.done) {
-    const { at, check } = step.value;
-    const link2 = await readlink.call(fs, at).catch(() => void 0);
-    const isDir = (st) => st.isDirectory === true;
-    const target = link2 ?? (check ? await lstat.call(fs, at).then(isDir, failed) : true);
-    step = walk2.next(target);
-  }
-  return step.value;
-}
-
-// src/kernel/host-ops.ts
-var HOST_OPS = [
-  "lock",
-  "unlock",
-  "async-submit",
-  "async-wait",
-  "async-take",
-  "async-resolve",
-  "async-hold",
-  "async-cancel",
-  "async-settle",
-  "async-close"
-];
-var json3 = (value) => ({ ok: true, kind: "json", json: value });
-var done2 = { ok: true, kind: "void" };
-var LockTable = class {
-  held = /* @__PURE__ */ new Map();
-  lock(pid, path, exclusive, fd) {
-    const holders = this.held.get(path) ?? /* @__PURE__ */ new Map();
-    for (const [other, h] of holders) if (other !== pid && (exclusive || h.exclusive)) return false;
-    const mine = holders.get(pid) ?? { exclusive, fds: /* @__PURE__ */ new Set() };
-    mine.exclusive = exclusive;
-    mine.fds.add(fd);
-    holders.set(pid, mine);
-    this.held.set(path, holders);
-    return true;
-  }
-  unlock(pid, path) {
-    const holders = this.held.get(path);
-    holders?.delete(pid);
-    if (holders?.size === 0) this.held.delete(path);
-  }
-  closed(pid, fd) {
-    for (const [path, holders] of [...this.held]) {
-      const mine = holders.get(pid);
-      if (mine?.fds.delete(fd) && mine.fds.size === 0) this.unlock(pid, path);
-    }
-  }
-  release(pid) {
-    for (const path of [...this.held.keys()]) this.unlock(pid, path);
-  }
-};
-var KEPT_OPS = /* @__PURE__ */ new Set(["fd-write"]);
-var unknownSettled = false;
-var AsyncOps = class {
-  next = 1;
-  results = /* @__PURE__ */ new Map();
-  ready = [];
-  running = /* @__PURE__ */ new Map();
-  waiters = /* @__PURE__ */ new Set();
-  taken = /* @__PURE__ */ new Map();
-  kept = /* @__PURE__ */ new Set();
-  closed = false;
-  run;
-  onReady;
-  constructor(run2, onReady) {
-    this.run = run2;
-    this.onReady = onReady;
-  }
-  submit(req) {
-    const id2 = this.hold();
-    if (KEPT_OPS.has(req.op)) this.kept.add(id2);
-    const running = new AbortController();
-    this.running.set(id2, running);
-    this.run(req, running.signal).then(
-      (result) => this.complete(id2, result),
-      (err) => this.complete(id2, { ok: false, errno: "EIO", message: String(err) })
-    );
-    return id2;
-  }
-  resolve(value) {
-    const id2 = this.hold();
-    this.complete(id2, json3(value));
-    return id2;
-  }
-  hold() {
-    const id2 = this.next++;
-    this.results.set(id2, void 0);
-    return id2;
-  }
-  take(id2) {
-    if (!this.results.has(id2)) throw new KernelError("EINVAL");
-    const result = this.results.get(id2);
-    if (!result) throw new KernelError("EAGAIN");
-    this.forget(id2);
-    if (this.kept.delete(id2)) this.taken.set(id2, result);
-    return result;
-  }
-  ack(ids) {
-    for (const id2 of ids) this.taken.delete(id2);
-  }
-  async settle(ids) {
-    const never = new AbortController().signal;
-    while (ids.some((id2) => this.running.has(id2))) await this.sleep(void 0, never);
-    return ids.map((id2) => {
-      const result = this.results.get(id2) ?? this.taken.get(id2) ?? null;
-      if (!result && !unknownSettled) {
-        unknownSettled = true;
-        console.warn(`async-settle: no result for op ${id2}; its write counts as made`);
+    }
+    if (leaf === void 0 && SYSTEM_NAMES.includes(top)) {
+      return {
+        kind: "file",
+        content: () => systemFile(top, this.listing(), Date.now(), this.memory)
+      };
+    }
+    if (!/^[1-9]\d*$/.test(top) || rest2.length > 0 || !this.alive(Number(top))) return void 0;
+    if (leaf === void 0) return { kind: "dir", names: () => [...PID_NAMES] };
+    if (!PID_NAMES.includes(leaf)) return void 0;
+    return {
+      kind: "file",
+      content: () => {
+        const listing = this.listing();
+        const info = listing.processes.find((p) => p.pid === Number(top));
+        if (!info) throw syncError("ENOENT", `/proc/${top}/${leaf}`);
+        return pidFile(leaf, info, listing.boot);
       }
-      return result;
-    });
+    };
   }
-  cancel(id2) {
-    this.kept.delete(id2);
-    this.running.get(id2)?.abort();
-    this.forget(id2);
+  parts(path, follow2) {
+    const parts2 = path.split("/").filter((p) => p !== "").slice(1);
+    if (parts2[0] === "self" && (follow2 || parts2.length > 1)) parts2[0] = String(this.pid);
+    return parts2;
   }
-  forget(id2) {
-    this.running.delete(id2);
-    this.results.delete(id2);
-    const at = this.ready.indexOf(id2);
-    if (at >= 0) this.ready.splice(at, 1);
+  find(path, follow2) {
+    const node = this.node(this.parts(path, follow2));
+    if (!node) throw syncError("ENOENT", path);
+    return node;
   }
-  async wait(timeoutMs, blocking) {
-    let signal;
-    for (; ; ) {
-      if (this.closed) return -1;
-      const id2 = this.ready.shift();
-      if (id2 !== void 0) return id2;
-      if (timeoutMs !== void 0 && timeoutMs <= 0) return 0;
-      signal ??= blocking();
-      const woke = await this.sleep(timeoutMs, signal);
-      if (!woke) return 0;
+  stat(path, follow2 = true) {
+    const node = this.find(path, follow2);
+    const base = {
+      isFile: false,
+      isDirectory: false,
+      size: 0,
+      mtimeMs: Date.now(),
+      readonly: true
+    };
+    if (node.kind === "dir") return { ...base, isDirectory: true, mode: DIR_MODE };
+    if (node.kind === "link") {
+      return { ...base, isSymbolicLink: true, mode: LINK_MODE, size: node.target.length };
     }
+    return { ...base, isFile: true, mode: FILE_MODE, size: this.bytes(node).length };
   }
-  close() {
-    this.closed = true;
-    this.wake();
-  }
-  sleep(timeoutMs, signal) {
-    return new Promise((resolve2, reject) => {
-      let timer;
-      const cleanup = () => {
-        clearTimeout(timer);
-        this.waiters.delete(wake);
-        signal.removeEventListener("abort", abort);
-      };
-      const wake = () => {
-        cleanup();
-        resolve2(true);
-      };
-      const abort = () => {
-        cleanup();
-        reject(new KernelError("EINTR"));
-      };
-      this.waiters.add(wake);
-      signal.addEventListener("abort", abort, { once: true });
-      if (timeoutMs !== void 0) {
-        timer = setTimeout(() => {
-          cleanup();
-          resolve2(false);
-        }, timeoutMs);
-      }
-    });
-  }
-  complete(id2, result) {
-    this.running.delete(id2);
-    if (!this.results.has(id2)) return;
-    this.results.set(id2, result);
-    this.ready.push(id2);
-    this.wake();
-    this.onReady?.();
+  bytes(node) {
+    return new TextEncoder().encode(node.kind === "file" ? node.content() : "");
   }
-  wake() {
-    for (const wake of [...this.waiters]) wake();
+  read(path) {
+    const node = this.find(path, true);
+    if (node.kind !== "file") throw syncError("EISDIR", path);
+    return this.bytes(node);
   }
-};
-async function hostSyscall(req, ctx) {
-  switch (req.op) {
-    case "lock":
-      if (!ctx.locks) throw new KernelError("ENOSYS");
-      if (!ctx.locks.lock(ctx.pid, req.path, req.exclusive, req.fd))
-        throw new KernelError("EAGAIN");
-      return done2;
-    case "unlock":
-      ctx.locks?.unlock(ctx.pid, req.path);
-      return done2;
-    case "async-submit":
-      if (!ctx.valid(req.req)) throw new KernelError("EINVAL");
-      if (req.ack) ctx.ops.ack(req.ack);
-      return json3(ctx.ops.submit(req.req));
-    case "async-wait":
-      return json3(await ctx.ops.wait(req.timeoutMs, ctx.blocking));
-    case "async-take":
-      return ctx.ops.take(req.id);
-    case "async-resolve":
-      return json3(ctx.ops.resolve(req.value));
-    case "async-hold":
-      return json3(ctx.ops.hold());
-    case "async-cancel":
-      ctx.ops.cancel(req.id);
-      return done2;
-    case "async-settle":
-      return json3(await ctx.ops.settle(req.ids));
-    case "async-close":
-      ctx.ops.close();
-      return done2;
+  readdir(path) {
+    const node = this.find(path, true);
+    if (node.kind !== "dir") throw syncError("ENOTDIR", path);
+    return node.names();
   }
-}
-
-// src/kernel/net/proxy-service.ts
-var SEND_BUFFER2 = 1024 * 1024;
-var TLS_HANDSHAKE = 22;
-var TOKEN2 = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
-var NO_WEBSOCKET2 = "WebSocket not supported by this transport (fetchTransport needs { webSocket: true })";
-var REALM_PROXY_PORT = 3128;
-var DEFAULT_LIMITS = {
-  maxConnections: 64,
-  maxHead: 64 * 1024,
-  idleMs: 12e4,
-  bodyBudget: 128 * 1024 * 1024,
-  closeWaitMs: 5e3
-};
-var HOP_BY_HOP = /* @__PURE__ */ new Set([
-  "connection",
-  "keep-alive",
-  "proxy-connection",
-  "proxy-authenticate",
-  "proxy-authorization",
-  "te",
-  "trailer",
-  "transfer-encoding",
-  "upgrade"
-]);
-var REQUEST_OWN = /* @__PURE__ */ new Set(["host", "content-length", "expect"]);
-var Budget = class {
-  free;
-  waiters = [];
-  constructor(free) {
-    this.free = free;
+  readlink(path) {
+    const node = this.find(path, false);
+    if (node.kind !== "link") throw syncError("EINVAL", path);
+    return node.target;
   }
-  async acquire(n, signal) {
-    while (this.free < n) {
-      signal.throwIfAborted();
-      await new Promise((resolve2) => {
-        const done4 = () => {
-          signal.removeEventListener("abort", done4);
-          resolve2();
-        };
-        this.waiters.push(done4);
-        signal.addEventListener("abort", done4, { once: true });
-      });
+  exists(path) {
+    try {
+      this.find(path, true);
+      return true;
+    } catch {
+      return false;
     }
-    this.free -= n;
-  }
-  release(n) {
-    this.free += n;
-    const waiters = this.waiters;
-    this.waiters = [];
-    for (const wake of waiters) wake();
   }
 };
-function canonicalHost2(host) {
-  const bare = host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;
-  try {
-    return new URL(`http://${bare}/`).hostname;
-  } catch {
-    return void 0;
-  }
-}
-function localV4(a, b) {
-  return a === 127 || a === 0 || a === 169 && b === 254;
-}
-function hextets(address) {
-  const [head, tail, extra] = address.split("::");
-  if (extra !== void 0) return void 0;
-  const part = (text) => text ? text.split(":").map((h) => Number.parseInt(h, 16)) : [];
-  const front = part(head);
-  const back = part(tail);
-  const groups = tail === void 0 ? front : [...front, ...new Array(8 - front.length - back.length).fill(0), ...back];
-  return groups.length === 8 && groups.every((g) => g >= 0 && g <= 65535) ? groups : void 0;
-}
-function localV6(address) {
-  const g = hextets(address);
-  if (!g) return true;
-  if ((g[0] & 65472) === 65152) return true;
-  const zeroPrefix = g.slice(0, 5).every((x) => x === 0);
-  if (!zeroPrefix) return false;
-  if (g[5] === 65535 || g[5] === 0 && g[6] !== 0) return localV4(g[6] >> 8, g[6] & 255);
-  return g[5] === 0 && g[6] === 0;
-}
-function isLoopbackHost(hostname) {
-  const canonical = canonicalHost2(hostname);
-  if (canonical === void 0) return false;
-  const host = canonical.replace(/\.+$/, "");
-  if (host === "localhost" || host.endsWith(".localhost")) return true;
-  if (host.startsWith("[")) return localV6(host.slice(1, -1));
-  const v4 = /^(\d+)\.(\d+)\.\d+\.\d+$/.exec(host);
-  return v4 ? localV4(Number(v4[1]), Number(v4[2])) : false;
-}
-function dropped(headers) {
-  return /* @__PURE__ */ new Set([...HOP_BY_HOP, ...fieldTokens(headers, "connection")]);
+var MAX_HOPS3 = 40;
+function* procWalk(path, follow2) {
+  let done4 = [];
+  let todo = path.split("/").filter((part) => part !== "");
+  let hops = 0;
+  let broken;
+  while (todo.length > 0) {
+    const part = todo.shift();
+    if (part === ".") continue;
+    if (part === "..") {
+      done4.pop();
+      continue;
+    }
+    const at = `/${[...done4, part].join("/")}`;
+    const whole = normalize(`/${[...done4, part, ...todo].join("/")}`);
+    if (inProc(at) && inProc(whole)) return broken ?? whole;
+    if (!follow2 && todo.length === 0) return void 0;
+    const target = yield { at, check: todo.find((next2) => next2 !== ".") === ".." };
+    if (typeof target === "string") {
+      if (++hops > MAX_HOPS3) return void 0;
+      [done4, todo] = throughLink(target, done4, todo);
+    } else {
+      broken ??= refusalOf(target);
+      done4.push(part);
+    }
+  }
+  return void 0;
 }
-function forwardRequestHeaders(headers) {
-  const drop = dropped(headers);
-  return headers.filter(([name2]) => {
-    const lower = name2.toLowerCase();
-    return !drop.has(lower) && !REQUEST_OWN.has(lower);
-  });
+function failed(err) {
+  const code = err?.code;
+  return { refused: typeof code === "string" ? code : "ENOENT" };
 }
-function forwardResponseHeaders(headers, opts) {
-  const drop = dropped(headers);
-  if (!opts.encodedBodies) drop.add("content-encoding");
-  if (!(opts.encodedBodies && opts.bodiless)) drop.add("content-length");
-  return headers.filter(([name2]) => !drop.has(name2.toLowerCase()));
+function refusalOf(found) {
+  if (found === true) return void 0;
+  return found === false ? { refused: "ENOTDIR" } : found;
 }
-function keepsAlive(req) {
-  const tokens = fieldTokens(req.headers, "connection");
-  if (tokens.includes("close")) return false;
-  return req.minor >= 1 || tokens.includes("keep-alive");
+function throughLink(target, done4, todo) {
+  const parts2 = target.split("/").filter((part) => part !== "");
+  return [target.startsWith("/") ? [] : done4, [...parts2, ...todo]];
 }
-function tunnelRequestUrl(req, origin) {
-  const base = new URL(origin);
-  let url;
-  try {
-    url = new URL(req.target, req.target.startsWith("/") ? base : void 0);
-  } catch {
-    throw new HttpError(400, "malformed request target");
-  }
-  const hosts = fieldValues(req.headers, "host");
-  const hostOk = hosts.every(
-    (h) => URL.canParse(`https://${h}`) && new URL(`https://${h}`).host === base.host
+async function procAlias(fs, path, follow2) {
+  const { readlink, lstat } = fs;
+  if (!readlink || !lstat) return void 0;
+  const physical = await lstat.call(fs, "/proc").then(
+    () => true,
+    () => false
   );
-  if (url.origin !== base.origin || !hostOk) {
-    throw new HttpError(421, `this tunnel is for ${base.host}`);
+  if (!physical) return void 0;
+  const walk2 = procWalk(path, follow2);
+  let step = walk2.next();
+  while (!step.done) {
+    const { at, check } = step.value;
+    const link2 = await readlink.call(fs, at).catch(() => void 0);
+    const isDir = (st) => st.isDirectory === true;
+    const target = link2 ?? (check ? await lstat.call(fs, at).then(isDir, failed) : true);
+    step = walk2.next(target);
   }
-  return url.href;
+  return step.value;
 }
-function requestUrl(req) {
-  if (req.target.startsWith("/")) {
-    throw new HttpError(400, "this is a proxy: send the absolute URL (GET http://host/path)");
+
+// src/kernel/host-ops.ts
+var HOST_OPS = [
+  "lock",
+  "unlock",
+  "async-submit",
+  "async-wait",
+  "async-take",
+  "async-resolve",
+  "async-hold",
+  "async-cancel",
+  "async-settle",
+  "async-close"
+];
+var json3 = (value) => ({ ok: true, kind: "json", json: value });
+var done2 = { ok: true, kind: "void" };
+var LockTable = class {
+  held = /* @__PURE__ */ new Map();
+  lock(pid, path, exclusive, fd) {
+    const holders = this.held.get(path) ?? /* @__PURE__ */ new Map();
+    for (const [other, h] of holders) if (other !== pid && (exclusive || h.exclusive)) return false;
+    const mine = holders.get(pid) ?? { exclusive, fds: /* @__PURE__ */ new Set() };
+    mine.exclusive = exclusive;
+    mine.fds.add(fd);
+    holders.set(pid, mine);
+    this.held.set(path, holders);
+    return true;
   }
-  let url;
-  try {
-    url = new URL(req.target);
-  } catch {
-    throw new HttpError(400, "malformed request target");
+  unlock(pid, path) {
+    const holders = this.held.get(path);
+    holders?.delete(pid);
+    if (holders?.size === 0) this.held.delete(path);
   }
-  if (url.protocol !== "http:" && url.protocol !== "https:") {
-    throw new HttpError(400, `unsupported scheme ${url.protocol}`);
+  closed(pid, fd) {
+    for (const [path, holders] of [...this.held]) {
+      const mine = holders.get(pid);
+      if (mine?.fds.delete(fd) && mine.fds.size === 0) this.unlock(pid, path);
+    }
   }
-  if (isLoopbackHost(url.hostname)) {
-    throw new HttpError(
-      403,
-      `${url.hostname} is the realm's own loopback, which the proxy does not reach: list it in no_proxy`
-    );
+  release(pid) {
+    for (const path of [...this.held.keys()]) this.unlock(pid, path);
   }
-  return url.href;
-}
-function tunnelTarget(req) {
-  const match = /^([A-Za-z0-9.-]+|\[[0-9A-Fa-f:.]+\]):(\d{1,5})$/.exec(req.target);
-  const port = Number(match?.[2]);
-  if (!match || port < 1 || port > 65535) {
-    throw new HttpError(400, "CONNECT needs host:port");
+};
+var KEPT_OPS = /* @__PURE__ */ new Set(["fd-write"]);
+var unknownSettled = false;
+var AsyncOps = class {
+  next = 1;
+  results = /* @__PURE__ */ new Map();
+  ready = [];
+  running = /* @__PURE__ */ new Map();
+  waiters = /* @__PURE__ */ new Set();
+  taken = /* @__PURE__ */ new Map();
+  kept = /* @__PURE__ */ new Set();
+  closed = false;
+  run;
+  onReady;
+  constructor(run2, onReady) {
+    this.run = run2;
+    this.onReady = onReady;
   }
-  const host = canonicalHost2(match[1]);
-  if (host === void 0) throw new HttpError(400, "CONNECT needs host:port");
-  if (isLoopbackHost(host)) {
-    throw new HttpError(
-      403,
-      `${host} is the realm's own loopback, which the proxy does not reach: list it in no_proxy`
+  submit(req) {
+    const id2 = this.hold();
+    if (KEPT_OPS.has(req.op)) this.kept.add(id2);
+    const running = new AbortController();
+    this.running.set(id2, running);
+    this.run(req, running.signal).then(
+      (result) => this.complete(id2, result),
+      (err) => this.complete(id2, { ok: false, errno: "EIO", message: String(err) })
     );
+    return id2;
   }
-  return { host, port };
-}
-async function watchHangup(conn, abort, until) {
-  while (!until.aborted && !abort.signal.aborted) {
-    if (conn.poll().hangup) {
-      abort.abort(new KernelError("EPIPE"));
-      return;
-    }
-    try {
-      await conn.changed(until);
-    } catch {
-      return;
-    }
+  resolve(value) {
+    const id2 = this.hold();
+    this.complete(id2, json3(value));
+    return id2;
   }
-}
-function untilAborted(response, signal) {
-  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(resolve2, reject).finally(() => signal.removeEventListener("abort", onAbort));
-  });
-}
-function plainResponse(status, message3) {
-  const body = latin1Bytes(`slicc realm proxy: ${message3}
-`);
-  return {
-    status,
-    statusText: REASON[status] ?? "",
-    headers: [["Content-Type", "text/plain; charset=utf-8"]],
-    body: (async function* () {
-      yield body;
-    })(),
-    cancel: async () => void 0
-  };
-}
-function timedSource(conn, idle, stop) {
-  return {
-    read: (max, signal) => {
-      const own = signal ? [stop, signal] : [stop];
-      if (Number.isFinite(idle.ms)) own.push(AbortSignal.timeout(idle.ms));
-      return conn.read(max, AbortSignal.any(own));
-    }
-  };
-}
-function webSocketTarget(req) {
-  return { ...req, target: req.target.replace(/^ws(s?):/i, (_, s) => `http${s.toLowerCase()}:`) };
-}
-function wireCode(code) {
-  if (code === 1005) return 1e3;
-  return sendableCode(code) ? code : 1011;
-}
-function quietly(ms) {
-  return new Promise((resolve2) => {
-    AbortSignal.timeout(ms).addEventListener("abort", () => resolve2(), { once: true });
-  });
-}
-var RealmProxy = class {
-  options;
-  listener;
-  stop = new AbortController();
-  limits;
-  slots;
-  bodies;
-  connections = /* @__PURE__ */ new Set();
-  warnedWebSocket = false;
-  closed;
-  port;
-  constructor(options) {
-    this.options = options;
-    this.limits = { ...DEFAULT_LIMITS, ...options.limits };
-    this.slots = new Budget(this.limits.maxConnections);
-    this.bodies = new Budget(this.limits.bodyBudget);
-    this.listener = options.net.listen({
-      family: "inet",
-      host: options.host ?? "127.0.0.1",
-      port: options.port ?? REALM_PROXY_PORT
-    });
-    this.port = this.listener.local?.family === "inet" ? this.listener.local.port : 0;
-    this.closed = this.acceptLoop();
+  hold() {
+    const id2 = this.next++;
+    this.results.set(id2, void 0);
+    return id2;
   }
-  get stopped() {
-    return this.stop.signal.aborted;
+  take(id2) {
+    if (!this.results.has(id2)) throw new KernelError("EINVAL");
+    const result = this.results.get(id2);
+    if (!result) throw new KernelError("EAGAIN");
+    this.forget(id2);
+    if (this.kept.delete(id2)) this.taken.set(id2, result);
+    return result;
   }
-  close() {
-    if (this.stop.signal.aborted) return;
-    this.stop.abort();
-    this.listener.close();
-    for (const conn of this.connections) conn.close();
+  ack(ids) {
+    for (const id2 of ids) this.taken.delete(id2);
   }
-  async acceptLoop() {
-    const served = /* @__PURE__ */ new Set();
-    try {
-      for (; ; ) {
-        await this.slots.acquire(1, this.stop.signal);
-        let conn;
-        try {
-          conn = await this.listener.accept(this.stop.signal);
-        } catch {
-          this.slots.release(1);
-          break;
-        }
-        const done4 = this.serve(conn).finally(() => {
-          this.slots.release(1);
-          served.delete(done4);
-        });
-        served.add(done4);
+  async settle(ids) {
+    const never = new AbortController().signal;
+    while (ids.some((id2) => this.running.has(id2))) await this.sleep(void 0, never);
+    return ids.map((id2) => {
+      const result = this.results.get(id2) ?? this.taken.get(id2) ?? null;
+      if (!result && !unknownSettled) {
+        unknownSettled = true;
+        console.warn(`async-settle: no result for op ${id2}; its write counts as made`);
       }
-    } catch {
-    }
-    await Promise.allSettled([...served]);
+      return result;
+    });
   }
-  async serve(conn) {
-    this.connections.add(conn);
-    const idle = { ms: this.limits.idleMs };
-    const incoming = new Incoming(timedSource(conn, idle, this.stop.signal));
-    try {
-      await this.requests({ sink: conn, incoming, conn, socket: conn, idle });
-    } finally {
-      this.connections.delete(conn);
-      conn.close();
-    }
+  cancel(id2) {
+    this.kept.delete(id2);
+    this.running.get(id2)?.abort();
+    this.forget(id2);
   }
-  async requests(ctx) {
-    try {
-      for (; ; ) {
-        const head = await ctx.incoming.head(this.limits.maxHead);
-        if (!head || !await this.exchange(ctx, head)) break;
-      }
-    } catch (e) {
-      if (e instanceof HttpError) await this.refuse(ctx.sink, e);
-    }
+  forget(id2) {
+    this.running.delete(id2);
+    this.results.delete(id2);
+    const at = this.ready.indexOf(id2);
+    if (at >= 0) this.ready.splice(at, 1);
   }
-  async refuse(sink, error) {
-    try {
-      await this.relay(sink, "GET", 1, plainResponse(error.status, error.message), false);
-    } catch {
+  async wait(timeoutMs, blocking) {
+    let signal;
+    for (; ; ) {
+      if (this.closed) return -1;
+      const id2 = this.ready.shift();
+      if (id2 !== void 0) return id2;
+      if (timeoutMs !== void 0 && timeoutMs <= 0) return 0;
+      signal ??= blocking();
+      const woke = await this.sleep(timeoutMs, signal);
+      if (!woke) return 0;
     }
   }
-  async exchange(ctx, head) {
-    const { sink: conn, incoming } = ctx;
-    const req = parseRequestHead(head);
-    if (req.method === "CONNECT") {
-      if (!ctx.conn) throw new HttpError(400, "CONNECT inside a tunnel");
-      await this.connect(ctx.conn, incoming, req, ctx.idle);
-      return false;
-    }
-    if (req.method === "GET" && isUpgrade(req.headers)) {
-      await this.websocket(ctx, req);
-      return false;
-    }
-    const url = ctx.origin ? tunnelRequestUrl(req, ctx.origin) : requestUrl(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`);
-    await this.expectContinue(conn, req, framing.kind !== "none");
-    await this.bodies.acquire(reserve, this.stop.signal);
-    let response;
-    const abort = new AbortController();
-    const stopExchange = () => abort.abort();
-    this.stop.signal.addEventListener("abort", stopExchange, { once: true });
-    try {
-      try {
-        const body = await readBody(incoming, framing, this.cap());
-        const waiting = new AbortController();
-        void watchHangup(ctx.socket, abort, waiting.signal);
-        try {
-          response = await this.upstream(req, url, body, abort.signal, ctx.socket.peerCred?.pid);
-        } finally {
-          waiting.abort();
-        }
-      } finally {
-        this.bodies.release(reserve);
+  close() {
+    this.closed = true;
+    this.wake();
+  }
+  sleep(timeoutMs, signal) {
+    return new Promise((resolve2, reject) => {
+      let timer;
+      const cleanup = () => {
+        clearTimeout(timer);
+        this.waiters.delete(wake);
+        signal.removeEventListener("abort", abort);
+      };
+      const wake = () => {
+        cleanup();
+        resolve2(true);
+      };
+      const abort = () => {
+        cleanup();
+        reject(new KernelError("EINTR"));
+      };
+      this.waiters.add(wake);
+      signal.addEventListener("abort", abort, { once: true });
+      if (timeoutMs !== void 0) {
+        timer = setTimeout(() => {
+          cleanup();
+          resolve2(false);
+        }, timeoutMs);
       }
-      return await this.relay(conn, req.method, req.minor, response, keep2);
-    } finally {
-      this.stop.signal.removeEventListener("abort", stopExchange);
-      abort.abort();
-    }
+    });
   }
-  cap() {
-    return Math.min(this.options.transport.traits.maxRequestBody, this.limits.bodyBudget);
+  complete(id2, result) {
+    this.running.delete(id2);
+    if (!this.results.has(id2)) return;
+    this.results.set(id2, result);
+    this.ready.push(id2);
+    this.wake();
+    this.onReady?.();
   }
-  async expectContinue(conn, req, hasBody) {
-    const expect = fieldTokens(req.headers, "expect");
-    if (expect.length === 0) return;
-    if (expect.length !== 1 || expect[0] !== "100-continue") {
-      throw new HttpError(417, `unsupported expectation: ${expect.join(", ")}`);
-    }
-    if (hasBody && req.minor >= 1) {
-      await conn.write(latin1Bytes("HTTP/1.1 100 Continue\r\n\r\n"), this.stop.signal);
-    }
+  wake() {
+    for (const wake of [...this.waiters]) wake();
   }
-  async upstream(req, url, body, signal, owner) {
-    try {
-      const fetching = this.options.transport.fetch(
-        {
-          url: toHostLoopback(url),
-          method: req.method.toUpperCase(),
-          headers: forwardRequestHeaders(req.headers),
-          body: req.method === "GET" || req.method === "HEAD" ? void 0 : body,
-          signal
-        },
-        owner
-      );
-      return await untilAborted(fetching, signal);
-    } catch (e) {
-      if (signal.aborted) throw e;
-      const message3 = e instanceof Error ? e.message : String(e);
-      const status = e?.status;
-      const own = typeof status === "number" && status >= 400 && status <= 599 ? status : 502;
-      return plainResponse(own, message3 || "upstream request failed");
-    }
+};
+async function hostSyscall(req, ctx) {
+  switch (req.op) {
+    case "lock":
+      if (!ctx.locks) throw new KernelError("ENOSYS");
+      if (!ctx.locks.lock(ctx.pid, req.path, req.exclusive, req.fd))
+        throw new KernelError("EAGAIN");
+      return done2;
+    case "unlock":
+      ctx.locks?.unlock(ctx.pid, req.path);
+      return done2;
+    case "async-submit":
+      if (!ctx.valid(req.req)) throw new KernelError("EINVAL");
+      if (req.ack) ctx.ops.ack(req.ack);
+      return json3(ctx.ops.submit(req.req));
+    case "async-wait":
+      return json3(await ctx.ops.wait(req.timeoutMs, ctx.blocking));
+    case "async-take":
+      return ctx.ops.take(req.id);
+    case "async-resolve":
+      return json3(ctx.ops.resolve(req.value));
+    case "async-hold":
+      return json3(ctx.ops.hold());
+    case "async-cancel":
+      ctx.ops.cancel(req.id);
+      return done2;
+    case "async-settle":
+      return json3(await ctx.ops.settle(req.ids));
+    case "async-close":
+      ctx.ops.close();
+      return done2;
   }
-  async relay(conn, method, minor, response, keepAlive) {
-    const status = response.status;
-    const bodiless2 = method === "HEAD" || status === 204 || status === 304 || status < 200;
-    const headers = forwardResponseHeaders(response.headers, {
-      encodedBodies: this.options.transport.traits.encodedBodies,
-      bodiless: bodiless2
-    });
-    const chunked2 = !bodiless2 && minor >= 1;
-    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(
-      responseHead(status, response.statusText || REASON[status] || "", headers),
-      signal
-    );
-    if (bodiless2) {
-      await response.cancel();
-      return keep2;
-    }
+}
+
+// src/kernel/net/loopback-transport.ts
+var LOOPBACK_TRAITS = {
+  manualRedirects: true,
+  encodedBodies: true,
+  maxRequestBody: 64 * 1024 * 1024,
+  crossOrigin: "any",
+  websocket: true
+};
+var MAX_HEAD2 = 64 * 1024;
+var OWN_HEADERS = /* @__PURE__ */ new Set([
+  "host",
+  "connection",
+  "content-length",
+  "transfer-encoding",
+  "upgrade",
+  "sec-websocket-key",
+  "sec-websocket-version",
+  "sec-websocket-protocol",
+  "sec-websocket-extensions"
+]);
+var OP_CLOSE = 8;
+var OP_PONG = 10;
+var TOKEN3 = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+var SAFE_VALUE = /^[^\r\n\0]*$/;
+var CLOSE_WAIT_MS3 = 5e3;
+var MAX_UNREAD = 16 * 1024 * 1024;
+function errno(code, message3) {
+  return Object.assign(new Error(`${code}: ${message3}`), { code });
+}
+function requestHead(method, url, headers, extra) {
+  if (!TOKEN3.test(method)) throw errno("EINVAL", `method ${method}`);
+  const lines2 = [`${method} ${url.pathname}${url.search} HTTP/1.1`, `Host: ${url.host}`];
+  for (const [name2, value] of headers) {
+    if (OWN_HEADERS.has(name2.toLowerCase())) continue;
+    if (!TOKEN3.test(name2) || !SAFE_VALUE.test(value)) throw errno("EINVAL", `header ${name2}`);
+    lines2.push(`${name2}: ${value}`);
+  }
+  for (const [name2, value] of extra) lines2.push(`${name2}: ${value}`);
+  return latin1Bytes(`${lines2.join("\r\n")}\r
+\r
+`);
+}
+function parseHead(bytes) {
+  const [statusLine = "", ...lines2] = latin1(bytes).split(/\r?\n/);
+  const match = /^HTTP\/1\.[01] (\d{3})(?: (.*))?$/.exec(statusLine);
+  if (!match) throw errno("EPROTO", `not an HTTP/1.x response: ${statusLine.slice(0, 80)}`);
+  const headers = [];
+  for (const line of lines2) {
+    const colon = line.indexOf(":");
+    if (colon > 0) headers.push([line.slice(0, colon).trim(), line.slice(colon + 1).trim()]);
+  }
+  return { status: Number(match[1]), statusText: match[2] ?? "", headers };
+}
+async function readHead(incoming, signal) {
+  for (; ; ) {
+    let raw;
     try {
-      for await (const piece of response.body) {
-        if (piece.length > 0) await conn.write(chunked2 ? chunk(piece) : piece, signal);
-      }
-    } catch {
-      await response.cancel().catch(() => void 0);
-      return false;
+      raw = await incoming.head(MAX_HEAD2, signal);
+    } catch (err) {
+      if (err instanceof KernelError) throw err;
+      throw errno("EPROTO", "the response head is malformed or too large");
     }
-    if (chunked2) await conn.write(LAST_CHUNK, signal);
-    return keep2;
+    if (!raw) throw errno("ECONNRESET", "the connection closed before a response");
+    const head = parseHead(raw);
+    if (head.status < 100 || head.status >= 200 || head.status === 101) return head;
   }
-  async connect(conn, incoming, req, idle) {
-    const target = tunnelTarget(req);
-    const refused2 = target.port === 443 ? await this.tunnelReady(target) : void 0;
-    if (refused2) throw refused2;
-    await conn.write(latin1Bytes("HTTP/1.1 200 Connection Established\r\n\r\n"), this.stop.signal);
-    try {
-      const first = await incoming.peek(this.stop.signal);
-      if (first === void 0) return;
-      if (first !== TLS_HANDSHAKE) {
-        const origin = `http://${target.port === 80 ? target.host : `${target.host}:${target.port}`}`;
-        await this.requests({ sink: conn, incoming, origin, socket: conn, idle });
-        return;
-      }
-      const tunnel = this.options.tunnel;
-      if (!tunnel || target.port !== 443 && await this.tunnelReady(target)) return;
-      await tunnel(
-        conn,
-        incoming,
-        target,
-        this.stop.signal,
-        (source, sink, origin) => this.requests({ sink, incoming: new Incoming(source), origin, socket: conn, idle })
-      );
-    } catch {
+}
+async function* chunked(incoming, signal) {
+  for (; ; ) {
+    const line = await incoming.line(4096, signal);
+    const size = /^([0-9A-Fa-f]{1,12})[ \t]*(;.*)?$/.exec(line);
+    if (!size) throw errno("EPROTO", "a malformed chunk size");
+    const n = Number.parseInt(size[1], 16);
+    if (n === 0) {
+      while (await incoming.line(MAX_HEAD2, signal) !== "") ;
+      return;
     }
+    yield await incoming.exactly(n, signal);
+    if (await incoming.line(2, signal) !== "") throw errno("EPROTO", "a malformed chunk");
   }
-  async tunnelReady(target) {
-    const name2 = `CONNECT ${target.host}:${target.port}`;
-    if (!this.options.tunnel) return new HttpError(501, `${name2}: no tunnels through this proxy`);
+}
+async function* counted(incoming, length2, signal) {
+  for (let left = length2; left > 0; ) {
+    const data = await incoming.some(Math.min(left, 64 * 1024), signal);
+    if (data.length === 0) throw errno("EPROTO", "the body ended early");
+    left -= data.length;
+    yield data;
+  }
+}
+async function* untilClose(incoming, signal) {
+  for (; ; ) {
+    const data = await incoming.some(64 * 1024, signal);
+    if (data.length === 0) return;
+    yield data;
+  }
+}
+function bodyOf(incoming, head, method, signal) {
+  if (method === "HEAD" || head.status === 204 || head.status === 304) return [];
+  if (fieldTokens(head.headers, "transfer-encoding").includes("chunked")) {
+    return chunked(incoming, signal);
+  }
+  const lengths = fieldValues(head.headers, "content-length");
+  if (lengths.length === 0) return untilClose(incoming, signal);
+  const length2 = lengths[0]?.trim() ?? "";
+  if (!/^\d{1,15}$/.test(length2) || lengths.some((l) => l.trim() !== length2)) {
+    throw errno("EPROTO", `a malformed Content-Length: ${lengths.join(", ")}`);
+  }
+  return counted(incoming, Number(length2), signal);
+}
+var KernelLoopback = class {
+  net;
+  cred;
+  constructor(net, cred) {
+    this.net = net;
+    this.cred = cred;
+  }
+  port(url) {
+    return kernelLoopbackPort(url);
+  }
+  connect(url, port, signal) {
+    if (url.protocol === "https:" || url.protocol === "wss:") {
+      throw errno("ENOTSUP", `TLS to the kernel's loopback is not supported: ${url.origin}`);
+    }
+    signal.throwIfAborted();
+    const socket = this.net.socket("inet");
     try {
-      await this.options.tunnelReady?.();
-      return void 0;
-    } catch (e) {
-      return new HttpError(501, `${name2}: ${e instanceof Error ? e.message : String(e)}`);
+      void socket.connect({ family: "inet", host: "127.0.0.1", port }, false, this.cred());
+    } catch (err) {
+      socket.close();
+      const refused2 = err instanceof KernelError && err.code === "ECONNREFUSED";
+      throw refused2 ? errno("ECONNREFUSED", `nothing listens on the kernel's port ${port}`) : err;
     }
+    signal.addEventListener("abort", () => socket.close(), { once: true });
+    return socket;
   }
-  async websocket(ctx, req) {
-    const href = ctx.origin ? tunnelRequestUrl(req, ctx.origin) : requestUrl(webSocketTarget(req));
-    const { transport } = this.options;
-    if (!transport.traits.websocket || !transport.websocket) {
-      if (!this.warnedWebSocket) {
-        this.warnedWebSocket = true;
-        console.warn(`slicc-kernel: a program asked for a WebSocket: ${NO_WEBSOCKET2}`);
-      }
-      throw new HttpError(501, NO_WEBSOCKET2);
-    }
-    const accept2 = await acceptKey(req.headers);
-    const protocols = fieldValues(req.headers, "sec-websocket-protocol").flatMap((v) => v.split(",")).map((t) => t.trim()).filter((t) => t !== "");
-    const hangup = new AbortController();
-    const waiting = new AbortController();
-    void watchHangup(ctx.socket, hangup, waiting.signal);
-    let socket;
+  async fetch(req, port) {
+    const url = new URL(req.url);
+    const body = req.body ?? (/^(POST|PUT|PATCH)$/i.test(req.method) ? new Uint8Array(0) : void 0);
+    const length2 = body ? [["Content-Length", String(body.length)]] : [];
+    const head = requestHead(req.method, url, req.headers, [...length2, ["Connection", "close"]]);
+    const socket = this.connect(url, port, req.signal);
     try {
-      socket = await transport.websocket({
-        url: toHostLoopback(href).replace(/^http/, "ws"),
-        protocols,
-        headers: forwardRequestHeaders(req.headers),
-        signal: AbortSignal.any([this.stop.signal, hangup.signal])
-      });
-    } catch (e) {
-      waiting.abort();
-      throw new HttpError(502, e instanceof Error ? e.message : String(e));
+      await writeAll2(socket, body ? concat([head, body]) : head, req.signal);
+      const incoming = new Incoming(socket);
+      const response = await readHead(incoming, req.signal);
+      const chunks2 = bodyOf(incoming, response, req.method, req.signal);
+      return {
+        url: req.url,
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+        body: closing(chunks2, socket),
+        cancel: async () => socket.close()
+      };
+    } catch (err) {
+      socket.close();
+      throw err;
     }
-    ctx.idle.ms = Number.POSITIVE_INFINITY;
+  }
+  async websocket(req, port) {
+    const url = new URL(req.url);
+    const socket = this.connect(url, port, req.signal);
     try {
-      if (hangup.signal.aborted) throw hangup.signal.reason;
-      if (socket.protocol && !(protocols.includes(socket.protocol) && TOKEN2.test(socket.protocol))) {
-        throw new HttpError(502, "the far end chose a subprotocol the client did not offer");
+      const key = btoa(String.fromCharCode(...crypto.getRandomValues(new Uint8Array(16))));
+      const extra = [
+        ["Upgrade", "websocket"],
+        ["Connection", "Upgrade"],
+        ["Sec-WebSocket-Key", key],
+        ["Sec-WebSocket-Version", "13"]
+      ];
+      if (req.protocols.length > 0)
+        extra.push(["Sec-WebSocket-Protocol", req.protocols.join(", ")]);
+      await writeAll2(socket, requestHead("GET", url, req.headers, extra), req.signal);
+      const incoming = new Incoming(socket);
+      const head = await readHead(incoming, req.signal);
+      if (head.status !== 101) {
+        throw errno(
+          "EPROTO",
+          `the server answered ${head.status} ${head.statusText}, not an upgrade`
+        );
       }
-      await ctx.sink.write(switchingHead(accept2, socket.protocol), this.stop.signal);
-      await this.bridge(ctx, socket, hangup.signal);
-    } catch (e) {
-      socket.close(1001, "the client went away");
-      throw e;
-    } finally {
-      waiting.abort();
+      const upgraded = fieldTokens(head.headers, "upgrade").includes("websocket") && fieldTokens(head.headers, "connection").includes("upgrade");
+      const accept2 = fieldValues(head.headers, "sec-websocket-accept")[0];
+      if (!upgraded || accept2 !== await acceptFor(key)) {
+        throw errno("EPROTO", "the server did not accept the WebSocket key");
+      }
+      const protocol = fieldValues(head.headers, "sec-websocket-protocol")[0] ?? "";
+      return new LoopbackWebSocket(socket, incoming, protocol);
+    } catch (err) {
+      socket.close();
+      throw err;
     }
   }
-  async bridge(ctx, socket, hangup) {
-    const stop = this.stop.signal;
-    let chain2 = Promise.resolve();
-    const toGuest = (bytes) => {
-      chain2 = chain2.then(() => ctx.sink.write(bytes, stop));
-      return chain2;
+};
+async function writeAll2(socket, bytes, signal) {
+  for (let at = 0; at < bytes.length; ) at += await socket.write(bytes.subarray(at), signal);
+}
+async function* closing(chunks2, socket) {
+  try {
+    yield* chunks2;
+  } catch (err) {
+    if (typeof err?.code === "string") throw err;
+    throw errno("EPROTO", err instanceof Error ? err.message : String(err));
+  } finally {
+    socket.close();
+  }
+}
+var LoopbackWebSocket = class {
+  protocol;
+  messages;
+  closed;
+  pending = 0;
+  writes = Promise.resolve();
+  sentClose = false;
+  stop = new AbortController();
+  socket;
+  settle;
+  unread = 0;
+  room;
+  constructor(socket, incoming, protocol) {
+    this.socket = socket;
+    this.protocol = protocol;
+    this.closed = new Promise((resolve2) => {
+      this.settle = resolve2;
+    });
+    this.stop.signal.addEventListener("abort", () => this.room?.(), { once: true });
+    const queue = [];
+    let wake;
+    let ended = false;
+    void this.pump(new WsReader(incoming, void 0, true, true), (message3) => {
+      queue.push(message3);
+      this.unread += message3.length;
+      wake?.();
+    }).finally(() => {
+      ended = true;
+      wake?.();
+    });
+    const taken = (message3) => {
+      this.unread -= message3.length;
+      const room = this.room;
+      this.room = void 0;
+      room?.();
     };
-    const done4 = new AbortController();
-    const reading = AbortSignal.any([stop, done4.signal, hangup]);
-    const stopping = () => socket.close(1001, "the proxy is stopping");
-    stop.addEventListener("abort", stopping, { once: true });
-    let guestDone = false;
-    let closeSent = false;
-    const outbound2 = (async () => {
-      for await (const data of socket.messages) {
-        if (guestDone) continue;
-        const text = typeof data === "string";
-        await toGuest(
-          frame(text ? OP_TEXT : OP_BINARY, text ? new TextEncoder().encode(data) : data)
-        );
+    this.messages = {
+      [Symbol.asyncIterator]: async function* () {
+        for (; ; ) {
+          const next2 = queue.shift();
+          if (next2 !== void 0) {
+            taken(next2);
+            yield next2;
+            continue;
+          }
+          if (ended) return;
+          await new Promise((resolve2) => {
+            wake = resolve2;
+          });
+          wake = void 0;
+        }
       }
-      const closed = await socket.closed;
-      if (guestDone) return;
-      closeSent = true;
-      await toGuest(closeFrame(wireCode(closed.code), closed.reason));
-      AbortSignal.timeout(this.limits.closeWaitMs).addEventListener("abort", () => done4.abort(), {
-        once: true
+    };
+  }
+  async space() {
+    while (this.unread > MAX_UNREAD && !this.stop.signal.aborted) {
+      await new Promise((resolve2) => {
+        this.room = resolve2;
       });
-    })().catch(() => done4.abort());
-    const reader = new WsReader(ctx.incoming, MESSAGE_LIMIT, true);
+    }
+  }
+  get buffered() {
+    return this.pending;
+  }
+  write(bytes) {
+    this.pending += bytes.length;
+    const previous = this.writes;
+    this.writes = (async () => {
+      await previous;
+      try {
+        await writeAll2(this.socket, bytes, this.stop.signal);
+      } catch {
+        this.stop.abort();
+      }
+      this.pending -= bytes.length;
+    })();
+  }
+  async pump(reader, deliver) {
+    let close = { code: 1006, reason: "" };
     try {
       for (; ; ) {
-        const event = await reader.next(reading);
+        await this.space();
+        const event = await reader.next(this.stop.signal);
         if (!event) break;
-        if (event.kind === "ping") {
-          await toGuest(pongFrame(event.payload));
-          continue;
-        }
-        if (event.kind === "close") {
-          guestDone = true;
-          if (closeSent) break;
-          const code = wireCode(event.code);
-          socket.close(code, event.reason);
-          const reply = await Promise.race([
-            socket.closed,
-            quietly(this.limits.closeWaitMs).then(() => ({ code, reason: event.reason }))
-          ]);
-          await toGuest(closeFrame(wireCode(reply.code), reply.reason));
+        if (event.kind === "text") deliver(event.text);
+        else if (event.kind === "binary") deliver(event.bytes);
+        else if (event.kind === "ping") this.write(clientFrame(OP_PONG, event.payload));
+        else {
+          close = { code: event.code, reason: event.reason };
+          if (!this.sentClose) this.sendClose(event.code === 1005 ? 1e3 : event.code, "");
           break;
         }
-        while (socket.buffered > SEND_BUFFER2 && !reading.aborted) await quietly(10);
-        socket.send(event.kind === "text" ? event.text : event.bytes);
-      }
-    } catch (e) {
-      if (e instanceof WsError) {
-        guestDone = true;
-        socket.close(e.code, e.message);
-        await toGuest(closeFrame(e.code, e.message)).catch(() => void 0);
       }
+    } catch (err) {
+      if (err instanceof WsError) this.sendClose(err.code, err.message);
+      close = { code: err instanceof WsError ? err.code : 1006, reason: "" };
     } finally {
-      guestDone = true;
-      socket.close(1e3, "the client went away");
-      stop.removeEventListener("abort", stopping);
-      await Promise.race([outbound2, quietly(this.limits.closeWaitMs)]);
-    }
+      const late = setTimeout(() => this.stop.abort(), CLOSE_WAIT_MS3);
+      await this.writes;
+      clearTimeout(late);
+      this.socket.close();
+      this.settle(close);
+    }
+  }
+  sendClose(code, reason) {
+    if (this.sentClose) return;
+    this.sentClose = true;
+    const late = setTimeout(() => this.stop.abort(), CLOSE_WAIT_MS3);
+    void this.closed.then(() => clearTimeout(late));
+    const bytes = new TextEncoder().encode(reason).subarray(0, 123);
+    const payload = new Uint8Array(2 + bytes.length);
+    new DataView(payload.buffer).setUint16(0, sendableCode(code) ? code : CLOSE.error);
+    payload.set(bytes, 2);
+    this.write(clientFrame(OP_CLOSE, payload));
+  }
+  send(data) {
+    if (this.sentClose) throw errno("EPIPE", "the websocket is closing");
+    const text = typeof data === "string";
+    const payload = text ? new TextEncoder().encode(data) : data;
+    this.write(clientFrame(text ? OP_TEXT : OP_BINARY, payload));
+  }
+  close(code = 1e3, reason = "") {
+    this.sendClose(code, reason);
   }
 };
 
@@ -10990,7 +11658,7 @@ var WS_OPS = [
   "net-ws-send",
   "net-ws-close"
 ];
-var TOKEN3 = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+var TOKEN4 = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
 function message(e) {
   return e instanceof Error ? e.message : String(e);
 }
@@ -10999,16 +11667,18 @@ function errnoOf(e) {
   const code = e?.code;
   return typeof code === "string" && ERRNO.test(code) ? code : "ECONNREFUSED";
 }
-function fail(errno, text) {
-  return { ok: false, errno, message: text };
+function fail(errno2, text) {
+  return { ok: false, errno: errno2, message: text };
 }
 var WsHandles = class {
   transport;
   open = /* @__PURE__ */ new Map();
   next;
-  constructor(transport, next2) {
+  local;
+  constructor(transport, next2, local) {
     this.transport = transport;
     this.next = next2;
+    this.local = local;
   }
   owns(handle) {
     return this.open.has(handle);
@@ -11037,16 +11707,18 @@ var WsHandles = class {
     return { ok: true, kind: "json", json: handle };
   }
   async connect(handle, req, entry) {
-    const { transport } = this;
-    if (!transport.traits.websocket || !transport.websocket) return fail("ENOTSUP", NO_WEBSOCKET2);
+    const { transport, local } = this;
+    const port = local?.port(req.url);
+    const open = { protocols: req.protocols, headers: req.headers, signal: entry.abort.signal };
+    if (port === void 0 && (!transport.traits.websocket || !transport.websocket)) {
+      return fail("ENOTSUP", NO_WEBSOCKET2);
+    }
     let socket;
     try {
-      socket = await transport.websocket({
+      socket = port === void 0 ? await transport.websocket({
         url: toHostLoopback(req.url),
-        protocols: req.protocols,
-        headers: req.headers,
-        signal: entry.abort.signal
-      });
+        ...open
+      }) : await local.websocket({ url: req.url, ...open }, port);
     } catch (e) {
       return fail(errnoOf(e), message(e));
     }
@@ -11054,7 +11726,7 @@ var WsHandles = class {
       socket.close(1001, "the program went away");
       return fail("EBADF", `no websocket ${handle}`);
     }
-    if (socket.protocol && !(req.protocols.includes(socket.protocol) && TOKEN3.test(socket.protocol))) {
+    if (socket.protocol && !(req.protocols.includes(socket.protocol) && TOKEN4.test(socket.protocol))) {
       socket.close(1002, "subprotocol not offered");
       return fail("EPROTO", "the far end chose a subprotocol the program did not offer");
     }
@@ -11117,6 +11789,10 @@ var EMPTY = new Uint8Array(0);
 function message2(e) {
   return e instanceof Error ? e.message : String(e);
 }
+function codeOf2(e) {
+  const code = e?.code;
+  return typeof code === "string" && /^E[A-Z]+$/.test(code) ? code : "EIO";
+}
 async function* once(bytes) {
   yield bytes;
 }
@@ -11126,10 +11802,12 @@ var HttpHandles = class {
   nextHandle = 0;
   ws;
   owner;
-  constructor(transport, owner) {
+  local;
+  constructor(transport, owner, local) {
     this.transport = transport;
     this.owner = owner;
-    this.ws = new WsHandles(transport, () => ++this.nextHandle);
+    this.local = local;
+    this.ws = new WsHandles(transport, () => ++this.nextHandle, local);
   }
   syscall(req) {
     if (req.op.startsWith("net-ws-")) return this.ws.syscall(req);
@@ -11137,10 +11815,13 @@ var HttpHandles = class {
     if (req.op === "net-open") return Promise.resolve(this.opened(req));
     if (req.op === "net-head") return this.head(req.handle);
     if (req.op === "net-read") return this.read(req.handle, req.max);
-    if (req.op === "net-traits") return Promise.resolve(this.traits());
+    if (req.op === "net-traits") return Promise.resolve(this.traits(req.url));
     return this.close(req.handle);
   }
-  traits() {
+  traits(url) {
+    if (url !== void 0 && this.local?.port(url) !== void 0) {
+      return { ok: true, kind: "json", json: LOOPBACK_TRAITS };
+    }
     const { unavailable, crossOrigin = "any", ...rest2 } = this.transport.traits;
     if (unavailable) return { ok: false, errno: "ENETUNREACH", message: NO_TRANSPORT };
     return { ok: true, kind: "json", json: { ...rest2, crossOrigin } };
@@ -11171,28 +11852,30 @@ var HttpHandles = class {
     return { handle, head: entry.head };
   }
   async respond(handle, req, entry) {
+    const port = this.local?.port(req.url);
     try {
-      const response = await this.transport.fetch(
-        {
-          url: req.url,
-          method: req.method,
-          headers: req.headers,
-          ...req.body ? { body: req.body } : {},
-          signal: entry.abort.signal
-        },
-        this.owner
-      );
+      const target = port === void 0 ? toHostLoopback(req.url) : req.url;
+      const request = {
+        url: target,
+        method: req.method,
+        headers: req.headers,
+        ...req.body ? { body: req.body } : {},
+        signal: entry.abort.signal
+      };
+      const response = port === void 0 ? await this.transport.fetch(request, this.owner) : await this.local.fetch(request, port);
       entry.body = response.body[Symbol.asyncIterator]();
       entry.cancel = () => response.cancel();
       if (!this.open.has(handle)) await entry.cancel().catch(() => void 0);
-      const head = this.headOf(handle, response.url ?? req.url, response);
+      const shown = response.url && response.url !== target ? response.url : req.url;
+      const head = this.headOf(handle, shown, response);
       return response.redirected ? { ...head, json: { ...head.json, redirected: true } } : head;
     } catch (e) {
       const text = message2(e);
+      if (port !== void 0) return { ok: false, errno: codeOf2(e), message: text };
       const status = e.status;
       if (text === NO_TRANSPORT || typeof status !== "number" || status === 502) {
-        const errno = text === NO_TRANSPORT ? "ENETUNREACH" : "ECONNREFUSED";
-        return { ok: false, errno, message: text };
+        const errno2 = text === NO_TRANSPORT ? "ENETUNREACH" : "ECONNREFUSED";
+        return { ok: false, errno: errno2, message: text };
       }
       entry.body = once(new TextEncoder().encode(text))[Symbol.asyncIterator]();
       return this.headOf(handle, req.url, {
@@ -12133,7 +12816,9 @@ async function socketSyscall(req, proc) {
     case "sock-accept":
       return ok(await accept(proc, req.fd, req.nonblock));
     case "sock-connect": {
-      const dialing = socketAt(fds, req.fd).connect(req.addr, true, proc.cred?.());
+      const socket = socketAt(fds, req.fd);
+      const stamp = net.facadeAt(req.addr) && await proc.stamp?.();
+      const dialing = socket.connect(req.addr, true, proc.cred?.(), stamp || void 0);
       if (req.nonblock) {
         dialing?.catch(() => void 0);
         throw new KernelError("EINPROGRESS");
@@ -13312,6 +13997,9 @@ var WasmProcess = class {
       if (channel) channel.stamp = stamp;
     }
   }
+  connectorStamp() {
+    return this.sealedCaller();
+  }
   async sealedCaller() {
     const shown = await this.options.identity?.();
     const broker = this.options.sealed;
@@ -13650,7 +14338,8 @@ var WasmProcess = class {
       net: this.net,
       blocking: () => this.blockingSignal(cancelled),
       resolve: (name2, family, blocking) => resolver.resolve(name2, family, blocking),
-      cred: () => ({ pid: this.pid, uid: this.cred.euid, gid: this.cred.egid })
+      cred: () => ({ pid: this.pid, uid: this.cred.euid, gid: this.cred.egid }),
+      stamp: () => this.connectorStamp()
     });
   }
   tty(fd) {
@@ -15022,7 +15711,7 @@ 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) {
+async function writeAll3(file, bytes) {
   const write = file.write;
   for (let at = 0; at < bytes.length; ) at += await write.call(file, bytes.subarray(at));
 }
@@ -15056,7 +15745,7 @@ function scrubbed(inner, scrubber, idleMs = SCRUB_IDLE_MS) {
   const later = (bytes) => {
     if (bytes.length === 0) return;
     pending += 1;
-    tail = tail.then(() => writeAll2(file, bytes)).catch((err) => {
+    tail = tail.then(() => writeAll3(file, bytes)).catch((err) => {
       if (failed3 === void 0) failed3 = err;
     }).finally(() => {
       pending -= 1;
@@ -15687,8 +16376,8 @@ var FSA_CAPABILITIES = {
   ranges: true,
   sessions: true
 };
-var codeOf2 = (err) => err?.code;
-var denied = (err) => codeOf2(err) === "EACCES" || err?.name === "NotAllowedError";
+var codeOf3 = (err) => err?.code;
+var denied = (err) => codeOf3(err) === "EACCES" || err?.name === "NotAllowedError";
 function attrOf(st) {
   return {
     kind: st.isDirectory ? "directory" : st.isSymbolicLink ? "symlink" : "file",
@@ -15710,7 +16399,7 @@ function kernelFsHandlers(fs) {
     try {
       return await fs.stat(path);
     } catch (err) {
-      if (codeOf2(err) === "ENOENT") return void 0;
+      if (codeOf3(err) === "ENOENT") return void 0;
       throw err;
     }
   }
@@ -15903,7 +16592,7 @@ function parseFstab(text) {
   });
   return lines2;
 }
-function codeOf3(err) {
+function codeOf4(err) {
   const code = err?.code;
   return typeof code === "string" ? code : "EIO";
 }
@@ -15941,18 +16630,18 @@ async function mountLine({ line, spec, invalid }, mount, signal, retries, discar
       break;
     } catch (err) {
       failed3 = err;
-      if (FINAL.has(codeOf3(err)) || attempt === retries.length) break;
+      if (FINAL.has(codeOf4(err)) || attempt === retries.length) break;
       await wait(retries[attempt], signal);
     }
   }
-  const code = codeOf3(failed3);
+  const code = codeOf4(failed3);
   return { line, target: spec.target, code, error: String(failed3?.message ?? code) };
 }
 
 // src/mount/hostfs.ts
 var HOSTFS_IO = 16 * 1024 * 1024;
-var codeOf4 = (err) => err?.code;
-var unreachable = (err) => codeOf4(err) === "ENOTCONN";
+var codeOf5 = (err) => err?.code;
+var unreachable = (err) => codeOf5(err) === "ENOTCONN";
 function rel(path) {
   return path.replace(/^\/+/, "");
 }
@@ -16012,9 +16701,9 @@ var HostfsClient = class {
         throw fsError2("ESTALE", "the folder was granted again, so its open files are gone");
       return this.send(path, init, false, true);
     }
-    const errno = response.headers.get("X-Hostfs-Errno") ?? "EIO";
+    const errno2 = response.headers.get("X-Hostfs-Errno") ?? "EIO";
     const body = await response.json().catch(() => ({}));
-    throw fsError2(errno, typeof body.message === "string" ? body.message : errno);
+    throw fsError2(errno2, typeof body.message === "string" ? body.message : errno2);
   }
   async call(op, body = {}, handle = false) {
     const response = await this.send(
@@ -16129,7 +16818,7 @@ function hostfsHandlers(current, againMs = RESTORE_AGAIN_MS) {
     try {
       return { opened: await opening2(), restore: void 0 };
     } catch (err) {
-      if (!flags2.write || codeOf4(err) !== "EACCES") throw err;
+      if (!flags2.write || codeOf5(err) !== "EACCES") throw err;
       const was = await client.call("stat", { path: rel(path) });
       const mode = was.mode ?? 0;
       if (mode & 128) throw err;
@@ -16554,7 +17243,7 @@ var PortTransport = class {
   }
 };
 var errorOf = (err) => ({
-  code: typeof codeOf4(err) === "string" ? codeOf4(err) : "EIO",
+  code: typeof codeOf5(err) === "string" ? codeOf5(err) : "EIO",
   message: err?.message ?? String(err)
 });
 function serveHostfsPort(port, transport) {
@@ -17145,8 +17834,8 @@ var RULE = new RegExp(
 var TERM = /^[A-Za-z0-9._+-]+$/;
 var PLAIN = /^[A-Za-z0-9_@%+=:,./-]+$/;
 var USAGE = "usage: sudo [-n] [-u user] [--] command [args...]\n       sudo -l";
-function failed2(errno, error) {
-  return { error, errno };
+function failed2(errno2, error) {
+  return { error, errno: errno2 };
 }
 function unescaped(double) {
   return double.replace(/\\(["\\$`])/g, "$1");
@@ -17757,6 +18446,7 @@ var Launcher = class {
   );
   net = new LoopbackNet();
   cdp;
+  facades;
   ca;
   transport;
   uplink;
@@ -17831,10 +18521,16 @@ var Launcher = class {
     this.modulesDir = options.modules ?? "/node_modules";
     this.appended = appendedRoots(options.commands);
     this.cdp = new CdpHosts(options.cdp);
+    this.facades = new FacadeHosts(options.facades);
     const hostname = options.hostname ?? DEFAULT_HOSTNAME;
     if (!isHostname(hostname)) throw new Error(`not a host name: ${String(hostname)}`);
     this.hostname = hostname;
-    this.env = { ...networkEnv(hostname), SLICC_CDP_URL: this.cdp.url, ...options.env };
+    this.env = {
+      ...networkEnv(hostname),
+      SLICC_CDP_URL: this.cdp.url,
+      ...this.facades.env(),
+      ...options.env
+    };
     this.ca = kernelCa(options.caStore ?? memoryCaStore());
     this.transport = replayingHops(options.transport ?? missingTransport());
     this.announcedTraits = JSON.stringify(this.transport.traits);
@@ -17849,6 +18545,7 @@ var Launcher = class {
       ca: this.ca
     });
     enableCdp(this.net, this.cdp);
+    this.facades.enable(this.net);
     const fs = withCommandDirs(
       this.base,
       async () => new Set((await this.commands()).keys()),
@@ -18432,6 +19129,12 @@ var Launcher = class {
   groupSession(pgid) {
     return this.jobs.sessionOf(pgid);
   }
+  loopbackFor(pid) {
+    return new KernelLoopback(this.net, () => {
+      const cred = this.credOf(pid);
+      return { pid, uid: cred.euid, gid: cred.egid };
+    });
+  }
   treeScrubs(req) {
     const inherited2 = req.ppid !== void 0 ? this.scrubs.get(req.ppid) : void 0;
     return req.scrub ? [...inherited2 ?? [], req.scrub] : inherited2;
@@ -18509,7 +19212,7 @@ var Launcher = class {
       jobs: this.jobs,
       ptys: this.ptys,
       net: this.net,
-      http: new HttpHandles(this.transport, pid),
+      http: new HttpHandles(this.transport, pid, this.loopbackFor(pid)),
       locks: this.locks,
       resolver: this.resolver,
       onReap: (child) => this.reaped(child, pid),
@@ -18782,6 +19485,9 @@ var Launcher = class {
       }
     };
   }
+  connectorStamp(pid) {
+    return this.sealed.stamp(this.identityOf(pid), this.credOf(pid), this.tagOf(pid));
+  }
   identityOf(pid) {
     const parent = this.jobs.shownParent(pid);
     const alive = parent !== void 0 && this.running(parent);
@@ -19688,7 +20394,7 @@ import { connect as tls } from "node:tls";
 var PROBE_MS = 3e3;
 var PASSED = /* @__PURE__ */ new Set(["ECONNREFUSED", "EHOSTUNREACH", "ENETUNREACH", "ETIMEDOUT", "ECONNRESET"]);
 var NO_NAME = /* @__PURE__ */ new Set(["ENOTFOUND", "EAI_AGAIN", "EAI_NONAME", "EAI_FAIL", "ENODATA"]);
-function codeOf5(e) {
+function codeOf6(e) {
   const code = e?.code;
   return typeof code === "string" ? code : void 0;
 }
@@ -19703,7 +20409,7 @@ function probe(secure, host, port, ms) {
     const timer = setTimeout(() => done4("ETIMEDOUT"), ms);
     socket.once(secure ? "secureConnect" : "connect", () => done4("EPROTO"));
     socket.once("error", (e) => {
-      const code = codeOf5(e) ?? "";
+      const code = codeOf6(e) ?? "";
       done4(PASSED.has(code) ? code : "EPROTO");
     });
   });
@@ -19716,7 +20422,7 @@ async function diagnose(url, ms = PROBE_MS) {
   try {
     await lookup2(host);
   } catch (e) {
-    return NO_NAME.has(codeOf5(e) ?? "") ? "EAI_NONAME" : void 0;
+    return NO_NAME.has(codeOf6(e) ?? "") ? "EAI_NONAME" : void 0;
   }
   return probe(secure, host, port, ms);
 }
@@ -19732,7 +20438,7 @@ function diagnosing(transport, check = diagnose) {
       try {
         return await open(request);
       } catch (e) {
-        if (request.signal.aborted || !(e instanceof Error) || codeOf5(e)) throw e;
+        if (request.signal.aborted || !(e instanceof Error) || codeOf6(e)) throw e;
         const code = await check(request.url).catch(() => void 0);
         throw code ? Object.assign(e, { code }) : e;
       }
@@ -19990,7 +20696,7 @@ function dialStream(port, onClose) {
 }
 
 // src/client/loopback-fetch.ts
-var OWN_HEADERS = /* @__PURE__ */ new Set(["host", "connection", "content-length", "transfer-encoding"]);
+var OWN_HEADERS2 = /* @__PURE__ */ new Set(["host", "connection", "content-length", "transfer-encoding"]);
 var encoder8 = new TextEncoder();
 var latin12 = new TextDecoder("latin1");
 var ByteSource = class {
@@ -20037,7 +20743,7 @@ function indexOf(haystack, needle) {
   }
   return -1;
 }
-function parseHead(bytes) {
+function parseHead2(bytes) {
   const [statusLine = "", ...lines2] = latin12.decode(bytes).split("\r\n");
   const match = /^HTTP\/1\.[01] (\d{3})(?: (.*))?$/.exec(statusLine);
   if (!match) throw errorWithCode(`EPROTO: not an HTTP/1.x response: ${statusLine.slice(0, 80)}`);
@@ -20051,7 +20757,7 @@ function parseHead(bytes) {
 function header3(head, name2) {
   return head.headers.find(([key]) => key.toLowerCase() === name2)?.[1];
 }
-async function* chunked(source) {
+async function* chunked2(source) {
   for (; ; ) {
     const line = await source.until("\r\n");
     if (!line) throw errorWithCode("EPROTO: the chunked body ended early");
@@ -20063,7 +20769,7 @@ async function* chunked(source) {
     yield data;
   }
 }
-async function* counted(source, length2) {
+async function* counted2(source, length2) {
   let left = length2;
   while (left > 0) {
     const data = await source.some(left);
@@ -20072,19 +20778,19 @@ async function* counted(source, length2) {
     yield data;
   }
 }
-async function* untilClose(source) {
+async function* untilClose2(source) {
   for (let data = await source.some(65536); data; data = await source.some(65536)) yield data;
 }
-function bodyOf(source, head, method) {
+function bodyOf2(source, head, method) {
   if (method === "HEAD" || head.status === 204 || head.status === 304) return void 0;
-  if (header3(head, "transfer-encoding")?.toLowerCase().includes("chunked")) return chunked(source);
+  if (header3(head, "transfer-encoding")?.toLowerCase().includes("chunked")) return chunked2(source);
   const length2 = header3(head, "content-length");
-  if (length2 === void 0) return untilClose(source);
+  if (length2 === void 0) return untilClose2(source);
   const size = Number(length2);
   if (!/^\d+$/.test(length2.trim()) || !Number.isSafeInteger(size)) {
     throw errorWithCode(`EPROTO: a malformed Content-Length: ${length2}`);
   }
-  return counted(source, size);
+  return counted2(source, size);
 }
 function stream(chunks2, socket, signal) {
   return new ReadableStream({
@@ -20113,7 +20819,7 @@ async function requestBytes(request) {
   const body = request.body ? new Uint8Array(await request.arrayBuffer()) : void 0;
   const lines2 = [`${request.method} ${url.pathname}${url.search} HTTP/1.1`, `Host: ${url.host}`];
   request.headers.forEach((value, name2) => {
-    if (!OWN_HEADERS.has(name2)) lines2.push(`${name2}: ${value}`);
+    if (!OWN_HEADERS2.has(name2)) lines2.push(`${name2}: ${value}`);
   });
   if (body) lines2.push(`Content-Length: ${body.length}`);
   lines2.push("Connection: close", "", "");
@@ -20141,9 +20847,9 @@ async function loopbackFetch(dial, input, options) {
     do {
       const raw = await source.until("\r\n\r\n");
       if (!raw) throw errorWithCode("ECONNRESET: the connection closed before a response");
-      head = parseHead(raw);
+      head = parseHead2(raw);
     } while (head.status >= 100 && head.status < 200);
-    const chunks2 = bodyOf(source, head, request.method);
+    const chunks2 = bodyOf2(source, head, request.method);
     if (!chunks2) socket.close();
     return new Response(chunks2 ? stream(chunks2, socket, options.signal) : null, {
       status: head.status,
@@ -20211,6 +20917,8 @@ var Channel = class {
   watching = /* @__PURE__ */ new Map();
   cdpHooks = /* @__PURE__ */ new Map();
   cdpOpen = /* @__PURE__ */ new Set();
+  facadeHooks = /* @__PURE__ */ new Map();
+  facadeOpen = /* @__PURE__ */ new Set();
   protocol = PROTOCOL;
   nextId = 0;
   port;
@@ -20233,6 +20941,8 @@ var Channel = class {
     this.remote?.fail(error);
     for (const close of [...this.cdpOpen]) close();
     this.cdpOpen.clear();
+    for (const close of [...this.facadeOpen]) close();
+    this.facadeOpen.clear();
     for (const call of this.pending.values()) call.reject(error);
     this.pending.clear();
     this.release();
@@ -20262,6 +20972,10 @@ var Channel = class {
       this.openCdp(data);
       return;
     }
+    if (data.facadeOpen && data.port) {
+      this.openFacade(data);
+      return;
+    }
     if (data.watch !== void 0) {
       this.watching.get(data.watch)?.(data.change);
       return;
@@ -20304,7 +21018,36 @@ var Channel = class {
     const close = serveCdpPort(port, hook, request, () => this.cdpOpen.delete(close));
     this.cdpOpen.add(close);
   }
+  openFacade({ facadeOpen: { registration, ...request }, port }) {
+    const hook = registration === void 0 ? void 0 : this.facadeHooks.get(registration);
+    if (!hook || this.failure) {
+      port.postMessage({ error: "this client no longer serves the facade" });
+      port.close();
+      return;
+    }
+    const close = serveFacadePort(port, hook, request, () => this.facadeOpen.delete(close));
+    this.facadeOpen.add(close);
+  }
 };
+async function serveFacadeOn(channel, name2, hook) {
+  if (typeof hook !== "function") throw new TypeError("serveFacade: hook must be a function");
+  await since(channel, 11, "facade serving", async () => {
+  });
+  const { id: id2, done: done4 } = channel.request({ op: "serve-facade", name: name2 });
+  channel.facadeHooks.set(id2, hook);
+  try {
+    await done4;
+  } catch (error) {
+    channel.facadeHooks.delete(id2);
+    throw error;
+  }
+  return {
+    close: () => {
+      if (!channel.facadeHooks.delete(id2)) return;
+      void channel.call({ op: "unserve-facade", registration: id2 }).catch(() => void 0);
+    }
+  };
+}
 async function serveCdpOn(channel, hook, options) {
   await since(channel, 5, "CDP serving", async () => {
   });
@@ -20538,6 +21281,7 @@ async function attachKernel(port, options = {}) {
     loopbackFetch: (input, options2) => loopbackFetch((o) => dialOn(channel, o), input, options2),
     fs: fsOn(channel),
     serveCdp: (hook, options2 = {}) => serveCdpOn(channel, hook, options2),
+    serveFacade: (name2, hook) => serveFacadeOn(channel, name2, hook),
     onTraits(listener) {
       channel.traitsListeners.add(listener);
       return () => channel.traitsListeners.delete(listener);
@@ -20654,6 +21398,7 @@ async function createNodeKernel(options = {}) {
     ...options.hostfs ? { hostfs: options.hostfs } : {},
     ...hostfsFetchOf(options),
     ...options.cdp ? { cdp: options.cdp } : {},
+    ...options.facades ? { facades: options.facades } : {},
     ...options.hostname !== void 0 ? { hostname: options.hostname } : {},
     users: options.users === void 0 ? DEFAULT_USERS : options.users,
     ...options.onDenial ? { onDenial: options.onDenial } : {},