From 08eeddfa8391fb8c085eb2d23ca155a9ae492d58 Mon Sep 17 00:00:00 2001
From: Rich Trott <rtrott@gmail.com>
Date: Thu, 23 Jan 2025 20:38:49 -0800
Subject: [PATCH 01/38] test: enforce strict mode in test-zlib-const
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Instead of checking that assignments fail silently in sloppy mode, check
that they throw in strict mode.

PR-URL: https://github.com/nodejs/node/pull/56689
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 test/parallel/test-zlib-const.js | 28 +++++++++-------------------
 1 file changed, 9 insertions(+), 19 deletions(-)

diff --git a/test/parallel/test-zlib-const.js b/test/parallel/test-zlib-const.js
index 342c8c712a475b..5b9a127f0eaa02 100644
--- a/test/parallel/test-zlib-const.js
+++ b/test/parallel/test-zlib-const.js
@@ -1,4 +1,4 @@
-/* eslint-disable strict */
+'use strict';
 require('../common');
 const assert = require('assert');
 
@@ -9,27 +9,17 @@ assert.strictEqual(zlib.constants.Z_OK, 0,
                      'Expected Z_OK to be 0;',
                      `got ${zlib.constants.Z_OK}`,
                    ].join(' '));
-zlib.constants.Z_OK = 1;
-assert.strictEqual(zlib.constants.Z_OK, 0,
-                   [
-                     'Z_OK should be immutable.',
-                     `Expected to get 0, got ${zlib.constants.Z_OK}`,
-                   ].join(' '));
+
+assert.throws(() => { zlib.constants.Z_OK = 1; },
+              TypeError, 'zlib.constants.Z_OK should be immutable');
 
 assert.strictEqual(zlib.codes.Z_OK, 0,
                    `Expected Z_OK to be 0; got ${zlib.codes.Z_OK}`);
-zlib.codes.Z_OK = 1;
-assert.strictEqual(zlib.codes.Z_OK, 0,
-                   [
-                     'Z_OK should be immutable.',
-                     `Expected to get 0, got ${zlib.codes.Z_OK}`,
-                   ].join(' '));
-zlib.codes = { Z_OK: 1 };
-assert.strictEqual(zlib.codes.Z_OK, 0,
-                   [
-                     'Z_OK should be immutable.',
-                     `Expected to get 0, got ${zlib.codes.Z_OK}`,
-                   ].join(' '));
+assert.throws(() => { zlib.codes.Z_OK = 1; },
+              TypeError, 'zlib.codes.Z_OK should be immutable');
+
+assert.throws(() => { zlib.codes = { Z_OK: 1 }; },
+              TypeError, 'zlib.codes should be immutable');
 
 assert.ok(Object.isFrozen(zlib.codes),
           [

From e55b02b368d479bdd27eea4aa67ecdfa62ebd7bd Mon Sep 17 00:00:00 2001
From: Aviv Keller <telavivkeller@gmail.com>
Date: Fri, 24 Jan 2025 05:44:05 -0500
Subject: [PATCH 02/38] build: drop support for python 3.8

PR-URL: https://github.com/nodejs/node/pull/55239
Reviewed-By: Christian Clauss <cclauss@me.com>
---
 android-configure | 3 +--
 configure         | 3 +--
 configure.py      | 2 +-
 pyproject.toml    | 2 +-
 4 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/android-configure b/android-configure
index fb237241d7413d..2558f52757e442 100755
--- a/android-configure
+++ b/android-configure
@@ -9,7 +9,6 @@ command -v python3.12 >/dev/null && exec python3.12 "$0" "$@"
 command -v python3.11 >/dev/null && exec python3.11 "$0" "$@"
 command -v python3.10 >/dev/null && exec python3.10 "$0" "$@"
 command -v python3.9 >/dev/null && exec python3.9 "$0" "$@"
-command -v python3.8 >/dev/null && exec python3.8 "$0" "$@"
 command -v python3 >/dev/null && exec python3 "$0" "$@"
 exec python "$0" "$@"
 ''' "$0" "$@"
@@ -23,7 +22,7 @@ except ImportError:
   from distutils.spawn import find_executable as which
 
 print('Node.js android configure: Found Python {}.{}.{}...'.format(*sys.version_info))
-acceptable_pythons = ((3, 13), (3, 12), (3, 11), (3, 10), (3, 9), (3, 8))
+acceptable_pythons = ((3, 13), (3, 12), (3, 11), (3, 10), (3, 9))
 if sys.version_info[:2] in acceptable_pythons:
   import android_configure
 else:
diff --git a/configure b/configure
index 56720e8f4c42d9..412f0b416e79c3 100755
--- a/configure
+++ b/configure
@@ -9,7 +9,6 @@ command -v python3.12 >/dev/null && exec python3.12 "$0" "$@"
 command -v python3.11 >/dev/null && exec python3.11 "$0" "$@"
 command -v python3.10 >/dev/null && exec python3.10 "$0" "$@"
 command -v python3.9 >/dev/null && exec python3.9 "$0" "$@"
-command -v python3.8 >/dev/null && exec python3.8 "$0" "$@"
 command -v python3 >/dev/null && exec python3 "$0" "$@"
 exec python "$0" "$@"
 ''' "$0" "$@"
@@ -23,7 +22,7 @@ except ImportError:
   from distutils.spawn import find_executable as which
 
 print('Node.js configure: Found Python {}.{}.{}...'.format(*sys.version_info))
-acceptable_pythons = ((3, 13), (3, 12), (3, 11), (3, 10), (3, 9), (3, 8))
+acceptable_pythons = ((3, 13), (3, 12), (3, 11), (3, 10), (3, 9))
 if sys.version_info[:2] in acceptable_pythons:
   import configure
 else:
diff --git a/configure.py b/configure.py
index c361676637c1cb..618117370238f7 100755
--- a/configure.py
+++ b/configure.py
@@ -2143,7 +2143,7 @@ def make_bin_override():
   if sys.platform == 'win32':
     raise Exception('make_bin_override should not be called on win32.')
   # If the system python is not the python we are running (which should be
-  # python 3.8+), then create a directory with a symlink called `python` to our
+  # python 3.9+), then create a directory with a symlink called `python` to our
   # sys.executable. This directory will be prefixed to the PATH, so that
   # other tools that shell out to `python` will use the appropriate python
 
diff --git a/pyproject.toml b/pyproject.toml
index 45f540bd15170d..43da73beceee7a 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -7,7 +7,7 @@ exclude = [
   "tools/eslint/node_modules"
 ]
 line-length = 172
-target-version = "py38"
+target-version = "py39"
 
 [tool.ruff.lint]
 select = [

From 1921371349c15d31b0b6884225a2093f0925a3d7 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Fri, 24 Jan 2025 15:22:12 +0100
Subject: [PATCH 03/38] tools: do not throw on missing
 `create-release-proposal.sh`

PR-URL: https://github.com/nodejs/node/pull/56704
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Tierney Cyren <hello@bnb.im>
Reviewed-By: Rafael Gonzaga <rafael.nunu@hotmail.com>
---
 .github/workflows/create-release-proposal.yml | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/create-release-proposal.yml b/.github/workflows/create-release-proposal.yml
index 33426bdcda4a5b..0b580eab81ac76 100644
--- a/.github/workflows/create-release-proposal.yml
+++ b/.github/workflows/create-release-proposal.yml
@@ -71,13 +71,10 @@ jobs:
           git config --local user.name "Node.js GitHub Bot"
 
       - name: Start git node release prepare
-        # `git update-index` tells git to ignore future changes to the `.sh` file,
-        # `|| true` is there to ignore the error if such file doesn't exist yet.
         # The curl command is to make sure we run the version of the script corresponding to the current workflow.
         run: |
-          git update-index --assume-unchanged tools/actions/create-release-proposal.sh || true
-          curl -fsSLo tools/actions/create-release-proposal.sh https://github.com/${GITHUB_REPOSITORY}/raw/${GITHUB_SHA}/tools/actions/create-release-proposal.sh
-          ./tools/actions/create-release-proposal.sh "${RELEASE_DATE}" "${RELEASE_LINE}" "${GITHUB_ACTOR}"
+          curl -fsSL https://github.com/${GITHUB_REPOSITORY}/raw/${GITHUB_SHA}/tools/actions/create-release-proposal.sh |\
+          sh -s -- "${RELEASE_DATE}" "${RELEASE_LINE}" "${GITHUB_ACTOR}"
         env:
           GH_TOKEN: ${{ github.token }}
           # We want the bot to push the push the release commit so CI runs on it.

From 19fabc0e3175d73e5b4c8acab66dd5424372ff55 Mon Sep 17 00:00:00 2001
From: Jordan Harband <ljharb@gmail.com>
Date: Sun, 12 Jan 2025 13:04:40 -0800
Subject: [PATCH 04/38] util: inspect: do not crash on an Error stack that
 contains a Symbol

See #56570

PR-URL: https://github.com/nodejs/node/pull/56573
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Jason Zhang <xzha4350@gmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
---
 lib/internal/util/inspect.js       | 14 ++++++++++----
 test/parallel/test-util-inspect.js | 20 ++++++++++++++++----
 2 files changed, 26 insertions(+), 8 deletions(-)

diff --git a/lib/internal/util/inspect.js b/lib/internal/util/inspect.js
index 60bee498e5ea8b..f38eecba6ae5fb 100644
--- a/lib/internal/util/inspect.js
+++ b/lib/internal/util/inspect.js
@@ -1287,8 +1287,14 @@ function identicalSequenceRange(a, b) {
   return { len: 0, offset: 0 };
 }
 
-function getStackString(error) {
-  return error.stack ? String(error.stack) : ErrorPrototypeToString(error);
+function getStackString(ctx, error) {
+  if (error.stack) {
+    if (typeof error.stack === 'string') {
+      return error.stack;
+    }
+    return formatValue(ctx, error.stack);
+  }
+  return ErrorPrototypeToString(error);
 }
 
 function getStackFrames(ctx, err, stack) {
@@ -1303,7 +1309,7 @@ function getStackFrames(ctx, err, stack) {
 
   // Remove stack frames identical to frames in cause.
   if (cause != null && isError(cause)) {
-    const causeStack = getStackString(cause);
+    const causeStack = getStackString(ctx, cause);
     const causeStackStart = StringPrototypeIndexOf(causeStack, '\n    at');
     if (causeStackStart !== -1) {
       const causeFrames = StringPrototypeSplit(StringPrototypeSlice(causeStack, causeStackStart + 1), '\n');
@@ -1426,7 +1432,7 @@ function safeGetCWD() {
 
 function formatError(err, constructor, tag, ctx, keys) {
   const name = err.name != null ? err.name : 'Error';
-  let stack = getStackString(err);
+  let stack = getStackString(ctx, err);
 
   removeDuplicateErrorKeys(ctx, keys, err, stack);
 
diff --git a/test/parallel/test-util-inspect.js b/test/parallel/test-util-inspect.js
index 0b04e3b8dc7179..87d92369b8deca 100644
--- a/test/parallel/test-util-inspect.js
+++ b/test/parallel/test-util-inspect.js
@@ -777,16 +777,18 @@ assert.strictEqual(util.inspect(-5e-324), '-5e-324');
   [undefined, 'RangeError: foo', '[RangeError: foo]'],
   [false, 'false [RangeError]: foo', '[RangeError: foo]'],
   ['', 'foo', '[RangeError: foo]'],
-  [[1, 2, 3], '1,2,3 [RangeError]: foo', '[1,2,3]'],
+  [[1, 2, 3], '1,2,3 [RangeError]: foo', '[[\n  1,\n  2,\n  3\n]]'],
 ].forEach(([value, outputStart, stack]) => {
   let err = new RangeError('foo');
   err.name = value;
+  const result = util.inspect(err);
   assert(
-    util.inspect(err).startsWith(outputStart),
+    result.startsWith(outputStart),
     util.format(
-      'The name set to %o did not result in the expected output "%s"',
+      'The name set to %o did not result in the expected output "%s", got "%s"',
       value,
-      outputStart
+      outputStart,
+      result.split('\n')[0]
     )
   );
 
@@ -3448,3 +3450,13 @@ assert.strictEqual(
 ${error.stack.split('\n').slice(1).join('\n')}`,
   );
 }
+
+{
+  const error = new Error();
+  error.stack = [Symbol('foo')];
+
+  assert.strictEqual(
+    inspect(error),
+    '[[\n  Symbol(foo)\n]]'
+  );
+}

From 01a5aa2ac10c051336e8ad4062b87f73a4d7824e Mon Sep 17 00:00:00 2001
From: Jonas <jonas@badalic.com>
Date: Fri, 24 Jan 2025 11:22:54 -0500
Subject: [PATCH 05/38] test: add missing test for env file

PR-URL: https://github.com/nodejs/node/pull/56642
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Jake Yuesong Li <jake.yuesong@gmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 test/parallel/test-dotenv-edge-cases.js | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/test/parallel/test-dotenv-edge-cases.js b/test/parallel/test-dotenv-edge-cases.js
index 769d33a13b8ce9..926c8d0793ac8b 100644
--- a/test/parallel/test-dotenv-edge-cases.js
+++ b/test/parallel/test-dotenv-edge-cases.js
@@ -170,4 +170,16 @@ describe('.env supports edge cases', () => {
     assert.strictEqual(SingleQuotesChild.stderr, '');
     assert.strictEqual(SingleQuotesChild.code, 0);
   });
+
+  it('should reject invalid env file flag', async () => {
+    const child = await common.spawnPromisified(
+      process.execPath,
+      ['--env-file-ABCD', validEnvFilePath],
+      { cwd: __dirname },
+    );
+
+    assert.strictEqual(child.stdout, '');
+    assert.strictEqual(child.code, 9);
+    assert.match(child.stderr, /bad option: --env-file-ABCD/);
+  });
 });

From c752615e2bbea73ec59de0439c997d334577fdae Mon Sep 17 00:00:00 2001
From: Pietro Marchini <pietro.marchini94@gmail.com>
Date: Sun, 19 Jan 2025 23:57:49 +0100
Subject: [PATCH 06/38] test_runner: print failing assertion only once with
 spec reporter

Co-authored-by: Llorx <dallorx@gmail.com>
PR-URL: https://github.com/nodejs/node/pull/56662
Reviewed-By: Chengzhong Wu <legendecas@gmail.com>
Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 lib/internal/test_runner/reporter/spec.js     |   2 +-
 lib/internal/test_runner/reporter/utils.js    |   6 +-
 .../output/assertion-color-tty.snapshot       |  12 -
 .../output/default_output.snapshot            |  23 --
 .../test-runner/output/eval_spec.snapshot     |   9 -
 .../output/hooks_spec_reporter.snapshot       | 311 ------------------
 .../test-runner/output/spec_reporter.snapshot | 212 ------------
 .../output/spec_reporter_cli.snapshot         | 212 ------------
 8 files changed, 5 insertions(+), 782 deletions(-)

diff --git a/lib/internal/test_runner/reporter/spec.js b/lib/internal/test_runner/reporter/spec.js
index 2092d22e3fe77f..caee92a7ba13e1 100644
--- a/lib/internal/test_runner/reporter/spec.js
+++ b/lib/internal/test_runner/reporter/spec.js
@@ -52,7 +52,7 @@ class SpecReporter extends Transform {
       hasChildren = true;
     }
     const indentation = indent(data.nesting);
-    return `${formatTestReport(type, data, prefix, indentation, hasChildren)}\n`;
+    return `${formatTestReport(type, data, prefix, indentation, hasChildren, false)}\n`;
   }
   #handleEvent({ type, data }) {
     switch (type) {
diff --git a/lib/internal/test_runner/reporter/utils.js b/lib/internal/test_runner/reporter/utils.js
index 9b6cc96a185a9a..256619039e8e90 100644
--- a/lib/internal/test_runner/reporter/utils.js
+++ b/lib/internal/test_runner/reporter/utils.js
@@ -59,7 +59,7 @@ function formatError(error, indent) {
   return `\n${indent}  ${message}\n`;
 }
 
-function formatTestReport(type, data, prefix = '', indent = '', hasChildren = false) {
+function formatTestReport(type, data, prefix = '', indent = '', hasChildren = false, showErrorDetails = true) {
   let color = reporterColorMap[type] ?? colors.white;
   let symbol = reporterUnicodeSymbolMap[type] ?? ' ';
   const { skip, todo } = data;
@@ -71,10 +71,12 @@ function formatTestReport(type, data, prefix = '', indent = '', hasChildren = fa
   } else if (todo !== undefined) {
     title += ` # ${typeof todo === 'string' && todo.length ? todo : 'TODO'}`;
   }
-  const error = formatError(data.details?.error, indent);
+
+  const error = showErrorDetails ? formatError(data.details?.error, indent) : '';
   const err = hasChildren ?
     (!error || data.details?.error?.failureType === 'subtestsFailed' ? '' : `\n${error}`) :
     error;
+
   if (skip !== undefined) {
     color = colors.gray;
     symbol = reporterUnicodeSymbolMap['hyphen:minus'];
diff --git a/test/fixtures/test-runner/output/assertion-color-tty.snapshot b/test/fixtures/test-runner/output/assertion-color-tty.snapshot
index 2909d909351743..a74016febc5df4 100644
--- a/test/fixtures/test-runner/output/assertion-color-tty.snapshot
+++ b/test/fixtures/test-runner/output/assertion-color-tty.snapshot
@@ -1,16 +1,4 @@
 [31m✖ failing assertion [90m(*ms)[39m[39m
-  [AssertionError [ERR_ASSERTION]: Expected values to be strictly equal:
-  [32mactual[39m [31mexpected[39m
-  
-  [39m'[39m[32m![39m[39mH[39m[39me[39m[39ml[39m[39ml[39m[39mo[39m[39m [39m[39mW[39m[39mo[39m[39mr[39m[39ml[39m[39md[39m[31m![39m[39m'[39m
-  ] {
-    generatedMessage: [33mtrue[39m,
-    code: [32m'ERR_ASSERTION'[39m,
-    actual: [32m'!Hello World'[39m,
-    expected: [32m'Hello World!'[39m,
-    operator: [32m'strictEqual'[39m
-  }
-
 [34mℹ tests 1[39m
 [34mℹ suites 0[39m
 [34mℹ pass 0[39m
diff --git a/test/fixtures/test-runner/output/default_output.snapshot b/test/fixtures/test-runner/output/default_output.snapshot
index 73bfc1da5e92e9..d0a83395733924 100644
--- a/test/fixtures/test-runner/output/default_output.snapshot
+++ b/test/fixtures/test-runner/output/default_output.snapshot
@@ -1,32 +1,9 @@
 [32m✔ should pass [90m(*ms)[39m[39m
 [31m✖ should fail [90m(*ms)[39m[39m
-  Error: fail
-      *[39m
-  *[39m
-  *[39m
-  *[39m
-  *[39m
-  *[39m
-  *[39m
-
 [90m﹣ should skip [90m(*ms)[39m # SKIP[39m
 ▶ parent
   [31m✖ should fail [90m(*ms)[39m[39m
-    Error: fail
-        *[39m
-    *[39m
-    *[39m
-    *[39m
-    *[39m
-        *[39m
-    *[39m
-    *[39m
-    *[39m
-    *[39m
-
   [31m✖ should pass but parent fail [90m(*ms)[39m[39m
-    [32m'test did not finish before its parent and was cancelled'[39m
-
 [31m✖ parent [90m(*ms)[39m[39m
 [34mℹ tests 6[39m
 [34mℹ suites 0[39m
diff --git a/test/fixtures/test-runner/output/eval_spec.snapshot b/test/fixtures/test-runner/output/eval_spec.snapshot
index 5c9a53009508e1..116c23ccf97077 100644
--- a/test/fixtures/test-runner/output/eval_spec.snapshot
+++ b/test/fixtures/test-runner/output/eval_spec.snapshot
@@ -1,14 +1,5 @@
 ✔ passes (*ms)
 ✖ fails (*ms)
-  Error: fail
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-
 ℹ tests 2
 ℹ suites 0
 ℹ pass 1
diff --git a/test/fixtures/test-runner/output/hooks_spec_reporter.snapshot b/test/fixtures/test-runner/output/hooks_spec_reporter.snapshot
index ea916c2ee754c4..8c267672b9a951 100644
--- a/test/fixtures/test-runner/output/hooks_spec_reporter.snapshot
+++ b/test/fixtures/test-runner/output/hooks_spec_reporter.snapshot
@@ -10,161 +10,29 @@
  describe hooks - no subtests (*ms)
  before throws
    1
-    'test did not finish before its parent and was cancelled'
-
    2
-    'test did not finish before its parent and was cancelled'
-
  before throws (*ms)
-
-  Error: before
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-
  before throws - no subtests (*ms)
-  Error: before
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-
  after throws
    1 (*ms)
    2 (*ms)
  after throws (*ms)
-
-  Error: after
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-
  after throws - no subtests (*ms)
-  Error: after
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-
  beforeEach throws
    1 (*ms)
-    Error: beforeEach
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        at new Promise (<anonymous>)
-
    2 (*ms)
-    Error: beforeEach
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        at async Promise.all (index 0)
-
  beforeEach throws (*ms)
  afterEach throws
    1 (*ms)
-    Error: afterEach
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        at async Promise.all (index 0)
-        *
-
    2 (*ms)
-    Error: afterEach
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-
  afterEach throws (*ms)
  afterEach when test fails
    1 (*ms)
-    Error: test
-        *
-        *
-        *
-        *
-        *
-        *
-        at new Promise (<anonymous>)
-        *
-        *
-        at Array.map (<anonymous>)
-
    2 (*ms)
  afterEach when test fails (*ms)
  afterEach throws and test fails
    1 (*ms)
-    Error: test
-        *
-        *
-        *
-        *
-        *
-        *
-        at new Promise (<anonymous>)
-        *
-        *
-        at Array.map (<anonymous>)
-
    2 (*ms)
-    Error: afterEach
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-
  afterEach throws and test fails (*ms)
  test hooks
    1 (*ms)
@@ -177,155 +45,24 @@
  test hooks - no subtests (*ms)
  t.before throws
    1 (*ms)
-    Error: before
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-
    2 (*ms)
-    Error: before
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-
  t.before throws (*ms)
-
-  Error: before
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-
  t.before throws - no subtests (*ms)
-  Error: before
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-
  t.after throws
    1 (*ms)
    2 (*ms)
  t.after throws (*ms)
-
-  Error: after
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-
  t.after throws - no subtests (*ms)
-  Error: after
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-
  t.beforeEach throws
    1 (*ms)
-    Error: beforeEach
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-
    2 (*ms)
-    Error: beforeEach
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-
  t.beforeEach throws (*ms)
  t.afterEach throws
    1 (*ms)
-    Error: afterEach
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-
    2 (*ms)
-    Error: afterEach
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-
  t.afterEach throws (*ms)
  afterEach when test fails
    1 (*ms)
-    Error: test
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-
    2 (*ms)
  afterEach when test fails (*ms)
  afterEach context when test passes
@@ -333,64 +70,16 @@
  afterEach context when test passes (*ms)
  afterEach context when test fails
    1 (*ms)
-    Error: test
-        *
-        *
-        *
-        *
-
  afterEach context when test fails (*ms)
  afterEach throws and test fails
    1 (*ms)
-    Error: test
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-
    2 (*ms)
-    Error: afterEach
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-
  afterEach throws and test fails (*ms)
  t.after() is called if test body throws (*ms)
-  Error: bye
-      *
-      *
-      *
-      *
-
  - after() called
  run after when before throws
    1
-    'test did not finish before its parent and was cancelled'
-
  run after when before throws (*ms)
-
-  Error: before
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-
  test hooks - async
    1 (*ms)
    2 (*ms)
diff --git a/test/fixtures/test-runner/output/spec_reporter.snapshot b/test/fixtures/test-runner/output/spec_reporter.snapshot
index f3aebbd7fe5aae..1892069327f92d 100644
--- a/test/fixtures/test-runner/output/spec_reporter.snapshot
+++ b/test/fixtures/test-runner/output/spec_reporter.snapshot
@@ -1,91 +1,19 @@
  sync pass todo (*ms) # TODO
  sync pass todo with message (*ms) # this is a passing todo
  sync fail todo (*ms) # TODO
-  Error: thrown from sync fail todo
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-
  sync fail todo with message (*ms) # this is a failing todo
-  Error: thrown from sync fail todo with message
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-
  sync skip pass (*ms) # SKIP
  sync skip pass with message (*ms) # this is skipped
  sync pass (*ms)
  this test should pass
  sync throw fail (*ms)
-  Error: thrown from sync throw fail
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-
  async skip pass (*ms) # SKIP
  async pass (*ms)
  async throw fail (*ms)
-  Error: thrown from async throw fail
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-
  async skip fail (*ms) # SKIP
-  Error: thrown from async throw fail
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-
  async assertion fail (*ms)
-  AssertionError [ERR_ASSERTION]: Expected values to be strictly equal:
-  
-  true !== false
-  
-      *
-      *
-      *
-      *
-      *
-      *
-      * {
-    generatedMessage: true,
-    code: 'ERR_ASSERTION',
-    actual: true,
-    expected: false,
-    operator: 'strictEqual'
-  }
-
  resolve pass (*ms)
  reject fail (*ms)
-  Error: rejected from reject fail
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-
  unhandled rejection - passes but warns (*ms)
  async unhandled rejection - passes but warns (*ms)
  immediate throw - passes but warns (*ms)
@@ -93,23 +21,9 @@
  immediate resolve pass (*ms)
  subtest sync throw fail
    +sync throw fail (*ms)
-    Error: thrown from subtest sync throw fail
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-
    this subtest should make its parent test fail
  subtest sync throw fail (*ms)
  sync throw non-error fail (*ms)
-  Symbol(thrown symbol from sync throw non-error fail)
-
  level 0a
    level 1a (*ms)
    level 1b (*ms)
@@ -118,8 +32,6 @@
  level 0a (*ms)
  top level
    +long running (*ms)
-    'test did not finish before its parent and was cancelled'
-
    +short running
      ++short running (*ms)
    +short running (*ms)
@@ -128,15 +40,6 @@
  sync skip option (*ms) # SKIP
  sync skip option with message (*ms) # this is skipped
  sync skip option is false fail (*ms)
-  Error: this should be executed
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-
  <anonymous> (*ms)
  functionOnly (*ms)
  <anonymous> (*ms)
@@ -147,43 +50,15 @@
  functionAndOptions (*ms) # SKIP
  callback pass (*ms)
  callback fail (*ms)
-  Error: callback failure
-      *
-      *
-
  sync t is this in test (*ms)
  async t is this in test (*ms)
  callback t is this in test (*ms)
  callback also returns a Promise (*ms)
-  'passed a callback but also returned a Promise'
-
  callback throw (*ms)
-  Error: thrown from callback throw
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-
  callback called twice (*ms)
-  'callback invoked multiple times'
-
  callback called twice in different ticks (*ms)
  callback called twice in future tick (*ms)
-  Error [ERR_TEST_FAILURE]: callback invoked multiple times
-      * {
-    code: 'ERR_TEST_FAILURE',
-    failureType: 'multipleCallbackInvocations',
-    cause: 'callback invoked multiple times'
-  }
-
  callback async throw (*ms)
-  Error: thrown from callback async throw
-      *
-      *
-
  callback async throw after done (*ms)
  only is set on subtests but not in only mode
    running subtest 1 (*ms)
@@ -191,108 +66,21 @@
    running subtest 4 (*ms)
  only is set on subtests but not in only mode (*ms)
  custom inspect symbol fail (*ms)
-  customized
-
  custom inspect symbol that throws fail (*ms)
-  { foo: 1, Symbol(nodejs.util.inspect.custom): [Function: [nodejs.util.inspect.custom]] }
-
  subtest sync throw fails
    sync throw fails at first (*ms)
-    Error: thrown from subtest sync throw fails at first
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-
    sync throw fails at second (*ms)
-    Error: thrown from subtest sync throw fails at second
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-
  subtest sync throw fails (*ms)
  timed out async test (*ms)
-  'test timed out after *ms'
-
  timed out callback test (*ms)
-  'test timed out after *ms'
-
  large timeout async test is ok (*ms)
  large timeout callback test is ok (*ms)
  successful thenable (*ms)
  rejected thenable (*ms)
-  'custom error'
-
  unfinished test with uncaughtException (*ms)
-  Error: foo
-      *
-      *
-      *
-
  unfinished test with unhandledRejection (*ms)
-  Error: bar
-      *
-      *
-      *
-
  assertion errors display actual and expected properly (*ms)
-  AssertionError [ERR_ASSERTION]: Expected values to be loosely deep-equal:
-  
-  {
-    bar: 1,
-    baz: {
-      date: 1970-01-01T00:00:00.000Z,
-      null: null,
-      number: 1,
-      string: 'Hello',
-      undefined: undefined
-    },
-    boo: [
-      1
-    ],
-    foo: 1
-  }
-  
-  should loosely deep-equal
-  
-  {
-    baz: {
-      date: 1970-01-01T00:00:00.000Z,
-      null: null,
-      number: 1,
-      string: 'Hello',
-      undefined: undefined
-    },
-    boo: [
-      1
-    ],
-    circular: <ref *1> {
-      bar: 2,
-      c: [Circular *1]
-    }
-  }
-      * {
-    generatedMessage: true,
-    code: 'ERR_ASSERTION',
-    actual: [Object],
-    expected: [Object],
-    operator: 'deepEqual'
-  }
-
  invalid subtest fail (*ms)
-  'test could not be started because its parent finished'
-
  Error: Test "unhandled rejection - passes but warns" at test/fixtures/test-runner/output/output.js:72:1 generated asynchronous activity after the test ended. This activity created the error "Error: rejected from unhandled rejection fail" and would have caused the test to fail, but instead triggered an unhandledRejection event.
  Error: Test "async unhandled rejection - passes but warns" at test/fixtures/test-runner/output/output.js:76:1 generated asynchronous activity after the test ended. This activity created the error "Error: rejected from async unhandled rejection fail" and would have caused the test to fail, but instead triggered an unhandledRejection event.
  Error: A resource generated asynchronous activity after the test ended. This activity created the error "Error: uncaught from outside of a test" which triggered an uncaughtException event, caught by the test runner.
diff --git a/test/fixtures/test-runner/output/spec_reporter_cli.snapshot b/test/fixtures/test-runner/output/spec_reporter_cli.snapshot
index 2e5f263e1a5e3a..52dc40bb366e2c 100644
--- a/test/fixtures/test-runner/output/spec_reporter_cli.snapshot
+++ b/test/fixtures/test-runner/output/spec_reporter_cli.snapshot
@@ -1,91 +1,19 @@
  sync pass todo (*ms) # TODO
  sync pass todo with message (*ms) # this is a passing todo
  sync fail todo (*ms) # TODO
-  Error: thrown from sync fail todo
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-
  sync fail todo with message (*ms) # this is a failing todo
-  Error: thrown from sync fail todo with message
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-
  sync skip pass (*ms) # SKIP
  sync skip pass with message (*ms) # this is skipped
  sync pass (*ms)
  this test should pass
  sync throw fail (*ms)
-  Error: thrown from sync throw fail
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-
  async skip pass (*ms) # SKIP
  async pass (*ms)
  async throw fail (*ms)
-  Error: thrown from async throw fail
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-
  async skip fail (*ms) # SKIP
-  Error: thrown from async throw fail
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-
  async assertion fail (*ms)
-  AssertionError [ERR_ASSERTION]: Expected values to be strictly equal:
-  
-  true !== false
-  
-      *
-      *
-      *
-      *
-      *
-      *
-      * {
-    generatedMessage: true,
-    code: 'ERR_ASSERTION',
-    actual: true,
-    expected: false,
-    operator: 'strictEqual'
-  }
-
  resolve pass (*ms)
  reject fail (*ms)
-  Error: rejected from reject fail
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-
  unhandled rejection - passes but warns (*ms)
  async unhandled rejection - passes but warns (*ms)
  immediate throw - passes but warns (*ms)
@@ -93,23 +21,9 @@
  immediate resolve pass (*ms)
  subtest sync throw fail
    +sync throw fail (*ms)
-    Error: thrown from subtest sync throw fail
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-
    this subtest should make its parent test fail
  subtest sync throw fail (*ms)
  sync throw non-error fail (*ms)
-  Symbol(thrown symbol from sync throw non-error fail)
-
  level 0a
    level 1a (*ms)
    level 1b (*ms)
@@ -118,8 +32,6 @@
  level 0a (*ms)
  top level
    +long running (*ms)
-    'test did not finish before its parent and was cancelled'
-
    +short running
      ++short running (*ms)
    +short running (*ms)
@@ -128,15 +40,6 @@
  sync skip option (*ms) # SKIP
  sync skip option with message (*ms) # this is skipped
  sync skip option is false fail (*ms)
-  Error: this should be executed
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-
  <anonymous> (*ms)
  functionOnly (*ms)
  <anonymous> (*ms)
@@ -147,43 +50,15 @@
  functionAndOptions (*ms) # SKIP
  callback pass (*ms)
  callback fail (*ms)
-  Error: callback failure
-      *
-      *
-
  sync t is this in test (*ms)
  async t is this in test (*ms)
  callback t is this in test (*ms)
  callback also returns a Promise (*ms)
-  'passed a callback but also returned a Promise'
-
  callback throw (*ms)
-  Error: thrown from callback throw
-      *
-      *
-      *
-      *
-      *
-      *
-      *
-
  callback called twice (*ms)
-  'callback invoked multiple times'
-
  callback called twice in different ticks (*ms)
  callback called twice in future tick (*ms)
-  Error [ERR_TEST_FAILURE]: callback invoked multiple times
-      * {
-    code: 'ERR_TEST_FAILURE',
-    failureType: 'multipleCallbackInvocations',
-    cause: 'callback invoked multiple times'
-  }
-
  callback async throw (*ms)
-  Error: thrown from callback async throw
-      *
-      *
-
  callback async throw after done (*ms)
  only is set on subtests but not in only mode
    running subtest 1 (*ms)
@@ -194,108 +69,21 @@
    running subtest 4 (*ms)
  only is set on subtests but not in only mode (*ms)
  custom inspect symbol fail (*ms)
-  customized
-
  custom inspect symbol that throws fail (*ms)
-  { foo: 1 }
-
  subtest sync throw fails
    sync throw fails at first (*ms)
-    Error: thrown from subtest sync throw fails at first
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-
    sync throw fails at second (*ms)
-    Error: thrown from subtest sync throw fails at second
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-        *
-
  subtest sync throw fails (*ms)
  timed out async test (*ms)
-  'test timed out after *ms'
-
  timed out callback test (*ms)
-  'test timed out after *ms'
-
  large timeout async test is ok (*ms)
  large timeout callback test is ok (*ms)
  successful thenable (*ms)
  rejected thenable (*ms)
-  'custom error'
-
  unfinished test with uncaughtException (*ms)
-  Error: foo
-      *
-      *
-      *
-
  unfinished test with unhandledRejection (*ms)
-  Error: bar
-      *
-      *
-      *
-
  assertion errors display actual and expected properly (*ms)
-  AssertionError [ERR_ASSERTION]: Expected values to be loosely deep-equal:
-  
-  {
-    bar: 1,
-    baz: {
-      date: 1970-01-01T00:00:00.000Z,
-      null: null,
-      number: 1,
-      string: 'Hello',
-      undefined: undefined
-    },
-    boo: [
-      1
-    ],
-    foo: 1
-  }
-  
-  should loosely deep-equal
-  
-  {
-    baz: {
-      date: 1970-01-01T00:00:00.000Z,
-      null: null,
-      number: 1,
-      string: 'Hello',
-      undefined: undefined
-    },
-    boo: [
-      1
-    ],
-    circular: <ref *1> {
-      bar: 2,
-      c: [Circular *1]
-    }
-  }
-      * {
-    generatedMessage: true,
-    code: 'ERR_ASSERTION',
-    actual: { foo: 1, bar: 1, boo: [ 1 ], baz: { date: 1970-01-01T00:00:00.000Z, null: null, number: 1, string: 'Hello', undefined: undefined } },
-    expected: { boo: [ 1 ], baz: { date: 1970-01-01T00:00:00.000Z, null: null, number: 1, string: 'Hello', undefined: undefined }, circular: <ref *1> { bar: 2, c: [Circular *1] } },
-    operator: 'deepEqual'
-  }
-
  invalid subtest fail (*ms)
-  'test could not be started because its parent finished'
-
  Error: Test "unhandled rejection - passes but warns" at test/fixtures/test-runner/output/output.js:72:1 generated asynchronous activity after the test ended. This activity created the error "Error: rejected from unhandled rejection fail" and would have caused the test to fail, but instead triggered an unhandledRejection event.
  Error: Test "async unhandled rejection - passes but warns" at test/fixtures/test-runner/output/output.js:76:1 generated asynchronous activity after the test ended. This activity created the error "Error: rejected from async unhandled rejection fail" and would have caused the test to fail, but instead triggered an unhandledRejection event.
  Error: A resource generated asynchronous activity after the test ended. This activity created the error "Error: uncaught from outside of a test" which triggered an uncaughtException event, caught by the test runner.

From 761de815c5cce3fb67f0d14ecabc5397497285ff Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Fri, 24 Jan 2025 16:58:32 -0800
Subject: [PATCH 07/38] test: move crypto related common utilities in
 common/crypto

Since `common/crypto` already exists, it makes sense to keep
crypto-related utilities there. The only exception being
common.hasCrypto which is needed up front to determine
if tests should be skipped.

Eliminate the redundant check in hasFipsCrypto and just
use crypto.getFips() directly where needed.

PR-URL: https://github.com/nodejs/node/pull/56714
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
---
 test/addons/openssl-providers/providers.cjs   |  7 ++-
 test/benchmark/test-benchmark-crypto.js       |  5 +-
 test/common/README.md                         | 17 ------
 test/common/crypto.js                         | 52 ++++++++++++++++++-
 test/common/index.js                          | 52 -------------------
 test/common/index.mjs                         |  2 -
 test/parallel/test-cli-node-options.js        |  3 +-
 test/parallel/test-crypto-authenticated.js    | 20 ++++---
 .../test-crypto-cipheriv-decipheriv.js        | 10 ++--
 test/parallel/test-crypto-classes.js          |  6 +--
 test/parallel/test-crypto-dh-constructor.js   |  3 +-
 test/parallel/test-crypto-dh-errors.js        |  3 +-
 test/parallel/test-crypto-dh-generate-keys.js |  3 +-
 test/parallel/test-crypto-dh-leak.js          |  3 +-
 test/parallel/test-crypto-dh-odd-key.js       |  8 +--
 test/parallel/test-crypto-dh-stateless.js     |  7 +--
 test/parallel/test-crypto-dh.js               | 17 +++---
 test/parallel/test-crypto-ecb.js              | 13 +++--
 test/parallel/test-crypto-fips.js             |  5 +-
 test/parallel/test-crypto-hash.js             |  7 +--
 test/parallel/test-crypto-hkdf.js             |  5 +-
 test/parallel/test-crypto-hmac.js             |  5 +-
 test/parallel/test-crypto-key-objects.js      | 10 ++--
 ...test-crypto-keygen-async-dsa-key-object.js |  8 +--
 test/parallel/test-crypto-keygen-async-dsa.js |  8 +--
 ...-explicit-elliptic-curve-encrypted-p256.js |  4 +-
 ...nc-explicit-elliptic-curve-encrypted.js.js |  3 +-
 ...ync-named-elliptic-curve-encrypted-p256.js |  3 +-
 ...en-async-named-elliptic-curve-encrypted.js |  3 +-
 test/parallel/test-crypto-keygen-async-rsa.js |  3 +-
 .../parallel/test-crypto-keygen-bit-length.js |  3 +-
 ...rypto-keygen-empty-passphrase-no-prompt.js |  3 +-
 .../test-crypto-keygen-missing-oid.js         |  4 +-
 test/parallel/test-crypto-keygen.js           |  3 +-
 test/parallel/test-crypto-no-algorithm.js     |  4 +-
 test/parallel/test-crypto-oneshot-hash.js     |  3 +-
 test/parallel/test-crypto-padding.js          |  5 +-
 test/parallel/test-crypto-pbkdf2.js           |  3 +-
 .../test-crypto-private-decrypt-gh32240.js    |  4 +-
 ...t-crypto-publicDecrypt-fails-first-time.js |  8 ++-
 test/parallel/test-crypto-rsa-dsa.js          |  7 +--
 test/parallel/test-crypto-secure-heap.js      | 13 +++--
 test/parallel/test-crypto-sign-verify.js      | 13 +++--
 test/parallel/test-crypto-stream.js           |  8 +--
 test/parallel/test-crypto-x509.js             |  5 +-
 test/parallel/test-crypto.js                  |  7 +--
 test/parallel/test-dsa-fips-invalid-key.js    | 10 +++-
 .../test-https-agent-session-eviction.js      |  9 ++--
 .../test-https-client-renegotiation-limit.js  |  8 ++-
 test/parallel/test-https-foafssl.js           | 10 ++--
 ...rocess-env-allowed-flags-are-documented.js |  7 +--
 test/parallel/test-process-versions.js        |  3 +-
 test/parallel/test-tls-alert-handling.js      | 20 ++++---
 test/parallel/test-tls-alert.js               | 15 ++++--
 test/parallel/test-tls-alpn-server-client.js  |  5 +-
 test/parallel/test-tls-cert-ext-encoding.js   |  4 +-
 test/parallel/test-tls-client-auth.js         |  7 ++-
 .../test-tls-client-getephemeralkeyinfo.js    |  3 +-
 test/parallel/test-tls-client-mindhsize.js    |  5 +-
 .../test-tls-client-renegotiation-13.js       |  8 ++-
 .../test-tls-client-renegotiation-limit.js    |  8 ++-
 test/parallel/test-tls-dhe.js                 | 17 ++++--
 test/parallel/test-tls-ecdh-auto.js           | 10 ++--
 test/parallel/test-tls-ecdh-multiple.js       | 14 +++--
 test/parallel/test-tls-ecdh.js                | 10 ++--
 test/parallel/test-tls-empty-sni-context.js   |  4 +-
 test/parallel/test-tls-getprotocol.js         |  6 ++-
 test/parallel/test-tls-junk-server.js         |  7 ++-
 test/parallel/test-tls-key-mismatch.js        |  6 ++-
 test/parallel/test-tls-legacy-pfx.js          |  9 +++-
 test/parallel/test-tls-min-max-version.js     | 16 ++++--
 test/parallel/test-tls-no-sslv3.js            | 10 ++--
 test/parallel/test-tls-ocsp-callback.js       | 15 ++++--
 test/parallel/test-tls-psk-circuit.js         | 10 ++--
 test/parallel/test-tls-psk-server.js          | 11 ++--
 test/parallel/test-tls-securepair-server.js   | 10 ++--
 test/parallel/test-tls-server-verify.js       | 10 ++--
 test/parallel/test-tls-session-cache.js       | 20 ++++---
 test/parallel/test-tls-set-ciphers.js         | 16 ++++--
 test/parallel/test-tls-set-secure-context.js  |  6 ++-
 test/parallel/test-tls-set-sigalgs.js         |  7 ++-
 test/parallel/test-trace-env.js               |  8 +--
 test/parallel/test-x509-escaping.js           |  5 +-
 test/pummel/test-crypto-dh-hash.js            |  4 +-
 test/pummel/test-crypto-dh-keys.js            |  3 +-
 test/pummel/test-dh-regr.js                   |  3 +-
 test/sequential/test-tls-psk-client.js        | 11 ++--
 test/sequential/test-tls-securepair-client.js | 25 +++++----
 test/sequential/test-tls-session-timeout.js   | 10 ++--
 89 files changed, 505 insertions(+), 288 deletions(-)

diff --git a/test/addons/openssl-providers/providers.cjs b/test/addons/openssl-providers/providers.cjs
index 2dabbf020e2a41..efa1019c62d99c 100644
--- a/test/addons/openssl-providers/providers.cjs
+++ b/test/addons/openssl-providers/providers.cjs
@@ -1,11 +1,14 @@
 'use strict';
 
 const common = require('../../common');
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
+}
+const { hasOpenSSL3 } = require('../../common/crypto');
 
-if (!common.hasOpenSSL3)
+if (!hasOpenSSL3) {
   common.skip('this test requires OpenSSL 3.x');
+}
 const assert = require('node:assert');
 const { createHash, getCiphers, getHashes } = require('node:crypto');
 const { debuglog } = require('node:util');
diff --git a/test/benchmark/test-benchmark-crypto.js b/test/benchmark/test-benchmark-crypto.js
index 7f6988acf234d8..72d79ece13e787 100644
--- a/test/benchmark/test-benchmark-crypto.js
+++ b/test/benchmark/test-benchmark-crypto.js
@@ -5,8 +5,11 @@ const common = require('../common');
 if (!common.hasCrypto)
   common.skip('missing crypto');
 
-if (common.hasFipsCrypto)
+const { getFips } = require('crypto');
+
+if (getFips()) {
   common.skip('some benchmarks are FIPS-incompatible');
+}
 
 const runBenchmark = require('../common/benchmark');
 
diff --git a/test/common/README.md b/test/common/README.md
index 5f5ff75fca2431..ee36503f920001 100644
--- a/test/common/README.md
+++ b/test/common/README.md
@@ -226,17 +226,6 @@ The TTY file descriptor is assumed to be capable of being writable.
 
 Indicates whether OpenSSL is available.
 
-### `hasFipsCrypto`
-
-* [\<boolean>][<boolean>]
-
-Indicates that Node.js has been linked with a FIPS compatible OpenSSL library,
-and that FIPS as been enabled using `--enable-fips`.
-
-To only detect if the OpenSSL library is FIPS compatible, regardless if it has
-been enabled or not, then `process.config.variables.openssl_is_fips` can be
-used to determine that situation.
-
 ### `hasIntl`
 
 * [\<boolean>][<boolean>]
@@ -417,12 +406,6 @@ Returns `true` if the exit code `exitCode` and/or signal name `signal` represent
 the exit code and/or signal name of a node process that aborted, `false`
 otherwise.
 
-### `opensslCli`
-
-* [\<boolean>][<boolean>]
-
-Indicates whether 'opensslCli' is supported.
-
 ### `platformTimeout(ms)`
 
 * `ms` [\<number>][<number>] | [\<bigint>][<bigint>]
diff --git a/test/common/crypto.js b/test/common/crypto.js
index 10432d7e7a7e32..f50d3895a1783b 100644
--- a/test/common/crypto.js
+++ b/test/common/crypto.js
@@ -1,8 +1,9 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
+}
 
 const assert = require('assert');
 const crypto = require('crypto');
@@ -98,6 +99,27 @@ const pkcs8EncExp = getRegExpForPEM('ENCRYPTED PRIVATE KEY');
 const sec1Exp = getRegExpForPEM('EC PRIVATE KEY');
 const sec1EncExp = (cipher) => getRegExpForPEM('EC PRIVATE KEY', cipher);
 
+// Synthesize OPENSSL_VERSION_NUMBER format with the layout 0xMNN00PPSL
+const opensslVersionNumber = (major = 0, minor = 0, patch = 0) => {
+  assert(major >= 0 && major <= 0xf);
+  assert(minor >= 0 && minor <= 0xff);
+  assert(patch >= 0 && patch <= 0xff);
+  return (major << 28) | (minor << 20) | (patch << 4);
+};
+
+let OPENSSL_VERSION_NUMBER;
+const hasOpenSSL = (major = 0, minor = 0, patch = 0) => {
+  if (!common.hasCrypto) return false;
+  if (OPENSSL_VERSION_NUMBER === undefined) {
+    const regexp = /(?<m>\d+)\.(?<n>\d+)\.(?<p>\d+)/;
+    const { m, n, p } = process.versions.openssl.match(regexp).groups;
+    OPENSSL_VERSION_NUMBER = opensslVersionNumber(m, n, p);
+  }
+  return OPENSSL_VERSION_NUMBER >= opensslVersionNumber(major, minor, patch);
+};
+
+let opensslCli = null;
+
 module.exports = {
   modp2buf,
   assertApproximateSize,
@@ -111,4 +133,32 @@ module.exports = {
   pkcs8EncExp,  // used once
   sec1Exp,
   sec1EncExp,
+  hasOpenSSL,
+  get hasOpenSSL3() {
+    return hasOpenSSL(3);
+  },
+  // opensslCli defined lazily to reduce overhead of spawnSync
+  get opensslCli() {
+    if (opensslCli !== null) return opensslCli;
+
+    if (process.config.variables.node_shared_openssl) {
+      // Use external command
+      opensslCli = 'openssl';
+    } else {
+      const path = require('path');
+      // Use command built from sources included in Node.js repository
+      opensslCli = path.join(path.dirname(process.execPath), 'openssl-cli');
+    }
+
+    if (exports.isWindows) opensslCli += '.exe';
+
+    const { spawnSync } = require('child_process');
+
+    const opensslCmd = spawnSync(opensslCli, ['version']);
+    if (opensslCmd.status !== 0 || opensslCmd.error !== undefined) {
+      // OpenSSL command cannot be executed
+      opensslCli = false;
+    }
+    return opensslCli;
+  },
 };
diff --git a/test/common/index.js b/test/common/index.js
index b5592a66a081c3..d2c39578324600 100644
--- a/test/common/index.js
+++ b/test/common/index.js
@@ -19,7 +19,6 @@
 // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-/* eslint-disable node-core/crypto-check */
 'use strict';
 const process = global.process;  // Some tests tamper with the process global.
 
@@ -57,25 +56,6 @@ const noop = () => {};
 const hasCrypto = Boolean(process.versions.openssl) &&
                   !process.env.NODE_SKIP_CRYPTO;
 
-// Synthesize OPENSSL_VERSION_NUMBER format with the layout 0xMNN00PPSL
-const opensslVersionNumber = (major = 0, minor = 0, patch = 0) => {
-  assert(major >= 0 && major <= 0xf);
-  assert(minor >= 0 && minor <= 0xff);
-  assert(patch >= 0 && patch <= 0xff);
-  return (major << 28) | (minor << 20) | (patch << 4);
-};
-
-let OPENSSL_VERSION_NUMBER;
-const hasOpenSSL = (major = 0, minor = 0, patch = 0) => {
-  if (!hasCrypto) return false;
-  if (OPENSSL_VERSION_NUMBER === undefined) {
-    const regexp = /(?<m>\d+)\.(?<n>\d+)\.(?<p>\d+)/;
-    const { m, n, p } = process.versions.openssl.match(regexp).groups;
-    OPENSSL_VERSION_NUMBER = opensslVersionNumber(m, n, p);
-  }
-  return OPENSSL_VERSION_NUMBER >= opensslVersionNumber(major, minor, patch);
-};
-
 const hasQuic = hasCrypto && !!process.config.variables.openssl_quic;
 
 function parseTestFlags(filename = process.argv[1]) {
@@ -220,7 +200,6 @@ if (process.env.NODE_TEST_WITH_ASYNC_HOOKS) {
   }).enable();
 }
 
-let opensslCli = null;
 let inFreeBSDJail = null;
 let localhostIPv4 = null;
 
@@ -985,7 +964,6 @@ const common = {
   getTTYfd,
   hasIntl,
   hasCrypto,
-  hasOpenSSL,
   hasQuic,
   hasMultiLocalhost,
   invalidArgTypeHelper,
@@ -1027,10 +1005,6 @@ const common = {
     return require('os').totalmem() > 0x70000000; /* 1.75 Gb */
   },
 
-  get hasFipsCrypto() {
-    return hasCrypto && require('crypto').getFips();
-  },
-
   get hasIPv6() {
     const iFaces = require('os').networkInterfaces();
     let re;
@@ -1047,10 +1021,6 @@ const common = {
     });
   },
 
-  get hasOpenSSL3() {
-    return hasOpenSSL(3);
-  },
-
   get inFreeBSDJail() {
     if (inFreeBSDJail !== null) return inFreeBSDJail;
 
@@ -1100,28 +1070,6 @@ const common = {
     return localhostIPv4;
   },
 
-  // opensslCli defined lazily to reduce overhead of spawnSync
-  get opensslCli() {
-    if (opensslCli !== null) return opensslCli;
-
-    if (process.config.variables.node_shared_openssl) {
-      // Use external command
-      opensslCli = 'openssl';
-    } else {
-      // Use command built from sources included in Node.js repository
-      opensslCli = path.join(path.dirname(process.execPath), 'openssl-cli');
-    }
-
-    if (exports.isWindows) opensslCli += '.exe';
-
-    const opensslCmd = spawnSync(opensslCli, ['version']);
-    if (opensslCmd.status !== 0 || opensslCmd.error !== undefined) {
-      // OpenSSL command cannot be executed
-      opensslCli = false;
-    }
-    return opensslCli;
-  },
-
   get PORT() {
     if (+process.env.TEST_PARALLEL) {
       throw new Error('common.PORT cannot be used in a parallelized test');
diff --git a/test/common/index.mjs b/test/common/index.mjs
index b252f2dc4aac5e..23328ac90ea3c9 100644
--- a/test/common/index.mjs
+++ b/test/common/index.mjs
@@ -41,7 +41,6 @@ const {
   mustNotMutateObjectDeep,
   mustSucceed,
   nodeProcessAborted,
-  opensslCli,
   parseTestFlags,
   PIPE,
   platformTimeout,
@@ -97,7 +96,6 @@ export {
   mustNotMutateObjectDeep,
   mustSucceed,
   nodeProcessAborted,
-  opensslCli,
   parseTestFlags,
   PIPE,
   platformTimeout,
diff --git a/test/parallel/test-cli-node-options.js b/test/parallel/test-cli-node-options.js
index 69bf136559c1a8..9e89200e9f6dfd 100644
--- a/test/parallel/test-cli-node-options.js
+++ b/test/parallel/test-cli-node-options.js
@@ -12,6 +12,7 @@ const { Worker } = require('worker_threads');
 
 const fixtures = require('../common/fixtures');
 const tmpdir = require('../common/tmpdir');
+const { hasOpenSSL3 } = require('../common/crypto');
 tmpdir.refresh();
 
 const printA = path.relative(tmpdir.path, fixtures.path('printA.js'));
@@ -64,7 +65,7 @@ if (common.isLinux) {
 if (common.hasCrypto) {
   expectNoWorker('--use-openssl-ca', 'B\n');
   expectNoWorker('--use-bundled-ca', 'B\n');
-  if (!common.hasOpenSSL3)
+  if (!hasOpenSSL3)
     expectNoWorker('--openssl-config=_ossl_cfg', 'B\n');
 }
 
diff --git a/test/parallel/test-crypto-authenticated.js b/test/parallel/test-crypto-authenticated.js
index d191ab7be2de20..181ea732b91281 100644
--- a/test/parallel/test-crypto-authenticated.js
+++ b/test/parallel/test-crypto-authenticated.js
@@ -21,13 +21,17 @@
 // Flags: --no-warnings
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
+}
 
 const assert = require('assert');
 const crypto = require('crypto');
 const { inspect } = require('util');
 const fixtures = require('../common/fixtures');
+const { hasOpenSSL3 } = require('../common/crypto');
+
+const isFipsEnabled = crypto.getFips();
 
 //
 // Test authenticated encryption modes.
@@ -53,7 +57,7 @@ for (const test of TEST_CASES) {
     continue;
   }
 
-  if (common.hasFipsCrypto && test.iv.length < 24) {
+  if (isFipsEnabled && test.iv.length < 24) {
     common.printSkipMessage('IV len < 12 bytes unsupported in FIPS mode');
     continue;
   }
@@ -95,7 +99,7 @@ for (const test of TEST_CASES) {
   }
 
   {
-    if (isCCM && common.hasFipsCrypto) {
+    if (isCCM && isFipsEnabled) {
       assert.throws(() => {
         crypto.createDecipheriv(test.algo,
                                 Buffer.from(test.key, 'hex'),
@@ -286,7 +290,7 @@ for (const test of TEST_CASES) {
                             });
     }, errMessages.authTagLength);
 
-    if (!common.hasFipsCrypto) {
+    if (!isFipsEnabled) {
       assert.throws(() => {
         crypto.createDecipheriv('aes-256-ccm',
                                 'FxLKsqdmv0E9xrQhp0b1ZgI0K7JFZJM8',
@@ -312,7 +316,7 @@ for (const test of TEST_CASES) {
     });
 
     // CCM decryption and create(De|C)ipher are unsupported in FIPS mode.
-    if (!common.hasFipsCrypto) {
+    if (!isFipsEnabled) {
       assert.throws(() => {
         crypto.createDecipheriv(`aes-256-${mode}`,
                                 'FxLKsqdmv0E9xrQhp0b1ZgI0K7JFZJM8',
@@ -388,7 +392,7 @@ for (const test of TEST_CASES) {
     cipher.setAAD(Buffer.from('0123456789', 'hex'));
   }, /options\.plaintextLength required for CCM mode with AAD/);
 
-  if (!common.hasFipsCrypto) {
+  if (!isFipsEnabled) {
     assert.throws(() => {
       const cipher = crypto.createDecipheriv('aes-256-ccm',
                                              'FxLKsqdmv0E9xrQhp0b1ZgI0K7JFZJM8',
@@ -403,7 +407,7 @@ for (const test of TEST_CASES) {
 
 // Test that final() throws in CCM mode when no authentication tag is provided.
 {
-  if (!common.hasFipsCrypto) {
+  if (!isFipsEnabled) {
     const key = Buffer.from('1ed2233fa2223ef5d7df08546049406c', 'hex');
     const iv = Buffer.from('7305220bca40d4c90e1791e9', 'hex');
     const ct = Buffer.from('8beba09d4d4d861f957d51c0794f4abf8030848e', 'hex');
@@ -562,7 +566,7 @@ for (const test of TEST_CASES) {
   ]) {
     assert.throws(() => {
       cipher.final();
-    }, common.hasOpenSSL3 ? {
+    }, hasOpenSSL3 ? {
       code: 'ERR_OSSL_TAG_NOT_SET'
     } : {
       message: /Unsupported state/
diff --git a/test/parallel/test-crypto-cipheriv-decipheriv.js b/test/parallel/test-crypto-cipheriv-decipheriv.js
index 3e3632203af72c..88d07c3b957f57 100644
--- a/test/parallel/test-crypto-cipheriv-decipheriv.js
+++ b/test/parallel/test-crypto-cipheriv-decipheriv.js
@@ -5,6 +5,8 @@ if (!common.hasCrypto)
 
 const assert = require('assert');
 const crypto = require('crypto');
+const { hasOpenSSL3 } = require('../common/crypto');
+const isFipsEnabled = crypto.getFips();
 
 function testCipher1(key, iv) {
   // Test encryption and decryption with explicit key and iv
@@ -150,7 +152,7 @@ testCipher1(Buffer.from('0123456789abcd0123456789'), '12345678');
 testCipher1(Buffer.from('0123456789abcd0123456789'), Buffer.from('12345678'));
 testCipher2(Buffer.from('0123456789abcd0123456789'), Buffer.from('12345678'));
 
-if (!common.hasFipsCrypto) {
+if (!isFipsEnabled) {
   testCipher3(Buffer.from('000102030405060708090A0B0C0D0E0F', 'hex'),
               Buffer.from('A6A6A6A6A6A6A6A6', 'hex'));
 }
@@ -193,10 +195,10 @@ assert.throws(
   errMessage);
 
 // But all other IV lengths should be accepted.
-const minIvLength = common.hasOpenSSL3 ? 8 : 1;
-const maxIvLength = common.hasOpenSSL3 ? 64 : 256;
+const minIvLength = hasOpenSSL3 ? 8 : 1;
+const maxIvLength = hasOpenSSL3 ? 64 : 256;
 for (let n = minIvLength; n < maxIvLength; n += 1) {
-  if (common.hasFipsCrypto && n < 12) continue;
+  if (isFipsEnabled && n < 12) continue;
   crypto.createCipheriv('aes-128-gcm', Buffer.alloc(16), Buffer.alloc(n));
 }
 
diff --git a/test/parallel/test-crypto-classes.js b/test/parallel/test-crypto-classes.js
index f736921476a1c5..429bc91d4412be 100644
--- a/test/parallel/test-crypto-classes.js
+++ b/test/parallel/test-crypto-classes.js
@@ -4,9 +4,9 @@ const assert = require('assert');
 
 if (!common.hasCrypto) {
   common.skip('missing crypto');
-  return;
 }
 const crypto = require('crypto');
+const { hasOpenSSL3 } = require('../common/crypto');
 
 // 'ClassName' : ['args', 'for', 'constructor']
 const TEST_CASES = {
@@ -21,8 +21,8 @@ const TEST_CASES = {
   'ECDH': ['prime256v1'],
 };
 
-if (!common.hasFipsCrypto) {
-  TEST_CASES.DiffieHellman = [common.hasOpenSSL3 ? 1024 : 256];
+if (!crypto.getFips()) {
+  TEST_CASES.DiffieHellman = [hasOpenSSL3 ? 1024 : 256];
 }
 
 for (const [clazz, args] of Object.entries(TEST_CASES)) {
diff --git a/test/parallel/test-crypto-dh-constructor.js b/test/parallel/test-crypto-dh-constructor.js
index c7eaca29347a2b..eb8674932484ed 100644
--- a/test/parallel/test-crypto-dh-constructor.js
+++ b/test/parallel/test-crypto-dh-constructor.js
@@ -5,8 +5,9 @@ if (!common.hasCrypto)
 
 const assert = require('assert');
 const crypto = require('crypto');
+const { hasOpenSSL3 } = require('../common/crypto');
 
-const size = common.hasFipsCrypto || common.hasOpenSSL3 ? 1024 : 256;
+const size = crypto.getFips() || hasOpenSSL3 ? 1024 : 256;
 const dh1 = crypto.createDiffieHellman(size);
 const p1 = dh1.getPrime('buffer');
 
diff --git a/test/parallel/test-crypto-dh-errors.js b/test/parallel/test-crypto-dh-errors.js
index 476ca64b4425b5..0af4db0310750c 100644
--- a/test/parallel/test-crypto-dh-errors.js
+++ b/test/parallel/test-crypto-dh-errors.js
@@ -5,6 +5,7 @@ if (!common.hasCrypto)
 
 const assert = require('assert');
 const crypto = require('crypto');
+const { hasOpenSSL3 } = require('../common/crypto');
 
 // https://github.com/nodejs/node/issues/32738
 // XXX(bnoordhuis) validateInt32() throwing ERR_OUT_OF_RANGE and RangeError
@@ -24,7 +25,7 @@ assert.throws(() => crypto.createDiffieHellman('abcdef', 13.37), {
 });
 
 for (const bits of [-1, 0, 1]) {
-  if (common.hasOpenSSL3) {
+  if (hasOpenSSL3) {
     assert.throws(() => crypto.createDiffieHellman(bits), {
       code: 'ERR_OSSL_DH_MODULUS_TOO_SMALL',
       name: 'Error',
diff --git a/test/parallel/test-crypto-dh-generate-keys.js b/test/parallel/test-crypto-dh-generate-keys.js
index fc277bb0d9b8e4..e4598274328bd8 100644
--- a/test/parallel/test-crypto-dh-generate-keys.js
+++ b/test/parallel/test-crypto-dh-generate-keys.js
@@ -6,9 +6,10 @@ if (!common.hasCrypto)
 
 const assert = require('assert');
 const crypto = require('crypto');
+const { hasOpenSSL3 } = require('../common/crypto');
 
 {
-  const size = common.hasFipsCrypto || common.hasOpenSSL3 ? 1024 : 256;
+  const size = crypto.getFips() || hasOpenSSL3 ? 1024 : 256;
 
   function unlessInvalidState(f) {
     try {
diff --git a/test/parallel/test-crypto-dh-leak.js b/test/parallel/test-crypto-dh-leak.js
index 1998d61d4affd7..3b5051feb43cd8 100644
--- a/test/parallel/test-crypto-dh-leak.js
+++ b/test/parallel/test-crypto-dh-leak.js
@@ -9,10 +9,11 @@ if (common.isASan)
 
 const assert = require('assert');
 const crypto = require('crypto');
+const { hasOpenSSL3 } = require('../common/crypto');
 
 const before = process.memoryUsage.rss();
 {
-  const size = common.hasFipsCrypto || common.hasOpenSSL3 ? 1024 : 256;
+  const size = crypto.getFips() || hasOpenSSL3 ? 1024 : 256;
   const dh = crypto.createDiffieHellman(size);
   const publicKey = dh.generateKeys();
   const privateKey = dh.getPrivateKey();
diff --git a/test/parallel/test-crypto-dh-odd-key.js b/test/parallel/test-crypto-dh-odd-key.js
index 69a1eb56c866b3..fbe42be425ed1c 100644
--- a/test/parallel/test-crypto-dh-odd-key.js
+++ b/test/parallel/test-crypto-dh-odd-key.js
@@ -21,22 +21,24 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
+}
 
 const assert = require('assert');
 const crypto = require('crypto');
+const { hasOpenSSL3 } = require('../common/crypto');
 
 function test() {
   const odd = Buffer.alloc(39, 'A');
 
-  const c = crypto.createDiffieHellman(common.hasOpenSSL3 ? 1024 : 32);
+  const c = crypto.createDiffieHellman(hasOpenSSL3 ? 1024 : 32);
   c.setPrivateKey(odd);
   c.generateKeys();
 }
 
 // FIPS requires a length of at least 1024
-if (!common.hasFipsCrypto) {
+if (!crypto.getFips()) {
   test();
 } else {
   assert.throws(function() { test(); }, /key size too small/);
diff --git a/test/parallel/test-crypto-dh-stateless.js b/test/parallel/test-crypto-dh-stateless.js
index 2ccac322e23958..f4fc1849699e31 100644
--- a/test/parallel/test-crypto-dh-stateless.js
+++ b/test/parallel/test-crypto-dh-stateless.js
@@ -5,6 +5,7 @@ if (!common.hasCrypto)
 
 const assert = require('assert');
 const crypto = require('crypto');
+const { hasOpenSSL3 } = require('../common/crypto');
 
 assert.throws(() => crypto.diffieHellman(), {
   name: 'TypeError',
@@ -150,7 +151,7 @@ const list = [
 
 // TODO(danbev): Take a closer look if there should be a check in OpenSSL3
 // when the dh parameters differ.
-if (!common.hasOpenSSL3) {
+if (!hasOpenSSL3) {
   // Same primes, but different generator.
   list.push([{ group: 'modp5' }, { prime: group.getPrime(), generator: 5 }]);
   // Same generator, but different primes.
@@ -161,7 +162,7 @@ for (const [params1, params2] of list) {
   assert.throws(() => {
     test(crypto.generateKeyPairSync('dh', params1),
          crypto.generateKeyPairSync('dh', params2));
-  }, common.hasOpenSSL3 ? {
+  }, hasOpenSSL3 ? {
     name: 'Error',
     code: 'ERR_OSSL_MISMATCHING_DOMAIN_PARAMETERS'
   } : {
@@ -220,7 +221,7 @@ const not256k1 = crypto.getCurves().find((c) => /^sec.*(224|384|512)/.test(c));
 assert.throws(() => {
   test(crypto.generateKeyPairSync('ec', { namedCurve: 'secp256k1' }),
        crypto.generateKeyPairSync('ec', { namedCurve: not256k1 }));
-}, common.hasOpenSSL3 ? {
+}, hasOpenSSL3 ? {
   name: 'Error',
   code: 'ERR_OSSL_MISMATCHING_DOMAIN_PARAMETERS'
 } : {
diff --git a/test/parallel/test-crypto-dh.js b/test/parallel/test-crypto-dh.js
index 9ebe14011eed22..d7ffbe5eca9273 100644
--- a/test/parallel/test-crypto-dh.js
+++ b/test/parallel/test-crypto-dh.js
@@ -1,13 +1,18 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
+}
 
 const assert = require('assert');
 const crypto = require('crypto');
+const {
+  hasOpenSSL3,
+  hasOpenSSL,
+} = require('../common/crypto');
 
 {
-  const size = common.hasFipsCrypto || common.hasOpenSSL3 ? 1024 : 256;
+  const size = crypto.getFips() || hasOpenSSL3 ? 1024 : 256;
   const dh1 = crypto.createDiffieHellman(size);
   const p1 = dh1.getPrime('buffer');
   const dh2 = crypto.createDiffieHellman(p1, 'buffer');
@@ -53,7 +58,7 @@ const crypto = require('crypto');
   assert.strictEqual(secret1, secret4);
 
   let wrongBlockLength;
-  if (common.hasOpenSSL3) {
+  if (hasOpenSSL3) {
     wrongBlockLength = {
       message: 'error:1C80006B:Provider routines::wrong final block length',
       code: 'ERR_OSSL_WRONG_FINAL_BLOCK_LENGTH',
@@ -87,11 +92,11 @@ const crypto = require('crypto');
 
   {
     // Error message was changed in OpenSSL 3.0.x from 3.0.12, and 3.1.x from 3.1.4.
-    const hasOpenSSL3WithNewErrorMessage = (common.hasOpenSSL(3, 0, 12) && !common.hasOpenSSL(3, 1, 0)) ||
-                                           (common.hasOpenSSL(3, 1, 4));
+    const hasOpenSSL3WithNewErrorMessage = (hasOpenSSL(3, 0, 12) && !hasOpenSSL(3, 1, 0)) ||
+                                           (hasOpenSSL(3, 1, 4));
     assert.throws(() => {
       dh3.computeSecret('');
-    }, { message: common.hasOpenSSL3 && !hasOpenSSL3WithNewErrorMessage ?
+    }, { message: hasOpenSSL3 && !hasOpenSSL3WithNewErrorMessage ?
       'Unspecified validation error' :
       'Supplied key is too small' });
   }
diff --git a/test/parallel/test-crypto-ecb.js b/test/parallel/test-crypto-ecb.js
index aecd858ef3bf1e..6439c9354a059e 100644
--- a/test/parallel/test-crypto-ecb.js
+++ b/test/parallel/test-crypto-ecb.js
@@ -21,18 +21,23 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
+}
+
+const { hasOpenSSL3 } = require('../common/crypto');
+const crypto = require('crypto');
 
-if (common.hasFipsCrypto)
+if (crypto.getFips()) {
   common.skip('BF-ECB is not FIPS 140-2 compatible');
+}
 
-if (common.hasOpenSSL3)
+if (hasOpenSSL3) {
   common.skip('Blowfish is only available with the legacy provider in ' +
     'OpenSSl 3.x');
+}
 
 const assert = require('assert');
-const crypto = require('crypto');
 
 // Testing whether EVP_CipherInit_ex is functioning correctly.
 // Reference: bug#1997
diff --git a/test/parallel/test-crypto-fips.js b/test/parallel/test-crypto-fips.js
index 8a8a8089a3cf3b..de004b9a9e8f23 100644
--- a/test/parallel/test-crypto-fips.js
+++ b/test/parallel/test-crypto-fips.js
@@ -10,6 +10,7 @@ const path = require('path');
 const fixtures = require('../common/fixtures');
 const { internalBinding } = require('internal/test/binding');
 const { testFipsCrypto } = internalBinding('crypto');
+const { hasOpenSSL3 } = require('../common/crypto');
 
 const FIPS_ENABLED = 1;
 const FIPS_DISABLED = 0;
@@ -114,7 +115,7 @@ assert.ok(test_result === 1 || test_result === 0);
 // ("Error: Cannot set FIPS mode in a non-FIPS build.").
 // Due to this uncertainty the following tests are skipped when configured
 // with --shared-openssl.
-if (!sharedOpenSSL() && !common.hasOpenSSL3) {
+if (!sharedOpenSSL() && !hasOpenSSL3) {
   // OpenSSL config file should be able to turn on FIPS mode
   testHelper(
     'stdout',
@@ -144,7 +145,7 @@ if (!sharedOpenSSL() && !common.hasOpenSSL3) {
 // will not work as expected with that version.
 // TODO(danbev) Revisit these test once FIPS support is available in
 // OpenSSL 3.x.
-if (!common.hasOpenSSL3) {
+if (!hasOpenSSL3) {
   testHelper(
     'stdout',
     [`--openssl-config=${CNF_FIPS_OFF}`],
diff --git a/test/parallel/test-crypto-hash.js b/test/parallel/test-crypto-hash.js
index ca8f630b4bb7e7..61145aee0727fb 100644
--- a/test/parallel/test-crypto-hash.js
+++ b/test/parallel/test-crypto-hash.js
@@ -1,13 +1,14 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
+}
 
 const assert = require('assert');
 const crypto = require('crypto');
 const fs = require('fs');
 
-const { hasOpenSSL } = common;
+const { hasOpenSSL } = require('../common/crypto');
 const fixtures = require('../common/fixtures');
 
 let cryptoType;
@@ -40,7 +41,7 @@ a8.write('');
 a8.end();
 a8 = a8.read();
 
-if (!common.hasFipsCrypto) {
+if (!crypto.getFips()) {
   cryptoType = 'md5';
   digest = 'latin1';
   const a0 = crypto.createHash(cryptoType).update('Test123').digest(digest);
diff --git a/test/parallel/test-crypto-hkdf.js b/test/parallel/test-crypto-hkdf.js
index ff3abdf291efcd..3f7e61e9b2ebc0 100644
--- a/test/parallel/test-crypto-hkdf.js
+++ b/test/parallel/test-crypto-hkdf.js
@@ -13,6 +13,7 @@ const {
   hkdfSync,
   getHashes
 } = require('crypto');
+const { hasOpenSSL3 } = require('../common/crypto');
 
 {
   assert.throws(() => hkdf(), {
@@ -124,7 +125,7 @@ const algorithms = [
   ['sha256', '', 'salt', '', 10],
   ['sha512', 'secret', 'salt', '', 15],
 ];
-if (!common.hasOpenSSL3)
+if (!hasOpenSSL3)
   algorithms.push(['whirlpool', 'secret', '', 'info', 20]);
 
 algorithms.forEach(([ hash, secret, salt, info, length ]) => {
@@ -215,7 +216,7 @@ algorithms.forEach(([ hash, secret, salt, info, length ]) => {
 });
 
 
-if (!common.hasOpenSSL3) {
+if (!hasOpenSSL3) {
   const kKnownUnsupported = ['shake128', 'shake256'];
   getHashes()
     .filter((hash) => !kKnownUnsupported.includes(hash))
diff --git a/test/parallel/test-crypto-hmac.js b/test/parallel/test-crypto-hmac.js
index 62a6ac18d25265..afb5f74cbf076b 100644
--- a/test/parallel/test-crypto-hmac.js
+++ b/test/parallel/test-crypto-hmac.js
@@ -1,7 +1,8 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
+}
 
 const assert = require('assert');
 const crypto = require('crypto');
@@ -40,7 +41,7 @@ assert.throws(
 
 function testHmac(algo, key, data, expected) {
   // FIPS does not support MD5.
-  if (common.hasFipsCrypto && algo === 'md5')
+  if (crypto.getFips() && algo === 'md5')
     return;
 
   if (!Array.isArray(data))
diff --git a/test/parallel/test-crypto-key-objects.js b/test/parallel/test-crypto-key-objects.js
index f5271f16d346c0..0c516d80950694 100644
--- a/test/parallel/test-crypto-key-objects.js
+++ b/test/parallel/test-crypto-key-objects.js
@@ -24,6 +24,8 @@ const {
   generateKeyPairSync,
 } = require('crypto');
 
+const { hasOpenSSL3 } = require('../common/crypto');
+
 const fixtures = require('../common/fixtures');
 
 const publicPem = fixtures.readKey('rsa_public.pem', 'ascii');
@@ -297,7 +299,7 @@ const privateDsa = fixtures.readKey('dsa_private_encrypted_1025.pem',
   // This should not cause a crash: https://github.com/nodejs/node/issues/25247
   assert.throws(() => {
     createPrivateKey({ key: '' });
-  }, common.hasOpenSSL3 ? {
+  }, hasOpenSSL3 ? {
     message: 'error:1E08010C:DECODER routines::unsupported',
   } : {
     message: 'error:0909006C:PEM routines:get_name:no start line',
@@ -323,7 +325,7 @@ const privateDsa = fixtures.readKey('dsa_private_encrypted_1025.pem',
       type: 'pkcs1'
     });
     createPrivateKey({ key, format: 'der', type: 'pkcs1' });
-  }, common.hasOpenSSL3 ? {
+  }, hasOpenSSL3 ? {
     message: /error:1E08010C:DECODER routines::unsupported/,
     library: 'DECODER routines'
   } : {
@@ -510,7 +512,7 @@ const privateDsa = fixtures.readKey('dsa_private_encrypted_1025.pem',
 
 {
   // Reading an encrypted key without a passphrase should fail.
-  assert.throws(() => createPrivateKey(privateDsa), common.hasOpenSSL3 ? {
+  assert.throws(() => createPrivateKey(privateDsa), hasOpenSSL3 ? {
     name: 'Error',
     message: 'error:07880109:common libcrypto routines::interrupted or ' +
              'cancelled',
@@ -526,7 +528,7 @@ const privateDsa = fixtures.readKey('dsa_private_encrypted_1025.pem',
     key: privateDsa,
     format: 'pem',
     passphrase: Buffer.alloc(1025, 'a')
-  }), common.hasOpenSSL3 ? { name: 'Error' } : {
+  }), hasOpenSSL3 ? { name: 'Error' } : {
     code: 'ERR_OSSL_PEM_BAD_PASSWORD_READ',
     name: 'Error'
   });
diff --git a/test/parallel/test-crypto-keygen-async-dsa-key-object.js b/test/parallel/test-crypto-keygen-async-dsa-key-object.js
index c15807295541e2..a3df136230d0f8 100644
--- a/test/parallel/test-crypto-keygen-async-dsa-key-object.js
+++ b/test/parallel/test-crypto-keygen-async-dsa-key-object.js
@@ -9,23 +9,25 @@ const {
   generateKeyPair,
 } = require('crypto');
 
+const { hasOpenSSL3 } = require('../common/crypto');
+
 // Test async DSA key object generation.
 {
   generateKeyPair('dsa', {
-    modulusLength: common.hasOpenSSL3 ? 2048 : 512,
+    modulusLength: hasOpenSSL3 ? 2048 : 512,
     divisorLength: 256
   }, common.mustSucceed((publicKey, privateKey) => {
     assert.strictEqual(publicKey.type, 'public');
     assert.strictEqual(publicKey.asymmetricKeyType, 'dsa');
     assert.deepStrictEqual(publicKey.asymmetricKeyDetails, {
-      modulusLength: common.hasOpenSSL3 ? 2048 : 512,
+      modulusLength: hasOpenSSL3 ? 2048 : 512,
       divisorLength: 256
     });
 
     assert.strictEqual(privateKey.type, 'private');
     assert.strictEqual(privateKey.asymmetricKeyType, 'dsa');
     assert.deepStrictEqual(privateKey.asymmetricKeyDetails, {
-      modulusLength: common.hasOpenSSL3 ? 2048 : 512,
+      modulusLength: hasOpenSSL3 ? 2048 : 512,
       divisorLength: 256
     });
   }));
diff --git a/test/parallel/test-crypto-keygen-async-dsa.js b/test/parallel/test-crypto-keygen-async-dsa.js
index 048c0ce6fb92ef..41968d8cc23365 100644
--- a/test/parallel/test-crypto-keygen-async-dsa.js
+++ b/test/parallel/test-crypto-keygen-async-dsa.js
@@ -14,6 +14,8 @@ const {
   spkiExp,
 } = require('../common/crypto');
 
+const { hasOpenSSL3 } = require('../common/crypto');
+
 // Test async DSA key generation.
 {
   const privateKeyEncoding = {
@@ -22,7 +24,7 @@ const {
   };
 
   generateKeyPair('dsa', {
-    modulusLength: common.hasOpenSSL3 ? 2048 : 512,
+    modulusLength: hasOpenSSL3 ? 2048 : 512,
     divisorLength: 256,
     publicKeyEncoding: {
       type: 'spki',
@@ -39,8 +41,8 @@ const {
     // The private key is DER-encoded.
     assert(Buffer.isBuffer(privateKeyDER));
 
-    assertApproximateSize(publicKey, common.hasOpenSSL3 ? 1194 : 440);
-    assertApproximateSize(privateKeyDER, common.hasOpenSSL3 ? 721 : 336);
+    assertApproximateSize(publicKey, hasOpenSSL3 ? 1194 : 440);
+    assertApproximateSize(privateKeyDER, hasOpenSSL3 ? 721 : 336);
 
     // Since the private key is encrypted, signing shouldn't work anymore.
     assert.throws(() => {
diff --git a/test/parallel/test-crypto-keygen-async-explicit-elliptic-curve-encrypted-p256.js b/test/parallel/test-crypto-keygen-async-explicit-elliptic-curve-encrypted-p256.js
index 553674774571d3..55aa3831c4233b 100644
--- a/test/parallel/test-crypto-keygen-async-explicit-elliptic-curve-encrypted-p256.js
+++ b/test/parallel/test-crypto-keygen-async-explicit-elliptic-curve-encrypted-p256.js
@@ -14,6 +14,8 @@ const {
   pkcs8EncExp,
 } = require('../common/crypto');
 
+const { hasOpenSSL3 } = require('../common/crypto');
+
 // Test async elliptic curve key generation, e.g. for ECDSA, with an encrypted
 // private key with paramEncoding explicit.
 {
@@ -38,7 +40,7 @@ const {
 
     // Since the private key is encrypted, signing shouldn't work anymore.
     assert.throws(() => testSignVerify(publicKey, privateKey),
-                  common.hasOpenSSL3 ? {
+                  hasOpenSSL3 ? {
                     message: 'error:07880109:common libcrypto ' +
                              'routines::interrupted or cancelled'
                   } : {
diff --git a/test/parallel/test-crypto-keygen-async-explicit-elliptic-curve-encrypted.js.js b/test/parallel/test-crypto-keygen-async-explicit-elliptic-curve-encrypted.js.js
index 79a132eed0b854..8a55d4338bc72f 100644
--- a/test/parallel/test-crypto-keygen-async-explicit-elliptic-curve-encrypted.js.js
+++ b/test/parallel/test-crypto-keygen-async-explicit-elliptic-curve-encrypted.js.js
@@ -12,6 +12,7 @@ const {
   testSignVerify,
   spkiExp,
   sec1EncExp,
+  hasOpenSSL3,
 } = require('../common/crypto');
 
 {
@@ -38,7 +39,7 @@ const {
 
     // Since the private key is encrypted, signing shouldn't work anymore.
     assert.throws(() => testSignVerify(publicKey, privateKey),
-                  common.hasOpenSSL3 ? {
+                  hasOpenSSL3 ? {
                     message: 'error:07880109:common libcrypto ' +
                              'routines::interrupted or cancelled'
                   } : {
diff --git a/test/parallel/test-crypto-keygen-async-named-elliptic-curve-encrypted-p256.js b/test/parallel/test-crypto-keygen-async-named-elliptic-curve-encrypted-p256.js
index 5e7d1a6c9b6611..4c11401d0fc516 100644
--- a/test/parallel/test-crypto-keygen-async-named-elliptic-curve-encrypted-p256.js
+++ b/test/parallel/test-crypto-keygen-async-named-elliptic-curve-encrypted-p256.js
@@ -12,6 +12,7 @@ const {
   testSignVerify,
   spkiExp,
   pkcs8EncExp,
+  hasOpenSSL3,
 } = require('../common/crypto');
 
 // Test async elliptic curve key generation, e.g. for ECDSA, with an encrypted
@@ -38,7 +39,7 @@ const {
 
     // Since the private key is encrypted, signing shouldn't work anymore.
     assert.throws(() => testSignVerify(publicKey, privateKey),
-                  common.hasOpenSSL3 ? {
+                  hasOpenSSL3 ? {
                     message: 'error:07880109:common libcrypto ' +
                              'routines::interrupted or cancelled'
                   } : {
diff --git a/test/parallel/test-crypto-keygen-async-named-elliptic-curve-encrypted.js b/test/parallel/test-crypto-keygen-async-named-elliptic-curve-encrypted.js
index 1cc93d0a794931..0503ff74787f37 100644
--- a/test/parallel/test-crypto-keygen-async-named-elliptic-curve-encrypted.js
+++ b/test/parallel/test-crypto-keygen-async-named-elliptic-curve-encrypted.js
@@ -12,6 +12,7 @@ const {
   testSignVerify,
   spkiExp,
   sec1EncExp,
+  hasOpenSSL3,
 } = require('../common/crypto');
 
 {
@@ -38,7 +39,7 @@ const {
 
     // Since the private key is encrypted, signing shouldn't work anymore.
     assert.throws(() => testSignVerify(publicKey, privateKey),
-                  common.hasOpenSSL3 ? {
+                  hasOpenSSL3 ? {
                     message: 'error:07880109:common libcrypto ' +
                              'routines::interrupted or cancelled'
                   } : {
diff --git a/test/parallel/test-crypto-keygen-async-rsa.js b/test/parallel/test-crypto-keygen-async-rsa.js
index f4a83809dc73c7..c80d7d33492923 100644
--- a/test/parallel/test-crypto-keygen-async-rsa.js
+++ b/test/parallel/test-crypto-keygen-async-rsa.js
@@ -13,6 +13,7 @@ const {
   testEncryptDecrypt,
   testSignVerify,
   pkcs1EncExp,
+  hasOpenSSL3,
 } = require('../common/crypto');
 
 // Test async RSA key generation with an encrypted private key.
@@ -43,7 +44,7 @@ const {
       type: 'pkcs1',
       format: 'der',
     };
-    const expectedError = common.hasOpenSSL3 ? {
+    const expectedError = hasOpenSSL3 ? {
       name: 'Error',
       message: 'error:07880109:common libcrypto routines::interrupted or ' +
                'cancelled'
diff --git a/test/parallel/test-crypto-keygen-bit-length.js b/test/parallel/test-crypto-keygen-bit-length.js
index 08772ba2e496b8..63a80659bb2f53 100644
--- a/test/parallel/test-crypto-keygen-bit-length.js
+++ b/test/parallel/test-crypto-keygen-bit-length.js
@@ -8,6 +8,7 @@ const assert = require('assert');
 const {
   generateKeyPair,
 } = require('crypto');
+const { hasOpenSSL3 } = require('../common/crypto');
 
 // This tests check that generateKeyPair returns correct bit length in
 // KeyObject's asymmetricKeyDetails.
@@ -27,7 +28,7 @@ const {
     assert.strictEqual(publicKey.asymmetricKeyDetails.modulusLength, 513);
   }));
 
-  if (common.hasOpenSSL3) {
+  if (hasOpenSSL3) {
     generateKeyPair('dsa', {
       modulusLength: 2049,
       divisorLength: 256,
diff --git a/test/parallel/test-crypto-keygen-empty-passphrase-no-prompt.js b/test/parallel/test-crypto-keygen-empty-passphrase-no-prompt.js
index 7679a492c3194c..cb873ff04748b7 100644
--- a/test/parallel/test-crypto-keygen-empty-passphrase-no-prompt.js
+++ b/test/parallel/test-crypto-keygen-empty-passphrase-no-prompt.js
@@ -11,6 +11,7 @@ const {
 } = require('crypto');
 const {
   testSignVerify,
+  hasOpenSSL3,
 } = require('../common/crypto');
 
 // Passing an empty passphrase string should not cause OpenSSL's default
@@ -40,7 +41,7 @@ for (const type of ['pkcs1', 'pkcs8']) {
     // the key, and not specifying a passphrase should fail when decoding it.
     assert.throws(() => {
       return testSignVerify(publicKey, privateKey);
-    }, common.hasOpenSSL3 ? {
+    }, hasOpenSSL3 ? {
       name: 'Error',
       code: 'ERR_OSSL_CRYPTO_INTERRUPTED_OR_CANCELLED',
       message: 'error:07880109:common libcrypto routines::interrupted or cancelled'
diff --git a/test/parallel/test-crypto-keygen-missing-oid.js b/test/parallel/test-crypto-keygen-missing-oid.js
index f7fefe13848d4b..1e4f309292eb47 100644
--- a/test/parallel/test-crypto-keygen-missing-oid.js
+++ b/test/parallel/test-crypto-keygen-missing-oid.js
@@ -11,6 +11,8 @@ const {
   getCurves,
 } = require('crypto');
 
+const { hasOpenSSL3 } = require('../common/crypto');
+
 // This test creates EC key pairs on curves without associated OIDs.
 // Specifying a key encoding should not crash.
 {
@@ -20,7 +22,7 @@ const {
         continue;
 
       const expectedErrorCode =
-        common.hasOpenSSL3 ? 'ERR_OSSL_MISSING_OID' : 'ERR_OSSL_EC_MISSING_OID';
+        hasOpenSSL3 ? 'ERR_OSSL_MISSING_OID' : 'ERR_OSSL_EC_MISSING_OID';
       const params = {
         namedCurve,
         publicKeyEncoding: {
diff --git a/test/parallel/test-crypto-keygen.js b/test/parallel/test-crypto-keygen.js
index b09ca9e7c531ea..edaee845075668 100644
--- a/test/parallel/test-crypto-keygen.js
+++ b/test/parallel/test-crypto-keygen.js
@@ -14,6 +14,7 @@ const {
 } = require('crypto');
 const { inspect } = require('util');
 
+const { hasOpenSSL3 } = require('../common/crypto');
 
 // Test invalid parameter encoding.
 {
@@ -351,7 +352,7 @@ const { inspect } = require('util');
       publicExponent
     }, common.mustCall((err) => {
       assert.strictEqual(err.name, 'Error');
-      assert.match(err.message, common.hasOpenSSL3 ? /exponent/ : /bad e value/);
+      assert.match(err.message, hasOpenSSL3 ? /exponent/ : /bad e value/);
     }));
   }
 }
diff --git a/test/parallel/test-crypto-no-algorithm.js b/test/parallel/test-crypto-no-algorithm.js
index 37db38cf613b65..06124e3d465e41 100644
--- a/test/parallel/test-crypto-no-algorithm.js
+++ b/test/parallel/test-crypto-no-algorithm.js
@@ -4,7 +4,9 @@ const common = require('../common');
 if (!common.hasCrypto)
   common.skip('missing crypto');
 
-if (!common.hasOpenSSL3)
+const { hasOpenSSL3 } = require('../common/crypto');
+
+if (!hasOpenSSL3)
   common.skip('this test requires OpenSSL 3.x');
 
 const assert = require('node:assert/strict');
diff --git a/test/parallel/test-crypto-oneshot-hash.js b/test/parallel/test-crypto-oneshot-hash.js
index 69051c43d9e882..861aded5dd3f60 100644
--- a/test/parallel/test-crypto-oneshot-hash.js
+++ b/test/parallel/test-crypto-oneshot-hash.js
@@ -8,6 +8,7 @@ if (!common.hasCrypto)
 const assert = require('assert');
 const crypto = require('crypto');
 const fixtures = require('../common/fixtures');
+const { hasOpenSSL } = require('../common/crypto');
 const fs = require('fs');
 
 // Test errors for invalid arguments.
@@ -32,7 +33,7 @@ const input = fs.readFileSync(fixtures.path('utf8_test_text.txt'));
 
 for (const method of methods) {
   // Skip failing tests on OpenSSL 3.4.0
-  if (method.startsWith('shake') && common.hasOpenSSL(3, 4))
+  if (method.startsWith('shake') && hasOpenSSL(3, 4))
     continue;
   for (const outputEncoding of ['buffer', 'hex', 'base64', undefined]) {
     const oldDigest = crypto.createHash(method).update(input).digest(outputEncoding || 'hex');
diff --git a/test/parallel/test-crypto-padding.js b/test/parallel/test-crypto-padding.js
index f1f14b472997e7..48cd1ed4df61aa 100644
--- a/test/parallel/test-crypto-padding.js
+++ b/test/parallel/test-crypto-padding.js
@@ -26,6 +26,7 @@ if (!common.hasCrypto)
 
 const assert = require('assert');
 const crypto = require('crypto');
+const { hasOpenSSL3 } = require('../common/crypto');
 
 // Input data.
 const ODD_LENGTH_PLAIN = 'Hello node world!';
@@ -82,7 +83,7 @@ assert.strictEqual(enc(EVEN_LENGTH_PLAIN, true), EVEN_LENGTH_ENCRYPTED);
 assert.throws(function() {
   // Input must have block length %.
   enc(ODD_LENGTH_PLAIN, false);
-}, common.hasOpenSSL3 ? {
+}, hasOpenSSL3 ? {
   message: 'error:1C80006B:Provider routines::wrong final block length',
   code: 'ERR_OSSL_WRONG_FINAL_BLOCK_LENGTH',
   reason: 'wrong final block length',
@@ -109,7 +110,7 @@ assert.strictEqual(dec(EVEN_LENGTH_ENCRYPTED, false).length, 48);
 assert.throws(function() {
   // Must have at least 1 byte of padding (PKCS):
   assert.strictEqual(dec(EVEN_LENGTH_ENCRYPTED_NOPAD, true), EVEN_LENGTH_PLAIN);
-}, common.hasOpenSSL3 ? {
+}, hasOpenSSL3 ? {
   message: 'error:1C800064:Provider routines::bad decrypt',
   reason: 'bad decrypt',
   code: 'ERR_OSSL_BAD_DECRYPT',
diff --git a/test/parallel/test-crypto-pbkdf2.js b/test/parallel/test-crypto-pbkdf2.js
index 1f8e6a81f300e7..efd8d6eaf0d640 100644
--- a/test/parallel/test-crypto-pbkdf2.js
+++ b/test/parallel/test-crypto-pbkdf2.js
@@ -5,6 +5,7 @@ if (!common.hasCrypto)
 
 const assert = require('assert');
 const crypto = require('crypto');
+const { hasOpenSSL3 } = require('../common/crypto');
 
 function runPBKDF2(password, salt, iterations, keylen, hash) {
   const syncResult =
@@ -219,7 +220,7 @@ assert.throws(
   }
 );
 
-if (!common.hasOpenSSL3) {
+if (!hasOpenSSL3) {
   const kNotPBKDF2Supported = ['shake128', 'shake256'];
   crypto.getHashes()
     .filter((hash) => !kNotPBKDF2Supported.includes(hash))
diff --git a/test/parallel/test-crypto-private-decrypt-gh32240.js b/test/parallel/test-crypto-private-decrypt-gh32240.js
index e88227a215ba4f..1ff5b565d6d5f4 100644
--- a/test/parallel/test-crypto-private-decrypt-gh32240.js
+++ b/test/parallel/test-crypto-private-decrypt-gh32240.js
@@ -14,6 +14,8 @@ const {
   privateDecrypt,
 } = require('crypto');
 
+const { hasOpenSSL3 } = require('../common/crypto');
+
 const pair = generateKeyPairSync('rsa', { modulusLength: 512 });
 
 const expected = Buffer.from('shibboleth');
@@ -34,7 +36,7 @@ function decrypt(key) {
 }
 
 decrypt(pkey);
-assert.throws(() => decrypt(pkeyEncrypted), common.hasOpenSSL3 ?
+assert.throws(() => decrypt(pkeyEncrypted), hasOpenSSL3 ?
   { message: 'error:07880109:common libcrypto routines::interrupted or ' +
              'cancelled' } :
   { code: 'ERR_MISSING_PASSPHRASE' });
diff --git a/test/parallel/test-crypto-publicDecrypt-fails-first-time.js b/test/parallel/test-crypto-publicDecrypt-fails-first-time.js
index a60b87dbf65229..1d64e08920c63b 100644
--- a/test/parallel/test-crypto-publicDecrypt-fails-first-time.js
+++ b/test/parallel/test-crypto-publicDecrypt-fails-first-time.js
@@ -3,11 +3,15 @@ const common = require('../common');
 
 // Test for https://github.com/nodejs/node/issues/40814
 
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
+}
 
-if (!common.hasOpenSSL3)
+const { hasOpenSSL3 } = require('../common/crypto');
+
+if (!hasOpenSSL3) {
   common.skip('only openssl3'); // https://github.com/nodejs/node/pull/42793#issuecomment-1107491901
+}
 
 const assert = require('assert');
 const crypto = require('crypto');
diff --git a/test/parallel/test-crypto-rsa-dsa.js b/test/parallel/test-crypto-rsa-dsa.js
index 5f4fafdfffbf72..dcd5045daaf58c 100644
--- a/test/parallel/test-crypto-rsa-dsa.js
+++ b/test/parallel/test-crypto-rsa-dsa.js
@@ -9,6 +9,7 @@ const crypto = require('crypto');
 const constants = crypto.constants;
 
 const fixtures = require('../common/fixtures');
+const { hasOpenSSL3 } = require('../common/crypto');
 
 // Test certificates
 const certPem = fixtures.readKey('rsa_cert.crt');
@@ -36,11 +37,11 @@ const openssl1DecryptError = {
   library: 'digital envelope routines',
 };
 
-const decryptError = common.hasOpenSSL3 ?
+const decryptError = hasOpenSSL3 ?
   { message: 'error:1C800064:Provider routines::bad decrypt' } :
   openssl1DecryptError;
 
-const decryptPrivateKeyError = common.hasOpenSSL3 ? {
+const decryptPrivateKeyError = hasOpenSSL3 ? {
   message: 'error:1C800064:Provider routines::bad decrypt',
 } : openssl1DecryptError;
 
@@ -146,7 +147,7 @@ function getBufferCopy(buf) {
   // Now with RSA_NO_PADDING. Plaintext needs to match key size.
   // OpenSSL 3.x has a rsa_check_padding that will cause an error if
   // RSA_NO_PADDING is used.
-  if (!common.hasOpenSSL3) {
+  if (!hasOpenSSL3) {
     {
       const plaintext = 'x'.repeat(rsaKeySize / 8);
       encryptedBuffer = crypto.privateEncrypt({
diff --git a/test/parallel/test-crypto-secure-heap.js b/test/parallel/test-crypto-secure-heap.js
index 0e5788f00e4a44..c20b01a91a9840 100644
--- a/test/parallel/test-crypto-secure-heap.js
+++ b/test/parallel/test-crypto-secure-heap.js
@@ -1,21 +1,26 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
+}
 
-if (common.isWindows)
+if (common.isWindows) {
   common.skip('Not supported on Windows');
+}
 
-if (common.isASan)
+if (common.isASan) {
   common.skip('ASan does not play well with secure heap allocations');
+}
 
 const assert = require('assert');
 const { fork } = require('child_process');
 const fixtures = require('../common/fixtures');
+const { hasOpenSSL3 } = require('../common/crypto');
 const {
   secureHeapUsed,
   createDiffieHellman,
+  getFips,
 } = require('crypto');
 
 if (process.argv[2] === 'child') {
@@ -29,7 +34,7 @@ if (process.argv[2] === 'child') {
   assert.strictEqual(a.used, 0);
 
   {
-    const size = common.hasFipsCrypto || common.hasOpenSSL3 ? 1024 : 256;
+    const size = getFips() || hasOpenSSL3 ? 1024 : 256;
     const dh1 = createDiffieHellman(size);
     const p1 = dh1.getPrime('buffer');
     const dh2 = createDiffieHellman(p1, 'buffer');
diff --git a/test/parallel/test-crypto-sign-verify.js b/test/parallel/test-crypto-sign-verify.js
index 8a263ec3350f55..0589d60736e377 100644
--- a/test/parallel/test-crypto-sign-verify.js
+++ b/test/parallel/test-crypto-sign-verify.js
@@ -8,6 +8,10 @@ const fs = require('fs');
 const exec = require('child_process').exec;
 const crypto = require('crypto');
 const fixtures = require('../common/fixtures');
+const {
+  hasOpenSSL3,
+  opensslCli,
+} = require('../common/crypto');
 
 // Test certificates
 const certPem = fixtures.readKey('rsa_cert.crt');
@@ -62,7 +66,7 @@ const keySize = 2048;
         key: keyPem,
         padding: crypto.constants.RSA_PKCS1_OAEP_PADDING
       });
-  }, { message: common.hasOpenSSL3 ?
+  }, { message: hasOpenSSL3 ?
     'error:1C8000A5:Provider routines::illegal or unsupported padding mode' :
     'bye, bye, error stack' });
 
@@ -340,7 +344,7 @@ assert.throws(
         key: keyPem,
         padding: crypto.constants.RSA_PKCS1_OAEP_PADDING
       });
-  }, common.hasOpenSSL3 ? {
+  }, hasOpenSSL3 ? {
     code: 'ERR_OSSL_ILLEGAL_OR_UNSUPPORTED_PADDING_MODE',
     message: /illegal or unsupported padding mode/,
   } : {
@@ -599,8 +603,9 @@ assert.throws(
 // Note: this particular test *must* be the last in this file as it will exit
 // early if no openssl binary is found
 {
-  if (!common.opensslCli)
+  if (!opensslCli) {
     common.skip('node compiled without OpenSSL CLI.');
+  }
 
   const pubfile = fixtures.path('keys', 'rsa_public_2048.pem');
   const privkey = fixtures.readKey('rsa_private_2048.pem');
@@ -622,7 +627,7 @@ assert.throws(
   fs.writeFileSync(msgfile, msg);
 
   exec(...common.escapePOSIXShell`"${
-    common.opensslCli}" dgst -sha256 -verify "${pubfile}" -signature "${
+    opensslCli}" dgst -sha256 -verify "${pubfile}" -signature "${
     sigfile}" -sigopt rsa_padding_mode:pss -sigopt rsa_pss_saltlen:-2 "${msgfile
   }"`, common.mustCall((err, stdout, stderr) => {
     assert(stdout.includes('Verified OK'));
diff --git a/test/parallel/test-crypto-stream.js b/test/parallel/test-crypto-stream.js
index 008ab129f0e019..62be4eaf6edfb0 100644
--- a/test/parallel/test-crypto-stream.js
+++ b/test/parallel/test-crypto-stream.js
@@ -21,14 +21,16 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
+}
 
 const assert = require('assert');
 const stream = require('stream');
 const crypto = require('crypto');
+const { hasOpenSSL3 } = require('../common/crypto');
 
-if (!common.hasFipsCrypto) {
+if (!crypto.getFips()) {
   // Small stream to buffer converter
   class Stream2buffer extends stream.Writable {
     constructor(callback) {
@@ -71,7 +73,7 @@ const cipher = crypto.createCipheriv('aes-128-cbc', key, iv);
 const decipher = crypto.createDecipheriv('aes-128-cbc', badkey, iv);
 
 cipher.pipe(decipher)
-  .on('error', common.expectsError(common.hasOpenSSL3 ? {
+  .on('error', common.expectsError(hasOpenSSL3 ? {
     message: /bad decrypt/,
     library: 'Provider routines',
     reason: 'bad decrypt',
diff --git a/test/parallel/test-crypto-x509.js b/test/parallel/test-crypto-x509.js
index bd906c25b9ee19..f75e1d63470bfb 100644
--- a/test/parallel/test-crypto-x509.js
+++ b/test/parallel/test-crypto-x509.js
@@ -18,6 +18,7 @@ const {
 
 const assert = require('assert');
 const fixtures = require('../common/fixtures');
+const { hasOpenSSL3 } = require('../common/crypto');
 const { readFileSync } = require('fs');
 
 const cert = readFileSync(fixtures.path('keys', 'agent1-cert.pem'));
@@ -50,7 +51,7 @@ emailAddress=ry@tinyclouds.org`;
 
 let infoAccessCheck = `OCSP - URI:http://ocsp.nodejs.org/
 CA Issuers - URI:http://ca.nodejs.org/ca.cert`;
-if (!common.hasOpenSSL3)
+if (!hasOpenSSL3)
   infoAccessCheck += '\n';
 
 const der = Buffer.from(
@@ -357,7 +358,7 @@ UcXd/5qu2GhokrKU2cPttU+XAN2Om6a0
 
   const cert = new X509Certificate(certPem);
   assert.throws(() => cert.publicKey, {
-    message: common.hasOpenSSL3 ? /decode error/ : /wrong tag/,
+    message: hasOpenSSL3 ? /decode error/ : /wrong tag/,
     name: 'Error'
   });
 
diff --git a/test/parallel/test-crypto.js b/test/parallel/test-crypto.js
index 4271121881379b..93644e016de447 100644
--- a/test/parallel/test-crypto.js
+++ b/test/parallel/test-crypto.js
@@ -29,6 +29,7 @@ const assert = require('assert');
 const crypto = require('crypto');
 const tls = require('tls');
 const fixtures = require('../common/fixtures');
+const { hasOpenSSL3 } = require('../common/crypto');
 
 // Test Certificates
 const certPfx = fixtures.readKey('rsa_cert.pfx');
@@ -208,9 +209,9 @@ assert.throws(() => {
   ].join('\n');
   crypto.createSign('SHA256').update('test').sign(priv);
 }, (err) => {
-  if (!common.hasOpenSSL3)
+  if (!hasOpenSSL3)
     assert.ok(!('opensslErrorStack' in err));
-  assert.throws(() => { throw err; }, common.hasOpenSSL3 ? {
+  assert.throws(() => { throw err; }, hasOpenSSL3 ? {
     name: 'Error',
     message: 'error:02000070:rsa routines::digest too big for rsa key',
     library: 'rsa routines',
@@ -225,7 +226,7 @@ assert.throws(() => {
   return true;
 });
 
-if (!common.hasOpenSSL3) {
+if (!hasOpenSSL3) {
   assert.throws(() => {
     // The correct header inside `rsa_private_pkcs8_bad.pem` should have been
     // -----BEGIN PRIVATE KEY----- and -----END PRIVATE KEY-----
diff --git a/test/parallel/test-dsa-fips-invalid-key.js b/test/parallel/test-dsa-fips-invalid-key.js
index 05cc1d143aca6e..3df51bfbed3517 100644
--- a/test/parallel/test-dsa-fips-invalid-key.js
+++ b/test/parallel/test-dsa-fips-invalid-key.js
@@ -1,12 +1,18 @@
 'use strict';
 const common = require('../common');
+
+if (!common.hasCrypto) {
+  common.skip('no crypto');
+}
+
 const fixtures = require('../common/fixtures');
+const crypto = require('crypto');
 
-if (!common.hasFipsCrypto)
+if (!crypto.getFips()) {
   common.skip('node compiled without FIPS OpenSSL.');
+}
 
 const assert = require('assert');
-const crypto = require('crypto');
 
 const input = 'hello';
 
diff --git a/test/parallel/test-https-agent-session-eviction.js b/test/parallel/test-https-agent-session-eviction.js
index e0986e53c1103b..6f88e81e9ff29d 100644
--- a/test/parallel/test-https-agent-session-eviction.js
+++ b/test/parallel/test-https-agent-session-eviction.js
@@ -2,10 +2,13 @@
 'use strict';
 
 const common = require('../common');
-const { readKey } = require('../common/fixtures');
 
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
+}
+
+const { readKey } = require('../common/fixtures');
+const { hasOpenSSL } = require('../common/crypto');
 
 const https = require('https');
 const { SSL_OP_NO_TICKET } = require('crypto').constants;
@@ -56,7 +59,7 @@ function faultyServer(port) {
 function second(server, session) {
   const req = https.request({
     port: server.address().port,
-    ciphers: (common.hasOpenSSL(3, 1) ? 'DEFAULT:@SECLEVEL=0' : 'DEFAULT'),
+    ciphers: (hasOpenSSL(3, 1) ? 'DEFAULT:@SECLEVEL=0' : 'DEFAULT'),
     rejectUnauthorized: false
   }, function(res) {
     res.resume();
diff --git a/test/parallel/test-https-client-renegotiation-limit.js b/test/parallel/test-https-client-renegotiation-limit.js
index 35fcc6bfcc6e43..18a602d738c316 100644
--- a/test/parallel/test-https-client-renegotiation-limit.js
+++ b/test/parallel/test-https-client-renegotiation-limit.js
@@ -21,11 +21,15 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
+}
+
+const { opensslCli } = require('../common/crypto');
 
-if (!common.opensslCli)
+if (!opensslCli) {
   common.skip('node compiled without OpenSSL CLI.');
+}
 
 const assert = require('assert');
 const tls = require('tls');
diff --git a/test/parallel/test-https-foafssl.js b/test/parallel/test-https-foafssl.js
index d6dde97a41da9c..df375e7d22201e 100644
--- a/test/parallel/test-https-foafssl.js
+++ b/test/parallel/test-https-foafssl.js
@@ -21,11 +21,15 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
+}
 
-if (!common.opensslCli)
+const { opensslCli } = require('../common/crypto');
+
+if (!opensslCli) {
   common.skip('node compiled without OpenSSL CLI.');
+}
 
 const assert = require('assert');
 const fixtures = require('../common/fixtures');
@@ -67,7 +71,7 @@ server.listen(0, function() {
                 '-cert', fixtures.path('keys/rsa_cert_foafssl_b.crt'),
                 '-key', fixtures.path('keys/rsa_private_b.pem')];
 
-  const client = spawn(common.opensslCli, args);
+  const client = spawn(opensslCli, args);
 
   client.stdout.on('data', function(data) {
     console.log('response received');
diff --git a/test/parallel/test-process-env-allowed-flags-are-documented.js b/test/parallel/test-process-env-allowed-flags-are-documented.js
index 2a40a821314ff3..070a88bca8c12c 100644
--- a/test/parallel/test-process-env-allowed-flags-are-documented.js
+++ b/test/parallel/test-process-env-allowed-flags-are-documented.js
@@ -5,6 +5,7 @@ const common = require('../common');
 const assert = require('assert');
 const fs = require('fs');
 const path = require('path');
+const { hasOpenSSL3 } = require('../common/crypto');
 
 const rootDir = path.resolve(__dirname, '..', '..');
 const cliMd = path.join(rootDir, 'doc', 'api', 'cli.md');
@@ -43,7 +44,7 @@ for (const line of [...nodeOptionsLines, ...v8OptionsLines]) {
   }
 }
 
-if (!common.hasOpenSSL3) {
+if (!hasOpenSSL3) {
   documented.delete('--openssl-legacy-provider');
   documented.delete('--openssl-shared-config');
 }
@@ -55,8 +56,8 @@ const conditionalOpts = [
     filter: (opt) => {
       return [
         '--openssl-config',
-        common.hasOpenSSL3 ? '--openssl-legacy-provider' : '',
-        common.hasOpenSSL3 ? '--openssl-shared-config' : '',
+        hasOpenSSL3 ? '--openssl-legacy-provider' : '',
+        hasOpenSSL3 ? '--openssl-shared-config' : '',
         '--tls-cipher-list',
         '--use-bundled-ca',
         '--use-openssl-ca',
diff --git a/test/parallel/test-process-versions.js b/test/parallel/test-process-versions.js
index 3b8af4b5b52526..0a2a4014f18d6b 100644
--- a/test/parallel/test-process-versions.js
+++ b/test/parallel/test-process-versions.js
@@ -85,11 +85,12 @@ assert.match(process.versions.modules, /^\d+$/);
 assert.match(process.versions.cjs_module_lexer, commonTemplate);
 
 if (common.hasCrypto) {
+  const { hasOpenSSL3 } = require('../common/crypto');
   assert.match(process.versions.ncrypto, commonTemplate);
   if (process.config.variables.node_shared_openssl) {
     assert.ok(process.versions.openssl);
   } else {
-    const versionRegex = common.hasOpenSSL3 ?
+    const versionRegex = hasOpenSSL3 ?
       // The following also matches a development version of OpenSSL 3.x which
       // can be in the format '3.0.0-alpha4-dev'. This can be handy when
       // building and linking against the main development branch of OpenSSL.
diff --git a/test/parallel/test-tls-alert-handling.js b/test/parallel/test-tls-alert-handling.js
index b14438bc92d7e6..eec072796063dc 100644
--- a/test/parallel/test-tls-alert-handling.js
+++ b/test/parallel/test-tls-alert-handling.js
@@ -1,11 +1,19 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
+}
+
+const {
+  hasOpenSSL,
+  hasOpenSSL3,
+  opensslCli,
+} = require('../common/crypto');
 
-if (!common.opensslCli)
+if (!opensslCli) {
   common.skip('node compiled without OpenSSL CLI');
+}
 
 const assert = require('assert');
 const net = require('net');
@@ -33,14 +41,14 @@ let iter = 0;
 const errorHandler = common.mustCall((err) => {
   let expectedErrorCode = 'ERR_SSL_WRONG_VERSION_NUMBER';
   let expectedErrorReason = 'wrong version number';
-  if (common.hasOpenSSL(3, 2)) {
+  if (hasOpenSSL(3, 2)) {
     expectedErrorCode = 'ERR_SSL_PACKET_LENGTH_TOO_LONG';
     expectedErrorReason = 'packet length too long';
   };
 
   assert.strictEqual(err.code, expectedErrorCode);
   assert.strictEqual(err.library, 'SSL routines');
-  if (!common.hasOpenSSL3) assert.strictEqual(err.function, 'ssl3_get_record');
+  if (!hasOpenSSL3) assert.strictEqual(err.function, 'ssl3_get_record');
   assert.strictEqual(err.reason, expectedErrorReason);
   errorReceived = true;
   if (canCloseServer())
@@ -96,13 +104,13 @@ function sendBADTLSRecord() {
   client.on('error', common.mustCall((err) => {
     let expectedErrorCode = 'ERR_SSL_TLSV1_ALERT_PROTOCOL_VERSION';
     let expectedErrorReason = 'tlsv1 alert protocol version';
-    if (common.hasOpenSSL(3, 2)) {
+    if (hasOpenSSL(3, 2)) {
       expectedErrorCode = 'ERR_SSL_TLSV1_ALERT_RECORD_OVERFLOW';
       expectedErrorReason = 'tlsv1 alert record overflow';
     }
     assert.strictEqual(err.code, expectedErrorCode);
     assert.strictEqual(err.library, 'SSL routines');
-    if (!common.hasOpenSSL3)
+    if (!hasOpenSSL3)
       assert.strictEqual(err.function, 'ssl3_read_bytes');
     assert.strictEqual(err.reason, expectedErrorReason);
   }));
diff --git a/test/parallel/test-tls-alert.js b/test/parallel/test-tls-alert.js
index e6aaaedfe59d72..23c92e7293458f 100644
--- a/test/parallel/test-tls-alert.js
+++ b/test/parallel/test-tls-alert.js
@@ -21,11 +21,18 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
+}
+
+const {
+  hasOpenSSL,
+  opensslCli,
+} = require('../common/crypto');
 
-if (!common.opensslCli)
+if (!opensslCli) {
   common.skip('node compiled without OpenSSL CLI.');
+}
 
 const assert = require('assert');
 const { execFile } = require('child_process');
@@ -42,10 +49,10 @@ const server = tls.Server({
   cert: loadPEM('agent2-cert')
 }, null).listen(0, common.mustCall(() => {
   const args = ['s_client', '-quiet', '-tls1_1',
-                '-cipher', (common.hasOpenSSL(3, 1) ? 'DEFAULT:@SECLEVEL=0' : 'DEFAULT'),
+                '-cipher', (hasOpenSSL(3, 1) ? 'DEFAULT:@SECLEVEL=0' : 'DEFAULT'),
                 '-connect', `127.0.0.1:${server.address().port}`];
 
-  execFile(common.opensslCli, args, common.mustCall((err, _, stderr) => {
+  execFile(opensslCli, args, common.mustCall((err, _, stderr) => {
     assert.strictEqual(err.code, 1);
     assert.match(stderr, /SSL alert number 70/);
     server.close();
diff --git a/test/parallel/test-tls-alpn-server-client.js b/test/parallel/test-tls-alpn-server-client.js
index 8f1a4b8e439aab..b7cd2806471e67 100644
--- a/test/parallel/test-tls-alpn-server-client.js
+++ b/test/parallel/test-tls-alpn-server-client.js
@@ -1,8 +1,9 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
+}
 
 const assert = require('assert');
 const { spawn } = require('child_process');
@@ -198,7 +199,7 @@ function TestFatalAlert() {
 
       // OpenSSL's s_client should output the TLS alert number, which is 120
       // for the 'no_application_protocol' alert.
-      const { opensslCli } = common;
+      const { opensslCli } = require('../common/crypto');
       if (opensslCli) {
         const addr = `${serverIP}:${port}`;
         let stderr = '';
diff --git a/test/parallel/test-tls-cert-ext-encoding.js b/test/parallel/test-tls-cert-ext-encoding.js
index 4556b5791851c5..154e0cdcf02294 100644
--- a/test/parallel/test-tls-cert-ext-encoding.js
+++ b/test/parallel/test-tls-cert-ext-encoding.js
@@ -3,7 +3,9 @@ const common = require('../common');
 if (!common.hasCrypto)
   common.skip('missing crypto');
 
-if (common.hasOpenSSL3)
+const { hasOpenSSL3 } = require('../common/crypto');
+
+if (hasOpenSSL3)
   // TODO(danbev) This test fails with the following error:
   // error:0D00008F:asn1 encoding routines::no matching choice type
   //
diff --git a/test/parallel/test-tls-client-auth.js b/test/parallel/test-tls-client-auth.js
index de4c8f038ec073..b347c0a88df571 100644
--- a/test/parallel/test-tls-client-auth.js
+++ b/test/parallel/test-tls-client-auth.js
@@ -3,6 +3,11 @@
 const common = require('../common');
 const fixtures = require('../common/fixtures');
 
+if (!common.hasCrypto) {
+  common.skip('missing crypto');
+}
+const { hasOpenSSL } = require('../common/crypto');
+
 const {
   assert, connect, keys, tls
 } = require(fixtures.path('tls-connect'));
@@ -79,7 +84,7 @@ connect({
 }, function(err, pair, cleanup) {
   assert.strictEqual(pair.server.err.code,
                      'ERR_SSL_PEER_DID_NOT_RETURN_A_CERTIFICATE');
-  const expectedErr = common.hasOpenSSL(3, 2) ?
+  const expectedErr = hasOpenSSL(3, 2) ?
     'ERR_SSL_SSL/TLS_ALERT_HANDSHAKE_FAILURE' : 'ERR_SSL_SSLV3_ALERT_HANDSHAKE_FAILURE';
   assert.strictEqual(pair.client.err.code,
                      expectedErr);
diff --git a/test/parallel/test-tls-client-getephemeralkeyinfo.js b/test/parallel/test-tls-client-getephemeralkeyinfo.js
index 0bacd8702fc650..0f132c565e4400 100644
--- a/test/parallel/test-tls-client-getephemeralkeyinfo.js
+++ b/test/parallel/test-tls-client-getephemeralkeyinfo.js
@@ -3,6 +3,7 @@ const common = require('../common');
 if (!common.hasCrypto)
   common.skip('missing crypto');
 const fixtures = require('../common/fixtures');
+const { hasOpenSSL } = require('../common/crypto');
 
 const assert = require('assert');
 const { X509Certificate } = require('crypto');
@@ -69,7 +70,7 @@ function test(size, type, name, cipher) {
 
 test(undefined, undefined, undefined, 'AES256-SHA256');
 test('auto', 'DH', undefined, 'DHE-RSA-AES256-GCM-SHA384');
-if (!common.hasOpenSSL(3, 2)) {
+if (!hasOpenSSL(3, 2)) {
   test(1024, 'DH', undefined, 'DHE-RSA-AES256-GCM-SHA384');
 } else {
   test(3072, 'DH', undefined, 'DHE-RSA-AES256-GCM-SHA384');
diff --git a/test/parallel/test-tls-client-mindhsize.js b/test/parallel/test-tls-client-mindhsize.js
index 15c086842e1e4a..1ab5b5fe1bffd7 100644
--- a/test/parallel/test-tls-client-mindhsize.js
+++ b/test/parallel/test-tls-client-mindhsize.js
@@ -3,6 +3,7 @@ const common = require('../common');
 if (!common.hasCrypto)
   common.skip('missing crypto');
 
+const { hasOpenSSL } = require('../common/crypto');
 const assert = require('assert');
 const tls = require('tls');
 const fixtures = require('../common/fixtures');
@@ -38,7 +39,7 @@ function test(size, err, next) {
     // Client set minimum DH parameter size to 2048 or 3072 bits
     // so that it fails when it makes a connection to the tls
     // server where is too small
-    const minDHSize = common.hasOpenSSL(3, 2) ? 3072 : 2048;
+    const minDHSize = hasOpenSSL(3, 2) ? 3072 : 2048;
     const client = tls.connect({
       minDHSize: minDHSize,
       port: this.address().port,
@@ -76,7 +77,7 @@ function testDHE3072() {
   test(3072, false, null);
 }
 
-if (common.hasOpenSSL(3, 2)) {
+if (hasOpenSSL(3, 2)) {
   // Minimum size for OpenSSL 3.2 is 2048 by default
   testDHE2048(true, testDHE3072);
 } else {
diff --git a/test/parallel/test-tls-client-renegotiation-13.js b/test/parallel/test-tls-client-renegotiation-13.js
index a32baed0249a0a..38a72fb525b430 100644
--- a/test/parallel/test-tls-client-renegotiation-13.js
+++ b/test/parallel/test-tls-client-renegotiation-13.js
@@ -1,6 +1,12 @@
 'use strict';
 
 const common = require('../common');
+
+if (!common.hasCrypto) {
+  common.skip('missing crypto');
+}
+const { hasOpenSSL3 } = require('../common/crypto');
+
 const fixtures = require('../common/fixtures');
 
 // Confirm that for TLSv1.3, renegotiate() is disallowed.
@@ -29,7 +35,7 @@ connect({
 
   const ok = client.renegotiate({}, common.mustCall((err) => {
     assert.throws(() => { throw err; }, {
-      message: common.hasOpenSSL3 ?
+      message: hasOpenSSL3 ?
         'error:0A00010A:SSL routines::wrong ssl version' :
         'error:1420410A:SSL routines:SSL_renegotiate:wrong ssl version',
       code: 'ERR_SSL_WRONG_SSL_VERSION',
diff --git a/test/parallel/test-tls-client-renegotiation-limit.js b/test/parallel/test-tls-client-renegotiation-limit.js
index 71d7a85bae468b..b35140e8964ac1 100644
--- a/test/parallel/test-tls-client-renegotiation-limit.js
+++ b/test/parallel/test-tls-client-renegotiation-limit.js
@@ -21,11 +21,15 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
+}
+
+const { opensslCli } = require('../common/crypto');
 
-if (!common.opensslCli)
+if (!opensslCli) {
   common.skip('node compiled without OpenSSL CLI.');
+}
 
 const assert = require('assert');
 const tls = require('tls');
diff --git a/test/parallel/test-tls-dhe.js b/test/parallel/test-tls-dhe.js
index 21739ce42428eb..25b58191e1d413 100644
--- a/test/parallel/test-tls-dhe.js
+++ b/test/parallel/test-tls-dhe.js
@@ -22,11 +22,18 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
+}
+
+const {
+  hasOpenSSL,
+  opensslCli,
+} = require('../common/crypto');
 
-if (!common.opensslCli)
+if (!opensslCli) {
   common.skip('missing openssl-cli');
+}
 
 const assert = require('assert');
 const { X509Certificate } = require('crypto');
@@ -43,7 +50,7 @@ const dheCipher = 'DHE-RSA-AES128-SHA256';
 const ecdheCipher = 'ECDHE-RSA-AES128-SHA256';
 const ciphers = `${dheCipher}:${ecdheCipher}`;
 
-if (!common.hasOpenSSL(3, 2)) {
+if (!hasOpenSSL(3, 2)) {
   // Test will emit a warning because the DH parameter size is < 2048 bits
   // when the test is run on versions lower than OpenSSL32
   common.expectWarning('SecurityWarning',
@@ -70,7 +77,7 @@ function test(dhparam, keylen, expectedCipher) {
     const args = ['s_client', '-connect', `127.0.0.1:${server.address().port}`,
                   '-cipher', `${ciphers}:@SECLEVEL=1`];
 
-    execFile(common.opensslCli, args, common.mustSucceed((stdout) => {
+    execFile(opensslCli, args, common.mustSucceed((stdout) => {
       assert(keylen === null ||
              stdout.includes(`Server Temp Key: DH, ${keylen} bits`));
       assert(stdout.includes(`Cipher    : ${expectedCipher}`));
@@ -107,7 +114,7 @@ function testCustomParam(keylen, expectedCipher) {
   }, /DH parameter is less than 1024 bits/);
 
   // Custom DHE parameters are supported (but discouraged).
-  if (!common.hasOpenSSL(3, 2)) {
+  if (!hasOpenSSL(3, 2)) {
     await testCustomParam(1024, dheCipher);
   } else {
     await testCustomParam(3072, dheCipher);
diff --git a/test/parallel/test-tls-ecdh-auto.js b/test/parallel/test-tls-ecdh-auto.js
index 11c588d8ac8ce1..adc7817b729aa8 100644
--- a/test/parallel/test-tls-ecdh-auto.js
+++ b/test/parallel/test-tls-ecdh-auto.js
@@ -4,11 +4,15 @@ const common = require('../common');
 // This test ensures that the value "auto" on ecdhCurve option is
 // supported to enable automatic curve selection in TLS server.
 
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
+}
+
+const { opensslCli } = require('../common/crypto');
 
-if (!common.opensslCli)
+if (!opensslCli) {
   common.skip('missing openssl-cli');
+}
 
 const assert = require('assert');
 const tls = require('tls');
@@ -36,7 +40,7 @@ const server = tls.createServer(options, (conn) => {
                 '-cipher', `${options.ciphers}`,
                 '-connect', `127.0.0.1:${server.address().port}`];
 
-  execFile(common.opensslCli, args, common.mustSucceed((stdout) => {
+  execFile(opensslCli, args, common.mustSucceed((stdout) => {
     assert(stdout.includes(reply));
     server.close();
   }));
diff --git a/test/parallel/test-tls-ecdh-multiple.js b/test/parallel/test-tls-ecdh-multiple.js
index 5bf119f48bacad..957f8e0407a6de 100644
--- a/test/parallel/test-tls-ecdh-multiple.js
+++ b/test/parallel/test-tls-ecdh-multiple.js
@@ -4,11 +4,16 @@ const common = require('../common');
 // This test ensures that ecdhCurve option of TLS server supports colon
 // separated ECDH curve names as value.
 
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
+}
+
+const { opensslCli } = require('../common/crypto');
+const crypto = require('crypto');
 
-if (!common.opensslCli)
+if (!opensslCli) {
   common.skip('missing openssl-cli');
+}
 
 const assert = require('assert');
 const tls = require('tls');
@@ -36,7 +41,7 @@ const server = tls.createServer(options, (conn) => {
                 '-cipher', `${options.ciphers}`,
                 '-connect', `127.0.0.1:${server.address().port}`];
 
-  execFile(common.opensslCli, args, common.mustSucceed((stdout) => {
+  execFile(opensslCli, args, common.mustSucceed((stdout) => {
     assert(stdout.includes(reply));
     server.close();
   }));
@@ -51,8 +56,9 @@ const server = tls.createServer(options, (conn) => {
   ];
 
   // Brainpool is not supported in FIPS mode.
-  if (common.hasFipsCrypto)
+  if (crypto.getFips()) {
     unsupportedCurves.push('brainpoolP256r1');
+  }
 
   unsupportedCurves.forEach((ecdhCurve) => {
     assert.throws(() => tls.createServer({ ecdhCurve }),
diff --git a/test/parallel/test-tls-ecdh.js b/test/parallel/test-tls-ecdh.js
index 276b713f5ecf70..4d45e7f024586e 100644
--- a/test/parallel/test-tls-ecdh.js
+++ b/test/parallel/test-tls-ecdh.js
@@ -23,11 +23,15 @@
 const common = require('../common');
 const fixtures = require('../common/fixtures');
 
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
+}
 
-if (!common.opensslCli)
+const { opensslCli } = require('../common/crypto');
+
+if (!opensslCli) {
   common.skip('missing openssl-cli');
+}
 
 const assert = require('assert');
 const tls = require('tls');
@@ -49,7 +53,7 @@ const server = tls.createServer(options, common.mustCall(function(conn) {
 }));
 
 server.listen(0, '127.0.0.1', common.mustCall(function() {
-  const cmd = common.escapePOSIXShell`"${common.opensslCli}" s_client -cipher ${
+  const cmd = common.escapePOSIXShell`"${opensslCli}" s_client -cipher ${
     options.ciphers} -connect 127.0.0.1:${this.address().port}`;
 
   exec(...cmd, common.mustSucceed((stdout, stderr) => {
diff --git a/test/parallel/test-tls-empty-sni-context.js b/test/parallel/test-tls-empty-sni-context.js
index 093e5cca712d2c..79f1ddd341d938 100644
--- a/test/parallel/test-tls-empty-sni-context.js
+++ b/test/parallel/test-tls-empty-sni-context.js
@@ -3,7 +3,7 @@
 const common = require('../common');
 if (!common.hasCrypto)
   common.skip('missing crypto');
-
+const { hasOpenSSL } = require('../common/crypto');
 const assert = require('assert');
 const tls = require('tls');
 
@@ -26,7 +26,7 @@ const server = tls.createServer(options, (c) => {
   }, common.mustNotCall());
 
   c.on('error', common.mustCall((err) => {
-    const expectedErr = common.hasOpenSSL(3, 2) ?
+    const expectedErr = hasOpenSSL(3, 2) ?
       'ERR_SSL_SSL/TLS_ALERT_HANDSHAKE_FAILURE' : 'ERR_SSL_SSLV3_ALERT_HANDSHAKE_FAILURE';
     assert.strictEqual(err.code, expectedErr);
   }));
diff --git a/test/parallel/test-tls-getprotocol.js b/test/parallel/test-tls-getprotocol.js
index a9c8775e2f112f..b1eab88fd6517e 100644
--- a/test/parallel/test-tls-getprotocol.js
+++ b/test/parallel/test-tls-getprotocol.js
@@ -3,6 +3,8 @@ const common = require('../common');
 if (!common.hasCrypto)
   common.skip('missing crypto');
 
+const { hasOpenSSL } = require('../common/crypto');
+
 // This test ensures that `getProtocol` returns the right protocol
 // from a TLS connection
 
@@ -14,11 +16,11 @@ const clientConfigs = [
   {
     secureProtocol: 'TLSv1_method',
     version: 'TLSv1',
-    ciphers: (common.hasOpenSSL(3, 1) ? 'DEFAULT:@SECLEVEL=0' : 'DEFAULT')
+    ciphers: (hasOpenSSL(3, 1) ? 'DEFAULT:@SECLEVEL=0' : 'DEFAULT')
   }, {
     secureProtocol: 'TLSv1_1_method',
     version: 'TLSv1.1',
-    ciphers: (common.hasOpenSSL(3, 1) ? 'DEFAULT:@SECLEVEL=0' : 'DEFAULT')
+    ciphers: (hasOpenSSL(3, 1) ? 'DEFAULT:@SECLEVEL=0' : 'DEFAULT')
   }, {
     secureProtocol: 'TLSv1_2_method',
     version: 'TLSv1.2'
diff --git a/test/parallel/test-tls-junk-server.js b/test/parallel/test-tls-junk-server.js
index cc520383ede45f..0e536a66884e94 100644
--- a/test/parallel/test-tls-junk-server.js
+++ b/test/parallel/test-tls-junk-server.js
@@ -1,8 +1,11 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
+}
+
+const { hasOpenSSL } = require('../common/crypto');
 
 const assert = require('assert');
 const https = require('https');
@@ -21,7 +24,7 @@ server.listen(0, function() {
   req.end();
 
   let expectedErrorMessage = new RegExp('wrong version number');
-  if (common.hasOpenSSL(3, 2)) {
+  if (hasOpenSSL(3, 2)) {
     expectedErrorMessage = new RegExp('packet length too long');
   };
   req.once('error', common.mustCall(function(err) {
diff --git a/test/parallel/test-tls-key-mismatch.js b/test/parallel/test-tls-key-mismatch.js
index fdbb3676267a9d..df8848a03de4a9 100644
--- a/test/parallel/test-tls-key-mismatch.js
+++ b/test/parallel/test-tls-key-mismatch.js
@@ -22,14 +22,16 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
+}
 
 const fixtures = require('../common/fixtures');
+const { hasOpenSSL3 } = require('../common/crypto');
 
 const assert = require('assert');
 const tls = require('tls');
-const errorMessageRegex = common.hasOpenSSL3 ?
+const errorMessageRegex = hasOpenSSL3 ?
   /^Error: error:05800074:x509 certificate routines::key values mismatch$/ :
   /^Error: error:0B080074:x509 certificate routines:X509_check_private_key:key values mismatch$/;
 
diff --git a/test/parallel/test-tls-legacy-pfx.js b/test/parallel/test-tls-legacy-pfx.js
index 33b4c58fc6ccc3..5106217718dbdc 100644
--- a/test/parallel/test-tls-legacy-pfx.js
+++ b/test/parallel/test-tls-legacy-pfx.js
@@ -1,9 +1,14 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
-if (!common.hasOpenSSL3)
+}
+
+const { hasOpenSSL3 } = require('../common/crypto');
+
+if (!hasOpenSSL3) {
   common.skip('OpenSSL legacy failures are only testable with OpenSSL 3+');
+}
 
 const fixtures = require('../common/fixtures');
 
diff --git a/test/parallel/test-tls-min-max-version.js b/test/parallel/test-tls-min-max-version.js
index af32468eea6a68..4903d92f5c5700 100644
--- a/test/parallel/test-tls-min-max-version.js
+++ b/test/parallel/test-tls-min-max-version.js
@@ -1,5 +1,13 @@
 'use strict';
 const common = require('../common');
+
+if (!common.hasCrypto) {
+  common.skip('missing crypto');
+}
+const {
+  hasOpenSSL,
+  hasOpenSSL3,
+} = require('../common/crypto');
 const fixtures = require('../common/fixtures');
 const { inspect } = require('util');
 
@@ -16,13 +24,13 @@ function test(cmin, cmax, cprot, smin, smax, sprot, proto, cerr, serr) {
   assert(proto || cerr || serr, 'test missing any expectations');
 
   let ciphers;
-  if (common.hasOpenSSL3 && (proto === 'TLSv1' || proto === 'TLSv1.1' ||
+  if (hasOpenSSL3 && (proto === 'TLSv1' || proto === 'TLSv1.1' ||
       proto === 'TLSv1_1_method' || proto === 'TLSv1_method' ||
       sprot === 'TLSv1_1_method' || sprot === 'TLSv1_method')) {
     if (serr !== 'ERR_SSL_UNSUPPORTED_PROTOCOL')
       ciphers = 'ALL@SECLEVEL=0';
   }
-  if (common.hasOpenSSL(3, 1) && cerr === 'ERR_SSL_TLSV1_ALERT_PROTOCOL_VERSION') {
+  if (hasOpenSSL(3, 1) && cerr === 'ERR_SSL_TLSV1_ALERT_PROTOCOL_VERSION') {
     ciphers = 'DEFAULT@SECLEVEL=0';
   }
   // Report where test was called from. Strip leading garbage from
@@ -125,9 +133,9 @@ test(U, U, 'TLS_method', U, U, 'TLSv1_method', 'TLSv1');
 
 // OpenSSL 1.1.1 and 3.0 use a different error code and alert (sent to the
 // client) when no protocols are enabled on the server.
-const NO_PROTOCOLS_AVAILABLE_SERVER = common.hasOpenSSL3 ?
+const NO_PROTOCOLS_AVAILABLE_SERVER = hasOpenSSL3 ?
   'ERR_SSL_NO_PROTOCOLS_AVAILABLE' : 'ERR_SSL_INTERNAL_ERROR';
-const NO_PROTOCOLS_AVAILABLE_SERVER_ALERT = common.hasOpenSSL3 ?
+const NO_PROTOCOLS_AVAILABLE_SERVER_ALERT = hasOpenSSL3 ?
   'ERR_SSL_TLSV1_ALERT_PROTOCOL_VERSION' : 'ERR_SSL_TLSV1_ALERT_INTERNAL_ERROR';
 
 // SSLv23 also means "any supported protocol" greater than the default
diff --git a/test/parallel/test-tls-no-sslv3.js b/test/parallel/test-tls-no-sslv3.js
index 9282beb4bdac2c..cd5f4ad944a6c5 100644
--- a/test/parallel/test-tls-no-sslv3.js
+++ b/test/parallel/test-tls-no-sslv3.js
@@ -1,10 +1,14 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
+}
 
-if (common.opensslCli === false)
+const { opensslCli } = require('../common/crypto');
+
+if (opensslCli === false) {
   common.skip('node compiled without OpenSSL CLI.');
+}
 
 const assert = require('assert');
 const tls = require('tls');
@@ -23,7 +27,7 @@ server.listen(0, '127.0.0.1', function() {
                 '-ssl3',
                 '-connect', address];
 
-  const client = spawn(common.opensslCli, args, { stdio: 'pipe' });
+  const client = spawn(opensslCli, args, { stdio: 'pipe' });
   client.stdout.pipe(process.stdout);
   client.stderr.pipe(process.stderr);
   client.stderr.setEncoding('utf8');
diff --git a/test/parallel/test-tls-ocsp-callback.js b/test/parallel/test-tls-ocsp-callback.js
index 04a60a0890c506..bdf622d4686ec1 100644
--- a/test/parallel/test-tls-ocsp-callback.js
+++ b/test/parallel/test-tls-ocsp-callback.js
@@ -22,12 +22,17 @@
 'use strict';
 const common = require('../common');
 
-if (!common.opensslCli)
-  common.skip('node compiled without OpenSSL CLI.');
-
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
+}
+
+const { opensslCli } = require('../common/crypto');
+
+if (!opensslCli) {
+  common.skip('node compiled without OpenSSL CLI.');
+}
 
+const crypto = require('crypto');
 const tls = require('tls');
 const fixtures = require('../common/fixtures');
 
@@ -108,6 +113,6 @@ test({ ocsp: true, response: false });
 test({ ocsp: true, response: 'hello world' });
 test({ ocsp: false });
 
-if (!common.hasFipsCrypto) {
+if (!crypto.getFips()) {
   test({ ocsp: true, response: 'hello pfx', pfx: pfx, passphrase: 'sample' });
 }
diff --git a/test/parallel/test-tls-psk-circuit.js b/test/parallel/test-tls-psk-circuit.js
index c06e61c321ef67..61861ecf4dafa6 100644
--- a/test/parallel/test-tls-psk-circuit.js
+++ b/test/parallel/test-tls-psk-circuit.js
@@ -1,9 +1,11 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
+}
 
+const { hasOpenSSL } = require('../common/crypto');
 const assert = require('assert');
 const tls = require('tls');
 
@@ -62,12 +64,12 @@ test({ psk: USERS.UserA, identity: 'UserA' }, { minVersion: 'TLSv1.3' });
 test({ psk: USERS.UserB, identity: 'UserB' });
 test({ psk: USERS.UserB, identity: 'UserB' }, { minVersion: 'TLSv1.3' });
 // Unrecognized user should fail handshake
-const expectedHandshakeErr = common.hasOpenSSL(3, 2) ?
+const expectedHandshakeErr = hasOpenSSL(3, 2) ?
   'ERR_SSL_SSL/TLS_ALERT_HANDSHAKE_FAILURE' : 'ERR_SSL_SSLV3_ALERT_HANDSHAKE_FAILURE';
 test({ psk: USERS.UserB, identity: 'UserC' }, {}, expectedHandshakeErr);
 // Recognized user but incorrect secret should fail handshake
-const expectedIllegalParameterErr = common.hasOpenSSL(3, 4) ? 'ERR_SSL_TLSV1_ALERT_DECRYPT_ERROR' :
-  common.hasOpenSSL(3, 2) ?
+const expectedIllegalParameterErr = hasOpenSSL(3, 4) ? 'ERR_SSL_TLSV1_ALERT_DECRYPT_ERROR' :
+  hasOpenSSL(3, 2) ?
     'ERR_SSL_SSL/TLS_ALERT_ILLEGAL_PARAMETER' : 'ERR_SSL_SSLV3_ALERT_ILLEGAL_PARAMETER';
 test({ psk: USERS.UserA, identity: 'UserB' }, {}, expectedIllegalParameterErr);
 test({ psk: USERS.UserB, identity: 'UserB' });
diff --git a/test/parallel/test-tls-psk-server.js b/test/parallel/test-tls-psk-server.js
index b9260958401522..87fad86083e1ab 100644
--- a/test/parallel/test-tls-psk-server.js
+++ b/test/parallel/test-tls-psk-server.js
@@ -1,10 +1,15 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
-if (!common.opensslCli)
+}
+
+const { opensslCli } = require('../common/crypto');
+
+if (!opensslCli) {
   common.skip('missing openssl cli');
+}
 
 const assert = require('assert');
 
@@ -41,7 +46,7 @@ let sentWorld = false;
 let gotWorld = false;
 
 server.listen(0, () => {
-  const client = spawn(common.opensslCli, [
+  const client = spawn(opensslCli, [
     's_client',
     '-connect', `127.0.0.1:${server.address().port}`,
     '-cipher', CIPHERS,
diff --git a/test/parallel/test-tls-securepair-server.js b/test/parallel/test-tls-securepair-server.js
index 78cd9f725401ed..fb4ebe6a2511cf 100644
--- a/test/parallel/test-tls-securepair-server.js
+++ b/test/parallel/test-tls-securepair-server.js
@@ -21,11 +21,15 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
+}
+
+const { opensslCli } = require('../common/crypto');
 
-if (!common.opensslCli)
+if (!opensslCli) {
   common.skip('missing openssl-cli');
+}
 
 const assert = require('assert');
 const tls = require('tls');
@@ -109,7 +113,7 @@ server.listen(0, common.mustCall(function() {
 
   const args = ['s_client', '-connect', `127.0.0.1:${this.address().port}`];
 
-  const client = spawn(common.opensslCli, args);
+  const client = spawn(opensslCli, args);
 
 
   let out = '';
diff --git a/test/parallel/test-tls-server-verify.js b/test/parallel/test-tls-server-verify.js
index 51ccd0d747fdf5..2517c7c8dbbb1f 100644
--- a/test/parallel/test-tls-server-verify.js
+++ b/test/parallel/test-tls-server-verify.js
@@ -22,11 +22,15 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
+}
+
+const { opensslCli } = require('../common/crypto');
 
-if (!common.opensslCli)
+if (!opensslCli) {
   common.skip('node compiled without OpenSSL CLI.');
+}
 
 // This is a rather complex test which sets up various TLS servers with node
 // and connects to them using the 'openssl s_client' command line utility
@@ -188,7 +192,7 @@ function runClient(prefix, port, options, cb) {
   }
 
   // To test use: openssl s_client -connect localhost:8000
-  const client = spawn(common.opensslCli, args);
+  const client = spawn(opensslCli, args);
 
   let out = '';
 
diff --git a/test/parallel/test-tls-session-cache.js b/test/parallel/test-tls-session-cache.js
index b55e150401d8a2..9524764aa609ee 100644
--- a/test/parallel/test-tls-session-cache.js
+++ b/test/parallel/test-tls-session-cache.js
@@ -21,17 +21,23 @@
 
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
+}
+const {
+  hasOpenSSL,
+  opensslCli,
+} = require('../common/crypto');
+
+if (!opensslCli) {
+  common.skip('node compiled without OpenSSL CLI.');
+}
+
 const fixtures = require('../common/fixtures');
 const assert = require('assert');
 const tls = require('tls');
 const { spawn } = require('child_process');
 
-if (!common.opensslCli)
-  common.skip('node compiled without OpenSSL CLI.');
-
-
 doTest({ tickets: false }, function() {
   doTest({ tickets: true }, function() {
     doTest({ tickets: false, invalidSession: true }, function() {
@@ -100,7 +106,7 @@ function doTest(testOptions, callback) {
     const args = [
       's_client',
       '-tls1',
-      '-cipher', (common.hasOpenSSL(3, 1) ? 'DEFAULT:@SECLEVEL=0' : 'DEFAULT'),
+      '-cipher', (hasOpenSSL(3, 1) ? 'DEFAULT:@SECLEVEL=0' : 'DEFAULT'),
       '-connect', `localhost:${this.address().port}`,
       '-servername', 'ohgod',
       '-key', fixtures.path('keys/rsa_private.pem'),
@@ -109,7 +115,7 @@ function doTest(testOptions, callback) {
     ].concat(testOptions.tickets ? [] : '-no_ticket');
 
     function spawnClient() {
-      const client = spawn(common.opensslCli, args, {
+      const client = spawn(opensslCli, args, {
         stdio: [ 0, 1, 'pipe' ]
       });
       let err = '';
diff --git a/test/parallel/test-tls-set-ciphers.js b/test/parallel/test-tls-set-ciphers.js
index f7062e73c9403c..1e63e9376e134b 100644
--- a/test/parallel/test-tls-set-ciphers.js
+++ b/test/parallel/test-tls-set-ciphers.js
@@ -1,7 +1,17 @@
 'use strict';
 const common = require('../common');
-if (!common.hasOpenSSL3)
+if (!common.hasCrypto) {
   common.skip('missing crypto, or OpenSSL version lower than 3');
+}
+
+const {
+  hasOpenSSL,
+  hasOpenSSL3,
+} = require('../common/crypto');
+
+if (!hasOpenSSL3) {
+  common.skip('missing crypto, or OpenSSL version lower than 3');
+}
 
 const fixtures = require('../common/fixtures');
 const { inspect } = require('util');
@@ -80,7 +90,7 @@ function test(cciphers, sciphers, cipher, cerr, serr, options) {
 const U = undefined;
 
 let expectedTLSAlertError = 'ERR_SSL_SSLV3_ALERT_HANDSHAKE_FAILURE';
-if (common.hasOpenSSL(3, 2)) {
+if (hasOpenSSL(3, 2)) {
   expectedTLSAlertError = 'ERR_SSL_SSL/TLS_ALERT_HANDSHAKE_FAILURE';
 }
 
@@ -117,7 +127,7 @@ test(U, 'AES256-SHA', 'TLS_AES_256_GCM_SHA384', U, U, { maxVersion: 'TLSv1.3' })
 // default, but work.
 // However, for OpenSSL32 AES_128 is not enabled due to the
 // default security level
-if (!common.hasOpenSSL(3, 2)) {
+if (!hasOpenSSL(3, 2)) {
   test('TLS_AES_128_CCM_8_SHA256', U,
        U, 'ERR_SSL_SSLV3_ALERT_HANDSHAKE_FAILURE', 'ERR_SSL_NO_SHARED_CIPHER');
 
diff --git a/test/parallel/test-tls-set-secure-context.js b/test/parallel/test-tls-set-secure-context.js
index c056875e14ddfb..3d2de6b3321414 100644
--- a/test/parallel/test-tls-set-secure-context.js
+++ b/test/parallel/test-tls-set-secure-context.js
@@ -1,8 +1,9 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
+}
 
 // This test verifies the behavior of the tls setSecureContext() method.
 // It also verifies that existing connections are not disrupted when the
@@ -12,6 +13,7 @@ const assert = require('assert');
 const events = require('events');
 const https = require('https');
 const timers = require('timers/promises');
+const { hasOpenSSL3 } = require('../common/crypto');
 const fixtures = require('../common/fixtures');
 const credentialOptions = [
   {
@@ -55,7 +57,7 @@ server.listen(0, common.mustCall(() => {
 
     server.setSecureContext(credentialOptions[1]);
     firstResponse.write('request-');
-    const errorMessageRegex = common.hasOpenSSL3 ?
+    const errorMessageRegex = hasOpenSSL3 ?
       /^Error: self-signed certificate$/ :
       /^Error: self signed certificate$/;
     await assert.rejects(makeRequest(port, 3), errorMessageRegex);
diff --git a/test/parallel/test-tls-set-sigalgs.js b/test/parallel/test-tls-set-sigalgs.js
index 3f3d152f4d877e..985ca13ba2ac7d 100644
--- a/test/parallel/test-tls-set-sigalgs.js
+++ b/test/parallel/test-tls-set-sigalgs.js
@@ -1,6 +1,9 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto) common.skip('missing crypto');
+if (!common.hasCrypto) {
+  common.skip('missing crypto');
+}
+const { hasOpenSSL } = require('../common/crypto');
 const fixtures = require('../common/fixtures');
 
 // Test sigalgs: option for TLS.
@@ -63,7 +66,7 @@ test('RSA-PSS+SHA256:RSA-PSS+SHA512:ECDSA+SHA256',
      ['RSA-PSS+SHA256', 'ECDSA+SHA256']);
 
 // Do not have shared sigalgs.
-const handshakeErr = common.hasOpenSSL(3, 2) ?
+const handshakeErr = hasOpenSSL(3, 2) ?
   'ERR_SSL_SSL/TLS_ALERT_HANDSHAKE_FAILURE' : 'ERR_SSL_SSLV3_ALERT_HANDSHAKE_FAILURE';
 test('RSA-PSS+SHA384', 'ECDSA+SHA256',
      undefined, handshakeErr,
diff --git a/test/parallel/test-trace-env.js b/test/parallel/test-trace-env.js
index ba08e0af2aad1d..7a7b80fa4c1094 100644
--- a/test/parallel/test-trace-env.js
+++ b/test/parallel/test-trace-env.js
@@ -18,9 +18,11 @@ spawnSyncAndAssert(process.execPath, ['--trace-env', fixtures.path('empty.js')],
     }
     if (common.hasCrypto) {
       assert.match(output, /get "NODE_EXTRA_CA_CERTS"/);
-    }
-    if (common.hasOpenSSL3) {
-      assert.match(output, /get "OPENSSL_CONF"/);
+
+      const { hasOpenSSL3 } = require('../common/crypto');
+      if (hasOpenSSL3) {
+        assert.match(output, /get "OPENSSL_CONF"/);
+      }
     }
     assert.match(output, /get "NODE_DEBUG_NATIVE"/);
     assert.match(output, /get "NODE_COMPILE_CACHE"/);
diff --git a/test/parallel/test-x509-escaping.js b/test/parallel/test-x509-escaping.js
index e6ae4d886908cb..b507af88e1f7f3 100644
--- a/test/parallel/test-x509-escaping.js
+++ b/test/parallel/test-x509-escaping.js
@@ -1,15 +1,16 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
+}
 
 const assert = require('assert');
 const { X509Certificate } = require('crypto');
 const tls = require('tls');
 const fixtures = require('../common/fixtures');
 
-const { hasOpenSSL3 } = common;
+const { hasOpenSSL3 } = require('../common/crypto');
 
 // Test that all certificate chains provided by the reporter are rejected.
 {
diff --git a/test/pummel/test-crypto-dh-hash.js b/test/pummel/test-crypto-dh-hash.js
index ef5a640688c9bb..b59f556a2042b9 100644
--- a/test/pummel/test-crypto-dh-hash.js
+++ b/test/pummel/test-crypto-dh-hash.js
@@ -30,7 +30,9 @@ if (common.isPi) {
   common.skip('Too slow for Raspberry Pi devices');
 }
 
-if (!common.hasOpenSSL3) {
+const { hasOpenSSL3 } = require('../common/crypto');
+
+if (!hasOpenSSL3) {
   common.skip('Too slow when dynamically linked against OpenSSL 1.1.1');
 }
 
diff --git a/test/pummel/test-crypto-dh-keys.js b/test/pummel/test-crypto-dh-keys.js
index 2caa4e244a9859..abce6a07acf4ac 100644
--- a/test/pummel/test-crypto-dh-keys.js
+++ b/test/pummel/test-crypto-dh-keys.js
@@ -36,8 +36,9 @@ const crypto = require('crypto');
 [ 'modp1', 'modp2', 'modp5', 'modp14', 'modp15', 'modp16', 'modp17' ]
 .forEach((name) => {
   // modp1 is 768 bits, FIPS requires >= 1024
-  if (name === 'modp1' && common.hasFipsCrypto)
+  if (name === 'modp1' && crypto.getFips()) {
     return;
+  }
   const group1 = crypto.getDiffieHellman(name);
   const group2 = crypto.getDiffieHellman(name);
   group1.generateKeys();
diff --git a/test/pummel/test-dh-regr.js b/test/pummel/test-dh-regr.js
index 41d5bf872f97ec..cfae57d0728bdb 100644
--- a/test/pummel/test-dh-regr.js
+++ b/test/pummel/test-dh-regr.js
@@ -32,10 +32,11 @@ if (common.isPi) {
 
 const assert = require('assert');
 const crypto = require('crypto');
+const { hasOpenSSL3 } = require('../common/crypto');
 
 // FIPS requires length >= 1024 but we use 512/256 in this test to keep it from
 // taking too long and timing out in CI.
-const length = (common.hasFipsCrypto) ? 1024 : common.hasOpenSSL3 ? 512 : 256;
+const length = crypto.getFips() ? 1024 : hasOpenSSL3 ? 512 : 256;
 
 const p = crypto.createDiffieHellman(length).getPrime();
 
diff --git a/test/sequential/test-tls-psk-client.js b/test/sequential/test-tls-psk-client.js
index ddebc8f8cc9807..c07b1f92d98376 100644
--- a/test/sequential/test-tls-psk-client.js
+++ b/test/sequential/test-tls-psk-client.js
@@ -1,10 +1,15 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
-if (!common.opensslCli)
+}
+
+const { opensslCli } = require('../common/crypto');
+
+if (!opensslCli) {
   common.skip('missing openssl cli');
+}
 
 const assert = require('assert');
 const tls = require('tls');
@@ -16,7 +21,7 @@ const KEY = 'd731ef57be09e5204f0b205b60627028';
 const IDENTITY = 'Client_identity';  // Hardcoded by `openssl s_server`
 const useIPv4 = !common.hasIPv6;
 
-const server = spawn(common.opensslCli, [
+const server = spawn(opensslCli, [
   's_server',
   '-accept', common.PORT,
   '-cipher', CIPHERS,
diff --git a/test/sequential/test-tls-securepair-client.js b/test/sequential/test-tls-securepair-client.js
index f3ca42ad6edfb0..262518621b5f3f 100644
--- a/test/sequential/test-tls-securepair-client.js
+++ b/test/sequential/test-tls-securepair-client.js
@@ -23,14 +23,19 @@
 
 const common = require('../common');
 
-if (!common.opensslCli)
-  common.skip('node compiled without OpenSSL CLI.');
-
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
+}
+
+const { opensslCli } = require('../common/crypto');
 
-if (common.isWindows)
+if (!opensslCli) {
+  common.skip('node compiled without OpenSSL CLI.');
+}
+
+if (common.isWindows) {
   common.skip('test does not work on Windows'); // ...but it should!
+}
 
 const net = require('net');
 const assert = require('assert');
@@ -63,11 +68,11 @@ function test(keyPath, certPath, check, next) {
   const key = fixtures.readSync(keyPath).toString();
   const cert = fixtures.readSync(certPath).toString();
 
-  const server = spawn(common.opensslCli, ['s_server',
-                                           '-accept', 0,
-                                           '-cert', fixtures.path(certPath),
-                                           '-key', fixtures.path(keyPath),
-                                           ...(useIPv4 ? ['-4'] : []),
+  const server = spawn(opensslCli, ['s_server',
+                                    '-accept', 0,
+                                    '-cert', fixtures.path(certPath),
+                                    '-key', fixtures.path(keyPath),
+                                    ...(useIPv4 ? ['-4'] : []),
   ]);
   server.stdout.pipe(process.stdout);
   server.stderr.pipe(process.stdout);
diff --git a/test/sequential/test-tls-session-timeout.js b/test/sequential/test-tls-session-timeout.js
index 09107011aeda52..a93cdc793a2337 100644
--- a/test/sequential/test-tls-session-timeout.js
+++ b/test/sequential/test-tls-session-timeout.js
@@ -22,8 +22,11 @@
 'use strict';
 const common = require('../common');
 
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
+}
+
+const { opensslCli } = require('../common/crypto');
 
 const tmpdir = require('../common/tmpdir');
 tmpdir.refresh();
@@ -56,8 +59,9 @@ const cert = fixtures.readKey('rsa_cert.crt');
   }
 }
 
-if (!common.opensslCli)
+if (!opensslCli) {
   common.skip('node compiled without OpenSSL CLI.');
+}
 
 doTest();
 
@@ -105,7 +109,7 @@ function doTest() {
       '-sess_in', sessionFileName,
       '-sess_out', sessionFileName,
     ];
-    const client = spawn(common.opensslCli, flags, {
+    const client = spawn(opensslCli, flags, {
       stdio: ['ignore', 'pipe', 'ignore']
     });
 

From f07300cfa32c197684fe44d39965770b2fcfc23d Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Fri, 24 Jan 2025 17:35:59 -0800
Subject: [PATCH 08/38] test: move hasMultiLocalhost to common/net

Given that `common/net` already exists and hasMultiLocalhost
is net specific, let's move it out of common/index to better
encapsulate and simplify common/index more

PR-URL: https://github.com/nodejs/node/pull/56716
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
Reviewed-By: Richard Lau <rlau@redhat.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
---
 test/common/README.md                       |  6 ------
 test/common/index.js                        | 10 ----------
 test/common/index.mjs                       |  2 --
 test/common/net.js                          | 10 ++++++++++
 test/parallel/test-http-localaddress.js     |  4 +++-
 test/parallel/test-http2-connect-options.js |  4 +++-
 test/parallel/test-https-localaddress.js    |  4 +++-
 7 files changed, 19 insertions(+), 21 deletions(-)

diff --git a/test/common/README.md b/test/common/README.md
index ee36503f920001..9ecee39b64a3df 100644
--- a/test/common/README.md
+++ b/test/common/README.md
@@ -238,12 +238,6 @@ Indicates if [internationalization][] is supported.
 
 Indicates whether `IPv6` is supported on this platform.
 
-### `hasMultiLocalhost`
-
-* [\<boolean>][<boolean>]
-
-Indicates if there are multiple localhosts available.
-
 ### `inFreeBSDJail`
 
 * [\<boolean>][<boolean>]
diff --git a/test/common/index.js b/test/common/index.js
index d2c39578324600..e8bf65d0a6edb4 100644
--- a/test/common/index.js
+++ b/test/common/index.js
@@ -489,15 +489,6 @@ function _mustCallInner(fn, criteria = 1, field) {
   return _return;
 }
 
-function hasMultiLocalhost() {
-  const { internalBinding } = require('internal/test/binding');
-  const { TCP, constants: TCPConstants } = internalBinding('tcp_wrap');
-  const t = new TCP(TCPConstants.SOCKET);
-  const ret = t.bind('127.0.0.2', 0);
-  t.close();
-  return ret === 0;
-}
-
 function skipIfEslintMissing() {
   if (!fs.existsSync(
     path.join(__dirname, '..', '..', 'tools', 'eslint', 'node_modules', 'eslint'),
@@ -965,7 +956,6 @@ const common = {
   hasIntl,
   hasCrypto,
   hasQuic,
-  hasMultiLocalhost,
   invalidArgTypeHelper,
   isAlive,
   isASan,
diff --git a/test/common/index.mjs b/test/common/index.mjs
index 23328ac90ea3c9..090659f93be8ef 100644
--- a/test/common/index.mjs
+++ b/test/common/index.mjs
@@ -20,7 +20,6 @@ const {
   hasCrypto,
   hasIntl,
   hasIPv6,
-  hasMultiLocalhost,
   isAIX,
   isAlive,
   isDumbTerminal,
@@ -75,7 +74,6 @@ export {
   hasCrypto,
   hasIntl,
   hasIPv6,
-  hasMultiLocalhost,
   isAIX,
   isAlive,
   isDumbTerminal,
diff --git a/test/common/net.js b/test/common/net.js
index 84eddd0966ed56..3886c542421005 100644
--- a/test/common/net.js
+++ b/test/common/net.js
@@ -17,7 +17,17 @@ function checkSupportReusePort() {
   });
 }
 
+function hasMultiLocalhost() {
+  const { internalBinding } = require('internal/test/binding');
+  const { TCP, constants: TCPConstants } = internalBinding('tcp_wrap');
+  const t = new TCP(TCPConstants.SOCKET);
+  const ret = t.bind('127.0.0.2', 0);
+  t.close();
+  return ret === 0;
+}
+
 module.exports = {
   checkSupportReusePort,
+  hasMultiLocalhost,
   options,
 };
diff --git a/test/parallel/test-http-localaddress.js b/test/parallel/test-http-localaddress.js
index a0e4bb80a3f8c2..da25ab3047613f 100644
--- a/test/parallel/test-http-localaddress.js
+++ b/test/parallel/test-http-localaddress.js
@@ -22,8 +22,10 @@
 // Flags: --expose-internals
 'use strict';
 const common = require('../common');
-if (!common.hasMultiLocalhost())
+const { hasMultiLocalhost } = require('../common/net');
+if (!hasMultiLocalhost()) {
   common.skip('platform-specific test.');
+}
 
 const http = require('http');
 const assert = require('assert');
diff --git a/test/parallel/test-http2-connect-options.js b/test/parallel/test-http2-connect-options.js
index 233ced016974e2..1abcee99e06433 100644
--- a/test/parallel/test-http2-connect-options.js
+++ b/test/parallel/test-http2-connect-options.js
@@ -4,8 +4,10 @@ const common = require('../common');
 if (!common.hasCrypto)
   common.skip('missing crypto');
 
-if (!common.hasMultiLocalhost())
+const { hasMultiLocalhost } = require('../common/net');
+if (!hasMultiLocalhost()) {
   common.skip('platform-specific test.');
+}
 
 const http2 = require('http2');
 const assert = require('assert');
diff --git a/test/parallel/test-https-localaddress.js b/test/parallel/test-https-localaddress.js
index 0de0974dc69b04..2a4629b34e4105 100644
--- a/test/parallel/test-https-localaddress.js
+++ b/test/parallel/test-https-localaddress.js
@@ -25,8 +25,10 @@ const common = require('../common');
 if (!common.hasCrypto)
   common.skip('missing crypto');
 
-if (!common.hasMultiLocalhost())
+const { hasMultiLocalhost } = require('../common/net');
+if (!hasMultiLocalhost()) {
   common.skip('platform-specific test.');
+}
 
 const fixtures = require('../common/fixtures');
 const assert = require('assert');

From 4a5d2c7538b412eea84a0f41544784b1b8ed7c8c Mon Sep 17 00:00:00 2001
From: Joyee Cheung <joyeec9h3@gmail.com>
Date: Sat, 25 Jan 2025 03:30:27 +0100
Subject: [PATCH 09/38] module: integrate TypeScript into compile cache

This integrates TypeScript into the compile cache by caching
the transpilation (either type-stripping or transforming) output
in addition to the V8 code cache that's generated from the
transpilation output.

Locally this speeds up loading with type stripping of
`benchmark/fixtures/strip-types-benchmark.ts` by ~65% and
loading with type transforms of
`fixtures/transform-types-benchmark.ts` by ~128%.

When comparing loading .ts and loading pre-transpiled .js on-disk
with the compile cache enabled, previously .ts loaded 46% slower
with type-stripping and 66% slower with transforms compared to
loading .js files directly.
After this patch, .ts loads 12% slower with type-stripping and
22% slower with transforms compared to .js.

(Note that the numbers are based on microbenchmark fixtures and
do not necessarily represent real-world workloads, though with
bigger real-world files, the speed up should be more significant).

PR-URL: https://github.com/nodejs/node/pull/56629
Fixes: https://github.com/nodejs/node/issues/54741
Reviewed-By: Geoffrey Booth <webadmin@geoffreybooth.com>
Reviewed-By: Marco Ippolito <marcoippolito54@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 lib/internal/modules/typescript.js            |  63 ++++++-
 src/compile_cache.cc                          |  65 ++++++-
 src/compile_cache.h                           |  15 +-
 src/node_modules.cc                           |  96 ++++++++++
 .../test-compile-cache-typescript-commonjs.js | 166 +++++++++++++++++
 .../test-compile-cache-typescript-esm.js      | 167 ++++++++++++++++++
 ...est-compile-cache-typescript-strip-miss.js | 104 +++++++++++
 ...mpile-cache-typescript-strip-sourcemaps.js |  59 +++++++
 ...test-compile-cache-typescript-transform.js | 127 +++++++++++++
 9 files changed, 846 insertions(+), 16 deletions(-)
 create mode 100644 test/parallel/test-compile-cache-typescript-commonjs.js
 create mode 100644 test/parallel/test-compile-cache-typescript-esm.js
 create mode 100644 test/parallel/test-compile-cache-typescript-strip-miss.js
 create mode 100644 test/parallel/test-compile-cache-typescript-strip-sourcemaps.js
 create mode 100644 test/parallel/test-compile-cache-typescript-transform.js

diff --git a/lib/internal/modules/typescript.js b/lib/internal/modules/typescript.js
index 6abfc707657b92..17bbc6ba944432 100644
--- a/lib/internal/modules/typescript.js
+++ b/lib/internal/modules/typescript.js
@@ -22,6 +22,11 @@ const {
 const { getOptionValue } = require('internal/options');
 const assert = require('internal/assert');
 const { Buffer } = require('buffer');
+const {
+  getCompileCacheEntry,
+  saveCompileCacheEntry,
+  cachedCodeTypes: { kStrippedTypeScript, kTransformedTypeScript, kTransformedTypeScriptWithSourceMaps },
+} = internalBinding('modules');
 
 /**
  * The TypeScript parsing mode, either 'strip-only' or 'transform'.
@@ -105,11 +110,19 @@ function stripTypeScriptTypes(code, options = kEmptyObject) {
   });
 }
 
+/**
+ * @typedef {'strip-only' | 'transform'} TypeScriptMode
+ * @typedef {object} TypeScriptOptions
+ * @property {TypeScriptMode} mode Mode.
+ * @property {boolean} sourceMap Whether to generate source maps.
+ * @property {string|undefined} filename Filename.
+ */
+
 /**
  * Processes TypeScript code by stripping types or transforming.
  * Handles source maps if needed.
  * @param {string} code TypeScript code to process.
- * @param {object} options The configuration object.
+ * @param {TypeScriptOptions} options The configuration object.
  * @returns {string} The processed code.
  */
 function processTypeScriptCode(code, options) {
@@ -126,6 +139,20 @@ function processTypeScriptCode(code, options) {
   return transformedCode;
 }
 
+/**
+ * Get the type enum used for compile cache.
+ * @param {TypeScriptMode} mode Mode of transpilation.
+ * @param {boolean} sourceMap Whether source maps are enabled.
+ * @returns {number}
+ */
+function getCachedCodeType(mode, sourceMap) {
+  if (mode === 'transform') {
+    if (sourceMap) { return kTransformedTypeScriptWithSourceMaps; }
+    return kTransformedTypeScript;
+  }
+  return kStrippedTypeScript;
+}
+
 /**
  * Performs type-stripping to TypeScript source code internally.
  * It is used by internal loaders.
@@ -142,12 +169,40 @@ function stripTypeScriptModuleTypes(source, filename, emitWarning = true) {
   if (isUnderNodeModules(filename)) {
     throw new ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING(filename);
   }
+  const sourceMap = getOptionValue('--enable-source-maps');
+
+  const mode = getTypeScriptParsingMode();
+
+  // Instead of caching the compile cache status, just go into C++ to fetch it,
+  // as checking process.env equally involves calling into C++ anyway, and
+  // the compile cache can be enabled dynamically.
+  const type = getCachedCodeType(mode, sourceMap);
+  // Get a compile cache entry into the native compile cache store,
+  // keyed by the filename. If the cache can already be loaded on disk,
+  // cached.transpiled contains the cached string. Otherwise we should do
+  // the transpilation and save it in the native store later using
+  // saveCompileCacheEntry().
+  const cached = (filename ? getCompileCacheEntry(source, filename, type) : undefined);
+  if (cached?.transpiled) {  // TODO(joyeecheung): return Buffer here.
+    return cached.transpiled;
+  }
+
   const options = {
-    mode: getTypeScriptParsingMode(),
-    sourceMap: getOptionValue('--enable-source-maps'),
+    mode,
+    sourceMap,
     filename,
   };
-  return processTypeScriptCode(source, options);
+
+  const transpiled = processTypeScriptCode(source, options);
+  if (cached) {
+    // cached.external contains a pointer to the native cache entry.
+    // The cached object would be unreachable once it's out of scope,
+    // but the pointer inside cached.external would stay around for reuse until
+    // environment shutdown or when the cache is manually flushed
+    // to disk. Unwrap it in JS before passing into C++ since it's faster.
+    saveCompileCacheEntry(cached.external, transpiled);
+  }
+  return transpiled;
 }
 
 /**
diff --git a/src/compile_cache.cc b/src/compile_cache.cc
index 50697bcfe1671d..f13797e5f50288 100644
--- a/src/compile_cache.cc
+++ b/src/compile_cache.cc
@@ -77,10 +77,27 @@ v8::ScriptCompiler::CachedData* CompileCacheEntry::CopyCache() const {
 // See comments in CompileCacheHandler::Persist().
 constexpr uint32_t kCacheMagicNumber = 0x8adfdbb2;
 
+const char* CompileCacheEntry::type_name() const {
+  switch (type) {
+    case CachedCodeType::kCommonJS:
+      return "CommonJS";
+    case CachedCodeType::kESM:
+      return "ESM";
+    case CachedCodeType::kStrippedTypeScript:
+      return "StrippedTypeScript";
+    case CachedCodeType::kTransformedTypeScript:
+      return "TransformedTypeScript";
+    case CachedCodeType::kTransformedTypeScriptWithSourceMaps:
+      return "TransformedTypeScriptWithSourceMaps";
+    default:
+      UNREACHABLE();
+  }
+}
+
 void CompileCacheHandler::ReadCacheFile(CompileCacheEntry* entry) {
   Debug("[compile cache] reading cache from %s for %s %s...",
         entry->cache_filename,
-        entry->type == CachedCodeType::kCommonJS ? "CommonJS" : "ESM",
+        entry->type_name(),
         entry->source_filename);
 
   uv_fs_t req;
@@ -256,7 +273,8 @@ void CompileCacheHandler::MaybeSaveImpl(CompileCacheEntry* entry,
                                         v8::Local<T> func_or_mod,
                                         bool rejected) {
   DCHECK_NOT_NULL(entry);
-  Debug("[compile cache] cache for %s was %s, ",
+  Debug("[compile cache] V8 code cache for %s %s was %s, ",
+        entry->type_name(),
         entry->source_filename,
         rejected                    ? "rejected"
         : (entry->cache == nullptr) ? "not initialized"
@@ -287,6 +305,25 @@ void CompileCacheHandler::MaybeSave(CompileCacheEntry* entry,
   MaybeSaveImpl(entry, func, rejected);
 }
 
+void CompileCacheHandler::MaybeSave(CompileCacheEntry* entry,
+                                    std::string_view transpiled) {
+  CHECK(entry->type == CachedCodeType::kStrippedTypeScript ||
+        entry->type == CachedCodeType::kTransformedTypeScript ||
+        entry->type == CachedCodeType::kTransformedTypeScriptWithSourceMaps);
+  Debug("[compile cache] saving transpilation cache for %s %s\n",
+        entry->type_name(),
+        entry->source_filename);
+
+  // TODO(joyeecheung): it's weird to copy it again here. Convert the v8::String
+  // directly into buffer held by v8::ScriptCompiler::CachedData here.
+  int cache_size = static_cast<int>(transpiled.size());
+  uint8_t* data = new uint8_t[cache_size];
+  memcpy(data, transpiled.data(), cache_size);
+  entry->cache.reset(new v8::ScriptCompiler::CachedData(
+      data, cache_size, v8::ScriptCompiler::CachedData::BufferOwned));
+  entry->refreshed = true;
+}
+
 /**
  * Persist the compile cache accumulated in memory to disk.
  *
@@ -316,18 +353,25 @@ void CompileCacheHandler::Persist() {
   // incur a negligible overhead from thread synchronization.
   for (auto& pair : compiler_cache_store_) {
     auto* entry = pair.second.get();
+    const char* type_name = entry->type_name();
     if (entry->cache == nullptr) {
-      Debug("[compile cache] skip %s because the cache was not initialized\n",
+      Debug("[compile cache] skip persisting %s %s because the cache was not "
+            "initialized\n",
+            type_name,
             entry->source_filename);
       continue;
     }
     if (entry->refreshed == false) {
-      Debug("[compile cache] skip %s because cache was the same\n",
-            entry->source_filename);
+      Debug(
+          "[compile cache] skip persisting %s %s because cache was the same\n",
+          type_name,
+          entry->source_filename);
       continue;
     }
     if (entry->persisted == true) {
-      Debug("[compile cache] skip %s because cache was already persisted\n",
+      Debug("[compile cache] skip persisting %s %s because cache was already "
+            "persisted\n",
+            type_name,
             entry->source_filename);
       continue;
     }
@@ -363,8 +407,9 @@ void CompileCacheHandler::Persist() {
     auto cleanup_mkstemp =
         OnScopeLeave([&mkstemp_req]() { uv_fs_req_cleanup(&mkstemp_req); });
     std::string cache_filename_tmp = entry->cache_filename + ".XXXXXX";
-    Debug("[compile cache] Creating temporary file for cache of %s...",
-          entry->source_filename);
+    Debug("[compile cache] Creating temporary file for cache of %s (%s)...",
+          entry->source_filename,
+          type_name);
     int err = uv_fs_mkstemp(
         nullptr, &mkstemp_req, cache_filename_tmp.c_str(), nullptr);
     if (err < 0) {
@@ -372,8 +417,10 @@ void CompileCacheHandler::Persist() {
       continue;
     }
     Debug(" -> %s\n", mkstemp_req.path);
-    Debug("[compile cache] writing cache for %s to temporary file %s [%d %d %d "
+    Debug("[compile cache] writing cache for %s %s to temporary file %s [%d "
+          "%d %d "
           "%d %d]...",
+          type_name,
           entry->source_filename,
           mkstemp_req.path,
           headers[kMagicNumberOffset],
diff --git a/src/compile_cache.h b/src/compile_cache.h
index a7bb58c4a0be95..72910084e18bca 100644
--- a/src/compile_cache.h
+++ b/src/compile_cache.h
@@ -13,10 +13,17 @@
 namespace node {
 class Environment;
 
-// TODO(joyeecheung): move it into a CacheHandler class.
+#define CACHED_CODE_TYPES(V)                                                   \
+  V(kCommonJS, 0)                                                              \
+  V(kESM, 1)                                                                   \
+  V(kStrippedTypeScript, 2)                                                    \
+  V(kTransformedTypeScript, 3)                                                 \
+  V(kTransformedTypeScriptWithSourceMaps, 4)
+
 enum class CachedCodeType : uint8_t {
-  kCommonJS = 0,
-  kESM,
+#define V(type, value) type = value,
+  CACHED_CODE_TYPES(V)
+#undef V
 };
 
 struct CompileCacheEntry {
@@ -34,6 +41,7 @@ struct CompileCacheEntry {
   // Copy the cache into a new store for V8 to consume. Caller takes
   // ownership.
   v8::ScriptCompiler::CachedData* CopyCache() const;
+  const char* type_name() const;
 };
 
 #define COMPILE_CACHE_STATUS(V)                                                \
@@ -70,6 +78,7 @@ class CompileCacheHandler {
   void MaybeSave(CompileCacheEntry* entry,
                  v8::Local<v8::Module> mod,
                  bool rejected);
+  void MaybeSave(CompileCacheEntry* entry, std::string_view transpiled);
   std::string_view cache_dir() { return compile_cache_dir_; }
 
  private:
diff --git a/src/node_modules.cc b/src/node_modules.cc
index 4b522a91323c9f..85c8e21cf026ff 100644
--- a/src/node_modules.cc
+++ b/src/node_modules.cc
@@ -1,6 +1,7 @@
 #include "node_modules.h"
 #include <cstdio>
 #include "base_object-inl.h"
+#include "compile_cache.h"
 #include "node_errors.h"
 #include "node_external_reference.h"
 #include "node_url.h"
@@ -21,12 +22,16 @@ namespace modules {
 
 using v8::Array;
 using v8::Context;
+using v8::External;
 using v8::FunctionCallbackInfo;
 using v8::HandleScope;
+using v8::Integer;
 using v8::Isolate;
 using v8::Local;
 using v8::LocalVector;
+using v8::Name;
 using v8::NewStringType;
+using v8::Null;
 using v8::Object;
 using v8::ObjectTemplate;
 using v8::Primitive;
@@ -498,6 +503,74 @@ void GetCompileCacheDir(const FunctionCallbackInfo<Value>& args) {
           .ToLocalChecked());
 }
 
+void GetCompileCacheEntry(const FunctionCallbackInfo<Value>& args) {
+  Isolate* isolate = args.GetIsolate();
+  CHECK(args[0]->IsString());  // TODO(joyeecheung): accept buffer.
+  CHECK(args[1]->IsString());
+  CHECK(args[2]->IsUint32());
+  Local<Context> context = isolate->GetCurrentContext();
+  Environment* env = Environment::GetCurrent(context);
+  if (!env->use_compile_cache()) {
+    return;
+  }
+  Local<String> source = args[0].As<String>();
+  Local<String> filename = args[1].As<String>();
+  CachedCodeType type =
+      static_cast<CachedCodeType>(args[2].As<v8::Uint32>()->Value());
+  auto* cache_entry =
+      env->compile_cache_handler()->GetOrInsert(source, filename, type);
+  if (cache_entry == nullptr) {
+    return;
+  }
+
+  v8::LocalVector<v8::Name> names(isolate,
+                                  {FIXED_ONE_BYTE_STRING(isolate, "external")});
+  v8::LocalVector<v8::Value> values(isolate,
+                                    {v8::External::New(isolate, cache_entry)});
+  if (cache_entry->cache != nullptr) {
+    Debug(env,
+          DebugCategory::COMPILE_CACHE,
+          "[compile cache] retrieving transpile cache for %s %s...",
+          cache_entry->type_name(),
+          cache_entry->source_filename);
+
+    std::string_view cache(
+        reinterpret_cast<const char*>(cache_entry->cache->data),
+        cache_entry->cache->length);
+    Local<Value> transpiled;
+    // TODO(joyeecheung): convert with simdutf and into external strings
+    if (!ToV8Value(context, cache).ToLocal(&transpiled)) {
+      Debug(env, DebugCategory::COMPILE_CACHE, "failed\n");
+      return;
+    } else {
+      Debug(env, DebugCategory::COMPILE_CACHE, "success\n");
+    }
+    names.push_back(FIXED_ONE_BYTE_STRING(isolate, "transpiled"));
+    values.push_back(transpiled);
+  } else {
+    Debug(env,
+          DebugCategory::COMPILE_CACHE,
+          "[compile cache] no transpile cache for %s %s\n",
+          cache_entry->type_name(),
+          cache_entry->source_filename);
+  }
+  args.GetReturnValue().Set(Object::New(
+      isolate, v8::Null(isolate), names.data(), values.data(), names.size()));
+}
+
+void SaveCompileCacheEntry(const FunctionCallbackInfo<Value>& args) {
+  Isolate* isolate = args.GetIsolate();
+  Local<Context> context = isolate->GetCurrentContext();
+  Environment* env = Environment::GetCurrent(context);
+  DCHECK(env->use_compile_cache());
+  CHECK(args[0]->IsExternal());
+  CHECK(args[1]->IsString());  // TODO(joyeecheung): accept buffer.
+  auto* cache_entry =
+      static_cast<CompileCacheEntry*>(args[0].As<External>()->Value());
+  Utf8Value utf8(isolate, args[1].As<String>());
+  env->compile_cache_handler()->MaybeSave(cache_entry, utf8.ToStringView());
+}
+
 void BindingData::CreatePerIsolateProperties(IsolateData* isolate_data,
                                              Local<ObjectTemplate> target) {
   Isolate* isolate = isolate_data->isolate();
@@ -514,6 +587,8 @@ void BindingData::CreatePerIsolateProperties(IsolateData* isolate_data,
   SetMethod(isolate, target, "enableCompileCache", EnableCompileCache);
   SetMethod(isolate, target, "getCompileCacheDir", GetCompileCacheDir);
   SetMethod(isolate, target, "flushCompileCache", FlushCompileCache);
+  SetMethod(isolate, target, "getCompileCacheEntry", GetCompileCacheEntry);
+  SetMethod(isolate, target, "saveCompileCacheEntry", SaveCompileCacheEntry);
 }
 
 void BindingData::CreatePerContextProperties(Local<Object> target,
@@ -530,12 +605,31 @@ void BindingData::CreatePerContextProperties(Local<Object> target,
   compile_cache_status_values.push_back(                                       \
       FIXED_ONE_BYTE_STRING(isolate, #status));
   COMPILE_CACHE_STATUS(V)
+#undef V
 
   USE(target->Set(context,
                   FIXED_ONE_BYTE_STRING(isolate, "compileCacheStatus"),
                   Array::New(isolate,
                              compile_cache_status_values.data(),
                              compile_cache_status_values.size())));
+
+  LocalVector<Name> cached_code_type_keys(isolate);
+  LocalVector<Value> cached_code_type_values(isolate);
+
+#define V(type, value)                                                         \
+  cached_code_type_keys.push_back(FIXED_ONE_BYTE_STRING(isolate, #type));      \
+  cached_code_type_values.push_back(Integer::New(isolate, value));             \
+  DCHECK_EQ(value, cached_code_type_values.size() - 1);
+  CACHED_CODE_TYPES(V)
+#undef V
+
+  USE(target->Set(context,
+                  FIXED_ONE_BYTE_STRING(isolate, "cachedCodeTypes"),
+                  Object::New(isolate,
+                              Null(isolate),
+                              cached_code_type_keys.data(),
+                              cached_code_type_values.data(),
+                              cached_code_type_keys.size())));
 }
 
 void BindingData::RegisterExternalReferences(
@@ -547,6 +641,8 @@ void BindingData::RegisterExternalReferences(
   registry->Register(EnableCompileCache);
   registry->Register(GetCompileCacheDir);
   registry->Register(FlushCompileCache);
+  registry->Register(GetCompileCacheEntry);
+  registry->Register(SaveCompileCacheEntry);
 }
 
 }  // namespace modules
diff --git a/test/parallel/test-compile-cache-typescript-commonjs.js b/test/parallel/test-compile-cache-typescript-commonjs.js
new file mode 100644
index 00000000000000..b6c4581ed47be3
--- /dev/null
+++ b/test/parallel/test-compile-cache-typescript-commonjs.js
@@ -0,0 +1,166 @@
+'use strict';
+
+// This tests NODE_COMPILE_CACHE works for CommonJS with types.
+
+require('../common');
+const { spawnSyncAndAssert } = require('../common/child_process');
+const assert = require('assert');
+const tmpdir = require('../common/tmpdir');
+const fixtures = require('../common/fixtures');
+
+// Check cache for .ts files that would be run as CommonJS.
+{
+  tmpdir.refresh();
+  const dir = tmpdir.resolve('.compile_cache_dir');
+  const script = fixtures.path('typescript', 'ts', 'test-commonjs-parsing.ts');
+
+  spawnSyncAndAssert(
+    process.execPath,
+    [script],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: dir
+      },
+      cwd: tmpdir.path
+    },
+    {
+      stderr(output) {
+        assert.match(output, /saving transpilation cache for StrippedTypeScript .*test-commonjs-parsing\.ts/);
+        assert.match(output, /writing cache for StrippedTypeScript .*test-commonjs-parsing\.ts.*success/);
+        assert.match(output, /writing cache for CommonJS .*test-commonjs-parsing\.ts.*success/);
+        return true;
+      }
+    });
+
+  spawnSyncAndAssert(
+    process.execPath,
+    [script],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: dir
+      },
+      cwd: tmpdir.path
+    },
+    {
+      stderr(output) {
+        assert.match(output, /retrieving transpile cache for StrippedTypeScript .*test-commonjs-parsing\.ts.*success/);
+        assert.match(output, /reading cache from .* for CommonJS .*test-commonjs-parsing\.ts.*success/);
+        assert.match(output, /skip persisting StrippedTypeScript .*test-commonjs-parsing\.ts because cache was the same/);
+        assert.match(output, /V8 code cache for CommonJS .*test-commonjs-parsing\.ts was accepted, keeping the in-memory entry/);
+        assert.match(output, /skip persisting CommonJS .*test-commonjs-parsing\.ts because cache was the same/);
+        return true;
+      }
+    });
+}
+
+// Check cache for .cts files that require .cts files.
+{
+  tmpdir.refresh();
+  const dir = tmpdir.resolve('.compile_cache_dir');
+  const script = fixtures.path('typescript', 'cts', 'test-require-commonjs.cts');
+
+  spawnSyncAndAssert(
+    process.execPath,
+    [script],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: dir
+      },
+      cwd: tmpdir.path
+    },
+    {
+      stderr(output) {
+        assert.match(output, /writing cache for StrippedTypeScript .*test-require-commonjs\.cts.*success/);
+        assert.match(output, /writing cache for StrippedTypeScript .*test-cts-export-foo\.cts.*success/);
+        assert.match(output, /writing cache for CommonJS .*test-require-commonjs\.cts.*success/);
+        assert.match(output, /writing cache for CommonJS .*test-cts-export-foo\.cts.*success/);
+        return true;
+      }
+    });
+
+  spawnSyncAndAssert(
+    process.execPath,
+    [script],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: dir
+      },
+      cwd: tmpdir.path
+    },
+    {
+      stderr(output) {
+        assert.match(output, /retrieving transpile cache for StrippedTypeScript .*test-require-commonjs\.cts.*success/);
+        assert.match(output, /skip persisting StrippedTypeScript .*test-require-commonjs\.cts because cache was the same/);
+        assert.match(output, /retrieving transpile cache for StrippedTypeScript .*test-cts-export-foo\.cts.*success/);
+        assert.match(output, /skip persisting StrippedTypeScript .*test-cts-export-foo\.cts because cache was the same/);
+
+        assert.match(output, /V8 code cache for CommonJS .*test-require-commonjs\.cts was accepted, keeping the in-memory entry/);
+        assert.match(output, /skip persisting CommonJS .*test-require-commonjs\.cts because cache was the same/);
+        assert.match(output, /V8 code cache for CommonJS .*test-cts-export-foo\.cts was accepted, keeping the in-memory entry/);
+        assert.match(output, /skip persisting CommonJS .*test-cts-export-foo\.cts because cache was the same/);
+        return true;
+      }
+    });
+}
+
+// Check cache for .cts files that require .mts files.
+{
+  tmpdir.refresh();
+  const dir = tmpdir.resolve('.compile_cache_dir');
+  const script = fixtures.path('typescript', 'cts', 'test-require-mts-module.cts');
+
+  spawnSyncAndAssert(
+    process.execPath,
+    [script],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: dir
+      },
+      cwd: tmpdir.path
+    },
+    {
+      stderr(output) {
+        assert.match(output, /writing cache for StrippedTypeScript .*test-require-mts-module\.cts.*success/);
+        assert.match(output, /writing cache for StrippedTypeScript .*test-mts-export-foo\.mts.*success/);
+        assert.match(output, /writing cache for CommonJS .*test-require-mts-module\.cts.*success/);
+        assert.match(output, /writing cache for ESM .*test-mts-export-foo\.mts.*success/);
+        return true;
+      }
+    });
+
+  spawnSyncAndAssert(
+    process.execPath,
+    [script],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: dir
+      },
+      cwd: tmpdir.path
+    },
+    {
+      stderr(output) {
+        assert.match(output, /retrieving transpile cache for StrippedTypeScript .*test-require-mts-module\.cts.*success/);
+        assert.match(output, /skip persisting StrippedTypeScript .*test-require-mts-module\.cts because cache was the same/);
+        assert.match(output, /retrieving transpile cache for StrippedTypeScript .*test-mts-export-foo\.mts.*success/);
+        assert.match(output, /skip persisting StrippedTypeScript .*test-mts-export-foo\.mts because cache was the same/);
+
+        assert.match(output, /V8 code cache for CommonJS .*test-require-mts-module\.cts was accepted, keeping the in-memory entry/);
+        assert.match(output, /skip persisting CommonJS .*test-require-mts-module\.cts because cache was the same/);
+        assert.match(output, /V8 code cache for ESM .*test-mts-export-foo\.mts was accepted, keeping the in-memory entry/);
+        assert.match(output, /skip persisting ESM .*test-mts-export-foo\.mts because cache was the same/);
+        return true;
+      }
+    });
+}
diff --git a/test/parallel/test-compile-cache-typescript-esm.js b/test/parallel/test-compile-cache-typescript-esm.js
new file mode 100644
index 00000000000000..cec7b814da6679
--- /dev/null
+++ b/test/parallel/test-compile-cache-typescript-esm.js
@@ -0,0 +1,167 @@
+'use strict';
+
+// This tests NODE_COMPILE_CACHE works for ESM with types.
+
+require('../common');
+const { spawnSyncAndAssert } = require('../common/child_process');
+const assert = require('assert');
+const tmpdir = require('../common/tmpdir');
+const fixtures = require('../common/fixtures');
+
+// Check cache for .ts files that would be run as ESM.
+{
+  tmpdir.refresh();
+  const dir = tmpdir.resolve('.compile_cache_dir');
+  const script = fixtures.path('typescript', 'ts', 'test-module-typescript.ts');
+
+  spawnSyncAndAssert(
+    process.execPath,
+    [script],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: dir
+      },
+      cwd: tmpdir.path
+    },
+    {
+      stderr(output) {
+        assert.match(output, /saving transpilation cache for StrippedTypeScript .*test-module-typescript\.ts/);
+        assert.match(output, /writing cache for StrippedTypeScript .*test-module-typescript\.ts.*success/);
+        assert.match(output, /writing cache for ESM .*test-module-typescript\.ts.*success/);
+        return true;
+      }
+    });
+
+  spawnSyncAndAssert(
+    process.execPath,
+    [script],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: dir
+      },
+      cwd: tmpdir.path
+    },
+    {
+      stderr(output) {
+        assert.match(output, /retrieving transpile cache for StrippedTypeScript .*test-module-typescript\.ts.*success/);
+        assert.match(output, /reading cache from .* for ESM .*test-module-typescript\.ts.*success/);
+        assert.match(output, /skip persisting StrippedTypeScript .*test-module-typescript\.ts because cache was the same/);
+        assert.match(output, /V8 code cache for ESM .*test-module-typescript\.ts was accepted, keeping the in-memory entry/);
+        assert.match(output, /skip persisting ESM .*test-module-typescript\.ts because cache was the same/);
+        return true;
+      }
+    });
+}
+
+// Check cache for .mts files that import .mts files.
+{
+  tmpdir.refresh();
+  const dir = tmpdir.resolve('.compile_cache_dir');
+  const script = fixtures.path('typescript', 'mts', 'test-import-module.mts');
+
+  spawnSyncAndAssert(
+    process.execPath,
+    [script],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: dir
+      },
+      cwd: tmpdir.path
+    },
+    {
+      stderr(output) {
+        assert.match(output, /writing cache for StrippedTypeScript .*test-import-module\.mts.*success/);
+        assert.match(output, /writing cache for StrippedTypeScript .*test-mts-export-foo\.mts.*success/);
+        assert.match(output, /writing cache for ESM .*test-import-module\.mts.*success/);
+        assert.match(output, /writing cache for ESM .*test-mts-export-foo\.mts.*success/);
+        return true;
+      }
+    });
+
+  spawnSyncAndAssert(
+    process.execPath,
+    [script],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: dir
+      },
+      cwd: tmpdir.path
+    },
+    {
+      stderr(output) {
+        assert.match(output, /retrieving transpile cache for StrippedTypeScript .*test-import-module\.mts.*success/);
+        assert.match(output, /skip persisting StrippedTypeScript .*test-import-module\.mts because cache was the same/);
+        assert.match(output, /retrieving transpile cache for StrippedTypeScript .*test-mts-export-foo\.mts.*success/);
+        assert.match(output, /skip persisting StrippedTypeScript .*test-mts-export-foo\.mts because cache was the same/);
+
+        assert.match(output, /V8 code cache for ESM .*test-import-module\.mts was accepted, keeping the in-memory entry/);
+        assert.match(output, /skip persisting ESM .*test-import-module\.mts because cache was the same/);
+        assert.match(output, /V8 code cache for ESM .*test-mts-export-foo\.mts was accepted, keeping the in-memory entry/);
+        assert.match(output, /skip persisting ESM .*test-mts-export-foo\.mts because cache was the same/);
+        return true;
+      }
+    });
+}
+
+
+// Check cache for .mts files that import .cts files.
+{
+  tmpdir.refresh();
+  const dir = tmpdir.resolve('.compile_cache_dir');
+  const script = fixtures.path('typescript', 'mts', 'test-import-commonjs.mts');
+
+  spawnSyncAndAssert(
+    process.execPath,
+    [script],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: dir
+      },
+      cwd: tmpdir.path
+    },
+    {
+      stderr(output) {
+        assert.match(output, /writing cache for StrippedTypeScript .*test-import-commonjs\.mts.*success/);
+        assert.match(output, /writing cache for StrippedTypeScript .*test-cts-export-foo\.cts.*success/);
+        assert.match(output, /writing cache for ESM .*test-import-commonjs\.mts.*success/);
+        assert.match(output, /writing cache for CommonJS .*test-cts-export-foo\.cts.*success/);
+        return true;
+      }
+    });
+
+  spawnSyncAndAssert(
+    process.execPath,
+    [script],
+    {
+      env: {
+        ...process.env,
+        NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+        NODE_COMPILE_CACHE: dir
+      },
+      cwd: tmpdir.path
+    },
+    {
+      stderr(output) {
+        assert.match(output, /retrieving transpile cache for StrippedTypeScript .*test-import-commonjs\.mts.*success/);
+        assert.match(output, /skip persisting StrippedTypeScript .*test-import-commonjs\.mts because cache was the same/);
+        assert.match(output, /retrieving transpile cache for StrippedTypeScript .*test-cts-export-foo\.cts.*success/);
+        assert.match(output, /skip persisting StrippedTypeScript .*test-cts-export-foo\.cts because cache was the same/);
+
+        assert.match(output, /V8 code cache for ESM .*test-import-commonjs\.mts was accepted, keeping the in-memory entry/);
+        assert.match(output, /skip persisting ESM .*test-import-commonjs\.mts because cache was the same/);
+        assert.match(output, /V8 code cache for CommonJS .*test-cts-export-foo\.cts was accepted, keeping the in-memory entry/);
+        assert.match(output, /skip persisting CommonJS .*test-cts-export-foo\.cts because cache was the same/);
+        return true;
+      }
+    });
+}
diff --git a/test/parallel/test-compile-cache-typescript-strip-miss.js b/test/parallel/test-compile-cache-typescript-strip-miss.js
new file mode 100644
index 00000000000000..5d37a377f002e4
--- /dev/null
+++ b/test/parallel/test-compile-cache-typescript-strip-miss.js
@@ -0,0 +1,104 @@
+'use strict';
+
+// This tests NODE_COMPILE_CACHE can handle cache invalidation
+// between strip-only TypeScript and transformed TypeScript.
+
+require('../common');
+const { spawnSyncAndAssert } = require('../common/child_process');
+const assert = require('assert');
+const tmpdir = require('../common/tmpdir');
+const fixtures = require('../common/fixtures');
+
+tmpdir.refresh();
+const dir = tmpdir.resolve('.compile_cache_dir');
+const script = fixtures.path('typescript', 'ts', 'test-typescript.ts');
+
+spawnSyncAndAssert(
+  process.execPath,
+  [script],
+  {
+    env: {
+      ...process.env,
+      NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+      NODE_COMPILE_CACHE: dir
+    },
+    cwd: tmpdir.path
+  },
+  {
+    stderr(output) {
+      assert.match(output, /saving transpilation cache for StrippedTypeScript .*test-typescript\.ts/);
+      assert.match(output, /writing cache for StrippedTypeScript .*test-typescript\.ts.*success/);
+      assert.match(output, /writing cache for CommonJS .*test-typescript\.ts.*success/);
+      return true;
+    }
+  });
+
+// Reloading with transform should miss the cache generated without transform.
+spawnSyncAndAssert(
+  process.execPath,
+  ['--experimental-transform-types', script],
+  {
+    env: {
+      ...process.env,
+      NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+      NODE_COMPILE_CACHE: dir
+    },
+    cwd: tmpdir.path
+  },
+  {
+    stderr(output) {
+      // Both the transpile cache and the code cache should be missed.
+      assert.match(output, /no transpile cache for TransformedTypeScriptWithSourceMaps .*test-typescript\.ts/);
+      assert.match(output, /reading cache from .* for CommonJS .*test-typescript\.ts.*mismatch/);
+      // New cache with source map should be generated.
+      assert.match(output, /writing cache for TransformedTypeScriptWithSourceMaps .*test-typescript\.ts.*success/);
+      assert.match(output, /writing cache for CommonJS .*test-typescript\.ts.*success/);
+      return true;
+    }
+  });
+
+// Reloading with transform should hit the cache generated with transform.
+spawnSyncAndAssert(
+  process.execPath,
+  ['--experimental-transform-types', script],
+  {
+    env: {
+      ...process.env,
+      NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+      NODE_COMPILE_CACHE: dir
+    },
+    cwd: tmpdir.path
+  },
+  {
+    stderr(output) {
+      assert.match(output, /retrieving transpile cache for TransformedTypeScriptWithSourceMaps .*test-typescript\.ts.*success/);
+      assert.match(output, /reading cache from .* for CommonJS .*test-typescript\.ts.*success/);
+      assert.match(output, /skip persisting TransformedTypeScriptWithSourceMaps .*test-typescript\.ts because cache was the same/);
+      assert.match(output, /V8 code cache for CommonJS .*test-typescript\.ts was accepted, keeping the in-memory entry/);
+      assert.match(output, /skip persisting CommonJS .*test-typescript\.ts because cache was the same/);
+      return true;
+    }
+  });
+
+// Reloading without transform should hit the co-existing transpile cache generated without transform,
+// but miss the code cache generated with transform.
+spawnSyncAndAssert(
+  process.execPath,
+  [script],
+  {
+    env: {
+      ...process.env,
+      NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+      NODE_COMPILE_CACHE: dir
+    },
+    cwd: tmpdir.path
+  },
+  {
+    stderr(output) {
+      assert.match(output, /retrieving transpile cache for StrippedTypeScript .*test-typescript\.ts.*success/);
+      assert.match(output, /reading cache from .* for CommonJS .*test-typescript\.ts.*mismatch/);
+      assert.match(output, /skip persisting StrippedTypeScript .*test-typescript\.ts because cache was the same/);
+      assert.match(output, /writing cache for CommonJS .*test-typescript\.ts.*success/);
+      return true;
+    }
+  });
diff --git a/test/parallel/test-compile-cache-typescript-strip-sourcemaps.js b/test/parallel/test-compile-cache-typescript-strip-sourcemaps.js
new file mode 100644
index 00000000000000..da5e350496f005
--- /dev/null
+++ b/test/parallel/test-compile-cache-typescript-strip-sourcemaps.js
@@ -0,0 +1,59 @@
+'use strict';
+
+// This tests NODE_COMPILE_CACHE can be used for type stripping and ignores
+// --enable-source-maps as there's no difference in the code generated.
+
+require('../common');
+const { spawnSyncAndAssert } = require('../common/child_process');
+const assert = require('assert');
+const tmpdir = require('../common/tmpdir');
+const fixtures = require('../common/fixtures');
+
+tmpdir.refresh();
+const dir = tmpdir.resolve('.compile_cache_dir');
+const script = fixtures.path('typescript', 'ts', 'test-typescript.ts');
+
+spawnSyncAndAssert(
+  process.execPath,
+  [script],
+  {
+    env: {
+      ...process.env,
+      NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+      NODE_COMPILE_CACHE: dir
+    },
+    cwd: tmpdir.path
+  },
+  {
+    stderr(output) {
+      assert.match(output, /saving transpilation cache for StrippedTypeScript .*test-typescript\.ts/);
+      assert.match(output, /writing cache for StrippedTypeScript .*test-typescript\.ts.*success/);
+      assert.match(output, /writing cache for CommonJS .*test-typescript\.ts.*success/);
+      return true;
+    }
+  });
+
+// Reloading with source maps should hit the cache generated without source maps, because for
+// type stripping, only sourceURL is added regardless of whether source map is enabled.
+spawnSyncAndAssert(
+  process.execPath,
+  ['--enable-source-maps', script],
+  {
+    env: {
+      ...process.env,
+      NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+      NODE_COMPILE_CACHE: dir
+    },
+    cwd: tmpdir.path
+  },
+  {
+    stderr(output) {
+      // Both the transpile cache and the code cache should be missed.
+      assert.match(output, /retrieving transpile cache for StrippedTypeScript .*test-typescript\.ts.*success/);
+      assert.match(output, /reading cache from .* for CommonJS .*test-typescript\.ts.*success/);
+      assert.match(output, /skip persisting StrippedTypeScript .*test-typescript\.ts because cache was the same/);
+      assert.match(output, /V8 code cache for CommonJS .*test-typescript\.ts was accepted, keeping the in-memory entry/);
+      assert.match(output, /skip persisting CommonJS .*test-typescript\.ts because cache was the same/);
+      return true;
+    }
+  });
diff --git a/test/parallel/test-compile-cache-typescript-transform.js b/test/parallel/test-compile-cache-typescript-transform.js
new file mode 100644
index 00000000000000..41eb67b203baa1
--- /dev/null
+++ b/test/parallel/test-compile-cache-typescript-transform.js
@@ -0,0 +1,127 @@
+'use strict';
+
+// This tests NODE_COMPILE_CACHE works with --experimental-transform-types.
+
+require('../common');
+const { spawnSyncAndAssert } = require('../common/child_process');
+const assert = require('assert');
+const tmpdir = require('../common/tmpdir');
+const fixtures = require('../common/fixtures');
+
+
+tmpdir.refresh();
+const dir = tmpdir.resolve('.compile_cache_dir');
+const script = fixtures.path('typescript', 'ts', 'transformation', 'test-enum.ts');
+
+// Check --experimental-transform-types which enables source maps by default.
+spawnSyncAndAssert(
+  process.execPath,
+  ['--experimental-transform-types', script],
+  {
+    env: {
+      ...process.env,
+      NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+      NODE_COMPILE_CACHE: dir
+    },
+    cwd: tmpdir.path
+  },
+  {
+    stderr(output) {
+      assert.match(output, /saving transpilation cache for TransformedTypeScriptWithSourceMaps .*test-enum\.ts/);
+      assert.match(output, /writing cache for TransformedTypeScriptWithSourceMaps .*test-enum\.ts.*success/);
+      assert.match(output, /writing cache for CommonJS .*test-enum\.ts.*success/);
+      return true;
+    }
+  });
+
+spawnSyncAndAssert(
+  process.execPath,
+  ['--experimental-transform-types', script],
+  {
+    env: {
+      ...process.env,
+      NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+      NODE_COMPILE_CACHE: dir
+    },
+    cwd: tmpdir.path
+  },
+  {
+    stderr(output) {
+      assert.match(output, /retrieving transpile cache for TransformedTypeScriptWithSourceMaps .*test-enum\.ts.*success/);
+      assert.match(output, /reading cache from .* for CommonJS .*test-enum\.ts.*success/);
+      assert.match(output, /skip persisting TransformedTypeScriptWithSourceMaps .*test-enum\.ts because cache was the same/);
+      assert.match(output, /V8 code cache for CommonJS .*test-enum\.ts was accepted, keeping the in-memory entry/);
+      assert.match(output, /skip persisting CommonJS .*test-enum\.ts because cache was the same/);
+      return true;
+    }
+  });
+
+// Reloading without source maps should miss the cache generated with source maps.
+spawnSyncAndAssert(
+  process.execPath,
+  ['--experimental-transform-types', '--no-enable-source-maps', script],
+  {
+    env: {
+      ...process.env,
+      NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+      NODE_COMPILE_CACHE: dir
+    },
+    cwd: tmpdir.path
+  },
+  {
+    stderr(output) {
+      // Both the transpile cache and the code cache should be missed.
+      assert.match(output, /no transpile cache for TransformedTypeScript .*test-enum\.ts/);
+      assert.match(output, /reading cache from .* for CommonJS .*test-enum\.ts.*mismatch/);
+      // New cache without source map should be generated.
+      assert.match(output, /writing cache for TransformedTypeScript .*test-enum\.ts.*success/);
+      assert.match(output, /writing cache for CommonJS .*test-enum\.ts.*success/);
+      return true;
+    }
+  });
+
+// Reloading without source maps again should hit the cache generated without source maps.
+spawnSyncAndAssert(
+  process.execPath,
+  ['--experimental-transform-types', '--no-enable-source-maps', script],
+  {
+    env: {
+      ...process.env,
+      NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+      NODE_COMPILE_CACHE: dir
+    },
+    cwd: tmpdir.path
+  },
+  {
+    stderr(output) {
+      assert.match(output, /retrieving transpile cache for TransformedTypeScript .*test-enum\.ts.*success/);
+      assert.match(output, /reading cache from .* for CommonJS .*test-enum\.ts.*success/);
+      assert.match(output, /skip persisting TransformedTypeScript .*test-enum\.ts because cache was the same/);
+      assert.match(output, /V8 code cache for CommonJS .*test-enum\.ts was accepted, keeping the in-memory entry/);
+      assert.match(output, /skip persisting CommonJS .*test-enum\.ts because cache was the same/);
+      return true;
+    }
+  });
+
+// Reloading with source maps again should hit the co-existing transpile cache with source
+// maps, but miss the code cache generated without source maps.
+spawnSyncAndAssert(
+  process.execPath,
+  ['--experimental-transform-types', script],
+  {
+    env: {
+      ...process.env,
+      NODE_DEBUG_NATIVE: 'COMPILE_CACHE',
+      NODE_COMPILE_CACHE: dir
+    },
+    cwd: tmpdir.path
+  },
+  {
+    stderr(output) {
+      assert.match(output, /retrieving transpile cache for TransformedTypeScriptWithSourceMaps .*test-enum\.ts.*success/);
+      assert.match(output, /reading cache from .* for CommonJS .*test-enum\.ts.*mismatch/);
+      assert.match(output, /skip persisting TransformedTypeScriptWithSourceMaps .*test-enum\.ts because cache was the same/);
+      assert.match(output, /writing cache for CommonJS .*test-enum\.ts.*success/);
+      return true;
+    }
+  });

From 0713ee3a17b06654fa80321bf53eb4f19a49413c Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Wed, 22 Jan 2025 13:05:54 -0800
Subject: [PATCH 10/38] test: simplify common/index.js

Move single or trivial and limited use things out of
common/index.js for the purpose of simplifying and reducing
common/index.js

PR-URL: https://github.com/nodejs/node/pull/56712
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 test/common/README.md                   |  6 ------
 test/common/index.js                    | 12 ------------
 test/common/index.mjs                   |  4 ----
 test/parallel/test-source-map-enable.js |  3 ++-
 test/tick-processor/util.js             | 11 +++++++++--
 test/wasi/test-wasi-io.js               | 11 ++++++++---
 6 files changed, 19 insertions(+), 28 deletions(-)

diff --git a/test/common/README.md b/test/common/README.md
index 9ecee39b64a3df..c3c44e32b3788c 100644
--- a/test/common/README.md
+++ b/test/common/README.md
@@ -279,12 +279,6 @@ Platform check for IBMi.
 
 Platform check for Linux.
 
-### `isLinuxPPCBE`
-
-* [\<boolean>][<boolean>]
-
-Platform check for Linux on PowerPC.
-
 ### `isMacOS`
 
 * [\<boolean>][<boolean>]
diff --git a/test/common/index.js b/test/common/index.js
index e8bf65d0a6edb4..238d66e96fe257 100644
--- a/test/common/index.js
+++ b/test/common/index.js
@@ -1034,11 +1034,6 @@ const common = {
     return require('os').type() === 'OS400';
   },
 
-  get isLinuxPPCBE() {
-    return (process.platform === 'linux') && (process.arch === 'ppc64') &&
-           (require('os').endianness() === 'BE');
-  },
-
   get localhostIPv4() {
     if (localhostIPv4 !== null) return localhostIPv4;
 
@@ -1067,13 +1062,6 @@ const common = {
     return +process.env.NODE_COMMON_PORT || 12346;
   },
 
-  /**
-   * Returns the EOL character used by this Git checkout.
-   */
-  get checkoutEOL() {
-    return fs.readFileSync(__filename).includes('\r\n') ? '\r\n' : '\n';
-  },
-
   get isInsideDirWithUnusualChars() {
     return __dirname.includes('%') ||
            (!isWindows && __dirname.includes('\\')) ||
diff --git a/test/common/index.mjs b/test/common/index.mjs
index 090659f93be8ef..aafef1453bd78a 100644
--- a/test/common/index.mjs
+++ b/test/common/index.mjs
@@ -7,7 +7,6 @@ const {
   allowGlobals,
   buildType,
   canCreateSymLink,
-  checkoutEOL,
   childShouldThrowAndAbort,
   createZeroFilledFile,
   enoughTestMem,
@@ -27,7 +26,6 @@ const {
   isIBMi,
   isInsideDirWithUnusualChars,
   isLinux,
-  isLinuxPPCBE,
   isMainThread,
   isOpenBSD,
   isMacOS,
@@ -59,7 +57,6 @@ export {
   allowGlobals,
   buildType,
   canCreateSymLink,
-  checkoutEOL,
   childShouldThrowAndAbort,
   createRequire,
   createZeroFilledFile,
@@ -81,7 +78,6 @@ export {
   isIBMi,
   isInsideDirWithUnusualChars,
   isLinux,
-  isLinuxPPCBE,
   isMainThread,
   isOpenBSD,
   isMacOS,
diff --git a/test/parallel/test-source-map-enable.js b/test/parallel/test-source-map-enable.js
index 46c25d26cfa8e7..64f4254fcddbc6 100644
--- a/test/parallel/test-source-map-enable.js
+++ b/test/parallel/test-source-map-enable.js
@@ -242,6 +242,7 @@ function nextdir() {
 
 // Persists line lengths for in-memory representation of source file.
 {
+  const checkoutEOL = fs.readFileSync(__filename).includes('\r\n') ? '\r\n' : '\n';
   const coverageDirectory = nextdir();
   spawnSync(process.execPath, [
     require.resolve('../fixtures/source-map/istanbul-throw.js'),
@@ -250,7 +251,7 @@ function nextdir() {
     'istanbul-throw.js',
     coverageDirectory
   );
-  if (common.checkoutEOL === '\r\n') {
+  if (checkoutEOL === '\r\n') {
     assert.deepStrictEqual(sourceMap.lineLengths, [1086, 31, 185, 649, 0]);
   } else {
     assert.deepStrictEqual(sourceMap.lineLengths, [1085, 30, 184, 648, 0]);
diff --git a/test/tick-processor/util.js b/test/tick-processor/util.js
index 6d118b7c38bc66..9586a81c276a65 100644
--- a/test/tick-processor/util.js
+++ b/test/tick-processor/util.js
@@ -5,14 +5,21 @@ const {
   isWindows,
   isSunOS,
   isAIX,
-  isLinuxPPCBE,
   isFreeBSD,
 } = require('../common');
 
+const { endianness } = require('os');
+
+function isLinuxPPCBE() {
+  return (process.platform === 'linux') &&
+         (process.arch === 'ppc64') &&
+         (endianness() === 'BE');
+}
+
 module.exports = {
   isCPPSymbolsNotMapped: isWindows ||
                          isSunOS ||
                          isAIX ||
-                         isLinuxPPCBE ||
+                         isLinuxPPCBE() ||
                          isFreeBSD,
 };
diff --git a/test/wasi/test-wasi-io.js b/test/wasi/test-wasi-io.js
index 061ac88a73ece4..f5348644f1cfbf 100644
--- a/test/wasi/test-wasi-io.js
+++ b/test/wasi/test-wasi-io.js
@@ -1,14 +1,19 @@
 'use strict';
-const common = require('../common');
-const { checkoutEOL } = common;
+require('../common');
+const { readFileSync } = require('fs');
 const { testWasiPreview1 } = require('../common/wasi');
 
+const checkoutEOL = readFileSync(__filename).includes('\r\n') ? '\r\n' : '\n';
+
+// TODO(@jasnell): It's not entirely clear what this test is asserting.
+// More comments would be helpful.
+
 testWasiPreview1(['freopen'], {}, { stdout: `hello from input2.txt${checkoutEOL}` });
 testWasiPreview1(['read_file'], {}, { stdout: `hello from input.txt${checkoutEOL}` });
 testWasiPreview1(['read_file_twice'], {}, {
   stdout: `hello from input.txt${checkoutEOL}hello from input.txt${checkoutEOL}`,
 });
 // Tests that are currently unsupported on Windows.
-if (!common.isWindows) {
+if (process.platform !== 'win32') {
   testWasiPreview1(['stdin'], { input: 'hello world' }, { stdout: 'hello world' });
 }

From 8caa1dcee63b2c6fd7a9edf9b9a6222b38a2cf62 Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Wed, 22 Jan 2025 14:19:38 -0800
Subject: [PATCH 11/38] test: rely less on duplicative common test harness
 utilities

There are several cleanups here that are not just style nits...

1. The `common.isMainThread` was just a passthrough to the
   `isMainThread` export on the worker_thread module. It's
   use was inconsistent and just obfuscated the fact that
   the test file depend on the `worker_threads` built-in.
   By eliminating it we simplify the test harness a bit and
   make it clearer which tests depend on the worker_threads
   check.
2. The `common.isDumbTerminal` is fairly unnecesary since
   that just wraps a public API check.
3. Several of the `common.skipIf....` checks were inconsistently
   used and really don't need to be separate utility functions.

A key part of the motivation here is to work towards making more
of the tests more self-contained and less reliant on the common
test harness where possible.

PR-URL: https://github.com/nodejs/node/pull/56712
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 test/abort/test-abort-backtrace.js            | 45 ++++++++++++-
 test/async-hooks/init-hooks.js                |  5 +-
 test/async-hooks/test-crypto-pbkdf2.js        |  7 +-
 test/async-hooks/test-crypto-randomBytes.js   |  7 +-
 test/async-hooks/test-enable-disable.js       |  3 +-
 test/async-hooks/test-fseventwrap.js          |  7 +-
 .../test-fsreqcallback-readFile.js            |  4 +-
 test/async-hooks/test-getaddrinforeqwrap.js   |  4 +-
 test/async-hooks/test-getnameinforeqwrap.js   |  4 +-
 test/async-hooks/test-graph.signal.js         |  7 +-
 .../test-no-assert-when-disabled.js           |  5 +-
 test/async-hooks/test-pipewrap.js             |  4 +-
 ...promise.chain-promise-before-init-hooks.js |  4 +-
 test/async-hooks/test-promise.js              |  4 +-
 test/async-hooks/test-signalwrap.js           |  7 +-
 test/async-hooks/test-statwatcher.js          |  5 +-
 .../test-unhandled-rejection-context.js       |  4 +-
 test/benchmark/test-benchmark-napi.js         |  4 +-
 test/common/README.md                         | 17 -----
 test/common/index.js                          | 66 -------------------
 test/common/index.mjs                         |  8 ---
 test/es-module/test-esm-resolve-type.mjs      |  4 +-
 .../test-vm-main-context-default-loader.js    |  6 +-
 test/fixtures/permission/fs-write.js          |  8 ++-
 test/fixtures/permission/processbinding.js    |  6 +-
 test/internet/test-trace-events-dns.js        |  4 +-
 ...test-async-hooks-disable-during-promise.js |  4 +-
 .../test-async-hooks-promise-triggerid.js     |  4 +-
 test/parallel/test-async-hooks-promise.js     |  4 +-
 ...st-async-hooks-top-level-clearimmediate.js |  4 +-
 .../test-async-wrap-promise-after-enabled.js  |  4 +-
 test/parallel/test-bootstrap-modules.js       | 10 +--
 .../test-child-process-validate-stdio.js      |  4 +-
 .../test-cluster-net-listen-relative-path.js  |  9 ++-
 test/parallel/test-code-cache.js              |  3 +-
 test/parallel/test-console-clear.js           |  4 +-
 test/parallel/test-console.js                 |  4 +-
 test/parallel/test-crypto-no-algorithm.js     |  3 +-
 test/parallel/test-cwd-enoent-preload.js      |  9 ++-
 test/parallel/test-cwd-enoent-repl.js         |  9 ++-
 test/parallel/test-cwd-enoent.js              |  9 ++-
 test/parallel/test-fs-mkdir.js                |  3 +-
 test/parallel/test-fs-realpath.js             |  4 +-
 test/parallel/test-fs-whatwg-url.js           |  4 +-
 test/parallel/test-fs-write-file-sync.js      |  4 +-
 test/parallel/test-http-chunk-problem.js      | 11 +++-
 test/parallel/test-icu-env.js                 |  4 +-
 .../test-inspector-already-activated-cli.js   |  7 +-
 .../test-inspector-async-hook-after-done.js   |  7 +-
 ...st-inspector-async-hook-setup-at-signal.js |  6 +-
 .../test-inspector-connect-main-thread.js     |  4 +-
 .../test-inspector-connect-to-main-thread.js  |  4 +-
 test/parallel/test-inspector-contexts.js      |  4 +-
 ...ctor-exit-worker-in-wait-for-connection.js | 12 +++-
 ...tor-exit-worker-in-wait-for-connection2.js |  6 +-
 test/parallel/test-inspector-open-coverage.js |  7 +-
 ...st-inspector-open-port-integer-overflow.js |  7 +-
 .../test-inspector-overwrite-config.js        |  4 +-
 .../test-inspector-port-zero-cluster.js       |  7 +-
 .../parallel/test-inspector-tracing-domain.js |  8 ++-
 .../test-inspector-workers-flat-list.js       |  4 +-
 test/parallel/test-internal-module-require.js |  3 +-
 ...st-performance-nodetiming-uvmetricsinfo.js |  6 +-
 .../test-permission-allow-addons-cli.js       |  6 +-
 ...test-permission-allow-child-process-cli.js |  8 ++-
 .../test-permission-allow-wasi-cli.js         |  6 +-
 .../test-permission-child-process-cli.js      |  7 +-
 .../test-permission-fs-absolute-path.js       |  6 +-
 ...test-permission-fs-internal-module-stat.js |  6 +-
 test/parallel/test-permission-fs-read.js      |  6 +-
 .../test-permission-fs-relative-path.js       |  6 +-
 .../test-permission-fs-repeat-path.js         |  6 +-
 test/parallel/test-permission-fs-require.js   |  8 ++-
 .../test-permission-fs-symlink-relative.js    |  7 +-
 ...test-permission-fs-symlink-target-write.js | 18 +++--
 test/parallel/test-permission-fs-symlink.js   | 12 +++-
 .../test-permission-fs-traversal-path.js      | 13 +++-
 test/parallel/test-permission-fs-wildcard.js  |  6 +-
 .../test-permission-fs-windows-path.js        |  6 +-
 .../test-permission-fs-write-report.js        | 10 ++-
 test/parallel/test-permission-fs-write-v8.js  | 10 ++-
 test/parallel/test-permission-fs-write.js     | 10 ++-
 .../parallel/test-permission-inspector-brk.js |  6 +-
 test/parallel/test-permission-inspector.js    |  7 +-
 test/parallel/test-permission-no-addons.js    |  6 +-
 .../test-permission-processbinding.js         |  6 +-
 .../test-permission-worker-threads-cli.js     |  8 ++-
 test/parallel/test-pipe-file-to-http.js       |  7 +-
 .../parallel/test-preload-self-referential.js |  4 +-
 test/parallel/test-process-abort.js           |  4 +-
 .../test-process-beforeexit-throw-exit.js     |  6 +-
 .../test-process-chdir-errormessage.js        |  5 +-
 test/parallel/test-process-chdir.js           |  4 +-
 test/parallel/test-process-env-tz.js          |  7 +-
 test/parallel/test-process-euid-egid.js       |  5 +-
 test/parallel/test-process-exit-handler.js    |  4 +-
 test/parallel/test-process-get-builtin.mjs    |  3 +-
 test/parallel/test-process-initgroups.js      |  5 +-
 test/parallel/test-process-load-env-file.js   |  5 +-
 test/parallel/test-process-setgroups.js       |  4 +-
 test/parallel/test-process-uid-gid.js         |  4 +-
 test/parallel/test-process-umask-mask.js      |  3 +-
 test/parallel/test-process-umask.js           |  3 +-
 ...-readline-interface-no-trailing-newline.js |  4 +-
 ...est-readline-interface-recursive-writes.js |  4 +-
 test/parallel/test-readline-interface.js      |  5 +-
 test/parallel/test-readline-position.js       |  4 +-
 .../test-readline-promises-interface.js       |  5 +-
 .../test-readline-promises-tab-complete.js    |  4 +-
 test/parallel/test-readline-tab-complete.js   |  4 +-
 .../test-readline-undefined-columns.js        |  4 +-
 test/parallel/test-readline.js                |  4 +-
 test/parallel/test-repl-autocomplete.js       |  4 +-
 test/parallel/test-repl-editor.js             |  4 +-
 test/parallel/test-repl-history-navigation.js |  4 +-
 ...repl-load-multiline-no-trailing-newline.js |  4 +-
 test/parallel/test-repl-load-multiline.js     |  4 +-
 test/parallel/test-repl-mode.js               |  4 +-
 test/parallel/test-repl-permission-model.js   |  4 +-
 test/parallel/test-repl-persistent-history.js |  4 +-
 .../test-repl-programmatic-history.js         |  4 +-
 .../test-repl-require-self-referential.js     |  4 +-
 test/parallel/test-repl-require.js            |  4 +-
 test/parallel/test-repl-reverse-search.js     |  5 +-
 test/parallel/test-repl-sigint-nested-eval.js |  6 +-
 test/parallel/test-repl-sigint.js             |  6 +-
 .../test-repl-strict-mode-previews.js         |  5 +-
 .../parallel/test-repl-tab-complete-import.js |  5 +-
 test/parallel/test-repl-tab-complete.js       |  4 +-
 test/parallel/test-require-symlink.js         |  8 ++-
 test/parallel/test-runner-module-mocking.js   |  3 +-
 test/parallel/test-set-process-debug-port.js  |  6 +-
 test/parallel/test-setproctitle.js            | 14 ++--
 .../test-shadow-realm-import-value-resolve.js |  5 +-
 test/parallel/test-signal-args.js             |  9 ++-
 test/parallel/test-signal-handler.js          |  9 ++-
 test/parallel/test-stdio-pipe-access.js       |  5 +-
 test/parallel/test-stdio-pipe-redirect.js     |  5 +-
 .../test-timers-immediate-unref-simple.js     |  3 +-
 test/parallel/test-trace-events-api.js        |  7 +-
 .../test-trace-events-dynamic-enable.js       |  8 ++-
 test/parallel/test-warn-sigprof.js            |  9 ++-
 test/parallel/test-worker-name.js             | 11 +++-
 test/report/test-report-signal.js             |  8 ++-
 test/sequential/test-fs-watch.js              |  4 +-
 test/sequential/test-heapdump.js              |  4 +-
 test/sequential/test-init.js                  |  4 +-
 test/sequential/test-perf-hooks.js            |  5 +-
 148 files changed, 672 insertions(+), 290 deletions(-)

diff --git a/test/abort/test-abort-backtrace.js b/test/abort/test-abort-backtrace.js
index ce9ed39196eb1f..455bbf2361cf51 100644
--- a/test/abort/test-abort-backtrace.js
+++ b/test/abort/test-abort-backtrace.js
@@ -1,8 +1,47 @@
 'use strict';
-const common = require('../common');
+require('../common');
 const assert = require('assert');
 const cp = require('child_process');
 
+function getPrintedStackTrace(stderr) {
+  const lines = stderr.split('\n');
+
+  let state = 'initial';
+  const result = {
+    message: [],
+    nativeStack: [],
+    jsStack: [],
+  };
+  for (let i = 0; i < lines.length; ++i) {
+    const line = lines[i].trim();
+    if (line.length === 0) {
+      continue;  // Skip empty lines.
+    }
+
+    switch (state) {
+      case 'initial':
+        result.message.push(line);
+        if (line.includes('Native stack trace')) {
+          state = 'native-stack';
+        } else {
+          result.message.push(line);
+        }
+        break;
+      case 'native-stack':
+        if (line.includes('JavaScript stack trace')) {
+          state = 'js-stack';
+        } else {
+          result.nativeStack.push(line);
+        }
+        break;
+      case 'js-stack':
+        result.jsStack.push(line);
+        break;
+    }
+  }
+  return result;
+}
+
 if (process.argv[2] === 'child') {
   process.abort();
 } else {
@@ -10,7 +49,7 @@ if (process.argv[2] === 'child') {
   const stderr = child.stderr.toString();
 
   assert.strictEqual(child.stdout.toString(), '');
-  const { nativeStack, jsStack } = common.getPrintedStackTrace(stderr);
+  const { nativeStack, jsStack } = getPrintedStackTrace(stderr);
 
   if (!nativeStack.every((frame, index) => frame.startsWith(`${index + 1}:`))) {
     assert.fail(`Each frame should start with a frame number:\n${stderr}`);
@@ -18,7 +57,7 @@ if (process.argv[2] === 'child') {
 
   // For systems that don't support backtraces, the native stack is
   // going to be empty.
-  if (!common.isWindows && nativeStack.length > 0) {
+  if (process.platform !== 'win32' && nativeStack.length > 0) {
     const { getBinaryPath } = require('../common/shared-lib-util');
     if (!nativeStack.some((frame) => frame.includes(`[${getBinaryPath()}]`))) {
       assert.fail(`Some native stack frame include the binary name:\n${stderr}`);
diff --git a/test/async-hooks/init-hooks.js b/test/async-hooks/init-hooks.js
index 2206ab31eba75f..8fc44994fbc497 100644
--- a/test/async-hooks/init-hooks.js
+++ b/test/async-hooks/init-hooks.js
@@ -1,9 +1,10 @@
 'use strict';
 // Flags: --expose-gc
 
-const common = require('../common');
+require('../common');
 const assert = require('assert');
 const async_hooks = require('async_hooks');
+const { isMainThread } = require('worker_threads');
 const util = require('util');
 const print = process._rawDebug;
 
@@ -161,7 +162,7 @@ class ActivityCollector {
         const stub = { uid, type: 'Unknown', handleIsObject: true, handle: {} };
         this._activities.set(uid, stub);
         return stub;
-      } else if (!common.isMainThread) {
+      } else if (!isMainThread) {
         // Worker threads start main script execution inside of an AsyncWrap
         // callback, so we don't yield errors for these.
         return null;
diff --git a/test/async-hooks/test-crypto-pbkdf2.js b/test/async-hooks/test-crypto-pbkdf2.js
index 4788ce4a580656..c607adf7258760 100644
--- a/test/async-hooks/test-crypto-pbkdf2.js
+++ b/test/async-hooks/test-crypto-pbkdf2.js
@@ -1,10 +1,13 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
-if (!common.isMainThread)
+}
+const { isMainThread } = require('worker_threads');
+if (!isMainThread) {
   common.skip('Worker bootstrapping works differently -> different async IDs');
+}
 
 const assert = require('assert');
 const tick = require('../common/tick');
diff --git a/test/async-hooks/test-crypto-randomBytes.js b/test/async-hooks/test-crypto-randomBytes.js
index 88cd4643ab6638..8ecc1c45a9a524 100644
--- a/test/async-hooks/test-crypto-randomBytes.js
+++ b/test/async-hooks/test-crypto-randomBytes.js
@@ -1,10 +1,13 @@
 'use strict';
 
 const common = require('../common');
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
-if (!common.isMainThread)
+}
+const { isMainThread } = require('worker_threads');
+if (!isMainThread) {
   common.skip('Worker bootstrapping works differently -> different async IDs');
+}
 
 const assert = require('assert');
 const tick = require('../common/tick');
diff --git a/test/async-hooks/test-enable-disable.js b/test/async-hooks/test-enable-disable.js
index 64139408a48209..d408338e892c32 100644
--- a/test/async-hooks/test-enable-disable.js
+++ b/test/async-hooks/test-enable-disable.js
@@ -87,8 +87,9 @@ const assert = require('assert');
 const tick = require('../common/tick');
 const initHooks = require('./init-hooks');
 const { checkInvocations } = require('./hook-checks');
+const { isMainThread } = require('worker_threads');
 
-if (!common.isMainThread)
+if (!isMainThread)
   common.skip('Worker bootstrapping works differently -> different timing');
 
 // Include "Unknown"s because hook2 will not be able to identify
diff --git a/test/async-hooks/test-fseventwrap.js b/test/async-hooks/test-fseventwrap.js
index 12a439f8033cbc..a5e1a3b9d2f232 100644
--- a/test/async-hooks/test-fseventwrap.js
+++ b/test/async-hooks/test-fseventwrap.js
@@ -6,12 +6,15 @@ const initHooks = require('./init-hooks');
 const tick = require('../common/tick');
 const { checkInvocations } = require('./hook-checks');
 const fs = require('fs');
+const { isMainThread } = require('worker_threads');
 
-if (!common.isMainThread)
+if (!isMainThread) {
   common.skip('Worker bootstrapping works differently -> different async IDs');
+}
 
-if (common.isIBMi)
+if (common.isIBMi) {
   common.skip('IBMi does not support fs.watch()');
+}
 
 const hooks = initHooks();
 
diff --git a/test/async-hooks/test-fsreqcallback-readFile.js b/test/async-hooks/test-fsreqcallback-readFile.js
index 01ccce9b4cc694..65f3652f12f988 100644
--- a/test/async-hooks/test-fsreqcallback-readFile.js
+++ b/test/async-hooks/test-fsreqcallback-readFile.js
@@ -6,9 +6,11 @@ const tick = require('../common/tick');
 const initHooks = require('./init-hooks');
 const { checkInvocations } = require('./hook-checks');
 const fs = require('fs');
+const { isMainThread } = require('worker_threads');
 
-if (!common.isMainThread)
+if (!isMainThread) {
   common.skip('Worker bootstrapping works differently -> different async IDs');
+}
 
 const hooks = initHooks();
 
diff --git a/test/async-hooks/test-getaddrinforeqwrap.js b/test/async-hooks/test-getaddrinforeqwrap.js
index 7291ea8a301954..a21557bcd56e7a 100644
--- a/test/async-hooks/test-getaddrinforeqwrap.js
+++ b/test/async-hooks/test-getaddrinforeqwrap.js
@@ -6,9 +6,11 @@ const tick = require('../common/tick');
 const initHooks = require('./init-hooks');
 const { checkInvocations } = require('./hook-checks');
 const dns = require('dns');
+const { isMainThread } = require('worker_threads');
 
-if (!common.isMainThread)
+if (!isMainThread) {
   common.skip('Worker bootstrapping works differently -> different async IDs');
+}
 
 const hooks = initHooks();
 
diff --git a/test/async-hooks/test-getnameinforeqwrap.js b/test/async-hooks/test-getnameinforeqwrap.js
index c7a3937ff3ceef..b00fa0d4d9dd54 100644
--- a/test/async-hooks/test-getnameinforeqwrap.js
+++ b/test/async-hooks/test-getnameinforeqwrap.js
@@ -6,9 +6,11 @@ const tick = require('../common/tick');
 const initHooks = require('./init-hooks');
 const { checkInvocations } = require('./hook-checks');
 const dns = require('dns');
+const { isMainThread } = require('worker_threads');
 
-if (!common.isMainThread)
+if (!isMainThread) {
   common.skip('Worker bootstrapping works differently -> different async IDs');
+}
 
 const hooks = initHooks();
 
diff --git a/test/async-hooks/test-graph.signal.js b/test/async-hooks/test-graph.signal.js
index f87b1215b523b9..351fb7550af431 100644
--- a/test/async-hooks/test-graph.signal.js
+++ b/test/async-hooks/test-graph.signal.js
@@ -1,10 +1,13 @@
 'use strict';
 
 const common = require('../common');
-if (common.isWindows)
+if (common.isWindows) {
   common.skip('no signals on Windows');
-if (!common.isMainThread)
+}
+const { isMainThread } = require('worker_threads');
+if (!isMainThread) {
   common.skip('No signal handling available in Workers');
+}
 
 const initHooks = require('./init-hooks');
 const verifyGraph = require('./verify-graph');
diff --git a/test/async-hooks/test-no-assert-when-disabled.js b/test/async-hooks/test-no-assert-when-disabled.js
index 70114d1e1140f8..0e7c0568cc09fa 100644
--- a/test/async-hooks/test-no-assert-when-disabled.js
+++ b/test/async-hooks/test-no-assert-when-disabled.js
@@ -1,9 +1,10 @@
 'use strict';
 // Flags: --no-force-async-hooks-checks --expose-internals
 const common = require('../common');
-
-if (!common.isMainThread)
+const { isMainThread } = require('worker_threads');
+if (!isMainThread) {
   common.skip('Workers don\'t inherit per-env state like the check flag');
+}
 
 const async_hooks = require('internal/async_hooks');
 
diff --git a/test/async-hooks/test-pipewrap.js b/test/async-hooks/test-pipewrap.js
index 2d42e769cfd1f3..7ea5f38adc85e2 100644
--- a/test/async-hooks/test-pipewrap.js
+++ b/test/async-hooks/test-pipewrap.js
@@ -9,9 +9,11 @@ const tick = require('../common/tick');
 const initHooks = require('./init-hooks');
 const { checkInvocations } = require('./hook-checks');
 const { spawn } = require('child_process');
+const { isMainThread } = require('worker_threads');
 
-if (!common.isMainThread)
+if (!isMainThread) {
   common.skip('Worker bootstrapping works differently -> different async IDs');
+}
 
 const hooks = initHooks();
 
diff --git a/test/async-hooks/test-promise.chain-promise-before-init-hooks.js b/test/async-hooks/test-promise.chain-promise-before-init-hooks.js
index 52a312dbdfe196..c5e67b6f94ca68 100644
--- a/test/async-hooks/test-promise.chain-promise-before-init-hooks.js
+++ b/test/async-hooks/test-promise.chain-promise-before-init-hooks.js
@@ -4,9 +4,11 @@ const common = require('../common');
 const assert = require('assert');
 const initHooks = require('./init-hooks');
 const { checkInvocations } = require('./hook-checks');
+const { isMainThread } = require('worker_threads');
 
-if (!common.isMainThread)
+if (!isMainThread) {
   common.skip('Worker bootstrapping works differently -> different async IDs');
+}
 
 const p = new Promise(common.mustCall(function executor(resolve) {
   resolve(5);
diff --git a/test/async-hooks/test-promise.js b/test/async-hooks/test-promise.js
index 417cb3c80d6298..554c3ae7dd711e 100644
--- a/test/async-hooks/test-promise.js
+++ b/test/async-hooks/test-promise.js
@@ -5,9 +5,11 @@ const common = require('../common');
 const assert = require('assert');
 const initHooks = require('./init-hooks');
 const { checkInvocations } = require('./hook-checks');
+const { isMainThread } = require('worker_threads');
 
-if (!common.isMainThread)
+if (!isMainThread) {
   common.skip('Worker bootstrapping works differently -> different async IDs');
+}
 
 const hooks = initHooks();
 
diff --git a/test/async-hooks/test-signalwrap.js b/test/async-hooks/test-signalwrap.js
index 4584d140ce1d0f..60adaedd476f27 100644
--- a/test/async-hooks/test-signalwrap.js
+++ b/test/async-hooks/test-signalwrap.js
@@ -1,10 +1,13 @@
 'use strict';
 const common = require('../common');
 
-if (common.isWindows)
+if (common.isWindows) {
   common.skip('no signals in Windows');
-if (!common.isMainThread)
+}
+const { isMainThread } = require('worker_threads');
+if (!isMainThread) {
   common.skip('No signal handling available in Workers');
+}
 
 const assert = require('assert');
 const initHooks = require('./init-hooks');
diff --git a/test/async-hooks/test-statwatcher.js b/test/async-hooks/test-statwatcher.js
index f3c0e74355eeba..8f4fb2175885f3 100644
--- a/test/async-hooks/test-statwatcher.js
+++ b/test/async-hooks/test-statwatcher.js
@@ -7,8 +7,11 @@ const initHooks = require('./init-hooks');
 const { checkInvocations } = require('./hook-checks');
 const fs = require('fs');
 
-if (!common.isMainThread)
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
   common.skip('Worker bootstrapping works differently -> different async IDs');
+}
 
 tmpdir.refresh();
 
diff --git a/test/async-hooks/test-unhandled-rejection-context.js b/test/async-hooks/test-unhandled-rejection-context.js
index 8404cf71f0db6f..168b51a3331f7f 100644
--- a/test/async-hooks/test-unhandled-rejection-context.js
+++ b/test/async-hooks/test-unhandled-rejection-context.js
@@ -5,9 +5,11 @@ const common = require('../common');
 const assert = require('assert');
 const initHooks = require('./init-hooks');
 const async_hooks = require('async_hooks');
+const { isMainThread } = require('worker_threads');
 
-if (!common.isMainThread)
+if (!isMainThread) {
   common.skip('Worker bootstrapping works differently -> different async IDs');
+}
 
 const promiseAsyncIds = [];
 const hooks = initHooks({
diff --git a/test/benchmark/test-benchmark-napi.js b/test/benchmark/test-benchmark-napi.js
index 7164efe3d4e718..518e10a5111a5b 100644
--- a/test/benchmark/test-benchmark-napi.js
+++ b/test/benchmark/test-benchmark-napi.js
@@ -6,7 +6,9 @@ if (common.isWindows) {
   common.skip('vcbuild.bat doesn\'t build the n-api benchmarks yet');
 }
 
-if (!common.isMainThread) {
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
   common.skip('addons are not supported in workers');
 }
 
diff --git a/test/common/README.md b/test/common/README.md
index c3c44e32b3788c..887dee2783ad72 100644
--- a/test/common/README.md
+++ b/test/common/README.md
@@ -102,10 +102,6 @@ symlinks
 ([SeCreateSymbolicLinkPrivilege](https://msdn.microsoft.com/en-us/library/windows/desktop/bb530716\(v=vs.85\).aspx)).
 On non-Windows platforms, this always returns `true`.
 
-### `createZeroFilledFile(filename)`
-
-Creates a 10 MiB file of all null characters.
-
 ### `enoughTestMem`
 
 * [\<boolean>][<boolean>]
@@ -257,10 +253,6 @@ Platform check for Advanced Interactive eXecutive (AIX).
 
 Attempts to 'kill' `pid`
 
-### `isDumbTerminal`
-
-* [\<boolean>][<boolean>]
-
 ### `isFreeBSD`
 
 * [\<boolean>][<boolean>]
@@ -456,10 +448,6 @@ will not be run.
 
 Logs '1..0 # Skipped: ' + `msg` and exits with exit code `0`.
 
-### `skipIfDumbTerminal()`
-
-Skip the rest of the tests if the current terminal is a dumb terminal
-
 ### `skipIfEslintMissing()`
 
 Skip the rest of the tests in the current file when `ESLint` is not available
@@ -475,11 +463,6 @@ was disabled at compile time.
 Skip the rest of the tests in the current file when the Node.js executable
 was compiled with a pointer size smaller than 64 bits.
 
-### `skipIfWorker()`
-
-Skip the rest of the tests in the current file when not running on a main
-thread.
-
 ## ArrayStream module
 
 The `ArrayStream` module provides a simple `Stream` that pushes elements from
diff --git a/test/common/index.js b/test/common/index.js
index 238d66e96fe257..6086d584f0b595 100644
--- a/test/common/index.js
+++ b/test/common/index.js
@@ -139,8 +139,6 @@ const isPi = (() => {
   }
 })();
 
-const isDumbTerminal = process.env.TERM === 'dumb';
-
 // When using high concurrency or in the CI we need much more time for each connection attempt
 net.setDefaultAutoSelectFamilyAttemptTimeout(platformTimeout(net.getDefaultAutoSelectFamilyAttemptTimeout() * 10));
 const defaultAutoSelectFamilyAttemptTimeout = net.getDefaultAutoSelectFamilyAttemptTimeout();
@@ -243,13 +241,6 @@ function childShouldThrowAndAbort() {
   });
 }
 
-function createZeroFilledFile(filename) {
-  const fd = fs.openSync(filename, 'w');
-  fs.ftruncateSync(fd, 10 * 1024 * 1024);
-  fs.closeSync(fd);
-}
-
-
 const pwdCommand = isWindows ?
   ['cmd.exe', ['/d', '/c', 'cd']] :
   ['pwd', []];
@@ -716,12 +707,6 @@ function skipIf32Bits() {
   }
 }
 
-function skipIfWorker() {
-  if (!isMainThread) {
-    skip('This test only works on a main thread');
-  }
-}
-
 function getArrayBufferViews(buf) {
   const { buffer, byteOffset, byteLength } = buf;
 
@@ -806,12 +791,6 @@ function invalidArgTypeHelper(input) {
   return ` Received type ${typeof input} (${inspected})`;
 }
 
-function skipIfDumbTerminal() {
-  if (isDumbTerminal) {
-    skip('skipping - dumb terminal');
-  }
-}
-
 function requireNoPackageJSONAbove(dir = __dirname) {
   let possiblePackage = path.join(dir, '..', 'package.json');
   let lastPackage = null;
@@ -882,45 +861,6 @@ function escapePOSIXShell(cmdParts, ...args) {
   return [cmd, { env }];
 };
 
-function getPrintedStackTrace(stderr) {
-  const lines = stderr.split('\n');
-
-  let state = 'initial';
-  const result = {
-    message: [],
-    nativeStack: [],
-    jsStack: [],
-  };
-  for (let i = 0; i < lines.length; ++i) {
-    const line = lines[i].trim();
-    if (line.length === 0) {
-      continue;  // Skip empty lines.
-    }
-
-    switch (state) {
-      case 'initial':
-        result.message.push(line);
-        if (line.includes('Native stack trace')) {
-          state = 'native-stack';
-        } else {
-          result.message.push(line);
-        }
-        break;
-      case 'native-stack':
-        if (line.includes('JavaScript stack trace')) {
-          state = 'js-stack';
-        } else {
-          result.nativeStack.push(line);
-        }
-        break;
-      case 'js-stack':
-        result.jsStack.push(line);
-        break;
-    }
-  }
-  return result;
-}
-
 /**
  * Check the exports of require(esm).
  * TODO(joyeecheung): use it in all the test-require-module-* tests to minimize changes
@@ -943,7 +883,6 @@ const common = {
   buildType,
   canCreateSymLink,
   childShouldThrowAndAbort,
-  createZeroFilledFile,
   defaultAutoSelectFamilyAttemptTimeout,
   escapePOSIXShell,
   expectsError,
@@ -951,7 +890,6 @@ const common = {
   expectWarning,
   getArrayBufferViews,
   getBufferSources,
-  getPrintedStackTrace,
   getTTYfd,
   hasIntl,
   hasCrypto,
@@ -960,10 +898,8 @@ const common = {
   isAlive,
   isASan,
   isDebug,
-  isDumbTerminal,
   isFreeBSD,
   isLinux,
-  isMainThread,
   isOpenBSD,
   isMacOS,
   isPi,
@@ -985,10 +921,8 @@ const common = {
   runWithInvalidFD,
   skip,
   skipIf32Bits,
-  skipIfDumbTerminal,
   skipIfEslintMissing,
   skipIfInspectorDisabled,
-  skipIfWorker,
   spawnPromisified,
 
   get enoughTestMem() {
diff --git a/test/common/index.mjs b/test/common/index.mjs
index aafef1453bd78a..dd0adadcb28d38 100644
--- a/test/common/index.mjs
+++ b/test/common/index.mjs
@@ -8,7 +8,6 @@ const {
   buildType,
   canCreateSymLink,
   childShouldThrowAndAbort,
-  createZeroFilledFile,
   enoughTestMem,
   escapePOSIXShell,
   expectsError,
@@ -21,12 +20,10 @@ const {
   hasIPv6,
   isAIX,
   isAlive,
-  isDumbTerminal,
   isFreeBSD,
   isIBMi,
   isInsideDirWithUnusualChars,
   isLinux,
-  isMainThread,
   isOpenBSD,
   isMacOS,
   isSunOS,
@@ -45,7 +42,6 @@ const {
   runWithInvalidFD,
   skip,
   skipIf32Bits,
-  skipIfDumbTerminal,
   skipIfEslintMissing,
   skipIfInspectorDisabled,
   spawnPromisified,
@@ -59,7 +55,6 @@ export {
   canCreateSymLink,
   childShouldThrowAndAbort,
   createRequire,
-  createZeroFilledFile,
   enoughTestMem,
   escapePOSIXShell,
   expectsError,
@@ -73,12 +68,10 @@ export {
   hasIPv6,
   isAIX,
   isAlive,
-  isDumbTerminal,
   isFreeBSD,
   isIBMi,
   isInsideDirWithUnusualChars,
   isLinux,
-  isMainThread,
   isOpenBSD,
   isMacOS,
   isSunOS,
@@ -97,7 +90,6 @@ export {
   runWithInvalidFD,
   skip,
   skipIf32Bits,
-  skipIfDumbTerminal,
   skipIfEslintMissing,
   skipIfInspectorDisabled,
   spawnPromisified,
diff --git a/test/es-module/test-esm-resolve-type.mjs b/test/es-module/test-esm-resolve-type.mjs
index 22163bbd5defb8..9d97413379ad3c 100644
--- a/test/es-module/test-esm-resolve-type.mjs
+++ b/test/es-module/test-esm-resolve-type.mjs
@@ -13,8 +13,10 @@ import path from 'path';
 import fs from 'fs';
 import url from 'url';
 import process from 'process';
+import { isMainThread } from 'worker_threads';
 
-if (!common.isMainThread) {
+
+if (!isMainThread) {
   common.skip(
     'test-esm-resolve-type.mjs: process.chdir is not available in Workers'
   );
diff --git a/test/es-module/test-vm-main-context-default-loader.js b/test/es-module/test-vm-main-context-default-loader.js
index f9edc761465d96..bda954be6ebf97 100644
--- a/test/es-module/test-vm-main-context-default-loader.js
+++ b/test/es-module/test-vm-main-context-default-loader.js
@@ -3,7 +3,11 @@
 const common = require('../common');
 
 // Can't process.chdir() in worker.
-common.skipIfWorker();
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
 
 const tmpdir = require('../common/tmpdir');
 const fixtures = require('../common/fixtures');
diff --git a/test/fixtures/permission/fs-write.js b/test/fixtures/permission/fs-write.js
index 0c0ec72602041a..83fe3d234db290 100644
--- a/test/fixtures/permission/fs-write.js
+++ b/test/fixtures/permission/fs-write.js
@@ -1,7 +1,11 @@
 'use strict';
 
 const common = require('../../common');
-common.skipIfWorker();
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
 
 const assert = require('assert');
 const fs = require('fs');
@@ -553,4 +557,4 @@ const relativeProtectedFolder = process.env.RELATIVEBLOCKEDFOLDER;
   }, {
     code: 'ERR_ACCESS_DENIED',
   });
-}
\ No newline at end of file
+}
diff --git a/test/fixtures/permission/processbinding.js b/test/fixtures/permission/processbinding.js
index bdb958fb01b5ca..69e2fac5d7f151 100644
--- a/test/fixtures/permission/processbinding.js
+++ b/test/fixtures/permission/processbinding.js
@@ -1,5 +1,9 @@
 const common = require('../../common');
-common.skipIfWorker();
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
 
 const assert = require('assert');
 
diff --git a/test/internet/test-trace-events-dns.js b/test/internet/test-trace-events-dns.js
index c18a49bc9496c8..c5df4751374399 100644
--- a/test/internet/test-trace-events-dns.js
+++ b/test/internet/test-trace-events-dns.js
@@ -5,9 +5,11 @@ const cp = require('child_process');
 const tmpdir = require('../common/tmpdir');
 const fs = require('fs');
 const util = require('util');
+const { isMainThread } = require('worker_threads');
 
-if (!common.isMainThread)
+if (!isMainThread) {
   common.skip('process.chdir is not available in Workers');
+}
 
 const traceFile = 'node_trace.1.log';
 
diff --git a/test/parallel/test-async-hooks-disable-during-promise.js b/test/parallel/test-async-hooks-disable-during-promise.js
index 6b9b53bd30f0f5..a25dae51e1f82d 100644
--- a/test/parallel/test-async-hooks-disable-during-promise.js
+++ b/test/parallel/test-async-hooks-disable-during-promise.js
@@ -1,9 +1,11 @@
 'use strict';
 const common = require('../common');
 const async_hooks = require('async_hooks');
+const { isMainThread } = require('worker_threads');
 
-if (!common.isMainThread)
+if (!isMainThread) {
   common.skip('Worker bootstrapping works differently -> different AsyncWraps');
+}
 
 const hook = async_hooks.createHook({
   init: common.mustCall(2),
diff --git a/test/parallel/test-async-hooks-promise-triggerid.js b/test/parallel/test-async-hooks-promise-triggerid.js
index b860d60999e1ef..89e5bc1464f8d5 100644
--- a/test/parallel/test-async-hooks-promise-triggerid.js
+++ b/test/parallel/test-async-hooks-promise-triggerid.js
@@ -2,9 +2,11 @@
 const common = require('../common');
 const assert = require('assert');
 const async_hooks = require('async_hooks');
+const { isMainThread } = require('worker_threads');
 
-if (!common.isMainThread)
+if (!isMainThread) {
   common.skip('Worker bootstrapping works differently -> different async IDs');
+}
 
 const promiseAsyncIds = [];
 
diff --git a/test/parallel/test-async-hooks-promise.js b/test/parallel/test-async-hooks-promise.js
index 9db510e329ffad..74f72a188240a0 100644
--- a/test/parallel/test-async-hooks-promise.js
+++ b/test/parallel/test-async-hooks-promise.js
@@ -2,9 +2,11 @@
 const common = require('../common');
 const assert = require('assert');
 const async_hooks = require('async_hooks');
+const { isMainThread } = require('worker_threads');
 
-if (!common.isMainThread)
+if (!isMainThread) {
   common.skip('Worker bootstrapping works differently -> different async IDs');
+}
 
 const initCalls = [];
 const resolveCalls = [];
diff --git a/test/parallel/test-async-hooks-top-level-clearimmediate.js b/test/parallel/test-async-hooks-top-level-clearimmediate.js
index cc5fcf48eb50b3..fd91fefa9c4bce 100644
--- a/test/parallel/test-async-hooks-top-level-clearimmediate.js
+++ b/test/parallel/test-async-hooks-top-level-clearimmediate.js
@@ -5,9 +5,11 @@
 const common = require('../common');
 const assert = require('assert');
 const async_hooks = require('async_hooks');
+const { isMainThread } = require('worker_threads');
 
-if (!common.isMainThread)
+if (!isMainThread) {
   common.skip('Worker bootstrapping works differently -> different async IDs');
+}
 
 let seenId, seenResource;
 
diff --git a/test/parallel/test-async-wrap-promise-after-enabled.js b/test/parallel/test-async-wrap-promise-after-enabled.js
index 0d58cbd653868b..cbca873574c1f8 100644
--- a/test/parallel/test-async-wrap-promise-after-enabled.js
+++ b/test/parallel/test-async-wrap-promise-after-enabled.js
@@ -4,9 +4,11 @@
 
 const common = require('../common');
 const assert = require('assert');
+const { isMainThread } = require('worker_threads');
 
-if (!common.isMainThread)
+if (!isMainThread) {
   common.skip('Worker bootstrapping works differently -> different timing');
+}
 
 const async_hooks = require('async_hooks');
 
diff --git a/test/parallel/test-bootstrap-modules.js b/test/parallel/test-bootstrap-modules.js
index c75ee390dcd195..ebcd2a6d6c12b2 100644
--- a/test/parallel/test-bootstrap-modules.js
+++ b/test/parallel/test-bootstrap-modules.js
@@ -115,7 +115,9 @@ expected.atRunTime = new Set([
   'NativeModule internal/modules/esm/utils',
 ]);
 
-if (common.isMainThread) {
+const { isMainThread } = require('worker_threads');
+
+if (isMainThread) {
   [
     'NativeModule url',
   ].forEach(expected.beforePreExec.add.bind(expected.beforePreExec));
@@ -186,7 +188,7 @@ function err(message) {
   }
 }
 
-if (common.isMainThread) {
+if (isMainThread) {
   const missing = expected.beforePreExec.difference(actual.beforePreExec);
   const extra = actual.beforePreExec.difference(expected.beforePreExec);
   if (missing.size !== 0) {
@@ -212,10 +214,10 @@ if (common.isMainThread) {
   }
 }
 
-if (!common.isMainThread) {
+if (!isMainThread) {
   // For workers, just merge beforePreExec into atRunTime for now.
   // When we start adding modules to the worker snapshot, this branch
-  // can be removed and  we can just remove the common.isMainThread
+  // can be removed and  we can just remove the isMainThread
   // conditions.
   expected.beforePreExec.forEach(expected.atRunTime.add.bind(expected.atRunTime));
   actual.beforePreExec.forEach(actual.atRunTime.add.bind(actual.atRunTime));
diff --git a/test/parallel/test-child-process-validate-stdio.js b/test/parallel/test-child-process-validate-stdio.js
index d5958c694ff6ff..5ba6f0fd123cc1 100644
--- a/test/parallel/test-child-process-validate-stdio.js
+++ b/test/parallel/test-child-process-validate-stdio.js
@@ -43,7 +43,9 @@ assert.throws(() => getValidStdio(stdio2, true),
   assert.throws(() => getValidStdio(stdio), expectedError);
 }
 
-if (common.isMainThread) {
+const { isMainThread } = require('worker_threads');
+
+if (isMainThread) {
   const stdio3 = [process.stdin, process.stdout, process.stderr];
   const result = getValidStdio(stdio3, false);
   assert.deepStrictEqual(result, {
diff --git a/test/parallel/test-cluster-net-listen-relative-path.js b/test/parallel/test-cluster-net-listen-relative-path.js
index bb4d0b90f203e6..16d2bf5c836b53 100644
--- a/test/parallel/test-cluster-net-listen-relative-path.js
+++ b/test/parallel/test-cluster-net-listen-relative-path.js
@@ -1,11 +1,16 @@
 'use strict';
 const common = require('../common');
 
-if (common.isWindows)
+if (common.isWindows) {
   common.skip('On Windows named pipes live in their own ' +
               'filesystem and don\'t have a ~100 byte limit');
-if (!common.isMainThread)
+}
+
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
   common.skip('process.chdir is not available in Workers');
+}
 
 const assert = require('assert');
 const cluster = require('cluster');
diff --git a/test/parallel/test-code-cache.js b/test/parallel/test-code-cache.js
index 1c768d664c8a18..576f713af1b02a 100644
--- a/test/parallel/test-code-cache.js
+++ b/test/parallel/test-code-cache.js
@@ -5,7 +5,8 @@
 // and the cache is used when built in modules are compiled.
 // Otherwise, verifies that no cache is used when compiling builtins.
 
-const { isMainThread } = require('../common');
+require('../common');
+const { isMainThread } = require('worker_threads');
 const assert = require('assert');
 const {
   internalBinding
diff --git a/test/parallel/test-console-clear.js b/test/parallel/test-console-clear.js
index 5975602547922a..8ded51595f654e 100644
--- a/test/parallel/test-console-clear.js
+++ b/test/parallel/test-console-clear.js
@@ -1,6 +1,6 @@
 'use strict';
 
-const common = require('../common');
+require('../common');
 const assert = require('assert');
 
 const stdoutWrite = process.stdout.write;
@@ -18,7 +18,7 @@ function doTest(isTTY, check) {
 }
 
 // Fake TTY
-if (!common.isDumbTerminal) {
+if (process.env.TERM !== 'dumb') {
   doTest(true, check);
 }
 doTest(false, '');
diff --git a/test/parallel/test-console.js b/test/parallel/test-console.js
index 5dd029a6e904cc..bc08ba395e787e 100644
--- a/test/parallel/test-console.js
+++ b/test/parallel/test-console.js
@@ -31,10 +31,12 @@ const {
   restoreStderr
 } = require('../common/hijackstdio');
 
+const { isMainThread } = require('worker_threads');
+
 assert.ok(process.stdout.writable);
 assert.ok(process.stderr.writable);
 // Support legacy API
-if (common.isMainThread) {
+if (isMainThread) {
   assert.strictEqual(typeof process.stdout.fd, 'number');
   assert.strictEqual(typeof process.stderr.fd, 'number');
 }
diff --git a/test/parallel/test-crypto-no-algorithm.js b/test/parallel/test-crypto-no-algorithm.js
index 06124e3d465e41..bb5b81e119c87d 100644
--- a/test/parallel/test-crypto-no-algorithm.js
+++ b/test/parallel/test-crypto-no-algorithm.js
@@ -11,8 +11,9 @@ if (!hasOpenSSL3)
 
 const assert = require('node:assert/strict');
 const crypto = require('node:crypto');
+const { isMainThread } = require('worker_threads');
 
-if (common.isMainThread) {
+if (isMainThread) {
   // TODO(richardlau): Decide if `crypto.setFips` should error if the
   // provider named "fips" is not available.
   crypto.setFips(1);
diff --git a/test/parallel/test-cwd-enoent-preload.js b/test/parallel/test-cwd-enoent-preload.js
index 21b20d6d035672..a7841e984d0eab 100644
--- a/test/parallel/test-cwd-enoent-preload.js
+++ b/test/parallel/test-cwd-enoent-preload.js
@@ -1,10 +1,15 @@
 'use strict';
 const common = require('../common');
 // Fails with EINVAL on SmartOS, EBUSY on Windows, EBUSY on AIX.
-if (common.isSunOS || common.isWindows || common.isAIX || common.isIBMi)
+if (common.isSunOS || common.isWindows || common.isAIX || common.isIBMi) {
   common.skip('cannot rmdir current working directory');
-if (!common.isMainThread)
+}
+
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
   common.skip('process.chdir is not available in Workers');
+}
 
 const assert = require('assert');
 const fs = require('fs');
diff --git a/test/parallel/test-cwd-enoent-repl.js b/test/parallel/test-cwd-enoent-repl.js
index 0a61cbfbced9b4..fcb08c004f345c 100644
--- a/test/parallel/test-cwd-enoent-repl.js
+++ b/test/parallel/test-cwd-enoent-repl.js
@@ -1,10 +1,15 @@
 'use strict';
 const common = require('../common');
 // Fails with EINVAL on SmartOS, EBUSY on Windows, EBUSY on AIX.
-if (common.isSunOS || common.isWindows || common.isAIX || common.isIBMi)
+if (common.isSunOS || common.isWindows || common.isAIX || common.isIBMi) {
   common.skip('cannot rmdir current working directory');
-if (!common.isMainThread)
+}
+
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
   common.skip('process.chdir is not available in Workers');
+}
 
 const assert = require('assert');
 const fs = require('fs');
diff --git a/test/parallel/test-cwd-enoent.js b/test/parallel/test-cwd-enoent.js
index 876888bc2be518..ca8b460835d45a 100644
--- a/test/parallel/test-cwd-enoent.js
+++ b/test/parallel/test-cwd-enoent.js
@@ -1,10 +1,15 @@
 'use strict';
 const common = require('../common');
 // Fails with EINVAL on SmartOS, EBUSY on Windows, EBUSY on AIX.
-if (common.isSunOS || common.isWindows || common.isAIX || common.isIBMi)
+if (common.isSunOS || common.isWindows || common.isAIX || common.isIBMi) {
   common.skip('cannot rmdir current working directory');
-if (!common.isMainThread)
+}
+
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
   common.skip('process.chdir is not available in Workers');
+}
 
 const assert = require('assert');
 const fs = require('fs');
diff --git a/test/parallel/test-fs-mkdir.js b/test/parallel/test-fs-mkdir.js
index 89b8b436d5c9f4..f7685c7de0a962 100644
--- a/test/parallel/test-fs-mkdir.js
+++ b/test/parallel/test-fs-mkdir.js
@@ -24,6 +24,7 @@ const common = require('../common');
 const assert = require('assert');
 const fs = require('fs');
 const path = require('path');
+const { isMainThread } = require('worker_threads');
 
 const tmpdir = require('../common/tmpdir');
 tmpdir.refresh();
@@ -217,7 +218,7 @@ function nextdir() {
 
 // mkdirpSync dirname loop
 // XXX: windows and smartos have issues removing a directory that you're in.
-if (common.isMainThread && (common.isLinux || common.isMacOS)) {
+if (isMainThread && (common.isLinux || common.isMacOS)) {
   const pathname = tmpdir.resolve(nextdir());
   fs.mkdirSync(pathname);
   process.chdir(pathname);
diff --git a/test/parallel/test-fs-realpath.js b/test/parallel/test-fs-realpath.js
index d944195de3de0c..69237e3974e5b0 100644
--- a/test/parallel/test-fs-realpath.js
+++ b/test/parallel/test-fs-realpath.js
@@ -23,9 +23,11 @@
 const common = require('../common');
 const fixtures = require('../common/fixtures');
 const tmpdir = require('../common/tmpdir');
+const { isMainThread } = require('worker_threads');
 
-if (!common.isMainThread)
+if (!isMainThread) {
   common.skip('process.chdir is not available in Workers');
+}
 
 const assert = require('assert');
 const fs = require('fs');
diff --git a/test/parallel/test-fs-whatwg-url.js b/test/parallel/test-fs-whatwg-url.js
index 7401ed7e76ecd1..2d5664cd12015c 100644
--- a/test/parallel/test-fs-whatwg-url.js
+++ b/test/parallel/test-fs-whatwg-url.js
@@ -5,6 +5,8 @@ const fixtures = require('../common/fixtures');
 const assert = require('assert');
 const fs = require('fs');
 const tmpdir = require('../common/tmpdir');
+const { isMainThread } = require('worker_threads');
+
 tmpdir.refresh();
 
 const url = fixtures.fileURL('a.js');
@@ -86,7 +88,7 @@ if (common.isWindows) {
 // Test that strings are interpreted as paths and not as URL
 // Can't use process.chdir in Workers
 // Please avoid testing fs.rmdir('file:') or using it as cleanup
-if (common.isMainThread && !common.isWindows) {
+if (isMainThread && !common.isWindows) {
   const oldCwd = process.cwd();
   process.chdir(tmpdir.path);
 
diff --git a/test/parallel/test-fs-write-file-sync.js b/test/parallel/test-fs-write-file-sync.js
index 4ead91530bb748..e5fbe32eab6d14 100644
--- a/test/parallel/test-fs-write-file-sync.js
+++ b/test/parallel/test-fs-write-file-sync.js
@@ -21,9 +21,11 @@
 
 'use strict';
 const common = require('../common');
+const { isMainThread } = require('worker_threads');
 
-if (!common.isMainThread)
+if (!isMainThread) {
   common.skip('Setting process.umask is not supported in Workers');
+}
 
 const assert = require('assert');
 const fs = require('fs');
diff --git a/test/parallel/test-http-chunk-problem.js b/test/parallel/test-http-chunk-problem.js
index 3629b7576600e8..90c54b8f5c7dcb 100644
--- a/test/parallel/test-http-chunk-problem.js
+++ b/test/parallel/test-http-chunk-problem.js
@@ -1,9 +1,12 @@
 'use strict';
 // http://groups.google.com/group/nodejs/browse_thread/thread/f66cd3c960406919
 const common = require('../common');
-if (!common.hasCrypto)
+
+if (!common.hasCrypto) {
   common.skip('missing crypto');
+}
 
+const fs = require('fs');
 const assert = require('assert');
 
 if (process.argv[2] === 'request') {
@@ -73,7 +76,11 @@ function executeRequest(cb) {
 
 tmpdir.refresh();
 
-common.createZeroFilledFile(filename);
+
+// Create a zero-filled file.
+const fd = fs.openSync(filename, 'w');
+fs.ftruncateSync(fd, 10 * 1024 * 1024);
+fs.closeSync(fd);
 
 server = http.createServer(function(req, res) {
   res.writeHead(200);
diff --git a/test/parallel/test-icu-env.js b/test/parallel/test-icu-env.js
index afa36132f60e8d..26075a3d0acec2 100644
--- a/test/parallel/test-icu-env.js
+++ b/test/parallel/test-icu-env.js
@@ -4,7 +4,7 @@ const assert = require('assert');
 const { execFileSync } = require('child_process');
 const { readFileSync, globSync } = require('fs');
 const { path } = require('../common/fixtures');
-
+const { isMainThread } = require('worker_threads');
 
 // This test checks for regressions in environment variable handling and
 // caching, but the localization data originated from ICU might change
@@ -169,7 +169,7 @@ if (isMockable) {
 // Tests with process.env mutated inside
 {
   // process.env.TZ is not intercepted in Workers
-  if (common.isMainThread) {
+  if (isMainThread) {
     assert.strictEqual(
       isSet(zones.map((TZ) => runEnvInside({ TZ }, () => new Date(333333333333).toString()))),
       true
diff --git a/test/parallel/test-inspector-already-activated-cli.js b/test/parallel/test-inspector-already-activated-cli.js
index ba76d5168c14b9..9de226cedca60c 100644
--- a/test/parallel/test-inspector-already-activated-cli.js
+++ b/test/parallel/test-inspector-already-activated-cli.js
@@ -3,7 +3,12 @@
 
 const common = require('../common');
 common.skipIfInspectorDisabled();
-common.skipIfWorker();
+
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
 
 const assert = require('assert');
 const inspector = require('inspector');
diff --git a/test/parallel/test-inspector-async-hook-after-done.js b/test/parallel/test-inspector-async-hook-after-done.js
index 9f96fdb7b0da84..b49fe32982e132 100644
--- a/test/parallel/test-inspector-async-hook-after-done.js
+++ b/test/parallel/test-inspector-async-hook-after-done.js
@@ -3,7 +3,12 @@
 const common = require('../common');
 
 common.skipIfInspectorDisabled();
-common.skipIfWorker();
+
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
 
 const assert = require('assert');
 const { Worker } = require('worker_threads');
diff --git a/test/parallel/test-inspector-async-hook-setup-at-signal.js b/test/parallel/test-inspector-async-hook-setup-at-signal.js
index 43f50d00615723..64a3835e415746 100644
--- a/test/parallel/test-inspector-async-hook-setup-at-signal.js
+++ b/test/parallel/test-inspector-async-hook-setup-at-signal.js
@@ -6,7 +6,11 @@ common.skipIf32Bits();
 const { NodeInstance } = require('../common/inspector-helper.js');
 const assert = require('assert');
 
-common.skipIfWorker(); // Signal starts a server for a main thread inspector
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
 
 const script = `
 process._rawDebug('Waiting until a signal enables the inspector...');
diff --git a/test/parallel/test-inspector-connect-main-thread.js b/test/parallel/test-inspector-connect-main-thread.js
index b724bf3cd9d62f..2281b5efcf3ed8 100644
--- a/test/parallel/test-inspector-connect-main-thread.js
+++ b/test/parallel/test-inspector-connect-main-thread.js
@@ -10,8 +10,8 @@ const { pathToFileURL } = require('url');
 const { isMainThread, parentPort, Worker, workerData } =
   require('worker_threads');
 
-if (!workerData) {
-  common.skipIfWorker();
+if (!workerData && !isMainThread) {
+  common.skip('This test only works on a main thread');
 }
 
 function toDebug() {
diff --git a/test/parallel/test-inspector-connect-to-main-thread.js b/test/parallel/test-inspector-connect-to-main-thread.js
index 7254145a2733f0..9244a85f21b15a 100644
--- a/test/parallel/test-inspector-connect-to-main-thread.js
+++ b/test/parallel/test-inspector-connect-to-main-thread.js
@@ -6,8 +6,8 @@ common.skipIfInspectorDisabled();
 const { Session } = require('inspector');
 const { Worker, isMainThread, workerData } = require('worker_threads');
 
-if (!workerData) {
-  common.skipIfWorker();
+if (!workerData && !isMainThread) {
+  common.skip('This test only works on a main thread');
 }
 
 if (isMainThread) {
diff --git a/test/parallel/test-inspector-contexts.js b/test/parallel/test-inspector-contexts.js
index 3d6ee4d460e863..9ab2c515b4a9de 100644
--- a/test/parallel/test-inspector-contexts.js
+++ b/test/parallel/test-inspector-contexts.js
@@ -9,6 +9,8 @@ const assert = require('assert');
 const vm = require('vm');
 const { Session } = require('inspector');
 const { gcUntil } = require('../common/gc');
+const { isMainThread } = require('worker_threads');
+
 const session = new Session();
 session.connect();
 
@@ -34,7 +36,7 @@ async function testContextCreatedAndDestroyed() {
       assert.strictEqual(name.includes(`[${process.pid}]`), true);
     } else {
       let expects = `${process.argv0}[${process.pid}]`;
-      if (!common.isMainThread) {
+      if (!isMainThread) {
         expects = `Worker[${require('worker_threads').threadId}]`;
       }
       assert.strictEqual(expects, name);
diff --git a/test/parallel/test-inspector-exit-worker-in-wait-for-connection.js b/test/parallel/test-inspector-exit-worker-in-wait-for-connection.js
index 4fcbb092fd23cf..9215d4969fb92f 100644
--- a/test/parallel/test-inspector-exit-worker-in-wait-for-connection.js
+++ b/test/parallel/test-inspector-exit-worker-in-wait-for-connection.js
@@ -3,9 +3,15 @@
 const common = require('../common');
 common.skipIfInspectorDisabled();
 
-const { parentPort, workerData, Worker } = require('node:worker_threads');
-if (!workerData) {
-  common.skipIfWorker();
+const {
+  isMainThread,
+  parentPort,
+  workerData,
+  Worker,
+} = require('node:worker_threads');
+
+if (!workerData && !isMainThread) {
+  common.skip('This test only works on a main thread');
 }
 
 const inspector = require('node:inspector');
diff --git a/test/parallel/test-inspector-exit-worker-in-wait-for-connection2.js b/test/parallel/test-inspector-exit-worker-in-wait-for-connection2.js
index fb13fc3f969304..cf485ae3a4318f 100644
--- a/test/parallel/test-inspector-exit-worker-in-wait-for-connection2.js
+++ b/test/parallel/test-inspector-exit-worker-in-wait-for-connection2.js
@@ -3,9 +3,9 @@
 const common = require('../common');
 common.skipIfInspectorDisabled();
 
-const { workerData, Worker } = require('node:worker_threads');
-if (!workerData) {
-  common.skipIfWorker();
+const { isMainThread, workerData, Worker } = require('node:worker_threads');
+if (!workerData && !isMainThread) {
+  common.skip('This test only works on a main thread');
 }
 
 const assert = require('node:assert');
diff --git a/test/parallel/test-inspector-open-coverage.js b/test/parallel/test-inspector-open-coverage.js
index 259049c36822ab..33f50bfc3f53c4 100644
--- a/test/parallel/test-inspector-open-coverage.js
+++ b/test/parallel/test-inspector-open-coverage.js
@@ -7,7 +7,12 @@ const fixtures = require('../common/fixtures');
 const tmpdir = require('../common/tmpdir');
 
 common.skipIfInspectorDisabled();
-common.skipIfWorker();
+
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
 
 tmpdir.refresh();
 
diff --git a/test/parallel/test-inspector-open-port-integer-overflow.js b/test/parallel/test-inspector-open-port-integer-overflow.js
index 0f9a4799d0642a..a1b5c640c4c18d 100644
--- a/test/parallel/test-inspector-open-port-integer-overflow.js
+++ b/test/parallel/test-inspector-open-port-integer-overflow.js
@@ -5,7 +5,12 @@
 
 const common = require('../common');
 common.skipIfInspectorDisabled();
-common.skipIfWorker();
+
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
 
 const assert = require('assert');
 const inspector = require('inspector');
diff --git a/test/parallel/test-inspector-overwrite-config.js b/test/parallel/test-inspector-overwrite-config.js
index c20df083256120..53599b31df8acc 100644
--- a/test/parallel/test-inspector-overwrite-config.js
+++ b/test/parallel/test-inspector-overwrite-config.js
@@ -13,9 +13,11 @@
 
 const common = require('../common');
 const assert = require('assert');
+const { isMainThread } = require('worker_threads');
 
-if (!common.isMainThread)
+if (!isMainThread) {
   common.skip('--require does not work with Workers');
+}
 
 const inspector = require('inspector');
 const msg = 'Test inspector logging';
diff --git a/test/parallel/test-inspector-port-zero-cluster.js b/test/parallel/test-inspector-port-zero-cluster.js
index 8e2db0b69d5ca0..5ee7bcf7417345 100644
--- a/test/parallel/test-inspector-port-zero-cluster.js
+++ b/test/parallel/test-inspector-port-zero-cluster.js
@@ -3,7 +3,12 @@
 const common = require('../common');
 
 common.skipIfInspectorDisabled();
-common.skipIfWorker();
+
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
 
 // Assert that even when started with `--inspect=0` workers are assigned
 // consecutive (i.e. deterministically predictable) debug ports
diff --git a/test/parallel/test-inspector-tracing-domain.js b/test/parallel/test-inspector-tracing-domain.js
index f5ac6875a0f643..aa31d63a01577d 100644
--- a/test/parallel/test-inspector-tracing-domain.js
+++ b/test/parallel/test-inspector-tracing-domain.js
@@ -3,7 +3,13 @@
 const common = require('../common');
 
 common.skipIfInspectorDisabled();
-common.skipIfWorker(); // https://github.com/nodejs/node/issues/22767
+
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  // https://github.com/nodejs/node/issues/22767
+  common.skip('This test only works on a main thread');
+}
 
 const assert = require('assert');
 const { Session } = require('inspector');
diff --git a/test/parallel/test-inspector-workers-flat-list.js b/test/parallel/test-inspector-workers-flat-list.js
index 9f6495d10fb147..a7b57fbb0a353b 100644
--- a/test/parallel/test-inspector-workers-flat-list.js
+++ b/test/parallel/test-inspector-workers-flat-list.js
@@ -6,8 +6,8 @@ common.skipIfInspectorDisabled();
 const { Worker, isMainThread, parentPort, workerData } =
   require('worker_threads');
 
-if (isMainThread || workerData !== 'launched by test') {
-  common.skipIfWorker();
+if (!isMainThread || workerData !== 'launched by test') {
+  common.skip('This test only works on a main thread');
 }
 
 const { Session } = require('inspector');
diff --git a/test/parallel/test-internal-module-require.js b/test/parallel/test-internal-module-require.js
index 058273c7ea4304..213838150b96d9 100644
--- a/test/parallel/test-internal-module-require.js
+++ b/test/parallel/test-internal-module-require.js
@@ -8,8 +8,9 @@
 // 3. Deprecated modules are properly deprecated.
 
 const common = require('../common');
+const { isMainThread } = require('worker_threads');
 
-if (!common.isMainThread) {
+if (!isMainThread) {
   common.skip('Cannot test the existence of --expose-internals from worker');
 }
 
diff --git a/test/parallel/test-performance-nodetiming-uvmetricsinfo.js b/test/parallel/test-performance-nodetiming-uvmetricsinfo.js
index 3d32e0deb72e94..b67682b0ff3559 100644
--- a/test/parallel/test-performance-nodetiming-uvmetricsinfo.js
+++ b/test/parallel/test-performance-nodetiming-uvmetricsinfo.js
@@ -1,7 +1,11 @@
 'use strict';
 
 const common = require('../common');
-common.skipIfWorker();
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
 
 const { spawnSync } = require('node:child_process');
 const assert = require('node:assert');
diff --git a/test/parallel/test-permission-allow-addons-cli.js b/test/parallel/test-permission-allow-addons-cli.js
index 484f16e0acb3b5..342bdb6bc01e35 100644
--- a/test/parallel/test-permission-allow-addons-cli.js
+++ b/test/parallel/test-permission-allow-addons-cli.js
@@ -2,7 +2,11 @@
 'use strict';
 
 const common = require('../common');
-common.skipIfWorker();
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
 
 const { createRequire } = require('node:module');
 const assert = require('node:assert');
diff --git a/test/parallel/test-permission-allow-child-process-cli.js b/test/parallel/test-permission-allow-child-process-cli.js
index 794f55ecf9a68c..cf7e79e208d389 100644
--- a/test/parallel/test-permission-allow-child-process-cli.js
+++ b/test/parallel/test-permission-allow-child-process-cli.js
@@ -2,7 +2,13 @@
 'use strict';
 
 const common = require('../common');
-common.skipIfWorker();
+
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
+
 const assert = require('assert');
 const childProcess = require('child_process');
 const fs = require('fs');
diff --git a/test/parallel/test-permission-allow-wasi-cli.js b/test/parallel/test-permission-allow-wasi-cli.js
index c6bea9fb39cf0a..20aca9292533d5 100644
--- a/test/parallel/test-permission-allow-wasi-cli.js
+++ b/test/parallel/test-permission-allow-wasi-cli.js
@@ -2,7 +2,11 @@
 'use strict';
 
 const common = require('../common');
-common.skipIfWorker();
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
 
 const assert = require('assert');
 const { WASI } = require('wasi');
diff --git a/test/parallel/test-permission-child-process-cli.js b/test/parallel/test-permission-child-process-cli.js
index dfea008a60407b..7d8fbf0564d5ef 100644
--- a/test/parallel/test-permission-child-process-cli.js
+++ b/test/parallel/test-permission-child-process-cli.js
@@ -2,7 +2,12 @@
 'use strict';
 
 const common = require('../common');
-common.skipIfWorker();
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
+
 const assert = require('assert');
 const childProcess = require('child_process');
 
diff --git a/test/parallel/test-permission-fs-absolute-path.js b/test/parallel/test-permission-fs-absolute-path.js
index 2c2257052c8b02..c3bf9ef5cfb2d1 100644
--- a/test/parallel/test-permission-fs-absolute-path.js
+++ b/test/parallel/test-permission-fs-absolute-path.js
@@ -3,7 +3,11 @@
 
 const common = require('../common');
 const path = require('path');
-common.skipIfWorker();
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
 
 const assert = require('assert');
 const { spawnSync } = require('child_process');
diff --git a/test/parallel/test-permission-fs-internal-module-stat.js b/test/parallel/test-permission-fs-internal-module-stat.js
index fd0222cc34fa2e..ef99e4cca73a4f 100644
--- a/test/parallel/test-permission-fs-internal-module-stat.js
+++ b/test/parallel/test-permission-fs-internal-module-stat.js
@@ -2,7 +2,11 @@
 'use strict';
 
 const common = require('../common');
-common.skipIfWorker();
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
 
 if (!common.hasCrypto) {
   common.skip('no crypto');
diff --git a/test/parallel/test-permission-fs-read.js b/test/parallel/test-permission-fs-read.js
index ed8e866a6a4c10..b719207bdbd820 100644
--- a/test/parallel/test-permission-fs-read.js
+++ b/test/parallel/test-permission-fs-read.js
@@ -2,7 +2,11 @@
 'use strict';
 
 const common = require('../common');
-common.skipIfWorker();
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
 
 if (!common.hasCrypto) {
   common.skip('no crypto');
diff --git a/test/parallel/test-permission-fs-relative-path.js b/test/parallel/test-permission-fs-relative-path.js
index 3b115ee35d1227..9f4ce25f0f7d37 100644
--- a/test/parallel/test-permission-fs-relative-path.js
+++ b/test/parallel/test-permission-fs-relative-path.js
@@ -2,7 +2,11 @@
 'use strict';
 
 const common = require('../common');
-common.skipIfWorker();
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
 
 const assert = require('assert');
 const { spawnSync } = require('child_process');
diff --git a/test/parallel/test-permission-fs-repeat-path.js b/test/parallel/test-permission-fs-repeat-path.js
index 764c7d91497248..d24197e905063d 100644
--- a/test/parallel/test-permission-fs-repeat-path.js
+++ b/test/parallel/test-permission-fs-repeat-path.js
@@ -3,7 +3,11 @@
 
 const common = require('../common');
 const path = require('path');
-common.skipIfWorker();
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
 
 const assert = require('assert');
 const { spawnSync } = require('child_process');
diff --git a/test/parallel/test-permission-fs-require.js b/test/parallel/test-permission-fs-require.js
index 5d3a407708371e..8406f9ec052eae 100644
--- a/test/parallel/test-permission-fs-require.js
+++ b/test/parallel/test-permission-fs-require.js
@@ -2,7 +2,13 @@
 'use strict';
 
 const common = require('../common');
-common.skipIfWorker();
+
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
+
 const fixtures = require('../common/fixtures');
 
 const assert = require('node:assert');
diff --git a/test/parallel/test-permission-fs-symlink-relative.js b/test/parallel/test-permission-fs-symlink-relative.js
index cf9b37ea79b059..e1fe5d064a8756 100644
--- a/test/parallel/test-permission-fs-symlink-relative.js
+++ b/test/parallel/test-permission-fs-symlink-relative.js
@@ -2,7 +2,12 @@
 'use strict';
 
 const common = require('../common');
-common.skipIfWorker();
+
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
 
 const assert = require('assert');
 const path = require('path');
diff --git a/test/parallel/test-permission-fs-symlink-target-write.js b/test/parallel/test-permission-fs-symlink-target-write.js
index f55b19fa764a89..1cffead4dd7e71 100644
--- a/test/parallel/test-permission-fs-symlink-target-write.js
+++ b/test/parallel/test-permission-fs-symlink-target-write.js
@@ -2,11 +2,19 @@
 'use strict';
 
 const common = require('../common');
-common.skipIfWorker();
-if (!common.canCreateSymLink())
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
+
+if (!common.canCreateSymLink()) {
   common.skip('insufficient privileges');
-if (!common.hasCrypto)
+}
+
+if (!common.hasCrypto) {
   common.skip('no crypto');
+}
 
 const assert = require('assert');
 const fs = require('fs');
@@ -15,9 +23,7 @@ const tmpdir = require('../common/tmpdir');
 const fixtures = require('../common/fixtures');
 const { spawnSync } = require('child_process');
 
-{
-  tmpdir.refresh();
-}
+tmpdir.refresh();
 
 const readOnlyFolder = tmpdir.resolve('read-only');
 const readWriteFolder = tmpdir.resolve('read-write');
diff --git a/test/parallel/test-permission-fs-symlink.js b/test/parallel/test-permission-fs-symlink.js
index 92965c960177d4..e5a80dba44ddf4 100644
--- a/test/parallel/test-permission-fs-symlink.js
+++ b/test/parallel/test-permission-fs-symlink.js
@@ -2,13 +2,19 @@
 'use strict';
 
 const common = require('../common');
-common.skipIfWorker();
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
 
 const fixtures = require('../common/fixtures');
-if (!common.canCreateSymLink())
+if (!common.canCreateSymLink()) {
   common.skip('insufficient privileges');
-if (!common.hasCrypto)
+}
+if (!common.hasCrypto) {
   common.skip('no crypto');
+}
 
 const assert = require('assert');
 const fs = require('fs');
diff --git a/test/parallel/test-permission-fs-traversal-path.js b/test/parallel/test-permission-fs-traversal-path.js
index 03571c2d01c861..ed9e434b6b862b 100644
--- a/test/parallel/test-permission-fs-traversal-path.js
+++ b/test/parallel/test-permission-fs-traversal-path.js
@@ -2,13 +2,20 @@
 'use strict';
 
 const common = require('../common');
-common.skipIfWorker();
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
 
 const fixtures = require('../common/fixtures');
-if (!common.canCreateSymLink())
+if (!common.canCreateSymLink()) {
   common.skip('insufficient privileges');
-if (!common.hasCrypto)
+}
+
+if (!common.hasCrypto) {
   common.skip('no crypto');
+}
 
 const assert = require('assert');
 const fs = require('fs');
diff --git a/test/parallel/test-permission-fs-wildcard.js b/test/parallel/test-permission-fs-wildcard.js
index adca56ed0dba6d..1b67f37c2dcda2 100644
--- a/test/parallel/test-permission-fs-wildcard.js
+++ b/test/parallel/test-permission-fs-wildcard.js
@@ -2,7 +2,11 @@
 'use strict';
 
 const common = require('../common');
-common.skipIfWorker();
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
 
 const assert = require('assert');
 const path = require('path');
diff --git a/test/parallel/test-permission-fs-windows-path.js b/test/parallel/test-permission-fs-windows-path.js
index 6869b347cf283f..c3b3683b6479f7 100644
--- a/test/parallel/test-permission-fs-windows-path.js
+++ b/test/parallel/test-permission-fs-windows-path.js
@@ -2,7 +2,11 @@
 'use strict';
 
 const common = require('../common');
-common.skipIfWorker();
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
 
 const assert = require('assert');
 const { spawnSync } = require('child_process');
diff --git a/test/parallel/test-permission-fs-write-report.js b/test/parallel/test-permission-fs-write-report.js
index 111f73b7bcc1ed..a5f8d74904fedc 100644
--- a/test/parallel/test-permission-fs-write-report.js
+++ b/test/parallel/test-permission-fs-write-report.js
@@ -2,9 +2,15 @@
 'use strict';
 
 const common = require('../common');
-common.skipIfWorker();
-if (!common.hasCrypto)
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
+
+if (!common.hasCrypto) {
   common.skip('no crypto');
+}
 
 const assert = require('assert');
 
diff --git a/test/parallel/test-permission-fs-write-v8.js b/test/parallel/test-permission-fs-write-v8.js
index 85cb9a5519b3af..1b8691969b7afb 100644
--- a/test/parallel/test-permission-fs-write-v8.js
+++ b/test/parallel/test-permission-fs-write-v8.js
@@ -2,9 +2,15 @@
 'use strict';
 
 const common = require('../common');
-common.skipIfWorker();
-if (!common.hasCrypto)
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
+
+if (!common.hasCrypto) {
   common.skip('no crypto');
+}
 
 const assert = require('assert');
 const v8 = require('v8');
diff --git a/test/parallel/test-permission-fs-write.js b/test/parallel/test-permission-fs-write.js
index 34eab7a40005db..385a37e2a92d86 100644
--- a/test/parallel/test-permission-fs-write.js
+++ b/test/parallel/test-permission-fs-write.js
@@ -2,9 +2,15 @@
 'use strict';
 
 const common = require('../common');
-common.skipIfWorker();
-if (!common.hasCrypto)
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
+
+if (!common.hasCrypto) {
   common.skip('no crypto');
+}
 
 const assert = require('assert');
 const path = require('path');
diff --git a/test/parallel/test-permission-inspector-brk.js b/test/parallel/test-permission-inspector-brk.js
index 61c9c799ba7eb6..3cc7caabd42ba1 100644
--- a/test/parallel/test-permission-inspector-brk.js
+++ b/test/parallel/test-permission-inspector-brk.js
@@ -5,8 +5,12 @@ const assert = require('assert');
 const { spawnSync } = require('child_process');
 const fixtures = require('../common/fixtures');
 const file = fixtures.path('permission', 'inspector-brk.js');
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
 
-common.skipIfWorker();
 common.skipIfInspectorDisabled();
 
 // See https://github.com/nodejs/node/issues/53385
diff --git a/test/parallel/test-permission-inspector.js b/test/parallel/test-permission-inspector.js
index 9d3bf485fc4348..4b52e12abca090 100644
--- a/test/parallel/test-permission-inspector.js
+++ b/test/parallel/test-permission-inspector.js
@@ -2,7 +2,12 @@
 'use strict';
 
 const common = require('../common');
-common.skipIfWorker();
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
+
 common.skipIfInspectorDisabled();
 
 const { Session } = require('inspector');
diff --git a/test/parallel/test-permission-no-addons.js b/test/parallel/test-permission-no-addons.js
index a3ae6f4be10641..df08c4aa9f9db5 100644
--- a/test/parallel/test-permission-no-addons.js
+++ b/test/parallel/test-permission-no-addons.js
@@ -2,7 +2,11 @@
 'use strict';
 
 const common = require('../common');
-common.skipIfWorker();
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
 
 const { createRequire } = require('node:module');
 const assert = require('node:assert');
diff --git a/test/parallel/test-permission-processbinding.js b/test/parallel/test-permission-processbinding.js
index 47a1364f19e303..f5e33dac4deb52 100644
--- a/test/parallel/test-permission-processbinding.js
+++ b/test/parallel/test-permission-processbinding.js
@@ -1,7 +1,11 @@
 'use strict';
 
 const common = require('../common');
-common.skipIfWorker();
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
 
 if (!common.hasCrypto) {
   common.skip('no crypto');
diff --git a/test/parallel/test-permission-worker-threads-cli.js b/test/parallel/test-permission-worker-threads-cli.js
index efd98b2a3881aa..cf397c280474c1 100644
--- a/test/parallel/test-permission-worker-threads-cli.js
+++ b/test/parallel/test-permission-worker-threads-cli.js
@@ -2,13 +2,17 @@
 'use strict';
 
 const common = require('../common');
-common.skipIfWorker();
-const assert = require('assert');
 const {
   Worker,
   isMainThread,
 } = require('worker_threads');
 
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
+
+const assert = require('assert');
+
 // Guarantee the initial state
 {
   assert.ok(!process.permission.has('worker'));
diff --git a/test/parallel/test-pipe-file-to-http.js b/test/parallel/test-pipe-file-to-http.js
index 82bdbe6a832a98..ffbab21f71fd9d 100644
--- a/test/parallel/test-pipe-file-to-http.js
+++ b/test/parallel/test-pipe-file-to-http.js
@@ -54,7 +54,12 @@ const server = http.createServer((req, res) => {
 server.listen(0);
 
 server.on('listening', () => {
-  common.createZeroFilledFile(filename);
+
+  // Create a zero-filled file
+  const fd = fs.openSync(filename, 'w');
+  fs.ftruncateSync(fd, 10 * 1024 * 1024);
+  fs.closeSync(fd);
+
   makeRequest();
 });
 
diff --git a/test/parallel/test-preload-self-referential.js b/test/parallel/test-preload-self-referential.js
index 867e1c67983c83..68681332978ea6 100644
--- a/test/parallel/test-preload-self-referential.js
+++ b/test/parallel/test-preload-self-referential.js
@@ -4,11 +4,13 @@ const common = require('../common');
 const fixtures = require('../common/fixtures');
 const assert = require('assert');
 const { exec } = require('child_process');
+const { isMainThread } = require('worker_threads');
 
 const nodeBinary = process.argv[0];
 
-if (!common.isMainThread)
+if (!isMainThread) {
   common.skip('process.chdir is not available in Workers');
+}
 
 const selfRefModule = fixtures.path('self_ref_module');
 const fixtureA = fixtures.path('printA.js');
diff --git a/test/parallel/test-process-abort.js b/test/parallel/test-process-abort.js
index 665e1399a3f362..34353befb02a44 100644
--- a/test/parallel/test-process-abort.js
+++ b/test/parallel/test-process-abort.js
@@ -2,9 +2,11 @@
 
 const common = require('../common');
 const assert = require('assert');
+const { isMainThread } = require('worker_threads');
 
-if (!common.isMainThread)
+if (!isMainThread) {
   common.skip('process.abort() is not available in Workers');
+}
 
 // Check that our built-in methods do not have a prototype/constructor behaviour
 // if they don't need to. This could be tested for any of our C++ methods.
diff --git a/test/parallel/test-process-beforeexit-throw-exit.js b/test/parallel/test-process-beforeexit-throw-exit.js
index 6e9d764be90baa..c967d3a62712a7 100644
--- a/test/parallel/test-process-beforeexit-throw-exit.js
+++ b/test/parallel/test-process-beforeexit-throw-exit.js
@@ -1,6 +1,10 @@
 'use strict';
 const common = require('../common');
-common.skipIfWorker();
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
 
 // Test that 'exit' is emitted if 'beforeExit' throws.
 
diff --git a/test/parallel/test-process-chdir-errormessage.js b/test/parallel/test-process-chdir-errormessage.js
index 0ed368287b377e..727a13f6f63f16 100644
--- a/test/parallel/test-process-chdir-errormessage.js
+++ b/test/parallel/test-process-chdir-errormessage.js
@@ -1,8 +1,11 @@
 'use strict';
 
 const common = require('../common');
-if (!common.isMainThread)
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
   common.skip('process.chdir is not available in Workers');
+}
 const assert = require('assert');
 
 assert.throws(
diff --git a/test/parallel/test-process-chdir.js b/test/parallel/test-process-chdir.js
index ee59df853b24ce..42d2a60c8ec63e 100644
--- a/test/parallel/test-process-chdir.js
+++ b/test/parallel/test-process-chdir.js
@@ -4,9 +4,11 @@ const common = require('../common');
 const assert = require('assert');
 const fs = require('fs');
 const path = require('path');
+const { isMainThread } = require('worker_threads');
 
-if (!common.isMainThread)
+if (!isMainThread) {
   common.skip('process.chdir is not available in Workers');
+}
 
 const tmpdir = require('../common/tmpdir');
 
diff --git a/test/parallel/test-process-env-tz.js b/test/parallel/test-process-env-tz.js
index dcc69ed4bf1d3b..b7bf730a9afa38 100644
--- a/test/parallel/test-process-env-tz.js
+++ b/test/parallel/test-process-env-tz.js
@@ -1,12 +1,15 @@
 'use strict';
 const common = require('../common');
 const assert = require('assert');
+const { isMainThread } = require('worker_threads');
 
-if (!common.isMainThread)
+if (!isMainThread) {
   common.skip('process.env.TZ is not intercepted in Workers');
+}
 
-if (common.isWindows)  // Using a different TZ format.
+if (common.isWindows) { // Using a different TZ format.
   common.skip('todo: test on Windows');
+}
 
 const date = new Date('2018-04-14T12:34:56.789Z');
 
diff --git a/test/parallel/test-process-euid-egid.js b/test/parallel/test-process-euid-egid.js
index 11a8cfa0ed2b3c..3f4934233a6308 100644
--- a/test/parallel/test-process-euid-egid.js
+++ b/test/parallel/test-process-euid-egid.js
@@ -3,6 +3,8 @@
 const common = require('../common');
 const assert = require('assert');
 
+const { isMainThread } = require('worker_threads');
+
 if (common.isWindows) {
   assert.strictEqual(process.geteuid, undefined);
   assert.strictEqual(process.getegid, undefined);
@@ -11,8 +13,9 @@ if (common.isWindows) {
   return;
 }
 
-if (!common.isMainThread)
+if (!isMainThread) {
   return;
+}
 
 assert.throws(() => {
   process.seteuid({});
diff --git a/test/parallel/test-process-exit-handler.js b/test/parallel/test-process-exit-handler.js
index d74e320fe63082..2546aa60a5cf89 100644
--- a/test/parallel/test-process-exit-handler.js
+++ b/test/parallel/test-process-exit-handler.js
@@ -1,8 +1,10 @@
 'use strict';
 const common = require('../common');
+const { isMainThread } = require('worker_threads');
 
-if (!common.isMainThread)
+if (!isMainThread) {
   common.skip('execArgv does not affect Workers');
+}
 
 // This test ensures that no asynchronous operations are performed in the 'exit'
 // handler.
diff --git a/test/parallel/test-process-get-builtin.mjs b/test/parallel/test-process-get-builtin.mjs
index b376e1b88f905a..6695828570f6c0 100644
--- a/test/parallel/test-process-get-builtin.mjs
+++ b/test/parallel/test-process-get-builtin.mjs
@@ -1,6 +1,7 @@
-import { isMainThread, hasCrypto, hasIntl } from '../common/index.mjs';
+import { hasCrypto, hasIntl } from '../common/index.mjs';
 import assert from 'node:assert';
 import { builtinModules } from 'node:module';
+import { isMainThread } from 'node:worker_threads';
 
 for (const invalid of [1, undefined, null, false, [], {}, () => {}, Symbol('test')]) {
   assert.throws(() => process.getBuiltinModule(invalid), { code: 'ERR_INVALID_ARG_TYPE' });
diff --git a/test/parallel/test-process-initgroups.js b/test/parallel/test-process-initgroups.js
index 6b4e3bdf1470b4..52597e096175e9 100644
--- a/test/parallel/test-process-initgroups.js
+++ b/test/parallel/test-process-initgroups.js
@@ -7,8 +7,11 @@ if (common.isWindows) {
   return;
 }
 
-if (!common.isMainThread)
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
   return;
+}
 
 [undefined, null, true, {}, [], () => {}].forEach((val) => {
   assert.throws(
diff --git a/test/parallel/test-process-load-env-file.js b/test/parallel/test-process-load-env-file.js
index 1dada3aa9b7016..ec99c099d11b80 100644
--- a/test/parallel/test-process-load-env-file.js
+++ b/test/parallel/test-process-load-env-file.js
@@ -5,6 +5,7 @@ const fixtures = require('../../test/common/fixtures');
 const assert = require('node:assert');
 const { describe, it } = require('node:test');
 const { join } = require('node:path');
+const { isMainThread } = require('worker_threads');
 
 const basicValidEnvFilePath = fixtures.path('dotenv/basic-valid.env');
 const validEnvFilePath = fixtures.path('dotenv/valid.env');
@@ -58,7 +59,7 @@ describe('process.loadEnvFile()', () => {
     const originalCwd = process.cwd();
 
     try {
-      if (common.isMainThread) {
+      if (isMainThread) {
         process.chdir(join(originalCwd, 'lib'));
       }
 
@@ -66,7 +67,7 @@ describe('process.loadEnvFile()', () => {
         process.loadEnvFile();
       }, { code: 'ENOENT', syscall: 'open', path: '.env' });
     } finally {
-      if (common.isMainThread) {
+      if (isMainThread) {
         process.chdir(originalCwd);
       }
     }
diff --git a/test/parallel/test-process-setgroups.js b/test/parallel/test-process-setgroups.js
index 9506f24a5f3447..49d147b6c2ddf5 100644
--- a/test/parallel/test-process-setgroups.js
+++ b/test/parallel/test-process-setgroups.js
@@ -1,14 +1,16 @@
 'use strict';
 const common = require('../common');
 const assert = require('assert');
+const { isMainThread } = require('worker_threads');
 
 if (common.isWindows) {
   assert.strictEqual(process.setgroups, undefined);
   return;
 }
 
-if (!common.isMainThread)
+if (!isMainThread) {
   return;
+}
 
 assert.throws(
   () => {
diff --git a/test/parallel/test-process-uid-gid.js b/test/parallel/test-process-uid-gid.js
index 54e87a6ff5c6e0..10eee45af1555b 100644
--- a/test/parallel/test-process-uid-gid.js
+++ b/test/parallel/test-process-uid-gid.js
@@ -23,6 +23,7 @@
 const common = require('../common');
 
 const assert = require('assert');
+const { isMainThread } = require('worker_threads');
 
 if (common.isWindows) {
   // uid/gid functions are POSIX only.
@@ -33,8 +34,9 @@ if (common.isWindows) {
   return;
 }
 
-if (!common.isMainThread)
+if (!isMainThread) {
   return;
+}
 
 assert.throws(() => {
   process.setuid({});
diff --git a/test/parallel/test-process-umask-mask.js b/test/parallel/test-process-umask-mask.js
index d599379761fd40..f0a67b8f14e895 100644
--- a/test/parallel/test-process-umask-mask.js
+++ b/test/parallel/test-process-umask-mask.js
@@ -5,8 +5,9 @@
 
 const common = require('../common');
 const assert = require('assert');
+const { isMainThread } = require('worker_threads');
 
-if (!common.isMainThread)
+if (!isMainThread)
   common.skip('Setting process.umask is not supported in Workers');
 
 let mask;
diff --git a/test/parallel/test-process-umask.js b/test/parallel/test-process-umask.js
index e90955f394df4e..594f75ebebed2b 100644
--- a/test/parallel/test-process-umask.js
+++ b/test/parallel/test-process-umask.js
@@ -22,8 +22,9 @@
 'use strict';
 const common = require('../common');
 const assert = require('assert');
+const { isMainThread } = require('worker_threads');
 
-if (!common.isMainThread) {
+if (!isMainThread) {
   assert.strictEqual(typeof process.umask(), 'number');
   assert.throws(() => {
     process.umask('0664');
diff --git a/test/parallel/test-readline-interface-no-trailing-newline.js b/test/parallel/test-readline-interface-no-trailing-newline.js
index b3392db8619c95..398b85838c8b71 100644
--- a/test/parallel/test-readline-interface-no-trailing-newline.js
+++ b/test/parallel/test-readline-interface-no-trailing-newline.js
@@ -3,7 +3,9 @@ const common = require('../common');
 const ArrayStream = require('../common/arraystream');
 const assert = require('assert');
 
-common.skipIfDumbTerminal();
+if (process.env.TERM === 'dumb') {
+  common.skip('skipping - dumb terminal');
+}
 
 const readline = require('readline');
 const rli = new readline.Interface({
diff --git a/test/parallel/test-readline-interface-recursive-writes.js b/test/parallel/test-readline-interface-recursive-writes.js
index 3a0aee5be9d619..ea3df1968d08d8 100644
--- a/test/parallel/test-readline-interface-recursive-writes.js
+++ b/test/parallel/test-readline-interface-recursive-writes.js
@@ -3,7 +3,9 @@ const common = require('../common');
 const ArrayStream = require('../common/arraystream');
 const assert = require('assert');
 
-common.skipIfDumbTerminal();
+if (process.env.TERM === 'dumb') {
+  common.skip('skipping - dumb terminal');
+}
 
 const readline = require('readline');
 const rli = new readline.Interface({
diff --git a/test/parallel/test-readline-interface.js b/test/parallel/test-readline-interface.js
index a90e07d235030f..12ba0c709622e9 100644
--- a/test/parallel/test-readline-interface.js
+++ b/test/parallel/test-readline-interface.js
@@ -22,7 +22,10 @@
 // Flags: --expose-internals
 'use strict';
 const common = require('../common');
-common.skipIfDumbTerminal();
+
+if (process.env.TERM === 'dumb') {
+  common.skip('skipping - dumb terminal');
+}
 
 const assert = require('assert');
 const readline = require('readline');
diff --git a/test/parallel/test-readline-position.js b/test/parallel/test-readline-position.js
index 3603a42ecedc68..ac2fe43b37a097 100644
--- a/test/parallel/test-readline-position.js
+++ b/test/parallel/test-readline-position.js
@@ -7,7 +7,9 @@ const assert = require('assert');
 
 const ctrlU = { ctrl: true, name: 'u' };
 
-common.skipIfDumbTerminal();
+if (process.env.TERM === 'dumb') {
+  common.skip('skipping - dumb terminal');
+}
 
 {
   const input = new PassThrough();
diff --git a/test/parallel/test-readline-promises-interface.js b/test/parallel/test-readline-promises-interface.js
index 8e42d977301267..97424c1372629c 100644
--- a/test/parallel/test-readline-promises-interface.js
+++ b/test/parallel/test-readline-promises-interface.js
@@ -1,7 +1,10 @@
 // Flags: --expose-internals
 'use strict';
 const common = require('../common');
-common.skipIfDumbTerminal();
+
+if (process.env.TERM === 'dumb') {
+  common.skip('skipping - dumb terminal');
+}
 
 const assert = require('assert');
 const readline = require('readline/promises');
diff --git a/test/parallel/test-readline-promises-tab-complete.js b/test/parallel/test-readline-promises-tab-complete.js
index fd32900e71d096..d8b0ac30ee779d 100644
--- a/test/parallel/test-readline-promises-tab-complete.js
+++ b/test/parallel/test-readline-promises-tab-complete.js
@@ -8,7 +8,9 @@ const assert = require('assert');
 const { EventEmitter } = require('events');
 const { getStringWidth } = require('internal/util/inspect');
 
-common.skipIfDumbTerminal();
+if (process.env.TERM === 'dumb') {
+  common.skip('skipping - dumb terminal');
+}
 
 // This test verifies that the tab completion supports unicode and the writes
 // are limited to the minimum.
diff --git a/test/parallel/test-readline-tab-complete.js b/test/parallel/test-readline-tab-complete.js
index 64df237d56ad44..5b7b19102f412a 100644
--- a/test/parallel/test-readline-tab-complete.js
+++ b/test/parallel/test-readline-tab-complete.js
@@ -8,7 +8,9 @@ const assert = require('assert');
 const EventEmitter = require('events').EventEmitter;
 const { getStringWidth } = require('internal/util/inspect');
 
-common.skipIfDumbTerminal();
+if (process.env.TERM === 'dumb') {
+  common.skip('skipping - dumb terminal');
+}
 
 // This test verifies that the tab completion supports unicode and the writes
 // are limited to the minimum.
diff --git a/test/parallel/test-readline-undefined-columns.js b/test/parallel/test-readline-undefined-columns.js
index 25bafe957fa40a..d7000a16dd88a7 100644
--- a/test/parallel/test-readline-undefined-columns.js
+++ b/test/parallel/test-readline-undefined-columns.js
@@ -5,7 +5,9 @@ const assert = require('assert');
 const PassThrough = require('stream').PassThrough;
 const readline = require('readline');
 
-common.skipIfDumbTerminal();
+if (process.env.TERM === 'dumb') {
+  common.skip('skipping - dumb terminal');
+}
 
 // Checks that tab completion still works
 // when output column size is undefined
diff --git a/test/parallel/test-readline.js b/test/parallel/test-readline.js
index 77799fc14cf75f..0cf577942915a6 100644
--- a/test/parallel/test-readline.js
+++ b/test/parallel/test-readline.js
@@ -4,7 +4,9 @@ const { PassThrough } = require('stream');
 const readline = require('readline');
 const assert = require('assert');
 
-common.skipIfDumbTerminal();
+if (process.env.TERM === 'dumb') {
+  common.skip('skipping - dumb terminal');
+}
 
 {
   const input = new PassThrough();
diff --git a/test/parallel/test-repl-autocomplete.js b/test/parallel/test-repl-autocomplete.js
index cb17523494b2ff..a68322c501e264 100644
--- a/test/parallel/test-repl-autocomplete.js
+++ b/test/parallel/test-repl-autocomplete.js
@@ -9,7 +9,9 @@ const assert = require('assert');
 const fs = require('fs');
 const { inspect } = require('util');
 
-common.skipIfDumbTerminal();
+if (process.env.TERM === 'dumb') {
+  common.skip('skipping - dumb terminal');
+}
 
 const tmpdir = require('../common/tmpdir');
 tmpdir.refresh();
diff --git a/test/parallel/test-repl-editor.js b/test/parallel/test-repl-editor.js
index e260f5e89174a8..fee647d0478e50 100644
--- a/test/parallel/test-repl-editor.js
+++ b/test/parallel/test-repl-editor.js
@@ -5,7 +5,9 @@ const assert = require('assert');
 const repl = require('repl');
 const ArrayStream = require('../common/arraystream');
 
-common.skipIfDumbTerminal();
+if (process.env.TERM === 'dumb') {
+  common.skip('skipping - dumb terminal');
+}
 
 // \u001b[nG - Moves the cursor to n st column
 // \u001b[0J - Clear screen
diff --git a/test/parallel/test-repl-history-navigation.js b/test/parallel/test-repl-history-navigation.js
index 4df120d7cb9eae..64317be960e8d1 100644
--- a/test/parallel/test-repl-history-navigation.js
+++ b/test/parallel/test-repl-history-navigation.js
@@ -9,7 +9,9 @@ const assert = require('assert');
 const fs = require('fs');
 const { inspect } = require('util');
 
-common.skipIfDumbTerminal();
+if (process.env.TERM === 'dumb') {
+  common.skip('skipping - dumb terminal');
+}
 
 const tmpdir = require('../common/tmpdir');
 tmpdir.refresh();
diff --git a/test/parallel/test-repl-load-multiline-no-trailing-newline.js b/test/parallel/test-repl-load-multiline-no-trailing-newline.js
index f57638d2521bbe..8fda91e35d1030 100644
--- a/test/parallel/test-repl-load-multiline-no-trailing-newline.js
+++ b/test/parallel/test-repl-load-multiline-no-trailing-newline.js
@@ -5,7 +5,9 @@ const fixtures = require('../common/fixtures');
 const assert = require('assert');
 const repl = require('repl');
 
-common.skipIfDumbTerminal();
+if (process.env.TERM === 'dumb') {
+  common.skip('skipping - dumb terminal');
+}
 
 const command = `.load ${fixtures.path('repl-load-multiline-no-trailing-newline.js')}`;
 const terminalCode = '\u001b[1G\u001b[0J \u001b[1G';
diff --git a/test/parallel/test-repl-load-multiline.js b/test/parallel/test-repl-load-multiline.js
index 4fcf206bef1be1..920f4b1c25d144 100644
--- a/test/parallel/test-repl-load-multiline.js
+++ b/test/parallel/test-repl-load-multiline.js
@@ -5,7 +5,9 @@ const fixtures = require('../common/fixtures');
 const assert = require('assert');
 const repl = require('repl');
 
-common.skipIfDumbTerminal();
+if (process.env.TERM === 'dumb') {
+  common.skip('skipping - dumb terminal');
+}
 
 const command = `.load ${fixtures.path('repl-load-multiline.js')}`;
 const terminalCode = '\u001b[1G\u001b[0J \u001b[1G';
diff --git a/test/parallel/test-repl-mode.js b/test/parallel/test-repl-mode.js
index aca8418904d082..f8a54d34089b00 100644
--- a/test/parallel/test-repl-mode.js
+++ b/test/parallel/test-repl-mode.js
@@ -4,7 +4,9 @@ const assert = require('assert');
 const Stream = require('stream');
 const repl = require('repl');
 
-common.skipIfDumbTerminal();
+if (process.env.TERM === 'dumb') {
+  common.skip('skipping - dumb terminal');
+}
 
 const tests = [
   testSloppyMode,
diff --git a/test/parallel/test-repl-permission-model.js b/test/parallel/test-repl-permission-model.js
index 938f5121163a23..ab5c7bff06cde8 100644
--- a/test/parallel/test-repl-permission-model.js
+++ b/test/parallel/test-repl-permission-model.js
@@ -8,7 +8,9 @@ const REPL = require('internal/repl');
 const assert = require('assert');
 const { inspect } = require('util');
 
-common.skipIfDumbTerminal();
+if (process.env.TERM === 'dumb') {
+  common.skip('skipping - dumb terminal');
+}
 
 // Create an input stream specialized for testing an array of actions
 class ActionStream extends stream.Stream {
diff --git a/test/parallel/test-repl-persistent-history.js b/test/parallel/test-repl-persistent-history.js
index 99ba92eda4cf3d..f5e2d48139f449 100644
--- a/test/parallel/test-repl-persistent-history.js
+++ b/test/parallel/test-repl-persistent-history.js
@@ -11,7 +11,9 @@ const fs = require('fs');
 const os = require('os');
 const util = require('util');
 
-common.skipIfDumbTerminal();
+if (process.env.TERM === 'dumb') {
+  common.skip('skipping - dumb terminal');
+}
 
 const tmpdir = require('../common/tmpdir');
 tmpdir.refresh();
diff --git a/test/parallel/test-repl-programmatic-history.js b/test/parallel/test-repl-programmatic-history.js
index 1ae5123c6c8ea1..aae15eb752c862 100644
--- a/test/parallel/test-repl-programmatic-history.js
+++ b/test/parallel/test-repl-programmatic-history.js
@@ -9,7 +9,9 @@ const fs = require('fs');
 const os = require('os');
 const util = require('util');
 
-common.skipIfDumbTerminal();
+if (process.env.TERM === 'dumb') {
+  common.skip('skipping - dumb terminal');
+}
 
 const tmpdir = require('../common/tmpdir');
 tmpdir.refresh();
diff --git a/test/parallel/test-repl-require-self-referential.js b/test/parallel/test-repl-require-self-referential.js
index 7ced6dbf11721e..9a4fe000bbb7e3 100644
--- a/test/parallel/test-repl-require-self-referential.js
+++ b/test/parallel/test-repl-require-self-referential.js
@@ -4,9 +4,11 @@ const common = require('../common');
 const fixtures = require('../common/fixtures');
 const assert = require('assert');
 const { spawn } = require('child_process');
+const { isMainThread } = require('worker_threads');
 
-if (!common.isMainThread)
+if (!isMainThread) {
   common.skip('process.chdir is not available in Workers');
+}
 
 const selfRefModule = fixtures.path('self_ref_module');
 const child = spawn(process.execPath,
diff --git a/test/parallel/test-repl-require.js b/test/parallel/test-repl-require.js
index fc431dea9f0f69..e740acef08b068 100644
--- a/test/parallel/test-repl-require.js
+++ b/test/parallel/test-repl-require.js
@@ -4,9 +4,11 @@ const common = require('../common');
 const fixtures = require('../common/fixtures');
 const assert = require('assert');
 const net = require('net');
+const { isMainThread } = require('worker_threads');
 
-if (!common.isMainThread)
+if (!isMainThread) {
   common.skip('process.chdir is not available in Workers');
+}
 
 process.chdir(fixtures.fixturesDir);
 const repl = require('repl');
diff --git a/test/parallel/test-repl-reverse-search.js b/test/parallel/test-repl-reverse-search.js
index 93fb037c392c01..246488cbd0ef5f 100644
--- a/test/parallel/test-repl-reverse-search.js
+++ b/test/parallel/test-repl-reverse-search.js
@@ -9,7 +9,10 @@ const assert = require('assert');
 const fs = require('fs');
 const { inspect } = require('util');
 
-common.skipIfDumbTerminal();
+if (process.env.TERM === 'dumb') {
+  common.skip('skipping - dumb terminal');
+}
+
 common.allowGlobals('aaaa');
 
 const tmpdir = require('../common/tmpdir');
diff --git a/test/parallel/test-repl-sigint-nested-eval.js b/test/parallel/test-repl-sigint-nested-eval.js
index 62eb46e0af6759..7955cf413f7c49 100644
--- a/test/parallel/test-repl-sigint-nested-eval.js
+++ b/test/parallel/test-repl-sigint-nested-eval.js
@@ -4,8 +4,12 @@ if (common.isWindows) {
   // No way to send CTRL_C_EVENT to processes from JS right now.
   common.skip('platform not supported');
 }
-if (!common.isMainThread)
+
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
   common.skip('No signal handling available in Workers');
+}
 
 const assert = require('assert');
 const spawn = require('child_process').spawn;
diff --git a/test/parallel/test-repl-sigint.js b/test/parallel/test-repl-sigint.js
index 8ad0b2f5c2c853..f4087b11d488d6 100644
--- a/test/parallel/test-repl-sigint.js
+++ b/test/parallel/test-repl-sigint.js
@@ -4,8 +4,12 @@ if (common.isWindows) {
   // No way to send CTRL_C_EVENT to processes from JS right now.
   common.skip('platform not supported');
 }
-if (!common.isMainThread)
+
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
   common.skip('No signal handling available in Workers');
+}
 
 const assert = require('assert');
 const spawn = require('child_process').spawn;
diff --git a/test/parallel/test-repl-strict-mode-previews.js b/test/parallel/test-repl-strict-mode-previews.js
index a05e11b39cf3ee..e7fc1ea5191ea3 100644
--- a/test/parallel/test-repl-strict-mode-previews.js
+++ b/test/parallel/test-repl-strict-mode-previews.js
@@ -5,7 +5,10 @@
 const common = require('../common');
 
 common.skipIfInspectorDisabled();
-common.skipIfDumbTerminal();
+
+if (process.env.TERM === 'dumb') {
+  common.skip('skipping - dumb terminal');
+}
 
 if (process.argv[2] === 'child') {
   const stream = require('stream');
diff --git a/test/parallel/test-repl-tab-complete-import.js b/test/parallel/test-repl-tab-complete-import.js
index fe9f7a3d11795b..f4ef408c89174c 100644
--- a/test/parallel/test-repl-tab-complete-import.js
+++ b/test/parallel/test-repl-tab-complete-import.js
@@ -7,8 +7,11 @@ const assert = require('assert');
 const { builtinModules } = require('module');
 const publicUnprefixedModules = builtinModules.filter((lib) => !lib.startsWith('_') && !lib.startsWith('node:'));
 
-if (!common.isMainThread)
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
   common.skip('process.chdir is not available in Workers');
+}
 
 // We have to change the directory to ../fixtures before requiring repl
 // in order to make the tests for completion of node_modules work properly
diff --git a/test/parallel/test-repl-tab-complete.js b/test/parallel/test-repl-tab-complete.js
index ff1e927078ddf5..c79162129bd69b 100644
--- a/test/parallel/test-repl-tab-complete.js
+++ b/test/parallel/test-repl-tab-complete.js
@@ -34,9 +34,11 @@ const { builtinModules } = require('module');
 const publicModules = builtinModules.filter((lib) => !lib.startsWith('_'));
 
 const hasInspector = process.features.inspector;
+const { isMainThread } = require('worker_threads');
 
-if (!common.isMainThread)
+if (!isMainThread) {
   common.skip('process.chdir is not available in Workers');
+}
 
 // We have to change the directory to ../fixtures before requiring repl
 // in order to make the tests for completion of node_modules work properly
diff --git a/test/parallel/test-require-symlink.js b/test/parallel/test-require-symlink.js
index 0c4477023bc90b..9ca543e8d64ca4 100644
--- a/test/parallel/test-require-symlink.js
+++ b/test/parallel/test-require-symlink.js
@@ -2,10 +2,14 @@
 'use strict';
 const common = require('../common');
 
-if (!common.canCreateSymLink())
+if (!common.canCreateSymLink()) {
   common.skip('insufficient privileges');
-if (!common.isMainThread)
+}
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
   common.skip('process.chdir is not available in Workers');
+}
 
 const assert = require('assert');
 const { spawn } = require('child_process');
diff --git a/test/parallel/test-runner-module-mocking.js b/test/parallel/test-runner-module-mocking.js
index cb40df98147302..8502d4aa99a9b6 100644
--- a/test/parallel/test-runner-module-mocking.js
+++ b/test/parallel/test-runner-module-mocking.js
@@ -1,8 +1,9 @@
 // Flags: --experimental-test-module-mocks --experimental-require-module
 'use strict';
 const common = require('../common');
+const { isMainThread } = require('worker_threads');
 
-if (!common.isMainThread) {
+if (!isMainThread) {
   common.skip('registering customization hooks in Workers does not work');
 }
 
diff --git a/test/parallel/test-set-process-debug-port.js b/test/parallel/test-set-process-debug-port.js
index d00a1ddf68ebb6..7f0cbe068549d0 100644
--- a/test/parallel/test-set-process-debug-port.js
+++ b/test/parallel/test-set-process-debug-port.js
@@ -2,7 +2,11 @@
 const common = require('../common');
 
 common.skipIfInspectorDisabled();
-common.skipIfWorker();
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
 
 const assert = require('assert');
 const kMinPort = 1024;
diff --git a/test/parallel/test-setproctitle.js b/test/parallel/test-setproctitle.js
index 7c4287829f7c0a..b08302e0a35ac0 100644
--- a/test/parallel/test-setproctitle.js
+++ b/test/parallel/test-setproctitle.js
@@ -1,15 +1,16 @@
 'use strict';
 // Original test written by Jakub Lekstan <kuebzky@gmail.com>
 const common = require('../common');
+const { isMainThread } = require('worker_threads');
 
 // FIXME add sunos support
-if (common.isSunOS)
+if (common.isSunOS || common.isIBMi) {
   common.skip(`Unsupported platform [${process.platform}]`);
-// FIXME add IBMi support
-if (common.isIBMi)
-  common.skip('Unsupported platform IBMi');
-if (!common.isMainThread)
+}
+
+if (!isMainThread) {
   common.skip('Setting the process title from Workers is not supported');
+}
 
 const assert = require('assert');
 const { exec, execSync } = require('child_process');
@@ -25,8 +26,9 @@ process.title = title;
 assert.strictEqual(process.title, title);
 
 // Test setting the title but do not try to run `ps` on Windows.
-if (common.isWindows)
+if (common.isWindows) {
   common.skip('Windows does not have "ps" utility');
+}
 
 try {
   execSync('command -v ps');
diff --git a/test/parallel/test-shadow-realm-import-value-resolve.js b/test/parallel/test-shadow-realm-import-value-resolve.js
index ee1c17d67c12f1..eeb00509d53a6c 100644
--- a/test/parallel/test-shadow-realm-import-value-resolve.js
+++ b/test/parallel/test-shadow-realm-import-value-resolve.js
@@ -3,8 +3,11 @@
 const common = require('../common');
 const assert = require('assert');
 const path = require('path');
+const { isMainThread } = require('worker_threads');
 
-common.skipIfWorker('process.chdir is not supported in workers.');
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
 
 async function main() {
   const realm = new ShadowRealm();
diff --git a/test/parallel/test-signal-args.js b/test/parallel/test-signal-args.js
index 7b72ed6dcb92d5..28a077ecc1c7d9 100644
--- a/test/parallel/test-signal-args.js
+++ b/test/parallel/test-signal-args.js
@@ -3,10 +3,15 @@
 const common = require('../common');
 const assert = require('assert');
 
-if (common.isWindows)
+if (common.isWindows) {
   common.skip('Sending signals with process.kill is not supported on Windows');
-if (!common.isMainThread)
+}
+
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
   common.skip('No signal handling available in Workers');
+}
 
 process.once('SIGINT', common.mustCall((signal) => {
   assert.strictEqual(signal, 'SIGINT');
diff --git a/test/parallel/test-signal-handler.js b/test/parallel/test-signal-handler.js
index 05ec4e7f73faf5..b84d2063a288db 100644
--- a/test/parallel/test-signal-handler.js
+++ b/test/parallel/test-signal-handler.js
@@ -23,10 +23,15 @@
 
 const common = require('../common');
 
-if (common.isWindows)
+if (common.isWindows) {
   common.skip('SIGUSR1 and SIGHUP signals are not supported');
-if (!common.isMainThread)
+}
+
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
   common.skip('Signal handling in Workers is not supported');
+}
 
 console.log(`process.pid: ${process.pid}`);
 
diff --git a/test/parallel/test-stdio-pipe-access.js b/test/parallel/test-stdio-pipe-access.js
index ac0e22c399a1b9..6bf6b107c60e92 100644
--- a/test/parallel/test-stdio-pipe-access.js
+++ b/test/parallel/test-stdio-pipe-access.js
@@ -1,7 +1,10 @@
 'use strict';
 const common = require('../common');
-if (!common.isMainThread)
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
   common.skip("Workers don't have process-like stdio");
+}
 
 // Test if Node handles accessing process.stdin if it is a redirected
 // pipe without deadlocking
diff --git a/test/parallel/test-stdio-pipe-redirect.js b/test/parallel/test-stdio-pipe-redirect.js
index 8b48133c8b0317..69367119ed3402 100644
--- a/test/parallel/test-stdio-pipe-redirect.js
+++ b/test/parallel/test-stdio-pipe-redirect.js
@@ -1,7 +1,10 @@
 'use strict';
 const common = require('../common');
-if (!common.isMainThread)
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
   common.skip("Workers don't have process-like stdio");
+}
 
 // Test if Node handles redirecting one child process stdout to another
 // process stdin without crashing.
diff --git a/test/parallel/test-timers-immediate-unref-simple.js b/test/parallel/test-timers-immediate-unref-simple.js
index 369894fcdebbae..fae8ad3eaea801 100644
--- a/test/parallel/test-timers-immediate-unref-simple.js
+++ b/test/parallel/test-timers-immediate-unref-simple.js
@@ -1,8 +1,9 @@
 'use strict';
 
 const common = require('../common');
+const { isMainThread } = require('worker_threads');
 
-if (!common.isMainThread) {
+if (!isMainThread) {
   // Note that test-timers-immediate-unref-nested-once works instead.
   common.skip('Worker bootstrapping works differently -> different timing');
 }
diff --git a/test/parallel/test-trace-events-api.js b/test/parallel/test-trace-events-api.js
index 709f8de9097906..8792a40cf00c80 100644
--- a/test/parallel/test-trace-events-api.js
+++ b/test/parallel/test-trace-events-api.js
@@ -2,7 +2,12 @@
 'use strict';
 
 const common = require('../common');
-common.skipIfWorker(); // https://github.com/nodejs/node/issues/22767
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  // https://github.com/nodejs/node/issues/22767
+  common.skip('This test only works on a main thread');
+}
 
 try {
   require('trace_events');
diff --git a/test/parallel/test-trace-events-dynamic-enable.js b/test/parallel/test-trace-events-dynamic-enable.js
index 69251944031e1f..5b2ce313421568 100644
--- a/test/parallel/test-trace-events-dynamic-enable.js
+++ b/test/parallel/test-trace-events-dynamic-enable.js
@@ -4,7 +4,13 @@
 const common = require('../common');
 
 common.skipIfInspectorDisabled();
-common.skipIfWorker(); // https://github.com/nodejs/node/issues/22767
+
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  // https://github.com/nodejs/node/issues/22767
+  common.skip('This test only works on a main thread');
+}
 
 const { internalBinding } = require('internal/test/binding');
 
diff --git a/test/parallel/test-warn-sigprof.js b/test/parallel/test-warn-sigprof.js
index 36b0db78d82687..929deb69addb17 100644
--- a/test/parallel/test-warn-sigprof.js
+++ b/test/parallel/test-warn-sigprof.js
@@ -7,10 +7,15 @@ const common = require('../common');
 
 common.skipIfInspectorDisabled();
 
-if (common.isWindows)
+if (common.isWindows) {
   common.skip('test does not apply to Windows');
+}
 
-common.skipIfWorker(); // Worker inspector never has a server running
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
 
 common.expectWarning('Warning',
                      'process.on(SIGPROF) is reserved while debugging');
diff --git a/test/parallel/test-worker-name.js b/test/parallel/test-worker-name.js
index 952fcee0e05429..30f3710a826caf 100644
--- a/test/parallel/test-worker-name.js
+++ b/test/parallel/test-worker-name.js
@@ -4,10 +4,17 @@ const common = require('../common');
 const fixtures = require('../common/fixtures');
 
 common.skipIfInspectorDisabled();
-common.skipIfWorker(); // This test requires both main and worker threads.
+
+const {
+  Worker,
+  isMainThread,
+} = require('worker_threads');
+
+if (!isMainThread) {
+  common.skip('This test only works on a main thread');
+}
 
 const assert = require('assert');
-const { Worker, isMainThread } = require('worker_threads');
 
 if (isMainThread) {
   const name = 'Hello Thread';
diff --git a/test/report/test-report-signal.js b/test/report/test-report-signal.js
index cb5efd9fc39fe2..03908ddcf24f16 100644
--- a/test/report/test-report-signal.js
+++ b/test/report/test-report-signal.js
@@ -3,11 +3,15 @@
 // Test producing a report via signal.
 const common = require('../common');
 
-if (common.isWindows)
+if (common.isWindows) {
   return common.skip('Unsupported on Windows.');
+}
 
-if (!common.isMainThread)
+const { isMainThread } = require('worker_threads');
+
+if (!isMainThread) {
   common.skip('Signal reporting is only supported in the main thread');
+}
 
 const assert = require('assert');
 const helper = require('../common/report');
diff --git a/test/sequential/test-fs-watch.js b/test/sequential/test-fs-watch.js
index cb12acfc115a4b..8db27a79e33d0a 100644
--- a/test/sequential/test-fs-watch.js
+++ b/test/sequential/test-fs-watch.js
@@ -29,9 +29,11 @@ const fs = require('fs');
 const path = require('path');
 
 const tmpdir = require('../common/tmpdir');
+const { isMainThread } = require('worker_threads');
 
-if (!common.isMainThread)
+if (!isMainThread) {
   common.skip('process.chdir is not available in Workers');
+}
 
 const expectFilePath = common.isWindows ||
                        common.isLinux ||
diff --git a/test/sequential/test-heapdump.js b/test/sequential/test-heapdump.js
index 1388623e61f939..f9df88375ae596 100644
--- a/test/sequential/test-heapdump.js
+++ b/test/sequential/test-heapdump.js
@@ -1,9 +1,11 @@
 'use strict';
 
 const common = require('../common');
+const { isMainThread } = require('worker_threads');
 
-if (!common.isMainThread)
+if (!isMainThread) {
   common.skip('process.chdir is not available in Workers');
+}
 
 const { writeHeapSnapshot, getHeapSnapshot } = require('v8');
 const assert = require('assert');
diff --git a/test/sequential/test-init.js b/test/sequential/test-init.js
index 7195369e0e4f8e..dd5db5640d1f0c 100644
--- a/test/sequential/test-init.js
+++ b/test/sequential/test-init.js
@@ -24,9 +24,11 @@ const common = require('../common');
 const assert = require('assert');
 const child = require('child_process');
 const fixtures = require('../common/fixtures');
+const { isMainThread } = require('worker_threads');
 
-if (!common.isMainThread)
+if (!isMainThread) {
   common.skip('process.chdir is not available in Workers');
+}
 
 if (process.env.TEST_INIT) {
   return process.stdout.write('Loaded successfully!');
diff --git a/test/sequential/test-perf-hooks.js b/test/sequential/test-perf-hooks.js
index 1e11f26571480d..847decdef18bfc 100644
--- a/test/sequential/test-perf-hooks.js
+++ b/test/sequential/test-perf-hooks.js
@@ -1,11 +1,12 @@
 'use strict';
 
-const common = require('../common');
+require('../common');
 const { performance } = require('perf_hooks');
 // Get the start time as soon as possible.
 const testStartTime = performance.now();
 const assert = require('assert');
 const { writeSync } = require('fs');
+const { isMainThread } = require('worker_threads');
 
 // Use writeSync to stdout to avoid disturbing the loop.
 function log(str) {
@@ -131,7 +132,7 @@ function checkValue(timing, name, min, max) {
 }
 
 let loopStart = initialTiming.loopStart;
-if (common.isMainThread) {
+if (isMainThread) {
   // In the main thread, the loop does not start until we start an operation
   // that requires it, e.g. setTimeout().
   assert.strictEqual(initialTiming.loopStart, -1);

From 552362a36607f5b7cb3ec0420b5ee8b5bcfa347e Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Wed, 22 Jan 2025 15:08:23 -0800
Subject: [PATCH 12/38] test: make common/index slightly less node.js specific

* s/global/globalThis
* clean up knownGlobals a bit, make it a Set instead of an array
  and condense a bit.

PR-URL: https://github.com/nodejs/node/pull/56712
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 test/common/index.js | 140 ++++++++++++++++++-------------------------
 1 file changed, 57 insertions(+), 83 deletions(-)

diff --git a/test/common/index.js b/test/common/index.js
index 6086d584f0b595..3647f4554a4647 100644
--- a/test/common/index.js
+++ b/test/common/index.js
@@ -20,7 +20,7 @@
 // USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 'use strict';
-const process = global.process;  // Some tests tamper with the process global.
+const process = globalThis.process;  // Some tests tamper with the process globalThis.
 
 const assert = require('assert');
 const { exec, execSync, spawn, spawnSync } = require('child_process');
@@ -266,7 +266,7 @@ function platformTimeout(ms) {
   return ms;
 }
 
-let knownGlobals = [
+const knownGlobals = new Set([
   AbortController,
   atob,
   btoa,
@@ -278,88 +278,59 @@ let knownGlobals = [
   setInterval,
   setTimeout,
   queueMicrotask,
-];
-
-if (global.gc) {
-  knownGlobals.push(global.gc);
-}
-
-if (global.navigator) {
-  knownGlobals.push(global.navigator);
-}
-
-if (global.Navigator) {
-  knownGlobals.push(global.Navigator);
-}
-
-if (global.Performance) {
-  knownGlobals.push(global.Performance);
-}
-if (global.performance) {
-  knownGlobals.push(global.performance);
-}
-if (global.PerformanceMark) {
-  knownGlobals.push(global.PerformanceMark);
-}
-if (global.PerformanceMeasure) {
-  knownGlobals.push(global.PerformanceMeasure);
-}
-
-// TODO(@ethan-arrowood): Similar to previous checks, this can be temporary
-// until v16.x is EOL. Once all supported versions have structuredClone we
-// can add this to the list above instead.
-if (global.structuredClone) {
-  knownGlobals.push(global.structuredClone);
-}
-
-if (global.EventSource) {
-  knownGlobals.push(EventSource);
-}
-
-if (global.fetch) {
-  knownGlobals.push(fetch);
-}
-if (hasCrypto && global.crypto) {
-  knownGlobals.push(global.crypto);
-  knownGlobals.push(global.Crypto);
-  knownGlobals.push(global.CryptoKey);
-  knownGlobals.push(global.SubtleCrypto);
-}
-if (global.CustomEvent) {
-  knownGlobals.push(global.CustomEvent);
-}
-if (global.ReadableStream) {
-  knownGlobals.push(
-    global.ReadableStream,
-    global.ReadableStreamDefaultReader,
-    global.ReadableStreamBYOBReader,
-    global.ReadableStreamBYOBRequest,
-    global.ReadableByteStreamController,
-    global.ReadableStreamDefaultController,
-    global.TransformStream,
-    global.TransformStreamDefaultController,
-    global.WritableStream,
-    global.WritableStreamDefaultWriter,
-    global.WritableStreamDefaultController,
-    global.ByteLengthQueuingStrategy,
-    global.CountQueuingStrategy,
-    global.TextEncoderStream,
-    global.TextDecoderStream,
-    global.CompressionStream,
-    global.DecompressionStream,
-  );
-}
+  structuredClone,
+  fetch,
+]);
+
+['gc',
+ // The following are assumed to be conditionally available in the
+ // global object currently. They can likely be added to the fixed
+ // set of known globals, however.
+ 'navigator',
+ 'Navigator',
+ 'performance',
+ 'Performance',
+ 'PerformanceMark',
+ 'PerformanceMeasure',
+ 'EventSource',
+ 'CustomEvent',
+ 'ReadableStream',
+ 'ReadableStreamDefaultReader',
+ 'ReadableStreamBYOBReader',
+ 'ReadableStreamBYOBRequest',
+ 'ReadableByteStreamController',
+ 'ReadableStreamDefaultController',
+ 'TransformStream',
+ 'TransformStreamDefaultController',
+ 'WritableStream',
+ 'WritableStreamDefaultWriter',
+ 'WritableStreamDefaultController',
+ 'ByteLengthQueuingStrategy',
+ 'CountQueuingStrategy',
+ 'TextEncoderStream',
+ 'TextDecoderStream',
+ 'CompressionStream',
+ 'DecompressionStream',
+ 'Storage',
+ 'localStorage',
+ 'sessionStorage',
+].forEach((i) => {
+  if (globalThis[i] !== undefined) {
+    knownGlobals.add(globalThis[i]);
+  }
+});
 
-if (global.Storage) {
-  knownGlobals.push(
-    global.localStorage,
-    global.sessionStorage,
-    global.Storage,
-  );
+if (hasCrypto) {
+  knownGlobals.add(globalThis.crypto);
+  knownGlobals.add(globalThis.Crypto);
+  knownGlobals.add(globalThis.CryptoKey);
+  knownGlobals.add(globalThis.SubtleCrypto);
 }
 
 function allowGlobals(...allowlist) {
-  knownGlobals = knownGlobals.concat(allowlist);
+  for (const val of allowlist) {
+    knownGlobals.add(val);
+  }
 }
 
 if (process.env.NODE_TEST_KNOWN_GLOBALS !== '0') {
@@ -371,10 +342,13 @@ if (process.env.NODE_TEST_KNOWN_GLOBALS !== '0') {
   function leakedGlobals() {
     const leaked = [];
 
-    for (const val in global) {
+    for (const val in globalThis) {
       // globalThis.crypto is a getter that throws if Node.js was compiled
-      // without OpenSSL.
-      if (val !== 'crypto' && !knownGlobals.includes(global[val])) {
+      // without OpenSSL so we'll skip it if it is not available.
+      if (val === 'crypto' && !hasCrypto) {
+        continue;
+      }
+      if (!knownGlobals.has(globalThis[val])) {
         leaked.push(val);
       }
     }

From 97a3a8204c7c0eb35fc6c11274a7aee5d2ea3ddc Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Wed, 22 Jan 2025 15:30:30 -0800
Subject: [PATCH 13/38] test: replace more uses of `global` with `globalThis`

PR-URL: https://github.com/nodejs/node/pull/56712
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 test/parallel/test-aborted-util.js            |  2 +-
 .../test-abortsignal-drop-settled-signals.mjs | 10 +--
 test/parallel/test-assert-checktag.js         |  8 +--
 .../test-async-hooks-destroy-on-gc.js         |  2 +-
 .../test-async-hooks-disable-gc-tracking.js   |  2 +-
 ...test-async-hooks-prevent-double-destroy.js |  2 +-
 test/parallel/test-cli-eval.js                |  2 +-
 test/parallel/test-common-gc.js               |  4 +-
 .../parallel/test-console-assign-undefined.js | 16 ++---
 test/parallel/test-console-instance.js        |  4 +-
 test/parallel/test-console-self-assign.js     |  2 +-
 test/parallel/test-crypto-dh-leak.js          |  2 +-
 test/parallel/test-domain-crypto.js           |  2 +-
 .../test-eventtarget-memoryleakwarning.js     |  2 +-
 test/parallel/test-eventtarget.js             |  2 +-
 .../test-finalization-registry-shutdown.js    |  2 +-
 test/parallel/test-fs-filehandle.js           |  2 +-
 .../test-fs-promises-file-handle-close.js     |  2 +-
 test/parallel/test-fs-write-reuse-callback.js |  2 +-
 test/parallel/test-fs-write.js                |  8 ++-
 .../test-gc-http-client-connaborted.js        |  2 +-
 test/parallel/test-gc-net-timeout.js          |  2 +-
 test/parallel/test-gc-tls-external-memory.js  |  2 +-
 test/parallel/test-global-setters.js          | 12 ++--
 test/parallel/test-global.js                  | 14 ++--
 ...-h2leak-destroy-session-on-socket-ended.js |  4 +-
 .../test-heapdump-async-hooks-init-promise.js |  2 +-
 .../test-http-agent-domain-reused-gc.js       |  2 +-
 test/parallel/test-http-parser-bad-ref.js     |  2 +-
 ...t-http-server-connections-checking-leak.js |  2 +-
 .../test-http-server-keepalive-req-gc.js      |  4 +-
 test/parallel/test-http2-createwritereq.js    |  2 +-
 ...-http2-session-gc-while-write-scheduled.js |  2 +-
 ...tp2-write-finishes-after-stream-destroy.js |  2 +-
 ...-https-server-connections-checking-leak.js |  2 +-
 .../test-inspector-scriptparsed-context.js    |  4 +-
 ...r-vm-global-accessors-getter-sideeffect.js |  2 +-
 test/parallel/test-module-relative-lookup.js  |  2 +-
 test/parallel/test-net-connect-memleak.js     |  2 +-
 .../test-net-write-fully-async-buffer.js      |  2 +-
 .../test-net-write-fully-async-hex-string.js  |  2 +-
 test/parallel/test-performance-gc.js          |  4 +-
 test/parallel/test-primitive-timer-leak.js    |  2 +-
 test/parallel/test-repl-autolibs.js           |  6 +-
 test/parallel/test-repl-underscore.js         |  4 +-
 test/parallel/test-repl-use-global.js         |  6 +-
 test/parallel/test-repl.js                    |  6 +-
 test/parallel/test-runner-mock-timers.js      | 68 +++++++++----------
 test/parallel/test-timers-api-refs.js         | 12 ++--
 .../parallel/test-timers-process-tampering.js |  4 +-
 test/parallel/test-tls-connect-memleak.js     |  2 +-
 test/parallel/test-tls-securepair-leak.js     |  2 +-
 ...test-tls-transport-destroy-after-own-gc.js |  6 +-
 test/parallel/test-trace-events-api.js        |  2 +-
 test/parallel/test-util-format.js             |  4 +-
 test/parallel/test-util-inspect.js            |  6 +-
 test/parallel/test-vm-basic.js                |  6 +-
 .../test-vm-create-and-run-in-context.js      |  2 +-
 test/parallel/test-vm-cross-context.js        |  2 +-
 test/parallel/test-vm-global-get-own.js       | 26 +++----
 test/parallel/test-vm-measure-memory-lazy.js  | 10 +--
 test/parallel/test-vm-module-basic.js         | 12 ++--
 .../test-vm-new-script-new-context.js         | 34 +++++-----
 .../test-vm-new-script-this-context.js        | 32 ++++-----
 test/parallel/test-vm-run-in-new-context.js   | 34 +++++-----
 test/parallel/test-vm-static-this.js          | 26 +++----
 test/parallel/test-webstorage.js              |  4 +-
 .../parallel/test-whatwg-url-custom-global.js |  4 +-
 test/parallel/test-worker-cli-options.js      |  2 +-
 ...orker-message-channel-sharedarraybuffer.js |  2 +-
 .../parallel/test-worker-message-port-move.js |  2 +-
 ...est-worker-workerdata-sharedarraybuffer.js |  2 +-
 .../test-zlib-invalid-input-memory.js         |  2 +-
 test/parallel/test-zlib-unused-weak.js        |  4 +-
 74 files changed, 246 insertions(+), 242 deletions(-)

diff --git a/test/parallel/test-aborted-util.js b/test/parallel/test-aborted-util.js
index 4bc45b9f5529bb..0566204ccdb074 100644
--- a/test/parallel/test-aborted-util.js
+++ b/test/parallel/test-aborted-util.js
@@ -32,7 +32,7 @@ test('Aborted with gc cleanup', async () => {
   const { promise, resolve } = Promise.withResolvers();
 
   setImmediate(() => {
-    global.gc();
+    globalThis.gc();
     ac.abort();
     strictEqual(ac.signal.aborted, true);
     strictEqual(getEventListeners(ac.signal, 'abort').length, 0);
diff --git a/test/parallel/test-abortsignal-drop-settled-signals.mjs b/test/parallel/test-abortsignal-drop-settled-signals.mjs
index 0abcaf81012716..b300b0e223fc93 100644
--- a/test/parallel/test-abortsignal-drop-settled-signals.mjs
+++ b/test/parallel/test-abortsignal-drop-settled-signals.mjs
@@ -16,7 +16,7 @@ function makeSubsequentCalls(limit, done, holdReferences = false) {
       // This setImmediate is necessary to ensure that in the last iteration the remaining signal is GCed (if not
       // retained)
       setImmediate(() => {
-        global.gc();
+        globalThis.gc();
         done(ac.signal, dependantSymbol);
       });
       return;
@@ -50,7 +50,7 @@ function runShortLivedSourceSignal(limit, done) {
 
   function run(iteration) {
     if (iteration > limit) {
-      global.gc();
+      globalThis.gc();
       done(signalRefs);
       return;
     }
@@ -74,9 +74,9 @@ function runWithOrphanListeners(limit, done) {
     const ac = new AbortController();
     if (iteration > limit) {
       setImmediate(() => {
-        global.gc();
+        globalThis.gc();
         setImmediate(() => {
-          global.gc();
+          globalThis.gc();
 
           done(composedSignalRefs);
         });
@@ -147,7 +147,7 @@ it('drops settled dependant signals when signal is composite', (t, done) => {
   t.assert.strictEqual(controllers[1].signal[kDependantSignals].size, 1);
 
   setImmediate(() => {
-    global.gc({ execution: 'async' }).then(async () => {
+    globalThis.gc({ execution: 'async' }).then(async () => {
       await gcUntil('all signals are GCed', () => {
         const totalDependantSignals = Math.max(
           controllers[0].signal[kDependantSignals].size,
diff --git a/test/parallel/test-assert-checktag.js b/test/parallel/test-assert-checktag.js
index 7587939436f40d..b86a1bde7f096d 100644
--- a/test/parallel/test-assert-checktag.js
+++ b/test/parallel/test-assert-checktag.js
@@ -49,13 +49,13 @@ test('', { skip: !hasCrypto }, () => {
 
   {  // At the moment global has its own type tag
     const fakeGlobal = {};
-    Object.setPrototypeOf(fakeGlobal, Object.getPrototypeOf(global));
-    for (const prop of Object.keys(global)) {
+    Object.setPrototypeOf(fakeGlobal, Object.getPrototypeOf(globalThis));
+    for (const prop of Object.keys(globalThis)) {
       fakeGlobal[prop] = global[prop];
     }
-    assert.notDeepEqual(fakeGlobal, global);
+    assert.notDeepEqual(fakeGlobal, globalThis);
     // Message will be truncated anyway, don't validate
-    assert.throws(() => assert.deepStrictEqual(fakeGlobal, global),
+    assert.throws(() => assert.deepStrictEqual(fakeGlobal, globalThis),
                   assert.AssertionError);
   }
 
diff --git a/test/parallel/test-async-hooks-destroy-on-gc.js b/test/parallel/test-async-hooks-destroy-on-gc.js
index fe6325e189734b..dd7eef8776cdf3 100644
--- a/test/parallel/test-async-hooks-destroy-on-gc.js
+++ b/test/parallel/test-async-hooks-destroy-on-gc.js
@@ -22,6 +22,6 @@ let asyncId = null;
 }
 
 setImmediate(() => {
-  global.gc();
+  globalThis.gc();
   setImmediate(() => assert.ok(destroyedIds.has(asyncId)));
 });
diff --git a/test/parallel/test-async-hooks-disable-gc-tracking.js b/test/parallel/test-async-hooks-disable-gc-tracking.js
index 84c5043aad3335..87b096c258121c 100644
--- a/test/parallel/test-async-hooks-disable-gc-tracking.js
+++ b/test/parallel/test-async-hooks-disable-gc-tracking.js
@@ -14,7 +14,7 @@ const hook = async_hooks.createHook({
 new async_hooks.AsyncResource('foobar', { requireManualDestroy: true });
 
 setImmediate(() => {
-  global.gc();
+  globalThis.gc();
   setImmediate(() => {
     hook.disable();
   });
diff --git a/test/parallel/test-async-hooks-prevent-double-destroy.js b/test/parallel/test-async-hooks-prevent-double-destroy.js
index 689dc399f9d2f2..4aa55a5a6c87bf 100644
--- a/test/parallel/test-async-hooks-prevent-double-destroy.js
+++ b/test/parallel/test-async-hooks-prevent-double-destroy.js
@@ -17,7 +17,7 @@ const hook = async_hooks.createHook({
 }
 
 setImmediate(() => {
-  global.gc();
+  globalThis.gc();
   setImmediate(() => {
     hook.disable();
   });
diff --git a/test/parallel/test-cli-eval.js b/test/parallel/test-cli-eval.js
index 24031581fd737e..9ec0fece409068 100644
--- a/test/parallel/test-cli-eval.js
+++ b/test/parallel/test-cli-eval.js
@@ -345,7 +345,7 @@ child.exec(
 // Regression test for https://github.com/nodejs/node/issues/45336
 child.execFile(process.execPath,
                ['-p',
-                'Object.defineProperty(global, "fs", { configurable: false });' +
+                'Object.defineProperty(globalThis, "fs", { configurable: false });' +
                 'fs === require("node:fs")'],
                common.mustSucceed((stdout) => {
                  assert.match(stdout, /^true/);
diff --git a/test/parallel/test-common-gc.js b/test/parallel/test-common-gc.js
index f7d73ccd0423e3..54abe3695cc3be 100644
--- a/test/parallel/test-common-gc.js
+++ b/test/parallel/test-common-gc.js
@@ -5,10 +5,10 @@ const { onGC } = require('../common/gc');
 
 {
   onGC({}, { ongc: common.mustCall() });
-  global.gc();
+  globalThis.gc();
 }
 
 {
   onGC(process, { ongc: common.mustNotCall() });
-  global.gc();
+  globalThis.gc();
 }
diff --git a/test/parallel/test-console-assign-undefined.js b/test/parallel/test-console-assign-undefined.js
index 1021307b3c5f22..7f5b0e04727679 100644
--- a/test/parallel/test-console-assign-undefined.js
+++ b/test/parallel/test-console-assign-undefined.js
@@ -1,28 +1,28 @@
 'use strict';
 
-// Patch global.console before importing modules that may modify the console
+// Patch globalThis.console before importing modules that may modify the console
 // object.
 
-const tmp = global.console;
-global.console = 42;
+const tmp = globalThis.console;
+globalThis.console = 42;
 
 require('../common');
 const assert = require('assert');
 
 // Originally the console had a getter. Test twice to verify it had no side
 // effect.
-assert.strictEqual(global.console, 42);
-assert.strictEqual(global.console, 42);
+assert.strictEqual(globalThis.console, 42);
+assert.strictEqual(globalThis.console, 42);
 
 assert.throws(
   () => console.log('foo'),
   { name: 'TypeError' }
 );
 
-global.console = 1;
-assert.strictEqual(global.console, 1);
+globalThis.console = 1;
+assert.strictEqual(globalThis.console, 1);
 assert.strictEqual(console, 1);
 
 // Reset the console
-global.console = tmp;
+globalThis.console = tmp;
 console.log('foo');
diff --git a/test/parallel/test-console-instance.js b/test/parallel/test-console-instance.js
index bf22314e22e031..0364a6213bc726 100644
--- a/test/parallel/test-console-instance.js
+++ b/test/parallel/test-console-instance.js
@@ -36,9 +36,9 @@ process.stdout.write = process.stderr.write = common.mustNotCall();
 // Make sure that the "Console" function exists.
 assert.strictEqual(typeof Console, 'function');
 
-assert.strictEqual(requiredConsole, global.console);
+assert.strictEqual(requiredConsole, globalThis.console);
 // Make sure the custom instanceof of Console works
-assert.ok(global.console instanceof Console);
+assert.ok(globalThis.console instanceof Console);
 assert.ok(!({} instanceof Console));
 
 // Make sure that the Console constructor throws
diff --git a/test/parallel/test-console-self-assign.js b/test/parallel/test-console-self-assign.js
index 53c54ab9a327cf..46f9bc93d4f2bf 100644
--- a/test/parallel/test-console-self-assign.js
+++ b/test/parallel/test-console-self-assign.js
@@ -3,4 +3,4 @@
 require('../common');
 
 // Assigning to itself should not throw.
-global.console = global.console; // eslint-disable-line no-self-assign
+globalThis.console = globalThis.console; // eslint-disable-line no-self-assign
diff --git a/test/parallel/test-crypto-dh-leak.js b/test/parallel/test-crypto-dh-leak.js
index 3b5051feb43cd8..df1ba89737c619 100644
--- a/test/parallel/test-crypto-dh-leak.js
+++ b/test/parallel/test-crypto-dh-leak.js
@@ -22,7 +22,7 @@ const before = process.memoryUsage.rss();
     dh.setPrivateKey(privateKey);
   }
 }
-global.gc();
+globalThis.gc();
 const after = process.memoryUsage.rss();
 
 // RSS should stay the same, ceteris paribus, but allow for
diff --git a/test/parallel/test-domain-crypto.js b/test/parallel/test-domain-crypto.js
index e0a470bd9db515..47eb33f70aae45 100644
--- a/test/parallel/test-domain-crypto.js
+++ b/test/parallel/test-domain-crypto.js
@@ -31,7 +31,7 @@ const crypto = require('crypto');
 // Pollution of global is intentional as part of test.
 common.allowGlobals(require('domain'));
 // See https://github.com/nodejs/node/commit/d1eff9ab
-global.domain = require('domain');
+globalThis.domain = require('domain');
 
 // Should not throw a 'TypeError: undefined is not a function' exception
 crypto.randomBytes(8);
diff --git a/test/parallel/test-eventtarget-memoryleakwarning.js b/test/parallel/test-eventtarget-memoryleakwarning.js
index 2c907165d865d9..2ec48720c8a8c5 100644
--- a/test/parallel/test-eventtarget-memoryleakwarning.js
+++ b/test/parallel/test-eventtarget-memoryleakwarning.js
@@ -103,7 +103,7 @@ common.expectWarning({
       });
 
       await setTimeout(0);
-      global.gc();
+      globalThis.gc();
     }
   })().then(common.mustCall(), common.mustNotCall());
 }
diff --git a/test/parallel/test-eventtarget.js b/test/parallel/test-eventtarget.js
index cbe7eb3b0e8687..7153da172c1cf6 100644
--- a/test/parallel/test-eventtarget.js
+++ b/test/parallel/test-eventtarget.js
@@ -683,7 +683,7 @@ let asyncTest = Promise.resolve();
   const et = new EventTarget();
   et.addEventListener('foo', common.mustNotCall(), { [kWeakHandler]: {} });
   setImmediate(() => {
-    global.gc();
+    globalThis.gc();
     et.dispatchEvent(new Event('foo'));
   });
 }
diff --git a/test/parallel/test-finalization-registry-shutdown.js b/test/parallel/test-finalization-registry-shutdown.js
index f896aa2f285c75..e288d8fecca7e6 100644
--- a/test/parallel/test-finalization-registry-shutdown.js
+++ b/test/parallel/test-finalization-registry-shutdown.js
@@ -19,5 +19,5 @@ process.on('exit', () => {
   // This is the final chance to execute JavaScript.
   register();
   // Queue a FinalizationRegistryCleanupTask by a testing gc request.
-  global.gc();
+  globalThis.gc();
 });
diff --git a/test/parallel/test-fs-filehandle.js b/test/parallel/test-fs-filehandle.js
index 818a3824904431..bcb62da9e4c2cc 100644
--- a/test/parallel/test-fs-filehandle.js
+++ b/test/parallel/test-fs-filehandle.js
@@ -35,6 +35,6 @@ common.expectWarning({
   'DeprecationWarning': [[deprecationWarning, 'DEP0137']]
 });
 
-global.gc();
+globalThis.gc();
 
 setTimeout(() => {}, 10);
diff --git a/test/parallel/test-fs-promises-file-handle-close.js b/test/parallel/test-fs-promises-file-handle-close.js
index d6417964746720..288bc31ea0ada5 100644
--- a/test/parallel/test-fs-promises-file-handle-close.js
+++ b/test/parallel/test-fs-promises-file-handle-close.js
@@ -32,7 +32,7 @@ doOpen().then(common.mustCall((fd) => {
 })).then(common.mustCall(() => {
   setImmediate(() => {
     // The FileHandle should be out-of-scope and no longer accessed now.
-    global.gc();
+    globalThis.gc();
 
     // Wait an extra event loop turn, as the warning is emitted from the
     // native layer in an unref()'ed setImmediate() callback.
diff --git a/test/parallel/test-fs-write-reuse-callback.js b/test/parallel/test-fs-write-reuse-callback.js
index 82c772ab340fed..c80902e54103fc 100644
--- a/test/parallel/test-fs-write-reuse-callback.js
+++ b/test/parallel/test-fs-write-reuse-callback.js
@@ -20,7 +20,7 @@ let done = 0;
 
 const ondone = common.mustSucceed(() => {
   if (++done < writes) {
-    if (done % 25 === 0) global.gc();
+    if (done % 25 === 0) globalThis.gc();
     setImmediate(write);
   } else {
     assert.strictEqual(
diff --git a/test/parallel/test-fs-write.js b/test/parallel/test-fs-write.js
index a4aeb4e16a748f..82f3425de2aa16 100644
--- a/test/parallel/test-fs-write.js
+++ b/test/parallel/test-fs-write.js
@@ -39,14 +39,18 @@ const {
   createExternalizableString,
   externalizeString,
   isOneByteString,
-} = global;
+} = globalThis;
+
+assert.notStrictEqual(createExternalizableString, undefined);
+assert.notStrictEqual(externalizeString, undefined);
+assert.notStrictEqual(isOneByteString, undefined);
 
 // Account for extra globals exposed by --expose_externalize_string.
 common.allowGlobals(
   createExternalizableString,
   externalizeString,
   isOneByteString,
-  global.x,
+  globalThis.x,
 );
 
 {
diff --git a/test/parallel/test-gc-http-client-connaborted.js b/test/parallel/test-gc-http-client-connaborted.js
index 93ca8ee4de59f1..e52a555d788085 100644
--- a/test/parallel/test-gc-http-client-connaborted.js
+++ b/test/parallel/test-gc-http-client-connaborted.js
@@ -53,7 +53,7 @@ setImmediate(status);
 function status() {
   if (done > 0) {
     createClients = false;
-    global.gc();
+    globalThis.gc();
     console.log(`done/collected/total: ${done}/${countGC}/${count}`);
     if (countGC === count) {
       server.close();
diff --git a/test/parallel/test-gc-net-timeout.js b/test/parallel/test-gc-net-timeout.js
index c4f74b34b79ec9..7a195c26bcdd6b 100644
--- a/test/parallel/test-gc-net-timeout.js
+++ b/test/parallel/test-gc-net-timeout.js
@@ -64,7 +64,7 @@ setImmediate(status);
 function status() {
   if (done > 0) {
     createClients = false;
-    global.gc();
+    globalThis.gc();
     console.log(`done/collected/total: ${done}/${countGC}/${count}`);
     if (countGC === count) {
       server.close();
diff --git a/test/parallel/test-gc-tls-external-memory.js b/test/parallel/test-gc-tls-external-memory.js
index dcf38e11f6c6bf..480b1086b5395e 100644
--- a/test/parallel/test-gc-tls-external-memory.js
+++ b/test/parallel/test-gc-tls-external-memory.js
@@ -27,7 +27,7 @@ connect();
 
 function connect() {
   if (runs % 64 === 0)
-    global.gc();
+    globalThis.gc();
   const externalMemoryUsage = process.memoryUsage().external;
   assert(externalMemoryUsage >= 0, `${externalMemoryUsage} < 0`);
   if (runs++ === 512) {
diff --git a/test/parallel/test-global-setters.js b/test/parallel/test-global-setters.js
index 7fd070ed8e1c4e..2da1097867261f 100644
--- a/test/parallel/test-global-setters.js
+++ b/test/parallel/test-global-setters.js
@@ -8,20 +8,20 @@ assert.strictEqual(process, _process);
 // eslint-disable-next-line no-global-assign
 process = 'asdf';
 assert.strictEqual(process, 'asdf');
-assert.strictEqual(global.process, 'asdf');
-global.process = _process;
+assert.strictEqual(globalThis.process, 'asdf');
+globalThis.process = _process;
 assert.strictEqual(process, _process);
 assert.strictEqual(
-  typeof Object.getOwnPropertyDescriptor(global, 'process').get,
+  typeof Object.getOwnPropertyDescriptor(globalThis, 'process').get,
   'function');
 
 assert.strictEqual(Buffer, _Buffer);
 // eslint-disable-next-line no-global-assign
 Buffer = 'asdf';
 assert.strictEqual(Buffer, 'asdf');
-assert.strictEqual(global.Buffer, 'asdf');
-global.Buffer = _Buffer;
+assert.strictEqual(globalThis.Buffer, 'asdf');
+globalThis.Buffer = _Buffer;
 assert.strictEqual(Buffer, _Buffer);
 assert.strictEqual(
-  typeof Object.getOwnPropertyDescriptor(global, 'Buffer').get,
+  typeof Object.getOwnPropertyDescriptor(globalThis, 'Buffer').get,
   'function');
diff --git a/test/parallel/test-global.js b/test/parallel/test-global.js
index 37f4db5252be5c..835bcc75a83e3b 100644
--- a/test/parallel/test-global.js
+++ b/test/parallel/test-global.js
@@ -60,9 +60,9 @@ for (const moduleName of builtinModules) {
     'crypto',
     'navigator',
   ];
-  assert.deepStrictEqual(new Set(Object.keys(global)), new Set(expected));
+  assert.deepStrictEqual(new Set(Object.keys(globalThis)), new Set(expected));
   expected.forEach((value) => {
-    const desc = Object.getOwnPropertyDescriptor(global, value);
+    const desc = Object.getOwnPropertyDescriptor(globalThis, value);
     if (typeof desc.value === 'function') {
       assert.strictEqual(desc.value.name, value);
     } else if (typeof desc.get === 'function') {
@@ -74,15 +74,15 @@ for (const moduleName of builtinModules) {
 common.allowGlobals('bar', 'foo');
 
 baseFoo = 'foo'; // eslint-disable-line no-undef
-global.baseBar = 'bar';
+globalThis.baseBar = 'bar';
 
-assert.strictEqual(global.baseFoo, 'foo',
-                   `x -> global.x failed: global.baseFoo = ${global.baseFoo}`);
+assert.strictEqual(globalThis.baseFoo, 'foo',
+                   `x -> globalThis.x failed: globalThis.baseFoo = ${globalThis.baseFoo}`);
 
 assert.strictEqual(baseBar, // eslint-disable-line no-undef
                    'bar',
                    // eslint-disable-next-line no-undef
-                   `global.x -> x failed: baseBar = ${baseBar}`);
+                   `globalThis.x -> x failed: baseBar = ${baseBar}`);
 
 const mod = require(fixtures.path('global', 'plain'));
 const fooBar = mod.fooBar;
@@ -91,4 +91,4 @@ assert.strictEqual(fooBar.foo, 'foo');
 
 assert.strictEqual(fooBar.bar, 'bar');
 
-assert.strictEqual(Object.prototype.toString.call(global), '[object global]');
+assert.strictEqual(Object.prototype.toString.call(globalThis), '[object global]');
diff --git a/test/parallel/test-h2leak-destroy-session-on-socket-ended.js b/test/parallel/test-h2leak-destroy-session-on-socket-ended.js
index 3f0fe3e69d924d..af692b278f7d06 100644
--- a/test/parallel/test-h2leak-destroy-session-on-socket-ended.js
+++ b/test/parallel/test-h2leak-destroy-session-on-socket-ended.js
@@ -31,8 +31,8 @@ server.on('secureConnection', (s) => {
     firstServerStream = null;
 
     setImmediate(() => {
-      global.gc();
-      global.gc();
+      globalThis.gc();
+      globalThis.gc();
 
       server.close();
     });
diff --git a/test/parallel/test-heapdump-async-hooks-init-promise.js b/test/parallel/test-heapdump-async-hooks-init-promise.js
index c59cb89baa3d18..63b26843d1254e 100644
--- a/test/parallel/test-heapdump-async-hooks-init-promise.js
+++ b/test/parallel/test-heapdump-async-hooks-init-promise.js
@@ -43,4 +43,4 @@ async_hooks.createHook({
 
 
 Promise.resolve().then(() => {});
-setImmediate(global.gc);
+setImmediate(globalThis.gc);
diff --git a/test/parallel/test-http-agent-domain-reused-gc.js b/test/parallel/test-http-agent-domain-reused-gc.js
index 35146ee688eb9b..4f12c2ede839cd 100644
--- a/test/parallel/test-http-agent-domain-reused-gc.js
+++ b/test/parallel/test-http-agent-domain-reused-gc.js
@@ -26,7 +26,7 @@ async_hooks.createHook({
   },
   before(id) {
     if (id === reusedHandleId) {
-      global.gc();
+      globalThis.gc();
       checkBeforeCalled();
     }
   }
diff --git a/test/parallel/test-http-parser-bad-ref.js b/test/parallel/test-http-parser-bad-ref.js
index 2c1bfe67485db7..e34054eca67063 100644
--- a/test/parallel/test-http-parser-bad-ref.js
+++ b/test/parallel/test-http-parser-bad-ref.js
@@ -18,7 +18,7 @@ let messagesComplete = 0;
 
 function flushPool() {
   Buffer.allocUnsafe(Buffer.poolSize - 1);
-  global.gc();
+  globalThis.gc();
 }
 
 function demoBug(part1, part2) {
diff --git a/test/parallel/test-http-server-connections-checking-leak.js b/test/parallel/test-http-server-connections-checking-leak.js
index 282c9a569fba7d..38dca83102cfea 100644
--- a/test/parallel/test-http-server-connections-checking-leak.js
+++ b/test/parallel/test-http-server-connections-checking-leak.js
@@ -20,5 +20,5 @@ for (let i = 0; i < max; i++) {
 }
 
 setImmediate(() => {
-  global.gc();
+  globalThis.gc();
 });
diff --git a/test/parallel/test-http-server-keepalive-req-gc.js b/test/parallel/test-http-server-keepalive-req-gc.js
index 3bfb6c9600cc24..c827cd19ad7222 100644
--- a/test/parallel/test-http-server-keepalive-req-gc.js
+++ b/test/parallel/test-http-server-keepalive-req-gc.js
@@ -16,8 +16,8 @@ const server = createServer(common.mustCall((req, res) => {
   req.on('end', common.mustCall(() => {
     setImmediate(async () => {
       client.end();
-      await global.gc({ type: 'major', execution: 'async' });
-      await global.gc({ type: 'major', execution: 'async' });
+      await globalThis.gc({ type: 'major', execution: 'async' });
+      await globalThis.gc({ type: 'major', execution: 'async' });
     });
   }));
   res.end('hello world');
diff --git a/test/parallel/test-http2-createwritereq.js b/test/parallel/test-http2-createwritereq.js
index 3015ad6c642801..6d2b07d5849ad0 100644
--- a/test/parallel/test-http2-createwritereq.js
+++ b/test/parallel/test-http2-createwritereq.js
@@ -69,7 +69,7 @@ server.listen(0, common.mustCall(function() {
     req.destroy = function(...args) {
       // Schedule a garbage collection event at the end of the current
       // MakeCallback() run.
-      process.nextTick(global.gc);
+      process.nextTick(globalThis.gc);
       return origDestroy.call(this, ...args);
     };
 
diff --git a/test/parallel/test-http2-session-gc-while-write-scheduled.js b/test/parallel/test-http2-session-gc-while-write-scheduled.js
index 62379f7d7ed678..9693ded17c0a18 100644
--- a/test/parallel/test-http2-session-gc-while-write-scheduled.js
+++ b/test/parallel/test-http2-session-gc-while-write-scheduled.js
@@ -23,6 +23,6 @@ const tick = require('../common/tick');
     // This schedules a write.
     client.settings(http2.getDefaultSettings());
     client = null;
-    global.gc();
+    globalThis.gc();
   });
 }
diff --git a/test/parallel/test-http2-write-finishes-after-stream-destroy.js b/test/parallel/test-http2-write-finishes-after-stream-destroy.js
index ed8833fdb926b1..bf9de8f9291917 100644
--- a/test/parallel/test-http2-write-finishes-after-stream-destroy.js
+++ b/test/parallel/test-http2-write-finishes-after-stream-destroy.js
@@ -9,7 +9,7 @@ const { duplexPair } = require('stream');
 
 // Make sure the Http2Stream destructor works, since we don't clean the
 // stream up like we would otherwise do.
-process.on('exit', global.gc);
+process.on('exit', globalThis.gc);
 
 {
   const [ clientSide, serverSide ] = duplexPair();
diff --git a/test/parallel/test-https-server-connections-checking-leak.js b/test/parallel/test-https-server-connections-checking-leak.js
index e920c8e403705f..f79149ef70a9ab 100644
--- a/test/parallel/test-https-server-connections-checking-leak.js
+++ b/test/parallel/test-https-server-connections-checking-leak.js
@@ -25,5 +25,5 @@ for (let i = 0; i < max; i++) {
 }
 
 setImmediate(() => {
-  global.gc();
+  globalThis.gc();
 });
diff --git a/test/parallel/test-inspector-scriptparsed-context.js b/test/parallel/test-inspector-scriptparsed-context.js
index bd86ba53d4c986..31ae896c818b82 100644
--- a/test/parallel/test-inspector-scriptparsed-context.js
+++ b/test/parallel/test-inspector-scriptparsed-context.js
@@ -8,8 +8,8 @@ const script = `
   'use strict';
   const assert = require('assert');
   const vm = require('vm');
-  global.outer = true;
-  global.inner = false;
+  globalThis.outer = true;
+  globalThis.inner = false;
   const context = vm.createContext({
     outer: false,
     inner: true
diff --git a/test/parallel/test-inspector-vm-global-accessors-getter-sideeffect.js b/test/parallel/test-inspector-vm-global-accessors-getter-sideeffect.js
index 8b367e98c37f49..89414e50346871 100644
--- a/test/parallel/test-inspector-vm-global-accessors-getter-sideeffect.js
+++ b/test/parallel/test-inspector-vm-global-accessors-getter-sideeffect.js
@@ -14,7 +14,7 @@ session.connect();
 
 const context = vm.createContext({
   get a() {
-    global.foo = '1';
+    globalThis.foo = '1';
     return 100;
   }
 });
diff --git a/test/parallel/test-module-relative-lookup.js b/test/parallel/test-module-relative-lookup.js
index 675c12c541fd4d..76af2b3b30c2e0 100644
--- a/test/parallel/test-module-relative-lookup.js
+++ b/test/parallel/test-module-relative-lookup.js
@@ -2,7 +2,7 @@
 
 const common = require('../common');
 const assert = require('assert');
-const _module = require('module'); // Avoid collision with global.module
+const _module = require('module'); // Avoid collision with globalThis.module
 
 // Current directory gets highest priority for local modules
 function testFirstInPath(moduleName, isLocalModule) {
diff --git a/test/parallel/test-net-connect-memleak.js b/test/parallel/test-net-connect-memleak.js
index 84f643746838b6..079e45f7223a8b 100644
--- a/test/parallel/test-net-connect-memleak.js
+++ b/test/parallel/test-net-connect-memleak.js
@@ -49,7 +49,7 @@ const gcListener = { ongc() { collected = true; } };
 }
 
 function done(sock) {
-  global.gc();
+  globalThis.gc();
   setImmediate(() => {
     assert.strictEqual(collected, true);
     sock.end();
diff --git a/test/parallel/test-net-write-fully-async-buffer.js b/test/parallel/test-net-write-fully-async-buffer.js
index 0dddb51bd76ade..042dd79cb03127 100644
--- a/test/parallel/test-net-write-fully-async-buffer.js
+++ b/test/parallel/test-net-write-fully-async-buffer.js
@@ -23,7 +23,7 @@ const server = net.createServer(common.mustCall(function(conn) {
       }
 
       while (conn.write(Buffer.from(data)));
-      global.gc({ type: 'minor' });
+      globalThis.gc({ type: 'minor' });
       // The buffer allocated above should still be alive.
     }
 
diff --git a/test/parallel/test-net-write-fully-async-hex-string.js b/test/parallel/test-net-write-fully-async-hex-string.js
index 37b5cd75c1385c..b80b09f3244585 100644
--- a/test/parallel/test-net-write-fully-async-hex-string.js
+++ b/test/parallel/test-net-write-fully-async-hex-string.js
@@ -21,7 +21,7 @@ const server = net.createServer(common.mustCall(function(conn) {
       }
 
       while (conn.write(data, 'hex'));
-      global.gc({ type: 'minor' });
+      globalThis.gc({ type: 'minor' });
       // The buffer allocated inside the .write() call should still be alive.
     }
 
diff --git a/test/parallel/test-performance-gc.js b/test/parallel/test-performance-gc.js
index 9c4a3a850a22dd..9dddf7207f59d2 100644
--- a/test/parallel/test-performance-gc.js
+++ b/test/parallel/test-performance-gc.js
@@ -40,7 +40,7 @@ const kinds = [
     obs.disconnect();
   }));
   obs.observe({ entryTypes: ['gc'] });
-  global.gc();
+  globalThis.gc();
   // Keep the event loop alive to witness the GC async callback happen.
   setImmediate(() => setImmediate(() => 0));
 }
@@ -51,6 +51,6 @@ const kinds = [
   process.on('beforeExit', () => {
     assert(!didCall);
     didCall = true;
-    global.gc();
+    globalThis.gc();
   });
 }
diff --git a/test/parallel/test-primitive-timer-leak.js b/test/parallel/test-primitive-timer-leak.js
index d590a0347b9cac..a0fe2765e1282d 100644
--- a/test/parallel/test-primitive-timer-leak.js
+++ b/test/parallel/test-primitive-timer-leak.js
@@ -5,7 +5,7 @@ const { onGC } = require('../common/gc');
 
 // See https://github.com/nodejs/node/issues/53335
 const poller = setInterval(() => {
-  global.gc();
+  globalThis.gc();
 }, 100);
 
 let count = 0;
diff --git a/test/parallel/test-repl-autolibs.js b/test/parallel/test-repl-autolibs.js
index 5cf3b1497221d0..a1eb476ef530b1 100644
--- a/test/parallel/test-repl-autolibs.js
+++ b/test/parallel/test-repl-autolibs.js
@@ -41,7 +41,7 @@ function test1() {
       assert.strictEqual(data,
                          `${util.inspect(require('fs'), null, 2, false)}\n`);
       // Globally added lib matches required lib
-      assert.strictEqual(global.fs, require('fs'));
+      assert.strictEqual(globalThis.fs, require('fs'));
       test2();
     }
   };
@@ -58,11 +58,11 @@ function test2() {
       // REPL response error message
       assert.strictEqual(data, '{}\n');
       // Original value wasn't overwritten
-      assert.strictEqual(val, global.url);
+      assert.strictEqual(val, globalThis.url);
     }
   };
   const val = {};
-  global.url = val;
+  globalThis.url = val;
   common.allowGlobals(val);
   assert(!gotWrite);
   putIn.run(['url']);
diff --git a/test/parallel/test-repl-underscore.js b/test/parallel/test-repl-underscore.js
index 0f8103ce4573cd..8ce9de5563acfb 100644
--- a/test/parallel/test-repl-underscore.js
+++ b/test/parallel/test-repl-underscore.js
@@ -150,8 +150,8 @@ function testResetContextGlobal() {
   ]);
 
   // Delete globals leaked by REPL when `useGlobal` is `true`
-  delete global.module;
-  delete global.require;
+  delete globalThis.module;
+  delete globalThis.require;
 }
 
 function testError() {
diff --git a/test/parallel/test-repl-use-global.js b/test/parallel/test-repl-use-global.js
index 3457d0c5ba7210..06cda54f4d6fa2 100644
--- a/test/parallel/test-repl-use-global.js
+++ b/test/parallel/test-repl-use-global.js
@@ -20,10 +20,10 @@ const globalTest = (useGlobal, cb, output) => (err, repl) => {
 
   let str = '';
   output.on('data', (data) => (str += data));
-  global.lunch = 'tacos';
-  repl.write('global.lunch;\n');
+  globalThis.lunch = 'tacos';
+  repl.write('globalThis.lunch;\n');
   repl.close();
-  delete global.lunch;
+  delete globalThis.lunch;
   cb(null, str.trim());
 };
 
diff --git a/test/parallel/test-repl.js b/test/parallel/test-repl.js
index d6c1cd6a9a7d6a..6c16d2a9679b21 100644
--- a/test/parallel/test-repl.js
+++ b/test/parallel/test-repl.js
@@ -36,7 +36,7 @@ const prompt_tcp = 'node via TCP socket> ';
 const moduleFilename = fixtures.path('a');
 
 // Function for REPL to run
-global.invoke_me = function(arg) {
+globalThis.invoke_me = function(arg) {
   return `invoked ${arg}`;
 };
 
@@ -939,8 +939,8 @@ alternatively use dynamic import: const { default: alias, namedExport } = await
 
     socket.end();
   }
-  common.allowGlobals(global.invoke_me, global.message, global.a, global.blah,
-                      global.I, global.f, global.path, global.x, global.name, global.foo);
+  common.allowGlobals(globalThis.invoke_me, globalThis.message, globalThis.a, globalThis.blah,
+                      globalThis.I, globalThis.f, globalThis.path, globalThis.x, globalThis.name, globalThis.foo);
 })().then(common.mustCall());
 
 function startTCPRepl() {
diff --git a/test/parallel/test-runner-mock-timers.js b/test/parallel/test-runner-mock-timers.js
index 87b8ba7e3784d2..da7458b4c46dd3 100644
--- a/test/parallel/test-runner-mock-timers.js
+++ b/test/parallel/test-runner-mock-timers.js
@@ -69,7 +69,7 @@ describe('Mock Timers Test Suite', () => {
           'clearImmediate',
         ];
 
-        const globalTimersDescriptors = timers.map((fn) => getDescriptor(global, fn));
+        const globalTimersDescriptors = timers.map((fn) => getDescriptor(globalThis, fn));
         const nodeTimersDescriptors = timers.map((fn) => getDescriptor(nodeTimers, fn));
         const nodeTimersPromisesDescriptors = timers
           .filter((fn) => !fn.includes('clear'))
@@ -116,7 +116,7 @@ describe('Mock Timers Test Suite', () => {
     it('should reset all timers when calling .reset function', (t) => {
       t.mock.timers.enable();
       const fn = t.mock.fn();
-      global.setTimeout(fn, 1000);
+      globalThis.setTimeout(fn, 1000);
       t.mock.timers.reset();
       assert.deepStrictEqual(Date.now, globalThis.Date.now);
       assert.throws(() => {
@@ -131,7 +131,7 @@ describe('Mock Timers Test Suite', () => {
     it('should reset all timers when calling Symbol.dispose', (t) => {
       t.mock.timers.enable();
       const fn = t.mock.fn();
-      global.setTimeout(fn, 1000);
+      globalThis.setTimeout(fn, 1000);
       // TODO(benjamingr) refactor to `using`
       t.mock.timers[Symbol.dispose]();
       assert.throws(() => {
@@ -148,8 +148,8 @@ describe('Mock Timers Test Suite', () => {
       const order = [];
       const fn1 = t.mock.fn(() => order.push('f1'));
       const fn2 = t.mock.fn(() => order.push('f2'));
-      global.setTimeout(fn1, 1000);
-      global.setTimeout(fn2, 1000);
+      globalThis.setTimeout(fn1, 1000);
+      globalThis.setTimeout(fn2, 1000);
       t.mock.timers.tick(1000);
       assert.strictEqual(fn1.mock.callCount(), 1);
       assert.strictEqual(fn2.mock.callCount(), 1);
@@ -170,11 +170,11 @@ describe('Mock Timers Test Suite', () => {
         const intervalFn = t.mock.fn();
 
         t.mock.timers.enable();
-        global.setTimeout(timeoutFn, 1111);
-        const id = global.setInterval(intervalFn, 9999);
+        globalThis.setTimeout(timeoutFn, 1111);
+        const id = globalThis.setInterval(intervalFn, 9999);
         t.mock.timers.runAll();
 
-        global.clearInterval(id);
+        globalThis.clearInterval(id);
         assert.strictEqual(timeoutFn.mock.callCount(), 1);
         assert.strictEqual(intervalFn.mock.callCount(), 1);
       });
@@ -184,11 +184,11 @@ describe('Mock Timers Test Suite', () => {
         const intervalFn = t.mock.fn();
 
         t.mock.timers.enable();
-        global.setTimeout(timeoutFn, 1111);
-        const id = global.setInterval(intervalFn, 9999);
+        globalThis.setTimeout(timeoutFn, 1111);
+        const id = globalThis.setInterval(intervalFn, 9999);
         t.mock.timers.runAll();
 
-        global.clearInterval(id);
+        globalThis.clearInterval(id);
         assert.strictEqual(timeoutFn.mock.callCount(), 1);
         assert.strictEqual(intervalFn.mock.callCount(), 1);
         assert.strictEqual(Date.now(), 9999);
@@ -209,7 +209,7 @@ describe('Mock Timers Test Suite', () => {
 
         const fn = mock.fn();
 
-        global.setTimeout(fn, 4000);
+        globalThis.setTimeout(fn, 4000);
 
         mock.timers.tick(4000);
         assert.strictEqual(fn.mock.callCount(), 1);
@@ -220,7 +220,7 @@ describe('Mock Timers Test Suite', () => {
         t.mock.timers.enable({ apis: ['setTimeout'] });
         const fn = t.mock.fn();
 
-        global.setTimeout(fn, 2000);
+        globalThis.setTimeout(fn, 2000);
 
         t.mock.timers.tick(1000);
         assert.strictEqual(fn.mock.callCount(), 0);
@@ -234,7 +234,7 @@ describe('Mock Timers Test Suite', () => {
         t.mock.timers.enable({ apis: ['setTimeout'] });
         const fn = t.mock.fn();
         const args = ['a', 'b', 'c'];
-        global.setTimeout(fn, 2000, ...args);
+        globalThis.setTimeout(fn, 2000, ...args);
 
         t.mock.timers.tick(1000);
         t.mock.timers.tick(500);
@@ -248,7 +248,7 @@ describe('Mock Timers Test Suite', () => {
         const now = Date.now();
         const timeout = 2;
         const expected = () => now - timeout;
-        global.setTimeout(common.mustCall(() => {
+        globalThis.setTimeout(common.mustCall(() => {
           assert.strictEqual(now - timeout, expected());
           done();
         }), timeout);
@@ -257,7 +257,7 @@ describe('Mock Timers Test Suite', () => {
       it('should change timeout to 1ms when it is > TIMEOUT_MAX', (t) => {
         t.mock.timers.enable({ apis: ['setTimeout'] });
         const fn = t.mock.fn();
-        global.setTimeout(fn, TIMEOUT_MAX + 1);
+        globalThis.setTimeout(fn, TIMEOUT_MAX + 1);
         t.mock.timers.tick(1);
         assert.strictEqual(fn.mock.callCount(), 1);
       });
@@ -265,7 +265,7 @@ describe('Mock Timers Test Suite', () => {
       it('should change the delay to one if timeout < 0', (t) => {
         t.mock.timers.enable({ apis: ['setTimeout'] });
         const fn = t.mock.fn();
-        global.setTimeout(fn, -1);
+        globalThis.setTimeout(fn, -1);
         t.mock.timers.tick(1);
         assert.strictEqual(fn.mock.callCount(), 1);
       });
@@ -277,8 +277,8 @@ describe('Mock Timers Test Suite', () => {
 
         const fn = mock.fn();
 
-        const id = global.setTimeout(fn, 4000);
-        global.clearTimeout(id);
+        const id = globalThis.setTimeout(fn, 4000);
+        globalThis.clearTimeout(id);
         t.mock.timers.tick(4000);
 
         assert.strictEqual(fn.mock.callCount(), 0);
@@ -297,13 +297,13 @@ describe('Mock Timers Test Suite', () => {
         t.mock.timers.enable({ apis: ['setInterval'] });
         const fn = t.mock.fn();
 
-        const id = global.setInterval(fn, 200);
+        const id = globalThis.setInterval(fn, 200);
 
         t.mock.timers.tick(200);
         t.mock.timers.tick(200);
         t.mock.timers.tick(200);
 
-        global.clearInterval(id);
+        globalThis.clearInterval(id);
 
         assert.strictEqual(fn.mock.callCount(), 3);
       });
@@ -312,13 +312,13 @@ describe('Mock Timers Test Suite', () => {
         t.mock.timers.enable({ apis: ['setInterval'] });
         const fn = t.mock.fn();
         const args = ['a', 'b', 'c'];
-        const id = global.setInterval(fn, 200, ...args);
+        const id = globalThis.setInterval(fn, 200, ...args);
 
         t.mock.timers.tick(200);
         t.mock.timers.tick(200);
         t.mock.timers.tick(200);
 
-        global.clearInterval(id);
+        globalThis.clearInterval(id);
 
         assert.strictEqual(fn.mock.callCount(), 3);
         assert.deepStrictEqual(fn.mock.calls[0].arguments, args);
@@ -332,8 +332,8 @@ describe('Mock Timers Test Suite', () => {
         t.mock.timers.enable({ apis: ['setInterval'] });
 
         const fn = mock.fn();
-        const id = global.setInterval(fn, 200);
-        global.clearInterval(id);
+        const id = globalThis.setInterval(fn, 200);
+        globalThis.clearInterval(id);
         t.mock.timers.tick(200);
 
         assert.strictEqual(fn.mock.callCount(), 0);
@@ -352,7 +352,7 @@ describe('Mock Timers Test Suite', () => {
         const now = Date.now();
         const timeout = 2;
         const expected = () => now - timeout;
-        global.setImmediate(common.mustCall(() => {
+        globalThis.setImmediate(common.mustCall(() => {
           assert.strictEqual(now - timeout, expected());
           done();
         }));
@@ -362,7 +362,7 @@ describe('Mock Timers Test Suite', () => {
         t.mock.timers.enable({ apis: ['setImmediate'] });
         const fn = t.mock.fn();
         const args = ['a', 'b', 'c'];
-        global.setImmediate(fn, ...args);
+        globalThis.setImmediate(fn, ...args);
         t.mock.timers.tick(9999);
 
         assert.strictEqual(fn.mock.callCount(), 1);
@@ -372,14 +372,14 @@ describe('Mock Timers Test Suite', () => {
       it('should not advance in time if clearImmediate was invoked', (t) => {
         t.mock.timers.enable({ apis: ['setImmediate'] });
 
-        const id = global.setImmediate(common.mustNotCall());
-        global.clearImmediate(id);
+        const id = globalThis.setImmediate(common.mustNotCall());
+        globalThis.clearImmediate(id);
         t.mock.timers.tick(200);
       });
 
       it('should advance in time and trigger timers when calling the .tick function', (t) => {
         t.mock.timers.enable({ apis: ['setImmediate'] });
-        global.setImmediate(common.mustCall(1));
+        globalThis.setImmediate(common.mustCall(1));
         t.mock.timers.tick(0);
       });
 
@@ -389,8 +389,8 @@ describe('Mock Timers Test Suite', () => {
         const fn1 = t.mock.fn(common.mustCall(() => order.push('f1'), 1));
         const fn2 = t.mock.fn(common.mustCall(() => order.push('f2'), 1));
 
-        global.setImmediate(fn1);
-        global.setImmediate(fn2);
+        globalThis.setImmediate(fn1);
+        globalThis.setImmediate(fn2);
 
         t.mock.timers.tick(0);
 
@@ -403,8 +403,8 @@ describe('Mock Timers Test Suite', () => {
         const fn1 = t.mock.fn(common.mustCall(() => order.push('f1'), 1));
         const fn2 = t.mock.fn(common.mustCall(() => order.push('f2'), 1));
 
-        global.setTimeout(fn2, 0);
-        global.setImmediate(fn1);
+        globalThis.setTimeout(fn2, 0);
+        globalThis.setImmediate(fn1);
 
         t.mock.timers.tick(100);
 
diff --git a/test/parallel/test-timers-api-refs.js b/test/parallel/test-timers-api-refs.js
index 3c55a05ac4c20a..a6a541963110bb 100644
--- a/test/parallel/test-timers-api-refs.js
+++ b/test/parallel/test-timers-api-refs.js
@@ -4,12 +4,12 @@ const timers = require('timers');
 
 // Delete global APIs to make sure they're not relied on by the internal timers
 // code
-delete global.setTimeout;
-delete global.clearTimeout;
-delete global.setInterval;
-delete global.clearInterval;
-delete global.setImmediate;
-delete global.clearImmediate;
+delete globalThis.setTimeout;
+delete globalThis.clearTimeout;
+delete globalThis.setInterval;
+delete globalThis.clearInterval;
+delete globalThis.setImmediate;
+delete globalThis.clearImmediate;
 
 const timeoutCallback = () => { timers.clearTimeout(timeout); };
 const timeout = timers.setTimeout(common.mustCall(timeoutCallback), 1);
diff --git a/test/parallel/test-timers-process-tampering.js b/test/parallel/test-timers-process-tampering.js
index 766cc9f3560c82..8632e7c96fa086 100644
--- a/test/parallel/test-timers-process-tampering.js
+++ b/test/parallel/test-timers-process-tampering.js
@@ -3,6 +3,6 @@
 
 'use strict';
 const common = require('../common');
-global.process = {};  // Boom!
-common.allowGlobals(global.process);
+globalThis.process = {};  // Boom!
+common.allowGlobals(globalThis.process);
 setImmediate(common.mustCall());
diff --git a/test/parallel/test-tls-connect-memleak.js b/test/parallel/test-tls-connect-memleak.js
index 5bdcbe89f785f6..7b9cb71d8df0ba 100644
--- a/test/parallel/test-tls-connect-memleak.js
+++ b/test/parallel/test-tls-connect-memleak.js
@@ -57,7 +57,7 @@ const gcListener = { ongc() { collected = true; } };
 }
 
 function done(sock) {
-  global.gc();
+  globalThis.gc();
   setImmediate(() => {
     assert.strictEqual(collected, true);
     sock.end();
diff --git a/test/parallel/test-tls-securepair-leak.js b/test/parallel/test-tls-securepair-leak.js
index 98bdcde76ec034..e3d5c2cdf37b5d 100644
--- a/test/parallel/test-tls-securepair-leak.js
+++ b/test/parallel/test-tls-securepair-leak.js
@@ -17,7 +17,7 @@ const before = process.memoryUsage().external;
     createSecurePair(context, false, false, false, options).destroy();
 }
 setImmediate(() => {
-  global.gc();
+  globalThis.gc();
   const after = process.memoryUsage().external;
 
   // It's not an exact science but a SecurePair grows .external by about 45 KiB.
diff --git a/test/parallel/test-tls-transport-destroy-after-own-gc.js b/test/parallel/test-tls-transport-destroy-after-own-gc.js
index 17c494ca0b79d1..bcac2c6ebde2b8 100644
--- a/test/parallel/test-tls-transport-destroy-after-own-gc.js
+++ b/test/parallel/test-tls-transport-destroy-after-own-gc.js
@@ -19,11 +19,11 @@ let clientTLSHandle = clientTLS._handle;  // eslint-disable-line no-unused-vars
 
 setImmediate(() => {
   clientTLS = null;
-  global.gc();
+  globalThis.gc();
   clientTLSHandle = null;
-  global.gc();
+  globalThis.gc();
   setImmediate(() => {
     clientSide = null;
-    global.gc();
+    globalThis.gc();
   });
 });
diff --git a/test/parallel/test-trace-events-api.js b/test/parallel/test-trace-events-api.js
index 8792a40cf00c80..9bffb3b78c4ba3 100644
--- a/test/parallel/test-trace-events-api.js
+++ b/test/parallel/test-trace-events-api.js
@@ -109,7 +109,7 @@ if (isChild) {
       assert.strictEqual(getEnabledCategories(), 'abc');
       tracing3 = undefined;
     }
-    global.gc();
+    globalThis.gc();
     assert.strictEqual(getEnabledCategories(), 'abc');
     // Not able to disable the thing after this point, however.
   }
diff --git a/test/parallel/test-util-format.js b/test/parallel/test-util-format.js
index 8d2cab5a9c7a1c..6f222d0fea0fb8 100644
--- a/test/parallel/test-util-format.js
+++ b/test/parallel/test-util-format.js
@@ -197,9 +197,9 @@ assert.strictEqual(util.format('%s', -Infinity), '-Infinity');
     util.format('%s', Object.setPrototypeOf(new Foo(), null)),
     '[Foo: null prototype] {}'
   );
-  global.Foo = Foo;
+  globalThis.Foo = Foo;
   assert.strictEqual(util.format('%s', new Foo()), 'Bar');
-  delete global.Foo;
+  delete globalThis.Foo;
   class Bar { abc = true; }
   assert.strictEqual(util.format('%s', new Bar()), 'Bar { abc: true }');
   class Foobar extends Array { aaa = true; }
diff --git a/test/parallel/test-util-inspect.js b/test/parallel/test-util-inspect.js
index 87d92369b8deca..2dc263443481a0 100644
--- a/test/parallel/test-util-inspect.js
+++ b/test/parallel/test-util-inspect.js
@@ -1267,9 +1267,9 @@ if (typeof Symbol !== 'undefined') {
 // a bonafide native Promise.
 {
   const oldPromise = Promise;
-  global.Promise = function() { this.bar = 42; };
+  globalThis.Promise = function() { this.bar = 42; };
   assert.strictEqual(util.inspect(new Promise()), '{ bar: 42 }');
-  global.Promise = oldPromise;
+  globalThis.Promise = oldPromise;
 }
 
 // Test Map iterators.
@@ -3183,7 +3183,7 @@ assert.strictEqual(
   }
 
   // Consistency check.
-  assert(fullObjectGraph(global).has(Function.prototype));
+  assert(fullObjectGraph(globalThis).has(Function.prototype));
 }
 
 {
diff --git a/test/parallel/test-vm-basic.js b/test/parallel/test-vm-basic.js
index 93c3fbaea631ab..5687987faeb0b9 100644
--- a/test/parallel/test-vm-basic.js
+++ b/test/parallel/test-vm-basic.js
@@ -59,9 +59,9 @@ const vm = require('vm');
   const result = vm.runInThisContext(
     'vmResult = "foo"; Object.prototype.toString.call(process);'
   );
-  assert.strictEqual(global.vmResult, 'foo');
+  assert.strictEqual(globalThis.vmResult, 'foo');
   assert.strictEqual(result, '[object process]');
-  delete global.vmResult;
+  delete globalThis.vmResult;
 }
 
 // vm.runInNewContext
@@ -69,7 +69,7 @@ const vm = require('vm');
   const result = vm.runInNewContext(
     'vmResult = "foo"; typeof process;'
   );
-  assert.strictEqual(global.vmResult, undefined);
+  assert.strictEqual(globalThis.vmResult, undefined);
   assert.strictEqual(result, 'undefined');
 }
 
diff --git a/test/parallel/test-vm-create-and-run-in-context.js b/test/parallel/test-vm-create-and-run-in-context.js
index bd746cf2df7080..314ab9525743dc 100644
--- a/test/parallel/test-vm-create-and-run-in-context.js
+++ b/test/parallel/test-vm-create-and-run-in-context.js
@@ -45,6 +45,6 @@ assert.strictEqual(context.thing, 'lala');
 // Run in contextified sandbox without referencing the context
 const sandbox = { x: 1 };
 vm.createContext(sandbox);
-global.gc();
+globalThis.gc();
 vm.runInContext('x = 2', sandbox);
 // Should not crash.
diff --git a/test/parallel/test-vm-cross-context.js b/test/parallel/test-vm-cross-context.js
index b7cf1309d3689f..abdfde32a8d847 100644
--- a/test/parallel/test-vm-cross-context.js
+++ b/test/parallel/test-vm-cross-context.js
@@ -23,7 +23,7 @@
 require('../common');
 
 const vm = require('vm');
-const ctx = vm.createContext(global);
+const ctx = vm.createContext(globalThis);
 
 // Should not throw.
 vm.runInContext('!function() { var x = console.log; }()', ctx);
diff --git a/test/parallel/test-vm-global-get-own.js b/test/parallel/test-vm-global-get-own.js
index 246fcbf866b8b6..de5e0a9619af65 100644
--- a/test/parallel/test-vm-global-get-own.js
+++ b/test/parallel/test-vm-global-get-own.js
@@ -9,7 +9,7 @@ const vm = require('vm');
 // Related to:
 // - https://github.com/nodejs/node/issues/45983
 
-const global = vm.runInContext('this', vm.createContext());
+const contextGlobal = vm.runInContext('this', vm.createContext());
 
 function runAssertions(data, property, viaDefine, value1, value2, value3) {
   // Define the property for the first time
@@ -35,20 +35,20 @@ function runAssertionsOnSandbox(builder) {
 }
 
 // Assertions on: define property
-runAssertions(global, 'toto', true, 1, 2, 3);
-runAssertions(global, Symbol.for('toto'), true, 1, 2, 3);
-runAssertions(global, 'tutu', true, fun1, fun2, fun3);
-runAssertions(global, Symbol.for('tutu'), true, fun1, fun2, fun3);
-runAssertions(global, 'tyty', true, fun1, 2, 3);
-runAssertions(global, Symbol.for('tyty'), true, fun1, 2, 3);
+runAssertions(contextGlobal, 'toto', true, 1, 2, 3);
+runAssertions(contextGlobal, Symbol.for('toto'), true, 1, 2, 3);
+runAssertions(contextGlobal, 'tutu', true, fun1, fun2, fun3);
+runAssertions(contextGlobal, Symbol.for('tutu'), true, fun1, fun2, fun3);
+runAssertions(contextGlobal, 'tyty', true, fun1, 2, 3);
+runAssertions(contextGlobal, Symbol.for('tyty'), true, fun1, 2, 3);
 
 // Assertions on: direct assignment
-runAssertions(global, 'titi', false, 1, 2, 3);
-runAssertions(global, Symbol.for('titi'), false, 1, 2, 3);
-runAssertions(global, 'tata', false, fun1, fun2, fun3);
-runAssertions(global, Symbol.for('tata'), false, fun1, fun2, fun3);
-runAssertions(global, 'tztz', false, fun1, 2, 3);
-runAssertions(global, Symbol.for('tztz'), false, fun1, 2, 3);
+runAssertions(contextGlobal, 'titi', false, 1, 2, 3);
+runAssertions(contextGlobal, Symbol.for('titi'), false, 1, 2, 3);
+runAssertions(contextGlobal, 'tata', false, fun1, fun2, fun3);
+runAssertions(contextGlobal, Symbol.for('tata'), false, fun1, fun2, fun3);
+runAssertions(contextGlobal, 'tztz', false, fun1, 2, 3);
+runAssertions(contextGlobal, Symbol.for('tztz'), false, fun1, 2, 3);
 
 // Assertions on: define property from sandbox
 runAssertionsOnSandbox(
diff --git a/test/parallel/test-vm-measure-memory-lazy.js b/test/parallel/test-vm-measure-memory-lazy.js
index 513cfbc3672451..7f85f8d6ca9656 100644
--- a/test/parallel/test-vm-measure-memory-lazy.js
+++ b/test/parallel/test-vm-measure-memory-lazy.js
@@ -10,28 +10,28 @@ const vm = require('vm');
 
 expectExperimentalWarning();
 
-// Test lazy memory measurement - we will need to global.gc()
+// Test lazy memory measurement - we will need to globalThis.gc()
 // or otherwise these may not resolve.
 {
   vm.measureMemory()
     .then(common.mustCall(assertSummaryShape));
-  global.gc();
+  globalThis.gc();
 }
 
 {
   vm.measureMemory({})
     .then(common.mustCall(assertSummaryShape));
-  global.gc();
+  globalThis.gc();
 }
 
 {
   vm.measureMemory({ mode: 'summary' })
     .then(common.mustCall(assertSummaryShape));
-  global.gc();
+  globalThis.gc();
 }
 
 {
   vm.measureMemory({ mode: 'detailed' })
     .then(common.mustCall(assertSummaryShape));
-  global.gc();
+  globalThis.gc();
 }
diff --git a/test/parallel/test-vm-module-basic.js b/test/parallel/test-vm-module-basic.js
index cba1e037ac455a..53fed6536079a0 100644
--- a/test/parallel/test-vm-module-basic.js
+++ b/test/parallel/test-vm-module-basic.js
@@ -37,15 +37,15 @@ const util = require('util');
 
 (async () => {
   const m = new SourceTextModule(`
-    global.vmResultFoo = "foo";
-    global.vmResultTypeofProcess = Object.prototype.toString.call(process);
+    globalThis.vmResultFoo = "foo";
+    globalThis.vmResultTypeofProcess = Object.prototype.toString.call(process);
   `);
   await m.link(common.mustNotCall());
   await m.evaluate();
-  assert.strictEqual(global.vmResultFoo, 'foo');
-  assert.strictEqual(global.vmResultTypeofProcess, '[object process]');
-  delete global.vmResultFoo;
-  delete global.vmResultTypeofProcess;
+  assert.strictEqual(globalThis.vmResultFoo, 'foo');
+  assert.strictEqual(globalThis.vmResultTypeofProcess, '[object process]');
+  delete globalThis.vmResultFoo;
+  delete globalThis.vmResultTypeofProcess;
 })().then(common.mustCall());
 
 (async () => {
diff --git a/test/parallel/test-vm-new-script-new-context.js b/test/parallel/test-vm-new-script-new-context.js
index 482b4130d615d9..b4221d81d98dcb 100644
--- a/test/parallel/test-vm-new-script-new-context.js
+++ b/test/parallel/test-vm-new-script-new-context.js
@@ -49,43 +49,43 @@ const Script = require('vm').Script;
 }
 
 {
-  global.hello = 5;
+  globalThis.hello = 5;
   const script = new Script('hello = 2');
   script.runInNewContext();
-  assert.strictEqual(global.hello, 5);
+  assert.strictEqual(globalThis.hello, 5);
 
   // Cleanup
-  delete global.hello;
+  delete globalThis.hello;
 }
 
 {
-  global.code = 'foo = 1;' +
+  globalThis.code = 'foo = 1;' +
                 'bar = 2;' +
                 'if (baz !== 3) throw new Error(\'test fail\');';
-  global.foo = 2;
-  global.obj = { foo: 0, baz: 3 };
-  const script = new Script(global.code);
+  globalThis.foo = 2;
+  globalThis.obj = { foo: 0, baz: 3 };
+  const script = new Script(globalThis.code);
   /* eslint-disable no-unused-vars */
-  const baz = script.runInNewContext(global.obj);
+  const baz = script.runInNewContext(globalThis.obj);
   /* eslint-enable no-unused-vars */
-  assert.strictEqual(global.obj.foo, 1);
-  assert.strictEqual(global.obj.bar, 2);
-  assert.strictEqual(global.foo, 2);
+  assert.strictEqual(globalThis.obj.foo, 1);
+  assert.strictEqual(globalThis.obj.bar, 2);
+  assert.strictEqual(globalThis.foo, 2);
 
   // cleanup
-  delete global.code;
-  delete global.foo;
-  delete global.obj;
+  delete globalThis.code;
+  delete globalThis.foo;
+  delete globalThis.obj;
 }
 
 {
   const script = new Script('f()');
-  function changeFoo() { global.foo = 100; }
+  function changeFoo() { globalThis.foo = 100; }
   script.runInNewContext({ f: changeFoo });
-  assert.strictEqual(global.foo, 100);
+  assert.strictEqual(globalThis.foo, 100);
 
   // cleanup
-  delete global.foo;
+  delete globalThis.foo;
 }
 
 {
diff --git a/test/parallel/test-vm-new-script-this-context.js b/test/parallel/test-vm-new-script-this-context.js
index 18f39f9086ae2a..30b220e3d4a2c2 100644
--- a/test/parallel/test-vm-new-script-this-context.js
+++ b/test/parallel/test-vm-new-script-this-context.js
@@ -35,34 +35,34 @@ assert.throws(() => {
   script.runInThisContext(script);
 }, /^Error: test$/);
 
-global.hello = 5;
+globalThis.hello = 5;
 script = new Script('hello = 2');
 script.runInThisContext(script);
-assert.strictEqual(global.hello, 2);
+assert.strictEqual(globalThis.hello, 2);
 
 
 // Pass values
-global.code = 'foo = 1;' +
+globalThis.code = 'foo = 1;' +
               'bar = 2;' +
               'if (typeof baz !== "undefined") throw new Error("test fail");';
-global.foo = 2;
-global.obj = { foo: 0, baz: 3 };
-script = new Script(global.code);
+globalThis.foo = 2;
+globalThis.obj = { foo: 0, baz: 3 };
+script = new Script(globalThis.code);
 script.runInThisContext(script);
-assert.strictEqual(global.obj.foo, 0);
-assert.strictEqual(global.bar, 2);
-assert.strictEqual(global.foo, 1);
+assert.strictEqual(globalThis.obj.foo, 0);
+assert.strictEqual(globalThis.bar, 2);
+assert.strictEqual(globalThis.foo, 1);
 
 // Call a function
-global.f = function() { global.foo = 100; };
+globalThis.f = function() { globalThis.foo = 100; };
 script = new Script('f()');
 script.runInThisContext(script);
-assert.strictEqual(global.foo, 100);
+assert.strictEqual(globalThis.foo, 100);
 
 common.allowGlobals(
-  global.hello,
-  global.code,
-  global.foo,
-  global.obj,
-  global.f
+  globalThis.hello,
+  globalThis.code,
+  globalThis.foo,
+  globalThis.obj,
+  globalThis.f
 );
diff --git a/test/parallel/test-vm-run-in-new-context.js b/test/parallel/test-vm-run-in-new-context.js
index 6e8c42812bbc88..c6f8fbf893ca9a 100644
--- a/test/parallel/test-vm-run-in-new-context.js
+++ b/test/parallel/test-vm-run-in-new-context.js
@@ -26,7 +26,7 @@ const common = require('../common');
 const assert = require('assert');
 const vm = require('vm');
 
-if (typeof global.gc !== 'function')
+if (typeof globalThis.gc !== 'function')
   assert.fail('Run this test with --expose-gc');
 
 // Run a string
@@ -38,28 +38,28 @@ assert.throws(() => {
   vm.runInNewContext('throw new Error(\'test\');');
 }, /^Error: test$/);
 
-global.hello = 5;
+globalThis.hello = 5;
 vm.runInNewContext('hello = 2');
-assert.strictEqual(global.hello, 5);
+assert.strictEqual(globalThis.hello, 5);
 
 
 // Pass values in and out
-global.code = 'foo = 1;' +
+globalThis.code = 'foo = 1;' +
               'bar = 2;' +
               'if (baz !== 3) throw new Error(\'test fail\');';
-global.foo = 2;
-global.obj = { foo: 0, baz: 3 };
+globalThis.foo = 2;
+globalThis.obj = { foo: 0, baz: 3 };
 /* eslint-disable no-unused-vars */
-const baz = vm.runInNewContext(global.code, global.obj);
+const baz = vm.runInNewContext(globalThis.code, globalThis.obj);
 /* eslint-enable no-unused-vars */
-assert.strictEqual(global.obj.foo, 1);
-assert.strictEqual(global.obj.bar, 2);
-assert.strictEqual(global.foo, 2);
+assert.strictEqual(globalThis.obj.foo, 1);
+assert.strictEqual(globalThis.obj.bar, 2);
+assert.strictEqual(globalThis.foo, 2);
 
 // Call a function by reference
-function changeFoo() { global.foo = 100; }
+function changeFoo() { globalThis.foo = 100; }
 vm.runInNewContext('f()', { f: changeFoo });
-assert.strictEqual(global.foo, 100);
+assert.strictEqual(globalThis.foo, 100);
 
 // Modify an object by reference
 const f = { a: 1 };
@@ -68,7 +68,7 @@ assert.strictEqual(f.a, 2);
 
 // Use function in context without referencing context
 const fn = vm.runInNewContext('(function() { obj.p = {}; })', { obj: {} });
-global.gc();
+globalThis.gc();
 fn();
 // Should not crash
 
@@ -93,8 +93,8 @@ for (const arg of [filename, { filename }]) {
 }
 
 common.allowGlobals(
-  global.hello,
-  global.code,
-  global.foo,
-  global.obj
+  globalThis.hello,
+  globalThis.code,
+  globalThis.foo,
+  globalThis.obj
 );
diff --git a/test/parallel/test-vm-static-this.js b/test/parallel/test-vm-static-this.js
index e9382d6c3b4c1a..f47c0b5d0d056a 100644
--- a/test/parallel/test-vm-static-this.js
+++ b/test/parallel/test-vm-static-this.js
@@ -33,9 +33,9 @@ assert.throws(function() {
   vm.runInThisContext('throw new Error(\'test\');');
 }, /test/);
 
-global.hello = 5;
+globalThis.hello = 5;
 vm.runInThisContext('hello = 2');
-assert.strictEqual(global.hello, 2);
+assert.strictEqual(globalThis.hello, 2);
 
 
 // pass values
@@ -43,23 +43,23 @@ const code = 'foo = 1;' +
              'bar = 2;' +
              'if (typeof baz !== \'undefined\')' +
              'throw new Error(\'test fail\');';
-global.foo = 2;
-global.obj = { foo: 0, baz: 3 };
+globalThis.foo = 2;
+globalThis.obj = { foo: 0, baz: 3 };
 /* eslint-disable no-unused-vars */
 const baz = vm.runInThisContext(code);
 /* eslint-enable no-unused-vars */
-assert.strictEqual(global.obj.foo, 0);
-assert.strictEqual(global.bar, 2);
-assert.strictEqual(global.foo, 1);
+assert.strictEqual(globalThis.obj.foo, 0);
+assert.strictEqual(globalThis.bar, 2);
+assert.strictEqual(globalThis.foo, 1);
 
 // call a function
-global.f = function() { global.foo = 100; };
+globalThis.f = function() { globalThis.foo = 100; };
 vm.runInThisContext('f()');
-assert.strictEqual(global.foo, 100);
+assert.strictEqual(globalThis.foo, 100);
 
 common.allowGlobals(
-  global.hello,
-  global.foo,
-  global.obj,
-  global.f
+  globalThis.hello,
+  globalThis.foo,
+  globalThis.obj,
+  globalThis.f
 );
diff --git a/test/parallel/test-webstorage.js b/test/parallel/test-webstorage.js
index 4da6b67bd2932b..7f9fe8dfa53391 100644
--- a/test/parallel/test-webstorage.js
+++ b/test/parallel/test-webstorage.js
@@ -69,7 +69,7 @@ test('sessionStorage is not persisted', async () => {
 test('localStorage throws without --localstorage-file ', async () => {
   const cp = await spawnPromisified(process.execPath, [
     '--experimental-webstorage',
-    '-pe', 'localStorage === global.localStorage',
+    '-pe', 'localStorage === globalThis.localStorage',
   ]);
   assert.strictEqual(cp.code, 1);
   assert.strictEqual(cp.signal, null);
@@ -81,7 +81,7 @@ test('localStorage is not persisted if it is unused', async () => {
   const cp = await spawnPromisified(process.execPath, [
     '--experimental-webstorage',
     '--localstorage-file', nextLocalStorage(),
-    '-pe', 'localStorage === global.localStorage',
+    '-pe', 'localStorage === globalThis.localStorage',
   ]);
   assert.strictEqual(cp.code, 0);
   assert.match(cp.stdout, /true/);
diff --git a/test/parallel/test-whatwg-url-custom-global.js b/test/parallel/test-whatwg-url-custom-global.js
index b99dfd8f3e7d94..16efdfa8df1174 100644
--- a/test/parallel/test-whatwg-url-custom-global.js
+++ b/test/parallel/test-whatwg-url-custom-global.js
@@ -6,7 +6,7 @@ require('../common');
 const assert = require('assert');
 
 assert.deepStrictEqual(
-  Object.getOwnPropertyDescriptor(global, 'URL'),
+  Object.getOwnPropertyDescriptor(globalThis, 'URL'),
   {
     value: URL,
     writable: true,
@@ -16,7 +16,7 @@ assert.deepStrictEqual(
 );
 
 assert.deepStrictEqual(
-  Object.getOwnPropertyDescriptor(global, 'URLSearchParams'),
+  Object.getOwnPropertyDescriptor(globalThis, 'URLSearchParams'),
   {
     value: URLSearchParams,
     writable: true,
diff --git a/test/parallel/test-worker-cli-options.js b/test/parallel/test-worker-cli-options.js
index 0c243d251e97bc..3e6ab46db6ea74 100644
--- a/test/parallel/test-worker-cli-options.js
+++ b/test/parallel/test-worker-cli-options.js
@@ -8,7 +8,7 @@ const CODE = `
 // If the --expose-internals flag does not pass to worker
 // require function will throw an error
 require('internal/options');
-global.gc();
+globalThis.gc();
 `;
 
 // Test if the flags is passed to worker threads correctly
diff --git a/test/parallel/test-worker-message-channel-sharedarraybuffer.js b/test/parallel/test-worker-message-channel-sharedarraybuffer.js
index 220aa978b12051..6ee577d447ec97 100644
--- a/test/parallel/test-worker-message-channel-sharedarraybuffer.js
+++ b/test/parallel/test-worker-message-channel-sharedarraybuffer.js
@@ -19,7 +19,7 @@ const { Worker } = require('worker_threads');
   `, { eval: true });
   w.on('message', common.mustCall(() => {
     assert.strictEqual(local.toString(), 'Hello world!');
-    global.gc();
+    globalThis.gc();
     w.terminate();
   }));
   w.postMessage({ sharedArrayBuffer });
diff --git a/test/parallel/test-worker-message-port-move.js b/test/parallel/test-worker-message-port-move.js
index 44efd2e6a6b94f..b8db31b88c7bc4 100644
--- a/test/parallel/test-worker-message-port-move.js
+++ b/test/parallel/test-worker-message-port-move.js
@@ -48,7 +48,7 @@ vm.runInContext('(' + function() {
   {
     let threw = false;
     try {
-      port.postMessage(global);
+      port.postMessage(globalThis);
     } catch (e) {
       assert.strictEqual(e.constructor.name, 'DOMException');
       assert(e instanceof Object);
diff --git a/test/parallel/test-worker-workerdata-sharedarraybuffer.js b/test/parallel/test-worker-workerdata-sharedarraybuffer.js
index 4e3d508ac94941..4f1b332461280f 100644
--- a/test/parallel/test-worker-workerdata-sharedarraybuffer.js
+++ b/test/parallel/test-worker-workerdata-sharedarraybuffer.js
@@ -23,7 +23,7 @@ const { Worker } = require('worker_threads');
   });
   w.on('message', common.mustCall(() => {
     assert.strictEqual(local.toString(), 'Hello world!');
-    global.gc();
+    globalThis.gc();
     w.terminate();
   }));
   w.postMessage({});
diff --git a/test/parallel/test-zlib-invalid-input-memory.js b/test/parallel/test-zlib-invalid-input-memory.js
index 9761e4bbf097d8..ac718395dae184 100644
--- a/test/parallel/test-zlib-invalid-input-memory.js
+++ b/test/parallel/test-zlib-invalid-input-memory.js
@@ -17,7 +17,7 @@ const ongc = common.mustCall();
   strm.once('error', common.mustCall((err) => {
     assert(err);
     setImmediate(() => {
-      global.gc();
+      globalThis.gc();
       // Keep the event loop alive for seeing the async_hooks destroy hook
       // we use for GC tracking...
       // TODO(addaleax): This should maybe not be necessary?
diff --git a/test/parallel/test-zlib-unused-weak.js b/test/parallel/test-zlib-unused-weak.js
index 2c1e2d729030dd..cd1ab91ceb5c4b 100644
--- a/test/parallel/test-zlib-unused-weak.js
+++ b/test/parallel/test-zlib-unused-weak.js
@@ -6,12 +6,12 @@ const zlib = require('zlib');
 
 // Tests that native zlib handles start out their life as weak handles.
 
-global.gc();
+globalThis.gc();
 const before = process.memoryUsage().external;
 for (let i = 0; i < 100; ++i)
   zlib.createGzip();
 const afterCreation = process.memoryUsage().external;
-global.gc();
+globalThis.gc();
 const afterGC = process.memoryUsage().external;
 
 assert((afterGC - before) / (afterCreation - before) <= 0.05,

From 687be594bb45a5baed588067c3d7f1159f1ea62f Mon Sep 17 00:00:00 2001
From: yamachu <yamachu.dev@gmail.com>
Date: Wed, 22 Jan 2025 20:21:46 +0900
Subject: [PATCH 14/38] test: add test that uses multibyte for path and
 resolves modules

PR-URL: https://github.com/nodejs/node/pull/56696
Fixes: https://github.com/nodejs/node/issues/56650
Refs: https://github.com/nodejs/node/pull/56657
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
---
 .../experimental.json"                        |  3 +++
 .../test-module-create-require-multibyte.js   | 24 +++++++++++++++++++
 2 files changed, 27 insertions(+)
 create mode 100644 "test/fixtures/copy/utf/\346\226\260\345\273\272\346\226\207\344\273\266\345\244\271/experimental.json"
 create mode 100644 test/parallel/test-module-create-require-multibyte.js

diff --git "a/test/fixtures/copy/utf/\346\226\260\345\273\272\346\226\207\344\273\266\345\244\271/experimental.json" "b/test/fixtures/copy/utf/\346\226\260\345\273\272\346\226\207\344\273\266\345\244\271/experimental.json"
new file mode 100644
index 00000000000000..12611d2385a5a5
--- /dev/null
+++ "b/test/fixtures/copy/utf/\346\226\260\345\273\272\346\226\207\344\273\266\345\244\271/experimental.json"
@@ -0,0 +1,3 @@
+{
+  "ofLife": 42
+}
diff --git a/test/parallel/test-module-create-require-multibyte.js b/test/parallel/test-module-create-require-multibyte.js
new file mode 100644
index 00000000000000..f9c4b6345dc59e
--- /dev/null
+++ b/test/parallel/test-module-create-require-multibyte.js
@@ -0,0 +1,24 @@
+'use strict';
+
+require('../common');
+const fixtures = require('../common/fixtures');
+const assert = require('assert');
+
+// This test ensures that the module can be resolved
+// even if the path given to createRequire contains multibyte characters.
+
+const { createRequire } = require('module');
+
+{
+  const u = fixtures.fileURL('あ.js');
+
+  const reqToo = createRequire(u);
+  assert.deepStrictEqual(reqToo('./experimental'), { ofLife: 42 });
+}
+
+{
+  const u = fixtures.fileURL('copy/utf/新建文件夹/index.js');
+
+  const reqToo = createRequire(u);
+  assert.deepStrictEqual(reqToo('./experimental'), { ofLife: 42 });
+}

From 176002400886bc7f438236c727a61831efd5e565 Mon Sep 17 00:00:00 2001
From: yamachu <yamachu.dev@gmail.com>
Date: Wed, 22 Jan 2025 20:24:38 +0900
Subject: [PATCH 15/38] src: fix to generate path from wchar_t via wstring

Take a similar approach to node_file and allow the creation of paths
code point must be specified to convert from wchar_t to utf8.

PR-URL: https://github.com/nodejs/node/pull/56696
Fixes: https://github.com/nodejs/node/issues/56650
Refs: https://github.com/nodejs/node/pull/56657
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
---
 src/node_file.cc    | 15 +--------------
 src/node_modules.cc | 24 ++++++++++++++++++++----
 src/util-inl.h      | 16 ++++++++++++++++
 3 files changed, 37 insertions(+), 18 deletions(-)

diff --git a/src/node_file.cc b/src/node_file.cc
index 984bc55ee9b941..8e29bb39887625 100644
--- a/src/node_file.cc
+++ b/src/node_file.cc
@@ -3146,21 +3146,8 @@ static void GetFormatOfExtensionlessFile(
 }
 
 #ifdef _WIN32
-std::wstring ConvertToWideString(const std::string& str) {
-  int size_needed = MultiByteToWideChar(
-      CP_UTF8, 0, &str[0], static_cast<int>(str.size()), nullptr, 0);
-  std::wstring wstrTo(size_needed, 0);
-  MultiByteToWideChar(CP_UTF8,
-                      0,
-                      &str[0],
-                      static_cast<int>(str.size()),
-                      &wstrTo[0],
-                      size_needed);
-  return wstrTo;
-}
-
 #define BufferValueToPath(str)                                                 \
-  std::filesystem::path(ConvertToWideString(str.ToString()))
+  std::filesystem::path(ConvertToWideString(str.ToString(), CP_UTF8))
 
 std::string ConvertWideToUTF8(const std::wstring& wstr) {
   if (wstr.empty()) return std::string();
diff --git a/src/node_modules.cc b/src/node_modules.cc
index 85c8e21cf026ff..38d2c65c7f3282 100644
--- a/src/node_modules.cc
+++ b/src/node_modules.cc
@@ -349,8 +349,16 @@ void BindingData::GetNearestParentPackageJSON(
     path_value_str.push_back(kPathSeparator);
   }
 
-  auto package_json =
-      TraverseParent(realm, std::filesystem::path(path_value_str));
+  std::filesystem::path path;
+
+#ifdef _WIN32
+  std::wstring wide_path = ConvertToWideString(path_value_str, GetACP());
+  path = std::filesystem::path(wide_path);
+#else
+  path = std::filesystem::path(path_value_str);
+#endif
+
+  auto package_json = TraverseParent(realm, path);
 
   if (package_json != nullptr) {
     args.GetReturnValue().Set(package_json->Serialize(realm));
@@ -375,8 +383,16 @@ void BindingData::GetNearestParentPackageJSONType(
     path_value_str.push_back(kPathSeparator);
   }
 
-  auto package_json =
-      TraverseParent(realm, std::filesystem::path(path_value_str));
+  std::filesystem::path path;
+
+#ifdef _WIN32
+  std::wstring wide_path = ConvertToWideString(path_value_str, GetACP());
+  path = std::filesystem::path(wide_path);
+#else
+  path = std::filesystem::path(path_value_str);
+#endif
+
+  auto package_json = TraverseParent(realm, path);
 
   if (package_json == nullptr) {
     return;
diff --git a/src/util-inl.h b/src/util-inl.h
index a35e15eeed6576..b5ae5950b62767 100644
--- a/src/util-inl.h
+++ b/src/util-inl.h
@@ -562,6 +562,22 @@ bool IsWindowsBatchFile(const char* filename) {
 #endif  // _WIN32
 }
 
+#ifdef _WIN32
+inline std::wstring ConvertToWideString(const std::string& str,
+                                        UINT code_page) {
+  int size_needed = MultiByteToWideChar(
+      code_page, 0, &str[0], static_cast<int>(str.size()), nullptr, 0);
+  std::wstring wstrTo(size_needed, 0);
+  MultiByteToWideChar(code_page,
+                      0,
+                      &str[0],
+                      static_cast<int>(str.size()),
+                      &wstrTo[0],
+                      size_needed);
+  return wstrTo;
+}
+#endif  // _WIN32
+
 }  // namespace node
 
 #endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

From bade7a1866618b9e46358b839fe5fdf16b1db2be Mon Sep 17 00:00:00 2001
From: tjuhaszrh <tjuhasz@redhat.com>
Date: Sat, 25 Jan 2025 10:34:54 +0100
Subject: [PATCH 16/38] src: fix build with GCC 15

Added cstdint to worker_inspector as on more recent version of gcc
the build was failing due to changes to libstdc++ and the removal
of transitive includes.

PR-URL: https://github.com/nodejs/node/pull/56740
Fixes: https://github.com/nodejs/node/issues/56731
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Chengzhong Wu <legendecas@gmail.com>
Reviewed-By: Richard Lau <rlau@redhat.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 src/inspector/worker_inspector.h | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/inspector/worker_inspector.h b/src/inspector/worker_inspector.h
index d3254d5aa0ebe4..24403bb1704c40 100644
--- a/src/inspector/worker_inspector.h
+++ b/src/inspector/worker_inspector.h
@@ -5,6 +5,7 @@
 #error("This header can only be used when inspector is enabled")
 #endif
 
+#include <cstdint>
 #include <memory>
 #include <string>
 #include <unordered_map>

From da1ca7db756c0db8a894f3b22a4d067701dc3c04 Mon Sep 17 00:00:00 2001
From: Robin Mehner <robin@coding-robin.de>
Date: Sat, 25 Jan 2025 12:02:31 +0100
Subject: [PATCH 17/38] doc: fix typo in example code for util.styleText
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Code shows how to style `errorMessage`, but then
only logs out `successMessage` twice. This might
trip people up when copying the code.

PR-URL: https://github.com/nodejs/node/pull/56720
Reviewed-By: Ulises Gascón <ulisesgascongonzalez@gmail.com>
Reviewed-By: Richard Lau <rlau@redhat.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Minwoo Jung <nodecorelab@gmail.com>
---
 doc/api/util.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/api/util.md b/doc/api/util.md
index 72a45b1cde8d11..958a49977e1a17 100644
--- a/doc/api/util.md
+++ b/doc/api/util.md
@@ -1972,7 +1972,7 @@ const errorMessage = styleText(
   // Validate if process.stderr has TTY
   { stream: stderr },
 );
-console.error(successMessage);
+console.error(errorMessage);
 ```
 
 ```cjs

From db5a2b55a59c2775f3b88f36080e51ca8069f9bd Mon Sep 17 00:00:00 2001
From: Burkov Egor <eburkov@rvision.ru>
Date: Wed, 22 Jan 2025 16:27:26 +0300
Subject: [PATCH 18/38] src: add default value for RSACipherConfig mode field
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Using default init of enum is UB

Refs: https://github.com/nodejs/node/issues/56693
PR-URL: https://github.com/nodejs/node/pull/56701
Reviewed-By: Juan José Arboleda <soyjuanarbol@gmail.com>
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 src/crypto/crypto_rsa.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/crypto/crypto_rsa.h b/src/crypto/crypto_rsa.h
index 29b259ae2f5284..6fc48da1aea2cd 100644
--- a/src/crypto/crypto_rsa.h
+++ b/src/crypto/crypto_rsa.h
@@ -77,7 +77,7 @@ struct RSAKeyExportTraits final {
 using RSAKeyExportJob = KeyExportJob<RSAKeyExportTraits>;
 
 struct RSACipherConfig final : public MemoryRetainer {
-  CryptoJobMode mode;
+  CryptoJobMode mode = kCryptoJobAsync;
   ByteSource label;
   int padding = 0;
   const EVP_MD* digest = nullptr;

From 23d0a7f80c36f238db9fd6c5575552b9a54a0f0e Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Wed, 22 Jan 2025 16:58:49 -0800
Subject: [PATCH 19/38] test: make some requires lazy in common/index

PR-URL: https://github.com/nodejs/node/pull/56715
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
Reviewed-By: Richard Lau <rlau@redhat.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 test/common/index.js | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/test/common/index.js b/test/common/index.js
index 3647f4554a4647..8113f604dfcdb6 100644
--- a/test/common/index.js
+++ b/test/common/index.js
@@ -23,7 +23,6 @@
 const process = globalThis.process;  // Some tests tamper with the process globalThis.
 
 const assert = require('assert');
-const { exec, execSync, spawn, spawnSync } = require('child_process');
 const fs = require('fs');
 const net = require('net');
 // Do not require 'os' until needed so that test-os-checked-function can
@@ -31,7 +30,6 @@ const net = require('net');
 const path = require('path');
 const { inspect, getCallSites } = require('util');
 const { isMainThread } = require('worker_threads');
-const { isModuleNamespaceObject } = require('util/types');
 
 const tmpdir = require('./tmpdir');
 const bits = ['arm64', 'loong64', 'mips', 'mipsel', 'ppc64', 'riscv64', 's390x', 'x64']
@@ -104,6 +102,7 @@ if (process.argv.length === 2 &&
         inspect(flags),
         'Use NODE_SKIP_FLAG_CHECK to run the test with the original flags.',
       );
+      const { spawnSync } = require('child_process');
       const args = [...flags, ...process.execArgv, ...process.argv.slice(1)];
       const options = { encoding: 'utf8', stdio: 'inherit' };
       const result = spawnSync(process.execPath, args, options);
@@ -232,6 +231,7 @@ function childShouldThrowAndAbort() {
     // continuous testing and developers' machines
     escapedArgs[0] = 'ulimit -c 0 && ' + escapedArgs[0];
   }
+  const { exec } = require('child_process');
   const child = exec(...escapedArgs);
   child.on('exit', function onExit(exitCode, signal) {
     const errMsg = 'Test should have aborted ' +
@@ -474,6 +474,7 @@ function canCreateSymLink() {
                                  'System32', 'whoami.exe');
 
     try {
+      const { execSync } = require('child_process');
       const output = execSync(`${whoamiPath} /priv`, { timeout: 1000 });
       return output.includes('SeCreateSymbolicLinkPrivilege');
     } catch {
@@ -780,6 +781,7 @@ function requireNoPackageJSONAbove(dir = __dirname) {
 }
 
 function spawnPromisified(...args) {
+  const { spawn } = require('child_process');
   let stderr = '';
   let stdout = '';
 
@@ -843,6 +845,7 @@ function escapePOSIXShell(cmdParts, ...args) {
  * @param {object} expectation shape of expected namespace.
  */
 function expectRequiredModule(mod, expectation, checkESModule = true) {
+  const { isModuleNamespaceObject } = require('util/types');
   const clone = { ...mod };
   if (Object.hasOwn(mod, 'default') && checkESModule) {
     assert.strictEqual(mod.__esModule, true);
@@ -920,6 +923,7 @@ const common = {
   },
 
   get inFreeBSDJail() {
+    const { execSync } = require('child_process');
     if (inFreeBSDJail !== null) return inFreeBSDJail;
 
     if (exports.isFreeBSD &&

From 59b3a8b21be9f206bf319cea50a6718c2230d09b Mon Sep 17 00:00:00 2001
From: Jonas <jonas@badalic.com>
Date: Sat, 25 Jan 2025 17:02:54 -0500
Subject: [PATCH 20/38] watch: reload env file for --env-file-if-exists

PR-URL: https://github.com/nodejs/node/pull/56643
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
---
 lib/internal/main/watch_mode.js     |  2 +-
 test/sequential/test-watch-mode.mjs | 26 ++++++++++++++++++++++++++
 2 files changed, 27 insertions(+), 1 deletion(-)

diff --git a/lib/internal/main/watch_mode.js b/lib/internal/main/watch_mode.js
index 6e2528e64737c7..60639efb45482d 100644
--- a/lib/internal/main/watch_mode.js
+++ b/lib/internal/main/watch_mode.js
@@ -33,7 +33,7 @@ markBootstrapComplete();
 // TODO(MoLow): Make kill signal configurable
 const kKillSignal = 'SIGTERM';
 const kShouldFilterModules = getOptionValue('--watch-path').length === 0;
-const kEnvFile = getOptionValue('--env-file');
+const kEnvFile = getOptionValue('--env-file') || getOptionValue('--env-file-if-exists');
 const kWatchedPaths = ArrayPrototypeMap(getOptionValue('--watch-path'), (path) => resolve(path));
 const kPreserveOutput = getOptionValue('--watch-preserve-output');
 const kCommand = ArrayPrototypeSlice(process.argv, 1);
diff --git a/test/sequential/test-watch-mode.mjs b/test/sequential/test-watch-mode.mjs
index 39bc7223dffdfc..324cdd10b3b4ef 100644
--- a/test/sequential/test-watch-mode.mjs
+++ b/test/sequential/test-watch-mode.mjs
@@ -242,6 +242,32 @@ describe('watch mode', { concurrency: !process.env.TEST_PARALLEL, timeout: 60_00
     }
   });
 
+  it('should load new env variables when --env-file-if-exists changes', async () => {
+    const envKey = `TEST_ENV_${Date.now()}`;
+    const envKey2 = `TEST_ENV_2_${Date.now()}`;
+    const jsFile = createTmpFile(`console.log('ENV: ' + process.env.${envKey} + '\\n' + 'ENV2: ' + process.env.${envKey2});`);
+    const envFile = createTmpFile(`${envKey}=value1`, '.env');
+    const { done, restart } = runInBackground({ args: ['--watch', `--env-file-if-exists=${envFile}`, jsFile] });
+
+    try {
+      await restart();
+      writeFileSync(envFile, `${envKey}=value1\n${envKey2}=newValue`);
+
+      // Second restart, after env change
+      const { stderr, stdout } = await restart();
+
+      assert.strictEqual(stderr, '');
+      assert.deepStrictEqual(stdout, [
+        `Restarting ${inspect(jsFile)}`,
+        'ENV: value1',
+        'ENV2: newValue',
+        `Completed running ${inspect(jsFile)}`,
+      ]);
+    } finally {
+      await done();
+    }
+  });
+
   it('should watch changes to a failing file', async () => {
     const file = createTmpFile('throw new Error("fails");');
     const { stderr, stdout } = await runWriteSucceed({

From 7119303a811b7f8ab5bebdaa8df4cc81f002dede Mon Sep 17 00:00:00 2001
From: Dario Piotrowicz <dario.piotrowicz@gmail.com>
Date: Sat, 25 Jan 2025 23:32:13 +0000
Subject: [PATCH 21/38] module: fix bad `require.resolve` with option paths for
 `.` and `..`

this change fixes `require.resolve` used with the `paths` option
not considering `.` and `..` as relative

Fixes: https://github.com/nodejs/node/issues/47000
PR-URL: https://github.com/nodejs/node/pull/56735
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Jordan Harband <ljharb@gmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 lib/internal/modules/cjs/loader.js            | 34 +++++++--------
 .../relative/subdir/relative-subdir.js        |  1 +
 ...est-require-resolve-opts-paths-relative.js | 43 +++++++++++++++++++
 3 files changed, 61 insertions(+), 17 deletions(-)
 create mode 100644 test/fixtures/module-require/relative/subdir/relative-subdir.js
 create mode 100644 test/parallel/test-require-resolve-opts-paths-relative.js

diff --git a/lib/internal/modules/cjs/loader.js b/lib/internal/modules/cjs/loader.js
index a558185e08ddb1..6608be9d2db029 100644
--- a/lib/internal/modules/cjs/loader.js
+++ b/lib/internal/modules/cjs/loader.js
@@ -722,18 +722,8 @@ Module._findPath = function(request, paths, isMain, conditions = getCjsCondition
       )
     ));
 
-  const isRelative = StringPrototypeCharCodeAt(request, 0) === CHAR_DOT &&
-    (
-      request.length === 1 ||
-      StringPrototypeCharCodeAt(request, 1) === CHAR_FORWARD_SLASH ||
-      (isWindows && StringPrototypeCharCodeAt(request, 1) === CHAR_BACKWARD_SLASH) ||
-      (StringPrototypeCharCodeAt(request, 1) === CHAR_DOT && ((
-        request.length === 2 ||
-        StringPrototypeCharCodeAt(request, 2) === CHAR_FORWARD_SLASH) ||
-        (isWindows && StringPrototypeCharCodeAt(request, 2) === CHAR_BACKWARD_SLASH)))
-    );
   let insidePath = true;
-  if (isRelative) {
+  if (isRelative(request)) {
     const normalizedRequest = path.normalize(request);
     if (StringPrototypeStartsWith(normalizedRequest, '..')) {
       insidePath = false;
@@ -1328,12 +1318,7 @@ Module._resolveFilename = function(request, parent, isMain, options) {
 
   if (typeof options === 'object' && options !== null) {
     if (ArrayIsArray(options.paths)) {
-      const isRelative = StringPrototypeStartsWith(request, './') ||
-          StringPrototypeStartsWith(request, '../') ||
-          ((isWindows && StringPrototypeStartsWith(request, '.\\')) ||
-          StringPrototypeStartsWith(request, '..\\'));
-
-      if (isRelative) {
+      if (isRelative(request)) {
         paths = options.paths;
       } else {
         const fakeParent = new Module('', null);
@@ -1978,6 +1963,21 @@ function createRequire(filename) {
   return createRequireFromPath(filepath);
 }
 
+/**
+ * Checks if a path is relative
+ * @param {string} path the target path
+ * @returns {boolean} true if the path is relative, false otherwise
+ */
+function isRelative(path) {
+  if (StringPrototypeCharCodeAt(path, 0) !== CHAR_DOT) { return false; }
+
+  return path.length === 1 || path === '..' ||
+  StringPrototypeStartsWith(path, './') ||
+  StringPrototypeStartsWith(path, '../') ||
+  ((isWindows && StringPrototypeStartsWith(path, '.\\')) ||
+  StringPrototypeStartsWith(path, '..\\'));
+}
+
 Module.createRequire = createRequire;
 
 /**
diff --git a/test/fixtures/module-require/relative/subdir/relative-subdir.js b/test/fixtures/module-require/relative/subdir/relative-subdir.js
new file mode 100644
index 00000000000000..34eb71b3c6ca39
--- /dev/null
+++ b/test/fixtures/module-require/relative/subdir/relative-subdir.js
@@ -0,0 +1 @@
+exports.value = 'relative subdir';
diff --git a/test/parallel/test-require-resolve-opts-paths-relative.js b/test/parallel/test-require-resolve-opts-paths-relative.js
new file mode 100644
index 00000000000000..522a1fdbce82a4
--- /dev/null
+++ b/test/parallel/test-require-resolve-opts-paths-relative.js
@@ -0,0 +1,43 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const fixtures = require('../common/fixtures');
+
+if (!common.isMainThread)
+  common.skip('process.chdir is not available in Workers');
+
+const subdir = fixtures.path('module-require', 'relative', 'subdir');
+
+process.chdir(subdir);
+
+// Parent directory paths (`..`) work as intended
+{
+  assert(require.resolve('.', { paths: ['../'] }).endsWith('index.js'));
+  assert(require.resolve('./index.js', { paths: ['../'] }).endsWith('index.js'));
+
+  // paths: [".."] should resolve like paths: ["../"]
+  assert(require.resolve('.', { paths: ['..'] }).endsWith('index.js'));
+  assert(require.resolve('./index.js', { paths: ['..'] }).endsWith('index.js'));
+}
+
+process.chdir('..');
+
+// Current directory paths (`.`) work as intended
+{
+  assert(require.resolve('.', { paths: ['.'] }).endsWith('index.js'));
+  assert(require.resolve('./index.js', { paths: ['./'] }).endsWith('index.js'));
+
+  // paths: ["."] should resolve like paths: ["../"]
+  assert(require.resolve('.', { paths: ['.'] }).endsWith('index.js'));
+  assert(require.resolve('./index.js', { paths: ['.'] }).endsWith('index.js'));
+}
+
+// Sub directory paths work as intended
+{
+  // assert.deepStrictEqual(fs.readdirSync('./subdir'), [5]);
+  assert(require.resolve('./relative-subdir.js', { paths: ['./subdir'] }).endsWith('relative-subdir.js'));
+
+  // paths: ["subdir"] should resolve like paths: ["./subdir"]
+  assert(require.resolve('./relative-subdir.js', { paths: ['subdir'] }).endsWith('relative-subdir.js'));
+}

From ce6a62872081d720734d82bf975653a322795288 Mon Sep 17 00:00:00 2001
From: Dario Piotrowicz <dario.piotrowicz@gmail.com>
Date: Sun, 26 Jan 2025 01:30:11 +0000
Subject: [PATCH 22/38] doc: add note regarding commit message trailers

Co-authored-by: Yagiz Nizipli <yagiz@nizipli.com>
Co-authored-by: Antoine du Hamel <duhamelantoine1995@gmail.com>
PR-URL: https://github.com/nodejs/node/pull/56736
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Rafael Gonzaga <rafael.nunu@hotmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
---
 doc/contributing/pull-requests.md | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/doc/contributing/pull-requests.md b/doc/contributing/pull-requests.md
index 2ad538b3fd8e29..8914d60c95aa2f 100644
--- a/doc/contributing/pull-requests.md
+++ b/doc/contributing/pull-requests.md
@@ -184,6 +184,11 @@ A good commit message should describe what changed and why.
    of the log. Use the `Fixes:` prefix and the full issue URL. For other
    references use `Refs:`.
 
+   `Fixes:` and `Refs:` trailers get automatically added to your commit message
+   when the Pull Request lands as long as they are included in the
+   Pull Request's description. If the Pull Request lands in several commits,
+   by default the trailers found in the description are added to each commits.
+
    Examples:
 
    * `Fixes: https://github.com/nodejs/node/issues/1337`

From e0a71517fef4ca83f2d40d2d1600022bc82a7f9f Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Wed, 15 Jan 2025 13:57:47 -0800
Subject: [PATCH 23/38] src: move more crypto to ncrypto

PR-URL: https://github.com/nodejs/node/pull/56653
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
---
 deps/ncrypto/ncrypto.cc      | 942 ++++++++++++++++++++++++++++++++++-
 deps/ncrypto/ncrypto.h       | 289 ++++++++++-
 src/crypto/crypto_cipher.cc  | 126 ++---
 src/crypto/crypto_cipher.h   |  16 +-
 src/crypto/crypto_common.cc  |   9 +-
 src/crypto/crypto_context.cc |   2 +-
 src/crypto/crypto_dh.cc      |  24 +-
 src/crypto/crypto_dsa.cc     |  47 +-
 src/crypto/crypto_ec.cc      |  71 +--
 src/crypto/crypto_hash.cc    | 140 +++---
 src/crypto/crypto_hkdf.cc    |   4 +-
 src/crypto/crypto_hmac.cc    |  75 +--
 src/crypto/crypto_keygen.cc  |   6 +-
 src/crypto/crypto_keys.cc    |  15 +-
 src/crypto/crypto_pbkdf2.cc  |   6 +-
 src/crypto/crypto_random.cc  |  22 +-
 src/crypto/crypto_rsa.cc     | 291 ++++-------
 src/crypto/crypto_sig.cc     | 596 ++++++++++------------
 src/crypto/crypto_sig.h      |  49 +-
 src/crypto/crypto_tls.cc     |  76 ++-
 src/crypto/crypto_tls.h      |  22 +-
 src/crypto/crypto_util.cc    |  13 +-
 src/crypto/crypto_util.h     |  45 +-
 src/crypto/crypto_x509.cc    | 227 ++++-----
 src/crypto/crypto_x509.h     |  10 +-
 25 files changed, 1989 insertions(+), 1134 deletions(-)

diff --git a/deps/ncrypto/ncrypto.cc b/deps/ncrypto/ncrypto.cc
index ce2e7b384eb198..be3ef98d763366 100644
--- a/deps/ncrypto/ncrypto.cc
+++ b/deps/ncrypto/ncrypto.cc
@@ -15,8 +15,23 @@
 #include "dh-primes.h"
 #endif  // OPENSSL_IS_BORINGSSL
 
+// EVP_PKEY_CTX_set_dsa_paramgen_q_bits was added in OpenSSL 1.1.1e.
+#if OPENSSL_VERSION_NUMBER < 0x1010105fL
+#define EVP_PKEY_CTX_set_dsa_paramgen_q_bits(ctx, qbits)                       \
+  EVP_PKEY_CTX_ctrl((ctx),                                                     \
+                    EVP_PKEY_DSA,                                              \
+                    EVP_PKEY_OP_PARAMGEN,                                      \
+                    EVP_PKEY_CTRL_DSA_PARAMGEN_Q_BITS,                         \
+                    (qbits),                                                   \
+                    nullptr)
+#endif
+
 namespace ncrypto {
 namespace {
+using BignumCtxPointer = DeleteFnPtr<BN_CTX, BN_CTX_free>;
+using BignumGenCallbackPointer = DeleteFnPtr<BN_GENCB, BN_GENCB_free>;
+using NetscapeSPKIPointer = DeleteFnPtr<NETSCAPE_SPKI, NETSCAPE_SPKI_free>;
+
 static constexpr int kX509NameFlagsRFC2253WithinUtf8JSON =
     XN_FLAG_RFC2253 & ~ASN1_STRFLGS_ESC_MSB & ~ASN1_STRFLGS_ESC_CTRL;
 }  // namespace
@@ -87,6 +102,10 @@ DataPointer DataPointer::Alloc(size_t len) {
   return DataPointer(OPENSSL_zalloc(len), len);
 }
 
+DataPointer DataPointer::Copy(const Buffer<const void>& buffer) {
+  return DataPointer(OPENSSL_memdup(buffer.data, buffer.len), buffer.len);
+}
+
 DataPointer::DataPointer(void* data, size_t length)
     : data_(data), len_(length) {}
 
@@ -109,6 +128,11 @@ DataPointer::~DataPointer() {
   reset();
 }
 
+void DataPointer::zero() {
+  if (!data_) return;
+  OPENSSL_cleanse(data_, len_);
+}
+
 void DataPointer::reset(void* data, size_t length) {
   if (data_ != nullptr) {
     OPENSSL_clear_free(data_, len_);
@@ -131,6 +155,15 @@ Buffer<void> DataPointer::release() {
   return buf;
 }
 
+DataPointer DataPointer::resize(size_t len) {
+  size_t actual_len = std::min(len_, len);
+  auto buf = release();
+  if (actual_len == len_) return DataPointer(buf);
+  buf.data = OPENSSL_realloc(buf.data, actual_len);
+  buf.len = actual_len;
+  return DataPointer(buf);
+}
+
 // ============================================================================
 bool isFipsEnabled() {
 #if OPENSSL_VERSION_MAJOR >= 3
@@ -782,7 +815,7 @@ bool PrintGeneralName(const BIOPointer& out, const GENERAL_NAME* gen) {
 
 bool SafeX509SubjectAltNamePrint(const BIOPointer& out, X509_EXTENSION* ext) {
   auto ret = OBJ_obj2nid(X509_EXTENSION_get_object(ext));
-  NCRYPTO_ASSERT_EQUAL(ret, NID_subject_alt_name, "unexpected extension type");
+  if (ret != NID_subject_alt_name) return false;
 
   GENERAL_NAMES* names = static_cast<GENERAL_NAMES*>(X509V3_EXT_d2i(ext));
   if (names == nullptr) return false;
@@ -805,7 +838,7 @@ bool SafeX509SubjectAltNamePrint(const BIOPointer& out, X509_EXTENSION* ext) {
 
 bool SafeX509InfoAccessPrint(const BIOPointer& out, X509_EXTENSION* ext) {
   auto ret = OBJ_obj2nid(X509_EXTENSION_get_object(ext));
-  NCRYPTO_ASSERT_EQUAL(ret, NID_info_access, "unexpected extension type");
+  if (ret != NID_info_access) return false;
 
   AUTHORITY_INFO_ACCESS* descs =
       static_cast<AUTHORITY_INFO_ACCESS*>(X509V3_EXT_d2i(ext));
@@ -1132,6 +1165,49 @@ Result<X509Pointer, int> X509Pointer::Parse(
   return Result<X509Pointer, int>(ERR_get_error());
 }
 
+bool X509View::enumUsages(UsageCallback callback) const {
+  if (cert_ == nullptr) return false;
+  StackOfASN1 eku(static_cast<STACK_OF(ASN1_OBJECT)*>(
+      X509_get_ext_d2i(cert_, NID_ext_key_usage, nullptr, nullptr)));
+  if (!eku) return false;
+  const int count = sk_ASN1_OBJECT_num(eku.get());
+  char buf[256]{};
+
+  for (int i = 0; i < count; i++) {
+    if (OBJ_obj2txt(buf, sizeof(buf), sk_ASN1_OBJECT_value(eku.get(), i), 1) >=
+        0) {
+      callback(buf);
+    }
+  }
+  return true;
+}
+
+bool X509View::ifRsa(KeyCallback<Rsa> callback) const {
+  if (cert_ == nullptr) return true;
+  OSSL3_CONST EVP_PKEY* pkey = X509_get0_pubkey(cert_);
+  auto id = EVP_PKEY_id(pkey);
+  if (id == EVP_PKEY_RSA || id == EVP_PKEY_RSA2 || id == EVP_PKEY_RSA_PSS) {
+    Rsa rsa(EVP_PKEY_get0_RSA(pkey));
+    if (!rsa) [[unlikely]]
+      return true;
+    return callback(rsa);
+  }
+  return true;
+}
+
+bool X509View::ifEc(KeyCallback<Ec> callback) const {
+  if (cert_ == nullptr) return true;
+  OSSL3_CONST EVP_PKEY* pkey = X509_get0_pubkey(cert_);
+  auto id = EVP_PKEY_id(pkey);
+  if (id == EVP_PKEY_EC) {
+    Ec ec(EVP_PKEY_get0_EC_KEY(pkey));
+    if (!ec) [[unlikely]]
+      return true;
+    return callback(ec);
+  }
+  return true;
+}
+
 X509Pointer X509Pointer::IssuerFrom(const SSLPointer& ssl,
                                     const X509View& view) {
   return IssuerFrom(SSL_get_SSL_CTX(ssl.get()), view);
@@ -1493,7 +1569,7 @@ DataPointer DHPointer::stateless(const EVPKeyPointer& ourKey,
   size_t out_size;
   if (!ourKey || !theirKey) return {};
 
-  EVPKeyCtxPointer ctx(EVP_PKEY_CTX_new(ourKey.get(), nullptr));
+  auto ctx = EVPKeyCtxPointer::New(ourKey);
   if (!ctx || EVP_PKEY_derive_init(ctx.get()) <= 0 ||
       EVP_PKEY_derive_set_peer(ctx.get(), theirKey.get()) <= 0 ||
       EVP_PKEY_derive(ctx.get(), nullptr, &out_size) <= 0) {
@@ -1522,9 +1598,18 @@ DataPointer DHPointer::stateless(const EVPKeyPointer& ourKey,
 // KDF
 
 const EVP_MD* getDigestByName(const std::string_view name) {
+  // Historically, "dss1" and "DSS1" were DSA aliases for SHA-1
+  // exposed through the public API.
+  if (name == "dss1" || name == "DSS1") [[unlikely]] {
+    return EVP_sha1();
+  }
   return EVP_get_digestbyname(name.data());
 }
 
+const EVP_CIPHER* getCipherByName(const std::string_view name) {
+  return EVP_get_cipherbyname(name.data());
+}
+
 bool checkHkdfLength(const EVP_MD* md, size_t length) {
   // HKDF-Expand computes up to 255 HMAC blocks, each having as many bits as
   // the output of the hash function. 255 is a hard limit because HKDF appends
@@ -1547,8 +1632,7 @@ DataPointer hkdf(const EVP_MD* md,
     return {};
   }
 
-  EVPKeyCtxPointer ctx =
-      EVPKeyCtxPointer(EVP_PKEY_CTX_new_id(EVP_PKEY_HKDF, nullptr));
+  auto ctx = EVPKeyCtxPointer::NewFromID(EVP_PKEY_HKDF);
   if (!ctx || !EVP_PKEY_derive_init(ctx.get()) ||
       !EVP_PKEY_CTX_set_hkdf_md(ctx.get(), md) ||
       !EVP_PKEY_CTX_add1_hkdf_info(ctx.get(), info.data, info.len)) {
@@ -1704,6 +1788,26 @@ EVPKeyPointer EVPKeyPointer::NewRawPrivate(
       EVP_PKEY_new_raw_private_key(id, nullptr, data.data, data.len));
 }
 
+EVPKeyPointer EVPKeyPointer::NewDH(DHPointer&& dh) {
+  if (!dh) return {};
+  auto key = New();
+  if (!key) return {};
+  if (EVP_PKEY_assign_DH(key.get(), dh.get())) {
+    dh.release();
+  }
+  return key;
+}
+
+EVPKeyPointer EVPKeyPointer::NewRSA(RSAPointer&& rsa) {
+  if (!rsa) return {};
+  auto key = New();
+  if (!key) return {};
+  if (EVP_PKEY_assign_RSA(key.get(), rsa.get())) {
+    rsa.release();
+  }
+  return key;
+}
+
 EVPKeyPointer::EVPKeyPointer(EVP_PKEY* pkey) : pkey_(pkey) {}
 
 EVPKeyPointer::EVPKeyPointer(EVPKeyPointer&& other) noexcept
@@ -1757,7 +1861,7 @@ size_t EVPKeyPointer::size() const {
 
 EVPKeyCtxPointer EVPKeyPointer::newCtx() const {
   if (!pkey_) return {};
-  return EVPKeyCtxPointer(EVP_PKEY_CTX_new(get(), nullptr));
+  return EVPKeyCtxPointer::New(*this);
 }
 
 size_t EVPKeyPointer::rawPublicKeySize() const {
@@ -2230,6 +2334,84 @@ Result<BIOPointer, bool> EVPKeyPointer::writePublicKey(
   return bio;
 }
 
+bool EVPKeyPointer::isRsaVariant() const {
+  if (!pkey_) return false;
+  int type = id();
+  return type == EVP_PKEY_RSA || type == EVP_PKEY_RSA2 ||
+         type == EVP_PKEY_RSA_PSS;
+}
+
+bool EVPKeyPointer::isOneShotVariant() const {
+  if (!pkey_) return false;
+  int type = id();
+  return type == EVP_PKEY_ED25519 || type == EVP_PKEY_ED448;
+}
+
+bool EVPKeyPointer::isSigVariant() const {
+  if (!pkey_) return false;
+  int type = id();
+  return type == EVP_PKEY_EC || type == EVP_PKEY_DSA;
+}
+
+int EVPKeyPointer::getDefaultSignPadding() const {
+  return id() == EVP_PKEY_RSA_PSS ? RSA_PKCS1_PSS_PADDING : RSA_PKCS1_PADDING;
+}
+
+std::optional<uint32_t> EVPKeyPointer::getBytesOfRS() const {
+  if (!pkey_) return std::nullopt;
+  int bits, id = base_id();
+
+  if (id == EVP_PKEY_DSA) {
+    const DSA* dsa_key = EVP_PKEY_get0_DSA(get());
+    // Both r and s are computed mod q, so their width is limited by that of q.
+    bits = BignumPointer::GetBitCount(DSA_get0_q(dsa_key));
+  } else if (id == EVP_PKEY_EC) {
+    bits = EC_GROUP_order_bits(ECKeyPointer::GetGroup(*this));
+  } else {
+    return std::nullopt;
+  }
+
+  return (bits + 7) / 8;
+}
+
+EVPKeyPointer::operator Rsa() const {
+  int type = id();
+  if (type != EVP_PKEY_RSA && type != EVP_PKEY_RSA_PSS) return {};
+
+  // TODO(tniessen): Remove the "else" branch once we drop support for OpenSSL
+  // versions older than 1.1.1e via FIPS / dynamic linking.
+  OSSL3_CONST RSA* rsa;
+  if (OPENSSL_VERSION_NUMBER >= 0x1010105fL) {
+    rsa = EVP_PKEY_get0_RSA(get());
+  } else {
+    rsa = static_cast<OSSL3_CONST RSA*>(EVP_PKEY_get0(get()));
+  }
+  if (rsa == nullptr) return {};
+  return Rsa(rsa);
+}
+
+bool EVPKeyPointer::validateDsaParameters() const {
+  if (!pkey_) return false;
+    /* Validate DSA2 parameters from FIPS 186-4 */
+#if OPENSSL_VERSION_MAJOR >= 3
+  if (EVP_default_properties_is_fips_enabled(nullptr) && EVP_PKEY_DSA == id()) {
+#else
+  if (FIPS_mode() && EVP_PKEY_DSA == id()) {
+#endif
+    const DSA* dsa = EVP_PKEY_get0_DSA(pkey_.get());
+    const BIGNUM* p;
+    const BIGNUM* q;
+    DSA_get0_pqg(dsa, &p, &q, nullptr);
+    int L = BignumPointer::GetBitCount(p);
+    int N = BignumPointer::GetBitCount(q);
+
+    return (L == 1024 && N == 160) || (L == 2048 && N == 224) ||
+           (L == 2048 && N == 256) || (L == 3072 && N == 256);
+  }
+
+  return true;
+}
+
 // ============================================================================
 
 SSLPointer::SSLPointer(SSL* ssl) : ssl_(ssl) {}
@@ -2883,4 +3065,752 @@ ECKeyPointer ECKeyPointer::New(const EC_GROUP* group) {
   return ptr;
 }
 
+// ============================================================================
+
+EVPKeyCtxPointer::EVPKeyCtxPointer() : ctx_(nullptr) {}
+
+EVPKeyCtxPointer::EVPKeyCtxPointer(EVP_PKEY_CTX* ctx) : ctx_(ctx) {}
+
+EVPKeyCtxPointer::EVPKeyCtxPointer(EVPKeyCtxPointer&& other) noexcept
+    : ctx_(other.release()) {}
+
+EVPKeyCtxPointer& EVPKeyCtxPointer::operator=(
+    EVPKeyCtxPointer&& other) noexcept {
+  ctx_.reset(other.release());
+  return *this;
+}
+
+EVPKeyCtxPointer::~EVPKeyCtxPointer() {
+  reset();
+}
+
+void EVPKeyCtxPointer::reset(EVP_PKEY_CTX* ctx) {
+  ctx_.reset(ctx);
+}
+
+EVP_PKEY_CTX* EVPKeyCtxPointer::release() {
+  return ctx_.release();
+}
+
+EVPKeyCtxPointer EVPKeyCtxPointer::New(const EVPKeyPointer& key) {
+  if (!key) return {};
+  return EVPKeyCtxPointer(EVP_PKEY_CTX_new(key.get(), nullptr));
+}
+
+EVPKeyCtxPointer EVPKeyCtxPointer::NewFromID(int id) {
+  return EVPKeyCtxPointer(EVP_PKEY_CTX_new_id(id, nullptr));
+}
+
+bool EVPKeyCtxPointer::initForDerive(const EVPKeyPointer& peer) {
+  if (!ctx_) return false;
+  if (EVP_PKEY_derive_init(ctx_.get()) != 1) return false;
+  return EVP_PKEY_derive_set_peer(ctx_.get(), peer.get()) == 1;
+}
+
+bool EVPKeyCtxPointer::initForKeygen() {
+  if (!ctx_) return false;
+  return EVP_PKEY_keygen_init(ctx_.get()) == 1;
+}
+
+bool EVPKeyCtxPointer::initForParamgen() {
+  if (!ctx_) return false;
+  return EVP_PKEY_paramgen_init(ctx_.get()) == 1;
+}
+
+int EVPKeyCtxPointer::initForVerify() {
+  if (!ctx_) return 0;
+  return EVP_PKEY_verify_init(ctx_.get());
+}
+
+int EVPKeyCtxPointer::initForSign() {
+  if (!ctx_) return 0;
+  return EVP_PKEY_sign_init(ctx_.get());
+}
+
+bool EVPKeyCtxPointer::setDhParameters(int prime_size, uint32_t generator) {
+  if (!ctx_) return false;
+  return EVP_PKEY_CTX_set_dh_paramgen_prime_len(ctx_.get(), prime_size) == 1 &&
+         EVP_PKEY_CTX_set_dh_paramgen_generator(ctx_.get(), generator) == 1;
+}
+
+bool EVPKeyCtxPointer::setDsaParameters(uint32_t bits,
+                                        std::optional<int> q_bits) {
+  if (!ctx_) return false;
+  if (EVP_PKEY_CTX_set_dsa_paramgen_bits(ctx_.get(), bits) != 1) {
+    return false;
+  }
+  if (q_bits.has_value() &&
+      EVP_PKEY_CTX_set_dsa_paramgen_q_bits(ctx_.get(), q_bits.value()) != 1) {
+    return false;
+  }
+  return true;
+}
+
+bool EVPKeyCtxPointer::setEcParameters(int curve, int encoding) {
+  if (!ctx_) return false;
+  return EVP_PKEY_CTX_set_ec_paramgen_curve_nid(ctx_.get(), curve) == 1 &&
+         EVP_PKEY_CTX_set_ec_param_enc(ctx_.get(), encoding) == 1;
+}
+
+bool EVPKeyCtxPointer::setRsaOaepMd(const EVP_MD* md) {
+  if (md == nullptr || !ctx_) return false;
+  return EVP_PKEY_CTX_set_rsa_oaep_md(ctx_.get(), md) > 0;
+}
+
+bool EVPKeyCtxPointer::setRsaMgf1Md(const EVP_MD* md) {
+  if (md == nullptr || !ctx_) return false;
+  return EVP_PKEY_CTX_set_rsa_mgf1_md(ctx_.get(), md) > 0;
+}
+
+bool EVPKeyCtxPointer::setRsaPadding(int padding) {
+  return setRsaPadding(ctx_.get(), padding, std::nullopt);
+}
+
+bool EVPKeyCtxPointer::setRsaPadding(EVP_PKEY_CTX* ctx,
+                                     int padding,
+                                     std::optional<int> salt_len) {
+  if (ctx == nullptr) return false;
+  if (EVP_PKEY_CTX_set_rsa_padding(ctx, padding) <= 0) {
+    return false;
+  }
+  if (padding == RSA_PKCS1_PSS_PADDING && salt_len.has_value()) {
+    return EVP_PKEY_CTX_set_rsa_pss_saltlen(ctx, salt_len.value()) > 0;
+  }
+  return true;
+}
+
+bool EVPKeyCtxPointer::setRsaKeygenBits(int bits) {
+  if (!ctx_) return false;
+  return EVP_PKEY_CTX_set_rsa_keygen_bits(ctx_.get(), bits) == 1;
+}
+
+bool EVPKeyCtxPointer::setRsaKeygenPubExp(BignumPointer&& e) {
+  if (!ctx_) return false;
+  if (EVP_PKEY_CTX_set_rsa_keygen_pubexp(ctx_.get(), e.get()) == 1) {
+    // The ctx_ takes ownership of e on success.
+    e.release();
+    return true;
+  }
+  return false;
+}
+
+bool EVPKeyCtxPointer::setRsaPssKeygenMd(const EVP_MD* md) {
+  if (md == nullptr || !ctx_) return false;
+  return EVP_PKEY_CTX_set_rsa_pss_keygen_md(ctx_.get(), md) > 0;
+}
+
+bool EVPKeyCtxPointer::setRsaPssKeygenMgf1Md(const EVP_MD* md) {
+  if (md == nullptr || !ctx_) return false;
+  return EVP_PKEY_CTX_set_rsa_pss_keygen_mgf1_md(ctx_.get(), md) > 0;
+}
+
+bool EVPKeyCtxPointer::setRsaPssSaltlen(int salt_len) {
+  if (!ctx_) return false;
+  return EVP_PKEY_CTX_set_rsa_pss_keygen_saltlen(ctx_.get(), salt_len) > 0;
+}
+
+bool EVPKeyCtxPointer::setRsaImplicitRejection() {
+  if (!ctx_) return false;
+  return EVP_PKEY_CTX_ctrl_str(
+             ctx_.get(), "rsa_pkcs1_implicit_rejection", "1") > 0;
+  // From the doc -2 means that the option is not supported.
+  // The default for the option is enabled and if it has been
+  // specifically disabled we want to respect that so we will
+  // not throw an error if the option is supported regardless
+  // of how it is set. The call to set the value
+  // will not affect what is used since a different context is
+  // used in the call if the option is supported
+}
+
+bool EVPKeyCtxPointer::setRsaOaepLabel(DataPointer&& data) {
+  if (!ctx_) return false;
+  if (EVP_PKEY_CTX_set0_rsa_oaep_label(ctx_.get(),
+                                       static_cast<unsigned char*>(data.get()),
+                                       data.size()) > 0) {
+    // The ctx_ takes ownership of data on success.
+    data.release();
+    return true;
+  }
+  return false;
+}
+
+bool EVPKeyCtxPointer::setSignatureMd(const EVPMDCtxPointer& md) {
+  if (!ctx_) return false;
+  return EVP_PKEY_CTX_set_signature_md(ctx_.get(), EVP_MD_CTX_md(md.get())) ==
+         1;
+}
+
+bool EVPKeyCtxPointer::initForEncrypt() {
+  if (!ctx_) return false;
+  return EVP_PKEY_encrypt_init(ctx_.get()) == 1;
+}
+
+bool EVPKeyCtxPointer::initForDecrypt() {
+  if (!ctx_) return false;
+  return EVP_PKEY_decrypt_init(ctx_.get()) == 1;
+}
+
+DataPointer EVPKeyCtxPointer::derive() const {
+  if (!ctx_) return {};
+  size_t len = 0;
+  if (EVP_PKEY_derive(ctx_.get(), nullptr, &len) != 1) return {};
+  auto data = DataPointer::Alloc(len);
+  if (!data) return {};
+  if (EVP_PKEY_derive(
+          ctx_.get(), static_cast<unsigned char*>(data.get()), &len) != 1) {
+    return {};
+  }
+  return data;
+}
+
+EVPKeyPointer EVPKeyCtxPointer::paramgen() const {
+  if (!ctx_) return {};
+  EVP_PKEY* key = nullptr;
+  if (EVP_PKEY_paramgen(ctx_.get(), &key) != 1) return {};
+  return EVPKeyPointer(key);
+}
+
+bool EVPKeyCtxPointer::publicCheck() const {
+  if (!ctx_) return false;
+#if OPENSSL_VERSION_MAJOR >= 3
+  return EVP_PKEY_public_check_quick(ctx_.get()) == 1;
+#else
+  return EVP_PKEY_public_check(ctx_.get()) == 1;
+#endif
+}
+
+bool EVPKeyCtxPointer::privateCheck() const {
+  if (!ctx_) return false;
+  return EVP_PKEY_check(ctx_.get()) == 1;
+}
+
+bool EVPKeyCtxPointer::verify(const Buffer<const unsigned char>& sig,
+                              const Buffer<const unsigned char>& data) {
+  if (!ctx_) return false;
+  return EVP_PKEY_verify(ctx_.get(), sig.data, sig.len, data.data, data.len) ==
+         1;
+}
+
+DataPointer EVPKeyCtxPointer::sign(const Buffer<const unsigned char>& data) {
+  if (!ctx_) return {};
+  size_t len = 0;
+  if (EVP_PKEY_sign(ctx_.get(), nullptr, &len, data.data, data.len) != 1) {
+    return {};
+  }
+  auto buf = DataPointer::Alloc(len);
+  if (!buf) return {};
+  if (EVP_PKEY_sign(ctx_.get(),
+                    static_cast<unsigned char*>(buf.get()),
+                    &len,
+                    data.data,
+                    data.len) != 1) {
+    return {};
+  }
+  return buf.resize(len);
+}
+
+bool EVPKeyCtxPointer::signInto(const Buffer<const unsigned char>& data,
+                                Buffer<unsigned char>* sig) {
+  if (!ctx_) return false;
+  size_t len = sig->len;
+  if (EVP_PKEY_sign(ctx_.get(), sig->data, &len, data.data, data.len) != 1) {
+    return false;
+  }
+  sig->len = len;
+  return true;
+}
+
+// ============================================================================
+
+namespace {
+
+using EVP_PKEY_cipher_init_t = int(EVP_PKEY_CTX* ctx);
+using EVP_PKEY_cipher_t = int(EVP_PKEY_CTX* ctx,
+                              unsigned char* out,
+                              size_t* outlen,
+                              const unsigned char* in,
+                              size_t inlen);
+
+template <EVP_PKEY_cipher_init_t init, EVP_PKEY_cipher_t cipher>
+DataPointer RSA_Cipher(const EVPKeyPointer& key,
+                       const Rsa::CipherParams& params,
+                       const Buffer<const void> in) {
+  if (!key) return {};
+  EVPKeyCtxPointer ctx = key.newCtx();
+
+  if (!ctx || init(ctx.get()) <= 0 || !ctx.setRsaPadding(params.padding) ||
+      (params.digest != nullptr && (!ctx.setRsaOaepMd(params.digest) ||
+                                    !ctx.setRsaMgf1Md(params.digest)))) {
+    return {};
+  }
+
+  if (params.label.len != 0 && params.label.data != nullptr &&
+      !ctx.setRsaOaepLabel(DataPointer::Copy(params.label))) {
+    return {};
+  }
+
+  size_t out_len = 0;
+  if (cipher(ctx.get(),
+             nullptr,
+             &out_len,
+             reinterpret_cast<const unsigned char*>(in.data),
+             in.len) <= 0) {
+    return {};
+  }
+
+  auto buf = DataPointer::Alloc(out_len);
+  if (!buf) return {};
+
+  if (cipher(ctx.get(),
+             static_cast<unsigned char*>(buf.get()),
+             &out_len,
+             static_cast<const unsigned char*>(in.data),
+             in.len) <= 0) {
+    return {};
+  }
+
+  return buf.resize(out_len);
+}
+
+template <EVP_PKEY_cipher_init_t init, EVP_PKEY_cipher_t cipher>
+DataPointer CipherImpl(const EVPKeyPointer& key,
+                       const Rsa::CipherParams& params,
+                       const Buffer<const void> in) {
+  if (!key) return {};
+  EVPKeyCtxPointer ctx = key.newCtx();
+  if (!ctx || init(ctx.get()) <= 0 || !ctx.setRsaPadding(params.padding) ||
+      (params.digest != nullptr && !ctx.setRsaOaepMd(params.digest))) {
+    return {};
+  }
+
+  if (params.label.len != 0 && params.label.data != nullptr &&
+      !ctx.setRsaOaepLabel(DataPointer::Copy(params.label))) {
+    return {};
+  }
+
+  size_t out_len = 0;
+  if (cipher(ctx.get(),
+             nullptr,
+             &out_len,
+             static_cast<const unsigned char*>(in.data),
+             in.len) <= 0) {
+    return {};
+  }
+
+  auto buf = DataPointer::Alloc(out_len);
+  if (!buf) return {};
+
+  if (cipher(ctx.get(),
+             static_cast<unsigned char*>(buf.get()),
+             &out_len,
+             static_cast<const unsigned char*>(in.data),
+             in.len) <= 0) {
+    return {};
+  }
+
+  return buf.resize(out_len);
+}
+}  // namespace
+
+Rsa::Rsa() : rsa_(nullptr) {}
+
+Rsa::Rsa(OSSL3_CONST RSA* ptr) : rsa_(ptr) {}
+
+const Rsa::PublicKey Rsa::getPublicKey() const {
+  if (rsa_ == nullptr) return {};
+  PublicKey key;
+  RSA_get0_key(rsa_, &key.n, &key.e, &key.d);
+  return key;
+}
+
+const Rsa::PrivateKey Rsa::getPrivateKey() const {
+  if (rsa_ == nullptr) return {};
+  PrivateKey key;
+  RSA_get0_factors(rsa_, &key.p, &key.q);
+  RSA_get0_crt_params(rsa_, &key.dp, &key.dq, &key.qi);
+  return key;
+}
+
+const std::optional<Rsa::PssParams> Rsa::getPssParams() const {
+  if (rsa_ == nullptr) return std::nullopt;
+  const RSA_PSS_PARAMS* params = RSA_get0_pss_params(rsa_);
+  if (params == nullptr) return std::nullopt;
+  Rsa::PssParams ret{
+      .digest = OBJ_nid2ln(NID_sha1),
+      .mgf1_digest = OBJ_nid2ln(NID_sha1),
+      .salt_length = 20,
+  };
+
+  if (params->hashAlgorithm != nullptr) {
+    const ASN1_OBJECT* hash_obj;
+    X509_ALGOR_get0(&hash_obj, nullptr, nullptr, params->hashAlgorithm);
+    ret.digest = OBJ_nid2ln(OBJ_obj2nid(hash_obj));
+  }
+
+  if (params->maskGenAlgorithm != nullptr) {
+    const ASN1_OBJECT* mgf_obj;
+    X509_ALGOR_get0(&mgf_obj, nullptr, nullptr, params->maskGenAlgorithm);
+    int mgf_nid = OBJ_obj2nid(mgf_obj);
+    if (mgf_nid == NID_mgf1) {
+      const ASN1_OBJECT* mgf1_hash_obj;
+      X509_ALGOR_get0(&mgf1_hash_obj, nullptr, nullptr, params->maskHash);
+      ret.mgf1_digest = OBJ_nid2ln(OBJ_obj2nid(mgf1_hash_obj));
+    }
+  }
+
+  if (params->saltLength != nullptr) {
+    if (ASN1_INTEGER_get_int64(&ret.salt_length, params->saltLength) != 1) {
+      return std::nullopt;
+    }
+  }
+  return ret;
+}
+
+bool Rsa::setPublicKey(BignumPointer&& n, BignumPointer&& e) {
+  if (!n || !e) return false;
+  if (RSA_set0_key(const_cast<RSA*>(rsa_), n.get(), e.get(), nullptr) == 1) {
+    n.release();
+    e.release();
+    return true;
+  }
+  return false;
+}
+
+bool Rsa::setPrivateKey(BignumPointer&& d,
+                        BignumPointer&& q,
+                        BignumPointer&& p,
+                        BignumPointer&& dp,
+                        BignumPointer&& dq,
+                        BignumPointer&& qi) {
+  if (!RSA_set0_key(const_cast<RSA*>(rsa_), nullptr, nullptr, d.get())) {
+    return false;
+  }
+  d.release();
+
+  if (!RSA_set0_factors(const_cast<RSA*>(rsa_), p.get(), q.get())) {
+    return false;
+  }
+  p.release();
+  q.release();
+
+  if (!RSA_set0_crt_params(
+          const_cast<RSA*>(rsa_), dp.get(), dq.get(), qi.get())) {
+    return false;
+  }
+  dp.release();
+  dq.release();
+  qi.release();
+  return true;
+}
+
+DataPointer Rsa::encrypt(const EVPKeyPointer& key,
+                         const Rsa::CipherParams& params,
+                         const Buffer<const void> in) {
+  if (!key) return {};
+  return RSA_Cipher<EVP_PKEY_encrypt_init, EVP_PKEY_encrypt>(key, params, in);
+}
+
+DataPointer Rsa::decrypt(const EVPKeyPointer& key,
+                         const Rsa::CipherParams& params,
+                         const Buffer<const void> in) {
+  if (!key) return {};
+  return RSA_Cipher<EVP_PKEY_decrypt_init, EVP_PKEY_decrypt>(key, params, in);
+}
+
+DataPointer Cipher::encrypt(const EVPKeyPointer& key,
+                            const CipherParams& params,
+                            const Buffer<const void> in) {
+  // public operation
+  return CipherImpl<EVP_PKEY_encrypt_init, EVP_PKEY_encrypt>(key, params, in);
+}
+
+DataPointer Cipher::decrypt(const EVPKeyPointer& key,
+                            const CipherParams& params,
+                            const Buffer<const void> in) {
+  // private operation
+  return CipherImpl<EVP_PKEY_decrypt_init, EVP_PKEY_decrypt>(key, params, in);
+}
+
+DataPointer Cipher::sign(const EVPKeyPointer& key,
+                         const CipherParams& params,
+                         const Buffer<const void> in) {
+  // private operation
+  return CipherImpl<EVP_PKEY_sign_init, EVP_PKEY_sign>(key, params, in);
+}
+
+DataPointer Cipher::recover(const EVPKeyPointer& key,
+                            const CipherParams& params,
+                            const Buffer<const void> in) {
+  // public operation
+  return CipherImpl<EVP_PKEY_verify_recover_init, EVP_PKEY_verify_recover>(
+      key, params, in);
+}
+
+// ============================================================================
+
+Ec::Ec() : ec_(nullptr) {}
+
+Ec::Ec(OSSL3_CONST EC_KEY* key) : ec_(key) {}
+
+const EC_GROUP* Ec::getGroup() const {
+  return ECKeyPointer::GetGroup(ec_);
+}
+
+int Ec::getCurve() const {
+  return EC_GROUP_get_curve_name(getGroup());
+}
+
+// ============================================================================
+
+EVPMDCtxPointer::EVPMDCtxPointer() : ctx_(nullptr) {}
+
+EVPMDCtxPointer::EVPMDCtxPointer(EVP_MD_CTX* ctx) : ctx_(ctx) {}
+
+EVPMDCtxPointer::EVPMDCtxPointer(EVPMDCtxPointer&& other) noexcept
+    : ctx_(other.release()) {}
+
+EVPMDCtxPointer& EVPMDCtxPointer::operator=(EVPMDCtxPointer&& other) noexcept {
+  ctx_.reset(other.release());
+  return *this;
+}
+
+EVPMDCtxPointer::~EVPMDCtxPointer() {
+  reset();
+}
+
+void EVPMDCtxPointer::reset(EVP_MD_CTX* ctx) {
+  ctx_.reset(ctx);
+}
+
+EVP_MD_CTX* EVPMDCtxPointer::release() {
+  return ctx_.release();
+}
+
+bool EVPMDCtxPointer::digestInit(const EVP_MD* digest) {
+  if (!ctx_) return false;
+  return EVP_DigestInit_ex(ctx_.get(), digest, nullptr) > 0;
+}
+
+bool EVPMDCtxPointer::digestUpdate(const Buffer<const void>& in) {
+  if (!ctx_) return false;
+  return EVP_DigestUpdate(ctx_.get(), in.data, in.len) > 0;
+}
+
+DataPointer EVPMDCtxPointer::digestFinal(size_t length) {
+  if (!ctx_) return {};
+
+  auto buf = DataPointer::Alloc(length);
+  if (!buf) return {};
+
+  Buffer<void> buffer = buf;
+
+  if (!digestFinalInto(&buffer)) [[unlikely]] {
+    return {};
+  }
+
+  return buf;
+}
+
+bool EVPMDCtxPointer::digestFinalInto(Buffer<void>* buf) {
+  if (!ctx_) return false;
+
+  auto ptr = static_cast<unsigned char*>(buf->data);
+
+  int ret = (buf->len == getExpectedSize())
+                ? EVP_DigestFinal_ex(ctx_.get(), ptr, nullptr)
+                : EVP_DigestFinalXOF(ctx_.get(), ptr, buf->len);
+
+  if (ret != 1) [[unlikely]]
+    return false;
+
+  return true;
+}
+
+size_t EVPMDCtxPointer::getExpectedSize() {
+  if (!ctx_) return 0;
+  return EVP_MD_CTX_size(ctx_.get());
+}
+
+size_t EVPMDCtxPointer::getDigestSize() const {
+  return EVP_MD_size(getDigest());
+}
+
+const EVP_MD* EVPMDCtxPointer::getDigest() const {
+  if (!ctx_) return nullptr;
+  return EVP_MD_CTX_md(ctx_.get());
+}
+
+bool EVPMDCtxPointer::hasXofFlag() const {
+  if (!ctx_) return false;
+  return (EVP_MD_flags(getDigest()) & EVP_MD_FLAG_XOF) == EVP_MD_FLAG_XOF;
+}
+
+bool EVPMDCtxPointer::copyTo(const EVPMDCtxPointer& other) const {
+  if (!ctx_ || !other) return {};
+  if (EVP_MD_CTX_copy(other.get(), ctx_.get()) != 1) return false;
+  return true;
+}
+
+std::optional<EVP_PKEY_CTX*> EVPMDCtxPointer::signInit(const EVPKeyPointer& key,
+                                                       const EVP_MD* digest) {
+  EVP_PKEY_CTX* ctx = nullptr;
+  if (!EVP_DigestSignInit(ctx_.get(), &ctx, digest, nullptr, key.get())) {
+    return std::nullopt;
+  }
+  return ctx;
+}
+
+std::optional<EVP_PKEY_CTX*> EVPMDCtxPointer::verifyInit(
+    const EVPKeyPointer& key, const EVP_MD* digest) {
+  EVP_PKEY_CTX* ctx = nullptr;
+  if (!EVP_DigestVerifyInit(ctx_.get(), &ctx, digest, nullptr, key.get())) {
+    return std::nullopt;
+  }
+  return ctx;
+}
+
+DataPointer EVPMDCtxPointer::signOneShot(
+    const Buffer<const unsigned char>& buf) const {
+  if (!ctx_) return {};
+  size_t len;
+  if (!EVP_DigestSign(ctx_.get(), nullptr, &len, buf.data, buf.len)) {
+    return {};
+  }
+  auto data = DataPointer::Alloc(len);
+  if (!data) [[unlikely]]
+    return {};
+
+  if (!EVP_DigestSign(ctx_.get(),
+                      static_cast<unsigned char*>(data.get()),
+                      &len,
+                      buf.data,
+                      buf.len)) {
+    return {};
+  }
+  return data;
+}
+
+DataPointer EVPMDCtxPointer::sign(
+    const Buffer<const unsigned char>& buf) const {
+  if (!ctx_) [[unlikely]]
+    return {};
+  size_t len;
+  if (!EVP_DigestSignUpdate(ctx_.get(), buf.data, buf.len) ||
+      !EVP_DigestSignFinal(ctx_.get(), nullptr, &len)) {
+    return {};
+  }
+  auto data = DataPointer::Alloc(len);
+  if (!data) [[unlikely]]
+    return {};
+  if (!EVP_DigestSignFinal(
+          ctx_.get(), static_cast<unsigned char*>(data.get()), &len)) {
+    return {};
+  }
+  return data.resize(len);
+}
+
+bool EVPMDCtxPointer::verify(const Buffer<const unsigned char>& buf,
+                             const Buffer<const unsigned char>& sig) const {
+  if (!ctx_) return false;
+  int ret = EVP_DigestVerify(ctx_.get(), sig.data, sig.len, buf.data, buf.len);
+  return ret == 1;
+}
+
+EVPMDCtxPointer EVPMDCtxPointer::New() {
+  return EVPMDCtxPointer(EVP_MD_CTX_new());
+}
+
+// ============================================================================
+
+bool extractP1363(const Buffer<const unsigned char>& buf,
+                  unsigned char* dest,
+                  size_t n) {
+  auto asn1_sig = ECDSASigPointer::Parse(buf);
+  if (!asn1_sig) return false;
+
+  return BignumPointer::EncodePaddedInto(asn1_sig.r(), dest, n) > 0 &&
+         BignumPointer::EncodePaddedInto(asn1_sig.s(), dest + n, n) > 0;
+}
+
+// ============================================================================
+
+HMACCtxPointer::HMACCtxPointer() : ctx_(nullptr) {}
+
+HMACCtxPointer::HMACCtxPointer(HMAC_CTX* ctx) : ctx_(ctx) {}
+
+HMACCtxPointer::HMACCtxPointer(HMACCtxPointer&& other) noexcept
+    : ctx_(other.release()) {}
+
+HMACCtxPointer& HMACCtxPointer::operator=(HMACCtxPointer&& other) noexcept {
+  ctx_.reset(other.release());
+  return *this;
+}
+
+HMACCtxPointer::~HMACCtxPointer() {
+  reset();
+}
+
+void HMACCtxPointer::reset(HMAC_CTX* ctx) {
+  ctx_.reset(ctx);
+}
+
+HMAC_CTX* HMACCtxPointer::release() {
+  return ctx_.release();
+}
+
+bool HMACCtxPointer::init(const Buffer<const void>& buf, const EVP_MD* md) {
+  if (!ctx_) return false;
+  return HMAC_Init_ex(ctx_.get(), buf.data, buf.len, md, nullptr) == 1;
+}
+
+bool HMACCtxPointer::update(const Buffer<const void>& buf) {
+  if (!ctx_) return false;
+  return HMAC_Update(ctx_.get(),
+                     static_cast<const unsigned char*>(buf.data),
+                     buf.len) == 1;
+}
+
+DataPointer HMACCtxPointer::digest() {
+  auto data = DataPointer::Alloc(EVP_MAX_MD_SIZE);
+  if (!data) return {};
+  Buffer<void> buf = data;
+  if (!digestInto(&buf)) return {};
+  return data.resize(buf.len);
+}
+
+bool HMACCtxPointer::digestInto(Buffer<void>* buf) {
+  if (!ctx_) return false;
+
+  unsigned int len = buf->len;
+  if (!HMAC_Final(ctx_.get(), static_cast<unsigned char*>(buf->data), &len)) {
+    return false;
+  }
+  buf->len = len;
+  return true;
+}
+
+HMACCtxPointer HMACCtxPointer::New() {
+  return HMACCtxPointer(HMAC_CTX_new());
+}
+
+DataPointer hashDigest(const Buffer<const unsigned char>& buf,
+                       const EVP_MD* md) {
+  if (md == nullptr) return {};
+  size_t md_len = EVP_MD_size(md);
+  unsigned int result_size;
+  auto data = DataPointer::Alloc(md_len);
+  if (!data) return {};
+
+  if (!EVP_Digest(buf.data,
+                  buf.len,
+                  reinterpret_cast<unsigned char*>(data.get()),
+                  &result_size,
+                  md,
+                  nullptr)) {
+    return {};
+  }
+
+  return data.resize(result_size);
+}
+
 }  // namespace ncrypto
diff --git a/deps/ncrypto/ncrypto.h b/deps/ncrypto/ncrypto.h
index e5bf2b529bf239..75ac9fd8d705aa 100644
--- a/deps/ncrypto/ncrypto.h
+++ b/deps/ncrypto/ncrypto.h
@@ -201,18 +201,28 @@ struct FunctionDeleter {
 template <typename T, void (*function)(T*)>
 using DeleteFnPtr = typename FunctionDeleter<T, function>::Pointer;
 
-using BignumCtxPointer = DeleteFnPtr<BN_CTX, BN_CTX_free>;
-using BignumGenCallbackPointer = DeleteFnPtr<BN_GENCB, BN_GENCB_free>;
-using EVPKeyCtxPointer = DeleteFnPtr<EVP_PKEY_CTX, EVP_PKEY_CTX_free>;
-using EVPMDCtxPointer = DeleteFnPtr<EVP_MD_CTX, EVP_MD_CTX_free>;
-using HMACCtxPointer = DeleteFnPtr<HMAC_CTX, HMAC_CTX_free>;
-using NetscapeSPKIPointer = DeleteFnPtr<NETSCAPE_SPKI, NETSCAPE_SPKI_free>;
 using PKCS8Pointer = DeleteFnPtr<PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO_free>;
 using RSAPointer = DeleteFnPtr<RSA, RSA_free>;
 using SSLSessionPointer = DeleteFnPtr<SSL_SESSION, SSL_SESSION_free>;
 
+class BIOPointer;
+class BignumPointer;
 class CipherCtxPointer;
+class DataPointer;
+class DHPointer;
 class ECKeyPointer;
+class EVPKeyPointer;
+class EVPMDCtxPointer;
+class SSLCtxPointer;
+class SSLPointer;
+class X509View;
+class X509Pointer;
+class ECDSASigPointer;
+class ECGroupPointer;
+class ECPointPointer;
+class ECKeyPointer;
+class Rsa;
+class Ec;
 
 struct StackOfXASN1Deleter {
   void operator()(STACK_OF(ASN1_OBJECT) * p) const {
@@ -228,6 +238,9 @@ struct Buffer {
   size_t len = 0;
 };
 
+DataPointer hashDigest(const Buffer<const unsigned char>& data,
+                       const EVP_MD* md);
+
 class Cipher final {
  public:
   Cipher() = default;
@@ -258,15 +271,108 @@ class Cipher final {
   static const Cipher FromNid(int nid);
   static const Cipher FromCtx(const CipherCtxPointer& ctx);
 
+  struct CipherParams {
+    int padding;
+    const EVP_MD* digest;
+    const Buffer<const void> label;
+  };
+
+  static DataPointer encrypt(const EVPKeyPointer& key,
+                             const CipherParams& params,
+                             const Buffer<const void> in);
+  static DataPointer decrypt(const EVPKeyPointer& key,
+                             const CipherParams& params,
+                             const Buffer<const void> in);
+
+  static DataPointer sign(const EVPKeyPointer& key,
+                          const CipherParams& params,
+                          const Buffer<const void> in);
+
+  static DataPointer recover(const EVPKeyPointer& key,
+                             const CipherParams& params,
+                             const Buffer<const void> in);
+
  private:
   const EVP_CIPHER* cipher_ = nullptr;
 };
 
+// ============================================================================
+// RSA
+
+class Rsa final {
+ public:
+  Rsa();
+  Rsa(OSSL3_CONST RSA* rsa);
+  NCRYPTO_DISALLOW_COPY_AND_MOVE(Rsa)
+
+  inline operator bool() const { return rsa_ != nullptr; }
+  inline operator OSSL3_CONST RSA*() const { return rsa_; }
+
+  struct PublicKey {
+    const BIGNUM* n;
+    const BIGNUM* e;
+    const BIGNUM* d;
+  };
+  struct PrivateKey {
+    const BIGNUM* p;
+    const BIGNUM* q;
+    const BIGNUM* dp;
+    const BIGNUM* dq;
+    const BIGNUM* qi;
+  };
+  struct PssParams {
+    std::string_view digest = "sha1";
+    std::optional<std::string_view> mgf1_digest = "sha1";
+    int64_t salt_length = 20;
+  };
+
+  const PublicKey getPublicKey() const;
+  const PrivateKey getPrivateKey() const;
+  const std::optional<PssParams> getPssParams() const;
+
+  bool setPublicKey(BignumPointer&& n, BignumPointer&& e);
+  bool setPrivateKey(BignumPointer&& d,
+                     BignumPointer&& q,
+                     BignumPointer&& p,
+                     BignumPointer&& dp,
+                     BignumPointer&& dq,
+                     BignumPointer&& qi);
+
+  using CipherParams = Cipher::CipherParams;
+
+  static DataPointer encrypt(const EVPKeyPointer& key,
+                             const CipherParams& params,
+                             const Buffer<const void> in);
+  static DataPointer decrypt(const EVPKeyPointer& key,
+                             const CipherParams& params,
+                             const Buffer<const void> in);
+
+ private:
+  OSSL3_CONST RSA* rsa_;
+};
+
+class Ec final {
+ public:
+  Ec();
+  Ec(OSSL3_CONST EC_KEY* key);
+  NCRYPTO_DISALLOW_COPY_AND_MOVE(Ec)
+
+  const EC_GROUP* getGroup() const;
+  int getCurve() const;
+
+  inline operator bool() const { return ec_ != nullptr; }
+  inline operator OSSL3_CONST EC_KEY*() const { return ec_; }
+
+ private:
+  OSSL3_CONST EC_KEY* ec_ = nullptr;
+};
+
 // A managed pointer to a buffer of data. When destroyed the underlying
 // buffer will be freed.
 class DataPointer final {
  public:
   static DataPointer Alloc(size_t len);
+  static DataPointer Copy(const Buffer<const void>& buffer);
 
   DataPointer() = default;
   explicit DataPointer(void* data, size_t len);
@@ -283,6 +389,11 @@ class DataPointer final {
   void reset(void* data = nullptr, size_t len = 0);
   void reset(const Buffer<void>& buffer);
 
+  // Sets the underlying data buffer to all zeros.
+  void zero();
+
+  DataPointer resize(size_t len);
+
   // Releases ownership of the underlying data buffer. It is the caller's
   // responsibility to ensure the buffer is appropriately freed.
   Buffer<void> release();
@@ -471,6 +582,74 @@ class CipherCtxPointer final {
   DeleteFnPtr<EVP_CIPHER_CTX, EVP_CIPHER_CTX_free> ctx_;
 };
 
+class EVPKeyCtxPointer final {
+ public:
+  EVPKeyCtxPointer();
+  explicit EVPKeyCtxPointer(EVP_PKEY_CTX* ctx);
+  EVPKeyCtxPointer(EVPKeyCtxPointer&& other) noexcept;
+  EVPKeyCtxPointer& operator=(EVPKeyCtxPointer&& other) noexcept;
+  NCRYPTO_DISALLOW_COPY(EVPKeyCtxPointer)
+  ~EVPKeyCtxPointer();
+
+  inline bool operator==(std::nullptr_t) const noexcept {
+    return ctx_ == nullptr;
+  }
+  inline operator bool() const { return ctx_ != nullptr; }
+  inline EVP_PKEY_CTX* get() const { return ctx_.get(); }
+  void reset(EVP_PKEY_CTX* ctx = nullptr);
+  EVP_PKEY_CTX* release();
+
+  bool initForDerive(const EVPKeyPointer& peer);
+  DataPointer derive() const;
+
+  bool initForParamgen();
+  bool setDhParameters(int prime_size, uint32_t generator);
+  bool setDsaParameters(uint32_t bits, std::optional<int> q_bits);
+  bool setEcParameters(int curve, int encoding);
+
+  bool setRsaOaepMd(const EVP_MD* md);
+  bool setRsaMgf1Md(const EVP_MD* md);
+  bool setRsaPadding(int padding);
+  bool setRsaKeygenPubExp(BignumPointer&& e);
+  bool setRsaKeygenBits(int bits);
+  bool setRsaPssKeygenMd(const EVP_MD* md);
+  bool setRsaPssKeygenMgf1Md(const EVP_MD* md);
+  bool setRsaPssSaltlen(int salt_len);
+  bool setRsaImplicitRejection();
+  bool setRsaOaepLabel(DataPointer&& data);
+
+  bool setSignatureMd(const EVPMDCtxPointer& md);
+
+  bool publicCheck() const;
+  bool privateCheck() const;
+
+  bool verify(const Buffer<const unsigned char>& sig,
+              const Buffer<const unsigned char>& data);
+  DataPointer sign(const Buffer<const unsigned char>& data);
+  bool signInto(const Buffer<const unsigned char>& data,
+                Buffer<unsigned char>* sig);
+
+  static constexpr int kDefaultRsaExponent = 0x10001;
+
+  static bool setRsaPadding(EVP_PKEY_CTX* ctx,
+                            int padding,
+                            std::optional<int> salt_len = std::nullopt);
+
+  EVPKeyPointer paramgen() const;
+
+  bool initForEncrypt();
+  bool initForDecrypt();
+  bool initForKeygen();
+  int initForVerify();
+  int initForSign();
+
+  static EVPKeyCtxPointer New(const EVPKeyPointer& key);
+  static EVPKeyCtxPointer NewFromID(int id);
+
+ private:
+  DeleteFnPtr<EVP_PKEY_CTX, EVP_PKEY_CTX_free> ctx_;
+};
+
 class EVPKeyPointer final {
  public:
   static EVPKeyPointer New();
@@ -478,6 +657,8 @@ class EVPKeyPointer final {
                                     const Buffer<const unsigned char>& data);
   static EVPKeyPointer NewRawPrivate(int id,
                                      const Buffer<const unsigned char>& data);
+  static EVPKeyPointer NewDH(DHPointer&& dh);
+  static EVPKeyPointer NewRSA(RSAPointer&& rsa);
 
   enum class PKEncodingType {
     // RSAPublicKey / RSAPrivateKey according to PKCS#1.
@@ -578,6 +759,15 @@ class EVPKeyPointer final {
 
   static bool IsRSAPrivateKey(const Buffer<const unsigned char>& buffer);
 
+  std::optional<uint32_t> getBytesOfRS() const;
+  int getDefaultSignPadding() const;
+  operator Rsa() const;
+
+  bool isRsaVariant() const;
+  bool isOneShotVariant() const;
+  bool isSigVariant() const;
+  bool validateDsaParameters() const;
+
  private:
   DeleteFnPtr<EVP_PKEY, EVP_PKEY_free> pkey_;
 };
@@ -663,9 +853,6 @@ struct StackOfX509Deleter {
 };
 using StackOfX509 = std::unique_ptr<STACK_OF(X509), StackOfX509Deleter>;
 
-class X509Pointer;
-class X509View;
-
 class SSLCtxPointer final {
  public:
   SSLCtxPointer() = default;
@@ -792,6 +979,14 @@ class X509View final {
   CheckMatch checkEmail(const std::string_view email, int flags) const;
   CheckMatch checkIp(const std::string_view ip, int flags) const;
 
+  using UsageCallback = std::function<void(std::string_view)>;
+  bool enumUsages(UsageCallback callback) const;
+
+  template <typename T>
+  using KeyCallback = std::function<bool(const T& t)>;
+  bool ifRsa(KeyCallback<Rsa> callback) const;
+  bool ifEc(KeyCallback<Ec> callback) const;
+
  private:
   const X509* cert_ = nullptr;
 };
@@ -948,6 +1143,77 @@ class ECKeyPointer final {
   DeleteFnPtr<EC_KEY, EC_KEY_free> key_;
 };
 
+class EVPMDCtxPointer final {
+ public:
+  EVPMDCtxPointer();
+  explicit EVPMDCtxPointer(EVP_MD_CTX* ctx);
+  EVPMDCtxPointer(EVPMDCtxPointer&& other) noexcept;
+  EVPMDCtxPointer& operator=(EVPMDCtxPointer&& other) noexcept;
+  NCRYPTO_DISALLOW_COPY(EVPMDCtxPointer)
+  ~EVPMDCtxPointer();
+
+  inline bool operator==(std::nullptr_t) noexcept { return ctx_ == nullptr; }
+  inline operator bool() const { return ctx_ != nullptr; }
+  inline EVP_MD_CTX* get() const { return ctx_.get(); }
+  inline operator EVP_MD_CTX*() const { return ctx_.get(); }
+  void reset(EVP_MD_CTX* ctx = nullptr);
+  EVP_MD_CTX* release();
+
+  bool digestInit(const EVP_MD* digest);
+  bool digestUpdate(const Buffer<const void>& in);
+  DataPointer digestFinal(size_t length);
+  bool digestFinalInto(Buffer<void>* buf);
+  size_t getExpectedSize();
+
+  std::optional<EVP_PKEY_CTX*> signInit(const EVPKeyPointer& key,
+                                        const EVP_MD* digest);
+  std::optional<EVP_PKEY_CTX*> verifyInit(const EVPKeyPointer& key,
+                                          const EVP_MD* digest);
+
+  DataPointer signOneShot(const Buffer<const unsigned char>& buf) const;
+  DataPointer sign(const Buffer<const unsigned char>& buf) const;
+  bool verify(const Buffer<const unsigned char>& buf,
+              const Buffer<const unsigned char>& sig) const;
+
+  const EVP_MD* getDigest() const;
+  size_t getDigestSize() const;
+  bool hasXofFlag() const;
+
+  bool copyTo(const EVPMDCtxPointer& other) const;
+
+  static EVPMDCtxPointer New();
+
+ private:
+  DeleteFnPtr<EVP_MD_CTX, EVP_MD_CTX_free> ctx_;
+};
+
+class HMACCtxPointer final {
+ public:
+  HMACCtxPointer();
+  explicit HMACCtxPointer(HMAC_CTX* ctx);
+  HMACCtxPointer(HMACCtxPointer&& other) noexcept;
+  HMACCtxPointer& operator=(HMACCtxPointer&& other) noexcept;
+  NCRYPTO_DISALLOW_COPY(HMACCtxPointer)
+  ~HMACCtxPointer();
+
+  inline bool operator==(std::nullptr_t) noexcept { return ctx_ == nullptr; }
+  inline operator bool() const { return ctx_ != nullptr; }
+  inline HMAC_CTX* get() const { return ctx_.get(); }
+  inline operator HMAC_CTX*() const { return ctx_.get(); }
+  void reset(HMAC_CTX* ctx = nullptr);
+  HMAC_CTX* release();
+
+  bool init(const Buffer<const void>& buf, const EVP_MD* md);
+  bool update(const Buffer<const void>& buf);
+  DataPointer digest();
+  bool digestInto(Buffer<void>* buf);
+
+  static HMACCtxPointer New();
+
+ private:
+  DeleteFnPtr<HMAC_CTX, HMAC_CTX_free> ctx_;
+};
+
 #ifndef OPENSSL_NO_ENGINE
 class EnginePointer final {
  public:
@@ -1025,12 +1291,17 @@ Buffer<char> ExportChallenge(const char* input, size_t length);
 // KDF
 
 const EVP_MD* getDigestByName(const std::string_view name);
+const EVP_CIPHER* getCipherByName(const std::string_view name);
 
 // Verify that the specified HKDF output length is valid for the given digest.
 // The maximum length for HKDF output for a given digest is 255 times the
 // hash size for the given digest algorithm.
 bool checkHkdfLength(const EVP_MD* md, size_t length);
 
+bool extractP1363(const Buffer<const unsigned char>& buf,
+                  unsigned char* dest,
+                  size_t n);
+
 DataPointer hkdf(const EVP_MD* md,
                  const Buffer<const unsigned char>& key,
                  const Buffer<const unsigned char>& info,
diff --git a/src/crypto/crypto_cipher.cc b/src/crypto/crypto_cipher.cc
index 61dd1e97d9672a..dca59f16723ef8 100644
--- a/src/crypto/crypto_cipher.cc
+++ b/src/crypto/crypto_cipher.cc
@@ -20,6 +20,7 @@ using ncrypto::SSLPointer;
 using v8::Array;
 using v8::ArrayBuffer;
 using v8::BackingStore;
+using v8::BackingStoreInitializationMode;
 using v8::Context;
 using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
@@ -244,26 +245,22 @@ void CipherBase::Initialize(Environment* env, Local<Object> target) {
             target,
             "publicEncrypt",
             PublicKeyCipher::Cipher<PublicKeyCipher::kPublic,
-                                    EVP_PKEY_encrypt_init,
-                                    EVP_PKEY_encrypt>);
+                                    ncrypto::Cipher::encrypt>);
   SetMethod(context,
             target,
             "privateDecrypt",
             PublicKeyCipher::Cipher<PublicKeyCipher::kPrivate,
-                                    EVP_PKEY_decrypt_init,
-                                    EVP_PKEY_decrypt>);
+                                    ncrypto::Cipher::decrypt>);
   SetMethod(context,
             target,
             "privateEncrypt",
             PublicKeyCipher::Cipher<PublicKeyCipher::kPrivate,
-                                    EVP_PKEY_sign_init,
-                                    EVP_PKEY_sign>);
+                                    ncrypto::Cipher::sign>);
   SetMethod(context,
             target,
             "publicDecrypt",
             PublicKeyCipher::Cipher<PublicKeyCipher::kPublic,
-                                    EVP_PKEY_verify_recover_init,
-                                    EVP_PKEY_verify_recover>);
+                                    ncrypto::Cipher::recover>);
 
   SetMethodNoSideEffect(context, target, "getCipherInfo", GetCipherInfo);
 
@@ -288,17 +285,13 @@ void CipherBase::RegisterExternalReferences(
   registry->Register(GetCiphers);
 
   registry->Register(PublicKeyCipher::Cipher<PublicKeyCipher::kPublic,
-                                             EVP_PKEY_encrypt_init,
-                                             EVP_PKEY_encrypt>);
+                                             ncrypto::Cipher::encrypt>);
   registry->Register(PublicKeyCipher::Cipher<PublicKeyCipher::kPrivate,
-                                             EVP_PKEY_decrypt_init,
-                                             EVP_PKEY_decrypt>);
+                                             ncrypto::Cipher::decrypt>);
   registry->Register(PublicKeyCipher::Cipher<PublicKeyCipher::kPrivate,
-                                             EVP_PKEY_sign_init,
-                                             EVP_PKEY_sign>);
+                                             ncrypto::Cipher::sign>);
   registry->Register(PublicKeyCipher::Cipher<PublicKeyCipher::kPublic,
-                                             EVP_PKEY_verify_recover_init,
-                                             EVP_PKEY_verify_recover>);
+                                             ncrypto::Cipher::recover>);
 
   registry->Register(GetCipherInfo);
 }
@@ -773,10 +766,10 @@ CipherBase::UpdateResult CipherBase::Update(
     return kErrorState;
   }
 
-  {
-    NoArrayBufferZeroFillScope no_zero_fill_scope(env()->isolate_data());
-    *out = ArrayBuffer::NewBackingStore(env()->isolate(), buf_len);
-  }
+  *out = ArrayBuffer::NewBackingStore(
+      env()->isolate(),
+      buf_len,
+      BackingStoreInitializationMode::kUninitialized);
 
   buffer = {
       .data = reinterpret_cast<const unsigned char*>(data),
@@ -853,11 +846,10 @@ bool CipherBase::Final(std::unique_ptr<BackingStore>* out) {
 
   const int mode = ctx_.getMode();
 
-  {
-    NoArrayBufferZeroFillScope no_zero_fill_scope(env()->isolate_data());
-    *out = ArrayBuffer::NewBackingStore(
-        env()->isolate(), static_cast<size_t>(ctx_.getBlockSize()));
-  }
+  *out = ArrayBuffer::NewBackingStore(
+      env()->isolate(),
+      static_cast<size_t>(ctx_.getBlockSize()),
+      BackingStoreInitializationMode::kUninitialized);
 
   if (kind_ == kDecipher &&
       Cipher::FromCtx(ctx_).isSupportedAuthenticatedMode()) {
@@ -939,9 +931,7 @@ void CipherBase::Final(const FunctionCallbackInfo<Value>& args) {
       Buffer::New(env, ab, 0, ab->ByteLength()).FromMaybe(Local<Value>()));
 }
 
-template <PublicKeyCipher::Operation operation,
-          PublicKeyCipher::EVP_PKEY_cipher_init_t EVP_PKEY_cipher_init,
-          PublicKeyCipher::EVP_PKEY_cipher_t EVP_PKEY_cipher>
+template <PublicKeyCipher::Cipher_t cipher>
 bool PublicKeyCipher::Cipher(
     Environment* env,
     const EVPKeyPointer& pkey,
@@ -950,62 +940,32 @@ bool PublicKeyCipher::Cipher(
     const ArrayBufferOrViewContents<unsigned char>& oaep_label,
     const ArrayBufferOrViewContents<unsigned char>& data,
     std::unique_ptr<BackingStore>* out) {
-  EVPKeyCtxPointer ctx = pkey.newCtx();
-  if (!ctx)
-    return false;
-  if (EVP_PKEY_cipher_init(ctx.get()) <= 0)
-    return false;
-  if (EVP_PKEY_CTX_set_rsa_padding(ctx.get(), padding) <= 0)
-    return false;
-
-  if (digest != nullptr) {
-    if (EVP_PKEY_CTX_set_rsa_oaep_md(ctx.get(), digest) <= 0)
-      return false;
-  }
-
-  if (!SetRsaOaepLabel(ctx, oaep_label.ToByteSource())) return false;
+  auto label = oaep_label.ToByteSource();
+  auto in = data.ToByteSource();
 
-  size_t out_len = 0;
-  if (EVP_PKEY_cipher(
-          ctx.get(),
-          nullptr,
-          &out_len,
-          data.data(),
-          data.size()) <= 0) {
-    return false;
-  }
-
-  {
-    NoArrayBufferZeroFillScope no_zero_fill_scope(env->isolate_data());
-    *out = ArrayBuffer::NewBackingStore(env->isolate(), out_len);
-  }
+  const ncrypto::Cipher::CipherParams params{
+      .padding = padding,
+      .digest = digest,
+      .label = label,
+  };
 
-  if (EVP_PKEY_cipher(
-          ctx.get(),
-          static_cast<unsigned char*>((*out)->Data()),
-          &out_len,
-          data.data(),
-          data.size()) <= 0) {
-    return false;
-  }
+  auto buf = cipher(pkey, params, in);
+  if (!buf) return false;
 
-  CHECK_LE(out_len, (*out)->ByteLength());
-  if (out_len == 0) {
+  if (buf.size() == 0) {
     *out = ArrayBuffer::NewBackingStore(env->isolate(), 0);
-  } else if (out_len != (*out)->ByteLength()) {
-    std::unique_ptr<BackingStore> old_out = std::move(*out);
-    *out = ArrayBuffer::NewBackingStore(env->isolate(), out_len);
+  } else {
+    *out = ArrayBuffer::NewBackingStore(env->isolate(), buf.size());
     memcpy(static_cast<char*>((*out)->Data()),
-           static_cast<char*>(old_out->Data()),
-           out_len);
+           static_cast<char*>(buf.get()),
+           buf.size());
   }
 
   return true;
 }
 
 template <PublicKeyCipher::Operation operation,
-          PublicKeyCipher::EVP_PKEY_cipher_init_t EVP_PKEY_cipher_init,
-          PublicKeyCipher::EVP_PKEY_cipher_t EVP_PKEY_cipher>
+          PublicKeyCipher::Cipher_t cipher>
 void PublicKeyCipher::Cipher(const FunctionCallbackInfo<Value>& args) {
   MarkPopErrorOnReturn mark_pop_error_on_return;
   Environment* env = Environment::GetCurrent(args);
@@ -1024,25 +984,16 @@ void PublicKeyCipher::Cipher(const FunctionCallbackInfo<Value>& args) {
   uint32_t padding;
   if (!args[offset + 1]->Uint32Value(env->context()).To(&padding)) return;
 
-  if (EVP_PKEY_cipher == EVP_PKEY_decrypt &&
+  if (cipher == ncrypto::Cipher::decrypt &&
       operation == PublicKeyCipher::kPrivate && padding == RSA_PKCS1_PADDING) {
     EVPKeyCtxPointer ctx = pkey.newCtx();
     CHECK(ctx);
 
-    if (EVP_PKEY_decrypt_init(ctx.get()) <= 0) {
+    if (!ctx.initForDecrypt()) {
       return ThrowCryptoError(env, ERR_get_error());
     }
 
-    int rsa_pkcs1_implicit_rejection =
-        EVP_PKEY_CTX_ctrl_str(ctx.get(), "rsa_pkcs1_implicit_rejection", "1");
-    // From the doc -2 means that the option is not supported.
-    // The default for the option is enabled and if it has been
-    // specifically disabled we want to respect that so we will
-    // not throw an error if the option is supported regardless
-    // of how it is set. The call to set the value
-    // will not affect what is used since a different context is
-    // used in the call if the option is supported
-    if (rsa_pkcs1_implicit_rejection <= 0) {
+    if (!ctx.setRsaImplicitRejection()) {
       return THROW_ERR_INVALID_ARG_VALUE(
           env,
           "RSA_PKCS1_PADDING is no longer supported for private decryption");
@@ -1052,7 +1003,7 @@ void PublicKeyCipher::Cipher(const FunctionCallbackInfo<Value>& args) {
   const EVP_MD* digest = nullptr;
   if (args[offset + 2]->IsString()) {
     const Utf8Value oaep_str(env->isolate(), args[offset + 2]);
-    digest = EVP_get_digestbyname(*oaep_str);
+    digest = ncrypto::getDigestByName(oaep_str.ToStringView());
     if (digest == nullptr)
       return THROW_ERR_OSSL_EVP_INVALID_DIGEST(env);
   }
@@ -1063,8 +1014,7 @@ void PublicKeyCipher::Cipher(const FunctionCallbackInfo<Value>& args) {
     return THROW_ERR_OUT_OF_RANGE(env, "oaepLabel is too big");
   }
   std::unique_ptr<BackingStore> out;
-  if (!Cipher<operation, EVP_PKEY_cipher_init, EVP_PKEY_cipher>(
-          env, pkey, padding, digest, oaep_label, buf, &out)) {
+  if (!Cipher<cipher>(env, pkey, padding, digest, oaep_label, buf, &out)) {
     return ThrowCryptoError(env, ERR_get_error());
   }
 
diff --git a/src/crypto/crypto_cipher.h b/src/crypto/crypto_cipher.h
index 57c424e7509fa2..950acfa2521ede 100644
--- a/src/crypto/crypto_cipher.h
+++ b/src/crypto/crypto_cipher.h
@@ -96,19 +96,17 @@ class CipherBase : public BaseObject {
 
 class PublicKeyCipher {
  public:
-  typedef int (*EVP_PKEY_cipher_init_t)(EVP_PKEY_CTX* ctx);
-  typedef int (*EVP_PKEY_cipher_t)(EVP_PKEY_CTX* ctx,
-                                   unsigned char* out, size_t* outlen,
-                                   const unsigned char* in, size_t inlen);
+  using Cipher_t =
+      ncrypto::DataPointer(const ncrypto::EVPKeyPointer&,
+                           const ncrypto::Cipher::CipherParams& params,
+                           const ncrypto::Buffer<const void>);
 
   enum Operation {
     kPublic,
     kPrivate
   };
 
-  template <Operation operation,
-            EVP_PKEY_cipher_init_t EVP_PKEY_cipher_init,
-            EVP_PKEY_cipher_t EVP_PKEY_cipher>
+  template <Cipher_t cipher>
   static bool Cipher(Environment* env,
                      const ncrypto::EVPKeyPointer& pkey,
                      int padding,
@@ -117,9 +115,7 @@ class PublicKeyCipher {
                      const ArrayBufferOrViewContents<unsigned char>& data,
                      std::unique_ptr<v8::BackingStore>* out);
 
-  template <Operation operation,
-            EVP_PKEY_cipher_init_t EVP_PKEY_cipher_init,
-            EVP_PKEY_cipher_t EVP_PKEY_cipher>
+  template <Operation operation, Cipher_t cipher>
   static void Cipher(const v8::FunctionCallbackInfo<v8::Value>& args);
 };
 
diff --git a/src/crypto/crypto_common.cc b/src/crypto/crypto_common.cc
index d94f6e1c82c4a6..591509e735b943 100644
--- a/src/crypto/crypto_common.cc
+++ b/src/crypto/crypto_common.cc
@@ -36,7 +36,7 @@ using ncrypto::StackOfX509;
 using ncrypto::X509Pointer;
 using ncrypto::X509View;
 using v8::ArrayBuffer;
-using v8::BackingStore;
+using v8::BackingStoreInitializationMode;
 using v8::Context;
 using v8::EscapableHandleScope;
 using v8::Integer;
@@ -307,11 +307,8 @@ MaybeLocal<Object> ECPointToBuffer(Environment* env,
     return MaybeLocal<Object>();
   }
 
-  std::unique_ptr<BackingStore> bs;
-  {
-    NoArrayBufferZeroFillScope no_zero_fill_scope(env->isolate_data());
-    bs = ArrayBuffer::NewBackingStore(env->isolate(), len);
-  }
+  auto bs = ArrayBuffer::NewBackingStore(
+      env->isolate(), len, BackingStoreInitializationMode::kUninitialized);
 
   len = EC_POINT_point2oct(group,
                            point,
diff --git a/src/crypto/crypto_context.cc b/src/crypto/crypto_context.cc
index c7574e67f03f03..da5cebb87a3d51 100644
--- a/src/crypto/crypto_context.cc
+++ b/src/crypto/crypto_context.cc
@@ -1451,7 +1451,7 @@ void SecureContext::GetCertificate(const FunctionCallbackInfo<Value>& args) {
 }
 
 // UseExtraCaCerts is called only once at the start of the Node.js process.
-void UseExtraCaCerts(const std::string& file) {
+void UseExtraCaCerts(std::string_view file) {
   extra_root_certs_file = file;
 }
 
diff --git a/src/crypto/crypto_dh.cc b/src/crypto/crypto_dh.cc
index 7041eb985d9f6d..0e25a937e175fa 100644
--- a/src/crypto/crypto_dh.cc
+++ b/src/crypto/crypto_dh.cc
@@ -397,31 +397,23 @@ EVPKeyCtxPointer DhKeyGenTraits::Setup(DhKeyPairGenConfig* params) {
     auto dh = DHPointer::New(std::move(prime), std::move(bn_g));
     if (!dh) return {};
 
-    key_params = EVPKeyPointer::New();
-    CHECK(key_params);
-    CHECK_EQ(EVP_PKEY_assign_DH(key_params.get(), dh.release()), 1);
+    key_params = EVPKeyPointer::NewDH(std::move(dh));
   } else if (int* prime_size = std::get_if<int>(&params->params.prime)) {
-    EVPKeyCtxPointer param_ctx(EVP_PKEY_CTX_new_id(EVP_PKEY_DH, nullptr));
-    EVP_PKEY* raw_params = nullptr;
-    if (!param_ctx ||
-        EVP_PKEY_paramgen_init(param_ctx.get()) <= 0 ||
-        EVP_PKEY_CTX_set_dh_paramgen_prime_len(
-            param_ctx.get(),
-            *prime_size) <= 0 ||
-        EVP_PKEY_CTX_set_dh_paramgen_generator(
-            param_ctx.get(),
-            params->params.generator) <= 0 ||
-        EVP_PKEY_paramgen(param_ctx.get(), &raw_params) <= 0) {
+    auto param_ctx = EVPKeyCtxPointer::NewFromID(EVP_PKEY_DH);
+    if (!param_ctx.initForParamgen() ||
+        !param_ctx.setDhParameters(*prime_size, params->params.generator)) {
       return {};
     }
 
-    key_params = EVPKeyPointer(raw_params);
+    key_params = param_ctx.paramgen();
   } else {
     UNREACHABLE();
   }
 
+  if (!key_params) return {};
+
   EVPKeyCtxPointer ctx = key_params.newCtx();
-  if (!ctx || EVP_PKEY_keygen_init(ctx.get()) <= 0) return {};
+  if (!ctx.initForKeygen()) return {};
 
   return ctx;
 }
diff --git a/src/crypto/crypto_dsa.cc b/src/crypto/crypto_dsa.cc
index 471fee77531139..cac05aa55f8dd2 100644
--- a/src/crypto/crypto_dsa.cc
+++ b/src/crypto/crypto_dsa.cc
@@ -12,22 +12,10 @@
 
 #include <cstdio>
 
-// EVP_PKEY_CTX_set_dsa_paramgen_q_bits was added in OpenSSL 1.1.1e.
-#if OPENSSL_VERSION_NUMBER < 0x1010105fL
-#define EVP_PKEY_CTX_set_dsa_paramgen_q_bits(ctx, qbits)                       \
-  EVP_PKEY_CTX_ctrl((ctx),                                                     \
-                    EVP_PKEY_DSA,                                              \
-                    EVP_PKEY_OP_PARAMGEN,                                      \
-                    EVP_PKEY_CTRL_DSA_PARAMGEN_Q_BITS,                         \
-                    (qbits),                                                   \
-                    nullptr)
-#endif
-
 namespace node {
 
 using ncrypto::BignumPointer;
 using ncrypto::EVPKeyCtxPointer;
-using ncrypto::EVPKeyPointer;
 using v8::FunctionCallbackInfo;
 using v8::Int32;
 using v8::JustVoid;
@@ -41,33 +29,22 @@ using v8::Value;
 
 namespace crypto {
 EVPKeyCtxPointer DsaKeyGenTraits::Setup(DsaKeyPairGenConfig* params) {
-  EVPKeyCtxPointer param_ctx(EVP_PKEY_CTX_new_id(EVP_PKEY_DSA, nullptr));
-  EVP_PKEY* raw_params = nullptr;
-
-  if (!param_ctx ||
-      EVP_PKEY_paramgen_init(param_ctx.get()) <= 0 ||
-      EVP_PKEY_CTX_set_dsa_paramgen_bits(
-          param_ctx.get(),
-          params->params.modulus_bits) <= 0) {
-    return EVPKeyCtxPointer();
-  }
-
-  if (params->params.divisor_bits != -1) {
-    if (EVP_PKEY_CTX_set_dsa_paramgen_q_bits(
-            param_ctx.get(), params->params.divisor_bits) <= 0) {
-      return EVPKeyCtxPointer();
-    }
+  auto param_ctx = EVPKeyCtxPointer::NewFromID(EVP_PKEY_DSA);
+
+  if (!param_ctx.initForParamgen() ||
+      !param_ctx.setDsaParameters(
+          params->params.modulus_bits,
+          params->params.divisor_bits != -1
+              ? std::optional<int>(params->params.divisor_bits)
+              : std::nullopt)) {
+    return {};
   }
 
-  if (EVP_PKEY_paramgen(param_ctx.get(), &raw_params) <= 0)
-    return EVPKeyCtxPointer();
+  auto key_params = param_ctx.paramgen();
+  if (!key_params) return {};
 
-  EVPKeyPointer key_params(raw_params);
   EVPKeyCtxPointer key_ctx = key_params.newCtx();
-
-  if (!key_ctx || EVP_PKEY_keygen_init(key_ctx.get()) <= 0)
-    return EVPKeyCtxPointer();
-
+  if (!key_ctx.initForKeygen()) return {};
   return key_ctx;
 }
 
diff --git a/src/crypto/crypto_ec.cc b/src/crypto/crypto_ec.cc
index 5ccda6f0768873..98f1e1312769ca 100644
--- a/src/crypto/crypto_ec.cc
+++ b/src/crypto/crypto_ec.cc
@@ -28,7 +28,7 @@ using ncrypto::EVPKeyPointer;
 using ncrypto::MarkPopErrorOnReturn;
 using v8::Array;
 using v8::ArrayBuffer;
-using v8::BackingStore;
+using v8::BackingStoreInitializationMode;
 using v8::Context;
 using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
@@ -201,14 +201,10 @@ void ECDH::ComputeSecret(const FunctionCallbackInfo<Value>& args) {
     return;
   }
 
-  std::unique_ptr<BackingStore> bs;
-  {
-    NoArrayBufferZeroFillScope no_zero_fill_scope(env->isolate_data());
-    // NOTE: field_size is in bits
-    int field_size = EC_GROUP_get_degree(ecdh->group_);
-    size_t out_len = (field_size + 7) / 8;
-    bs = ArrayBuffer::NewBackingStore(env->isolate(), out_len);
-  }
+  int field_size = EC_GROUP_get_degree(ecdh->group_);
+  size_t out_len = (field_size + 7) / 8;
+  auto bs = ArrayBuffer::NewBackingStore(
+      env->isolate(), out_len, BackingStoreInitializationMode::kUninitialized);
 
   if (!ECDH_compute_key(
           bs->Data(), bs->ByteLength(), pub, ecdh->key_.get(), nullptr))
@@ -257,12 +253,11 @@ void ECDH::GetPrivateKey(const FunctionCallbackInfo<Value>& args) {
     return THROW_ERR_CRYPTO_OPERATION_FAILED(env,
         "Failed to get ECDH private key");
 
-  std::unique_ptr<BackingStore> bs;
-  {
-    NoArrayBufferZeroFillScope no_zero_fill_scope(env->isolate_data());
-    bs = ArrayBuffer::NewBackingStore(env->isolate(),
-                                      BignumPointer::GetByteCount(b));
-  }
+  auto bs = ArrayBuffer::NewBackingStore(
+      env->isolate(),
+      BignumPointer::GetByteCount(b),
+      BackingStoreInitializationMode::kUninitialized);
+
   CHECK_EQ(bs->ByteLength(),
            BignumPointer::EncodePaddedInto(
                b, static_cast<unsigned char*>(bs->Data()), bs->ByteLength()));
@@ -459,24 +454,14 @@ bool ECDHBitsTraits::DeriveBits(Environment* env,
     case EVP_PKEY_X25519:
       // Fall through
     case EVP_PKEY_X448: {
-      EVPKeyCtxPointer ctx = m_privkey.newCtx();
       Mutex::ScopedLock pub_lock(params.public_.mutex());
-      if (EVP_PKEY_derive_init(ctx.get()) <= 0 ||
-          EVP_PKEY_derive_set_peer(
-              ctx.get(),
-              m_pubkey.get()) <= 0 ||
-          EVP_PKEY_derive(ctx.get(), nullptr, &len) <= 0) {
-        return false;
-      }
-
-      ByteSource::Builder buf(len);
-
-      if (EVP_PKEY_derive(ctx.get(), buf.data<unsigned char>(), &len) <= 0) {
-        return false;
-      }
+      EVPKeyCtxPointer ctx = m_privkey.newCtx();
+      if (!ctx.initForDerive(m_pubkey)) return false;
 
-      *out = std::move(buf).release(len);
+      auto data = ctx.derive();
+      if (!data) return false;
 
+      *out = ByteSource::Allocated(data.release());
       break;
     }
     default: {
@@ -523,28 +508,24 @@ EVPKeyCtxPointer EcKeyGenTraits::Setup(EcKeyPairGenConfig* params) {
     case EVP_PKEY_X25519:
       // Fall through
     case EVP_PKEY_X448:
-      key_ctx.reset(EVP_PKEY_CTX_new_id(params->params.curve_nid, nullptr));
+      key_ctx = EVPKeyCtxPointer::NewFromID(params->params.curve_nid);
       break;
     default: {
-      EVPKeyCtxPointer param_ctx(EVP_PKEY_CTX_new_id(EVP_PKEY_EC, nullptr));
-      EVP_PKEY* raw_params = nullptr;
-      if (!param_ctx ||
-          EVP_PKEY_paramgen_init(param_ctx.get()) <= 0 ||
-          EVP_PKEY_CTX_set_ec_paramgen_curve_nid(
-              param_ctx.get(), params->params.curve_nid) <= 0 ||
-          EVP_PKEY_CTX_set_ec_param_enc(
-              param_ctx.get(), params->params.param_encoding) <= 0 ||
-          EVP_PKEY_paramgen(param_ctx.get(), &raw_params) <= 0) {
-        return EVPKeyCtxPointer();
+      auto param_ctx = EVPKeyCtxPointer::NewFromID(EVP_PKEY_EC);
+      if (!param_ctx.initForParamgen() ||
+          !param_ctx.setEcParameters(params->params.curve_nid,
+                                     params->params.param_encoding)) {
+        return {};
       }
-      EVPKeyPointer key_params(raw_params);
+
+      auto key_params = param_ctx.paramgen();
+      if (!key_params) return {};
+
       key_ctx = key_params.newCtx();
     }
   }
 
-  if (key_ctx && EVP_PKEY_keygen_init(key_ctx.get()) <= 0)
-    key_ctx.reset();
-
+  if (!key_ctx.initForKeygen()) return {};
   return key_ctx;
 }
 
diff --git a/src/crypto/crypto_hash.cc b/src/crypto/crypto_hash.cc
index bcd4c533b07ceb..851847483327c1 100644
--- a/src/crypto/crypto_hash.cc
+++ b/src/crypto/crypto_hash.cc
@@ -11,6 +11,7 @@
 
 namespace node {
 
+using ncrypto::DataPointer;
 using ncrypto::EVPMDCtxPointer;
 using ncrypto::MarkPopErrorOnReturn;
 using v8::Context;
@@ -59,7 +60,7 @@ struct MaybeCachedMD {
 };
 
 MaybeCachedMD FetchAndMaybeCacheMD(Environment* env, const char* search_name) {
-  const EVP_MD* implicit_md = EVP_get_digestbyname(search_name);
+  const EVP_MD* implicit_md = ncrypto::getDigestByName(search_name);
   if (!implicit_md) return {nullptr, nullptr, -1};
 
   const char* real_name = EVP_MD_get0_name(implicit_md);
@@ -202,7 +203,7 @@ const EVP_MD* GetDigestImplementation(Environment* env,
   return result.explicit_md ? result.explicit_md : result.implicit_md;
 #else
   Utf8Value utf8(env->isolate(), algorithm);
-  return EVP_get_digestbyname(*utf8);
+  return ncrypto::getDigestByName(utf8.ToStringView());
 #endif
 }
 
@@ -220,7 +221,7 @@ void Hash::OneShotDigest(const FunctionCallbackInfo<Value>& args) {
   CHECK(args[5]->IsUint32() || args[5]->IsUndefined());  // outputEncodingId
 
   const EVP_MD* md = GetDigestImplementation(env, args[0], args[1], args[2]);
-  if (md == nullptr) {
+  if (md == nullptr) [[unlikely]] {
     Utf8Value method(isolate, args[0]);
     std::string message =
         "Digest method " + method.ToString() + " is not supported";
@@ -229,41 +230,36 @@ void Hash::OneShotDigest(const FunctionCallbackInfo<Value>& args) {
 
   enum encoding output_enc = ParseEncoding(isolate, args[4], args[5], HEX);
 
-  int md_len = EVP_MD_size(md);
-  unsigned int result_size;
-  ByteSource::Builder output(md_len);
-  int success;
-  // On smaller inputs, EVP_Digest() can be slower than the
-  // deprecated helpers e.g SHA256_XXX. The speedup may not
-  // be worth using deprecated APIs, however, so we use
-  // EVP_Digest(), unless there's a better alternative
-  // in the future.
-  // https://github.com/openssl/openssl/issues/19612
-  if (args[3]->IsString()) {
-    Utf8Value utf8(isolate, args[3]);
-    success = EVP_Digest(utf8.out(),
-                         utf8.length(),
-                         output.data<unsigned char>(),
-                         &result_size,
-                         md,
-                         nullptr);
-  } else {
+  DataPointer output = ([&] {
+    if (args[3]->IsString()) {
+      Utf8Value utf8(isolate, args[3]);
+      ncrypto::Buffer<const unsigned char> buf{
+          .data = reinterpret_cast<const unsigned char*>(utf8.out()),
+          .len = utf8.length(),
+      };
+      return ncrypto::hashDigest(buf, md);
+    }
+
     ArrayBufferViewContents<unsigned char> input(args[3]);
-    success = EVP_Digest(input.data(),
-                         input.length(),
-                         output.data<unsigned char>(),
-                         &result_size,
-                         md,
-                         nullptr);
-  }
-  if (!success) {
+    ncrypto::Buffer<const unsigned char> buf{
+        .data = reinterpret_cast<const unsigned char*>(input.data()),
+        .len = input.length(),
+    };
+    return ncrypto::hashDigest(buf, md);
+  })();
+
+  if (!output) [[unlikely]] {
     return ThrowCryptoError(env, ERR_get_error());
   }
 
   Local<Value> error;
-  MaybeLocal<Value> rc = StringBytes::Encode(
-      env->isolate(), output.data<char>(), md_len, output_enc, &error);
-  if (rc.IsEmpty()) {
+  MaybeLocal<Value> rc =
+      StringBytes::Encode(env->isolate(),
+                          static_cast<const char*>(output.get()),
+                          output.size(),
+                          output_enc,
+                          &error);
+  if (rc.IsEmpty()) [[unlikely]] {
     CHECK(!error.IsEmpty());
     env->isolate()->ThrowException(error);
     return;
@@ -314,7 +310,8 @@ void Hash::New(const FunctionCallbackInfo<Value>& args) {
   const EVP_MD* md = nullptr;
   if (args[0]->IsObject()) {
     ASSIGN_OR_RETURN_UNWRAP(&orig, args[0].As<Object>());
-    md = EVP_MD_CTX_md(orig->mdctx_.get());
+    CHECK_NOT_NULL(orig);
+    md = orig->mdctx_.getDigest();
   } else {
     md = GetDigestImplementation(env, args[0], args[2], args[3]);
   }
@@ -331,25 +328,25 @@ void Hash::New(const FunctionCallbackInfo<Value>& args) {
                             "Digest method not supported");
   }
 
-  if (orig != nullptr &&
-      0 >= EVP_MD_CTX_copy(hash->mdctx_.get(), orig->mdctx_.get())) {
+  if (orig != nullptr && !orig->mdctx_.copyTo(hash->mdctx_)) {
     return ThrowCryptoError(env, ERR_get_error(), "Digest copy error");
   }
 }
 
 bool Hash::HashInit(const EVP_MD* md, Maybe<unsigned int> xof_md_len) {
-  mdctx_.reset(EVP_MD_CTX_new());
-  if (!mdctx_ || EVP_DigestInit_ex(mdctx_.get(), md, nullptr) <= 0) {
+  mdctx_ = EVPMDCtxPointer::New();
+  if (!mdctx_.digestInit(md)) [[unlikely]] {
     mdctx_.reset();
     return false;
   }
 
-  md_len_ = EVP_MD_size(md);
+  md_len_ = mdctx_.getDigestSize();
   if (xof_md_len.IsJust() && xof_md_len.FromJust() != md_len_) {
     // This is a little hack to cause createHash to fail when an incorrect
     // hashSize option was passed for a non-XOF hash function.
-    if ((EVP_MD_flags(md) & EVP_MD_FLAG_XOF) == 0) {
+    if (!mdctx_.hasXofFlag()) [[unlikely]] {
       EVPerr(EVP_F_EVP_DIGESTFINALXOF, EVP_R_NOT_XOF_OR_INVALID_LENGTH);
+      mdctx_.reset();
       return false;
     }
     md_len_ = xof_md_len.FromJust();
@@ -359,9 +356,11 @@ bool Hash::HashInit(const EVP_MD* md, Maybe<unsigned int> xof_md_len) {
 }
 
 bool Hash::HashUpdate(const char* data, size_t len) {
-  if (!mdctx_)
-    return false;
-  return EVP_DigestUpdate(mdctx_.get(), data, len) == 1;
+  if (!mdctx_) return false;
+  return mdctx_.digestUpdate(ncrypto::Buffer<const void>{
+      .data = data,
+      .len = len,
+  });
 }
 
 void Hash::HashUpdate(const FunctionCallbackInfo<Value>& args) {
@@ -402,31 +401,18 @@ void Hash::HashDigest(const FunctionCallbackInfo<Value>& args) {
     // and Hash.digest can both be used to retrieve the digest,
     // so we need to cache it.
     // See https://github.com/nodejs/node/issues/28245.
-
-    ByteSource::Builder digest(len);
-
-    size_t default_len = EVP_MD_CTX_size(hash->mdctx_.get());
-    int ret;
-    if (len == default_len) {
-      ret = EVP_DigestFinal_ex(
-          hash->mdctx_.get(), digest.data<unsigned char>(), &len);
-      // The output length should always equal hash->md_len_
-      CHECK_EQ(len, hash->md_len_);
-    } else {
-      ret = EVP_DigestFinalXOF(
-          hash->mdctx_.get(), digest.data<unsigned char>(), len);
-    }
-
-    if (ret != 1)
+    auto data = hash->mdctx_.digestFinal(len);
+    if (!data) [[unlikely]] {
       return ThrowCryptoError(env, ERR_get_error());
+    }
 
-    hash->digest_ = std::move(digest).release();
+    hash->digest_ = ByteSource::Allocated(data.release());
   }
 
   Local<Value> error;
   MaybeLocal<Value> rc = StringBytes::Encode(
       env->isolate(), hash->digest_.data<char>(), len, encoding, &error);
-  if (rc.IsEmpty()) {
+  if (rc.IsEmpty()) [[unlikely]] {
     CHECK(!error.IsEmpty());
     env->isolate()->ThrowException(error);
     return;
@@ -469,7 +455,7 @@ Maybe<void> HashTraits::AdditionalConfig(
 
   CHECK(args[offset]->IsString());  // Hash algorithm
   Utf8Value digest(env->isolate(), args[offset]);
-  params->digest = EVP_get_digestbyname(*digest);
+  params->digest = ncrypto::getDigestByName(digest.ToStringView());
   if (params->digest == nullptr) [[unlikely]] {
     THROW_ERR_CRYPTO_INVALID_DIGEST(env, "Invalid digest: %s", *digest);
     return Nothing<void>();
@@ -492,7 +478,7 @@ Maybe<void> HashTraits::AdditionalConfig(
         static_cast<uint32_t>(args[offset + 2]
             .As<Uint32>()->Value()) / CHAR_BIT;
     if (params->length != expected) {
-      if ((EVP_MD_flags(params->digest) & EVP_MD_FLAG_XOF) == 0) {
+      if ((EVP_MD_flags(params->digest) & EVP_MD_FLAG_XOF) == 0) [[unlikely]] {
         THROW_ERR_CRYPTO_INVALID_DIGEST(env, "Digest method not supported");
         return Nothing<void>();
       }
@@ -506,29 +492,19 @@ bool HashTraits::DeriveBits(
     Environment* env,
     const HashConfig& params,
     ByteSource* out) {
-  EVPMDCtxPointer ctx(EVP_MD_CTX_new());
+  auto ctx = EVPMDCtxPointer::New();
 
-  if (!ctx || EVP_DigestInit_ex(ctx.get(), params.digest, nullptr) <= 0 ||
-      EVP_DigestUpdate(ctx.get(), params.in.data<char>(), params.in.size()) <=
-          0) [[unlikely]] {
+  if (!ctx.digestInit(params.digest) || !ctx.digestUpdate(params.in))
+      [[unlikely]] {
     return false;
   }
 
   if (params.length > 0) [[likely]] {
-    unsigned int length = params.length;
-    ByteSource::Builder buf(length);
-
-    size_t expected = EVP_MD_CTX_size(ctx.get());
-
-    int ret =
-        (length == expected)
-            ? EVP_DigestFinal_ex(ctx.get(), buf.data<unsigned char>(), &length)
-            : EVP_DigestFinalXOF(ctx.get(), buf.data<unsigned char>(), length);
-
-    if (ret != 1) [[unlikely]]
+    auto data = ctx.digestFinal(params.length);
+    if (!data) [[unlikely]]
       return false;
 
-    *out = std::move(buf).release();
+    *out = ByteSource::Allocated(data.release());
   }
 
   return true;
@@ -548,7 +524,7 @@ void InternalVerifyIntegrity(const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK(args[2]->IsArrayBufferView());
   ArrayBufferOrViewContents<unsigned char> expected(args[2]);
 
-  const EVP_MD* md_type = EVP_get_digestbyname(*algorithm);
+  const EVP_MD* md_type = ncrypto::getDigestByName(algorithm.ToStringView());
   unsigned char digest[EVP_MAX_MD_SIZE];
   unsigned int digest_size;
   if (md_type == nullptr || EVP_Digest(content.data(),
@@ -556,7 +532,7 @@ void InternalVerifyIntegrity(const v8::FunctionCallbackInfo<v8::Value>& args) {
                                        digest,
                                        &digest_size,
                                        md_type,
-                                       nullptr) != 1) {
+                                       nullptr) != 1) [[unlikely]] {
     return ThrowCryptoError(
         env, ERR_get_error(), "Digest method not supported");
   }
@@ -570,7 +546,7 @@ void InternalVerifyIntegrity(const v8::FunctionCallbackInfo<v8::Value>& args) {
                             digest_size,
                             BASE64,
                             &error);
-    if (rc.IsEmpty()) {
+    if (rc.IsEmpty()) [[unlikely]] {
       CHECK(!error.IsEmpty());
       env->isolate()->ThrowException(error);
       return;
diff --git a/src/crypto/crypto_hkdf.cc b/src/crypto/crypto_hkdf.cc
index 2a465c849def44..10bb8e4258bf63 100644
--- a/src/crypto/crypto_hkdf.cc
+++ b/src/crypto/crypto_hkdf.cc
@@ -55,7 +55,7 @@ Maybe<void> HKDFTraits::AdditionalConfig(
 
   Utf8Value hash(env->isolate(), args[offset]);
   params->digest = ncrypto::getDigestByName(hash.ToStringView());
-  if (params->digest == nullptr) {
+  if (params->digest == nullptr) [[unlikely]] {
     THROW_ERR_CRYPTO_INVALID_DIGEST(env, "Invalid digest: %s", *hash);
     return Nothing<void>();
   }
@@ -88,7 +88,7 @@ Maybe<void> HKDFTraits::AdditionalConfig(
   // HKDF-Expand computes up to 255 HMAC blocks, each having as many bits as the
   // output of the hash function. 255 is a hard limit because HKDF appends an
   // 8-bit counter to each HMAC'd message, starting at 1.
-  if (!ncrypto::checkHkdfLength(params->digest, params->length)) {
+  if (!ncrypto::checkHkdfLength(params->digest, params->length)) [[unlikely]] {
     THROW_ERR_CRYPTO_INVALID_KEYLEN(env);
     return Nothing<void>();
   }
diff --git a/src/crypto/crypto_hmac.cc b/src/crypto/crypto_hmac.cc
index 25ccb1b9d04e51..56a09e1a2d9b0f 100644
--- a/src/crypto/crypto_hmac.cc
+++ b/src/crypto/crypto_hmac.cc
@@ -70,15 +70,21 @@ void Hmac::New(const FunctionCallbackInfo<Value>& args) {
 void Hmac::HmacInit(const char* hash_type, const char* key, int key_len) {
   HandleScope scope(env()->isolate());
 
-  const EVP_MD* md = EVP_get_digestbyname(hash_type);
-  if (md == nullptr)
+  const EVP_MD* md = ncrypto::getDigestByName(hash_type);
+  if (md == nullptr) [[unlikely]] {
     return THROW_ERR_CRYPTO_INVALID_DIGEST(
         env(), "Invalid digest: %s", hash_type);
+  }
   if (key_len == 0) {
     key = "";
   }
-  ctx_.reset(HMAC_CTX_new());
-  if (!ctx_ || !HMAC_Init_ex(ctx_.get(), key, key_len, md, nullptr)) {
+
+  ctx_ = HMACCtxPointer::New();
+  ncrypto::Buffer<const void> key_buf{
+      .data = key,
+      .len = static_cast<size_t>(key_len),
+  };
+  if (!ctx_.init(key_buf, md)) [[unlikely]] {
     ctx_.reset();
     return ThrowCryptoError(env(), ERR_get_error());
   }
@@ -95,9 +101,11 @@ void Hmac::HmacInit(const FunctionCallbackInfo<Value>& args) {
 }
 
 bool Hmac::HmacUpdate(const char* data, size_t len) {
-  return ctx_ && HMAC_Update(ctx_.get(),
-                             reinterpret_cast<const unsigned char*>(data),
-                             len) == 1;
+  ncrypto::Buffer<const void> buf{
+      .data = data,
+      .len = len,
+  };
+  return ctx_.update(buf);
 }
 
 void Hmac::HmacUpdate(const FunctionCallbackInfo<Value>& args) {
@@ -123,24 +131,27 @@ void Hmac::HmacDigest(const FunctionCallbackInfo<Value>& args) {
   }
 
   unsigned char md_value[EVP_MAX_MD_SIZE];
-  unsigned int md_len = 0;
+  ncrypto::Buffer<void> buf{
+      .data = md_value,
+      .len = sizeof(md_value),
+  };
 
   if (hmac->ctx_) {
-    bool ok = HMAC_Final(hmac->ctx_.get(), md_value, &md_len);
-    hmac->ctx_.reset();
-    if (!ok) {
+    if (!hmac->ctx_.digestInto(&buf)) [[unlikely]] {
+      hmac->ctx_.reset();
       return ThrowCryptoError(env, ERR_get_error(), "Failed to finalize HMAC");
     }
+    hmac->ctx_.reset();
   }
 
   Local<Value> error;
   MaybeLocal<Value> rc =
       StringBytes::Encode(env->isolate(),
                           reinterpret_cast<const char*>(md_value),
-                          md_len,
+                          buf.len,
                           encoding,
                           &error);
-  if (rc.IsEmpty()) {
+  if (rc.IsEmpty()) [[unlikely]] {
     CHECK(!error.IsEmpty());
     env->isolate()->ThrowException(error);
     return;
@@ -188,8 +199,8 @@ Maybe<void> HmacTraits::AdditionalConfig(
   CHECK(args[offset + 2]->IsObject());  // Key
 
   Utf8Value digest(env->isolate(), args[offset + 1]);
-  params->digest = EVP_get_digestbyname(*digest);
-  if (params->digest == nullptr) {
+  params->digest = ncrypto::getDigestByName(digest.ToStringView());
+  if (params->digest == nullptr) [[unlikely]] {
     THROW_ERR_CRYPTO_INVALID_DIGEST(env, "Invalid digest: %s", *digest);
     return Nothing<void>();
   }
@@ -225,31 +236,29 @@ bool HmacTraits::DeriveBits(
     Environment* env,
     const HmacConfig& params,
     ByteSource* out) {
-  HMACCtxPointer ctx(HMAC_CTX_new());
+  auto ctx = HMACCtxPointer::New();
 
-  if (!ctx || !HMAC_Init_ex(ctx.get(),
-                            params.key.GetSymmetricKey(),
-                            params.key.GetSymmetricKeySize(),
-                            params.digest,
-                            nullptr)) {
+  ncrypto::Buffer<const void> key_buf{
+      .data = params.key.GetSymmetricKey(),
+      .len = params.key.GetSymmetricKeySize(),
+  };
+  if (!ctx.init(key_buf, params.digest)) [[unlikely]] {
     return false;
   }
 
-  if (!HMAC_Update(
-          ctx.get(),
-          params.data.data<unsigned char>(),
-          params.data.size())) {
+  ncrypto::Buffer<const void> buffer{
+      .data = params.data.data(),
+      .len = params.data.size(),
+  };
+  if (!ctx.update(buffer)) [[unlikely]] {
     return false;
   }
 
-  ByteSource::Builder buf(EVP_MAX_MD_SIZE);
-  unsigned int len;
-
-  if (!HMAC_Final(ctx.get(), buf.data<unsigned char>(), &len)) {
+  auto buf = ctx.digest();
+  if (!buf) [[unlikely]]
     return false;
-  }
 
-  *out = std::move(buf).release(len);
+  *out = ByteSource::Allocated(buf.release());
 
   return true;
 }
@@ -258,9 +267,9 @@ MaybeLocal<Value> HmacTraits::EncodeOutput(Environment* env,
                                            const HmacConfig& params,
                                            ByteSource* out) {
   switch (params.mode) {
-    case SignConfiguration::kSign:
+    case SignConfiguration::Mode::Sign:
       return out->ToArrayBuffer(env);
-    case SignConfiguration::kVerify:
+    case SignConfiguration::Mode::Verify:
       return Boolean::New(
           env->isolate(),
           out->size() > 0 && out->size() == params.signature.size() &&
diff --git a/src/crypto/crypto_keygen.cc b/src/crypto/crypto_keygen.cc
index 246191f5d51796..7c3a85e9f8a24d 100644
--- a/src/crypto/crypto_keygen.cc
+++ b/src/crypto/crypto_keygen.cc
@@ -47,10 +47,8 @@ Maybe<void> NidKeyPairGenTraits::AdditionalConfig(
 }
 
 EVPKeyCtxPointer NidKeyPairGenTraits::Setup(NidKeyPairGenConfig* params) {
-  EVPKeyCtxPointer ctx =
-      EVPKeyCtxPointer(EVP_PKEY_CTX_new_id(params->params.id, nullptr));
-  if (!ctx || EVP_PKEY_keygen_init(ctx.get()) <= 0) return {};
-
+  auto ctx = EVPKeyCtxPointer::NewFromID(params->params.id);
+  if (!ctx || !ctx.initForKeygen()) return {};
   return ctx;
 }
 
diff --git a/src/crypto/crypto_keys.cc b/src/crypto/crypto_keys.cc
index bedcf04d036478..2c55828facc35b 100644
--- a/src/crypto/crypto_keys.cc
+++ b/src/crypto/crypto_keys.cc
@@ -349,7 +349,7 @@ KeyObjectData::GetPrivateKeyEncodingFromJs(
     if (context != kKeyContextInput) {
       if (args[*offset]->IsString()) {
         Utf8Value cipher_name(env->isolate(), args[*offset]);
-        config.cipher = EVP_get_cipherbyname(*cipher_name);
+        config.cipher = ncrypto::getCipherByName(cipher_name.ToStringView());
         if (config.cipher == nullptr) {
           THROW_ERR_CRYPTO_UNKNOWN_CIPHER(env);
           return Nothing<EVPKeyPointer::PrivateKeyEncodingConfig>();
@@ -597,7 +597,7 @@ bool KeyObjectHandle::HasInstance(Environment* env, Local<Value> value) {
   return !t.IsEmpty() && t->HasInstance(value);
 }
 
-v8::Local<v8::Function> KeyObjectHandle::Initialize(Environment* env) {
+Local<Function> KeyObjectHandle::Initialize(Environment* env) {
   Local<FunctionTemplate> templ = env->crypto_key_object_handle_constructor();
   if (templ.IsEmpty()) {
     Isolate* isolate = env->isolate();
@@ -958,14 +958,10 @@ bool KeyObjectHandle::CheckEcKeyData() const {
   CHECK_EQ(key.id(), EVP_PKEY_EC);
 
   if (data_.GetKeyType() == kKeyTypePrivate) {
-    return EVP_PKEY_check(ctx.get()) == 1;
+    return ctx.privateCheck();
   }
 
-#if OPENSSL_VERSION_MAJOR >= 3
-  return EVP_PKEY_public_check_quick(ctx.get()) == 1;
-#else
-  return EVP_PKEY_public_check(ctx.get()) == 1;
-#endif
+  return ctx.publicCheck();
 }
 
 void KeyObjectHandle::CheckEcKeyData(const FunctionCallbackInfo<Value>& args) {
@@ -1202,6 +1198,9 @@ void Initialize(Environment* env, Local<Object> target) {
   constexpr int kKeyFormatJWK =
       static_cast<int>(EVPKeyPointer::PKFormatType::JWK);
 
+  constexpr auto kSigEncDER = DSASigEnc::DER;
+  constexpr auto kSigEncP1363 = DSASigEnc::P1363;
+
   NODE_DEFINE_CONSTANT(target, kWebCryptoKeyFormatRaw);
   NODE_DEFINE_CONSTANT(target, kWebCryptoKeyFormatPKCS8);
   NODE_DEFINE_CONSTANT(target, kWebCryptoKeyFormatSPKI);
diff --git a/src/crypto/crypto_pbkdf2.cc b/src/crypto/crypto_pbkdf2.cc
index dcaa430aacd3d7..1a0dff8238d938 100644
--- a/src/crypto/crypto_pbkdf2.cc
+++ b/src/crypto/crypto_pbkdf2.cc
@@ -88,20 +88,20 @@ Maybe<void> PBKDF2Traits::AdditionalConfig(
   CHECK(args[offset + 4]->IsString());  // digest_name
 
   params->iterations = args[offset + 2].As<Int32>()->Value();
-  if (params->iterations < 0) {
+  if (params->iterations < 0) [[unlikely]] {
     THROW_ERR_OUT_OF_RANGE(env, "iterations must be <= %d", INT_MAX);
     return Nothing<void>();
   }
 
   params->length = args[offset + 3].As<Int32>()->Value();
-  if (params->length < 0) {
+  if (params->length < 0) [[unlikely]] {
     THROW_ERR_OUT_OF_RANGE(env, "length must be <= %d", INT_MAX);
     return Nothing<void>();
   }
 
   Utf8Value name(args.GetIsolate(), args[offset + 4]);
   params->digest = ncrypto::getDigestByName(name.ToStringView());
-  if (params->digest == nullptr) {
+  if (params->digest == nullptr) [[unlikely]] {
     THROW_ERR_CRYPTO_INVALID_DIGEST(env, "Invalid digest: %s", *name);
     return Nothing<void>();
   }
diff --git a/src/crypto/crypto_random.cc b/src/crypto/crypto_random.cc
index cb96698aa644c3..4e9ff906c06571 100644
--- a/src/crypto/crypto_random.cc
+++ b/src/crypto/crypto_random.cc
@@ -14,7 +14,6 @@ namespace node {
 using ncrypto::BignumPointer;
 using ncrypto::ClearErrorOnReturn;
 using v8::ArrayBuffer;
-using v8::BackingStore;
 using v8::Boolean;
 using v8::FunctionCallbackInfo;
 using v8::Int32;
@@ -25,6 +24,7 @@ using v8::MaybeLocal;
 using v8::Nothing;
 using v8::Object;
 using v8::Uint32;
+using v8::Undefined;
 using v8::Value;
 
 namespace crypto {
@@ -39,7 +39,7 @@ BignumPointer::PrimeCheckCallback getPrimeCheckCallback(Environment* env) {
 }  // namespace
 MaybeLocal<Value> RandomBytesTraits::EncodeOutput(
     Environment* env, const RandomBytesConfig& params, ByteSource* unused) {
-  return v8::Undefined(env->isolate());
+  return Undefined(env->isolate());
 }
 
 Maybe<void> RandomBytesTraits::AdditionalConfig(
@@ -78,14 +78,13 @@ void RandomPrimeConfig::MemoryInfo(MemoryTracker* tracker) const {
 MaybeLocal<Value> RandomPrimeTraits::EncodeOutput(
     Environment* env, const RandomPrimeConfig& params, ByteSource* unused) {
   size_t size = params.prime.byteLength();
-  std::shared_ptr<BackingStore> store =
-      ArrayBuffer::NewBackingStore(env->isolate(), size);
+  auto store = ArrayBuffer::NewBackingStore(env->isolate(), size);
   CHECK_EQ(size,
            BignumPointer::EncodePaddedInto(
                params.prime.get(),
                reinterpret_cast<unsigned char*>(store->Data()),
                size));
-  return ArrayBuffer::New(env->isolate(), store);
+  return ArrayBuffer::New(env->isolate(), std::move(store));
 }
 
 Maybe<void> RandomPrimeTraits::AdditionalConfig(
@@ -104,7 +103,7 @@ Maybe<void> RandomPrimeTraits::AdditionalConfig(
   if (!args[offset + 2]->IsUndefined()) {
     ArrayBufferOrViewContents<unsigned char> add(args[offset + 2]);
     params->add.reset(add.data(), add.size());
-    if (!params->add) {
+    if (!params->add) [[unlikely]] {
       THROW_ERR_CRYPTO_OPERATION_FAILED(env, "could not generate prime");
       return Nothing<void>();
     }
@@ -113,7 +112,7 @@ Maybe<void> RandomPrimeTraits::AdditionalConfig(
   if (!args[offset + 3]->IsUndefined()) {
     ArrayBufferOrViewContents<unsigned char> rem(args[offset + 3]);
     params->rem.reset(rem.data(), rem.size());
-    if (!params->rem) {
+    if (!params->rem) [[unlikely]] {
       THROW_ERR_CRYPTO_OPERATION_FAILED(env, "could not generate prime");
       return Nothing<void>();
     }
@@ -124,7 +123,7 @@ Maybe<void> RandomPrimeTraits::AdditionalConfig(
   CHECK_GT(bits, 0);
 
   if (params->add) {
-    if (BignumPointer::GetBitCount(params->add.get()) > bits) {
+    if (BignumPointer::GetBitCount(params->add.get()) > bits) [[unlikely]] {
       // If we allowed this, the best case would be returning a static prime
       // that wasn't generated randomly. The worst case would be an infinite
       // loop within OpenSSL, blocking the main thread or one of the threads
@@ -133,7 +132,7 @@ Maybe<void> RandomPrimeTraits::AdditionalConfig(
       return Nothing<void>();
     }
 
-    if (params->rem && params->add <= params->rem) {
+    if (params->rem && params->add <= params->rem) [[unlikely]] {
       // This would definitely lead to an infinite loop if allowed since
       // OpenSSL does not check this condition.
       THROW_ERR_OUT_OF_RANGE(env, "invalid options.rem");
@@ -144,7 +143,7 @@ Maybe<void> RandomPrimeTraits::AdditionalConfig(
   params->bits = bits;
   params->safe = safe;
   params->prime = BignumPointer::NewSecure();
-  if (!params->prime) {
+  if (!params->prime) [[unlikely]] {
     THROW_ERR_CRYPTO_OPERATION_FAILED(env, "could not generate prime");
     return Nothing<void>();
   }
@@ -195,7 +194,8 @@ bool CheckPrimeTraits::DeriveBits(
     const CheckPrimeConfig& params,
     ByteSource* out) {
   int ret = params.candidate.isPrime(params.checks, getPrimeCheckCallback(env));
-  if (ret < 0) return false;
+  if (ret < 0) [[unlikely]]
+    return false;
   ByteSource::Builder buf(1);
   buf.data<char>()[0] = ret;
   *out = std::move(buf).release();
diff --git a/src/crypto/crypto_rsa.cc b/src/crypto/crypto_rsa.cc
index 05a3882c7e17d7..f0e0f9fd5f94a1 100644
--- a/src/crypto/crypto_rsa.cc
+++ b/src/crypto/crypto_rsa.cc
@@ -15,13 +15,15 @@
 namespace node {
 
 using ncrypto::BignumPointer;
+using ncrypto::DataPointer;
 using ncrypto::EVPKeyCtxPointer;
 using ncrypto::EVPKeyPointer;
 using ncrypto::RSAPointer;
 using v8::ArrayBuffer;
-using v8::BackingStore;
+using v8::BackingStoreInitializationMode;
 using v8::FunctionCallbackInfo;
 using v8::Int32;
+using v8::Integer;
 using v8::JustVoid;
 using v8::Local;
 using v8::Maybe;
@@ -34,37 +36,28 @@ using v8::Value;
 
 namespace crypto {
 EVPKeyCtxPointer RsaKeyGenTraits::Setup(RsaKeyPairGenConfig* params) {
-  EVPKeyCtxPointer ctx(
-      EVP_PKEY_CTX_new_id(
-          params->params.variant == kKeyVariantRSA_PSS
-              ? EVP_PKEY_RSA_PSS
-              : EVP_PKEY_RSA,
-          nullptr));
-
-  if (EVP_PKEY_keygen_init(ctx.get()) <= 0)
-    return EVPKeyCtxPointer();
-
-  if (EVP_PKEY_CTX_set_rsa_keygen_bits(
-          ctx.get(),
-          params->params.modulus_bits) <= 0) {
-    return EVPKeyCtxPointer();
+  auto ctx = EVPKeyCtxPointer::NewFromID(
+      params->params.variant == kKeyVariantRSA_PSS ? EVP_PKEY_RSA_PSS
+                                                   : EVP_PKEY_RSA);
+
+  if (!ctx.initForKeygen() ||
+      !ctx.setRsaKeygenBits(params->params.modulus_bits)) {
+    return {};
   }
 
   // 0x10001 is the default RSA exponent.
-  if (params->params.exponent != 0x10001) {
+  if (params->params.exponent != EVPKeyCtxPointer::kDefaultRsaExponent) {
     auto bn = BignumPointer::New();
-    CHECK(bn.setWord(params->params.exponent));
-    // EVP_CTX accepts ownership of bn on success.
-    if (EVP_PKEY_CTX_set_rsa_keygen_pubexp(ctx.get(), bn.get()) <= 0)
-      return EVPKeyCtxPointer();
-
-    bn.release();
+    if (!bn.setWord(params->params.exponent) ||
+        !ctx.setRsaKeygenPubExp(std::move(bn))) {
+      return {};
+    }
   }
 
   if (params->params.variant == kKeyVariantRSA_PSS) {
     if (params->params.md != nullptr &&
-        EVP_PKEY_CTX_set_rsa_pss_keygen_md(ctx.get(), params->params.md) <= 0) {
-      return EVPKeyCtxPointer();
+        !ctx.setRsaPssKeygenMd(params->params.md)) {
+      return {};
     }
 
     // TODO(tniessen): This appears to only be necessary in OpenSSL 3, while
@@ -76,11 +69,8 @@ EVPKeyCtxPointer RsaKeyGenTraits::Setup(RsaKeyPairGenConfig* params) {
       mgf1_md = params->params.md;
     }
 
-    if (mgf1_md != nullptr &&
-        EVP_PKEY_CTX_set_rsa_pss_keygen_mgf1_md(
-            ctx.get(),
-            mgf1_md) <= 0) {
-      return EVPKeyCtxPointer();
+    if (mgf1_md != nullptr && !ctx.setRsaPssKeygenMgf1Md(mgf1_md)) {
+      return {};
     }
 
     int saltlen = params->params.saltlen;
@@ -88,11 +78,8 @@ EVPKeyCtxPointer RsaKeyGenTraits::Setup(RsaKeyPairGenConfig* params) {
       saltlen = EVP_MD_size(params->params.md);
     }
 
-    if (saltlen >= 0 &&
-        EVP_PKEY_CTX_set_rsa_pss_keygen_saltlen(
-            ctx.get(),
-            saltlen) <= 0) {
-      return EVPKeyCtxPointer();
+    if (saltlen >= 0 && !ctx.setRsaPssSaltlen(saltlen)) {
+      return {};
     }
   }
 
@@ -154,7 +141,7 @@ Maybe<void> RsaKeyGenTraits::AdditionalConfig(
     if (!args[*offset]->IsUndefined()) {
       CHECK(args[*offset]->IsString());
       Utf8Value digest(env->isolate(), args[*offset]);
-      params->params.md = EVP_get_digestbyname(*digest);
+      params->params.md = ncrypto::getDigestByName(digest.ToStringView());
       if (params->params.md == nullptr) {
         THROW_ERR_CRYPTO_INVALID_DIGEST(env, "Invalid digest: %s", *digest);
         return Nothing<void>();
@@ -164,7 +151,7 @@ Maybe<void> RsaKeyGenTraits::AdditionalConfig(
     if (!args[*offset + 1]->IsUndefined()) {
       CHECK(args[*offset + 1]->IsString());
       Utf8Value digest(env->isolate(), args[*offset + 1]);
-      params->params.mgf1_md = EVP_get_digestbyname(*digest);
+      params->params.mgf1_md = ncrypto::getDigestByName(digest.ToStringView());
       if (params->params.mgf1_md == nullptr) {
         THROW_ERR_CRYPTO_INVALID_DIGEST(
             env, "Invalid MGF1 digest: %s", *digest);
@@ -196,8 +183,11 @@ WebCryptoKeyExportStatus RSA_JWK_Export(const KeyObjectData& key_data,
   return WebCryptoKeyExportStatus::FAILED;
 }
 
-template <PublicKeyCipher::EVP_PKEY_cipher_init_t init,
-          PublicKeyCipher::EVP_PKEY_cipher_t cipher>
+using Cipher_t = DataPointer(const EVPKeyPointer& key,
+                             const ncrypto::Rsa::CipherParams& params,
+                             const ncrypto::Buffer<const void> in);
+
+template <Cipher_t cipher>
 WebCryptoCipherStatus RSA_Cipher(Environment* env,
                                  const KeyObjectData& key_data,
                                  const RSACipherConfig& params,
@@ -206,45 +196,16 @@ WebCryptoCipherStatus RSA_Cipher(Environment* env,
   CHECK_NE(key_data.GetKeyType(), kKeyTypeSecret);
   Mutex::ScopedLock lock(key_data.mutex());
   const auto& m_pkey = key_data.GetAsymmetricKey();
+  const ncrypto::Rsa::CipherParams nparams{
+      .padding = params.padding,
+      .digest = params.digest,
+      .label = params.label,
+  };
 
-  EVPKeyCtxPointer ctx = m_pkey.newCtx();
-
-  if (!ctx || init(ctx.get()) <= 0)
-    return WebCryptoCipherStatus::FAILED;
-
-  if (EVP_PKEY_CTX_set_rsa_padding(ctx.get(), params.padding) <= 0) {
-    return WebCryptoCipherStatus::FAILED;
-  }
-
-  if (params.digest != nullptr &&
-      (EVP_PKEY_CTX_set_rsa_oaep_md(ctx.get(), params.digest) <= 0 ||
-       EVP_PKEY_CTX_set_rsa_mgf1_md(ctx.get(), params.digest) <= 0)) {
-    return WebCryptoCipherStatus::FAILED;
-  }
-
-  if (!SetRsaOaepLabel(ctx, params.label)) return WebCryptoCipherStatus::FAILED;
-
-  size_t out_len = 0;
-  if (cipher(
-          ctx.get(),
-          nullptr,
-          &out_len,
-          in.data<unsigned char>(),
-          in.size()) <= 0) {
-    return WebCryptoCipherStatus::FAILED;
-  }
-
-  ByteSource::Builder buf(out_len);
-
-  if (cipher(ctx.get(),
-             buf.data<unsigned char>(),
-             &out_len,
-             in.data<unsigned char>(),
-             in.size()) <= 0) {
-    return WebCryptoCipherStatus::FAILED;
-  }
+  auto data = cipher(m_pkey, nparams, in);
+  if (!data) return WebCryptoCipherStatus::FAILED;
 
-  *out = std::move(buf).release(out_len);
+  *out = ByteSource::Allocated(data.release());
   return WebCryptoCipherStatus::OK;
 }
 }  // namespace
@@ -316,7 +277,7 @@ Maybe<void> RSACipherTraits::AdditionalConfig(
       CHECK(args[offset + 1]->IsString());  // digest
       Utf8Value digest(env->isolate(), args[offset + 1]);
 
-      params->digest = EVP_get_digestbyname(*digest);
+      params->digest = ncrypto::getDigestByName(digest.ToStringView());
       if (params->digest == nullptr) {
         THROW_ERR_CRYPTO_INVALID_DIGEST(env, "Invalid digest: %s", *digest);
         return Nothing<void>();
@@ -349,12 +310,10 @@ WebCryptoCipherStatus RSACipherTraits::DoCipher(Environment* env,
   switch (cipher_mode) {
     case kWebCryptoCipherEncrypt:
       CHECK_EQ(key_data.GetKeyType(), kKeyTypePublic);
-      return RSA_Cipher<EVP_PKEY_encrypt_init, EVP_PKEY_encrypt>(
-          env, key_data, params, in, out);
+      return RSA_Cipher<ncrypto::Rsa::encrypt>(env, key_data, params, in, out);
     case kWebCryptoCipherDecrypt:
       CHECK_EQ(key_data.GetKeyType(), kKeyTypePrivate);
-      return RSA_Cipher<EVP_PKEY_decrypt_init, EVP_PKEY_decrypt>(
-          env, key_data, params, in, out);
+      return RSA_Cipher<ncrypto::Rsa::decrypt>(env, key_data, params, in, out);
   }
   return WebCryptoCipherStatus::FAILED;
 }
@@ -364,50 +323,37 @@ Maybe<void> ExportJWKRsaKey(Environment* env,
                             Local<Object> target) {
   Mutex::ScopedLock lock(key.mutex());
   const auto& m_pkey = key.GetAsymmetricKey();
-  int type = m_pkey.id();
-  CHECK(type == EVP_PKEY_RSA || type == EVP_PKEY_RSA_PSS);
 
-  // TODO(tniessen): Remove the "else" branch once we drop support for OpenSSL
-  // versions older than 1.1.1e via FIPS / dynamic linking.
-  const RSA* rsa;
-  if (OpenSSL_version_num() >= 0x1010105fL) {
-    rsa = EVP_PKEY_get0_RSA(m_pkey.get());
-  } else {
-    rsa = static_cast<const RSA*>(EVP_PKEY_get0(m_pkey.get()));
-  }
-  CHECK_NOT_NULL(rsa);
-
-  const BIGNUM* n;
-  const BIGNUM* e;
-  const BIGNUM* d;
-  const BIGNUM* p;
-  const BIGNUM* q;
-  const BIGNUM* dp;
-  const BIGNUM* dq;
-  const BIGNUM* qi;
-  RSA_get0_key(rsa, &n, &e, &d);
-
-  if (target->Set(
-          env->context(),
-          env->jwk_kty_string(),
-          env->jwk_rsa_string()).IsNothing()) {
+  const ncrypto::Rsa rsa = m_pkey;
+  if (!rsa ||
+      target->Set(env->context(), env->jwk_kty_string(), env->jwk_rsa_string())
+          .IsNothing()) {
     return Nothing<void>();
   }
 
-  if (SetEncodedValue(env, target, env->jwk_n_string(), n).IsNothing() ||
-      SetEncodedValue(env, target, env->jwk_e_string(), e).IsNothing()) {
+  auto pub_key = rsa.getPublicKey();
+
+  if (SetEncodedValue(env, target, env->jwk_n_string(), pub_key.n)
+          .IsNothing() ||
+      SetEncodedValue(env, target, env->jwk_e_string(), pub_key.e)
+          .IsNothing()) {
     return Nothing<void>();
   }
 
   if (key.GetKeyType() == kKeyTypePrivate) {
-    RSA_get0_factors(rsa, &p, &q);
-    RSA_get0_crt_params(rsa, &dp, &dq, &qi);
-    if (SetEncodedValue(env, target, env->jwk_d_string(), d).IsNothing() ||
-        SetEncodedValue(env, target, env->jwk_p_string(), p).IsNothing() ||
-        SetEncodedValue(env, target, env->jwk_q_string(), q).IsNothing() ||
-        SetEncodedValue(env, target, env->jwk_dp_string(), dp).IsNothing() ||
-        SetEncodedValue(env, target, env->jwk_dq_string(), dq).IsNothing() ||
-        SetEncodedValue(env, target, env->jwk_qi_string(), qi).IsNothing()) {
+    auto pvt_key = rsa.getPrivateKey();
+    if (SetEncodedValue(env, target, env->jwk_d_string(), pub_key.d)
+            .IsNothing() ||
+        SetEncodedValue(env, target, env->jwk_p_string(), pvt_key.p)
+            .IsNothing() ||
+        SetEncodedValue(env, target, env->jwk_q_string(), pvt_key.q)
+            .IsNothing() ||
+        SetEncodedValue(env, target, env->jwk_dp_string(), pvt_key.dp)
+            .IsNothing() ||
+        SetEncodedValue(env, target, env->jwk_dq_string(), pvt_key.dq)
+            .IsNothing() ||
+        SetEncodedValue(env, target, env->jwk_qi_string(), pvt_key.qi)
+            .IsNothing()) {
       return Nothing<void>();
     }
   }
@@ -440,15 +386,12 @@ KeyObjectData ImportJWKRsaKey(Environment* env,
   KeyType type = d_value->IsString() ? kKeyTypePrivate : kKeyTypePublic;
 
   RSAPointer rsa(RSA_new());
+  ncrypto::Rsa rsa_view(rsa.get());
 
   ByteSource n = ByteSource::FromEncodedString(env, n_value.As<String>());
   ByteSource e = ByteSource::FromEncodedString(env, e_value.As<String>());
 
-  if (!RSA_set0_key(
-          rsa.get(),
-          n.ToBN().release(),
-          e.ToBN().release(),
-          nullptr)) {
+  if (!rsa_view.setPublicKey(n.ToBN(), e.ToBN())) {
     THROW_ERR_CRYPTO_INVALID_JWK(env, "Invalid JWK RSA key");
     return {};
   }
@@ -485,20 +428,15 @@ KeyObjectData ImportJWKRsaKey(Environment* env,
     ByteSource dq = ByteSource::FromEncodedString(env, dq_value.As<String>());
     ByteSource qi = ByteSource::FromEncodedString(env, qi_value.As<String>());
 
-    if (!RSA_set0_key(rsa.get(), nullptr, nullptr, d.ToBN().release()) ||
-        !RSA_set0_factors(rsa.get(), p.ToBN().release(), q.ToBN().release()) ||
-        !RSA_set0_crt_params(
-            rsa.get(),
-            dp.ToBN().release(),
-            dq.ToBN().release(),
-            qi.ToBN().release())) {
+    if (!rsa_view.setPrivateKey(
+            d.ToBN(), q.ToBN(), p.ToBN(), dp.ToBN(), dq.ToBN(), qi.ToBN())) {
       THROW_ERR_CRYPTO_INVALID_JWK(env, "Invalid JWK RSA key");
       return {};
     }
   }
 
-  auto pkey = EVPKeyPointer::New();
-  CHECK_EQ(EVP_PKEY_set1_RSA(pkey.get(), rsa.get()), 1);
+  auto pkey = EVPKeyPointer::NewRSA(std::move(rsa));
+  if (!pkey) return {};
 
   return KeyObjectData::CreateAsymmetric(type, std::move(pkey));
 }
@@ -506,43 +444,32 @@ KeyObjectData ImportJWKRsaKey(Environment* env,
 Maybe<void> GetRsaKeyDetail(Environment* env,
                             const KeyObjectData& key,
                             Local<Object> target) {
-  const BIGNUM* e;  // Public Exponent
-  const BIGNUM* n;  // Modulus
-
   Mutex::ScopedLock lock(key.mutex());
   const auto& m_pkey = key.GetAsymmetricKey();
-  int type = m_pkey.id();
-  CHECK(type == EVP_PKEY_RSA || type == EVP_PKEY_RSA_PSS);
 
   // TODO(tniessen): Remove the "else" branch once we drop support for OpenSSL
   // versions older than 1.1.1e via FIPS / dynamic linking.
-  const RSA* rsa;
-  if (OpenSSL_version_num() >= 0x1010105fL) {
-    rsa = EVP_PKEY_get0_RSA(m_pkey.get());
-  } else {
-    rsa = static_cast<const RSA*>(EVP_PKEY_get0(m_pkey.get()));
-  }
-  CHECK_NOT_NULL(rsa);
+  const ncrypto::Rsa rsa = m_pkey;
+  if (!rsa) return Nothing<void>();
 
-  RSA_get0_key(rsa, &n, &e, nullptr);
+  auto pub_key = rsa.getPublicKey();
 
   if (target
           ->Set(env->context(),
                 env->modulus_length_string(),
-                Number::New(env->isolate(),
-                            static_cast<double>(BignumPointer::GetBitCount(n))))
+                Number::New(
+                    env->isolate(),
+                    static_cast<double>(BignumPointer::GetBitCount(pub_key.n))))
           .IsNothing()) {
     return Nothing<void>();
   }
 
-  std::unique_ptr<BackingStore> public_exponent;
-  {
-    NoArrayBufferZeroFillScope no_zero_fill_scope(env->isolate_data());
-    public_exponent = ArrayBuffer::NewBackingStore(
-        env->isolate(), BignumPointer::GetByteCount(e));
-  }
+  auto public_exponent = ArrayBuffer::NewBackingStore(
+      env->isolate(),
+      BignumPointer::GetByteCount(pub_key.e),
+      BackingStoreInitializationMode::kUninitialized);
   CHECK_EQ(BignumPointer::EncodePaddedInto(
-               e,
+               pub_key.e,
                static_cast<unsigned char*>(public_exponent->Data()),
                public_exponent->ByteLength()),
            public_exponent->ByteLength());
@@ -555,7 +482,7 @@ Maybe<void> GetRsaKeyDetail(Environment* env,
     return Nothing<void>();
   }
 
-  if (type == EVP_PKEY_RSA_PSS) {
+  if (m_pkey.id() == EVP_PKEY_RSA_PSS) {
     // Due to the way ASN.1 encoding works, default values are omitted when
     // encoding the data structure. However, there are also RSA-PSS keys for
     // which no parameters are set. In that case, the ASN.1 RSASSA-PSS-params
@@ -565,64 +492,34 @@ Maybe<void> GetRsaKeyDetail(Environment* env,
     // In that case, RSA_get0_pss_params does not return nullptr but all fields
     // of the returned RSA_PSS_PARAMS will be set to nullptr.
 
-    const RSA_PSS_PARAMS* params = RSA_get0_pss_params(rsa);
-    if (params != nullptr) {
-      int hash_nid = NID_sha1;
-      int mgf_nid = NID_mgf1;
-      int mgf1_hash_nid = NID_sha1;
-      int64_t salt_length = 20;
-
-      if (params->hashAlgorithm != nullptr) {
-        const ASN1_OBJECT* hash_obj;
-        X509_ALGOR_get0(&hash_obj, nullptr, nullptr, params->hashAlgorithm);
-        hash_nid = OBJ_obj2nid(hash_obj);
-      }
-
+    auto maybe_params = rsa.getPssParams();
+    if (maybe_params.has_value()) {
+      auto& params = maybe_params.value();
       if (target
-              ->Set(
-                  env->context(),
-                  env->hash_algorithm_string(),
-                  OneByteString(env->isolate(), OBJ_nid2ln(hash_nid)))
+              ->Set(env->context(),
+                    env->hash_algorithm_string(),
+                    OneByteString(env->isolate(), params.digest))
               .IsNothing()) {
         return Nothing<void>();
       }
 
-      if (params->maskGenAlgorithm != nullptr) {
-        const ASN1_OBJECT* mgf_obj;
-        X509_ALGOR_get0(&mgf_obj, nullptr, nullptr, params->maskGenAlgorithm);
-        mgf_nid = OBJ_obj2nid(mgf_obj);
-        if (mgf_nid == NID_mgf1) {
-          const ASN1_OBJECT* mgf1_hash_obj;
-          X509_ALGOR_get0(&mgf1_hash_obj, nullptr, nullptr, params->maskHash);
-          mgf1_hash_nid = OBJ_obj2nid(mgf1_hash_obj);
-        }
-      }
-
       // If, for some reason, the MGF is not MGF1, then the MGF1 hash function
       // is intentionally not added to the object.
-      if (mgf_nid == NID_mgf1) {
+      if (params.mgf1_digest.has_value()) {
+        auto digest = params.mgf1_digest.value();
         if (target
-                ->Set(
-                    env->context(),
-                    env->mgf1_hash_algorithm_string(),
-                    OneByteString(env->isolate(), OBJ_nid2ln(mgf1_hash_nid)))
+                ->Set(env->context(),
+                      env->mgf1_hash_algorithm_string(),
+                      OneByteString(env->isolate(), digest))
                 .IsNothing()) {
           return Nothing<void>();
         }
       }
 
-      if (params->saltLength != nullptr) {
-        if (ASN1_INTEGER_get_int64(&salt_length, params->saltLength) != 1) {
-          ThrowCryptoError(env, ERR_get_error(), "ASN1_INTEGER_get_in64 error");
-          return Nothing<void>();
-        }
-      }
-
       if (target
-              ->Set(
-                  env->context(),
-                  env->salt_length_string(),
-                  Number::New(env->isolate(), static_cast<double>(salt_length)))
+              ->Set(env->context(),
+                    env->salt_length_string(),
+                    Integer::New(env->isolate(), params.salt_length))
               .IsNothing()) {
         return Nothing<void>();
       }
diff --git a/src/crypto/crypto_sig.cc b/src/crypto/crypto_sig.cc
index abb8a804c1b508..175a8e92ef437f 100644
--- a/src/crypto/crypto_sig.cc
+++ b/src/crypto/crypto_sig.cc
@@ -14,20 +14,20 @@ namespace node {
 
 using ncrypto::BignumPointer;
 using ncrypto::ClearErrorOnReturn;
+using ncrypto::DataPointer;
 using ncrypto::ECDSASigPointer;
-using ncrypto::ECKeyPointer;
 using ncrypto::EVPKeyCtxPointer;
 using ncrypto::EVPKeyPointer;
 using ncrypto::EVPMDCtxPointer;
 using v8::ArrayBuffer;
 using v8::BackingStore;
+using v8::BackingStoreInitializationMode;
 using v8::Boolean;
 using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
 using v8::HandleScope;
 using v8::Int32;
 using v8::Isolate;
-using v8::Just;
 using v8::JustVoid;
 using v8::Local;
 using v8::Maybe;
@@ -39,44 +39,40 @@ using v8::Value;
 
 namespace crypto {
 namespace {
-bool ValidateDSAParameters(EVP_PKEY* key) {
-  /* Validate DSA2 parameters from FIPS 186-4 */
-  auto id = EVPKeyPointer::base_id(key);
-#if OPENSSL_VERSION_MAJOR >= 3
-  if (EVP_default_properties_is_fips_enabled(nullptr) && EVP_PKEY_DSA == id) {
-#else
-  if (FIPS_mode() && EVP_PKEY_DSA == id) {
-#endif
-    const DSA* dsa = EVP_PKEY_get0_DSA(key);
-    const BIGNUM* p;
-    const BIGNUM* q;
-    DSA_get0_pqg(dsa, &p, &q, nullptr);
-    int L = BignumPointer::GetBitCount(p);
-    int N = BignumPointer::GetBitCount(q);
-
-    return (L == 1024 && N == 160) ||
-           (L == 2048 && N == 224) ||
-           (L == 2048 && N == 256) ||
-           (L == 3072 && N == 256);
+int GetPaddingFromJS(const EVPKeyPointer& key, Local<Value> val) {
+  int padding = key.getDefaultSignPadding();
+  if (!val->IsUndefined()) [[likely]] {
+    CHECK(val->IsInt32());
+    padding = val.As<Int32>()->Value();
   }
+  return padding;
+}
 
-  return true;
+std::optional<int> GetSaltLenFromJS(Local<Value> val) {
+  std::optional<int> salt_len;
+  if (!val->IsUndefined()) [[likely]] {
+    CHECK(val->IsInt32());
+    salt_len = val.As<Int32>()->Value();
+  }
+  return salt_len;
+}
+
+DSASigEnc GetDSASigEncFromJS(Local<Value> val) {
+  CHECK(val->IsInt32());
+  int i = val.As<Int32>()->Value();
+  if (i < 0 || i >= static_cast<int>(DSASigEnc::Invalid)) [[unlikely]] {
+    return DSASigEnc::Invalid;
+  }
+  return static_cast<DSASigEnc>(val.As<Int32>()->Value());
 }
 
 bool ApplyRSAOptions(const EVPKeyPointer& pkey,
                      EVP_PKEY_CTX* pkctx,
                      int padding,
-                     const Maybe<int>& salt_len) {
-  int id = pkey.id();
-  if (id == EVP_PKEY_RSA || id == EVP_PKEY_RSA2 || id == EVP_PKEY_RSA_PSS) {
-    if (EVP_PKEY_CTX_set_rsa_padding(pkctx, padding) <= 0)
-      return false;
-    if (padding == RSA_PKCS1_PSS_PADDING && salt_len.IsJust()) {
-      if (EVP_PKEY_CTX_set_rsa_pss_saltlen(pkctx, salt_len.FromJust()) <= 0)
-        return false;
-    }
+                     std::optional<int> salt_len) {
+  if (pkey.isRsaVariant()) {
+    return EVPKeyCtxPointer::setRsaPadding(pkctx, padding, salt_len);
   }
-
   return true;
 }
 
@@ -84,38 +80,31 @@ std::unique_ptr<BackingStore> Node_SignFinal(Environment* env,
                                              EVPMDCtxPointer&& mdctx,
                                              const EVPKeyPointer& pkey,
                                              int padding,
-                                             Maybe<int> pss_salt_len) {
-  unsigned char m[EVP_MAX_MD_SIZE];
-  unsigned int m_len;
-
-  if (!EVP_DigestFinal_ex(mdctx.get(), m, &m_len))
+                                             std::optional<int> pss_salt_len) {
+  auto data = mdctx.digestFinal(mdctx.getExpectedSize());
+  if (!data) [[unlikely]]
     return nullptr;
 
-  size_t sig_len = pkey.size();
-  std::unique_ptr<BackingStore> sig;
-  {
-    NoArrayBufferZeroFillScope no_zero_fill_scope(env->isolate_data());
-    sig = ArrayBuffer::NewBackingStore(env->isolate(), sig_len);
-  }
+  auto sig = ArrayBuffer::NewBackingStore(env->isolate(), pkey.size());
+  ncrypto::Buffer<unsigned char> sig_buf{
+      .data = static_cast<unsigned char*>(sig->Data()),
+      .len = pkey.size(),
+  };
+
   EVPKeyCtxPointer pkctx = pkey.newCtx();
-  if (pkctx && EVP_PKEY_sign_init(pkctx.get()) > 0 &&
+  if (pkctx.initForSign() > 0 &&
       ApplyRSAOptions(pkey, pkctx.get(), padding, pss_salt_len) &&
-      EVP_PKEY_CTX_set_signature_md(pkctx.get(), EVP_MD_CTX_md(mdctx.get())) >
-          0 &&
-      EVP_PKEY_sign(pkctx.get(),
-                    static_cast<unsigned char*>(sig->Data()),
-                    &sig_len,
-                    m,
-                    m_len) > 0) {
-    CHECK_LE(sig_len, sig->ByteLength());
-    if (sig_len == 0) {
-      sig = ArrayBuffer::NewBackingStore(env->isolate(), 0);
-    } else if (sig_len != sig->ByteLength()) {
-      std::unique_ptr<BackingStore> old_sig = std::move(sig);
-      sig = ArrayBuffer::NewBackingStore(env->isolate(), sig_len);
-      memcpy(static_cast<char*>(sig->Data()),
-             static_cast<char*>(old_sig->Data()),
-             sig_len);
+      pkctx.setSignatureMd(mdctx) && pkctx.signInto(data, &sig_buf))
+      [[likely]] {
+    CHECK_LE(sig_buf.len, sig->ByteLength());
+    if (sig_buf.len < sig->ByteLength()) {
+      auto new_sig = ArrayBuffer::NewBackingStore(env->isolate(), sig_buf.len);
+      if (sig_buf.len > 0) [[likely]] {
+        memcpy(static_cast<char*>(new_sig->Data()),
+               static_cast<char*>(sig->Data()),
+               sig_buf.len);
+      }
+      sig = std::move(new_sig);
     }
     return sig;
   }
@@ -123,62 +112,26 @@ std::unique_ptr<BackingStore> Node_SignFinal(Environment* env,
   return nullptr;
 }
 
-int GetDefaultSignPadding(const EVPKeyPointer& m_pkey) {
-  return m_pkey.id() == EVP_PKEY_RSA_PSS ? RSA_PKCS1_PSS_PADDING
-                                         : RSA_PKCS1_PADDING;
-}
-
-unsigned int GetBytesOfRS(const EVPKeyPointer& pkey) {
-  int bits, base_id = pkey.base_id();
-
-  if (base_id == EVP_PKEY_DSA) {
-    const DSA* dsa_key = EVP_PKEY_get0_DSA(pkey.get());
-    // Both r and s are computed mod q, so their width is limited by that of q.
-    bits = BignumPointer::GetBitCount(DSA_get0_q(dsa_key));
-  } else if (base_id == EVP_PKEY_EC) {
-    bits = EC_GROUP_order_bits(ECKeyPointer::GetGroup(pkey));
-  } else {
-    return kNoDsaSignature;
-  }
-
-  return (bits + 7) / 8;
-}
-
-bool ExtractP1363(
-    const unsigned char* sig_data,
-    unsigned char* out,
-    size_t len,
-    size_t n) {
-  ncrypto::Buffer<const unsigned char> sig_buffer{
-      .data = sig_data,
-      .len = len,
-  };
-  auto asn1_sig = ECDSASigPointer::Parse(sig_buffer);
-  if (!asn1_sig)
-    return false;
-
-  return BignumPointer::EncodePaddedInto(asn1_sig.r(), out, n) > 0 &&
-         BignumPointer::EncodePaddedInto(asn1_sig.s(), out + n, n) > 0;
-}
-
 // Returns the maximum size of each of the integers (r, s) of the DSA signature.
 std::unique_ptr<BackingStore> ConvertSignatureToP1363(
     Environment* env,
     const EVPKeyPointer& pkey,
     std::unique_ptr<BackingStore>&& signature) {
-  unsigned int n = GetBytesOfRS(pkey);
-  if (n == kNoDsaSignature)
-    return std::move(signature);
+  uint32_t n = pkey.getBytesOfRS().value_or(kNoDsaSignature);
+  if (n == kNoDsaSignature) return std::move(signature);
 
-  std::unique_ptr<BackingStore> buf;
-  {
-    NoArrayBufferZeroFillScope no_zero_fill_scope(env->isolate_data());
-    buf = ArrayBuffer::NewBackingStore(env->isolate(), 2 * n);
-  }
-  if (!ExtractP1363(static_cast<unsigned char*>(signature->Data()),
-                    static_cast<unsigned char*>(buf->Data()),
-                    signature->ByteLength(), n))
+  auto buf = ArrayBuffer::NewBackingStore(
+      env->isolate(), 2 * n, BackingStoreInitializationMode::kUninitialized);
+
+  ncrypto::Buffer<const unsigned char> sig_buffer{
+      .data = static_cast<const unsigned char*>(signature->Data()),
+      .len = signature->ByteLength(),
+  };
+
+  if (!ncrypto::extractP1363(
+          sig_buffer, static_cast<unsigned char*>(buf->Data()), n)) {
     return std::move(signature);
+  }
 
   return buf;
 }
@@ -187,30 +140,33 @@ std::unique_ptr<BackingStore> ConvertSignatureToP1363(
 ByteSource ConvertSignatureToP1363(Environment* env,
                                    const EVPKeyPointer& pkey,
                                    const ByteSource& signature) {
-  unsigned int n = GetBytesOfRS(pkey);
-  if (n == kNoDsaSignature)
-    return ByteSource();
+  unsigned int n = pkey.getBytesOfRS().value_or(kNoDsaSignature);
+  if (n == kNoDsaSignature) [[unlikely]]
+    return {};
 
-  const unsigned char* sig_data = signature.data<unsigned char>();
+  auto data = DataPointer::Alloc(n * 2);
+  if (!data) [[unlikely]]
+    return {};
+  unsigned char* out = static_cast<unsigned char*>(data.get());
 
-  ByteSource::Builder out(n * 2);
-  memset(out.data<void>(), 0, n * 2);
+  // Extracting the signature may not actually use all of the allocated space.
+  // We need to ensure that the buffer is zeroed out before use.
+  data.zero();
 
-  if (!ExtractP1363(sig_data, out.data<unsigned char>(), signature.size(), n))
-    return ByteSource();
+  if (!ncrypto::extractP1363(signature, out, n)) [[unlikely]] {
+    return {};
+  }
 
-  return std::move(out).release();
+  return ByteSource::Allocated(data.release());
 }
 
 ByteSource ConvertSignatureToDER(const EVPKeyPointer& pkey, ByteSource&& out) {
-  unsigned int n = GetBytesOfRS(pkey);
-  if (n == kNoDsaSignature)
-    return std::move(out);
+  unsigned int n = pkey.getBytesOfRS().value_or(kNoDsaSignature);
+  if (n == kNoDsaSignature) return std::move(out);
 
   const unsigned char* sig_data = out.data<unsigned char>();
 
-  if (out.size() != 2 * n)
-    return ByteSource();
+  if (out.size() != 2 * n) return {};
 
   auto asn1_sig = ECDSASigPointer::New();
   CHECK(asn1_sig);
@@ -221,7 +177,8 @@ ByteSource ConvertSignatureToDER(const EVPKeyPointer& pkey, ByteSource&& out) {
   CHECK(asn1_sig.setParams(std::move(r), std::move(s)));
 
   auto buf = asn1_sig.encode();
-  if (buf.len <= 0) return ByteSource();
+  if (buf.len <= 0) [[unlikely]]
+    return {};
 
   CHECK_NOT_NULL(buf.data);
   return ByteSource::Allocated(buf);
@@ -231,95 +188,87 @@ void CheckThrow(Environment* env, SignBase::Error error) {
   HandleScope scope(env->isolate());
 
   switch (error) {
-    case SignBase::Error::kSignUnknownDigest:
+    case SignBase::Error::UnknownDigest:
       return THROW_ERR_CRYPTO_INVALID_DIGEST(env);
 
-    case SignBase::Error::kSignNotInitialised:
+    case SignBase::Error::NotInitialised:
       return THROW_ERR_CRYPTO_INVALID_STATE(env, "Not initialised");
 
-    case SignBase::Error::kSignMalformedSignature:
+    case SignBase::Error::MalformedSignature:
       return THROW_ERR_CRYPTO_OPERATION_FAILED(env, "Malformed signature");
 
-    case SignBase::Error::kSignInit:
-    case SignBase::Error::kSignUpdate:
-    case SignBase::Error::kSignPrivateKey:
-    case SignBase::Error::kSignPublicKey:
-      {
-        unsigned long err = ERR_get_error();  // NOLINT(runtime/int)
-        if (err)
-          return ThrowCryptoError(env, err);
-        switch (error) {
-          case SignBase::Error::kSignInit:
-            return THROW_ERR_CRYPTO_OPERATION_FAILED(env,
-                "EVP_SignInit_ex failed");
-          case SignBase::Error::kSignUpdate:
-            return THROW_ERR_CRYPTO_OPERATION_FAILED(env,
-                "EVP_SignUpdate failed");
-          case SignBase::Error::kSignPrivateKey:
-            return THROW_ERR_CRYPTO_OPERATION_FAILED(env,
-                "PEM_read_bio_PrivateKey failed");
-          case SignBase::Error::kSignPublicKey:
-            return THROW_ERR_CRYPTO_OPERATION_FAILED(env,
-                "PEM_read_bio_PUBKEY failed");
-          default:
-            ABORT();
-        }
+    case SignBase::Error::Init:
+    case SignBase::Error::Update:
+    case SignBase::Error::PrivateKey:
+    case SignBase::Error::PublicKey: {
+      unsigned long err = ERR_get_error();  // NOLINT(runtime/int)
+      if (err) return ThrowCryptoError(env, err);
+      switch (error) {
+        case SignBase::Error::Init:
+          return THROW_ERR_CRYPTO_OPERATION_FAILED(env,
+                                                   "EVP_SignInit_ex failed");
+        case SignBase::Error::Update:
+          return THROW_ERR_CRYPTO_OPERATION_FAILED(env,
+                                                   "EVP_SignUpdate failed");
+        case SignBase::Error::PrivateKey:
+          return THROW_ERR_CRYPTO_OPERATION_FAILED(
+              env, "PEM_read_bio_PrivateKey failed");
+        case SignBase::Error::PublicKey:
+          return THROW_ERR_CRYPTO_OPERATION_FAILED(
+              env, "PEM_read_bio_PUBKEY failed");
+        default:
+          ABORT();
       }
+    }
 
-    case SignBase::Error::kSignOk:
+    case SignBase::Error::Ok:
       return;
   }
 }
 
-bool IsOneShot(const EVPKeyPointer& key) {
-  return key.id() == EVP_PKEY_ED25519 || key.id() == EVP_PKEY_ED448;
-}
-
-bool UseP1363Encoding(const EVPKeyPointer& key, const DSASigEnc& dsa_encoding) {
-  return (key.id() == EVP_PKEY_EC || key.id() == EVP_PKEY_DSA) &&
-         dsa_encoding == kSigEncP1363;
+bool UseP1363Encoding(const EVPKeyPointer& key, const DSASigEnc dsa_encoding) {
+  return key.isSigVariant() && dsa_encoding == DSASigEnc::P1363;
 }
 }  // namespace
 
-SignBase::Error SignBase::Init(const char* sign_type) {
+SignBase::Error SignBase::Init(std::string_view digest) {
   CHECK_NULL(mdctx_);
-  // Historically, "dss1" and "DSS1" were DSA aliases for SHA-1
-  // exposed through the public API.
-  if (strcmp(sign_type, "dss1") == 0 ||
-      strcmp(sign_type, "DSS1") == 0) {
-    sign_type = "SHA1";
-  }
-  const EVP_MD* md = EVP_get_digestbyname(sign_type);
-  if (md == nullptr)
-    return kSignUnknownDigest;
-
-  mdctx_.reset(EVP_MD_CTX_new());
-  if (!mdctx_ || !EVP_DigestInit_ex(mdctx_.get(), md, nullptr)) {
+  auto md = ncrypto::getDigestByName(digest);
+  if (md == nullptr) [[unlikely]]
+    return Error::UnknownDigest;
+
+  mdctx_ = EVPMDCtxPointer::New();
+
+  if (!mdctx_.digestInit(md)) [[unlikely]] {
     mdctx_.reset();
-    return kSignInit;
+    return Error::Init;
   }
 
-  return kSignOk;
+  return Error::Ok;
 }
 
 SignBase::Error SignBase::Update(const char* data, size_t len) {
-  if (mdctx_ == nullptr)
-    return kSignNotInitialised;
-  if (!EVP_DigestUpdate(mdctx_.get(), data, len))
-    return kSignUpdate;
-  return kSignOk;
+  if (mdctx_ == nullptr) [[unlikely]]
+    return Error::NotInitialised;
+
+  ncrypto::Buffer<const void> buf{
+      .data = data,
+      .len = len,
+  };
+
+  return mdctx_.digestUpdate(buf) ? Error::Ok : Error::Update;
 }
 
 SignBase::SignBase(Environment* env, Local<Object> wrap)
-    : BaseObject(env, wrap) {}
+    : BaseObject(env, wrap) {
+  MakeWeak();
+}
 
 void SignBase::MemoryInfo(MemoryTracker* tracker) const {
   tracker->TrackFieldWithSize("mdctx", mdctx_ ? kSizeOf_EVP_MD_CTX : 0);
 }
 
-Sign::Sign(Environment* env, Local<Object> wrap) : SignBase(env, wrap) {
-  MakeWeak();
-}
+Sign::Sign(Environment* env, Local<Object> wrap) : SignBase(env, wrap) {}
 
 void Sign::Initialize(Environment* env, Local<Object> target) {
   Isolate* isolate = env->isolate();
@@ -335,8 +284,13 @@ void Sign::Initialize(Environment* env, Local<Object> target) {
 
   SignJob::Initialize(env, target);
 
-  constexpr int kSignJobModeSign = SignConfiguration::kSign;
-  constexpr int kSignJobModeVerify = SignConfiguration::kVerify;
+  constexpr int kSignJobModeSign =
+      static_cast<int>(SignConfiguration::Mode::Sign);
+  constexpr int kSignJobModeVerify =
+      static_cast<int>(SignConfiguration::Mode::Verify);
+
+  constexpr auto kSigEncDER = DSASigEnc::DER;
+  constexpr auto kSigEncP1363 = DSASigEnc::P1363;
 
   NODE_DEFINE_CONSTANT(target, kSignJobModeSign);
   NODE_DEFINE_CONSTANT(target, kSignJobModeVerify);
@@ -363,8 +317,8 @@ void Sign::SignInit(const FunctionCallbackInfo<Value>& args) {
   Sign* sign;
   ASSIGN_OR_RETURN_UNWRAP(&sign, args.This());
 
-  const node::Utf8Value sign_type(args.GetIsolate(), args[0]);
-  crypto::CheckThrow(env, sign->Init(*sign_type));
+  const node::Utf8Value sign_type(env->isolate(), args[0]);
+  crypto::CheckThrow(env, sign->Init(sign_type.ToStringView()));
 }
 
 void Sign::SignUpdate(const FunctionCallbackInfo<Value>& args) {
@@ -380,20 +334,22 @@ void Sign::SignUpdate(const FunctionCallbackInfo<Value>& args) {
 
 Sign::SignResult Sign::SignFinal(const EVPKeyPointer& pkey,
                                  int padding,
-                                 const Maybe<int>& salt_len,
+                                 std::optional<int> salt_len,
                                  DSASigEnc dsa_sig_enc) {
-  if (!mdctx_)
-    return SignResult(kSignNotInitialised);
+  if (!mdctx_) [[unlikely]] {
+    return SignResult(Error::NotInitialised);
+  }
 
   EVPMDCtxPointer mdctx = std::move(mdctx_);
 
-  if (!ValidateDSAParameters(pkey.get()))
-    return SignResult(kSignPrivateKey);
+  if (!pkey.validateDsaParameters()) {
+    return SignResult(Error::PrivateKey);
+  }
 
-  std::unique_ptr<BackingStore> buffer =
+  auto buffer =
       Node_SignFinal(env(), std::move(mdctx), pkey, padding, salt_len);
-  Error error = buffer ? kSignOk : kSignPrivateKey;
-  if (error == kSignOk && dsa_sig_enc == kSigEncP1363) {
+  Error error = buffer ? Error::Ok : Error::PrivateKey;
+  if (error == Error::Ok && dsa_sig_enc == DSASigEnc::P1363) {
     buffer = ConvertSignatureToP1363(env(), pkey, std::move(buffer));
     CHECK_NOT_NULL(buffer->Data());
   }
@@ -412,49 +368,34 @@ void Sign::SignFinal(const FunctionCallbackInfo<Value>& args) {
   if (!data) [[unlikely]]
     return;
   const auto& key = data.GetAsymmetricKey();
-  if (!key)
+  if (!key) [[unlikely]]
     return;
 
-  if (IsOneShot(key)) {
+  if (key.isOneShotVariant()) [[unlikely]] {
     THROW_ERR_CRYPTO_UNSUPPORTED_OPERATION(env);
     return;
   }
 
-  int padding = GetDefaultSignPadding(key);
-  if (!args[offset]->IsUndefined()) {
-    CHECK(args[offset]->IsInt32());
-    padding = args[offset].As<Int32>()->Value();
-  }
-
-  Maybe<int> salt_len = Nothing<int>();
-  if (!args[offset + 1]->IsUndefined()) {
-    CHECK(args[offset + 1]->IsInt32());
-    salt_len = Just<int>(args[offset + 1].As<Int32>()->Value());
+  int padding = GetPaddingFromJS(key, args[offset]);
+  std::optional<int> salt_len = GetSaltLenFromJS(args[offset + 1]);
+  DSASigEnc dsa_sig_enc = GetDSASigEncFromJS(args[offset + 2]);
+  if (dsa_sig_enc == DSASigEnc::Invalid) [[unlikely]] {
+    THROW_ERR_OUT_OF_RANGE(env, "invalid signature encoding");
+    return;
   }
 
-  CHECK(args[offset + 2]->IsInt32());
-  DSASigEnc dsa_sig_enc =
-      static_cast<DSASigEnc>(args[offset + 2].As<Int32>()->Value());
+  SignResult ret = sign->SignFinal(key, padding, salt_len, dsa_sig_enc);
 
-  SignResult ret = sign->SignFinal(
-      key,
-      padding,
-      salt_len,
-      dsa_sig_enc);
-
-  if (ret.error != kSignOk)
+  if (ret.error != Error::Ok) [[unlikely]] {
     return crypto::CheckThrow(env, ret.error);
+  }
 
-  Local<ArrayBuffer> ab =
-      ArrayBuffer::New(env->isolate(), std::move(ret.signature));
+  auto ab = ArrayBuffer::New(env->isolate(), std::move(ret.signature));
   args.GetReturnValue().Set(
       Buffer::New(env, ab, 0, ab->ByteLength()).FromMaybe(Local<Value>()));
 }
 
-Verify::Verify(Environment* env, Local<Object> wrap)
-  : SignBase(env, wrap) {
-  MakeWeak();
-}
+Verify::Verify(Environment* env, Local<Object> wrap) : SignBase(env, wrap) {}
 
 void Verify::Initialize(Environment* env, Local<Object> target) {
   Isolate* isolate = env->isolate();
@@ -486,8 +427,8 @@ void Verify::VerifyInit(const FunctionCallbackInfo<Value>& args) {
   Verify* verify;
   ASSIGN_OR_RETURN_UNWRAP(&verify, args.This());
 
-  const node::Utf8Value verify_type(args.GetIsolate(), args[0]);
-  crypto::CheckThrow(env, verify->Init(*verify_type));
+  const node::Utf8Value verify_type(env->isolate(), args[0]);
+  crypto::CheckThrow(env, verify->Init(verify_type.ToStringView()));
 }
 
 void Verify::VerifyUpdate(const FunctionCallbackInfo<Value>& args) {
@@ -495,8 +436,9 @@ void Verify::VerifyUpdate(const FunctionCallbackInfo<Value>& args) {
                           const FunctionCallbackInfo<Value>& args,
                           const char* data, size_t size) {
     Environment* env = Environment::GetCurrent(args);
-    if (size > INT_MAX) [[unlikely]]
+    if (size > INT_MAX) [[unlikely]] {
       return THROW_ERR_OUT_OF_RANGE(env, "data is too long");
+    }
     Error err = verify->Update(data, size);
     crypto::CheckThrow(verify->env(), err);
   });
@@ -505,35 +447,30 @@ void Verify::VerifyUpdate(const FunctionCallbackInfo<Value>& args) {
 SignBase::Error Verify::VerifyFinal(const EVPKeyPointer& pkey,
                                     const ByteSource& sig,
                                     int padding,
-                                    const Maybe<int>& saltlen,
+                                    std::optional<int> saltlen,
                                     bool* verify_result) {
-  if (!mdctx_)
-    return kSignNotInitialised;
+  if (!mdctx_) [[unlikely]]
+    return Error::NotInitialised;
 
-  unsigned char m[EVP_MAX_MD_SIZE];
-  unsigned int m_len;
   *verify_result = false;
   EVPMDCtxPointer mdctx = std::move(mdctx_);
 
-  if (!EVP_DigestFinal_ex(mdctx.get(), m, &m_len))
-    return kSignPublicKey;
+  auto data = mdctx.digestFinal(mdctx.getExpectedSize());
+  if (!data) [[unlikely]]
+    return Error::PublicKey;
 
   EVPKeyCtxPointer pkctx = pkey.newCtx();
-  if (pkctx) {
-    const int init_ret = EVP_PKEY_verify_init(pkctx.get());
-    if (init_ret == -2) {
-      return kSignPublicKey;
-    }
+  if (pkctx) [[likely]] {
+    const int init_ret = pkctx.initForVerify();
+    if (init_ret == -2) [[unlikely]]
+      return Error::PublicKey;
     if (init_ret > 0 && ApplyRSAOptions(pkey, pkctx.get(), padding, saltlen) &&
-        EVP_PKEY_CTX_set_signature_md(pkctx.get(), EVP_MD_CTX_md(mdctx.get())) >
-            0) {
-      const unsigned char* s = sig.data<unsigned char>();
-      const int r = EVP_PKEY_verify(pkctx.get(), s, sig.size(), m, m_len);
-      *verify_result = r == 1;
+        pkctx.setSignatureMd(mdctx)) {
+      *verify_result = pkctx.verify(sig, data);
     }
   }
 
-  return kSignOk;
+  return Error::Ok;
 }
 
 void Verify::VerifyFinal(const FunctionCallbackInfo<Value>& args) {
@@ -545,47 +482,42 @@ void Verify::VerifyFinal(const FunctionCallbackInfo<Value>& args) {
 
   unsigned int offset = 0;
   auto data = KeyObjectData::GetPublicOrPrivateKeyFromJs(args, &offset);
-  if (!data) return;
-  const auto& pkey = data.GetAsymmetricKey();
-  if (!pkey)
+  if (!data) [[unlikely]]
+    return;
+  const auto& key = data.GetAsymmetricKey();
+  if (!key) [[unlikely]]
     return;
 
-  if (IsOneShot(pkey)) {
+  if (key.isOneShotVariant()) [[unlikely]] {
     THROW_ERR_CRYPTO_UNSUPPORTED_OPERATION(env);
     return;
   }
 
   ArrayBufferOrViewContents<char> hbuf(args[offset]);
-  if (!hbuf.CheckSizeInt32()) [[unlikely]]
+  if (!hbuf.CheckSizeInt32()) [[unlikely]] {
     return THROW_ERR_OUT_OF_RANGE(env, "buffer is too big");
-
-  int padding = GetDefaultSignPadding(pkey);
-  if (!args[offset + 1]->IsUndefined()) {
-    CHECK(args[offset + 1]->IsInt32());
-    padding = args[offset + 1].As<Int32>()->Value();
   }
 
-  Maybe<int> salt_len = Nothing<int>();
-  if (!args[offset + 2]->IsUndefined()) {
-    CHECK(args[offset + 2]->IsInt32());
-    salt_len = Just<int>(args[offset + 2].As<Int32>()->Value());
+  int padding = GetPaddingFromJS(key, args[offset + 1]);
+  std::optional<int> salt_len = GetSaltLenFromJS(args[offset + 2]);
+  DSASigEnc dsa_sig_enc = GetDSASigEncFromJS(args[offset + 3]);
+  if (dsa_sig_enc == DSASigEnc::Invalid) [[unlikely]] {
+    THROW_ERR_OUT_OF_RANGE(env, "invalid signature encoding");
+    return;
   }
 
-  CHECK(args[offset + 3]->IsInt32());
-  DSASigEnc dsa_sig_enc =
-      static_cast<DSASigEnc>(args[offset + 3].As<Int32>()->Value());
-
   ByteSource signature = hbuf.ToByteSource();
-  if (dsa_sig_enc == kSigEncP1363) {
-    signature = ConvertSignatureToDER(pkey, hbuf.ToByteSource());
-    if (signature.data() == nullptr)
-      return crypto::CheckThrow(env, Error::kSignMalformedSignature);
+  if (dsa_sig_enc == DSASigEnc::P1363) {
+    signature = ConvertSignatureToDER(key, hbuf.ToByteSource());
+    if (signature.data() == nullptr) [[unlikely]] {
+      return crypto::CheckThrow(env, Error::MalformedSignature);
+    }
   }
 
   bool verify_result;
-  Error err = verify->VerifyFinal(pkey, signature, padding,
-                                  salt_len, &verify_result);
-  if (err != kSignOk)
+  Error err =
+      verify->VerifyFinal(key, signature, padding, salt_len, &verify_result);
+  if (err != Error::Ok) [[unlikely]]
     return crypto::CheckThrow(env, err);
   args.GetReturnValue().Set(verify_result);
 }
@@ -633,7 +565,7 @@ Maybe<void> SignTraits::AdditionalConfig(
       static_cast<SignConfiguration::Mode>(args[offset].As<Uint32>()->Value());
 
   unsigned int keyParamOffset = offset + 1;
-  if (params->mode == SignConfiguration::kVerify) {
+  if (params->mode == SignConfiguration::Mode::Verify) {
     auto data =
         KeyObjectData::GetPublicOrPrivateKeyFromJs(args, &keyParamOffset);
     if (!data) return Nothing<void>();
@@ -655,8 +587,8 @@ Maybe<void> SignTraits::AdditionalConfig(
 
   if (args[offset + 6]->IsString()) {
     Utf8Value digest(env->isolate(), args[offset + 6]);
-    params->digest = EVP_get_digestbyname(*digest);
-    if (params->digest == nullptr) {
+    params->digest = ncrypto::getDigestByName(digest.ToStringView());
+    if (params->digest == nullptr) [[unlikely]] {
       THROW_ERR_CRYPTO_INVALID_DIGEST(env, "Invalid digest: %s", *digest);
       return Nothing<void>();
     }
@@ -664,24 +596,24 @@ Maybe<void> SignTraits::AdditionalConfig(
 
   if (args[offset + 7]->IsInt32()) {  // Salt length
     params->flags |= SignConfiguration::kHasSaltLength;
-    params->salt_length = args[offset + 7].As<Int32>()->Value();
+    params->salt_length =
+        GetSaltLenFromJS(args[offset + 7]).value_or(params->salt_length);
   }
   if (args[offset + 8]->IsUint32()) {  // Padding
     params->flags |= SignConfiguration::kHasPadding;
-    params->padding = args[offset + 8].As<Uint32>()->Value();
+    params->padding =
+        GetPaddingFromJS(params->key.GetAsymmetricKey(), args[offset + 8]);
   }
 
   if (args[offset + 9]->IsUint32()) {  // DSA Encoding
-    params->dsa_encoding =
-        static_cast<DSASigEnc>(args[offset + 9].As<Uint32>()->Value());
-    if (params->dsa_encoding != kSigEncDER &&
-        params->dsa_encoding != kSigEncP1363) {
+    params->dsa_encoding = GetDSASigEncFromJS(args[offset + 9]);
+    if (params->dsa_encoding == DSASigEnc::Invalid) [[unlikely]] {
       THROW_ERR_OUT_OF_RANGE(env, "invalid signature encoding");
       return Nothing<void>();
     }
   }
 
-  if (params->mode == SignConfiguration::kVerify) {
+  if (params->mode == SignConfiguration::Mode::Verify) {
     ArrayBufferOrViewContents<char> signature(args[offset + 10]);
     if (!signature.CheckSizeInt32()) [[unlikely]] {
       THROW_ERR_OUT_OF_RANGE(env, "signature is too big");
@@ -708,97 +640,69 @@ bool SignTraits::DeriveBits(
     const SignConfiguration& params,
     ByteSource* out) {
   ClearErrorOnReturn clear_error_on_return;
-  EVPMDCtxPointer context(EVP_MD_CTX_new());
-  EVP_PKEY_CTX* ctx = nullptr;
-
+  auto context = EVPMDCtxPointer::New();
+  if (!context) [[unlikely]]
+    return false;
   const auto& key = params.key.GetAsymmetricKey();
 
-  switch (params.mode) {
-    case SignConfiguration::kSign:
-      if (!EVP_DigestSignInit(
-              context.get(), &ctx, params.digest, nullptr, key.get())) {
-        crypto::CheckThrow(env, SignBase::Error::kSignInit);
-        return false;
-      }
-      break;
-    case SignConfiguration::kVerify:
-      if (!EVP_DigestVerifyInit(
-              context.get(), &ctx, params.digest, nullptr, key.get())) {
-        crypto::CheckThrow(env, SignBase::Error::kSignInit);
-        return false;
-      }
-      break;
+  auto ctx = ([&] {
+    switch (params.mode) {
+      case SignConfiguration::Mode::Sign:
+        return context.signInit(key, params.digest);
+      case SignConfiguration::Mode::Verify:
+        return context.verifyInit(key, params.digest);
+    }
+    UNREACHABLE();
+  })();
+
+  if (!ctx.has_value()) [[unlikely]] {
+    crypto::CheckThrow(env, SignBase::Error::Init);
+    return false;
   }
 
   int padding = params.flags & SignConfiguration::kHasPadding
                     ? params.padding
-                    : GetDefaultSignPadding(key);
+                    : key.getDefaultSignPadding();
 
-  Maybe<int> salt_length = params.flags & SignConfiguration::kHasSaltLength
-      ? Just<int>(params.salt_length) : Nothing<int>();
+  std::optional<int> salt_length =
+      params.flags & SignConfiguration::kHasSaltLength
+          ? std::optional<int>(params.salt_length)
+          : std::nullopt;
 
-  if (!ApplyRSAOptions(key, ctx, padding, salt_length)) {
-    crypto::CheckThrow(env, SignBase::Error::kSignPrivateKey);
+  if (!ApplyRSAOptions(key, *ctx, padding, salt_length)) {
+    crypto::CheckThrow(env, SignBase::Error::PrivateKey);
     return false;
   }
 
   switch (params.mode) {
-    case SignConfiguration::kSign: {
-      if (IsOneShot(key)) {
-        size_t len;
-        if (!EVP_DigestSign(
-            context.get(),
-            nullptr,
-            &len,
-            params.data.data<unsigned char>(),
-            params.data.size())) {
-          crypto::CheckThrow(env, SignBase::Error::kSignPrivateKey);
-          return false;
-        }
-        ByteSource::Builder buf(len);
-        if (!EVP_DigestSign(context.get(),
-                            buf.data<unsigned char>(),
-                            &len,
-                            params.data.data<unsigned char>(),
-                            params.data.size())) {
-          crypto::CheckThrow(env, SignBase::Error::kSignPrivateKey);
+    case SignConfiguration::Mode::Sign: {
+      if (key.isOneShotVariant()) {
+        auto data = context.signOneShot(params.data);
+        if (!data) [[unlikely]] {
+          crypto::CheckThrow(env, SignBase::Error::PrivateKey);
           return false;
         }
-        *out = std::move(buf).release(len);
+        *out = ByteSource::Allocated(data.release());
       } else {
-        size_t len;
-        if (!EVP_DigestSignUpdate(
-                context.get(),
-                params.data.data<unsigned char>(),
-                params.data.size()) ||
-            !EVP_DigestSignFinal(context.get(), nullptr, &len)) {
-          crypto::CheckThrow(env, SignBase::Error::kSignPrivateKey);
-          return false;
-        }
-        ByteSource::Builder buf(len);
-        if (!EVP_DigestSignFinal(
-                context.get(), buf.data<unsigned char>(), &len)) {
-          crypto::CheckThrow(env, SignBase::Error::kSignPrivateKey);
+        auto data = context.sign(params.data);
+        if (!data) [[unlikely]] {
+          crypto::CheckThrow(env, SignBase::Error::PrivateKey);
           return false;
         }
+        auto bs = ByteSource::Allocated(data.release());
 
         if (UseP1363Encoding(key, params.dsa_encoding)) {
-          *out = ConvertSignatureToP1363(env, key, std::move(buf).release());
+          *out = ConvertSignatureToP1363(env, key, std::move(bs));
         } else {
-          *out = std::move(buf).release(len);
+          *out = std::move(bs);
         }
       }
       break;
     }
-    case SignConfiguration::kVerify: {
+    case SignConfiguration::Mode::Verify: {
       ByteSource::Builder buf(1);
       buf.data<char>()[0] = 0;
-      if (EVP_DigestVerify(
-              context.get(),
-              params.signature.data<unsigned char>(),
-              params.signature.size(),
-              params.data.data<unsigned char>(),
-              params.data.size()) == 1) {
+      if (context.verify(params.data, params.signature)) {
         buf.data<char>()[0] = 1;
       }
       *out = std::move(buf).release();
@@ -812,9 +716,9 @@ MaybeLocal<Value> SignTraits::EncodeOutput(Environment* env,
                                            const SignConfiguration& params,
                                            ByteSource* out) {
   switch (params.mode) {
-    case SignConfiguration::kSign:
+    case SignConfiguration::Mode::Sign:
       return out->ToArrayBuffer(env);
-    case SignConfiguration::kVerify:
+    case SignConfiguration::Mode::Verify:
       return Boolean::New(env->isolate(), out->data<char>()[0] == 1);
   }
   UNREACHABLE();
diff --git a/src/crypto/crypto_sig.h b/src/crypto/crypto_sig.h
index 3a3c27b4e8e748..36c51b07bb5692 100644
--- a/src/crypto/crypto_sig.h
+++ b/src/crypto/crypto_sig.h
@@ -13,27 +13,24 @@ namespace node {
 namespace crypto {
 static const unsigned int kNoDsaSignature = static_cast<unsigned int>(-1);
 
-enum DSASigEnc {
-  kSigEncDER,
-  kSigEncP1363
-};
+enum class DSASigEnc { DER, P1363, Invalid };
 
 class SignBase : public BaseObject {
  public:
-  enum Error {
-    kSignOk,
-    kSignUnknownDigest,
-    kSignInit,
-    kSignNotInitialised,
-    kSignUpdate,
-    kSignPrivateKey,
-    kSignPublicKey,
-    kSignMalformedSignature
+  enum class Error {
+    Ok,
+    UnknownDigest,
+    Init,
+    NotInitialised,
+    Update,
+    PrivateKey,
+    PublicKey,
+    MalformedSignature
   };
 
   SignBase(Environment* env, v8::Local<v8::Object> wrap);
 
-  Error Init(const char* sign_type);
+  Error Init(std::string_view digest);
   Error Update(const char* data, size_t len);
 
   // TODO(joyeecheung): track the memory used by OpenSSL types
@@ -45,7 +42,7 @@ class SignBase : public BaseObject {
   ncrypto::EVPMDCtxPointer mdctx_;
 };
 
-class Sign : public SignBase {
+class Sign final : public SignBase {
  public:
   static void Initialize(Environment* env, v8::Local<v8::Object> target);
   static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
@@ -54,15 +51,14 @@ class Sign : public SignBase {
     Error error;
     std::unique_ptr<v8::BackingStore> signature;
 
-    explicit SignResult(
-        Error err,
-        std::unique_ptr<v8::BackingStore>&& sig = nullptr)
-      : error(err), signature(std::move(sig)) {}
+    inline explicit SignResult(
+        Error err, std::unique_ptr<v8::BackingStore>&& sig = nullptr)
+        : error(err), signature(std::move(sig)) {}
   };
 
   SignResult SignFinal(const ncrypto::EVPKeyPointer& pkey,
                        int padding,
-                       const v8::Maybe<int>& saltlen,
+                       std::optional<int> saltlen,
                        DSASigEnc dsa_sig_enc);
 
   static void SignSync(const v8::FunctionCallbackInfo<v8::Value>& args);
@@ -76,7 +72,7 @@ class Sign : public SignBase {
   Sign(Environment* env, v8::Local<v8::Object> wrap);
 };
 
-class Verify : public SignBase {
+class Verify final : public SignBase {
  public:
   static void Initialize(Environment* env, v8::Local<v8::Object> target);
   static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
@@ -84,7 +80,7 @@ class Verify : public SignBase {
   Error VerifyFinal(const ncrypto::EVPKeyPointer& key,
                     const ByteSource& sig,
                     int padding,
-                    const v8::Maybe<int>& saltlen,
+                    std::optional<int> saltlen,
                     bool* verify_result);
 
   static void VerifySync(const v8::FunctionCallbackInfo<v8::Value>& args);
@@ -99,10 +95,7 @@ class Verify : public SignBase {
 };
 
 struct SignConfiguration final : public MemoryRetainer {
-  enum Mode {
-    kSign,
-    kVerify
-  };
+  enum class Mode { Sign, Verify };
   enum Flags {
     kHasNone = 0,
     kHasSaltLength = 1,
@@ -118,7 +111,7 @@ struct SignConfiguration final : public MemoryRetainer {
   int flags = SignConfiguration::kHasNone;
   int padding = 0;
   int salt_length = 0;
-  DSASigEnc dsa_encoding = kSigEncDER;
+  DSASigEnc dsa_encoding = DSASigEnc::DER;
 
   SignConfiguration() = default;
 
@@ -135,8 +128,6 @@ struct SignTraits final {
   using AdditionalParameters = SignConfiguration;
   static constexpr const char* JobName = "SignJob";
 
-// TODO(@jasnell): Sign request vs. Verify request
-
   static constexpr AsyncWrap::ProviderType Provider =
       AsyncWrap::PROVIDER_SIGNREQUEST;
 
diff --git a/src/crypto/crypto_tls.cc b/src/crypto/crypto_tls.cc
index 0f1defef16661a..7104ee19a6dd79 100644
--- a/src/crypto/crypto_tls.cc
+++ b/src/crypto/crypto_tls.cc
@@ -46,6 +46,7 @@ using v8::Array;
 using v8::ArrayBuffer;
 using v8::ArrayBufferView;
 using v8::BackingStore;
+using v8::BackingStoreInitializationMode;
 using v8::Boolean;
 using v8::Context;
 using v8::DontDelete;
@@ -60,6 +61,7 @@ using v8::Isolate;
 using v8::Local;
 using v8::MaybeLocal;
 using v8::Null;
+using v8::Number;
 using v8::Object;
 using v8::PropertyAttribute;
 using v8::ReadOnly;
@@ -161,7 +163,7 @@ int NewSessionCallback(SSL* s, SSL_SESSION* sess) {
   HandleScope handle_scope(env->isolate());
   Context::Scope context_scope(env->context());
 
-  if (!w->has_session_callbacks())
+  if (!w->has_session_callbacks()) [[unlikely]]
     return 0;
 
   // Check if session is small enough to be stored
@@ -225,10 +227,9 @@ int SSLCertCallback(SSL* s, void* arg) {
 
   auto servername = SSLPointer::GetServerName(s);
   Local<String> servername_str =
-      !servername.has_value() ? String::Empty(env->isolate())
-                              : OneByteString(env->isolate(),
-                                              servername.value().data(),
-                                              servername.value().length());
+      !servername.has_value()
+          ? String::Empty(env->isolate())
+          : OneByteString(env->isolate(), servername.value());
 
   Local<Value> ocsp = Boolean::New(
       env->isolate(), SSL_get_tlsext_status_type(s) == TLSEXT_STATUSTYPE_ocsp);
@@ -257,30 +258,27 @@ int SelectALPNCallback(
     Environment* env = w->env();
     HandleScope handle_scope(env->isolate());
 
-    Local<Value> callback_arg =
-        Buffer::Copy(env, reinterpret_cast<const char*>(in), inlen)
-            .ToLocalChecked();
+    Local<Value> callback_arg;
+    Local<Value> callback_result;
 
-    MaybeLocal<Value> maybe_callback_result =
-        w->MakeCallback(env->alpn_callback_string(), 1, &callback_arg);
-
-    if (maybe_callback_result.IsEmpty()) [[unlikely]] {
-      // Implies the callback didn't return, because some exception was thrown
-      // during processing, e.g. if callback returned an invalid ALPN value.
+    if (!Buffer::Copy(env, reinterpret_cast<const char*>(in), inlen)
+             .ToLocal(&callback_arg)) {
       return SSL_TLSEXT_ERR_ALERT_FATAL;
     }
 
-    Local<Value> callback_result = maybe_callback_result.ToLocalChecked();
+    if (!w->MakeCallback(env->alpn_callback_string(), 1, &callback_arg)
+             .ToLocal(&callback_result)) {
+      return SSL_TLSEXT_ERR_ALERT_FATAL;
+    }
 
-    if (callback_result->IsUndefined()) {
+    if (callback_result->IsUndefined() && !callback_result->IsNumber()) {
       // If you set an ALPN callback, but you return undefined for an ALPN
       // request, you're rejecting all proposed ALPN protocols, and so we send
       // a fatal alert:
       return SSL_TLSEXT_ERR_ALERT_FATAL;
     }
 
-    CHECK(callback_result->IsNumber());
-    unsigned int result_int = callback_result.As<v8::Number>()->Value();
+    unsigned int result_int = callback_result.As<Number>()->Value();
 
     // The callback returns an offset into the given buffer, for the selected
     // protocol that should be returned. We then set outlen & out to point
@@ -1087,10 +1085,10 @@ int TLSWrap::DoWrite(WriteWrap* w,
   // and copying it when it could just be used.
 
   if (nonempty_count != 1) {
-    {
-      NoArrayBufferZeroFillScope no_zero_fill_scope(env()->isolate_data());
-      bs = ArrayBuffer::NewBackingStore(env()->isolate(), length);
-    }
+    bs = ArrayBuffer::NewBackingStore(
+        env()->isolate(),
+        length,
+        BackingStoreInitializationMode::kUninitialized);
     size_t offset = 0;
     for (i = 0; i < count; i++) {
       memcpy(static_cast<char*>(bs->Data()) + offset,
@@ -1107,8 +1105,10 @@ int TLSWrap::DoWrite(WriteWrap* w,
     written = SSL_write(ssl_.get(), buf->base, buf->len);
 
     if (written == -1) {
-      NoArrayBufferZeroFillScope no_zero_fill_scope(env()->isolate_data());
-      bs = ArrayBuffer::NewBackingStore(env()->isolate(), length);
+      bs = ArrayBuffer::NewBackingStore(
+          env()->isolate(),
+          length,
+          BackingStoreInitializationMode::kUninitialized);
       memcpy(bs->Data(), buf->base, buf->len);
     }
   }
@@ -1750,11 +1750,8 @@ void TLSWrap::GetFinished(const FunctionCallbackInfo<Value>& args) {
   if (len == 0)
     return;
 
-  std::unique_ptr<BackingStore> bs;
-  {
-    NoArrayBufferZeroFillScope no_zero_fill_scope(env->isolate_data());
-    bs = ArrayBuffer::NewBackingStore(env->isolate(), len);
-  }
+  auto bs = ArrayBuffer::NewBackingStore(
+      env->isolate(), len, BackingStoreInitializationMode::kUninitialized);
 
   CHECK_EQ(bs->ByteLength(),
            SSL_get_finished(w->ssl_.get(), bs->Data(), bs->ByteLength()));
@@ -1781,11 +1778,8 @@ void TLSWrap::GetPeerFinished(const FunctionCallbackInfo<Value>& args) {
   if (len == 0)
     return;
 
-  std::unique_ptr<BackingStore> bs;
-  {
-    NoArrayBufferZeroFillScope no_zero_fill_scope(env->isolate_data());
-    bs = ArrayBuffer::NewBackingStore(env->isolate(), len);
-  }
+  auto bs = ArrayBuffer::NewBackingStore(
+      env->isolate(), len, BackingStoreInitializationMode::kUninitialized);
 
   CHECK_EQ(bs->ByteLength(),
            SSL_get_peer_finished(w->ssl_.get(), bs->Data(), bs->ByteLength()));
@@ -1810,11 +1804,8 @@ void TLSWrap::GetSession(const FunctionCallbackInfo<Value>& args) {
   if (slen <= 0)
     return;  // Invalid or malformed session.
 
-  std::unique_ptr<BackingStore> bs;
-  {
-    NoArrayBufferZeroFillScope no_zero_fill_scope(env->isolate_data());
-    bs = ArrayBuffer::NewBackingStore(env->isolate(), slen);
-  }
+  auto bs = ArrayBuffer::NewBackingStore(
+      env->isolate(), slen, BackingStoreInitializationMode::kUninitialized);
 
   unsigned char* p = static_cast<unsigned char*>(bs->Data());
   CHECK_LT(0, i2d_SSL_SESSION(sess, &p));
@@ -1997,11 +1988,8 @@ void TLSWrap::ExportKeyingMaterial(const FunctionCallbackInfo<Value>& args) {
   uint32_t olen = args[0].As<Uint32>()->Value();
   Utf8Value label(env->isolate(), args[1]);
 
-  std::unique_ptr<BackingStore> bs;
-  {
-    NoArrayBufferZeroFillScope no_zero_fill_scope(env->isolate_data());
-    bs = ArrayBuffer::NewBackingStore(env->isolate(), olen);
-  }
+  auto bs = ArrayBuffer::NewBackingStore(
+      env->isolate(), olen, BackingStoreInitializationMode::kUninitialized);
 
   ByteSource context;
   bool use_context = !args[2]->IsUndefined();
diff --git a/src/crypto/crypto_tls.h b/src/crypto/crypto_tls.h
index ed1ee337b42ec1..f02c37182ff189 100644
--- a/src/crypto/crypto_tls.h
+++ b/src/crypto/crypto_tls.h
@@ -58,15 +58,17 @@ class TLSWrap : public AsyncWrap,
 
   ~TLSWrap() override;
 
-  bool is_cert_cb_running() const { return cert_cb_running_; }
-  bool is_waiting_cert_cb() const { return cert_cb_ != nullptr; }
-  bool has_session_callbacks() const { return session_callbacks_; }
-  void set_cert_cb_running(bool on = true) { cert_cb_running_ = on; }
-  void set_awaiting_new_session(bool on = true) { awaiting_new_session_ = on; }
-  void enable_session_callbacks() { session_callbacks_ = true; }
-  bool is_server() const { return kind_ == Kind::kServer; }
-  bool is_client() const { return kind_ == Kind::kClient; }
-  bool is_awaiting_new_session() const { return awaiting_new_session_; }
+  inline bool is_cert_cb_running() const { return cert_cb_running_; }
+  inline bool is_waiting_cert_cb() const { return cert_cb_ != nullptr; }
+  inline bool has_session_callbacks() const { return session_callbacks_; }
+  inline void set_cert_cb_running(bool on = true) { cert_cb_running_ = on; }
+  inline void set_awaiting_new_session(bool on = true) {
+    awaiting_new_session_ = on;
+  }
+  inline void enable_session_callbacks() { session_callbacks_ = true; }
+  inline bool is_server() const { return kind_ == Kind::kServer; }
+  inline bool is_client() const { return kind_ == Kind::kClient; }
+  inline bool is_awaiting_new_session() const { return awaiting_new_session_; }
 
   // Implement StreamBase:
   bool IsAlive() override;
@@ -128,7 +130,7 @@ class TLSWrap : public AsyncWrap,
 
   // Alternative to StreamListener::stream(), that returns a StreamBase instead
   // of a StreamResource.
-  StreamBase* underlying_stream() const {
+  inline StreamBase* underlying_stream() const {
     return static_cast<StreamBase*>(stream());
   }
 
diff --git a/src/crypto/crypto_util.cc b/src/crypto/crypto_util.cc
index 60610b1b795c9b..61f8cbf6703b50 100644
--- a/src/crypto/crypto_util.cc
+++ b/src/crypto/crypto_util.cc
@@ -630,17 +630,12 @@ Maybe<void> SetEncodedValue(Environment* env,
                                                            : Nothing<void>();
 }
 
-bool SetRsaOaepLabel(const EVPKeyCtxPointer& ctx, const ByteSource& label) {
+bool SetRsaOaepLabel(EVPKeyCtxPointer* ctx, const ByteSource& label) {
   if (label.size() != 0) {
     // OpenSSL takes ownership of the label, so we need to create a copy.
-    void* label_copy = OPENSSL_memdup(label.data(), label.size());
-    CHECK_NOT_NULL(label_copy);
-    int ret = EVP_PKEY_CTX_set0_rsa_oaep_label(
-        ctx.get(), static_cast<unsigned char*>(label_copy), label.size());
-    if (ret <= 0) {
-      OPENSSL_free(label_copy);
-      return false;
-    }
+    auto dup = ncrypto::DataPointer::Copy(label);
+    if (!dup) return false;
+    return ctx->setRsaOaepLabel(std::move(dup));
   }
   return true;
 }
diff --git a/src/crypto/crypto_util.h b/src/crypto/crypto_util.h
index a5967c7d24b836..e3c9a82c17b382 100644
--- a/src/crypto/crypto_util.h
+++ b/src/crypto/crypto_util.h
@@ -61,10 +61,9 @@ void InitCryptoOnce();
 
 void InitCrypto(v8::Local<v8::Object> target);
 
-extern void UseExtraCaCerts(const std::string& file);
+extern void UseExtraCaCerts(std::string_view file);
 
 int PasswordCallback(char* buf, int size, int rwflag, void* u);
-
 int NoPasswordCallback(char* buf, int size, int rwflag, void* u);
 
 // Decode is used by the various stream-based crypto utilities to decode
@@ -165,7 +164,7 @@ T* MallocOpenSSL(size_t count) {
 
 // A helper class representing a read-only byte array. When deallocated, its
 // contents are zeroed.
-class ByteSource {
+class ByteSource final {
  public:
   class Builder {
    public:
@@ -224,17 +223,25 @@ class ByteSource {
   ByteSource& operator=(const ByteSource&) = delete;
 
   template <typename T = void>
-  const T* data() const {
+  inline const T* data() const {
     return reinterpret_cast<const T*>(data_);
   }
 
-  size_t size() const { return size_; }
+  template <typename T = void>
+  operator ncrypto::Buffer<const T>() const {
+    return ncrypto::Buffer<const T>{
+        .data = data<T>(),
+        .len = size(),
+    };
+  }
+
+  inline size_t size() const { return size_; }
 
-  bool empty() const { return size_ == 0; }
+  inline bool empty() const { return size_ == 0; }
 
-  operator bool() const { return data_ != nullptr; }
+  inline operator bool() const { return data_ != nullptr; }
 
-  ncrypto::BignumPointer ToBN() const {
+  inline ncrypto::BignumPointer ToBN() const {
     return ncrypto::BignumPointer(data<unsigned char>(), size());
   }
 
@@ -518,7 +525,7 @@ void ThrowCryptoError(Environment* env,
                       unsigned long err,  // NOLINT(runtime/int)
                       const char* message = nullptr);
 
-class CipherPushContext {
+class CipherPushContext final {
  public:
   inline explicit CipherPushContext(Environment* env)
       : list_(env->isolate()), env_(env) {}
@@ -546,16 +553,13 @@ void array_push_back(const TypeName* evp_ref,
                      const char* from,
                      const char* to,
                      void* arg) {
-  if (!from)
-    return;
+  if (!from) return;
 
   const TypeName* real_instance = getbyname(from);
-  if (!real_instance)
-    return;
+  if (!real_instance) return;
 
   const char* real_name = getname(real_instance);
-  if (!real_name)
-    return;
+  if (!real_name) return;
 
   // EVP_*_fetch() does not support alias names, so we need to pass it the
   // real/original algorithm name.
@@ -564,8 +568,7 @@ void array_push_back(const TypeName* evp_ref,
   // algorithms are used internally by OpenSSL and are also passed to this
   // callback).
   TypeName* fetched = fetch_type(nullptr, real_name, nullptr);
-  if (!fetched)
-    return;
+  if (!fetched) return;
 
   free_type(fetched);
   static_cast<CipherPushContext*>(arg)->push_back(from);
@@ -576,8 +579,7 @@ void array_push_back(const TypeName* evp_ref,
                      const char* from,
                      const char* to,
                      void* arg) {
-  if (!from)
-    return;
+  if (!from) return;
   static_cast<CipherPushContext*>(arg)->push_back(from);
 }
 #endif
@@ -590,7 +592,7 @@ inline bool IsAnyBufferSource(v8::Local<v8::Value> arg) {
 }
 
 template <typename T>
-class ArrayBufferOrViewContents {
+class ArrayBufferOrViewContents final {
  public:
   ArrayBufferOrViewContents() = default;
   ArrayBufferOrViewContents(const ArrayBufferOrViewContents&) = delete;
@@ -707,8 +709,7 @@ v8::Maybe<void> SetEncodedValue(Environment* env,
                                 const BIGNUM* bn,
                                 int size = 0);
 
-bool SetRsaOaepLabel(const ncrypto::EVPKeyCtxPointer& rsa,
-                     const ByteSource& label);
+bool SetRsaOaepLabel(ncrypto::EVPKeyCtxPointer* rsa, const ByteSource& label);
 
 namespace Util {
 void Initialize(Environment* env, v8::Local<v8::Object> target);
diff --git a/src/crypto/crypto_x509.cc b/src/crypto/crypto_x509.cc
index 3465454e4de4a7..782eced277518d 100644
--- a/src/crypto/crypto_x509.cc
+++ b/src/crypto/crypto_x509.cc
@@ -21,13 +21,12 @@ using ncrypto::ClearErrorOnReturn;
 using ncrypto::DataPointer;
 using ncrypto::ECKeyPointer;
 using ncrypto::SSLPointer;
-using ncrypto::StackOfASN1;
 using ncrypto::X509Pointer;
 using ncrypto::X509View;
 using v8::Array;
 using v8::ArrayBuffer;
 using v8::ArrayBufferView;
-using v8::BackingStore;
+using v8::BackingStoreInitializationMode;
 using v8::Boolean;
 using v8::Context;
 using v8::Date;
@@ -38,6 +37,7 @@ using v8::FunctionTemplate;
 using v8::Integer;
 using v8::Isolate;
 using v8::Local;
+using v8::LocalVector;
 using v8::MaybeLocal;
 using v8::NewStringType;
 using v8::Object;
@@ -55,14 +55,13 @@ ManagedX509::ManagedX509(const ManagedX509& that) {
 
 ManagedX509& ManagedX509::operator=(const ManagedX509& that) {
   cert_.reset(that.get());
-
-  if (cert_)
+  if (cert_) [[likely]]
     X509_up_ref(cert_.get());
-
   return *this;
 }
 
 void ManagedX509::MemoryInfo(MemoryTracker* tracker) const {
+  if (!cert_) return;
   // This is an approximation based on the der encoding size.
   int size = i2d_X509(cert_.get(), nullptr);
   tracker->TrackFieldWithSize("cert", size);
@@ -94,7 +93,8 @@ void Fingerprint(const FunctionCallbackInfo<Value>& args) {
 }
 
 MaybeLocal<Value> ToV8Value(Local<Context> context, BIOPointer&& bio) {
-  if (!bio) return {};
+  if (!bio) [[unlikely]]
+    return {};
   BUF_MEM* mem = bio;
   Local<Value> ret;
   if (!String::NewFromUtf8(context->GetIsolate(),
@@ -135,7 +135,7 @@ MaybeLocal<Value> ToV8Value(Local<Context> context, const ASN1_STRING* str) {
   // not escape anything.
   unsigned char* value_str;
   int value_str_size = ASN1_STRING_to_UTF8(&value_str, str);
-  if (value_str_size < 0) {
+  if (value_str_size < 0) [[unlikely]] {
     return Undefined(context->GetIsolate());
   }
   DataPointer free_value_str(value_str, value_str_size);
@@ -152,7 +152,8 @@ MaybeLocal<Value> ToV8Value(Local<Context> context, const ASN1_STRING* str) {
 }
 
 MaybeLocal<Value> ToV8Value(Local<Context> context, const BIOPointer& bio) {
-  if (!bio) return {};
+  if (!bio) [[unlikely]]
+    return {};
   BUF_MEM* mem = bio;
   Local<Value> ret;
   if (!String::NewFromUtf8(context->GetIsolate(),
@@ -165,7 +166,8 @@ MaybeLocal<Value> ToV8Value(Local<Context> context, const BIOPointer& bio) {
 }
 
 MaybeLocal<Value> ToBuffer(Environment* env, BIOPointer* bio) {
-  if (bio == nullptr || !*bio) return {};
+  if (bio == nullptr || !*bio) [[unlikely]]
+    return {};
   BUF_MEM* mem = *bio;
   auto backing = ArrayBuffer::NewBackingStore(
       mem->data,
@@ -183,7 +185,8 @@ MaybeLocal<Value> ToBuffer(Environment* env, BIOPointer* bio) {
 MaybeLocal<Value> GetDer(Environment* env, const X509View& view) {
   Local<Value> ret;
   auto bio = view.toDER();
-  if (!bio) return Undefined(env->isolate());
+  if (!bio) [[unlikely]]
+    return Undefined(env->isolate());
   if (!ToBuffer(env, &bio).ToLocal(&ret)) {
     return {};
   }
@@ -194,7 +197,8 @@ MaybeLocal<Value> GetSubjectAltNameString(Environment* env,
                                           const X509View& view) {
   Local<Value> ret;
   auto bio = view.getSubjectAltName();
-  if (!bio) return Undefined(env->isolate());
+  if (!bio) [[unlikely]]
+    return Undefined(env->isolate());
   if (!ToV8Value(env->context(), bio).ToLocal(&ret)) return {};
   return ret;
 }
@@ -202,7 +206,8 @@ MaybeLocal<Value> GetSubjectAltNameString(Environment* env,
 MaybeLocal<Value> GetInfoAccessString(Environment* env, const X509View& view) {
   Local<Value> ret;
   auto bio = view.getInfoAccess();
-  if (!bio) return Undefined(env->isolate());
+  if (!bio) [[unlikely]]
+    return Undefined(env->isolate());
   if (!ToV8Value(env->context(), bio).ToLocal(&ret)) {
     return {};
   }
@@ -212,7 +217,8 @@ MaybeLocal<Value> GetInfoAccessString(Environment* env, const X509View& view) {
 MaybeLocal<Value> GetValidFrom(Environment* env, const X509View& view) {
   Local<Value> ret;
   auto bio = view.getValidFrom();
-  if (!bio) return Undefined(env->isolate());
+  if (!bio) [[unlikely]]
+    return Undefined(env->isolate());
   if (!ToV8Value(env->context(), bio).ToLocal(&ret)) {
     return {};
   }
@@ -222,7 +228,8 @@ MaybeLocal<Value> GetValidFrom(Environment* env, const X509View& view) {
 MaybeLocal<Value> GetValidTo(Environment* env, const X509View& view) {
   Local<Value> ret;
   auto bio = view.getValidTo();
-  if (!bio) return Undefined(env->isolate());
+  if (!bio) [[unlikely]]
+    return Undefined(env->isolate());
   if (!ToV8Value(env->context(), bio).ToLocal(&ret)) {
     return {};
   }
@@ -248,25 +255,12 @@ MaybeLocal<Value> GetSerialNumber(Environment* env, const X509View& view) {
 }
 
 MaybeLocal<Value> GetKeyUsage(Environment* env, const X509View& cert) {
-  StackOfASN1 eku(static_cast<STACK_OF(ASN1_OBJECT)*>(
-      X509_get_ext_d2i(cert.get(), NID_ext_key_usage, nullptr, nullptr)));
-  if (eku) {
-    const int count = sk_ASN1_OBJECT_num(eku.get());
-    MaybeStackBuffer<Local<Value>, 16> ext_key_usage(count);
-    char buf[256];
-
-    int j = 0;
-    for (int i = 0; i < count; i++) {
-      if (OBJ_obj2txt(
-              buf, sizeof(buf), sk_ASN1_OBJECT_value(eku.get(), i), 1) >= 0) {
-        ext_key_usage[j++] = OneByteString(env->isolate(), buf);
-      }
-    }
-
-    return Array::New(env->isolate(), ext_key_usage.out(), count);
-  }
-
-  return Undefined(env->isolate());
+  LocalVector<Value> vec(env->isolate());
+  bool res = cert.enumUsages([&](std::string_view view) {
+    vec.push_back(OneByteString(env->isolate(), view));
+  });
+  if (!res) return Undefined(env->isolate());
+  return Array::New(env->isolate(), vec.data(), vec.size());
 }
 
 void Pem(const FunctionCallbackInfo<Value>& args) {
@@ -387,7 +381,7 @@ void PublicKey(const FunctionCallbackInfo<Value>& args) {
   // TODO(tniessen): consider checking X509_get_pubkey() when the
   // X509Certificate object is being created.
   auto result = cert->view().getPublicKey();
-  if (!result.value) {
+  if (!result.value) [[unlikely]] {
     ThrowCryptoError(env, result.error.value_or(0));
     return;
   }
@@ -547,7 +541,9 @@ void Parse(const FunctionCallbackInfo<Value>& args) {
       .len = buf.length(),
   });
 
-  if (!result.value) return ThrowCryptoError(env, result.error.value_or(0));
+  if (!result.value) [[unlikely]] {
+    return ThrowCryptoError(env, result.error.value_or(0));
+  }
 
   if (X509Certificate::New(env, std::move(result.value)).ToLocal(&cert)) {
     args.GetReturnValue().Set(cert);
@@ -571,7 +567,8 @@ bool Set(Environment* env,
          Local<Value> name,
          MaybeLocal<T> maybe_value) {
   Local<Value> value;
-  if (!maybe_value.ToLocal(&value)) return false;
+  if (!maybe_value.ToLocal(&value)) [[unlikely]]
+    return false;
 
   // Undefined is ignored, but still considered successful
   if (value->IsUndefined()) return true;
@@ -585,7 +582,8 @@ bool Set(Environment* env,
          uint32_t index,
          MaybeLocal<T> maybe_value) {
   Local<Value> value;
-  if (!maybe_value.ToLocal(&value)) return false;
+  if (!maybe_value.ToLocal(&value)) [[unlikely]]
+    return false;
 
   // Undefined is ignored, but still considered successful
   if (value->IsUndefined()) return true;
@@ -664,33 +662,32 @@ static MaybeLocal<Value> GetX509NameObject(Environment* env,
   return result;
 }
 
-MaybeLocal<Object> GetPubKey(Environment* env, OSSL3_CONST RSA* rsa) {
+MaybeLocal<Object> GetPubKey(Environment* env, const ncrypto::Rsa& rsa) {
   int size = i2d_RSA_PUBKEY(rsa, nullptr);
   CHECK_GE(size, 0);
 
-  std::unique_ptr<BackingStore> bs;
-  {
-    NoArrayBufferZeroFillScope no_zero_fill_scope(env->isolate_data());
-    bs = ArrayBuffer::NewBackingStore(env->isolate(), size);
-  }
+  auto bs = ArrayBuffer::NewBackingStore(
+      env->isolate(), size, BackingStoreInitializationMode::kUninitialized);
 
-  unsigned char* serialized = reinterpret_cast<unsigned char*>(bs->Data());
+  auto serialized = reinterpret_cast<unsigned char*>(bs->Data());
   CHECK_GE(i2d_RSA_PUBKEY(rsa, &serialized), 0);
 
-  Local<ArrayBuffer> ab = ArrayBuffer::New(env->isolate(), std::move(bs));
+  auto ab = ArrayBuffer::New(env->isolate(), std::move(bs));
   return Buffer::New(env, ab, 0, ab->ByteLength()).FromMaybe(Local<Object>());
 }
 
 MaybeLocal<Value> GetModulusString(Environment* env, const BIGNUM* n) {
   auto bio = BIOPointer::New(n);
-  if (!bio) return {};
+  if (!bio) [[unlikely]]
+    return {};
   return ToV8Value(env->context(), bio);
 }
 
 MaybeLocal<Value> GetExponentString(Environment* env, const BIGNUM* e) {
   uint64_t exponent_word = static_cast<uint64_t>(BignumPointer::GetWord(e));
   auto bio = BIOPointer::NewMem();
-  if (!bio) return {};
+  if (!bio) [[unlikely]]
+    return {};
   BIO_printf(bio.get(), "0x%" PRIx64, exponent_word);
   return ToV8Value(env->context(), bio);
 }
@@ -699,14 +696,16 @@ MaybeLocal<Value> GetECPubKey(Environment* env,
                               const EC_GROUP* group,
                               OSSL3_CONST EC_KEY* ec) {
   const auto pubkey = ECKeyPointer::GetPublicKey(ec);
-  if (pubkey == nullptr) return Undefined(env->isolate());
+  if (pubkey == nullptr) [[unlikely]]
+    return Undefined(env->isolate());
 
   return ECPointToBuffer(env, group, pubkey, EC_KEY_get_conv_form(ec), nullptr)
       .FromMaybe(Local<Object>());
 }
 
 MaybeLocal<Value> GetECGroupBits(Environment* env, const EC_GROUP* group) {
-  if (group == nullptr) return Undefined(env->isolate());
+  if (group == nullptr) [[unlikely]]
+    return Undefined(env->isolate());
 
   int bits = EC_GROUP_order_bits(group);
   if (bits <= 0) return Undefined(env->isolate());
@@ -716,10 +715,9 @@ MaybeLocal<Value> GetECGroupBits(Environment* env, const EC_GROUP* group) {
 
 template <const char* (*nid2string)(int nid)>
 MaybeLocal<Value> GetCurveName(Environment* env, const int nid) {
-  const char* name = nid2string(nid);
-  return name != nullptr
-             ? MaybeLocal<Value>(OneByteString(env->isolate(), name))
-             : MaybeLocal<Value>(Undefined(env->isolate()));
+  std::string_view name = nid2string(nid);
+  return name.size() ? MaybeLocal<Value>(OneByteString(env->isolate(), name))
+                     : MaybeLocal<Value>(Undefined(env->isolate()));
 }
 
 MaybeLocal<Object> X509ToObject(Environment* env, const X509View& cert) {
@@ -745,68 +743,68 @@ MaybeLocal<Object> X509ToObject(Environment* env, const X509View& cert) {
       !Set<Boolean>(env,
                     info,
                     env->ca_string(),
-                    Boolean::New(env->isolate(), cert.isCA()))) {
+                    Boolean::New(env->isolate(), cert.isCA()))) [[unlikely]] {
     return {};
   }
 
-  OSSL3_CONST EVP_PKEY* pkey = X509_get0_pubkey(cert.get());
-  OSSL3_CONST RSA* rsa = nullptr;
-  OSSL3_CONST EC_KEY* ec = nullptr;
-  if (pkey != nullptr) {
-    switch (EVP_PKEY_id(pkey)) {
-      case EVP_PKEY_RSA:
-        rsa = EVP_PKEY_get0_RSA(pkey);
-        break;
-      case EVP_PKEY_EC:
-        ec = EVP_PKEY_get0_EC_KEY(pkey);
-        break;
-    }
+  if (!cert.ifRsa([&](const ncrypto::Rsa& rsa) {
+        auto pub_key = rsa.getPublicKey();
+        if (!Set<Value>(env,
+                        info,
+                        env->modulus_string(),
+                        GetModulusString(env, pub_key.n)) ||
+            !Set<Value>(env,
+                        info,
+                        env->bits_string(),
+                        Integer::New(env->isolate(),
+                                     BignumPointer::GetBitCount(pub_key.n))) ||
+            !Set<Value>(env,
+                        info,
+                        env->exponent_string(),
+                        GetExponentString(env, pub_key.e)) ||
+            !Set<Object>(env, info, env->pubkey_string(), GetPubKey(env, rsa)))
+            [[unlikely]] {
+          return false;
+        }
+        return true;
+      })) [[unlikely]] {
+    return {};
   }
 
-  if (rsa) {
-    const BIGNUM* n;
-    const BIGNUM* e;
-    RSA_get0_key(rsa, &n, &e, nullptr);
-    if (!Set<Value>(
-            env, info, env->modulus_string(), GetModulusString(env, n)) ||
-        !Set<Value>(
-            env,
-            info,
-            env->bits_string(),
-            Integer::New(env->isolate(), BignumPointer::GetBitCount(n))) ||
-        !Set<Value>(
-            env, info, env->exponent_string(), GetExponentString(env, e)) ||
-        !Set<Object>(env, info, env->pubkey_string(), GetPubKey(env, rsa))) {
-      return {};
-    }
-  } else if (ec) {
-    const auto group = ECKeyPointer::GetGroup(ec);
+  if (!cert.ifEc([&](const ncrypto::Ec& ec) {
+        const auto group = ec.getGroup();
 
-    if (!Set<Value>(
-            env, info, env->bits_string(), GetECGroupBits(env, group)) ||
-        !Set<Value>(
-            env, info, env->pubkey_string(), GetECPubKey(env, group, ec))) {
-      return {};
-    }
+        if (!Set<Value>(
+                env, info, env->bits_string(), GetECGroupBits(env, group)) ||
+            !Set<Value>(
+                env, info, env->pubkey_string(), GetECPubKey(env, group, ec)))
+            [[unlikely]] {
+          return false;
+        }
 
-    const int nid = EC_GROUP_get_curve_name(group);
-    if (nid != 0) {
-      // Curve is well-known, get its OID and NIST nick-name (if it has one).
-
-      if (!Set<Value>(env,
-                      info,
-                      env->asn1curve_string(),
-                      GetCurveName<OBJ_nid2sn>(env, nid)) ||
-          !Set<Value>(env,
-                      info,
-                      env->nistcurve_string(),
-                      GetCurveName<EC_curve_nid2nist>(env, nid))) {
-        return {};
-      }
-    } else {
-      // Unnamed curves can be described by their mathematical properties,
-      // but aren't used much (at all?) with X.509/TLS. Support later if needed.
-    }
+        const int nid = ec.getCurve();
+        if (nid != 0) [[likely]] {
+          // Curve is well-known, get its OID and NIST nick-name (if it has
+          // one).
+
+          if (!Set<Value>(env,
+                          info,
+                          env->asn1curve_string(),
+                          GetCurveName<OBJ_nid2sn>(env, nid)) ||
+              !Set<Value>(env,
+                          info,
+                          env->nistcurve_string(),
+                          GetCurveName<EC_curve_nid2nist>(env, nid)))
+              [[unlikely]] {
+            return false;
+          }
+        }
+        // Unnamed curves can be described by their mathematical properties,
+        // but aren't used much (at all?) with X.509/TLS. Support later if
+        // needed.
+        return true;
+      })) [[unlikely]] {
+    return {};
   }
 
   if (!Set<Value>(
@@ -828,7 +826,8 @@ MaybeLocal<Object> X509ToObject(Environment* env, const X509View& cert) {
           env, info, env->ext_key_usage_string(), GetKeyUsage(env, cert)) ||
       !Set<Value>(
           env, info, env->serial_number_string(), GetSerialNumber(env, cert)) ||
-      !Set<Value>(env, info, env->raw_string(), GetDer(env, cert))) {
+      !Set<Value>(env, info, env->raw_string(), GetDer(env, cert)))
+      [[unlikely]] {
     return {};
   }
 
@@ -910,7 +909,8 @@ MaybeLocal<Object> X509Certificate::New(Environment* env,
 MaybeLocal<Object> X509Certificate::GetCert(Environment* env,
                                             const SSLPointer& ssl) {
   auto cert = X509View::From(ssl);
-  if (!cert) return {};
+  if (!cert) [[unlikely]]
+    return {};
   return New(env, cert.clone());
 }
 
@@ -930,7 +930,7 @@ MaybeLocal<Object> X509Certificate::GetPeerCert(Environment* env,
   if (!cert && (ssl_certs == nullptr || sk_X509_num(ssl_certs) == 0))
     return MaybeLocal<Object>();
 
-  if (!cert) {
+  if (!cert) [[unlikely]] {
     cert.reset(sk_X509_value(ssl_certs, 0));
     sk_X509_delete(ssl_certs, 0);
   }
@@ -945,7 +945,8 @@ v8::MaybeLocal<v8::Value> X509Certificate::toObject(Environment* env) {
 
 v8::MaybeLocal<v8::Value> X509Certificate::toObject(Environment* env,
                                                     const X509View& cert) {
-  if (!cert) return {};
+  if (!cert) [[unlikely]]
+    return {};
   return X509ToObject(env, cert).FromMaybe(Local<Value>());
 }
 
@@ -979,7 +980,7 @@ X509Certificate::X509CertificateTransferData::Deserialize(
     Environment* env,
     Local<Context> context,
     std::unique_ptr<worker::TransferData> self) {
-  if (context != env->context()) {
+  if (context != env->context()) [[unlikely]] {
     THROW_ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE(env);
     return {};
   }
diff --git a/src/crypto/crypto_x509.h b/src/crypto/crypto_x509.h
index 54f4b2a40732d2..39f1878be1925f 100644
--- a/src/crypto/crypto_x509.h
+++ b/src/crypto/crypto_x509.h
@@ -25,10 +25,10 @@ class ManagedX509 final : public MemoryRetainer {
   ManagedX509(const ManagedX509& that);
   ManagedX509& operator=(const ManagedX509& that);
 
-  operator bool() const { return !!cert_; }
-  X509* get() const { return cert_.get(); }
-  ncrypto::X509View view() const { return cert_; }
-  operator ncrypto::X509View() const { return cert_; }
+  inline operator bool() const { return !!cert_; }
+  inline X509* get() const { return cert_.get(); }
+  inline ncrypto::X509View view() const { return cert_; }
+  inline operator ncrypto::X509View() const { return cert_; }
 
   void MemoryInfo(MemoryTracker* tracker) const override;
   SET_MEMORY_INFO_NAME(ManagedX509)
@@ -77,7 +77,7 @@ class X509Certificate final : public BaseObject {
   }
 
   inline ncrypto::X509View view() const { return *cert_; }
-  X509* get() { return cert_->get(); }
+  inline X509* get() { return cert_->get(); }
 
   v8::MaybeLocal<v8::Value> toObject(Environment* env);
   static v8::MaybeLocal<v8::Value> toObject(Environment* env,

From 1c7c32f96128ac2ae5472dd2da425d9cf638b453 Mon Sep 17 00:00:00 2001
From: Burkov Egor <eburkov@rvision.ru>
Date: Wed, 22 Jan 2025 16:16:31 +0300
Subject: [PATCH 24/38] src: add nullptr handling from X509_STORE_new()

In openssl we should check result of X509_STORE_new() for nullptr
Refs: https://github.com/nodejs/node/issues/56694

PR-URL: https://github.com/nodejs/node/pull/56700
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
---
 src/crypto/crypto_context.cc | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/crypto/crypto_context.cc b/src/crypto/crypto_context.cc
index da5cebb87a3d51..af7ac2e5e8eba9 100644
--- a/src/crypto/crypto_context.cc
+++ b/src/crypto/crypto_context.cc
@@ -272,6 +272,7 @@ X509_STORE* NewRootCertStore() {
   }
 
   X509_STORE* store = X509_STORE_new();
+  CHECK_NOT_NULL(store);
   if (*system_cert_path != '\0') {
     ERR_set_mark();
     X509_STORE_load_locations(store, system_cert_path, nullptr);

From 80c70ee84520b6f489e63c1e4298c3a296f00aab Mon Sep 17 00:00:00 2001
From: Luigi Pinca <luigipinca@gmail.com>
Date: Sun, 26 Jan 2025 17:41:21 +0100
Subject: [PATCH 25/38] test: do not use common.isMainThread
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`common.isMainThread` was removed in
https://github.com/nodejs/node/commit/8caa1dcee63b2c6fd7a9, use the
`isMainThread` export of the `worker_threads` module instead.

PR-URL: https://github.com/nodejs/node/pull/56768
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Chengzhong Wu <legendecas@gmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 test/parallel/test-require-resolve-opts-paths-relative.js | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/test/parallel/test-require-resolve-opts-paths-relative.js b/test/parallel/test-require-resolve-opts-paths-relative.js
index 522a1fdbce82a4..13d17d478b753d 100644
--- a/test/parallel/test-require-resolve-opts-paths-relative.js
+++ b/test/parallel/test-require-resolve-opts-paths-relative.js
@@ -3,8 +3,9 @@
 const common = require('../common');
 const assert = require('assert');
 const fixtures = require('../common/fixtures');
+const { isMainThread } = require('worker_threads');
 
-if (!common.isMainThread)
+if (!isMainThread)
   common.skip('process.chdir is not available in Workers');
 
 const subdir = fixtures.path('module-require', 'relative', 'subdir');

From ea7ab162d67b4122510d23e197a80ec8c5a2ecde Mon Sep 17 00:00:00 2001
From: James M Snell <jasnell@gmail.com>
Date: Sun, 26 Jan 2025 09:19:39 -0800
Subject: [PATCH 26/38] test: cleanup and simplify test-crypto-aes-wrap

* Add comment explaining purpose of the test
* Eliminate duplicative/extraneous buffer allocations

PR-URL: https://github.com/nodejs/node/pull/56748
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
Reviewed-By: Richard Lau <rlau@redhat.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
---
 test/parallel/test-crypto-aes-wrap.js | 58 +++++++++++++--------------
 1 file changed, 28 insertions(+), 30 deletions(-)

diff --git a/test/parallel/test-crypto-aes-wrap.js b/test/parallel/test-crypto-aes-wrap.js
index 6fe35258f7d6b2..21d48d8a3fbae7 100644
--- a/test/parallel/test-crypto-aes-wrap.js
+++ b/test/parallel/test-crypto-aes-wrap.js
@@ -1,62 +1,60 @@
 'use strict';
 const common = require('../common');
-if (!common.hasCrypto)
+if (!common.hasCrypto) {
   common.skip('missing crypto');
+}
+
+// Tests that the AES wrap and unwrap functions are working correctly.
 
 const assert = require('assert');
 const crypto = require('crypto');
 
-const test = [
+const ivShort = Buffer.from('3fd838af', 'hex');
+const ivLong = Buffer.from('3fd838af4093d749', 'hex');
+const key1 = Buffer.from('b26f309fbe57e9b3bb6ae5ef31d54450', 'hex');
+const key2 = Buffer.from('40978085d68091f7dfca0d7dfc7a5ee76d2cc7f2f345a304', 'hex');
+const key3 = Buffer.from('29c9eab5ed5ad44134a1437fe2e673b4d88a5b7c72e68454fea08721392b7323', 'hex');
+
+[
   {
     algorithm: 'aes128-wrap',
-    key: 'b26f309fbe57e9b3bb6ae5ef31d54450',
-    iv: '3fd838af4093d749',
+    key: key1,
+    iv: ivLong,
     text: '12345678123456781234567812345678'
   },
   {
     algorithm: 'id-aes128-wrap-pad',
-    key: 'b26f309fbe57e9b3bb6ae5ef31d54450',
-    iv: '3fd838af',
+    key: key1,
+    iv: ivShort,
     text: '12345678123456781234567812345678123'
   },
   {
     algorithm: 'aes192-wrap',
-    key: '40978085d68091f7dfca0d7dfc7a5ee76d2cc7f2f345a304',
-    iv: '3fd838af4093d749',
+    key: key2,
+    iv: ivLong,
     text: '12345678123456781234567812345678'
   },
   {
     algorithm: 'id-aes192-wrap-pad',
-    key: '40978085d68091f7dfca0d7dfc7a5ee76d2cc7f2f345a304',
-    iv: '3fd838af',
+    key: key2,
+    iv: ivShort,
     text: '12345678123456781234567812345678123'
   },
   {
     algorithm: 'aes256-wrap',
-    key: '29c9eab5ed5ad44134a1437fe2e673b4d88a5b7c72e68454fea08721392b7323',
-    iv: '3fd838af4093d749',
+    key: key3,
+    iv: ivLong,
     text: '12345678123456781234567812345678'
   },
   {
     algorithm: 'id-aes256-wrap-pad',
-    key: '29c9eab5ed5ad44134a1437fe2e673b4d88a5b7c72e68454fea08721392b7323',
-    iv: '3fd838af',
+    key: key3,
+    iv: ivShort,
     text: '12345678123456781234567812345678123'
   },
-];
-
-test.forEach((data) => {
-  const cipher = crypto.createCipheriv(
-    data.algorithm,
-    Buffer.from(data.key, 'hex'),
-    Buffer.from(data.iv, 'hex'));
-  const ciphertext = cipher.update(data.text, 'utf8');
-
-  const decipher = crypto.createDecipheriv(
-    data.algorithm,
-    Buffer.from(data.key, 'hex'),
-    Buffer.from(data.iv, 'hex'));
-  const msg = decipher.update(ciphertext, 'buffer', 'utf8');
-
-  assert.strictEqual(msg, data.text, `${data.algorithm} test case failed`);
+].forEach(({ algorithm, key, iv, text }) => {
+  const cipher = crypto.createCipheriv(algorithm, key, iv);
+  const decipher = crypto.createDecipheriv(algorithm, key, iv);
+  const msg = decipher.update(cipher.update(text, 'utf8'), 'buffer', 'utf8');
+  assert.strictEqual(msg, text, `${algorithm} test case failed`);
 });

From a6c5ce27d39d52e8bfe04ed8d747b19eb8970960 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Sun, 26 Jan 2025 19:31:35 +0100
Subject: [PATCH 27/38] doc: improve accessibility of expandable lists
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

PR-URL: https://github.com/nodejs/node/pull/56749
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Ulises Gascón <ulisesgascongonzalez@gmail.com>
Reviewed-By: Claudio Wunder <cwunder@gnome.org>
---
 doc/api_assets/api.js    |  6 +++++-
 doc/api_assets/style.css | 17 ++++++-----------
 doc/template.html        |  6 +++---
 tools/doc/html.mjs       | 12 ++++++------
 4 files changed, 20 insertions(+), 21 deletions(-)

diff --git a/doc/api_assets/api.js b/doc/api_assets/api.js
index 394b5ba990946c..e86f110e0346bf 100644
--- a/doc/api_assets/api.js
+++ b/doc/api_assets/api.js
@@ -41,6 +41,7 @@
     function closeAllPickers() {
       for (const picker of pickers) {
         picker.parentNode.classList.remove('expanded');
+        picker.ariaExpanded = false;
       }
 
       window.removeEventListener('click', closeAllPickers);
@@ -58,6 +59,7 @@
     for (const picker of pickers) {
       const parentNode = picker.parentNode;
 
+      picker.ariaExpanded = parentNode.classList.contains('expanded');
       picker.addEventListener('click', function(e) {
         e.preventDefault();
 
@@ -65,7 +67,7 @@
           closeAllPickers as window event trigger already closed all the pickers,
           if it already closed there is nothing else to do here
         */
-        if (parentNode.classList.contains('expanded')) {
+        if (picker.ariaExpanded === 'true') {
           return;
         }
 
@@ -75,9 +77,11 @@
         */
 
         requestAnimationFrame(function() {
+          picker.ariaExpanded = true;
           parentNode.classList.add('expanded');
           window.addEventListener('click', closeAllPickers);
           window.addEventListener('keydown', onKeyDown);
+          parentNode.querySelector('.picker a').focus();
         });
       });
     }
diff --git a/doc/api_assets/style.css b/doc/api_assets/style.css
index 28a284e3b975b8..a40990a39252a4 100644
--- a/doc/api_assets/style.css
+++ b/doc/api_assets/style.css
@@ -182,22 +182,15 @@ li.picker-header .picker-arrow {
   height: .6rem;
   border-top: .3rem solid transparent;
   border-bottom: .3rem solid transparent;
-  border-left: .6rem solid var(--color-links);
+  border-left: .6rem solid currentColor;
   border-right: none;
   margin: 0 .2rem .05rem 0;
 }
 
-li.picker-header a:focus .picker-arrow,
-li.picker-header a:active .picker-arrow,
-li.picker-header a:hover .picker-arrow {
-  border-left: .6rem solid var(--white);
-}
-
-li.picker-header.expanded a:focus .picker-arrow,
-li.picker-header.expanded a:active .picker-arrow,
-li.picker-header.expanded a:hover .picker-arrow,
+li.picker-header.expanded .picker-arrow,
+:root:not(.has-js) li.picker-header:focus-within .picker-arrow,
 :root:not(.has-js) li.picker-header:hover .picker-arrow  {
-  border-top: .6rem solid var(--white);
+  border-top: .6rem solid currentColor;
   border-bottom: none;
   border-left: .35rem solid transparent;
   border-right: .35rem solid transparent;
@@ -205,11 +198,13 @@ li.picker-header.expanded a:hover .picker-arrow,
 }
 
 li.picker-header.expanded > a,
+:root:not(.has-js) li.picker-header:focus-within > a,
 :root:not(.has-js) li.picker-header:hover > a {
   border-radius: 2px 2px 0 0;
 }
 
 li.picker-header.expanded > .picker, 
+:root:not(.has-js) li.picker-header:focus-within > .picker,
 :root:not(.has-js) li.picker-header:hover > .picker {
   display: block;
   z-index: 1;
diff --git a/doc/template.html b/doc/template.html
index ab8be0e747f492..51e789b7e6168c 100644
--- a/doc/template.html
+++ b/doc/template.html
@@ -59,13 +59,13 @@ <h1>Node.js __VERSION__ documentation</h1>
             __GTOC_PICKER__
             __ALTDOCS__
             <li class="picker-header">
-              <a href="#">
+              <a href="#options-picker" aria-controls="options-picker">
                 <span class="picker-arrow"></span>
                 Options
               </a>
         
-              <div class="picker">
-                <ul>
+              <div class="picker" tabindex="-1">
+                <ul id="options-picker">
                   <li>
                     <a href="all.html">View on single page</a>
                   </li>
diff --git a/tools/doc/html.mjs b/tools/doc/html.mjs
index 68762d89e048ce..d61d335c7b8957 100644
--- a/tools/doc/html.mjs
+++ b/tools/doc/html.mjs
@@ -527,11 +527,11 @@ function altDocs(filename, docCreated, versions) {
 
   return list ? `
     <li class="picker-header">
-      <a href="#">
+      <a href="#alt-docs" aria-controls="alt-docs">
         <span class="picker-arrow"></span>
         Other versions
       </a>
-      <div class="picker"><ol id="alt-docs">${list}</ol></div>
+      <div class="picker" tabindex="-1"><ol id="alt-docs">${list}</ol></div>
     </li>
   ` : '';
 }
@@ -557,12 +557,12 @@ function gtocPicker(id) {
 
   return `
     <li class="picker-header">
-      <a href="#">
+      <a href="#gtoc-picker" aria-controls="gtoc-picker">
         <span class="picker-arrow"></span>
         Index
       </a>
 
-      <div class="picker">${gtoc}</div>
+      <div class="picker" tabindex="-1" id="gtoc-picker">${gtoc}</div>
     </li>
   `;
 }
@@ -574,12 +574,12 @@ function tocPicker(id, content) {
 
   return `
     <li class="picker-header">
-      <a href="#">
+      <a href="#toc-picker" aria-controls="toc-picker">
         <span class="picker-arrow"></span>
         Table of contents
       </a>
 
-      <div class="picker">${content.tocPicker}</div>
+      <div class="picker" tabindex="-1">${content.tocPicker.replace('<ul', '<ul id="toc-picker"')}</div>
     </li>
   `;
 }

From f1196ee3bbd115dbf0937c3a48c7b47da0274e34 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Sun, 26 Jan 2025 19:41:45 +0100
Subject: [PATCH 28/38] doc: add "Skip to content" button
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

PR-URL: https://github.com/nodejs/node/pull/56750
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Ulises Gascón <ulisesgascongonzalez@gmail.com>
Reviewed-By: Claudio Wunder <cwunder@gnome.org>
---
 doc/api_assets/style.css | 13 +++++++++++++
 doc/template.html        |  1 +
 2 files changed, 14 insertions(+)

diff --git a/doc/api_assets/style.css b/doc/api_assets/style.css
index a40990a39252a4..35c216bb0523fc 100644
--- a/doc/api_assets/style.css
+++ b/doc/api_assets/style.css
@@ -122,6 +122,19 @@ a.type {
   font-size: .9em;
 }
 
+.skip-to-content {
+  position: fixed;
+  top: -300%;
+}
+.skip-to-content:focus {
+  display: block;
+  top: 0;
+  left: 0;
+  background-color: var(--green1);
+  padding: 1rem;
+  z-index: 999999;
+}
+
 #content {
   position: relative;
 }
diff --git a/doc/template.html b/doc/template.html
index 51e789b7e6168c..34edf068df5c8d 100644
--- a/doc/template.html
+++ b/doc/template.html
@@ -26,6 +26,7 @@
   __JS_FLAVORED_DYNAMIC_CSS__
 </head>
 <body class="alt apidoc" id="api-section-__FILENAME__">
+  <a href="#apicontent" class="skip-to-content">Skip to content</a>
   <div id="content" class="clearfix">
     <div role="navigation" id="column2" class="interior">
       <div id="intro" class="interior">

From e1e1ada807051ea9088e8542c0753c3c5b9cd21b Mon Sep 17 00:00:00 2001
From: Cheng <git@zcbenz.com>
Date: Mon, 27 Jan 2025 07:12:33 +0900
Subject: [PATCH 29/38] deps: macro ENODATA is deprecated in libc++

PR-URL: https://github.com/nodejs/node/pull/56698
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Chengzhong Wu <legendecas@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
---
 deps/uv/unofficial.gni | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/deps/uv/unofficial.gni b/deps/uv/unofficial.gni
index 7a73f891e3fc32..348d2f0703e47c 100644
--- a/deps/uv/unofficial.gni
+++ b/deps/uv/unofficial.gni
@@ -7,6 +7,11 @@
 template("uv_gn_build") {
   config("uv_external_config") {
     include_dirs = [ "include" ]
+    if (is_clang || !is_win) {
+      cflags_cc = [
+        "-Wno-deprecated-pragma",  # for using ENODATA in errno.h
+      ]
+    }
   }
 
   config("uv_internal_config") {

From 43daa9b217934f2cd01d328a8e5563a64d96cdd3 Mon Sep 17 00:00:00 2001
From: Antoine du Hamel <duhamelantoine1995@gmail.com>
Date: Sun, 26 Jan 2025 23:24:29 +0100
Subject: [PATCH 30/38] doc: fix styles of the expandable TOC
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

PR-URL: https://github.com/nodejs/node/pull/56755
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Ulises Gascón <ulisesgascongonzalez@gmail.com>
Reviewed-By: Claudio Wunder <cwunder@gnome.org>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
---
 doc/api_assets/style.css | 36 ++++++++++++------------------------
 1 file changed, 12 insertions(+), 24 deletions(-)

diff --git a/doc/api_assets/style.css b/doc/api_assets/style.css
index 35c216bb0523fc..9f56028d09162c 100644
--- a/doc/api_assets/style.css
+++ b/doc/api_assets/style.css
@@ -570,40 +570,28 @@ hr {
 }
 
 .toc ul {
-  margin: 0
+  margin: 0;
 }
-
-.toc li a::before {
-  content: "■";
-  color: var(--color-text-primary);
-  padding-right: 1em;
-  font-size: 0.9em;
+.toc>ul:first-child {
+  margin-left: 1rem;
+}
+.toc li {
+  display: list-item;
+  list-style: square;
+}
+.toc li a {
+  display: inline;
+  padding-left: 0;
 }
 
 .toc li a:hover::before {
   color: var(--white);
 }
 
-.toc ul ul a {
+.toc ul {
   padding-left: 1rem;
 }
 
-.toc ul ul ul a {
-  padding-left: 2rem;
-}
-
-.toc ul ul ul ul a {
-  padding-left: 3rem;
-}
-
-.toc ul ul ul ul ul a {
-  padding-left: 4rem;
-}
-
-.toc ul ul ul ul ul ul a {
-  padding-left: 5rem;
-}
-
 #toc .stability_0::after,
 .deprecated-inline::after {
   background-color: var(--red2);

From 6d22fceb3651ba837e58806ad1cc3c40974abcb7 Mon Sep 17 00:00:00 2001
From: Chengzhong Wu <cwu631@bloomberg.net>
Date: Wed, 15 Jan 2025 10:11:02 +0000
Subject: [PATCH 31/38] tools: update inspector_protocol roller

Fix the inspector_protocol/roll.py to fit node source directory
structure.

`roll.py` reads the `deps/v8/thrid_party/inspector_protocol/README.v8`
to get the revision of the inspector_protocol that V8 depends on, and
updates the local version to match.

V8's copy of inspector_protocol modifies the namespace of `crdtp`
library and does not export the symbols. So it can not be used outside
of V8.

PR-URL: https://github.com/nodejs/node/pull/56649
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
---
 tools/inspector_protocol/roll.py | 82 +++++++++++++++++---------------
 1 file changed, 43 insertions(+), 39 deletions(-)

diff --git a/tools/inspector_protocol/roll.py b/tools/inspector_protocol/roll.py
index abe636e270b7cf..a2bbd5d3f69336 100644
--- a/tools/inspector_protocol/roll.py
+++ b/tools/inspector_protocol/roll.py
@@ -18,9 +18,7 @@
     'code_generator.py',
     'concatenate_protocols.py',
     'convert_protocol_to_json.py',
-    'encoding/encoding.h',
-    'encoding/encoding.cc',
-    'encoding/encoding_test.cc',
+    'crdtp/*',
     'inspector_protocol.gni',
     'inspector_protocol.gypi',
     'lib/*',
@@ -28,13 +26,14 @@
     'templates/*',
 ]
 
+REVISION_LINE_PREFIX = 'Revision: '
 
 def RunCmd(cmd):
   p = subprocess.Popen(cmd, stdout=subprocess.PIPE)
   (stdoutdata, stderrdata) = p.communicate()
   if p.returncode != 0:
     raise Exception('%s: exit status %d', str(cmd), p.returncode)
-  return stdoutdata
+  return stdoutdata.decode('utf-8')
 
 
 def CheckRepoIsClean(path, suffix):
@@ -48,25 +47,18 @@ def CheckRepoIsClean(path, suffix):
     raise Exception('%s does not end with /%s' % (path, suffix))
 
 
-def CheckRepoIsNotAtMasterBranch(path):
+def CheckRepoIsNotAtMainBranch(path):
   os.chdir(path)
   stdout = RunCmd(['git', 'rev-parse', '--abbrev-ref', 'HEAD']).strip()
-  if stdout == 'master':
-    raise Exception('%s is at master branch - refusing to copy there.' % path)
-
-
-def CheckRepoIsV8Checkout(path):
-  os.chdir(path)
-  if (RunCmd(['git', 'config', '--get', 'remote.origin.url']).strip() !=
-      'https://chromium.googlesource.com/v8/v8.git'):
-    raise Exception('%s is not a proper V8 checkout.' % path)
+  if stdout == 'main':
+    raise Exception('%s is at main branch - refusing to copy there.' % path)
 
 
 def CheckRepoIsInspectorProtocolCheckout(path):
   os.chdir(path)
-  if (RunCmd(['git', 'config', '--get', 'remote.origin.url']).strip() !=
-      'https://chromium.googlesource.com/deps/inspector_protocol.git'):
-    raise Exception('%s is not a proper inspector_protocol checkout.' % path)
+  revision = RunCmd(['git', 'config', '--get', 'remote.origin.url']).strip()
+  if (revision != 'https://chromium.googlesource.com/deps/inspector_protocol.git'):
+    raise Exception('%s is not a proper inspector_protocol checkout: %s' % (path, revision))
 
 
 def FindFilesToSyncIn(path):
@@ -83,6 +75,19 @@ def FilesAreEqual(path1, path2):
           open(path1).read() == open(path2).read())
 
 
+def ReadV8IPRevision(node_src_path):
+  lines = open(os.path.join(node_src_path, 'deps/v8/third_party/inspector_protocol/README.v8')).readlines()
+  for line in lines:
+    line = line.strip()
+    if line.startswith(REVISION_LINE_PREFIX):
+      return line[len(REVISION_LINE_PREFIX):]
+  raise Exception('No V8 inspector protocol revision found')
+
+def CheckoutRevision(path, revision):
+  os.chdir(path)
+  return RunCmd(['git', 'checkout', revision])
+
+
 def GetHeadRevision(path):
   os.chdir(path)
   return RunCmd(['git', 'rev-parse', 'HEAD'])
@@ -90,14 +95,14 @@ def GetHeadRevision(path):
 
 def main(argv):
   parser = argparse.ArgumentParser(description=(
-      "Rolls the inspector_protocol project (upstream) into V8's "
-      "third_party (downstream)."))
+      "Rolls the inspector_protocol project (upstream) into node's "
+      "tools/inspector_protocol (downstream)."))
   parser.add_argument("--ip_src_upstream",
                       help="The inspector_protocol (upstream) tree.",
                       default="~/ip/src")
-  parser.add_argument("--v8_src_downstream",
-                      help="The V8 src tree.",
-                      default="~/v8/v8")
+  parser.add_argument("--node_src_downstream",
+                      help="The nodejs/node src tree.",
+                      default="~/nodejs/node")
   parser.add_argument('--force', dest='force', action='store_true',
                       help=("Whether to carry out the modifications "
                             "in the destination tree."))
@@ -106,17 +111,22 @@ def main(argv):
   args = parser.parse_args(argv)
   upstream = os.path.normpath(os.path.expanduser(args.ip_src_upstream))
   downstream = os.path.normpath(os.path.expanduser(
-      args.v8_src_downstream))
+      args.node_src_downstream))
   CheckRepoIsClean(upstream, '/src')
-  CheckRepoIsClean(downstream, '/v8')
+  CheckRepoIsClean(downstream, '/node')
   CheckRepoIsInspectorProtocolCheckout(upstream)
-  CheckRepoIsV8Checkout(downstream)
-  # Check that the destination Git repo isn't at the master branch - it's
-  # generally a bad idea to check into the master branch, so we catch this
+  # Check that the destination Git repo isn't at the main branch - it's
+  # generally a bad idea to check into the main branch, so we catch this
   # common pilot error here early.
-  CheckRepoIsNotAtMasterBranch(downstream)
+  CheckRepoIsNotAtMainBranch(downstream)
+
+  # Read V8's inspector_protocol revision
+  v8_ip_revision = ReadV8IPRevision(downstream)
+  print('Checking out %s into %s ...' % (upstream, v8_ip_revision))
+  CheckoutRevision(upstream, v8_ip_revision)
+
   src_dir = upstream
-  dest_dir = os.path.join(downstream, 'third_party/inspector_protocol')
+  dest_dir = os.path.join(downstream, 'tools/inspector_protocol')
   print('Rolling %s into %s ...' % (src_dir, dest_dir))
   src_files = set(FindFilesToSyncIn(src_dir))
   dest_files = set(FindFilesToSyncIn(dest_dir))
@@ -137,22 +147,16 @@ def main(argv):
   print('You said --force ... as you wish, modifying the destination.')
   for f in to_add + to_copy:
     contents = open(os.path.join(src_dir, f)).read()
-    contents = contents.replace(
-        'INSPECTOR_PROTOCOL_ENCODING_ENCODING_H_',
-        'V8_INSPECTOR_PROTOCOL_ENCODING_ENCODING_H_')
-    contents = contents.replace(
-        'namespace inspector_protocol_encoding',
-        'namespace v8_inspector_protocol_encoding')
     open(os.path.join(dest_dir, f), 'w').write(contents)
     shutil.copymode(os.path.join(src_dir, f), os.path.join(dest_dir, f))
   for f in to_delete:
     os.unlink(os.path.join(dest_dir, f))
   head_revision = GetHeadRevision(upstream)
-  lines = open(os.path.join(dest_dir, 'README.v8')).readlines()
-  f = open(os.path.join(dest_dir, 'README.v8'), 'w')
+  lines = open(os.path.join(dest_dir, 'README.node')).readlines()
+  f = open(os.path.join(dest_dir, 'README.node'), 'w')
   for line in lines:
-    if line.startswith('Revision: '):
-      f.write('Revision: %s' % head_revision)
+    if line.startswith(REVISION_LINE_PREFIX):
+      f.write(f'{REVISION_LINE_PREFIX}{head_revision}')
     else:
       f.write(line)
   f.close()

From 744c2f507b6976ee615357286efd7b343da72e05 Mon Sep 17 00:00:00 2001
From: Chengzhong Wu <cwu631@bloomberg.net>
Date: Wed, 15 Jan 2025 10:37:52 +0000
Subject: [PATCH 32/38] inspector: roll inspector_protocol

Roll the inspector_protocol library to match V8's inspector_protocol
revision.

Update the node inspector to use the new `crdtp` protocol library.

PR-URL: https://github.com/nodejs/node/pull/56649
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
---
 src/inspector/network_agent.cc                |   12 +-
 src/inspector/node_inspector.gypi             |   42 +-
 src/inspector/node_json.cc                    |  190 ++
 src/inspector/node_json.h                     |   24 +
 src/inspector/node_protocol_config.json       |    5 +-
 src/inspector/node_string.cc                  |  128 +-
 src/inspector/node_string.h                   |   91 +-
 src/inspector/runtime_agent.cc                |    6 +-
 src/inspector/tracing_agent.cc                |   25 +-
 src/inspector/worker_agent.cc                 |   10 +-
 src/inspector_agent.cc                        |   78 +-
 tools/inspector_protocol/README.md            |   19 +-
 tools/inspector_protocol/README.node          |    2 +-
 .../check_protocol_compatibility.py           |   32 +-
 tools/inspector_protocol/code_generator.py    | 1233 ++++-----
 .../concatenate_protocols.py                  |   51 +-
 .../convert_protocol_to_json.py               |   22 +-
 tools/inspector_protocol/crdtp/README.md      |  114 +
 tools/inspector_protocol/crdtp/cbor.cc        | 1078 ++++++++
 tools/inspector_protocol/crdtp/cbor.h         |  329 +++
 tools/inspector_protocol/crdtp/cbor_test.cc   | 1449 +++++++++++
 tools/inspector_protocol/crdtp/dispatch.cc    |  584 +++++
 tools/inspector_protocol/crdtp/dispatch.h     |  313 +++
 .../inspector_protocol/crdtp/dispatch_test.cc |  442 ++++
 .../inspector_protocol/crdtp/error_support.cc |   59 +
 .../inspector_protocol/crdtp/error_support.h  |   62 +
 .../crdtp/error_support_test.cc               |   45 +
 tools/inspector_protocol/crdtp/export.h       |   29 +
 .../inspector_protocol/crdtp/find_by_first.h  |   58 +
 .../crdtp/find_by_first_test.cc               |   76 +
 .../crdtp/frontend_channel.h                  |   47 +
 tools/inspector_protocol/crdtp/json.cc        | 1037 ++++++++
 tools/inspector_protocol/crdtp/json.h         |   57 +
 .../inspector_protocol/crdtp/json_platform.cc |   33 +
 .../inspector_protocol/crdtp/json_platform.h  |   26 +
 tools/inspector_protocol/crdtp/json_test.cc   |  753 ++++++
 tools/inspector_protocol/crdtp/maybe.h        |  154 ++
 tools/inspector_protocol/crdtp/maybe_test.cc  |   44 +
 .../inspector_protocol/crdtp/parser_handler.h |   39 +
 .../inspector_protocol/crdtp/protocol_core.cc |  289 +++
 .../inspector_protocol/crdtp/protocol_core.h  |  418 ++++
 .../crdtp/protocol_core_test.cc               |  476 ++++
 .../inspector_protocol/crdtp/serializable.cc  |   39 +
 tools/inspector_protocol/crdtp/serializable.h |   32 +
 .../crdtp/serializable_test.cc                |   40 +
 tools/inspector_protocol/crdtp/span.cc        |   39 +
 tools/inspector_protocol/crdtp/span.h         |  100 +
 tools/inspector_protocol/crdtp/span_test.cc   |  109 +
 tools/inspector_protocol/crdtp/status.cc      |  130 +
 tools/inspector_protocol/crdtp/status.h       |  143 ++
 tools/inspector_protocol/crdtp/status_test.cc |   29 +
 .../crdtp/status_test_support.cc              |   50 +
 .../crdtp/status_test_support.h               |   32 +
 .../inspector_protocol/crdtp/test_platform.cc |   33 +
 .../inspector_protocol/crdtp/test_platform.h  |   31 +
 .../crdtp/test_string_traits.cc               |   31 +
 .../crdtp/test_string_traits.h                |   21 +
 tools/inspector_protocol/crdtp/transcode.cc   |   61 +
 .../inspector_protocol/inspector_protocol.gni |   50 +-
 .../inspector_protocol.gypi                   |   33 -
 .../lib/Allocator_h.template                  |   23 -
 .../lib/DispatcherBase_cpp.template           |  353 ---
 .../lib/DispatcherBase_h.template             |  185 --
 .../lib/ErrorSupport_cpp.template             |   73 -
 .../lib/ErrorSupport_h.template               |   39 -
 .../inspector_protocol/lib/Forward_h.template |   49 +-
 .../lib/FrontendChannel_h.template            |   40 -
 tools/inspector_protocol/lib/Maybe_h.template |   77 -
 .../lib/Object_cpp.template                   |    9 +-
 .../inspector_protocol/lib/Object_h.template  |   13 +-
 .../lib/Parser_cpp.template                   |  548 ----
 .../inspector_protocol/lib/Parser_h.template  |   24 -
 .../lib/Protocol_cpp.template                 |    2 +-
 .../lib/ValueConversions_cpp.template         |  127 +
 .../lib/ValueConversions_h.template           |   93 +-
 .../lib/Values_cpp.template                   |  507 ++--
 .../inspector_protocol/lib/Values_h.template  |   72 +-
 .../lib/base_string_adapter_cc.template       |  230 --
 .../lib/base_string_adapter_h.template        |  142 --
 .../lib/encoding_cpp.template                 | 2203 -----------------
 .../lib/encoding_h.template                   |  552 -----
 tools/inspector_protocol/pdl.py               |  300 +--
 .../templates/Exported_h.template             |    7 +-
 .../templates/Imported_h.template             |   70 +-
 .../templates/TypeBuilder_cpp.template        |  339 ++-
 .../templates/TypeBuilder_h.template          |   49 +-
 86 files changed, 10879 insertions(+), 6231 deletions(-)
 create mode 100644 src/inspector/node_json.cc
 create mode 100644 src/inspector/node_json.h
 create mode 100644 tools/inspector_protocol/crdtp/README.md
 create mode 100644 tools/inspector_protocol/crdtp/cbor.cc
 create mode 100644 tools/inspector_protocol/crdtp/cbor.h
 create mode 100644 tools/inspector_protocol/crdtp/cbor_test.cc
 create mode 100644 tools/inspector_protocol/crdtp/dispatch.cc
 create mode 100644 tools/inspector_protocol/crdtp/dispatch.h
 create mode 100644 tools/inspector_protocol/crdtp/dispatch_test.cc
 create mode 100644 tools/inspector_protocol/crdtp/error_support.cc
 create mode 100644 tools/inspector_protocol/crdtp/error_support.h
 create mode 100644 tools/inspector_protocol/crdtp/error_support_test.cc
 create mode 100644 tools/inspector_protocol/crdtp/export.h
 create mode 100644 tools/inspector_protocol/crdtp/find_by_first.h
 create mode 100644 tools/inspector_protocol/crdtp/find_by_first_test.cc
 create mode 100644 tools/inspector_protocol/crdtp/frontend_channel.h
 create mode 100644 tools/inspector_protocol/crdtp/json.cc
 create mode 100644 tools/inspector_protocol/crdtp/json.h
 create mode 100644 tools/inspector_protocol/crdtp/json_platform.cc
 create mode 100644 tools/inspector_protocol/crdtp/json_platform.h
 create mode 100644 tools/inspector_protocol/crdtp/json_test.cc
 create mode 100644 tools/inspector_protocol/crdtp/maybe.h
 create mode 100644 tools/inspector_protocol/crdtp/maybe_test.cc
 create mode 100644 tools/inspector_protocol/crdtp/parser_handler.h
 create mode 100644 tools/inspector_protocol/crdtp/protocol_core.cc
 create mode 100644 tools/inspector_protocol/crdtp/protocol_core.h
 create mode 100644 tools/inspector_protocol/crdtp/protocol_core_test.cc
 create mode 100644 tools/inspector_protocol/crdtp/serializable.cc
 create mode 100644 tools/inspector_protocol/crdtp/serializable.h
 create mode 100644 tools/inspector_protocol/crdtp/serializable_test.cc
 create mode 100644 tools/inspector_protocol/crdtp/span.cc
 create mode 100644 tools/inspector_protocol/crdtp/span.h
 create mode 100644 tools/inspector_protocol/crdtp/span_test.cc
 create mode 100644 tools/inspector_protocol/crdtp/status.cc
 create mode 100644 tools/inspector_protocol/crdtp/status.h
 create mode 100644 tools/inspector_protocol/crdtp/status_test.cc
 create mode 100644 tools/inspector_protocol/crdtp/status_test_support.cc
 create mode 100644 tools/inspector_protocol/crdtp/status_test_support.h
 create mode 100644 tools/inspector_protocol/crdtp/test_platform.cc
 create mode 100644 tools/inspector_protocol/crdtp/test_platform.h
 create mode 100644 tools/inspector_protocol/crdtp/test_string_traits.cc
 create mode 100644 tools/inspector_protocol/crdtp/test_string_traits.h
 create mode 100644 tools/inspector_protocol/crdtp/transcode.cc
 delete mode 100644 tools/inspector_protocol/inspector_protocol.gypi
 delete mode 100644 tools/inspector_protocol/lib/Allocator_h.template
 delete mode 100644 tools/inspector_protocol/lib/DispatcherBase_cpp.template
 delete mode 100644 tools/inspector_protocol/lib/DispatcherBase_h.template
 delete mode 100644 tools/inspector_protocol/lib/ErrorSupport_cpp.template
 delete mode 100644 tools/inspector_protocol/lib/ErrorSupport_h.template
 delete mode 100644 tools/inspector_protocol/lib/FrontendChannel_h.template
 delete mode 100644 tools/inspector_protocol/lib/Maybe_h.template
 delete mode 100644 tools/inspector_protocol/lib/Parser_cpp.template
 delete mode 100644 tools/inspector_protocol/lib/Parser_h.template
 create mode 100644 tools/inspector_protocol/lib/ValueConversions_cpp.template
 delete mode 100644 tools/inspector_protocol/lib/base_string_adapter_cc.template
 delete mode 100644 tools/inspector_protocol/lib/base_string_adapter_h.template
 delete mode 100644 tools/inspector_protocol/lib/encoding_cpp.template
 delete mode 100644 tools/inspector_protocol/lib/encoding_h.template

diff --git a/src/inspector/network_agent.cc b/src/inspector/network_agent.cc
index f8b42b29158572..68a1bd4198fde4 100644
--- a/src/inspector/network_agent.cc
+++ b/src/inspector/network_agent.cc
@@ -53,12 +53,12 @@ void NetworkAgent::Wire(UberDispatcher* dispatcher) {
 
 DispatchResponse NetworkAgent::enable() {
   inspector_->Enable();
-  return DispatchResponse::OK();
+  return DispatchResponse::Success();
 }
 
 DispatchResponse NetworkAgent::disable() {
   inspector_->Disable();
-  return DispatchResponse::OK();
+  return DispatchResponse::Success();
 }
 
 void NetworkAgent::requestWillBeSent(
@@ -76,9 +76,11 @@ void NetworkAgent::requestWillBeSent(
   request->getString("method", &method);
 
   ErrorSupport errors;
+  errors.Push();
+  errors.SetName("headers");
   auto headers =
       Network::Headers::fromValue(request->getObject("headers"), &errors);
-  if (errors.hasErrors()) {
+  if (!errors.Errors().empty()) {
     headers = std::make_unique<Network::Headers>(DictionaryValue::create());
   }
 
@@ -105,9 +107,11 @@ void NetworkAgent::responseReceived(
   response->getString("statusText", &statusText);
 
   ErrorSupport errors;
+  errors.Push();
+  errors.SetName("headers");
   auto headers =
       Network::Headers::fromValue(response->getObject("headers"), &errors);
-  if (errors.hasErrors()) {
+  if (!errors.Errors().empty()) {
     headers = std::make_unique<Network::Headers>(DictionaryValue::create());
   }
 
diff --git a/src/inspector/node_inspector.gypi b/src/inspector/node_inspector.gypi
index d559004be80944..6e5d872c36836c 100644
--- a/src/inspector/node_inspector.gypi
+++ b/src/inspector/node_inspector.gypi
@@ -15,6 +15,8 @@
       'src/inspector_socket_server.h',
       'src/inspector/main_thread_interface.cc',
       'src/inspector/main_thread_interface.h',
+      'src/inspector/node_json.cc',
+      'src/inspector/node_json.h',
       'src/inspector/node_string.cc',
       'src/inspector/node_string.h',
       'src/inspector/runtime_agent.cc',
@@ -29,6 +31,30 @@
       'src/inspector/network_agent.h',
       'src/inspector/worker_inspector.cc',
       'src/inspector/worker_inspector.h',
+
+      '<(protocol_tool_path)/crdtp/cbor.cc',
+      '<(protocol_tool_path)/crdtp/cbor.h',
+      '<(protocol_tool_path)/crdtp/dispatch.cc',
+      '<(protocol_tool_path)/crdtp/dispatch.h',
+      '<(protocol_tool_path)/crdtp/error_support.cc',
+      '<(protocol_tool_path)/crdtp/error_support.h',
+      '<(protocol_tool_path)/crdtp/export.h',
+      '<(protocol_tool_path)/crdtp/find_by_first.h',
+      '<(protocol_tool_path)/crdtp/frontend_channel.h',
+      '<(protocol_tool_path)/crdtp/json.cc',
+      '<(protocol_tool_path)/crdtp/json.h',
+      '<(protocol_tool_path)/crdtp/json_platform.cc',
+      '<(protocol_tool_path)/crdtp/json_platform.h',
+      '<(protocol_tool_path)/crdtp/maybe.h',
+      '<(protocol_tool_path)/crdtp/parser_handler.h',
+      '<(protocol_tool_path)/crdtp/protocol_core.cc',
+      '<(protocol_tool_path)/crdtp/protocol_core.h',
+      '<(protocol_tool_path)/crdtp/serializable.cc',
+      '<(protocol_tool_path)/crdtp/serializable.h',
+      '<(protocol_tool_path)/crdtp/span.cc',
+      '<(protocol_tool_path)/crdtp/span.h',
+      '<(protocol_tool_path)/crdtp/status.cc',
+      '<(protocol_tool_path)/crdtp/status.h',
     ],
     'node_inspector_generated_sources': [
       '<(SHARED_INTERMEDIATE_DIR)/src/node/inspector/protocol/Forward.h',
@@ -44,23 +70,11 @@
       '<(SHARED_INTERMEDIATE_DIR)/src/node/inspector/protocol/Network.h',
     ],
     'node_protocol_files': [
-      '<(protocol_tool_path)/lib/Allocator_h.template',
-      '<(protocol_tool_path)/lib/base_string_adapter_cc.template',
-      '<(protocol_tool_path)/lib/base_string_adapter_h.template',
-      '<(protocol_tool_path)/lib/DispatcherBase_cpp.template',
-      '<(protocol_tool_path)/lib/DispatcherBase_h.template',
-      '<(protocol_tool_path)/lib/encoding_cpp.template',
-      '<(protocol_tool_path)/lib/encoding_h.template',
-      '<(protocol_tool_path)/lib/ErrorSupport_cpp.template',
-      '<(protocol_tool_path)/lib/ErrorSupport_h.template',
       '<(protocol_tool_path)/lib/Forward_h.template',
-      '<(protocol_tool_path)/lib/FrontendChannel_h.template',
-      '<(protocol_tool_path)/lib/Maybe_h.template',
       '<(protocol_tool_path)/lib/Object_cpp.template',
       '<(protocol_tool_path)/lib/Object_h.template',
-      '<(protocol_tool_path)/lib/Parser_cpp.template',
-      '<(protocol_tool_path)/lib/Parser_h.template',
       '<(protocol_tool_path)/lib/Protocol_cpp.template',
+      '<(protocol_tool_path)/lib/ValueConversions_cpp.template',
       '<(protocol_tool_path)/lib/ValueConversions_h.template',
       '<(protocol_tool_path)/lib/Values_cpp.template',
       '<(protocol_tool_path)/lib/Values_h.template',
@@ -77,6 +91,7 @@
     '<@(node_inspector_sources)',
   ],
   'include_dirs': [
+    '<(protocol_tool_path)',
     '<(SHARED_INTERMEDIATE_DIR)/include', # for inspector
     '<(SHARED_INTERMEDIATE_DIR)',
     '<(SHARED_INTERMEDIATE_DIR)/src', # for inspector
@@ -112,6 +127,7 @@
       'action': [
         '<(python)',
         'tools/inspector_protocol/code_generator.py',
+        '--inspector_protocol_dir', 'tools/inspector_protocol/',
         '--jinja_dir', '<@(protocol_tool_path)',
         '--output_base', '<(SHARED_INTERMEDIATE_DIR)/src/',
         '--config', 'src/inspector/node_protocol_config.json',
diff --git a/src/inspector/node_json.cc b/src/inspector/node_json.cc
new file mode 100644
index 00000000000000..d8aacbdf1a8fc8
--- /dev/null
+++ b/src/inspector/node_json.cc
@@ -0,0 +1,190 @@
+#include "node_json.h"
+
+#include "crdtp/json.h"
+
+namespace node {
+namespace inspector {
+
+using crdtp::ParserHandler;
+using crdtp::span;
+using crdtp::Status;
+using protocol::Binary;
+using protocol::BinaryValue;
+using protocol::DictionaryValue;
+using protocol::FundamentalValue;
+using protocol::ListValue;
+using protocol::String;
+using protocol::StringUtil;
+using protocol::StringValue;
+using protocol::Value;
+
+namespace {
+
+// Uses the parsing events received from driver of `ParserHandler`
+// (e.g. crdtp::json::ParseJSON) into a protocol::Value instance.
+class ValueParserHandler : public ParserHandler {
+ public:
+  // Provides the parsed protocol::Value.
+  std::unique_ptr<Value> ReleaseRoot() { return std::move(root_); }
+
+  // The first parsing error encountered; `status().ok()` is the default.
+  Status status() const { return status_; }
+
+ private:
+  // Implementation of `ParserHandler`.
+  void HandleMapBegin() override {
+    if (!status_.ok()) return;
+    std::unique_ptr<DictionaryValue> dict = DictionaryValue::create();
+    DictionaryValue* dict_ptr = dict.get();
+    AddValueToParent(std::move(dict));
+    stack_.emplace_back(dict_ptr);
+  }
+
+  void HandleMapEnd() override {
+    if (!status_.ok()) return;
+    DCHECK(!stack_.empty());
+    DCHECK(stack_.back().is_dict);
+    stack_.pop_back();
+  }
+
+  void HandleArrayBegin() override {
+    if (!status_.ok()) return;
+    std::unique_ptr<ListValue> list = ListValue::create();
+    ListValue* list_ptr = list.get();
+    AddValueToParent(std::move(list));
+    stack_.emplace_back(list_ptr);
+  }
+
+  void HandleArrayEnd() override {
+    if (!status_.ok()) return;
+    DCHECK(!stack_.empty());
+    DCHECK(!stack_.back().is_dict);
+    stack_.pop_back();
+  }
+
+  void HandleString8(span<uint8_t> chars) override {
+    AddStringToParent(StringUtil::fromUTF8(chars.data(), chars.size()));
+  }
+
+  void HandleString16(span<uint16_t> chars) override {
+    AddStringToParent(StringUtil::fromUTF16(chars.data(), chars.size()));
+  }
+
+  void HandleBinary(span<uint8_t> bytes) override {
+    AddValueToParent(
+        BinaryValue::create(Binary::fromSpan(bytes.data(), bytes.size())));
+  }
+
+  void HandleDouble(double value) override {
+    AddValueToParent(FundamentalValue::create(value));
+  }
+
+  void HandleInt32(int32_t value) override {
+    AddValueToParent(FundamentalValue::create(value));
+  }
+
+  void HandleBool(bool value) override {
+    AddValueToParent(FundamentalValue::create(value));
+  }
+
+  void HandleNull() override { AddValueToParent(Value::null()); }
+
+  void HandleError(Status error) override { status_ = error; }
+
+  // Adding strings and values to the parent value.
+  // Strings are handled separately because they can be keys for
+  // dictionary values.
+  void AddStringToParent(String str) {
+    if (!status_.ok()) return;
+    if (!root_) {
+      DCHECK(!key_is_pending_);
+      root_ = StringValue::create(str);
+    } else if (stack_.back().is_dict) {
+      // If we already have a pending key, then this is the value of the
+      // key/value pair. Otherwise, it's the new pending key.
+      if (key_is_pending_) {
+        stack_.back().dict->setString(pending_key_, str);
+        key_is_pending_ = false;
+      } else {
+        pending_key_ = std::move(str);
+        key_is_pending_ = true;
+      }
+    } else {  // Top of the stack is a list.
+      DCHECK(!key_is_pending_);
+      stack_.back().list->pushValue(StringValue::create(str));
+    }
+  }
+
+  void AddValueToParent(std::unique_ptr<Value> value) {
+    if (!status_.ok()) return;
+    if (!root_) {
+      DCHECK(!key_is_pending_);
+      root_ = std::move(value);
+    } else if (stack_.back().is_dict) {
+      DCHECK(key_is_pending_);
+      stack_.back().dict->setValue(pending_key_, std::move(value));
+      key_is_pending_ = false;
+    } else {  // Top of the stack is a list.
+      DCHECK(!key_is_pending_);
+      stack_.back().list->pushValue(std::move(value));
+    }
+  }
+
+  // `status_.ok()` is the default; if we receive an error event
+  // we keep the first one and stop modifying any other state.
+  Status status_;
+
+  // The root of the parsed protocol::Value tree.
+  std::unique_ptr<Value> root_;
+
+  // If root_ is a list or a dictionary, this stack keeps track of
+  // the container we're currently parsing as well as its ancestors.
+  struct ContainerState {
+    explicit ContainerState(DictionaryValue* dict)
+        : is_dict(true), dict(dict) {}
+    explicit ContainerState(ListValue* list) : is_dict(false), list(list) {}
+
+    bool is_dict;
+    union {
+      DictionaryValue* dict;
+      ListValue* list;
+    };
+  };
+  std::vector<ContainerState> stack_;
+
+  // For maps, keys and values are alternating events, so we keep the
+  // key around and process it when the value arrives.
+  bool key_is_pending_ = false;
+  String pending_key_;
+};
+}  // anonymous namespace
+
+std::unique_ptr<Value> JsonUtil::ParseJSON(const uint8_t* chars, size_t size) {
+  ValueParserHandler handler;
+  crdtp::json::ParseJSON(span<uint8_t>(chars, size), &handler);
+  if (handler.status().ok()) return handler.ReleaseRoot();
+  return nullptr;
+}
+
+std::unique_ptr<Value> JsonUtil::ParseJSON(const uint16_t* chars, size_t size) {
+  ValueParserHandler handler;
+  crdtp::json::ParseJSON(span<uint16_t>(chars, size), &handler);
+  if (handler.status().ok()) return handler.ReleaseRoot();
+  return nullptr;
+}
+
+std::unique_ptr<Value> JsonUtil::parseJSON(const std::string_view string) {
+  if (string.empty()) return nullptr;
+
+  return ParseJSON(reinterpret_cast<const uint8_t*>(string.data()),
+                   string.size());
+}
+
+std::unique_ptr<Value> JsonUtil::parseJSON(v8_inspector::StringView string) {
+  if (string.length() == 0) return nullptr;
+  if (string.is8Bit()) return ParseJSON(string.characters8(), string.length());
+  return ParseJSON(string.characters16(), string.length());
+}
+
+}  // namespace inspector
+}  // namespace node
diff --git a/src/inspector/node_json.h b/src/inspector/node_json.h
new file mode 100644
index 00000000000000..88bc705fa288d2
--- /dev/null
+++ b/src/inspector/node_json.h
@@ -0,0 +1,24 @@
+#ifndef SRC_INSPECTOR_NODE_JSON_H_
+#define SRC_INSPECTOR_NODE_JSON_H_
+
+#include "node/inspector/protocol/Protocol.h"
+
+namespace node {
+namespace inspector {
+
+struct JsonUtil {
+  // Parse s JSON string into protocol::Value.
+  static std::unique_ptr<protocol::Value> ParseJSON(const uint8_t* chars,
+                                                    size_t size);
+  static std::unique_ptr<protocol::Value> ParseJSON(const uint16_t* chars,
+                                                    size_t size);
+
+  static std::unique_ptr<protocol::Value> parseJSON(const std::string_view);
+  static std::unique_ptr<protocol::Value> parseJSON(
+      v8_inspector::StringView view);
+};
+
+}  // namespace inspector
+}  // namespace node
+
+#endif  // SRC_INSPECTOR_NODE_JSON_H_
diff --git a/src/inspector/node_protocol_config.json b/src/inspector/node_protocol_config.json
index 4ef37856068093..959a1f4eb1b67a 100644
--- a/src/inspector/node_protocol_config.json
+++ b/src/inspector/node_protocol_config.json
@@ -1,6 +1,6 @@
 {
     "protocol": {
-        "path": "node_protocol.json",
+        "path": "node_protocol.pdl",
         "package": "src/node/inspector/protocol",
         "output": "node/inspector/protocol",
         "namespace": ["node", "inspector", "protocol"]
@@ -18,5 +18,8 @@
         "package": "src/node/inspector/protocol",
         "output": "node/inspector/protocol",
         "string_header": "inspector/node_string.h"
+    },
+    "crdtp": {
+      "dir": "crdtp"
     }
 }
diff --git a/src/inspector/node_string.cc b/src/inspector/node_string.cc
index c62e7ed30c4e19..d83c53c81ca774 100644
--- a/src/inspector/node_string.cc
+++ b/src/inspector/node_string.cc
@@ -1,78 +1,57 @@
 #include "node_string.h"
+#include "crdtp/json.h"
 #include "node/inspector/protocol/Protocol.h"
 #include "simdutf.h"
 #include "util-inl.h"
 
-namespace node {
-namespace inspector {
-namespace protocol {
-namespace StringUtil {
-
-size_t kNotFound = std::string::npos;
+namespace crdtp {
 
-// NOLINTNEXTLINE(runtime/references) V8 API requirement
-void builderAppendQuotedString(StringBuilder& builder,
-                               const std::string_view string) {
-  builder.put('"');
-  if (!string.empty()) {
-    size_t expected_utf16_length =
-        simdutf::utf16_length_from_utf8(string.data(), string.length());
-    MaybeStackBuffer<char16_t> buffer(expected_utf16_length);
-    // simdutf::convert_utf8_to_utf16 returns zero in case of error.
-    size_t utf16_length = simdutf::convert_utf8_to_utf16(
-        string.data(), string.length(), buffer.out());
-    // We have that utf16_length == expected_utf16_length if and only
-    // if the input was a valid UTF-8 string.
-    if (utf16_length != 0) {
-      CHECK_EQ(expected_utf16_length, utf16_length);
-      escapeWideStringForJSON(reinterpret_cast<const uint16_t*>(buffer.out()),
-                              utf16_length,
-                              &builder);
-    }  // Otherwise, we had an invalid UTF-8 input.
+bool ProtocolTypeTraits<std::string>::Deserialize(DeserializerState* state,
+                                                  std::string* value) {
+  if (state->tokenizer()->TokenTag() == cbor::CBORTokenTag::STRING8) {
+    span<uint8_t> cbor_span = state->tokenizer()->GetString8();
+    value->assign(reinterpret_cast<const char*>(cbor_span.data()),
+                  cbor_span.size());
+    return true;
   }
-  builder.put('"');
-}
+  CHECK(state->tokenizer()->TokenTag() == cbor::CBORTokenTag::STRING16);
+  span<uint8_t> utf16le = state->tokenizer()->GetString16WireRep();
 
-std::unique_ptr<Value> parseJSON(const std::string_view string) {
-  if (string.empty())
-    return nullptr;
-  size_t expected_utf16_length =
-      simdutf::utf16_length_from_utf8(string.data(), string.length());
-  MaybeStackBuffer<char16_t> buffer(expected_utf16_length);
-  // simdutf::convert_utf8_to_utf16 returns zero in case of error.
-  size_t utf16_length = simdutf::convert_utf8_to_utf16(
-      string.data(), string.length(), buffer.out());
-  // We have that utf16_length == expected_utf16_length if and only
-  // if the input was a valid UTF-8 string.
-  if (utf16_length == 0) return nullptr;  // We had an invalid UTF-8 input.
-  CHECK_EQ(expected_utf16_length, utf16_length);
-  return parseJSONCharacters(reinterpret_cast<const uint16_t*>(buffer.out()),
-                             utf16_length);
+  value->assign(node::inspector::protocol::StringUtil::fromUTF16LE(
+      reinterpret_cast<const uint16_t*>(utf16le.data()),
+      utf16le.size() / sizeof(uint16_t)));
+  return true;
 }
 
-std::unique_ptr<Value> parseJSON(v8_inspector::StringView string) {
-  if (string.length() == 0)
-    return nullptr;
-  if (string.is8Bit())
-    return parseJSONCharacters(string.characters8(), string.length());
-  return parseJSONCharacters(string.characters16(), string.length());
+void ProtocolTypeTraits<std::string>::Serialize(const std::string& value,
+                                                std::vector<uint8_t>* bytes) {
+  cbor::EncodeString8(SpanFrom(value), bytes);
 }
 
-String StringViewToUtf8(v8_inspector::StringView view) {
+}  // namespace crdtp
+
+namespace node {
+namespace inspector {
+namespace protocol {
+
+String StringUtil::StringViewToUtf8(v8_inspector::StringView view) {
   if (view.length() == 0)
     return "";
   if (view.is8Bit()) {
     return std::string(reinterpret_cast<const char*>(view.characters8()),
                        view.length());
   }
-  const char16_t* source =
-      reinterpret_cast<const char16_t*>(view.characters16());
+  return fromUTF16(view.characters16(), view.length());
+}
+
+String StringUtil::fromUTF16(const uint16_t* data, size_t length) {
+  auto casted_data = reinterpret_cast<const char16_t*>(data);
   size_t expected_utf8_length =
-      simdutf::utf8_length_from_utf16(source, view.length());
+      simdutf::utf8_length_from_utf16(casted_data, length);
   MaybeStackBuffer<char> buffer(expected_utf8_length);
-  // convert_utf16_to_utf8 returns zero in case of error.
+  // simdutf::convert_utf16_to_utf8 returns zero in case of error.
   size_t utf8_length =
-      simdutf::convert_utf16_to_utf8(source, view.length(), buffer.out());
+      simdutf::convert_utf16_to_utf8(casted_data, length, buffer.out());
   // We have that utf8_length == expected_utf8_length if and only
   // if the input was a valid UTF-16 string. Otherwise, utf8_length
   // must be zero.
@@ -81,43 +60,18 @@ String StringViewToUtf8(v8_inspector::StringView view) {
   return String(buffer.out(), utf8_length);
 }
 
-String fromDouble(double d) {
-  std::ostringstream stream;
-  stream.imbue(std::locale::classic());  // Ignore current locale
-  stream << std::fixed << d;
-  return stream.str();
-}
-
-double toDouble(const char* buffer, size_t length, bool* ok) {
-  std::istringstream stream(std::string(buffer, length));
-  stream.imbue(std::locale::classic());  // Ignore current locale
-  double d;
-  stream >> d;
-  *ok = !stream.fail();
-  return d;
-}
-
-ProtocolMessage jsonToMessage(String message) {
-  return message;
-}
-
-ProtocolMessage binaryToMessage(std::vector<uint8_t> message) {
-  return std::string(reinterpret_cast<const char*>(message.data()),
-                     message.size());
-}
-
-String fromUTF8(const uint8_t* data, size_t length) {
+String StringUtil::fromUTF8(const uint8_t* data, size_t length) {
   return std::string(reinterpret_cast<const char*>(data), length);
 }
 
-String fromUTF16(const uint16_t* data, size_t length) {
+String StringUtil::fromUTF16LE(const uint16_t* data, size_t length) {
   auto casted_data = reinterpret_cast<const char16_t*>(data);
   size_t expected_utf8_length =
-      simdutf::utf8_length_from_utf16(casted_data, length);
+      simdutf::utf8_length_from_utf16le(casted_data, length);
   MaybeStackBuffer<char> buffer(expected_utf8_length);
-  // simdutf::convert_utf16_to_utf8 returns zero in case of error.
+  // simdutf::convert_utf16le_to_utf8 returns zero in case of error.
   size_t utf8_length =
-      simdutf::convert_utf16_to_utf8(casted_data, length, buffer.out());
+      simdutf::convert_utf16le_to_utf8(casted_data, length, buffer.out());
   // We have that utf8_length == expected_utf8_length if and only
   // if the input was a valid UTF-16 string. Otherwise, utf8_length
   // must be zero.
@@ -126,11 +80,11 @@ String fromUTF16(const uint16_t* data, size_t length) {
   return String(buffer.out(), utf8_length);
 }
 
-const uint8_t* CharactersUTF8(const std::string_view s) {
+const uint8_t* StringUtil::CharactersUTF8(const std::string_view s) {
   return reinterpret_cast<const uint8_t*>(s.data());
 }
 
-size_t CharacterCount(const std::string_view s) {
+size_t StringUtil::CharacterCount(const std::string_view s) {
   // The utf32_length_from_utf8 function calls count_utf8.
   // The count_utf8 function counts the number of code points
   // (characters) in the string, assuming that the string is valid Unicode.
@@ -138,8 +92,6 @@ size_t CharacterCount(const std::string_view s) {
   return simdutf::utf32_length_from_utf8(s.data(), s.length());
 }
 
-}  // namespace StringUtil
 }  // namespace protocol
 }  // namespace inspector
 }  // namespace node
-
diff --git a/src/inspector/node_string.h b/src/inspector/node_string.h
index 369041841ef96d..d529d1337be0e2 100644
--- a/src/inspector/node_string.h
+++ b/src/inspector/node_string.h
@@ -3,6 +3,7 @@
 #ifndef SRC_INSPECTOR_NODE_STRING_H_
 #define SRC_INSPECTOR_NODE_STRING_H_
 
+#include "crdtp/protocol_core.h"
 #include "util.h"
 #include "v8-inspector.h"
 
@@ -10,6 +11,16 @@
 #include <sstream>
 #include <string>
 
+namespace crdtp {
+
+template <>
+struct ProtocolTypeTraits<std::string> {
+  static bool Deserialize(DeserializerState* state, std::string* value);
+  static void Serialize(const std::string& value, std::vector<uint8_t>* bytes);
+};
+
+}  // namespace crdtp
+
 namespace node {
 namespace inspector {
 namespace protocol {
@@ -20,71 +31,25 @@ using String = std::string;
 using StringBuilder = std::ostringstream;
 using ProtocolMessage = std::string;
 
-namespace StringUtil {
-// NOLINTNEXTLINE(runtime/references) This is V8 API...
-inline void builderAppend(StringBuilder& builder, char c) {
-  builder.put(c);
-}
-
-// NOLINTNEXTLINE(runtime/references)
-inline void builderAppend(StringBuilder& builder, const char* value,
-                          size_t length) {
-  builder.write(value, length);
-}
-
-// NOLINTNEXTLINE(runtime/references)
-inline void builderAppend(StringBuilder& builder, const char* value) {
-  builderAppend(builder, value, std::strlen(value));
-}
-
-// NOLINTNEXTLINE(runtime/references)
-inline void builderAppend(StringBuilder& builder, const String& string) {
-  builder << string;
-}
+// Implements StringUtil methods used in `inspector_protocol/lib/`.
+struct StringUtil {
+  // Convert Utf16 in local endianness to Utf8 if needed.
+  static String StringViewToUtf8(v8_inspector::StringView view);
+  static String fromUTF16(const uint16_t* data, size_t length);
 
-// NOLINTNEXTLINE(runtime/references)
-inline void builderReserve(StringBuilder& builder, size_t) {
-  // ostringstream does not have a counterpart
-}
-inline String substring(const String& string, size_t start, size_t count) {
-  return string.substr(start, count);
-}
-inline String fromInteger(int n) {
-  return std::to_string(n);
-}
-inline String builderToString(const StringBuilder& builder) {
-  return builder.str();
-}
-inline size_t find(const String& string, const char* substring) {
-  return string.find(substring);
-}
-String fromDouble(double d);
-double toDouble(const char* buffer, size_t length, bool* ok);
+  static String fromUTF8(const uint8_t* data, size_t length);
+  static String fromUTF16LE(const uint16_t* data, size_t length);
+  static const uint8_t* CharactersUTF8(const std::string_view s);
+  static size_t CharacterCount(const std::string_view s);
 
-String StringViewToUtf8(v8_inspector::StringView view);
-
-// NOLINTNEXTLINE(runtime/references)
-void builderAppendQuotedString(StringBuilder& builder, const std::string_view);
-std::unique_ptr<Value> parseJSON(const std::string_view);
-std::unique_ptr<Value> parseJSON(v8_inspector::StringView view);
-
-ProtocolMessage jsonToMessage(String message);
-ProtocolMessage binaryToMessage(std::vector<uint8_t> message);
-String fromUTF8(const uint8_t* data, size_t length);
-String fromUTF16(const uint16_t* data, size_t length);
-const uint8_t* CharactersUTF8(const std::string_view s);
-size_t CharacterCount(const std::string_view s);
-
-// Unimplemented. The generated code will fall back to CharactersUTF8().
-inline uint8_t* CharactersLatin1(const std::string_view s) {
-  return nullptr;
-}
-inline const uint16_t* CharactersUTF16(const std::string_view s) {
-  return nullptr;
-}
-
-extern size_t kNotFound;
-}  // namespace StringUtil
+  // Unimplemented. The generated code will fall back to CharactersUTF8().
+  inline static uint8_t* CharactersLatin1(const std::string_view s) {
+    return nullptr;
+  }
+  inline static const uint16_t* CharactersUTF16(const std::string_view s) {
+    return nullptr;
+  }
+};
 
 // A read-only sequence of uninterpreted bytes with reference-counted storage.
 // Though the templates for generating the protocol bindings reference
diff --git a/src/inspector/runtime_agent.cc b/src/inspector/runtime_agent.cc
index 94aa8bef405b66..d3bc60741d9256 100644
--- a/src/inspector/runtime_agent.cc
+++ b/src/inspector/runtime_agent.cc
@@ -19,7 +19,7 @@ void RuntimeAgent::Wire(UberDispatcher* dispatcher) {
 
 DispatchResponse RuntimeAgent::notifyWhenWaitingForDisconnect(bool enabled) {
   notify_when_waiting_for_disconnect_ = enabled;
-  return DispatchResponse::OK();
+  return DispatchResponse::Success();
 }
 
 DispatchResponse RuntimeAgent::enable() {
@@ -27,12 +27,12 @@ DispatchResponse RuntimeAgent::enable() {
   if (is_waiting_for_debugger_) {
     frontend_->waitingForDebugger();
   }
-  return DispatchResponse::OK();
+  return DispatchResponse::Success();
 }
 
 DispatchResponse RuntimeAgent::disable() {
   enabled_ = false;
-  return DispatchResponse::OK();
+  return DispatchResponse::Success();
 }
 
 void RuntimeAgent::setWaitingForDebugger() {
diff --git a/src/inspector/tracing_agent.cc b/src/inspector/tracing_agent.cc
index e7b6d3b3ea63bd..40c8aea35c931c 100644
--- a/src/inspector/tracing_agent.cc
+++ b/src/inspector/tracing_agent.cc
@@ -1,4 +1,5 @@
 #include "tracing_agent.h"
+#include "crdtp/json.h"
 #include "main_thread_interface.h"
 #include "node_internals.h"
 #include "node_v8_platform-inl.h"
@@ -69,9 +70,16 @@ class SendMessageRequest : public Request {
             thread->GetObjectIfExists(object_id_));
     if (frontend_wrapper == nullptr) return;
     auto frontend = frontend_wrapper->get();
-    if (frontend != nullptr) {
-      frontend->sendRawJSONNotification(message_);
+    if (frontend == nullptr) {
+      return;
     }
+    std::vector<uint8_t> cbor;
+    crdtp::Status status =
+        crdtp::json::ConvertJSONToCBOR(crdtp::SpanFrom(message_), &cbor);
+    DCHECK(status.ok());
+    USE(status);
+
+    frontend->sendRawNotification(Serializable::From(cbor));
   }
 
  private:
@@ -136,11 +144,11 @@ void TracingAgent::Wire(UberDispatcher* dispatcher) {
 DispatchResponse TracingAgent::start(
     std::unique_ptr<protocol::NodeTracing::TraceConfig> traceConfig) {
   if (!trace_writer_.empty()) {
-    return DispatchResponse::Error(
+    return DispatchResponse::InvalidRequest(
         "Call NodeTracing::end to stop tracing before updating the config");
   }
   if (!env_->owns_process_state()) {
-    return DispatchResponse::Error(
+    return DispatchResponse::InvalidRequest(
         "Tracing properties can only be changed through main thread sessions");
   }
 
@@ -151,7 +159,8 @@ DispatchResponse TracingAgent::start(
     categories_set.insert((*categories)[i]);
 
   if (categories_set.empty())
-    return DispatchResponse::Error("At least one category should be enabled");
+    return DispatchResponse::InvalidRequest(
+        "At least one category should be enabled");
 
   tracing::AgentWriterHandle* writer = GetTracingAgentWriter();
   if (writer != nullptr) {
@@ -161,13 +170,13 @@ DispatchResponse TracingAgent::start(
                                        frontend_object_id_, main_thread_),
                                    tracing::Agent::kIgnoreDefaultCategories);
   }
-  return DispatchResponse::OK();
+  return DispatchResponse::Success();
 }
 
 DispatchResponse TracingAgent::stop() {
   trace_writer_.reset();
   frontend_->tracingComplete();
-  return DispatchResponse::OK();
+  return DispatchResponse::Success();
 }
 
 DispatchResponse TracingAgent::getCategories(
@@ -195,7 +204,7 @@ DispatchResponse TracingAgent::getCategories(
   categories_list->emplace_back("node.threadpoolwork.sync");
   categories_list->emplace_back("node.vm.script");
   categories_list->emplace_back("v8");
-  return DispatchResponse::OK();
+  return DispatchResponse::Success();
 }
 
 }  // namespace protocol
diff --git a/src/inspector/worker_agent.cc b/src/inspector/worker_agent.cc
index 81706572e646ea..87da164ee9e9b9 100644
--- a/src/inspector/worker_agent.cc
+++ b/src/inspector/worker_agent.cc
@@ -93,13 +93,13 @@ void WorkerAgent::Wire(UberDispatcher* dispatcher) {
 DispatchResponse WorkerAgent::sendMessageToWorker(const String& message,
                                                   const String& sessionId) {
   workers_->Receive(sessionId, message);
-  return DispatchResponse::OK();
+  return DispatchResponse::Success();
 }
 
 DispatchResponse WorkerAgent::enable(bool waitForDebuggerOnStart) {
   auto manager = manager_.lock();
   if (!manager) {
-    return DispatchResponse::OK();
+    return DispatchResponse::Success();
   }
   if (!event_handle_) {
     std::unique_ptr<AgentWorkerInspectorDelegate> delegate(
@@ -107,17 +107,17 @@ DispatchResponse WorkerAgent::enable(bool waitForDebuggerOnStart) {
     event_handle_ = manager->SetAutoAttach(std::move(delegate));
   }
   event_handle_->SetWaitOnStart(waitForDebuggerOnStart);
-  return DispatchResponse::OK();
+  return DispatchResponse::Success();
 }
 
 DispatchResponse WorkerAgent::disable() {
   event_handle_.reset();
-  return DispatchResponse::OK();
+  return DispatchResponse::Success();
 }
 
 DispatchResponse WorkerAgent::detach(const String& sessionId) {
   workers_->Detached(sessionId);
-  return DispatchResponse::OK();
+  return DispatchResponse::Success();
 }
 
 void NodeWorkers::WorkerCreated(const std::string& title,
diff --git a/src/inspector_agent.cc b/src/inspector_agent.cc
index bb39a0cb42a7be..be767c1825d64f 100644
--- a/src/inspector_agent.cc
+++ b/src/inspector_agent.cc
@@ -1,8 +1,10 @@
 #include "inspector_agent.h"
 
+#include "crdtp/json.h"
 #include "env-inl.h"
 #include "inspector/main_thread_interface.h"
 #include "inspector/network_inspector.h"
+#include "inspector/node_json.h"
 #include "inspector/node_string.h"
 #include "inspector/runtime_agent.h"
 #include "inspector/tracing_agent.h"
@@ -37,6 +39,12 @@
 namespace node {
 namespace inspector {
 namespace {
+
+using crdtp::Dispatchable;
+using crdtp::Serializable;
+using crdtp::UberDispatcher;
+using crdtp::json::ConvertCBORToJSON;
+using crdtp::json::ConvertJSONToCBOR;
 using v8::Context;
 using v8::Function;
 using v8::HandleScope;
@@ -45,7 +53,6 @@ using v8::Local;
 using v8::Message;
 using v8::Object;
 using v8::Value;
-
 using v8_inspector::StringBuffer;
 using v8_inspector::StringView;
 using v8_inspector::V8Inspector;
@@ -222,7 +229,7 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
                                   this,
                                   StringView(),
                                   V8Inspector::ClientTrustLevel::kFullyTrusted);
-    node_dispatcher_ = std::make_unique<protocol::UberDispatcher>(this);
+    node_dispatcher_ = std::make_unique<UberDispatcher>(this);
     tracing_agent_ =
         std::make_unique<protocol::TracingAgent>(env, main_thread_);
     tracing_agent_->Wire(node_dispatcher_.get());
@@ -252,8 +259,7 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
   void emitNotificationFromBackend(const StringView& event,
                                    const StringView& params) {
     std::unique_ptr<protocol::DictionaryValue> value =
-        protocol::DictionaryValue::cast(
-            protocol::StringUtil::parseJSON(params));
+        protocol::DictionaryValue::cast(JsonUtil::parseJSON(params));
     std::string raw_event = protocol::StringUtil::StringViewToUtf8(event);
     std::string domain_name = raw_event.substr(0, raw_event.find('.'));
     std::string event_name = raw_event.substr(raw_event.find('.') + 1);
@@ -270,19 +276,24 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
     per_process::Debug(DebugCategory::INSPECTOR_SERVER,
                        "[inspector received] %s\n",
                        raw_message);
-    std::unique_ptr<protocol::DictionaryValue> value =
-        protocol::DictionaryValue::cast(
-            protocol::StringUtil::parseJSON(message));
-    int call_id;
-    std::string method;
-    node_dispatcher_->parseCommand(value.get(), &call_id, &method);
+
+    std::vector<uint8_t> cbor_buffer;
+    ConvertJSONToCBOR(crdtp::SpanFrom(raw_message), &cbor_buffer);
+    Dispatchable dispatchable(crdtp::SpanFrom(cbor_buffer));
+    crdtp::span<uint8_t> method = dispatchable.Method();
     if (v8_inspector::V8InspectorSession::canDispatchMethod(
-            Utf8ToStringView(method)->string())) {
+            StringView(method.data(), method.size()))) {
       session_->dispatchProtocolMessage(message);
-    } else {
-      node_dispatcher_->dispatch(
-          call_id, method, std::move(value), raw_message);
+      return;
     }
+    UberDispatcher::DispatchResult result =
+        node_dispatcher_->Dispatch(dispatchable);
+    if (!result.MethodFound()) {
+      per_process::Debug(DebugCategory::INSPECTOR_SERVER,
+                         "[inspector] method not found\n");
+      // Fall through to send a method not found error.
+    }
+    result.Run();
   }
 
   void schedulePauseOnNextStatement(const std::string& reason) {
@@ -308,18 +319,23 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
   }
 
  private:
+  // v8_inspector::V8Inspector::Channel
   void sendResponse(
       int callId,
       std::unique_ptr<v8_inspector::StringBuffer> message) override {
     sendMessageToFrontend(message->string());
   }
 
+  // v8_inspector::V8Inspector::Channel
   void sendNotification(
       std::unique_ptr<v8_inspector::StringBuffer> message) override {
     sendMessageToFrontend(message->string());
   }
 
+  // v8_inspector::V8Inspector::Channel
   void flushProtocolNotifications() override { }
+  // crdtp::FrontendChannel
+  void FlushProtocolNotifications() override {}
 
   void sendMessageToFrontend(const StringView& message) {
     if (per_process::enabled_debug_list.enabled(
@@ -336,20 +352,34 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
     sendMessageToFrontend(Utf8ToStringView(message)->string());
   }
 
-  using Serializable = protocol::Serializable;
-
-  void sendProtocolResponse(int callId,
+  // crdtp::FrontendChannel
+  void SendProtocolResponse(int callId,
                             std::unique_ptr<Serializable> message) override {
-    sendMessageToFrontend(message->serializeToJSON());
+    std::vector<uint8_t> cbor = message->Serialize();
+    std::string json;
+    crdtp::Status status = ConvertCBORToJSON(crdtp::SpanFrom(cbor), &json);
+    DCHECK(status.ok());
+    USE(status);
+
+    sendMessageToFrontend(json);
   }
-  void sendProtocolNotification(
+
+  // crdtp::FrontendChannel
+  void SendProtocolNotification(
       std::unique_ptr<Serializable> message) override {
-    sendMessageToFrontend(message->serializeToJSON());
+    std::vector<uint8_t> cbor = message->Serialize();
+    std::string json;
+    crdtp::Status status = ConvertCBORToJSON(crdtp::SpanFrom(cbor), &json);
+    DCHECK(status.ok());
+    USE(status);
+
+    sendMessageToFrontend(json);
   }
 
-  void fallThrough(int callId,
-                   const std::string& method,
-                   const std::string& message) override {
+  // crdtp::FrontendChannel
+  void FallThrough(int call_id,
+                   crdtp::span<uint8_t> method,
+                   crdtp::span<uint8_t> message) override {
     DCHECK(false);
   }
 
@@ -359,7 +389,7 @@ class ChannelImpl final : public v8_inspector::V8Inspector::Channel,
   std::unique_ptr<NetworkInspector> network_inspector_;
   std::unique_ptr<InspectorSessionDelegate> delegate_;
   std::unique_ptr<v8_inspector::V8InspectorSession> session_;
-  std::unique_ptr<protocol::UberDispatcher> node_dispatcher_;
+  std::unique_ptr<UberDispatcher> node_dispatcher_;
   bool prevent_shutdown_;
   bool retaining_context_;
 };
diff --git a/tools/inspector_protocol/README.md b/tools/inspector_protocol/README.md
index da3f93f3f3b49e..d15f719fdda32c 100644
--- a/tools/inspector_protocol/README.md
+++ b/tools/inspector_protocol/README.md
@@ -14,20 +14,5 @@ https://cs.chromium.org/chromium/src/v8/third_party/inspector_protocol/
 
 See also [Contributing to Chrome Devtools Protocol](https://docs.google.com/document/d/1c-COD2kaK__5iMM5SEx-PzNA7HFmgttcYfOHHX0HaOM/edit).
 
-We're working on enabling standalone builds for parts of this package for
-testing and development, please feel free to ignore this for now.
-But, if you're familiar with
-[Chromium's development process](https://www.chromium.org/developers/contributing-code)
-and have the depot_tools installed, you may use these commands
-to fetch the package (and dependencies) and build and run the tests:
-
-    fetch inspector_protocol
-    cd src
-    gn gen out/Release
-    ninja -C out/Release json_parser_test
-    out/Release/json_parser_test
-
-You'll probably also need to install g++, since Clang uses this to find the
-standard C++ headers. E.g.,
-
-    sudo apt-get install g++-8
+To build and run the tests of the crdtp library, see
+[CRDTP - Chrome DevTools Protocol](crdtp/README.md).
diff --git a/tools/inspector_protocol/README.node b/tools/inspector_protocol/README.node
index a8380198576d46..5d5b486b512297 100644
--- a/tools/inspector_protocol/README.node
+++ b/tools/inspector_protocol/README.node
@@ -2,7 +2,7 @@ Name: inspector protocol
 Short Name: inspector_protocol
 URL: https://chromium.googlesource.com/deps/inspector_protocol/
 Version: 0
-Revision: 0aafd2876f7485db7b07c513c0457b7cbbbe3304
+Revision: 64cc2301620c04f0fe0313ae94a9319f003603cf
 License: BSD
 License File: LICENSE
 Security Critical: no
diff --git a/tools/inspector_protocol/check_protocol_compatibility.py b/tools/inspector_protocol/check_protocol_compatibility.py
index d2df244fa97154..ca72da24e99828 100755
--- a/tools/inspector_protocol/check_protocol_compatibility.py
+++ b/tools/inspector_protocol/check_protocol_compatibility.py
@@ -1,31 +1,7 @@
-#!/usr/bin/env python
-# Copyright (c) 2011 Google Inc. All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-#
-#     * Redistributions of source code must retain the above copyright
-# notice, this list of conditions and the following disclaimer.
-#     * Redistributions in binary form must reproduce the above
-# copyright notice, this list of conditions and the following disclaimer
-# in the documentation and/or other materials provided with the
-# distribution.
-#     * Neither the name of Google Inc. nor the names of its
-# contributors may be used to endorse or promote products derived from
-# this software without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+#!/usr/bin/env python3
+# Copyright 2011 The Chromium Authors
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
 #
 # Inspector protocol validator.
 #
diff --git a/tools/inspector_protocol/code_generator.py b/tools/inspector_protocol/code_generator.py
index a6e163c6fe911f..53beb861259af5 100755
--- a/tools/inspector_protocol/code_generator.py
+++ b/tools/inspector_protocol/code_generator.py
@@ -1,8 +1,9 @@
-#!/usr/bin/env python
-# Copyright 2016 The Chromium Authors. All rights reserved.
+#!/usr/bin/env python3
+# Copyright 2016 The Chromium Authors
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
+import os
 import os.path
 import sys
 import argparse
@@ -11,18 +12,18 @@
 import re
 import copy
 try:
-    import json
+  import json
 except ImportError:
-    import simplejson as json
+  import simplejson as json
 
 import pdl
 
 try:
-    unicode
+  unicode
 except NameError:
-    # Define unicode for Py3
-    def unicode(s, *_):
-        return s
+  # Define unicode for Py3
+  def unicode(s, *_):
+    return s
 
 # Path handling for libraries and templates
 # Paths have to be normalized because Jinja uses the exact template path to
@@ -35,666 +36,698 @@ def unicode(s, *_):
 module_path, module_filename = os.path.split(os.path.realpath(__file__))
 
 def read_config():
-    # pylint: disable=W0703
-    def json_to_object(data, output_base):
-        def json_object_hook(object_dict):
-            items = [(k, os.path.join(output_base, v) if k == "path" else v) for (k, v) in object_dict.items()]
-            items = [(k, os.path.join(output_base, v) if k == "output" else v) for (k, v) in items]
-            keys, values = list(zip(*items))
-            # 'async' is a python 3.7 keyword. Don't use namedtuple(rename=True)
-            # because that only renames it in python 3 but not python 2.
-            keys = tuple('async_' if k == 'async' else k for k in keys)
-            return collections.namedtuple('X', keys)(*values)
-        return json.loads(data, object_hook=json_object_hook)
-
-    def init_defaults(config_tuple, path, defaults):
-        keys = list(config_tuple._fields)  # pylint: disable=E1101
-        values = [getattr(config_tuple, k) for k in keys]
-        for i in range(len(keys)):
-            if hasattr(values[i], "_fields"):
-                values[i] = init_defaults(values[i], path + "." + keys[i], defaults)
-        for optional in defaults:
-            if optional.find(path + ".") != 0:
-                continue
-            optional_key = optional[len(path) + 1:]
-            if optional_key.find(".") == -1 and optional_key not in keys:
-                keys.append(optional_key)
-                values.append(defaults[optional])
-        return collections.namedtuple('X', keys)(*values)
-
-    try:
-        cmdline_parser = argparse.ArgumentParser()
-        cmdline_parser.add_argument("--output_base", type=unicode, required=True)
-        cmdline_parser.add_argument("--jinja_dir", type=unicode, required=True)
-        cmdline_parser.add_argument("--config", type=unicode, required=True)
-        cmdline_parser.add_argument("--config_value", default=[], action="append")
-        arg_options = cmdline_parser.parse_args()
-        jinja_dir = arg_options.jinja_dir
-        output_base = arg_options.output_base
-        config_file = arg_options.config
-        config_values = arg_options.config_value
-    except Exception:
-        # Work with python 2 and 3 http://docs.python.org/py3k/howto/pyporting.html
-        exc = sys.exc_info()[1]
-        sys.stderr.write("Failed to parse command-line arguments: %s\n\n" % exc)
-        exit(1)
-
-    try:
-        config_json_file = open(config_file, "r")
-        config_json_string = config_json_file.read()
-        config_partial = json_to_object(config_json_string, output_base)
-        config_json_file.close()
-        defaults = {
-            ".use_snake_file_names": False,
-            ".use_title_case_methods": False,
-            ".imported": False,
-            ".imported.export_macro": "",
-            ".imported.export_header": False,
-            ".imported.header": False,
-            ".imported.package": False,
-            ".imported.options": False,
-            ".protocol.export_macro": "",
-            ".protocol.export_header": False,
-            ".protocol.options": False,
-            ".protocol.file_name_prefix": "",
-            ".exported": False,
-            ".exported.export_macro": "",
-            ".exported.export_header": False,
-            ".lib": False,
-            ".lib.export_macro": "",
-            ".lib.export_header": False,
-            # The encoding lib consists of encoding/encoding.h and
-            # encoding/encoding.cc in its subdirectory, which binaries
-            # may link / depend on, instead of relying on the
-            # JINJA2 templates lib/encoding_{h,cc}.template.
-            # In that case, |header| identifies the include file
-            # and |namespace| is the namespace it's using. Usually
-            # inspector_protocol_encoding but for v8's copy it's
-            # v8_inspector_protocol_encoding.
-            # TODO(johannes): Migrate away from lib/encoding_{h,cc}.template
-            #                 in favor of this.
-            ".encoding_lib": { "header": "", "namespace": []},
-        }
-        for key_value in config_values:
-            parts = key_value.split("=")
-            if len(parts) == 2:
-                defaults["." + parts[0]] = parts[1]
-        return (jinja_dir, config_file, init_defaults(config_partial, "", defaults))
-    except Exception:
-        # Work with python 2 and 3 http://docs.python.org/py3k/howto/pyporting.html
-        exc = sys.exc_info()[1]
-        sys.stderr.write("Failed to parse config file: %s\n\n" % exc)
-        exit(1)
+  # pylint: disable=W0703
+  def json_to_object(data, output_base, config_base):
+    def json_object_hook(object_dict):
+      items = [(k, os.path.join(config_base, v) if k == "path" else v)
+               for (k, v) in object_dict.items()]
+      items = [(k, os.path.join(output_base, v) if k == "output" else v)
+               for (k, v) in items]
+      keys, values = list(zip(*items))
+      # 'async' is a keyword since Python 3.7.
+      # Avoid namedtuple(rename=True) for compatibility with Python 2.X.
+      keys = tuple('async_' if k == 'async' else k for k in keys)
+      return collections.namedtuple('X', keys)(*values)
+    return json.loads(data, object_hook=json_object_hook)
+
+  def init_defaults(config_tuple, path, defaults):
+    keys = list(config_tuple._fields)  # pylint: disable=E1101
+    values = [getattr(config_tuple, k) for k in keys]
+    for i in range(len(keys)):
+      if hasattr(values[i], "_fields"):
+        values[i] = init_defaults(values[i], path + "." + keys[i], defaults)
+    for optional in defaults:
+      if optional.find(path + ".") != 0:
+        continue
+      optional_key = optional[len(path) + 1:]
+      if optional_key.find(".") == -1 and optional_key not in keys:
+        keys.append(optional_key)
+        values.append(defaults[optional])
+    return collections.namedtuple('X', keys)(*values)
+
+  try:
+    cmdline_parser = argparse.ArgumentParser()
+    cmdline_parser.add_argument("--output_base", type=unicode, required=True)
+    cmdline_parser.add_argument("--jinja_dir", type=unicode, required=True)
+    cmdline_parser.add_argument("--config", type=unicode, required=True)
+    cmdline_parser.add_argument("--config_value", default=[], action="append")
+    cmdline_parser.add_argument(
+      "--inspector_protocol_dir", type=unicode, required=True,
+      help=("directory with code_generator.py and C++ encoding / binding "
+          "libraries, relative to the root of the source tree."))
+    arg_options = cmdline_parser.parse_args()
+    jinja_dir = arg_options.jinja_dir
+    output_base = arg_options.output_base
+    config_file = arg_options.config
+    config_base = os.path.dirname(config_file)
+    config_values = arg_options.config_value
+    inspector_protocol_dir = arg_options.inspector_protocol_dir.lstrip('/')
+  except Exception:
+    # Work with python 2 and 3 http://docs.python.org/py3k/howto/pyporting.html
+    exc = sys.exc_info()[1]
+    sys.stderr.write("Failed to parse command-line arguments: %s\n\n" % exc)
+    exit(1)
+
+  try:
+    config_json_file = open(config_file, "r")
+    config_json_string = config_json_file.read()
+    config_partial = json_to_object(config_json_string, output_base,
+                                    config_base)
+    config_json_file.close()
+    defaults = {
+      ".use_snake_file_names": False,
+      ".use_title_case_methods": False,
+      ".use_embedder_types": False,
+      ".imported": False,
+      ".imported.export_macro": "",
+      ".imported.export_header": False,
+      ".imported.header": False,
+      ".imported.package": False,
+      ".imported.options": False,
+      ".protocol.export_macro": "",
+      ".protocol.export_header": False,
+      ".protocol.options": False,
+      ".protocol.file_name_prefix": "",
+      ".exported": False,
+      ".exported.export_macro": "",
+      ".exported.export_header": False,
+      ".lib": False,
+      ".lib.export_macro": "",
+      ".lib.export_header": False,
+      ".crdtp": False,
+      ".crdtp.dir": os.path.join(inspector_protocol_dir, "crdtp"),
+      ".crdtp.namespace": "crdtp",
+    }
+    for key_value in config_values:
+      parts = key_value.split("=")
+      if len(parts) == 2:
+        defaults["." + parts[0]] = parts[1]
+    return (jinja_dir, config_file, init_defaults(config_partial, "", defaults))
+  except Exception:
+    # Work with python 2 and 3 http://docs.python.org/py3k/howto/pyporting.html
+    exc = sys.exc_info()[1]
+    sys.stderr.write("Failed to parse config file: %s\n\n" % exc)
+    exit(1)
 
 
 # ---- Begin of utilities exposed to generator ----
 
 
 def to_title_case(name):
-    return name[:1].upper() + name[1:]
+  return name[:1].upper() + name[1:]
 
 
 def dash_to_camelcase(word):
-    prefix = ""
-    if word[0] == "-":
-        prefix = "Negative"
-        word = word[1:]
-    return prefix + "".join(to_title_case(x) or "-" for x in word.split("-"))
+  prefix = ""
+  if word[0] == "-":
+    prefix = "Negative"
+    word = word[1:]
+  return prefix + "".join(to_title_case(x) or "-" for x in word.split("-"))
 
 
 def to_snake_case(name):
-    return re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", name, sys.maxsize).lower()
+  name = re.sub(r"([A-Z]{2,})([A-Z][a-z])", r"\1_\2", name)
+  return re.sub(r"([a-z0-9])([A-Z])", r"\1_\2", name, sys.maxsize).lower()
 
 
 def to_method_case(config, name):
-    if config.use_title_case_methods:
-        return to_title_case(name)
-    return name
+  if config.use_title_case_methods:
+    return to_title_case(name)
+  return name
 
 
 def join_arrays(dict, keys):
-    result = []
-    for key in keys:
-        if key in dict:
-            result += dict[key]
-    return result
+  result = []
+  for key in keys:
+    if key in dict:
+      result += dict[key]
+  return result
 
 
 def format_include(config, header, file_name=None):
-    if file_name is not None:
-        header = header + "/" + file_name + ".h"
-    header = "\"" + header + "\"" if header[0] not in "<\"" else header
-    if config.use_snake_file_names:
-        header = to_snake_case(header)
-    return header
+  if file_name is not None:
+    header = header + "/" + file_name + ".h"
+  header = "\"" + header + "\"" if header[0] not in "<\"" else header
+  if config.use_snake_file_names:
+    header = to_snake_case(header)
+  return header
 
 
 def format_domain_include(config, header, file_name):
-    return format_include(config, header, config.protocol.file_name_prefix + file_name)
+  return format_include(config, header,
+                        config.protocol.file_name_prefix + file_name)
 
 
 def to_file_name(config, file_name):
-    if config.use_snake_file_names:
-        return to_snake_case(file_name).replace(".cpp", ".cc")
-    return file_name
+  if config.use_snake_file_names:
+    return to_snake_case(file_name).replace(".cpp", ".cc")
+  return file_name
 
 
 # ---- End of utilities exposed to generator ----
 
 
 def initialize_jinja_env(jinja_dir, cache_dir, config):
-    # pylint: disable=F0401
-    sys.path.insert(1, os.path.abspath(jinja_dir))
-    import jinja2
-
-    jinja_env = jinja2.Environment(
-        loader=jinja2.FileSystemLoader(module_path),
-        # Bytecode cache is not concurrency-safe unless pre-cached:
-        # if pre-cached this is read-only, but writing creates a race condition.
-        bytecode_cache=jinja2.FileSystemBytecodeCache(cache_dir),
-        keep_trailing_newline=True,  # newline-terminate generated files
-        lstrip_blocks=True,  # so can indent control flow tags
-        trim_blocks=True)
-    jinja_env.filters.update({"to_title_case": to_title_case, "dash_to_camelcase": dash_to_camelcase, "to_method_case": functools.partial(to_method_case, config)})
-    jinja_env.add_extension("jinja2.ext.loopcontrols")
-    return jinja_env
+  # pylint: disable=F0401
+  sys.path.insert(1, os.path.abspath(jinja_dir))
+  import jinja2
+
+  jinja_env = jinja2.Environment(
+    loader=jinja2.FileSystemLoader(module_path),
+    # Bytecode cache is not concurrency-safe unless pre-cached:
+    # if pre-cached this is read-only, but writing creates a race condition.
+    bytecode_cache=jinja2.FileSystemBytecodeCache(cache_dir),
+    keep_trailing_newline=True,  # newline-terminate generated files
+    lstrip_blocks=True,  # so can indent control flow tags
+    trim_blocks=True)
+  jinja_env.filters.update({
+      "to_title_case": to_title_case,
+      "dash_to_camelcase": dash_to_camelcase,
+      "to_method_case": functools.partial(to_method_case, config)})
+  jinja_env.add_extension("jinja2.ext.loopcontrols")
+  return jinja_env
 
 
 def create_imported_type_definition(domain_name, type, imported_namespace):
-    # pylint: disable=W0622
-    return {
-        "return_type": "std::unique_ptr<%s::%s::API::%s>" % (imported_namespace, domain_name, type["id"]),
-        "pass_type": "std::unique_ptr<%s::%s::API::%s>" % (imported_namespace, domain_name, type["id"]),
-        "to_raw_type": "%s.get()",
-        "to_pass_type": "std::move(%s)",
-        "to_rvalue": "std::move(%s)",
-        "type": "std::unique_ptr<%s::%s::API::%s>" % (imported_namespace, domain_name, type["id"]),
-        "raw_type": "%s::%s::API::%s" % (imported_namespace, domain_name, type["id"]),
-        "raw_pass_type": "%s::%s::API::%s*" % (imported_namespace, domain_name, type["id"]),
-        "raw_return_type": "%s::%s::API::%s*" % (imported_namespace, domain_name, type["id"]),
-    }
+  # pylint: disable=W0622
+  return {
+    "return_type": "std::unique_ptr<%s::%s::API::%s>" % (
+        imported_namespace, domain_name, type["id"]),
+    "pass_type": "std::unique_ptr<%s::%s::API::%s>" % (
+        imported_namespace, domain_name, type["id"]),
+    "to_raw_type": "%s.get()",
+    "to_pass_type": "std::move(%s)",
+    "to_rvalue": "std::move(%s)",
+    "type": "std::unique_ptr<%s::%s::API::%s>" % (
+        imported_namespace, domain_name, type["id"]),
+    "raw_type": "%s::%s::API::%s" % (
+        imported_namespace, domain_name, type["id"]),
+    "raw_pass_type": "%s::%s::API::%s*" % (
+        imported_namespace, domain_name, type["id"]),
+    "raw_return_type": "%s::%s::API::%s*" % (
+        imported_namespace, domain_name, type["id"]),
+  }
 
 
 def create_user_type_definition(domain_name, type):
-    # pylint: disable=W0622
-    return {
-        "return_type": "std::unique_ptr<protocol::%s::%s>" % (domain_name, type["id"]),
-        "pass_type": "std::unique_ptr<protocol::%s::%s>" % (domain_name, type["id"]),
-        "to_raw_type": "%s.get()",
-        "to_pass_type": "std::move(%s)",
-        "to_rvalue": "std::move(%s)",
-        "type": "std::unique_ptr<protocol::%s::%s>" % (domain_name, type["id"]),
-        "raw_type": "protocol::%s::%s" % (domain_name, type["id"]),
-        "raw_pass_type": "protocol::%s::%s*" % (domain_name, type["id"]),
-        "raw_return_type": "protocol::%s::%s*" % (domain_name, type["id"]),
-    }
+  # pylint: disable=W0622
+  return {
+    "return_type": "std::unique_ptr<protocol::%s::%s>" % (
+        domain_name, type["id"]),
+    "pass_type": "std::unique_ptr<protocol::%s::%s>" % (
+        domain_name, type["id"]),
+    "to_raw_type": "%s.get()",
+    "to_pass_type": "std::move(%s)",
+    "to_rvalue": "std::move(%s)",
+    "type": "std::unique_ptr<protocol::%s::%s>" % (domain_name, type["id"]),
+    "raw_type": "protocol::%s::%s" % (domain_name, type["id"]),
+    "raw_pass_type": "protocol::%s::%s*" % (domain_name, type["id"]),
+    "raw_return_type": "protocol::%s::%s*" % (domain_name, type["id"]),
+  }
 
 
 def create_object_type_definition():
-    # pylint: disable=W0622
-    return {
-        "return_type": "std::unique_ptr<protocol::DictionaryValue>",
-        "pass_type": "std::unique_ptr<protocol::DictionaryValue>",
-        "to_raw_type": "%s.get()",
-        "to_pass_type": "std::move(%s)",
-        "to_rvalue": "std::move(%s)",
-        "type": "std::unique_ptr<protocol::DictionaryValue>",
-        "raw_type": "protocol::DictionaryValue",
-        "raw_pass_type": "protocol::DictionaryValue*",
-        "raw_return_type": "protocol::DictionaryValue*",
-    }
+  # pylint: disable=W0622
+  return {
+    "return_type": "std::unique_ptr<protocol::DictionaryValue>",
+    "pass_type": "std::unique_ptr<protocol::DictionaryValue>",
+    "to_raw_type": "%s.get()",
+    "to_pass_type": "std::move(%s)",
+    "to_rvalue": "std::move(%s)",
+    "type": "std::unique_ptr<protocol::DictionaryValue>",
+    "raw_type": "protocol::DictionaryValue",
+    "raw_pass_type": "protocol::DictionaryValue*",
+    "raw_return_type": "protocol::DictionaryValue*",
+  }
 
 
 def create_any_type_definition():
-    # pylint: disable=W0622
-    return {
-        "return_type": "std::unique_ptr<protocol::Value>",
-        "pass_type": "std::unique_ptr<protocol::Value>",
-        "to_raw_type": "%s.get()",
-        "to_pass_type": "std::move(%s)",
-        "to_rvalue": "std::move(%s)",
-        "type": "std::unique_ptr<protocol::Value>",
-        "raw_type": "protocol::Value",
-        "raw_pass_type": "protocol::Value*",
-        "raw_return_type": "protocol::Value*",
-    }
+  # pylint: disable=W0622
+  return {
+    "return_type": "std::unique_ptr<protocol::Value>",
+    "pass_type": "std::unique_ptr<protocol::Value>",
+    "to_raw_type": "%s.get()",
+    "to_pass_type": "std::move(%s)",
+    "to_rvalue": "std::move(%s)",
+    "type": "std::unique_ptr<protocol::Value>",
+    "raw_type": "protocol::Value",
+    "raw_pass_type": "protocol::Value*",
+    "raw_return_type": "protocol::Value*",
+  }
 
 
 def create_string_type_definition():
-    # pylint: disable=W0622
-    return {
-        "return_type": "String",
-        "pass_type": "const String&",
-        "to_pass_type": "%s",
-        "to_raw_type": "%s",
-        "to_rvalue": "%s",
-        "type": "String",
-        "raw_type": "String",
-        "raw_pass_type": "const String&",
-        "raw_return_type": "String",
-    }
+  # pylint: disable=W0622
+  return {
+    "return_type": "String",
+    "pass_type": "const String&",
+    "to_pass_type": "%s",
+    "to_raw_type": "%s",
+    "to_rvalue": "%s",
+    "type": "String",
+    "raw_type": "String",
+    "raw_pass_type": "const String&",
+    "raw_return_type": "String",
+    "is_primitive": True
+  }
 
 
 def create_binary_type_definition():
-    # pylint: disable=W0622
-    return {
-        "return_type": "Binary",
-        "pass_type": "const Binary&",
-        "to_pass_type": "%s",
-        "to_raw_type": "%s",
-        "to_rvalue": "%s",
-        "type": "Binary",
-        "raw_type": "Binary",
-        "raw_pass_type": "const Binary&",
-        "raw_return_type": "Binary",
-    }
+  # pylint: disable=W0622
+  return {
+    "return_type": "Binary",
+    "pass_type": "const Binary&",
+    "to_pass_type": "%s",
+    "to_raw_type": "%s",
+    "to_rvalue": "%s",
+    "type": "Binary",
+    "raw_type": "Binary",
+    "raw_pass_type": "const Binary&",
+    "raw_return_type": "Binary",
+    "is_primitive": True
+  }
 
 
 def create_primitive_type_definition(type):
-    # pylint: disable=W0622
-    typedefs = {
-        "number": "double",
-        "integer": "int",
-        "boolean": "bool"
-    }
-    defaults = {
-        "number": "0",
-        "integer": "0",
-        "boolean": "false"
-    }
-    jsontypes = {
-        "number": "TypeDouble",
-        "integer": "TypeInteger",
-        "boolean": "TypeBoolean",
-    }
-    return {
-        "return_type": typedefs[type],
-        "pass_type": typedefs[type],
-        "to_pass_type": "%s",
-        "to_raw_type": "%s",
-        "to_rvalue": "%s",
-        "type": typedefs[type],
-        "raw_type": typedefs[type],
-        "raw_pass_type": typedefs[type],
-        "raw_return_type": typedefs[type],
-        "default_value": defaults[type]
-    }
-
+  # pylint: disable=W0622
+  typedefs = {
+    "number": "double",
+    "integer": "int",
+    "boolean": "bool"
+  }
+  defaults = {
+    "number": "0",
+    "integer": "0",
+    "boolean": "false"
+  }
+  jsontypes = {
+    "number": "TypeDouble",
+    "integer": "TypeInteger",
+    "boolean": "TypeBoolean",
+  }
+  return {
+    "return_type": typedefs[type],
+    "pass_type": typedefs[type],
+    "to_pass_type": "%s",
+    "to_raw_type": "%s",
+    "to_rvalue": "%s",
+    "type": typedefs[type],
+    "raw_type": typedefs[type],
+    "raw_pass_type": typedefs[type],
+    "raw_return_type": typedefs[type],
+    "default_value": defaults[type],
+    "is_primitive": True
+  }
 
 def wrap_array_definition(type):
-    # pylint: disable=W0622
-    return {
-        "return_type": "std::unique_ptr<protocol::Array<%s>>" % type["raw_type"],
-        "pass_type": "std::unique_ptr<protocol::Array<%s>>" % type["raw_type"],
-        "to_raw_type": "%s.get()",
-        "to_pass_type": "std::move(%s)",
-        "to_rvalue": "std::move(%s)",
-        "type": "std::unique_ptr<protocol::Array<%s>>" % type["raw_type"],
-        "raw_type": "protocol::Array<%s>" % type["raw_type"],
-        "raw_pass_type": "protocol::Array<%s>*" % type["raw_type"],
-        "raw_return_type": "protocol::Array<%s>*" % type["raw_type"],
-        "out_type": "protocol::Array<%s>&" % type["raw_type"],
-    }
+  # pylint: disable=W0622
+  return {
+    "return_type": "std::unique_ptr<protocol::Array<%s>>" % type["raw_type"],
+    "pass_type": "std::unique_ptr<protocol::Array<%s>>" % type["raw_type"],
+    "to_raw_type": "%s.get()",
+    "to_pass_type": "std::move(%s)",
+    "to_rvalue": "std::move(%s)",
+    "type": "std::unique_ptr<protocol::Array<%s>>" % type["raw_type"],
+    "raw_type": "protocol::Array<%s>" % type["raw_type"],
+    "raw_pass_type": "protocol::Array<%s>*" % type["raw_type"],
+    "raw_return_type": "protocol::Array<%s>*" % type["raw_type"],
+    "out_type": "protocol::Array<%s>&" % type["raw_type"],
+  }
 
 
 class Protocol(object):
-    def __init__(self, config):
-        self.config = config
-        self.json_api = {"domains": []}
-        self.imported_domains = []
-        self.exported_domains = []
-        self.generate_domains = self.read_protocol_file(config.protocol.path)
-
-        if config.protocol.options:
-            self.generate_domains = [rule.domain for rule in config.protocol.options]
-            self.exported_domains = [rule.domain for rule in config.protocol.options if hasattr(rule, "exported")]
-
-        if config.imported:
-            self.imported_domains = self.read_protocol_file(config.imported.path)
-            if config.imported.options:
-                self.imported_domains = [rule.domain for rule in config.imported.options]
-
-        self.patch_full_qualified_refs()
-        self.create_notification_types()
-        self.create_type_definitions()
-        self.generate_used_types()
-
-
-    def read_protocol_file(self, file_name):
-        input_file = open(file_name, "r")
-        parsed_json = pdl.loads(input_file.read(), file_name)
-        input_file.close()
-        version = parsed_json["version"]["major"] + "." + parsed_json["version"]["minor"]
-        domains = []
-        for domain in parsed_json["domains"]:
-            domains.append(domain["domain"])
-            domain["version"] = version
-        self.json_api["domains"] += parsed_json["domains"]
-        return domains
-
-
-    def patch_full_qualified_refs(self):
-        def patch_full_qualified_refs_in_domain(json, domain_name):
-            if isinstance(json, list):
-                for item in json:
-                    patch_full_qualified_refs_in_domain(item, domain_name)
-            if not isinstance(json, dict):
-                return
-            for key in json:
-                if key == "type" and json[key] == "string":
-                    json[key] = domain_name + ".string"
-                if key != "$ref":
-                    patch_full_qualified_refs_in_domain(json[key], domain_name)
-                    continue
-                if json["$ref"].find(".") == -1:
-                    json["$ref"] = domain_name + "." + json["$ref"]
-            return
-
-        for domain in self.json_api["domains"]:
-            patch_full_qualified_refs_in_domain(domain, domain["domain"])
-
-
-    def all_references(self, json):
-        refs = set()
-        if isinstance(json, list):
-            for item in json:
-                refs |= self.all_references(item)
-        if not isinstance(json, dict):
-            return refs
-        for key in json:
-            if key != "$ref":
-                refs |= self.all_references(json[key])
-            else:
-                refs.add(json["$ref"])
-        return refs
-
-    def generate_used_types(self):
-        all_refs = set()
-        for domain in self.json_api["domains"]:
-            domain_name = domain["domain"]
-            if "commands" in domain:
-                for command in domain["commands"]:
-                    if self.generate_command(domain_name, command["name"]):
-                        all_refs |= self.all_references(command)
-            if "events" in domain:
-                for event in domain["events"]:
-                    if self.generate_event(domain_name, event["name"]):
-                        all_refs |= self.all_references(event)
-                        all_refs.add(domain_name + "." + to_title_case(event["name"]) + "Notification")
-
-        dependencies = self.generate_type_dependencies()
-        queue = set(all_refs)
-        while len(queue):
-            ref = queue.pop()
-            if ref in dependencies:
-                queue |= dependencies[ref] - all_refs
-                all_refs |= dependencies[ref]
-        self.used_types = all_refs
-
-
-    def generate_type_dependencies(self):
-        dependencies = dict()
-        domains_with_types = (x for x in self.json_api["domains"] if "types" in x)
-        for domain in domains_with_types:
-            domain_name = domain["domain"]
-            for type in domain["types"]:
-                related_types = self.all_references(type)
-                if len(related_types):
-                    dependencies[domain_name + "." + type["id"]] = related_types
-        return dependencies
-
-
-    def create_notification_types(self):
-        for domain in self.json_api["domains"]:
-            if "events" in domain:
-                for event in domain["events"]:
-                    event_type = dict()
-                    event_type["description"] = "Wrapper for notification params"
-                    event_type["type"] = "object"
-                    event_type["id"] = to_title_case(event["name"]) + "Notification"
-                    if "parameters" in event:
-                        event_type["properties"] = copy.deepcopy(event["parameters"])
-                    if "types" not in domain:
-                        domain["types"] = list()
-                    domain["types"].append(event_type)
-
-
-    def create_type_definitions(self):
-        imported_namespace = "::".join(self.config.imported.namespace) if self.config.imported else ""
-        self.type_definitions = {}
-        self.type_definitions["number"] = create_primitive_type_definition("number")
-        self.type_definitions["integer"] = create_primitive_type_definition("integer")
-        self.type_definitions["boolean"] = create_primitive_type_definition("boolean")
-        self.type_definitions["object"] = create_object_type_definition()
-        self.type_definitions["any"] = create_any_type_definition()
-        self.type_definitions["binary"] = create_binary_type_definition()
-        for domain in self.json_api["domains"]:
-            self.type_definitions[domain["domain"] + ".string"] = create_string_type_definition()
-            self.type_definitions[domain["domain"] + ".binary"] = create_binary_type_definition()
-            if not ("types" in domain):
-                continue
-            for type in domain["types"]:
-                type_name = domain["domain"] + "." + type["id"]
-                if type["type"] == "object" and domain["domain"] in self.imported_domains:
-                    self.type_definitions[type_name] = create_imported_type_definition(domain["domain"], type, imported_namespace)
-                elif type["type"] == "object":
-                    self.type_definitions[type_name] = create_user_type_definition(domain["domain"], type)
-                elif type["type"] == "array":
-                    self.type_definitions[type_name] = self.resolve_type(type)
-                elif type["type"] == domain["domain"] + ".string":
-                    self.type_definitions[type_name] = create_string_type_definition()
-                elif type["type"] == domain["domain"] + ".binary":
-                    self.type_definitions[type_name] = create_binary_type_definition()
-                else:
-                    self.type_definitions[type_name] = create_primitive_type_definition(type["type"])
-
-
-    def check_options(self, options, domain, name, include_attr, exclude_attr, default):
-        for rule in options:
-            if rule.domain != domain:
-                continue
-            if include_attr and hasattr(rule, include_attr):
-                return name in getattr(rule, include_attr)
-            if exclude_attr and hasattr(rule, exclude_attr):
-                return name not in getattr(rule, exclude_attr)
-            return default
-        return False
-
-
-    # ---- Begin of methods exposed to generator
-
 
-    def type_definition(self, name):
-        return self.type_definitions[name]
+  def __init__(self, config):
+    self.config = config
+    self.json_api = {"domains": []}
+    self.imported_domains = []
+    self.exported_domains = []
+    self.generate_domains = self.read_protocol_file(config.protocol.path)
 
+    if config.protocol.options:
+      self.generate_domains = [rule.domain for rule in config.protocol.options]
+      self.exported_domains = [rule.domain for rule in config.protocol.options
+                               if hasattr(rule, "exported")]
 
-    def resolve_type(self, prop):
-        if "$ref" in prop:
-            return self.type_definitions[prop["$ref"]]
-        if prop["type"] == "array":
-            return wrap_array_definition(self.resolve_type(prop["items"]))
-        return self.type_definitions[prop["type"]]
-
-
-    def generate_command(self, domain, command):
-        if not self.config.protocol.options:
-            return domain in self.generate_domains
-        return self.check_options(self.config.protocol.options, domain, command, "include", "exclude", True)
-
-
-    def generate_event(self, domain, event):
-        if not self.config.protocol.options:
-            return domain in self.generate_domains
-        return self.check_options(self.config.protocol.options, domain, event, "include_events", "exclude_events", True)
-
-
-    def generate_type(self, domain, typename):
-        return domain + "." + typename in self.used_types
-
-
-    def is_async_command(self, domain, command):
-        if not self.config.protocol.options:
-            return False
-        return self.check_options(self.config.protocol.options, domain, command, "async_", None, False)
-
-
-    def is_exported(self, domain, name):
-        if not self.config.protocol.options:
-            return False
-        return self.check_options(self.config.protocol.options, domain, name, "exported", None, False)
-
-
-    def is_imported(self, domain, name):
-        if not self.config.imported:
-            return False
-        if not self.config.imported.options:
-            return domain in self.imported_domains
-        return self.check_options(self.config.imported.options, domain, name, "imported", None, False)
-
-
-    def is_exported_domain(self, domain):
-        return domain in self.exported_domains
-
-
-    def generate_disable(self, domain):
-        if "commands" not in domain:
-            return True
+    if config.imported:
+      self.imported_domains = self.read_protocol_file(config.imported.path)
+      if config.imported.options:
+        self.imported_domains = [rule.domain
+                                 for rule in config.imported.options]
+
+    self.patch_full_qualified_refs()
+    self.create_type_definitions()
+    self.generate_used_types()
+
+  def read_protocol_file(self, file_name):
+    input_file = open(file_name, "r")
+    parsed_json = pdl.loads(input_file.read(), file_name)
+    input_file.close()
+    version = '%s.%s' % (parsed_json["version"]["major"],
+                         parsed_json["version"]["minor"])
+    domains = []
+    for domain in parsed_json["domains"]:
+      domains.append(domain["domain"])
+      domain["version"] = version
+    self.json_api["domains"] += parsed_json["domains"]
+    return domains
+
+  def patch_full_qualified_refs(self):
+    def patch_full_qualified_refs_in_domain(json, domain_name):
+      if isinstance(json, list):
+        for item in json:
+          patch_full_qualified_refs_in_domain(item, domain_name)
+      if not isinstance(json, dict):
+        return
+      for key in json:
+        if key == "type" and json[key] == "string":
+          json[key] = domain_name + ".string"
+        if key != "$ref":
+          patch_full_qualified_refs_in_domain(json[key], domain_name)
+          continue
+        if json["$ref"].find(".") == -1:
+          json["$ref"] = domain_name + "." + json["$ref"]
+      return
+
+    for domain in self.json_api["domains"]:
+      patch_full_qualified_refs_in_domain(domain, domain["domain"])
+
+  def all_references(self, json):
+    refs = set()
+    if isinstance(json, list):
+      for item in json:
+        refs |= self.all_references(item)
+    if not isinstance(json, dict):
+      return refs
+    for key in json:
+      if key != "$ref":
+        refs |= self.all_references(json[key])
+      else:
+        refs.add(json["$ref"])
+    return refs
+
+  def check_if_dependency_declared(self, domain, refs):
+    dependencies = domain.get('dependencies', set())
+    for ref in refs:
+      type_definition = self.type_definitions[ref]
+      if type_definition.get('is_primitive', False):
+        continue
+      domain_match = re.match(r'^(.*)[.]', ref)
+      if domain_match:
+        referenced_domain_name = domain_match.group(1)
+        if referenced_domain_name != domain['domain'] and not referenced_domain_name in dependencies:
+            sys.stderr.write(("Domains [%s] uses type [%s] from domain [%s], but did not declare the dependency\n\n"
+                    ) % (domain["domain"], ref, referenced_domain_name))
+            exit(1)
+
+  def generate_used_types(self):
+    all_refs = set()
+    for domain in self.json_api["domains"]:
+      domain_name = domain["domain"]
+      if "commands" in domain:
         for command in domain["commands"]:
-            if command["name"] == "disable" and self.generate_command(domain["domain"], "disable"):
-                return False
-        return True
-
+          if self.generate_command(domain_name, command["name"]):
+            all_refs_command = self.all_references(command)
+            # If the command has a redirect, it is as if it didn't exist on this domain.
+            if not command.get('redirect', False):
+              self.check_if_dependency_declared(domain, all_refs_command)
+            all_refs |= all_refs_command
+
+      if "events" in domain:
+        for event in domain["events"]:
+          if self.generate_event(domain_name, event["name"]):
+            all_refs_event = self.all_references(event)
+            self.check_if_dependency_declared(domain, all_refs_event)
+            all_refs |= all_refs_event
+
+
+    dependencies = self.generate_type_dependencies()
+    queue = set(all_refs)
+    while len(queue):
+      ref = queue.pop()
+      if ref in dependencies:
+        queue |= dependencies[ref] - all_refs
+        all_refs |= dependencies[ref]
+    self.used_types = all_refs
+
+  def generate_type_dependencies(self):
+    dependencies = dict()
+    domains_with_types = (x for x in self.json_api["domains"] if "types" in x)
+    for domain in domains_with_types:
+      domain_name = domain["domain"]
+      for type in domain["types"]:
+        related_types = self.all_references(type)
+        if len(related_types):
+          dependencies[domain_name + "." + type["id"]] = related_types
+    return dependencies
+
+  def create_type_definitions(self):
+    imported_namespace = ""
+    if self.config.imported:
+      imported_namespace = "::".join(self.config.imported.namespace)
+    self.type_definitions = {}
+    self.type_definitions["number"] = create_primitive_type_definition("number")
+    self.type_definitions["integer"] = create_primitive_type_definition("integer")
+    self.type_definitions["boolean"] = create_primitive_type_definition("boolean")
+    self.type_definitions["object"] = create_object_type_definition()
+    self.type_definitions["any"] = create_any_type_definition()
+    self.type_definitions["binary"] = create_binary_type_definition()
+    for domain in self.json_api["domains"]:
+      self.type_definitions[domain["domain"] + ".string"] = (
+          create_string_type_definition())
+      self.type_definitions[domain["domain"] + ".binary"] = (
+          create_binary_type_definition())
+      if not ("types" in domain):
+        continue
+      for type in domain["types"]:
+        type_name = domain["domain"] + "." + type["id"]
+        if type["type"] == "object" and domain["domain"] in self.imported_domains:
+          self.type_definitions[type_name] = create_imported_type_definition(
+              domain["domain"], type, imported_namespace)
+        elif type["type"] == "object":
+          self.type_definitions[type_name] = create_user_type_definition(
+              domain["domain"], type)
+        elif type["type"] == "array":
+          self.type_definitions[type_name] = self.resolve_type(type)
+        elif type["type"] == domain["domain"] + ".string":
+          self.type_definitions[type_name] = create_string_type_definition()
+        elif type["type"] == domain["domain"] + ".binary":
+          self.type_definitions[type_name] = create_binary_type_definition()
+        else:
+          self.type_definitions[type_name] = create_primitive_type_definition(
+              type["type"])
+
+  def check_options(self, options, domain, name, include_attr, exclude_attr,
+                    default):
+    for rule in options:
+      if rule.domain != domain:
+        continue
+      if include_attr and hasattr(rule, include_attr):
+        return name in getattr(rule, include_attr)
+      if exclude_attr and hasattr(rule, exclude_attr):
+        return name not in getattr(rule, exclude_attr)
+      return default
+    return False
+
+
+  # ---- Begin of methods exposed to generator
+
+  def type_definition(self, name):
+    return self.type_definitions[name]
+
+  def resolve_type(self, prop):
+    if "$ref" in prop:
+      return self.type_definitions[prop["$ref"]]
+    if prop["type"] == "array":
+      return wrap_array_definition(self.resolve_type(prop["items"]))
+    return self.type_definitions[prop["type"]]
+
+  def generate_command(self, domain, command):
+    if not self.config.protocol.options:
+      return domain in self.generate_domains
+    return self.check_options(self.config.protocol.options, domain, command,
+                              "include", "exclude", True)
+
+  def generate_event(self, domain, event):
+    if not self.config.protocol.options:
+      return domain in self.generate_domains
+    return self.check_options(self.config.protocol.options, domain, event,
+                              "include_events", "exclude_events", True)
+
+  def generate_type(self, domain, typename):
+    return domain + "." + typename in self.used_types
+
+  def is_async_command(self, domain, command):
+    if not self.config.protocol.options:
+      return False
+    return self.check_options(self.config.protocol.options, domain, command,
+                              "async_", None, False)
+
+  def is_exported(self, domain, name):
+    if not self.config.protocol.options:
+      return False
+    return self.check_options(self.config.protocol.options, domain, name,
+                              "exported", None, False)
+
+  def is_imported(self, domain, name):
+    if not self.config.imported:
+      return False
+    if not self.config.imported.options:
+      return domain in self.imported_domains
+    return self.check_options(self.config.imported.options, domain, name,
+                              "imported", None, False)
+
+  def is_exported_domain(self, domain):
+    return domain in self.exported_domains
+
+  def generate_disable(self, domain):
+    if "commands" not in domain:
+      return True
+    for command in domain["commands"]:
+      if command["name"] == "disable" and self.generate_command(
+          domain["domain"], "disable"):
+        return False
+    return True
 
-    def is_imported_dependency(self, domain):
-        return domain in self.generate_domains or domain in self.imported_domains
+  def is_imported_dependency(self, domain):
+    return domain in self.generate_domains or domain in self.imported_domains
 
 
 def main():
-    jinja_dir, config_file, config = read_config()
+  jinja_dir, config_file, config = read_config()
+
+  protocol = Protocol(config)
+
+  if not config.exported and len(protocol.exported_domains):
+    sys.stderr.write(("Domains [%s] are exported, but config is missing export "
+                      "entry\n\n") % ", ".join(protocol.exported_domains))
+    exit(1)
+
+  if not os.path.exists(config.protocol.output):
+    os.mkdir(config.protocol.output)
+  if len(protocol.exported_domains) and not os.path.exists(
+      config.exported.output):
+    os.mkdir(config.exported.output)
+  jinja_env = initialize_jinja_env(jinja_dir, config.protocol.output, config)
+
+  inputs = []
+  inputs.append(__file__)
+  inputs.append(config_file)
+  inputs.append(config.protocol.path)
+  if config.imported:
+    inputs.append(config.imported.path)
+  templates_dir = os.path.join(module_path, "templates")
+  inputs.append(os.path.join(templates_dir, "TypeBuilder_h.template"))
+  inputs.append(os.path.join(templates_dir, "TypeBuilder_cpp.template"))
+  inputs.append(os.path.join(templates_dir, "Exported_h.template"))
+  inputs.append(os.path.join(templates_dir, "Imported_h.template"))
+
+  h_template = jinja_env.get_template("templates/TypeBuilder_h.template")
+  cpp_template = jinja_env.get_template("templates/TypeBuilder_cpp.template")
+  exported_template = jinja_env.get_template("templates/Exported_h.template")
+  imported_template = jinja_env.get_template("templates/Imported_h.template")
+
+  outputs = dict()
+
+  for domain in protocol.json_api["domains"]:
+    class_name = domain["domain"]
+    file_name = config.protocol.file_name_prefix + class_name
+    template_context = {
+      "protocol": protocol,
+      "config": config,
+      "domain": domain,
+      "join_arrays": join_arrays,
+      "format_include": functools.partial(format_include, config),
+      "format_domain_include": functools.partial(format_domain_include, config),
+    }
 
-    protocol = Protocol(config)
+    if domain["domain"] in protocol.generate_domains:
+      outputs[os.path.join(config.protocol.output, to_file_name(
+          config, file_name + ".h"))] = h_template.render(template_context)
+      outputs[os.path.join(config.protocol.output, to_file_name(
+          config, file_name + ".cpp"))] = cpp_template.render(template_context)
+      if domain["domain"] in protocol.exported_domains:
+        outputs[os.path.join(config.exported.output, to_file_name(
+            config, file_name + ".h"))] = exported_template.render(
+                template_context)
+    if domain["domain"] in protocol.imported_domains:
+      outputs[os.path.join(config.protocol.output, to_file_name(
+          config, file_name + ".h"))] = imported_template.render(
+              template_context)
+
+  if config.lib:
+    template_context = {
+      "config": config,
+      "format_include": functools.partial(format_include, config),
+    }
 
-    if not config.exported and len(protocol.exported_domains):
-        sys.stderr.write("Domains [%s] are exported, but config is missing export entry\n\n" % ", ".join(protocol.exported_domains))
-        exit(1)
+    lib_templates_dir = os.path.join(module_path, "lib")
+    # Note these should be sorted in the right order.
+
+    # TODO(dgozman): sort them programmatically based on commented includes.
+
+    forward_h_templates = [
+      "Forward_h.template",
+    ]
+
+    protocol_h_templates = []
+    protocol_cpp_templates = []
+
+    if not config.use_embedder_types:
+      protocol_h_templates += [
+        "Values_h.template",
+        "Object_h.template",
+        "ValueConversions_h.template",
+      ]
+      protocol_cpp_templates += [
+        "Protocol_cpp.template",
+        "Values_cpp.template",
+        "Object_cpp.template",
+        "ValueConversions_cpp.template",
+      ]
+    else:
+      protocol_h_templates += [
+        "Forward_h.template",
+      ]
+
+    def generate_lib_file(file_name, template_files):
+      parts = []
+      for template_file in template_files:
+        inputs.append(os.path.join(lib_templates_dir, template_file))
+        template = jinja_env.get_template("lib/" + template_file)
+        parts.append(template.render(template_context))
+      outputs[file_name] = "\n\n".join(parts)
+
+    generate_lib_file(os.path.join(config.lib.output, to_file_name(
+        config, "Forward.h")), forward_h_templates)
+    generate_lib_file(os.path.join(config.lib.output, to_file_name(
+        config, "Protocol.h")), protocol_h_templates)
+
+    if not config.use_embedder_types:
+      generate_lib_file(os.path.join(config.lib.output, to_file_name(
+          config, "Protocol.cpp")), protocol_cpp_templates)
+
+  # Make gyp / make generatos happy, otherwise make rebuilds world.
+  inputs_ts = max(map(os.path.getmtime, inputs))
+  up_to_date = True
+  for output_file in outputs.keys():
+    if (not os.path.exists(output_file)
+        or os.path.getmtime(output_file) < inputs_ts):
+      up_to_date = False
+      break
+  if up_to_date:
+    sys.exit()
+
+  for file_name, content in outputs.items():
+    # Remove output file first to account for potential case changes.
+    try:
+      os.remove(file_name)
+    except OSError:
+      pass
+    out_file = open(file_name, "w")
+    out_file.write(content)
+    out_file.close()
 
-    if not os.path.exists(config.protocol.output):
-        os.mkdir(config.protocol.output)
-    if len(protocol.exported_domains) and not os.path.exists(config.exported.output):
-        os.mkdir(config.exported.output)
-    jinja_env = initialize_jinja_env(jinja_dir, config.protocol.output, config)
 
-    inputs = []
-    inputs.append(__file__)
-    inputs.append(config_file)
-    inputs.append(config.protocol.path)
-    if config.imported:
-        inputs.append(config.imported.path)
-    templates_dir = os.path.join(module_path, "templates")
-    inputs.append(os.path.join(templates_dir, "TypeBuilder_h.template"))
-    inputs.append(os.path.join(templates_dir, "TypeBuilder_cpp.template"))
-    inputs.append(os.path.join(templates_dir, "Exported_h.template"))
-    inputs.append(os.path.join(templates_dir, "Imported_h.template"))
-
-    h_template = jinja_env.get_template("templates/TypeBuilder_h.template")
-    cpp_template = jinja_env.get_template("templates/TypeBuilder_cpp.template")
-    exported_template = jinja_env.get_template("templates/Exported_h.template")
-    imported_template = jinja_env.get_template("templates/Imported_h.template")
-
-    outputs = dict()
-
-    for domain in protocol.json_api["domains"]:
-        class_name = domain["domain"]
-        file_name = config.protocol.file_name_prefix + class_name
-        template_context = {
-            "protocol": protocol,
-            "config": config,
-            "domain": domain,
-            "join_arrays": join_arrays,
-            "format_include": functools.partial(format_include, config),
-            "format_domain_include": functools.partial(format_domain_include, config),
-        }
-
-        if domain["domain"] in protocol.generate_domains:
-            outputs[os.path.join(config.protocol.output, to_file_name(config, file_name + ".h"))] = h_template.render(template_context)
-            outputs[os.path.join(config.protocol.output, to_file_name(config, file_name + ".cpp"))] = cpp_template.render(template_context)
-            if domain["domain"] in protocol.exported_domains:
-                outputs[os.path.join(config.exported.output, to_file_name(config, file_name + ".h"))] = exported_template.render(template_context)
-        if domain["domain"] in protocol.imported_domains:
-            outputs[os.path.join(config.protocol.output, to_file_name(config, file_name + ".h"))] = imported_template.render(template_context)
-
-    if config.lib:
-        template_context = {
-            "config": config,
-            "format_include": functools.partial(format_include, config),
-        }
-
-        lib_templates_dir = os.path.join(module_path, "lib")
-        # Note these should be sorted in the right order.
-        # TODO(dgozman): sort them programmatically based on commented includes.
-        protocol_h_templates = [
-            "ErrorSupport_h.template",
-            "Values_h.template",
-            "Object_h.template",
-            "ValueConversions_h.template",
-            "Maybe_h.template",
-            "DispatcherBase_h.template",
-            "Parser_h.template",
-            "encoding_h.template",
-        ]
-
-        protocol_cpp_templates = [
-            "Protocol_cpp.template",
-            "ErrorSupport_cpp.template",
-            "Values_cpp.template",
-            "Object_cpp.template",
-            "DispatcherBase_cpp.template",
-            "Parser_cpp.template",
-            "encoding_cpp.template",
-        ]
-
-        forward_h_templates = [
-            "Forward_h.template",
-            "Allocator_h.template",
-            "FrontendChannel_h.template",
-        ]
-
-        base_string_adapter_h_templates = [
-            "base_string_adapter_h.template",
-        ]
-
-        base_string_adapter_cc_templates = [
-            "base_string_adapter_cc.template",
-        ]
-
-        def generate_lib_file(file_name, template_files):
-            parts = []
-            for template_file in template_files:
-                inputs.append(os.path.join(lib_templates_dir, template_file))
-                template = jinja_env.get_template("lib/" + template_file)
-                parts.append(template.render(template_context))
-            outputs[file_name] = "\n\n".join(parts)
-
-        generate_lib_file(os.path.join(config.lib.output, to_file_name(config, "Forward.h")), forward_h_templates)
-        generate_lib_file(os.path.join(config.lib.output, to_file_name(config, "Protocol.h")), protocol_h_templates)
-        generate_lib_file(os.path.join(config.lib.output, to_file_name(config, "Protocol.cpp")), protocol_cpp_templates)
-        generate_lib_file(os.path.join(config.lib.output, to_file_name(config, "base_string_adapter.h")), base_string_adapter_h_templates)
-        generate_lib_file(os.path.join(config.lib.output, to_file_name(config, "base_string_adapter.cc")), base_string_adapter_cc_templates)
-
-    # Make gyp / make generatos happy, otherwise make rebuilds world.
-    inputs_ts = max(map(os.path.getmtime, inputs))
-    up_to_date = True
-    for output_file in outputs.keys():
-        if not os.path.exists(output_file) or os.path.getmtime(output_file) < inputs_ts:
-            up_to_date = False
-            break
-    if up_to_date:
-        sys.exit()
-
-    for file_name, content in outputs.items():
-        out_file = open(file_name, "w")
-        out_file.write(content)
-        out_file.close()
-
-
-main()
+if __name__ == "__main__":
+  main()
diff --git a/tools/inspector_protocol/concatenate_protocols.py b/tools/inspector_protocol/concatenate_protocols.py
index e9f448efe72702..11f1fed06c49f6 100755
--- a/tools/inspector_protocol/concatenate_protocols.py
+++ b/tools/inspector_protocol/concatenate_protocols.py
@@ -1,5 +1,5 @@
-#!/usr/bin/env python
-# Copyright 2016 The Chromium Authors. All rights reserved.
+#!/usr/bin/env python3
+# Copyright 2016 The Chromium Authors
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
@@ -7,33 +7,36 @@
 import sys
 
 try:
-    import json
+  import json
 except ImportError:
-    import simplejson as json
+  import simplejson as json
 
 import pdl
 
 def main(argv):
-    if len(argv) < 1:
-        sys.stderr.write("Usage: %s <protocol-1> [<protocol-2> [, <protocol-3>...]] <output-file>\n" % sys.argv[0])
-        return 1
-
-    domains = []
-    version = None
-    for protocol in argv[:-1]:
-        file_name = os.path.normpath(protocol)
-        if not os.path.isfile(file_name):
-            sys.stderr.write("Cannot find %s\n" % file_name)
-            return 1
-        input_file = open(file_name, "r")
-        parsed_json = pdl.loads(input_file.read(), file_name)
-        domains += parsed_json["domains"]
-        version = parsed_json["version"]
-
-    output_file = open(argv[-1], "w")
-    json.dump({"version": version, "domains": domains}, output_file, indent=4, sort_keys=False, separators=(',', ': '))
-    output_file.close()
+  if len(argv) < 1:
+    sys.stderr.write(
+        "Usage: %s <protocol-1> [<protocol-2> [, <protocol-3>...]] "
+        "<output-file>\n" % sys.argv[0])
+    return 1
+
+  domains = []
+  version = None
+  for protocol in argv[:-1]:
+    file_name = os.path.normpath(protocol)
+    if not os.path.isfile(file_name):
+      sys.stderr.write("Cannot find %s\n" % file_name)
+      return 1
+    input_file = open(file_name, "r")
+    parsed_json = pdl.loads(input_file.read(), file_name)
+    domains += parsed_json["domains"]
+    version = parsed_json["version"]
+
+  output_file = open(argv[-1], "w")
+  json.dump({"version": version, "domains": domains}, output_file,
+            indent=4, sort_keys=False, separators=(',', ': '))
+  output_file.close()
 
 
 if __name__ == '__main__':
-    sys.exit(main(sys.argv[1:]))
+  sys.exit(main(sys.argv[1:]))
diff --git a/tools/inspector_protocol/convert_protocol_to_json.py b/tools/inspector_protocol/convert_protocol_to_json.py
index 835e6387120bcc..e31dd7f127e151 100755
--- a/tools/inspector_protocol/convert_protocol_to_json.py
+++ b/tools/inspector_protocol/convert_protocol_to_json.py
@@ -1,5 +1,5 @@
-#!/usr/bin/env python
-# Copyright 2017 The Chromium Authors. All rights reserved.
+#!/usr/bin/env python3
+# Copyright 2017 The Chromium Authors
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
@@ -10,6 +10,13 @@
 
 import pdl
 
+def open_to_write(path):
+    if sys.version_info >= (3,0):
+        return open(path, 'w', encoding='utf-8')
+    else:
+        return open(path, 'wb')
+
+
 def main(argv):
     parser = argparse.ArgumentParser(description=(
         "Converts from .pdl to .json by invoking the pdl Python module."))
@@ -21,12 +28,13 @@ def main(argv):
     parser.add_argument("json_file", help="The .json output file write.")
     args = parser.parse_args(argv)
     file_name = os.path.normpath(args.pdl_file)
-    with open(file_name, "r") as input_file:
-        pdl_string = input_file.read()
+    input_file = open(file_name, "r")
+    pdl_string = input_file.read()
     protocol = pdl.loads(pdl_string, file_name, args.map_binary_to_string)
-
-    with open(os.path.normpath(args.json_file), 'w') as output_file:
-        json.dump(protocol, output_file, indent=4, separators=(',', ': '))
+    input_file.close()
+    output_file = open_to_write(os.path.normpath(args.json_file))
+    json.dump(protocol, output_file, indent=4, separators=(',', ': '))
+    output_file.close()
 
 
 if __name__ == '__main__':
diff --git a/tools/inspector_protocol/crdtp/README.md b/tools/inspector_protocol/crdtp/README.md
new file mode 100644
index 00000000000000..a9bbc9e8865fd2
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/README.md
@@ -0,0 +1,114 @@
+# CRDTP - Chrome DevTools Protocol Library.
+
+[Canonical location for this library.](https://chromium.googlesource.com/deps/inspector_protocol/+/refs/heads/main)
+
+This is a support library for the Chrome DevTools protocol implementation.
+
+It's used from within the Jinja templates which we use for code generation
+(see ../lib and ../templates) as well as from Chromium (headless,
+chrome, content, blink), V8, and other code bases that use the DevTools
+protocol.
+
+The library is designed to be portable. The only allowed dependencies are:
+
+- The C/C++ standard libraries, up to C++14.
+  The litmus test is that it compiles and passes tests for all platforms
+  supported by V8.
+
+- For testing, we depend on mini_chromium and gtest. This is isolated
+  into the `crdtp/test_platform.{h,cc}` library.
+
+We support 32 bit and 64 bit architectures.
+
+# Common types used in this library.
+
+- `uint8_t`: a byte, e.g. for raw bytes or UTF8 characters
+
+- `uint16_t`: two bytes, e.g. for UTF16 characters
+
+For input parameters:
+
+- `span<uint8_t>`: pointer to bytes and length
+
+- `span<uint16_t>`: pointer to UTF16 chars and length
+
+For output parameters:
+
+- `std::vector<uint8_t>` - Owned segment of bytes / utf8 characters and length.
+
+- `std::string` - Same, for compatibility, even though char is signed.
+
+# Building and running the tests.
+
+If you're familiar with
+[Chromium's development process](https://www.chromium.org/developers/contributing-code)
+and have the depot_tools installed, you may use these commands
+to fetch the package (and dependencies) and build and run the tests:
+
+    fetch inspector_protocol
+    cd src
+    gn gen out/Release
+    ninja -C out/Release crdtp_test
+    out/Release/crdtp_test
+
+You'll probably also need to install g++, since Clang uses this to find the
+standard C++ headers. E.g.,
+
+    sudo apt-get install g++-8
+
+# Purpose of the tests
+
+crdtp comes with unittest coverage.
+
+Upstream, in this standalone package, the unittests make development
+more pleasant because they are very fast and light (try the previous
+section to see).
+
+Downstream (in Chromium, V8, etc.), they ensure that the library behaves
+correctly within each specific code base. We have seen bugs from different
+architectures / compilers / etc. in the past. We have also seen
+that a tweaked downstream crdtp_platform library did not behave correctly,
+becaues V8's strtod routine interprets out of range literals as 'inf'.
+Thus, the unittests function as a conformance test suite for such code-base
+specific tweaks downstream.
+
+# Customization by downstream users (Chrome, V8, google3, etc.).
+
+Downstream users may need to customize the library. We isolate these typical
+customizations into two platform libraries (crdtp_plaform and
+crdtp_test_platform), to reduce the chance of merge conflicts and grief when
+rolling as much as possible. While customized platform libraries may
+depend on the downstream code base (e.g. abseil, Chromium's base, V8's utility
+functions, Boost, etc.), they are not exposed to the headers that
+downstream code depends on.
+
+## crdtp_platform
+
+This platform library is only used by the crdtp library; it is not part of the
+crdtp API. Thus far it consists only of json_platform.h and json_platform.cc,
+because conversion between a `std::string` and a double is tricky, and different
+code bases have different preferences in this regard. In this repository
+(upstream), json_platform.cc provides a reference implementation which uses the
+C++ standard library.
+
+Downstream, in Chromium, json_platform_chromium.cc has a different
+implementation that uses the routines in Chromium's //base, that is, it's a .cc
+file that's specific to Chromium. Similarly, in V8, json_platform_v8.cc uses
+V8's number conversion utilities, so it's a .cc file that's specific to V8. And
+in google3, we use the absl library. crdtp/json_platform.cc is designed to be
+easy to modify or replace, and the interface defined by its header is designed
+to be stable.
+
+## crdtp_test_platform
+
+This platform library is only used by the tests. Upstream, it's setup to
+use mini_chromium and gtest. Downstream, Chromium uses its //base libraries,
+and V8 uses theirs; and a small amount of tweaking is needed in each code
+base - e.g., Chromium, V8, and google3 each place `#include` declarations into
+test_platform.h that are specific to their code base, and they have their
+own routines in test_platform.cc which uses their own libraries.
+
+The purpose of crdtp_test_platform is to isolate the tweaking to this small,
+stable library (modifying test_platform.h and test_platform.cc). This avoids
+having to modify the actual tests (json_test.cc, cbor_test.cc, ...)
+when rolling changes downstream. We try to not use patch files.
diff --git a/tools/inspector_protocol/crdtp/cbor.cc b/tools/inspector_protocol/crdtp/cbor.cc
new file mode 100644
index 00000000000000..801c1708022763
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/cbor.cc
@@ -0,0 +1,1078 @@
+// Copyright 2019 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "cbor.h"
+
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <cstring>
+#include <limits>
+#include <stack>
+
+namespace crdtp {
+namespace cbor {
+namespace {
+// Indicates the number of bits the "initial byte" needs to be shifted to the
+// right after applying |kMajorTypeMask| to produce the major type in the
+// lowermost bits.
+static constexpr uint8_t kMajorTypeBitShift = 5u;
+// Mask selecting the low-order 5 bits of the "initial byte", which is where
+// the additional information is encoded.
+static constexpr uint8_t kAdditionalInformationMask = 0x1f;
+// Mask selecting the high-order 3 bits of the "initial byte", which indicates
+// the major type of the encoded value.
+static constexpr uint8_t kMajorTypeMask = 0xe0;
+// Indicates the integer is in the following byte.
+static constexpr uint8_t kAdditionalInformation1Byte = 24u;
+// Indicates the integer is in the next 2 bytes.
+static constexpr uint8_t kAdditionalInformation2Bytes = 25u;
+// Indicates the integer is in the next 4 bytes.
+static constexpr uint8_t kAdditionalInformation4Bytes = 26u;
+// Indicates the integer is in the next 8 bytes.
+static constexpr uint8_t kAdditionalInformation8Bytes = 27u;
+
+// Encodes the initial byte, consisting of the |type| in the first 3 bits
+// followed by 5 bits of |additional_info|.
+constexpr uint8_t EncodeInitialByte(MajorType type, uint8_t additional_info) {
+  return (static_cast<uint8_t>(type) << kMajorTypeBitShift) |
+         (additional_info & kAdditionalInformationMask);
+}
+
+// TAG 24 indicates that what follows is a byte string which is
+// encoded in CBOR format. We use this as a wrapper for
+// maps and arrays, allowing us to skip them, because the
+// byte string carries its size (byte length).
+// https://tools.ietf.org/html/rfc7049#section-2.4.4.1
+static constexpr uint8_t kInitialByteForEnvelope =
+    EncodeInitialByte(MajorType::TAG, kAdditionalInformation1Byte);
+
+// The standalone byte for "envelope" tag, to follow kInitialByteForEnvelope
+// in the correct implementation, as it is above in-tag value max (which is
+// also, confusingly, 24). See EnvelopeHeader::Parse() for more.
+static constexpr uint8_t kCBOREnvelopeTag = 24;
+
+// The initial byte for a byte string with at most 2^32 bytes
+// of payload. This is used for envelope encoding, even if
+// the byte string is shorter.
+static constexpr uint8_t kInitialByteFor32BitLengthByteString =
+    EncodeInitialByte(MajorType::BYTE_STRING, 26);
+
+// See RFC 7049 Section 2.2.1, indefinite length arrays / maps have additional
+// info = 31.
+static constexpr uint8_t kInitialByteIndefiniteLengthArray =
+    EncodeInitialByte(MajorType::ARRAY, 31);
+static constexpr uint8_t kInitialByteIndefiniteLengthMap =
+    EncodeInitialByte(MajorType::MAP, 31);
+// See RFC 7049 Section 2.3, Table 1; this is used for finishing indefinite
+// length maps / arrays.
+static constexpr uint8_t kStopByte =
+    EncodeInitialByte(MajorType::SIMPLE_VALUE, 31);
+
+// See RFC 7049 Section 2.3, Table 2.
+static constexpr uint8_t kEncodedTrue =
+    EncodeInitialByte(MajorType::SIMPLE_VALUE, 21);
+static constexpr uint8_t kEncodedFalse =
+    EncodeInitialByte(MajorType::SIMPLE_VALUE, 20);
+static constexpr uint8_t kEncodedNull =
+    EncodeInitialByte(MajorType::SIMPLE_VALUE, 22);
+static constexpr uint8_t kInitialByteForDouble =
+    EncodeInitialByte(MajorType::SIMPLE_VALUE, 27);
+
+// See RFC 7049 Table 3 and Section 2.4.4.2. This is used as a prefix for
+// arbitrary binary data encoded as BYTE_STRING.
+static constexpr uint8_t kExpectedConversionToBase64Tag =
+    EncodeInitialByte(MajorType::TAG, 22);
+
+// Writes the bytes for |v| to |out|, starting with the most significant byte.
+// See also: https://commandcenter.blogspot.com/2012/04/byte-order-fallacy.html
+template <typename T>
+void WriteBytesMostSignificantByteFirst(T v, std::vector<uint8_t>* out) {
+  for (int shift_bytes = sizeof(T) - 1; shift_bytes >= 0; --shift_bytes)
+    out->push_back(0xff & (v >> (shift_bytes * 8)));
+}
+
+// Extracts sizeof(T) bytes from |in| to extract a value of type T
+// (e.g. uint64_t, uint32_t, ...), most significant byte first.
+// See also: https://commandcenter.blogspot.com/2012/04/byte-order-fallacy.html
+template <typename T>
+T ReadBytesMostSignificantByteFirst(span<uint8_t> in) {
+  assert(in.size() >= sizeof(T));
+  T result = 0;
+  for (size_t shift_bytes = 0; shift_bytes < sizeof(T); ++shift_bytes)
+    result |= T(in[sizeof(T) - 1 - shift_bytes]) << (shift_bytes * 8);
+  return result;
+}
+}  // namespace
+
+namespace internals {
+// Reads the start of a token with definitive size from |bytes|.
+// |type| is the major type as specified in RFC 7049 Section 2.1.
+// |value| is the payload (e.g. for MajorType::UNSIGNED) or is the size
+// (e.g. for BYTE_STRING).
+// If successful, returns the number of bytes read. Otherwise returns 0.
+size_t ReadTokenStart(span<uint8_t> bytes, MajorType* type, uint64_t* value) {
+  if (bytes.empty())
+    return 0;
+  uint8_t initial_byte = bytes[0];
+  *type = MajorType((initial_byte & kMajorTypeMask) >> kMajorTypeBitShift);
+
+  uint8_t additional_information = initial_byte & kAdditionalInformationMask;
+  if (additional_information < 24) {
+    // Values 0-23 are encoded directly into the additional info of the
+    // initial byte.
+    *value = additional_information;
+    return 1;
+  }
+  if (additional_information == kAdditionalInformation1Byte) {
+    // Values 24-255 are encoded with one initial byte, followed by the value.
+    if (bytes.size() < 2)
+      return 0;
+    *value = ReadBytesMostSignificantByteFirst<uint8_t>(bytes.subspan(1));
+    return 2;
+  }
+  if (additional_information == kAdditionalInformation2Bytes) {
+    // Values 256-65535: 1 initial byte + 2 bytes payload.
+    if (bytes.size() < 1 + sizeof(uint16_t))
+      return 0;
+    *value = ReadBytesMostSignificantByteFirst<uint16_t>(bytes.subspan(1));
+    return 3;
+  }
+  if (additional_information == kAdditionalInformation4Bytes) {
+    // 32 bit uint: 1 initial byte + 4 bytes payload.
+    if (bytes.size() < 1 + sizeof(uint32_t))
+      return 0;
+    *value = ReadBytesMostSignificantByteFirst<uint32_t>(bytes.subspan(1));
+    return 5;
+  }
+  if (additional_information == kAdditionalInformation8Bytes) {
+    // 64 bit uint: 1 initial byte + 8 bytes payload.
+    if (bytes.size() < 1 + sizeof(uint64_t))
+      return 0;
+    *value = ReadBytesMostSignificantByteFirst<uint64_t>(bytes.subspan(1));
+    return 9;
+  }
+  return 0;
+}
+
+// Writes the start of a token with |type|. The |value| may indicate the size,
+// or it may be the payload if the value is an unsigned integer.
+void WriteTokenStart(MajorType type,
+                     uint64_t value,
+                     std::vector<uint8_t>* encoded) {
+  if (value < 24) {
+    // Values 0-23 are encoded directly into the additional info of the
+    // initial byte.
+    encoded->push_back(EncodeInitialByte(type, /*additional_info=*/value));
+    return;
+  }
+  if (value <= std::numeric_limits<uint8_t>::max()) {
+    // Values 24-255 are encoded with one initial byte, followed by the value.
+    encoded->push_back(EncodeInitialByte(type, kAdditionalInformation1Byte));
+    encoded->push_back(value);
+    return;
+  }
+  if (value <= std::numeric_limits<uint16_t>::max()) {
+    // Values 256-65535: 1 initial byte + 2 bytes payload.
+    encoded->push_back(EncodeInitialByte(type, kAdditionalInformation2Bytes));
+    WriteBytesMostSignificantByteFirst<uint16_t>(value, encoded);
+    return;
+  }
+  if (value <= std::numeric_limits<uint32_t>::max()) {
+    // 32 bit uint: 1 initial byte + 4 bytes payload.
+    encoded->push_back(EncodeInitialByte(type, kAdditionalInformation4Bytes));
+    WriteBytesMostSignificantByteFirst<uint32_t>(static_cast<uint32_t>(value),
+                                                 encoded);
+    return;
+  }
+  // 64 bit uint: 1 initial byte + 8 bytes payload.
+  encoded->push_back(EncodeInitialByte(type, kAdditionalInformation8Bytes));
+  WriteBytesMostSignificantByteFirst<uint64_t>(value, encoded);
+}
+}  // namespace internals
+
+// =============================================================================
+// Detecting CBOR content
+// =============================================================================
+
+bool IsCBORMessage(span<uint8_t> msg) {
+  return msg.size() >= 4 && msg[0] == kInitialByteForEnvelope &&
+         (msg[1] == kInitialByteFor32BitLengthByteString ||
+          (msg[1] == kCBOREnvelopeTag &&
+           msg[2] == kInitialByteFor32BitLengthByteString));
+}
+
+Status CheckCBORMessage(span<uint8_t> msg) {
+  if (msg.empty())
+    return Status(Error::CBOR_UNEXPECTED_EOF_IN_ENVELOPE, 0);
+  if (msg[0] != kInitialByteForEnvelope)
+    return Status(Error::CBOR_INVALID_START_BYTE, 0);
+  StatusOr<EnvelopeHeader> status_or_header = EnvelopeHeader::Parse(msg);
+  if (!status_or_header.ok())
+    return status_or_header.status();
+  const size_t pos = (*status_or_header).header_size();
+  assert(pos < msg.size());  // EnvelopeParser would not allow empty envelope.
+  if (msg[pos] != EncodeIndefiniteLengthMapStart())
+    return Status(Error::CBOR_MAP_START_EXPECTED, pos);
+  return Status();
+}
+
+// =============================================================================
+// Encoding invidiual CBOR items
+// =============================================================================
+
+uint8_t EncodeTrue() {
+  return kEncodedTrue;
+}
+
+uint8_t EncodeFalse() {
+  return kEncodedFalse;
+}
+
+uint8_t EncodeNull() {
+  return kEncodedNull;
+}
+
+uint8_t EncodeIndefiniteLengthArrayStart() {
+  return kInitialByteIndefiniteLengthArray;
+}
+
+uint8_t EncodeIndefiniteLengthMapStart() {
+  return kInitialByteIndefiniteLengthMap;
+}
+
+uint8_t EncodeStop() {
+  return kStopByte;
+}
+
+void EncodeInt32(int32_t value, std::vector<uint8_t>* out) {
+  if (value >= 0) {
+    internals::WriteTokenStart(MajorType::UNSIGNED, value, out);
+  } else {
+    uint64_t representation = static_cast<uint64_t>(-(value + 1));
+    internals::WriteTokenStart(MajorType::NEGATIVE, representation, out);
+  }
+}
+
+void EncodeString16(span<uint16_t> in, std::vector<uint8_t>* out) {
+  uint64_t byte_length = static_cast<uint64_t>(in.size_bytes());
+  internals::WriteTokenStart(MajorType::BYTE_STRING, byte_length, out);
+  // When emitting UTF16 characters, we always write the least significant byte
+  // first; this is because it's the native representation for X86.
+  // TODO(johannes): Implement a more efficient thing here later, e.g.
+  // casting *iff* the machine has this byte order.
+  // The wire format for UTF16 chars will probably remain the same
+  // (least significant byte first) since this way we can have
+  // golden files, unittests, etc. that port easily and universally.
+  // See also:
+  // https://commandcenter.blogspot.com/2012/04/byte-order-fallacy.html
+  for (const uint16_t two_bytes : in) {
+    out->push_back(two_bytes);
+    out->push_back(two_bytes >> 8);
+  }
+}
+
+void EncodeString8(span<uint8_t> in, std::vector<uint8_t>* out) {
+  internals::WriteTokenStart(MajorType::STRING,
+                             static_cast<uint64_t>(in.size_bytes()), out);
+  out->insert(out->end(), in.begin(), in.end());
+}
+
+void EncodeFromLatin1(span<uint8_t> latin1, std::vector<uint8_t>* out) {
+  for (size_t ii = 0; ii < latin1.size(); ++ii) {
+    if (latin1[ii] <= 127)
+      continue;
+    // If there's at least one non-ASCII char, convert to UTF8.
+    std::vector<uint8_t> utf8(latin1.begin(), latin1.begin() + ii);
+    for (; ii < latin1.size(); ++ii) {
+      if (latin1[ii] <= 127) {
+        utf8.push_back(latin1[ii]);
+      } else {
+        // 0xC0 means it's a UTF8 sequence with 2 bytes.
+        utf8.push_back((latin1[ii] >> 6) | 0xc0);
+        utf8.push_back((latin1[ii] | 0x80) & 0xbf);
+      }
+    }
+    EncodeString8(SpanFrom(utf8), out);
+    return;
+  }
+  EncodeString8(latin1, out);
+}
+
+void EncodeFromUTF16(span<uint16_t> utf16, std::vector<uint8_t>* out) {
+  // If there's at least one non-ASCII char, encode as STRING16 (UTF16).
+  for (uint16_t ch : utf16) {
+    if (ch <= 127)
+      continue;
+    EncodeString16(utf16, out);
+    return;
+  }
+  // It's all US-ASCII, strip out every second byte and encode as UTF8.
+  internals::WriteTokenStart(MajorType::STRING,
+                             static_cast<uint64_t>(utf16.size()), out);
+  out->insert(out->end(), utf16.begin(), utf16.end());
+}
+
+void EncodeBinary(span<uint8_t> in, std::vector<uint8_t>* out) {
+  out->push_back(kExpectedConversionToBase64Tag);
+  uint64_t byte_length = static_cast<uint64_t>(in.size_bytes());
+  internals::WriteTokenStart(MajorType::BYTE_STRING, byte_length, out);
+  out->insert(out->end(), in.begin(), in.end());
+}
+
+// A double is encoded with a specific initial byte
+// (kInitialByteForDouble) plus the 64 bits of payload for its value.
+constexpr size_t kEncodedDoubleSize = 1 + sizeof(uint64_t);
+
+void EncodeDouble(double value, std::vector<uint8_t>* out) {
+  // The additional_info=27 indicates 64 bits for the double follow.
+  // See RFC 7049 Section 2.3, Table 1.
+  out->push_back(kInitialByteForDouble);
+  union {
+    double from_double;
+    uint64_t to_uint64;
+  } reinterpret;
+  reinterpret.from_double = value;
+  WriteBytesMostSignificantByteFirst<uint64_t>(reinterpret.to_uint64, out);
+}
+
+// =============================================================================
+// cbor::EnvelopeEncoder - for wrapping submessages
+// =============================================================================
+
+void EnvelopeEncoder::EncodeStart(std::vector<uint8_t>* out) {
+  assert(byte_size_pos_ == 0);
+  out->push_back(kInitialByteForEnvelope);
+  out->push_back(kCBOREnvelopeTag);
+  out->push_back(kInitialByteFor32BitLengthByteString);
+  byte_size_pos_ = out->size();
+  out->resize(out->size() + sizeof(uint32_t));
+}
+
+bool EnvelopeEncoder::EncodeStop(std::vector<uint8_t>* out) {
+  assert(byte_size_pos_ != 0);
+  // The byte size is the size of the payload, that is, all the
+  // bytes that were written past the byte size position itself.
+  uint64_t byte_size = out->size() - (byte_size_pos_ + sizeof(uint32_t));
+  // We store exactly 4 bytes, so at most INT32MAX, with most significant
+  // byte first.
+  if (byte_size > std::numeric_limits<uint32_t>::max())
+    return false;
+  for (int shift_bytes = sizeof(uint32_t) - 1; shift_bytes >= 0;
+       --shift_bytes) {
+    (*out)[byte_size_pos_++] = 0xff & (byte_size >> (shift_bytes * 8));
+  }
+  return true;
+}
+
+// static
+StatusOr<EnvelopeHeader> EnvelopeHeader::Parse(span<uint8_t> in) {
+  auto header_or_status = ParseFromFragment(in);
+  if (!header_or_status.ok())
+    return header_or_status;
+  if ((*header_or_status).outer_size() > in.size()) {
+    return StatusOr<EnvelopeHeader>(
+        Status(Error::CBOR_ENVELOPE_CONTENTS_LENGTH_MISMATCH, in.size()));
+  }
+  return header_or_status;
+}
+
+// static
+StatusOr<EnvelopeHeader> EnvelopeHeader::ParseFromFragment(span<uint8_t> in) {
+  // Our copy of StatusOr<> requires explicit constructor.
+  using Ret = StatusOr<EnvelopeHeader>;
+  constexpr size_t kMinEnvelopeSize = 2 + /* for envelope tag */
+                                      1 + /* for byte string */
+                                      1;  /* for contents, a map or an array */
+  if (in.size() < kMinEnvelopeSize)
+    return Ret(Status(Error::CBOR_UNEXPECTED_EOF_IN_ENVELOPE, in.size()));
+  assert(in[0] == kInitialByteForEnvelope);  // Caller should assure that.
+  size_t offset = 1;
+  // TODO(caseq): require this! We're currently accepting both a legacy,
+  // non spec-compliant envelope tag (that this implementation still currently
+  // produces), as well as a well-formed two-byte tag that a correct
+  // implementation should emit.
+  if (in[offset] == kCBOREnvelopeTag)
+    ++offset;
+  MajorType type;
+  uint64_t size;
+  size_t string_header_size =
+      internals::ReadTokenStart(in.subspan(offset), &type, &size);
+  if (!string_header_size)
+    return Ret(Status(Error::CBOR_UNEXPECTED_EOF_IN_ENVELOPE, in.size()));
+  if (type != MajorType::BYTE_STRING)
+    return Ret(Status(Error::CBOR_INVALID_ENVELOPE, offset));
+  // Do not allow empty envelopes -- at least an empty map/array should fit.
+  if (!size) {
+    return Ret(Status(Error::CBOR_MAP_OR_ARRAY_EXPECTED_IN_ENVELOPE,
+                      offset + string_header_size));
+  }
+  if (size > std::numeric_limits<uint32_t>::max())
+    return Ret(Status(Error::CBOR_INVALID_ENVELOPE, offset));
+  offset += string_header_size;
+  return Ret(EnvelopeHeader(offset, static_cast<size_t>(size)));
+}
+
+// =============================================================================
+// cbor::NewCBOREncoder - for encoding from a streaming parser
+// =============================================================================
+
+namespace {
+class CBOREncoder : public ParserHandler {
+ public:
+  CBOREncoder(std::vector<uint8_t>* out, Status* status)
+      : out_(out), status_(status) {
+    *status_ = Status();
+  }
+
+  void HandleMapBegin() override {
+    if (!status_->ok())
+      return;
+    envelopes_.emplace_back();
+    envelopes_.back().EncodeStart(out_);
+    out_->push_back(kInitialByteIndefiniteLengthMap);
+  }
+
+  void HandleMapEnd() override {
+    if (!status_->ok())
+      return;
+    out_->push_back(kStopByte);
+    assert(!envelopes_.empty());
+    if (!envelopes_.back().EncodeStop(out_)) {
+      HandleError(
+          Status(Error::CBOR_ENVELOPE_SIZE_LIMIT_EXCEEDED, out_->size()));
+      return;
+    }
+    envelopes_.pop_back();
+  }
+
+  void HandleArrayBegin() override {
+    if (!status_->ok())
+      return;
+    envelopes_.emplace_back();
+    envelopes_.back().EncodeStart(out_);
+    out_->push_back(kInitialByteIndefiniteLengthArray);
+  }
+
+  void HandleArrayEnd() override {
+    if (!status_->ok())
+      return;
+    out_->push_back(kStopByte);
+    assert(!envelopes_.empty());
+    if (!envelopes_.back().EncodeStop(out_)) {
+      HandleError(
+          Status(Error::CBOR_ENVELOPE_SIZE_LIMIT_EXCEEDED, out_->size()));
+      return;
+    }
+    envelopes_.pop_back();
+  }
+
+  void HandleString8(span<uint8_t> chars) override {
+    if (!status_->ok())
+      return;
+    EncodeString8(chars, out_);
+  }
+
+  void HandleString16(span<uint16_t> chars) override {
+    if (!status_->ok())
+      return;
+    EncodeFromUTF16(chars, out_);
+  }
+
+  void HandleBinary(span<uint8_t> bytes) override {
+    if (!status_->ok())
+      return;
+    EncodeBinary(bytes, out_);
+  }
+
+  void HandleDouble(double value) override {
+    if (!status_->ok())
+      return;
+    EncodeDouble(value, out_);
+  }
+
+  void HandleInt32(int32_t value) override {
+    if (!status_->ok())
+      return;
+    EncodeInt32(value, out_);
+  }
+
+  void HandleBool(bool value) override {
+    if (!status_->ok())
+      return;
+    // See RFC 7049 Section 2.3, Table 2.
+    out_->push_back(value ? kEncodedTrue : kEncodedFalse);
+  }
+
+  void HandleNull() override {
+    if (!status_->ok())
+      return;
+    // See RFC 7049 Section 2.3, Table 2.
+    out_->push_back(kEncodedNull);
+  }
+
+  void HandleError(Status error) override {
+    if (!status_->ok())
+      return;
+    *status_ = error;
+    out_->clear();
+  }
+
+ private:
+  std::vector<uint8_t>* out_;
+  std::vector<EnvelopeEncoder> envelopes_;
+  Status* status_;
+};
+}  // namespace
+
+std::unique_ptr<ParserHandler> NewCBOREncoder(std::vector<uint8_t>* out,
+                                              Status* status) {
+  return std::unique_ptr<ParserHandler>(new CBOREncoder(out, status));
+}
+
+// =============================================================================
+// cbor::CBORTokenizer - for parsing individual CBOR items
+// =============================================================================
+
+CBORTokenizer::CBORTokenizer(span<uint8_t> bytes)
+    : bytes_(bytes), status_(Error::OK, 0) {
+  ReadNextToken();
+}
+
+CBORTokenizer::~CBORTokenizer() {}
+
+CBORTokenTag CBORTokenizer::TokenTag() const {
+  return token_tag_;
+}
+
+void CBORTokenizer::Next() {
+  if (token_tag_ == CBORTokenTag::ERROR_VALUE ||
+      token_tag_ == CBORTokenTag::DONE)
+    return;
+  ReadNextToken();
+}
+
+void CBORTokenizer::EnterEnvelope() {
+  token_byte_length_ = GetEnvelopeHeader().header_size();
+  ReadNextToken();
+}
+
+Status CBORTokenizer::Status() const {
+  return status_;
+}
+
+// The following accessor functions ::GetInt32, ::GetDouble,
+// ::GetString8, ::GetString16WireRep, ::GetBinary, ::GetEnvelopeContents
+// assume that a particular token was recognized in ::ReadNextToken.
+// That's where all the error checking is done. By design,
+// the accessors (assuming the token was recognized) never produce
+// an error.
+
+int32_t CBORTokenizer::GetInt32() const {
+  assert(token_tag_ == CBORTokenTag::INT32);
+  // The range checks happen in ::ReadNextToken().
+  return static_cast<int32_t>(
+      token_start_type_ == MajorType::UNSIGNED
+          ? token_start_internal_value_
+          : -static_cast<int64_t>(token_start_internal_value_) - 1);
+}
+
+double CBORTokenizer::GetDouble() const {
+  assert(token_tag_ == CBORTokenTag::DOUBLE);
+  union {
+    uint64_t from_uint64;
+    double to_double;
+  } reinterpret;
+  reinterpret.from_uint64 = ReadBytesMostSignificantByteFirst<uint64_t>(
+      bytes_.subspan(status_.pos + 1));
+  return reinterpret.to_double;
+}
+
+span<uint8_t> CBORTokenizer::GetString8() const {
+  assert(token_tag_ == CBORTokenTag::STRING8);
+  auto length = static_cast<size_t>(token_start_internal_value_);
+  return bytes_.subspan(status_.pos + (token_byte_length_ - length), length);
+}
+
+span<uint8_t> CBORTokenizer::GetString16WireRep() const {
+  assert(token_tag_ == CBORTokenTag::STRING16);
+  auto length = static_cast<size_t>(token_start_internal_value_);
+  return bytes_.subspan(status_.pos + (token_byte_length_ - length), length);
+}
+
+span<uint8_t> CBORTokenizer::GetBinary() const {
+  assert(token_tag_ == CBORTokenTag::BINARY);
+  auto length = static_cast<size_t>(token_start_internal_value_);
+  return bytes_.subspan(status_.pos + (token_byte_length_ - length), length);
+}
+
+span<uint8_t> CBORTokenizer::GetEnvelope() const {
+  return bytes_.subspan(status_.pos, GetEnvelopeHeader().outer_size());
+}
+
+span<uint8_t> CBORTokenizer::GetEnvelopeContents() const {
+  const EnvelopeHeader& header = GetEnvelopeHeader();
+  return bytes_.subspan(status_.pos + header.header_size(),
+                        header.content_size());
+}
+
+const EnvelopeHeader& CBORTokenizer::GetEnvelopeHeader() const {
+  assert(token_tag_ == CBORTokenTag::ENVELOPE);
+  return envelope_header_;
+}
+
+// All error checking happens in ::ReadNextToken, so that the accessors
+// can avoid having to carry an error return value.
+//
+// With respect to checking the encoded lengths of strings, arrays, etc:
+// On the wire, CBOR uses 1,2,4, and 8 byte unsigned integers, so
+// we initially read them as uint64_t, usually into token_start_internal_value_.
+//
+// However, since these containers have a representation on the machine,
+// we need to do corresponding size computations on the input byte array,
+// output span (e.g. the payload for a string), etc., and size_t is
+// machine specific (in practice either 32 bit or 64 bit).
+//
+// Further, we must avoid overflowing size_t. Therefore, we use this
+// kMaxValidLength constant to:
+// - Reject values that are larger than the architecture specific
+//   max size_t (differs between 32 bit and 64 bit arch).
+// - Reserve at least one bit so that we can check against overflows
+//   when adding lengths (array / string length / etc.); we do this by
+//   ensuring that the inputs to an addition are <= kMaxValidLength,
+//   and then checking whether the sum went past it.
+//
+// See also
+// https://chromium.googlesource.com/chromium/src/+/main/docs/security/integer-semantics.md
+static const uint64_t kMaxValidLength =
+    std::min<uint64_t>(std::numeric_limits<uint64_t>::max() >> 2,
+                       std::numeric_limits<size_t>::max());
+
+void CBORTokenizer::ReadNextToken() {
+  status_.pos += token_byte_length_;
+  status_.error = Error::OK;
+  envelope_header_ = EnvelopeHeader();
+  if (status_.pos >= bytes_.size()) {
+    token_tag_ = CBORTokenTag::DONE;
+    return;
+  }
+  const size_t remaining_bytes = bytes_.size() - status_.pos;
+  switch (bytes_[status_.pos]) {
+    case kStopByte:
+      SetToken(CBORTokenTag::STOP, 1);
+      return;
+    case kInitialByteIndefiniteLengthMap:
+      SetToken(CBORTokenTag::MAP_START, 1);
+      return;
+    case kInitialByteIndefiniteLengthArray:
+      SetToken(CBORTokenTag::ARRAY_START, 1);
+      return;
+    case kEncodedTrue:
+      SetToken(CBORTokenTag::TRUE_VALUE, 1);
+      return;
+    case kEncodedFalse:
+      SetToken(CBORTokenTag::FALSE_VALUE, 1);
+      return;
+    case kEncodedNull:
+      SetToken(CBORTokenTag::NULL_VALUE, 1);
+      return;
+    case kExpectedConversionToBase64Tag: {  // BINARY
+      const size_t bytes_read = internals::ReadTokenStart(
+          bytes_.subspan(status_.pos + 1), &token_start_type_,
+          &token_start_internal_value_);
+      if (!bytes_read || token_start_type_ != MajorType::BYTE_STRING ||
+          token_start_internal_value_ > kMaxValidLength) {
+        SetError(Error::CBOR_INVALID_BINARY);
+        return;
+      }
+      const uint64_t token_byte_length = token_start_internal_value_ +
+                                         /* tag before token start: */ 1 +
+                                         /* token start: */ bytes_read;
+      if (token_byte_length > remaining_bytes) {
+        SetError(Error::CBOR_INVALID_BINARY);
+        return;
+      }
+      SetToken(CBORTokenTag::BINARY, static_cast<size_t>(token_byte_length));
+      return;
+    }
+    case kInitialByteForDouble: {  // DOUBLE
+      if (kEncodedDoubleSize > remaining_bytes) {
+        SetError(Error::CBOR_INVALID_DOUBLE);
+        return;
+      }
+      SetToken(CBORTokenTag::DOUBLE, kEncodedDoubleSize);
+      return;
+    }
+    case kInitialByteForEnvelope: {  // ENVELOPE
+      StatusOr<EnvelopeHeader> status_or_header =
+          EnvelopeHeader::Parse(bytes_.subspan(status_.pos));
+      if (!status_or_header.ok()) {
+        status_.pos += status_or_header.status().pos;
+        SetError(status_or_header.status().error);
+        return;
+      }
+      assert((*status_or_header).outer_size() <= remaining_bytes);
+      envelope_header_ = *status_or_header;
+      SetToken(CBORTokenTag::ENVELOPE, envelope_header_.outer_size());
+      return;
+    }
+    default: {
+      const size_t bytes_read = internals::ReadTokenStart(
+          bytes_.subspan(status_.pos), &token_start_type_,
+          &token_start_internal_value_);
+      switch (token_start_type_) {
+        case MajorType::UNSIGNED:  // INT32.
+          // INT32 is a signed int32 (int32 makes sense for the
+          // inspector protocol, it's not a CBOR limitation), so we check
+          // against the signed max, so that the allowable values are
+          // 0, 1, 2, ... 2^31 - 1.
+          if (!bytes_read ||
+              static_cast<uint64_t>(std::numeric_limits<int32_t>::max()) <
+                  static_cast<uint64_t>(token_start_internal_value_)) {
+            SetError(Error::CBOR_INVALID_INT32);
+            return;
+          }
+          SetToken(CBORTokenTag::INT32, bytes_read);
+          return;
+        case MajorType::NEGATIVE: {  // INT32.
+          // INT32 is a signed int32 (int32 makes sense for the
+          // inspector protocol, it's not a CBOR limitation); in CBOR, the
+          // negative values for INT32 are represented as NEGATIVE, that is, -1
+          // INT32 is represented as 1 << 5 | 0 (major type 1, additional info
+          // value 0).
+          // The represented allowed values range is -1 to -2^31.
+          // They are mapped into the encoded range of 0 to 2^31-1.
+          // We check the payload in token_start_internal_value_ against
+          // that range (2^31-1 is also known as
+          // std::numeric_limits<int32_t>::max()).
+          if (!bytes_read ||
+              static_cast<uint64_t>(token_start_internal_value_) >
+                  static_cast<uint64_t>(std::numeric_limits<int32_t>::max())) {
+            SetError(Error::CBOR_INVALID_INT32);
+            return;
+          }
+          SetToken(CBORTokenTag::INT32, bytes_read);
+          return;
+        }
+        case MajorType::STRING: {  // STRING8.
+          if (!bytes_read || token_start_internal_value_ > kMaxValidLength) {
+            SetError(Error::CBOR_INVALID_STRING8);
+            return;
+          }
+          uint64_t token_byte_length = token_start_internal_value_ + bytes_read;
+          if (token_byte_length > remaining_bytes) {
+            SetError(Error::CBOR_INVALID_STRING8);
+            return;
+          }
+          SetToken(CBORTokenTag::STRING8,
+                   static_cast<size_t>(token_byte_length));
+          return;
+        }
+        case MajorType::BYTE_STRING: {  // STRING16.
+          // Length must be divisible by 2 since UTF16 is 2 bytes per
+          // character, hence the &1 check.
+          if (!bytes_read || token_start_internal_value_ > kMaxValidLength ||
+              token_start_internal_value_ & 1) {
+            SetError(Error::CBOR_INVALID_STRING16);
+            return;
+          }
+          uint64_t token_byte_length = token_start_internal_value_ + bytes_read;
+          if (token_byte_length > remaining_bytes) {
+            SetError(Error::CBOR_INVALID_STRING16);
+            return;
+          }
+          SetToken(CBORTokenTag::STRING16,
+                   static_cast<size_t>(token_byte_length));
+          return;
+        }
+        case MajorType::ARRAY:
+        case MajorType::MAP:
+        case MajorType::TAG:
+        case MajorType::SIMPLE_VALUE:
+          SetError(Error::CBOR_UNSUPPORTED_VALUE);
+          return;
+      }
+    }
+  }
+}
+
+void CBORTokenizer::SetToken(CBORTokenTag token_tag, size_t token_byte_length) {
+  token_tag_ = token_tag;
+  token_byte_length_ = token_byte_length;
+}
+
+void CBORTokenizer::SetError(Error error) {
+  token_tag_ = CBORTokenTag::ERROR_VALUE;
+  status_.error = error;
+}
+
+// =============================================================================
+// cbor::ParseCBOR - for receiving streaming parser events for CBOR messages
+// =============================================================================
+
+namespace {
+// When parsing CBOR, we limit recursion depth for objects and arrays
+// to this constant.
+static constexpr int kStackLimit = 300;
+
+// Below are three parsing routines for CBOR, which cover enough
+// to roundtrip JSON messages.
+bool ParseMap(int32_t stack_depth,
+              CBORTokenizer* tokenizer,
+              ParserHandler* out);
+bool ParseArray(int32_t stack_depth,
+                CBORTokenizer* tokenizer,
+                ParserHandler* out);
+bool ParseValue(int32_t stack_depth,
+                CBORTokenizer* tokenizer,
+                ParserHandler* out);
+
+void ParseUTF16String(CBORTokenizer* tokenizer, ParserHandler* out) {
+  std::vector<uint16_t> value;
+  span<uint8_t> rep = tokenizer->GetString16WireRep();
+  for (size_t ii = 0; ii < rep.size(); ii += 2)
+    value.push_back((rep[ii + 1] << 8) | rep[ii]);
+  out->HandleString16(span<uint16_t>(value.data(), value.size()));
+  tokenizer->Next();
+}
+
+bool ParseUTF8String(CBORTokenizer* tokenizer, ParserHandler* out) {
+  assert(tokenizer->TokenTag() == CBORTokenTag::STRING8);
+  out->HandleString8(tokenizer->GetString8());
+  tokenizer->Next();
+  return true;
+}
+
+bool ParseEnvelope(int32_t stack_depth,
+                   CBORTokenizer* tokenizer,
+                   ParserHandler* out) {
+  assert(tokenizer->TokenTag() == CBORTokenTag::ENVELOPE);
+  // Before we enter the envelope, we save the position that we
+  // expect to see after we're done parsing the envelope contents.
+  // This way we can compare and produce an error if the contents
+  // didn't fit exactly into the envelope length.
+  size_t pos_past_envelope =
+      tokenizer->Status().pos + tokenizer->GetEnvelopeHeader().outer_size();
+  tokenizer->EnterEnvelope();
+  switch (tokenizer->TokenTag()) {
+    case CBORTokenTag::ERROR_VALUE:
+      out->HandleError(tokenizer->Status());
+      return false;
+    case CBORTokenTag::MAP_START:
+      if (!ParseMap(stack_depth + 1, tokenizer, out))
+        return false;
+      break;  // Continue to check pos_past_envelope below.
+    case CBORTokenTag::ARRAY_START:
+      if (!ParseArray(stack_depth + 1, tokenizer, out))
+        return false;
+      break;  // Continue to check pos_past_envelope below.
+    default:
+      out->HandleError(Status{Error::CBOR_MAP_OR_ARRAY_EXPECTED_IN_ENVELOPE,
+                              tokenizer->Status().pos});
+      return false;
+  }
+  // The contents of the envelope parsed OK, now check that we're at
+  // the expected position.
+  if (pos_past_envelope != tokenizer->Status().pos) {
+    out->HandleError(Status{Error::CBOR_ENVELOPE_CONTENTS_LENGTH_MISMATCH,
+                            tokenizer->Status().pos});
+    return false;
+  }
+  return true;
+}
+
+bool ParseValue(int32_t stack_depth,
+                CBORTokenizer* tokenizer,
+                ParserHandler* out) {
+  if (stack_depth > kStackLimit) {
+    out->HandleError(
+        Status{Error::CBOR_STACK_LIMIT_EXCEEDED, tokenizer->Status().pos});
+    return false;
+  }
+  switch (tokenizer->TokenTag()) {
+    case CBORTokenTag::ERROR_VALUE:
+      out->HandleError(tokenizer->Status());
+      return false;
+    case CBORTokenTag::DONE:
+      out->HandleError(Status{Error::CBOR_UNEXPECTED_EOF_EXPECTED_VALUE,
+                              tokenizer->Status().pos});
+      return false;
+    case CBORTokenTag::ENVELOPE:
+      return ParseEnvelope(stack_depth, tokenizer, out);
+    case CBORTokenTag::TRUE_VALUE:
+      out->HandleBool(true);
+      tokenizer->Next();
+      return true;
+    case CBORTokenTag::FALSE_VALUE:
+      out->HandleBool(false);
+      tokenizer->Next();
+      return true;
+    case CBORTokenTag::NULL_VALUE:
+      out->HandleNull();
+      tokenizer->Next();
+      return true;
+    case CBORTokenTag::INT32:
+      out->HandleInt32(tokenizer->GetInt32());
+      tokenizer->Next();
+      return true;
+    case CBORTokenTag::DOUBLE:
+      out->HandleDouble(tokenizer->GetDouble());
+      tokenizer->Next();
+      return true;
+    case CBORTokenTag::STRING8:
+      return ParseUTF8String(tokenizer, out);
+    case CBORTokenTag::STRING16:
+      ParseUTF16String(tokenizer, out);
+      return true;
+    case CBORTokenTag::BINARY: {
+      out->HandleBinary(tokenizer->GetBinary());
+      tokenizer->Next();
+      return true;
+    }
+    case CBORTokenTag::MAP_START:
+      return ParseMap(stack_depth + 1, tokenizer, out);
+    case CBORTokenTag::ARRAY_START:
+      return ParseArray(stack_depth + 1, tokenizer, out);
+    default:
+      out->HandleError(
+          Status{Error::CBOR_UNSUPPORTED_VALUE, tokenizer->Status().pos});
+      return false;
+  }
+}
+
+// |bytes| must start with the indefinite length array byte, so basically,
+// ParseArray may only be called after an indefinite length array has been
+// detected.
+bool ParseArray(int32_t stack_depth,
+                CBORTokenizer* tokenizer,
+                ParserHandler* out) {
+  assert(tokenizer->TokenTag() == CBORTokenTag::ARRAY_START);
+  tokenizer->Next();
+  out->HandleArrayBegin();
+  while (tokenizer->TokenTag() != CBORTokenTag::STOP) {
+    if (tokenizer->TokenTag() == CBORTokenTag::DONE) {
+      out->HandleError(
+          Status{Error::CBOR_UNEXPECTED_EOF_IN_ARRAY, tokenizer->Status().pos});
+      return false;
+    }
+    if (tokenizer->TokenTag() == CBORTokenTag::ERROR_VALUE) {
+      out->HandleError(tokenizer->Status());
+      return false;
+    }
+    // Parse value.
+    if (!ParseValue(stack_depth, tokenizer, out))
+      return false;
+  }
+  out->HandleArrayEnd();
+  tokenizer->Next();
+  return true;
+}
+
+// |bytes| must start with the indefinite length array byte, so basically,
+// ParseArray may only be called after an indefinite length array has been
+// detected.
+bool ParseMap(int32_t stack_depth,
+              CBORTokenizer* tokenizer,
+              ParserHandler* out) {
+  assert(tokenizer->TokenTag() == CBORTokenTag::MAP_START);
+  out->HandleMapBegin();
+  tokenizer->Next();
+  while (tokenizer->TokenTag() != CBORTokenTag::STOP) {
+    if (tokenizer->TokenTag() == CBORTokenTag::DONE) {
+      out->HandleError(
+          Status{Error::CBOR_UNEXPECTED_EOF_IN_MAP, tokenizer->Status().pos});
+      return false;
+    }
+    if (tokenizer->TokenTag() == CBORTokenTag::ERROR_VALUE) {
+      out->HandleError(tokenizer->Status());
+      return false;
+    }
+    // Parse key.
+    if (tokenizer->TokenTag() == CBORTokenTag::STRING8) {
+      if (!ParseUTF8String(tokenizer, out))
+        return false;
+    } else if (tokenizer->TokenTag() == CBORTokenTag::STRING16) {
+      ParseUTF16String(tokenizer, out);
+    } else {
+      out->HandleError(
+          Status{Error::CBOR_INVALID_MAP_KEY, tokenizer->Status().pos});
+      return false;
+    }
+    // Parse value.
+    if (!ParseValue(stack_depth, tokenizer, out))
+      return false;
+  }
+  out->HandleMapEnd();
+  tokenizer->Next();
+  return true;
+}
+}  // namespace
+
+void ParseCBOR(span<uint8_t> bytes, ParserHandler* out) {
+  if (bytes.empty()) {
+    out->HandleError(Status{Error::CBOR_UNEXPECTED_EOF_IN_ENVELOPE, 0});
+    return;
+  }
+  CBORTokenizer tokenizer(bytes);
+  if (tokenizer.TokenTag() == CBORTokenTag::ERROR_VALUE) {
+    out->HandleError(tokenizer.Status());
+    return;
+  }
+  if (!ParseValue(/*stack_depth=*/0, &tokenizer, out))
+    return;
+  if (tokenizer.TokenTag() == CBORTokenTag::DONE)
+    return;
+  if (tokenizer.TokenTag() == CBORTokenTag::ERROR_VALUE) {
+    out->HandleError(tokenizer.Status());
+    return;
+  }
+  out->HandleError(Status{Error::CBOR_TRAILING_JUNK, tokenizer.Status().pos});
+}
+
+// =============================================================================
+// cbor::AppendString8EntryToMap - for limited in-place editing of messages
+// =============================================================================
+
+Status AppendString8EntryToCBORMap(span<uint8_t> string8_key,
+                                   span<uint8_t> string8_value,
+                                   std::vector<uint8_t>* cbor) {
+  span<uint8_t> bytes(cbor->data(), cbor->size());
+  CBORTokenizer tokenizer(bytes);
+  if (tokenizer.TokenTag() == CBORTokenTag::ERROR_VALUE)
+    return tokenizer.Status();
+  if (tokenizer.TokenTag() != CBORTokenTag::ENVELOPE)
+    return Status(Error::CBOR_INVALID_ENVELOPE, 0);
+  EnvelopeHeader env_header = tokenizer.GetEnvelopeHeader();
+  size_t old_size = cbor->size();
+  if (old_size != env_header.outer_size())
+    return Status(Error::CBOR_INVALID_ENVELOPE, 0);
+  assert(env_header.content_size() > 0);
+  if (tokenizer.GetEnvelopeContents()[0] != EncodeIndefiniteLengthMapStart())
+    return Status(Error::CBOR_MAP_START_EXPECTED, env_header.header_size());
+  if (bytes[bytes.size() - 1] != EncodeStop())
+    return Status(Error::CBOR_MAP_STOP_EXPECTED, cbor->size() - 1);
+  // We generally accept envelope headers with size specified in all possible
+  // widths, but when it comes to modifying, we only support the fixed 4 byte
+  // widths that we produce.
+  const size_t byte_string_pos = bytes[1] == kCBOREnvelopeTag ? 2 : 1;
+  if (bytes[byte_string_pos] != kInitialByteFor32BitLengthByteString)
+    return Status(Error::CBOR_INVALID_ENVELOPE, byte_string_pos);
+  cbor->pop_back();
+  EncodeString8(string8_key, cbor);
+  EncodeString8(string8_value, cbor);
+  cbor->push_back(EncodeStop());
+  size_t new_envelope_size =
+      env_header.content_size() + (cbor->size() - old_size);
+  if (new_envelope_size > std::numeric_limits<uint32_t>::max())
+    return Status(Error::CBOR_ENVELOPE_SIZE_LIMIT_EXCEEDED, 0);
+  std::vector<uint8_t>::iterator out =
+      cbor->begin() + env_header.header_size() - sizeof(int32_t);
+  *(out++) = (new_envelope_size >> 24) & 0xff;
+  *(out++) = (new_envelope_size >> 16) & 0xff;
+  *(out++) = (new_envelope_size >> 8) & 0xff;
+  *(out) = new_envelope_size & 0xff;
+  return Status();
+}
+}  // namespace cbor
+}  // namespace crdtp
diff --git a/tools/inspector_protocol/crdtp/cbor.h b/tools/inspector_protocol/crdtp/cbor.h
new file mode 100644
index 00000000000000..471aa78e605298
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/cbor.h
@@ -0,0 +1,329 @@
+// Copyright 2019 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CRDTP_CBOR_H_
+#define CRDTP_CBOR_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "export.h"
+#include "parser_handler.h"
+#include "span.h"
+
+namespace crdtp {
+namespace cbor {
+// The binary encoding for the inspector protocol follows the CBOR specification
+// (RFC 7049). Additional constraints:
+// - Only indefinite length maps and arrays are supported.
+// - Maps and arrays are wrapped with an envelope, that is, a
+//   CBOR tag with value 24 followed by a byte string specifying
+//   the byte length of the enclosed map / array. The byte string
+//   must use a 32 bit wide length.
+// - At the top level, a message must be an indefinite length map
+//   wrapped by an envelope.
+// - Maximal size for messages is 2^32 (4 GB).
+// - For scalars, we support only the int32_t range, encoded as
+//   UNSIGNED/NEGATIVE (major types 0 / 1).
+// - UTF16 strings, including with unbalanced surrogate pairs, are encoded
+//   as CBOR BYTE_STRING (major type 2). For such strings, the number of
+//   bytes encoded must be even.
+// - UTF8 strings (major type 3) are supported.
+// - 7 bit US-ASCII strings must always be encoded as UTF8 strings, never
+//   as UTF16 strings.
+// - Arbitrary byte arrays, in the inspector protocol called 'binary',
+//   are encoded as BYTE_STRING (major type 2), prefixed with a byte
+//   indicating base64 when rendered as JSON.
+
+// =============================================================================
+// Detecting CBOR content
+// =============================================================================
+
+// Checks whether |msg| is a cbor message.
+CRDTP_EXPORT bool IsCBORMessage(span<uint8_t> msg);
+
+// Performs a leightweight check of |msg|.
+// Disallows:
+// - Empty message
+// - Not starting with the two bytes 0xd8, 0x5a
+// - Empty envelope (all length bytes are 0)
+// - Not starting with a map after the envelope stanza
+// DevTools messages should pass this check.
+CRDTP_EXPORT Status CheckCBORMessage(span<uint8_t> msg);
+
+// =============================================================================
+// Encoding individual CBOR items
+// =============================================================================
+
+// Some constants for CBOR tokens that only take a single byte on the wire.
+CRDTP_EXPORT uint8_t EncodeTrue();
+CRDTP_EXPORT uint8_t EncodeFalse();
+CRDTP_EXPORT uint8_t EncodeNull();
+CRDTP_EXPORT uint8_t EncodeIndefiniteLengthArrayStart();
+CRDTP_EXPORT uint8_t EncodeIndefiniteLengthMapStart();
+CRDTP_EXPORT uint8_t EncodeStop();
+
+// Encodes |value| as |UNSIGNED| (major type 0) iff >= 0, or |NEGATIVE|
+// (major type 1) iff < 0.
+CRDTP_EXPORT void EncodeInt32(int32_t value, std::vector<uint8_t>* out);
+
+// Encodes a UTF16 string as a BYTE_STRING (major type 2). Each utf16
+// character in |in| is emitted with most significant byte first,
+// appending to |out|.
+CRDTP_EXPORT void EncodeString16(span<uint16_t> in, std::vector<uint8_t>* out);
+
+// Encodes a UTF8 string |in| as STRING (major type 3).
+CRDTP_EXPORT void EncodeString8(span<uint8_t> in, std::vector<uint8_t>* out);
+
+// Encodes the given |latin1| string as STRING8.
+// If any non-ASCII character is present, it will be represented
+// as a 2 byte UTF8 sequence.
+CRDTP_EXPORT void EncodeFromLatin1(span<uint8_t> latin1,
+                                   std::vector<uint8_t>* out);
+
+// Encodes the given |utf16| string as STRING8 if it's entirely US-ASCII.
+// Otherwise, encodes as STRING16.
+CRDTP_EXPORT void EncodeFromUTF16(span<uint16_t> utf16,
+                                  std::vector<uint8_t>* out);
+
+// Encodes arbitrary binary data in |in| as a BYTE_STRING (major type 2) with
+// definitive length, prefixed with tag 22 indicating expected conversion to
+// base64 (see RFC 7049, Table 3 and Section 2.4.4.2).
+CRDTP_EXPORT void EncodeBinary(span<uint8_t> in, std::vector<uint8_t>* out);
+
+// Encodes / decodes a double as Major type 7 (SIMPLE_VALUE),
+// with additional info = 27, followed by 8 bytes in big endian.
+CRDTP_EXPORT void EncodeDouble(double value, std::vector<uint8_t>* out);
+
+// =============================================================================
+// cbor::EnvelopeEncoder - for wrapping submessages
+// =============================================================================
+
+// An envelope indicates the byte length of a wrapped item.
+// We use this for maps and array, which allows the decoder
+// to skip such (nested) values whole sale.
+// It's implemented as a CBOR tag (major type 6) with additional
+// info = 24, followed by a byte string with a 32 bit length value;
+// so the maximal structure that we can wrap is 2^32 bits long.
+// See also: https://tools.ietf.org/html/rfc7049#section-2.4.4.1
+class CRDTP_EXPORT EnvelopeEncoder {
+ public:
+  // Emits the envelope start bytes and records the position for the
+  // byte size in |byte_size_pos_|. Also emits empty bytes for the
+  // byte sisze so that encoding can continue.
+  void EncodeStart(std::vector<uint8_t>* out);
+  // This records the current size in |out| at position byte_size_pos_.
+  // Returns true iff successful.
+  bool EncodeStop(std::vector<uint8_t>* out);
+
+ private:
+  size_t byte_size_pos_ = 0;
+};
+
+class CRDTP_EXPORT EnvelopeHeader {
+ public:
+  EnvelopeHeader() = default;
+  ~EnvelopeHeader() = default;
+
+  // Parse envelope. Implies that `in` accomodates the entire size of envelope.
+  static StatusOr<EnvelopeHeader> Parse(span<uint8_t> in);
+  // Parse envelope, but allow `in` to only include the beginning of the
+  // envelope.
+  static StatusOr<EnvelopeHeader> ParseFromFragment(span<uint8_t> in);
+
+  size_t header_size() const { return header_size_; }
+  size_t content_size() const { return content_size_; }
+  size_t outer_size() const { return header_size_ + content_size_; }
+
+ private:
+  EnvelopeHeader(size_t header_size, size_t content_size)
+      : header_size_(header_size), content_size_(content_size) {}
+
+  size_t header_size_ = 0;
+  size_t content_size_ = 0;
+};
+
+// =============================================================================
+// cbor::NewCBOREncoder - for encoding from a streaming parser
+// =============================================================================
+
+// This can be used to convert to CBOR, by passing the return value to a parser
+// that drives it. The handler will encode into |out|, and iff an error occurs
+// it will set |status| to an error and clear |out|. Otherwise, |status.ok()|
+// will be |true|.
+CRDTP_EXPORT std::unique_ptr<ParserHandler> NewCBOREncoder(
+    std::vector<uint8_t>* out,
+    Status* status);
+
+// =============================================================================
+// cbor::CBORTokenizer - for parsing individual CBOR items
+// =============================================================================
+
+// Tags for the tokens within a CBOR message that CBORTokenizer understands.
+// Note that this is not the same terminology as the CBOR spec (RFC 7049),
+// but rather, our adaptation. For instance, we lump unsigned and signed
+// major type into INT32 here (and disallow values outside the int32_t range).
+enum class CBORTokenTag {
+  // Encountered an error in the structure of the message. Consult
+  // status() for details.
+  ERROR_VALUE,
+  // Booleans and NULL.
+  TRUE_VALUE,
+  FALSE_VALUE,
+  NULL_VALUE,
+  // An int32_t (signed 32 bit integer).
+  INT32,
+  // A double (64 bit floating point).
+  DOUBLE,
+  // A UTF8 string.
+  STRING8,
+  // A UTF16 string.
+  STRING16,
+  // A binary string.
+  BINARY,
+  // Starts an indefinite length map; after the map start we expect
+  // alternating keys and values, followed by STOP.
+  MAP_START,
+  // Starts an indefinite length array; after the array start we
+  // expect values, followed by STOP.
+  ARRAY_START,
+  // Ends a map or an array.
+  STOP,
+  // An envelope indicator, wrapping a map or array.
+  // Internally this carries the byte length of the wrapped
+  // map or array. While CBORTokenizer::Next() will read / skip the entire
+  // envelope, CBORTokenizer::EnterEnvelope() reads the tokens
+  // inside of it.
+  ENVELOPE,
+  // We've reached the end there is nothing else to read.
+  DONE,
+};
+
+// The major types from RFC 7049 Section 2.1.
+enum class MajorType {
+  UNSIGNED = 0,
+  NEGATIVE = 1,
+  BYTE_STRING = 2,
+  STRING = 3,
+  ARRAY = 4,
+  MAP = 5,
+  TAG = 6,
+  SIMPLE_VALUE = 7
+};
+
+// CBORTokenizer segments a CBOR message, presenting the tokens therein as
+// numbers, strings, etc. This is not a complete CBOR parser, but makes it much
+// easier to implement one (e.g. ParseCBOR, above). It can also be used to parse
+// messages partially.
+class CRDTP_EXPORT CBORTokenizer {
+ public:
+  explicit CBORTokenizer(span<uint8_t> bytes);
+  ~CBORTokenizer();
+
+  // Identifies the current token that we're looking at,
+  // or ERROR_VALUE (in which ase ::Status() has details)
+  // or DONE (if we're past the last token).
+  CBORTokenTag TokenTag() const;
+
+  // Advances to the next token.
+  void Next();
+  // Can only be called if TokenTag() == CBORTokenTag::ENVELOPE.
+  // While Next() would skip past the entire envelope / what it's
+  // wrapping, EnterEnvelope positions the cursor inside of the envelope,
+  // letting the client explore the nested structure.
+  void EnterEnvelope();
+
+  // If TokenTag() is CBORTokenTag::ERROR_VALUE, then Status().error describes
+  // the error more precisely; otherwise it'll be set to Error::OK.
+  // In either case, Status().pos is the current position.
+  struct Status Status() const;
+
+  // The following methods retrieve the token values. They can only
+  // be called if TokenTag() matches.
+
+  // To be called only if ::TokenTag() == CBORTokenTag::INT32.
+  int32_t GetInt32() const;
+
+  // To be called only if ::TokenTag() == CBORTokenTag::DOUBLE.
+  double GetDouble() const;
+
+  // To be called only if ::TokenTag() == CBORTokenTag::STRING8.
+  span<uint8_t> GetString8() const;
+
+  // Wire representation for STRING16 is low byte first (little endian).
+  // To be called only if ::TokenTag() == CBORTokenTag::STRING16.
+  span<uint8_t> GetString16WireRep() const;
+
+  // To be called only if ::TokenTag() == CBORTokenTag::BINARY.
+  span<uint8_t> GetBinary() const;
+
+  // To be called only if ::TokenTag() == CBORTokenTag::ENVELOPE.
+  // Returns the envelope including its payload; message which
+  // can be passed to the CBORTokenizer constructor, which will
+  // then see the envelope token first (looking at it a second time,
+  // basically).
+  span<uint8_t> GetEnvelope() const;
+
+  // To be called only if ::TokenTag() == CBORTokenTag::ENVELOPE.
+  // Returns only the payload inside the envelope, e.g., a map
+  // or an array. This is not a complete message by our
+  // IsCBORMessage definition, since it doesn't include the
+  // enclosing envelope (the header, basically).
+  span<uint8_t> GetEnvelopeContents() const;
+
+  // To be called only if ::TokenTag() == CBORTokenTag::ENVELOPE.
+  // Returns the envelope header.
+  const EnvelopeHeader& GetEnvelopeHeader() const;
+
+ private:
+  void ReadNextToken();
+  void SetToken(CBORTokenTag token, size_t token_byte_length);
+  void SetError(Error error);
+
+  const span<uint8_t> bytes_;
+  CBORTokenTag token_tag_;
+  struct Status status_;
+  size_t token_byte_length_ = 0;
+  MajorType token_start_type_;
+  uint64_t token_start_internal_value_;
+  EnvelopeHeader envelope_header_;
+};
+
+// =============================================================================
+// cbor::ParseCBOR - for receiving streaming parser events for CBOR messages
+// =============================================================================
+
+// Parses a CBOR encoded message from |bytes|, sending events to
+// |out|. If an error occurs, sends |out->HandleError|, and parsing stops.
+// The client is responsible for discarding the already received information in
+// that case.
+CRDTP_EXPORT void ParseCBOR(span<uint8_t> bytes, ParserHandler* out);
+
+// =============================================================================
+// cbor::AppendString8EntryToMap - for limited in-place editing of messages
+// =============================================================================
+
+// Modifies the |cbor| message by appending a new key/value entry at the end
+// of the map. Patches up the envelope size; Status.ok() iff successful.
+// If not successful, |cbor| may be corrupted after this call.
+CRDTP_EXPORT Status AppendString8EntryToCBORMap(span<uint8_t> string8_key,
+                                                span<uint8_t> string8_value,
+                                                std::vector<uint8_t>* cbor);
+
+namespace internals {  // Exposed only for writing tests.
+CRDTP_EXPORT size_t ReadTokenStart(span<uint8_t> bytes,
+                                   cbor::MajorType* type,
+                                   uint64_t* value);
+
+CRDTP_EXPORT void WriteTokenStart(cbor::MajorType type,
+                                  uint64_t value,
+                                  std::vector<uint8_t>* encoded);
+}  // namespace internals
+}  // namespace cbor
+}  // namespace crdtp
+
+#endif  // CRDTP_CBOR_H_
diff --git a/tools/inspector_protocol/crdtp/cbor_test.cc b/tools/inspector_protocol/crdtp/cbor_test.cc
new file mode 100644
index 00000000000000..058cd787d6416b
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/cbor_test.cc
@@ -0,0 +1,1449 @@
+// Copyright 2018 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "cbor.h"
+
+#include <array>
+#include <clocale>
+#include <cmath>
+#include <cstdlib>
+#include <cstring>
+#include <iomanip>
+#include <iostream>
+#include <sstream>
+#include <string>
+#include "json.h"
+#include "parser_handler.h"
+#include "span.h"
+#include "status.h"
+#include "status_test_support.h"
+#include "test_platform.h"
+
+using testing::ElementsAreArray;
+using testing::Eq;
+
+namespace crdtp {
+namespace cbor {
+// =============================================================================
+// Detecting CBOR content
+// =============================================================================
+
+TEST(IsCBORMessage, SomeSmokeTests) {
+  std::vector<uint8_t> empty;
+  EXPECT_FALSE(IsCBORMessage(SpanFrom(empty)));
+  std::vector<uint8_t> hello = {'H', 'e', 'l', 'o', ' ', 't',
+                                'h', 'e', 'r', 'e', '!'};
+  EXPECT_FALSE(IsCBORMessage(SpanFrom(hello)));
+  std::vector<uint8_t> example = {0xd8, 0x5a, 0, 0, 0, 0};
+  EXPECT_TRUE(IsCBORMessage(SpanFrom(example)));
+  std::vector<uint8_t> one = {0xd8, 0x5a, 0, 0, 0, 1, 1};
+  EXPECT_TRUE(IsCBORMessage(SpanFrom(one)));
+}
+
+TEST(CheckCBORMessage, SmallestValidExample) {
+  // The smallest example that we consider valid for this lightweight check is
+  // an empty dictionary inside of an envelope.
+  std::vector<uint8_t> empty_dict = {
+      0xd8, 0x5a, 0, 0, 0, 2, EncodeIndefiniteLengthMapStart(), EncodeStop()};
+  Status status = CheckCBORMessage(SpanFrom(empty_dict));
+  EXPECT_THAT(status, StatusIsOk());
+}
+
+TEST(CheckCBORMessage, ValidCBORButNotValidMessage) {
+  // The CBOR parser supports parsing values that aren't messages. E.g., this is
+  // the encoded unsigned int 7 (CBOR really encodes it as a single byte with
+  // value 7).
+  std::vector<uint8_t> not_a_message = {7};
+
+  // Show that the parser (happily) decodes it into JSON
+  std::string json;
+  Status status;
+  std::unique_ptr<ParserHandler> json_writer =
+      json::NewJSONEncoder(&json, &status);
+  ParseCBOR(SpanFrom(not_a_message), json_writer.get());
+  EXPECT_THAT(status, StatusIsOk());
+  EXPECT_EQ("7", json);
+
+  // ... but it's not a message.
+  EXPECT_THAT(CheckCBORMessage(SpanFrom(not_a_message)),
+              StatusIs(Error::CBOR_INVALID_START_BYTE, 0));
+}
+
+TEST(CheckCBORMessage, EmptyMessage) {
+  std::vector<uint8_t> empty;
+  Status status = CheckCBORMessage(SpanFrom(empty));
+  EXPECT_THAT(status, StatusIs(Error::CBOR_UNEXPECTED_EOF_IN_ENVELOPE, 0));
+}
+
+TEST(CheckCBORMessage, InvalidStartByte) {
+  // Here we test that some actual json, which usually starts with {, is not
+  // considered CBOR. CBOR messages must start with 0xd8, 0x5a, the envelope
+  // start bytes.
+  Status status = CheckCBORMessage(SpanFrom("{\"msg\": \"Hello, world.\"}"));
+  EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_START_BYTE, 0));
+}
+
+TEST(CheckCBORMessage, InvalidEnvelopes) {
+  std::vector<uint8_t> bytes = {0xd8, 0x5a};
+  EXPECT_THAT(CheckCBORMessage(SpanFrom(bytes)),
+              StatusIs(Error::CBOR_UNEXPECTED_EOF_IN_ENVELOPE, 2));
+  bytes = {0xd8, 0x5a, 0};
+  EXPECT_THAT(CheckCBORMessage(SpanFrom(bytes)),
+              StatusIs(Error::CBOR_UNEXPECTED_EOF_IN_ENVELOPE, 3));
+  bytes = {0xd8, 0x5a, 0, 0};
+  EXPECT_THAT(CheckCBORMessage(SpanFrom(bytes)),
+              StatusIs(Error::CBOR_UNEXPECTED_EOF_IN_ENVELOPE, 4));
+  bytes = {0xd8, 0x5a, 0, 0, 0};
+  EXPECT_THAT(CheckCBORMessage(SpanFrom(bytes)),
+              StatusIs(Error::CBOR_UNEXPECTED_EOF_IN_ENVELOPE, 5));
+  bytes = {0xd8, 0x5a, 0, 0, 0, 0};
+  EXPECT_THAT(CheckCBORMessage(SpanFrom(bytes)),
+              StatusIs(Error::CBOR_MAP_OR_ARRAY_EXPECTED_IN_ENVELOPE, 6));
+}
+
+TEST(CheckCBORMessage, MapStartExpected) {
+  std::vector<uint8_t> bytes = {0xd8, 0x5a, 0, 0, 0, 1};
+  EXPECT_THAT(CheckCBORMessage(SpanFrom(bytes)),
+              StatusIs(Error::CBOR_ENVELOPE_CONTENTS_LENGTH_MISMATCH, 6));
+}
+
+// =============================================================================
+// Encoding individual CBOR items
+// cbor::CBORTokenizer - for parsing individual CBOR items
+// =============================================================================
+
+//
+// EncodeInt32 / CBORTokenTag::INT32
+//
+TEST(EncodeDecodeInt32Test, Roundtrips23) {
+  // This roundtrips the int32_t value 23 through the pair of EncodeInt32 /
+  // CBORTokenizer; this is interesting since 23 is encoded as a single byte.
+  std::vector<uint8_t> encoded;
+  EncodeInt32(23, &encoded);
+  // first three bits: major type = 0; remaining five bits: additional info =
+  // value 23.
+  EXPECT_THAT(encoded, ElementsAreArray(std::array<uint8_t, 1>{{23}}));
+
+  // Reverse direction: decode with CBORTokenizer.
+  CBORTokenizer tokenizer(SpanFrom(encoded));
+  EXPECT_EQ(CBORTokenTag::INT32, tokenizer.TokenTag());
+  EXPECT_EQ(23, tokenizer.GetInt32());
+  tokenizer.Next();
+  EXPECT_EQ(CBORTokenTag::DONE, tokenizer.TokenTag());
+}
+
+TEST(EncodeDecodeInt32Test, RoundtripsUint8) {
+  // This roundtrips the int32_t value 42 through the pair of EncodeInt32 /
+  // CBORTokenizer. This is different from Roundtrip23 because 42 is encoded
+  // in an extra byte after the initial one.
+  std::vector<uint8_t> encoded;
+  EncodeInt32(42, &encoded);
+  // first three bits: major type = 0;
+  // remaining five bits: additional info = 24, indicating payload is uint8.
+  EXPECT_THAT(encoded, ElementsAreArray(std::array<uint8_t, 2>{{24, 42}}));
+
+  // Reverse direction: decode with CBORTokenizer.
+  CBORTokenizer tokenizer(SpanFrom(encoded));
+  EXPECT_EQ(CBORTokenTag::INT32, tokenizer.TokenTag());
+  EXPECT_EQ(42, tokenizer.GetInt32());
+  tokenizer.Next();
+  EXPECT_EQ(CBORTokenTag::DONE, tokenizer.TokenTag());
+}
+
+TEST(EncodeDecodeInt32Test, RoundtripsUint16) {
+  // 500 is encoded as a uint16 after the initial byte.
+  std::vector<uint8_t> encoded;
+  EncodeInt32(500, &encoded);
+  // 1 for initial byte, 2 for uint16.
+  EXPECT_EQ(3u, encoded.size());
+  // first three bits: major type = 0;
+  // remaining five bits: additional info = 25, indicating payload is uint16.
+  EXPECT_EQ(25, encoded[0]);
+  EXPECT_EQ(0x01, encoded[1]);
+  EXPECT_EQ(0xf4, encoded[2]);
+
+  // Reverse direction: decode with CBORTokenizer.
+  CBORTokenizer tokenizer(SpanFrom(encoded));
+  EXPECT_EQ(CBORTokenTag::INT32, tokenizer.TokenTag());
+  EXPECT_EQ(500, tokenizer.GetInt32());
+  tokenizer.Next();
+  EXPECT_EQ(CBORTokenTag::DONE, tokenizer.TokenTag());
+}
+
+TEST(EncodeDecodeInt32Test, RoundtripsInt32Max) {
+  // std::numeric_limits<int32_t> is encoded as a uint32 after the initial byte.
+  std::vector<uint8_t> encoded;
+  EncodeInt32(std::numeric_limits<int32_t>::max(), &encoded);
+  // 1 for initial byte, 4 for the uint32.
+  // first three bits: major type = 0;
+  // remaining five bits: additional info = 26, indicating payload is uint32.
+  EXPECT_THAT(
+      encoded,
+      ElementsAreArray(std::array<uint8_t, 5>{{26, 0x7f, 0xff, 0xff, 0xff}}));
+
+  // Reverse direction: decode with CBORTokenizer.
+  CBORTokenizer tokenizer(SpanFrom(encoded));
+  EXPECT_EQ(CBORTokenTag::INT32, tokenizer.TokenTag());
+  EXPECT_EQ(std::numeric_limits<int32_t>::max(), tokenizer.GetInt32());
+  tokenizer.Next();
+  EXPECT_EQ(CBORTokenTag::DONE, tokenizer.TokenTag());
+}
+
+TEST(EncodeDecodeInt32Test, RoundtripsInt32Min) {
+  // std::numeric_limits<int32_t> is encoded as a uint32 (4 unsigned bytes)
+  // after the initial byte, which effectively carries the sign by
+  // designating the token as NEGATIVE.
+  std::vector<uint8_t> encoded;
+  EncodeInt32(std::numeric_limits<int32_t>::min(), &encoded);
+  // 1 for initial byte, 4 for the uint32.
+  // first three bits: major type = 1;
+  // remaining five bits: additional info = 26, indicating payload is uint32.
+  EXPECT_THAT(encoded, ElementsAreArray(std::array<uint8_t, 5>{
+                           {1 << 5 | 26, 0x7f, 0xff, 0xff, 0xff}}));
+
+  // Reverse direction: decode with CBORTokenizer.
+  CBORTokenizer tokenizer(SpanFrom(encoded));
+  EXPECT_EQ(CBORTokenTag::INT32, tokenizer.TokenTag());
+  EXPECT_EQ(std::numeric_limits<int32_t>::min(), tokenizer.GetInt32());
+  // It's nice to see how the min int32 value reads in hex:
+  // That is, -1 minus the unsigned payload (0x7fffffff, see above).
+  int32_t expected = -1 - 0x7fffffff;
+  EXPECT_EQ(expected, tokenizer.GetInt32());
+  tokenizer.Next();
+  EXPECT_EQ(CBORTokenTag::DONE, tokenizer.TokenTag());
+}
+
+TEST(EncodeDecodeInt32Test, CantRoundtripUint32) {
+  // 0xdeadbeef is a value which does not fit below
+  // std::numerical_limits<int32_t>::max(), so we can't encode
+  // it with EncodeInt32. However, CBOR does support this, so we
+  // encode it here manually with the internal routine, just to observe
+  // that it's considered an invalid int32 by CBORTokenizer.
+  std::vector<uint8_t> encoded;
+  internals::WriteTokenStart(MajorType::UNSIGNED, 0xdeadbeef, &encoded);
+  // 1 for initial byte, 4 for the uint32.
+  // first three bits: major type = 0;
+  // remaining five bits: additional info = 26, indicating payload is uint32.
+  EXPECT_THAT(
+      encoded,
+      ElementsAreArray(std::array<uint8_t, 5>{{26, 0xde, 0xad, 0xbe, 0xef}}));
+
+  // Now try to decode; we treat this as an invalid INT32.
+  CBORTokenizer tokenizer(SpanFrom(encoded));
+  // 0xdeadbeef is > std::numerical_limits<int32_t>::max().
+  EXPECT_EQ(CBORTokenTag::ERROR_VALUE, tokenizer.TokenTag());
+  EXPECT_THAT(tokenizer.Status(), StatusIs(Error::CBOR_INVALID_INT32, 0u));
+}
+
+TEST(EncodeDecodeInt32Test, DecodeErrorCases) {
+  struct TestCase {
+    std::vector<uint8_t> data;
+    std::string msg;
+  };
+  std::vector<TestCase> tests{{
+      TestCase{
+          {24},
+          "additional info = 24 would require 1 byte of payload (but it's 0)"},
+      TestCase{{27, 0xaa, 0xbb, 0xcc},
+               "additional info = 27 would require 8 bytes of payload (but "
+               "it's 3)"},
+      TestCase{{29}, "additional info = 29 isn't recognized"},
+      TestCase{{1 << 5 | 27, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
+               "Max UINT64 payload is outside the allowed range"},
+      TestCase{{1 << 5 | 26, 0xff, 0xff, 0xff, 0xff},
+               "Max UINT32 payload is outside the allowed range"},
+      TestCase{{1 << 5 | 26, 0x80, 0x00, 0x00, 0x00},
+               "UINT32 payload w/ high bit set is outside the allowed range"},
+  }};
+  for (const TestCase& test : tests) {
+    SCOPED_TRACE(test.msg);
+    CBORTokenizer tokenizer(SpanFrom(test.data));
+    EXPECT_EQ(CBORTokenTag::ERROR_VALUE, tokenizer.TokenTag());
+    EXPECT_THAT(tokenizer.Status(), StatusIs(Error::CBOR_INVALID_INT32, 0u));
+  }
+}
+
+TEST(EncodeDecodeInt32Test, RoundtripsMinus24) {
+  // This roundtrips the int32_t value -24 through the pair of EncodeInt32 /
+  // CBORTokenizer; this is interesting since -24 is encoded as
+  // a single byte as NEGATIVE, and it tests the specific encoding
+  // (note how for unsigned the single byte covers values up to 23).
+  // Additional examples are covered in RoundtripsAdditionalExamples.
+  std::vector<uint8_t> encoded;
+  EncodeInt32(-24, &encoded);
+  // first three bits: major type = 1; remaining five bits: additional info =
+  // value 23.
+  EXPECT_THAT(encoded, ElementsAreArray(std::array<uint8_t, 1>{{1 << 5 | 23}}));
+
+  // Reverse direction: decode with CBORTokenizer.
+  CBORTokenizer tokenizer(SpanFrom(encoded));
+  EXPECT_EQ(CBORTokenTag::INT32, tokenizer.TokenTag());
+  EXPECT_EQ(-24, tokenizer.GetInt32());
+  tokenizer.Next();
+  EXPECT_EQ(CBORTokenTag::DONE, tokenizer.TokenTag());
+}
+
+TEST(EncodeDecodeInt32Test, RoundtripsAdditionalNegativeExamples) {
+  std::vector<int32_t> examples = {-1,
+                                   -10,
+                                   -24,
+                                   -25,
+                                   -300,
+                                   -30000,
+                                   -300 * 1000,
+                                   -1000 * 1000,
+                                   -1000 * 1000 * 1000,
+                                   std::numeric_limits<int32_t>::min()};
+  for (int32_t example : examples) {
+    SCOPED_TRACE(std::string("example ") + std::to_string(example));
+    std::vector<uint8_t> encoded;
+    EncodeInt32(example, &encoded);
+    CBORTokenizer tokenizer(SpanFrom(encoded));
+    EXPECT_EQ(CBORTokenTag::INT32, tokenizer.TokenTag());
+    EXPECT_EQ(example, tokenizer.GetInt32());
+    tokenizer.Next();
+    EXPECT_EQ(CBORTokenTag::DONE, tokenizer.TokenTag());
+  }
+}
+
+//
+// EncodeString16 / CBORTokenTag::STRING16
+//
+TEST(EncodeDecodeString16Test, RoundtripsEmpty) {
+  // This roundtrips the empty utf16 string through the pair of EncodeString16 /
+  // CBORTokenizer.
+  std::vector<uint8_t> encoded;
+  EncodeString16(span<uint16_t>(), &encoded);
+  EXPECT_EQ(1u, encoded.size());
+  // first three bits: major type = 2; remaining five bits: additional info =
+  // size 0.
+  EXPECT_EQ(2 << 5, encoded[0]);
+
+  // Reverse direction: decode with CBORTokenizer.
+  CBORTokenizer tokenizer(SpanFrom(encoded));
+  EXPECT_EQ(CBORTokenTag::STRING16, tokenizer.TokenTag());
+  span<uint8_t> decoded_string16_wirerep = tokenizer.GetString16WireRep();
+  EXPECT_TRUE(decoded_string16_wirerep.empty());
+  tokenizer.Next();
+  EXPECT_EQ(CBORTokenTag::DONE, tokenizer.TokenTag());
+}
+
+// On the wire, we STRING16 is encoded as little endian (least
+// significant byte first). The host may or may not be little endian,
+// so this routine follows the advice in
+// https://commandcenter.blogspot.com/2012/04/byte-order-fallacy.html.
+std::vector<uint16_t> String16WireRepToHost(span<uint8_t> in) {
+  // must be even number of bytes.
+  CHECK_EQ(in.size() & 1, 0u);
+  std::vector<uint16_t> host_out;
+  for (size_t ii = 0; ii < in.size(); ii += 2)
+    host_out.push_back(in[ii + 1] << 8 | in[ii]);
+  return host_out;
+}
+
+TEST(EncodeDecodeString16Test, RoundtripsHelloWorld) {
+  // This roundtrips the hello world message which is given here in utf16
+  // characters. 0xd83c, 0xdf0e: UTF16 encoding for the "Earth Globe Americas"
+  // character, 🌎.
+  std::array<uint16_t, 10> msg{
+      {'H', 'e', 'l', 'l', 'o', ',', ' ', 0xd83c, 0xdf0e, '.'}};
+  std::vector<uint8_t> encoded;
+  EncodeString16(span<uint16_t>(msg.data(), msg.size()), &encoded);
+  // This will be encoded as BYTE_STRING of length 20, so the 20 is encoded in
+  // the additional info part of the initial byte. Payload is two bytes for each
+  // UTF16 character.
+  uint8_t initial_byte = /*major type=*/2 << 5 | /*additional info=*/20;
+  std::array<uint8_t, 21> encoded_expected = {
+      {initial_byte, 'H', 0,   'e', 0,    'l',  0,    'l',  0,   'o', 0,
+       ',',          0,   ' ', 0,   0x3c, 0xd8, 0x0e, 0xdf, '.', 0}};
+  EXPECT_THAT(encoded, ElementsAreArray(encoded_expected));
+
+  // Now decode to complete the roundtrip.
+  CBORTokenizer tokenizer(SpanFrom(encoded));
+  EXPECT_EQ(CBORTokenTag::STRING16, tokenizer.TokenTag());
+  std::vector<uint16_t> decoded =
+      String16WireRepToHost(tokenizer.GetString16WireRep());
+  EXPECT_THAT(decoded, ElementsAreArray(msg));
+  tokenizer.Next();
+  EXPECT_EQ(CBORTokenTag::DONE, tokenizer.TokenTag());
+
+  // For bonus points, we look at the decoded message in UTF8 as well so we can
+  // easily see it on the terminal screen.
+  std::string utf8_decoded = UTF16ToUTF8(SpanFrom(decoded));
+  EXPECT_EQ("Hello, 🌎.", utf8_decoded);
+}
+
+TEST(EncodeDecodeString16Test, Roundtrips500) {
+  // We roundtrip a message that has 250 16 bit values. Each of these are just
+  // set to their index. 250 is interesting because the cbor spec uses a
+  // BYTE_STRING of length 500 for one of their examples of how to encode the
+  // start of it (section 2.1) so it's easy for us to look at the first three
+  // bytes closely.
+  std::vector<uint16_t> two_fifty;
+  for (uint16_t ii = 0; ii < 250; ++ii)
+    two_fifty.push_back(ii);
+  std::vector<uint8_t> encoded;
+  EncodeString16(span<uint16_t>(two_fifty.data(), two_fifty.size()), &encoded);
+  EXPECT_EQ(3u + 250u * 2, encoded.size());
+  // Now check the first three bytes:
+  // Major type: 2 (BYTE_STRING)
+  // Additional information: 25, indicating size is represented by 2 bytes.
+  // Bytes 1 and 2 encode 500 (0x01f4).
+  EXPECT_EQ(2 << 5 | 25, encoded[0]);
+  EXPECT_EQ(0x01, encoded[1]);
+  EXPECT_EQ(0xf4, encoded[2]);
+
+  // Now decode to complete the roundtrip.
+  CBORTokenizer tokenizer(SpanFrom(encoded));
+  EXPECT_EQ(CBORTokenTag::STRING16, tokenizer.TokenTag());
+  std::vector<uint16_t> decoded =
+      String16WireRepToHost(tokenizer.GetString16WireRep());
+  EXPECT_THAT(decoded, ElementsAreArray(two_fifty));
+  tokenizer.Next();
+  EXPECT_EQ(CBORTokenTag::DONE, tokenizer.TokenTag());
+}
+
+TEST(EncodeDecodeString16Test, ErrorCases) {
+  struct TestCase {
+    std::vector<uint8_t> data;
+    std::string msg;
+  };
+  std::vector<TestCase> tests{
+      {TestCase{{2 << 5 | 1, 'a'},
+                "length must be divisible by 2 (but it's 1)"},
+       TestCase{{2 << 5 | 29}, "additional info = 29 isn't recognized"},
+       TestCase{{2 << 5 | 9, 1, 2, 3, 4, 5, 6, 7, 8},
+                "length (9) points just past the end of the test case"},
+       TestCase{{2 << 5 | 27, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                 'a', 'b', 'c'},
+                "large length pointing past the end of the test case"}}};
+  for (const TestCase& test : tests) {
+    SCOPED_TRACE(test.msg);
+    CBORTokenizer tokenizer(SpanFrom(test.data));
+    EXPECT_EQ(CBORTokenTag::ERROR_VALUE, tokenizer.TokenTag());
+    EXPECT_THAT(tokenizer.Status(), StatusIs(Error::CBOR_INVALID_STRING16, 0u));
+  }
+}
+
+//
+// EncodeString8 / CBORTokenTag::STRING8
+//
+TEST(EncodeDecodeString8Test, RoundtripsHelloWorld) {
+  // This roundtrips the hello world message which is given here in utf8
+  // characters. 🌎 is a four byte utf8 character.
+  std::string utf8_msg = "Hello, 🌎.";
+  std::vector<uint8_t> msg(utf8_msg.begin(), utf8_msg.end());
+  std::vector<uint8_t> encoded;
+  EncodeString8(SpanFrom(utf8_msg), &encoded);
+  // This will be encoded as STRING of length 12, so the 12 is encoded in
+  // the additional info part of the initial byte. Payload is one byte per
+  // utf8 byte.
+  uint8_t initial_byte = /*major type=*/3 << 5 | /*additional info=*/12;
+  std::array<uint8_t, 13> encoded_expected = {{initial_byte, 'H', 'e', 'l', 'l',
+                                               'o', ',', ' ', 0xF0, 0x9f, 0x8c,
+                                               0x8e, '.'}};
+  EXPECT_THAT(encoded, ElementsAreArray(encoded_expected));
+
+  // Now decode to complete the roundtrip.
+  CBORTokenizer tokenizer(SpanFrom(encoded));
+  EXPECT_EQ(CBORTokenTag::STRING8, tokenizer.TokenTag());
+  std::vector<uint8_t> decoded(tokenizer.GetString8().begin(),
+                               tokenizer.GetString8().end());
+  EXPECT_THAT(decoded, ElementsAreArray(msg));
+  tokenizer.Next();
+  EXPECT_EQ(CBORTokenTag::DONE, tokenizer.TokenTag());
+}
+
+TEST(EncodeDecodeString8Test, ErrorCases) {
+  struct TestCase {
+    std::vector<uint8_t> data;
+    std::string msg;
+  };
+  std::vector<TestCase> tests{
+      {TestCase{{3 << 5 | 29}, "additional info = 29 isn't recognized"},
+       TestCase{{3 << 5 | 9, 1, 2, 3, 4, 5, 6, 7, 8},
+                "length (9) points just past the end of the test case"},
+       TestCase{{3 << 5 | 27, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+                 'a', 'b', 'c'},
+                "large length pointing past the end of the test case"}}};
+  for (const TestCase& test : tests) {
+    SCOPED_TRACE(test.msg);
+    CBORTokenizer tokenizer(SpanFrom(test.data));
+    EXPECT_EQ(CBORTokenTag::ERROR_VALUE, tokenizer.TokenTag());
+    EXPECT_THAT(tokenizer.Status(), StatusIs(Error::CBOR_INVALID_STRING8, 0u));
+  }
+}
+
+TEST(EncodeFromLatin1Test, ConvertsToUTF8IfNeeded) {
+  std::vector<std::pair<std::string, std::string>> examples = {
+      {"Hello, world.", "Hello, world."},
+      {"Above: \xDC"
+       "ber",
+       "Above: Über"},
+      {"\xA5 500 are about \xA3 3.50; a y with umlaut is \xFF",
+       "¥ 500 are about £ 3.50; a y with umlaut is ÿ"}};
+
+  for (const auto& example : examples) {
+    const std::string& latin1 = example.first;
+    const std::string& expected_utf8 = example.second;
+    std::vector<uint8_t> encoded;
+    EncodeFromLatin1(SpanFrom(latin1), &encoded);
+    CBORTokenizer tokenizer(SpanFrom(encoded));
+    EXPECT_EQ(CBORTokenTag::STRING8, tokenizer.TokenTag());
+    std::vector<uint8_t> decoded(tokenizer.GetString8().begin(),
+                                 tokenizer.GetString8().end());
+    std::string decoded_str(decoded.begin(), decoded.end());
+    EXPECT_THAT(decoded_str, testing::Eq(expected_utf8));
+  }
+}
+
+TEST(EncodeFromUTF16Test, ConvertsToUTF8IfEasy) {
+  std::vector<uint16_t> ascii = {'e', 'a', 's', 'y'};
+  std::vector<uint8_t> encoded;
+  EncodeFromUTF16(span<uint16_t>(ascii.data(), ascii.size()), &encoded);
+
+  CBORTokenizer tokenizer(SpanFrom(encoded));
+  EXPECT_EQ(CBORTokenTag::STRING8, tokenizer.TokenTag());
+  std::vector<uint8_t> decoded(tokenizer.GetString8().begin(),
+                               tokenizer.GetString8().end());
+  std::string decoded_str(decoded.begin(), decoded.end());
+  EXPECT_THAT(decoded_str, testing::Eq("easy"));
+}
+
+TEST(EncodeFromUTF16Test, EncodesAsString16IfNeeded) {
+  // Since this message contains non-ASCII characters, the routine is
+  // forced to encode as UTF16. We see this below by checking that the
+  // token tag is STRING16.
+  std::vector<uint16_t> msg = {'H', 'e', 'l',    'l',    'o',
+                               ',', ' ', 0xd83c, 0xdf0e, '.'};
+  std::vector<uint8_t> encoded;
+  EncodeFromUTF16(span<uint16_t>(msg.data(), msg.size()), &encoded);
+
+  CBORTokenizer tokenizer(SpanFrom(encoded));
+  EXPECT_EQ(CBORTokenTag::STRING16, tokenizer.TokenTag());
+  std::vector<uint16_t> decoded =
+      String16WireRepToHost(tokenizer.GetString16WireRep());
+  std::string utf8_decoded = UTF16ToUTF8(SpanFrom(decoded));
+  EXPECT_EQ("Hello, 🌎.", utf8_decoded);
+}
+
+//
+// EncodeBinary / CBORTokenTag::BINARY
+//
+TEST(EncodeDecodeBinaryTest, RoundtripsHelloWorld) {
+  std::vector<uint8_t> binary = {'H', 'e', 'l', 'l', 'o', ',', ' ',
+                                 'w', 'o', 'r', 'l', 'd', '.'};
+  std::vector<uint8_t> encoded;
+  EncodeBinary(span<uint8_t>(binary.data(), binary.size()), &encoded);
+  // So, on the wire we see that the binary blob travels unmodified.
+  EXPECT_THAT(
+      encoded,
+      ElementsAreArray(std::array<uint8_t, 15>{
+          {(6 << 5 | 22),  // tag 22 indicating base64 interpretation in JSON
+           (2 << 5 | 13),  // BYTE_STRING (type 2) of length 13
+           'H', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '.'}}));
+  std::vector<uint8_t> decoded;
+  CBORTokenizer tokenizer(SpanFrom(encoded));
+  EXPECT_EQ(CBORTokenTag::BINARY, tokenizer.TokenTag());
+  EXPECT_THAT(tokenizer.Status(), StatusIsOk());
+  decoded = std::vector<uint8_t>(tokenizer.GetBinary().begin(),
+                                 tokenizer.GetBinary().end());
+  EXPECT_THAT(decoded, ElementsAreArray(binary));
+  tokenizer.Next();
+  EXPECT_EQ(CBORTokenTag::DONE, tokenizer.TokenTag());
+}
+
+TEST(EncodeDecodeBinaryTest, ErrorCases) {
+  struct TestCase {
+    std::vector<uint8_t> data;
+    std::string msg;
+  };
+  std::vector<TestCase> tests{{TestCase{
+      {6 << 5 | 22,  // tag 22 indicating base64 interpretation in JSON
+       2 << 5 | 27,  // BYTE_STRING (type 2), followed by 8 bytes length
+       0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
+      "large length pointing past the end of the test case"}}};
+  for (const TestCase& test : tests) {
+    SCOPED_TRACE(test.msg);
+    CBORTokenizer tokenizer(SpanFrom(test.data));
+    EXPECT_EQ(CBORTokenTag::ERROR_VALUE, tokenizer.TokenTag());
+    EXPECT_THAT(tokenizer.Status(), StatusIs(Error::CBOR_INVALID_BINARY, 0u));
+  }
+}
+
+//
+// EncodeDouble / CBORTokenTag::DOUBLE
+//
+TEST(EncodeDecodeDoubleTest, RoundtripsWikipediaExample) {
+  // https://en.wikipedia.org/wiki/Double-precision_floating-point_format
+  // provides the example of a hex representation 3FD5 5555 5555 5555, which
+  // approximates 1/3.
+
+  const double kOriginalValue = 1.0 / 3;
+  std::vector<uint8_t> encoded;
+  EncodeDouble(kOriginalValue, &encoded);
+  // first three bits: major type = 7; remaining five bits: additional info =
+  // value 27. This is followed by 8 bytes of payload (which match Wikipedia).
+  EXPECT_THAT(
+      encoded,
+      ElementsAreArray(std::array<uint8_t, 9>{
+          {7 << 5 | 27, 0x3f, 0xd5, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55}}));
+
+  // Reverse direction: decode and compare with original value.
+  CBORTokenizer tokenizer(SpanFrom(encoded));
+  EXPECT_EQ(CBORTokenTag::DOUBLE, tokenizer.TokenTag());
+  EXPECT_THAT(tokenizer.GetDouble(), testing::DoubleEq(kOriginalValue));
+  tokenizer.Next();
+  EXPECT_EQ(CBORTokenTag::DONE, tokenizer.TokenTag());
+}
+
+TEST(EncodeDecodeDoubleTest, RoundtripsAdditionalExamples) {
+  std::vector<double> examples = {0.0,
+                                  1.0,
+                                  -1.0,
+                                  3.1415,
+                                  std::numeric_limits<double>::min(),
+                                  std::numeric_limits<double>::max(),
+                                  std::numeric_limits<double>::infinity(),
+                                  std::numeric_limits<double>::quiet_NaN()};
+  for (double example : examples) {
+    SCOPED_TRACE(std::string("example ") + std::to_string(example));
+    std::vector<uint8_t> encoded;
+    EncodeDouble(example, &encoded);
+    CBORTokenizer tokenizer(SpanFrom(encoded));
+    EXPECT_EQ(CBORTokenTag::DOUBLE, tokenizer.TokenTag());
+    if (std::isnan(example))
+      EXPECT_TRUE(std::isnan(tokenizer.GetDouble()));
+    else
+      EXPECT_THAT(tokenizer.GetDouble(), testing::DoubleEq(example));
+    tokenizer.Next();
+    EXPECT_EQ(CBORTokenTag::DONE, tokenizer.TokenTag());
+  }
+}
+
+TEST(EncodeDecodeEnvelopesTest, MessageWithNestingAndEnvelopeContentsAccess) {
+  // This encodes and decodes the following message, which has some nesting
+  // and therefore envelopes.
+  //  { "inner": { "foo" : "bar" } }
+  // The decoding is done with the Tokenizer,
+  // and we test both ::GetEnvelopeContents and GetEnvelope here.
+  std::vector<uint8_t> message;
+  EnvelopeEncoder envelope;
+  envelope.EncodeStart(&message);
+  size_t pos_after_header = message.size();
+  message.push_back(EncodeIndefiniteLengthMapStart());
+  EncodeString8(SpanFrom("inner"), &message);
+  size_t pos_inside_inner = message.size();
+  EnvelopeEncoder inner_envelope;
+  inner_envelope.EncodeStart(&message);
+  size_t pos_inside_inner_contents = message.size();
+  message.push_back(EncodeIndefiniteLengthMapStart());
+  EncodeString8(SpanFrom("foo"), &message);
+  EncodeString8(SpanFrom("bar"), &message);
+  message.push_back(EncodeStop());
+  size_t pos_after_inner = message.size();
+  inner_envelope.EncodeStop(&message);
+  message.push_back(EncodeStop());
+  envelope.EncodeStop(&message);
+
+  CBORTokenizer tokenizer(SpanFrom(message));
+  ASSERT_EQ(CBORTokenTag::ENVELOPE, tokenizer.TokenTag());
+  EXPECT_EQ(message.size(), tokenizer.GetEnvelope().size());
+  EXPECT_EQ(message.data(), tokenizer.GetEnvelope().data());
+  EXPECT_EQ(message.data() + pos_after_header,
+            tokenizer.GetEnvelopeContents().data());
+  EXPECT_EQ(message.size() - pos_after_header,
+            tokenizer.GetEnvelopeContents().size());
+  tokenizer.EnterEnvelope();
+  ASSERT_EQ(CBORTokenTag::MAP_START, tokenizer.TokenTag());
+  tokenizer.Next();
+  ASSERT_EQ(CBORTokenTag::STRING8, tokenizer.TokenTag());
+  EXPECT_EQ("inner", std::string(tokenizer.GetString8().begin(),
+                                 tokenizer.GetString8().end()));
+  tokenizer.Next();
+  ASSERT_EQ(CBORTokenTag::ENVELOPE, tokenizer.TokenTag());
+  EXPECT_EQ(message.data() + pos_inside_inner, tokenizer.GetEnvelope().data());
+  EXPECT_EQ(pos_after_inner - pos_inside_inner, tokenizer.GetEnvelope().size());
+  EXPECT_EQ(message.data() + pos_inside_inner_contents,
+            tokenizer.GetEnvelopeContents().data());
+  EXPECT_EQ(pos_after_inner - pos_inside_inner_contents,
+            tokenizer.GetEnvelopeContents().size());
+  tokenizer.EnterEnvelope();
+  ASSERT_EQ(CBORTokenTag::MAP_START, tokenizer.TokenTag());
+  tokenizer.Next();
+  ASSERT_EQ(CBORTokenTag::STRING8, tokenizer.TokenTag());
+  EXPECT_EQ("foo", std::string(tokenizer.GetString8().begin(),
+                               tokenizer.GetString8().end()));
+  tokenizer.Next();
+  ASSERT_EQ(CBORTokenTag::STRING8, tokenizer.TokenTag());
+  EXPECT_EQ("bar", std::string(tokenizer.GetString8().begin(),
+                               tokenizer.GetString8().end()));
+  tokenizer.Next();
+  ASSERT_EQ(CBORTokenTag::STOP, tokenizer.TokenTag());
+  tokenizer.Next();
+  ASSERT_EQ(CBORTokenTag::STOP, tokenizer.TokenTag());
+  tokenizer.Next();
+  ASSERT_EQ(CBORTokenTag::DONE, tokenizer.TokenTag());
+}
+
+// =============================================================================
+// cbor::NewCBOREncoder - for encoding from a streaming parser
+// =============================================================================
+
+TEST(JSONToCBOREncoderTest, SevenBitStrings) {
+  // When a string can be represented as 7 bit ASCII, the encoder will use the
+  // STRING (major Type 3) type, so the actual characters end up as bytes on the
+  // wire.
+  std::vector<uint8_t> encoded;
+  Status status;
+  std::unique_ptr<ParserHandler> encoder = NewCBOREncoder(&encoded, &status);
+  std::vector<uint16_t> utf16 = {'f', 'o', 'o'};
+  encoder->HandleString16(span<uint16_t>(utf16.data(), utf16.size()));
+  EXPECT_THAT(status, StatusIsOk());
+  // Here we assert that indeed, seven bit strings are represented as
+  // bytes on the wire, "foo" is just "foo".
+  EXPECT_THAT(encoded,
+              ElementsAreArray(std::array<uint8_t, 4>{
+                  {/*major type 3*/ 3 << 5 | /*length*/ 3, 'f', 'o', 'o'}}));
+}
+
+TEST(JsonCborRoundtrip, EncodingDecoding) {
+  // Hits all the cases except binary and error in ParserHandler, first
+  // parsing a JSON message into CBOR, then parsing it back from CBOR into JSON.
+  std::string json =
+      "{"
+      "\"string\":\"Hello, \\ud83c\\udf0e.\","
+      "\"double\":3.1415,"
+      "\"int\":1,"
+      "\"negative int\":-1,"
+      "\"bool\":true,"
+      "\"null\":null,"
+      "\"array\":[1,2,3]"
+      "}";
+  std::vector<uint8_t> encoded;
+  Status status;
+  std::unique_ptr<ParserHandler> encoder = NewCBOREncoder(&encoded, &status);
+  span<uint8_t> ascii_in = SpanFrom(json);
+  json::ParseJSON(ascii_in, encoder.get());
+  std::vector<uint8_t> expected = {
+      0xd8, 0x18,         // envelope
+      0x5a,               // byte string with 32 bit length
+      0,    0,    0, 95,  // length is 95 bytes
+  };
+  expected.push_back(0xbf);  // indef length map start
+  EncodeString8(SpanFrom("string"), &expected);
+  // This is followed by the encoded string for "Hello, 🌎."
+  // So, it's the same bytes that we tested above in
+  // EncodeDecodeString16Test.RoundtripsHelloWorld.
+  expected.push_back(/*major type=*/2 << 5 | /*additional info=*/20);
+  for (uint8_t ch : std::array<uint8_t, 20>{
+           {'H', 0, 'e', 0, 'l',  0,    'l',  0,    'o', 0,
+            ',', 0, ' ', 0, 0x3c, 0xd8, 0x0e, 0xdf, '.', 0}})
+    expected.push_back(ch);
+  EncodeString8(SpanFrom("double"), &expected);
+  EncodeDouble(3.1415, &expected);
+  EncodeString8(SpanFrom("int"), &expected);
+  EncodeInt32(1, &expected);
+  EncodeString8(SpanFrom("negative int"), &expected);
+  EncodeInt32(-1, &expected);
+  EncodeString8(SpanFrom("bool"), &expected);
+  expected.push_back(7 << 5 | 21);  // RFC 7049 Section 2.3, Table 2: true
+  EncodeString8(SpanFrom("null"), &expected);
+  expected.push_back(7 << 5 | 22);  // RFC 7049 Section 2.3, Table 2: null
+  EncodeString8(SpanFrom("array"), &expected);
+  expected.push_back(0xd8);  // envelope (tag first byte)
+  expected.push_back(0x18);  // envelope (tag second byte)
+  expected.push_back(0x5a);  // byte string with 32 bit length
+  // the length is 5 bytes (that's up to end indef length array below).
+  for (uint8_t ch : std::array<uint8_t, 4>{{0, 0, 0, 5}})
+    expected.push_back(ch);
+  expected.push_back(0x9f);  // RFC 7049 Section 2.2.1, indef length array start
+  expected.push_back(1);     // Three UNSIGNED values (easy since Major Type 0)
+  expected.push_back(2);
+  expected.push_back(3);
+  expected.push_back(0xff);  // End indef length array
+  expected.push_back(0xff);  // End indef length map
+  EXPECT_TRUE(status.ok());
+  EXPECT_THAT(encoded, ElementsAreArray(expected));
+
+  // And now we roundtrip, decoding the message we just encoded.
+  std::string decoded;
+  std::unique_ptr<ParserHandler> json_encoder =
+      json::NewJSONEncoder(&decoded, &status);
+  ParseCBOR(span<uint8_t>(encoded.data(), encoded.size()), json_encoder.get());
+  EXPECT_THAT(status, StatusIsOk());
+  EXPECT_EQ(json, decoded);
+}
+
+TEST(JsonCborRoundtrip, MoreRoundtripExamples) {
+  std::vector<std::string> examples = {
+      // Tests that after closing a nested objects, additional key/value pairs
+      // are considered.
+      "{\"foo\":{\"bar\":1},\"baz\":2}", "{\"foo\":[1,2,3],\"baz\":2}"};
+  for (const std::string& json : examples) {
+    SCOPED_TRACE(std::string("example: ") + json);
+    std::vector<uint8_t> encoded;
+    Status status;
+    std::unique_ptr<ParserHandler> encoder = NewCBOREncoder(&encoded, &status);
+    span<uint8_t> ascii_in = SpanFrom(json);
+    json::ParseJSON(ascii_in, encoder.get());
+    std::string decoded;
+    std::unique_ptr<ParserHandler> json_writer =
+        json::NewJSONEncoder(&decoded, &status);
+    ParseCBOR(span<uint8_t>(encoded.data(), encoded.size()), json_writer.get());
+    EXPECT_THAT(status, StatusIsOk());
+    EXPECT_EQ(json, decoded);
+  }
+}
+
+TEST(JSONToCBOREncoderTest, HelloWorldBinary_WithTripToJson) {
+  // The ParserHandler::HandleBinary is a special case: The JSON parser
+  // will never call this method, because JSON does not natively support the
+  // binary type. So, we can't fully roundtrip. However, the other direction
+  // works: binary will be rendered in JSON, as a base64 string. So, we make
+  // calls to the encoder directly here, to construct a message, and one of
+  // these calls is ::HandleBinary, to which we pass a "binary" string
+  // containing "Hello, world.".
+  std::vector<uint8_t> encoded;
+  Status status;
+  std::unique_ptr<ParserHandler> encoder = NewCBOREncoder(&encoded, &status);
+  encoder->HandleMapBegin();
+  // Emit a key.
+  std::vector<uint16_t> key = {'f', 'o', 'o'};
+  encoder->HandleString16(SpanFrom(key));
+  // Emit the binary payload, an arbitrary array of bytes that happens to
+  // be the ascii message "Hello, world.".
+  encoder->HandleBinary(SpanFrom(std::vector<uint8_t>{
+      'H', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '.'}));
+  encoder->HandleMapEnd();
+  EXPECT_THAT(status, StatusIsOk());
+
+  // Now drive the json writer via the CBOR decoder.
+  std::string decoded;
+  std::unique_ptr<ParserHandler> json_writer =
+      json::NewJSONEncoder(&decoded, &status);
+  ParseCBOR(SpanFrom(encoded), json_writer.get());
+  EXPECT_THAT(status, StatusIsOk());
+  // "Hello, world." in base64 is "SGVsbG8sIHdvcmxkLg==".
+  EXPECT_EQ("{\"foo\":\"SGVsbG8sIHdvcmxkLg==\"}", decoded);
+}
+
+// =============================================================================
+// cbor::ParseCBOR - for receiving streaming parser events for CBOR messages
+// =============================================================================
+
+TEST(ParseCBORTest, ParseEmptyCBORMessage) {
+  // An envelope starting with 0xd8, 0x5a, with the byte length
+  // of 2, containing a map that's empty (0xbf for map
+  // start, and 0xff for map end).
+  std::vector<uint8_t> in = {0xd8, 0x5a, 0, 0, 0, 2, 0xbf, 0xff};
+  std::string out;
+  Status status;
+  std::unique_ptr<ParserHandler> json_writer =
+      json::NewJSONEncoder(&out, &status);
+  ParseCBOR(span<uint8_t>(in.data(), in.size()), json_writer.get());
+  EXPECT_THAT(status, StatusIsOk());
+  EXPECT_EQ("{}", out);
+}
+
+TEST(ParseCBORTest, ParseCBORHelloWorld) {
+  const uint8_t kPayloadLen = 27;
+  std::vector<uint8_t> bytes = {0xd8, 0x5a, 0, 0, 0, kPayloadLen};
+  bytes.push_back(0xbf);                   // start indef length map.
+  EncodeString8(SpanFrom("msg"), &bytes);  // key: msg
+  // Now write the value, the familiar "Hello, 🌎." where the globe is expressed
+  // as two utf16 chars.
+  bytes.push_back(/*major type=*/2 << 5 | /*additional info=*/20);
+  for (uint8_t ch : std::array<uint8_t, 20>{
+           {'H', 0, 'e', 0, 'l',  0,    'l',  0,    'o', 0,
+            ',', 0, ' ', 0, 0x3c, 0xd8, 0x0e, 0xdf, '.', 0}})
+    bytes.push_back(ch);
+  bytes.push_back(0xff);  // stop byte
+  EXPECT_EQ(kPayloadLen, bytes.size() - 6);
+
+  std::string out;
+  Status status;
+  std::unique_ptr<ParserHandler> json_writer =
+      json::NewJSONEncoder(&out, &status);
+  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+  EXPECT_THAT(status, StatusIsOk());
+  EXPECT_EQ("{\"msg\":\"Hello, \\ud83c\\udf0e.\"}", out);
+}
+
+TEST(ParseCBORTest, UTF8IsSupportedInKeys) {
+  const uint8_t kPayloadLen = 11;
+  std::vector<uint8_t> bytes = {0xd8, 0x5a,  // envelope
+                                0,    0,    0, kPayloadLen};
+  bytes.push_back(cbor::EncodeIndefiniteLengthMapStart());
+  // Two UTF16 chars.
+  EncodeString8(SpanFrom("🌎"), &bytes);
+  // Can be encoded as a single UTF16 char.
+  EncodeString8(SpanFrom("☾"), &bytes);
+  bytes.push_back(cbor::EncodeStop());
+  EXPECT_EQ(kPayloadLen, bytes.size() - 6);
+
+  std::string out;
+  Status status;
+  std::unique_ptr<ParserHandler> json_writer =
+      json::NewJSONEncoder(&out, &status);
+  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+  EXPECT_THAT(status, StatusIsOk());
+  EXPECT_EQ("{\"\\ud83c\\udf0e\":\"\\u263e\"}", out);
+}
+
+TEST(ParseCBORTest, NoInputError) {
+  std::vector<uint8_t> in = {};
+  std::string out;
+  Status status;
+  std::unique_ptr<ParserHandler> json_writer =
+      json::NewJSONEncoder(&out, &status);
+  ParseCBOR(span<uint8_t>(in.data(), in.size()), json_writer.get());
+  EXPECT_THAT(status, StatusIs(Error::CBOR_UNEXPECTED_EOF_IN_ENVELOPE, 0u));
+  EXPECT_EQ("", out);
+}
+
+TEST(ParseCBORTest, UnexpectedEofExpectedValueError) {
+  constexpr uint8_t kPayloadLen = 5;
+  std::vector<uint8_t> bytes = {0xd8, 0x5a, 0, 0, 0, kPayloadLen,  // envelope
+                                0xbf};                             // map start
+  // A key; so value would be next.
+  EncodeString8(SpanFrom("key"), &bytes);
+  EXPECT_EQ(kPayloadLen, bytes.size() - 6);
+  std::string out;
+  Status status;
+  std::unique_ptr<ParserHandler> json_writer =
+      json::NewJSONEncoder(&out, &status);
+  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+  EXPECT_THAT(status, StatusIs(Error::CBOR_UNEXPECTED_EOF_EXPECTED_VALUE,
+                               bytes.size()));
+  EXPECT_EQ("", out);
+}
+
+TEST(ParseCBORTest, UnexpectedEofInArrayError) {
+  constexpr uint8_t kPayloadLen = 8;
+  std::vector<uint8_t> bytes = {0xd8, 0x5a, 0, 0, 0, kPayloadLen,  // envelope
+                                0xbf};  // The byte for starting a map.
+  // A key; so value would be next.
+  EncodeString8(SpanFrom("array"), &bytes);
+  bytes.push_back(0x9f);  // byte for indefinite length array start.
+  EXPECT_EQ(kPayloadLen, bytes.size() - 6);
+  std::string out;
+  Status status;
+  std::unique_ptr<ParserHandler> json_writer =
+      json::NewJSONEncoder(&out, &status);
+  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+  EXPECT_THAT(status,
+              StatusIs(Error::CBOR_UNEXPECTED_EOF_IN_ARRAY, bytes.size()));
+  EXPECT_EQ("", out);
+}
+
+TEST(ParseCBORTest, UnexpectedEofInMapError) {
+  constexpr uint8_t kPayloadLen = 1;
+  std::vector<uint8_t> bytes = {0xd8, 0x5a, 0, 0, 0, kPayloadLen,  // envelope
+                                0xbf};  // The byte for starting a map.
+  EXPECT_EQ(kPayloadLen, bytes.size() - 6);
+  std::string out;
+  Status status;
+  std::unique_ptr<ParserHandler> json_writer =
+      json::NewJSONEncoder(&out, &status);
+  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+  EXPECT_THAT(status, StatusIs(Error::CBOR_UNEXPECTED_EOF_IN_MAP, 7u));
+  EXPECT_EQ("", out);
+}
+
+TEST(ParseCBORTest, EnvelopeEncodingLegacy) {
+  constexpr uint8_t kPayloadLen = 8;
+  std::vector<uint8_t> bytes = {0xd8, 0x5a, 0, 0, 0, kPayloadLen};  // envelope
+  bytes.push_back(cbor::EncodeIndefiniteLengthMapStart());
+  EncodeString8(SpanFrom("foo"), &bytes);
+  EncodeInt32(42, &bytes);
+  bytes.emplace_back(EncodeStop());
+  std::string out;
+  Status status;
+  std::unique_ptr<ParserHandler> json_writer =
+      json::NewJSONEncoder(&out, &status);
+  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+  EXPECT_THAT(status, StatusIsOk());
+  EXPECT_EQ(out, "{\"foo\":42}");
+}
+
+TEST(ParseCBORTest, EnvelopeEncodingBySpec) {
+  constexpr uint8_t kPayloadLen = 8;
+  std::vector<uint8_t> bytes = {0xd8, 0x18, 0x5a,       0,
+                                0,    0,    kPayloadLen};  // envelope
+  bytes.push_back(cbor::EncodeIndefiniteLengthMapStart());
+  EncodeString8(SpanFrom("foo"), &bytes);
+  EncodeInt32(42, &bytes);
+  bytes.emplace_back(EncodeStop());
+  std::string out;
+  Status status;
+  std::unique_ptr<ParserHandler> json_writer =
+      json::NewJSONEncoder(&out, &status);
+  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+  EXPECT_THAT(status, StatusIsOk());
+  EXPECT_EQ(out, "{\"foo\":42}");
+}
+
+TEST(ParseCBORTest, NoEmptyEnvelopesAllowed) {
+  std::vector<uint8_t> bytes = {0xd8, 0x5a, 0, 0, 0, 0};  // envelope
+  std::string out;
+  Status status;
+  std::unique_ptr<ParserHandler> json_writer =
+      json::NewJSONEncoder(&out, &status);
+  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+  EXPECT_THAT(status, StatusIs(Error::CBOR_MAP_OR_ARRAY_EXPECTED_IN_ENVELOPE,
+                               bytes.size()));
+  EXPECT_EQ("", out);
+}
+
+TEST(ParseCBORTest, OnlyMapsAndArraysSupportedInsideEnvelopes) {
+  // The top level is a map with key "foo", and the value
+  // is an envelope that contains just a number (1). We don't
+  // allow numbers to be contained in an envelope though, only
+  // maps and arrays.
+  constexpr uint8_t kPayloadLen = 8;
+  std::vector<uint8_t> bytes = {0xd8,
+                                0x5a,
+                                0,
+                                0,
+                                0,
+                                kPayloadLen,  // envelope
+                                EncodeIndefiniteLengthMapStart()};
+  EncodeString8(SpanFrom("foo"), &bytes);
+  for (uint8_t byte : {0xd8, 0x5a, 0, 0, 0, /*payload_len*/ 1})
+    bytes.emplace_back(byte);
+  size_t error_pos = bytes.size();
+  bytes.push_back(1);  // Envelope contents / payload = number 1.
+  bytes.emplace_back(EncodeStop());
+
+  std::string out;
+  Status status;
+  std::unique_ptr<ParserHandler> json_writer =
+      json::NewJSONEncoder(&out, &status);
+  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+  EXPECT_THAT(status, StatusIs(Error::CBOR_MAP_OR_ARRAY_EXPECTED_IN_ENVELOPE,
+                               error_pos));
+  EXPECT_EQ("", out);
+}
+
+TEST(ParseCBORTest, InvalidMapKeyError) {
+  constexpr uint8_t kPayloadLen = 2;
+  std::vector<uint8_t> bytes = {0xd8,       0x5a, 0,
+                                0,          0,    kPayloadLen,  // envelope
+                                0xbf,                           // map start
+                                7 << 5 | 22};  // null (not a valid map key)
+  EXPECT_EQ(kPayloadLen, bytes.size() - 6);
+  std::string out;
+  Status status;
+  std::unique_ptr<ParserHandler> json_writer =
+      json::NewJSONEncoder(&out, &status);
+  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+  EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_MAP_KEY, 7u));
+  EXPECT_EQ("", out);
+}
+
+std::vector<uint8_t> MakeNestedCBOR(int depth) {
+  std::vector<uint8_t> bytes;
+  std::vector<EnvelopeEncoder> envelopes;
+  for (int ii = 0; ii < depth; ++ii) {
+    envelopes.emplace_back();
+    envelopes.back().EncodeStart(&bytes);
+    bytes.push_back(0xbf);  // indef length map start
+    EncodeString8(SpanFrom("key"), &bytes);
+  }
+  EncodeString8(SpanFrom("innermost_value"), &bytes);
+  for (int ii = 0; ii < depth; ++ii) {
+    bytes.push_back(0xff);  // stop byte, finishes map.
+    envelopes.back().EncodeStop(&bytes);
+    envelopes.pop_back();
+  }
+  return bytes;
+}
+
+TEST(ParseCBORTest, StackLimitExceededError) {
+  {  // Depth 3: no stack limit exceeded error and is easy to inspect.
+    std::vector<uint8_t> bytes = MakeNestedCBOR(3);
+    std::string out;
+    Status status;
+    std::unique_ptr<ParserHandler> json_writer =
+        json::NewJSONEncoder(&out, &status);
+    ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+    EXPECT_THAT(status, StatusIsOk());
+    EXPECT_EQ("{\"key\":{\"key\":{\"key\":\"innermost_value\"}}}", out);
+  }
+  {  // Depth 300: no stack limit exceeded.
+    std::vector<uint8_t> bytes = MakeNestedCBOR(300);
+    std::string out;
+    Status status;
+    std::unique_ptr<ParserHandler> json_writer =
+        json::NewJSONEncoder(&out, &status);
+    ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+    EXPECT_THAT(status, StatusIsOk());
+  }
+
+  // We just want to know the length of one opening map so we can compute
+  // where the error is encountered. So we look at a small example and find
+  // the second envelope start.
+  std::vector<uint8_t> small_example = MakeNestedCBOR(3);
+  size_t opening_segment_size = 1;  // Start after the first envelope start.
+  while (opening_segment_size < small_example.size() &&
+         small_example[opening_segment_size] != 0xd8)
+    opening_segment_size++;
+
+  {  // Depth 301: limit exceeded.
+    std::vector<uint8_t> bytes = MakeNestedCBOR(301);
+    std::string out;
+    Status status;
+    std::unique_ptr<ParserHandler> json_writer =
+        json::NewJSONEncoder(&out, &status);
+    ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+    EXPECT_THAT(status, StatusIs(Error::CBOR_STACK_LIMIT_EXCEEDED,
+                                 opening_segment_size * 301));
+  }
+  {  // Depth 320: still limit exceeded, and at the same pos as for 1001
+    std::vector<uint8_t> bytes = MakeNestedCBOR(320);
+    std::string out;
+    Status status;
+    std::unique_ptr<ParserHandler> json_writer =
+        json::NewJSONEncoder(&out, &status);
+    ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+    EXPECT_THAT(status, StatusIs(Error::CBOR_STACK_LIMIT_EXCEEDED,
+                                 opening_segment_size * 301));
+  }
+}
+
+TEST(ParseCBORTest, UnsupportedValueError) {
+  constexpr uint8_t kPayloadLen = 6;
+  std::vector<uint8_t> bytes = {0xd8, 0x5a, 0, 0, 0, kPayloadLen,  // envelope
+                                0xbf};                             // map start
+  EncodeString8(SpanFrom("key"), &bytes);
+  size_t error_pos = bytes.size();
+  bytes.push_back(6 << 5 | 5);  // tags aren't supported yet.
+  EXPECT_EQ(kPayloadLen, bytes.size() - 6);
+
+  std::string out;
+  Status status;
+  std::unique_ptr<ParserHandler> json_writer =
+      json::NewJSONEncoder(&out, &status);
+  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+  EXPECT_THAT(status, StatusIs(Error::CBOR_UNSUPPORTED_VALUE, error_pos));
+  EXPECT_EQ("", out);
+}
+
+TEST(ParseCBORTest, InvalidString16Error) {
+  constexpr uint8_t kPayloadLen = 11;
+  std::vector<uint8_t> bytes = {0xd8, 0x5a, 0, 0, 0, kPayloadLen,  // envelope
+                                0xbf};                             // map start
+  EncodeString8(SpanFrom("key"), &bytes);
+  size_t error_pos = bytes.size();
+  // a BYTE_STRING of length 5 as value; since we interpret these as string16,
+  // it's going to be invalid as each character would need two bytes, but
+  // 5 isn't divisible by 2.
+  bytes.push_back(2 << 5 | 5);
+  for (int ii = 0; ii < 5; ++ii)
+    bytes.push_back(' ');
+  EXPECT_EQ(kPayloadLen, bytes.size() - 6);
+  std::string out;
+  Status status;
+  std::unique_ptr<ParserHandler> json_writer =
+      json::NewJSONEncoder(&out, &status);
+  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+  EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_STRING16, error_pos));
+  EXPECT_EQ("", out);
+}
+
+TEST(ParseCBORTest, InvalidString8Error) {
+  constexpr uint8_t kPayloadLen = 6;
+  std::vector<uint8_t> bytes = {0xd8, 0x5a, 0, 0, 0, kPayloadLen,  // envelope
+                                0xbf};                             // map start
+  EncodeString8(SpanFrom("key"), &bytes);
+  size_t error_pos = bytes.size();
+  // a STRING of length 5 as value, but we're at the end of the bytes array
+  // so it can't be decoded successfully.
+  bytes.push_back(3 << 5 | 5);
+  EXPECT_EQ(kPayloadLen, bytes.size() - 6);
+  std::string out;
+  Status status;
+  std::unique_ptr<ParserHandler> json_writer =
+      json::NewJSONEncoder(&out, &status);
+  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+  EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_STRING8, error_pos));
+  EXPECT_EQ("", out);
+}
+
+TEST(ParseCBORTest, InvalidBinaryError) {
+  constexpr uint8_t kPayloadLen = 9;
+  std::vector<uint8_t> bytes = {0xd8, 0x5a, 0, 0, 0, kPayloadLen,  // envelope
+                                0xbf};                             // map start
+  EncodeString8(SpanFrom("key"), &bytes);
+  size_t error_pos = bytes.size();
+  bytes.push_back(6 << 5 | 22);  // base64 hint for JSON; indicates binary
+  bytes.push_back(2 << 5 | 10);  // BYTE_STRING (major type 2) of length 10
+  // Just two garbage bytes, not enough for the binary.
+  bytes.push_back(0x31);
+  bytes.push_back(0x23);
+  EXPECT_EQ(kPayloadLen, bytes.size() - 6);
+  std::string out;
+  Status status;
+  std::unique_ptr<ParserHandler> json_writer =
+      json::NewJSONEncoder(&out, &status);
+  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+  EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_BINARY, error_pos));
+  EXPECT_EQ("", out);
+}
+
+TEST(ParseCBORTest, InvalidDoubleError) {
+  constexpr uint8_t kPayloadLen = 8;
+  std::vector<uint8_t> bytes = {0xd8, 0x5a, 0, 0, 0, kPayloadLen,  // envelope
+                                0xbf};                             // map start
+  EncodeString8(SpanFrom("key"), &bytes);
+  size_t error_pos = bytes.size();
+  bytes.push_back(7 << 5 | 27);  // initial byte for double
+  // Just two garbage bytes, not enough to represent an actual double.
+  bytes.push_back(0x31);
+  bytes.push_back(0x23);
+  EXPECT_EQ(kPayloadLen, bytes.size() - 6);
+  std::string out;
+  Status status;
+  std::unique_ptr<ParserHandler> json_writer =
+      json::NewJSONEncoder(&out, &status);
+  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+  EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_DOUBLE, error_pos));
+  EXPECT_EQ("", out);
+}
+
+TEST(ParseCBORTest, InvalidSignedError) {
+  constexpr uint8_t kPayloadLen = 14;
+  std::vector<uint8_t> bytes = {0xd8, 0x5a, 0, 0, 0, kPayloadLen,  // envelope
+                                0xbf};                             // map start
+  EncodeString8(SpanFrom("key"), &bytes);
+  size_t error_pos = bytes.size();
+  // uint64_t max is a perfectly fine value to encode as CBOR unsigned,
+  // but we don't support this since we only cover the int32_t range.
+  internals::WriteTokenStart(MajorType::UNSIGNED,
+                             std::numeric_limits<uint64_t>::max(), &bytes);
+  EXPECT_EQ(kPayloadLen, bytes.size() - 6);
+  std::string out;
+  Status status;
+  std::unique_ptr<ParserHandler> json_writer =
+      json::NewJSONEncoder(&out, &status);
+  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+  EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_INT32, error_pos));
+  EXPECT_EQ("", out);
+}
+
+TEST(ParseCBORTest, TrailingJunk) {
+  constexpr uint8_t kPayloadLen = 12;
+  std::vector<uint8_t> bytes = {0xd8, 0x5a, 0, 0, 0, kPayloadLen,  // envelope
+                                0xbf};                             // map start
+  EncodeString8(SpanFrom("key"), &bytes);
+  EncodeString8(SpanFrom("value"), &bytes);
+  bytes.push_back(0xff);  // Up to here, it's a perfectly fine msg.
+  ASSERT_EQ(kPayloadLen, bytes.size() - 6);
+  size_t error_pos = bytes.size();
+  // Now write some trailing junk after the message.
+  EncodeString8(SpanFrom("trailing junk"), &bytes);
+  internals::WriteTokenStart(MajorType::UNSIGNED,
+                             std::numeric_limits<uint64_t>::max(), &bytes);
+  std::string out;
+  Status status;
+  std::unique_ptr<ParserHandler> json_writer =
+      json::NewJSONEncoder(&out, &status);
+  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+  EXPECT_THAT(status, StatusIs(Error::CBOR_TRAILING_JUNK, error_pos));
+  EXPECT_EQ("", out);
+}
+
+TEST(ParseCBORTest, EnvelopeContentsLengthMismatch) {
+  constexpr uint8_t kPartialPayloadLen = 5;
+  std::vector<uint8_t> bytes = {0xd8, 0x5a, 0,
+                                0,    0,    kPartialPayloadLen,  // envelope
+                                0xbf};                           // map start
+  EncodeString8(SpanFrom("key"), &bytes);
+  // kPartialPayloadLen would need to indicate the length of the entire map,
+  // all the way past the 0xff map stop character. Instead, it only covers
+  // a portion of the map.
+  EXPECT_EQ(bytes.size() - 6, kPartialPayloadLen);
+  EncodeString8(SpanFrom("value"), &bytes);
+  bytes.push_back(0xff);  // map stop
+
+  std::string out;
+  Status status;
+  std::unique_ptr<ParserHandler> json_writer =
+      json::NewJSONEncoder(&out, &status);
+  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
+  EXPECT_THAT(status, StatusIs(Error::CBOR_ENVELOPE_CONTENTS_LENGTH_MISMATCH,
+                               bytes.size()));
+  EXPECT_EQ("", out);
+}
+
+// =============================================================================
+// cbor::EnvelopeHeader - for parsing envelope headers
+// =============================================================================
+// Note most of converage for this is historically on a higher level of
+// ParseCBOR(). This provides just a few essnetial scenarios for now.
+
+template <typename T>
+class EnvelopeHeaderTest : public ::testing::Test {};
+
+TEST(EnvelopeHeaderTest, EnvelopeStartLegacy) {
+  std::vector<uint8_t> bytes = {0xd8,             // Tag start
+                                0x5a,             // Byte string, 4 bytes length
+                                0,    0,   0, 2,  // Length
+                                0xbf, 0xff};      // map start / map end
+  auto result = EnvelopeHeader::Parse(SpanFrom(bytes));
+  ASSERT_THAT(result.status(), StatusIsOk());
+  EXPECT_THAT((*result).header_size(), Eq(6u));
+  EXPECT_THAT((*result).content_size(), Eq(2u));
+  EXPECT_THAT((*result).outer_size(), Eq(8u));
+}
+
+TEST(EnvelopeHeaderTest, EnvelopeStartSpecCompliant) {
+  std::vector<uint8_t> bytes = {0xd8,             // Tag start
+                                0x18,             // Tag type (CBOR)
+                                0x5a,             // Byte string, 4 bytes length
+                                0,    0,   0, 2,  // Length
+                                0xbf, 0xff};      // map start / map end
+  auto result = EnvelopeHeader::Parse(SpanFrom(bytes));
+  ASSERT_THAT(result.status(), StatusIsOk());
+  EXPECT_THAT((*result).header_size(), Eq(7u));
+  EXPECT_THAT((*result).content_size(), Eq(2u));
+  EXPECT_THAT((*result).outer_size(), Eq(9u));
+}
+
+TEST(EnvelopeHeaderTest, EnvelopeStartShortLen) {
+  std::vector<uint8_t> bytes = {0xd8,         // Tag start
+                                0x18,         // Tag type (CBOR)
+                                0x58,         // Byte string, 1 byte length
+                                2,            // Length
+                                0xbf, 0xff};  // map start / map end
+  auto result = EnvelopeHeader::Parse(SpanFrom(bytes));
+  ASSERT_THAT(result.status(), StatusIsOk());
+  EXPECT_THAT((*result).header_size(), Eq(4u));
+  EXPECT_THAT((*result).content_size(), Eq(2u));
+  EXPECT_THAT((*result).outer_size(), Eq(6u));
+}
+
+TEST(EnvelopeHeaderTest, ParseFragment) {
+  std::vector<uint8_t> bytes = {0xd8,  // Tag start
+                                0x18,  // Tag type (CBOR)
+                                0x5a,  // Byte string, 4 bytes length
+                                0,    0, 0, 20, 0xbf};  // map start
+  auto result = EnvelopeHeader::ParseFromFragment(SpanFrom(bytes));
+  ASSERT_THAT(result.status(), StatusIsOk());
+  EXPECT_THAT((*result).header_size(), Eq(7u));
+  EXPECT_THAT((*result).content_size(), Eq(20u));
+  EXPECT_THAT((*result).outer_size(), Eq(27u));
+
+  result = EnvelopeHeader::Parse(SpanFrom(bytes));
+  ASSERT_THAT(result.status(),
+              StatusIs(Error::CBOR_ENVELOPE_CONTENTS_LENGTH_MISMATCH, 8));
+}
+
+// =============================================================================
+// cbor::AppendString8EntryToMap - for limited in-place editing of messages
+// =============================================================================
+
+template <typename T>
+class AppendString8EntryToMapTest : public ::testing::Test {};
+
+using ContainerTestTypes = ::testing::Types<std::vector<uint8_t>, std::string>;
+TYPED_TEST_SUITE(AppendString8EntryToMapTest, ContainerTestTypes);
+
+TEST(AppendString8EntryToMapTest, AppendsEntrySuccessfully) {
+  constexpr uint8_t kPayloadLen = 12;
+  std::vector<uint8_t> bytes = {0xd8, 0x5a, 0, 0, 0, kPayloadLen,  // envelope
+                                0xbf};                             // map start
+  size_t pos_before_payload = bytes.size() - 1;
+  EncodeString8(SpanFrom("key"), &bytes);
+  EncodeString8(SpanFrom("value"), &bytes);
+  bytes.push_back(0xff);  // A perfectly fine cbor message.
+  EXPECT_EQ(kPayloadLen, bytes.size() - pos_before_payload);
+
+  std::vector<uint8_t> msg(bytes.begin(), bytes.end());
+
+  Status status =
+      AppendString8EntryToCBORMap(SpanFrom("foo"), SpanFrom("bar"), &msg);
+  EXPECT_THAT(status, StatusIsOk());
+  std::string out;
+  std::unique_ptr<ParserHandler> json_writer =
+      json::NewJSONEncoder(&out, &status);
+  ParseCBOR(SpanFrom(msg), json_writer.get());
+  EXPECT_EQ("{\"key\":\"value\",\"foo\":\"bar\"}", out);
+  EXPECT_THAT(status, StatusIsOk());
+}
+
+TYPED_TEST(AppendString8EntryToMapTest, AppendThreeEntries) {
+  std::vector<uint8_t> encoded = {
+      0xd8, 0x5a, 0, 0, 0, 2, EncodeIndefiniteLengthMapStart(), EncodeStop()};
+  EXPECT_THAT(
+      AppendString8EntryToCBORMap(SpanFrom("key"), SpanFrom("value"), &encoded),
+      StatusIsOk());
+  EXPECT_THAT(AppendString8EntryToCBORMap(SpanFrom("key1"), SpanFrom("value1"),
+                                          &encoded),
+              StatusIsOk());
+  EXPECT_THAT(AppendString8EntryToCBORMap(SpanFrom("key2"), SpanFrom("value2"),
+                                          &encoded),
+              StatusIsOk());
+  TypeParam msg(encoded.begin(), encoded.end());
+  std::string out;
+  Status status;
+  std::unique_ptr<ParserHandler> json_writer =
+      json::NewJSONEncoder(&out, &status);
+  ParseCBOR(SpanFrom(msg), json_writer.get());
+  EXPECT_EQ("{\"key\":\"value\",\"key1\":\"value1\",\"key2\":\"value2\"}", out);
+  EXPECT_THAT(status, StatusIsOk());
+}
+
+TEST(AppendString8EntryToMapTest, MapStartExpected_Error) {
+  std::vector<uint8_t> msg = {
+      0xd8, 0x5a, 0, 0, 0, 1, EncodeIndefiniteLengthArrayStart()};
+  Status status =
+      AppendString8EntryToCBORMap(SpanFrom("key"), SpanFrom("value"), &msg);
+  EXPECT_THAT(status, StatusIs(Error::CBOR_MAP_START_EXPECTED, 6u));
+}
+
+TEST(AppendString8EntryToMapTest, MapStopExpected_Error) {
+  std::vector<uint8_t> msg = {
+      0xd8, 0x5a, 0, 0, 0, 2, EncodeIndefiniteLengthMapStart(), 42};
+  Status status =
+      AppendString8EntryToCBORMap(SpanFrom("key"), SpanFrom("value"), &msg);
+  EXPECT_THAT(status, StatusIs(Error::CBOR_MAP_STOP_EXPECTED, 7u));
+}
+
+TEST(AppendString8EntryToMapTest, InvalidEnvelope_Error) {
+  {  // Second byte is wrong.
+    std::vector<uint8_t> msg = {
+        0x5a, 0, 0, 0, 2, EncodeIndefiniteLengthMapStart(), EncodeStop(), 0};
+    Status status =
+        AppendString8EntryToCBORMap(SpanFrom("key"), SpanFrom("value"), &msg);
+    EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_ENVELOPE, 0u));
+  }
+  {  // Second byte is wrong.
+    std::vector<uint8_t> msg = {
+        0xd8, 0x7a, 0, 0, 0, 2, EncodeIndefiniteLengthMapStart(), EncodeStop()};
+    Status status =
+        AppendString8EntryToCBORMap(SpanFrom("key"), SpanFrom("value"), &msg);
+    EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_ENVELOPE, 1u));
+  }
+  {  // Invalid envelope size example.
+    std::vector<uint8_t> msg = {
+        0xd8, 0x5a, 0, 0, 0, 3, EncodeIndefiniteLengthMapStart(), EncodeStop(),
+    };
+    Status status =
+        AppendString8EntryToCBORMap(SpanFrom("key"), SpanFrom("value"), &msg);
+    EXPECT_THAT(status,
+                StatusIs(Error::CBOR_ENVELOPE_CONTENTS_LENGTH_MISMATCH, 8u));
+  }
+  {  // Invalid envelope size example.
+    std::vector<uint8_t> msg = {
+        0xd8, 0x5a, 0, 0, 0, 1, EncodeIndefiniteLengthMapStart(), EncodeStop(),
+    };
+    Status status =
+        AppendString8EntryToCBORMap(SpanFrom("key"), SpanFrom("value"), &msg);
+    EXPECT_THAT(status, StatusIs(Error::CBOR_INVALID_ENVELOPE, 0));
+  }
+}
+}  // namespace cbor
+}  // namespace crdtp
diff --git a/tools/inspector_protocol/crdtp/dispatch.cc b/tools/inspector_protocol/crdtp/dispatch.cc
new file mode 100644
index 00000000000000..b36b91ad0e37e6
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/dispatch.cc
@@ -0,0 +1,584 @@
+// Copyright 2020 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "dispatch.h"
+
+#include <cassert>
+#include "cbor.h"
+#include "error_support.h"
+#include "find_by_first.h"
+#include "frontend_channel.h"
+#include "protocol_core.h"
+
+namespace crdtp {
+// =============================================================================
+// DispatchResponse - Error status and chaining / fall through
+// =============================================================================
+
+// static
+DispatchResponse DispatchResponse::Success() {
+  DispatchResponse result;
+  result.code_ = DispatchCode::SUCCESS;
+  return result;
+}
+
+// static
+DispatchResponse DispatchResponse::FallThrough() {
+  DispatchResponse result;
+  result.code_ = DispatchCode::FALL_THROUGH;
+  return result;
+}
+
+// static
+DispatchResponse DispatchResponse::ParseError(std::string message) {
+  DispatchResponse result;
+  result.code_ = DispatchCode::PARSE_ERROR;
+  result.message_ = std::move(message);
+  return result;
+}
+
+// static
+DispatchResponse DispatchResponse::InvalidRequest(std::string message) {
+  DispatchResponse result;
+  result.code_ = DispatchCode::INVALID_REQUEST;
+  result.message_ = std::move(message);
+  return result;
+}
+
+// static
+DispatchResponse DispatchResponse::MethodNotFound(std::string message) {
+  DispatchResponse result;
+  result.code_ = DispatchCode::METHOD_NOT_FOUND;
+  result.message_ = std::move(message);
+  return result;
+}
+
+// static
+DispatchResponse DispatchResponse::InvalidParams(std::string message) {
+  DispatchResponse result;
+  result.code_ = DispatchCode::INVALID_PARAMS;
+  result.message_ = std::move(message);
+  return result;
+}
+
+// static
+DispatchResponse DispatchResponse::InternalError() {
+  DispatchResponse result;
+  result.code_ = DispatchCode::INTERNAL_ERROR;
+  result.message_ = "Internal error";
+  return result;
+}
+
+// static
+DispatchResponse DispatchResponse::ServerError(std::string message) {
+  DispatchResponse result;
+  result.code_ = DispatchCode::SERVER_ERROR;
+  result.message_ = std::move(message);
+  return result;
+}
+
+// static
+DispatchResponse DispatchResponse::SessionNotFound(std::string message) {
+  DispatchResponse result;
+  result.code_ = DispatchCode::SESSION_NOT_FOUND;
+  result.message_ = std::move(message);
+  return result;
+}
+
+// =============================================================================
+// Dispatchable - a shallow parser for CBOR encoded DevTools messages
+// =============================================================================
+Dispatchable::Dispatchable(span<uint8_t> serialized) : serialized_(serialized) {
+  Status s = cbor::CheckCBORMessage(serialized);
+  if (!s.ok()) {
+    status_ = {Error::MESSAGE_MUST_BE_AN_OBJECT, s.pos};
+    return;
+  }
+  cbor::CBORTokenizer tokenizer(serialized);
+  if (tokenizer.TokenTag() == cbor::CBORTokenTag::ERROR_VALUE) {
+    status_ = tokenizer.Status();
+    return;
+  }
+
+  // We checked for the envelope start byte above, so the tokenizer
+  // must agree here, since it's not an error.
+  assert(tokenizer.TokenTag() == cbor::CBORTokenTag::ENVELOPE);
+
+  // Before we enter the envelope, we save the position that we
+  // expect to see after we're done parsing the envelope contents.
+  // This way we can compare and produce an error if the contents
+  // didn't fit exactly into the envelope length.
+  const size_t pos_past_envelope =
+      tokenizer.Status().pos + tokenizer.GetEnvelopeHeader().outer_size();
+  tokenizer.EnterEnvelope();
+  if (tokenizer.TokenTag() == cbor::CBORTokenTag::ERROR_VALUE) {
+    status_ = tokenizer.Status();
+    return;
+  }
+  if (tokenizer.TokenTag() != cbor::CBORTokenTag::MAP_START) {
+    status_ = {Error::MESSAGE_MUST_BE_AN_OBJECT, tokenizer.Status().pos};
+    return;
+  }
+  assert(tokenizer.TokenTag() == cbor::CBORTokenTag::MAP_START);
+  tokenizer.Next();  // Now we should be pointed at the map key.
+  while (tokenizer.TokenTag() != cbor::CBORTokenTag::STOP) {
+    switch (tokenizer.TokenTag()) {
+      case cbor::CBORTokenTag::DONE:
+        status_ =
+            Status{Error::CBOR_UNEXPECTED_EOF_IN_MAP, tokenizer.Status().pos};
+        return;
+      case cbor::CBORTokenTag::ERROR_VALUE:
+        status_ = tokenizer.Status();
+        return;
+      case cbor::CBORTokenTag::STRING8:
+        if (!MaybeParseProperty(&tokenizer))
+          return;
+        break;
+      default:
+        // We require the top-level keys to be UTF8 (US-ASCII in practice).
+        status_ = Status{Error::CBOR_INVALID_MAP_KEY, tokenizer.Status().pos};
+        return;
+    }
+  }
+  tokenizer.Next();
+  if (!has_call_id_) {
+    status_ = Status{Error::MESSAGE_MUST_HAVE_INTEGER_ID_PROPERTY,
+                     tokenizer.Status().pos};
+    return;
+  }
+  if (method_.empty()) {
+    status_ = Status{Error::MESSAGE_MUST_HAVE_STRING_METHOD_PROPERTY,
+                     tokenizer.Status().pos};
+    return;
+  }
+  // The contents of the envelope parsed OK, now check that we're at
+  // the expected position.
+  if (pos_past_envelope != tokenizer.Status().pos) {
+    status_ = Status{Error::CBOR_ENVELOPE_CONTENTS_LENGTH_MISMATCH,
+                     tokenizer.Status().pos};
+    return;
+  }
+  if (tokenizer.TokenTag() != cbor::CBORTokenTag::DONE) {
+    status_ = Status{Error::CBOR_TRAILING_JUNK, tokenizer.Status().pos};
+    return;
+  }
+}
+
+bool Dispatchable::ok() const {
+  return status_.ok();
+}
+
+DispatchResponse Dispatchable::DispatchError() const {
+  // TODO(johannes): Replace with DCHECK / similar?
+  if (status_.ok())
+    return DispatchResponse::Success();
+
+  if (status_.IsMessageError())
+    return DispatchResponse::InvalidRequest(status_.Message());
+  return DispatchResponse::ParseError(status_.ToASCIIString());
+}
+
+bool Dispatchable::MaybeParseProperty(cbor::CBORTokenizer* tokenizer) {
+  span<uint8_t> property_name = tokenizer->GetString8();
+  if (SpanEquals(SpanFrom("id"), property_name))
+    return MaybeParseCallId(tokenizer);
+  if (SpanEquals(SpanFrom("method"), property_name))
+    return MaybeParseMethod(tokenizer);
+  if (SpanEquals(SpanFrom("params"), property_name))
+    return MaybeParseParams(tokenizer);
+  if (SpanEquals(SpanFrom("sessionId"), property_name))
+    return MaybeParseSessionId(tokenizer);
+  status_ =
+      Status{Error::MESSAGE_HAS_UNKNOWN_PROPERTY, tokenizer->Status().pos};
+  return false;
+}
+
+bool Dispatchable::MaybeParseCallId(cbor::CBORTokenizer* tokenizer) {
+  if (has_call_id_) {
+    status_ = Status{Error::CBOR_DUPLICATE_MAP_KEY, tokenizer->Status().pos};
+    return false;
+  }
+  tokenizer->Next();
+  if (tokenizer->TokenTag() != cbor::CBORTokenTag::INT32) {
+    status_ = Status{Error::MESSAGE_MUST_HAVE_INTEGER_ID_PROPERTY,
+                     tokenizer->Status().pos};
+    return false;
+  }
+  call_id_ = tokenizer->GetInt32();
+  has_call_id_ = true;
+  tokenizer->Next();
+  return true;
+}
+
+bool Dispatchable::MaybeParseMethod(cbor::CBORTokenizer* tokenizer) {
+  if (!method_.empty()) {
+    status_ = Status{Error::CBOR_DUPLICATE_MAP_KEY, tokenizer->Status().pos};
+    return false;
+  }
+  tokenizer->Next();
+  if (tokenizer->TokenTag() != cbor::CBORTokenTag::STRING8) {
+    status_ = Status{Error::MESSAGE_MUST_HAVE_STRING_METHOD_PROPERTY,
+                     tokenizer->Status().pos};
+    return false;
+  }
+  method_ = tokenizer->GetString8();
+  tokenizer->Next();
+  return true;
+}
+
+bool Dispatchable::MaybeParseParams(cbor::CBORTokenizer* tokenizer) {
+  if (params_seen_) {
+    status_ = Status{Error::CBOR_DUPLICATE_MAP_KEY, tokenizer->Status().pos};
+    return false;
+  }
+  params_seen_ = true;
+  tokenizer->Next();
+  if (tokenizer->TokenTag() == cbor::CBORTokenTag::NULL_VALUE) {
+    tokenizer->Next();
+    return true;
+  }
+  if (tokenizer->TokenTag() != cbor::CBORTokenTag::ENVELOPE) {
+    status_ = Status{Error::MESSAGE_MAY_HAVE_OBJECT_PARAMS_PROPERTY,
+                     tokenizer->Status().pos};
+    return false;
+  }
+  params_ = tokenizer->GetEnvelope();
+  tokenizer->Next();
+  return true;
+}
+
+bool Dispatchable::MaybeParseSessionId(cbor::CBORTokenizer* tokenizer) {
+  if (!session_id_.empty()) {
+    status_ = Status{Error::CBOR_DUPLICATE_MAP_KEY, tokenizer->Status().pos};
+    return false;
+  }
+  tokenizer->Next();
+  if (tokenizer->TokenTag() != cbor::CBORTokenTag::STRING8) {
+    status_ = Status{Error::MESSAGE_MAY_HAVE_STRING_SESSION_ID_PROPERTY,
+                     tokenizer->Status().pos};
+    return false;
+  }
+  session_id_ = tokenizer->GetString8();
+  tokenizer->Next();
+  return true;
+}
+
+namespace {
+class ProtocolError : public Serializable {
+ public:
+  explicit ProtocolError(DispatchResponse dispatch_response)
+      : dispatch_response_(std::move(dispatch_response)) {}
+
+  void AppendSerialized(std::vector<uint8_t>* out) const override {
+    Status status;
+    std::unique_ptr<ParserHandler> encoder = cbor::NewCBOREncoder(out, &status);
+    encoder->HandleMapBegin();
+    if (has_call_id_) {
+      encoder->HandleString8(SpanFrom("id"));
+      encoder->HandleInt32(call_id_);
+    }
+    encoder->HandleString8(SpanFrom("error"));
+    encoder->HandleMapBegin();
+    encoder->HandleString8(SpanFrom("code"));
+    encoder->HandleInt32(static_cast<int32_t>(dispatch_response_.Code()));
+    encoder->HandleString8(SpanFrom("message"));
+    encoder->HandleString8(SpanFrom(dispatch_response_.Message()));
+    if (!data_.empty()) {
+      encoder->HandleString8(SpanFrom("data"));
+      encoder->HandleString8(SpanFrom(data_));
+    }
+    encoder->HandleMapEnd();
+    encoder->HandleMapEnd();
+    assert(status.ok());
+  }
+
+  void SetCallId(int call_id) {
+    has_call_id_ = true;
+    call_id_ = call_id;
+  }
+  void SetData(std::string data) { data_ = std::move(data); }
+
+ private:
+  const DispatchResponse dispatch_response_;
+  std::string data_;
+  int call_id_ = 0;
+  bool has_call_id_ = false;
+};
+}  // namespace
+
+// =============================================================================
+// Helpers for creating protocol cresponses and notifications.
+// =============================================================================
+
+std::unique_ptr<Serializable> CreateErrorResponse(
+    int call_id,
+    DispatchResponse dispatch_response) {
+  auto protocol_error =
+      std::make_unique<ProtocolError>(std::move(dispatch_response));
+  protocol_error->SetCallId(call_id);
+  return protocol_error;
+}
+
+std::unique_ptr<Serializable> CreateErrorResponse(
+    int call_id,
+    DispatchResponse dispatch_response,
+    const DeserializerState& state) {
+  auto protocol_error =
+      std::make_unique<ProtocolError>(std::move(dispatch_response));
+  protocol_error->SetCallId(call_id);
+  // TODO(caseq): should we plumb the call name here?
+  protocol_error->SetData(state.ErrorMessage(MakeSpan("params")));
+  return protocol_error;
+}
+
+std::unique_ptr<Serializable> CreateErrorNotification(
+    DispatchResponse dispatch_response) {
+  return std::make_unique<ProtocolError>(std::move(dispatch_response));
+}
+
+namespace {
+class Response : public Serializable {
+ public:
+  Response(int call_id, std::unique_ptr<Serializable> params)
+      : call_id_(call_id), params_(std::move(params)) {}
+
+  void AppendSerialized(std::vector<uint8_t>* out) const override {
+    Status status;
+    std::unique_ptr<ParserHandler> encoder = cbor::NewCBOREncoder(out, &status);
+    encoder->HandleMapBegin();
+    encoder->HandleString8(SpanFrom("id"));
+    encoder->HandleInt32(call_id_);
+    encoder->HandleString8(SpanFrom("result"));
+    if (params_) {
+      params_->AppendSerialized(out);
+    } else {
+      encoder->HandleMapBegin();
+      encoder->HandleMapEnd();
+    }
+    encoder->HandleMapEnd();
+    assert(status.ok());
+  }
+
+ private:
+  const int call_id_;
+  std::unique_ptr<Serializable> params_;
+};
+
+class Notification : public Serializable {
+ public:
+  Notification(const char* method, std::unique_ptr<Serializable> params)
+      : method_(method), params_(std::move(params)) {}
+
+  void AppendSerialized(std::vector<uint8_t>* out) const override {
+    Status status;
+    std::unique_ptr<ParserHandler> encoder = cbor::NewCBOREncoder(out, &status);
+    encoder->HandleMapBegin();
+    encoder->HandleString8(SpanFrom("method"));
+    encoder->HandleString8(SpanFrom(method_));
+    encoder->HandleString8(SpanFrom("params"));
+    if (params_) {
+      params_->AppendSerialized(out);
+    } else {
+      encoder->HandleMapBegin();
+      encoder->HandleMapEnd();
+    }
+    encoder->HandleMapEnd();
+    assert(status.ok());
+  }
+
+ private:
+  const char* method_;
+  std::unique_ptr<Serializable> params_;
+};
+}  // namespace
+
+std::unique_ptr<Serializable> CreateResponse(
+    int call_id,
+    std::unique_ptr<Serializable> params) {
+  return std::make_unique<Response>(call_id, std::move(params));
+}
+
+std::unique_ptr<Serializable> CreateNotification(
+    const char* method,
+    std::unique_ptr<Serializable> params) {
+  return std::make_unique<Notification>(method, std::move(params));
+}
+
+// =============================================================================
+// DomainDispatcher - Dispatching betwen protocol methods within a domain.
+// =============================================================================
+DomainDispatcher::WeakPtr::WeakPtr(DomainDispatcher* dispatcher)
+    : dispatcher_(dispatcher) {}
+
+DomainDispatcher::WeakPtr::~WeakPtr() {
+  if (dispatcher_)
+    dispatcher_->weak_ptrs_.erase(this);
+}
+
+DomainDispatcher::Callback::~Callback() = default;
+
+void DomainDispatcher::Callback::dispose() {
+  backend_impl_ = nullptr;
+}
+
+DomainDispatcher::Callback::Callback(
+    std::unique_ptr<DomainDispatcher::WeakPtr> backend_impl,
+    int call_id,
+    span<uint8_t> method,
+    span<uint8_t> message)
+    : backend_impl_(std::move(backend_impl)),
+      call_id_(call_id),
+      method_(method),
+      message_(message.begin(), message.end()) {}
+
+void DomainDispatcher::Callback::sendIfActive(
+    std::unique_ptr<Serializable> partialMessage,
+    const DispatchResponse& response) {
+  if (!backend_impl_ || !backend_impl_->get())
+    return;
+  backend_impl_->get()->sendResponse(call_id_, response,
+                                     std::move(partialMessage));
+  backend_impl_ = nullptr;
+}
+
+void DomainDispatcher::Callback::fallThroughIfActive() {
+  if (!backend_impl_ || !backend_impl_->get())
+    return;
+  backend_impl_->get()->channel()->FallThrough(call_id_, method_,
+                                               SpanFrom(message_));
+  backend_impl_ = nullptr;
+}
+
+DomainDispatcher::DomainDispatcher(FrontendChannel* frontendChannel)
+    : frontend_channel_(frontendChannel) {}
+
+DomainDispatcher::~DomainDispatcher() {
+  clearFrontend();
+}
+
+void DomainDispatcher::sendResponse(int call_id,
+                                    const DispatchResponse& response,
+                                    std::unique_ptr<Serializable> result) {
+  if (!frontend_channel_)
+    return;
+  std::unique_ptr<Serializable> serializable;
+  if (response.IsError()) {
+    serializable = CreateErrorResponse(call_id, response);
+  } else {
+    serializable = CreateResponse(call_id, std::move(result));
+  }
+  frontend_channel_->SendProtocolResponse(call_id, std::move(serializable));
+}
+
+void DomainDispatcher::ReportInvalidParams(const Dispatchable& dispatchable,
+                                           const DeserializerState& state) {
+  assert(!state.status().ok());
+  if (frontend_channel_) {
+    frontend_channel_->SendProtocolResponse(
+        dispatchable.CallId(),
+        CreateErrorResponse(
+            dispatchable.CallId(),
+            DispatchResponse::InvalidParams("Invalid parameters"), state));
+  }
+}
+
+void DomainDispatcher::clearFrontend() {
+  frontend_channel_ = nullptr;
+  for (auto& weak : weak_ptrs_)
+    weak->dispose();
+  weak_ptrs_.clear();
+}
+
+std::unique_ptr<DomainDispatcher::WeakPtr> DomainDispatcher::weakPtr() {
+  auto weak = std::make_unique<DomainDispatcher::WeakPtr>(this);
+  weak_ptrs_.insert(weak.get());
+  return weak;
+}
+
+// =============================================================================
+// UberDispatcher - dispatches between domains (backends).
+// =============================================================================
+UberDispatcher::DispatchResult::DispatchResult(bool method_found,
+                                               std::function<void()> runnable)
+    : method_found_(method_found), runnable_(runnable) {}
+
+void UberDispatcher::DispatchResult::Run() {
+  if (!runnable_)
+    return;
+  runnable_();
+  runnable_ = nullptr;
+}
+
+UberDispatcher::UberDispatcher(FrontendChannel* frontend_channel)
+    : frontend_channel_(frontend_channel) {
+  assert(frontend_channel);
+}
+
+UberDispatcher::~UberDispatcher() = default;
+
+constexpr size_t kNotFound = std::numeric_limits<size_t>::max();
+
+namespace {
+size_t DotIdx(span<uint8_t> method) {
+  const void* p = memchr(method.data(), '.', method.size());
+  return p ? reinterpret_cast<const uint8_t*>(p) - method.data() : kNotFound;
+}
+}  // namespace
+
+UberDispatcher::DispatchResult UberDispatcher::Dispatch(
+    const Dispatchable& dispatchable) const {
+  span<uint8_t> method = FindByFirst(redirects_, dispatchable.Method(),
+                                     /*default_value=*/dispatchable.Method());
+  size_t dot_idx = DotIdx(method);
+  if (dot_idx != kNotFound) {
+    span<uint8_t> domain = method.subspan(0, dot_idx);
+    span<uint8_t> command = method.subspan(dot_idx + 1);
+    DomainDispatcher* dispatcher = FindByFirst(dispatchers_, domain);
+    if (dispatcher) {
+      std::function<void(const Dispatchable&)> dispatched =
+          dispatcher->Dispatch(command);
+      if (dispatched) {
+        return DispatchResult(
+            true, [dispatchable, dispatched = std::move(dispatched)]() {
+              dispatched(dispatchable);
+            });
+      }
+    }
+  }
+  return DispatchResult(false, [this, dispatchable]() {
+    frontend_channel_->SendProtocolResponse(
+        dispatchable.CallId(),
+        CreateErrorResponse(dispatchable.CallId(),
+                            DispatchResponse::MethodNotFound(
+                                "'" +
+                                std::string(dispatchable.Method().begin(),
+                                            dispatchable.Method().end()) +
+                                "' wasn't found")));
+  });
+}
+
+template <typename T>
+struct FirstLessThan {
+  bool operator()(const std::pair<span<uint8_t>, T>& left,
+                  const std::pair<span<uint8_t>, T>& right) {
+    return SpanLessThan(left.first, right.first);
+  }
+};
+
+void UberDispatcher::WireBackend(
+    span<uint8_t> domain,
+    const std::vector<std::pair<span<uint8_t>, span<uint8_t>>>&
+        sorted_redirects,
+    std::unique_ptr<DomainDispatcher> dispatcher) {
+  auto it = redirects_.insert(redirects_.end(), sorted_redirects.begin(),
+                              sorted_redirects.end());
+  std::inplace_merge(redirects_.begin(), it, redirects_.end(),
+                     FirstLessThan<span<uint8_t>>());
+  auto jt = dispatchers_.insert(dispatchers_.end(),
+                                std::make_pair(domain, std::move(dispatcher)));
+  std::inplace_merge(dispatchers_.begin(), jt, dispatchers_.end(),
+                     FirstLessThan<std::unique_ptr<DomainDispatcher>>());
+}
+
+}  // namespace crdtp
diff --git a/tools/inspector_protocol/crdtp/dispatch.h b/tools/inspector_protocol/crdtp/dispatch.h
new file mode 100644
index 00000000000000..8da8255c6fe882
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/dispatch.h
@@ -0,0 +1,313 @@
+// Copyright 2020 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CRDTP_DISPATCH_H_
+#define CRDTP_DISPATCH_H_
+
+#include <cassert>
+#include <cstdint>
+#include <functional>
+#include <string>
+#include <unordered_set>
+#include "export.h"
+#include "serializable.h"
+#include "span.h"
+#include "status.h"
+
+namespace crdtp {
+class DeserializerState;
+class ErrorSupport;
+class FrontendChannel;
+namespace cbor {
+class CBORTokenizer;
+}  // namespace cbor
+
+// =============================================================================
+// DispatchResponse - Error status and chaining / fall through
+// =============================================================================
+enum class DispatchCode {
+  SUCCESS = 1,
+  FALL_THROUGH = 2,
+  // For historical reasons, these error codes correspond to commonly used
+  // XMLRPC codes (e.g. see METHOD_NOT_FOUND in
+  // https://github.com/python/cpython/blob/main/Lib/xmlrpc/client.py).
+  PARSE_ERROR = -32700,
+  INVALID_REQUEST = -32600,
+  METHOD_NOT_FOUND = -32601,
+  INVALID_PARAMS = -32602,
+  INTERNAL_ERROR = -32603,
+  SERVER_ERROR = -32000,
+  SESSION_NOT_FOUND = SERVER_ERROR - 1,
+};
+
+// Information returned by command handlers. Usually returned after command
+// execution attempts.
+class CRDTP_EXPORT DispatchResponse {
+ public:
+  const std::string& Message() const { return message_; }
+
+  DispatchCode Code() const { return code_; }
+
+  bool IsSuccess() const { return code_ == DispatchCode::SUCCESS; }
+  bool IsFallThrough() const { return code_ == DispatchCode::FALL_THROUGH; }
+  bool IsError() const { return code_ < DispatchCode::SUCCESS; }
+
+  static DispatchResponse Success();
+  static DispatchResponse FallThrough();
+
+  // Indicates that a message could not be parsed. E.g., malformed JSON.
+  static DispatchResponse ParseError(std::string message);
+
+  // Indicates that a request is lacking required top-level properties
+  // ('id', 'method'), has top-level properties of the wrong type, or has
+  // unknown top-level properties.
+  static DispatchResponse InvalidRequest(std::string message);
+
+  // Indicates that a protocol method such as "Page.bringToFront" could not be
+  // dispatched because it's not known to the (domain) dispatcher.
+  static DispatchResponse MethodNotFound(std::string message);
+
+  // Indicates that the params sent to a domain handler are invalid.
+  static DispatchResponse InvalidParams(std::string message);
+
+  // Used for application level errors, e.g. within protocol agents.
+  static DispatchResponse InternalError();
+
+  // Used for application level errors, e.g. within protocol agents.
+  static DispatchResponse ServerError(std::string message);
+
+  // Indicate that session with the id specified in the protocol message
+  // was not found (e.g. because it has already been detached).
+  static DispatchResponse SessionNotFound(std::string message);
+
+ private:
+  DispatchResponse() = default;
+  DispatchCode code_;
+  std::string message_;
+};
+
+// =============================================================================
+// Dispatchable - a shallow parser for CBOR encoded DevTools messages
+// =============================================================================
+
+// This parser extracts only the known top-level fields from a CBOR encoded map;
+// method, id, sessionId, and params.
+class CRDTP_EXPORT Dispatchable {
+ public:
+  // This constructor parses the |serialized| message. If successful,
+  // |ok()| will yield |true|, and |Method()|, |SessionId()|, |CallId()|,
+  // |Params()| can be used to access, the extracted contents. Otherwise,
+  // |ok()| will yield |false|, and |DispatchError()| can be
+  // used to send a response or notification to the client.
+  explicit Dispatchable(span<uint8_t> serialized);
+
+  // The serialized message that we just parsed.
+  span<uint8_t> Serialized() const { return serialized_; }
+
+  // Yields true if parsing was successful. This is cheaper than calling
+  // ::DispatchError().
+  bool ok() const;
+
+  // If !ok(), returns a DispatchResponse with appropriate code and error
+  // which can be sent to the client as a response or notification.
+  DispatchResponse DispatchError() const;
+
+  // Top level field: the command to be executed, fully qualified by
+  // domain. E.g. "Page.createIsolatedWorld".
+  span<uint8_t> Method() const { return method_; }
+  // Used to identify protocol connections attached to a specific
+  // target. See Target.attachToTarget, Target.setAutoAttach.
+  span<uint8_t> SessionId() const { return session_id_; }
+  // The call id, a sequence number that's used in responses to indicate
+  // the request to which the response belongs.
+  int32_t CallId() const { return call_id_; }
+  bool HasCallId() const { return has_call_id_; }
+  // The payload of the request in CBOR format. The |Dispatchable| parser does
+  // not parse into this; it only provides access to its raw contents here.
+  span<uint8_t> Params() const { return params_; }
+
+ private:
+  bool MaybeParseProperty(cbor::CBORTokenizer* tokenizer);
+  bool MaybeParseCallId(cbor::CBORTokenizer* tokenizer);
+  bool MaybeParseMethod(cbor::CBORTokenizer* tokenizer);
+  bool MaybeParseParams(cbor::CBORTokenizer* tokenizer);
+  bool MaybeParseSessionId(cbor::CBORTokenizer* tokenizer);
+
+  span<uint8_t> serialized_;
+
+  Status status_;
+
+  bool has_call_id_ = false;
+  int32_t call_id_;
+  span<uint8_t> method_;
+  bool params_seen_ = false;
+  span<uint8_t> params_;
+  span<uint8_t> session_id_;
+};
+
+// =============================================================================
+// Helpers for creating protocol cresponses and notifications.
+// =============================================================================
+
+// The resulting notifications can be sent to a protocol client,
+// usually via a FrontendChannel (see frontend_channel.h).
+
+CRDTP_EXPORT std::unique_ptr<Serializable> CreateErrorResponse(
+    int callId,
+    DispatchResponse dispatch_response);
+
+CRDTP_EXPORT std::unique_ptr<Serializable> CreateErrorNotification(
+    DispatchResponse dispatch_response);
+
+CRDTP_EXPORT std::unique_ptr<Serializable> CreateResponse(
+    int callId,
+    std::unique_ptr<Serializable> params);
+
+CRDTP_EXPORT std::unique_ptr<Serializable> CreateNotification(
+    const char* method,
+    std::unique_ptr<Serializable> params = nullptr);
+
+// =============================================================================
+// DomainDispatcher - Dispatching betwen protocol methods within a domain.
+// =============================================================================
+
+// This class is subclassed by |DomainDispatcherImpl|, which we generate per
+// DevTools domain. It contains routines called from the generated code,
+// e.g. ::MaybeReportInvalidParams, which are optimized for small code size.
+// The most important method is ::Dispatch, which implements method dispatch
+// by command name lookup.
+class CRDTP_EXPORT DomainDispatcher {
+ public:
+  class CRDTP_EXPORT WeakPtr {
+   public:
+    explicit WeakPtr(DomainDispatcher*);
+    ~WeakPtr();
+    DomainDispatcher* get() { return dispatcher_; }
+    void dispose() { dispatcher_ = nullptr; }
+
+   private:
+    DomainDispatcher* dispatcher_;
+  };
+
+  class CRDTP_EXPORT Callback {
+   public:
+    virtual ~Callback();
+    void dispose();
+
+   protected:
+    // |method| must point at static storage (a C++ string literal in practice).
+    Callback(std::unique_ptr<WeakPtr> backend_impl,
+             int call_id,
+             span<uint8_t> method,
+             span<uint8_t> message);
+
+    void sendIfActive(std::unique_ptr<Serializable> partialMessage,
+                      const DispatchResponse& response);
+    void fallThroughIfActive();
+
+   private:
+    std::unique_ptr<WeakPtr> backend_impl_;
+    int call_id_;
+    // Subclasses of this class are instantiated from generated code which
+    // passes a string literal for the method name to the constructor. So the
+    // storage for |method| is the binary of the running process.
+    span<uint8_t> method_;
+    std::vector<uint8_t> message_;
+  };
+
+  explicit DomainDispatcher(FrontendChannel*);
+  virtual ~DomainDispatcher();
+
+  // Given a |command_name| without domain qualification, looks up the
+  // corresponding method. If the method is not found, returns nullptr.
+  // Otherwise, Returns a closure that will parse the provided
+  // Dispatchable.params() to a protocol object and execute the
+  // apprpropriate method. If the parsing fails it will issue an
+  // error response on the frontend channel, otherwise it will execute the
+  // command.
+  virtual std::function<void(const Dispatchable&)> Dispatch(
+      span<uint8_t> command_name) = 0;
+
+  // Sends a response to the client via the channel.
+  void sendResponse(int call_id,
+                    const DispatchResponse&,
+                    std::unique_ptr<Serializable> result = nullptr);
+
+  void ReportInvalidParams(const Dispatchable& dispatchable,
+                           const DeserializerState& state);
+
+  FrontendChannel* channel() { return frontend_channel_; }
+
+  void clearFrontend();
+
+  std::unique_ptr<WeakPtr> weakPtr();
+
+ private:
+  FrontendChannel* frontend_channel_;
+  std::unordered_set<WeakPtr*> weak_ptrs_;
+};
+
+// =============================================================================
+// UberDispatcher - dispatches between domains (backends).
+// =============================================================================
+class CRDTP_EXPORT UberDispatcher {
+ public:
+  // Return type for ::Dispatch.
+  class CRDTP_EXPORT DispatchResult {
+   public:
+    DispatchResult(bool method_found, std::function<void()> runnable);
+
+    // Indicates whether the method was found, that is, it could be dispatched
+    // to a backend registered with this dispatcher.
+    bool MethodFound() const { return method_found_; }
+
+    // Runs the dispatched result. This will send the appropriate error
+    // responses if the method wasn't found or if something went wrong during
+    // parameter parsing.
+    void Run();
+
+   private:
+    bool method_found_;
+    std::function<void()> runnable_;
+  };
+
+  // |frontend_hannel| can't be nullptr.
+  explicit UberDispatcher(FrontendChannel* frontend_channel);
+  virtual ~UberDispatcher();
+
+  // Dispatches the provided |dispatchable| considering all redirects and domain
+  // handlers registered with this uber dispatcher. Also see |DispatchResult|.
+  // |dispatchable.ok()| must hold - callers must check this separately and
+  // deal with errors.
+  DispatchResult Dispatch(const Dispatchable& dispatchable) const;
+
+  // Invoked from generated code for wiring domain backends; that is,
+  // connecting domain handlers to an uber dispatcher.
+  // See <domain-namespace>::Dispatcher::Wire(UberDispatcher*,Backend*).
+  FrontendChannel* channel() const {
+    assert(frontend_channel_);
+    return frontend_channel_;
+  }
+
+  // Invoked from generated code for wiring domain backends; that is,
+  // connecting domain handlers to an uber dispatcher.
+  // See <domain-namespace>::Dispatcher::Wire(UberDispatcher*,Backend*).
+  void WireBackend(span<uint8_t> domain,
+                   const std::vector<std::pair<span<uint8_t>, span<uint8_t>>>&,
+                   std::unique_ptr<DomainDispatcher> dispatcher);
+
+ private:
+  DomainDispatcher* findDispatcher(span<uint8_t> method);
+  FrontendChannel* const frontend_channel_;
+  // Pairs of ascii strings of the form ("Domain1.method1","Domain2.method2")
+  // indicating that the first element of each pair redirects to the second.
+  // Sorted by first element.
+  std::vector<std::pair<span<uint8_t>, span<uint8_t>>> redirects_;
+  // Domain dispatcher instances, sorted by their domain name.
+  std::vector<std::pair<span<uint8_t>, std::unique_ptr<DomainDispatcher>>>
+      dispatchers_;
+};
+}  // namespace crdtp
+
+#endif  // CRDTP_DISPATCH_H_
diff --git a/tools/inspector_protocol/crdtp/dispatch_test.cc b/tools/inspector_protocol/crdtp/dispatch_test.cc
new file mode 100644
index 00000000000000..03c8792a8ee1c3
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/dispatch_test.cc
@@ -0,0 +1,442 @@
+// Copyright 2020 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <vector>
+
+#include "cbor.h"
+#include "dispatch.h"
+#include "error_support.h"
+#include "frontend_channel.h"
+#include "json.h"
+#include "test_platform.h"
+
+namespace crdtp {
+// =============================================================================
+// DispatchResponse - Error status and chaining / fall through
+// =============================================================================
+TEST(DispatchResponseTest, OK) {
+  EXPECT_EQ(DispatchCode::SUCCESS, DispatchResponse::Success().Code());
+  EXPECT_TRUE(DispatchResponse::Success().IsSuccess());
+}
+
+TEST(DispatchResponseTest, ServerError) {
+  DispatchResponse error = DispatchResponse::ServerError("Oops!");
+  EXPECT_FALSE(error.IsSuccess());
+  EXPECT_EQ(DispatchCode::SERVER_ERROR, error.Code());
+  EXPECT_EQ("Oops!", error.Message());
+}
+
+TEST(DispatchResponseTest, SessionNotFound) {
+  DispatchResponse error = DispatchResponse::SessionNotFound("OMG!");
+  EXPECT_FALSE(error.IsSuccess());
+  EXPECT_EQ(DispatchCode::SESSION_NOT_FOUND, error.Code());
+  EXPECT_EQ("OMG!", error.Message());
+}
+
+TEST(DispatchResponseTest, InternalError) {
+  DispatchResponse error = DispatchResponse::InternalError();
+  EXPECT_FALSE(error.IsSuccess());
+  EXPECT_EQ(DispatchCode::INTERNAL_ERROR, error.Code());
+  EXPECT_EQ("Internal error", error.Message());
+}
+
+TEST(DispatchResponseTest, InvalidParams) {
+  DispatchResponse error = DispatchResponse::InvalidParams("too cool");
+  EXPECT_FALSE(error.IsSuccess());
+  EXPECT_EQ(DispatchCode::INVALID_PARAMS, error.Code());
+  EXPECT_EQ("too cool", error.Message());
+}
+
+TEST(DispatchResponseTest, FallThrough) {
+  DispatchResponse error = DispatchResponse::FallThrough();
+  EXPECT_FALSE(error.IsSuccess());
+  EXPECT_TRUE(error.IsFallThrough());
+  EXPECT_EQ(DispatchCode::FALL_THROUGH, error.Code());
+}
+
+// =============================================================================
+// Dispatchable - a shallow parser for CBOR encoded DevTools messages
+// =============================================================================
+TEST(DispatchableTest, MessageMustBeAnObject) {
+  // Provide no input whatsoever.
+  span<uint8_t> empty_span;
+  Dispatchable empty(empty_span);
+  EXPECT_FALSE(empty.ok());
+  EXPECT_EQ(DispatchCode::INVALID_REQUEST, empty.DispatchError().Code());
+  EXPECT_EQ("Message must be an object", empty.DispatchError().Message());
+}
+
+TEST(DispatchableTest, MessageMustHaveIntegerIdProperty) {
+  // Construct an empty map inside of an envelope.
+  std::vector<uint8_t> cbor;
+  ASSERT_TRUE(json::ConvertJSONToCBOR(SpanFrom("{}"), &cbor).ok());
+  Dispatchable dispatchable(SpanFrom(cbor));
+  EXPECT_FALSE(dispatchable.ok());
+  EXPECT_FALSE(dispatchable.HasCallId());
+  EXPECT_EQ(DispatchCode::INVALID_REQUEST, dispatchable.DispatchError().Code());
+  EXPECT_EQ("Message must have integer 'id' property",
+            dispatchable.DispatchError().Message());
+}
+
+TEST(DispatchableTest, MessageMustHaveIntegerIdProperty_IncorrectType) {
+  // This time we set the id property, but fail to make it an int32.
+  std::vector<uint8_t> cbor;
+  ASSERT_TRUE(
+      json::ConvertJSONToCBOR(SpanFrom("{\"id\":\"foo\"}"), &cbor).ok());
+  Dispatchable dispatchable(SpanFrom(cbor));
+  EXPECT_FALSE(dispatchable.ok());
+  EXPECT_FALSE(dispatchable.HasCallId());
+  EXPECT_EQ(DispatchCode::INVALID_REQUEST, dispatchable.DispatchError().Code());
+  EXPECT_EQ("Message must have integer 'id' property",
+            dispatchable.DispatchError().Message());
+}
+
+TEST(DispatchableTest, MessageMustHaveStringMethodProperty) {
+  // This time we set the id property, but not the method property.
+  std::vector<uint8_t> cbor;
+  ASSERT_TRUE(json::ConvertJSONToCBOR(SpanFrom("{\"id\":42}"), &cbor).ok());
+  Dispatchable dispatchable(SpanFrom(cbor));
+  EXPECT_FALSE(dispatchable.ok());
+  EXPECT_TRUE(dispatchable.HasCallId());
+  EXPECT_EQ(DispatchCode::INVALID_REQUEST, dispatchable.DispatchError().Code());
+  EXPECT_EQ("Message must have string 'method' property",
+            dispatchable.DispatchError().Message());
+}
+
+TEST(DispatchableTest, MessageMustHaveStringMethodProperty_IncorrectType) {
+  // This time we set the method property, but fail to make it a string.
+  std::vector<uint8_t> cbor;
+  ASSERT_TRUE(
+      json::ConvertJSONToCBOR(SpanFrom("{\"id\":42,\"method\":42}"), &cbor)
+          .ok());
+  Dispatchable dispatchable(SpanFrom(cbor));
+  EXPECT_FALSE(dispatchable.ok());
+  EXPECT_TRUE(dispatchable.HasCallId());
+  EXPECT_EQ(DispatchCode::INVALID_REQUEST, dispatchable.DispatchError().Code());
+  EXPECT_EQ("Message must have string 'method' property",
+            dispatchable.DispatchError().Message());
+}
+
+TEST(DispatchableTest, MessageMayHaveStringSessionIdProperty) {
+  // This time, the session id is an int but it should be a string. Method and
+  // call id are present.
+  std::vector<uint8_t> cbor;
+  ASSERT_TRUE(json::ConvertJSONToCBOR(
+                  SpanFrom("{\"id\":42,\"method\":\"Foo.executeBar\","
+                           "\"sessionId\":42"  // int32 is wrong type
+                           "}"),
+                  &cbor)
+                  .ok());
+  Dispatchable dispatchable(SpanFrom(cbor));
+  EXPECT_FALSE(dispatchable.ok());
+  EXPECT_TRUE(dispatchable.HasCallId());
+  EXPECT_EQ(DispatchCode::INVALID_REQUEST, dispatchable.DispatchError().Code());
+  EXPECT_EQ("Message may have string 'sessionId' property",
+            dispatchable.DispatchError().Message());
+}
+
+TEST(DispatchableTest, MessageMayHaveObjectParamsProperty) {
+  // This time, we fail to use the correct type for the params property.
+  std::vector<uint8_t> cbor;
+  ASSERT_TRUE(json::ConvertJSONToCBOR(
+                  SpanFrom("{\"id\":42,\"method\":\"Foo.executeBar\","
+                           "\"params\":42"  // int32 is wrong type
+                           "}"),
+                  &cbor)
+                  .ok());
+  Dispatchable dispatchable(SpanFrom(cbor));
+  EXPECT_FALSE(dispatchable.ok());
+  EXPECT_TRUE(dispatchable.HasCallId());
+  EXPECT_EQ(DispatchCode::INVALID_REQUEST, dispatchable.DispatchError().Code());
+  EXPECT_EQ("Message may have object 'params' property",
+            dispatchable.DispatchError().Message());
+}
+
+TEST(DispatchableTest, MessageWithUnknownProperty) {
+  // This time we set the 'unknown' property, so we are told what's allowed.
+  std::vector<uint8_t> cbor;
+  ASSERT_TRUE(
+      json::ConvertJSONToCBOR(SpanFrom("{\"id\":42,\"unknown\":42}"), &cbor)
+          .ok());
+  Dispatchable dispatchable(SpanFrom(cbor));
+  EXPECT_FALSE(dispatchable.ok());
+  EXPECT_TRUE(dispatchable.HasCallId());
+  EXPECT_EQ(DispatchCode::INVALID_REQUEST, dispatchable.DispatchError().Code());
+  EXPECT_EQ(
+      "Message has property other than 'id', 'method', 'sessionId', 'params'",
+      dispatchable.DispatchError().Message());
+}
+
+TEST(DispatchableTest, DuplicateMapKey) {
+  for (const std::string& json :
+       {"{\"id\":42,\"id\":42}", "{\"params\":null,\"params\":null}",
+        "{\"method\":\"foo\",\"method\":\"foo\"}",
+        "{\"sessionId\":\"42\",\"sessionId\":\"42\"}"}) {
+    SCOPED_TRACE("json = " + json);
+    std::vector<uint8_t> cbor;
+    ASSERT_TRUE(json::ConvertJSONToCBOR(SpanFrom(json), &cbor).ok());
+    Dispatchable dispatchable(SpanFrom(cbor));
+    EXPECT_FALSE(dispatchable.ok());
+    EXPECT_EQ(DispatchCode::PARSE_ERROR, dispatchable.DispatchError().Code());
+    EXPECT_THAT(dispatchable.DispatchError().Message(),
+                testing::StartsWith("CBOR: duplicate map key at position "));
+  }
+}
+
+TEST(DispatchableTest, ValidMessageParsesOK_NoParams) {
+  for (const std::string& json :
+       {"{\"id\":42,\"method\":\"Foo.executeBar\",\"sessionId\":"
+        "\"f421ssvaz4\"}",
+        "{\"id\":42,\"method\":\"Foo.executeBar\",\"sessionId\":\"f421ssvaz4\","
+        "\"params\":null}"}) {
+    SCOPED_TRACE("json = " + json);
+    std::vector<uint8_t> cbor;
+    ASSERT_TRUE(json::ConvertJSONToCBOR(SpanFrom(json), &cbor).ok());
+    Dispatchable dispatchable(SpanFrom(cbor));
+    EXPECT_TRUE(dispatchable.ok());
+    EXPECT_TRUE(dispatchable.HasCallId());
+    EXPECT_EQ(42, dispatchable.CallId());
+    EXPECT_EQ("Foo.executeBar", std::string(dispatchable.Method().begin(),
+                                            dispatchable.Method().end()));
+    EXPECT_EQ("f421ssvaz4", std::string(dispatchable.SessionId().begin(),
+                                        dispatchable.SessionId().end()));
+    EXPECT_TRUE(dispatchable.Params().empty());
+  }
+}
+
+TEST(DispatchableTest, ValidMessageParsesOK_WithParams) {
+  std::vector<uint8_t> cbor;
+  cbor::EnvelopeEncoder envelope;
+  envelope.EncodeStart(&cbor);
+  cbor.push_back(cbor::EncodeIndefiniteLengthMapStart());
+  cbor::EncodeString8(SpanFrom("id"), &cbor);
+  cbor::EncodeInt32(42, &cbor);
+  cbor::EncodeString8(SpanFrom("method"), &cbor);
+  cbor::EncodeString8(SpanFrom("Foo.executeBar"), &cbor);
+  cbor::EncodeString8(SpanFrom("params"), &cbor);
+  cbor::EnvelopeEncoder params_envelope;
+  params_envelope.EncodeStart(&cbor);
+  // The |Dispatchable| class does not parse into the "params" envelope,
+  // so we can stick anything into there for the purpose of this test.
+  // For convenience, we use a String8.
+  cbor::EncodeString8(SpanFrom("params payload"), &cbor);
+  params_envelope.EncodeStop(&cbor);
+  cbor::EncodeString8(SpanFrom("sessionId"), &cbor);
+  cbor::EncodeString8(SpanFrom("f421ssvaz4"), &cbor);
+  cbor.push_back(cbor::EncodeStop());
+  envelope.EncodeStop(&cbor);
+  Dispatchable dispatchable(SpanFrom(cbor));
+  EXPECT_TRUE(dispatchable.ok());
+  EXPECT_TRUE(dispatchable.HasCallId());
+  EXPECT_EQ(42, dispatchable.CallId());
+  EXPECT_EQ("Foo.executeBar", std::string(dispatchable.Method().begin(),
+                                          dispatchable.Method().end()));
+  EXPECT_EQ("f421ssvaz4", std::string(dispatchable.SessionId().begin(),
+                                      dispatchable.SessionId().end()));
+  cbor::CBORTokenizer params_tokenizer(dispatchable.Params());
+  ASSERT_EQ(cbor::CBORTokenTag::ENVELOPE, params_tokenizer.TokenTag());
+  params_tokenizer.EnterEnvelope();
+  ASSERT_EQ(cbor::CBORTokenTag::STRING8, params_tokenizer.TokenTag());
+  EXPECT_EQ("params payload", std::string(params_tokenizer.GetString8().begin(),
+                                          params_tokenizer.GetString8().end()));
+}
+
+TEST(DispatchableTest, FaultyCBORTrailingJunk) {
+  // In addition to the higher level parsing errors, we also catch CBOR
+  // structural corruption. E.g., in this case, the message would be
+  // OK but has some extra trailing bytes.
+  std::vector<uint8_t> cbor;
+  cbor::EnvelopeEncoder envelope;
+  envelope.EncodeStart(&cbor);
+  cbor.push_back(cbor::EncodeIndefiniteLengthMapStart());
+  cbor::EncodeString8(SpanFrom("id"), &cbor);
+  cbor::EncodeInt32(42, &cbor);
+  cbor::EncodeString8(SpanFrom("method"), &cbor);
+  cbor::EncodeString8(SpanFrom("Foo.executeBar"), &cbor);
+  cbor::EncodeString8(SpanFrom("sessionId"), &cbor);
+  cbor::EncodeString8(SpanFrom("f421ssvaz4"), &cbor);
+  cbor.push_back(cbor::EncodeStop());
+  envelope.EncodeStop(&cbor);
+  size_t trailing_junk_pos = cbor.size();
+  cbor.push_back('t');
+  cbor.push_back('r');
+  cbor.push_back('a');
+  cbor.push_back('i');
+  cbor.push_back('l');
+  Dispatchable dispatchable(SpanFrom(cbor));
+  EXPECT_FALSE(dispatchable.ok());
+  EXPECT_EQ(DispatchCode::PARSE_ERROR, dispatchable.DispatchError().Code());
+  EXPECT_EQ(57u, trailing_junk_pos);
+  EXPECT_EQ("CBOR: trailing junk at position 57",
+            dispatchable.DispatchError().Message());
+}
+
+// =============================================================================
+// Helpers for creating protocol cresponses and notifications.
+// =============================================================================
+TEST(CreateErrorResponseTest, SmokeTest) {
+  auto serializable = CreateErrorResponse(
+      42, DispatchResponse::InvalidParams("invalid params message"));
+  std::string json;
+  auto status =
+      json::ConvertCBORToJSON(SpanFrom(serializable->Serialize()), &json);
+  ASSERT_TRUE(status.ok());
+  EXPECT_EQ(
+      "{\"id\":42,\"error\":"
+      "{\"code\":-32602,"
+      "\"message\":\"invalid params message\"}}",
+      json);
+}
+
+TEST(CreateErrorNotificationTest, SmokeTest) {
+  auto serializable =
+      CreateErrorNotification(DispatchResponse::InvalidRequest("oops!"));
+  std::string json;
+  auto status =
+      json::ConvertCBORToJSON(SpanFrom(serializable->Serialize()), &json);
+  ASSERT_TRUE(status.ok());
+  EXPECT_EQ("{\"error\":{\"code\":-32600,\"message\":\"oops!\"}}", json);
+}
+
+TEST(CreateResponseTest, SmokeTest) {
+  auto serializable = CreateResponse(42, nullptr);
+  std::string json;
+  auto status =
+      json::ConvertCBORToJSON(SpanFrom(serializable->Serialize()), &json);
+  ASSERT_TRUE(status.ok());
+  EXPECT_EQ("{\"id\":42,\"result\":{}}", json);
+}
+
+TEST(CreateNotificationTest, SmokeTest) {
+  auto serializable = CreateNotification("Foo.bar");
+  std::string json;
+  auto status =
+      json::ConvertCBORToJSON(SpanFrom(serializable->Serialize()), &json);
+  ASSERT_TRUE(status.ok());
+  EXPECT_EQ("{\"method\":\"Foo.bar\",\"params\":{}}", json);
+}
+
+// =============================================================================
+// UberDispatcher - dispatches between domains (backends).
+// =============================================================================
+class TestChannel : public FrontendChannel {
+ public:
+  std::string JSON() const {
+    std::string json;
+    json::ConvertCBORToJSON(SpanFrom(cbor_), &json);
+    return json;
+  }
+
+ private:
+  void SendProtocolResponse(int call_id,
+                            std::unique_ptr<Serializable> message) override {
+    cbor_ = message->Serialize();
+  }
+
+  void SendProtocolNotification(
+      std::unique_ptr<Serializable> message) override {
+    cbor_ = message->Serialize();
+  }
+
+  void FallThrough(int call_id,
+                   span<uint8_t> method,
+                   span<uint8_t> message) override {}
+
+  void FlushProtocolNotifications() override {}
+
+  std::vector<uint8_t> cbor_;
+};
+
+TEST(UberDispatcherTest, MethodNotFound) {
+  // No domain dispatchers are registered, so unsuprisingly, we'll get a method
+  // not found error and can see that DispatchResult::MethodFound() yields
+  // false.
+  TestChannel channel;
+  UberDispatcher dispatcher(&channel);
+  std::vector<uint8_t> message;
+  json::ConvertJSONToCBOR(SpanFrom("{\"id\":42,\"method\":\"Foo.bar\"}"),
+                          &message);
+  Dispatchable dispatchable(SpanFrom(message));
+  ASSERT_TRUE(dispatchable.ok());
+  UberDispatcher::DispatchResult dispatched = dispatcher.Dispatch(dispatchable);
+  EXPECT_FALSE(dispatched.MethodFound());
+  dispatched.Run();
+  EXPECT_EQ(
+      "{\"id\":42,\"error\":"
+      "{\"code\":-32601,\"message\":\"'Foo.bar' wasn't found\"}}",
+      channel.JSON());
+}
+
+// A domain dispatcher which captured dispatched and executed commands in fields
+// for testing.
+class TestDomain : public DomainDispatcher {
+ public:
+  explicit TestDomain(FrontendChannel* channel) : DomainDispatcher(channel) {}
+
+  std::function<void(const Dispatchable&)> Dispatch(
+      span<uint8_t> command_name) override {
+    dispatched_commands_.push_back(
+        std::string(command_name.begin(), command_name.end()));
+    return [this](const Dispatchable& dispatchable) {
+      executed_commands_.push_back(dispatchable.CallId());
+    };
+  }
+
+  // Command names of the dispatched commands.
+  std::vector<std::string> DispatchedCommands() const {
+    return dispatched_commands_;
+  }
+
+  // Call ids of the executed commands.
+  std::vector<int32_t> ExecutedCommands() const { return executed_commands_; }
+
+ private:
+  std::vector<std::string> dispatched_commands_;
+  std::vector<int32_t> executed_commands_;
+};
+
+TEST(UberDispatcherTest, DispatchingToDomainWithRedirects) {
+  // This time, we register two domain dispatchers (Foo and Bar) and issue one
+  // command 'Foo.execute' which executes on Foo and one command 'Foo.redirect'
+  // which executes as 'Bar.redirected'.
+  TestChannel channel;
+  UberDispatcher dispatcher(&channel);
+  auto foo_dispatcher = std::make_unique<TestDomain>(&channel);
+  TestDomain* foo = foo_dispatcher.get();
+  auto bar_dispatcher = std::make_unique<TestDomain>(&channel);
+  TestDomain* bar = bar_dispatcher.get();
+
+  dispatcher.WireBackend(
+      SpanFrom("Foo"), {{SpanFrom("Foo.redirect"), SpanFrom("Bar.redirected")}},
+      std::move(foo_dispatcher));
+  dispatcher.WireBackend(SpanFrom("Bar"), {}, std::move(bar_dispatcher));
+
+  {
+    std::vector<uint8_t> message;
+    json::ConvertJSONToCBOR(SpanFrom("{\"id\":42,\"method\":\"Foo.execute\"}"),
+                            &message);
+    Dispatchable dispatchable(SpanFrom(message));
+    ASSERT_TRUE(dispatchable.ok());
+    UberDispatcher::DispatchResult dispatched =
+        dispatcher.Dispatch(dispatchable);
+    EXPECT_TRUE(dispatched.MethodFound());
+    dispatched.Run();
+  }
+  {
+    std::vector<uint8_t> message;
+    json::ConvertJSONToCBOR(SpanFrom("{\"id\":43,\"method\":\"Foo.redirect\"}"),
+                            &message);
+    Dispatchable dispatchable(SpanFrom(message));
+    ASSERT_TRUE(dispatchable.ok());
+    UberDispatcher::DispatchResult dispatched =
+        dispatcher.Dispatch(dispatchable);
+    EXPECT_TRUE(dispatched.MethodFound());
+    dispatched.Run();
+  }
+  EXPECT_THAT(foo->DispatchedCommands(), testing::ElementsAre("execute"));
+  EXPECT_THAT(foo->ExecutedCommands(), testing::ElementsAre(42));
+  EXPECT_THAT(bar->DispatchedCommands(), testing::ElementsAre("redirected"));
+  EXPECT_THAT(bar->ExecutedCommands(), testing::ElementsAre(43));
+}
+}  // namespace crdtp
diff --git a/tools/inspector_protocol/crdtp/error_support.cc b/tools/inspector_protocol/crdtp/error_support.cc
new file mode 100644
index 00000000000000..da4c2bed760bcc
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/error_support.cc
@@ -0,0 +1,59 @@
+// Copyright 2020 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "error_support.h"
+
+#include <cassert>
+
+namespace crdtp {
+
+void ErrorSupport::Push() {
+  stack_.emplace_back();
+}
+
+void ErrorSupport::Pop() {
+  stack_.pop_back();
+}
+
+void ErrorSupport::SetName(const char* name) {
+  assert(!stack_.empty());
+  stack_.back().type = NAME;
+  stack_.back().name = name;
+}
+
+void ErrorSupport::SetIndex(size_t index) {
+  assert(!stack_.empty());
+  stack_.back().type = INDEX;
+  stack_.back().index = index;
+}
+
+void ErrorSupport::AddError(const char* error) {
+  assert(!stack_.empty());
+  if (!errors_.empty())
+    errors_ += "; ";
+  for (size_t ii = 0; ii < stack_.size(); ++ii) {
+    if (ii)
+      errors_ += ".";
+    const Segment& s = stack_[ii];
+    switch (s.type) {
+      case NAME:
+        errors_ += s.name;
+        continue;
+      case INDEX:
+        errors_ += std::to_string(s.index);
+        continue;
+      default:
+        assert(s.type != EMPTY);
+        continue;
+    }
+  }
+  errors_ += ": ";
+  errors_ += error;
+}
+
+span<uint8_t> ErrorSupport::Errors() const {
+  return SpanFrom(errors_);
+}
+
+}  // namespace crdtp
diff --git a/tools/inspector_protocol/crdtp/error_support.h b/tools/inspector_protocol/crdtp/error_support.h
new file mode 100644
index 00000000000000..231bf3e8ea63be
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/error_support.h
@@ -0,0 +1,62 @@
+// Copyright 2020 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CRDTP_ERROR_SUPPORT_H_
+#define CRDTP_ERROR_SUPPORT_H_
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include "export.h"
+#include "span.h"
+
+namespace crdtp {
+// =============================================================================
+// ErrorSupport - For tracking errors in tree structures.
+// =============================================================================
+
+// This abstraction is used when converting between Values and inspector
+// objects, e.g. in lib/ValueConversions_{h,cc}.template. As the processing
+// enters and exits a branch, we call Push / Pop. Within the branch,
+// we either set the name or an index (in case we're processing the element of a
+// list/vector). Only once an error is seen, the path which is now on the
+// stack is materialized and prefixes the error message. E.g.,
+// "foo.bar.2: some error". After error collection, ::Errors() is used to
+// access the message.
+class CRDTP_EXPORT ErrorSupport {
+ public:
+  // Push / Pop operations for the path segments; after Push, either SetName or
+  // SetIndex must be called exactly once.
+  void Push();
+  void Pop();
+
+  // Sets the name of the current segment on the stack; e.g. a field name.
+  // |name| must be a C++ string literal in 7 bit US-ASCII.
+  void SetName(const char* name);
+  // Sets the index of the current segment on the stack; e.g. an array index.
+  void SetIndex(size_t index);
+
+  // Materializes the error internally. |error| must be a C++ string literal
+  // in 7 bit US-ASCII.
+  void AddError(const char* error);
+
+  // Returns the semicolon-separated list of errors as in 7 bit ASCII.
+  span<uint8_t> Errors() const;
+
+ private:
+  enum SegmentType { EMPTY, NAME, INDEX };
+  struct Segment {
+    SegmentType type = EMPTY;
+    union {
+      const char* name;
+      size_t index;
+    };
+  };
+  std::vector<Segment> stack_;
+  std::string errors_;
+};
+
+}  // namespace crdtp
+
+#endif  // CRDTP_ERROR_SUPPORT_H_
diff --git a/tools/inspector_protocol/crdtp/error_support_test.cc b/tools/inspector_protocol/crdtp/error_support_test.cc
new file mode 100644
index 00000000000000..87b27113dae8d0
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/error_support_test.cc
@@ -0,0 +1,45 @@
+// Copyright 2020 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "error_support.h"
+
+#include <string>
+#include <vector>
+
+#include "test_platform.h"
+
+namespace crdtp {
+TEST(ErrorSupportTest, Empty) {
+  ErrorSupport errors;
+  EXPECT_TRUE(errors.Errors().empty());
+}
+
+TEST(ErrorSupportTest, Nesting) {
+  ErrorSupport errors;
+  // Enter field foo, inter element at index 42, enter field bar, and encounter
+  // an error there ("something wrong").
+  errors.Push();
+  errors.SetName("foo");
+  errors.Push();
+  errors.SetIndex(42);
+  errors.Push();
+  errors.SetName("bar_sibling");
+  errors.SetName("bar");
+  errors.AddError("something wrong");
+  errors.Pop();  // bar
+  errors.Pop();  // 42
+  // The common case is actually that we'll enter some field, set the name
+  // or index, and leave without ever producing an error.
+  errors.Push();
+  errors.SetName("no_error_here");
+  errors.Pop();  // no_error_here
+  errors.Push();
+  errors.SetName("bang");
+  errors.AddError("one last error");
+  errors.Pop();  // bang
+  errors.Pop();  // foo
+  std::string out(errors.Errors().begin(), errors.Errors().end());
+  EXPECT_EQ("foo.42.bar: something wrong; foo.bang: one last error", out);
+}
+}  // namespace crdtp
diff --git a/tools/inspector_protocol/crdtp/export.h b/tools/inspector_protocol/crdtp/export.h
new file mode 100644
index 00000000000000..92fa1427c3b299
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/export.h
@@ -0,0 +1,29 @@
+// Copyright 2019 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CRDTP_EXPORT_H_
+#define CRDTP_EXPORT_H_
+
+#if defined(COMPONENT_BUILD)
+#if defined(WIN32)
+
+#if defined(CRDTP_IMPLEMENTATION)
+#define CRDTP_EXPORT __declspec(dllexport)
+#else
+#define CRDTP_EXPORT __declspec(dllimport)
+#endif  // defined(CRDTP_IMPLEMENTATION)
+
+#else  // defined(WIN32)
+#if defined(CRDTP_IMPLEMENTATION)
+#define CRDTP_EXPORT __attribute__((visibility("default")))
+#else
+#define CRDTP_EXPORT
+#endif
+#endif
+
+#else  // defined(COMPONENT_BUILD)
+#define CRDTP_EXPORT
+#endif
+
+#endif  // CRDTP_EXPORT_H_
diff --git a/tools/inspector_protocol/crdtp/find_by_first.h b/tools/inspector_protocol/crdtp/find_by_first.h
new file mode 100644
index 00000000000000..68c2715913402a
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/find_by_first.h
@@ -0,0 +1,58 @@
+// Copyright 2020 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CRDTP_FIND_BY_FIRST_H_
+#define CRDTP_FIND_BY_FIRST_H_
+
+#include <algorithm>
+#include <cstdint>
+#include <memory>
+#include <vector>
+
+#include "export.h"
+#include "span.h"
+
+namespace crdtp {
+// =============================================================================
+// FindByFirst - Retrieval from a sorted vector that's keyed by span<uint8_t>.
+// =============================================================================
+
+// Given a vector of pairs sorted by the first element of each pair, find
+// the corresponding value given a key to be compared to the first element.
+// Together with std::inplace_merge and pre-sorting or std::sort, this can
+// be used to implement a minimalistic equivalent of Chromium's flat_map.
+
+// In this variant, the template parameter |T| is a value type and a
+// |default_value| is provided.
+template <typename T>
+T FindByFirst(const std::vector<std::pair<span<uint8_t>, T>>& sorted_by_first,
+              span<uint8_t> key,
+              T default_value) {
+  auto it = std::lower_bound(
+      sorted_by_first.begin(), sorted_by_first.end(), key,
+      [](const std::pair<span<uint8_t>, T>& left, span<uint8_t> right) {
+        return SpanLessThan(left.first, right);
+      });
+  return (it != sorted_by_first.end() && SpanEquals(it->first, key))
+             ? it->second
+             : default_value;
+}
+
+// In this variant, the template parameter |T| is a class or struct that's
+// instantiated in std::unique_ptr, and we return either a T* or a nullptr.
+template <typename T>
+T* FindByFirst(const std::vector<std::pair<span<uint8_t>, std::unique_ptr<T>>>&
+                   sorted_by_first,
+               span<uint8_t> key) {
+  auto it = std::lower_bound(
+      sorted_by_first.begin(), sorted_by_first.end(), key,
+      [](const std::pair<span<uint8_t>, std::unique_ptr<T>>& left,
+         span<uint8_t> right) { return SpanLessThan(left.first, right); });
+  return (it != sorted_by_first.end() && SpanEquals(it->first, key))
+             ? it->second.get()
+             : nullptr;
+}
+}  // namespace crdtp
+
+#endif  // CRDTP_FIND_BY_FIRST_H_
diff --git a/tools/inspector_protocol/crdtp/find_by_first_test.cc b/tools/inspector_protocol/crdtp/find_by_first_test.cc
new file mode 100644
index 00000000000000..93c79e3f721a3f
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/find_by_first_test.cc
@@ -0,0 +1,76 @@
+// Copyright 2020 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <string>
+
+#include "find_by_first.h"
+#include "test_platform.h"
+
+namespace crdtp {
+// =============================================================================
+// FindByFirst - Efficient retrieval from a sorted vector.
+// =============================================================================
+TEST(FindByFirst, SpanBySpan) {
+  std::vector<std::pair<span<uint8_t>, span<uint8_t>>> sorted_span_by_span = {
+      {SpanFrom("foo1"), SpanFrom("bar1")},
+      {SpanFrom("foo2"), SpanFrom("bar2")},
+      {SpanFrom("foo3"), SpanFrom("bar3")},
+  };
+  {
+    auto result = FindByFirst(sorted_span_by_span, SpanFrom("foo1"),
+                              SpanFrom("not_found"));
+    EXPECT_EQ("bar1", std::string(result.begin(), result.end()));
+  }
+  {
+    auto result = FindByFirst(sorted_span_by_span, SpanFrom("foo3"),
+                              SpanFrom("not_found"));
+    EXPECT_EQ("bar3", std::string(result.begin(), result.end()));
+  }
+  {
+    auto result = FindByFirst(sorted_span_by_span, SpanFrom("baz"),
+                              SpanFrom("not_found"));
+    EXPECT_EQ("not_found", std::string(result.begin(), result.end()));
+  }
+}
+
+namespace {
+class TestObject {
+ public:
+  explicit TestObject(const std::string& message) : message_(message) {}
+
+  const std::string& message() const { return message_; }
+
+ private:
+  std::string message_;
+};
+}  // namespace
+
+TEST(FindByFirst, ObjectBySpan) {
+  std::vector<std::pair<span<uint8_t>, std::unique_ptr<TestObject>>>
+      sorted_object_by_span;
+  sorted_object_by_span.push_back(
+      std::make_pair(SpanFrom("foo1"), std::make_unique<TestObject>("bar1")));
+  sorted_object_by_span.push_back(
+      std::make_pair(SpanFrom("foo2"), std::make_unique<TestObject>("bar2")));
+  sorted_object_by_span.push_back(
+      std::make_pair(SpanFrom("foo3"), std::make_unique<TestObject>("bar3")));
+  {
+    TestObject* result =
+        FindByFirst<TestObject>(sorted_object_by_span, SpanFrom("foo1"));
+    ASSERT_TRUE(result);
+    ASSERT_EQ("bar1", result->message());
+  }
+  {
+    TestObject* result =
+        FindByFirst<TestObject>(sorted_object_by_span, SpanFrom("foo3"));
+    ASSERT_TRUE(result);
+    ASSERT_EQ("bar3", result->message());
+  }
+  {
+    TestObject* result =
+        FindByFirst<TestObject>(sorted_object_by_span, SpanFrom("baz"));
+    ASSERT_FALSE(result);
+  }
+}
+}  // namespace crdtp
diff --git a/tools/inspector_protocol/crdtp/frontend_channel.h b/tools/inspector_protocol/crdtp/frontend_channel.h
new file mode 100644
index 00000000000000..0aa7480c943237
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/frontend_channel.h
@@ -0,0 +1,47 @@
+// Copyright 2020 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CRDTP_FRONTEND_CHANNEL_H_
+#define CRDTP_FRONTEND_CHANNEL_H_
+
+#include <cstdint>
+#include <memory>
+#include "export.h"
+#include "serializable.h"
+#include "span.h"
+
+namespace crdtp {
+// =============================================================================
+// FrontendChannel - For sending notifications and responses to protocol clients
+// =============================================================================
+class CRDTP_EXPORT FrontendChannel {
+ public:
+  virtual ~FrontendChannel() = default;
+
+  // Sends protocol responses and notifications. The |call_id| parameter is
+  // seemingly redundant because it's also included in the message, but
+  // responses may be sent from an untrusted source to a trusted process (e.g.
+  // from Chromium's renderer (blink) to the browser process), which needs
+  // to be able to match the response to an earlier request without parsing the
+  // messsage.
+  virtual void SendProtocolResponse(int call_id,
+                                    std::unique_ptr<Serializable> message) = 0;
+  virtual void SendProtocolNotification(
+      std::unique_ptr<Serializable> message) = 0;
+
+  // FallThrough indicates that |message| should be handled in another layer.
+  // Usually this means the layer responding to the message didn't handle it,
+  // but in some cases messages are handled by multiple layers (e.g. both
+  // the embedder and the content layer in Chromium).
+  virtual void FallThrough(int call_id,
+                           span<uint8_t> method,
+                           span<uint8_t> message) = 0;
+
+  // Session implementations may queue notifications for performance or
+  // other considerations; this is a hook for domain handlers to manually flush.
+  virtual void FlushProtocolNotifications() = 0;
+};
+}  // namespace crdtp
+
+#endif  // CRDTP_FRONTEND_CHANNEL_H_
diff --git a/tools/inspector_protocol/crdtp/json.cc b/tools/inspector_protocol/crdtp/json.cc
new file mode 100644
index 00000000000000..479f9ba51875ab
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/json.cc
@@ -0,0 +1,1037 @@
+// Copyright 2019 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "json.h"
+
+#include <algorithm>
+#include <cassert>
+#include <cmath>
+#include <cstring>
+#include <limits>
+#include <stack>
+
+#include "cbor.h"
+#include "json_platform.h"
+
+namespace crdtp {
+namespace json {
+// =============================================================================
+// json::NewJSONEncoder - for encoding streaming parser events as JSON
+// =============================================================================
+
+namespace {
+// Prints |value| to |out| with 4 hex digits, most significant chunk first.
+template <typename C>
+void PrintHex(uint16_t value, C* out) {
+  for (int ii = 3; ii >= 0; --ii) {
+    int four_bits = 0xf & (value >> (4 * ii));
+    out->push_back(four_bits + ((four_bits <= 9) ? '0' : ('a' - 10)));
+  }
+}
+
+// In the writer below, we maintain a stack of State instances.
+// It is just enough to emit the appropriate delimiters and brackets
+// in JSON.
+enum class Container {
+  // Used for the top-level, initial state.
+  NONE,
+  // Inside a JSON object.
+  MAP,
+  // Inside a JSON array.
+  ARRAY
+};
+
+class State {
+ public:
+  explicit State(Container container) : container_(container) {}
+  void StartElement(std::vector<uint8_t>* out) { StartElementTmpl(out); }
+  void StartElement(std::string* out) { StartElementTmpl(out); }
+  Container container() const { return container_; }
+
+ private:
+  template <typename C>
+  void StartElementTmpl(C* out) {
+    assert(container_ != Container::NONE || size_ == 0);
+    if (size_ != 0) {
+      char delim = (!(size_ & 1) || container_ == Container::ARRAY) ? ',' : ':';
+      out->push_back(delim);
+    }
+    ++size_;
+  }
+
+  Container container_ = Container::NONE;
+  int size_ = 0;
+};
+
+constexpr char kBase64Table[] =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+    "abcdefghijklmnopqrstuvwxyz0123456789+/";
+
+template <typename C>
+void Base64Encode(const span<uint8_t>& in, C* out) {
+  // The following three cases are based on the tables in the example
+  // section in https://en.wikipedia.org/wiki/Base64. We process three
+  // input bytes at a time, emitting 4 output bytes at a time.
+  size_t ii = 0;
+
+  // While possible, process three input bytes.
+  for (; ii + 3 <= in.size(); ii += 3) {
+    uint32_t twentyfour_bits = (in[ii] << 16) | (in[ii + 1] << 8) | in[ii + 2];
+    out->push_back(kBase64Table[(twentyfour_bits >> 18)]);
+    out->push_back(kBase64Table[(twentyfour_bits >> 12) & 0x3f]);
+    out->push_back(kBase64Table[(twentyfour_bits >> 6) & 0x3f]);
+    out->push_back(kBase64Table[twentyfour_bits & 0x3f]);
+  }
+  if (ii + 2 <= in.size()) {  // Process two input bytes.
+    uint32_t twentyfour_bits = (in[ii] << 16) | (in[ii + 1] << 8);
+    out->push_back(kBase64Table[(twentyfour_bits >> 18)]);
+    out->push_back(kBase64Table[(twentyfour_bits >> 12) & 0x3f]);
+    out->push_back(kBase64Table[(twentyfour_bits >> 6) & 0x3f]);
+    out->push_back('=');  // Emit padding.
+    return;
+  }
+  if (ii + 1 <= in.size()) {  // Process a single input byte.
+    uint32_t twentyfour_bits = (in[ii] << 16);
+    out->push_back(kBase64Table[(twentyfour_bits >> 18)]);
+    out->push_back(kBase64Table[(twentyfour_bits >> 12) & 0x3f]);
+    out->push_back('=');  // Emit padding.
+    out->push_back('=');  // Emit padding.
+  }
+}
+
+// Implements a handler for JSON parser events to emit a JSON string.
+template <typename C>
+class JSONEncoder : public ParserHandler {
+ public:
+  JSONEncoder(C* out, Status* status) : out_(out), status_(status) {
+    *status_ = Status();
+    state_.emplace(Container::NONE);
+  }
+
+  void HandleMapBegin() override {
+    if (!status_->ok())
+      return;
+    assert(!state_.empty());
+    state_.top().StartElement(out_);
+    state_.emplace(Container::MAP);
+    Emit('{');
+  }
+
+  void HandleMapEnd() override {
+    if (!status_->ok())
+      return;
+    assert(state_.size() >= 2 && state_.top().container() == Container::MAP);
+    state_.pop();
+    Emit('}');
+  }
+
+  void HandleArrayBegin() override {
+    if (!status_->ok())
+      return;
+    state_.top().StartElement(out_);
+    state_.emplace(Container::ARRAY);
+    Emit('[');
+  }
+
+  void HandleArrayEnd() override {
+    if (!status_->ok())
+      return;
+    assert(state_.size() >= 2 && state_.top().container() == Container::ARRAY);
+    state_.pop();
+    Emit(']');
+  }
+
+  void HandleString16(span<uint16_t> chars) override {
+    if (!status_->ok())
+      return;
+    state_.top().StartElement(out_);
+    Emit('"');
+    for (const uint16_t ch : chars) {
+      if (ch == '"') {
+        Emit('\\'); Emit('"');
+      } else if (ch == '\\') {
+        Emit('\\'); Emit('\\');
+      } else if (ch >= 32 && ch <= 127) {
+        Emit(ch);
+      } else if (ch == '\n') {
+        Emit('\\'); Emit('n');
+      } else if (ch == '\r') {
+        Emit('\\'); Emit('r');
+      } else if (ch == '\t') {
+        Emit('\\'); Emit('t');
+      } else if (ch == '\b') {
+        Emit('\\'); Emit('b');
+      } else if (ch == '\f') {
+        Emit('\\'); Emit('f');
+      } else {
+        Emit('\\'); Emit('u');
+        PrintHex(ch, out_);
+      }
+    }
+    Emit('"');
+  }
+
+  void HandleString8(span<uint8_t> chars) override {
+    if (!status_->ok())
+      return;
+    state_.top().StartElement(out_);
+    Emit('"');
+    for (size_t ii = 0; ii < chars.size(); ++ii) {
+      uint8_t c = chars[ii];
+      if (c == '"') {
+        Emit('\\'); Emit('"');
+      } else if (c == '\\') {
+        Emit('\\'); Emit('\\');
+      } else if (c >= 32 && c <= 127) {
+        Emit(c);
+      } else if (c == '\n') {
+        Emit('\\'); Emit('n');
+      } else if (c == '\r') {
+        Emit('\\'); Emit('r');
+      } else if (c == '\t') {
+        Emit('\\'); Emit('t');
+      } else if (c == '\b') {
+        Emit('\\'); Emit('b');
+      } else if (c == '\f') {
+        Emit('\\'); Emit('f');
+      } else if (c < 32) {
+        Emit('\\'); Emit('u');
+        PrintHex(static_cast<uint16_t>(c), out_);
+      } else {
+        // Inspect the leading byte to figure out how long the utf8
+        // byte sequence is; while doing this initialize |codepoint|
+        // with the first few bits.
+        // See table in: https://en.wikipedia.org/wiki/UTF-8
+        // byte one is 110x xxxx -> 2 byte utf8 sequence
+        // byte one is 1110 xxxx -> 3 byte utf8 sequence
+        // byte one is 1111 0xxx -> 4 byte utf8 sequence
+        uint32_t codepoint;
+        int num_bytes_left;
+        if ((c & 0xe0) == 0xc0) {  // 2 byte utf8 sequence
+          num_bytes_left = 1;
+          codepoint = c & 0x1f;
+        } else if ((c & 0xf0) == 0xe0) {  // 3 byte utf8 sequence
+          num_bytes_left = 2;
+          codepoint = c & 0x0f;
+        } else if ((c & 0xf8) == 0xf0) {  // 4 byte utf8 sequence
+          codepoint = c & 0x07;
+          num_bytes_left = 3;
+        } else {
+          continue;  // invalid leading byte
+        }
+
+        // If we have enough bytes in our input, decode the remaining ones
+        // belonging to this Unicode character into |codepoint|.
+        if (ii + num_bytes_left >= chars.size())
+          continue;
+        bool invalid_byte_seen = false;
+        while (num_bytes_left > 0) {
+          c = chars[++ii];
+          --num_bytes_left;
+          // Check the next byte is a continuation byte, that is 10xx xxxx.
+          if ((c & 0xc0) != 0x80)
+            invalid_byte_seen = true;
+          codepoint = (codepoint << 6) | (c & 0x3f);
+        }
+        if (invalid_byte_seen)
+          continue;
+
+        // Disallow overlong encodings for ascii characters, as these
+        // would include " and other characters significant to JSON
+        // string termination / control.
+        if (codepoint <= 0x7f)
+          continue;
+        // Invalid in UTF8, and can't be represented in UTF16 anyway.
+        if (codepoint > 0x10ffff)
+          continue;
+
+        // So, now we transcode to UTF16,
+        // using the math described at https://en.wikipedia.org/wiki/UTF-16,
+        // for either one or two 16 bit characters.
+        if (codepoint <= 0xffff) {
+          Emit("\\u");
+          PrintHex(static_cast<uint16_t>(codepoint), out_);
+          continue;
+        }
+        codepoint -= 0x10000;
+        // high surrogate
+        Emit("\\u");
+        PrintHex(static_cast<uint16_t>((codepoint >> 10) + 0xd800), out_);
+        // low surrogate
+        Emit("\\u");
+        PrintHex(static_cast<uint16_t>((codepoint & 0x3ff) + 0xdc00), out_);
+      }
+    }
+    Emit('"');
+  }
+
+  void HandleBinary(span<uint8_t> bytes) override {
+    if (!status_->ok())
+      return;
+    state_.top().StartElement(out_);
+    Emit('"');
+    Base64Encode(bytes, out_);
+    Emit('"');
+  }
+
+  void HandleDouble(double value) override {
+    if (!status_->ok())
+      return;
+    state_.top().StartElement(out_);
+    // JSON cannot represent NaN or Infinity. So, for compatibility,
+    // we behave like the JSON object in web browsers: emit 'null'.
+    if (!std::isfinite(value)) {
+      Emit("null");
+      return;
+    }
+    // If |value| is a scalar, emit it as an int. Taken from json_writer.cc in
+    // Chromium.
+    if (value < static_cast<double>(std::numeric_limits<int64_t>::max()) &&
+        value >= std::numeric_limits<int64_t>::min() &&
+        std::floor(value) == value) {
+      Emit(std::to_string(static_cast<int64_t>(value)));
+      return;
+    }
+    std::string str_value = json::platform::DToStr(value);
+    // The following is somewhat paranoid, but also taken from json_writer.cc
+    // in Chromium:
+    // Ensure that the number has a .0 if there's no decimal or 'e'.  This
+    // makes sure that when we read the JSON back, it's interpreted as a
+    // real rather than an int.
+    if (str_value.find_first_of(".eE") == std::string::npos)
+      str_value.append(".0");
+
+    // DToStr may fail to emit a 0 before the decimal dot. E.g. this is
+    // the case in base::NumberToString in Chromium (which is based on
+    // dmg_fp). So, much like
+    // https://cs.chromium.org/chromium/src/base/json/json_writer.cc
+    // we probe for this and emit the leading 0 anyway if necessary.
+    if (str_value[0] == '.') {
+      Emit('0');
+      Emit(str_value);
+    } else if (str_value[0] == '-' && str_value[1] == '.') {
+      Emit("-0");
+      // Skip the '-' from the original string and emit the rest.
+      out_->insert(out_->end(), str_value.begin() + 1, str_value.end());
+    } else {
+      Emit(str_value);
+    }
+  }
+
+  void HandleInt32(int32_t value) override {
+    if (!status_->ok())
+      return;
+    state_.top().StartElement(out_);
+    Emit(std::to_string(value));
+  }
+
+  void HandleBool(bool value) override {
+    if (!status_->ok())
+      return;
+    state_.top().StartElement(out_);
+    if (value)
+      Emit("true");
+    else
+      Emit("false");
+  }
+
+  void HandleNull() override {
+    if (!status_->ok())
+      return;
+    state_.top().StartElement(out_);
+    Emit("null");
+  }
+
+  void HandleError(Status error) override {
+    assert(!error.ok());
+    *status_ = error;
+    out_->clear();
+  }
+
+ private:
+  inline void Emit(char c) { out_->push_back(c); }
+  template<size_t N>
+  inline void Emit(const char (&str)[N]) {
+    out_->insert(out_->end(), str, str + N - 1);
+  }
+  inline void Emit(const std::string& str) {
+    out_->insert(out_->end(), str.begin(), str.end());
+  }
+
+  C* out_;
+  Status* status_;
+  std::stack<State> state_;
+};
+}  // namespace
+
+std::unique_ptr<ParserHandler> NewJSONEncoder(std::vector<uint8_t>* out,
+                                              Status* status) {
+  return std::unique_ptr<ParserHandler>(
+      new JSONEncoder<std::vector<uint8_t>>(out, status));
+}
+
+std::unique_ptr<ParserHandler> NewJSONEncoder(std::string* out,
+                                              Status* status) {
+  return std::unique_ptr<ParserHandler>(
+      new JSONEncoder<std::string>(out, status));
+}
+
+// =============================================================================
+// json::ParseJSON - for receiving streaming parser events for JSON.
+// =============================================================================
+
+namespace {
+const int kStackLimit = 300;
+
+enum Token {
+  ObjectBegin,
+  ObjectEnd,
+  ArrayBegin,
+  ArrayEnd,
+  StringLiteral,
+  Number,
+  BoolTrue,
+  BoolFalse,
+  NullToken,
+  ListSeparator,
+  ObjectPairSeparator,
+  InvalidToken,
+  NoInput
+};
+
+const char* const kNullString = "null";
+const char* const kTrueString = "true";
+const char* const kFalseString = "false";
+
+template <typename Char>
+class JsonParser {
+ public:
+  explicit JsonParser(ParserHandler* handler) : handler_(handler) {}
+
+  void Parse(const Char* start, size_t length) {
+    start_pos_ = start;
+    const Char* end = start + length;
+    const Char* tokenEnd = nullptr;
+    ParseValue(start, end, &tokenEnd, 0);
+    if (error_)
+      return;
+    if (tokenEnd != end) {
+      HandleError(Error::JSON_PARSER_UNPROCESSED_INPUT_REMAINS, tokenEnd);
+    }
+  }
+
+ private:
+  bool CharsToDouble(const uint16_t* chars, size_t length, double* result) {
+    std::string buffer;
+    buffer.reserve(length + 1);
+    for (size_t ii = 0; ii < length; ++ii) {
+      bool is_ascii = !(chars[ii] & ~0x7F);
+      if (!is_ascii)
+        return false;
+      buffer.push_back(static_cast<char>(chars[ii]));
+    }
+    return platform::StrToD(buffer.c_str(), result);
+  }
+
+  bool CharsToDouble(const uint8_t* chars, size_t length, double* result) {
+    std::string buffer(reinterpret_cast<const char*>(chars), length);
+    return platform::StrToD(buffer.c_str(), result);
+  }
+
+  static bool ParseConstToken(const Char* start,
+                              const Char* end,
+                              const Char** token_end,
+                              const char* token) {
+    // |token| is \0 terminated, it's one of the constants at top of the file.
+    while (start < end && *token != '\0' && *start++ == *token++) {
+    }
+    if (*token != '\0')
+      return false;
+    *token_end = start;
+    return true;
+  }
+
+  static bool ReadInt(const Char* start,
+                      const Char* end,
+                      const Char** token_end,
+                      bool allow_leading_zeros) {
+    if (start == end)
+      return false;
+    bool has_leading_zero = '0' == *start;
+    int length = 0;
+    while (start < end && '0' <= *start && *start <= '9') {
+      ++start;
+      ++length;
+    }
+    if (!length)
+      return false;
+    if (!allow_leading_zeros && length > 1 && has_leading_zero)
+      return false;
+    *token_end = start;
+    return true;
+  }
+
+  static bool ParseNumberToken(const Char* start,
+                               const Char* end,
+                               const Char** token_end) {
+    // We just grab the number here. We validate the size in DecodeNumber.
+    // According to RFC4627, a valid number is: [minus] int [frac] [exp]
+    if (start == end)
+      return false;
+    Char c = *start;
+    if ('-' == c)
+      ++start;
+
+    if (!ReadInt(start, end, &start, /*allow_leading_zeros=*/false))
+      return false;
+    if (start == end) {
+      *token_end = start;
+      return true;
+    }
+
+    // Optional fraction part
+    c = *start;
+    if ('.' == c) {
+      ++start;
+      if (!ReadInt(start, end, &start, /*allow_leading_zeros=*/true))
+        return false;
+      if (start == end) {
+        *token_end = start;
+        return true;
+      }
+      c = *start;
+    }
+
+    // Optional exponent part
+    if ('e' == c || 'E' == c) {
+      ++start;
+      if (start == end)
+        return false;
+      c = *start;
+      if ('-' == c || '+' == c) {
+        ++start;
+        if (start == end)
+          return false;
+      }
+      if (!ReadInt(start, end, &start, /*allow_leading_zeros=*/true))
+        return false;
+    }
+
+    *token_end = start;
+    return true;
+  }
+
+  static bool ReadHexDigits(const Char* start,
+                            const Char* end,
+                            const Char** token_end,
+                            int digits) {
+    if (end - start < digits)
+      return false;
+    for (int i = 0; i < digits; ++i) {
+      Char c = *start++;
+      if (!(('0' <= c && c <= '9') || ('a' <= c && c <= 'f') ||
+            ('A' <= c && c <= 'F')))
+        return false;
+    }
+    *token_end = start;
+    return true;
+  }
+
+  static bool ParseStringToken(const Char* start,
+                               const Char* end,
+                               const Char** token_end) {
+    while (start < end) {
+      Char c = *start++;
+      if ('\\' == c) {
+        if (start == end)
+          return false;
+        c = *start++;
+        // Make sure the escaped char is valid.
+        switch (c) {
+          case 'x':
+            if (!ReadHexDigits(start, end, &start, 2))
+              return false;
+            break;
+          case 'u':
+            if (!ReadHexDigits(start, end, &start, 4))
+              return false;
+            break;
+          case '\\':
+          case '/':
+          case 'b':
+          case 'f':
+          case 'n':
+          case 'r':
+          case 't':
+          case 'v':
+          case '"':
+            break;
+          default:
+            return false;
+        }
+      } else if ('"' == c) {
+        *token_end = start;
+        return true;
+      }
+    }
+    return false;
+  }
+
+  static bool SkipComment(const Char* start,
+                          const Char* end,
+                          const Char** comment_end) {
+    if (start == end)
+      return false;
+
+    if (*start != '/' || start + 1 >= end)
+      return false;
+    ++start;
+
+    if (*start == '/') {
+      // Single line comment, read to newline.
+      for (++start; start < end; ++start) {
+        if (*start == '\n' || *start == '\r') {
+          *comment_end = start + 1;
+          return true;
+        }
+      }
+      *comment_end = end;
+      // Comment reaches end-of-input, which is fine.
+      return true;
+    }
+
+    if (*start == '*') {
+      Char previous = '\0';
+      // Block comment, read until end marker.
+      for (++start; start < end; previous = *start++) {
+        if (previous == '*' && *start == '/') {
+          *comment_end = start + 1;
+          return true;
+        }
+      }
+      // Block comment must close before end-of-input.
+      return false;
+    }
+
+    return false;
+  }
+
+  static bool IsSpaceOrNewLine(Char c) {
+    // \v = vertial tab; \f = form feed page break.
+    return c == ' ' || c == '\n' || c == '\v' || c == '\f' || c == '\r' ||
+           c == '\t';
+  }
+
+  static void SkipWhitespaceAndComments(const Char* start,
+                                        const Char* end,
+                                        const Char** whitespace_end) {
+    while (start < end) {
+      if (IsSpaceOrNewLine(*start)) {
+        ++start;
+      } else if (*start == '/') {
+        const Char* comment_end = nullptr;
+        if (!SkipComment(start, end, &comment_end))
+          break;
+        start = comment_end;
+      } else {
+        break;
+      }
+    }
+    *whitespace_end = start;
+  }
+
+  static Token ParseToken(const Char* start,
+                          const Char* end,
+                          const Char** tokenStart,
+                          const Char** token_end) {
+    SkipWhitespaceAndComments(start, end, tokenStart);
+    start = *tokenStart;
+
+    if (start == end)
+      return NoInput;
+
+    switch (*start) {
+      case 'n':
+        if (ParseConstToken(start, end, token_end, kNullString))
+          return NullToken;
+        break;
+      case 't':
+        if (ParseConstToken(start, end, token_end, kTrueString))
+          return BoolTrue;
+        break;
+      case 'f':
+        if (ParseConstToken(start, end, token_end, kFalseString))
+          return BoolFalse;
+        break;
+      case '[':
+        *token_end = start + 1;
+        return ArrayBegin;
+      case ']':
+        *token_end = start + 1;
+        return ArrayEnd;
+      case ',':
+        *token_end = start + 1;
+        return ListSeparator;
+      case '{':
+        *token_end = start + 1;
+        return ObjectBegin;
+      case '}':
+        *token_end = start + 1;
+        return ObjectEnd;
+      case ':':
+        *token_end = start + 1;
+        return ObjectPairSeparator;
+      case '0':
+      case '1':
+      case '2':
+      case '3':
+      case '4':
+      case '5':
+      case '6':
+      case '7':
+      case '8':
+      case '9':
+      case '-':
+        if (ParseNumberToken(start, end, token_end))
+          return Number;
+        break;
+      case '"':
+        if (ParseStringToken(start + 1, end, token_end))
+          return StringLiteral;
+        break;
+    }
+    return InvalidToken;
+  }
+
+  static int HexToInt(Char c) {
+    if ('0' <= c && c <= '9')
+      return c - '0';
+    if ('A' <= c && c <= 'F')
+      return c - 'A' + 10;
+    if ('a' <= c && c <= 'f')
+      return c - 'a' + 10;
+    assert(false);  // Unreachable.
+    return 0;
+  }
+
+  static bool DecodeString(const Char* start,
+                           const Char* end,
+                           std::vector<uint16_t>* output) {
+    if (start == end)
+      return true;
+    if (start > end)
+      return false;
+    output->reserve(end - start);
+    while (start < end) {
+      uint16_t c = *start++;
+      // If the |Char| we're dealing with is really a byte, then
+      // we have utf8 here, and we need to check for multibyte characters
+      // and transcode them to utf16 (either one or two utf16 chars).
+      if (sizeof(Char) == sizeof(uint8_t) && c > 0x7f) {
+        // Inspect the leading byte to figure out how long the utf8
+        // byte sequence is; while doing this initialize |codepoint|
+        // with the first few bits.
+        // See table in: https://en.wikipedia.org/wiki/UTF-8
+        // byte one is 110x xxxx -> 2 byte utf8 sequence
+        // byte one is 1110 xxxx -> 3 byte utf8 sequence
+        // byte one is 1111 0xxx -> 4 byte utf8 sequence
+        uint32_t codepoint;
+        int num_bytes_left;
+        if ((c & 0xe0) == 0xc0) {  // 2 byte utf8 sequence
+          num_bytes_left = 1;
+          codepoint = c & 0x1f;
+        } else if ((c & 0xf0) == 0xe0) {  // 3 byte utf8 sequence
+          num_bytes_left = 2;
+          codepoint = c & 0x0f;
+        } else if ((c & 0xf8) == 0xf0) {  // 4 byte utf8 sequence
+          codepoint = c & 0x07;
+          num_bytes_left = 3;
+        } else {
+          return false;  // invalid leading byte
+        }
+
+        // If we have enough bytes in our inpput, decode the remaining ones
+        // belonging to this Unicode character into |codepoint|.
+        if (start + num_bytes_left > end)
+          return false;
+        while (num_bytes_left > 0) {
+          c = *start++;
+          --num_bytes_left;
+          // Check the next byte is a continuation byte, that is 10xx xxxx.
+          if ((c & 0xc0) != 0x80)
+            return false;
+          codepoint = (codepoint << 6) | (c & 0x3f);
+        }
+
+        // Disallow overlong encodings for ascii characters, as these
+        // would include " and other characters significant to JSON
+        // string termination / control.
+        if (codepoint <= 0x7f)
+          return false;
+        // Invalid in UTF8, and can't be represented in UTF16 anyway.
+        if (codepoint > 0x10ffff)
+          return false;
+
+        // So, now we transcode to UTF16,
+        // using the math described at https://en.wikipedia.org/wiki/UTF-16,
+        // for either one or two 16 bit characters.
+        if (codepoint <= 0xffff) {
+          output->push_back(codepoint);
+          continue;
+        }
+        codepoint -= 0x10000;
+        output->push_back((codepoint >> 10) + 0xd800);    // high surrogate
+        output->push_back((codepoint & 0x3ff) + 0xdc00);  // low surrogate
+        continue;
+      }
+      if ('\\' != c) {
+        output->push_back(c);
+        continue;
+      }
+      if (start == end)
+        return false;
+      c = *start++;
+
+      if (c == 'x') {
+        // \x is not supported.
+        return false;
+      }
+
+      switch (c) {
+        case '"':
+        case '/':
+        case '\\':
+          break;
+        case 'b':
+          c = '\b';
+          break;
+        case 'f':
+          c = '\f';
+          break;
+        case 'n':
+          c = '\n';
+          break;
+        case 'r':
+          c = '\r';
+          break;
+        case 't':
+          c = '\t';
+          break;
+        case 'v':
+          c = '\v';
+          break;
+        case 'u':
+          c = (HexToInt(*start) << 12) + (HexToInt(*(start + 1)) << 8) +
+              (HexToInt(*(start + 2)) << 4) + HexToInt(*(start + 3));
+          start += 4;
+          break;
+        default:
+          return false;
+      }
+      output->push_back(c);
+    }
+    return true;
+  }
+
+  void ParseValue(const Char* start,
+                  const Char* end,
+                  const Char** value_token_end,
+                  int depth) {
+    if (depth > kStackLimit) {
+      HandleError(Error::JSON_PARSER_STACK_LIMIT_EXCEEDED, start);
+      return;
+    }
+    const Char* token_start = nullptr;
+    const Char* token_end = nullptr;
+    Token token = ParseToken(start, end, &token_start, &token_end);
+    switch (token) {
+      case NoInput:
+        HandleError(Error::JSON_PARSER_NO_INPUT, token_start);
+        return;
+      case InvalidToken:
+        HandleError(Error::JSON_PARSER_INVALID_TOKEN, token_start);
+        return;
+      case NullToken:
+        handler_->HandleNull();
+        break;
+      case BoolTrue:
+        handler_->HandleBool(true);
+        break;
+      case BoolFalse:
+        handler_->HandleBool(false);
+        break;
+      case Number: {
+        double value;
+        if (!CharsToDouble(token_start, token_end - token_start, &value)) {
+          HandleError(Error::JSON_PARSER_INVALID_NUMBER, token_start);
+          return;
+        }
+        if (value >= std::numeric_limits<int32_t>::min() &&
+            value <= std::numeric_limits<int32_t>::max() &&
+            static_cast<int32_t>(value) == value)
+          handler_->HandleInt32(static_cast<int32_t>(value));
+        else
+          handler_->HandleDouble(value);
+        break;
+      }
+      case StringLiteral: {
+        std::vector<uint16_t> value;
+        bool ok = DecodeString(token_start + 1, token_end - 1, &value);
+        if (!ok) {
+          HandleError(Error::JSON_PARSER_INVALID_STRING, token_start);
+          return;
+        }
+        handler_->HandleString16(span<uint16_t>(value.data(), value.size()));
+        break;
+      }
+      case ArrayBegin: {
+        handler_->HandleArrayBegin();
+        start = token_end;
+        token = ParseToken(start, end, &token_start, &token_end);
+        while (token != ArrayEnd) {
+          ParseValue(start, end, &token_end, depth + 1);
+          if (error_)
+            return;
+
+          // After a list value, we expect a comma or the end of the list.
+          start = token_end;
+          token = ParseToken(start, end, &token_start, &token_end);
+          if (token == ListSeparator) {
+            start = token_end;
+            token = ParseToken(start, end, &token_start, &token_end);
+            if (token == ArrayEnd) {
+              HandleError(Error::JSON_PARSER_UNEXPECTED_ARRAY_END, token_start);
+              return;
+            }
+          } else if (token != ArrayEnd) {
+            // Unexpected value after list value. Bail out.
+            HandleError(Error::JSON_PARSER_COMMA_OR_ARRAY_END_EXPECTED,
+                        token_start);
+            return;
+          }
+        }
+        handler_->HandleArrayEnd();
+        break;
+      }
+      case ObjectBegin: {
+        handler_->HandleMapBegin();
+        start = token_end;
+        token = ParseToken(start, end, &token_start, &token_end);
+        while (token != ObjectEnd) {
+          if (token != StringLiteral) {
+            HandleError(Error::JSON_PARSER_STRING_LITERAL_EXPECTED,
+                        token_start);
+            return;
+          }
+          std::vector<uint16_t> key;
+          if (!DecodeString(token_start + 1, token_end - 1, &key)) {
+            HandleError(Error::JSON_PARSER_INVALID_STRING, token_start);
+            return;
+          }
+          handler_->HandleString16(span<uint16_t>(key.data(), key.size()));
+          start = token_end;
+
+          token = ParseToken(start, end, &token_start, &token_end);
+          if (token != ObjectPairSeparator) {
+            HandleError(Error::JSON_PARSER_COLON_EXPECTED, token_start);
+            return;
+          }
+          start = token_end;
+
+          ParseValue(start, end, &token_end, depth + 1);
+          if (error_)
+            return;
+          start = token_end;
+
+          // After a key/value pair, we expect a comma or the end of the
+          // object.
+          token = ParseToken(start, end, &token_start, &token_end);
+          if (token == ListSeparator) {
+            start = token_end;
+            token = ParseToken(start, end, &token_start, &token_end);
+            if (token == ObjectEnd) {
+              HandleError(Error::JSON_PARSER_UNEXPECTED_MAP_END, token_start);
+              return;
+            }
+          } else if (token != ObjectEnd) {
+            // Unexpected value after last object value. Bail out.
+            HandleError(Error::JSON_PARSER_COMMA_OR_MAP_END_EXPECTED,
+                        token_start);
+            return;
+          }
+        }
+        handler_->HandleMapEnd();
+        break;
+      }
+
+      default:
+        // We got a token that's not a value.
+        HandleError(Error::JSON_PARSER_VALUE_EXPECTED, token_start);
+        return;
+    }
+
+    SkipWhitespaceAndComments(token_end, end, value_token_end);
+  }
+
+  void HandleError(Error error, const Char* pos) {
+    assert(error != Error::OK);
+    if (!error_) {
+      handler_->HandleError(
+          Status{error, static_cast<size_t>(pos - start_pos_)});
+      error_ = true;
+    }
+  }
+
+  const Char* start_pos_ = nullptr;
+  bool error_ = false;
+  ParserHandler* handler_;
+};
+}  // namespace
+
+void ParseJSON(span<uint8_t> chars, ParserHandler* handler) {
+  JsonParser<uint8_t> parser(handler);
+  parser.Parse(chars.data(), chars.size());
+}
+
+void ParseJSON(span<uint16_t> chars, ParserHandler* handler) {
+  JsonParser<uint16_t> parser(handler);
+  parser.Parse(chars.data(), chars.size());
+}
+
+// =============================================================================
+// json::ConvertCBORToJSON, json::ConvertJSONToCBOR - for transcoding
+// =============================================================================
+template <typename C>
+Status ConvertCBORToJSONTmpl(span<uint8_t> cbor, C* json) {
+  Status status;
+  std::unique_ptr<ParserHandler> json_writer = NewJSONEncoder(json, &status);
+  cbor::ParseCBOR(cbor, json_writer.get());
+  return status;
+}
+
+Status ConvertCBORToJSON(span<uint8_t> cbor, std::vector<uint8_t>* json) {
+  return ConvertCBORToJSONTmpl(cbor, json);
+}
+
+Status ConvertCBORToJSON(span<uint8_t> cbor, std::string* json) {
+  return ConvertCBORToJSONTmpl(cbor, json);
+}
+
+template <typename T>
+Status ConvertJSONToCBORTmpl(span<T> json, std::vector<uint8_t>* cbor) {
+  Status status;
+  std::unique_ptr<ParserHandler> encoder = cbor::NewCBOREncoder(cbor, &status);
+  ParseJSON(json, encoder.get());
+  return status;
+}
+
+Status ConvertJSONToCBOR(span<uint8_t> json, std::vector<uint8_t>* cbor) {
+  return ConvertJSONToCBORTmpl(json, cbor);
+}
+
+Status ConvertJSONToCBOR(span<uint16_t> json, std::vector<uint8_t>* cbor) {
+  return ConvertJSONToCBORTmpl(json, cbor);
+}
+}  // namespace json
+}  // namespace crdtp
diff --git a/tools/inspector_protocol/crdtp/json.h b/tools/inspector_protocol/crdtp/json.h
new file mode 100644
index 00000000000000..3e3c6b386af465
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/json.h
@@ -0,0 +1,57 @@
+// Copyright 2019 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CRDTP_JSON_H_
+#define CRDTP_JSON_H_
+
+#include <memory>
+#include <vector>
+#include "export.h"
+#include "parser_handler.h"
+
+namespace crdtp {
+namespace json {
+// =============================================================================
+// json::NewJSONEncoder - for encoding streaming parser events as JSON
+// =============================================================================
+
+// Returns a handler object which will write ascii characters to |out|.
+// |status->ok()| will be false iff the handler routine HandleError() is called.
+// In that case, we'll stop emitting output.
+// Except for calling the HandleError routine at any time, the client
+// code must call the Handle* methods in an order in which they'd occur
+// in valid JSON; otherwise we may crash (the code uses assert).
+CRDTP_EXPORT std::unique_ptr<ParserHandler> NewJSONEncoder(
+    std::vector<uint8_t>* out,
+    Status* status);
+
+CRDTP_EXPORT std::unique_ptr<ParserHandler> NewJSONEncoder(std::string* out,
+                                                           Status* status);
+
+// =============================================================================
+// json::ParseJSON - for receiving streaming parser events for JSON
+// =============================================================================
+
+CRDTP_EXPORT void ParseJSON(span<uint8_t> chars, ParserHandler* handler);
+
+CRDTP_EXPORT void ParseJSON(span<uint16_t> chars, ParserHandler* handler);
+
+// =============================================================================
+// json::ConvertCBORToJSON, json::ConvertJSONToCBOR - for transcoding
+// =============================================================================
+
+CRDTP_EXPORT Status ConvertCBORToJSON(span<uint8_t> cbor, std::string* json);
+
+CRDTP_EXPORT Status ConvertCBORToJSON(span<uint8_t> cbor,
+                                      std::vector<uint8_t>* json);
+
+CRDTP_EXPORT Status ConvertJSONToCBOR(span<uint8_t> json,
+                                      std::vector<uint8_t>* cbor);
+
+CRDTP_EXPORT Status ConvertJSONToCBOR(span<uint16_t> json,
+                                      std::vector<uint8_t>* cbor);
+}  // namespace json
+}  // namespace crdtp
+
+#endif  // CRDTP_JSON_H_
diff --git a/tools/inspector_protocol/crdtp/json_platform.cc b/tools/inspector_protocol/crdtp/json_platform.cc
new file mode 100644
index 00000000000000..d43db8683c269d
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/json_platform.cc
@@ -0,0 +1,33 @@
+// Copyright 2019 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "json_platform.h"
+
+#include <sstream>
+
+// This is a reference implementation using the C++ standard library.
+// Downstream projects may invoke their preferred routines instead,
+// by modifying / replacing this file to call them.
+// Examples of optimized string<->number conversion libraries:
+// - https://github.com/google/double-conversion
+// - https://github.com/abseil/abseil-cpp/blob/master/absl/strings/numbers.h
+namespace crdtp {
+namespace json {
+namespace platform {
+bool StrToD(const char* str, double* result) {
+  std::istringstream is(str);
+  is.imbue(std::locale::classic());
+  is >> *result;
+  return !is.fail() && is.eof();
+}
+
+std::string DToStr(double value) {
+  std::stringstream ss;
+  ss.imbue(std::locale::classic());
+  ss << value;
+  return ss.str();
+}
+}  // namespace platform
+}  // namespace json
+}  // namespace crdtp
diff --git a/tools/inspector_protocol/crdtp/json_platform.h b/tools/inspector_protocol/crdtp/json_platform.h
new file mode 100644
index 00000000000000..2ab09bf80e44e8
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/json_platform.h
@@ -0,0 +1,26 @@
+// Copyright 2019 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CRDTP_JSON_PLATFORM_H_
+#define CRDTP_JSON_PLATFORM_H_
+
+#include <string>
+
+namespace crdtp {
+namespace json {
+// These routines are implemented in json_platform.cc, or in a
+// platform-dependent (code-base dependent) custom replacement.
+// E.g., json_platform_chromium.cc, json_platform_v8.cc.
+namespace platform {
+// Parses |str| into |result|. Returns false iff there are
+// leftover characters or parsing errors.
+bool StrToD(const char* str, double* result);
+
+// Prints |value| in a format suitable for JSON.
+std::string DToStr(double value);
+}  // namespace platform
+}  // namespace json
+}  // namespace crdtp
+
+#endif  // CRDTP_JSON_PLATFORM_H_
diff --git a/tools/inspector_protocol/crdtp/json_test.cc b/tools/inspector_protocol/crdtp/json_test.cc
new file mode 100644
index 00000000000000..64362d391bf7b6
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/json_test.cc
@@ -0,0 +1,753 @@
+// Copyright 2018 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "json.h"
+
+#include <array>
+#include <clocale>
+#include <cmath>
+#include <cstdlib>
+#include <cstring>
+#include <iomanip>
+#include <iostream>
+#include <sstream>
+#include <string>
+
+#include "cbor.h"
+#include "parser_handler.h"
+#include "span.h"
+#include "status.h"
+#include "status_test_support.h"
+#include "test_platform.h"
+
+namespace crdtp {
+namespace json {
+// =============================================================================
+// json::NewJSONEncoder - for encoding streaming parser events as JSON
+// =============================================================================
+
+void WriteUTF8AsUTF16(ParserHandler* writer, const std::string& utf8) {
+  writer->HandleString16(SpanFrom(UTF8ToUTF16(SpanFrom(utf8))));
+}
+
+TEST(JsonEncoder, OverlongEncodings) {
+  std::string out;
+  Status status;
+  std::unique_ptr<ParserHandler> writer = NewJSONEncoder(&out, &status);
+
+  // We encode 0x7f, which is the DEL ascii character, as a 4 byte UTF8
+  // sequence. This is called an overlong encoding, because only 1 byte
+  // is needed to represent 0x7f as UTF8.
+  std::vector<uint8_t> chars = {
+      0xf0,  // Starts 4 byte utf8 sequence
+      0x80,  // continuation byte
+      0x81,  // continuation byte w/ payload bit 7 set to 1.
+      0xbf,  // continuation byte w/ payload bits 0-6 set to 11111.
+  };
+  writer->HandleString8(SpanFrom(chars));
+  EXPECT_EQ("\"\"", out);  // Empty string means that 0x7f was rejected (good).
+}
+
+TEST(JsonEncoder, NotAContinuationByte) {
+  std::string out;
+  Status status;
+  std::unique_ptr<ParserHandler> writer = NewJSONEncoder(&out, &status);
+
+  // |world| encodes the globe as a 4 byte UTF8 sequence. So, naturally, it'll
+  // have a start byte, followed by three continuation bytes.
+  std::string world = "🌎";
+  ASSERT_EQ(4u, world.size());
+  ASSERT_EQ(world[1] & 0xc0, 0x80);  // checks for continuation byte
+  ASSERT_EQ(world[2] & 0xc0, 0x80);
+  ASSERT_EQ(world[3] & 0xc0, 0x80);
+
+  // Now create a corrupted UTF8 string, starting with the first two bytes from
+  // |world|, followed by an ASCII message. Upon encountering '!', our decoder
+  // will realize that it's not a continuation byte; it'll skip to the end of
+  // this UTF8 sequence and continue with the next character. In this case, the
+  // 'H', of "Hello".
+  std::vector<uint8_t> chars;
+  chars.push_back(world[0]);
+  chars.push_back(world[1]);
+  chars.push_back('!');
+  chars.push_back('?');
+  chars.push_back('H');
+  chars.push_back('e');
+  chars.push_back('l');
+  chars.push_back('l');
+  chars.push_back('o');
+  writer->HandleString8(SpanFrom(chars));
+  EXPECT_EQ("\"Hello\"", out);  // "Hello" shows we restarted at 'H'.
+}
+
+TEST(JsonEncoder, EscapesLoneHighSurrogates) {
+  // This tests that the JSON encoder escapes lone high surrogates, i.e.
+  // invalid code points in the range from 0xD800 to 0xDBFF. In
+  // unescaped form, these cannot be represented in well-formed UTF-8 or
+  // UTF-16.
+  std::vector<uint16_t> chars = {'a', 0xd800, 'b', 0xdada, 'c', 0xdbff, 'd'};
+  std::string out;
+  Status status;
+  std::unique_ptr<ParserHandler> writer = NewJSONEncoder(&out, &status);
+  writer->HandleString16(span<uint16_t>(chars.data(), chars.size()));
+  EXPECT_EQ("\"a\\ud800b\\udadac\\udbffd\"", out);
+}
+
+TEST(JsonEncoder, EscapesLoneLowSurrogates) {
+  // This tests that the JSON encoder escapes lone low surrogates, i.e.
+  // invalid code points in the range from 0xDC00 to 0xDFFF. In
+  // unescaped form, these cannot be represented in well-formed UTF-8 or
+  // UTF-16.
+  std::vector<uint16_t> chars = {'a', 0xdc00, 'b', 0xdede, 'c', 0xdfff, 'd'};
+  std::string out;
+  Status status;
+  std::unique_ptr<ParserHandler> writer = NewJSONEncoder(&out, &status);
+  writer->HandleString16(span<uint16_t>(chars.data(), chars.size()));
+  EXPECT_EQ("\"a\\udc00b\\udedec\\udfffd\"", out);
+}
+
+TEST(JsonEncoder, EscapesFFFF) {
+  // This tests that the JSON encoder will escape the UTF16 input 0xffff as
+  // \uffff; useful to check this since it's an edge case.
+  std::vector<uint16_t> chars = {'a', 'b', 'c', 0xffff, 'd'};
+  std::string out;
+  Status status;
+  std::unique_ptr<ParserHandler> writer = NewJSONEncoder(&out, &status);
+  writer->HandleString16(span<uint16_t>(chars.data(), chars.size()));
+  EXPECT_EQ("\"abc\\uffffd\"", out);
+}
+
+TEST(JsonEncoder, Passes0x7FString8) {
+  std::vector<uint8_t> chars = {'a', 0x7f, 'b'};
+  std::string out;
+  Status status;
+  std::unique_ptr<ParserHandler> writer = NewJSONEncoder(&out, &status);
+  writer->HandleString8(span<uint8_t>(chars.data(), chars.size()));
+  EXPECT_EQ(
+      "\"a\x7f"
+      "b\"",
+      out);
+}
+
+TEST(JsonEncoder, Passes0x7FString16) {
+  std::vector<uint16_t> chars16 = {'a', 0x7f, 'b'};
+  std::string out;
+  Status status;
+  std::unique_ptr<ParserHandler> writer = NewJSONEncoder(&out, &status);
+  writer->HandleString16(span<uint16_t>(chars16.data(), chars16.size()));
+  EXPECT_EQ(
+      "\"a\x7f"
+      "b\"",
+      out);
+}
+
+TEST(JsonEncoder, IncompleteUtf8Sequence) {
+  std::string out;
+  Status status;
+  std::unique_ptr<ParserHandler> writer = NewJSONEncoder(&out, &status);
+
+  writer->HandleArrayBegin();  // This emits [, which starts an array.
+
+  {  // 🌎 takes four bytes to encode in UTF-8. We test with the first three;
+    // This means we're trying to emit a string that consists solely of an
+    // incomplete UTF-8 sequence. So the string in the JSON output is empty.
+    std::string world_utf8 = "🌎";
+    ASSERT_EQ(4u, world_utf8.size());
+    std::vector<uint8_t> chars(world_utf8.begin(), world_utf8.begin() + 3);
+    writer->HandleString8(SpanFrom(chars));
+    EXPECT_EQ("[\"\"", out);  // Incomplete sequence rejected: empty string.
+  }
+
+  {  // This time, the incomplete sequence is at the end of the string.
+    std::string msg = "Hello, \xF0\x9F\x8C";
+    std::vector<uint8_t> chars(msg.begin(), msg.end());
+    writer->HandleString8(SpanFrom(chars));
+    EXPECT_EQ("[\"\",\"Hello, \"", out);  // Incomplete sequence dropped at end.
+  }
+}
+
+TEST(JsonStdStringWriterTest, HelloWorld) {
+  std::string out;
+  Status status;
+  std::unique_ptr<ParserHandler> writer = NewJSONEncoder(&out, &status);
+  writer->HandleMapBegin();
+  WriteUTF8AsUTF16(writer.get(), "msg1");
+  WriteUTF8AsUTF16(writer.get(), "Hello, 🌎.");
+  std::string key = "msg1-as-utf8";
+  std::string value = "Hello, 🌎.";
+  writer->HandleString8(SpanFrom(key));
+  writer->HandleString8(SpanFrom(value));
+  WriteUTF8AsUTF16(writer.get(), "msg2");
+  WriteUTF8AsUTF16(writer.get(), "\\\b\r\n\t\f\"");
+  WriteUTF8AsUTF16(writer.get(), "nested");
+  writer->HandleMapBegin();
+  WriteUTF8AsUTF16(writer.get(), "double");
+  writer->HandleDouble(3.1415);
+  WriteUTF8AsUTF16(writer.get(), "int");
+  writer->HandleInt32(-42);
+  WriteUTF8AsUTF16(writer.get(), "bool");
+  writer->HandleBool(false);
+  WriteUTF8AsUTF16(writer.get(), "null");
+  writer->HandleNull();
+  writer->HandleMapEnd();
+  WriteUTF8AsUTF16(writer.get(), "array");
+  writer->HandleArrayBegin();
+  writer->HandleInt32(1);
+  writer->HandleInt32(2);
+  writer->HandleInt32(3);
+  writer->HandleArrayEnd();
+  writer->HandleMapEnd();
+  EXPECT_TRUE(status.ok());
+  EXPECT_EQ(
+      "{\"msg1\":\"Hello, \\ud83c\\udf0e.\","
+      "\"msg1-as-utf8\":\"Hello, \\ud83c\\udf0e.\","
+      "\"msg2\":\"\\\\\\b\\r\\n\\t\\f\\\"\","
+      "\"nested\":{\"double\":3.1415,\"int\":-42,"
+      "\"bool\":false,\"null\":null},\"array\":[1,2,3]}",
+      out);
+}
+
+TEST(JsonStdStringWriterTest, ScalarsAreRenderedAsInt) {
+  // Test that Number.MIN_SAFE_INTEGER / Number.MAX_SAFE_INTEGER from Javascript
+  // are rendered as integers (no decimal point / rounding), even when we
+  // encode them from double. Javascript's Number is an IEE754 double, so
+  // it has 53 bits to represent integers.
+  std::string out;
+  Status status;
+  std::unique_ptr<ParserHandler> writer = NewJSONEncoder(&out, &status);
+  writer->HandleMapBegin();
+
+  writer->HandleString8(SpanFrom("Number.MIN_SAFE_INTEGER"));
+  EXPECT_EQ(-0x1fffffffffffff, -9007199254740991);  // 53 bits for integers.
+  writer->HandleDouble(-9007199254740991);          // Note HandleDouble here.
+
+  writer->HandleString8(SpanFrom("Number.MAX_SAFE_INTEGER"));
+  EXPECT_EQ(0x1fffffffffffff, 9007199254740991);  // 53 bits for integers.
+  writer->HandleDouble(9007199254740991);         // Note HandleDouble here.
+
+  writer->HandleMapEnd();
+  EXPECT_TRUE(status.ok());
+  EXPECT_EQ(
+      "{\"Number.MIN_SAFE_INTEGER\":-9007199254740991,"
+      "\"Number.MAX_SAFE_INTEGER\":9007199254740991}",
+      out);
+}
+
+TEST(JsonStdStringWriterTest, RepresentingNonFiniteValuesAsNull) {
+  // JSON can't represent +Infinity, -Infinity, or NaN.
+  // So in practice it's mapped to null.
+  std::string out;
+  Status status;
+  std::unique_ptr<ParserHandler> writer = NewJSONEncoder(&out, &status);
+  writer->HandleMapBegin();
+  writer->HandleString8(SpanFrom("Infinity"));
+  writer->HandleDouble(std::numeric_limits<double>::infinity());
+  writer->HandleString8(SpanFrom("-Infinity"));
+  writer->HandleDouble(-std::numeric_limits<double>::infinity());
+  writer->HandleString8(SpanFrom("NaN"));
+  writer->HandleDouble(std::numeric_limits<double>::quiet_NaN());
+  writer->HandleMapEnd();
+  EXPECT_TRUE(status.ok());
+  EXPECT_EQ("{\"Infinity\":null,\"-Infinity\":null,\"NaN\":null}", out);
+}
+
+TEST(JsonStdStringWriterTest, BinaryEncodedAsJsonString) {
+  // The encoder emits binary submitted to ParserHandler::HandleBinary
+  // as base64. The following three examples are taken from
+  // https://en.wikipedia.org/wiki/Base64.
+  {
+    std::string out;
+    Status status;
+    std::unique_ptr<ParserHandler> writer = NewJSONEncoder(&out, &status);
+    writer->HandleBinary(SpanFrom(std::vector<uint8_t>({'M', 'a', 'n'})));
+    EXPECT_TRUE(status.ok());
+    EXPECT_EQ("\"TWFu\"", out);
+  }
+  {
+    std::string out;
+    Status status;
+    std::unique_ptr<ParserHandler> writer = NewJSONEncoder(&out, &status);
+    writer->HandleBinary(SpanFrom(std::vector<uint8_t>({'M', 'a'})));
+    EXPECT_TRUE(status.ok());
+    EXPECT_EQ("\"TWE=\"", out);
+  }
+  {
+    std::string out;
+    Status status;
+    std::unique_ptr<ParserHandler> writer = NewJSONEncoder(&out, &status);
+    writer->HandleBinary(SpanFrom(std::vector<uint8_t>({'M'})));
+    EXPECT_TRUE(status.ok());
+    EXPECT_EQ("\"TQ==\"", out);
+  }
+  {  // "Hello, world.", verified with base64decode.org.
+    std::string out;
+    Status status;
+    std::unique_ptr<ParserHandler> writer = NewJSONEncoder(&out, &status);
+    writer->HandleBinary(SpanFrom(std::vector<uint8_t>(
+        {'H', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '.'})));
+    EXPECT_TRUE(status.ok());
+    EXPECT_EQ("\"SGVsbG8sIHdvcmxkLg==\"", out);
+  }
+}
+
+TEST(JsonStdStringWriterTest, HandlesErrors) {
+  // When an error is sent via HandleError, it saves it in the provided
+  // status and clears the output.
+  std::string out;
+  Status status;
+  std::unique_ptr<ParserHandler> writer = NewJSONEncoder(&out, &status);
+  writer->HandleMapBegin();
+  WriteUTF8AsUTF16(writer.get(), "msg1");
+  writer->HandleError(Status{Error::JSON_PARSER_VALUE_EXPECTED, 42});
+  EXPECT_THAT(status, StatusIs(Error::JSON_PARSER_VALUE_EXPECTED, 42u));
+  EXPECT_EQ("", out);
+}
+
+TEST(JsonStdStringWriterTest, DoubleToString_LeadingZero) {
+  // In JSON, .1 must be rendered as 0.1, and -.7 must be rendered as -0.7.
+  std::string out;
+  Status status;
+  std::unique_ptr<ParserHandler> writer = NewJSONEncoder(&out, &status);
+  writer->HandleArrayBegin();
+  writer->HandleDouble(.1);
+  writer->HandleDouble(-.7);
+  writer->HandleArrayEnd();
+  EXPECT_EQ("[0.1,-0.7]", out);
+}
+
+// =============================================================================
+// json::ParseJSON - for receiving streaming parser events for JSON
+// =============================================================================
+
+class Log : public ParserHandler {
+ public:
+  void HandleMapBegin() override { log_ << "map begin\n"; }
+
+  void HandleMapEnd() override { log_ << "map end\n"; }
+
+  void HandleArrayBegin() override { log_ << "array begin\n"; }
+
+  void HandleArrayEnd() override { log_ << "array end\n"; }
+
+  void HandleString8(span<uint8_t> chars) override {
+    log_ << "string8: " << std::string(chars.begin(), chars.end()) << "\n";
+  }
+
+  void HandleString16(span<uint16_t> chars) override {
+    raw_log_string16_.emplace_back(chars.begin(), chars.end());
+    log_ << "string16: " << UTF16ToUTF8(chars) << "\n";
+  }
+
+  void HandleBinary(span<uint8_t> bytes) override {
+    // JSON doesn't have native support for arbitrary bytes, so our parser will
+    // never call this.
+    CHECK(false);
+  }
+
+  void HandleDouble(double value) override {
+    log_ << "double: " << value << "\n";
+  }
+
+  void HandleInt32(int32_t value) override { log_ << "int: " << value << "\n"; }
+
+  void HandleBool(bool value) override { log_ << "bool: " << value << "\n"; }
+
+  void HandleNull() override { log_ << "null\n"; }
+
+  void HandleError(Status status) override { status_ = status; }
+
+  std::string str() const { return status_.ok() ? log_.str() : ""; }
+
+  std::vector<std::vector<uint16_t>> raw_log_string16() const {
+    return raw_log_string16_;
+  }
+
+  Status status() const { return status_; }
+
+ private:
+  std::ostringstream log_;
+  std::vector<std::vector<uint16_t>> raw_log_string16_;
+  Status status_;
+};
+
+class JsonParserTest : public ::testing::Test {
+ protected:
+  Log log_;
+};
+
+TEST_F(JsonParserTest, SimpleDictionary) {
+  std::string json = "{\"foo\": 42}";
+  ParseJSON(SpanFrom(json), &log_);
+  EXPECT_TRUE(log_.status().ok());
+  EXPECT_EQ(
+      "map begin\n"
+      "string16: foo\n"
+      "int: 42\n"
+      "map end\n",
+      log_.str());
+}
+
+TEST_F(JsonParserTest, UsAsciiDelCornerCase) {
+  // DEL (0x7f) is a 7 bit US-ASCII character, and while it is a control
+  // character according to Unicode, it's not considered a control
+  // character in https://tools.ietf.org/html/rfc7159#section-7, so
+  // it can be placed directly into the JSON string, without JSON escaping.
+  std::string json = "{\"foo\": \"a\x7f\"}";
+  ParseJSON(SpanFrom(json), &log_);
+  EXPECT_TRUE(log_.status().ok());
+  EXPECT_EQ(
+      "map begin\n"
+      "string16: foo\n"
+      "string16: a\x7f\n"
+      "map end\n",
+      log_.str());
+
+  // We've seen an implementation of UTF16ToUTF8 which would replace the DEL
+  // character with ' ', so this simple roundtrip tests the routines in
+  // encoding_test_helper.h, to make test failures of the above easier to
+  // diagnose.
+  std::vector<uint16_t> utf16 = UTF8ToUTF16(SpanFrom(json));
+  EXPECT_EQ(json, UTF16ToUTF8(SpanFrom(utf16)));
+}
+
+TEST_F(JsonParserTest, Whitespace) {
+  std::string json = "\n  {\n\"msg\"\n: \v\"Hello, world.\"\t\r}\t";
+  ParseJSON(SpanFrom(json), &log_);
+  EXPECT_TRUE(log_.status().ok());
+  EXPECT_EQ(
+      "map begin\n"
+      "string16: msg\n"
+      "string16: Hello, world.\n"
+      "map end\n",
+      log_.str());
+}
+
+TEST_F(JsonParserTest, NestedDictionary) {
+  std::string json = "{\"foo\": {\"bar\": {\"baz\": 1}, \"bar2\": 2}}";
+  ParseJSON(SpanFrom(json), &log_);
+  EXPECT_TRUE(log_.status().ok());
+  EXPECT_EQ(
+      "map begin\n"
+      "string16: foo\n"
+      "map begin\n"
+      "string16: bar\n"
+      "map begin\n"
+      "string16: baz\n"
+      "int: 1\n"
+      "map end\n"
+      "string16: bar2\n"
+      "int: 2\n"
+      "map end\n"
+      "map end\n",
+      log_.str());
+}
+
+TEST_F(JsonParserTest, Doubles) {
+  std::string json = "{\"foo\": 3.1415, \"bar\": 31415e-4}";
+  ParseJSON(SpanFrom(json), &log_);
+  EXPECT_TRUE(log_.status().ok());
+  EXPECT_EQ(
+      "map begin\n"
+      "string16: foo\n"
+      "double: 3.1415\n"
+      "string16: bar\n"
+      "double: 3.1415\n"
+      "map end\n",
+      log_.str());
+}
+
+TEST_F(JsonParserTest, Unicode) {
+  // Globe character. 0xF0 0x9F 0x8C 0x8E in utf8, 0xD83C 0xDF0E in utf16.
+  std::string json = "{\"msg\": \"Hello, \\uD83C\\uDF0E.\"}";
+  ParseJSON(SpanFrom(json), &log_);
+  EXPECT_TRUE(log_.status().ok());
+  EXPECT_EQ(
+      "map begin\n"
+      "string16: msg\n"
+      "string16: Hello, 🌎.\n"
+      "map end\n",
+      log_.str());
+}
+
+TEST_F(JsonParserTest, Unicode_ParseUtf16) {
+  // Globe character. utf8: 0xF0 0x9F 0x8C 0x8E; utf16: 0xD83C 0xDF0E.
+  // Crescent moon character. utf8: 0xF0 0x9F 0x8C 0x99; utf16: 0xD83C 0xDF19.
+
+  // We provide the moon with json escape, but the earth as utf16 input.
+  // Either way they arrive as utf8 (after decoding in log_.str()).
+  std::vector<uint16_t> json =
+      UTF8ToUTF16(SpanFrom("{\"space\": \"🌎 \\uD83C\\uDF19.\"}"));
+  ParseJSON(SpanFrom(json), &log_);
+  EXPECT_TRUE(log_.status().ok());
+  EXPECT_EQ(
+      "map begin\n"
+      "string16: space\n"
+      "string16: 🌎 🌙.\n"
+      "map end\n",
+      log_.str());
+}
+
+TEST_F(JsonParserTest, Unicode_ParseUtf16_SingleEscapeUpToFFFF) {
+  // 0xFFFF is the max codepoint that can be represented as a single \u escape.
+  // One way to write this is \uffff, another way is to encode it as a 3 byte
+  // UTF-8 sequence (0xef 0xbf 0xbf). Both are equivalent.
+
+  // Example with both ways of encoding code point 0xFFFF in a JSON string.
+  std::string json = "{\"escape\": \"\xef\xbf\xbf or \\uffff\"}";
+  ParseJSON(SpanFrom(json), &log_);
+  EXPECT_TRUE(log_.status().ok());
+
+  // Shows both inputs result in equivalent output once converted to UTF-8.
+  EXPECT_EQ(
+      "map begin\n"
+      "string16: escape\n"
+      "string16: \xEF\xBF\xBF or \xEF\xBF\xBF\n"
+      "map end\n",
+      log_.str());
+
+  // Make an even stronger assertion: The parser represents \xffff as a single
+  // UTF-16 char.
+  ASSERT_EQ(2u, log_.raw_log_string16().size());
+  std::vector<uint16_t> expected = {0xffff, ' ', 'o', 'r', ' ', 0xffff};
+  EXPECT_EQ(expected, log_.raw_log_string16()[1]);
+}
+
+TEST_F(JsonParserTest, Unicode_ParseUtf8) {
+  // Used below:
+  // гласность - example for 2 byte utf8, Russian word "glasnost"
+  // 屋 - example for 3 byte utf8, Chinese word for "house"
+  // 🌎 - example for 4 byte utf8: 0xF0 0x9F 0x8C 0x8E; utf16: 0xD83C 0xDF0E.
+  // 🌙 - example for escapes: utf8: 0xF0 0x9F 0x8C 0x99; utf16: 0xD83C 0xDF19.
+
+  // We provide the moon with json escape, but the earth as utf8 input.
+  // Either way they arrive as utf8 (after decoding in log_.str()).
+  std::string json =
+      "{"
+      "\"escapes\": \"\\uD83C\\uDF19\","
+      "\"2 byte\":\"гласность\","
+      "\"3 byte\":\"屋\","
+      "\"4 byte\":\"🌎\""
+      "}";
+  ParseJSON(SpanFrom(json), &log_);
+  EXPECT_TRUE(log_.status().ok());
+  EXPECT_EQ(
+      "map begin\n"
+      "string16: escapes\n"
+      "string16: 🌙\n"
+      "string16: 2 byte\n"
+      "string16: гласность\n"
+      "string16: 3 byte\n"
+      "string16: 屋\n"
+      "string16: 4 byte\n"
+      "string16: 🌎\n"
+      "map end\n",
+      log_.str());
+}
+
+TEST_F(JsonParserTest, UnprocessedInputRemainsError) {
+  // Trailing junk after the valid JSON.
+  std::string json = "{\"foo\": 3.1415} junk";
+  size_t junk_idx = json.find("junk");
+  EXPECT_NE(junk_idx, std::string::npos);
+  ParseJSON(SpanFrom(json), &log_);
+  EXPECT_THAT(log_.status(),
+              StatusIs(Error::JSON_PARSER_UNPROCESSED_INPUT_REMAINS, junk_idx));
+  EXPECT_EQ("", log_.str());
+}
+
+std::string MakeNestedJson(int depth) {
+  std::string json;
+  for (int ii = 0; ii < depth; ++ii)
+    json += "{\"foo\":";
+  json += "42";
+  for (int ii = 0; ii < depth; ++ii)
+    json += "}";
+  return json;
+}
+
+TEST_F(JsonParserTest, StackLimitExceededError_BelowLimit) {
+  // kStackLimit is 300 (see json_parser.cc). First let's
+  // try with a small nested example.
+  std::string json_3 = MakeNestedJson(3);
+  ParseJSON(SpanFrom(json_3), &log_);
+  EXPECT_TRUE(log_.status().ok());
+  EXPECT_EQ(
+      "map begin\n"
+      "string16: foo\n"
+      "map begin\n"
+      "string16: foo\n"
+      "map begin\n"
+      "string16: foo\n"
+      "int: 42\n"
+      "map end\n"
+      "map end\n"
+      "map end\n",
+      log_.str());
+}
+
+TEST_F(JsonParserTest, StackLimitExceededError_AtLimit) {
+  // Now with kStackLimit (300).
+  std::string json_limit = MakeNestedJson(300);
+  ParseJSON(span<uint8_t>(reinterpret_cast<const uint8_t*>(json_limit.data()),
+                          json_limit.size()),
+            &log_);
+  EXPECT_THAT(log_.status(), StatusIsOk());
+}
+
+TEST_F(JsonParserTest, StackLimitExceededError_AboveLimit) {
+  // Now with kStackLimit + 1 (301) - it exceeds in the innermost instance.
+  std::string exceeded = MakeNestedJson(301);
+  ParseJSON(SpanFrom(exceeded), &log_);
+  EXPECT_THAT(log_.status(), StatusIs(Error::JSON_PARSER_STACK_LIMIT_EXCEEDED,
+                                      strlen("{\"foo\":") * 301));
+}
+
+TEST_F(JsonParserTest, StackLimitExceededError_WayAboveLimit) {
+  // Now way past the limit. Still, the point of exceeding is 301.
+  std::string far_out = MakeNestedJson(320);
+  ParseJSON(SpanFrom(far_out), &log_);
+  EXPECT_THAT(log_.status(), StatusIs(Error::JSON_PARSER_STACK_LIMIT_EXCEEDED,
+                                      strlen("{\"foo\":") * 301));
+}
+
+TEST_F(JsonParserTest, NoInputError) {
+  std::string json = "";
+  ParseJSON(SpanFrom(json), &log_);
+  EXPECT_THAT(log_.status(), StatusIs(Error::JSON_PARSER_NO_INPUT, 0u));
+  EXPECT_EQ("", log_.str());
+}
+
+TEST_F(JsonParserTest, InvalidTokenError) {
+  std::string json = "|";
+  ParseJSON(SpanFrom(json), &log_);
+  EXPECT_THAT(log_.status(), StatusIs(Error::JSON_PARSER_INVALID_TOKEN, 0u));
+  EXPECT_EQ("", log_.str());
+}
+
+TEST_F(JsonParserTest, InvalidNumberError) {
+  // Mantissa exceeds max (the constant used here is int64_t max).
+  std::string json = "1E9223372036854775807";
+  ParseJSON(SpanFrom(json), &log_);
+  EXPECT_THAT(log_.status(), StatusIs(Error::JSON_PARSER_INVALID_NUMBER, 0u));
+  EXPECT_EQ("", log_.str());
+}
+
+TEST_F(JsonParserTest, InvalidStringError) {
+  // \x22 is an unsupported escape sequence
+  std::string json = "\"foo\\x22\"";
+  ParseJSON(SpanFrom(json), &log_);
+  EXPECT_THAT(log_.status(), StatusIs(Error::JSON_PARSER_INVALID_STRING, 0u));
+  EXPECT_EQ("", log_.str());
+}
+
+TEST_F(JsonParserTest, UnexpectedArrayEndError) {
+  std::string json = "[1,2,]";
+  ParseJSON(SpanFrom(json), &log_);
+  EXPECT_THAT(log_.status(),
+              StatusIs(Error::JSON_PARSER_UNEXPECTED_ARRAY_END, 5u));
+  EXPECT_EQ("", log_.str());
+}
+
+TEST_F(JsonParserTest, CommaOrArrayEndExpectedError) {
+  std::string json = "[1,2 2";
+  ParseJSON(SpanFrom(json), &log_);
+  EXPECT_THAT(log_.status(),
+              StatusIs(Error::JSON_PARSER_COMMA_OR_ARRAY_END_EXPECTED, 5u));
+  EXPECT_EQ("", log_.str());
+}
+
+TEST_F(JsonParserTest, StringLiteralExpectedError) {
+  // There's an error because the key bar, a string, is not terminated.
+  std::string json = "{\"foo\": 3.1415, \"bar: 31415e-4}";
+  ParseJSON(SpanFrom(json), &log_);
+  EXPECT_THAT(log_.status(),
+              StatusIs(Error::JSON_PARSER_STRING_LITERAL_EXPECTED, 16u));
+  EXPECT_EQ("", log_.str());
+}
+
+TEST_F(JsonParserTest, ColonExpectedError) {
+  std::string json = "{\"foo\", 42}";
+  ParseJSON(SpanFrom(json), &log_);
+  EXPECT_THAT(log_.status(), StatusIs(Error::JSON_PARSER_COLON_EXPECTED, 6u));
+  EXPECT_EQ("", log_.str());
+}
+
+TEST_F(JsonParserTest, UnexpectedMapEndError) {
+  std::string json = "{\"foo\": 42, }";
+  ParseJSON(SpanFrom(json), &log_);
+  EXPECT_THAT(log_.status(),
+              StatusIs(Error::JSON_PARSER_UNEXPECTED_MAP_END, 12u));
+  EXPECT_EQ("", log_.str());
+}
+
+TEST_F(JsonParserTest, CommaOrMapEndExpectedError) {
+  // The second separator should be a comma.
+  std::string json = "{\"foo\": 3.1415: \"bar\": 0}";
+  ParseJSON(SpanFrom(json), &log_);
+  EXPECT_THAT(log_.status(),
+              StatusIs(Error::JSON_PARSER_COMMA_OR_MAP_END_EXPECTED, 14u));
+  EXPECT_EQ("", log_.str());
+}
+
+TEST_F(JsonParserTest, ValueExpectedError) {
+  std::string json = "}";
+  ParseJSON(SpanFrom(json), &log_);
+  EXPECT_THAT(log_.status(), StatusIs(Error::JSON_PARSER_VALUE_EXPECTED, 0u));
+  EXPECT_EQ("", log_.str());
+}
+
+template <typename T>
+class ConvertJSONToCBORTest : public ::testing::Test {};
+
+using ContainerTestTypes = ::testing::Types<std::vector<uint8_t>, std::string>;
+TYPED_TEST_SUITE(ConvertJSONToCBORTest, ContainerTestTypes);
+
+TYPED_TEST(ConvertJSONToCBORTest, RoundTripValidJson) {
+  for (const std::string& json_in : {
+           "{\"msg\":\"Hello, world.\",\"lst\":[1,2,3]}",
+           "3.1415",
+           "false",
+           "true",
+           "\"Hello, world.\"",
+           "[1,2,3]",
+           "[]",
+       }) {
+    SCOPED_TRACE(json_in);
+    TypeParam json(json_in.begin(), json_in.end());
+    std::vector<uint8_t> cbor;
+    {
+      Status status = ConvertJSONToCBOR(SpanFrom(json), &cbor);
+      EXPECT_THAT(status, StatusIsOk());
+    }
+    TypeParam roundtrip_json;
+    {
+      Status status = ConvertCBORToJSON(SpanFrom(cbor), &roundtrip_json);
+      EXPECT_THAT(status, StatusIsOk());
+    }
+    EXPECT_EQ(json, roundtrip_json);
+  }
+}
+
+TYPED_TEST(ConvertJSONToCBORTest, RoundTripValidJson16) {
+  std::vector<uint16_t> json16 = {
+      '{', '"', 'm', 's',    'g',    '"', ':', '"', 'H', 'e', 'l', 'l',
+      'o', ',', ' ', 0xd83c, 0xdf0e, '.', '"', ',', '"', 'l', 's', 't',
+      '"', ':', '[', '1',    ',',    '2', ',', '3', ']', '}'};
+  std::vector<uint8_t> cbor;
+  {
+    Status status =
+        ConvertJSONToCBOR(span<uint16_t>(json16.data(), json16.size()), &cbor);
+    EXPECT_THAT(status, StatusIsOk());
+  }
+  TypeParam roundtrip_json;
+  {
+    Status status = ConvertCBORToJSON(SpanFrom(cbor), &roundtrip_json);
+    EXPECT_THAT(status, StatusIsOk());
+  }
+  std::string json = "{\"msg\":\"Hello, \\ud83c\\udf0e.\",\"lst\":[1,2,3]}";
+  TypeParam expected_json(json.begin(), json.end());
+  EXPECT_EQ(expected_json, roundtrip_json);
+}
+}  // namespace json
+}  // namespace crdtp
diff --git a/tools/inspector_protocol/crdtp/maybe.h b/tools/inspector_protocol/crdtp/maybe.h
new file mode 100644
index 00000000000000..ecdfb4fd89fe8f
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/maybe.h
@@ -0,0 +1,154 @@
+// Copyright 2019 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+#ifndef CRDTP_MAYBE_H_
+#define CRDTP_MAYBE_H_
+
+#include <cassert>
+#include <memory>
+
+namespace crdtp {
+
+// =============================================================================
+// detail::PtrMaybe, detail::ValueMaybe, templates for optional
+// pointers / values which are used in ../lib/Forward_h.template.
+// =============================================================================
+
+namespace detail {
+template <typename T>
+class PtrMaybe {
+ public:
+  PtrMaybe() = default;
+  PtrMaybe(std::unique_ptr<T> value) : value_(std::move(value)) {}
+  PtrMaybe(PtrMaybe&& other) noexcept : value_(std::move(other.value_)) {}
+  void operator=(std::unique_ptr<T> value) { value_ = std::move(value); }
+
+  // std::optional<>-compatible accessors (preferred).
+  bool has_value() const { return !!value_; }
+  operator bool() const { return has_value(); }
+  const T& value() const& {
+    assert(has_value());
+    return *value_;
+  }
+  T& value() & {
+    assert(has_value());
+    return *value_;
+  }
+  T&& value() && {
+    assert(has_value());
+    return std::move(*value_);
+  }
+  const T& value_or(const T& default_value) const {
+    return has_value() ? *value_ : default_value;
+  }
+  T* operator->() { return &value(); }
+  const T* operator->() const { return &value(); }
+
+  T& operator*() & { return value(); }
+  const T& operator*() const& { return value(); }
+  T&& operator*() && { return std::move(value()); }
+
+  // Legacy Maybe<> accessors (deprecated).
+  T* fromJust() const {
+    assert(value_);
+    return value_.get();
+  }
+  T* fromMaybe(T* default_value) const {
+    return value_ ? value_.get() : default_value;
+  }
+  bool isJust() const { return value_ != nullptr; }
+
+ private:
+  std::unique_ptr<T> value_;
+};
+
+template <typename T>
+class ValueMaybe {
+ public:
+  ValueMaybe() : is_just_(false), value_() {}
+  ValueMaybe(T value) : is_just_(true), value_(std::move(value)) {}
+  ValueMaybe(ValueMaybe&& other) noexcept
+      : is_just_(other.is_just_), value_(std::move(other.value_)) {}
+  void operator=(T value) {
+    value_ = std::move(value);
+    is_just_ = true;
+  }
+
+  // std::optional<>-compatible accessors (preferred).
+  bool has_value() const { return is_just_; }
+  operator bool() const { return has_value(); }
+  const T& value() const& {
+    assert(is_just_);
+    return value_;
+  }
+  T& value() & {
+    assert(is_just_);
+    return value_;
+  }
+  T&& value() && {
+    assert(is_just_);
+    return *std::move(value_);
+  }
+  template <typename U>
+  T value_or(U&& default_value) const& {
+    return is_just_ ? value_ : std::forward<U>(default_value);
+  }
+  template <typename U>
+  T value_or(U&& default_value) && {
+    return is_just_ ? std::move(value_) : std::forward<U>(default_value);
+  }
+  T* operator->() { return &value(); }
+  const T* operator->() const { return &value(); }
+
+  T& operator*() & { return value(); }
+  const T& operator*() const& { return value(); }
+  T&& operator*() && { return std::move(value()); }
+
+  // Legacy Maybe<> accessors (deprecated).
+  const T& fromJust() const {
+    assert(is_just_);
+    return value_;
+  }
+  const T& fromMaybe(const T& default_value) const {
+    return is_just_ ? value_ : default_value;
+  }
+  bool isJust() const { return is_just_; }
+
+ private:
+  bool is_just_;
+  T value_;
+};
+
+template <typename T>
+struct MaybeTypedef {
+  typedef PtrMaybe<T> type;
+};
+
+template <>
+struct MaybeTypedef<bool> {
+  typedef ValueMaybe<bool> type;
+};
+
+template <>
+struct MaybeTypedef<int> {
+  typedef ValueMaybe<int> type;
+};
+
+template <>
+struct MaybeTypedef<double> {
+  typedef ValueMaybe<double> type;
+};
+
+template <>
+struct MaybeTypedef<std::string> {
+  typedef ValueMaybe<std::string> type;
+};
+
+}  // namespace detail
+
+template <typename T>
+using Maybe = typename detail::MaybeTypedef<T>::type;
+
+}  // namespace crdtp
+
+#endif  // CRDTP_MAYBE_H_
diff --git a/tools/inspector_protocol/crdtp/maybe_test.cc b/tools/inspector_protocol/crdtp/maybe_test.cc
new file mode 100644
index 00000000000000..d606692b51a1c5
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/maybe_test.cc
@@ -0,0 +1,44 @@
+// Copyright 2019 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "maybe.h"
+
+#include <string>
+#include <vector>
+
+#include "test_platform.h"
+
+namespace crdtp {
+
+// =============================================================================
+// detail::PtrMaybe, detail::ValueMaybe, templates for optional
+// pointers / values which are used in ../lib/Forward_h.template.
+// =============================================================================
+TEST(PtrMaybeTest, SmokeTest) {
+  detail::PtrMaybe<std::vector<uint32_t>> example;
+  EXPECT_FALSE(example.has_value());
+  std::unique_ptr<std::vector<uint32_t>> v(new std::vector<uint32_t>);
+  v->push_back(42);
+  v->push_back(21);
+  example = std::move(v);
+  EXPECT_TRUE(example.has_value());
+  EXPECT_THAT(example.value(), testing::ElementsAre(42, 21));
+  std::vector<uint32_t> out = *std::move(example);
+  EXPECT_TRUE(example.has_value());
+  EXPECT_THAT(*example, testing::IsEmpty());
+  EXPECT_THAT(out, testing::ElementsAre(42, 21));
+}
+
+TEST(ValueMaybeTest, SmokeTest) {
+  detail::ValueMaybe<int32_t> example;
+  EXPECT_FALSE(example.has_value());
+  EXPECT_EQ(-1, example.value_or(-1));
+  example = 42;
+  EXPECT_TRUE(example.has_value());
+  EXPECT_EQ(42, example.value());
+  int32_t out = *std::move(example);
+  EXPECT_EQ(out, 42);
+}
+
+}  // namespace crdtp
diff --git a/tools/inspector_protocol/crdtp/parser_handler.h b/tools/inspector_protocol/crdtp/parser_handler.h
new file mode 100644
index 00000000000000..ed7aae14da34b1
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/parser_handler.h
@@ -0,0 +1,39 @@
+// Copyright 2019 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CRDTP_PARSER_HANDLER_H_
+#define CRDTP_PARSER_HANDLER_H_
+
+#include <cstdint>
+#include "span.h"
+#include "status.h"
+
+namespace crdtp {
+// Handler interface for parser events emitted by a streaming parser.
+// See cbor::NewCBOREncoder, cbor::ParseCBOR, json::NewJSONEncoder,
+// json::ParseJSON.
+class ParserHandler {
+ public:
+  virtual ~ParserHandler() = default;
+  virtual void HandleMapBegin() = 0;
+  virtual void HandleMapEnd() = 0;
+  virtual void HandleArrayBegin() = 0;
+  virtual void HandleArrayEnd() = 0;
+  virtual void HandleString8(span<uint8_t> chars) = 0;
+  virtual void HandleString16(span<uint16_t> chars) = 0;
+  virtual void HandleBinary(span<uint8_t> bytes) = 0;
+  virtual void HandleDouble(double value) = 0;
+  virtual void HandleInt32(int32_t value) = 0;
+  virtual void HandleBool(bool value) = 0;
+  virtual void HandleNull() = 0;
+
+  // The parser may send one error even after other events have already
+  // been received. Client code is reponsible to then discard the
+  // already processed events.
+  // |error| must be an eror, as in, |error.is_ok()| can't be true.
+  virtual void HandleError(Status error) = 0;
+};
+}  // namespace crdtp
+
+#endif  // CRDTP_PARSER_HANDLER_H_
diff --git a/tools/inspector_protocol/crdtp/protocol_core.cc b/tools/inspector_protocol/crdtp/protocol_core.cc
new file mode 100644
index 00000000000000..d9cc3b11360087
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/protocol_core.cc
@@ -0,0 +1,289 @@
+// Copyright 2020 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "protocol_core.h"
+
+#include <algorithm>
+#include <cassert>
+#include <string>
+
+namespace crdtp {
+
+DeserializerState::DeserializerState(std::vector<uint8_t> bytes)
+    : storage_(new std::vector<uint8_t>(std::move(bytes))),
+      tokenizer_(span<uint8_t>(storage_->data(), storage_->size())) {}
+
+DeserializerState::DeserializerState(Storage storage, span<uint8_t> span)
+    : storage_(std::move(storage)), tokenizer_(span) {}
+
+void DeserializerState::RegisterError(Error error) {
+  assert(Error::OK != error);
+  if (tokenizer_.Status().ok())
+    status_ = Status{error, tokenizer_.Status().pos};
+}
+
+void DeserializerState::RegisterFieldPath(span<char> name) {
+  field_path_.push_back(name);
+}
+
+std::string DeserializerState::ErrorMessage(span<char> message_name) const {
+  std::string msg = "Failed to deserialize ";
+  msg.append(message_name.begin(), message_name.end());
+  for (int field = static_cast<int>(field_path_.size()) - 1; field >= 0;
+       --field) {
+    msg.append(".");
+    msg.append(field_path_[field].begin(), field_path_[field].end());
+  }
+  Status s = status();
+  if (!s.ok())
+    msg += " - " + s.ToASCIIString();
+  return msg;
+}
+
+Status DeserializerState::status() const {
+  if (!tokenizer_.Status().ok())
+    return tokenizer_.Status();
+  return status_;
+}
+
+namespace {
+constexpr int32_t GetMandatoryFieldMask(
+    const DeserializerDescriptor::Field* fields,
+    size_t count) {
+  int32_t mask = 0;
+  for (size_t i = 0; i < count; ++i) {
+    if (!fields[i].is_optional)
+      mask |= (1 << i);
+  }
+  return mask;
+}
+}  // namespace
+
+DeserializerDescriptor::DeserializerDescriptor(const Field* fields,
+                                               size_t field_count)
+    : fields_(fields),
+      field_count_(field_count),
+      mandatory_field_mask_(GetMandatoryFieldMask(fields, field_count)) {}
+
+bool DeserializerDescriptor::Deserialize(DeserializerState* state,
+                                         void* obj) const {
+  auto* tokenizer = state->tokenizer();
+
+  // As a special compatibility quirk, allow empty objects if
+  // no mandatory fields are required.
+  if (tokenizer->TokenTag() == cbor::CBORTokenTag::DONE &&
+      !mandatory_field_mask_) {
+    return true;
+  }
+  if (tokenizer->TokenTag() == cbor::CBORTokenTag::ENVELOPE)
+    tokenizer->EnterEnvelope();
+  if (tokenizer->TokenTag() != cbor::CBORTokenTag::MAP_START) {
+    state->RegisterError(Error::CBOR_MAP_START_EXPECTED);
+    return false;
+  }
+  tokenizer->Next();
+  int32_t seen_mandatory_fields = 0;
+  for (; tokenizer->TokenTag() != cbor::CBORTokenTag::STOP; tokenizer->Next()) {
+    if (tokenizer->TokenTag() != cbor::CBORTokenTag::STRING8) {
+      state->RegisterError(Error::CBOR_INVALID_MAP_KEY);
+      return false;
+    }
+    span<uint8_t> u_key = tokenizer->GetString8();
+    span<char> key(reinterpret_cast<const char*>(u_key.data()), u_key.size());
+    tokenizer->Next();
+    if (!DeserializeField(state, key, &seen_mandatory_fields, obj))
+      return false;
+  }
+  // Only compute mandatory fields once per type.
+  int32_t missing_fields = seen_mandatory_fields ^ mandatory_field_mask_;
+  if (missing_fields) {
+    int32_t idx = 0;
+    while ((missing_fields & 1) == 0) {
+      missing_fields >>= 1;
+      ++idx;
+    }
+    state->RegisterError(Error::BINDINGS_MANDATORY_FIELD_MISSING);
+    state->RegisterFieldPath(fields_[idx].name);
+    return false;
+  }
+  return true;
+}
+
+bool DeserializerDescriptor::DeserializeField(DeserializerState* state,
+                                              span<char> name,
+                                              int* seen_mandatory_fields,
+                                              void* obj) const {
+  // TODO(caseq): consider checking if the sought field is the one
+  // after the last deserialized.
+  const auto* begin = fields_;
+  const auto* end = fields_ + field_count_;
+  auto entry = std::lower_bound(
+      begin, end, name, [](const Field& field_desc, span<char> field_name) {
+        return SpanLessThan(field_desc.name, field_name);
+      });
+  // Unknown field is not an error -- we may be working against an
+  // implementation of a later version of the protocol.
+  // TODO(caseq): support unknown arrays and maps not enclosed by an envelope.
+  if (entry == end || !SpanEquals(entry->name, name))
+    return true;
+  if (!entry->deserializer(state, obj)) {
+    state->RegisterFieldPath(name);
+    return false;
+  }
+  if (!entry->is_optional)
+    *seen_mandatory_fields |= 1 << (entry - begin);
+  return true;
+}
+
+bool ProtocolTypeTraits<bool>::Deserialize(DeserializerState* state,
+                                           bool* value) {
+  const auto tag = state->tokenizer()->TokenTag();
+  if (tag == cbor::CBORTokenTag::TRUE_VALUE) {
+    *value = true;
+    return true;
+  }
+  if (tag == cbor::CBORTokenTag::FALSE_VALUE) {
+    *value = false;
+    return true;
+  }
+  state->RegisterError(Error::BINDINGS_BOOL_VALUE_EXPECTED);
+  return false;
+}
+
+void ProtocolTypeTraits<bool>::Serialize(bool value,
+                                         std::vector<uint8_t>* bytes) {
+  bytes->push_back(value ? cbor::EncodeTrue() : cbor::EncodeFalse());
+}
+
+bool ProtocolTypeTraits<int32_t>::Deserialize(DeserializerState* state,
+                                              int32_t* value) {
+  if (state->tokenizer()->TokenTag() != cbor::CBORTokenTag::INT32) {
+    state->RegisterError(Error::BINDINGS_INT32_VALUE_EXPECTED);
+    return false;
+  }
+  *value = state->tokenizer()->GetInt32();
+  return true;
+}
+
+void ProtocolTypeTraits<int32_t>::Serialize(int32_t value,
+                                            std::vector<uint8_t>* bytes) {
+  cbor::EncodeInt32(value, bytes);
+}
+
+ContainerSerializer::ContainerSerializer(std::vector<uint8_t>* bytes,
+                                         uint8_t tag)
+    : bytes_(bytes) {
+  envelope_.EncodeStart(bytes_);
+  bytes_->push_back(tag);
+}
+
+void ContainerSerializer::EncodeStop() {
+  bytes_->push_back(cbor::EncodeStop());
+  envelope_.EncodeStop(bytes_);
+}
+
+ObjectSerializer::ObjectSerializer()
+    : serializer_(&owned_bytes_, cbor::EncodeIndefiniteLengthMapStart()) {}
+
+ObjectSerializer::~ObjectSerializer() = default;
+
+std::unique_ptr<Serializable> ObjectSerializer::Finish() {
+  serializer_.EncodeStop();
+  return Serializable::From(std::move(owned_bytes_));
+}
+
+bool ProtocolTypeTraits<double>::Deserialize(DeserializerState* state,
+                                             double* value) {
+  // Double values that round-trip through JSON may end up getting represented
+  // as an int32 (SIGNED, UNSIGNED) on the wire in CBOR. Therefore, we also
+  // accept an INT32 here.
+  if (state->tokenizer()->TokenTag() == cbor::CBORTokenTag::INT32) {
+    *value = state->tokenizer()->GetInt32();
+    return true;
+  }
+  if (state->tokenizer()->TokenTag() != cbor::CBORTokenTag::DOUBLE) {
+    state->RegisterError(Error::BINDINGS_DOUBLE_VALUE_EXPECTED);
+    return false;
+  }
+  *value = state->tokenizer()->GetDouble();
+  return true;
+}
+
+void ProtocolTypeTraits<double>::Serialize(double value,
+                                           std::vector<uint8_t>* bytes) {
+  cbor::EncodeDouble(value, bytes);
+}
+
+class IncomingDeferredMessage : public DeferredMessage {
+ public:
+  // Creates the state from the part of another message.
+  // Note storage is opaque and is mostly to retain ownership.
+  // It may be null in case caller owns the memory and will dispose
+  // of the message synchronously.
+  IncomingDeferredMessage(DeserializerState::Storage storage,
+                          span<uint8_t> span)
+      : storage_(storage), span_(span) {}
+
+ private:
+  DeserializerState MakeDeserializer() const override {
+    return DeserializerState(storage_, span_);
+  }
+  void AppendSerialized(std::vector<uint8_t>* out) const override {
+    out->insert(out->end(), span_.begin(), span_.end());
+  }
+
+  DeserializerState::Storage storage_;
+  span<uint8_t> span_;
+};
+
+class OutgoingDeferredMessage : public DeferredMessage {
+ public:
+  OutgoingDeferredMessage() = default;
+  explicit OutgoingDeferredMessage(std::unique_ptr<Serializable> serializable)
+      : serializable_(std::move(serializable)) {
+    assert(!!serializable_);
+  }
+
+ private:
+  DeserializerState MakeDeserializer() const override {
+    return DeserializerState(serializable_->Serialize());
+  }
+  void AppendSerialized(std::vector<uint8_t>* out) const override {
+    serializable_->AppendSerialized(out);
+  }
+
+  std::unique_ptr<Serializable> serializable_;
+};
+
+// static
+std::unique_ptr<DeferredMessage> DeferredMessage::FromSerializable(
+    std::unique_ptr<Serializable> serializeable) {
+  return std::make_unique<OutgoingDeferredMessage>(std::move(serializeable));
+}
+
+// static
+std::unique_ptr<DeferredMessage> DeferredMessage::FromSpan(
+    span<uint8_t> bytes) {
+  return std::make_unique<IncomingDeferredMessage>(nullptr, bytes);
+}
+
+bool ProtocolTypeTraits<std::unique_ptr<DeferredMessage>>::Deserialize(
+    DeserializerState* state,
+    std::unique_ptr<DeferredMessage>* value) {
+  if (state->tokenizer()->TokenTag() != cbor::CBORTokenTag::ENVELOPE) {
+    state->RegisterError(Error::CBOR_INVALID_ENVELOPE);
+    return false;
+  }
+  *value = std::make_unique<IncomingDeferredMessage>(
+      state->storage(), state->tokenizer()->GetEnvelope());
+  return true;
+}
+
+void ProtocolTypeTraits<std::unique_ptr<DeferredMessage>>::Serialize(
+    const std::unique_ptr<DeferredMessage>& value,
+    std::vector<uint8_t>* bytes) {
+  value->AppendSerialized(bytes);
+}
+
+}  // namespace crdtp
diff --git a/tools/inspector_protocol/crdtp/protocol_core.h b/tools/inspector_protocol/crdtp/protocol_core.h
new file mode 100644
index 00000000000000..e89e0b2d9516eb
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/protocol_core.h
@@ -0,0 +1,418 @@
+// Copyright 2020 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CRDTP_PROTOCOL_CORE_H_
+#define CRDTP_PROTOCOL_CORE_H_
+
+#include <sys/types.h>
+
+#include <memory>
+#include <string>
+#include <tuple>
+#include <vector>
+
+#include "cbor.h"
+#include "maybe.h"
+#include "serializable.h"
+#include "span.h"
+#include "status.h"
+
+namespace crdtp {
+
+class CRDTP_EXPORT DeserializerState {
+ public:
+  using Storage = std::shared_ptr<const std::vector<uint8_t>>;
+
+  // Creates a state from the raw bytes received from the peer.
+  explicit DeserializerState(std::vector<uint8_t> bytes);
+  // Creates the state from the part of another message.
+  DeserializerState(Storage storage, span<uint8_t> span);
+  DeserializerState(const DeserializerState& r) = delete;
+  DeserializerState(DeserializerState&& r) = default;
+
+  // Registers |error|, unless the tokenizer's status is already an error.
+  void RegisterError(Error error);
+  // Registers |name| as a segment of the field path.
+  void RegisterFieldPath(span<char> name);
+
+  // Produces an error message considering |tokenizer.Status()|,
+  // status_, and field_path_.
+  std::string ErrorMessage(span<char> message_name) const;
+  Status status() const;
+  const Storage& storage() const { return storage_; }
+  cbor::CBORTokenizer* tokenizer() { return &tokenizer_; }
+
+ private:
+  const Storage storage_;
+  cbor::CBORTokenizer tokenizer_;
+  Status status_;
+  std::vector<span<char>> field_path_;
+};
+
+template <typename T, typename = void>
+struct ProtocolTypeTraits {};
+
+template <>
+struct CRDTP_EXPORT ProtocolTypeTraits<bool> {
+  static bool Deserialize(DeserializerState* state, bool* value);
+  static void Serialize(bool value, std::vector<uint8_t>* bytes);
+};
+
+template <>
+struct CRDTP_EXPORT ProtocolTypeTraits<int32_t> {
+  static bool Deserialize(DeserializerState* state, int* value);
+  static void Serialize(int value, std::vector<uint8_t>* bytes);
+};
+
+template <>
+struct CRDTP_EXPORT ProtocolTypeTraits<double> {
+  static bool Deserialize(DeserializerState* state, double* value);
+  static void Serialize(double value, std::vector<uint8_t>* bytes);
+};
+
+class CRDTP_EXPORT ContainerSerializer {
+ public:
+  ContainerSerializer(std::vector<uint8_t>* bytes, uint8_t tag);
+
+  template <typename T>
+  void AddField(span<char> field_name, const T& value) {
+    cbor::EncodeString8(
+        span<uint8_t>(reinterpret_cast<const uint8_t*>(field_name.data()),
+                      field_name.size()),
+        bytes_);
+    ProtocolTypeTraits<T>::Serialize(value, bytes_);
+  }
+  template <typename T>
+  void AddField(span<char> field_name, const detail::ValueMaybe<T>& value) {
+    if (!value.has_value()) {
+      return;
+    }
+    AddField(field_name, value.value());
+  }
+
+  template <typename T>
+  void AddField(span<char> field_name, const detail::PtrMaybe<T>& value) {
+    if (!value.has_value()) {
+      return;
+    }
+    AddField(field_name, value.value());
+  }
+
+  void EncodeStop();
+
+ private:
+  std::vector<uint8_t>* const bytes_;
+  cbor::EnvelopeEncoder envelope_;
+};
+
+class CRDTP_EXPORT ObjectSerializer {
+ public:
+  ObjectSerializer();
+  ~ObjectSerializer();
+
+  template <typename T>
+  void AddField(span<char> name, const T& field) {
+    serializer_.AddField(name, field);
+  }
+  std::unique_ptr<Serializable> Finish();
+
+ private:
+  std::vector<uint8_t> owned_bytes_;
+  ContainerSerializer serializer_;
+};
+
+class CRDTP_EXPORT DeserializerDescriptor {
+ public:
+  struct CRDTP_EXPORT Field {
+    span<char> name;
+    bool is_optional;
+    bool (*deserializer)(DeserializerState* state, void* obj);
+  };
+
+  DeserializerDescriptor(const Field* fields, size_t field_count);
+
+  bool Deserialize(DeserializerState* state, void* obj) const;
+
+ private:
+  bool DeserializeField(DeserializerState* state,
+                        span<char> name,
+                        int* seen_mandatory_fields,
+                        void* obj) const;
+
+  const Field* const fields_;
+  const size_t field_count_;
+  const int mandatory_field_mask_;
+};
+
+template <typename T>
+struct ProtocolTypeTraits<std::vector<T>> {
+  static bool Deserialize(DeserializerState* state, std::vector<T>* value) {
+    auto* tokenizer = state->tokenizer();
+    if (tokenizer->TokenTag() == cbor::CBORTokenTag::ENVELOPE)
+      tokenizer->EnterEnvelope();
+    if (tokenizer->TokenTag() != cbor::CBORTokenTag::ARRAY_START) {
+      state->RegisterError(Error::CBOR_ARRAY_START_EXPECTED);
+      return false;
+    }
+    assert(value->empty());
+    tokenizer->Next();
+    for (; tokenizer->TokenTag() != cbor::CBORTokenTag::STOP;
+         tokenizer->Next()) {
+      value->emplace_back();
+      if (!ProtocolTypeTraits<T>::Deserialize(state, &value->back()))
+        return false;
+    }
+    return true;
+  }
+
+  static void Serialize(const std::vector<T>& value,
+                        std::vector<uint8_t>* bytes) {
+    ContainerSerializer container_serializer(
+        bytes, cbor::EncodeIndefiniteLengthArrayStart());
+    for (const auto& item : value)
+      ProtocolTypeTraits<T>::Serialize(item, bytes);
+    container_serializer.EncodeStop();
+  }
+};
+
+template <typename T>
+struct ProtocolTypeTraits<std::unique_ptr<std::vector<T>>> {
+  static bool Deserialize(DeserializerState* state,
+                          std::unique_ptr<std::vector<T>>* value) {
+    auto res = std::make_unique<std::vector<T>>();
+    if (!ProtocolTypeTraits<std::vector<T>>::Deserialize(state, res.get()))
+      return false;
+    *value = std::move(res);
+    return true;
+  }
+  static void Serialize(const std::unique_ptr<std::vector<T>>& value,
+                        std::vector<uint8_t>* bytes) {
+    ProtocolTypeTraits<std::vector<T>>::Serialize(*value, bytes);
+  }
+};
+
+class CRDTP_EXPORT DeferredMessage : public Serializable {
+ public:
+  static std::unique_ptr<DeferredMessage> FromSerializable(
+      std::unique_ptr<Serializable> serializeable);
+  static std::unique_ptr<DeferredMessage> FromSpan(span<uint8_t> bytes);
+
+  ~DeferredMessage() override = default;
+  virtual DeserializerState MakeDeserializer() const = 0;
+
+ protected:
+  DeferredMessage() = default;
+};
+
+template <>
+struct CRDTP_EXPORT ProtocolTypeTraits<std::unique_ptr<DeferredMessage>> {
+  static bool Deserialize(DeserializerState* state,
+                          std::unique_ptr<DeferredMessage>* value);
+  static void Serialize(const std::unique_ptr<DeferredMessage>& value,
+                        std::vector<uint8_t>* bytes);
+};
+
+template <typename T>
+struct ProtocolTypeTraits<detail::ValueMaybe<T>> {
+  static bool Deserialize(DeserializerState* state,
+                          detail::ValueMaybe<T>* value) {
+    T res;
+    if (!ProtocolTypeTraits<T>::Deserialize(state, &res))
+      return false;
+    *value = std::move(res);
+    return true;
+  }
+
+  static void Serialize(const detail::ValueMaybe<T>& value,
+                        std::vector<uint8_t>* bytes) {
+    ProtocolTypeTraits<T>::Serialize(value.value(), bytes);
+  }
+};
+
+template <typename T>
+struct ProtocolTypeTraits<detail::PtrMaybe<T>> {
+  static bool Deserialize(DeserializerState* state,
+                          detail::PtrMaybe<T>* value) {
+    std::unique_ptr<T> res;
+    if (!ProtocolTypeTraits<std::unique_ptr<T>>::Deserialize(state, &res))
+      return false;
+    *value = std::move(res);
+    return true;
+  }
+
+  static void Serialize(const detail::PtrMaybe<T>& value,
+                        std::vector<uint8_t>* bytes) {
+    ProtocolTypeTraits<T>::Serialize(value.value(), bytes);
+  }
+};
+
+template <typename T>
+class DeserializableProtocolObject {
+ public:
+  static StatusOr<std::unique_ptr<T>> ReadFrom(
+      const DeferredMessage& deferred_message) {
+    auto state = deferred_message.MakeDeserializer();
+    if (auto res = Deserialize(&state))
+      return StatusOr<std::unique_ptr<T>>(std::move(res));
+    return StatusOr<std::unique_ptr<T>>(state.status());
+  }
+
+  static StatusOr<std::unique_ptr<T>> ReadFrom(std::vector<uint8_t> bytes) {
+    auto state = DeserializerState(std::move(bytes));
+    if (auto res = Deserialize(&state))
+      return StatusOr<std::unique_ptr<T>>(std::move(res));
+    return StatusOr<std::unique_ptr<T>>(state.status());
+  }
+
+  // Short-hand for legacy clients. This would swallow any errors, consider
+  // using ReadFrom.
+  static std::unique_ptr<T> FromBinary(const uint8_t* bytes, size_t size) {
+    std::unique_ptr<T> value(new T());
+    auto deserializer = DeferredMessage::FromSpan(span<uint8_t>(bytes, size))
+                            ->MakeDeserializer();
+    std::ignore = Deserialize(&deserializer, value.get());
+    return value;
+  }
+
+  [[nodiscard]] static bool Deserialize(DeserializerState* state, T* value) {
+    return T::deserializer_descriptor().Deserialize(state, value);
+  }
+
+ protected:
+  // This is for the sake of the macros used by derived classes thay may be in
+  // a different namespace;
+  using ProtocolType = T;
+  using DeserializerDescriptorType = DeserializerDescriptor;
+  template <typename U>
+  using DeserializableBase = DeserializableProtocolObject<U>;
+
+  DeserializableProtocolObject() = default;
+  ~DeserializableProtocolObject() = default;
+
+ private:
+  friend struct ProtocolTypeTraits<std::unique_ptr<T>>;
+
+  static std::unique_ptr<T> Deserialize(DeserializerState* state) {
+    std::unique_ptr<T> value(new T());
+    if (Deserialize(state, value.get()))
+      return value;
+    return nullptr;
+  }
+};
+
+template <typename T>
+class ProtocolObject : public Serializable,
+                       public DeserializableProtocolObject<T> {
+ public:
+  std::unique_ptr<T> Clone() const {
+    std::vector<uint8_t> serialized;
+    AppendSerialized(&serialized);
+    return T::ReadFrom(std::move(serialized)).value();
+  }
+
+ protected:
+  using ProtocolType = T;
+
+  ProtocolObject() = default;
+};
+
+template <typename T>
+struct ProtocolTypeTraits<
+    T,
+    typename std::enable_if<
+        std::is_base_of<ProtocolObject<T>, T>::value>::type> {
+  static bool Deserialize(DeserializerState* state, T* value) {
+    return T::Deserialize(state, value);
+  }
+
+  static void Serialize(const T& value, std::vector<uint8_t>* bytes) {
+    value.AppendSerialized(bytes);
+  }
+};
+
+template <typename T>
+struct ProtocolTypeTraits<
+    std::unique_ptr<T>,
+    typename std::enable_if<
+        std::is_base_of<ProtocolObject<T>, T>::value>::type> {
+  static bool Deserialize(DeserializerState* state, std::unique_ptr<T>* value) {
+    std::unique_ptr<T> res = T::Deserialize(state);
+    if (!res)
+      return false;
+    *value = std::move(res);
+    return true;
+  }
+
+  static void Serialize(const std::unique_ptr<T>& value,
+                        std::vector<uint8_t>* bytes) {
+    ProtocolTypeTraits<T>::Serialize(*value, bytes);
+  }
+};
+
+template <typename T, typename F>
+bool ConvertProtocolValue(const F& from, T* to) {
+  std::vector<uint8_t> bytes;
+  ProtocolTypeTraits<F>::Serialize(from, &bytes);
+  auto deserializer =
+      DeferredMessage::FromSpan(span<uint8_t>(bytes.data(), bytes.size()))
+          ->MakeDeserializer();
+  return ProtocolTypeTraits<T>::Deserialize(&deserializer, to);
+}
+
+#define DECLARE_DESERIALIZATION_SUPPORT()  \
+  friend DeserializableBase<ProtocolType>; \
+  static const DeserializerDescriptorType& deserializer_descriptor()
+
+#define DECLARE_SERIALIZATION_SUPPORT()                              \
+ public:                                                             \
+  void AppendSerialized(std::vector<uint8_t>* bytes) const override; \
+                                                                     \
+ private:                                                            \
+  friend DeserializableBase<ProtocolType>;                           \
+  static const DeserializerDescriptorType& deserializer_descriptor()
+
+#define CRDTP_DESERIALIZE_FILED_IMPL(name, field, is_optional)     \
+  {                                                                \
+    MakeSpan(name), is_optional,                                   \
+        [](DeserializerState* __state, void* __obj) -> bool {      \
+          return ProtocolTypeTraits<decltype(field)>::Deserialize( \
+              __state, &static_cast<ProtocolType*>(__obj)->field); \
+        }                                                          \
+  }
+
+// clang-format off
+#define CRDTP_BEGIN_DESERIALIZER(type)                                      \
+  const type::DeserializerDescriptorType& type::deserializer_descriptor() { \
+    using namespace crdtp;                                                  \
+    static const DeserializerDescriptorType::Field fields[] = {
+
+#define CRDTP_END_DESERIALIZER()                    \
+    };                                              \
+    static const DeserializerDescriptorType s_desc( \
+        fields, sizeof fields / sizeof fields[0]);  \
+    return s_desc;                                  \
+  }
+
+#define CRDTP_DESERIALIZE_FIELD(name, field) \
+  CRDTP_DESERIALIZE_FILED_IMPL(name, field, false)
+#define CRDTP_DESERIALIZE_FIELD_OPT(name, field) \
+  CRDTP_DESERIALIZE_FILED_IMPL(name, field, true)
+
+#define CRDTP_BEGIN_SERIALIZER(type)                               \
+  void type::AppendSerialized(std::vector<uint8_t>* bytes) const { \
+    using namespace crdtp;                                         \
+    ContainerSerializer __serializer(bytes,                        \
+                                     cbor::EncodeIndefiniteLengthMapStart());
+
+#define CRDTP_SERIALIZE_FIELD(name, field) \
+    __serializer.AddField(MakeSpan(name), field)
+
+#define CRDTP_END_SERIALIZER() \
+    __serializer.EncodeStop();   \
+  } class __cddtp_dummy_name
+// clang-format on
+
+}  // namespace crdtp
+
+#endif  // CRDTP_PROTOCOL_CORE_H_
diff --git a/tools/inspector_protocol/crdtp/protocol_core_test.cc b/tools/inspector_protocol/crdtp/protocol_core_test.cc
new file mode 100644
index 00000000000000..2d9246b4b85998
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/protocol_core_test.cc
@@ -0,0 +1,476 @@
+// Copyright 2020 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "protocol_core.h"
+
+#include <memory>
+
+#include "cbor.h"
+#include "maybe.h"
+#include "status_test_support.h"
+#include "test_platform.h"
+#include "test_string_traits.h"
+
+namespace crdtp {
+
+namespace {
+using ::testing::Eq;
+
+template <typename TResult, typename TArg>
+std::unique_ptr<TResult> RoundtripToType(const TArg& obj) {
+  std::vector<uint8_t> bytes;
+  obj.AppendSerialized(&bytes);
+
+  StatusOr<std::unique_ptr<TResult>> result =
+      TResult::ReadFrom(std::move(bytes));
+  return std::move(result).value();
+}
+
+template <typename T>
+std::unique_ptr<T> Roundtrip(const T& obj) {
+  return RoundtripToType<T, T>(obj);
+}
+
+// These TestTypeFOO classes below would normally be generated
+// by the protocol generator.
+
+class TestTypeBasic : public ProtocolObject<TestTypeBasic> {
+ public:
+  TestTypeBasic() = default;
+
+  const std::string& GetValue() const { return value_; }
+  void SetValue(std::string value) { value_ = std::move(value); }
+
+ private:
+  DECLARE_SERIALIZATION_SUPPORT();
+
+  std::string value_;
+};
+
+// clang-format off
+CRDTP_BEGIN_DESERIALIZER(TestTypeBasic)
+  CRDTP_DESERIALIZE_FIELD("value", value_)
+CRDTP_END_DESERIALIZER()
+
+CRDTP_BEGIN_SERIALIZER(TestTypeBasic)
+  CRDTP_SERIALIZE_FIELD("value", value_);
+CRDTP_END_SERIALIZER();
+// clang-format on
+
+TEST(ProtocolCoreTest, Basic) {
+  TestTypeBasic obj1;
+  obj1.SetValue("foo");
+
+  auto obj2 = Roundtrip(obj1);
+  ASSERT_THAT(obj2, Not(testing::IsNull()));
+  EXPECT_THAT(obj2->GetValue(), Eq("foo"));
+}
+
+TEST(ProtocolCoreTest, FailedToDeserializeTestTypeBasic) {
+  std::vector<uint8_t> garbage = {'g', 'a', 'r', 'b', 'a', 'g', 'e'};
+  StatusOr<std::unique_ptr<TestTypeBasic>> result =
+      TestTypeBasic::ReadFrom(std::move(garbage));
+  EXPECT_THAT(result.status(), StatusIs(Error::CBOR_INVALID_STRING8, 0));
+}
+
+class TestTypeBasicDouble : public ProtocolObject<TestTypeBasicDouble> {
+ public:
+  TestTypeBasicDouble() = default;
+
+  double GetValue() const { return value_; }
+  void SetValue(double value) { value_ = value; }
+
+ private:
+  DECLARE_SERIALIZATION_SUPPORT();
+
+  double value_;
+};
+
+// clang-format off
+CRDTP_BEGIN_DESERIALIZER(TestTypeBasicDouble)
+  CRDTP_DESERIALIZE_FIELD("value", value_)
+CRDTP_END_DESERIALIZER()
+
+CRDTP_BEGIN_SERIALIZER(TestTypeBasicDouble)
+  CRDTP_SERIALIZE_FIELD("value", value_);
+CRDTP_END_SERIALIZER();
+// clang-format on
+
+TEST(TestBasicDouble, ParserAllowsAllowsDoubleEncodedAsInt) {
+  // We allow double's encoded as INT32, because this is what a roundtrip via
+  // JSON would produce.
+  std::vector<uint8_t> encoded;
+  crdtp::cbor::EnvelopeEncoder envelope;
+  envelope.EncodeStart(&encoded);
+  encoded.push_back(crdtp::cbor::EncodeIndefiniteLengthMapStart());
+  crdtp::cbor::EncodeString8(crdtp::SpanFrom("value"), &encoded);
+  crdtp::cbor::EncodeInt32(
+      42, &encoded);  // It's a double field, but we encode an int.
+  encoded.push_back(crdtp::cbor::EncodeStop());
+  envelope.EncodeStop(&encoded);
+  auto obj = TestTypeBasicDouble::ReadFrom(encoded).value();
+  ASSERT_THAT(obj, Not(testing::IsNull()));
+  EXPECT_THAT(obj->GetValue(), Eq(42));
+}
+
+class TestTypeComposite : public ProtocolObject<TestTypeComposite> {
+ public:
+  bool GetBoolField() const { return bool_field_; }
+  void SetBoolField(bool value) { bool_field_ = value; }
+
+  int GetIntField() const { return int_field_; }
+  void SetIntField(int value) { int_field_ = value; }
+
+  double GetDoubleField() const { return double_field_; }
+  void SetDoubleField(double value) { double_field_ = value; }
+
+  const std::string& GetStrField() const { return str_field_; }
+  void SetStrField(std::string value) { str_field_ = std::move(value); }
+
+  const TestTypeBasic* GetTestTypeBasicField() {
+    return test_type1_field_.get();
+  }
+  void SetTestTypeBasicField(std::unique_ptr<TestTypeBasic> value) {
+    test_type1_field_ = std::move(value);
+  }
+
+ private:
+  DECLARE_SERIALIZATION_SUPPORT();
+
+  bool bool_field_ = false;
+  int int_field_ = 0;
+  double double_field_ = 0.0;
+  std::string str_field_;
+  std::unique_ptr<TestTypeBasic> test_type1_field_;
+};
+
+// clang-format off
+CRDTP_BEGIN_DESERIALIZER(TestTypeComposite)
+  CRDTP_DESERIALIZE_FIELD("bool_field", bool_field_),
+  CRDTP_DESERIALIZE_FIELD("double_field", double_field_),
+  CRDTP_DESERIALIZE_FIELD("int_field", int_field_),
+  CRDTP_DESERIALIZE_FIELD("str_field", str_field_),
+  CRDTP_DESERIALIZE_FIELD("test_type1_field", test_type1_field_),
+CRDTP_END_DESERIALIZER()
+
+CRDTP_BEGIN_SERIALIZER(TestTypeComposite)
+  CRDTP_SERIALIZE_FIELD("bool_field", bool_field_),
+  CRDTP_SERIALIZE_FIELD("double_field", double_field_),
+  CRDTP_SERIALIZE_FIELD("int_field", int_field_),
+  CRDTP_SERIALIZE_FIELD("str_field", str_field_),
+  CRDTP_SERIALIZE_FIELD("test_type1_field", test_type1_field_),
+CRDTP_END_SERIALIZER();
+// clang-format on
+
+TEST(ProtocolCoreTest, Composite) {
+  TestTypeComposite obj1;
+  obj1.SetBoolField(true);
+  obj1.SetIntField(42);
+  obj1.SetDoubleField(2.718281828);
+  obj1.SetStrField("bar");
+  auto val1 = std::make_unique<TestTypeBasic>();
+  val1->SetValue("bazzzz");
+  obj1.SetTestTypeBasicField(std::move(val1));
+
+  auto obj2 = Roundtrip(obj1);
+  ASSERT_THAT(obj2, Not(testing::IsNull()));
+  EXPECT_THAT(obj2->GetBoolField(), Eq(true));
+  EXPECT_THAT(obj2->GetIntField(), Eq(42));
+  EXPECT_THAT(obj2->GetDoubleField(), Eq(2.718281828));
+  EXPECT_THAT(obj2->GetStrField(), Eq("bar"));
+  EXPECT_THAT(obj2->GetTestTypeBasicField()->GetValue(), Eq("bazzzz"));
+}
+
+class CompositeParsingTest : public testing::Test {
+ public:
+  CompositeParsingTest() {
+    TestTypeComposite top;
+    top.SetIntField(42);
+    top.SetBoolField(true);
+    top.SetIntField(42);
+    top.SetDoubleField(2.718281828);
+    top.SetStrField("junk");
+    auto child = std::make_unique<TestTypeBasic>();
+    child->SetValue("child_value");
+    top.SetTestTypeBasicField(std::move(child));
+
+    // Let's establish that |serialized_| is a properly serialized
+    // representation of |top|, by checking that it deserializes ok.
+    top.AppendSerialized(&serialized_);
+    TestTypeComposite::ReadFrom(serialized_).value();
+  }
+
+ protected:
+  std::vector<uint8_t> serialized_;
+};
+
+TEST_F(CompositeParsingTest, DecodingFailure_CBORTokenizer) {
+  // Mutates |serialized_| so that it won't parse correctly. In this case,
+  // we're changing a string value so that it's invalid, making CBORTokenizer
+  // unhappy.
+  size_t position =
+      std::string(reinterpret_cast<const char*>(serialized_.data()),
+                  serialized_.size())
+          .find("child_value");
+  EXPECT_GT(position, 0ul);
+  // We override the byte just before so that it's still a string
+  // (3 << 5), but the length is encoded in the bytes that follows.
+  // So, we override that with 0xff (255), which exceeds the length
+  // of the message and thereby makes the string8 invalid.
+  --position;
+  serialized_[position] = 3 << 5 |   // major type: STRING
+                          25;        // length in encoded in byte that follows.
+  serialized_[position + 1] = 0xff;  // length
+  auto result = TestTypeComposite::ReadFrom(serialized_);
+
+  EXPECT_THAT(result.status(), StatusIs(Error::CBOR_INVALID_STRING8, position));
+}
+
+TEST_F(CompositeParsingTest, DecodingFailure_MandatoryFieldMissingShallow) {
+  // We're changing the string key "int_field" to something else ("lnt_field"),
+  // so that the mandatory field value won't be found. Unknown fields are
+  // ignored for compatibility, so that's why this simple technique works here.
+  size_t position =
+      std::string(reinterpret_cast<const char*>(serialized_.data()),
+                  serialized_.size())
+          .find("int_field");
+  serialized_[position] = 'l';  // Change 'i' to 'l'.
+  // serialized_.size() - 1 is the STOP character for the entire message,
+  size_t expected_error_pos = serialized_.size() - 1;
+  auto result = TestTypeComposite::ReadFrom(serialized_);
+  EXPECT_THAT(result.status(), StatusIs(Error::BINDINGS_MANDATORY_FIELD_MISSING,
+                                        expected_error_pos));
+}
+
+TEST_F(CompositeParsingTest, DecodingFailure_MandatoryFieldMissingNested) {
+  // We're changing the string key "value" to something else ("falue"), so that
+  // the mandatory field value in TestTypeBasic in the child won't be found.
+  size_t position =
+      std::string(reinterpret_cast<const char*>(serialized_.data()),
+                  serialized_.size())
+          .find("value");
+  serialized_[position] = 'f';  // Change 'v' to 'f'.
+  // serialized_.size() - 1 is the STOP character for the enclosing message,
+  // and serialized_.size() - 2 is the STOP character for TestTypeBasic.
+  size_t expected_error_pos = serialized_.size() - 2;
+  auto result = TestTypeComposite::ReadFrom(serialized_);
+  EXPECT_THAT(result.status(), StatusIs(Error::BINDINGS_MANDATORY_FIELD_MISSING,
+                                        expected_error_pos));
+}
+
+TEST_F(CompositeParsingTest, DecodingFailure_BoolValueExpected) {
+  // We're changing the bool value (true) to null; we do this by looking
+  // for bool_field, and searching from there for TRUE; both TRUE and null
+  // are just one byte in the serialized buffer, so this swap is convenient.
+  std::string serialized_view(reinterpret_cast<const char*>(serialized_.data()),
+                              serialized_.size());
+  size_t position = serialized_view.find("bool_field");
+  for (; position < serialized_.size(); ++position) {
+    if (serialized_[position] == crdtp::cbor::EncodeTrue()) {
+      serialized_[position] = crdtp::cbor::EncodeNull();
+      break;
+    }
+  }
+  auto result = TestTypeComposite::ReadFrom(serialized_);
+  EXPECT_THAT(result.status(),
+              StatusIs(Error::BINDINGS_BOOL_VALUE_EXPECTED, position));
+}
+
+class TestTypeArrays : public ProtocolObject<TestTypeArrays> {
+ public:
+  const std::vector<int>* GetIntArray() const { return &int_array_; }
+  void SetIntArray(std::vector<int> value) { int_array_ = std::move(value); }
+
+  const std::vector<double>* GetDoubleArray() const { return &double_array_; }
+  void SetDoubleArray(std::vector<double> value) {
+    double_array_ = std::move(value);
+  }
+
+  const std::vector<std::string>* GetStrArray() const { return &str_array_; }
+  void SetStrArray(std::vector<std::string> value) {
+    str_array_ = std::move(value);
+  }
+
+  const std::vector<std::unique_ptr<TestTypeBasic>>* GetTestTypeBasicArray()
+      const {
+    return &test_type_basic_array_;
+  }
+
+  void SetTestTypeBasicArray(
+      std::vector<std::unique_ptr<TestTypeBasic>> value) {
+    test_type_basic_array_ = std::move(value);
+  }
+
+ private:
+  DECLARE_SERIALIZATION_SUPPORT();
+
+  std::vector<int> int_array_;
+  std::vector<double> double_array_;
+  std::vector<std::string> str_array_;
+  std::vector<std::unique_ptr<TestTypeBasic>> test_type_basic_array_;
+};
+
+// clang-format off
+CRDTP_BEGIN_DESERIALIZER(TestTypeArrays)
+  CRDTP_DESERIALIZE_FIELD("int_array", int_array_),
+  CRDTP_DESERIALIZE_FIELD("str_array", str_array_),
+  CRDTP_DESERIALIZE_FIELD("test_type_basic_array", test_type_basic_array_),
+CRDTP_END_DESERIALIZER()
+
+CRDTP_BEGIN_SERIALIZER(TestTypeArrays)
+  CRDTP_SERIALIZE_FIELD("int_array", int_array_),
+  CRDTP_SERIALIZE_FIELD("str_array", str_array_),
+  CRDTP_SERIALIZE_FIELD("test_type_basic_array", test_type_basic_array_),
+CRDTP_END_SERIALIZER();
+// clang-format on
+
+TEST_F(CompositeParsingTest, Arrays) {
+  TestTypeArrays obj1;
+  obj1.SetIntArray(std::vector<int>{1, 3, 5, 7});
+  std::vector<std::string> strs;
+  strs.emplace_back("foo");
+  strs.emplace_back(std::string("bar"));
+  obj1.SetStrArray(std::move(strs));
+  auto val1 = std::make_unique<TestTypeBasic>();
+  val1->SetValue("bazzzz");
+  std::vector<std::unique_ptr<TestTypeBasic>> vec1;
+  vec1.emplace_back(std::move(val1));
+  obj1.SetTestTypeBasicArray(std::move(vec1));
+
+  auto obj2 = Roundtrip(obj1);
+  ASSERT_THAT(obj2, Not(testing::IsNull()));
+  EXPECT_THAT(*obj2->GetIntArray(), testing::ElementsAre(1, 3, 5, 7));
+  EXPECT_THAT(*obj2->GetStrArray(), testing::ElementsAre("foo", "bar"));
+  EXPECT_THAT(obj2->GetDoubleArray()->size(), Eq(0ul));
+  EXPECT_THAT(obj2->GetTestTypeBasicArray()->size(), Eq(1ul));
+  EXPECT_THAT(obj2->GetTestTypeBasicArray()->front()->GetValue(), Eq("bazzzz"));
+}
+
+class TestTypeOptional : public ProtocolObject<TestTypeOptional> {
+ public:
+  TestTypeOptional() = default;
+
+  bool HasIntField() const { return int_field_.has_value(); }
+  int GetIntField() const { return int_field_.value(); }
+  void SetIntField(int value) { int_field_ = value; }
+
+  bool HasStrField() { return str_field_.has_value(); }
+  const std::string& GetStrField() const { return str_field_.value(); }
+  void SetStrField(std::string value) { str_field_ = std::move(value); }
+
+  bool HasTestTypeBasicField() { return test_type_basic_field_.has_value(); }
+  const TestTypeBasic* GetTestTypeBasicField() const {
+    return test_type_basic_field_.has_value() ? &test_type_basic_field_.value()
+                                              : nullptr;
+  }
+  void SetTestTypeBasicField(std::unique_ptr<TestTypeBasic> value) {
+    test_type_basic_field_ = std::move(value);
+  }
+
+ private:
+  DECLARE_SERIALIZATION_SUPPORT();
+
+  Maybe<int> int_field_;
+  Maybe<std::string> str_field_;
+  Maybe<TestTypeBasic> test_type_basic_field_;
+};
+
+// clang-format off
+CRDTP_BEGIN_DESERIALIZER(TestTypeOptional)
+  CRDTP_DESERIALIZE_FIELD_OPT("int_field", int_field_),
+  CRDTP_DESERIALIZE_FIELD_OPT("str_field", str_field_),
+  CRDTP_DESERIALIZE_FIELD_OPT("test_type_basic_field", test_type_basic_field_),
+CRDTP_END_DESERIALIZER()
+
+CRDTP_BEGIN_SERIALIZER(TestTypeOptional)
+  CRDTP_SERIALIZE_FIELD("int_field", int_field_),
+  CRDTP_SERIALIZE_FIELD("str_field", str_field_),
+  CRDTP_SERIALIZE_FIELD("test_type_basic_field", test_type_basic_field_),
+CRDTP_END_SERIALIZER();
+// clang-format on
+
+TEST(ProtocolCoreTest, OptionalAbsent) {
+  TestTypeOptional obj1;
+  auto obj2 = Roundtrip(obj1);
+  ASSERT_THAT(obj2, Not(testing::IsNull()));
+
+  EXPECT_THAT(obj2->HasIntField(), Eq(false));
+  EXPECT_THAT(obj2->HasStrField(), Eq(false));
+  EXPECT_THAT(obj2->HasTestTypeBasicField(), Eq(false));
+}
+
+TEST(ProtocolCoreTest, OptionalPresent) {
+  TestTypeOptional obj1;
+  obj1.SetIntField(42);
+  obj1.SetStrField("foo");
+
+  auto val1 = std::make_unique<TestTypeBasic>();
+  val1->SetValue("bar");
+  obj1.SetTestTypeBasicField(std::move(val1));
+
+  auto obj2 = Roundtrip(obj1);
+  ASSERT_THAT(obj2, Not(testing::IsNull()));
+
+  EXPECT_THAT(obj2->HasIntField(), Eq(true));
+  EXPECT_THAT(obj2->GetIntField(), Eq(42));
+  EXPECT_THAT(obj2->HasStrField(), Eq(true));
+  EXPECT_THAT(obj2->GetStrField(), Eq("foo"));
+  EXPECT_THAT(obj2->HasTestTypeBasicField(), Eq(true));
+  EXPECT_THAT(obj2->GetTestTypeBasicField()->GetValue(), Eq("bar"));
+}
+
+class TestTypeLazy : public ProtocolObject<TestTypeLazy> {
+ public:
+  TestTypeLazy() = default;
+
+  const std::string& GetStrField() const { return str_field_; }
+  void SetStrField(std::string value) { str_field_ = std::move(value); }
+
+  const DeferredMessage* deferred_test_type1_field() const {
+    return test_type1_field_.get();
+  }
+
+ private:
+  DECLARE_SERIALIZATION_SUPPORT();
+
+  std::string str_field_;
+  std::unique_ptr<DeferredMessage> test_type1_field_;
+};
+
+// clang-format off
+CRDTP_BEGIN_DESERIALIZER(TestTypeLazy)
+  CRDTP_DESERIALIZE_FIELD("str_field", str_field_),
+  CRDTP_DESERIALIZE_FIELD_OPT("test_type1_field", test_type1_field_),
+CRDTP_END_DESERIALIZER()
+
+CRDTP_BEGIN_SERIALIZER(TestTypeLazy)
+  CRDTP_SERIALIZE_FIELD("str_field", str_field_),
+  CRDTP_SERIALIZE_FIELD("test_type1_field", test_type1_field_),
+CRDTP_END_SERIALIZER();
+// clang-format on
+
+TEST(ProtocolCoreTest, TestDeferredMessage) {
+  TestTypeComposite obj1;
+  obj1.SetStrField("bar");
+  auto val1 = std::make_unique<TestTypeBasic>();
+  val1->SetValue("bazzzz");
+  obj1.SetTestTypeBasicField(std::move(val1));
+
+  auto obj2 = RoundtripToType<TestTypeLazy>(obj1);
+  EXPECT_THAT(obj2->GetStrField(), Eq("bar"));
+
+  TestTypeBasic basic_val;
+  auto deserializer = obj2->deferred_test_type1_field()->MakeDeserializer();
+  EXPECT_THAT(TestTypeBasic::Deserialize(&deserializer, &basic_val), Eq(true));
+  EXPECT_THAT(basic_val.GetValue(), Eq("bazzzz"));
+
+  StatusOr<std::unique_ptr<TestTypeBasic>> maybe_parsed =
+      TestTypeBasic::ReadFrom(*obj2->deferred_test_type1_field());
+  ASSERT_THAT(maybe_parsed.status(), StatusIsOk());
+  ASSERT_THAT((*maybe_parsed), Not(testing::IsNull()));
+  ASSERT_EQ((*maybe_parsed)->GetValue(), "bazzzz");
+}
+
+}  // namespace
+}  // namespace crdtp
diff --git a/tools/inspector_protocol/crdtp/serializable.cc b/tools/inspector_protocol/crdtp/serializable.cc
new file mode 100644
index 00000000000000..e0bc6ffb62a9c5
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/serializable.cc
@@ -0,0 +1,39 @@
+// Copyright 2019 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "serializable.h"
+
+#include <utility>
+
+namespace crdtp {
+// =============================================================================
+// Serializable - An object to be emitted as a sequence of bytes.
+// =============================================================================
+
+std::vector<uint8_t> Serializable::Serialize() const {
+  std::vector<uint8_t> out;
+  AppendSerialized(&out);
+  return out;
+}
+
+namespace {
+class PreSerialized : public Serializable {
+ public:
+  explicit PreSerialized(std::vector<uint8_t> bytes)
+      : bytes_(std::move(bytes)) {}
+
+  void AppendSerialized(std::vector<uint8_t>* out) const override {
+    out->insert(out->end(), bytes_.begin(), bytes_.end());
+  }
+
+ private:
+  std::vector<uint8_t> bytes_;
+};
+}  // namespace
+
+// static
+std::unique_ptr<Serializable> Serializable::From(std::vector<uint8_t> bytes) {
+  return std::make_unique<PreSerialized>(std::move(bytes));
+}
+}  // namespace crdtp
diff --git a/tools/inspector_protocol/crdtp/serializable.h b/tools/inspector_protocol/crdtp/serializable.h
new file mode 100644
index 00000000000000..a5e2881e17ea50
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/serializable.h
@@ -0,0 +1,32 @@
+// Copyright 2019 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CRDTP_SERIALIZABLE_H_
+#define CRDTP_SERIALIZABLE_H_
+
+#include <cstdint>
+#include <memory>
+#include <vector>
+#include "export.h"
+
+namespace crdtp {
+// =============================================================================
+// Serializable - An object to be emitted as a sequence of bytes.
+// =============================================================================
+class CRDTP_EXPORT Serializable {
+ public:
+  // Convenience: Invokes |AppendSerialized| on an empty vector.
+  std::vector<uint8_t> Serialize() const;
+
+  virtual void AppendSerialized(std::vector<uint8_t>* out) const = 0;
+
+  virtual ~Serializable() = default;
+
+  // Wraps a vector of |bytes| into a Serializable for situations in which we
+  // eagerly serialize a structure.
+  static std::unique_ptr<Serializable> From(std::vector<uint8_t> bytes);
+};
+}  // namespace crdtp
+
+#endif  // CRDTP_SERIALIZABLE_H_
diff --git a/tools/inspector_protocol/crdtp/serializable_test.cc b/tools/inspector_protocol/crdtp/serializable_test.cc
new file mode 100644
index 00000000000000..adfd8595ad8371
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/serializable_test.cc
@@ -0,0 +1,40 @@
+// Copyright 2019 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <cstdlib>
+#include <string>
+
+#include "serializable.h"
+#include "test_platform.h"
+
+namespace crdtp {
+// =============================================================================
+// Serializable - An object to be emitted as a sequence of bytes.
+// =============================================================================
+
+namespace {
+// Tests ::Serialize (which invokes ::AppendSerialized).
+class SimpleExample : public Serializable {
+ public:
+  explicit SimpleExample(const std::vector<uint8_t>& contents)
+      : contents_(contents) {}
+
+  void AppendSerialized(std::vector<uint8_t>* out) const override {
+    out->insert(out->end(), contents_.begin(), contents_.end());
+  }
+
+ private:
+  std::vector<uint8_t> contents_;
+};
+}  // namespace
+
+TEST(SerializableTest, YieldsContents) {
+  std::vector<uint8_t> contents = {1, 2, 3};
+  SimpleExample foo(contents);
+  foo.AppendSerialized(&contents);  // Yields contents by appending.
+  EXPECT_THAT(contents, testing::ElementsAre(1, 2, 3, 1, 2, 3));
+  // Yields contents by returning.
+  EXPECT_THAT(foo.Serialize(), testing::ElementsAre(1, 2, 3));
+}
+}  // namespace crdtp
diff --git a/tools/inspector_protocol/crdtp/span.cc b/tools/inspector_protocol/crdtp/span.cc
new file mode 100644
index 00000000000000..ae7545489c43b4
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/span.cc
@@ -0,0 +1,39 @@
+// Copyright 2020 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "span.h"
+
+#include <algorithm>
+
+namespace crdtp {
+
+bool SpanLessThan(span<uint8_t> x, span<uint8_t> y) noexcept {
+  auto min_size = std::min(x.size(), y.size());
+  const int r = min_size == 0 ? 0 : memcmp(x.data(), y.data(), min_size);
+  return (r < 0) || (r == 0 && x.size() < y.size());
+}
+
+bool SpanEquals(span<uint8_t> x, span<uint8_t> y) noexcept {
+  auto len = x.size();
+  if (len != y.size())
+    return false;
+  return x.data() == y.data() || len == 0 ||
+         std::memcmp(x.data(), y.data(), len) == 0;
+}
+
+bool SpanLessThan(span<char> x, span<char> y) noexcept {
+  auto min_size = std::min(x.size(), y.size());
+  const int r = min_size == 0 ? 0 : memcmp(x.data(), y.data(), min_size);
+  return (r < 0) || (r == 0 && x.size() < y.size());
+}
+
+bool SpanEquals(span<char> x, span<char> y) noexcept {
+  auto len = x.size();
+  if (len != y.size())
+    return false;
+  return x.data() == y.data() || len == 0 ||
+         std::memcmp(x.data(), y.data(), len) == 0;
+}
+
+}  // namespace crdtp
diff --git a/tools/inspector_protocol/crdtp/span.h b/tools/inspector_protocol/crdtp/span.h
new file mode 100644
index 00000000000000..c2b5b02d9a1832
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/span.h
@@ -0,0 +1,100 @@
+// Copyright 2019 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CRDTP_SPAN_H_
+#define CRDTP_SPAN_H_
+
+#include <cstdint>
+#include <cstring>
+#include <type_traits>
+#include <string>
+
+#include "export.h"
+
+namespace crdtp {
+// =============================================================================
+// span - sequence of bytes
+// =============================================================================
+
+// This template is similar to std::span, which will be included in C++20.
+template <typename T>
+class span {
+ public:
+  using index_type = size_t;
+
+  constexpr span() : data_(nullptr), size_(0) {}
+  constexpr span(const T* data, index_type size) : data_(data), size_(size) {}
+
+  constexpr const T* data() const { return data_; }
+
+  constexpr const T* begin() const { return data_; }
+  constexpr const T* end() const { return data_ + size_; }
+
+  constexpr const T& operator[](index_type idx) const { return data_[idx]; }
+
+  constexpr span<T> subspan(index_type offset, index_type count) const {
+    return span(data_ + offset, count);
+  }
+
+  constexpr span<T> subspan(index_type offset) const {
+    return span(data_ + offset, size_ - offset);
+  }
+
+  constexpr bool empty() const { return size_ == 0; }
+
+  constexpr index_type size() const { return size_; }
+  constexpr index_type size_bytes() const { return size_ * sizeof(T); }
+
+ private:
+  const T* data_;
+  index_type size_;
+};
+
+template <size_t N>
+constexpr span<char> MakeSpan(const char (&str)[N]) {
+  return span<char>(str, N - 1);
+}
+
+template <size_t N>
+constexpr span<uint8_t> SpanFrom(const char (&str)[N]) {
+  return span<uint8_t>(reinterpret_cast<const uint8_t*>(str), N - 1);
+}
+
+constexpr inline span<uint8_t> SpanFrom(const char* str) {
+  return str ? span<uint8_t>(reinterpret_cast<const uint8_t*>(str), strlen(str))
+             : span<uint8_t>();
+}
+
+inline span<uint8_t> SpanFrom(const std::string& v) {
+  return span<uint8_t>(reinterpret_cast<const uint8_t*>(v.data()), v.size());
+}
+
+// This SpanFrom routine works for std::vector<uint8_t> and
+// std::vector<uint16_t>, but also for base::span<const uint8_t> in Chromium.
+template <typename C,
+          typename = std::enable_if_t<
+              std::is_unsigned<typename C::value_type>{} &&
+              std::is_member_function_pointer<decltype(&C::size)>{}>>
+inline span<typename C::value_type> SpanFrom(const C& v) {
+  return span<typename C::value_type>(v.data(), v.size());
+}
+
+// Less than / equality comparison functions for sorting / searching for byte
+// spans.
+CRDTP_EXPORT bool SpanLessThan(span<uint8_t> x, span<uint8_t> y) noexcept;
+CRDTP_EXPORT bool SpanEquals(span<uint8_t> x, span<uint8_t> y) noexcept;
+
+// Less than / equality comparison functions for sorting / searching for byte
+// spans.
+CRDTP_EXPORT bool SpanLessThan(span<char> x, span<char> y) noexcept;
+CRDTP_EXPORT bool SpanEquals(span<char> x, span<char> y) noexcept;
+
+struct SpanLt {
+  bool operator()(span<uint8_t> l, span<uint8_t> r) const {
+    return SpanLessThan(l, r);
+  }
+};
+}  // namespace crdtp
+
+#endif  // CRDTP_SPAN_H_
diff --git a/tools/inspector_protocol/crdtp/span_test.cc b/tools/inspector_protocol/crdtp/span_test.cc
new file mode 100644
index 00000000000000..e562f4ea6feed9
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/span_test.cc
@@ -0,0 +1,109 @@
+// Copyright 2018 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <cstdlib>
+#include <string>
+
+#include "span.h"
+#include "test_platform.h"
+
+namespace crdtp {
+// =============================================================================
+// span - sequence of bytes
+// =============================================================================
+template <typename T>
+class SpanTest : public ::testing::Test {};
+
+using TestTypes = ::testing::Types<uint8_t, uint16_t>;
+TYPED_TEST_SUITE(SpanTest, TestTypes);
+
+TYPED_TEST(SpanTest, Empty) {
+  span<TypeParam> empty;
+  EXPECT_TRUE(empty.empty());
+  EXPECT_EQ(0u, empty.size());
+  EXPECT_EQ(0u, empty.size_bytes());
+  EXPECT_EQ(empty.begin(), empty.end());
+}
+
+TYPED_TEST(SpanTest, SingleItem) {
+  TypeParam single_item = 42;
+  span<TypeParam> singular(&single_item, 1);
+  EXPECT_FALSE(singular.empty());
+  EXPECT_EQ(1u, singular.size());
+  EXPECT_EQ(sizeof(TypeParam), singular.size_bytes());
+  EXPECT_EQ(singular.begin() + 1, singular.end());
+  EXPECT_EQ(42, singular[0]);
+}
+
+TYPED_TEST(SpanTest, FiveItems) {
+  std::vector<TypeParam> test_input = {31, 32, 33, 34, 35};
+  span<TypeParam> five_items(test_input.data(), 5);
+  EXPECT_FALSE(five_items.empty());
+  EXPECT_EQ(5u, five_items.size());
+  EXPECT_EQ(sizeof(TypeParam) * 5, five_items.size_bytes());
+  EXPECT_EQ(five_items.begin() + 5, five_items.end());
+  EXPECT_EQ(31, five_items[0]);
+  EXPECT_EQ(32, five_items[1]);
+  EXPECT_EQ(33, five_items[2]);
+  EXPECT_EQ(34, five_items[3]);
+  EXPECT_EQ(35, five_items[4]);
+  span<TypeParam> three_items = five_items.subspan(2);
+  EXPECT_EQ(3u, three_items.size());
+  EXPECT_EQ(33, three_items[0]);
+  EXPECT_EQ(34, three_items[1]);
+  EXPECT_EQ(35, three_items[2]);
+  span<TypeParam> two_items = five_items.subspan(2, 2);
+  EXPECT_EQ(2u, two_items.size());
+  EXPECT_EQ(33, two_items[0]);
+  EXPECT_EQ(34, two_items[1]);
+}
+
+TEST(SpanFromTest, FromConstCharAndLiteral) {
+  // Testing this is useful because strlen(nullptr) is undefined.
+  EXPECT_EQ(nullptr, SpanFrom(nullptr).data());
+  EXPECT_EQ(0u, SpanFrom(nullptr).size());
+
+  const char* kEmpty = "";
+  EXPECT_EQ(kEmpty, reinterpret_cast<const char*>(SpanFrom(kEmpty).data()));
+  EXPECT_EQ(0u, SpanFrom(kEmpty).size());
+
+  const char* kFoo = "foo";
+  EXPECT_EQ(kFoo, reinterpret_cast<const char*>(SpanFrom(kFoo).data()));
+  EXPECT_EQ(3u, SpanFrom(kFoo).size());
+
+  EXPECT_EQ(3u, SpanFrom("foo").size());
+}
+
+TEST(SpanFromTest, FromVectorUint8AndUint16) {
+  std::vector<uint8_t> foo = {'f', 'o', 'o'};
+  span<uint8_t> foo_span = SpanFrom(foo);
+  EXPECT_EQ(foo.size(), foo_span.size());
+
+  std::vector<uint16_t> bar = {0xff, 0xef, 0xeb};
+  span<uint16_t> bar_span = SpanFrom(bar);
+  EXPECT_EQ(bar.size(), bar_span.size());
+}
+
+TEST(SpanComparisons, ByteWiseLexicographicalOrder) {
+  // Compare the empty span.
+  EXPECT_FALSE(SpanLessThan(span<uint8_t>(), span<uint8_t>()));
+  EXPECT_TRUE(SpanEquals(span<uint8_t>(), span<uint8_t>()));
+
+  // Compare message with itself.
+  std::string msg = "Hello, world";
+  EXPECT_FALSE(SpanLessThan(SpanFrom(msg), SpanFrom(msg)));
+  EXPECT_TRUE(SpanEquals(SpanFrom(msg), SpanFrom(msg)));
+
+  // Compare message and copy.
+  EXPECT_FALSE(SpanLessThan(SpanFrom(msg), SpanFrom(std::string(msg))));
+  EXPECT_TRUE(SpanEquals(SpanFrom(msg), SpanFrom(std::string(msg))));
+
+  // Compare two messages. |lesser_msg| < |msg| because of the first
+  // byte ('A' < 'H').
+  std::string lesser_msg = "A lesser message.";
+  EXPECT_TRUE(SpanLessThan(SpanFrom(lesser_msg), SpanFrom(msg)));
+  EXPECT_FALSE(SpanLessThan(SpanFrom(msg), SpanFrom(lesser_msg)));
+  EXPECT_FALSE(SpanEquals(SpanFrom(msg), SpanFrom(lesser_msg)));
+}
+}  // namespace crdtp
diff --git a/tools/inspector_protocol/crdtp/status.cc b/tools/inspector_protocol/crdtp/status.cc
new file mode 100644
index 00000000000000..41f8b5df7542cc
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/status.cc
@@ -0,0 +1,130 @@
+// Copyright 2019 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "status.h"
+
+namespace crdtp {
+// =============================================================================
+// Status and Error codes
+// =============================================================================
+
+std::string Status::Message() const {
+  switch (error) {
+    case Error::OK:
+      return "OK";
+    case Error::JSON_PARSER_UNPROCESSED_INPUT_REMAINS:
+      return "JSON: unprocessed input remains";
+    case Error::JSON_PARSER_STACK_LIMIT_EXCEEDED:
+      return "JSON: stack limit exceeded";
+    case Error::JSON_PARSER_NO_INPUT:
+      return "JSON: no input";
+    case Error::JSON_PARSER_INVALID_TOKEN:
+      return "JSON: invalid token";
+    case Error::JSON_PARSER_INVALID_NUMBER:
+      return "JSON: invalid number";
+    case Error::JSON_PARSER_INVALID_STRING:
+      return "JSON: invalid string";
+    case Error::JSON_PARSER_UNEXPECTED_ARRAY_END:
+      return "JSON: unexpected array end";
+    case Error::JSON_PARSER_COMMA_OR_ARRAY_END_EXPECTED:
+      return "JSON: comma or array end expected";
+    case Error::JSON_PARSER_STRING_LITERAL_EXPECTED:
+      return "JSON: string literal expected";
+    case Error::JSON_PARSER_COLON_EXPECTED:
+      return "JSON: colon expected";
+    case Error::JSON_PARSER_UNEXPECTED_MAP_END:
+      return "JSON: unexpected map end";
+    case Error::JSON_PARSER_COMMA_OR_MAP_END_EXPECTED:
+      return "JSON: comma or map end expected";
+    case Error::JSON_PARSER_VALUE_EXPECTED:
+      return "JSON: value expected";
+
+    case Error::CBOR_INVALID_INT32:
+      return "CBOR: invalid int32";
+    case Error::CBOR_INVALID_DOUBLE:
+      return "CBOR: invalid double";
+    case Error::CBOR_INVALID_ENVELOPE:
+      return "CBOR: invalid envelope";
+    case Error::CBOR_ENVELOPE_CONTENTS_LENGTH_MISMATCH:
+      return "CBOR: envelope contents length mismatch";
+    case Error::CBOR_MAP_OR_ARRAY_EXPECTED_IN_ENVELOPE:
+      return "CBOR: map or array expected in envelope";
+    case Error::CBOR_INVALID_STRING8:
+      return "CBOR: invalid string8";
+    case Error::CBOR_INVALID_STRING16:
+      return "CBOR: invalid string16";
+    case Error::CBOR_INVALID_BINARY:
+      return "CBOR: invalid binary";
+    case Error::CBOR_UNSUPPORTED_VALUE:
+      return "CBOR: unsupported value";
+    case Error::CBOR_UNEXPECTED_EOF_IN_ENVELOPE:
+      return "CBOR: unexpected EOF reading envelope";
+    case Error::CBOR_INVALID_START_BYTE:
+      return "CBOR: invalid start byte";
+    case Error::CBOR_UNEXPECTED_EOF_EXPECTED_VALUE:
+      return "CBOR: unexpected EOF expected value";
+    case Error::CBOR_UNEXPECTED_EOF_IN_ARRAY:
+      return "CBOR: unexpected EOF in array";
+    case Error::CBOR_UNEXPECTED_EOF_IN_MAP:
+      return "CBOR: unexpected EOF in map";
+    case Error::CBOR_INVALID_MAP_KEY:
+      return "CBOR: invalid map key";
+    case Error::CBOR_DUPLICATE_MAP_KEY:
+      return "CBOR: duplicate map key";
+    case Error::CBOR_STACK_LIMIT_EXCEEDED:
+      return "CBOR: stack limit exceeded";
+    case Error::CBOR_TRAILING_JUNK:
+      return "CBOR: trailing junk";
+    case Error::CBOR_MAP_START_EXPECTED:
+      return "CBOR: map start expected";
+    case Error::CBOR_MAP_STOP_EXPECTED:
+      return "CBOR: map stop expected";
+    case Error::CBOR_ARRAY_START_EXPECTED:
+      return "CBOR: array start expected";
+    case Error::CBOR_ENVELOPE_SIZE_LIMIT_EXCEEDED:
+      return "CBOR: envelope size limit exceeded";
+
+    case Error::MESSAGE_MUST_BE_AN_OBJECT:
+      return "Message must be an object";
+    case Error::MESSAGE_MUST_HAVE_INTEGER_ID_PROPERTY:
+      return "Message must have integer 'id' property";
+    case Error::MESSAGE_MUST_HAVE_STRING_METHOD_PROPERTY:
+      return "Message must have string 'method' property";
+    case Error::MESSAGE_MAY_HAVE_STRING_SESSION_ID_PROPERTY:
+      return "Message may have string 'sessionId' property";
+    case Error::MESSAGE_MAY_HAVE_OBJECT_PARAMS_PROPERTY:
+      return "Message may have object 'params' property";
+    case Error::MESSAGE_HAS_UNKNOWN_PROPERTY:
+      return "Message has property other than "
+             "'id', 'method', 'sessionId', 'params'";
+
+    case Error::BINDINGS_MANDATORY_FIELD_MISSING:
+      return "BINDINGS: mandatory field missing";
+    case Error::BINDINGS_BOOL_VALUE_EXPECTED:
+      return "BINDINGS: bool value expected";
+    case Error::BINDINGS_INT32_VALUE_EXPECTED:
+      return "BINDINGS: int32 value expected";
+    case Error::BINDINGS_DOUBLE_VALUE_EXPECTED:
+      return "BINDINGS: double value expected";
+    case Error::BINDINGS_STRING_VALUE_EXPECTED:
+      return "BINDINGS: string value expected";
+    case Error::BINDINGS_STRING8_VALUE_EXPECTED:
+      return "BINDINGS: string8 value expected";
+    case Error::BINDINGS_BINARY_VALUE_EXPECTED:
+      return "BINDINGS: binary value expected";
+    case Error::BINDINGS_DICTIONARY_VALUE_EXPECTED:
+      return "BINDINGS: dictionary value expected";
+    case Error::BINDINGS_INVALID_BASE64_STRING:
+      return "BINDINGS: invalid base64 string";
+  }
+  // Some compilers can't figure out that we can't get here.
+  return "INVALID ERROR CODE";
+}
+
+std::string Status::ToASCIIString() const {
+  if (ok())
+    return "OK";
+  return Message() + " at position " + std::to_string(pos);
+}
+}  // namespace crdtp
diff --git a/tools/inspector_protocol/crdtp/status.h b/tools/inspector_protocol/crdtp/status.h
new file mode 100644
index 00000000000000..5f32c040f3ec1e
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/status.h
@@ -0,0 +1,143 @@
+// Copyright 2019 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CRDTP_STATUS_H_
+#define CRDTP_STATUS_H_
+
+#include <cassert>
+#include <cstddef>
+#include <limits>
+#include <string>
+
+#include "export.h"
+
+namespace crdtp {
+// =============================================================================
+// Status and Error codes
+// =============================================================================
+
+enum class Error {
+  OK = 0,
+
+  // JSON parsing errors; checked when parsing / converting from JSON.
+  // See json.{h,cc}.
+  JSON_PARSER_UNPROCESSED_INPUT_REMAINS = 0x01,
+  JSON_PARSER_STACK_LIMIT_EXCEEDED = 0x02,
+  JSON_PARSER_NO_INPUT = 0x03,
+  JSON_PARSER_INVALID_TOKEN = 0x04,
+  JSON_PARSER_INVALID_NUMBER = 0x05,
+  JSON_PARSER_INVALID_STRING = 0x06,
+  JSON_PARSER_UNEXPECTED_ARRAY_END = 0x07,
+  JSON_PARSER_COMMA_OR_ARRAY_END_EXPECTED = 0x08,
+  JSON_PARSER_STRING_LITERAL_EXPECTED = 0x09,
+  JSON_PARSER_COLON_EXPECTED = 0x0a,
+  JSON_PARSER_UNEXPECTED_MAP_END = 0x0b,
+  JSON_PARSER_COMMA_OR_MAP_END_EXPECTED = 0x0c,
+  JSON_PARSER_VALUE_EXPECTED = 0x0d,
+
+  // CBOR parsing errors; checked when parsing / converting from CBOR.
+  CBOR_INVALID_INT32 = 0x0e,
+  CBOR_INVALID_DOUBLE = 0x0f,
+  CBOR_INVALID_ENVELOPE = 0x10,
+  CBOR_ENVELOPE_CONTENTS_LENGTH_MISMATCH = 0x11,
+  CBOR_MAP_OR_ARRAY_EXPECTED_IN_ENVELOPE = 0x12,
+  CBOR_INVALID_STRING8 = 0x13,
+  CBOR_INVALID_STRING16 = 0x14,
+  CBOR_INVALID_BINARY = 0x15,
+  CBOR_UNSUPPORTED_VALUE = 0x16,
+  CBOR_UNEXPECTED_EOF_IN_ENVELOPE = 0x17,
+  CBOR_INVALID_START_BYTE = 0x18,
+  CBOR_UNEXPECTED_EOF_EXPECTED_VALUE = 0x19,
+  CBOR_UNEXPECTED_EOF_IN_ARRAY = 0x1a,
+  CBOR_UNEXPECTED_EOF_IN_MAP = 0x1b,
+  CBOR_INVALID_MAP_KEY = 0x1c,
+  CBOR_DUPLICATE_MAP_KEY = 0x1d,
+  CBOR_STACK_LIMIT_EXCEEDED = 0x1e,
+  CBOR_TRAILING_JUNK = 0x1f,
+  CBOR_MAP_START_EXPECTED = 0x20,
+  CBOR_MAP_STOP_EXPECTED = 0x21,
+  CBOR_ARRAY_START_EXPECTED = 0x22,
+  CBOR_ENVELOPE_SIZE_LIMIT_EXCEEDED = 0x23,
+
+  // Message errors are constraints we place on protocol messages coming
+  // from a protocol client; these are checked in crdtp::Dispatchable
+  // (see dispatch.h) as it performs a shallow parse.
+  MESSAGE_MUST_BE_AN_OBJECT = 0x24,
+  MESSAGE_MUST_HAVE_INTEGER_ID_PROPERTY = 0x25,
+  MESSAGE_MUST_HAVE_STRING_METHOD_PROPERTY = 0x26,
+  MESSAGE_MAY_HAVE_STRING_SESSION_ID_PROPERTY = 0x27,
+  MESSAGE_MAY_HAVE_OBJECT_PARAMS_PROPERTY = 0x28,
+  MESSAGE_HAS_UNKNOWN_PROPERTY = 0x29,
+
+  BINDINGS_MANDATORY_FIELD_MISSING = 0x30,
+  BINDINGS_BOOL_VALUE_EXPECTED = 0x31,
+  BINDINGS_INT32_VALUE_EXPECTED = 0x32,
+  BINDINGS_DOUBLE_VALUE_EXPECTED = 0x33,
+  BINDINGS_STRING_VALUE_EXPECTED = 0x34,
+  BINDINGS_STRING8_VALUE_EXPECTED = 0x35,
+  BINDINGS_BINARY_VALUE_EXPECTED = 0x36,
+  BINDINGS_DICTIONARY_VALUE_EXPECTED = 0x37,
+  BINDINGS_INVALID_BASE64_STRING = 0x38,
+};
+
+// A status value with position that can be copied. The default status
+// is OK. Usually, error status values should come with a valid position.
+struct CRDTP_EXPORT Status {
+  static constexpr size_t npos() { return std::numeric_limits<size_t>::max(); }
+
+  bool ok() const { return error == Error::OK; }
+
+  Error error = Error::OK;
+  size_t pos = npos();
+  Status(Error error, size_t pos) : error(error), pos(pos) {}
+  Status() = default;
+
+  bool IsMessageError() const {
+    return error >= Error::MESSAGE_MUST_BE_AN_OBJECT &&
+           error <= Error::MESSAGE_HAS_UNKNOWN_PROPERTY;
+  }
+
+  // Returns 7 bit US-ASCII string, either "OK" or an error message without
+  // position.
+  std::string Message() const;
+
+  // Returns a 7 bit US-ASCII string, either "OK" or an error message that
+  // includes the position.
+  std::string ToASCIIString() const;
+};
+
+template <typename T>
+class StatusOr {
+ public:
+  explicit StatusOr(const T& value) : value_(value) {}
+  explicit StatusOr(T&& value) : value_(std::move(value)) {}
+  explicit StatusOr(const Status& status) : status_(status) {}
+
+  bool ok() const { return status_.ok(); }
+  const Status& status() const { return status_; }
+  T& operator*() & { return value(); }
+  const T& operator*() const& { return value(); }
+  T&& operator*() && { return value(); }
+
+  T& value() & {
+    assert(ok());
+    return value_;
+  }
+  T&& value() && {
+    assert(ok());
+    return std::move(value_);
+  }
+  const T& value() const& {
+    assert(ok());
+    return value_;
+  }
+
+ private:
+  Status status_;
+  T value_;
+};
+
+}  // namespace crdtp
+
+#endif  // CRDTP_STATUS_H_
diff --git a/tools/inspector_protocol/crdtp/status_test.cc b/tools/inspector_protocol/crdtp/status_test.cc
new file mode 100644
index 00000000000000..e25af39f0594be
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/status_test.cc
@@ -0,0 +1,29 @@
+// Copyright 2018 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "status.h"
+#include "status_test_support.h"
+#include "test_platform.h"
+
+namespace crdtp {
+// =============================================================================
+// Status and Error codes
+// =============================================================================
+
+TEST(StatusTest, StatusToASCIIString) {
+  Status ok_status;
+  EXPECT_EQ("OK", ok_status.ToASCIIString());
+  Status json_error(Error::JSON_PARSER_COLON_EXPECTED, 42);
+  EXPECT_EQ("JSON: colon expected at position 42", json_error.ToASCIIString());
+  Status cbor_error(Error::CBOR_TRAILING_JUNK, 21);
+  EXPECT_EQ("CBOR: trailing junk at position 21", cbor_error.ToASCIIString());
+}
+
+TEST(StatusTest, StatusTestSupport) {
+  Status ok_status;
+  EXPECT_THAT(ok_status, StatusIsOk());
+  Status json_error(Error::JSON_PARSER_COLON_EXPECTED, 42);
+  EXPECT_THAT(json_error, StatusIs(Error::JSON_PARSER_COLON_EXPECTED, 42));
+}
+}  // namespace crdtp
diff --git a/tools/inspector_protocol/crdtp/status_test_support.cc b/tools/inspector_protocol/crdtp/status_test_support.cc
new file mode 100644
index 00000000000000..3bf267a037906c
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/status_test_support.cc
@@ -0,0 +1,50 @@
+// Copyright 2020 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "status_test_support.h"
+
+namespace crdtp {
+void PrintTo(const Status& status, std::ostream* os) {
+  *os << status.ToASCIIString() << " (error: 0x" << std::hex
+      << static_cast<int>(status.error) << ", "
+      << "pos: " << std::dec << status.pos << ")";
+}
+
+namespace {
+class StatusIsMatcher : public testing::MatcherInterface<Status> {
+ public:
+  explicit StatusIsMatcher(Status status) : expected_(status) {}
+
+  bool MatchAndExplain(Status status,
+                       testing::MatchResultListener* listener) const override {
+    return status.error == expected_.error && status.pos == expected_.pos;
+  }
+
+  void DescribeTo(std::ostream* os) const override {
+    *os << "equals to ";
+    PrintTo(expected_, os);
+  }
+
+ private:
+  Status expected_;
+};
+
+class StatusIsOkMatcher : public testing::MatcherInterface<Status> {
+  bool MatchAndExplain(Status status,
+                       testing::MatchResultListener* listener) const override {
+    return status.ok();
+  }
+
+  void DescribeTo(std::ostream* os) const override { *os << "is ok"; }
+};
+}  // namespace
+
+testing::Matcher<Status> StatusIsOk() {
+  return MakeMatcher(new StatusIsOkMatcher());
+}
+
+testing::Matcher<Status> StatusIs(Error error, size_t pos) {
+  return MakeMatcher(new StatusIsMatcher(Status(error, pos)));
+}
+}  // namespace crdtp
diff --git a/tools/inspector_protocol/crdtp/status_test_support.h b/tools/inspector_protocol/crdtp/status_test_support.h
new file mode 100644
index 00000000000000..5e2ee601e1855a
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/status_test_support.h
@@ -0,0 +1,32 @@
+// Copyright 2020 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CRDTP_STATUS_TEST_SUPPORT_H_
+#define CRDTP_STATUS_TEST_SUPPORT_H_
+
+#include <ostream>
+#include "status.h"
+#include "test_platform.h"
+
+namespace crdtp {
+// Supports gtest, to conveniently match Status objects and
+// get useful error messages when tests fail.
+// Typically used with EXPECT_THAT, e.g.
+//
+// EXPECT_THAT(status, StatusIs(Error::JSON_PARSER_COLON_EXPECTED, 42));
+//
+// EXPECT_THAT(status, StatusIsOk());
+
+// Prints a |status|, including its generated error message, error code, and
+// position. This is used by gtest for pretty printing actual vs. expected.
+void PrintTo(const Status& status, std::ostream* os);
+
+// Matches any status with |status.ok()|.
+testing::Matcher<Status> StatusIsOk();
+
+// Matches any status with |error| and |pos|.
+testing::Matcher<Status> StatusIs(Error error, size_t pos);
+}  // namespace crdtp
+
+#endif  // CRDTP_STATUS_TEST_SUPPORT_H_
diff --git a/tools/inspector_protocol/crdtp/test_platform.cc b/tools/inspector_protocol/crdtp/test_platform.cc
new file mode 100644
index 00000000000000..bbd8d6cd9fefd4
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/test_platform.cc
@@ -0,0 +1,33 @@
+// Copyright 2019 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// This file is Chromium specific, to make the tests work.  It will work
+// in the standalone (upstream) build, as well as in Chromium. In other code
+// bases (e.g. v8), a custom file with these two functions and with appropriate
+// includes may need to be provided, so it isn't necessarily part of a roll.
+
+#include "test_platform.h"
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include "base/strings/utf_string_conversions.h"
+
+namespace crdtp {
+std::string UTF16ToUTF8(span<uint16_t> in) {
+  std::string out;
+  bool success = base::UTF16ToUTF8(reinterpret_cast<const char16_t*>(in.data()),
+                                   in.size(), &out);
+  CHECK(success);
+  return out;
+}
+
+std::vector<uint16_t> UTF8ToUTF16(span<uint8_t> in) {
+  std::u16string tmp;
+  bool success = base::UTF8ToUTF16(reinterpret_cast<const char*>(in.data()),
+                                   in.size(), &tmp);
+  CHECK(success);
+  return std::vector<uint16_t>(tmp.begin(), tmp.end());
+}
+}  // namespace crdtp
diff --git a/tools/inspector_protocol/crdtp/test_platform.h b/tools/inspector_protocol/crdtp/test_platform.h
new file mode 100644
index 00000000000000..a512464be9f38e
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/test_platform.h
@@ -0,0 +1,31 @@
+// Copyright 2019 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// This file is Chromium specific, to make the tests work. It will work
+// in the standalone (upstream) build, as well as in Chromium. In other code
+// bases (e.g. v8), a custom file with these two functions and with appropriate
+// includes may need to be provided, so it isn't necessarily part of a roll.
+//
+// Put another way: The tests, e.g. json_test.cc include *only* test_platform.h,
+// which provides CHECK and gunit functionality, and UTF8<->UTF16 conversion
+// functions.
+
+#ifndef CRDTP_TEST_PLATFORM_H_
+#define CRDTP_TEST_PLATFORM_H_
+
+#include <cstdint>
+#include <string>
+#include <vector>
+#include "base/check_op.h"  // Provides CHECK and CHECK_EQ, etc.
+#include "span.h"
+#include "testing/gmock/include/gmock/gmock.h"  // Provides Gunit
+#include "testing/gtest/include/gtest/gtest.h"  // Provides Gmock
+
+// Provides UTF8<->UTF16 conversion routines (implemented in .cc file).
+namespace crdtp {
+std::string UTF16ToUTF8(span<uint16_t> in);
+std::vector<uint16_t> UTF8ToUTF16(span<uint8_t> in);
+}  // namespace crdtp
+
+#endif  // CRDTP_TEST_PLATFORM_H_
diff --git a/tools/inspector_protocol/crdtp/test_string_traits.cc b/tools/inspector_protocol/crdtp/test_string_traits.cc
new file mode 100644
index 00000000000000..b328ae22805bd4
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/test_string_traits.cc
@@ -0,0 +1,31 @@
+// Copyright 2021 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "test_string_traits.h"
+
+namespace crdtp {
+
+// Test-only. Real-life bindings use UTF8/16 conversions as needed.
+bool ProtocolTypeTraits<std::string>::Deserialize(DeserializerState* state,
+                                                  std::string* value) {
+  if (state->tokenizer()->TokenTag() == cbor::CBORTokenTag::STRING8) {
+    auto cbor_span = state->tokenizer()->GetString8();
+    value->assign(reinterpret_cast<const char*>(cbor_span.data()),
+                  cbor_span.size());
+    return true;
+  }
+  state->RegisterError(Error::BINDINGS_STRING8_VALUE_EXPECTED);
+  return false;
+}
+
+// static
+void ProtocolTypeTraits<std::string>::Serialize(const std::string& value,
+                                                std::vector<uint8_t>* bytes) {
+  cbor::EncodeString8(
+      span<uint8_t>(reinterpret_cast<const uint8_t*>(value.data()),
+                    value.size()),
+      bytes);
+}
+
+}  // namespace crdtp
diff --git a/tools/inspector_protocol/crdtp/test_string_traits.h b/tools/inspector_protocol/crdtp/test_string_traits.h
new file mode 100644
index 00000000000000..be9a8418784bb5
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/test_string_traits.h
@@ -0,0 +1,21 @@
+// Copyright 2021 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CRDTP_TEST_STRING_TRAITS_H_
+
+#include "protocol_core.h"
+
+namespace crdtp {
+
+// Either real string traits or dummy string traits are going to be used
+// depending on whether this is built standalone or with embedder.
+template <>
+struct ProtocolTypeTraits<std::string> {
+  static bool Deserialize(DeserializerState* state, std::string* value);
+  static void Serialize(const std::string& value, std::vector<uint8_t>* bytes);
+};
+
+}  // namespace crdtp
+
+#endif  // CRDTP_TEST_STRING_TRAITS_H_
diff --git a/tools/inspector_protocol/crdtp/transcode.cc b/tools/inspector_protocol/crdtp/transcode.cc
new file mode 100644
index 00000000000000..dee576d9ee8c2c
--- /dev/null
+++ b/tools/inspector_protocol/crdtp/transcode.cc
@@ -0,0 +1,61 @@
+// Copyright 2019 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <string>
+
+#include "json.h"
+
+namespace crdtp {
+namespace {
+int Transcode(const std::string& cmd,
+              const std::string& input_file_name,
+              const std::string& output_file_name) {
+  std::ifstream input_file(input_file_name, std::ios::binary);
+  if (!input_file.is_open()) {
+    std::cerr << "failed to open " << input_file_name << "\n";
+    return 1;
+  }
+  std::string in;
+  while (input_file) {
+    std::string buffer(1024, '\0');
+    input_file.read(&buffer.front(), buffer.size());
+    in += buffer.substr(0, input_file.gcount());
+  }
+  Status status;
+  std::vector<uint8_t> out;
+  if (cmd == "--json-to-cbor") {
+    status = json::ConvertJSONToCBOR(SpanFrom(in), &out);
+  } else if (cmd == "--cbor-to-json") {
+    status = json::ConvertCBORToJSON(SpanFrom(in), &out);
+  } else {
+    std::cerr << "unknown command " << cmd << "\n";
+    return 1;
+  }
+  if (!status.ok()) {
+    std::cerr << "transcoding error: " << status.ToASCIIString() << "\n";
+    return 1;
+  }
+  std::ofstream output_file(output_file_name, std::ios::binary);
+  if (!output_file.is_open()) {
+    std::cerr << "failed to open " << output_file_name << "\n";
+    return 1;
+  }
+  output_file.write(reinterpret_cast<const char*>(out.data()), out.size());
+  return 0;
+}
+}  // namespace
+}  // namespace crdtp
+
+int main(int argc, char** argv) {
+  if (argc == 4)
+    return ::crdtp::Transcode(argv[1], argv[2], argv[3]);
+  std::cerr << "usage: " << argv[0]
+            << " --json-to-cbor <input-file> <output-file>\n"
+            << "  or   " << argv[0]
+            << " --cbor-to-json <input-file> <output-file>\n";
+  return 1;
+}
diff --git a/tools/inspector_protocol/inspector_protocol.gni b/tools/inspector_protocol/inspector_protocol.gni
index 3e934526b82ae1..4e2547a09ad658 100644
--- a/tools/inspector_protocol/inspector_protocol.gni
+++ b/tools/inspector_protocol/inspector_protocol.gni
@@ -1,7 +1,12 @@
-# Copyright 2016 The Chromium Authors. All rights reserved.
+# Copyright 2016 The Chromium Authors
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
+declare_args() {
+  # Where jinja2 is located, in chromium it is //third_party.
+  jinja_dir = "//third_party"
+}
+
 # This template will generate inspector protocol source code. The code will
 # not be compiled, use get_target_outputs(<name>) to compile them.
 #
@@ -25,32 +30,14 @@ template("inspector_protocol_generate") {
   assert(defined(invoker.outputs))
   assert(defined(invoker.inspector_protocol_dir))
   inspector_protocol_dir = invoker.inspector_protocol_dir
-
+  use_embedder_types =
+      defined(invoker.use_embedder_types) && invoker.use_embedder_types
   action(target_name) {
     script = "$inspector_protocol_dir/code_generator.py"
 
     inputs = [
       invoker.config_file,
-      "$inspector_protocol_dir/lib/base_string_adapter_cc.template",
-      "$inspector_protocol_dir/lib/base_string_adapter_h.template",
-      "$inspector_protocol_dir/lib/encoding_h.template",
-      "$inspector_protocol_dir/lib/encoding_cpp.template",
-      "$inspector_protocol_dir/lib/Allocator_h.template",
-      "$inspector_protocol_dir/lib/DispatcherBase_cpp.template",
-      "$inspector_protocol_dir/lib/DispatcherBase_h.template",
-      "$inspector_protocol_dir/lib/ErrorSupport_cpp.template",
-      "$inspector_protocol_dir/lib/ErrorSupport_h.template",
       "$inspector_protocol_dir/lib/Forward_h.template",
-      "$inspector_protocol_dir/lib/FrontendChannel_h.template",
-      "$inspector_protocol_dir/lib/Maybe_h.template",
-      "$inspector_protocol_dir/lib/Object_cpp.template",
-      "$inspector_protocol_dir/lib/Object_h.template",
-      "$inspector_protocol_dir/lib/Parser_cpp.template",
-      "$inspector_protocol_dir/lib/Parser_h.template",
-      "$inspector_protocol_dir/lib/Protocol_cpp.template",
-      "$inspector_protocol_dir/lib/ValueConversions_h.template",
-      "$inspector_protocol_dir/lib/Values_cpp.template",
-      "$inspector_protocol_dir/lib/Values_h.template",
       "$inspector_protocol_dir/templates/Exported_h.template",
       "$inspector_protocol_dir/templates/Imported_h.template",
       "$inspector_protocol_dir/templates/TypeBuilder_cpp.template",
@@ -59,16 +46,33 @@ template("inspector_protocol_generate") {
     if (defined(invoker.inputs)) {
       inputs += invoker.inputs
     }
+    if (!use_embedder_types) {
+      inputs += [
+        "$inspector_protocol_dir/lib/ValueConversions_cpp.template",
+        "$inspector_protocol_dir/lib/ValueConversions_h.template",
+        "$inspector_protocol_dir/lib/Values_cpp.template",
+        "$inspector_protocol_dir/lib/Values_h.template",
+        "$inspector_protocol_dir/lib/Object_cpp.template",
+        "$inspector_protocol_dir/lib/Object_h.template",
+      ]
+    }
 
     args = [
       "--jinja_dir",
-      rebase_path("//third_party/", root_build_dir),  # jinja is in chromium's third_party
+      rebase_path(jinja_dir, root_build_dir),
       "--output_base",
       rebase_path(invoker.out_dir, root_build_dir),
       "--config",
       rebase_path(invoker.config_file, root_build_dir),
+      "--inspector_protocol_dir",
+      "$inspector_protocol_dir",
     ]
-
+    if (use_embedder_types) {
+      args += [
+        "--config_value",
+        "use_embedder_types=true",
+      ]
+    }
     if (defined(invoker.config_values)) {
       foreach(value, invoker.config_values) {
         args += [
diff --git a/tools/inspector_protocol/inspector_protocol.gypi b/tools/inspector_protocol/inspector_protocol.gypi
deleted file mode 100644
index c11386dc05174e..00000000000000
--- a/tools/inspector_protocol/inspector_protocol.gypi
+++ /dev/null
@@ -1,33 +0,0 @@
-# Copyright 2016 The Chromium Authors. All rights reserved.
-# Use of this source code is governed by a BSD-style license that can be
-# found in the LICENSE file.
-
-{
-  'variables': {
-    'inspector_protocol_files': [
-      'lib/encoding_h.template',
-      'lib/encoding_cpp.template',
-      'lib/Allocator_h.template',
-      'lib/DispatcherBase_cpp.template',
-      'lib/DispatcherBase_h.template',
-      'lib/ErrorSupport_cpp.template',
-      'lib/ErrorSupport_h.template',
-      'lib/Forward_h.template',
-      'lib/FrontendChannel_h.template',
-      'lib/Maybe_h.template',
-      'lib/Object_cpp.template',
-      'lib/Object_h.template',
-      'lib/Parser_cpp.template',
-      'lib/Parser_h.template',
-      'lib/Protocol_cpp.template',
-      'lib/ValueConversions_h.template',
-      'lib/Values_cpp.template',
-      'lib/Values_h.template',
-      'templates/Exported_h.template',
-      'templates/Imported_h.template',
-      'templates/TypeBuilder_cpp.template',
-      'templates/TypeBuilder_h.template',
-      'code_generator.py',
-    ]
-  }
-}
diff --git a/tools/inspector_protocol/lib/Allocator_h.template b/tools/inspector_protocol/lib/Allocator_h.template
deleted file mode 100644
index d94c4ca5b0ae99..00000000000000
--- a/tools/inspector_protocol/lib/Allocator_h.template
+++ /dev/null
@@ -1,23 +0,0 @@
-// This file is generated by Allocator_h.template.
-
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef {{"_".join(config.protocol.namespace)}}_Allocator_h
-#define {{"_".join(config.protocol.namespace)}}_Allocator_h
-
-{% for namespace in config.protocol.namespace %}
-namespace {{namespace}} {
-{% endfor %}
-
-#define PROTOCOL_DISALLOW_COPY(ClassName) \
-    private: \
-        ClassName(const ClassName&) = delete; \
-        ClassName& operator=(const ClassName&) = delete
-
-{% for namespace in config.protocol.namespace %}
-} // namespace {{namespace}}
-{% endfor %}
-
-#endif // !defined({{"_".join(config.protocol.namespace)}}_Allocator_h)
diff --git a/tools/inspector_protocol/lib/DispatcherBase_cpp.template b/tools/inspector_protocol/lib/DispatcherBase_cpp.template
deleted file mode 100644
index 11843f433007fc..00000000000000
--- a/tools/inspector_protocol/lib/DispatcherBase_cpp.template
+++ /dev/null
@@ -1,353 +0,0 @@
-// This file is generated by DispatcherBase_cpp.template.
-
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-//#include "DispatcherBase.h"
-//#include "Parser.h"
-
-{% for namespace in config.protocol.namespace %}
-namespace {{namespace}} {
-{% endfor %}
-
-// static
-DispatchResponse DispatchResponse::OK()
-{
-    DispatchResponse result;
-    result.m_status = kSuccess;
-    result.m_errorCode = kParseError;
-    return result;
-}
-
-// static
-DispatchResponse DispatchResponse::Error(const String& error)
-{
-    DispatchResponse result;
-    result.m_status = kError;
-    result.m_errorCode = kServerError;
-    result.m_errorMessage = error;
-    return result;
-}
-
-// static
-DispatchResponse DispatchResponse::InternalError()
-{
-    DispatchResponse result;
-    result.m_status = kError;
-    result.m_errorCode = kInternalError;
-    result.m_errorMessage = "Internal error";
-    return result;
-}
-
-// static
-DispatchResponse DispatchResponse::InvalidParams(const String& error)
-{
-    DispatchResponse result;
-    result.m_status = kError;
-    result.m_errorCode = kInvalidParams;
-    result.m_errorMessage = error;
-    return result;
-}
-
-// static
-DispatchResponse DispatchResponse::FallThrough()
-{
-    DispatchResponse result;
-    result.m_status = kFallThrough;
-    result.m_errorCode = kParseError;
-    return result;
-}
-
-// static
-const char DispatcherBase::kInvalidParamsString[] = "Invalid parameters";
-
-DispatcherBase::WeakPtr::WeakPtr(DispatcherBase* dispatcher) : m_dispatcher(dispatcher) { }
-
-DispatcherBase::WeakPtr::~WeakPtr()
-{
-    if (m_dispatcher)
-        m_dispatcher->m_weakPtrs.erase(this);
-}
-
-DispatcherBase::Callback::Callback(std::unique_ptr<DispatcherBase::WeakPtr> backendImpl, int callId, const String& method, const ProtocolMessage& message)
-    : m_backendImpl(std::move(backendImpl))
-    , m_callId(callId)
-    , m_method(method)
-    , m_message(message) { }
-
-DispatcherBase::Callback::~Callback() = default;
-
-void DispatcherBase::Callback::dispose()
-{
-    m_backendImpl = nullptr;
-}
-
-void DispatcherBase::Callback::sendIfActive(std::unique_ptr<protocol::DictionaryValue> partialMessage, const DispatchResponse& response)
-{
-    if (!m_backendImpl || !m_backendImpl->get())
-        return;
-    m_backendImpl->get()->sendResponse(m_callId, response, std::move(partialMessage));
-    m_backendImpl = nullptr;
-}
-
-void DispatcherBase::Callback::fallThroughIfActive()
-{
-    if (!m_backendImpl || !m_backendImpl->get())
-        return;
-    m_backendImpl->get()->channel()->fallThrough(m_callId, m_method, m_message);
-    m_backendImpl = nullptr;
-}
-
-DispatcherBase::DispatcherBase(FrontendChannel* frontendChannel)
-    : m_frontendChannel(frontendChannel) { }
-
-DispatcherBase::~DispatcherBase()
-{
-    clearFrontend();
-}
-
-void DispatcherBase::sendResponse(int callId, const DispatchResponse& response, std::unique_ptr<protocol::DictionaryValue> result)
-{
-    if (!m_frontendChannel)
-        return;
-    if (response.status() == DispatchResponse::kError) {
-        reportProtocolError(callId, response.errorCode(), response.errorMessage(), nullptr);
-        return;
-    }
-    m_frontendChannel->sendProtocolResponse(callId, InternalResponse::createResponse(callId, std::move(result)));
-}
-
-void DispatcherBase::sendResponse(int callId, const DispatchResponse& response)
-{
-    sendResponse(callId, response, DictionaryValue::create());
-}
-
-namespace {
-
-class ProtocolError : public Serializable {
-public:
-    static std::unique_ptr<ProtocolError> createErrorResponse(int callId, DispatchResponse::ErrorCode code, const String& errorMessage, ErrorSupport* errors)
-    {
-        std::unique_ptr<ProtocolError> protocolError(new ProtocolError(code, errorMessage));
-        protocolError->m_callId = callId;
-        protocolError->m_hasCallId = true;
-        if (errors && errors->hasErrors())
-            protocolError->m_data = errors->errors();
-        return protocolError;
-    }
-
-    static std::unique_ptr<ProtocolError> createErrorNotification(DispatchResponse::ErrorCode code, const String& errorMessage)
-    {
-        return std::unique_ptr<ProtocolError>(new ProtocolError(code, errorMessage));
-    }
-
-    String serializeToJSON() override
-    {
-        return serialize()->serializeToJSON();
-    }
-
-    std::vector<uint8_t> serializeToBinary() override
-    {
-        return serialize()->serializeToBinary();
-    }
-
-    ~ProtocolError() override {}
-
-private:
-    ProtocolError(DispatchResponse::ErrorCode code, const String& errorMessage)
-        : m_code(code)
-        , m_errorMessage(errorMessage)
-    {
-    }
-
-    std::unique_ptr<DictionaryValue> serialize() {
-        std::unique_ptr<protocol::DictionaryValue> error = DictionaryValue::create();
-        error->setInteger("code", m_code);
-        error->setString("message", m_errorMessage);
-        if (m_data.length())
-            error->setString("data", m_data);
-        std::unique_ptr<protocol::DictionaryValue> message = DictionaryValue::create();
-        message->setObject("error", std::move(error));
-        if (m_hasCallId)
-            message->setInteger("id", m_callId);
-        return message;
-    }
-
-    DispatchResponse::ErrorCode m_code;
-    String m_errorMessage;
-    String m_data;
-    int m_callId = 0;
-    bool m_hasCallId = false;
-};
-
-} // namespace
-
-static void reportProtocolErrorTo(FrontendChannel* frontendChannel, int callId, DispatchResponse::ErrorCode code, const String& errorMessage, ErrorSupport* errors)
-{
-    if (frontendChannel)
-        frontendChannel->sendProtocolResponse(callId, ProtocolError::createErrorResponse(callId, code, errorMessage, errors));
-}
-
-static void reportProtocolErrorTo(FrontendChannel* frontendChannel, DispatchResponse::ErrorCode code, const String& errorMessage)
-{
-    if (frontendChannel)
-        frontendChannel->sendProtocolNotification(ProtocolError::createErrorNotification(code, errorMessage));
-}
-
-void DispatcherBase::reportProtocolError(int callId, DispatchResponse::ErrorCode code, const String& errorMessage, ErrorSupport* errors)
-{
-    reportProtocolErrorTo(m_frontendChannel, callId, code, errorMessage, errors);
-}
-
-void DispatcherBase::clearFrontend()
-{
-    m_frontendChannel = nullptr;
-    for (auto& weak : m_weakPtrs)
-        weak->dispose();
-    m_weakPtrs.clear();
-}
-
-std::unique_ptr<DispatcherBase::WeakPtr> DispatcherBase::weakPtr()
-{
-    std::unique_ptr<DispatcherBase::WeakPtr> weak(new DispatcherBase::WeakPtr(this));
-    m_weakPtrs.insert(weak.get());
-    return weak;
-}
-
-UberDispatcher::UberDispatcher(FrontendChannel* frontendChannel)
-    : m_frontendChannel(frontendChannel) { }
-
-void UberDispatcher::registerBackend(const String& name, std::unique_ptr<protocol::DispatcherBase> dispatcher)
-{
-    m_dispatchers[name] = std::move(dispatcher);
-}
-
-void UberDispatcher::setupRedirects(const std::unordered_map<String, String>& redirects)
-{
-    for (const auto& pair : redirects)
-        m_redirects[pair.first] = pair.second;
-}
-
-bool UberDispatcher::parseCommand(Value* parsedMessage, int* outCallId, String* outMethod) {
-    if (!parsedMessage) {
-        reportProtocolErrorTo(m_frontendChannel, DispatchResponse::kParseError, "Message must be a valid JSON");
-        return false;
-    }
-    protocol::DictionaryValue* messageObject = DictionaryValue::cast(parsedMessage);
-    if (!messageObject) {
-        reportProtocolErrorTo(m_frontendChannel, DispatchResponse::kInvalidRequest, "Message must be an object");
-        return false;
-    }
-
-    int callId = 0;
-    protocol::Value* callIdValue = messageObject->get("id");
-    bool success = callIdValue && callIdValue->asInteger(&callId);
-    if (!success) {
-        reportProtocolErrorTo(m_frontendChannel, DispatchResponse::kInvalidRequest, "Message must have integer 'id' property");
-        return false;
-    }
-    if (outCallId)
-      *outCallId = callId;
-
-    protocol::Value* methodValue = messageObject->get("method");
-    String method;
-    success = methodValue && methodValue->asString(&method);
-    if (!success) {
-        reportProtocolErrorTo(m_frontendChannel, callId, DispatchResponse::kInvalidRequest, "Message must have string 'method' property", nullptr);
-        return false;
-    }
-    if (outMethod)
-      *outMethod = method;
-    return true;
-}
-
-protocol::DispatcherBase* UberDispatcher::findDispatcher(const String& method) {
-    size_t dotIndex = StringUtil::find(method, ".");
-    if (dotIndex == StringUtil::kNotFound)
-        return nullptr;
-    String domain = StringUtil::substring(method, 0, dotIndex);
-    auto it = m_dispatchers.find(domain);
-    if (it == m_dispatchers.end())
-        return nullptr;
-    if (!it->second->canDispatch(method))
-        return nullptr;
-    return it->second.get();
-}
-
-bool UberDispatcher::canDispatch(const String& in_method)
-{
-    String method = in_method;
-    auto redirectIt = m_redirects.find(method);
-    if (redirectIt != m_redirects.end())
-        method = redirectIt->second;
-    return !!findDispatcher(method);
-}
-
-void UberDispatcher::dispatch(int callId, const String& in_method, std::unique_ptr<Value> parsedMessage, const ProtocolMessage& rawMessage)
-{
-    String method = in_method;
-    auto redirectIt = m_redirects.find(method);
-    if (redirectIt != m_redirects.end())
-        method = redirectIt->second;
-    protocol::DispatcherBase* dispatcher = findDispatcher(method);
-    if (!dispatcher) {
-        reportProtocolErrorTo(m_frontendChannel, callId, DispatchResponse::kMethodNotFound, "'" + method + "' wasn't found", nullptr);
-        return;
-    }
-    std::unique_ptr<protocol::DictionaryValue> messageObject = DictionaryValue::cast(std::move(parsedMessage));
-    dispatcher->dispatch(callId, method, rawMessage, std::move(messageObject));
-}
-
-UberDispatcher::~UberDispatcher() = default;
-
-// static
-std::unique_ptr<InternalResponse> InternalResponse::createResponse(int callId, std::unique_ptr<Serializable> params)
-{
-    return std::unique_ptr<InternalResponse>(new InternalResponse(callId, String(), std::move(params)));
-}
-
-// static
-std::unique_ptr<InternalResponse> InternalResponse::createNotification(const String& notification, std::unique_ptr<Serializable> params)
-{
-    return std::unique_ptr<InternalResponse>(new InternalResponse(0, notification, std::move(params)));
-}
-
-String InternalResponse::serializeToJSON()
-{
-    std::unique_ptr<DictionaryValue> result = DictionaryValue::create();
-    std::unique_ptr<Serializable> params(m_params ? std::move(m_params) : DictionaryValue::create());
-    if (m_notification.length()) {
-        result->setString("method", m_notification);
-        result->setValue("params", SerializedValue::fromJSON(params->serializeToJSON()));
-    } else {
-        result->setInteger("id", m_callId);
-        result->setValue("result", SerializedValue::fromJSON(params->serializeToJSON()));
-    }
-    return result->serializeToJSON();
-}
-
-std::vector<uint8_t> InternalResponse::serializeToBinary()
-{
-    std::unique_ptr<DictionaryValue> result = DictionaryValue::create();
-    std::unique_ptr<Serializable> params(m_params ? std::move(m_params) : DictionaryValue::create());
-    if (m_notification.length()) {
-        result->setString("method", m_notification);
-        result->setValue("params", SerializedValue::fromBinary(params->serializeToBinary()));
-    } else {
-        result->setInteger("id", m_callId);
-        result->setValue("result", SerializedValue::fromBinary(params->serializeToBinary()));
-    }
-    return result->serializeToBinary();
-}
-
-InternalResponse::InternalResponse(int callId, const String& notification, std::unique_ptr<Serializable> params)
-    : m_callId(callId)
-    , m_notification(notification)
-    , m_params(params ? std::move(params) : nullptr)
-{
-}
-
-{% for namespace in config.protocol.namespace %}
-} // namespace {{namespace}}
-{% endfor %}
diff --git a/tools/inspector_protocol/lib/DispatcherBase_h.template b/tools/inspector_protocol/lib/DispatcherBase_h.template
deleted file mode 100644
index 4aa0688adb33fc..00000000000000
--- a/tools/inspector_protocol/lib/DispatcherBase_h.template
+++ /dev/null
@@ -1,185 +0,0 @@
-// This file is generated by DispatcherBase_h.template.
-
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef {{"_".join(config.protocol.namespace)}}_DispatcherBase_h
-#define {{"_".join(config.protocol.namespace)}}_DispatcherBase_h
-
-//#include "Forward.h"
-//#include "ErrorSupport.h"
-//#include "Values.h"
-
-{% for namespace in config.protocol.namespace %}
-namespace {{namespace}} {
-{% endfor %}
-
-class WeakPtr;
-
-class {{config.lib.export_macro}} DispatchResponse {
-public:
-    enum Status {
-        kSuccess = 0,
-        kError = 1,
-        kFallThrough = 2,
-    };
-
-    // For historical reasons, these error codes correspond to commonly used
-    // XMLRPC codes (e.g. see METHOD_NOT_FOUND in
-    // https://github.com/python/cpython/blob/master/Lib/xmlrpc/client.py).
-    enum ErrorCode {
-        kParseError = -32700,
-        kInvalidRequest = -32600,
-        kMethodNotFound = -32601,
-        kInvalidParams = -32602,
-        kInternalError = -32603,
-        kServerError = -32000,
-    };
-
-    Status status() const { return m_status; }
-    const String& errorMessage() const { return m_errorMessage; }
-    ErrorCode errorCode() const { return m_errorCode; }
-    bool isSuccess() const { return m_status == kSuccess; }
-
-    static DispatchResponse OK();
-    static DispatchResponse Error(const String&);
-    static DispatchResponse InternalError();
-    static DispatchResponse InvalidParams(const String&);
-    static DispatchResponse FallThrough();
-
-private:
-    Status m_status;
-    String m_errorMessage;
-    ErrorCode m_errorCode;
-};
-
-class {{config.lib.export_macro}} DispatcherBase {
-    PROTOCOL_DISALLOW_COPY(DispatcherBase);
-public:
-    static const char kInvalidParamsString[];
-    class {{config.lib.export_macro}} WeakPtr {
-    public:
-        explicit WeakPtr(DispatcherBase*);
-        ~WeakPtr();
-        DispatcherBase* get() { return m_dispatcher; }
-        void dispose() { m_dispatcher = nullptr; }
-
-    private:
-        DispatcherBase* m_dispatcher;
-    };
-
-    class {{config.lib.export_macro}} Callback {
-    public:
-        Callback(std::unique_ptr<WeakPtr> backendImpl, int callId, const String& method, const ProtocolMessage& message);
-        virtual ~Callback();
-        void dispose();
-
-    protected:
-        void sendIfActive(std::unique_ptr<protocol::DictionaryValue> partialMessage, const DispatchResponse& response);
-        void fallThroughIfActive();
-
-    private:
-        std::unique_ptr<WeakPtr> m_backendImpl;
-        int m_callId;
-        String m_method;
-        ProtocolMessage m_message;
-    };
-
-    explicit DispatcherBase(FrontendChannel*);
-    virtual ~DispatcherBase();
-
-    virtual bool canDispatch(const String& method) = 0;
-    virtual void dispatch(int callId, const String& method, const ProtocolMessage& rawMessage, std::unique_ptr<protocol::DictionaryValue> messageObject) = 0;
-    FrontendChannel* channel() { return m_frontendChannel; }
-
-    void sendResponse(int callId, const DispatchResponse&, std::unique_ptr<protocol::DictionaryValue> result);
-    void sendResponse(int callId, const DispatchResponse&);
-
-    void reportProtocolError(int callId, DispatchResponse::ErrorCode, const String& errorMessage, ErrorSupport* errors);
-    void clearFrontend();
-
-    std::unique_ptr<WeakPtr> weakPtr();
-
-private:
-    FrontendChannel* m_frontendChannel;
-    std::unordered_set<WeakPtr*> m_weakPtrs;
-};
-
-class {{config.lib.export_macro}} UberDispatcher {
-    PROTOCOL_DISALLOW_COPY(UberDispatcher);
-public:
-    explicit UberDispatcher(FrontendChannel*);
-    void registerBackend(const String& name, std::unique_ptr<protocol::DispatcherBase>);
-    void setupRedirects(const std::unordered_map<String, String>&);
-    bool parseCommand(Value* message, int* callId, String* method);
-    bool canDispatch(const String& method);
-    void dispatch(int callId, const String& method, std::unique_ptr<Value> message, const ProtocolMessage& rawMessage);
-    FrontendChannel* channel() { return m_frontendChannel; }
-    virtual ~UberDispatcher();
-
-private:
-    protocol::DispatcherBase* findDispatcher(const String& method);
-    FrontendChannel* m_frontendChannel;
-    std::unordered_map<String, String> m_redirects;
-    std::unordered_map<String, std::unique_ptr<protocol::DispatcherBase>> m_dispatchers;
-};
-
-class InternalResponse : public Serializable {
-    PROTOCOL_DISALLOW_COPY(InternalResponse);
-public:
-    static std::unique_ptr<InternalResponse> createResponse(int callId, std::unique_ptr<Serializable> params);
-    static std::unique_ptr<InternalResponse> createNotification(const String& notification, std::unique_ptr<Serializable> params = nullptr);
-
-    String serializeToJSON() override;
-    std::vector<uint8_t> serializeToBinary() override;
-
-    ~InternalResponse() override {}
-
-private:
-    InternalResponse(int callId, const String& notification, std::unique_ptr<Serializable> params);
-
-    int m_callId;
-    String m_notification;
-    std::unique_ptr<Serializable> m_params;
-};
-
-class InternalRawNotification : public Serializable {
-public:
-    static std::unique_ptr<InternalRawNotification> fromJSON(String notification)
-    {
-        return std::unique_ptr<InternalRawNotification>(new InternalRawNotification(std::move(notification)));
-    }
-
-    static std::unique_ptr<InternalRawNotification> fromBinary(std::vector<uint8_t> notification)
-    {
-        return std::unique_ptr<InternalRawNotification>(new InternalRawNotification(std::move(notification)));
-    }
-
-    ~InternalRawNotification() override {}
-
-    String serializeToJSON() override
-    {
-        return std::move(m_jsonNotification);
-    }
-
-    std::vector<uint8_t> serializeToBinary() override
-    {
-        return std::move(m_binaryNotification);
-    }
-
-private:
-  explicit InternalRawNotification(String notification)
-    : m_jsonNotification(std::move(notification)) { }
-  explicit InternalRawNotification(std::vector<uint8_t> notification)
-    : m_binaryNotification(std::move(notification)) { }
-
-  String m_jsonNotification;
-  std::vector<uint8_t> m_binaryNotification;
-};
-
-{% for namespace in config.protocol.namespace %}
-} // namespace {{namespace}}
-{% endfor %}
-
-#endif // !defined({{"_".join(config.protocol.namespace)}}_DispatcherBase_h)
diff --git a/tools/inspector_protocol/lib/ErrorSupport_cpp.template b/tools/inspector_protocol/lib/ErrorSupport_cpp.template
deleted file mode 100644
index a5c2a79bbd25c4..00000000000000
--- a/tools/inspector_protocol/lib/ErrorSupport_cpp.template
+++ /dev/null
@@ -1,73 +0,0 @@
-// This file is generated by ErrorSupport_cpp.template.
-
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-//#include "ErrorSupport.h"
-
-{% for namespace in config.protocol.namespace %}
-namespace {{namespace}} {
-{% endfor %}
-
-ErrorSupport::ErrorSupport() { }
-ErrorSupport::~ErrorSupport() { }
-
-void ErrorSupport::setName(const char* name)
-{
-    setName(String(name));
-}
-
-void ErrorSupport::setName(const String& name)
-{
-    DCHECK(m_path.size());
-    m_path[m_path.size() - 1] = name;
-}
-
-void ErrorSupport::push()
-{
-    m_path.push_back(String());
-}
-
-void ErrorSupport::pop()
-{
-    m_path.pop_back();
-}
-
-void ErrorSupport::addError(const char* error)
-{
-    addError(String(error));
-}
-
-void ErrorSupport::addError(const String& error)
-{
-    StringBuilder builder;
-    for (size_t i = 0; i < m_path.size(); ++i) {
-        if (i)
-            StringUtil::builderAppend(builder, '.');
-        StringUtil::builderAppend(builder, m_path[i]);
-    }
-    StringUtil::builderAppend(builder, ": ");
-    StringUtil::builderAppend(builder, error);
-    m_errors.push_back(StringUtil::builderToString(builder));
-}
-
-bool ErrorSupport::hasErrors()
-{
-    return !!m_errors.size();
-}
-
-String ErrorSupport::errors()
-{
-    StringBuilder builder;
-    for (size_t i = 0; i < m_errors.size(); ++i) {
-        if (i)
-            StringUtil::builderAppend(builder, "; ");
-        StringUtil::builderAppend(builder, m_errors[i]);
-    }
-    return StringUtil::builderToString(builder);
-}
-
-{% for namespace in config.protocol.namespace %}
-} // namespace {{namespace}}
-{% endfor %}
diff --git a/tools/inspector_protocol/lib/ErrorSupport_h.template b/tools/inspector_protocol/lib/ErrorSupport_h.template
deleted file mode 100644
index f317a3cfb411b5..00000000000000
--- a/tools/inspector_protocol/lib/ErrorSupport_h.template
+++ /dev/null
@@ -1,39 +0,0 @@
-// This file is generated by ErrorSupport_h.template.
-
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef {{"_".join(config.protocol.namespace)}}_ErrorSupport_h
-#define {{"_".join(config.protocol.namespace)}}_ErrorSupport_h
-
-#include {{format_include(config.protocol.package, "Forward")}}
-
-{% for namespace in config.protocol.namespace %}
-namespace {{namespace}} {
-{% endfor %}
-
-class {{config.lib.export_macro}} ErrorSupport {
-public:
-    ErrorSupport();
-    ~ErrorSupport();
-
-    void push();
-    void setName(const char*);
-    void setName(const String&);
-    void pop();
-    void addError(const char*);
-    void addError(const String&);
-    bool hasErrors();
-    String errors();
-
-private:
-    std::vector<String> m_path;
-    std::vector<String> m_errors;
-};
-
-{% for namespace in config.protocol.namespace %}
-} // namespace {{namespace}}
-{% endfor %}
-
-#endif // !defined({{"_".join(config.protocol.namespace)}}_ErrorSupport_h)
diff --git a/tools/inspector_protocol/lib/Forward_h.template b/tools/inspector_protocol/lib/Forward_h.template
index a6c4b12feca013..4de0eeb803174b 100644
--- a/tools/inspector_protocol/lib/Forward_h.template
+++ b/tools/inspector_protocol/lib/Forward_h.template
@@ -1,6 +1,6 @@
 // This file is generated by Forward_h.template.
 
-// Copyright 2016 The Chromium Authors. All rights reserved.
+// Copyright 2016 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -10,31 +10,58 @@
 {% if config.lib.export_header %}
 #include {{format_include(config.lib.export_header)}}
 {% endif %}
-#include {{format_include(config.lib.string_header)}}
 
-#include <cstddef>
 #include <memory>
 #include <vector>
-#include <unordered_map>
-#include <unordered_set>
+
+#include "{{config.crdtp.dir}}/error_support.h"
+#include "{{config.crdtp.dir}}/dispatch.h"
+#include "{{config.crdtp.dir}}/frontend_channel.h"
+#include "{{config.crdtp.dir}}/protocol_core.h"
+
+{% if config.use_embedder_types %}
+#include {{format_include(config.lib.protocol_traits)}}
+{% else %}
+#include {{format_include(config.lib.string_header)}}
+{% endif %}
 
 {% for namespace in config.protocol.namespace %}
 namespace {{namespace}} {
 {% endfor %}
 
+using DispatchResponse = {{config.crdtp.namespace}}::DispatchResponse;
+using ErrorSupport = {{config.crdtp.namespace}}::ErrorSupport;
+using Serializable = {{config.crdtp.namespace}}::Serializable;
+using FrontendChannel = {{config.crdtp.namespace}}::FrontendChannel;
+using DomainDispatcher = {{config.crdtp.namespace}}::DomainDispatcher;
+using UberDispatcher = {{config.crdtp.namespace}}::UberDispatcher;
+using Response = DispatchResponse;
+
+{% if config.use_embedder_types %}
+using DictionaryValue = crdtp::traits::DictionaryValue;
+using Object = crdtp::traits::DictionaryValue;
+using ListValue = crdtp::traits::ListValue;
+using Value = crdtp::traits::Value;
+using String = crdtp::traits::String;
+using Binary = crdtp::Binary;
+{% else %}
 class DictionaryValue;
-class DispatchResponse;
-class ErrorSupport;
 class FundamentalValue;
 class ListValue;
 class Object;
-using Response = DispatchResponse;
 class SerializedValue;
 class StringValue;
-class UberDispatcher;
 class Value;
+{% endif %}
+
+using {{config.crdtp.namespace}}::detail::PtrMaybe;
+using {{config.crdtp.namespace}}::detail::ValueMaybe;
+
+template<typename T>
+using Maybe = {{config.crdtp.namespace}}::Maybe<T>;
 
 namespace detail {
+
 template <typename T>
 struct ArrayTypedef { typedef std::vector<std::unique_ptr<T>> type; };
 
@@ -49,6 +76,10 @@ struct ArrayTypedef<double> { typedef std::vector<double> type; };
 
 template <>
 struct ArrayTypedef<bool> { typedef std::vector<bool> type; };
+
+template <>
+struct ArrayTypedef<Binary> { typedef std::vector<Binary> type; };
+
 }  // namespace detail
 
 template <typename T>
diff --git a/tools/inspector_protocol/lib/FrontendChannel_h.template b/tools/inspector_protocol/lib/FrontendChannel_h.template
deleted file mode 100644
index df104debadbe85..00000000000000
--- a/tools/inspector_protocol/lib/FrontendChannel_h.template
+++ /dev/null
@@ -1,40 +0,0 @@
-// This file is generated by FrontendChannel_h.template.
-
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef {{"_".join(config.protocol.namespace)}}_FrontendChannel_h
-#define {{"_".join(config.protocol.namespace)}}_FrontendChannel_h
-
-{% for namespace in config.protocol.namespace %}
-namespace {{namespace}} {
-{% endfor %}
-
-class {{config.lib.export_macro}} Serializable {
-public:
-    ProtocolMessage serialize(bool binary) {
-      if (binary)
-        return StringUtil::binaryToMessage(serializeToBinary());
-      else
-        return StringUtil::jsonToMessage(serializeToJSON());
-    }
-    virtual String serializeToJSON() = 0;
-    virtual std::vector<uint8_t> serializeToBinary() = 0;
-    virtual ~Serializable() = default;
-};
-
-class {{config.lib.export_macro}} FrontendChannel {
-public:
-    virtual ~FrontendChannel() { }
-    virtual void sendProtocolResponse(int callId, std::unique_ptr<Serializable> message) = 0;
-    virtual void sendProtocolNotification(std::unique_ptr<Serializable> message) = 0;
-    virtual void fallThrough(int callId, const String& method, const ProtocolMessage& message) = 0;
-    virtual void flushProtocolNotifications() = 0;
-};
-
-{% for namespace in config.protocol.namespace %}
-} // namespace {{namespace}}
-{% endfor %}
-
-#endif // !defined({{"_".join(config.protocol.namespace)}}_FrontendChannel_h)
diff --git a/tools/inspector_protocol/lib/Maybe_h.template b/tools/inspector_protocol/lib/Maybe_h.template
deleted file mode 100644
index 8dfee7e9d5cb72..00000000000000
--- a/tools/inspector_protocol/lib/Maybe_h.template
+++ /dev/null
@@ -1,77 +0,0 @@
-// This file is generated by Maybe_h.template.
-
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef {{"_".join(config.protocol.namespace)}}_Maybe_h
-#define {{"_".join(config.protocol.namespace)}}_Maybe_h
-
-//#include "Forward.h"
-
-{% for namespace in config.protocol.namespace %}
-namespace {{namespace}} {
-{% endfor %}
-
-namespace detail {
-template<typename T>
-class PtrMaybe {
-public:
-    PtrMaybe() = default;
-    PtrMaybe(std::unique_ptr<T> value) : m_value(std::move(value)) { }
-    PtrMaybe(PtrMaybe&& other) noexcept : m_value(std::move(other.m_value)) {}
-    void operator=(std::unique_ptr<T> value) { m_value = std::move(value); }
-    T* fromJust() const { DCHECK(m_value); return m_value.get(); }
-    T* fromMaybe(T* defaultValue) const { return m_value ? m_value.get() : defaultValue; }
-    bool isJust() const { return !!m_value; }
-    std::unique_ptr<T> takeJust() { DCHECK(m_value); return std::move(m_value); }
-private:
-    std::unique_ptr<T> m_value;
-};
-
-template<typename T>
-class ValueMaybe {
-public:
-    ValueMaybe() : m_isJust(false), m_value() { }
-    ValueMaybe(T value) : m_isJust(true), m_value(std::move(value)) { }
-    ValueMaybe(ValueMaybe&& other) noexcept
-        : m_isJust(other.m_isJust),
-          m_value(std::move(other.m_value)) {}
-    void operator=(T value) { m_value = value; m_isJust = true; }
-    const T& fromJust() const { DCHECK(m_isJust); return m_value; }
-    const T& fromMaybe(const T& defaultValue) const { return m_isJust ? m_value : defaultValue; }
-    bool isJust() const { return m_isJust; }
-    T takeJust() { DCHECK(m_isJust); return std::move(m_value); }
-private:
-    bool m_isJust;
-    T m_value;
-};
-
-template <typename T>
-struct MaybeTypedef { typedef PtrMaybe<T> type; };
-
-template <>
-struct MaybeTypedef<bool> { typedef ValueMaybe<bool> type; };
-
-template <>
-struct MaybeTypedef<int> { typedef ValueMaybe<int> type; };
-
-template <>
-struct MaybeTypedef<double> { typedef ValueMaybe<double> type; };
-
-template <>
-struct MaybeTypedef<String> { typedef ValueMaybe<String> type; };
-
-template <>
-struct MaybeTypedef<Binary> { typedef ValueMaybe<Binary> type; };
-
-}  // namespace detail
-
-template <typename T>
-using Maybe = typename detail::MaybeTypedef<T>::type;
-
-{% for namespace in config.protocol.namespace %}
-} // namespace {{namespace}}
-{% endfor %}
-
-#endif // !defined({{"_".join(config.protocol.namespace)}}_Maybe_h)
diff --git a/tools/inspector_protocol/lib/Object_cpp.template b/tools/inspector_protocol/lib/Object_cpp.template
index 1640a11127b442..2b08cee303d335 100644
--- a/tools/inspector_protocol/lib/Object_cpp.template
+++ b/tools/inspector_protocol/lib/Object_cpp.template
@@ -1,6 +1,6 @@
 // This file is generated by Object_cpp.template.
 
-// Copyright 2016 The Chromium Authors. All rights reserved.
+// Copyright 2016 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -14,13 +14,18 @@ std::unique_ptr<Object> Object::fromValue(protocol::Value* value, ErrorSupport*
 {
     protocol::DictionaryValue* dictionary = DictionaryValue::cast(value);
     if (!dictionary) {
-        errors->addError("object expected");
+        errors->AddError("object expected");
         return nullptr;
     }
     dictionary = static_cast<protocol::DictionaryValue*>(dictionary->clone().release());
     return std::unique_ptr<Object>(new Object(std::unique_ptr<DictionaryValue>(dictionary)));
 }
 
+// Implements Serializable.
+void Object::AppendSerialized(std::vector<uint8_t>* out) const {
+    m_object->AppendSerialized(out);
+}
+
 std::unique_ptr<protocol::DictionaryValue> Object::toValue() const
 {
     return DictionaryValue::cast(m_object->clone());
diff --git a/tools/inspector_protocol/lib/Object_h.template b/tools/inspector_protocol/lib/Object_h.template
index ec953d0d4836a4..fe4df6b9cc7d5e 100644
--- a/tools/inspector_protocol/lib/Object_h.template
+++ b/tools/inspector_protocol/lib/Object_h.template
@@ -1,6 +1,6 @@
 // This file is generated by Object_h.template.
 
-// Copyright 2016 The Chromium Authors. All rights reserved.
+// Copyright 2016 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -11,19 +11,28 @@
 //#include "Forward.h"
 //#include "Values.h"
 
+#include "{{config.crdtp.dir}}/serializable.h"
+
 {% for namespace in config.protocol.namespace %}
 namespace {{namespace}} {
 {% endfor %}
 
-class {{config.lib.export_macro}} Object {
+class {{config.lib.export_macro}} Object : public {{config.crdtp.namespace}}::Serializable {
 public:
     static std::unique_ptr<Object> fromValue(protocol::Value*, ErrorSupport*);
     explicit Object(std::unique_ptr<protocol::DictionaryValue>);
     ~Object();
 
+    // Implements Serializable.
+    void AppendSerialized(std::vector<uint8_t>* out) const override;
+
     std::unique_ptr<protocol::DictionaryValue> toValue() const;
     std::unique_ptr<Object> clone() const;
+
 private:
+    Object() = default;
+    friend struct {{config.crdtp.namespace}}::ProtocolTypeTraits<std::unique_ptr<Object>, void>;
+
     std::unique_ptr<protocol::DictionaryValue> m_object;
 };
 
diff --git a/tools/inspector_protocol/lib/Parser_cpp.template b/tools/inspector_protocol/lib/Parser_cpp.template
deleted file mode 100644
index ea7ecc5a1a4756..00000000000000
--- a/tools/inspector_protocol/lib/Parser_cpp.template
+++ /dev/null
@@ -1,548 +0,0 @@
-// This file is generated by Parser_cpp.template.
-
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-{% for namespace in config.protocol.namespace %}
-namespace {{namespace}} {
-{% endfor %}
-
-namespace {
-
-const int stackLimit = 1000;
-
-enum Token {
-    ObjectBegin,
-    ObjectEnd,
-    ArrayBegin,
-    ArrayEnd,
-    StringLiteral,
-    Number,
-    BoolTrue,
-    BoolFalse,
-    NullToken,
-    ListSeparator,
-    ObjectPairSeparator,
-    InvalidToken,
-};
-
-const char* const nullString = "null";
-const char* const trueString = "true";
-const char* const falseString = "false";
-
-bool isASCII(uint16_t c)
-{
-    return !(c & ~0x7F);
-}
-
-bool isSpaceOrNewLine(uint16_t c)
-{
-    return isASCII(c) && c <= ' ' && (c == ' ' || (c <= 0xD && c >= 0x9));
-}
-
-double charactersToDouble(const uint16_t* characters, size_t length, bool* ok)
-{
-    std::vector<char> buffer;
-    buffer.reserve(length + 1);
-    for (size_t i = 0; i < length; ++i) {
-        if (!isASCII(characters[i])) {
-            *ok = false;
-            return 0;
-        }
-        buffer.push_back(static_cast<char>(characters[i]));
-    }
-    buffer.push_back('\0');
-    return StringUtil::toDouble(buffer.data(), length, ok);
-}
-
-double charactersToDouble(const uint8_t* characters, size_t length, bool* ok)
-{
-    std::string buffer(reinterpret_cast<const char*>(characters), length);
-    return StringUtil::toDouble(buffer.data(), length, ok);
-}
-
-template<typename Char>
-bool parseConstToken(const Char* start, const Char* end, const Char** tokenEnd, const char* token)
-{
-    while (start < end && *token != '\0' && *start++ == *token++) { }
-    if (*token != '\0')
-        return false;
-    *tokenEnd = start;
-    return true;
-}
-
-template<typename Char>
-bool readInt(const Char* start, const Char* end, const Char** tokenEnd, bool canHaveLeadingZeros)
-{
-    if (start == end)
-        return false;
-    bool haveLeadingZero = '0' == *start;
-    int length = 0;
-    while (start < end && '0' <= *start && *start <= '9') {
-        ++start;
-        ++length;
-    }
-    if (!length)
-        return false;
-    if (!canHaveLeadingZeros && length > 1 && haveLeadingZero)
-        return false;
-    *tokenEnd = start;
-    return true;
-}
-
-template<typename Char>
-bool parseNumberToken(const Char* start, const Char* end, const Char** tokenEnd)
-{
-    // We just grab the number here. We validate the size in DecodeNumber.
-    // According to RFC4627, a valid number is: [minus] int [frac] [exp]
-    if (start == end)
-        return false;
-    Char c = *start;
-    if ('-' == c)
-        ++start;
-
-    if (!readInt(start, end, &start, false))
-        return false;
-    if (start == end) {
-        *tokenEnd = start;
-        return true;
-    }
-
-    // Optional fraction part
-    c = *start;
-    if ('.' == c) {
-        ++start;
-        if (!readInt(start, end, &start, true))
-            return false;
-        if (start == end) {
-            *tokenEnd = start;
-            return true;
-        }
-        c = *start;
-    }
-
-    // Optional exponent part
-    if ('e' == c || 'E' == c) {
-        ++start;
-        if (start == end)
-            return false;
-        c = *start;
-        if ('-' == c || '+' == c) {
-            ++start;
-            if (start == end)
-                return false;
-        }
-        if (!readInt(start, end, &start, true))
-            return false;
-    }
-
-    *tokenEnd = start;
-    return true;
-}
-
-template<typename Char>
-bool readHexDigits(const Char* start, const Char* end, const Char** tokenEnd, int digits)
-{
-    if (end - start < digits)
-        return false;
-    for (int i = 0; i < digits; ++i) {
-        Char c = *start++;
-        if (!(('0' <= c && c <= '9') || ('a' <= c && c <= 'f') || ('A' <= c && c <= 'F')))
-            return false;
-    }
-    *tokenEnd = start;
-    return true;
-}
-
-template<typename Char>
-bool parseStringToken(const Char* start, const Char* end, const Char** tokenEnd)
-{
-    while (start < end) {
-        Char c = *start++;
-        if ('\\' == c) {
-	    if (start == end)
-	        return false;
-            c = *start++;
-            // Make sure the escaped char is valid.
-            switch (c) {
-            case 'x':
-                if (!readHexDigits(start, end, &start, 2))
-                    return false;
-                break;
-            case 'u':
-                if (!readHexDigits(start, end, &start, 4))
-                    return false;
-                break;
-            case '\\':
-            case '/':
-            case 'b':
-            case 'f':
-            case 'n':
-            case 'r':
-            case 't':
-            case 'v':
-            case '"':
-                break;
-            default:
-                return false;
-            }
-        } else if ('"' == c) {
-            *tokenEnd = start;
-            return true;
-        }
-    }
-    return false;
-}
-
-template<typename Char>
-bool skipComment(const Char* start, const Char* end, const Char** commentEnd)
-{
-    if (start == end)
-        return false;
-
-    if (*start != '/' || start + 1 >= end)
-        return false;
-    ++start;
-
-    if (*start == '/') {
-        // Single line comment, read to newline.
-        for (++start; start < end; ++start) {
-            if (*start == '\n' || *start == '\r') {
-                *commentEnd = start + 1;
-                return true;
-            }
-        }
-        *commentEnd = end;
-        // Comment reaches end-of-input, which is fine.
-        return true;
-    }
-
-    if (*start == '*') {
-        Char previous = '\0';
-        // Block comment, read until end marker.
-        for (++start; start < end; previous = *start++) {
-            if (previous == '*' && *start == '/') {
-                *commentEnd = start + 1;
-                return true;
-            }
-        }
-        // Block comment must close before end-of-input.
-        return false;
-    }
-
-    return false;
-}
-
-template<typename Char>
-void skipWhitespaceAndComments(const Char* start, const Char* end, const Char** whitespaceEnd)
-{
-    while (start < end) {
-        if (isSpaceOrNewLine(*start)) {
-            ++start;
-        } else if (*start == '/') {
-            const Char* commentEnd;
-            if (!skipComment(start, end, &commentEnd))
-                break;
-            start = commentEnd;
-        } else {
-            break;
-        }
-    }
-    *whitespaceEnd = start;
-}
-
-template<typename Char>
-Token parseToken(const Char* start, const Char* end, const Char** tokenStart, const Char** tokenEnd)
-{
-    skipWhitespaceAndComments(start, end, tokenStart);
-    start = *tokenStart;
-
-    if (start == end)
-        return InvalidToken;
-
-    switch (*start) {
-    case 'n':
-        if (parseConstToken(start, end, tokenEnd, nullString))
-            return NullToken;
-        break;
-    case 't':
-        if (parseConstToken(start, end, tokenEnd, trueString))
-            return BoolTrue;
-        break;
-    case 'f':
-        if (parseConstToken(start, end, tokenEnd, falseString))
-            return BoolFalse;
-        break;
-    case '[':
-        *tokenEnd = start + 1;
-        return ArrayBegin;
-    case ']':
-        *tokenEnd = start + 1;
-        return ArrayEnd;
-    case ',':
-        *tokenEnd = start + 1;
-        return ListSeparator;
-    case '{':
-        *tokenEnd = start + 1;
-        return ObjectBegin;
-    case '}':
-        *tokenEnd = start + 1;
-        return ObjectEnd;
-    case ':':
-        *tokenEnd = start + 1;
-        return ObjectPairSeparator;
-    case '0':
-    case '1':
-    case '2':
-    case '3':
-    case '4':
-    case '5':
-    case '6':
-    case '7':
-    case '8':
-    case '9':
-    case '-':
-        if (parseNumberToken(start, end, tokenEnd))
-            return Number;
-        break;
-    case '"':
-        if (parseStringToken(start + 1, end, tokenEnd))
-            return StringLiteral;
-        break;
-    }
-    return InvalidToken;
-}
-
-template<typename Char>
-int hexToInt(Char c)
-{
-    if ('0' <= c && c <= '9')
-        return c - '0';
-    if ('A' <= c && c <= 'F')
-        return c - 'A' + 10;
-    if ('a' <= c && c <= 'f')
-        return c - 'a' + 10;
-    DCHECK(false);
-    return 0;
-}
-
-template<typename Char>
-bool decodeString(const Char* start, const Char* end, StringBuilder* output)
-{
-    while (start < end) {
-        uint16_t c = *start++;
-        if ('\\' != c) {
-            StringUtil::builderAppend(*output, c);
-            continue;
-        }
-	if (start == end)
-	    return false;
-        c = *start++;
-
-        if (c == 'x') {
-            // \x is not supported.
-            return false;
-        }
-
-        switch (c) {
-        case '"':
-        case '/':
-        case '\\':
-            break;
-        case 'b':
-            c = '\b';
-            break;
-        case 'f':
-            c = '\f';
-            break;
-        case 'n':
-            c = '\n';
-            break;
-        case 'r':
-            c = '\r';
-            break;
-        case 't':
-            c = '\t';
-            break;
-        case 'v':
-            c = '\v';
-            break;
-        case 'u':
-            c = (hexToInt(*start) << 12) +
-                (hexToInt(*(start + 1)) << 8) +
-                (hexToInt(*(start + 2)) << 4) +
-                hexToInt(*(start + 3));
-            start += 4;
-            break;
-        default:
-            return false;
-        }
-        StringUtil::builderAppend(*output, c);
-    }
-    return true;
-}
-
-template<typename Char>
-bool decodeString(const Char* start, const Char* end, String* output)
-{
-    if (start == end) {
-        *output = "";
-        return true;
-    }
-    if (start > end)
-        return false;
-    StringBuilder buffer;
-    StringUtil::builderReserve(buffer, end - start);
-    if (!decodeString(start, end, &buffer))
-        return false;
-    *output = StringUtil::builderToString(buffer);
-    return true;
-}
-
-template<typename Char>
-std::unique_ptr<Value> buildValue(const Char* start, const Char* end, const Char** valueTokenEnd, int depth)
-{
-    if (depth > stackLimit)
-        return nullptr;
-
-    std::unique_ptr<Value> result;
-    const Char* tokenStart;
-    const Char* tokenEnd;
-    Token token = parseToken(start, end, &tokenStart, &tokenEnd);
-    switch (token) {
-    case InvalidToken:
-        return nullptr;
-    case NullToken:
-        result = Value::null();
-        break;
-    case BoolTrue:
-        result = FundamentalValue::create(true);
-        break;
-    case BoolFalse:
-        result = FundamentalValue::create(false);
-        break;
-    case Number: {
-        bool ok;
-        double value = charactersToDouble(tokenStart, tokenEnd - tokenStart, &ok);
-        if (!ok)
-            return nullptr;
-        if (value >= INT_MIN && value <= INT_MAX && static_cast<int>(value) == value)
-            result = FundamentalValue::create(static_cast<int>(value));
-        else
-            result = FundamentalValue::create(value);
-        break;
-    }
-    case StringLiteral: {
-        String value;
-        bool ok = decodeString(tokenStart + 1, tokenEnd - 1, &value);
-        if (!ok)
-            return nullptr;
-        result = StringValue::create(value);
-        break;
-    }
-    case ArrayBegin: {
-        std::unique_ptr<ListValue> array = ListValue::create();
-        start = tokenEnd;
-        token = parseToken(start, end, &tokenStart, &tokenEnd);
-        while (token != ArrayEnd) {
-            std::unique_ptr<Value> arrayNode = buildValue(start, end, &tokenEnd, depth + 1);
-            if (!arrayNode)
-                return nullptr;
-            array->pushValue(std::move(arrayNode));
-
-            // After a list value, we expect a comma or the end of the list.
-            start = tokenEnd;
-            token = parseToken(start, end, &tokenStart, &tokenEnd);
-            if (token == ListSeparator) {
-                start = tokenEnd;
-                token = parseToken(start, end, &tokenStart, &tokenEnd);
-                if (token == ArrayEnd)
-                    return nullptr;
-            } else if (token != ArrayEnd) {
-                // Unexpected value after list value. Bail out.
-                return nullptr;
-            }
-        }
-        if (token != ArrayEnd)
-            return nullptr;
-        result = std::move(array);
-        break;
-    }
-    case ObjectBegin: {
-        std::unique_ptr<DictionaryValue> object = DictionaryValue::create();
-        start = tokenEnd;
-        token = parseToken(start, end, &tokenStart, &tokenEnd);
-        while (token != ObjectEnd) {
-            if (token != StringLiteral)
-                return nullptr;
-            String key;
-            if (!decodeString(tokenStart + 1, tokenEnd - 1, &key))
-                return nullptr;
-            start = tokenEnd;
-
-            token = parseToken(start, end, &tokenStart, &tokenEnd);
-            if (token != ObjectPairSeparator)
-                return nullptr;
-            start = tokenEnd;
-
-            std::unique_ptr<Value> value = buildValue(start, end, &tokenEnd, depth + 1);
-            if (!value)
-                return nullptr;
-            object->setValue(key, std::move(value));
-            start = tokenEnd;
-
-            // After a key/value pair, we expect a comma or the end of the
-            // object.
-            token = parseToken(start, end, &tokenStart, &tokenEnd);
-            if (token == ListSeparator) {
-                start = tokenEnd;
-                token = parseToken(start, end, &tokenStart, &tokenEnd);
-                if (token == ObjectEnd)
-                    return nullptr;
-            } else if (token != ObjectEnd) {
-                // Unexpected value after last object value. Bail out.
-                return nullptr;
-            }
-        }
-        if (token != ObjectEnd)
-            return nullptr;
-        result = std::move(object);
-        break;
-    }
-
-    default:
-        // We got a token that's not a value.
-        return nullptr;
-    }
-
-    skipWhitespaceAndComments(tokenEnd, end, valueTokenEnd);
-    return result;
-}
-
-template<typename Char>
-std::unique_ptr<Value> parseJSONInternal(const Char* start, unsigned length)
-{
-    const Char* end = start + length;
-    const Char *tokenEnd;
-    std::unique_ptr<Value> value = buildValue(start, end, &tokenEnd, 0);
-    if (!value || tokenEnd != end)
-        return nullptr;
-    return value;
-}
-
-} // anonymous namespace
-
-std::unique_ptr<Value> parseJSONCharacters(const uint16_t* characters, unsigned length)
-{
-    return parseJSONInternal<uint16_t>(characters, length);
-}
-
-std::unique_ptr<Value> parseJSONCharacters(const uint8_t* characters, unsigned length)
-{
-    return parseJSONInternal<uint8_t>(characters, length);
-}
-
-{% for namespace in config.protocol.namespace %}
-} // namespace {{namespace}}
-{% endfor %}
diff --git a/tools/inspector_protocol/lib/Parser_h.template b/tools/inspector_protocol/lib/Parser_h.template
deleted file mode 100644
index 1832c2e9724b4a..00000000000000
--- a/tools/inspector_protocol/lib/Parser_h.template
+++ /dev/null
@@ -1,24 +0,0 @@
-// This file is generated by Parser_h.template.
-
-// Copyright 2016 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef {{"_".join(config.protocol.namespace)}}_Parser_h
-#define {{"_".join(config.protocol.namespace)}}_Parser_h
-
-//#include "Forward.h"
-//#include "Values.h"
-
-{% for namespace in config.protocol.namespace %}
-namespace {{namespace}} {
-{% endfor %}
-
-{{config.lib.export_macro}} std::unique_ptr<Value> parseJSONCharacters(const uint8_t*, unsigned);
-{{config.lib.export_macro}} std::unique_ptr<Value> parseJSONCharacters(const uint16_t*, unsigned);
-
-{% for namespace in config.protocol.namespace %}
-} // namespace {{namespace}}
-{% endfor %}
-
-#endif // !defined({{"_".join(config.protocol.namespace)}}_Parser_h)
diff --git a/tools/inspector_protocol/lib/Protocol_cpp.template b/tools/inspector_protocol/lib/Protocol_cpp.template
index 88303a27ab9e7e..84bd6e70d6b200 100644
--- a/tools/inspector_protocol/lib/Protocol_cpp.template
+++ b/tools/inspector_protocol/lib/Protocol_cpp.template
@@ -1,6 +1,6 @@
 // This file is generated by Protocol_cpp.template.
 
-// Copyright 2016 The Chromium Authors. All rights reserved.
+// Copyright 2016 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
diff --git a/tools/inspector_protocol/lib/ValueConversions_cpp.template b/tools/inspector_protocol/lib/ValueConversions_cpp.template
new file mode 100644
index 00000000000000..d2ab41a2dbab6a
--- /dev/null
+++ b/tools/inspector_protocol/lib/ValueConversions_cpp.template
@@ -0,0 +1,127 @@
+// This file is generated by ValueConversions_cpp.template.
+
+// Copyright 2020 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include {{format_include(config.protocol.package, "Protocol")}}
+
+#include <algorithm>
+#include <climits>
+#include <string>
+
+//#include "ValueConversions.h"
+//#include "Values.h"
+
+{% for namespace in config.protocol.namespace %}
+namespace {{namespace}} {
+{% endfor %}
+
+{% for namespace in config.protocol.namespace %}
+}  // namespace
+{% endfor %}
+
+
+namespace {{config.crdtp.namespace}} {
+
+namespace {
+
+using {{"::".join(config.protocol.namespace)}}::Binary;
+using {{"::".join(config.protocol.namespace)}}::Object;
+using {{"::".join(config.protocol.namespace)}}::Value;
+using {{"::".join(config.protocol.namespace)}}::String;
+using {{"::".join(config.protocol.namespace)}}::DictionaryValue;
+using {{"::".join(config.protocol.namespace)}}::FundamentalValue;
+using {{"::".join(config.protocol.namespace)}}::StringValue;
+using {{"::".join(config.protocol.namespace)}}::StringUtil;
+//using {{"::".join(config.protocol.namespace)}}::EncodeString;
+
+std::unique_ptr<Value> ReadValue(DeserializerState* state) {
+  cbor::CBORTokenizer* tokenizer = state->tokenizer();
+  switch (tokenizer->TokenTag()) {
+    case cbor::CBORTokenTag::TRUE_VALUE:
+      return FundamentalValue::create(true);
+    case cbor::CBORTokenTag::FALSE_VALUE:
+      return FundamentalValue::create(false);
+    case cbor::CBORTokenTag::NULL_VALUE:
+      return Value::null();
+    case cbor::CBORTokenTag::INT32:
+      return FundamentalValue::create(tokenizer->GetInt32());
+    case cbor::CBORTokenTag::DOUBLE:
+      return FundamentalValue::create(tokenizer->GetDouble());
+    case cbor::CBORTokenTag::STRING8: {
+      const auto str = tokenizer->GetString8();
+      return StringValue::create(StringUtil::fromUTF8(str.data(), str.size()));
+    }
+    case cbor::CBORTokenTag::STRING16: {
+      const auto str = tokenizer->GetString16WireRep();
+      return StringValue::create(StringUtil::fromUTF16LE(reinterpret_cast<const uint16_t*>(str.data()), str.size() / 2));
+    }
+    case cbor::CBORTokenTag::ENVELOPE: {
+      const auto env = tokenizer->GetEnvelope();
+      return Value::parseBinary(env.data(), env.size());
+    }
+    // Intentionally not supported.
+    case cbor::CBORTokenTag::BINARY:
+    // Should not be encountered outside of envelope.
+    case cbor::CBORTokenTag::MAP_START:
+    case cbor::CBORTokenTag::ARRAY_START:
+    default:
+      state->RegisterError(Error::CBOR_UNSUPPORTED_VALUE);
+      return nullptr;
+  }
+}
+
+}  // namespace
+
+// static
+bool ProtocolTypeTraits<std::unique_ptr<Value>>::Deserialize(
+    DeserializerState* state, std::unique_ptr<Value>* value) {
+  auto result = ReadValue(state);
+  if (!result)
+    return false;
+  *value = std::move(result);
+  return true;
+}
+
+// static
+void ProtocolTypeTraits<std::unique_ptr<Value>>::Serialize(
+    const std::unique_ptr<Value>& value, std::vector<uint8_t>* bytes) {
+  value->AppendSerialized(bytes);
+}
+
+// static
+bool ProtocolTypeTraits<std::unique_ptr<DictionaryValue>>::Deserialize(
+    DeserializerState* state, std::unique_ptr<DictionaryValue>* value) {
+  std::unique_ptr<Value> res;
+  if (!ProtocolTypeTraits<std::unique_ptr<Value>>::Deserialize(state, &res))
+    return false;
+  if (res->type() != Value::TypeObject) {
+    state->RegisterError(Error::BINDINGS_DICTIONARY_VALUE_EXPECTED);
+    return false;
+  }
+  *value = DictionaryValue::cast(std::move(res));
+  return true;
+}
+
+// static
+void ProtocolTypeTraits<std::unique_ptr<DictionaryValue>>::Serialize(
+    const std::unique_ptr<DictionaryValue>& value, std::vector<uint8_t>* bytes) {
+  value->AppendSerialized(bytes);
+}
+
+// static
+bool ProtocolTypeTraits<std::unique_ptr<Object>>::Deserialize(DeserializerState* state, std::unique_ptr<Object>* value) {
+  auto res = DictionaryValue::create();
+  if (ProtocolTypeTraits<std::unique_ptr<DictionaryValue>>::Deserialize(state, &res)) {
+    *value = std::make_unique<Object>(std::move(res));
+    return true;
+  }
+  return false;
+}
+
+void ProtocolTypeTraits<std::unique_ptr<Object>>::Serialize(const std::unique_ptr<Object>& value, std::vector<uint8_t>* bytes) {
+  value->AppendSerialized(bytes);
+}
+
+}  // namespace {{config.crdtp.namespace}}
diff --git a/tools/inspector_protocol/lib/ValueConversions_h.template b/tools/inspector_protocol/lib/ValueConversions_h.template
index 63baf689c6e11c..bf05014f10154f 100644
--- a/tools/inspector_protocol/lib/ValueConversions_h.template
+++ b/tools/inspector_protocol/lib/ValueConversions_h.template
@@ -1,6 +1,6 @@
 // This file is generated by ValueConversions_h.template.
 
-// Copyright 2016 The Chromium Authors. All rights reserved.
+// Copyright 2016 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -40,7 +40,7 @@ struct ValueConversions<bool> {
         bool result = false;
         bool success = value ? value->asBoolean(&result) : false;
         if (!success)
-            errors->addError("boolean value expected");
+            errors->AddError("boolean value expected");
         return result;
     }
 
@@ -57,7 +57,7 @@ struct ValueConversions<int> {
         int result = 0;
         bool success = value ? value->asInteger(&result) : false;
         if (!success)
-            errors->addError("integer value expected");
+            errors->AddError("integer value expected");
         return result;
     }
 
@@ -74,7 +74,7 @@ struct ValueConversions<double> {
         double result = 0;
         bool success = value ? value->asDouble(&result) : false;
         if (!success)
-            errors->addError("double value expected");
+            errors->AddError("double value expected");
         return result;
     }
 
@@ -91,7 +91,7 @@ struct ValueConversions<String> {
         String result;
         bool success = value ? value->asString(&result) : false;
         if (!success)
-            errors->addError("string value expected");
+            errors->AddError("string value expected");
         return result;
     }
 
@@ -107,7 +107,7 @@ struct ValueConversions<Binary> {
     {
         if (!value ||
             (value->type() != Value::TypeBinary && value->type() != Value::TypeString)) {
-            errors->addError("Either string base64 or binary value expected");
+            errors->AddError("Either string base64 or binary value expected");
             return Binary();
         }
         Binary binary;
@@ -118,7 +118,7 @@ struct ValueConversions<Binary> {
         bool success;
         Binary out = Binary::fromBase64(result, &success);
         if (!success)
-          errors->addError("base64 decoding error");
+          errors->AddError("base64 decoding error");
         return out;
     }
 
@@ -133,20 +133,20 @@ struct ValueConversions<std::vector<std::unique_ptr<T>>> {
     static std::unique_ptr<std::vector<std::unique_ptr<T>>> fromValue(protocol::Value* value, ErrorSupport* errors) {
         protocol::ListValue* array = ListValue::cast(value);
         if (!array) {
-            errors->addError("array expected");
+            errors->AddError("array expected");
             return nullptr;
         }
-        errors->push();
+        errors->Push();
         std::unique_ptr<std::vector<std::unique_ptr<T>>> result(
             new std::vector<std::unique_ptr<T>>());
         result->reserve(array->size());
         for (size_t i = 0; i < array->size(); ++i) {
-            errors->setName(StringUtil::fromInteger(i));
+            errors->SetIndex(i);
             auto item = ValueConversions<T>::fromValue(array->at(i), errors);
             result->emplace_back(std::move(item));
         }
-        errors->pop();
-        if (errors->hasErrors())
+        errors->Pop();
+        if (!errors->Errors().empty())
             return nullptr;
         return result;
     }
@@ -167,19 +167,19 @@ struct ValueConversions<std::vector<T>> {
     static std::unique_ptr<std::vector<T>> fromValue(protocol::Value* value, ErrorSupport* errors) {
         protocol::ListValue* array = ListValue::cast(value);
         if (!array) {
-            errors->addError("array expected");
+            errors->AddError("array expected");
             return nullptr;
         }
-        errors->push();
+        errors->Push();
         std::unique_ptr<std::vector<T>> result(new std::vector<T>());
         result->reserve(array->size());
         for (size_t i = 0; i < array->size(); ++i) {
-            errors->setName(StringUtil::fromInteger(i));
+            errors->SetIndex(i);
             auto item = ValueConversions<T>::fromValue(array->at(i), errors);
             result->emplace_back(std::move(item));
         }
-        errors->pop();
-        if (errors->hasErrors())
+        errors->Pop();
+        if (!errors->Errors().empty())
             return nullptr;
         return result;
     }
@@ -200,7 +200,7 @@ struct ValueConversions<Value> {
     {
         bool success = !!value;
         if (!success) {
-            errors->addError("value expected");
+            errors->AddError("value expected");
             return nullptr;
         }
         return value->clone();
@@ -223,7 +223,7 @@ struct ValueConversions<DictionaryValue> {
     {
         bool success = value && value->type() == protocol::Value::TypeObject;
         if (!success)
-            errors->addError("object expected");
+            errors->AddError("object expected");
         return DictionaryValue::cast(value->clone());
     }
 
@@ -244,7 +244,7 @@ struct ValueConversions<ListValue> {
     {
         bool success = value && value->type() == protocol::Value::TypeArray;
         if (!success)
-            errors->addError("list expected");
+            errors->AddError("list expected");
         return ListValue::cast(value->clone());
     }
 
@@ -259,8 +259,61 @@ struct ValueConversions<ListValue> {
     }
 };
 
+template<typename T> struct ValueTypeConverter {
+  static std::unique_ptr<T> FromValue(const protocol::Value& value) {
+    std::vector<uint8_t> bytes;
+    value.AppendSerialized(&bytes);
+    return T::FromBinary(bytes.data(), bytes.size());
+  }
+
+  static std::unique_ptr<protocol::DictionaryValue> ToValue(const T& obj) {
+    std::vector<uint8_t> bytes;
+    obj.AppendSerialized(&bytes);
+    auto result = Value::parseBinary(bytes.data(), bytes.size());
+    return DictionaryValue::cast(std::move(result));
+  }
+};
+
 {% for namespace in config.protocol.namespace %}
 } // namespace {{namespace}}
 {% endfor %}
 
+namespace {{config.crdtp.namespace}} {
+
+template<typename T>
+struct ProtocolTypeTraits<T,
+     typename std::enable_if<std::is_base_of<{{"::".join(config.protocol.namespace)}}::Value, T>::value>::type> {
+  static void Serialize(const {{"::".join(config.protocol.namespace)}}::Value& value, std::vector<uint8_t>* bytes) {
+    value.AppendSerialized(bytes);
+  }
+};
+
+template <>
+struct ProtocolTypeTraits<std::unique_ptr<{{"::".join(config.protocol.namespace)}}::Value>> {
+  static bool Deserialize(DeserializerState* state, std::unique_ptr<{{"::".join(config.protocol.namespace)}}::Value>* value);
+  static void Serialize(const std::unique_ptr<{{"::".join(config.protocol.namespace)}}::Value>& value, std::vector<uint8_t>* bytes);
+};
+
+template <>
+struct ProtocolTypeTraits<std::unique_ptr<{{"::".join(config.protocol.namespace)}}::DictionaryValue>> {
+  static bool Deserialize(DeserializerState* state, std::unique_ptr<{{"::".join(config.protocol.namespace)}}::DictionaryValue>* value);
+  static void Serialize(const std::unique_ptr<{{"::".join(config.protocol.namespace)}}::DictionaryValue>& value, std::vector<uint8_t>* bytes);
+};
+
+// TODO(caseq): get rid of it, it's just a DictionaryValue really.
+template <>
+struct ProtocolTypeTraits<std::unique_ptr<{{"::".join(config.protocol.namespace)}}::Object>> {
+  static bool Deserialize(DeserializerState* state, std::unique_ptr<{{"::".join(config.protocol.namespace)}}::Object>* value);
+  static void Serialize(const std::unique_ptr<{{"::".join(config.protocol.namespace)}}::Object>& value, std::vector<uint8_t>* bytes);
+};
+
+template<>
+struct ProtocolTypeTraits<{{"::".join(config.protocol.namespace)}}::Object> {
+  static void Serialize(const {{"::".join(config.protocol.namespace)}}::Object& value, std::vector<uint8_t>* bytes) {
+    value.AppendSerialized(bytes);
+  }
+};
+
+}  // namespace {{config.crdtp.namespace}}
+
 #endif // !defined({{"_".join(config.protocol.namespace)}}_ValueConversions_h)
diff --git a/tools/inspector_protocol/lib/Values_cpp.template b/tools/inspector_protocol/lib/Values_cpp.template
index 8b4dfc91e3b9c9..dbc51694db2fa6 100644
--- a/tools/inspector_protocol/lib/Values_cpp.template
+++ b/tools/inspector_protocol/lib/Values_cpp.template
@@ -1,256 +1,193 @@
 // This file is generated by Values_cpp.template.
 
-// Copyright 2016 The Chromium Authors. All rights reserved.
+// Copyright 2016 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 //#include "Values.h"
 
-{% if config.encoding_lib.header %}
-#include "{{config.encoding_lib.header}}"
-{% endif %}
+#include "{{config.crdtp.dir}}/cbor.h"
 
 {% for namespace in config.protocol.namespace %}
 namespace {{namespace}} {
 {% endfor %}
 
 namespace {
+using {{config.crdtp.namespace}}::Status;
+using {{config.crdtp.namespace}}::ParserHandler;
+using {{config.crdtp.namespace}}::span;
+namespace cbor {
+using {{config.crdtp.namespace}}::cbor::ParseCBOR;
+using {{config.crdtp.namespace}}::cbor::EncodeBinary;
+using {{config.crdtp.namespace}}::cbor::EncodeDouble;
+using {{config.crdtp.namespace}}::cbor::EncodeFalse;
+using {{config.crdtp.namespace}}::cbor::EncodeFromLatin1;
+using {{config.crdtp.namespace}}::cbor::EncodeFromUTF16;
+using {{config.crdtp.namespace}}::cbor::EncodeIndefiniteLengthArrayStart;
+using {{config.crdtp.namespace}}::cbor::EncodeIndefiniteLengthMapStart;
+using {{config.crdtp.namespace}}::cbor::EncodeInt32;
+using {{config.crdtp.namespace}}::cbor::EncodeNull;
+using {{config.crdtp.namespace}}::cbor::EncodeStop;
+using {{config.crdtp.namespace}}::cbor::EncodeString8;
+using {{config.crdtp.namespace}}::cbor::EncodeTrue;
+using {{config.crdtp.namespace}}::cbor::EnvelopeEncoder;
+}  // namespace cbor
 
-const char* const nullValueString = "null";
-const char* const trueValueString = "true";
-const char* const falseValueString = "false";
+// Uses the parsing events received from driver of |ParserHandler|
+// (e.g. cbor::ParseCBOR) into a protocol::Value instance.
+class ValueParserHandler : public ParserHandler {
+ public:
+   // Provides the parsed protocol::Value.
+   std::unique_ptr<Value> ReleaseRoot() { return std::move(root_); }
+
+   // The first parsing error encountered; |status().ok()| is the default.
+   Status status() const { return status_; }
+
+ private:
+  //
+  // Implementation of  ParserHandler.
+  //
+  void HandleMapBegin() override {
+    if (!status_.ok()) return;
+    std::unique_ptr<DictionaryValue> dict = DictionaryValue::create();
+    DictionaryValue* dict_ptr = dict.get();
+    AddValueToParent(std::move(dict));
+    stack_.emplace_back(dict_ptr);
+  }
 
-inline bool escapeChar(uint16_t c, StringBuilder* dst)
-{
-    switch (c) {
-    case '\b': StringUtil::builderAppend(*dst, "\\b"); break;
-    case '\f': StringUtil::builderAppend(*dst, "\\f"); break;
-    case '\n': StringUtil::builderAppend(*dst, "\\n"); break;
-    case '\r': StringUtil::builderAppend(*dst, "\\r"); break;
-    case '\t': StringUtil::builderAppend(*dst, "\\t"); break;
-    case '\\': StringUtil::builderAppend(*dst, "\\\\"); break;
-    case '"': StringUtil::builderAppend(*dst, "\\\""); break;
-    default:
-        return false;
-    }
-    return true;
-}
+  void HandleMapEnd() override {
+    if (!status_.ok()) return;
+    DCHECK(!stack_.empty());
+    DCHECK(stack_.back().is_dict);
+    stack_.pop_back();
+  }
 
-const char hexDigits[17] = "0123456789ABCDEF";
+  void HandleArrayBegin() override {
+    if (!status_.ok()) return;
+    std::unique_ptr<ListValue> list = ListValue::create();
+    ListValue* list_ptr = list.get();
+    AddValueToParent(std::move(list));
+    stack_.emplace_back(list_ptr);
+  }
 
-void appendUnsignedAsHex(uint16_t number, StringBuilder* dst)
-{
-    StringUtil::builderAppend(*dst, "\\u");
-    for (size_t i = 0; i < 4; ++i) {
-        uint16_t c = hexDigits[(number & 0xF000) >> 12];
-        StringUtil::builderAppend(*dst, c);
-        number <<= 4;
-    }
-}
+  void HandleArrayEnd() override {
+    if (!status_.ok()) return;
+    DCHECK(!stack_.empty());
+    DCHECK(!stack_.back().is_dict);
+    stack_.pop_back();
+  }
 
-template <typename Char>
-void escapeStringForJSONInternal(const Char* str, unsigned len,
-                                 StringBuilder* dst)
-{
-    for (unsigned i = 0; i < len; ++i) {
-        Char c = str[i];
-        if (escapeChar(c, dst))
-            continue;
-        if (c < 32 || c > 126) {
-            appendUnsignedAsHex(c, dst);
-        } else {
-            StringUtil::builderAppend(*dst, c);
-        }
-    }
-}
+  void HandleString8(span<uint8_t> chars) override {
+    AddStringToParent(StringUtil::fromUTF8(chars.data(), chars.size()));
+  }
 
-// When parsing CBOR, we limit recursion depth for objects and arrays
-// to this constant.
-static constexpr int kStackLimitValues = 1000;
+  void HandleString16(span<uint16_t> chars) override {
+    AddStringToParent(
+        StringUtil::fromUTF16LE(chars.data(), chars.size()));
+  }
 
-{% if config.encoding_lib.namespace %}
-using {{"::".join(config.encoding_lib.namespace)}}::Error;
-using {{"::".join(config.encoding_lib.namespace)}}::Status;
-using {{"::".join(config.encoding_lib.namespace)}}::span;
-namespace cbor {
-using {{"::".join(config.encoding_lib.namespace + ['cbor'])}}::CBORTokenTag;
-using {{"::".join(config.encoding_lib.namespace + ['cbor'])}}::CBORTokenizer;
-using {{"::".join(config.encoding_lib.namespace + ['cbor'])}}::EncodeBinary;
-using {{"::".join(config.encoding_lib.namespace + ['cbor'])}}::EncodeDouble;
-using {{"::".join(config.encoding_lib.namespace + ['cbor'])}}::EncodeFalse;
-using {{"::".join(config.encoding_lib.namespace + ['cbor'])}}::EncodeFromLatin1;
-using {{"::".join(config.encoding_lib.namespace + ['cbor'])}}::EncodeFromUTF16;
-using {{"::".join(config.encoding_lib.namespace + ['cbor'])}}::EncodeIndefiniteLengthArrayStart;
-using {{"::".join(config.encoding_lib.namespace + ['cbor'])}}::EncodeIndefiniteLengthMapStart;
-using {{"::".join(config.encoding_lib.namespace + ['cbor'])}}::EncodeInt32;
-using {{"::".join(config.encoding_lib.namespace + ['cbor'])}}::EncodeNull;
-using {{"::".join(config.encoding_lib.namespace + ['cbor'])}}::EncodeStop;
-using {{"::".join(config.encoding_lib.namespace + ['cbor'])}}::EncodeString8;
-using {{"::".join(config.encoding_lib.namespace + ['cbor'])}}::EncodeTrue;
-using {{"::".join(config.encoding_lib.namespace + ['cbor'])}}::EnvelopeEncoder;
-using {{"::".join(config.encoding_lib.namespace + ['cbor'])}}::InitialByteForEnvelope;
-}  // namespace cbor
-{% endif %}
-
-// Below are three parsing routines for CBOR, which cover enough
-// to roundtrip JSON messages.
-std::unique_ptr<DictionaryValue> parseMap(int32_t stack_depth, cbor::CBORTokenizer* tokenizer);
-std::unique_ptr<ListValue> parseArray(int32_t stack_depth, cbor::CBORTokenizer* tokenizer);
-std::unique_ptr<Value> parseValue(int32_t stack_depth, cbor::CBORTokenizer* tokenizer);
-
-// |bytes| must start with the indefinite length array byte, so basically,
-// ParseArray may only be called after an indefinite length array has been
-// detected.
-std::unique_ptr<ListValue> parseArray(int32_t stack_depth, cbor::CBORTokenizer* tokenizer) {
-  DCHECK(tokenizer->TokenTag() == cbor::CBORTokenTag::ARRAY_START);
-  tokenizer->Next();
-  auto list = ListValue::create();
-  while (tokenizer->TokenTag() != cbor::CBORTokenTag::STOP) {
-    // Error::CBOR_UNEXPECTED_EOF_IN_ARRAY
-    if (tokenizer->TokenTag() == cbor::CBORTokenTag::DONE) return nullptr;
-    if (tokenizer->TokenTag() == cbor::CBORTokenTag::ERROR_VALUE) return nullptr;
-    // Parse value.
-    auto value = parseValue(stack_depth, tokenizer);
-    if (!value) return nullptr;
-    list->pushValue(std::move(value));
+  void HandleBinary(span<uint8_t> bytes) override {
+    AddValueToParent(
+        BinaryValue::create(Binary::fromSpan(bytes.data(), bytes.size())));
   }
-  tokenizer->Next();
-  return list;
-}
-
-std::unique_ptr<Value> parseValue(
-    int32_t stack_depth, cbor::CBORTokenizer* tokenizer) {
-  // Error::CBOR_STACK_LIMIT_EXCEEDED
-  if (stack_depth > kStackLimitValues) return nullptr;
-  // Skip past the envelope to get to what's inside.
-  if (tokenizer->TokenTag() == cbor::CBORTokenTag::ENVELOPE)
-    tokenizer->EnterEnvelope();
-  switch (tokenizer->TokenTag()) {
-    case cbor::CBORTokenTag::ERROR_VALUE:
-      return nullptr;
-    case cbor::CBORTokenTag::DONE:
-      // Error::CBOR_UNEXPECTED_EOF_EXPECTED_VALUE
-      return nullptr;
-    case cbor::CBORTokenTag::TRUE_VALUE: {
-      std::unique_ptr<Value> value = FundamentalValue::create(true);
-      tokenizer->Next();
-      return value;
-    }
-    case cbor::CBORTokenTag::FALSE_VALUE: {
-      std::unique_ptr<Value> value = FundamentalValue::create(false);
-      tokenizer->Next();
-      return value;
-    }
-    case cbor::CBORTokenTag::NULL_VALUE: {
-      std::unique_ptr<Value> value = FundamentalValue::null();
-      tokenizer->Next();
-      return value;
-    }
-    case cbor::CBORTokenTag::INT32: {
-      std::unique_ptr<Value> value = FundamentalValue::create(tokenizer->GetInt32());
-      tokenizer->Next();
-      return value;
-    }
-    case cbor::CBORTokenTag::DOUBLE: {
-      std::unique_ptr<Value> value = FundamentalValue::create(tokenizer->GetDouble());
-      tokenizer->Next();
-      return value;
-    }
-    case cbor::CBORTokenTag::STRING8: {
-      span<uint8_t> str = tokenizer->GetString8();
-      std::unique_ptr<Value> value =
-          StringValue::create(StringUtil::fromUTF8(str.data(), str.size()));
-      tokenizer->Next();
-      return value;
-    }
-    case cbor::CBORTokenTag::STRING16: {
-      span<uint8_t> wire = tokenizer->GetString16WireRep();
-      DCHECK_EQ(wire.size() & 1, 0u);
-      std::unique_ptr<Value> value = StringValue::create(StringUtil::fromUTF16(
-          reinterpret_cast<const uint16_t*>(wire.data()), wire.size() / 2));
-      tokenizer->Next();
-      return value;
-    }
-    case cbor::CBORTokenTag::BINARY: {
-      span<uint8_t> payload = tokenizer->GetBinary();
-      tokenizer->Next();
-      return BinaryValue::create(Binary::fromSpan(payload.data(), payload.size()));
-    }
-    case cbor::CBORTokenTag::MAP_START:
-      return parseMap(stack_depth + 1, tokenizer);
-    case cbor::CBORTokenTag::ARRAY_START:
-      return parseArray(stack_depth + 1, tokenizer);
-    default:
-      // Error::CBOR_UNSUPPORTED_VALUE
-      return nullptr;
+
+  void HandleDouble(double value) override {
+    AddValueToParent(FundamentalValue::create(value));
   }
-}
 
-// |bytes| must start with the indefinite length array byte, so basically,
-// ParseArray may only be called after an indefinite length array has been
-// detected.
-std::unique_ptr<DictionaryValue> parseMap(
-    int32_t stack_depth, cbor::CBORTokenizer* tokenizer) {
-  auto dict = DictionaryValue::create();
-  tokenizer->Next();
-  while (tokenizer->TokenTag() != cbor::CBORTokenTag::STOP) {
-    if (tokenizer->TokenTag() == cbor::CBORTokenTag::DONE) {
-      // Error::CBOR_UNEXPECTED_EOF_IN_MAP
-      return nullptr;
+  void HandleInt32(int32_t value) override {
+    AddValueToParent(FundamentalValue::create(value));
+  }
+
+  void HandleBool(bool value) override {
+    AddValueToParent(FundamentalValue::create(value));
+  }
+
+  void HandleNull() override {
+    AddValueToParent(Value::null());
+  }
+
+  void HandleError(Status error) override {
+    status_ = error;
+  }
+
+  //
+  // Adding strings and values to the parent value.
+  // Strings are handled separately because they can be keys for
+  // dictionary values.
+  //
+  void AddStringToParent(String str) {
+    if (!status_.ok()) return;
+    if (!root_) {
+      DCHECK(!key_is_pending_);
+      root_ = StringValue::create(str);
+    } else if (stack_.back().is_dict) {
+      // If we already have a pending key, then this is the value of the
+      // key/value pair. Otherwise, it's the new pending key.
+      if (key_is_pending_) {
+        stack_.back().dict->setString(pending_key_, str);
+        key_is_pending_ = false;
+      } else {
+        pending_key_ = std::move(str);
+        key_is_pending_ = true;
+      }
+    } else {  // Top of the stack is a list.
+      DCHECK(!key_is_pending_);
+      stack_.back().list->pushValue(StringValue::create(str));
     }
-    if (tokenizer->TokenTag() == cbor::CBORTokenTag::ERROR_VALUE) return nullptr;
-    // Parse key.
-    String key;
-    if (tokenizer->TokenTag() == cbor::CBORTokenTag::STRING8) {
-      span<uint8_t> key_span = tokenizer->GetString8();
-      key = StringUtil::fromUTF8(key_span.data(), key_span.size());
-      tokenizer->Next();
-    } else if (tokenizer->TokenTag() == cbor::CBORTokenTag::STRING16) {
-      span<uint8_t> key_span = tokenizer->GetString16WireRep();
-      if (key_span.size() & 1) return nullptr;  // UTF16 is 2 byte multiple.
-      key = StringUtil::fromUTF16(
-          reinterpret_cast<const uint16_t*>(key_span.data()),
-          key_span.size() / 2);
-      tokenizer->Next();
-    } else {
-      // Error::CBOR_INVALID_MAP_KEY
-      return nullptr;
+  }
+
+  void AddValueToParent(std::unique_ptr<Value> value) {
+    if (!status_.ok()) return;
+    if (!root_) {
+      DCHECK(!key_is_pending_);
+      root_ = std::move(value);
+    } else if (stack_.back().is_dict) {
+      DCHECK(key_is_pending_);
+      stack_.back().dict->setValue(pending_key_, std::move(value));
+      key_is_pending_ = false;
+    } else {  // Top of the stack is a list.
+      DCHECK(!key_is_pending_);
+      stack_.back().list->pushValue(std::move(value));
     }
-    // Parse value.
-    auto value = parseValue(stack_depth, tokenizer);
-    if (!value) return nullptr;
-    dict->setValue(key, std::move(value));
   }
-  tokenizer->Next();
-  return dict;
-}
 
+  // |status_.ok()| is the default; if we receive an error event
+  // we keep the first one and stop modifying any other state.
+  Status status_;
+
+  // The root of the parsed protocol::Value tree.
+  std::unique_ptr<Value> root_;
+
+  // If root_ is a list or a dictionary, this stack keeps track of
+  // the container we're currently parsing as well as its ancestors.
+  struct ContainerState {
+    ContainerState(DictionaryValue* dict) : is_dict(true), dict(dict) {}
+    ContainerState(ListValue* list) : is_dict(false), list(list) {}
+
+    bool is_dict;
+    union {
+      DictionaryValue* dict;
+      ListValue* list;
+    };
+  };
+  std::vector<ContainerState> stack_;
+
+  // For maps, keys and values are alternating events, so we keep the
+  // key around and process it when the value arrives.
+  bool key_is_pending_ = false;
+  String pending_key_;
+};
 } // anonymous namespace
 
 // static
 std::unique_ptr<Value> Value::parseBinary(const uint8_t* data, size_t size) {
-  span<uint8_t> bytes(data, size);
-
-  // Error::CBOR_NO_INPUT
-  if (bytes.empty()) return nullptr;
-
-  // Error::CBOR_INVALID_START_BYTE
-  if (bytes[0] != cbor::InitialByteForEnvelope()) return nullptr;
-
-  cbor::CBORTokenizer tokenizer(bytes);
-  if (tokenizer.TokenTag() == cbor::CBORTokenTag::ERROR_VALUE) return nullptr;
-
-  // We checked for the envelope start byte above, so the tokenizer
-  // must agree here, since it's not an error.
-  DCHECK(tokenizer.TokenTag() == cbor::CBORTokenTag::ENVELOPE);
-  tokenizer.EnterEnvelope();
-  // Error::MAP_START_EXPECTED
-  if (tokenizer.TokenTag() != cbor::CBORTokenTag::MAP_START) return nullptr;
-  std::unique_ptr<Value> result = parseMap(/*stack_depth=*/1, &tokenizer);
-  if (!result) return nullptr;
-  if (tokenizer.TokenTag() == cbor::CBORTokenTag::DONE) return result;
-  if (tokenizer.TokenTag() == cbor::CBORTokenTag::ERROR_VALUE) return nullptr;
-  // Error::CBOR_TRAILING_JUNK
+  ValueParserHandler handler;
+  cbor::ParseCBOR(span<uint8_t>(data, size), &handler);
+  // TODO(johannes): We have decent error info in handler.status(); provide
+  // a richer interface that makes this available to client code.
+  if (handler.status().ok())
+    return handler.ReleaseRoot();
   return nullptr;
 }
 
@@ -279,13 +216,7 @@ bool Value::asBinary(Binary*) const
     return false;
 }
 
-void Value::writeJSON(StringBuilder* output) const
-{
-    DCHECK(m_type == TypeNull);
-    StringUtil::builderAppend(*output, nullValueString, 4);
-}
-
-void Value::writeBinary(std::vector<uint8_t>* bytes) const {
+void Value::AppendSerialized(std::vector<uint8_t>* bytes) const {
     DCHECK(m_type == TypeNull);
     bytes->push_back(cbor::EncodeNull());
 }
@@ -295,24 +226,6 @@ std::unique_ptr<Value> Value::clone() const
     return Value::null();
 }
 
-String Value::toJSONString() const
-{
-    StringBuilder result;
-    StringUtil::builderReserve(result, 512);
-    writeJSON(&result);
-    return StringUtil::builderToString(result);
-}
-
-String Value::serializeToJSON() {
-    return toJSONString();
-}
-
-std::vector<uint8_t> Value::serializeToBinary() {
-    std::vector<uint8_t> bytes;
-    writeBinary(&bytes);
-    return bytes;
-}
-
 bool FundamentalValue::asBoolean(bool* output) const
 {
     if (type() != TypeBoolean)
@@ -342,26 +255,7 @@ bool FundamentalValue::asInteger(int* output) const
     return true;
 }
 
-void FundamentalValue::writeJSON(StringBuilder* output) const
-{
-    DCHECK(type() == TypeBoolean || type() == TypeInteger || type() == TypeDouble);
-    if (type() == TypeBoolean) {
-        if (m_boolValue)
-            StringUtil::builderAppend(*output, trueValueString, 4);
-        else
-            StringUtil::builderAppend(*output, falseValueString, 5);
-    } else if (type() == TypeDouble) {
-        if (!std::isfinite(m_doubleValue)) {
-            StringUtil::builderAppend(*output, nullValueString, 4);
-            return;
-        }
-        StringUtil::builderAppend(*output, StringUtil::fromDouble(m_doubleValue));
-    } else if (type() == TypeInteger) {
-        StringUtil::builderAppend(*output, StringUtil::fromInteger(m_integerValue));
-    }
-}
-
-void FundamentalValue::writeBinary(std::vector<uint8_t>* bytes) const {
+void FundamentalValue::AppendSerialized(std::vector<uint8_t>* bytes) const {
     switch (type()) {
     case TypeDouble:
         cbor::EncodeDouble(m_doubleValue, bytes);
@@ -395,12 +289,6 @@ bool StringValue::asString(String* output) const
     return true;
 }
 
-void StringValue::writeJSON(StringBuilder* output) const
-{
-    DCHECK(type() == TypeString);
-    StringUtil::builderAppendQuotedString(*output, m_stringValue);
-}
-
 namespace {
 // This routine distinguishes between the current encoding for a given
 // string |s|, and calls encoding routines that will
@@ -429,8 +317,7 @@ void EncodeString(const String& s, std::vector<uint8_t>* out) {
   }
 }
 }  // namespace
-
-void StringValue::writeBinary(std::vector<uint8_t>* bytes) const {
+void StringValue::AppendSerialized(std::vector<uint8_t>* bytes) const {
   EncodeString(m_stringValue, bytes);
 }
 
@@ -445,13 +332,7 @@ bool BinaryValue::asBinary(Binary* output) const
     return true;
 }
 
-void BinaryValue::writeJSON(StringBuilder* output) const
-{
-    DCHECK(type() == TypeBinary);
-    StringUtil::builderAppendQuotedString(*output, m_binaryValue.toBase64());
-}
-
-void BinaryValue::writeBinary(std::vector<uint8_t>* bytes) const {
+void BinaryValue::AppendSerialized(std::vector<uint8_t>* bytes) const {
     cbor::EncodeBinary(span<uint8_t>(m_binaryValue.data(),
                                      m_binaryValue.size()), bytes);
 }
@@ -461,22 +342,6 @@ std::unique_ptr<Value> BinaryValue::clone() const
     return BinaryValue::create(m_binaryValue);
 }
 
-void SerializedValue::writeJSON(StringBuilder* output) const
-{
-    DCHECK(type() == TypeSerialized);
-    StringUtil::builderAppend(*output, m_serializedJSON);
-}
-
-void SerializedValue::writeBinary(std::vector<uint8_t>* output) const
-{
-    DCHECK(type() == TypeSerialized);
-    output->insert(output->end(), m_serializedBinary.begin(), m_serializedBinary.end());
-}
-
-std::unique_ptr<Value> SerializedValue::clone() const
-{
-    return std::unique_ptr<SerializedValue>(new SerializedValue(m_serializedJSON, m_serializedBinary));
-}
 
 DictionaryValue::~DictionaryValue()
 {
@@ -600,22 +465,7 @@ void DictionaryValue::remove(const String& name)
     m_order.erase(std::remove(m_order.begin(), m_order.end(), name), m_order.end());
 }
 
-void DictionaryValue::writeJSON(StringBuilder* output) const
-{
-    StringUtil::builderAppend(*output, '{');
-    for (size_t i = 0; i < m_order.size(); ++i) {
-        Dictionary::const_iterator it = m_data.find(m_order[i]);
-        CHECK(it != m_data.end());
-        if (i)
-            StringUtil::builderAppend(*output, ',');
-        StringUtil::builderAppendQuotedString(*output, it->first);
-        StringUtil::builderAppend(*output, ':');
-        it->second->writeJSON(output);
-    }
-    StringUtil::builderAppend(*output, '}');
-}
-
-void DictionaryValue::writeBinary(std::vector<uint8_t>* bytes) const {
+void DictionaryValue::AppendSerialized(std::vector<uint8_t>* bytes) const {
     cbor::EnvelopeEncoder encoder;
     encoder.EncodeStart(bytes);
     bytes->push_back(cbor::EncodeIndefiniteLengthMapStart());
@@ -624,7 +474,7 @@ void DictionaryValue::writeBinary(std::vector<uint8_t>* bytes) const {
         Dictionary::const_iterator value = m_data.find(key);
         DCHECK(value != m_data.cend() && value->second);
         EncodeString(key, bytes);
-        value->second->writeBinary(bytes);
+        value->second->AppendSerialized(bytes);
     }
     bytes->push_back(cbor::EncodeStop());
     encoder.EncodeStop(bytes);
@@ -651,25 +501,12 @@ ListValue::~ListValue()
 {
 }
 
-void ListValue::writeJSON(StringBuilder* output) const
-{
-    StringUtil::builderAppend(*output, '[');
-    bool first = true;
-    for (const std::unique_ptr<protocol::Value>& value : m_data) {
-        if (!first)
-            StringUtil::builderAppend(*output, ',');
-        value->writeJSON(output);
-        first = false;
-    }
-    StringUtil::builderAppend(*output, ']');
-}
-
-void ListValue::writeBinary(std::vector<uint8_t>* bytes) const {
+void ListValue::AppendSerialized(std::vector<uint8_t>* bytes) const {
     cbor::EnvelopeEncoder encoder;
     encoder.EncodeStart(bytes);
     bytes->push_back(cbor::EncodeIndefiniteLengthArrayStart());
     for (size_t i = 0; i < m_data.size(); ++i) {
-        m_data[i]->writeBinary(bytes);
+        m_data[i]->AppendSerialized(bytes);
     }
     bytes->push_back(cbor::EncodeStop());
     encoder.EncodeStop(bytes);
@@ -700,16 +537,6 @@ protocol::Value* ListValue::at(size_t index)
     return m_data[index].get();
 }
 
-void escapeLatinStringForJSON(const uint8_t* str, unsigned len, StringBuilder* dst)
-{
-    escapeStringForJSONInternal<uint8_t>(str, len, dst);
-}
-
-void escapeWideStringForJSON(const uint16_t* str, unsigned len, StringBuilder* dst)
-{
-    escapeStringForJSONInternal<uint16_t>(str, len, dst);
-}
-
 {% for namespace in config.protocol.namespace %}
 } // namespace {{namespace}}
 {% endfor %}
diff --git a/tools/inspector_protocol/lib/Values_h.template b/tools/inspector_protocol/lib/Values_h.template
index 4d6fde07d4df2c..30cd0e16323517 100644
--- a/tools/inspector_protocol/lib/Values_h.template
+++ b/tools/inspector_protocol/lib/Values_h.template
@@ -1,6 +1,6 @@
 // This file is generated by Values_h.template.
 
-// Copyright 2016 The Chromium Authors. All rights reserved.
+// Copyright 2016 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -10,6 +10,13 @@
 //#include "Allocator.h"
 //#include "Forward.h"
 
+#include <memory>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+#include {{format_include(config.protocol.package, "Forward")}}
+
 {% for namespace in config.protocol.namespace %}
 namespace {{namespace}} {
 {% endfor %}
@@ -18,6 +25,11 @@ class ListValue;
 class DictionaryValue;
 class Value;
 
+#define PROTOCOL_DISALLOW_COPY(ClassName) \
+ private:                                 \
+  ClassName(const ClassName&) = delete;   \
+  ClassName& operator=(const ClassName&) = delete
+
 class {{config.lib.export_macro}} Value : public Serializable {
     PROTOCOL_DISALLOW_COPY(Value);
 public:
@@ -39,7 +51,6 @@ public:
         TypeBinary,
         TypeObject,
         TypeArray,
-        TypeSerialized,
         TypeImported
     };
 
@@ -53,12 +64,8 @@ public:
     virtual bool asString(String* output) const;
     virtual bool asBinary(Binary* output) const;
 
-    virtual void writeJSON(StringBuilder* output) const;
-    virtual void writeBinary(std::vector<uint8_t>* bytes) const;
+    virtual void AppendSerialized(std::vector<uint8_t>* bytes) const override;
     virtual std::unique_ptr<Value> clone() const;
-    String toJSONString() const;
-    String serializeToJSON() override;
-    std::vector<uint8_t> serializeToBinary() override;
 
 protected:
     Value() : m_type(TypeNull) { }
@@ -91,8 +98,7 @@ public:
     bool asBoolean(bool* output) const override;
     bool asDouble(double* output) const override;
     bool asInteger(int* output) const override;
-    void writeJSON(StringBuilder* output) const override;
-    void writeBinary(std::vector<uint8_t>* bytes) const override;
+    void AppendSerialized(std::vector<uint8_t>* bytes) const override;
     std::unique_ptr<Value> clone() const override;
 
 private:
@@ -120,8 +126,7 @@ public:
     }
 
     bool asString(String* output) const override;
-    void writeJSON(StringBuilder* output) const override;
-    void writeBinary(std::vector<uint8_t>* bytes) const override;
+    void AppendSerialized(std::vector<uint8_t>* bytes) const override;
     std::unique_ptr<Value> clone() const override;
 
 private:
@@ -139,8 +144,7 @@ public:
     }
 
     bool asBinary(Binary* output) const override;
-    void writeJSON(StringBuilder* output) const override;
-    void writeBinary(std::vector<uint8_t>* bytes) const override;
+    void AppendSerialized(std::vector<uint8_t>* bytes) const override;
     std::unique_ptr<Value> clone() const override;
 
 private:
@@ -149,31 +153,6 @@ private:
     Binary m_binaryValue;
 };
 
-class {{config.lib.export_macro}} SerializedValue : public Value {
-public:
-    static std::unique_ptr<SerializedValue> fromJSON(const String& value)
-    {
-        return std::unique_ptr<SerializedValue>(new SerializedValue(value));
-    }
-
-    static std::unique_ptr<SerializedValue> fromBinary(std::vector<uint8_t> value)
-    {
-        return std::unique_ptr<SerializedValue>(new SerializedValue(std::move(value)));
-    }
-
-    void writeJSON(StringBuilder* output) const override;
-    void writeBinary(std::vector<uint8_t>* bytes) const override;
-    std::unique_ptr<Value> clone() const override;
-
-private:
-    explicit SerializedValue(const String& json) : Value(TypeSerialized), m_serializedJSON(json) { }
-    explicit SerializedValue(std::vector<uint8_t> binary) : Value(TypeSerialized), m_serializedBinary(std::move(binary)) { }
-    SerializedValue(const String& json, const std::vector<uint8_t>& binary)
-        : Value(TypeSerialized), m_serializedJSON(json), m_serializedBinary(binary) { }
-    String m_serializedJSON;
-    std::vector<uint8_t> m_serializedBinary;
-};
-
 class {{config.lib.export_macro}} DictionaryValue : public Value {
 public:
     using Entry = std::pair<String, Value*>;
@@ -191,11 +170,12 @@ public:
 
     static std::unique_ptr<DictionaryValue> cast(std::unique_ptr<Value> value)
     {
-        return std::unique_ptr<DictionaryValue>(DictionaryValue::cast(value.release()));
+        DictionaryValue* dictionaryValue = cast(value.get());
+        if (dictionaryValue) value.release();
+        return std::unique_ptr<DictionaryValue>(dictionaryValue);
     }
 
-    void writeJSON(StringBuilder* output) const override;
-    void writeBinary(std::vector<uint8_t>* bytes) const override;
+    void AppendSerialized(std::vector<uint8_t>* bytes) const override;
     std::unique_ptr<Value> clone() const override;
 
     size_t size() const { return m_data.size(); }
@@ -258,13 +238,14 @@ public:
 
     static std::unique_ptr<ListValue> cast(std::unique_ptr<Value> value)
     {
-        return std::unique_ptr<ListValue>(ListValue::cast(value.release()));
+        ListValue* listValue = cast(value.get());
+        if (listValue) value.release();
+        return std::unique_ptr<ListValue>(listValue);
     }
 
     ~ListValue() override;
 
-    void writeJSON(StringBuilder* output) const override;
-    void writeBinary(std::vector<uint8_t>* bytes) const override;
+    void AppendSerialized(std::vector<uint8_t>* bytes) const override;
     std::unique_ptr<Value> clone() const override;
 
     void pushValue(std::unique_ptr<Value>);
@@ -278,9 +259,6 @@ private:
     std::vector<std::unique_ptr<Value>> m_data;
 };
 
-void escapeLatinStringForJSON(const uint8_t* str, unsigned len, StringBuilder* dst);
-void escapeWideStringForJSON(const uint16_t* str, unsigned len, StringBuilder* dst);
-
 {% for namespace in config.protocol.namespace %}
 } // namespace {{namespace}}
 {% endfor %}
diff --git a/tools/inspector_protocol/lib/base_string_adapter_cc.template b/tools/inspector_protocol/lib/base_string_adapter_cc.template
deleted file mode 100644
index af078b8e8ae729..00000000000000
--- a/tools/inspector_protocol/lib/base_string_adapter_cc.template
+++ /dev/null
@@ -1,230 +0,0 @@
-// This file is generated by DispatcherBase_cpp.template.
-
-// Copyright 2019 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include {{format_include(config.protocol.package, "base_string_adapter")}}
-#include {{format_include(config.protocol.package, "Protocol")}}
-
-#include <utility>
-#include "base/base64.h"
-#include "base/json/json_reader.h"
-#include "base/memory/ptr_util.h"
-#include "base/strings/string16.h"
-#include "base/strings/stringprintf.h"
-#include "base/strings/utf_string_conversions.h"
-#include "base/values.h"
-
-{% for namespace in config.protocol.namespace %}
-namespace {{namespace}} {
-{% endfor %}
-
-std::unique_ptr<protocol::Value> toProtocolValue(
-    const base::Value* value, int depth) {
-  if (!value || !depth)
-    return nullptr;
-  if (value->is_none())
-    return protocol::Value::null();
-  if (value->is_bool()) {
-    bool inner;
-    value->GetAsBoolean(&inner);
-    return protocol::FundamentalValue::create(inner);
-  }
-  if (value->is_int()) {
-    int inner;
-    value->GetAsInteger(&inner);
-    return protocol::FundamentalValue::create(inner);
-  }
-  if (value->is_double()) {
-    double inner;
-    value->GetAsDouble(&inner);
-    return protocol::FundamentalValue::create(inner);
-  }
-  if (value->is_string()) {
-    std::string inner;
-    value->GetAsString(&inner);
-    return protocol::StringValue::create(inner);
-  }
-  if (value->is_list()) {
-    const base::ListValue* list = nullptr;
-    value->GetAsList(&list);
-    std::unique_ptr<protocol::ListValue> result = protocol::ListValue::create();
-    for (size_t i = 0; i < list->GetSize(); i++) {
-      const base::Value* item = nullptr;
-      list->Get(i, &item);
-      std::unique_ptr<protocol::Value> converted =
-          toProtocolValue(item, depth - 1);
-      if (converted)
-        result->pushValue(std::move(converted));
-    }
-    return std::move(result);
-  }
-  if (value->is_dict()) {
-    const base::DictionaryValue* dictionary = nullptr;
-    value->GetAsDictionary(&dictionary);
-    std::unique_ptr<protocol::DictionaryValue> result =
-        protocol::DictionaryValue::create();
-    for (base::DictionaryValue::Iterator it(*dictionary);
-        !it.IsAtEnd(); it.Advance()) {
-      std::unique_ptr<protocol::Value> converted =
-          toProtocolValue(&it.value(), depth - 1);
-      if (converted)
-        result->setValue(it.key(), std::move(converted));
-    }
-    return std::move(result);
-  }
-  return nullptr;
-}
-
-std::unique_ptr<base::Value> toBaseValue(Value* value, int depth) {
-  if (!value || !depth)
-    return nullptr;
-  if (value->type() == Value::TypeNull)
-    return std::make_unique<base::Value>();
-  if (value->type() == Value::TypeBoolean) {
-    bool inner;
-    value->asBoolean(&inner);
-    return base::WrapUnique(new base::Value(inner));
-  }
-  if (value->type() == Value::TypeInteger) {
-    int inner;
-    value->asInteger(&inner);
-    return base::WrapUnique(new base::Value(inner));
-  }
-  if (value->type() == Value::TypeDouble) {
-    double inner;
-    value->asDouble(&inner);
-    return base::WrapUnique(new base::Value(inner));
-  }
-  if (value->type() == Value::TypeString) {
-    std::string inner;
-    value->asString(&inner);
-    return base::WrapUnique(new base::Value(inner));
-  }
-  if (value->type() == Value::TypeArray) {
-    ListValue* list = ListValue::cast(value);
-    std::unique_ptr<base::ListValue> result(new base::ListValue());
-    for (size_t i = 0; i < list->size(); i++) {
-      std::unique_ptr<base::Value> converted =
-          toBaseValue(list->at(i), depth - 1);
-      if (converted)
-        result->Append(std::move(converted));
-    }
-    return std::move(result);
-  }
-  if (value->type() == Value::TypeObject) {
-    DictionaryValue* dict = DictionaryValue::cast(value);
-    std::unique_ptr<base::DictionaryValue> result(new base::DictionaryValue());
-    for (size_t i = 0; i < dict->size(); i++) {
-      DictionaryValue::Entry entry = dict->at(i);
-      std::unique_ptr<base::Value> converted =
-          toBaseValue(entry.second, depth - 1);
-      if (converted)
-        result->SetWithoutPathExpansion(entry.first, std::move(converted));
-    }
-    return std::move(result);
-  }
-  return nullptr;
-}
-
-// static
-ProtocolMessage StringUtil::jsonToMessage(String message) {
-  return message;
-}
-
-// static
-ProtocolMessage StringUtil::binaryToMessage(std::vector<uint8_t> message) {
-  // TODO(pfeldman): figure out what to do with this copy.
-  return std::string(reinterpret_cast<const char*>(message.data()), message.size());
-}
-
-StringBuilder::StringBuilder() {}
-
-StringBuilder::~StringBuilder() {}
-
-void StringBuilder::append(const std::string& s) {
-  string_ += s;
-}
-
-void StringBuilder::append(char c) {
-  string_ += c;
-}
-
-void StringBuilder::append(const char* characters, size_t length) {
-  string_.append(characters, length);
-}
-
-// static
-void StringUtil::builderAppendQuotedString(StringBuilder& builder,
-                                           const String& str) {
-  builder.append('"');
-  base::string16 str16 = base::UTF8ToUTF16(str);
-  escapeWideStringForJSON(reinterpret_cast<const uint16_t*>(&str16[0]),
-                          str16.length(), &builder);
-  builder.append('"');
-}
-
-std::string StringBuilder::toString() {
-  return string_;
-}
-
-void StringBuilder::reserveCapacity(size_t capacity) {
-  string_.reserve(capacity);
-}
-
-// static
-String StringUtil::fromUTF16(const uint16_t* data, size_t length) {
-  std::string utf8;
-  base::UTF16ToUTF8(reinterpret_cast<const base::char16*>(data), length, &utf8);
-  return utf8;
-}
-
-Binary::Binary() : bytes_(new base::RefCountedBytes) {}
-Binary::Binary(const Binary& binary) : bytes_(binary.bytes_) {}
-Binary::Binary(scoped_refptr<base::RefCountedMemory> bytes) : bytes_(bytes) {}
-Binary::~Binary() {}
-
-String Binary::toBase64() const {
-  std::string encoded;
-  base::Base64Encode(
-      base::StringPiece(reinterpret_cast<const char*>(bytes_->front()),
-                        bytes_->size()),
-      &encoded);
-  return encoded;
-}
-
-// static
-Binary Binary::fromBase64(const String& base64, bool* success) {
-  std::string decoded;
-  *success = base::Base64Decode(base::StringPiece(base64), &decoded);
-  if (*success) {
-    return Binary::fromString(std::move(decoded));
-  }
-  return Binary();
-}
-
-// static
-Binary Binary::fromRefCounted(scoped_refptr<base::RefCountedMemory> memory) {
-  return Binary(memory);
-}
-
-// static
-Binary Binary::fromVector(std::vector<uint8_t> data) {
-  return Binary(base::RefCountedBytes::TakeVector(&data));
-}
-
-// static
-Binary Binary::fromString(std::string data) {
-  return Binary(base::RefCountedString::TakeString(&data));
-}
-
-// static
-Binary Binary::fromSpan(const uint8_t* data, size_t size) {
-  return Binary(scoped_refptr<base::RefCountedBytes>(
-      new base::RefCountedBytes(data, size)));
-}
-
-{% for namespace in config.protocol.namespace %}
-} // namespace {{namespace}}
-{% endfor %}
diff --git a/tools/inspector_protocol/lib/base_string_adapter_h.template b/tools/inspector_protocol/lib/base_string_adapter_h.template
deleted file mode 100644
index 46f9e1778b12bb..00000000000000
--- a/tools/inspector_protocol/lib/base_string_adapter_h.template
+++ /dev/null
@@ -1,142 +0,0 @@
-// This file is generated by Parser_h.template.
-
-// Copyright 2019 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef {{"_".join(config.protocol.namespace)}}_BASE_STRING_ADAPTER_H
-#define {{"_".join(config.protocol.namespace)}}_BASE_STRING_ADAPTER_H
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "base/logging.h"
-#include "base/macros.h"
-#include "base/memory/ref_counted_memory.h"
-#include "base/strings/string_number_conversions.h"
-{% if config.lib.export_header %}
-#include "{{config.lib.export_header}}"
-{% endif %}
-
-namespace base {
-class Value;
-}
-
-{% for namespace in config.protocol.namespace %}
-namespace {{namespace}} {
-{% endfor %}
-
-class Value;
-
-using String = std::string;
-using ProtocolMessage = std::string;
-
-class {{config.lib.export_macro}} StringBuilder {
- public:
-  StringBuilder();
-  ~StringBuilder();
-  void append(const String&);
-  void append(char);
-  void append(const char*, size_t);
-  String toString();
-  void reserveCapacity(size_t);
-
- private:
-  std::string string_;
-};
-
-class {{config.lib.export_macro}} StringUtil {
- public:
-  static String substring(const String& s, unsigned pos, unsigned len) {
-    return s.substr(pos, len);
-  }
-  static String fromInteger(int number) { return base::NumberToString(number); }
-  static String fromDouble(double number) {
-    String s = base::NumberToString(number);
-    if (!s.empty()) {  // .123 -> 0.123; -.123 -> -0.123 for valid JSON.
-      if (s[0] == '.')
-        s.insert(/*index=*/ 0, /*count=*/ 1, /*ch=*/ '0');
-      else if (s[0] == '-' && s.size() >= 2 && s[1] == '.')
-        s.insert(/*index=*/ 1, /*count=*/ 1, /*ch=*/ '0');
-    }
-    return s;
-  }
-  static double toDouble(const char* s, size_t len, bool* ok) {
-    double v = 0.0;
-    *ok = base::StringToDouble(std::string(s, len), &v);
-    return *ok ? v : 0.0;
-  }
-  static size_t find(const String& s, const char* needle) {
-    return s.find(needle);
-  }
-  static size_t find(const String& s, const String& needle) {
-    return s.find(needle);
-  }
-  static const size_t kNotFound = static_cast<size_t>(-1);
-  static void builderAppend(StringBuilder& builder, const String& s) {
-    builder.append(s);
-  }
-  static void builderAppend(StringBuilder& builder, char c) {
-    builder.append(c);
-  }
-  static void builderAppend(StringBuilder& builder, const char* s, size_t len) {
-    builder.append(s, len);
-  }
-  static void builderAppendQuotedString(StringBuilder& builder,
-                                        const String& str);
-  static void builderReserve(StringBuilder& builder, unsigned capacity) {
-    builder.reserveCapacity(capacity);
-  }
-  static String builderToString(StringBuilder& builder) {
-    return builder.toString();
-  }
-
-  static ProtocolMessage jsonToMessage(String message);
-  static ProtocolMessage binaryToMessage(std::vector<uint8_t> message);
-
-  static String fromUTF8(const uint8_t* data, size_t length) {
-    return std::string(reinterpret_cast<const char*>(data), length);
-  }
-
-  static String fromUTF16(const uint16_t* data, size_t length);
-
-  static const uint8_t* CharactersLatin1(const String& s) { return nullptr; }
-  static const uint8_t* CharactersUTF8(const String& s) {
-    return reinterpret_cast<const uint8_t*>(s.data());
-  }
-  static const uint16_t* CharactersUTF16(const String& s) { return nullptr; }
-  static size_t CharacterCount(const String& s) { return s.size(); }
-};
-
-// A read-only sequence of uninterpreted bytes with reference-counted storage.
-class {{config.lib.export_macro}} Binary {
- public:
-  Binary(const Binary&);
-  Binary();
-  ~Binary();
-
-  const uint8_t* data() const { return bytes_->front(); }
-  size_t size() const { return bytes_->size(); }
-  scoped_refptr<base::RefCountedMemory> bytes() const { return bytes_; }
-
-  String toBase64() const;
-
-  static Binary fromBase64(const String& base64, bool* success);
-  static Binary fromRefCounted(scoped_refptr<base::RefCountedMemory> memory);
-  static Binary fromVector(std::vector<uint8_t> data);
-  static Binary fromString(std::string data);
-  static Binary fromSpan(const uint8_t* data, size_t size);
-
- private:
-  explicit Binary(scoped_refptr<base::RefCountedMemory> bytes);
-  scoped_refptr<base::RefCountedMemory> bytes_;
-};
-
-std::unique_ptr<Value> toProtocolValue(const base::Value* value, int depth);
-std::unique_ptr<base::Value> toBaseValue(Value* value, int depth);
-{% for namespace in config.protocol.namespace %}
-} // namespace {{namespace}}
-{% endfor %}
-
-#endif // !defined({{"_".join(config.protocol.namespace)}}_BASE_STRING_ADAPTER_H)
diff --git a/tools/inspector_protocol/lib/encoding_cpp.template b/tools/inspector_protocol/lib/encoding_cpp.template
deleted file mode 100644
index a0377d12f7dbb1..00000000000000
--- a/tools/inspector_protocol/lib/encoding_cpp.template
+++ /dev/null
@@ -1,2203 +0,0 @@
-{# This template is generated by gen_cbor_templates.py. #}
-// Generated by lib/encoding_cpp.template.
-
-// Copyright 2019 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-{% if config.encoding_lib.header == "" %}
-
-#include <algorithm>
-#include <cassert>
-#include <cmath>
-#include <cstring>
-#include <limits>
-#include <stack>
-
-{% for namespace in config.protocol.namespace %}
-namespace {{namespace}} {
-{% endfor %}
-
-// ===== encoding/encoding.cc =====
-
-// =============================================================================
-// Status and Error codes
-// =============================================================================
-
-std::string Status::ToASCIIString() const {
-  switch (error) {
-    case Error::OK:
-      return "OK";
-    case Error::JSON_PARSER_UNPROCESSED_INPUT_REMAINS:
-      return ToASCIIString("JSON: unprocessed input remains");
-    case Error::JSON_PARSER_STACK_LIMIT_EXCEEDED:
-      return ToASCIIString("JSON: stack limit exceeded");
-    case Error::JSON_PARSER_NO_INPUT:
-      return ToASCIIString("JSON: no input");
-    case Error::JSON_PARSER_INVALID_TOKEN:
-      return ToASCIIString("JSON: invalid token");
-    case Error::JSON_PARSER_INVALID_NUMBER:
-      return ToASCIIString("JSON: invalid number");
-    case Error::JSON_PARSER_INVALID_STRING:
-      return ToASCIIString("JSON: invalid string");
-    case Error::JSON_PARSER_UNEXPECTED_ARRAY_END:
-      return ToASCIIString("JSON: unexpected array end");
-    case Error::JSON_PARSER_COMMA_OR_ARRAY_END_EXPECTED:
-      return ToASCIIString("JSON: comma or array end expected");
-    case Error::JSON_PARSER_STRING_LITERAL_EXPECTED:
-      return ToASCIIString("JSON: string literal expected");
-    case Error::JSON_PARSER_COLON_EXPECTED:
-      return ToASCIIString("JSON: colon expected");
-    case Error::JSON_PARSER_UNEXPECTED_MAP_END:
-      return ToASCIIString("JSON: unexpected map end");
-    case Error::JSON_PARSER_COMMA_OR_MAP_END_EXPECTED:
-      return ToASCIIString("JSON: comma or map end expected");
-    case Error::JSON_PARSER_VALUE_EXPECTED:
-      return ToASCIIString("JSON: value expected");
-
-    case Error::CBOR_INVALID_INT32:
-      return ToASCIIString("CBOR: invalid int32");
-    case Error::CBOR_INVALID_DOUBLE:
-      return ToASCIIString("CBOR: invalid double");
-    case Error::CBOR_INVALID_ENVELOPE:
-      return ToASCIIString("CBOR: invalid envelope");
-    case Error::CBOR_INVALID_STRING8:
-      return ToASCIIString("CBOR: invalid string8");
-    case Error::CBOR_INVALID_STRING16:
-      return ToASCIIString("CBOR: invalid string16");
-    case Error::CBOR_INVALID_BINARY:
-      return ToASCIIString("CBOR: invalid binary");
-    case Error::CBOR_UNSUPPORTED_VALUE:
-      return ToASCIIString("CBOR: unsupported value");
-    case Error::CBOR_NO_INPUT:
-      return ToASCIIString("CBOR: no input");
-    case Error::CBOR_INVALID_START_BYTE:
-      return ToASCIIString("CBOR: invalid start byte");
-    case Error::CBOR_UNEXPECTED_EOF_EXPECTED_VALUE:
-      return ToASCIIString("CBOR: unexpected eof expected value");
-    case Error::CBOR_UNEXPECTED_EOF_IN_ARRAY:
-      return ToASCIIString("CBOR: unexpected eof in array");
-    case Error::CBOR_UNEXPECTED_EOF_IN_MAP:
-      return ToASCIIString("CBOR: unexpected eof in map");
-    case Error::CBOR_INVALID_MAP_KEY:
-      return ToASCIIString("CBOR: invalid map key");
-    case Error::CBOR_STACK_LIMIT_EXCEEDED:
-      return ToASCIIString("CBOR: stack limit exceeded");
-    case Error::CBOR_TRAILING_JUNK:
-      return ToASCIIString("CBOR: trailing junk");
-    case Error::CBOR_MAP_START_EXPECTED:
-      return ToASCIIString("CBOR: map start expected");
-    case Error::CBOR_MAP_STOP_EXPECTED:
-      return ToASCIIString("CBOR: map stop expected");
-    case Error::CBOR_ENVELOPE_SIZE_LIMIT_EXCEEDED:
-      return ToASCIIString("CBOR: envelope size limit exceeded");
-  }
-  // Some compilers can't figure out that we can't get here.
-  return "INVALID ERROR CODE";
-}
-
-std::string Status::ToASCIIString(const char* msg) const {
-  return std::string(msg) + " at position " + std::to_string(pos);
-}
-
-namespace cbor {
-namespace {
-// Indicates the number of bits the "initial byte" needs to be shifted to the
-// right after applying |kMajorTypeMask| to produce the major type in the
-// lowermost bits.
-static constexpr uint8_t kMajorTypeBitShift = 5u;
-// Mask selecting the low-order 5 bits of the "initial byte", which is where
-// the additional information is encoded.
-static constexpr uint8_t kAdditionalInformationMask = 0x1f;
-// Mask selecting the high-order 3 bits of the "initial byte", which indicates
-// the major type of the encoded value.
-static constexpr uint8_t kMajorTypeMask = 0xe0;
-// Indicates the integer is in the following byte.
-static constexpr uint8_t kAdditionalInformation1Byte = 24u;
-// Indicates the integer is in the next 2 bytes.
-static constexpr uint8_t kAdditionalInformation2Bytes = 25u;
-// Indicates the integer is in the next 4 bytes.
-static constexpr uint8_t kAdditionalInformation4Bytes = 26u;
-// Indicates the integer is in the next 8 bytes.
-static constexpr uint8_t kAdditionalInformation8Bytes = 27u;
-
-// Encodes the initial byte, consisting of the |type| in the first 3 bits
-// followed by 5 bits of |additional_info|.
-constexpr uint8_t EncodeInitialByte(MajorType type, uint8_t additional_info) {
-  return (static_cast<uint8_t>(type) << kMajorTypeBitShift) |
-         (additional_info & kAdditionalInformationMask);
-}
-
-// TAG 24 indicates that what follows is a byte string which is
-// encoded in CBOR format. We use this as a wrapper for
-// maps and arrays, allowing us to skip them, because the
-// byte string carries its size (byte length).
-// https://tools.ietf.org/html/rfc7049#section-2.4.4.1
-static constexpr uint8_t kInitialByteForEnvelope =
-    EncodeInitialByte(MajorType::TAG, 24);
-// The initial byte for a byte string with at most 2^32 bytes
-// of payload. This is used for envelope encoding, even if
-// the byte string is shorter.
-static constexpr uint8_t kInitialByteFor32BitLengthByteString =
-    EncodeInitialByte(MajorType::BYTE_STRING, 26);
-
-// See RFC 7049 Section 2.2.1, indefinite length arrays / maps have additional
-// info = 31.
-static constexpr uint8_t kInitialByteIndefiniteLengthArray =
-    EncodeInitialByte(MajorType::ARRAY, 31);
-static constexpr uint8_t kInitialByteIndefiniteLengthMap =
-    EncodeInitialByte(MajorType::MAP, 31);
-// See RFC 7049 Section 2.3, Table 1; this is used for finishing indefinite
-// length maps / arrays.
-static constexpr uint8_t kStopByte =
-    EncodeInitialByte(MajorType::SIMPLE_VALUE, 31);
-
-// See RFC 7049 Section 2.3, Table 2.
-static constexpr uint8_t kEncodedTrue =
-    EncodeInitialByte(MajorType::SIMPLE_VALUE, 21);
-static constexpr uint8_t kEncodedFalse =
-    EncodeInitialByte(MajorType::SIMPLE_VALUE, 20);
-static constexpr uint8_t kEncodedNull =
-    EncodeInitialByte(MajorType::SIMPLE_VALUE, 22);
-static constexpr uint8_t kInitialByteForDouble =
-    EncodeInitialByte(MajorType::SIMPLE_VALUE, 27);
-
-// See RFC 7049 Table 3 and Section 2.4.4.2. This is used as a prefix for
-// arbitrary binary data encoded as BYTE_STRING.
-static constexpr uint8_t kExpectedConversionToBase64Tag =
-    EncodeInitialByte(MajorType::TAG, 22);
-
-// Writes the bytes for |v| to |out|, starting with the most significant byte.
-// See also: https://commandcenter.blogspot.com/2012/04/byte-order-fallacy.html
-template <typename T, class C>
-void WriteBytesMostSignificantByteFirst(T v, C* out) {
-  for (int shift_bytes = sizeof(T) - 1; shift_bytes >= 0; --shift_bytes)
-    out->push_back(0xff & (v >> (shift_bytes * 8)));
-}
-
-// Extracts sizeof(T) bytes from |in| to extract a value of type T
-// (e.g. uint64_t, uint32_t, ...), most significant byte first.
-// See also: https://commandcenter.blogspot.com/2012/04/byte-order-fallacy.html
-template <typename T>
-T ReadBytesMostSignificantByteFirst(span<uint8_t> in) {
-  assert(in.size() >= sizeof(T));
-  T result = 0;
-  for (size_t shift_bytes = 0; shift_bytes < sizeof(T); ++shift_bytes)
-    result |= T(in[sizeof(T) - 1 - shift_bytes]) << (shift_bytes * 8);
-  return result;
-}
-}  // namespace
-
-namespace internals {
-// Reads the start of a token with definitive size from |bytes|.
-// |type| is the major type as specified in RFC 7049 Section 2.1.
-// |value| is the payload (e.g. for MajorType::UNSIGNED) or is the size
-// (e.g. for BYTE_STRING).
-// If successful, returns the number of bytes read. Otherwise returns 0.
-size_t ReadTokenStart(span<uint8_t> bytes, MajorType* type, uint64_t* value) {
-  if (bytes.empty())
-    return 0;
-  uint8_t initial_byte = bytes[0];
-  *type = MajorType((initial_byte & kMajorTypeMask) >> kMajorTypeBitShift);
-
-  uint8_t additional_information = initial_byte & kAdditionalInformationMask;
-  if (additional_information < 24) {
-    // Values 0-23 are encoded directly into the additional info of the
-    // initial byte.
-    *value = additional_information;
-    return 1;
-  }
-  if (additional_information == kAdditionalInformation1Byte) {
-    // Values 24-255 are encoded with one initial byte, followed by the value.
-    if (bytes.size() < 2)
-      return 0;
-    *value = ReadBytesMostSignificantByteFirst<uint8_t>(bytes.subspan(1));
-    return 2;
-  }
-  if (additional_information == kAdditionalInformation2Bytes) {
-    // Values 256-65535: 1 initial byte + 2 bytes payload.
-    if (bytes.size() < 1 + sizeof(uint16_t))
-      return 0;
-    *value = ReadBytesMostSignificantByteFirst<uint16_t>(bytes.subspan(1));
-    return 3;
-  }
-  if (additional_information == kAdditionalInformation4Bytes) {
-    // 32 bit uint: 1 initial byte + 4 bytes payload.
-    if (bytes.size() < 1 + sizeof(uint32_t))
-      return 0;
-    *value = ReadBytesMostSignificantByteFirst<uint32_t>(bytes.subspan(1));
-    return 5;
-  }
-  if (additional_information == kAdditionalInformation8Bytes) {
-    // 64 bit uint: 1 initial byte + 8 bytes payload.
-    if (bytes.size() < 1 + sizeof(uint64_t))
-      return 0;
-    *value = ReadBytesMostSignificantByteFirst<uint64_t>(bytes.subspan(1));
-    return 9;
-  }
-  return 0;
-}
-
-// Writes the start of a token with |type|. The |value| may indicate the size,
-// or it may be the payload if the value is an unsigned integer.
-template <typename C>
-void WriteTokenStartTmpl(MajorType type, uint64_t value, C* encoded) {
-  if (value < 24) {
-    // Values 0-23 are encoded directly into the additional info of the
-    // initial byte.
-    encoded->push_back(EncodeInitialByte(type, /*additional_info=*/value));
-    return;
-  }
-  if (value <= std::numeric_limits<uint8_t>::max()) {
-    // Values 24-255 are encoded with one initial byte, followed by the value.
-    encoded->push_back(EncodeInitialByte(type, kAdditionalInformation1Byte));
-    encoded->push_back(value);
-    return;
-  }
-  if (value <= std::numeric_limits<uint16_t>::max()) {
-    // Values 256-65535: 1 initial byte + 2 bytes payload.
-    encoded->push_back(EncodeInitialByte(type, kAdditionalInformation2Bytes));
-    WriteBytesMostSignificantByteFirst<uint16_t>(value, encoded);
-    return;
-  }
-  if (value <= std::numeric_limits<uint32_t>::max()) {
-    // 32 bit uint: 1 initial byte + 4 bytes payload.
-    encoded->push_back(EncodeInitialByte(type, kAdditionalInformation4Bytes));
-    WriteBytesMostSignificantByteFirst<uint32_t>(static_cast<uint32_t>(value),
-                                                 encoded);
-    return;
-  }
-  // 64 bit uint: 1 initial byte + 8 bytes payload.
-  encoded->push_back(EncodeInitialByte(type, kAdditionalInformation8Bytes));
-  WriteBytesMostSignificantByteFirst<uint64_t>(value, encoded);
-}
-void WriteTokenStart(MajorType type,
-                     uint64_t value,
-                     std::vector<uint8_t>* encoded) {
-  WriteTokenStartTmpl(type, value, encoded);
-}
-void WriteTokenStart(MajorType type, uint64_t value, std::string* encoded) {
-  WriteTokenStartTmpl(type, value, encoded);
-}
-}  // namespace internals
-
-// =============================================================================
-// Detecting CBOR content
-// =============================================================================
-
-uint8_t InitialByteForEnvelope() {
-  return kInitialByteForEnvelope;
-}
-uint8_t InitialByteFor32BitLengthByteString() {
-  return kInitialByteFor32BitLengthByteString;
-}
-bool IsCBORMessage(span<uint8_t> msg) {
-  return msg.size() >= 6 && msg[0] == InitialByteForEnvelope() &&
-         msg[1] == InitialByteFor32BitLengthByteString();
-}
-
-// =============================================================================
-// Encoding invidiual CBOR items
-// =============================================================================
-
-uint8_t EncodeTrue() {
-  return kEncodedTrue;
-}
-uint8_t EncodeFalse() {
-  return kEncodedFalse;
-}
-uint8_t EncodeNull() {
-  return kEncodedNull;
-}
-
-uint8_t EncodeIndefiniteLengthArrayStart() {
-  return kInitialByteIndefiniteLengthArray;
-}
-
-uint8_t EncodeIndefiniteLengthMapStart() {
-  return kInitialByteIndefiniteLengthMap;
-}
-
-uint8_t EncodeStop() {
-  return kStopByte;
-}
-
-template <typename C>
-void EncodeInt32Tmpl(int32_t value, C* out) {
-  if (value >= 0) {
-    internals::WriteTokenStart(MajorType::UNSIGNED, value, out);
-  } else {
-    uint64_t representation = static_cast<uint64_t>(-(value + 1));
-    internals::WriteTokenStart(MajorType::NEGATIVE, representation, out);
-  }
-}
-void EncodeInt32(int32_t value, std::vector<uint8_t>* out) {
-  EncodeInt32Tmpl(value, out);
-}
-void EncodeInt32(int32_t value, std::string* out) {
-  EncodeInt32Tmpl(value, out);
-}
-
-template <typename C>
-void EncodeString16Tmpl(span<uint16_t> in, C* out) {
-  uint64_t byte_length = static_cast<uint64_t>(in.size_bytes());
-  internals::WriteTokenStart(MajorType::BYTE_STRING, byte_length, out);
-  // When emitting UTF16 characters, we always write the least significant byte
-  // first; this is because it's the native representation for X86.
-  // TODO(johannes): Implement a more efficient thing here later, e.g.
-  // casting *iff* the machine has this byte order.
-  // The wire format for UTF16 chars will probably remain the same
-  // (least significant byte first) since this way we can have
-  // golden files, unittests, etc. that port easily and universally.
-  // See also:
-  // https://commandcenter.blogspot.com/2012/04/byte-order-fallacy.html
-  for (const uint16_t two_bytes : in) {
-    out->push_back(two_bytes);
-    out->push_back(two_bytes >> 8);
-  }
-}
-void EncodeString16(span<uint16_t> in, std::vector<uint8_t>* out) {
-  EncodeString16Tmpl(in, out);
-}
-void EncodeString16(span<uint16_t> in, std::string* out) {
-  EncodeString16Tmpl(in, out);
-}
-
-template <typename C>
-void EncodeString8Tmpl(span<uint8_t> in, C* out) {
-  internals::WriteTokenStart(MajorType::STRING,
-                             static_cast<uint64_t>(in.size_bytes()), out);
-  out->insert(out->end(), in.begin(), in.end());
-}
-void EncodeString8(span<uint8_t> in, std::vector<uint8_t>* out) {
-  EncodeString8Tmpl(in, out);
-}
-void EncodeString8(span<uint8_t> in, std::string* out) {
-  EncodeString8Tmpl(in, out);
-}
-
-template <typename C>
-void EncodeFromLatin1Tmpl(span<uint8_t> latin1, C* out) {
-  for (size_t ii = 0; ii < latin1.size(); ++ii) {
-    if (latin1[ii] <= 127)
-      continue;
-    // If there's at least one non-ASCII char, convert to UTF8.
-    std::vector<uint8_t> utf8(latin1.begin(), latin1.begin() + ii);
-    for (; ii < latin1.size(); ++ii) {
-      if (latin1[ii] <= 127) {
-        utf8.push_back(latin1[ii]);
-      } else {
-        // 0xC0 means it's a UTF8 sequence with 2 bytes.
-        utf8.push_back((latin1[ii] >> 6) | 0xc0);
-        utf8.push_back((latin1[ii] | 0x80) & 0xbf);
-      }
-    }
-    EncodeString8(SpanFrom(utf8), out);
-    return;
-  }
-  EncodeString8(latin1, out);
-}
-void EncodeFromLatin1(span<uint8_t> latin1, std::vector<uint8_t>* out) {
-  EncodeFromLatin1Tmpl(latin1, out);
-}
-void EncodeFromLatin1(span<uint8_t> latin1, std::string* out) {
-  EncodeFromLatin1Tmpl(latin1, out);
-}
-
-template <typename C>
-void EncodeFromUTF16Tmpl(span<uint16_t> utf16, C* out) {
-  // If there's at least one non-ASCII char, encode as STRING16 (UTF16).
-  for (uint16_t ch : utf16) {
-    if (ch <= 127)
-      continue;
-    EncodeString16(utf16, out);
-    return;
-  }
-  // It's all US-ASCII, strip out every second byte and encode as UTF8.
-  internals::WriteTokenStart(MajorType::STRING,
-                             static_cast<uint64_t>(utf16.size()), out);
-  out->insert(out->end(), utf16.begin(), utf16.end());
-}
-void EncodeFromUTF16(span<uint16_t> utf16, std::vector<uint8_t>* out) {
-  EncodeFromUTF16Tmpl(utf16, out);
-}
-void EncodeFromUTF16(span<uint16_t> utf16, std::string* out) {
-  EncodeFromUTF16Tmpl(utf16, out);
-}
-
-template <typename C>
-void EncodeBinaryTmpl(span<uint8_t> in, C* out) {
-  out->push_back(kExpectedConversionToBase64Tag);
-  uint64_t byte_length = static_cast<uint64_t>(in.size_bytes());
-  internals::WriteTokenStart(MajorType::BYTE_STRING, byte_length, out);
-  out->insert(out->end(), in.begin(), in.end());
-}
-void EncodeBinary(span<uint8_t> in, std::vector<uint8_t>* out) {
-  EncodeBinaryTmpl(in, out);
-}
-void EncodeBinary(span<uint8_t> in, std::string* out) {
-  EncodeBinaryTmpl(in, out);
-}
-
-// A double is encoded with a specific initial byte
-// (kInitialByteForDouble) plus the 64 bits of payload for its value.
-constexpr size_t kEncodedDoubleSize = 1 + sizeof(uint64_t);
-
-// An envelope is encoded with a specific initial byte
-// (kInitialByteForEnvelope), plus the start byte for a BYTE_STRING with a 32
-// bit wide length, plus a 32 bit length for that string.
-constexpr size_t kEncodedEnvelopeHeaderSize = 1 + 1 + sizeof(uint32_t);
-
-template <typename C>
-void EncodeDoubleTmpl(double value, C* out) {
-  // The additional_info=27 indicates 64 bits for the double follow.
-  // See RFC 7049 Section 2.3, Table 1.
-  out->push_back(kInitialByteForDouble);
-  union {
-    double from_double;
-    uint64_t to_uint64;
-  } reinterpret;
-  reinterpret.from_double = value;
-  WriteBytesMostSignificantByteFirst<uint64_t>(reinterpret.to_uint64, out);
-}
-void EncodeDouble(double value, std::vector<uint8_t>* out) {
-  EncodeDoubleTmpl(value, out);
-}
-void EncodeDouble(double value, std::string* out) {
-  EncodeDoubleTmpl(value, out);
-}
-
-// =============================================================================
-// cbor::EnvelopeEncoder - for wrapping submessages
-// =============================================================================
-
-template <typename C>
-void EncodeStartTmpl(C* out, size_t* byte_size_pos) {
-  assert(*byte_size_pos == 0);
-  out->push_back(kInitialByteForEnvelope);
-  out->push_back(kInitialByteFor32BitLengthByteString);
-  *byte_size_pos = out->size();
-  out->resize(out->size() + sizeof(uint32_t));
-}
-
-void EnvelopeEncoder::EncodeStart(std::vector<uint8_t>* out) {
-  EncodeStartTmpl<std::vector<uint8_t>>(out, &byte_size_pos_);
-}
-
-void EnvelopeEncoder::EncodeStart(std::string* out) {
-  EncodeStartTmpl<std::string>(out, &byte_size_pos_);
-}
-
-template <typename C>
-bool EncodeStopTmpl(C* out, size_t* byte_size_pos) {
-  assert(*byte_size_pos != 0);
-  // The byte size is the size of the payload, that is, all the
-  // bytes that were written past the byte size position itself.
-  uint64_t byte_size = out->size() - (*byte_size_pos + sizeof(uint32_t));
-  // We store exactly 4 bytes, so at most INT32MAX, with most significant
-  // byte first.
-  if (byte_size > std::numeric_limits<uint32_t>::max())
-    return false;
-  for (int shift_bytes = sizeof(uint32_t) - 1; shift_bytes >= 0;
-       --shift_bytes) {
-    (*out)[(*byte_size_pos)++] = 0xff & (byte_size >> (shift_bytes * 8));
-  }
-  return true;
-}
-
-bool EnvelopeEncoder::EncodeStop(std::vector<uint8_t>* out) {
-  return EncodeStopTmpl(out, &byte_size_pos_);
-}
-
-bool EnvelopeEncoder::EncodeStop(std::string* out) {
-  return EncodeStopTmpl(out, &byte_size_pos_);
-}
-
-// =============================================================================
-// cbor::NewCBOREncoder - for encoding from a streaming parser
-// =============================================================================
-
-namespace {
-template <typename C>
-class CBOREncoder : public StreamingParserHandler {
- public:
-  CBOREncoder(C* out, Status* status) : out_(out), status_(status) {
-    *status_ = Status();
-  }
-
-  void HandleMapBegin() override {
-    if (!status_->ok())
-      return;
-    envelopes_.emplace_back();
-    envelopes_.back().EncodeStart(out_);
-    out_->push_back(kInitialByteIndefiniteLengthMap);
-  }
-
-  void HandleMapEnd() override {
-    if (!status_->ok())
-      return;
-    out_->push_back(kStopByte);
-    assert(!envelopes_.empty());
-    if (!envelopes_.back().EncodeStop(out_)) {
-      HandleError(
-          Status(Error::CBOR_ENVELOPE_SIZE_LIMIT_EXCEEDED, out_->size()));
-      return;
-    }
-    envelopes_.pop_back();
-  }
-
-  void HandleArrayBegin() override {
-    if (!status_->ok())
-      return;
-    envelopes_.emplace_back();
-    envelopes_.back().EncodeStart(out_);
-    out_->push_back(kInitialByteIndefiniteLengthArray);
-  }
-
-  void HandleArrayEnd() override {
-    if (!status_->ok())
-      return;
-    out_->push_back(kStopByte);
-    assert(!envelopes_.empty());
-    if (!envelopes_.back().EncodeStop(out_)) {
-      HandleError(
-          Status(Error::CBOR_ENVELOPE_SIZE_LIMIT_EXCEEDED, out_->size()));
-      return;
-    }
-    envelopes_.pop_back();
-  }
-
-  void HandleString8(span<uint8_t> chars) override {
-    if (!status_->ok())
-      return;
-    EncodeString8(chars, out_);
-  }
-
-  void HandleString16(span<uint16_t> chars) override {
-    if (!status_->ok())
-      return;
-    EncodeFromUTF16(chars, out_);
-  }
-
-  void HandleBinary(span<uint8_t> bytes) override {
-    if (!status_->ok())
-      return;
-    EncodeBinary(bytes, out_);
-  }
-
-  void HandleDouble(double value) override {
-    if (!status_->ok())
-      return;
-    EncodeDouble(value, out_);
-  }
-
-  void HandleInt32(int32_t value) override {
-    if (!status_->ok())
-      return;
-    EncodeInt32(value, out_);
-  }
-
-  void HandleBool(bool value) override {
-    if (!status_->ok())
-      return;
-    // See RFC 7049 Section 2.3, Table 2.
-    out_->push_back(value ? kEncodedTrue : kEncodedFalse);
-  }
-
-  void HandleNull() override {
-    if (!status_->ok())
-      return;
-    // See RFC 7049 Section 2.3, Table 2.
-    out_->push_back(kEncodedNull);
-  }
-
-  void HandleError(Status error) override {
-    if (!status_->ok())
-      return;
-    *status_ = error;
-    out_->clear();
-  }
-
- private:
-  C* out_;
-  std::vector<EnvelopeEncoder> envelopes_;
-  Status* status_;
-};
-}  // namespace
-
-std::unique_ptr<StreamingParserHandler> NewCBOREncoder(
-    std::vector<uint8_t>* out,
-    Status* status) {
-  return std::unique_ptr<StreamingParserHandler>(
-      new CBOREncoder<std::vector<uint8_t>>(out, status));
-}
-std::unique_ptr<StreamingParserHandler> NewCBOREncoder(std::string* out,
-                                                       Status* status) {
-  return std::unique_ptr<StreamingParserHandler>(
-      new CBOREncoder<std::string>(out, status));
-}
-
-// =============================================================================
-// cbor::CBORTokenizer - for parsing individual CBOR items
-// =============================================================================
-
-CBORTokenizer::CBORTokenizer(span<uint8_t> bytes) : bytes_(bytes) {
-  ReadNextToken(/*enter_envelope=*/false);
-}
-CBORTokenizer::~CBORTokenizer() {}
-
-CBORTokenTag CBORTokenizer::TokenTag() const {
-  return token_tag_;
-}
-
-void CBORTokenizer::Next() {
-  if (token_tag_ == CBORTokenTag::ERROR_VALUE ||
-      token_tag_ == CBORTokenTag::DONE)
-    return;
-  ReadNextToken(/*enter_envelope=*/false);
-}
-
-void CBORTokenizer::EnterEnvelope() {
-  assert(token_tag_ == CBORTokenTag::ENVELOPE);
-  ReadNextToken(/*enter_envelope=*/true);
-}
-
-Status CBORTokenizer::Status() const {
-  return status_;
-}
-
-// The following accessor functions ::GetInt32, ::GetDouble,
-// ::GetString8, ::GetString16WireRep, ::GetBinary, ::GetEnvelopeContents
-// assume that a particular token was recognized in ::ReadNextToken.
-// That's where all the error checking is done. By design,
-// the accessors (assuming the token was recognized) never produce
-// an error.
-
-int32_t CBORTokenizer::GetInt32() const {
-  assert(token_tag_ == CBORTokenTag::INT32);
-  // The range checks happen in ::ReadNextToken().
-  return static_cast<int32_t>(
-      token_start_type_ == MajorType::UNSIGNED
-          ? token_start_internal_value_
-          : -static_cast<int64_t>(token_start_internal_value_) - 1);
-}
-
-double CBORTokenizer::GetDouble() const {
-  assert(token_tag_ == CBORTokenTag::DOUBLE);
-  union {
-    uint64_t from_uint64;
-    double to_double;
-  } reinterpret;
-  reinterpret.from_uint64 = ReadBytesMostSignificantByteFirst<uint64_t>(
-      bytes_.subspan(status_.pos + 1));
-  return reinterpret.to_double;
-}
-
-span<uint8_t> CBORTokenizer::GetString8() const {
-  assert(token_tag_ == CBORTokenTag::STRING8);
-  auto length = static_cast<size_t>(token_start_internal_value_);
-  return bytes_.subspan(status_.pos + (token_byte_length_ - length), length);
-}
-
-span<uint8_t> CBORTokenizer::GetString16WireRep() const {
-  assert(token_tag_ == CBORTokenTag::STRING16);
-  auto length = static_cast<size_t>(token_start_internal_value_);
-  return bytes_.subspan(status_.pos + (token_byte_length_ - length), length);
-}
-
-span<uint8_t> CBORTokenizer::GetBinary() const {
-  assert(token_tag_ == CBORTokenTag::BINARY);
-  auto length = static_cast<size_t>(token_start_internal_value_);
-  return bytes_.subspan(status_.pos + (token_byte_length_ - length), length);
-}
-
-span<uint8_t> CBORTokenizer::GetEnvelopeContents() const {
-  assert(token_tag_ == CBORTokenTag::ENVELOPE);
-  auto length = static_cast<size_t>(token_start_internal_value_);
-  return bytes_.subspan(status_.pos + kEncodedEnvelopeHeaderSize, length);
-}
-
-// All error checking happens in ::ReadNextToken, so that the accessors
-// can avoid having to carry an error return value.
-//
-// With respect to checking the encoded lengths of strings, arrays, etc:
-// On the wire, CBOR uses 1,2,4, and 8 byte unsigned integers, so
-// we initially read them as uint64_t, usually into token_start_internal_value_.
-//
-// However, since these containers have a representation on the machine,
-// we need to do corresponding size computations on the input byte array,
-// output span (e.g. the payload for a string), etc., and size_t is
-// machine specific (in practice either 32 bit or 64 bit).
-//
-// Further, we must avoid overflowing size_t. Therefore, we use this
-// kMaxValidLength constant to:
-// - Reject values that are larger than the architecture specific
-//   max size_t (differs between 32 bit and 64 bit arch).
-// - Reserve at least one bit so that we can check against overflows
-//   when adding lengths (array / string length / etc.); we do this by
-//   ensuring that the inputs to an addition are <= kMaxValidLength,
-//   and then checking whether the sum went past it.
-//
-// See also
-// https://chromium.googlesource.com/chromium/src/+/HEAD/docs/security/integer-semantics.md
-static const uint64_t kMaxValidLength =
-    std::min<uint64_t>(std::numeric_limits<uint64_t>::max() >> 2,
-                       std::numeric_limits<size_t>::max());
-
-void CBORTokenizer::ReadNextToken(bool enter_envelope) {
-  if (enter_envelope) {
-    status_.pos += kEncodedEnvelopeHeaderSize;
-  } else {
-    status_.pos =
-        status_.pos == Status::npos() ? 0 : status_.pos + token_byte_length_;
-  }
-  status_.error = Error::OK;
-  if (status_.pos >= bytes_.size()) {
-    token_tag_ = CBORTokenTag::DONE;
-    return;
-  }
-  const size_t remaining_bytes = bytes_.size() - status_.pos;
-  switch (bytes_[status_.pos]) {
-    case kStopByte:
-      SetToken(CBORTokenTag::STOP, 1);
-      return;
-    case kInitialByteIndefiniteLengthMap:
-      SetToken(CBORTokenTag::MAP_START, 1);
-      return;
-    case kInitialByteIndefiniteLengthArray:
-      SetToken(CBORTokenTag::ARRAY_START, 1);
-      return;
-    case kEncodedTrue:
-      SetToken(CBORTokenTag::TRUE_VALUE, 1);
-      return;
-    case kEncodedFalse:
-      SetToken(CBORTokenTag::FALSE_VALUE, 1);
-      return;
-    case kEncodedNull:
-      SetToken(CBORTokenTag::NULL_VALUE, 1);
-      return;
-    case kExpectedConversionToBase64Tag: {  // BINARY
-      const size_t bytes_read = internals::ReadTokenStart(
-          bytes_.subspan(status_.pos + 1), &token_start_type_,
-          &token_start_internal_value_);
-      if (!bytes_read || token_start_type_ != MajorType::BYTE_STRING ||
-          token_start_internal_value_ > kMaxValidLength) {
-        SetError(Error::CBOR_INVALID_BINARY);
-        return;
-      }
-      const uint64_t token_byte_length = token_start_internal_value_ +
-                                         /* tag before token start: */ 1 +
-                                         /* token start: */ bytes_read;
-      if (token_byte_length > remaining_bytes) {
-        SetError(Error::CBOR_INVALID_BINARY);
-        return;
-      }
-      SetToken(CBORTokenTag::BINARY, static_cast<size_t>(token_byte_length));
-      return;
-    }
-    case kInitialByteForDouble: {  // DOUBLE
-      if (kEncodedDoubleSize > remaining_bytes) {
-        SetError(Error::CBOR_INVALID_DOUBLE);
-        return;
-      }
-      SetToken(CBORTokenTag::DOUBLE, kEncodedDoubleSize);
-      return;
-    }
-    case kInitialByteForEnvelope: {  // ENVELOPE
-      if (kEncodedEnvelopeHeaderSize > remaining_bytes) {
-        SetError(Error::CBOR_INVALID_ENVELOPE);
-        return;
-      }
-      // The envelope must be a byte string with 32 bit length.
-      if (bytes_[status_.pos + 1] != kInitialByteFor32BitLengthByteString) {
-        SetError(Error::CBOR_INVALID_ENVELOPE);
-        return;
-      }
-      // Read the length of the byte string.
-      token_start_internal_value_ = ReadBytesMostSignificantByteFirst<uint32_t>(
-          bytes_.subspan(status_.pos + 2));
-      if (token_start_internal_value_ > kMaxValidLength) {
-        SetError(Error::CBOR_INVALID_ENVELOPE);
-        return;
-      }
-      uint64_t token_byte_length =
-          token_start_internal_value_ + kEncodedEnvelopeHeaderSize;
-      if (token_byte_length > remaining_bytes) {
-        SetError(Error::CBOR_INVALID_ENVELOPE);
-        return;
-      }
-      SetToken(CBORTokenTag::ENVELOPE, static_cast<size_t>(token_byte_length));
-      return;
-    }
-    default: {
-      const size_t bytes_read = internals::ReadTokenStart(
-          bytes_.subspan(status_.pos), &token_start_type_,
-          &token_start_internal_value_);
-      switch (token_start_type_) {
-        case MajorType::UNSIGNED:  // INT32.
-          // INT32 is a signed int32 (int32 makes sense for the
-          // inspector_protocol, it's not a CBOR limitation), so we check
-          // against the signed max, so that the allowable values are
-          // 0, 1, 2, ... 2^31 - 1.
-          if (!bytes_read ||
-                static_cast<int64_t>(std::numeric_limits<int32_t>::max()) <
-                  static_cast<int64_t>(token_start_internal_value_)) {
-            SetError(Error::CBOR_INVALID_INT32);
-            return;
-          }
-          SetToken(CBORTokenTag::INT32, bytes_read);
-          return;
-        case MajorType::NEGATIVE: {  // INT32.
-          // INT32 is a signed int32 (int32 makes sense for the
-          // inspector_protocol, it's not a CBOR limitation); in CBOR, the
-          // negative values for INT32 are represented as NEGATIVE, that is, -1
-          // INT32 is represented as 1 << 5 | 0 (major type 1, additional info
-          // value 0).
-          // The represented allowed values range is -1 to -2^31.
-          // They are mapped into the encoded range of 0 to 2^31-1.
-          // We check the payload in token_start_internal_value_ against
-          // that range (2^31-1 is also known as
-          // std::numeric_limits<int32_t>::max()).
-          if (!bytes_read ||
-	        static_cast<int64_t>(token_start_internal_value_) >
-                  static_cast<int64_t>(std::numeric_limits<int32_t>::max())) {
-            SetError(Error::CBOR_INVALID_INT32);
-            return;
-          }
-          SetToken(CBORTokenTag::INT32, bytes_read);
-          return;
-        }
-        case MajorType::STRING: {  // STRING8.
-          if (!bytes_read || token_start_internal_value_ > kMaxValidLength) {
-            SetError(Error::CBOR_INVALID_STRING8);
-            return;
-          }
-          uint64_t token_byte_length = token_start_internal_value_ + bytes_read;
-          if (token_byte_length > remaining_bytes) {
-            SetError(Error::CBOR_INVALID_STRING8);
-            return;
-          }
-          SetToken(CBORTokenTag::STRING8,
-                   static_cast<size_t>(token_byte_length));
-          return;
-        }
-        case MajorType::BYTE_STRING: {  // STRING16.
-          // Length must be divisible by 2 since UTF16 is 2 bytes per
-          // character, hence the &1 check.
-          if (!bytes_read || token_start_internal_value_ > kMaxValidLength ||
-              token_start_internal_value_ & 1) {
-            SetError(Error::CBOR_INVALID_STRING16);
-            return;
-          }
-          uint64_t token_byte_length = token_start_internal_value_ + bytes_read;
-          if (token_byte_length > remaining_bytes) {
-            SetError(Error::CBOR_INVALID_STRING16);
-            return;
-          }
-          SetToken(CBORTokenTag::STRING16,
-                   static_cast<size_t>(token_byte_length));
-          return;
-        }
-        case MajorType::ARRAY:
-        case MajorType::MAP:
-        case MajorType::TAG:
-        case MajorType::SIMPLE_VALUE:
-          SetError(Error::CBOR_UNSUPPORTED_VALUE);
-          return;
-      }
-    }
-  }
-}
-
-void CBORTokenizer::SetToken(CBORTokenTag token_tag, size_t token_byte_length) {
-  token_tag_ = token_tag;
-  token_byte_length_ = token_byte_length;
-}
-
-void CBORTokenizer::SetError(Error error) {
-  token_tag_ = CBORTokenTag::ERROR_VALUE;
-  status_.error = error;
-}
-
-// =============================================================================
-// cbor::ParseCBOR - for receiving streaming parser events for CBOR messages
-// =============================================================================
-
-namespace {
-// When parsing CBOR, we limit recursion depth for objects and arrays
-// to this constant.
-static constexpr int kStackLimit = 300;
-
-// Below are three parsing routines for CBOR, which cover enough
-// to roundtrip JSON messages.
-bool ParseMap(int32_t stack_depth,
-              CBORTokenizer* tokenizer,
-              StreamingParserHandler* out);
-bool ParseArray(int32_t stack_depth,
-                CBORTokenizer* tokenizer,
-                StreamingParserHandler* out);
-bool ParseValue(int32_t stack_depth,
-                CBORTokenizer* tokenizer,
-                StreamingParserHandler* out);
-
-void ParseUTF16String(CBORTokenizer* tokenizer, StreamingParserHandler* out) {
-  std::vector<uint16_t> value;
-  span<uint8_t> rep = tokenizer->GetString16WireRep();
-  for (size_t ii = 0; ii < rep.size(); ii += 2)
-    value.push_back((rep[ii + 1] << 8) | rep[ii]);
-  out->HandleString16(span<uint16_t>(value.data(), value.size()));
-  tokenizer->Next();
-}
-
-bool ParseUTF8String(CBORTokenizer* tokenizer, StreamingParserHandler* out) {
-  assert(tokenizer->TokenTag() == CBORTokenTag::STRING8);
-  out->HandleString8(tokenizer->GetString8());
-  tokenizer->Next();
-  return true;
-}
-
-bool ParseValue(int32_t stack_depth,
-                CBORTokenizer* tokenizer,
-                StreamingParserHandler* out) {
-  if (stack_depth > kStackLimit) {
-    out->HandleError(
-        Status{Error::CBOR_STACK_LIMIT_EXCEEDED, tokenizer->Status().pos});
-    return false;
-  }
-  // Skip past the envelope to get to what's inside.
-  if (tokenizer->TokenTag() == CBORTokenTag::ENVELOPE)
-    tokenizer->EnterEnvelope();
-  switch (tokenizer->TokenTag()) {
-    case CBORTokenTag::ERROR_VALUE:
-      out->HandleError(tokenizer->Status());
-      return false;
-    case CBORTokenTag::DONE:
-      out->HandleError(Status{Error::CBOR_UNEXPECTED_EOF_EXPECTED_VALUE,
-                              tokenizer->Status().pos});
-      return false;
-    case CBORTokenTag::TRUE_VALUE:
-      out->HandleBool(true);
-      tokenizer->Next();
-      return true;
-    case CBORTokenTag::FALSE_VALUE:
-      out->HandleBool(false);
-      tokenizer->Next();
-      return true;
-    case CBORTokenTag::NULL_VALUE:
-      out->HandleNull();
-      tokenizer->Next();
-      return true;
-    case CBORTokenTag::INT32:
-      out->HandleInt32(tokenizer->GetInt32());
-      tokenizer->Next();
-      return true;
-    case CBORTokenTag::DOUBLE:
-      out->HandleDouble(tokenizer->GetDouble());
-      tokenizer->Next();
-      return true;
-    case CBORTokenTag::STRING8:
-      return ParseUTF8String(tokenizer, out);
-    case CBORTokenTag::STRING16:
-      ParseUTF16String(tokenizer, out);
-      return true;
-    case CBORTokenTag::BINARY: {
-      out->HandleBinary(tokenizer->GetBinary());
-      tokenizer->Next();
-      return true;
-    }
-    case CBORTokenTag::MAP_START:
-      return ParseMap(stack_depth + 1, tokenizer, out);
-    case CBORTokenTag::ARRAY_START:
-      return ParseArray(stack_depth + 1, tokenizer, out);
-    default:
-      out->HandleError(
-          Status{Error::CBOR_UNSUPPORTED_VALUE, tokenizer->Status().pos});
-      return false;
-  }
-}
-
-// |bytes| must start with the indefinite length array byte, so basically,
-// ParseArray may only be called after an indefinite length array has been
-// detected.
-bool ParseArray(int32_t stack_depth,
-                CBORTokenizer* tokenizer,
-                StreamingParserHandler* out) {
-  assert(tokenizer->TokenTag() == CBORTokenTag::ARRAY_START);
-  tokenizer->Next();
-  out->HandleArrayBegin();
-  while (tokenizer->TokenTag() != CBORTokenTag::STOP) {
-    if (tokenizer->TokenTag() == CBORTokenTag::DONE) {
-      out->HandleError(
-          Status{Error::CBOR_UNEXPECTED_EOF_IN_ARRAY, tokenizer->Status().pos});
-      return false;
-    }
-    if (tokenizer->TokenTag() == CBORTokenTag::ERROR_VALUE) {
-      out->HandleError(tokenizer->Status());
-      return false;
-    }
-    // Parse value.
-    if (!ParseValue(stack_depth, tokenizer, out))
-      return false;
-  }
-  out->HandleArrayEnd();
-  tokenizer->Next();
-  return true;
-}
-
-// |bytes| must start with the indefinite length array byte, so basically,
-// ParseArray may only be called after an indefinite length array has been
-// detected.
-bool ParseMap(int32_t stack_depth,
-              CBORTokenizer* tokenizer,
-              StreamingParserHandler* out) {
-  assert(tokenizer->TokenTag() == CBORTokenTag::MAP_START);
-  out->HandleMapBegin();
-  tokenizer->Next();
-  while (tokenizer->TokenTag() != CBORTokenTag::STOP) {
-    if (tokenizer->TokenTag() == CBORTokenTag::DONE) {
-      out->HandleError(
-          Status{Error::CBOR_UNEXPECTED_EOF_IN_MAP, tokenizer->Status().pos});
-      return false;
-    }
-    if (tokenizer->TokenTag() == CBORTokenTag::ERROR_VALUE) {
-      out->HandleError(tokenizer->Status());
-      return false;
-    }
-    // Parse key.
-    if (tokenizer->TokenTag() == CBORTokenTag::STRING8) {
-      if (!ParseUTF8String(tokenizer, out))
-        return false;
-    } else if (tokenizer->TokenTag() == CBORTokenTag::STRING16) {
-      ParseUTF16String(tokenizer, out);
-    } else {
-      out->HandleError(
-          Status{Error::CBOR_INVALID_MAP_KEY, tokenizer->Status().pos});
-      return false;
-    }
-    // Parse value.
-    if (!ParseValue(stack_depth, tokenizer, out))
-      return false;
-  }
-  out->HandleMapEnd();
-  tokenizer->Next();
-  return true;
-}
-}  // namespace
-
-void ParseCBOR(span<uint8_t> bytes, StreamingParserHandler* out) {
-  if (bytes.empty()) {
-    out->HandleError(Status{Error::CBOR_NO_INPUT, 0});
-    return;
-  }
-  if (bytes[0] != kInitialByteForEnvelope) {
-    out->HandleError(Status{Error::CBOR_INVALID_START_BYTE, 0});
-    return;
-  }
-  CBORTokenizer tokenizer(bytes);
-  if (tokenizer.TokenTag() == CBORTokenTag::ERROR_VALUE) {
-    out->HandleError(tokenizer.Status());
-    return;
-  }
-  // We checked for the envelope start byte above, so the tokenizer
-  // must agree here, since it's not an error.
-  assert(tokenizer.TokenTag() == CBORTokenTag::ENVELOPE);
-  tokenizer.EnterEnvelope();
-  if (tokenizer.TokenTag() != CBORTokenTag::MAP_START) {
-    out->HandleError(
-        Status{Error::CBOR_MAP_START_EXPECTED, tokenizer.Status().pos});
-    return;
-  }
-  if (!ParseMap(/*stack_depth=*/1, &tokenizer, out))
-    return;
-  if (tokenizer.TokenTag() == CBORTokenTag::DONE)
-    return;
-  if (tokenizer.TokenTag() == CBORTokenTag::ERROR_VALUE) {
-    out->HandleError(tokenizer.Status());
-    return;
-  }
-  out->HandleError(Status{Error::CBOR_TRAILING_JUNK, tokenizer.Status().pos});
-}
-
-// =============================================================================
-// cbor::AppendString8EntryToMap - for limited in-place editing of messages
-// =============================================================================
-
-template <typename C>
-Status AppendString8EntryToCBORMapTmpl(span<uint8_t> string8_key,
-                                       span<uint8_t> string8_value,
-                                       C* cbor) {
-  // Careful below: Don't compare (*cbor)[idx] with a uint8_t, since
-  // it could be a char (signed!). Instead, use bytes.
-  span<uint8_t> bytes(reinterpret_cast<const uint8_t*>(cbor->data()),
-                      cbor->size());
-  CBORTokenizer tokenizer(bytes);
-  if (tokenizer.TokenTag() == CBORTokenTag::ERROR_VALUE)
-    return tokenizer.Status();
-  if (tokenizer.TokenTag() != CBORTokenTag::ENVELOPE)
-    return Status(Error::CBOR_INVALID_ENVELOPE, 0);
-  size_t envelope_size = tokenizer.GetEnvelopeContents().size();
-  size_t old_size = cbor->size();
-  if (old_size != envelope_size + kEncodedEnvelopeHeaderSize)
-    return Status(Error::CBOR_INVALID_ENVELOPE, 0);
-  if (envelope_size == 0 ||
-      (tokenizer.GetEnvelopeContents()[0] != EncodeIndefiniteLengthMapStart()))
-    return Status(Error::CBOR_MAP_START_EXPECTED, kEncodedEnvelopeHeaderSize);
-  if (bytes[bytes.size() - 1] != EncodeStop())
-    return Status(Error::CBOR_MAP_STOP_EXPECTED, cbor->size() - 1);
-  cbor->pop_back();
-  EncodeString8(string8_key, cbor);
-  EncodeString8(string8_value, cbor);
-  cbor->push_back(EncodeStop());
-  size_t new_envelope_size = envelope_size + (cbor->size() - old_size);
-  if (new_envelope_size > std::numeric_limits<uint32_t>::max())
-    return Status(Error::CBOR_ENVELOPE_SIZE_LIMIT_EXCEEDED, 0);
-  size_t size_pos = cbor->size() - new_envelope_size - sizeof(uint32_t);
-  uint8_t* out = reinterpret_cast<uint8_t*>(&cbor->at(size_pos));
-  *(out++) = (new_envelope_size >> 24) & 0xff;
-  *(out++) = (new_envelope_size >> 16) & 0xff;
-  *(out++) = (new_envelope_size >> 8) & 0xff;
-  *(out) = new_envelope_size & 0xff;
-  return Status();
-}
-Status AppendString8EntryToCBORMap(span<uint8_t> string8_key,
-                                   span<uint8_t> string8_value,
-                                   std::vector<uint8_t>* cbor) {
-  return AppendString8EntryToCBORMapTmpl(string8_key, string8_value, cbor);
-}
-Status AppendString8EntryToCBORMap(span<uint8_t> string8_key,
-                                   span<uint8_t> string8_value,
-                                   std::string* cbor) {
-  return AppendString8EntryToCBORMapTmpl(string8_key, string8_value, cbor);
-}
-}  // namespace cbor
-
-namespace json {
-
-// =============================================================================
-// json::NewJSONEncoder - for encoding streaming parser events as JSON
-// =============================================================================
-
-namespace {
-// Prints |value| to |out| with 4 hex digits, most significant chunk first.
-template <typename C>
-void PrintHex(uint16_t value, C* out) {
-  for (int ii = 3; ii >= 0; --ii) {
-    int four_bits = 0xf & (value >> (4 * ii));
-    out->push_back(four_bits + ((four_bits <= 9) ? '0' : ('a' - 10)));
-  }
-}
-
-// In the writer below, we maintain a stack of State instances.
-// It is just enough to emit the appropriate delimiters and brackets
-// in JSON.
-enum class Container {
-  // Used for the top-level, initial state.
-  NONE,
-  // Inside a JSON object.
-  MAP,
-  // Inside a JSON array.
-  ARRAY
-};
-class State {
- public:
-  explicit State(Container container) : container_(container) {}
-  void StartElement(std::vector<uint8_t>* out) { StartElementTmpl(out); }
-  void StartElement(std::string* out) { StartElementTmpl(out); }
-  Container container() const { return container_; }
-
- private:
-  template <typename C>
-  void StartElementTmpl(C* out) {
-    assert(container_ != Container::NONE || size_ == 0);
-    if (size_ != 0) {
-      char delim = (!(size_ & 1) || container_ == Container::ARRAY) ? ',' : ':';
-      out->push_back(delim);
-    }
-    ++size_;
-  }
-
-  Container container_ = Container::NONE;
-  int size_ = 0;
-};
-
-constexpr char kBase64Table[] =
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-    "abcdefghijklmnopqrstuvwxyz0123456789+/";
-
-template <typename C>
-void Base64Encode(const span<uint8_t>& in, C* out) {
-  // The following three cases are based on the tables in the example
-  // section in https://en.wikipedia.org/wiki/Base64. We process three
-  // input bytes at a time, emitting 4 output bytes at a time.
-  size_t ii = 0;
-
-  // While possible, process three input bytes.
-  for (; ii + 3 <= in.size(); ii += 3) {
-    uint32_t twentyfour_bits = (in[ii] << 16) | (in[ii + 1] << 8) | in[ii + 2];
-    out->push_back(kBase64Table[(twentyfour_bits >> 18)]);
-    out->push_back(kBase64Table[(twentyfour_bits >> 12) & 0x3f]);
-    out->push_back(kBase64Table[(twentyfour_bits >> 6) & 0x3f]);
-    out->push_back(kBase64Table[twentyfour_bits & 0x3f]);
-  }
-  if (ii + 2 <= in.size()) {  // Process two input bytes.
-    uint32_t twentyfour_bits = (in[ii] << 16) | (in[ii + 1] << 8);
-    out->push_back(kBase64Table[(twentyfour_bits >> 18)]);
-    out->push_back(kBase64Table[(twentyfour_bits >> 12) & 0x3f]);
-    out->push_back(kBase64Table[(twentyfour_bits >> 6) & 0x3f]);
-    out->push_back('=');  // Emit padding.
-    return;
-  }
-  if (ii + 1 <= in.size()) {  // Process a single input byte.
-    uint32_t twentyfour_bits = (in[ii] << 16);
-    out->push_back(kBase64Table[(twentyfour_bits >> 18)]);
-    out->push_back(kBase64Table[(twentyfour_bits >> 12) & 0x3f]);
-    out->push_back('=');  // Emit padding.
-    out->push_back('=');  // Emit padding.
-  }
-}
-
-// Implements a handler for JSON parser events to emit a JSON string.
-template <typename C>
-class JSONEncoder : public StreamingParserHandler {
- public:
-  JSONEncoder(const Platform* platform, C* out, Status* status)
-      : platform_(platform), out_(out), status_(status) {
-    *status_ = Status();
-    state_.emplace(Container::NONE);
-  }
-
-  void HandleMapBegin() override {
-    if (!status_->ok())
-      return;
-    assert(!state_.empty());
-    state_.top().StartElement(out_);
-    state_.emplace(Container::MAP);
-    Emit('{');
-  }
-
-  void HandleMapEnd() override {
-    if (!status_->ok())
-      return;
-    assert(state_.size() >= 2 && state_.top().container() == Container::MAP);
-    state_.pop();
-    Emit('}');
-  }
-
-  void HandleArrayBegin() override {
-    if (!status_->ok())
-      return;
-    state_.top().StartElement(out_);
-    state_.emplace(Container::ARRAY);
-    Emit('[');
-  }
-
-  void HandleArrayEnd() override {
-    if (!status_->ok())
-      return;
-    assert(state_.size() >= 2 && state_.top().container() == Container::ARRAY);
-    state_.pop();
-    Emit(']');
-  }
-
-  void HandleString16(span<uint16_t> chars) override {
-    if (!status_->ok())
-      return;
-    state_.top().StartElement(out_);
-    Emit('"');
-    for (const uint16_t ch : chars) {
-      if (ch == '"') {
-        Emit("\\\"");
-      } else if (ch == '\\') {
-        Emit("\\\\");
-      } else if (ch == '\b') {
-        Emit("\\b");
-      } else if (ch == '\f') {
-        Emit("\\f");
-      } else if (ch == '\n') {
-        Emit("\\n");
-      } else if (ch == '\r') {
-        Emit("\\r");
-      } else if (ch == '\t') {
-        Emit("\\t");
-      } else if (ch >= 32 && ch <= 126) {
-        Emit(ch);
-      } else {
-        Emit("\\u");
-        PrintHex(ch, out_);
-      }
-    }
-    Emit('"');
-  }
-
-  void HandleString8(span<uint8_t> chars) override {
-    if (!status_->ok())
-      return;
-    state_.top().StartElement(out_);
-    Emit('"');
-    for (size_t ii = 0; ii < chars.size(); ++ii) {
-      uint8_t c = chars[ii];
-      if (c == '"') {
-        Emit("\\\"");
-      } else if (c == '\\') {
-        Emit("\\\\");
-      } else if (c == '\b') {
-        Emit("\\b");
-      } else if (c == '\f') {
-        Emit("\\f");
-      } else if (c == '\n') {
-        Emit("\\n");
-      } else if (c == '\r') {
-        Emit("\\r");
-      } else if (c == '\t') {
-        Emit("\\t");
-      } else if (c >= 32 && c <= 126) {
-        Emit(c);
-      } else if (c < 32) {
-        Emit("\\u");
-        PrintHex(static_cast<uint16_t>(c), out_);
-      } else {
-        // Inspect the leading byte to figure out how long the utf8
-        // byte sequence is; while doing this initialize |codepoint|
-        // with the first few bits.
-        // See table in: https://en.wikipedia.org/wiki/UTF-8
-        // byte one is 110x xxxx -> 2 byte utf8 sequence
-        // byte one is 1110 xxxx -> 3 byte utf8 sequence
-        // byte one is 1111 0xxx -> 4 byte utf8 sequence
-        uint32_t codepoint;
-        int num_bytes_left;
-        if ((c & 0xe0) == 0xc0) {  // 2 byte utf8 sequence
-          num_bytes_left = 1;
-          codepoint = c & 0x1f;
-        } else if ((c & 0xf0) == 0xe0) {  // 3 byte utf8 sequence
-          num_bytes_left = 2;
-          codepoint = c & 0x0f;
-        } else if ((c & 0xf8) == 0xf0) {  // 4 byte utf8 sequence
-          codepoint = c & 0x07;
-          num_bytes_left = 3;
-        } else {
-          continue;  // invalid leading byte
-        }
-
-        // If we have enough bytes in our input, decode the remaining ones
-        // belonging to this Unicode character into |codepoint|.
-        if (ii + num_bytes_left > chars.size())
-          continue;
-        while (num_bytes_left > 0) {
-          c = chars[++ii];
-          --num_bytes_left;
-          // Check the next byte is a continuation byte, that is 10xx xxxx.
-          if ((c & 0xc0) != 0x80)
-            continue;
-          codepoint = (codepoint << 6) | (c & 0x3f);
-        }
-
-        // Disallow overlong encodings for ascii characters, as these
-        // would include " and other characters significant to JSON
-        // string termination / control.
-        if (codepoint <= 0x7f)
-          continue;
-        // Invalid in UTF8, and can't be represented in UTF16 anyway.
-        if (codepoint > 0x10ffff)
-          continue;
-
-        // So, now we transcode to UTF16,
-        // using the math described at https://en.wikipedia.org/wiki/UTF-16,
-        // for either one or two 16 bit characters.
-        if (codepoint < 0xffff) {
-          Emit("\\u");
-          PrintHex(static_cast<uint16_t>(codepoint), out_);
-          continue;
-        }
-        codepoint -= 0x10000;
-        // high surrogate
-        Emit("\\u");
-        PrintHex(static_cast<uint16_t>((codepoint >> 10) + 0xd800), out_);
-        // low surrogate
-        Emit("\\u");
-        PrintHex(static_cast<uint16_t>((codepoint & 0x3ff) + 0xdc00), out_);
-      }
-    }
-    Emit('"');
-  }
-
-  void HandleBinary(span<uint8_t> bytes) override {
-    if (!status_->ok())
-      return;
-    state_.top().StartElement(out_);
-    Emit('"');
-    Base64Encode(bytes, out_);
-    Emit('"');
-  }
-
-  void HandleDouble(double value) override {
-    if (!status_->ok())
-      return;
-    state_.top().StartElement(out_);
-    // JSON cannot represent NaN or Infinity. So, for compatibility,
-    // we behave like the JSON object in web browsers: emit 'null'.
-    if (!std::isfinite(value)) {
-      Emit("null");
-      return;
-    }
-    std::unique_ptr<char[]> str_value = platform_->DToStr(value);
-
-    // DToStr may fail to emit a 0 before the decimal dot. E.g. this is
-    // the case in base::NumberToString in Chromium (which is based on
-    // dmg_fp). So, much like
-    // https://cs.chromium.org/chromium/src/base/json/json_writer.cc
-    // we probe for this and emit the leading 0 anyway if necessary.
-    const char* chars = str_value.get();
-    if (chars[0] == '.') {
-      Emit('0');
-    } else if (chars[0] == '-' && chars[1] == '.') {
-      Emit("-0");
-      ++chars;
-    }
-    Emit(chars);
-  }
-
-  void HandleInt32(int32_t value) override {
-    if (!status_->ok())
-      return;
-    state_.top().StartElement(out_);
-    Emit(std::to_string(value));
-  }
-
-  void HandleBool(bool value) override {
-    if (!status_->ok())
-      return;
-    state_.top().StartElement(out_);
-    Emit(value ? "true" : "false");
-  }
-
-  void HandleNull() override {
-    if (!status_->ok())
-      return;
-    state_.top().StartElement(out_);
-    Emit("null");
-  }
-
-  void HandleError(Status error) override {
-    assert(!error.ok());
-    *status_ = error;
-    out_->clear();
-  }
-
- private:
-  void Emit(char c) { out_->push_back(c); }
-  void Emit(const char* str) {
-    out_->insert(out_->end(), str, str + strlen(str));
-  }
-  void Emit(const std::string& str) {
-    out_->insert(out_->end(), str.begin(), str.end());
-  }
-
-  const Platform* platform_;
-  C* out_;
-  Status* status_;
-  std::stack<State> state_;
-};
-}  // namespace
-
-std::unique_ptr<StreamingParserHandler> NewJSONEncoder(
-    const Platform* platform,
-    std::vector<uint8_t>* out,
-    Status* status) {
-  return std::unique_ptr<StreamingParserHandler>(
-      new JSONEncoder<std::vector<uint8_t>>(platform, out, status));
-}
-std::unique_ptr<StreamingParserHandler> NewJSONEncoder(const Platform* platform,
-                                                       std::string* out,
-                                                       Status* status) {
-  return std::unique_ptr<StreamingParserHandler>(
-      new JSONEncoder<std::string>(platform, out, status));
-}
-
-// =============================================================================
-// json::ParseJSON - for receiving streaming parser events for JSON.
-// =============================================================================
-
-namespace {
-const int kStackLimit = 300;
-
-enum Token {
-  ObjectBegin,
-  ObjectEnd,
-  ArrayBegin,
-  ArrayEnd,
-  StringLiteral,
-  Number,
-  BoolTrue,
-  BoolFalse,
-  NullToken,
-  ListSeparator,
-  ObjectPairSeparator,
-  InvalidToken,
-  NoInput
-};
-
-const char* const kNullString = "null";
-const char* const kTrueString = "true";
-const char* const kFalseString = "false";
-
-template <typename Char>
-class JsonParser {
- public:
-  JsonParser(const Platform* platform, StreamingParserHandler* handler)
-      : platform_(platform), handler_(handler) {}
-
-  void Parse(const Char* start, size_t length) {
-    start_pos_ = start;
-    const Char* end = start + length;
-    const Char* tokenEnd = nullptr;
-    ParseValue(start, end, &tokenEnd, 0);
-    if (error_)
-      return;
-    if (tokenEnd != end) {
-      HandleError(Error::JSON_PARSER_UNPROCESSED_INPUT_REMAINS, tokenEnd);
-    }
-  }
-
- private:
-  bool CharsToDouble(const uint16_t* chars, size_t length, double* result) {
-    std::string buffer;
-    buffer.reserve(length + 1);
-    for (size_t ii = 0; ii < length; ++ii) {
-      bool is_ascii = !(chars[ii] & ~0x7F);
-      if (!is_ascii)
-        return false;
-      buffer.push_back(static_cast<char>(chars[ii]));
-    }
-    return platform_->StrToD(buffer.c_str(), result);
-  }
-
-  bool CharsToDouble(const uint8_t* chars, size_t length, double* result) {
-    std::string buffer(reinterpret_cast<const char*>(chars), length);
-    return platform_->StrToD(buffer.c_str(), result);
-  }
-
-  static bool ParseConstToken(const Char* start,
-                              const Char* end,
-                              const Char** token_end,
-                              const char* token) {
-    // |token| is \0 terminated, it's one of the constants at top of the file.
-    while (start < end && *token != '\0' && *start++ == *token++) {
-    }
-    if (*token != '\0')
-      return false;
-    *token_end = start;
-    return true;
-  }
-
-  static bool ReadInt(const Char* start,
-                      const Char* end,
-                      const Char** token_end,
-                      bool allow_leading_zeros) {
-    if (start == end)
-      return false;
-    bool has_leading_zero = '0' == *start;
-    int length = 0;
-    while (start < end && '0' <= *start && *start <= '9') {
-      ++start;
-      ++length;
-    }
-    if (!length)
-      return false;
-    if (!allow_leading_zeros && length > 1 && has_leading_zero)
-      return false;
-    *token_end = start;
-    return true;
-  }
-
-  static bool ParseNumberToken(const Char* start,
-                               const Char* end,
-                               const Char** token_end) {
-    // We just grab the number here. We validate the size in DecodeNumber.
-    // According to RFC4627, a valid number is: [minus] int [frac] [exp]
-    if (start == end)
-      return false;
-    Char c = *start;
-    if ('-' == c)
-      ++start;
-
-    if (!ReadInt(start, end, &start, /*allow_leading_zeros=*/false))
-      return false;
-    if (start == end) {
-      *token_end = start;
-      return true;
-    }
-
-    // Optional fraction part
-    c = *start;
-    if ('.' == c) {
-      ++start;
-      if (!ReadInt(start, end, &start, /*allow_leading_zeros=*/true))
-        return false;
-      if (start == end) {
-        *token_end = start;
-        return true;
-      }
-      c = *start;
-    }
-
-    // Optional exponent part
-    if ('e' == c || 'E' == c) {
-      ++start;
-      if (start == end)
-        return false;
-      c = *start;
-      if ('-' == c || '+' == c) {
-        ++start;
-        if (start == end)
-          return false;
-      }
-      if (!ReadInt(start, end, &start, /*allow_leading_zeros=*/true))
-        return false;
-    }
-
-    *token_end = start;
-    return true;
-  }
-
-  static bool ReadHexDigits(const Char* start,
-                            const Char* end,
-                            const Char** token_end,
-                            int digits) {
-    if (end - start < digits)
-      return false;
-    for (int i = 0; i < digits; ++i) {
-      Char c = *start++;
-      if (!(('0' <= c && c <= '9') || ('a' <= c && c <= 'f') ||
-            ('A' <= c && c <= 'F')))
-        return false;
-    }
-    *token_end = start;
-    return true;
-  }
-
-  static bool ParseStringToken(const Char* start,
-                               const Char* end,
-                               const Char** token_end) {
-    while (start < end) {
-      Char c = *start++;
-      if ('\\' == c) {
-        if (start == end)
-          return false;
-        c = *start++;
-        // Make sure the escaped char is valid.
-        switch (c) {
-          case 'x':
-            if (!ReadHexDigits(start, end, &start, 2))
-              return false;
-            break;
-          case 'u':
-            if (!ReadHexDigits(start, end, &start, 4))
-              return false;
-            break;
-          case '\\':
-          case '/':
-          case 'b':
-          case 'f':
-          case 'n':
-          case 'r':
-          case 't':
-          case 'v':
-          case '"':
-            break;
-          default:
-            return false;
-        }
-      } else if ('"' == c) {
-        *token_end = start;
-        return true;
-      }
-    }
-    return false;
-  }
-
-  static bool SkipComment(const Char* start,
-                          const Char* end,
-                          const Char** comment_end) {
-    if (start == end)
-      return false;
-
-    if (*start != '/' || start + 1 >= end)
-      return false;
-    ++start;
-
-    if (*start == '/') {
-      // Single line comment, read to newline.
-      for (++start; start < end; ++start) {
-        if (*start == '\n' || *start == '\r') {
-          *comment_end = start + 1;
-          return true;
-        }
-      }
-      *comment_end = end;
-      // Comment reaches end-of-input, which is fine.
-      return true;
-    }
-
-    if (*start == '*') {
-      Char previous = '\0';
-      // Block comment, read until end marker.
-      for (++start; start < end; previous = *start++) {
-        if (previous == '*' && *start == '/') {
-          *comment_end = start + 1;
-          return true;
-        }
-      }
-      // Block comment must close before end-of-input.
-      return false;
-    }
-
-    return false;
-  }
-
-  static bool IsSpaceOrNewLine(Char c) {
-    // \v = vertial tab; \f = form feed page break.
-    return c == ' ' || c == '\n' || c == '\v' || c == '\f' || c == '\r' ||
-           c == '\t';
-  }
-
-  static void SkipWhitespaceAndComments(const Char* start,
-                                        const Char* end,
-                                        const Char** whitespace_end) {
-    while (start < end) {
-      if (IsSpaceOrNewLine(*start)) {
-        ++start;
-      } else if (*start == '/') {
-        const Char* comment_end = nullptr;
-        if (!SkipComment(start, end, &comment_end))
-          break;
-        start = comment_end;
-      } else {
-        break;
-      }
-    }
-    *whitespace_end = start;
-  }
-
-  static Token ParseToken(const Char* start,
-                          const Char* end,
-                          const Char** tokenStart,
-                          const Char** token_end) {
-    SkipWhitespaceAndComments(start, end, tokenStart);
-    start = *tokenStart;
-
-    if (start == end)
-      return NoInput;
-
-    switch (*start) {
-      case 'n':
-        if (ParseConstToken(start, end, token_end, kNullString))
-          return NullToken;
-        break;
-      case 't':
-        if (ParseConstToken(start, end, token_end, kTrueString))
-          return BoolTrue;
-        break;
-      case 'f':
-        if (ParseConstToken(start, end, token_end, kFalseString))
-          return BoolFalse;
-        break;
-      case '[':
-        *token_end = start + 1;
-        return ArrayBegin;
-      case ']':
-        *token_end = start + 1;
-        return ArrayEnd;
-      case ',':
-        *token_end = start + 1;
-        return ListSeparator;
-      case '{':
-        *token_end = start + 1;
-        return ObjectBegin;
-      case '}':
-        *token_end = start + 1;
-        return ObjectEnd;
-      case ':':
-        *token_end = start + 1;
-        return ObjectPairSeparator;
-      case '0':
-      case '1':
-      case '2':
-      case '3':
-      case '4':
-      case '5':
-      case '6':
-      case '7':
-      case '8':
-      case '9':
-      case '-':
-        if (ParseNumberToken(start, end, token_end))
-          return Number;
-        break;
-      case '"':
-        if (ParseStringToken(start + 1, end, token_end))
-          return StringLiteral;
-        break;
-    }
-    return InvalidToken;
-  }
-
-  static int HexToInt(Char c) {
-    if ('0' <= c && c <= '9')
-      return c - '0';
-    if ('A' <= c && c <= 'F')
-      return c - 'A' + 10;
-    if ('a' <= c && c <= 'f')
-      return c - 'a' + 10;
-    assert(false);  // Unreachable.
-    return 0;
-  }
-
-  static bool DecodeString(const Char* start,
-                           const Char* end,
-                           std::vector<uint16_t>* output) {
-    if (start == end)
-      return true;
-    if (start > end)
-      return false;
-    output->reserve(end - start);
-    while (start < end) {
-      uint16_t c = *start++;
-      // If the |Char| we're dealing with is really a byte, then
-      // we have utf8 here, and we need to check for multibyte characters
-      // and transcode them to utf16 (either one or two utf16 chars).
-      if (sizeof(Char) == sizeof(uint8_t) && c > 0x7f) {
-        // Inspect the leading byte to figure out how long the utf8
-        // byte sequence is; while doing this initialize |codepoint|
-        // with the first few bits.
-        // See table in: https://en.wikipedia.org/wiki/UTF-8
-        // byte one is 110x xxxx -> 2 byte utf8 sequence
-        // byte one is 1110 xxxx -> 3 byte utf8 sequence
-        // byte one is 1111 0xxx -> 4 byte utf8 sequence
-        uint32_t codepoint;
-        int num_bytes_left;
-        if ((c & 0xe0) == 0xc0) {  // 2 byte utf8 sequence
-          num_bytes_left = 1;
-          codepoint = c & 0x1f;
-        } else if ((c & 0xf0) == 0xe0) {  // 3 byte utf8 sequence
-          num_bytes_left = 2;
-          codepoint = c & 0x0f;
-        } else if ((c & 0xf8) == 0xf0) {  // 4 byte utf8 sequence
-          codepoint = c & 0x07;
-          num_bytes_left = 3;
-        } else {
-          return false;  // invalid leading byte
-        }
-
-        // If we have enough bytes in our inpput, decode the remaining ones
-        // belonging to this Unicode character into |codepoint|.
-        if (start + num_bytes_left > end)
-          return false;
-        while (num_bytes_left > 0) {
-          c = *start++;
-          --num_bytes_left;
-          // Check the next byte is a continuation byte, that is 10xx xxxx.
-          if ((c & 0xc0) != 0x80)
-            return false;
-          codepoint = (codepoint << 6) | (c & 0x3f);
-        }
-
-        // Disallow overlong encodings for ascii characters, as these
-        // would include " and other characters significant to JSON
-        // string termination / control.
-        if (codepoint <= 0x7f)
-          return false;
-        // Invalid in UTF8, and can't be represented in UTF16 anyway.
-        if (codepoint > 0x10ffff)
-          return false;
-
-        // So, now we transcode to UTF16,
-        // using the math described at https://en.wikipedia.org/wiki/UTF-16,
-        // for either one or two 16 bit characters.
-        if (codepoint < 0xffff) {
-          output->push_back(codepoint);
-          continue;
-        }
-        codepoint -= 0x10000;
-        output->push_back((codepoint >> 10) + 0xd800);    // high surrogate
-        output->push_back((codepoint & 0x3ff) + 0xdc00);  // low surrogate
-        continue;
-      }
-      if ('\\' != c) {
-        output->push_back(c);
-        continue;
-      }
-      if (start == end)
-        return false;
-      c = *start++;
-
-      if (c == 'x') {
-        // \x is not supported.
-        return false;
-      }
-
-      switch (c) {
-        case '"':
-        case '/':
-        case '\\':
-          break;
-        case 'b':
-          c = '\b';
-          break;
-        case 'f':
-          c = '\f';
-          break;
-        case 'n':
-          c = '\n';
-          break;
-        case 'r':
-          c = '\r';
-          break;
-        case 't':
-          c = '\t';
-          break;
-        case 'v':
-          c = '\v';
-          break;
-        case 'u':
-          c = (HexToInt(*start) << 12) + (HexToInt(*(start + 1)) << 8) +
-              (HexToInt(*(start + 2)) << 4) + HexToInt(*(start + 3));
-          start += 4;
-          break;
-        default:
-          return false;
-      }
-      output->push_back(c);
-    }
-    return true;
-  }
-
-  void ParseValue(const Char* start,
-                  const Char* end,
-                  const Char** value_token_end,
-                  int depth) {
-    if (depth > kStackLimit) {
-      HandleError(Error::JSON_PARSER_STACK_LIMIT_EXCEEDED, start);
-      return;
-    }
-    const Char* token_start = nullptr;
-    const Char* token_end = nullptr;
-    Token token = ParseToken(start, end, &token_start, &token_end);
-    switch (token) {
-      case NoInput:
-        HandleError(Error::JSON_PARSER_NO_INPUT, token_start);
-        return;
-      case InvalidToken:
-        HandleError(Error::JSON_PARSER_INVALID_TOKEN, token_start);
-        return;
-      case NullToken:
-        handler_->HandleNull();
-        break;
-      case BoolTrue:
-        handler_->HandleBool(true);
-        break;
-      case BoolFalse:
-        handler_->HandleBool(false);
-        break;
-      case Number: {
-        double value;
-        if (!CharsToDouble(token_start, token_end - token_start, &value)) {
-          HandleError(Error::JSON_PARSER_INVALID_NUMBER, token_start);
-          return;
-        }
-        if (value >= std::numeric_limits<int32_t>::min() &&
-            value <= std::numeric_limits<int32_t>::max() &&
-            static_cast<int32_t>(value) == value)
-          handler_->HandleInt32(static_cast<int32_t>(value));
-        else
-          handler_->HandleDouble(value);
-        break;
-      }
-      case StringLiteral: {
-        std::vector<uint16_t> value;
-        bool ok = DecodeString(token_start + 1, token_end - 1, &value);
-        if (!ok) {
-          HandleError(Error::JSON_PARSER_INVALID_STRING, token_start);
-          return;
-        }
-        handler_->HandleString16(span<uint16_t>(value.data(), value.size()));
-        break;
-      }
-      case ArrayBegin: {
-        handler_->HandleArrayBegin();
-        start = token_end;
-        token = ParseToken(start, end, &token_start, &token_end);
-        while (token != ArrayEnd) {
-          ParseValue(start, end, &token_end, depth + 1);
-          if (error_)
-            return;
-
-          // After a list value, we expect a comma or the end of the list.
-          start = token_end;
-          token = ParseToken(start, end, &token_start, &token_end);
-          if (token == ListSeparator) {
-            start = token_end;
-            token = ParseToken(start, end, &token_start, &token_end);
-            if (token == ArrayEnd) {
-              HandleError(Error::JSON_PARSER_UNEXPECTED_ARRAY_END, token_start);
-              return;
-            }
-          } else if (token != ArrayEnd) {
-            // Unexpected value after list value. Bail out.
-            HandleError(Error::JSON_PARSER_COMMA_OR_ARRAY_END_EXPECTED,
-                        token_start);
-            return;
-          }
-        }
-        handler_->HandleArrayEnd();
-        break;
-      }
-      case ObjectBegin: {
-        handler_->HandleMapBegin();
-        start = token_end;
-        token = ParseToken(start, end, &token_start, &token_end);
-        while (token != ObjectEnd) {
-          if (token != StringLiteral) {
-            HandleError(Error::JSON_PARSER_STRING_LITERAL_EXPECTED,
-                        token_start);
-            return;
-          }
-          std::vector<uint16_t> key;
-          if (!DecodeString(token_start + 1, token_end - 1, &key)) {
-            HandleError(Error::JSON_PARSER_INVALID_STRING, token_start);
-            return;
-          }
-          handler_->HandleString16(span<uint16_t>(key.data(), key.size()));
-          start = token_end;
-
-          token = ParseToken(start, end, &token_start, &token_end);
-          if (token != ObjectPairSeparator) {
-            HandleError(Error::JSON_PARSER_COLON_EXPECTED, token_start);
-            return;
-          }
-          start = token_end;
-
-          ParseValue(start, end, &token_end, depth + 1);
-          if (error_)
-            return;
-          start = token_end;
-
-          // After a key/value pair, we expect a comma or the end of the
-          // object.
-          token = ParseToken(start, end, &token_start, &token_end);
-          if (token == ListSeparator) {
-            start = token_end;
-            token = ParseToken(start, end, &token_start, &token_end);
-            if (token == ObjectEnd) {
-              HandleError(Error::JSON_PARSER_UNEXPECTED_MAP_END, token_start);
-              return;
-            }
-          } else if (token != ObjectEnd) {
-            // Unexpected value after last object value. Bail out.
-            HandleError(Error::JSON_PARSER_COMMA_OR_MAP_END_EXPECTED,
-                        token_start);
-            return;
-          }
-        }
-        handler_->HandleMapEnd();
-        break;
-      }
-
-      default:
-        // We got a token that's not a value.
-        HandleError(Error::JSON_PARSER_VALUE_EXPECTED, token_start);
-        return;
-    }
-
-    SkipWhitespaceAndComments(token_end, end, value_token_end);
-  }
-
-  void HandleError(Error error, const Char* pos) {
-    assert(error != Error::OK);
-    if (!error_) {
-      handler_->HandleError(
-          Status{error, static_cast<size_t>(pos - start_pos_)});
-      error_ = true;
-    }
-  }
-
-  const Char* start_pos_ = nullptr;
-  bool error_ = false;
-  const Platform* platform_;
-  StreamingParserHandler* handler_;
-};
-}  // namespace
-
-void ParseJSON(const Platform& platform,
-               span<uint8_t> chars,
-               StreamingParserHandler* handler) {
-  JsonParser<uint8_t> parser(&platform, handler);
-  parser.Parse(chars.data(), chars.size());
-}
-
-void ParseJSON(const Platform& platform,
-               span<uint16_t> chars,
-               StreamingParserHandler* handler) {
-  JsonParser<uint16_t> parser(&platform, handler);
-  parser.Parse(chars.data(), chars.size());
-}
-
-// =============================================================================
-// json::ConvertCBORToJSON, json::ConvertJSONToCBOR - for transcoding
-// =============================================================================
-template <typename C>
-Status ConvertCBORToJSONTmpl(const Platform& platform,
-                             span<uint8_t> cbor,
-                             C* json) {
-  Status status;
-  std::unique_ptr<StreamingParserHandler> json_writer =
-      NewJSONEncoder(&platform, json, &status);
-  cbor::ParseCBOR(cbor, json_writer.get());
-  return status;
-}
-
-Status ConvertCBORToJSON(const Platform& platform,
-                         span<uint8_t> cbor,
-                         std::vector<uint8_t>* json) {
-  return ConvertCBORToJSONTmpl(platform, cbor, json);
-}
-Status ConvertCBORToJSON(const Platform& platform,
-                         span<uint8_t> cbor,
-                         std::string* json) {
-  return ConvertCBORToJSONTmpl(platform, cbor, json);
-}
-
-template <typename T, typename C>
-Status ConvertJSONToCBORTmpl(const Platform& platform, span<T> json, C* cbor) {
-  Status status;
-  std::unique_ptr<StreamingParserHandler> encoder =
-      cbor::NewCBOREncoder(cbor, &status);
-  ParseJSON(platform, json, encoder.get());
-  return status;
-}
-Status ConvertJSONToCBOR(const Platform& platform,
-                         span<uint8_t> json,
-                         std::string* cbor) {
-  return ConvertJSONToCBORTmpl(platform, json, cbor);
-}
-Status ConvertJSONToCBOR(const Platform& platform,
-                         span<uint16_t> json,
-                         std::string* cbor) {
-  return ConvertJSONToCBORTmpl(platform, json, cbor);
-}
-Status ConvertJSONToCBOR(const Platform& platform,
-                         span<uint8_t> json,
-                         std::vector<uint8_t>* cbor) {
-  return ConvertJSONToCBORTmpl(platform, json, cbor);
-}
-Status ConvertJSONToCBOR(const Platform& platform,
-                         span<uint16_t> json,
-                         std::vector<uint8_t>* cbor) {
-  return ConvertJSONToCBORTmpl(platform, json, cbor);
-}
-}  // namespace json
-
-{% for namespace in config.protocol.namespace %}
-} // namespace {{namespace}}
-{% endfor %}
-
-{% endif %}
diff --git a/tools/inspector_protocol/lib/encoding_h.template b/tools/inspector_protocol/lib/encoding_h.template
deleted file mode 100644
index 2601192e160543..00000000000000
--- a/tools/inspector_protocol/lib/encoding_h.template
+++ /dev/null
@@ -1,552 +0,0 @@
-{# This template is generated by gen_cbor_templates.py. #}
-// Generated by lib/encoding_h.template.
-
-// Copyright 2019 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-{% if config.encoding_lib.header == "" %}
-#ifndef {{"_".join(config.protocol.namespace)}}_encoding_h
-#define {{"_".join(config.protocol.namespace)}}_encoding_h
-
-#include <algorithm>
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <limits>
-#include <memory>
-#include <string>
-#include <vector>
-
-{% for namespace in config.protocol.namespace %}
-namespace {{namespace}} {
-{% endfor %}
-
-// ===== encoding/encoding.h =====
-
-// This library is designed to be portable. The only allowed dependency
-// are the C/C++ standard libraries, up to C++11. We support both 32 bit
-// and 64 architectures.
-//
-// Types used below:
-// uint8_t: a byte, e.g. for raw bytes or UTF8 characters
-// uint16_t: two bytes, e.g. for UTF16 characters
-// For input parameters:
-//   span<uint8_t>: pointer to bytes and length
-//   span<uint16_t>: pointer to UTF16 chars and length
-// For output parameters:
-//   std::vector<uint8_t> - Owned segment of bytes / utf8 characters and length.
-//   std::string - Same, for compatibility, even though char is signed.
-
-// =============================================================================
-// span - sequence of bytes
-// =============================================================================
-
-// This template is similar to std::span, which will be included in C++20.
-template <typename T>
-class span {
- public:
-  using index_type = size_t;
-
-  span() : data_(nullptr), size_(0) {}
-  span(const T* data, index_type size) : data_(data), size_(size) {}
-
-  const T* data() const { return data_; }
-
-  const T* begin() const { return data_; }
-  const T* end() const { return data_ + size_; }
-
-  const T& operator[](index_type idx) const { return data_[idx]; }
-
-  span<T> subspan(index_type offset, index_type count) const {
-    return span(data_ + offset, count);
-  }
-
-  span<T> subspan(index_type offset) const {
-    return span(data_ + offset, size_ - offset);
-  }
-
-  bool empty() const { return size_ == 0; }
-
-  index_type size() const { return size_; }
-  index_type size_bytes() const { return size_ * sizeof(T); }
-
- private:
-  const T* data_;
-  index_type size_;
-};
-
-template <typename T>
-span<T> SpanFrom(const std::vector<T>& v) {
-  return span<T>(v.data(), v.size());
-}
-
-template <size_t N>
-span<uint8_t> SpanFrom(const char (&str)[N]) {
-  return span<uint8_t>(reinterpret_cast<const uint8_t*>(str), N - 1);
-}
-
-inline span<uint8_t> SpanFrom(const char* str) {
-  return str ? span<uint8_t>(reinterpret_cast<const uint8_t*>(str), strlen(str))
-             : span<uint8_t>();
-}
-
-inline span<uint8_t> SpanFrom(const std::string& v) {
-  return span<uint8_t>(reinterpret_cast<const uint8_t*>(v.data()), v.size());
-}
-
-// Less than / equality comparison functions for sorting / searching for byte
-// spans. These are similar to absl::string_view's < and == operators.
-inline bool SpanLessThan(span<uint8_t> x, span<uint8_t> y) noexcept {
-  auto min_size = std::min(x.size(), y.size());
-  const int r = min_size == 0 ? 0 : memcmp(x.data(), y.data(), min_size);
-  return (r < 0) || (r == 0 && x.size() < y.size());
-}
-
-inline bool SpanEquals(span<uint8_t> x, span<uint8_t> y) noexcept {
-  auto len = x.size();
-  if (len != y.size())
-    return false;
-  return x.data() == y.data() || len == 0 ||
-         std::memcmp(x.data(), y.data(), len) == 0;
-}
-
-// =============================================================================
-// Status and Error codes
-// =============================================================================
-enum class Error {
-  OK = 0,
-  // JSON parsing errors - json_parser.{h,cc}.
-  JSON_PARSER_UNPROCESSED_INPUT_REMAINS = 0x01,
-  JSON_PARSER_STACK_LIMIT_EXCEEDED = 0x02,
-  JSON_PARSER_NO_INPUT = 0x03,
-  JSON_PARSER_INVALID_TOKEN = 0x04,
-  JSON_PARSER_INVALID_NUMBER = 0x05,
-  JSON_PARSER_INVALID_STRING = 0x06,
-  JSON_PARSER_UNEXPECTED_ARRAY_END = 0x07,
-  JSON_PARSER_COMMA_OR_ARRAY_END_EXPECTED = 0x08,
-  JSON_PARSER_STRING_LITERAL_EXPECTED = 0x09,
-  JSON_PARSER_COLON_EXPECTED = 0x0a,
-  JSON_PARSER_UNEXPECTED_MAP_END = 0x0b,
-  JSON_PARSER_COMMA_OR_MAP_END_EXPECTED = 0x0c,
-  JSON_PARSER_VALUE_EXPECTED = 0x0d,
-
-  CBOR_INVALID_INT32 = 0x0e,
-  CBOR_INVALID_DOUBLE = 0x0f,
-  CBOR_INVALID_ENVELOPE = 0x10,
-  CBOR_INVALID_STRING8 = 0x11,
-  CBOR_INVALID_STRING16 = 0x12,
-  CBOR_INVALID_BINARY = 0x13,
-  CBOR_UNSUPPORTED_VALUE = 0x14,
-  CBOR_NO_INPUT = 0x15,
-  CBOR_INVALID_START_BYTE = 0x16,
-  CBOR_UNEXPECTED_EOF_EXPECTED_VALUE = 0x17,
-  CBOR_UNEXPECTED_EOF_IN_ARRAY = 0x18,
-  CBOR_UNEXPECTED_EOF_IN_MAP = 0x19,
-  CBOR_INVALID_MAP_KEY = 0x1a,
-  CBOR_STACK_LIMIT_EXCEEDED = 0x1b,
-  CBOR_TRAILING_JUNK = 0x1c,
-  CBOR_MAP_START_EXPECTED = 0x1d,
-  CBOR_MAP_STOP_EXPECTED = 0x1e,
-  CBOR_ENVELOPE_SIZE_LIMIT_EXCEEDED = 0x1f,
-};
-
-// A status value with position that can be copied. The default status
-// is OK. Usually, error status values should come with a valid position.
-struct Status {
-  static constexpr size_t npos() { return std::numeric_limits<size_t>::max(); }
-
-  bool ok() const { return error == Error::OK; }
-
-  Error error = Error::OK;
-  size_t pos = npos();
-  Status(Error error, size_t pos) : error(error), pos(pos) {}
-  Status() = default;
-
-  // Returns a 7 bit US-ASCII string, either "OK" or an error message
-  // that includes the position.
-  std::string ToASCIIString() const;
-
- private:
-  std::string ToASCIIString(const char* msg) const;
-};
-
-// Handler interface for parser events emitted by a streaming parser.
-// See cbor::NewCBOREncoder, cbor::ParseCBOR, json::NewJSONEncoder,
-// json::ParseJSON.
-class StreamingParserHandler {
- public:
-  virtual ~StreamingParserHandler() = default;
-  virtual void HandleMapBegin() = 0;
-  virtual void HandleMapEnd() = 0;
-  virtual void HandleArrayBegin() = 0;
-  virtual void HandleArrayEnd() = 0;
-  virtual void HandleString8(span<uint8_t> chars) = 0;
-  virtual void HandleString16(span<uint16_t> chars) = 0;
-  virtual void HandleBinary(span<uint8_t> bytes) = 0;
-  virtual void HandleDouble(double value) = 0;
-  virtual void HandleInt32(int32_t value) = 0;
-  virtual void HandleBool(bool value) = 0;
-  virtual void HandleNull() = 0;
-
-  // The parser may send one error even after other events have already
-  // been received. Client code is reponsible to then discard the
-  // already processed events.
-  // |error| must be an eror, as in, |error.is_ok()| can't be true.
-  virtual void HandleError(Status error) = 0;
-};
-
-namespace cbor {
-// The binary encoding for the inspector protocol follows the CBOR specification
-// (RFC 7049). Additional constraints:
-// - Only indefinite length maps and arrays are supported.
-// - Maps and arrays are wrapped with an envelope, that is, a
-//   CBOR tag with value 24 followed by a byte string specifying
-//   the byte length of the enclosed map / array. The byte string
-//   must use a 32 bit wide length.
-// - At the top level, a message must be an indefinite length map
-//   wrapped by an envelope.
-// - Maximal size for messages is 2^32 (4 GiB).
-// - For scalars, we support only the int32_t range, encoded as
-//   UNSIGNED/NEGATIVE (major types 0 / 1).
-// - UTF16 strings, including with unbalanced surrogate pairs, are encoded
-//   as CBOR BYTE_STRING (major type 2). For such strings, the number of
-//   bytes encoded must be even.
-// - UTF8 strings (major type 3) are supported.
-// - 7 bit US-ASCII strings must always be encoded as UTF8 strings, never
-//   as UTF16 strings.
-// - Arbitrary byte arrays, in the inspector protocol called 'binary',
-//   are encoded as BYTE_STRING (major type 2), prefixed with a byte
-//   indicating base64 when rendered as JSON.
-
-// =============================================================================
-// Detecting CBOR content
-// =============================================================================
-
-// The first byte for an envelope, which we use for wrapping dictionaries
-// and arrays; and the byte that indicates a byte string with 32 bit length.
-// These two bytes start an envelope, and thereby also any CBOR message
-// produced or consumed by this protocol. See also |EnvelopeEncoder| below.
-uint8_t InitialByteForEnvelope();
-uint8_t InitialByteFor32BitLengthByteString();
-
-// Checks whether |msg| is a cbor message.
-bool IsCBORMessage(span<uint8_t> msg);
-
-// =============================================================================
-// Encoding individual CBOR items
-// =============================================================================
-
-// Some constants for CBOR tokens that only take a single byte on the wire.
-uint8_t EncodeTrue();
-uint8_t EncodeFalse();
-uint8_t EncodeNull();
-uint8_t EncodeIndefiniteLengthArrayStart();
-uint8_t EncodeIndefiniteLengthMapStart();
-uint8_t EncodeStop();
-
-// Encodes |value| as |UNSIGNED| (major type 0) iff >= 0, or |NEGATIVE|
-// (major type 1) iff < 0.
-void EncodeInt32(int32_t value, std::vector<uint8_t>* out);
-void EncodeInt32(int32_t value, std::string* out);
-
-// Encodes a UTF16 string as a BYTE_STRING (major type 2). Each utf16
-// character in |in| is emitted with most significant byte first,
-// appending to |out|.
-void EncodeString16(span<uint16_t> in, std::vector<uint8_t>* out);
-void EncodeString16(span<uint16_t> in, std::string* out);
-
-// Encodes a UTF8 string |in| as STRING (major type 3).
-void EncodeString8(span<uint8_t> in, std::vector<uint8_t>* out);
-void EncodeString8(span<uint8_t> in, std::string* out);
-
-// Encodes the given |latin1| string as STRING8.
-// If any non-ASCII character is present, it will be represented
-// as a 2 byte UTF8 sequence.
-void EncodeFromLatin1(span<uint8_t> latin1, std::vector<uint8_t>* out);
-void EncodeFromLatin1(span<uint8_t> latin1, std::string* out);
-
-// Encodes the given |utf16| string as STRING8 if it's entirely US-ASCII.
-// Otherwise, encodes as STRING16.
-void EncodeFromUTF16(span<uint16_t> utf16, std::vector<uint8_t>* out);
-void EncodeFromUTF16(span<uint16_t> utf16, std::string* out);
-
-// Encodes arbitrary binary data in |in| as a BYTE_STRING (major type 2) with
-// definitive length, prefixed with tag 22 indicating expected conversion to
-// base64 (see RFC 7049, Table 3 and Section 2.4.4.2).
-void EncodeBinary(span<uint8_t> in, std::vector<uint8_t>* out);
-void EncodeBinary(span<uint8_t> in, std::string* out);
-
-// Encodes / decodes a double as Major type 7 (SIMPLE_VALUE),
-// with additional info = 27, followed by 8 bytes in big endian.
-void EncodeDouble(double value, std::vector<uint8_t>* out);
-void EncodeDouble(double value, std::string* out);
-
-// =============================================================================
-// cbor::EnvelopeEncoder - for wrapping submessages
-// =============================================================================
-
-// An envelope indicates the byte length of a wrapped item.
-// We use this for maps and array, which allows the decoder
-// to skip such (nested) values whole sale.
-// It's implemented as a CBOR tag (major type 6) with additional
-// info = 24, followed by a byte string with a 32 bit length value;
-// so the maximal structure that we can wrap is 2^32 bits long.
-// See also: https://tools.ietf.org/html/rfc7049#section-2.4.4.1
-class EnvelopeEncoder {
- public:
-  // Emits the envelope start bytes and records the position for the
-  // byte size in |byte_size_pos_|. Also emits empty bytes for the
-  // byte sisze so that encoding can continue.
-  void EncodeStart(std::vector<uint8_t>* out);
-  void EncodeStart(std::string* out);
-  // This records the current size in |out| at position byte_size_pos_.
-  // Returns true iff successful.
-  bool EncodeStop(std::vector<uint8_t>* out);
-  bool EncodeStop(std::string* out);
-
- private:
-  size_t byte_size_pos_ = 0;
-};
-
-// =============================================================================
-// cbor::NewCBOREncoder - for encoding from a streaming parser
-// =============================================================================
-
-// This can be used to convert to CBOR, by passing the return value to a parser
-// that drives it. The handler will encode into |out|, and iff an error occurs
-// it will set |status| to an error and clear |out|. Otherwise, |status.ok()|
-// will be |true|.
-std::unique_ptr<StreamingParserHandler> NewCBOREncoder(
-    std::vector<uint8_t>* out,
-    Status* status);
-std::unique_ptr<StreamingParserHandler> NewCBOREncoder(std::string* out,
-                                                       Status* status);
-
-// =============================================================================
-// cbor::CBORTokenizer - for parsing individual CBOR items
-// =============================================================================
-
-// Tags for the tokens within a CBOR message that CBORTokenizer understands.
-// Note that this is not the same terminology as the CBOR spec (RFC 7049),
-// but rather, our adaptation. For instance, we lump unsigned and signed
-// major type into INT32 here (and disallow values outside the int32_t range).
-enum class CBORTokenTag {
-  // Encountered an error in the structure of the message. Consult
-  // status() for details.
-  ERROR_VALUE,
-  // Booleans and NULL.
-  TRUE_VALUE,
-  FALSE_VALUE,
-  NULL_VALUE,
-  // An int32_t (signed 32 bit integer).
-  INT32,
-  // A double (64 bit floating point).
-  DOUBLE,
-  // A UTF8 string.
-  STRING8,
-  // A UTF16 string.
-  STRING16,
-  // A binary string.
-  BINARY,
-  // Starts an indefinite length map; after the map start we expect
-  // alternating keys and values, followed by STOP.
-  MAP_START,
-  // Starts an indefinite length array; after the array start we
-  // expect values, followed by STOP.
-  ARRAY_START,
-  // Ends a map or an array.
-  STOP,
-  // An envelope indicator, wrapping a map or array.
-  // Internally this carries the byte length of the wrapped
-  // map or array. While CBORTokenizer::Next() will read / skip the entire
-  // envelope, CBORTokenizer::EnterEnvelope() reads the tokens
-  // inside of it.
-  ENVELOPE,
-  // We've reached the end there is nothing else to read.
-  DONE,
-};
-
-// The major types from RFC 7049 Section 2.1.
-enum class MajorType {
-  UNSIGNED = 0,
-  NEGATIVE = 1,
-  BYTE_STRING = 2,
-  STRING = 3,
-  ARRAY = 4,
-  MAP = 5,
-  TAG = 6,
-  SIMPLE_VALUE = 7
-};
-
-// CBORTokenizer segments a CBOR message, presenting the tokens therein as
-// numbers, strings, etc. This is not a complete CBOR parser, but makes it much
-// easier to implement one (e.g. ParseCBOR, above). It can also be used to parse
-// messages partially.
-class CBORTokenizer {
- public:
-  explicit CBORTokenizer(span<uint8_t> bytes);
-  ~CBORTokenizer();
-
-  // Identifies the current token that we're looking at,
-  // or ERROR_VALUE (in which ase ::Status() has details)
-  // or DONE (if we're past the last token).
-  CBORTokenTag TokenTag() const;
-
-  // Advances to the next token.
-  void Next();
-  // Can only be called if TokenTag() == CBORTokenTag::ENVELOPE.
-  // While Next() would skip past the entire envelope / what it's
-  // wrapping, EnterEnvelope positions the cursor inside of the envelope,
-  // letting the client explore the nested structure.
-  void EnterEnvelope();
-
-  // If TokenTag() is CBORTokenTag::ERROR_VALUE, then Status().error describes
-  // the error more precisely; otherwise it'll be set to Error::OK.
-  // In either case, Status().pos is the current position.
-  struct Status Status() const;
-
-  // The following methods retrieve the token values. They can only
-  // be called if TokenTag() matches.
-
-  // To be called only if ::TokenTag() == CBORTokenTag::INT32.
-  int32_t GetInt32() const;
-
-  // To be called only if ::TokenTag() == CBORTokenTag::DOUBLE.
-  double GetDouble() const;
-
-  // To be called only if ::TokenTag() == CBORTokenTag::STRING8.
-  span<uint8_t> GetString8() const;
-
-  // Wire representation for STRING16 is low byte first (little endian).
-  // To be called only if ::TokenTag() == CBORTokenTag::STRING16.
-  span<uint8_t> GetString16WireRep() const;
-
-  // To be called only if ::TokenTag() == CBORTokenTag::BINARY.
-  span<uint8_t> GetBinary() const;
-
-  // To be called only if ::TokenTag() == CBORTokenTag::ENVELOPE.
-  span<uint8_t> GetEnvelopeContents() const;
-
- private:
-  void ReadNextToken(bool enter_envelope);
-  void SetToken(CBORTokenTag token, size_t token_byte_length);
-  void SetError(Error error);
-
-  span<uint8_t> bytes_;
-  CBORTokenTag token_tag_;
-  struct Status status_;
-  size_t token_byte_length_;
-  MajorType token_start_type_;
-  uint64_t token_start_internal_value_;
-};
-
-// =============================================================================
-// cbor::ParseCBOR - for receiving streaming parser events for CBOR messages
-// =============================================================================
-
-// Parses a CBOR encoded message from |bytes|, sending events to
-// |out|. If an error occurs, sends |out->HandleError|, and parsing stops.
-// The client is responsible for discarding the already received information in
-// that case.
-void ParseCBOR(span<uint8_t> bytes, StreamingParserHandler* out);
-
-// =============================================================================
-// cbor::AppendString8EntryToMap - for limited in-place editing of messages
-// =============================================================================
-
-// Modifies the |cbor| message by appending a new key/value entry at the end
-// of the map. Patches up the envelope size; Status.ok() iff successful.
-// If not successful, |cbor| may be corrupted after this call.
-Status AppendString8EntryToCBORMap(span<uint8_t> string8_key,
-                                   span<uint8_t> string8_value,
-                                   std::vector<uint8_t>* cbor);
-Status AppendString8EntryToCBORMap(span<uint8_t> string8_key,
-                                   span<uint8_t> string8_value,
-                                   std::string* cbor);
-
-namespace internals {  // Exposed only for writing tests.
-size_t ReadTokenStart(span<uint8_t> bytes,
-                      cbor::MajorType* type,
-                      uint64_t* value);
-
-void WriteTokenStart(cbor::MajorType type,
-                     uint64_t value,
-                     std::vector<uint8_t>* encoded);
-void WriteTokenStart(cbor::MajorType type,
-                     uint64_t value,
-                     std::string* encoded);
-}  // namespace internals
-}  // namespace cbor
-
-namespace json {
-// Client code must provide an instance. Implementation should delegate
-// to whatever is appropriate.
-class Platform {
- public:
-  virtual ~Platform() = default;
-  // Parses |str| into |result|. Returns false iff there are
-  // leftover characters or parsing errors.
-  virtual bool StrToD(const char* str, double* result) const = 0;
-
-  // Prints |value| in a format suitable for JSON.
-  virtual std::unique_ptr<char[]> DToStr(double value) const = 0;
-};
-
-// =============================================================================
-// json::NewJSONEncoder - for encoding streaming parser events as JSON
-// =============================================================================
-
-// Returns a handler object which will write ascii characters to |out|.
-// |status->ok()| will be false iff the handler routine HandleError() is called.
-// In that case, we'll stop emitting output.
-// Except for calling the HandleError routine at any time, the client
-// code must call the Handle* methods in an order in which they'd occur
-// in valid JSON; otherwise we may crash (the code uses assert).
-std::unique_ptr<StreamingParserHandler> NewJSONEncoder(
-    const Platform* platform,
-    std::vector<uint8_t>* out,
-    Status* status);
-std::unique_ptr<StreamingParserHandler> NewJSONEncoder(const Platform* platform,
-                                                       std::string* out,
-                                                       Status* status);
-
-// =============================================================================
-// json::ParseJSON - for receiving streaming parser events for JSON
-// =============================================================================
-
-void ParseJSON(const Platform& platform,
-               span<uint8_t> chars,
-               StreamingParserHandler* handler);
-void ParseJSON(const Platform& platform,
-               span<uint16_t> chars,
-               StreamingParserHandler* handler);
-
-// =============================================================================
-// json::ConvertCBORToJSON, json::ConvertJSONToCBOR - for transcoding
-// =============================================================================
-Status ConvertCBORToJSON(const Platform& platform,
-                         span<uint8_t> cbor,
-                         std::string* json);
-Status ConvertCBORToJSON(const Platform& platform,
-                         span<uint8_t> cbor,
-                         std::vector<uint8_t>* json);
-Status ConvertJSONToCBOR(const Platform& platform,
-                         span<uint8_t> json,
-                         std::vector<uint8_t>* cbor);
-Status ConvertJSONToCBOR(const Platform& platform,
-                         span<uint16_t> json,
-                         std::vector<uint8_t>* cbor);
-Status ConvertJSONToCBOR(const Platform& platform,
-                         span<uint8_t> json,
-                         std::string* cbor);
-Status ConvertJSONToCBOR(const Platform& platform,
-                         span<uint16_t> json,
-                         std::string* cbor);
-}  // namespace json
-
-{% for namespace in config.protocol.namespace %}
-} // namespace {{namespace}}
-{% endfor %}
-#endif // !defined({{"_".join(config.protocol.namespace)}}_encoding_h)
-{% endif %}
diff --git a/tools/inspector_protocol/pdl.py b/tools/inspector_protocol/pdl.py
index 03d11b39d636df..6b448c07443c7e 100644
--- a/tools/inspector_protocol/pdl.py
+++ b/tools/inspector_protocol/pdl.py
@@ -1,4 +1,4 @@
-# Copyright 2018 The Chromium Authors. All rights reserved.
+# Copyright 2018 The Chromium Authors
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
@@ -12,160 +12,170 @@
 description = ''
 
 
-primitiveTypes = ['integer', 'number', 'boolean', 'string', 'object', 'any', 'array', 'binary']
+primitiveTypes = ['integer', 'number', 'boolean', 'string', 'object',
+                  'any', 'array', 'binary']
 
 
 def assignType(item, type, is_array=False, map_binary_to_string=False):
-    if is_array:
-        item['type'] = 'array'
-        item['items'] = collections.OrderedDict()
-        assignType(item['items'], type, False, map_binary_to_string)
-        return
-
-    if type == 'enum':
-        type = 'string'
-    if map_binary_to_string and type == 'binary':
-        type = 'string'
-    if type in primitiveTypes:
-        item['type'] = type
-    else:
-        item['$ref'] = type
+  if is_array:
+    item['type'] = 'array'
+    item['items'] = collections.OrderedDict()
+    assignType(item['items'], type, False, map_binary_to_string)
+    return
+
+  if type == 'enum':
+    type = 'string'
+  if map_binary_to_string and type == 'binary':
+    type = 'string'
+    if 'description' in item:
+      item['description'] = (item['description'] +
+          ' (Encoded as a base64 string when passed over JSON)')
+  if type in primitiveTypes:
+    item['type'] = type
+  else:
+    item['$ref'] = type
 
 
 def createItem(d, experimental, deprecated, name=None):
-    result = collections.OrderedDict(d)
-    if name:
-        result['name'] = name
-    global description
-    if description:
-        result['description'] = description.strip()
-    if experimental:
-        result['experimental'] = True
-    if deprecated:
-        result['deprecated'] = True
-    return result
+  result = collections.OrderedDict(d)
+  if name:
+    result['name'] = name
+  global description
+  if description:
+    result['description'] = description.strip()
+  if experimental:
+    result['experimental'] = True
+  if deprecated:
+    result['deprecated'] = True
+  return result
 
 
 def parse(data, file_name, map_binary_to_string=False):
-    protocol = collections.OrderedDict()
-    protocol['version'] = collections.OrderedDict()
-    protocol['domains'] = []
-    domain = None
-    item = None
-    subitems = None
-    nukeDescription = False
-    global description
-    lines = data.split('\n')
-    for i in range(0, len(lines)):
-        if nukeDescription:
-            description = ''
-            nukeDescription = False
-        line = lines[i]
-        trimLine = line.strip()
-
-        if trimLine.startswith('#'):
-            if len(description):
-              description += '\n'
-            description += trimLine[2:]
-            continue
+  protocol = collections.OrderedDict()
+  protocol['version'] = collections.OrderedDict()
+  protocol['domains'] = []
+  domain = None
+  item = None
+  subitems = None
+  nukeDescription = False
+  global description
+  lines = data.split('\n')
+  for i in range(0, len(lines)):
+    if nukeDescription:
+      description = ''
+      nukeDescription = False
+    line = lines[i]
+    trimLine = line.strip()
+
+    if trimLine.startswith('#'):
+      if len(description):
+        description += '\n'
+      description += trimLine[2:]
+      continue
+    else:
+      nukeDescription = True
+
+    if len(trimLine) == 0:
+      continue
+
+    match = re.compile(
+        r'^(experimental )?(deprecated )?domain (.*)').match(line)
+    if match:
+      domain = createItem({'domain' : match.group(3)}, match.group(1),
+                          match.group(2))
+      protocol['domains'].append(domain)
+      continue
+
+    match = re.compile(r'^  depends on ([^\s]+)').match(line)
+    if match:
+      if 'dependencies' not in domain:
+        domain['dependencies'] = []
+      domain['dependencies'].append(match.group(1))
+      continue
+
+    match = re.compile(r'^  (experimental )?(deprecated )?type (.*) '
+                       r'extends (array of )?([^\s]+)').match(line)
+    if match:
+      if 'types' not in domain:
+        domain['types'] = []
+      item = createItem({'id': match.group(3)}, match.group(1), match.group(2))
+      assignType(item, match.group(5), match.group(4), map_binary_to_string)
+      domain['types'].append(item)
+      continue
+
+    match = re.compile(
+        r'^  (experimental )?(deprecated )?(command|event) (.*)').match(line)
+    if match:
+      list = []
+      if match.group(3) == 'command':
+        if 'commands' in domain:
+          list = domain['commands']
+        else:
+          list = domain['commands'] = []
+      else:
+        if 'events' in domain:
+          list = domain['events']
         else:
-            nukeDescription = True
-
-        if len(trimLine) == 0:
-            continue
-
-        match = re.compile(r'^(experimental )?(deprecated )?domain (.*)').match(line)
-        if match:
-            domain = createItem({'domain' : match.group(3)}, match.group(1), match.group(2))
-            protocol['domains'].append(domain)
-            continue
-
-        match = re.compile(r'^  depends on ([^\s]+)').match(line)
-        if match:
-            if 'dependencies' not in domain:
-                domain['dependencies'] = []
-            domain['dependencies'].append(match.group(1))
-            continue
-
-        match = re.compile(r'^  (experimental )?(deprecated )?type (.*) extends (array of )?([^\s]+)').match(line)
-        if match:
-            if 'types' not in domain:
-                domain['types'] = []
-            item = createItem({'id': match.group(3)}, match.group(1), match.group(2))
-            assignType(item, match.group(5), match.group(4), map_binary_to_string)
-            domain['types'].append(item)
-            continue
-
-        match = re.compile(r'^  (experimental )?(deprecated )?(command|event) (.*)').match(line)
-        if match:
-            list = []
-            if match.group(3) == 'command':
-                if 'commands' in domain:
-                    list = domain['commands']
-                else:
-                    list = domain['commands'] = []
-            else:
-                if 'events' in domain:
-                    list = domain['events']
-                else:
-                    list = domain['events'] = []
-
-            item = createItem({}, match.group(1), match.group(2), match.group(4))
-            list.append(item)
-            continue
-
-        match = re.compile(r'^      (experimental )?(deprecated )?(optional )?(array of )?([^\s]+) ([^\s]+)').match(line)
-        if match:
-            param = createItem({}, match.group(1), match.group(2), match.group(6))
-            if match.group(3):
-                param['optional'] = True
-            assignType(param, match.group(5), match.group(4), map_binary_to_string)
-            if match.group(5) == 'enum':
-                enumliterals = param['enum'] = []
-            subitems.append(param)
-            continue
-
-        match = re.compile(r'^    (parameters|returns|properties)').match(line)
-        if match:
-            subitems = item[match.group(1)] = []
-            continue
-
-        match = re.compile(r'^    enum').match(line)
-        if match:
-            enumliterals = item['enum'] = []
-            continue
-
-        match = re.compile(r'^version').match(line)
-        if match:
-            continue
-
-        match = re.compile(r'^  major (\d+)').match(line)
-        if match:
-            protocol['version']['major'] = match.group(1)
-            continue
-
-        match = re.compile(r'^  minor (\d+)').match(line)
-        if match:
-            protocol['version']['minor'] = match.group(1)
-            continue
-
-        match = re.compile(r'^    redirect ([^\s]+)').match(line)
-        if match:
-            item['redirect'] = match.group(1)
-            continue
-
-        match = re.compile(r'^      (  )?[^\s]+$').match(line)
-        if match:
-            # enum literal
-            enumliterals.append(trimLine)
-            continue
-
-        print('Error in %s:%s, illegal token: \t%s' % (file_name, i, line))
-        sys.exit(1)
-    return protocol
+          list = domain['events'] = []
+
+      item = createItem({}, match.group(1), match.group(2), match.group(4))
+      list.append(item)
+      continue
+
+    match = re.compile(
+        r'^      (experimental )?(deprecated )?(optional )?'
+        r'(array of )?([^\s]+) ([^\s]+)').match(line)
+    if match:
+      param = createItem({}, match.group(1), match.group(2), match.group(6))
+      if match.group(3):
+        param['optional'] = True
+      assignType(param, match.group(5), match.group(4), map_binary_to_string)
+      if match.group(5) == 'enum':
+        enumliterals = param['enum'] = []
+      subitems.append(param)
+      continue
+
+    match = re.compile(r'^    (parameters|returns|properties)').match(line)
+    if match:
+      subitems = item[match.group(1)] = []
+      continue
+
+    match = re.compile(r'^    enum').match(line)
+    if match:
+      enumliterals = item['enum'] = []
+      continue
+
+    match = re.compile(r'^version').match(line)
+    if match:
+      continue
+
+    match = re.compile(r'^  major (\d+)').match(line)
+    if match:
+      protocol['version']['major'] = match.group(1)
+      continue
+
+    match = re.compile(r'^  minor (\d+)').match(line)
+    if match:
+      protocol['version']['minor'] = match.group(1)
+      continue
+
+    match = re.compile(r'^    redirect ([^\s]+)').match(line)
+    if match:
+      item['redirect'] = match.group(1)
+      continue
+
+    match = re.compile(r'^      (  )?[^\s]+$').match(line)
+    if match:
+      # enum literal
+      enumliterals.append(trimLine)
+      continue
+
+    print('Error in %s:%s, illegal token: \t%s' % (file_name, i, line))
+    sys.exit(1)
+  return protocol
 
 
 def loads(data, file_name, map_binary_to_string=False):
-    if file_name.endswith(".pdl"):
-        return parse(data, file_name, map_binary_to_string)
-    return json.loads(data)
+  if file_name.endswith(".pdl"):
+    return parse(data, file_name, map_binary_to_string)
+  return json.loads(data)
diff --git a/tools/inspector_protocol/templates/Exported_h.template b/tools/inspector_protocol/templates/Exported_h.template
index 765f6c2135b9c3..f00875ac77a2a1 100644
--- a/tools/inspector_protocol/templates/Exported_h.template
+++ b/tools/inspector_protocol/templates/Exported_h.template
@@ -1,6 +1,6 @@
 // This file is generated by Exported_h.template.
 
-// Copyright (c) 2016 The Chromium Authors. All rights reserved.
+// Copyright 2016 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -20,8 +20,8 @@ namespace {{namespace}} {
 #define {{"_".join(config.protocol.namespace)}}_exported_api_h
 class {{config.exported.export_macro}} Exported {
 public:
-    virtual {{config.exported.string_out}} toJSONString() const = 0;
-    virtual void writeBinary(std::vector<uint8_t>* out) const = 0;
+    virtual void AppendSerialized(std::vector<uint8_t>* out) const = 0;
+
     virtual ~Exported() { }
 };
 #endif // !defined({{"_".join(config.protocol.namespace)}}_exported_api_h)
@@ -61,7 +61,6 @@ namespace {{param.name | to_title_case}}Enum {
 
 class {{config.exported.export_macro}} {{type.id}} : public Exported {
 public:
-    static std::unique_ptr<protocol::{{domain.domain}}::API::{{type.id}}> fromJSONString(const {{config.exported.string_in}}& json);
     static std::unique_ptr<protocol::{{domain.domain}}::API::{{type.id}}> fromBinary(const uint8_t* data, size_t length);
 };
   {% endfor %}
diff --git a/tools/inspector_protocol/templates/Imported_h.template b/tools/inspector_protocol/templates/Imported_h.template
index f2e576a9c470ae..5161d27351be47 100644
--- a/tools/inspector_protocol/templates/Imported_h.template
+++ b/tools/inspector_protocol/templates/Imported_h.template
@@ -1,6 +1,6 @@
 // This file is generated by Imported_h.template.
 
-// Copyright (c) 2016 The Chromium Authors. All rights reserved.
+// Copyright 2016 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -14,6 +14,53 @@
 #include {{format_include(config.imported.package, domain.domain)}}
 {% endif %}
 
+#ifndef {{"_".join(config.protocol.namespace)}}_imported_imported_h
+
+namespace {{config.crdtp.namespace}} {
+
+template <typename T>
+struct ProtocolTypeTraits<
+    std::unique_ptr<T>,
+    typename std::enable_if<
+        std::is_base_of<{{"::".join(config.imported.namespace)}}::Exported, T>::value>::type> {
+  static bool Deserialize(DeserializerState* state, std::unique_ptr<T>* value) {
+    if (state->tokenizer()->TokenTag() != cbor::CBORTokenTag::ENVELOPE) {
+      state->RegisterError(Error::CBOR_INVALID_ENVELOPE);
+      return false;
+    }
+    span<uint8_t> env = state->tokenizer()->GetEnvelope();
+    auto res = T::fromBinary(env.data(), env.size());
+    if (!res) {
+      // TODO(caseq): properly plumb an error rather than returning a bogus code.
+      state->RegisterError(Error::MESSAGE_MUST_BE_AN_OBJECT);
+      return false;
+    }
+    *value = std::move(res);
+    return true;
+  }
+  static void Serialize(const std::unique_ptr<T>& value, std::vector<uint8_t>* bytes) {
+    // Use virtual method, so that outgoing protocol objects could be retained
+    // by a pointer to ProtocolObject.
+    value->AppendSerialized(bytes);
+  }
+};
+
+template <typename T>
+struct ProtocolTypeTraits<
+    T,
+    typename std::enable_if<
+        std::is_base_of<{{"::".join(config.imported.namespace)}}::Exported, T>::value>::type> {
+  static void Serialize(const T& value, std::vector<uint8_t>* bytes) {
+    // Use virtual method, so that outgoing protocol objects could be retained
+    // by a pointer to ProtocolObject.
+    value.AppendSerialized(bytes);
+  }
+};
+
+}  // namespace {{config.crdtp.namespace}}
+
+#endif  // {{"_".join(config.protocol.namespace)}}_imported_imported_h
+
 {% for namespace in config.protocol.namespace %}
 namespace {{namespace}} {
 {% endfor %}
@@ -29,14 +76,10 @@ public:
         return std::unique_ptr<ImportedValue>(new ImportedValue(value));
     }
 
-    void writeJSON(StringBuilder* output) const override {
-        auto json = m_exported->toJSONString();
-        String local_json = ({{config.imported.from_imported_string % "std::move(json)"}});
-        StringUtil::builderAppend(*output, local_json);
-    }
-    void writeBinary(std::vector<uint8_t>* output) const override {
-        m_exported->writeBinary(output);
+    void AppendSerialized(std::vector<uint8_t>* output) const override {
+        m_exported->AppendSerialized(output);
     }
+
     std::unique_ptr<Value> clone() const override {
         return std::unique_ptr<Value>(new ImportedValue(m_exported));
     }
@@ -56,15 +99,15 @@ struct ValueConversions<{{"::".join(config.imported.namespace)}}::{{domain.domai
     static std::unique_ptr<{{"::".join(config.imported.namespace)}}::{{domain.domain}}::API::{{type.id}}> fromValue(protocol::Value* value, ErrorSupport* errors)
     {
         if (!value) {
-            errors->addError("value expected");
+            errors->AddError("value expected");
             return nullptr;
         }
 
         std::vector<uint8_t> binary;
-        value->writeBinary(&binary);
+        value->AppendSerialized(&binary);
         auto result = {{"::".join(config.imported.namespace)}}::{{domain.domain}}::API::{{type.id}}::fromBinary(binary.data(), binary.size());
         if (!result)
-            errors->addError("cannot parse");
+            errors->AddError("cannot parse");
         return result;
     }
 
@@ -72,11 +115,6 @@ struct ValueConversions<{{"::".join(config.imported.namespace)}}::{{domain.domai
     {
         return ImportedValue::fromExported(exported);
     }
-
-    static std::unique_ptr<protocol::Value> toValue(const std::unique_ptr<{{"::".join(config.imported.namespace)}}::{{domain.domain}}::API::{{type.id}}>& value)
-    {
-        return toValue(value.get());
-    }
 };
 
   {% endfor %}
diff --git a/tools/inspector_protocol/templates/TypeBuilder_cpp.template b/tools/inspector_protocol/templates/TypeBuilder_cpp.template
index 982e2c61b8e916..27a8f1f12b7e76 100644
--- a/tools/inspector_protocol/templates/TypeBuilder_cpp.template
+++ b/tools/inspector_protocol/templates/TypeBuilder_cpp.template
@@ -1,6 +1,6 @@
 // This file is generated by TypeBuilder_cpp.template.
 
-// Copyright (c) 2016 The Chromium Authors. All rights reserved.
+// Copyright 2016 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -8,11 +8,18 @@
 
 #include {{format_include(config.protocol.package, "Protocol")}}
 
+#include "{{config.crdtp.dir}}/cbor.h"
+#include "{{config.crdtp.dir}}/find_by_first.h"
+#include "{{config.crdtp.dir}}/span.h"
+
 {% for namespace in config.protocol.namespace %}
 namespace {{namespace}} {
 {% endfor %}
 namespace {{domain.domain}} {
 
+using {{config.crdtp.namespace}}::DeserializerState;
+using {{config.crdtp.namespace}}::ProtocolTypeTraits;
+
 // ------------- Enum values from types.
 
 const char Metainfo::domainName[] = "{{domain.domain}}";
@@ -38,6 +45,7 @@ const char* {{ literal | dash_to_camelcase}} = "{{literal}}";
 } // namespace API
       {% endif %}
     {% endif %}
+
     {% for property in type.properties %}
       {% if "enum" in property %}
 
@@ -47,89 +55,28 @@ const char* {{type.id}}::{{property.name | to_title_case}}Enum::{{literal | dash
       {% endif %}
     {% endfor %}
     {% if not (type.type == "object") or not ("properties" in type) %}{% continue %}{% endif %}
-
-std::unique_ptr<{{type.id}}> {{type.id}}::fromValue(protocol::Value* value, ErrorSupport* errors)
-{
-    if (!value || value->type() != protocol::Value::TypeObject) {
-        errors->addError("object expected");
-        return nullptr;
-    }
-
-    std::unique_ptr<{{type.id}}> result(new {{type.id}}());
-    protocol::DictionaryValue* object = DictionaryValue::cast(value);
-    errors->push();
-    {% for property in type.properties %}
-    protocol::Value* {{property.name}}Value = object->get("{{property.name}}");
+CRDTP_BEGIN_DESERIALIZER({{type.id}})
+      {% for property in type.properties | sort(attribute = 'name', case_sensitive=True) %}
       {% if property.optional %}
-    if ({{property.name}}Value) {
-        errors->setName("{{property.name}}");
-        result->m_{{property.name}} = ValueConversions<{{protocol.resolve_type(property).raw_type}}>::fromValue({{property.name}}Value, errors);
-    }
+    CRDTP_DESERIALIZE_FIELD_OPT("{{property.name}}", m_{{property.name}}),
       {% else %}
-    errors->setName("{{property.name}}");
-    result->m_{{property.name}} = ValueConversions<{{protocol.resolve_type(property).raw_type}}>::fromValue({{property.name}}Value, errors);
+    CRDTP_DESERIALIZE_FIELD("{{property.name}}", m_{{property.name}}),
       {% endif %}
-    {% endfor %}
-    errors->pop();
-    if (errors->hasErrors())
-        return nullptr;
-    return result;
-}
+      {% endfor %}
+CRDTP_END_DESERIALIZER()
 
-std::unique_ptr<protocol::DictionaryValue> {{type.id}}::toValue() const
-{
-    std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
-    {% for property in type.properties %}
-      {% set property_type = protocol.resolve_type(property) %}
-      {% set property_field = "m_" + property.name %}
-      {% if property.optional %}
-    if ({{property_field}}.isJust())
-        result->setValue("{{property.name}}", ValueConversions<{{property_type.raw_type}}>::toValue({{property_field}}.fromJust()));
-      {% else %}
-    result->setValue("{{property.name}}", ValueConversions<{{property_type.raw_type}}>::toValue({{property_type.to_raw_type % property_field}}));
-      {% endif %}
-    {% endfor %}
-    return result;
-}
+CRDTP_BEGIN_SERIALIZER({{type.id}})
+      {% for property in type.properties %}
+    CRDTP_SERIALIZE_FIELD("{{property.name}}", m_{{property.name}});
+      {% endfor %}
+CRDTP_END_SERIALIZER();
 
-std::unique_ptr<{{type.id}}> {{type.id}}::clone() const
-{
-    ErrorSupport errors;
-    return fromValue(toValue().get(), &errors);
-}
     {% if protocol.is_exported(domain.domain, type.id) %}
-
-{{config.exported.string_out}} {{type.id}}::toJSONString() const
-{
-    String json = toValue()->serializeToJSON();
-    return {{config.exported.to_string_out % "json"}};
-}
-
-void {{type.id}}::writeBinary(std::vector<uint8_t>* out) const
-{
-    toValue()->writeBinary(out);
-}
-
-// static
-std::unique_ptr<API::{{type.id}}> API::{{type.id}}::fromJSONString(const {{config.exported.string_in}}& json)
-{
-    ErrorSupport errors;
-    std::unique_ptr<Value> value = StringUtil::parseJSON(json);
-    if (!value)
-        return nullptr;
-    return protocol::{{domain.domain}}::{{type.id}}::fromValue(value.get(), &errors);
-}
-
 // static
 std::unique_ptr<API::{{type.id}}> API::{{type.id}}::fromBinary(const uint8_t* data, size_t length)
 {
-    ErrorSupport errors;
-    std::unique_ptr<Value> value = Value::parseBinary(data, length);
-    if (!value)
-        return nullptr;
-    return protocol::{{domain.domain}}::{{type.id}}::fromValue(value.get(), &errors);
+    return protocol::{{domain.domain}}::{{type.id}}::FromBinary(data, length);
 }
-
     {% endif %}
   {% endfor %}
 
@@ -175,90 +122,82 @@ void Frontend::{{event.name | to_method_case}}(
       {%- endif %} {{parameter.name}}{%- if not loop.last -%}, {% endif -%}
     {% endfor -%})
 {
-    if (!m_frontendChannel)
+    if (!frontend_channel_)
         return;
       {% if event.parameters %}
-    std::unique_ptr<{{event.name | to_title_case}}Notification> messageData = {{event.name | to_title_case}}Notification::{{"create" | to_method_case}}()
-        {% for parameter in event.parameters %}
-          {% if not "optional" in parameter %}
-        .{{"set" | to_method_case}}{{parameter.name | to_title_case}}({{protocol.resolve_type(parameter).to_pass_type % parameter.name}})
-          {% endif %}
-        {% endfor %}
-        .{{ "build" | to_method_case }}();
+    {{config.crdtp.namespace}}::ObjectSerializer serializer;
         {% for parameter in event.parameters %}
-          {% if "optional" in parameter %}
-    if ({{parameter.name}}.isJust())
-        messageData->{{"set" | to_method_case}}{{parameter.name | to_title_case}}(std::move({{parameter.name}}).takeJust());
-          {% endif %}
+    serializer.AddField({{config.crdtp.namespace}}::MakeSpan("{{parameter.name}}"), {{parameter.name}});
         {% endfor %}
-    m_frontendChannel->sendProtocolNotification(InternalResponse::createNotification("{{domain.domain}}.{{event.name}}", std::move(messageData)));
+    frontend_channel_->SendProtocolNotification({{config.crdtp.namespace}}::CreateNotification("{{domain.domain}}.{{event.name}}", serializer.Finish()));
       {% else %}
-    m_frontendChannel->sendProtocolNotification(InternalResponse::createNotification("{{domain.domain}}.{{event.name}}"));
+    frontend_channel_->SendProtocolNotification({{config.crdtp.namespace}}::CreateNotification("{{domain.domain}}.{{event.name}}"));
       {% endif %}
 }
   {% endfor %}
 
 void Frontend::flush()
 {
-    m_frontendChannel->flushProtocolNotifications();
+    frontend_channel_->FlushProtocolNotifications();
 }
 
-void Frontend::sendRawJSONNotification(String notification)
+void Frontend::sendRawNotification(std::unique_ptr<Serializable> notification)
 {
-    m_frontendChannel->sendProtocolNotification(InternalRawNotification::fromJSON(std::move(notification)));
-}
-
-void Frontend::sendRawCBORNotification(std::vector<uint8_t> notification)
-{
-    m_frontendChannel->sendProtocolNotification(InternalRawNotification::fromBinary(std::move(notification)));
+    frontend_channel_->SendProtocolNotification(std::move(notification));
 }
 
 // --------------------- Dispatcher.
 
-class DispatcherImpl : public protocol::DispatcherBase {
+class DomainDispatcherImpl : public protocol::DomainDispatcher {
 public:
-    DispatcherImpl(FrontendChannel* frontendChannel, Backend* backend)
-        : DispatcherBase(frontendChannel)
-        , m_backend(backend) {
-  {% for command in domain.commands %}
-    {% if "redirect" in command %}
-      m_redirects["{{domain.domain}}.{{command.name}}"] = "{{command.redirect}}.{{command.name}}";
-      {% continue %}
-    {% endif %}
-    {% if not protocol.generate_command(domain.domain, command.name) %}{% continue %}{% endif %}
-        m_dispatchMap["{{domain.domain}}.{{command.name}}"] = &DispatcherImpl::{{command.name}};
-  {% endfor %}
-    }
-    ~DispatcherImpl() override { }
-    bool canDispatch(const String& method) override;
-    void dispatch(int callId, const String& method, const ProtocolMessage& message, std::unique_ptr<protocol::DictionaryValue> messageObject) override;
-    std::unordered_map<String, String>& redirects() { return m_redirects; }
+    DomainDispatcherImpl(FrontendChannel* frontendChannel, Backend* backend)
+        : DomainDispatcher(frontendChannel)
+        , m_backend(backend) {}
+    ~DomainDispatcherImpl() override { }
 
-protected:
-    using CallHandler = void (DispatcherImpl::*)(int callId, const String& method, const ProtocolMessage& message, std::unique_ptr<DictionaryValue> messageObject, ErrorSupport* errors);
-    using DispatchMap = std::unordered_map<String, CallHandler>;
-    DispatchMap m_dispatchMap;
-    std::unordered_map<String, String> m_redirects;
+    using CallHandler = void (DomainDispatcherImpl::*)(const {{config.crdtp.namespace}}::Dispatchable& dispatchable);
+
+    std::function<void(const {{config.crdtp.namespace}}::Dispatchable&)> Dispatch({{config.crdtp.namespace}}::span<uint8_t> command_name) override;
 
   {% for command in domain.commands %}
     {% if "redirect" in command %}{% continue %}{% endif %}
     {% if not protocol.generate_command(domain.domain, command.name) %}{% continue %}{% endif %}
-    void {{command.name}}(int callId, const String& method, const ProtocolMessage& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport*);
+    void {{command.name}}(const {{config.crdtp.namespace}}::Dispatchable& dispatchable);
   {% endfor %}
-
+ protected:
     Backend* m_backend;
 };
 
-bool DispatcherImpl::canDispatch(const String& method) {
-    return m_dispatchMap.find(method) != m_dispatchMap.end();
+namespace {
+// This helper method with a static map of command methods (instance methods
+// of DomainDispatcherImpl declared just above) by their name is used immediately below,
+// in the DomainDispatcherImpl::Dispatch method.
+DomainDispatcherImpl::CallHandler CommandByName({{config.crdtp.namespace}}::span<uint8_t> command_name) {
+  static auto* commands = [](){
+    auto* commands = new std::vector<std::pair<{{config.crdtp.namespace}}::span<uint8_t>,
+                              DomainDispatcherImpl::CallHandler>>{
+      {% for command in domain.commands|sort(attribute="name",case_sensitive=True) %}
+        {% if "redirect" in command %}{% continue %}{% endif %}
+        {% if not protocol.generate_command(domain.domain, command.name) %}{% continue %}{% endif %}
+    {
+          {{config.crdtp.namespace}}::SpanFrom("{{command.name}}"),
+          &DomainDispatcherImpl::{{command.name}}
+    },
+      {% endfor %}
+    };
+    return commands;
+  }();
+  return {{config.crdtp.namespace}}::FindByFirst<DomainDispatcherImpl::CallHandler>(*commands, command_name, nullptr);
 }
+}  // namespace
 
-void DispatcherImpl::dispatch(int callId, const String& method, const ProtocolMessage& message, std::unique_ptr<protocol::DictionaryValue> messageObject)
-{
-    std::unordered_map<String, CallHandler>::iterator it = m_dispatchMap.find(method);
-    DCHECK(it != m_dispatchMap.end());
-    protocol::ErrorSupport errors;
-    (this->*(it->second))(callId, method, message, std::move(messageObject), &errors);
+std::function<void(const {{config.crdtp.namespace}}::Dispatchable&)> DomainDispatcherImpl::Dispatch({{config.crdtp.namespace}}::span<uint8_t> command_name) {
+  CallHandler handler = CommandByName(command_name);
+  if (!handler) return nullptr;
+
+  return [this, handler](const {{config.crdtp.namespace}}::Dispatchable& dispatchable) {
+    (this->*handler)(dispatchable);
+  };
 }
 
   {% for command in domain.commands %}
@@ -267,10 +206,11 @@ void DispatcherImpl::dispatch(int callId, const String& method, const ProtocolMe
     {% if not protocol.generate_command(domain.domain, command.name) %}{% continue %}{% endif %}
     {% if protocol.is_async_command(domain.domain, command.name) %}
 
-class {{command_name_title}}CallbackImpl : public Backend::{{command_name_title}}Callback, public DispatcherBase::Callback {
+class {{command_name_title}}CallbackImpl : public Backend::{{command_name_title}}Callback, public DomainDispatcher::Callback {
 public:
-    {{command_name_title}}CallbackImpl(std::unique_ptr<DispatcherBase::WeakPtr> backendImpl, int callId, const String& method, const ProtocolMessage& message)
-        : DispatcherBase::Callback(std::move(backendImpl), callId, method, message) { }
+    {{command_name_title}}CallbackImpl(std::unique_ptr<DomainDispatcher::WeakPtr> backendImpl, int callId, {{config.crdtp.namespace}}::span<uint8_t> message)
+        : DomainDispatcher::Callback(std::move(backendImpl), callId,
+{{config.crdtp.namespace}}::SpanFrom("{{domain.domain}}.{{command.name}}"), message) { }
 
     void sendSuccess(
       {%- for parameter in command.returns -%}
@@ -282,16 +222,11 @@ public:
         {%- if not loop.last -%}, {% endif -%}
       {%- endfor -%}) override
     {
-        std::unique_ptr<protocol::DictionaryValue> resultObject = DictionaryValue::create();
-          {% for parameter in command.returns %}
-            {% if "optional" in parameter %}
-        if ({{parameter.name}}.isJust())
-            resultObject->setValue("{{parameter.name}}", ValueConversions<{{protocol.resolve_type(parameter).raw_type}}>::toValue({{parameter.name}}.fromJust()));
-           {% else %}
-        resultObject->setValue("{{parameter.name}}", ValueConversions<{{protocol.resolve_type(parameter).raw_type}}>::toValue({{protocol.resolve_type(parameter).to_raw_type % parameter.name}}));
-            {% endif %}
-          {% endfor %}
-        sendIfActive(std::move(resultObject), DispatchResponse::OK());
+        {{config.crdtp.namespace}}::ObjectSerializer serializer;
+        {% for parameter in command.returns %}
+        serializer.AddField({{config.crdtp.namespace}}::MakeSpan("{{parameter.name}}"), {{parameter.name}});
+        {% endfor %}
+        sendIfActive(serializer.Finish(), DispatchResponse::Success());
     }
 
     void fallThrough() override
@@ -301,38 +236,52 @@ public:
 
     void sendFailure(const DispatchResponse& response) override
     {
-        DCHECK(response.status() == DispatchResponse::kError);
+        DCHECK(response.IsError());
         sendIfActive(nullptr, response);
     }
 };
     {% endif %}
 
-void DispatcherImpl::{{command.name}}(int callId, const String& method, const ProtocolMessage& message, std::unique_ptr<DictionaryValue> requestMessageObject, ErrorSupport* errors)
-{
+namespace {
+
     {% if "parameters" in command %}
-    // Prepare input parameters.
-    protocol::DictionaryValue* object = DictionaryValue::cast(requestMessageObject->get("params"));
-    errors->push();
+struct {{command.name}}Params : public {{config.crdtp.namespace}}::DeserializableProtocolObject<{{command.name}}Params> {
       {% for parameter in command.parameters %}
         {% set parameter_type = protocol.resolve_type(parameter) %}
-    protocol::Value* {{parameter.name}}Value = object ? object->get("{{parameter.name}}") : nullptr;
         {% if parameter.optional %}
-    Maybe<{{parameter_type.raw_type}}> in_{{parameter.name}};
-    if ({{parameter.name}}Value) {
-        errors->setName("{{parameter.name}}");
-        in_{{parameter.name}} = ValueConversions<{{parameter_type.raw_type}}>::fromValue({{parameter.name}}Value, errors);
-    }
+    Maybe<{{parameter_type.raw_type}}> {{parameter.name}};
         {% else %}
-    errors->setName("{{parameter.name}}");
-    {{parameter_type.type}} in_{{parameter.name}} = ValueConversions<{{parameter_type.raw_type}}>::fromValue({{parameter.name}}Value, errors);
+    {{parameter_type.type}} {{parameter.name}};
         {% endif %}
       {% endfor %}
-    errors->pop();
-    if (errors->hasErrors()) {
-        reportProtocolError(callId, DispatchResponse::kInvalidParams, kInvalidParamsString, errors);
-        return;
+    DECLARE_DESERIALIZATION_SUPPORT();
+};
+
+CRDTP_BEGIN_DESERIALIZER({{command.name}}Params)
+      {% for parameter in command.parameters  | sort(attribute = 'name', case_sensitive=True) %}
+      {% if parameter.optional %}
+    CRDTP_DESERIALIZE_FIELD_OPT("{{parameter.name}}", {{parameter.name}}),
+      {% else %}
+    CRDTP_DESERIALIZE_FIELD("{{parameter.name}}", {{parameter.name}}),
+      {% endif %}
+      {% endfor %}
+CRDTP_END_DESERIALIZER()
+     {% endif %}
+
+}  // namespace
+
+void DomainDispatcherImpl::{{command.name}}(const {{config.crdtp.namespace}}::Dispatchable& dispatchable)
+{
+    // Prepare input parameters.
+    {% if "parameters" in command %}
+    auto deserializer = {{config.crdtp.namespace}}::DeferredMessage::FromSpan(dispatchable.Params())->MakeDeserializer();
+    {{command.name}}Params params;
+    if (!{{command.name}}Params::Deserialize(&deserializer, &params)) {
+      ReportInvalidParams(dispatchable, deserializer);
+      return;
     }
-    {% endif %}
+    {% endif -%}
+
     {% if "returns" in command and not protocol.is_async_command(domain.domain, command.name) %}
     // Declare output parameters.
       {% for parameter in command.returns %}
@@ -345,14 +294,14 @@ void DispatcherImpl::{{command.name}}(int callId, const String& method, const Pr
     {% endif %}
 
     {% if not protocol.is_async_command(domain.domain, command.name) %}
-    std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
+    std::unique_ptr<DomainDispatcher::WeakPtr> weak = weakPtr();
     DispatchResponse response = m_backend->{{command.name | to_method_case}}(
       {%- for parameter in command.parameters -%}
         {%- if not loop.first -%}, {% endif -%}
         {%- if "optional" in parameter -%}
-        std::move(in_{{parameter.name}})
+        std::move(params.{{parameter.name}})
         {%- else -%}
-        {{protocol.resolve_type(parameter).to_pass_type % ("in_" + parameter.name)}}
+        {{protocol.resolve_type(parameter).to_pass_type % ("params." + parameter.name)}}
         {%- endif -%}
       {%- endfor %}
       {%- if "returns" in command %}
@@ -361,54 +310,68 @@ void DispatcherImpl::{{command.name}}(int callId, const String& method, const Pr
           &out_{{parameter.name}}
         {%- endfor %}
       {% endif %});
-    if (response.status() == DispatchResponse::kFallThrough) {
-        channel()->fallThrough(callId, method, message);
+    if (response.IsFallThrough()) {
+        channel()->FallThrough(dispatchable.CallId(), {{config.crdtp.namespace}}::SpanFrom("{{domain.domain}}.{{command.name}}"), dispatchable.Serialized());
         return;
     }
       {% if "returns" in command %}
-    std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
-    if (response.status() == DispatchResponse::kSuccess) {
-        {% for parameter in command.returns %}
-          {% if "optional" in parameter %}
-        if (out_{{parameter.name}}.isJust())
-            result->setValue("{{parameter.name}}", ValueConversions<{{protocol.resolve_type(parameter).raw_type}}>::toValue(out_{{parameter.name}}.fromJust()));
-          {% else %}
-        result->setValue("{{parameter.name}}", ValueConversions<{{protocol.resolve_type(parameter).raw_type}}>::toValue({{protocol.resolve_type(parameter).to_raw_type % ("out_" + parameter.name)}}));
-          {% endif %}
-        {% endfor %}
-    }
-    if (weak->get())
-        weak->get()->sendResponse(callId, response, std::move(result));
+      if (weak->get()) {
+        std::unique_ptr<{{config.crdtp.namespace}}::Serializable> result;
+        if (response.IsSuccess()) {
+          {{config.crdtp.namespace}}::ObjectSerializer serializer;
+          {% for parameter in command.returns %}
+          serializer.AddField({{config.crdtp.namespace}}::MakeSpan("{{parameter.name}}"), out_{{parameter.name}});
+          {% endfor %}
+          result = serializer.Finish();
+        } else {
+          result = Serializable::From({});
+        }
+        weak->get()->sendResponse(dispatchable.CallId(), response, std::move(result));
+      }
       {% else %}
     if (weak->get())
-        weak->get()->sendResponse(callId, response);
+        weak->get()->sendResponse(dispatchable.CallId(), response);
       {% endif %}
     return;
     {% else %}
-    std::unique_ptr<DispatcherBase::WeakPtr> weak = weakPtr();
-    std::unique_ptr<{{command_name_title}}CallbackImpl> callback(new {{command.name | to_title_case}}CallbackImpl(weakPtr(), callId, method, message));
     m_backend->{{command.name | to_method_case}}(
       {%- for property in command.parameters -%}
         {%- if not loop.first -%}, {% endif -%}
         {%- if "optional" in property -%}
-        std::move(in_{{property.name}})
+        std::move(params.{{property.name}})
         {%- else -%}
-        {{protocol.resolve_type(property).to_pass_type % ("in_" + property.name)}}
+        {{protocol.resolve_type(property).to_pass_type % ("params." + property.name)}}
         {%- endif -%}
       {%- endfor -%}
         {%- if command.parameters -%}, {% endif -%}
-        std::move(callback));
-    return;
+        std::make_unique<{{command_name_title}}CallbackImpl>(weakPtr(), dispatchable.CallId(), dispatchable.Serialized()));
     {% endif %}
 }
   {% endfor %}
 
+namespace {
+// This helper method (with a static map of redirects) is used from Dispatcher::wire
+// immediately below.
+const std::vector<std::pair<{{config.crdtp.namespace}}::span<uint8_t>, {{config.crdtp.namespace}}::span<uint8_t>>>& SortedRedirects() {
+  static auto* redirects = [](){
+    auto* redirects = new std::vector<std::pair<{{config.crdtp.namespace}}::span<uint8_t>, {{config.crdtp.namespace}}::span<uint8_t>>>{
+      {% for command in domain.commands|sort(attribute="name",case_sensitive=True) %}
+        {% if "redirect" in command %}
+          { {{config.crdtp.namespace}}::SpanFrom("{{domain.domain}}.{{command.name}}"), {{config.crdtp.namespace}}::SpanFrom("{{command.redirect}}.{{command.name}}") },
+        {% endif %}
+      {% endfor %}
+    };
+    return redirects;
+  }();
+  return *redirects;
+}
+}  // namespace
+
 // static
 void Dispatcher::wire(UberDispatcher* uber, Backend* backend)
 {
-    std::unique_ptr<DispatcherImpl> dispatcher(new DispatcherImpl(uber->channel(), backend));
-    uber->setupRedirects(dispatcher->redirects());
-    uber->registerBackend("{{domain.domain}}", std::move(dispatcher));
+    auto dispatcher = std::make_unique<DomainDispatcherImpl>(uber->channel(), backend);
+    uber->WireBackend({{config.crdtp.namespace}}::SpanFrom("{{domain.domain}}"), SortedRedirects(), std::move(dispatcher));
 }
 
 } // {{domain.domain}}
diff --git a/tools/inspector_protocol/templates/TypeBuilder_h.template b/tools/inspector_protocol/templates/TypeBuilder_h.template
index 9d86d7a4ac0a5c..e23567a5732d76 100644
--- a/tools/inspector_protocol/templates/TypeBuilder_h.template
+++ b/tools/inspector_protocol/templates/TypeBuilder_h.template
@@ -1,6 +1,6 @@
 // This file is generated by TypeBuilder_h.template.
 
-// Copyright (c) 2016 The Chromium Authors. All rights reserved.
+// Copyright 2016 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -26,8 +26,6 @@
 namespace {{namespace}} {
 {% endfor %}
 namespace {{domain.domain}} {
-
-// ------------- Forward and enum declarations.
   {% for type in domain.types %}
     {% if not protocol.generate_type(domain.domain, type.id) %}{% continue %}{% endif %}
     {% if type.type == "object" %}
@@ -40,6 +38,8 @@ using {{type.id}} = Object;
 using {{type.id}} = {{protocol.resolve_type(type).type}};
     {% endif %}
   {% endfor %}
+
+// ------------- Forward and enum declarations.
   {% for type in domain.types %}
     {% if not protocol.generate_type(domain.domain, type.id) %}{% continue %}{% endif %}
     {% if "enum" in type %}
@@ -71,11 +71,9 @@ namespace {{param.name | to_title_case}}Enum {
     {% if not protocol.generate_type(domain.domain, type.id) %}{% continue %}{% endif %}
     {% if not (type.type == "object") or not ("properties" in type) %}{% continue %}{% endif %}
 
-class {{config.protocol.export_macro}} {{type.id}} : public Serializable{% if protocol.is_exported(domain.domain, type.id) %}, public API::{{type.id}}{% endif %}{
-    PROTOCOL_DISALLOW_COPY({{type.id}});
+class {{config.protocol.export_macro}} {{type.id}} : public ::{{config.crdtp.namespace}}::ProtocolObject<{{type.id}}>{% if protocol.is_exported(domain.domain, type.id) %},
+    public API::{{type.id}}{% endif %} {
 public:
-    static std::unique_ptr<{{type.id}}> fromValue(protocol::Value* value, ErrorSupport* errors);
-
     ~{{type.id}}() override { }
     {% for property in type.properties %}
       {% set property_type = protocol.resolve_type(property) %}
@@ -91,24 +89,22 @@ public:
       {% endif %}
 
       {% if property.optional %}
-    bool {{"has" | to_method_case}}{{property_name}}() { return {{property_field}}.isJust(); }
-    {{property_type.raw_return_type}} {{"get" | to_method_case}}{{property_name}}({{property_type.raw_pass_type}} defaultValue) { return {{property_field}}.isJust() ? {{property_field}}.fromJust() : defaultValue; }
+    bool {{"has" | to_method_case}}{{property_name}}() { return {{property_field}}.has_value(); }
+    {% if property_type.is_primitive %}
+    {{property_type.raw_return_type}} {{"get" | to_method_case}}{{property_name}}({{property_type.raw_pass_type}} defaultValue) const {
+       return {{property_field}}.value_or(defaultValue);
+    }
+    {% else %}
+    {{property_type.raw_return_type}} {{"get" | to_method_case}}{{property_name}}({{property_type.raw_pass_type}} defaultValue) {
+       return {{property_field}}.has_value() ? &{{property_field}}.value() : defaultValue;
+    }
+    {% endif %}
       {% else %}
     {{property_type.raw_return_type}} {{"get" | to_method_case}}{{property_name}}() { return {{property_type.to_raw_type % property_field}}; }
       {% endif %}
     void {{"set" | to_method_case}}{{property_name}}({{property_type.pass_type}} value) { {{property_field}} = {{property_type.to_rvalue % "value"}}; }
     {% endfor %}
 
-    std::unique_ptr<protocol::DictionaryValue> toValue() const;
-    String serializeToJSON() override { return toValue()->serializeToJSON(); }
-    std::vector<uint8_t> serializeToBinary() override { return toValue()->serializeToBinary(); }
-    String toJSON() const { return toValue()->toJSONString(); }
-    std::unique_ptr<{{type.id}}> clone() const;
-    {% if protocol.is_exported(domain.domain, type.id) %}
-    {{config.exported.string_out}} toJSONString() const override;
-    void writeBinary(std::vector<uint8_t>* out) const override;
-    {% endif %}
-
     template<int STATE>
     class {{type.id}}Builder {
     public:
@@ -166,6 +162,8 @@ public:
     }
 
 private:
+    DECLARE_SERIALIZATION_SUPPORT();
+
     {{type.id}}()
     {
     {% for property in type.properties %}
@@ -245,7 +243,7 @@ public:
   {% if protocol.generate_disable(domain) %}
     virtual DispatchResponse {{"disable" | to_method_case}}()
     {
-        return DispatchResponse::OK();
+        return DispatchResponse::Success();
     }
   {% endif %}
 };
@@ -254,7 +252,7 @@ public:
 
 class {{config.protocol.export_macro}} Frontend {
 public:
-    explicit Frontend(FrontendChannel* frontendChannel) : m_frontendChannel(frontendChannel) { }
+  explicit Frontend(FrontendChannel* frontend_channel) : frontend_channel_(frontend_channel) {}
   {% for event in domain.events %}
     {% if not protocol.generate_event(domain.domain, event.name) %}{% continue %}{% endif %}
     void {{event.name | to_method_case}}(
@@ -268,11 +266,10 @@ public:
     );
   {% endfor %}
 
-    void flush();
-    void sendRawJSONNotification(String);
-    void sendRawCBORNotification(std::vector<uint8_t>);
-private:
-    FrontendChannel* m_frontendChannel;
+  void flush();
+  void sendRawNotification(std::unique_ptr<Serializable>);
+ private:
+  FrontendChannel* frontend_channel_;
 };
 
 // ------------- Dispatcher.

From 0aa5874098fb05c04963b160d617d21af4cf3b42 Mon Sep 17 00:00:00 2001
From: Chengzhong Wu <legendecas@gmail.com>
Date: Fri, 17 Jan 2025 23:45:29 +0000
Subject: [PATCH 33/38] deps: move inspector_protocol to deps

The `crdtp` library in the inspector_protocol is compiled as a library
and linked to the node executable.

PR-URL: https://github.com/nodejs/node/pull/56649
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
---
 LICENSE                                       |    2 +-
 {tools => deps}/inspector_protocol/BUILD.gn   |    0
 {tools => deps}/inspector_protocol/LICENSE    |    0
 deps/inspector_protocol/README.md             |   18 +
 .../inspector_protocol/README.node            |    0
 .../check_protocol_compatibility.py           |    0
 .../inspector_protocol/code_generator.py      |    0
 .../concatenate_protocols.py                  |    0
 .../convert_protocol_to_json.py               |    0
 .../inspector_protocol/crdtp/README.md        |    0
 .../inspector_protocol/crdtp/cbor.cc          |    0
 .../inspector_protocol/crdtp/cbor.h           |    0
 .../inspector_protocol/crdtp/cbor_test.cc     |    0
 .../inspector_protocol/crdtp/dispatch.cc      |    0
 .../inspector_protocol/crdtp/dispatch.h       |    0
 .../inspector_protocol/crdtp/dispatch_test.cc |    0
 .../inspector_protocol/crdtp/error_support.cc |    0
 .../inspector_protocol/crdtp/error_support.h  |    0
 .../crdtp/error_support_test.cc               |    0
 .../inspector_protocol/crdtp/export.h         |    0
 .../inspector_protocol/crdtp/find_by_first.h  |    0
 .../crdtp/find_by_first_test.cc               |    0
 .../crdtp/frontend_channel.h                  |    0
 .../inspector_protocol/crdtp/json.cc          |    0
 .../inspector_protocol/crdtp/json.h           |    0
 .../inspector_protocol/crdtp/json_platform.cc |    0
 .../inspector_protocol/crdtp/json_platform.h  |    0
 .../inspector_protocol/crdtp/json_test.cc     |    0
 .../inspector_protocol/crdtp/maybe.h          |    0
 .../inspector_protocol/crdtp/maybe_test.cc    |    0
 .../inspector_protocol/crdtp/parser_handler.h |    0
 .../inspector_protocol/crdtp/protocol_core.cc |    0
 .../inspector_protocol/crdtp/protocol_core.h  |    0
 .../crdtp/protocol_core_test.cc               |    0
 .../inspector_protocol/crdtp/serializable.cc  |    0
 .../inspector_protocol/crdtp/serializable.h   |    0
 .../crdtp/serializable_test.cc                |    0
 .../inspector_protocol/crdtp/span.cc          |    0
 .../inspector_protocol/crdtp/span.h           |    0
 .../inspector_protocol/crdtp/span_test.cc     |    0
 .../inspector_protocol/crdtp/status.cc        |    0
 .../inspector_protocol/crdtp/status.h         |    0
 .../inspector_protocol/crdtp/status_test.cc   |    0
 .../crdtp/status_test_support.cc              |    0
 .../crdtp/status_test_support.h               |    0
 .../inspector_protocol/crdtp/test_platform.cc |    0
 .../inspector_protocol/crdtp/test_platform.h  |    0
 .../crdtp/test_string_traits.cc               |    0
 .../crdtp/test_string_traits.h                |    0
 .../inspector_protocol/crdtp/transcode.cc     |    0
 .../inspector_protocol/inspector_protocol.gni |    0
 .../inspector_protocol/inspector_protocol.gyp |   43 +
 .../inspector_protocol/lib/Forward_h.template |    0
 .../lib/Object_cpp.template                   |    0
 .../inspector_protocol/lib/Object_h.template  |    0
 .../lib/Protocol_cpp.template                 |    0
 .../lib/ValueConversions_cpp.template         |    0
 .../lib/ValueConversions_h.template           |    0
 .../lib/Values_cpp.template                   |    0
 .../inspector_protocol/lib/Values_h.template  |    0
 {tools => deps}/inspector_protocol/pdl.py     |    0
 .../templates/Exported_h.template             |    0
 .../templates/Imported_h.template             |    0
 .../templates/TypeBuilder_cpp.template        |    0
 .../templates/TypeBuilder_h.template          |    0
 src/inspector/node_inspector.gypi             |   41 +-
 tools/inspector_protocol/.clang-format        |   36 -
 tools/inspector_protocol/OWNERS               |    8 -
 tools/inspector_protocol/README.md            |   18 +-
 tools/inspector_protocol/codereview.settings  |    6 -
 tools/inspector_protocol/encoding/encoding.cc | 2190 -----------------
 tools/inspector_protocol/encoding/encoding.h  |  540 ----
 .../encoding/encoding_test.cc                 | 1932 ---------------
 .../encoding/encoding_test_helper.h           |   33 -
 tools/inspector_protocol/roll.py              |   16 +-
 75 files changed, 84 insertions(+), 4799 deletions(-)
 rename {tools => deps}/inspector_protocol/BUILD.gn (100%)
 rename {tools => deps}/inspector_protocol/LICENSE (100%)
 create mode 100644 deps/inspector_protocol/README.md
 rename {tools => deps}/inspector_protocol/README.node (100%)
 rename {tools => deps}/inspector_protocol/check_protocol_compatibility.py (100%)
 rename {tools => deps}/inspector_protocol/code_generator.py (100%)
 rename {tools => deps}/inspector_protocol/concatenate_protocols.py (100%)
 rename {tools => deps}/inspector_protocol/convert_protocol_to_json.py (100%)
 rename {tools => deps}/inspector_protocol/crdtp/README.md (100%)
 rename {tools => deps}/inspector_protocol/crdtp/cbor.cc (100%)
 rename {tools => deps}/inspector_protocol/crdtp/cbor.h (100%)
 rename {tools => deps}/inspector_protocol/crdtp/cbor_test.cc (100%)
 rename {tools => deps}/inspector_protocol/crdtp/dispatch.cc (100%)
 rename {tools => deps}/inspector_protocol/crdtp/dispatch.h (100%)
 rename {tools => deps}/inspector_protocol/crdtp/dispatch_test.cc (100%)
 rename {tools => deps}/inspector_protocol/crdtp/error_support.cc (100%)
 rename {tools => deps}/inspector_protocol/crdtp/error_support.h (100%)
 rename {tools => deps}/inspector_protocol/crdtp/error_support_test.cc (100%)
 rename {tools => deps}/inspector_protocol/crdtp/export.h (100%)
 rename {tools => deps}/inspector_protocol/crdtp/find_by_first.h (100%)
 rename {tools => deps}/inspector_protocol/crdtp/find_by_first_test.cc (100%)
 rename {tools => deps}/inspector_protocol/crdtp/frontend_channel.h (100%)
 rename {tools => deps}/inspector_protocol/crdtp/json.cc (100%)
 rename {tools => deps}/inspector_protocol/crdtp/json.h (100%)
 rename {tools => deps}/inspector_protocol/crdtp/json_platform.cc (100%)
 rename {tools => deps}/inspector_protocol/crdtp/json_platform.h (100%)
 rename {tools => deps}/inspector_protocol/crdtp/json_test.cc (100%)
 rename {tools => deps}/inspector_protocol/crdtp/maybe.h (100%)
 rename {tools => deps}/inspector_protocol/crdtp/maybe_test.cc (100%)
 rename {tools => deps}/inspector_protocol/crdtp/parser_handler.h (100%)
 rename {tools => deps}/inspector_protocol/crdtp/protocol_core.cc (100%)
 rename {tools => deps}/inspector_protocol/crdtp/protocol_core.h (100%)
 rename {tools => deps}/inspector_protocol/crdtp/protocol_core_test.cc (100%)
 rename {tools => deps}/inspector_protocol/crdtp/serializable.cc (100%)
 rename {tools => deps}/inspector_protocol/crdtp/serializable.h (100%)
 rename {tools => deps}/inspector_protocol/crdtp/serializable_test.cc (100%)
 rename {tools => deps}/inspector_protocol/crdtp/span.cc (100%)
 rename {tools => deps}/inspector_protocol/crdtp/span.h (100%)
 rename {tools => deps}/inspector_protocol/crdtp/span_test.cc (100%)
 rename {tools => deps}/inspector_protocol/crdtp/status.cc (100%)
 rename {tools => deps}/inspector_protocol/crdtp/status.h (100%)
 rename {tools => deps}/inspector_protocol/crdtp/status_test.cc (100%)
 rename {tools => deps}/inspector_protocol/crdtp/status_test_support.cc (100%)
 rename {tools => deps}/inspector_protocol/crdtp/status_test_support.h (100%)
 rename {tools => deps}/inspector_protocol/crdtp/test_platform.cc (100%)
 rename {tools => deps}/inspector_protocol/crdtp/test_platform.h (100%)
 rename {tools => deps}/inspector_protocol/crdtp/test_string_traits.cc (100%)
 rename {tools => deps}/inspector_protocol/crdtp/test_string_traits.h (100%)
 rename {tools => deps}/inspector_protocol/crdtp/transcode.cc (100%)
 rename {tools => deps}/inspector_protocol/inspector_protocol.gni (100%)
 create mode 100644 deps/inspector_protocol/inspector_protocol.gyp
 rename {tools => deps}/inspector_protocol/lib/Forward_h.template (100%)
 rename {tools => deps}/inspector_protocol/lib/Object_cpp.template (100%)
 rename {tools => deps}/inspector_protocol/lib/Object_h.template (100%)
 rename {tools => deps}/inspector_protocol/lib/Protocol_cpp.template (100%)
 rename {tools => deps}/inspector_protocol/lib/ValueConversions_cpp.template (100%)
 rename {tools => deps}/inspector_protocol/lib/ValueConversions_h.template (100%)
 rename {tools => deps}/inspector_protocol/lib/Values_cpp.template (100%)
 rename {tools => deps}/inspector_protocol/lib/Values_h.template (100%)
 rename {tools => deps}/inspector_protocol/pdl.py (100%)
 rename {tools => deps}/inspector_protocol/templates/Exported_h.template (100%)
 rename {tools => deps}/inspector_protocol/templates/Imported_h.template (100%)
 rename {tools => deps}/inspector_protocol/templates/TypeBuilder_cpp.template (100%)
 rename {tools => deps}/inspector_protocol/templates/TypeBuilder_h.template (100%)
 delete mode 100644 tools/inspector_protocol/.clang-format
 delete mode 100644 tools/inspector_protocol/OWNERS
 delete mode 100644 tools/inspector_protocol/codereview.settings
 delete mode 100644 tools/inspector_protocol/encoding/encoding.cc
 delete mode 100644 tools/inspector_protocol/encoding/encoding.h
 delete mode 100644 tools/inspector_protocol/encoding/encoding_test.cc
 delete mode 100644 tools/inspector_protocol/encoding/encoding_test_helper.h

diff --git a/LICENSE b/LICENSE
index cedb4caec177f4..41585ea6c97d5a 100644
--- a/LICENSE
+++ b/LICENSE
@@ -2098,7 +2098,7 @@ The externally maintained libraries used by Node.js are:
     OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   """
 
-- inspector_protocol, located at tools/inspector_protocol, is licensed as follows:
+- inspector_protocol, located at deps/inspector_protocol, is licensed as follows:
   """
     // Copyright 2016 The Chromium Authors. All rights reserved.
     //
diff --git a/tools/inspector_protocol/BUILD.gn b/deps/inspector_protocol/BUILD.gn
similarity index 100%
rename from tools/inspector_protocol/BUILD.gn
rename to deps/inspector_protocol/BUILD.gn
diff --git a/tools/inspector_protocol/LICENSE b/deps/inspector_protocol/LICENSE
similarity index 100%
rename from tools/inspector_protocol/LICENSE
rename to deps/inspector_protocol/LICENSE
diff --git a/deps/inspector_protocol/README.md b/deps/inspector_protocol/README.md
new file mode 100644
index 00000000000000..d15f719fdda32c
--- /dev/null
+++ b/deps/inspector_protocol/README.md
@@ -0,0 +1,18 @@
+# Chromium inspector (devtools) protocol
+
+This package contains code generators and templates for the Chromium
+inspector protocol.
+
+The canonical location of this package is at
+https://chromium.googlesource.com/deps/inspector_protocol/
+
+In the Chromium tree, it's rolled into
+https://cs.chromium.org/chromium/src/third_party/inspector_protocol/
+
+In the V8 tree, it's rolled into
+https://cs.chromium.org/chromium/src/v8/third_party/inspector_protocol/
+
+See also [Contributing to Chrome Devtools Protocol](https://docs.google.com/document/d/1c-COD2kaK__5iMM5SEx-PzNA7HFmgttcYfOHHX0HaOM/edit).
+
+To build and run the tests of the crdtp library, see
+[CRDTP - Chrome DevTools Protocol](crdtp/README.md).
diff --git a/tools/inspector_protocol/README.node b/deps/inspector_protocol/README.node
similarity index 100%
rename from tools/inspector_protocol/README.node
rename to deps/inspector_protocol/README.node
diff --git a/tools/inspector_protocol/check_protocol_compatibility.py b/deps/inspector_protocol/check_protocol_compatibility.py
similarity index 100%
rename from tools/inspector_protocol/check_protocol_compatibility.py
rename to deps/inspector_protocol/check_protocol_compatibility.py
diff --git a/tools/inspector_protocol/code_generator.py b/deps/inspector_protocol/code_generator.py
similarity index 100%
rename from tools/inspector_protocol/code_generator.py
rename to deps/inspector_protocol/code_generator.py
diff --git a/tools/inspector_protocol/concatenate_protocols.py b/deps/inspector_protocol/concatenate_protocols.py
similarity index 100%
rename from tools/inspector_protocol/concatenate_protocols.py
rename to deps/inspector_protocol/concatenate_protocols.py
diff --git a/tools/inspector_protocol/convert_protocol_to_json.py b/deps/inspector_protocol/convert_protocol_to_json.py
similarity index 100%
rename from tools/inspector_protocol/convert_protocol_to_json.py
rename to deps/inspector_protocol/convert_protocol_to_json.py
diff --git a/tools/inspector_protocol/crdtp/README.md b/deps/inspector_protocol/crdtp/README.md
similarity index 100%
rename from tools/inspector_protocol/crdtp/README.md
rename to deps/inspector_protocol/crdtp/README.md
diff --git a/tools/inspector_protocol/crdtp/cbor.cc b/deps/inspector_protocol/crdtp/cbor.cc
similarity index 100%
rename from tools/inspector_protocol/crdtp/cbor.cc
rename to deps/inspector_protocol/crdtp/cbor.cc
diff --git a/tools/inspector_protocol/crdtp/cbor.h b/deps/inspector_protocol/crdtp/cbor.h
similarity index 100%
rename from tools/inspector_protocol/crdtp/cbor.h
rename to deps/inspector_protocol/crdtp/cbor.h
diff --git a/tools/inspector_protocol/crdtp/cbor_test.cc b/deps/inspector_protocol/crdtp/cbor_test.cc
similarity index 100%
rename from tools/inspector_protocol/crdtp/cbor_test.cc
rename to deps/inspector_protocol/crdtp/cbor_test.cc
diff --git a/tools/inspector_protocol/crdtp/dispatch.cc b/deps/inspector_protocol/crdtp/dispatch.cc
similarity index 100%
rename from tools/inspector_protocol/crdtp/dispatch.cc
rename to deps/inspector_protocol/crdtp/dispatch.cc
diff --git a/tools/inspector_protocol/crdtp/dispatch.h b/deps/inspector_protocol/crdtp/dispatch.h
similarity index 100%
rename from tools/inspector_protocol/crdtp/dispatch.h
rename to deps/inspector_protocol/crdtp/dispatch.h
diff --git a/tools/inspector_protocol/crdtp/dispatch_test.cc b/deps/inspector_protocol/crdtp/dispatch_test.cc
similarity index 100%
rename from tools/inspector_protocol/crdtp/dispatch_test.cc
rename to deps/inspector_protocol/crdtp/dispatch_test.cc
diff --git a/tools/inspector_protocol/crdtp/error_support.cc b/deps/inspector_protocol/crdtp/error_support.cc
similarity index 100%
rename from tools/inspector_protocol/crdtp/error_support.cc
rename to deps/inspector_protocol/crdtp/error_support.cc
diff --git a/tools/inspector_protocol/crdtp/error_support.h b/deps/inspector_protocol/crdtp/error_support.h
similarity index 100%
rename from tools/inspector_protocol/crdtp/error_support.h
rename to deps/inspector_protocol/crdtp/error_support.h
diff --git a/tools/inspector_protocol/crdtp/error_support_test.cc b/deps/inspector_protocol/crdtp/error_support_test.cc
similarity index 100%
rename from tools/inspector_protocol/crdtp/error_support_test.cc
rename to deps/inspector_protocol/crdtp/error_support_test.cc
diff --git a/tools/inspector_protocol/crdtp/export.h b/deps/inspector_protocol/crdtp/export.h
similarity index 100%
rename from tools/inspector_protocol/crdtp/export.h
rename to deps/inspector_protocol/crdtp/export.h
diff --git a/tools/inspector_protocol/crdtp/find_by_first.h b/deps/inspector_protocol/crdtp/find_by_first.h
similarity index 100%
rename from tools/inspector_protocol/crdtp/find_by_first.h
rename to deps/inspector_protocol/crdtp/find_by_first.h
diff --git a/tools/inspector_protocol/crdtp/find_by_first_test.cc b/deps/inspector_protocol/crdtp/find_by_first_test.cc
similarity index 100%
rename from tools/inspector_protocol/crdtp/find_by_first_test.cc
rename to deps/inspector_protocol/crdtp/find_by_first_test.cc
diff --git a/tools/inspector_protocol/crdtp/frontend_channel.h b/deps/inspector_protocol/crdtp/frontend_channel.h
similarity index 100%
rename from tools/inspector_protocol/crdtp/frontend_channel.h
rename to deps/inspector_protocol/crdtp/frontend_channel.h
diff --git a/tools/inspector_protocol/crdtp/json.cc b/deps/inspector_protocol/crdtp/json.cc
similarity index 100%
rename from tools/inspector_protocol/crdtp/json.cc
rename to deps/inspector_protocol/crdtp/json.cc
diff --git a/tools/inspector_protocol/crdtp/json.h b/deps/inspector_protocol/crdtp/json.h
similarity index 100%
rename from tools/inspector_protocol/crdtp/json.h
rename to deps/inspector_protocol/crdtp/json.h
diff --git a/tools/inspector_protocol/crdtp/json_platform.cc b/deps/inspector_protocol/crdtp/json_platform.cc
similarity index 100%
rename from tools/inspector_protocol/crdtp/json_platform.cc
rename to deps/inspector_protocol/crdtp/json_platform.cc
diff --git a/tools/inspector_protocol/crdtp/json_platform.h b/deps/inspector_protocol/crdtp/json_platform.h
similarity index 100%
rename from tools/inspector_protocol/crdtp/json_platform.h
rename to deps/inspector_protocol/crdtp/json_platform.h
diff --git a/tools/inspector_protocol/crdtp/json_test.cc b/deps/inspector_protocol/crdtp/json_test.cc
similarity index 100%
rename from tools/inspector_protocol/crdtp/json_test.cc
rename to deps/inspector_protocol/crdtp/json_test.cc
diff --git a/tools/inspector_protocol/crdtp/maybe.h b/deps/inspector_protocol/crdtp/maybe.h
similarity index 100%
rename from tools/inspector_protocol/crdtp/maybe.h
rename to deps/inspector_protocol/crdtp/maybe.h
diff --git a/tools/inspector_protocol/crdtp/maybe_test.cc b/deps/inspector_protocol/crdtp/maybe_test.cc
similarity index 100%
rename from tools/inspector_protocol/crdtp/maybe_test.cc
rename to deps/inspector_protocol/crdtp/maybe_test.cc
diff --git a/tools/inspector_protocol/crdtp/parser_handler.h b/deps/inspector_protocol/crdtp/parser_handler.h
similarity index 100%
rename from tools/inspector_protocol/crdtp/parser_handler.h
rename to deps/inspector_protocol/crdtp/parser_handler.h
diff --git a/tools/inspector_protocol/crdtp/protocol_core.cc b/deps/inspector_protocol/crdtp/protocol_core.cc
similarity index 100%
rename from tools/inspector_protocol/crdtp/protocol_core.cc
rename to deps/inspector_protocol/crdtp/protocol_core.cc
diff --git a/tools/inspector_protocol/crdtp/protocol_core.h b/deps/inspector_protocol/crdtp/protocol_core.h
similarity index 100%
rename from tools/inspector_protocol/crdtp/protocol_core.h
rename to deps/inspector_protocol/crdtp/protocol_core.h
diff --git a/tools/inspector_protocol/crdtp/protocol_core_test.cc b/deps/inspector_protocol/crdtp/protocol_core_test.cc
similarity index 100%
rename from tools/inspector_protocol/crdtp/protocol_core_test.cc
rename to deps/inspector_protocol/crdtp/protocol_core_test.cc
diff --git a/tools/inspector_protocol/crdtp/serializable.cc b/deps/inspector_protocol/crdtp/serializable.cc
similarity index 100%
rename from tools/inspector_protocol/crdtp/serializable.cc
rename to deps/inspector_protocol/crdtp/serializable.cc
diff --git a/tools/inspector_protocol/crdtp/serializable.h b/deps/inspector_protocol/crdtp/serializable.h
similarity index 100%
rename from tools/inspector_protocol/crdtp/serializable.h
rename to deps/inspector_protocol/crdtp/serializable.h
diff --git a/tools/inspector_protocol/crdtp/serializable_test.cc b/deps/inspector_protocol/crdtp/serializable_test.cc
similarity index 100%
rename from tools/inspector_protocol/crdtp/serializable_test.cc
rename to deps/inspector_protocol/crdtp/serializable_test.cc
diff --git a/tools/inspector_protocol/crdtp/span.cc b/deps/inspector_protocol/crdtp/span.cc
similarity index 100%
rename from tools/inspector_protocol/crdtp/span.cc
rename to deps/inspector_protocol/crdtp/span.cc
diff --git a/tools/inspector_protocol/crdtp/span.h b/deps/inspector_protocol/crdtp/span.h
similarity index 100%
rename from tools/inspector_protocol/crdtp/span.h
rename to deps/inspector_protocol/crdtp/span.h
diff --git a/tools/inspector_protocol/crdtp/span_test.cc b/deps/inspector_protocol/crdtp/span_test.cc
similarity index 100%
rename from tools/inspector_protocol/crdtp/span_test.cc
rename to deps/inspector_protocol/crdtp/span_test.cc
diff --git a/tools/inspector_protocol/crdtp/status.cc b/deps/inspector_protocol/crdtp/status.cc
similarity index 100%
rename from tools/inspector_protocol/crdtp/status.cc
rename to deps/inspector_protocol/crdtp/status.cc
diff --git a/tools/inspector_protocol/crdtp/status.h b/deps/inspector_protocol/crdtp/status.h
similarity index 100%
rename from tools/inspector_protocol/crdtp/status.h
rename to deps/inspector_protocol/crdtp/status.h
diff --git a/tools/inspector_protocol/crdtp/status_test.cc b/deps/inspector_protocol/crdtp/status_test.cc
similarity index 100%
rename from tools/inspector_protocol/crdtp/status_test.cc
rename to deps/inspector_protocol/crdtp/status_test.cc
diff --git a/tools/inspector_protocol/crdtp/status_test_support.cc b/deps/inspector_protocol/crdtp/status_test_support.cc
similarity index 100%
rename from tools/inspector_protocol/crdtp/status_test_support.cc
rename to deps/inspector_protocol/crdtp/status_test_support.cc
diff --git a/tools/inspector_protocol/crdtp/status_test_support.h b/deps/inspector_protocol/crdtp/status_test_support.h
similarity index 100%
rename from tools/inspector_protocol/crdtp/status_test_support.h
rename to deps/inspector_protocol/crdtp/status_test_support.h
diff --git a/tools/inspector_protocol/crdtp/test_platform.cc b/deps/inspector_protocol/crdtp/test_platform.cc
similarity index 100%
rename from tools/inspector_protocol/crdtp/test_platform.cc
rename to deps/inspector_protocol/crdtp/test_platform.cc
diff --git a/tools/inspector_protocol/crdtp/test_platform.h b/deps/inspector_protocol/crdtp/test_platform.h
similarity index 100%
rename from tools/inspector_protocol/crdtp/test_platform.h
rename to deps/inspector_protocol/crdtp/test_platform.h
diff --git a/tools/inspector_protocol/crdtp/test_string_traits.cc b/deps/inspector_protocol/crdtp/test_string_traits.cc
similarity index 100%
rename from tools/inspector_protocol/crdtp/test_string_traits.cc
rename to deps/inspector_protocol/crdtp/test_string_traits.cc
diff --git a/tools/inspector_protocol/crdtp/test_string_traits.h b/deps/inspector_protocol/crdtp/test_string_traits.h
similarity index 100%
rename from tools/inspector_protocol/crdtp/test_string_traits.h
rename to deps/inspector_protocol/crdtp/test_string_traits.h
diff --git a/tools/inspector_protocol/crdtp/transcode.cc b/deps/inspector_protocol/crdtp/transcode.cc
similarity index 100%
rename from tools/inspector_protocol/crdtp/transcode.cc
rename to deps/inspector_protocol/crdtp/transcode.cc
diff --git a/tools/inspector_protocol/inspector_protocol.gni b/deps/inspector_protocol/inspector_protocol.gni
similarity index 100%
rename from tools/inspector_protocol/inspector_protocol.gni
rename to deps/inspector_protocol/inspector_protocol.gni
diff --git a/deps/inspector_protocol/inspector_protocol.gyp b/deps/inspector_protocol/inspector_protocol.gyp
new file mode 100644
index 00000000000000..0eb551c769f55d
--- /dev/null
+++ b/deps/inspector_protocol/inspector_protocol.gyp
@@ -0,0 +1,43 @@
+{
+  'variables': {
+    'crdtp_sources': [
+      'crdtp/cbor.cc',
+      'crdtp/cbor.h',
+      'crdtp/dispatch.cc',
+      'crdtp/dispatch.h',
+      'crdtp/error_support.cc',
+      'crdtp/error_support.h',
+      'crdtp/export.h',
+      'crdtp/find_by_first.h',
+      'crdtp/frontend_channel.h',
+      'crdtp/json.cc',
+      'crdtp/json.h',
+      'crdtp/json_platform.cc',
+      'crdtp/json_platform.h',
+      'crdtp/maybe.h',
+      'crdtp/parser_handler.h',
+      'crdtp/protocol_core.cc',
+      'crdtp/protocol_core.h',
+      'crdtp/serializable.cc',
+      'crdtp/serializable.h',
+      'crdtp/span.cc',
+      'crdtp/span.h',
+      'crdtp/status.cc',
+      'crdtp/status.h',
+    ]
+  },
+  'targets': [
+    {
+      'target_name': 'crdtp',
+      'type': 'static_library',
+      'include_dirs': [ '.' ],
+      'direct_dependent_settings': {
+        # Use like `#include "crdtp/json.h"`
+        'include_dirs': [ '.' ],
+      },
+      'sources': [
+        '<@(crdtp_sources)',
+      ],
+    },
+  ]
+}
diff --git a/tools/inspector_protocol/lib/Forward_h.template b/deps/inspector_protocol/lib/Forward_h.template
similarity index 100%
rename from tools/inspector_protocol/lib/Forward_h.template
rename to deps/inspector_protocol/lib/Forward_h.template
diff --git a/tools/inspector_protocol/lib/Object_cpp.template b/deps/inspector_protocol/lib/Object_cpp.template
similarity index 100%
rename from tools/inspector_protocol/lib/Object_cpp.template
rename to deps/inspector_protocol/lib/Object_cpp.template
diff --git a/tools/inspector_protocol/lib/Object_h.template b/deps/inspector_protocol/lib/Object_h.template
similarity index 100%
rename from tools/inspector_protocol/lib/Object_h.template
rename to deps/inspector_protocol/lib/Object_h.template
diff --git a/tools/inspector_protocol/lib/Protocol_cpp.template b/deps/inspector_protocol/lib/Protocol_cpp.template
similarity index 100%
rename from tools/inspector_protocol/lib/Protocol_cpp.template
rename to deps/inspector_protocol/lib/Protocol_cpp.template
diff --git a/tools/inspector_protocol/lib/ValueConversions_cpp.template b/deps/inspector_protocol/lib/ValueConversions_cpp.template
similarity index 100%
rename from tools/inspector_protocol/lib/ValueConversions_cpp.template
rename to deps/inspector_protocol/lib/ValueConversions_cpp.template
diff --git a/tools/inspector_protocol/lib/ValueConversions_h.template b/deps/inspector_protocol/lib/ValueConversions_h.template
similarity index 100%
rename from tools/inspector_protocol/lib/ValueConversions_h.template
rename to deps/inspector_protocol/lib/ValueConversions_h.template
diff --git a/tools/inspector_protocol/lib/Values_cpp.template b/deps/inspector_protocol/lib/Values_cpp.template
similarity index 100%
rename from tools/inspector_protocol/lib/Values_cpp.template
rename to deps/inspector_protocol/lib/Values_cpp.template
diff --git a/tools/inspector_protocol/lib/Values_h.template b/deps/inspector_protocol/lib/Values_h.template
similarity index 100%
rename from tools/inspector_protocol/lib/Values_h.template
rename to deps/inspector_protocol/lib/Values_h.template
diff --git a/tools/inspector_protocol/pdl.py b/deps/inspector_protocol/pdl.py
similarity index 100%
rename from tools/inspector_protocol/pdl.py
rename to deps/inspector_protocol/pdl.py
diff --git a/tools/inspector_protocol/templates/Exported_h.template b/deps/inspector_protocol/templates/Exported_h.template
similarity index 100%
rename from tools/inspector_protocol/templates/Exported_h.template
rename to deps/inspector_protocol/templates/Exported_h.template
diff --git a/tools/inspector_protocol/templates/Imported_h.template b/deps/inspector_protocol/templates/Imported_h.template
similarity index 100%
rename from tools/inspector_protocol/templates/Imported_h.template
rename to deps/inspector_protocol/templates/Imported_h.template
diff --git a/tools/inspector_protocol/templates/TypeBuilder_cpp.template b/deps/inspector_protocol/templates/TypeBuilder_cpp.template
similarity index 100%
rename from tools/inspector_protocol/templates/TypeBuilder_cpp.template
rename to deps/inspector_protocol/templates/TypeBuilder_cpp.template
diff --git a/tools/inspector_protocol/templates/TypeBuilder_h.template b/deps/inspector_protocol/templates/TypeBuilder_h.template
similarity index 100%
rename from tools/inspector_protocol/templates/TypeBuilder_h.template
rename to deps/inspector_protocol/templates/TypeBuilder_h.template
diff --git a/src/inspector/node_inspector.gypi b/src/inspector/node_inspector.gypi
index 6e5d872c36836c..3ae714b51407a4 100644
--- a/src/inspector/node_inspector.gypi
+++ b/src/inspector/node_inspector.gypi
@@ -1,6 +1,7 @@
 {
   'variables': {
-    'protocol_tool_path': '../../tools/inspector_protocol',
+    'protocol_tool_path': '../../deps/inspector_protocol',
+    'jinja_dir': '../../tools/inspector_protocol',
     'node_inspector_sources': [
       'src/inspector_agent.cc',
       'src/inspector_io.cc',
@@ -31,30 +32,6 @@
       'src/inspector/network_agent.h',
       'src/inspector/worker_inspector.cc',
       'src/inspector/worker_inspector.h',
-
-      '<(protocol_tool_path)/crdtp/cbor.cc',
-      '<(protocol_tool_path)/crdtp/cbor.h',
-      '<(protocol_tool_path)/crdtp/dispatch.cc',
-      '<(protocol_tool_path)/crdtp/dispatch.h',
-      '<(protocol_tool_path)/crdtp/error_support.cc',
-      '<(protocol_tool_path)/crdtp/error_support.h',
-      '<(protocol_tool_path)/crdtp/export.h',
-      '<(protocol_tool_path)/crdtp/find_by_first.h',
-      '<(protocol_tool_path)/crdtp/frontend_channel.h',
-      '<(protocol_tool_path)/crdtp/json.cc',
-      '<(protocol_tool_path)/crdtp/json.h',
-      '<(protocol_tool_path)/crdtp/json_platform.cc',
-      '<(protocol_tool_path)/crdtp/json_platform.h',
-      '<(protocol_tool_path)/crdtp/maybe.h',
-      '<(protocol_tool_path)/crdtp/parser_handler.h',
-      '<(protocol_tool_path)/crdtp/protocol_core.cc',
-      '<(protocol_tool_path)/crdtp/protocol_core.h',
-      '<(protocol_tool_path)/crdtp/serializable.cc',
-      '<(protocol_tool_path)/crdtp/serializable.h',
-      '<(protocol_tool_path)/crdtp/span.cc',
-      '<(protocol_tool_path)/crdtp/span.h',
-      '<(protocol_tool_path)/crdtp/status.cc',
-      '<(protocol_tool_path)/crdtp/status.h',
     ],
     'node_inspector_generated_sources': [
       '<(SHARED_INTERMEDIATE_DIR)/src/node/inspector/protocol/Forward.h',
@@ -91,11 +68,13 @@
     '<@(node_inspector_sources)',
   ],
   'include_dirs': [
-    '<(protocol_tool_path)',
     '<(SHARED_INTERMEDIATE_DIR)/include', # for inspector
     '<(SHARED_INTERMEDIATE_DIR)',
     '<(SHARED_INTERMEDIATE_DIR)/src', # for inspector
   ],
+  'dependencies': [
+    '<(protocol_tool_path)/inspector_protocol.gyp:crdtp',
+  ],
   'actions': [
     {
       'action_name': 'convert_node_protocol_to_json',
@@ -107,7 +86,7 @@
       ],
       'action': [
         '<(python)',
-        'tools/inspector_protocol/convert_protocol_to_json.py',
+        '<(protocol_tool_path)/convert_protocol_to_json.py',
         '<@(_inputs)',
         '<@(_outputs)',
       ],
@@ -126,9 +105,9 @@
       'process_outputs_as_sources': 1,
       'action': [
         '<(python)',
-        'tools/inspector_protocol/code_generator.py',
-        '--inspector_protocol_dir', 'tools/inspector_protocol/',
-        '--jinja_dir', '<@(protocol_tool_path)',
+        '<(protocol_tool_path)/code_generator.py',
+        '--inspector_protocol_dir', '<(protocol_tool_path)',
+        '--jinja_dir', '<(jinja_dir)',
         '--output_base', '<(SHARED_INTERMEDIATE_DIR)/src/',
         '--config', 'src/inspector/node_protocol_config.json',
       ],
@@ -145,7 +124,7 @@
       ],
       'action': [
         '<(python)',
-        'tools/inspector_protocol/concatenate_protocols.py',
+        '<(protocol_tool_path)/concatenate_protocols.py',
         '<@(_inputs)',
         '<@(_outputs)',
       ],
diff --git a/tools/inspector_protocol/.clang-format b/tools/inspector_protocol/.clang-format
deleted file mode 100644
index fcbc9c321a5c61..00000000000000
--- a/tools/inspector_protocol/.clang-format
+++ /dev/null
@@ -1,36 +0,0 @@
-# Defines the Chromium style for automatic reformatting.
-# http://clang.llvm.org/docs/ClangFormatStyleOptions.html
-BasedOnStyle: Chromium
-# This defaults to 'Auto'. Explicitly set it for a while, so that
-# 'vector<vector<int> >' in existing files gets formatted to
-# 'vector<vector<int>>'. ('Auto' means that clang-format will only use
-# 'int>>' if the file already contains at least one such instance.)
-Standard: Cpp11
-
-# Make sure code like:
-# IPC_BEGIN_MESSAGE_MAP()
-#   IPC_MESSAGE_HANDLER(WidgetHostViewHost_Update, OnUpdate)
-# IPC_END_MESSAGE_MAP()
-# gets correctly indented.
-MacroBlockBegin: "^\
-BEGIN_MSG_MAP|\
-BEGIN_MSG_MAP_EX|\
-BEGIN_SAFE_MSG_MAP_EX|\
-CR_BEGIN_MSG_MAP_EX|\
-IPC_BEGIN_MESSAGE_MAP|\
-IPC_BEGIN_MESSAGE_MAP_WITH_PARAM|\
-IPC_PROTOBUF_MESSAGE_TRAITS_BEGIN|\
-IPC_STRUCT_BEGIN|\
-IPC_STRUCT_BEGIN_WITH_PARENT|\
-IPC_STRUCT_TRAITS_BEGIN|\
-POLPARAMS_BEGIN|\
-PPAPI_BEGIN_MESSAGE_MAP$"
-MacroBlockEnd: "^\
-CR_END_MSG_MAP|\
-END_MSG_MAP|\
-IPC_END_MESSAGE_MAP|\
-IPC_PROTOBUF_MESSAGE_TRAITS_END|\
-IPC_STRUCT_END|\
-IPC_STRUCT_TRAITS_END|\
-POLPARAMS_END|\
-PPAPI_END_MESSAGE_MAP$"
diff --git a/tools/inspector_protocol/OWNERS b/tools/inspector_protocol/OWNERS
deleted file mode 100644
index 8d0b6d90cb233b..00000000000000
--- a/tools/inspector_protocol/OWNERS
+++ /dev/null
@@ -1,8 +0,0 @@
-set noparent
-
-alph@chromium.org
-caseq@chromium.org
-dgozman@chromium.org
-kozyatinskiy@chromium.org
-pfeldman@chromium.org
-yangguo@chromium.org
diff --git a/tools/inspector_protocol/README.md b/tools/inspector_protocol/README.md
index d15f719fdda32c..9b1e3263a86bc3 100644
--- a/tools/inspector_protocol/README.md
+++ b/tools/inspector_protocol/README.md
@@ -1,18 +1,6 @@
 # Chromium inspector (devtools) protocol
 
-This package contains code generators and templates for the Chromium
-inspector protocol.
+This directory contains scripts to update the [Chromium inspector protocol][]
+to local at `deps/inspector_protocol`.
 
-The canonical location of this package is at
-https://chromium.googlesource.com/deps/inspector_protocol/
-
-In the Chromium tree, it's rolled into
-https://cs.chromium.org/chromium/src/third_party/inspector_protocol/
-
-In the V8 tree, it's rolled into
-https://cs.chromium.org/chromium/src/v8/third_party/inspector_protocol/
-
-See also [Contributing to Chrome Devtools Protocol](https://docs.google.com/document/d/1c-COD2kaK__5iMM5SEx-PzNA7HFmgttcYfOHHX0HaOM/edit).
-
-To build and run the tests of the crdtp library, see
-[CRDTP - Chrome DevTools Protocol](crdtp/README.md).
+[Chromium inspector protocol]: https://chromium.googlesource.com/deps/inspector_protocol/
diff --git a/tools/inspector_protocol/codereview.settings b/tools/inspector_protocol/codereview.settings
deleted file mode 100644
index 6ac8580b4ccd9f..00000000000000
--- a/tools/inspector_protocol/codereview.settings
+++ /dev/null
@@ -1,6 +0,0 @@
-# This file is used by git-cl to get repository specific information.
-CC_LIST: chromium-reviews@chromium.org
-CODE_REVIEW_SERVER: codereview.chromium.org
-GERRIT_HOST: True
-PROJECT: inspector_protocol
-VIEW_VC: https://chromium.googlesource.com/deps/inspector_protocol/+/
diff --git a/tools/inspector_protocol/encoding/encoding.cc b/tools/inspector_protocol/encoding/encoding.cc
deleted file mode 100644
index f7e933e41afac5..00000000000000
--- a/tools/inspector_protocol/encoding/encoding.cc
+++ /dev/null
@@ -1,2190 +0,0 @@
-// Copyright 2019 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "encoding.h"
-
-#include <algorithm>
-#include <cassert>
-#include <cmath>
-#include <cstring>
-#include <limits>
-#include <stack>
-
-namespace v8_inspector_protocol_encoding {
-// =============================================================================
-// Status and Error codes
-// =============================================================================
-
-std::string Status::ToASCIIString() const {
-  switch (error) {
-    case Error::OK:
-      return "OK";
-    case Error::JSON_PARSER_UNPROCESSED_INPUT_REMAINS:
-      return ToASCIIString("JSON: unprocessed input remains");
-    case Error::JSON_PARSER_STACK_LIMIT_EXCEEDED:
-      return ToASCIIString("JSON: stack limit exceeded");
-    case Error::JSON_PARSER_NO_INPUT:
-      return ToASCIIString("JSON: no input");
-    case Error::JSON_PARSER_INVALID_TOKEN:
-      return ToASCIIString("JSON: invalid token");
-    case Error::JSON_PARSER_INVALID_NUMBER:
-      return ToASCIIString("JSON: invalid number");
-    case Error::JSON_PARSER_INVALID_STRING:
-      return ToASCIIString("JSON: invalid string");
-    case Error::JSON_PARSER_UNEXPECTED_ARRAY_END:
-      return ToASCIIString("JSON: unexpected array end");
-    case Error::JSON_PARSER_COMMA_OR_ARRAY_END_EXPECTED:
-      return ToASCIIString("JSON: comma or array end expected");
-    case Error::JSON_PARSER_STRING_LITERAL_EXPECTED:
-      return ToASCIIString("JSON: string literal expected");
-    case Error::JSON_PARSER_COLON_EXPECTED:
-      return ToASCIIString("JSON: colon expected");
-    case Error::JSON_PARSER_UNEXPECTED_MAP_END:
-      return ToASCIIString("JSON: unexpected map end");
-    case Error::JSON_PARSER_COMMA_OR_MAP_END_EXPECTED:
-      return ToASCIIString("JSON: comma or map end expected");
-    case Error::JSON_PARSER_VALUE_EXPECTED:
-      return ToASCIIString("JSON: value expected");
-
-    case Error::CBOR_INVALID_INT32:
-      return ToASCIIString("CBOR: invalid int32");
-    case Error::CBOR_INVALID_DOUBLE:
-      return ToASCIIString("CBOR: invalid double");
-    case Error::CBOR_INVALID_ENVELOPE:
-      return ToASCIIString("CBOR: invalid envelope");
-    case Error::CBOR_INVALID_STRING8:
-      return ToASCIIString("CBOR: invalid string8");
-    case Error::CBOR_INVALID_STRING16:
-      return ToASCIIString("CBOR: invalid string16");
-    case Error::CBOR_INVALID_BINARY:
-      return ToASCIIString("CBOR: invalid binary");
-    case Error::CBOR_UNSUPPORTED_VALUE:
-      return ToASCIIString("CBOR: unsupported value");
-    case Error::CBOR_NO_INPUT:
-      return ToASCIIString("CBOR: no input");
-    case Error::CBOR_INVALID_START_BYTE:
-      return ToASCIIString("CBOR: invalid start byte");
-    case Error::CBOR_UNEXPECTED_EOF_EXPECTED_VALUE:
-      return ToASCIIString("CBOR: unexpected eof expected value");
-    case Error::CBOR_UNEXPECTED_EOF_IN_ARRAY:
-      return ToASCIIString("CBOR: unexpected eof in array");
-    case Error::CBOR_UNEXPECTED_EOF_IN_MAP:
-      return ToASCIIString("CBOR: unexpected eof in map");
-    case Error::CBOR_INVALID_MAP_KEY:
-      return ToASCIIString("CBOR: invalid map key");
-    case Error::CBOR_STACK_LIMIT_EXCEEDED:
-      return ToASCIIString("CBOR: stack limit exceeded");
-    case Error::CBOR_TRAILING_JUNK:
-      return ToASCIIString("CBOR: trailing junk");
-    case Error::CBOR_MAP_START_EXPECTED:
-      return ToASCIIString("CBOR: map start expected");
-    case Error::CBOR_MAP_STOP_EXPECTED:
-      return ToASCIIString("CBOR: map stop expected");
-    case Error::CBOR_ENVELOPE_SIZE_LIMIT_EXCEEDED:
-      return ToASCIIString("CBOR: envelope size limit exceeded");
-  }
-  // Some compilers can't figure out that we can't get here.
-  return "INVALID ERROR CODE";
-}
-
-std::string Status::ToASCIIString(const char* msg) const {
-  return std::string(msg) + " at position " + std::to_string(pos);
-}
-
-namespace cbor {
-namespace {
-// Indicates the number of bits the "initial byte" needs to be shifted to the
-// right after applying |kMajorTypeMask| to produce the major type in the
-// lowermost bits.
-static constexpr uint8_t kMajorTypeBitShift = 5u;
-// Mask selecting the low-order 5 bits of the "initial byte", which is where
-// the additional information is encoded.
-static constexpr uint8_t kAdditionalInformationMask = 0x1f;
-// Mask selecting the high-order 3 bits of the "initial byte", which indicates
-// the major type of the encoded value.
-static constexpr uint8_t kMajorTypeMask = 0xe0;
-// Indicates the integer is in the following byte.
-static constexpr uint8_t kAdditionalInformation1Byte = 24u;
-// Indicates the integer is in the next 2 bytes.
-static constexpr uint8_t kAdditionalInformation2Bytes = 25u;
-// Indicates the integer is in the next 4 bytes.
-static constexpr uint8_t kAdditionalInformation4Bytes = 26u;
-// Indicates the integer is in the next 8 bytes.
-static constexpr uint8_t kAdditionalInformation8Bytes = 27u;
-
-// Encodes the initial byte, consisting of the |type| in the first 3 bits
-// followed by 5 bits of |additional_info|.
-constexpr uint8_t EncodeInitialByte(MajorType type, uint8_t additional_info) {
-  return (static_cast<uint8_t>(type) << kMajorTypeBitShift) |
-         (additional_info & kAdditionalInformationMask);
-}
-
-// TAG 24 indicates that what follows is a byte string which is
-// encoded in CBOR format. We use this as a wrapper for
-// maps and arrays, allowing us to skip them, because the
-// byte string carries its size (byte length).
-// https://tools.ietf.org/html/rfc7049#section-2.4.4.1
-static constexpr uint8_t kInitialByteForEnvelope =
-    EncodeInitialByte(MajorType::TAG, 24);
-// The initial byte for a byte string with at most 2^32 bytes
-// of payload. This is used for envelope encoding, even if
-// the byte string is shorter.
-static constexpr uint8_t kInitialByteFor32BitLengthByteString =
-    EncodeInitialByte(MajorType::BYTE_STRING, 26);
-
-// See RFC 7049 Section 2.2.1, indefinite length arrays / maps have additional
-// info = 31.
-static constexpr uint8_t kInitialByteIndefiniteLengthArray =
-    EncodeInitialByte(MajorType::ARRAY, 31);
-static constexpr uint8_t kInitialByteIndefiniteLengthMap =
-    EncodeInitialByte(MajorType::MAP, 31);
-// See RFC 7049 Section 2.3, Table 1; this is used for finishing indefinite
-// length maps / arrays.
-static constexpr uint8_t kStopByte =
-    EncodeInitialByte(MajorType::SIMPLE_VALUE, 31);
-
-// See RFC 7049 Section 2.3, Table 2.
-static constexpr uint8_t kEncodedTrue =
-    EncodeInitialByte(MajorType::SIMPLE_VALUE, 21);
-static constexpr uint8_t kEncodedFalse =
-    EncodeInitialByte(MajorType::SIMPLE_VALUE, 20);
-static constexpr uint8_t kEncodedNull =
-    EncodeInitialByte(MajorType::SIMPLE_VALUE, 22);
-static constexpr uint8_t kInitialByteForDouble =
-    EncodeInitialByte(MajorType::SIMPLE_VALUE, 27);
-
-// See RFC 7049 Table 3 and Section 2.4.4.2. This is used as a prefix for
-// arbitrary binary data encoded as BYTE_STRING.
-static constexpr uint8_t kExpectedConversionToBase64Tag =
-    EncodeInitialByte(MajorType::TAG, 22);
-
-// Writes the bytes for |v| to |out|, starting with the most significant byte.
-// See also: https://commandcenter.blogspot.com/2012/04/byte-order-fallacy.html
-template <typename T, class C>
-void WriteBytesMostSignificantByteFirst(T v, C* out) {
-  for (int shift_bytes = sizeof(T) - 1; shift_bytes >= 0; --shift_bytes)
-    out->push_back(0xff & (v >> (shift_bytes * 8)));
-}
-
-// Extracts sizeof(T) bytes from |in| to extract a value of type T
-// (e.g. uint64_t, uint32_t, ...), most significant byte first.
-// See also: https://commandcenter.blogspot.com/2012/04/byte-order-fallacy.html
-template <typename T>
-T ReadBytesMostSignificantByteFirst(span<uint8_t> in) {
-  assert(in.size() >= sizeof(T));
-  T result = 0;
-  for (size_t shift_bytes = 0; shift_bytes < sizeof(T); ++shift_bytes)
-    result |= T(in[sizeof(T) - 1 - shift_bytes]) << (shift_bytes * 8);
-  return result;
-}
-}  // namespace
-
-namespace internals {
-// Reads the start of a token with definitive size from |bytes|.
-// |type| is the major type as specified in RFC 7049 Section 2.1.
-// |value| is the payload (e.g. for MajorType::UNSIGNED) or is the size
-// (e.g. for BYTE_STRING).
-// If successful, returns the number of bytes read. Otherwise returns 0.
-size_t ReadTokenStart(span<uint8_t> bytes, MajorType* type, uint64_t* value) {
-  if (bytes.empty())
-    return 0;
-  uint8_t initial_byte = bytes[0];
-  *type = MajorType((initial_byte & kMajorTypeMask) >> kMajorTypeBitShift);
-
-  uint8_t additional_information = initial_byte & kAdditionalInformationMask;
-  if (additional_information < 24) {
-    // Values 0-23 are encoded directly into the additional info of the
-    // initial byte.
-    *value = additional_information;
-    return 1;
-  }
-  if (additional_information == kAdditionalInformation1Byte) {
-    // Values 24-255 are encoded with one initial byte, followed by the value.
-    if (bytes.size() < 2)
-      return 0;
-    *value = ReadBytesMostSignificantByteFirst<uint8_t>(bytes.subspan(1));
-    return 2;
-  }
-  if (additional_information == kAdditionalInformation2Bytes) {
-    // Values 256-65535: 1 initial byte + 2 bytes payload.
-    if (bytes.size() < 1 + sizeof(uint16_t))
-      return 0;
-    *value = ReadBytesMostSignificantByteFirst<uint16_t>(bytes.subspan(1));
-    return 3;
-  }
-  if (additional_information == kAdditionalInformation4Bytes) {
-    // 32 bit uint: 1 initial byte + 4 bytes payload.
-    if (bytes.size() < 1 + sizeof(uint32_t))
-      return 0;
-    *value = ReadBytesMostSignificantByteFirst<uint32_t>(bytes.subspan(1));
-    return 5;
-  }
-  if (additional_information == kAdditionalInformation8Bytes) {
-    // 64 bit uint: 1 initial byte + 8 bytes payload.
-    if (bytes.size() < 1 + sizeof(uint64_t))
-      return 0;
-    *value = ReadBytesMostSignificantByteFirst<uint64_t>(bytes.subspan(1));
-    return 9;
-  }
-  return 0;
-}
-
-// Writes the start of a token with |type|. The |value| may indicate the size,
-// or it may be the payload if the value is an unsigned integer.
-template <typename C>
-void WriteTokenStartTmpl(MajorType type, uint64_t value, C* encoded) {
-  if (value < 24) {
-    // Values 0-23 are encoded directly into the additional info of the
-    // initial byte.
-    encoded->push_back(EncodeInitialByte(type, /*additional_info=*/value));
-    return;
-  }
-  if (value <= std::numeric_limits<uint8_t>::max()) {
-    // Values 24-255 are encoded with one initial byte, followed by the value.
-    encoded->push_back(EncodeInitialByte(type, kAdditionalInformation1Byte));
-    encoded->push_back(value);
-    return;
-  }
-  if (value <= std::numeric_limits<uint16_t>::max()) {
-    // Values 256-65535: 1 initial byte + 2 bytes payload.
-    encoded->push_back(EncodeInitialByte(type, kAdditionalInformation2Bytes));
-    WriteBytesMostSignificantByteFirst<uint16_t>(value, encoded);
-    return;
-  }
-  if (value <= std::numeric_limits<uint32_t>::max()) {
-    // 32 bit uint: 1 initial byte + 4 bytes payload.
-    encoded->push_back(EncodeInitialByte(type, kAdditionalInformation4Bytes));
-    WriteBytesMostSignificantByteFirst<uint32_t>(static_cast<uint32_t>(value),
-                                                 encoded);
-    return;
-  }
-  // 64 bit uint: 1 initial byte + 8 bytes payload.
-  encoded->push_back(EncodeInitialByte(type, kAdditionalInformation8Bytes));
-  WriteBytesMostSignificantByteFirst<uint64_t>(value, encoded);
-}
-void WriteTokenStart(MajorType type,
-                     uint64_t value,
-                     std::vector<uint8_t>* encoded) {
-  WriteTokenStartTmpl(type, value, encoded);
-}
-void WriteTokenStart(MajorType type, uint64_t value, std::string* encoded) {
-  WriteTokenStartTmpl(type, value, encoded);
-}
-}  // namespace internals
-
-// =============================================================================
-// Detecting CBOR content
-// =============================================================================
-
-uint8_t InitialByteForEnvelope() {
-  return kInitialByteForEnvelope;
-}
-uint8_t InitialByteFor32BitLengthByteString() {
-  return kInitialByteFor32BitLengthByteString;
-}
-bool IsCBORMessage(span<uint8_t> msg) {
-  return msg.size() >= 6 && msg[0] == InitialByteForEnvelope() &&
-         msg[1] == InitialByteFor32BitLengthByteString();
-}
-
-// =============================================================================
-// Encoding invidiual CBOR items
-// =============================================================================
-
-uint8_t EncodeTrue() {
-  return kEncodedTrue;
-}
-uint8_t EncodeFalse() {
-  return kEncodedFalse;
-}
-uint8_t EncodeNull() {
-  return kEncodedNull;
-}
-
-uint8_t EncodeIndefiniteLengthArrayStart() {
-  return kInitialByteIndefiniteLengthArray;
-}
-
-uint8_t EncodeIndefiniteLengthMapStart() {
-  return kInitialByteIndefiniteLengthMap;
-}
-
-uint8_t EncodeStop() {
-  return kStopByte;
-}
-
-template <typename C>
-void EncodeInt32Tmpl(int32_t value, C* out) {
-  if (value >= 0) {
-    internals::WriteTokenStart(MajorType::UNSIGNED, value, out);
-  } else {
-    uint64_t representation = static_cast<uint64_t>(-(value + 1));
-    internals::WriteTokenStart(MajorType::NEGATIVE, representation, out);
-  }
-}
-void EncodeInt32(int32_t value, std::vector<uint8_t>* out) {
-  EncodeInt32Tmpl(value, out);
-}
-void EncodeInt32(int32_t value, std::string* out) {
-  EncodeInt32Tmpl(value, out);
-}
-
-template <typename C>
-void EncodeString16Tmpl(span<uint16_t> in, C* out) {
-  uint64_t byte_length = static_cast<uint64_t>(in.size_bytes());
-  internals::WriteTokenStart(MajorType::BYTE_STRING, byte_length, out);
-  // When emitting UTF16 characters, we always write the least significant byte
-  // first; this is because it's the native representation for X86.
-  // TODO(johannes): Implement a more efficient thing here later, e.g.
-  // casting *iff* the machine has this byte order.
-  // The wire format for UTF16 chars will probably remain the same
-  // (least significant byte first) since this way we can have
-  // golden files, unittests, etc. that port easily and universally.
-  // See also:
-  // https://commandcenter.blogspot.com/2012/04/byte-order-fallacy.html
-  for (const uint16_t two_bytes : in) {
-    out->push_back(two_bytes);
-    out->push_back(two_bytes >> 8);
-  }
-}
-void EncodeString16(span<uint16_t> in, std::vector<uint8_t>* out) {
-  EncodeString16Tmpl(in, out);
-}
-void EncodeString16(span<uint16_t> in, std::string* out) {
-  EncodeString16Tmpl(in, out);
-}
-
-template <typename C>
-void EncodeString8Tmpl(span<uint8_t> in, C* out) {
-  internals::WriteTokenStart(MajorType::STRING,
-                             static_cast<uint64_t>(in.size_bytes()), out);
-  out->insert(out->end(), in.begin(), in.end());
-}
-void EncodeString8(span<uint8_t> in, std::vector<uint8_t>* out) {
-  EncodeString8Tmpl(in, out);
-}
-void EncodeString8(span<uint8_t> in, std::string* out) {
-  EncodeString8Tmpl(in, out);
-}
-
-template <typename C>
-void EncodeFromLatin1Tmpl(span<uint8_t> latin1, C* out) {
-  for (size_t ii = 0; ii < latin1.size(); ++ii) {
-    if (latin1[ii] <= 127)
-      continue;
-    // If there's at least one non-ASCII char, convert to UTF8.
-    std::vector<uint8_t> utf8(latin1.begin(), latin1.begin() + ii);
-    for (; ii < latin1.size(); ++ii) {
-      if (latin1[ii] <= 127) {
-        utf8.push_back(latin1[ii]);
-      } else {
-        // 0xC0 means it's a UTF8 sequence with 2 bytes.
-        utf8.push_back((latin1[ii] >> 6) | 0xc0);
-        utf8.push_back((latin1[ii] | 0x80) & 0xbf);
-      }
-    }
-    EncodeString8(SpanFrom(utf8), out);
-    return;
-  }
-  EncodeString8(latin1, out);
-}
-void EncodeFromLatin1(span<uint8_t> latin1, std::vector<uint8_t>* out) {
-  EncodeFromLatin1Tmpl(latin1, out);
-}
-void EncodeFromLatin1(span<uint8_t> latin1, std::string* out) {
-  EncodeFromLatin1Tmpl(latin1, out);
-}
-
-template <typename C>
-void EncodeFromUTF16Tmpl(span<uint16_t> utf16, C* out) {
-  // If there's at least one non-ASCII char, encode as STRING16 (UTF16).
-  for (uint16_t ch : utf16) {
-    if (ch <= 127)
-      continue;
-    EncodeString16(utf16, out);
-    return;
-  }
-  // It's all US-ASCII, strip out every second byte and encode as UTF8.
-  internals::WriteTokenStart(MajorType::STRING,
-                             static_cast<uint64_t>(utf16.size()), out);
-  out->insert(out->end(), utf16.begin(), utf16.end());
-}
-void EncodeFromUTF16(span<uint16_t> utf16, std::vector<uint8_t>* out) {
-  EncodeFromUTF16Tmpl(utf16, out);
-}
-void EncodeFromUTF16(span<uint16_t> utf16, std::string* out) {
-  EncodeFromUTF16Tmpl(utf16, out);
-}
-
-template <typename C>
-void EncodeBinaryTmpl(span<uint8_t> in, C* out) {
-  out->push_back(kExpectedConversionToBase64Tag);
-  uint64_t byte_length = static_cast<uint64_t>(in.size_bytes());
-  internals::WriteTokenStart(MajorType::BYTE_STRING, byte_length, out);
-  out->insert(out->end(), in.begin(), in.end());
-}
-void EncodeBinary(span<uint8_t> in, std::vector<uint8_t>* out) {
-  EncodeBinaryTmpl(in, out);
-}
-void EncodeBinary(span<uint8_t> in, std::string* out) {
-  EncodeBinaryTmpl(in, out);
-}
-
-// A double is encoded with a specific initial byte
-// (kInitialByteForDouble) plus the 64 bits of payload for its value.
-constexpr size_t kEncodedDoubleSize = 1 + sizeof(uint64_t);
-
-// An envelope is encoded with a specific initial byte
-// (kInitialByteForEnvelope), plus the start byte for a BYTE_STRING with a 32
-// bit wide length, plus a 32 bit length for that string.
-constexpr size_t kEncodedEnvelopeHeaderSize = 1 + 1 + sizeof(uint32_t);
-
-template <typename C>
-void EncodeDoubleTmpl(double value, C* out) {
-  // The additional_info=27 indicates 64 bits for the double follow.
-  // See RFC 7049 Section 2.3, Table 1.
-  out->push_back(kInitialByteForDouble);
-  union {
-    double from_double;
-    uint64_t to_uint64;
-  } reinterpret;
-  reinterpret.from_double = value;
-  WriteBytesMostSignificantByteFirst<uint64_t>(reinterpret.to_uint64, out);
-}
-void EncodeDouble(double value, std::vector<uint8_t>* out) {
-  EncodeDoubleTmpl(value, out);
-}
-void EncodeDouble(double value, std::string* out) {
-  EncodeDoubleTmpl(value, out);
-}
-
-// =============================================================================
-// cbor::EnvelopeEncoder - for wrapping submessages
-// =============================================================================
-
-template <typename C>
-void EncodeStartTmpl(C* out, size_t* byte_size_pos) {
-  assert(*byte_size_pos == 0);
-  out->push_back(kInitialByteForEnvelope);
-  out->push_back(kInitialByteFor32BitLengthByteString);
-  *byte_size_pos = out->size();
-  out->resize(out->size() + sizeof(uint32_t));
-}
-
-void EnvelopeEncoder::EncodeStart(std::vector<uint8_t>* out) {
-  EncodeStartTmpl<std::vector<uint8_t>>(out, &byte_size_pos_);
-}
-
-void EnvelopeEncoder::EncodeStart(std::string* out) {
-  EncodeStartTmpl<std::string>(out, &byte_size_pos_);
-}
-
-template <typename C>
-bool EncodeStopTmpl(C* out, size_t* byte_size_pos) {
-  assert(*byte_size_pos != 0);
-  // The byte size is the size of the payload, that is, all the
-  // bytes that were written past the byte size position itself.
-  uint64_t byte_size = out->size() - (*byte_size_pos + sizeof(uint32_t));
-  // We store exactly 4 bytes, so at most INT32MAX, with most significant
-  // byte first.
-  if (byte_size > std::numeric_limits<uint32_t>::max())
-    return false;
-  for (int shift_bytes = sizeof(uint32_t) - 1; shift_bytes >= 0;
-       --shift_bytes) {
-    (*out)[(*byte_size_pos)++] = 0xff & (byte_size >> (shift_bytes * 8));
-  }
-  return true;
-}
-
-bool EnvelopeEncoder::EncodeStop(std::vector<uint8_t>* out) {
-  return EncodeStopTmpl(out, &byte_size_pos_);
-}
-
-bool EnvelopeEncoder::EncodeStop(std::string* out) {
-  return EncodeStopTmpl(out, &byte_size_pos_);
-}
-
-// =============================================================================
-// cbor::NewCBOREncoder - for encoding from a streaming parser
-// =============================================================================
-
-namespace {
-template <typename C>
-class CBOREncoder : public StreamingParserHandler {
- public:
-  CBOREncoder(C* out, Status* status) : out_(out), status_(status) {
-    *status_ = Status();
-  }
-
-  void HandleMapBegin() override {
-    if (!status_->ok())
-      return;
-    envelopes_.emplace_back();
-    envelopes_.back().EncodeStart(out_);
-    out_->push_back(kInitialByteIndefiniteLengthMap);
-  }
-
-  void HandleMapEnd() override {
-    if (!status_->ok())
-      return;
-    out_->push_back(kStopByte);
-    assert(!envelopes_.empty());
-    if (!envelopes_.back().EncodeStop(out_)) {
-      HandleError(
-          Status(Error::CBOR_ENVELOPE_SIZE_LIMIT_EXCEEDED, out_->size()));
-      return;
-    }
-    envelopes_.pop_back();
-  }
-
-  void HandleArrayBegin() override {
-    if (!status_->ok())
-      return;
-    envelopes_.emplace_back();
-    envelopes_.back().EncodeStart(out_);
-    out_->push_back(kInitialByteIndefiniteLengthArray);
-  }
-
-  void HandleArrayEnd() override {
-    if (!status_->ok())
-      return;
-    out_->push_back(kStopByte);
-    assert(!envelopes_.empty());
-    if (!envelopes_.back().EncodeStop(out_)) {
-      HandleError(
-          Status(Error::CBOR_ENVELOPE_SIZE_LIMIT_EXCEEDED, out_->size()));
-      return;
-    }
-    envelopes_.pop_back();
-  }
-
-  void HandleString8(span<uint8_t> chars) override {
-    if (!status_->ok())
-      return;
-    EncodeString8(chars, out_);
-  }
-
-  void HandleString16(span<uint16_t> chars) override {
-    if (!status_->ok())
-      return;
-    EncodeFromUTF16(chars, out_);
-  }
-
-  void HandleBinary(span<uint8_t> bytes) override {
-    if (!status_->ok())
-      return;
-    EncodeBinary(bytes, out_);
-  }
-
-  void HandleDouble(double value) override {
-    if (!status_->ok())
-      return;
-    EncodeDouble(value, out_);
-  }
-
-  void HandleInt32(int32_t value) override {
-    if (!status_->ok())
-      return;
-    EncodeInt32(value, out_);
-  }
-
-  void HandleBool(bool value) override {
-    if (!status_->ok())
-      return;
-    // See RFC 7049 Section 2.3, Table 2.
-    out_->push_back(value ? kEncodedTrue : kEncodedFalse);
-  }
-
-  void HandleNull() override {
-    if (!status_->ok())
-      return;
-    // See RFC 7049 Section 2.3, Table 2.
-    out_->push_back(kEncodedNull);
-  }
-
-  void HandleError(Status error) override {
-    if (!status_->ok())
-      return;
-    *status_ = error;
-    out_->clear();
-  }
-
- private:
-  C* out_;
-  std::vector<EnvelopeEncoder> envelopes_;
-  Status* status_;
-};
-}  // namespace
-
-std::unique_ptr<StreamingParserHandler> NewCBOREncoder(
-    std::vector<uint8_t>* out,
-    Status* status) {
-  return std::unique_ptr<StreamingParserHandler>(
-      new CBOREncoder<std::vector<uint8_t>>(out, status));
-}
-std::unique_ptr<StreamingParserHandler> NewCBOREncoder(std::string* out,
-                                                       Status* status) {
-  return std::unique_ptr<StreamingParserHandler>(
-      new CBOREncoder<std::string>(out, status));
-}
-
-// =============================================================================
-// cbor::CBORTokenizer - for parsing individual CBOR items
-// =============================================================================
-
-CBORTokenizer::CBORTokenizer(span<uint8_t> bytes) : bytes_(bytes) {
-  ReadNextToken(/*enter_envelope=*/false);
-}
-CBORTokenizer::~CBORTokenizer() {}
-
-CBORTokenTag CBORTokenizer::TokenTag() const {
-  return token_tag_;
-}
-
-void CBORTokenizer::Next() {
-  if (token_tag_ == CBORTokenTag::ERROR_VALUE ||
-      token_tag_ == CBORTokenTag::DONE)
-    return;
-  ReadNextToken(/*enter_envelope=*/false);
-}
-
-void CBORTokenizer::EnterEnvelope() {
-  assert(token_tag_ == CBORTokenTag::ENVELOPE);
-  ReadNextToken(/*enter_envelope=*/true);
-}
-
-Status CBORTokenizer::Status() const {
-  return status_;
-}
-
-// The following accessor functions ::GetInt32, ::GetDouble,
-// ::GetString8, ::GetString16WireRep, ::GetBinary, ::GetEnvelopeContents
-// assume that a particular token was recognized in ::ReadNextToken.
-// That's where all the error checking is done. By design,
-// the accessors (assuming the token was recognized) never produce
-// an error.
-
-int32_t CBORTokenizer::GetInt32() const {
-  assert(token_tag_ == CBORTokenTag::INT32);
-  // The range checks happen in ::ReadNextToken().
-  return static_cast<int32_t>(
-      token_start_type_ == MajorType::UNSIGNED
-          ? token_start_internal_value_
-          : -static_cast<int64_t>(token_start_internal_value_) - 1);
-}
-
-double CBORTokenizer::GetDouble() const {
-  assert(token_tag_ == CBORTokenTag::DOUBLE);
-  union {
-    uint64_t from_uint64;
-    double to_double;
-  } reinterpret;
-  reinterpret.from_uint64 = ReadBytesMostSignificantByteFirst<uint64_t>(
-      bytes_.subspan(status_.pos + 1));
-  return reinterpret.to_double;
-}
-
-span<uint8_t> CBORTokenizer::GetString8() const {
-  assert(token_tag_ == CBORTokenTag::STRING8);
-  auto length = static_cast<size_t>(token_start_internal_value_);
-  return bytes_.subspan(status_.pos + (token_byte_length_ - length), length);
-}
-
-span<uint8_t> CBORTokenizer::GetString16WireRep() const {
-  assert(token_tag_ == CBORTokenTag::STRING16);
-  auto length = static_cast<size_t>(token_start_internal_value_);
-  return bytes_.subspan(status_.pos + (token_byte_length_ - length), length);
-}
-
-span<uint8_t> CBORTokenizer::GetBinary() const {
-  assert(token_tag_ == CBORTokenTag::BINARY);
-  auto length = static_cast<size_t>(token_start_internal_value_);
-  return bytes_.subspan(status_.pos + (token_byte_length_ - length), length);
-}
-
-span<uint8_t> CBORTokenizer::GetEnvelopeContents() const {
-  assert(token_tag_ == CBORTokenTag::ENVELOPE);
-  auto length = static_cast<size_t>(token_start_internal_value_);
-  return bytes_.subspan(status_.pos + kEncodedEnvelopeHeaderSize, length);
-}
-
-// All error checking happens in ::ReadNextToken, so that the accessors
-// can avoid having to carry an error return value.
-//
-// With respect to checking the encoded lengths of strings, arrays, etc:
-// On the wire, CBOR uses 1,2,4, and 8 byte unsigned integers, so
-// we initially read them as uint64_t, usually into token_start_internal_value_.
-//
-// However, since these containers have a representation on the machine,
-// we need to do corresponding size computations on the input byte array,
-// output span (e.g. the payload for a string), etc., and size_t is
-// machine specific (in practice either 32 bit or 64 bit).
-//
-// Further, we must avoid overflowing size_t. Therefore, we use this
-// kMaxValidLength constant to:
-// - Reject values that are larger than the architecture specific
-//   max size_t (differs between 32 bit and 64 bit arch).
-// - Reserve at least one bit so that we can check against overflows
-//   when adding lengths (array / string length / etc.); we do this by
-//   ensuring that the inputs to an addition are <= kMaxValidLength,
-//   and then checking whether the sum went past it.
-//
-// See also
-// https://chromium.googlesource.com/chromium/src/+/master/docs/security/integer-semantics.md
-static const uint64_t kMaxValidLength =
-    std::min<uint64_t>(std::numeric_limits<uint64_t>::max() >> 2,
-                       std::numeric_limits<size_t>::max());
-
-void CBORTokenizer::ReadNextToken(bool enter_envelope) {
-  if (enter_envelope) {
-    status_.pos += kEncodedEnvelopeHeaderSize;
-  } else {
-    status_.pos =
-        status_.pos == Status::npos() ? 0 : status_.pos + token_byte_length_;
-  }
-  status_.error = Error::OK;
-  if (status_.pos >= bytes_.size()) {
-    token_tag_ = CBORTokenTag::DONE;
-    return;
-  }
-  const size_t remaining_bytes = bytes_.size() - status_.pos;
-  switch (bytes_[status_.pos]) {
-    case kStopByte:
-      SetToken(CBORTokenTag::STOP, 1);
-      return;
-    case kInitialByteIndefiniteLengthMap:
-      SetToken(CBORTokenTag::MAP_START, 1);
-      return;
-    case kInitialByteIndefiniteLengthArray:
-      SetToken(CBORTokenTag::ARRAY_START, 1);
-      return;
-    case kEncodedTrue:
-      SetToken(CBORTokenTag::TRUE_VALUE, 1);
-      return;
-    case kEncodedFalse:
-      SetToken(CBORTokenTag::FALSE_VALUE, 1);
-      return;
-    case kEncodedNull:
-      SetToken(CBORTokenTag::NULL_VALUE, 1);
-      return;
-    case kExpectedConversionToBase64Tag: {  // BINARY
-      const size_t bytes_read = internals::ReadTokenStart(
-          bytes_.subspan(status_.pos + 1), &token_start_type_,
-          &token_start_internal_value_);
-      if (!bytes_read || token_start_type_ != MajorType::BYTE_STRING ||
-          token_start_internal_value_ > kMaxValidLength) {
-        SetError(Error::CBOR_INVALID_BINARY);
-        return;
-      }
-      const uint64_t token_byte_length = token_start_internal_value_ +
-                                         /* tag before token start: */ 1 +
-                                         /* token start: */ bytes_read;
-      if (token_byte_length > remaining_bytes) {
-        SetError(Error::CBOR_INVALID_BINARY);
-        return;
-      }
-      SetToken(CBORTokenTag::BINARY, static_cast<size_t>(token_byte_length));
-      return;
-    }
-    case kInitialByteForDouble: {  // DOUBLE
-      if (kEncodedDoubleSize > remaining_bytes) {
-        SetError(Error::CBOR_INVALID_DOUBLE);
-        return;
-      }
-      SetToken(CBORTokenTag::DOUBLE, kEncodedDoubleSize);
-      return;
-    }
-    case kInitialByteForEnvelope: {  // ENVELOPE
-      if (kEncodedEnvelopeHeaderSize > remaining_bytes) {
-        SetError(Error::CBOR_INVALID_ENVELOPE);
-        return;
-      }
-      // The envelope must be a byte string with 32 bit length.
-      if (bytes_[status_.pos + 1] != kInitialByteFor32BitLengthByteString) {
-        SetError(Error::CBOR_INVALID_ENVELOPE);
-        return;
-      }
-      // Read the length of the byte string.
-      token_start_internal_value_ = ReadBytesMostSignificantByteFirst<uint32_t>(
-          bytes_.subspan(status_.pos + 2));
-      if (token_start_internal_value_ > kMaxValidLength) {
-        SetError(Error::CBOR_INVALID_ENVELOPE);
-        return;
-      }
-      uint64_t token_byte_length =
-          token_start_internal_value_ + kEncodedEnvelopeHeaderSize;
-      if (token_byte_length > remaining_bytes) {
-        SetError(Error::CBOR_INVALID_ENVELOPE);
-        return;
-      }
-      SetToken(CBORTokenTag::ENVELOPE, static_cast<size_t>(token_byte_length));
-      return;
-    }
-    default: {
-      const size_t bytes_read = internals::ReadTokenStart(
-          bytes_.subspan(status_.pos), &token_start_type_,
-          &token_start_internal_value_);
-      switch (token_start_type_) {
-        case MajorType::UNSIGNED:  // INT32.
-          // INT32 is a signed int32 (int32 makes sense for the
-          // inspector_protocol, it's not a CBOR limitation), so we check
-          // against the signed max, so that the allowable values are
-          // 0, 1, 2, ... 2^31 - 1.
-          if (!bytes_read ||
-                static_cast<int64_t>(std::numeric_limits<int32_t>::max()) <
-                  static_cast<int64_t>(token_start_internal_value_)) {
-            SetError(Error::CBOR_INVALID_INT32);
-            return;
-          }
-          SetToken(CBORTokenTag::INT32, bytes_read);
-          return;
-        case MajorType::NEGATIVE: {  // INT32.
-          // INT32 is a signed int32 (int32 makes sense for the
-          // inspector_protocol, it's not a CBOR limitation); in CBOR, the
-          // negative values for INT32 are represented as NEGATIVE, that is, -1
-          // INT32 is represented as 1 << 5 | 0 (major type 1, additional info
-          // value 0).
-          // The represented allowed values range is -1 to -2^31.
-          // They are mapped into the encoded range of 0 to 2^31-1.
-          // We check the payload in token_start_internal_value_ against
-          // that range (2^31-1 is also known as
-          // std::numeric_limits<int32_t>::max()).
-          if (!bytes_read ||
-	      static_cast<int64_t>(token_start_internal_value_) >
-                static_cast<int64_t>(std::numeric_limits<int32_t>::max())) {
-            SetError(Error::CBOR_INVALID_INT32);
-            return;
-          }
-          SetToken(CBORTokenTag::INT32, bytes_read);
-          return;
-        }
-        case MajorType::STRING: {  // STRING8.
-          if (!bytes_read || token_start_internal_value_ > kMaxValidLength) {
-            SetError(Error::CBOR_INVALID_STRING8);
-            return;
-          }
-          uint64_t token_byte_length = token_start_internal_value_ + bytes_read;
-          if (token_byte_length > remaining_bytes) {
-            SetError(Error::CBOR_INVALID_STRING8);
-            return;
-          }
-          SetToken(CBORTokenTag::STRING8,
-                   static_cast<size_t>(token_byte_length));
-          return;
-        }
-        case MajorType::BYTE_STRING: {  // STRING16.
-          // Length must be divisible by 2 since UTF16 is 2 bytes per
-          // character, hence the &1 check.
-          if (!bytes_read || token_start_internal_value_ > kMaxValidLength ||
-              token_start_internal_value_ & 1) {
-            SetError(Error::CBOR_INVALID_STRING16);
-            return;
-          }
-          uint64_t token_byte_length = token_start_internal_value_ + bytes_read;
-          if (token_byte_length > remaining_bytes) {
-            SetError(Error::CBOR_INVALID_STRING16);
-            return;
-          }
-          SetToken(CBORTokenTag::STRING16,
-                   static_cast<size_t>(token_byte_length));
-          return;
-        }
-        case MajorType::ARRAY:
-        case MajorType::MAP:
-        case MajorType::TAG:
-        case MajorType::SIMPLE_VALUE:
-          SetError(Error::CBOR_UNSUPPORTED_VALUE);
-          return;
-      }
-    }
-  }
-}
-
-void CBORTokenizer::SetToken(CBORTokenTag token_tag, size_t token_byte_length) {
-  token_tag_ = token_tag;
-  token_byte_length_ = token_byte_length;
-}
-
-void CBORTokenizer::SetError(Error error) {
-  token_tag_ = CBORTokenTag::ERROR_VALUE;
-  status_.error = error;
-}
-
-// =============================================================================
-// cbor::ParseCBOR - for receiving streaming parser events for CBOR messages
-// =============================================================================
-
-namespace {
-// When parsing CBOR, we limit recursion depth for objects and arrays
-// to this constant.
-static constexpr int kStackLimit = 300;
-
-// Below are three parsing routines for CBOR, which cover enough
-// to roundtrip JSON messages.
-bool ParseMap(int32_t stack_depth,
-              CBORTokenizer* tokenizer,
-              StreamingParserHandler* out);
-bool ParseArray(int32_t stack_depth,
-                CBORTokenizer* tokenizer,
-                StreamingParserHandler* out);
-bool ParseValue(int32_t stack_depth,
-                CBORTokenizer* tokenizer,
-                StreamingParserHandler* out);
-
-void ParseUTF16String(CBORTokenizer* tokenizer, StreamingParserHandler* out) {
-  std::vector<uint16_t> value;
-  span<uint8_t> rep = tokenizer->GetString16WireRep();
-  for (size_t ii = 0; ii < rep.size(); ii += 2)
-    value.push_back((rep[ii + 1] << 8) | rep[ii]);
-  out->HandleString16(span<uint16_t>(value.data(), value.size()));
-  tokenizer->Next();
-}
-
-bool ParseUTF8String(CBORTokenizer* tokenizer, StreamingParserHandler* out) {
-  assert(tokenizer->TokenTag() == CBORTokenTag::STRING8);
-  out->HandleString8(tokenizer->GetString8());
-  tokenizer->Next();
-  return true;
-}
-
-bool ParseValue(int32_t stack_depth,
-                CBORTokenizer* tokenizer,
-                StreamingParserHandler* out) {
-  if (stack_depth > kStackLimit) {
-    out->HandleError(
-        Status{Error::CBOR_STACK_LIMIT_EXCEEDED, tokenizer->Status().pos});
-    return false;
-  }
-  // Skip past the envelope to get to what's inside.
-  if (tokenizer->TokenTag() == CBORTokenTag::ENVELOPE)
-    tokenizer->EnterEnvelope();
-  switch (tokenizer->TokenTag()) {
-    case CBORTokenTag::ERROR_VALUE:
-      out->HandleError(tokenizer->Status());
-      return false;
-    case CBORTokenTag::DONE:
-      out->HandleError(Status{Error::CBOR_UNEXPECTED_EOF_EXPECTED_VALUE,
-                              tokenizer->Status().pos});
-      return false;
-    case CBORTokenTag::TRUE_VALUE:
-      out->HandleBool(true);
-      tokenizer->Next();
-      return true;
-    case CBORTokenTag::FALSE_VALUE:
-      out->HandleBool(false);
-      tokenizer->Next();
-      return true;
-    case CBORTokenTag::NULL_VALUE:
-      out->HandleNull();
-      tokenizer->Next();
-      return true;
-    case CBORTokenTag::INT32:
-      out->HandleInt32(tokenizer->GetInt32());
-      tokenizer->Next();
-      return true;
-    case CBORTokenTag::DOUBLE:
-      out->HandleDouble(tokenizer->GetDouble());
-      tokenizer->Next();
-      return true;
-    case CBORTokenTag::STRING8:
-      return ParseUTF8String(tokenizer, out);
-    case CBORTokenTag::STRING16:
-      ParseUTF16String(tokenizer, out);
-      return true;
-    case CBORTokenTag::BINARY: {
-      out->HandleBinary(tokenizer->GetBinary());
-      tokenizer->Next();
-      return true;
-    }
-    case CBORTokenTag::MAP_START:
-      return ParseMap(stack_depth + 1, tokenizer, out);
-    case CBORTokenTag::ARRAY_START:
-      return ParseArray(stack_depth + 1, tokenizer, out);
-    default:
-      out->HandleError(
-          Status{Error::CBOR_UNSUPPORTED_VALUE, tokenizer->Status().pos});
-      return false;
-  }
-}
-
-// |bytes| must start with the indefinite length array byte, so basically,
-// ParseArray may only be called after an indefinite length array has been
-// detected.
-bool ParseArray(int32_t stack_depth,
-                CBORTokenizer* tokenizer,
-                StreamingParserHandler* out) {
-  assert(tokenizer->TokenTag() == CBORTokenTag::ARRAY_START);
-  tokenizer->Next();
-  out->HandleArrayBegin();
-  while (tokenizer->TokenTag() != CBORTokenTag::STOP) {
-    if (tokenizer->TokenTag() == CBORTokenTag::DONE) {
-      out->HandleError(
-          Status{Error::CBOR_UNEXPECTED_EOF_IN_ARRAY, tokenizer->Status().pos});
-      return false;
-    }
-    if (tokenizer->TokenTag() == CBORTokenTag::ERROR_VALUE) {
-      out->HandleError(tokenizer->Status());
-      return false;
-    }
-    // Parse value.
-    if (!ParseValue(stack_depth, tokenizer, out))
-      return false;
-  }
-  out->HandleArrayEnd();
-  tokenizer->Next();
-  return true;
-}
-
-// |bytes| must start with the indefinite length array byte, so basically,
-// ParseArray may only be called after an indefinite length array has been
-// detected.
-bool ParseMap(int32_t stack_depth,
-              CBORTokenizer* tokenizer,
-              StreamingParserHandler* out) {
-  assert(tokenizer->TokenTag() == CBORTokenTag::MAP_START);
-  out->HandleMapBegin();
-  tokenizer->Next();
-  while (tokenizer->TokenTag() != CBORTokenTag::STOP) {
-    if (tokenizer->TokenTag() == CBORTokenTag::DONE) {
-      out->HandleError(
-          Status{Error::CBOR_UNEXPECTED_EOF_IN_MAP, tokenizer->Status().pos});
-      return false;
-    }
-    if (tokenizer->TokenTag() == CBORTokenTag::ERROR_VALUE) {
-      out->HandleError(tokenizer->Status());
-      return false;
-    }
-    // Parse key.
-    if (tokenizer->TokenTag() == CBORTokenTag::STRING8) {
-      if (!ParseUTF8String(tokenizer, out))
-        return false;
-    } else if (tokenizer->TokenTag() == CBORTokenTag::STRING16) {
-      ParseUTF16String(tokenizer, out);
-    } else {
-      out->HandleError(
-          Status{Error::CBOR_INVALID_MAP_KEY, tokenizer->Status().pos});
-      return false;
-    }
-    // Parse value.
-    if (!ParseValue(stack_depth, tokenizer, out))
-      return false;
-  }
-  out->HandleMapEnd();
-  tokenizer->Next();
-  return true;
-}
-}  // namespace
-
-void ParseCBOR(span<uint8_t> bytes, StreamingParserHandler* out) {
-  if (bytes.empty()) {
-    out->HandleError(Status{Error::CBOR_NO_INPUT, 0});
-    return;
-  }
-  if (bytes[0] != kInitialByteForEnvelope) {
-    out->HandleError(Status{Error::CBOR_INVALID_START_BYTE, 0});
-    return;
-  }
-  CBORTokenizer tokenizer(bytes);
-  if (tokenizer.TokenTag() == CBORTokenTag::ERROR_VALUE) {
-    out->HandleError(tokenizer.Status());
-    return;
-  }
-  // We checked for the envelope start byte above, so the tokenizer
-  // must agree here, since it's not an error.
-  assert(tokenizer.TokenTag() == CBORTokenTag::ENVELOPE);
-  tokenizer.EnterEnvelope();
-  if (tokenizer.TokenTag() != CBORTokenTag::MAP_START) {
-    out->HandleError(
-        Status{Error::CBOR_MAP_START_EXPECTED, tokenizer.Status().pos});
-    return;
-  }
-  if (!ParseMap(/*stack_depth=*/1, &tokenizer, out))
-    return;
-  if (tokenizer.TokenTag() == CBORTokenTag::DONE)
-    return;
-  if (tokenizer.TokenTag() == CBORTokenTag::ERROR_VALUE) {
-    out->HandleError(tokenizer.Status());
-    return;
-  }
-  out->HandleError(Status{Error::CBOR_TRAILING_JUNK, tokenizer.Status().pos});
-}
-
-// =============================================================================
-// cbor::AppendString8EntryToMap - for limited in-place editing of messages
-// =============================================================================
-
-template <typename C>
-Status AppendString8EntryToCBORMapTmpl(span<uint8_t> string8_key,
-                                       span<uint8_t> string8_value,
-                                       C* cbor) {
-  // Careful below: Don't compare (*cbor)[idx] with a uint8_t, since
-  // it could be a char (signed!). Instead, use bytes.
-  span<uint8_t> bytes(reinterpret_cast<const uint8_t*>(cbor->data()),
-                      cbor->size());
-  CBORTokenizer tokenizer(bytes);
-  if (tokenizer.TokenTag() == CBORTokenTag::ERROR_VALUE)
-    return tokenizer.Status();
-  if (tokenizer.TokenTag() != CBORTokenTag::ENVELOPE)
-    return Status(Error::CBOR_INVALID_ENVELOPE, 0);
-  size_t envelope_size = tokenizer.GetEnvelopeContents().size();
-  size_t old_size = cbor->size();
-  if (old_size != envelope_size + kEncodedEnvelopeHeaderSize)
-    return Status(Error::CBOR_INVALID_ENVELOPE, 0);
-  if (envelope_size == 0 ||
-      (tokenizer.GetEnvelopeContents()[0] != EncodeIndefiniteLengthMapStart()))
-    return Status(Error::CBOR_MAP_START_EXPECTED, kEncodedEnvelopeHeaderSize);
-  if (bytes[bytes.size() - 1] != EncodeStop())
-    return Status(Error::CBOR_MAP_STOP_EXPECTED, cbor->size() - 1);
-  cbor->pop_back();
-  EncodeString8(string8_key, cbor);
-  EncodeString8(string8_value, cbor);
-  cbor->push_back(EncodeStop());
-  size_t new_envelope_size = envelope_size + (cbor->size() - old_size);
-  if (new_envelope_size > std::numeric_limits<uint32_t>::max())
-    return Status(Error::CBOR_ENVELOPE_SIZE_LIMIT_EXCEEDED, 0);
-  size_t size_pos = cbor->size() - new_envelope_size - sizeof(uint32_t);
-  uint8_t* out = reinterpret_cast<uint8_t*>(&cbor->at(size_pos));
-  *(out++) = (new_envelope_size >> 24) & 0xff;
-  *(out++) = (new_envelope_size >> 16) & 0xff;
-  *(out++) = (new_envelope_size >> 8) & 0xff;
-  *(out) = new_envelope_size & 0xff;
-  return Status();
-}
-Status AppendString8EntryToCBORMap(span<uint8_t> string8_key,
-                                   span<uint8_t> string8_value,
-                                   std::vector<uint8_t>* cbor) {
-  return AppendString8EntryToCBORMapTmpl(string8_key, string8_value, cbor);
-}
-Status AppendString8EntryToCBORMap(span<uint8_t> string8_key,
-                                   span<uint8_t> string8_value,
-                                   std::string* cbor) {
-  return AppendString8EntryToCBORMapTmpl(string8_key, string8_value, cbor);
-}
-}  // namespace cbor
-
-namespace json {
-
-// =============================================================================
-// json::NewJSONEncoder - for encoding streaming parser events as JSON
-// =============================================================================
-
-namespace {
-// Prints |value| to |out| with 4 hex digits, most significant chunk first.
-template <typename C>
-void PrintHex(uint16_t value, C* out) {
-  for (int ii = 3; ii >= 0; --ii) {
-    int four_bits = 0xf & (value >> (4 * ii));
-    out->push_back(four_bits + ((four_bits <= 9) ? '0' : ('a' - 10)));
-  }
-}
-
-// In the writer below, we maintain a stack of State instances.
-// It is just enough to emit the appropriate delimiters and brackets
-// in JSON.
-enum class Container {
-  // Used for the top-level, initial state.
-  NONE,
-  // Inside a JSON object.
-  MAP,
-  // Inside a JSON array.
-  ARRAY
-};
-class State {
- public:
-  explicit State(Container container) : container_(container) {}
-  void StartElement(std::vector<uint8_t>* out) { StartElementTmpl(out); }
-  void StartElement(std::string* out) { StartElementTmpl(out); }
-  Container container() const { return container_; }
-
- private:
-  template <typename C>
-  void StartElementTmpl(C* out) {
-    assert(container_ != Container::NONE || size_ == 0);
-    if (size_ != 0) {
-      char delim = (!(size_ & 1) || container_ == Container::ARRAY) ? ',' : ':';
-      out->push_back(delim);
-    }
-    ++size_;
-  }
-
-  Container container_ = Container::NONE;
-  int size_ = 0;
-};
-
-constexpr char kBase64Table[] =
-    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-    "abcdefghijklmnopqrstuvwxyz0123456789+/";
-
-template <typename C>
-void Base64Encode(const span<uint8_t>& in, C* out) {
-  // The following three cases are based on the tables in the example
-  // section in https://en.wikipedia.org/wiki/Base64. We process three
-  // input bytes at a time, emitting 4 output bytes at a time.
-  size_t ii = 0;
-
-  // While possible, process three input bytes.
-  for (; ii + 3 <= in.size(); ii += 3) {
-    uint32_t twentyfour_bits = (in[ii] << 16) | (in[ii + 1] << 8) | in[ii + 2];
-    out->push_back(kBase64Table[(twentyfour_bits >> 18)]);
-    out->push_back(kBase64Table[(twentyfour_bits >> 12) & 0x3f]);
-    out->push_back(kBase64Table[(twentyfour_bits >> 6) & 0x3f]);
-    out->push_back(kBase64Table[twentyfour_bits & 0x3f]);
-  }
-  if (ii + 2 <= in.size()) {  // Process two input bytes.
-    uint32_t twentyfour_bits = (in[ii] << 16) | (in[ii + 1] << 8);
-    out->push_back(kBase64Table[(twentyfour_bits >> 18)]);
-    out->push_back(kBase64Table[(twentyfour_bits >> 12) & 0x3f]);
-    out->push_back(kBase64Table[(twentyfour_bits >> 6) & 0x3f]);
-    out->push_back('=');  // Emit padding.
-    return;
-  }
-  if (ii + 1 <= in.size()) {  // Process a single input byte.
-    uint32_t twentyfour_bits = (in[ii] << 16);
-    out->push_back(kBase64Table[(twentyfour_bits >> 18)]);
-    out->push_back(kBase64Table[(twentyfour_bits >> 12) & 0x3f]);
-    out->push_back('=');  // Emit padding.
-    out->push_back('=');  // Emit padding.
-  }
-}
-
-// Implements a handler for JSON parser events to emit a JSON string.
-template <typename C>
-class JSONEncoder : public StreamingParserHandler {
- public:
-  JSONEncoder(const Platform* platform, C* out, Status* status)
-      : platform_(platform), out_(out), status_(status) {
-    *status_ = Status();
-    state_.emplace(Container::NONE);
-  }
-
-  void HandleMapBegin() override {
-    if (!status_->ok())
-      return;
-    assert(!state_.empty());
-    state_.top().StartElement(out_);
-    state_.emplace(Container::MAP);
-    Emit('{');
-  }
-
-  void HandleMapEnd() override {
-    if (!status_->ok())
-      return;
-    assert(state_.size() >= 2 && state_.top().container() == Container::MAP);
-    state_.pop();
-    Emit('}');
-  }
-
-  void HandleArrayBegin() override {
-    if (!status_->ok())
-      return;
-    state_.top().StartElement(out_);
-    state_.emplace(Container::ARRAY);
-    Emit('[');
-  }
-
-  void HandleArrayEnd() override {
-    if (!status_->ok())
-      return;
-    assert(state_.size() >= 2 && state_.top().container() == Container::ARRAY);
-    state_.pop();
-    Emit(']');
-  }
-
-  void HandleString16(span<uint16_t> chars) override {
-    if (!status_->ok())
-      return;
-    state_.top().StartElement(out_);
-    Emit('"');
-    for (const uint16_t ch : chars) {
-      if (ch == '"') {
-        Emit("\\\"");
-      } else if (ch == '\\') {
-        Emit("\\\\");
-      } else if (ch == '\b') {
-        Emit("\\b");
-      } else if (ch == '\f') {
-        Emit("\\f");
-      } else if (ch == '\n') {
-        Emit("\\n");
-      } else if (ch == '\r') {
-        Emit("\\r");
-      } else if (ch == '\t') {
-        Emit("\\t");
-      } else if (ch >= 32 && ch <= 126) {
-        Emit(ch);
-      } else {
-        Emit("\\u");
-        PrintHex(ch, out_);
-      }
-    }
-    Emit('"');
-  }
-
-  void HandleString8(span<uint8_t> chars) override {
-    if (!status_->ok())
-      return;
-    state_.top().StartElement(out_);
-    Emit('"');
-    for (size_t ii = 0; ii < chars.size(); ++ii) {
-      uint8_t c = chars[ii];
-      if (c == '"') {
-        Emit("\\\"");
-      } else if (c == '\\') {
-        Emit("\\\\");
-      } else if (c == '\b') {
-        Emit("\\b");
-      } else if (c == '\f') {
-        Emit("\\f");
-      } else if (c == '\n') {
-        Emit("\\n");
-      } else if (c == '\r') {
-        Emit("\\r");
-      } else if (c == '\t') {
-        Emit("\\t");
-      } else if (c >= 32 && c <= 126) {
-        Emit(c);
-      } else if (c < 32) {
-        Emit("\\u");
-        PrintHex(static_cast<uint16_t>(c), out_);
-      } else {
-        // Inspect the leading byte to figure out how long the utf8
-        // byte sequence is; while doing this initialize |codepoint|
-        // with the first few bits.
-        // See table in: https://en.wikipedia.org/wiki/UTF-8
-        // byte one is 110x xxxx -> 2 byte utf8 sequence
-        // byte one is 1110 xxxx -> 3 byte utf8 sequence
-        // byte one is 1111 0xxx -> 4 byte utf8 sequence
-        uint32_t codepoint;
-        int num_bytes_left;
-        if ((c & 0xe0) == 0xc0) {  // 2 byte utf8 sequence
-          num_bytes_left = 1;
-          codepoint = c & 0x1f;
-        } else if ((c & 0xf0) == 0xe0) {  // 3 byte utf8 sequence
-          num_bytes_left = 2;
-          codepoint = c & 0x0f;
-        } else if ((c & 0xf8) == 0xf0) {  // 4 byte utf8 sequence
-          codepoint = c & 0x07;
-          num_bytes_left = 3;
-        } else {
-          continue;  // invalid leading byte
-        }
-
-        // If we have enough bytes in our input, decode the remaining ones
-        // belonging to this Unicode character into |codepoint|.
-        if (ii + num_bytes_left > chars.size())
-          continue;
-        while (num_bytes_left > 0) {
-          c = chars[++ii];
-          --num_bytes_left;
-          // Check the next byte is a continuation byte, that is 10xx xxxx.
-          if ((c & 0xc0) != 0x80)
-            continue;
-          codepoint = (codepoint << 6) | (c & 0x3f);
-        }
-
-        // Disallow overlong encodings for ascii characters, as these
-        // would include " and other characters significant to JSON
-        // string termination / control.
-        if (codepoint <= 0x7f)
-          continue;
-        // Invalid in UTF8, and can't be represented in UTF16 anyway.
-        if (codepoint > 0x10ffff)
-          continue;
-
-        // So, now we transcode to UTF16,
-        // using the math described at https://en.wikipedia.org/wiki/UTF-16,
-        // for either one or two 16 bit characters.
-        if (codepoint < 0xffff) {
-          Emit("\\u");
-          PrintHex(static_cast<uint16_t>(codepoint), out_);
-          continue;
-        }
-        codepoint -= 0x10000;
-        // high surrogate
-        Emit("\\u");
-        PrintHex(static_cast<uint16_t>((codepoint >> 10) + 0xd800), out_);
-        // low surrogate
-        Emit("\\u");
-        PrintHex(static_cast<uint16_t>((codepoint & 0x3ff) + 0xdc00), out_);
-      }
-    }
-    Emit('"');
-  }
-
-  void HandleBinary(span<uint8_t> bytes) override {
-    if (!status_->ok())
-      return;
-    state_.top().StartElement(out_);
-    Emit('"');
-    Base64Encode(bytes, out_);
-    Emit('"');
-  }
-
-  void HandleDouble(double value) override {
-    if (!status_->ok())
-      return;
-    state_.top().StartElement(out_);
-    // JSON cannot represent NaN or Infinity. So, for compatibility,
-    // we behave like the JSON object in web browsers: emit 'null'.
-    if (!std::isfinite(value)) {
-      Emit("null");
-      return;
-    }
-    std::unique_ptr<char[]> str_value = platform_->DToStr(value);
-
-    // DToStr may fail to emit a 0 before the decimal dot. E.g. this is
-    // the case in base::NumberToString in Chromium (which is based on
-    // dmg_fp). So, much like
-    // https://cs.chromium.org/chromium/src/base/json/json_writer.cc
-    // we probe for this and emit the leading 0 anyway if necessary.
-    const char* chars = str_value.get();
-    if (chars[0] == '.') {
-      Emit('0');
-    } else if (chars[0] == '-' && chars[1] == '.') {
-      Emit("-0");
-      ++chars;
-    }
-    Emit(chars);
-  }
-
-  void HandleInt32(int32_t value) override {
-    if (!status_->ok())
-      return;
-    state_.top().StartElement(out_);
-    Emit(std::to_string(value));
-  }
-
-  void HandleBool(bool value) override {
-    if (!status_->ok())
-      return;
-    state_.top().StartElement(out_);
-    Emit(value ? "true" : "false");
-  }
-
-  void HandleNull() override {
-    if (!status_->ok())
-      return;
-    state_.top().StartElement(out_);
-    Emit("null");
-  }
-
-  void HandleError(Status error) override {
-    assert(!error.ok());
-    *status_ = error;
-    out_->clear();
-  }
-
- private:
-  void Emit(char c) { out_->push_back(c); }
-  void Emit(const char* str) {
-    out_->insert(out_->end(), str, str + strlen(str));
-  }
-  void Emit(const std::string& str) {
-    out_->insert(out_->end(), str.begin(), str.end());
-  }
-
-  const Platform* platform_;
-  C* out_;
-  Status* status_;
-  std::stack<State> state_;
-};
-}  // namespace
-
-std::unique_ptr<StreamingParserHandler> NewJSONEncoder(
-    const Platform* platform,
-    std::vector<uint8_t>* out,
-    Status* status) {
-  return std::unique_ptr<StreamingParserHandler>(
-      new JSONEncoder<std::vector<uint8_t>>(platform, out, status));
-}
-std::unique_ptr<StreamingParserHandler> NewJSONEncoder(const Platform* platform,
-                                                       std::string* out,
-                                                       Status* status) {
-  return std::unique_ptr<StreamingParserHandler>(
-      new JSONEncoder<std::string>(platform, out, status));
-}
-
-// =============================================================================
-// json::ParseJSON - for receiving streaming parser events for JSON.
-// =============================================================================
-
-namespace {
-const int kStackLimit = 300;
-
-enum Token {
-  ObjectBegin,
-  ObjectEnd,
-  ArrayBegin,
-  ArrayEnd,
-  StringLiteral,
-  Number,
-  BoolTrue,
-  BoolFalse,
-  NullToken,
-  ListSeparator,
-  ObjectPairSeparator,
-  InvalidToken,
-  NoInput
-};
-
-const char* const kNullString = "null";
-const char* const kTrueString = "true";
-const char* const kFalseString = "false";
-
-template <typename Char>
-class JsonParser {
- public:
-  JsonParser(const Platform* platform, StreamingParserHandler* handler)
-      : platform_(platform), handler_(handler) {}
-
-  void Parse(const Char* start, size_t length) {
-    start_pos_ = start;
-    const Char* end = start + length;
-    const Char* tokenEnd = nullptr;
-    ParseValue(start, end, &tokenEnd, 0);
-    if (error_)
-      return;
-    if (tokenEnd != end) {
-      HandleError(Error::JSON_PARSER_UNPROCESSED_INPUT_REMAINS, tokenEnd);
-    }
-  }
-
- private:
-  bool CharsToDouble(const uint16_t* chars, size_t length, double* result) {
-    std::string buffer;
-    buffer.reserve(length + 1);
-    for (size_t ii = 0; ii < length; ++ii) {
-      bool is_ascii = !(chars[ii] & ~0x7F);
-      if (!is_ascii)
-        return false;
-      buffer.push_back(static_cast<char>(chars[ii]));
-    }
-    return platform_->StrToD(buffer.c_str(), result);
-  }
-
-  bool CharsToDouble(const uint8_t* chars, size_t length, double* result) {
-    std::string buffer(reinterpret_cast<const char*>(chars), length);
-    return platform_->StrToD(buffer.c_str(), result);
-  }
-
-  static bool ParseConstToken(const Char* start,
-                              const Char* end,
-                              const Char** token_end,
-                              const char* token) {
-    // |token| is \0 terminated, it's one of the constants at top of the file.
-    while (start < end && *token != '\0' && *start++ == *token++) {
-    }
-    if (*token != '\0')
-      return false;
-    *token_end = start;
-    return true;
-  }
-
-  static bool ReadInt(const Char* start,
-                      const Char* end,
-                      const Char** token_end,
-                      bool allow_leading_zeros) {
-    if (start == end)
-      return false;
-    bool has_leading_zero = '0' == *start;
-    int length = 0;
-    while (start < end && '0' <= *start && *start <= '9') {
-      ++start;
-      ++length;
-    }
-    if (!length)
-      return false;
-    if (!allow_leading_zeros && length > 1 && has_leading_zero)
-      return false;
-    *token_end = start;
-    return true;
-  }
-
-  static bool ParseNumberToken(const Char* start,
-                               const Char* end,
-                               const Char** token_end) {
-    // We just grab the number here. We validate the size in DecodeNumber.
-    // According to RFC4627, a valid number is: [minus] int [frac] [exp]
-    if (start == end)
-      return false;
-    Char c = *start;
-    if ('-' == c)
-      ++start;
-
-    if (!ReadInt(start, end, &start, /*allow_leading_zeros=*/false))
-      return false;
-    if (start == end) {
-      *token_end = start;
-      return true;
-    }
-
-    // Optional fraction part
-    c = *start;
-    if ('.' == c) {
-      ++start;
-      if (!ReadInt(start, end, &start, /*allow_leading_zeros=*/true))
-        return false;
-      if (start == end) {
-        *token_end = start;
-        return true;
-      }
-      c = *start;
-    }
-
-    // Optional exponent part
-    if ('e' == c || 'E' == c) {
-      ++start;
-      if (start == end)
-        return false;
-      c = *start;
-      if ('-' == c || '+' == c) {
-        ++start;
-        if (start == end)
-          return false;
-      }
-      if (!ReadInt(start, end, &start, /*allow_leading_zeros=*/true))
-        return false;
-    }
-
-    *token_end = start;
-    return true;
-  }
-
-  static bool ReadHexDigits(const Char* start,
-                            const Char* end,
-                            const Char** token_end,
-                            int digits) {
-    if (end - start < digits)
-      return false;
-    for (int i = 0; i < digits; ++i) {
-      Char c = *start++;
-      if (!(('0' <= c && c <= '9') || ('a' <= c && c <= 'f') ||
-            ('A' <= c && c <= 'F')))
-        return false;
-    }
-    *token_end = start;
-    return true;
-  }
-
-  static bool ParseStringToken(const Char* start,
-                               const Char* end,
-                               const Char** token_end) {
-    while (start < end) {
-      Char c = *start++;
-      if ('\\' == c) {
-        if (start == end)
-          return false;
-        c = *start++;
-        // Make sure the escaped char is valid.
-        switch (c) {
-          case 'x':
-            if (!ReadHexDigits(start, end, &start, 2))
-              return false;
-            break;
-          case 'u':
-            if (!ReadHexDigits(start, end, &start, 4))
-              return false;
-            break;
-          case '\\':
-          case '/':
-          case 'b':
-          case 'f':
-          case 'n':
-          case 'r':
-          case 't':
-          case 'v':
-          case '"':
-            break;
-          default:
-            return false;
-        }
-      } else if ('"' == c) {
-        *token_end = start;
-        return true;
-      }
-    }
-    return false;
-  }
-
-  static bool SkipComment(const Char* start,
-                          const Char* end,
-                          const Char** comment_end) {
-    if (start == end)
-      return false;
-
-    if (*start != '/' || start + 1 >= end)
-      return false;
-    ++start;
-
-    if (*start == '/') {
-      // Single line comment, read to newline.
-      for (++start; start < end; ++start) {
-        if (*start == '\n' || *start == '\r') {
-          *comment_end = start + 1;
-          return true;
-        }
-      }
-      *comment_end = end;
-      // Comment reaches end-of-input, which is fine.
-      return true;
-    }
-
-    if (*start == '*') {
-      Char previous = '\0';
-      // Block comment, read until end marker.
-      for (++start; start < end; previous = *start++) {
-        if (previous == '*' && *start == '/') {
-          *comment_end = start + 1;
-          return true;
-        }
-      }
-      // Block comment must close before end-of-input.
-      return false;
-    }
-
-    return false;
-  }
-
-  static bool IsSpaceOrNewLine(Char c) {
-    // \v = vertial tab; \f = form feed page break.
-    return c == ' ' || c == '\n' || c == '\v' || c == '\f' || c == '\r' ||
-           c == '\t';
-  }
-
-  static void SkipWhitespaceAndComments(const Char* start,
-                                        const Char* end,
-                                        const Char** whitespace_end) {
-    while (start < end) {
-      if (IsSpaceOrNewLine(*start)) {
-        ++start;
-      } else if (*start == '/') {
-        const Char* comment_end = nullptr;
-        if (!SkipComment(start, end, &comment_end))
-          break;
-        start = comment_end;
-      } else {
-        break;
-      }
-    }
-    *whitespace_end = start;
-  }
-
-  static Token ParseToken(const Char* start,
-                          const Char* end,
-                          const Char** tokenStart,
-                          const Char** token_end) {
-    SkipWhitespaceAndComments(start, end, tokenStart);
-    start = *tokenStart;
-
-    if (start == end)
-      return NoInput;
-
-    switch (*start) {
-      case 'n':
-        if (ParseConstToken(start, end, token_end, kNullString))
-          return NullToken;
-        break;
-      case 't':
-        if (ParseConstToken(start, end, token_end, kTrueString))
-          return BoolTrue;
-        break;
-      case 'f':
-        if (ParseConstToken(start, end, token_end, kFalseString))
-          return BoolFalse;
-        break;
-      case '[':
-        *token_end = start + 1;
-        return ArrayBegin;
-      case ']':
-        *token_end = start + 1;
-        return ArrayEnd;
-      case ',':
-        *token_end = start + 1;
-        return ListSeparator;
-      case '{':
-        *token_end = start + 1;
-        return ObjectBegin;
-      case '}':
-        *token_end = start + 1;
-        return ObjectEnd;
-      case ':':
-        *token_end = start + 1;
-        return ObjectPairSeparator;
-      case '0':
-      case '1':
-      case '2':
-      case '3':
-      case '4':
-      case '5':
-      case '6':
-      case '7':
-      case '8':
-      case '9':
-      case '-':
-        if (ParseNumberToken(start, end, token_end))
-          return Number;
-        break;
-      case '"':
-        if (ParseStringToken(start + 1, end, token_end))
-          return StringLiteral;
-        break;
-    }
-    return InvalidToken;
-  }
-
-  static int HexToInt(Char c) {
-    if ('0' <= c && c <= '9')
-      return c - '0';
-    if ('A' <= c && c <= 'F')
-      return c - 'A' + 10;
-    if ('a' <= c && c <= 'f')
-      return c - 'a' + 10;
-    assert(false);  // Unreachable.
-    return 0;
-  }
-
-  static bool DecodeString(const Char* start,
-                           const Char* end,
-                           std::vector<uint16_t>* output) {
-    if (start == end)
-      return true;
-    if (start > end)
-      return false;
-    output->reserve(end - start);
-    while (start < end) {
-      uint16_t c = *start++;
-      // If the |Char| we're dealing with is really a byte, then
-      // we have utf8 here, and we need to check for multibyte characters
-      // and transcode them to utf16 (either one or two utf16 chars).
-      if (sizeof(Char) == sizeof(uint8_t) && c > 0x7f) {
-        // Inspect the leading byte to figure out how long the utf8
-        // byte sequence is; while doing this initialize |codepoint|
-        // with the first few bits.
-        // See table in: https://en.wikipedia.org/wiki/UTF-8
-        // byte one is 110x xxxx -> 2 byte utf8 sequence
-        // byte one is 1110 xxxx -> 3 byte utf8 sequence
-        // byte one is 1111 0xxx -> 4 byte utf8 sequence
-        uint32_t codepoint;
-        int num_bytes_left;
-        if ((c & 0xe0) == 0xc0) {  // 2 byte utf8 sequence
-          num_bytes_left = 1;
-          codepoint = c & 0x1f;
-        } else if ((c & 0xf0) == 0xe0) {  // 3 byte utf8 sequence
-          num_bytes_left = 2;
-          codepoint = c & 0x0f;
-        } else if ((c & 0xf8) == 0xf0) {  // 4 byte utf8 sequence
-          codepoint = c & 0x07;
-          num_bytes_left = 3;
-        } else {
-          return false;  // invalid leading byte
-        }
-
-        // If we have enough bytes in our inpput, decode the remaining ones
-        // belonging to this Unicode character into |codepoint|.
-        if (start + num_bytes_left > end)
-          return false;
-        while (num_bytes_left > 0) {
-          c = *start++;
-          --num_bytes_left;
-          // Check the next byte is a continuation byte, that is 10xx xxxx.
-          if ((c & 0xc0) != 0x80)
-            return false;
-          codepoint = (codepoint << 6) | (c & 0x3f);
-        }
-
-        // Disallow overlong encodings for ascii characters, as these
-        // would include " and other characters significant to JSON
-        // string termination / control.
-        if (codepoint <= 0x7f)
-          return false;
-        // Invalid in UTF8, and can't be represented in UTF16 anyway.
-        if (codepoint > 0x10ffff)
-          return false;
-
-        // So, now we transcode to UTF16,
-        // using the math described at https://en.wikipedia.org/wiki/UTF-16,
-        // for either one or two 16 bit characters.
-        if (codepoint < 0xffff) {
-          output->push_back(codepoint);
-          continue;
-        }
-        codepoint -= 0x10000;
-        output->push_back((codepoint >> 10) + 0xd800);    // high surrogate
-        output->push_back((codepoint & 0x3ff) + 0xdc00);  // low surrogate
-        continue;
-      }
-      if ('\\' != c) {
-        output->push_back(c);
-        continue;
-      }
-      if (start == end)
-        return false;
-      c = *start++;
-
-      if (c == 'x') {
-        // \x is not supported.
-        return false;
-      }
-
-      switch (c) {
-        case '"':
-        case '/':
-        case '\\':
-          break;
-        case 'b':
-          c = '\b';
-          break;
-        case 'f':
-          c = '\f';
-          break;
-        case 'n':
-          c = '\n';
-          break;
-        case 'r':
-          c = '\r';
-          break;
-        case 't':
-          c = '\t';
-          break;
-        case 'v':
-          c = '\v';
-          break;
-        case 'u':
-          c = (HexToInt(*start) << 12) + (HexToInt(*(start + 1)) << 8) +
-              (HexToInt(*(start + 2)) << 4) + HexToInt(*(start + 3));
-          start += 4;
-          break;
-        default:
-          return false;
-      }
-      output->push_back(c);
-    }
-    return true;
-  }
-
-  void ParseValue(const Char* start,
-                  const Char* end,
-                  const Char** value_token_end,
-                  int depth) {
-    if (depth > kStackLimit) {
-      HandleError(Error::JSON_PARSER_STACK_LIMIT_EXCEEDED, start);
-      return;
-    }
-    const Char* token_start = nullptr;
-    const Char* token_end = nullptr;
-    Token token = ParseToken(start, end, &token_start, &token_end);
-    switch (token) {
-      case NoInput:
-        HandleError(Error::JSON_PARSER_NO_INPUT, token_start);
-        return;
-      case InvalidToken:
-        HandleError(Error::JSON_PARSER_INVALID_TOKEN, token_start);
-        return;
-      case NullToken:
-        handler_->HandleNull();
-        break;
-      case BoolTrue:
-        handler_->HandleBool(true);
-        break;
-      case BoolFalse:
-        handler_->HandleBool(false);
-        break;
-      case Number: {
-        double value;
-        if (!CharsToDouble(token_start, token_end - token_start, &value)) {
-          HandleError(Error::JSON_PARSER_INVALID_NUMBER, token_start);
-          return;
-        }
-        if (value >= std::numeric_limits<int32_t>::min() &&
-            value <= std::numeric_limits<int32_t>::max() &&
-            static_cast<int32_t>(value) == value)
-          handler_->HandleInt32(static_cast<int32_t>(value));
-        else
-          handler_->HandleDouble(value);
-        break;
-      }
-      case StringLiteral: {
-        std::vector<uint16_t> value;
-        bool ok = DecodeString(token_start + 1, token_end - 1, &value);
-        if (!ok) {
-          HandleError(Error::JSON_PARSER_INVALID_STRING, token_start);
-          return;
-        }
-        handler_->HandleString16(span<uint16_t>(value.data(), value.size()));
-        break;
-      }
-      case ArrayBegin: {
-        handler_->HandleArrayBegin();
-        start = token_end;
-        token = ParseToken(start, end, &token_start, &token_end);
-        while (token != ArrayEnd) {
-          ParseValue(start, end, &token_end, depth + 1);
-          if (error_)
-            return;
-
-          // After a list value, we expect a comma or the end of the list.
-          start = token_end;
-          token = ParseToken(start, end, &token_start, &token_end);
-          if (token == ListSeparator) {
-            start = token_end;
-            token = ParseToken(start, end, &token_start, &token_end);
-            if (token == ArrayEnd) {
-              HandleError(Error::JSON_PARSER_UNEXPECTED_ARRAY_END, token_start);
-              return;
-            }
-          } else if (token != ArrayEnd) {
-            // Unexpected value after list value. Bail out.
-            HandleError(Error::JSON_PARSER_COMMA_OR_ARRAY_END_EXPECTED,
-                        token_start);
-            return;
-          }
-        }
-        handler_->HandleArrayEnd();
-        break;
-      }
-      case ObjectBegin: {
-        handler_->HandleMapBegin();
-        start = token_end;
-        token = ParseToken(start, end, &token_start, &token_end);
-        while (token != ObjectEnd) {
-          if (token != StringLiteral) {
-            HandleError(Error::JSON_PARSER_STRING_LITERAL_EXPECTED,
-                        token_start);
-            return;
-          }
-          std::vector<uint16_t> key;
-          if (!DecodeString(token_start + 1, token_end - 1, &key)) {
-            HandleError(Error::JSON_PARSER_INVALID_STRING, token_start);
-            return;
-          }
-          handler_->HandleString16(span<uint16_t>(key.data(), key.size()));
-          start = token_end;
-
-          token = ParseToken(start, end, &token_start, &token_end);
-          if (token != ObjectPairSeparator) {
-            HandleError(Error::JSON_PARSER_COLON_EXPECTED, token_start);
-            return;
-          }
-          start = token_end;
-
-          ParseValue(start, end, &token_end, depth + 1);
-          if (error_)
-            return;
-          start = token_end;
-
-          // After a key/value pair, we expect a comma or the end of the
-          // object.
-          token = ParseToken(start, end, &token_start, &token_end);
-          if (token == ListSeparator) {
-            start = token_end;
-            token = ParseToken(start, end, &token_start, &token_end);
-            if (token == ObjectEnd) {
-              HandleError(Error::JSON_PARSER_UNEXPECTED_MAP_END, token_start);
-              return;
-            }
-          } else if (token != ObjectEnd) {
-            // Unexpected value after last object value. Bail out.
-            HandleError(Error::JSON_PARSER_COMMA_OR_MAP_END_EXPECTED,
-                        token_start);
-            return;
-          }
-        }
-        handler_->HandleMapEnd();
-        break;
-      }
-
-      default:
-        // We got a token that's not a value.
-        HandleError(Error::JSON_PARSER_VALUE_EXPECTED, token_start);
-        return;
-    }
-
-    SkipWhitespaceAndComments(token_end, end, value_token_end);
-  }
-
-  void HandleError(Error error, const Char* pos) {
-    assert(error != Error::OK);
-    if (!error_) {
-      handler_->HandleError(
-          Status{error, static_cast<size_t>(pos - start_pos_)});
-      error_ = true;
-    }
-  }
-
-  const Char* start_pos_ = nullptr;
-  bool error_ = false;
-  const Platform* platform_;
-  StreamingParserHandler* handler_;
-};
-}  // namespace
-
-void ParseJSON(const Platform& platform,
-               span<uint8_t> chars,
-               StreamingParserHandler* handler) {
-  JsonParser<uint8_t> parser(&platform, handler);
-  parser.Parse(chars.data(), chars.size());
-}
-
-void ParseJSON(const Platform& platform,
-               span<uint16_t> chars,
-               StreamingParserHandler* handler) {
-  JsonParser<uint16_t> parser(&platform, handler);
-  parser.Parse(chars.data(), chars.size());
-}
-
-// =============================================================================
-// json::ConvertCBORToJSON, json::ConvertJSONToCBOR - for transcoding
-// =============================================================================
-template <typename C>
-Status ConvertCBORToJSONTmpl(const Platform& platform,
-                             span<uint8_t> cbor,
-                             C* json) {
-  Status status;
-  std::unique_ptr<StreamingParserHandler> json_writer =
-      NewJSONEncoder(&platform, json, &status);
-  cbor::ParseCBOR(cbor, json_writer.get());
-  return status;
-}
-
-Status ConvertCBORToJSON(const Platform& platform,
-                         span<uint8_t> cbor,
-                         std::vector<uint8_t>* json) {
-  return ConvertCBORToJSONTmpl(platform, cbor, json);
-}
-Status ConvertCBORToJSON(const Platform& platform,
-                         span<uint8_t> cbor,
-                         std::string* json) {
-  return ConvertCBORToJSONTmpl(platform, cbor, json);
-}
-
-template <typename T, typename C>
-Status ConvertJSONToCBORTmpl(const Platform& platform, span<T> json, C* cbor) {
-  Status status;
-  std::unique_ptr<StreamingParserHandler> encoder =
-      cbor::NewCBOREncoder(cbor, &status);
-  ParseJSON(platform, json, encoder.get());
-  return status;
-}
-Status ConvertJSONToCBOR(const Platform& platform,
-                         span<uint8_t> json,
-                         std::string* cbor) {
-  return ConvertJSONToCBORTmpl(platform, json, cbor);
-}
-Status ConvertJSONToCBOR(const Platform& platform,
-                         span<uint16_t> json,
-                         std::string* cbor) {
-  return ConvertJSONToCBORTmpl(platform, json, cbor);
-}
-Status ConvertJSONToCBOR(const Platform& platform,
-                         span<uint8_t> json,
-                         std::vector<uint8_t>* cbor) {
-  return ConvertJSONToCBORTmpl(platform, json, cbor);
-}
-Status ConvertJSONToCBOR(const Platform& platform,
-                         span<uint16_t> json,
-                         std::vector<uint8_t>* cbor) {
-  return ConvertJSONToCBORTmpl(platform, json, cbor);
-}
-}  // namespace json
-}  // namespace v8_inspector_protocol_encoding
diff --git a/tools/inspector_protocol/encoding/encoding.h b/tools/inspector_protocol/encoding/encoding.h
deleted file mode 100644
index a1bcfc4be3db4a..00000000000000
--- a/tools/inspector_protocol/encoding/encoding.h
+++ /dev/null
@@ -1,540 +0,0 @@
-// Copyright 2019 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef V8_INSPECTOR_PROTOCOL_ENCODING_ENCODING_H_
-#define V8_INSPECTOR_PROTOCOL_ENCODING_ENCODING_H_
-
-#include <algorithm>
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-#include <limits>
-#include <memory>
-#include <string>
-#include <vector>
-
-namespace v8_inspector_protocol_encoding {
-// This library is designed to be portable. The only allowed dependency
-// are the C/C++ standard libraries, up to C++11. We support both 32 bit
-// and 64 architectures.
-//
-// Types used below:
-// uint8_t: a byte, e.g. for raw bytes or UTF8 characters
-// uint16_t: two bytes, e.g. for UTF16 characters
-// For input parameters:
-//   span<uint8_t>: pointer to bytes and length
-//   span<uint16_t>: pointer to UTF16 chars and length
-// For output parameters:
-//   std::vector<uint8_t> - Owned segment of bytes / utf8 characters and length.
-//   std::string - Same, for compatibility, even though char is signed.
-
-// =============================================================================
-// span - sequence of bytes
-// =============================================================================
-
-// This template is similar to std::span, which will be included in C++20.
-template <typename T>
-class span {
- public:
-  using index_type = size_t;
-
-  span() : data_(nullptr), size_(0) {}
-  span(const T* data, index_type size) : data_(data), size_(size) {}
-
-  const T* data() const { return data_; }
-
-  const T* begin() const { return data_; }
-  const T* end() const { return data_ + size_; }
-
-  const T& operator[](index_type idx) const { return data_[idx]; }
-
-  span<T> subspan(index_type offset, index_type count) const {
-    return span(data_ + offset, count);
-  }
-
-  span<T> subspan(index_type offset) const {
-    return span(data_ + offset, size_ - offset);
-  }
-
-  bool empty() const { return size_ == 0; }
-
-  index_type size() const { return size_; }
-  index_type size_bytes() const { return size_ * sizeof(T); }
-
- private:
-  const T* data_;
-  index_type size_;
-};
-
-template <typename T>
-span<T> SpanFrom(const std::vector<T>& v) {
-  return span<T>(v.data(), v.size());
-}
-
-template <size_t N>
-span<uint8_t> SpanFrom(const char (&str)[N]) {
-  return span<uint8_t>(reinterpret_cast<const uint8_t*>(str), N - 1);
-}
-
-inline span<uint8_t> SpanFrom(const char* str) {
-  return str ? span<uint8_t>(reinterpret_cast<const uint8_t*>(str), strlen(str))
-             : span<uint8_t>();
-}
-
-inline span<uint8_t> SpanFrom(const std::string& v) {
-  return span<uint8_t>(reinterpret_cast<const uint8_t*>(v.data()), v.size());
-}
-
-// Less than / equality comparison functions for sorting / searching for byte
-// spans. These are similar to absl::string_view's < and == operators.
-inline bool SpanLessThan(span<uint8_t> x, span<uint8_t> y) noexcept {
-  auto min_size = std::min(x.size(), y.size());
-  const int r = min_size == 0 ? 0 : memcmp(x.data(), y.data(), min_size);
-  return (r < 0) || (r == 0 && x.size() < y.size());
-}
-
-inline bool SpanEquals(span<uint8_t> x, span<uint8_t> y) noexcept {
-  auto len = x.size();
-  if (len != y.size())
-    return false;
-  return x.data() == y.data() || len == 0 ||
-         std::memcmp(x.data(), y.data(), len) == 0;
-}
-
-// =============================================================================
-// Status and Error codes
-// =============================================================================
-enum class Error {
-  OK = 0,
-  // JSON parsing errors - json_parser.{h,cc}.
-  JSON_PARSER_UNPROCESSED_INPUT_REMAINS = 0x01,
-  JSON_PARSER_STACK_LIMIT_EXCEEDED = 0x02,
-  JSON_PARSER_NO_INPUT = 0x03,
-  JSON_PARSER_INVALID_TOKEN = 0x04,
-  JSON_PARSER_INVALID_NUMBER = 0x05,
-  JSON_PARSER_INVALID_STRING = 0x06,
-  JSON_PARSER_UNEXPECTED_ARRAY_END = 0x07,
-  JSON_PARSER_COMMA_OR_ARRAY_END_EXPECTED = 0x08,
-  JSON_PARSER_STRING_LITERAL_EXPECTED = 0x09,
-  JSON_PARSER_COLON_EXPECTED = 0x0a,
-  JSON_PARSER_UNEXPECTED_MAP_END = 0x0b,
-  JSON_PARSER_COMMA_OR_MAP_END_EXPECTED = 0x0c,
-  JSON_PARSER_VALUE_EXPECTED = 0x0d,
-
-  CBOR_INVALID_INT32 = 0x0e,
-  CBOR_INVALID_DOUBLE = 0x0f,
-  CBOR_INVALID_ENVELOPE = 0x10,
-  CBOR_INVALID_STRING8 = 0x11,
-  CBOR_INVALID_STRING16 = 0x12,
-  CBOR_INVALID_BINARY = 0x13,
-  CBOR_UNSUPPORTED_VALUE = 0x14,
-  CBOR_NO_INPUT = 0x15,
-  CBOR_INVALID_START_BYTE = 0x16,
-  CBOR_UNEXPECTED_EOF_EXPECTED_VALUE = 0x17,
-  CBOR_UNEXPECTED_EOF_IN_ARRAY = 0x18,
-  CBOR_UNEXPECTED_EOF_IN_MAP = 0x19,
-  CBOR_INVALID_MAP_KEY = 0x1a,
-  CBOR_STACK_LIMIT_EXCEEDED = 0x1b,
-  CBOR_TRAILING_JUNK = 0x1c,
-  CBOR_MAP_START_EXPECTED = 0x1d,
-  CBOR_MAP_STOP_EXPECTED = 0x1e,
-  CBOR_ENVELOPE_SIZE_LIMIT_EXCEEDED = 0x1f,
-};
-
-// A status value with position that can be copied. The default status
-// is OK. Usually, error status values should come with a valid position.
-struct Status {
-  static constexpr size_t npos() { return std::numeric_limits<size_t>::max(); }
-
-  bool ok() const { return error == Error::OK; }
-
-  Error error = Error::OK;
-  size_t pos = npos();
-  Status(Error error, size_t pos) : error(error), pos(pos) {}
-  Status() = default;
-
-  // Returns a 7 bit US-ASCII string, either "OK" or an error message
-  // that includes the position.
-  std::string ToASCIIString() const;
-
- private:
-  std::string ToASCIIString(const char* msg) const;
-};
-
-// Handler interface for parser events emitted by a streaming parser.
-// See cbor::NewCBOREncoder, cbor::ParseCBOR, json::NewJSONEncoder,
-// json::ParseJSON.
-class StreamingParserHandler {
- public:
-  virtual ~StreamingParserHandler() = default;
-  virtual void HandleMapBegin() = 0;
-  virtual void HandleMapEnd() = 0;
-  virtual void HandleArrayBegin() = 0;
-  virtual void HandleArrayEnd() = 0;
-  virtual void HandleString8(span<uint8_t> chars) = 0;
-  virtual void HandleString16(span<uint16_t> chars) = 0;
-  virtual void HandleBinary(span<uint8_t> bytes) = 0;
-  virtual void HandleDouble(double value) = 0;
-  virtual void HandleInt32(int32_t value) = 0;
-  virtual void HandleBool(bool value) = 0;
-  virtual void HandleNull() = 0;
-
-  // The parser may send one error even after other events have already
-  // been received. Client code is reponsible to then discard the
-  // already processed events.
-  // |error| must be an eror, as in, |error.is_ok()| can't be true.
-  virtual void HandleError(Status error) = 0;
-};
-
-namespace cbor {
-// The binary encoding for the inspector protocol follows the CBOR specification
-// (RFC 7049). Additional constraints:
-// - Only indefinite length maps and arrays are supported.
-// - Maps and arrays are wrapped with an envelope, that is, a
-//   CBOR tag with value 24 followed by a byte string specifying
-//   the byte length of the enclosed map / array. The byte string
-//   must use a 32 bit wide length.
-// - At the top level, a message must be an indefinite length map
-//   wrapped by an envelope.
-// - Maximal size for messages is 2^32 (4 GiB).
-// - For scalars, we support only the int32_t range, encoded as
-//   UNSIGNED/NEGATIVE (major types 0 / 1).
-// - UTF16 strings, including with unbalanced surrogate pairs, are encoded
-//   as CBOR BYTE_STRING (major type 2). For such strings, the number of
-//   bytes encoded must be even.
-// - UTF8 strings (major type 3) are supported.
-// - 7 bit US-ASCII strings must always be encoded as UTF8 strings, never
-//   as UTF16 strings.
-// - Arbitrary byte arrays, in the inspector protocol called 'binary',
-//   are encoded as BYTE_STRING (major type 2), prefixed with a byte
-//   indicating base64 when rendered as JSON.
-
-// =============================================================================
-// Detecting CBOR content
-// =============================================================================
-
-// The first byte for an envelope, which we use for wrapping dictionaries
-// and arrays; and the byte that indicates a byte string with 32 bit length.
-// These two bytes start an envelope, and thereby also any CBOR message
-// produced or consumed by this protocol. See also |EnvelopeEncoder| below.
-uint8_t InitialByteForEnvelope();
-uint8_t InitialByteFor32BitLengthByteString();
-
-// Checks whether |msg| is a cbor message.
-bool IsCBORMessage(span<uint8_t> msg);
-
-// =============================================================================
-// Encoding individual CBOR items
-// =============================================================================
-
-// Some constants for CBOR tokens that only take a single byte on the wire.
-uint8_t EncodeTrue();
-uint8_t EncodeFalse();
-uint8_t EncodeNull();
-uint8_t EncodeIndefiniteLengthArrayStart();
-uint8_t EncodeIndefiniteLengthMapStart();
-uint8_t EncodeStop();
-
-// Encodes |value| as |UNSIGNED| (major type 0) iff >= 0, or |NEGATIVE|
-// (major type 1) iff < 0.
-void EncodeInt32(int32_t value, std::vector<uint8_t>* out);
-void EncodeInt32(int32_t value, std::string* out);
-
-// Encodes a UTF16 string as a BYTE_STRING (major type 2). Each utf16
-// character in |in| is emitted with most significant byte first,
-// appending to |out|.
-void EncodeString16(span<uint16_t> in, std::vector<uint8_t>* out);
-void EncodeString16(span<uint16_t> in, std::string* out);
-
-// Encodes a UTF8 string |in| as STRING (major type 3).
-void EncodeString8(span<uint8_t> in, std::vector<uint8_t>* out);
-void EncodeString8(span<uint8_t> in, std::string* out);
-
-// Encodes the given |latin1| string as STRING8.
-// If any non-ASCII character is present, it will be represented
-// as a 2 byte UTF8 sequence.
-void EncodeFromLatin1(span<uint8_t> latin1, std::vector<uint8_t>* out);
-void EncodeFromLatin1(span<uint8_t> latin1, std::string* out);
-
-// Encodes the given |utf16| string as STRING8 if it's entirely US-ASCII.
-// Otherwise, encodes as STRING16.
-void EncodeFromUTF16(span<uint16_t> utf16, std::vector<uint8_t>* out);
-void EncodeFromUTF16(span<uint16_t> utf16, std::string* out);
-
-// Encodes arbitrary binary data in |in| as a BYTE_STRING (major type 2) with
-// definitive length, prefixed with tag 22 indicating expected conversion to
-// base64 (see RFC 7049, Table 3 and Section 2.4.4.2).
-void EncodeBinary(span<uint8_t> in, std::vector<uint8_t>* out);
-void EncodeBinary(span<uint8_t> in, std::string* out);
-
-// Encodes / decodes a double as Major type 7 (SIMPLE_VALUE),
-// with additional info = 27, followed by 8 bytes in big endian.
-void EncodeDouble(double value, std::vector<uint8_t>* out);
-void EncodeDouble(double value, std::string* out);
-
-// =============================================================================
-// cbor::EnvelopeEncoder - for wrapping submessages
-// =============================================================================
-
-// An envelope indicates the byte length of a wrapped item.
-// We use this for maps and array, which allows the decoder
-// to skip such (nested) values whole sale.
-// It's implemented as a CBOR tag (major type 6) with additional
-// info = 24, followed by a byte string with a 32 bit length value;
-// so the maximal structure that we can wrap is 2^32 bits long.
-// See also: https://tools.ietf.org/html/rfc7049#section-2.4.4.1
-class EnvelopeEncoder {
- public:
-  // Emits the envelope start bytes and records the position for the
-  // byte size in |byte_size_pos_|. Also emits empty bytes for the
-  // byte sisze so that encoding can continue.
-  void EncodeStart(std::vector<uint8_t>* out);
-  void EncodeStart(std::string* out);
-  // This records the current size in |out| at position byte_size_pos_.
-  // Returns true iff successful.
-  bool EncodeStop(std::vector<uint8_t>* out);
-  bool EncodeStop(std::string* out);
-
- private:
-  size_t byte_size_pos_ = 0;
-};
-
-// =============================================================================
-// cbor::NewCBOREncoder - for encoding from a streaming parser
-// =============================================================================
-
-// This can be used to convert to CBOR, by passing the return value to a parser
-// that drives it. The handler will encode into |out|, and iff an error occurs
-// it will set |status| to an error and clear |out|. Otherwise, |status.ok()|
-// will be |true|.
-std::unique_ptr<StreamingParserHandler> NewCBOREncoder(
-    std::vector<uint8_t>* out,
-    Status* status);
-std::unique_ptr<StreamingParserHandler> NewCBOREncoder(std::string* out,
-                                                       Status* status);
-
-// =============================================================================
-// cbor::CBORTokenizer - for parsing individual CBOR items
-// =============================================================================
-
-// Tags for the tokens within a CBOR message that CBORTokenizer understands.
-// Note that this is not the same terminology as the CBOR spec (RFC 7049),
-// but rather, our adaptation. For instance, we lump unsigned and signed
-// major type into INT32 here (and disallow values outside the int32_t range).
-enum class CBORTokenTag {
-  // Encountered an error in the structure of the message. Consult
-  // status() for details.
-  ERROR_VALUE,
-  // Booleans and NULL.
-  TRUE_VALUE,
-  FALSE_VALUE,
-  NULL_VALUE,
-  // An int32_t (signed 32 bit integer).
-  INT32,
-  // A double (64 bit floating point).
-  DOUBLE,
-  // A UTF8 string.
-  STRING8,
-  // A UTF16 string.
-  STRING16,
-  // A binary string.
-  BINARY,
-  // Starts an indefinite length map; after the map start we expect
-  // alternating keys and values, followed by STOP.
-  MAP_START,
-  // Starts an indefinite length array; after the array start we
-  // expect values, followed by STOP.
-  ARRAY_START,
-  // Ends a map or an array.
-  STOP,
-  // An envelope indicator, wrapping a map or array.
-  // Internally this carries the byte length of the wrapped
-  // map or array. While CBORTokenizer::Next() will read / skip the entire
-  // envelope, CBORTokenizer::EnterEnvelope() reads the tokens
-  // inside of it.
-  ENVELOPE,
-  // We've reached the end there is nothing else to read.
-  DONE,
-};
-
-// The major types from RFC 7049 Section 2.1.
-enum class MajorType {
-  UNSIGNED = 0,
-  NEGATIVE = 1,
-  BYTE_STRING = 2,
-  STRING = 3,
-  ARRAY = 4,
-  MAP = 5,
-  TAG = 6,
-  SIMPLE_VALUE = 7
-};
-
-// CBORTokenizer segments a CBOR message, presenting the tokens therein as
-// numbers, strings, etc. This is not a complete CBOR parser, but makes it much
-// easier to implement one (e.g. ParseCBOR, above). It can also be used to parse
-// messages partially.
-class CBORTokenizer {
- public:
-  explicit CBORTokenizer(span<uint8_t> bytes);
-  ~CBORTokenizer();
-
-  // Identifies the current token that we're looking at,
-  // or ERROR_VALUE (in which ase ::Status() has details)
-  // or DONE (if we're past the last token).
-  CBORTokenTag TokenTag() const;
-
-  // Advances to the next token.
-  void Next();
-  // Can only be called if TokenTag() == CBORTokenTag::ENVELOPE.
-  // While Next() would skip past the entire envelope / what it's
-  // wrapping, EnterEnvelope positions the cursor inside of the envelope,
-  // letting the client explore the nested structure.
-  void EnterEnvelope();
-
-  // If TokenTag() is CBORTokenTag::ERROR_VALUE, then Status().error describes
-  // the error more precisely; otherwise it'll be set to Error::OK.
-  // In either case, Status().pos is the current position.
-  struct Status Status() const;
-
-  // The following methods retrieve the token values. They can only
-  // be called if TokenTag() matches.
-
-  // To be called only if ::TokenTag() == CBORTokenTag::INT32.
-  int32_t GetInt32() const;
-
-  // To be called only if ::TokenTag() == CBORTokenTag::DOUBLE.
-  double GetDouble() const;
-
-  // To be called only if ::TokenTag() == CBORTokenTag::STRING8.
-  span<uint8_t> GetString8() const;
-
-  // Wire representation for STRING16 is low byte first (little endian).
-  // To be called only if ::TokenTag() == CBORTokenTag::STRING16.
-  span<uint8_t> GetString16WireRep() const;
-
-  // To be called only if ::TokenTag() == CBORTokenTag::BINARY.
-  span<uint8_t> GetBinary() const;
-
-  // To be called only if ::TokenTag() == CBORTokenTag::ENVELOPE.
-  span<uint8_t> GetEnvelopeContents() const;
-
- private:
-  void ReadNextToken(bool enter_envelope);
-  void SetToken(CBORTokenTag token, size_t token_byte_length);
-  void SetError(Error error);
-
-  span<uint8_t> bytes_;
-  CBORTokenTag token_tag_;
-  struct Status status_;
-  size_t token_byte_length_;
-  MajorType token_start_type_;
-  uint64_t token_start_internal_value_;
-};
-
-// =============================================================================
-// cbor::ParseCBOR - for receiving streaming parser events for CBOR messages
-// =============================================================================
-
-// Parses a CBOR encoded message from |bytes|, sending events to
-// |out|. If an error occurs, sends |out->HandleError|, and parsing stops.
-// The client is responsible for discarding the already received information in
-// that case.
-void ParseCBOR(span<uint8_t> bytes, StreamingParserHandler* out);
-
-// =============================================================================
-// cbor::AppendString8EntryToMap - for limited in-place editing of messages
-// =============================================================================
-
-// Modifies the |cbor| message by appending a new key/value entry at the end
-// of the map. Patches up the envelope size; Status.ok() iff successful.
-// If not successful, |cbor| may be corrupted after this call.
-Status AppendString8EntryToCBORMap(span<uint8_t> string8_key,
-                                   span<uint8_t> string8_value,
-                                   std::vector<uint8_t>* cbor);
-Status AppendString8EntryToCBORMap(span<uint8_t> string8_key,
-                                   span<uint8_t> string8_value,
-                                   std::string* cbor);
-
-namespace internals {  // Exposed only for writing tests.
-size_t ReadTokenStart(span<uint8_t> bytes,
-                      cbor::MajorType* type,
-                      uint64_t* value);
-
-void WriteTokenStart(cbor::MajorType type,
-                     uint64_t value,
-                     std::vector<uint8_t>* encoded);
-void WriteTokenStart(cbor::MajorType type,
-                     uint64_t value,
-                     std::string* encoded);
-}  // namespace internals
-}  // namespace cbor
-
-namespace json {
-// Client code must provide an instance. Implementation should delegate
-// to whatever is appropriate.
-class Platform {
- public:
-  virtual ~Platform() = default;
-  // Parses |str| into |result|. Returns false iff there are
-  // leftover characters or parsing errors.
-  virtual bool StrToD(const char* str, double* result) const = 0;
-
-  // Prints |value| in a format suitable for JSON.
-  virtual std::unique_ptr<char[]> DToStr(double value) const = 0;
-};
-
-// =============================================================================
-// json::NewJSONEncoder - for encoding streaming parser events as JSON
-// =============================================================================
-
-// Returns a handler object which will write ascii characters to |out|.
-// |status->ok()| will be false iff the handler routine HandleError() is called.
-// In that case, we'll stop emitting output.
-// Except for calling the HandleError routine at any time, the client
-// code must call the Handle* methods in an order in which they'd occur
-// in valid JSON; otherwise we may crash (the code uses assert).
-std::unique_ptr<StreamingParserHandler> NewJSONEncoder(
-    const Platform* platform,
-    std::vector<uint8_t>* out,
-    Status* status);
-std::unique_ptr<StreamingParserHandler> NewJSONEncoder(const Platform* platform,
-                                                       std::string* out,
-                                                       Status* status);
-
-// =============================================================================
-// json::ParseJSON - for receiving streaming parser events for JSON
-// =============================================================================
-
-void ParseJSON(const Platform& platform,
-               span<uint8_t> chars,
-               StreamingParserHandler* handler);
-void ParseJSON(const Platform& platform,
-               span<uint16_t> chars,
-               StreamingParserHandler* handler);
-
-// =============================================================================
-// json::ConvertCBORToJSON, json::ConvertJSONToCBOR - for transcoding
-// =============================================================================
-Status ConvertCBORToJSON(const Platform& platform,
-                         span<uint8_t> cbor,
-                         std::string* json);
-Status ConvertCBORToJSON(const Platform& platform,
-                         span<uint8_t> cbor,
-                         std::vector<uint8_t>* json);
-Status ConvertJSONToCBOR(const Platform& platform,
-                         span<uint8_t> json,
-                         std::vector<uint8_t>* cbor);
-Status ConvertJSONToCBOR(const Platform& platform,
-                         span<uint16_t> json,
-                         std::vector<uint8_t>* cbor);
-Status ConvertJSONToCBOR(const Platform& platform,
-                         span<uint8_t> json,
-                         std::string* cbor);
-Status ConvertJSONToCBOR(const Platform& platform,
-                         span<uint16_t> json,
-                         std::string* cbor);
-}  // namespace json
-}  // namespace v8_inspector_protocol_encoding
-
-#endif  // V8_INSPECTOR_PROTOCOL_ENCODING_ENCODING_H_
diff --git a/tools/inspector_protocol/encoding/encoding_test.cc b/tools/inspector_protocol/encoding/encoding_test.cc
deleted file mode 100644
index f6b40dfcefe2df..00000000000000
--- a/tools/inspector_protocol/encoding/encoding_test.cc
+++ /dev/null
@@ -1,1932 +0,0 @@
-// Copyright 2018 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "encoding.h"
-
-#include <array>
-#include <clocale>
-#include <cmath>
-#include <cstdlib>
-#include <cstring>
-#include <iomanip>
-#include <iostream>
-#include <sstream>
-#include <string>
-
-#include "encoding_test_helper.h"
-
-using testing::ElementsAreArray;
-
-namespace v8_inspector_protocol_encoding {
-
-class TestPlatform : public json::Platform {
-  bool StrToD(const char* str, double* result) const override {
-    // This is not thread-safe
-    // (see https://en.cppreference.com/w/cpp/locale/setlocale)
-    // but good enough for a unittest.
-    const char* saved_locale = std::setlocale(LC_NUMERIC, nullptr);
-    char* end;
-    *result = std::strtod(str, &end);
-    std::setlocale(LC_NUMERIC, saved_locale);
-    if (errno == ERANGE) {
-      // errno must be reset, e.g. see the example here:
-      // https://en.cppreference.com/w/cpp/string/byte/strtof
-      errno = 0;
-      return false;
-    }
-    return end == str + strlen(str);
-  }
-
-  std::unique_ptr<char[]> DToStr(double value) const override {
-    std::stringstream ss;
-    ss.imbue(std::locale("C"));
-    ss << value;
-    std::string str = ss.str();
-    std::unique_ptr<char[]> result(new char[str.size() + 1]);
-    memcpy(result.get(), str.c_str(), str.size() + 1);
-    return result;
-  }
-};
-
-const json::Platform& GetTestPlatform() {
-  static TestPlatform* platform = new TestPlatform;
-  return *platform;
-}
-
-// =============================================================================
-// span - sequence of bytes
-// =============================================================================
-
-template <typename T>
-class SpanTest : public ::testing::Test {};
-
-using TestTypes = ::testing::Types<uint8_t, uint16_t>;
-TYPED_TEST_SUITE(SpanTest, TestTypes);
-
-TYPED_TEST(SpanTest, Empty) {
-  span<TypeParam> empty;
-  EXPECT_TRUE(empty.empty());
-  EXPECT_EQ(0u, empty.size());
-  EXPECT_EQ(0u, empty.size_bytes());
-  EXPECT_EQ(empty.begin(), empty.end());
-}
-
-TYPED_TEST(SpanTest, SingleItem) {
-  TypeParam single_item = 42;
-  span<TypeParam> singular(&single_item, 1);
-  EXPECT_FALSE(singular.empty());
-  EXPECT_EQ(1u, singular.size());
-  EXPECT_EQ(sizeof(TypeParam), singular.size_bytes());
-  EXPECT_EQ(singular.begin() + 1, singular.end());
-  EXPECT_EQ(42, singular[0]);
-}
-
-TYPED_TEST(SpanTest, FiveItems) {
-  std::vector<TypeParam> test_input = {31, 32, 33, 34, 35};
-  span<TypeParam> five_items(test_input.data(), 5);
-  EXPECT_FALSE(five_items.empty());
-  EXPECT_EQ(5u, five_items.size());
-  EXPECT_EQ(sizeof(TypeParam) * 5, five_items.size_bytes());
-  EXPECT_EQ(five_items.begin() + 5, five_items.end());
-  EXPECT_EQ(31, five_items[0]);
-  EXPECT_EQ(32, five_items[1]);
-  EXPECT_EQ(33, five_items[2]);
-  EXPECT_EQ(34, five_items[3]);
-  EXPECT_EQ(35, five_items[4]);
-  span<TypeParam> three_items = five_items.subspan(2);
-  EXPECT_EQ(3u, three_items.size());
-  EXPECT_EQ(33, three_items[0]);
-  EXPECT_EQ(34, three_items[1]);
-  EXPECT_EQ(35, three_items[2]);
-  span<TypeParam> two_items = five_items.subspan(2, 2);
-  EXPECT_EQ(2u, two_items.size());
-  EXPECT_EQ(33, two_items[0]);
-  EXPECT_EQ(34, two_items[1]);
-}
-
-TEST(SpanFromTest, FromConstCharAndLiteral) {
-  // Testing this is useful because strlen(nullptr) is undefined.
-  EXPECT_EQ(nullptr, SpanFrom(nullptr).data());
-  EXPECT_EQ(0u, SpanFrom(nullptr).size());
-
-  const char* kEmpty = "";
-  EXPECT_EQ(kEmpty, reinterpret_cast<const char*>(SpanFrom(kEmpty).data()));
-  EXPECT_EQ(0u, SpanFrom(kEmpty).size());
-
-  const char* kFoo = "foo";
-  EXPECT_EQ(kFoo, reinterpret_cast<const char*>(SpanFrom(kFoo).data()));
-  EXPECT_EQ(3u, SpanFrom(kFoo).size());
-
-  EXPECT_EQ(3u, SpanFrom("foo").size());
-}
-
-TEST(SpanComparisons, ByteWiseLexicographicalOrder) {
-  // Compare the empty span.
-  EXPECT_FALSE(SpanLessThan(span<uint8_t>(), span<uint8_t>()));
-  EXPECT_TRUE(SpanEquals(span<uint8_t>(), span<uint8_t>()));
-
-  // Compare message with itself.
-  std::string msg = "Hello, world";
-  EXPECT_FALSE(SpanLessThan(SpanFrom(msg), SpanFrom(msg)));
-  EXPECT_TRUE(SpanEquals(SpanFrom(msg), SpanFrom(msg)));
-
-  // Compare message and copy.
-  EXPECT_FALSE(SpanLessThan(SpanFrom(msg), SpanFrom(std::string(msg))));
-  EXPECT_TRUE(SpanEquals(SpanFrom(msg), SpanFrom(std::string(msg))));
-
-  // Compare two messages. |lesser_msg| < |msg| because of the first
-  // byte ('A' < 'H').
-  std::string lesser_msg = "A lesser message.";
-  EXPECT_TRUE(SpanLessThan(SpanFrom(lesser_msg), SpanFrom(msg)));
-  EXPECT_FALSE(SpanLessThan(SpanFrom(msg), SpanFrom(lesser_msg)));
-  EXPECT_FALSE(SpanEquals(SpanFrom(msg), SpanFrom(lesser_msg)));
-}
-
-// =============================================================================
-// Status and Error codes
-// =============================================================================
-
-TEST(StatusTest, StatusToASCIIString) {
-  Status ok_status;
-  EXPECT_EQ("OK", ok_status.ToASCIIString());
-  Status json_error(Error::JSON_PARSER_COLON_EXPECTED, 42);
-  EXPECT_EQ("JSON: colon expected at position 42", json_error.ToASCIIString());
-  Status cbor_error(Error::CBOR_TRAILING_JUNK, 21);
-  EXPECT_EQ("CBOR: trailing junk at position 21", cbor_error.ToASCIIString());
-}
-
-namespace cbor {
-
-// =============================================================================
-// Detecting CBOR content
-// =============================================================================
-
-TEST(IsCBORMessage, SomeSmokeTests) {
-  std::vector<uint8_t> empty;
-  EXPECT_FALSE(IsCBORMessage(SpanFrom(empty)));
-  std::vector<uint8_t> hello = {'H', 'e', 'l', 'o', ' ', 't',
-                                'h', 'e', 'r', 'e', '!'};
-  EXPECT_FALSE(IsCBORMessage(SpanFrom(hello)));
-  std::vector<uint8_t> example = {0xd8, 0x5a, 0, 0, 0, 0};
-  EXPECT_TRUE(IsCBORMessage(SpanFrom(example)));
-  std::vector<uint8_t> one = {0xd8, 0x5a, 0, 0, 0, 1, 1};
-  EXPECT_TRUE(IsCBORMessage(SpanFrom(one)));
-}
-
-// =============================================================================
-// Encoding individual CBOR items
-// cbor::CBORTokenizer - for parsing individual CBOR items
-// =============================================================================
-
-//
-// EncodeInt32 / CBORTokenTag::INT32
-//
-TEST(EncodeDecodeInt32Test, Roundtrips23) {
-  // This roundtrips the int32_t value 23 through the pair of EncodeInt32 /
-  // CBORTokenizer; this is interesting since 23 is encoded as a single byte.
-  std::vector<uint8_t> encoded;
-  EncodeInt32(23, &encoded);
-  // first three bits: major type = 0; remaining five bits: additional info =
-  // value 23.
-  EXPECT_THAT(encoded, ElementsAreArray(std::array<uint8_t, 1>{{23}}));
-
-  // Reverse direction: decode with CBORTokenizer.
-  CBORTokenizer tokenizer(SpanFrom(encoded));
-  EXPECT_EQ(CBORTokenTag::INT32, tokenizer.TokenTag());
-  EXPECT_EQ(23, tokenizer.GetInt32());
-  tokenizer.Next();
-  EXPECT_EQ(CBORTokenTag::DONE, tokenizer.TokenTag());
-}
-
-TEST(EncodeDecodeInt32Test, RoundtripsUint8) {
-  // This roundtrips the int32_t value 42 through the pair of EncodeInt32 /
-  // CBORTokenizer. This is different from Roundtrip23 because 42 is encoded
-  // in an extra byte after the initial one.
-  std::vector<uint8_t> encoded;
-  EncodeInt32(42, &encoded);
-  // first three bits: major type = 0;
-  // remaining five bits: additional info = 24, indicating payload is uint8.
-  EXPECT_THAT(encoded, ElementsAreArray(std::array<uint8_t, 2>{{24, 42}}));
-
-  // Reverse direction: decode with CBORTokenizer.
-  CBORTokenizer tokenizer(SpanFrom(encoded));
-  EXPECT_EQ(CBORTokenTag::INT32, tokenizer.TokenTag());
-  EXPECT_EQ(42, tokenizer.GetInt32());
-  tokenizer.Next();
-  EXPECT_EQ(CBORTokenTag::DONE, tokenizer.TokenTag());
-}
-
-TEST(EncodeDecodeInt32Test, RoundtripsUint16) {
-  // 500 is encoded as a uint16 after the initial byte.
-  std::vector<uint8_t> encoded;
-  EncodeInt32(500, &encoded);
-  // 1 for initial byte, 2 for uint16.
-  EXPECT_EQ(3u, encoded.size());
-  // first three bits: major type = 0;
-  // remaining five bits: additional info = 25, indicating payload is uint16.
-  EXPECT_EQ(25, encoded[0]);
-  EXPECT_EQ(0x01, encoded[1]);
-  EXPECT_EQ(0xf4, encoded[2]);
-
-  // Reverse direction: decode with CBORTokenizer.
-  CBORTokenizer tokenizer(SpanFrom(encoded));
-  EXPECT_EQ(CBORTokenTag::INT32, tokenizer.TokenTag());
-  EXPECT_EQ(500, tokenizer.GetInt32());
-  tokenizer.Next();
-  EXPECT_EQ(CBORTokenTag::DONE, tokenizer.TokenTag());
-}
-
-TEST(EncodeDecodeInt32Test, RoundtripsInt32Max) {
-  // std::numeric_limits<int32_t> is encoded as a uint32 after the initial byte.
-  std::vector<uint8_t> encoded;
-  EncodeInt32(std::numeric_limits<int32_t>::max(), &encoded);
-  // 1 for initial byte, 4 for the uint32.
-  // first three bits: major type = 0;
-  // remaining five bits: additional info = 26, indicating payload is uint32.
-  EXPECT_THAT(
-      encoded,
-      ElementsAreArray(std::array<uint8_t, 5>{{26, 0x7f, 0xff, 0xff, 0xff}}));
-
-  // Reverse direction: decode with CBORTokenizer.
-  CBORTokenizer tokenizer(SpanFrom(encoded));
-  EXPECT_EQ(CBORTokenTag::INT32, tokenizer.TokenTag());
-  EXPECT_EQ(std::numeric_limits<int32_t>::max(), tokenizer.GetInt32());
-  tokenizer.Next();
-  EXPECT_EQ(CBORTokenTag::DONE, tokenizer.TokenTag());
-}
-
-TEST(EncodeDecodeInt32Test, RoundtripsInt32Min) {
-  // std::numeric_limits<int32_t> is encoded as a uint32 (4 unsigned bytes)
-  // after the initial byte, which effectively carries the sign by
-  // designating the token as NEGATIVE.
-  std::vector<uint8_t> encoded;
-  EncodeInt32(std::numeric_limits<int32_t>::min(), &encoded);
-  // 1 for initial byte, 4 for the uint32.
-  // first three bits: major type = 1;
-  // remaining five bits: additional info = 26, indicating payload is uint32.
-  EXPECT_THAT(encoded, ElementsAreArray(std::array<uint8_t, 5>{
-                           {1 << 5 | 26, 0x7f, 0xff, 0xff, 0xff}}));
-
-  // Reverse direction: decode with CBORTokenizer.
-  CBORTokenizer tokenizer(SpanFrom(encoded));
-  EXPECT_EQ(CBORTokenTag::INT32, tokenizer.TokenTag());
-  EXPECT_EQ(std::numeric_limits<int32_t>::min(), tokenizer.GetInt32());
-  // It's nice to see how the min int32 value reads in hex:
-  // That is, -1 minus the unsigned payload (0x7fffffff, see above).
-  int32_t expected = -1 - 0x7fffffff;
-  EXPECT_EQ(expected, tokenizer.GetInt32());
-  tokenizer.Next();
-  EXPECT_EQ(CBORTokenTag::DONE, tokenizer.TokenTag());
-}
-
-TEST(EncodeDecodeInt32Test, CantRoundtripUint32) {
-  // 0xdeadbeef is a value which does not fit below
-  // std::numerical_limits<int32_t>::max(), so we can't encode
-  // it with EncodeInt32. However, CBOR does support this, so we
-  // encode it here manually with the internal routine, just to observe
-  // that it's considered an invalid int32 by CBORTokenizer.
-  std::vector<uint8_t> encoded;
-  internals::WriteTokenStart(MajorType::UNSIGNED, 0xdeadbeef, &encoded);
-  // 1 for initial byte, 4 for the uint32.
-  // first three bits: major type = 0;
-  // remaining five bits: additional info = 26, indicating payload is uint32.
-  EXPECT_THAT(
-      encoded,
-      ElementsAreArray(std::array<uint8_t, 5>{{26, 0xde, 0xad, 0xbe, 0xef}}));
-
-  // Now try to decode; we treat this as an invalid INT32.
-  CBORTokenizer tokenizer(SpanFrom(encoded));
-  // 0xdeadbeef is > std::numerical_limits<int32_t>::max().
-  EXPECT_EQ(CBORTokenTag::ERROR_VALUE, tokenizer.TokenTag());
-  EXPECT_EQ(Error::CBOR_INVALID_INT32, tokenizer.Status().error);
-}
-
-TEST(EncodeDecodeInt32Test, DecodeErrorCases) {
-  struct TestCase {
-    std::vector<uint8_t> data;
-    std::string msg;
-  };
-  std::vector<TestCase> tests{{
-      TestCase{
-          {24},
-          "additional info = 24 would require 1 byte of payload (but it's 0)"},
-      TestCase{{27, 0xaa, 0xbb, 0xcc},
-               "additional info = 27 would require 8 bytes of payload (but "
-               "it's 3)"},
-      TestCase{{29}, "additional info = 29 isn't recognized"},
-      TestCase{{1 << 5 | 27, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff},
-               "Max UINT64 payload is outside the allowed range"},
-      TestCase{{1 << 5 | 26, 0xff, 0xff, 0xff, 0xff},
-               "Max UINT32 payload is outside the allowed range"},
-      TestCase{{1 << 5 | 26, 0x80, 0x00, 0x00, 0x00},
-               "UINT32 payload w/ high bit set is outside the allowed range"},
-  }};
-  for (const TestCase& test : tests) {
-    SCOPED_TRACE(test.msg);
-    CBORTokenizer tokenizer(SpanFrom(test.data));
-    EXPECT_EQ(CBORTokenTag::ERROR_VALUE, tokenizer.TokenTag());
-    EXPECT_EQ(Error::CBOR_INVALID_INT32, tokenizer.Status().error);
-  }
-}
-
-TEST(EncodeDecodeInt32Test, RoundtripsMinus24) {
-  // This roundtrips the int32_t value -24 through the pair of EncodeInt32 /
-  // CBORTokenizer; this is interesting since -24 is encoded as
-  // a single byte as NEGATIVE, and it tests the specific encoding
-  // (note how for unsigned the single byte covers values up to 23).
-  // Additional examples are covered in RoundtripsAdditionalExamples.
-  std::vector<uint8_t> encoded;
-  EncodeInt32(-24, &encoded);
-  // first three bits: major type = 1; remaining five bits: additional info =
-  // value 23.
-  EXPECT_THAT(encoded, ElementsAreArray(std::array<uint8_t, 1>{{1 << 5 | 23}}));
-
-  // Reverse direction: decode with CBORTokenizer.
-  CBORTokenizer tokenizer(SpanFrom(encoded));
-  EXPECT_EQ(CBORTokenTag::INT32, tokenizer.TokenTag());
-  EXPECT_EQ(-24, tokenizer.GetInt32());
-  tokenizer.Next();
-  EXPECT_EQ(CBORTokenTag::DONE, tokenizer.TokenTag());
-}
-
-TEST(EncodeDecodeInt32Test, RoundtripsAdditionalNegativeExamples) {
-  std::vector<int32_t> examples = {-1,
-                                   -10,
-                                   -24,
-                                   -25,
-                                   -300,
-                                   -30000,
-                                   -300 * 1000,
-                                   -1000 * 1000,
-                                   -1000 * 1000 * 1000,
-                                   std::numeric_limits<int32_t>::min()};
-  for (int32_t example : examples) {
-    SCOPED_TRACE(std::string("example ") + std::to_string(example));
-    std::vector<uint8_t> encoded;
-    EncodeInt32(example, &encoded);
-    CBORTokenizer tokenizer(SpanFrom(encoded));
-    EXPECT_EQ(CBORTokenTag::INT32, tokenizer.TokenTag());
-    EXPECT_EQ(example, tokenizer.GetInt32());
-    tokenizer.Next();
-    EXPECT_EQ(CBORTokenTag::DONE, tokenizer.TokenTag());
-  }
-}
-
-//
-// EncodeString16 / CBORTokenTag::STRING16
-//
-TEST(EncodeDecodeString16Test, RoundtripsEmpty) {
-  // This roundtrips the empty utf16 string through the pair of EncodeString16 /
-  // CBORTokenizer.
-  std::vector<uint8_t> encoded;
-  EncodeString16(span<uint16_t>(), &encoded);
-  EXPECT_EQ(1u, encoded.size());
-  // first three bits: major type = 2; remaining five bits: additional info =
-  // size 0.
-  EXPECT_EQ(2 << 5, encoded[0]);
-
-  // Reverse direction: decode with CBORTokenizer.
-  CBORTokenizer tokenizer(SpanFrom(encoded));
-  EXPECT_EQ(CBORTokenTag::STRING16, tokenizer.TokenTag());
-  span<uint8_t> decoded_string16_wirerep = tokenizer.GetString16WireRep();
-  EXPECT_TRUE(decoded_string16_wirerep.empty());
-  tokenizer.Next();
-  EXPECT_EQ(CBORTokenTag::DONE, tokenizer.TokenTag());
-}
-
-// On the wire, we STRING16 is encoded as little endian (least
-// significant byte first). The host may or may not be little endian,
-// so this routine follows the advice in
-// https://commandcenter.blogspot.com/2012/04/byte-order-fallacy.html.
-std::vector<uint16_t> String16WireRepToHost(span<uint8_t> in) {
-  // must be even number of bytes.
-  CHECK_EQ(in.size() & 1, 0u);
-  std::vector<uint16_t> host_out;
-  for (size_t ii = 0; ii < in.size(); ii += 2)
-    host_out.push_back(in[ii + 1] << 8 | in[ii]);
-  return host_out;
-}
-
-TEST(EncodeDecodeString16Test, RoundtripsHelloWorld) {
-  // This roundtrips the hello world message which is given here in utf16
-  // characters. 0xd83c, 0xdf0e: UTF16 encoding for the "Earth Globe Americas"
-  // character, 🌎.
-  std::array<uint16_t, 10> msg{
-      {'H', 'e', 'l', 'l', 'o', ',', ' ', 0xd83c, 0xdf0e, '.'}};
-  std::vector<uint8_t> encoded;
-  EncodeString16(span<uint16_t>(msg.data(), msg.size()), &encoded);
-  // This will be encoded as BYTE_STRING of length 20, so the 20 is encoded in
-  // the additional info part of the initial byte. Payload is two bytes for each
-  // UTF16 character.
-  uint8_t initial_byte = /*major type=*/2 << 5 | /*additional info=*/20;
-  std::array<uint8_t, 21> encoded_expected = {
-      {initial_byte, 'H', 0,   'e', 0,    'l',  0,    'l',  0,   'o', 0,
-       ',',          0,   ' ', 0,   0x3c, 0xd8, 0x0e, 0xdf, '.', 0}};
-  EXPECT_THAT(encoded, ElementsAreArray(encoded_expected));
-
-  // Now decode to complete the roundtrip.
-  CBORTokenizer tokenizer(SpanFrom(encoded));
-  EXPECT_EQ(CBORTokenTag::STRING16, tokenizer.TokenTag());
-  std::vector<uint16_t> decoded =
-      String16WireRepToHost(tokenizer.GetString16WireRep());
-  EXPECT_THAT(decoded, ElementsAreArray(msg));
-  tokenizer.Next();
-  EXPECT_EQ(CBORTokenTag::DONE, tokenizer.TokenTag());
-
-  // For bonus points, we look at the decoded message in UTF8 as well so we can
-  // easily see it on the terminal screen.
-  std::string utf8_decoded = UTF16ToUTF8(SpanFrom(decoded));
-  EXPECT_EQ("Hello, 🌎.", utf8_decoded);
-}
-
-TEST(EncodeDecodeString16Test, Roundtrips500) {
-  // We roundtrip a message that has 250 16 bit values. Each of these are just
-  // set to their index. 250 is interesting because the cbor spec uses a
-  // BYTE_STRING of length 500 for one of their examples of how to encode the
-  // start of it (section 2.1) so it's easy for us to look at the first three
-  // bytes closely.
-  std::vector<uint16_t> two_fifty;
-  for (uint16_t ii = 0; ii < 250; ++ii)
-    two_fifty.push_back(ii);
-  std::vector<uint8_t> encoded;
-  EncodeString16(span<uint16_t>(two_fifty.data(), two_fifty.size()), &encoded);
-  EXPECT_EQ(3u + 250u * 2, encoded.size());
-  // Now check the first three bytes:
-  // Major type: 2 (BYTE_STRING)
-  // Additional information: 25, indicating size is represented by 2 bytes.
-  // Bytes 1 and 2 encode 500 (0x01f4).
-  EXPECT_EQ(2 << 5 | 25, encoded[0]);
-  EXPECT_EQ(0x01, encoded[1]);
-  EXPECT_EQ(0xf4, encoded[2]);
-
-  // Now decode to complete the roundtrip.
-  CBORTokenizer tokenizer(SpanFrom(encoded));
-  EXPECT_EQ(CBORTokenTag::STRING16, tokenizer.TokenTag());
-  std::vector<uint16_t> decoded =
-      String16WireRepToHost(tokenizer.GetString16WireRep());
-  EXPECT_THAT(decoded, ElementsAreArray(two_fifty));
-  tokenizer.Next();
-  EXPECT_EQ(CBORTokenTag::DONE, tokenizer.TokenTag());
-}
-
-TEST(EncodeDecodeString16Test, ErrorCases) {
-  struct TestCase {
-    std::vector<uint8_t> data;
-    std::string msg;
-  };
-  std::vector<TestCase> tests{
-      {TestCase{{2 << 5 | 1, 'a'},
-                "length must be divisible by 2 (but it's 1)"},
-       TestCase{{2 << 5 | 29}, "additional info = 29 isn't recognized"},
-       TestCase{{2 << 5 | 9, 1, 2, 3, 4, 5, 6, 7, 8},
-                "length (9) points just past the end of the test case"},
-       TestCase{{2 << 5 | 27, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                 'a', 'b', 'c'},
-                "large length pointing past the end of the test case"}}};
-  for (const TestCase& test : tests) {
-    SCOPED_TRACE(test.msg);
-    CBORTokenizer tokenizer(SpanFrom(test.data));
-    EXPECT_EQ(CBORTokenTag::ERROR_VALUE, tokenizer.TokenTag());
-    EXPECT_EQ(Error::CBOR_INVALID_STRING16, tokenizer.Status().error);
-  }
-}
-
-//
-// EncodeString8 / CBORTokenTag::STRING8
-//
-TEST(EncodeDecodeString8Test, RoundtripsHelloWorld) {
-  // This roundtrips the hello world message which is given here in utf8
-  // characters. 🌎 is a four byte utf8 character.
-  std::string utf8_msg = "Hello, 🌎.";
-  std::vector<uint8_t> msg(utf8_msg.begin(), utf8_msg.end());
-  std::vector<uint8_t> encoded;
-  EncodeString8(SpanFrom(utf8_msg), &encoded);
-  // This will be encoded as STRING of length 12, so the 12 is encoded in
-  // the additional info part of the initial byte. Payload is one byte per
-  // utf8 byte.
-  uint8_t initial_byte = /*major type=*/3 << 5 | /*additional info=*/12;
-  std::array<uint8_t, 13> encoded_expected = {{initial_byte, 'H', 'e', 'l', 'l',
-                                               'o', ',', ' ', 0xF0, 0x9f, 0x8c,
-                                               0x8e, '.'}};
-  EXPECT_THAT(encoded, ElementsAreArray(encoded_expected));
-
-  // Now decode to complete the roundtrip.
-  CBORTokenizer tokenizer(SpanFrom(encoded));
-  EXPECT_EQ(CBORTokenTag::STRING8, tokenizer.TokenTag());
-  std::vector<uint8_t> decoded(tokenizer.GetString8().begin(),
-                               tokenizer.GetString8().end());
-  EXPECT_THAT(decoded, ElementsAreArray(msg));
-  tokenizer.Next();
-  EXPECT_EQ(CBORTokenTag::DONE, tokenizer.TokenTag());
-}
-
-TEST(EncodeDecodeString8Test, ErrorCases) {
-  struct TestCase {
-    std::vector<uint8_t> data;
-    std::string msg;
-  };
-  std::vector<TestCase> tests{
-      {TestCase{{3 << 5 | 29}, "additional info = 29 isn't recognized"},
-       TestCase{{3 << 5 | 9, 1, 2, 3, 4, 5, 6, 7, 8},
-                "length (9) points just past the end of the test case"},
-       TestCase{{3 << 5 | 27, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-                 'a', 'b', 'c'},
-                "large length pointing past the end of the test case"}}};
-  for (const TestCase& test : tests) {
-    SCOPED_TRACE(test.msg);
-    CBORTokenizer tokenizer(SpanFrom(test.data));
-    EXPECT_EQ(CBORTokenTag::ERROR_VALUE, tokenizer.TokenTag());
-    EXPECT_EQ(Error::CBOR_INVALID_STRING8, tokenizer.Status().error);
-  }
-}
-
-TEST(EncodeFromLatin1Test, ConvertsToUTF8IfNeeded) {
-  std::vector<std::pair<std::string, std::string>> examples = {
-      {"Hello, world.", "Hello, world."},
-      {"Above: \xDC"
-       "ber",
-       "Above: Über"},
-      {"\xA5 500 are about \xA3 3.50; a y with umlaut is \xFF",
-       "¥ 500 are about £ 3.50; a y with umlaut is ÿ"}};
-
-  for (const auto& example : examples) {
-    const std::string& latin1 = example.first;
-    const std::string& expected_utf8 = example.second;
-    std::vector<uint8_t> encoded;
-    EncodeFromLatin1(SpanFrom(latin1), &encoded);
-    CBORTokenizer tokenizer(SpanFrom(encoded));
-    EXPECT_EQ(CBORTokenTag::STRING8, tokenizer.TokenTag());
-    std::vector<uint8_t> decoded(tokenizer.GetString8().begin(),
-                                 tokenizer.GetString8().end());
-    std::string decoded_str(decoded.begin(), decoded.end());
-    EXPECT_THAT(decoded_str, testing::Eq(expected_utf8));
-  }
-}
-
-TEST(EncodeFromUTF16Test, ConvertsToUTF8IfEasy) {
-  std::vector<uint16_t> ascii = {'e', 'a', 's', 'y'};
-  std::vector<uint8_t> encoded;
-  EncodeFromUTF16(span<uint16_t>(ascii.data(), ascii.size()), &encoded);
-
-  CBORTokenizer tokenizer(SpanFrom(encoded));
-  EXPECT_EQ(CBORTokenTag::STRING8, tokenizer.TokenTag());
-  std::vector<uint8_t> decoded(tokenizer.GetString8().begin(),
-                               tokenizer.GetString8().end());
-  std::string decoded_str(decoded.begin(), decoded.end());
-  EXPECT_THAT(decoded_str, testing::Eq("easy"));
-}
-
-TEST(EncodeFromUTF16Test, EncodesAsString16IfNeeded) {
-  // Since this message contains non-ASCII characters, the routine is
-  // forced to encode as UTF16. We see this below by checking that the
-  // token tag is STRING16.
-  std::vector<uint16_t> msg = {'H', 'e', 'l',    'l',    'o',
-                               ',', ' ', 0xd83c, 0xdf0e, '.'};
-  std::vector<uint8_t> encoded;
-  EncodeFromUTF16(span<uint16_t>(msg.data(), msg.size()), &encoded);
-
-  CBORTokenizer tokenizer(SpanFrom(encoded));
-  EXPECT_EQ(CBORTokenTag::STRING16, tokenizer.TokenTag());
-  std::vector<uint16_t> decoded =
-      String16WireRepToHost(tokenizer.GetString16WireRep());
-  std::string utf8_decoded = UTF16ToUTF8(SpanFrom(decoded));
-  EXPECT_EQ("Hello, 🌎.", utf8_decoded);
-}
-
-//
-// EncodeBinary / CBORTokenTag::BINARY
-//
-TEST(EncodeDecodeBinaryTest, RoundtripsHelloWorld) {
-  std::vector<uint8_t> binary = {'H', 'e', 'l', 'l', 'o', ',', ' ',
-                                 'w', 'o', 'r', 'l', 'd', '.'};
-  std::vector<uint8_t> encoded;
-  EncodeBinary(span<uint8_t>(binary.data(), binary.size()), &encoded);
-  // So, on the wire we see that the binary blob travels unmodified.
-  EXPECT_THAT(
-      encoded,
-      ElementsAreArray(std::array<uint8_t, 15>{
-          {(6 << 5 | 22),  // tag 22 indicating base64 interpretation in JSON
-           (2 << 5 | 13),  // BYTE_STRING (type 2) of length 13
-           'H', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '.'}}));
-  std::vector<uint8_t> decoded;
-  CBORTokenizer tokenizer(SpanFrom(encoded));
-  EXPECT_EQ(CBORTokenTag::BINARY, tokenizer.TokenTag());
-  EXPECT_EQ(0, static_cast<int>(tokenizer.Status().error));
-  decoded = std::vector<uint8_t>(tokenizer.GetBinary().begin(),
-                                 tokenizer.GetBinary().end());
-  EXPECT_THAT(decoded, ElementsAreArray(binary));
-  tokenizer.Next();
-  EXPECT_EQ(CBORTokenTag::DONE, tokenizer.TokenTag());
-}
-
-TEST(EncodeDecodeBinaryTest, ErrorCases) {
-  struct TestCase {
-    std::vector<uint8_t> data;
-    std::string msg;
-  };
-  std::vector<TestCase> tests{{TestCase{
-      {6 << 5 | 22,  // tag 22 indicating base64 interpretation in JSON
-       2 << 5 | 27,  // BYTE_STRING (type 2), followed by 8 bytes length
-       0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00},
-      "large length pointing past the end of the test case"}}};
-  for (const TestCase& test : tests) {
-    SCOPED_TRACE(test.msg);
-    CBORTokenizer tokenizer(SpanFrom(test.data));
-    EXPECT_EQ(CBORTokenTag::ERROR_VALUE, tokenizer.TokenTag());
-    EXPECT_EQ(Error::CBOR_INVALID_BINARY, tokenizer.Status().error);
-  }
-}
-
-//
-// EncodeDouble / CBORTokenTag::DOUBLE
-//
-TEST(EncodeDecodeDoubleTest, RoundtripsWikipediaExample) {
-  // https://en.wikipedia.org/wiki/Double-precision_floating-point_format
-  // provides the example of a hex representation 3FD5 5555 5555 5555, which
-  // approximates 1/3.
-
-  const double kOriginalValue = 1.0 / 3;
-  std::vector<uint8_t> encoded;
-  EncodeDouble(kOriginalValue, &encoded);
-  // first three bits: major type = 7; remaining five bits: additional info =
-  // value 27. This is followed by 8 bytes of payload (which match Wikipedia).
-  EXPECT_THAT(
-      encoded,
-      ElementsAreArray(std::array<uint8_t, 9>{
-          {7 << 5 | 27, 0x3f, 0xd5, 0x55, 0x55, 0x55, 0x55, 0x55, 0x55}}));
-
-  // Reverse direction: decode and compare with original value.
-  CBORTokenizer tokenizer(SpanFrom(encoded));
-  EXPECT_EQ(CBORTokenTag::DOUBLE, tokenizer.TokenTag());
-  EXPECT_THAT(tokenizer.GetDouble(), testing::DoubleEq(kOriginalValue));
-  tokenizer.Next();
-  EXPECT_EQ(CBORTokenTag::DONE, tokenizer.TokenTag());
-}
-
-TEST(EncodeDecodeDoubleTest, RoundtripsAdditionalExamples) {
-  std::vector<double> examples = {0.0,
-                                  1.0,
-                                  -1.0,
-                                  3.1415,
-                                  std::numeric_limits<double>::min(),
-                                  std::numeric_limits<double>::max(),
-                                  std::numeric_limits<double>::infinity(),
-                                  std::numeric_limits<double>::quiet_NaN()};
-  for (double example : examples) {
-    SCOPED_TRACE(std::string("example ") + std::to_string(example));
-    std::vector<uint8_t> encoded;
-    EncodeDouble(example, &encoded);
-    CBORTokenizer tokenizer(SpanFrom(encoded));
-    EXPECT_EQ(CBORTokenTag::DOUBLE, tokenizer.TokenTag());
-    if (std::isnan(example))
-      EXPECT_TRUE(std::isnan(tokenizer.GetDouble()));
-    else
-      EXPECT_THAT(tokenizer.GetDouble(), testing::DoubleEq(example));
-    tokenizer.Next();
-    EXPECT_EQ(CBORTokenTag::DONE, tokenizer.TokenTag());
-  }
-}
-
-// =============================================================================
-// cbor::NewCBOREncoder - for encoding from a streaming parser
-// =============================================================================
-
-void EncodeUTF8ForTest(const std::string& key, std::vector<uint8_t>* out) {
-  EncodeString8(SpanFrom(key), out);
-}
-TEST(JSONToCBOREncoderTest, SevenBitStrings) {
-  // When a string can be represented as 7 bit ASCII, the encoder will use the
-  // STRING (major Type 3) type, so the actual characters end up as bytes on the
-  // wire.
-  std::vector<uint8_t> encoded;
-  Status status;
-  std::unique_ptr<StreamingParserHandler> encoder =
-      NewCBOREncoder(&encoded, &status);
-  std::vector<uint16_t> utf16 = {'f', 'o', 'o'};
-  encoder->HandleString16(span<uint16_t>(utf16.data(), utf16.size()));
-  EXPECT_EQ(Error::OK, status.error);
-  // Here we assert that indeed, seven bit strings are represented as
-  // bytes on the wire, "foo" is just "foo".
-  EXPECT_THAT(encoded,
-              ElementsAreArray(std::array<uint8_t, 4>{
-                  {/*major type 3*/ 3 << 5 | /*length*/ 3, 'f', 'o', 'o'}}));
-}
-
-TEST(JsonCborRoundtrip, EncodingDecoding) {
-  // Hits all the cases except binary and error in StreamingParserHandler, first
-  // parsing a JSON message into CBOR, then parsing it back from CBOR into JSON.
-  std::string json =
-      "{"
-      "\"string\":\"Hello, \\ud83c\\udf0e.\","
-      "\"double\":3.1415,"
-      "\"int\":1,"
-      "\"negative int\":-1,"
-      "\"bool\":true,"
-      "\"null\":null,"
-      "\"array\":[1,2,3]"
-      "}";
-  std::vector<uint8_t> encoded;
-  Status status;
-  std::unique_ptr<StreamingParserHandler> encoder =
-      NewCBOREncoder(&encoded, &status);
-  span<uint8_t> ascii_in = SpanFrom(json);
-  json::ParseJSON(GetTestPlatform(), ascii_in, encoder.get());
-  std::vector<uint8_t> expected = {
-      0xd8,            // envelope
-      0x5a,            // byte string with 32 bit length
-      0,    0, 0, 94,  // length is 94 bytes
-  };
-  expected.push_back(0xbf);  // indef length map start
-  EncodeString8(SpanFrom("string"), &expected);
-  // This is followed by the encoded string for "Hello, 🌎."
-  // So, it's the same bytes that we tested above in
-  // EncodeDecodeString16Test.RoundtripsHelloWorld.
-  expected.push_back(/*major type=*/2 << 5 | /*additional info=*/20);
-  for (uint8_t ch : std::array<uint8_t, 20>{
-           {'H', 0, 'e', 0, 'l',  0,    'l',  0,    'o', 0,
-            ',', 0, ' ', 0, 0x3c, 0xd8, 0x0e, 0xdf, '.', 0}})
-    expected.push_back(ch);
-  EncodeString8(SpanFrom("double"), &expected);
-  EncodeDouble(3.1415, &expected);
-  EncodeString8(SpanFrom("int"), &expected);
-  EncodeInt32(1, &expected);
-  EncodeString8(SpanFrom("negative int"), &expected);
-  EncodeInt32(-1, &expected);
-  EncodeString8(SpanFrom("bool"), &expected);
-  expected.push_back(7 << 5 | 21);  // RFC 7049 Section 2.3, Table 2: true
-  EncodeString8(SpanFrom("null"), &expected);
-  expected.push_back(7 << 5 | 22);  // RFC 7049 Section 2.3, Table 2: null
-  EncodeString8(SpanFrom("array"), &expected);
-  expected.push_back(0xd8);  // envelope
-  expected.push_back(0x5a);  // byte string with 32 bit length
-  // the length is 5 bytes (that's up to end indef length array below).
-  for (uint8_t ch : std::array<uint8_t, 4>{{0, 0, 0, 5}})
-    expected.push_back(ch);
-  expected.push_back(0x9f);  // RFC 7049 Section 2.2.1, indef length array start
-  expected.push_back(1);     // Three UNSIGNED values (easy since Major Type 0)
-  expected.push_back(2);
-  expected.push_back(3);
-  expected.push_back(0xff);  // End indef length array
-  expected.push_back(0xff);  // End indef length map
-  EXPECT_TRUE(status.ok());
-  EXPECT_THAT(encoded, ElementsAreArray(expected));
-
-  // And now we roundtrip, decoding the message we just encoded.
-  std::string decoded;
-  std::unique_ptr<StreamingParserHandler> json_encoder =
-      NewJSONEncoder(&GetTestPlatform(), &decoded, &status);
-  ParseCBOR(span<uint8_t>(encoded.data(), encoded.size()), json_encoder.get());
-  EXPECT_EQ(Error::OK, status.error);
-  EXPECT_EQ(json, decoded);
-}
-
-TEST(JsonCborRoundtrip, MoreRoundtripExamples) {
-  std::vector<std::string> examples = {
-      // Tests that after closing a nested objects, additional key/value pairs
-      // are considered.
-      "{\"foo\":{\"bar\":1},\"baz\":2}", "{\"foo\":[1,2,3],\"baz\":2}"};
-  for (const std::string& json : examples) {
-    SCOPED_TRACE(std::string("example: ") + json);
-    std::vector<uint8_t> encoded;
-    Status status;
-    std::unique_ptr<StreamingParserHandler> encoder =
-        NewCBOREncoder(&encoded, &status);
-    span<uint8_t> ascii_in = SpanFrom(json);
-    ParseJSON(GetTestPlatform(), ascii_in, encoder.get());
-    std::string decoded;
-    std::unique_ptr<StreamingParserHandler> json_writer =
-        NewJSONEncoder(&GetTestPlatform(), &decoded, &status);
-    ParseCBOR(span<uint8_t>(encoded.data(), encoded.size()), json_writer.get());
-    EXPECT_EQ(Error::OK, status.error);
-    EXPECT_EQ(json, decoded);
-  }
-}
-
-TEST(JSONToCBOREncoderTest, HelloWorldBinary_WithTripToJson) {
-  // The StreamingParserHandler::HandleBinary is a special case: The JSON parser
-  // will never call this method, because JSON does not natively support the
-  // binary type. So, we can't fully roundtrip. However, the other direction
-  // works: binary will be rendered in JSON, as a base64 string. So, we make
-  // calls to the encoder directly here, to construct a message, and one of
-  // these calls is ::HandleBinary, to which we pass a "binary" string
-  // containing "Hello, world.".
-  std::vector<uint8_t> encoded;
-  Status status;
-  std::unique_ptr<StreamingParserHandler> encoder =
-      NewCBOREncoder(&encoded, &status);
-  encoder->HandleMapBegin();
-  // Emit a key.
-  std::vector<uint16_t> key = {'f', 'o', 'o'};
-  encoder->HandleString16(SpanFrom(key));
-  // Emit the binary payload, an arbitrary array of bytes that happens to
-  // be the ascii message "Hello, world.".
-  encoder->HandleBinary(SpanFrom(std::vector<uint8_t>{
-      'H', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '.'}));
-  encoder->HandleMapEnd();
-  EXPECT_EQ(Error::OK, status.error);
-
-  // Now drive the json writer via the CBOR decoder.
-  std::string decoded;
-  std::unique_ptr<StreamingParserHandler> json_writer =
-      NewJSONEncoder(&GetTestPlatform(), &decoded, &status);
-  ParseCBOR(SpanFrom(encoded), json_writer.get());
-  EXPECT_EQ(Error::OK, status.error);
-  EXPECT_EQ(Status::npos(), status.pos);
-  // "Hello, world." in base64 is "SGVsbG8sIHdvcmxkLg==".
-  EXPECT_EQ("{\"foo\":\"SGVsbG8sIHdvcmxkLg==\"}", decoded);
-}
-
-// =============================================================================
-// cbor::ParseCBOR - for receiving streaming parser events for CBOR messages
-// =============================================================================
-
-TEST(ParseCBORTest, ParseEmptyCBORMessage) {
-  // An envelope starting with 0xd8, 0x5a, with the byte length
-  // of 2, containing a map that's empty (0xbf for map
-  // start, and 0xff for map end).
-  std::vector<uint8_t> in = {0xd8, 0x5a, 0, 0, 0, 2, 0xbf, 0xff};
-  std::string out;
-  Status status;
-  std::unique_ptr<StreamingParserHandler> json_writer =
-      NewJSONEncoder(&GetTestPlatform(), &out, &status);
-  ParseCBOR(span<uint8_t>(in.data(), in.size()), json_writer.get());
-  EXPECT_EQ(Error::OK, status.error);
-  EXPECT_EQ("{}", out);
-}
-
-TEST(ParseCBORTest, ParseCBORHelloWorld) {
-  const uint8_t kPayloadLen = 27;
-  std::vector<uint8_t> bytes = {0xd8, 0x5a, 0, 0, 0, kPayloadLen};
-  bytes.push_back(0xbf);                            // start indef length map.
-  EncodeString8(SpanFrom("msg"), &bytes);           // key: msg
-  // Now write the value, the familiar "Hello, 🌎." where the globe is expressed
-  // as two utf16 chars.
-  bytes.push_back(/*major type=*/2 << 5 | /*additional info=*/20);
-  for (uint8_t ch : std::array<uint8_t, 20>{
-           {'H', 0, 'e', 0, 'l',  0,    'l',  0,    'o', 0,
-            ',', 0, ' ', 0, 0x3c, 0xd8, 0x0e, 0xdf, '.', 0}})
-    bytes.push_back(ch);
-  bytes.push_back(0xff);  // stop byte
-  EXPECT_EQ(kPayloadLen, bytes.size() - 6);
-
-  std::string out;
-  Status status;
-  std::unique_ptr<StreamingParserHandler> json_writer =
-      NewJSONEncoder(&GetTestPlatform(), &out, &status);
-  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-  EXPECT_EQ(Error::OK, status.error);
-  EXPECT_EQ("{\"msg\":\"Hello, \\ud83c\\udf0e.\"}", out);
-}
-
-TEST(ParseCBORTest, UTF8IsSupportedInKeys) {
-  const uint8_t kPayloadLen = 11;
-  std::vector<uint8_t> bytes = {cbor::InitialByteForEnvelope(),
-                                cbor::InitialByteFor32BitLengthByteString(),
-                                0,
-                                0,
-                                0,
-                                kPayloadLen};
-  bytes.push_back(cbor::EncodeIndefiniteLengthMapStart());
-  // Two UTF16 chars.
-  EncodeString8(SpanFrom("🌎"), &bytes);
-  // Can be encoded as a single UTF16 char.
-  EncodeString8(SpanFrom("☾"), &bytes);
-  bytes.push_back(cbor::EncodeStop());
-  EXPECT_EQ(kPayloadLen, bytes.size() - 6);
-
-  std::string out;
-  Status status;
-  std::unique_ptr<StreamingParserHandler> json_writer =
-      NewJSONEncoder(&GetTestPlatform(), &out, &status);
-  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-  EXPECT_EQ(Error::OK, status.error);
-  EXPECT_EQ("{\"\\ud83c\\udf0e\":\"\\u263e\"}", out);
-}
-
-TEST(ParseCBORTest, NoInputError) {
-  std::vector<uint8_t> in = {};
-  std::string out;
-  Status status;
-  std::unique_ptr<StreamingParserHandler> json_writer =
-      NewJSONEncoder(&GetTestPlatform(), &out, &status);
-  ParseCBOR(span<uint8_t>(in.data(), in.size()), json_writer.get());
-  EXPECT_EQ(Error::CBOR_NO_INPUT, status.error);
-  EXPECT_EQ("", out);
-}
-
-TEST(ParseCBORTest, InvalidStartByteError) {
-  // Here we test that some actual json, which usually starts with {,
-  // is not considered CBOR. CBOR messages must start with 0x5a, the
-  // envelope start byte.
-  std::string json = "{\"msg\": \"Hello, world.\"}";
-  std::string out;
-  Status status;
-  std::unique_ptr<StreamingParserHandler> json_writer =
-      NewJSONEncoder(&GetTestPlatform(), &out, &status);
-  ParseCBOR(SpanFrom(json), json_writer.get());
-  EXPECT_EQ(Error::CBOR_INVALID_START_BYTE, status.error);
-  EXPECT_EQ("", out);
-}
-
-TEST(ParseCBORTest, UnexpectedEofExpectedValueError) {
-  constexpr uint8_t kPayloadLen = 5;
-  std::vector<uint8_t> bytes = {0xd8, 0x5a, 0, 0, 0, kPayloadLen,  // envelope
-                                0xbf};                             // map start
-  // A key; so value would be next.
-  EncodeString8(SpanFrom("key"), &bytes);
-  EXPECT_EQ(kPayloadLen, bytes.size() - 6);
-  std::string out;
-  Status status;
-  std::unique_ptr<StreamingParserHandler> json_writer =
-      NewJSONEncoder(&GetTestPlatform(), &out, &status);
-  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-  EXPECT_EQ(Error::CBOR_UNEXPECTED_EOF_EXPECTED_VALUE, status.error);
-  EXPECT_EQ(bytes.size(), status.pos);
-  EXPECT_EQ("", out);
-}
-
-TEST(ParseCBORTest, UnexpectedEofInArrayError) {
-  constexpr uint8_t kPayloadLen = 8;
-  std::vector<uint8_t> bytes = {0xd8, 0x5a, 0, 0, 0, kPayloadLen,  // envelope
-                                0xbf};  // The byte for starting a map.
-  // A key; so value would be next.
-  EncodeString8(SpanFrom("array"), &bytes);
-  bytes.push_back(0x9f);  // byte for indefinite length array start.
-  EXPECT_EQ(kPayloadLen, bytes.size() - 6);
-  std::string out;
-  Status status;
-  std::unique_ptr<StreamingParserHandler> json_writer =
-      NewJSONEncoder(&GetTestPlatform(), &out, &status);
-  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-  EXPECT_EQ(Error::CBOR_UNEXPECTED_EOF_IN_ARRAY, status.error);
-  EXPECT_EQ(bytes.size(), status.pos);
-  EXPECT_EQ("", out);
-}
-
-TEST(ParseCBORTest, UnexpectedEofInMapError) {
-  constexpr uint8_t kPayloadLen = 1;
-  std::vector<uint8_t> bytes = {0xd8, 0x5a, 0, 0, 0, kPayloadLen,  // envelope
-                                0xbf};  // The byte for starting a map.
-  EXPECT_EQ(kPayloadLen, bytes.size() - 6);
-  std::string out;
-  Status status;
-  std::unique_ptr<StreamingParserHandler> json_writer =
-      NewJSONEncoder(&GetTestPlatform(), &out, &status);
-  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-  EXPECT_EQ(Error::CBOR_UNEXPECTED_EOF_IN_MAP, status.error);
-  EXPECT_EQ(7u, status.pos);
-  EXPECT_EQ("", out);
-}
-
-TEST(ParseCBORTest, InvalidMapKeyError) {
-  constexpr uint8_t kPayloadLen = 2;
-  std::vector<uint8_t> bytes = {0xd8,       0x5a, 0,
-                                0,          0,    kPayloadLen,  // envelope
-                                0xbf,                           // map start
-                                7 << 5 | 22};  // null (not a valid map key)
-  EXPECT_EQ(kPayloadLen, bytes.size() - 6);
-  std::string out;
-  Status status;
-  std::unique_ptr<StreamingParserHandler> json_writer =
-      NewJSONEncoder(&GetTestPlatform(), &out, &status);
-  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-  EXPECT_EQ(Error::CBOR_INVALID_MAP_KEY, status.error);
-  EXPECT_EQ(7u, status.pos);
-  EXPECT_EQ("", out);
-}
-
-std::vector<uint8_t> MakeNestedCBOR(int depth) {
-  std::vector<uint8_t> bytes;
-  std::vector<EnvelopeEncoder> envelopes;
-  for (int ii = 0; ii < depth; ++ii) {
-    envelopes.emplace_back();
-    envelopes.back().EncodeStart(&bytes);
-    bytes.push_back(0xbf);  // indef length map start
-    EncodeString8(SpanFrom("key"), &bytes);
-  }
-  EncodeString8(SpanFrom("innermost_value"), &bytes);
-  for (int ii = 0; ii < depth; ++ii) {
-    bytes.push_back(0xff);  // stop byte, finishes map.
-    envelopes.back().EncodeStop(&bytes);
-    envelopes.pop_back();
-  }
-  return bytes;
-}
-
-TEST(ParseCBORTest, StackLimitExceededError) {
-  {  // Depth 3: no stack limit exceeded error and is easy to inspect.
-    std::vector<uint8_t> bytes = MakeNestedCBOR(3);
-    std::string out;
-    Status status;
-    std::unique_ptr<StreamingParserHandler> json_writer =
-        NewJSONEncoder(&GetTestPlatform(), &out, &status);
-    ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-    EXPECT_EQ(Error::OK, status.error);
-    EXPECT_EQ(Status::npos(), status.pos);
-    EXPECT_EQ("{\"key\":{\"key\":{\"key\":\"innermost_value\"}}}", out);
-  }
-  {  // Depth 300: no stack limit exceeded.
-    std::vector<uint8_t> bytes = MakeNestedCBOR(300);
-    std::string out;
-    Status status;
-    std::unique_ptr<StreamingParserHandler> json_writer =
-        NewJSONEncoder(&GetTestPlatform(), &out, &status);
-    ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-    EXPECT_EQ(Error::OK, status.error);
-    EXPECT_EQ(Status::npos(), status.pos);
-  }
-
-  // We just want to know the length of one opening map so we can compute
-  // where the error is encountered. So we look at a small example and find
-  // the second envelope start.
-  std::vector<uint8_t> small_example = MakeNestedCBOR(3);
-  size_t opening_segment_size = 1;  // Start after the first envelope start.
-  while (opening_segment_size < small_example.size() &&
-         small_example[opening_segment_size] != 0xd8)
-    opening_segment_size++;
-
-  {  // Depth 301: limit exceeded.
-    std::vector<uint8_t> bytes = MakeNestedCBOR(301);
-    std::string out;
-    Status status;
-    std::unique_ptr<StreamingParserHandler> json_writer =
-        NewJSONEncoder(&GetTestPlatform(), &out, &status);
-    ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-    EXPECT_EQ(Error::CBOR_STACK_LIMIT_EXCEEDED, status.error);
-    EXPECT_EQ(opening_segment_size * 301, status.pos);
-  }
-  {  // Depth 320: still limit exceeded, and at the same pos as for 1001
-    std::vector<uint8_t> bytes = MakeNestedCBOR(320);
-    std::string out;
-    Status status;
-    std::unique_ptr<StreamingParserHandler> json_writer =
-        NewJSONEncoder(&GetTestPlatform(), &out, &status);
-    ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-    EXPECT_EQ(Error::CBOR_STACK_LIMIT_EXCEEDED, status.error);
-    EXPECT_EQ(opening_segment_size * 301, status.pos);
-  }
-}
-
-TEST(ParseCBORTest, UnsupportedValueError) {
-  constexpr uint8_t kPayloadLen = 6;
-  std::vector<uint8_t> bytes = {0xd8, 0x5a, 0, 0, 0, kPayloadLen,  // envelope
-                                0xbf};                             // map start
-  EncodeString8(SpanFrom("key"), &bytes);
-  size_t error_pos = bytes.size();
-  bytes.push_back(6 << 5 | 5);  // tags aren't supported yet.
-  EXPECT_EQ(kPayloadLen, bytes.size() - 6);
-
-  std::string out;
-  Status status;
-  std::unique_ptr<StreamingParserHandler> json_writer =
-      NewJSONEncoder(&GetTestPlatform(), &out, &status);
-  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-  EXPECT_EQ(Error::CBOR_UNSUPPORTED_VALUE, status.error);
-  EXPECT_EQ(error_pos, status.pos);
-  EXPECT_EQ("", out);
-}
-
-TEST(ParseCBORTest, InvalidString16Error) {
-  constexpr uint8_t kPayloadLen = 11;
-  std::vector<uint8_t> bytes = {0xd8, 0x5a, 0, 0, 0, kPayloadLen,  // envelope
-                                0xbf};                             // map start
-  EncodeString8(SpanFrom("key"), &bytes);
-  size_t error_pos = bytes.size();
-  // a BYTE_STRING of length 5 as value; since we interpret these as string16,
-  // it's going to be invalid as each character would need two bytes, but
-  // 5 isn't divisible by 2.
-  bytes.push_back(2 << 5 | 5);
-  for (int ii = 0; ii < 5; ++ii)
-    bytes.push_back(' ');
-  EXPECT_EQ(kPayloadLen, bytes.size() - 6);
-  std::string out;
-  Status status;
-  std::unique_ptr<StreamingParserHandler> json_writer =
-      NewJSONEncoder(&GetTestPlatform(), &out, &status);
-  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-  EXPECT_EQ(Error::CBOR_INVALID_STRING16, status.error);
-  EXPECT_EQ(error_pos, status.pos);
-  EXPECT_EQ("", out);
-}
-
-TEST(ParseCBORTest, InvalidString8Error) {
-  constexpr uint8_t kPayloadLen = 6;
-  std::vector<uint8_t> bytes = {0xd8, 0x5a, 0, 0, 0, kPayloadLen,  // envelope
-                                0xbf};                             // map start
-  EncodeString8(SpanFrom("key"), &bytes);
-  size_t error_pos = bytes.size();
-  // a STRING of length 5 as value, but we're at the end of the bytes array
-  // so it can't be decoded successfully.
-  bytes.push_back(3 << 5 | 5);
-  EXPECT_EQ(kPayloadLen, bytes.size() - 6);
-  std::string out;
-  Status status;
-  std::unique_ptr<StreamingParserHandler> json_writer =
-      NewJSONEncoder(&GetTestPlatform(), &out, &status);
-  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-  EXPECT_EQ(Error::CBOR_INVALID_STRING8, status.error);
-  EXPECT_EQ(error_pos, status.pos);
-  EXPECT_EQ("", out);
-}
-
-TEST(ParseCBORTest, InvalidBinaryError) {
-  constexpr uint8_t kPayloadLen = 9;
-  std::vector<uint8_t> bytes = {0xd8, 0x5a, 0, 0, 0, kPayloadLen,  // envelope
-                                0xbf};                             // map start
-  EncodeString8(SpanFrom("key"), &bytes);
-  size_t error_pos = bytes.size();
-  bytes.push_back(6 << 5 | 22);  // base64 hint for JSON; indicates binary
-  bytes.push_back(2 << 5 | 10);  // BYTE_STRING (major type 2) of length 10
-  // Just two garbage bytes, not enough for the binary.
-  bytes.push_back(0x31);
-  bytes.push_back(0x23);
-  EXPECT_EQ(kPayloadLen, bytes.size() - 6);
-  std::string out;
-  Status status;
-  std::unique_ptr<StreamingParserHandler> json_writer =
-      NewJSONEncoder(&GetTestPlatform(), &out, &status);
-  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-  EXPECT_EQ(Error::CBOR_INVALID_BINARY, status.error);
-  EXPECT_EQ(error_pos, status.pos);
-  EXPECT_EQ("", out);
-}
-
-TEST(ParseCBORTest, InvalidDoubleError) {
-  constexpr uint8_t kPayloadLen = 8;
-  std::vector<uint8_t> bytes = {0xd8, 0x5a, 0, 0, 0, kPayloadLen,  // envelope
-                                0xbf};                             // map start
-  EncodeString8(SpanFrom("key"), &bytes);
-  size_t error_pos = bytes.size();
-  bytes.push_back(7 << 5 | 27);  // initial byte for double
-  // Just two garbage bytes, not enough to represent an actual double.
-  bytes.push_back(0x31);
-  bytes.push_back(0x23);
-  EXPECT_EQ(kPayloadLen, bytes.size() - 6);
-  std::string out;
-  Status status;
-  std::unique_ptr<StreamingParserHandler> json_writer =
-      NewJSONEncoder(&GetTestPlatform(), &out, &status);
-  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-  EXPECT_EQ(Error::CBOR_INVALID_DOUBLE, status.error);
-  EXPECT_EQ(error_pos, status.pos);
-  EXPECT_EQ("", out);
-}
-
-TEST(ParseCBORTest, InvalidSignedError) {
-  constexpr uint8_t kPayloadLen = 14;
-  std::vector<uint8_t> bytes = {0xd8, 0x5a, 0, 0, 0, kPayloadLen,  // envelope
-                                0xbf};                             // map start
-  EncodeString8(SpanFrom("key"), &bytes);
-  size_t error_pos = bytes.size();
-  // uint64_t max is a perfectly fine value to encode as CBOR unsigned,
-  // but we don't support this since we only cover the int32_t range.
-  internals::WriteTokenStart(MajorType::UNSIGNED,
-                             std::numeric_limits<uint64_t>::max(), &bytes);
-  EXPECT_EQ(kPayloadLen, bytes.size() - 6);
-  std::string out;
-  Status status;
-  std::unique_ptr<StreamingParserHandler> json_writer =
-      NewJSONEncoder(&GetTestPlatform(), &out, &status);
-  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-  EXPECT_EQ(Error::CBOR_INVALID_INT32, status.error);
-  EXPECT_EQ(error_pos, status.pos);
-  EXPECT_EQ("", out);
-}
-
-TEST(ParseCBORTest, TrailingJunk) {
-  constexpr uint8_t kPayloadLen = 35;
-  std::vector<uint8_t> bytes = {0xd8, 0x5a, 0, 0, 0, kPayloadLen,  // envelope
-                                0xbf};                             // map start
-  EncodeString8(SpanFrom("key"), &bytes);
-  EncodeString8(SpanFrom("value"), &bytes);
-  bytes.push_back(0xff);  // Up to here, it's a perfectly fine msg.
-  size_t error_pos = bytes.size();
-  EncodeString8(SpanFrom("trailing junk"), &bytes);
-
-  internals::WriteTokenStart(MajorType::UNSIGNED,
-                             std::numeric_limits<uint64_t>::max(), &bytes);
-  EXPECT_EQ(kPayloadLen, bytes.size() - 6);
-  std::string out;
-  Status status;
-  std::unique_ptr<StreamingParserHandler> json_writer =
-      NewJSONEncoder(&GetTestPlatform(), &out, &status);
-  ParseCBOR(span<uint8_t>(bytes.data(), bytes.size()), json_writer.get());
-  EXPECT_EQ(Error::CBOR_TRAILING_JUNK, status.error);
-  EXPECT_EQ(error_pos, status.pos);
-  EXPECT_EQ("", out);
-}
-
-// =============================================================================
-// cbor::AppendString8EntryToMap - for limited in-place editing of messages
-// =============================================================================
-
-template <typename T>
-class AppendString8EntryToMapTest : public ::testing::Test {};
-
-using ContainerTestTypes = ::testing::Types<std::vector<uint8_t>, std::string>;
-TYPED_TEST_SUITE(AppendString8EntryToMapTest, ContainerTestTypes);
-
-TYPED_TEST(AppendString8EntryToMapTest, AppendsEntrySuccessfully) {
-  constexpr uint8_t kPayloadLen = 12;
-  std::vector<uint8_t> bytes = {0xd8, 0x5a, 0, 0, 0, kPayloadLen,  // envelope
-                                0xbf};                             // map start
-  size_t pos_before_payload = bytes.size() - 1;
-  EncodeString8(SpanFrom("key"), &bytes);
-  EncodeString8(SpanFrom("value"), &bytes);
-  bytes.push_back(0xff);  // A perfectly fine cbor message.
-  EXPECT_EQ(kPayloadLen, bytes.size() - pos_before_payload);
-
-  TypeParam msg(bytes.begin(), bytes.end());
-
-  Status status =
-      AppendString8EntryToCBORMap(SpanFrom("foo"), SpanFrom("bar"), &msg);
-  EXPECT_EQ(Error::OK, status.error);
-  EXPECT_EQ(Status::npos(), status.pos);
-  std::string out;
-  std::unique_ptr<StreamingParserHandler> json_writer =
-      NewJSONEncoder(&GetTestPlatform(), &out, &status);
-  ParseCBOR(SpanFrom(msg), json_writer.get());
-  EXPECT_EQ("{\"key\":\"value\",\"foo\":\"bar\"}", out);
-  EXPECT_EQ(Error::OK, status.error);
-  EXPECT_EQ(Status::npos(), status.pos);
-}
-
-TYPED_TEST(AppendString8EntryToMapTest, AppendThreeEntries) {
-  std::vector<uint8_t> encoded = {
-      0xd8, 0x5a, 0, 0, 0, 2, EncodeIndefiniteLengthMapStart(), EncodeStop()};
-  EXPECT_EQ(Error::OK, AppendString8EntryToCBORMap(SpanFrom("key"),
-                                                   SpanFrom("value"), &encoded)
-                           .error);
-  EXPECT_EQ(Error::OK, AppendString8EntryToCBORMap(SpanFrom("key1"),
-                                                   SpanFrom("value1"), &encoded)
-                           .error);
-  EXPECT_EQ(Error::OK, AppendString8EntryToCBORMap(SpanFrom("key2"),
-                                                   SpanFrom("value2"), &encoded)
-                           .error);
-  TypeParam msg(encoded.begin(), encoded.end());
-  std::string out;
-  Status status;
-  std::unique_ptr<StreamingParserHandler> json_writer =
-      NewJSONEncoder(&GetTestPlatform(), &out, &status);
-  ParseCBOR(SpanFrom(msg), json_writer.get());
-  EXPECT_EQ("{\"key\":\"value\",\"key1\":\"value1\",\"key2\":\"value2\"}", out);
-  EXPECT_EQ(Error::OK, status.error);
-  EXPECT_EQ(Status::npos(), status.pos);
-}
-
-TYPED_TEST(AppendString8EntryToMapTest, MapStartExpected_Error) {
-  std::vector<uint8_t> bytes = {
-      0xd8, 0x5a, 0, 0, 0, 1, EncodeIndefiniteLengthArrayStart()};
-  TypeParam msg(bytes.begin(), bytes.end());
-  Status status =
-      AppendString8EntryToCBORMap(SpanFrom("key"), SpanFrom("value"), &msg);
-  EXPECT_EQ(Error::CBOR_MAP_START_EXPECTED, status.error);
-  EXPECT_EQ(6u, status.pos);
-}
-
-TYPED_TEST(AppendString8EntryToMapTest, MapStopExpected_Error) {
-  std::vector<uint8_t> bytes = {
-      0xd8, 0x5a, 0, 0, 0, 2, EncodeIndefiniteLengthMapStart(), 42};
-  TypeParam msg(bytes.begin(), bytes.end());
-  Status status =
-      AppendString8EntryToCBORMap(SpanFrom("key"), SpanFrom("value"), &msg);
-  EXPECT_EQ(Error::CBOR_MAP_STOP_EXPECTED, status.error);
-  EXPECT_EQ(7u, status.pos);
-}
-
-TYPED_TEST(AppendString8EntryToMapTest, InvalidEnvelope_Error) {
-  {  // Second byte is wrong.
-    std::vector<uint8_t> bytes = {
-        0x5a, 0, 0, 0, 2, EncodeIndefiniteLengthMapStart(), EncodeStop(), 0};
-    TypeParam msg(bytes.begin(), bytes.end());
-    Status status =
-        AppendString8EntryToCBORMap(SpanFrom("key"), SpanFrom("value"), &msg);
-    EXPECT_EQ(Error::CBOR_INVALID_ENVELOPE, status.error);
-    EXPECT_EQ(0u, status.pos);
-  }
-  {  // Second byte is wrong.
-    std::vector<uint8_t> bytes = {
-        0xd8, 0x7a, 0, 0, 0, 2, EncodeIndefiniteLengthMapStart(), EncodeStop()};
-    TypeParam msg(bytes.begin(), bytes.end());
-    Status status =
-        AppendString8EntryToCBORMap(SpanFrom("key"), SpanFrom("value"), &msg);
-    EXPECT_EQ(Error::CBOR_INVALID_ENVELOPE, status.error);
-    EXPECT_EQ(0u, status.pos);
-  }
-  {  // Invalid envelope size example.
-    std::vector<uint8_t> bytes = {
-        0xd8, 0x5a, 0, 0, 0, 3, EncodeIndefiniteLengthMapStart(), EncodeStop(),
-    };
-    TypeParam msg(bytes.begin(), bytes.end());
-    Status status =
-        AppendString8EntryToCBORMap(SpanFrom("key"), SpanFrom("value"), &msg);
-    EXPECT_EQ(Error::CBOR_INVALID_ENVELOPE, status.error);
-    EXPECT_EQ(0u, status.pos);
-  }
-  {  // Invalid envelope size example.
-    std::vector<uint8_t> bytes = {
-        0xd8, 0x5a, 0, 0, 0, 1, EncodeIndefiniteLengthMapStart(), EncodeStop(),
-    };
-    TypeParam msg(bytes.begin(), bytes.end());
-    Status status =
-        AppendString8EntryToCBORMap(SpanFrom("key"), SpanFrom("value"), &msg);
-    EXPECT_EQ(Error::CBOR_INVALID_ENVELOPE, status.error);
-    EXPECT_EQ(0u, status.pos);
-  }
-}
-}  // namespace cbor
-
-namespace json {
-
-// =============================================================================
-// json::NewJSONEncoder - for encoding streaming parser events as JSON
-// =============================================================================
-
-void WriteUTF8AsUTF16(StreamingParserHandler* writer, const std::string& utf8) {
-  writer->HandleString16(SpanFrom(UTF8ToUTF16(SpanFrom(utf8))));
-}
-
-TEST(JsonEncoder, OverlongEncodings) {
-  std::string out;
-  Status status;
-  std::unique_ptr<StreamingParserHandler> writer =
-      NewJSONEncoder(&GetTestPlatform(), &out, &status);
-
-  // We encode 0x7f, which is the DEL ascii character, as a 4 byte UTF8
-  // sequence. This is called an overlong encoding, because only 1 byte
-  // is needed to represent 0x7f as UTF8.
-  std::vector<uint8_t> chars = {
-      0xf0,  // Starts 4 byte utf8 sequence
-      0x80,  // continuation byte
-      0x81,  // continuation byte w/ payload bit 7 set to 1.
-      0xbf,  // continuation byte w/ payload bits 0-6 set to 11111.
-  };
-  writer->HandleString8(SpanFrom(chars));
-  EXPECT_EQ("\"\"", out);  // Empty string means that 0x7f was rejected (good).
-}
-
-TEST(JsonStdStringWriterTest, HelloWorld) {
-  std::string out;
-  Status status;
-  std::unique_ptr<StreamingParserHandler> writer =
-      NewJSONEncoder(&GetTestPlatform(), &out, &status);
-  writer->HandleMapBegin();
-  WriteUTF8AsUTF16(writer.get(), "msg1");
-  WriteUTF8AsUTF16(writer.get(), "Hello, 🌎.");
-  std::string key = "msg1-as-utf8";
-  std::string value = "Hello, 🌎.";
-  writer->HandleString8(SpanFrom(key));
-  writer->HandleString8(SpanFrom(value));
-  WriteUTF8AsUTF16(writer.get(), "msg2");
-  WriteUTF8AsUTF16(writer.get(), "\\\b\r\n\t\f\"");
-  WriteUTF8AsUTF16(writer.get(), "nested");
-  writer->HandleMapBegin();
-  WriteUTF8AsUTF16(writer.get(), "double");
-  writer->HandleDouble(3.1415);
-  WriteUTF8AsUTF16(writer.get(), "int");
-  writer->HandleInt32(-42);
-  WriteUTF8AsUTF16(writer.get(), "bool");
-  writer->HandleBool(false);
-  WriteUTF8AsUTF16(writer.get(), "null");
-  writer->HandleNull();
-  writer->HandleMapEnd();
-  WriteUTF8AsUTF16(writer.get(), "array");
-  writer->HandleArrayBegin();
-  writer->HandleInt32(1);
-  writer->HandleInt32(2);
-  writer->HandleInt32(3);
-  writer->HandleArrayEnd();
-  writer->HandleMapEnd();
-  EXPECT_TRUE(status.ok());
-  EXPECT_EQ(
-      "{\"msg1\":\"Hello, \\ud83c\\udf0e.\","
-      "\"msg1-as-utf8\":\"Hello, \\ud83c\\udf0e.\","
-      "\"msg2\":\"\\\\\\b\\r\\n\\t\\f\\\"\","
-      "\"nested\":{\"double\":3.1415,\"int\":-42,"
-      "\"bool\":false,\"null\":null},\"array\":[1,2,3]}",
-      out);
-}
-
-TEST(JsonStdStringWriterTest, RepresentingNonFiniteValuesAsNull) {
-  // JSON can't represent +Infinity, -Infinity, or NaN.
-  // So in practice it's mapped to null.
-  std::string out;
-  Status status;
-  std::unique_ptr<StreamingParserHandler> writer =
-      NewJSONEncoder(&GetTestPlatform(), &out, &status);
-  writer->HandleMapBegin();
-  writer->HandleString8(SpanFrom("Infinity"));
-  writer->HandleDouble(std::numeric_limits<double>::infinity());
-  writer->HandleString8(SpanFrom("-Infinity"));
-  writer->HandleDouble(-std::numeric_limits<double>::infinity());
-  writer->HandleString8(SpanFrom("NaN"));
-  writer->HandleDouble(std::numeric_limits<double>::quiet_NaN());
-  writer->HandleMapEnd();
-  EXPECT_TRUE(status.ok());
-  EXPECT_EQ("{\"Infinity\":null,\"-Infinity\":null,\"NaN\":null}", out);
-}
-
-TEST(JsonStdStringWriterTest, BinaryEncodedAsJsonString) {
-  // The encoder emits binary submitted to StreamingParserHandler::HandleBinary
-  // as base64. The following three examples are taken from
-  // https://en.wikipedia.org/wiki/Base64.
-  {
-    std::string out;
-    Status status;
-    std::unique_ptr<StreamingParserHandler> writer =
-        NewJSONEncoder(&GetTestPlatform(), &out, &status);
-    writer->HandleBinary(SpanFrom(std::vector<uint8_t>({'M', 'a', 'n'})));
-    EXPECT_TRUE(status.ok());
-    EXPECT_EQ("\"TWFu\"", out);
-  }
-  {
-    std::string out;
-    Status status;
-    std::unique_ptr<StreamingParserHandler> writer =
-        NewJSONEncoder(&GetTestPlatform(), &out, &status);
-    writer->HandleBinary(SpanFrom(std::vector<uint8_t>({'M', 'a'})));
-    EXPECT_TRUE(status.ok());
-    EXPECT_EQ("\"TWE=\"", out);
-  }
-  {
-    std::string out;
-    Status status;
-    std::unique_ptr<StreamingParserHandler> writer =
-        NewJSONEncoder(&GetTestPlatform(), &out, &status);
-    writer->HandleBinary(SpanFrom(std::vector<uint8_t>({'M'})));
-    EXPECT_TRUE(status.ok());
-    EXPECT_EQ("\"TQ==\"", out);
-  }
-  {  // "Hello, world.", verified with base64decode.org.
-    std::string out;
-    Status status;
-    std::unique_ptr<StreamingParserHandler> writer =
-        NewJSONEncoder(&GetTestPlatform(), &out, &status);
-    writer->HandleBinary(SpanFrom(std::vector<uint8_t>(
-        {'H', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '.'})));
-    EXPECT_TRUE(status.ok());
-    EXPECT_EQ("\"SGVsbG8sIHdvcmxkLg==\"", out);
-  }
-}
-
-TEST(JsonStdStringWriterTest, HandlesErrors) {
-  // When an error is sent via HandleError, it saves it in the provided
-  // status and clears the output.
-  std::string out;
-  Status status;
-  std::unique_ptr<StreamingParserHandler> writer =
-      NewJSONEncoder(&GetTestPlatform(), &out, &status);
-  writer->HandleMapBegin();
-  WriteUTF8AsUTF16(writer.get(), "msg1");
-  writer->HandleError(Status{Error::JSON_PARSER_VALUE_EXPECTED, 42});
-  EXPECT_EQ(Error::JSON_PARSER_VALUE_EXPECTED, status.error);
-  EXPECT_EQ(42u, status.pos);
-  EXPECT_EQ("", out);
-}
-
-// We'd use Gmock but unfortunately it only handles copyable return types.
-class MockPlatform : public Platform {
- public:
-  // Not implemented.
-  bool StrToD(const char* str, double* result) const override { return false; }
-
-  // A map with pre-registered responses for DToSTr.
-  std::map<double, std::string> dtostr_responses_;
-
-  std::unique_ptr<char[]> DToStr(double value) const override {
-    auto it = dtostr_responses_.find(value);
-    CHECK(it != dtostr_responses_.end());
-    const std::string& str = it->second;
-    std::unique_ptr<char[]> response(new char[str.size() + 1]);
-    memcpy(response.get(), str.c_str(), str.size() + 1);
-    return response;
-  }
-};
-
-TEST(JsonStdStringWriterTest, DoubleToString) {
-  // This "broken" platform responds without the leading 0 before the
-  // decimal dot, so it'd be invalid JSON.
-  MockPlatform platform;
-  platform.dtostr_responses_[.1] = ".1";
-  platform.dtostr_responses_[-.7] = "-.7";
-
-  std::string out;
-  Status status;
-  std::unique_ptr<StreamingParserHandler> writer =
-      NewJSONEncoder(&platform, &out, &status);
-  writer->HandleArrayBegin();
-  writer->HandleDouble(.1);
-  writer->HandleDouble(-.7);
-  writer->HandleArrayEnd();
-  EXPECT_EQ("[0.1,-0.7]", out);
-}
-
-// =============================================================================
-// json::ParseJSON - for receiving streaming parser events for JSON
-// =============================================================================
-
-class Log : public StreamingParserHandler {
- public:
-  void HandleMapBegin() override { log_ << "map begin\n"; }
-
-  void HandleMapEnd() override { log_ << "map end\n"; }
-
-  void HandleArrayBegin() override { log_ << "array begin\n"; }
-
-  void HandleArrayEnd() override { log_ << "array end\n"; }
-
-  void HandleString8(span<uint8_t> chars) override {
-    log_ << "string8: " << std::string(chars.begin(), chars.end()) << "\n";
-  }
-
-  void HandleString16(span<uint16_t> chars) override {
-    log_ << "string16: " << UTF16ToUTF8(chars) << "\n";
-  }
-
-  void HandleBinary(span<uint8_t> bytes) override {
-    // JSON doesn't have native support for arbitrary bytes, so our parser will
-    // never call this.
-    CHECK(false);
-  }
-
-  void HandleDouble(double value) override {
-    log_ << "double: " << value << "\n";
-  }
-
-  void HandleInt32(int32_t value) override { log_ << "int: " << value << "\n"; }
-
-  void HandleBool(bool value) override { log_ << "bool: " << value << "\n"; }
-
-  void HandleNull() override { log_ << "null\n"; }
-
-  void HandleError(Status status) override { status_ = status; }
-
-  std::string str() const { return status_.ok() ? log_.str() : ""; }
-
-  Status status() const { return status_; }
-
- private:
-  std::ostringstream log_;
-  Status status_;
-};
-
-class JsonParserTest : public ::testing::Test {
- protected:
-  Log log_;
-};
-
-TEST_F(JsonParserTest, SimpleDictionary) {
-  std::string json = "{\"foo\": 42}";
-  ParseJSON(GetTestPlatform(), SpanFrom(json), &log_);
-  EXPECT_TRUE(log_.status().ok());
-  EXPECT_EQ(
-      "map begin\n"
-      "string16: foo\n"
-      "int: 42\n"
-      "map end\n",
-      log_.str());
-}
-
-TEST_F(JsonParserTest, UsAsciiDelCornerCase) {
-  // DEL (0x7f) is a 7 bit US-ASCII character, and while it is a control
-  // character according to Unicode, it's not considered a control
-  // character in https://tools.ietf.org/html/rfc7159#section-7, so
-  // it can be placed directly into the JSON string, without JSON escaping.
-  std::string json = "{\"foo\": \"a\x7f\"}";
-  ParseJSON(GetTestPlatform(), SpanFrom(json), &log_);
-  EXPECT_TRUE(log_.status().ok());
-  EXPECT_EQ(
-      "map begin\n"
-      "string16: foo\n"
-      "string16: a\x7f\n"
-      "map end\n",
-      log_.str());
-
-  // We've seen an implementation of UTF16ToUTF8 which would replace the DEL
-  // character with ' ', so this simple roundtrip tests the routines in
-  // encoding_test_helper.h, to make test failures of the above easier to
-  // diagnose.
-  std::vector<uint16_t> utf16 = UTF8ToUTF16(SpanFrom(json));
-  EXPECT_EQ(json, UTF16ToUTF8(SpanFrom(utf16)));
-}
-
-TEST_F(JsonParserTest, Whitespace) {
-  std::string json = "\n  {\n\"msg\"\n: \v\"Hello, world.\"\t\r}\t";
-  ParseJSON(GetTestPlatform(), SpanFrom(json), &log_);
-  EXPECT_TRUE(log_.status().ok());
-  EXPECT_EQ(
-      "map begin\n"
-      "string16: msg\n"
-      "string16: Hello, world.\n"
-      "map end\n",
-      log_.str());
-}
-
-TEST_F(JsonParserTest, NestedDictionary) {
-  std::string json = "{\"foo\": {\"bar\": {\"baz\": 1}, \"bar2\": 2}}";
-  ParseJSON(GetTestPlatform(), SpanFrom(json), &log_);
-  EXPECT_TRUE(log_.status().ok());
-  EXPECT_EQ(
-      "map begin\n"
-      "string16: foo\n"
-      "map begin\n"
-      "string16: bar\n"
-      "map begin\n"
-      "string16: baz\n"
-      "int: 1\n"
-      "map end\n"
-      "string16: bar2\n"
-      "int: 2\n"
-      "map end\n"
-      "map end\n",
-      log_.str());
-}
-
-TEST_F(JsonParserTest, Doubles) {
-  std::string json = "{\"foo\": 3.1415, \"bar\": 31415e-4}";
-  ParseJSON(GetTestPlatform(), SpanFrom(json), &log_);
-  EXPECT_TRUE(log_.status().ok());
-  EXPECT_EQ(
-      "map begin\n"
-      "string16: foo\n"
-      "double: 3.1415\n"
-      "string16: bar\n"
-      "double: 3.1415\n"
-      "map end\n",
-      log_.str());
-}
-
-TEST_F(JsonParserTest, Unicode) {
-  // Globe character. 0xF0 0x9F 0x8C 0x8E in utf8, 0xD83C 0xDF0E in utf16.
-  std::string json = "{\"msg\": \"Hello, \\uD83C\\uDF0E.\"}";
-  ParseJSON(GetTestPlatform(), SpanFrom(json), &log_);
-  EXPECT_TRUE(log_.status().ok());
-  EXPECT_EQ(
-      "map begin\n"
-      "string16: msg\n"
-      "string16: Hello, 🌎.\n"
-      "map end\n",
-      log_.str());
-}
-
-TEST_F(JsonParserTest, Unicode_ParseUtf16) {
-  // Globe character. utf8: 0xF0 0x9F 0x8C 0x8E; utf16: 0xD83C 0xDF0E.
-  // Crescent moon character. utf8: 0xF0 0x9F 0x8C 0x99; utf16: 0xD83C 0xDF19.
-
-  // We provide the moon with json escape, but the earth as utf16 input.
-  // Either way they arrive as utf8 (after decoding in log_.str()).
-  std::vector<uint16_t> json =
-      UTF8ToUTF16(SpanFrom("{\"space\": \"🌎 \\uD83C\\uDF19.\"}"));
-  ParseJSON(GetTestPlatform(), SpanFrom(json), &log_);
-  EXPECT_TRUE(log_.status().ok());
-  EXPECT_EQ(
-      "map begin\n"
-      "string16: space\n"
-      "string16: 🌎 🌙.\n"
-      "map end\n",
-      log_.str());
-}
-
-TEST_F(JsonParserTest, Unicode_ParseUtf8) {
-  // Used below:
-  // гласность - example for 2 byte utf8, Russian word "glasnost"
-  // 屋 - example for 3 byte utf8, Chinese word for "house"
-  // 🌎 - example for 4 byte utf8: 0xF0 0x9F 0x8C 0x8E; utf16: 0xD83C 0xDF0E.
-  // 🌙 - example for escapes: utf8: 0xF0 0x9F 0x8C 0x99; utf16: 0xD83C 0xDF19.
-
-  // We provide the moon with json escape, but the earth as utf8 input.
-  // Either way they arrive as utf8 (after decoding in log_.str()).
-  std::string json =
-      "{"
-      "\"escapes\": \"\\uD83C\\uDF19\","
-      "\"2 byte\":\"гласность\","
-      "\"3 byte\":\"屋\","
-      "\"4 byte\":\"🌎\""
-      "}";
-  ParseJSON(GetTestPlatform(), SpanFrom(json), &log_);
-  EXPECT_TRUE(log_.status().ok());
-  EXPECT_EQ(
-      "map begin\n"
-      "string16: escapes\n"
-      "string16: 🌙\n"
-      "string16: 2 byte\n"
-      "string16: гласность\n"
-      "string16: 3 byte\n"
-      "string16: 屋\n"
-      "string16: 4 byte\n"
-      "string16: 🌎\n"
-      "map end\n",
-      log_.str());
-}
-
-TEST_F(JsonParserTest, UnprocessedInputRemainsError) {
-  // Trailing junk after the valid JSON.
-  std::string json = "{\"foo\": 3.1415} junk";
-  size_t junk_idx = json.find("junk");
-  EXPECT_NE(junk_idx, std::string::npos);
-  ParseJSON(GetTestPlatform(), SpanFrom(json), &log_);
-  EXPECT_EQ(Error::JSON_PARSER_UNPROCESSED_INPUT_REMAINS, log_.status().error);
-  EXPECT_EQ(junk_idx, log_.status().pos);
-  EXPECT_EQ("", log_.str());
-}
-
-std::string MakeNestedJson(int depth) {
-  std::string json;
-  for (int ii = 0; ii < depth; ++ii)
-    json += "{\"foo\":";
-  json += "42";
-  for (int ii = 0; ii < depth; ++ii)
-    json += "}";
-  return json;
-}
-
-TEST_F(JsonParserTest, StackLimitExceededError_BelowLimit) {
-  // kStackLimit is 300 (see json_parser.cc). First let's
-  // try with a small nested example.
-  std::string json_3 = MakeNestedJson(3);
-  ParseJSON(GetTestPlatform(), SpanFrom(json_3), &log_);
-  EXPECT_TRUE(log_.status().ok());
-  EXPECT_EQ(
-      "map begin\n"
-      "string16: foo\n"
-      "map begin\n"
-      "string16: foo\n"
-      "map begin\n"
-      "string16: foo\n"
-      "int: 42\n"
-      "map end\n"
-      "map end\n"
-      "map end\n",
-      log_.str());
-}
-
-TEST_F(JsonParserTest, StackLimitExceededError_AtLimit) {
-  // Now with kStackLimit (300).
-  std::string json_limit = MakeNestedJson(300);
-  ParseJSON(GetTestPlatform(),
-            span<uint8_t>(reinterpret_cast<const uint8_t*>(json_limit.data()),
-                          json_limit.size()),
-            &log_);
-  EXPECT_TRUE(log_.status().ok());
-}
-
-TEST_F(JsonParserTest, StackLimitExceededError_AboveLimit) {
-  // Now with kStackLimit + 1 (301) - it exceeds in the innermost instance.
-  std::string exceeded = MakeNestedJson(301);
-  ParseJSON(GetTestPlatform(), SpanFrom(exceeded), &log_);
-  EXPECT_EQ(Error::JSON_PARSER_STACK_LIMIT_EXCEEDED, log_.status().error);
-  EXPECT_EQ(strlen("{\"foo\":") * 301, log_.status().pos);
-}
-
-TEST_F(JsonParserTest, StackLimitExceededError_WayAboveLimit) {
-  // Now way past the limit. Still, the point of exceeding is 301.
-  std::string far_out = MakeNestedJson(320);
-  ParseJSON(GetTestPlatform(), SpanFrom(far_out), &log_);
-  EXPECT_EQ(Error::JSON_PARSER_STACK_LIMIT_EXCEEDED, log_.status().error);
-  EXPECT_EQ(strlen("{\"foo\":") * 301, log_.status().pos);
-}
-
-TEST_F(JsonParserTest, NoInputError) {
-  std::string json = "";
-  ParseJSON(GetTestPlatform(), SpanFrom(json), &log_);
-  EXPECT_EQ(Error::JSON_PARSER_NO_INPUT, log_.status().error);
-  EXPECT_EQ(0u, log_.status().pos);
-  EXPECT_EQ("", log_.str());
-}
-
-TEST_F(JsonParserTest, InvalidTokenError) {
-  std::string json = "|";
-  ParseJSON(GetTestPlatform(), SpanFrom(json), &log_);
-  EXPECT_EQ(Error::JSON_PARSER_INVALID_TOKEN, log_.status().error);
-  EXPECT_EQ(0u, log_.status().pos);
-  EXPECT_EQ("", log_.str());
-}
-
-TEST_F(JsonParserTest, InvalidNumberError) {
-  // Mantissa exceeds max (the constant used here is int64_t max).
-  std::string json = "1E9223372036854775807";
-  ParseJSON(GetTestPlatform(), SpanFrom(json), &log_);
-  EXPECT_EQ(Error::JSON_PARSER_INVALID_NUMBER, log_.status().error);
-  EXPECT_EQ(0u, log_.status().pos);
-  EXPECT_EQ("", log_.str());
-}
-
-TEST_F(JsonParserTest, InvalidStringError) {
-  // \x22 is an unsupported escape sequence
-  std::string json = "\"foo\\x22\"";
-  ParseJSON(GetTestPlatform(), SpanFrom(json), &log_);
-  EXPECT_EQ(Error::JSON_PARSER_INVALID_STRING, log_.status().error);
-  EXPECT_EQ(0u, log_.status().pos);
-  EXPECT_EQ("", log_.str());
-}
-
-TEST_F(JsonParserTest, UnexpectedArrayEndError) {
-  std::string json = "[1,2,]";
-  ParseJSON(GetTestPlatform(), SpanFrom(json), &log_);
-  EXPECT_EQ(Error::JSON_PARSER_UNEXPECTED_ARRAY_END, log_.status().error);
-  EXPECT_EQ(5u, log_.status().pos);
-  EXPECT_EQ("", log_.str());
-}
-
-TEST_F(JsonParserTest, CommaOrArrayEndExpectedError) {
-  std::string json = "[1,2 2";
-  ParseJSON(GetTestPlatform(), SpanFrom(json), &log_);
-  EXPECT_EQ(Error::JSON_PARSER_COMMA_OR_ARRAY_END_EXPECTED,
-            log_.status().error);
-  EXPECT_EQ(5u, log_.status().pos);
-  EXPECT_EQ("", log_.str());
-}
-
-TEST_F(JsonParserTest, StringLiteralExpectedError) {
-  // There's an error because the key bar, a string, is not terminated.
-  std::string json = "{\"foo\": 3.1415, \"bar: 31415e-4}";
-  ParseJSON(GetTestPlatform(), SpanFrom(json), &log_);
-  EXPECT_EQ(Error::JSON_PARSER_STRING_LITERAL_EXPECTED, log_.status().error);
-  EXPECT_EQ(16u, log_.status().pos);
-  EXPECT_EQ("", log_.str());
-}
-
-TEST_F(JsonParserTest, ColonExpectedError) {
-  std::string json = "{\"foo\", 42}";
-  ParseJSON(GetTestPlatform(), SpanFrom(json), &log_);
-  EXPECT_EQ(Error::JSON_PARSER_COLON_EXPECTED, log_.status().error);
-  EXPECT_EQ(6u, log_.status().pos);
-  EXPECT_EQ("", log_.str());
-}
-
-TEST_F(JsonParserTest, UnexpectedMapEndError) {
-  std::string json = "{\"foo\": 42, }";
-  ParseJSON(GetTestPlatform(), SpanFrom(json), &log_);
-  EXPECT_EQ(Error::JSON_PARSER_UNEXPECTED_MAP_END, log_.status().error);
-  EXPECT_EQ(12u, log_.status().pos);
-  EXPECT_EQ("", log_.str());
-}
-
-TEST_F(JsonParserTest, CommaOrMapEndExpectedError) {
-  // The second separator should be a comma.
-  std::string json = "{\"foo\": 3.1415: \"bar\": 0}";
-  ParseJSON(GetTestPlatform(), SpanFrom(json), &log_);
-  EXPECT_EQ(Error::JSON_PARSER_COMMA_OR_MAP_END_EXPECTED, log_.status().error);
-  EXPECT_EQ(14u, log_.status().pos);
-  EXPECT_EQ("", log_.str());
-}
-
-TEST_F(JsonParserTest, ValueExpectedError) {
-  std::string json = "}";
-  ParseJSON(GetTestPlatform(), SpanFrom(json), &log_);
-  EXPECT_EQ(Error::JSON_PARSER_VALUE_EXPECTED, log_.status().error);
-  EXPECT_EQ(0u, log_.status().pos);
-  EXPECT_EQ("", log_.str());
-}
-
-template <typename T>
-class ConvertJSONToCBORTest : public ::testing::Test {};
-
-using ContainerTestTypes = ::testing::Types<std::vector<uint8_t>, std::string>;
-TYPED_TEST_SUITE(ConvertJSONToCBORTest, ContainerTestTypes);
-
-TYPED_TEST(ConvertJSONToCBORTest, RoundTripValidJson) {
-  std::string json_in = "{\"msg\":\"Hello, world.\",\"lst\":[1,2,3]}";
-  TypeParam json(json_in.begin(), json_in.end());
-  TypeParam cbor;
-  {
-    Status status = ConvertJSONToCBOR(GetTestPlatform(), SpanFrom(json), &cbor);
-    EXPECT_EQ(Error::OK, status.error);
-    EXPECT_EQ(Status::npos(), status.pos);
-  }
-  TypeParam roundtrip_json;
-  {
-    Status status =
-        ConvertCBORToJSON(GetTestPlatform(), SpanFrom(cbor), &roundtrip_json);
-    EXPECT_EQ(Error::OK, status.error);
-    EXPECT_EQ(Status::npos(), status.pos);
-  }
-  EXPECT_EQ(json, roundtrip_json);
-}
-
-TYPED_TEST(ConvertJSONToCBORTest, RoundTripValidJson16) {
-  std::vector<uint16_t> json16 = {
-      '{', '"', 'm', 's',    'g',    '"', ':', '"', 'H', 'e', 'l', 'l',
-      'o', ',', ' ', 0xd83c, 0xdf0e, '.', '"', ',', '"', 'l', 's', 't',
-      '"', ':', '[', '1',    ',',    '2', ',', '3', ']', '}'};
-  TypeParam cbor;
-  {
-    Status status = ConvertJSONToCBOR(
-        GetTestPlatform(), span<uint16_t>(json16.data(), json16.size()), &cbor);
-    EXPECT_EQ(Error::OK, status.error);
-    EXPECT_EQ(Status::npos(), status.pos);
-  }
-  TypeParam roundtrip_json;
-  {
-    Status status =
-        ConvertCBORToJSON(GetTestPlatform(), SpanFrom(cbor), &roundtrip_json);
-    EXPECT_EQ(Error::OK, status.error);
-    EXPECT_EQ(Status::npos(), status.pos);
-  }
-  std::string json = "{\"msg\":\"Hello, \\ud83c\\udf0e.\",\"lst\":[1,2,3]}";
-  TypeParam expected_json(json.begin(), json.end());
-  EXPECT_EQ(expected_json, roundtrip_json);
-}
-}  // namespace json
-}  // namespace v8_inspector_protocol_encoding
diff --git a/tools/inspector_protocol/encoding/encoding_test_helper.h b/tools/inspector_protocol/encoding/encoding_test_helper.h
deleted file mode 100644
index 84da2e72e87f5c..00000000000000
--- a/tools/inspector_protocol/encoding/encoding_test_helper.h
+++ /dev/null
@@ -1,33 +0,0 @@
-// Copyright 2019 The V8 Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// This file is V8 specific, to make encoding_test.cc work.
-// It is not rolled from the upstream project.
-
-#ifndef V8_INSPECTOR_PROTOCOL_ENCODING_ENCODING_TEST_HELPER_H_
-#define V8_INSPECTOR_PROTOCOL_ENCODING_ENCODING_TEST_HELPER_H_
-
-#include <string>
-#include <vector>
-
-#include "src/base/logging.h"
-#include "src/inspector/v8-string-conversions.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace v8_inspector_protocol_encoding {
-
-std::string UTF16ToUTF8(span<uint16_t> in) {
-  return v8_inspector::UTF16ToUTF8(in.data(), in.size());
-}
-
-std::vector<uint16_t> UTF8ToUTF16(span<uint8_t> in) {
-  std::basic_string<uint16_t> utf16 = v8_inspector::UTF8ToUTF16(
-      reinterpret_cast<const char*>(in.data()), in.size());
-  return std::vector<uint16_t>(utf16.begin(), utf16.end());
-}
-
-}  // namespace v8_inspector_protocol_encoding
-
-#endif  // V8_INSPECTOR_PROTOCOL_ENCODING_ENCODING_TEST_HELPER_H_
diff --git a/tools/inspector_protocol/roll.py b/tools/inspector_protocol/roll.py
index a2bbd5d3f69336..474d163c30a123 100644
--- a/tools/inspector_protocol/roll.py
+++ b/tools/inspector_protocol/roll.py
@@ -13,17 +13,19 @@
 
 
 FILES_TO_SYNC = [
-    'README.md',
+    'crdtp/*',
+    'lib/*',
+    'templates/*',
+
+    'BUILD.gn',
     'check_protocol_compatibility.py',
     'code_generator.py',
     'concatenate_protocols.py',
     'convert_protocol_to_json.py',
-    'crdtp/*',
     'inspector_protocol.gni',
-    'inspector_protocol.gypi',
-    'lib/*',
+    'README.md',
+    'LICENSE',
     'pdl.py',
-    'templates/*',
 ]
 
 REVISION_LINE_PREFIX = 'Revision: '
@@ -96,7 +98,7 @@ def GetHeadRevision(path):
 def main(argv):
   parser = argparse.ArgumentParser(description=(
       "Rolls the inspector_protocol project (upstream) into node's "
-      "tools/inspector_protocol (downstream)."))
+      "deps/inspector_protocol (downstream)."))
   parser.add_argument("--ip_src_upstream",
                       help="The inspector_protocol (upstream) tree.",
                       default="~/ip/src")
@@ -126,7 +128,7 @@ def main(argv):
   CheckoutRevision(upstream, v8_ip_revision)
 
   src_dir = upstream
-  dest_dir = os.path.join(downstream, 'tools/inspector_protocol')
+  dest_dir = os.path.join(downstream, 'deps/inspector_protocol')
   print('Rolling %s into %s ...' % (src_dir, dest_dir))
   src_files = set(FindFilesToSyncIn(src_dir))
   dest_files = set(FindFilesToSyncIn(dest_dir))

From 1263efdfca224682300498cf8594e3d96b93fa47 Mon Sep 17 00:00:00 2001
From: Rich Trott <rtrott@gmail.com>
Date: Sun, 26 Jan 2025 16:02:05 -0800
Subject: [PATCH 34/38] test: use strict mode in global setters test

test-global-setters.js was added in
https://github.com/nodejs/node/pull/26882 and hasn't been modified
since. It appears that it avoids strict mode so that unscoped
identifiers are treated as globals, but that's true in strict mode too.
(In sloppy mode, an assignment to an undefined identifier will create a
global, but that's not what this test does. In strict mode, those
assignments will throw an error, which would seem to be what we would
want.)

PR-URL: https://github.com/nodejs/node/pull/56742
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Guy Bedford <guybedford@gmail.com>
---
 test/parallel/test-global-setters.js | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/test/parallel/test-global-setters.js b/test/parallel/test-global-setters.js
index 2da1097867261f..42f2b69b37b408 100644
--- a/test/parallel/test-global-setters.js
+++ b/test/parallel/test-global-setters.js
@@ -1,4 +1,10 @@
-/* eslint-disable strict */
+// When setters and getters were added for global.process and global.Buffer to
+// create a deprecation path for them in ESM, this test was added to make sure
+// the setters and getters behaved as expected.
+// Ref: https://github.com/nodejs/node/pull/26882
+// Ref: https://github.com/nodejs/node/pull/26334
+
+'use strict';
 require('../common');
 const assert = require('assert');
 const _process = require('process');

From 04f147b0245ac22fc983ddc7d9d0efd3ec69ee38 Mon Sep 17 00:00:00 2001
From: Luigi Pinca <luigipinca@gmail.com>
Date: Mon, 27 Jan 2025 11:09:37 +0100
Subject: [PATCH 35/38] test: fix invalid common.mustSucceed() usage

By its own nature, the function returned by `common.mustSucceed()`
cannot be used as a listener for `'error'` events.

Write errors like `read ECONNRESET` or `write EPIPE`, should be ignored
because the socket might be closed by the other peer while the request
is sent.

Refs: https://github.com/nodejs/node/commit/3caa2c1a005652fdb3e8
PR-URL: https://github.com/nodejs/node/pull/56756
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Rafael Gonzaga <rafael.nunu@hotmail.com>
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
---
 ...-server-headers-timeout-delayed-headers.js | 12 ++++++----
 ...ver-headers-timeout-interrupted-headers.js | 12 ++++++----
 ...ttp-server-request-timeout-delayed-body.js | 24 ++++++++++---------
 ...-server-request-timeout-delayed-headers.js | 12 ++++++----
 ...server-request-timeout-interrupted-body.js | 12 ++++++----
 ...ver-request-timeout-interrupted-headers.js | 12 ++++++----
 6 files changed, 48 insertions(+), 36 deletions(-)

diff --git a/test/parallel/test-http-server-headers-timeout-delayed-headers.js b/test/parallel/test-http-server-headers-timeout-delayed-headers.js
index af4a5df4b7f530..844dfebdd8c5de 100644
--- a/test/parallel/test-http-server-headers-timeout-delayed-headers.js
+++ b/test/parallel/test-http-server-headers-timeout-delayed-headers.js
@@ -38,16 +38,18 @@ server.listen(0, common.mustCall(() => {
     response += chunk;
   }));
 
-  const errOrEnd = common.mustSucceed(function(err) {
+  client.on('error', () => {
+    // Ignore errors like 'write EPIPE' that might occur while the request is
+    // sent.
+  });
+
+  client.on('close', common.mustCall(() => {
     assert.strictEqual(
       response,
       'HTTP/1.1 408 Request Timeout\r\nConnection: close\r\n\r\n'
     );
     server.close();
-  });
-
-  client.on('end', errOrEnd);
-  client.on('error', errOrEnd);
+  }));
 
   client.resume();
 
diff --git a/test/parallel/test-http-server-headers-timeout-interrupted-headers.js b/test/parallel/test-http-server-headers-timeout-interrupted-headers.js
index 9d25940ec65cd1..790e98499f9529 100644
--- a/test/parallel/test-http-server-headers-timeout-interrupted-headers.js
+++ b/test/parallel/test-http-server-headers-timeout-interrupted-headers.js
@@ -38,16 +38,18 @@ server.listen(0, common.mustCall(() => {
     response += chunk;
   }));
 
-  const errOrEnd = common.mustSucceed(function(err) {
+  client.on('error', () => {
+    // Ignore errors like 'write EPIPE' that might occur while the request is
+    // sent.
+  });
+
+  client.on('close', common.mustCall(() => {
     assert.strictEqual(
       response,
       'HTTP/1.1 408 Request Timeout\r\nConnection: close\r\n\r\n'
     );
     server.close();
-  });
-
-  client.on('end', errOrEnd);
-  client.on('error', errOrEnd);
+  }));
 
   client.resume();
   client.write('GET / HTTP/1.1\r\n');
diff --git a/test/parallel/test-http-server-request-timeout-delayed-body.js b/test/parallel/test-http-server-request-timeout-delayed-body.js
index fdfbbb2f4cb4e8..053b4f849b6191 100644
--- a/test/parallel/test-http-server-request-timeout-delayed-body.js
+++ b/test/parallel/test-http-server-request-timeout-delayed-body.js
@@ -45,6 +45,19 @@ server.listen(0, common.mustCall(() => {
     response += chunk;
   }));
 
+  client.on('error', () => {
+    // Ignore errors like 'write EPIPE' that might occur while the request is
+    // sent.
+  });
+
+  client.on('close', common.mustCall(() => {
+    assert.strictEqual(
+      response,
+      'HTTP/1.1 408 Request Timeout\r\nConnection: close\r\n\r\n'
+    );
+    server.close();
+  }));
+
   client.resume();
   client.write('POST / HTTP/1.1\r\n');
   client.write('Host: example.com\r\n');
@@ -57,15 +70,4 @@ server.listen(0, common.mustCall(() => {
       client.write('12345678901234567890\r\n\r\n');
     }, common.platformTimeout(requestTimeout * 2)).unref();
   });
-
-  const errOrEnd = common.mustSucceed(function(err) {
-    assert.strictEqual(
-      response,
-      'HTTP/1.1 408 Request Timeout\r\nConnection: close\r\n\r\n'
-    );
-    server.close();
-  });
-
-  client.on('end', errOrEnd);
-  client.on('error', errOrEnd);
 }));
diff --git a/test/parallel/test-http-server-request-timeout-delayed-headers.js b/test/parallel/test-http-server-request-timeout-delayed-headers.js
index 304a78b96a77d3..5176adc8e5a249 100644
--- a/test/parallel/test-http-server-request-timeout-delayed-headers.js
+++ b/test/parallel/test-http-server-request-timeout-delayed-headers.js
@@ -33,16 +33,18 @@ server.listen(0, common.mustCall(() => {
     response += chunk;
   }));
 
-  const errOrEnd = common.mustSucceed(function(err) {
+  client.on('error', () => {
+    // Ignore errors like 'write EPIPE' that might occur while the request is
+    // sent.
+  });
+
+  client.on('close', common.mustCall(() => {
     assert.strictEqual(
       response,
       'HTTP/1.1 408 Request Timeout\r\nConnection: close\r\n\r\n'
     );
     server.close();
-  });
-
-  client.on('end', errOrEnd);
-  client.on('error', errOrEnd);
+  }));
 
   client.resume();
 
diff --git a/test/parallel/test-http-server-request-timeout-interrupted-body.js b/test/parallel/test-http-server-request-timeout-interrupted-body.js
index 82c2f3171736a6..02d81d7bb7d8be 100644
--- a/test/parallel/test-http-server-request-timeout-interrupted-body.js
+++ b/test/parallel/test-http-server-request-timeout-interrupted-body.js
@@ -45,16 +45,18 @@ server.listen(0, common.mustCall(() => {
     response += chunk;
   }));
 
-  const errOrEnd = common.mustSucceed(function(err) {
+  client.on('error', () => {
+    // Ignore errors like 'write EPIPE' that might occur while the request is
+    // sent.
+  });
+
+  client.on('close', common.mustCall(() => {
     assert.strictEqual(
       response,
       'HTTP/1.1 408 Request Timeout\r\nConnection: close\r\n\r\n'
     );
     server.close();
-  });
-
-  client.on('error', errOrEnd);
-  client.on('end', errOrEnd);
+  }));
 
   client.resume();
   client.write('POST / HTTP/1.1\r\n');
diff --git a/test/parallel/test-http-server-request-timeout-interrupted-headers.js b/test/parallel/test-http-server-request-timeout-interrupted-headers.js
index eb9914dad1f56a..856f45d8e117e4 100644
--- a/test/parallel/test-http-server-request-timeout-interrupted-headers.js
+++ b/test/parallel/test-http-server-request-timeout-interrupted-headers.js
@@ -33,16 +33,18 @@ server.listen(0, common.mustCall(() => {
     response += chunk;
   }));
 
-  const errOrEnd = common.mustSucceed(function(err) {
+  client.on('error', () => {
+    // Ignore errors like 'write EPIPE' that might occur while the request is
+    // sent.
+  });
+
+  client.on('close', common.mustCall(() => {
     assert.strictEqual(
       response,
       'HTTP/1.1 408 Request Timeout\r\nConnection: close\r\n\r\n'
     );
     server.close();
-  });
-
-  client.on('end', errOrEnd);
-  client.on('error', errOrEnd);
+  }));
 
   client.resume();
   client.write('GET / HTTP/1.1\r\n');

From 50d405a2b6db859fe5e0f67c71b0b706e89cd5f2 Mon Sep 17 00:00:00 2001
From: Luigi Pinca <luigipinca@gmail.com>
Date: Mon, 27 Jan 2025 11:35:11 +0100
Subject: [PATCH 36/38] test: reduce number of written chunks

Reduce chances of write errors while the request is sent.

Refs: https://github.com/nodejs/node/pull/56756
PR-URL: https://github.com/nodejs/node/pull/56757
Reviewed-By: James M Snell <jasnell@gmail.com>
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Stefan Stojanovic <stefan.stojanovic@janeasystems.com>
---
 ...t-http-server-headers-timeout-delayed-headers.js | 10 ++++++----
 ...tp-server-headers-timeout-interrupted-headers.js |  8 +++++---
 ...test-http-server-request-timeout-delayed-body.js | 11 ++++++-----
 ...t-http-server-request-timeout-delayed-headers.js | 10 ++++++----
 ...-http-server-request-timeout-interrupted-body.js | 13 +++++++------
 ...tp-server-request-timeout-interrupted-headers.js |  8 +++++---
 6 files changed, 35 insertions(+), 25 deletions(-)

diff --git a/test/parallel/test-http-server-headers-timeout-delayed-headers.js b/test/parallel/test-http-server-headers-timeout-delayed-headers.js
index 844dfebdd8c5de..652969ae324cdf 100644
--- a/test/parallel/test-http-server-headers-timeout-delayed-headers.js
+++ b/test/parallel/test-http-server-headers-timeout-delayed-headers.js
@@ -55,10 +55,12 @@ server.listen(0, common.mustCall(() => {
 
   sendDelayedRequestHeaders = common.mustCall(() => {
     setTimeout(() => {
-      client.write('POST / HTTP/1.1\r\n');
-      client.write('Content-Length: 20\r\n');
-      client.write('Connection: close\r\n\r\n');
-      client.write('12345678901234567890\r\n\r\n');
+      client.write(
+        'POST / HTTP/1.1\r\n' +
+        'Content-Length: 20\r\n' +
+        'Connection: close\r\n\r\n' +
+        '12345678901234567890\r\n\r\n'
+      );
     }, common.platformTimeout(headersTimeout * 2)).unref();
   });
 }));
diff --git a/test/parallel/test-http-server-headers-timeout-interrupted-headers.js b/test/parallel/test-http-server-headers-timeout-interrupted-headers.js
index 790e98499f9529..863057dc2819f5 100644
--- a/test/parallel/test-http-server-headers-timeout-interrupted-headers.js
+++ b/test/parallel/test-http-server-headers-timeout-interrupted-headers.js
@@ -52,9 +52,11 @@ server.listen(0, common.mustCall(() => {
   }));
 
   client.resume();
-  client.write('GET / HTTP/1.1\r\n');
-  client.write('Connection: close\r\n');
-  client.write('X-CRASH: ');
+  client.write(
+    'GET / HTTP/1.1\r\n' +
+    'Connection: close\r\n' +
+    'X-CRASH: '
+  );
 
   sendDelayedRequestHeaders = common.mustCall(() => {
     setTimeout(() => {
diff --git a/test/parallel/test-http-server-request-timeout-delayed-body.js b/test/parallel/test-http-server-request-timeout-delayed-body.js
index 053b4f849b6191..2bc6b55a6fcb76 100644
--- a/test/parallel/test-http-server-request-timeout-delayed-body.js
+++ b/test/parallel/test-http-server-request-timeout-delayed-body.js
@@ -59,11 +59,12 @@ server.listen(0, common.mustCall(() => {
   }));
 
   client.resume();
-  client.write('POST / HTTP/1.1\r\n');
-  client.write('Host: example.com\r\n');
-  client.write('Content-Length: 20\r\n');
-  client.write('Connection: close\r\n');
-  client.write('\r\n');
+  client.write(
+    'POST / HTTP/1.1\r\n' +
+    'Host: example.com\r\n' +
+    'Content-Length: 20\r\n' +
+    'Connection: close\r\n\r\n'
+  );
 
   sendDelayedRequestBody = common.mustCall(() => {
     setTimeout(() => {
diff --git a/test/parallel/test-http-server-request-timeout-delayed-headers.js b/test/parallel/test-http-server-request-timeout-delayed-headers.js
index 5176adc8e5a249..e0d4945ec927e1 100644
--- a/test/parallel/test-http-server-request-timeout-delayed-headers.js
+++ b/test/parallel/test-http-server-request-timeout-delayed-headers.js
@@ -50,10 +50,12 @@ server.listen(0, common.mustCall(() => {
 
   sendDelayedRequestHeaders = common.mustCall(() => {
     setTimeout(() => {
-      client.write('POST / HTTP/1.1\r\n');
-      client.write('Content-Length: 20\r\n');
-      client.write('Connection: close\r\n\r\n');
-      client.write('12345678901234567890\r\n\r\n');
+      client.write(
+        'POST / HTTP/1.1\r\n' +
+        'Content-Length: 20\r\n' +
+        'Connection: close\r\n\r\n' +
+        '12345678901234567890\r\n\r\n'
+      );
     }, common.platformTimeout(requestTimeout * 2)).unref();
   });
 }));
diff --git a/test/parallel/test-http-server-request-timeout-interrupted-body.js b/test/parallel/test-http-server-request-timeout-interrupted-body.js
index 02d81d7bb7d8be..97e0a21d53d747 100644
--- a/test/parallel/test-http-server-request-timeout-interrupted-body.js
+++ b/test/parallel/test-http-server-request-timeout-interrupted-body.js
@@ -59,12 +59,13 @@ server.listen(0, common.mustCall(() => {
   }));
 
   client.resume();
-  client.write('POST / HTTP/1.1\r\n');
-  client.write('Host: example.com\r\n');
-  client.write('Content-Length: 20\r\n');
-  client.write('Connection: close\r\n');
-  client.write('\r\n');
-  client.write('1234567890');
+  client.write(
+    'POST / HTTP/1.1\r\n' +
+    'Host: example.com\r\n' +
+    'Content-Length: 20\r\n' +
+    'Connection: close\r\n\r\n' +
+    '1234567890'
+  );
 
   sendDelayedRequestBody = common.mustCall(() => {
     setTimeout(() => {
diff --git a/test/parallel/test-http-server-request-timeout-interrupted-headers.js b/test/parallel/test-http-server-request-timeout-interrupted-headers.js
index 856f45d8e117e4..752156ed0ed9da 100644
--- a/test/parallel/test-http-server-request-timeout-interrupted-headers.js
+++ b/test/parallel/test-http-server-request-timeout-interrupted-headers.js
@@ -47,9 +47,11 @@ server.listen(0, common.mustCall(() => {
   }));
 
   client.resume();
-  client.write('GET / HTTP/1.1\r\n');
-  client.write('Connection: close\r\n');
-  client.write('X-CRASH: ');
+  client.write(
+    'GET / HTTP/1.1\r\n' +
+    'Connection: close\r\n' +
+    'X-CRASH: '
+  );
 
   sendDelayedRequestHeaders = common.mustCall(() => {
     setTimeout(() => {

From 33dc9bcc8711ad0c9395d8465cd28193e51a23ff Mon Sep 17 00:00:00 2001
From: Michael Dawson <midawson@redhat.com>
Date: Mon, 27 Jan 2025 15:32:02 -0500
Subject: [PATCH 37/38] doc: move anatoli to emeritus
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Michael Dawson <midawson@redhat.com>
PR-URL: https://github.com/nodejs/node/pull/56592
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Reviewed-By: Ulises Gascón <ulisesgascongonzalez@gmail.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Ruy Adorno <ruy@vlt.sh>
---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 563e89a2807b9a..efdf46e15dfd9d 100644
--- a/README.md
+++ b/README.md
@@ -197,8 +197,6 @@ For information about the governance of the Node.js project, see
 
 #### TSC regular members
 
-* [apapirovski](https://github.com/apapirovski) -
-  **Anatoli Papirovski** <<apapirovski@mac.com>> (he/him)
 * [BethGriggs](https://github.com/BethGriggs) -
   **Beth Griggs** <<bethanyngriggs@gmail.com>> (she/her)
 * [bnoordhuis](https://github.com/bnoordhuis) -
@@ -222,6 +220,8 @@ For information about the governance of the Node.js project, see
 
 * [addaleax](https://github.com/addaleax) -
   **Anna Henningsen** <<anna@addaleax.net>> (she/her)
+* [apapirovski](https://github.com/apapirovski) -
+  **Anatoli Papirovski** <<apapirovski@mac.com>> (he/him)
 * [ChALkeR](https://github.com/ChALkeR) -
   **Сковорода Никита Андреевич** <<chalkerx@gmail.com>> (he/him)
 * [chrisdickinson](https://github.com/chrisdickinson) -

From 532fff6b27be6b0d833d06b4a9fe46d6fb7f0f6c Mon Sep 17 00:00:00 2001
From: "Node.js GitHub Bot" <github-bot@iojs.org>
Date: Mon, 27 Jan 2025 17:15:54 -0500
Subject: [PATCH 38/38] meta: move one or more collaborators to emeritus
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

PR-URL: https://github.com/nodejs/node/pull/56580
Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
Reviewed-By: Antoine du Hamel <duhamelantoine1995@gmail.com>
Reviewed-By: Michael Dawson <midawson@redhat.com>
Reviewed-By: Yagiz Nizipli <yagiz@nizipli.com>
Reviewed-By: Benjamin Gruenbaum <benjamingr@gmail.com>
Reviewed-By: Matteo Collina <matteo.collina@gmail.com>
Reviewed-By: Michaël Zasso <targos@protonmail.com>
Reviewed-By: Ulises Gascón <ulisesgascongonzalez@gmail.com>
Reviewed-By: Ruben Bridgewater <ruben@bridgewater.de>
Reviewed-By: Rafael Gonzaga <rafael.nunu@hotmail.com>
---
 README.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index efdf46e15dfd9d..c66bc8a36231e0 100644
--- a/README.md
+++ b/README.md
@@ -291,8 +291,6 @@ For information about the governance of the Node.js project, see
   **Antoine du Hamel** <<duhamelantoine1995@gmail.com>> (he/him) - [Support me](https://github.com/sponsors/aduh95)
 * [anonrig](https://github.com/anonrig) -
   **Yagiz Nizipli** <<yagiz@nizipli.com>> (he/him) - [Support me](https://github.com/sponsors/anonrig)
-* [apapirovski](https://github.com/apapirovski) -
-  **Anatoli Papirovski** <<apapirovski@mac.com>> (he/him)
 * [atlowChemi](https://github.com/atlowChemi) -
   **Chemi Atlow** <<chemi@atlow.co.il>> (he/him)
 * [Ayase-252](https://github.com/Ayase-252) -
@@ -475,6 +473,8 @@ For information about the governance of the Node.js project, see
   **Anna M. Kedzierska** <<anna.m.kedzierska@gmail.com>>
 * [antsmartian](https://github.com/antsmartian) -
   **Anto Aravinth** <<anto.aravinth.cse@gmail.com>> (he/him)
+* [apapirovski](https://github.com/apapirovski) -
+  **Anatoli Papirovski** <<apapirovski@mac.com>> (he/him)
 * [aqrln](https://github.com/aqrln) -
   **Alexey Orlenko** <<eaglexrlnk@gmail.com>> (he/him)
 * [AshCripps](https://github.com/AshCripps) -