paperlint 2.0.0

package/scripts/mutation-batteries-frozen.harness.mjs

@@ -0,0 +1,204 @@
+/**
+ * Colocated test for `scripts/mutation-batteries-frozen.mjs` — the shrink-only guard (#52).
+ * Run: `npx vigiles test scripts/mutation-batteries-frozen.harness.mjs`
+ *
+ * Both halves:
+ *   I.  QUIET on this repository — every battery on disk is listed, every listed one exists,
+ *       and every count matches. Plus a non-vacuity row: the walk found batteries at all.
+ *   II. RED on a planted tree — a new battery, a grown one, a shrunk one, a stale list entry
+ *       and an uncountable table are each named; an unchanged battery beside them is not.
+ *   III. The case counter on each table shape the repository actually uses.
+ *
+ * ⚠️ Assertions at the TOP LEVEL: `vigiles test` imports the file and counts "did not throw"
+ * as a pass.
+ */
+import assert from "node:assert/strict";
+import {
+  mkdirSync,
+  mkdtempSync,
+  realpathSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const ROOT = dirname(HERE);
+const { checkFrozen, countCases, findBatteries, FROZEN_FILE } = await import(
+  join(HERE, "mutation-batteries-frozen.mjs")
+);
+
+let n = 0;
+const check = (label, cond, detail = "") => {
+  n++;
+  assert.ok(cond, detail ? `${label}\n${detail}` : label);
+};
+
+// ── I. quiet on this repository ─────────────────────────────────────────────────────────
+{
+  const { problems, found, frozen } = checkFrozen(ROOT);
+  check(
+    "the walk finds batteries in this repository — otherwise the quiet below proves nothing",
+    found.length > 0,
+  );
+  check(
+    "this repository passes: nothing new, nothing grown, nothing stale",
+    problems.length === 0,
+    problems.join("\n"),
+  );
+  check(
+    "the frozen list names exactly the batteries on disk",
+    JSON.stringify(Object.keys(frozen).sort()) === JSON.stringify(found),
+  );
+}
+
+// ── II. red on a planted tree ───────────────────────────────────────────────────────────
+const driverBattery = (k) =>
+  `import { runMutations } from "./lib/mutation-driver.mjs";\n` +
+  `process.exit(runMutations({ root: ".", cases: [${Array.from({ length: k }, (_, i) => `{ name: "c${String(i)}" }`).join(", ")}] }));\n`;
+
+const TMP = realpathSync(mkdtempSync(join(tmpdir(), "rpp-frozen-h-")));
+process.on("exit", () => rmSync(TMP, { recursive: true, force: true }));
+mkdirSync(join(TMP, "scripts"), { recursive: true });
+mkdirSync(join(TMP, "src"), { recursive: true });
+mkdirSync(join(TMP, "node_modules", "dep"), { recursive: true });
+writeFileSync(join(TMP, "src", "same.mutations.mjs"), driverBattery(3));
+writeFileSync(join(TMP, "src", "grown.mutations.mjs"), driverBattery(4));
+writeFileSync(join(TMP, "src", "shrunk.mutations.mjs"), driverBattery(1));
+writeFileSync(join(TMP, "src", "planted.mutations.mjs"), driverBattery(1));
+writeFileSync(
+  join(TMP, "src", "opaque.mutations.mjs"),
+  `const ALL = [{}, {}];\nrunMutations({ cases: ALL.filter(Boolean) });\n`,
+);
+// Not the repository's own files: a dependency, and a symlinked view of `src/`.
+writeFileSync(
+  join(TMP, "node_modules", "dep", "theirs.mutations.mjs"),
+  driverBattery(9),
+);
+symlinkSync(join(TMP, "src"), join(TMP, "view"), "dir");
+writeFileSync(
+  join(TMP, FROZEN_FILE),
+  JSON.stringify({
+    batteries: {
+      "src/same.mutations.mjs": { cases: 3 },
+      "src/grown.mutations.mjs": { cases: 2 },
+      "src/shrunk.mutations.mjs": { cases: 2 },
+      "src/opaque.mutations.mjs": { cases: 2 },
+      "src/gone.mutations.mjs": { cases: 5 },
+    },
+  }),
+);
+{
+  const { problems, found } = checkFrozen(TMP);
+  const about = (file) => problems.filter((p) => p.startsWith(`${file}:`));
+  const all = problems.join("\n");
+  check(
+    "the walk skips node_modules and does not follow symlinks — each battery once",
+    JSON.stringify(found) ===
+      JSON.stringify([
+        "src/grown.mutations.mjs",
+        "src/opaque.mutations.mjs",
+        "src/planted.mutations.mjs",
+        "src/same.mutations.mjs",
+        "src/shrunk.mutations.mjs",
+      ]),
+    JSON.stringify(found),
+  );
+  check(
+    "🔴 a NEW battery fails, pointing at #52",
+    about("src/planted.mutations.mjs").some((p) =>
+      p.includes(
+        "new hand-written mutation batteries are not accepted, see #52",
+      ),
+    ),
+    all,
+  );
+  check(
+    "🔴 a battery that GREW fails, naming both counts",
+    about("src/grown.mutations.mjs").some(
+      (p) => p.includes("4 cases, frozen at 2") && p.includes("#52"),
+    ),
+    all,
+  );
+  check(
+    "🔴 a listed file that no longer exists fails: remove it from the frozen list",
+    about("src/gone.mutations.mjs").some(
+      (p) =>
+        p.includes("remove it from") &&
+        p.includes("the list must shrink with the code"),
+    ),
+    all,
+  );
+  check(
+    "a battery that SHRANK fails until its recorded count is lowered to the new one",
+    about("src/shrunk.mutations.mjs").some((p) =>
+      p.includes('lower "cases" to 1'),
+    ),
+    all,
+  );
+  check(
+    "a table the counter cannot read is a failure, never a guessed number",
+    about("src/opaque.mutations.mjs").some((p) =>
+      p.includes("cannot be counted"),
+    ),
+    all,
+  );
+  check(
+    "control: an unchanged battery beside them is not reported",
+    about("src/same.mutations.mjs").length === 0,
+    all,
+  );
+  check(
+    "exactly the five planted defects, nothing else",
+    problems.length === 5,
+    all,
+  );
+}
+
+// ── III. the counter, on each table shape in use ────────────────────────────────────────
+const cases = (src) => countCases(src, "x.mutations.mjs");
+check("inline `cases: [...]` literal", cases(driverBattery(3)).count === 3);
+check(
+  "`cases: TABLE.map(...)` counts TABLE",
+  cases(
+    `const T = [[1], [2], [3], [4]];\nrunMutations({ cases: T.map(([a]) => ({ a })) });`,
+  ).count === 4,
+);
+check(
+  "`const CASES = A.map(...)` then `cases: CASES`, and the shorthand `{ cases }`",
+  cases(
+    `const A = [1, 2];\nconst CASES = A.map((x) => x);\nrunMutations({ cases: CASES });`,
+  ).count === 2 &&
+    cases(`const cases = [1, 2, 3];\nrunMutations({ root, cases });`).count ===
+      3,
+);
+check(
+  "a spread of another const table adds its length",
+  cases(`const A = [1, 2];\nrunMutations({ cases: [...A, 3] });`).count === 3,
+);
+check(
+  "a self-contained battery: the loop over M counts, the results loop over `rows = []` does not",
+  cases(
+    `const M = [["a"], ["b"], ["c"]];\nconst rows = [];\nfor (const [x] of M) rows.push(x);\nfor (const r of rows) console.log(r);`,
+  ).count === 3,
+);
+check(
+  "a file with no table is an error, not zero",
+  "error" in cases(`console.log("hi");`),
+);
+check(
+  "two driver calls are ambiguous, not summed",
+  "error" in
+    cases(`runMutations({ cases: [1] });\nrunMutations({ cases: [2] });`),
+);
+check(
+  "findBatteries on this repository matches only `*.mutations.mjs` names",
+  findBatteries(ROOT).every((f) => f.endsWith(".mutations.mjs")),
+);
+
+console.log(
+  `✓ ${String(n)} assertions passed — mutation-batteries-frozen: quiet here, red on a new, grown, shrunk, stale or uncountable battery`,
+);

package/scripts/mutation-batteries-frozen.mjs

@@ -0,0 +1,238 @@
+#!/usr/bin/env node
+/**
+ * mutation-batteries-frozen.mjs — the hand-written mutation batteries may only SHRINK.
+ *
+ * Issue #52 retires the `*.mutations.mjs` pattern: string replacements of source lines, run
+ * through `lib/mutation-driver.mjs`. The idea behind it stays (a test must be seen going red
+ * when the code breaks); the vehicle is being replaced by a real mutation-testing tool, or by
+ * nothing — that is decided in #52, not here. Until the last battery is gone, this check holds
+ * the line so the pattern cannot grow back while it is being removed:
+ *
+ *   1. a `*.mutations.mjs` on disk that is not in the frozen list fails — a NEW battery;
+ *   2. a listed file that no longer exists fails — the list must shrink with the code;
+ *   3. a listed battery whose case table grew fails — no new cases in an old battery;
+ *   4. a listed battery whose case table shrank fails until the recorded count is lowered —
+ *      otherwise a removed case leaves room for a different one to be added later.
+ *
+ * The frozen list and the counts live in `mutation-batteries.frozen.json`, next to this file.
+ *
+ * ── HOW CASES ARE COUNTED, AND WHY NOT BY IMPORTING ───────────────────────────────────────
+ * A battery runs on import and ends with `process.exit`, so it cannot be imported to read its
+ * table. The file is PARSED instead (TypeScript's parser, already a dependency) and the case
+ * table is found structurally:
+ *
+ *   - batteries on the shared driver pass `cases` to `runMutations({ ... })`;
+ *   - the older self-contained batteries loop `for (const [...] of M)` over a top-level table.
+ *
+ * The table expression is then resolved to an array literal: an identifier goes to its
+ * top-level `const` initializer, `X.map(...)` goes to `X` (map keeps the length), and a spread
+ * `...X` inside a literal adds X's count. Anything else — `.filter`, a function call, a table
+ * built in a loop — is NOT guessed at: the battery is reported as uncountable, which fails the
+ * check. A count that silently stood for something else would be the green zero this repo
+ * keeps guarding against.
+ *
+ * Run: `node scripts/mutation-batteries-frozen.mjs` (also part of `npm run check`)
+ */
+import { readFileSync, readdirSync, existsSync } from "node:fs";
+import { dirname, join, relative, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import ts from "typescript";
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), "..");
+export const FROZEN_FILE = join("scripts", "mutation-batteries.frozen.json");
+
+// Build output and dependencies are not the repository's own files. Symlinks are not followed:
+// `.claude/skills/<name>` points back into `skills/`, and following it would list every skill
+// battery twice under two spellings.
+const SKIP = new Set(["node_modules", ".git", "dist", "_build"]);
+
+/** Every `*.mutations.mjs` under `root`, as sorted POSIX-style repo-relative paths. */
+export function findBatteries(root) {
+  const found = [];
+  const walk = (dir) => {
+    for (const e of readdirSync(dir, { withFileTypes: true })) {
+      if (e.isSymbolicLink() || SKIP.has(e.name)) continue;
+      const p = join(dir, e.name);
+      if (e.isDirectory()) walk(p);
+      else if (e.isFile() && e.name.endsWith(".mutations.mjs"))
+        found.push(relative(root, p).split(sep).join("/"));
+    }
+  };
+  walk(root);
+  return found.sort();
+}
+
+/**
+ * The number of cases in a battery's table, read from its source without running it.
+ * Returns `{ count }` or `{ error }` — never a guess.
+ */
+export function countCases(source, fileName = "battery.mjs") {
+  const sf = ts.createSourceFile(
+    fileName,
+    source,
+    ts.ScriptTarget.Latest,
+    true,
+    ts.ScriptKind.JS,
+  );
+
+  // Top-level `const NAME = <init>` — the only bindings a table name is resolved through.
+  const consts = new Map();
+  for (const st of sf.statements) {
+    if (!ts.isVariableStatement(st)) continue;
+    if (!(st.declarationList.flags & ts.NodeFlags.Const)) continue;
+    for (const d of st.declarationList.declarations)
+      if (ts.isIdentifier(d.name) && d.initializer)
+        consts.set(d.name.text, d.initializer);
+  }
+
+  const tables = [];
+  const visit = (node) => {
+    if (
+      ts.isCallExpression(node) &&
+      ts.isIdentifier(node.expression) &&
+      node.expression.text === "runMutations"
+    ) {
+      const arg = node.arguments[0];
+      const prop =
+        arg && ts.isObjectLiteralExpression(arg)
+          ? arg.properties.find((p) => p.name?.getText(sf) === "cases")
+          : undefined;
+      if (prop && ts.isPropertyAssignment(prop)) tables.push(prop.initializer);
+      else if (prop && ts.isShorthandPropertyAssignment(prop))
+        tables.push(prop.name);
+      else tables.push(null);
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(sf);
+
+  const size = (expr, seen = new Set()) => {
+    if (!expr) return null;
+    while (
+      ts.isParenthesizedExpression(expr) ||
+      ts.isAsExpression?.(expr) ||
+      ts.isSatisfiesExpression?.(expr)
+    )
+      expr = expr.expression;
+    if (ts.isArrayLiteralExpression(expr)) {
+      let n = 0;
+      for (const el of expr.elements) {
+        if (ts.isSpreadElement(el)) {
+          const inner = size(el.expression, seen);
+          if (inner === null) return null;
+          n += inner;
+        } else if (ts.isOmittedExpression(el)) return null;
+        else n += 1;
+      }
+      return n;
+    }
+    if (ts.isIdentifier(expr)) {
+      if (seen.has(expr.text) || !consts.has(expr.text)) return null;
+      seen.add(expr.text);
+      return size(consts.get(expr.text), seen);
+    }
+    if (
+      ts.isCallExpression(expr) &&
+      ts.isPropertyAccessExpression(expr.expression) &&
+      expr.expression.name.text === "map"
+    )
+      return size(expr.expression.expression, seen);
+    return null;
+  };
+
+  // The self-contained batteries: a top-level `for (... of TABLE)`. They also loop over a
+  // results accumulator (`const rows = []; for (const r of rows) ...`), which is empty in the
+  // source — so a candidate counts only when its table is non-empty.
+  if (tables.length === 0)
+    for (const st of sf.statements)
+      if (ts.isForOfStatement(st) && (size(st.expression) ?? 0) > 0)
+        tables.push(st.expression);
+
+  if (tables.length !== 1)
+    return {
+      error:
+        tables.length === 0
+          ? "no case table found (neither `runMutations({ cases })` nor a top-level `for ... of` over a non-empty table)"
+          : `${String(tables.length)} candidate case tables — which one counts is ambiguous`,
+    };
+
+  const count = size(tables[0]);
+  return count === null
+    ? {
+        error: `the case table (${tables[0]?.getText(sf).slice(0, 60) ?? "?"}) is not an array literal this check can count`,
+      }
+    : { count };
+}
+
+/**
+ * Compare what is on disk with the frozen list. Pure: every input is passed in.
+ * `found` — paths from findBatteries; `frozen` — `{ path: { cases } }`;
+ * `counted` — `{ path: { count } | { error } }` for the paths that exist.
+ */
+export function judge({ found, frozen, counted }) {
+  const problems = [];
+  const listed = new Set(Object.keys(frozen));
+  for (const f of found)
+    if (!listed.has(f))
+      problems.push(
+        `${f}: new hand-written mutation batteries are not accepted, see #52. ` +
+          `Record what a test guards as a comment above its assertion instead.`,
+      );
+  const onDisk = new Set(found);
+  for (const f of listed)
+    if (!onDisk.has(f))
+      problems.push(
+        `${f}: no longer exists — remove it from ${FROZEN_FILE} (the list must shrink with the code).`,
+      );
+  for (const f of found) {
+    if (!listed.has(f)) continue;
+    const want = frozen[f].cases;
+    const got = counted[f];
+    if (!got || "error" in got) {
+      problems.push(
+        `${f}: cases cannot be counted — ${got?.error ?? "not read"}. ` +
+          `The table must stay an array literal (optionally through a const or .map) so it can only shrink.`,
+      );
+      continue;
+    }
+    if (got.count > want)
+      problems.push(
+        `${f}: ${String(got.count)} cases, frozen at ${String(want)} — ` +
+          `no new cases in existing batteries, see #52.`,
+      );
+    else if (got.count < want)
+      problems.push(
+        `${f}: ${String(got.count)} cases, frozen at ${String(want)} — ` +
+          `lower "cases" to ${String(got.count)} in ${FROZEN_FILE} (the list must shrink with the code).`,
+      );
+  }
+  return problems;
+}
+
+/** Run the whole check against `root`. Returns the problems found. */
+export function checkFrozen(root = ROOT) {
+  const data = JSON.parse(readFileSync(join(root, FROZEN_FILE), "utf8"));
+  const frozen = data.batteries ?? {};
+  const found = findBatteries(root);
+  const counted = {};
+  for (const f of found) {
+    const p = join(root, f);
+    if (existsSync(p)) counted[f] = countCases(readFileSync(p, "utf8"), f);
+  }
+  return { problems: judge({ found, frozen, counted }), found, frozen };
+}
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const { problems, found, frozen } = checkFrozen(ROOT);
+  if (problems.length) {
+    console.error(
+      `🔴 mutation batteries are frozen and may only shrink (#52) — ${String(problems.length)} problem(s):`,
+    );
+    for (const p of problems) console.error(`   ${p}`);
+    process.exit(1);
+  }
+  const cases = Object.values(frozen).reduce((s, v) => s + v.cases, 0);
+  console.log(
+    `✓ ${String(found.length)} frozen mutation batteries, ${String(cases)} cases, none new, none grown (#52)`,
+  );
+}

package/scripts/mutation-batteries.frozen.json

@@ -0,0 +1,117 @@
+{
+  "issue": "https://github.com/zernie/research-paper-pipeline/issues/52",
+  "why": "Hand-written *.mutations.mjs batteries are being removed (#52). This list may only shrink: no new batteries, no new cases in existing ones. Delete a battery or a case, then delete its entry or lower its count here. Checked by scripts/mutation-batteries-frozen.mjs, part of npm run check.",
+  "batteries": {
+    "action.mutations.mjs": {
+      "cases": 6
+    },
+    "eslint-rules/doc-fields.mutations.mjs": {
+      "cases": 6
+    },
+    "eslint-rules/install-path-literals.mutations.mjs": {
+      "cases": 3
+    },
+    "eslint-rules/latex-language.mutations.mjs": {
+      "cases": 12
+    },
+    "eslint-rules/paper-research-question.mutations.mjs": {
+      "cases": 6
+    },
+    "eslint-rules/paper-stages.mutations.mjs": {
+      "cases": 9
+    },
+    "eslint-rules/paper-typography.mutations.mjs": {
+      "cases": 6
+    },
+    "eslint-rules/papers.mutations.mjs": {
+      "cases": 10
+    },
+    "eslint-rules/review-findings-cause.mutations.mjs": {
+      "cases": 4
+    },
+    "eslint-rules/temp-root-realpath.mutations.mjs": {
+      "cases": 5
+    },
+    "eslint-rules/tex-build.mutations.mjs": {
+      "cases": 21
+    },
+    "fixtures/real-markdown-paper/real-markdown-paper.mutations.mjs": {
+      "cases": 4
+    },
+    "hooks/hooks.mutations.mjs": {
+      "cases": 23
+    },
+    "lib/agent-cli-version.mutations.mjs": {
+      "cases": 6
+    },
+    "lib/mutation-driver.mutations.mjs": {
+      "cases": 3
+    },
+    "lib/paper-config.mutations.mjs": {
+      "cases": 7
+    },
+    "lib/skill-trigger-cases.mutations.mjs": {
+      "cases": 3
+    },
+    "scripts/check.mutations.mjs": {
+      "cases": 5
+    },
+    "scripts/rules-are-content-only.mutations.mjs": {
+      "cases": 3
+    },
+    "scripts/rules-see-files.mutations.mjs": {
+      "cases": 2
+    },
+    "skills/paper-pipeline/scripts/artifact-coverage.mutations.mjs": {
+      "cases": 22
+    },
+    "skills/paper-pipeline/scripts/consumer.mutations.mjs": {
+      "cases": 14
+    },
+    "skills/paper-pipeline/scripts/extract-ref-facts.mutations.mjs": {
+      "cases": 1
+    },
+    "skills/paper-pipeline/scripts/generated-code.mutations.mjs": {
+      "cases": 25
+    },
+    "skills/paper-pipeline/scripts/pipeline-check.mutations.mjs": {
+      "cases": 1
+    },
+    "skills/paper-pipeline/scripts/population-map.mutations.mjs": {
+      "cases": 2
+    },
+    "skills/paper-pipeline/scripts/provenance.mutations.mjs": {
+      "cases": 2
+    },
+    "skills/paper-pipeline/scripts/round-diff.mutations.mjs": {
+      "cases": 28
+    },
+    "skills/plan-paper-timeline/plan-paper-timeline.effects.mutations.mjs": {
+      "cases": 2
+    },
+    "skills/skill-contract.mutations.mjs": {
+      "cases": 22
+    },
+    "src/build.mutations.mjs": {
+      "cases": 11
+    },
+    "src/cli.mutations.mjs": {
+      "cases": 28
+    },
+    "src/doctor.mutations.mjs": {
+      "cases": 10
+    },
+    "src/hooks-settings.mutations.mjs": {
+      "cases": 7
+    },
+    "src/link-skills.mutations.mjs": {
+      "cases": 6
+    },
+    "src/new-paper.mutations.mjs": {
+      "cases": 4
+    },
+    "src/structure.mutations.mjs": {
+      "cases": 4
+    }
+  }
+}

package/scripts/release-config.test.ts

@@ -0,0 +1,90 @@
+/**
+ * The release pipeline, rendered locally from the real `.releaserc.json` with the installed
+ * toolchain — the same plugins, the same preset, the same versions `npx --no-install
+ * semantic-release` runs in release.yml.
+ *
+ * 🔴 WHY THIS EXISTS. In zernie/vigiles, from v16.0.0 to v31.0.0, every GitHub release shipped a
+ * header and nothing else (zernie/vigiles#282). `conventional-changelog-conventionalcommits` had
+ * moved to 10, which renders only through `conventional-changelog-writer@9`, while
+ * `@semantic-release/release-notes-generator` 14 still loads writer 8. The release went out with
+ * an empty body, and nothing checked the notes. This package copies that setup, so it copies the
+ * check: a dependency bump that breaks either half of the preset's job turns this red before it
+ * releases.
+ */
+import { describe, expect, test } from "vitest";
+import { readFileSync } from "node:fs";
+import { analyzeCommits } from "@semantic-release/commit-analyzer";
+import { generateNotes } from "@semantic-release/release-notes-generator";
+
+type PluginEntry = string | [string, Record<string, unknown>];
+const releaserc = JSON.parse(
+  readFileSync(new URL("../.releaserc.json", import.meta.url), "utf8"),
+) as { plugins: PluginEntry[] };
+
+/** The options `.releaserc.json` gives one plugin, exactly as semantic-release would pass them. */
+function optionsFor(name: string): Record<string, unknown> {
+  const entry = releaserc.plugins.find((p) =>
+    Array.isArray(p) ? p[0] === name : p === name,
+  );
+  if (entry === undefined) throw new Error(`${name} is not in .releaserc.json`);
+  return Array.isArray(entry) ? entry[1] : {};
+}
+
+const breaking = {
+  hash: "1111111111111111111111111111111111111111",
+  message:
+    "feat!: drop the markdown profile (#90)\n\n" +
+    "BREAKING CHANGE: the `markdown` venue profile is removed.",
+};
+/** `!` alone, no footer. The default (angular) preset ignores it; conventionalcommits makes it major. */
+const bangOnly = {
+  hash: "4444444444444444444444444444444444444444",
+  message: "feat!: rename the lint command",
+};
+const feature = {
+  hash: "2222222222222222222222222222222222222222",
+  message: "feat(cli): add a flag (#1)",
+};
+const fix = {
+  hash: "3333333333333333333333333333333333333333",
+  message: "fix(build): resolve the paper from the config root (#2)",
+};
+
+const context = {
+  cwd: process.cwd(),
+  options: {
+    repositoryUrl: "https://github.com/zernie/research-paper-pipeline",
+  },
+  lastRelease: { gitTag: "v1.0.0", version: "1.0.0" },
+  nextRelease: { gitTag: "v2.0.0", version: "2.0.0", type: "major" },
+  logger: { log() {}, error() {} },
+};
+
+describe("release config (.releaserc.json) with the installed toolchain", () => {
+  test("`feat!:` is a major (with or without a footer), `feat:` a minor, `fix:` a patch", async () => {
+    const analyzer = optionsFor("@semantic-release/commit-analyzer");
+    expect(
+      await analyzeCommits(analyzer, { ...context, commits: [breaking] }),
+    ).toBe("major");
+    expect(
+      await analyzeCommits(analyzer, { ...context, commits: [bangOnly] }),
+    ).toBe("major");
+    expect(
+      await analyzeCommits(analyzer, { ...context, commits: [feature] }),
+    ).toBe("minor");
+    expect(await analyzeCommits(analyzer, { ...context, commits: [fix] })).toBe(
+      "patch",
+    );
+  });
+
+  test("the notes carry the breaking change, the feature and the fix — not just a header", async () => {
+    const notes: string = await generateNotes(
+      optionsFor("@semantic-release/release-notes-generator"),
+      { ...context, commits: [breaking, feature, fix] },
+    );
+    expect(notes).toContain("BREAKING CHANGES");
+    expect(notes).toContain("the `markdown` venue profile is removed.");
+    expect(notes).toContain("add a flag");
+    expect(notes).toContain("resolve the paper from the config root");
+  });
+});