diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index 3e7c3f62aa752f..f4a1ff56f29817 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -68,7 +68,7 @@
 
 # http
 
-/deps/llhttp/* @nodejs/http @nodejs/net
+/deps/milo/* @nodejs/http @nodejs/net
 /doc/api/http.md @nodejs/http @nodejs/net
 /lib/_http_* @nodejs/http @nodejs/net
 /lib/http.js @nodejs/http @nodejs/net
diff --git a/.github/workflows/tools.yml b/.github/workflows/tools.yml
index 852097fa5626cf..5a8d03f4e88aa1 100644
--- a/.github/workflows/tools.yml
+++ b/.github/workflows/tools.yml
@@ -29,7 +29,7 @@ on:
           - icu
           - libuv
           - lint-md-dependencies
-          - llhttp
+          - milo
           - minimatch
           - nghttp2
           - nghttp3
@@ -199,11 +199,11 @@ jobs:
                 cd ../..
                 make lint-md-rollup
               fi
-          - id: llhttp
+          - id: milo
             subsystem: deps
             label: dependencies
             run: |
-              ./tools/dep_updaters/update-llhttp.sh > temp-output
+              ./tools/dep_updaters/update-milo.sh > temp-output
               cat temp-output
               tail -n1 temp-output | grep "NEW_VERSION=" >> "$GITHUB_ENV" || true
               rm temp-output
diff --git a/LICENSE b/LICENSE
index 5688952e3ba22f..2b63d5f6e01403 100644
--- a/LICENSE
+++ b/LICENSE
@@ -696,30 +696,13 @@ The externally maintained libraries used by Node.js are:
         license.
   """
 
-- llhttp, located at deps/llhttp, is licensed as follows:
+- milo, located at deps/milo, is licensed as follows:
   """
-    This software is licensed under the MIT License.
+    Copyright (c) 2023, and above Paolo Insogna and other contributors
 
-    Copyright Fedor Indutny, 2018.
+    Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
 
-    Permission is hereby granted, free of charge, to any person obtaining a
-    copy of this software and associated documentation files (the
-    "Software"), to deal in the Software without restriction, including
-    without limitation the rights to use, copy, modify, merge, publish,
-    distribute, sublicense, and/or sell copies of the Software, and to permit
-    persons to whom the Software is furnished to do so, subject to the
-    following conditions:
-
-    The above copyright notice and this permission notice shall be included
-    in all copies or substantial portions of the Software.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-    OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-    MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-    NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-    DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-    OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-    USE OR OTHER DEALINGS IN THE SOFTWARE.
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
   """
 
 - corepack, located at deps/corepack, is licensed as follows:
diff --git a/Makefile b/Makefile
index b7871bf218572c..6efa3387ccaeff 100644
--- a/Makefile
+++ b/Makefile
@@ -169,7 +169,7 @@ with-code-cache test-code-cache:
 	$(warning '$@' target is a noop)
 
 out/Makefile: config.gypi common.gypi node.gyp \
-	deps/uv/uv.gyp deps/llhttp/llhttp.gyp deps/zlib/zlib.gyp \
+	deps/uv/uv.gyp deps/zlib/zlib.gyp \
 	deps/simdutf/simdutf.gyp deps/ada/ada.gyp \
 	tools/v8_gypfiles/toolchain.gypi tools/v8_gypfiles/features.gypi \
 	tools/v8_gypfiles/inspector.gypi tools/v8_gypfiles/v8.gyp
diff --git a/benchmark/http/bench-parser.js b/benchmark/http/bench-parser.js
index 6b8bbd8808c720..6a1fa8be542d5b 100644
--- a/benchmark/http/bench-parser.js
+++ b/benchmark/http/bench-parser.js
@@ -23,7 +23,7 @@ function main({ len, n }) {
 
     bench.start();
     for (let i = 0; i < n; i++) {
-      parser.execute(header, 0, header.length);
+      parser.execute(header, header.length);
       parser.initialize(REQUEST, {});
     }
     bench.end(n);
diff --git a/deps/milo/libmilo.a b/deps/milo/libmilo.a
new file mode 100644
index 00000000000000..605d153ba78614
Binary files /dev/null and b/deps/milo/libmilo.a differ
diff --git a/deps/milo/milo.h b/deps/milo/milo.h
new file mode 100644
index 00000000000000..21380a568bf60b
--- /dev/null
+++ b/deps/milo/milo.h
@@ -0,0 +1,414 @@
+#ifndef MILO_H
+#define MILO_H
+
+#include <cstdarg>
+#include <cstdint>
+#include <cstdlib>
+#include <ostream>
+#include <new>
+
+#define MILO_VERSION "0.1.0"
+#define MILO_VERSION_MAJOR 0
+#define MILO_VERSION_MINOR 1
+#define MILO_VERSION_PATCH 0
+
+#define MILO_METHODS_MAP(EACH) \
+  EACH(0, ACL, ACL) \
+  EACH(1, BASELINE_CONTROL, BASELINE_CONTROL) \
+  EACH(2, BIND, BIND) \
+  EACH(3, CHECKIN, CHECKIN) \
+  EACH(4, CHECKOUT, CHECKOUT) \
+  EACH(5, CONNECT, CONNECT) \
+  EACH(6, COPY, COPY) \
+  EACH(7, DELETE, DELETE) \
+  EACH(8, GET, GET) \
+  EACH(9, HEAD, HEAD) \
+  EACH(10, LABEL, LABEL) \
+  EACH(11, LINK, LINK) \
+  EACH(12, LOCK, LOCK) \
+  EACH(13, MERGE, MERGE) \
+  EACH(14, MKACTIVITY, MKACTIVITY) \
+  EACH(15, MKCALENDAR, MKCALENDAR) \
+  EACH(16, MKCOL, MKCOL) \
+  EACH(17, MKREDIRECTREF, MKREDIRECTREF) \
+  EACH(18, MKWORKSPACE, MKWORKSPACE) \
+  EACH(19, MOVE, MOVE) \
+  EACH(20, OPTIONS, OPTIONS) \
+  EACH(21, ORDERPATCH, ORDERPATCH) \
+  EACH(22, PATCH, PATCH) \
+  EACH(23, POST, POST) \
+  EACH(24, PRI, PRI) \
+  EACH(25, PROPFIND, PROPFIND) \
+  EACH(26, PROPPATCH, PROPPATCH) \
+  EACH(27, PUT, PUT) \
+  EACH(28, REBIND, REBIND) \
+  EACH(29, REPORT, REPORT) \
+  EACH(30, SEARCH, SEARCH) \
+  EACH(31, TRACE, TRACE) \
+  EACH(32, UNBIND, UNBIND) \
+  EACH(33, UNCHECKOUT, UNCHECKOUT) \
+  EACH(34, UNLINK, UNLINK) \
+  EACH(35, UNLOCK, UNLOCK) \
+  EACH(36, UPDATE, UPDATE) \
+  EACH(37, UPDATEREDIRECTREF, UPDATEREDIRECTREF) \
+  EACH(38, VERSION_CONTROL, VERSION_CONTROL) \
+  EACH(39, DESCRIBE, DESCRIBE) \
+  EACH(40, GET_PARAMETER, GET_PARAMETER) \
+  EACH(41, PAUSE, PAUSE) \
+  EACH(42, PLAY, PLAY) \
+  EACH(43, PLAY_NOTIFY, PLAY_NOTIFY) \
+  EACH(44, REDIRECT, REDIRECT) \
+  EACH(45, SETUP, SETUP) \
+  EACH(46, SET_PARAMETER, SET_PARAMETER) \
+  EACH(47, TEARDOWN, TEARDOWN) \
+  EACH(48, PURGE, PURGE) \
+
+namespace milo {
+
+struct Parser;
+
+constexpr static const uint8_t AUTODETECT = 0;
+
+constexpr static const uint8_t REQUEST = 1;
+
+constexpr static const uint8_t RESPONSE = 2;
+
+constexpr static const uint8_t CONNECTION_KEEPALIVE = 0;
+
+constexpr static const uint8_t CONNECTION_CLOSE = 1;
+
+constexpr static const uint8_t CONNECTION_UPGRADE = 2;
+
+constexpr static const uint8_t ERROR_NONE = 0;
+
+constexpr static const uint8_t ERROR_UNEXPECTED_DATA = 1;
+
+constexpr static const uint8_t ERROR_UNEXPECTED_EOF = 2;
+
+constexpr static const uint8_t ERROR_CALLBACK_ERROR = 3;
+
+constexpr static const uint8_t ERROR_UNEXPECTED_CHARACTER = 4;
+
+constexpr static const uint8_t ERROR_UNEXPECTED_CONTENT_LENGTH = 5;
+
+constexpr static const uint8_t ERROR_UNEXPECTED_TRANSFER_ENCODING = 6;
+
+constexpr static const uint8_t ERROR_UNEXPECTED_CONTENT = 7;
+
+constexpr static const uint8_t ERROR_UNTRAILERS = 8;
+
+constexpr static const uint8_t ERROR_INVALID_VERSION = 9;
+
+constexpr static const uint8_t ERROR_INVALID_STATUS = 10;
+
+constexpr static const uint8_t ERROR_INVALID_CONTENT_LENGTH = 11;
+
+constexpr static const uint8_t ERROR_INVALID_TRANSFER_ENCODING = 12;
+
+constexpr static const uint8_t ERROR_INVALID_CHUNK_SIZE = 13;
+
+constexpr static const uint8_t ERROR_MISSING_CONNECTION_UPGRADE = 14;
+
+constexpr static const uint8_t ERROR_UNSUPPORTED_HTTP_VERSION = 15;
+
+constexpr static const uint8_t METHOD_ACL = 0;
+
+constexpr static const uint8_t METHOD_BASELINE_CONTROL = 1;
+
+constexpr static const uint8_t METHOD_BIND = 2;
+
+constexpr static const uint8_t METHOD_CHECKIN = 3;
+
+constexpr static const uint8_t METHOD_CHECKOUT = 4;
+
+constexpr static const uint8_t METHOD_CONNECT = 5;
+
+constexpr static const uint8_t METHOD_COPY = 6;
+
+constexpr static const uint8_t METHOD_DELETE = 7;
+
+constexpr static const uint8_t METHOD_GET = 8;
+
+constexpr static const uint8_t METHOD_HEAD = 9;
+
+constexpr static const uint8_t METHOD_LABEL = 10;
+
+constexpr static const uint8_t METHOD_LINK = 11;
+
+constexpr static const uint8_t METHOD_LOCK = 12;
+
+constexpr static const uint8_t METHOD_MERGE = 13;
+
+constexpr static const uint8_t METHOD_MKACTIVITY = 14;
+
+constexpr static const uint8_t METHOD_MKCALENDAR = 15;
+
+constexpr static const uint8_t METHOD_MKCOL = 16;
+
+constexpr static const uint8_t METHOD_MKREDIRECTREF = 17;
+
+constexpr static const uint8_t METHOD_MKWORKSPACE = 18;
+
+constexpr static const uint8_t METHOD_MOVE = 19;
+
+constexpr static const uint8_t METHOD_OPTIONS = 20;
+
+constexpr static const uint8_t METHOD_ORDERPATCH = 21;
+
+constexpr static const uint8_t METHOD_PATCH = 22;
+
+constexpr static const uint8_t METHOD_POST = 23;
+
+constexpr static const uint8_t METHOD_PRI = 24;
+
+constexpr static const uint8_t METHOD_PROPFIND = 25;
+
+constexpr static const uint8_t METHOD_PROPPATCH = 26;
+
+constexpr static const uint8_t METHOD_PUT = 27;
+
+constexpr static const uint8_t METHOD_REBIND = 28;
+
+constexpr static const uint8_t METHOD_REPORT = 29;
+
+constexpr static const uint8_t METHOD_SEARCH = 30;
+
+constexpr static const uint8_t METHOD_TRACE = 31;
+
+constexpr static const uint8_t METHOD_UNBIND = 32;
+
+constexpr static const uint8_t METHOD_UNCHECKOUT = 33;
+
+constexpr static const uint8_t METHOD_UNLINK = 34;
+
+constexpr static const uint8_t METHOD_UNLOCK = 35;
+
+constexpr static const uint8_t METHOD_UPDATE = 36;
+
+constexpr static const uint8_t METHOD_UPDATEREDIRECTREF = 37;
+
+constexpr static const uint8_t METHOD_VERSION_CONTROL = 38;
+
+constexpr static const uint8_t METHOD_DESCRIBE = 39;
+
+constexpr static const uint8_t METHOD_GET_PARAMETER = 40;
+
+constexpr static const uint8_t METHOD_PAUSE = 41;
+
+constexpr static const uint8_t METHOD_PLAY = 42;
+
+constexpr static const uint8_t METHOD_PLAY_NOTIFY = 43;
+
+constexpr static const uint8_t METHOD_REDIRECT = 44;
+
+constexpr static const uint8_t METHOD_SETUP = 45;
+
+constexpr static const uint8_t METHOD_SET_PARAMETER = 46;
+
+constexpr static const uint8_t METHOD_TEARDOWN = 47;
+
+constexpr static const uint8_t METHOD_PURGE = 48;
+
+constexpr static const uint8_t STATE_START = 0;
+
+constexpr static const uint8_t STATE_FINISH = 1;
+
+constexpr static const uint8_t STATE_ERROR = 2;
+
+constexpr static const uint8_t STATE_MESSAGE = 3;
+
+constexpr static const uint8_t STATE_END = 4;
+
+constexpr static const uint8_t STATE_REQUEST = 5;
+
+constexpr static const uint8_t STATE_REQUEST_METHOD = 6;
+
+constexpr static const uint8_t STATE_REQUEST_URL = 7;
+
+constexpr static const uint8_t STATE_REQUEST_PROTOCOL = 8;
+
+constexpr static const uint8_t STATE_REQUEST_VERSION = 9;
+
+constexpr static const uint8_t STATE_RESPONSE = 10;
+
+constexpr static const uint8_t STATE_RESPONSE_VERSION = 11;
+
+constexpr static const uint8_t STATE_RESPONSE_STATUS = 12;
+
+constexpr static const uint8_t STATE_RESPONSE_REASON = 13;
+
+constexpr static const uint8_t STATE_HEADER_NAME = 14;
+
+constexpr static const uint8_t STATE_HEADER_TRANSFER_ENCODING = 15;
+
+constexpr static const uint8_t STATE_HEADER_CONTENT_LENGTH = 16;
+
+constexpr static const uint8_t STATE_HEADER_CONNECTION = 17;
+
+constexpr static const uint8_t STATE_HEADER_VALUE = 18;
+
+constexpr static const uint8_t STATE_HEADERS = 19;
+
+constexpr static const uint8_t STATE_BODY = 20;
+
+constexpr static const uint8_t STATE_TUNNEL = 21;
+
+constexpr static const uint8_t STATE_BODY_VIA_CONTENT_LENGTH = 22;
+
+constexpr static const uint8_t STATE_BODY_WITH_NO_LENGTH = 23;
+
+constexpr static const uint8_t STATE_CHUNK_LENGTH = 24;
+
+constexpr static const uint8_t STATE_CHUNK_EXTENSION_NAME = 25;
+
+constexpr static const uint8_t STATE_CHUNK_EXTENSION_VALUE = 26;
+
+constexpr static const uint8_t STATE_CHUNK_EXTENSION_QUOTED_VALUE = 27;
+
+constexpr static const uint8_t STATE_CHUNK_DATA = 28;
+
+constexpr static const uint8_t STATE_CHUNK_END = 29;
+
+constexpr static const uint8_t STATE_CRLF_AFTER_LAST_CHUNK = 30;
+
+constexpr static const uint8_t STATE_TRAILER_NAME = 31;
+
+constexpr static const uint8_t STATE_TRAILER_VALUE = 32;
+
+using Callback = intptr_t(*)(const Parser*, const unsigned char*, uintptr_t);
+
+struct Callbacks {
+  Callback before_state_change;
+  Callback after_state_change;
+  Callback on_error;
+  Callback on_finish;
+  Callback on_message_start;
+  Callback on_message_complete;
+  Callback on_request;
+  Callback on_response;
+  Callback on_reset;
+  Callback on_method;
+  Callback on_url;
+  Callback on_protocol;
+  Callback on_version;
+  Callback on_status;
+  Callback on_reason;
+  Callback on_header_name;
+  Callback on_header_value;
+  Callback on_headers;
+  Callback on_connect;
+  Callback on_upgrade;
+  Callback on_chunk_length;
+  Callback on_chunk_extension_name;
+  Callback on_chunk_extension_value;
+  Callback on_body;
+  Callback on_data;
+  Callback on_trailer_name;
+  Callback on_trailer_value;
+  Callback on_trailers;
+};
+
+struct Parser {
+  void *owner;
+  uint8_t state;
+  uint64_t position;
+  bool paused;
+  uint8_t error_code;
+  const unsigned char *error_description;
+  uintptr_t error_description_len;
+  const unsigned char *unconsumed;
+  uintptr_t unconsumed_len;
+  uint8_t id;
+  uint8_t mode;
+  bool continue_without_data;
+  uint8_t message_type;
+  bool is_connect;
+  uint8_t method;
+  uint32_t status;
+  uint8_t version_major;
+  uint8_t version_minor;
+  uint8_t connection;
+  bool has_content_length;
+  bool has_chunked_transfer_encoding;
+  bool has_upgrade;
+  bool has_trailers;
+  uint64_t content_length;
+  uint64_t chunk_size;
+  uint64_t remaining_content_length;
+  uint64_t remaining_chunk_size;
+  bool skip_body;
+  Callbacks callbacks;
+};
+
+extern "C" {
+
+/// A callback that simply returns `0`.
+///
+/// Use this callback as pointer when you want to remove a callback from the
+/// parser.
+intptr_t milo_noop(const Parser *_parser, const unsigned char *_data, uintptr_t _len);
+
+/// Cleans up memory used by a string previously returned by one of the milo's C
+/// public interface.
+void milo_free_string(const unsigned char *s);
+
+/// Creates a new parser.
+Parser *milo_create();
+
+/// # Safety
+///
+/// Destroys a parser.
+void milo_destroy(Parser *ptr);
+
+/// # Safety
+///
+/// Resets a parser to its initial state.
+void milo_reset(const Parser *parser, bool keep_position);
+
+/// # Safety
+///
+/// Parses a slice of characters. It returns the number of consumed characters.
+uintptr_t milo_parse(const Parser *parser, const unsigned char *data, uintptr_t limit);
+
+/// # Safety
+///
+/// Pauses the parser. It will have to be resumed via `milo_resume`.
+void milo_pause(const Parser *parser);
+
+/// # Safety
+///
+/// Resumes the parser.
+void milo_resume(const Parser *parser);
+
+/// # Safety
+///
+/// Marks the parser as finished. Any new data received via `milo_parse` will
+/// put the parser in the error state.
+void milo_finish(const Parser *parser);
+
+/// # Safety
+///
+/// Returns the current parser's state as string.
+///
+/// The returned value must be freed using `free_string`.
+const unsigned char *milo_state_string(const Parser *parser);
+
+/// # Safety
+///
+/// Returns the current parser's error state as string.
+///
+/// The returned value must be freed using `free_string`.
+const unsigned char *milo_error_code_string(const Parser *parser);
+
+/// # Safety
+///
+/// Returns the current parser's error descrition.
+///
+/// The returned value must be freed using `free_string`.
+const unsigned char *milo_error_description_string(const Parser *parser);
+
+} // extern "C"
+
+} // namespace milo
+
+#endif // MILO_H
diff --git a/doc/api/cli.md b/doc/api/cli.md
index a92ede78f8af23..c3539dd1c961a9 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -1000,33 +1000,6 @@ Valid values are `"commonjs"` and `"module"`. The default is `"commonjs"`.
 
 The REPL does not support this option.
 
-### `--insecure-http-parser`
-
-<!-- YAML
-added:
- - v13.4.0
- - v12.15.0
- - v10.19.0
--->
-
-Enable leniency flags on the HTTP parser. This may allow
-interoperability with non-conformant HTTP implementations.
-
-When enabled, the parser will accept the following:
-
-* Invalid HTTP headers values.
-* Invalid HTTP versions.
-* Allow message containing both `Transfer-Encoding`
-  and `Content-Length` headers.
-* Allow extra data after message when `Connection: close` is present.
-* Allow extra trasfer encodings after `chunked` has been provided.
-* Allow `\n` to be used as token separator instead of `\r\n`.
-* Allow `\r\n` not to be provided after a chunk.
-* Allow spaces to be present after a chunk size and before `\r\n`.
-
-All the above will expose your application to request smuggling
-or poisoning attack. Avoid using this option.
-
 ### `--inspect[=[host:]port]`
 
 <!-- YAML
@@ -2310,7 +2283,6 @@ Node.js options that are allowed are:
 * `--icu-data-dir`
 * `--import`
 * `--input-type`
-* `--insecure-http-parser`
 * `--inspect-brk`
 * `--inspect-port`, `--debug-port`
 * `--inspect-publish-uid`
diff --git a/doc/api/http.md b/doc/api/http.md
index ce761af7561198..bfe58da60c6868 100644
--- a/doc/api/http.md
+++ b/doc/api/http.md
@@ -1077,6 +1077,16 @@ const hasContentType = request.hasHeader('content-type');
 
 Limits maximum response headers count. If set to 0, no limit will be applied.
 
+### `request.maxTrailersCount`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* {number} **Default:** `2000`
+
+Limits maximum response trailers count. If set to 0, no limit will be applied.
+
 ### `request.path`
 
 <!-- YAML
@@ -1750,6 +1760,16 @@ added: v0.7.0
 
 Limits maximum incoming headers count. If set to 0, no limit will be applied.
 
+### `server.maxTrailersCount`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+* {number} **Default:** `2000`
+
+Limits maximum incoming trailers count. If set to 0, no limit will be applied.
+
 ### `server.requestTimeout`
 
 <!-- YAML
@@ -3403,6 +3423,9 @@ Found'`.
 <!-- YAML
 added: v0.1.13
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/99999
+    description: The `insecureHTTPParser` option has been removed.
   - version:
     - v20.1.0
     - v18.17.0
@@ -3449,10 +3472,6 @@ changes:
     `readableHighWaterMark` and `writableHighWaterMark`. This affects
     `highWaterMark` property of both `IncomingMessage` and `ServerResponse`.
     **Default:** See [`stream.getDefaultHighWaterMark()`][].
-  * `insecureHTTPParser` {boolean} If set to `true`, it will use a HTTP parser
-    with leniency flags enabled. Using the insecure parser should be avoided.
-    See [`--insecure-http-parser`][] for more information.
-    **Default:** `false`.
   * `IncomingMessage` {http.IncomingMessage} Specifies the `IncomingMessage`
     class to be used. Useful for extending the original `IncomingMessage`.
     **Default:** `IncomingMessage`.
@@ -3742,10 +3761,6 @@ changes:
     request to. **Default:** `'localhost'`.
   * `hostname` {string} Alias for `host`. To support [`url.parse()`][],
     `hostname` will be used if both `host` and `hostname` are specified.
-  * `insecureHTTPParser` {boolean} If set to `true`, it will use a HTTP parser
-    with leniency flags enabled. Using the insecure parser should be avoided.
-    See [`--insecure-http-parser`][] for more information.
-    **Default:** `false`
   * `joinDuplicateHeaders` {boolean} It joins the field line values of
     multiple headers in a request with `, ` instead of discarding
     the duplicates. See [`message.headers`][] for more information.
@@ -4152,7 +4167,6 @@ Set the maximum number of idle HTTP parsers.
 [`'request'`]: #event-request
 [`'response'`]: #event-response
 [`'upgrade'`]: #event-upgrade
-[`--insecure-http-parser`]: cli.md#--insecure-http-parser
 [`--max-http-header-size`]: cli.md#--max-http-header-sizesize
 [`Agent`]: #class-httpagent
 [`Buffer.byteLength()`]: buffer.md#static-method-bufferbytelengthstring-encoding
diff --git a/doc/api/process.md b/doc/api/process.md
index 5718c83e4fbcf4..9292c6b5282e6f 100644
--- a/doc/api/process.md
+++ b/doc/api/process.md
@@ -3870,7 +3870,7 @@ Will generate an object similar to:
   cjs_module_lexer: '1.2.2',
   cldr: '43.0',
   icu: '73.1',
-  llhttp: '8.1.0',
+  milo: '0.1.0',
   modules: '115',
   napi: '8',
   nghttp2: '1.52.0',
diff --git a/doc/contributing/maintaining/maintaining-dependencies.md b/doc/contributing/maintaining/maintaining-dependencies.md
index c68245bf0bf6ad..29ac1d06535083 100644
--- a/doc/contributing/maintaining/maintaining-dependencies.md
+++ b/doc/contributing/maintaining/maintaining-dependencies.md
@@ -19,7 +19,7 @@ This a list of all the dependencies:
 * [histogram 0.11.8][]
 * [icu-small 73.2][]
 * [libuv 1.46.0][]
-* [llhttp 9.1.2][]
+* [milo 0.1.0][]
 * [minimatch 9.0.3][]
 * [nghttp2 1.56.0][]
 * [nghttp3 0.7.0][]
@@ -212,11 +212,11 @@ The [libuv](https://github.com/libuv/libuv) dependency is a
 multi-platform support library with a focus on asynchronous I/O.
 It was primarily developed for use by Node.js.
 
-### llhttp 9.1.2
+### milo 0.1.0
 
-The [llhttp](https://github.com/nodejs/llhttp) dependency is
+The [milo](https://github.com/ShogunPanda/milo) dependency is
 the http parser used by Node.js.
-See [maintaining-http][] for more informations.
+See \[maintaining-milo]\[] for more informations.
 
 ### minimatch 9.0.3
 
@@ -330,13 +330,13 @@ performance improvements not currently available in standard zlib.
 [histogram 0.11.8]: #histogram-0118
 [icu-small 73.2]: #icu-small-732
 [libuv 1.46.0]: #libuv-1460
-[llhttp 9.1.2]: #llhttp-912
 [maintaining-V8]: ./maintaining-V8.md
 [maintaining-cjs-module-lexer]: ./maintaining-cjs-module-lexer.md
 [maintaining-http]: ./maintaining-http.md
 [maintaining-icu]: ./maintaining-icu.md
 [maintaining-openssl]: ./maintaining-openssl.md
 [maintaining-web-assembly]: ./maintaining-web-assembly.md
+[milo 0.1.0]: #milo-010
 [minimatch 9.0.3]: #minimatch-903
 [nghttp2 1.56.0]: #nghttp2-1560
 [nghttp3 0.7.0]: #nghttp3-070
diff --git a/doc/contributing/maintaining/maintaining-http.md b/doc/contributing/maintaining/maintaining-http.md
index a1ffdff5045e8a..8315f7b392304a 100644
--- a/doc/contributing/maintaining/maintaining-http.md
+++ b/doc/contributing/maintaining/maintaining-http.md
@@ -72,9 +72,9 @@ to align them with the APIs built for the client.
 The low-level implementation of the
 [HTTP](https://nodejs.org/docs/latest/api/http.html)
 and [HTTPS](https://nodejs.org/docs/latest/api/https.html) APIs
-are maintained in the [llhttp](https://github.com/nodejs/llhttp)
+are maintained in the [milo](https://github.com/ShogunPanda/milo)
 repository. Updates are pulled into Node.js under
-[deps/llhttp](https://github.com/nodejs/node/tree/HEAD/deps/llhttp).
+[deps/milo](https://github.com/nodejs/node/tree/HEAD/deps/milo).
 
 ### HTTP2
 
diff --git a/doc/contributing/releases.md b/doc/contributing/releases.md
index 04d005ad8258a8..95b8ece0279380 100644
--- a/doc/contributing/releases.md
+++ b/doc/contributing/releases.md
@@ -674,7 +674,7 @@ the build before moving forward. Use the following list as a baseline:
 
 * `process.version` is as expected
 * `process.release` is as expected
-* `process.versions` is as expected (for example, `openssl` or `llhttp` version
+* `process.versions` is as expected (for example, `openssl` or `milo` version
   must be in the expected updated version)
 * npm version (check it matches what we expect)
 * Run the test suite against the built binaries (optional)
diff --git a/doc/node.1 b/doc/node.1
index 48ac6dc82130c2..9d2e87e1339013 100644
--- a/doc/node.1
+++ b/doc/node.1
@@ -288,12 +288,6 @@ Default is
 V8 Inspector integration allows attaching Chrome DevTools and IDEs to Node.js instances for debugging and profiling.
 It uses the Chrome DevTools Protocol.
 .
-.It Fl -insecure-http-parser
-Use an insecure HTTP parser that accepts invalid HTTP headers. This may allow
-interoperability with non-conformant HTTP implementations. It may also allow
-request smuggling and other HTTP attacks that rely on invalid headers being
-accepted. Avoid using this option.
-.
 .It Fl -jitless
 Disable runtime allocation of executable memory. This may be required on
 some platforms for security reasons. It can also reduce attack surface on
diff --git a/lib/_http_client.js b/lib/_http_client.js
index 9fd07e1676b8ff..28b2a3f627f2be 100644
--- a/lib/_http_client.js
+++ b/lib/_http_client.js
@@ -52,7 +52,6 @@ const {
   freeParser,
   parsers,
   HTTPParser,
-  isLenient,
   prepareError,
 } = require('_http_common');
 const {
@@ -106,9 +105,6 @@ let debug = require('internal/util/debuglog').debuglog('http', (fn) => {
 const INVALID_PATH_REGEX = /[^\u0021-\u00ff]/;
 const kError = Symbol('kError');
 
-const kLenientAll = HTTPParser.kLenientAll | 0;
-const kLenientNone = HTTPParser.kLenientNone | 0;
-
 const HTTP_CLIENT_TRACE_EVENT_NAME = 'http.client.request';
 
 function validateHost(host, name) {
@@ -221,13 +217,6 @@ function ClientRequest(input, options, cb) {
     validateInteger(maxHeaderSize, 'maxHeaderSize', 0);
   this.maxHeaderSize = maxHeaderSize;
 
-  const insecureHTTPParser = options.insecureHTTPParser;
-  if (insecureHTTPParser !== undefined) {
-    validateBoolean(insecureHTTPParser, 'options.insecureHTTPParser');
-  }
-
-  this.insecureHTTPParser = insecureHTTPParser;
-
   if (options.joinDuplicateHeaders !== undefined) {
     validateBoolean(options.joinDuplicateHeaders, 'options.joinDuplicateHeaders');
   }
@@ -532,7 +521,15 @@ function socketOnData(d) {
 
   assert(parser && parser.socket === socket);
 
-  const ret = parser.execute(d);
+  if (parser.busy) {
+    process.nextTick(socketOnData.bind(this, d));
+    return;
+  }
+
+  parser.busy = true;
+  const ret = parser.execute(d, d.length, req.method === 'CONNECT');
+  parser.busy = false;
+
   if (ret instanceof Error) {
     prepareError(ret, parser, d);
     debug('parse error', ret);
@@ -613,19 +610,18 @@ function parserOnIncomingClient(res, shouldKeepAlive) {
     // We already have a response object, this means the server
     // sent a double response.
     socket.destroy();
-    return 0;  // No special treatment.
+    return 0;
   }
   req.res = res;
 
-  // Skip body and treat as Upgrade.
   if (res.upgrade)
-    return 2;
+    return 0; // No further processing, body will by skipped by the parser
 
   // Responses to CONNECT request is handled as Upgrade.
   const method = req.method;
   if (method === 'CONNECT') {
     res.upgrade = true;
-    return 2;  // Skip body and treat as Upgrade.
+    return 0; // No further processing, body will by skipped by the parser
   }
 
   if (statusIsInformational(res.statusCode)) {
@@ -646,7 +642,7 @@ function parserOnIncomingClient(res, shouldKeepAlive) {
       rawHeaders: res.rawHeaders,
     });
 
-    return 1;  // Skip body but don't treat as Upgrade.
+    return 0; // No further processing, body will by skipped by the parser
   }
 
   if (req.shouldKeepAlive && !shouldKeepAlive && !req.upgradeOrConnect) {
@@ -694,11 +690,10 @@ function parserOnIncomingClient(res, shouldKeepAlive) {
     res._dump();
 
   if (method === 'HEAD')
-    return 1;  // Skip body but don't treat as Upgrade.
+    return 1;  // Manually skip body parsing
 
   if (res.statusCode === 304) {
     res.complete = true;
-    return 1; // Skip body as there won't be any
   }
 
   return 0;  // No special treatment.
@@ -798,12 +793,9 @@ function emitFreeNT(req) {
 function tickOnSocket(req, socket) {
   const parser = parsers.alloc();
   req.socket = socket;
-  const lenient = req.insecureHTTPParser === undefined ?
-    isLenient() : req.insecureHTTPParser;
   parser.initialize(HTTPParser.RESPONSE,
                     new HTTPClientAsyncResource('HTTPINCOMINGMESSAGE', req),
-                    req.maxHeaderSize || 0,
-                    lenient ? kLenientAll : kLenientNone);
+                    req.maxHeaderSize || 0);
   parser.socket = socket;
   parser.outgoing = req;
   req.parser = parser;
@@ -811,11 +803,15 @@ function tickOnSocket(req, socket) {
   socket.parser = parser;
   socket._httpMessage = req;
 
-  // Propagate headers limit from request object to parser
+  // Propagate headers and trailers limit from request object to parser
   if (typeof req.maxHeadersCount === 'number') {
     parser.maxHeaderPairs = req.maxHeadersCount << 1;
   }
 
+  if (typeof req.maxHeadersCount === 'number') {
+    parser.maxTrailerPairs = req.maxTrailersCount << 1;
+  }
+
   parser.joinDuplicateHeaders = req.joinDuplicateHeaders;
 
   parser.onIncoming = parserOnIncomingClient;
diff --git a/lib/_http_common.js b/lib/_http_common.js
index 2c7866d350eea2..e5c952c9454f5d 100644
--- a/lib/_http_common.js
+++ b/lib/_http_common.js
@@ -29,8 +29,6 @@ const {
 const { setImmediate } = require('timers');
 
 const { methods, HTTPParser } = internalBinding('http_parser');
-const { getOptionValue } = require('internal/options');
-const insecureHTTPParser = getOptionValue('--insecure-http-parser');
 
 const FreeList = require('internal/freelist');
 const incoming = require('_http_incoming');
@@ -45,11 +43,13 @@ const kOnMessageBegin = HTTPParser.kOnMessageBegin | 0;
 const kOnHeaders = HTTPParser.kOnHeaders | 0;
 const kOnHeadersComplete = HTTPParser.kOnHeadersComplete | 0;
 const kOnBody = HTTPParser.kOnBody | 0;
+const kOnTrailers = HTTPParser.kOnTrailers | 0;
+const kOnTrailersComplete = HTTPParser.kOnTrailersComplete | 0;
 const kOnMessageComplete = HTTPParser.kOnMessageComplete | 0;
 const kOnExecute = HTTPParser.kOnExecute | 0;
-const kOnTimeout = HTTPParser.kOnTimeout | 0;
 
 const MAX_HEADER_PAIRS = 2000;
+const MAX_TRAILER_PAIRS = 2000;
 
 // Only called in the slow case where slow means
 // that the request headers were either fragmented
@@ -134,6 +134,14 @@ function parserOnBody(b) {
   }
 }
 
+function parserOnTrailers(trailers) {
+  // Once we exceeded trailers limit - stop collecting them
+  if (this.maxTrailerPairs <= 0 ||
+    this._trailers.length < this.maxTrailerPairs) {
+    this._trailers.push(...trailers);
+  }
+}
+
 function parserOnMessageComplete() {
   const parser = this;
   const stream = parser.incoming;
@@ -141,10 +149,10 @@ function parserOnMessageComplete() {
   if (stream !== null) {
     stream.complete = true;
     // Emit any trailing headers.
-    const headers = parser._headers;
-    if (headers.length) {
-      stream._addHeaderLines(headers, headers.length);
-      parser._headers = [];
+    const trailers = parser._trailers;
+    if (trailers.length) {
+      stream._addHeaderLines(trailers, trailers.length);
+      parser._trailers = [];
       parser._url = '';
     }
 
@@ -165,6 +173,8 @@ const parsers = new FreeList('parsers', 1000, function parsersCb() {
   parser[kOnHeaders] = parserOnHeaders;
   parser[kOnHeadersComplete] = parserOnHeadersComplete;
   parser[kOnBody] = parserOnBody;
+  parser[kOnTrailers] = parserOnTrailers;
+  parser[kOnTrailersComplete] = parserOnTrailers;
   parser[kOnMessageComplete] = parserOnMessageComplete;
 
   return parser;
@@ -226,14 +236,15 @@ function checkInvalidHeaderChar(val) {
 
 function cleanParser(parser) {
   parser._headers = [];
+  parser._trailers = [];
   parser._url = '';
   parser.socket = null;
   parser.incoming = null;
   parser.outgoing = null;
   parser.maxHeaderPairs = MAX_HEADER_PAIRS;
+  parser.maxTrailerPairs = MAX_TRAILER_PAIRS;
   parser[kOnMessageBegin] = null;
   parser[kOnExecute] = null;
-  parser[kOnTimeout] = null;
   parser._consumed = false;
   parser.onIncoming = null;
   parser.joinDuplicateHeaders = null;
@@ -245,16 +256,6 @@ function prepareError(err, parser, rawPacket) {
     err.message = `Parse Error: ${err.reason}`;
 }
 
-let warnedLenient = false;
-
-function isLenient() {
-  if (insecureHTTPParser && !warnedLenient) {
-    warnedLenient = true;
-    process.emitWarning('Using insecure HTTP parsing');
-  }
-  return insecureHTTPParser;
-}
-
 module.exports = {
   _checkInvalidHeaderChar: checkInvalidHeaderChar,
   _checkIsHttpToken: checkIsHttpToken,
@@ -266,6 +267,5 @@ module.exports = {
   parsers,
   kIncomingMessage,
   HTTPParser,
-  isLenient,
   prepareError,
 };
diff --git a/lib/_http_server.js b/lib/_http_server.js
index c62ea17599512f..45b9bd217b3f16 100644
--- a/lib/_http_server.js
+++ b/lib/_http_server.js
@@ -45,7 +45,6 @@ const {
   chunkExpression,
   kIncomingMessage,
   HTTPParser,
-  isLenient,
   _checkInvalidHeaderChar: checkInvalidHeaderChar,
   prepareError,
 } = require('_http_common');
@@ -177,9 +176,6 @@ const STATUS_CODES = {
 };
 
 const kOnExecute = HTTPParser.kOnExecute | 0;
-const kOnTimeout = HTTPParser.kOnTimeout | 0;
-const kLenientAll = HTTPParser.kLenientAll | 0;
-const kLenientNone = HTTPParser.kLenientNone | 0;
 const kConnections = Symbol('http.server.connections');
 const kConnectionsCheckingInterval = Symbol('http.server.connectionsCheckingInterval');
 
@@ -436,11 +432,6 @@ function storeHTTPOptions(options) {
     validateInteger(maxHeaderSize, 'maxHeaderSize', 0);
   this.maxHeaderSize = maxHeaderSize;
 
-  const insecureHTTPParser = options.insecureHTTPParser;
-  if (insecureHTTPParser !== undefined)
-    validateBoolean(insecureHTTPParser, 'options.insecureHTTPParser');
-  this.insecureHTTPParser = insecureHTTPParser;
-
   const requestTimeout = options.requestTimeout;
   if (requestTimeout !== undefined) {
     validateInteger(requestTimeout, 'requestTimeout', 0);
@@ -663,9 +654,6 @@ function connectionListenerInternal(server, socket) {
 
   const parser = parsers.alloc();
 
-  const lenient = server.insecureHTTPParser === undefined ?
-    isLenient() : server.insecureHTTPParser;
-
   // TODO(addaleax): This doesn't play well with the
   // `async_hooks.currentResource()` proposal, see
   // https://github.com/nodejs/node/pull/21313
@@ -673,17 +661,20 @@ function connectionListenerInternal(server, socket) {
     HTTPParser.REQUEST,
     new HTTPServerAsyncResource('HTTPINCOMINGMESSAGE', socket),
     server.maxHeaderSize || 0,
-    lenient ? kLenientAll : kLenientNone,
     server[kConnections],
   );
   parser.socket = socket;
   socket.parser = parser;
 
-  // Propagate headers limit from server instance to parser
+  // Propagate headers and trailers limit from server instance to parser
   if (typeof server.maxHeadersCount === 'number') {
     parser.maxHeaderPairs = server.maxHeadersCount << 1;
   }
 
+  if (typeof server.maxTrailersCount === 'number') {
+    parser.maxTrailerPairs = server.maxTrailersCount << 1;
+  }
+
   const state = {
     onData: null,
     onEnd: null,
@@ -736,10 +727,6 @@ function connectionListenerInternal(server, socket) {
     onParserExecute.bind(undefined,
                          server, socket, parser, state);
 
-  parser[kOnTimeout] =
-    onParserTimeout.bind(undefined,
-                         server, socket);
-
   socket._paused = false;
 }
 
@@ -817,7 +804,7 @@ function socketOnData(server, socket, parser, state, d) {
   assert(!socket._paused);
   debug('SERVER socketOnData %d', d.length);
 
-  const ret = parser.execute(d);
+  const ret = parser.execute(d, d.length);
   onParserExecuteCommon(server, socket, parser, state, ret, d);
 }
 
@@ -832,17 +819,10 @@ function onParserExecute(server, socket, parser, state, ret) {
   // callback even if the data is constantly flowing into the socket.
   // See, https://github.com/nodejs/node/commit/ec2822adaad76b126b5cccdeaa1addf2376c9aa6
   socket._unrefTimer();
-  debug('SERVER socketOnParserExecute %d', ret);
+  debug('SERVER socketOnParserExecute %o', ret);
   onParserExecuteCommon(server, socket, parser, state, ret, undefined);
 }
 
-function onParserTimeout(server, socket) {
-  const serverTimeout = server.emit('timeout', socket);
-
-  if (!serverTimeout)
-    socket.destroy();
-}
-
 const noop = () => {};
 const badRequestResponse = Buffer.from(
   `HTTP/1.1 400 ${STATUS_CODES[400]}\r\n` +
@@ -880,12 +860,18 @@ function socketOnError(e) {
     warnUnclosedSocket();
   }
 
+  // Reset the parser in case the use mistakenly wants to use the socket
+  if (this.parser) {
+    this.parser.reset(true);
+  }
+
   if (!this.server.emit('clientError', e, this)) {
     // Caution must be taken to avoid corrupting the remote peer.
     // Reply an error segment if there is no in-flight `ServerResponse`,
     // or no data of the in-flight one has been written yet to this socket.
+
     if (this.writable &&
-        (!this._httpMessage || !this._httpMessage._headerSent)) {
+        (!this._httpMessage || !this._httpMessage._headerSent || this._httpMessage.finished)) {
       let response;
 
       switch (e.code) {
diff --git a/lib/http.js b/lib/http.js
index 9fce02d6e3b3ac..f16caa15e5b57b 100644
--- a/lib/http.js
+++ b/lib/http.js
@@ -50,7 +50,6 @@ let maxHeaderSize;
  * @param {{
  *   IncomingMessage?: IncomingMessage;
  *   ServerResponse?: ServerResponse;
- *   insecureHTTPParser?: boolean;
  *   maxHeaderSize?: number;
  *   requireHostHeader?: boolean;
  *   joinDuplicateHeaders?: boolean;
@@ -75,7 +74,6 @@ function createServer(opts, requestListener) {
  * @property {number} [hints] Optional dns.lookup() hints.
  * @property {string} [host] A domain name or IP address of the server to issue the request to.
  * @property {string} [hostname] Alias for host.
- * @property {boolean} [insecureHTTPParser] Use an insecure HTTP parser that accepts invalid HTTP headers when true.
  * @property {boolean} [joinDuplicateHeaders] Multiple header that joined with `,` field line values.
  * @property {string} [localAddress] Local interface to bind for network connections.
  * @property {number} [localPort] Local port to connect from.
diff --git a/lib/https.js b/lib/https.js
index ca8c49d5bef319..510b91d8fbb81c 100644
--- a/lib/https.js
+++ b/lib/https.js
@@ -122,7 +122,6 @@ Server.prototype[SymbolAsyncDispose] = async function() {
  * @param {{
  *   IncomingMessage?: IncomingMessage;
  *   ServerResponse?: ServerResponse;
- *   insecureHTTPParser?: boolean;
  *   maxHeaderSize?: number;
  *   }} [opts]
  * @param {Function} [requestListener]
@@ -391,7 +390,6 @@ function request(...args) {
  *   hints?: number;
  *   host?: string;
  *   hostname?: string;
- *   insecureHTTPParser?: boolean;
  *   joinDuplicateHeaders?: boolean;
  *   localAddress?: string;
  *   localPort?: number;
diff --git a/node.gyp b/node.gyp
index 93e4235a0f3efd..1fb5d59b6af5fb 100644
--- a/node.gyp
+++ b/node.gyp
@@ -510,7 +510,8 @@
       'include_dirs': [
         'src',
         'deps/v8/include',
-        'deps/postject'
+        'deps/postject',
+        'deps/milo'
       ],
 
       'sources': [
@@ -522,6 +523,8 @@
         'deps/uvwasi/uvwasi.gyp:uvwasi',
       ],
 
+      'libraries': ['../../deps/milo/libmilo.a'],
+
       'msvs_settings': {
         'VCLinkerTool': {
           'GenerateMapFile': 'true', # /MAP
@@ -809,6 +812,7 @@
       'include_dirs': [
         'src',
         'deps/postject',
+        'deps/milo',
         '<(SHARED_INTERMEDIATE_DIR)' # for node_natives.h
       ],
       'dependencies': [
@@ -833,6 +837,8 @@
         'common.gypi',
       ],
 
+      'libraries': ['../../deps/milo/libmilo.a'],
+
       'variables': {
         'openssl_system_ca_path%': '',
         'openssl_default_cipher_list%': '',
@@ -1062,6 +1068,7 @@
         'deps/cares/include',
         'deps/uv/include',
         'deps/uvwasi/include',
+        'deps/milo',
         'test/cctest',
       ],
 
@@ -1073,6 +1080,8 @@
 
       'sources': [ '<@(node_cctest_sources)' ],
 
+      'libraries': ['../../deps/milo/libmilo.a'],
+
       'conditions': [
         [ 'node_use_openssl=="true"', {
           'defines': [
@@ -1138,6 +1147,7 @@
         'deps/cares/include',
         'deps/uv/include',
         'deps/uvwasi/include',
+        'deps/milo',
         'test/embedding',
       ],
 
@@ -1146,6 +1156,8 @@
         'test/embedding/embedtest.cc',
       ],
 
+      'libraries': ['../../deps/milo/libmilo.a'],
+
       'conditions': [
         ['OS=="solaris"', {
           'ldflags': [ '-I<(SHARED_INTERMEDIATE_DIR)' ]
@@ -1249,6 +1261,7 @@
         'deps/cares/include',
         'deps/uv/include',
         'deps/uvwasi/include',
+        'deps/milo'
       ],
 
       'defines': [ 'NODE_WANT_INTERNALS=1' ],
@@ -1258,6 +1271,8 @@
         'tools/snapshot/node_mksnapshot.cc',
       ],
 
+      'libraries': ['../../deps/milo/libmilo.a'],
+
       'conditions': [
         ['node_write_snapshot_as_array_literals=="true"', {
           'defines': [ 'NODE_MKSNAPSHOT_USE_ARRAY_LITERALS=1' ],
diff --git a/node.gypi b/node.gypi
index 9138317c62c7cd..284a5f3174bcb6 100644
--- a/node.gypi
+++ b/node.gypi
@@ -168,11 +168,7 @@
       ],
     }],
 
-    [ 'node_shared_http_parser=="false"', {
-      'dependencies': [
-        'deps/llhttp/llhttp.gyp:llhttp'
-      ],
-    } ],
+    [ 'node_shared_http_parser=="false"', {} ],
 
     [ 'node_shared_cares=="false"', {
       'dependencies': [ 'deps/cares/cares.gyp:cares' ],
diff --git a/src/inspector_socket.cc b/src/inspector_socket.cc
index fbaa4969164d7a..67287b9ba54017 100644
--- a/src/inspector_socket.cc
+++ b/src/inspector_socket.cc
@@ -1,5 +1,5 @@
 #include "inspector_socket.h"
-#include "llhttp.h"
+#include "milo.h"
 
 #include "base64-inl.h"
 #include "util-inl.h"
@@ -485,12 +485,14 @@ class HttpHandler : public ProtocolHandler {
   explicit HttpHandler(InspectorSocket* inspector, TcpHolder::Pointer tcp)
                        : ProtocolHandler(inspector, std::move(tcp)),
                          parsing_value_(false) {
-    llhttp_init(&parser_, HTTP_REQUEST, &parser_settings);
-    llhttp_settings_init(&parser_settings);
-    parser_settings.on_header_field = OnHeaderField;
-    parser_settings.on_header_value = OnHeaderValue;
-    parser_settings.on_message_complete = OnMessageComplete;
-    parser_settings.on_url = OnPath;
+    parser_ = milo::milo_create();
+    parser_->owner = this;
+    parser_->mode = milo::REQUEST;
+    parser_->callbacks.on_header_name = OnHeaderName;
+    parser_->callbacks.on_header_value = OnHeaderValue;
+    parser_->callbacks.on_url = OnPath;
+    parser_->callbacks.on_upgrade = OnMessageComplete;
+    parser_->callbacks.on_message_complete = OnMessageComplete;
   }
 
   void AcceptUpgrade(const std::string& accept_key) override {
@@ -516,7 +518,8 @@ class HttpHandler : public ProtocolHandler {
 
   void CancelHandshake() override {
     const char HANDSHAKE_FAILED_RESPONSE[] =
-        "HTTP/1.0 400 Bad Request\r\n"
+        "HTTP/1.1 400 Bad Request\r\n"
+        "Connection: close\r\n"
         "Content-Type: text/html; charset=UTF-8\r\n\r\n"
         "WebSockets request was expected\r\n";
     WriteRaw(std::vector<char>(HANDSHAKE_FAILED_RESPONSE,
@@ -530,15 +533,11 @@ class HttpHandler : public ProtocolHandler {
   }
 
   void OnData(std::vector<char>* data) override {
-    llhttp_errno_t err;
-    err = llhttp_execute(&parser_, data->data(), data->size());
-
-    if (err == HPE_PAUSED_UPGRADE) {
-      err = HPE_OK;
-      llhttp_resume_after_upgrade(&parser_);
-    }
+    milo::milo_parse(parser_,
+                     reinterpret_cast<const unsigned char*>(data->data()),
+                     data->size());
     data->clear();
-    if (err != HPE_OK) {
+    if (parser_->error_code != milo::ERROR_NONE) {
       CancelHandshake();
     }
     // Event handling may delete *this
@@ -565,6 +564,7 @@ class HttpHandler : public ProtocolHandler {
 
  protected:
   void Shutdown() override {
+    milo::milo_destroy(parser_);
     delete this;
   }
 
@@ -575,39 +575,45 @@ class HttpHandler : public ProtocolHandler {
     handler->inspector()->SwitchProtocol(nullptr);
   }
 
-  static int OnHeaderValue(llhttp_t* parser, const char* at, size_t length) {
+  static HttpHandler* From(const milo::Parser* parser) {
+    return reinterpret_cast<HttpHandler*>(parser->owner);
+  }
+
+  static intptr_t OnHeaderValue(const milo::Parser* parser,
+                                const unsigned char* at, size_t length) {
     HttpHandler* handler = From(parser);
     handler->parsing_value_ = true;
-    handler->headers_[handler->current_header_].append(at, length);
+    handler->headers_[handler->current_header_].append(
+      reinterpret_cast<const char *>(at), length);
     return 0;
   }
 
-  static int OnHeaderField(llhttp_t* parser, const char* at, size_t length) {
+  static intptr_t OnHeaderName(const milo::Parser* parser,
+                                const unsigned char* at, size_t length) {
     HttpHandler* handler = From(parser);
     if (handler->parsing_value_) {
       handler->parsing_value_ = false;
       handler->current_header_.clear();
     }
-    handler->current_header_.append(at, length);
+    handler->current_header_.append(reinterpret_cast<const char *>(at), length);
     return 0;
   }
 
-  static int OnPath(llhttp_t* parser, const char* at, size_t length) {
+  static intptr_t OnPath(const milo::Parser* parser,
+                                const unsigned char* at, size_t length) {
     HttpHandler* handler = From(parser);
-    handler->path_.append(at, length);
+    handler->path_.append(reinterpret_cast<const char *>(at), length);
     return 0;
   }
 
-  static HttpHandler* From(llhttp_t* parser) {
-    return node::ContainerOf(&HttpHandler::parser_, parser);
-  }
-
-  static int OnMessageComplete(llhttp_t* parser) {
+  static intptr_t OnMessageComplete(const milo::Parser* parser,
+                                const unsigned char* at, size_t length) {
     // Event needs to be fired after the parser is done.
     HttpHandler* handler = From(parser);
+    bool is_upgrade = parser->is_connect || parser->has_upgrade;
     handler->events_.emplace_back(handler->path_,
-                                  parser->upgrade,
-                                  parser->method == HTTP_GET,
+                                  is_upgrade,
+                                  parser->method == milo::METHOD_GET,
                                   handler->HeaderValue("Sec-WebSocket-Key"),
                                   handler->HeaderValue("Host"));
     handler->path_ = "";
@@ -639,8 +645,7 @@ class HttpHandler : public ProtocolHandler {
   }
 
   bool parsing_value_;
-  llhttp_t parser_;
-  llhttp_settings_t parser_settings;
+  milo::Parser* parser_;
   std::vector<HttpEvent> events_;
   std::string current_header_;
   std::map<std::string, std::string> headers_;
diff --git a/src/inspector_socket_server.cc b/src/inspector_socket_server.cc
index f8f6a1b4ab6bd0..a0d0778ab66111 100644
--- a/src/inspector_socket_server.cc
+++ b/src/inspector_socket_server.cc
@@ -97,7 +97,8 @@ const char* MatchPathSegment(const char* path, const char* expected) {
 void SendHttpResponse(InspectorSocket* socket,
                       const std::string& response,
                       int code) {
-  const char HEADERS[] = "HTTP/1.0 %d OK\r\n"
+  const char HEADERS[] = "HTTP/1.1 %d OK\r\n"
+                         "Connection: close\r\n"
                          "Content-Type: application/json; charset=UTF-8\r\n"
                          "Cache-Control: no-cache\r\n"
                          "Content-Length: %zu\r\n"
diff --git a/src/node_http_parser.cc b/src/node_http_parser.cc
index 20c1bbb0bf9a06..841fc0cac91ff8 100644
--- a/src/node_http_parser.cc
+++ b/src/node_http_parser.cc
@@ -28,24 +28,11 @@
 #include "memory_tracker-inl.h"
 #include "stream_base-inl.h"
 #include "v8.h"
-#include "llhttp.h"
+#include "milo.h"
 
 #include <cstdlib>  // free()
 #include <cstring>  // strdup(), strchr()
 
-
-// This is a binding to llhttp (https://github.com/nodejs/llhttp)
-// The goal is to decouple sockets from parsing for more javascript-level
-// agility. A Buffer is read from a socket and passed to parser.execute().
-// The parser then issues callbacks with slices of the data
-//     parser.onMessageBegin
-//     parser.onPath
-//     parser.onBody
-//     ...
-// No copying is performed when slicing the buffer, only small reference
-// allocations.
-
-
 namespace node {
 namespace {  // NOLINT(build/namespaces)
 
@@ -74,32 +61,14 @@ const uint32_t kOnMessageBegin = 0;
 const uint32_t kOnHeaders = 1;
 const uint32_t kOnHeadersComplete = 2;
 const uint32_t kOnBody = 3;
-const uint32_t kOnMessageComplete = 4;
-const uint32_t kOnExecute = 5;
-const uint32_t kOnTimeout = 6;
+const uint32_t kOnTrailers = 4;
+const uint32_t kOnTrailersComplete = 5;
+const uint32_t kOnMessageComplete = 6;
+const uint32_t kOnExecute = 7;
+
 // Any more fields than this will be flushed into JS
 const size_t kMaxHeaderFieldsCount = 32;
-
-const uint32_t kLenientNone = 0;
-const uint32_t kLenientHeaders = 1 << 0;
-const uint32_t kLenientChunkedLength = 1 << 1;
-const uint32_t kLenientKeepAlive = 1 << 2;
-const uint32_t kLenientTransferEncoding = 1 << 3;
-const uint32_t kLenientVersion = 1 << 4;
-const uint32_t kLenientDataAfterClose = 1 << 5;
-const uint32_t kLenientOptionalLFAfterCR = 1 << 6;
-const uint32_t kLenientOptionalCRLFAfterChunk = 1 << 7;
-const uint32_t kLenientOptionalCRBeforeLF = 1 << 8;
-const uint32_t kLenientSpacesAfterChunkSize = 1 << 9;
-const uint32_t kLenientAll =
-    kLenientHeaders | kLenientChunkedLength | kLenientKeepAlive |
-    kLenientTransferEncoding | kLenientVersion | kLenientDataAfterClose |
-    kLenientOptionalLFAfterCR | kLenientOptionalCRLFAfterChunk |
-    kLenientOptionalCRBeforeLF | kLenientSpacesAfterChunkSize;
-
-inline bool IsOWS(char c) {
-  return c == ' ' || c == '\t';
-}
+const size_t kMaxTrailerFieldsCount = 32;
 
 class BindingData : public BaseObject {
  public:
@@ -118,82 +87,56 @@ class BindingData : public BaseObject {
 };
 
 // helper class for the Parser
-struct StringPtr {
-  StringPtr() {
-    on_heap_ = false;
-    Reset();
+struct Data {
+  Data() {
+    data_ = nullptr;
+    size_ = 0;
   }
 
-
-  ~StringPtr() {
+  ~Data() {
     Reset();
   }
 
-
-  // If str_ does not point to a heap string yet, this function makes it do
-  // so. This is called at the end of each http_parser_execute() so as not
-  // to leak references. See issue #2438 and test-http-parser-bad-ref.js.
-  void Save() {
-    if (!on_heap_ && size_ > 0) {
-      char* s = new char[size_];
-      memcpy(s, str_, size_);
-      str_ = s;
-      on_heap_ = true;
-    }
-  }
-
-
   void Reset() {
-    if (on_heap_) {
-      delete[] str_;
-      on_heap_ = false;
+    if (size_ == 0) {
+      return;
     }
 
-    str_ = nullptr;
+    free(data_);
     size_ = 0;
   }
 
-
-  void Update(const char* str, size_t size) {
-    if (str_ == nullptr) {
-      str_ = str;
-    } else if (on_heap_ || str_ + size_ != str) {
-      // Non-consecutive input, make a copy on the heap.
-      // TODO(bnoordhuis) Use slab allocation, O(n) allocs is bad.
-      char* s = new char[size_ + size];
-      memcpy(s, str_, size_);
-      memcpy(s + size_, str, size);
-
-      if (on_heap_)
-        delete[] str_;
-      else
-        on_heap_ = true;
-
-      str_ = s;
+  void Set(const unsigned char* str, size_t size) {
+    if (size_ > 0) {
+      free(data_);
     }
-    size_ += size;
-  }
 
+    data_ = UncheckedMalloc<unsigned char>(sizeof(unsigned char) * size);
+    size_ = size;
+    memcpy(data_, str, size_);
+  }
 
-  Local<String> ToString(Environment* env) const {
+  Local<String> ToString(Isolate* isolate) const {
     if (size_ != 0)
-      return OneByteString(env->isolate(), str_, size_);
+      return OneByteString(isolate, data_, size_);
     else
-      return String::Empty(env->isolate());
+      return String::Empty(isolate);
   }
 
+  Local<String> ToTrimmedString(Isolate* isolate) const {
+    if (size_ == 0)
+      return String::Empty(isolate);
 
-  // Strip trailing OWS (SPC or HTAB) from string.
-  Local<String> ToTrimmedString(Environment* env) {
-    while (size_ > 0 && IsOWS(str_[size_ - 1])) {
-      size_--;
+    size_t size = size_;
+    while (size > 0 && (data_[size - 1] == ' ' || data_[size - 1] == '\t')) {
+      size--;
     }
-    return ToString(env);
+
+    return OneByteString(isolate, data_, size);
   }
 
 
-  const char* str_;
-  bool on_heap_;
+  unsigned char* data_;
   size_t size_;
 };
 
@@ -207,14 +150,19 @@ class ConnectionsList : public BaseObject {
  public:
     static void New(const FunctionCallbackInfo<Value>& args);
 
+
     static void All(const FunctionCallbackInfo<Value>& args);
 
+
     static void Idle(const FunctionCallbackInfo<Value>& args);
 
+
     static void Active(const FunctionCallbackInfo<Value>& args);
 
+
     static void Expired(const FunctionCallbackInfo<Value>& args);
 
+
     void Push(Parser* parser) {
       all_connections_.insert(parser);
     }
@@ -261,7 +209,8 @@ class Parser : public AsyncWrap, public StreamListener {
   SET_MEMORY_INFO_NAME(Parser)
   SET_SELF_SIZE(Parser)
 
-  int on_message_begin() {
+  intptr_t on_message_start(const milo::Parser* parser,
+                            const unsigned char* data, uintptr_t length) {
     // Important: Pop from the lists BEFORE resetting the last_message_start_
     // otherwise std::set.erase will fail.
     if (connectionsList_ != nullptr) {
@@ -269,11 +218,18 @@ class Parser : public AsyncWrap, public StreamListener {
       connectionsList_->PopActive(this);
     }
 
-    num_fields_ = num_values_ = 0;
+    num_header_fields_ = num_header_values_ = 0;
+    num_trailer_fields_ = num_trailer_values_ = 0;
     headers_completed_ = false;
+    trailers_completed_ = false;
+    headers_flushed_ = false;
+    trailers_flushed_ = false;
     last_message_start_ = uv_hrtime();
+
     url_.Reset();
     status_message_.Reset();
+    error_code_.Reset();
+    error_reason_.Reset();
 
     if (connectionsList_ != nullptr) {
       connectionsList_->Push(this);
@@ -282,6 +238,7 @@ class Parser : public AsyncWrap, public StreamListener {
 
     Local<Value> cb = object()->Get(env()->context(), kOnMessageBegin)
                               .ToLocalChecked();
+
     if (cb->IsFunction()) {
       InternalCallbackScope callback_scope(
         this, InternalCallbackScope::kSkipTaskQueues);
@@ -295,80 +252,82 @@ class Parser : public AsyncWrap, public StreamListener {
     return 0;
   }
 
-
-  int on_url(const char* at, size_t length) {
+  intptr_t on_url(const milo::Parser* parser,
+                  const unsigned char* data, uintptr_t length) {
     int rv = TrackHeader(length);
     if (rv != 0) {
-      return rv;
+      return 1;
     }
 
-    url_.Update(at, length);
+    url_.Set(data, length);
+
     return 0;
   }
 
 
-  int on_status(const char* at, size_t length) {
+  intptr_t on_reason(const milo::Parser* parser,
+                     const unsigned char* data, uintptr_t length) {
     int rv = TrackHeader(length);
     if (rv != 0) {
-      return rv;
+      return 1;
     }
 
-    status_message_.Update(at, length);
+    status_message_.Set(data, length);
+
     return 0;
   }
 
 
-  int on_header_field(const char* at, size_t length) {
+  intptr_t on_header_name(const milo::Parser* parser,
+                           const unsigned char* data, uintptr_t length) {
     int rv = TrackHeader(length);
     if (rv != 0) {
       return rv;
     }
 
-    if (num_fields_ == num_values_) {
-      // start of new field name
-      num_fields_++;
-      if (num_fields_ == kMaxHeaderFieldsCount) {
-        // ran out of space - flush to javascript land
-        Flush();
-        num_fields_ = 1;
-        num_values_ = 0;
-      }
-      fields_[num_fields_ - 1].Reset();
+    CHECK_EQ(num_header_fields_, num_header_values_);
+
+    // start of new field name
+    num_header_fields_++;
+    if (num_header_fields_ == kMaxHeaderFieldsCount) {
+      // ran out of space - flush to javascript land
+      FlushHeaders();
+      num_header_fields_ = 1;
+      num_header_values_ = 0;
     }
 
-    CHECK_LT(num_fields_, kMaxHeaderFieldsCount);
-    CHECK_EQ(num_fields_, num_values_ + 1);
+    header_fields_[num_header_fields_ - 1].Set(data, length);
 
-    fields_[num_fields_ - 1].Update(at, length);
+    CHECK_LT(num_header_fields_, kMaxHeaderFieldsCount);
+    CHECK_EQ(num_header_fields_, num_header_values_ + 1);
 
     return 0;
   }
 
 
-  int on_header_value(const char* at, size_t length) {
+  intptr_t on_header_value(const milo::Parser* parser,
+                           const unsigned char* data, uintptr_t length) {
     int rv = TrackHeader(length);
     if (rv != 0) {
       return rv;
     }
 
-    if (num_values_ != num_fields_) {
-      // start of new header value
-      num_values_++;
-      values_[num_values_ - 1].Reset();
-    }
+    CHECK_NE(num_header_values_, num_header_fields_);
 
-    CHECK_LT(num_values_, arraysize(values_));
-    CHECK_EQ(num_values_, num_fields_);
+    num_header_values_++;
+    header_values_[num_header_values_ - 1].Set(data, length);
 
-    values_[num_values_ - 1].Update(at, length);
+    CHECK_LT(num_header_values_, arraysize(header_values_));
+    CHECK_EQ(num_header_values_, num_header_fields_);
 
     return 0;
   }
 
 
-  int on_headers_complete() {
+  intptr_t on_headers(const milo::Parser* parser,
+                               const unsigned char* data, uintptr_t length) {
     headers_completed_ = true;
-    header_nread_ = 0;
+    heades_nread_ = 0;
 
     // Arguments for the on-headers-complete javascript callback. This
     // list needs to be kept in sync with the actual argument list for
@@ -394,47 +353,46 @@ class Parser : public AsyncWrap, public StreamListener {
     if (!cb->IsFunction())
       return 0;
 
-    Local<Value> undefined = Undefined(env()->isolate());
+    Isolate* isolate = env()->isolate();
+
+    Local<Value> undefined = Undefined(isolate);
     for (size_t i = 0; i < arraysize(argv); i++)
       argv[i] = undefined;
 
-    if (have_flushed_) {
+    if (headers_flushed_) {
       // Slow case, flush remaining headers.
-      Flush();
+      FlushHeaders();
     } else {
       // Fast case, pass headers and URL to JS land.
       argv[A_HEADERS] = CreateHeaders();
-      if (parser_.type == HTTP_REQUEST)
-        argv[A_URL] = url_.ToString(env());
+      if (parser_->mode == milo::REQUEST)
+        argv[A_URL] = url_.ToString(isolate);
     }
 
-    num_fields_ = 0;
-    num_values_ = 0;
+    num_header_fields_ = 0;
+    num_header_values_ = 0;
 
     // METHOD
-    if (parser_.type == HTTP_REQUEST) {
+    if (parser_->mode == milo::REQUEST) {
       argv[A_METHOD] =
-          Uint32::NewFromUnsigned(env()->isolate(), parser_.method);
-    }
-
+          Uint32::NewFromUnsigned(isolate, parser_->method);
+    } else {
     // STATUS
-    if (parser_.type == HTTP_RESPONSE) {
       argv[A_STATUS_CODE] =
-          Integer::New(env()->isolate(), parser_.status_code);
-      argv[A_STATUS_MESSAGE] = status_message_.ToString(env());
+          Integer::New(isolate, parser_->status);
+      argv[A_STATUS_MESSAGE] = status_message_.ToString(isolate);
     }
 
     // VERSION
-    argv[A_VERSION_MAJOR] = Integer::New(env()->isolate(), parser_.http_major);
-    argv[A_VERSION_MINOR] = Integer::New(env()->isolate(), parser_.http_minor);
+    argv[A_VERSION_MAJOR] = Integer::New(isolate, parser_->version_major);
+    argv[A_VERSION_MINOR] = Integer::New(isolate, parser_->version_minor);
 
-    bool should_keep_alive;
-    should_keep_alive = llhttp_should_keep_alive(&parser_);
+    // KEEP ALIVE
+    argv[A_SHOULD_KEEP_ALIVE] = Boolean::New(isolate, parser_->connection !=
+                                                 milo::CONNECTION_CLOSE);
 
-    argv[A_SHOULD_KEEP_ALIVE] =
-        Boolean::New(env()->isolate(), should_keep_alive);
-
-    argv[A_UPGRADE] = Boolean::New(env()->isolate(), parser_.upgrade);
+    argv[A_UPGRADE] = Boolean::New(isolate, parser_->is_connect ||
+                                   parser_->has_upgrade);
 
     MaybeLocal<Value> head_response;
     {
@@ -445,7 +403,7 @@ class Parser : public AsyncWrap, public StreamListener {
       if (head_response.IsEmpty()) callback_scope.MarkAsFailed();
     }
 
-    int64_t val;
+    int64_t val = 0;
 
     if (head_response.IsEmpty() || !head_response.ToLocalChecked()
                                         ->IntegerValue(env()->context())
@@ -454,11 +412,16 @@ class Parser : public AsyncWrap, public StreamListener {
       return -1;
     }
 
-    return static_cast<int>(val);
+    if (val > 0) {
+      parser_->skip_body = 1;
+    }
+
+    return static_cast<intptr_t>(0);
   }
 
 
-  int on_body(const char* at, size_t length) {
+  intptr_t on_body(const milo::Parser* parser,
+                   const unsigned char* data, uintptr_t length) {
     if (length == 0)
       return 0;
 
@@ -470,21 +433,23 @@ class Parser : public AsyncWrap, public StreamListener {
     if (!cb->IsFunction())
       return 0;
 
-    Local<Value> buffer = Buffer::Copy(env, at, length).ToLocalChecked();
+    Local<Value> buffer = Buffer::Copy(env,
+                                       reinterpret_cast<const char*>(data),
+                                       length).ToLocalChecked();
 
     MaybeLocal<Value> r = MakeCallback(cb.As<Function>(), 1, &buffer);
 
     if (r.IsEmpty()) {
       got_exception_ = true;
-      llhttp_set_error_reason(&parser_, "HPE_JS_EXCEPTION:JS Exception");
-      return HPE_USER;
+      return 1;
     }
 
     return 0;
   }
 
 
-  int on_message_complete() {
+  intptr_t on_message_complete(const milo::Parser* parser,
+                               const unsigned char* data, uintptr_t length) {
     HandleScope scope(env()->isolate());
 
     // Important: Pop from the lists BEFORE resetting the last_message_start_
@@ -500,8 +465,8 @@ class Parser : public AsyncWrap, public StreamListener {
       connectionsList_->Push(this);
     }
 
-    if (num_fields_)
-      Flush();  // Flush trailing HTTP headers.
+    if (trailers_flushed_)
+      FlushTrailers();  // Flush trailing HTTP trailers.
 
     Local<Object> obj = object();
     Local<Value> cb = obj->Get(env()->context(),
@@ -520,25 +485,106 @@ class Parser : public AsyncWrap, public StreamListener {
 
     if (r.IsEmpty()) {
       got_exception_ = true;
-      return -1;
+      return 1;
     }
 
     return 0;
   }
 
-  // Reset nread for the next chunk
-  int on_chunk_header() {
-    header_nread_ = 0;
+
+  intptr_t on_trailer_name(const milo::Parser* parser,
+                            const unsigned char* data, uintptr_t length) {
+    int rv = TrackTrailer(length);
+    if (rv != 0) {
+      return rv;
+    }
+
+    // start of new field name
+    num_trailer_fields_++;
+    if (num_trailer_fields_ == kMaxTrailerFieldsCount) {
+      // ran out of space - flush to javascript land
+      FlushTrailers();
+      num_trailer_fields_ = 1;
+      num_trailer_values_ = 0;
+    }
+
+    trailer_fields_[num_trailer_fields_ - 1].Set(data, length);
+
+    CHECK_LT(num_trailer_fields_, kMaxTrailerFieldsCount);
+    CHECK_EQ(num_trailer_fields_, num_trailer_values_ + 1);
+
     return 0;
   }
 
 
-  // Reset nread for the next chunk
-  int on_chunk_complete() {
-    header_nread_ = 0;
+  intptr_t on_trailer_value(const milo::Parser* parser,
+                            const unsigned char* data, uintptr_t length) {
+    int rv = TrackTrailer(length);
+    if (rv != 0) {
+      return rv;
+    }
+
+    CHECK_NE(num_trailer_values_, num_trailer_fields_);
+
+    num_trailer_values_++;
+    trailer_values_[num_trailer_values_ - 1].Set(data, length);
+
+    CHECK_LT(num_trailer_values_, arraysize(trailer_values_));
+    CHECK_EQ(num_trailer_values_, num_trailer_fields_);
+
     return 0;
   }
 
+
+  intptr_t on_trailers(const milo::Parser* parser,
+                                const unsigned char* data, uintptr_t length) {
+    trailers_completed_ = true;
+    trailers_nread_ = 0;
+
+    Local<Value> argv[1];
+    Local<Object> obj = object();
+    Local<Value> cb = obj->Get(env()->context(),
+                               kOnTrailersComplete).ToLocalChecked();
+
+    if (!cb->IsFunction())
+      return 0;
+
+    Local<Value> undefined = Undefined(env()->isolate());
+
+    if (trailers_flushed_) {
+      // Slow case, flush remaining headers.
+      FlushTrailers();
+      argv[0] = undefined;
+    } else {
+      // Fast case, pass headers and URL to JS land.
+      argv[0] = CreateTrailers();
+    }
+
+    num_trailer_fields_ = 0;
+    num_trailer_values_ = 0;
+
+    MaybeLocal<Value> trailer_response;
+    {
+      InternalCallbackScope callback_scope(
+          this, InternalCallbackScope::kSkipTaskQueues);
+      trailer_response = cb.As<Function>()->Call(
+          env()->context(), object(), arraysize(argv), argv);
+      if (trailer_response.IsEmpty()) callback_scope.MarkAsFailed();
+    }
+
+    int64_t val;
+
+    if (trailer_response.IsEmpty() || !trailer_response.ToLocalChecked()
+                                        ->IntegerValue(env()->context())
+                                        .To(&val)) {
+      got_exception_ = true;
+      return -1;
+    }
+
+    return static_cast<int>(val);
+  }
+
+
   static void New(const FunctionCallbackInfo<Value>& args) {
     BindingData* binding_data = Realm::GetBindingData<BindingData>(args);
     new Parser(binding_data, args.This());
@@ -563,6 +609,7 @@ class Parser : public AsyncWrap, public StreamListener {
     parser->EmitDestroy();
   }
 
+
   static void Remove(const FunctionCallbackInfo<Value>& args) {
     Parser* parser;
     ASSIGN_OR_RETURN_UNWRAP(&parser, args.Holder());
@@ -573,27 +620,42 @@ class Parser : public AsyncWrap, public StreamListener {
     }
   }
 
-  void Save() {
-    url_.Save();
-    status_message_.Save();
-
-    for (size_t i = 0; i < num_fields_; i++) {
-      fields_[i].Save();
-    }
-
-    for (size_t i = 0; i < num_values_; i++) {
-      values_[i].Save();
-    }
+  void Reset(bool keep_position) {
+    milo::milo_reset(parser_, keep_position);
+    heades_nread_ = 0;
+    trailers_nread_ = 0;
+    url_.Reset();
+    status_message_.Reset();
+    error_code_.Reset();
+    error_reason_.Reset();
+    num_header_fields_ = 0;
+    num_header_values_ = 0;
+    num_trailer_fields_ = 0;
+    num_trailer_values_ = 0;
+    headers_flushed_ = false;
+    trailers_flushed_ = false;
+    got_exception_ = false;
+    headers_completed_ = false;
+    trailers_completed_ = false;
   }
 
   // var bytesParsed = parser->execute(buffer);
   static void Execute(const FunctionCallbackInfo<Value>& args) {
     Parser* parser;
+
     ASSIGN_OR_RETURN_UNWRAP(&parser, args.Holder());
+    CHECK(args[1]->IsUint32());
+
+    if (args.Length() > 2 && args[2]->IsTrue()) {
+      CHECK(args[2]->IsTrue());
+      parser->parser_->is_connect = args[2]->IsTrue() ? 1 : 0;
+    }
 
     ArrayBufferViewContents<char> buffer(args[0]);
+    size_t limit = static_cast<size_t>(args[1].As<Number>()->Value());
 
-    Local<Value> ret = parser->Execute(buffer.data(), buffer.length());
+    Local<Value> ret = parser->Execute(buffer.data(),
+                                       limit > 0 ? limit : buffer.length());
 
     if (!ret.IsEmpty())
       args.GetReturnValue().Set(ret);
@@ -615,7 +677,6 @@ class Parser : public AsyncWrap, public StreamListener {
     Environment* env = Environment::GetCurrent(args);
 
     uint64_t max_http_header_size = 0;
-    uint32_t lenient_flags = kLenientNone;
     ConnectionsList* connectionsList = nullptr;
 
     CHECK(args[0]->IsInt32());
@@ -630,33 +691,27 @@ class Parser : public AsyncWrap, public StreamListener {
       max_http_header_size = env->options()->max_http_header_size;
     }
 
-    if (args.Length() > 3) {
-      CHECK(args[3]->IsInt32());
-      lenient_flags = args[3].As<Int32>()->Value();
-    }
-
-    if (args.Length() > 4 && !args[4]->IsNullOrUndefined()) {
-      CHECK(args[4]->IsObject());
-      ASSIGN_OR_RETURN_UNWRAP(&connectionsList, args[4]);
+    if (args.Length() > 3 && !args[3]->IsNullOrUndefined()) {
+      CHECK(args[3]->IsObject());
+      ASSIGN_OR_RETURN_UNWRAP(&connectionsList, args[3]);
     }
 
-    llhttp_type_t type =
-        static_cast<llhttp_type_t>(args[0].As<Int32>()->Value());
+    intptr_t type = static_cast<intptr_t>(args[0].As<Int32>()->Value());
 
-    CHECK(type == HTTP_REQUEST || type == HTTP_RESPONSE);
+    CHECK(type == milo::REQUEST || type == milo::RESPONSE);
     Parser* parser;
     ASSIGN_OR_RETURN_UNWRAP(&parser, args.Holder());
     // Should always be called from the same context.
     CHECK_EQ(env, parser->env());
 
     AsyncWrap::ProviderType provider =
-        (type == HTTP_REQUEST ?
+        (type == milo::REQUEST ?
             AsyncWrap::PROVIDER_HTTPINCOMINGMESSAGE
             : AsyncWrap::PROVIDER_HTTPCLIENTREQUEST);
 
     parser->set_provider_type(provider);
     parser->AsyncReset(args[1].As<Object>());
-    parser->Init(type, max_http_header_size, lenient_flags);
+    parser->Init(type, max_http_header_size);
 
     if (connectionsList != nullptr) {
       parser->connectionsList_ = connectionsList;
@@ -675,6 +730,17 @@ class Parser : public AsyncWrap, public StreamListener {
     }
   }
 
+
+  static void Reset(const FunctionCallbackInfo<Value>& args) {
+    Parser* parser;
+
+    ASSIGN_OR_RETURN_UNWRAP(&parser, args.Holder());
+    CHECK(args[0]->IsBoolean());
+
+    parser->Reset(args[0].As<Boolean>()->Value());
+  }
+
+
   template <bool should_pause>
   static void Pause(const FunctionCallbackInfo<Value>& args) {
     Environment* env = Environment::GetCurrent(args);
@@ -684,9 +750,9 @@ class Parser : public AsyncWrap, public StreamListener {
     CHECK_EQ(env, parser->env());
 
     if constexpr (should_pause) {
-      llhttp_pause(&parser->parser_);
+      milo::milo_pause(parser->parser_);
     } else {
-      llhttp_resume(&parser->parser_);
+      milo::milo_resume(parser->parser_);
     }
   }
 
@@ -745,6 +811,13 @@ class Parser : public AsyncWrap, public StreamListener {
     args.GetReturnValue().Set(parser->headers_completed_);
   }
 
+  static void TrailersCompleted(const FunctionCallbackInfo<Value>& args) {
+    Parser* parser;
+    ASSIGN_OR_RETURN_UNWRAP(&parser, args.Holder());
+
+    args.GetReturnValue().Set(parser->trailers_completed_);
+  }
+
  protected:
   static const size_t kAllocBufferSize = 64 * 1024;
 
@@ -807,39 +880,38 @@ class Parser : public AsyncWrap, public StreamListener {
   }
 
 
+  template <typename P,
+            intptr_t(P::*Member)(const milo::Parser* parser,
+                                 const unsigned char* data, uintptr_t len)>
+  static intptr_t CB(const milo::Parser* parser,
+                                 const unsigned char* data, uintptr_t len) {
+    Parser* container = reinterpret_cast<Parser*>(parser->owner);
+    return (container->*Member)(parser, data, len);
+  }
+
   Local<Value> Execute(const char* data, size_t len) {
-    EscapableHandleScope scope(env()->isolate());
+    Environment* environment = env();
+    Isolate* isolate = env()->isolate();
+    EscapableHandleScope scope(isolate);
 
     current_buffer_len_ = len;
     current_buffer_data_ = data;
     got_exception_ = false;
 
-    llhttp_errno_t err;
+    uintptr_t nread = 0;
+    // Finishing can fail so track the previous error
+    u_int8_t previous_err = parser_->error_code;
 
-    if (data == nullptr) {
-      err = llhttp_finish(&parser_);
+    if (data != nullptr) {
+      nread = milo::milo_parse(
+                               parser_,
+                               reinterpret_cast<const unsigned char *>(data),
+                               len);
     } else {
-      err = llhttp_execute(&parser_, data, len);
-      Save();
+      milo::milo_finish(parser_);
     }
 
-    // Calculate bytes read and resume after Upgrade/CONNECT pause
-    size_t nread = len;
-    if (err != HPE_OK) {
-      nread = llhttp_get_error_pos(&parser_) - data;
-
-      // This isn't a real pause, just a way to stop parsing early.
-      if (err == HPE_PAUSED_UPGRADE) {
-        err = HPE_OK;
-        llhttp_resume_after_upgrade(&parser_);
-      }
-    }
-
-    // Apply pending pause
-    if (pending_pause_) {
-      pending_pause_ = false;
-      llhttp_pause(&parser_);
-    }
+    u_int8_t err = parser_->error_code;
 
     current_buffer_len_ = 0;
     current_buffer_data_ = nullptr;
@@ -848,35 +920,57 @@ class Parser : public AsyncWrap, public StreamListener {
     if (got_exception_)
       return scope.Escape(Local<Value>());
 
-    Local<Integer> nread_obj = Integer::New(env()->isolate(), nread);
+    Local<Integer> nread_obj = Integer::New(isolate, nread);
 
     // If there was a parse error in one of the callbacks
     // TODO(bnoordhuis) What if there is an error on EOF?
-    if (!parser_.upgrade && err != HPE_OK) {
-      Local<Value> e = Exception::Error(env()->parse_error_string());
-      Local<Object> obj = e->ToObject(env()->isolate()->GetCurrentContext())
+    if (err != milo::ERROR_NONE && err != previous_err) {
+      Local<Value> e = Exception::Error(environment->
+                                        parse_error_string());
+      Local<Object> obj = e->ToObject(environment->
+                                      isolate()->GetCurrentContext())
         .ToLocalChecked();
-      obj->Set(env()->context(),
-               env()->bytes_parsed_string(),
+      obj->Set(environment->context(),
+               environment->bytes_parsed_string(),
                nread_obj).Check();
-      const char* errno_reason = llhttp_get_error_reason(&parser_);
 
       Local<String> code;
       Local<String> reason;
-      if (err == HPE_USER) {
-        const char* colon = strchr(errno_reason, ':');
-        CHECK_NOT_NULL(colon);
-        code = OneByteString(env()->isolate(),
-                             errno_reason,
-                             static_cast<int>(colon - errno_reason));
-        reason = OneByteString(env()->isolate(), colon + 1);
+
+      if (error_code_.size_ > 0) {
+        code = error_code_.ToString(isolate);
+        reason = error_reason_.ToString(isolate);
       } else {
-        code = OneByteString(env()->isolate(), llhttp_errno_name(err));
-        reason = OneByteString(env()->isolate(), errno_reason);
+        if (
+          err == milo::ERROR_UNEXPECTED_TRANSFER_ENCODING ||
+          err == milo::ERROR_INVALID_CONTENT_LENGTH
+        ) {
+          code = OneByteString(environment->isolate(),
+                               "HPE_UNEXPECTED_CONTENT_LENGTH");
+        } else {
+          const char* error_code_string =
+              reinterpret_cast<const char*>(
+                  milo::milo_error_code_string(parser_));
+          size_t error_code_len = strlen(error_code_string) + 6;
+          char* error_code = Malloc(error_code_len);
+          snprintf(error_code, error_code_len, "MILO_%s", error_code_string);
+          code = OneByteString(environment->isolate(), error_code);
+          free(error_code);
+          milo::milo_free_string(
+              reinterpret_cast<const unsigned char*>(error_code_string));
+        }
+
+        const unsigned char* errno_reason =
+            milo::milo_error_description_string(parser_);
+        reason = OneByteString(environment->isolate(), errno_reason);
+        milo::milo_free_string(errno_reason);
       }
 
-      obj->Set(env()->context(), env()->code_string(), code).Check();
-      obj->Set(env()->context(), env()->reason_string(), reason).Check();
+      obj->Set(environment->context(),
+               environment->code_string(), code).Check();
+      obj->Set(environment->context(),
+               environment->reason_string(), reason).Check();
+
       return scope.Escape(e);
     }
 
@@ -884,24 +978,43 @@ class Parser : public AsyncWrap, public StreamListener {
     if (data == nullptr) {
       return scope.Escape(Local<Value>());
     }
+
     return scope.Escape(nread_obj);
   }
 
+
   Local<Array> CreateHeaders() {
+    Isolate* isolate = env()->isolate();
+
     // There could be extra entries but the max size should be fixed
     Local<Value> headers_v[kMaxHeaderFieldsCount * 2];
 
-    for (size_t i = 0; i < num_values_; ++i) {
-      headers_v[i * 2] = fields_[i].ToString(env());
-      headers_v[i * 2 + 1] = values_[i].ToTrimmedString(env());
+    for (size_t i = 0; i < num_header_values_; ++i) {
+      headers_v[i * 2] = header_fields_[i].ToString(isolate);
+      headers_v[i * 2 + 1] = header_values_[i].ToTrimmedString(isolate);
     }
 
-    return Array::New(env()->isolate(), headers_v, num_values_ * 2);
+    return Array::New(env()->isolate(), headers_v, num_header_values_ * 2);
+  }
+
+
+  Local<Array> CreateTrailers() {
+    Isolate* isolate = env()->isolate();
+
+    // There could be extra entries but the max size should be fixed
+    Local<Value> trailers_v[kMaxTrailerFieldsCount * 2];
+
+    for (size_t i = 0; i < num_trailer_values_; ++i) {
+      trailers_v[i * 2] = trailer_fields_[i].ToString(isolate);
+      trailers_v[i * 2 + 1] = trailer_values_[i].ToTrimmedString(isolate);
+    }
+
+    return Array::New(env()->isolate(), trailers_v, num_trailer_values_ * 2);
   }
 
 
   // spill headers and request path to JS land
-  void Flush() {
+  void FlushHeaders() {
     HandleScope scope(env()->isolate());
 
     Local<Object> obj = object();
@@ -912,7 +1025,7 @@ class Parser : public AsyncWrap, public StreamListener {
 
     Local<Value> argv[2] = {
       CreateHeaders(),
-      url_.ToString(env())
+      url_.ToString(env()->isolate())
     };
 
     MaybeLocal<Value> r = MakeCallback(cb.As<Function>(),
@@ -923,75 +1036,147 @@ class Parser : public AsyncWrap, public StreamListener {
       got_exception_ = true;
 
     url_.Reset();
-    have_flushed_ = true;
+    headers_flushed_ = true;
   }
 
+  // spill trailers to JS land
+  void FlushTrailers() {
+    HandleScope scope(env()->isolate());
 
-  void Init(llhttp_type_t type, uint64_t max_http_header_size,
-            uint32_t lenient_flags) {
-    llhttp_init(&parser_, type, &settings);
+    Local<Object> obj = object();
+    Local<Value> cb = obj->Get(env()->context(), kOnTrailers).ToLocalChecked();
 
-    if (lenient_flags & kLenientHeaders) {
-      llhttp_set_lenient_headers(&parser_, 1);
-    }
-    if (lenient_flags & kLenientChunkedLength) {
-      llhttp_set_lenient_chunked_length(&parser_, 1);
-    }
-    if (lenient_flags & kLenientKeepAlive) {
-      llhttp_set_lenient_keep_alive(&parser_, 1);
-    }
-    if (lenient_flags & kLenientTransferEncoding) {
-      llhttp_set_lenient_transfer_encoding(&parser_, 1);
-    }
-    if (lenient_flags & kLenientVersion) {
-      llhttp_set_lenient_version(&parser_, 1);
-    }
-    if (lenient_flags & kLenientDataAfterClose) {
-      llhttp_set_lenient_data_after_close(&parser_, 1);
-    }
-    if (lenient_flags & kLenientOptionalLFAfterCR) {
-      llhttp_set_lenient_optional_lf_after_cr(&parser_, 1);
-    }
-    if (lenient_flags & kLenientOptionalCRLFAfterChunk) {
-      llhttp_set_lenient_optional_crlf_after_chunk(&parser_, 1);
-    }
-    if (lenient_flags & kLenientOptionalCRBeforeLF) {
-      llhttp_set_lenient_optional_cr_before_lf(&parser_, 1);
-    }
-    if (lenient_flags & kLenientSpacesAfterChunkSize) {
-      llhttp_set_lenient_spaces_after_chunk_size(&parser_, 1);
-    }
+    if (!cb->IsFunction())
+      return;
+
+    Local<Value> argv[1] = {
+      CreateTrailers(),
+    };
+
+    MaybeLocal<Value> r = MakeCallback(cb.As<Function>(),
+                                       arraysize(argv),
+                                       argv);
+
+    if (r.IsEmpty())
+      got_exception_ = true;
 
-    header_nread_ = 0;
+    trailers_flushed_ = true;
+  }
+
+  void Init(intptr_t type, uint64_t max_http_header_size) {
+    parser_ = milo::milo_create();
+    heades_nread_ = 0;
+    trailers_nread_ = 0;
     url_.Reset();
     status_message_.Reset();
-    num_fields_ = 0;
-    num_values_ = 0;
-    have_flushed_ = false;
+    error_code_.Reset();
+    error_reason_.Reset();
+    num_header_fields_ = 0;
+    num_header_values_ = 0;
+    num_trailer_fields_ = 0;
+    num_trailer_values_ = 0;
+    headers_flushed_ = false;
+    trailers_flushed_ = false;
     got_exception_ = false;
     headers_completed_ = false;
+    trailers_completed_ = false;
     max_http_header_size_ = max_http_header_size;
+    max_http_trailer_size_ = max_http_header_size;
+
+    InitParser(type);
   }
 
 
+  void InitParser(intptr_t type) {
+    parser_->owner = this;
+    parser_->mode = type;
+    parser_->callbacks.on_message_start = CB<Parser, &Parser::on_message_start>;
+    parser_->callbacks.on_url = CB<Parser, &Parser::on_url>;
+    parser_->callbacks.on_reason = CB<Parser, &Parser::on_reason>;
+    parser_->callbacks.on_header_name = CB<Parser, &Parser::on_header_name>;
+    parser_->callbacks.on_header_value = CB<Parser, &Parser::on_header_value>;
+    parser_->callbacks.on_headers = CB<Parser, &Parser::on_headers>;
+    parser_->callbacks.on_data = CB<Parser, &Parser::on_body>;
+    parser_->callbacks.on_trailer_name = CB<Parser, &Parser::on_trailer_name>;
+    parser_->callbacks.on_trailer_value = CB<Parser, &Parser::on_trailer_value>;
+    parser_->callbacks.on_trailers = CB<Parser, &Parser::on_trailers>;
+    parser_->callbacks.on_message_complete =
+        CB<Parser, &Parser::on_message_complete>;
+
+    // Important - Do not remove the code below, only comment it out.
+    // This enables to track Milo state change when using its debug version.
+    // parser_->callbacks.after_state_change =
+    //                              [](milo::Parser* p,
+    //                                 const unsigned char* data,
+    //                                 uintptr_t length) -> intptr_t {
+    //   const unsigned char* state = milo::get_state_string(p);
+    //   intptr_t type = p->message_type;
+
+    //   printf(
+    //     "%p[%s @ %lu] %s\n",
+    //     reinterpret_cast<void*>(p),
+    //     (type == milo::REQUEST
+    //        ? "REQ"
+    //        : (type == milo::RESPONSE ? "RES" : "---")),
+    //     p->position,
+    //     state
+    //   );
+
+    //   milo::milo_free_string(state);
+
+    //   return 0;
+    // };
+    // parser_->callbacks.on_error =
+    //                              [](milo::Parser* p,
+    //                                 const unsigned char* data,
+    //                                 uintptr_t length) -> intptr_t {
+    //   const unsigned char* error_code_string =
+    //       milo::get_error_code_string(p);
+    //   const unsigned char* error_description_string =
+    //       milo::get_error_description_string(p);
+    //   intptr_t type = p->message_type;
+
+    //   printf(
+    //     "%p[%s @ %lu] ERROR %s (%u): %s\n",
+    //     reinterpret_cast<void*>(p),
+    //     (type == milo::REQUEST
+    //        ? "REQ"
+    //        : (type == milo::RESPONSE ? "RES" : "---")),
+    //     p->position,
+    //     error_code_string,
+    //     static_cast<unsigned int>(p->error_code),
+    //     error_description_string
+    //   );
+
+    //   milo::milo_free_string(error_code_string);
+    //   milo::milo_free_string(error_description_string);
+
+    //   return 0;
+    // };
+  }
+
   int TrackHeader(size_t len) {
-    header_nread_ += len;
-    if (header_nread_ >= max_http_header_size_) {
-      llhttp_set_error_reason(&parser_, "HPE_HEADER_OVERFLOW:Header overflow");
-      return HPE_USER;
+    heades_nread_ += len;
+    if (heades_nread_ >= max_http_header_size_) {
+      error_code_.Set(
+          reinterpret_cast<const unsigned char*>("HPE_HEADER_OVERFLOW"), 19);
+      error_reason_.Set(
+          reinterpret_cast<const unsigned char*>("Header overflow"), 15);
+      return 1;
     }
     return 0;
   }
 
-
-  int MaybePause() {
-    if (!pending_pause_) {
-      return 0;
+  int TrackTrailer(size_t len) {
+    trailers_nread_ += len;
+    if (trailers_nread_ >= max_http_trailer_size_) {
+      error_code_.Set(
+          reinterpret_cast<const unsigned char*>("HPE_HEADER_OVERFLOW"), 19);
+      error_reason_.Set(
+          reinterpret_cast<const unsigned char*>("Header overflow"), 15);
+      return 1;
     }
-
-    pending_pause_ = false;
-    llhttp_set_error_reason(&parser_, "Paused in callback");
-    return HPE_PAUSED;
+    return 0;
   }
 
 
@@ -1003,45 +1188,34 @@ class Parser : public AsyncWrap, public StreamListener {
   }
 
 
-  llhttp_t parser_;
-  StringPtr fields_[kMaxHeaderFieldsCount];  // header fields
-  StringPtr values_[kMaxHeaderFieldsCount];  // header values
-  StringPtr url_;
-  StringPtr status_message_;
-  size_t num_fields_;
-  size_t num_values_;
-  bool have_flushed_;
+  milo::Parser* parser_;
+  Data header_fields_[kMaxHeaderFieldsCount];  // header fields
+  Data header_values_[kMaxHeaderFieldsCount];  // header values
+  Data trailer_fields_[kMaxTrailerFieldsCount];  // trailer fields
+  Data trailer_values_[kMaxTrailerFieldsCount];  // trailer values
+  Data url_;
+  Data status_message_;
+  Data error_code_;
+  Data error_reason_;
+  size_t num_header_fields_;
+  size_t num_header_values_;
+  size_t num_trailer_fields_;
+  size_t num_trailer_values_;
+  bool headers_flushed_;
+  bool trailers_flushed_;
   bool got_exception_;
   size_t current_buffer_len_;
   const char* current_buffer_data_;
   bool headers_completed_ = false;
-  bool pending_pause_ = false;
-  uint64_t header_nread_ = 0;
+  bool trailers_completed_ = false;
+  uint64_t heades_nread_ = 0;
+  uint64_t trailers_nread_ = 0;
   uint64_t max_http_header_size_;
+  uint64_t max_http_trailer_size_;
   uint64_t last_message_start_;
   ConnectionsList* connectionsList_;
 
   BaseObjectPtr<BindingData> binding_data_;
-
-  // These are helper functions for filling `http_parser_settings`, which turn
-  // a member function of Parser into a C-style HTTP parser callback.
-  template <typename Parser, Parser> struct Proxy;
-  template <typename Parser, typename ...Args, int (Parser::*Member)(Args...)>
-  struct Proxy<int (Parser::*)(Args...), Member> {
-    static int Raw(llhttp_t* p, Args ... args) {
-      Parser* parser = ContainerOf(&Parser::parser_, p);
-      int rv = (parser->*Member)(std::forward<Args>(args)...);
-      if (rv == 0) {
-        rv = parser->MaybePause();
-      }
-      return rv;
-    }
-  };
-
-  typedef int (Parser::*Call)();
-  typedef int (Parser::*DataCall)(const char* at, size_t length);
-
-  static const llhttp_settings_t settings;
 };
 
 bool ParserComparator::operator()(const Parser* lhs, const Parser* rhs) const {
@@ -1181,52 +1355,6 @@ void ConnectionsList::Expired(const FunctionCallbackInfo<Value>& args) {
       Array::New(isolate, result.data(), result.size()));
 }
 
-const llhttp_settings_t Parser::settings = {
-    Proxy<Call, &Parser::on_message_begin>::Raw,
-    Proxy<DataCall, &Parser::on_url>::Raw,
-    Proxy<DataCall, &Parser::on_status>::Raw,
-
-    // on_method
-    nullptr,
-    // on_version
-    nullptr,
-
-    Proxy<DataCall, &Parser::on_header_field>::Raw,
-    Proxy<DataCall, &Parser::on_header_value>::Raw,
-
-    // on_chunk_extension_name
-    nullptr,
-    // on_chunk_extension_value
-    nullptr,
-
-    Proxy<Call, &Parser::on_headers_complete>::Raw,
-    Proxy<DataCall, &Parser::on_body>::Raw,
-    Proxy<Call, &Parser::on_message_complete>::Raw,
-
-    // on_url_complete
-    nullptr,
-    // on_status_complete
-    nullptr,
-    // on_method_complete
-    nullptr,
-    // on_version_complete
-    nullptr,
-    // on_header_field_complete
-    nullptr,
-    // on_header_value_complete
-    nullptr,
-    // on_chunk_extension_name_complete
-    nullptr,
-    // on_chunk_extension_value_complete
-    nullptr,
-
-    Proxy<Call, &Parser::on_chunk_header>::Raw,
-    Proxy<Call, &Parser::on_chunk_complete>::Raw,
-
-    // on_reset,
-    nullptr,
-};
-
 void InitializeHttpParser(Local<Object> target,
                           Local<Value> unused,
                           Local<Context> context,
@@ -1241,9 +1369,9 @@ void InitializeHttpParser(Local<Object> target,
   t->InstanceTemplate()->SetInternalFieldCount(Parser::kInternalFieldCount);
 
   t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "REQUEST"),
-         Integer::New(env->isolate(), HTTP_REQUEST));
+         Integer::New(env->isolate(), milo::REQUEST));
   t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "RESPONSE"),
-         Integer::New(env->isolate(), HTTP_RESPONSE));
+         Integer::New(env->isolate(), milo::RESPONSE));
   t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kOnMessageBegin"),
          Integer::NewFromUnsigned(env->isolate(), kOnMessageBegin));
   t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kOnHeaders"),
@@ -1252,46 +1380,20 @@ void InitializeHttpParser(Local<Object> target,
          Integer::NewFromUnsigned(env->isolate(), kOnHeadersComplete));
   t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kOnBody"),
          Integer::NewFromUnsigned(env->isolate(), kOnBody));
+  t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kOnTrailers"),
+         Integer::NewFromUnsigned(env->isolate(), kOnTrailers));
+  t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kOnTrailersComplete"),
+         Integer::NewFromUnsigned(env->isolate(), kOnTrailersComplete));
   t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kOnMessageComplete"),
          Integer::NewFromUnsigned(env->isolate(), kOnMessageComplete));
   t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kOnExecute"),
          Integer::NewFromUnsigned(env->isolate(), kOnExecute));
-  t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kOnTimeout"),
-         Integer::NewFromUnsigned(env->isolate(), kOnTimeout));
-
-  t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kLenientNone"),
-         Integer::NewFromUnsigned(env->isolate(), kLenientNone));
-  t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kLenientHeaders"),
-         Integer::NewFromUnsigned(env->isolate(), kLenientHeaders));
-  t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kLenientChunkedLength"),
-         Integer::NewFromUnsigned(env->isolate(), kLenientChunkedLength));
-  t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kLenientKeepAlive"),
-         Integer::NewFromUnsigned(env->isolate(), kLenientKeepAlive));
-  t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kLenientTransferEncoding"),
-         Integer::NewFromUnsigned(env->isolate(), kLenientTransferEncoding));
-  t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kLenientVersion"),
-         Integer::NewFromUnsigned(env->isolate(), kLenientVersion));
-  t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kLenientDataAfterClose"),
-         Integer::NewFromUnsigned(env->isolate(), kLenientDataAfterClose));
-  t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kLenientOptionalLFAfterCR"),
-         Integer::NewFromUnsigned(env->isolate(), kLenientOptionalLFAfterCR));
-  t->Set(
-      FIXED_ONE_BYTE_STRING(env->isolate(), "kLenientOptionalCRLFAfterChunk"),
-      Integer::NewFromUnsigned(env->isolate(), kLenientOptionalCRLFAfterChunk));
-  t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kLenientOptionalCRBeforeLF"),
-         Integer::NewFromUnsigned(env->isolate(), kLenientOptionalCRBeforeLF));
-  t->Set(
-      FIXED_ONE_BYTE_STRING(env->isolate(), "kLenientSpacesAfterChunkSize"),
-      Integer::NewFromUnsigned(env->isolate(), kLenientSpacesAfterChunkSize));
-
-  t->Set(FIXED_ONE_BYTE_STRING(env->isolate(), "kLenientAll"),
-         Integer::NewFromUnsigned(env->isolate(), kLenientAll));
 
   Local<Array> methods = Array::New(env->isolate());
 #define V(num, name, string)                                                  \
     methods->Set(env->context(),                                              \
         num, FIXED_ONE_BYTE_STRING(env->isolate(), #string)).Check();
-  HTTP_METHOD_MAP(V)
+  MILO_METHODS_MAP(V)
 #undef V
   target->Set(env->context(),
               FIXED_ONE_BYTE_STRING(env->isolate(), "methods"),
@@ -1306,11 +1408,13 @@ void InitializeHttpParser(Local<Object> target,
   SetProtoMethod(isolate, t, "initialize", Parser::Initialize);
   SetProtoMethod(isolate, t, "pause", Parser::Pause<true>);
   SetProtoMethod(isolate, t, "resume", Parser::Pause<false>);
+  SetProtoMethod(isolate, t, "reset", Parser::Reset);
   SetProtoMethod(isolate, t, "consume", Parser::Consume);
   SetProtoMethod(isolate, t, "unconsume", Parser::Unconsume);
   SetProtoMethod(isolate, t, "getCurrentBuffer", Parser::GetCurrentBuffer);
   SetProtoMethod(isolate, t, "duration", Parser::Duration);
   SetProtoMethod(isolate, t, "headersCompleted", Parser::HeadersCompleted);
+  SetProtoMethod(isolate, t, "trailersCompleted", Parser::TrailersCompleted);
 
   SetConstructorFunction(context, target, "HTTPParser", t);
 
diff --git a/src/node_metadata.cc b/src/node_metadata.cc
index 112d6a9b7fb56f..405bb34f5b376d 100644
--- a/src/node_metadata.cc
+++ b/src/node_metadata.cc
@@ -5,7 +5,7 @@
 #include "base64_version.h"
 #include "brotli/encode.h"
 #include "cjs_module_lexer_version.h"
-#include "llhttp.h"
+#include "milo.h"
 #include "nghttp2/nghttp2ver.h"
 #include "node.h"
 #include "simdutf.h"
@@ -83,13 +83,7 @@ Metadata::Versions::Versions() {
   modules = NODE_STRINGIFY(NODE_MODULE_VERSION);
   nghttp2 = NGHTTP2_VERSION;
   napi = NODE_STRINGIFY(NODE_API_SUPPORTED_VERSION_MAX);
-  llhttp =
-      NODE_STRINGIFY(LLHTTP_VERSION_MAJOR)
-      "."
-      NODE_STRINGIFY(LLHTTP_VERSION_MINOR)
-      "."
-      NODE_STRINGIFY(LLHTTP_VERSION_PATCH);
-
+  milo = MILO_VERSION;
   brotli =
     std::to_string(BrotliEncoderVersion() >> 24) +
     "." +
diff --git a/src/node_metadata.h b/src/node_metadata.h
index cf051585e779e2..8b41aba3598d53 100644
--- a/src/node_metadata.h
+++ b/src/node_metadata.h
@@ -43,7 +43,7 @@ namespace node {
   V(modules)                                                                   \
   V(nghttp2)                                                                   \
   V(napi)                                                                      \
-  V(llhttp)                                                                    \
+  V(milo)                                                                      \
   V(uvwasi)                                                                    \
   V(acorn)                                                                     \
   V(simdutf)                                                                   \
diff --git a/src/node_options.cc b/src/node_options.cc
index fc9940b64c5c33..a8484d0c6886a2 100644
--- a/src/node_options.cc
+++ b/src/node_options.cc
@@ -474,10 +474,6 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
             &EnvironmentOptions::heap_snapshot_near_heap_limit,
             kAllowedInEnvvar);
   AddOption("--http-parser", "", NoOp{}, kAllowedInEnvvar);
-  AddOption("--insecure-http-parser",
-            "use an insecure HTTP parser that accepts invalid HTTP headers",
-            &EnvironmentOptions::insecure_http_parser,
-            kAllowedInEnvvar);
   AddOption("--input-type",
             "set module type for string input",
             &EnvironmentOptions::input_type,
diff --git a/test/async-hooks/test-httpparser.request.js b/test/async-hooks/test-httpparser.request.js
index 40c01bc8177d6e..cdb0396e0aed70 100644
--- a/test/async-hooks/test-httpparser.request.js
+++ b/test/async-hooks/test-httpparser.request.js
@@ -30,7 +30,7 @@ assert.strictEqual(typeof httpparser.triggerAsyncId, 'number');
 checkInvocations(httpparser, { init: 1 }, 'when created new Httphttpparser');
 
 parser[kOnHeadersComplete] = common.mustCall(onheadersComplete);
-parser.execute(request, 0, request.length);
+parser.execute(request, request.length);
 
 function onheadersComplete() {
   checkInvocations(httpparser, { init: 1, before: 1 },
diff --git a/test/async-hooks/test-httpparser.response.js b/test/async-hooks/test-httpparser.response.js
index 64f0893c5a9aa8..62021bc083d12e 100644
--- a/test/async-hooks/test-httpparser.response.js
+++ b/test/async-hooks/test-httpparser.response.js
@@ -36,7 +36,7 @@ checkInvocations(httpparser, { init: 1 }, 'when created new Httphttpparser');
 
 parser[kOnHeadersComplete] = common.mustCall(onheadersComplete);
 parser[kOnBody] = common.mustCall(onbody);
-parser.execute(request, 0, request.length);
+parser.execute(request, request.length);
 
 function onheadersComplete() {
   checkInvocations(httpparser, { init: 1, before: 1 },
diff --git a/test/cctest/test_inspector_socket.cc b/test/cctest/test_inspector_socket.cc
index 2efa0d55d748f1..b52c36680da577 100644
--- a/test/cctest/test_inspector_socket.cc
+++ b/test/cctest/test_inspector_socket.cc
@@ -334,7 +334,8 @@ static void expect_handshake() {
 
 static void expect_handshake_failure() {
   const char UPGRADE_RESPONSE[] =
-      "HTTP/1.0 400 Bad Request\r\n"
+      "HTTP/1.1 400 Bad Request\r\n"
+      "Connection: close\r\n"
       "Content-Type: text/html; charset=UTF-8\r\n\r\n"
       "WebSockets request was expected\r\n";
   expect_on_client(UPGRADE_RESPONSE, sizeof(UPGRADE_RESPONSE) - 1);
diff --git a/test/cctest/test_inspector_socket_server.cc b/test/cctest/test_inspector_socket_server.cc
index 451fbbd6acfc4d..5b04fcd4c3b72c 100644
--- a/test/cctest/test_inspector_socket_server.cc
+++ b/test/cctest/test_inspector_socket_server.cc
@@ -156,7 +156,8 @@ class SocketWrapper {
   void TestHttpRequest(const std::string& path,
                        const std::string& expected_reply) {
     std::ostringstream expectations;
-    expectations << "HTTP/1.0 200 OK\r\n"
+    expectations << "HTTP/1.1 200 OK\r\n"
+                    "Connection: close\r\n"
                     "Content-Type: application/json; charset=UTF-8\r\n"
                     "Cache-Control: no-cache\r\n"
                     "Content-Length: ";
@@ -415,7 +416,7 @@ TEST_F(InspectorSocketServerTest, InspectorSessions) {
   SocketWrapper bogus_target_socket(&loop);
   bogus_target_socket.Connect(HOST, server.port());
   bogus_target_socket.Write(WsHandshakeRequest("bogus_target"));
-  bogus_target_socket.Expect("HTTP/1.0 400 Bad Request");
+  bogus_target_socket.Expect("HTTP/1.1 400 Bad Request");
   bogus_target_socket.ExpectEOF();
   EXPECT_EQ(1, server.connected);
   EXPECT_EQ(1, server.disconnected);
@@ -480,7 +481,7 @@ TEST_F(InspectorSocketServerTest, ServerWithoutTargets) {
   SocketWrapper socket(&loop);
   socket.Connect(HOST, server.port());
   socket.Write(WsHandshakeRequest("any target id"));
-  socket.Expect("HTTP/1.0 400 Bad Request");
+  socket.Expect("HTTP/1.1 400 Bad Request");
   socket.ExpectEOF();
   server->Stop();
   server->TerminateConnections();
diff --git a/test/parallel/test-domain-multi.js b/test/parallel/test-domain-multi.js
index 27cdff7b1c92f1..8821ac480f3d63 100644
--- a/test/parallel/test-domain-multi.js
+++ b/test/parallel/test-domain-multi.js
@@ -47,8 +47,9 @@ const server = http.createServer((req, res) => {
   b.on('error', common.mustCall((er) => {
     if (res) {
       // Introduce an error on the client by writing unexpected data.
-      // The client is now expecting a chunk header so any letter will have the parser throw an error.
-      res.socket.write('H');
+      // The client is now expecting a chunk header so let's send it
+      // an invalid number to have the parser throw an error.
+      res.socket.write('H\r\n');
     }
     // res.writeHead(500), res.destroy, etc.
     server.close();
diff --git a/test/parallel/test-http-1.0-keep-alive.js b/test/parallel/test-http-1.1-keep-alive.js
similarity index 57%
rename from test/parallel/test-http-1.0-keep-alive.js
rename to test/parallel/test-http-1.1-keep-alive.js
index 6d117035a5c727..a1703edb8cb09f 100644
--- a/test/parallel/test-http-1.0-keep-alive.js
+++ b/test/parallel/test-http-1.1-keep-alive.js
@@ -24,84 +24,96 @@ require('../common');
 const http = require('http');
 const net = require('net');
 
-// Check that our HTTP server correctly handles HTTP/1.0 keep-alive requests.
+// Check that our HTTP server correctly handles HTTP/1.1 keep-alive requests.
 check([{
   name: 'keep-alive, no TE header',
   requests: [{
     expectClose: true,
-    data: 'POST / HTTP/1.0\r\n' +
-          'Connection: keep-alive\r\n' +
+    data: 'POST / HTTP/1.1\r\n' +
+          'Host: 127.0.0.1:1337\r\n' +
+          'Connection: close\r\n' +
           '\r\n'
   }, {
     expectClose: true,
-    data: 'POST / HTTP/1.0\r\n' +
-          'Connection: keep-alive\r\n' +
+    data: 'POST / HTTP/1.1\r\n' +
+          'Host: 127.0.0.1:1337\r\n' +
+          'Connection: close\r\n' +
           '\r\n'
   }],
   responses: [{
-    headers: { 'Connection': 'keep-alive' },
+    headers: { 'Connection': 'close' },
     chunks: ['OK']
   }, {
     chunks: []
   }]
-}, {
-  name: 'keep-alive, with TE: chunked',
-  requests: [{
-    expectClose: false,
-    data: 'POST / HTTP/1.0\r\n' +
+},
+       {
+         name: 'keep-alive, with TE: chunked',
+         requests: [{
+           expectClose: false,
+           data: 'POST / HTTP/1.1\r\n' +
+          'Host: 127.0.0.1:1337\r\n' +
           'Connection: keep-alive\r\n' +
           'TE: chunked\r\n' +
           '\r\n'
-  }, {
-    expectClose: true,
-    data: 'POST / HTTP/1.0\r\n' +
+         }, {
+           expectClose: true,
+           data: 'POST / HTTP/1.1\r\n' +
+          'Connection: close\r\n' +
+          'Host: 127.0.0.1:1337\r\n' +
           '\r\n'
-  }],
-  responses: [{
-    headers: { 'Connection': 'keep-alive' },
-    chunks: ['OK']
-  }, {
-    chunks: []
-  }]
-}, {
-  name: 'keep-alive, with Transfer-Encoding: chunked',
-  requests: [{
-    expectClose: false,
-    data: 'POST / HTTP/1.0\r\n' +
+         }],
+         responses: [{
+           headers: { 'Connection': 'keep-alive' },
+           chunks: ['OK']
+         }, {
+           chunks: []
+         }]
+       }, {
+         name: 'keep-alive, with Transfer-Encoding: chunked',
+         requests: [{
+           expectClose: false,
+           data: 'POST / HTTP/1.1\r\n' +
+          'Host: 127.0.0.1:1337\r\n' +
           'Connection: keep-alive\r\n' +
           '\r\n'
-  }, {
-    expectClose: true,
-    data: 'POST / HTTP/1.0\r\n' +
+         }, {
+           expectClose: true,
+           data: 'POST / HTTP/1.1\r\n' +
+          'Connection: close\r\n' +
+          'Host: 127.0.0.1:1337\r\n' +
           '\r\n'
-  }],
-  responses: [{
-    headers: { 'Connection': 'keep-alive',
-               'Transfer-Encoding': 'chunked' },
-    chunks: ['OK']
-  }, {
-    chunks: []
-  }]
-}, {
-  name: 'keep-alive, with Content-Length',
-  requests: [{
-    expectClose: false,
-    data: 'POST / HTTP/1.0\r\n' +
+         }],
+         responses: [{
+           headers: { 'Connection': 'keep-alive',
+                      'Transfer-Encoding': 'chunked' },
+           chunks: ['OK']
+         }, {
+           chunks: []
+         }]
+       }, {
+         name: 'keep-alive, with Content-Length',
+         requests: [{
+           expectClose: false,
+           data: 'POST / HTTP/1.1\r\n' +
+          'Host: 127.0.0.1:1337\r\n' +
           'Connection: keep-alive\r\n' +
           '\r\n'
-  }, {
-    expectClose: true,
-    data: 'POST / HTTP/1.0\r\n' +
+         }, {
+           expectClose: true,
+           data: 'POST / HTTP/1.1\r\n' +
+          'Connection: close\r\n' +
+          'Host: 127.0.0.1:1337\r\n' +
           '\r\n'
-  }],
-  responses: [{
-    headers: { 'Connection': 'keep-alive',
-               'Content-Length': '2' },
-    chunks: ['OK']
-  }, {
-    chunks: []
-  }]
-}]);
+         }],
+         responses: [{
+           headers: { 'Connection': 'keep-alive',
+                      'Content-Length': '2' },
+           chunks: ['OK']
+         }, {
+           chunks: []
+         }]
+       }]);
 
 function check(tests) {
   const test = tests[0];
@@ -118,7 +130,7 @@ function check(tests) {
   function serverHandler(req, res) {
     if (current + 1 === test.responses.length) this.close();
     const ctx = test.responses[current];
-    console.error('<  SERVER SENDING RESPONSE', ctx);
+    // console.error('<  SERVER SENDING RESPONSE', ctx);
     res.writeHead(200, ctx.headers);
     ctx.chunks.slice(0, -1).forEach(function(chunk) { res.write(chunk); });
     res.end(ctx.chunks[ctx.chunks.length - 1]);
@@ -131,19 +143,19 @@ function check(tests) {
 
     function connected() {
       const ctx = test.requests[current];
-      console.error(' > CLIENT SENDING REQUEST', ctx);
+      // console.error(' > CLIENT SENDING REQUEST', ctx);
       conn.setEncoding('utf8');
       conn.write(ctx.data);
 
       function onclose() {
-        console.error(' > CLIENT CLOSE');
+        // console.error(' > CLIENT CLOSE');
         if (!ctx.expectClose) throw new Error('unexpected close');
         client();
       }
       conn.on('close', onclose);
 
       function ondata(s) {
-        console.error(' > CLIENT ONDATA %j %j', s.length, s.toString());
+        // console.error(' > CLIENT ONDATA %j %j', s.length, s.toString());
         current++;
         if (ctx.expectClose) return;
         conn.removeListener('close', onclose);
diff --git a/test/parallel/test-http-1.0.js b/test/parallel/test-http-1.1.js
similarity index 71%
rename from test/parallel/test-http-1.0.js
rename to test/parallel/test-http-1.1.js
index 134a5bb9853102..e0b5d957e3861d 100644
--- a/test/parallel/test-http-1.0.js
+++ b/test/parallel/test-http-1.1.js
@@ -25,7 +25,6 @@ const assert = require('assert');
 const net = require('net');
 const http = require('http');
 
-const body = 'hello world\n';
 
 function test(handler, request_generator, response_validator) {
   const server = http.createServer(handler);
@@ -58,61 +57,20 @@ function test(handler, request_generator, response_validator) {
 
 {
   function handler(req, res) {
-    assert.strictEqual(req.httpVersion, '1.0');
+    assert.strictEqual(req.httpVersion, '1.1');
     assert.strictEqual(req.httpVersionMajor, 1);
-    assert.strictEqual(req.httpVersionMinor, 0);
+    assert.strictEqual(req.httpVersionMinor, 1);
     res.writeHead(200, { 'Content-Type': 'text/plain' });
-    res.end(body);
+    res.end('hello world');
   }
 
   function request_generator() {
-    return 'GET / HTTP/1.0\r\n\r\n';
+    return 'GET / HTTP/1.1\r\nConnection: close\r\nHost: 127.0.0.1:1337\r\n\r\n';
   }
 
   function response_validator(server_response, client_got_eof, timed_out) {
     const m = server_response.split('\r\n\r\n');
-    assert.strictEqual(m[1], body);
-    assert.strictEqual(client_got_eof, true);
-    assert.strictEqual(timed_out, false);
-  }
-
-  test(handler, request_generator, response_validator);
-}
-
-//
-// Don't send HTTP/1.1 status lines to HTTP/1.0 clients.
-//
-// https://github.com/joyent/node/issues/1234
-//
-{
-  function handler(req, res) {
-    assert.strictEqual(req.httpVersion, '1.0');
-    assert.strictEqual(req.httpVersionMajor, 1);
-    assert.strictEqual(req.httpVersionMinor, 0);
-    res.sendDate = false;
-    res.writeHead(200, { 'Content-Type': 'text/plain' });
-    res.write('Hello, '); res._send('');
-    res.write('world!'); res._send('');
-    res.end();
-  }
-
-  function request_generator() {
-    return ('GET / HTTP/1.0\r\n' +
-        'User-Agent: curl/7.19.7 (x86_64-pc-linux-gnu) libcurl/7.19.7 ' +
-        'OpenSSL/0.9.8k zlib/1.2.3.3 libidn/1.15\r\n' +
-        'Host: 127.0.0.1:1337\r\n' +
-        'Accept: */*\r\n' +
-        '\r\n');
-  }
-
-  function response_validator(server_response, client_got_eof, timed_out) {
-    const expected_response = 'HTTP/1.1 200 OK\r\n' +
-                              'Content-Type: text/plain\r\n' +
-                              'Connection: close\r\n' +
-                              '\r\n' +
-                              'Hello, world!';
-
-    assert.strictEqual(server_response, expected_response);
+    assert.strictEqual(m[1], 'b\r\nhello world\r\n0');
     assert.strictEqual(client_got_eof, true);
     assert.strictEqual(timed_out, false);
   }
diff --git a/test/parallel/test-http-blank-header.js b/test/parallel/test-http-blank-header.js
index 696b16f4995b57..21073b13d40e95 100644
--- a/test/parallel/test-http-blank-header.js
+++ b/test/parallel/test-http-blank-header.js
@@ -25,15 +25,7 @@ const assert = require('assert');
 const http = require('http');
 const net = require('net');
 
-const server = http.createServer(common.mustCall((req, res) => {
-  assert.strictEqual(req.method, 'GET');
-  assert.strictEqual(req.url, '/blah');
-  assert.deepStrictEqual(req.headers, {
-    host: 'example.org:443',
-    origin: 'http://example.org',
-    cookie: ''
-  });
-}));
+const server = http.createServer(common.mustNotCall());
 
 
 server.listen(0, common.mustCall(() => {
diff --git a/test/parallel/test-http-client-error-rawbytes.js b/test/parallel/test-http-client-error-rawbytes.js
index 0c8efb8c9767ab..76df96fb077d65 100644
--- a/test/parallel/test-http-client-error-rawbytes.js
+++ b/test/parallel/test-http-client-error-rawbytes.js
@@ -19,11 +19,11 @@ server.listen(0, common.mustCall(() => {
   const req = http.get(`http://localhost:${server.address().port}/`);
   req.end();
   req.on('error', common.mustCall((err) => {
-    const reason = "Transfer-Encoding can't be present with Content-Length";
+    const reason = 'Unexpected Transfer-Encoding header when Content-Length header is present';
     assert.strictEqual(err.message, `Parse Error: ${reason}`);
     assert(err.bytesParsed < response.length);
     assert(err.bytesParsed >= response.indexOf('Transfer-Encoding'));
-    assert.strictEqual(err.code, 'HPE_INVALID_TRANSFER_ENCODING');
+    assert.strictEqual(err.code, 'HPE_UNEXPECTED_CONTENT_LENGTH');
     assert.strictEqual(err.reason, reason);
     assert.deepStrictEqual(err.rawPacket, response);
 
diff --git a/test/parallel/test-http-client-parse-error.js b/test/parallel/test-http-client-parse-error.js
index 5d0ad4b1463ed5..fd6445e7c2b760 100644
--- a/test/parallel/test-http-client-parse-error.js
+++ b/test/parallel/test-http-client-parse-error.js
@@ -46,8 +46,8 @@ server.listen(0, common.mustCall(() => {
       assert.strictEqual(req.socket.listenerCount('data'), 0);
       assert.strictEqual(req.socket.listenerCount('end'), 1);
       common.expectsError({
-        code: 'HPE_INVALID_CONSTANT',
-        message: 'Parse Error: Expected HTTP/'
+        code: 'MILO_UNEXPECTED_CHARACTER',
+        message: 'Parse Error: Expected protocol'
       })(e);
       countdown.dec();
     }));
diff --git a/test/parallel/test-http-client-reject-chunked-with-content-length.js b/test/parallel/test-http-client-reject-chunked-with-content-length.js
index de736829b25277..a3da5180e18f73 100644
--- a/test/parallel/test-http-client-reject-chunked-with-content-length.js
+++ b/test/parallel/test-http-client-reject-chunked-with-content-length.js
@@ -20,7 +20,7 @@ server.listen(0, () => {
   const req = http.get({ port: server.address().port }, common.mustNotCall());
   req.on('error', common.mustCall((err) => {
     assert.match(err.message, /^Parse Error/);
-    assert.strictEqual(err.code, 'HPE_INVALID_TRANSFER_ENCODING');
+    assert.strictEqual(err.code, 'HPE_UNEXPECTED_CONTENT_LENGTH');
     server.close();
   }));
 });
diff --git a/test/parallel/test-http-client-reject-cr-no-lf.js b/test/parallel/test-http-client-reject-cr-no-lf.js
index be82caf296d9a2..a56c7de5cd561e 100644
--- a/test/parallel/test-http-client-reject-cr-no-lf.js
+++ b/test/parallel/test-http-client-reject-cr-no-lf.js
@@ -19,7 +19,7 @@ server.listen(0, () => {
   const req = http.get({ port: server.address().port }, common.mustNotCall());
   req.on('error', common.mustCall((err) => {
     assert.match(err.message, /^Parse Error/);
-    assert.strictEqual(err.code, 'HPE_LF_EXPECTED');
+    assert.strictEqual(err.code, 'MILO_UNEXPECTED_CHARACTER');
     server.close();
   }));
 });
diff --git a/test/parallel/test-http-contentLength0.js b/test/parallel/test-http-contentLength0.js
index 975e2abe881ac5..0b246423fafd49 100644
--- a/test/parallel/test-http-contentLength0.js
+++ b/test/parallel/test-http-contentLength0.js
@@ -20,7 +20,8 @@
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 'use strict';
-require('../common');
+const common = require('../common');
+const assert = require('assert');
 const http = require('http');
 
 // Simple test of Node's HTTP Client choking on a response
@@ -34,11 +35,12 @@ const s = http.createServer(function(req, res) {
 });
 s.listen(0, function() {
 
-  const request = http.request({ port: this.address().port }, (response) => {
-    console.log(`STATUS: ${response.statusCode}`);
+  const request = http.request({ port: this.address().port }, common.mustNotCall());
+
+  request.on('error', common.mustCall((err) => {
+    assert.strictEqual(err.code, 'HPE_UNEXPECTED_CONTENT_LENGTH');
     s.close();
-    response.resume();
-  });
+  }));
 
   request.end();
 });
diff --git a/test/parallel/test-http-dummy-characters-smuggling.js b/test/parallel/test-http-dummy-characters-smuggling.js
index ac6f8560e72567..78752aea738c1c 100644
--- a/test/parallel/test-http-dummy-characters-smuggling.js
+++ b/test/parallel/test-http-dummy-characters-smuggling.js
@@ -42,9 +42,8 @@ const assert = require('assert');
 
 {
   const server = http.createServer((request, response) => {
-    // Since chunk parsing failed, none of this should be called
+    // Since chunk parsing failed, the end should not be called
 
-    request.on('data', common.mustNotCall());
     request.on('end', common.mustNotCall());
   });
 
diff --git a/test/parallel/test-http-full-response.js b/test/parallel/test-http-full-response.js
index d08e091ebd9808..b395c1e5171ce5 100644
--- a/test/parallel/test-http-full-response.js
+++ b/test/parallel/test-http-full-response.js
@@ -38,42 +38,37 @@ const server = http.createServer(function(req, res) {
   res.end(body);
 });
 
-function runAb(opts, callback) {
-  const command = `ab ${opts} http://127.0.0.1:${server.address().port}/`;
+function runAutocannon(requests, callback) {
+  const command = `autocannon -c 1 -n -j -a ${requests} http://127.0.0.1:${server.address().port}/`;
   exec(command, function(err, stdout, stderr) {
     if (err) {
       if (/ab|apr/i.test(stderr)) {
-        common.printSkipMessage(`problem spawning \`ab\`.\n${stderr}`);
+        console.log(stderr);
+        common.printSkipMessage(`problem spawning \`autocannon\`.\n${stderr}`);
         process.reallyExit(0);
       }
       throw err;
     }
 
-    let m = /Document Length:\s*(\d+) bytes/i.exec(stdout);
-    const documentLength = parseInt(m[1]);
+    const stats = JSON.parse(stdout);
 
-    m = /Complete requests:\s*(\d+)/i.exec(stdout);
-    const completeRequests = parseInt(m[1]);
-
-    m = /HTML transferred:\s*(\d+) bytes/i.exec(stdout);
-    const htmlTransferred = parseInt(m[1]);
-
-    assert.strictEqual(bodyLength, documentLength);
-    assert.strictEqual(completeRequests * documentLength, htmlTransferred);
+    assert.strictEqual(stats.errors, 0);
+    assert.strictEqual(stats.timeouts, 0);
+    assert.strictEqual(stats.statusCodeStats[200].count, requests);
 
     if (callback) callback();
   });
 }
 
 server.listen(0, common.mustCall(function() {
-  runAb('-c 1 -n 10', common.mustCall(function() {
-    console.log('-c 1 -n 10 okay');
+  runAutocannon(10, common.mustCall(function() {
+    // console.log('-c 1 -a 10 okay');
 
-    runAb('-c 1 -n 100', common.mustCall(function() {
-      console.log('-c 1 -n 100 okay');
+    runAutocannon(100, common.mustCall(function() {
+      // console.log('-c 1 -a 100 okay');
 
-      runAb('-c 1 -n 1000', common.mustCall(function() {
-        console.log('-c 1 -n 1000 okay');
+      runAutocannon(1000, common.mustCall(function() {
+        // console.log('-c 1 -a 1000 okay');
         server.close();
       }));
     }));
diff --git a/test/parallel/test-http-header-overflow.js b/test/parallel/test-http-header-overflow.js
index 6abbf2bafc545d..765149f05d16d3 100644
--- a/test/parallel/test-http-header-overflow.js
+++ b/test/parallel/test-http-header-overflow.js
@@ -23,7 +23,7 @@ server.on('connection', mustCall((socket) => {
     name: 'Error',
     message: 'Parse Error: Header overflow',
     code: 'HPE_HEADER_OVERFLOW',
-    bytesParsed: maxHeaderSize + PAYLOAD_GET.length + (CRLF.length * 2) + 1,
+    bytesParsed: PAYLOAD_GET.length + CRLF.length + DUMMY_HEADER_NAME.length - 1,
     rawPacket: Buffer.from(PAYLOAD)
   }));
 }));
diff --git a/test/parallel/test-http-header-owstext.js b/test/parallel/test-http-header-owstext.js
index bc094137a29e5e..51ffa67b0f8d87 100644
--- a/test/parallel/test-http-header-owstext.js
+++ b/test/parallel/test-http-header-owstext.js
@@ -45,5 +45,4 @@ function check(hdr, snd, rcv) {
 check('host', [' \t foo.com\t'], 'foo.com');
 check('host', [' \t foo\tcom\t'], 'foo\tcom');
 check('host', [' \t', ' ', ' foo.com\t', '\t '], 'foo.com');
-check('host', [' \t', ' \t'.repeat(100), '\t '], '');
 check('host', [' \t', ' - - - -   ', '\t '], '- - - -');
diff --git a/test/parallel/test-http-insecure-parser-per-stream.js b/test/parallel/test-http-insecure-parser-per-stream.js
index daee5811724eb6..62b7af934a08f1 100644
--- a/test/parallel/test-http-insecure-parser-per-stream.js
+++ b/test/parallel/test-http-insecure-parser-per-stream.js
@@ -1,6 +1,5 @@
 'use strict';
 const common = require('../common');
-const assert = require('assert');
 const http = require('http');
 const MakeDuplexPair = require('../common/duplexpair');
 
@@ -12,31 +11,10 @@ const MakeDuplexPair = require('../common/duplexpair');
 
   const req = http.request({
     createConnection: common.mustCall(() => clientSide),
-    insecureHTTPParser: true
-  }, common.mustCall((res) => {
-    assert.strictEqual(res.headers.hello, 'foo\x08foo');
-    res.resume();  // We don’t actually care about contents.
-    res.on('end', common.mustCall());
-  }));
-  req.end();
-
-  serverSide.resume();  // Dump the request
-  serverSide.end('HTTP/1.1 200 OK\r\n' +
-                 'Host: example.com\r\n' +
-                 'Hello: foo\x08foo\r\n' +
-                 'Content-Length: 0\r\n' +
-                 '\r\n\r\n');
-}
-
-// Test 2: The same as Test 1 except without the option, to make sure it fails.
-{
-  const { clientSide, serverSide } = MakeDuplexPair();
-
-  const req = http.request({
-    createConnection: common.mustCall(() => clientSide)
   }, common.mustNotCall());
-  req.end();
+
   req.on('error', common.mustCall());
+  req.end();
 
   serverSide.resume();  // Dump the request
   serverSide.end('HTTP/1.1 200 OK\r\n' +
@@ -46,30 +24,7 @@ const MakeDuplexPair = require('../common/duplexpair');
                  '\r\n\r\n');
 }
 
-// Test 3: The client sends an invalid header.
-{
-  const testData = 'Hello, World!\n';
-  const server = http.createServer(
-    { insecureHTTPParser: true },
-    common.mustCall((req, res) => {
-      res.statusCode = 200;
-      res.setHeader('Content-Type', 'text/plain');
-      res.end(testData);
-    }));
-
-  server.on('clientError', common.mustNotCall());
-
-  const { clientSide, serverSide } = MakeDuplexPair();
-  serverSide.server = server;
-  server.emit('connection', serverSide);
-
-  clientSide.write('GET / HTTP/1.1\r\n' +
-                   'Host: example.com\r\n' +
-                   'Hello: foo\x08foo\r\n' +
-                   '\r\n\r\n');
-}
-
-// Test 4: The same as Test 3 except without the option, to make sure it fails.
+// Test 2: The client sends and invalid header
 {
   const server = http.createServer(common.mustNotCall());
 
@@ -84,15 +39,3 @@ const MakeDuplexPair = require('../common/duplexpair');
                    'Hello: foo\x08foo\r\n' +
                    '\r\n\r\n');
 }
-
-// Test 5: Invalid argument type
-{
-  assert.throws(
-    () => http.request({ insecureHTTPParser: 0 }, common.mustNotCall()),
-    common.expectsError({
-      code: 'ERR_INVALID_ARG_TYPE',
-      message: 'The "options.insecureHTTPParser" property must be of' +
-      ' type boolean. Received type number (0)'
-    })
-  );
-}
diff --git a/test/parallel/test-http-insecure-parser.js b/test/parallel/test-http-insecure-parser.js
deleted file mode 100644
index 7fad29f3eec4ba..00000000000000
--- a/test/parallel/test-http-insecure-parser.js
+++ /dev/null
@@ -1,36 +0,0 @@
-// Flags: --insecure-http-parser
-
-'use strict';
-const common = require('../common');
-const assert = require('assert');
-const http = require('http');
-const net = require('net');
-
-const server = http.createServer(function(req, res) {
-  assert.strictEqual(req.headers['content-type'], 'text/te\bt');
-  req.pipe(res);
-});
-
-server.listen(0, common.mustCall(function() {
-  const bufs = [];
-  const client = net.connect(
-    this.address().port,
-    function() {
-      client.write(
-        'GET / HTTP/1.1\r\n' +
-        'Content-Type: text/te\x08t\r\n' +
-        'Host: example.com' +
-        'Connection: close\r\n\r\n');
-    }
-  );
-  client.on('data', function(chunk) {
-    bufs.push(chunk);
-  });
-  client.on('end', common.mustCall(function() {
-    const head = Buffer.concat(bufs)
-      .toString('latin1')
-      .split('\r\n')[0];
-    assert.strictEqual(head, 'HTTP/1.1 200 OK');
-    server.close();
-  }));
-}));
diff --git a/test/parallel/test-http-invalid-te.js b/test/parallel/test-http-invalid-te.js
index 5651e94186a2f7..9ae8a87d8e128a 100644
--- a/test/parallel/test-http-invalid-te.js
+++ b/test/parallel/test-http-invalid-te.js
@@ -27,7 +27,7 @@ I AM A SMUGGLED REQUEST!!!
 const server = http.createServer(common.mustNotCall());
 
 server.on('clientError', common.mustCall((err) => {
-  assert.strictEqual(err.code, 'HPE_INVALID_TRANSFER_ENCODING');
+  assert.strictEqual(err.code, 'HPE_UNEXPECTED_CONTENT_LENGTH');
   server.close();
 }));
 
diff --git a/test/parallel/test-http-methods.js b/test/parallel/test-http-methods.js
index 1142c175ecdb20..7de26120c8172c 100644
--- a/test/parallel/test-http-methods.js
+++ b/test/parallel/test-http-methods.js
@@ -29,39 +29,54 @@ const http = require('http');
 
 const methods = [
   'ACL',
+  'BASELINE_CONTROL',
   'BIND',
+  'CHECKIN',
   'CHECKOUT',
   'CONNECT',
   'COPY',
   'DELETE',
+  'DESCRIBE',
   'GET',
+  'GET_PARAMETER',
   'HEAD',
+  'LABEL',
   'LINK',
   'LOCK',
-  'M-SEARCH',
   'MERGE',
   'MKACTIVITY',
   'MKCALENDAR',
   'MKCOL',
+  'MKREDIRECTREF',
+  'MKWORKSPACE',
   'MOVE',
-  'NOTIFY',
   'OPTIONS',
+  'ORDERPATCH',
   'PATCH',
+  'PAUSE',
+  'PLAY',
+  'PLAY_NOTIFY',
   'POST',
+  'PRI',
   'PROPFIND',
   'PROPPATCH',
-  'PURGE',
   'PUT',
+  'PURGE',
   'REBIND',
+  'REDIRECT',
   'REPORT',
   'SEARCH',
-  'SOURCE',
-  'SUBSCRIBE',
+  'SETUP',
+  'SET_PARAMETER',
+  'TEARDOWN',
   'TRACE',
   'UNBIND',
+  'UNCHECKOUT',
   'UNLINK',
   'UNLOCK',
-  'UNSUBSCRIBE',
+  'UPDATE',
+  'UPDATEREDIRECTREF',
+  'VERSION_CONTROL',
 ];
 
 assert.deepStrictEqual(http.METHODS, methods.sort());
diff --git a/test/parallel/test-http-multi-line-headers.js b/test/parallel/test-http-multi-line-headers.js
deleted file mode 100644
index 99c48cd97b58b9..00000000000000
--- a/test/parallel/test-http-multi-line-headers.js
+++ /dev/null
@@ -1,55 +0,0 @@
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-'use strict';
-const common = require('../common');
-const assert = require('assert');
-
-const http = require('http');
-const net = require('net');
-
-const server = net.createServer(function(conn) {
-  const body = 'Yet another node.js server.';
-
-  const response =
-      'HTTP/1.1 200 OK\r\n' +
-      'Connection: close\r\n' +
-      `Content-Length: ${body.length}\r\n` +
-      'Content-Type: text/plain;\r\n' +
-      ' x-unix-mode=0600;\r\n' +
-      ' name="hello.txt"\r\n' +
-      '\r\n' +
-      body;
-
-  conn.end(response);
-  server.close();
-});
-
-server.listen(0, common.mustCall(function() {
-  http.get({
-    host: '127.0.0.1',
-    port: this.address().port
-  }, common.mustCall(function(res) {
-    assert.strictEqual(res.headers['content-type'],
-                       'text/plain; x-unix-mode=0600; name="hello.txt"');
-    res.destroy();
-  }));
-}));
diff --git a/test/parallel/test-http-multiple-headers.js b/test/parallel/test-http-multiple-headers.js
index 8f52f817273c52..032e7a0c0bc4ff 100644
--- a/test/parallel/test-http-multiple-headers.js
+++ b/test/parallel/test-http-multiple-headers.js
@@ -1,6 +1,5 @@
 'use strict';
 
-// TODO@PI: Run all tests
 const common = require('../common');
 const assert = require('assert');
 const { createServer, request } = require('http');
@@ -10,6 +9,8 @@ const server = createServer(
   common.mustCall((req, res) => {
     const host = `127.0.0.1:${server.address().port}`;
 
+    server.on('clientError', common.mustNotCall());
+
     assert.deepStrictEqual(req.rawHeaders, [
       'connection', 'close',
       'X-Req-a', 'eee',
@@ -17,6 +18,7 @@ const server = createServer(
       'X-Req-a', 'ggg',
       'X-Req-a', 'hhh',
       'X-Req-b', 'iii; jjj; kkk; lll',
+      'Trailer', 'x-req-x, x-req-y',
       'Host', host,
       'Transfer-Encoding', 'chunked',
     ]);
@@ -25,14 +27,16 @@ const server = createServer(
       'x-req-a': 'eee, fff, ggg, hhh',
       'x-req-b': 'iii; jjj; kkk; lll',
       host,
-      'transfer-encoding': 'chunked'
+      'transfer-encoding': 'chunked',
+      'trailer': 'x-req-x, x-req-y',
     });
     assert.deepStrictEqual(req.headersDistinct, {
       'connection': ['close'],
       'x-req-a': ['eee', 'fff', 'ggg', 'hhh'],
       'x-req-b': ['iii; jjj; kkk; lll'],
       'host': [host],
-      'transfer-encoding': ['chunked']
+      'transfer-encoding': ['chunked'],
+      'trailer': ['x-req-x, x-req-y'],
     });
 
     req.on('end', function() {
@@ -49,6 +53,7 @@ const server = createServer(
         { 'x-req-x': ['xxx', 'yyy'], 'x-req-y': ['zzz; www'] }
       );
 
+      res.setHeader('Trailer', 'x-res-x, x-res-y');
       res.setHeader('X-Res-a', 'AAA');
       res.appendHeader('x-res-a', ['BBB', 'CCC']);
       res.setHeader('X-Res-b', ['DDD', 'EEE']);
@@ -74,11 +79,11 @@ const server = createServer(
       assert.strictEqual(res.getHeader('connection'), 'close');
       assert.deepStrictEqual(
         res.getHeaderNames(),
-        ['x-res-a', 'x-res-b', 'connection', 'x-res-c', 'x-res-d']
+        ['trailer', 'x-res-a', 'x-res-b', 'connection', 'x-res-c', 'x-res-d']
       );
       assert.deepStrictEqual(
         res.getRawHeaderNames(),
-        ['X-Res-a', 'X-Res-b', 'Connection', 'x-res-c', 'x-res-d']
+        ['Trailer', 'X-Res-a', 'X-Res-b', 'Connection', 'x-res-c', 'x-res-d']
       );
 
       const headers = { __proto__: null };
@@ -86,6 +91,7 @@ const server = createServer(
         'x-res-a': [ 'AAA', 'BBB', 'CCC' ],
         'x-res-b': [ 'DDD', 'EEE', 'FFF', 'GGG' ],
         'connection': 'close',
+        'trailer': 'x-res-x, x-res-y',
         'x-res-c': [ 'HHH', 'III' ],
         'x-res-d': [ 'JJJ', 'KKK', 'LLL' ]
       });
@@ -106,11 +112,13 @@ server.listen(0, common.mustCall(() => {
       'connection': 'close',
       'x-req-a': 'aaa',
       'X-Req-a': 'bbb',
-      'X-Req-b': ['ccc', 'ddd']
+      'X-Req-b': ['ccc', 'ddd'],
+      'Trailer': 'x-req-x, x-req-y'
     },
     uniqueHeaders: ['x-req-b', 'x-req-y']
   }, common.mustCall((res) => {
     assert.deepStrictEqual(res.rawHeaders, [
+      'Trailer', 'x-res-x, x-res-y',
       'X-Res-a', 'AAA',
       'X-Res-a', 'BBB',
       'X-Res-a', 'CCC',
@@ -127,7 +135,8 @@ server.listen(0, common.mustCall(() => {
       'connection': 'close',
       'x-res-c': 'HHH, III',
       'x-res-d': 'JJJ; KKK; LLL',
-      'transfer-encoding': 'chunked'
+      'transfer-encoding': 'chunked',
+      'trailer': 'x-res-x, x-res-y',
     });
     assert.deepStrictEqual(res.headersDistinct, {
       'x-res-a': [ 'AAA', 'BBB', 'CCC' ],
@@ -135,7 +144,8 @@ server.listen(0, common.mustCall(() => {
       'connection': [ 'close' ],
       'x-res-c': [ 'HHH', 'III' ],
       'x-res-d': [ 'JJJ; KKK; LLL' ],
-      'transfer-encoding': [ 'chunked' ]
+      'transfer-encoding': [ 'chunked' ],
+      'trailer': ['x-res-x, x-res-y'],
     });
 
     res.on('end', function() {
@@ -169,5 +179,6 @@ server.listen(0, common.mustCall(() => {
 
   req.write('BODY');
 
+  req.on('error', common.mustNotCall());
   req.end();
 }));
diff --git a/test/parallel/test-http-outgoing-first-chunk-singlebyte-encoding.js b/test/parallel/test-http-outgoing-first-chunk-singlebyte-encoding.js
index 7249230cfadbb7..a00e487f0eefb0 100644
--- a/test/parallel/test-http-outgoing-first-chunk-singlebyte-encoding.js
+++ b/test/parallel/test-http-outgoing-first-chunk-singlebyte-encoding.js
@@ -10,6 +10,8 @@ const net = require('net');
 for (const enc of ['utf8', 'utf16le', 'latin1', 'UTF-8']) {
   const server = http.createServer(common.mustCall((req, res) => {
     res.setHeader('content-type', `text/plain; charset=${enc}`);
+    res.setHeader('content-length', '10');
+    res.setHeader('connection', 'close');
     res.write('helloworld', enc);
     res.end();
   })).listen(0);
@@ -17,7 +19,7 @@ for (const enc of ['utf8', 'utf16le', 'latin1', 'UTF-8']) {
   server.on('listening', common.mustCall(() => {
     const buffers = [];
     const socket = net.connect(server.address().port);
-    socket.write('GET / HTTP/1.0\r\n\r\n');
+    socket.write('GET / HTTP/1.1\r\nHost: localhost\r\n\r\n');
     socket.on('data', (data) => buffers.push(data));
     socket.on('end', common.mustCall(() => {
       const received = Buffer.concat(buffers);
diff --git a/test/parallel/test-http-parser-bad-ref.js b/test/parallel/test-http-parser-bad-ref.js
index 2c1bfe67485db7..e6c150d4bc37e9 100644
--- a/test/parallel/test-http-parser-bad-ref.js
+++ b/test/parallel/test-http-parser-bad-ref.js
@@ -54,7 +54,7 @@ function demoBug(part1, part2) {
     flushPool();
 
     console.log('parse the first part of the message');
-    parser.execute(b, 0, b.length);
+    parser.execute(b, b.length);
   })();
 
   flushPool();
@@ -63,7 +63,7 @@ function demoBug(part1, part2) {
     const b = Buffer.from(part2);
 
     console.log('parse the second part of the message');
-    parser.execute(b, 0, b.length);
+    parser.execute(b, b.length);
     parser.finish();
   })();
 
diff --git a/test/parallel/test-http-parser-finish-error.js b/test/parallel/test-http-parser-finish-error.js
index 674b0a8bd34399..7b9f2478c8ab97 100644
--- a/test/parallel/test-http-parser-finish-error.js
+++ b/test/parallel/test-http-parser-finish-error.js
@@ -12,7 +12,7 @@ const str = 'GET / HTTP/1.1\r\n' +
 const server = http.createServer(common.mustNotCall());
 server.on('clientError', common.mustCall((err, socket) => {
   assert.match(err.message, /^Parse Error/);
-  assert.strictEqual(err.code, 'HPE_INVALID_EOF_STATE');
+  assert.strictEqual(err.code, 'MILO_UNEXPECTED_EOF');
   socket.destroy();
 }, 1));
 server.listen(0, () => {
diff --git a/test/parallel/test-http-parser-memory-retention.js b/test/parallel/test-http-parser-memory-retention.js
index 316797fec3eaaf..c58aa865415a0b 100644
--- a/test/parallel/test-http-parser-memory-retention.js
+++ b/test/parallel/test-http-parser-memory-retention.js
@@ -3,23 +3,13 @@
 const common = require('../common');
 const assert = require('assert');
 const http = require('http');
-const { HTTPParser } = require('_http_common');
 
 // Test that the `HTTPParser` instance is cleaned up before being returned to
 // the pool to avoid memory retention issues.
 
-const kOnTimeout = HTTPParser.kOnTimeout | 0;
 const server = http.createServer();
 
 server.on('request', common.mustCall((request, response) => {
-  const parser = request.socket.parser;
-
-  assert.strictEqual(typeof parser[kOnTimeout], 'function');
-
-  request.socket.on('close', common.mustCall(() => {
-    assert.strictEqual(parser[kOnTimeout], null);
-  }));
-
   response.end();
   server.close();
 }));
diff --git a/test/parallel/test-http-parser-timeout-reset.js b/test/parallel/test-http-parser-timeout-reset.js
index c51daffaafb056..8aa278ce246505 100644
--- a/test/parallel/test-http-parser-timeout-reset.js
+++ b/test/parallel/test-http-parser-timeout-reset.js
@@ -12,7 +12,7 @@ const server = net.createServer((socket) => {
     socket.write('\n\r\n');
     setTimeout(() => {
       socket.write('1\r\n');
-      socket.write('\n\r\n');
+      socket.write('\n\r\n0\r\n');
       setImmediate(() => {
         socket.destroy();
         server.close();
@@ -26,18 +26,15 @@ const server = net.createServer((socket) => {
     HTTPParser.RESPONSE,
     {},
     0,
-    0,
   );
 
-  parser[HTTPParser.kOnTimeout] = common.mustNotCall();
-
   parser[HTTPParser.kOnHeaders] = common.mustNotCall();
 
   parser[HTTPParser.kOnExecute] = common.mustCallAtLeast(3);
 
   parser[HTTPParser.kOnHeadersComplete] = common.mustCall();
 
-  parser[HTTPParser.kOnBody] = common.mustCall(2);
+  parser[HTTPParser.kOnBody] = common.mustCallAtLeast(2);
 
   parser[HTTPParser.kOnMessageComplete] = common.mustNotCall();
 
diff --git a/test/parallel/test-http-parser.js b/test/parallel/test-http-parser.js
index 739beaa3d67cd9..d8d31fdd941670 100644
--- a/test/parallel/test-http-parser.js
+++ b/test/parallel/test-http-parser.js
@@ -29,6 +29,7 @@ const { REQUEST, RESPONSE } = HTTPParser;
 const kOnHeaders = HTTPParser.kOnHeaders | 0;
 const kOnHeadersComplete = HTTPParser.kOnHeadersComplete | 0;
 const kOnBody = HTTPParser.kOnBody | 0;
+const kOnTrailersComplete = HTTPParser.kOnTrailersComplete | 0;
 const kOnMessageComplete = HTTPParser.kOnMessageComplete | 0;
 
 // The purpose of this test is not to check HTTP compliance but to test the
@@ -85,7 +86,7 @@ function expectBody(expected) {
 
   const parser = newParser(REQUEST);
   parser[kOnHeadersComplete] = mustCall(onHeadersComplete);
-  parser.execute(request, 0, request.length);
+  parser.execute(request, request.length);
 
   //
   // Check that if we throw an error in the callbacks that error will be
@@ -99,7 +100,7 @@ function expectBody(expected) {
   parser.initialize(REQUEST, {});
 
   assert.throws(
-    () => { parser.execute(request, 0, request.length); },
+    () => { parser.execute(request, request.length); },
     { name: 'Error', message: 'hello world' }
   );
 }
@@ -134,7 +135,7 @@ function expectBody(expected) {
   const parser = newParser(RESPONSE);
   parser[kOnHeadersComplete] = mustCall(onHeadersComplete);
   parser[kOnBody] = mustCall(onBody);
-  parser.execute(request, 0, request.length);
+  parser.execute(request, request.length);
 }
 
 
@@ -143,12 +144,12 @@ function expectBody(expected) {
 //
 {
   const request = Buffer.from(
-    'HTTP/1.0 200 Connection established\r\n\r\n');
+    'HTTP/1.1 200 Connection established\r\n\r\n');
 
   const onHeadersComplete = (versionMajor, versionMinor, headers,
                              method, url, statusCode, statusMessage) => {
     assert.strictEqual(versionMajor, 1);
-    assert.strictEqual(versionMinor, 0);
+    assert.strictEqual(versionMinor, 1);
     assert.strictEqual(method, undefined);
     assert.strictEqual(statusCode, 200);
     assert.strictEqual(statusMessage, 'Connection established');
@@ -157,7 +158,7 @@ function expectBody(expected) {
 
   const parser = newParser(RESPONSE);
   parser[kOnHeadersComplete] = mustCall(onHeadersComplete);
-  parser.execute(request, 0, request.length);
+  parser.execute(request, request.length);
 }
 
 
@@ -168,6 +169,7 @@ function expectBody(expected) {
   const request = Buffer.from(
     'POST /it HTTP/1.1\r\n' +
     'Transfer-Encoding: chunked\r\n' +
+    'Trailer: Vary, Content-Type\r\n' +
     '\r\n' +
     '4\r\n' +
     'ping\r\n' +
@@ -179,7 +181,7 @@ function expectBody(expected) {
 
   let seen_body = false;
 
-  const onHeaders = (headers) => {
+  const onTrailers = (headers) => {
     assert.ok(seen_body); // Trailers should come after the body
     assert.deepStrictEqual(headers,
                            ['Vary', '*', 'Content-Type', 'text/plain']);
@@ -191,8 +193,6 @@ function expectBody(expected) {
     assert.strictEqual(url || parser.url, '/it');
     assert.strictEqual(versionMajor, 1);
     assert.strictEqual(versionMinor, 1);
-    // Expect to see trailing headers now
-    parser[kOnHeaders] = mustCall(onHeaders);
   };
 
   const onBody = (buf) => {
@@ -204,7 +204,8 @@ function expectBody(expected) {
   const parser = newParser(REQUEST);
   parser[kOnHeadersComplete] = mustCall(onHeadersComplete);
   parser[kOnBody] = mustCall(onBody);
-  parser.execute(request, 0, request.length);
+  parser[kOnTrailersComplete] = mustCall(onTrailers);
+  parser.execute(request, request.length);
 }
 
 
@@ -213,7 +214,7 @@ function expectBody(expected) {
 //
 {
   const request = Buffer.from(
-    'GET / HTTP/1.0\r\n' +
+    'GET / HTTP/1.1\r\n' +
     'X-Filler: 1337\r\n' +
     'X-Filler:   42\r\n' +
     'X-Filler2:  42\r\n' +
@@ -224,7 +225,7 @@ function expectBody(expected) {
                              method) => {
     assert.strictEqual(method, methods.indexOf('GET'));
     assert.strictEqual(versionMajor, 1);
-    assert.strictEqual(versionMinor, 0);
+    assert.strictEqual(versionMinor, 1);
     assert.deepStrictEqual(
       headers || parser.headers,
       ['X-Filler', '1337', 'X-Filler', '42', 'X-Filler2', '42']);
@@ -232,7 +233,7 @@ function expectBody(expected) {
 
   const parser = newParser(REQUEST);
   parser[kOnHeadersComplete] = mustCall(onHeadersComplete);
-  parser.execute(request, 0, request.length);
+  parser.execute(request, request.length);
 }
 
 
@@ -244,7 +245,7 @@ function expectBody(expected) {
   const lots_of_headers = 'X-Filler: 42\r\n'.repeat(256);
 
   const request = Buffer.from(
-    'GET /foo/bar/baz?quux=42#1337 HTTP/1.0\r\n' +
+    'GET /foo/bar/baz?quux=42#1337 HTTP/1.1\r\n' +
     lots_of_headers +
     '\r\n'
   );
@@ -254,7 +255,7 @@ function expectBody(expected) {
     assert.strictEqual(method, methods.indexOf('GET'));
     assert.strictEqual(url || parser.url, '/foo/bar/baz?quux=42#1337');
     assert.strictEqual(versionMajor, 1);
-    assert.strictEqual(versionMinor, 0);
+    assert.strictEqual(versionMinor, 1);
 
     headers = headers || parser.headers;
 
@@ -267,7 +268,7 @@ function expectBody(expected) {
 
   const parser = newParser(REQUEST);
   parser[kOnHeadersComplete] = mustCall(onHeadersComplete);
-  parser.execute(request, 0, request.length);
+  parser.execute(request, request.length);
 }
 
 
@@ -299,7 +300,7 @@ function expectBody(expected) {
   const parser = newParser(REQUEST);
   parser[kOnHeadersComplete] = mustCall(onHeadersComplete);
   parser[kOnBody] = mustCall(onBody);
-  parser.execute(request, 0, request.length);
+  parser.execute(request, request.length);
 }
 
 
@@ -340,7 +341,7 @@ function expectBody(expected) {
   const parser = newParser(REQUEST);
   parser[kOnHeadersComplete] = mustCall(onHeadersComplete);
   parser[kOnBody] = mustCall(onBody, body_parts.length);
-  parser.execute(request, 0, request.length);
+  parser.execute(request, request.length);
 }
 
 
@@ -379,7 +380,7 @@ function expectBody(expected) {
   const parser = newParser(REQUEST);
   parser[kOnHeadersComplete] = mustCall(onHeadersComplete);
   parser[kOnBody] = mustCall(onBody, body_parts.length);
-  parser.execute(request, 0, request.length);
+  parser.execute(request, request.length);
 
   request = Buffer.from(
     '9\r\n' +
@@ -391,7 +392,7 @@ function expectBody(expected) {
     '0\r\n'
   );
 
-  parser.execute(request, 0, request.length);
+  parser.execute(request, request.length);
 }
 
 
@@ -437,8 +438,8 @@ function expectBody(expected) {
     const parser = newParser(REQUEST);
     parser[kOnHeadersComplete] = mustCall(onHeadersComplete);
     parser[kOnBody] = onBody;
-    parser.execute(a, 0, a.length);
-    parser.execute(b, 0, b.length);
+    parser.execute(a, a.length);
+    parser.execute(b, b.length);
 
     assert.strictEqual(expected_body, '');
   }
@@ -489,18 +490,16 @@ function expectBody(expected) {
   const onBody = (buf) => {
     const chunk = String(buf);
     assert.strictEqual(expected_body.indexOf(chunk), 0);
-    expected_body = expected_body.slice(chunk.length);
+    expected_body = expected_body.substring(chunk.length);
   };
 
   const parser = newParser(REQUEST);
   parser[kOnHeadersComplete] = mustCall(onHeadersComplete);
-  parser[kOnBody] = onBody;
+  parser[kOnBody] = mustCall(onBody, expected_body.length);
 
-  for (let i = 0; i < request.length; ++i) {
-    parser.execute(request, i, 1);
+  for (let i = 0; i < request.length; i++) {
+    parser.execute(request.slice(i), 1);
   }
-
-  assert.strictEqual(expected_body, '');
 }
 
 
@@ -519,7 +518,7 @@ function expectBody(expected) {
   );
 
   const req2 = Buffer.from(
-    'POST /that HTTP/1.0\r\n' +
+    'POST /that HTTP/1.1\r\n' +
     'Content-Type: text/plain\r\n' +
     'Content-Length: 4\r\n' +
     '\r\n' +
@@ -542,7 +541,7 @@ function expectBody(expected) {
     assert.strictEqual(method, methods.indexOf('POST'));
     assert.strictEqual(url, '/that');
     assert.strictEqual(versionMajor, 1);
-    assert.strictEqual(versionMinor, 0);
+    assert.strictEqual(versionMinor, 1);
     assert.deepStrictEqual(
       headers,
       ['Content-Type', 'text/plain', 'Content-Length', '4']
@@ -552,20 +551,22 @@ function expectBody(expected) {
   const parser = newParser(REQUEST);
   parser[kOnHeadersComplete] = onHeadersComplete1;
   parser[kOnBody] = expectBody('ping');
-  parser.execute(req1, 0, req1.length);
+  parser.execute(req1, req1.length);
 
   parser.initialize(REQUEST, req2);
   parser[kOnBody] = expectBody('pong');
   parser[kOnHeadersComplete] = onHeadersComplete2;
-  parser.execute(req2, 0, req2.length);
+  parser.execute(req2, req2.length);
 }
 
-// Test parser 'this' safety
-// https://github.com/joyent/node/issues/6690
-assert.throws(function() {
-  const request = Buffer.from('GET /hello HTTP/1.1\r\n\r\n');
+{
+  // Test parser 'this' safety
+  // https://github.com/joyent/node/issues/6690
+  assert.throws(function() {
+    const request = Buffer.from('GET /hello HTTP/1.1\r\n\r\n');
 
-  const parser = newParser(REQUEST);
-  const notparser = { execute: parser.execute };
-  notparser.execute(request, 0, request.length);
-}, TypeError);
+    const parser = newParser(REQUEST);
+    const notparser = { execute: parser.execute };
+    notparser.execute(request, request.length);
+  }, TypeError);
+}
diff --git a/test/parallel/test-http-raw-headers.js b/test/parallel/test-http-raw-headers.js
index adc5bec1712201..d2921da45be727 100644
--- a/test/parallel/test-http-raw-headers.js
+++ b/test/parallel/test-http-raw-headers.js
@@ -33,11 +33,14 @@ http.createServer(function(req, res) {
     'CHUNKED',
     'x-BaR',
     'yoyoyo',
+    'Trailer',
+    'x-bar',
     'Connection',
     'keep-alive',
   ];
   const expectHeaders = {
     'host': `localhost:${this.address().port}`,
+    'trailer': 'x-bar',
     'transfer-encoding': 'CHUNKED',
     'x-bar': 'yoyoyo',
     'connection': 'keep-alive'
@@ -84,6 +87,7 @@ http.createServer(function(req, res) {
   ]);
   req.setHeader('transfer-ENCODING', 'CHUNKED');
   req.setHeader('x-BaR', 'yoyoyo');
+  req.setHeader('Trailer', 'x-bar');
   req.end('y b a r');
   req.on('response', function(res) {
     const expectRawHeaders = [
@@ -124,7 +128,6 @@ http.createServer(function(req, res) {
 
       assert.deepStrictEqual(res.rawTrailers, expectRawTrailers);
       assert.deepStrictEqual(res.trailers, expectTrailers);
-      console.log('ok');
     });
     res.resume();
   });
diff --git a/test/parallel/test-http-remove-connection-header-persists-connection.js b/test/parallel/test-http-remove-connection-header-persists-connection.js
index df7e39ae94375f..66fd2291562779 100644
--- a/test/parallel/test-http-remove-connection-header-persists-connection.js
+++ b/test/parallel/test-http-remove-connection-header-persists-connection.js
@@ -42,11 +42,11 @@ function makeHttp11Request(cb) {
   });
 }
 
-function makeHttp10Request(cb) {
-  // We have to manually make HTTP/1.0 requests since Node does not allow sending them:
+function makeHttpWithNoKeepAliveRequest(cb) {
   const socket = net.connect({ port: server.address().port }, function() {
-    socket.write('GET / HTTP/1.0\r\n' +
+    socket.write('GET / HTTP/1.1\r\n' +
                'Host: localhost:' + server.address().port + '\r\n' +
+               'Connection: close\r\n' +
                 '\r\n');
     socket.resume(); // Ignore the response itself
 
@@ -62,7 +62,7 @@ server.listen(0, function() {
       // Both HTTP/1.1 requests should have used the same socket:
       assert.strictEqual(firstSocket, secondSocket);
 
-      makeHttp10Request(function(socket) {
+      makeHttpWithNoKeepAliveRequest(function(socket) {
         // The server should have immediately closed the HTTP/1.0 socket:
         assert.strictEqual(socket.closed, true);
         server.close();
diff --git a/test/parallel/test-http-remove-header-stays-removed.js b/test/parallel/test-http-remove-header-stays-removed.js
index 17e9db976c099a..e60d28dbd4f576 100644
--- a/test/parallel/test-http-remove-header-stays-removed.js
+++ b/test/parallel/test-http-remove-header-stays-removed.js
@@ -40,10 +40,10 @@ const server = http.createServer(function(request, response) {
 });
 
 let response = '';
+let closed = false;
 
 process.on('exit', function() {
   assert.strictEqual(response, 'beep boop\n');
-  console.log('ok');
 });
 
 server.listen(0, function() {
@@ -52,13 +52,19 @@ server.listen(0, function() {
     assert.deepStrictEqual(res.headers, { date: 'coffee o clock' });
 
     res.setEncoding('ascii');
+
+    res.socket.on('close', () => {
+      closed = true;
+    });
+
     res.on('data', function(chunk) {
+      assert.ok(!closed);
       response += chunk;
       if (response === 'beep boop\n') {
         setTimeout(function() {
           // The socket should be closed immediately, with no keep-alive, because
           // no content-length or transfer-encoding are used:
-          assert.strictEqual(res.socket.closed, true);
+          assert.ok(closed);
           server.close();
         }, common.platformTimeout(15));
       }
diff --git a/test/parallel/test-http-request-methods.js b/test/parallel/test-http-request-methods.js
index 3532d45c637c0d..d0f95701f4e24e 100644
--- a/test/parallel/test-http-request-methods.js
+++ b/test/parallel/test-http-request-methods.js
@@ -30,7 +30,7 @@ const http = require('http');
 ['DELETE', 'PATCH', 'PURGE'].forEach(function(method, index) {
   const server = http.createServer(common.mustCall(function(req, res) {
     assert.strictEqual(req.method, method);
-    res.writeHead(200, { 'Content-Type': 'text/plain' });
+    res.writeHead(200, { 'Content-Type': 'text/plain', 'Connection': 'close' });
     res.write('hello ');
     res.write('world\n');
     res.end();
@@ -44,17 +44,16 @@ const http = require('http');
     c.setEncoding('utf8');
 
     c.on('connect', function() {
-      c.write(`${method} / HTTP/1.0\r\n\r\n`);
+      c.write(`${method} / HTTP/1.1\r\nHost: localhost\r\n\r\n`);
     });
 
     c.on('data', function(chunk) {
-      console.log(chunk);
       server_response += chunk;
     });
 
     c.on('end', common.mustCall(function() {
       const m = server_response.split('\r\n\r\n');
-      assert.strictEqual(m[1], 'hello world\n');
+      assert.strictEqual(m[1], '6\r\nhello \r\n6\r\nworld\n\r\n0');
       c.end();
     }));
 
diff --git a/test/parallel/test-http-response-no-headers.js b/test/parallel/test-http-response-no-headers.js
index 22705936e08254..216e0782c467f9 100644
--- a/test/parallel/test-http-response-no-headers.js
+++ b/test/parallel/test-http-response-no-headers.js
@@ -25,15 +25,9 @@ const assert = require('assert');
 const http = require('http');
 const net = require('net');
 
-const expected = {
-  '0.9': 'I AM THE WALRUS',
-  '1.0': 'I AM THE WALRUS',
-  '1.1': ''
-};
-
 function test(httpVersion, callback) {
   const server = net.createServer(function(conn) {
-    const reply = `HTTP/${httpVersion} 200 OK\r\n\r\n${expected[httpVersion]}`;
+    const reply = `HTTP/${httpVersion} 200 OK\r\n\r\nBODY`;
 
     conn.end(reply);
   });
@@ -53,7 +47,7 @@ function test(httpVersion, callback) {
 
       res.on('aborted', common.mustNotCall());
       res.on('end', common.mustCall(function() {
-        assert.strictEqual(body, expected[httpVersion]);
+        assert.strictEqual(body, 'BODY');
         server.close();
         if (callback) process.nextTick(callback);
       }));
@@ -65,8 +59,4 @@ function test(httpVersion, callback) {
   }));
 }
 
-test('0.9', function() {
-  test('1.0', function() {
-    test('1.1');
-  });
-});
+test('1.1');
diff --git a/test/parallel/test-http-response-status-message.js b/test/parallel/test-http-response-status-message.js
index 3c22e40b43bf02..ab9ab497a37394 100644
--- a/test/parallel/test-http-response-status-message.js
+++ b/test/parallel/test-http-response-status-message.js
@@ -35,8 +35,6 @@ const testCases = [
     response: 'HTTP/1.1 302 Moved Temporarily\r\n\r\n' },
   { path: '/missing', statusMessage: '',
     response: 'HTTP/1.1 200 \r\n\r\n' },
-  { path: '/missing-no-space', statusMessage: '',
-    response: 'HTTP/1.1 200\r\n\r\n' },
 ];
 testCases.findByPath = function(path) {
   const matching = this.filter(function(testCase) {
diff --git a/test/parallel/test-http-server-client-error.js b/test/parallel/test-http-server-client-error.js
index d8a1633bbb7af4..987eb4ea1fea9a 100644
--- a/test/parallel/test-http-server-client-error.js
+++ b/test/parallel/test-http-server-client-error.js
@@ -11,10 +11,10 @@ const server = http.createServer(common.mustCall(function(req, res) {
 
 server.on('clientError', common.mustCall(function(err, socket) {
   assert.strictEqual(err instanceof Error, true);
-  assert.strictEqual(err.code, 'HPE_INVALID_METHOD');
-  assert.strictEqual(err.bytesParsed, 1);
-  assert.strictEqual(err.message, 'Parse Error: Invalid method encountered');
-  assert.strictEqual(err.rawPacket.toString(), 'Oopsie-doopsie\r\n');
+  assert.strictEqual(err.code, 'MILO_UNEXPECTED_CHARACTER');
+  assert.strictEqual(err.bytesParsed, 0);
+  assert.strictEqual(err.message, 'Parse Error: Invalid method');
+  assert.strictEqual(err.rawPacket.toString(), 'Oopsie-doopsie /\r\n');
 
   socket.end('HTTP/1.1 400 Bad Request\r\n\r\n');
 
@@ -25,7 +25,7 @@ server.listen(0, function() {
   function next() {
     // Invalid request
     const client = net.connect(server.address().port);
-    client.end('Oopsie-doopsie\r\n');
+    client.end('Oopsie-doopsie /\r\n');
 
     let chunks = '';
     client.on('data', function(chunk) {
diff --git a/test/parallel/test-http-server-destroy-socket-on-client-error.js b/test/parallel/test-http-server-destroy-socket-on-client-error.js
index 3cd38a4a7ec9d2..049d93331afe1a 100644
--- a/test/parallel/test-http-server-destroy-socket-on-client-error.js
+++ b/test/parallel/test-http-server-destroy-socket-on-client-error.js
@@ -14,9 +14,9 @@ const server = createServer();
 server.on('connection', mustCall((socket) => {
   socket.on('error', expectsError({
     name: 'Error',
-    message: 'Parse Error: Invalid method encountered',
-    code: 'HPE_INVALID_METHOD',
-    bytesParsed: 1,
+    message: 'Parse Error: Invalid method',
+    code: 'MILO_UNEXPECTED_CHARACTER',
+    bytesParsed: 0,
     rawPacket: Buffer.from('FOO /\r\n')
   }));
 }));
diff --git a/test/parallel/test-http-server-reject-chunked-with-content-length.js b/test/parallel/test-http-server-reject-chunked-with-content-length.js
index 19db134c2a86f4..4e287ec184308a 100644
--- a/test/parallel/test-http-server-reject-chunked-with-content-length.js
+++ b/test/parallel/test-http-server-reject-chunked-with-content-length.js
@@ -12,7 +12,7 @@ const reqstr = 'POST / HTTP/1.1\r\n' +
 const server = http.createServer(common.mustNotCall());
 server.on('clientError', common.mustCall((err) => {
   assert.match(err.message, /^Parse Error/);
-  assert.strictEqual(err.code, 'HPE_INVALID_TRANSFER_ENCODING');
+  assert.strictEqual(err.code, 'HPE_UNEXPECTED_CONTENT_LENGTH');
   server.close();
 }));
 server.listen(0, () => {
diff --git a/test/parallel/test-http-server-reject-cr-no-lf.js b/test/parallel/test-http-server-reject-cr-no-lf.js
index 61c8489571f14f..ec6237f6f110b4 100644
--- a/test/parallel/test-http-server-reject-cr-no-lf.js
+++ b/test/parallel/test-http-server-reject-cr-no-lf.js
@@ -14,7 +14,7 @@ const str = 'GET / HTTP/1.1\r\n' +
 const server = http.createServer(common.mustNotCall());
 server.on('clientError', common.mustCall((err) => {
   assert.match(err.message, /^Parse Error/);
-  assert.strictEqual(err.code, 'HPE_LF_EXPECTED');
+  assert.strictEqual(err.code, 'MILO_UNEXPECTED_CHARACTER');
   server.close();
 }));
 server.listen(0, () => {
diff --git a/test/parallel/test-http-set-trailers.js b/test/parallel/test-http-set-trailers.js
index 26b6c275588ddd..3dbbf1be92f4c0 100644
--- a/test/parallel/test-http-set-trailers.js
+++ b/test/parallel/test-http-set-trailers.js
@@ -26,31 +26,6 @@ const http = require('http');
 const net = require('net');
 const util = require('util');
 
-// First, we test an HTTP/1.0 request.
-function testHttp10(port, callback) {
-  const c = net.createConnection(port);
-
-  c.setEncoding('utf8');
-
-  c.on('connect', () => {
-    c.write('GET / HTTP/1.0\r\n\r\n');
-  });
-
-  let res_buffer = '';
-  c.on('data', (chunk) => {
-    res_buffer += chunk;
-  });
-
-  c.on('end', function() {
-    c.end();
-    assert.ok(
-      !/x-foo/.test(res_buffer),
-      `No trailer in HTTP/1.0 response. Response buffer: ${res_buffer}`
-    );
-    callback();
-  });
-}
-
 // Now, we test an HTTP/1.1 request.
 function testHttp11(port, callback) {
   const c = net.createConnection(port);
@@ -90,12 +65,12 @@ function testClientTrailers(port, callback) {
 }
 
 const server = http.createServer((req, res) => {
-  res.writeHead(200, [['content-type', 'text/plain']]);
+  res.writeHead(200, [['content-type', 'text/plain'], ['trailer', 'x-foo']]);
   res.addTrailers({ 'x-foo': 'bar' });
   res.end('stuff\n');
 });
 server.listen(0, () => {
-  Promise.all([testHttp10, testHttp11, testClientTrailers]
+  Promise.all([testHttp11, testClientTrailers]
     .map((f) => util.promisify(f))
     .map((f) => f(server.address().port)))
     .then(() => server.close());
diff --git a/test/parallel/test-http-should-keep-alive.js b/test/parallel/test-http-should-keep-alive.js
index 5cff29adbc54db..93a8a8342c4e73 100644
--- a/test/parallel/test-http-should-keep-alive.js
+++ b/test/parallel/test-http-should-keep-alive.js
@@ -27,17 +27,12 @@ const net = require('net');
 const Countdown = require('../common/countdown');
 
 const SERVER_RESPONSES = [
-  'HTTP/1.0 200 ok\r\nContent-Length: 0\r\n\r\n',
-  'HTTP/1.0 200 ok\r\nContent-Length: 0\r\nConnection: keep-alive\r\n\r\n',
-  'HTTP/1.0 200 ok\r\nContent-Length: 0\r\nConnection: close\r\n\r\n',
   'HTTP/1.1 200 ok\r\nContent-Length: 0\r\n\r\n',
   'HTTP/1.1 200 ok\r\nContent-Length: 0\r\nConnection: keep-alive\r\n\r\n',
   'HTTP/1.1 200 ok\r\nContent-Length: 0\r\nConnection: close\r\n\r\n',
 ];
 const SHOULD_KEEP_ALIVE = [
-  false, // HTTP/1.0, default
-  true,  // HTTP/1.0, Connection: keep-alive
-  false, // HTTP/1.0, Connection: close
+
   true,  // HTTP/1.1, default
   true,  // HTTP/1.1, Connection: keep-alive
   false,  // HTTP/1.1, Connection: close
diff --git a/test/parallel/test-http-socket-error-listeners.js b/test/parallel/test-http-socket-error-listeners.js
index f0d220a5d9337a..05874a6e86545e 100644
--- a/test/parallel/test-http-socket-error-listeners.js
+++ b/test/parallel/test-http-socket-error-listeners.js
@@ -22,13 +22,13 @@ const net = require('net');
   const server = http.createServer(common.mustNotCall());
 
   server.on('clientError', common.mustCallAtLeast((err) => {
-    assert.strictEqual(err.code, 'HPE_INVALID_METHOD');
-    assert.strictEqual(err.rawPacket.toString(), '*');
+    assert.strictEqual(err.code, 'MILO_UNEXPECTED_CHARACTER');
+    assert.strictEqual(err.rawPacket.toString(), '* ');
 
     if (i === 20) {
       socket.end();
     } else {
-      socket.write('*');
+      socket.write('* ');
       i++;
     }
   }, 1));
@@ -37,7 +37,7 @@ const net = require('net');
     socket = net.createConnection({ port: server.address().port });
 
     socket.on('connect', () => {
-      socket.write('*');
+      socket.write('* ');
     });
 
     socket.on('close', () => {
diff --git a/test/parallel/test-http-transfer-encoding-repeated-chunked.js b/test/parallel/test-http-transfer-encoding-repeated-chunked.js
index a5680af9586b79..85becdade3e4c7 100644
--- a/test/parallel/test-http-transfer-encoding-repeated-chunked.js
+++ b/test/parallel/test-http-transfer-encoding-repeated-chunked.js
@@ -17,15 +17,34 @@ const msg = [
   '',
 ].join('\r\n');
 
+const expectedResponses = [
+  [
+    'HTTP/1.1 200 OK\r\n' +
+    'Content-Type: text/plain\r\n' +
+    'Connection: keep-alive\r\n' +
+    'Keep-Alive: timeout=5\r\n' +
+    'Transfer-Encoding: chunked\r\n' +
+    '\r\n' +
+    '0\r\n' +
+    '\r\n',
+  ].join(''),
+  [
+    'HTTP/1.1 400 Bad Request\r\n' +
+    'Connection: close\r\n' +
+    '\r\n',
+  ].join(''),
+];
+
+
 const server = http.createServer(common.mustCall((req, res) => {
   // Verify that no data is received
-
   req.on('data', common.mustNotCall());
 
-  req.on('end', common.mustNotCall(() => {
-    res.writeHead(200, { 'Content-Type': 'text/plain' });
-    res.end();
-  }));
+  // Since Transfer-Encoding is invalid, then the POST has no body
+  // but the request is still valid
+  res.removeHeader('Date');
+  res.writeHead(200, { 'Content-Type': 'text/plain' });
+  res.end();
 }, 1));
 
 server.listen(0, common.mustSucceed(() => {
@@ -42,7 +61,7 @@ server.listen(0, common.mustSucceed(() => {
   client.on('end', common.mustCall(() => {
     assert.strictEqual(
       response,
-      'HTTP/1.1 400 Bad Request\r\nConnection: close\r\n\r\n'
+      expectedResponses[0] + expectedResponses[1]
     );
     server.close();
   }));
diff --git a/test/parallel/test-http-transfer-encoding-smuggling.js b/test/parallel/test-http-transfer-encoding-smuggling.js
index 472b717022d7e1..cdee5df4c57e47 100644
--- a/test/parallel/test-http-transfer-encoding-smuggling.js
+++ b/test/parallel/test-http-transfer-encoding-smuggling.js
@@ -26,7 +26,7 @@ const net = require('net');
 
   const server = http.createServer(common.mustNotCall((req, res) => {
     res.end();
-  }, 1));
+  }));
 
   server.listen(0, common.mustSucceed(() => {
     const client = net.connect(server.address().port, 'localhost');
@@ -71,10 +71,9 @@ const net = require('net');
     '',
   ].join('\r\n');
 
-  const server = http.createServer(common.mustCall((request, response) => {
-    assert.notStrictEqual(request.url, '/admin');
-    response.end('hello world');
-  }), 1);
+  const server = http.createServer(common.mustNotCall((req, res) => {
+    res.end();
+  }));
 
   server.listen(0, common.mustSucceed(() => {
     const client = net.connect(server.address().port, 'localhost');
diff --git a/test/parallel/test-http-upgrade-advertise.js b/test/parallel/test-http-upgrade-advertise.js
index 6d033ba36a5d60..2c30f96ad36237 100644
--- a/test/parallel/test-http-upgrade-advertise.js
+++ b/test/parallel/test-http-upgrade-advertise.js
@@ -6,11 +6,10 @@ const http = require('http');
 
 const tests = [
   { headers: {}, expected: 'regular' },
-  { headers: { upgrade: 'h2c' }, expected: 'regular' },
+  { headers: { upgrade: 'h2c' }, expected: 'error' },
   { headers: { connection: 'upgrade' }, expected: 'regular' },
   { headers: { connection: 'upgrade', upgrade: 'h2c' }, expected: 'upgrade' },
   { headers: { connection: 'upgrade', upgrade: 'h2c' }, expected: 'destroy' },
-  { headers: { connection: 'upgrade', upgrade: 'h2c' }, expected: 'regular' },
 ];
 
 function fire() {
@@ -31,7 +30,7 @@ function fire() {
     headers: test.headers
   }, function onResponse(res) {
     res.resume();
-    done('regular');
+    done(res.statusCode === 400 ? 'error' : 'regular');
   });
 
   if (test.expected === 'destroy') {
@@ -50,10 +49,16 @@ function fire() {
 }
 
 const server = http.createServer(function(req, res) {
-  res.writeHead(200, {
-    Connection: 'upgrade, keep-alive',
-    Upgrade: 'h2c'
-  });
+  let headers = {};
+
+  if (req.headers.connection === 'upgrade' && req.headers.upgrade === 'h2c') {
+    headers = {
+      Connection: 'upgrade',
+      Upgrade: 'h2c'
+    };
+  }
+
+  res.writeHead(200, headers);
   res.end('hello world');
 }).on('upgrade', function(req, socket) {
   socket.end('HTTP/1.1 101 Switching protocols\r\n' +
diff --git a/test/parallel/test-http-upgrade-agent.js b/test/parallel/test-http-upgrade-agent.js
index d2969522433db1..0ea3659581c567 100644
--- a/test/parallel/test-http-upgrade-agent.js
+++ b/test/parallel/test-http-upgrade-agent.js
@@ -33,7 +33,7 @@ const net = require('net');
 // Create a TCP server
 const server = net.createServer(function(c) {
   c.on('data', function(d) {
-    c.write('HTTP/1.1 101\r\n');
+    c.write('HTTP/1.1 101 Switching Protocols\r\n');
     c.write('hello: world\r\n');
     c.write('connection: upgrade\r\n');
     c.write('upgrade: websocket\r\n');
diff --git a/test/parallel/test-http-upgrade-client.js b/test/parallel/test-http-upgrade-client.js
index fbeaf08c2c5582..2b37ab52beff1f 100644
--- a/test/parallel/test-http-upgrade-client.js
+++ b/test/parallel/test-http-upgrade-client.js
@@ -36,7 +36,7 @@ const expectedRecvData = 'nurtzo';
 // Create a TCP server
 const server = net.createServer(function(c) {
   c.on('data', function(d) {
-    c.write('HTTP/1.1 101\r\n');
+    c.write('HTTP/1.1 101 Switching Protocols\r\n');
     c.write('hello: world\r\n');
     c.write('connection: upgrade\r\n');
     c.write('upgrade: websocket\r\n');
diff --git a/test/parallel/test-http-wget.js b/test/parallel/test-http-wget.js
deleted file mode 100644
index 2ce6f6f698f538..00000000000000
--- a/test/parallel/test-http-wget.js
+++ /dev/null
@@ -1,78 +0,0 @@
-// Copyright Joyent, Inc. and other Node contributors.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a
-// copy of this software and associated documentation files (the
-// "Software"), to deal in the Software without restriction, including
-// without limitation the rights to use, copy, modify, merge, publish,
-// distribute, sublicense, and/or sell copies of the Software, and to permit
-// persons to whom the Software is furnished to do so, subject to the
-// following conditions:
-//
-// The above copyright notice and this permission notice shall be included
-// in all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
-// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
-// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
-// USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-'use strict';
-const common = require('../common');
-const assert = require('assert');
-const net = require('net');
-const http = require('http');
-
-// `wget` sends an HTTP/1.0 request with Connection: Keep-Alive
-//
-// Sending back a chunked response to an HTTP/1.0 client would be wrong,
-// so what has to happen in this case is that the connection is closed
-// by the server after the entity body if the Content-Length was not
-// sent.
-//
-// If the Content-Length was sent, we can probably safely honor the
-// keep-alive request, even though HTTP 1.0 doesn't say that the
-// connection can be kept open.  Presumably any client sending this
-// header knows that it is extending HTTP/1.0 and can handle the
-// response.  We don't test that here however, just that if the
-// content-length is not provided, that the connection is in fact
-// closed.
-
-const server = http.createServer((req, res) => {
-  res.writeHead(200, { 'Content-Type': 'text/plain' });
-  res.write('hello ');
-  res.write('world\n');
-  res.end();
-});
-server.listen(0);
-
-server.on('listening', common.mustCall(() => {
-  const c = net.createConnection(server.address().port);
-  let server_response = '';
-
-  c.setEncoding('utf8');
-
-  c.on('connect', () => {
-    c.write('GET / HTTP/1.0\r\n' +
-            'Connection: Keep-Alive\r\n\r\n');
-  });
-
-  c.on('data', (chunk) => {
-    console.log(chunk);
-    server_response += chunk;
-  });
-
-  c.on('end', common.mustCall(() => {
-    const m = server_response.split('\r\n\r\n');
-    assert.strictEqual(m[1], 'hello world\n');
-    console.log('got end');
-    c.end();
-  }));
-
-  c.on('close', common.mustCall(() => {
-    console.log('got close');
-    server.close();
-  }));
-}));
diff --git a/test/parallel/test-http2-client-http1-server.js b/test/parallel/test-http2-client-http1-server.js
index 4a7c7c0a7d59cd..f48adf3dcba96d 100644
--- a/test/parallel/test-http2-client-http1-server.js
+++ b/test/parallel/test-http2-client-http1-server.js
@@ -13,8 +13,8 @@ const { NghttpError } = require('internal/http2/util');
 // Creating an http1 server here...
 const server = http.createServer(common.mustNotCall())
   .on('clientError', common.mustCall((error, socket) => {
-    assert.strictEqual(error.code, 'HPE_PAUSED_H2_UPGRADE');
-    assert.strictEqual(error.bytesParsed, 24);
+    assert.strictEqual(error.code, 'MILO_UNSUPPORTED_HTTP_VERSION');
+    assert.strictEqual(error.bytesParsed, 11);
     socket.write('HTTP/1.1 400 No H2 support\r\n\r\n');
 
     // Don't give client a chance to send a preamble.
diff --git a/test/parallel/test-https-client-resume.js b/test/parallel/test-https-client-resume.js
index 8904e24180b329..8f9a8c3e64622e 100644
--- a/test/parallel/test-https-client-resume.js
+++ b/test/parallel/test-https-client-resume.js
@@ -50,7 +50,8 @@ server.listen(0, common.mustCall(function() {
   }, common.mustCall(() => {
     console.log('connect1');
     assert.strictEqual(client1.isSessionReused(), false);
-    client1.write('GET / HTTP/1.0\r\n' +
+    client1.write('GET / HTTP/1.1\r\n' +
+                  'Host: localhost\r\n' +
                   'Server: 127.0.0.1\r\n' +
                   '\r\n');
   }));
@@ -68,7 +69,8 @@ server.listen(0, common.mustCall(function() {
     const client2 = tls.connect(opts, common.mustCall(() => {
       console.log('connect2');
       assert.strictEqual(client2.isSessionReused(), true);
-      client2.write('GET / HTTP/1.0\r\n' +
+      client2.write('GET / HTTP/1.1\r\n' +
+                    'Host: localhost\r\n' +
                     'Server: 127.0.0.1\r\n' +
                     '\r\n');
     }));
diff --git a/test/parallel/test-https-foafssl.js b/test/parallel/test-https-foafssl.js
index d6dde97a41da9c..664bedc00528e0 100644
--- a/test/parallel/test-https-foafssl.js
+++ b/test/parallel/test-https-foafssl.js
@@ -55,7 +55,7 @@ const server = https.createServer(options, common.mustCall(function(req, res) {
   assert.strictEqual(cert.subjectaltname, webIdUrl);
   assert.strictEqual(cert.exponent, exponent);
   assert.strictEqual(cert.modulus, modulus);
-  res.writeHead(200, { 'content-type': 'text/plain' });
+  res.writeHead(200, { 'content-type': 'text/plain', 'content-length': body.length });
   res.end(body, () => { console.log('stream finished'); });
   console.log('sent response');
 }));
@@ -81,7 +81,7 @@ server.listen(0, function() {
     console.log('server.close() called');
   });
 
-  client.stdin.write('GET /\r\n\r\n');
+  client.stdin.write('GET / HTTP/1.1\r\nHost: localhost\r\n\r\n');
 
   client.on('error', function(error) {
     throw error;
diff --git a/test/parallel/test-https-insecure-parse-per-stream.js b/test/parallel/test-https-insecure-parse-per-stream.js
index 73e69d056913aa..9dc77cdab3e3f0 100644
--- a/test/parallel/test-https-insecure-parse-per-stream.js
+++ b/test/parallel/test-https-insecure-parse-per-stream.js
@@ -5,7 +5,6 @@ if (!common.hasCrypto) {
 }
 
 const fixtures = require('../common/fixtures');
-const assert = require('assert');
 const https = require('https');
 const MakeDuplexPair = require('../common/duplexpair');
 const tls = require('tls');
@@ -17,42 +16,17 @@ const certFixture = {
   ca: fixtures.readKey('ca1-cert.pem'),
 };
 
-
-// Test that setting the `insecureHTTPParse` option works on a per-stream-basis.
-
 // Test 1: The server sends an invalid header.
 {
   const { clientSide, serverSide } = MakeDuplexPair();
 
-  const req = https.request({
-    rejectUnauthorized: false,
-    createConnection: common.mustCall(() => clientSide),
-    insecureHTTPParser: true
-  }, common.mustCall((res) => {
-    assert.strictEqual(res.headers.hello, 'foo\x08foo');
-    res.resume();  // We don’t actually care about contents.
-    res.on('end', common.mustCall());
-  }));
-  req.end();
-
-  serverSide.resume();  // Dump the request
-  serverSide.end('HTTP/1.1 200 OK\r\n' +
-                 'Host: example.com\r\n' +
-                 'Hello: foo\x08foo\r\n' +
-                 'Content-Length: 0\r\n' +
-                 '\r\n\r\n');
-}
-
-// Test 2: The same as Test 1 except without the option, to make sure it fails.
-{
-  const { clientSide, serverSide } = MakeDuplexPair();
-
   const req = https.request({
     rejectUnauthorized: false,
     createConnection: common.mustCall(() => clientSide)
   }, common.mustNotCall());
-  req.end();
+
   req.on('error', common.mustCall());
+  req.end();
 
   serverSide.resume();  // Dump the request
   serverSide.end('HTTP/1.1 200 OK\r\n' +
@@ -62,40 +36,7 @@ const certFixture = {
                  '\r\n\r\n');
 }
 
-// Test 3: The client sends an invalid header.
-{
-  const testData = 'Hello, World!\n';
-  const server = https.createServer(
-    { insecureHTTPParser: true,
-      ...certFixture },
-    common.mustCall((req, res) => {
-      res.statusCode = 200;
-      res.setHeader('Content-Type', 'text/plain');
-      res.end(testData);
-    }));
-
-  server.on('clientError', common.mustNotCall());
-
-  server.listen(0, common.mustCall(() => {
-    const client = tls.connect({
-      port: server.address().port,
-      rejectUnauthorized: false
-    });
-    client.write(
-      'GET / HTTP/1.1\r\n' +
-      'Host: example.com\r\n' +
-      'Hello: foo\x08foo\r\n' +
-      '\r\n\r\n');
-    client.end();
-
-    client.on('data', () => {});
-    finished(client, common.mustCall(() => {
-      server.close();
-    }));
-  }));
-}
-
-// Test 4: The same as Test 3 except without the option, to make sure it fails.
+// Test 2: The client sends and invalid header
 {
   const server = https.createServer(
     { ...certFixture },
@@ -121,15 +62,3 @@ const certFixture = {
     }));
   }));
 }
-
-// Test 5: Invalid argument type
-{
-  assert.throws(
-    () => https.request({ insecureHTTPParser: 0 }, common.mustNotCall()),
-    common.expectsError({
-      code: 'ERR_INVALID_ARG_TYPE',
-      message: 'The "options.insecureHTTPParser" property must be of' +
-      ' type boolean. Received type number (0)'
-    })
-  );
-}
diff --git a/test/parallel/test-process-versions.js b/test/parallel/test-process-versions.js
index 31886093df8cc2..6f353681b3523b 100644
--- a/test/parallel/test-process-versions.js
+++ b/test/parallel/test-process-versions.js
@@ -15,7 +15,7 @@ const expected_keys = [
   'zlib',
   'nghttp2',
   'napi',
-  'llhttp',
+  'milo',
   'uvwasi',
   'acorn',
   'simdutf',
@@ -58,7 +58,7 @@ const commonTemplate = /^\d+\.\d+\.\d+(?:-.*)?$/;
 assert.match(process.versions.acorn, commonTemplate);
 assert.match(process.versions.ares, commonTemplate);
 assert.match(process.versions.brotli, commonTemplate);
-assert.match(process.versions.llhttp, commonTemplate);
+assert.match(process.versions.milo, commonTemplate);
 assert.match(process.versions.node, commonTemplate);
 assert.match(process.versions.uv, commonTemplate);
 assert.match(process.versions.zlib, /^\d+(?:\.\d+){2,3}(?:-.*)?$/);
diff --git a/test/parallel/test-stream-destroy.js b/test/parallel/test-stream-destroy.js
index 5269ccfec50271..aaa75fea099ee3 100644
--- a/test/parallel/test-stream-destroy.js
+++ b/test/parallel/test-stream-destroy.js
@@ -79,7 +79,7 @@ const http = require('http');
       }));
     });
 
-    req.end('asd');
+    req.end();
   });
 }
 
@@ -115,6 +115,6 @@ const http = require('http');
       }));
     });
 
-    req.end('asd');
+    req.end();
   });
 }
diff --git a/test/parallel/test-trace-events-metadata.js b/test/parallel/test-trace-events-metadata.js
index 3a86698e1f7db6..18ad0f399474c0 100644
--- a/test/parallel/test-trace-events-metadata.js
+++ b/test/parallel/test-trace-events-metadata.js
@@ -37,8 +37,8 @@ proc.once('exit', common.mustCall(() => {
       trace.name === 'node' &&
         trace.args.process.versions.http_parser ===
           process.versions.http_parser &&
-        trace.args.process.versions.llhttp ===
-          process.versions.llhttp &&
+        trace.args.process.versions.milo ===
+          process.versions.milo &&
         trace.args.process.versions.node ===
           process.versions.node &&
         trace.args.process.versions.v8 ===
diff --git a/test/sequential/test-pipe.js b/test/sequential/test-pipe.js
index c3e0ddef9fe57d..27554e699856e1 100644
--- a/test/sequential/test-pipe.js
+++ b/test/sequential/test-pipe.js
@@ -95,7 +95,7 @@ function startClient() {
 
   const req = http.request({
     port: common.PORT,
-    method: 'GET',
+    method: 'POST',
     path: '/',
     headers: { 'content-length': buffer.length }
   }, common.mustCall((res) => {
diff --git a/tools/dep_updaters/update-llhttp.sh b/tools/dep_updaters/update-llhttp.sh
deleted file mode 100755
index c9462748775287..00000000000000
--- a/tools/dep_updaters/update-llhttp.sh
+++ /dev/null
@@ -1,80 +0,0 @@
-#!/bin/sh
-set -e
-
-# Shell script to update llhttp in the source tree to specific version
-
-BASE_DIR=$(cd "$(dirname "$0")/../.." && pwd)
-DEPS_DIR="${BASE_DIR}/deps"
-
-[ -z "$NODE" ] && NODE="$BASE_DIR/out/Release/node"
-[ -x "$NODE" ] || NODE=$(command -v node)
-
-# shellcheck disable=SC1091
-. "$BASE_DIR/tools/dep_updaters/utils.sh"
-
-NEW_VERSION="$("$NODE" --input-type=module <<'EOF'
-const res = await fetch('https://api.github.com/repos/nodejs/llhttp/releases/latest',
-  process.env.GITHUB_TOKEN && {
-    headers: {
-      "Authorization": `Bearer ${process.env.GITHUB_TOKEN}`
-    },
-  });
-if (!res.ok) throw new Error(`FetchError: ${res.status} ${res.statusText}`, { cause: res });
-const { tag_name } = await res.json();
-console.log(tag_name.replace('release/v', ''));
-EOF
-)"
-
-CURRENT_MAJOR_VERSION=$(grep "#define LLHTTP_VERSION_MAJOR" ./deps/llhttp/include/llhttp.h | sed -n "s/^.*MAJOR \(.*\)/\1/p")
-CURRENT_MINOR_VERSION=$(grep "#define LLHTTP_VERSION_MINOR" ./deps/llhttp/include/llhttp.h | sed -n "s/^.*MINOR \(.*\)/\1/p")
-CURRENT_PATCH_VERSION=$(grep "#define LLHTTP_VERSION_PATCH" ./deps/llhttp/include/llhttp.h | sed -n "s/^.*PATCH \(.*\)/\1/p")
-CURRENT_VERSION="$CURRENT_MAJOR_VERSION.$CURRENT_MINOR_VERSION.$CURRENT_PATCH_VERSION"
-
-# This function exit with 0 if new version and current version are the same
-compare_dependency_version "llhttp" "$NEW_VERSION" "$CURRENT_VERSION"
-
-cleanup () {
-  EXIT_CODE=$?
-  [ -d "$WORKSPACE" ] && rm -rf "$WORKSPACE"
-  exit $EXIT_CODE
-}
-
-echo "Making temporary workspace ..."
-WORKSPACE=$(mktemp -d 2> /dev/null || mktemp -d -t 'tmp')
-trap cleanup INT TERM EXIT
-
-cd "$WORKSPACE"
-
-if echo "$NEW_VERSION" | grep -qs "/" ; then # Download a release
-  REPO="git@github.com:$NEW_VERSION.git"
-  BRANCH=$2
-  [ -z "$BRANCH" ] && BRANCH=main
-
-  echo "Cloning llhttp source archive $REPO ..."
-  git clone "$REPO" llhttp
-  cd llhttp
-  echo "Checking out branch $BRANCH ..."
-  git checkout "$BRANCH"
-
-  echo "Building llhttp ..."
-  npm install
-  make release
-
-  echo "Copying llhttp release ..."
-  rm -rf "$DEPS_DIR/llhttp"
-  cp -a release "$DEPS_DIR/llhttp"
-else
-  echo "Download llhttp release $NEW_VERSION ..."
-  LLHTTP_TARBALL="llhttp-v$NEW_VERSION.tar.gz"
-  curl -sL -o "$LLHTTP_TARBALL" "https://github.com/nodejs/llhttp/archive/refs/tags/release/v$NEW_VERSION.tar.gz"
-  gzip -dc "$LLHTTP_TARBALL" | tar xf -
-
-  echo "Copying llhttp release ..."
-  rm -rf "$DEPS_DIR/llhttp"
-  cp -a "llhttp-release-v$NEW_VERSION" "$DEPS_DIR/llhttp"
-fi
-
-# Update the version number on maintaining-dependencies.md
-# and print the new version as the last line of the script as we need
-# to add it to $GITHUB_ENV variable
-finalize_version_update "llhttp" "$NEW_VERSION"
diff --git a/tools/dep_updaters/update-milo.sh b/tools/dep_updaters/update-milo.sh
new file mode 100755
index 00000000000000..a97ecb9e216a8f
--- /dev/null
+++ b/tools/dep_updaters/update-milo.sh
@@ -0,0 +1,61 @@
+#!/bin/sh
+set -e
+
+# Shell script to update llhttp in the source tree to specific version
+
+BASE_DIR=$(cd "$(dirname "$0")/../.." && pwd)
+DEPS_DIR="${BASE_DIR}/deps"
+
+[ -z "$NODE" ] && NODE="$BASE_DIR/out/Release/node"
+[ -x "$NODE" ] || NODE=$(command -v node)
+
+# shellcheck disable=SC1091
+. "$BASE_DIR/tools/dep_updaters/utils.sh"
+
+NEW_VERSION="$("$NODE" --input-type=module <<'EOF'
+const res = await fetch('https://api.github.com/repos/ShogunPanda/milo/releases/latest',
+  process.env.GITHUB_TOKEN && {
+    headers: {
+      "Authorization": `Bearer ${process.env.GITHUB_TOKEN}`
+    },
+  });
+if (!res.ok) throw new Error(`FetchError: ${res.status} ${res.statusText}`, { cause: res });
+const { tag_name } = await res.json();
+console.log(tag_name.replace('release/v', ''));
+EOF
+)"
+
+CURRENT_VERSION=$(grep "#define MILO_VERSION" ./deps/milo/milo.h | sed -n "s/^.*VERSION \"\(.*\)\"/\1/p")
+
+# This function exit with 0 if new version and current version are the same
+compare_dependency_version "milo" "$NEW_VERSION" "$CURRENT_VERSION"
+
+cleanup () {
+  EXIT_CODE=$?
+  [ -d "$WORKSPACE" ] && rm -rf "$WORKSPACE"
+  exit $EXIT_CODE
+}
+
+echo "Making temporary workspace ..."
+WORKSPACE=$(mktemp -d 2> /dev/null || mktemp -d -t 'tmp')
+trap cleanup INT TERM EXIT
+
+cd "$WORKSPACE"
+
+MILO_REF="v$NEW_VERSION"
+MILO_ZIP="milo-${MILO_REF}.zip"
+
+echo "Fetching milo archive ..."
+curl -sL -o "$MILO_ZIP" "https://github.com/ShogunPanda/milo/releases/download/$MILO_ZIP"
+log_and_verify_sha256sum "milo" "$MILO_ZIP"
+unzip "$MILO_ZIP"
+rm "$MILO_ZIP"
+
+echo "Copying milo release ..."
+rm -rf "$DEPS_DIR/milo"
+mv "$WORKSPACE" "$DEPS_DIR/milo"
+
+# Update the version number on maintaining-dependencies.md
+# and print the new version as the last line of the script as we need
+# to add it to $GITHUB_ENV variable
+finalize_version_update "milo" "$NEW_VERSION"
diff --git a/tools/license-builder.sh b/tools/license-builder.sh
index 10b894262946ea..023ff01ac466ce 100755
--- a/tools/license-builder.sh
+++ b/tools/license-builder.sh
@@ -61,8 +61,8 @@ fi
 
 licenseText="$(cat "${rootdir}/deps/uv/LICENSE" "${rootdir}/deps/uv/LICENSE-extra")"
 addlicense "libuv" "deps/uv" "$licenseText"
-licenseText="$(cat deps/llhttp/LICENSE-MIT)"
-addlicense "llhttp" "deps/llhttp" "$licenseText"
+licenseText="$(cat deps/milo/LICENSE-MIT)"
+addlicense "milo" "deps/milo" "$licenseText"
 licenseText="$(cat "${rootdir}/deps/corepack/LICENSE.md")"
 addlicense "corepack" "deps/corepack" "$licenseText"
 licenseText="$(cat "${rootdir}/deps/undici/LICENSE")"
diff --git a/typings/internalBinding/http_parser.d.ts b/typings/internalBinding/http_parser.d.ts
index 5ab5651b637176..9a3cd3d71a50cc 100644
--- a/typings/internalBinding/http_parser.d.ts
+++ b/typings/internalBinding/http_parser.d.ts
@@ -1,6 +1,6 @@
 declare namespace InternalHttpParserBinding {
-  type Buffer = Uint8Array;
-  type Stream = object;
+  type Buffer: Uint8Array;
+  type Stream: object;
 
   class HTTPParser {
     static REQUEST: 1;
@@ -10,9 +10,10 @@ declare namespace InternalHttpParserBinding {
     static kOnHeaders: 1;
     static kOnHeadersComplete: 2;
     static kOnBody: 3;
-    static kOnMessageComplete: 4;
-    static kOnExecute: 5;
-    static kOnTimeout: 6;
+    static kOnTrailers: 4;
+    static kOnTrailersComplete: 5;
+    static kOnMessageComplete: 6;
+    static kOnExecute: 7;
 
     static kLenientNone: number;
     static kLenientHeaders: number;
@@ -22,7 +23,7 @@ declare namespace InternalHttpParserBinding {
 
     close(): void;
     free(): void;
-    execute(buffer: Buffer): Error | Buffer;
+    execute(buffer: Buffer, skip: number, limit: number): Error | Buffer;
     finish(): Error | Buffer;
     initialize(
       type: number,
@@ -36,6 +37,10 @@ declare namespace InternalHttpParserBinding {
     consume(stream: Stream): void;
     unconsume(): void;
     getCurrentBuffer(): Buffer;
+    duration(): number;
+    headersCompleted(): boolean;
+    trailersCompleted(): boolean
+  
   }
 }