versionary 1.0.0 → 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,10 +1,26 @@
 #!/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
+ * aggregate, which in a monorepo names no real release, so prefer the
+ * per-package versions whenever the plan has them.
+ */
+function formatDryRunReleaseSubject(plan) {
+    const releasing = (plan.packages ?? []).filter((pkg) => pkg.nextVersion);
+    if (releasing.length === 0) {
+        return plan.nextVersion ?? "";
+    }
+    return releasing
+        .map((pkg) => `${pkg.path === "." ? plan.packageName : pkg.path} ${pkg.nextVersion}`)
+        .join(", ");
+}
 function printVerifyResult() {
     const result = verifyProject();
     const categories = [
@@ -39,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);
@@ -48,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();
@@ -113,8 +281,28 @@ 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 ${plan.nextVersion}`;
+            const dryRunMessage = `Dry run: would prepare release PR branch ${plan.releaseBranchPrefix} for ${formatDryRunReleaseSubject(plan)}`;
             if (flags.json) {
                 emitJson({
                     action: "pr-dry-run",
@@ -207,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"]) {
@@ -217,8 +408,18 @@ 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 ${plan.nextVersion}`);
+            console.log(`Dry run: would prepare release PR branch ${plan.releaseBranchPrefix} for ${formatDryRunReleaseSubject(plan)}`);
             return 0;
         }
         const pr = prepareReleasePr(process.cwd(), { logger: console });

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

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { applyRevertSuppression, inferReleaseTypeFromParsedCommit, parseConventionalCommitMessage, } from "../git/commits.js";
 import { resolveRepositoryWebBaseUrl } from "../git/repo-url.js";
-import { resolvePackageDependencies } from "./plan.js";
+import { resolvePackageDependencies, resolveRootReleaseView, } from "./plan.js";
 import { isVersionHeading } from "./semver.js";
 const REVIEW_REQUEST_FOOTER = "---\n\nThis PR was generated by [Versionary](https://github.com/jolars/versionary).";
 function formatDate() {
@@ -192,24 +192,27 @@ export function renderReviewRequestFooter() {
     return REVIEW_REQUEST_FOOTER;
 }
 export function renderReleasePlanChangelog(plan, options = {}) {
-    if (!plan.nextVersion) {
+    // Root's changelog describes root's own release, so it must be driven by the
+    // root package's version and commit set rather than the plan-level aggregate.
+    const root = resolveRootReleaseView(plan);
+    if (!root.nextVersion) {
         return "";
     }
     const dedupedCommits = [
-        ...new Map(plan.commits.map((commit) => [commit.hash, commit])).values(),
+        ...new Map(root.commits.map((commit) => [commit.hash, commit])).values(),
     ];
     if (plan.changelogFormat === "r-news") {
         return renderRNewsReleaseNotes({
             packageName: plan.packageName,
-            nextVersion: plan.nextVersion,
+            nextVersion: root.nextVersion,
             commits: dedupedCommits,
             cwd: process.cwd(),
             highlights: options.highlights,
         });
     }
     return renderReleaseNotesSection({
-        currentVersion: plan.currentVersion,
-        nextVersion: plan.nextVersion,
+        currentVersion: root.currentVersion,
+        nextVersion: root.nextVersion,
         commits: dedupedCommits,
         cwd: options.cwd ?? process.cwd(),
         dependencies: resolvePackageDependencies(plan, "."),

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;