@ai-ecoverse/slicc-kernel 1.88.1 → 1.90.0

package/dist/kernel-worker.js

@@ -383,6 +383,14 @@ function inodeOf(path) {
   h2 = Math.imul(h2 ^ h2 >>> 16, 2246822507) ^ Math.imul(h1 ^ h1 >>> 13, 3266489909);
   return 4294967296 * (2097151 & h2) + (h1 >>> 0) || 1;
 }
+function redirected(of, to) {
+  return Object.assign(fsError("EXDEV", `${of} leads to the mount at ${to}`), {
+    redirect: { of: normalizePath(of), to: normalizePath(to) }
+  });
+}
+function redirectOf(err) {
+  return err?.redirect;
+}
 
 // src/fs/owners.ts
 var ROOT_OWNER = Object.freeze({ uid: 0, gid: 0 });
@@ -476,39 +484,47 @@ var Integrity = class {
     this.unknown = integrityUnknown(options);
     this.report = report;
   }
-  async real(path) {
+  async real(path, asked) {
     const at = normalizePath(path);
     const real = await this.root.realpath?.(at, true).catch(() => void 0) ?? at;
-    return isProtected(this.prefixes, real) ? real : void 0;
-  }
-  async key(path) {
-    const real = await this.real(path);
-    if (real === void 0 || !this.root.version) return void 0;
+    if (isProtected(this.prefixes, real)) return { real, name: real };
+    const names = asked === void 0 ? [] : await namesOf(this.root, asked);
+    if (real !== at) names.push(...await namesOf(this.root, at));
+    const name2 = names.findLast((p) => isProtected(this.prefixes, p));
+    return name2 === void 0 ? void 0 : { real, name: name2 };
+  }
+  async key(path, asked) {
+    const found = await this.real(path, asked);
+    if (found === void 0) return void 0;
+    const { real, name: name2 } = found;
+    if (name2 !== real) return `${name2}\0${real}\0`;
+    if (!this.root.version) return void 0;
     return `${real}\0${await this.root.version(real)}`;
   }
-  async read(path, caller, plain) {
-    return (await this.readKeyed(path, caller, plain)).bytes;
+  async read(path, caller, plain, asked) {
+    return (await this.readKeyed(path, caller, plain, asked)).bytes;
   }
-  async readKeyed(path, caller, plain) {
-    const real = await this.real(path);
-    if (real === void 0) return { bytes: await plain() };
-    const read = this.root.readVersioned ? await this.root.readVersioned(real) : { bytes: await this.root.readFileBuffer(real), version: void 0 };
+  async readKeyed(path, caller, plain, asked) {
+    const found = await this.real(path, asked);
+    if (found === void 0) return { bytes: await plain() };
+    const { real, name: name2 } = found;
+    const read = name2 !== real ? { bytes: await plain(), version: void 0 } : this.root.readVersioned ? await this.root.readVersioned(real) : { bytes: await this.root.readFileBuffer(real), version: void 0 };
     const { bytes } = read;
     const keyed = read.version === void 0 ? { bytes } : { bytes, key: `${real}\0${read.version}` };
     const actual = await sha256(bytes);
-    const denial = { pid: caller.pid, uid: caller.uid, path: real, actual };
+    const denial = { pid: caller.pid, uid: caller.uid, path: name2, actual };
     const tagged = caller.tag !== void 0 ? { tag: caller.tag } : {};
     let expected;
     try {
-      expected = await this.expected(real);
+      expected = await this.expected(name2);
     } catch {
       this.say({ ...denial, ...tagged, op: "exec-integrity", errno: "EACCES" });
-      throw fsError("EACCES", `integrity lookup failed: ${real}`);
+      throw fsError("EACCES", `integrity lookup failed: ${name2}`);
     }
     if (expected === void 0) {
       if (this.unknown === "allow") {
-        if (!this.unverified.has(real)) {
-          this.unverified.add(real);
+        if (!this.unverified.has(name2)) {
+          this.unverified.add(name2);
           this.say({ ...denial, ...tagged, op: "exec-unverified", errno: "ENODATA" });
         }
         return keyed;
@@ -518,7 +534,12 @@ var Integrity = class {
     }
     const known = expected !== void 0 ? { expected } : {};
     this.say({ ...denial, ...tagged, ...known, op: "exec-integrity", errno: "EACCES" });
-    throw fsError("EACCES", `integrity check failed: ${real}`);
+    throw fsError("EACCES", `integrity check failed: ${name2}`);
+  }
+  forget(path) {
+    for (const name2 of [...this.unverified]) {
+      if (path === void 0 || isProtected([path], name2)) this.unverified.delete(name2);
+    }
   }
   async expected(path) {
     const answer = await this.lookup(path);
@@ -572,10 +593,10 @@ function missing(err) {
   const code = err?.code;
   return code === "ENOENT" || code === "ENOTDIR";
 }
-async function resolved(fs, path, follow2) {
+async function resolved(fs, path, follow2, hops = []) {
   let done4 = [];
   let todo = partsOf(path);
-  for (let hops = 0; todo.length > 0; ) {
+  for (let links = 0; todo.length > 0; ) {
     const part = todo.shift();
     if (part === "..") {
       done4.pop();
@@ -597,13 +618,20 @@ async function resolved(fs, path, follow2) {
       done4.push(part);
       continue;
     }
-    if (++hops > MAX_LINKS) throw fsError("ELOOP", path);
+    if (++links > MAX_LINKS) throw fsError("ELOOP", path);
+    hops.push(normalizePath([at, ...todo].join("/")));
     const link2 = await fs.readlink(at);
     if (link2.startsWith("/")) done4 = [];
     todo = [...partsOf(link2), ...todo];
   }
   return `/${done4.join("/")}`;
 }
+async function namesOf(fs, path) {
+  const lexical2 = normalizePath(path);
+  const hops = [];
+  await resolved(fs, lexical2, true, hops).catch(() => void 0);
+  return [lexical2, ...hops];
+}
 var ProtectedFs = class {
   prefixes;
   constructor(prefixes2) {
@@ -656,8 +684,8 @@ var ProtectedFs = class {
         await check(path, true);
         return fs.utimes(path, atime, mtime);
       },
-      async mayChange(path, follow2) {
-        await check(path, follow2);
+      async mayChange(path, follow2, whole = false) {
+        await check(path, follow2, whole);
       },
       async stat(path) {
         return marked(path, await fs.stat(path));
@@ -984,6 +1012,7 @@ var OpfsFs = class {
   remote;
   ranged;
   owners = false;
+  mounts = {};
   constructor(root, meta = new MemoryMeta(), channel, options = {}) {
     this.root = root;
     this.meta = sidecar(meta);
@@ -1057,6 +1086,12 @@ var OpfsFs = class {
   trackOwners() {
     this.owners = true;
   }
+  crossings(mounted) {
+    this.mounts.mounted = mounted;
+  }
+  crossing(of, to) {
+    if (this.mounts.mounted?.(to)) throw redirected(of, to);
+  }
   async hasOwner(path) {
     return ownOf((await this.meta.get([path]))[0]) !== void 0;
   }
@@ -1251,12 +1286,13 @@ var OpfsFs = class {
         if (!link2) throw err;
         if (link2.path === current && !follow2) return { path: current, link: link2 };
         const target = `${link2.link}${current.slice(link2.path.length)}`;
-        current = target.split("/").includes("..") ? await this.physical(parentOf3(link2.path), target, hops + 1) : resolvePath(parentOf3(link2.path), target);
+        current = target.split("/").includes("..") ? await this.physical(parentOf3(link2.path), target, hops + 1, path) : resolvePath(parentOf3(link2.path), target);
+        this.crossing(path, current);
       }
     }
     throw fsError("ELOOP", path);
   }
-  async physical(base, path, used) {
+  async physical(base, path, used, of) {
     let done4 = [];
     let todo = (path.startsWith("/") ? path : `${base}/${path}`).split("/").filter((p) => p !== "" && p !== ".");
     for (let hops = used; todo.length > 0; ) {
@@ -1265,6 +1301,7 @@ var OpfsFs = class {
       else if (!todo.includes("..")) done4.push(part);
       else {
         const at = `/${[...done4, part].join("/")}`;
+        this.crossing(of, [at, ...todo].join("/"));
         const st = await this.lstat(at);
         if (!st.isSymbolicLink && !st.isDirectory) throw fsError("ENOTDIR", at);
         if (!st.isSymbolicLink) done4.push(part);
@@ -2015,7 +2052,7 @@ function portCdpHook(ask, gone) {
 }
 
 // src/client/protocol.ts
-var PROTOCOL = [1, 10];
+var PROTOCOL = [1, 11];
 var FS_METHODS = [
   "readFile",
   "writeFile",
@@ -2046,6 +2083,52 @@ function fresh(bytes, start2 = 0, end = bytes.length) {
   return new Uint8Array(bytes.subarray(start2, end));
 }
 
+// src/facade/port.ts
+var FACADE_GONE = "the facade host is gone";
+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/walk.ts
 var MAX_LINKS3 = 40;
 function parentOf4(path) {
@@ -2159,7 +2242,10 @@ var Perms = class {
 function parts(path) {
   return path.split("/").filter((part) => part !== "" && part !== ".");
 }
-async function walk(fs, cred, path, follow2) {
+function trustedLink(perm, links) {
+  return links === void 0 || perm.uid === 0 || perm.uid === links;
+}
+async function walk(fs, cred, path, follow2, links) {
   const perms = new Perms(fs);
   await perms.learn(path);
   const queue = parts(path);
@@ -2177,6 +2263,7 @@ async function walk(fs, cred, path, follow2) {
     const perm = await perms.at(next2);
     const last = queue.length === 0;
     if (perm?.link !== void 0 && (!last || follow2)) {
+      if (!trustedLink(perm, links)) return { path, perm: void 0, denied: next2, link: true };
       if (++hops > MAX_LINKS4) return { path: next2, perm: void 0 };
       queue.unshift(...parts(perm.link));
       if (perm.link.startsWith("/")) at = "/";
@@ -2201,9 +2288,9 @@ async function finalOf(fs, walked, want, options) {
   return st ? [permOf(st), st.isDirectory] : [perm, false];
 }
 async function access(fs, cred, path, want, options = {}) {
-  const walked = await walk(fs, cred, path, options.follow !== false);
+  const walked = await walk(fs, cred, path, options.follow !== false, options.links);
   if (walked.denied !== void 0) {
-    if (await present(fs, walked.denied, true)) return walked;
+    if (walked.link || await present(fs, walked.denied, true)) return walked;
     return { path, perm: void 0, missing: true };
   }
   if (!walked.perm) return { ...walked, missing: true };
@@ -2270,6 +2357,9 @@ var Created = class {
     return this.paths.delete(normalizePath(path));
   }
 };
+function linked(g, options) {
+  return g.links === void 0 ? options : { ...options, links: g.links };
+}
 function deny(g, op, path, errno = "EACCES") {
   const tag = g.tag === void 0 ? {} : { tag: g.tag };
   g.dac.denied({ pid: g.pid, uid: g.cred.euid, op, path, errno, ...tag });
@@ -2280,8 +2370,8 @@ function ttyOpenable(g, tty) {
   deny(g, "open", tty.name ?? "/dev/tty");
 }
 async function need(g, op, path, want, options = {}, shown = path) {
-  const walked = await access(g.fs, g.cred, path, want, options);
-  if (walked.denied !== void 0) deny(g, op, shown);
+  const walked = await access(g.fs, g.cred, path, want, linked(g, options));
+  if (walked.denied !== void 0) deny(g, op, walked.link ? walked.denied : shown);
   return walked;
 }
 function entryIn(dir, path) {
@@ -2300,14 +2390,16 @@ async function inParent(g, op, path, old = false) {
     return dir2.denied === void 0 ? stickyEntry(g, op, path, dir2) : void 0;
   }
   if (!old) return void await need(g, op, parentOf4(path), W_OK | X_OK, DIR, path);
-  const dir = await access(g.fs, g.cred, parentOf4(path), W_OK | X_OK, DIR);
+  const dir = await access(g.fs, g.cred, parentOf4(path), W_OK | X_OK, linked(g, DIR));
   if (dir.denied === void 0) return stickyEntry(g, op, path, dir);
+  if (dir.link) return deny(g, op, dir.denied);
   const lookup = dir.denied === dir.path && dir.perm && permits(g.cred, dir.perm, X_OK);
   if (!lookup || await present(g.fs, entryIn(dir, path), false)) deny(g, op, path);
 }
 async function makeIn(g, op, path) {
   for (let dir = parentOf4(path); ; dir = parentOf4(dir)) {
-    const walked = await access(g.fs, g.cred, dir, W_OK | X_OK, DIR);
+    const walked = await access(g.fs, g.cred, dir, W_OK | X_OK, linked(g, DIR));
+    if (walked.link) return deny(g, op, walked.denied);
     if (walked.denied !== void 0) {
       if (!await present(g.fs, path, true)) deny(g, op, path);
       return;
@@ -3091,6 +3183,7 @@ var KernelSocket = class _KernelSocket {
   local;
   peer;
   peerCred;
+  peerStamp;
   listenerCred;
   link;
   readShut = false;
@@ -3161,10 +3254,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) {
@@ -3193,7 +3286,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");
@@ -3212,6 +3305,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);
@@ -3352,6 +3446,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) {
@@ -3366,6 +3462,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);
   }
@@ -3374,7 +3482,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;
   }
@@ -3383,11 +3491,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);
@@ -3414,7 +3524,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");
   }
@@ -3710,12 +3820,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) {
       fail2(call.nid, e);
     }
   };
-  const relay = async (nid, socket) => {
+  const relay2 = async (nid, socket) => {
     let ending;
     let late;
     const unanswered = new Promise((resolve2) => {
@@ -4349,6 +4459,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(
+        (request2, facade) => send({ facadeOpen: { ...request2, 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();
@@ -4392,7 +4541,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 });
@@ -4400,7 +4549,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]);
@@ -4497,16 +4646,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:
@@ -6599,7 +6748,7 @@ var RemoteTransport = class {
       finish();
       throw e;
     }
-    const { status, statusText, headers, url, redirected, redirects } = head;
+    const { status, statusText, headers, url, redirected: redirected2, redirects } = head;
     const read = async () => {
       if (finished) return void 0;
       const reply = await this.ask({ net: "read", nid }).catch((e) => {
@@ -6616,7 +6765,7 @@ var RemoteTransport = class {
       this.cancel(nid);
     };
     return {
-      ...redirected ? { url, redirected } : {},
+      ...redirected2 ? { url, redirected: redirected2 } : {},
       ...redirects ? { redirects } : {},
       status,
       statusText,
@@ -7081,6 +7230,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;
@@ -7395,9 +7545,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);
     }
@@ -7415,9 +7565,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) {
@@ -7447,6 +7597,132 @@ function binfmtOf(binfmts, path) {
   return best === void 0 ? void 0 : binfmts.get(best);
 }
 
+// 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;
@@ -7641,14 +7917,14 @@ function withCommandDirs(fs, names, userDir = async () => void 0, owners = false
     const own = await userDir(dir);
     return own?.has(path.slice(slash + 1)) ? owned4(synthetic(false, path), dir) : void 0;
   }
-  async function linked(path) {
+  async function linked2(path) {
     return await virtual(path) ?? virtual(await followLinks(fs, path));
   }
   async function stat(path, real) {
     try {
       return await real(path);
     } catch (err) {
-      const found = missing3(err) ? await linked(path) : void 0;
+      const found = missing3(err) ? await linked2(path) : void 0;
       if (found) return found;
       throw err;
     }
@@ -7660,7 +7936,7 @@ function withCommandDirs(fs, names, userDir = async () => void 0, owners = false
       try {
         return await fs.readFileBuffer(path);
       } catch (err) {
-        if (missing3(err) && (await linked(path))?.isFile) return new Uint8Array(0);
+        if (missing3(err) && (await linked2(path))?.isFile) return new Uint8Array(0);
         throw err;
       }
     },
@@ -7668,7 +7944,7 @@ function withCommandDirs(fs, names, userDir = async () => void 0, owners = false
     link: (from, to, follow2) => fs.link(from, to, follow2),
     links: (path) => mayLink(fs, path),
     async exists(path) {
-      return await fs.exists(path) || await linked(path) !== void 0;
+      return await fs.exists(path) || await linked2(path) !== void 0;
     },
     stat: (path) => stat(path, (p) => fs.stat(p)),
     lstat: (path) => stat(path, (p) => fs.lstat(p)),
@@ -9093,6 +9369,7 @@ var MountTable = class {
     return { quota: st.blocks * st.bsize, usage: (st.blocks - st.bfree) * st.bsize };
   }
   wrap(base) {
+    base.crossings?.((path) => this.locate(normalizePath(path)) !== void 0);
     return new MountFs(this, base);
   }
 };
@@ -9116,6 +9393,37 @@ var MountFs = class {
   writable(mount, path) {
     if (readonly(mount)) throw errnoError("EROFS", path);
   }
+  async through(path) {
+    const real = normalizePath(path);
+    if (this.at(real)) return real;
+    try {
+      await this.base.stat(parentOf7(real));
+      return real;
+    } catch (err) {
+      const moved2 = redirectOf(err);
+      return moved2 ? normalizePath(moved2.to + real.slice(moved2.of.length)) : real;
+    }
+  }
+  async across(from, to, redirects) {
+    const moved2 = [await this.through(from), await this.through(to)];
+    const same = moved2[0] === normalizePath(from) && moved2[1] === normalizePath(to);
+    if (same || redirects >= MAX_LINKS7) throw errnoError("EXDEV", `${from} -> ${to}`);
+    return moved2;
+  }
+  async based(paths, redirects, run2, again) {
+    try {
+      return await run2();
+    } catch (err) {
+      const moved2 = redirectOf(err);
+      if (!moved2) throw err;
+      if (redirects >= MAX_LINKS7) throw errnoError("ELOOP", paths[0]);
+      const at = paths.map((path) => {
+        const real = normalizePath(path);
+        return within6(real, moved2.of) ? normalizePath(moved2.to + real.slice(moved2.of.length)) : real;
+      });
+      return again(at, redirects + 1);
+    }
+  }
   async follow(path, hops = 0, create = false) {
     const found = this.at(path);
     if (!found) return path;
@@ -9163,10 +9471,17 @@ var MountFs = class {
   async readFile(path) {
     return new TextDecoder().decode(await this.readFileBuffer(path));
   }
-  async readFileBuffer(path) {
+  async readFileBuffer(path, redirects = 0) {
     const real = await this.follow(path);
     const found = this.at(real);
-    if (!found) return this.base.readFileBuffer(real);
+    if (!found) {
+      return this.based(
+        [real],
+        redirects,
+        () => this.base.readFileBuffer(real),
+        ([to], n) => this.readFileBuffer(to, n)
+      );
+    }
     for (let attempt = 1; ; attempt++) {
       try {
         return await this.readWhole(found.mount, real, found.rel);
@@ -9205,10 +9520,18 @@ var MountFs = class {
     }
     return concat4(chunks, total);
   }
-  async writeFile(path, content, owner) {
+  async writeFile(path, content, owner, redirects = 0) {
     const real = await this.follow(path, 0, true);
     const found = this.at(real);
-    if (!found) return this.base.writeFile(real, content, owner);
+    if (!found) {
+      const write = () => this.base.writeFile(real, content, owner);
+      return this.based(
+        [real],
+        redirects,
+        write,
+        ([to], n) => this.writeFile(to, content, owner, n)
+      );
+    }
     const { mount, rel: rel2 } = found;
     this.writable(mount, real);
     const bytes = typeof content === "string" ? new TextEncoder().encode(content) : content;
@@ -9242,10 +9565,18 @@ var MountFs = class {
       this.table.forget(mount, real);
     }
   }
-  async pread(path, offset, length2, version) {
+  async pread(path, offset, length2, version, redirects = 0) {
     const real = await this.follow(path);
     const found = this.at(real);
-    if (!found && this.base.pread) return this.base.pread(real, offset, length2);
+    const { pread } = this.base;
+    if (!found && pread) {
+      return this.based(
+        [real],
+        redirects,
+        () => pread.call(this.base, real, offset, length2),
+        ([to], n) => this.pread(to, offset, length2, version, n)
+      );
+    }
     if (!found) return (await this.base.readFileBuffer(real)).slice(offset, offset + length2);
     const { mount, rel: rel2 } = found;
     if ((await this.table.getattr(mount, real, rel2)).kind === "directory") {
@@ -9292,10 +9623,18 @@ var MountFs = class {
       );
     }
   }
-  async pwrite(path, offset, bytes, transfer = false) {
+  async pwrite(path, offset, bytes, transfer = false, redirects = 0) {
     const real = await this.follow(path, 0, true);
     const found = this.at(real);
-    if (!found && this.base.pwrite) return this.base.pwrite(real, offset, bytes);
+    const { pwrite } = this.base;
+    if (!found && pwrite) {
+      return this.based(
+        [real],
+        redirects,
+        () => pwrite.call(this.base, real, offset, bytes),
+        ([to], n) => this.pwrite(to, offset, bytes, transfer, n)
+      );
+    }
     if (!found)
       return this.base.writeFile(
         real,
@@ -9335,10 +9674,18 @@ var MountFs = class {
       await mount.conn.call({ op: "write", fh, offset: offset + at, bytes: part }, [part.buffer]);
     }
   }
-  async truncate(path, size) {
+  async truncate(path, size, redirects = 0) {
     const real = await this.follow(path);
     const found = this.at(real);
-    if (!found && this.base.truncate) return this.base.truncate(real, size);
+    const { truncate } = this.base;
+    if (!found && truncate) {
+      return this.based(
+        [real],
+        redirects,
+        () => truncate.call(this.base, real, size),
+        ([to], n) => this.truncate(to, size, n)
+      );
+    }
     if (!found?.mount.caps.ranges) {
       return this.writeFile(real, resized(await this.readFileBuffer(real), size));
     }
@@ -9354,8 +9701,15 @@ var MountFs = class {
       this.table.forget(mount, real);
     }
   }
-  async exists(path) {
-    if (!this.at(path)) return this.base.exists(path);
+  async exists(path, redirects = 0) {
+    if (!this.at(path)) {
+      return this.based(
+        [path],
+        redirects,
+        () => this.base.exists(path),
+        ([to], n) => this.exists(to, n)
+      );
+    }
     try {
       await this.stat(path);
       return true;
@@ -9365,9 +9719,16 @@ var MountFs = class {
       throw err;
     }
   }
-  async lstat(path) {
+  async lstat(path, redirects = 0) {
     const found = this.at(path);
-    if (!found) return this.base.lstat(path);
+    if (!found) {
+      return this.based(
+        [path],
+        redirects,
+        () => this.base.lstat(path),
+        ([to], n) => this.lstat(to, n)
+      );
+    }
     const real = normalizePath(path);
     if (this.table.writing(real)?.truncated) await this.table.commit(real);
     return this.statWriting(
@@ -9380,9 +9741,15 @@ var MountFs = class {
     const ends = (this.table.writing(real)?.extents ?? []).map(([, end]) => end);
     return statOf({ ...attr2, size: Math.max(attr2.size, ...ends) }, real, mount);
   }
-  async stat(path) {
+  async stat(path, redirects = 0) {
     const real = await this.follow(path);
-    return this.at(real) ? this.lstat(real) : this.base.stat(real);
+    if (this.at(real)) return this.lstat(real);
+    return this.based(
+      [real],
+      redirects,
+      () => this.base.stat(real),
+      ([to], n) => this.stat(to, n)
+    );
   }
   async entries(path) {
     const real = await this.follow(path);
@@ -9394,12 +9761,26 @@ var MountFs = class {
       list: await this.table.readdir(found.mount, real, found.rel)
     };
   }
-  async readdir(path) {
-    if (!this.at(path)) return this.base.readdir(path);
+  async readdir(path, redirects = 0) {
+    if (!this.at(path)) {
+      return this.based(
+        [path],
+        redirects,
+        () => this.base.readdir(path),
+        ([to], n) => this.readdir(to, n)
+      );
+    }
     return (await this.entries(path)).list.map((e) => e.name);
   }
-  async readdirStat(path) {
-    if (!this.at(path)) return this.base.readdirStat(path);
+  async readdirStat(path, redirects = 0) {
+    if (!this.at(path)) {
+      return this.based(
+        [path],
+        redirects,
+        () => this.base.readdirStat(path),
+        ([to], n) => this.readdirStat(to, n)
+      );
+    }
     const { real, mount, list } = await this.entries(path);
     return Promise.all(
       list.map(async (entry) => {
@@ -9411,9 +9792,16 @@ var MountFs = class {
       })
     );
   }
-  async mkdir(path, options = {}) {
+  async mkdir(path, options = {}, redirects = 0) {
     const found = this.at(path);
-    if (!found) return this.base.mkdir(path, options);
+    if (!found) {
+      return this.based(
+        [path],
+        redirects,
+        () => this.base.mkdir(path, options),
+        ([to], n) => this.mkdir(to, options, n)
+      );
+    }
     const { mount, rel: rel2 } = found;
     const real = normalizePath(path);
     this.writable(mount, real);
@@ -9438,11 +9826,18 @@ var MountFs = class {
       await mount.conn.call({ op: "mkdir", path: sub, ...made2 });
     }
   }
-  async rm(path, options = {}) {
+  async rm(path, options = {}, redirects = 0) {
     const found = this.at(path);
     if (!found && options.recursive && this.table.under(normalizePath(path)))
       return this.rmAround(normalizePath(path), options);
-    if (!found) return this.base.rm(path, options);
+    if (!found) {
+      return this.based(
+        [path],
+        redirects,
+        () => this.base.rm(path, options),
+        ([to], n) => this.rm(to, options, n)
+      );
+    }
     const { mount, rel: rel2 } = found;
     const real = normalizePath(path);
     if (rel2 === "/" && options.recursive) await this.rmEach(real, mount, rel2, options);
@@ -9483,11 +9878,22 @@ var MountFs = class {
     }
     throw first ?? errnoError("EBUSY", `${path} holds a mount point`);
   }
-  async rename(from, to) {
+  async rename(from, to, redirects = 0) {
     const a = this.at(from);
     const b = this.at(to);
-    if (!a && !b) return this.base.rename(from, to);
-    if (!a || !b || a.mount !== b.mount) throw errnoError("EXDEV", `${from} -> ${to}`);
+    if (!a && !b) {
+      return this.based(
+        [from, to],
+        redirects,
+        () => this.base.rename(from, to),
+        ([f, t], n) => this.rename(f, t, n)
+      );
+    }
+    if (!a || !b) {
+      const [f, t] = await this.across(from, to, redirects);
+      return this.rename(f, t, redirects + 1);
+    }
+    if (a.mount !== b.mount) throw errnoError("EXDEV", `${from} -> ${to}`);
     this.writable(a.mount, normalizePath(to));
     await this.table.commitUnder(from);
     await this.table.commitUnder(to);
@@ -9528,9 +9934,17 @@ var MountFs = class {
       this.table.forget(a.mount, normalizePath(to));
     }
   }
-  async symlink(target, path, owner) {
+  async symlink(target, path, owner, redirects = 0) {
     const found = this.at(path);
-    if (!found) return this.base.symlink(target, path, owner);
+    if (!found) {
+      const make = () => this.base.symlink(target, path, owner);
+      return this.based(
+        [path],
+        redirects,
+        make,
+        ([to], n) => this.symlink(target, to, owner, n)
+      );
+    }
     this.writable(found.mount, normalizePath(path));
     if (!found.mount.caps.symlinks)
       throw errnoError("EPERM", `${path}: this file system has no symlinks`);
@@ -9540,8 +9954,11 @@ var MountFs = class {
     await found.mount.conn.call({ op: "symlink", target, path: found.rel, ...made2 });
   }
   async realpath(path, follow2) {
-    if (this.at(path) || !this.base.realpath) throw errnoError("ENOSYS", path);
-    const real = await this.base.realpath(path, follow2);
+    const { realpath: realpath2 } = this.base;
+    if (this.at(path) || !realpath2) throw errnoError("ENOSYS", path);
+    const real = await realpath2.call(this.base, path, follow2).catch((err) => {
+      throw redirectOf(err) ? errnoError("ENOSYS", path) : err;
+    });
     if (this.at(real)) throw errnoError("ENOSYS", path);
     return real;
   }
@@ -9563,17 +9980,30 @@ var MountFs = class {
     }
     return out;
   }
-  async readlink(path) {
+  async readlink(path, redirects = 0) {
     const found = this.at(path);
-    if (!found) return this.base.readlink(path);
+    if (!found) {
+      return this.based(
+        [path],
+        redirects,
+        () => this.base.readlink(path),
+        ([to], n) => this.readlink(to, n)
+      );
+    }
     return await found.mount.conn.call({ op: "readlink", path: found.rel });
   }
-  async chown(path, change) {
+  async chown(path, change, redirects = 0) {
     const real = change.follow === false || change.kind === "new" ? path : await this.follow(path);
     const found = this.at(real);
     if (found) return this.chownMounted(found, normalizePath(real), change);
-    if (!this.base.chown) throw errnoError("EPERM", path);
-    return this.base.chown(real, change);
+    const { chown: chown2 } = this.base;
+    if (!chown2) throw errnoError("EPERM", path);
+    return this.based(
+      [real],
+      redirects,
+      () => chown2.call(this.base, real, change),
+      ([to], n) => this.chown(to, change, n)
+    );
   }
   async chownMounted(found, real, change) {
     const { mount, rel: rel2 } = found;
@@ -9593,24 +10023,47 @@ var MountFs = class {
       ...Object.fromEntries(attrs.filter(([, value]) => value !== void 0))
     });
   }
-  async chmod(path, mode) {
+  async chmod(path, mode, redirects = 0) {
     const real = await this.follow(path);
     const found = this.at(real);
-    if (!found) return this.base.chmod(real, mode);
+    if (!found) {
+      return this.based(
+        [real],
+        redirects,
+        () => this.base.chmod(real, mode),
+        ([to], n) => this.chmod(to, mode, n)
+      );
+    }
     this.writable(found.mount, real);
     if (!found.mount.caps.chmod) return;
     this.table.forget(found.mount, real);
     await found.mount.conn.call({ op: "setattr", path: found.rel, mode });
   }
-  async utimes(path, atime, mtime) {
+  async utimes(path, atime, mtime, redirects = 0) {
     const real = await this.follow(path);
     const found = this.at(real);
-    if (!found) return this.base.utimes(real, atime, mtime);
+    if (!found) {
+      const set2 = () => this.base.utimes(real, atime, mtime);
+      return this.based(
+        [real],
+        redirects,
+        set2,
+        ([to], n) => this.utimes(to, atime, mtime, n)
+      );
+    }
     await this.setMtime(found, real, mtime);
   }
-  async lutimes(path, atime, mtime) {
+  async lutimes(path, atime, mtime, redirects = 0) {
     const found = this.at(path);
-    if (!found) return lutimesOf(this.base, path, atime, mtime);
+    if (!found) {
+      const set2 = () => lutimesOf(this.base, path, atime, mtime);
+      return this.based(
+        [path],
+        redirects,
+        set2,
+        ([to], n) => this.lutimes(to, atime, mtime, n)
+      );
+    }
     const real = normalizePath(path);
     if (!found.mount.caps.linkTimes && (await this.lstat(real)).isSymbolicLink) {
       throw errnoError("EOPNOTSUPP", path);
@@ -9829,7 +10282,8 @@ async function run(entry, path, req) {
 function guardOf(entry) {
   const cred = entry.dac && entry.cred?.();
   if (!cred || !entry.dac) return void 0;
-  return { fs: entry.fs, cred, pid: entry.pid ?? 0, dac: entry.dac };
+  const links = entry.links === void 0 ? {} : { links: entry.links };
+  return { fs: entry.fs, cred, pid: entry.pid ?? 0, dac: entry.dac, ...links };
 }
 var FOLLOWING = /* @__PURE__ */ new Set(["exists", "stat", "chown", "statfs"]);
 var LOOKS = /* @__PURE__ */ new Set(["exists", "stat", "lstat"]);
@@ -9890,9 +10344,15 @@ async function holdOp(entry, path, req) {
   entry.hold?.(path, on, open, void 0, req.handle);
   return done;
 }
+async function followed(g, path) {
+  const st = await g.fs.lstat(path).catch(() => void 0);
+  if (st?.isSymbolicLink && !trustedLink(permOf(st), g.links)) deny(g, "follow", path);
+  return done;
+}
 async function accessOp(entry, path, req) {
   const g = guardOf(entry);
   if (!g) return done;
+  if (req.arg2 === "follow") return followed(g, path);
   const open = req.arg2 === "open";
   const cred = open || req.arg2 === "eaccess" ? g.cred : realIds(g.cred);
   const options = { follow: req.nofollow !== true, ...open ? { directory: false } : {} };
@@ -9915,15 +10375,18 @@ var CHANGING = /* @__PURE__ */ new Set([
   "lchown"
 ]);
 var CONTENT = /* @__PURE__ */ new Set(["write", "pwrite", "truncate"]);
+var REMOVING = /* @__PURE__ */ new Set(["unlink", "rmdir", "rm", "rename"]);
 async function mayChange(entry, path, req) {
   const { mayChange: mayChange2 } = entry.fs;
   if (!mayChange2) return;
   const { op } = req;
   if (CONTENT.has(op) && req.handle === void 0) return mayChange2.call(entry.fs, path, true);
   if (!CHANGING.has(op)) return;
-  await mayChange2.call(entry.fs, path, op === "utimes" || op === "chmod" || op === "chown");
+  const follow2 = op === "utimes" || op === "chmod" || op === "chown";
+  await mayChange2.call(entry.fs, path, follow2, REMOVING.has(op));
   if (op === "rename" || op === "link") {
-    await mayChange2.call(entry.fs, entry.fs.resolvePath(entry.cwd, req.arg2 ?? ""), false);
+    const to = entry.fs.resolvePath(entry.cwd, req.arg2 ?? "");
+    await mayChange2.call(entry.fs, to, false, op === "rename");
   }
 }
 async function guarded(entry, path, req) {
@@ -10616,7 +11079,7 @@ function mountTable(mounts = []) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.88.1" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.90.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
@@ -12256,7 +12719,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");
@@ -13387,7 +13852,7 @@ var WasmProcess = class {
     const { guard: guard2 } = this.options;
     const inherited2 = req.orphan || req.contents !== void 0 || req.handle !== void 0;
     if (!guard2 || inherited2 || req.pin !== void 0) return;
-    const g = { fs: guard2.fs, dac: guard2.dac, cred: this.cred, pid: this.pid };
+    const g = { fs: guard2.fs, dac: guard2.dac, cred: this.cred, pid: this.pid, links: guard2.links };
     if (req.exclusive) return inParent(g, "open", req.path);
     if (req.created && guard2.created?.take(req.path)) return;
     const access2 = req.flags & WRITE_ACCESS;
@@ -13435,6 +13900,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;
@@ -13443,7 +13911,7 @@ var WasmProcess = class {
   }
   guarded() {
     const { guard: guard2 } = this.options;
-    return guard2 && { fs: guard2.fs, dac: guard2.dac, cred: this.cred, pid: this.pid };
+    return guard2 && { fs: guard2.fs, dac: guard2.dac, cred: this.cred, pid: this.pid, links: guard2.links };
   }
   ttyOwner() {
     return { uid: this.cred.euid, gid: this.cred.egid, mode: TTY_MODE };
@@ -13773,7 +14241,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) {
@@ -14169,6 +14638,7 @@ function processInit(opts, sab, umask, cred, lane) {
     umask,
     cred,
     ...opts.owners ? { owners: true } : {},
+    ...opts.links !== void 0 ? { links: true } : {},
     ...opts.ppid !== void 0 ? { ppid: opts.ppid } : {}
   };
   if (opts.program.abi === "js") {
@@ -14196,6 +14666,7 @@ function holdingToken(opts, holds, caller) {
   return mintSyncFsToken({
     ...opts.owners ? caller : {},
     ...opts.dac ? { dac: opts.dac, pid: opts.pid, created: caller.created } : {},
+    ...opts.links !== void 0 ? { links: opts.links } : {},
     ...opts.fresh ? { fresh: (path) => opts.fresh?.(path, caller.umask()) } : {},
     fs: opts.fs,
     cwd: opts.cwd,
@@ -14209,6 +14680,9 @@ function holdingToken(opts, holds, caller) {
     renamed: (from, to) => holds.renamed(from, to)
   });
 }
+function linksOf(opts) {
+  return opts.links === void 0 ? {} : { links: opts.links };
+}
 function clipboardName(opts) {
   return opts.program.abi === "js" ? {} : { clipboardName: opts.argv0 };
 }
@@ -14220,7 +14694,7 @@ function processOptions(opts, header3, hooks, created3) {
     ...opts.outputFilter ? { outputFilter: opts.outputFilter } : {},
     ...opts.clipboard ? { clipboard: opts.clipboard, ...clipboardName(opts) } : {},
     ...opts.readonlyAt ? { readonlyAt: opts.readonlyAt } : {},
-    ...opts.dac ? { guard: { dac: opts.dac, fs: opts.fs, created: created3 } } : {},
+    ...opts.dac ? { guard: { dac: opts.dac, fs: opts.fs, created: created3, ...linksOf(opts) } } : {},
     ...opts.identity ? { identity: opts.identity } : {},
     ...opts.onSyscall ? { onSyscall: opts.onSyscall } : {},
     ...opts.settling ? { settling: opts.settling } : {},
@@ -14266,6 +14740,7 @@ function threadInit(opts, program, sab, cred, thread, main) {
     sab,
     cred: copyCred(cred),
     owners: opts.owners === true,
+    ...opts.links !== void 0 ? { links: true } : {},
     ...opts.ppid !== void 0 ? { ppid: opts.ppid } : {},
     thread,
     signals: main
@@ -17566,6 +18041,9 @@ var SUDO_SOURCE = [
 ].join("\n");
 
 // src/launcher.ts
+function linksOf2(req) {
+  return req.links === void 0 ? {} : { links: req.links };
+}
 var COMMAND2 = /^\/(?:usr\/)?bin\/([^/]+)$/;
 var PACKAGE_ROOT = /^(.*\/node_modules\/(?:@[^/]+\/)?[^/]+)\//;
 var ENV_REFERENCE = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}/g;
@@ -17741,6 +18219,7 @@ var Launcher = class {
   warned = /* @__PURE__ */ new Set();
   compiled = /* @__PURE__ */ new Map();
   texts = /* @__PURE__ */ new Map();
+  revocations = 0;
   integrity;
   scannedFs;
   get scanned() {
@@ -17753,6 +18232,7 @@ var Launcher = class {
   described = /* @__PURE__ */ new Map();
   creds = /* @__PURE__ */ new Map();
   tags = /* @__PURE__ */ new Map();
+  links = /* @__PURE__ */ new Map();
   freshModules = new FreshModules();
   granted = /* @__PURE__ */ new Map();
   users;
@@ -17766,6 +18246,7 @@ var Launcher = class {
   );
   net = new LoopbackNet();
   cdp;
+  facades;
   ca;
   transport;
   uplink;
@@ -17840,10 +18321,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);
@@ -17858,6 +18345,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()),
@@ -18055,14 +18543,16 @@ var Launcher = class {
     }
     const path = this.fs.resolvePath(cwd, file);
     const glue = await followLinks(this.base, path);
-    const linked = COMMAND2.exec(glue)?.[1];
-    if (linked !== void 0) {
-      const target = await this.resolve(`/bin/${linked}`, argv0, cwd);
-      const byPath = !COMMAND2.test(path) && (await this.commands()).get(linked)?.argv0Path === true;
+    const asked = glue === path ? {} : { asked: path };
+    const linked2 = COMMAND2.exec(glue)?.[1];
+    if (linked2 !== void 0) {
+      const found = await this.resolve(`/bin/${linked2}`, argv0, cwd);
+      const target = found && { ...found, ...asked };
+      const byPath = !COMMAND2.test(path) && (await this.commands()).get(linked2)?.argv0Path === true;
       return target && byPath ? { ...target, argv0: path } : target;
     }
     const own = await this.commandAt(glue, scope);
-    if (own) return own.script ? void 0 : targetOf(own);
+    if (own) return own.script ? void 0 : { ...targetOf(own), ...asked };
     const head = await this.head(glue);
     if (!head) return void 0;
     if (isWasm(head)) {
@@ -18070,13 +18560,14 @@ var Launcher = class {
         abi: "wasi",
         glue,
         wasm: glue,
-        argv0: baseName(argv0 || file).replace(/\.wasm$/, "")
+        argv0: baseName(argv0 || file).replace(/\.wasm$/, ""),
+        ...asked
       };
     }
     if (interpreter(head) !== "node") return void 0;
     const wasm = modulePath(glue);
     if (!await this.base.exists(wasm)) return void 0;
-    return { abi: "emscripten", glue, wasm, argv0: baseName(argv0 || file) };
+    return { abi: "emscripten", glue, wasm, argv0: baseName(argv0 || file), ...asked };
   }
   async head(path) {
     try {
@@ -18094,6 +18585,8 @@ var Launcher = class {
   async interpreted(file, argv, cwd, scope, depth = 0) {
     const command = await this.scriptCommand(file, cwd, scope);
     const script = command?.script ?? this.fs.resolvePath(cwd, file);
+    const byPath = command && file.includes("/") && !COMMAND2.test(file);
+    const named = byPath ? { [script]: this.fs.resolvePath(cwd, file) } : {};
     const head = await this.head(script);
     if (!head) return void 0;
     const binfmt = isWasm(head) ? void 0 : binfmtOf(await this.interpreters(scope), script);
@@ -18116,7 +18609,8 @@ var Launcher = class {
         target: withScriptEnv(inner.target, command),
         via,
         sources,
-        ...bins.length > 0 ? { bins } : {}
+        ...bins.length > 0 ? { bins } : {},
+        asked: { ...inner.asked, ...named }
       };
     }
     const target = withScriptEnv(found, command);
@@ -18125,7 +18619,8 @@ var Launcher = class {
       args: [...target.prefix ?? [], ...passed],
       via: [interp],
       sources: [script],
-      ...command?.bin ? { bins: [script] } : {}
+      ...command?.bin ? { bins: [script] } : {},
+      asked: named
     };
   }
   async plan(file, argv, cwd, scope, argv0) {
@@ -18139,7 +18634,14 @@ var Launcher = class {
   async mayExec(cred, req, planned) {
     const { dac } = this;
     if (!dac) return;
-    const g = { fs: this.fs, cred, pid: req.pid, dac, tag: req.tag };
+    const g = {
+      fs: this.fs,
+      cred,
+      pid: req.pid,
+      dac,
+      tag: req.tag,
+      links: this.links.get(req.pid)
+    };
     const byPath = (file) => file.includes("/") && !COMMAND2.test(file);
     if (byPath(req.file)) {
       const path = this.fs.resolvePath(req.cwd, req.file);
@@ -18296,8 +18798,8 @@ var Launcher = class {
       readFile: (path) => this.integrity ? this.text(path, KERNEL_CALLER) : fs.readFile(path)
     });
   }
-  async cacheKey(path) {
-    const verified = await this.integrity?.key(path);
+  async cacheKey(path, asked) {
+    const verified = await this.integrity?.key(path, asked);
     if (verified !== void 0) return verified;
     const st = await this.base.stat(path);
     return `${path}:${st.size}:${st.mtime.getTime()}`;
@@ -18306,30 +18808,31 @@ var Launcher = class {
     const plain = () => fs.readFileBuffer(path);
     return this.integrity ? this.integrity.read(path, caller, plain) : plain();
   }
-  keyed(path, caller) {
+  keyed(path, caller, asked) {
     const plain = async () => this.base.readFileBuffer(path);
-    return this.integrity ? this.integrity.readKeyed(path, caller, plain) : plain().then((bytes) => ({ bytes }));
+    return this.integrity ? this.integrity.readKeyed(path, caller, plain, asked) : plain().then((bytes) => ({ bytes }));
   }
   cached(cache, key, load) {
     const hit = cache.get(key);
     if (hit !== void 0) return hit;
+    const revocations = this.revocations;
     const loading2 = load();
     const found = loading2.then(({ value }) => value);
     cache.set(key, found);
-    loading2.then(
-      (done4) => {
-        if (done4.key === key || done4.key === void 0 && !key.includes("\0")) return;
-        if (cache.get(key) === found) cache.delete(key);
-        if (done4.key !== void 0) cache.set(done4.key, found);
-      },
-      () => cache.delete(key)
-    );
+    const drop = () => {
+      if (cache.get(key) === found) cache.delete(key);
+    };
+    loading2.then((done4) => {
+      if (done4.key === key || done4.key === void 0 && !key.includes("\0")) return;
+      drop();
+      if (done4.key !== void 0 && revocations === this.revocations) cache.set(done4.key, found);
+    }, drop);
     return found;
   }
-  async module(path, caller) {
-    const key = await this.cacheKey(path);
+  async module(path, caller, asked) {
+    const key = await this.cacheKey(path, asked);
     return this.cached(this.compiled, key, async () => {
-      const { bytes, key: read } = await this.keyed(path, caller);
+      const { bytes, key: read } = await this.keyed(path, caller, asked);
       const memory = importedMemory(bytes);
       const foreign = foreignImports(bytes);
       const compiled = await WebAssembly.compile(bytes);
@@ -18338,22 +18841,30 @@ var Launcher = class {
   }
   async checkedSources(planned, caller) {
     const { target } = planned;
-    const files = [target.wasm, target.glue, target.imports, ...planned.sources ?? []];
+    const files = [
+      target.wasm,
+      target.glue,
+      target.imports,
+      target.asked,
+      ...planned.sources ?? []
+    ];
     const manifests = /* @__PURE__ */ new Set();
     for (const file of files) {
       const root = file === void 0 ? void 0 : PACKAGE_ROOT.exec(file)?.[1];
       if (root !== void 0) manifests.add(`${root}/package.json`);
     }
-    for (const source of planned.sources ?? []) await this.text(source, caller);
+    for (const source of planned.sources ?? []) {
+      await this.text(source, caller, planned.asked?.[source]);
+    }
     for (const manifest of manifests) {
       if (await this.base.exists(manifest)) await this.text(manifest, caller);
     }
   }
-  async text(path, caller) {
+  async text(path, caller, asked) {
     if (!this.integrity) return this.base.readFile(path);
-    const key = await this.cacheKey(path);
+    const key = await this.cacheKey(path, asked);
     return this.cached(this.texts, key, async () => {
-      const { bytes, key: read } = await this.keyed(path, caller);
+      const { bytes, key: read } = await this.keyed(path, caller, asked);
       return { value: new TextDecoder().decode(bytes), key: read };
     });
   }
@@ -18370,17 +18881,18 @@ var Launcher = class {
     if (target.abi === "js" && target.wasm === SUDO_PATH) {
       return { abi: "js", glue: SUDO_SOURCE, path: SUDO_PATH };
     }
+    const { asked } = target;
     if (target.abi === "js") {
-      return { abi: "js", glue: await this.text(target.wasm, caller), path: target.wasm };
+      return { abi: "js", glue: await this.text(target.wasm, caller, asked), path: target.wasm };
     }
     if (target.abi !== "wasi") {
       const [glue, { module: module2 }] = await Promise.all([
-        this.text(target.glue, caller),
-        this.module(target.wasm, caller)
+        this.text(target.glue, caller, asked),
+        this.module(target.wasm, caller, asked && modulePath(asked))
       ]);
       return { glue, module: module2 };
     }
-    const { module, memory, foreign } = await this.module(target.wasm, caller);
+    const { module, memory, foreign } = await this.module(target.wasm, caller, asked);
     const names = env.SLICC_WASM_BACKTRACE === "1" ? await this.names(target.wasm, module) : void 0;
     const imports = target.imports ? await this.text(target.imports, caller) : void 0;
     return {
@@ -18421,6 +18933,10 @@ var Launcher = class {
     const inherited2 = req.ppid !== void 0 ? this.scrubs.get(req.ppid) : void 0;
     return req.scrub ? [...inherited2 ?? [], req.scrub] : inherited2;
   }
+  marks(pid, req) {
+    if (req.tag !== void 0) this.tags.set(pid, req.tag);
+    if (req.links !== void 0) this.links.set(pid, req.links);
+  }
   start(req) {
     this.sampling();
     if (req.pgid !== void 0 && this.jobs.sessionOf(req.pgid) === void 0) {
@@ -18453,6 +18969,7 @@ var Launcher = class {
       cred: req.cred,
       ...this.owners && req.program.abi === "wasi" ? { fresh: (path, umask) => this.freshModules.add(path, umask, pid) } : {},
       ...this.owners ? { owners: true } : {},
+      ...linksOf2(req),
       sealed: this.sealed,
       ...scrubs ? { outputFilter: (file) => scrubbedAll(file, scrubs) } : {},
       clipboard: this.clipboard,
@@ -18500,7 +19017,7 @@ var Launcher = class {
     if (scrubs) this.scrubs.set(pid, scrubs);
     const { cred } = req;
     this.creds.set(pid, () => handle.cred?.() ?? copyCred(cred));
-    if (req.tag !== void 0) this.tags.set(pid, req.tag);
+    this.marks(pid, req);
     if (req.ppid !== void 0 && this.controlsJobs(req.ppid)) this.settling.started(pid, req.ppid);
     this.jobs.add(pid, req.ppid, (sig) => handle.signal(sig), terminal);
     if (req.exec && req.ppid !== void 0) this.jobs.exec(req.ppid, pid, true);
@@ -18553,6 +19070,7 @@ var Launcher = class {
     this.childTimes.delete(pid);
     this.creds.delete(pid);
     this.tags.delete(pid);
+    this.links.delete(pid);
     this.granted.delete(pid);
   }
   reaped(pid, parent) {
@@ -18728,6 +19246,7 @@ var Launcher = class {
         umask: this.umaskOf(ppid),
         cred,
         tag: this.tagOf(ppid),
+        links: grant ? grant.cred.euid : this.links.get(ppid),
         ...group,
         ...exec
       });
@@ -18760,6 +19279,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);
@@ -18789,7 +19311,8 @@ var Launcher = class {
         blocked: this.blockedBy(ppid),
         umask: this.umaskOf(ppid),
         cred: this.credOf(ppid),
-        tag: this.tagOf(ppid)
+        tag: this.tagOf(ppid),
+        links: this.links.get(ppid)
       })
     );
   }
@@ -18969,6 +19492,23 @@ var Launcher = class {
       }
     };
   }
+  async revokeIntegrity(path) {
+    if (path !== void 0 && (typeof path !== "string" || !path.startsWith("/"))) {
+      throw new TypeError("integrity.revoke takes an absolute path");
+    }
+    if (!this.integrity) return;
+    const at = path === void 0 ? void 0 : normalizePath(path);
+    const real = at && await this.base.realpath?.(at, true).catch(() => void 0);
+    const roots = [at, real].filter((p) => p !== void 0);
+    this.revocations++;
+    const hit = (key) => key.includes("\0") && (at === void 0 || key.split("\0").slice(0, 2).some((part) => isProtected(roots, part)));
+    for (const cache of [this.compiled, this.texts]) {
+      for (const key of [...cache.keys()]) if (hit(key)) cache.delete(key);
+    }
+    if (at === void 0) this.integrity.forget();
+    for (const root of roots) this.integrity.forget(root);
+    this.resetCatalogs();
+  }
   attest(path) {
     return attest(this.rootFs, path, {
       users: this.usersMode,
@@ -19413,6 +19953,20 @@ function cdpOption(req, port) {
     )
   };
 }
+function pageHooks(req, port) {
+  return { ...cdpOption(req, port), ...facadesOption(req, port) };
+}
+function facadesOption(req, port) {
+  if (!req.facades) return {};
+  const hook = portFacadeHook(
+    (request2, facade) => port.postMessage({ facadeOpen: request2, port: facade }, [facade])
+  );
+  const facades = {};
+  for (const [name2, spec] of Object.entries(req.facades)) {
+    facades[name2] = { port: spec.port, ...spec.hook ? { hook } : {} };
+  }
+  return { facades };
+}
 function remotes(port, req) {
   return {
     ...req.transport ? { transport: new RemoteTransport(port, req.transport) } : {},
@@ -19466,7 +20020,8 @@ var ATTEST_OPS = /* @__PURE__ */ new Set([
   "attest",
   "watch-files",
   "unwatch-files",
-  "chmod"
+  "chmod",
+  "integrity-revoke"
 ]);
 function isAttestRequest(req) {
   return ATTEST_OPS.has(req.op);
@@ -19484,6 +20039,7 @@ function attestOps(port) {
   return async (l, req) => {
     if (req.op === "attest") return l.attest(req.path);
     if (req.op === "chmod") return l.fs.chmod(req.path, modeOption(req.mode)).then(() => true);
+    if (req.op === "integrity-revoke") return l.revokeIntegrity(req.path).then(() => true);
     if (req.op === "unwatch-files") {
       watches.get(req.watch)?.();
       return watches.delete(req.watch);
@@ -19624,7 +20180,7 @@ function serveKernel(port, deps) {
         ...media ? { media } : {},
         onMountPending: (medium) => port.postMessage({ medium }),
         ...req.hostfs ? { hostfs: askGrant } : {},
-        ...cdpOption(req, port),
+        ...pageHooks(req, port),
         ...mountPolicy(req.processMounts),
         caStore: caStore(deps.metadata ? caDb(req) : false)
       });