monocart-coverage-reports 3.1.0 → 3.2.0

package/README.md

@@ -868,6 +868,53 @@ const coverageOptions = {
 };
 ```
 
+### `onTestEnd` — `mcr test` only
+
+`onTestEnd(testResults)` runs once after the test runner exits and its JSON results are collected, before publishing the test results cache, `onReady`, and coverage generation. It is awaited even when assertions fail. Other commands, API calls, and runs skipped because no targets were supplied do not call it. The existing `onEnd(coverageResults)` is unchanged.
+
+`mcr test` always collects structured test results using an internal JSON reporter, preserving terminal output and user-specified reporter/destination pairs. `onTestEnd` is optional; omitting it does not disable result collection. To retain results for later use, enable `raw` reports or debug logging; normal cache cleanup still applies.
+
+```js
+// mcr.config.js
+export default {
+    test: './test/**/*.test.js',
+    onTestEnd: (testResults) => {
+        console.log(testResults.summary);
+        for (const test of testResults.tests) {
+            console.log(test.name, test.status, test.error);
+        }
+    }
+};
+```
+
+- `id`: a collection ID generated with the same `Util.uid()` mechanism as coverage cache data.
+- `framework`: `'node:test'`.
+- `complete`: whether the final runner summary was received, not whether tests passed.
+- `summary`: `{ tests, suites, passed, failed, cancelled, skipped, todo, duration, success }`; `null` if incomplete. Counts come from the runner's final summary; `tests` excludes suites. Durations are in milliseconds.
+- `tests`: completed test and suite records, including nested tests: `{ name, type, nesting, testNumber, file?, line?, column?, duration, status, skip?, todo?, error? }`. Status is `passed`, `failed`, `cancelled`, `skipped`, or `todo`. Errors always include string `name` and `message` (defaults: `'Error'` and `''`). Other own enumerable data properties are copied only when their values are strings, booleans, finite numbers, or `null`; BigInts become decimal strings. Getters/setters, objects/arrays, functions, symbols, `undefined`, `NaN`, and infinities are omitted without recursive traversal. Apart from the two fixed fields, inherited/non-enumerable properties are not collected, so normal `stack` is omitted and fields inside `cause` are not flattened. Explicitly enumerable string `stack` is copied like any other string. Reserved keys `__proto__`, `constructor`, and `prototype` are excluded; the fixed fields cannot be overwritten by extra properties.
+
+Test failures, incomplete/missing/invalid reports, and hook errors keep the command nonzero. An incomplete report is delivered with `complete: false`; a missing or invalid JSON report cannot be delivered and is logged as a collection error. A nonzero `process.exitCode` set by `onTestEnd` cannot be cleared by later coverage hooks. Hook/collection errors do not prevent MCR from attempting coverage generation. If the hook throws, test results are not published or exported, rather than falling back to possibly unredacted data. Test results are independent of coverage, so this hook can run even if coverage generation later fails.
+
+Test results use the same ID and filename mechanism as coverage cache data: `outputDir/.cache/test-results-<id>.json`, with the same `id` stored in the JSON. The reporter streams records into `.json.tmp` with its collection ID already included. A small `.meta.tmp` completion record verifies the final byte count. Without a hook, MCR reads only this completion record and renames the JSON, without loading or rewriting the full report. With a hook, MCR reads the full result object and publishes its mutations after the hook completes. Temporary output and metadata are removed before coverage generation. Finalized JSON follows the coverage cache lifecycle: normally cleaned after generation, retained in debug mode, or exported by `raw` (including ZIP). It is not embedded in HTML/coverage JSON reports, and importing raw data does not yet merge test results. Save results yourself if needed; files written into `outputDir` by this hook may be removed by the subsequent coverage cleanup when `clean: true`.
+
+**Sensitive data:** Primitive does not mean non-sensitive: a string `token`, `password`, or response body is also copied. Messages, test names, and paths may contain credentials or personal data; large strings can also increase report size. MCR does not redact them automatically. Keep the output directory private and review raw/debug artifacts before uploading them. Mutate results in `onTestEnd` to sanitize the persisted JSON; this does not redact Node's terminal output or data already written to temporary files. For example, adapt the following rule to your application's data:
+
+```js
+export default {
+    onTestEnd: (results) => {
+        for (const test of results.tests) {
+            if (test.error) {
+                for (const [key, value] of Object.entries(test.error)) {
+                    if (typeof value === 'string') {
+                        test.error[key] = value.replace(/(Bearer\s+)\S+/gi, '$1[REDACTED]');
+                    }
+                }
+            }
+        }
+    }
+};
+```
+
 ### `onStart` / `onReady` — CLI-only
 Only available when using `mcr <command>`:
 - `onStart(coverageReport)` — runs before the child process is spawned.
@@ -985,6 +1032,7 @@ The options below are only available when using the CLI (`mcr <command>`):
 | `--require` | `string` | `null` | Deprecated alias for `--import`; uses ESM loading, not CommonJS resolution |
 | `--env` | `string` | `null` | Load environment variables from a dotenv file (defaults to `.env`). |
 | `test` (config only) | `string \| string[] \| null` | `null` | Default test file paths or glob patterns accepted by `node --test`, passed unchanged when `mcr test` has no positional targets; ignored by other commands and the API. Requires Node.js `>= 22.15.0` |
+| `onTestEnd` (config only) | `(testResults) => void \| Promise<void>` | `null` | Only `mcr test`: runs after test result collection, before `onReady` and coverage generation; see [Hooks](#hooks) |
 | `onStart` | `(coverageReport) => Promise<void>` | `null` | Runs before the child process is spawned; see [Hooks](#hooks) |
 | `onReady` | `(coverageReport, nodeV8CoverageDir, subprocess) => Promise<void>` | `null` | Runs after the child exits, before MCR reads coverage; see [Hooks](#hooks) |
 
@@ -1103,6 +1151,9 @@ The following usage scenarios may require merging coverage reports:
 ### Manual Merging
 If the reports cannot be merged automatically, then here is how to manually merge the reports.  
 First, using the `raw` report to export the original coverage data to the specified directory.
+
+**Before uploading raw/debug artifacts (3.2.0+):** `mcr test` also exports `test-results-<id>.json` in raw reports (including ZIP) and retains it in debug caches, even without a hook. Test names, paths and error strings may contain secrets or personal data. Review artifacts and use [`onTestEnd`](#ontestend--mcr-test-only) to redact persisted test results before publication; this does not redact terminal output or temporary files already written. Raw imports merge coverage only, not test results.
+
 - For example, we have `raw` coverage data from `unit test`, which is output to `./coverage-reports/unit/raw`. Unit test examples:
     - `Jest` + [jest-monocart-coverage](https://github.com/cenfun/jest-monocart-coverage)
     - `Vitest` + [vitest-monocart-coverage](https://github.com/cenfun/vitest-monocart-coverage)

package/README.zh-Hans.md

@@ -871,6 +871,53 @@ const coverageOptions = {
 };
 ```
 
+### `onTestEnd` — 仅 `mcr test` 可用
+
+`onTestEnd(testResults)` 在测试运行器退出、JSON 测试结果采集完成后触发一次，早于测试结果缓存发布、`onReady` 和覆盖率报告生成。支持异步等待，测试断言失败时也会触发。其他命令、API 调用，以及因未提供目标而跳过的测试，不触发该 hook。现有 `onEnd(coverageResults)` 保持不变。
+
+`mcr test` 始终通过内部 JSON reporter 采集结构化测试结果，同时保留终端输出和用户指定的 reporter/destination 配对。`onTestEnd` 为可选回调，不配置也不会关闭采集。如需留待后续使用，请启用 `raw` 报告或 debug 日志；默认的缓存清理规则仍然生效。
+
+```js
+// mcr.config.js
+export default {
+    test: './test/**/*.test.js',
+    onTestEnd: (testResults) => {
+        console.log(testResults.summary);
+        for (const test of testResults.tests) {
+            console.log(test.name, test.status, test.error);
+        }
+    }
+};
+```
+
+- `id`：采用与覆盖率缓存数据相同的 `Util.uid()` 机制生成的采集 ID。
+- `framework`：`'node:test'`。
+- `complete`：是否收到运行器最终汇总，不代表测试是否通过。
+- `summary`：`{ tests, suites, passed, failed, cancelled, skipped, todo, duration, success }`，报告不完整时为 `null`。计数采用运行器最终汇总，`tests` 不包含 suite，耗时单位为毫秒。
+- `tests`：已完成的测试及 suite 记录，包含嵌套测试：`{ name, type, nesting, testNumber, file?, line?, column?, duration, status, skip?, todo?, error? }`。状态为 `passed`、`failed`、`cancelled`、`skipped` 或 `todo`。错误固定包含字符串 `name`、`message`，不可用或非字符串时分别使用 `'Error'`、`''`。其余只复制自有、可枚举的数据属性，值仅限字符串、布尔值、有限数字和 `null`；BigInt 转为十进制字符串。不递归遍历，跳过 getter/setter、对象/数组、函数、Symbol、`undefined`、`NaN` 和无穷数。除两个固定字段外，不采集继承或不可枚举属性，因此通常不包含 `stack`，也不展开 `cause` 内的字段；明确设为可枚举的字符串 `stack` 仍按普通字符串复制。过滤 `__proto__`、`constructor`、`prototype` 等特殊键，额外属性不会覆盖固定字段。
+
+测试失败、报告不完整/缺失/损坏或 hook 抛错，均保持非零退出状态。不完整报告以 `complete: false` 交付；缺失或无效的 JSON 无法交付，会明确记录采集错误。`onTestEnd` 设置的非零 `process.exitCode` 不会被后续覆盖率 hook 清零。hook 或采集失败后仍尝试生成覆盖率报告。hook 抛错时不会发布或导出测试结果，避免回退导出可能尚未脱敏的数据。测试结果独立于覆盖率，因此即使后续覆盖率生成失败，此 hook 仍可执行。
+
+测试结果复用覆盖率缓存的 ID 和文件命名机制：`outputDir/.cache/test-results-<id>.json`，JSON 内容保存同一个 `id`。reporter 将记录逐条写入 `.json.tmp`，输出时即包含采集 ID，并通过很小的 `.meta.tmp` 完成记录校验最终字节数。没有 hook 时，MCR 只读取完成记录并重命名 JSON，不会加载或重写完整报告；配置 hook 时，读取完整结果对象，在 hook 完成后将修改后的数据发布为正式缓存。临时输出和元数据均在生成覆盖率前清理。正式 JSON 遵循覆盖率缓存生命周期：正常生成后清理、调试模式保留，或由 `raw` 报告导出（包括 ZIP）。它不会嵌入 HTML/覆盖率 JSON 报告，导入 raw 数据目前也不会合并测试结果。如需持久化，请自行保存；当 `clean: true` 时，此 hook 写入 `outputDir` 的文件可能被后续覆盖率清理流程删除。
+
+**敏感信息提醒：** 基础类型不等于非敏感数据，字符串 `token`、`password` 或响应正文同样会被复制。错误消息、测试名称和路径也可能包含凭据或个人信息，大字符串仍可能增大报告体积，MCR 不会自动脱敏。请保护输出目录，并在上传 raw/debug 产物前审查内容。可在 `onTestEnd` 中修改结果，对正式保存的 JSON 脱敏；这不会处理 Node 的终端输出或已经写入临时文件的数据。以下规则仅为示例，请按业务数据调整：
+
+```js
+export default {
+    onTestEnd: (results) => {
+        for (const test of results.tests) {
+            if (test.error) {
+                for (const [key, value] of Object.entries(test.error)) {
+                    if (typeof value === 'string') {
+                        test.error[key] = value.replace(/(Bearer\s+)\S+/gi, '$1[REDACTED]');
+                    }
+                }
+            }
+        }
+    }
+};
+```
+
 ### `onStart` / `onReady` — 仅CLI可用
 只在使用 `mcr <command>` 时有效:
 - `onStart(coverageReport)` — 子进程启动前触发
@@ -988,6 +1035,7 @@ npx mcr node ./test/specs/node.test.js -r v8,console-details --lcov
 | `--require` | `string` | `null` | `--import` 的已弃用别名；使用 ESM 加载，不使用 CommonJS 解析 |
 | `--env` | `string` | `null` | 从 dotenv 文件加载环境变量（默认 `.env`）。|
 | `test`（仅配置文件） | `string \| string[] \| null` | `null` | 未指定命令行目标时，原样传给 `node --test` 的默认测试文件路径或 glob，**仅 `mcr test` 使用**；其他命令和 API 忽略。需要 Node.js `>= 22.15.0` |
+| `onTestEnd`（仅配置文件） | `(testResults) => void \| Promise<void>` | `null` | 仅 `mcr test`：测试结果采集完成后、`onReady` 和覆盖率生成前触发；参见 [Hooks](#hooks) |
 | `onStart` | `(coverageReport) => Promise<void>` | `null` | 子进程启动前触发；参见 [Hooks](#hooks) |
 | `onReady` | `(coverageReport, nodeV8CoverageDir, subprocess) => Promise<void>` | `null` | 子进程退出后、MCR 读取覆盖率前触发；参见 [Hooks](#hooks) |
 
@@ -1105,6 +1153,9 @@ npx mcr -c ./mcr.config.js -- test "../tests/**/*.test.js" -- --test-reporter=sp
 
 ### Manual Merging
 手动合并覆盖率报告需要使用`raw`报告来导出原始的覆盖率数据到指定的目录
+
+**上传 raw/debug 产物前请注意（3.2.0+）：** 即使未配置 hook，`mcr test` 也会在 raw 报告（包括 ZIP）中导出 `test-results-<id>.json`，并在 debug 缓存中保留该文件。测试名称、路径及错误字符串可能包含凭据或个人信息。请先审查产物，并通过 [`onTestEnd`](#ontestend--仅-mcr-test-可用) 在发布前对正式保存的测试结果脱敏；这不会处理终端输出或已写入的临时文件。导入 raw 数据只合并覆盖率，不会合并测试结果。
+
 - 比如，单元测试保存到`./coverage-reports/unit/raw`，见例子
     - `Jest` + [jest-monocart-coverage](https://github.com/cenfun/jest-monocart-coverage)
     - `Vitest` + [vitest-monocart-coverage](https://github.com/cenfun/vitest-monocart-coverage)

package/lib/cli.js

@@ -9,6 +9,7 @@ import { program } from 'commander';
 import { execa } from 'execa';
 
 import { MCR } from './index.js';
+import { getTestCommand, createTestRunner } from './test/test-runner.js';
 import { Util } from './utils/util.js';
 import pkg from '../package.json' with { type: 'json' };
 
@@ -85,17 +86,6 @@ const mergeCoverage = async (cliOptions) => {
     await coverageReport.generate();
 };
 
-// Only check whether targets were supplied. Node owns all target parsing,
-// discovery and validation; preserve each argument exactly as provided.
-const getTestTargets = (test) => {
-    if (!test || (Array.isArray(test) && !test.length)) {
-        Util.logInfo('No test targets configured; skipping tests.');
-        return;
-    }
-
-    return Array.isArray(test) ? test : [test];
-};
-
 // Preserve signals and failing commands even if a hook sets exitCode=0.
 const getExitStatus = (code, signal) => signal || code || process.exitCode || 0;
 
@@ -177,24 +167,19 @@ const executeCommand = async ([command, ... commandArgs], cliOptions, testArgs =
 
     // console.log(options);
     const coverageReport = MCR(cliOptions);
-    const isTest = command === 'test';
     await coverageReport.loadConfig(cliOptions.config);
 
     const coverageOptions = coverageReport.options;
-    let childArgs;
-    if (isTest) {
-        const targets = getTestTargets(coverageOptions.test);
-        if (!targets) {
+    let testRunner;
+    if (command === 'test') {
+        testRunner = createTestRunner(coverageOptions, testArgs);
+        if (!testRunner) {
             return;
         }
-        childArgs = ['--test', ... testArgs, ... targets];
     }
     coverageReport.cleanCache();
     const nodeV8CoverageDir = initNodeV8CoverageDir(coverageOptions);
-    if (isTest) {
-        // Tests may spawn children with a different working directory.
-        process.env.NODE_V8_COVERAGE = path.resolve(nodeV8CoverageDir);
-    }
+    testRunner?.initCoverageDir(nodeV8CoverageDir);
 
     // =========================================
     // onStart hook
@@ -204,22 +189,26 @@ const executeCommand = async ([command, ... commandArgs], cliOptions, testArgs =
     }
     // =========================================
 
-    const onClose = async (code, signal, subprocess) => {
+    const generateCoverage = async (subprocess) => {
+        // onReady hook before adding coverage data. Some children need
+        // additional time to finish writing their coverage files.
+        const onReady = coverageOptions.onReady;
+        if (typeof onReady === 'function') {
+            await onReady(coverageReport, nodeV8CoverageDir, subprocess);
+        }
+        await coverageReport.addFromDir(nodeV8CoverageDir);
+        return coverageReport.generate();
+    };
 
-        // generate coverage even it is failed. code != 0
+    const onClose = async (code, signal, subprocess) => {
 
+        // Generate coverage even when the child failed (code != 0).
         try {
-            // onReady hook before adding coverage data. Some children need
-            // additional time to finish writing their coverage files.
-            const onReady = coverageOptions.onReady;
-            if (typeof onReady === 'function') {
-                await onReady(coverageReport, nodeV8CoverageDir, subprocess);
-            }
-
-            await coverageReport.addFromDir(nodeV8CoverageDir);
-            const report = await coverageReport.generate();
-            if (isTest && !report) {
-                throw new Error('No coverage report was generated');
+            const generate = () => generateCoverage(subprocess);
+            if (testRunner) {
+                await testRunner.onClose(generate);
+            } else {
+                await generate();
             }
         } catch (error) {
             Util.logError(`Coverage report generation failed: ${error.message}`);
@@ -233,8 +222,8 @@ const executeCommand = async ([command, ... commandArgs], cliOptions, testArgs =
         return getExitStatus(code, signal);
     };
 
-    if (isTest) {
-        return executeSubprocess(process.execPath, childArgs, onClose);
+    if (testRunner) {
+        return testRunner.execute(executeSubprocess, onClose);
     }
     return executeSubprocess(command, commandArgs, onClose);
 
@@ -261,30 +250,6 @@ process.argv.forEach((it) => {
     }
 });
 
-// Also recognize `mcr -c config -- test targets -- runner-options` without
-// falling through to the shell's unrelated `test` command. Only MCR options
-// before the first separator are parsed in that form.
-const getTestCommand = (args, subArgs) => {
-    if (args[0] === 'test') {
-        return {
-            targets: args.slice(1), runnerArgs: subArgs.slice(1)
-        };
-    }
-    if (args.length || subArgs[1] !== 'test') {
-        return;
-    }
-    const remaining = subArgs.slice(2);
-    const index = remaining.indexOf('--');
-    if (index === -1) {
-        return {
-            targets: remaining, runnerArgs: []
-        };
-    }
-    return {
-        targets: remaining.slice(0, index), runnerArgs: remaining.slice(index + 1)
-    };
-};
-
 program
     .name('mcr')
     .description('CLI to generate coverage reports')

package/lib/converter/converter.js

@@ -761,31 +761,25 @@ const handleOriginalEmptyBytesCoverage = (state, originalStateMap) => {
         }
 
         const { decodedMappings } = originalState;
-        const len = decodedMappings.length;
-        if (len < 2) {
-            return;
-        }
-        // sort by original line/column
-        const startMapping = decodedMappings[0];
-        const endMapping = decodedMappings[len - 1];
-        // console.log(startMapping, endMapping);
-        const startOffset = startMapping.generatedOffset;
-
-        if (!endMapping.generatedEndOffset) {
-            // line last one
-            const line = state.locator.getLine(endMapping.generatedLine + 1);
-            // could be no line found
-            if (line) {
-                // last column
-                endMapping.generatedEndOffset = line.end;
-            } else {
-                endMapping.generatedEndOffset = endMapping.generatedOffset;
+        // The generated range the file's own mappings start in. Leave out the
+        // added line-end mappings: the last one is at the end of its line, which
+        // in a minified bundle is the end of the whole script, not of the wrapper
+        // the file is in.
+        let startOffset = Infinity;
+        let endOffset = -Infinity;
+        decodedMappings.forEach((mapping) => {
+            if (mapping.end) {
+                return;
             }
-        }
-        const endOffset = endMapping.generatedEndOffset;
+            startOffset = Math.min(startOffset, mapping.generatedOffset);
+            endOffset = Math.max(endOffset, mapping.generatedOffset);
+        });
 
-        // console.log('===========================================================', originalState.sourcePath);
-        // console.log(originalState.source.length, endMapping);
+        // A single real mapping is enough; auxiliary line-end mappings are not
+        // guaranteed for every source. Do not infer coverage without mappings.
+        if (startOffset === Infinity) {
+            return;
+        }
 
         checkList.push({
             originalState,
@@ -819,7 +813,9 @@ const handleOriginalEmptyBytesCoverage = (state, originalStateMap) => {
             if (range.count > 0) {
                 continue;
             }
-            if (startOffset >= range.start && endOffset <= range.end) {
+            // endOffset is the last mapping's start, not an exclusive end.
+            // V8 ranges exclude range.end, so a mapping there is outside.
+            if (startOffset >= range.start && endOffset < range.end) {
                 // console.log('------------', 'added');
                 originalState.bytes.push({
                     start: 0,

package/lib/default/options.js

@@ -111,6 +111,11 @@ const defaultOptions = {
     // onEntry: async (entry) => {}
     onEntry: null,
 
+    // (mcr test only) {function} Optional hook before test result publication, onReady and coverage generation.
+    // Results are always collected. Redact sensitive messages/names here before raw/debug export.
+    // onTestEnd: async (testResults) => {}
+    onTestEnd: null,
+
     // {function} onEnd hook
     // onEnd: async (reportData) => {}
     onEnd: null

package/lib/generate.js

@@ -303,8 +303,9 @@ const addZipData = async (mcr, dataList, sourceCache, dir) => {
         }
         const entryName = entry.name;
         const filename = path.basename(entryName);
-        // console.log('============================', filename);
-        if (filename.endsWith('.json')) {
+        // Do not decompress or parse test results (or other unrelated JSON)
+        // when merging coverage. Match the cache reader's accepted prefixes.
+        if (filename.endsWith('.json') && (filename.startsWith('coverage-') || filename.startsWith('source-'))) {
             const buf = await zip.entryData(entryName);
             const json = JSON.parse(buf.toString('utf-8'));
             await addJsonData(mcr, dataList, sourceCache, json, filename);

package/lib/index.d.ts

@@ -271,6 +271,58 @@ declare namespace MCR {
         files: CoverageFile[];
     };
 
+    export interface TestError {
+        /** Fixed string fields; defaults are "Error" and "" for unavailable/non-string values. */
+        name: string;
+        message: string;
+        /** Own enumerable data properties only: strings, booleans, finite numbers,
+         * and null. BigInts become strings; objects, accessors and unsupported values
+         * are omitted. Missing properties read as undefined. Values may be sensitive.
+         */
+        [key: string]: string | number | boolean | null | undefined;
+    }
+
+    export interface TestResult {
+        name: string;
+        type: "test" | "suite";
+        nesting: number;
+        testNumber: number;
+        file?: string;
+        line?: number;
+        column?: number;
+        /** Duration in milliseconds. */
+        duration: number;
+        status: "passed" | "failed" | "cancelled" | "skipped" | "todo";
+        skip?: string | boolean;
+        todo?: string | boolean;
+        error?: TestError;
+    }
+
+    export interface TestSummary {
+        tests: number;
+        suites: number;
+        passed: number;
+        failed: number;
+        cancelled: number;
+        skipped: number;
+        todo: number;
+        /** Duration in milliseconds. */
+        duration: number;
+        success: boolean;
+    }
+
+    export interface TestResults {
+        /** Unique collection ID, also used in test-results-<id>.json. */
+        id: string;
+        framework: "node:test";
+        /** Whether the runner emitted its final summary (not whether tests passed). */
+        complete: boolean;
+        /** Final runner counts, excluding suites from the test count; null if incomplete. */
+        summary: TestSummary | null;
+        /** Completed test and suite records, including nested tests. */
+        tests: TestResult[];
+    }
+
     export type LoggingType = "off" | "error" | "info" | "debug";
     export interface CoverageReportOptions {
 
@@ -449,6 +501,17 @@ declare namespace MCR {
          */
         test?: string | string[] | null;
 
+        /** Optional hook for `mcr test`; results are collected even when omitted.
+         * Runs before publishing the test results cache, onReady and coverage generation,
+         * even when assertions fail. Mutate messages/names here to redact persisted raw/debug
+         * results. Hook errors prevent publication of test results but not coverage generation.
+         * Not called for skipped runs.
+         * Missing/invalid reports fail the command without calling this hook. An incomplete
+         * report has complete=false and summary=null, and also fails the command.
+         * Hook errors fail the command but do not prevent coverage generation.
+         */
+        onTestEnd?: (testResults: TestResults) => void | Promise<void>;
+
         /** (CLI only) {function} onStart hook */
         onStart?: (coverageReport: CoverageReport) => void | Promise<void>;
 
@@ -639,6 +702,10 @@ export import CoverageRange = MCR.CoverageRange;
 export import IgnoredRange = MCR.IgnoredRange;
 export import CoverageFile = MCR.CoverageFile;
 export import CoverageResults = MCR.CoverageResults;
+export import TestError = MCR.TestError;
+export import TestResult = MCR.TestResult;
+export import TestSummary = MCR.TestSummary;
+export import TestResults = MCR.TestResults;
 export import LoggingType = MCR.LoggingType;
 export import CoverageReportOptions = MCR.CoverageReportOptions;
 export import McrCliOptions = MCR.McrCliOptions;