@ai-ecoverse/slicc-kernel 1.44.0 → 1.45.0

package/dist/process-worker.js

@@ -1465,7 +1465,7 @@ var init_sync_sab_wire = __esm({
 function createSyncSabTransport(sab, port2, deps = {}) {
   const views = sabViews(sab);
   const { header, window } = views;
-  const wait = deps.wait ?? ((a, i, v, t) => Atomics.wait(a, i, v, t));
+  const wait2 = deps.wait ?? ((a, i, v, t) => Atomics.wait(a, i, v, t));
   const now = deps.now ?? (() => performance.now());
   let seq = 0;
   function awaitReady(id, deadline, label) {
@@ -1476,7 +1476,7 @@ function createSyncSabTransport(sab, port2, deps = {}) {
       }
       const remaining = deadline - now();
       if (remaining <= 0) throw syncError("ETIMEDOUT", label);
-      wait(header, SAB_I_PUB, published, remaining);
+      wait2(header, SAB_I_PUB, published, remaining);
     }
   }
   return {
@@ -4033,12 +4033,12 @@ async function runWasmProcess(init, port2, deps = {}) {
   const say = (fd) => (text) => sys.write(fd, encoder4.encode(`${text}
 `));
   let ready;
-  let failed2;
+  let failed3;
   let memory;
   let exports;
   const initialized = new Promise((resolve, reject) => {
     ready = resolve;
-    failed2 = reject;
+    failed3 = reject;
   });
   const id = identify(transport, init);
   const module = {
@@ -4091,7 +4091,7 @@ async function runWasmProcess(init, port2, deps = {}) {
         exports = instance.exports;
         publishMemory(init.sab, memory?.buffer.byteLength ?? 0);
         done(instance, init.program.module);
-      }, failed2);
+      }, failed3);
       return {};
     },
     preRun: [
@@ -7748,7 +7748,7 @@ var init_wasix_host = __esm({
       }
       dlImports() {
         const { mem, host } = this;
-        const failed2 = (message2, buf, len) => {
+        const failed3 = (message2, buf, len) => {
           if (len > 0) {
             const bytes = new TextEncoder().encode(message2).subarray(0, len - 1);
             mem.bytes(buf, bytes.length).set(bytes);
@@ -7757,12 +7757,12 @@ var init_wasix_host = __esm({
           return E.NOEXEC;
         };
         const linked = (buf, len, op, out) => {
-          if (!this.linker) return failed2("not a dynamically-linked program", buf, len);
+          if (!this.linker) return failed3("not a dynamically-linked program", buf, len);
           try {
             out(op(this.linker));
             return E.SUCCESS;
           } catch (e) {
-            if (e instanceof DlError) return failed2(e.message, buf, len);
+            if (e instanceof DlError) return failed3(e.message, buf, len);
             throw e;
           }
         };
@@ -8680,7 +8680,7 @@ function writable(io, fd) {
   });
 }
 function childOps(kernel, io, defaults) {
-  const wait = async (pid) => {
+  const wait2 = async (pid) => {
     const r = await kernel.blocking({ op: "proc-wait", pid, nohang: false });
     const [, status2] = r.ok && r.kind === "json" ? r.json : [0, 0];
     return exitedOf(status2);
@@ -8695,7 +8695,7 @@ function childOps(kernel, io, defaults) {
       ...stdin !== void 0 ? { stdin: writable(io, stdin) } : {},
       ...stdout !== void 0 ? { stdout: readable(io, stdout) } : {},
       ...stderr !== void 0 ? { stderr: readable(io, stderr) } : {},
-      wait: () => wait(pid),
+      wait: () => wait2(pid),
       kill: (signal) => kill(pid, signal)
     };
   };
@@ -8722,7 +8722,7 @@ function childOps(kernel, io, defaults) {
       await closeAll(io, theirs);
     }
   };
-  return { spawn, wait, kill };
+  return { spawn, wait: wait2, kill };
 }
 async function closeAll(io, fds) {
   for (const fd of fds) if (fd !== void 0) await io.close(fd).catch(() => void 0);
@@ -8966,13 +8966,13 @@ function netOps(kernel, io) {
         const r = await kernel.raw({ op: "sock-connect", fd, addr, nonblock: true });
         if (!r.ok && r.errno !== "EINPROGRESS") throw new JsCallError(r.errno, "connect");
         await kernel.blocking({ op: "fd-select", read: [], write: [fd], timeoutMs: -1 }, signal);
-        const failed2 = await kernel.json({
+        const failed3 = await kernel.json({
           op: "sock-getopt",
           fd,
           level: SOL_SOCKET,
           name: SO_ERROR
         });
-        if (failed2 !== 0) throw new JsCallError(errnoName(failed2), "connect");
+        if (failed3 !== 0) throw new JsCallError(errnoName(failed3), "connect");
         return connection(fd);
       });
     }
@@ -9216,6 +9216,156 @@ var init_js_sync = __esm({
   }
 });
 
+// src/process/js/js-websocket.ts
+function failed2(err) {
+  return new TypeError("websocket failed", { cause: err });
+}
+function socketUrl(input) {
+  const url = new URL(input);
+  if (url.protocol === "http:") url.protocol = "ws:";
+  else if (url.protocol === "https:") url.protocol = "wss:";
+  if (url.protocol !== "ws:" && url.protocol !== "wss:") {
+    throw new SyntaxError(`not a WebSocket URL: ${url.href}`);
+  }
+  url.hash = "";
+  return url.href;
+}
+function closeCode(code2) {
+  if (code2 === void 0) return 1e3;
+  if (code2 === 1e3 || code2 >= 3e3 && code2 <= 4999) return code2;
+  throw new JsCallError("EINVAL", `close code ${code2}`);
+}
+function closeReason(reason) {
+  if (reason === void 0) return "";
+  if (new TextEncoder().encode(reason).length > MAX_REASON) {
+    throw new JsCallError("EINVAL", `close reason over ${MAX_REASON} bytes`);
+  }
+  return reason;
+}
+function websocketOp(kernel) {
+  return async (input, options = {}) => {
+    const url = socketUrl(input);
+    const signal = options.signal ?? NEVER2;
+    signal.throwIfAborted();
+    const protocols = typeof options.protocols === "string" ? [options.protocols] : options.protocols ?? [];
+    const handle = await kernel.json({
+      op: "net-ws-open",
+      url,
+      protocols,
+      headers: [...new Headers(options.headers)]
+    });
+    const free = () => kernel.raw({ op: "net-close", handle });
+    let protocol;
+    try {
+      const r = await kernel.blocking({ op: "net-ws-ready", handle }, signal);
+      protocol = (r.ok && r.kind === "json" ? r.json : {}).protocol;
+    } catch (err) {
+      await free();
+      throw signal.aborted ? signal.reason : failed2(err);
+    }
+    let settle;
+    let lose;
+    const closed = new Promise((resolve, reject) => {
+      settle = resolve;
+      lose = reject;
+    });
+    closed.catch(() => void 0);
+    const stop = new AbortController();
+    let freed = false;
+    const onAbort = () => hardStop(signal.reason);
+    const finish = () => {
+      freed = true;
+      signal.removeEventListener("abort", onAbort);
+      void free();
+    };
+    const hardStop = (reason) => {
+      if (stop.signal.aborted) return;
+      stop.abort(reason);
+      lose(reason);
+      finish();
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    let settled = false;
+    let readDone = false;
+    const release = () => {
+      if (!settled || !readDone || freed) return;
+      finish();
+    };
+    kernel.blocking({ op: "net-ws-wait", handle }, stop.signal).then((r) => {
+      settled = true;
+      settle(r.json);
+      release();
+    }).catch(lose);
+    const close = (how = {}) => {
+      void kernel.raw({
+        op: "net-ws-close",
+        handle,
+        code: closeCode(how.code),
+        reason: closeReason(how.reason)
+      });
+    };
+    const readable2 = new ReadableStream(
+      {
+        async pull(controller) {
+          let r;
+          try {
+            r = await kernel.blocking({ op: "net-ws-recv", handle }, stop.signal);
+          } catch (err) {
+            hardStop(stop.signal.aborted ? stop.signal.reason : failed2(err));
+            throw stop.signal.reason;
+          }
+          stop.signal.throwIfAborted();
+          if (r.ok && r.kind === "bytes") {
+            controller.enqueue(r.bytes);
+            return;
+          }
+          const text = (r.ok && r.kind === "json" ? r.json : {}).text;
+          if (text !== void 0) {
+            controller.enqueue(text);
+            return;
+          }
+          controller.close();
+          readDone = true;
+          release();
+        },
+        cancel: () => {
+          close();
+          readDone = true;
+          release();
+        }
+      },
+      { highWaterMark: 0 }
+    );
+    const writable2 = new WritableStream({
+      async write(chunk, controller) {
+        stop.signal.throwIfAborted();
+        const body = typeof chunk === "string" ? { text: chunk } : { body: chunk };
+        let buffered = await kernel.json({ op: "net-ws-send", handle, ...body });
+        while (buffered > SEND_BUFFER) {
+          await wait(10);
+          stop.signal.throwIfAborted();
+          controller.signal.throwIfAborted();
+          buffered = await kernel.json({ op: "net-ws-send", handle });
+        }
+      },
+      close: () => close(),
+      abort: () => close({ code: 1e3, reason: "" })
+    });
+    return { url, protocol, readable: readable2, writable: writable2, closed, close };
+  };
+}
+var SEND_BUFFER, MAX_REASON, NEVER2, wait;
+var init_js_websocket = __esm({
+  "src/process/js/js-websocket.ts"() {
+    "use strict";
+    init_js_kernel();
+    SEND_BUFFER = 1024 * 1024;
+    MAX_REASON = 123;
+    NEVER2 = new AbortController().signal;
+    wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+  }
+});
+
 // src/process/js/js-context.ts
 function identityOf(answer2, fallback) {
   const id = answer2;
@@ -9381,6 +9531,7 @@ function createContext(o) {
     sync,
     ...children,
     net: netOps(kernel, io),
+    websocket: websocketOp(kernel),
     exit
   };
   const drain2 = async () => {
@@ -9518,6 +9669,7 @@ var init_js_context = __esm({
     init_js_kernel();
     init_js_net();
     init_js_sync();
+    init_js_websocket();
     JsExit = class extends Error {
       status;
       constructor(status2) {
@@ -9714,20 +9866,20 @@ function started(init, port2, run, wasi, js) {
   return run(wasmInit, port2);
 }
 function processEntry(port2, run = runWasmProcess, wasi = loadWasi, js = loadJs) {
-  const failed2 = (err) => port2.postMessage({
+  const failed3 = (err) => port2.postMessage({
     type: WASM_PROCESS_ERROR,
     message: err instanceof Error ? err.stack ?? err.message : String(err)
   });
   return (data) => {
     const type = data?.type;
     if (type === WASM_THREAD_INIT) {
-      wasi().then((m) => m.runWasiThread(data, port2)).catch(failed2);
+      wasi().then((m) => m.runWasiThread(data, port2)).catch(failed3);
       return;
     }
     if (type !== WASM_PROCESS_INIT) return;
     started(data, port2, run, wasi, js).then(
       (code2) => port2.postMessage({ type: WASM_PROCESS_EXIT, code: code2 }),
-      failed2
+      failed3
     );
   };
 }