@ai-ecoverse/slicc-kernel 1.45.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;
@@ -2138,6 +2141,7 @@ 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
@@ -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,
@@ -7722,6 +7727,8 @@ var WsHandles = class {
 // src/kernel/net/http-syscalls.ts
 var HTTP_OPS = [
   "net-request",
+  "net-open",
+  "net-head",
   "net-read",
   "net-close",
   "net-traits",
@@ -7746,6 +7753,8 @@ var HttpHandles = class {
   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);
@@ -7755,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 = message2(e);
-      if (text === NO_TRANSPORT) return { ok: false, errno: "ENETUNREACH", message: text };
       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}` };
@@ -9587,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;
@@ -9597,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();
@@ -9919,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();