anonrig · Aug 16, 2026 · Aug 16, 2026 · Aug 16, 2026 · Aug 16, 2026 · Aug 16, 2026
diff --git a/lib/_http_client.js b/lib/_http_client.js
@@ -897,6 +897,7 @@ function parserOnIncomingClient(res, shouldKeepAlive) {
       // we need to rewrite it to the first one and skip all the pending IncomingMessage
       socket.parser.incoming = req.res;
       socket.parser.incoming[kSkipPendingData] = true;
+      socket.parser.setSkipBody?.(true);
     }
     return 0;
   }

diff --git a/lib/_http_common.js b/lib/_http_common.js
@@ -22,13 +22,18 @@
 'use strict';
 
 const {
+  ArrayIsArray,
   MathMin,
   Symbol,
   Uint8Array,
 } = primordials;
 const { setImmediate } = require('timers');
 
-const { methods, allMethods, HTTPParser } = internalBinding('http_parser');
+const {
+  methods,
+  allMethods,
+  HTTPParser,
+} = internalBinding('http_parser');
 const { getOptionValue } = require('internal/options');
 const insecureHTTPParser = getOptionValue('--insecure-http-parser');
 
@@ -105,13 +110,17 @@ function parserOnHeadersComplete(versionMajor, versionMinor, headers, method,
   incoming.url = url;
   incoming.upgrade = upgrade;
 
-  let n = headers.length;
+  if (headers !== undefined && !ArrayIsArray(headers)) {
+    incoming._setNativeHeaders(headers, parser.maxHeaderPairs);
+  } else {
+    let n = headers.length;
 
-  // If parser.maxHeaderPairs <= 0 assume that there's no limit.
-  if (parser.maxHeaderPairs > 0)
-    n = MathMin(n, parser.maxHeaderPairs);
+    // If parser.maxHeaderPairs <= 0 assume that there's no limit.
+    if (parser.maxHeaderPairs > 0)
+      n = MathMin(n, parser.maxHeaderPairs);
 
-  incoming._addHeaderLines(headers, n);
+    incoming._addHeaderLines(headers, n);
+  }
 
   if (typeof method === 'number') {
     // server only
@@ -241,14 +250,14 @@ const validTokenChars = new Uint8Array([
  * @returns {boolean}
  */
 function checkIsHttpToken(val) {
-  if (val.length >= 10) {
+  const len = val.length;
+  if (len === 0) return false;
+  // Table is faster for short names (Connection, Keep-Alive). V8's regex
+  // wins once the name is longer than ~10 bytes (Content-Length, etc.).
+  if (len > 10)
     return tokenRegExp.test(val);
-  }
-
-  if (val.length === 0) return false;
 
-  // Use lookup table for short strings, regex for longer ones
-  for (let i = 0; i < val.length; i++) {
+  for (let i = 0; i < len; i++) {
     if (!validTokenChars[val.charCodeAt(i)]) {
       return false;
     }

diff --git a/lib/_http_incoming.js b/lib/_http_incoming.js
@@ -22,6 +22,7 @@
 'use strict';
 
 const {
+  MathMin,
   ObjectDefineProperty,
   ObjectSetPrototypeOf,
   Symbol,
@@ -31,12 +32,29 @@ const { Readable, finished } = require('stream');
 const {
   deprecateInstantiation,
 } = require('internal/util');
+const {
+  HTTPParser,
+  nativeHeadersHas,
+  nativeHeadersGet,
+  nativeHeadersToArray,
+} = internalBinding('http_parser');
+
+const kNativeFlagHost = HTTPParser.kNativeHeaderFlagHost;
+const kNativeFlagExpect = HTTPParser.kNativeHeaderFlagExpect;
+const kNativeFlagContentLength = HTTPParser.kNativeHeaderFlagContentLength;
+const kNativeFlagTransferEncoding =
+  HTTPParser.kNativeHeaderFlagTransferEncoding;
+const kNativeFlagTE = HTTPParser.kNativeHeaderFlagTE;
+const kNativeHeadersCountOffset = HTTPParser.kNativeHeadersCountOffset;
+const kNativeHeadersFlagsOffset = HTTPParser.kNativeHeadersFlagsOffset;
 
 const { AbortController } = require('internal/abort_controller');
 
 const kHeaders = Symbol('kHeaders');
 const kHeadersDistinct = Symbol('kHeadersDistinct');
 const kHeadersCount = Symbol('kHeadersCount');
+const kNativeHeaders = Symbol('kNativeHeaders');
+const kNativeFlags = Symbol('kNativeFlags');
 const kTrailers = Symbol('kTrailers');
 const kTrailersDistinct = Symbol('kTrailersDistinct');
 const kTrailersCount = Symbol('kTrailersCount');
@@ -83,6 +101,8 @@ function IncomingMessage(socket) {
   this.complete = false;
   this[kHeaders] = null;
   this[kHeadersCount] = 0;
+  this[kNativeHeaders] = null;
+  this[kNativeFlags] = 0;
   this.rawHeaders = [];
   this[kTrailers] = null;
   this[kTrailersCount] = 0;
@@ -123,6 +143,44 @@ ObjectDefineProperty(IncomingMessage.prototype, 'connection', {
   },
 });
 
+function materializeRawHeaders() {
+  const headers = this[kNativeHeaders] !== null ?
+    nativeHeadersToArray(this[kNativeHeaders], this[kHeadersCount]) :
+    [];
+  this[kNativeHeaders] = null;
+  this[kNativeFlags] = 0;
+  ObjectDefineProperty(this, 'rawHeaders', {
+    __proto__: null,
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    value: headers,
+  });
+  return headers;
+}
+
+function setRawHeaders(val) {
+  this[kNativeHeaders] = null;
+  this[kNativeFlags] = 0;
+  ObjectDefineProperty(this, 'rawHeaders', {
+    __proto__: null,
+    configurable: true,
+    enumerable: true,
+    writable: true,
+    value: val,
+  });
+}
+
+function defineLazyRawHeaders(self) {
+  ObjectDefineProperty(self, 'rawHeaders', {
+    __proto__: null,
+    configurable: true,
+    enumerable: true,
+    get: materializeRawHeaders,
+    set: setRawHeaders,
+  });
+}
+
 ObjectDefineProperty(IncomingMessage.prototype, 'headers', {
   __proto__: null,
   get: function() {
@@ -311,6 +369,63 @@ function abortSignal(self) {
   }
 }
 
+IncomingMessage.prototype._setNativeHeaders = function _setNativeHeaders(native, maxPairs) {
+  this[kNativeHeaders] = native;
+  this[kNativeFlags] = native.readUInt32LE(kNativeHeadersFlagsOffset);
+  const pairs = native.readUInt32LE(kNativeHeadersCountOffset);
+  const len = pairs * 2;
+  this[kHeadersCount] = maxPairs > 0 ? MathMin(len, maxPairs) : len;
+  defineLazyRawHeaders(this);
+};
+
+IncomingMessage.prototype._hasHeader = function _hasHeader(name) {
+  if (this[kNativeHeaders] !== null) {
+    const flags = this[kNativeFlags];
+    switch (name) {
+      case 'host':
+        return (flags & kNativeFlagHost) !== 0;
+      case 'expect':
+        return (flags & kNativeFlagExpect) !== 0;
+      case 'content-length':
+        return (flags & kNativeFlagContentLength) !== 0;
+      case 'transfer-encoding':
+        return (flags & kNativeFlagTransferEncoding) !== 0;
+      case 'te':
+        return (flags & kNativeFlagTE) !== 0;
+      default:
+        return nativeHeadersHas(this[kNativeHeaders], name);
+    }
+  }
+  const headers = this.rawHeaders;
+  const n = this[kHeadersCount];
+  const want = name.length;
+  for (let i = 0; i < n; i += 2) {
+    const field = headers[i];
+    if (field.length === want && field.toLowerCase() === name)
+      return true;
+  }
+  return false;
+};
+
+IncomingMessage.prototype._getHeader = function _getHeader(name) {
+  if (this[kNativeHeaders] !== null)
+    return nativeHeadersGet(this[kNativeHeaders], name);
+  const headers = this.rawHeaders;
+  const n = this[kHeadersCount];
+  const want = name.length;
+  let value;
+  for (let i = 0; i < n; i += 2) {
+    const field = headers[i];
+    if (field.length === want && field.toLowerCase() === name) {
+      if (value === undefined)
+        value = headers[i + 1];
+      else
+        value += ', ' + headers[i + 1];
+    }
+  }
+  return value;
+};
+
 IncomingMessage.prototype._addHeaderLines = _addHeaderLines;
 function _addHeaderLines(headers, n) {
   if (headers?.length) {
@@ -494,13 +609,40 @@ function _addHeaderLineDistinct(field, value, dest) {
   }
 }
 
+// Scan C++ headers (or rawHeaders) so callers do not force req.headers.
+IncomingMessage.prototype._hasBodyHeaders = function _hasBodyHeaders() {
+  if (this[kNativeHeaders] !== null) {
+    return (this[kNativeFlags] &
+            (kNativeFlagContentLength | kNativeFlagTransferEncoding)) !== 0;
+  }
+  const headers = this.rawHeaders;
+  const n = this[kHeadersCount];
+  for (let i = 0; i < n; i += 2) {
+    const name = headers[i];
+    const len = name.length;
+    if (len === 14) {
+      if (name === 'Content-Length' || name === 'content-length' ||
+          name.toLowerCase() === 'content-length') {
+        return true;
+      }
+    } else if (len === 17) {
+      if (name === 'Transfer-Encoding' || name === 'transfer-encoding' ||
+          name.toLowerCase() === 'transfer-encoding') {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+
 IncomingMessage.prototype._dumpAndCloseReadable = function _dumpAndCloseReadable() {
   this._dumped = true;
   this._readableState.ended = true;
   this._readableState.endEmitted = true;
   this._readableState.destroyed = true;
   this._readableState.closed = true;
   this._readableState.closeEmitted = true;
+  this.socket?.parser?.setSkipBody?.(true);
 };
 
 
@@ -509,6 +651,7 @@ IncomingMessage.prototype._dumpAndCloseReadable = function _dumpAndCloseReadable
 IncomingMessage.prototype._dump = function _dump() {
   if (!this._dumped) {
     this._dumped = true;
+    this.socket?.parser?.setSkipBody?.(true);
     // If there is buffered data, it may trigger 'data' events.
     // Remove 'data' event listeners explicitly.
     this.removeAllListeners('data');