@t09tanaka/test-gates 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,759 @@
+import {
+  DEFAULT_FORBIDDEN_SOURCE,
+  DEFAULT_GATE_EXTENSIONS,
+  DEFAULT_IMPURE_IMPORTS,
+  DEFAULT_IMPURE_NAMED_IMPORTS,
+  DEFAULT_IMPURE_PATHS,
+  DEFAULT_REPORT_FILE,
+  EXCLUDE_ENV,
+  MANIFEST_FILE,
+  ManifestError,
+  existsExact,
+  gateExtensionOf,
+  gateSpecs,
+  isUsableEquivalentMutant,
+  judgeSelfcheck,
+  loadGates,
+  looksLikeSpec,
+  parseManifest,
+  readManifest,
+  readText,
+  resolveSettings,
+  validateEquivalentMutants
+} from "./chunk-XEKQKLKY.js";
+
+// src/commands/check.ts
+import fs from "fs";
+import path from "path";
+
+// src/core/imports.ts
+var FROM_STATEMENT = /(?:^|[\n;])[ \t]*(import|export)\s+(type\s+)?([\w$\s,{}*]*?)\s*\bfrom\s*(['"])([^'"\n]+)\4/g;
+var SIDE_EFFECT_IMPORT = /(?:^|[\n;])[ \t]*import\s*(['"])([^'"\n]+)\1/g;
+var CALL_IMPORT = /\b(?:require|import)\s*\(\s*(['"`])([^'"`\n]+)\1\s*\)/g;
+function lineAt(source, index) {
+  let line = 1;
+  for (let i = 0; i < index; i += 1) {
+    if (source[i] === "\n") {
+      line += 1;
+    }
+  }
+  return line;
+}
+function parseImports(source) {
+  const found = [];
+  for (const match of source.matchAll(FROM_STATEMENT)) {
+    const clause = match[3];
+    const module = match[5];
+    const braces = /\{([^}]*)\}/.exec(clause);
+    const names = braces ? braces[1].split(",").map((part) => part.trim()).filter((part) => part !== "" && !/^type\s/.test(part)).map((part) => part.split(/\s+as\s+/)[0].trim()) : [];
+    const outsideBraces = clause.replace(/\{[^}]*\}/, "").replace(/,/g, "").trim();
+    found.push({
+      module,
+      line: lineAt(source, match.index + match[0].lastIndexOf(module)),
+      typeOnly: match[2] !== void 0,
+      names,
+      whole: outsideBraces !== ""
+    });
+  }
+  for (const match of source.matchAll(SIDE_EFFECT_IMPORT)) {
+    const module = match[2];
+    found.push({
+      module,
+      line: lineAt(source, match.index + match[0].lastIndexOf(module)),
+      typeOnly: false,
+      names: [],
+      whole: false
+    });
+  }
+  for (const match of source.matchAll(CALL_IMPORT)) {
+    const module = match[2];
+    found.push({
+      module,
+      line: lineAt(source, match.index + match[0].lastIndexOf(module)),
+      typeOnly: false,
+      names: [],
+      whole: true
+    });
+  }
+  return found.sort((a, b) => a.line - b.line);
+}
+var COMPUTED_CALL_IMPORT = /(?<![.\w$])(?:require|import)\s*\(\s*(?!['"`\s)])/g;
+function findUncheckableImports(source) {
+  return [...source.matchAll(COMPUTED_CALL_IMPORT)].map((match) => lineAt(source, match.index));
+}
+
+// src/core/import-policy.ts
+var SCRIPT_EXTENSION = /\.[cm]?[jt]sx?$/;
+function isProjectImport(specifier, aliases) {
+  return specifier.startsWith(".") || aliases.some((alias) => specifier.startsWith(alias.prefix));
+}
+function resolveSpecifier(specifier, fromFile, aliases) {
+  let joined = null;
+  if (specifier.startsWith(".")) {
+    const slash = fromFile.lastIndexOf("/");
+    joined = slash === -1 ? specifier : `${fromFile.slice(0, slash)}/${specifier}`;
+  } else {
+    const alias = aliases.find((candidate) => specifier.startsWith(candidate.prefix));
+    if (alias) {
+      joined = alias.target + specifier.slice(alias.prefix.length);
+    }
+  }
+  if (joined === null) {
+    return null;
+  }
+  const segments = [];
+  for (const segment of joined.split("/")) {
+    if (segment === "..") {
+      segments.pop();
+    } else if (segment !== "." && segment !== "") {
+      segments.push(segment);
+    }
+  }
+  return segments.join("/").replace(SCRIPT_EXTENSION, "");
+}
+function matches(rule, specifier) {
+  if (rule.regex) {
+    return rule.regex.test(specifier);
+  }
+  return specifier === rule.module || specifier.startsWith(`${rule.module}/`);
+}
+function judgePackageImport(ref, allow) {
+  const rules = allow.filter((rule) => matches(rule, ref.module));
+  if (rules.length === 0) {
+    return `runtime import of "${ref.module}" is not in settings.imports.allow (allowlist mode allows relative imports, import aliases and listed packages only)`;
+  }
+  if (rules.some((rule) => rule.names === void 0)) {
+    return null;
+  }
+  const allowedNames = rules.flatMap((rule) => rule.names);
+  if (ref.whole) {
+    return `only ${allowedNames.join(", ")} may be imported from "${ref.module}", as named imports (settings.imports.allow)`;
+  }
+  const extra = ref.names.filter((name) => !allowedNames.includes(name));
+  return extra.length === 0 ? null : `runtime import of ${extra.join(", ")} from "${ref.module}" is not in settings.imports.allow (allowed: ${allowedNames.join(", ")})`;
+}
+function judgeProjectImport(target, impurePaths, gateExtensions) {
+  const candidates = [target, ...gateExtensions.map((extension) => target + extension)];
+  for (const rule of impurePaths) {
+    if (candidates.some((candidate) => rule.regex.test(candidate))) {
+      return rule.reason;
+    }
+  }
+  return null;
+}
+
+// src/core/scan.ts
+var IGNORE_DIRECTIVE = /\b(istanbul|c8|v8)\s+ignore\b/;
+var DECORATOR = /^\s*@[A-Za-z_$][\w$.]*\s*\(/;
+var STRYKER_COMMENT = /Stryker\s+(disable|restore)\b/;
+var DISABLED_TESTS = [
+  { regex: /\.\s*(skip|only|todo)\b/, label: ".skip / .only / .todo" },
+  {
+    regex: /\b(?:describe|it|test|suite)(?:\s*\.\s*\w+)*\s*\.\s*(?:skipIf|runIf|fails)\b/,
+    label: ".skipIf / .runIf / .fails"
+  },
+  {
+    regex: /\b(xit|xtest|xdescribe|fit|fdescribe)\s*[.(]/,
+    label: "xit / xtest / xdescribe / fit / fdescribe"
+  }
+];
+var MODULE_MOCK = /\b(?:jest|vi)\s*\.\s*(?:mock|doMock|unstable_mockModule|setMock)\s*\(\s*(?:import\s*\(\s*)?(['"`])([^'"`\n]+)\1/g;
+var SCRIPT_EXTENSION2 = /\.[cm]?[jt]sx?$/;
+function eachLine(source, visit) {
+  source.split("\n").forEach((line, index) => visit(line, index + 1));
+}
+function escapeRegExp(text) {
+  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function scanGateSource(gatePath, source, settings) {
+  const violations = [];
+  eachLine(source, (line, lineNumber) => {
+    if (DECORATOR.test(line)) {
+      violations.push({
+        file: gatePath,
+        line: lineNumber,
+        message: "decorator found (not a pure module). Move the file to candidates"
+      });
+    }
+    if (IGNORE_DIRECTIVE.test(line)) {
+      violations.push({ file: gatePath, line: lineNumber, message: "coverage ignore directive" });
+    }
+    if (STRYKER_COMMENT.test(line)) {
+      violations.push({
+        file: gatePath,
+        line: lineNumber,
+        message: "Stryker comment (disable / restore). Allow an equivalent mutant in test-gates.json (equivalentMutants) instead"
+      });
+    }
+    for (const rule of settings.forbiddenSource) {
+      if (rule.regex.test(line)) {
+        violations.push({ file: gatePath, line: lineNumber, message: rule.reason });
+      }
+    }
+  });
+  for (const imported of parseImports(source)) {
+    if (imported.typeOnly) {
+      continue;
+    }
+    const before = violations.length;
+    if (!settings.allowedImports.some((regex) => regex.test(imported.module))) {
+      for (const rule of settings.impureImports) {
+        if (rule.regex.test(imported.module)) {
+          violations.push({
+            file: gatePath,
+            line: imported.line,
+            message: `runtime import of "${imported.module}" (${rule.reason})`
+          });
+        }
+      }
+    }
+    for (const rule of settings.impureNamedImports) {
+      if (imported.module !== rule.module) {
+        continue;
+      }
+      const hit = rule.names.filter(
+        (name) => imported.names.includes(name) || imported.whole && new RegExp(`\\b${escapeRegExp(name)}\\b`).test(source)
+      );
+      if (hit.length > 0) {
+        violations.push({
+          file: gatePath,
+          line: imported.line,
+          message: `runtime use of ${hit.join(", ")} from "${rule.module}" (${rule.reason})`
+        });
+      }
+    }
+    if (settings.importMode === "allowlist" && violations.length === before) {
+      const reason = isProjectImport(imported.module, settings.importAliases) ? judgeProjectImport(
+        resolveSpecifier(imported.module, gatePath, settings.importAliases),
+        settings.impurePaths,
+        settings.gateExtensions
+      ) : judgePackageImport(imported, settings.importAllow);
+      if (reason !== null) {
+        violations.push({
+          file: gatePath,
+          line: imported.line,
+          message: isProjectImport(imported.module, settings.importAliases) ? `runtime import of "${imported.module}" (${reason})` : reason
+        });
+      }
+    }
+  }
+  if (settings.importMode === "allowlist") {
+    for (const line of findUncheckableImports(source)) {
+      violations.push({
+        file: gatePath,
+        line,
+        message: "require() / import() with a computed specifier cannot be checked (allowlist mode)"
+      });
+    }
+  }
+  return violations.sort((a, b) => a.line - b.line);
+}
+function scanSpecSource(gatePath, specPath, source, settings) {
+  const violations = [];
+  eachLine(source, (line, lineNumber) => {
+    if (IGNORE_DIRECTIVE.test(line)) {
+      violations.push({ file: specPath, line: lineNumber, message: "coverage ignore directive" });
+    }
+    for (const { regex, label } of DISABLED_TESTS) {
+      if (regex.test(line)) {
+        violations.push({
+          file: specPath,
+          line: lineNumber,
+          message: `${label} (a skipped or focused test)`
+        });
+      }
+    }
+  });
+  const gateModule = gatePath.replace(SCRIPT_EXTENSION2, "");
+  const gateDirectory = gateModule.replace(/\/index$/, "");
+  for (const match of source.matchAll(MODULE_MOCK)) {
+    const specifier = match[2];
+    const resolved = resolveSpecifier(specifier, specPath, settings.importAliases);
+    if (resolved === gateModule || resolved === gateDirectory) {
+      let line = 1;
+      for (let i = 0; i < match.index; i += 1) {
+        if (source[i] === "\n") {
+          line += 1;
+        }
+      }
+      violations.push({
+        file: specPath,
+        line,
+        message: `mocks the module under test ("${specifier}")`
+      });
+    }
+  }
+  return violations.sort((a, b) => a.line - b.line);
+}
+var STRYKER_WEAKENING = /\b(excludedMutations|ignoreStatic|ignorers)\b/;
+function scanStrykerConfig(configPath, source) {
+  const violations = [];
+  eachLine(source, (line, lineNumber) => {
+    const match = STRYKER_WEAKENING.exec(line);
+    if (match) {
+      violations.push({
+        file: configPath,
+        line: lineNumber,
+        message: `${match[1]} takes mutants out of the evaluation. Allow equivalent mutants one by one in test-gates.json instead`
+      });
+    }
+  });
+  return violations;
+}
+
+// src/commands/check.ts
+var STRYKER_CONFIG_NAMES = [
+  "stryker.gates.config.mjs",
+  "stryker.gates.config.js",
+  "stryker.gates.config.cjs",
+  "stryker.gates.config.json"
+];
+function findStrykerConfig(manifest) {
+  if (manifest.settings.strykerConfigFile !== null) {
+    return manifest.settings.strykerConfigFile;
+  }
+  return STRYKER_CONFIG_NAMES.find((name) => fs.existsSync(path.join(manifest.dir, name))) ?? null;
+}
+function isPlainRelativePath(file) {
+  return !path.isAbsolute(file) && !/^[A-Za-z]:/.test(file) && !file.includes("\\") && !file.split("/").some((segment) => segment === ".." || segment === "." || segment === "");
+}
+function checkGates(manifest) {
+  const { dir, settings } = manifest;
+  const violations = [...manifest.violations];
+  for (const gate of manifest.gates) {
+    if (!isPlainRelativePath(gate.path)) {
+      violations.push({
+        file: MANIFEST_FILE,
+        message: `${gate.path}: write the path relative to the subproject, with "/" and without ".."`
+      });
+      continue;
+    }
+    if (gateExtensionOf(gate.path, settings.gateExtensions) === null) {
+      violations.push({
+        file: gate.path,
+        message: `a gate must be one of ${settings.gateExtensions.join(" / ")} (settings.gateExtensions)`
+      });
+      continue;
+    }
+    if (looksLikeSpec(gate.path, settings)) {
+      violations.push({ file: gate.path, message: "a spec cannot be a gate" });
+      continue;
+    }
+    for (const rule of settings.impurePaths) {
+      if (rule.regex.test(gate.path)) {
+        violations.push({
+          file: gate.path,
+          message: `cannot be a gate (${rule.reason}). Move it to candidates`
+        });
+      }
+    }
+    if (!existsExact(dir, gate.path)) {
+      violations.push({
+        file: gate.path,
+        message: "file not found (the check is case-sensitive)"
+      });
+      continue;
+    }
+    violations.push(...scanGateSource(gate.path, readText(dir, gate.path), settings));
+    if (gate.specCandidates.length === 0) {
+      continue;
+    }
+    if (gate.existingSpecs.length === 0) {
+      violations.push({
+        file: gate.path,
+        message: `spec not found (looked for ${gate.specCandidates.join(", ")}; the check is case-sensitive)`
+      });
+      continue;
+    }
+    if (gate.existingSpecs.length > 1) {
+      violations.push({
+        file: gate.path,
+        message: `more than one spec (${gate.existingSpecs.join(", ")}). Keep one, or narrow settings.spec.suffixes`
+      });
+      continue;
+    }
+    const specPath = gate.existingSpecs[0];
+    violations.push(...scanSpecSource(gate.path, specPath, readText(dir, specPath), settings));
+  }
+  for (const candidate of manifest.candidates) {
+    if (!isPlainRelativePath(candidate.path) || !existsExact(dir, candidate.path, "any")) {
+      violations.push({
+        file: MANIFEST_FILE,
+        message: `${candidate.path}: candidate not found. Remove it, or fix the path`
+      });
+    }
+  }
+  const strykerConfig = findStrykerConfig(manifest);
+  if (strykerConfig !== null) {
+    if (!fs.existsSync(path.join(dir, strykerConfig))) {
+      violations.push({ file: strykerConfig, message: "Stryker config not found" });
+    } else {
+      violations.push(...scanStrykerConfig(strykerConfig, readText(dir, strykerConfig)));
+    }
+  }
+  return violations;
+}
+var VITEST_GATE_CONFIGS = ["ts", "mts", "cts", "js", "mjs", "cjs"].map(
+  (extension) => `vitest.gates.config.${extension}`
+);
+
+// src/core/mutation-result.ts
+var DETECTED = /* @__PURE__ */ new Set(["Killed", "Timeout"]);
+var SURVIVED = /* @__PURE__ */ new Set(["Survived", "NoCoverage"]);
+var NOT_EVALUABLE = /* @__PURE__ */ new Set(["RuntimeError", "CompileError"]);
+function normalizeCode(text) {
+  return text.replace(/\s+/g, " ").trim();
+}
+function normalizePath(file) {
+  return file.replace(/\\/g, "/").replace(/^\.\//, "");
+}
+function normalizeNewlines(text) {
+  return text.replace(/\r\n/g, "\n");
+}
+function sliceByLocation(source, location) {
+  const lines = source.split("\n");
+  const { start, end } = location;
+  const first = lines[start.line - 1];
+  const last = lines[end.line - 1];
+  if (first === void 0 || last === void 0 || start.column < 1 || end.column < 1 || end.line < start.line || end.line === start.line && end.column < start.column) {
+    return null;
+  }
+  if (start.line === end.line) {
+    return first.slice(start.column - 1, end.column - 1);
+  }
+  return [
+    first.slice(start.column - 1),
+    ...lines.slice(start.line, end.line - 1),
+    last.slice(0, end.column - 1)
+  ].join("\n");
+}
+function keyOf(mutator, original, replacement) {
+  return JSON.stringify([mutator, normalizeCode(original), normalizeCode(replacement)]);
+}
+function describeMutant(file, entry) {
+  const { mutant } = entry;
+  return {
+    file,
+    line: mutant.location.start.line,
+    column: mutant.location.start.column,
+    status: mutant.status,
+    mutator: mutant.mutatorName,
+    original: normalizeCode(entry.original),
+    replacement: normalizeCode(entry.replacement),
+    occurrence: entry.occurrence,
+    sameKeyCount: entry.sameKeyCount,
+    allowance: {
+      mutator: mutant.mutatorName,
+      original: normalizeCode(entry.original),
+      replacement: normalizeCode(entry.replacement),
+      ...entry.sameKeyCount > 1 ? { occurrence: entry.occurrence } : {},
+      reason: ""
+    }
+  };
+}
+function describeAllowance(entry) {
+  const occurrence = entry.occurrence === void 0 ? "" : ` / occurrence ${entry.occurrence}`;
+  return `${entry.mutator} / ${normalizeCode(entry.original)} \u2192 ${normalizeCode(entry.replacement)}${occurrence}`;
+}
+function judgeMutationReport(input) {
+  const violations = [];
+  const survivors = [];
+  const unexpectedTimeouts = [];
+  const summary = {
+    total: 0,
+    detected: 0,
+    timeout: 0,
+    allowed: 0,
+    notEvaluable: 0,
+    unallowed: 0,
+    expectedTimeout: 0
+  };
+  const files = /* @__PURE__ */ new Map();
+  for (const [file, result] of Object.entries(input.report.files ?? {})) {
+    files.set(normalizePath(file), result);
+  }
+  for (const gate of input.gates) {
+    const gatePath = normalizePath(gate.path);
+    const shapeViolations = validateEquivalentMutants(gate.path, gate.equivalentMutants);
+    violations.push(...shapeViolations);
+    violations.push(
+      ...validateEquivalentMutants(gate.path, gate.expectedTimeouts, "expectedTimeouts")
+    );
+    const result = files.get(gatePath);
+    if (!result || !Array.isArray(result.mutants) || result.mutants.length === 0) {
+      violations.push({
+        file: gate.path,
+        message: "no mutants in the report (the gate was not mutation tested)"
+      });
+      continue;
+    }
+    const diskSource = input.readSource(gate.path);
+    const source = result.source ?? diskSource;
+    if (source === void 0) {
+      violations.push({
+        file: gate.path,
+        message: "source is neither in the report nor readable on disk"
+      });
+      continue;
+    }
+    if (result.source !== void 0 && diskSource !== void 0 && normalizeNewlines(result.source) !== normalizeNewlines(diskSource)) {
+      violations.push({
+        file: gate.path,
+        message: "the report was made from a different version of this file. Run Stryker again"
+      });
+      continue;
+    }
+    const located = [];
+    const byKey = /* @__PURE__ */ new Map();
+    const sorted = [...result.mutants].sort(
+      (a, b) => a.location.start.line - b.location.start.line || a.location.start.column - b.location.start.column
+    );
+    let locationsValid = true;
+    for (const mutant of sorted) {
+      const original = sliceByLocation(normalizeNewlines(source), mutant.location);
+      if (original === null) {
+        violations.push({
+          file: gate.path,
+          line: mutant.location.start.line,
+          message: `the report location of a ${mutant.mutatorName} mutant is outside the source`
+        });
+        locationsValid = false;
+        continue;
+      }
+      const replacement = mutant.replacement ?? "";
+      const key = keyOf(mutant.mutatorName, original, replacement);
+      const group = byKey.get(key) ?? [];
+      const entry = {
+        mutant,
+        original,
+        replacement,
+        occurrence: group.length + 1,
+        sameKeyCount: 0
+      };
+      group.push(entry);
+      byKey.set(key, group);
+      located.push(entry);
+    }
+    for (const group of byKey.values()) {
+      for (const entry of group) {
+        entry.sameKeyCount = group.length;
+      }
+    }
+    if (!locationsValid) {
+      continue;
+    }
+    const claim = (field, entries, noun, accept) => {
+      const claimed = /* @__PURE__ */ new Set();
+      if (!Array.isArray(entries)) {
+        return claimed;
+      }
+      entries.forEach((entry, index) => {
+        if (!isUsableEquivalentMutant(entry)) {
+          return;
+        }
+        const at = `${gate.path}: ${field}[${index}] (${describeAllowance(entry)})`;
+        const group = byKey.get(keyOf(entry.mutator, entry.original, entry.replacement)) ?? [];
+        if (entry.occurrence === void 0 && group.length > 1) {
+          violations.push({
+            file: MANIFEST_FILE,
+            message: `${at}: matches ${group.length} mutants in the file. Add "occurrence" (1-based) to pick one`
+          });
+          return;
+        }
+        const target = group[(entry.occurrence ?? 1) - 1];
+        const refusal = target ? accept(target.mutant.status) : `stale ${noun} (no such mutant in this run). Remove it`;
+        if (!target || refusal !== null) {
+          violations.push({ file: MANIFEST_FILE, message: `${at}: ${refusal}` });
+          return;
+        }
+        if (claimed.has(target)) {
+          violations.push({
+            file: MANIFEST_FILE,
+            message: `${at}: another ${noun} already covers this mutant`
+          });
+          return;
+        }
+        claimed.add(target);
+      });
+      return claimed;
+    };
+    const allowed = claim(
+      "equivalentMutants",
+      gate.equivalentMutants,
+      "allowance",
+      (status) => SURVIVED.has(status) ? null : `stale allowance (the mutant is now ${status}). Remove it`
+    );
+    const expected = claim(
+      "expectedTimeouts",
+      gate.expectedTimeouts,
+      "entry",
+      (status) => SURVIVED.has(status) ? `the mutant ${status === "NoCoverage" ? "has no coverage" : "survived"} instead of timing out. Detect it with a test` : null
+    );
+    for (const entry of located) {
+      const { mutant } = entry;
+      summary.total += 1;
+      if (DETECTED.has(mutant.status)) {
+        summary.detected += 1;
+        if (mutant.status === "Timeout") {
+          summary.timeout += 1;
+          if (expected.has(entry)) {
+            summary.expectedTimeout += 1;
+          } else {
+            unexpectedTimeouts.push(describeMutant(gate.path, entry));
+          }
+        }
+      } else if (NOT_EVALUABLE.has(mutant.status)) {
+        summary.notEvaluable += 1;
+      } else if (SURVIVED.has(mutant.status)) {
+        if (allowed.has(entry)) {
+          summary.allowed += 1;
+          continue;
+        }
+        summary.unallowed += 1;
+        survivors.push(describeMutant(gate.path, entry));
+      } else {
+        violations.push({
+          file: gate.path,
+          line: mutant.location.start.line,
+          message: mutant.status === "Ignored" ? `a ${mutant.mutatorName} mutant was ignored. Taking mutants out with Stryker comments or mutator exclusions is not allowed` : `a ${mutant.mutatorName} mutant was not evaluated (status: ${mutant.status})`
+        });
+      }
+    }
+  }
+  if (summary.total === 0) {
+    violations.push({
+      file: MANIFEST_FILE,
+      message: "no mutants were evaluated (the mutation test ran on nothing)"
+    });
+  }
+  const maxTimeouts = input.maxTimeouts ?? null;
+  if (maxTimeouts !== null && unexpectedTimeouts.length > maxTimeouts) {
+    violations.push({
+      file: MANIFEST_FILE,
+      message: `${unexpectedTimeouts.length} mutant(s) timed out outside expectedTimeouts; settings.mutation.maxTimeouts allows ${maxTimeouts}`
+    });
+  }
+  return { violations, survivors, unexpectedTimeouts, summary };
+}
+function formatSurvivor(survivor) {
+  const occurrence = survivor.sameKeyCount > 1 ? ` / occurrence ${survivor.occurrence} of ${survivor.sameKeyCount}` : "";
+  return `${survivor.file}:${survivor.line}:${survivor.column} / ${survivor.mutator} / ${survivor.original} \u2192 ${survivor.replacement}${occurrence} (${survivor.status})`;
+}
+function formatSummary(summary) {
+  return `mutants ${summary.total} / detected ${summary.detected} (timeout ${summary.timeout}) / allowed equivalent ${summary.allowed} / not evaluable ${summary.notEvaluable} / unallowed survivors ${summary.unallowed}`;
+}
+
+// src/core/lcov.ts
+function normalizePath2(file, rootDir) {
+  let normalized = file.replace(/\\/g, "/");
+  if (rootDir !== void 0) {
+    const root = rootDir.replace(/\\/g, "/").replace(/\/+$/, "");
+    if (normalized.startsWith(`${root}/`)) {
+      normalized = normalized.slice(root.length + 1);
+    }
+  }
+  return normalized.replace(/^\.\//, "");
+}
+function parseLcov(text, rootDir) {
+  const files = /* @__PURE__ */ new Map();
+  let record = null;
+  const closeRecord = () => {
+    if (record && !record.hasDa) {
+      record.file.found += record.found;
+      record.file.hit += record.hit;
+    }
+    record = null;
+  };
+  for (const rawLine of text.split("\n")) {
+    const line = rawLine.trim();
+    if (line.startsWith("SF:")) {
+      closeRecord();
+      const path2 = normalizePath2(line.slice(3), rootDir);
+      const file = files.get(path2) ?? { lines: /* @__PURE__ */ new Map(), found: 0, hit: 0 };
+      files.set(path2, file);
+      record = { file, hasDa: false, found: 0, hit: 0 };
+    } else if (line === "end_of_record") {
+      closeRecord();
+    } else if (record) {
+      const open = record;
+      if (line.startsWith("DA:")) {
+        const [lineNumber, hits] = line.slice(3).split(",");
+        const number = Number(lineNumber);
+        const count = Number(hits);
+        if (Number.isInteger(number) && Number.isFinite(count)) {
+          open.hasDa = true;
+          open.file.lines.set(number, Math.max(open.file.lines.get(number) ?? 0, count));
+        }
+      } else if (line.startsWith("LF:")) {
+        open.found = Number(line.slice(3)) || 0;
+      } else if (line.startsWith("LH:")) {
+        open.hit = Number(line.slice(3)) || 0;
+      }
+    }
+  }
+  closeRecord();
+  const result = /* @__PURE__ */ new Map();
+  for (const [file, accumulator] of files) {
+    const uncovered = [...accumulator.lines.entries()].filter(([, hits]) => hits <= 0).map(([lineNumber]) => lineNumber).sort((a, b) => a - b);
+    result.set(file, {
+      found: accumulator.lines.size + accumulator.found,
+      hit: accumulator.lines.size - uncovered.length + accumulator.hit,
+      uncovered
+    });
+  }
+  return result;
+}
+function judgeLcov(gatePaths, coverage) {
+  const violations = [];
+  const results = [];
+  for (const gatePath of gatePaths) {
+    const file = coverage.get(normalizePath2(gatePath));
+    if (!file) {
+      violations.push({ file: gatePath, message: "no record in the lcov file" });
+      results.push({ path: gatePath, found: 0, hit: 0, ok: false });
+      continue;
+    }
+    if (file.found === 0) {
+      violations.push({ file: gatePath, message: "no instrumented lines in the lcov record" });
+      results.push({ path: gatePath, found: 0, hit: 0, ok: false });
+      continue;
+    }
+    const ok = file.hit === file.found;
+    if (!ok) {
+      const shown = file.uncovered.slice(0, 20).join(", ");
+      const more = file.uncovered.length > 20 ? ", \u2026" : "";
+      violations.push({
+        file: gatePath,
+        ...file.uncovered[0] === void 0 ? {} : { line: file.uncovered[0] },
+        message: `${file.hit}/${file.found} lines covered` + (shown === "" ? "" : ` (uncovered: ${shown}${more})`)
+      });
+    }
+    results.push({ path: gatePath, found: file.found, hit: file.hit, ok });
+  }
+  return { violations, results };
+}
+export {
+  DEFAULT_FORBIDDEN_SOURCE,
+  DEFAULT_GATE_EXTENSIONS,
+  DEFAULT_IMPURE_IMPORTS,
+  DEFAULT_IMPURE_NAMED_IMPORTS,
+  DEFAULT_IMPURE_PATHS,
+  DEFAULT_REPORT_FILE,
+  EXCLUDE_ENV,
+  MANIFEST_FILE,
+  ManifestError,
+  checkGates,
+  formatSummary,
+  formatSurvivor,
+  gateSpecs,
+  judgeLcov,
+  judgeMutationReport,
+  judgeSelfcheck,
+  loadGates,
+  normalizeCode,
+  parseLcov,
+  parseManifest,
+  readManifest,
+  resolveSettings,
+  sliceByLocation
+};