@tallyrelease/core 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Changelog
 
+## [0.3.0](https://github.com/abinnovision/tally-release/compare/core-v0.2.0...core-v0.3.0) (2026-10-16)
+
+
+### Features
+
+* **cli:** add tallyrelease pr for shared and separate release PRs ([#34](https://github.com/abinnovision/tally-release/issues/34)) ([5dbb294](https://github.com/abinnovision/tally-release/commit/5dbb2944a6f9535511710cbcfa5c6ddfccb14fe8))
+* **cli:** add tallyrelease run and fill released in plans ([#36](https://github.com/abinnovision/tally-release/issues/36)) ([8d90546](https://github.com/abinnovision/tally-release/commit/8d905469ed398a6daaa0e09f4fd9eb9c4c79c818))
+* **core:** add changelog writer, release items and PR marker ([#30](https://github.com/abinnovision/tally-release/issues/30)) ([e74244e](https://github.com/abinnovision/tally-release/commit/e74244ebc4752e3de39614159ef0761f1cd2a33c))
+* tag merged release PRs with tallyrelease release ([#35](https://github.com/abinnovision/tally-release/issues/35)) ([0058045](https://github.com/abinnovision/tally-release/commit/005804542b3f0b18a1a5afdb1a559231f8d10b4d))
+* write version files and changelogs with tallyrelease version ([#33](https://github.com/abinnovision/tally-release/issues/33)) ([5961ce0](https://github.com/abinnovision/tally-release/commit/5961ce0c56b7ddbb4bff2cf154d5b5556212e8cb))
+
 ## [0.2.0](https://github.com/abinnovision/tally-release/compare/core-v0.1.1...core-v0.2.0) (2026-10-15)
 
 

package/dist/base64.d.ts

@@ -0,0 +1,4 @@
+/** Standard padded base64 of the UTF-8 encoding of `text`. */
+export declare const encodeBase64: (text: string) => string;
+/** Text of padded base64 holding UTF-8; undefined when either is malformed. */
+export declare const decodeBase64: (data: string) => string | undefined;

package/dist/base64.js

@@ -0,0 +1,40 @@
+const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const BASE64 = /^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u;
+/** UTF-8 bytes of `text`; throws on lone surrogates. */
+const utf8 = (text) => [...encodeURIComponent(text).matchAll(/%([0-9A-F]{2})|[^%]/gu)].map(([char, hex]) => hex === undefined ? char.charCodeAt(0) : parseInt(hex, 16));
+/** Standard padded base64 of the UTF-8 encoding of `text`. */
+export const encodeBase64 = (text) => {
+    const bytes = utf8(text);
+    let out = "";
+    for (let i = 0; i < bytes.length; i += 3) {
+        const [a = 0, b = 0, c = 0] = bytes.slice(i, i + 3);
+        const n = a * 65536 + b * 256 + c;
+        const chars = [18, 12, 6, 0].map((s) => ALPHABET[Math.floor(n / 2 ** s) % 64]);
+        const pad = 3 - Math.min(3, bytes.length - i);
+        out += chars.slice(0, 4 - pad).join("") + "=".repeat(pad);
+    }
+    return out;
+};
+/** Text of padded base64 holding UTF-8; undefined when either is malformed. */
+export const decodeBase64 = (data) => {
+    if (!BASE64.test(data)) {
+        return undefined;
+    }
+    let hex = "";
+    for (let i = 0; i < data.length; i += 4) {
+        const quad = data.slice(i, i + 4);
+        const pad = quad.length - quad.replace(/=+$/u, "").length;
+        const n = Array.from({ length: 4 }, (_, k) => quad.charAt(k)).reduce((acc, char) => acc * 64 + Math.max(0, ALPHABET.indexOf(char)), 0);
+        const bytes = [16, 8, 0].map((s) => Math.floor(n / 2 ** s) % 256);
+        hex += bytes
+            .slice(0, 3 - pad)
+            .map((b) => `%${b.toString(16).padStart(2, "0")}`)
+            .join("");
+    }
+    try {
+        return decodeURIComponent(hex);
+    }
+    catch {
+        return undefined;
+    }
+};

package/dist/changelog.d.ts

@@ -0,0 +1,65 @@
+import type { PlanChange, Plan } from "./plan.js";
+import type { Unit, VersionScheme } from "./plugin.js";
+import type { Workspace } from "./workspace.js";
+/** `<root>/CHANGELOG.md` of a unit. */
+export declare const changelogPath: (unit: Pick<Unit, "root">) => string;
+export interface ChangelogDependency {
+    /** Manifest field, such as `dependencies`. */
+    field: string;
+    name: string;
+    version: string;
+}
+export interface ChangelogInput {
+    version: string;
+    /** `YYYY-MM-DD`, the date the section is generated. */
+    date: string;
+    /** Repository URL such as `https://github.com/o/r`; null omits all links. */
+    repoUrl: string | null;
+    /** Previous tag of the unit; null omits the compare link. */
+    baseTag: string | null;
+    tag: string;
+    /** Core commit order. */
+    changes: readonly PlanChange[];
+    dependencies?: readonly ChangelogDependency[];
+    /** Group member: lists a synchronize entry when nothing else is listed. */
+    member?: {
+        unit: string;
+        group: string;
+    };
+}
+/**
+ * One version section in release-please format: heading, breaking notes,
+ * sections by commit type with entries sorted like release-please (scope
+ * followed by subject, locale order), then dependencies. No trailing newline.
+ */
+export declare const renderChangelogSection: (input: ChangelogInput) => string;
+/**
+ * The changelog section of a unit with a stable `next` in `plan`, else
+ * undefined. Dependencies are direct edges from units of the same release PR,
+ * named after the edge reason (`<field>: <name>`, else `dependencies` and the
+ * unit id).
+ */
+export declare const changelogSection: (workspace: Workspace, plan: Plan, opts: {
+    id: string;
+    repoUrl: string | null;
+    date: string;
+    /** Units released in the same release PR; dependencies outside it are not listed. */
+    prUnits: readonly string[];
+}) => string | undefined;
+/**
+ * Inserts `section` on top of the version sections of `content` (undefined or blank:
+ * a new file with `# Changelog`). Version headings are `##` or `###` lines,
+ * linked or plain. Sections above `baseVersion` are untagged leftovers and are
+ * replaced; without a base version, sections not below the new version are.
+ * Text before the first version heading and the other sections stay as they
+ * are.
+ */
+export declare const updateChangelog: <V>(content: string | undefined, section: string, { baseVersion, scheme, }: {
+    baseVersion: string | null;
+    scheme: VersionScheme<V>;
+}) => string;
+/**
+ * Top version section of unit `id`'s `<root>/CHANGELOG.md`, heading included,
+ * read through `read`; undefined without a file or a version section.
+ */
+export declare const releaseNotes: (workspace: Workspace, id: string, read: (path: string) => string | undefined) => string | undefined;

package/dist/changelog.js

@@ -0,0 +1,259 @@
+import { schemeRegistry } from "./schemes.js";
+import { renderTag } from "./tags.js";
+import { compare } from "./util.js";
+/** Commit types in section order; hidden sections list only breaking or Release-As changes. */
+const SECTIONS = [
+    ["feat", "Features", false],
+    ["feature", "Features", false],
+    ["fix", "Bug Fixes", false],
+    ["perf", "Performance Improvements", false],
+    ["revert", "Reverts", false],
+    ["docs", "Documentation", true],
+    ["style", "Styles", true],
+    ["chore", "Miscellaneous Chores", true],
+    ["refactor", "Code Refactoring", true],
+    ["test", "Tests", true],
+    ["build", "Build System", true],
+    ["ci", "Continuous Integration", true],
+];
+const TITLES = [...new Set(SECTIONS.map(([, title]) => title))];
+const FIELDS = [
+    "dependencies",
+    "devDependencies",
+    "peerDependencies",
+    "optionalDependencies",
+];
+const VERSION_HEADING = /^###? (?:\[v?([^\]\s]+)\]|v?(\S+))/u;
+const EDGE_REASON = /^([A-Za-z]+): (.+)$/u;
+/** release-please `htmlEscape`: `<` and `>` outside code spans. */
+const htmlEscape = (text) => text.replace(/``[^`].*[^`]``|`[^`]*`|<|>/gu, (m) => m.length > 1 ? m : m === "<" ? "&lt;" : "&gt;");
+/** Subject with the trailing PR reference the commit header had. */
+const withPr = (change) => change.pr === undefined
+    ? change.subject
+    : `${change.subject} (#${String(change.pr)})`;
+/** Subject with its PR, issue and user references linked. */
+const subjectOf = (change, repoUrl) => {
+    const text = htmlEscape(withPr(change));
+    if (repoUrl === null) {
+        return text;
+    }
+    const host = repoUrl.split("/").slice(0, 3).join("/");
+    return text
+        .replace(/#([0-9]+)/gu, (_, n) => `[#${n}](${repoUrl}/issues/${n})`)
+        .replace(/\B@([a-z0-9](?:-?[a-z0-9/]){0,38})/gu, (m, user) => user.includes("/") ? m : `[@${user}](${host}/${user})`);
+};
+/**
+ * Breaking note text as release-please renders it: lines of the first
+ * paragraph joined by spaces, except that from the first later line starting
+ * with `#### `, `* ` or `- ` on, lines are kept below, indented by four
+ * spaces. Without notes, the subject.
+ */
+const noteOf = (change, repoUrl) => {
+    let text = "";
+    let extended = false;
+    for (const [i, line] of (change.notes?.split("\n") ?? []).entries()) {
+        if (i > 0 && !extended && /^#### |^[*-] /u.test(line)) {
+            text = `${text.trim()}\n`;
+            extended = true;
+        }
+        if (line === "") {
+            break;
+        }
+        text += extended ? `    ${line}\n` : `${line} `;
+    }
+    text = change.notes === undefined ? withPr(change) : text.trim();
+    return repoUrl === null
+        ? text
+        : text.replace(/\(#([0-9]+)\)/u, (_, n) => `([#${n}](${repoUrl}/issues/${n}))`);
+};
+const scoped = (scope, text) => `* ${scope === undefined ? "" : `**${scope}:** `}${text}`;
+const via = (change) => change.via === undefined ? "" : ` (via ${change.via})`;
+const dependencyLines = (deps) => {
+    const rank = (field) => {
+        const i = FIELDS.indexOf(field);
+        return i === -1 ? FIELDS.length : i;
+    };
+    const fields = [...new Set(deps.map((d) => d.field))].sort((a, b) => rank(a) - rank(b) || compare(a, b));
+    return [
+        "* The following workspace dependencies were updated",
+        ...fields.flatMap((field) => [
+            `  * ${field}`,
+            ...deps
+                .filter((d) => d.field === field)
+                .sort((a, b) => compare(a.name, b.name))
+                .map((d) => `    * ${d.name} bumped to ${d.version}`),
+        ]),
+    ].join("\n");
+};
+/** Version of a version heading line, else undefined. */
+const headingVersion = (line, scheme) => {
+    const m = VERSION_HEADING.exec(line);
+    const raw = m?.[1] ?? m?.[2];
+    return raw === undefined ? undefined : scheme.parse(raw);
+};
+/** `<root>/CHANGELOG.md` of a unit. */
+export const changelogPath = (unit) => unit.root === "." ? "CHANGELOG.md" : `${unit.root}/CHANGELOG.md`;
+/**
+ * One version section in release-please format: heading, breaking notes,
+ * sections by commit type with entries sorted like release-please (scope
+ * followed by subject, locale order), then dependencies. No trailing newline.
+ */
+export const renderChangelogSection = (input) => {
+    const { repoUrl, changes } = input;
+    const heading = input.baseTag !== null && repoUrl !== null
+        ? `## [${input.version}](${repoUrl}/compare/${input.baseTag}...${input.tag}) (${input.date})`
+        : `## ${input.version} (${input.date})`;
+    const groups = new Map();
+    for (const change of changes) {
+        const section = SECTIONS.find(([type]) => type === change.type.toLowerCase());
+        const listed = section !== undefined &&
+            (!section[2] || change.breaking || change.releaseAs !== undefined);
+        if (!section || !listed) {
+            continue;
+        }
+        const subject = subjectOf(change, repoUrl);
+        const link = repoUrl === null || change.sha === undefined
+            ? ""
+            : ` ([${change.sha.slice(0, 7)}](${repoUrl}/commit/${change.sha}))`;
+        const entries = groups.get(section[1]) ?? [];
+        entries.push({
+            key: `${change.scope ?? ""}${subject}`,
+            line: `${scoped(change.scope, subject)}${link}${via(change)}`,
+        });
+        groups.set(section[1], entries);
+    }
+    const notes = changes
+        .filter((c) => c.breaking)
+        .map((c) => `${scoped(c.scope, noteOf(c, repoUrl))}${via(c)}`);
+    if (input.member && notes.length === 0 && groups.size === 0) {
+        const { unit, group } = input.member;
+        groups.set("Miscellaneous Chores", [
+            { key: "", line: scoped(unit, `Synchronize ${group} versions`) },
+        ]);
+    }
+    let text = `${heading}\n\n`;
+    if (notes.length > 0) {
+        text += `\n### ⚠ BREAKING CHANGES\n\n${notes.map((n) => `${n}\n`).join("")}`;
+    }
+    for (const title of TITLES) {
+        const entries = groups.get(title);
+        if (entries) {
+            const lines = entries
+                .sort((a, b) => a.key.localeCompare(b.key, "en"))
+                .map((e) => `${e.line}\n`);
+            text += `\n### ${title}\n\n${lines.join("")}\n`;
+        }
+    }
+    text = text.trim();
+    const deps = input.dependencies ?? [];
+    return deps.length > 0
+        ? `${text}\n\n\n### Dependencies\n\n${dependencyLines(deps)}`
+        : text;
+};
+/**
+ * The changelog section of a unit with a stable `next` in `plan`, else
+ * undefined. Dependencies are direct edges from units of the same release PR,
+ * named after the edge reason (`<field>: <name>`, else `dependencies` and the
+ * unit id).
+ */
+export const changelogSection = (workspace, plan, opts) => {
+    const { id } = opts;
+    const inPr = new Set(opts.prUnits);
+    const units = new Map(workspace.units.map((u) => [u.id, u]));
+    const planned = new Map(plan.units.map((u) => [u.id, u]));
+    const entry = planned.get(id);
+    const unit = units.get(id);
+    if (!entry || !unit || entry.next === null) {
+        return undefined;
+    }
+    const dependencies = workspace.graph.edges.flatMap((edge) => {
+        const version = planned.get(edge.from)?.next;
+        if (edge.to !== id ||
+            !inPr.has(edge.from) ||
+            version === null ||
+            version === undefined) {
+            return [];
+        }
+        const parsed = edge.reasons.flatMap((r) => {
+            const m = EDGE_REASON.exec(r);
+            return m?.[1] === undefined || m[2] === undefined
+                ? []
+                : [{ field: m[1], name: m[2], version }];
+        });
+        return parsed.length > 0
+            ? parsed
+            : [{ field: "dependencies", name: edge.from, version }];
+    });
+    return renderChangelogSection({
+        version: entry.next,
+        date: opts.date,
+        repoUrl: opts.repoUrl,
+        baseTag: entry.baseTag,
+        tag: renderTag(unit, entry.next),
+        changes: entry.changes,
+        dependencies,
+        ...(entry.group === null
+            ? {}
+            : { member: { unit: id, group: entry.group } }),
+    });
+};
+/**
+ * Inserts `section` on top of the version sections of `content` (undefined or blank:
+ * a new file with `# Changelog`). Version headings are `##` or `###` lines,
+ * linked or plain. Sections above `baseVersion` are untagged leftovers and are
+ * replaced; without a base version, sections not below the new version are.
+ * Text before the first version heading and the other sections stay as they
+ * are.
+ */
+export const updateChangelog = (content, section, { baseVersion, scheme, }) => {
+    const lines = (content?.trim() ? content : "# Changelog\n").split("\n");
+    const base = baseVersion === null ? undefined : scheme.parse(baseVersion);
+    const next = headingVersion(section.split("\n")[0] ?? "", scheme);
+    const stale = (v) => base !== undefined
+        ? scheme.compare(v, base) > 0
+        : next !== undefined && scheme.compare(v, next) >= 0;
+    const preamble = [];
+    const kept = [];
+    let keep;
+    for (const line of lines) {
+        const version = headingVersion(line, scheme);
+        if (version !== undefined) {
+            keep = !stale(version);
+        }
+        if (keep === undefined) {
+            preamble.push(line);
+        }
+        else if (keep) {
+            kept.push(line);
+        }
+    }
+    const rest = kept.join("\n").trim();
+    return `${[preamble.join("\n").trimEnd(), section, rest]
+        .filter((part) => part !== "")
+        .join("\n\n")}\n`;
+};
+/**
+ * Top version section of unit `id`'s `<root>/CHANGELOG.md`, heading included,
+ * read through `read`; undefined without a file or a version section.
+ */
+export const releaseNotes = (workspace, id, read) => {
+    const unit = workspace.units.find((u) => u.id === id);
+    const scheme = unit && schemeRegistry(workspace.schemes).get(unit.scheme);
+    const content = unit && read(changelogPath(unit));
+    if (!scheme || content === undefined) {
+        return undefined;
+    }
+    const section = [];
+    for (const line of content.split("\n")) {
+        if (headingVersion(line, scheme) !== undefined) {
+            if (section.length > 0) {
+                break;
+            }
+        }
+        else if (section.length === 0) {
+            continue;
+        }
+        section.push(line);
+    }
+    return section.length === 0 ? undefined : section.join("\n").trim();
+};

package/dist/config.d.ts

@@ -1,4 +1,6 @@
 import type { BumpLevel, Propagate, VersionSource } from "./plugin.js";
+/** Release PR of a release item: the shared PR or its own. */
+export type ReleasePrMode = "shared" | "separate";
 /** Config overlay for the unit at a root; creates a config-only unit if none is discovered. */
 export interface UnitOverlay {
     id?: string;
@@ -15,6 +17,18 @@ export interface UnitOverlay {
     tags?: string[];
     /** First release version, parsed by the unit's scheme. */
     initialVersion?: string;
+    /** Ungrouped released units only; default `defaults.releasePr`. */
+    releasePr?: ReleasePrMode;
+    /** Templated text replacements written on release. */
+    versionFiles?: VersionTemplate[];
+}
+/**
+ * A text file holding a unit's version. `file` is relative to the repository
+ * root; `pattern` uses `{id}`, `{version}`, `{major}`, `{minor}` and `{patch}`.
+ */
+export interface VersionTemplate {
+    file: string;
+    pattern: string;
 }
 /** A branch rule; the first rule whose `name` matches the branch wins. */
 export interface BranchConfig {
@@ -45,6 +59,8 @@ export interface GroupConfig {
     units?: string[];
     /** Selects released units with any of these tags. */
     tags?: string[];
+    /** Default `defaults.releasePr`. */
+    releasePr?: ReleasePrMode;
 }
 export interface DepConfig {
     from: string;
@@ -64,6 +80,8 @@ export interface TallyConfig {
         tagFormat?: string;
         propagate?: Propagate;
         initialVersion?: string;
+        /** Default `shared`. */
+        releasePr?: ReleasePrMode;
     };
     /** Overlays keyed by unit root. */
     units?: Record<string, UnitOverlay>;
@@ -74,6 +92,10 @@ export interface TallyConfig {
     bumps?: BumpsConfig;
     /** Fixed groups by name; names follow the unit id pattern. */
     groups?: Record<string, GroupConfig>;
+    tags?: {
+        /** Floating tag formats with `{id}`, `{major}` and `{minor}`. */
+        floating?: string[];
+    };
 }
 /** Global input owned by core. */
 export declare const CONFIG_FILE = "tallyrelease.yaml";

package/dist/conventional.js

@@ -76,6 +76,11 @@ export const conventionalCommits = {
     collect: (_ctx, { commits }) => commits.map((commit) => {
         const parsed = parseCommit(commit.message);
         const values = parsed.footers["release-as"] ?? [];
+        // The last breaking footer wins, as in release-please.
+        const notes = [
+            ...(parsed.footers["breaking change"] ?? []),
+            ...(parsed.footers["breaking-change"] ?? []),
+        ].at(-1);
         return {
             sha: commit.sha,
             type: parsed.type,
@@ -83,6 +88,7 @@ export const conventionalCommits = {
             ...(parsed.scope === undefined ? {} : { scope: parsed.scope }),
             subject: parsed.subject,
             ...(parsed.body === undefined ? {} : { body: parsed.body }),
+            ...(notes === undefined ? {} : { notes }),
             ...(parsed.pr === undefined ? {} : { pr: parsed.pr }),
             ...(values.length === 0 ? {} : { releaseAs: values.map(releaseAs) }),
         };

package/dist/discover.d.ts

@@ -1,5 +1,7 @@
 import type { Unit } from "./plugin.js";
 import type { ActivePlugin, PluginEnv } from "./plugins.js";
+/** Drops `.` and empty segments; rejects absolute roots and `..` segments. */
+export declare const normalizeRoot: (root: string) => string;
 /**
  * Runs `discover` hooks in config order, applies config overlays and fills
  * defaults. Returns units sorted by id.

package/dist/discover.js

@@ -4,17 +4,17 @@ import { runHook } from "./plugins.js";
 import { compare, uniqueSorted } from "./util.js";
 const UNIT_ID = /^(?!\.\.?$)[A-Za-z0-9._-]+$/;
 const UNIT_TAG = /^[A-Za-z0-9._-]+$/;
+/** Escapes glob metacharacters so a root matches literally. */
+const escapeGlob = (path) => path.replace(/[[\]{}()!*?+@\\]/g, "\\$&");
+const isInside = (path, root) => path !== root && (root === "." || path.startsWith(`${root}/`));
 /** Drops `.` and empty segments; rejects absolute roots and `..` segments. */
-const normalizeRoot = (root) => {
+export const normalizeRoot = (root) => {
     const segments = root.split("/");
     if (root.startsWith("/") || segments.includes("..")) {
         throw new TallyError("E_ROOT_INVALID", `root "${root}" must be repo-relative without ".." segments`, { root });
     }
     return segments.filter((s) => s !== "" && s !== ".").join("/") || ".";
 };
-/** Escapes glob metacharacters so a root matches literally. */
-const escapeGlob = (path) => path.replace(/[[\]{}()!*?+@\\]/g, "\\$&");
-const isInside = (path, root) => path !== root && (root === "." || path.startsWith(`${root}/`));
 /**
  * Runs `discover` hooks in config order, applies config overlays and fills
  * defaults. Returns units sorted by id.

package/dist/floating.d.ts

@@ -0,0 +1,14 @@
+import type { Unit, VersionScheme } from "./plugin.js";
+/** Throws `E_CONFIG` for a floating tag format with an unknown token. */
+export declare const validateFloating: (formats: readonly string[]) => void;
+/**
+ * Floating tags `version` takes: per format, the rendered name when `version`
+ * is stable and not lower than any stable version among the unit's `tags`
+ * (tag names, others ignored) that renders to the same name. In format order,
+ * without duplicates.
+ */
+export declare const renderFloatingTags: <V>(unit: Pick<Unit, "id" | "tagFormat">, version: string, { tags, scheme, formats, }: {
+    tags: readonly string[];
+    scheme: VersionScheme<V>;
+    formats: readonly string[];
+}) => string[];

package/dist/floating.js

@@ -0,0 +1,44 @@
+import { TallyError } from "./errors.js";
+import { compileTagFormat } from "./tags.js";
+const TOKEN = /\{([^{}]*)\}/gu;
+const TOKENS = new Set(["id", "major", "minor"]);
+/** Throws `E_CONFIG` for a floating tag format with an unknown token. */
+export const validateFloating = (formats) => {
+    for (const format of formats) {
+        const unknown = [...format.matchAll(TOKEN)].find(([, token]) => !TOKENS.has(token ?? ""));
+        if (unknown) {
+            throw new TallyError("E_CONFIG", `floating tag format "${format}" uses unknown token "${unknown[0]}"; use {id}, {major} or {minor}`, { format });
+        }
+    }
+};
+/**
+ * Floating tags `version` takes: per format, the rendered name when `version`
+ * is stable and not lower than any stable version among the unit's `tags`
+ * (tag names, others ignored) that renders to the same name. In format order,
+ * without duplicates.
+ */
+export const renderFloatingTags = (unit, version, { tags, scheme, formats, }) => {
+    const released = scheme.parse(version);
+    if (released === undefined || scheme.isPrerelease(released)) {
+        return [];
+    }
+    const format = compileTagFormat(unit.tagFormat, unit.id);
+    const versions = tags.flatMap((tag) => {
+        const raw = format.match(tag);
+        const v = raw === undefined ? undefined : scheme.parse(raw);
+        return v === undefined || scheme.isPrerelease(v) ? [] : [v];
+    });
+    const render = (pattern, v) => {
+        const { major, minor } = scheme.core(v);
+        return pattern
+            .replaceAll("{id}", unit.id)
+            .replaceAll("{major}", String(major))
+            .replaceAll("{minor}", String(minor));
+    };
+    const names = formats.flatMap((pattern) => {
+        const name = render(pattern, released);
+        const highest = versions.every((v) => render(pattern, v) !== name || scheme.compare(v, released) <= 0);
+        return highest ? [name] : [];
+    });
+    return [...new Set(names)];
+};

package/dist/index.d.ts

@@ -1,28 +1,37 @@
 export declare const version = "0.0.0";
 export type { AffectedDoc, AffectedOptions, AffectedReason, AffectedUnit, BaseSource, } from "./affected.js";
+export type { ChangelogDependency, ChangelogInput } from "./changelog.js";
 export type { ParsedCommit } from "./conventional.js";
 export type { ExplainedChange, ExplainOptions, ReleaseAsFooter, UnitExplanation, } from "./explain.js";
 export type { GroupPlan, Plan, PlanChange, PlanLine, PlanOptions, ReleasedUnit, UnitPlan, } from "./plan.js";
-export type { DepConfig, GroupConfig, TallyConfig, UnitOverlay, } from "./config.js";
+export type { DepConfig, GroupConfig, ReleasePrMode, TallyConfig, UnitOverlay, VersionTemplate, } from "./config.js";
 export type { Warning } from "./errors.js";
 export type { Graph, SourcedEdge } from "./graph.js";
 export type { Group } from "./groups.js";
 export type { BumpLevel, Change, Ctx, Edge, EdgeDraft, GitReader, IntentSource, MaybePromise, Plugin, PreCtx, Propagate, RawCommit, ReadonlyFs, ReleaseAsValue, TagRef, Unit, UnitDraft, VersionFile, VersionMode, VersionScheme, VersionSource, WriteCtx, } from "./plugin.js";
+export type { Marker, MarkerRelease } from "./marker.js";
 export type { ActivePlugin, PluginEnv } from "./plugins.js";
+export type { ReleaseItem } from "./release-items.js";
 export type { BranchRule, ReleaseSettings } from "./release.js";
 export type { SchemeEntry } from "./schemes.js";
 export type { SemVer } from "./semver.js";
 export type { IntentEntry, Workspace, WorkspaceInput } from "./workspace.js";
 export { computeAffected } from "./affected.js";
+export { changelogSection, releaseNotes, renderChangelogSection, updateChangelog, } from "./changelog.js";
 export { CONFIG_FILE } from "./config.js";
 export { conventionalCommits, parseCommit } from "./conventional.js";
 export { discoverUnits } from "./discover.js";
 export { TallyError } from "./errors.js";
 export { explainUnit } from "./explain.js";
+export { renderFloatingTags } from "./floating.js";
 export { buildGraph } from "./graph.js";
 export { definePlugin, defaultUnitId, PLUGIN_API_VERSION } from "./plugin.js";
 export { computePlan } from "./plan.js";
+export { decodeMarker, encodeMarker } from "./marker.js";
 export { activatePlugins } from "./plugins.js";
+export { planEquals, releaseEntries, releaseItems } from "./release-items.js";
+export { highestReleases, releasedFromTags, withReleased } from "./released.js";
 export { semver } from "./semver.js";
 export { validateRelease, validateTags } from "./validate.js";
+export { releaseFiles, versionFileClaims } from "./version-files.js";
 export { loadWorkspace } from "./workspace.js";

package/dist/index.js

@@ -1,14 +1,20 @@
 export const version = "0.0.0";
 export { computeAffected } from "./affected.js";
+export { changelogSection, releaseNotes, renderChangelogSection, updateChangelog, } from "./changelog.js";
 export { CONFIG_FILE } from "./config.js";
 export { conventionalCommits, parseCommit } from "./conventional.js";
 export { discoverUnits } from "./discover.js";
 export { TallyError } from "./errors.js";
 export { explainUnit } from "./explain.js";
+export { renderFloatingTags } from "./floating.js";
 export { buildGraph } from "./graph.js";
 export { definePlugin, defaultUnitId, PLUGIN_API_VERSION } from "./plugin.js";
 export { computePlan } from "./plan.js";
+export { decodeMarker, encodeMarker } from "./marker.js";
 export { activatePlugins } from "./plugins.js";
+export { planEquals, releaseEntries, releaseItems } from "./release-items.js";
+export { highestReleases, releasedFromTags, withReleased } from "./released.js";
 export { semver } from "./semver.js";
 export { validateRelease, validateTags } from "./validate.js";
+export { releaseFiles, versionFileClaims } from "./version-files.js";
 export { loadWorkspace } from "./workspace.js";

package/dist/marker.d.ts

@@ -0,0 +1,17 @@
+/** A release recorded in a release PR marker. */
+export interface MarkerRelease {
+    id: string;
+    version: string;
+    tag: string;
+}
+/** Release PR marker, version 1. */
+export interface Marker {
+    /** Line head the release commit was built on. */
+    head: string;
+    releaseCommit: string;
+    releases: MarkerRelease[];
+}
+/** `<!-- tallyrelease-plan:v1 <base64 json> -->` holding only the marker fields. */
+export declare const encodeMarker: ({ head, releaseCommit, releases, }: Marker) => string;
+/** The marker in a PR body; undefined when missing or malformed. */
+export declare const decodeMarker: (body: string) => Marker | undefined;