@ai-ecoverse/slicc-kernel 1.47.1 → 1.47.2

package/README.md

@@ -225,7 +225,7 @@ The module's default export (or its `main` export) is called with a context and
 - `wait(pid)` resolves with `{ status }` once a child ends, or `{ status: 128 + signal, signal }` when a signal ended it, without blocking the program; `kill(pid, signal)` signals any process, by number or as `'SIGTERM'` (the default);
 - `net`: `listen({ port, host, backlog })` and `connect({ host, port, signal })` (`host` defaults to `127.0.0.1`) on the kernel's loopback, the same sockets WASIX programs use, so a JS server is reached by other processes, by the page as `<port>.kernel.localhost` (`loopbackFetch`, `dial`) and by attached clients. A listener has its `port` (as bound, so port `0` picks a free one), `accept({ signal })`, `close()` and `for await` over its connections. A connection has `local` and `remote` addresses, `readable` and `writable` web streams (closing the writable shuts down the sending side, so the peer reads the end), and `close()`. The loopback is IPv4 (`127.0.0.1` by default, or `0.0.0.0`), so an IPv6 host such as `::1` fails with `EADDRNOTAVAIL` for both `listen` and `connect`, and binding and connecting fail as they would for a WASIX program (`EADDRINUSE`, `ECONNREFUSED`, `EADDRNOTAVAIL`). A blocked accept, read or write waits without holding anything in the kernel, so aborting it or closing the socket leaves nothing behind. A write to a connection the peer closed fails with `EPIPE` and no `SIGPIPE`;
 - `websocket(url, { protocols, headers, signal })`, a WebSocket over the kernel's transport (its `websocket`, so `fetchTransport({ webSocket: true })` in a browser), shaped like `WebSocketStream`. It resolves once the socket is open, with `url`, the `protocol` the far end chose (always one the program offered: a transport that hands back a socket with another fails the open with `EPROTO`, while browsers and Node's `WebSocket`, which `fetchTransport()` uses, fail such a handshake themselves without saying why, so the open fails with `ECONNREFUSED`), a `readable` of messages (`string` for text, `Uint8Array` for binary), a `writable` for sending them, `closed` (the `{ code, reason }` of the close, from either side, whether or not the program reads) and `close({ code, reason })`. An `http(s):` URL is taken as `ws(s):`. Sending waits while more than 1 MiB is buffered. A signal aborts the open, and after it the socket. A transport without WebSockets rejects with a `TypeError` whose `cause.code` is `ENOTSUP`, and one that cannot connect with `ECONNREFUSED`;
-- `fetch(input, init)`, the web's `fetch` over the kernel's transport, the one the proxy uses, so the embedder's transport, its WebSocket and proxy settings and the kernel's routes apply. The response body streams as the program reads it. The request body is read whole first, since a transport takes it whole (streaming it is [#238](https://github.com/ai-ecoverse/slicc-kernel/issues/238)), and one larger than the transport's `maxRequestBody` is answered `413`, as through the proxy. A signal aborts the request at any stage. Redirects follow the fetch rules: at most 20, a 301 or 302 after a `POST` and a 303 turn into a `GET` without a body, `Authorization` is dropped across origins, and `redirect: 'manual'` returns the redirect itself. On a transport that follows redirects on its own (`fetchTransport()` in a browser) only `'follow'` works: `'manual'` and `'error'` reject with a `TypeError` whose `cause.code` is `ENOTSUP`, since such a transport never shows the program a redirect. A status the transport chose comes back as a response whose body is the reason. An unreachable host, or no transport at all, rejects with a `TypeError` whose `cause.code` is `ECONNREFUSED` or `ENETUNREACH`, as Node's `fetch` does. The global `fetch` stays withheld;
+- `fetch(input, init)`, the web's `fetch` over the kernel's transport, the one the proxy uses, so the embedder's transport, its WebSocket and proxy settings and the kernel's routes apply. The response body streams as the program reads it. The request body is read whole first, since a transport takes it whole (streaming it is [#238](https://github.com/ai-ecoverse/slicc-kernel/issues/238)), and one larger than the transport's `maxRequestBody` is answered `413`, as through the proxy. A signal aborts the request at any stage. Redirects follow the fetch rules: at most 20, a 301 or 302 after a `POST` and a 303 turn into a `GET` without a body, `Authorization` is dropped across origins, and `redirect: 'manual'` returns the redirect itself. On a transport that follows redirects on its own (`fetchTransport()` in a browser) only `'follow'` works: `'manual'` and `'error'` reject with a `TypeError` whose `cause.code` is `ENOTSUP`, since such a transport never shows the program a redirect. A status the transport chose comes back as a response whose body is the reason. An unreachable host, or no transport at all, rejects with a `TypeError` whose `cause.code` is `ECONNREFUSED` or `ENETUNREACH`, as Node's `fetch` does. A `data:` URL is answered by `fetch` itself, as the fetch standard decodes it (a `GET` only, as in Node), without a transport; any other scheme than `http:` and `https:` rejects with a `TypeError` whose `cause.code` is `EPROTONOSUPPORT`, at the start as for a redirect target. The global `fetch` stays withheld;
 - `tty`, for programs on a terminal: `getAttr(fd)` and `setAttr(fd, termios)` read and set its termios (`{ c_iflag, c_oflag, c_cflag, c_lflag, c_cc }`, Linux values), `setRaw(fd, raw)` switches raw mode on as libuv (and Node's `setRawMode`) does (no echo, no line editing, no `^C` signal, each key read as it comes) and off again to the termios it had before, `size(fd)` answers `{ columns, rows }`, and `foreground(fd)` and `setForeground(fd, pgrp)` get and set the foreground process group, under the same job-control rules as other programs. A window resize arrives as `SIGWINCH` through `signals`. A terminal the program left raw is set back when the program ends, whether it returns, exits or throws (a program killed by a signal cannot do so). On a descriptor that is not a terminal, each call fails with `ENOTTY`;
 - `exit(status)`, which ends the program once its pending writes are done.
 

package/dist/node-process-worker.js

@@ -8889,6 +8889,58 @@ function rewrite(hop, status2, location) {
     body: toGet ? void 0 : hop.body
   };
 }
+function isHex(byte) {
+  return byte !== void 0 && /^[0-9A-Fa-f]$/.test(String.fromCharCode(byte));
+}
+function percentDecode(input) {
+  const bytes = new TextEncoder().encode(input);
+  const out = new Uint8Array(bytes.length);
+  let at = 0;
+  for (let i = 0; i < bytes.length; i++) {
+    const byte = bytes[i];
+    if (byte === 37 && isHex(bytes[i + 1]) && isHex(bytes[i + 2])) {
+      out[at++] = Number.parseInt(
+        String.fromCharCode(bytes[i + 1], bytes[i + 2]),
+        16
+      );
+      i += 2;
+    } else out[at++] = byte;
+  }
+  return out.subarray(0, at);
+}
+function latin1(bytes) {
+  let text = "";
+  for (let at = 0; at < bytes.length; at += SLICE) {
+    text += String.fromCharCode(...bytes.subarray(at, at + SLICE));
+  }
+  return text;
+}
+function dataResponse(request) {
+  const url = withoutFragment(new URL(request.url));
+  const rest2 = url.slice("data:".length);
+  const comma = rest2.indexOf(",");
+  if (comma < 0) throw failed2(new JsCallError("EINVAL", "a data: URL without a comma"));
+  let type = rest2.slice(0, comma).replace(/^[\t\n\f\r ]+|[\t\n\f\r ]+$/g, "");
+  let body = percentDecode(rest2.slice(comma + 1));
+  const base642 = BASE64.exec(type);
+  if (base642) {
+    type = type.slice(0, base642.index).replace(/[\t\n\f\r ]+$/, "");
+    let binary;
+    try {
+      binary = atob(latin1(body));
+    } catch {
+      throw failed2(new JsCallError("EINVAL", "a data: URL whose base64 does not decode"));
+    }
+    body = Uint8Array.from(binary, (c) => c.charCodeAt(0));
+  }
+  if (type.startsWith(";")) type = `text/plain${type}`;
+  if (!MIME.test(type)) type = "text/plain;charset=US-ASCII";
+  const response = new Response(body, {
+    status: 200,
+    headers: { "content-type": type }
+  });
+  return withMeta(response, url, false);
+}
 function withMeta(response, url, redirected) {
   const clone = response.clone.bind(response);
   Object.defineProperty(response, "url", { value: url });
@@ -9037,6 +9089,11 @@ function fetchOp(kernel) {
     const request = new Request(input, init);
     const { signal } = request;
     signal.throwIfAborted();
+    const { protocol } = new URL(request.url);
+    if (protocol === "data:") return dataResponse(request);
+    if (protocol !== "http:" && protocol !== "https:") {
+      throw failed2(new JsCallError("EPROTONOSUPPORT", protocol));
+    }
     const known = await traitsOf().catch((err) => {
       throw failed2(err);
     });
@@ -9069,7 +9126,7 @@ function fetchOp(kernel) {
     }
   };
 }
-var CHUNK, MAX_REDIRECTS, NULL_BODY, REDIRECTS, BODY_HEADERS, DECODED, CREDENTIALS, OVER;
+var CHUNK, MAX_REDIRECTS, NULL_BODY, REDIRECTS, BODY_HEADERS, DECODED, CREDENTIALS, OVER, MIME, BASE64, SLICE;
 var init_js_fetch = __esm({
   "src/process/js/js-fetch.ts"() {
     "use strict";
@@ -9088,6 +9145,9 @@ var init_js_fetch = __esm({
     DECODED = /* @__PURE__ */ new Set(["gzip", "x-gzip", "deflate"]);
     CREDENTIALS = /* @__PURE__ */ new Set(["authorization", "proxy-authorization", "cookie", "cookie2"]);
     OVER = /* @__PURE__ */ Symbol("over");
+    MIME = /^[!#$%&'*+.^_`|~0-9A-Za-z-]+\/[!#$%&'*+.^_`|~0-9A-Za-z-]+(?:[\t ]*;.*)?$/s;
+    BASE64 = /; *base64$/i;
+    SLICE = 32768;
   }
 });
 
@@ -9590,7 +9650,7 @@ function ttyOps(kernel) {
     }
   };
   const restore = async () => {
-    for (const [fd, original] of [...saved]) {
+    for (const [fd, original] of [...saved].reverse()) {
       saved.delete(fd);
       await setAttr(fd, original).catch(() => void 0);
     }