visaljs 0.0.1 → 0.0.3

package/node/prelude/http.js

@@ -1,11 +1,16 @@
 // node:http (ADR 0012, layer 3), the server side: createServer, Server, IncomingMessage and
-// ServerResponse over the host primitives of runtime/src/host_http.c (libuv TCP, llhttp
-// parsing). Responses are written as Node writes them: the status line, the headers in the
-// order set, then Date, Connection, Keep-Alive and Content-Length or chunked encoding.
-// A request is a Readable of the body's Buffers; a response writes strings and bytes.
-// Not yet: the client, timeouts, upgrades, trailers.
-import { errnoMessage, errnoName, httpAddress, httpCloseServer, httpDate, httpEnd, httpListen, httpWrite } from "visaljs:host";
-import { EventEmitter } from "./events.js";
+// ServerResponse. As in Node, a Server is a net.Server and a request's socket a net.Socket, whose
+// bytes llhttp parses in C (node/src/host_http.c) before JS would see them. Responses are
+// written as Node writes them: the status line, the headers in the order set, then Date,
+// Connection, Keep-Alive and Content-Length or chunked encoding, corked into one write.
+// A request is a Readable of the body's Buffers; a response writes strings and bytes. An
+// upgrade (or CONNECT) hands the socket over with 'upgrade' ('connect'). Idle keep-alive
+// connections close after keepAliveTimeout; server.timeout and setTimeout are the sockets'.
+// Not yet: the client, headersTimeout and requestTimeout, trailers.
+import { httpAttach, httpDate, httpDetach, httpExpired, httpFlush, httpParsers, httpWrite, timerUnref } from "visaljs:host";
+import { codeError, invalidArgType, outOfRange, validateInteger, validateString } from "./internal/errors.js";
+import { Agent, globalAgent } from "./internal/http_agent.js";
+import { createConnection, Server as NetServer } from "./net.js";
 import { Readable, Stream } from "./stream.js";
 
 export const METHODS = ["ACL", "BIND", "CHECKOUT", "CONNECT", "COPY", "DELETE", "GET", "HEAD", "LINK", "LOCK", "M-SEARCH", "MERGE",
@@ -77,6 +82,15 @@ export class IncomingMessage extends Readable {
 
   _read() {}
 
+  /* a response nobody reads: its body is discarded, so the socket isn't held up */
+  _dump() {
+    if (!this._dumped) {
+      this._dumped = true;
+      this.removeAllListeners("data");
+      this.resume();
+    }
+  }
+
   _push(chunk) {
     this.push(Buffer.from(chunk.buffer, chunk.byteOffset, chunk.byteLength));
   }
@@ -89,77 +103,98 @@ export class IncomingMessage extends Readable {
   /* the connection closed before the body was complete */
   _abort() {
     if (this.complete || this.destroyed) return;
-    this.aborted = true;
-    this.emit("aborted");
     const e = new Error("aborted");
     e.code = "ECONNRESET";
     this.destroy(e);
   }
 
+  /* Node's: 'aborted' when the body wasn't all read; 'error' only for those listening for it */
+  _destroy(err, cb) {
+    if (!this.readableEnded || !this.complete) {
+      this.aborted = true;
+      this.emit("aborted");
+    }
+    if (this.socket && !this.socket.destroyed && this.aborted) this.socket.destroy(err);
+    process.nextTick(() => cb(this.listenerCount("error") === 0 ? undefined : err));
+  }
+
   setTimeout(msecs, callback) {
-    if (typeof callback === "function") this.once("timeout", callback);
+    if (typeof callback === "function") this.on("timeout", callback);
+    this.socket.setTimeout(msecs);
     return this;
   }
 }
 
 /* Node's req.headers: lowercase names; repeats joined with ", " ("; " for cookie), kept as an
- * array for set-cookie, and the first one kept for the headers that can't repeat */
+ * array for set-cookie, and the first one kept for the headers that can't repeat (unless
+ * joinDuplicateHeaders) */
 const SINGLE = new Set(["age", "authorization", "content-length", "content-type", "etag", "expires", "from", "host",
   "if-modified-since", "if-unmodified-since", "last-modified", "location", "max-forwards", "proxy-authorization", "referer",
   "retry-after", "server", "user-agent"]);
 
-function addHeader(headers, name, value) {
+function addHeader(headers, name, value, join) {
   const key = name.toLowerCase();
   const existing = headers[key];
   if (existing === undefined) headers[key] = key === "set-cookie" ? [value] : value;
   else if (key === "set-cookie") existing.push(value);
-  else if (SINGLE.has(key)) return;
+  else if (SINGLE.has(key) && !join) return;
   else headers[key] = existing + (key === "cookie" ? "; " : ", ") + value;
 }
 
-/* ---- ServerResponse ------------------------------------------------------------------------- */
+/* ---- OutgoingMessage: a response's (and a request's) headers ------------------------------------ */
+
+/* Node's checks: a header name is an HTTP token; a value has no control characters */
+const tokenRegExp = /^[\^_`a-zA-Z\-0-9!#$%&'*+.|~]+$/;
+const headerCharRegex = /[^\t\x20-\x7e\x80-\xff]/;
 
-export class ServerResponse extends Stream {
-  constructor(req, conn, keepAlive) {
+export function validateHeaderName(name, label = "Header name") {
+  if (typeof name !== "string" || !name || !tokenRegExp.test(name)) {
+    throw codeError(TypeError, "ERR_INVALID_HTTP_TOKEN", label + " must be a valid HTTP token [\"" + name + "\"]");
+  }
+}
+
+export function validateHeaderValue(name, value) {
+  if (value === undefined) throw codeError(TypeError, "ERR_HTTP_INVALID_HEADER_VALUE", "Invalid value \"" + value + "\" for header \"" + name + "\"");
+  if (headerCharRegex.test(value)) throw codeError(TypeError, "ERR_INVALID_CHAR", "Invalid character in header content [\"" + name + "\"]");
+}
+
+const headersSent = (what) => codeError(Error, "ERR_HTTP_HEADERS_SENT", "Cannot " + what + " headers after they are sent to the client");
+
+export class OutgoingMessage extends Stream {
+  constructor() {
     super();
     this.writable = true;
     this.destroyed = false;
     this.writableCorked = 0;
     this.writableNeedDrain = false;
     this.writableHighWaterMark = 16384;
-    /* Node's OutgoingMessage internals, which frameworks set (@hono/node-server sets
-     * _contentLength to have the length sent after the other headers, as Node sends it) */
-    this.useChunkedEncodingByDefault = true;
-    this._hasBody = req.method !== "HEAD";
-    this._contentLength = null;
-    this._removedContLen = false;
-    this.req = req;
-    this.socket = req.socket;
-    this.statusCode = 200;
-    this.statusMessage = undefined;
     this.headersSent = false;
     this.finished = false;
     this.writableEnded = false;
     this.writableFinished = false;
-    this.sendDate = true;
+    this.sendDate = false;
     this.chunkedEncoding = false;
-    this._conn = conn;
-    this._keepAlive = keepAlive;
+    this.useChunkedEncodingByDefault = true;
+    this._hasBody = true;
+    this._contentLength = null;
+    this._removedContLen = false;
+    this._trailer = "";
     this._headers = new Map();  /* lowercase name → [name as set, value] */
-    this._head = req.method === "HEAD";
+    this.socket = null;
   }
 
   setHeader(name, value) {
-    if (this.headersSent) {
-      const e = new Error("Cannot set headers after they are sent to the client");
-      e.code = "ERR_HTTP_HEADERS_SENT";
-      throw e;
-    }
+    if (this.headersSent) throw headersSent("set");
+    validateHeaderName(name);
+    validateHeaderValue(name, value);
     this._headers.set(String(name).toLowerCase(), [String(name), value]);
     return this;
   }
 
   appendHeader(name, value) {
+    if (this.headersSent) throw headersSent("append");
+    validateHeaderName(name);
+    validateHeaderValue(name, value);
     const key = String(name).toLowerCase();
     const existing = this._headers.get(key);
     if (existing === undefined) return this.setHeader(name, value);
@@ -183,8 +218,74 @@ export class ServerResponse extends Stream {
     if (this.writableCorked) this.writableCorked--;
   }
 
+  getHeader(name) {
+    validateString(name, "name");
+    const h = this._headers.get(String(name).toLowerCase());
+    return h === undefined ? undefined : h[1];
+  }
+
+  hasHeader(name) {
+    return this._headers.has(String(name).toLowerCase());
+  }
+
+  removeHeader(name) {
+    validateString(name, "name");
+    if (this.headersSent) throw headersSent("remove");
+    if (name.toLowerCase() === "content-length") this._removedContLen = true;
+    this._headers.delete(String(name).toLowerCase());
+  }
+
+  getHeaderNames() {
+    return [...this._headers.keys()];
+  }
+
+  getHeaders() {
+    const out = Object.create(null);
+    for (const [key, [, value]] of this._headers) out[key] = value;
+    return out;
+  }
+
+  getRawHeaderNames() {
+    return [...this._headers.values()].map(([name]) => name);
+  }
+
+  /* trailers, sent after a chunked body: { name: value } or [[name, value], …] */
+  addTrailers(headers) {
+    this._trailer = "";
+    const entries = Array.isArray(headers) ? headers : Object.keys(headers).map((key) => [key, headers[key]]);
+    for (const [field, value] of entries) {
+      validateHeaderName(field, "Trailer name");
+      const values = Array.isArray(value) && value.length > 1 ? value : [Array.isArray(value) ? value.join("; ") : value];
+      for (const v of values) {
+        if (headerCharRegex.test(v)) throw codeError(TypeError, "ERR_INVALID_CHAR", "Invalid character in trailer content [\"" + field + "\"]");
+        this._trailer += field + ": " + v + "\r\n";
+      }
+    }
+  }
+}
+
+/* ---- ServerResponse ------------------------------------------------------------------------- */
+
+export class ServerResponse extends OutgoingMessage {
+  constructor(req, conn, keepAlive, server) {
+    super();
+    /* Node's OutgoingMessage internals, which frameworks set (@hono/node-server sets
+     * _contentLength to have the length sent after the other headers, as Node sends it) */
+    this._hasBody = req.method !== "HEAD";
+    this.req = req;
+    this.socket = req.socket;
+    this.statusCode = 200;
+    this.statusMessage = undefined;
+    this.sendDate = true;
+    this._conn = conn;
+    this._keepAlive = keepAlive;
+    this._keepAliveTimeout = server ? server.keepAliveTimeout : 5000;
+    this._head = req.method === "HEAD";
+  }
+
   setTimeout(msecs, callback) {
-    if (typeof callback === "function") this.once("timeout", callback);
+    if (typeof callback === "function") this.on("timeout", callback);
+    if (this.socket) this.socket.setTimeout(msecs);
     return this;
   }
 
@@ -197,7 +298,8 @@ export class ServerResponse extends Stream {
     if (this.destroyed) return this;
     this.destroyed = true;
     this.writable = false;
-    httpEnd(this._conn, true);
+    this._closeEmitted = true;
+    if (this.socket) this.socket.destroy();
     queueMicrotask(() => {
       if (error) this.emit("error", error);
       this.emit("close");
@@ -214,29 +316,6 @@ export class ServerResponse extends Stream {
     queueMicrotask(() => this.emit("close"));
   }
 
-  getHeader(name) {
-    const h = this._headers.get(String(name).toLowerCase());
-    return h === undefined ? undefined : h[1];
-  }
-
-  hasHeader(name) {
-    return this._headers.has(String(name).toLowerCase());
-  }
-
-  removeHeader(name) {
-    this._headers.delete(String(name).toLowerCase());
-  }
-
-  getHeaderNames() {
-    return [...this._headers.keys()];
-  }
-
-  getHeaders() {
-    const out = Object.create(null);
-    for (const [key, [, value]] of this._headers) out[key] = value;
-    return out;
-  }
-
   writeHead(statusCode, statusMessage, headers) {
     if (typeof statusMessage !== "string") {
       headers = statusMessage;
@@ -275,7 +354,13 @@ export class ServerResponse extends Stream {
     if (this.sendDate && !this._headers.has("date")) head += "Date: " + httpDate() + "\r\n";
     const connection = this._headers.get("connection");
     if (connection !== undefined && String(connection[1]).toLowerCase().includes("close")) this._keepAlive = false;
-    if (connection === undefined) head += this._keepAlive ? "Connection: keep-alive\r\nKeep-Alive: timeout=5\r\n" : "Connection: close\r\n";
+    if (connection === undefined) {
+      if (!this._keepAlive) head += "Connection: close\r\n";
+      else {
+        head += "Connection: keep-alive\r\n";
+        if (this._keepAliveTimeout) head += "Keep-Alive: timeout=" + Math.floor(this._keepAliveTimeout / 1000) + "\r\n";
+      }
+    }
     /* Node: no length for HEAD; an HTTP/1.0 client gets a body that ends with the connection */
     const http10 = this.req.httpVersionMajor < 1 || this.req.httpVersionMinor < 1;
     /* a Transfer-Encoding: chunked the program set: the body is chunk-encoded, as Node does */
@@ -340,11 +425,14 @@ export class ServerResponse extends Stream {
       if (chunk !== undefined && chunk !== null) this.write(chunk);
       const head = this._takeHead(undefined);
       if (head) httpWrite(this._conn, head);
-      if (this.chunkedEncoding && !this._head) httpWrite(this._conn, "0\r\n\r\n");
+      if (this.chunkedEncoding && !this._head) httpWrite(this._conn, "0\r\n" + this._trailer + "\r\n");
     }
     this.writableEnded = this.finished = true;
     this.writable = false;
-    httpEnd(this._conn, !this._keepAlive);
+    if (!this._keepAlive && this.socket) {  /* the response goes out, then the socket ends */
+      httpFlush(this._conn);
+      this.socket.destroySoon();
+    }
     queueMicrotask(() => {
       this.writableFinished = true;
       this.emit("finish");
@@ -358,141 +446,174 @@ export class ServerResponse extends Stream {
   }
 }
 
-/* ---- Socket: what a request's and a response's `socket` is ---------------------------------- */
+/* ---- Server --------------------------------------------------------------------------------- */
 
-class Socket extends EventEmitter {
-  constructor(conn) {
-    super();
-    this._conn = conn;
-    this.remoteAddress = undefined;
-    this.remotePort = undefined;
-    this.encrypted = false;
-    this.destroyed = false;
-    this.readable = true;
-    this.writable = true;
-  }
+const badRequestResponse = "HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n";
+const headersTooLargeResponse = "HTTP/1.1 431 Request Header Fields Too Large\r\nConnection: close\r\n\r\n";
+const requestTimeoutResponse = "HTTP/1.1 408 Request Timeout\r\nConnection: close\r\n\r\n";
 
-  destroy() {
-    if (!this.destroyed) {
-      this.destroyed = true;
-      httpEnd(this._conn, true);
-    }
-    return this;
-  }
+function noop() {}
 
-  destroySoon() {
-    return this.destroy();
+export class Server extends NetServer {
+  constructor(options, requestListener) {
+    if (typeof options === "function") {
+      requestListener = options;
+      options = {};
+    } else if (options === undefined || options === null) {
+      options = {};
+    } else if (typeof options !== "object") {
+      throw invalidArgType("options", "of type object", options);
+    }
+    super({ allowHalfOpen: true, noDelay: options.noDelay ?? true, keepAlive: options.keepAlive, keepAliveInitialDelay: options.keepAliveInitialDelay });
+    if (typeof requestListener === "function") this.on("request", requestListener);
+    this.httpAllowHalfOpen = false;
+    this.timeout = 0;
+    this.maxHeadersCount = null;
+    this.maxRequestsPerSocket = 0;
+    /* Node's storeHTTPOptions and the server's timeouts */
+    const integer = (name, fallback) => {
+      const value = options[name];
+      if (value === undefined) return fallback;
+      validateInteger(value, name);
+      if (value < 0) throw outOfRange(name, ">= 0 && <= 9007199254740991", value);
+      return value;
+    };
+    const boolean = (name, fallback) => {
+      const value = options[name];
+      if (value === undefined) return fallback;
+      if (typeof value !== "boolean") throw invalidArgType("options." + name, "of type boolean", value);
+      return value;
+    };
+    this.maxHeaderSize = integer("maxHeaderSize", undefined);
+    this.insecureHTTPParser = boolean("insecureHTTPParser", undefined);
+    this.requireHostHeader = boolean("requireHostHeader", true);
+    this.joinDuplicateHeaders = boolean("joinDuplicateHeaders", undefined);
+    this.requestTimeout = integer("requestTimeout", 300_000);
+    this.headersTimeout = integer("headersTimeout", Math.min(60_000, this.requestTimeout));
+    if (this.requestTimeout > 0 && this.headersTimeout > 0 && this.headersTimeout > this.requestTimeout) {
+      throw outOfRange("headersTimeout", "<= requestTimeout", this.headersTimeout);
+    }
+    this.keepAliveTimeout = integer("keepAliveTimeout", 5000);
+    this.connectionsCheckingInterval = integer("connectionsCheckingInterval", 30_000);
+    this._checking = null;  /* the connections-checking timer, unref'd, while listening */
+    this._parsers = -1;
+    this._states = new Map();  /* connection → { socket, req, res, keepAliveTimeoutSet } */
+    this.on("connection", (socket) => this._onSocket(socket));
+    this.on("listening", () => this._checkConnectionsLater());
   }
 
-  end() {
-    return this.destroy();
+  /* Node's checkConnections: a request (or its head) over requestTimeout (headersTimeout) gets a 408 */
+  _checkConnectionsLater() {
+    if (this.connectionsCheckingInterval <= 0 || this._checking !== null) return;
+    this._checking = timerUnref(() => {
+      this._checking = null;
+      if (this._handle === null) return;
+      if (this._parsers !== -1 && (this.headersTimeout > 0 || this.requestTimeout > 0)) {
+        for (const conn of httpExpired(this._parsers, this.headersTimeout, this.requestTimeout)) {
+          const state = this._states.get(conn);
+          if (state) socketOnError.call(state.socket, codeError(Error, "ERR_HTTP_REQUEST_TIMEOUT", "Request timeout"));
+        }
+      }
+      this._checkConnectionsLater();
+    }, this.connectionsCheckingInterval);
   }
 
-  setTimeout() {
+  setTimeout(msecs, callback) {
+    this.timeout = msecs;
+    if (typeof callback === "function") this.on("timeout", callback);
     return this;
   }
 
-  setNoDelay() {
-    return this;
+  /* the sockets go before the server stops listening: idle ones on close(), all on request */
+  closeAllConnections() {
+    for (const { socket } of [...this._states.values()]) socket.destroy();
   }
 
-  setKeepAlive() {
-    return this;
+  closeIdleConnections() {
+    for (const state of [...this._states.values()]) if (!state.req && !state.res) state.socket.destroy();
   }
 
-  ref() {
-    return this;
+  close(callback) {
+    this.closeIdleConnections();
+    if (this._checking !== null) clearTimeout(this._checking);
+    this._checking = null;
+    return super.close(callback);
   }
 
-  unref() {
-    return this;
+  /* a connection: its bytes go to llhttp; its end, timeout, errors and close are the requests' */
+  _onSocket(socket) {
+    if (this._parsers === -1) {
+      this._parsers = httpParsers(
+        (conn, method, url, raw, major, minor, keepAlive, upgrade) => this._onRequest(conn, method, url, raw, major, minor, keepAlive, upgrade),
+        (conn, chunk) => this._states.get(conn)?.req?._push(chunk),
+        (conn, trailers) => {
+          const state = this._states.get(conn);
+          const req = state?.req;
+          if (req) {
+            if (state.res === null || state.res.writableEnded) state.req = null;
+            if (trailers) {
+              req.rawTrailers = trailers;
+              for (let i = 0; i < trailers.length; i += 2) addHeader(req.trailers, trailers[i], trailers[i + 1]);
+            }
+            req._finish();
+          }
+        },
+        (conn, head) => this._onUpgrade(conn, head),
+        (conn, code, reason) => {
+          const state = this._states.get(conn);
+          if (!state) return;
+          const e = new Error("Parse Error: " + reason);
+          e.code = code;
+          e.reason = reason;
+          socketOnError.call(state.socket, e);
+        },
+      );
+    }
+    const conn = socket._handle;
+    if (conn === null) return;
+    const state = { socket, conn, req: null, res: null, keepAliveTimeoutSet: false, listeners: null };
+    this._states.set(conn, state);
+    if (this.timeout && typeof socket.setTimeout === "function") socket.setTimeout(this.timeout);
+    const onTimeout = () => this._onTimeout(state);
+    const onEnd = () => {
+      this._abortIncoming(state);
+      if (socket.writable) socket.end();
+    };
+    const onClose = () => {
+      this._states.delete(conn);
+      this._abortIncoming(state);
+      const res = state.res;
+      state.res = null;
+      if (res) res._connectionClosed();
+    };
+    state.listeners = { timeout: onTimeout, end: onEnd, close: onClose, error: socketOnError };
+    for (const [event, fn] of Object.entries(state.listeners)) socket.on(event, fn);
+    httpAttach(conn, this._parsers, false, this.maxHeaderSize ?? maxHeaderSize);
   }
-}
 
-/* ---- Server --------------------------------------------------------------------------------- */
+  _abortIncoming(state) {
+    const req = state.req;
+    state.req = null;
+    if (req) req._abort();
+  }
 
-export class Server extends EventEmitter {
-  constructor(options, requestListener) {
-    super();
-    if (typeof options === "function") requestListener = options;
-    if (typeof requestListener === "function") this.on("request", requestListener);
-    this.listening = false;
-    this._id = -1;
-    this._requests = new Map();  /* connection → the request being received */
-    this._sockets = new Map();   /* connection → its socket object */
-    this._responses = new Map(); /* connection → the response being written */
-  }
-
-  listen(...args) {
-    let port, host, backlog = 511, callback;
-    if (typeof args[args.length - 1] === "function") callback = args.pop();
-    if (args[0] !== null && typeof args[0] === "object") {
-      port = args[0].port ?? 0;
-      host = args[0].host;
-      backlog = args[0].backlog ?? backlog;
-    } else {
-      port = args[0] ?? 0;
-      if (typeof args[1] === "string") host = args[1];
-      if (typeof args[args.length - 1] === "number" && args.length > 1) backlog = args[args.length - 1];
-    }
-    if (callback) this.once("listening", callback);
-    const callbacks = [
-      (conn, method, url, raw, major, minor, keepAlive) => this._onRequest(conn, method, url, raw, major, minor, keepAlive),
-      (conn, chunk) => {
-        const req = this._requests.get(conn);
-        if (req) req._push(chunk);
-      },
-      (conn) => {
-        const req = this._requests.get(conn);
-        if (req) {
-          this._requests.delete(conn);
-          req._finish();
-        }
-      },
-      (conn) => {
-        const req = this._requests.get(conn);
-        this._requests.delete(conn);
-        if (req) req._abort();
-        const res = this._responses.get(conn);
-        this._responses.delete(conn);
-        if (res) res._connectionClosed();
-        const socket = this._sockets.get(conn);
-        this._sockets.delete(conn);
-        if (socket) {
-          socket.destroyed = true;
-          socket.emit("close", false);
-        }
-      },
-    ];
-    let address = host ?? "::";
-    let id = httpListen(address, Number(port), backlog, ...callbacks);
-    if (id < 0 && host === undefined && errnoName(id) === "EAFNOSUPPORT") {  /* no IPv6: Node falls back to IPv4 */
-      address = "0.0.0.0";
-      id = httpListen(address, Number(port), backlog, ...callbacks);
-    }
-    if (id < 0) {
-      const code = errnoName(id);
-      const err = new Error("listen " + code + ": " + errnoMessage(id) + " " + address + ":" + port);
-      err.code = code;
-      err.errno = id;
-      err.syscall = "listen";
-      err.address = address;
-      err.port = Number(port);
-      queueMicrotask(() => this.emit("error", err));
-      return this;
-    }
-    this._id = id;
-    this.listening = true;
-    queueMicrotask(() => this.emit("listening"));
-    return this;
+  /* Node's socketOnTimeout: the request's, the response's or the server's 'timeout', or the end */
+  _onTimeout(state) {
+    const req = state.req;
+    const reqTimeout = req && !req.complete && req.emit("timeout", state.socket);
+    const res = state.res;
+    const resTimeout = res && res.emit("timeout", state.socket);
+    const serverTimeout = this.emit("timeout", state.socket);
+    if (!reqTimeout && !resTimeout && !serverTimeout) state.socket.destroy();
   }
 
-  _onRequest(conn, method, url, raw, major, minor, keepAlive) {
-    let socket = this._sockets.get(conn);
-    if (!socket) {
-      socket = new Socket(conn);
-      this._sockets.set(conn, socket);
-      this.emit("connection", socket);
+  _onRequest(conn, method, url, raw, major, minor, keepAlive, upgrade) {
+    const state = this._states.get(conn);
+    if (!state) return 0;
+    const socket = state.socket;
+    if (state.keepAliveTimeoutSet) {
+      socket.setTimeout(0);
+      state.keepAliveTimeoutSet = false;
     }
     const req = new IncomingMessage(socket);
     req.method = method;
@@ -501,31 +622,62 @@ export class Server extends EventEmitter {
     req.httpVersionMinor = minor;
     req.httpVersion = major + "." + minor;
     req.rawHeaders = raw;
-    for (let i = 0; i < raw.length; i += 2) addHeader(req.headers, raw[i], raw[i + 1]);
-    this._requests.set(conn, req);
-    const res = new ServerResponse(req, conn, keepAlive);
-    this._responses.set(conn, res);
+    for (let i = 0; i < raw.length; i += 2) addHeader(req.headers, raw[i], raw[i + 1], this.joinDuplicateHeaders);
+    req.upgrade = upgrade && (method === "CONNECT" || this.listenerCount("upgrade") > 0);
+    if (req.upgrade) {
+      state.upgradeReq = req;
+      return 2;
+    }
+    state.req = req;
+    const res = new ServerResponse(req, conn, keepAlive, this);
+    state.res = res;
+    if (this.requireHostHeader && major === 1 && minor === 1 && !req.headers.host) {  /* Node: a 400, and the connection ends */
+      res.writeHead(400, ["Connection", "close"]);
+      res.end();
+      return 0;
+    }
     res.once("finish", () => {
-      if (this._responses.get(conn) === res) this._responses.delete(conn);
+      if (state.res === res) state.res = null;
+      if (state.req === req && req.complete) state.req = null;
+      if (res._keepAlive && !state.res && this.keepAliveTimeout && socket.writable) {
+        socket.setTimeout(this.keepAliveTimeout);
+        state.keepAliveTimeoutSet = true;
+      }
     });
     this.emit("request", req, res);
+    return 0;
   }
 
-  address() {
-    const a = httpAddress(this._id);
-    return a === null ? null : { address: a[0], family: a[1], port: a[2] };
+  /* the parser let go of the socket after an upgrade's head: it's the 'upgrade' listener's */
+  _onUpgrade(conn, head) {
+    const state = this._states.get(conn);
+    if (!state) return;
+    const { socket, upgradeReq: req } = state;
+    this._states.delete(conn);
+    for (const [event, fn] of Object.entries(state.listeners)) socket.removeListener(event, fn);
+    if (socket.listenerCount("error") === 0) socket.on("error", noop);
+    /* what the socket reads next goes to its stream, buffered until someone reads it */
+    socket._readableState.flowing = null;
+    const bodyHead = Buffer.from(head.buffer, head.byteOffset, head.byteLength);
+    const eventName = req.method === "CONNECT" ? "connect" : "upgrade";
+    if (eventName === "upgrade" || this.listenerCount(eventName) > 0) this.emit(eventName, req, socket, bodyHead);
+    else socket.destroy();
   }
+}
 
-  close(callback) {
-    if (this.listening) {
-      httpCloseServer(this._id);
-      this.listening = false;
+/* Node's socketOnError: 'clientError', or a 400 (when nothing was written yet) and the end */
+function socketOnError(e) {
+  this.removeListener("error", socketOnError);
+  if (this.listenerCount("error") === 0) this.on("error", noop);
+  const server = this.server;
+  if (!server.emit("clientError", e, this)) {
+    const state = server._states.get(this._handle);
+    const res = state?.res;
+    if (this.writable && (!res || !res.headersSent)) {
+      if (state) httpFlush(state.conn);
+      this.write(e.code === "HPE_HEADER_OVERFLOW" ? headersTooLargeResponse : e.code === "ERR_HTTP_REQUEST_TIMEOUT" ? requestTimeoutResponse : badRequestResponse);
     }
-    queueMicrotask(() => {
-      this.emit("close");
-      if (typeof callback === "function") callback();
-    });
-    return this;
+    this.destroy(e);
   }
 }
 
@@ -533,4 +685,696 @@ export function createServer(options, requestListener) {
   return new Server(options, requestListener);
 }
 
-export default { METHODS, STATUS_CODES, IncomingMessage, ServerResponse, Server, createServer };
+/* ---- The client: ClientRequest, request, get ------------------------------------------------- */
+
+const connReset = (message) => codeError(Error, "ECONNRESET", message);
+
+function urlToHttpOptions(url) {
+  const { hostname, pathname, port, username, password, search } = url;
+  const options = {
+    __proto__: null, ...url, protocol: url.protocol, hostname: hostname && hostname[0] === "[" ? hostname.slice(1, -1) : hostname,
+    hash: url.hash, search, pathname, path: (pathname || "") + (search || ""), href: url.href,
+  };
+  if (port !== "") options.port = Number(port);
+  if (username || password) options.auth = decodeURIComponent(username) + ":" + decodeURIComponent(password);
+  return options;
+}
+
+/* the sockets whose responses llhttp parses: handle id → socket */
+const clientSockets = new Map();
+let clientParsers = -1;
+
+function clientParsersId() {
+  if (clientParsers !== -1) return clientParsers;
+  const reqOf = (conn) => clientSockets.get(conn)?._httpMessage;
+  clientParsers = httpParsers(
+    (conn, statusCode, statusMessage, raw, major, minor, keepAlive, upgrade) => {
+      const socket = clientSockets.get(conn);
+      const req = socket?._httpMessage;
+      if (!req) return 0;
+      const res = new IncomingMessage(socket);
+      res.statusCode = statusCode;
+      res.statusMessage = statusMessage;
+      res.httpVersionMajor = major;
+      res.httpVersionMinor = minor;
+      res.httpVersion = major + "." + minor;
+      res.rawHeaders = raw;
+      for (let i = 0; i < raw.length; i += 2) addHeader(res.headers, raw[i], raw[i + 1], req.joinDuplicateHeaders);
+      res.upgrade = upgrade;
+      return parserOnIncomingClient(req, socket, res, keepAlive);
+    },
+    (conn, chunk) => reqOf(conn)?.res?._push(chunk),
+    (conn, trailers) => {
+      const socket = clientSockets.get(conn);
+      const req = socket?._httpMessage;
+      const res = req?.res;
+      if (!res) return;
+      if (res.upgrade) {  /* llhttp completes an upgrade's head before it pauses: the upgrade frees the parser */
+        res.complete = true;
+        return;
+      }
+      if (trailers) {
+        res.rawTrailers = trailers;
+        for (let i = 0; i < trailers.length; i += 2) addHeader(res.trailers, trailers[i], trailers[i + 1]);
+      }
+      if (!statusIsInformational(res.statusCode)) freeParser(socket);
+      res._finish();
+    },
+    (conn, head) => {
+      const socket = clientSockets.get(conn);
+      if (socket?._httpMessage) clientUpgrade(socket._httpMessage, socket, head);
+    },
+    (conn, code, reason) => {
+      const socket = clientSockets.get(conn);
+      const req = socket?._httpMessage;
+      const e = new Error("Parse Error: " + reason);
+      e.code = code;
+      e.reason = reason;
+      if (socket) {
+        freeParser(socket);
+        socket.destroy();
+      }
+      if (req) {
+        socket._hadError = true;
+        req.emit("error", e);
+      }
+    },
+  );
+  return clientParsers;
+}
+
+const statusIsInformational = (status) => status < 200 && status >= 100 && status !== 101;
+
+/* the socket's bytes go to a response parser: now, or once it has connected */
+function attachParser(socket, req) {
+  const attach = () => {
+    if (socket._httpMessage !== req || socket._handle === null) return;
+    clientSockets.set(socket._handle, socket);
+    socket._clientConn = socket._handle;
+    httpAttach(socket._handle, clientParsersId(), true, req.maxHeaderSize ?? maxHeaderSize);
+  };
+  if (socket.connecting || socket._handle === null) socket.once("connect", attach);
+  else attach();
+}
+
+function freeParser(socket) {
+  const conn = socket._clientConn;
+  if (conn === undefined) return;
+  socket._clientConn = undefined;
+  clientSockets.delete(conn);
+  httpDetach(conn);
+}
+
+/* Node's parserOnIncomingClient: 0, or 1 for no body, or 2 to take the socket */
+function parserOnIncomingClient(req, socket, res, shouldKeepAlive) {
+  if (req.res) {  /* a second response to one request */
+    socket.destroy();
+    return 0;
+  }
+  req.res = res;
+  if (res.upgrade) return 2;
+  if (req.method === "CONNECT") {
+    res.upgrade = true;
+    return 2;
+  }
+  if (statusIsInformational(res.statusCode)) {  /* 1xx: the final response follows */
+    req.res = null;
+    if (res.statusCode === 100) req.emit("continue");
+    req.emit("information", {
+      statusCode: res.statusCode, statusMessage: res.statusMessage, httpVersion: res.httpVersion, httpVersionMajor: res.httpVersionMajor,
+      httpVersionMinor: res.httpVersionMinor, headers: res.headers, rawHeaders: res.rawHeaders,
+    });
+    return 1;
+  }
+  if (req.shouldKeepAlive && !shouldKeepAlive && !req.upgradeOrConnect) req.shouldKeepAlive = false;
+  res.req = req;
+  res.on("end", responseOnEnd);
+  req.on("finish", requestOnFinish);
+  socket.on("timeout", responseOnTimeout);
+  if (req.aborted || !req.emit("response", res)) res._dump();
+  if (req.method === "HEAD") return 1;
+  if (res.statusCode === 304) {
+    res.complete = true;
+    return 1;
+  }
+  return 0;
+}
+
+function clientUpgrade(req, socket, head) {
+  socket.removeListener("end", socketOnEnd);
+  if (req.timeoutCb) socket.removeListener("timeout", req.timeoutCb);
+  socket.removeListener("timeout", responseOnTimeout);
+  freeParser(socket);
+  const bodyHead = Buffer.from(head.buffer, head.byteOffset, head.byteLength);
+  const eventName = req.method === "CONNECT" ? "connect" : "upgrade";
+  if (req.listenerCount(eventName) > 0) {
+    req.upgradeOrConnect = true;
+    socket.emit("agentRemove");
+    socket.removeListener("close", socketCloseListener);
+    socket.removeListener("error", socketErrorListener);
+    socket._httpMessage = null;
+    socket._readableState.flowing = null;
+    req.emit(eventName, req.res, socket, bodyHead);
+    req.destroyed = true;
+    req._closed = true;
+    req.emit("close");
+  } else {
+    socket.destroy();
+  }
+}
+
+function responseOnEnd() {
+  const req = this.req;
+  const socket = req.socket;
+  if (socket) {
+    if (req.timeoutCb) socket.removeListener("timeout", emitRequestTimeout);
+    socket.removeListener("timeout", responseOnTimeout);
+  }
+  req._ended = true;
+  if (!req.shouldKeepAlive) {
+    if (socket.writable) socket.destroySoon();
+  } else if (req.writableFinished && !this.aborted) {
+    responseKeepAlive(req);
+  }
+}
+
+function requestOnFinish() {
+  if (this.shouldKeepAlive && this._ended) responseKeepAlive(this);
+}
+
+/* the response is read and the request sent: the socket goes back to the agent */
+function responseKeepAlive(req) {
+  const socket = req.socket;
+  if (req.timeoutCb) {
+    socket.setTimeout(0, req.timeoutCb);
+    req.timeoutCb = null;
+  }
+  socket.removeListener("close", socketCloseListener);
+  socket.removeListener("error", socketErrorListener);
+  socket.removeListener("end", socketOnEnd);
+  process.nextTick(() => {
+    req._closed = true;
+    req.emit("close");
+    if (req.socket) req.socket.emit("free");
+  });
+  req.destroyed = true;
+  if (req.res) req.res.socket = null;
+}
+
+function responseOnTimeout() {
+  const req = this._httpMessage;
+  if (req?.res) req.res.emit("timeout");
+}
+
+function emitRequestTimeout() {
+  const req = this._httpMessage;
+  if (req) req.emit("timeout");
+}
+
+function listenSocketTimeout(req) {
+  if (req.timeoutCb) return;
+  req.timeoutCb = emitRequestTimeout;
+  if (req.socket) req.socket.once("timeout", emitRequestTimeout);
+  else req.on("socket", (socket) => socket.once("timeout", emitRequestTimeout));
+}
+
+function socketCloseListener() {
+  const req = this._httpMessage;
+  const res = req.res;
+  req.destroyed = true;
+  if (res) {
+    if (!res.complete) res.destroy(connReset("aborted"));
+    req._closed = true;
+    req.emit("close");
+    if (!res.aborted && res.readable) res.push(null);
+  } else {
+    if (!this._hadError) {  /* closed before a response: the request's error */
+      this._hadError = true;
+      req.emit("error", connReset("socket hang up"));
+    }
+    req._closed = true;
+    req.emit("close");
+  }
+  req.outputData.length = 0;
+  freeParser(this);
+}
+
+function socketErrorListener(err) {
+  const req = this._httpMessage;
+  if (req) {
+    this._hadError = true;
+    req.emit("error", err);
+  }
+  freeParser(this);
+  this.removeListener("end", socketOnEnd);
+  this.destroy();
+}
+
+function socketOnEnd() {
+  const req = this._httpMessage;
+  if (!req.res && !this._hadError) {
+    this._hadError = true;
+    req.emit("error", connReset("socket hang up"));
+  }
+  freeParser(this);
+  this.destroy();
+}
+
+const INVALID_PATH_REGEX = /[^!-ÿ]/;
+
+export class ClientRequest extends OutgoingMessage {
+  constructor(input, options, cb) {
+    super();
+    if (typeof input === "string") input = urlToHttpOptions(new URL(input));
+    else if (input instanceof URL) input = urlToHttpOptions(input);
+    else {
+      cb = options;
+      options = input;
+      input = null;
+    }
+    if (typeof options === "function") {
+      cb = options;
+      options = input || {};
+    } else {
+      options = { ...input, ...options };
+    }
+    let agent = options.agent;
+    const defaultAgent = options._defaultAgent || globalAgent;
+    if (agent === false) agent = new defaultAgent.constructor();
+    else if (agent === null || agent === undefined) {
+      if (typeof options.createConnection !== "function") agent = defaultAgent;
+      options._defaultAgent = defaultAgent;
+    } else if (typeof agent.addRequest !== "function") {
+      throw invalidArgType("options.agent", "one of Agent-like Object, undefined, or false", agent);
+    }
+    this.agent = agent;
+    const protocol = options.protocol || defaultAgent.protocol;
+    const expectedProtocol = this.agent?.protocol || defaultAgent.protocol;
+    if (options.path && INVALID_PATH_REGEX.test(String(options.path))) {
+      throw codeError(TypeError, "ERR_UNESCAPED_CHARACTERS", "Request path contains unescaped characters");
+    }
+    if (protocol !== expectedProtocol) {
+      throw codeError(TypeError, "ERR_INVALID_PROTOCOL", "Protocol \"" + protocol + "\" not supported. Expected \"" + expectedProtocol + "\"");
+    }
+    const defaultPort = options.defaultPort || this.agent?.defaultPort;
+    const optsWithoutSignal = { __proto__: null, ...options };
+    const port = optsWithoutSignal.port = options.port || defaultPort || 80;
+    const validHost = (host, name) => {
+      if (host !== null && host !== undefined && typeof host !== "string") throw invalidArgType("options." + name, "of type string or one of undefined or null", host);
+      return host;
+    };
+    const host = optsWithoutSignal.host = validHost(options.hostname, "hostname") || validHost(options.host, "host") || "localhost";
+    const setHost = options.setHost === undefined || Boolean(options.setHost);
+    this.socketPath = options.socketPath;
+    if (options.timeout !== undefined) {
+      if (typeof options.timeout !== "number") throw invalidArgType("timeout", "of type number", options.timeout);
+      this.timeout = options.timeout;
+    }
+    const signal = options.signal;
+    if (signal) {
+      delete optsWithoutSignal.signal;
+      const onAbort = () => this.destroy(codeError(Error, "ABORT_ERR", "The operation was aborted"));
+      if (signal.aborted) process.nextTick(onAbort);
+      else {
+        signal.addEventListener("abort", onAbort, { once: true });
+        this.once("close", () => signal.removeEventListener("abort", onAbort));
+      }
+    }
+    let method = options.method;
+    if (method !== null && method !== undefined && typeof method !== "string") throw invalidArgType("options.method", "of type string", method);
+    if (method) {
+      if (!tokenRegExp.test(method)) throw codeError(TypeError, "ERR_INVALID_HTTP_TOKEN", "Method must be a valid HTTP token [\"" + method + "\"]");
+      method = this.method = method.toUpperCase();
+    } else {
+      method = this.method = "GET";
+    }
+    if (options.maxHeaderSize !== undefined) validateInteger(options.maxHeaderSize, "maxHeaderSize");
+    this.maxHeaderSize = options.maxHeaderSize;
+    this.joinDuplicateHeaders = options.joinDuplicateHeaders;
+    this.path = options.path || "/";
+    if (cb) this.once("response", cb);
+    this.useChunkedEncodingByDefault = !(method === "GET" || method === "HEAD" || method === "DELETE" || method === "OPTIONS" ||
+      method === "TRACE" || method === "CONNECT");
+    this._ended = false;
+    this.res = null;
+    this.aborted = false;
+    this.timeoutCb = null;
+    this.upgradeOrConnect = false;
+    this.maxHeadersCount = null;
+    this.reusedSocket = false;
+    this.host = host;
+    this.protocol = protocol;
+    this.outputData = [];
+    this.outputSize = 0;
+    this._header = null;
+    this._headerSent = false;
+    this._closed = false;
+    this.shouldKeepAlive = false;
+    this._last = true;
+    if (this.agent) {
+      if (!this.agent.keepAlive && !Number.isFinite(this.agent.maxSockets)) {
+        this._last = true;
+        this.shouldKeepAlive = false;
+      } else {
+        this._last = false;
+        this.shouldKeepAlive = true;
+      }
+    }
+    if (!Array.isArray(options.headers)) {
+      if (options.headers) for (const key of Object.keys(options.headers)) this.setHeader(key, options.headers[key]);
+      if (host && !this.getHeader("host") && setHost) {
+        let hostHeader = host;
+        const colon = hostHeader.indexOf(":");
+        if (colon !== -1 && hostHeader.includes(":", colon + 1) && hostHeader.charCodeAt(0) !== 91) hostHeader = "[" + hostHeader + "]";
+        if (port && +port !== defaultPort) hostHeader += ":" + port;
+        this.setHeader("Host", hostHeader);
+      }
+      if (options.auth && !this.getHeader("Authorization")) this.setHeader("Authorization", "Basic " + Buffer.from(options.auth).toString("base64"));
+      if (this.getHeader("expect")) this._storeHeader(this.method + " " + this.path + " HTTP/1.1\r\n", null);
+    } else {
+      this._storeHeader(this.method + " " + this.path + " HTTP/1.1\r\n", options.headers);
+    }
+    if (this.agent) {
+      this.agent.addRequest(this, optsWithoutSignal);
+    } else {
+      this._last = true;
+      this.shouldKeepAlive = false;
+      let opts = optsWithoutSignal;
+      if (opts.path || opts.socketPath) {
+        opts = { ...optsWithoutSignal };
+        if (opts.socketPath) opts.path = opts.socketPath;
+        else if (opts.path) opts.path = undefined;
+      }
+      if (typeof opts.createConnection === "function") {
+        let done = false;
+        const oncreate = (err, socket) => {
+          if (done) return;
+          done = true;
+          if (err) process.nextTick(() => this.emit("error", err));
+          else this.onSocket(socket);
+        };
+        try {
+          const newSocket = opts.createConnection(opts, oncreate);
+          if (newSocket) oncreate(null, newSocket);
+        } catch (err) {
+          oncreate(err);
+        }
+      } else {
+        this.onSocket(createConnection(opts));
+      }
+    }
+  }
+
+  /* Node's _storeHeader: the request line, the headers as set (or as given in an array), then
+   * Connection and the body's framing */
+  _storeHeader(firstLine, headersArray) {
+    let head = firstLine;
+    let hasConnection = false, hasLength = false, hasTE = false, hasTrailer = false;
+    const add = (name, value) => {
+      const key = String(name).toLowerCase();
+      if (key === "connection") {
+        hasConnection = true;
+        if (/close/i.test(String(value))) this._last = true;
+        else this.shouldKeepAlive = true;
+      } else if (key === "content-length") hasLength = true;
+      else if (key === "transfer-encoding") {
+        hasTE = true;
+        if (/chunked/i.test(String(value))) this.chunkedEncoding = true;
+      } else if (key === "trailer") hasTrailer = true;
+      if (Array.isArray(value)) for (const v of value) head += name + ": " + v + "\r\n";
+      else head += name + ": " + value + "\r\n";
+    };
+    if (headersArray) {
+      if (Array.isArray(headersArray[0])) for (const [name, value] of headersArray) add(name, value);
+      else for (let i = 0; i < headersArray.length; i += 2) add(headersArray[i], headersArray[i + 1]);
+    } else {
+      for (const [, [name, value]] of this._headers) add(name, value);
+    }
+    if (!hasConnection) {
+      const shouldSendKeepAlive = this.shouldKeepAlive && (hasLength || this.useChunkedEncodingByDefault || this.agent);
+      if (shouldSendKeepAlive) head += "Connection: keep-alive\r\n";
+      else {
+        this._last = true;
+        head += "Connection: close\r\n";
+      }
+    }
+    if (!hasLength && !hasTE) {
+      if (!this._hasBody) this.chunkedEncoding = false;
+      else if (!this.useChunkedEncodingByDefault) this._last = true;
+      else if (!hasTrailer && !this._removedContLen && typeof this._contentLength === "number") head += "Content-Length: " + this._contentLength + "\r\n";
+      else {
+        head += "Transfer-Encoding: chunked\r\n";
+        this.chunkedEncoding = true;
+      }
+    }
+    this._header = head + "\r\n";
+    this._headerSent = false;
+    this.headersSent = true;
+  }
+
+  _implicitHeader() {
+    if (this._header) throw codeError(Error, "ERR_HTTP_HEADERS_SENT", "Cannot render headers after they are sent to the client");
+    this._storeHeader(this.method + " " + this.path + " HTTP/1.1\r\n", null);
+  }
+
+  /* bytes for the socket: written now, or kept until it's assigned */
+  _writeRaw(data, encoding, callback) {
+    const conn = this.socket;
+    if (conn?.destroyed) return false;
+    if (conn && conn._httpMessage === this && conn.writable) {
+      if (this.outputData.length) this._flushOutput(conn);
+      return conn.write(data, encoding, callback);
+    }
+    this.outputData.push({ data, encoding, callback });
+    this.outputSize += data.length;
+    return this.outputSize < this.writableHighWaterMark;
+  }
+
+  /* the head goes with the first bytes: in the same string when it can be */
+  _send(data, encoding, callback) {
+    if (!this._headerSent && this._header !== null) {
+      this._headerSent = true;
+      if (typeof data === "string" && (encoding === "utf8" || encoding === "latin1" || !encoding)) data = this._header + data;
+      else this._writeRaw(this._header, "latin1", null);
+    }
+    return this._writeRaw(data, encoding, callback);
+  }
+
+  _flushOutput(socket) {
+    const output = this.outputData;
+    if (output.length === 0) return undefined;
+    this.outputData = [];
+    this.outputSize = 0;
+    let ret;
+    for (const { data, encoding, callback } of output) ret = socket.write(data, encoding, callback);
+    return ret;
+  }
+
+  _flush() {
+    const socket = this.socket;
+    if (socket?.writable) {
+      const ret = this._flushOutput(socket);
+      if (!this.finished && ret && this._needDrain) {
+        this._needDrain = false;
+        this.emit("drain");
+      }
+    }
+  }
+
+  write(chunk, encoding, callback) {
+    if (typeof encoding === "function") {
+      callback = encoding;
+      encoding = null;
+    }
+    const ret = this._write_(chunk, encoding, callback, false);
+    if (!ret) this._needDrain = true;
+    return ret;
+  }
+
+  _write_(chunk, encoding, callback, fromEnd) {
+    if (typeof callback !== "function") callback = () => {};
+    if (chunk === null) throw codeError(TypeError, "ERR_STREAM_NULL_VALUES", "May not write null values to stream");
+    if (typeof chunk !== "string" && !(chunk instanceof Uint8Array)) {
+      throw invalidArgType("chunk", "of type string or an instance of Buffer or Uint8Array", chunk);
+    }
+    let err;
+    if (this.finished) err = codeError(Error, "ERR_STREAM_WRITE_AFTER_END", "write after end");
+    else if (this.destroyed) err = codeError(Error, "ERR_STREAM_DESTROYED", "Cannot call write after a stream was destroyed");
+    if (err) {
+      if (!this.destroyed) process.nextTick(() => this.emit("error", err));
+      process.nextTick(callback, err);
+      return false;
+    }
+    const len = typeof chunk === "string" ? Buffer.byteLength(chunk, encoding || "utf8") : chunk.byteLength;
+    if (!this._header) {
+      if (fromEnd) this._contentLength = len;
+      this._implicitHeader();
+    }
+    if (!this._hasBody) {
+      process.nextTick(callback);
+      return true;
+    }
+    if (this.chunkedEncoding && len !== 0) {
+      this._send(len.toString(16), "latin1", null);
+      this._send("\r\n", "latin1", null);
+      this._send(chunk, encoding, null);
+      return this._send("\r\n", "latin1", callback);
+    }
+    return this._send(chunk, encoding, callback);
+  }
+
+  end(chunk, encoding, callback) {
+    if (typeof chunk === "function") {
+      callback = chunk;
+      chunk = null;
+      encoding = null;
+    } else if (typeof encoding === "function") {
+      callback = encoding;
+      encoding = null;
+    }
+    if (chunk) {
+      if (this.finished) {
+        this._write_(chunk, encoding, null, true);
+        return this;
+      }
+      this._write_(chunk, encoding, null, true);
+    } else if (this.finished) {
+      if (typeof callback === "function") {
+        if (!this.writableFinished) this.on("finish", callback);
+        else callback(codeError(Error, "ERR_STREAM_ALREADY_FINISHED", "Cannot call end after a stream was finished"));
+      }
+      return this;
+    } else if (!this._header) {
+      this._contentLength = 0;
+      this._implicitHeader();
+    }
+    if (typeof callback === "function") this.once("finish", callback);
+    const finish = () => {
+      if (this.socket && this.socket._hadError) return;
+      this.writableFinished = true;
+      this.emit("finish");
+    };
+    if (this._hasBody && this.chunkedEncoding) this._send("0\r\n" + this._trailer + "\r\n", "latin1", finish);
+    else if (!this._headerSent || chunk) this._send("", "latin1", finish);
+    else process.nextTick(finish);
+    this.finished = true;
+    this.writableEnded = true;
+    this.writable = false;
+    return this;
+  }
+
+  flushHeaders() {
+    if (!this._header) this._implicitHeader();
+    this._send("");
+  }
+
+  /* the socket the agent (or createConnection) gave: its listeners, the parser, then the output */
+  onSocket(socket, err) {
+    process.nextTick(() => {
+      if (this.destroyed || err) {
+        this.destroyed = true;
+        const done = (er) => {
+          if (!this.aborted && !er) er = connReset("socket hang up");
+          if (er) this.emit("error", er);
+          this._closed = true;
+          this.emit("close");
+        };
+        if (socket) {
+          if (!err && this.agent && !socket.destroyed) {
+            socket.emit("free");
+            done(this._error);
+          } else {
+            socket.once("close", () => done(err || this._error));
+            socket.destroy(err || this._error);
+          }
+          return;
+        }
+        done(err || this._error);
+        return;
+      }
+      this.socket = socket;
+      socket._httpMessage = this;
+      socket.on("error", socketErrorListener);
+      socket.on("end", socketOnEnd);
+      socket.on("close", socketCloseListener);
+      if (this.timeout !== undefined || this.agent?.options?.timeout) listenSocketTimeout(this);
+      attachParser(socket, this);
+      this.emit("socket", socket);
+      this._flush();
+    });
+  }
+
+  get connection() {
+    return this.socket;
+  }
+
+  abort() {
+    if (this.aborted) return;
+    this.aborted = true;
+    process.nextTick(() => this.emit("abort"));
+    this.destroy();
+  }
+
+  destroy(err) {
+    if (this.destroyed) return this;
+    this.destroyed = true;
+    if (this.res) this.res._dump();
+    this._error = err;
+    this.socket?.destroy(err);
+    return this;
+  }
+
+  setTimeout(msecs, callback) {
+    if (this._ended) return this;
+    listenSocketTimeout(this);
+    if (typeof msecs !== "number") throw invalidArgType("msecs", "of type number", msecs);
+    if (callback) this.once("timeout", callback);
+    const set = (sock) => {
+      if (sock.connecting) sock.once("connect", () => sock.setTimeout(msecs));
+      else sock.setTimeout(msecs);
+    };
+    if (this.socket) set(this.socket);
+    else this.once("socket", set);
+    return this;
+  }
+
+  setNoDelay(noDelay) {
+    if (this.socket) this.socket.setNoDelay(noDelay);
+    else this.once("socket", (socket) => socket.setNoDelay(noDelay));
+  }
+
+  setSocketKeepAlive(enable, initialDelay) {
+    if (this.socket) this.socket.setKeepAlive(enable, initialDelay);
+    else this.once("socket", (socket) => socket.setKeepAlive(enable, initialDelay));
+  }
+
+  clearTimeout(cb) {
+    this.setTimeout(0, cb);
+  }
+}
+
+export function request(url, options, cb) {
+  return new ClientRequest(url, options, cb);
+}
+
+export function get(url, options, cb) {
+  const req = request(url, options, cb);
+  req.end();
+  return req;
+}
+
+/** The largest head a parser accepts (bytes): a bigger one is a 431. */
+export const maxHeaderSize = 16384;
+
+/** Node keeps a pool of idle parsers; visaljs's are C structs made per connection. */
+export function setMaxIdleHTTPParsers(max) {
+  validateInteger(max, "max");
+  if (max < 1) throw outOfRange("max", ">= 1 && <= 9007199254740991", max);
+}
+
+export { Agent, globalAgent };
+
+export default {
+  METHODS, STATUS_CODES, Agent, ClientRequest, IncomingMessage, OutgoingMessage, ServerResponse, Server, createServer, get, globalAgent,
+  maxHeaderSize, request, setMaxIdleHTTPParsers, validateHeaderName, validateHeaderValue,
+};