diff --git a/doc/api/cli.md b/doc/api/cli.md
index fa044c442a01383..70e3b5c21760622 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -1229,6 +1229,16 @@ Starts the Node.js command line test runner. This flag cannot be combined with
 See the documentation on [running tests from the command line][]
 for more details.
 
+### `--test-coverage`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+When used in conjunction with the `node:test` module, a code coverage report is
+generated as part of the test runner output. See the documentation on
+[collecting code coverage from tests][] for more details.
+
 ### `--test-name-pattern`
 
 <!-- YAML
@@ -2358,6 +2368,7 @@ done
 [`unhandledRejection`]: process.md#event-unhandledrejection
 [`v8.startupSnapshot` API]: v8.md#startup-snapshot-api
 [`worker_threads.threadId`]: worker_threads.md#workerthreadid
+[collecting code coverage from tests]: test.md#collecting-code-coverage
 [conditional exports]: packages.md#conditional-exports
 [context-aware]: addons.md#context-aware-addons
 [debugger]: debugger.md
diff --git a/doc/api/test.md b/doc/api/test.md
index f17f43a59fe27d6..4783cd6f444565b 100644
--- a/doc/api/test.md
+++ b/doc/api/test.md
@@ -368,6 +368,26 @@ Otherwise, the test is considered to be a failure. Test files must be
 executable by Node.js, but are not required to use the `node:test` module
 internally.
 
+## Collecting code coverage
+
+When Node.js is started with the [`--test-coverage`][] command-line flag, code
+coverage is collected and statistics are reported once all tests have completed.
+If the [`NODE_V8_COVERAGE`][] environment variable is used to specify a
+code coverage directory, the generated V8 coverage files are written to that
+directory. Node.js core modules and files within `node_modules/` directories
+are not included in the coverage report. If coverage is enabled, the coverage
+report is sent to any [test reporters][] via the `'test:coverage'` event.
+
+The test runner's code coverage functionality has the following limitations,
+which will be addressed in a future Node.js release:
+
+* Although coverage data is collected for child processes, this information is
+  not included in the coverage report. Because the command line test runner uses
+  child processes to execute test files, it cannot be used with `--test-coverage`.
+* Source maps are not supported.
+* Excluding specific files or directories from the coverage report is not
+  supported.
+
 ## Mocking
 
 The `node:test` module supports mocking during testing via a top-level `mock`
@@ -1219,6 +1239,42 @@ A successful call to [`run()`][] method will return a new {TestsStream}
 object, streaming a series of events representing the execution of the tests.
 `TestsStream` will emit events, in the order of the tests definition
 
+### Event: `'test:coverage'`
+
+* `data` {Object}
+  * `summary` {Object} An object containing the coverage report.
+    * `files` {Array} An array of coverage reports for individual files. Each
+      report is an object with the following schema:
+      * `path` {string} The absolute path of the file.
+      * `totalLineCount` {number} The total number of lines.
+      * `totalBranchCount` {number} The total number of branches.
+      * `totalFunctionCount` {number} The total number of functions.
+      * `coveredLineCount` {number} The number of covered lines.
+      * `coveredBranchCount` {number} The number of covered branches.
+      * `coveredFunctionCount` {number} The number of covered functions.
+      * `coveredLinePercent` {number} The percentage of lines covered.
+      * `coveredBranchPercent` {number} The percentage of branches covered.
+      * `coveredFunctionPercent` {number} The percentage of functions covered.
+      * `uncoveredLineNumbers` {Array} An array of integers representing line
+        numbers that are uncovered.
+    * `totals` {Object} An object containing a summary of coverage for all
+      files.
+      * `totalLineCount` {number} The total number of lines.
+      * `totalBranchCount` {number} The total number of branches.
+      * `totalFunctionCount` {number} The total number of functions.
+      * `coveredLineCount` {number} The number of covered lines.
+      * `coveredBranchCount` {number} The number of covered branches.
+      * `coveredFunctionCount` {number} The number of covered functions.
+      * `coveredLinePercent` {number} The percentage of lines covered.
+      * `coveredBranchPercent` {number} The percentage of branches covered.
+      * `coveredFunctionPercent` {number} The percentage of functions covered.
+    * `workingDirectory` {string} The working directory when code coverage
+      began. This is useful for displaying relative path names in case the tests
+      changed the working directory of the Node.js process.
+  * `nesting` {number} The nesting level of the test.
+
+Emitted when code coverage is enabled and all tests have completed.
+
 ### Event: `'test:diagnostic'`
 
 * `data` {Object}
@@ -1589,6 +1645,7 @@ added:
 
 [TAP]: https://testanything.org/
 [`--import`]: cli.md#--importmodule
+[`--test-coverage`]: cli.md#--test-coverage
 [`--test-name-pattern`]: cli.md#--test-name-pattern
 [`--test-only`]: cli.md#--test-only
 [`--test-reporter-destination`]: cli.md#--test-reporter-destination
@@ -1597,6 +1654,7 @@ added:
 [`MockFunctionContext`]: #class-mockfunctioncontext
 [`MockTracker.method`]: #mockmethodobject-methodname-implementation-options
 [`MockTracker`]: #class-mocktracker
+[`NODE_V8_COVERAGE`]: cli.md#node_v8_coveragedir
 [`SuiteContext`]: #class-suitecontext
 [`TestContext`]: #class-testcontext
 [`context.diagnostic`]: #contextdiagnosticmessage
@@ -1607,4 +1665,5 @@ added:
 [describe options]: #describename-options-fn
 [it options]: #testname-options-fn
 [stream.compose]: stream.md#streamcomposestreams
+[test reporters]: #test-reporters
 [test runner execution model]: #test-runner-execution-model
diff --git a/doc/node.1 b/doc/node.1
index 6abee7e4b79a8a9..cdbd10edb4f2c63 100644
--- a/doc/node.1
+++ b/doc/node.1
@@ -391,6 +391,9 @@ Specify the minimum allocation from the OpenSSL secure heap. The default is 2. T
 .It Fl -test
 Starts the Node.js command line test runner.
 .
+.It Fl -test-coverage
+Enable code coverage in the test runner.
+.
 .It Fl -test-name-pattern
 A regular expression that configures the test runner to only execute tests
 whose name matches the provided pattern.
diff --git a/lib/internal/process/pre_execution.js b/lib/internal/process/pre_execution.js
index 4c44927fb0c15a0..6af480648ce7c70 100644
--- a/lib/internal/process/pre_execution.js
+++ b/lib/internal/process/pre_execution.js
@@ -20,6 +20,7 @@ const {
   exposeInterface,
   exposeLazyInterfaces,
   defineReplaceableLazyAttribute,
+  setupCoverageHooks,
 } = require('internal/util');
 
 const {
@@ -66,15 +67,7 @@ function prepareExecution(options) {
   setupFetch();
   setupWebCrypto();
   setupCustomEvent();
-
-  // Resolve the coverage directory to an absolute path, and
-  // overwrite process.env so that the original path gets passed
-  // to child processes even when they switch cwd.
-  if (process.env.NODE_V8_COVERAGE) {
-    process.env.NODE_V8_COVERAGE =
-      setupCoverageHooks(process.env.NODE_V8_COVERAGE);
-  }
-
+  setupCodeCoverage();
   setupDebugEnv();
   // Process initial diagnostic reporting configuration, if present.
   initializeReport();
@@ -304,6 +297,17 @@ function setupWebCrypto() {
   }
 }
 
+function setupCodeCoverage() {
+  // Resolve the coverage directory to an absolute path, and
+  // overwrite process.env so that the original path gets passed
+  // to child processes even when they switch cwd. Don't do anything if the
+  // --test-coverage flag is present, as the test runner will handle coverage.
+  if (process.env.NODE_V8_COVERAGE && !getOptionValue('--test-coverage')) {
+    process.env.NODE_V8_COVERAGE =
+      setupCoverageHooks(process.env.NODE_V8_COVERAGE);
+  }
+}
+
 // TODO(daeyeon): move this to internal/bootstrap/browser when the CLI flag is
 //                removed.
 function setupCustomEvent() {
@@ -315,27 +319,6 @@ function setupCustomEvent() {
   exposeInterface(globalThis, 'CustomEvent', CustomEvent);
 }
 
-// Setup User-facing NODE_V8_COVERAGE environment variable that writes
-// ScriptCoverage to a specified file.
-function setupCoverageHooks(dir) {
-  const cwd = require('internal/process/execution').tryGetCwd();
-  const { resolve } = require('path');
-  const coverageDirectory = resolve(cwd, dir);
-  const { sourceMapCacheToObject } =
-    require('internal/source_map/source_map_cache');
-
-  if (process.features.inspector) {
-    internalBinding('profiler').setCoverageDirectory(coverageDirectory);
-    internalBinding('profiler').setSourceMapCacheGetter(sourceMapCacheToObject);
-  } else {
-    process.emitWarning('The inspector is disabled, ' +
-                        'coverage could not be collected',
-                        'Warning');
-    return '';
-  }
-  return coverageDirectory;
-}
-
 function setupStacktracePrinterOnSigint() {
   if (!getOptionValue('--trace-sigint')) {
     return;
diff --git a/lib/internal/test_runner/coverage.js b/lib/internal/test_runner/coverage.js
new file mode 100644
index 000000000000000..0afe84e0ef25320
--- /dev/null
+++ b/lib/internal/test_runner/coverage.js
@@ -0,0 +1,362 @@
+'use strict';
+const {
+  ArrayPrototypeMap,
+  ArrayPrototypePush,
+  JSONParse,
+  MathFloor,
+  NumberParseInt,
+  RegExp,
+  RegExpPrototypeExec,
+  StringPrototypeIncludes,
+  StringPrototypeLocaleCompare,
+  StringPrototypeSplit,
+  StringPrototypeStartsWith,
+} = primordials;
+const {
+  copyFileSync,
+  mkdirSync,
+  mkdtempSync,
+  opendirSync,
+  readFileSync,
+} = require('fs');
+const { setupCoverageHooks } = require('internal/util');
+const { tmpdir } = require('os');
+const { join, resolve } = require('path');
+const { fileURLToPath } = require('url');
+const kCoveragePattern =
+  `^coverage\\-${process.pid}\\-(\\d{13})\\-(\\d+)\\.json$`;
+const kCoverageFileRegex = new RegExp(kCoveragePattern);
+const kIgnoreRegex = /\/\* node:coverage ignore next (?<count>\d+ )?\*\//;
+const kLineEndingRegex = /\r?\n$/u;
+const kLineSplitRegex = /(?<=\r?\n)/u;
+const kStatusRegex = /\/\* node:coverage (?<status>enable|disable) \*\//;
+
+class CoverageLine {
+  #covered;
+
+  constructor(line, src, startOffset) {
+    const newlineLength =
+      RegExpPrototypeExec(kLineEndingRegex, src)?.[0].length ?? 0;
+
+    this.line = line;
+    this.src = src;
+    this.startOffset = startOffset;
+    this.endOffset = startOffset + src.length - newlineLength;
+    this.ignore = false;
+    this.#covered = true;
+  }
+
+  get covered() {
+    return this.#covered;
+  }
+
+  set covered(isCovered) {
+    // V8 can generate multiple ranges that span the same line.
+    if (!this.#covered) {
+      return;
+    }
+
+    this.#covered = isCovered;
+  }
+}
+
+class TestCoverage {
+  constructor(coverageDirectory, originalCoverageDirectory, workingDirectory) {
+    this.coverageDirectory = coverageDirectory;
+    this.originalCoverageDirectory = originalCoverageDirectory;
+    this.workingDirectory = workingDirectory;
+  }
+
+  summary() {
+    internalBinding('profiler').takeCoverage();
+    const coverage = getCoverageFromDirectory(this.coverageDirectory);
+    const coverageSummary = {
+      __proto__: null,
+      workingDirectory: this.workingDirectory,
+      files: [],
+      totals: {
+        __proto__: null,
+        totalLineCount: 0,
+        totalBranchCount: 0,
+        totalFunctionCount: 0,
+        coveredLineCount: 0,
+        coveredBranchCount: 0,
+        coveredFunctionCount: 0,
+        coveredLinePercent: 0,
+        coveredBranchPercent: 0,
+        coveredFunctionPercent: 0,
+      },
+    };
+
+    if (!coverage) {
+      return coverageSummary;
+    }
+
+    for (let i = 0; i < coverage.length; ++i) {
+      const { functions, url } = coverage[i];
+
+      if (StringPrototypeStartsWith(url, 'node:') ||
+          StringPrototypeIncludes(url, '/node_modules/')) {
+        continue;
+      }
+
+      // Split the file source into lines. Make sure the lines maintain their
+      // original line endings because those characters are necessary for
+      // determining offsets in the file.
+      const filePath = fileURLToPath(url);
+      const source = readFileSync(filePath, 'utf8');
+      const linesWithBreaks = StringPrototypeSplit(source, kLineSplitRegex);
+      let ignoreCount = 0;
+      let enabled = true;
+      let offset = 0;
+      let totalBranches = 0;
+      let totalFunctions = 0;
+      let branchesCovered = 0;
+      let functionsCovered = 0;
+
+      const lines = ArrayPrototypeMap(linesWithBreaks, (line, i) => {
+        const startOffset = offset;
+        const coverageLine = new CoverageLine(i + 1, line, startOffset);
+
+        offset += line.length;
+
+        // Determine if this line is being ignored.
+        if (ignoreCount > 0) {
+          ignoreCount--;
+          coverageLine.ignore = true;
+        } else if (!enabled) {
+          coverageLine.ignore = true;
+        }
+
+        if (!coverageLine.ignore) {
+          // If this line is not already being ignored, check for ignore
+          // comments.
+          const match = RegExpPrototypeExec(kIgnoreRegex, line);
+
+          if (match !== null) {
+            const count = NumberParseInt(match.groups?.count ?? 1, 10);
+            ignoreCount = count;
+          }
+        }
+
+        // Check for comments to enable/disable coverage no matter what. These
+        // take precedence over ignore comments.
+        const match = RegExpPrototypeExec(kStatusRegex, line);
+        const status = match?.groups?.status;
+
+        if (status) {
+          ignoreCount = 0;
+          enabled = status === 'enable';
+        }
+
+        return coverageLine;
+      });
+
+      for (let j = 0; j < functions.length; ++j) {
+        const { functionName, isBlockCoverage, ranges } = functions[j];
+
+        for (let k = 0; k < ranges.length; ++k) {
+          const range = ranges[k];
+
+          mapRangeToLines(range, lines);
+
+          if (isBlockCoverage) {
+            if (range.count !== 0 ||
+                range.ignoredLines === range.lines.length) {
+              branchesCovered++;
+            }
+
+            totalBranches++;
+          }
+        }
+
+        if (functionName.length > 0 && ranges.length > 0) {
+          const range = ranges[0];
+
+          if (range.count !== 0 || range.ignoredLines === range.lines.length) {
+            functionsCovered++;
+          }
+
+          totalFunctions++;
+        }
+      }
+
+      let coveredCnt = 0;
+      const uncoveredLineNums = [];
+
+      for (let j = 0; j < lines.length; ++j) {
+        const line = lines[j];
+
+        if (line.covered || line.ignore) {
+          coveredCnt++;
+        } else {
+          ArrayPrototypePush(uncoveredLineNums, line.line);
+        }
+      }
+
+      ArrayPrototypePush(coverageSummary.files, {
+        __proto__: null,
+        path: filePath,
+        totalLineCount: lines.length,
+        totalBranchCount: totalBranches,
+        totalFunctionCount: totalFunctions,
+        coveredLineCount: coveredCnt,
+        coveredBranchCount: branchesCovered,
+        coveredFunctionCount: functionsCovered,
+        coveredLinePercent: toPercentage(coveredCnt, lines.length),
+        coveredBranchPercent: toPercentage(branchesCovered, totalBranches),
+        coveredFunctionPercent: toPercentage(functionsCovered, totalFunctions),
+        uncoveredLineNumbers: uncoveredLineNums,
+      });
+
+      coverageSummary.totals.totalLineCount += lines.length;
+      coverageSummary.totals.totalBranchCount += totalBranches;
+      coverageSummary.totals.totalFunctionCount += totalFunctions;
+      coverageSummary.totals.coveredLineCount += coveredCnt;
+      coverageSummary.totals.coveredBranchCount += branchesCovered;
+      coverageSummary.totals.coveredFunctionCount += functionsCovered;
+    }
+
+    coverageSummary.totals.coveredLinePercent = toPercentage(
+      coverageSummary.totals.coveredLineCount,
+      coverageSummary.totals.totalLineCount
+    );
+    coverageSummary.totals.coveredBranchPercent = toPercentage(
+      coverageSummary.totals.coveredBranchCount,
+      coverageSummary.totals.totalBranchCount
+    );
+    coverageSummary.totals.coveredFunctionPercent = toPercentage(
+      coverageSummary.totals.coveredFunctionCount,
+      coverageSummary.totals.totalFunctionCount
+    );
+    coverageSummary.files.sort(sortCoverageFiles);
+
+    return coverageSummary;
+  }
+
+  cleanup() {
+    // Restore the original value of process.env.NODE_V8_COVERAGE. Then, copy
+    // all of the created coverage files to the original coverage directory.
+    if (this.originalCoverageDirectory === undefined) {
+      delete process.env.NODE_V8_COVERAGE;
+      return;
+    }
+
+    process.env.NODE_V8_COVERAGE = this.originalCoverageDirectory;
+
+    try {
+      mkdirSync(this.originalCoverageDirectory, { recursive: true });
+      const dir = opendirSync(this.coverageDirectory);
+
+      for (let entry; (entry = dir.readSync()) !== null;) {
+        const src = join(this.coverageDirectory, entry.name);
+        const dst = join(this.originalCoverageDirectory, entry.name);
+        copyFileSync(src, dst);
+      }
+    } catch {
+      // Ignore.
+    }
+  }
+}
+
+function toPercentage(covered, total) {
+  return total === 0 ? 0 : (covered / total) * 100;
+}
+
+function sortCoverageFiles(a, b) {
+  return StringPrototypeLocaleCompare(a.path, b.path);
+}
+
+function setupCoverage() {
+  let originalCoverageDirectory = process.env.NODE_V8_COVERAGE;
+  const cwd = process.cwd();
+
+  if (originalCoverageDirectory) {
+    // NODE_V8_COVERAGE was already specified. Convert it to an absolute path
+    // and store it for later. The test runner will use a temporary directory
+    // so that no preexisting coverage files interfere with the results of the
+    // coverage report. Then, once the coverage is computed, move the coverage
+    // files back to the original NODE_V8_COVERAGE directory.
+    originalCoverageDirectory = resolve(cwd, originalCoverageDirectory);
+  }
+
+  const coverageDirectory = mkdtempSync(join(tmpdir(), 'node-coverage-'));
+  const enabled = setupCoverageHooks(coverageDirectory);
+
+  if (!enabled) {
+    return null;
+  }
+
+  // Ensure that NODE_V8_COVERAGE is set so that coverage can propagate to
+  // child processes.
+  process.env.NODE_V8_COVERAGE = coverageDirectory;
+
+  return new TestCoverage(coverageDirectory, originalCoverageDirectory, cwd);
+}
+
+function mapRangeToLines(range, lines) {
+  const { startOffset, endOffset, count } = range;
+  const mappedLines = [];
+  let ignoredLines = 0;
+  let start = 0;
+  let end = lines.length;
+  let mid;
+
+  while (start <= end) {
+    mid = MathFloor((start + end) / 2);
+    let line = lines[mid];
+
+    if (startOffset >= line.startOffset && startOffset <= line.endOffset) {
+      while (endOffset > line?.startOffset) {
+        // If the range is not covered, and the range covers the entire line,
+        // then mark that line as not covered.
+        if (count === 0 && startOffset <= line.startOffset &&
+            endOffset >= line.endOffset) {
+          line.covered = false;
+        }
+
+        ArrayPrototypePush(mappedLines, line);
+
+        if (line.ignore) {
+          ignoredLines++;
+        }
+
+        mid++;
+        line = lines[mid];
+      }
+
+      break;
+    } else if (startOffset >= line.endOffset) {
+      start = mid + 1;
+    } else {
+      end = mid - 1;
+    }
+  }
+
+  // Add some useful data to the range. The test runner has read these ranges
+  // from a file, so we own the data structures and can do what we want.
+  range.lines = mappedLines;
+  range.ignoredLines = ignoredLines;
+}
+
+function getCoverageFromDirectory(coverageDirectory) {
+  // TODO(cjihrig): Instead of only reading the coverage file for this process,
+  // combine all coverage files in the directory into a single data structure.
+  try {
+    const dir = opendirSync(coverageDirectory);
+
+    for (let entry; (entry = dir.readSync()) !== null;) {
+      if (RegExpPrototypeExec(kCoverageFileRegex, entry.name) === null) {
+        continue;
+      }
+
+      const coverageFile = join(coverageDirectory, entry.name);
+      const coverage = JSONParse(readFileSync(coverageFile, 'utf8'));
+      return coverage.result;
+    }
+  } catch {
+    // Ignore.
+  }
+}
+
+module.exports = { setupCoverage };
diff --git a/lib/internal/test_runner/runner.js b/lib/internal/test_runner/runner.js
index ff91993ce9df29e..37f1957a78016f1 100644
--- a/lib/internal/test_runner/runner.js
+++ b/lib/internal/test_runner/runner.js
@@ -49,7 +49,7 @@ const {
   exitCodes: { kGenericUserError },
 } = internalBinding('errors');
 
-const kFilterArgs = ['--test', '--watch'];
+const kFilterArgs = ['--test', '--test-coverage', '--watch'];
 const kFilterArgValues = ['--test-reporter', '--test-reporter-destination'];
 
 // TODO(cjihrig): Replace this with recursive readdir once it lands.
diff --git a/lib/internal/test_runner/test.js b/lib/internal/test_runner/test.js
index b7267491d50c3f5..9ef02f94ff007dd 100644
--- a/lib/internal/test_runner/test.js
+++ b/lib/internal/test_runner/test.js
@@ -195,6 +195,13 @@ class Test extends AsyncResource {
       this.runOnlySubtests = this.only;
       this.testNumber = 0;
       this.timeout = kDefaultTimeout;
+
+      if (getOptionValue('--test-coverage')) {
+        const { setupCoverage } = require('internal/test_runner/coverage');
+        this.coverage = setupCoverage();
+      } else {
+        this.coverage = null;
+      }
     } else {
       const nesting = parent.parent === null ? parent.nesting :
         parent.nesting + 1;
@@ -206,6 +213,7 @@ class Test extends AsyncResource {
       this.runOnlySubtests = !this.only;
       this.testNumber = parent.subtests.length + 1;
       this.timeout = parent.timeout;
+      this.coverage = null;
     }
 
     switch (typeof concurrency) {
@@ -645,6 +653,12 @@ class Test extends AsyncResource {
       this.reporter.diagnostic(this.nesting, `skipped ${counters.skipped}`);
       this.reporter.diagnostic(this.nesting, `todo ${counters.todo}`);
       this.reporter.diagnostic(this.nesting, `duration_ms ${this.#duration()}`);
+
+      if (this.coverage) {
+        this.reporter.coverage(this.nesting, this.coverage.summary());
+        this.coverage.cleanup();
+      }
+
       this.reporter.push(null);
     }
   }
diff --git a/lib/internal/test_runner/tests_stream.js b/lib/internal/test_runner/tests_stream.js
index b016d3161548077..e2ce0afe055e974 100644
--- a/lib/internal/test_runner/tests_stream.js
+++ b/lib/internal/test_runner/tests_stream.js
@@ -55,6 +55,10 @@ class TestsStream extends Readable {
     this.#emit('test:diagnostic', { __proto__: null, nesting, message });
   }
 
+  coverage(nesting, summary) {
+    this.#emit('test:coverage', { __proto__: null, nesting, summary });
+  }
+
   #emit(type, data) {
     this.emit(type, data);
     this.#tryPush({ type, data });
diff --git a/lib/internal/util.js b/lib/internal/util.js
index 0d769e061fe4485..9117611f8d35601 100644
--- a/lib/internal/util.js
+++ b/lib/internal/util.js
@@ -715,6 +715,27 @@ function getLazy(initializer) {
   };
 }
 
+// Setup user-facing NODE_V8_COVERAGE environment variable that writes
+// ScriptCoverage objects to a specified directory.
+function setupCoverageHooks(dir) {
+  const cwd = require('internal/process/execution').tryGetCwd();
+  const { resolve } = require('path');
+  const coverageDirectory = resolve(cwd, dir);
+  const { sourceMapCacheToObject } =
+    require('internal/source_map/source_map_cache');
+
+  if (process.features.inspector) {
+    internalBinding('profiler').setCoverageDirectory(coverageDirectory);
+    internalBinding('profiler').setSourceMapCacheGetter(sourceMapCacheToObject);
+  } else {
+    process.emitWarning('The inspector is disabled, ' +
+                        'coverage could not be collected',
+                        'Warning');
+    return '';
+  }
+  return coverageDirectory;
+}
+
 module.exports = {
   getLazy,
   assertCrypto,
@@ -750,6 +771,7 @@ module.exports = {
   SideEffectFreeRegExpPrototypeSymbolSplit,
   sleep,
   spliceOne,
+  setupCoverageHooks,
   toUSVString,
   removeColors,
 
diff --git a/lib/test/reporter/tap.js b/lib/test/reporter/tap.js
index fa5d4684fbb9e3f..ebf7be80e2a2f5d 100644
--- a/lib/test/reporter/tap.js
+++ b/lib/test/reporter/tap.js
@@ -3,6 +3,7 @@ const {
   ArrayPrototypeForEach,
   ArrayPrototypeJoin,
   ArrayPrototypePush,
+  NumberPrototypeToFixed,
   ObjectEntries,
   RegExpPrototypeSymbolReplace,
   SafeMap,
@@ -12,6 +13,7 @@ const {
 } = primordials;
 const { inspectWithNoCustomRetry } = require('internal/errors');
 const { isError, kEmptyObject } = require('internal/util');
+const { relative } = require('path');
 const kDefaultIndent = '    '; // 4 spaces
 const kFrameStartRegExp = /^ {4}at /;
 const kLineBreakRegExp = /\n|\r\n/;
@@ -46,6 +48,9 @@ async function * tapReporter(source) {
       case 'test:diagnostic':
         yield `${indent(data.nesting)}# ${tapEscape(data.message)}\n`;
         break;
+      case 'test:coverage':
+        yield reportCoverage(data.nesting, data.summary);
+        break;
     }
   }
 }
@@ -68,6 +73,39 @@ function reportTest(nesting, testNumber, status, name, skip, todo) {
   return line;
 }
 
+function reportCoverage(nesting, summary) {
+  const pad = indent(nesting);
+  let report = `${pad}# start of coverage report\n`;
+
+  report += `${pad}# file | line % | branch % | funcs % | uncovered lines\n`;
+
+  for (let i = 0; i < summary.files.length; ++i) {
+    const {
+      path,
+      coveredLinePercent,
+      coveredBranchPercent,
+      coveredFunctionPercent,
+      uncoveredLineNumbers,
+    } = summary.files[i];
+    const relativePath = relative(summary.workingDirectory, path);
+    const lines = NumberPrototypeToFixed(coveredLinePercent, 2);
+    const branches = NumberPrototypeToFixed(coveredBranchPercent, 2);
+    const functions = NumberPrototypeToFixed(coveredFunctionPercent, 2);
+    const uncovered = ArrayPrototypeJoin(uncoveredLineNumbers, ', ');
+
+    report += `${pad}# ${relativePath} | ${lines} | ${branches} | ` +
+              `${functions} | ${uncovered}\n`;
+  }
+
+  const { totals } = summary;
+  report += `${pad}# all files | ` +
+            `${NumberPrototypeToFixed(totals.coveredLinePercent, 2)} | ` +
+            `${NumberPrototypeToFixed(totals.coveredBranchPercent, 2)} | ` +
+            `${NumberPrototypeToFixed(totals.coveredFunctionPercent, 2)} |\n`;
+
+  report += `${pad}# end of coverage report\n`;
+  return report;
+}
 
 function reportDetails(nesting, data = kEmptyObject) {
   const { error, duration_ms } = data;
diff --git a/src/node_options.cc b/src/node_options.cc
index 3a064ce8282d05c..0b19c859cdffe0c 100644
--- a/src/node_options.cc
+++ b/src/node_options.cc
@@ -140,6 +140,12 @@ void EnvironmentOptions::CheckOptions(std::vector<std::string>* errors,
   }
 
   if (test_runner) {
+    if (test_runner_coverage) {
+      // TODO(cjihrig): This restriction can be removed once multi-process
+      // code coverage is supported.
+      errors->push_back("--test-coverage cannot be used with --test");
+    }
+
     if (syntax_check_only) {
       errors->push_back("either --test or --check can be used, not both");
     }
@@ -549,6 +555,9 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
   AddOption("--test",
             "launch test runner on startup",
             &EnvironmentOptions::test_runner);
+  AddOption("--test-coverage",
+            "enable code coverage in the test runner",
+            &EnvironmentOptions::test_runner_coverage);
   AddOption("--test-name-pattern",
             "run tests whose name matches this regular expression",
             &EnvironmentOptions::test_name_pattern);
diff --git a/src/node_options.h b/src/node_options.h
index e145868763a51bc..8f43fc106fe8053 100644
--- a/src/node_options.h
+++ b/src/node_options.h
@@ -155,6 +155,7 @@ class EnvironmentOptions : public Options {
   std::string redirect_warnings;
   std::string diagnostic_dir;
   bool test_runner = false;
+  bool test_runner_coverage = false;
   std::vector<std::string> test_name_pattern;
   std::vector<std::string> test_reporter;
   std::vector<std::string> test_reporter_destination;