versionary 1.0.1 → 1.1.0

package/dist/action/index.js

@@ -112,7 +112,9 @@ function main() {
             setOutput("release_created", "false");
             setOutput("tag_name", "");
             setOutput("tag_names", "[]");
+            setOutput("release_targets", "[]");
             setOutput("review_url", "");
+            setOutput("review_requests", "[]");
             setOutput("branch", "");
             setOutput("title", "");
             return;
@@ -148,7 +150,9 @@ function main() {
     setOutput("release_created", releaseCreated);
     setOutput("tag_name", firstTag);
     setOutput("tag_names", JSON.stringify(tagNames));
+    setOutput("release_targets", JSON.stringify(Array.isArray(payload.releaseTargets) ? payload.releaseTargets : []));
     setOutput("review_url", payload.reviewUrl ?? "");
+    setOutput("review_requests", JSON.stringify(Array.isArray(payload.reviewRequests) ? payload.reviewRequests : []));
     setOutput("branch", payload.branch ?? "");
     setOutput("title", payload.title ?? "");
 }

package/dist/cli/index.js

@@ -1,9 +1,11 @@
 #!/usr/bin/env node
 import { execFileSync } from "node:child_process";
+import { loadConfig } from "../config/load-config.js";
 import { prependChangelog, renderReleasePlanChangelog, } from "../release/changelog.js";
 import { createReleasePlan } from "../release/plan.js";
-import { closeStaleReviewRequestIfExists, isReleaseCommitMessage, openOrUpdateReviewRequest, prepareReleasePr, pushReleaseBranch, resolveReleaseHighlights, } from "../release/pr.js";
+import { closeStaleReviewRequestIfExists, isReleaseCommitMessage, openOrUpdateReviewRequest, preparePendingReleasePr, preparePendingSeparateReleasePrs, prepareReleasePr, prepareSeparateReleasePrs, pushReleaseBranch, reconcileSeparateReviewRequests, resolveReleaseHighlights, } from "../release/pr.js";
 import { runRelease, runReleaseDetailed } from "../release/release.js";
+import { hasFullyUntaggedPendingRelease, hasReleaseStateChangeAtHead, readPendingReleaseTargets, } from "../release/state.js";
 import { verifyProject } from "../release/verify-project.js";
 /**
  * What a dry run would actually release. `plan.nextVersion` is the repository
@@ -53,6 +55,140 @@ function parseFlags(args) {
 function emitJson(payload) {
     process.stdout.write(`${JSON.stringify(payload)}\n`);
 }
+function reviewResultPayload(action, message, reviewRequests) {
+    const primary = reviewRequests[0];
+    return {
+        action,
+        message,
+        releaseCreated: false,
+        tagNames: [],
+        reviewUrl: primary?.reviewUrl,
+        branch: primary?.branch,
+        title: primary?.title,
+        reviewRequests,
+        targets: reviewRequests.flatMap((request) => request.targets.map((target) => ({
+            tag: target.tag,
+            version: target.version,
+        }))),
+    };
+}
+function printReviewResults(message, reviewRequests) {
+    console.log(message);
+    for (const request of reviewRequests) {
+        console.log(`${request.branch}: ${request.title}`);
+        if (request.reviewUrl) {
+            console.log(request.reviewUrl);
+        }
+    }
+}
+async function prepareCurrentSeparateReviewRequests(flags, logger) {
+    const cwd = process.cwd();
+    const prepared = prepareSeparateReleasePrs(cwd, {
+        logger,
+        "dry-run": flags["dry-run"],
+    });
+    const reviewRequests = await reconcileSeparateReviewRequests(cwd, prepared, {
+        logger,
+        "dry-run": flags["dry-run"],
+    });
+    return {
+        reviewRequests,
+        updated: reviewRequests.some((request) => request.status === "prepared"),
+    };
+}
+async function recoverPendingReleaseIfNeeded(flags, logger) {
+    const cwd = process.cwd();
+    if (!hasFullyUntaggedPendingRelease(cwd)) {
+        return false;
+    }
+    const pendingTargets = readPendingReleaseTargets(cwd);
+    const loaded = loadConfig(cwd);
+    const releaseBranch = loaded.config["release-branch"] ?? "versionary/release";
+    if (loaded.config["separate-release-prs"]) {
+        const prepared = preparePendingSeparateReleasePrs(cwd, {
+            logger,
+            "dry-run": flags["dry-run"],
+        });
+        const reviewRequests = await reconcileSeparateReviewRequests(cwd, prepared, {
+            logger,
+            "dry-run": flags["dry-run"],
+            recovered: true,
+        });
+        const action = flags["dry-run"]
+            ? "pr-dry-run"
+            : reviewRequests.some((request) => request.status === "recovered")
+                ? "pr-prepared"
+                : "pr-up-to-date";
+        const message = flags["dry-run"]
+            ? `Dry run: would recover ${prepared.length} pending package release PR${prepared.length === 1 ? "" : "s"}.`
+            : action === "pr-prepared"
+                ? `Prepared ${prepared.length} pending package release recovery PR${prepared.length === 1 ? "" : "s"}.`
+                : "Pending package release recovery PRs are already up to date.";
+        if (flags.json) {
+            emitJson(reviewResultPayload(action, message, reviewRequests));
+            return true;
+        }
+        printReviewResults(message, reviewRequests);
+        return true;
+    }
+    if (flags["dry-run"]) {
+        const message = `Dry run: would recover pending releases ${pendingTargets.map((target) => target.tag).join(", ")} on branch ${releaseBranch}`;
+        if (flags.json) {
+            emitJson({
+                action: "pr-dry-run",
+                message,
+                releaseCreated: false,
+                tagNames: [],
+                branch: releaseBranch,
+                targets: pendingTargets.map((target) => ({
+                    tag: target.tag,
+                    version: target.version,
+                })),
+            });
+            return true;
+        }
+        console.log(message);
+        return true;
+    }
+    const recovery = preparePendingReleasePr(cwd, { logger });
+    if (!recovery.updated) {
+        const message = `Pending release recovery branch ${recovery.branch} is already up to date.`;
+        if (flags.json) {
+            emitJson({
+                action: "pr-up-to-date",
+                message,
+                releaseCreated: false,
+                tagNames: [],
+                branch: recovery.branch,
+                title: recovery.title,
+            });
+            return true;
+        }
+        console.log(message);
+        console.log(`Title: ${recovery.title}`);
+        return true;
+    }
+    pushReleaseBranch(cwd, recovery.branch);
+    const primaryVersion = recovery.targets[0]?.version ?? "";
+    const reviewResult = await openOrUpdateReviewRequest(cwd, recovery.branch, recovery.title, primaryVersion, primaryVersion, [], null, { logger, body: recovery.body });
+    const message = `Prepared pending release recovery PR branch ${recovery.branch}`;
+    if (flags.json) {
+        emitJson({
+            action: "pr-prepared",
+            message,
+            releaseCreated: false,
+            tagNames: [],
+            reviewUrl: reviewResult,
+            branch: recovery.branch,
+            title: recovery.title,
+        });
+        return true;
+    }
+    console.log(message);
+    console.log(`Title: ${recovery.title}`);
+    console.log(reviewResult);
+    return true;
+}
 async function main() {
     const [, , command, ...args] = process.argv;
     const flags = parseFlags(args);
@@ -62,51 +198,69 @@ async function main() {
             encoding: "utf8",
             stdio: ["ignore", "pipe", "ignore"],
         }).trim();
-        if (isReleaseCommitMessage(commitMessage)) {
-            if (flags["dry-run"] && !flags.json) {
-                const release = await runReleaseDetailed(process.cwd(), {
-                    logger,
-                    "dry-run": true,
-                });
-                if (release.action === "release-dry-run") {
-                    console.log(release.message);
-                    return 0;
-                }
-            }
-            if (flags.json) {
-                const release = await runReleaseDetailed(process.cwd(), {
-                    logger,
-                    "dry-run": flags["dry-run"],
-                });
-                if (release.action === "release-skipped") {
+        if (isReleaseCommitMessage(commitMessage) ||
+            hasReleaseStateChangeAtHead(process.cwd())) {
+            const release = await runReleaseDetailed(process.cwd(), {
+                logger,
+                "dry-run": flags["dry-run"],
+            });
+            if (release.action === "release-skipped") {
+                if (flags.json) {
                     emitJson({
                         action: "release-skipped",
                         message: release.reason,
                         releaseCreated: false,
                         tagNames: [],
                     });
-                    return 0;
                 }
-                if (release.action === "release-dry-run") {
+                else {
+                    console.log(release.reason);
+                }
+                return 0;
+            }
+            if (release.action === "release-dry-run") {
+                if (flags.json) {
                     emitJson({
                         action: "release-dry-run",
                         message: release.message,
                         releaseCreated: false,
                         tagNames: release.targets.map((target) => target.tag),
+                        releaseTargets: release.releaseTargets,
                         targets: release.targets,
                     });
-                    return 0;
                 }
+                else {
+                    console.log(release.message);
+                }
+                return 0;
+            }
+            let reviewRequests = [];
+            if (loadConfig(process.cwd()).config["separate-release-prs"]) {
+                reviewRequests = (await prepareCurrentSeparateReviewRequests({ ...flags, "dry-run": false }, logger)).reviewRequests;
+            }
+            if (flags.json) {
+                const primary = reviewRequests[0];
                 emitJson({
                     action: "release-published",
                     message: release.message,
                     releaseCreated: release.releases.length > 0,
                     tagNames: release.releases.map((target) => target.tag),
+                    releaseTargets: release.releaseTargets,
+                    reviewUrl: primary?.reviewUrl,
+                    branch: primary?.branch,
+                    title: primary?.title,
+                    reviewRequests,
                 });
-                return 0;
             }
-            const message = await runRelease(process.cwd());
-            console.log(message);
+            else {
+                console.log(release.message);
+                if (reviewRequests.length > 0) {
+                    printReviewResults(`Reconciled ${reviewRequests.length} remaining package release PR${reviewRequests.length === 1 ? "" : "s"}.`, reviewRequests);
+                }
+            }
+            return 0;
+        }
+        if (await recoverPendingReleaseIfNeeded(flags, logger)) {
             return 0;
         }
         const plan = createReleasePlan();
@@ -127,6 +281,26 @@ async function main() {
             console.log(message);
             return 0;
         }
+        if (loadConfig(process.cwd()).config["separate-release-prs"]) {
+            const { reviewRequests, updated } = await prepareCurrentSeparateReviewRequests(flags, logger);
+            const action = flags["dry-run"]
+                ? "pr-dry-run"
+                : updated
+                    ? "pr-prepared"
+                    : "pr-up-to-date";
+            const message = flags["dry-run"]
+                ? `Dry run: would prepare ${reviewRequests.length} package release PR${reviewRequests.length === 1 ? "" : "s"}.`
+                : updated
+                    ? `Prepared ${reviewRequests.length} package release PR${reviewRequests.length === 1 ? "" : "s"}.`
+                    : "Package release PRs are already up to date.";
+            if (flags.json) {
+                emitJson(reviewResultPayload(action, message, reviewRequests));
+            }
+            else {
+                printReviewResults(message, reviewRequests);
+            }
+            return 0;
+        }
         if (flags["dry-run"]) {
             const dryRunMessage = `Dry run: would prepare release PR branch ${plan.releaseBranchPrefix} for ${formatDryRunReleaseSubject(plan)}`;
             if (flags.json) {
@@ -221,6 +395,9 @@ async function main() {
         return 0;
     }
     if (command === "pr") {
+        if (await recoverPendingReleaseIfNeeded({ ...flags, json: false }, console)) {
+            return 0;
+        }
         const plan = createReleasePlan();
         if (!plan.nextVersion) {
             if (!flags["dry-run"]) {
@@ -231,6 +408,16 @@ async function main() {
             console.log("No releasable commits found. Nothing to do.");
             return 0;
         }
+        if (loadConfig(process.cwd()).config["separate-release-prs"]) {
+            const { reviewRequests, updated } = await prepareCurrentSeparateReviewRequests(flags, console);
+            const message = flags["dry-run"]
+                ? `Dry run: would prepare ${reviewRequests.length} package release PR${reviewRequests.length === 1 ? "" : "s"}.`
+                : updated
+                    ? `Prepared ${reviewRequests.length} package release PR${reviewRequests.length === 1 ? "" : "s"}.`
+                    : "Package release PRs are already up to date.";
+            printReviewResults(message, reviewRequests);
+            return 0;
+        }
         if (flags["dry-run"]) {
             console.log(`Dry run: would prepare release PR branch ${plan.releaseBranchPrefix} for ${formatDryRunReleaseSubject(plan)}`);
             return 0;

package/dist/config/schema.d.ts

@@ -19,6 +19,7 @@ export declare const configSchema: z.ZodObject<{
         strict: "strict";
     }>>;
     "release-branch": z.ZodOptional<z.ZodString>;
+    "separate-release-prs": z.ZodOptional<z.ZodBoolean>;
     "baseline-file": z.ZodOptional<z.ZodString>;
     "bootstrap-sha": z.ZodOptional<z.ZodString>;
     "monorepo-mode": z.ZodOptional<z.ZodEnum<{
@@ -52,6 +53,7 @@ export declare const configSchema: z.ZodObject<{
             "field-path": z.ZodOptional<z.ZodString>;
             pattern: z.ZodOptional<z.ZodString>;
             replacement: z.ZodOptional<z.ZodString>;
+            "expected-matches": z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>>;
         follows: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>>;

package/dist/config/schema.js

@@ -6,6 +6,7 @@ const artifactRuleSchema = z
     "field-path": z.string().optional(),
     pattern: z.string().optional(),
     replacement: z.string().optional(),
+    "expected-matches": z.number().int().positive().optional(),
 })
     .superRefine((value, ctx) => {
     const needsFieldPath = value.type === "json" ||
@@ -33,6 +34,13 @@ const artifactRuleSchema = z
             path: ["replacement"],
         });
     }
+    if (needsFieldPath && value["expected-matches"] !== undefined) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `${value.type} artifact rules do not support "expected-matches".`,
+            path: ["expected-matches"],
+        });
+    }
     if (value.type === "regex" && !value.pattern) {
         ctx.addIssue({
             code: z.ZodIssueCode.custom,
@@ -75,6 +83,7 @@ export const configSchema = z
         .enum(["off", "best-effort", "strict"])
         .optional(),
     "release-branch": z.string().optional(),
+    "separate-release-prs": z.boolean().optional(),
     "baseline-file": z.string().optional(),
     "bootstrap-sha": z.string().optional(),
     "monorepo-mode": z.enum(["independent", "fixed"]).optional(),
@@ -90,6 +99,29 @@ export const configSchema = z
     .strict()
     .superRefine((value, ctx) => {
     const packages = value.packages;
+    if (value["separate-release-prs"]) {
+        if (!packages || Object.keys(packages).length === 0) {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: '"separate-release-prs" requires a non-empty packages map.',
+                path: ["separate-release-prs"],
+            });
+        }
+        if (value["monorepo-mode"] === "fixed") {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: '"separate-release-prs" cannot be combined with monorepo-mode "fixed".',
+                path: ["separate-release-prs"],
+            });
+        }
+        if (value["review-mode"] === "direct") {
+            ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                message: '"separate-release-prs" cannot be combined with review-mode "direct".',
+                path: ["separate-release-prs"],
+            });
+        }
+    }
     if (!packages) {
         return;
     }

package/dist/index.d.ts

@@ -3,7 +3,7 @@ export { verifyProject } from "./release/verify-project.js";
 export { findPluginsByCapability, pluginHasCapability, } from "./scm/capabilities.js";
 export { getScmClient } from "./scm/client.js";
 export { createGitHubPlugin } from "./scm/github-plugin.js";
-export type { ScmClient, ScmClientContext, ScmProvider, ScmReleaseMetadataInput, ScmReleaseMetadataResult, ScmReleaseReferenceCommentsInput, ScmReleaseReferenceCommentsResult, ScmReviewRequestInput, ScmReviewRequestResult, } from "./scm/types.js";
+export type { ScmClient, ScmClientContext, ScmListReviewRequestsInput, ScmProvider, ScmReleaseMetadataInput, ScmReleaseMetadataResult, ScmReleaseReferenceCommentsInput, ScmReleaseReferenceCommentsResult, ScmReviewRequestInput, ScmReviewRequestResult, ScmReviewRequestSummary, } from "./scm/types.js";
 export { resolveVersionStrategy } from "./strategy/resolve.js";
 export type { VersionaryArtifactRule, VersionaryConfig, VersionaryPackage, } from "./types/config.js";
-export type { VersionaryPluginCapability, VersionaryPluginContext, VersionaryPluginRuntime, VersionaryScmReleaseMetadataInput, VersionaryScmReleaseMetadataResult, VersionaryScmReleaseReferenceCommentsInput, VersionaryScmReleaseReferenceCommentsResult, VersionaryScmReviewRequestInput, VersionaryScmReviewRequestResult, } from "./types/plugins.js";
+export type { VersionaryPluginCapability, VersionaryPluginContext, VersionaryPluginRuntime, VersionaryScmListReviewRequestsInput, VersionaryScmReleaseMetadataInput, VersionaryScmReleaseMetadataResult, VersionaryScmReleaseReferenceCommentsInput, VersionaryScmReleaseReferenceCommentsResult, VersionaryScmReviewRequestInput, VersionaryScmReviewRequestResult, VersionaryScmReviewRequestSummary, } from "./types/plugins.js";

package/dist/release/artifact-rules.js

@@ -183,40 +183,39 @@ function renderReplacementTemplate(template, version) {
         return value;
     });
 }
-function applyRegexRule(content, pattern, version, replacementTemplate) {
+function applyRegexRule(content, pattern, version, expectedMatches, replacementTemplate) {
     const regex = parseRegexPattern(pattern);
     const matchFlags = regex.flags.includes("g")
         ? regex.flags
         : `${regex.flags}g`;
     const globalRegex = new RegExp(regex.source, matchFlags.includes("d") ? matchFlags : `${matchFlags}d`);
     const matches = [...content.matchAll(globalRegex)];
-    if (matches.length !== 1) {
-        throw new Error(`Regex pattern must match exactly one occurrence; matched ${matches.length}.`);
+    if (matches.length !== expectedMatches) {
+        throw new Error(`Regex pattern expected ${expectedMatches} ${expectedMatches === 1 ? "match" : "matches"}; matched ${matches.length}.`);
+    }
+    const renderedReplacement = replacementTemplate === undefined
+        ? undefined
+        : renderReplacementTemplate(replacementTemplate, version);
+    let updated = content;
+    for (let index = matches.length - 1; index >= 0; index -= 1) {
+        const match = matches[index];
+        if (!match || match.index === undefined) {
+            throw new Error("Regex match did not include an index.");
+        }
+        // Apply edits from right to left so every match keeps its original indices.
+        if (renderedReplacement !== undefined) {
+            updated = `${updated.slice(0, match.index)}${renderedReplacement}${updated.slice(match.index + match[0].length)}`;
+            continue;
+        }
+        // Splice by group indices so literal `$` sequences and repeated group content
+        // are handled correctly.
+        const [start, end] = match.indices?.[1] ?? [
+            match.index,
+            match.index + match[0].length,
+        ];
+        updated = `${updated.slice(0, start)}${version}${updated.slice(end)}`;
     }
-    const match = matches[0];
-    if (!match) {
-        throw new Error("Regex match result missing.");
-    }
-    const start = match.index;
-    if (start === undefined) {
-        throw new Error("Regex match did not include an index.");
-    }
-    const full = match[0];
-    // With a replacement template, render it and replace the entire match.
-    if (replacementTemplate !== undefined) {
-        const rendered = renderReplacementTemplate(replacementTemplate, version);
-        return `${content.slice(0, start)}${rendered}${content.slice(start + full.length)}`;
-    }
-    // Without a template: substitute the full version into the first capture
-    // group, leaving the rest of the match intact. Splice by group indices rather than
-    // `String.replace` so literal `$` sequences and repeated group content are
-    // handled correctly.
-    const groupIndices = match.indices?.[1];
-    if (!groupIndices) {
-        return `${content.slice(0, start)}${version}${content.slice(start + full.length)}`;
-    }
-    const [groupStart, groupEnd] = groupIndices;
-    return `${content.slice(0, groupStart)}${version}${content.slice(groupEnd)}`;
+    return updated;
 }
 function applyTomlRulePreservingFormatting(content, fieldPath, version) {
     const simplePath = fieldPath.match(/^\$\.([A-Za-z0-9_-]+)$/u);
@@ -403,7 +402,7 @@ function applyArtifactRuleToContent(content, rule, version) {
         if (!rule.pattern) {
             throw new Error('regex artifact rules require "pattern".');
         }
-        return applyRegexRule(content, rule.pattern, version, rule.replacement);
+        return applyRegexRule(content, rule.pattern, version, rule["expected-matches"] ?? 1, rule.replacement);
     }
     if (rule.type === "json") {
         const parsed = JSON.parse(content);

package/dist/release/cohorts.d.ts

@@ -0,0 +1,6 @@
+import type { ReleasePlan } from "./plan.js";
+export type ReleaseCohort = string[];
+export declare function buildInitialReleaseCohorts(plan: ReleasePlan): ReleaseCohort[];
+export declare function stabilizeReleaseCohorts(initial: readonly ReleaseCohort[], changedFilesFor: (packagePaths: ReleaseCohort) => readonly string[]): ReleaseCohort[];
+export declare function resolveSeparateReleaseBranchPrefix(prefix: string): string;
+export declare function resolveSeparateReleaseBranch(prefix: string, releaseName: string, packagePath: string): string;

package/dist/release/cohorts.js

@@ -0,0 +1,125 @@
+import { createHash } from "node:crypto";
+function normalizedCohorts(cohorts) {
+    return cohorts
+        .map((cohort) => [...new Set(cohort)].sort((a, b) => a.localeCompare(b)))
+        .filter((cohort) => cohort.length > 0)
+        .sort((a, b) => (a[0] ?? "").localeCompare(b[0] ?? ""));
+}
+export function buildInitialReleaseCohorts(plan) {
+    const releasing = (plan.packages ?? [])
+        .filter((pkg) => pkg.nextVersion)
+        .map((pkg) => pkg.path)
+        .sort((a, b) => a.localeCompare(b));
+    const releasingSet = new Set(releasing);
+    const parent = new Map(releasing.map((packagePath) => [packagePath, packagePath]));
+    const find = (packagePath) => {
+        const current = parent.get(packagePath) ?? packagePath;
+        if (current === packagePath) {
+            return current;
+        }
+        const root = find(current);
+        parent.set(packagePath, root);
+        return root;
+    };
+    const union = (left, right) => {
+        const leftRoot = find(left);
+        const rightRoot = find(right);
+        if (leftRoot === rightRoot) {
+            return;
+        }
+        const [first, second] = [leftRoot, rightRoot].sort((a, b) => a.localeCompare(b));
+        if (first && second) {
+            parent.set(second, first);
+        }
+    };
+    for (const pkg of plan.packages ?? []) {
+        if (!pkg.nextVersion || !releasingSet.has(pkg.path)) {
+            continue;
+        }
+        for (const sourcePath of pkg.dependencySourcePaths ?? []) {
+            if (releasingSet.has(sourcePath)) {
+                union(pkg.path, sourcePath);
+            }
+        }
+    }
+    const grouped = new Map();
+    for (const packagePath of releasing) {
+        const root = find(packagePath);
+        grouped.set(root, [...(grouped.get(root) ?? []), packagePath]);
+    }
+    return normalizedCohorts([...grouped.values()]);
+}
+function overlaps(left, right) {
+    for (const value of left) {
+        if (right.has(value)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function stabilizeReleaseCohorts(initial, changedFilesFor) {
+    let cohorts = normalizedCohorts(initial);
+    while (cohorts.length > 1) {
+        const footprints = cohorts.map((cohort) => new Set(changedFilesFor(cohort).map((file) => file.replaceAll("\\", "/"))));
+        const parent = cohorts.map((_, index) => index);
+        const find = (index) => {
+            const current = parent[index] ?? index;
+            if (current === index) {
+                return current;
+            }
+            const root = find(current);
+            parent[index] = root;
+            return root;
+        };
+        const union = (left, right) => {
+            const leftRoot = find(left);
+            const rightRoot = find(right);
+            if (leftRoot !== rightRoot) {
+                parent[Math.max(leftRoot, rightRoot)] = Math.min(leftRoot, rightRoot);
+            }
+        };
+        for (let left = 0; left < cohorts.length; left += 1) {
+            for (let right = left + 1; right < cohorts.length; right += 1) {
+                if (overlaps(footprints[left] ?? new Set(), footprints[right] ?? new Set())) {
+                    union(left, right);
+                }
+            }
+        }
+        const merged = new Map();
+        for (let index = 0; index < cohorts.length; index += 1) {
+            const root = find(index);
+            merged.set(root, [
+                ...(merged.get(root) ?? []),
+                ...(cohorts[index] ?? []),
+            ]);
+        }
+        const next = normalizedCohorts([...merged.values()]);
+        if (next.length === cohorts.length) {
+            return cohorts;
+        }
+        cohorts = next;
+    }
+    return cohorts;
+}
+// The prefix shared by every separate release branch. It is the configured
+// release branch itself, so listing on it also matches the legacy single
+// release branch left behind by repos migrating from the combined PR flow.
+export function resolveSeparateReleaseBranchPrefix(prefix) {
+    return prefix.replace(/\/+$/gu, "");
+}
+export function resolveSeparateReleaseBranch(prefix, releaseName, packagePath) {
+    const normalizedPrefix = resolveSeparateReleaseBranchPrefix(prefix);
+    const slug = releaseName
+        .trim()
+        .replace(/^@/u, "")
+        .replace(/[^A-Za-z0-9._-]+/gu, "-")
+        .replace(/^-+|-+$/gu, "") || "package";
+    const digest = createHash("sha256")
+        .update(packagePath)
+        .digest("hex")
+        .slice(0, 12);
+    // A sibling of the legacy release branch, not a child of it: git cannot hold
+    // both `refs/heads/<prefix>` and `refs/heads/<prefix>/<name>`, and repos
+    // migrating from the combined PR flow still have the former on the remote.
+    return `${normalizedPrefix}-${slug}-${digest}`;
+}