From a27f9e5f44e90071f75b2a24fce168c3778c3135 Mon Sep 17 00:00:00 2001
From: Marco Ippolito <marcoippolito54@gmail.com>
Date: Thu, 5 Jan 2023 17:45:53 +0100
Subject: [PATCH 01/12] http: res.setHeaders first implementation

---
 lib/_http_outgoing.js                         | 28 ++++++++
 lib/_http_server.js                           | 23 +------
 .../parallel/test-http-response-setheaders.js | 69 +++++++++++++++++++
 3 files changed, 98 insertions(+), 22 deletions(-)
 create mode 100644 test/parallel/test-http-response-setheaders.js

diff --git a/lib/_http_outgoing.js b/lib/_http_outgoing.js
index 8c80eabaec9e74..5ce90de6edfd7b 100644
--- a/lib/_http_outgoing.js
+++ b/lib/_http_outgoing.js
@@ -673,6 +673,34 @@ OutgoingMessage.prototype.setHeader = function setHeader(name, value) {
   return this;
 };
 
+OutgoingMessage.prototype.setHeaders = function setHeaders(obj) {
+  if (this._header) {
+    throw new ERR_HTTP_HEADERS_SENT('set');
+  }
+  
+  let k;
+  if (ArrayIsArray(obj)) {
+    if (obj.length % 2 !== 0) {
+      throw new ERR_INVALID_ARG_VALUE('headers', obj);
+    }
+
+    for (let n = 0; n < obj.length; n += 2) {
+      k = obj[n + 0];
+      if (k) this.setHeader(k, obj[n + 1]);
+    }
+  } else if (obj) {
+    const keys = ObjectKeys(obj);
+    // Retain for(;;) loop for performance reasons
+    // Refs: https://github.com/nodejs/node/pull/30958
+    for (let i = 0; i < keys.length; i++) {
+      k = keys[i];
+      if (k) this.setHeader(k, obj[k]);
+    }
+  }
+
+  return this;
+};
+
 OutgoingMessage.prototype.appendHeader = function appendHeader(name, value) {
   if (this._header) {
     throw new ERR_HTTP_HEADERS_SENT('append');
diff --git a/lib/_http_server.js b/lib/_http_server.js
index 62a26cdbaccd71..87d4c3fa6c9180 100644
--- a/lib/_http_server.js
+++ b/lib/_http_server.js
@@ -359,28 +359,7 @@ function writeHead(statusCode, reason, obj) {
   let headers;
   if (this[kOutHeaders]) {
     // Slow-case: when progressive API and header fields are passed.
-    let k;
-    if (ArrayIsArray(obj)) {
-      if (obj.length % 2 !== 0) {
-        throw new ERR_INVALID_ARG_VALUE('headers', obj);
-      }
-
-      for (let n = 0; n < obj.length; n += 2) {
-        k = obj[n + 0];
-        if (k) this.setHeader(k, obj[n + 1]);
-      }
-    } else if (obj) {
-      const keys = ObjectKeys(obj);
-      // Retain for(;;) loop for performance reasons
-      // Refs: https://github.com/nodejs/node/pull/30958
-      for (let i = 0; i < keys.length; i++) {
-        k = keys[i];
-        if (k) this.setHeader(k, obj[k]);
-      }
-    }
-    if (k === undefined && this._header) {
-      throw new ERR_HTTP_HEADERS_SENT('render');
-    }
+    this.setHeaders(obj);
     // Only progressive api is used
     headers = this[kOutHeaders];
   } else {
diff --git a/test/parallel/test-http-response-setheaders.js b/test/parallel/test-http-response-setheaders.js
new file mode 100644
index 00000000000000..533e128d8b1d6b
--- /dev/null
+++ b/test/parallel/test-http-response-setheaders.js
@@ -0,0 +1,69 @@
+'use strict';
+const common = require('../common');
+const http = require('http');
+const assert = require('assert');
+
+
+{
+  const server = http.createServer({ requireHostHeader: false }, common.mustCall((req, res) => {
+    res.setHeaders(['foo', '1', 'bar', '2' ]);
+    res.writeHead(200);
+    res.end();
+  }));
+
+  server.listen(0, common.mustCall(() => {
+    http.get({ port: server.address().port, headers: [] }, (res) => {
+      assert.strictEqual(res.statusCode, 200);
+      assert.strictEqual(res.headers.foo, '1');
+      assert.strictEqual(res.headers.bar, '2');
+      res.resume().on('end', common.mustCall(() => {
+        server.close();
+      }));
+    });
+  }));
+}
+
+{
+  const server = http.createServer({ requireHostHeader: false }, common.mustCall((req, res) => {
+    res.setHeaders({
+      foo: '1',
+      bar: '2'
+    });
+    res.writeHead(200);
+    res.end();
+  }));
+
+  server.listen(0, common.mustCall(() => {
+    http.get({ port: server.address().port }, (res) => {
+      assert.strictEqual(res.statusCode, 200);
+      assert.strictEqual(res.headers.foo, '1');
+      assert.strictEqual(res.headers.bar, '2');
+      res.resume().on('end', common.mustCall(() => {
+        server.close();
+      }));
+    });
+  }));
+}
+
+{
+  const server = http.createServer({ requireHostHeader: false }, common.mustCall((req, res) => {
+    res.writeHead(200); // headers already sent
+    assert.throws(() => { 
+      res.setHeaders({
+        foo: 'bar',
+      }); 
+    }, {
+      code: 'ERR_HTTP_HEADERS_SENT'
+    });
+    res.end();
+  }));
+
+  server.listen(0, common.mustCall(() => {
+    http.get({ port: server.address().port }, (res) => {
+      assert.strictEqual(res.headers.foo, undefined)
+      res.resume().on('end', common.mustCall(() => {
+        server.close();
+      }));
+    });
+  }));
+}

From e642c5736ef587d7e57ffacf904facca564e2955 Mon Sep 17 00:00:00 2001
From: Marco Ippolito <marcoippolito54@gmail.com>
Date: Thu, 5 Jan 2023 18:16:33 +0100
Subject: [PATCH 02/12] http: setheaders documentation

---
 doc/api/http.md                               | 46 +++++++++++++++++++
 lib/_http_server.js                           |  2 -
 .../parallel/test-http-response-setheaders.js |  6 +--
 3 files changed, 49 insertions(+), 5 deletions(-)

diff --git a/doc/api/http.md b/doc/api/http.md
index 553d611f846291..d1e93aa7180cad 100644
--- a/doc/api/http.md
+++ b/doc/api/http.md
@@ -1953,6 +1953,8 @@ non-string values. However, the non-string values will be converted to strings
 for network transmission. The same response object is returned to the caller,
 to enable call chaining.
 
+> To set multiple header values at once see [`response.setHeaders()`][].
+
 ```js
 response.setHeader('Content-Type', 'text/html');
 ```
@@ -1987,6 +1989,49 @@ header will not yield the expected result. If progressive population of headers
 is desired with potential future retrieval and modification, use
 [`response.setHeader()`][] instead of [`response.writeHead()`][].
 
+### `response.setHeaders(headers)`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `headers` {Object|Array}
+* Returns: {http.ServerResponse}
+
+Returns the response object.
+
+Sets multiple header values for implicit headers.
+`headers` may be an `Array` where the keys and values are in the same list.
+It is _not_ a list of tuples. So, the even-numbered offsets are key values,
+and the odd-numbered offsets are the associated values. The array is in the same
+format as `request.rawHeaders`.
+
+```js
+response.setHeaders(['foo', 'bar', 'fizz', 'buzz']);
+```
+
+or
+
+```js
+response.setHeaders({
+  foo: 'bar',
+  fizz: 'buzz',
+});
+```
+
+When headers have been set with [`response.setHeaders()`][], they will be merged
+with any headers passed to [`response.writeHead()`][], with the headers passed
+to [`response.writeHead()`][] given precedence.
+
+```js
+// Returns content-type = text/plain
+const server = http.createServer((req, res) => {
+  res.setHeaders(['Content-Type', 'text/html', 'X-Foo', 'bar']);
+  res.writeHead(200, { 'Content-Type': 'text/plain' });
+  res.end('ok');
+});
+```
+
 ### `response.setTimeout(msecs[, callback])`
 
 <!-- YAML
@@ -3803,6 +3848,7 @@ Set the maximum number of idle HTTP parsers. **Default:** `1000`.
 [`response.end()`]: #responseenddata-encoding-callback
 [`response.getHeader()`]: #responsegetheadername
 [`response.setHeader()`]: #responsesetheadername-value
+[`response.setHeaders()`]: #responsesetheadersheaders
 [`response.socket`]: #responsesocket
 [`response.writableEnded`]: #responsewritableended
 [`response.writableFinished`]: #responsewritablefinished
diff --git a/lib/_http_server.js b/lib/_http_server.js
index 87d4c3fa6c9180..cdd9ac0bffee3f 100644
--- a/lib/_http_server.js
+++ b/lib/_http_server.js
@@ -22,7 +22,6 @@
 'use strict';
 
 const {
-  ArrayIsArray,
   Error,
   MathMin,
   ObjectKeys,
@@ -76,7 +75,6 @@ const {
   ERR_HTTP_INVALID_STATUS_CODE,
   ERR_HTTP_SOCKET_ENCODING,
   ERR_INVALID_ARG_TYPE,
-  ERR_INVALID_ARG_VALUE,
   ERR_INVALID_CHAR
 } = codes;
 const {
diff --git a/test/parallel/test-http-response-setheaders.js b/test/parallel/test-http-response-setheaders.js
index 533e128d8b1d6b..5b655b960b52d1 100644
--- a/test/parallel/test-http-response-setheaders.js
+++ b/test/parallel/test-http-response-setheaders.js
@@ -48,10 +48,10 @@ const assert = require('assert');
 {
   const server = http.createServer({ requireHostHeader: false }, common.mustCall((req, res) => {
     res.writeHead(200); // headers already sent
-    assert.throws(() => { 
+    assert.throws(() => {
       res.setHeaders({
         foo: 'bar',
-      }); 
+      });
     }, {
       code: 'ERR_HTTP_HEADERS_SENT'
     });
@@ -60,7 +60,7 @@ const assert = require('assert');
 
   server.listen(0, common.mustCall(() => {
     http.get({ port: server.address().port }, (res) => {
-      assert.strictEqual(res.headers.foo, undefined)
+      assert.strictEqual(res.headers.foo, undefined);
       res.resume().on('end', common.mustCall(() => {
         server.close();
       }));

From 5749b04827bd2b0121c643eebdf98328e87578a8 Mon Sep 17 00:00:00 2001
From: Marco Ippolito <marcoippolito54@gmail.com>
Date: Thu, 5 Jan 2023 18:36:49 +0100
Subject: [PATCH 03/12] http: fix lint

---
 lib/_http_outgoing.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/_http_outgoing.js b/lib/_http_outgoing.js
index 5ce90de6edfd7b..9eb356afc69b9f 100644
--- a/lib/_http_outgoing.js
+++ b/lib/_http_outgoing.js
@@ -677,7 +677,7 @@ OutgoingMessage.prototype.setHeaders = function setHeaders(obj) {
   if (this._header) {
     throw new ERR_HTTP_HEADERS_SENT('set');
   }
-  
+
   let k;
   if (ArrayIsArray(obj)) {
     if (obj.length % 2 !== 0) {

From 4dceea00418ad65d6400fa3aaffb3a9a4aec4ac5 Mon Sep 17 00:00:00 2001
From: Marco Ippolito <marcoippolito54@gmail.com>
Date: Thu, 5 Jan 2023 21:22:39 +0100
Subject: [PATCH 04/12] http: setheaders accepts headers class

---
 doc/api/http.md                               |  9 +++++-
 lib/_http_outgoing.js                         | 30 ++++++++++++-------
 .../parallel/test-http-response-setheaders.js | 20 +++++++++++++
 3 files changed, 47 insertions(+), 12 deletions(-)

diff --git a/doc/api/http.md b/doc/api/http.md
index d1e93aa7180cad..616ca5e5f679cb 100644
--- a/doc/api/http.md
+++ b/doc/api/http.md
@@ -1995,7 +1995,7 @@ is desired with potential future retrieval and modification, use
 added: REPLACEME
 -->
 
-* `headers` {Object|Array}
+* `headers` {Headers|Object|Array}
 * Returns: {http.ServerResponse}
 
 Returns the response object.
@@ -2006,6 +2006,13 @@ It is _not_ a list of tuples. So, the even-numbered offsets are key values,
 and the odd-numbered offsets are the associated values. The array is in the same
 format as `request.rawHeaders`.
 
+```js
+const headers = new Headers({ foo: 'bar' });
+response.setHeaders(headers);
+```
+
+or
+
 ```js
 response.setHeaders(['foo', 'bar', 'fizz', 'buzz']);
 ```
diff --git a/lib/_http_outgoing.js b/lib/_http_outgoing.js
index 9eb356afc69b9f..e7e17fbb31da3e 100644
--- a/lib/_http_outgoing.js
+++ b/lib/_http_outgoing.js
@@ -82,6 +82,8 @@ let debug = require('internal/util/debuglog').debuglog('http', (fn) => {
   debug = fn;
 });
 
+const { Headers } = require('internal/deps/undici/undici');
+
 const HIGH_WATER_MARK = getDefaultHighWaterMark();
 
 const kCorked = Symbol('corked');
@@ -673,28 +675,34 @@ OutgoingMessage.prototype.setHeader = function setHeader(name, value) {
   return this;
 };
 
-OutgoingMessage.prototype.setHeaders = function setHeaders(obj) {
+OutgoingMessage.prototype.setHeaders = function setHeaders(headers) {
   if (this._header) {
     throw new ERR_HTTP_HEADERS_SENT('set');
   }
-
   let k;
-  if (ArrayIsArray(obj)) {
-    if (obj.length % 2 !== 0) {
-      throw new ERR_INVALID_ARG_VALUE('headers', obj);
+
+  if (headers instanceof Headers) {
+    const keys = [...headers.keys()];
+    for (let i = 0; i < keys.length; i++) {
+      k = keys[i];
+      if (k) this.setHeader(k, headers.get(k));
+    }
+  } else if (ArrayIsArray(headers)) {
+    if (headers.length % 2 !== 0) {
+      throw new ERR_INVALID_ARG_VALUE('headers', headers);
     }
 
-    for (let n = 0; n < obj.length; n += 2) {
-      k = obj[n + 0];
-      if (k) this.setHeader(k, obj[n + 1]);
+    for (let n = 0; n < headers.length; n += 2) {
+      k = headers[n + 0];
+      if (k) this.setHeader(k, headers[n + 1]);
     }
-  } else if (obj) {
-    const keys = ObjectKeys(obj);
+  } else if (headers) {
+    const keys = ObjectKeys(headers);
     // Retain for(;;) loop for performance reasons
     // Refs: https://github.com/nodejs/node/pull/30958
     for (let i = 0; i < keys.length; i++) {
       k = keys[i];
-      if (k) this.setHeader(k, obj[k]);
+      if (k) this.setHeader(k, headers[k]);
     }
   }
 
diff --git a/test/parallel/test-http-response-setheaders.js b/test/parallel/test-http-response-setheaders.js
index 5b655b960b52d1..a3af552e69a451 100644
--- a/test/parallel/test-http-response-setheaders.js
+++ b/test/parallel/test-http-response-setheaders.js
@@ -67,3 +67,23 @@ const assert = require('assert');
     });
   }));
 }
+
+{
+  const server = http.createServer({ requireHostHeader: false }, common.mustCall((req, res) => {
+    const headers = new globalThis.Headers({ foo: '1', bar: '2' });
+    res.setHeaders(headers);
+    res.writeHead(200);
+    res.end();
+  }));
+
+  server.listen(0, common.mustCall(() => {
+    http.get({ port: server.address().port }, (res) => {
+      assert.strictEqual(res.statusCode, 200);
+      assert.strictEqual(res.headers.foo, '1');
+      assert.strictEqual(res.headers.bar, '2');
+      res.resume().on('end', common.mustCall(() => {
+        server.close();
+      }));
+    });
+  }));
+}

From 0620d8c70a13ffc95203edaa109f76504802c9ef Mon Sep 17 00:00:00 2001
From: Marco Ippolito <marcoippolito54@gmail.com>
Date: Thu, 5 Jan 2023 22:05:55 +0100
Subject: [PATCH 05/12] http: writeHead accepts headers

---
 doc/api/http.md                         | 19 ++++++++++++--
 lib/_http_server.js                     |  4 +++
 test/parallel/test-http-write-head-2.js | 35 +++++++++++++++++++++++++
 3 files changed, 56 insertions(+), 2 deletions(-)

diff --git a/doc/api/http.md b/doc/api/http.md
index 616ca5e5f679cb..7bc58f1787a038 100644
--- a/doc/api/http.md
+++ b/doc/api/http.md
@@ -2001,7 +2001,8 @@ added: REPLACEME
 Returns the response object.
 
 Sets multiple header values for implicit headers.
-`headers` may be an `Array` where the keys and values are in the same list.
+`headers` may be an instance of [`Headers`][] or `Array` where the keys
+and values are in the same list.
 It is _not_ a list of tuples. So, the even-numbered offsets are key values,
 and the odd-numbered offsets are the associated values. The array is in the same
 format as `request.rawHeaders`.
@@ -2255,6 +2256,10 @@ response.writeEarlyHints({
 <!-- YAML
 added: v0.1.30
 changes:
+  - version:
+    - REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/46109
+    description: Allow passing headers as Headers object.
   - version: v14.14.0
     pr-url: https://github.com/nodejs/node/pull/35274
     description: Allow passing headers as an array.
@@ -2274,7 +2279,7 @@ changes:
 
 * `statusCode` {number}
 * `statusMessage` {string}
-* `headers` {Object|Array}
+* `headers` {Headers|Object|Array}
 * Returns: {http.ServerResponse}
 
 Sends a response header to the request. The status code is a 3-digit HTTP
@@ -2299,6 +2304,15 @@ response
   .end(body);
 ```
 
+`headers` may also be an instance of the [`Headers`][].
+
+```js
+const body = 'hello world';
+response
+  .writeHead(200, new Headers({ foo: 'bar' }))
+  .end(body);
+```
+
 This method must only be called once on a message and it must
 be called before [`response.end()`][] is called.
 
@@ -3812,6 +3826,7 @@ Set the maximum number of idle HTTP parsers. **Default:** `1000`.
 [`Buffer.byteLength()`]: buffer.md#static-method-bufferbytelengthstring-encoding
 [`Duplex`]: stream.md#class-streamduplex
 [`HPE_HEADER_OVERFLOW`]: errors.md#hpe_header_overflow
+[`Headers`]: globals.md#class-headers
 [`TypeError`]: errors.md#class-typeerror
 [`URL`]: url.md#the-whatwg-url-api
 [`agent.createConnection()`]: #agentcreateconnectionoptions-callback
diff --git a/lib/_http_server.js b/lib/_http_server.js
index cdd9ac0bffee3f..5fc703e6ded838 100644
--- a/lib/_http_server.js
+++ b/lib/_http_server.js
@@ -25,6 +25,7 @@ const {
   Error,
   MathMin,
   ObjectKeys,
+  ObjectFromEntries,
   ObjectSetPrototypeOf,
   RegExpPrototypeExec,
   ReflectApply,
@@ -88,6 +89,7 @@ const { setInterval, clearInterval } = require('timers');
 let debug = require('internal/util/debuglog').debuglog('http', (fn) => {
   debug = fn;
 });
+const { Headers } = require('internal/deps/undici/undici');
 
 const dc = require('diagnostics_channel');
 const onRequestStartChannel = dc.channel('http.server.request.start');
@@ -360,6 +362,8 @@ function writeHead(statusCode, reason, obj) {
     this.setHeaders(obj);
     // Only progressive api is used
     headers = this[kOutHeaders];
+  } else if (obj instanceof Headers) {
+    headers = ObjectFromEntries(obj.entries());
   } else {
     // Only writeHead() called
     headers = obj;
diff --git a/test/parallel/test-http-write-head-2.js b/test/parallel/test-http-write-head-2.js
index a47d0d72e3be56..447fc22d3bd8f2 100644
--- a/test/parallel/test-http-write-head-2.js
+++ b/test/parallel/test-http-write-head-2.js
@@ -59,3 +59,38 @@ const http = require('http');
     }));
   }));
 }
+
+{
+  const server = http.createServer(common.mustCall((req, res) => {
+    res.writeHead(200, new globalThis.Headers({ foo: 'bar' }));
+    res.end();
+  }));
+
+  server.listen(0, common.mustCall(() => {
+    http.get({ port: server.address().port }, common.mustCall((res) => {
+      assert.strictEqual(res.headers.foo, 'bar');
+      assert.strictEqual(res.statusCode, 200);
+      res.resume().on('end', common.mustCall(() => {
+        server.close();
+      }));
+    }));
+  }));
+}
+
+{
+  const server = http.createServer(common.mustCall((req, res) => {
+    res.setHeader('test', '1');
+    res.writeHead(200, new globalThis.Headers({ test: '2', test2: '2' }));
+    res.end();
+  }));
+
+  server.listen(0, common.mustCall(() => {
+    http.get({ port: server.address().port }, common.mustCall((res) => {
+      assert.strictEqual(res.headers.test, '2');
+      assert.strictEqual(res.headers.test2, '2');
+      res.resume().on('end', common.mustCall(() => {
+        server.close();
+      }));
+    }));
+  }));
+}

From 680904dc830afc3dbdb09c995aecb6b7ab10f353 Mon Sep 17 00:00:00 2001
From: Marco Ippolito <marcoippolito54@gmail.com>
Date: Fri, 6 Jan 2023 12:44:28 +0100
Subject: [PATCH 06/12] http: removed support for array and object

---
 doc/api/http.md                               | 42 ++---------
 lib/_http_outgoing.js                         | 28 ++------
 lib/_http_server.js                           | 26 +++++--
 .../parallel/test-http-response-setheaders.js | 72 ++++++++++++-------
 test/parallel/test-http-write-head-2.js       | 35 ---------
 5 files changed, 79 insertions(+), 124 deletions(-)

diff --git a/doc/api/http.md b/doc/api/http.md
index 7bc58f1787a038..78c1e42efa25dd 100644
--- a/doc/api/http.md
+++ b/doc/api/http.md
@@ -1995,38 +1995,20 @@ is desired with potential future retrieval and modification, use
 added: REPLACEME
 -->
 
-* `headers` {Headers|Object|Array}
+* `headers` {Headers}
 * Returns: {http.ServerResponse}
 
 Returns the response object.
 
 Sets multiple header values for implicit headers.
-`headers` may be an instance of [`Headers`][] or `Array` where the keys
-and values are in the same list.
-It is _not_ a list of tuples. So, the even-numbered offsets are key values,
-and the odd-numbered offsets are the associated values. The array is in the same
-format as `request.rawHeaders`.
+`headers` must be an instance of [`Headers`][], if header already exists
+in the to-be-sent headers, its value will be replaced.
 
 ```js
 const headers = new Headers({ foo: 'bar' });
 response.setHeaders(headers);
 ```
 
-or
-
-```js
-response.setHeaders(['foo', 'bar', 'fizz', 'buzz']);
-```
-
-or
-
-```js
-response.setHeaders({
-  foo: 'bar',
-  fizz: 'buzz',
-});
-```
-
 When headers have been set with [`response.setHeaders()`][], they will be merged
 with any headers passed to [`response.writeHead()`][], with the headers passed
 to [`response.writeHead()`][] given precedence.
@@ -2034,7 +2016,8 @@ to [`response.writeHead()`][] given precedence.
 ```js
 // Returns content-type = text/plain
 const server = http.createServer((req, res) => {
-  res.setHeaders(['Content-Type', 'text/html', 'X-Foo', 'bar']);
+  const headers = new Headers({ 'Content-Type': 'text/html' });
+  res.setHeaders(headers);
   res.writeHead(200, { 'Content-Type': 'text/plain' });
   res.end('ok');
 });
@@ -2256,10 +2239,6 @@ response.writeEarlyHints({
 <!-- YAML
 added: v0.1.30
 changes:
-  - version:
-    - REPLACEME
-    pr-url: https://github.com/nodejs/node/pull/46109
-    description: Allow passing headers as Headers object.
   - version: v14.14.0
     pr-url: https://github.com/nodejs/node/pull/35274
     description: Allow passing headers as an array.
@@ -2279,7 +2258,7 @@ changes:
 
 * `statusCode` {number}
 * `statusMessage` {string}
-* `headers` {Headers|Object|Array}
+* `headers` {Object|Array}
 * Returns: {http.ServerResponse}
 
 Sends a response header to the request. The status code is a 3-digit HTTP
@@ -2304,15 +2283,6 @@ response
   .end(body);
 ```
 
-`headers` may also be an instance of the [`Headers`][].
-
-```js
-const body = 'hello world';
-response
-  .writeHead(200, new Headers({ foo: 'bar' }))
-  .end(body);
-```
-
 This method must only be called once on a message and it must
 be called before [`response.end()`][] is called.
 
diff --git a/lib/_http_outgoing.js b/lib/_http_outgoing.js
index e7e17fbb31da3e..dabcb79ecdd5ef 100644
--- a/lib/_http_outgoing.js
+++ b/lib/_http_outgoing.js
@@ -679,31 +679,13 @@ OutgoingMessage.prototype.setHeaders = function setHeaders(headers) {
   if (this._header) {
     throw new ERR_HTTP_HEADERS_SENT('set');
   }
-  let k;
 
-  if (headers instanceof Headers) {
-    const keys = [...headers.keys()];
-    for (let i = 0; i < keys.length; i++) {
-      k = keys[i];
-      if (k) this.setHeader(k, headers.get(k));
-    }
-  } else if (ArrayIsArray(headers)) {
-    if (headers.length % 2 !== 0) {
-      throw new ERR_INVALID_ARG_VALUE('headers', headers);
-    }
+  if (headers instanceof Headers === false) {
+    throw new ERR_INVALID_ARG_TYPE('headers', 'Headers', headers);
+  }
 
-    for (let n = 0; n < headers.length; n += 2) {
-      k = headers[n + 0];
-      if (k) this.setHeader(k, headers[n + 1]);
-    }
-  } else if (headers) {
-    const keys = ObjectKeys(headers);
-    // Retain for(;;) loop for performance reasons
-    // Refs: https://github.com/nodejs/node/pull/30958
-    for (let i = 0; i < keys.length; i++) {
-      k = keys[i];
-      if (k) this.setHeader(k, headers[k]);
-    }
+  for (const key of headers.keys()) {
+    this.setHeader(key, headers.get(key));
   }
 
   return this;
diff --git a/lib/_http_server.js b/lib/_http_server.js
index 5fc703e6ded838..da5f240a37c489 100644
--- a/lib/_http_server.js
+++ b/lib/_http_server.js
@@ -22,10 +22,10 @@
 'use strict';
 
 const {
+  ArrayIsArray,
   Error,
   MathMin,
   ObjectKeys,
-  ObjectFromEntries,
   ObjectSetPrototypeOf,
   RegExpPrototypeExec,
   ReflectApply,
@@ -76,6 +76,7 @@ const {
   ERR_HTTP_INVALID_STATUS_CODE,
   ERR_HTTP_SOCKET_ENCODING,
   ERR_INVALID_ARG_TYPE,
+  ERR_INVALID_ARG_VALUE,
   ERR_INVALID_CHAR
 } = codes;
 const {
@@ -89,7 +90,6 @@ const { setInterval, clearInterval } = require('timers');
 let debug = require('internal/util/debuglog').debuglog('http', (fn) => {
   debug = fn;
 });
-const { Headers } = require('internal/deps/undici/undici');
 
 const dc = require('diagnostics_channel');
 const onRequestStartChannel = dc.channel('http.server.request.start');
@@ -359,11 +359,27 @@ function writeHead(statusCode, reason, obj) {
   let headers;
   if (this[kOutHeaders]) {
     // Slow-case: when progressive API and header fields are passed.
-    this.setHeaders(obj);
+    let k;
+    if (ArrayIsArray(obj)) {
+      if (obj.length % 2 !== 0) {
+        throw new ERR_INVALID_ARG_VALUE('headers', obj);
+      }
+
+      for (let n = 0; n < obj.length; n += 2) {
+        k = obj[n + 0];
+        if (k) this.setHeader(k, obj[n + 1]);
+      }
+    } else if (obj) {
+      const keys = ObjectKeys(obj);
+      // Retain for(;;) loop for performance reasons
+      // Refs: https://github.com/nodejs/node/pull/30958
+      for (let i = 0; i < keys.length; i++) {
+        k = keys[i];
+        if (k) this.setHeader(k, obj[k]);
+      }
+    }
     // Only progressive api is used
     headers = this[kOutHeaders];
-  } else if (obj instanceof Headers) {
-    headers = ObjectFromEntries(obj.entries());
   } else {
     // Only writeHead() called
     headers = obj;
diff --git a/test/parallel/test-http-response-setheaders.js b/test/parallel/test-http-response-setheaders.js
index a3af552e69a451..c3b48b816cd2dd 100644
--- a/test/parallel/test-http-response-setheaders.js
+++ b/test/parallel/test-http-response-setheaders.js
@@ -3,19 +3,21 @@ const common = require('../common');
 const http = require('http');
 const assert = require('assert');
 
-
 {
   const server = http.createServer({ requireHostHeader: false }, common.mustCall((req, res) => {
-    res.setHeaders(['foo', '1', 'bar', '2' ]);
-    res.writeHead(200);
+    res.writeHead(200); // headers already sent
+    const headers = new globalThis.Headers({ foo: '1' });
+    assert.throws(() => {
+      res.setHeaders(headers);
+    }, {
+      code: 'ERR_HTTP_HEADERS_SENT'
+    });
     res.end();
   }));
 
   server.listen(0, common.mustCall(() => {
-    http.get({ port: server.address().port, headers: [] }, (res) => {
-      assert.strictEqual(res.statusCode, 200);
-      assert.strictEqual(res.headers.foo, '1');
-      assert.strictEqual(res.headers.bar, '2');
+    http.get({ port: server.address().port }, (res) => {
+      assert.strictEqual(res.headers.foo, undefined);
       res.resume().on('end', common.mustCall(() => {
         server.close();
       }));
@@ -25,19 +27,42 @@ const assert = require('assert');
 
 {
   const server = http.createServer({ requireHostHeader: false }, common.mustCall((req, res) => {
-    res.setHeaders({
-      foo: '1',
-      bar: '2'
+    assert.throws(() => {
+      res.setHeaders(['foo', '1']);
+    }, {
+      code: 'ERR_INVALID_ARG_TYPE'
+    });
+    assert.throws(() => {
+      res.setHeaders({ foo: '1' });
+    }, {
+      code: 'ERR_INVALID_ARG_TYPE'
+    });
+    assert.throws(() => {
+      res.setHeaders(null);
+    }, {
+      code: 'ERR_INVALID_ARG_TYPE'
+    });
+    assert.throws(() => {
+      res.setHeaders(undefined);
+    }, {
+      code: 'ERR_INVALID_ARG_TYPE'
+    });
+    assert.throws(() => {
+      res.setHeaders('test');
+    }, {
+      code: 'ERR_INVALID_ARG_TYPE'
+    });
+    assert.throws(() => {
+      res.setHeaders(1);
+    }, {
+      code: 'ERR_INVALID_ARG_TYPE'
     });
-    res.writeHead(200);
     res.end();
   }));
 
   server.listen(0, common.mustCall(() => {
     http.get({ port: server.address().port }, (res) => {
-      assert.strictEqual(res.statusCode, 200);
-      assert.strictEqual(res.headers.foo, '1');
-      assert.strictEqual(res.headers.bar, '2');
+      assert.strictEqual(res.headers.foo, undefined);
       res.resume().on('end', common.mustCall(() => {
         server.close();
       }));
@@ -47,20 +72,17 @@ const assert = require('assert');
 
 {
   const server = http.createServer({ requireHostHeader: false }, common.mustCall((req, res) => {
-    res.writeHead(200); // headers already sent
-    assert.throws(() => {
-      res.setHeaders({
-        foo: 'bar',
-      });
-    }, {
-      code: 'ERR_HTTP_HEADERS_SENT'
-    });
+    const headers = new globalThis.Headers({ foo: '1', bar: '2' });
+    res.setHeaders(headers);
+    res.writeHead(200);
     res.end();
   }));
 
   server.listen(0, common.mustCall(() => {
     http.get({ port: server.address().port }, (res) => {
-      assert.strictEqual(res.headers.foo, undefined);
+      assert.strictEqual(res.statusCode, 200);
+      assert.strictEqual(res.headers.foo, '1');
+      assert.strictEqual(res.headers.bar, '2');
       res.resume().on('end', common.mustCall(() => {
         server.close();
       }));
@@ -72,14 +94,14 @@ const assert = require('assert');
   const server = http.createServer({ requireHostHeader: false }, common.mustCall((req, res) => {
     const headers = new globalThis.Headers({ foo: '1', bar: '2' });
     res.setHeaders(headers);
-    res.writeHead(200);
+    res.writeHead(200, ['foo', '3']);
     res.end();
   }));
 
   server.listen(0, common.mustCall(() => {
     http.get({ port: server.address().port }, (res) => {
       assert.strictEqual(res.statusCode, 200);
-      assert.strictEqual(res.headers.foo, '1');
+      assert.strictEqual(res.headers.foo, '3'); // ovverride by writeHead
       assert.strictEqual(res.headers.bar, '2');
       res.resume().on('end', common.mustCall(() => {
         server.close();
diff --git a/test/parallel/test-http-write-head-2.js b/test/parallel/test-http-write-head-2.js
index 447fc22d3bd8f2..a47d0d72e3be56 100644
--- a/test/parallel/test-http-write-head-2.js
+++ b/test/parallel/test-http-write-head-2.js
@@ -59,38 +59,3 @@ const http = require('http');
     }));
   }));
 }
-
-{
-  const server = http.createServer(common.mustCall((req, res) => {
-    res.writeHead(200, new globalThis.Headers({ foo: 'bar' }));
-    res.end();
-  }));
-
-  server.listen(0, common.mustCall(() => {
-    http.get({ port: server.address().port }, common.mustCall((res) => {
-      assert.strictEqual(res.headers.foo, 'bar');
-      assert.strictEqual(res.statusCode, 200);
-      res.resume().on('end', common.mustCall(() => {
-        server.close();
-      }));
-    }));
-  }));
-}
-
-{
-  const server = http.createServer(common.mustCall((req, res) => {
-    res.setHeader('test', '1');
-    res.writeHead(200, new globalThis.Headers({ test: '2', test2: '2' }));
-    res.end();
-  }));
-
-  server.listen(0, common.mustCall(() => {
-    http.get({ port: server.address().port }, common.mustCall((res) => {
-      assert.strictEqual(res.headers.test, '2');
-      assert.strictEqual(res.headers.test2, '2');
-      res.resume().on('end', common.mustCall(() => {
-        server.close();
-      }));
-    }));
-  }));
-}

From 67a0838a37280a96469377a185d8e9d4fa9d07be Mon Sep 17 00:00:00 2001
From: Marco Ippolito <marcoippolito54@gmail.com>
Date: Fri, 6 Jan 2023 12:50:52 +0100
Subject: [PATCH 07/12] http: fix comments lint

---
 test/parallel/test-http-response-setheaders.js | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/parallel/test-http-response-setheaders.js b/test/parallel/test-http-response-setheaders.js
index c3b48b816cd2dd..19d190e98ed5ba 100644
--- a/test/parallel/test-http-response-setheaders.js
+++ b/test/parallel/test-http-response-setheaders.js
@@ -5,7 +5,7 @@ const assert = require('assert');
 
 {
   const server = http.createServer({ requireHostHeader: false }, common.mustCall((req, res) => {
-    res.writeHead(200); // headers already sent
+    res.writeHead(200); // Headers already sent
     const headers = new globalThis.Headers({ foo: '1' });
     assert.throws(() => {
       res.setHeaders(headers);
@@ -101,7 +101,7 @@ const assert = require('assert');
   server.listen(0, common.mustCall(() => {
     http.get({ port: server.address().port }, (res) => {
       assert.strictEqual(res.statusCode, 200);
-      assert.strictEqual(res.headers.foo, '3'); // ovverride by writeHead
+      assert.strictEqual(res.headers.foo, '3'); // Ovverride by writeHead
       assert.strictEqual(res.headers.bar, '2');
       res.resume().on('end', common.mustCall(() => {
         server.close();

From 0075cbd6af949967676e6d66f8d929927a2d55fb Mon Sep 17 00:00:00 2001
From: Marco Ippolito <marcoippolito54@gmail.com>
Date: Fri, 6 Jan 2023 19:54:24 +0100
Subject: [PATCH 08/12] http: fix typo

Co-authored-by: Rich Trott <rtrott@gmail.com>
---
 test/parallel/test-http-response-setheaders.js | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/parallel/test-http-response-setheaders.js b/test/parallel/test-http-response-setheaders.js
index 19d190e98ed5ba..730c9f45fc69dd 100644
--- a/test/parallel/test-http-response-setheaders.js
+++ b/test/parallel/test-http-response-setheaders.js
@@ -101,7 +101,7 @@ const assert = require('assert');
   server.listen(0, common.mustCall(() => {
     http.get({ port: server.address().port }, (res) => {
       assert.strictEqual(res.statusCode, 200);
-      assert.strictEqual(res.headers.foo, '3'); // Ovverride by writeHead
+      assert.strictEqual(res.headers.foo, '3'); // Override by writeHead
       assert.strictEqual(res.headers.bar, '2');
       res.resume().on('end', common.mustCall(() => {
         server.close();

From eb7481f185c6de0a631028ae53f152f7ef20a7d5 Mon Sep 17 00:00:00 2001
From: Marco Ippolito <marcoippolito54@gmail.com>
Date: Sat, 7 Jan 2023 11:57:15 +0100
Subject: [PATCH 09/12] http: added map support

---
 doc/api/http.md                               | 79 ++++++++++---------
 lib/_http_outgoing.js                         | 10 ++-
 .../parallel/test-http-response-setheaders.js | 20 +++++
 3 files changed, 69 insertions(+), 40 deletions(-)

diff --git a/doc/api/http.md b/doc/api/http.md
index 78c1e42efa25dd..cb46d815ec6290 100644
--- a/doc/api/http.md
+++ b/doc/api/http.md
@@ -1953,8 +1953,6 @@ non-string values. However, the non-string values will be converted to strings
 for network transmission. The same response object is returned to the caller,
 to enable call chaining.
 
-> To set multiple header values at once see [`response.setHeaders()`][].
-
 ```js
 response.setHeader('Content-Type', 'text/html');
 ```
@@ -1989,40 +1987,6 @@ header will not yield the expected result. If progressive population of headers
 is desired with potential future retrieval and modification, use
 [`response.setHeader()`][] instead of [`response.writeHead()`][].
 
-### `response.setHeaders(headers)`
-
-<!-- YAML
-added: REPLACEME
--->
-
-* `headers` {Headers}
-* Returns: {http.ServerResponse}
-
-Returns the response object.
-
-Sets multiple header values for implicit headers.
-`headers` must be an instance of [`Headers`][], if header already exists
-in the to-be-sent headers, its value will be replaced.
-
-```js
-const headers = new Headers({ foo: 'bar' });
-response.setHeaders(headers);
-```
-
-When headers have been set with [`response.setHeaders()`][], they will be merged
-with any headers passed to [`response.writeHead()`][], with the headers passed
-to [`response.writeHead()`][] given precedence.
-
-```js
-// Returns content-type = text/plain
-const server = http.createServer((req, res) => {
-  const headers = new Headers({ 'Content-Type': 'text/html' });
-  res.setHeaders(headers);
-  res.writeHead(200, { 'Content-Type': 'text/plain' });
-  res.end('ok');
-});
-```
-
 ### `response.setTimeout(msecs[, callback])`
 
 <!-- YAML
@@ -3005,6 +2969,47 @@ Sets a single header value. If the header already exists in the to-be-sent
 headers, its value will be replaced. Use an array of strings to send multiple
 headers with the same name.
 
+### `outgoingMessage.setHeaders(headers)`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* `headers` {Headers|Map}
+* Returns: {http.ServerResponse}
+
+Returns the response object.
+
+Sets multiple header values for implicit headers.
+`headers` must be an instance of [`Headers`][], if header already exists
+in the to-be-sent headers, its value will be replaced.
+
+```js
+const headers = new Headers({ foo: 'bar' });
+response.setHeaders(headers);
+```
+
+or
+
+```js
+const headers = new Map([['foo', 'bar']]);
+res.setHeaders(headers);
+```
+
+When headers have been set with [`outgoingMessage.setHeaders()`][],
+they will be merged with any headers passed to [`response.writeHead()`][],
+with the headers passed to [`response.writeHead()`][] given precedence.
+
+```js
+// Returns content-type = text/plain
+const server = http.createServer((req, res) => {
+  const headers = new Headers({ 'Content-Type': 'text/html' });
+  res.setHeaders(headers);
+  res.writeHead(200, { 'Content-Type': 'text/plain' });
+  res.end('ok');
+});
+```
+
 ### `outgoingMessage.setTimeout(msesc[, callback])`
 
 <!-- YAML
@@ -3823,6 +3828,7 @@ Set the maximum number of idle HTTP parsers. **Default:** `1000`.
 [`net.createConnection()`]: net.md#netcreateconnectionoptions-connectlistener
 [`new URL()`]: url.md#new-urlinput-base
 [`outgoingMessage.setHeader(name, value)`]: #outgoingmessagesetheadername-value
+[`outgoingMessage.setHeaders()`]: #outgoingmessagesetheadersheaders
 [`outgoingMessage.socket`]: #outgoingmessagesocket
 [`removeHeader(name)`]: #requestremoveheadername
 [`request.destroy()`]: #requestdestroyerror
@@ -3840,7 +3846,6 @@ Set the maximum number of idle HTTP parsers. **Default:** `1000`.
 [`response.end()`]: #responseenddata-encoding-callback
 [`response.getHeader()`]: #responsegetheadername
 [`response.setHeader()`]: #responsesetheadername-value
-[`response.setHeaders()`]: #responsesetheadersheaders
 [`response.socket`]: #responsesocket
 [`response.writableEnded`]: #responsewritableended
 [`response.writableFinished`]: #responsewritablefinished
diff --git a/lib/_http_outgoing.js b/lib/_http_outgoing.js
index dabcb79ecdd5ef..a4ab5de6574dca 100644
--- a/lib/_http_outgoing.js
+++ b/lib/_http_outgoing.js
@@ -82,7 +82,6 @@ let debug = require('internal/util/debuglog').debuglog('http', (fn) => {
   debug = fn;
 });
 
-const { Headers } = require('internal/deps/undici/undici');
 
 const HIGH_WATER_MARK = getDefaultHighWaterMark();
 
@@ -680,8 +679,13 @@ OutgoingMessage.prototype.setHeaders = function setHeaders(headers) {
     throw new ERR_HTTP_HEADERS_SENT('set');
   }
 
-  if (headers instanceof Headers === false) {
-    throw new ERR_INVALID_ARG_TYPE('headers', 'Headers', headers);
+
+  if (
+    !headers ||
+    !typeof headers.keys === 'function' ||
+    !typeof headers.get === 'function'
+  ) {
+    throw new ERR_INVALID_ARG_TYPE('headers', ['Headers', 'Map'], headers);
   }
 
   for (const key of headers.keys()) {
diff --git a/test/parallel/test-http-response-setheaders.js b/test/parallel/test-http-response-setheaders.js
index 730c9f45fc69dd..c1f697fa5d6cfe 100644
--- a/test/parallel/test-http-response-setheaders.js
+++ b/test/parallel/test-http-response-setheaders.js
@@ -109,3 +109,23 @@ const assert = require('assert');
     });
   }));
 }
+
+{
+  const server = http.createServer({ requireHostHeader: false }, common.mustCall((req, res) => {
+    const headers = new Map([['foo', '1'], ['bar', '2']]);
+    res.setHeaders(headers);
+    res.writeHead(200);
+    res.end();
+  }));
+
+  server.listen(0, common.mustCall(() => {
+    http.get({ port: server.address().port }, (res) => {
+      assert.strictEqual(res.statusCode, 200);
+      assert.strictEqual(res.headers.foo, '1');
+      assert.strictEqual(res.headers.bar, '2');
+      res.resume().on('end', common.mustCall(() => {
+        server.close();
+      }));
+    });
+  }));
+}

From 822eb15451b0480433b21fd1b3e1bf19fdb15dfc Mon Sep 17 00:00:00 2001
From: Marco Ippolito <marcoippolito54@gmail.com>
Date: Sat, 7 Jan 2023 14:34:59 +0100
Subject: [PATCH 10/12] http: fix array test

---
 doc/api/http.md       | 2 +-
 lib/_http_outgoing.js | 5 +++--
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/doc/api/http.md b/doc/api/http.md
index cb46d815ec6290..36f2be884827d8 100644
--- a/doc/api/http.md
+++ b/doc/api/http.md
@@ -2981,7 +2981,7 @@ added: REPLACEME
 Returns the response object.
 
 Sets multiple header values for implicit headers.
-`headers` must be an instance of [`Headers`][], if header already exists
+`headers` must be an instance of [`Headers`][] or `Map`, if a header already exists
 in the to-be-sent headers, its value will be replaced.
 
 ```js
diff --git a/lib/_http_outgoing.js b/lib/_http_outgoing.js
index a4ab5de6574dca..7f373d3a7c4061 100644
--- a/lib/_http_outgoing.js
+++ b/lib/_http_outgoing.js
@@ -682,8 +682,9 @@ OutgoingMessage.prototype.setHeaders = function setHeaders(headers) {
 
   if (
     !headers ||
-    !typeof headers.keys === 'function' ||
-    !typeof headers.get === 'function'
+    ArrayIsArray(headers) ||
+    typeof headers.keys !== 'function' ||
+    typeof headers.get !== 'function'
   ) {
     throw new ERR_INVALID_ARG_TYPE('headers', ['Headers', 'Map'], headers);
   }

From e33a41c7bbb20d21a932e782c279cb44ebcc4979 Mon Sep 17 00:00:00 2001
From: Marco Ippolito <marcoippolito54@gmail.com>
Date: Sat, 7 Jan 2023 14:47:34 +0100
Subject: [PATCH 11/12] http: fix lint

---
 doc/api/http.md | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/doc/api/http.md b/doc/api/http.md
index 36f2be884827d8..16489b3fe02904 100644
--- a/doc/api/http.md
+++ b/doc/api/http.md
@@ -2981,8 +2981,9 @@ added: REPLACEME
 Returns the response object.
 
 Sets multiple header values for implicit headers.
-`headers` must be an instance of [`Headers`][] or `Map`, if a header already exists
-in the to-be-sent headers, its value will be replaced.
+`headers` must be an instance of [`Headers`][] or `Map`,
+if a header already exists in the to-be-sent headers,
+its value will be replaced.
 
 ```js
 const headers = new Headers({ foo: 'bar' });

From 55923f64d21555566329dd1e495ea60017a26e45 Mon Sep 17 00:00:00 2001
From: Marco Ippolito <marcoippolito54@gmail.com>
Date: Sun, 8 Jan 2023 17:32:57 +0100
Subject: [PATCH 12/12] http: removed extra line

---
 lib/_http_outgoing.js | 1 -
 1 file changed, 1 deletion(-)

diff --git a/lib/_http_outgoing.js b/lib/_http_outgoing.js
index 7f373d3a7c4061..84d7c83ac1e60b 100644
--- a/lib/_http_outgoing.js
+++ b/lib/_http_outgoing.js
@@ -82,7 +82,6 @@ let debug = require('internal/util/debuglog').debuglog('http', (fn) => {
   debug = fn;
 });
 
-
 const HIGH_WATER_MARK = getDefaultHighWaterMark();
 
 const kCorked = Symbol('corked');