monocart-coverage-reports 3.1.0 → 3.2.1

package/README.md

@@ -14,6 +14,7 @@
 
 * [Usage](#usage)
 * [Best Practices](#best-practices)
+* [AI Agent Skill](#ai-agent-skill)
 * [Options](#options)
 * [Available Reports](#available-reports)
 * [Compare Reports](#compare-reports)
@@ -118,20 +119,21 @@ For detailed setup instructions and examples, see the [best-practices guide](ski
 
 ## AI Agent Skill
 
-For AI-assisted development in a source checkout, start with [AGENTS.md](https://github.com/cenfun/monocart-coverage-reports/blob/main/AGENTS.md). It describes the source layout, development commands, validation, and safety boundaries. `.github/copilot-instructions.md` provides a self-contained summary of the core rules for GitHub Copilot. These checkout-only guides are not included in the npm package and are separate from the reusable integration skill below.
+**Reliable AI-assisted development starts with automated testing.** Test results validate behavior; coverage highlights testing gaps. With **`mcr test`**, AI coding agents can run Node.js tests, collect native V8 coverage, and generate reports without instrumentation. This feedback supports iterative development and CI/CD quality gates, whether an agent assists a developer or works autonomously.
 
-The reusable [Monocart Coverage Reports skill](skills/monocart-coverage-reports/SKILL.md) helps AI coding agents collect coverage, configure the CLI, debug sourcemaps and filters, merge raw reports, and enforce CI thresholds. It uses a main `SKILL.md` with task-specific references loaded on demand, targeting MCR 3.x only and checking its runtime requirements.
+The [Monocart Coverage Reports skill](skills/monocart-coverage-reports/SKILL.md) guides agents through coverage collection, CLI configuration, sourcemap troubleshooting, report merging, and CI thresholds. It targets MCR 3.x and loads task-specific references on demand.
 
-The npm package includes `skills/monocart-coverage-reports/`. Copy this **entire directory**, including `references/`, into your agent's supported skills location, or ask the agent to read `SKILL.md` directly. Installing MCR does not automatically register the skill or modify agent settings. The instructions are in English; requests and responses can use any language.
+The skill ships in the npm package. Copy the **entire `skills/monocart-coverage-reports/` directory**, including `references/`, into your agent's skills directory, or have the agent read `SKILL.md` directly. Installation does not automatically register the skill. The instructions are in English; you can use any language with your agent.
 
-From the host project root, locate the installed skill and package manifest (older releases may not include the skill):
+Locate the installed skill from your project root:
 
 ```sh
 node -p "require.resolve('monocart-coverage-reports/skills/monocart-coverage-reports/SKILL.md')"
-node -p "require.resolve('monocart-coverage-reports/package.json')"
 ```
 
-Read the resolved skill, then follow its relative reference links. Use the installed package's runtime, API, and version requirements rather than assuming all examples apply to older releases. These commands resolve files; they do not import Markdown as JavaScript.
+Follow the skill's reference links and the installed package's version and runtime requirements. Older releases may not include the skill.
+
+For development of MCR itself, see [AGENTS.md](https://github.com/cenfun/monocart-coverage-reports/blob/main/AGENTS.md).
 
 ## Options
 - Default options: [lib/default/options.js](./lib/default/options.js)
@@ -868,6 +870,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 +1034,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 +1153,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

@@ -14,6 +14,7 @@
 
 * [用法](#usage)
 * [最佳实践](#best-practices)
+* [AI Agent Skill](#ai-agent-skill)
 * [选项配置](#options)
 * [所有支持的报告类型](#available-reports)
 * [比较两种报告](#compare-reports)
@@ -118,20 +119,21 @@ mcr node my-app.js -r v8,console-details
 
 ## AI Agent Skill
 
-使用 AI 辅助开发本仓库源码时，请先阅读 [AGENTS.md](https://github.com/cenfun/monocart-coverage-reports/blob/main/AGENTS.md)，了解源码结构、开发命令、验证流程和安全边界。`.github/copilot-instructions.md` 为 GitHub Copilot 提供可独立使用的核心规则摘要。这些指南仅用于源码仓库，不随 npm 包发布，与下面可复用的集成技能相互独立。
+**可靠的 AI 辅助开发离不开自动化测试。** 测试结果验证代码行为，覆盖率帮助识别测试缺口。通过 **`mcr test`**，AI 编程助手可直接运行 Node.js 测试、采集原生 V8 覆盖率并生成报告，无需插桩。测试与覆盖率反馈支持持续迭代，并可结合 CI/CD 质量门禁，用于 AI 辅助或自主开发。
 
-项目提供可复用的 [Monocart Coverage Reports 技能](skills/monocart-coverage-reports/SKILL.md)，帮助 AI coding agent 采集覆盖率、配置 CLI、排查 sourcemap 和过滤问题、合并 raw 报告及设置 CI 阈值。结构为主 `SKILL.md` 加按需加载的专题参考文档，仅面向 MCR 3.x，并检查其运行环境要求。
+[Monocart Coverage Reports 技能](skills/monocart-coverage-reports/SKILL.md) 指导 AI 配置覆盖率采集和 CLI、排查 sourcemap 问题、合并报告及设置 CI 阈值，适用于 MCR 3.x，专题参考文档按需加载。
 
-npm 包包含 `skills/monocart-coverage-reports/`。请将**整个目录**（包括 `references/`）复制到 agent 支持的 skills 目录，或直接让 agent 读取 `SKILL.md`。安装 MCR 不会自动注册技能或修改 agent 配置。技能说明使用英文，但提问和回复可以使用中文或其他语言。
+技能随 npm 包发布。将**整个 `skills/monocart-coverage-reports/` 目录**（含 `references/`）复制到 AI 工具的技能目录，或让 AI 直接读取 `SKILL.md`。安装 MCR 不会自动注册技能。技能说明使用英文，与 AI 交流可使用任意语言。
 
-在使用 MCR 的项目根目录中定位已安装的技能和包配置（旧版本可能尚未包含技能）：
+在项目根目录定位已安装的技能：
 
 ```sh
 node -p "require.resolve('monocart-coverage-reports/skills/monocart-coverage-reports/SKILL.md')"
-node -p "require.resolve('monocart-coverage-reports/package.json')"
 ```
 
-读取定位到的技能文件，再按相对链接读取专题文档。请以已安装包的运行时、API 和版本要求为准，不要假设所有示例都适用于旧版本。以上命令用于定位文件，不是将 Markdown 作为 JavaScript 导入。
+按技能中的链接查阅参考文档，并以已安装包的版本和运行环境要求为准。旧版本可能不包含该技能。
+
+开发 MCR 本身时，请参阅 [AGENTS.md](https://github.com/cenfun/monocart-coverage-reports/blob/main/AGENTS.md)。
 
 ## Options
 - 默认选项: [lib/default/options.js](./lib/default/options.js)
@@ -871,6 +873,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 +1037,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 +1155,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/ast-visitor.js

@@ -489,6 +489,7 @@ const viteImportDefaultHandler = (node, group) => {
 
 const collectNodes = (ast) => {
     const functionNodes = [];
+    const initializerNodes = [];
     const statementNodes = [];
     const blockNodes = [];
     const branchMap = new Map();
@@ -514,6 +515,12 @@ const collectNodes = (ast) => {
             });
         },
 
+        PropertyDefinition: (node) => {
+            if (node.value) {
+                initializerNodes.push(node);
+            }
+        },
+
         // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Classes/static
         // as a function "functionName": "<static_initializer>",
         StaticBlock: (node, parents) => {
@@ -646,6 +653,7 @@ const collectNodes = (ast) => {
 
     return {
         functionNodes,
+        initializerNodes,
         statementNodes,
         blockNodes,
         branchMap
@@ -735,12 +743,30 @@ const findFunctionRange = (item, coverageInfo) => {
 const collectAstInfo = (ast, coverageInfo) => {
 
     const {
-        functionNodes, statementNodes, blockNodes, branchMap
+        functionNodes, initializerNodes, statementNodes, blockNodes, branchMap
     } = collectNodes(ast);
 
     // root function state
     const rootState = getRootFunctionState(ast, coverageInfo);
 
+    // V8 groups field values into implicit functions. Use their counts and
+    // block ranges without adding synthetic functions to the report. Keys
+    // execute at class definition time, so only the value gets this state.
+    initializerNodes.forEach((node) => {
+        const ranges = node.static ? coverageInfo.functionStaticRanges : coverageInfo.functionInstanceRanges;
+        const { value } = node;
+        const range = Util.findInRanges(value.start, value.end, ranges, 'startOffset', 'endOffset');
+        if (range) {
+            value._state = {
+                isFunction: true,
+                count: range.count,
+                range
+            };
+        }
+    });
+
+    // Explicit functions (including arrow-valued fields) keep their own
+    // execution state, overriding any initializer state on the value node.
     const functions = [];
     functionNodes.forEach((item) => {
         const { node } = item;

package/lib/converter/ast.js

@@ -9,6 +9,7 @@ const getCoverageInfo = (coverageList) => {
     const functionMap = new Map();
     const functionNameMap = new Map();
     const functionStaticRanges = [];
+    const functionInstanceRanges = [];
     const functionUncoveredRanges = [];
 
     let rootRange;
@@ -66,6 +67,9 @@ const getCoverageInfo = (coverageList) => {
         if (functionName === '<static_initializer>') {
             functionStaticRanges.push(functionRange);
         }
+        if (functionName === '<instance_members_initializer>') {
+            functionInstanceRanges.push(functionRange);
+        }
 
         // cache uncovered
         if (functionRange.count === 0) {
@@ -76,11 +80,14 @@ const getCoverageInfo = (coverageList) => {
 
     // sort ranges
     Util.sortOffsetRanges(functionUncoveredRanges);
+    Util.sortOffsetRanges(functionStaticRanges);
+    Util.sortOffsetRanges(functionInstanceRanges);
 
     return {
         functionMap,
         functionNameMap,
         functionStaticRanges,
+        functionInstanceRanges,
         functionUncoveredRanges,
         rootRange
     };
@@ -220,7 +227,19 @@ const addRule = (item, coverageList, coveredRanges, count = 0) => {
     const endOffset = end.offset;
 
     if (!count) {
-        const coveredRange = Util.findInRanges(startOffset, endOffset, coveredRanges, 'startOffset', 'endOffset');
+        let matchEnd = endOffset;
+        if (item.type === 'rule') {
+            const child = item.nodes?.find((node) => node.type === 'rule' || node.type === 'atrule');
+            if (child) {
+                // Chromium 158 may stop the used parent range before a nested
+                // rule. Keep legacy whole-rule accounting, matching only the
+                // parent's prefix rather than requiring its entire subtree.
+                // TODO: Track native nested rules and trailing declarations
+                // separately, including their sparse sourcemap boundaries.
+                matchEnd = startOffset + source.input.css.slice(startOffset, child.source.start.offset).trimEnd().length;
+            }
+        }
+        const coveredRange = Util.findInRanges(startOffset, matchEnd, coveredRanges, 'startOffset', 'endOffset');
         if (coveredRange) {
             count = 1;
         }

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);