vitest-runner 1.0.0

package/README.md

@@ -0,0 +1,342 @@
+# vitest-runner
+
+Sequential Vitest runner that spawns each test file in its own child process to avoid out-of-memory crashes in large test suites.
+
+- Runs files one-at-a-time or in a configurable parallel worker pool
+- Supports full coverage mode via blob-per-file + `--mergeReports` (no OOM)
+- Auto-detects your vitest config; accepts an explicit path if needed
+- All standard Vitest CLI flags are forwarded unchanged
+- Usable as a **CLI binary** or as a **programmatic Node.js API**
+- Pure ESM with a CJS shim for `require()` compatibility
+
+[![npm version]][npm_version_url] [![npm downloads]][npm_downloads_url] <!-- [![GitHub release]][github_release_url] -->[![GitHub downloads]][github_downloads_url] [![Last commit]][last_commit_url] <!-- [![Release date]][release_date_url] -->[![npm last update]][npm_last_update_url] [![Coverage]][coverage_url]
+
+[![Contributors]][contributors_url] [![Sponsor shinrai]][sponsor_url]
+
+---
+
+## Requirements
+
+- Node.js ≥ 18
+- `vitest` ≥ 1.0 (peer dependency, installed in your project)
+- `chalk` (bundled dependency — no action needed)
+
+---
+
+## Installation
+
+```sh
+npm install --save-dev vitest-runner
+```
+
+Or to use the CLI globally:
+
+```sh
+npm install -g vitest-runner
+```
+
+---
+
+## CLI usage
+
+```sh
+vitest-runner [OPTIONS] [PATTERNS...]
+```
+
+### Runner flags
+
+| Flag | Description |
+|------|-------------|
+| `--test-list <file>` | Run only the files listed in a JSON array file instead of scanning |
+| `--file-pattern <regex>` | Override the file discovery regex (default: `\.test\.vitest\.(?:js\|mjs\|cjs)$`) |
+| `--workers <n>` | Number of parallel workers (default: `4` or `VITEST_WORKERS`) |
+| `--solo-pattern <pat>` | Run files matching this path substring solo (one at a time) before the worker pool; repeatable |
+| `--no-error-details` | Hide inline error blocks — show only counts in the summary |
+| `--coverage-quiet` | Implies `--coverage`; suppress per-file output and show only a live progress bar and final summaries |
+| `--log-file <path>` | Write a clean (ANSI-stripped) copy of all output to this file; implies `--coverage-quiet` when set without it. Defaults to `coverage/coverage-run.log` when `--coverage-quiet` is active |
+| `--help`, `-h` | Print this help and exit |
+
+### Test patterns
+
+Patterns are resolved against `cwd`. Any of the following forms work:
+
+```sh
+# Absolute or relative file path
+vitest-runner src/tests/config/background.test.vitest.mjs
+
+# Partial path or filename — matched against all discovered test files
+vitest-runner background.test.vitest.mjs
+vitest-runner config/background.test.vitest.mjs
+
+# Directory — all test files inside it are run
+vitest-runner src/tests/metadata
+```
+
+Multiple patterns can be combined:
+
+```sh
+vitest-runner src/tests/config src/tests/metadata
+```
+
+### Vitest passthrough flags
+
+All unrecognised flags are forwarded verbatim to every vitest child process:
+
+```sh
+vitest-runner --reporter=verbose
+vitest-runner -t "lazy materialization"
+vitest-runner --coverage
+vitest-runner --bail
+```
+
+### Environment variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `VITEST_HEAP_MB` | *(none)* | `--max-old-space-size` ceiling passed to every child process |
+| `VITEST_WORKERS` | `4` | Maximum parallel worker slots in the non-solo phase (overridden by `--workers`) |
+
+### Examples
+
+```sh
+# Run all test files discovered under the default testDir
+vitest-runner
+
+# Run all tests, filter by name
+vitest-runner -t "should handle null input"
+
+# Run a specific folder
+vitest-runner src/tests/auth
+
+# Run with coverage (blob + merge — OOM-safe)
+vitest-runner --coverage
+
+# Coverage with quiet output and live progress bar (ideal for CI)
+vitest-runner --coverage --coverage-quiet
+
+# Run only files listed in a JSON file
+vitest-runner --test-list my-tests.json
+
+# Use a custom file discovery pattern
+vitest-runner --file-pattern '\.spec\.ts$'
+
+# Run 2 workers, with certain files running solo first
+vitest-runner --workers 2 --solo-pattern heavy/ --solo-pattern listener-cleanup/
+
+# Custom heap and worker count
+VITEST_HEAP_MB=8192 vitest-runner --workers 2 src/tests/heavy
+
+# Suppress error details in the summary
+vitest-runner --no-error-details
+```
+
+---
+
+## Programmatic API
+
+```js
+import { run } from 'vitest-runner';
+
+// CommonJS
+const { run } = await require('vitest-runner');
+```
+
+### `run(options)` → `Promise<number>`
+
+Runs the test suite and resolves with an exit code (`0` = all passed, `1` = any failure). Does **not** call `process.exit` — that is the caller's responsibility.
+
+```js
+import { run } from 'vitest-runner';
+
+const code = await run({
+  cwd: process.cwd(),
+  testDir: 'src/tests',
+});
+
+process.exit(code);
+```
+
+#### Options
+
+| Option | Type | Default | Description |
+|--------|------|---------|-------------|
+| `cwd` | `string` | **required** | Absolute project root directory |
+| `testDir` | `string` | `cwd` | Directory (absolute or relative to `cwd`) to scan for `*.test.vitest.{js,mjs}` files |
+| `vitestConfig` | `string` | auto-detect | Explicit vitest config path; when omitted the runner walks standard config names (`vitest.config.ts`, `vite.config.ts`, etc.) relative to `cwd` |
+| `testPatterns` | `string[]` | `[]` | File / folder patterns to filter — empty means all files in `testDir` |
+| `testListFile` | `string` | `undefined` | Path to a JSON array of test file paths; when set, scanning is skipped entirely |
+| `testFilePattern` | `RegExp` | `DEFAULT_TEST_FILE_PATTERN` | Regex matched against file names during discovery (`*.test.vitest.{js,mjs,cjs}` by default) |
+| `vitestArgs` | `string[]` | `[]` | Extra CLI args forwarded verbatim to every vitest invocation |
+| `showErrorDetails` | `boolean` | `true` | Print inline error blocks under each failed file in the summary |
+| `coverageQuiet` | `boolean` | `false` | Suppress per-file output; show only the progress bar and final summaries |
+| `workers` | `number` | `4` | Maximum parallel worker slots (overrides `VITEST_WORKERS`) |
+| `worstCoverageCount` | `number` | `10` | Rows in the worst-coverage table after a coverage run (`0` disables it) |
+| `maxOldSpaceMb` | `number` | `undefined` | Global `--max-old-space-size` ceiling in MB (overrides `VITEST_HEAP_MB`) |
+| `earlyRunPatterns` | `string[]` | `[]` | Path substrings — matching files run solo (one at a time) before the parallel worker pool starts |
+| `perFileHeapOverrides` | `PerFileHeapOverride[]` | `[]` | Per-file minimum heap ceilings; the maximum of this and `maxOldSpaceMb` wins |
+| `conditions` | `string[]` | `[]` | Additional `--conditions` Node flags forwarded to children |
+| `nodeEnv` | `string` | `'development'` | Value written to `NODE_ENV` in child processes |
+
+#### `PerFileHeapOverride`
+
+```ts
+{ pattern: string; heapMb: number }
+```
+
+`pattern` is a substring matched against the normalised (forward-slash) file path. The first match wins and is compared against the global `maxOldSpaceMb`; the larger value is used.
+
+#### Examples
+
+```js
+// Run all tests under src/tests/
+await run({ cwd: process.cwd(), testDir: 'src/tests' });
+
+// Run only the config and metadata suites
+await run({
+  cwd: process.cwd(),
+  testDir: 'src/tests',
+  testPatterns: ['src/tests/config', 'src/tests/metadata'],
+});
+
+// Coverage run (OOM-safe blob + merge mode)
+await run({
+  cwd: process.cwd(),
+  testDir: 'src/tests',
+  vitestArgs: ['--coverage'],
+});
+
+// Quiet coverage with live progress bar
+await run({
+  cwd: process.cwd(),
+  testDir: 'src/tests',
+  coverageQuiet: true,
+});
+
+// Give heap-heavy files a larger ceiling while keeping the global limit lower
+await run({
+  cwd: process.cwd(),
+  testDir: 'src/tests',
+  maxOldSpaceMb: 2048,
+  earlyRunPatterns: ['listener-cleanup/'],
+  perFileHeapOverrides: [
+    { pattern: 'listener-cleanup/', heapMb: 6144 },
+  ],
+});
+```
+
+---
+
+## Coverage mode
+
+When `--coverage` (or `coverageQuiet: true`) is passed, the runner uses a blob-per-file strategy:
+
+1. Each file receives `--coverage --reporter=blob` with its own temp output directory.
+2. After all files complete, `vitest --mergeReports` combines the blobs into a single report.
+3. Temporary blob and coverage-tmp directories are cleaned up automatically.
+
+This avoids the OOM crash that occurs when a single vitest process holds coverage data for thousands of files simultaneously.
+
+### Coverage quiet mode
+
+`--coverage-quiet` / `coverageQuiet: true` suppresses all per-file output and renders a live progress bar instead. On completion it prints the coverage table and any failures verbosely. When running in this mode, output is also mirrored to `coverage/coverage-run.log` (CLI only) with ANSI colour codes stripped so the file is human-readable in any editor.
+
+The log file path can be overridden with `--log-file <path>`. Passing `--log-file` alone (without `--coverage-quiet`) also enables quiet mode and log mirroring.
+
+---
+
+## Test list files
+
+A test list file is a plain JSON array of test file paths (relative to `cwd`):
+
+```json
+[
+  "src/tests/auth/login.test.vitest.mjs",
+  "src/tests/auth/register.test.vitest.mjs",
+  "src/tests/config/defaults.test.vitest.mjs"
+]
+```
+
+Pass `--test-list <file>` (CLI) or `testListFile: 'path/to/list.json'` (API) to run exactly those files instead of scanning `testDir`.
+
+---
+
+## Test file naming
+
+By default, the runner discovers files matching:
+
+```
+*.test.vitest.js
+*.test.vitest.mjs
+*.test.vitest.cjs
+```
+
+Files in `node_modules` or hidden directories (names starting with `.`) are always skipped.
+
+The pattern can be overridden with `--file-pattern <regex>` (CLI) or the `testFilePattern` option (API):
+
+```sh
+# Match .spec.ts files instead
+vitest-runner --file-pattern '\.spec\.ts$'
+```
+
+```js
+await run({ cwd, testDir: 'src', testFilePattern: /\.spec\.ts$/i });
+```
+
+---
+
+## Source layout
+
+```
+index.mjs              ← ESM entry (re-exports src/runner.mjs)
+index.cjs              ← CJS shim (dynamic import of index.mjs)
+bin/
+  vitest-runner.mjs    ← CLI binary
+src/
+  runner.mjs           ← main run() API + re-exports
+  utils/
+    ansi.mjs           ← stripAnsi, colourPct
+    duration.mjs       ← formatDuration
+    env.mjs            ← buildNodeOptions
+    resolve.mjs        ← resolveBin, resolveVitestConfig
+  core/
+    discover.mjs       ← discoverVitestFiles, sortWithPriority
+    parse.mjs          ← parseVitestOutput, deduplicateErrors
+    spawn.mjs          ← runSingleFile, runVitestDirect, runMergeReports
+    report.mjs         ← printCoverageSummary, printMergeOutput
+    progress.mjs       ← createCoverageProgressTracker
+  cli/
+    args.mjs           ← parseArguments
+    help.mjs           ← showHelp
+```
+
+All sub-module utilities are re-exported from the root entry point, so deep imports are optional.
+
+---
+
+## License
+
+MIT
+
+<!-- Badge definitions -->
+<!-- [github release]: https://img.shields.io/github/v/release/CLDMV/vitest-runner?style=for-the-badge&logo=github&logoColor=white&labelColor=181717 -->
+<!-- [github_release_url]: https://github.com/CLDMV/vitest-runner/releases -->
+<!-- [release date]: https://img.shields.io/github/release-date/CLDMV/vitest-runner?style=for-the-badge&logo=github&logoColor=white&labelColor=181717 -->
+<!-- [release_date_url]: https://github.com/CLDMV/vitest-runner/releases -->
+
+[npm version]: https://img.shields.io/npm/v/vitest-runner.svg?style=for-the-badge&logo=npm&logoColor=white&labelColor=CB3837
+[npm_version_url]: https://www.npmjs.com/package/vitest-runner
+[npm downloads]: https://img.shields.io/npm/dm/vitest-runner.svg?style=for-the-badge&logo=npm&logoColor=white&labelColor=CB3837
+[npm_downloads_url]: https://www.npmjs.com/package/vitest-runner
+[github downloads]: https://img.shields.io/github/downloads/CLDMV/vitest-runner/total?style=for-the-badge&logo=github&logoColor=white&labelColor=181717
+[github_downloads_url]: https://github.com/CLDMV/vitest-runner/releases
+[last commit]: https://img.shields.io/github/last-commit/CLDMV/vitest-runner?style=for-the-badge&logo=github&logoColor=white&labelColor=181717
+[last_commit_url]: https://github.com/CLDMV/vitest-runner/commits
+[npm last update]: https://img.shields.io/npm/last-update/vitest-runner?style=for-the-badge&logo=npm&logoColor=white&labelColor=CB3837
+[npm_last_update_url]: https://www.npmjs.com/package/vitest-runner
+[coverage]: https://img.shields.io/endpoint?url=https%3A%2F%2Fraw.githubusercontent.com%2FCLDMV%2Fvitest-runner%2Fbadges%2Fcoverage.json&style=for-the-badge&logo=vitest&logoColor=white
+[coverage_url]: https://github.com/CLDMV/vitest-runner/blob/badges/coverage.json
+[contributors]: https://img.shields.io/github/contributors/CLDMV/vitest-runner.svg?style=for-the-badge&logo=github&logoColor=white&labelColor=181717
+[contributors_url]: https://github.com/CLDMV/vitest-runner/graphs/contributors
+[sponsor shinrai]: https://img.shields.io/github/sponsors/shinrai?style=for-the-badge&logo=githubsponsors&logoColor=white&labelColor=EA4AAA&label=Sponsor
+[sponsor_url]: https://github.com/sponsors/shinrai

package/bin/vitest-runner.mjs

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+/**
+ * @fileoverview CLI entry point for the vitest-runner binary.
+ * @module vitest-runner/bin/vitest-runner
+ *
+ * Mirrors its own output to a log file when --coverage-quiet is set, then
+ * delegates all logic to `src/runner.mjs` via the programmatic `run()` API.
+ */
+
+import { createWriteStream, mkdirSync } from "node:fs";
+import path from "node:path";
+import { parseArguments } from "../src/cli/args.mjs";
+import { showHelp } from "../src/cli/help.mjs";
+import { run } from "../src/runner.mjs";
+import { stripAnsi } from "../src/utils/ansi.mjs";
+
+const args = parseArguments(process.argv.slice(2));
+
+if (args.help) {
+	showHelp();
+	process.exit(0);
+}
+
+// Mirror all output (excluding progress bar lines) to a log file
+// when running in --coverage-quiet mode (or when --log-file is set).
+if (args.coverageQuiet || args.logFile) {
+	const cwd = process.cwd();
+	const resolvedLogFile = args.logFile
+		? path.isAbsolute(args.logFile)
+			? args.logFile
+			: path.resolve(cwd, args.logFile)
+		: path.join(cwd, "coverage", "coverage-run.log");
+	mkdirSync(path.dirname(resolvedLogFile), { recursive: true });
+	const logStream = createWriteStream(resolvedLogFile, { flags: "a" });
+	const origStdoutWrite = process.stdout.write.bind(process.stdout);
+	const origStderrWrite = process.stderr.write.bind(process.stderr);
+
+	/**
+	 * Determine if a chunk is a progress-bar write that should be excluded from the log.
+	 * TTY mode uses `\r` to overwrite in place; non-TTY prints "progress N.N% ..." lines.
+	 * @param {Buffer|string} chunk
+	 * @returns {boolean}
+	 */
+	function isProgressChunk(chunk) {
+		const str = chunk.toString();
+		return str.startsWith("\r") || /^progress \d+\.\d+%/.test(str);
+	}
+
+	process.stdout.write = (chunk, enc, cb) => {
+		if (!isProgressChunk(chunk)) logStream.write(stripAnsi(chunk.toString()));
+		return origStdoutWrite(chunk, enc, cb);
+	};
+
+	process.stderr.write = (chunk, enc, cb) => {
+		if (!isProgressChunk(chunk)) logStream.write(stripAnsi(chunk.toString()));
+		return origStderrWrite(chunk, enc, cb);
+	};
+
+	process.on("exit", () => logStream.end());
+}
+
+const cwd = process.cwd();
+
+const vitestArgs = [...args.vitestPassthroughArgs];
+if ((args.coverageQuiet || args.logFile) && !vitestArgs.some((a) => a === "--coverage" || a.startsWith("--coverage."))) {
+	vitestArgs.unshift("--coverage");
+}
+
+run({
+	cwd,
+	testPatterns: args.testPatterns,
+	testListFile: args.testListFile,
+	testFilePattern: args.testFilePattern,
+	vitestArgs,
+	showErrorDetails: args.showErrorDetails,
+	coverageQuiet: args.coverageQuiet,
+	...(args.workers !== undefined && { workers: args.workers }),
+	...(args.soloPatterns.length > 0 && { earlyRunPatterns: args.soloPatterns })
+})
+	.then((code) => {
+		process.exit(code);
+	})
+	.catch((err) => {
+		console.error("Fatal error:", err);
+		process.exit(1);
+	});

package/index.cjs

@@ -0,0 +1,17 @@
+/**
+ * @fileoverview CJS shim — dynamically imports the ESM entry point so that
+ * CommonJS callers can `require('vitest-runner')`.
+ *
+ * Because the package is pure ESM (`"type": "module"`) we cannot use `module.exports =`
+ * directly; instead we export a promise and re-attach named exports once resolved.
+ *
+ * @example
+ * // CommonJS usage
+ * const { run } = await require('vitest-runner');
+ */
+
+"use strict";
+
+// Async shim: re-export everything from the ESM module.
+// Callers must await the result or use .then().
+module.exports = import("./index.mjs");

package/index.mjs

@@ -0,0 +1,5 @@
+/**
+ * @fileoverview ESM entry-point — re-exports the public API from src/runner.mjs.
+ * @module vitest-runner
+ */
+export * from "./src/runner.mjs";

package/package.json

@@ -0,0 +1,60 @@
+{
+	"name": "vitest-runner",
+	"version": "1.0.0",
+	"description": "Sequential Vitest runner to avoid OOM issues with large test suites",
+	"type": "module",
+	"main": "index.cjs",
+	"module": "index.mjs",
+	"types": "./types/index.d.mts",
+	"exports": {
+		".": {
+			"types": "./types/index.d.mts",
+			"import": "./index.mjs",
+			"require": "./index.cjs"
+		}
+	},
+	"bin": {
+		"vitest-runner": "./bin/vitest-runner.mjs"
+	},
+	"files": [
+		"index.mjs",
+		"index.cjs",
+		"types/",
+		"src/",
+		"bin/"
+	],
+	"scripts": {
+		"lint": "eslint src/ bin/ index.mjs",
+		"test": "vitest run --config .configs/vitest.config.mjs",
+		"test:watch": "vitest --config .configs/vitest.config.mjs",
+		"test:coverage": "vitest run --coverage --config .configs/vitest.config.mjs",
+		"ci:coverage": "vitest run --coverage --reporter=dot --maxWorkers=1 --config .configs/vitest.config.mjs",
+		"types:build": "tsc -p .configs/tsconfig.json",
+		"types:check": "tsc -p .configs/tsconfig.json --noEmit"
+	},
+	"keywords": [
+		"vitest",
+		"test-runner",
+		"sequential",
+		"oom"
+	],
+	"devDependencies": {
+		"@types/node": "^25.3.0",
+		"@vitest/coverage-v8": "^4.0.18",
+		"typescript": "^5.9.3",
+		"vitest": "^4.0.18"
+	},
+	"dependencies": {
+		"chalk": "^5.4.1"
+	},
+	"peerDependencies": {
+		"vitest": ">=1.0.0"
+	},
+	"engines": {
+		"node": ">=18.0.0"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"license": "MIT"
+}

package/src/cli/args.mjs

@@ -0,0 +1,110 @@
+/**
+ * @fileoverview CLI argument parsing for the vitest-runner binary.
+ * @module vitest-runner/src/cli/args
+ */
+
+/**
+ * @typedef {Object} ParsedArgs
+ * @property {string|undefined} testListFile - Path to a JSON file of test paths to run (`--test-list`).
+ * @property {boolean} showErrorDetails - `false` when `--no-error-details` was passed.
+ * @property {boolean} coverageQuiet - Whether `--coverage-quiet` was passed.
+ * @property {string|undefined} logFile - Path for the coverage run log (`--log-file`); defaults to `coverage/coverage-run.log`.
+ * @property {boolean} help - Whether `--help` / `-h` was passed.
+ * @property {number|undefined} workers - Worker count from `--workers <n>`, or undefined.
+ * @property {string[]} soloPatterns - Path substrings from `--solo-pattern <pattern>` (repeatable).
+ * @property {RegExp|undefined} testFilePattern - Compiled regex from `--file-pattern <regex>`, or undefined.
+ * @property {string[]} vitestPassthroughArgs - Flags forwarded verbatim to vitest.
+ * @property {string[]} testPatterns - Non-flag positional arguments (file / folder patterns).
+ */
+
+/** Runner-owned flags that must not be forwarded to vitest. */
+const RUNNER_FLAGS = new Set([
+	"--test-list",
+	"--no-error-details",
+	"--coverage-quiet",
+	"--log-file",
+	"--workers",
+	"--solo-pattern",
+	"--file-pattern",
+	"--help",
+	"-h"
+]);
+
+/**
+ * Parse raw CLI arguments into structured runner options.
+ *
+ * Runner-specific flags are extracted; everything else (flags and their
+ * optional values) is forwarded to vitest as passthrough args.
+ * A flag that takes a value (where the next token does not start with `-`)
+ * consumes that token too.
+ *
+ * @param {string[]} args - Raw argument array (typically `process.argv.slice(2)`).
+ * @returns {ParsedArgs}
+ * @example
+ * parseArguments(['--test-list', 'tests.json', '--workers', '2', '--reporter=verbose']);
+ */
+export function parseArguments(args) {
+	const vitestPassthroughArgs = [];
+	const testPatterns = [];
+	const soloPatterns = [];
+	let testListFile;
+	let showErrorDetails = true;
+	let coverageQuiet = false;
+	let logFile;
+	let workers;
+	let help = false;
+	let testFilePattern;
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+
+		if (arg === "--test-list") {
+			testListFile = args[++i];
+		} else if (arg.startsWith("--test-list=")) {
+			testListFile = arg.slice("--test-list=".length);
+		} else if (arg === "--no-error-details") {
+			showErrorDetails = false;
+		} else if (arg === "--coverage-quiet") {
+			coverageQuiet = true;
+		} else if (arg === "--log-file") {
+			logFile = args[++i];
+		} else if (arg.startsWith("--log-file=")) {
+			logFile = arg.slice("--log-file=".length);
+		} else if (arg === "--workers") {
+			workers = parseInt(args[++i], 10);
+		} else if (arg.startsWith("--workers=")) {
+			workers = parseInt(arg.slice("--workers=".length), 10);
+		} else if (arg === "--solo-pattern") {
+			soloPatterns.push(args[++i]);
+		} else if (arg.startsWith("--solo-pattern=")) {
+			soloPatterns.push(arg.slice("--solo-pattern=".length));
+		} else if (arg === "--file-pattern") {
+			testFilePattern = new RegExp(args[++i], "i");
+		} else if (arg.startsWith("--file-pattern=")) {
+			testFilePattern = new RegExp(arg.slice("--file-pattern=".length), "i");
+		} else if (arg === "--help" || arg === "-h") {
+			help = true;
+		} else if ((arg.startsWith("--") || arg.startsWith("-")) && !RUNNER_FLAGS.has(arg)) {
+			vitestPassthroughArgs.push(arg);
+			// Consume the next token if it looks like a value (not another flag)
+			if (i + 1 < args.length && !args[i + 1].startsWith("-")) {
+				vitestPassthroughArgs.push(args[++i]);
+			}
+		} else {
+			// Any remaining token (cannot start with '-'; those are caught above)
+			testPatterns.push(arg);
+		}
+	}
+
+	return {
+		testListFile,
+		showErrorDetails,
+		coverageQuiet,
+		logFile,
+		help,
+		workers,
+		soloPatterns,
+		testFilePattern,
+		vitestPassthroughArgs,
+		testPatterns
+	};
+}