@mnaoumov/typescript-dev-toolkit 3.10.0 → 3.12.0

package/dist/lib/cjs/linters/markdownlint-content.cjs

@@ -56,15 +56,40 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var markdownlint_content_exports = {};
 __export(markdownlint_content_exports, {
+  fixMarkdownContent: () => fixMarkdownContent,
   lintMarkdownContent: () => lintMarkdownContent
 });
 module.exports = __toCommonJS(markdownlint_content_exports);
 var import_debug = require('@mnaoumov/typescript-lib/debug');
 var import_path = require('@mnaoumov/typescript-lib/path');
+var import_markdownlint = require('markdownlint');
 var import_markdownlint_cli2 = require('markdownlint-cli2');
 var import_root = require('../root.cjs');
 var import_markdownlint_cli2_config = require('./markdownlint-cli2-config.cjs');
 const SUCCESS_EXIT_CODE = 0;
+async function fixMarkdownContent(params) {
+  const { content, cwd, filePath } = params;
+  const contentDebugger = (0, import_debug.getLibDebugger)("markdownlint:fixMarkdownContent");
+  const fixableErrors = [];
+  await (0, import_markdownlint_cli2.main)({
+    directory: (0, import_root.getRootFolder)(cwd) ?? cwd ?? process.cwd(),
+    logMessage: (message) => {
+      contentDebugger(message);
+    },
+    noGlobs: true,
+    nonFileContents: { [(0, import_path.toPosixPath)(filePath)]: content },
+    optionsDefault: import_markdownlint_cli2_config.obsidianDevUtilsConfig,
+    optionsOverride: {
+      outputFormatters: [[({ results }) => {
+        fixableErrors.push(...results.filter((result) => result.fixInfo !== null));
+      }]]
+    }
+  });
+  return {
+    content: fixableErrors.length === 0 ? content : (0, import_markdownlint.applyFixes)(content, fixableErrors),
+    fixCount: fixableErrors.length
+  };
+}
 async function lintMarkdownContent(params) {
   const { content, cwd, filePath } = params;
   const findings = [];
@@ -93,6 +118,7 @@ async function lintMarkdownContent(params) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  fixMarkdownContent,
   lintMarkdownContent
 });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3NyYy9saW50ZXJzL21hcmtkb3dubGludC1jb250ZW50LnRzIl0sInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQGZpbGVcbiAqXG4gKiBMaW50cyBtYXJrZG93biB0aGF0IGlzIHN0aWxsIGluIG1lbW9yeSwgd2l0aCB0aGUgcmVwb3NpdG9yeSdzIG93biBgbGludDptZGAgY29uZmlndXJhdGlvbi5cbiAqXG4gKiBgbGludDptZGAgY2FuIG9ubHkgYW5zd2VyIGZvciB3aGF0IGlzIGFscmVhZHkgb24gZGlzaywgd2hpY2ggbGVhdmVzIGV2ZXJ5IGRvY3VtZW50IGNvbXBvc2VkIGR1cmluZyBhIHJ1blxuICogdW5jaGVja2VkIHVudGlsIHRoZSBuZXh0IGdhdGUg4oCUIHRoZSByZWxlYXNlJ3MgY2hhbmdlbG9nIGJlaW5nIHRoZSBvbmUgdGhhdCBjb3N0cyBhIHJlZCBgbWFpbmAuIFRoaXMgbW9kdWxlXG4gKiBpcyB0aGUgc2FtZSBjaGVjayBvbmUgc3RlcCBlYXJsaWVyOiB0aGUgdGV4dCBpcyBsaW50ZWQgYXMgdGhlIHBhdGggaXQgaXMgZGVzdGluZWQgZm9yLCBhbmQgYSBjYWxsZXIgdGhhdFxuICogZG9lcyBub3QgbGlrZSB0aGUgYW5zd2VyIGNhbiBzdG9wIGJlZm9yZSB3cml0aW5nIGFueXRoaW5nLlxuICpcbiAqIEl0IGdvZXMgdGhyb3VnaCBgbWFya2Rvd25saW50LWNsaTJgIHJhdGhlciB0aGFuIGBtYXJrZG93bmxpbnRgJ3Mgb3duIHN0cmluZyBBUEksIGFuZCB0aGF0IGlzIHRoZSB3aG9sZVxuICogcG9pbnQgb2YgdGhlIG1vZHVsZS4gVGhlIHF1ZXN0aW9uIGEgY2FsbGVyIGlzIGFza2luZyBpcyAqXCJ3b3VsZCBgbGludDptZGAgaGF2ZSBmYWlsZWQgb24gdGhpcyB0ZXh0P1wiKiwgYW5kXG4gKiBvbmx5IHRoZSBgbWFya2Rvd25saW50LWNsaTJgIGxheWVyIGtub3dzOiBpdCBpcyB3aGF0IGZpbmRzIGAubWFya2Rvd25saW50LWNsaTIubWpzYCAodGhyb3VnaCBgaml0aWAsIGZvclxuICogdGhlIFR5cGVTY3JpcHQgY29uZmlndXJhdGlvbiB0aGlzIHdvcmtzcGFjZSB3cml0ZXMpLCBtZXJnZXMgdGhlIHJlcG9zaXRvcnkncyBvd24gb3ZlcnJpZGVzIG92ZXIgdGhlIHNoYXJlZFxuICogZGVmYXVsdHMsIGFuZCBsb2FkcyB0aGUgY3VzdG9tIHJ1bGVzLiBSZWFjaGluZyBmb3IgdGhlIHN0cmluZyBBUEkgbWVhbnMgaGFuZC1yb2xsaW5nIHRoYXQgcmVzb2x1dGlvbiBvdmVyXG4gKiBmaXZlIGNvbmZpZ3VyYXRpb24gZmlsZSBmb3JtYXRzLCB3aGljaCBpcyBhIGNvcHkgb2YgYG1hcmtkb3dubGludC1jbGkyYCB0aGF0IGNhbiBvbmx5IGV2ZXIgZHJpZnQgZnJvbSBpdC5cbiAqL1xuXG5pbXBvcnQgeyBnZXRMaWJEZWJ1Z2dlciB9IGZyb20gJ0BtbmFvdW1vdi90eXBlc2NyaXB0LWxpYi9kZWJ1Zyc7XG5pbXBvcnQgeyB0b1Bvc2l4UGF0aCB9IGZyb20gJ0BtbmFvdW1vdi90eXBlc2NyaXB0LWxpYi9wYXRoJztcbmltcG9ydCB7IG1haW4gYXMgbWFya2Rvd25saW50Q2xpMiB9IGZyb20gJ21hcmtkb3dubGludC1jbGkyJztcblxuaW1wb3J0IHsgZ2V0Um9vdEZvbGRlciB9IGZyb20gJy4uL3Jvb3QudHMnO1xuaW1wb3J0IHsgb2JzaWRpYW5EZXZVdGlsc0NvbmZpZyB9IGZyb20gJy4vbWFya2Rvd25saW50LWNsaTItY29uZmlnLnRzJztcblxuLyoqXG4gKiBUaGUgZXhpdCBjb2RlIGBtYXJrZG93bmxpbnQtY2xpMmAgcmV0dXJucyB3aGVuIGl0IHJlcG9ydGVkIG5vdGhpbmcgdGhhdCBjb3VudHMgYXMgYSBmYWlsdXJlLlxuICovXG5jb25zdCBTVUNDRVNTX0VYSVRfQ09ERSA9IDA7XG5cbi8qKlxuICogUGFyYW1ldGVycyBmb3Ige0BsaW5rIGxpbnRNYXJrZG93bkNvbnRlbnR9LlxuICovXG5leHBvcnQgaW50ZXJmYWNlIExpbnRNYXJrZG93bkNvbnRlbnRQYXJhbXMge1xuICAvKipcbiAgICogVGhlIG1hcmtkb3duIHRvIGxpbnQuXG4gICAqL1xuICByZWFkb25seSBjb250ZW50OiBzdHJpbmc7XG5cbiAgLyoqXG4gICAqIEEgZm9sZGVyIGluc2lkZSB0aGUgcHJvamVjdCB3aG9zZSBtYXJrZG93bmxpbnQgY29uZmlndXJhdGlvbiBhcHBsaWVzLiBEZWZhdWx0cyB0byB0aGUgY3VycmVudCB3b3JraW5nIGZvbGRlci5cbiAgICogSW4gYSB3b3Jrc3BhY2UsIGEgcGFja2FnZSdzIG93biBmb2xkZXIgaGFzIG5vIGNvbmZpZ3VyYXRpb24gb2YgaXRzIG93biwgc28gYSBjYWxsZXIgbGludGluZyBmb3IgdGhlXG4gICAqIHdvcmtzcGFjZSByb290IG5hbWVzIGl0IGhlcmUuXG4gICAqL1xuICByZWFkb25seSBjd2Q/OiBzdHJpbmcgfCB1bmRlZmluZWQ7XG5cbiAgLyoqXG4gICAqIFRoZSBwYXRoIHRoZSBjb250ZW50IGlzIGxpbnRlZCBBUyDigJQgbm9ybWFsbHkgdGhlIHBhdGggaXQgaXMgYWJvdXQgdG8gYmUgd3JpdHRlbiB0by4gSXQgZGVjaWRlcyBob3cgdGhlXG4gICAqIHBhdGgtcmVsYXRpdmUgcnVsZXMgcmVzb2x2ZSAoYHJlbGF0aXZlLWxpbmtzYCB3YWxrcyBmcm9tIHRoZSBmaWxlJ3Mgb3duIGZvbGRlciksIGFuZCBpdCBpcyB3aGF0IGV2ZXJ5XG4gICAqIHJlcG9ydGVkIGZpbmRpbmcgaXMgbmFtZWQgYWZ0ZXIuXG4gICAqL1xuICByZWFkb25seSBmaWxlUGF0aDogc3RyaW5nO1xufVxuXG4vKipcbiAqIExpbnRzIG1hcmtkb3duIGNvbnRlbnQgdGhhdCBpcyBub3Qgb24gZGlzaywgd2l0aCB0aGUgY29uZmlndXJhdGlvbiBgbGludDptZGAgd291bGQgaGF2ZSB1c2VkIGZvciBpdC5cbiAqXG4gKiBAcGFyYW0gcGFyYW1zIC0gVGhlIHtAbGluayBMaW50TWFya2Rvd25Db250ZW50UGFyYW1zfS5cbiAqIEByZXR1cm5zIEEge0BsaW5rIFByb21pc2V9IHRoYXQgcmVzb2x2ZXMgdG8gdGhlIGZpbmRpbmdzLCBlYWNoIG9uZSB0aGUgbGluZSB0aGUgYGxpbnQ6bWRgIG91dHB1dCB3b3VsZCBoYXZlXG4gKiBjYXJyaWVkIOKAlCBgPHBhdGg+OjxsaW5lPls6PGNvbHVtbj5dIGVycm9yIDxydWxlPiA8ZGVzY3JpcHRpb24+YCDigJQgb3IgYW4gZW1wdHkgYXJyYXkgd2hlbiB0aGVyZSBhcmUgbm9uZS5cbiAqL1xuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGxpbnRNYXJrZG93bkNvbnRlbnQocGFyYW1zOiBMaW50TWFya2Rvd25Db250ZW50UGFyYW1zKTogUHJvbWlzZTxzdHJpbmdbXT4ge1xuICBjb25zdCB7IGNvbnRlbnQsIGN3ZCwgZmlsZVBhdGggfSA9IHBhcmFtcztcbiAgY29uc3QgZmluZGluZ3M6IHN0cmluZ1tdID0gW107XG4gIGNvbnN0IGNvbnRlbnREZWJ1Z2dlciA9IGdldExpYkRlYnVnZ2VyKCdtYXJrZG93bmxpbnQ6bGludE1hcmtkb3duQ29udGVudCcpO1xuXG4gIGNvbnN0IGV4aXRDb2RlID0gYXdhaXQgbWFya2Rvd25saW50Q2xpMih7XG4gICAgZGlyZWN0b3J5OiBnZXRSb290Rm9sZGVyKGN3ZCkgPz8gY3dkID8/IHByb2Nlc3MuY3dkKCksXG4gICAgbG9nRXJyb3I6IChtZXNzYWdlOiBzdHJpbmcpOiB2b2lkID0+IHtcbiAgICAgIGZpbmRpbmdzLnB1c2gobWVzc2FnZSk7XG4gICAgfSxcbiAgICBsb2dNZXNzYWdlOiAobWVzc2FnZTogc3RyaW5nKTogdm9pZCA9PiB7XG4gICAgICBjb250ZW50RGVidWdnZXIobWVzc2FnZSk7XG4gICAgfSxcbiAgICAvLyBUaGUgY29udGVudCBpcyB0aGUgb25seSBpbnB1dC4gV2l0aG91dCB0aGlzIHRoZSBjb25maWd1cmF0aW9uJ3Mgb3duIGBnbG9ic2Agd291bGQgYmUgZXhwYW5kZWQgdG9vLCBhbmRcbiAgICAvLyBhIGNoZWNrIG9uIG9uZSBkb2N1bWVudCB3b3VsZCBsaW50IHRoZSB3aG9sZSByZXBvc2l0b3J5IOKAlCBzbG93bHksIGFuZCByZXBvcnRpbmcgZmluZGluZ3MgaXRzIGNhbGxlciBoYXNcbiAgICAvLyBubyBidXNpbmVzcyBmYWlsaW5nIG9uLlxuICAgIG5vR2xvYnM6IHRydWUsXG4gICAgbm9uRmlsZUNvbnRlbnRzOiB7IFt0b1Bvc2l4UGF0aChmaWxlUGF0aCldOiBjb250ZW50IH0sXG4gICAgLy8gVGhlIEJBU0UgdGhlIHJlcG9zaXRvcnkncyBvd24gY29uZmlndXJhdGlvbiBpcyBtZXJnZWQgb3Zlciwgd2hpY2ggbWF0dGVycyBmb3IgYSByZXBvc2l0b3J5IHRoYXQgaGFzIG5vbmVcbiAgICAvLyB5ZXQ6IGBsaW50KClgIGNvcGllcyB0aGUgdGVtcGxhdGUgY29uZmlndXJhdGlvbiBpbiDigJQgd2hpY2ggaXMgYnVpbHQgb24gdGhpcyBvbmUg4oCUIGJlZm9yZSBpdCBsaW50cywgc28gYVxuICAgIC8vIHJ1biB3aXRob3V0IGl0IHdvdWxkIGFwcGx5IG1hcmtkb3dubGludCdzIHN0b2NrIGRlZmF1bHRzIGluc3RlYWQsIGFuZCBgTUQwMTMvbGluZS1sZW5ndGhgIHdvdWxkIGZhaWwgYXRcbiAgICAvLyA4MCBjb2x1bW5zIG9uIGFuIG9yZGluYXJ5IHJlbGVhc2Ugbm90ZSB0aGF0IGBsaW50Om1kYCBpcyBwZXJmZWN0bHkgaGFwcHkgd2l0aC4gU2luY2UgYSByZXBvc2l0b3J5J3Mgb3duXG4gICAgLy8gY29uZmlndXJhdGlvbiBvdmVycmlkZXMgdGhpcyBrZXkgYnkga2V5LCB0aGUgd29yc3QgYSBtaXNtYXRjaCBjYW4gZG8gaXMgbWlzcyBhIGZpbmRpbmcsIG5ldmVyIGludmVudCBvbmUuXG4gICAgb3B0aW9uc0RlZmF1bHQ6IG9ic2lkaWFuRGV2VXRpbHNDb25maWdcbiAgfSk7XG5cbiAgLy8gV2hldGhlciB0aGlzIGlzIGEgRkFJTFVSRSBpcyB0aGUgdG9vbCdzIG93biBhbnN3ZXIsIG5vdCBhIGNvdW50IG9mIHRoZSBsaW5lcyBpdCBwcmludGVkOiBhIHJ1bGUgY29uZmlndXJlZFxuICAvLyB3aXRoIGBzZXZlcml0eTogd2FybmluZ2AgaXMgcHJpbnRlZCB0aHJvdWdoIGBsb2dFcnJvcmAgbGlrZSBhbnkgb3RoZXIgYW5kIHN0aWxsIGV4aXRzIGAwYCwgc28gcmV0dXJuaW5nIHRoZVxuICAvLyBsaW5lcyBhbG9uZSB3b3VsZCBmYWlsIGEgcmVsZWFzZSBvbiBzb21ldGhpbmcgYGxpbnQ6bWRgIGl0c2VsZiBwYXNzZXMuXG4gIHJldHVybiBleGl0Q29kZSA9PT0gU1VDQ0VTU19FWElUX0NPREUgPyBbXSA6IGZpbmRpbmdzO1xufVxuIl0sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFrQkEsbUJBQStCO0FBQy9CLGtCQUE0QjtBQUM1QiwrQkFBeUM7QUFFekMsa0JBQThCO0FBQzlCLHNDQUF1QztBQUt2QyxNQUFNLG9CQUFvQjtBQWlDMUIsZUFBc0Isb0JBQW9CLFFBQXNEO0FBQzlGLFFBQU0sRUFBRSxTQUFTLEtBQUssU0FBUyxJQUFJO0FBQ25DLFFBQU0sV0FBcUIsQ0FBQztBQUM1QixRQUFNLHNCQUFrQiw2QkFBZSxrQ0FBa0M7QUFFekUsUUFBTSxXQUFXLFVBQU0seUJBQUFBLE1BQWlCO0FBQUEsSUFDdEMsZUFBVywyQkFBYyxHQUFHLEtBQUssT0FBTyxRQUFRLElBQUk7QUFBQSxJQUNwRCxVQUFVLENBQUMsWUFBMEI7QUFDbkMsZUFBUyxLQUFLLE9BQU87QUFBQSxJQUN2QjtBQUFBLElBQ0EsWUFBWSxDQUFDLFlBQTBCO0FBQ3JDLHNCQUFnQixPQUFPO0FBQUEsSUFDekI7QUFBQTtBQUFBO0FBQUE7QUFBQSxJQUlBLFNBQVM7QUFBQSxJQUNULGlCQUFpQixFQUFFLEtBQUMseUJBQVksUUFBUSxDQUFDLEdBQUcsUUFBUTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQSxJQU1wRCxnQkFBZ0I7QUFBQSxFQUNsQixDQUFDO0FBS0QsU0FBTyxhQUFhLG9CQUFvQixDQUFDLElBQUk7QUFDL0M7IiwibmFtZXMiOlsibWFya2Rvd25saW50Q2xpMiJdfQ==
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../../src/linters/markdownlint-content.ts"],"sourcesContent":["/**\n * @file\n *\n * Lints markdown that is still in memory, with the repository's own `lint:md` configuration.\n *\n * `lint:md` can only answer for what is already on disk, which leaves every document composed during a run\n * unchecked until the next gate — the release's changelog being the one that costs a red `main`. This module\n * is the same check one step earlier: the text is linted as the path it is destined for, and a caller that\n * does not like the answer can stop before writing anything.\n *\n * It goes through `markdownlint-cli2` rather than `markdownlint`'s own string API, and that is the whole\n * point of the module. The question a caller is asking is *\"would `lint:md` have failed on this text?\"*, and\n * only the `markdownlint-cli2` layer knows: it is what finds `.markdownlint-cli2.mjs` (through `jiti`, for\n * the TypeScript configuration this workspace writes), merges the repository's own overrides over the shared\n * defaults, and loads the custom rules. Reaching for the string API means hand-rolling that resolution over\n * five configuration file formats, which is a copy of `markdownlint-cli2` that can only ever drift from it.\n */\n\nimport type { LintError } from 'markdownlint';\n\nimport { getLibDebugger } from '@mnaoumov/typescript-lib/debug';\nimport { toPosixPath } from '@mnaoumov/typescript-lib/path';\nimport { applyFixes } from 'markdownlint';\nimport { main as markdownlintCli2 } from 'markdownlint-cli2';\n\nimport { getRootFolder } from '../root.ts';\nimport { obsidianDevUtilsConfig } from './markdownlint-cli2-config.ts';\n\n/**\n * The exit code `markdownlint-cli2` returns when it reported nothing that counts as a failure.\n */\nconst SUCCESS_EXIT_CODE = 0;\n\n/**\n * Parameters for {@link fixMarkdownContent}, the same as {@link lintMarkdownContent}'s.\n */\nexport type FixMarkdownContentParams = LintMarkdownContentParams;\n\n/**\n * The result of {@link fixMarkdownContent}.\n */\nexport interface FixMarkdownContentResult {\n  /**\n   * The content with every fixable finding fixed.\n   */\n  readonly content: string;\n\n  /**\n   * How many findings were fixed.\n   */\n  readonly fixCount: number;\n}\n\n/**\n * Parameters for {@link lintMarkdownContent}.\n */\nexport interface LintMarkdownContentParams {\n  /**\n   * The markdown to lint.\n   */\n  readonly content: string;\n\n  /**\n   * A folder inside the project whose markdownlint configuration applies. Defaults to the current working folder.\n   * In a workspace, a package's own folder has no configuration of its own, so a caller linting for the\n   * workspace root names it here.\n   */\n  readonly cwd?: string | undefined;\n\n  /**\n   * The path the content is linted AS — normally the path it is about to be written to. It decides how the\n   * path-relative rules resolve (`relative-links` walks from the file's own folder), and it is what every\n   * reported finding is named after.\n   */\n  readonly filePath: string;\n}\n\n/**\n * Applies the fixes `lint:md:fix` would apply to markdown that is not on disk, with the configuration `lint:md`\n * would have used for it.\n *\n * `markdownlint-cli2`'s own `fix` reads and writes files only, and skips `nonFileContents`. So the content is linted\n * as {@link lintMarkdownContent} lints it, an output formatter collects the findings with their `fixInfo`, and\n * markdownlint's own `applyFixes` applies them. That is one pass, as `lint:md:fix` makes one: a finding left over is\n * for the caller's next lint to report.\n *\n * @param params - The {@link FixMarkdownContentParams}.\n * @returns A {@link Promise} that resolves to the {@link FixMarkdownContentResult}.\n */\nexport async function fixMarkdownContent(params: FixMarkdownContentParams): Promise<FixMarkdownContentResult> {\n  const { content, cwd, filePath } = params;\n  const contentDebugger = getLibDebugger('markdownlint:fixMarkdownContent');\n  const fixableErrors: LintError[] = [];\n\n  await markdownlintCli2({\n    directory: getRootFolder(cwd) ?? cwd ?? process.cwd(),\n    logMessage: (message: string): void => {\n      contentDebugger(message);\n    },\n    noGlobs: true,\n    nonFileContents: { [toPosixPath(filePath)]: content },\n    optionsDefault: obsidianDevUtilsConfig,\n    optionsOverride: {\n      outputFormatters: [[({ results }): void => {\n        fixableErrors.push(...results.filter((result) => result.fixInfo !== null));\n      }]]\n    }\n  });\n\n  return {\n    content: fixableErrors.length === 0 ? content : applyFixes(content, fixableErrors),\n    fixCount: fixableErrors.length\n  };\n}\n\n/**\n * Lints markdown content that is not on disk, with the configuration `lint:md` would have used for it.\n *\n * @param params - The {@link LintMarkdownContentParams}.\n * @returns A {@link Promise} that resolves to the findings, each one the line the `lint:md` output would have\n * carried — `<path>:<line>[:<column>] error <rule> <description>` — or an empty array when there are none.\n */\nexport async function lintMarkdownContent(params: LintMarkdownContentParams): Promise<string[]> {\n  const { content, cwd, filePath } = params;\n  const findings: string[] = [];\n  const contentDebugger = getLibDebugger('markdownlint:lintMarkdownContent');\n\n  const exitCode = await markdownlintCli2({\n    directory: getRootFolder(cwd) ?? cwd ?? process.cwd(),\n    logError: (message: string): void => {\n      findings.push(message);\n    },\n    logMessage: (message: string): void => {\n      contentDebugger(message);\n    },\n    // The content is the only input. Without this the configuration's own `globs` would be expanded too, and\n    // a check on one document would lint the whole repository — slowly, and reporting findings its caller has\n    // no business failing on.\n    noGlobs: true,\n    nonFileContents: { [toPosixPath(filePath)]: content },\n    // The BASE the repository's own configuration is merged over, which matters for a repository that has none\n    // yet: `lint()` copies the template configuration in — which is built on this one — before it lints, so a\n    // run without it would apply markdownlint's stock defaults instead, and `MD013/line-length` would fail at\n    // 80 columns on an ordinary release note that `lint:md` is perfectly happy with. Since a repository's own\n    // configuration overrides this key by key, the worst a mismatch can do is miss a finding, never invent one.\n    optionsDefault: obsidianDevUtilsConfig\n  });\n\n  // Whether this is a FAILURE is the tool's own answer, not a count of the lines it printed: a rule configured\n  // with `severity: warning` is printed through `logError` like any other and still exits `0`, so returning the\n  // lines alone would fail a release on something `lint:md` itself passes.\n  return exitCode === SUCCESS_EXIT_CODE ? [] : findings;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAoBA,mBAA+B;AAC/B,kBAA4B;AAC5B,0BAA2B;AAC3B,+BAAyC;AAEzC,kBAA8B;AAC9B,sCAAuC;AAKvC,MAAM,oBAAoB;AA0D1B,eAAsB,mBAAmB,QAAqE;AAC5G,QAAM,EAAE,SAAS,KAAK,SAAS,IAAI;AACnC,QAAM,sBAAkB,6BAAe,iCAAiC;AACxE,QAAM,gBAA6B,CAAC;AAEpC,YAAM,yBAAAA,MAAiB;AAAA,IACrB,eAAW,2BAAc,GAAG,KAAK,OAAO,QAAQ,IAAI;AAAA,IACpD,YAAY,CAAC,YAA0B;AACrC,sBAAgB,OAAO;AAAA,IACzB;AAAA,IACA,SAAS;AAAA,IACT,iBAAiB,EAAE,KAAC,yBAAY,QAAQ,CAAC,GAAG,QAAQ;AAAA,IACpD,gBAAgB;AAAA,IAChB,iBAAiB;AAAA,MACf,kBAAkB,CAAC,CAAC,CAAC,EAAE,QAAQ,MAAY;AACzC,sBAAc,KAAK,GAAG,QAAQ,OAAO,CAAC,WAAW,OAAO,YAAY,IAAI,CAAC;AAAA,MAC3E,CAAC,CAAC;AAAA,IACJ;AAAA,EACF,CAAC;AAED,SAAO;AAAA,IACL,SAAS,cAAc,WAAW,IAAI,cAAU,gCAAW,SAAS,aAAa;AAAA,IACjF,UAAU,cAAc;AAAA,EAC1B;AACF;AASA,eAAsB,oBAAoB,QAAsD;AAC9F,QAAM,EAAE,SAAS,KAAK,SAAS,IAAI;AACnC,QAAM,WAAqB,CAAC;AAC5B,QAAM,sBAAkB,6BAAe,kCAAkC;AAEzE,QAAM,WAAW,UAAM,yBAAAA,MAAiB;AAAA,IACtC,eAAW,2BAAc,GAAG,KAAK,OAAO,QAAQ,IAAI;AAAA,IACpD,UAAU,CAAC,YAA0B;AACnC,eAAS,KAAK,OAAO;AAAA,IACvB;AAAA,IACA,YAAY,CAAC,YAA0B;AACrC,sBAAgB,OAAO;AAAA,IACzB;AAAA;AAAA;AAAA;AAAA,IAIA,SAAS;AAAA,IACT,iBAAiB,EAAE,KAAC,yBAAY,QAAQ,CAAC,GAAG,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,IAMpD,gBAAgB;AAAA,EAClB,CAAC;AAKD,SAAO,aAAa,oBAAoB,CAAC,IAAI;AAC/C;","names":["markdownlintCli2"]}

package/dist/lib/cjs/linters/markdownlint-content.d.cts

@@ -16,6 +16,23 @@
  * defaults, and loads the custom rules. Reaching for the string API means hand-rolling that resolution over
  * five configuration file formats, which is a copy of `markdownlint-cli2` that can only ever drift from it.
  */
+/**
+ * Parameters for {@link fixMarkdownContent}, the same as {@link lintMarkdownContent}'s.
+ */
+export type FixMarkdownContentParams = LintMarkdownContentParams;
+/**
+ * The result of {@link fixMarkdownContent}.
+ */
+export interface FixMarkdownContentResult {
+    /**
+     * The content with every fixable finding fixed.
+     */
+    readonly content: string;
+    /**
+     * How many findings were fixed.
+     */
+    readonly fixCount: number;
+}
 /**
  * Parameters for {@link lintMarkdownContent}.
  */
@@ -37,6 +54,19 @@ export interface LintMarkdownContentParams {
      */
     readonly filePath: string;
 }
+/**
+ * Applies the fixes `lint:md:fix` would apply to markdown that is not on disk, with the configuration `lint:md`
+ * would have used for it.
+ *
+ * `markdownlint-cli2`'s own `fix` reads and writes files only, and skips `nonFileContents`. So the content is linted
+ * as {@link lintMarkdownContent} lints it, an output formatter collects the findings with their `fixInfo`, and
+ * markdownlint's own `applyFixes` applies them. That is one pass, as `lint:md:fix` makes one: a finding left over is
+ * for the caller's next lint to report.
+ *
+ * @param params - The {@link FixMarkdownContentParams}.
+ * @returns A {@link Promise} that resolves to the {@link FixMarkdownContentResult}.
+ */
+export declare function fixMarkdownContent(params: FixMarkdownContentParams): Promise<FixMarkdownContentResult>;
 /**
  * Lints markdown content that is not on disk, with the configuration `lint:md` would have used for it.
  *

package/dist/lib/cjs/linters/markdownlint-types/@types/markdownlint-cli2.d.cts

@@ -5,13 +5,35 @@
  * The types for `markdownlint-cli2`'s programmatic entry point, which the package itself describes in JSDoc
  * and ships no declaration for. Vendored here, beside the configuration-schema types, for the same reason.
  *
- * Only the parameters {@link lintMarkdownContent} passes are declared. The full parameter object also carries
- * `argv`, `allowStdin`, `fileContents`, `fs`, `noImport` and `optionsOverride`, none of which a caller linting
+ * Only the parameters {@link lintMarkdownContent} and {@link fixMarkdownContent} pass are declared. The full parameter
+ * object also carries `argv`, `allowStdin`, `fileContents`, `fs` and `noImport`, none of which a caller linting
  * one in-memory document has any use for — and declaring an option nobody passes is a claim about a shape
  * nothing here ever checks.
  */
 
 declare module 'markdownlint-cli2' {
+  /**
+   * What `markdownlint-cli2` hands an output formatter.
+   */
+  interface MarkdownlintCli2FormatterOptions {
+    /**
+     * Every finding of the run, each one markdownlint's own `LintError` with the reported path added, so a fixable
+     * one still carries its `fixInfo`.
+     */
+    readonly results: readonly (import('markdownlint', { with: { 'resolution-mode': 'import' } }).LintError & { readonly fileName: string })[];
+  }
+
+  /**
+   * The options that win over every configuration `markdownlint-cli2` discovers.
+   */
+  interface MarkdownlintCli2OptionsOverride {
+    /**
+     * The output formatters, each a module id or the formatter function itself, followed by its parameters. Setting
+     * it replaces the default formatter, so nothing reaches `logError`.
+     */
+    readonly outputFormatters?: readonly (readonly [(options: MarkdownlintCli2FormatterOptions) => Promise<void> | void])[] | undefined;
+  }
+
   /**
    * The parameters of {@link main}.
    */
@@ -54,6 +76,11 @@ declare module 'markdownlint-cli2' {
      * key by key and every other option is replaced wholesale, so anything the repository states itself wins.
      */
     readonly optionsDefault?: import('./markdownlint-cli2-config-schema.d.cjs').MarkdownlintCli2ConfigurationSchema | undefined;
+
+    /**
+     * The options merged over everything discovered, which win over the repository's own configuration.
+     */
+    readonly optionsOverride?: MarkdownlintCli2OptionsOverride | undefined;
   }
 
   /**

package/dist/lib/cjs/test-runners/index.cjs

@@ -36,6 +36,8 @@ __export(test_runners_exports, {
   auto: () => auto,
   jest: () => jest,
   "jest-config": () => jest_config,
+  stryker: () => stryker,
+  "stryker-config": () => stryker_config,
   vitest: () => vitest,
   "vitest-config": () => vitest_config
 });
@@ -43,6 +45,8 @@ module.exports = __toCommonJS(test_runners_exports);
 var auto = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./auto.cjs')), 1);
 var jest_config = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./jest-config.cjs')), 1);
 var jest = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./jest.cjs')), 1);
+var stryker_config = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./stryker-config.cjs')), 1);
+var stryker = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./stryker.cjs')), 1);
 var vitest_config = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./vitest-config.cjs')), 1);
 var vitest = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('./vitest.cjs')), 1);
 // Annotate the CommonJS export names for ESM import in node:
@@ -50,7 +54,9 @@ var vitest = __toESM(((module) => module && module.__esModule && 'default' in mo
   auto,
   jest,
   "jest-config": null,
+  stryker,
+  "stryker-config": null,
   vitest,
   "vitest-config": null
 });
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL3Rlc3QtcnVubmVycy9pbmRleC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyogVEhJUyBJUyBBIEdFTkVSQVRFRC9CVU5ETEVEIEZJTEUgQlkgQlVJTEQgU0NSSVBUICovXG5cbmV4cG9ydCAqIGFzICdhdXRvJyBmcm9tICcuL2F1dG8udHMnO1xuZXhwb3J0ICogYXMgJ2plc3QtY29uZmlnJyBmcm9tICcuL2plc3QtY29uZmlnLnRzJztcbmV4cG9ydCAqIGFzICdqZXN0JyBmcm9tICcuL2plc3QudHMnO1xuZXhwb3J0ICogYXMgJ3ZpdGVzdC1jb25maWcnIGZyb20gJy4vdml0ZXN0LWNvbmZpZy50cyc7XG5leHBvcnQgKiBhcyAndml0ZXN0JyBmcm9tICcuL3ZpdGVzdC50cyc7XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLHVCQUFBQTtBQUFBLEVBQUE7QUFBQSx5QkFBQUM7QUFBQTtBQUFBO0FBRUEsV0FBd0I7QUFDeEIsSUFBQUQsY0FBK0I7QUFDL0IsV0FBd0I7QUFDeEIsSUFBQUMsZ0JBQWlDO0FBQ2pDLGFBQTBCOyIsCiAgIm5hbWVzIjogWyJqZXN0LWNvbmZpZyIsICJ2aXRlc3QtY29uZmlnIl0KfQo=
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL3Rlc3QtcnVubmVycy9pbmRleC50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyogVEhJUyBJUyBBIEdFTkVSQVRFRC9CVU5ETEVEIEZJTEUgQlkgQlVJTEQgU0NSSVBUICovXG5cbmV4cG9ydCAqIGFzICdhdXRvJyBmcm9tICcuL2F1dG8udHMnO1xuZXhwb3J0ICogYXMgJ2plc3QtY29uZmlnJyBmcm9tICcuL2plc3QtY29uZmlnLnRzJztcbmV4cG9ydCAqIGFzICdqZXN0JyBmcm9tICcuL2plc3QudHMnO1xuZXhwb3J0ICogYXMgJ3N0cnlrZXItY29uZmlnJyBmcm9tICcuL3N0cnlrZXItY29uZmlnLnRzJztcbmV4cG9ydCAqIGFzICdzdHJ5a2VyJyBmcm9tICcuL3N0cnlrZXIudHMnO1xuZXhwb3J0ICogYXMgJ3ZpdGVzdC1jb25maWcnIGZyb20gJy4vdml0ZXN0LWNvbmZpZy50cyc7XG5leHBvcnQgKiBhcyAndml0ZXN0JyBmcm9tICcuL3ZpdGVzdC50cyc7XG4iXSwKICAibWFwcGluZ3MiOiAiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBLHVCQUFBQTtBQUFBLEVBQUE7QUFBQSwwQkFBQUM7QUFBQSxFQUFBO0FBQUEseUJBQUFDO0FBQUE7QUFBQTtBQUVBLFdBQXdCO0FBQ3hCLElBQUFGLGNBQStCO0FBQy9CLFdBQXdCO0FBQ3hCLElBQUFDLGlCQUFrQztBQUNsQyxjQUEyQjtBQUMzQixJQUFBQyxnQkFBaUM7QUFDakMsYUFBMEI7IiwKICAibmFtZXMiOiBbImplc3QtY29uZmlnIiwgInN0cnlrZXItY29uZmlnIiwgInZpdGVzdC1jb25maWciXQp9Cg==

package/dist/lib/cjs/test-runners/index.d.cts

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

package/dist/lib/cjs/test-runners/stryker-config.cjs

@@ -0,0 +1,102 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stryker_config_exports = {};
+__export(stryker_config_exports, {
+  DEFAULT_STRYKER_IGNORE_PATTERNS: () => DEFAULT_STRYKER_IGNORE_PATTERNS,
+  DEFAULT_STRYKER_MUTATE: () => DEFAULT_STRYKER_MUTATE,
+  STRYKER_TEST_FILES_ENV_VARIABLE: () => STRYKER_TEST_FILES_ENV_VARIABLE,
+  STRYKER_VITEST_CONFIG_FILE_NAME: () => STRYKER_VITEST_CONFIG_FILE_NAME,
+  defineStrykerConfig: () => defineStrykerConfig,
+  getStrykerTestInclude: () => getStrykerTestInclude
+});
+module.exports = __toCommonJS(stryker_config_exports);
+var import_node_process = __toESM(((module) => module && module.__esModule && 'default' in module ? module.default : module)(require('node:process')), 1);
+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 = import_node_process.default.env[STRYKER_TEST_FILES_ENV_VARIABLE];
+  return testFiles ? testFiles.split(",") : [...defaultInclude];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_STRYKER_IGNORE_PATTERNS,
+  DEFAULT_STRYKER_MUTATE,
+  STRYKER_TEST_FILES_ENV_VARIABLE,
+  STRYKER_VITEST_CONFIG_FILE_NAME,
+  defineStrykerConfig,
+  getStrykerTestInclude
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/test-runners/stryker-config.d.cts

@@ -0,0 +1,60 @@
+/// <reference path="../library-references.d.cts" />
+/**
+ * @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/cjs/test-runners/stryker.cjs

@@ -0,0 +1,105 @@
+/*
+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();
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var stryker_exports = {};
+__export(stryker_exports, {
+  testMutation: () => testMutation
+});
+module.exports = __toCommonJS(stryker_exports);
+var import_path = require('@mnaoumov/typescript-lib/path');
+var import_node_fs = require('node:fs');
+var import_package_manager = require('../package-manager.cjs');
+var import_root = require('../root.cjs');
+var import_stryker_config = require('./stryker-config.cjs');
+const TS_EXTENSION_REG_EXP = /\.ts$/;
+async function testMutation(options = {}) {
+  const modulePaths = (options.modulePaths ?? []).map((modulePath) => (0, import_path.toPosixPath)(modulePath));
+  const testFiles = getSiblingTestFiles(modulePaths);
+  const status = await (0, import_root.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 ? { [import_stryker_config.STRYKER_TEST_FILES_ENV_VARIABLE]: testFiles.join(",") } : {};
+  await (0, import_root.execFromRoot)([...(0, import_package_manager.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 (!(0, import_node_fs.existsSync)((0, import_root.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;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  testMutation
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/test-runners/stryker.d.cts

@@ -0,0 +1,30 @@
+/// <reference path="../library-references.d.cts" />
+/**
+ * @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>;