@ai-ecoverse/slicc-kernel 1.44.0 → 1.46.0

package/dist/node.js

@@ -735,6 +735,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;
@@ -1061,8 +1064,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;
@@ -1194,8 +1197,8 @@ async function readWithin(reader, ms) {
 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 = [];
@@ -1215,9 +1218,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`;
@@ -1226,7 +1229,7 @@ var MessageQueue = class {
       return;
     }
     this.size += size;
-    this.items.push(message2);
+    this.items.push(message3);
     this.wake();
   }
   end(close) {
@@ -1399,6 +1402,7 @@ function fetchTransport(options = {}) {
       });
       const body = chunks(response.body, options.bodyIdleMs ?? BODY_IDLE_MS);
       return {
+        ...response.redirected ? { url: response.url, redirected: true } : {},
         status: response.status,
         statusText: response.statusText,
         headers: headers2,
@@ -1413,7 +1417,7 @@ function fetchTransport(options = {}) {
 }
 function serveTransport(peer, transport, { closeWaitMs = CLOSE_WAIT_MS } = {}) {
   const open = /* @__PURE__ */ new Map();
-  const fail2 = (nid, e) => {
+  const fail3 = (nid, e) => {
     open.delete(nid);
     const { status, code } = e;
     peer.postMessage({
@@ -1444,12 +1448,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) {
-      fail2(call.nid, e);
+      fail3(call.nid, e);
     }
   };
   const sockets = /* @__PURE__ */ new Map();
@@ -1483,7 +1488,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) {
-      fail2(call.nid, e);
+      fail3(call.nid, e);
     }
   };
   const relay = async (nid, socket) => {
@@ -1555,7 +1560,7 @@ function serveTransport(peer, transport, { closeWaitMs = CLOSE_WAIT_MS } = {}) {
         peer.postMessage({ net: "chunk", nid, bytes }, [bytes.buffer]);
       }
     } catch (e) {
-      fail2(nid, e);
+      fail3(nid, e);
     }
   };
   const drop = (nid) => {
@@ -2059,8 +2064,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);
@@ -2079,8 +2084,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();
@@ -2091,7 +2096,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,
@@ -3124,8 +3129,8 @@ var UnlinkedKeeper = class {
 // src/kernel/net/http1.ts
 var HttpError = class extends Error {
   status;
-  constructor(status, message2) {
-    super(message2);
+  constructor(status, message3) {
+    super(message3);
     this.status = status;
   }
 };
@@ -3392,8 +3397,8 @@ var OP = {
 };
 var WsError = class extends Error {
   code;
-  constructor(code, message2) {
-    super(message2);
+  constructor(code, message3) {
+    super(message3);
     this.code = code;
   }
 };
@@ -3690,8 +3695,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);
@@ -3759,9 +3764,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));
@@ -4349,10 +4354,10 @@ var SpawnError = class extends Error {
 };
 function interrupted(signal) {
   const { promise, reject } = Promise.withResolvers();
-  const fail2 = () => reject(new KernelError("EINTR"));
-  if (signal?.aborted) fail2();
-  else signal?.addEventListener("abort", fail2, { once: true });
-  return { promise, done: () => signal?.removeEventListener("abort", fail2) };
+  const fail3 = () => reject(new KernelError("EINTR"));
+  if (signal?.aborted) fail3();
+  else signal?.addEventListener("abort", fail3, { once: true });
+  return { promise, done: () => signal?.removeEventListener("abort", fail3) };
 }
 function stoppedStatus(sig) {
   return (sig & 255) << 8 | 127;
@@ -4543,8 +4548,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;
@@ -5526,12 +5531,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 {
@@ -6228,8 +6233,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,
@@ -6411,10 +6416,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) {
@@ -6875,8 +6880,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;
   }
 };
@@ -7257,10 +7262,135 @@ function enableNetwork(net, options) {
   return () => proxy;
 }
 
+// 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) {
@@ -7270,11 +7400,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);
@@ -7284,56 +7419,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}` };
@@ -7350,7 +7499,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));
@@ -7358,6 +7507,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);
@@ -7366,6 +7519,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)));
   }
 };
@@ -7498,7 +7652,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) {
@@ -8058,10 +8212,10 @@ function ready(fds, read, write) {
 }
 function interruption(signal) {
   const { promise, reject } = Promise.withResolvers();
-  const fail2 = () => reject(new KernelError("EINTR"));
-  if (signal.aborted) fail2();
-  else signal.addEventListener("abort", fail2, { once: true });
-  return { promise, done: () => signal.removeEventListener("abort", fail2) };
+  const fail3 = () => reject(new KernelError("EINTR"));
+  if (signal.aborted) fail3();
+  else signal.addEventListener("abort", fail3, { once: true });
+  return { promise, done: () => signal.removeEventListener("abort", fail3) };
 }
 async function selectFds(fds, read, write, timeoutMs, interrupt) {
   const deadline = timeoutMs < 0 ? Number.POSITIVE_INFINITY : Date.now() + timeoutMs;
@@ -9211,6 +9365,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;
@@ -9221,6 +9378,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();
@@ -9543,8 +9701,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();
@@ -10210,8 +10370,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) {
@@ -10261,15 +10421,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 } }
@@ -11601,10 +11761,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;
@@ -12231,7 +12391,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;
@@ -12261,7 +12421,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`);
@@ -12287,7 +12447,7 @@ var Launcher = class {
 };
 
 // src/node/memory-root.ts
-var fail = (name2) => {
+var fail2 = (name2) => {
   throw new DOMException(name2, name2);
 };
 function valid(name2) {
@@ -12400,7 +12560,7 @@ var MemoryFile = class {
   }
   async move(parent, name2) {
     valid(name2);
-    if (parent.children.get(name2)?.kind === "directory") fail("InvalidModificationError");
+    if (parent.children.get(name2)?.kind === "directory") fail2("InvalidModificationError");
     this.parent.children.delete(this.name);
     this.name = name2;
     this.parent = parent;
@@ -12418,15 +12578,15 @@ var MemoryDirectory = class _MemoryDirectory {
     this.parent = parent;
   }
   present() {
-    if (this.removed) fail("NotFoundError");
+    if (this.removed) fail2("NotFoundError");
   }
   async getDirectoryHandle(name2, { create = false } = {}) {
     this.present();
     valid(name2);
     const found = this.children.get(name2);
-    if (found?.kind === "file") fail("TypeMismatchError");
+    if (found?.kind === "file") fail2("TypeMismatchError");
     if (found) return found;
-    if (!create) fail("NotFoundError");
+    if (!create) fail2("NotFoundError");
     const dir = new _MemoryDirectory(name2, this);
     this.children.set(name2, dir);
     return dir;
@@ -12435,9 +12595,9 @@ var MemoryDirectory = class _MemoryDirectory {
     this.present();
     valid(name2);
     const found = this.children.get(name2);
-    if (found?.kind === "directory") fail("TypeMismatchError");
+    if (found?.kind === "directory") fail2("TypeMismatchError");
     if (found) return found;
-    if (!create) fail("NotFoundError");
+    if (!create) fail2("NotFoundError");
     const file = new MemoryFile(name2, this);
     this.children.set(name2, file);
     return file;
@@ -12446,9 +12606,9 @@ var MemoryDirectory = class _MemoryDirectory {
     this.present();
     valid(name2);
     const found = this.children.get(name2);
-    if (!found) return fail("NotFoundError");
+    if (!found) return fail2("NotFoundError");
     if (found.kind === "directory" && found.children.size > 0 && !recursive) {
-      fail("InvalidModificationError");
+      fail2("InvalidModificationError");
     }
     this.children.delete(name2);
     if (found.kind === "directory") found.remove();
@@ -12477,7 +12637,7 @@ var MemoryDirectory = class _MemoryDirectory {
   }
   async move(parent, name2) {
     valid(name2);
-    if (parent.children.has(name2)) fail("InvalidModificationError");
+    if (parent.children.has(name2)) fail2("InvalidModificationError");
     this.parent?.children.delete(this.name);
     this.name = name2;
     this.parent = parent;
@@ -12495,8 +12655,8 @@ function isMemoryRoot(handle) {
 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;
   }
@@ -12581,7 +12741,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) => {
@@ -12598,6 +12758,7 @@ var RemoteTransport = class {
       this.cancel(nid);
     };
     return {
+      ...redirected ? { url, redirected } : {},
       status,
       statusText,
       headers,
@@ -12667,9 +12828,9 @@ function signalNumber(name2) {
 }
 
 // src/client/dial-stream.ts
-function errorWithCode(message2) {
-  const code = /^E[A-Z]+/.exec(message2)?.[0];
-  return Object.assign(new Error(message2), code ? { code } : {});
+function errorWithCode(message3) {
+  const code = /^E[A-Z]+/.exec(message3)?.[0];
+  return Object.assign(new Error(message3), code ? { code } : {});
 }
 function dialStream(port, onClose) {
   let closed = false;
@@ -12687,15 +12848,15 @@ function dialStream(port, onClose) {
       close();
     }
   });
-  const finish = (fail3) => {
+  const finish = (fail4) => {
     const controller = reader;
     reader = void 0;
     for (const ack of acks.splice(0)) {
-      if (fail3) ack.reject(fail3);
+      if (fail4) ack.reject(fail4);
       else ack.resolve();
     }
     if (!controller) return;
-    if (fail3) controller.error(fail3);
+    if (fail4) controller.error(fail4);
     else controller.close();
   };
   function shut() {
@@ -12731,11 +12892,11 @@ function dialStream(port, onClose) {
       close();
     }
   });
-  const fail2 = (error) => {
+  const fail3 = (error) => {
     shut();
     finish(error);
   };
-  return { readable, writable, close, fail: fail2 };
+  return { readable, writable, close, fail: fail3 };
 }
 
 // src/client/loopback-fetch.ts
@@ -12907,15 +13068,15 @@ async function loopbackFetch(dial, input, options) {
 
 // src/client/attach.ts
 var KernelGoneError = class extends Error {
-  constructor(message2 = "the slicc-kernel this client was attached to is gone") {
-    super(message2);
+  constructor(message3 = "the slicc-kernel this client was attached to is gone") {
+    super(message3);
     this.name = "KernelGoneError";
   }
 };
 var KernelCallError = class extends Error {
   code;
-  constructor(message2, code) {
-    super(message2);
+  constructor(message3, code) {
+    super(message3);
     this.name = "KernelCallError";
     this.code = code;
   }
@@ -12971,8 +13132,8 @@ var Channel = class {
     port.addEventListener("close", () => this.end(new KernelGoneError()));
     port.start?.();
   }
-  post(message2) {
-    if (!this.failure) this.port.postMessage(message2);
+  post(message3) {
+    if (!this.failure) this.port.postMessage(message3);
   }
   end(error) {
     if (this.failure) return;
@@ -13288,9 +13449,9 @@ var TERMINATED = "the kernel is terminated";
 function nodeWorker(file, live, closed) {
   const errors = /* @__PURE__ */ new Set();
   const messages = /* @__PURE__ */ new Map();
-  const fail2 = (message2) => {
+  const fail3 = (message3) => {
     for (const handler of [...errors]) {
-      handler({ message: message2, preventDefault() {
+      handler({ message: message3, preventDefault() {
       } });
     }
   };
@@ -13298,16 +13459,16 @@ function nodeWorker(file, live, closed) {
   if (worker) {
     const kill = () => {
       void worker.terminate();
-      fail2(TERMINATED);
+      fail3(TERMINATED);
     };
     live.add(kill);
     worker.once("exit", () => live.delete(kill));
-    worker.on("error", (err) => fail2(String(err)));
+    worker.on("error", (err) => fail3(String(err)));
   } else {
-    setTimeout(() => fail2(TERMINATED), 0);
+    setTimeout(() => fail3(TERMINATED), 0);
   }
   return {
-    postMessage: (message2, transfer) => worker?.postMessage(message2, transfer),
+    postMessage: (message3, transfer) => worker?.postMessage(message3, transfer),
     addEventListener(type, handler) {
       if (type === "error") {
         errors.add(handler);