Hmm, you don't need to parse the headers by yourself, this is done by undici automatically, we just need to standardise the way that these are forward to undici.

If Array, push host to the headers array, if an object, attach host as a new property

I've simplified the code!

A header case I'm slightly worried about though is non-array iterables.

request({ origin, path: '/', method: 'GET', headers: new Set([['f0', 'b0'], ['f1', 'b1']]) }).

These headers are valid under UndiciHeaders and a request like this (though rare) is possible; but the proposed array/object check would break this.

Another issue I've noticed is [string,string][] headers always raise an error due to the way header processing is handled in Request.js. Say headers = [['f0', 'b0']] or [['f0', 'b0'], ['f1', 'b1']]

if (Array.isArray(headers)) {
      if (headers.length % 2 !== 0) {
        throw new InvalidArgumentError('headers array must be even')
      }
      for (let i = 0; i < headers.length; i += 2) {
        processHeader(this, headers[i], headers[i + 1])
      }
}

These headers are valid under UndiciHeaders and a request like this (though rare) is possible; but the proposed array/object check would break this.

Usually these are iterables, and we iterate over them, but not use utility functions; if that's the case, we can try to also check for Symbol.iterator to decide what to do with them.

Say headers = [['f0', 'b0']] or [['f0', 'b0'], ['f1', 'b1']]

That's somehow expected, we only expect them in the format [string, string], anything outside should throw

Handling iterators might mean we can't avoid some normalization. However this can be streamlined with the normalizeHeaders function also used in cache.js

diff --git a/lib/interceptor/dns.js b/lib/interceptor/dns.js
index 38287607..a878f39f 100644
--- a/lib/interceptor/dns.js
+++ b/lib/interceptor/dns.js
@@ -4,6 +4,15 @@ const { lookup } = require('node:dns')
 const DecoratorHandler = require('../handler/decorator-handler')
 const { InvalidArgumentError, InformationalError } = require('../core/errors')
 const maxInt = Math.pow(2, 31) - 1
+const { normalizeHeaders } = require('../util/cache.js')
+
+function addHostHeader (opts, host) {
+  if (Array.isArray(opts.headers)) {
+    return ['host', host, ...opts.headers]
+  }
+  const headers = normalizeHeaders(opts)
+  return { host, ...headers }
+}
 
 class DNSInstance {
   #maxTTL = 0
@@ -411,10 +420,7 @@ module.exports = interceptorOpts => {
           ...origDispatchOpts,
           servername: origin.hostname, // For SNI on TLS
           origin: newOrigin.origin,
-          headers: {
-            host: origin.host,
-            ...origDispatchOpts.headers
-          }
+          headers: addHostHeader(origDispatchOpts, origin.host)
         }
 
         dispatch(

Hmm... that's a good catch; I'd suggest to move the normalize headers to core/utils and implement it within the DNS interceptor first, and we can check if we wanna do the same for the core request in a further issue

Hmm... that's a good catch; I'd suggest to move the normalize headers to core/utils and implement it within the DNS interceptor first, and we can check if we wanna do the same for the core request in a further issue

This makes sense to me

Do we really support them? They should throw if request receives a multi-dimensional array.

They do throw for arrays, just not other iterables

Got it, let's do this: #4498 (comment)

The normalizeHeaders will normalize it to a plain JS object, feel free to append it once normalized.

Not for flat arrays for some reason. Refactored to accept types of [k1, v1, k2, v2, ...]

If there's an Undici error that is usable, let's make usage of it