@mnaoumov/typescript-dev-toolkit 3.10.0 → 3.11.0

package/dist/lib/esm/commitlint-config.d.mts

@@ -8,8 +8,8 @@ import type { UserConfig } from '@commitlint/types';
 /**
  * Commitlint configuration extending `@commitlint/config-conventional`, plus a rule refusing a message whose
  * header, body or footer matches the unpublished forbidden-patterns list (a no-op when none is configured), and
- * a rule spellchecking the header the way the release spellchecks the changelog bullet it becomes (a no-op in a
- * project with no `spellcheck` script).
+ * two rules checking the header the way the release checks the changelog bullet it becomes: a spellcheck (a no-op
+ * in a project with no `spellcheck` script) and a markdownlint (a no-op in a project with no `lint:md` script).
  */
 export declare const commitlintConfig: UserConfig;
 /**

package/dist/lib/esm/commitlint-config.mjs

@@ -42,6 +42,10 @@ import {
   forbiddenPatternsPlugin,
   NO_FORBIDDEN_PATTERNS_RULE_NAME
 } from "./commitlint-forbidden-patterns.mjs";
+import {
+  LINT_MD_HEADER_RULE_NAME,
+  lintMdHeaderPlugin
+} from "./commitlint-lint-md-header.mjs";
 import {
   SPELLCHECK_HEADER_RULE_NAME,
   spellcheckHeaderPlugin
@@ -57,11 +61,13 @@ const commitlintConfig = {
     {
       rules: {
         ...forbiddenPatternsPlugin.rules,
+        ...lintMdHeaderPlugin.rules,
         ...spellcheckHeaderPlugin.rules
       }
     }
   ],
   rules: {
+    [LINT_MD_HEADER_RULE_NAME]: [ERROR_SEVERITY, "always"],
     [NO_FORBIDDEN_PATTERNS_RULE_NAME]: [ERROR_SEVERITY, "always"],
     [SPELLCHECK_HEADER_RULE_NAME]: [ERROR_SEVERITY, "always"]
   }
@@ -71,4 +77,4 @@ export {
   commitlintConfig,
   obsidianDevUtilsConfig
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/commitlint-lint-md-header.d.mts

@@ -0,0 +1,40 @@
+/// <reference path="./library-references.d.mts" />
+/**
+ * @file
+ *
+ * A commitlint rule that lints a commit HEADER with the project's own `lint:md` configuration.
+ *
+ * The header is the one part of a commit message that ships verbatim: a release turns every commit subject
+ * since the last tag into a `- <subject>` bullet of the new `CHANGELOG.md` section, and lints that section with
+ * `lint:md` before writing it. That check runs at release time, after the whole preflight gate, and weeks after
+ * the subject was pushed: a release once passed its 25-minute preflight and was then refused because a custom
+ * rule flagged a plugin name in a pushed `docs(readme):` subject. A pushed subject cannot be changed, so the
+ * release had to be re-run with hand-written notes. The commit-msg hook is the last point at which the subject
+ * can still be changed for free.
+ *
+ * The header is checked AS the section the release would build from it, attributed to `CHANGELOG.md`, so the
+ * verdict is the one the release would give: the same configuration, the same custom rules, and bare URLs
+ * autolinked the way the release autolinks them. It runs only where the project defines a `lint:md` script,
+ * which is the condition the release applies too.
+ */
+import type { AsyncRule, Plugin, RuleOutcome } from '@commitlint/types';
+/**
+ * The name the rule is registered under.
+ */
+export declare const LINT_MD_HEADER_RULE_NAME = "typescript-dev-toolkit/lint-md-header";
+type Commit = Parameters<AsyncRule>[0];
+/**
+ * Lints the commit header as the changelog section the release would build from it.
+ *
+ * Only the `always` condition is meaningful: `never` would require the header to fail `lint:md`, so it is
+ * treated the same way rather than inverted.
+ *
+ * @param commit - The parsed commit.
+ * @returns A {@link Promise} that resolves to the rule outcome, naming each finding.
+ */
+export declare function lintMdHeaderRule(commit: Commit): Promise<RuleOutcome>;
+/**
+ * The commitlint plugin carrying {@link lintMdHeaderRule}.
+ */
+export declare const lintMdHeaderPlugin: Plugin;
+export {};

package/dist/lib/esm/commitlint-lint-md-header.mjs

@@ -0,0 +1,52 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+import { lintMarkdownContent } from "./linters/markdownlint-content.mjs";
+import { readPackageJson } from "./npm.mjs";
+import { RepoPaths } from "./repo-paths.mjs";
+import { resolvePathFromRootSafe } from "./root.mjs";
+import { autolinkBareUrls } from "./version.mjs";
+const LINT_MD_HEADER_RULE_NAME = "typescript-dev-toolkit/lint-md-header";
+const LINT_MD_SCRIPT_NAME = "lint:md";
+const FALLBACK_VERSION = "0.0.0";
+async function lintMdHeaderRule(commit) {
+  if (!commit.header) {
+    return [true];
+  }
+  const packageJson = await readPackageJson();
+  if (!Object.keys(packageJson.scripts ?? {}).includes(LINT_MD_SCRIPT_NAME)) {
+    return [true];
+  }
+  const version = packageJson.version ?? FALLBACK_VERSION;
+  const findings = await lintMarkdownContent({
+    content: `# CHANGELOG
+
+## ${version}
+
+- ${autolinkBareUrls(commit.header)}
+`,
+    filePath: resolvePathFromRootSafe({ path: RepoPaths.ChangelogMd })
+  });
+  if (findings.length === 0) {
+    return [true];
+  }
+  return [
+    false,
+    `the header does not pass \`${LINT_MD_SCRIPT_NAME}\`, and it ships verbatim into the next release's changelog:
+${findings.join("\n")}
+Reword it so the changelog bullet it becomes passes the project's markdownlint configuration.`
+  ];
+}
+const lintMdHeaderPlugin = {
+  rules: {
+    [LINT_MD_HEADER_RULE_NAME]: lintMdHeaderRule
+  }
+};
+export {
+  LINT_MD_HEADER_RULE_NAME,
+  lintMdHeaderPlugin,
+  lintMdHeaderRule
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2NvbW1pdGxpbnQtbGludC1tZC1oZWFkZXIudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQGZpbGVcbiAqXG4gKiBBIGNvbW1pdGxpbnQgcnVsZSB0aGF0IGxpbnRzIGEgY29tbWl0IEhFQURFUiB3aXRoIHRoZSBwcm9qZWN0J3Mgb3duIGBsaW50Om1kYCBjb25maWd1cmF0aW9uLlxuICpcbiAqIFRoZSBoZWFkZXIgaXMgdGhlIG9uZSBwYXJ0IG9mIGEgY29tbWl0IG1lc3NhZ2UgdGhhdCBzaGlwcyB2ZXJiYXRpbTogYSByZWxlYXNlIHR1cm5zIGV2ZXJ5IGNvbW1pdCBzdWJqZWN0XG4gKiBzaW5jZSB0aGUgbGFzdCB0YWcgaW50byBhIGAtIDxzdWJqZWN0PmAgYnVsbGV0IG9mIHRoZSBuZXcgYENIQU5HRUxPRy5tZGAgc2VjdGlvbiwgYW5kIGxpbnRzIHRoYXQgc2VjdGlvbiB3aXRoXG4gKiBgbGludDptZGAgYmVmb3JlIHdyaXRpbmcgaXQuIFRoYXQgY2hlY2sgcnVucyBhdCByZWxlYXNlIHRpbWUsIGFmdGVyIHRoZSB3aG9sZSBwcmVmbGlnaHQgZ2F0ZSwgYW5kIHdlZWtzIGFmdGVyXG4gKiB0aGUgc3ViamVjdCB3YXMgcHVzaGVkOiBhIHJlbGVhc2Ugb25jZSBwYXNzZWQgaXRzIDI1LW1pbnV0ZSBwcmVmbGlnaHQgYW5kIHdhcyB0aGVuIHJlZnVzZWQgYmVjYXVzZSBhIGN1c3RvbVxuICogcnVsZSBmbGFnZ2VkIGEgcGx1Z2luIG5hbWUgaW4gYSBwdXNoZWQgYGRvY3MocmVhZG1lKTpgIHN1YmplY3QuIEEgcHVzaGVkIHN1YmplY3QgY2Fubm90IGJlIGNoYW5nZWQsIHNvIHRoZVxuICogcmVsZWFzZSBoYWQgdG8gYmUgcmUtcnVuIHdpdGggaGFuZC13cml0dGVuIG5vdGVzLiBUaGUgY29tbWl0LW1zZyBob29rIGlzIHRoZSBsYXN0IHBvaW50IGF0IHdoaWNoIHRoZSBzdWJqZWN0XG4gKiBjYW4gc3RpbGwgYmUgY2hhbmdlZCBmb3IgZnJlZS5cbiAqXG4gKiBUaGUgaGVhZGVyIGlzIGNoZWNrZWQgQVMgdGhlIHNlY3Rpb24gdGhlIHJlbGVhc2Ugd291bGQgYnVpbGQgZnJvbSBpdCwgYXR0cmlidXRlZCB0byBgQ0hBTkdFTE9HLm1kYCwgc28gdGhlXG4gKiB2ZXJkaWN0IGlzIHRoZSBvbmUgdGhlIHJlbGVhc2Ugd291bGQgZ2l2ZTogdGhlIHNhbWUgY29uZmlndXJhdGlvbiwgdGhlIHNhbWUgY3VzdG9tIHJ1bGVzLCBhbmQgYmFyZSBVUkxzXG4gKiBhdXRvbGlua2VkIHRoZSB3YXkgdGhlIHJlbGVhc2UgYXV0b2xpbmtzIHRoZW0uIEl0IHJ1bnMgb25seSB3aGVyZSB0aGUgcHJvamVjdCBkZWZpbmVzIGEgYGxpbnQ6bWRgIHNjcmlwdCxcbiAqIHdoaWNoIGlzIHRoZSBjb25kaXRpb24gdGhlIHJlbGVhc2UgYXBwbGllcyB0b28uXG4gKi9cblxuaW1wb3J0IHR5cGUge1xuICBBc3luY1J1bGUsXG4gIFBsdWdpbixcbiAgUnVsZU91dGNvbWVcbn0gZnJvbSAnQGNvbW1pdGxpbnQvdHlwZXMnO1xuXG5pbXBvcnQgeyBsaW50TWFya2Rvd25Db250ZW50IH0gZnJvbSAnLi9saW50ZXJzL21hcmtkb3dubGludC1jb250ZW50LnRzJztcbmltcG9ydCB7IHJlYWRQYWNrYWdlSnNvbiB9IGZyb20gJy4vbnBtLnRzJztcbmltcG9ydCB7IFJlcG9QYXRocyB9IGZyb20gJy4vcmVwby1wYXRocy50cyc7XG5pbXBvcnQgeyByZXNvbHZlUGF0aEZyb21Sb290U2FmZSB9IGZyb20gJy4vcm9vdC50cyc7XG5pbXBvcnQgeyBhdXRvbGlua0JhcmVVcmxzIH0gZnJvbSAnLi92ZXJzaW9uLnRzJztcblxuLyoqXG4gKiBUaGUgbmFtZSB0aGUgcnVsZSBpcyByZWdpc3RlcmVkIHVuZGVyLlxuICovXG5leHBvcnQgY29uc3QgTElOVF9NRF9IRUFERVJfUlVMRV9OQU1FID0gJ3R5cGVzY3JpcHQtZGV2LXRvb2xraXQvbGludC1tZC1oZWFkZXInO1xuXG4vKipcbiAqIFRoZSBucG0gc2NyaXB0IHdob3NlIHByZXNlbmNlIG9wdHMgYSBwcm9qZWN0IGludG8gdGhlIGNoZWNrLlxuICovXG5jb25zdCBMSU5UX01EX1NDUklQVF9OQU1FID0gJ2xpbnQ6bWQnO1xuXG4vKipcbiAqIFRoZSB2ZXJzaW9uIHRoZSBzZWN0aW9uIGhlYWRpbmcgbmFtZXMgd2hlbiBgcGFja2FnZS5qc29uYCBoYXMgbm9uZS4gTWFya2Rvd25saW50IHJlYWRzIGl0IGFzIGFueSBoZWFkaW5nIHRleHQuXG4gKi9cbmNvbnN0IEZBTExCQUNLX1ZFUlNJT04gPSAnMC4wLjAnO1xuXG50eXBlIENvbW1pdCA9IFBhcmFtZXRlcnM8QXN5bmNSdWxlPlswXTtcblxuLyoqXG4gKiBMaW50cyB0aGUgY29tbWl0IGhlYWRlciBhcyB0aGUgY2hhbmdlbG9nIHNlY3Rpb24gdGhlIHJlbGVhc2Ugd291bGQgYnVpbGQgZnJvbSBpdC5cbiAqXG4gKiBPbmx5IHRoZSBgYWx3YXlzYCBjb25kaXRpb24gaXMgbWVhbmluZ2Z1bDogYG5ldmVyYCB3b3VsZCByZXF1aXJlIHRoZSBoZWFkZXIgdG8gZmFpbCBgbGludDptZGAsIHNvIGl0IGlzXG4gKiB0cmVhdGVkIHRoZSBzYW1lIHdheSByYXRoZXIgdGhhbiBpbnZlcnRlZC5cbiAqXG4gKiBAcGFyYW0gY29tbWl0IC0gVGhlIHBhcnNlZCBjb21taXQuXG4gKiBAcmV0dXJucyBBIHtAbGluayBQcm9taXNlfSB0aGF0IHJlc29sdmVzIHRvIHRoZSBydWxlIG91dGNvbWUsIG5hbWluZyBlYWNoIGZpbmRpbmcuXG4gKi9cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBsaW50TWRIZWFkZXJSdWxlKGNvbW1pdDogQ29tbWl0KTogUHJvbWlzZTxSdWxlT3V0Y29tZT4ge1xuICBpZiAoIWNvbW1pdC5oZWFkZXIpIHtcbiAgICByZXR1cm4gW3RydWVdO1xuICB9XG5cbiAgY29uc3QgcGFja2FnZUpzb24gPSBhd2FpdCByZWFkUGFja2FnZUpzb24oKTtcbiAgaWYgKCFPYmplY3Qua2V5cyhwYWNrYWdlSnNvbi5zY3JpcHRzID8/IHt9KS5pbmNsdWRlcyhMSU5UX01EX1NDUklQVF9OQU1FKSkge1xuICAgIHJldHVybiBbdHJ1ZV07XG4gIH1cblxuICBjb25zdCB2ZXJzaW9uID0gcGFja2FnZUpzb24udmVyc2lvbiA/PyBGQUxMQkFDS19WRVJTSU9OO1xuICBjb25zdCBmaW5kaW5ncyA9IGF3YWl0IGxpbnRNYXJrZG93bkNvbnRlbnQoe1xuICAgIGNvbnRlbnQ6IGAjIENIQU5HRUxPR1xcblxcbiMjICR7dmVyc2lvbn1cXG5cXG4tICR7YXV0b2xpbmtCYXJlVXJscyhjb21taXQuaGVhZGVyKX1cXG5gLFxuICAgIGZpbGVQYXRoOiByZXNvbHZlUGF0aEZyb21Sb290U2FmZSh7IHBhdGg6IFJlcG9QYXRocy5DaGFuZ2Vsb2dNZCB9KVxuICB9KTtcblxuICBpZiAoZmluZGluZ3MubGVuZ3RoID09PSAwKSB7XG4gICAgcmV0dXJuIFt0cnVlXTtcbiAgfVxuXG4gIHJldHVybiBbXG4gICAgZmFsc2UsXG4gICAgYHRoZSBoZWFkZXIgZG9lcyBub3QgcGFzcyBcXGAke0xJTlRfTURfU0NSSVBUX05BTUV9XFxgLCBhbmQgaXQgc2hpcHMgdmVyYmF0aW0gaW50byB0aGUgbmV4dCByZWxlYXNlJ3MgY2hhbmdlbG9nOlxcbmBcbiAgICArIGAke2ZpbmRpbmdzLmpvaW4oJ1xcbicpfVxcbmBcbiAgICArICdSZXdvcmQgaXQgc28gdGhlIGNoYW5nZWxvZyBidWxsZXQgaXQgYmVjb21lcyBwYXNzZXMgdGhlIHByb2plY3RcXCdzIG1hcmtkb3dubGludCBjb25maWd1cmF0aW9uLidcbiAgXTtcbn1cblxuLyoqXG4gKiBUaGUgY29tbWl0bGludCBwbHVnaW4gY2Fycnlpbmcge0BsaW5rIGxpbnRNZEhlYWRlclJ1bGV9LlxuICovXG5leHBvcnQgY29uc3QgbGludE1kSGVhZGVyUGx1Z2luOiBQbHVnaW4gPSB7XG4gIHJ1bGVzOiB7XG4gICAgW0xJTlRfTURfSEVBREVSX1JVTEVfTkFNRV06IGxpbnRNZEhlYWRlclJ1bGVcbiAgfVxufTtcbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7O0FBeUJBLFNBQVMsMkJBQTJCO0FBQ3BDLFNBQVMsdUJBQXVCO0FBQ2hDLFNBQVMsaUJBQWlCO0FBQzFCLFNBQVMsK0JBQStCO0FBQ3hDLFNBQVMsd0JBQXdCO0FBSzFCLE1BQU0sMkJBQTJCO0FBS3hDLE1BQU0sc0JBQXNCO0FBSzVCLE1BQU0sbUJBQW1CO0FBYXpCLGVBQXNCLGlCQUFpQixRQUFzQztBQUMzRSxNQUFJLENBQUMsT0FBTyxRQUFRO0FBQ2xCLFdBQU8sQ0FBQyxJQUFJO0FBQUEsRUFDZDtBQUVBLFFBQU0sY0FBYyxNQUFNLGdCQUFnQjtBQUMxQyxNQUFJLENBQUMsT0FBTyxLQUFLLFlBQVksV0FBVyxDQUFDLENBQUMsRUFBRSxTQUFTLG1CQUFtQixHQUFHO0FBQ3pFLFdBQU8sQ0FBQyxJQUFJO0FBQUEsRUFDZDtBQUVBLFFBQU0sVUFBVSxZQUFZLFdBQVc7QUFDdkMsUUFBTSxXQUFXLE1BQU0sb0JBQW9CO0FBQUEsSUFDekMsU0FBUztBQUFBO0FBQUEsS0FBcUIsT0FBTztBQUFBO0FBQUEsSUFBUyxpQkFBaUIsT0FBTyxNQUFNLENBQUM7QUFBQTtBQUFBLElBQzdFLFVBQVUsd0JBQXdCLEVBQUUsTUFBTSxVQUFVLFlBQVksQ0FBQztBQUFBLEVBQ25FLENBQUM7QUFFRCxNQUFJLFNBQVMsV0FBVyxHQUFHO0FBQ3pCLFdBQU8sQ0FBQyxJQUFJO0FBQUEsRUFDZDtBQUVBLFNBQU87QUFBQSxJQUNMO0FBQUEsSUFDQSw4QkFBOEIsbUJBQW1CO0FBQUEsRUFDNUMsU0FBUyxLQUFLLElBQUksQ0FBQztBQUFBO0FBQUEsRUFFMUI7QUFDRjtBQUtPLE1BQU0scUJBQTZCO0FBQUEsRUFDeEMsT0FBTztBQUFBLElBQ0wsQ0FBQyx3QkFBd0IsR0FBRztBQUFBLEVBQzlCO0FBQ0Y7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist/lib/esm/index.d.mts

@@ -10,6 +10,7 @@ export * as 'cli-utils' from './cli-utils.mjs';
 export * as 'code-generator' from './code-generator.mjs';
 export * as 'commitlint-config' from './commitlint-config.mjs';
 export * as 'commitlint-forbidden-patterns' from './commitlint-forbidden-patterns.mjs';
+export * as 'commitlint-lint-md-header' from './commitlint-lint-md-header.mjs';
 export * as 'commitlint-spellcheck-header' from './commitlint-spellcheck-header.mjs';
 export * as 'docs-site' from './docs-site/index.mjs';
 export * as 'env-toggle' from './env-toggle.mjs';

package/dist/lib/esm/index.mjs

@@ -10,6 +10,7 @@ import * as cli_utils from "./cli-utils.mjs";
 import * as code_generator from "./code-generator.mjs";
 import * as commitlint_config from "./commitlint-config.mjs";
 import * as commitlint_forbidden_patterns from "./commitlint-forbidden-patterns.mjs";
+import * as commitlint_lint_md_header from "./commitlint-lint-md-header.mjs";
 import * as commitlint_spellcheck_header from "./commitlint-spellcheck-header.mjs";
 import * as docs_site from "./docs-site/index.mjs";
 import * as env_toggle from "./env-toggle.mjs";
@@ -46,6 +47,7 @@ export {
   code_generator as "code-generator",
   commitlint_config as "commitlint-config",
   commitlint_forbidden_patterns as "commitlint-forbidden-patterns",
+  commitlint_lint_md_header as "commitlint-lint-md-header",
   commitlint_spellcheck_header as "commitlint-spellcheck-header",
   docs_site as "docs-site",
   env_toggle as "env-toggle",
@@ -75,4 +77,4 @@ export {
   validate_dependencies as "validate-dependencies",
   version
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -2,5 +2,7 @@
 export * as 'auto' from './auto.mjs';
 export * as 'jest-config' from './jest-config.mjs';
 export * as 'jest' from './jest.mjs';
+export * as 'stryker-config' from './stryker-config.mjs';
+export * as 'stryker' from './stryker.mjs';
 export * as 'vitest-config' from './vitest-config.mjs';
 export * as 'vitest' from './vitest.mjs';

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

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

package/dist/lib/esm/test-runners/stryker-config.d.mts

@@ -0,0 +1,60 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * The shared Stryker configuration for an on-demand mutation run ({@link defineStrykerConfig}), and the test list the
+ * mutation run's vitest configuration reads ({@link getStrykerTestInclude}).
+ *
+ * The module imports nothing but `node:process` and holds no TypeScript syntax Node cannot strip, so a repository
+ * that cannot install this package (this one) loads it straight from its `stryker.config.mjs`.
+ */
+/**
+ * The environment variable `testMutation` hands the scoped run's test files in, comma-separated.
+ */
+export declare const STRYKER_TEST_FILES_ENV_VARIABLE = "STRYKER_TEST_FILES";
+/**
+ * The vitest configuration file the mutation run reads, beside the project's own `vitest.config.*`.
+ */
+export declare const STRYKER_VITEST_CONFIG_FILE_NAME = "vitest.stryker.config.ts";
+/**
+ * The files mutated by a run that names none: every source file but the tests, the declarations, the generated
+ * barrels and the test helpers.
+ */
+export declare const DEFAULT_STRYKER_MUTATE: readonly string[];
+/**
+ * The folders Stryker never reads. A documentation site's `docs/` alone held 18,000 files in the pilot: copying it
+ * took 5 minutes, and then the main process died of a 4 GB heap OOM.
+ */
+export declare const DEFAULT_STRYKER_IGNORE_PATTERNS: readonly string[];
+/**
+ * A Stryker configuration object, as a `stryker.config.mjs` exports it.
+ *
+ * Kept loose rather than typed by `@stryker-mutator/api`, so a consumer that never runs Stryker never needs its
+ * types.
+ */
+export type StrykerConfig = Record<string, unknown>;
+/**
+ * Defines the Stryker configuration of an on-demand mutation run.
+ *
+ * The defaults encode what the pilot measured:
+ *
+ * - `inPlace: true`, because Stryker's sandbox copy breaks module resolution through a symlinked `node_modules`. In
+ *   place, Stryker mutates the tree itself and puts back the WHOLE tree as it was when the run started, so the run
+ *   needs a committed tree and nobody may edit it while the run is going.
+ * - `vitest.related: false`, because `vitest.related` found no tests at all; the scoped run names its test files
+ *   through {@link getStrykerTestInclude} instead.
+ * - `ignorePatterns`, see {@link DEFAULT_STRYKER_IGNORE_PATTERNS}.
+ *
+ * @param overrides - Keys that replace the defaults. The merge is shallow: an override of `vitest` replaces the
+ *   whole `vitest` object.
+ * @returns The configuration to export from `stryker.config.mjs`.
+ */
+export declare function defineStrykerConfig(overrides?: StrykerConfig): StrykerConfig;
+/**
+ * Picks the test files of the mutation run's vitest configuration: the ones `testMutation` named for a scoped run, or
+ * the given defaults for a full one.
+ *
+ * @param defaultInclude - The `include` globs of a full run.
+ * @returns The `include` list.
+ */
+export declare function getStrykerTestInclude(defaultInclude: readonly string[]): string[];

package/dist/lib/esm/test-runners/stryker-config.mjs

@@ -0,0 +1,63 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+import process from "node:process";
+const DEFAULT_CONCURRENCY = 4;
+const DEFAULT_TIMEOUT_IN_MILLISECONDS = 1e4;
+const STRYKER_TEST_FILES_ENV_VARIABLE = "STRYKER_TEST_FILES";
+const STRYKER_VITEST_CONFIG_FILE_NAME = "vitest.stryker.config.ts";
+const DEFAULT_STRYKER_MUTATE = [
+  "src/**/*.ts",
+  "!src/**/*.test.ts",
+  "!src/**/*.d.ts",
+  "!src/**/index.ts",
+  "!src/__merged.ts",
+  "!src/test-helpers/**",
+  "!src/**/@types/**"
+];
+const DEFAULT_STRYKER_IGNORE_PATTERNS = [
+  "/.astro",
+  "/.claude",
+  "/.codex",
+  "/coverage",
+  "/dist",
+  "/docs",
+  "/reports"
+];
+function defineStrykerConfig(overrides = {}) {
+  return {
+    checkers: [],
+    concurrency: DEFAULT_CONCURRENCY,
+    coverageAnalysis: "perTest",
+    htmlReporter: { fileName: "reports/mutation/mutation.html" },
+    ignorePatterns: [...DEFAULT_STRYKER_IGNORE_PATTERNS],
+    inPlace: true,
+    jsonReporter: { fileName: "reports/mutation/mutation.json" },
+    mutate: [...DEFAULT_STRYKER_MUTATE],
+    reporters: ["clear-text", "progress-append-only", "json", "html"],
+    // eslint-disable-next-line unicorn/name-replacements -- `tempDirName` is a Stryker option.
+    tempDirName: ".stryker-tmp",
+    testRunner: "vitest",
+    timeoutMS: DEFAULT_TIMEOUT_IN_MILLISECONDS,
+    vitest: {
+      configFile: STRYKER_VITEST_CONFIG_FILE_NAME,
+      related: false
+    },
+    ...overrides
+  };
+}
+function getStrykerTestInclude(defaultInclude) {
+  const testFiles = process.env[STRYKER_TEST_FILES_ENV_VARIABLE];
+  return testFiles ? testFiles.split(",") : [...defaultInclude];
+}
+export {
+  DEFAULT_STRYKER_IGNORE_PATTERNS,
+  DEFAULT_STRYKER_MUTATE,
+  STRYKER_TEST_FILES_ENV_VARIABLE,
+  STRYKER_VITEST_CONFIG_FILE_NAME,
+  defineStrykerConfig,
+  getStrykerTestInclude
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL3Rlc3QtcnVubmVycy9zdHJ5a2VyLWNvbmZpZy50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAZmlsZVxuICpcbiAqIFRoZSBzaGFyZWQgU3RyeWtlciBjb25maWd1cmF0aW9uIGZvciBhbiBvbi1kZW1hbmQgbXV0YXRpb24gcnVuICh7QGxpbmsgZGVmaW5lU3RyeWtlckNvbmZpZ30pLCBhbmQgdGhlIHRlc3QgbGlzdCB0aGVcbiAqIG11dGF0aW9uIHJ1bidzIHZpdGVzdCBjb25maWd1cmF0aW9uIHJlYWRzICh7QGxpbmsgZ2V0U3RyeWtlclRlc3RJbmNsdWRlfSkuXG4gKlxuICogVGhlIG1vZHVsZSBpbXBvcnRzIG5vdGhpbmcgYnV0IGBub2RlOnByb2Nlc3NgIGFuZCBob2xkcyBubyBUeXBlU2NyaXB0IHN5bnRheCBOb2RlIGNhbm5vdCBzdHJpcCwgc28gYSByZXBvc2l0b3J5XG4gKiB0aGF0IGNhbm5vdCBpbnN0YWxsIHRoaXMgcGFja2FnZSAodGhpcyBvbmUpIGxvYWRzIGl0IHN0cmFpZ2h0IGZyb20gaXRzIGBzdHJ5a2VyLmNvbmZpZy5tanNgLlxuICovXG5cbmltcG9ydCBwcm9jZXNzIGZyb20gJ25vZGU6cHJvY2Vzcyc7XG5cbmNvbnN0IERFRkFVTFRfQ09OQ1VSUkVOQ1kgPSA0O1xuY29uc3QgREVGQVVMVF9USU1FT1VUX0lOX01JTExJU0VDT05EUyA9IDEwXzAwMDtcblxuLyoqXG4gKiBUaGUgZW52aXJvbm1lbnQgdmFyaWFibGUgYHRlc3RNdXRhdGlvbmAgaGFuZHMgdGhlIHNjb3BlZCBydW4ncyB0ZXN0IGZpbGVzIGluLCBjb21tYS1zZXBhcmF0ZWQuXG4gKi9cbmV4cG9ydCBjb25zdCBTVFJZS0VSX1RFU1RfRklMRVNfRU5WX1ZBUklBQkxFID0gJ1NUUllLRVJfVEVTVF9GSUxFUyc7XG5cbi8qKlxuICogVGhlIHZpdGVzdCBjb25maWd1cmF0aW9uIGZpbGUgdGhlIG11dGF0aW9uIHJ1biByZWFkcywgYmVzaWRlIHRoZSBwcm9qZWN0J3Mgb3duIGB2aXRlc3QuY29uZmlnLipgLlxuICovXG5leHBvcnQgY29uc3QgU1RSWUtFUl9WSVRFU1RfQ09ORklHX0ZJTEVfTkFNRSA9ICd2aXRlc3Quc3RyeWtlci5jb25maWcudHMnO1xuXG4vKipcbiAqIFRoZSBmaWxlcyBtdXRhdGVkIGJ5IGEgcnVuIHRoYXQgbmFtZXMgbm9uZTogZXZlcnkgc291cmNlIGZpbGUgYnV0IHRoZSB0ZXN0cywgdGhlIGRlY2xhcmF0aW9ucywgdGhlIGdlbmVyYXRlZFxuICogYmFycmVscyBhbmQgdGhlIHRlc3QgaGVscGVycy5cbiAqL1xuZXhwb3J0IGNvbnN0IERFRkFVTFRfU1RSWUtFUl9NVVRBVEU6IHJlYWRvbmx5IHN0cmluZ1tdID0gW1xuICAnc3JjLyoqLyoudHMnLFxuICAnIXNyYy8qKi8qLnRlc3QudHMnLFxuICAnIXNyYy8qKi8qLmQudHMnLFxuICAnIXNyYy8qKi9pbmRleC50cycsXG4gICchc3JjL19fbWVyZ2VkLnRzJyxcbiAgJyFzcmMvdGVzdC1oZWxwZXJzLyoqJyxcbiAgJyFzcmMvKiovQHR5cGVzLyoqJ1xuXTtcblxuLyoqXG4gKiBUaGUgZm9sZGVycyBTdHJ5a2VyIG5ldmVyIHJlYWRzLiBBIGRvY3VtZW50YXRpb24gc2l0ZSdzIGBkb2NzL2AgYWxvbmUgaGVsZCAxOCwwMDAgZmlsZXMgaW4gdGhlIHBpbG90OiBjb3B5aW5nIGl0XG4gKiB0b29rIDUgbWludXRlcywgYW5kIHRoZW4gdGhlIG1haW4gcHJvY2VzcyBkaWVkIG9mIGEgNCBHQiBoZWFwIE9PTS5cbiAqL1xuZXhwb3J0IGNvbnN0IERFRkFVTFRfU1RSWUtFUl9JR05PUkVfUEFUVEVSTlM6IHJlYWRvbmx5IHN0cmluZ1tdID0gW1xuICAnLy5hc3RybycsXG4gICcvLmNsYXVkZScsXG4gICcvLmNvZGV4JyxcbiAgJy9jb3ZlcmFnZScsXG4gICcvZGlzdCcsXG4gICcvZG9jcycsXG4gICcvcmVwb3J0cydcbl07XG5cbi8qKlxuICogQSBTdHJ5a2VyIGNvbmZpZ3VyYXRpb24gb2JqZWN0LCBhcyBhIGBzdHJ5a2VyLmNvbmZpZy5tanNgIGV4cG9ydHMgaXQuXG4gKlxuICogS2VwdCBsb29zZSByYXRoZXIgdGhhbiB0eXBlZCBieSBgQHN0cnlrZXItbXV0YXRvci9hcGlgLCBzbyBhIGNvbnN1bWVyIHRoYXQgbmV2ZXIgcnVucyBTdHJ5a2VyIG5ldmVyIG5lZWRzIGl0c1xuICogdHlwZXMuXG4gKi9cbmV4cG9ydCB0eXBlIFN0cnlrZXJDb25maWcgPSBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPjtcblxuLyoqXG4gKiBEZWZpbmVzIHRoZSBTdHJ5a2VyIGNvbmZpZ3VyYXRpb24gb2YgYW4gb24tZGVtYW5kIG11dGF0aW9uIHJ1bi5cbiAqXG4gKiBUaGUgZGVmYXVsdHMgZW5jb2RlIHdoYXQgdGhlIHBpbG90IG1lYXN1cmVkOlxuICpcbiAqIC0gYGluUGxhY2U6IHRydWVgLCBiZWNhdXNlIFN0cnlrZXIncyBzYW5kYm94IGNvcHkgYnJlYWtzIG1vZHVsZSByZXNvbHV0aW9uIHRocm91Z2ggYSBzeW1saW5rZWQgYG5vZGVfbW9kdWxlc2AuIEluXG4gKiAgIHBsYWNlLCBTdHJ5a2VyIG11dGF0ZXMgdGhlIHRyZWUgaXRzZWxmIGFuZCBwdXRzIGJhY2sgdGhlIFdIT0xFIHRyZWUgYXMgaXQgd2FzIHdoZW4gdGhlIHJ1biBzdGFydGVkLCBzbyB0aGUgcnVuXG4gKiAgIG5lZWRzIGEgY29tbWl0dGVkIHRyZWUgYW5kIG5vYm9keSBtYXkgZWRpdCBpdCB3aGlsZSB0aGUgcnVuIGlzIGdvaW5nLlxuICogLSBgdml0ZXN0LnJlbGF0ZWQ6IGZhbHNlYCwgYmVjYXVzZSBgdml0ZXN0LnJlbGF0ZWRgIGZvdW5kIG5vIHRlc3RzIGF0IGFsbDsgdGhlIHNjb3BlZCBydW4gbmFtZXMgaXRzIHRlc3QgZmlsZXNcbiAqICAgdGhyb3VnaCB7QGxpbmsgZ2V0U3RyeWtlclRlc3RJbmNsdWRlfSBpbnN0ZWFkLlxuICogLSBgaWdub3JlUGF0dGVybnNgLCBzZWUge0BsaW5rIERFRkFVTFRfU1RSWUtFUl9JR05PUkVfUEFUVEVSTlN9LlxuICpcbiAqIEBwYXJhbSBvdmVycmlkZXMgLSBLZXlzIHRoYXQgcmVwbGFjZSB0aGUgZGVmYXVsdHMuIFRoZSBtZXJnZSBpcyBzaGFsbG93OiBhbiBvdmVycmlkZSBvZiBgdml0ZXN0YCByZXBsYWNlcyB0aGVcbiAqICAgd2hvbGUgYHZpdGVzdGAgb2JqZWN0LlxuICogQHJldHVybnMgVGhlIGNvbmZpZ3VyYXRpb24gdG8gZXhwb3J0IGZyb20gYHN0cnlrZXIuY29uZmlnLm1qc2AuXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBkZWZpbmVTdHJ5a2VyQ29uZmlnKG92ZXJyaWRlczogU3RyeWtlckNvbmZpZyA9IHt9KTogU3RyeWtlckNvbmZpZyB7XG4gIHJldHVybiB7XG4gICAgY2hlY2tlcnM6IFtdLFxuICAgIGNvbmN1cnJlbmN5OiBERUZBVUxUX0NPTkNVUlJFTkNZLFxuICAgIGNvdmVyYWdlQW5hbHlzaXM6ICdwZXJUZXN0JyxcbiAgICBodG1sUmVwb3J0ZXI6IHsgZmlsZU5hbWU6ICdyZXBvcnRzL211dGF0aW9uL211dGF0aW9uLmh0bWwnIH0sXG4gICAgaWdub3JlUGF0dGVybnM6IFsuLi5ERUZBVUxUX1NUUllLRVJfSUdOT1JFX1BBVFRFUk5TXSxcbiAgICBpblBsYWNlOiB0cnVlLFxuICAgIGpzb25SZXBvcnRlcjogeyBmaWxlTmFtZTogJ3JlcG9ydHMvbXV0YXRpb24vbXV0YXRpb24uanNvbicgfSxcbiAgICBtdXRhdGU6IFsuLi5ERUZBVUxUX1NUUllLRVJfTVVUQVRFXSxcbiAgICByZXBvcnRlcnM6IFsnY2xlYXItdGV4dCcsICdwcm9ncmVzcy1hcHBlbmQtb25seScsICdqc29uJywgJ2h0bWwnXSxcbiAgICAvLyBlc2xpbnQtZGlzYWJsZS1uZXh0LWxpbmUgdW5pY29ybi9uYW1lLXJlcGxhY2VtZW50cyAtLSBgdGVtcERpck5hbWVgIGlzIGEgU3RyeWtlciBvcHRpb24uXG4gICAgdGVtcERpck5hbWU6ICcuc3RyeWtlci10bXAnLFxuICAgIHRlc3RSdW5uZXI6ICd2aXRlc3QnLFxuICAgIHRpbWVvdXRNUzogREVGQVVMVF9USU1FT1VUX0lOX01JTExJU0VDT05EUyxcbiAgICB2aXRlc3Q6IHtcbiAgICAgIGNvbmZpZ0ZpbGU6IFNUUllLRVJfVklURVNUX0NPTkZJR19GSUxFX05BTUUsXG4gICAgICByZWxhdGVkOiBmYWxzZVxuICAgIH0sXG4gICAgLi4ub3ZlcnJpZGVzXG4gIH07XG59XG5cbi8qKlxuICogUGlja3MgdGhlIHRlc3QgZmlsZXMgb2YgdGhlIG11dGF0aW9uIHJ1bidzIHZpdGVzdCBjb25maWd1cmF0aW9uOiB0aGUgb25lcyBgdGVzdE11dGF0aW9uYCBuYW1lZCBmb3IgYSBzY29wZWQgcnVuLCBvclxuICogdGhlIGdpdmVuIGRlZmF1bHRzIGZvciBhIGZ1bGwgb25lLlxuICpcbiAqIEBwYXJhbSBkZWZhdWx0SW5jbHVkZSAtIFRoZSBgaW5jbHVkZWAgZ2xvYnMgb2YgYSBmdWxsIHJ1bi5cbiAqIEByZXR1cm5zIFRoZSBgaW5jbHVkZWAgbGlzdC5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGdldFN0cnlrZXJUZXN0SW5jbHVkZShkZWZhdWx0SW5jbHVkZTogcmVhZG9ubHkgc3RyaW5nW10pOiBzdHJpbmdbXSB7XG4gIGNvbnN0IHRlc3RGaWxlcyA9IHByb2Nlc3MuZW52W1NUUllLRVJfVEVTVF9GSUxFU19FTlZfVkFSSUFCTEVdO1xuICByZXR1cm4gdGVzdEZpbGVzID8gdGVzdEZpbGVzLnNwbGl0KCcsJykgOiBbLi4uZGVmYXVsdEluY2x1ZGVdO1xufVxuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7QUFVQSxPQUFPLGFBQWE7QUFFcEIsTUFBTSxzQkFBc0I7QUFDNUIsTUFBTSxrQ0FBa0M7QUFLakMsTUFBTSxrQ0FBa0M7QUFLeEMsTUFBTSxrQ0FBa0M7QUFNeEMsTUFBTSx5QkFBNEM7QUFBQSxFQUN2RDtBQUFBLEVBQ0E7QUFBQSxFQUNBO0FBQUEsRUFDQTtBQUFBLEVBQ0E7QUFBQSxFQUNBO0FBQUEsRUFDQTtBQUNGO0FBTU8sTUFBTSxrQ0FBcUQ7QUFBQSxFQUNoRTtBQUFBLEVBQ0E7QUFBQSxFQUNBO0FBQUEsRUFDQTtBQUFBLEVBQ0E7QUFBQSxFQUNBO0FBQUEsRUFDQTtBQUNGO0FBMEJPLFNBQVMsb0JBQW9CLFlBQTJCLENBQUMsR0FBa0I7QUFDaEYsU0FBTztBQUFBLElBQ0wsVUFBVSxDQUFDO0FBQUEsSUFDWCxhQUFhO0FBQUEsSUFDYixrQkFBa0I7QUFBQSxJQUNsQixjQUFjLEVBQUUsVUFBVSxpQ0FBaUM7QUFBQSxJQUMzRCxnQkFBZ0IsQ0FBQyxHQUFHLCtCQUErQjtBQUFBLElBQ25ELFNBQVM7QUFBQSxJQUNULGNBQWMsRUFBRSxVQUFVLGlDQUFpQztBQUFBLElBQzNELFFBQVEsQ0FBQyxHQUFHLHNCQUFzQjtBQUFBLElBQ2xDLFdBQVcsQ0FBQyxjQUFjLHdCQUF3QixRQUFRLE1BQU07QUFBQTtBQUFBLElBRWhFLGFBQWE7QUFBQSxJQUNiLFlBQVk7QUFBQSxJQUNaLFdBQVc7QUFBQSxJQUNYLFFBQVE7QUFBQSxNQUNOLFlBQVk7QUFBQSxNQUNaLFNBQVM7QUFBQSxJQUNYO0FBQUEsSUFDQSxHQUFHO0FBQUEsRUFDTDtBQUNGO0FBU08sU0FBUyxzQkFBc0IsZ0JBQTZDO0FBQ2pGLFFBQU0sWUFBWSxRQUFRLElBQUksK0JBQStCO0FBQzdELFNBQU8sWUFBWSxVQUFVLE1BQU0sR0FBRyxJQUFJLENBQUMsR0FBRyxjQUFjO0FBQzlEOyIsCiAgIm5hbWVzIjogW10KfQo=

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

@@ -0,0 +1,30 @@
+/// <reference path="../library-references.d.mts" />
+/**
+ * @file
+ *
+ * Runs Stryker mutation testing on demand: over named modules and their sibling tests, or incrementally over the
+ * whole project. Never part of a gate: a full run takes about an hour.
+ */
+/**
+ * Options for {@link testMutation}.
+ */
+export interface TestMutationOptions {
+    /**
+     * The modules to mutate, as paths from the project root. Each needs a sibling `*.test.ts`, and only those tests run.
+     * With none, every file the configuration's `mutate` globs name is mutated, incrementally.
+     *
+     * @default `[]`
+     */
+    readonly modulePaths?: readonly string[];
+}
+/**
+ * Runs Stryker mutation testing.
+ *
+ * The run mutates the tree in place and, when it ends, puts back the whole tree as it was when it started, so it
+ * refuses to start on a tree with uncommitted changes, and nothing may be edited while it runs.
+ *
+ * @param options - The {@link TestMutationOptions}.
+ * @returns A {@link Promise} that resolves when Stryker exits.
+ * @throws If the tree has uncommitted changes, a path is not a `.ts` module, or a module has no sibling test.
+ */
+export declare function testMutation(options?: TestMutationOptions): Promise<void>;

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

@@ -0,0 +1,84 @@
+/*
+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'
+  };
+
+  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 { toPosixPath } from "@mnaoumov/typescript-lib/path";
+import { existsSync } from "node:fs";
+import { resolveToolCommand } from "../package-manager.mjs";
+import {
+  execFromRoot,
+  resolvePathFromRootSafe
+} from "../root.mjs";
+import { STRYKER_TEST_FILES_ENV_VARIABLE } from "./stryker-config.mjs";
+const TS_EXTENSION_REG_EXP = /\.ts$/;
+async function testMutation(options = {}) {
+  const modulePaths = (options.modulePaths ?? []).map((modulePath) => toPosixPath(modulePath));
+  const testFiles = getSiblingTestFiles(modulePaths);
+  const status = await execFromRoot("git status --porcelain --untracked-files=all", { isQuiet: true });
+  if (status) {
+    throw new Error(
+      `Mutation testing needs a committed tree: Stryker mutates it in place and puts the whole tree back as it was when the run started, so an uncommitted change would be lost.
+${status}`
+    );
+  }
+  const runArguments = modulePaths.length > 0 ? ["--mutate", modulePaths.join(",")] : ["--incremental"];
+  const env = modulePaths.length > 0 ? { [STRYKER_TEST_FILES_ENV_VARIABLE]: testFiles.join(",") } : {};
+  await execFromRoot([...resolveToolCommand({ tool: "stryker" }), "run", ...runArguments], { env, isInteractive: true });
+}
+function getSiblingTestFiles(modulePaths) {
+  const problems = [];
+  const testFiles = modulePaths.map((modulePath) => {
+    if (!modulePath.endsWith(".ts") || modulePath.endsWith(".d.ts") || modulePath.endsWith(".test.ts")) {
+      problems.push(`${modulePath}: not a .ts module`);
+      return modulePath;
+    }
+    const testFile = modulePath.replace(TS_EXTENSION_REG_EXP, ".test.ts");
+    if (!existsSync(resolvePathFromRootSafe({ path: testFile }))) {
+      problems.push(`${modulePath}: no sibling test ${testFile}`);
+    }
+    return testFile;
+  });
+  if (problems.length > 0) {
+    throw new Error(`Cannot scope the mutation run:
+${problems.join("\n")}`);
+  }
+  return testFiles;
+}
+export {
+  testMutation
+};
+//# sourceMappingURL=data:application/json;base64,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