visaljs 0.0.7 → 0.0.9

package/node/prelude/http.js

@@ -1,4 +1,4 @@
-// node:http (ADR 0012, layer 3), the server side: createServer, Server, IncomingMessage and
+// node:http, the server side: createServer, Server, IncomingMessage and
 // 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,
@@ -7,12 +7,16 @@
 // 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 {
+  httpAttach, httpBusy, httpDate, httpPending, httpWatchDrain, httpDetach, httpExpired, httpFedClose, httpFedOpen, httpFeed, httpFlush, httpParsers, httpWrite, timerUnref,
+} from "visaljs:host";
 import { bindContext, currentContext, runInContext } from "./internal/async_context.js";
-import { codeError, invalidArgType, outOfRange, validateInteger, validateString } from "./internal/errors.js";
-import { Agent, globalAgent } from "./internal/http_agent.js";
+import { codeError, invalidArgType, invalidArgValue, outOfRange, validateInteger, validateString } from "./internal/errors.js";
+import { Agent, globalAgent, setGlobalAgent } from "./internal/http_agent.js";
+import { kConnectionsCheckingInterval } from "./internal/http_symbols.js";
 import { createConnection, Server as NetServer } from "./net.js";
-import { Readable, Stream } from "./stream.js";
+import { addAbortSignal, Readable, Stream } from "./stream.js";
+import { callableClass } from "./internal/features.js";
 
 export const METHODS = ["ACL", "BIND", "CHECKOUT", "CONNECT", "COPY", "DELETE", "GET", "HEAD", "LINK", "LOCK", "M-SEARCH", "MERGE",
   "MKACTIVITY", "MKCALENDAR", "MKCOL", "MOVE", "NOTIFY", "OPTIONS", "PATCH", "POST", "PROPFIND", "PROPPATCH", "PURGE", "PUT", "QUERY",
@@ -75,13 +79,18 @@ export class IncomingMessage extends Readable {
     this.aborted = false;
     this.statusCode = null;
     this.statusMessage = null;
+    /* Node's: read yet, and dumped (stream utils' isServerRequest tells a request by them) */
+    this._consuming = false;
+    this._dumped = false;
   }
 
   get connection() {
     return this.socket;
   }
 
-  _read() {}
+  _read() {
+    this._consuming = true;
+  }
 
   /* a response nobody reads: its body is discarded, so the socket isn't held up */
   _dump() {
@@ -98,12 +107,35 @@ export class IncomingMessage extends Readable {
 
   _finish() {
     this.complete = true;
-    this.push(null);
+    if (!this._readableState.ended) this.push(null);
+  }
+
+  /* Node's: a request without a body (the server's optimizeEmptyRequests) ended and closed at once,
+   * without its 'data', 'end' and 'close' */
+  _dumpAndCloseReadable() {
+    this._dumped = true;
+    const state = this._readableState;
+    state.ended = true;
+    state.endEmitted = true;
+    state.destroyed = true;
+    state.closed = true;
+    state.closeEmitted = true;
+  }
+
+  /* Node's: an AbortSignal that aborts when the connection closes before the response finished */
+  get signal() {
+    if (!this._abortController) {
+      this._abortController = new AbortController();
+      if (this.destroyed && (!this.readableEnded || !this.complete)) this._abortController.abort();
+    }
+    return this._abortController.signal;
   }
 
-  /* the connection closed before the body was complete */
+  /* the connection closed before the response was finished (Node's abortIncoming): destroyed, and
+   * 'aborted' if its body wasn't all read (_destroy) */
   _abort() {
-    if (this.complete || this.destroyed) return;
+    this._abortController?.abort();
+    if (this.destroyed) return;
     const e = new Error("aborted");
     e.code = "ECONNRESET";
     this.destroy(e);
@@ -136,10 +168,16 @@ const SINGLE = new Set(["age", "authorization", "content-length", "content-type"
 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) && !join) return;
-  else headers[key] = existing + (key === "cookie" ? "; " : ", ") + value;
+  if (key === "set-cookie") {
+    if (existing !== undefined) existing.push(value);
+    else headers[key] = [value];
+  } else if (SINGLE.has(key) && !join) {
+    if (existing === undefined) headers[key] = value;  /* duplicates dropped */
+  } else if (typeof existing === "string") {  /* as Node's: not a value inherited from Object.prototype */
+    headers[key] = existing + (key === "cookie" ? "; " : ", ") + value;
+  } else {
+    headers[key] = value;
+  }
 }
 
 /* ---- OutgoingMessage: a response's (and a request's) headers ------------------------------------ */
@@ -161,6 +199,26 @@ export function validateHeaderValue(name, value) {
 
 const headersSent = (what) => codeError(Error, "ERR_HTTP_HEADERS_SENT", "Cannot " + what + " headers after they are sent to the client");
 
+/* Node's write_: a chunk is a string or bytes */
+function validateChunk(chunk) {
+  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);
+  }
+}
+
+/* llhttp's error, as Node's: its code and reason, how far it parsed the read, and the read */
+function parseError(code, reason, bytesParsed, rawPacket) {
+  const e = new Error("Parse Error: " + reason);
+  e.code = code;
+  e.reason = reason;
+  e.bytesParsed = bytesParsed;
+  if (rawPacket !== undefined) {
+    e.rawPacket = Buffer.isBuffer(rawPacket) ? rawPacket : Buffer.from(rawPacket.buffer, rawPacket.byteOffset, rawPacket.byteLength);
+  }
+  return e;
+}
+
 export class OutgoingMessage extends Stream {
   constructor() {
     super();
@@ -168,7 +226,7 @@ export class OutgoingMessage extends Stream {
     this.destroyed = false;
     this.writableCorked = 0;
     this.writableNeedDrain = false;
-    this.writableHighWaterMark = 16384;
+    this._highWaterMark = 65536;  /* Node's default, until there's a socket */
     this.headersSent = false;
     this.finished = false;
     this.writableEnded = false;
@@ -182,10 +240,18 @@ export class OutgoingMessage extends Stream {
     this._trailer = "";
     this._headers = new Map();  /* lowercase name → [name as set, value] */
     this.socket = null;
+    /* Node's: the head once stored, and the bytes kept until there's a socket */
+    this.outputData = [];
+    this.outputSize = 0;
+    this._header = null;
+    this._headerSent = false;
+    this._last = false;
+    this.shouldKeepAlive = true;
+    this._closed = false;
   }
 
   setHeader(name, value) {
-    if (this.headersSent) throw headersSent("set");
+    if (this._header || this.headersSent) throw headersSent("set");
     validateHeaderName(name);
     validateHeaderValue(name, value);
     this._headers.set(String(name).toLowerCase(), [String(name), value]);
@@ -193,7 +259,7 @@ export class OutgoingMessage extends Stream {
   }
 
   appendHeader(name, value) {
-    if (this.headersSent) throw headersSent("append");
+    if (this._header || this.headersSent) throw headersSent("append");
     validateHeaderName(name);
     validateHeaderValue(name, value);
     const key = String(name).toLowerCase();
@@ -203,20 +269,94 @@ export class OutgoingMessage extends Stream {
     return this;
   }
 
+  /* the socket's, as Node's, else the default */
+  get writableHighWaterMark() {
+    return this.socket ? this.socket.writableHighWaterMark : this._highWaterMark;
+  }
+
+  set writableHighWaterMark(value) {
+    this._highWaterMark = value;
+  }
+
+  /* headers from a Headers or a Map, as Node's: set-cookie's values together */
+  setHeaders(headers) {
+    if (this._header || this.headersSent) throw headersSent("set");
+    if (!headers || Array.isArray(headers) || typeof headers.keys !== "function" || typeof headers.get !== "function") {
+      throw invalidArgType("headers", "an instance of Headers or Map", headers);
+    }
+    let cookies = null;
+    for (const [key, value] of headers) {
+      if (key === "set-cookie") {
+        cookies ??= [];
+        if (Array.isArray(value)) cookies.push(...value);
+        else cookies.push(value);
+        continue;
+      }
+      this.setHeader(key, value);
+    }
+    if (cookies !== null) this.setHeader("set-cookie", cookies);
+    return this;
+  }
+
   get connection() {
     return this.socket;
   }
 
+  set connection(value) {
+    this.socket = value;
+  }
+
+  /* as Node's: what's kept until there's a socket, and the socket's own */
   get writableLength() {
-    return 0;
+    return this.outputSize + (this.socket ? this.socket.writableLength : 0);
+  }
+
+  get writableObjectMode() {
+    return false;
+  }
+
+  get errored() {
+    return this._errored ?? null;
+  }
+
+  get closed() {
+    return this._closed;
   }
 
   cork() {
     this.writableCorked++;
+    if (this.socket) this.socket.cork();
   }
 
   uncork() {
     if (this.writableCorked) this.writableCorked--;
+    if (this.socket) this.socket.uncork();
+  }
+
+  /* the socket's timeout, once there is a socket, as Node's */
+  setTimeout(msecs, callback) {
+    if (callback) this.on("timeout", callback);
+    if (!this.socket) this.once("socket", (socket) => socket.setTimeout(msecs));
+    else this.socket.setTimeout(msecs);
+    return this;
+  }
+
+  /* as Node's: the socket destroyed with it, or 'close' on the next tick without one */
+  destroy(error) {
+    if (this.destroyed) return this;
+    this.destroyed = true;
+    this._errored = error;
+    if (this.socket) {
+      this.socket.destroy(error);
+    } else {
+      process.nextTick(() => {
+        if (!this._closed) {
+          this._closed = true;
+          this.emit("close");
+        }
+      });
+    }
+    return this;
   }
 
   getHeader(name) {
@@ -231,7 +371,7 @@ export class OutgoingMessage extends Stream {
 
   removeHeader(name) {
     validateString(name, "name");
-    if (this.headersSent) throw headersSent("remove");
+    if (this._header || this.headersSent) throw headersSent("remove");
     if (name.toLowerCase() === "content-length") this._removedContLen = true;
     this._headers.delete(String(name).toLowerCase());
   }
@@ -250,6 +390,192 @@ export class OutgoingMessage extends Stream {
     return [...this._headers.values()].map(([name]) => name);
   }
 
+  /* Node's OutgoingMessage, as a ClientRequest (and an OutgoingMessage made by hand) writes: the
+   * head stored, then the bytes through the socket (ServerResponse has its own, on llhttp's
+   * connection). _storeHeader: the first 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;
+  }
+
+  /* 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;
+    }
+    validateChunk(chunk);  /* first, as Node's write_ (called on another object too) */
+    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("");
+  }
+
+  /* as Node's: a subclass renders its first line (ClientRequest, ServerResponse) */
+  _implicitHeader() {
+    throw codeError(Error, "ERR_METHOD_NOT_IMPLEMENTED", "The _implicitHeader() method is not implemented");
+  }
+
   /* trailers, sent after a chunked body: { name: value } or [[name, value], …] */
   addTrailers(headers) {
     this._trailer = "";
@@ -279,25 +605,66 @@ export class ServerResponse extends OutgoingMessage {
     this.statusMessage = undefined;
     this.sendDate = true;
     this._conn = conn;
-    this._keepAlive = keepAlive;
-    this._keepAliveTimeout = server ? server.keepAliveTimeout : 5000;
+    /* one made by hand (new ServerResponse(req)) is kept alive, without a Keep-Alive timeout, as Node's */
+    this._keepAlive = keepAlive ?? true;
+    this._keepAliveTimeout = server ? server.keepAliveTimeout : 0;
     this._head = req.method === "HEAD";
   }
 
+  /* the response's bytes: to the connection's parser, which corks them; or, for a response made by
+   * hand (new ServerResponse(req), Node's assignSocket), to its socket, kept until it has one */
+  _send(data, latin1 = false) {
+    if (this._queued) (this._unsent ??= []).push([data, latin1]);  /* behind the connection's earlier responses */
+    else if (this._conn !== undefined) httpWrite(this._conn, data, latin1);
+    else if (this.socket) this.socket.write(data, latin1 ? "latin1" : undefined);
+    else (this._unsent ??= []).push([data, latin1]);
+  }
+
+  /** A socket for a response made by hand, as Node's: its writes go there. */
+  assignSocket(socket) {
+    if (socket._httpMessage) throw codeError(Error, "ERR_HTTP_SOCKET_ASSIGNED", "Socket already assigned");
+    socket._httpMessage = this;
+    this.socket = socket;
+    this.emit("socket", socket);
+    const unsent = this._unsent;
+    this._unsent = undefined;
+    if (unsent) for (const [data, latin1] of unsent) socket.write(data, latin1 ? "latin1" : undefined);
+  }
+
+  detachSocket(socket) {
+    socket._httpMessage = null;
+    this.socket = null;
+  }
+
   setTimeout(msecs, callback) {
     if (typeof callback === "function") this.on("timeout", callback);
     if (this.socket) this.socket.setTimeout(msecs);
     return this;
   }
 
+  /* the head a write sends without writeHead, through writeHead as Node's: a wrapper of it runs
+   * (on-headers: compression sets Vary and Content-Encoding there). Middleware calls it too, before
+   * writing (compression). `length`: the whole body's, when end() knows it */
+  _implicitHeader(length) {
+    this._implicitLength = length;
+    try {
+      this.writeHead(this.statusCode);
+    } finally {
+      this._implicitLength = undefined;
+    }
+  }
+
   /* sends the head now: the body that follows is chunked */
   flushHeaders() {
-    if (!this.headersSent) httpWrite(this._conn, this._renderHead(undefined));
+    if (!this.headersSent && Object.hasOwn(this, "writeHead")) this._implicitHeader(undefined);  /* a wrapper sees it */
+    const head = this._takeHead(undefined);
+    if (head) this._send(head, true);
   }
 
   destroy(error) {
     if (this.destroyed) return this;
     this.destroyed = true;
+    this._errored = error;
     this.writable = false;
     this._closeEmitted = true;
     if (this.socket) this.socket.destroy();
@@ -318,6 +685,13 @@ export class ServerResponse extends OutgoingMessage {
   }
 
   writeHead(statusCode, statusMessage, headers) {
+    /* as Node's: an integer status from 100 to 999 */
+    const originalStatusCode = statusCode;
+    statusCode |= 0;
+    if (statusCode < 100 || statusCode > 999) {
+      const shown = typeof originalStatusCode === "object" && originalStatusCode !== null ? JSON.stringify(originalStatusCode) : String(originalStatusCode);
+      throw codeError(RangeError, "ERR_HTTP_INVALID_STATUS_CODE", `Invalid status code: ${shown}`);
+    }
     if (typeof statusMessage !== "string") {
       headers = statusMessage;
       statusMessage = undefined;
@@ -325,13 +699,16 @@ export class ServerResponse extends OutgoingMessage {
     this.statusCode = statusCode;
     if (statusMessage !== undefined) this.statusMessage = statusMessage;
     if (Array.isArray(headers)) {
-      for (let i = 0; i < headers.length; i += 2) this.appendHeader(headers[i], headers[i + 1]);
+      /* as Node's: they replace the headers set before, and may repeat a name among themselves */
+      if (headers.length % 2 !== 0) throw invalidArgValue("headers", "is invalid", headers);
+      for (let i = 0; i < headers.length; i += 2) if (this.hasHeader(headers[i])) this.removeHeader(headers[i]);
+      for (let i = 0; i < headers.length; i += 2) if (headers[i]) this.appendHeader(headers[i], headers[i + 1]);
     } else if (headers) {
       for (const name of Object.keys(headers)) this.setHeader(name, headers[name]);
     }
     /* Node renders the head now (sent with the first write): without a known length, the body
      * is chunked even when end() brings all of it */
-    if (!this.headersSent) this._pendingHead = this._renderHead(undefined);
+    if (!this.headersSent) this._pendingHead = this._renderHead(this._implicitLength);
     return this;
   }
 
@@ -347,7 +724,8 @@ export class ServerResponse extends OutgoingMessage {
   _renderHead(length) {
     const status = this.statusCode;
     const noBody = status === 204 || status === 304 || (status >= 100 && status < 200);
-    let head = "HTTP/1.1 " + status + " " + (this.statusMessage ?? STATUS_CODES[status] ?? "unknown") + "\r\n";
+    /* an empty statusMessage gets the standard one, as in Node (Next.js's route handlers set "") */
+    let head = "HTTP/1.1 " + status + " " + (this.statusMessage || STATUS_CODES[status] || "unknown") + "\r\n";
     for (const [, [name, value]] of this._headers) {
       if (Array.isArray(value)) for (const v of value) head += name + ": " + v + "\r\n";
       else head += name + ": " + value + "\r\n";
@@ -376,33 +754,82 @@ export class ServerResponse extends OutgoingMessage {
         this.chunkedEncoding = true;
       }
     }
+    /* as Node's _storeHeader: only a chunked body can have trailers (the head isn't sent) */
+    if (this.chunkedEncoding !== true && this._headers.has("trailer")) {
+      throw codeError(Error, "ERR_HTTP_TRAILER_INVALID", "Trailers are invalid with this transfer encoding");
+    }
     this.headersSent = true;
     return head + "\r\n";
   }
 
   write(chunk, encoding, callback) {
     if (typeof encoding === "function") callback = encoding;
+    validateChunk(chunk);
     if (this.writableEnded || this.destroyed) {
-      const e = new Error(this.destroyed ? "Cannot call write after a stream was destroyed" : "write after end");
-      e.code = this.destroyed ? "ERR_STREAM_DESTROYED" : "ERR_STREAM_WRITE_AFTER_END";
-      queueMicrotask(() => this.emit("error", e));
-      if (typeof callback === "function") queueMicrotask(() => callback(e));
+      /* Node's write_: after end before destroyed; the callback, then 'error' (Node's emitErrorNt),
+       * none on a destroyed response (it closed, or its client went away) */
+      const ended = this.writableEnded;
+      const e = new Error(ended ? "write after end" : "Cannot call write after a stream was destroyed");
+      e.code = ended ? "ERR_STREAM_WRITE_AFTER_END" : "ERR_STREAM_DESTROYED";
+      if (!this.destroyed) {
+        process.nextTick(() => {
+          if (typeof callback === "function") callback(e);
+          if (!this.destroyed) this.emit("error", e);
+        });
+      } else if (typeof callback === "function") {
+        process.nextTick(callback, e);
+      }
       return false;
     }
     if (typeof chunk === "string" && typeof encoding === "string" && encoding !== "utf8" && encoding !== "utf-8") chunk = Buffer.from(chunk, encoding);
+    /* a writeHead of the response's own (a wrapper) sees the implicit head, as in Node */
+    if (!this.headersSent && Object.hasOwn(this, "writeHead")) this._implicitHeader(undefined);
     const head = this._takeHead(undefined);
-    if (head) httpWrite(this._conn, head);
+    if (head) this._send(head, true);
     if (chunk !== undefined && chunk !== null && chunkLength(chunk) > 0 && !this._head) {
       if (this.chunkedEncoding) {
-        httpWrite(this._conn, chunkLength(chunk).toString(16) + "\r\n");
-        httpWrite(this._conn, chunk);
-        httpWrite(this._conn, "\r\n");
+        this._send(chunkLength(chunk).toString(16) + "\r\n");
+        this._send(chunk);
+        this._send("\r\n");
       } else {
-        httpWrite(this._conn, chunk);
+        this._send(chunk);
       }
     }
     if (typeof callback === "function") queueMicrotask(callback);
-    return true;
+    return this._underHighWaterMark();
+  }
+
+  get writableLength() {
+    return this._pendingBytes();
+  }
+
+  /* bytes written that haven't gone out: corked in C and in libuv's queue, or a TLS socket's */
+  _pendingBytes() {
+    if (this._conn === undefined || this._queued) return 0;
+    return isFed(this.socket) ? httpPending(this._conn) + (this.socket?.writableLength ?? 0) : httpPending(this._conn);
+  }
+
+  /* write()'s answer, as Node's: false over the high-water mark, with 'drain' once it all went out */
+  _underHighWaterMark() {
+    if (this._pendingBytes() < this.writableHighWaterMark) return true;
+    /* over it while corked: sent now, libuv writing what the kernel takes at once, as Node's socket
+     * does; only what's left counts */
+    if (!isFed(this.socket)) {
+      httpFlush(this._conn);
+      if (this._pendingBytes() < this.writableHighWaterMark) return true;
+    }
+    if (!this.writableNeedDrain) {
+      this.writableNeedDrain = true;
+      if (isFed(this.socket)) this.socket.once("drain", () => this._emitDrain());
+      else if (httpWatchDrain(this._conn)) process.nextTick(() => this._emitDrain());
+    }
+    return false;
+  }
+
+  _emitDrain() {
+    if (!this.writableNeedDrain) return;
+    this.writableNeedDrain = false;
+    this.emit("drain");
   }
 
   end(chunk, encoding, callback) {
@@ -412,33 +839,66 @@ export class ServerResponse extends OutgoingMessage {
     } else if (typeof encoding === "function") {
       callback = encoding;
     }
+    if (chunk !== undefined && chunk !== null) validateChunk(chunk);
     if (this.writableEnded) return this;
     if (typeof chunk === "string" && typeof encoding === "string" && encoding !== "utf8" && encoding !== "utf-8") chunk = Buffer.from(chunk, encoding);
+    if (!this.headersSent && Object.hasOwn(this, "writeHead")) this._implicitHeader(chunk !== undefined && chunk !== null ? chunkLength(chunk) : 0);
     if (!this.headersSent) {
       const hasChunk = chunk !== undefined && chunk !== null;
       const length = hasChunk ? chunkLength(chunk) : 0;
-      if (hasChunk && typeof chunk === "string" && !this._head) httpWrite(this._conn, this._renderHead(length) + chunk);
-      else {
-        httpWrite(this._conn, this._renderHead(length));
-        if (hasChunk && length && !this._head) httpWrite(this._conn, chunk);
+      if (hasChunk && typeof chunk === "string" && !this._head) {
+        /* the head's bytes are latin1, the body's UTF-8: corked into one write by the parser's
+         * connection; a response made by hand writes them as one string, as Node's _send */
+        if (this._conn === undefined) {
+          this._send(this._renderHead(length) + chunk);
+        } else {
+          this._send(this._renderHead(length), true);
+          this._send(chunk);
+        }
+      } else {
+        this._send(this._renderHead(length), true);
+        if (hasChunk && length && !this._head) this._send(chunk);
       }
     } else {
       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" + this._trailer + "\r\n");
+      if (head) this._send(head, true);
+      if (this.chunkedEncoding && !this._head) this._send("0\r\n" + this._trailer + "\r\n", true);
     }
     this.writableEnded = this.finished = true;
     this.writable = false;
-    if (!this._keepAlive && this.socket) {  /* the response goes out, then the socket ends */
-      httpFlush(this._conn);
-      this.socket.destroySoon();
+    if (this._queued) {  /* finished once it has gone out, after the responses before it */
+      this._endCallback = callback;
+      return this;
+    }
+    this._afterEnd(callback);
+    return this;
+  }
+
+  /* a response that waited behind the connection's earlier ones: its turn (Node's assignSocket) */
+  _activate() {
+    this._queued = false;
+    const unsent = this._unsent;
+    this._unsent = undefined;
+    if (unsent) for (const [data, latin1] of unsent) httpWrite(this._conn, data, latin1);
+    if (this.writableEnded) this._afterEnd(this._endCallback);
+  }
+
+  /* the response is all written: the socket ends after the last one (not kept alive, or the client
+   * ended its side), then 'finish' and 'close' */
+  _afterEnd(callback) {
+    /* the response is all written: sent now, so that by 'finish' it has gone to the socket, as Node's */
+    if (this._conn !== undefined) httpFlush(this._conn);
+    if ((!this._keepAlive || this._last) && this.socket) {  /* the response goes out, then the socket ends */
+      if (typeof this.socket.destroySoon === "function") this.socket.destroySoon();  /* as Node's resOnFinish */
+      else this.socket.end();
     }
     queueMicrotask(() => {
       this.writableFinished = true;
       this.emit("finish");
       if (!this._closeEmitted) {
         this._closeEmitted = true;
+        this.destroyed = true;  /* as Node's emitCloseNT */
         this.emit("close");
       }
       if (typeof callback === "function") callback();
@@ -455,23 +915,29 @@ const requestTimeoutResponse = "HTTP/1.1 408 Request Timeout\r\nConnection: clos
 
 function noop() {}
 
-export class Server extends NetServer {
+/** (options, requestListener) or (requestListener): the options an object. */
+function serverArguments(options, requestListener) {
+  if (typeof options === "function") return [{}, options];
+  if (options === undefined || options === null) return [{}, requestListener];
+  if (typeof options !== "object" || Array.isArray(options)) throw invalidArgType("options", "of type object", options);  /* validateObject */
+  return [options, requestListener];
+}
+
+class ServerClass 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);
-    }
+    [options, requestListener] = serverArguments(options, requestListener);
     super({ allowHalfOpen: true, noDelay: options.noDelay ?? true, keepAlive: options.keepAlive, keepAliveInitialDelay: options.keepAliveInitialDelay });
+    this._initHttp(options, requestListener, "connection");
+  }
+
+  /* Node's storeHTTPOptions and the server's timeouts, and its sockets' requests: those of each
+   * 'connection' (https.Server's: of each 'secureConnection') */
+  _initHttp(options, requestListener, connectionEvent) {
     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;
@@ -489,6 +955,10 @@ export class Server extends NetServer {
     this.insecureHTTPParser = boolean("insecureHTTPParser", undefined);
     this.requireHostHeader = boolean("requireHostHeader", true);
     this.joinDuplicateHeaders = boolean("joinDuplicateHeaders", undefined);
+    /* the classes requests and responses are made of (subclasses of node:http's), as Node's */
+    this._IncomingMessage = options.IncomingMessage || IncomingMessage;
+    this._ServerResponse = options.ServerResponse || ServerResponse;
+    this._optimizeEmptyRequests = boolean("optimizeEmptyRequests", false);
     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) {
@@ -496,27 +966,63 @@ export class Server extends NetServer {
     }
     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());
+    this.on(connectionEvent, (socket) => this._onSocket(socket));
+    this.on("listening", () => this._startConnectionsChecking());
+  }
+
+  /* captureRejections: a 'request' listener's rejection answers 500, its headers dropped (or the
+   * response destroyed, once sent), as Node's; another event's goes to net.Server's */
+  [Symbol.for("nodejs.rejection")](err, event, ...args) {
+    if (event === "request") {
+      const res = args[1];
+      if (!res.headersSent && !res.writableEnded) {
+        for (const name of res.getHeaderNames()) res.removeHeader(name);
+        res.statusCode = 500;
+        res.end(STATUS_CODES[500]);
+      } else {
+        res.destroy();
+      }
+      return;
+    }
+    const base = NetServer.prototype[Symbol.for("nodejs.rejection")];
+    if (typeof base === "function") base.call(this, err, event, ...args);
+    else this.emit("error", err);
+  }
+
+  /* Node's setupConnectionsTracking: the connections checked every connectionsCheckingInterval ms
+   * (unref'd), a new timer for each 'listening'. server[kConnectionsCheckingInterval] stands for
+   * Node's interval: its _destroyed says whether it was stopped. */
+  _startConnectionsChecking() {
+    this._stopConnectionsChecking();
+    const interval = { _destroyed: false, _timer: null };
+    this[kConnectionsCheckingInterval] = interval;
+    const tick = () => {
+      if (interval._destroyed) return;
+      this._checkConnections();
+      interval._timer = timerUnref(tick, this.connectionsCheckingInterval);
+    };
+    if (this.connectionsCheckingInterval > 0) interval._timer = timerUnref(tick, this.connectionsCheckingInterval);
+  }
+
+  _stopConnectionsChecking() {
+    const interval = this[kConnectionsCheckingInterval];
+    if (!interval || interval._destroyed) return;
+    interval._destroyed = true;
+    if (interval._timer !== null) clearTimeout(interval._timer);
+    interval._timer = null;
   }
 
   /* 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"));
-        }
+  _checkConnections() {
+    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(msecs, callback) {
@@ -531,28 +1037,35 @@ export class Server extends NetServer {
   }
 
   closeIdleConnections() {
-    for (const state of [...this._states.values()]) if (!state.req && !state.res) state.socket.destroy();
+    /* as Node's: idle is no request under way (none begun on it, nor a response unfinished) */
+    for (const state of [...this._states.values()]) {
+      if (state.incoming.length === 0 && !state.res && !httpBusy(state.conn)) state.socket.destroy();
+    }
   }
 
   close(callback) {
     this.closeIdleConnections();
-    if (this._checking !== null) clearTimeout(this._checking);
-    this._checking = null;
+    this._stopConnectionsChecking();
     return super.close(callback);
   }
 
   /* a connection: its bytes go to llhttp; its end, timeout, errors and close are the requests' */
   _onSocket(socket) {
     if (this._parsers === -1) {
-      /* in the async context of the connection's (ADR 0020), as the server's sockets' callbacks */
+      /* in the async context of the connection's, as the server's sockets' callbacks */
       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, chunk) => {
+          /* the bytes llhttp reads in C are the socket's activity, as Node's onParserExecute counts them */
+          const state = this._states.get(conn);
+          state?.socket._unrefTimer?.();
+          state?.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;
+            state.req = null;  /* parsed; it stays in state.incoming until its response finishes */
             if (trailers) {
               req.rawTrailers = trailers;
               for (let i = 0; i < trailers.length; i += 2) addHeader(req.trailers, trailers[i], trailers[i + 1]);
@@ -561,42 +1074,64 @@ export class Server extends NetServer {
           }
         },
         (conn, head) => this._onUpgrade(conn, head),
-        (conn, code, reason) => {
+        (conn, code, reason, bytesParsed, rawPacket) => {
           const state = this._states.get(conn);
           if (!state) return;
-          const e = new Error("Parse Error: " + reason);
-          e.code = code;
-          e.reason = reason;
+          const e = parseError(code, reason, bytesParsed, rawPacket);
           socketOnError.call(state.socket, e);
         },
+        /* the connection's output went out: the response waiting for it gets 'drain' */
+        (conn) => this._states.get(conn)?.res?._emitDrain(),
       ].map(bindContext));
     }
-    const conn = socket._handle;
+    const conn = connOf(socket);
     if (conn === null) return;
-    const state = { socket, conn, req: null, res: null, keepAliveTimeoutSet: false, listeners: null };
+    socket.server = this;  /* as Node's: the http server, even for a socket another server accepted */
+    /* as Node's connection state: the request being parsed (req); those whose responses aren't
+     * finished (incoming); the response writing to the connection (res), and those waiting behind it
+     * (outgoing: pipelined requests are answered in order) */
+    const state = { socket, conn, req: null, incoming: [], res: null, outgoing: [], 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);
+    /* Node's socketOnEnd: the client ended its side; with httpAllowHalfOpen, the socket ends after
+     * the last response, else now */
     const onEnd = () => {
-      this._abortIncoming(state);
-      if (socket.writable) socket.end();
+      if (!this.httpAllowHalfOpen) {
+        if (socket.writable) socket.end();
+      } else if (state.outgoing.length) {
+        state.outgoing[state.outgoing.length - 1]._last = true;
+      } else if (state.res) {
+        state.res._last = true;
+      } else if (socket.writable) {
+        socket.end();
+      }
     };
+    /* Node's socketOnClose: the requests and responses not finished are aborted */
     const onClose = () => {
       this._states.delete(conn);
       this._abortIncoming(state);
-      const res = state.res;
+      const responses = state.res ? [state.res, ...state.outgoing] : state.outgoing;
       state.res = null;
-      if (res) res._connectionClosed();
+      state.outgoing = [];
+      for (const res of responses) 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);
+    /* bytes the socket read before it was the server's (a program that peeked, then emitted
+     * 'connection' itself): parsed first, a chunk at a time, as Node's 'data' brings them */
+    const readable = socket._readableState;
+    while (readable && !isFed(socket) && socket.readableLength > 0 && this._states.has(conn)) {
+      const chunk = socket.read(readable.buffer[readable.bufferIndex]?.length ?? socket.readableLength);
+      if (chunk === null) break;
+      httpFeed(conn, typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+    }
   }
 
   _abortIncoming(state) {
-    const req = state.req;
     state.req = null;
-    if (req) req._abort();
+    for (const req of state.incoming.splice(0)) req._abort();
   }
 
   /* Node's socketOnTimeout: the request's, the response's or the server's 'timeout', or the end */
@@ -613,11 +1148,12 @@ export class Server extends NetServer {
     const state = this._states.get(conn);
     if (!state) return 0;
     const socket = state.socket;
+    socket._unrefTimer?.();  /* the head's bytes are the socket's activity */
     if (state.keepAliveTimeoutSet) {
       socket.setTimeout(0);
       state.keepAliveTimeoutSet = false;
     }
-    const req = new IncomingMessage(socket);
+    const req = new this._IncomingMessage(socket);
     req.method = method;
     req.url = url;
     req.httpVersionMajor = major;
@@ -631,25 +1167,43 @@ export class Server extends NetServer {
       return 2;
     }
     state.req = req;
-    const res = new ServerResponse(req, conn, keepAlive, this);
-    state.res = res;
+    state.incoming.push(req);
+    if (this._optimizeEmptyRequests && !("content-length" in req.headers) && !("transfer-encoding" in req.headers)) req._dumpAndCloseReadable();
+    const res = new this._ServerResponse(req, conn, keepAlive, this);
+    if (state.res) {  /* a pipelined request: its response waits for the one before */
+      res._queued = true;
+      state.outgoing.push(res);
+    } else {
+      state.res = res;
+    }
+    res.once("finish", () => this._resOnFinish(state, req, 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 (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;
   }
 
+  /* Node's resOnFinish: the request is done with; the next response's turn, or the idle keep-alive
+   * timeout */
+  _resOnFinish(state, req, res) {
+    const i = state.incoming.indexOf(req);
+    if (i !== -1) state.incoming.splice(i, 1);
+    if (state.req === req && req.complete) state.req = null;
+    if (state.res === res) state.res = null;
+    if (res._last || !res._keepAlive) return;  /* the socket is ending */
+    const next = state.outgoing.shift();
+    if (next) {
+      state.res = next;
+      next._activate();
+    } else if (this.keepAliveTimeout && state.socket.writable) {
+      state.socket.setTimeout(this.keepAliveTimeout);
+      state.keepAliveTimeoutSet = true;
+    }
+  }
+
   /* 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);
@@ -658,6 +1212,7 @@ export class Server extends NetServer {
     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);
+    unfeed(socket);
     /* 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);
@@ -666,6 +1221,47 @@ export class Server extends NetServer {
     else socket.destroy();
   }
 }
+export const Server = callableClass(ServerClass, "Server");  /* Server(…) without new, as Node's */
+
+/* ---- Connections: llhttp on a socket's handle, or fed --------------------------------------- */
+
+/* A socket whose bytes aren't its handle's: a TLSSocket's handle carries ciphertext, a Duplex
+ * has none. llhttp parses what it reads ('data') and writes through it (write()). */
+const isFed = (socket) => socket.encrypted === true || socket._handle === undefined;
+const kFed = Symbol("kFed");
+
+/** The socket's connection for llhttp: its net handle's id (the parser reads the handle in C), or a
+ *  fed connection, made the first time; null for a net socket without a handle yet. */
+function connOf(socket) {
+  if (!isFed(socket)) return socket._handle;
+  const fed = socket[kFed];
+  if (fed) return fed.conn;
+  const conn = httpFedOpen((bytes) => {
+    if (!socket.destroyed) socket.write(Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength));
+  });
+  const onData = (chunk) => httpFeed(conn, typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  const onEnd = () => httpFeed(conn, null);
+  const onClose = () => unfeed(socket);
+  socket[kFed] = { conn, onData, onEnd, onClose };
+  socket.on("data", onData);
+  socket.on("end", onEnd);
+  socket.on("close", onClose);
+  return conn;
+}
+
+/** A socket's connection if it has one: its handle's id, or its fed connection's. */
+const connKey = (socket) => (isFed(socket) ? socket[kFed]?.conn : socket._handle);
+
+/* the socket's bytes stop going to llhttp: it upgraded, or closed */
+function unfeed(socket) {
+  const fed = socket[kFed];
+  if (!fed) return;
+  socket[kFed] = undefined;
+  socket.removeListener("data", fed.onData);
+  socket.removeListener("end", fed.onEnd);
+  socket.removeListener("close", fed.onClose);
+  httpFedClose(fed.conn);
+}
 
 /* Node's socketOnError: 'clientError', or a 400 (when nothing was written yet) and the end */
 function socketOnError(e) {
@@ -673,7 +1269,7 @@ function socketOnError(e) {
   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 state = server._states.get(connKey(this));
     const res = state?.res;
     if (this.writable && (!res || !res.headersSent)) {
       if (state) httpFlush(state.conn);
@@ -702,11 +1298,11 @@ function urlToHttpOptions(url) {
   return options;
 }
 
-/* the sockets whose responses llhttp parses: handle id → socket */
+/* the sockets whose responses llhttp parses: connection → socket */
 const clientSockets = new Map();
 let clientParsers = -1;
 
-/* the async context a request was made in (ADR 0020): its response's callbacks run in it, as in
+/* the async context a request was made in: its response's callbacks run in it, as in
  * Node, whichever request's the socket was */
 const kAsyncContext = Symbol("kAsyncContext");
 const inRequestContext = (fn) => (conn, ...args) =>
@@ -731,7 +1327,10 @@ function clientParsersId() {
       res.upgrade = upgrade;
       return parserOnIncomingClient(req, socket, res, keepAlive);
     },
-    (conn, chunk) => reqOf(conn)?.res?._push(chunk),
+    (conn, chunk) => {
+      clientSockets.get(conn)?._unrefTimer?.();  /* the socket's activity, as Node's onParserExecute */
+      reqOf(conn)?.res?._push(chunk);
+    },
     (conn, trailers) => {
       const socket = clientSockets.get(conn);
       const req = socket?._httpMessage;
@@ -745,21 +1344,20 @@ function clientParsersId() {
         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);
+      if (!statusIsInformational(res.statusCode)) freeParserAfterRead(socket);
       res._finish();
     },
     (conn, head) => {
       const socket = clientSockets.get(conn);
       if (socket?._httpMessage) clientUpgrade(socket._httpMessage, socket, head);
     },
-    (conn, code, reason) => {
+    (conn, code, reason, bytesParsed, rawPacket) => {
       const socket = clientSockets.get(conn);
       const req = socket?._httpMessage;
-      const e = new Error("Parse Error: " + reason);
-      e.code = code;
-      e.reason = reason;
+      const e = parseError(code, reason, bytesParsed, rawPacket);
       if (socket) {
         freeParser(socket);
+        socket.removeListener("end", socketOnEnd);  /* as Node's socketOnData */
         socket.destroy();
       }
       if (req) {
@@ -776,12 +1374,15 @@ const statusIsInformational = (status) => status < 200 && status >= 100 && statu
 /* 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._httpMessage !== req) return;
+    const conn = connOf(socket);
+    if (conn === null) return;
+    clientSockets.set(conn, socket);
+    socket._clientConn = conn;
+    httpAttach(conn, clientParsersId(), true, req.maxHeaderSize ?? maxHeaderSize);
   };
-  if (socket.connecting || socket._handle === null) socket.once("connect", attach);
+  /* a net socket's handle is its once connected; a fed socket's bytes come as they come */
+  if (!isFed(socket) && (socket.connecting || socket._handle === null)) socket.once("connect", attach);
   else attach();
 }
 
@@ -789,10 +1390,25 @@ function freeParser(socket) {
   const conn = socket._clientConn;
   if (conn === undefined) return;
   socket._clientConn = undefined;
+  socket.parser = null;  /* as Node's: no parser on a socket between requests */
   clientSockets.delete(conn);
   httpDetach(conn);
 }
 
+/* a complete response's parser, let go of once the read is parsed, as Node's socketOnData frees it:
+ * what follows the response in the read is still parsed, and an error there is the request's (the
+ * socket's entry stays until then) */
+function freeParserAfterRead(socket) {
+  const conn = socket._clientConn;
+  if (conn === undefined) return;
+  socket._clientConn = undefined;
+  socket.parser = null;  /* as Node's: no parser on a socket between requests */
+  httpDetach(conn, true);
+  queueMicrotask(() => {
+    if (clientSockets.get(conn) === socket && socket._clientConn !== conn) clientSockets.delete(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 */
@@ -833,6 +1449,7 @@ function clientUpgrade(req, socket, head) {
   if (req.timeoutCb) socket.removeListener("timeout", req.timeoutCb);
   socket.removeListener("timeout", responseOnTimeout);
   freeParser(socket);
+  unfeed(socket);
   const bodyHead = Buffer.from(head.buffer, head.byteOffset, head.byteLength);
   const eventName = req.method === "CONNECT" ? "connect" : "upgrade";
   if (req.listenerCount(eventName) > 0) {
@@ -949,6 +1566,7 @@ function socketOnEnd() {
 }
 
 const INVALID_PATH_REGEX = /[^!-ÿ]/;
+const kPath = Symbol("kPath");
 
 export class ClientRequest extends OutgoingMessage {
   constructor(input, options, cb) {
@@ -965,7 +1583,7 @@ export class ClientRequest extends OutgoingMessage {
       cb = options;
       options = input || {};
     } else {
-      options = { ...input, ...options };
+      options = Object.assign({ __proto__: null }, input, options);  /* as Node's: no prototype's options */
     }
     let agent = options.agent;
     const defaultAgent = options._defaultAgent || globalAgent;
@@ -993,7 +1611,7 @@ export class ClientRequest extends OutgoingMessage {
       return host;
     };
     const host = optsWithoutSignal.host = validHost(options.hostname, "hostname") || validHost(options.host, "host") || "localhost";
-    const setHost = options.setHost === undefined || Boolean(options.setHost);
+    const setHost = options.setHost !== undefined ? Boolean(options.setHost) : options.setDefaultHeaders !== false;
     this.socketPath = options.socketPath;
     if (options.timeout !== undefined) {
       if (typeof options.timeout !== "number") throw invalidArgType("timeout", "of type number", options.timeout);
@@ -1001,13 +1619,8 @@ export class ClientRequest extends OutgoingMessage {
     }
     const signal = options.signal;
     if (signal) {
+      addAbortSignal(signal, this);  /* as Node's: destroyed with an AbortError, now if already aborted */
       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);
@@ -1019,8 +1632,28 @@ export class ClientRequest extends OutgoingMessage {
     }
     if (options.maxHeaderSize !== undefined) validateInteger(options.maxHeaderSize, "maxHeaderSize");
     this.maxHeaderSize = options.maxHeaderSize;
+    const insecureHTTPParser = options.insecureHTTPParser;
+    if (insecureHTTPParser !== undefined && typeof insecureHTTPParser !== "boolean") {
+      throw invalidArgType("options.insecureHTTPParser", "of type boolean", insecureHTTPParser);
+    }
+    this.insecureHTTPParser = insecureHTTPParser;
+    const httpValidation = options.httpValidation;
+    if (httpValidation !== undefined) {
+      if (httpValidation !== "strict" && httpValidation !== "relaxed" && httpValidation !== "insecure") {
+        throw codeError(TypeError, "ERR_INVALID_ARG_VALUE",
+          `The property 'options.httpValidation' must be one of: 'strict', 'relaxed', 'insecure'. Received ${JSON.stringify(httpValidation)}`);
+      }
+      if (insecureHTTPParser !== undefined) {
+        throw codeError(TypeError, "ERR_INVALID_ARG_VALUE",
+          `The property 'options.httpValidation' cannot be used together with options.insecureHTTPParser. Received ${JSON.stringify(httpValidation)}`);
+      }
+    }
+    this.httpValidation = httpValidation;
+    if (options.joinDuplicateHeaders !== undefined && typeof options.joinDuplicateHeaders !== "boolean") {
+      throw invalidArgType("options.joinDuplicateHeaders", "of type boolean", options.joinDuplicateHeaders);
+    }
     this.joinDuplicateHeaders = options.joinDuplicateHeaders;
-    this.path = options.path || "/";
+    this[kPath] = options.path || "/";
     if (cb) this.once("response", cb);
     this.useChunkedEncodingByDefault = !(method === "GET" || method === "HEAD" || method === "DELETE" || method === "OPTIONS" ||
       method === "TRACE" || method === "CONNECT");
@@ -1094,191 +1727,19 @@ export class ClientRequest extends OutgoingMessage {
     }
   }
 
-  /* 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) {
+    /* as Node's: the socket's request and error listener set now, so an error before the next tick
+     * reaches the request, and a request destroyed meanwhile gives its socket back to the agent */
+    if (socket && !err) {
+      socket._httpMessage = this;
+      socket.on("error", socketErrorListener);
+    }
     process.nextTick(() => {
       if (this.destroyed || err) {
         this.destroyed = true;
@@ -1291,6 +1752,7 @@ export class ClientRequest extends OutgoingMessage {
         if (socket) {
           if (!err && this.agent && !socket.destroyed) {
             socket.emit("free");
+            socket.removeListener("error", socketErrorListener);
             done(this._error);
           } else {
             socket.once("close", () => done(err || this._error));
@@ -1302,8 +1764,6 @@ export class ClientRequest extends OutgoingMessage {
         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);
@@ -1329,6 +1789,7 @@ export class ClientRequest extends OutgoingMessage {
     this.destroyed = true;
     if (this.res) this.res._dump();
     this._error = err;
+    this._errored = err;
     this.socket?.destroy(err);
     return this;
   }
@@ -1362,6 +1823,21 @@ export class ClientRequest extends OutgoingMessage {
   }
 }
 
+/* the request path, checked when set too: a path changed after the request was made can't smuggle
+ * a header in (Node's) */
+Object.defineProperty(ClientRequest.prototype, "path", {
+  get() {
+    return this[kPath];
+  },
+  set(value) {
+    const path = String(value);
+    if (INVALID_PATH_REGEX.test(path)) throw codeError(TypeError, "ERR_UNESCAPED_CHARACTERS", "Request path contains unescaped characters");
+    this[kPath] = path;
+  },
+  configurable: true,
+  enumerable: true,
+});
+
 export function request(url, options, cb) {
   return new ClientRequest(url, options, cb);
 }
@@ -1384,6 +1860,13 @@ export function setMaxIdleHTTPParsers(max) {
 export { Agent, globalAgent };
 
 export default {
-  METHODS, STATUS_CODES, Agent, ClientRequest, IncomingMessage, OutgoingMessage, ServerResponse, Server, createServer, get, globalAgent,
+  METHODS, STATUS_CODES, Agent, ClientRequest, IncomingMessage, OutgoingMessage, ServerResponse, Server, createServer, get,
   maxHeaderSize, request, setMaxIdleHTTPParsers, validateHeaderName, validateHeaderValue,
+  /* an accessor, as Node's: a program may replace the agent requests use by default */
+  get globalAgent() {
+    return globalAgent;
+  },
+  set globalAgent(value) {
+    setGlobalAgent(value);
+  },
 };