@amritk/nish-x86_64-linux 0.30.0 → 0.31.0

package/std/net/{http-client.ts → fetch.ts}

@@ -1,21 +1,21 @@
 /**
- * `nish/net/http-client` — a blocking HTTP/1.1 client for command-line
- * programs: `httpFetch(request, options)` dials, sends, and answers the
- * response's head with a reader for its body, and an `HttpClient` does the
+ * `nish/net/fetch` — a blocking HTTP/1.1 client for command-line
+ * programs: `fetchSync(request, options)` dials, sends, and answers the
+ * response's head with a reader for its body, and a `FetchSyncClient` does the
  * same while keeping one connection alive between fetches.
  *
- *     import { HttpOptions, HttpRequest, HttpResponse, httpFetch } from "nish/net/http-client";
+ *     import { HttpOptions, HttpRequest, HttpResponse, fetchSync } from "nish/net/fetch";
  *
  *     const req = new HttpRequest("GET", "http://example.com/");
  *     req.header("Accept", "application/json");
- *     const res: HttpResponse | null = httpFetch(req, new HttpOptions());
+ *     const res: HttpResponse | null = fetchSync(req, new HttpOptions());
  *     if (res !== null) {
  *       const body: u8[] | null = res.body.readAll(1048576);
  *     }
  *
  * **It blocks the thread** at every step, the way a CLI wants it to: the
  * lookup, the connect, each write and each read. A server, which must not
- * stall every connection for one slow peer, drives `nish/net/http1-client`'s
+ * stall every connection for one slow peer, drives `nish/net/http1-client-codec`'s
  * parser from its own loop instead. Every wait is bounded: `connectTimeoutMs`
  * for the lookup and the connect (one budget across every address the name
  * has), `readTimeoutMs` for each wait on the peer, and `totalTimeoutMs`, when
@@ -25,7 +25,7 @@
  * **Framing is the parser's.** The head is written by `http1RequestHead` and
  * every byte read goes through `Http1ResponseParser`, so a value holding a CR
  * or LF is refused rather than sent, and every response-smuggling shape is
- * refused with the parser's own code (see `docs/security/http1-client.md`).
+ * refused with the parser's own code (see `docs/security/http1-client-codec.md`).
  *
  * **Keep-alive** holds one connection, to the last origin (or proxy) used. A
  * fetch to the same place reuses it once the last body has been read to its
@@ -70,14 +70,14 @@ import {
   HTTP1_HEAD,
   HTTP1_NEED_MORE,
   HTTP1_UPGRADE,
-} from "nish/net/http1"
+} from "nish/net/http1-codec"
 import {
   HTTP1_E_BODY_LIMIT,
   HTTP1_E_TRUNCATED,
   HTTP1_INFORMATIONAL,
   Http1ResponseParser,
   http1RequestHead,
-} from "nish/net/http1-client"
+} from "nish/net/http1-client-codec"
 import { httpFieldBytes } from "nish/net/http-fields"
 import { Url, urlDecode, urlDefaultPort, urlOrigin, urlParse, urlResolve } from "nish/net/url"
 import { resolveHost } from "nish/net/dns"
@@ -293,10 +293,10 @@ export class HttpResponse {
  * client that made it, and only until that client starts its next fetch.
  */
 export class HttpBodyReader {
-  client: HttpClient
+  client: FetchSyncClient
   generation: i32
 
-  constructor(client: HttpClient, generation: i32) {
+  constructor(client: FetchSyncClient, generation: i32) {
     this.client = client
     this.generation = generation
   }
@@ -371,7 +371,7 @@ export class HttpBodyReader {
  * A client: the options, the proxy settings, and at most one open
  * connection, kept between fetches. Not for two threads at once.
  */
-export class HttpClient {
+export class FetchSyncClient {
   // Declared widest first, so no byte of a client is padding.
   options: HttpOptions
   errorText: string = ""
@@ -416,7 +416,7 @@ export class HttpClient {
   lost: boolean = false
   /** Whether the latest response's body is unread. */
   bodyOpen: boolean = false
-  /** Whether this is `httpFetch`'s client, closed whole once its one body is done with. */
+  /** Whether this is `fetchSync`'s client, closed whole once its one body is done with. */
   once: boolean = false
 
   constructor(options: HttpOptions) {
@@ -1336,7 +1336,7 @@ export class HttpClient {
     return take
   }
 
-  /** Closes the connection a body is done with, and `httpFetch`'s whole client with it. */
+  /** Closes the connection a body is done with, and `fetchSync`'s whole client with it. */
   release(): void {
     if (this.once) {
       this.close()
@@ -1391,10 +1391,10 @@ export class HttpClient {
 /**
  * One fetch on a client of its own, closed once the body has been read or
  * the fetch failed. Null on a failure, with no way to say why: a program
- * that reports its errors fetches through an `HttpClient`.
+ * that reports its errors fetches through a `FetchSyncClient`.
  */
-export const httpFetch = (req: HttpRequest, options: HttpOptions): HttpResponse | null => {
-  const client: HttpClient = new HttpClient(options)
+export const fetchSync = (req: HttpRequest, options: HttpOptions): HttpResponse | null => {
+  const client: FetchSyncClient = new FetchSyncClient(options)
   client.once = true
   const res: HttpResponse | null = client.fetch(req)
   if (res === null) {

package/std/net/handler.ts

@@ -80,7 +80,7 @@
 import { copyBytes } from "nish/bytes"
 import { JsonWriter } from "nish/json"
 import { httpFieldBytes } from "nish/net/http-fields"
-import { HTTP1_CHUNKED, HTTP1_NO_BODY, http1HexValue } from "nish/net/http1"
+import { HTTP1_CHUNKED, HTTP1_NO_BODY, http1HexValue } from "nish/net/http1-codec"
 import {
   H1_AGAIN,
   H1_BODY,

package/std/net/{http1-client.ts → http1-client-codec.ts}

@@ -1,14 +1,14 @@
 /**
- * `nish/net/http1-client` — the client side of HTTP/1.1, sans-IO: a request
+ * `nish/net/http1-client-codec` — the client side of HTTP/1.1, sans-IO: a request
  * writer and an incremental response parser, bytes in, events and bytes out,
- * and no socket anywhere. `nish/net/http1` is the server side; the event
+ * and no socket anywhere. `nish/net/http1-codec` is the server side; the event
  * constants and the chunk writers are shared and imported from there.
  *
  * **The writer** is `http1RequestHead`, which answers a request line and
  * header section with the framing field the body needs, and
  * `http1WriteRequestHead`, which writes the same head into a caller's buffer
  * with nothing allocated. A chunked body is written with `http1Chunk` and
- * `http1LastChunk` from `nish/net/http1`. The writer refuses anything that
+ * `http1LastChunk` from `nish/net/http1-codec`. The writer refuses anything that
  * would let a caller's string end a line early or frame the body itself — the
  * request-splitting and request-smuggling shapes. `http1UpgradeRequestHead`
  * is the one way to ask the server to switch protocols: it writes `Upgrade`
@@ -19,8 +19,8 @@
  * what it asked (`expect`), `feed`s whatever slice the socket gave it, cut
  * anywhere, and calls `next()` until it answers `HTTP1_NEED_MORE`:
  *
- *     import { HTTP1_NEED_MORE, HTTP1_HEAD, HTTP1_BODY, HTTP1_END, HTTP1_ERROR } from "nish/net/http1";
- *     import { Http1ResponseParser } from "nish/net/http1-client";
+ *     import { HTTP1_NEED_MORE, HTTP1_HEAD, HTTP1_BODY, HTTP1_END, HTTP1_ERROR } from "nish/net/http1-codec";
+ *     import { Http1ResponseParser } from "nish/net/http1-client-codec";
  *
  *     const p = new Http1ResponseParser(maxStatusLine, maxHeaderBytes, maxHeaders, maxBody, maxTrailerBytes);
  *     p.expect(false, false);
@@ -96,7 +96,7 @@ import {
   http1PutText,
   http1SameWord,
   http1Text,
-} from "nish/net/http1"
+} from "nish/net/http1-codec"
 
 /** `next()`: an interim 1xx response was read; `status` and the fields are its. */
 export const HTTP1_INFORMATIONAL: i32 = 7

package/std/net/{http1.ts → http1-codec.ts}

@@ -1,12 +1,12 @@
 /**
- * `nish/net/http1` — an incremental HTTP/1.1 request parser and a response
+ * `nish/net/http1-codec` — an incremental HTTP/1.1 request parser and a response
  * writer, sans-IO: bytes in, events and bytes out, and no socket anywhere.
  *
  * **The parser** is a push-pull machine. A caller `feed`s whatever slice the
  * socket gave it, of any length and cut anywhere, and then calls `next()`
  * until it answers `HTTP1_NEED_MORE`:
  *
- *     import { Http1Parser, HTTP1_HEAD, HTTP1_BODY, HTTP1_END, HTTP1_ERROR } from "nish/net/http1";
+ *     import { Http1Parser, HTTP1_HEAD, HTTP1_BODY, HTTP1_END, HTTP1_ERROR } from "nish/net/http1-codec";
  *
  *     const p = new Http1Parser(maxTarget, maxHeaderBytes, maxHeaders, maxBody);
  *     p.feed(received, 0, n);

package/std/net/http1-server.ts

@@ -1,6 +1,6 @@
 /**
  * `nish/net/http1-server` — the server side of HTTP/1.1 (RFC 9112): a
- * sans-IO connection that drives `nish/net/http1`'s parser, and two pools of
+ * sans-IO connection that drives `nish/net/http1-codec`'s parser, and two pools of
  * them for a program that owns its readiness loop, one on `nish:net`'s plain
  * TCP and one on `nish/net/tls-tcp` with ALPN `http/1.1`.
  *
@@ -76,12 +76,12 @@
  * given later, reads the clock then. `date.pin(unixMs)` fixes it, for a test
  * that compares bytes.
  *
- * **Refusals.** Every refusal of `nish/net/http1`'s parser — the smuggling
+ * **Refusals.** Every refusal of `nish/net/http1-codec`'s parser — the smuggling
  * shapes, a `Content-Length` with a `Transfer-Encoding`, two that disagree,
  * a malformed chunk size — is answered with its status (400, 413, 414, 431,
  * 501, 505), `Content-Length: 0` and `Connection: close`, and ends the
  * connection; so does a malformed WebSocket frame, with its close code.
- * `docs/security/http1.md` is the record.
+ * `docs/security/http1-codec.md` is the record.
  *
  * **WebSocket.** A request that asked to upgrade reaches the program like any
  * other; `acceptWebSocket(protocol)` answers it with the 101 of
@@ -145,7 +145,7 @@ import {
   http1WriteChunk,
   http1WriteLastChunk,
   http1WriteResponseHead,
-} from "nish/net/http1"
+} from "nish/net/http1-codec"
 import {
   WS_CLOSE,
   WS_ERROR,

package/std/net/outbound.ts

@@ -7,13 +7,13 @@
  * reaches services that trust the program's address.
  *
  *     import { OutboundPolicy } from "nish/net/outbound";
- *     import { HttpOptions } from "nish/net/http-client";
+ *     import { HttpOptions } from "nish/net/fetch";
  *
  *     const options = new HttpOptions();
  *     options.outbound = new OutboundPolicy();
  *
  * **The check is on the address, after the lookup.** A name is never judged
- * by its text: `nish/net/http-client` resolves it, drops every address
+ * by its text: `nish/net/fetch` resolves it, drops every address
  * `outboundAddressAllowed` refuses, and connects only to the bytes it kept,
  * with no second lookup, so a name whose answer changes between a check and
  * a connect (DNS rebinding) cannot move the connection. Every redirect hop is