@t09tanaka/test-gates 0.0.0-stage → 0.2.0

package/dist/jest.js

@@ -0,0 +1,39 @@
+import {
+  FULL_COVERAGE,
+  resolveRootDir
+} from "./chunk-4HAJIKDZ.js";
+import {
+  NO_SPEC_PATTERN,
+  gateSpecs,
+  loadGates
+} from "./chunk-XEKQKLKY.js";
+
+// src/jest.ts
+import path from "path";
+function createJestGatesConfig(options = {}) {
+  const { rootDir: rootDirOption, ...overrides } = options;
+  const rootDir = resolveRootDir(rootDirOption);
+  const manifest = loadGates(rootDir);
+  const specs = gateSpecs(manifest);
+  return {
+    testEnvironment: "node",
+    coverageReporters: ["text"],
+    coverageDirectory: "<rootDir>/coverage/gates",
+    ...overrides,
+    rootDir,
+    // Never an empty array: Jest would fall back to its default pattern and run every test.
+    testMatch: (specs.length > 0 ? specs : [NO_SPEC_PATTERN]).map((spec) => `<rootDir>/${spec}`),
+    // With no spec left (`test-gates selfcheck` on a single-gate project) the run must fail on the
+    // missing coverage of the gate, not on "No tests found".
+    passWithNoTests: true,
+    collectCoverage: true,
+    coverageProvider: "babel",
+    collectCoverageFrom: manifest.gates.map((gate) => `<rootDir>/${gate.path}`),
+    coverageThreshold: Object.fromEntries(
+      manifest.gates.map((gate) => [path.join(rootDir, gate.path), { ...FULL_COVERAGE }])
+    )
+  };
+}
+export {
+  createJestGatesConfig
+};

package/dist/stryker.cjs

@@ -0,0 +1,634 @@
+"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);
+
+// src/stryker.ts
+var stryker_exports = {};
+__export(stryker_exports, {
+  createStrykerGatesConfig: () => createStrykerGatesConfig
+});
+module.exports = __toCommonJS(stryker_exports);
+
+// src/load.ts
+var import_node_fs2 = __toESM(require("fs"), 1);
+var import_node_path2 = __toESM(require("path"), 1);
+
+// src/core/manifest.ts
+var MANIFEST_FILE = "test-gates.json";
+var ManifestError = class extends Error {
+};
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isFilled(value) {
+  return typeof value === "string" && value.trim() !== "";
+}
+function allowanceProblems(entry) {
+  if (!isRecord(entry)) {
+    return [" must be an object"];
+  }
+  const problems = [];
+  if (!isFilled(entry.mutator)) {
+    problems.push(': "mutator" is missing');
+  }
+  if (!isFilled(entry.original)) {
+    problems.push(': "original" is missing');
+  }
+  if (typeof entry.replacement !== "string") {
+    problems.push(': "replacement" is missing');
+  }
+  if (!isFilled(entry.reason)) {
+    problems.push(': "reason" is missing (say why the mutant cannot be observed)');
+  }
+  if (entry.occurrence !== void 0 && !(Number.isInteger(entry.occurrence) && entry.occurrence >= 1)) {
+    problems.push(': "occurrence" must be an integer >= 1');
+  }
+  return problems;
+}
+function validateEquivalentMutants(gatePath, value, field = "equivalentMutants") {
+  if (value === void 0) {
+    return [];
+  }
+  if (!Array.isArray(value)) {
+    return [{ file: MANIFEST_FILE, message: `${gatePath}: ${field} must be an array` }];
+  }
+  return value.flatMap(
+    (entry, index) => allowanceProblems(entry).map((problem) => ({
+      file: MANIFEST_FILE,
+      message: `${gatePath}: ${field}[${index}]${problem}`
+    }))
+  );
+}
+function parseEntries(kind, entries, fields, violations) {
+  const usable = [];
+  const seen = /* @__PURE__ */ new Set();
+  entries.forEach((entry, index) => {
+    const at = `${kind}[${index}]`;
+    if (!isRecord(entry)) {
+      violations.push({ file: MANIFEST_FILE, message: `${at} must be an object` });
+      return;
+    }
+    if (!isFilled(entry.path)) {
+      violations.push({ file: MANIFEST_FILE, message: `${at}: "path" is missing` });
+      return;
+    }
+    for (const field of fields) {
+      if (!isFilled(entry[field])) {
+        violations.push({
+          file: MANIFEST_FILE,
+          message: `${entry.path}: "${field}" is missing in ${kind}`
+        });
+      }
+    }
+    if (seen.has(entry.path)) {
+      violations.push({ file: MANIFEST_FILE, message: `${entry.path}: listed twice in ${kind}` });
+      return;
+    }
+    seen.add(entry.path);
+    usable.push(entry);
+  });
+  return usable;
+}
+function parseManifest(text) {
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch (error) {
+    throw new ManifestError(`${MANIFEST_FILE} is not valid JSON: ${error.message}`);
+  }
+  if (!isRecord(raw)) {
+    throw new ManifestError(`${MANIFEST_FILE} must be a JSON object`);
+  }
+  if (!Array.isArray(raw.gates)) {
+    throw new ManifestError(`${MANIFEST_FILE}: "gates" must be an array`);
+  }
+  if (raw.candidates !== void 0 && !Array.isArray(raw.candidates)) {
+    throw new ManifestError(`${MANIFEST_FILE}: "candidates" must be an array`);
+  }
+  for (const key of Object.keys(raw)) {
+    if (!["$schema", "gates", "candidates", "settings"].includes(key)) {
+      throw new ManifestError(`${MANIFEST_FILE}: unknown top-level key ${JSON.stringify(key)}`);
+    }
+  }
+  const violations = [];
+  if (raw.gates.length === 0) {
+    violations.push({
+      file: MANIFEST_FILE,
+      message: "gates is empty. A project with nothing to gate should not have this file"
+    });
+  }
+  const gates = parseEntries("gates", raw.gates, ["decides", "impact"], violations);
+  const candidates = parseEntries(
+    "candidates",
+    raw.candidates ?? [],
+    ["decides", "blocker"],
+    violations
+  );
+  const gatePaths = new Set(gates.map((gate) => gate.path));
+  for (const candidate of candidates) {
+    if (gatePaths.has(candidate.path)) {
+      violations.push({
+        file: MANIFEST_FILE,
+        message: `${candidate.path}: listed in both gates and candidates`
+      });
+    }
+  }
+  for (const gate of gates) {
+    violations.push(...validateEquivalentMutants(gate.path, gate.equivalentMutants));
+    violations.push(
+      ...validateEquivalentMutants(gate.path, gate.expectedTimeouts, "expectedTimeouts")
+    );
+  }
+  return { gates, candidates, settings: raw.settings, violations };
+}
+
+// src/core/settings.ts
+var DEFAULT_REPORT_FILE = "reports/mutation/mutation.json";
+var DEFAULT_GATE_EXTENSIONS = [".ts", ".mts", ".cts", ".js", ".mjs", ".cjs"];
+var DEFAULT_IMPURE_IMPORTS = [
+  { pattern: "^@nestjs/", reason: "NestJS runtime (DI, decorators)" },
+  { pattern: "^class-(validator|transformer)$", reason: "decorator-based DTO library" },
+  {
+    pattern: "^(typeorm|sequelize|mongoose|knex|pg|mysql|mysql2|ioredis|redis)(/|$)",
+    reason: "database client"
+  },
+  { pattern: "^@prisma/adapter-", reason: "database client" },
+  { pattern: "^(react|react-dom)(/|$)", reason: "React runtime" },
+  { pattern: "^next(/|$)", reason: "Next.js runtime" },
+  { pattern: "^(server-only|client-only)$", reason: "Next.js execution environment" },
+  { pattern: "^(vue|vue-router|vue-i18n|pinia)(/|$)", reason: "Vue runtime" },
+  { pattern: "^nuxt(/|$)", reason: "Nuxt runtime" },
+  { pattern: "^#(app|imports)(/|$)", reason: "Nuxt runtime" },
+  { pattern: "\\.vue$", reason: "component" },
+  {
+    pattern: "^(express|express-jwt|fastify|koa|rxjs|passport)(/|$)",
+    reason: "HTTP framework runtime"
+  },
+  { pattern: "^passport-", reason: "HTTP framework runtime" },
+  {
+    pattern: "^(axios|openapi-fetch|stripe|nodemailer|firebase-admin)(/|$)",
+    reason: "HTTP client / external service SDK"
+  },
+  { pattern: "^@(aws-sdk|sentry|slack|stripe)/", reason: "external service SDK" },
+  {
+    pattern: "^(node:)?(fs|http|https|http2|net|tls|dgram|dns|child_process|worker_threads)(/|$)",
+    reason: "file system / network / process access"
+  }
+];
+var DEFAULT_IMPURE_NAMED_IMPORTS = [
+  { module: "@prisma/client", names: ["PrismaClient"], reason: "connects to the database" }
+];
+var DEFAULT_IMPURE_PATHS = [
+  { pattern: "\\.(vue|jsx|tsx)$", reason: "component file" },
+  { pattern: "\\.d\\.[cm]?ts$", reason: "type declaration file" }
+];
+var DEFAULT_FORBIDDEN_SOURCE = [
+  {
+    pattern: `^\\s*(['"])use (client|server)\\1`,
+    reason: "'use client' / 'use server' directive (not a pure module)"
+  }
+];
+var SettingsError = class extends Error {
+};
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function compile(pattern, flags, where) {
+  try {
+    return new RegExp(pattern, flags);
+  } catch (error) {
+    throw new SettingsError(
+      `${where}: invalid regular expression ${JSON.stringify(pattern)} (${error.message})`
+    );
+  }
+}
+function stringArray(value, where) {
+  if (!Array.isArray(value) || value.some((item) => typeof item !== "string" || item === "")) {
+    throw new SettingsError(`${where}: must be an array of non-empty strings`);
+  }
+  return value;
+}
+function optionalString(value, where) {
+  if (value === void 0) {
+    return null;
+  }
+  if (typeof value !== "string" || value === "") {
+    throw new SettingsError(`${where}: must be a non-empty string`);
+  }
+  return value;
+}
+function rejectUnknownKeys(value, known, where) {
+  for (const key of Object.keys(value)) {
+    if (!known.includes(key)) {
+      throw new SettingsError(`${where}: unknown key ${JSON.stringify(key)}`);
+    }
+  }
+}
+function section(value, known, where) {
+  if (value === void 0) {
+    return {};
+  }
+  if (!isRecord2(value)) {
+    throw new SettingsError(`${where}: must be an object`);
+  }
+  rejectUnknownKeys(value, known, where);
+  return value;
+}
+function compileRules(defaults, raw, where, extraKeys = []) {
+  const config = section(raw, ["defaults", "add", ...extraKeys], where);
+  if (config.defaults !== void 0 && typeof config.defaults !== "boolean") {
+    throw new SettingsError(`${where}.defaults: must be a boolean`);
+  }
+  const added = config.add ?? [];
+  if (!Array.isArray(added)) {
+    throw new SettingsError(`${where}.add: must be an array`);
+  }
+  const all = [];
+  if (config.defaults !== false) {
+    defaults.forEach((rule) => all.push({ rule, where: `${where} (default)` }));
+  }
+  added.forEach((item, index) => {
+    const at = `${where}.add[${index}]`;
+    if (typeof item === "string" && item !== "") {
+      all.push({ rule: { pattern: item }, where: at });
+      return;
+    }
+    if (!isRecord2(item) || typeof item.pattern !== "string" || item.pattern === "") {
+      throw new SettingsError(`${at}: must be a pattern string or { pattern, flags?, reason? }`);
+    }
+    rejectUnknownKeys(item, ["pattern", "flags", "reason"], at);
+    if (item.flags !== void 0 && typeof item.flags !== "string") {
+      throw new SettingsError(`${at}.flags: must be a string`);
+    }
+    if (item.reason !== void 0 && typeof item.reason !== "string") {
+      throw new SettingsError(`${at}.reason: must be a string`);
+    }
+    all.push({ rule: item, where: at });
+  });
+  return {
+    rules: all.map(({ rule, where: at }) => ({
+      regex: compile(rule.pattern, rule.flags, at),
+      reason: rule.reason ?? `matches ${rule.pattern}`
+    })),
+    section: config
+  };
+}
+function resolveSettings(raw) {
+  const settings = section(
+    raw,
+    [
+      "gateExtensions",
+      "spec",
+      "impureImports",
+      "impureNamedImports",
+      "impurePaths",
+      "forbiddenSource",
+      "importAliases",
+      "gateCommand",
+      "selfcheck",
+      "stryker",
+      "lcov",
+      "imports",
+      "mutation"
+    ],
+    "settings"
+  );
+  const gateExtensions = settings.gateExtensions === void 0 ? DEFAULT_GATE_EXTENSIONS : stringArray(settings.gateExtensions, "settings.gateExtensions");
+  if (gateExtensions.length === 0 || gateExtensions.some((ext) => !ext.startsWith("."))) {
+    throw new SettingsError(
+      'settings.gateExtensions: must list at least one extension starting with "."'
+    );
+  }
+  const spec = section(settings.spec, ["suffixes", "rewrite"], "settings.spec");
+  const specSuffixes = spec.suffixes === void 0 ? null : stringArray(spec.suffixes, "settings.spec.suffixes");
+  const rewriteRaw = spec.rewrite ?? [];
+  if (!Array.isArray(rewriteRaw)) {
+    throw new SettingsError("settings.spec.rewrite: must be an array");
+  }
+  const specRewrite = rewriteRaw.map((item, index) => {
+    const at = `settings.spec.rewrite[${index}]`;
+    if (!isRecord2(item) || typeof item.from !== "string" || typeof item.to !== "string") {
+      throw new SettingsError(`${at}: must be { from, to }`);
+    }
+    rejectUnknownKeys(item, ["from", "to"], at);
+    return { regex: compile(item.from, void 0, at), to: item.to };
+  });
+  const imports = compileRules(
+    DEFAULT_IMPURE_IMPORTS,
+    settings.impureImports,
+    "settings.impureImports",
+    ["allow"]
+  );
+  const allowedImports = imports.section.allow === void 0 ? [] : stringArray(imports.section.allow, "settings.impureImports.allow").map(
+    (pattern, index) => compile(pattern, void 0, `settings.impureImports.allow[${index}]`)
+  );
+  const named = section(
+    settings.impureNamedImports,
+    ["defaults", "add"],
+    "settings.impureNamedImports"
+  );
+  if (named.defaults !== void 0 && typeof named.defaults !== "boolean") {
+    throw new SettingsError("settings.impureNamedImports.defaults: must be a boolean");
+  }
+  const namedAdd = named.add ?? [];
+  if (!Array.isArray(namedAdd)) {
+    throw new SettingsError("settings.impureNamedImports.add: must be an array");
+  }
+  const impureNamedImports = [
+    ...named.defaults === false ? [] : DEFAULT_IMPURE_NAMED_IMPORTS,
+    ...namedAdd.map((item, index) => {
+      const at = `settings.impureNamedImports.add[${index}]`;
+      if (!isRecord2(item) || typeof item.module !== "string" || item.module === "") {
+        throw new SettingsError(`${at}: must be { module, names, reason? }`);
+      }
+      rejectUnknownKeys(item, ["module", "names", "reason"], at);
+      const names = stringArray(item.names, `${at}.names`);
+      if (names.length === 0) {
+        throw new SettingsError(`${at}.names: must list at least one name`);
+      }
+      if (item.reason !== void 0 && typeof item.reason !== "string") {
+        throw new SettingsError(`${at}.reason: must be a string`);
+      }
+      return {
+        module: item.module,
+        names,
+        reason: item.reason ?? "not allowed in a pure module"
+      };
+    })
+  ];
+  const aliasesRaw = settings.importAliases ?? [];
+  if (!Array.isArray(aliasesRaw)) {
+    throw new SettingsError("settings.importAliases: must be an array");
+  }
+  const importAliases = aliasesRaw.map((item, index) => {
+    const at = `settings.importAliases[${index}]`;
+    if (!isRecord2(item) || typeof item.prefix !== "string" || item.prefix === "" || typeof item.target !== "string") {
+      throw new SettingsError(`${at}: must be { prefix, target }`);
+    }
+    rejectUnknownKeys(item, ["prefix", "target"], at);
+    return { prefix: item.prefix, target: item.target };
+  });
+  let gateCommand = null;
+  if (settings.gateCommand !== void 0) {
+    gateCommand = stringArray(settings.gateCommand, "settings.gateCommand");
+    if (gateCommand.length === 0) {
+      throw new SettingsError("settings.gateCommand: must not be empty");
+    }
+  }
+  const selfcheck = section(settings.selfcheck, ["mode", "failurePattern"], "settings.selfcheck");
+  if (selfcheck.mode !== void 0 && selfcheck.mode !== "all" && selfcheck.mode !== "first") {
+    throw new SettingsError('settings.selfcheck.mode: must be "all" or "first"');
+  }
+  const selfcheckFailurePattern = optionalString(
+    selfcheck.failurePattern,
+    "settings.selfcheck.failurePattern"
+  );
+  if (selfcheckFailurePattern !== null) {
+    compile(
+      selfcheckFailurePattern.split("{gate}").join("x"),
+      void 0,
+      "settings.selfcheck.failurePattern"
+    );
+  }
+  const importsSection = section(settings.imports, ["mode", "allow"], "settings.imports");
+  if (importsSection.mode !== void 0 && importsSection.mode !== "blocklist" && importsSection.mode !== "allowlist") {
+    throw new SettingsError('settings.imports.mode: must be "blocklist" or "allowlist"');
+  }
+  const importAllowRaw = importsSection.allow ?? [];
+  if (!Array.isArray(importAllowRaw)) {
+    throw new SettingsError("settings.imports.allow: must be an array");
+  }
+  const importAllow = importAllowRaw.map((item, index) => {
+    const at = `settings.imports.allow[${index}]`;
+    if (typeof item === "string" && item !== "") {
+      return { module: item };
+    }
+    if (isRecord2(item) && typeof item.pattern === "string" && item.pattern !== "") {
+      rejectUnknownKeys(item, ["pattern", "flags"], at);
+      if (item.flags !== void 0 && typeof item.flags !== "string") {
+        throw new SettingsError(`${at}.flags: must be a string`);
+      }
+      return { regex: compile(item.pattern, item.flags, at) };
+    }
+    if (isRecord2(item) && typeof item.module === "string" && item.module !== "") {
+      rejectUnknownKeys(item, ["module", "names"], at);
+      const names = stringArray(item.names, `${at}.names`);
+      if (names.length === 0) {
+        throw new SettingsError(`${at}.names: must list at least one name`);
+      }
+      return { module: item.module, names };
+    }
+    throw new SettingsError(
+      `${at}: must be a package name, { pattern, flags? } or { module, names }`
+    );
+  });
+  const mutation = section(settings.mutation, ["maxTimeouts"], "settings.mutation");
+  if (mutation.maxTimeouts !== void 0 && !(Number.isInteger(mutation.maxTimeouts) && mutation.maxTimeouts >= 0)) {
+    throw new SettingsError("settings.mutation.maxTimeouts: must be an integer >= 0");
+  }
+  const stryker = section(settings.stryker, ["configFile", "reportFile"], "settings.stryker");
+  const lcov = section(settings.lcov, ["file", "summaryExclude"], "settings.lcov");
+  return {
+    gateExtensions,
+    specSuffixes,
+    specRewrite,
+    impureImports: imports.rules,
+    allowedImports,
+    impureNamedImports,
+    impurePaths: compileRules(DEFAULT_IMPURE_PATHS, settings.impurePaths, "settings.impurePaths").rules,
+    forbiddenSource: compileRules(
+      DEFAULT_FORBIDDEN_SOURCE,
+      settings.forbiddenSource,
+      "settings.forbiddenSource"
+    ).rules,
+    importAliases,
+    gateCommand,
+    selfcheckMode: selfcheck.mode ?? "all",
+    selfcheckFailurePattern,
+    strykerConfigFile: optionalString(stryker.configFile, "settings.stryker.configFile"),
+    strykerReportFile: optionalString(stryker.reportFile, "settings.stryker.reportFile") ?? DEFAULT_REPORT_FILE,
+    importMode: importsSection.mode ?? "blocklist",
+    importAllow,
+    maxTimeouts: mutation.maxTimeouts ?? null,
+    lcovFile: optionalString(lcov.file, "settings.lcov.file"),
+    lcovSummaryExclude: lcov.summaryExclude === void 0 ? [] : stringArray(lcov.summaryExclude, "settings.lcov.summaryExclude").map(
+      (pattern, index) => compile(pattern, void 0, `settings.lcov.summaryExclude[${index}]`)
+    )
+  };
+}
+
+// src/core/spec-path.ts
+function gateExtensionOf(gatePath, gateExtensions) {
+  const matching = gateExtensions.filter((extension) => gatePath.endsWith(extension)).sort((a, b) => b.length - a.length);
+  return matching[0] ?? null;
+}
+function suffixesFor(extension, settings) {
+  return settings.specSuffixes ?? [`.spec${extension}`, `.test${extension}`];
+}
+function specCandidatesFor(gatePath, settings) {
+  const extension = gateExtensionOf(gatePath, settings.gateExtensions);
+  if (extension === null) {
+    return [];
+  }
+  let base = gatePath.slice(0, -extension.length);
+  for (const { regex, to } of settings.specRewrite) {
+    base = base.replace(regex, to);
+  }
+  return suffixesFor(extension, settings).map((suffix) => base + suffix);
+}
+
+// src/fs.ts
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_path = __toESM(require("path"), 1);
+function existsExact(rootDir, relativePath, kind = "file") {
+  let current = rootDir;
+  for (const segment of relativePath.split("/")) {
+    if (segment === "" || segment === ".") {
+      continue;
+    }
+    let entries;
+    try {
+      entries = import_node_fs.default.readdirSync(current);
+    } catch {
+      return false;
+    }
+    if (!entries.includes(segment)) {
+      return false;
+    }
+    current = import_node_path.default.join(current, segment);
+  }
+  try {
+    return kind === "any" || import_node_fs.default.statSync(current).isFile();
+  } catch {
+    return false;
+  }
+}
+
+// src/load.ts
+function readManifest(dir) {
+  const absoluteDir = import_node_path2.default.resolve(dir);
+  const manifestPath = import_node_path2.default.join(absoluteDir, MANIFEST_FILE);
+  let text;
+  try {
+    text = import_node_fs2.default.readFileSync(manifestPath, "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      throw new ManifestError(`${MANIFEST_FILE} not found in ${absoluteDir}`);
+    }
+    throw new ManifestError(`cannot read ${manifestPath}: ${error.message}`);
+  }
+  const parsed = parseManifest(text);
+  let settings;
+  try {
+    settings = resolveSettings(parsed.settings);
+  } catch (error) {
+    if (error instanceof SettingsError) {
+      throw new ManifestError(`${MANIFEST_FILE}: ${error.message}`);
+    }
+    throw error;
+  }
+  const gates = parsed.gates.map((gate) => {
+    const specCandidates = specCandidatesFor(gate.path, settings);
+    const existingSpecs = specCandidates.filter((candidate) => existsExact(absoluteDir, candidate));
+    return {
+      ...gate,
+      specCandidates,
+      existingSpecs,
+      spec: existingSpecs[0] ?? specCandidates[0] ?? null
+    };
+  });
+  return {
+    dir: absoluteDir,
+    gates,
+    candidates: parsed.candidates,
+    settings,
+    violations: parsed.violations
+  };
+}
+function loadGates(dir = process.cwd()) {
+  const manifest = readManifest(dir);
+  if (manifest.violations.length > 0) {
+    throw new ManifestError(
+      `${MANIFEST_FILE} has problems (run "test-gates check"):
+` + manifest.violations.map((violation) => `  - ${violation.message}`).join("\n")
+    );
+  }
+  return manifest;
+}
+
+// src/shared.ts
+var import_node_path3 = __toESM(require("path"), 1);
+var import_node_url = require("url");
+function resolveRootDir(rootDir) {
+  if (rootDir === void 0) {
+    return process.cwd();
+  }
+  if (rootDir.startsWith("file:")) {
+    return import_node_path3.default.dirname((0, import_node_url.fileURLToPath)(rootDir));
+  }
+  return import_node_path3.default.resolve(rootDir);
+}
+
+// src/stryker.ts
+var WEAKENING_OPTIONS = ["ignoreStatic", "ignorers"];
+function createStrykerGatesConfig(options = {}) {
+  const { rootDir: rootDirOption, ...overrides } = options;
+  for (const option of WEAKENING_OPTIONS) {
+    if (overrides[option] !== void 0) {
+      throw new Error(
+        `test-gates: "${option}" takes mutants out of the evaluation. Allow equivalent mutants one by one in test-gates.json (equivalentMutants) instead`
+      );
+    }
+  }
+  const mutator = overrides.mutator;
+  if (Array.isArray(mutator?.excludedMutations) && mutator.excludedMutations.length > 0) {
+    throw new Error(
+      'test-gates: "mutator.excludedMutations" takes mutants out of the evaluation. Allow equivalent mutants one by one in test-gates.json (equivalentMutants) instead'
+    );
+  }
+  const manifest = loadGates(resolveRootDir(rootDirOption));
+  const reporters = Array.isArray(overrides.reporters) ? overrides.reporters : ["clear-text", "progress"];
+  const thresholds = typeof overrides.thresholds === "object" && overrides.thresholds !== null ? overrides.thresholds : { high: 100, low: 100 };
+  const jsonReporter = typeof overrides.jsonReporter === "object" && overrides.jsonReporter !== null ? overrides.jsonReporter : {};
+  return {
+    coverageAnalysis: "perTest",
+    incremental: true,
+    incrementalFile: "reports/stryker-incremental.json",
+    tempDirName: ".stryker-tmp",
+    clearTextReporter: { logTests: false, reportTests: false },
+    ...overrides,
+    mutate: manifest.gates.map((gate) => gate.path),
+    thresholds: { ...thresholds, break: null },
+    reporters: reporters.includes("json") ? reporters : [...reporters, "json"],
+    jsonReporter: { ...jsonReporter, fileName: manifest.settings.strykerReportFile }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createStrykerGatesConfig
+});

package/dist/stryker.d.cts

@@ -0,0 +1,16 @@
+interface StrykerGatesOptions {
+    /** Directory of test-gates.json: `import.meta.url` of the config file, or a directory path. */
+    rootDir?: string;
+    /** Any other Stryker option: testRunner, jest / vitest, concurrency, ignorePatterns, … */
+    [option: string]: unknown;
+}
+/**
+ * Stryker config for the gates: mutate exactly the gates, never fail on the score
+ * (`thresholds.break: null`), and write the JSON report that `test-gates mutation` judges.
+ *
+ * `mutate`, `thresholds.break` and `jsonReporter.fileName` are always set here, and `json` is
+ * always among the reporters. Options that take mutants out of the evaluation are rejected.
+ */
+declare function createStrykerGatesConfig(options?: StrykerGatesOptions): Record<string, unknown>;
+
+export { type StrykerGatesOptions, createStrykerGatesConfig };