@ai-ecoverse/slicc-kernel 1.152.1 → 1.153.0

package/dist/kernel-worker.js

@@ -1922,9 +1922,9 @@ var OpfsFs = class {
     this.lookups++;
     if (split(path).length === 0) return this.root;
     const cached = this.files.get(path);
-    const fresh2 = cached && performance.now() - (this.found.get(cached) ?? -CHECK_MS) < CHECK_MS;
-    if (cached && !fresh2) this.files.delete(path);
-    if (cached && fresh2) {
+    const fresh3 = cached && performance.now() - (this.found.get(cached) ?? -CHECK_MS) < CHECK_MS;
+    if (cached && !fresh3) this.files.delete(path);
+    if (cached && fresh3) {
       if (this.glanced(cached)) return this.remember(path, cached);
       try {
         await this.glance(cached);
@@ -2142,8 +2142,8 @@ var OpfsFs = class {
   glanced(handle) {
     if (this.exact > 0) return void 0;
     const seen = this.glances.get(handle);
-    const fresh2 = seen && seen.changes === this.changes && this.recent(seen, GLANCE_LOOKUPS);
-    return fresh2 ? seen.file : void 0;
+    const fresh3 = seen && seen.changes === this.changes && this.recent(seen, GLANCE_LOOKUPS);
+    return fresh3 ? seen.file : void 0;
   }
   async glance(handle) {
     const at = performance.now();
@@ -2333,13 +2333,13 @@ var OpfsFs = class {
   async keptFor(path) {
     const at = normalizePath(path);
     const cached = this.files.get(at);
-    const fresh2 = cached && performance.now() - (this.found.get(cached) ?? -CHECK_MS) < CHECK_MS;
-    const [target, existed] = fresh2 ? [at, true] : await this.writeTarget(path);
+    const fresh3 = cached && performance.now() - (this.found.get(cached) ?? -CHECK_MS) < CHECK_MS;
+    const [target, existed] = fresh3 ? [at, true] : await this.writeTarget(path);
     if (!existed) return [void 0, target, false];
     this.refuse(target);
     const [entry] = await this.meta.get([target]);
     if (entry?.fifo || entry?.socket) throw fsError("ENXIO", path);
-    const kept = fresh2 ? cached : this.files.get(target);
+    const kept = fresh3 ? cached : this.files.get(target);
     const usable2 = kept && performance.now() - (this.found.get(kept) ?? -CHECK_MS) < CHECK_MS;
     return [usable2 ? kept : void 0, target, true];
   }
@@ -4520,6 +4520,102 @@ function portCdpHook(ask, gone) {
   });
 }
 
+// src/embedder-relay.ts
+function fresh2(bytes) {
+  return bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength ? bytes : bytes.slice();
+}
+function embedderAsker(port) {
+  const asks = /* @__PURE__ */ new Map();
+  let next3 = 0;
+  const post = (message3, transfer = []) => port.postMessage({ embedder: message3 }, transfer);
+  const push = (asked, item) => {
+    asked.chunks.push(item);
+    asked.wake?.();
+  };
+  const reply = (id2, asked) => new ReadableStream(
+    {
+      pull: async (controller) => {
+        if (asked.chunks.length === 0) {
+          post({ id: id2, pull: true });
+          await new Promise((resolve2) => {
+            asked.wake = resolve2;
+          });
+        }
+        const item = asked.chunks.shift();
+        if (item instanceof Uint8Array) controller.enqueue(item);
+        else if (item === null || item === void 0) {
+          asks.delete(id2);
+          controller.close();
+        } else {
+          asks.delete(id2);
+          controller.error(Object.assign(new Error(item.message), { name: item.name }));
+        }
+      },
+      cancel: (reason) => {
+        asks.delete(id2);
+        post({ id: id2, cancel: String(reason ?? "closed") });
+      }
+    },
+    { highWaterMark: 0 }
+  );
+  const sendBody = async (id2, asked) => {
+    const got = await asked.body.read().catch(() => ({ done: true, value: void 0 }));
+    if (got.done) post({ id: id2, bodyEnd: true });
+    else {
+      const bytes = fresh2(got.value);
+      post({ id: id2, body: bytes }, [bytes.buffer]);
+    }
+  };
+  const hookFor = (client, kinds) => ({
+    kinds,
+    handle: async (request3) => {
+      const id2 = ++next3;
+      const asked = {
+        ready: Promise.withResolvers(),
+        chunks: [],
+        wake: void 0,
+        body: request3.body.getReader(),
+        progress: request3.progress
+      };
+      asks.set(id2, asked);
+      const cancel = () => {
+        asks.delete(id2);
+        post({
+          id: id2,
+          cancel: String(request3.signal.reason?.message ?? "closed")
+        });
+        asked.ready.reject(request3.signal.reason);
+        push(asked, { name: "AbortError", message: "cancelled" });
+      };
+      request3.signal.addEventListener("abort", cancel, { once: true });
+      const { kind, options, stamp } = request3;
+      post({ ask: { id: id2, client, kind, options, stamp } });
+      await asked.ready.promise;
+      return reply(id2, asked);
+    }
+  });
+  const answer2 = (message3) => {
+    const asked = asks.get(message3.id);
+    if (!asked) return;
+    if ("ready" in message3) asked.ready.resolve();
+    else if ("chunk" in message3) push(asked, message3.chunk);
+    else if ("done" in message3) push(asked, null);
+    else if ("error" in message3) {
+      asked.ready.reject(
+        Object.assign(new Error(message3.error.message), { name: message3.error.name })
+      );
+      asks.delete(message3.id);
+      void asked.body.cancel(message3.error.message).catch(() => void 0);
+      push(asked, message3.error);
+    } else if ("progress" in message3) asked.progress(message3.progress);
+    else void sendBody(message3.id, asked);
+  };
+  return { hookFor, answer: answer2 };
+}
+function embedderReplyOf(data) {
+  return data?.embedderReply;
+}
+
 // src/facade/port.ts
 var FACADE_GONE = "the facade host is gone";
 function portFacadeHook(ask, gone) {
@@ -5347,6 +5443,7 @@ function kernelFdKind(file) {
   if (file.tty) return "tty";
   if (file.sealed) return "sealed";
   if (file.clipboard) return "clipboard";
+  if (file.embedder) return "embedder";
   return file.seek ? "file" : "stream";
 }
 var FdTable = class _FdTable {
@@ -7231,7 +7328,7 @@ var UserDb = class {
       joined(name2, extra);
       group.push({ name: name2, gid: uid, members: [] });
       passwd.push(row);
-      const fresh2 = !await this.fs.exists(home);
+      const fresh3 = !await this.fs.exists(home);
       await this.fs.mkdir(home, { recursive: true });
       try {
         await this.provision(row, this.umaskFor(options), shared);
@@ -7239,7 +7336,7 @@ var UserDb = class {
         await this.fs.mkdir("/etc", { recursive: true });
         await this.commit(formatPasswd(passwd), formatGroup(group));
       } catch (err) {
-        if (fresh2) await this.fs.rm(home, { recursive: true, force: true });
+        if (fresh3) await this.fs.rm(home, { recursive: true, force: true });
         throw err;
       }
       remember();
@@ -7303,7 +7400,7 @@ var UserDb = class {
 };
 
 // src/client/protocol.ts
-var PROTOCOL = [1, 12];
+var PROTOCOL = [1, 13];
 var FS_METHODS = [
   "readFile",
   "writeFile",
@@ -7470,14 +7567,15 @@ async function runAs(l, self, requested) {
 function clientCred(self) {
   return self ? credOf(self) : copyCred(ROOT);
 }
-async function runTagged(l, self, options, tag) {
+async function runTagged(l, self, options, tag, session = -1) {
   tagOption(options.tag);
   const tags = withTag(withTag(void 0, tag), options.tag);
   return {
     user: await runAs(l, self, options.user),
     tag,
     tags,
-    tagBase: tag === void 0 ? 0 : 1
+    tagBase: tag === void 0 ? 0 : 1,
+    session
   };
 }
 function processes(l, self) {
@@ -7558,10 +7656,12 @@ function facadeRegistry(send2, gone) {
     }
   };
 }
-function hostRegistries(send2, gone) {
+function hostRegistries(send2, gone, port) {
   const cdps = cdpRegistry(send2, gone);
   const facades = facadeRegistry(send2, gone);
+  const requests = requestBinding(send2, port);
   return {
+    requests,
     answer(l, req) {
       if (req.op === "serve-cdp") return cdps.serve(l, req);
       if (req.op === "unserve-cdp") return cdps.drop(req.registration);
@@ -7569,6 +7669,7 @@ function hostRegistries(send2, gone) {
       return facades.drop(req.registration);
     },
     close() {
+      requests.close();
       cdps.close();
       facades.close();
     }
@@ -7603,6 +7704,28 @@ var TRAITS_WATCH = -1;
 function traitsWatch(launcher, transport, send2) {
   return launcher.onTraits(() => send2({ traits: transport.traits }));
 }
+function requestBinding(send2, port) {
+  const asker = embedderAsker({ postMessage: (m, t) => send2(m, t) });
+  let unbind;
+  port.addEventListener("message", (event) => {
+    const reply = embedderReplyOf(event.data);
+    if (reply) asker.answer(reply);
+  });
+  return {
+    async accept(host, hello) {
+      if (!hello.requests) return void 0;
+      if (!host.attachRequests || host.session === void 0)
+        return "EPERM: this port may not answer requests";
+      const launcher = await host.launcher();
+      unbind = launcher.embedder.register(
+        host.session,
+        asker.hookFor(host.session, hello.requests)
+      );
+      return void 0;
+    },
+    close: () => unbind?.()
+  };
+}
 function serveClient(port, host) {
   let state = "new";
   let self;
@@ -7617,7 +7740,7 @@ function serveClient(port, host) {
     if (state !== "closed") port.postMessage(message3, transfer);
   };
   const reply = (id2, body, transfer) => send2({ id: id2, ...body }, transfer);
-  const hosts = hostRegistries(send2, ended.promise);
+  const hosts = hostRegistries(send2, ended.promise, port);
   function detach(kill = false, bye = "the slicc-kernel detached this client") {
     if (state === "closed") return;
     send2({ bye });
@@ -7634,7 +7757,7 @@ function serveClient(port, host) {
     ended.resolve();
   }
   async function hello(message3) {
-    const refused3 = versionError(message3.protocol);
+    const refused3 = versionError(message3.protocol) ?? await hosts.requests.accept(host, message3);
     if (refused3) {
       send2({ hello: { protocol: PROTOCOL, error: refused3 } });
       detach();
@@ -7659,7 +7782,7 @@ function serveClient(port, host) {
   async function terminal(req, l) {
     const session = await l.openTerminal(req.argv, {
       ...req.options,
-      ...await runTagged(l, self, req.options, host.tag),
+      ...await runTagged(l, self, req.options, host.tag, host.session),
       onData: (bytes) => reply(req.id, { fd: 1, bytes: bytes.slice() })
     });
     if (state === "closed") {
@@ -7682,7 +7805,7 @@ function serveClient(port, host) {
     let leader;
     const result = await l.run(req.argv, {
       ...req.options,
-      ...await runTagged(l, self, req.options, host.tag),
+      ...await runTagged(l, self, req.options, host.tag, host.session),
       collect: false,
       onStdout: out(1),
       onStderr: out(2),
@@ -7926,7 +8049,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.152.1" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.153.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
@@ -8771,9 +8894,9 @@ var Crontabs = class {
     const json5 = JSON.stringify({ v: TAGS_VERSION, ...kept });
     if (json5 === await fs.readFile(TAGS_PATH).catch(() => "")) return;
     const owner = owners ? { uid: 0, gid: 0, mode: 384 } : void 0;
-    const fresh2 = `${TAGS_PATH}.${crypto.randomUUID()}.new`;
-    await fs.writeFile(fresh2, json5, owner);
-    await fs.rename(fresh2, TAGS_PATH);
+    const fresh3 = `${TAGS_PATH}.${crypto.randomUUID()}.new`;
+    await fs.writeFile(fresh3, json5, owner);
+    await fs.rename(fresh3, TAGS_PATH);
   }
   async install(path, target, text, caller) {
     if (text.length > CRONTAB_MAX) return { error: "crontab: the table is too long" };
@@ -8787,11 +8910,11 @@ var Crontabs = class {
       await fs.mkdir(SPOOL_DIR, { recursive: true });
       if (owners) await fs.chown?.(SPOOL_DIR, { uid: 0, gid: 0, mode: 448, follow: false });
     }
-    const fresh2 = `${SPOOL_DIR}/.${target.name}.${crypto.randomUUID()}.new`;
+    const fresh3 = `${SPOOL_DIR}/.${target.name}.${crypto.randomUUID()}.new`;
     const owner = owners ? { uid: target.uid, gid: target.gid, mode: 384 } : void 0;
     await this.retag(path, text, caller);
-    await fs.writeFile(fresh2, text, owner);
-    await fs.rename(fresh2, path);
+    await fs.writeFile(fresh3, text, owner);
+    await fs.rename(fresh3, path);
     return { text: "" };
   }
 };
@@ -8803,6 +8926,7 @@ var PathMarks = class {
   floor = 0;
   touched = /* @__PURE__ */ new Map();
   flying = /* @__PURE__ */ new Map();
+  waiting = /* @__PURE__ */ new Set();
   generation() {
     return this.gen;
   }
@@ -8835,10 +8959,22 @@ var PathMarks = class {
         const n = (this.flying.get(p) ?? 1) - 1;
         if (n > 0) this.flying.set(p, n);
         else this.flying.delete(p);
+        for (const wake of [...this.waiting]) wake();
         this.touch(p);
       }
     }
   }
+  async landed(path) {
+    if (!this.inFlight(path)) return;
+    await new Promise((resolve2) => {
+      const wake = () => {
+        if (this.inFlight(path)) return;
+        this.waiting.delete(wake);
+        resolve2();
+      };
+      this.waiting.add(wake);
+    });
+  }
   inFlight(path) {
     for (let p = path; this.flying.size > 0; p = parentOf5(p)) {
       if (this.flying.has(p)) return true;
@@ -9016,6 +9152,9 @@ var UnlinkedKeeper = class {
   changedSince(path, gen) {
     return this.marks.changedSince(path, gen);
   }
+  landed(path) {
+    return this.marks.landed(path);
+  }
   inFlight(path) {
     return this.marks.inFlight(path);
   }
@@ -9051,15 +9190,15 @@ var UnlinkedKeeper = class {
     const releases = [];
     const take = async () => {
       for (; ; ) {
-        const fresh2 = [...this.heldWithin(target).keys()].filter((path) => !paths.includes(path));
-        if (fresh2.length === 0) return;
-        fresh2.sort();
-        if (paths.some((path) => path > fresh2[0])) {
+        const fresh3 = [...this.heldWithin(target).keys()].filter((path) => !paths.includes(path));
+        if (fresh3.length === 0) return;
+        fresh3.sort();
+        if (paths.some((path) => path > fresh3[0])) {
           for (const release of releases.splice(0)) release();
-          fresh2.push(...paths.splice(0));
-          fresh2.sort();
+          fresh3.push(...paths.splice(0));
+          fresh3.sort();
         }
-        for (const path of fresh2) {
+        for (const path of fresh3) {
           paths.push(path);
           releases.push(await this.gate.acquire(path));
         }
@@ -9394,10 +9533,10 @@ var CronService = class {
     const text = JSON.stringify(stamp);
     const old = await fs.readFile(STAMP_PATH).catch(() => void 0);
     if (old === text || old === void 0 && text === EMPTY_STAMP) return;
-    const fresh2 = `${STAMP_PATH}.new`;
+    const fresh3 = `${STAMP_PATH}.new`;
     const owner = owners ? { uid: 0, gid: 0, mode: 384 } : void 0;
-    await fs.writeFile(fresh2, text, owner);
-    await fs.rename(fresh2, STAMP_PATH);
+    await fs.writeFile(fresh3, text, owner);
+    await fs.rename(fresh3, STAMP_PATH);
   }
   async load() {
     const { fs } = this.host;
@@ -10747,10 +10886,10 @@ var FreshModules = class {
     this.fresh.set(key, { umask: mask, pid, added: 0, setup: mask !== DEFAULT_UMASK });
   }
   forget(pid) {
-    for (const [path, fresh2] of this.fresh) if (fresh2.pid === pid) this.fresh.delete(path);
+    for (const [path, fresh3] of this.fresh) if (fresh3.pid === pid) this.fresh.delete(path);
   }
-  drop(fresh2) {
-    for (const [key, note] of [...this.fresh]) if (note === fresh2) this.fresh.delete(key);
+  drop(fresh3) {
+    for (const [key, note] of [...this.fresh]) if (note === fresh3) this.fresh.delete(key);
   }
   moved(from, to) {
     const source = normalizePath(from);
@@ -10759,10 +10898,10 @@ var FreshModules = class {
     for (const key of [...this.fresh.keys()]) {
       if (key === target || within5(key, target)) this.fresh.delete(key);
     }
-    for (const [key, fresh2] of [...this.fresh]) {
+    for (const [key, fresh3] of [...this.fresh]) {
       if (key !== source && !within5(key, source)) continue;
       this.fresh.delete(key);
-      this.fresh.set(target + key.slice(source.length), fresh2);
+      this.fresh.set(target + key.slice(source.length), fresh3);
     }
   }
   wrap(fs) {
@@ -10772,15 +10911,15 @@ var FreshModules = class {
     };
     const decide = async (given, known) => {
       const path = normalizePath(given);
-      const fresh2 = this.fresh.get(path);
-      if (!fresh2) return;
+      const fresh3 = this.fresh.get(path);
+      if (!fresh3) return;
       const bytes = known && known.length >= MAGIC.length ? known : await head(path);
-      const want = isModule(bytes) ? 73 & ~fresh2.umask : 0;
-      fresh2.setup = false;
-      if (want === fresh2.added) return;
+      const want = isModule(bytes) ? 73 & ~fresh3.umask : 0;
+      fresh3.setup = false;
+      if (want === fresh3.added) return;
       const mode = (await fs.stat(path)).mode & 4095;
-      await fs.chmod(path, mode & ~fresh2.added | want);
-      fresh2.added = want;
+      await fs.chmod(path, mode & ~fresh3.added | want);
+      fresh3.added = want;
     };
     const overrides = {
       writeFile: async (path, content, owner) => {
@@ -10793,9 +10932,9 @@ var FreshModules = class {
         }
       },
       chmod: async (path, mode) => {
-        const fresh2 = this.fresh.get(normalizePath(path));
-        if (fresh2?.setup && (mode & 4095) === (438 & ~fresh2.umask)) fresh2.setup = false;
-        else if (fresh2) this.drop(fresh2);
+        const fresh3 = this.fresh.get(normalizePath(path));
+        if (fresh3?.setup && (mode & 4095) === (438 & ~fresh3.umask)) fresh3.setup = false;
+        else if (fresh3) this.drop(fresh3);
         await fs.chmod(path, mode);
       },
       rm: async (path, options) => {
@@ -10812,8 +10951,8 @@ var FreshModules = class {
       link: async (from, to, follow2) => {
         await fs.link(from, to, follow2);
         const source = follow2 && fs.realpath ? await fs.realpath(from, true).catch(() => from) : from;
-        const fresh2 = this.fresh.get(normalizePath(source));
-        if (fresh2) this.fresh.set(normalizePath(to), fresh2);
+        const fresh3 = this.fresh.get(normalizePath(source));
+        if (fresh3) this.fresh.set(normalizePath(to), fresh3);
       }
     };
     const ranged2 = rangedOps(fs);
@@ -11131,7 +11270,7 @@ var FsWatchers = class {
     };
     const content = (run2, types) => async (...args) => {
       const at = normalizePath(args[0]);
-      const fresh2 = this.covers(at) && !await fs.exists(at).catch(() => true);
+      const fresh3 = this.covers(at) && !await fs.exists(at).catch(() => true);
       let done5 = false;
       try {
         await run2(...args);
@@ -11140,11 +11279,11 @@ var FsWatchers = class {
         const real = await realOf(at);
         const paths = real === at ? [at] : [at, real];
         this.report(paths);
-        if (done5) for (const type of types(fresh2, args)) this.emit(type, paths);
+        if (done5) for (const type of types(fresh3, args)) this.emit(type, paths);
       }
     };
-    const written2 = (fresh2) => fresh2 ? ["rename", "change"] : ["change"];
-    const overwritten = (fresh2, args) => fresh2 || args[1].length === 0 ? written2(fresh2) : ["change", "change"];
+    const written2 = (fresh3) => fresh3 ? ["rename", "change"] : ["change"];
+    const overwritten = (fresh3, args) => fresh3 || args[1].length === 0 ? written2(fresh3) : ["change", "change"];
     const reshaping = (run2) => async (...args) => {
       this.reshaped();
       try {
@@ -11171,14 +11310,14 @@ var FsWatchers = class {
             if (created4.length > 0 || !await fs.exists(ancestor)) created4.push(ancestor);
           }
         }
-        const fresh2 = !options?.recursive || this.typed.size > 0 && !await fs.exists(path);
+        const fresh3 = !options?.recursive || this.typed.size > 0 && !await fs.exists(path);
         let done5 = false;
         try {
           await fs.mkdir(path, options);
           done5 = true;
         } finally {
           this.report([...created4, path]);
-          if (done5) this.emit("rename", fresh2 ? [...created4, path] : created4);
+          if (done5) this.emit("rename", fresh3 ? [...created4, path] : created4);
         }
       },
       rm: reshaping(after(fs.rm.bind(fs), (path) => [path], "rename")),
@@ -11634,6 +11773,403 @@ var ClipboardBroker = class {
   }
 };
 
+// src/kernel/embedder.ts
+var EMBEDDER_PATH = "/dev/embedder";
+var EMBEDDER_HEADER_MAX = 64 * 1024;
+var EMBEDDER_WINDOW = 1024 * 1024;
+var EMBEDDER_BUDGET = 256 * 1024 * 1024;
+var EMBEDDER_PER_PROCESS = 16;
+var EMBEDDER_PROGRESS_PER_SECOND = 4;
+var KIND = /^[a-z][a-z0-9-]*(\.[a-z0-9-]+)*$/;
+var NL = 10;
+var READY2 = { readable: true, writable: true, hangup: false };
+function lineOf2(err) {
+  const text = err instanceof Error ? err.message : String(err);
+  return (text.split("\n")[0] ?? "").slice(0, 200);
+}
+var ERRNOS = {
+  NotAllowedError: "EACCES",
+  AbortError: "EACCES",
+  NotSupportedError: "ENOTSUP",
+  NotFoundError: "ENOENT"
+};
+function embedderFailure(err) {
+  if (err instanceof KernelError) return err;
+  const name2 = err?.name;
+  return new KernelError(ERRNOS[String(name2)] ?? "EIO", lineOf2(err));
+}
+function headerOf(bytes) {
+  let parsed2;
+  try {
+    parsed2 = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+  } catch {
+    throw new KernelError("EINVAL", "the request header is not JSON");
+  }
+  if (typeof parsed2 !== "object" || parsed2 === null || Array.isArray(parsed2))
+    throw new KernelError("EINVAL", "the request header is not an object");
+  const { kind, ...options } = parsed2;
+  if (typeof kind !== "string" || kind.length > 64 || !KIND.test(kind))
+    throw new KernelError("EINVAL", "the request has no valid kind");
+  return { kind, options };
+}
+function joined3(a, b) {
+  const out = new Uint8Array(a.length + b.length);
+  out.set(a);
+  out.set(b, a.length);
+  return out;
+}
+function aborted(signal) {
+  if (!signal) return void 0;
+  return new Promise((_, reject) => {
+    const stop = () => reject(new KernelError("EINTR"));
+    if (signal.aborted) stop();
+    else signal.addEventListener("abort", stop, { once: true });
+  });
+}
+async function interruptible2(work, signal) {
+  const stop = aborted(signal);
+  if (!stop) return work;
+  stop.catch(() => void 0);
+  return Promise.race([work, stop]);
+}
+var Budget2 = class {
+  used = 0;
+  limit;
+  constructor(limit) {
+    this.limit = limit;
+  }
+  take(n) {
+    if (this.used + n > this.limit) return false;
+    this.used += n;
+    return true;
+  }
+  give(n) {
+    this.used = Math.max(0, this.used - n);
+  }
+};
+var BodyPipe = class {
+  queue = [];
+  size = 0;
+  ended = false;
+  wake;
+  room;
+  stream;
+  constructor() {
+    this.stream = new ReadableStream(
+      {
+        pull: async (controller) => {
+          while (this.queue.length === 0 && !this.ended) {
+            await new Promise((resolve2) => {
+              this.wake = resolve2;
+            });
+          }
+          const next3 = this.queue.shift();
+          if (next3) {
+            this.size -= next3.length;
+            this.room?.();
+            controller.enqueue(next3);
+          } else controller.close();
+        }
+      },
+      { highWaterMark: 0 }
+    );
+  }
+  get full() {
+    return this.size >= EMBEDDER_WINDOW;
+  }
+  push(bytes) {
+    if (bytes.length === 0) return;
+    this.queue.push(bytes.slice());
+    this.size += bytes.length;
+    this.wake?.();
+  }
+  waitRoom() {
+    return new Promise((resolve2) => {
+      this.room = resolve2;
+    });
+  }
+  end() {
+    this.ended = true;
+    this.wake?.();
+    this.room?.();
+  }
+};
+function replyStream(reply) {
+  if (reply instanceof ReadableStream) return reply;
+  const bytes = typeof reply === "string" ? new TextEncoder().encode(reply) : reply instanceof Uint8Array ? reply : new Uint8Array(0);
+  return new ReadableStream({
+    start(controller) {
+      if (bytes.length > 0) controller.enqueue(bytes);
+      controller.close();
+    }
+  });
+}
+var Throttle = class {
+  window = 0;
+  count = 0;
+  allow(now) {
+    if (now - this.window >= 1e3) {
+      this.window = now;
+      this.count = 0;
+    }
+    this.count += 1;
+    return this.count <= EMBEDDER_PROGRESS_PER_SECOND;
+  }
+};
+var EmbedderChannel = class {
+  access;
+  owner;
+  caller;
+  broker;
+  header = new Uint8Array(0);
+  body;
+  reply;
+  replied;
+  rest;
+  done = false;
+  failure;
+  reported = false;
+  abort = new AbortController();
+  closed = false;
+  throttle = new Throttle();
+  constructor(broker, access2, caller) {
+    this.broker = broker;
+    this.access = access2;
+    this.caller = caller;
+    this.owner = caller.pid;
+  }
+  get dispatched() {
+    return this.body !== void 0;
+  }
+  fail(err) {
+    this.failure ??= embedderFailure(err);
+    return this.failure;
+  }
+  report(err) {
+    this.reported = true;
+    return this.fail(err);
+  }
+  async dispatch(bytes) {
+    const { kind, options } = headerOf(bytes);
+    const stamp = await this.broker.admit(kind, this.caller);
+    const hook = this.broker.hookFor(this.caller.client);
+    const body = new BodyPipe();
+    this.body = body;
+    const caller = this.caller;
+    const progress = (line) => {
+      if (this.throttle.allow(Date.now())) caller.progress(lineOf2(line));
+    };
+    const asked = Promise.resolve().then(
+      () => hook.handle({
+        kind,
+        options,
+        body: body.stream,
+        stamp,
+        signal: this.abort.signal,
+        progress
+      })
+    ).then((reply) => replyStream(reply).getReader());
+    this.replied = asked.catch((err) => {
+      body.end();
+      throw this.fail(err);
+    });
+    this.replied.catch(() => void 0);
+  }
+  async write(bytes, signal) {
+    if (this.access === "read") throw new KernelError("EBADF");
+    if (this.failure) throw this.report(this.failure);
+    if (this.reply || this.done) throw new KernelError("EBADF");
+    if (this.body) return this.writeBody(bytes, signal);
+    const at = bytes.indexOf(NL);
+    const head = at < 0 ? bytes : bytes.subarray(0, at);
+    if (this.header.length + head.length > EMBEDDER_HEADER_MAX)
+      throw this.report(new KernelError("EINVAL", "the request header is too long"));
+    this.header = joined3(this.header, head);
+    if (at < 0) return bytes.length;
+    try {
+      await this.dispatch(this.header);
+    } catch (err) {
+      throw this.report(err);
+    }
+    this.body?.push(bytes.subarray(at + 1));
+    return bytes.length;
+  }
+  async writeBody(bytes, signal) {
+    const body = this.body;
+    while (body.full && !this.failure) {
+      await interruptible2(body.waitRoom(), signal).catch((err) => {
+        this.cancel("interrupted");
+        throw err;
+      });
+    }
+    if (this.failure) throw this.report(this.failure);
+    body.push(bytes);
+    return bytes.length;
+  }
+  async readerOf(signal) {
+    if (this.reply) return this.reply;
+    if (!this.body) {
+      try {
+        await this.dispatch(this.header);
+      } catch (err) {
+        throw this.fail(err);
+      }
+    }
+    this.body?.end();
+    this.reply = await interruptible2(
+      this.replied,
+      signal
+    );
+    return this.reply;
+  }
+  async read(max, signal) {
+    if (this.access === "write") throw new KernelError("EBADF");
+    if (this.failure) throw this.report(this.failure);
+    if (this.done || max <= 0) return new Uint8Array(0);
+    try {
+      return await this.next(max, signal);
+    } catch (err) {
+      if (err instanceof KernelError && err.code === "EINTR") {
+        this.cancel("interrupted");
+        throw err;
+      }
+      throw this.report(err);
+    }
+  }
+  async next(max, signal) {
+    const reader = await this.readerOf(signal);
+    let chunk2 = this.rest;
+    this.rest = void 0;
+    if (!chunk2) {
+      const got = await interruptible2(reader.read(), signal);
+      if (got.done) {
+        this.done = true;
+        return new Uint8Array(0);
+      }
+      chunk2 = got.value;
+    }
+    if (chunk2.length > max) this.rest = chunk2.subarray(max);
+    return chunk2.subarray(0, max);
+  }
+  poll() {
+    return this.body?.full ? { ...READY2, writable: false } : READY2;
+  }
+  cancel(reason) {
+    if (this.abort.signal.aborted) return;
+    this.abort.abort(new DOMException(reason, "AbortError"));
+    this.body?.end();
+    void this.reply?.cancel(reason).catch(() => void 0);
+  }
+  async close() {
+    if (this.closed) return;
+    const signal = this.caller.closing();
+    this.closed = true;
+    try {
+      if (this.access === "read") return;
+      if (this.failure) {
+        if (this.reported) return;
+        throw this.report(this.failure);
+      }
+      if (this.access === "both" && this.dispatched) return;
+      if (!this.dispatched && this.header.length === 0) return;
+      await this.drain(signal);
+    } finally {
+      if (!this.done) this.cancel("closed");
+      this.broker.release(this);
+    }
+  }
+  async drain(signal) {
+    try {
+      const reader = await this.readerOf(signal);
+      for (; ; ) {
+        const got = await interruptible2(reader.read(), signal);
+        if (got.done) break;
+      }
+      this.done = true;
+    } catch (err) {
+      if (err instanceof KernelError && err.code === "EINTR") this.cancel("interrupted");
+      throw this.fail(err);
+    }
+  }
+};
+var EmbedderBroker = class {
+  users;
+  lookup;
+  hooks = /* @__PURE__ */ new Map();
+  budget;
+  open = /* @__PURE__ */ new Map();
+  tagsOf;
+  constructor(users, lookup2, tagsOf = () => void 0, budget = EMBEDDER_BUDGET) {
+    this.users = users;
+    this.tagsOf = tagsOf;
+    this.lookup = lookup2;
+    this.budget = new Budget2(budget);
+  }
+  register(client, hook) {
+    if (!hook) return () => void 0;
+    this.hooks.set(client, hook);
+    return () => {
+      if (this.hooks.get(client) === hook) this.hooks.delete(client);
+    };
+  }
+  hookFor(client) {
+    return this.hooks.get(client);
+  }
+  async allowed(policy, caller) {
+    if (caller.euid === 0 || caller.euid === caller.sessionUid) return true;
+    if (policy.group !== void 0) {
+      const gid = await this.lookup.groupId(policy.group);
+      if (gid !== void 0 && (caller.egid === gid || caller.groups.includes(gid))) return true;
+    }
+    for (const user of policy.users ?? []) {
+      const uid = typeof user === "number" ? user : await this.lookup.userId(user);
+      if (uid === caller.euid) return true;
+    }
+    return false;
+  }
+  async admit(kind, caller) {
+    const hook = this.hooks.get(caller.client);
+    if (!hook) throw new KernelError("ENOTSUP", "no page answers requests for this session");
+    const policy = Object.hasOwn(hook.kinds, kind) ? hook.kinds[kind] : void 0;
+    if (!policy) throw new KernelError("ENOTSUP", `this embedder does not answer ${kind}`);
+    if (this.users !== "off" && !await this.allowed(policy, caller))
+      throw new KernelError("EACCES", `${kind} is not allowed for this user`);
+    const tags = caller.tags;
+    return {
+      pid: caller.shownPid,
+      uid: caller.euid,
+      gid: caller.egid,
+      groups: [...caller.groups],
+      users: this.users,
+      kind,
+      ...tags?.length ? { tag: tags[0], tags: [...tags] } : {}
+    };
+  }
+  channel(access2, caller) {
+    const mine = this.open.get(caller.pid) ?? /* @__PURE__ */ new Set();
+    if (mine.size >= EMBEDDER_PER_PROCESS)
+      throw new KernelError("EMFILE", `at most ${EMBEDDER_PER_PROCESS} requests per process`);
+    if (!this.budget.take(2 * EMBEDDER_WINDOW))
+      throw new KernelError("EAGAIN", "the embedder request budget is spent");
+    const channel = new EmbedderChannel(this, access2, caller);
+    mine.add(channel);
+    this.open.set(caller.pid, mine);
+    return new OpenFile({
+      read: channel.read.bind(channel),
+      write: (bytes, signal) => channel.write(bytes, signal),
+      poll: () => channel.poll(),
+      close: () => channel.close(),
+      embedder: channel
+    });
+  }
+  release(channel) {
+    const mine = this.open.get(channel.owner);
+    if (!mine?.delete(channel)) return;
+    if (mine.size === 0) this.open.delete(channel.owner);
+    this.budget.give(2 * EMBEDDER_WINDOW);
+  }
+};
+
 // src/kernel/exec-ticket.ts
 var TICKET_ENV = "SLICC_SEALED_TICKET";
 var TICKET_TTL_MS = 3e4;
@@ -12170,6 +12706,9 @@ var HeldPaths = class extends Map {
   trust(handle, doubt) {
     if (this.doubted.get(handle) === doubt) this.doubted.delete(handle);
   }
+  pathOf(handle) {
+    return this.handles.get(handle);
+  }
   keptFor(handle) {
     return this.keptHandles.get(handle);
   }
@@ -12182,9 +12721,9 @@ var HeldPaths = class extends Map {
     return false;
   }
   keep(path, file) {
-    const fresh2 = this.handlesAt(path).filter((id2) => !this.keptHandles.has(id2));
-    for (const id2 of fresh2) this.keptHandles.set(id2, file);
-    this.uses.set(file, Math.max(fresh2.length, 1));
+    const fresh3 = this.handlesAt(path).filter((id2) => !this.keptHandles.has(id2));
+    for (const id2 of fresh3) this.keptHandles.set(id2, file);
+    this.uses.set(file, Math.max(fresh3.length, 1));
     this.unlinked.set(path, file);
   }
   unkeep(path, file) {
@@ -13380,8 +13919,8 @@ var MountFs = class _MountFs {
     }
     this.writable(mount, real);
     const { uid, gid, mode } = change;
-    const fresh2 = change.kind === "new" && { uid, gid, mode };
-    const set3 = fresh2 ? await this.driverOwner(found, real, fresh2, false) : change;
+    const fresh3 = change.kind === "new" && { uid, gid, mode };
+    const set3 = fresh3 ? await this.driverOwner(found, real, fresh3, false) : change;
     this.table.forget(mount, real);
     const attrs = Object.entries({ uid: set3.uid, gid: set3.gid, mode: set3.mode });
     await mount.conn.call({
@@ -13653,10 +14192,10 @@ async function runMkdir(entry, path, req) {
   const plain3 = plainDirMode(entry, req.mode);
   const parentsMode = !req.exclusive ? plainParentsMode(entry) : void 0;
   const fixParents = parentsMode !== void 0 ? await missingParents(fs, path, parentsMode) : void 0;
-  const fresh2 = plain3 !== void 0 && !await fs.exists(path);
+  const fresh3 = plain3 !== void 0 && !await fs.exists(path);
   await (req.exclusive ? mkdirExclusive(entry, path, req.mode) : fs.mkdir(path, mkdirOptions(entry, req.mode)));
   await fixParents?.();
-  if (fresh2) await fs.chmod(path, plain3);
+  if (fresh3) await fs.chmod(path, plain3);
   return done2;
 }
 async function shownAs(entry, path, st) {
@@ -14053,12 +14592,20 @@ async function linkedElsewhere(fs, path, from) {
   const source = from === void 0 ? void 0 : await fs.lstat(from).catch(() => void 0);
   return !(source && source.ino === st.ino && source.dev === st.dev);
 }
+async function gatedByHandle(entry, opEntry, path, req, opReq) {
+  const heldAt2 = () => req.handle === void 0 ? void 0 : opEntry.heldAt?.(req.handle);
+  if (req.handle !== void 0) await opEntry.replacements?.landed?.(heldAt2() ?? path);
+  const at = heldAt2() ?? path;
+  const serve = async () => run(opEntry, await keptOr(opEntry, at, req.handle), opReq);
+  return entry.gate ? entry.gate(at, serve) : serve();
+}
 async function keptOr(entry, path, handle) {
   if (handle !== void 0) {
     const hidden = entry.keptFor?.(handle)?.hidden;
     if (hidden !== void 0) return hidden;
-    await bound(entry, path, handle);
-    return path;
+    const at = entry.heldAt?.(handle) ?? path;
+    await bound(entry, at, handle);
+    return at;
   }
   const kept = entry.unlinked?.(path);
   return kept && !await entry.fs.exists(path) ? kept.hidden : path;
@@ -14251,8 +14798,7 @@ async function dispatchPath(entry, req) {
     if (entry.revoked?.(resolvedPath))
       return { ok: false, errno: "EIO", message: `${resolvedPath} was unmounted` };
     if (req.op === "write" && req.mode === 1 || UNLINKED_OPS.has(req.op)) {
-      const serve = async () => run(opEntry, await keptOr(opEntry, resolvedPath, req.handle), opReq);
-      return await (entry.gate ? entry.gate(resolvedPath, serve) : serve());
+      return await gatedByHandle(entry, opEntry, resolvedPath, req, opReq);
     }
     if (!entry.own || !OWN_OPS.has(req.op)) return await run(opEntry, resolvedPath, opReq);
     const target = resolvedArg2 ?? (TWO_PATHS.has(req.op) ? fs.resolvePath(cwd, req.arg2 ?? "") : resolvedPath);
@@ -14653,9 +15199,9 @@ var Pages = class {
       const page = (start2 + at) / PAGE;
       if (this.pages.has(page)) continue;
       const part = bytes.subarray(at, Math.min(at + PAGE, bytes.length));
-      const fresh2 = this.take(part.length);
-      fresh2.set(part);
-      this.pages.set(page, fresh2);
+      const fresh3 = this.take(part.length);
+      fresh3.set(part);
+      this.pages.set(page, fresh3);
     }
   }
   read(at, length2) {
@@ -16961,18 +17507,18 @@ var TlsEngine = class {
   chainFlags(store, chain2, hostname) {
     const verify = this.m._tls_chain_verify;
     if (!verify || chain2.length === 0) return void 0;
-    const joined4 = new Uint8Array(chain2.reduce((n, c) => n + c.length, 0));
+    const joined5 = new Uint8Array(chain2.reduce((n, c) => n + c.length, 0));
     let at = 0;
     for (const der2 of chain2) {
-      joined4.set(der2, at);
+      joined5.set(der2, at);
       at += der2.length;
     }
     const name2 = this.put(new TextEncoder().encode(hostname));
     try {
-      return this.withBytes(joined4, (p) => {
+      return this.withBytes(joined5, (p) => {
         const out = this.scratch;
         this.m.HEAPU8.fill(255, out, out + 4);
-        const ret = verify(store.ptr, p, joined4.length, name2, out);
+        const ret = verify(store.ptr, p, joined5.length, name2, out);
         const flags2 = new DataView(this.m.HEAPU8.buffer, out, 4).getUint32(0, true);
         if (ret === 0) return flags2 === 0 ? 0 : void 0;
         return ret === 1 && flags2 !== 0 ? flags2 : void 0;
@@ -19822,6 +20368,7 @@ function scrubbed(inner, scrubber, idleMs = SCRUB_IDLE_MS) {
     ...file.tty ? { tty: file.tty } : {},
     identity: file.identity ?? file,
     ...file.clipboard ? { clipboard: file.clipboard } : {},
+    ...file.embedder ? { embedder: file.embedder } : {},
     ...file.write ? {
       write: async (bytes, signal) => {
         await turn(signal);
@@ -19878,7 +20425,8 @@ function scrubStdio(fds, scrubber) {
   const stdio = stdioFiles(fds);
   for (const fd of fds.numbers()) {
     const original = fds.get(fd);
-    if (!stdio.has(original) && !original.file.tty && !original.file.clipboard) continue;
+    const named = original.file.tty || original.file.clipboard || original.file.embedder;
+    if (!stdio.has(original) && !named) continue;
     const known = wrapped.get(original);
     const flags2 = fds.statusFlags(fd);
     const wrapper = known ? known.retain() : scrubbed(original.retain(), scrubber);
@@ -19891,9 +20439,9 @@ function scrubStdio(fds, scrubber) {
 // src/kernel/net/sealed-scrubs.ts
 function addTo(tree2, host, secrets) {
   const entry = tree2.get(host) ?? { secrets: [], version: 0, scrubber: void 0 };
-  const fresh2 = secrets.filter((s) => !entry.secrets.some((e) => e.value === s.value));
-  if (fresh2.length === 0) return;
-  entry.secrets = [...entry.secrets, ...fresh2];
+  const fresh3 = secrets.filter((s) => !entry.secrets.some((e) => e.value === s.value));
+  if (fresh3.length === 0) return;
+  entry.secrets = [...entry.secrets, ...fresh3];
   entry.version += 1;
   entry.scrubber = void 0;
   tree2.set(host, entry);
@@ -20107,13 +20655,13 @@ function serialized(reply) {
     const text = JSON.stringify(reply);
     plain3 = text === void 0 ? void 0 : JSON.parse(text);
   } catch (err) {
-    return JSON.stringify(errorReply("EIO", lineOf2(err)));
+    return JSON.stringify(errorReply("EIO", lineOf3(err)));
   }
   if (!isRecord(plain3)) return JSON.stringify(errorReply("EIO", "the vault gave no reply"));
   const { v: _, ...rest2 } = plain3;
   return JSON.stringify({ v: 1, ...rest2 });
 }
-function lineOf2(err) {
+function lineOf3(err) {
   const text = err instanceof Error ? err.message : String(err);
   return (text.split("\n")[0] ?? "").slice(0, 200);
 }
@@ -20164,7 +20712,7 @@ var SealedChannel = class {
     if (signal.aborted) return void 0;
     const asked = Promise.resolve().then(() => hook(req, { signal })).then(
       (reply2) => isRecord(reply2) ? reply2 : errorReply("EIO", "the vault gave no reply"),
-      (err) => errorReply("EIO", lineOf2(err))
+      (err) => errorReply("EIO", lineOf3(err))
     );
     const reply = await Promise.race([asked, stopped]);
     if (!signal.aborted) return reply;
@@ -21281,13 +21829,13 @@ var PgServer = class {
       at += whole;
     }
     this.buffer = data.slice(at);
-    const joined4 = new Uint8Array(out.reduce((n, b) => n + b.length, 0));
+    const joined5 = new Uint8Array(out.reduce((n, b) => n + b.length, 0));
     let to = 0;
     for (const b of out) {
-      joined4.set(b, to);
+      joined5.set(b, to);
       to += b.length;
     }
-    return joined4;
+    return joined5;
   }
 };
 function frame3(type, body) {
@@ -21629,12 +22177,12 @@ var SessionWriter = class {
     if (this.failed !== void 0) throw this.failed;
     if (this.mode === "pass") return this.conn.write(bytes);
     clearTimeout(this.timer);
-    const joined4 = new Uint8Array(this.buffer.length + bytes.length);
-    joined4.set(this.buffer);
-    joined4.set(bytes, this.buffer.length);
+    const joined5 = new Uint8Array(this.buffer.length + bytes.length);
+    joined5.set(this.buffer);
+    joined5.set(bytes, this.buffer.length);
     this.buffer.fill(0);
-    this.buffer = joined4;
-    if (this.mode === "sniff") this.mode = modeOf(latin12(joined4.subarray(0, 8))) ?? "sniff";
+    this.buffer = joined5;
+    if (this.mode === "sniff") this.mode = modeOf(latin12(joined5.subarray(0, 8))) ?? "sniff";
     if (this.mode === "pg" && !this.sawPg) {
       this.sawPg = true;
       if (!this.s.verified) void this.proof("pg");
@@ -21782,7 +22330,7 @@ var ScrubReader = class {
       const before = this.current();
       const out = this.through(got);
       if (before.length === 0 && out !== void 0) return out;
-      if (before.length > 0) return joined3(before, out);
+      if (before.length > 0) return joined4(before, out);
     }
   }
   through(got) {
@@ -21798,7 +22346,7 @@ var ScrubReader = class {
     return out.length > 0 ? out : void 0;
   }
 };
-function joined3(a, b) {
+function joined4(a, b) {
   if (!b) return a;
   const out = new Uint8Array(a.length + b.length);
   out.set(a);
@@ -22706,7 +23254,7 @@ async function connect(req, proc) {
     dialing?.catch(() => void 0);
     throw new KernelError("EINPROGRESS");
   }
-  if (dialing !== void 0) await interruptible2(dialing, proc.blocking());
+  if (dialing !== void 0) await interruptible3(dialing, proc.blocking());
   return ok3();
 }
 async function bindUnixDgram(proc, socket, addr) {
@@ -22771,7 +23319,7 @@ async function unixDatagram(req, dgram, proc) {
 function domainOf(socket) {
   return socket instanceof UnixDgram ? "unix" : "inet";
 }
-function interruptible2(dialing, signal) {
+function interruptible3(dialing, signal) {
   return new Promise((resolve2, reject) => {
     const abort = () => reject(new KernelError("EINTR"));
     signal.addEventListener("abort", abort, { once: true });
@@ -23775,7 +24323,7 @@ var ProcessWatches = class {
 };
 
 // src/kernel/process.ts
-function aborted(signal) {
+function aborted2(signal) {
   return new Promise((_, reject) => {
     signal.addEventListener("abort", () => reject(new KernelError("EINTR")), { once: true });
   });
@@ -23865,6 +24413,7 @@ var SYSCALL_OPS = /* @__PURE__ */ new Set([
   "fd-open-sealed",
   "fd-open-clipboard",
   "fd-clipboard-abort",
+  "fd-open-embedder",
   "tty-get",
   "tty-set",
   "tty-winsz",
@@ -24418,6 +24967,7 @@ var WasmProcess = class {
     if (!read) throw new KernelError(req.peek && file.read ? "EOPNOTSUPP" : "EBADF");
     if (file.tty) this.checkForeground(file.tty);
     if (file.clipboard) return this.readClipboard(file.clipboard, req, cancelled);
+    if (file.embedder) return this.readEmbedder(file, req, cancelled);
     if (file instanceof EventFd && req.max < EventFd.SIZE) throw new KernelError("EINVAL");
     if (req.max <= 0) return new Uint8Array(0);
     if (file instanceof KernelSocket && file.unconnected) throw new KernelError("ENOTCONN");
@@ -24438,6 +24988,81 @@ var WasmProcess = class {
       throw err;
     }
   }
+  async readEmbedder(file, req, cancelled) {
+    const channel = file.embedder;
+    if (req.max <= 0) return new Uint8Array(0);
+    channel.caller = await this.embedderCaller();
+    try {
+      return await channel.read(Math.min(req.max, MAX_READ), this.blockingSignal(cancelled));
+    } catch (err) {
+      await this.deviceComplaint(EMBEDDER_PATH, err);
+      throw err;
+    }
+  }
+  async writeEmbedder(file, body, nonblock, cancelled) {
+    const channel = file.embedder;
+    channel.caller = await this.embedderCaller();
+    const write = file.write;
+    if (!pollFile(file).writable && nonblock) throw new KernelError("EAGAIN");
+    try {
+      return await write.call(file, body, this.blockingSignal(cancelled));
+    } catch (err) {
+      await this.deviceComplaint(EMBEDDER_PATH, err);
+      throw err;
+    }
+  }
+  async deviceComplaint(path, err) {
+    const name2 = this.options.clipboardName;
+    if (name2 === void 0 || !(err instanceof KernelError) || err.detail === void 0) return;
+    if (err.code === "EINTR") return;
+    await this.complainLine(`${name2}: ${path}: ${clipboardLine(err.detail)}`);
+  }
+  async complainLine(line) {
+    const stderr = this.fds.has(2) ? this.fds.get(2).file : void 0;
+    if (!stderr?.write || stderr.clipboard || stderr.embedder || stderr.sealed) return;
+    const timeout = new Promise((r) => setTimeout(() => r(0), 1e3));
+    await Promise.race([
+      stderr.write(new TextEncoder().encode(`${line}
+`), AbortSignal.timeout(1e3)).catch(() => 0),
+      timeout
+    ]);
+  }
+  async embedderCaller() {
+    const shown = await this.options.identity?.();
+    const session = this.options.embedderSession?.() ?? { client: 0, uid: 0 };
+    const name2 = this.options.clipboardName ?? this.options.embedderName ?? "program";
+    return {
+      pid: this.pid,
+      shownPid: shown?.pid ?? this.pid,
+      euid: this.cred.euid,
+      egid: this.cred.egid,
+      groups: [...this.cred.groups],
+      sessionUid: session.uid,
+      client: session.client,
+      tags: this.options.embedder?.tagsOf(this.pid),
+      progress: (line) => void this.complainLine(`${name2}: ${line}`),
+      closing: () => AbortSignal.any([this.interrupt.signal, this.gone.signal])
+    };
+  }
+  async closeFd(fd) {
+    this.options.locks?.closed(this.pid, fd);
+    await this.dropRecordLocks(fd);
+    const closing2 = this.fds.get(fd).file;
+    const channel = closing2.clipboard;
+    if (channel) channel.stamp = await this.clipboardStamp();
+    if (closing2.embedder) closing2.embedder.caller = await this.embedderCaller();
+    await Promise.resolve(this.fds.close(fd)).catch(async (err) => {
+      if (channel) await this.clipboardComplaint(err);
+      if (closing2.embedder) await this.deviceComplaint(EMBEDDER_PATH, err);
+      throw err;
+    });
+  }
+  async openEmbedder(flags2) {
+    const broker = this.options.embedder;
+    if (!broker) throw new KernelError("ENOENT");
+    const file = broker.channel(openAccess(flags2), await this.embedderCaller());
+    return this.fds.install(this.options.outputFilter?.(file) ?? file, 3);
+  }
   async complain(line) {
     const stderr = this.fds.has(2) ? this.fds.get(2).file : void 0;
     if (!stderr?.write || stderr.sealed || stderr.clipboard) return false;
@@ -24468,6 +25093,7 @@ var WasmProcess = class {
     const file = this.fds.get(fd).file;
     if (file.sealed) return file.sealed.send(body, await this.sealedCaller(), this.gone.signal);
     if (!file.write) throw new KernelError("EBADF");
+    if (file.embedder) return this.writeEmbedder(file, body, nonblock, cancelled);
     if (!pollFile(file).writable) {
       if (nonblock) throw new KernelError("EAGAIN");
       return file.write(body, this.blockingSignal(cancelled));
@@ -24515,11 +25141,11 @@ var WasmProcess = class {
       } else if (req.create) {
         await nodes.onEntry(path, async () => {
           const marks = this.options.owners || plain3 !== void 0;
-          const fresh2 = marks && !await present3(fs, path, true);
+          const fresh3 = marks && !await present3(fs, path, true);
           this.fds.installAt(fd, this.openVfsFile(open2, await nodes.identify(path), fs));
           await this.fds.get(fd).file.stat?.();
-          if (fresh2 && plain3 !== void 0) await fs.chmod?.(path, plain3);
-          else if (fresh2) {
+          if (fresh3 && plain3 !== void 0) await fs.chmod?.(path, plain3);
+          else if (fresh3) {
             await fs.chown?.(path, { ...this.newOwner(req.mode), kind: "new" });
           }
         });
@@ -24737,17 +25363,9 @@ var WasmProcess = class {
           kind: "json",
           json: await this.write(req.fd, req.body, req.nonblock, cancelled)
         };
-      case "fd-close": {
-        this.options.locks?.closed(this.pid, req.fd);
-        await this.dropRecordLocks(req.fd);
-        const channel = this.fds.get(req.fd).file.clipboard;
-        if (channel) channel.stamp = await this.clipboardStamp();
-        await Promise.resolve(this.fds.close(req.fd)).catch(async (err) => {
-          if (channel) await this.clipboardComplaint(err);
-          throw err;
-        });
+      case "fd-close":
+        await this.closeFd(req.fd);
         return { ok: true, kind: "void" };
-      }
       case "fd-pipe": {
         const pipe = openPipe();
         const read = this.fds.install(pipe.read, 3);
@@ -24807,6 +25425,8 @@ var WasmProcess = class {
         return { ok: true, kind: "json", json: this.openSealed(req.flags) };
       case "fd-open-clipboard":
         return { ok: true, kind: "json", json: await this.openClipboard(req.flags) };
+      case "fd-open-embedder":
+        return { ok: true, kind: "json", json: await this.openEmbedder(req.flags) };
       case "fd-clipboard-abort": {
         const file = this.fds.get(req.fd);
         file.file.clipboard?.abort();
@@ -25301,7 +25921,7 @@ var WasmProcess = class {
       else {
         const { source, target, type, flags: flags2, data } = req;
         const signal = this.blockingSignal(cancelled);
-        await Promise.race([mount({ source, target, type, flags: flags2, data }, signal), aborted(signal)]);
+        await Promise.race([mount({ source, target, type, flags: flags2, data }, signal), aborted2(signal)]);
       }
     } catch (err) {
       const code = err?.code;
@@ -25311,7 +25931,7 @@ var WasmProcess = class {
     return { ok: true, kind: "void" };
   }
   pause(cancelled) {
-    return aborted(this.blockingSignal(cancelled));
+    return aborted2(this.blockingSignal(cancelled));
   }
   alarm;
   dlLog = [];
@@ -25847,6 +26467,7 @@ function holdingToken(opts, holds2, caller) {
     boundIno: holds2.boundIno.bind(holds2),
     trust: holds2.trust.bind(holds2),
     keptFor: (handle) => holds2.keptFor(handle),
+    heldAt: (handle) => holds2.pathOf(handle),
     unlinked: (path) => holds2.keptAt(path),
     gate: (path, op) => opts.unlinkGate && holds2.holding(path) ? opts.unlinkGate.run(holds2.keyOf(path), op) : op(),
     own: (path, op) => holds2.own(path, op),
@@ -25860,6 +26481,15 @@ function linksOf(opts) {
 function clipboardName(opts) {
   return opts.program.abi === "js" ? {} : { clipboardName: opts.argv0 };
 }
+function embedderOptions(opts) {
+  if (!opts.embedder) return {};
+  return {
+    embedder: opts.embedder.broker,
+    embedderSession: opts.embedder.session,
+    embedderName: opts.argv0,
+    ...clipboardName(opts)
+  };
+}
 function processOptions(opts, header4, hooks, created4) {
   return {
     ...inherited(opts),
@@ -25867,6 +26497,7 @@ function processOptions(opts, header4, hooks, created4) {
     ...opts.sealed ? { sealed: opts.sealed } : {},
     ...opts.outputFilter ? { outputFilter: opts.outputFilter } : {},
     ...opts.clipboard ? { clipboard: opts.clipboard, ...clipboardName(opts) } : {},
+    ...embedderOptions(opts),
     ...opts.readonlyAt ? { readonlyAt: opts.readonlyAt } : {},
     ...opts.source ? { source: opts.source } : {},
     noLinks: opts.noLinks,
@@ -28017,14 +28648,14 @@ var RESTORE_AGAIN_MS = 3e4;
 function hostfsHandlers(current, againMs = RESTORE_AGAIN_MS) {
   const handles = /* @__PURE__ */ new Map();
   let nextFh = 0;
-  const fresh2 = (remote) => {
+  const fresh3 = (remote) => {
     if (remote.client.token === remote.token && !remote.client.gone) return remote;
     throw fsError2("ESTALE", "the folder was granted again, so this open file is gone");
   };
   const live = (fh) => {
     const remote = handles.get(fh);
     if (!remote) throw fsError2("EBADF", `handle ${fh}`);
-    return fresh2(remote);
+    return fresh3(remote);
   };
   const call = (op, body = {}) => current().call(op, body);
   const same3 = (was, mode, seen) => seen?.mode === (mode | 128) && (was.ino !== void 0 && seen.ino !== void 0 ? seen.ino === was.ino : seen.size === was.size && seen.mtime === was.mtime);
@@ -28106,7 +28737,7 @@ function hostfsHandlers(current, againMs = RESTORE_AGAIN_MS) {
       if (!remote) throw fsError2("EBADF", `handle ${fh}`);
       handles.delete(fh);
       try {
-        await fresh2(remote).client.call("release", { fh: remote.fh }, true);
+        await fresh3(remote).client.call("release", { fh: remote.fh }, true);
       } finally {
         if (remote.restore) await settle3(current(), remote.restore);
       }
@@ -29338,12 +29969,12 @@ ${lines2}
     const timer = setTimeout(() => control.abort("expired"), timeout);
     const withdraw = () => control.abort("withdrawn");
     requester.addEventListener("abort", withdraw, { once: true });
-    const aborted2 = new Promise(
+    const aborted3 = new Promise(
       (resolve2) => control.signal.addEventListener("abort", () => resolve2("aborted"), { once: true })
     );
     try {
       const answered2 = Promise.resolve().then(() => approve(req, { signal: control.signal })).catch(() => "deny");
-      const answer2 = await Promise.race([answered2, aborted2]);
+      const answer2 = await Promise.race([answered2, aborted3]);
       if (answer2 === "aborted" || control.signal.aborted) {
         return control.signal.reason === "expired" ? failed2("ETIMEDOUT", "sudo: the request expired") : failed2("EINTR", "sudo: the request was withdrawn");
       }
@@ -29469,6 +30100,7 @@ var SUDO_SOURCE = [
 ].join("\n");
 
 // src/launcher.ts
+var NO_SESSION = { client: -1, uid: -1 };
 var MODULE_URLS = 16;
 function dataModuleUrl(source) {
   const bytes = new TextEncoder().encode(source);
@@ -29731,6 +30363,7 @@ var Launcher = class {
   described = /* @__PURE__ */ new Map();
   creds = /* @__PURE__ */ new Map();
   tags = /* @__PURE__ */ new Map();
+  sessions = /* @__PURE__ */ new Map();
   tagBases = /* @__PURE__ */ new Map();
   links = /* @__PURE__ */ new Map();
   freshModules = new FreshModules();
@@ -29791,6 +30424,7 @@ var Launcher = class {
   sealed;
   scrubs = /* @__PURE__ */ new Map();
   clipboard;
+  embedder;
   rootFs;
   fileWatches;
   nextPid = 1e3;
@@ -29812,14 +30446,14 @@ var Launcher = class {
       void 0,
       (pid) => this.tagsOf(pid)
     );
+    this.embedder = this.embedderBroker(options.embedder);
     this.sealed = new SealedBroker(
       options.sealed,
       this.usersMode,
       void 0,
       (pid) => this.tagsOf(pid)
     );
-    this.sealed.tickets.normalise = (path) => physicalPathAsync(this.base, path);
-    this.sealed.userOf = async (uid) => (await this.users.lookup(uid))?.name;
+    this.wireSealed();
     if (this.owners) options.fs.trackOwners?.();
     this.watchers.tap((paths) => {
       this.changes.publish(...paths);
@@ -30880,6 +31514,8 @@ var Launcher = class {
   }
   marks(pid, req) {
     if (req.tags?.length) this.tags.set(pid, req.tags);
+    const session = req.session ?? this.sessions.get(req.ppid ?? -1);
+    if (session) this.sessions.set(pid, session);
     if (req.tags?.length) this.tagBases.set(pid, req.tagBase ?? req.tags.length);
     if (req.links !== void 0) this.links.set(pid, req.links);
   }
@@ -30959,6 +31595,7 @@ var Launcher = class {
       sealed: this.sealed,
       ...scrubs ? { outputFilter: (file) => scrubbedAll(file, scrubs) } : {},
       clipboard: this.clipboard,
+      embedder: { broker: this.embedder, session: () => this.sessionOf(pid) },
       ...this.dac ? { dac: this.dac } : {},
       program: req.program,
       changes: this.changes.sab,
@@ -31087,6 +31724,7 @@ var Launcher = class {
     this.childTimes.delete(pid);
     this.creds.delete(pid);
     this.tags.delete(pid);
+    this.sessions.delete(pid);
     this.tagBases.delete(pid);
     this.links.delete(pid);
     this.granted.delete(pid);
@@ -31132,8 +31770,8 @@ var Launcher = class {
     this.sampledAt = Math.max(this.sampledAt, now);
     this.load = this.load.map((avg, i) => {
       const window = LOAD_WINDOWS_MS[i];
-      const fresh2 = 1 - Math.exp(-LOAD_SAMPLE_MS / window);
-      return avg * Math.exp(-elapsed / window) + running * fresh2;
+      const fresh3 = 1 - Math.exp(-LOAD_SAMPLE_MS / window);
+      return avg * Math.exp(-elapsed / window) + running * fresh3;
     });
   }
   idleSince;
@@ -31363,7 +32001,7 @@ var Launcher = class {
   forker(ppid, parent) {
     const { exec: _exec, pgid: _pgid, group: _group, pid: _pid, scrub: _scrub, ...image } = parent;
     return async (state, given) => {
-      const fresh2 = (fds, quietOom) => this.start({
+      const fresh3 = (fds, quietOom) => this.start({
         ...image,
         quietOom,
         cwd: state.cwd ?? parent.cwd,
@@ -31379,7 +32017,7 @@ var Launcher = class {
         tagBase: this.tagBases.get(ppid),
         links: this.links.get(ppid)
       });
-      return childHandle(await this.admitted(parent.program.abi !== "js", given, fresh2));
+      return childHandle(await this.admitted(parent.program.abi !== "js", given, fresh3));
     };
   }
   keySignal(tty, fallback, sig, send2) {
@@ -31415,6 +32053,25 @@ var Launcher = class {
   credOf(pid) {
     return this.creds.get(pid)?.() ?? copyCred(ROOT);
   }
+  wireSealed() {
+    this.sealed.tickets.normalise = (path) => physicalPathAsync(this.base, path);
+    this.sealed.userOf = async (uid) => (await this.users.lookup(uid))?.name;
+  }
+  embedderBroker(hook) {
+    const broker = new EmbedderBroker(
+      this.usersMode,
+      {
+        groupId: async (name2) => (await this.users.groups()).find((g) => g.name === name2)?.gid,
+        userId: async (name2) => (await this.users.lookup(name2))?.uid
+      },
+      (pid) => this.tagsOf(pid)
+    );
+    broker.register(0, hook);
+    return broker;
+  }
+  sessionOf(pid) {
+    return this.sessions.get(pid) ?? NO_SESSION;
+  }
   tagOf(pid) {
     return this.tags.get(pid)?.[0];
   }
@@ -31686,8 +32343,8 @@ var Launcher = class {
     for (const [path, mode] of layout) {
       if (isProtected(this.prefixes, normalizePath(path))) continue;
       const real = await this.realLayoutPath(path);
-      const fresh2 = real !== void 0 && !await this.base.hasOwner?.(real);
-      if (fresh2) await this.base.chown?.(real, { uid: 0, gid: 0, mode, follow: false });
+      const fresh3 = real !== void 0 && !await this.base.hasOwner?.(real);
+      if (fresh3) await this.base.chown?.(real, { uid: 0, gid: 0, mode, follow: false });
     }
   }
   async realLayoutPath(given) {
@@ -31860,9 +32517,10 @@ var Launcher = class {
     if (!found) throw fsError("ENOENT", `no user ${String(user)}`);
     return found;
   }
-  identity(account, given) {
+  identity(account, given, session = 0) {
     return {
       ...given,
+      session: { client: session, uid: account.uid },
       cred: credOf(account),
       ...account.umask !== void 0 ? { umask: account.umask } : {}
     };
@@ -31982,9 +32640,9 @@ var Launcher = class {
   }
   moved(from, to, source) {
     this.renameLog.add(from, to);
+    for (const holds2 of this.held) holds2.renamed(from, to);
     if (source) return;
     for (const nodes of this.openFiles) nodes.renamed(from, to);
-    for (const holds2 of this.held) holds2.renamed(from, to);
     this.watchers.moved(from, to);
   }
   processChain(fs, nodes, unlinked) {
@@ -32049,7 +32707,7 @@ var Launcher = class {
       cwd,
       fds,
       report,
-      ...this.identity(account, tagged)
+      ...this.identity(account, tagged, options.session)
     });
     leader = handle.pid;
     void handle.exited.then(() => tty.hangup());
@@ -32106,7 +32764,7 @@ var Launcher = class {
       fds,
       report,
       ...group,
-      ...this.identity(account, tagged)
+      ...this.identity(account, tagged, options.session)
     });
     options.onStarted?.(handle.pid);
     const status = await handle.exited;
@@ -32572,6 +33230,8 @@ function isUsersRequest(req) {
 }
 function transferOf2(req, result) {
   if (result instanceof MessagePort) return [result];
+  const bound3 = result?.port;
+  if (req.op === "connect" && bound3 instanceof MessagePort) return [bound3];
   if (req.op === "attest") return [result.bytes.buffer];
   return void 0;
 }
@@ -32605,7 +33265,35 @@ function usersOp(l, req) {
   if (req.op === "groups-remove-member") return l.users.removeMember(req.group, req.user);
   return l.users.list();
 }
-function hostOptions(req, port, sealed, clipboard, lookup2) {
+var clientIds = 0;
+async function connectClient(deps, { user, tag, bind: bind2 }) {
+  const l = await deps.ready();
+  tagOption(tag);
+  if (user !== void 0 && !await l.users.lookup(user)) {
+    throw fsError("ENOENT", `no user ${String(user)}`);
+  }
+  const { port1, port2 } = new MessageChannel();
+  const held = deps.held ? await deps.held() : void 0;
+  const client = ++clientIds;
+  const served2 = serveClient(port1, {
+    launcher: deps.ready,
+    signal: signalNumber,
+    session: client,
+    ...bind2 === "attach" ? { attachRequests: true } : {},
+    ...user !== void 0 ? { user } : {},
+    ...tag !== void 0 ? { tag } : {},
+    ...deps.locks ? { locks: deps.locks } : {},
+    ...held ? { lock: held } : {}
+  });
+  deps.clients.add(served2);
+  const unbind = bind2 && bind2 !== "attach" ? l.embedder.register(client, deps.requests.hookFor(client, bind2)) : void 0;
+  void served2.closed.then(() => {
+    deps.clients.delete(served2);
+    unbind?.();
+  });
+  return unbind ? { port: port2, client } : port2;
+}
+function hostOptions(req, port, sealed, clipboard, lookup2, requests) {
   return {
     cron: { lock: `slicc-kernel-cron:${req.metadata ?? META_DB}` },
     ...req.hostname !== void 0 ? { hostname: req.hostname } : {},
@@ -32614,7 +33302,8 @@ function hostOptions(req, port, sealed, clipboard, lookup2) {
     ...req.denials ? { onDenial: (denial) => port.postMessage({ denial }) } : {},
     ...req.protect ? { protect: hostProtect(req.protect, lookup2) } : {},
     ...req.sealed ? { sealed } : {},
-    ...req.clipboard ? { clipboard } : {}
+    ...req.clipboard ? { clipboard } : {},
+    ...req.requests ? { embedder: requests.hookFor(0, req.requests) } : {}
   };
 }
 function hostProtect(init, lookup2) {
@@ -32649,6 +33338,7 @@ function serveKernel(port, deps) {
   const clients = /* @__PURE__ */ new Set();
   const sealed = sealedAsker(port);
   const clipboard = clipboardAsker(port);
+  const requests = embedderAsker(port);
   const integrity = integrityAsker(port);
   const approvals = sudoApprovals(port);
   const locks = deps.locks === null ? void 0 : deps.locks ?? locksOf();
@@ -32664,26 +33354,10 @@ function serveKernel(port, deps) {
     });
     return holding;
   }
-  async function connect2(user, tag) {
-    const l = await ready2();
-    tagOption(tag);
-    if (user !== void 0 && !await l.users.lookup(user)) {
-      throw fsError("ENOENT", `no user ${String(user)}`);
-    }
-    const { port1, port2 } = new MessageChannel();
-    const held = locks ? await holdLock(locks) : void 0;
-    const served2 = serveClient(port1, {
-      launcher: ready2,
-      signal: signalNumber,
-      ...user !== void 0 ? { user } : {},
-      ...tag !== void 0 ? { tag } : {},
-      ...locks ? { locks } : {},
-      ...held ? { lock: held } : {}
-    });
-    clients.add(served2);
-    void served2.closed.then(() => clients.delete(served2));
-    return port2;
-  }
+  const connect2 = (user, tag, bind2) => connectClient(
+    { ready: ready2, clients, requests, held: locks ? () => holdLock(locks) : void 0, locks },
+    { user, tag, bind: bind2 }
+  );
   async function ready2() {
     if (!launcher) throw new Error("the kernel is not initialized");
     return launcher;
@@ -32717,7 +33391,7 @@ function serveKernel(port, deps) {
         ...req.modules ? { modules: req.modules } : {},
         ...req.commands ? { commands: req.commands } : {},
         ...req.env ? { env: req.env } : {},
-        ...hostOptions(req, port, sealed.hook, clipboard.hook, integrity.lookup),
+        ...hostOptions(req, port, sealed.hook, clipboard.hook, integrity.lookup, requests),
         ...req.approve ? { approve: approvals.ask } : {},
         ...net,
         ...media ? { media } : {},
@@ -32745,7 +33419,7 @@ function serveKernel(port, deps) {
     if (req.op === "init") return init(req);
     if (isAttestRequest(req)) return attestOp(await ready2(), req);
     if (req.op === "open-terminal") return terminal(req);
-    if (req.op === "connect") return connect2(req.user, req.tag);
+    if (req.op === "connect") return connect2(req.user, req.tag, req.requests);
     if (isUsersRequest(req)) return usersOp(await ready2(), req);
     if (req.op === "routes" || req.op === "transport-traits") {
       return networkOp(await ready2(), req, remote);
@@ -32787,6 +33461,8 @@ function serveKernel(port, deps) {
     if (sealedReply) return sealed.answer(sealedReply);
     const clipboardReply = event.data.clipboardReply;
     if (clipboardReply) return clipboard.answer(clipboardReply);
+    const embedderReply = embedderReplyOf(event.data);
+    if (embedderReply) return requests.answer(embedderReply);
     const integrityReply = event.data.integrityReply;
     if (integrityReply) return integrity.answer(integrityReply);
     const grant = event.data.hostfsGrant;