@ai-ecoverse/slicc-kernel 1.44.0 → 1.46.0

package/dist/kernel-worker.js

@@ -1594,6 +1594,9 @@ var KernelSocket = class _KernelSocket {
   get listening() {
     return this.state === "listening";
   }
+  get unconnected() {
+    return this.state === "open" || this.state === "listening";
+  }
   connection() {
     if (!this.link || this.state !== "connected") throw new KernelError("ENOTCONN");
     return this.link;
@@ -1920,8 +1923,8 @@ function serveSocket(socket, port, onClose) {
   let writes = Promise.resolve();
   let credit = 0;
   let granted2;
-  const send = (message2, transfer) => {
-    if (!closed) port.postMessage(message2, transfer);
+  const send = (message3, transfer) => {
+    if (!closed) port.postMessage(message3, transfer);
   };
   const close = (reset = false) => {
     if (closed) return;
@@ -2036,8 +2039,8 @@ var BODY_IDLE_MS = 5 * 60 * 1e3;
 var INBOUND_LIMIT = 16 * 1024 * 1024;
 var MESSAGE_LIMIT = 64 * 1024 * 1024;
 var TOO_BIG = 1009;
-function payloadSize(message2) {
-  return typeof message2 === "string" ? new TextEncoder().encode(message2).length : message2.length;
+function payloadSize(message3) {
+  return typeof message3 === "string" ? new TextEncoder().encode(message3).length : message3.length;
 }
 var MessageQueue = class {
   items = [];
@@ -2057,9 +2060,9 @@ var MessageQueue = class {
       this.settle = resolve;
     });
   }
-  push(message2) {
+  push(message3) {
     if (this.ended) return;
-    const size = payloadSize(message2);
+    const size = payloadSize(message3);
     const huge = size > MESSAGE_LIMIT;
     if (huge || this.items.length > 0 && this.size + size > this.limit) {
       const reason = huge ? `a message is over ${MESSAGE_LIMIT} bytes` : `over ${this.limit} bytes of messages are waiting`;
@@ -2068,7 +2071,7 @@ var MessageQueue = class {
       return;
     }
     this.size += size;
-    this.items.push(message2);
+    this.items.push(message3);
     this.wake();
   }
   end(close) {
@@ -2107,7 +2110,7 @@ var NO_WEBSOCKET = "WebSocket not supported by this transport (fetchTransport ne
 var MAX_REQUEST_BODY = 64 * 1024 * 1024;
 function serveTransport(peer, transport, { closeWaitMs = CLOSE_WAIT_MS } = {}) {
   const open = /* @__PURE__ */ new Map();
-  const fail = (nid, e) => {
+  const fail2 = (nid, e) => {
     open.delete(nid);
     const { status, code } = e;
     peer.postMessage({
@@ -2138,12 +2141,13 @@ function serveTransport(peer, transport, { closeWaitMs = CLOSE_WAIT_MS } = {}) {
       peer.postMessage({
         net: "head",
         nid: call.nid,
+        ...response.redirected ? { url: response.url, redirected: true } : {},
         status: response.status,
         statusText: response.statusText,
         headers: response.headers
       });
     } catch (e) {
-      fail(call.nid, e);
+      fail2(call.nid, e);
     }
   };
   const sockets = /* @__PURE__ */ new Map();
@@ -2177,7 +2181,7 @@ function serveTransport(peer, transport, { closeWaitMs = CLOSE_WAIT_MS } = {}) {
       peer.postMessage({ net: "ws-opened", nid: call.nid, protocol: socket.protocol });
       void relay(call.nid, socket);
     } catch (e) {
-      fail(call.nid, e);
+      fail2(call.nid, e);
     }
   };
   const relay = async (nid, socket) => {
@@ -2249,7 +2253,7 @@ function serveTransport(peer, transport, { closeWaitMs = CLOSE_WAIT_MS } = {}) {
         peer.postMessage({ net: "chunk", nid, bytes }, [bytes.buffer]);
       }
     } catch (e) {
-      fail(nid, e);
+      fail2(nid, e);
     }
   };
   const drop = (nid) => {
@@ -2726,8 +2730,8 @@ function serveClient(port, host) {
   const watches = /* @__PURE__ */ new Map();
   let net;
   const ended = Promise.withResolvers();
-  const send = (message2, transfer = []) => {
-    if (state !== "closed") port.postMessage(message2, transfer);
+  const send = (message3, transfer = []) => {
+    if (state !== "closed") port.postMessage(message3, transfer);
   };
   const reply = (id2, body, transfer) => send({ id: id2, ...body }, transfer);
   const cdps = cdpRegistry(send, ended.promise);
@@ -2746,8 +2750,8 @@ function serveClient(port, host) {
     port.close?.();
     ended.resolve();
   }
-  async function hello(message2) {
-    const refused = versionError(message2.protocol);
+  async function hello(message3) {
+    const refused = versionError(message3.protocol);
     if (refused) {
       send({ hello: { protocol: PROTOCOL, error: refused } });
       detach();
@@ -2758,7 +2762,7 @@ function serveClient(port, host) {
     const transport = host.transport?.() ?? launcher.transport;
     net = serveTransport({ postMessage: (m, t) => send(m, t) }, transport);
     state = "open";
-    if (message2.lock && host.locks) void host.locks.request(message2.lock, () => detach());
+    if (message3.lock && host.locks) void host.locks.request(message3.lock, () => detach());
     send({
       hello: {
         protocol: PROTOCOL,
@@ -2918,8 +2922,8 @@ function ownNames(hostname) {
 // src/kernel/net/http1.ts
 var HttpError = class extends Error {
   status;
-  constructor(status, message2) {
-    super(message2);
+  constructor(status, message3) {
+    super(message3);
     this.status = status;
   }
 };
@@ -3182,8 +3186,8 @@ var OP = {
 };
 var WsError = class extends Error {
   code;
-  constructor(code, message2) {
-    super(message2);
+  constructor(code, message3) {
+    super(message3);
     this.code = code;
   }
 };
@@ -3549,8 +3553,8 @@ function untilAborted(response, signal) {
     response.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
   });
 }
-function plainResponse(status, message2) {
-  const body = latin1Bytes(`slicc realm proxy: ${message2}
+function plainResponse(status, message3) {
+  const body = latin1Bytes(`slicc realm proxy: ${message3}
 `);
   return {
     status,
@@ -3732,10 +3736,10 @@ var RealmProxy = class {
       return await untilAborted(fetching, signal);
     } catch (e) {
       if (signal.aborted) throw e;
-      const message2 = e instanceof Error ? e.message : String(e);
+      const message3 = e instanceof Error ? e.message : String(e);
       const status = e?.status;
       const own = typeof status === "number" && status >= 400 && status <= 599 ? status : 502;
-      return plainResponse(own, message2 || "upstream request failed");
+      return plainResponse(own, message3 || "upstream request failed");
     }
   }
   async relay(conn, method, minor, response, keepAlive) {
@@ -4240,8 +4244,8 @@ var SCRATCH = 64 * 1024;
 var EOF = -1;
 var TlsError = class extends Error {
   code;
-  constructor(code, message2) {
-    super(message2);
+  constructor(code, message3) {
+    super(message3);
     this.code = code;
   }
 };
@@ -4630,8 +4634,8 @@ function enableNetwork(net, options) {
 var TransportError = class extends Error {
   status;
   code;
-  constructor(message2, status, code) {
-    super(message2);
+  constructor(message3, status, code) {
+    super(message3);
     this.status = status;
     this.code = code;
   }
@@ -4716,7 +4720,7 @@ var RemoteTransport = class {
       finish();
       throw e;
     }
-    const { status, statusText, headers } = head;
+    const { status, statusText, headers, url, redirected } = head;
     const read = async () => {
       if (finished) return void 0;
       const reply = await this.ask({ net: "read", nid }).catch((e) => {
@@ -4733,6 +4737,7 @@ var RemoteTransport = class {
       this.cancel(nid);
     };
     return {
+      ...redirected ? { url, redirected } : {},
       status,
       statusText,
       headers,
@@ -5089,8 +5094,8 @@ var CdpFacade = class {
             clearTimeout(timer);
             reject(new HttpError(502, `the CDP host closed: ${reason ?? "no reason"}`));
           };
-          conn.onmessage = (message2) => {
-            const parsed2 = JSON.parse(message2);
+          conn.onmessage = (message3) => {
+            const parsed2 = JSON.parse(message3);
             if (parsed2.id !== 1) return;
             clearTimeout(timer);
             resolve(parsed2);
@@ -5158,9 +5163,9 @@ var Relay = class {
         void this.end(reason ? CLOSE.error : CLOSE.normal, reason ?? "").then(() => resolve());
       };
     });
-    this.host.onmessage = (message2) => {
+    this.host.onmessage = (message3) => {
       if (this.ended) return;
-      const bytes = new TextEncoder().encode(message2);
+      const bytes = new TextEncoder().encode(message3);
       if (bytes.length > this.max)
         void this.end(CLOSE.tooBig, `a message is over ${this.max} bytes`);
       else void this.send(frame(OP_TEXT, bytes));
@@ -5939,10 +5944,10 @@ var SpawnError = class extends Error {
 };
 function interrupted(signal) {
   const { promise, reject } = Promise.withResolvers();
-  const fail = () => reject(new KernelError("EINTR"));
-  if (signal?.aborted) fail();
-  else signal?.addEventListener("abort", fail, { once: true });
-  return { promise, done: () => signal?.removeEventListener("abort", fail) };
+  const fail2 = () => reject(new KernelError("EINTR"));
+  if (signal?.aborted) fail2();
+  else signal?.addEventListener("abort", fail2, { once: true });
+  return { promise, done: () => signal?.removeEventListener("abort", fail2) };
 }
 function stoppedStatus(sig) {
   return (sig & 255) << 8 | 127;
@@ -6133,8 +6138,8 @@ function unref(timer) {
   timer.unref?.();
   return timer;
 }
-function errnoError(code, message2) {
-  return Object.assign(new Error(`${code}: ${message2}`), { code });
+function errnoError(code, message3) {
+  return Object.assign(new Error(`${code}: ${message3}`), { code });
 }
 var DriverConnection = class _DriverConnection {
   capabilities;
@@ -7116,12 +7121,12 @@ function syncError(code, label) {
 
 // src/realm/sync-fs-dispatch.ts
 function toErrno(err) {
-  const message2 = err instanceof Error ? err.message : String(err);
+  const message3 = err instanceof Error ? err.message : String(err);
   const code = err?.code;
   if (typeof code === "string" && /^E[A-Z]+$/.test(code)) {
-    return { ok: false, errno: code, message: message2 };
+    return { ok: false, errno: code, message: message3 };
   }
-  return { ok: false, errno: "EIO", message: message2 };
+  return { ok: false, errno: "EIO", message: message3 };
 }
 function statJson(s) {
   return {
@@ -7602,10 +7607,135 @@ async function hostSyscall(req, ctx) {
   }
 }
 
+// src/kernel/net/ws-syscalls.ts
+var WS_OPS = [
+  "net-ws-open",
+  "net-ws-ready",
+  "net-ws-recv",
+  "net-ws-wait",
+  "net-ws-send",
+  "net-ws-close"
+];
+var TOKEN3 = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/;
+function message(e) {
+  return e instanceof Error ? e.message : String(e);
+}
+function fail(errno, text) {
+  return { ok: false, errno, message: text };
+}
+var WsHandles = class {
+  transport;
+  open = /* @__PURE__ */ new Map();
+  next;
+  constructor(transport, next2) {
+    this.transport = transport;
+    this.next = next2;
+  }
+  owns(handle) {
+    return this.open.has(handle);
+  }
+  syscall(req) {
+    if (req.op === "net-ws-open") return Promise.resolve(this.start(req));
+    const entry = this.open.get(req.handle);
+    if (!entry) return Promise.resolve(fail("EBADF", `no websocket ${req.handle}`));
+    if (req.op === "net-ws-ready") return entry.ready;
+    if (!entry.socket) return Promise.resolve(fail("ENOTCONN", "websocket not open"));
+    if (req.op === "net-ws-recv") return this.recv(entry.socket, entry);
+    if (req.op === "net-ws-wait") return this.closed(entry.socket);
+    if (req.op === "net-ws-send") return Promise.resolve(this.send(entry.socket, req, entry));
+    entry.ended = true;
+    entry.socket.close(req.code ?? 1e3, req.reason ?? "");
+    return Promise.resolve({ ok: true, kind: "void" });
+  }
+  start(req) {
+    const handle = this.next();
+    const entry = {
+      abort: new AbortController(),
+      ready: Promise.resolve({ ok: true, kind: "void" })
+    };
+    this.open.set(handle, entry);
+    entry.ready = this.connect(handle, req, entry);
+    return { ok: true, kind: "json", json: handle };
+  }
+  async connect(handle, req, entry) {
+    const { transport } = this;
+    if (!transport.traits.websocket || !transport.websocket) return fail("ENOTSUP", NO_WEBSOCKET2);
+    let socket;
+    try {
+      socket = await transport.websocket({
+        url: req.url,
+        protocols: req.protocols,
+        headers: req.headers,
+        signal: entry.abort.signal
+      });
+    } catch (e) {
+      return fail("ECONNREFUSED", message(e));
+    }
+    if (!this.open.has(handle)) {
+      socket.close(1001, "the program went away");
+      return fail("EBADF", `no websocket ${handle}`);
+    }
+    if (socket.protocol && !(req.protocols.includes(socket.protocol) && TOKEN3.test(socket.protocol))) {
+      socket.close(1002, "subprotocol not offered");
+      return fail("EPROTO", "the far end chose a subprotocol the program did not offer");
+    }
+    entry.socket = socket;
+    void socket.closed.then(() => {
+      entry.ended = true;
+    });
+    entry.messages = socket.messages[Symbol.asyncIterator]();
+    return { ok: true, kind: "json", json: { protocol: socket.protocol } };
+  }
+  async recv(socket, entry) {
+    try {
+      const next2 = await entry.messages.next();
+      if (!next2.done) {
+        return typeof next2.value === "string" ? { ok: true, kind: "json", json: { text: next2.value } } : { ok: true, kind: "bytes", bytes: next2.value };
+      }
+      const closed = await socket.closed;
+      return { ok: true, kind: "json", json: { code: closed.code, reason: closed.reason } };
+    } catch (e) {
+      return fail("ECONNRESET", message(e));
+    }
+  }
+  async closed(socket) {
+    const { code, reason } = await socket.closed;
+    return { ok: true, kind: "json", json: { code, reason } };
+  }
+  send(socket, req, entry) {
+    const data = req.text ?? req.body;
+    if (entry.ended) return fail("EPIPE", "the websocket is closed");
+    try {
+      if (data !== void 0) socket.send(data);
+    } catch (e) {
+      return fail("EPIPE", message(e));
+    }
+    return { ok: true, kind: "json", json: socket.buffered };
+  }
+  close(handle) {
+    const entry = this.open.get(handle);
+    if (!entry) return;
+    this.open.delete(handle);
+    entry.abort.abort();
+    entry.socket?.close(1001, "the program went away");
+  }
+  closeAll() {
+    for (const handle of [...this.open.keys()]) this.close(handle);
+  }
+};
+
 // src/kernel/net/http-syscalls.ts
-var HTTP_OPS = ["net-request", "net-read", "net-close", "net-traits"];
+var HTTP_OPS = [
+  "net-request",
+  "net-open",
+  "net-head",
+  "net-read",
+  "net-close",
+  "net-traits",
+  ...WS_OPS
+];
 var EMPTY = new Uint8Array(0);
-function message(e) {
+function message2(e) {
   return e instanceof Error ? e.message : String(e);
 }
 async function* once(bytes) {
@@ -7615,11 +7745,16 @@ var HttpHandles = class {
   transport;
   open = /* @__PURE__ */ new Map();
   nextHandle = 0;
+  ws;
   constructor(transport) {
     this.transport = transport;
+    this.ws = new WsHandles(transport, () => ++this.nextHandle);
   }
   syscall(req) {
+    if (req.op.startsWith("net-ws-")) return this.ws.syscall(req);
     if (req.op === "net-request") return this.request(req);
+    if (req.op === "net-open") return Promise.resolve(this.opened(req));
+    if (req.op === "net-head") return this.head(req.handle);
     if (req.op === "net-read") return this.read(req.handle, req.max);
     if (req.op === "net-traits") return Promise.resolve(this.traits());
     return this.close(req.handle);
@@ -7629,56 +7764,70 @@ var HttpHandles = class {
     if (unavailable) return { ok: false, errno: "ENETUNREACH", message: NO_TRANSPORT };
     return { ok: true, kind: "json", json: { ...rest2, crossOrigin } };
   }
-  add(abort, body, cancel) {
+  async request(req) {
+    const { handle, head } = this.start(req);
+    const result = await head;
+    if (!result.ok) this.open.delete(handle);
+    return result;
+  }
+  opened(req) {
+    return { ok: true, kind: "json", json: this.start(req).handle };
+  }
+  start(req) {
     const handle = ++this.nextHandle;
-    this.open.set(handle, {
+    const abort = new AbortController();
+    const entry = {
       abort,
-      body: body[Symbol.asyncIterator](),
+      head: Promise.resolve({ ok: true, kind: "void" }),
+      body: once(EMPTY),
       left: EMPTY,
       done: false,
       reading: Promise.resolve(),
-      cancel
-    });
-    return handle;
+      cancel: async () => void 0
+    };
+    this.open.set(handle, entry);
+    entry.head = this.respond(handle, req, entry);
+    return { handle, head: entry.head };
   }
-  async request(req) {
-    const abort = new AbortController();
+  async respond(handle, req, entry) {
     try {
       const response = await this.transport.fetch({
         url: req.url,
         method: req.method,
         headers: req.headers,
         ...req.body ? { body: req.body } : {},
-        signal: abort.signal
+        signal: entry.abort.signal
       });
-      const handle = this.add(abort, response.body, () => response.cancel());
-      const head = {
-        handle,
-        status: response.status,
-        statusText: response.statusText,
-        url: req.url,
-        headers: response.headers
-      };
-      return { ok: true, kind: "json", json: head };
+      entry.body = response.body[Symbol.asyncIterator]();
+      entry.cancel = () => response.cancel();
+      if (!this.open.has(handle)) await entry.cancel().catch(() => void 0);
+      const head = this.headOf(handle, response.url ?? req.url, response);
+      return response.redirected ? { ...head, json: { ...head.json, redirected: true } } : head;
     } catch (e) {
-      const text = message(e);
-      if (text === NO_TRANSPORT) return { ok: false, errno: "ENETUNREACH", message: text };
+      const text = message2(e);
       const status = e.status;
-      if (typeof status !== "number" || status === 502) {
-        return { ok: false, errno: "ECONNREFUSED", message: text };
+      if (text === NO_TRANSPORT || typeof status !== "number" || status === 502) {
+        const errno = text === NO_TRANSPORT ? "ENETUNREACH" : "ECONNREFUSED";
+        return { ok: false, errno, message: text };
       }
-      const body = new TextEncoder().encode(text);
-      const handle = this.add(abort, once(body), async () => void 0);
-      const head = {
-        handle,
+      entry.body = once(new TextEncoder().encode(text))[Symbol.asyncIterator]();
+      return this.headOf(handle, req.url, {
         status,
         statusText: "",
-        url: req.url,
         headers: [["content-type", "text/plain; charset=utf-8"]]
-      };
-      return { ok: true, kind: "json", json: head };
+      });
     }
   }
+  headOf(handle, url, response) {
+    const { status, statusText, headers } = response;
+    return { ok: true, kind: "json", json: { handle, status, statusText, url, headers } };
+  }
+  head(handle) {
+    const entry = this.open.get(handle);
+    if (!entry)
+      return Promise.resolve({ ok: false, errno: "EBADF", message: `no request ${handle}` });
+    return entry.head;
+  }
   async read(handle, max) {
     const entry = this.open.get(handle);
     if (!entry) return { ok: false, errno: "EBADF", message: `no request ${handle}` };
@@ -7695,7 +7844,7 @@ var HttpHandles = class {
       } catch (e) {
         entry.done = true;
         const timedOut = e?.code === "ETIMEDOUT";
-        return { ok: false, errno: timedOut ? "ETIMEDOUT" : "EIO", message: message(e) };
+        return { ok: false, errno: timedOut ? "ETIMEDOUT" : "EIO", message: message2(e) };
       }
     }
     const bytes = entry.left.subarray(0, Math.max(0, max));
@@ -7703,6 +7852,10 @@ var HttpHandles = class {
     return { ok: true, kind: "bytes", bytes };
   }
   async close(handle) {
+    if (this.ws.owns(handle)) {
+      this.ws.close(handle);
+      return { ok: true, kind: "void" };
+    }
     const entry = this.open.get(handle);
     if (!entry) return { ok: false, errno: "EBADF", message: `no request ${handle}` };
     this.open.delete(handle);
@@ -7711,6 +7864,7 @@ var HttpHandles = class {
     return { ok: true, kind: "void" };
   }
   async closeAll() {
+    this.ws.closeAll();
     await Promise.all([...this.open.keys()].map((handle) => this.close(handle)));
   }
 };
@@ -7743,7 +7897,7 @@ var Resolver = class {
     this.routes = options.routes;
     this.now = options.now ?? Date.now;
     this.timeoutMs = options.timeoutMs ?? RESOLVE_TIMEOUT_MS;
-    this.log = options.log ?? ((message2) => console.warn(message2));
+    this.log = options.log ?? ((message3) => console.warn(message3));
     this.own = ownNames(options.hostname ?? DEFAULT_HOSTNAME);
   }
   async resolve(name2, family, blocking) {
@@ -8303,10 +8457,10 @@ function ready(fds, read, write) {
 }
 function interruption(signal) {
   const { promise, reject } = Promise.withResolvers();
-  const fail = () => reject(new KernelError("EINTR"));
-  if (signal.aborted) fail();
-  else signal.addEventListener("abort", fail, { once: true });
-  return { promise, done: () => signal.removeEventListener("abort", fail) };
+  const fail2 = () => reject(new KernelError("EINTR"));
+  if (signal.aborted) fail2();
+  else signal.addEventListener("abort", fail2, { once: true });
+  return { promise, done: () => signal.removeEventListener("abort", fail2) };
 }
 async function selectFds(fds, read, write, timeoutMs, interrupt) {
   const deadline = timeoutMs < 0 ? Number.POSITIVE_INFINITY : Date.now() + timeoutMs;
@@ -9456,6 +9610,9 @@ var WasmProcess = class {
       throw e;
     }
   }
+  refuseIfPending(restart) {
+    if (restart && this.options.hasPending?.()) throw new KernelError("EINTR");
+  }
   blockingSignal() {
     if (this.options.hasPending?.()) throw new KernelError("EINTR");
     return this.interrupt.signal;
@@ -9466,6 +9623,7 @@ var WasmProcess = class {
     if (!read) throw new KernelError(req.peek && file.read ? "EOPNOTSUPP" : "EBADF");
     if (file.tty) this.checkForeground(file.tty);
     if (req.max <= 0) return new Uint8Array(0);
+    if (file instanceof KernelSocket && file.unconnected) throw new KernelError("ENOTCONN");
     const ready2 = pollFile(file).readable;
     if (!ready2 && req.nonblock) throw new KernelError("EAGAIN");
     const signal = ready2 ? this.interrupt.signal : this.blockingSignal();
@@ -9788,8 +9946,10 @@ var WasmProcess = class {
   async procSyscall(req) {
     switch (req.op) {
       case "proc-fork":
+        this.refuseIfPending(req.restart);
         return { ok: true, kind: "json", json: await this.children.fork(req.state) };
       case "proc-spawn":
+        this.refuseIfPending(req.restart);
         return { ok: true, kind: "json", json: await this.spawn(req) };
       case "proc-wait": {
         const signal = req.nohang ? this.interrupt.signal : this.blockingSignal();
@@ -10455,8 +10615,8 @@ var SettlingChildren = class {
 };
 
 // src/mount/driver.ts
-function fsError2(code, message2 = code) {
-  return Object.assign(new Error(message2), { code });
+function fsError2(code, message3 = code) {
+  return Object.assign(new Error(message3), { code });
 }
 async function dispatch(h, req) {
   switch (req.op) {
@@ -10506,15 +10666,15 @@ async function dispatch(h, req) {
 }
 function serveFilesystem(port, handlers, capabilities = {}, options = {}) {
   let open = false;
-  const reply = (message2, transfer = []) => port.postMessage(message2, transfer);
-  async function hello(message2) {
-    const refused = driverVersionError(message2.protocol);
+  const reply = (message3, transfer = []) => port.postMessage(message3, transfer);
+  async function hello(message3) {
+    const refused = driverVersionError(message3.protocol);
     if (refused) {
       reply({ hello: { protocol: DRIVER_PROTOCOL, error: refused, errno: "EPROTO" } });
       return;
     }
     try {
-      const refined = await handlers.mount?.(message2.mount);
+      const refined = await handlers.mount?.(message3.mount);
       open = true;
       reply({
         hello: { protocol: DRIVER_PROTOCOL, capabilities: { ...capabilities, ...refined } }
@@ -11837,10 +11997,10 @@ var Launcher = class {
   }
   interpreters() {
     this.binfmts ??= this.roots().then(
-      (roots) => scanBinfmts(this.base, roots, (message2) => {
-        if (this.warned.has(message2)) return;
-        this.warned.add(message2);
-        console.warn(message2);
+      (roots) => scanBinfmts(this.base, roots, (message3) => {
+        if (this.warned.has(message3)) return;
+        this.warned.add(message3);
+        console.warn(message3);
       })
     );
     return this.binfmts;
@@ -12467,7 +12627,7 @@ var Launcher = class {
       },
       account
     );
-    const report = (message2) => options.onData(encoder3.encode(`${message2}\r
+    const report = (message3) => options.onData(encoder3.encode(`${message3}\r
 `));
     const handle = await this.launch(planned, { env, cwd, fds, report, ...this.identity(account) });
     leader = handle.pid;
@@ -12497,7 +12657,7 @@ var Launcher = class {
     };
     const stdout = collect(out, options.onStdout);
     const stderr = collect(err, options.onStderr);
-    const report = (message2) => stderr(encoder3.encode(`${message2}
+    const report = (message3) => stderr(encoder3.encode(`${message3}
 `));
     if (!planned) {
       report(`${file}: command not found`);