diff --git a/doc/api/cli.md b/doc/api/cli.md
index b1a0d674ca4ded..d5cb96aa4da9c9 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -2701,6 +2701,21 @@ added: v22.8.0
 Require a minimum percent of covered lines. If code coverage does not reach
 the threshold specified, the process will exit with code `1`.
 
+### `--test-coverage-statements=threshold`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1 - Experimental
+
+Require a minimum percent of covered statements. If code coverage does not reach
+the threshold specified, the process will exit with code `1`.
+
+Statement coverage uses acorn to parse source files and extract statement
+nodes from the AST. The V8 coverage ranges are then mapped to these statements
+to determine which ones were executed.
+
 ### `--test-force-exit`
 
 <!-- YAML
@@ -3687,6 +3702,7 @@ one is included in the list below.
 * `--test-coverage-functions`
 * `--test-coverage-include`
 * `--test-coverage-lines`
+* `--test-coverage-statements`
 * `--test-global-setup`
 * `--test-isolation`
 * `--test-name-pattern`
diff --git a/doc/api/test.md b/doc/api/test.md
index 3d245c2303b185..6781af5308a764 100644
--- a/doc/api/test.md
+++ b/doc/api/test.md
@@ -3255,12 +3255,15 @@ are defined, while others are emitted in the order that the tests execute.
       * `totalLineCount` {number} The total number of lines.
       * `totalBranchCount` {number} The total number of branches.
       * `totalFunctionCount` {number} The total number of functions.
+      * `totalStatementCount` {number} The total number of statements.
       * `coveredLineCount` {number} The number of covered lines.
       * `coveredBranchCount` {number} The number of covered branches.
       * `coveredFunctionCount` {number} The number of covered functions.
+      * `coveredStatementCount` {number} The number of covered statements.
       * `coveredLinePercent` {number} The percentage of lines covered.
       * `coveredBranchPercent` {number} The percentage of branches covered.
       * `coveredFunctionPercent` {number} The percentage of functions covered.
+      * `coveredStatementPercent` {number} The percentage of statements covered.
       * `functions` {Array} An array of functions representing function
         coverage.
         * `name` {string} The name of the function.
@@ -3273,22 +3276,30 @@ are defined, while others are emitted in the order that the tests execute.
         numbers and the number of times they were covered.
         * `line` {number} The line number.
         * `count` {number} The number of times the line was covered.
+      * `statements` {Array} An array of statements representing statement
+        coverage.
+        * `line` {number} The line number where the statement starts.
+        * `count` {number} The number of times the statement was executed.
     * `thresholds` {Object} An object containing whether or not the coverage for
       each coverage type.
       * `function` {number} The function coverage threshold.
       * `branch` {number} The branch coverage threshold.
       * `line` {number} The line coverage threshold.
+      * `statement` {number} The statement coverage threshold.
     * `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.
+      * `totalStatementCount` {number} The total number of statements.
       * `coveredLineCount` {number} The number of covered lines.
       * `coveredBranchCount` {number} The number of covered branches.
       * `coveredFunctionCount` {number} The number of covered functions.
+      * `coveredStatementCount` {number} The number of covered statements.
       * `coveredLinePercent` {number} The percentage of lines covered.
       * `coveredBranchPercent` {number} The percentage of branches covered.
       * `coveredFunctionPercent` {number} The percentage of functions covered.
+      * `coveredStatementPercent` {number} The percentage of statements 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.
diff --git a/lib/internal/test_runner/coverage.js b/lib/internal/test_runner/coverage.js
index 8fa9c872568d1e..873816755de4dd 100644
--- a/lib/internal/test_runner/coverage.js
+++ b/lib/internal/test_runner/coverage.js
@@ -30,6 +30,10 @@ const { tmpdir } = require('os');
 const { join, resolve, relative } = require('path');
 const { fileURLToPath, URL } = require('internal/url');
 const { kMappings, SourceMap } = require('internal/source_map/source_map');
+const { Parser: AcornParser } =
+  require('internal/deps/acorn/acorn/dist/acorn');
+const { simple: acornWalkSimple } =
+  require('internal/deps/acorn/acorn-walk/dist/walk');
 const {
   codes: {
     ERR_SOURCE_MAP_CORRUPT,
@@ -39,6 +43,12 @@ const {
 const { matchGlobPattern } = require('internal/fs/glob');
 const { constants: { kMockSearchParam } } = require('internal/test_runner/mock/loader');
 
+// Statement types excluded from coverage: containers (BlockStatement)
+// and empty statements that carry no executable semantics.
+const kExcludedStatementTypes = new SafeSet([
+  'BlockStatement', 'EmptyStatement',
+]);
+
 const kCoverageFileRegex = /^coverage-(\d+)-(\d{13})-(\d+)\.json$/;
 const kIgnoreRegex = /\/\* node:coverage ignore next (?<count>\d+ )?\*\//;
 const kLineEndingRegex = /\r?\n$/u;
@@ -69,6 +79,64 @@ class TestCoverage {
   }
 
   #sourceLines = new SafeMap();
+  #sourceStatements = new SafeMap();
+
+  getStatements(fileUrl, source) {
+    if (this.#sourceStatements.has(fileUrl)) {
+      return this.#sourceStatements.get(fileUrl);
+    }
+
+    try {
+      source ??= readFileSync(fileURLToPath(fileUrl), 'utf8');
+    } catch {
+      // The file can no longer be read. Leave it out of statement coverage.
+      this.#sourceStatements.set(fileUrl, null);
+      return null;
+    }
+
+    const statements = [];
+
+    // acorn-walk's simple() fires a generic "Statement" visitor for every
+    // node dispatched in a statement position (Program body, block bodies,
+    // if/for/while bodies, etc.). This automatically covers all current and
+    // future ESTree statement types without hardcoding a list.
+    const visitor = { __proto__: null };
+    visitor.Statement = (node) => {
+      if (kExcludedStatementTypes.has(node.type)) return;
+      ArrayPrototypePush(statements, {
+        __proto__: null,
+        startOffset: node.start,
+        endOffset: node.end,
+        count: 0,
+      });
+    };
+
+    // Parse as script with permissive flags — script mode is non-strict,
+    // so it handles legacy CJS (e.g. `with` statements) while the
+    // allow* flags enable ESM syntax (import/export/top-level await).
+    let ast;
+    try {
+      ast = AcornParser.parse(source, {
+        __proto__: null,
+        ecmaVersion: 'latest',
+        sourceType: 'script',
+        allowHashBang: true,
+        allowReturnOutsideFunction: true,
+        allowImportExportEverywhere: true,
+        allowAwaitOutsideFunction: true,
+      });
+    } catch {
+      // Acorn could not parse the file (e.g. non-JS syntax, TypeScript).
+      // Degrade gracefully — the file will report no statement coverage.
+      this.#sourceStatements.set(fileUrl, null);
+      return null;
+    }
+
+    acornWalkSimple(ast, visitor);
+
+    this.#sourceStatements.set(fileUrl, statements);
+    return statements;
+  }
 
   getLines(fileUrl, source) {
     // Split the file source into lines. Make sure the lines maintain their
@@ -145,18 +213,22 @@ class TestCoverage {
         totalLineCount: 0,
         totalBranchCount: 0,
         totalFunctionCount: 0,
+        totalStatementCount: 0,
         coveredLineCount: 0,
         coveredBranchCount: 0,
         coveredFunctionCount: 0,
+        coveredStatementCount: 0,
         coveredLinePercent: 0,
         coveredBranchPercent: 0,
         coveredFunctionPercent: 0,
+        coveredStatementPercent: 0,
       },
       thresholds: {
         __proto__: null,
         line: this.options.lineCoverage,
         branch: this.options.branchCoverage,
         function: this.options.functionCoverage,
+        statement: this.options.statementCoverage,
       },
     };
 
@@ -174,7 +246,17 @@ class TestCoverage {
       const functionReports = [];
       const branchReports = [];
 
-      const lines = this.getLines(url);
+      // Read source once and pass to both getLines and getStatements to
+      // avoid double disk I/O for the same file.
+      let source;
+      try {
+        source = readFileSync(fileURLToPath(url), 'utf8');
+      } catch {
+        // The file can no longer be read. Skip it entirely.
+        continue;
+      }
+
+      const lines = this.getLines(url, source);
       if (!lines) {
         continue;
       }
@@ -243,29 +325,88 @@ class TestCoverage {
         }
       }
 
+      // Compute statement coverage by mapping V8 ranges to AST statements.
+      // Pass the source already read above to avoid double disk I/O.
+      const statements = this.getStatements(url, source);
+      let totalStatements = 0;
+      let statementsCovered = 0;
+      const statementReports = [];
+
+      if (statements) {
+        // Flatten all V8 coverage ranges into a single array so
+        // the statement loop only needs two levels of iteration.
+        const allRanges = [];
+        for (let fi = 0; fi < functions.length; ++fi) {
+          const { ranges } = functions[fi];
+          for (let ri = 0; ri < ranges.length; ++ri) {
+            ArrayPrototypePush(allRanges, ranges[ri]);
+          }
+        }
+
+        for (let j = 0; j < statements.length; ++j) {
+          const stmt = statements[j];
+          let bestCount = 0;
+          let bestSize = Infinity;
+
+          for (let ri = 0; ri < allRanges.length; ++ri) {
+            const range = allRanges[ri];
+            if (doesRangeContainOtherRange(range, stmt)) {
+              const size = range.endOffset - range.startOffset;
+              if (size < bestSize) {
+                bestCount = range.count;
+                bestSize = size;
+              }
+            }
+          }
+
+          stmt.count = bestSize !== Infinity ? bestCount : 0;
+
+          const stmtLine = findLineForOffset(stmt.startOffset, lines);
+          const isIgnored = stmtLine != null && stmtLine.ignore;
+
+          if (!isIgnored) {
+            totalStatements++;
+            ArrayPrototypePush(statementReports, {
+              __proto__: null,
+              line: stmtLine?.line,
+              count: stmt.count,
+            });
+            if (stmt.count > 0) {
+              statementsCovered++;
+            }
+          }
+        }
+      }
+
       ArrayPrototypePush(coverageSummary.files, {
         __proto__: null,
         path: fileURLToPath(url),
         totalLineCount: lines.length,
         totalBranchCount: totalBranches,
         totalFunctionCount: totalFunctions,
+        totalStatementCount: totalStatements,
         coveredLineCount: coveredCnt,
         coveredBranchCount: branchesCovered,
         coveredFunctionCount: functionsCovered,
+        coveredStatementCount: statementsCovered,
         coveredLinePercent: toPercentage(coveredCnt, lines.length),
         coveredBranchPercent: toPercentage(branchesCovered, totalBranches),
         coveredFunctionPercent: toPercentage(functionsCovered, totalFunctions),
+        coveredStatementPercent: toPercentage(statementsCovered, totalStatements),
         functions: functionReports,
         branches: branchReports,
         lines: lineReports,
+        statements: statementReports,
       });
 
       coverageSummary.totals.totalLineCount += lines.length;
       coverageSummary.totals.totalBranchCount += totalBranches;
       coverageSummary.totals.totalFunctionCount += totalFunctions;
+      coverageSummary.totals.totalStatementCount += totalStatements;
       coverageSummary.totals.coveredLineCount += coveredCnt;
       coverageSummary.totals.coveredBranchCount += branchesCovered;
       coverageSummary.totals.coveredFunctionCount += functionsCovered;
+      coverageSummary.totals.coveredStatementCount += statementsCovered;
     }
 
     coverageSummary.totals.coveredLinePercent = toPercentage(
@@ -280,6 +421,10 @@ class TestCoverage {
       coverageSummary.totals.coveredFunctionCount,
       coverageSummary.totals.totalFunctionCount,
     );
+    coverageSummary.totals.coveredStatementPercent = toPercentage(
+      coverageSummary.totals.coveredStatementCount,
+      coverageSummary.totals.totalStatementCount,
+    );
     coverageSummary.files.sort(sortCoverageFiles);
 
     return coverageSummary;
@@ -695,4 +840,25 @@ function doesRangeContainOtherRange(range, otherRange) {
          range.endOffset >= otherRange.endOffset;
 }
 
+function findLineForOffset(offset, lines) {
+  let start = 0;
+  let end = lines.length - 1;
+
+  while (start <= end) {
+    const mid = MathFloor((start + end) / 2);
+    const line = lines[mid];
+
+    if (offset >= line.startOffset && offset <= line.endOffset) {
+      return line;
+    }
+    if (offset > line.endOffset) {
+      start = mid + 1;
+    } else {
+      end = mid - 1;
+    }
+  }
+
+  return null;
+}
+
 module.exports = { setupCoverage, TestCoverage };
diff --git a/lib/internal/test_runner/test.js b/lib/internal/test_runner/test.js
index 2203bbd3497659..23c451d7cf9992 100644
--- a/lib/internal/test_runner/test.js
+++ b/lib/internal/test_runner/test.js
@@ -1367,6 +1367,9 @@ class Test extends AsyncResource {
 
           { __proto__: null, actual: coverage.totals.coveredFunctionPercent,
             threshold: this.config.functionCoverage, name: 'function' },
+
+          { __proto__: null, actual: coverage.totals.coveredStatementPercent,
+            threshold: this.config.statementCoverage, name: 'statement' },
         ];
 
         for (let i = 0; i < coverages.length; i++) {
diff --git a/lib/internal/test_runner/utils.js b/lib/internal/test_runner/utils.js
index db7e2ee50dd8d6..0ab2909ddbc63a 100644
--- a/lib/internal/test_runner/utils.js
+++ b/lib/internal/test_runner/utils.js
@@ -227,6 +227,7 @@ function parseCommandLine() {
   let lineCoverage;
   let branchCoverage;
   let functionCoverage;
+  let statementCoverage;
   let destinations;
   let isolation;
   let only = getOptionValue('--test-only');
@@ -318,10 +319,12 @@ function parseCommandLine() {
     branchCoverage = getOptionValue('--test-coverage-branches');
     lineCoverage = getOptionValue('--test-coverage-lines');
     functionCoverage = getOptionValue('--test-coverage-functions');
+    statementCoverage = getOptionValue('--test-coverage-statements');
 
     validateInteger(branchCoverage, '--test-coverage-branches', 0, 100);
     validateInteger(lineCoverage, '--test-coverage-lines', 0, 100);
     validateInteger(functionCoverage, '--test-coverage-functions', 0, 100);
+    validateInteger(statementCoverage, '--test-coverage-statements', 0, 100);
   }
 
   if (rerunFailuresFilePath) {
@@ -351,6 +354,7 @@ function parseCommandLine() {
     branchCoverage,
     functionCoverage,
     lineCoverage,
+    statementCoverage,
     only,
     reporters,
     setup,
@@ -449,8 +453,11 @@ function formatUncoveredLines(lines, table) {
   return ArrayPrototypeJoin(lines, ', ');
 }
 
-const kColumns = ['line %', 'branch %', 'funcs %'];
-const kColumnsKeys = ['coveredLinePercent', 'coveredBranchPercent', 'coveredFunctionPercent'];
+const kColumns = ['stmts %', 'line %', 'branch %', 'funcs %'];
+const kColumnsKeys = [
+  'coveredStatementPercent', 'coveredLinePercent',
+  'coveredBranchPercent', 'coveredFunctionPercent',
+];
 const kSeparator = ' | ';
 
 function buildFileTree(summary) {
diff --git a/src/node_options.cc b/src/node_options.cc
index d48641ae3ffe07..6936facd0d0fe6 100644
--- a/src/node_options.cc
+++ b/src/node_options.cc
@@ -935,6 +935,11 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
             &EnvironmentOptions::test_coverage_lines,
             kAllowedInEnvvar,
             OptionNamespaces::kTestRunnerNamespace);
+  AddOption("--test-coverage-statements",
+            "the statement coverage minimum threshold",
+            &EnvironmentOptions::test_coverage_statements,
+            kAllowedInEnvvar,
+            OptionNamespaces::kTestRunnerNamespace);
   AddOption("--test-isolation",
             "configures the type of test isolation used in the test runner",
             &EnvironmentOptions::test_isolation,
diff --git a/src/node_options.h b/src/node_options.h
index 2f0adb5ae491ec..a865efed7c7e59 100644
--- a/src/node_options.h
+++ b/src/node_options.h
@@ -198,6 +198,7 @@ class EnvironmentOptions : public Options {
   uint64_t test_coverage_branches = 0;
   uint64_t test_coverage_functions = 0;
   uint64_t test_coverage_lines = 0;
+  uint64_t test_coverage_statements = 0;
   bool test_runner_module_mocks = false;
   bool test_runner_update_snapshots = false;
   std::vector<std::string> test_name_pattern;
diff --git a/test/fixtures/test-runner/coverage-class.js b/test/fixtures/test-runner/coverage-class.js
new file mode 100644
index 00000000000000..a359375d117f50
--- /dev/null
+++ b/test/fixtures/test-runner/coverage-class.js
@@ -0,0 +1,38 @@
+'use strict';
+const test = require('node:test');
+
+class Animal {
+  constructor(name) {
+    this.name = name;
+  }
+
+  speak() {
+    return `${this.name} makes a sound`;
+  }
+
+  static create(name) {
+    return new Animal(name);
+  }
+}
+
+class Dog extends Animal {
+  static {
+    Dog.species = 'Canis familiaris';
+  }
+
+  speak() {
+    return `${this.name} barks`;
+  }
+}
+
+// This class is never instantiated — its body should be uncovered.
+class UnusedClass {
+  doSomething() {
+    return 42;
+  }
+}
+
+test('class coverage', () => {
+  const dog = Dog.create('Rex');
+  dog.speak();
+});
diff --git a/test/fixtures/test-runner/coverage-multistatement.js b/test/fixtures/test-runner/coverage-multistatement.js
new file mode 100644
index 00000000000000..cea120cf25523c
--- /dev/null
+++ b/test/fixtures/test-runner/coverage-multistatement.js
@@ -0,0 +1,24 @@
+'use strict';
+const test = require('node:test');
+
+// Multiple statements on one line — only first executes if condition met
+function riskyOperation(value) {
+  if (value > 0) return value * 2; return -1;
+}
+
+// Single line if/else — only one branch runs per call
+function classify(n) {
+  if (n > 0) return 'positive'; else return 'non-positive';
+}
+
+// One-liner function where early validation can skip later statements
+function processEntry(a) { if (!a) return null; return String(a).toUpperCase(); }
+
+// Uncalled function with multiple inline statements — 0% statement coverage
+function neverCalled() { const a = 1; const b = 2; return a + b; }
+
+test('multistatement coverage', () => {
+  riskyOperation(5);    // takes early return, second statement skipped
+  classify(10);         // takes positive branch, else branch skipped
+  processEntry('hello'); // passes guard, both statements execute
+});
diff --git a/test/fixtures/test-runner/coverage-shebang.js b/test/fixtures/test-runner/coverage-shebang.js
new file mode 100644
index 00000000000000..58f7b9358a0ba3
--- /dev/null
+++ b/test/fixtures/test-runner/coverage-shebang.js
@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+'use strict';
+const test = require('node:test');
+
+// This file has a shebang line. Without allowHashBang: true,
+// acorn would fail to parse it and statement coverage would
+// degrade to 0 total statements.
+
+function greet(name) {
+  return 'Hello, ' + name;
+}
+
+// Uncalled — should show as uncovered statements
+function farewell(name) {
+  return 'Goodbye, ' + name;
+}
+
+test('shebang file coverage', () => {
+  greet('world');
+});
diff --git a/test/fixtures/test-runner/coverage-unparseable-test.js b/test/fixtures/test-runner/coverage-unparseable-test.js
new file mode 100644
index 00000000000000..e676525c3be021
--- /dev/null
+++ b/test/fixtures/test-runner/coverage-unparseable-test.js
@@ -0,0 +1,10 @@
+'use strict';
+const test = require('node:test');
+const unparseable = require('./coverage-unparseable.js');
+
+test('require unparseable module', () => {
+  // The unparseable module loads fine at runtime (CJS wrapper makes
+  // top-level `using` valid) but acorn cannot parse the raw source.
+  // Statement coverage should degrade gracefully for that file.
+  require('node:assert').ok(unparseable.ok);
+});
diff --git a/test/fixtures/test-runner/coverage-unparseable.js b/test/fixtures/test-runner/coverage-unparseable.js
new file mode 100644
index 00000000000000..cee21548c48d55
--- /dev/null
+++ b/test/fixtures/test-runner/coverage-unparseable.js
@@ -0,0 +1,8 @@
+'use strict';
+// Top-level `using` is valid inside the CJS module wrapper (V8 wraps this
+// in a function) but the ECMAScript spec forbids `using` at the top level
+// of a Script. Since acorn parses raw source as sourceType:'script',
+// this file triggers a parse error -> getStatements() returns null.
+// Line, branch, and function coverage still work normally.
+using resource = { [Symbol.dispose]() {} };
+module.exports = { ok: true };
diff --git a/test/parallel/test-runner-coverage-statements.js b/test/parallel/test-runner-coverage-statements.js
new file mode 100644
index 00000000000000..b5246f325bc202
--- /dev/null
+++ b/test/parallel/test-runner-coverage-statements.js
@@ -0,0 +1,271 @@
+'use strict';
+const common = require('../common');
+const assert = require('node:assert');
+const { spawnSync } = require('node:child_process');
+const { test } = require('node:test');
+const fixtures = require('../common/fixtures');
+
+common.skipIfInspectorDisabled();
+
+const fixture = fixtures.path('test-runner', 'coverage.js');
+const reporter = fixtures.fileURL('test-runner/custom_reporters/coverage.mjs');
+
+test('statement coverage is reported via custom reporter', () => {
+  const result = spawnSync(process.execPath, [
+    '--test',
+    '--experimental-test-coverage',
+    '--test-coverage-exclude=!test/**',
+    '--test-reporter', reporter,
+    fixture,
+  ]);
+
+  assert.strictEqual(result.stderr.toString(), '');
+  assert.strictEqual(result.status, 0);
+
+  const stdout = JSON.parse(result.stdout.toString());
+  const { summary } = stdout;
+
+  // Verify statement coverage fields exist in totals
+  assert.ok('coveredStatementPercent' in summary.totals,
+            'totals should have coveredStatementPercent');
+  assert.ok('totalStatementCount' in summary.totals,
+            'totals should have totalStatementCount');
+  assert.ok('coveredStatementCount' in summary.totals,
+            'totals should have coveredStatementCount');
+
+  // Statement coverage should be a number between 0 and 100
+  assert.ok(summary.totals.coveredStatementPercent >= 0 &&
+            summary.totals.coveredStatementPercent <= 100,
+            `statement percent should be 0-100, got ${summary.totals.coveredStatementPercent}`);
+
+  // Regression: totalStatementCount must be > 0 for files with actual
+  // statements. A zero here means the AST visitor is not firing.
+  assert.ok(summary.totals.totalStatementCount > 0,
+            `totalStatementCount must be > 0, got ${summary.totals.totalStatementCount}`);
+
+  // Each file should have statement data
+  for (const file of summary.files) {
+    assert.ok('coveredStatementPercent' in file,
+              `${file.path} should have coveredStatementPercent`);
+    assert.ok('totalStatementCount' in file,
+              `${file.path} should have totalStatementCount`);
+    assert.ok('coveredStatementCount' in file,
+              `${file.path} should have coveredStatementCount`);
+    assert.ok(Array.isArray(file.statements),
+              `${file.path} should have statements array`);
+
+    // Verify statement reports have the right shape
+    for (const stmt of file.statements) {
+      assert.ok('line' in stmt, 'statement should have line');
+      assert.ok('count' in stmt, 'statement should have count');
+    }
+  }
+});
+
+test('statement coverage reports covered and uncovered statements', () => {
+  const result = spawnSync(process.execPath, [
+    '--test',
+    '--experimental-test-coverage',
+    '--test-coverage-exclude=!test/**',
+    '--test-reporter', reporter,
+    fixture,
+  ]);
+
+  assert.strictEqual(result.status, 0);
+  const { summary } = JSON.parse(result.stdout.toString());
+  const coverageFile = summary.files.find((f) => f.path.endsWith('coverage.js'));
+
+  assert.ok(coverageFile, 'coverage.js should be in the report');
+
+  // Regression: totalStatementCount must be > 0 for files with actual
+  // statements. A zero here means the AST visitor is not firing.
+  assert.ok(coverageFile.totalStatementCount > 0,
+            `totalStatementCount must be > 0, got ${coverageFile.totalStatementCount}`);
+
+  // The file has uncalled functions and dead branches, so statement
+  // coverage should be less than 100%.
+  assert.ok(coverageFile.coveredStatementPercent < 100,
+            'coverage.js should have uncovered statements');
+  assert.ok(coverageFile.coveredStatementPercent > 0,
+            'coverage.js should have some covered statements');
+
+  // Verify specific uncovered statements exist
+  const uncoveredStmts = coverageFile.statements.filter((s) => s.count === 0);
+  assert.ok(uncoveredStmts.length > 0,
+            'should have uncovered statements');
+
+  // The uncalled function body should have uncovered statements
+  const coveredStmts = coverageFile.statements.filter((s) => s.count > 0);
+  assert.ok(coveredStmts.length > 0,
+            'should have covered statements');
+});
+
+// Threshold passing/failing/out-of-range tests are in
+// test-runner-coverage-thresholds.js via the data-driven coverages loop.
+
+test('statement coverage column appears in report', () => {
+  const result = spawnSync(process.execPath, [
+    '--experimental-test-coverage',
+    '--test-coverage-exclude=!test/**',
+    '--test-reporter', 'tap',
+    fixture,
+  ]);
+
+  const stdout = result.stdout.toString();
+  assert.ok(stdout.includes('stmts %'), 'report should include stmts % column');
+  assert.ok(stdout.includes('start of coverage report'),
+            'report should contain coverage report');
+});
+
+test('100% statement coverage for fully covered file', () => {
+  const result = spawnSync(process.execPath, [
+    '--test',
+    '--experimental-test-coverage',
+    '--test-coverage-exclude=!test/**',
+    '--test-reporter', reporter,
+    fixture,
+  ]);
+
+  assert.strictEqual(result.status, 0);
+  const { summary } = JSON.parse(result.stdout.toString());
+
+  // invalid-tap.js should have 100% statement coverage
+  const invalidTap = summary.files.find((f) => f.path.endsWith('invalid-tap.js'));
+  assert.ok(invalidTap, 'invalid-tap.js should be in the report');
+  assert.strictEqual(invalidTap.coveredStatementPercent, 100);
+});
+
+test('statement coverage differs from line coverage on multistatement lines', () => {
+  const multiFixture = fixtures.path('test-runner', 'coverage-multistatement.js');
+  const result = spawnSync(process.execPath, [
+    '--test',
+    '--experimental-test-coverage',
+    '--test-coverage-exclude=!test/**',
+    '--test-reporter', reporter,
+    multiFixture,
+  ]);
+
+  assert.strictEqual(result.stderr.toString(), '');
+  assert.strictEqual(result.status, 0);
+
+  const { summary } = JSON.parse(result.stdout.toString());
+  const file = summary.files.find(
+    (f) => f.path.endsWith('coverage-multistatement.js'),
+  );
+
+  assert.ok(file, 'coverage-multistatement.js should be in the report');
+  assert.ok(file.totalStatementCount > 0,
+            'should have statements');
+
+  // The key assertion: statement coverage should be LOWER than line
+  // coverage because multiple statements share single lines where
+  // only some execute (e.g. early returns, single-line if/else).
+  assert.ok(file.coveredStatementPercent < file.coveredLinePercent,
+            `statement % (${file.coveredStatementPercent}) should be ` +
+            `lower than line % (${file.coveredLinePercent})`);
+
+  // The uncalled function has statements that are never executed
+  const uncoveredStmts = file.statements.filter((s) => s.count === 0);
+  assert.ok(uncoveredStmts.length > 0,
+            'should have uncovered statements from skipped branches and neverCalled');
+});
+
+test('shebang files get real statement coverage with allowHashBang', () => {
+  const shebangFixture = fixtures.path('test-runner', 'coverage-shebang.js');
+  const result = spawnSync(process.execPath, [
+    '--test',
+    '--experimental-test-coverage',
+    '--test-coverage-exclude=!test/**',
+    '--test-reporter', reporter,
+    shebangFixture,
+  ]);
+
+  assert.strictEqual(result.stderr.toString(), '');
+  assert.strictEqual(result.status, 0);
+
+  const { summary } = JSON.parse(result.stdout.toString());
+  const file = summary.files.find(
+    (f) => f.path.endsWith('coverage-shebang.js'),
+  );
+
+  assert.ok(file, 'coverage-shebang.js should be in the report');
+
+  // With allowHashBang: true, acorn parses the file successfully
+  // and totalStatementCount should be > 0 (not degraded to null).
+  assert.ok(file.totalStatementCount > 0,
+            `shebang file must have statements, got ${file.totalStatementCount}`);
+
+  // The farewell() function is uncalled, so coverage should be < 100%
+  assert.ok(file.coveredStatementPercent < 100,
+            'should have uncovered statements from farewell()');
+  assert.ok(file.coveredStatementPercent > 0,
+            'should have covered statements from greet()');
+});
+
+test('unparseable files degrade gracefully to zero statements', () => {
+  const unparseableTest = fixtures.path(
+    'test-runner', 'coverage-unparseable-test.js',
+  );
+  const result = spawnSync(process.execPath, [
+    '--test',
+    '--experimental-test-coverage',
+    '--test-coverage-exclude=!test/**',
+    '--test-reporter', reporter,
+    unparseableTest,
+  ]);
+
+  assert.strictEqual(result.stderr.toString(), '');
+  assert.strictEqual(result.status, 0);
+
+  const { summary } = JSON.parse(result.stdout.toString());
+  const file = summary.files.find(
+    (f) => f.path.endsWith('coverage-unparseable.js'),
+  );
+
+  assert.ok(file, 'coverage-unparseable.js should be in the report');
+
+  // The file uses top-level `using` which is valid at runtime (CJS wrapper)
+  // but acorn cannot parse as sourceType:'script'. Statement coverage
+  // degrades to 0 total statements while other metrics still work.
+  assert.strictEqual(file.totalStatementCount, 0,
+                     'unparseable file should have 0 statements');
+  assert.strictEqual(file.coveredStatementCount, 0,
+                     'unparseable file should have 0 covered statements');
+  assert.strictEqual(file.coveredStatementPercent, 100,
+                     'unparseable file should degrade to 100% statement coverage');
+  assert.ok(Array.isArray(file.statements) && file.statements.length === 0,
+            'unparseable file should have empty statements array');
+
+  // Line and function coverage should still work normally
+  assert.ok(file.totalLineCount > 0,
+            'line coverage should still work for unparseable files');
+});
+
+test('statement coverage counts class and function declarations', () => {
+  const classFixture = fixtures.path('test-runner', 'coverage-class.js');
+  const result = spawnSync(process.execPath, [
+    '--test',
+    '--experimental-test-coverage',
+    '--test-coverage-exclude=!test/**',
+    '--test-reporter', reporter,
+    classFixture,
+  ]);
+
+  assert.strictEqual(result.stderr.toString(), '');
+  assert.strictEqual(result.status, 0);
+
+  const { summary } = JSON.parse(result.stdout.toString());
+  const classFile = summary.files.find(
+    (f) => f.path.endsWith('coverage-class.js'),
+  );
+
+  assert.ok(classFile, 'coverage-class.js should be in the report');
+  assert.ok(classFile.totalStatementCount > 0,
+            `totalStatementCount must be > 0, got ${classFile.totalStatementCount}`);
+
+  // The file has an unused class, so statement coverage should be < 100%.
+  assert.ok(classFile.coveredStatementPercent < 100,
+            'should have uncovered statements from UnusedClass');
+  assert.ok(classFile.coveredStatementPercent > 0,
+            'should have covered statements from Dog/Animal');
+});
diff --git a/test/parallel/test-runner-coverage-thresholds.js b/test/parallel/test-runner-coverage-thresholds.js
index e45e1191299ca7..5580d22a46b7cc 100644
--- a/test/parallel/test-runner-coverage-thresholds.js
+++ b/test/parallel/test-runner-coverage-thresholds.js
@@ -20,22 +20,21 @@ function findCoverageFileForPid(pid) {
 }
 
 function getTapCoverageFixtureReport() {
-
   const report = [
     '# start of coverage report',
-    '# --------------------------------------------------------------------------------------------',
-    '# file              | line % | branch % | funcs % | uncovered lines',
-    '# --------------------------------------------------------------------------------------------',
-    '# test              |        |          |         | ',
-    '#  fixtures         |        |          |         | ',
-    '#   test-runner     |        |          |         | ',
-    '#    coverage.js    |  78.65 |    38.46 |   60.00 | 12-13 16-22 27 39 43-44 61-62 66-67 71-72',
-    '#    invalid-tap.js | 100.00 |   100.00 |  100.00 | ',
-    '#   v8-coverage     |        |          |         | ',
-    '#    throw.js       |  71.43 |    50.00 |  100.00 | 5-6',
-    '# --------------------------------------------------------------------------------------------',
-    '# all files         |  78.35 |    43.75 |   60.00 | ',
-    '# --------------------------------------------------------------------------------------------',
+    '# --------------------------------------------------------------------------------------------------------',
+    '# file              | stmts % | line % | branch % | funcs % | uncovered lines',
+    '# --------------------------------------------------------------------------------------------------------',
+    '# test              |         |        |          |         | ',
+    '#  fixtures         |         |        |          |         | ',
+    '#   test-runner     |         |        |          |         | ',
+    '#    coverage.js    |   75.00 |  78.65 |    38.46 |   60.00 | 12-13 16-22 27 39 43-44 61-62 66-67 71-72',
+    '#    invalid-tap.js |  100.00 | 100.00 |   100.00 |  100.00 | ',
+    '#   v8-coverage     |         |        |          |         | ',
+    '#    throw.js       |   80.00 |  71.43 |    50.00 |  100.00 | 5-6',
+    '# --------------------------------------------------------------------------------------------------------',
+    '# all files         |   76.00 |  78.35 |    43.75 |   60.00 | ',
+    '# --------------------------------------------------------------------------------------------------------',
     '# end of coverage report',
   ].join('\n');
 
@@ -54,6 +53,7 @@ const coverages = [
   { flag: '--test-coverage-lines', name: 'line', actual: 78.35 },
   { flag: '--test-coverage-functions', name: 'function', actual: 60.00 },
   { flag: '--test-coverage-branches', name: 'branch', actual: 43.75 },
+  { flag: '--test-coverage-statements', name: 'statement', actual: 76.00 },
 ];
 
 for (const coverage of coverages) {