@hugojosefson/cli 0.11.0 → 0.13.0

package/esm/src/release/changelog-markdown.js

@@ -0,0 +1,41 @@
+export function changelogLines(text) {
+    const lines = [];
+    let offset = 0;
+    let comment = false;
+    let fence;
+    for (const line of text.split(/(?<=\n)/)) {
+        const value = line.replace(/\r?\n$/, "");
+        const marker = /^ {0,3}(`{3,}|~{3,})(.*)$/.exec(value);
+        if (fence) {
+            if (marker && marker[1][0] === fence.character &&
+                marker[1].length >= fence.length && !marker[2].trim())
+                fence = undefined;
+        }
+        else if (comment || value.replace(/(`+).*?\1/g, "").includes("<!--")) {
+            // Comments can contain example headings and fences; neither is structure.
+            const markers = value.replace(/(`+).*?\1/g, "").match(/<!--|-->/g) ?? [];
+            for (const token of markers) {
+                if (token === "<!--")
+                    comment = true;
+                else
+                    comment = false;
+            }
+        }
+        else if (marker) {
+            fence = { character: marker[1][0], length: marker[1].length };
+        }
+        else if (!/^ {4}|^\t/.test(value)) {
+            lines.push({ text: value, offset });
+        }
+        offset += line.length;
+    }
+    return lines;
+}
+export function changelogHeadings(text) {
+    return changelogLines(text).flatMap((line) => {
+        const heading = /^ {0,3}(#{1,6})[ \t]+(.+?)(?:[ \t]+#+)?[ \t]*$/.exec(line.text);
+        return heading
+            ? [{ title: heading[2], level: heading[1].length, offset: line.offset }]
+            : [];
+    });
+}

package/esm/src/release/changelog.js

@@ -1,7 +1,117 @@
 /** @module Immutable changelog release-section creation and insertion. */
+import { changelogHeadings } from "./changelog-markdown.js";
+import { CommitParser } from "conventional-commits-parser";
+import { writeChangelogString } from "conventional-changelog-writer";
+import { validateConventionalCommits } from "./conventional-commit.js";
+import { parseSemver } from "./semver.js";
+const sections = ["BREAKING CHANGE", "Features", "Fixes", "Other"];
+/** Validates the target used for commit and issue links. */
+export function changelogRepositoryUrl(repository) {
+    const parts = repository.split("/");
+    if (parts.length !== 2 ||
+        parts.some((part) => !/^[A-Za-z0-9_.-]+$/.test(part) || part === "." || part === ".."))
+        throw new TypeError("Changelog requires a GitHub owner/repository.");
+    return `https://github.com/${repository}`;
+}
+/** Groups validated full messages with the pinned Conventional Changelog libraries. */
+export async function createReleaseSection(version, commits, repository) {
+    const repositoryUrl = changelogRepositoryUrl(repository);
+    if (!parseSemver(version) || commits.length === 0 ||
+        commits.some((commit) => !/^[0-9a-f]{40}(?:[0-9a-f]{24})?$/.test(commit.hash))) {
+        throw new TypeError("Release section requires a version and full commit SHAs.");
+    }
+    const validated = validateConventionalCommits(commits.map((commit) => commit.message));
+    const parser = new CommitParser({
+        headerPattern: /^([a-z][a-z0-9-]*)(?:\(([\w./@ -]+)\))?!?: (.+)$/,
+        headerCorrespondence: ["type", "scope", "subject"],
+        noteKeywords: ["BREAKING CHANGE", "BREAKING-CHANGE"],
+    });
+    const parsed = commits.map((commit, index) => {
+        const data = parser.parse(commit.message);
+        const references = [
+            ...data.references,
+            ...data.notes.flatMap((note) => parser.parse(`fix: note\n\n${note.text}`).references),
+        ];
+        const refs = new Map();
+        for (const reference of references) {
+            if (!/^\d+$/.test(reference.issue))
+                continue;
+            const target = reference.repository
+                ? `${reference.owner ?? repository.split("/")[0]}/${reference.repository}`
+                : repository;
+            const label = `${reference.owner ? `${reference.owner}/` : ""}${reference.repository ?? ""}#${reference.issue}`;
+            refs.set(label, `${changelogRepositoryUrl(target)}/issues/${reference.issue}`);
+        }
+        const used = new Set();
+        const subject = linkReferences(data.subject ?? "", refs, used);
+        const notes = data.notes.map((note) => ({
+            ...note,
+            text: linkReferences(note.text, refs, used),
+        }));
+        const extraLinks = [...refs].flatMap(([label, url]) => {
+            if (used.has(url))
+                return [];
+            used.add(url);
+            return [`[${label}](${url})`];
+        });
+        return {
+            ...data,
+            hash: commit.hash,
+            scope: data.scope ?? "",
+            subject,
+            notes,
+            type: validated[index].breaking
+                ? "BREAKING CHANGE"
+                : data.type === "feat"
+                    ? "Features"
+                    : data.type === "fix"
+                        ? "Fixes"
+                        : "Other",
+            links: [
+                `[${commit.hash.slice(0, 7)}](${repositoryUrl}/commit/${commit.hash})`,
+                ...extraLinks,
+            ],
+        };
+    });
+    const text = await writeChangelogString(parsed, { version }, {
+        // Preserve full hashes, every commit type, and the supplied range order.
+        transform: (commit) => commit,
+        ignoreReverted: false,
+        generateOn: () => false,
+        groupBy: "type",
+        commitsSort: (a, b) => compare(a.scope, b.scope),
+        commitGroupsSort: (a, b) => sections.indexOf(a.title) - sections.indexOf(b.title),
+        template: (context) => {
+            let output = `## ${version}\n\n`;
+            for (const group of context.commitGroups ?? []) {
+                output += `### ${group.title}\n\n`;
+                let scope;
+                for (const commit of group.commits) {
+                    if (commit.scope !== scope) {
+                        if (scope !== undefined)
+                            output += "\n";
+                        scope = commit.scope;
+                        if (scope)
+                            output += `#### ${scope}\n\n`;
+                    }
+                    output += `- ${commit.subject} (${commit.links.join(", ")})\n`;
+                    for (const note of commit.notes) {
+                        output += `\n  ${note.text.replaceAll("\n", "\n  ")}\n`;
+                    }
+                }
+                output += "\n";
+            }
+            return output;
+        },
+    });
+    return `${text.trimEnd()}\n\n`;
+}
+function compare(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
 const heading = "# Changelog";
 /** Creates a deterministic release heading and list from validated commit subjects. */
-export function createReleaseSection(version, subjects) {
+export function createLegacyReleaseSection(version, subjects) {
     if (!version || subjects.some((subject) => !subject)) {
         throw new TypeError("Release section requires a version and non-empty subjects.");
     }
@@ -15,12 +125,22 @@ export function createChangelogInsertion(oldText, releaseSection) {
     if (!oldText) {
         return { offset: 0, text: `${heading}\n\n${releaseSection}` };
     }
-    if (!oldText.startsWith(heading) || !/^# Changelog(?:\r?\n|$)/.test(oldText)) {
-        throw new TypeError("Existing changelog must start with # Changelog.");
-    }
-    const section = /\n## [^\n]+(?:\r?\n|$)/.exec(oldText);
-    const offset = section ? section.index + 1 : oldText.length;
-    return { offset, text: releaseSection };
+    const allHeadings = changelogHeadings(oldText);
+    const headings = allHeadings.filter((item) => item.level === 2);
+    const section = headings.find((item) => parseSemver(item.title) || /^\[?unreleased\]?$/i.test(item.title)) ?? headings[0];
+    // Without release headings, insert just after a leading title. Never enter a code block.
+    const titleEnd = allHeadings[0]?.level === 1 && allHeadings[0]?.offset === 0
+        ? /^(?:[^\n]*\n)(?:[ \t]*\r?\n)*/.exec(oldText)?.[0].length ??
+            oldText.length
+        : 0;
+    const offset = section?.offset ?? titleEnd;
+    const prefix = oldText.slice(0, offset);
+    const separator = !prefix || prefix.endsWith("\n\n")
+        ? ""
+        : prefix.endsWith("\n")
+            ? "\n"
+            : "\n\n";
+    return { offset, text: separator + releaseSection };
 }
 /** Applies the recorded insertion and leaves every old byte outside it unchanged. */
 export function applyChangelogInsertion(oldText, insertion) {
@@ -31,3 +151,31 @@ export function applyChangelogInsertion(oldText, insertion) {
     return oldText.slice(0, insertion.offset) + insertion.text +
         oldText.slice(insertion.offset);
 }
+/** Leave existing Markdown links, code and URLs intact while linking plain references. */
+function linkReferences(text, references, used) {
+    return text.replace(/\[[^\]]*\]\([^)]*\)|`[^`]*`|https?:\/\/\S+|(?<![\w/])(?:[\w.-]+(?:\/[\w.-]+)?)?#\d+\b/g, (token) => {
+        const url = references.get(token);
+        if (!url) {
+            for (const target of references.values()) {
+                if (token.endsWith(`](${target})`))
+                    used.add(target);
+            }
+            return token;
+        }
+        used.add(url);
+        return `[${token}](${url})`;
+    });
+}
+/** The original insertion algorithm remains frozen for exact legacy recovery. */
+export function createLegacyChangelogInsertion(oldText, releaseSection) {
+    if (!oldText)
+        return { offset: 0, text: `${heading}\n\n${releaseSection}` };
+    if (!/^# Changelog(?:\r?\n|$)/.test(oldText)) {
+        throw new TypeError("Existing changelog must start with # Changelog.");
+    }
+    const section = /\n## [^\n]+(?:\r?\n|$)/.exec(oldText);
+    return {
+        offset: section ? section.index + 1 : oldText.length,
+        text: releaseSection,
+    };
+}

package/esm/src/release/format-changelog.js

@@ -0,0 +1,15 @@
+/** Format new changelog text without rewriting previous content. */
+import { createChangelogInsertion, } from "./changelog.js";
+import { runOrThrow } from "./release-process.js";
+export async function formatChangelogSection(process, section) {
+    return await runOrThrow(process, "deno", ["fmt", "--ext=md", "-"], {
+        stdin: section,
+    });
+}
+export async function formatChangelogInsertion(process, oldText, section) {
+    const formatted = await formatChangelogSection(process, section);
+    const insertion = createChangelogInsertion(oldText, `${formatted.trimEnd()}\n\n`);
+    return insertion.offset === oldText.length
+        ? { ...insertion, text: `${insertion.text.trimEnd()}\n` }
+        : insertion;
+}

package/esm/src/release/migrate-changelog.js

@@ -0,0 +1,92 @@
+/** Read-only reconstruction of supported release sections from immutable Git ranges. */
+import { changelogHeadings } from "./changelog-markdown.js";
+import { parse } from "jsonc-parser";
+import { createLegacyReleaseSection, createReleaseSection, } from "./changelog.js";
+import { formatChangelogSection } from "./format-changelog.js";
+import { commitMessages, releaseTags } from "./release-history.js";
+import { selectPreviousRelease } from "./previous-release.js";
+import { runOrThrow } from "./release-process.js";
+import { parseSemver } from "./semver.js";
+export async function migrateChangelog(oldText, repository, process) {
+    const headings = changelogHeadings(oldText).filter((heading) => heading.level === 2);
+    const tags = await releaseTags(process, "HEAD");
+    const seen = new Set();
+    const replacements = [];
+    for (const [index, heading] of headings.entries()) {
+        const version = heading.title;
+        if (!parseSemver(version))
+            continue;
+        if (seen.has(version)) {
+            throw new Error(`Duplicate changelog release ${version}.`);
+        }
+        seen.add(version);
+        const tag = tags.find((tag) => tag.name === version);
+        if (!tag?.lightweight || !tag.targetIsAncestor) {
+            throw new Error(`Release ${version} needs its original lightweight ancestor tag; fetch the complete Git history and tags.`);
+        }
+        const subject = (await runOrThrow(process, "git", [
+            "show",
+            "-s",
+            "--format=%s",
+            tag.target,
+        ])).trimEnd();
+        const parents = (await runOrThrow(process, "git", [
+            "rev-list",
+            "--parents",
+            "-n",
+            "1",
+            tag.target,
+        ])).trim().split(" ");
+        if (subject !== `chore(release): ${version}` || parents.length !== 2) {
+            throw new Error(`Release ${version} has no recognized single-parent release boundary.`);
+        }
+        const parent = parents[1];
+        const configs = [];
+        for (const path of ["deno.json", "deno.jsonc"]) {
+            const result = await process.run("git", ["show", `${parent}:${path}`]);
+            if (result.success)
+                configs.push(new TextDecoder().decode(result.stdout));
+        }
+        const errors = [];
+        const config = configs.length === 1
+            ? parse(configs[0], errors, { allowTrailingComma: true })
+            : undefined;
+        if (!config || errors.length || typeof config.version !== "string") {
+            throw new Error(`Release ${version} has no unambiguous previous version config.`);
+        }
+        const previous = selectPreviousRelease(await releaseTags(process, parent), config.version);
+        if (previous.kind === "conflict" || previous.kind === "version-mismatch") {
+            throw new Error(`Release ${version} has ambiguous previous release tags.`);
+        }
+        const range = previous.kind === "tag"
+            ? `${previous.tag.target}..${parent}`
+            : parent;
+        const ids = (await runOrThrow(process, "git", ["rev-list", "--reverse", range]))
+            .trim().split("\n");
+        const messages = await commitMessages(process, ids);
+        const grouped = await formatChangelogSection(process, await createReleaseSection(version, ids.map((hash, i) => ({ hash, message: messages[i] })), repository));
+        const legacy = await formatChangelogSection(process, createLegacyReleaseSection(version, messages.map((message) => message.split("\n")[0])));
+        const start = heading.offset;
+        const end = headings[index + 1]?.offset ?? oldText.length;
+        const existing = oldText.slice(start, end);
+        if (existing.trimEnd() !== legacy.trimEnd() &&
+            existing.trimEnd() !== grouped.trimEnd()) {
+            throw new Error(`Release ${version} contains custom or mismatched text. Keep extending this changelog, or reconcile that section with Git history before migration.`);
+        }
+        // Retain the section's exact separating whitespace and all non-release text.
+        replacements.push({
+            start,
+            end,
+            text: grouped.trimEnd() + existing.slice(existing.trimEnd().length),
+        });
+    }
+    if (!seen.size) {
+        throw new Error("No supported release sections found. Keep extending this changelog; migration supports ## <SemVer> sections from hj releases.");
+    }
+    let result = oldText;
+    for (const replacement of replacements.reverse()) {
+        result = result.slice(0, replacement.start) + replacement.text +
+            result.slice(replacement.end);
+    }
+    return result;
+}

package/esm/src/release/publish-github.js

@@ -1,3 +1,5 @@
+/** Idempotent GitHub Release publication. */
+import { changelogHeadings } from "./changelog-markdown.js";
 import { processText } from "./release-process.js";
 import { confirmPublication, } from "./confirm-publication.js";
 import { parseSemver } from "./semver.js";
@@ -32,12 +34,14 @@ export async function publishGithub(input) {
         throw new Error("GitHub Release creation was not confirmed.");
 }
 export function changelogSection(text, version) {
-    const escaped = version.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    const matches = [...text.matchAll(new RegExp(`^## ${escaped}\\r?\\n[\\s\\S]*?(?=^## |(?![\\s\\S]))`, "gm"))];
+    const headings = changelogHeadings(text).filter((heading) => heading.level === 2);
+    const matches = headings.flatMap((heading, index) => heading.title === version
+        ? [{ start: heading.offset, end: headings[index + 1]?.offset }]
+        : []);
     if (matches.length !== 1) {
         throw new TypeError("Applicable changelog section is missing or ambiguous.");
     }
-    return matches[0][0];
+    return text.slice(matches[0].start, matches[0].end);
 }
 export function githubReleaseApi(process, repository) {
     if (!/^([A-Za-z0-9_.-]+)\/([A-Za-z0-9_.-]+)$/.test(repository)) {

package/esm/src/release/publish-npm.js

@@ -1,4 +1,5 @@
 /** Independent npm publication of a checked, reproducible build artifact. */
+import { validNpmPublishName } from "../package/npm-name.js";
 import * as fs from "node:fs/promises";
 import { isDeepStrictEqual } from "node:util";
 import { confirmPublication, } from "./confirm-publication.js";
@@ -75,8 +76,7 @@ export async function publishNpm(input) {
         throw new TypeError("npm publication requires a clean release checkout.");
     }
     const config = await versionConfig(input.files, release.version);
-    if (typeof config.name !== "string" ||
-        !/^@[a-z0-9][a-z0-9._-]*\/[a-z0-9][a-z0-9._-]*$/.test(config.name)) {
+    if (!validNpmPublishName(config.name)) {
         throw new TypeError("npm publication requires a scoped package name in Deno config.");
     }
     const tasks = object(config.tasks);

package/esm/src/release/publish-tag-prepare.js

@@ -1,12 +1,14 @@
 /** @module Read-only-token preparation routes for tag publication. */
 import * as fs from "node:fs/promises";
+import { commitMessages, releaseTags } from "./release-history.js";
+import { formatChangelogInsertion } from "./format-changelog.js";
 import { requiredEnvironment } from "./release-environment.js";
 import { digestBytes } from "../repository/digest-bytes.js";
 import { LocalFileReader } from "../repository/local-file-reader.js";
 import { LocalGitReader } from "../repository/local-git-reader.js";
 import { inspectDenoConfig } from "../features/deno-config.js";
 import { githubReleasePublisherFeatures } from "../features/github-release-publish-feature.js";
-import { applyChangelogInsertion, createChangelogInsertion, createReleaseSection, } from "./changelog.js";
+import { applyChangelogInsertion, changelogRepositoryUrl, createLegacyChangelogInsertion, createLegacyReleaseSection, createReleaseSection, } from "./changelog.js";
 import { validateConventionalCommits } from "./conventional-commit.js";
 import { nextVersion } from "./fork-version.js";
 import { validateGithubOutputSize } from "./github-output.js";
@@ -29,14 +31,14 @@ export async function publishTagPrepare(root, environment, process) {
         return { output: "Source commits are valid.\n", releaseNeeded: false };
     }
     if (route === "recovery") {
-        return await prepareRecovery(root, environment, process);
+        return await prepareRecovery(root, environment, process, releaseRepository(environment));
     }
     if (route !== "usual") {
         throw new Error("HJ_RELEASE_ROUTE must be source-validation, usual, or recovery.");
     }
-    return await prepareUsual(root, environment, process);
+    return await prepareUsual(root, environment, process, releaseRepository(environment));
 }
-async function prepareUsual(root, environment, process) {
+async function prepareUsual(root, environment, process, repository) {
     await requireClean(process);
     await runOrThrow(process, "git", [
         "fetch",
@@ -55,7 +57,7 @@ async function prepareUsual(root, environment, process) {
     if (config.kind !== "config" || typeof config.value.version !== "string")
         throw new Error("One Deno config with a string version is required.");
     const tags = await releaseTags(process, selectedSha);
-    await requireNoUntaggedRelease(root, process, selectedSha, tags);
+    await requireNoUntaggedRelease(root, process, selectedSha, tags, repository);
     await runOrThrow(process, "git", ["switch", "--detach", selectedSha]);
     const previous = selectPreviousRelease(tags, config.value.version);
     if (previous.kind === "conflict") {
@@ -85,16 +87,15 @@ async function prepareUsual(root, environment, process) {
     if (!releaseType)
         throw new Error("The release range is empty.");
     const version = await nextVersion(previousVersion, releaseType);
-    await runOrThrow(process, "deno", ["task", "all"]);
     await requireClean(process);
     const previousVersionText = config.text;
     const versionText = updateDenoConfigVersion(config.path, config.text, version);
     const changelog = await observeOptionalFile(files, changelogPath);
-    const releaseSection = createReleaseSection(version, conventional.map((commit) => commit.subject));
-    const insertion = createChangelogInsertion(changelog?.content ?? "", releaseSection);
+    const releaseSection = await createReleaseSection(version, commits.map((hash, index) => ({ hash, message: messages[index] })), repository);
+    const insertion = await formatChangelogInsertion(process, changelog?.content ?? "", releaseSection);
     await fs.writeFile(new URL(config.path, root), versionText);
     await fs.writeFile(new URL(changelogPath, root), applyChangelogInsertion(changelog?.content ?? "", insertion));
-    await runOrThrow(process, "deno", ["fmt", config.path, changelogPath]);
+    await runOrThrow(process, "deno", ["fmt", config.path]);
     const formattedVersion = await fs.readFile(new URL(config.path, root), "utf8");
     const formattedChangelog = await fs.readFile(new URL(changelogPath, root), "utf8");
     const formattedInsertion = retainedInsertion(changelog?.content ?? "", formattedChangelog, insertion.offset);
@@ -171,7 +172,7 @@ async function runReleaseContributions(root, files, process) {
     }
 }
 /** Rebuilds a committed release; it intentionally never creates a ref or tag. */
-async function prepareRecovery(root, environment, process) {
+async function prepareRecovery(root, environment, process, repository) {
     const version = requiredEnvironment(environment, "HJ_RELEASE_TAG");
     if (!parseSemver(version)) {
         throw new Error("HJ_RELEASE_TAG must be an exact nonempty SemVer value.");
@@ -205,7 +206,7 @@ async function prepareRecovery(root, environment, process) {
         }
         let bundle;
         try {
-            bundle = await rebuildRelease(root, process, parents[1], commit);
+            bundle = await rebuildRelease(root, process, parents[1], commit, repository);
         }
         finally {
             await restoreRecoveryWorktree(process, main, changelogPath);
@@ -236,7 +237,7 @@ async function prepareRecovery(root, environment, process) {
         releaseNeeded: true,
     };
 }
-async function requireNoUntaggedRelease(root, process, selectedSha, tags) {
+async function requireNoUntaggedRelease(root, process, selectedSha, tags, repository) {
     const commits = lines(await runOrThrow(process, "git", ["rev-list", "--reverse", selectedSha]));
     const found = [];
     for (const commit of commits) {
@@ -257,7 +258,7 @@ async function requireNoUntaggedRelease(root, process, selectedSha, tags) {
         }
         let bundle;
         try {
-            bundle = await rebuildRelease(root, process, parents[1], commit);
+            bundle = await rebuildRelease(root, process, parents[1], commit, repository);
         }
         finally {
             await restoreRecoveryWorktree(process, selectedSha, changelogPath);
@@ -279,7 +280,7 @@ async function requireNoUntaggedRelease(root, process, selectedSha, tags) {
         throw new Error(`Release ${found[0].version} is untagged; start the tag workflow with ${found[0].version}.`);
     }
 }
-async function rebuildRelease(root, process, parent, release) {
+async function rebuildRelease(root, process, parent, release, repository) {
     await runOrThrow(process, "git", ["switch", "--detach", parent]);
     const files = new LocalFileReader(root, false);
     const config = await inspectDenoConfig({ files });
@@ -299,29 +300,59 @@ async function rebuildRelease(root, process, parent, release) {
         : previous.version;
     const range = previousTagTarget ? `${previousTagTarget}..${parent}` : parent;
     const commitIds = lines(await runOrThrow(process, "git", ["rev-list", "--reverse", range]));
-    const conventional = validateConventionalCommits(await commitMessages(process, commitIds));
+    const messages = await commitMessages(process, commitIds);
+    const conventional = validateConventionalCommits(messages);
     const releaseType = selectReleaseType(conventional);
     if (!releaseType)
         throw new Error("Recovery release range is empty.");
     const version = await nextVersion(previousVersion, releaseType);
     const oldChangelog = await observeOptionalFile(files, changelogPath);
     const versionText = updateDenoConfigVersion(config.path, config.text, version);
-    const insertion = createChangelogInsertion(oldChangelog?.content ?? "", createReleaseSection(version, conventional.map((item) => item.subject)));
-    await fs.writeFile(new URL(config.path, root), versionText);
-    await fs.writeFile(new URL(changelogPath, root), applyChangelogInsertion(oldChangelog?.content ?? "", insertion));
-    await runOrThrow(process, "deno", ["fmt", config.path, changelogPath]);
-    const formattedVersion = await fs.readFile(new URL(config.path, root), "utf8");
-    const formattedChangelog = await fs.readFile(new URL(changelogPath, root), "utf8");
-    const formattedInsertion = retainedInsertion(oldChangelog?.content ?? "", formattedChangelog, insertion.offset);
-    const paths = await worktreeChangedPaths(process);
+    const sections = [
+        await createReleaseSection(version, commitIds.map((hash, index) => ({
+            hash,
+            message: messages[index],
+        })), repository),
+        createLegacyReleaseSection(version, conventional.map((item) => item.subject)),
+    ];
     const expectedPaths = [config.path, changelogPath];
-    if (paths.length !== 2 || !expectedPaths.every((path) => paths.includes(path)))
-        throw new Error("Recovery candidate changed an unexpected path.");
-    const candidateDigest = await candidateTreeDigest(process, parent, expectedPaths);
     const releaseDigest = await releaseTreeIndexDigest(process, release);
-    if (candidateDigest !== releaseDigest) {
+    let candidate;
+    // Compatibility is exact: neither format may waive the tree or path checks.
+    for (const [index, section] of sections.entries()) {
+        const insertion = index === 0
+            ? await formatChangelogInsertion(process, oldChangelog?.content ?? "", section)
+            : createLegacyChangelogInsertion(oldChangelog?.content ?? "", section);
+        await fs.writeFile(new URL(config.path, root), versionText);
+        await fs.writeFile(new URL(changelogPath, root), applyChangelogInsertion(oldChangelog?.content ?? "", insertion));
+        await runOrThrow(process, "deno", [
+            "fmt",
+            config.path,
+            ...(index === 1 ? [changelogPath] : []),
+        ]);
+        const formattedVersion = await fs.readFile(new URL(config.path, root), "utf8");
+        const formattedChangelog = await fs.readFile(new URL(changelogPath, root), "utf8");
+        const formattedInsertion = retainedInsertion(oldChangelog?.content ?? "", formattedChangelog, insertion.offset);
+        const paths = await worktreeChangedPaths(process);
+        if (paths.length !== 2 || !expectedPaths.every((path) => paths.includes(path))) {
+            throw new Error("Recovery candidate changed an unexpected path.");
+        }
+        const candidateDigest = await candidateTreeDigest(process, parent, expectedPaths);
+        if (candidateDigest === releaseDigest) {
+            candidate = {
+                insertion,
+                formattedVersion,
+                formattedChangelog,
+                formattedInsertion,
+                candidateDigest,
+            };
+            break;
+        }
+    }
+    if (!candidate) {
         throw new Error("Recovery release tree differs from its expected candidate.");
     }
+    const { insertion, formattedVersion, formattedChangelog, formattedInsertion, candidateDigest, } = candidate;
     const releasePaths = (await runOrThrow(process, "git", [
         "diff-tree",
         "--no-commit-id",
@@ -361,57 +392,6 @@ async function rebuildRelease(root, process, parent, release) {
         treeDigest: candidateDigest,
     };
 }
-async function releaseTags(process, selectedSha) {
-    const text = await runOrThrow(process, "git", [
-        "for-each-ref",
-        "--format=%(refname:strip=2)%00%(objecttype)%00%(objectname)%00%(*objectname)%00",
-        "refs/tags",
-    ]);
-    const fields = text.split("\0");
-    const tags = [];
-    for (let index = 0; index + 3 < fields.length; index += 4) {
-        const name = fields[index].replace(/^\n+/, "");
-        const objectType = fields[index + 1];
-        const objectName = fields[index + 2];
-        const peeled = fields[index + 3];
-        if (!name)
-            continue;
-        const target = objectType === "commit" ? objectName : peeled;
-        if (!sha.test(target))
-            continue;
-        const ancestor = await process.run("git", [
-            "merge-base",
-            "--is-ancestor",
-            target,
-            selectedSha,
-        ]);
-        if (ancestor.code !== 0 && ancestor.code !== 1) {
-            throw new Error("Could not determine release-tag ancestry.");
-        }
-        tags.push({
-            name,
-            target,
-            lightweight: objectType === "commit",
-            targetIsAncestor: ancestor.code === 0,
-        });
-    }
-    return tags;
-}
-async function commitMessages(process, commits) {
-    const messages = [];
-    for (const commit of commits) {
-        if (!sha.test(commit)) {
-            throw new Error("Git returned an invalid commit SHA.");
-        }
-        messages.push((await runOrThrow(process, "git", [
-            "show",
-            "--no-patch",
-            "--format=%B",
-            commit,
-        ])).replace(/\n+$/, ""));
-    }
-    return messages;
-}
 async function requireClean(process) {
     const status = await runOrThrow(process, "git", [
         "status",
@@ -497,3 +477,8 @@ function lines(value) {
 async function digestText(text) {
     return await digestBytes(new TextEncoder().encode(text));
 }
+function releaseRepository(environment) {
+    const repository = requiredEnvironment(environment, "GITHUB_REPOSITORY");
+    changelogRepositoryUrl(repository);
+    return repository;
+}