versionary 1.0.1 → 1.2.0

package/dist/action/index.js

@@ -48,6 +48,24 @@ function getRemoteRefSha(cwd, ref) {
         return null;
     }
 }
+function hasVersionaryReleaseMarker(cwd, sha) {
+    try {
+        const message = runGit(cwd, ["show", "-s", "--format=%B", sha]);
+        return /^Versionary-Release:\s*true$/imu.test(message);
+    }
+    catch {
+        return false;
+    }
+}
+function isAncestor(cwd, ancestor, descendant) {
+    try {
+        runGit(cwd, ["merge-base", "--is-ancestor", ancestor, descendant]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function setOutput(name, value) {
     const outputPath = process.env.GITHUB_OUTPUT;
     if (!outputPath) {
@@ -98,24 +116,31 @@ function main() {
         hasOriginRemote(cwd)) {
         const remoteSha = getRemoteRefSha(cwd, ref);
         if (remoteSha && remoteSha !== sha) {
-            const staleMessage = `Skipping stale push run for ${sha.slice(0, 7)}; ` +
-                `${ref} now points to ${remoteSha.slice(0, 7)}.`;
-            const stalePayload = {
-                action: "stale-run-skipped",
-                message: staleMessage,
-                releaseCreated: false,
-                tagNames: [],
-            };
-            process.stdout.write(`${JSON.stringify(stalePayload)}\n`);
-            setOutput("action", stalePayload.action);
-            setOutput("message", stalePayload.message);
-            setOutput("release_created", "false");
-            setOutput("tag_name", "");
-            setOutput("tag_names", "[]");
-            setOutput("review_url", "");
-            setOutput("branch", "");
-            setOutput("title", "");
-            return;
+            // Descendant pushes must not turn an otherwise valid release into a
+            // recovery cycle.
+            const releaseCanPublish = hasVersionaryReleaseMarker(cwd, sha) && isAncestor(cwd, sha, remoteSha);
+            if (!releaseCanPublish) {
+                const staleMessage = `Skipping stale push run for ${sha.slice(0, 7)}; ` +
+                    `${ref} now points to ${remoteSha.slice(0, 7)}.`;
+                const stalePayload = {
+                    action: "stale-run-skipped",
+                    message: staleMessage,
+                    releaseCreated: false,
+                    tagNames: [],
+                };
+                process.stdout.write(`${JSON.stringify(stalePayload)}\n`);
+                setOutput("action", stalePayload.action);
+                setOutput("message", stalePayload.message);
+                setOutput("release_created", "false");
+                setOutput("tag_name", "");
+                setOutput("tag_names", "[]");
+                setOutput("release_targets", "[]");
+                setOutput("review_url", "");
+                setOutput("review_requests", "[]");
+                setOutput("branch", "");
+                setOutput("title", "");
+                return;
+            }
         }
     }
     const raw = execFileSync("npx", ["--yes", `versionary@${versionaryVersion}`, "run", "--json"], {
@@ -148,7 +173,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/changelog.js

@@ -291,7 +291,6 @@ export function prependChangelog(cwd, changelogFile, section, format = "markdown
 export function renderRNewsReleaseNotes(input) {
     const repoUrl = resolveRepositoryWebBaseUrl(input.cwd ?? process.cwd());
     const grouped = groupCommitLines(input.commits, repoUrl);
-    const normalizedVersion = input.nextVersion.replace(/\.\d+$/u, "");
     const sections = [];
     const trimmedHighlights = input.highlights?.trim() ?? "";
     if (trimmedHighlights.length > 0) {
@@ -315,7 +314,7 @@ export function renderRNewsReleaseNotes(input) {
     if (needsOtherChangesFallback(grouped, trimmedHighlights.length > 0, 0)) {
         sections.push("## Other changes", "", ...grouped.other, "");
     }
-    return [`# ${input.packageName} ${normalizedVersion}`, "", ...sections]
+    return [`# ${input.packageName} ${input.nextVersion}`, "", ...sections]
         .join("\n")
         .trimEnd();
 }

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;