versionary 0.21.0 → 0.23.0

package/README.md

@@ -157,6 +157,32 @@ For a quick trial, use:
   - per-package `package-name` can override release identity (labels + tag base)
   - per-package `changelog-file` writes package release notes to
     `<package-path>/<changelog-file>`
+  - per-package `follows` declares an asymmetric version link to one or more
+    source packages: when any source bumps, the follower releases too, with
+    bump = `max(own bump, max(source bumps))`. The follower's changelog gets a
+    `### Dependencies` section listing the followed sources. Use it when one
+    package bundles another's artifact (e.g. an editor extension that ships
+    the CLI binary). Cycles, self-references, unknown source paths, and
+    combining `follows` with `monorepo-mode: "fixed"` are config errors.
+    `follows` is non-transitive: A follows B does not imply A follows what B
+    follows.
+
+```jsonc
+// Editor extension that bundles the root CLI artifact
+{
+  "version": 1,
+  "release-type": "rust",
+  "monorepo-mode": "independent",
+  "packages": {
+    ".": { "exclude-paths": ["editors"] },
+    "editors/code": {
+      "release-type": "node",
+      "package-name": "panache-code",
+      "follows": ["."]
+    }
+  }
+}
+```
 
 Rust strategy examples:
 

package/dist/cli/index.js

@@ -2,6 +2,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const node_child_process_1 = require("node:child_process");
+const load_config_js_1 = require("../config/load-config.js");
 const changelog_js_1 = require("../release/changelog.js");
 const plan_js_1 = require("../release/plan.js");
 const pr_js_1 = require("../release/pr.js");
@@ -162,7 +163,7 @@ async function main() {
             return 0;
         }
         (0, pr_js_1.pushReleaseBranch)(process.cwd(), pr.branch);
-        const reviewResult = await (0, pr_js_1.openOrUpdateReviewRequest)(process.cwd(), pr.branch, pr.title, pr.version, pr.previousVersion, pr.commits, pr.plan, { logger });
+        const reviewResult = await (0, pr_js_1.openOrUpdateReviewRequest)(process.cwd(), pr.branch, pr.title, pr.version, pr.previousVersion, pr.commits, pr.plan, { logger, highlights: pr.highlights });
         const message = `Prepared release PR branch ${pr.branch}`;
         if (flags.json) {
             emitJson({
@@ -196,12 +197,18 @@ async function main() {
             console.log("No releasable commits found.");
             return 0;
         }
-        const section = (0, changelog_js_1.renderReleasePlanChangelog)(plan);
+        const loaded = (0, load_config_js_1.loadConfig)();
+        const highlightsRead = (0, pr_js_1.readNextReleaseHighlights)(process.cwd(), loaded.config);
+        const highlights = highlightsRead?.content ?? "";
+        const section = (0, changelog_js_1.renderReleasePlanChangelog)(plan, { highlights });
         if (!write) {
             console.log(section);
             return 0;
         }
         (0, changelog_js_1.prependChangelog)(process.cwd(), plan.changelogFile, section, plan.changelogFormat);
+        if (highlightsRead) {
+            (0, pr_js_1.consumeNextReleaseFile)(process.cwd(), highlightsRead.filePath);
+        }
         console.log(`Updated ${plan.changelogFile}`);
         return 0;
     }
@@ -227,7 +234,7 @@ async function main() {
             return 0;
         }
         (0, pr_js_1.pushReleaseBranch)(process.cwd(), pr.branch);
-        const reviewResult = await (0, pr_js_1.openOrUpdateReviewRequest)(process.cwd(), pr.branch, pr.title, pr.version, pr.previousVersion, pr.commits, pr.plan);
+        const reviewResult = await (0, pr_js_1.openOrUpdateReviewRequest)(process.cwd(), pr.branch, pr.title, pr.version, pr.previousVersion, pr.commits, pr.plan, { highlights: pr.highlights });
         console.log(`Prepared release PR branch ${pr.branch}`);
         console.log(`Title: ${pr.title}`);
         console.log(reviewResult);

package/dist/config/schema.d.ts

@@ -21,6 +21,7 @@ export declare const configSchema: z.ZodObject<{
     }>>;
     "release-branch": z.ZodOptional<z.ZodString>;
     "baseline-file": z.ZodOptional<z.ZodString>;
+    "next-release-file": z.ZodOptional<z.ZodString>;
     "bootstrap-sha": z.ZodOptional<z.ZodString>;
     "monorepo-mode": z.ZodOptional<z.ZodEnum<{
         independent: "independent";
@@ -52,6 +53,7 @@ export declare const configSchema: z.ZodObject<{
             jsonpath: z.ZodOptional<z.ZodString>;
             pattern: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>>>;
+        follows: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strict>>>;
 }, z.core.$strict>;
 export type ConfigSchema = z.infer<typeof configSchema>;

package/dist/config/schema.js

@@ -60,6 +60,7 @@ const packageSchema = zod_1.z
     "changelog-format": zod_1.z.enum(["markdown-changelog", "r-news"]).optional(),
     "exclude-paths": zod_1.z.array(zod_1.z.string()).optional(),
     "extra-files": zod_1.z.array(artifactRuleSchema).optional(),
+    follows: zod_1.z.array(zod_1.z.string().min(1)).optional(),
 })
     .strict();
 exports.configSchema = zod_1.z
@@ -76,6 +77,7 @@ exports.configSchema = zod_1.z
         .optional(),
     "release-branch": zod_1.z.string().optional(),
     "baseline-file": zod_1.z.string().optional(),
+    "next-release-file": zod_1.z.string().optional(),
     "bootstrap-sha": zod_1.z.string().optional(),
     "monorepo-mode": zod_1.z.enum(["independent", "fixed"]).optional(),
     "bump-minor-pre-major": zod_1.z.boolean().optional(),
@@ -84,4 +86,88 @@ exports.configSchema = zod_1.z
     "release-type": zod_1.z.string().optional(),
     packages: zod_1.z.record(zod_1.z.string().min(1), packageSchema).optional(),
 })
-    .strict();
+    .strict()
+    .superRefine((value, ctx) => {
+    const packages = value.packages;
+    if (!packages) {
+        return;
+    }
+    const knownPaths = new Set(Object.keys(packages));
+    const followsByPath = new Map();
+    for (const [packagePath, packageConfig] of Object.entries(packages)) {
+        const follows = packageConfig.follows;
+        if (!follows || follows.length === 0) {
+            continue;
+        }
+        followsByPath.set(packagePath, follows);
+        for (const sourcePath of follows) {
+            if (sourcePath === packagePath) {
+                ctx.addIssue({
+                    code: zod_1.z.ZodIssueCode.custom,
+                    message: `Package "${packagePath}" cannot follow itself.`,
+                    path: ["packages", packagePath, "follows"],
+                });
+                continue;
+            }
+            if (!knownPaths.has(sourcePath)) {
+                ctx.addIssue({
+                    code: zod_1.z.ZodIssueCode.custom,
+                    message: `Package "${packagePath}" follows unknown package "${sourcePath}".`,
+                    path: ["packages", packagePath, "follows"],
+                });
+            }
+        }
+    }
+    if (followsByPath.size > 0 && value["monorepo-mode"] === "fixed") {
+        for (const followerPath of followsByPath.keys()) {
+            ctx.addIssue({
+                code: zod_1.z.ZodIssueCode.custom,
+                message: 'Package "follows" cannot be combined with monorepo-mode "fixed" (fixed mode already pins all package versions together).',
+                path: ["packages", followerPath, "follows"],
+            });
+        }
+    }
+    const reportedCycles = new Set();
+    const findCycleFrom = (start) => {
+        const trail = [];
+        const visit = (node) => {
+            const trailIndex = trail.indexOf(node);
+            if (trailIndex !== -1) {
+                return [...trail.slice(trailIndex), node];
+            }
+            const sources = followsByPath.get(node);
+            if (!sources || sources.length === 0) {
+                return null;
+            }
+            trail.push(node);
+            for (const source of sources) {
+                if (!knownPaths.has(source)) {
+                    continue;
+                }
+                const cycle = visit(source);
+                if (cycle) {
+                    return cycle;
+                }
+            }
+            trail.pop();
+            return null;
+        };
+        return visit(start);
+    };
+    for (const followerPath of followsByPath.keys()) {
+        const cycle = findCycleFrom(followerPath);
+        if (!cycle) {
+            continue;
+        }
+        const key = [...cycle].sort().join("->");
+        if (reportedCycles.has(key)) {
+            continue;
+        }
+        reportedCycles.add(key);
+        ctx.addIssue({
+            code: zod_1.z.ZodIssueCode.custom,
+            message: `Package "follows" cycle detected: ${cycle.join(" -> ")}.`,
+            path: ["packages", cycle[0] ?? followerPath, "follows"],
+        });
+    }
+});

package/dist/release/artifact-rules.js

@@ -26,7 +26,7 @@ function parseFieldPath(fieldPath) {
                 index += 2;
                 continue;
             }
-            const keyMatch = fieldPath.slice(index + 1).match(/^[A-Za-z0-9_-]+/u);
+            const keyMatch = fieldPath.slice(index + 1).match(/^[A-Za-z0-9_@/-]+/u);
             if (!keyMatch) {
                 throw new Error(`Invalid field-path "${fieldPath}" near index ${index}.`);
             }

package/dist/release/changelog.d.ts

@@ -10,6 +10,7 @@ export declare function renderSimpleReleaseNotes(input: {
         name: string;
         version: string;
     }>;
+    highlights?: string;
 }, options?: {
     includeFooter?: boolean;
     headerLabel?: string;
@@ -19,6 +20,7 @@ export declare function renderReleasePlanChangelog(plan: ReleasePlan, options?:
     headerLabel?: string;
     includeFooter?: boolean;
     cwd?: string;
+    highlights?: string;
 }): string;
 /** @deprecated Use renderReleasePlanChangelog. */
 export declare function renderSimpleChangelog(plan: SimplePlan): string;
@@ -35,4 +37,5 @@ export declare function renderRNewsReleaseNotes(input: {
     nextVersion: string;
     commits: ParsedCommit[];
     cwd?: string;
+    highlights?: string;
 }): string;

package/dist/release/changelog.js

@@ -148,6 +148,10 @@ function renderSimpleReleaseNotes(input, options = {}) {
         : `## ${headerLabel} (${formatDate()})`;
     const grouped = groupCommitLines(input.commits, repoUrl);
     const sections = [];
+    const trimmedHighlights = input.highlights?.trim() ?? "";
+    if (trimmedHighlights.length > 0) {
+        sections.push(trimmedHighlights, "");
+    }
     if (grouped.breaking.length > 0) {
         sections.push("### Breaking changes", ...grouped.breaking, "");
     }
@@ -212,6 +216,7 @@ function renderReleasePlanChangelog(plan, options = {}) {
             nextVersion: plan.nextVersion,
             commits: dedupedCommits,
             cwd: process.cwd(),
+            highlights: options.highlights,
         });
     }
     return renderSimpleReleaseNotes({
@@ -220,6 +225,7 @@ function renderReleasePlanChangelog(plan, options = {}) {
         commits: dedupedCommits,
         cwd: options.cwd ?? process.cwd(),
         dependencies,
+        highlights: options.highlights,
     }, {
         includeFooter: options.includeFooter,
         headerLabel: options.headerLabel,
@@ -276,6 +282,10 @@ function renderRNewsReleaseNotes(input) {
     const grouped = groupCommitLines(input.commits, repoUrl);
     const normalizedVersion = input.nextVersion.replace(/\.\d+$/u, "");
     const sections = [];
+    const trimmedHighlights = input.highlights?.trim() ?? "";
+    if (trimmedHighlights.length > 0) {
+        sections.push(trimmedHighlights, "");
+    }
     if (grouped.breaking.length > 0) {
         sections.push("## Breaking changes", "", ...grouped.breaking, "");
     }

package/dist/release/plan.d.ts

@@ -18,7 +18,7 @@ export interface ReleasePlan {
         releaseType: ReleaseType;
         currentVersion: string;
         nextVersion: string | null;
-        bumpReason?: "direct" | "dependency-propagation";
+        bumpReason?: "direct" | "dependency-propagation" | "follows";
         dependencySourcePaths?: string[];
         commits: ParsedCommit[];
     }>;

package/dist/release/plan.js

@@ -98,6 +98,8 @@ function createReleasePlan(cwd = process.cwd()) {
             releaseType: null,
             currentVersion: explicitPackagePlans[0]?.currentVersion ?? "0.0.0",
             nextVersion: null,
+            bumpReason: undefined,
+            dependencySourcePaths: undefined,
             commits: [],
             parsedCommits: [],
             resolvedVersionFile: versionFile,
@@ -171,7 +173,7 @@ function createReleasePlan(cwd = process.cwd()) {
             }
         }
     }
-    const adjustedPackages = packagePlans.map((pkgPlan) => {
+    const propagatedPackages = packagePlans.map((pkgPlan) => {
         const dependencySourcePaths = [
             ...(dependencySourcePathsByPackage.get(pkgPlan.path) ??
                 new Set()),
@@ -196,6 +198,47 @@ function createReleasePlan(cwd = process.cwd()) {
             dependencySourcePaths,
         };
     });
+    const followsByPath = new Map();
+    for (const [packagePath, packageConfig] of Object.entries(loaded.config.packages ?? {})) {
+        const follows = packageConfig.follows ?? [];
+        if (follows.length > 0) {
+            followsByPath.set(packagePath, follows);
+        }
+    }
+    const adjustedPackages = propagatedPackages.map((pkgPlan) => {
+        const followsSources = followsByPath.get(pkgPlan.path) ?? [];
+        const bumpingSources = followsSources
+            .map((sourcePath) => propagatedPackages.find((pkg) => pkg.path === sourcePath))
+            .filter((sourcePlan) => Boolean(sourcePlan?.nextVersion));
+        if (bumpingSources.length === 0) {
+            return pkgPlan;
+        }
+        const ownReleaseType = pkgPlan.releaseType;
+        const combinedReleaseType = (0, semver_js_1.maxReleaseType)([
+            ownReleaseType,
+            ...bumpingSources.map((sourcePlan) => sourcePlan.releaseType),
+        ]);
+        const mergedDependencySourcePaths = [
+            ...new Set([
+                ...(pkgPlan.dependencySourcePaths ?? []),
+                ...bumpingSources.map((sourcePlan) => sourcePlan.path),
+            ]),
+        ].sort((a, b) => a.localeCompare(b));
+        const sourceDrove = combinedReleaseType !== ownReleaseType ||
+            pkgPlan.bumpReason === "dependency-propagation" ||
+            pkgPlan.bumpReason === undefined;
+        const baseVersion = packageCurrentVersionByPath[pkgPlan.path] ?? pkgPlan.currentVersion;
+        const nextVersion = combinedReleaseType
+            ? (0, semver_js_1.bumpVersion)(baseVersion, combinedReleaseType, { allowStableMajor })
+            : null;
+        return {
+            ...pkgPlan,
+            releaseType: combinedReleaseType,
+            nextVersion,
+            bumpReason: sourceDrove ? "follows" : pkgPlan.bumpReason,
+            dependencySourcePaths: mergedDependencySourcePaths,
+        };
+    });
     const visiblePackages = adjustedPackages.filter((pkgPlan) => !pkgPlan.implicitRoot || hasExplicitRootPackage);
     const rootPackagePlan = adjustedPackages.find((pkgPlan) => pkgPlan.path === ".");
     if (!rootPackagePlan) {

package/dist/release/pr.d.ts

@@ -1,6 +1,15 @@
 import type { ParsedCommit } from "../git/commits.js";
+import type { VersionaryConfig } from "../types/config.js";
 import type { VersionaryPluginContext } from "../types/plugins.js";
 import { type ReleasePlan, type SimplePlan } from "./plan.js";
+export declare function getNextReleaseFile(config: VersionaryConfig): string;
+export declare function readNextReleaseHighlights(cwd: string, config: VersionaryConfig): {
+    content: string;
+    filePath: string;
+} | null;
+export declare function consumeNextReleaseFile(cwd: string, filePath: string): {
+    tracked: boolean;
+};
 export declare function splitSafeDirtyFiles(files: string[]): {
     ignored: string[];
     blocking: string[];
@@ -15,10 +24,12 @@ export declare function prepareReleasePr(cwd?: string, options?: {
     commits: ParsedCommit[];
     plan: ReleasePlan;
     updated: boolean;
+    highlights: string;
 };
-export declare function renderSimpleReviewRequestBody(version: string, previousVersion: string, commits: ParsedCommit[], plan?: SimplePlan | null, cwd?: string): string;
+export declare function renderSimpleReviewRequestBody(version: string, previousVersion: string, commits: ParsedCommit[], plan?: SimplePlan | null, cwd?: string, highlights?: string): string;
 export declare function openOrUpdateReviewRequest(cwd: string, branch: string, title: string, version: string, previousVersion: string, commits: ParsedCommit[], plan?: SimplePlan | null, options?: {
     logger?: VersionaryPluginContext["logger"];
+    highlights?: string;
 }): Promise<string>;
 export declare function closeStaleReviewRequestIfExists(cwd?: string, options?: {
     logger?: VersionaryPluginContext["logger"];
@@ -34,6 +45,7 @@ export declare function prepareSimpleReleasePr(cwd?: string, options?: {
 /** @deprecated Use openOrUpdateReviewRequest. */
 export declare function openOrUpdateSimpleReviewRequest(cwd: string, branch: string, title: string, version: string, previousVersion: string, commits: ParsedCommit[], plan?: SimplePlan | null, options?: {
     logger?: VersionaryPluginContext["logger"];
+    highlights?: string;
 }): Promise<string>;
 export declare function pushReleaseBranch(cwd: string, branch: string): void;
 export declare function isReleaseCommitMessage(commitMessage: string): boolean;

package/dist/release/pr.js

@@ -3,6 +3,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNextReleaseFile = getNextReleaseFile;
+exports.readNextReleaseHighlights = readNextReleaseHighlights;
+exports.consumeNextReleaseFile = consumeNextReleaseFile;
 exports.splitSafeDirtyFiles = splitSafeDirtyFiles;
 exports.prepareReleasePr = prepareReleasePr;
 exports.renderSimpleReviewRequestBody = renderSimpleReviewRequestBody;
@@ -13,6 +16,7 @@ exports.openOrUpdateSimpleReviewRequest = openOrUpdateSimpleReviewRequest;
 exports.pushReleaseBranch = pushReleaseBranch;
 exports.isReleaseCommitMessage = isReleaseCommitMessage;
 const node_child_process_1 = require("node:child_process");
+const node_fs_1 = __importDefault(require("node:fs"));
 const node_path_1 = __importDefault(require("node:path"));
 const load_config_js_1 = require("../config/load-config.js");
 const client_js_1 = require("../scm/client.js");
@@ -29,6 +33,38 @@ const SAFE_DIRTY_FILES = new Set([
     "npm-shrinkwrap.json",
 ]);
 const VERSIONARY_RELEASE_TRAILER = "Versionary-Release: true";
+function getNextReleaseFile(config) {
+    return config["next-release-file"] ?? "NEXT_RELEASE.md";
+}
+function readNextReleaseHighlights(cwd, config) {
+    const filePath = getNextReleaseFile(config);
+    const fullPath = node_path_1.default.join(cwd, filePath);
+    if (!node_fs_1.default.existsSync(fullPath)) {
+        return null;
+    }
+    const content = node_fs_1.default.readFileSync(fullPath, "utf8").trim();
+    return { content, filePath };
+}
+function isTrackedFile(cwd, filePath) {
+    try {
+        (0, node_child_process_1.execFileSync)("git", ["ls-files", "--error-unmatch", "--", filePath], {
+            cwd,
+            stdio: ["ignore", "pipe", "ignore"],
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function consumeNextReleaseFile(cwd, filePath) {
+    const tracked = isTrackedFile(cwd, filePath);
+    const fullPath = node_path_1.default.join(cwd, filePath);
+    if (node_fs_1.default.existsSync(fullPath)) {
+        node_fs_1.default.rmSync(fullPath);
+    }
+    return { tracked };
+}
 function listTrackedDirtyFiles(cwd) {
     const status = (0, node_child_process_1.execFileSync)("git", ["status", "--porcelain", "--untracked-files=no"], {
         cwd,
@@ -251,9 +287,18 @@ function prepareReleasePr(cwd = process.cwd(), options = {}) {
     }
     const updatedArtifactFiles = (0, artifact_rules_js_1.applyConfiguredArtifactRules)(cwd, loaded.config, plan);
     const packageReleaseMetadata = buildPackageReleaseMetadata(cwd, plan, loaded.config);
-    const section = (0, changelog_js_1.renderReleasePlanChangelog)(plan);
+    const nextReleaseRead = readNextReleaseHighlights(cwd, loaded.config);
+    const highlights = nextReleaseRead?.content ?? "";
+    const section = (0, changelog_js_1.renderReleasePlanChangelog)(plan, { highlights, cwd });
     (0, changelog_js_1.prependChangelog)(cwd, plan.changelogFile, section, plan.changelogFormat);
     const updatedChangelogFiles = [plan.changelogFile];
+    let consumedHighlightsPath = null;
+    if (nextReleaseRead) {
+        const { tracked } = consumeNextReleaseFile(cwd, nextReleaseRead.filePath);
+        if (tracked) {
+            consumedHighlightsPath = nextReleaseRead.filePath;
+        }
+    }
     for (const packagePlan of plan.packages ?? []) {
         if (!packagePlan.nextVersion || packagePlan.path === ".") {
             continue;
@@ -296,6 +341,7 @@ function prepareReleasePr(cwd = process.cwd(), options = {}) {
             ...updatedVersionFiles,
             ...updatedArtifactFiles,
             ...updatedChangelogFiles,
+            ...(consumedHighlightsPath ? [consumedHighlightsPath] : []),
         ]),
     ];
     (0, node_child_process_1.execFileSync)("git", ["add", ...filesToAdd], {
@@ -325,9 +371,10 @@ function prepareReleasePr(cwd = process.cwd(), options = {}) {
         commits: plan.commits,
         plan,
         updated,
+        highlights,
     };
 }
-function renderSimpleReviewRequestBody(version, previousVersion, commits, plan = null, cwd = process.cwd()) {
+function renderSimpleReviewRequestBody(version, previousVersion, commits, plan = null, cwd = process.cwd(), highlights = "") {
     const rootPackageLabel = node_path_1.default.basename(cwd);
     const formatPackageLabel = (packagePath) => packagePath === "." ? rootPackageLabel : packagePath;
     const isDirectBump = (pkg) => pkg.bumpReason === "direct" ||
@@ -361,6 +408,7 @@ function renderSimpleReviewRequestBody(version, previousVersion, commits, plan =
             const rootNotes = (0, changelog_js_1.renderReleasePlanChangelog)(plan, {
                 headerLabel: `${formatPackageLabel(".")}: ${rootPackage.nextVersion}`,
                 cwd,
+                highlights,
             });
             sections.push(rootNotes);
         }
@@ -393,6 +441,7 @@ function renderSimpleReviewRequestBody(version, previousVersion, commits, plan =
         nextVersion: version,
         commits,
         cwd,
+        highlights,
     }, { includeFooter: true });
 }
 async function openOrUpdateReviewRequest(cwd, branch, title, version, previousVersion, commits, plan = null, options = {}) {
@@ -406,7 +455,7 @@ async function openOrUpdateReviewRequest(cwd, branch, title, version, previousVe
         baseBranch: process.env.VERSIONARY_BASE_BRANCH ?? "main",
         headBranch: branch,
         title,
-        body: renderSimpleReviewRequestBody(version, previousVersion, commits, plan, cwd),
+        body: renderSimpleReviewRequestBody(version, previousVersion, commits, plan, cwd, options.highlights ?? ""),
         labels: ["release"],
     }, {
         cwd,

package/dist/release/semver.d.ts

@@ -1,4 +1,5 @@
 export type ReleaseType = "major" | "minor" | "patch" | null;
+export declare function maxReleaseType(types: ReleaseType[]): ReleaseType;
 export interface ParsedVersion {
     major: number;
     minor: number;

package/dist/release/semver.js

@@ -1,9 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.maxReleaseType = maxReleaseType;
 exports.parseVersion = parseVersion;
 exports.isValidVersion = isValidVersion;
 exports.compareVersions = compareVersions;
 exports.bumpVersion = bumpVersion;
+function maxReleaseType(types) {
+    if (types.includes("major")) {
+        return "major";
+    }
+    if (types.includes("minor")) {
+        return "minor";
+    }
+    if (types.includes("patch")) {
+        return "patch";
+    }
+    return null;
+}
 const SEMVER_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*))*))?(?:\+([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?$/u;
 const COMPAT_DOTTED_PRERELEASE_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/u;
 function normalizeVersionInput(version) {

package/dist/types/config.d.ts

@@ -15,6 +15,7 @@ export interface VersionaryPackage {
     "changelog-format"?: VersionaryChangelogFormat;
     "exclude-paths"?: string[];
     "extra-files"?: VersionaryArtifactRule[];
+    follows?: string[];
 }
 export interface VersionaryConfig {
     version: 1;
@@ -26,6 +27,7 @@ export interface VersionaryConfig {
     "release-reference-comments"?: ReleaseReferenceCommentsMode;
     "release-branch"?: string;
     "baseline-file"?: string;
+    "next-release-file"?: string;
     "bootstrap-sha"?: string;
     "monorepo-mode"?: "independent" | "fixed";
     "bump-minor-pre-major"?: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "versionary",
-  "version": "0.21.0",
+  "version": "0.23.0",
   "description": "Automatic release framework based on conventional commits and semantic versioning",
   "keywords": [
     "releasing",