@ai-ecoverse/slicc-kernel 1.44.0 → 1.45.0

package/dist/kernel-worker.js

@@ -1920,8 +1920,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 +2036,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 +2057,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 +2068,7 @@ var MessageQueue = class {
       return;
     }
     this.size += size;
-    this.items.push(message2);
+    this.items.push(message3);
     this.wake();
   }
   end(close) {
@@ -2107,7 +2107,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({
@@ -2143,7 +2143,7 @@ function serveTransport(peer, transport, { closeWaitMs = CLOSE_WAIT_MS } = {}) {
         headers: response.headers
       });
     } catch (e) {
-      fail(call.nid, e);
+      fail2(call.nid, e);
     }
   };
   const sockets = /* @__PURE__ */ new Map();
@@ -2177,7 +2177,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 +2249,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 +2726,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 +2746,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 +2758,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 +2918,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 +3182,8 @@ var OP = {
 };
 var WsError = class extends Error {
   code;
-  constructor(code, message2) {
-    super(message2);
+  constructor(code, message3) {
+    super(message3);
     this.code = code;
   }
 };
@@ -3549,8 +3549,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 +3732,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 +4240,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 +4630,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;
   }
@@ -5089,8 +5089,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 +5158,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 +5939,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 +6133,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 +7116,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 +7602,133 @@ 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-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,10 +7738,13 @@ 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-read") return this.read(req.handle, req.max);
     if (req.op === "net-traits") return Promise.resolve(this.traits());
@@ -7661,7 +7787,7 @@ var HttpHandles = class {
       };
       return { ok: true, kind: "json", json: head };
     } catch (e) {
-      const text = message(e);
+      const text = message2(e);
       if (text === NO_TRANSPORT) return { ok: false, errno: "ENETUNREACH", message: text };
       const status = e.status;
       if (typeof status !== "number" || status === 502) {
@@ -7695,7 +7821,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 +7829,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 +7841,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 +7874,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 +8434,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;
@@ -10455,8 +10586,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 +10637,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 +11968,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 +12598,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 +12628,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`);