@mnaoumov/typescript-dev-toolkit 5.0.0 → 5.2.0

package/dist/lib/esm/nano-staged-config.mjs

@@ -41,14 +41,35 @@ function getNanoStagedConfig(options) {
   const hasAllSharedScripts = [SPELLCHECK_SCRIPT_NAME, ...Object.values(WRITER_SCRIPT_NAMES).flat()].every((scriptName) => scriptNames.has(scriptName));
   const additionalWriterTasks = options?.additionalWriterTasks ?? {};
   if (hasAllSharedScripts && Object.keys(additionalWriterTasks).length === 0) {
-    return obsidianDevUtilsConfig;
+    return applyBulkBudget(obsidianDevUtilsConfig);
   }
   const writerTasks = toWriterTasks((scriptName) => scriptNames.has(scriptName));
   const duplicatePattern = Object.keys(additionalWriterTasks).find((pattern) => Object.hasOwn(writerTasks, pattern));
   if (duplicatePattern !== void 0) {
     throw new Error(`nano-staged writer pattern '${duplicatePattern}' is already a shared writer pattern.`);
   }
-  return partitionSpellcheck({ ...writerTasks, ...additionalWriterTasks }, scriptNames.has(SPELLCHECK_SCRIPT_NAME));
+  return applyBulkBudget(partitionSpellcheck({ ...writerTasks, ...additionalWriterTasks }, scriptNames.has(SPELLCHECK_SCRIPT_NAME)));
+}
+function applyBulkBudget(config) {
+  const budget = process.env["BULK_CORES"]?.trim() ?? "";
+  if (!/^[1-9]\d*$/.test(budget)) {
+    return config;
+  }
+  const commands = [];
+  const serialConfig = {};
+  for (const [pattern, task] of Object.entries(config)) {
+    serialConfig[pattern] = (context) => {
+      commands.push(...task(context));
+      return [];
+    };
+  }
+  const collectAll = serialConfig["*"];
+  delete serialConfig["*"];
+  serialConfig["*"] = (context) => {
+    collectAll?.(context);
+    return commands.splice(0);
+  };
+  return serialConfig;
 }
 function batchCommandArguments(prefix, commandArguments) {
   const emptyLength = getEffectiveCommandLineLength("");
@@ -120,4 +141,4 @@ export {
   getNanoStagedConfig,
   obsidianDevUtilsConfig
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/nano-staged-config.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Shared nano-staged configuration for pre-commit hooks.\n */\n\nimport {\n  isAbsolute,\n  relative\n} from 'node:path';\nimport process from 'node:process';\n\nimport {\n  isEnvVariableOff,\n  loadEnvFileIfExists\n} from './env-toggle.ts';\nimport {\n  getEffectiveCommandLineLength,\n  getMaxBatchCommandLength\n} from './exec.ts';\nimport { readPackageJsonSync } from './npm.ts';\nimport { getPackageManagerRunCommand } from './package-manager.ts';\n\n/**\n * Options for {@link getNanoStagedConfig}.\n */\nexport interface GetNanoStagedConfigOptions {\n  /**\n   * Repo-specific file-rewriting tasks, keyed by the nano-staged pattern that claims their files.\n   *\n   * Each gets spellcheck appended and its files removed from the spellcheck-only key, exactly like the shared\n   * writers. A pattern must not contain `/`, and must not repeat a shared writer pattern. Each command is a\n   * prefix the staged paths are appended to, in batches, like the shared ones (`npm run lint:fix --`).\n   */\n  readonly additionalWriterTasks?: Readonly<Record<string, readonly string[]>>;\n}\n\n/**\n * A nano-staged configuration whose every key is a {@link NanoStagedTask}.\n */\nexport type NanoStagedConfig = Record<string, NanoStagedTask>;\n\n/**\n * A function-valued nano-staged task: it receives the staged files its pattern claims and returns the\n * commands to run over them, in order.\n */\nexport type NanoStagedTask = (context: NanoStagedTaskContext) => string[];\n\n/**\n * What nano-staged passes to a function-valued task.\n */\nexport interface NanoStagedTaskContext {\n  /**\n   * The absolute paths of the staged files the task's pattern claims.\n   */\n  readonly filenames: readonly string[];\n}\n\n/**\n * The `<manager> run` prefix every task below is built on, resolved once for the process.\n *\n * Detection probes for a lockfile beside `package.json`, so it is a handful of `existsSync` calls and\n * nothing more \u2014 no `.env` read and no `process.exit`, which is what lets it sit at module scope.\n */\nconst PACKAGE_MANAGER_RUN_COMMAND = getPackageManagerRunCommand().join(' ');\n\nconst SPELLCHECK_SCRIPT_NAME = 'spellcheck';\n\nconst SPELLCHECK_COMMAND = toScriptCommand(SPELLCHECK_SCRIPT_NAME);\n\n/**\n * Room left in every batch for the resolved path of the package manager's executable.\n *\n * nano-staged runs `npm` as the absolute path of `npm.cmd` (`<comspec> /D /S /C \"<path>\" \"<arg>\" \u2026`), which\n * the batch cannot see, so a full Windows `MAX_PATH` is set aside for it.\n */\nconst EXECUTABLE_PATH_RESERVE = 260;\n\n/**\n * The characters nano-staged's command tokenizer cannot carry inside an argument.\n *\n * A function-valued task returns its commands as STRINGS, and nano-staged splits each one with\n * `stringArgvToArray`, which emits a quoted token twice (once bare, once with its quotes) and has no escape.\n * So a path holding whitespace or a quote cannot be passed as itself.\n */\nconst TOKENIZER_UNSAFE_CHARACTERS_REG_EXP = /[\\s\"']/g;\n\n/**\n * The npm scripts that REWRITE a staged file, in the order they run, keyed by the nano-staged pattern that\n * claims it.\n *\n * `lint:fix` and `format` both rewrite the file, so they have to share one key: nano-staged runs its\n * per-pattern groups under `Promise.all` (`run()` in `nano-staged/lib/cmd-runner.js`), and sequences only\n * the commands INSIDE a single key's array (`runTask()`, a `for ... of await`). Split across two keys they\n * race, whichever finishes last wins, and the commit stages bytes that neither tool would have produced on\n * its own.\n *\n * So do NOT express a directory exclusion by giving one of these two its own negated key -- that silently\n * takes the ordering away. An exclusion belongs in the excluded tool's own config, where ESLint's\n * `globalIgnores` already puts it: a path ESLint ignores is reported as a warning and exits 0 when it is\n * passed explicitly, so it costs a console line rather than a failed commit and needs no key here.\n */\nconst WRITER_SCRIPT_NAMES: Readonly<Record<string, readonly string[]>> = {\n  '*.{ts,tsx,mts}': ['lint:fix', 'format'],\n  '*.md': ['lint:md:fix']\n};\n\nconst WRITER_TASKS: Readonly<Record<string, readonly string[]>> = toWriterTasks(() => true);\n\n/**\n * Nano-staged configuration that runs file-based lint, format, and spellcheck on staged files.\n *\n * Only includes tools that can operate on individual files. Whole-project checks\n * (TypeScript compilation, unit tests) are left to CI.\n *\n * Commands run through the package manager that owns the tree \u2014 `npm run ... --`, `bun run ... --`, and\n * so on \u2014 so nano-staged file paths are forwarded as CLI arguments, batched to fit the command line (see\n * `toBatchedTask`).\n *\n * Spellcheck is partitioned across the keys rather than given a catch-all `'*'` key (see\n * `partitionSpellcheck`). A repo adding a file-rewriting task of its own passes it to\n * {@link getNanoStagedConfig} as `additionalWriterTasks` rather than spreading this object and adding a key,\n * which would reintroduce the overlap for that key's files.\n */\nexport const obsidianDevUtilsConfig: NanoStagedConfig = partitionSpellcheck(WRITER_TASKS, true);\n\nconst NANO_STAGED_ENV_VARIABLE = 'NANO_STAGED';\n\n/**\n * Resolves the nano-staged configuration to use, honoring a per-developer opt-out.\n *\n * Loads a gitignored `.env` if present, then \u2014 when `NANO_STAGED` is set to an off value (`0`, `false`,\n * `off`, or `no`) \u2014 prints a notice and exits the process successfully so the pre-commit checks are\n * skipped. This mirrors husky's own `HUSKY=0` switch, but scoped to the nano-staged step (so the\n * commit-msg hook still runs). Otherwise it returns {@link obsidianDevUtilsConfig}, or \u2014 when\n * `additionalWriterTasks` are given \u2014 the same configuration re-partitioned with those writers added.\n *\n * A shared task whose npm script the project's `package.json` does not declare is left out, so a project\n * without, say, markdownlint does not fail its first commit that stages a `.md` file on a missing script. A\n * writer pattern left with no writer is dropped, and spellcheck runs only when `spellcheck` is declared, in\n * which case its files fall to the spellcheck-only key. The `additionalWriterTasks` are the caller's own and\n * are kept as given.\n *\n * `NANO_STAGED` is not an npm script, so it carries its own switch rather than the script-name-derived one\n * every npm script gets \u2014 but both share the same notion of an off value, via {@link isEnvVariableOff}.\n *\n * This is a function rather than module-level code so importing the package barrel never triggers the\n * `.env` read or the process exit; call it from the thin `scripts/nano-staged-config.ts` entry. Resolving the\n * package manager is the one thing that does run at module scope, and it does neither of those two\n * things \u2014 it only probes for a lockfile.\n *\n * @param options - The optional options.\n * @returns The nano-staged task configuration. Does not return when the opt-out is active.\n */\nexport function getNanoStagedConfig(options?: GetNanoStagedConfigOptions): NanoStagedConfig {\n  loadEnvFileIfExists();\n\n  if (isEnvVariableOff(NANO_STAGED_ENV_VARIABLE)) {\n    process.stdout.write(`nano-staged: skipped (${NANO_STAGED_ENV_VARIABLE} is off).\\n`);\n    process.exit(0);\n  }\n\n  const scriptNames = new Set(Object.keys(readPackageJsonSync().scripts ?? {}));\n  const hasAllSharedScripts = [SPELLCHECK_SCRIPT_NAME, ...Object.values(WRITER_SCRIPT_NAMES).flat()]\n    .every((scriptName) => scriptNames.has(scriptName));\n  const additionalWriterTasks = options?.additionalWriterTasks ?? {};\n  if (hasAllSharedScripts && Object.keys(additionalWriterTasks).length === 0) {\n    return obsidianDevUtilsConfig;\n  }\n\n  const writerTasks = toWriterTasks((scriptName) => scriptNames.has(scriptName));\n  const duplicatePattern = Object.keys(additionalWriterTasks).find((pattern) => Object.hasOwn(writerTasks, pattern));\n  if (duplicatePattern !== undefined) {\n    throw new Error(`nano-staged writer pattern '${duplicatePattern}' is already a shared writer pattern.`);\n  }\n\n  return partitionSpellcheck({ ...writerTasks, ...additionalWriterTasks }, scriptNames.has(SPELLCHECK_SCRIPT_NAME));\n}\n\n/**\n * Splits command arguments into batches that each fit one command line after a given prefix.\n *\n * Each argument is costed as nano-staged passes it on Windows \u2014 quoted, then `^`-escaped by `cmd.exe`'s\n * rules \u2014 through {@link getEffectiveCommandLineLength}, and the budget is {@link getMaxBatchCommandLength},\n * which already holds back the reserve for the `npm` \u2192 `cmd.exe` \u2192 `.bin` shim chain re-expanding the\n * arguments. An argument too long for any batch still gets a batch of its own: it fails loudly there, which\n * dropping it would not.\n *\n * @param prefix - The command the arguments are appended to.\n * @param commandArguments - The arguments to split.\n * @returns The batches, in order, together holding every argument once.\n */\nfunction batchCommandArguments(prefix: string, commandArguments: readonly string[]): string[][] {\n  const emptyLength = getEffectiveCommandLineLength('');\n  const budget = getMaxBatchCommandLength() - EXECUTABLE_PATH_RESERVE - getEffectiveCommandLineLength(prefix);\n  const batches: string[][] = [];\n  let batch: string[] = [];\n  let batchLength = 0;\n\n  for (const commandArgument of commandArguments) {\n    const argumentLength = getEffectiveCommandLineLength(` \"${commandArgument}\"`) - emptyLength;\n    if (batch.length > 0 && batchLength + argumentLength > budget) {\n      batches.push(batch);\n      batch = [];\n      batchLength = 0;\n    }\n    batch.push(commandArgument);\n    batchLength += argumentLength;\n  }\n\n  if (batch.length > 0) {\n    batches.push(batch);\n  }\n\n  return batches;\n}\n\n/**\n * Builds a nano-staged configuration in which spellcheck never reads a file while another task rewrites it.\n *\n * The same `Promise.all` that forces two writers into one key makes a catch-all `'*'` spellcheck key run\n * CONCURRENTLY with every writer key, so cspell would read a file that ESLint or dprint is rewriting in\n * place -- a spurious finding on a half-written file, or a pass over content that is not what gets\n * committed. So the staged files are PARTITIONED instead:\n *\n * - every writer key gets spellcheck appended as its LAST command, so it reads that key's files after they\n *   have been rewritten;\n * - one complement key spellchecks exactly the files no writer key claims.\n *\n * The complement is written in nano-staged's own glob dialect, which compiles `!(...)` to a lookahead that\n * is NOT anchored at the end of the path: `!(*.md)*` would exclude `notes.md.bak` too. A nested `!(?)`\n * compiles to `(?!.)`, which IS an end anchor, so each alternative is suffixed with it. A writer pattern\n * containing `/` would switch nano-staged into globstar mode, where `*` stops crossing directories and the\n * construction no longer holds -- hence the throw. The unit test pins the partition against the installed\n * nano-staged compiler, so a release that changes its dialect fails there rather than in a commit.\n *\n * Without spellcheck there is nothing to partition: each writer key runs its own commands, and no complement\n * key is emitted.\n *\n * @param writerTasks - The file-rewriting tasks, keyed by the pattern that claims their files.\n * @param shouldSpellcheck - Whether the project has a `spellcheck` script to run.\n * @returns The configuration, with the spellcheck step partitioned across the keys.\n */\nfunction partitionSpellcheck(writerTasks: Readonly<Record<string, readonly string[]>>, shouldSpellcheck: boolean): NanoStagedConfig {\n  if (!shouldSpellcheck) {\n    return Object.fromEntries(Object.entries(writerTasks).map(([pattern, commands]) => [pattern, toBatchedTask(commands)]));\n  }\n\n  const patterns = Object.keys(writerTasks);\n  const patternWithSlash = patterns.find((pattern) => pattern.includes('/'));\n  if (patternWithSlash !== undefined) {\n    throw new Error(`nano-staged writer pattern '${patternWithSlash}' contains '/', which the spellcheck partition cannot express.`);\n  }\n\n  // `!()*` would compile to a lookahead that rejects every path, so with no writer the complement is everything.\n  const complementPattern = patterns.length === 0 ? '*' : `!(${patterns.map((pattern) => `${pattern}!(?)`).join('|')})*`;\n  const config: NanoStagedConfig = {\n    [complementPattern]: toBatchedTask([SPELLCHECK_COMMAND])\n  };\n\n  for (const [pattern, commands] of Object.entries(writerTasks)) {\n    config[pattern] = toBatchedTask([...commands, SPELLCHECK_COMMAND]);\n  }\n\n  return config;\n}\n\n/**\n * Builds a task that runs each command over every staged file it receives, in as many batches as the command\n * line needs.\n *\n * nano-staged appends a string task's files to ONE command, so a commit staging a few hundred files ran\n * `npm run lint:fix -- <every path>` and failed on Windows with `The command line is too long.`, refusing\n * exactly the whole-repo commits that most need the hook. A function-valued task builds its own commands\n * instead, and these are batched against the same budget `exec()` uses (see `batchCommandArguments`).\n *\n * The commands keep their order: every batch of the first command runs before any batch of the second,\n * because nano-staged runs one key's commands one after another, so a writer still finishes before the next\n * writer, and spellcheck still reads the rewritten files.\n *\n * @param commands - The command prefixes, in the order they run.\n * @returns The task.\n */\nfunction toBatchedTask(commands: readonly string[]): NanoStagedTask {\n  return ({ filenames }) => {\n    const commandArguments = filenames.map((filename) => toCommandArgument(filename));\n    return commands.flatMap((command) => batchCommandArguments(command, commandArguments).map((batch) => `${command} ${batch.join(' ')}`));\n  };\n}\n\n/**\n * Turns a staged file's absolute path into the argument a batched task passes for it.\n *\n * The path is made relative to the working directory, where nano-staged and the task both run, which roughly\n * halves its length and so the number of batches; a path outside it stays absolute. A relative path starting\n * with `-` gets `./`, so no tool reads it as an option.\n *\n * Whitespace and quotes become `?`, because nano-staged's tokenizer cannot carry them (see\n * {@link TOKENIZER_UNSAFE_CHARACTERS_REG_EXP}). Every tool the tasks run (ESLint, dprint, cspell,\n * markdownlint-cli2) takes its paths as globs, and `?` matches exactly the one character it replaced, so the\n * file is still found; a sibling differing only in that character would match too, which costs a lint of an\n * extra file, not a missed one.\n *\n * @param filename - The absolute path of the staged file.\n * @returns The argument.\n */\nfunction toCommandArgument(filename: string): string {\n  const relativePath = relative(process.cwd(), filename);\n  let commandArgument = (relativePath.startsWith('..') || isAbsolute(relativePath) ? filename : relativePath).replaceAll('\\\\', '/');\n  if (commandArgument.startsWith('-')) {\n    commandArgument = `./${commandArgument}`;\n  }\n  return commandArgument.replaceAll(TOKENIZER_UNSAFE_CHARACTERS_REG_EXP, '?');\n}\n\n/**\n * Builds the command prefix that runs an npm script over the paths appended to it.\n *\n * @param scriptName - The script name.\n * @returns The command prefix, such as `npm run lint:fix --`.\n */\nfunction toScriptCommand(scriptName: string): string {\n  return `${PACKAGE_MANAGER_RUN_COMMAND} ${scriptName} --`;\n}\n\n/**\n * Builds the shared writer tasks from {@link WRITER_SCRIPT_NAMES}, keeping only the scripts a filter accepts\n * and dropping a pattern left with none.\n *\n * @param shouldIncludeScript - Whether to run a given script.\n * @returns The writer tasks, keyed by the pattern that claims their files.\n */\nfunction toWriterTasks(shouldIncludeScript: (scriptName: string) => boolean): Record<string, readonly string[]> {\n  const writerTasks: Record<string, readonly string[]> = {};\n  for (const [pattern, scriptNames] of Object.entries(WRITER_SCRIPT_NAMES)) {\n    const commands = scriptNames.filter((scriptName) => shouldIncludeScript(scriptName)).map((scriptName) => toScriptCommand(scriptName));\n    if (commands.length > 0) {\n      writerTasks[pattern] = commands;\n    }\n  }\n  return writerTasks;\n}\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/nano-staged-config.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Shared nano-staged configuration for pre-commit hooks.\n */\n\nimport {\n  isAbsolute,\n  relative\n} from 'node:path';\nimport process from 'node:process';\n\nimport {\n  isEnvVariableOff,\n  loadEnvFileIfExists\n} from './env-toggle.ts';\nimport {\n  getEffectiveCommandLineLength,\n  getMaxBatchCommandLength\n} from './exec.ts';\nimport { readPackageJsonSync } from './npm.ts';\nimport { getPackageManagerRunCommand } from './package-manager.ts';\n\n/**\n * Options for {@link getNanoStagedConfig}.\n */\nexport interface GetNanoStagedConfigOptions {\n  /**\n   * Repo-specific file-rewriting tasks, keyed by the nano-staged pattern that claims their files.\n   *\n   * Each gets spellcheck appended and its files removed from the spellcheck-only key, exactly like the shared\n   * writers. A pattern must not contain `/`, and must not repeat a shared writer pattern. Each command is a\n   * prefix the staged paths are appended to, in batches, like the shared ones (`npm run lint:fix --`).\n   */\n  readonly additionalWriterTasks?: Readonly<Record<string, readonly string[]>>;\n}\n\n/**\n * A nano-staged configuration whose every key is a {@link NanoStagedTask}.\n */\nexport type NanoStagedConfig = Record<string, NanoStagedTask>;\n\n/**\n * A function-valued nano-staged task: it receives the staged files its pattern claims and returns the\n * commands to run over them, in order.\n */\nexport type NanoStagedTask = (context: NanoStagedTaskContext) => string[];\n\n/**\n * What nano-staged passes to a function-valued task.\n */\nexport interface NanoStagedTaskContext {\n  /**\n   * The absolute paths of the staged files the task's pattern claims.\n   */\n  readonly filenames: readonly string[];\n}\n\n/**\n * The `<manager> run` prefix every task below is built on, resolved once for the process.\n *\n * Detection probes for a lockfile beside `package.json`, so it is a handful of `existsSync` calls and\n * nothing more \u2014 no `.env` read and no `process.exit`, which is what lets it sit at module scope.\n */\nconst PACKAGE_MANAGER_RUN_COMMAND = getPackageManagerRunCommand().join(' ');\n\nconst SPELLCHECK_SCRIPT_NAME = 'spellcheck';\n\nconst SPELLCHECK_COMMAND = toScriptCommand(SPELLCHECK_SCRIPT_NAME);\n\n/**\n * Room left in every batch for the resolved path of the package manager's executable.\n *\n * nano-staged runs `npm` as the absolute path of `npm.cmd` (`<comspec> /D /S /C \"<path>\" \"<arg>\" \u2026`), which\n * the batch cannot see, so a full Windows `MAX_PATH` is set aside for it.\n */\nconst EXECUTABLE_PATH_RESERVE = 260;\n\n/**\n * The characters nano-staged's command tokenizer cannot carry inside an argument.\n *\n * A function-valued task returns its commands as STRINGS, and nano-staged splits each one with\n * `stringArgvToArray`, which emits a quoted token twice (once bare, once with its quotes) and has no escape.\n * So a path holding whitespace or a quote cannot be passed as itself.\n */\nconst TOKENIZER_UNSAFE_CHARACTERS_REG_EXP = /[\\s\"']/g;\n\n/**\n * The npm scripts that REWRITE a staged file, in the order they run, keyed by the nano-staged pattern that\n * claims it.\n *\n * `lint:fix` and `format` both rewrite the file, so they have to share one key: nano-staged runs its\n * per-pattern groups under `Promise.all` (`run()` in `nano-staged/lib/cmd-runner.js`), and sequences only\n * the commands INSIDE a single key's array (`runTask()`, a `for ... of await`). Split across two keys they\n * race, whichever finishes last wins, and the commit stages bytes that neither tool would have produced on\n * its own.\n *\n * So do NOT express a directory exclusion by giving one of these two its own negated key -- that silently\n * takes the ordering away. An exclusion belongs in the excluded tool's own config, where ESLint's\n * `globalIgnores` already puts it: a path ESLint ignores is reported as a warning and exits 0 when it is\n * passed explicitly, so it costs a console line rather than a failed commit and needs no key here.\n */\nconst WRITER_SCRIPT_NAMES: Readonly<Record<string, readonly string[]>> = {\n  '*.{ts,tsx,mts}': ['lint:fix', 'format'],\n  '*.md': ['lint:md:fix']\n};\n\nconst WRITER_TASKS: Readonly<Record<string, readonly string[]>> = toWriterTasks(() => true);\n\n/**\n * Nano-staged configuration that runs file-based lint, format, and spellcheck on staged files.\n *\n * Only includes tools that can operate on individual files. Whole-project checks\n * (TypeScript compilation, unit tests) are left to CI.\n *\n * Commands run through the package manager that owns the tree \u2014 `npm run ... --`, `bun run ... --`, and\n * so on \u2014 so nano-staged file paths are forwarded as CLI arguments, batched to fit the command line (see\n * `toBatchedTask`).\n *\n * Spellcheck is partitioned across the keys rather than given a catch-all `'*'` key (see\n * `partitionSpellcheck`). A repo adding a file-rewriting task of its own passes it to\n * {@link getNanoStagedConfig} as `additionalWriterTasks` rather than spreading this object and adding a key,\n * which would reintroduce the overlap for that key's files.\n */\nexport const obsidianDevUtilsConfig: NanoStagedConfig = partitionSpellcheck(WRITER_TASKS, true);\n\nconst NANO_STAGED_ENV_VARIABLE = 'NANO_STAGED';\n\n/**\n * Resolves the nano-staged configuration to use, honoring a per-developer opt-out.\n *\n * Loads a gitignored `.env` if present, then \u2014 when `NANO_STAGED` is set to an off value (`0`, `false`,\n * `off`, or `no`) \u2014 prints a notice and exits the process successfully so the pre-commit checks are\n * skipped. This mirrors husky's own `HUSKY=0` switch, but scoped to the nano-staged step (so the\n * commit-msg hook still runs). Otherwise it returns {@link obsidianDevUtilsConfig}, or \u2014 when\n * `additionalWriterTasks` are given \u2014 the same configuration re-partitioned with those writers added.\n *\n * A shared task whose npm script the project's `package.json` does not declare is left out, so a project\n * without, say, markdownlint does not fail its first commit that stages a `.md` file on a missing script. A\n * writer pattern left with no writer is dropped, and spellcheck runs only when `spellcheck` is declared, in\n * which case its files fall to the spellcheck-only key. The `additionalWriterTasks` are the caller's own and\n * are kept as given.\n *\n * A positive integer `BULK_CORES` budget serializes the generated commands into one group. nano-staged\n * has no concurrency option, so this keeps its processes within even a one-core budget. Without a valid\n * budget the usual parallel groups are retained.\n *\n * `NANO_STAGED` is not an npm script, so it carries its own switch rather than the script-name-derived one\n * every npm script gets \u2014 but both share the same notion of an off value, via {@link isEnvVariableOff}.\n *\n * This is a function rather than module-level code so importing the package barrel never triggers the\n * `.env` read or the process exit; call it from the thin `scripts/nano-staged-config.ts` entry. Resolving the\n * package manager is the one thing that does run at module scope, and it does neither of those two\n * things \u2014 it only probes for a lockfile.\n *\n * @param options - The optional options.\n * @returns The nano-staged task configuration. Does not return when the opt-out is active.\n */\nexport function getNanoStagedConfig(options?: GetNanoStagedConfigOptions): NanoStagedConfig {\n  loadEnvFileIfExists();\n\n  if (isEnvVariableOff(NANO_STAGED_ENV_VARIABLE)) {\n    process.stdout.write(`nano-staged: skipped (${NANO_STAGED_ENV_VARIABLE} is off).\\n`);\n    process.exit(0);\n  }\n\n  const scriptNames = new Set(Object.keys(readPackageJsonSync().scripts ?? {}));\n  const hasAllSharedScripts = [SPELLCHECK_SCRIPT_NAME, ...Object.values(WRITER_SCRIPT_NAMES).flat()]\n    .every((scriptName) => scriptNames.has(scriptName));\n  const additionalWriterTasks = options?.additionalWriterTasks ?? {};\n  if (hasAllSharedScripts && Object.keys(additionalWriterTasks).length === 0) {\n    return applyBulkBudget(obsidianDevUtilsConfig);\n  }\n\n  const writerTasks = toWriterTasks((scriptName) => scriptNames.has(scriptName));\n  const duplicatePattern = Object.keys(additionalWriterTasks).find((pattern) => Object.hasOwn(writerTasks, pattern));\n  if (duplicatePattern !== undefined) {\n    throw new Error(`nano-staged writer pattern '${duplicatePattern}' is already a shared writer pattern.`);\n  }\n\n  return applyBulkBudget(partitionSpellcheck({ ...writerTasks, ...additionalWriterTasks }, scriptNames.has(SPELLCHECK_SCRIPT_NAME)));\n}\n\n/**\n * Collects commands using nano-staged's own pattern matching, then runs them in one serial group.\n *\n * nano-staged's `generateCmdTasks` visits configuration entries in insertion order before executing any\n * commands. The original pattern callbacks collect their commands and return none; the final catch-all\n * drains them. This preserves its glob dialect, custom writers, batching and per-file writer order without\n * depending on its private compiler. The installed runner's generation order is pinned by the tests.\n *\n * @param config - The configuration whose execution should respect the bulk budget.\n * @returns The serial configuration when a budget is present, otherwise the original configuration.\n */\nfunction applyBulkBudget(config: NanoStagedConfig): NanoStagedConfig {\n  const budget = process.env['BULK_CORES']?.trim() ?? '';\n  if (!/^[1-9]\\d*$/.test(budget)) {\n    return config;\n  }\n\n  const commands: string[] = [];\n  const serialConfig: NanoStagedConfig = {};\n  for (const [pattern, task] of Object.entries(config)) {\n    serialConfig[pattern] = (context): string[] => {\n      commands.push(...task(context));\n      return [];\n    };\n  }\n\n  // A spellcheck-only configuration can already own `*`; move its collector into the final callback.\n  const collectAll = serialConfig['*'];\n  delete serialConfig['*'];\n  serialConfig['*'] = (context): string[] => {\n    collectAll?.(context);\n    return commands.splice(0);\n  };\n  return serialConfig;\n}\n\n/**\n * Splits command arguments into batches that each fit one command line after a given prefix.\n *\n * Each argument is costed as nano-staged passes it on Windows \u2014 quoted, then `^`-escaped by `cmd.exe`'s\n * rules \u2014 through {@link getEffectiveCommandLineLength}, and the budget is {@link getMaxBatchCommandLength},\n * which already holds back the reserve for the `npm` \u2192 `cmd.exe` \u2192 `.bin` shim chain re-expanding the\n * arguments. An argument too long for any batch still gets a batch of its own: it fails loudly there, which\n * dropping it would not.\n *\n * @param prefix - The command the arguments are appended to.\n * @param commandArguments - The arguments to split.\n * @returns The batches, in order, together holding every argument once.\n */\nfunction batchCommandArguments(prefix: string, commandArguments: readonly string[]): string[][] {\n  const emptyLength = getEffectiveCommandLineLength('');\n  const budget = getMaxBatchCommandLength() - EXECUTABLE_PATH_RESERVE - getEffectiveCommandLineLength(prefix);\n  const batches: string[][] = [];\n  let batch: string[] = [];\n  let batchLength = 0;\n\n  for (const commandArgument of commandArguments) {\n    const argumentLength = getEffectiveCommandLineLength(` \"${commandArgument}\"`) - emptyLength;\n    if (batch.length > 0 && batchLength + argumentLength > budget) {\n      batches.push(batch);\n      batch = [];\n      batchLength = 0;\n    }\n    batch.push(commandArgument);\n    batchLength += argumentLength;\n  }\n\n  if (batch.length > 0) {\n    batches.push(batch);\n  }\n\n  return batches;\n}\n\n/**\n * Builds a nano-staged configuration in which spellcheck never reads a file while another task rewrites it.\n *\n * The same `Promise.all` that forces two writers into one key makes a catch-all `'*'` spellcheck key run\n * CONCURRENTLY with every writer key, so cspell would read a file that ESLint or dprint is rewriting in\n * place -- a spurious finding on a half-written file, or a pass over content that is not what gets\n * committed. So the staged files are PARTITIONED instead:\n *\n * - every writer key gets spellcheck appended as its LAST command, so it reads that key's files after they\n *   have been rewritten;\n * - one complement key spellchecks exactly the files no writer key claims.\n *\n * The complement is written in nano-staged's own glob dialect, which compiles `!(...)` to a lookahead that\n * is NOT anchored at the end of the path: `!(*.md)*` would exclude `notes.md.bak` too. A nested `!(?)`\n * compiles to `(?!.)`, which IS an end anchor, so each alternative is suffixed with it. A writer pattern\n * containing `/` would switch nano-staged into globstar mode, where `*` stops crossing directories and the\n * construction no longer holds -- hence the throw. The unit test pins the partition against the installed\n * nano-staged compiler, so a release that changes its dialect fails there rather than in a commit.\n *\n * Without spellcheck there is nothing to partition: each writer key runs its own commands, and no complement\n * key is emitted.\n *\n * @param writerTasks - The file-rewriting tasks, keyed by the pattern that claims their files.\n * @param shouldSpellcheck - Whether the project has a `spellcheck` script to run.\n * @returns The configuration, with the spellcheck step partitioned across the keys.\n */\nfunction partitionSpellcheck(writerTasks: Readonly<Record<string, readonly string[]>>, shouldSpellcheck: boolean): NanoStagedConfig {\n  if (!shouldSpellcheck) {\n    return Object.fromEntries(Object.entries(writerTasks).map(([pattern, commands]) => [pattern, toBatchedTask(commands)]));\n  }\n\n  const patterns = Object.keys(writerTasks);\n  const patternWithSlash = patterns.find((pattern) => pattern.includes('/'));\n  if (patternWithSlash !== undefined) {\n    throw new Error(`nano-staged writer pattern '${patternWithSlash}' contains '/', which the spellcheck partition cannot express.`);\n  }\n\n  // `!()*` would compile to a lookahead that rejects every path, so with no writer the complement is everything.\n  const complementPattern = patterns.length === 0 ? '*' : `!(${patterns.map((pattern) => `${pattern}!(?)`).join('|')})*`;\n  const config: NanoStagedConfig = {\n    [complementPattern]: toBatchedTask([SPELLCHECK_COMMAND])\n  };\n\n  for (const [pattern, commands] of Object.entries(writerTasks)) {\n    config[pattern] = toBatchedTask([...commands, SPELLCHECK_COMMAND]);\n  }\n\n  return config;\n}\n\n/**\n * Builds a task that runs each command over every staged file it receives, in as many batches as the command\n * line needs.\n *\n * nano-staged appends a string task's files to ONE command, so a commit staging a few hundred files ran\n * `npm run lint:fix -- <every path>` and failed on Windows with `The command line is too long.`, refusing\n * exactly the whole-repo commits that most need the hook. A function-valued task builds its own commands\n * instead, and these are batched against the same budget `exec()` uses (see `batchCommandArguments`).\n *\n * The commands keep their order: every batch of the first command runs before any batch of the second,\n * because nano-staged runs one key's commands one after another, so a writer still finishes before the next\n * writer, and spellcheck still reads the rewritten files.\n *\n * @param commands - The command prefixes, in the order they run.\n * @returns The task.\n */\nfunction toBatchedTask(commands: readonly string[]): NanoStagedTask {\n  return ({ filenames }) => {\n    const commandArguments = filenames.map((filename) => toCommandArgument(filename));\n    return commands.flatMap((command) => batchCommandArguments(command, commandArguments).map((batch) => `${command} ${batch.join(' ')}`));\n  };\n}\n\n/**\n * Turns a staged file's absolute path into the argument a batched task passes for it.\n *\n * The path is made relative to the working directory, where nano-staged and the task both run, which roughly\n * halves its length and so the number of batches; a path outside it stays absolute. A relative path starting\n * with `-` gets `./`, so no tool reads it as an option.\n *\n * Whitespace and quotes become `?`, because nano-staged's tokenizer cannot carry them (see\n * {@link TOKENIZER_UNSAFE_CHARACTERS_REG_EXP}). Every tool the tasks run (ESLint, dprint, cspell,\n * markdownlint-cli2) takes its paths as globs, and `?` matches exactly the one character it replaced, so the\n * file is still found; a sibling differing only in that character would match too, which costs a lint of an\n * extra file, not a missed one.\n *\n * @param filename - The absolute path of the staged file.\n * @returns The argument.\n */\nfunction toCommandArgument(filename: string): string {\n  const relativePath = relative(process.cwd(), filename);\n  let commandArgument = (relativePath.startsWith('..') || isAbsolute(relativePath) ? filename : relativePath).replaceAll('\\\\', '/');\n  if (commandArgument.startsWith('-')) {\n    commandArgument = `./${commandArgument}`;\n  }\n  return commandArgument.replaceAll(TOKENIZER_UNSAFE_CHARACTERS_REG_EXP, '?');\n}\n\n/**\n * Builds the command prefix that runs an npm script over the paths appended to it.\n *\n * @param scriptName - The script name.\n * @returns The command prefix, such as `npm run lint:fix --`.\n */\nfunction toScriptCommand(scriptName: string): string {\n  return `${PACKAGE_MANAGER_RUN_COMMAND} ${scriptName} --`;\n}\n\n/**\n * Builds the shared writer tasks from {@link WRITER_SCRIPT_NAMES}, keeping only the scripts a filter accepts\n * and dropping a pattern left with none.\n *\n * @param shouldIncludeScript - Whether to run a given script.\n * @returns The writer tasks, keyed by the pattern that claims their files.\n */\nfunction toWriterTasks(shouldIncludeScript: (scriptName: string) => boolean): Record<string, readonly string[]> {\n  const writerTasks: Record<string, readonly string[]> = {};\n  for (const [pattern, scriptNames] of Object.entries(WRITER_SCRIPT_NAMES)) {\n    const commands = scriptNames.filter((scriptName) => shouldIncludeScript(scriptName)).map((scriptName) => toScriptCommand(scriptName));\n    if (commands.length > 0) {\n      writerTasks[pattern] = commands;\n    }\n  }\n  return writerTasks;\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/esm/test-runners/auto.d.mts

@@ -31,6 +31,11 @@ export interface TestCoverageOptions extends TestOptions {
  * Options for running tests.
  */
 export interface TestOptions {
+    /**
+     * Further CLI arguments for the runner, appended after the wrapper's own: file filters, `-t`, `--maxWorkers`. An
+     * argument naming an option the wrapper sets itself (projects, coverage, watch mode) throws.
+     */
+    readonly additionalArguments?: readonly string[];
     /**
      * Whether jest runs the suite as ES modules. Vitest ignores it.
      *

package/dist/lib/esm/test-runners/auto.mjs

@@ -61,4 +61,4 @@ export {
   testCoverage,
   testWatch
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/test-runners/forwarded-arguments.d.mts

@@ -0,0 +1,49 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * Guards the CLI arguments a test wrapper forwards to its runner against the options the wrapper sets itself.
+ */
+/**
+ * Params for {@link assertNoOwnedArguments}.
+ */
+export interface AssertNoOwnedArgumentsParams {
+    /**
+     * The arguments the caller forwards.
+     */
+    readonly forwardedArguments: readonly string[];
+    /**
+     * The options the wrapper sets itself.
+     */
+    readonly ownedOptions: readonly OwnedOption[];
+    /**
+     * The runner's name, shown in the error.
+     */
+    readonly runnerName: string;
+}
+/**
+ * An option a test wrapper sets itself, so a forwarded argument may not name it.
+ */
+export interface OwnedOption {
+    /**
+     * The spellings that name the option, each matched alone (`--project`) or with a value (`--project=x`).
+     */
+    readonly names: readonly string[];
+    /**
+     * Prefixes that name the option's sub-options, such as `--coverage.`.
+     */
+    readonly prefixes?: readonly string[];
+    /**
+     * What to use instead, shown in the error.
+     */
+    readonly replacement: string;
+}
+/**
+ * Throws when a forwarded argument names an option the wrapper sets itself.
+ *
+ * Letting it through would not override the wrapper reliably: vitest adds every `--project` to the wrapper's own, and a
+ * later `--coverage.thresholds.lines` would quietly lower a coverage gate.
+ *
+ * @param params - The {@link AssertNoOwnedArgumentsParams}.
+ */
+export declare function assertNoOwnedArguments(params: AssertNoOwnedArgumentsParams): void;

package/dist/lib/esm/test-runners/forwarded-arguments.mjs

@@ -0,0 +1,26 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+function assertNoOwnedArguments(params) {
+  const { forwardedArguments, ownedOptions, runnerName } = params;
+  const problems = [];
+  for (const argument of forwardedArguments) {
+    const option = ownedOptions.find((candidate) => isOwnedArgument(argument, candidate));
+    if (option) {
+      problems.push(`${argument} (use ${option.replacement} instead)`);
+    }
+  }
+  if (problems.length > 0) {
+    throw new Error(`The ${runnerName} wrapper sets these options itself, so they cannot be forwarded: ${problems.join(", ")}.`);
+  }
+}
+function isOwnedArgument(argument, option) {
+  const name = argument.replace(/[=].*$/su, "");
+  return option.names.includes(name) || (option.prefixes ?? []).some((prefix) => argument.startsWith(prefix));
+}
+export {
+  assertNoOwnedArguments
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/test-runners/index.d.mts

@@ -1,5 +1,6 @@
 /// <reference path="../library-references.d.mts" />
 export * as 'auto' from './auto.mjs';
+export * as 'forwarded-arguments' from './forwarded-arguments.mjs';
 export * as 'jest-config' from './jest-config.mjs';
 export * as 'jest' from './jest.mjs';
 export * as 'stryker-config' from './stryker-config.mjs';

package/dist/lib/esm/test-runners/index.mjs

@@ -4,6 +4,7 @@ if you want to view the source, please visit the github repository of this plugi
 */
 
 import * as auto from "./auto.mjs";
+import * as forwarded_arguments from "./forwarded-arguments.mjs";
 import * as jest_config from "./jest-config.mjs";
 import * as jest from "./jest.mjs";
 import * as stryker_config from "./stryker-config.mjs";
@@ -12,6 +13,7 @@ import * as vitest_config from "./vitest-config.mjs";
 import * as vitest from "./vitest.mjs";
 export {
   auto,
+  forwarded_arguments as "forwarded-arguments",
   jest,
   jest_config as "jest-config",
   stryker,
@@ -19,4 +21,4 @@ export {
   vitest,
   vitest_config as "vitest-config"
 };
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL3Rlc3QtcnVubmVycy9pbmRleC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyogVEhJUyBJUyBBIEdFTkVSQVRFRC9CVU5ETEVEIEZJTEUgQlkgQlVJTEQgU0NSSVBUICovXG5cbmV4cG9ydCAqIGFzICdhdXRvJyBmcm9tICcuL2F1dG8udHMnO1xuZXhwb3J0ICogYXMgJ2plc3QtY29uZmlnJyBmcm9tICcuL2plc3QtY29uZmlnLnRzJztcbmV4cG9ydCAqIGFzICdqZXN0JyBmcm9tICcuL2plc3QudHMnO1xuZXhwb3J0ICogYXMgJ3N0cnlrZXItY29uZmlnJyBmcm9tICcuL3N0cnlrZXItY29uZmlnLnRzJztcbmV4cG9ydCAqIGFzICdzdHJ5a2VyJyBmcm9tICcuL3N0cnlrZXIudHMnO1xuZXhwb3J0ICogYXMgJ3ZpdGVzdC1jb25maWcnIGZyb20gJy4vdml0ZXN0LWNvbmZpZy50cyc7XG5leHBvcnQgKiBhcyAndml0ZXN0JyBmcm9tICcuL3ZpdGVzdC50cyc7XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7OztBQUVBLFlBQVksVUFBWTtBQUN4QixZQUFZQSxpQkFBbUI7QUFDL0IsWUFBWSxVQUFZO0FBQ3hCLFlBQVlDLG9CQUFzQjtBQUNsQyxZQUFZLGFBQWU7QUFDM0IsWUFBWUMsbUJBQXFCO0FBQ2pDLFlBQVksWUFBYzsiLAogICJuYW1lcyI6IFsiamVzdC1jb25maWciLCAic3RyeWtlci1jb25maWciLCAidml0ZXN0LWNvbmZpZyJdCn0K
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL3Rlc3QtcnVubmVycy9pbmRleC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyogVEhJUyBJUyBBIEdFTkVSQVRFRC9CVU5ETEVEIEZJTEUgQlkgQlVJTEQgU0NSSVBUICovXG5cbmV4cG9ydCAqIGFzICdhdXRvJyBmcm9tICcuL2F1dG8udHMnO1xuZXhwb3J0ICogYXMgJ2ZvcndhcmRlZC1hcmd1bWVudHMnIGZyb20gJy4vZm9yd2FyZGVkLWFyZ3VtZW50cy50cyc7XG5leHBvcnQgKiBhcyAnamVzdC1jb25maWcnIGZyb20gJy4vamVzdC1jb25maWcudHMnO1xuZXhwb3J0ICogYXMgJ2plc3QnIGZyb20gJy4vamVzdC50cyc7XG5leHBvcnQgKiBhcyAnc3RyeWtlci1jb25maWcnIGZyb20gJy4vc3RyeWtlci1jb25maWcudHMnO1xuZXhwb3J0ICogYXMgJ3N0cnlrZXInIGZyb20gJy4vc3RyeWtlci50cyc7XG5leHBvcnQgKiBhcyAndml0ZXN0LWNvbmZpZycgZnJvbSAnLi92aXRlc3QtY29uZmlnLnRzJztcbmV4cG9ydCAqIGFzICd2aXRlc3QnIGZyb20gJy4vdml0ZXN0LnRzJztcbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7O0FBRUEsWUFBWSxVQUFZO0FBQ3hCLFlBQVlBLHlCQUEyQjtBQUN2QyxZQUFZQyxpQkFBbUI7QUFDL0IsWUFBWSxVQUFZO0FBQ3hCLFlBQVlDLG9CQUFzQjtBQUNsQyxZQUFZLGFBQWU7QUFDM0IsWUFBWUMsbUJBQXFCO0FBQ2pDLFlBQVksWUFBYzsiLAogICJuYW1lcyI6IFsiZm9yd2FyZGVkLWFyZ3VtZW50cyIsICJqZXN0LWNvbmZpZyIsICJzdHJ5a2VyLWNvbmZpZyIsICJ2aXRlc3QtY29uZmlnIl0KfQo=

package/dist/lib/esm/test-runners/jest.d.mts

@@ -31,6 +31,11 @@ export interface TestCoverageOptions extends TestOptions {
  * Options for running tests.
  */
 export interface TestOptions {
+    /**
+     * Further jest CLI arguments, appended after the wrapper's own: test path patterns, `-t`, `--maxWorkers`, `--bail`.
+     * An argument naming an option the wrapper sets itself (`--selectProjects`, `--coverage*`, `--watch*`) throws.
+     */
+    readonly additionalArguments?: readonly string[];
     /**
      * Whether jest runs the suite as ES modules, which adds {@link EXPERIMENTAL_VM_MODULES_FLAG} to `NODE_OPTIONS`.
      *

package/dist/lib/esm/test-runners/jest.mjs

@@ -12,7 +12,16 @@ import {
   execFromRoot,
   resolvePathFromRootSafe
 } from "../root.mjs";
+import { assertNoOwnedArguments } from "./forwarded-arguments.mjs";
 import { isEsmPackage } from "./jest-config.mjs";
+const OWNED_OPTIONS = [
+  { names: ["--selectProjects", "--select-projects"], replacement: "the `projects` option" },
+  { names: ["--watch", "--watchAll", "--watch-all"], replacement: "the `testWatch` wrapper" },
+  {
+    names: ["--coverage", "--no-coverage", "--collectCoverage", "--collect-coverage", "--no-collectCoverage", "--coverageThreshold", "--coverage-threshold"],
+    replacement: "the `testCoverage` wrapper and its `minCoverageInPercents` option"
+  }
+];
 const JEST_CONFIG_FILE_NAMES = [
   "jest.config.cjs",
   "jest.config.cts",
@@ -59,10 +68,14 @@ function addExperimentalVmModulesFlag(nodeOptions) {
   return flags.join(" ");
 }
 async function runJest(runArguments, options, isInteractive = false) {
-  const { esm = isEsmPackage(), projects = [] } = options;
+  const { additionalArguments = [], esm = isEsmPackage(), projects = [] } = options;
+  assertNoOwnedArguments({ forwardedArguments: additionalArguments, ownedOptions: OWNED_OPTIONS, runnerName: "jest" });
   const projectArguments = projects.length > 0 ? ["--selectProjects", ...projects] : [];
   const env = esm ? { NODE_OPTIONS: addExperimentalVmModulesFlag(process.env["NODE_OPTIONS"]) } : {};
-  await execFromRoot([...resolveToolCommand({ tool: "jest" }), ...runArguments, ...projectArguments], { env, isInteractive });
+  await execFromRoot([...resolveToolCommand({ tool: "jest" }), ...runArguments, ...projectArguments, ...additionalArguments], {
+    env,
+    isInteractive
+  });
 }
 export {
   EXPERIMENTAL_VM_MODULES_FLAG,
@@ -72,4 +85,4 @@ export {
   testCoverage,
   testWatch
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/test-runners/jest.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * This module provides functions for running tests using the Jest framework.\n */\n\nimport { existsSync } from 'node:fs';\nimport process from 'node:process';\n\nimport { readPackageJson } from '../npm.ts';\nimport { resolveToolCommand } from '../package-manager.ts';\nimport { RepoPaths } from '../repo-paths.ts';\nimport {\n  execFromRoot,\n  resolvePathFromRootSafe\n} from '../root.ts';\nimport { isEsmPackage } from './jest-config.ts';\n\n/**\n * Every file jest reads its configuration from, besides the `jest` key of `package.json`.\n *\n * @see {@link https://jestjs.io/docs/configuration}\n */\nexport const JEST_CONFIG_FILE_NAMES: readonly string[] = [\n  'jest.config.cjs',\n  'jest.config.cts',\n  'jest.config.js',\n  'jest.config.json',\n  'jest.config.mjs',\n  'jest.config.mts',\n  'jest.config.ts'\n];\n\n/**\n * The Node flag jest's ESM loader needs: it is built on `vm.SyntheticModule`, which Node only exposes under it.\n * Without it every ESM suite fails to load with `Must use import to load ES Module`.\n */\nexport const EXPERIMENTAL_VM_MODULES_FLAG = '--experimental-vm-modules';\n\n/**\n * Options for running tests with coverage.\n */\nexport interface TestCoverageOptions extends TestOptions {\n  /**\n   * Minimum coverage percentage required, for lines, functions, branches and statements alike. If the actual coverage\n   * falls below it, jest exits with a non-zero code.\n   *\n   * @default `0`\n   */\n  readonly minCoverageInPercents?: number;\n}\n\n/**\n * Options for running tests.\n */\nexport interface TestOptions {\n  /**\n   * Whether jest runs the suite as ES modules, which adds {@link EXPERIMENTAL_VM_MODULES_FLAG} to `NODE_OPTIONS`.\n   *\n   * @default `true` when `package.json` declares `\"type\": \"module\"`, the rule `defineJestConfig` follows too\n   */\n  readonly esm?: boolean;\n\n  /**\n   * The projects to run, by their `displayName`, passed to jest's `--selectProjects`. Unlike vitest's runner, a name\n   * matches only itself: jest has no `name:*` form.\n   */\n  readonly projects?: string[];\n}\n\n/**\n * Options for running tests in watch mode.\n */\nexport type TestWatchOptions = TestOptions;\n\n/**\n * Says whether the project configures jest.\n *\n * @returns Whether a jest configuration file, or a `jest` key in `package.json`, exists at the project root.\n */\nexport async function hasJestConfig(): Promise<boolean> {\n  if (JEST_CONFIG_FILE_NAMES.some((fileName) => existsSync(resolvePathFromRootSafe({ path: fileName })))) {\n    return true;\n  }\n\n  if (!existsSync(resolvePathFromRootSafe({ path: RepoPaths.PackageJson }))) {\n    return false;\n  }\n\n  const packageJson = await readPackageJson();\n  return Object.hasOwn(packageJson, 'jest');\n}\n\n/**\n * Runs the test suite.\n *\n * @param options - The options for the test.\n * @returns A {@link Promise} that resolves when the tests have completed.\n */\nexport async function test(options: TestOptions = {}): Promise<void> {\n  await runJest([], options);\n}\n\n/**\n * Runs the test suite with coverage.\n *\n * @param options - Optional coverage configuration.\n * @returns A {@link Promise} that resolves when the tests have completed.\n */\nexport async function testCoverage(options: TestCoverageOptions = {}): Promise<void> {\n  const threshold = options.minCoverageInPercents ?? 0;\n  const coverageThreshold = {\n    global: {\n      branches: threshold,\n      functions: threshold,\n      lines: threshold,\n      statements: threshold\n    }\n  };\n  await runJest(['--coverage', `--coverageThreshold=${JSON.stringify(coverageThreshold)}`], options);\n}\n\n/**\n * Runs the test suite in watch mode, re-running the tests the changed files affect. Jest needs a git or Mercurial\n * repository for that.\n *\n * @param options - The options for the test.\n * @returns A {@link Promise} that resolves when the watcher exits.\n */\nexport async function testWatch(options: TestWatchOptions = {}): Promise<void> {\n  await runJest(['--watch'], options, true);\n}\n\n/**\n * Appends {@link EXPERIMENTAL_VM_MODULES_FLAG} to a `NODE_OPTIONS` value, keeping whatever it already holds.\n *\n * @param nodeOptions - The inherited `NODE_OPTIONS`.\n * @returns The `NODE_OPTIONS` jest runs with.\n */\nfunction addExperimentalVmModulesFlag(nodeOptions: string | undefined): string {\n  const flags = (nodeOptions ?? '').split(/\\s+/).filter(Boolean);\n  if (!flags.includes(EXPERIMENTAL_VM_MODULES_FLAG)) {\n    flags.push(EXPERIMENTAL_VM_MODULES_FLAG);\n  }\n\n  return flags.join(' ');\n}\n\n/**\n * Runs the jest CLI from the project root.\n *\n * @param runArguments - The arguments that select what jest does.\n * @param options - The {@link TestOptions}.\n * @param isInteractive - Whether jest gets the terminal, as its watch mode needs to read keys.\n * @returns A {@link Promise} that resolves when jest exits.\n */\nasync function runJest(runArguments: string[], options: TestOptions, isInteractive = false): Promise<void> {\n  const { esm = isEsmPackage(), projects = [] } = options;\n  const projectArguments = projects.length > 0 ? ['--selectProjects', ...projects] : [];\n  const env = esm ? { NODE_OPTIONS: addExperimentalVmModulesFlag(process.env['NODE_OPTIONS']) } : {};\n\n  await execFromRoot([...resolveToolCommand({ tool: 'jest' }), ...runArguments, ...projectArguments], { env, isInteractive });\n}\n"],
  "mappings": ";;;;;AAMA,SAAS,kBAAkB;AAC3B,OAAO,aAAa;AAEpB,SAAS,uBAAuB;AAChC,SAAS,0BAA0B;AACnC,SAAS,iBAAiB;AAC1B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,oBAAoB;AAOtB,MAAM,yBAA4C;AAAA,EACvD;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAMO,MAAM,+BAA+B;AA2C5C,eAAsB,gBAAkC;AACtD,MAAI,uBAAuB,KAAK,CAAC,aAAa,WAAW,wBAAwB,EAAE,MAAM,SAAS,CAAC,CAAC,CAAC,GAAG;AACtG,WAAO;AAAA,EACT;AAEA,MAAI,CAAC,WAAW,wBAAwB,EAAE,MAAM,UAAU,YAAY,CAAC,CAAC,GAAG;AACzE,WAAO;AAAA,EACT;AAEA,QAAM,cAAc,MAAM,gBAAgB;AAC1C,SAAO,OAAO,OAAO,aAAa,MAAM;AAC1C;AAQA,eAAsB,KAAK,UAAuB,CAAC,GAAkB;AACnE,QAAM,QAAQ,CAAC,GAAG,OAAO;AAC3B;AAQA,eAAsB,aAAa,UAA+B,CAAC,GAAkB;AACnF,QAAM,YAAY,QAAQ,yBAAyB;AACnD,QAAM,oBAAoB;AAAA,IACxB,QAAQ;AAAA,MACN,UAAU;AAAA,MACV,WAAW;AAAA,MACX,OAAO;AAAA,MACP,YAAY;AAAA,IACd;AAAA,EACF;AACA,QAAM,QAAQ,CAAC,cAAc,uBAAuB,KAAK,UAAU,iBAAiB,CAAC,EAAE,GAAG,OAAO;AACnG;AASA,eAAsB,UAAU,UAA4B,CAAC,GAAkB;AAC7E,QAAM,QAAQ,CAAC,SAAS,GAAG,SAAS,IAAI;AAC1C;AAQA,SAAS,6BAA6B,aAAyC;AAC7E,QAAM,SAAS,eAAe,IAAI,MAAM,KAAK,EAAE,OAAO,OAAO;AAC7D,MAAI,CAAC,MAAM,SAAS,4BAA4B,GAAG;AACjD,UAAM,KAAK,4BAA4B;AAAA,EACzC;AAEA,SAAO,MAAM,KAAK,GAAG;AACvB;AAUA,eAAe,QAAQ,cAAwB,SAAsB,gBAAgB,OAAsB;AACzG,QAAM,EAAE,MAAM,aAAa,GAAG,WAAW,CAAC,EAAE,IAAI;AAChD,QAAM,mBAAmB,SAAS,SAAS,IAAI,CAAC,oBAAoB,GAAG,QAAQ,IAAI,CAAC;AACpF,QAAM,MAAM,MAAM,EAAE,cAAc,6BAA6B,QAAQ,IAAI,cAAc,CAAC,EAAE,IAAI,CAAC;AAEjG,QAAM,aAAa,CAAC,GAAG,mBAAmB,EAAE,MAAM,OAAO,CAAC,GAAG,GAAG,cAAc,GAAG,gBAAgB,GAAG,EAAE,KAAK,cAAc,CAAC;AAC5H;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/test-runners/jest.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * This module provides functions for running tests using the Jest framework.\n */\n\nimport { existsSync } from 'node:fs';\nimport process from 'node:process';\n\nimport type { OwnedOption } from './forwarded-arguments.ts';\n\nimport { readPackageJson } from '../npm.ts';\nimport { resolveToolCommand } from '../package-manager.ts';\nimport { RepoPaths } from '../repo-paths.ts';\nimport {\n  execFromRoot,\n  resolvePathFromRootSafe\n} from '../root.ts';\nimport { assertNoOwnedArguments } from './forwarded-arguments.ts';\nimport { isEsmPackage } from './jest-config.ts';\n\nconst OWNED_OPTIONS: readonly OwnedOption[] = [\n  { names: ['--selectProjects', '--select-projects'], replacement: 'the `projects` option' },\n  { names: ['--watch', '--watchAll', '--watch-all'], replacement: 'the `testWatch` wrapper' },\n  {\n    names: ['--coverage', '--no-coverage', '--collectCoverage', '--collect-coverage', '--no-collectCoverage', '--coverageThreshold', '--coverage-threshold'],\n    replacement: 'the `testCoverage` wrapper and its `minCoverageInPercents` option'\n  }\n];\n\n/**\n * Every file jest reads its configuration from, besides the `jest` key of `package.json`.\n *\n * @see {@link https://jestjs.io/docs/configuration}\n */\nexport const JEST_CONFIG_FILE_NAMES: readonly string[] = [\n  'jest.config.cjs',\n  'jest.config.cts',\n  'jest.config.js',\n  'jest.config.json',\n  'jest.config.mjs',\n  'jest.config.mts',\n  'jest.config.ts'\n];\n\n/**\n * The Node flag jest's ESM loader needs: it is built on `vm.SyntheticModule`, which Node only exposes under it.\n * Without it every ESM suite fails to load with `Must use import to load ES Module`.\n */\nexport const EXPERIMENTAL_VM_MODULES_FLAG = '--experimental-vm-modules';\n\n/**\n * Options for running tests with coverage.\n */\nexport interface TestCoverageOptions extends TestOptions {\n  /**\n   * Minimum coverage percentage required, for lines, functions, branches and statements alike. If the actual coverage\n   * falls below it, jest exits with a non-zero code.\n   *\n   * @default `0`\n   */\n  readonly minCoverageInPercents?: number;\n}\n\n/**\n * Options for running tests.\n */\nexport interface TestOptions {\n  /**\n   * Further jest CLI arguments, appended after the wrapper's own: test path patterns, `-t`, `--maxWorkers`, `--bail`.\n   * An argument naming an option the wrapper sets itself (`--selectProjects`, `--coverage*`, `--watch*`) throws.\n   */\n  readonly additionalArguments?: readonly string[];\n\n  /**\n   * Whether jest runs the suite as ES modules, which adds {@link EXPERIMENTAL_VM_MODULES_FLAG} to `NODE_OPTIONS`.\n   *\n   * @default `true` when `package.json` declares `\"type\": \"module\"`, the rule `defineJestConfig` follows too\n   */\n  readonly esm?: boolean;\n\n  /**\n   * The projects to run, by their `displayName`, passed to jest's `--selectProjects`. Unlike vitest's runner, a name\n   * matches only itself: jest has no `name:*` form.\n   */\n  readonly projects?: string[];\n}\n\n/**\n * Options for running tests in watch mode.\n */\nexport type TestWatchOptions = TestOptions;\n\n/**\n * Says whether the project configures jest.\n *\n * @returns Whether a jest configuration file, or a `jest` key in `package.json`, exists at the project root.\n */\nexport async function hasJestConfig(): Promise<boolean> {\n  if (JEST_CONFIG_FILE_NAMES.some((fileName) => existsSync(resolvePathFromRootSafe({ path: fileName })))) {\n    return true;\n  }\n\n  if (!existsSync(resolvePathFromRootSafe({ path: RepoPaths.PackageJson }))) {\n    return false;\n  }\n\n  const packageJson = await readPackageJson();\n  return Object.hasOwn(packageJson, 'jest');\n}\n\n/**\n * Runs the test suite.\n *\n * @param options - The options for the test.\n * @returns A {@link Promise} that resolves when the tests have completed.\n */\nexport async function test(options: TestOptions = {}): Promise<void> {\n  await runJest([], options);\n}\n\n/**\n * Runs the test suite with coverage.\n *\n * @param options - Optional coverage configuration.\n * @returns A {@link Promise} that resolves when the tests have completed.\n */\nexport async function testCoverage(options: TestCoverageOptions = {}): Promise<void> {\n  const threshold = options.minCoverageInPercents ?? 0;\n  const coverageThreshold = {\n    global: {\n      branches: threshold,\n      functions: threshold,\n      lines: threshold,\n      statements: threshold\n    }\n  };\n  await runJest(['--coverage', `--coverageThreshold=${JSON.stringify(coverageThreshold)}`], options);\n}\n\n/**\n * Runs the test suite in watch mode, re-running the tests the changed files affect. Jest needs a git or Mercurial\n * repository for that.\n *\n * @param options - The options for the test.\n * @returns A {@link Promise} that resolves when the watcher exits.\n */\nexport async function testWatch(options: TestWatchOptions = {}): Promise<void> {\n  await runJest(['--watch'], options, true);\n}\n\n/**\n * Appends {@link EXPERIMENTAL_VM_MODULES_FLAG} to a `NODE_OPTIONS` value, keeping whatever it already holds.\n *\n * @param nodeOptions - The inherited `NODE_OPTIONS`.\n * @returns The `NODE_OPTIONS` jest runs with.\n */\nfunction addExperimentalVmModulesFlag(nodeOptions: string | undefined): string {\n  const flags = (nodeOptions ?? '').split(/\\s+/).filter(Boolean);\n  if (!flags.includes(EXPERIMENTAL_VM_MODULES_FLAG)) {\n    flags.push(EXPERIMENTAL_VM_MODULES_FLAG);\n  }\n\n  return flags.join(' ');\n}\n\n/**\n * Runs the jest CLI from the project root.\n *\n * @param runArguments - The arguments that select what jest does.\n * @param options - The {@link TestOptions}.\n * @param isInteractive - Whether jest gets the terminal, as its watch mode needs to read keys.\n * @returns A {@link Promise} that resolves when jest exits.\n */\nasync function runJest(runArguments: string[], options: TestOptions, isInteractive = false): Promise<void> {\n  const { additionalArguments = [], esm = isEsmPackage(), projects = [] } = options;\n  assertNoOwnedArguments({ forwardedArguments: additionalArguments, ownedOptions: OWNED_OPTIONS, runnerName: 'jest' });\n  const projectArguments = projects.length > 0 ? ['--selectProjects', ...projects] : [];\n  const env = esm ? { NODE_OPTIONS: addExperimentalVmModulesFlag(process.env['NODE_OPTIONS']) } : {};\n\n  await execFromRoot([...resolveToolCommand({ tool: 'jest' }), ...runArguments, ...projectArguments, ...additionalArguments], {\n    env,\n    isInteractive\n  });\n}\n"],
  "mappings": ";;;;;AAMA,SAAS,kBAAkB;AAC3B,OAAO,aAAa;AAIpB,SAAS,uBAAuB;AAChC,SAAS,0BAA0B;AACnC,SAAS,iBAAiB;AAC1B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AACP,SAAS,8BAA8B;AACvC,SAAS,oBAAoB;AAE7B,MAAM,gBAAwC;AAAA,EAC5C,EAAE,OAAO,CAAC,oBAAoB,mBAAmB,GAAG,aAAa,wBAAwB;AAAA,EACzF,EAAE,OAAO,CAAC,WAAW,cAAc,aAAa,GAAG,aAAa,0BAA0B;AAAA,EAC1F;AAAA,IACE,OAAO,CAAC,cAAc,iBAAiB,qBAAqB,sBAAsB,wBAAwB,uBAAuB,sBAAsB;AAAA,IACvJ,aAAa;AAAA,EACf;AACF;AAOO,MAAM,yBAA4C;AAAA,EACvD;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF;AAMO,MAAM,+BAA+B;AAiD5C,eAAsB,gBAAkC;AACtD,MAAI,uBAAuB,KAAK,CAAC,aAAa,WAAW,wBAAwB,EAAE,MAAM,SAAS,CAAC,CAAC,CAAC,GAAG;AACtG,WAAO;AAAA,EACT;AAEA,MAAI,CAAC,WAAW,wBAAwB,EAAE,MAAM,UAAU,YAAY,CAAC,CAAC,GAAG;AACzE,WAAO;AAAA,EACT;AAEA,QAAM,cAAc,MAAM,gBAAgB;AAC1C,SAAO,OAAO,OAAO,aAAa,MAAM;AAC1C;AAQA,eAAsB,KAAK,UAAuB,CAAC,GAAkB;AACnE,QAAM,QAAQ,CAAC,GAAG,OAAO;AAC3B;AAQA,eAAsB,aAAa,UAA+B,CAAC,GAAkB;AACnF,QAAM,YAAY,QAAQ,yBAAyB;AACnD,QAAM,oBAAoB;AAAA,IACxB,QAAQ;AAAA,MACN,UAAU;AAAA,MACV,WAAW;AAAA,MACX,OAAO;AAAA,MACP,YAAY;AAAA,IACd;AAAA,EACF;AACA,QAAM,QAAQ,CAAC,cAAc,uBAAuB,KAAK,UAAU,iBAAiB,CAAC,EAAE,GAAG,OAAO;AACnG;AASA,eAAsB,UAAU,UAA4B,CAAC,GAAkB;AAC7E,QAAM,QAAQ,CAAC,SAAS,GAAG,SAAS,IAAI;AAC1C;AAQA,SAAS,6BAA6B,aAAyC;AAC7E,QAAM,SAAS,eAAe,IAAI,MAAM,KAAK,EAAE,OAAO,OAAO;AAC7D,MAAI,CAAC,MAAM,SAAS,4BAA4B,GAAG;AACjD,UAAM,KAAK,4BAA4B;AAAA,EACzC;AAEA,SAAO,MAAM,KAAK,GAAG;AACvB;AAUA,eAAe,QAAQ,cAAwB,SAAsB,gBAAgB,OAAsB;AACzG,QAAM,EAAE,sBAAsB,CAAC,GAAG,MAAM,aAAa,GAAG,WAAW,CAAC,EAAE,IAAI;AAC1E,yBAAuB,EAAE,oBAAoB,qBAAqB,cAAc,eAAe,YAAY,OAAO,CAAC;AACnH,QAAM,mBAAmB,SAAS,SAAS,IAAI,CAAC,oBAAoB,GAAG,QAAQ,IAAI,CAAC;AACpF,QAAM,MAAM,MAAM,EAAE,cAAc,6BAA6B,QAAQ,IAAI,cAAc,CAAC,EAAE,IAAI,CAAC;AAEjG,QAAM,aAAa,CAAC,GAAG,mBAAmB,EAAE,MAAM,OAAO,CAAC,GAAG,GAAG,cAAc,GAAG,kBAAkB,GAAG,mBAAmB,GAAG;AAAA,IAC1H;AAAA,IACA;AAAA,EACF,CAAC;AACH;",
  "names": []
}


package/dist/lib/esm/test-runners/vitest.d.mts

@@ -20,6 +20,11 @@ export interface TestCoverageOptions extends TestOptions {
  * Options for running tests.
  */
 export interface TestOptions {
+    /**
+     * Further vitest CLI arguments, appended after the wrapper's own: file filters, `-t`, `--maxWorkers`, `--reporter`.
+     * An argument naming an option the wrapper sets itself (`--project`, `--coverage*`, `--run`, `--watch`) throws.
+     */
+    readonly additionalArguments?: readonly string[];
     /**
      * The projects to run.
      */

package/dist/lib/esm/test-runners/vitest.mjs

@@ -2,10 +2,62 @@
 THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
 if you want to view the source, please visit the github repository of this plugin
 */
+(function () {
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
 
-import { execFromRoot } from "../root.mjs";
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+ensureBrowserProcess();
+})();
+
+import { availableParallelism } from "node:os";
+import process from "node:process";
+import { getBulkConcurrency } from "../bulk-concurrency.mjs";
+import {
+  execFromRoot,
+  resolvePathFromRootSafe
+} from "../root.mjs";
+import { assertNoOwnedArguments } from "./forwarded-arguments.mjs";
+const WATCH_WORKER_DIVISOR = 2;
+const workerEnvironmentQueue = { pending: Promise.resolve(void 0) };
+const PROJECT_OPTION = { names: ["--project"], replacement: "the `projects` option" };
+const RUN_MODE_OPTION = { names: ["--run", "--watch", "-w"], replacement: "the `test`, `testCoverage` or `testWatch` wrapper" };
+const COVERAGE_OPTION = {
+  names: ["--coverage", "--no-coverage"],
+  prefixes: ["--coverage."],
+  replacement: "the `testCoverage` wrapper and its `minCoverageInPercents` option"
+};
+const OWNED_OPTIONS = [PROJECT_OPTION, RUN_MODE_OPTION, COVERAGE_OPTION];
 async function test(options = {}) {
-  await execFromRoot(["vitest", "run", ...buildProjectFlags(options.projects)]);
+  await execFromRoot(["vitest", "run", ...buildProjectFlags(options.projects), ...getAdditionalArguments(options)], {
+    env: await getWorkerEnvironment(options)
+  });
 }
 async function testCoverage(options = {}) {
   const threshold = String(options.minCoverageInPercents ?? 0);
@@ -17,18 +69,65 @@ async function testCoverage(options = {}) {
     `--coverage.thresholds.lines=${threshold}`,
     `--coverage.thresholds.functions=${threshold}`,
     `--coverage.thresholds.branches=${threshold}`,
-    `--coverage.thresholds.statements=${threshold}`
-  ]);
+    `--coverage.thresholds.statements=${threshold}`,
+    ...getAdditionalArguments(options)
+  ], { env: await getWorkerEnvironment(options) });
 }
 async function testWatch(options = {}) {
-  await execFromRoot(["vitest", ...buildProjectFlags(options.projects)]);
+  await execFromRoot(["vitest", ...buildProjectFlags(options.projects), ...getAdditionalArguments(options)], {
+    env: await getWorkerEnvironment(options, true)
+  });
 }
 function buildProjectFlags(projects) {
   return (projects ?? []).flatMap((project) => [`--project=${project}`, `--project=${project}:*`]);
 }
+function getAdditionalArguments(options) {
+  const { additionalArguments = [] } = options;
+  assertNoOwnedArguments({ forwardedArguments: additionalArguments, ownedOptions: OWNED_OPTIONS, runnerName: "vitest" });
+  return additionalArguments;
+}
+async function getWorkerEnvironment(options, isWatch = false) {
+  const next = workerEnvironmentQueue.pending.then(() => resolveWorkerEnvironment(options, isWatch));
+  workerEnvironmentQueue.pending = next.catch(() => void 0);
+  return next;
+}
+async function resolveWorkerEnvironment(options, isWatch) {
+  const budget = getBulkConcurrency(Infinity);
+  if (!Number.isFinite(budget)) {
+    return {};
+  }
+  const { resolveConfig } = await import("vitest/node");
+  const inheritedWorkers = process.env["VITEST_MAX_WORKERS"];
+  delete process.env["VITEST_MAX_WORKERS"];
+  let config;
+  try {
+    config = await resolveConfig({
+      project: (options.projects ?? []).flatMap((project) => [project, `${project}:*`]),
+      root: resolvePathFromRootSafe({ path: "." }),
+      watch: isWatch
+    });
+  } finally {
+    if (inheritedWorkers !== void 0) {
+      process.env["VITEST_MAX_WORKERS"] = inheritedWorkers;
+    }
+  }
+  const ordinaryWorkers = Math.max(isWatch ? Math.floor(availableParallelism() / WATCH_WORKER_DIVISOR) : availableParallelism() - 1, 1);
+  const inheritedLimit = Number.parseInt(inheritedWorkers ?? "", 10);
+  let workers = Math.min(budget, ordinaryWorkers);
+  if (Number.isSafeInteger(inheritedLimit) && inheritedLimit > 0) {
+    workers = Math.min(workers, inheritedLimit);
+  }
+  const configs = [config.test, ...config.test.resolvedProjects.filter((entry) => !entry.hidden).map((entry) => entry.projectConfig)];
+  for (const testConfig of configs) {
+    if (testConfig.maxWorkers) {
+      workers = Math.min(workers, testConfig.maxWorkers);
+    }
+  }
+  return { VITEST_MAX_WORKERS: String(workers) };
+}
 export {
   test,
   testCoverage,
   testWatch
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/test-runners/vitest.ts"],"sourcesContent":["/**\n * @file\n *\n * This module provides functions for running tests using the Vitest framework.\n */\n\nimport { availableParallelism } from 'node:os';\nimport process from 'node:process';\n\nimport type { OwnedOption } from './forwarded-arguments.ts';\n\nimport { getBulkConcurrency } from '../bulk-concurrency.ts';\nimport {\n  execFromRoot,\n  resolvePathFromRootSafe\n} from '../root.ts';\nimport { assertNoOwnedArguments } from './forwarded-arguments.ts';\n\nconst WATCH_WORKER_DIVISOR = 2;\nconst workerEnvironmentQueue = { pending: Promise.resolve<unknown>(undefined) };\n\nconst PROJECT_OPTION: OwnedOption = { names: ['--project'], replacement: 'the `projects` option' };\nconst RUN_MODE_OPTION: OwnedOption = { names: ['--run', '--watch', '-w'], replacement: 'the `test`, `testCoverage` or `testWatch` wrapper' };\nconst COVERAGE_OPTION: OwnedOption = {\n  names: ['--coverage', '--no-coverage'],\n  prefixes: ['--coverage.'],\n  replacement: 'the `testCoverage` wrapper and its `minCoverageInPercents` option'\n};\nconst OWNED_OPTIONS: readonly OwnedOption[] = [PROJECT_OPTION, RUN_MODE_OPTION, COVERAGE_OPTION];\n\n/**\n * Options for running tests with coverage.\n */\nexport interface TestCoverageOptions extends TestOptions {\n  /**\n   * Minimum coverage percentage required. If the actual coverage falls below\n   * this threshold, the process exits with a non-zero code.\n   *\n   * @default `0`\n   */\n  readonly minCoverageInPercents?: number;\n}\n\n/**\n * Options for running tests.\n */\nexport interface TestOptions {\n  /**\n   * Further vitest CLI arguments, appended after the wrapper's own: file filters, `-t`, `--maxWorkers`, `--reporter`.\n   * An argument naming an option the wrapper sets itself (`--project`, `--coverage*`, `--run`, `--watch`) throws.\n   */\n  readonly additionalArguments?: readonly string[];\n\n  /**\n   * The projects to run.\n   */\n  readonly projects?: string[];\n}\n\n/**\n * Options for running tests in watch mode.\n */\nexport type TestWatchOptions = TestOptions;\n\n/**\n * Runs the test suite.\n *\n * @param options - The options for the test.\n * @returns A {@link Promise} that resolves when the tests have completed.\n */\nexport async function test(options: TestOptions = {}): Promise<void> {\n  await execFromRoot(['vitest', 'run', ...buildProjectFlags(options.projects), ...getAdditionalArguments(options)], {\n    env: await getWorkerEnvironment(options)\n  });\n}\n\n/**\n * Runs the test suite with coverage.\n *\n * @param options - Optional coverage configuration.\n * @returns A {@link Promise} that resolves when the tests have completed.\n */\nexport async function testCoverage(options: TestCoverageOptions = {}): Promise<void> {\n  const threshold = String(options.minCoverageInPercents ?? 0);\n  await execFromRoot([\n    'vitest',\n    'run',\n    ...buildProjectFlags(options.projects),\n    '--coverage',\n    `--coverage.thresholds.lines=${threshold}`,\n    `--coverage.thresholds.functions=${threshold}`,\n    `--coverage.thresholds.branches=${threshold}`,\n    `--coverage.thresholds.statements=${threshold}`,\n    ...getAdditionalArguments(options)\n  ], { env: await getWorkerEnvironment(options) });\n}\n\n/**\n * Runs the test suite in watch mode.\n *\n * @param options - The options for the test.\n * @returns A {@link Promise} that resolves when the tests have completed.\n */\nexport async function testWatch(options: TestWatchOptions = {}): Promise<void> {\n  await execFromRoot(['vitest', ...buildProjectFlags(options.projects), ...getAdditionalArguments(options)], {\n    env: await getWorkerEnvironment(options, true)\n  });\n}\n\n/**\n * Builds `--project` flags for the given project prefixes.\n * Each prefix expands to both `--project=prefix` (exact match)\n * and `--project=prefix:*` (sub-projects).\n *\n * @param projects - The project name prefixes.\n * @returns The `--project` flags array.\n */\nfunction buildProjectFlags(projects?: string[]): string[] {\n  return (projects ?? []).flatMap((project) => [`--project=${project}`, `--project=${project}:*`]);\n}\n\n/**\n * Checks the forwarded arguments against the options the wrappers set themselves.\n *\n * @param options - The options for the test.\n * @returns The forwarded arguments.\n */\nfunction getAdditionalArguments(options: TestOptions): readonly string[] {\n  const { additionalArguments = [] } = options;\n  assertNoOwnedArguments({ forwardedArguments: additionalArguments, ownedOptions: OWNED_OPTIONS, runnerName: 'vitest' });\n  return additionalArguments;\n}\n\n/**\n * Resolves the bulk cap without letting Vitest's environment override hide narrower project limits.\n * The narrowest limit applies to the whole invocation because CLI and environment limits replace project limits.\n *\n * @param options - The selected test projects.\n * @param isWatch - Whether this invocation watches for changes.\n * @returns Child environment overrides, empty outside bulk work.\n */\nasync function getWorkerEnvironment(options: TestOptions, isWatch = false): Promise<NodeJS.ProcessEnv> {\n  const next = workerEnvironmentQueue.pending.then(() => resolveWorkerEnvironment(options, isWatch));\n  workerEnvironmentQueue.pending = next.catch(() => undefined);\n  return next;\n}\n\n/**\n * Resolves one invocation's worker environment while holding the configuration-resolution queue.\n *\n * @param options - The selected test projects.\n * @param isWatch - Whether this invocation watches for changes.\n * @returns Child environment overrides.\n */\nasync function resolveWorkerEnvironment(options: TestOptions, isWatch: boolean): Promise<NodeJS.ProcessEnv> {\n  const budget = getBulkConcurrency(Infinity);\n  if (!Number.isFinite(budget)) {\n    return {};\n  }\n\n  // Optional peer: leave loading Vitest to the CLI outside bulk work.\n  const { resolveConfig } = await import('vitest/node');\n  const inheritedWorkers = process.env['VITEST_MAX_WORKERS'];\n  delete process.env['VITEST_MAX_WORKERS'];\n  let config;\n  try {\n    config = await resolveConfig({\n      project: (options.projects ?? []).flatMap((project) => [project, `${project}:*`]),\n      root: resolvePathFromRootSafe({ path: '.' }),\n      watch: isWatch\n    });\n  } finally {\n    if (inheritedWorkers !== undefined) {\n      // eslint-disable-next-line require-atomic-updates -- Worker environment resolutions are serialized; restore the inherited value before the next invocation reads it.\n      process.env['VITEST_MAX_WORKERS'] = inheritedWorkers;\n    }\n  }\n\n  const ordinaryWorkers = Math.max(isWatch ? Math.floor(availableParallelism() / WATCH_WORKER_DIVISOR) : availableParallelism() - 1, 1);\n  const inheritedLimit = Number.parseInt(inheritedWorkers ?? '', 10);\n  let workers = Math.min(budget, ordinaryWorkers);\n  if (Number.isSafeInteger(inheritedLimit) && inheritedLimit > 0) {\n    workers = Math.min(workers, inheritedLimit);\n  }\n\n  const configs = [config.test, ...config.test.resolvedProjects.filter((entry) => !entry.hidden).map((entry) => entry.projectConfig)];\n  for (const testConfig of configs) {\n    if (testConfig.maxWorkers) {\n      workers = Math.min(workers, testConfig.maxWorkers);\n    }\n  }\n\n  return { VITEST_MAX_WORKERS: String(workers) };\n}\n"],"mappings":"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","names":[]}