nodejs · anonrig · 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,19 @@
 'use strict';
 
 const {
+  ArrayIsArray,
   MathMin,
   Symbol,
   Uint8Array,
 } = primordials;
 const { setImmediate } = require('timers');
 
-const { methods, allMethods, HTTPParser } = internalBinding('http_parser');
+const {
+  methods,
+  allMethods,
+  HTTPParser,
+  nativeHeadersToArray,
+} = internalBinding('http_parser');
 const { getOptionValue } = require('internal/options');
 const insecureHTTPParser = getOptionValue('--insecure-http-parser');
 
@@ -105,13 +111,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 +251,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;
     }
@@ -327,6 +337,12 @@ function calculateLenientFlags(httpValidation, insecureHTTPParserOption) {
   return lenient ? HTTPParser.kLenientAll | 0 : HTTPParser.kLenientNone | 0;
 }
 
+function unpackHeaderList(headers, fallback) {
+  if (headers != null && !ArrayIsArray(headers))
+    return nativeHeadersToArray(headers);
+  return headers || fallback || [];
+}
+
 module.exports = {
   _checkInvalidHeaderChar: checkInvalidHeaderChar,
   _checkIsHttpToken: checkIsHttpToken,
@@ -342,4 +358,5 @@ module.exports = {
   calculateLenientFlags,
   prepareError,
   kSkipPendingData,
+  unpackHeaderList,
 };
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,26 @@ const { Readable, finished } = require('stream');
 const {
   deprecateInstantiation,
 } = require('internal/util');
+const {
+  nativeHeadersHas,
+  nativeHeadersGet,
+  nativeHeadersToArray,
+} = internalBinding('http_parser');
+
+const kNativeFlagHost = 1 << 0;
+const kNativeFlagExpect = 1 << 1;
+const kNativeFlagContentLength = 1 << 2;
+const kNativeFlagTransferEncoding = 1 << 3;
+const kNativeFlagTE = 1 << 4;
 
 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 kRawHeaders = Symbol('kRawHeaders');
 const kTrailers = Symbol('kTrailers');
 const kTrailersDistinct = Symbol('kTrailersDistinct');
 const kTrailersCount = Symbol('kTrailersCount');
@@ -83,7 +98,9 @@ function IncomingMessage(socket) {
   this.complete = false;
   this[kHeaders] = null;
   this[kHeadersCount] = 0;
-  this.rawHeaders = [];
+  this[kNativeHeaders] = null;
+  this[kNativeFlags] = 0;
+  this[kRawHeaders] = null;
   this[kTrailers] = null;
   this[kTrailersCount] = 0;
   this.rawTrailers = [];
@@ -123,6 +140,32 @@ ObjectDefineProperty(IncomingMessage.prototype, 'connection', {
   },
 });
 
+ObjectDefineProperty(IncomingMessage.prototype, 'rawHeaders', {
+  __proto__: null,
+  configurable: true,
+  enumerable: true,
+  get: function() {
+    if (this[kRawHeaders] === null) {
+      if (this[kNativeHeaders] !== null) {
+        this[kRawHeaders] = nativeHeadersToArray(
+          this[kNativeHeaders],
+          this[kHeadersCount],
+        );
+        this[kNativeHeaders] = null;
+        this[kNativeFlags] = 0;
+      } else {
+        this[kRawHeaders] = [];
+      }
+    }
+    return this[kRawHeaders];
+  },
+  set: function(val) {
+    this[kRawHeaders] = val;
+    this[kNativeHeaders] = null;
+    this[kNativeFlags] = 0;
+  },
+});
+
 ObjectDefineProperty(IncomingMessage.prototype, 'headers', {
   __proto__: null,
   get: function() {
@@ -311,6 +354,65 @@ function abortSignal(self) {
   }
 }
 
+IncomingMessage.prototype._setNativeHeaders = function _setNativeHeaders(native, maxPairs) {
+  this[kNativeHeaders] = native;
+  this[kRawHeaders] = null;
+  this[kNativeFlags] = native[8] | (native[9] << 8) |
+                       (native[10] << 16) | (native[11] << 24);
+  const pairs = native[4] | (native[5] << 8) |
+                (native[6] << 16) | (native[7] << 24);
+  const len = pairs * 2;
+  this[kHeadersCount] = maxPairs > 0 ? MathMin(len, maxPairs) : len;
+};
+
+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 +596,41 @@ 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 === 'CONTENT-LENGTH' || name.toLowerCase() === 'content-length') {
+        return true;
+      }
+    } else if (len === 17) {
+      if (name === 'Transfer-Encoding' || 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 +639,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');