@tallyrelease/core 0.3.2-beta.4 → 0.4.0-beta.10

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.3.2](https://github.com/abinnovision/tallyrelease/compare/core-v0.3.1...core-v0.3.2) (2026-10-16)
+
+
+### Miscellaneous Chores
+
+* **core:** Synchronize tallyrelease versions
+
 ## [0.3.1](https://github.com/abinnovision/tallyrelease/compare/core-v0.3.0...core-v0.3.1) (2026-10-16)
 
 

package/dist/affected.js

@@ -1,4 +1,5 @@
 import { attribution, matcher } from "./attribution.js";
+import { changelogPath } from "./changelog.js";
 import { uniqueSorted } from "./util.js";
 /** Computes the build set for `base..head` from a tree-to-tree diff. */
 export const computeAffected = async (workspace, git, opts) => {
@@ -30,7 +31,11 @@ export const computeAffected = async (workspace, git, opts) => {
     const ignored = matcher(workspace.ignore);
     const isGlobal = matcher(workspace.globalInputs);
     const owners = attribution(units);
-    const files = (await git.diffFiles(opts.base, opts.head)).filter((f) => !ignored(f));
+    // A released unit owns its changelog regardless of ignore, include and exclude.
+    const changelogs = new Map(units
+        .filter((u) => u.version !== "none")
+        .map((u) => [changelogPath(u), u.id]));
+    const files = (await git.diffFiles(opts.base, opts.head)).filter((f) => changelogs.has(f) || !ignored(f));
     const hits = uniqueSorted(files.filter(isGlobal));
     const direct = new Set();
     const unattributed = [];
@@ -38,7 +43,8 @@ export const computeAffected = async (workspace, git, opts) => {
         if (isGlobal(file)) {
             continue;
         }
-        const ids = owners(file);
+        const own = changelogs.get(file);
+        const ids = own === undefined ? owners(file) : [own];
         if (ids.length === 0) {
             unattributed.push(file);
         }

package/dist/branches.d.ts

@@ -1,5 +1,8 @@
+import type { Plan } from "./plan.js";
 import type { BumpLevel } from "./plugin.js";
+import type { ReleaseItem as PrItem } from "./release-items.js";
 import type { BranchRule } from "./release.js";
+import type { Workspace } from "./workspace.js";
 /** The branch rule matching the planned branch. */
 export interface Line {
     rule: string;
@@ -68,3 +71,16 @@ export declare const checkLimits: (line: Line | null, items: readonly LimitItem[
     branch: string;
     implicit: boolean;
 }) => void;
+/** A maintenance branch to cut at the last release of the previous major. */
+export interface MaintenanceCut {
+    branch: string;
+    tag: string;
+    /** `2.x`, or `2.3.x` for a `{minor}` rule. */
+    line: string;
+}
+/**
+ * The cut for `item` when a default-line plan releases a new major: the first
+ * maintenance rule with `{major}` and no `*` that targets the item or nothing,
+ * rendered from `from`, at the item's base tag; else undefined.
+ */
+export declare const maintenanceCut: (workspace: Workspace, plan: Plan, item: PrItem) => MaintenanceCut | undefined;

package/dist/branches.js

@@ -1,4 +1,5 @@
 import { TallyError } from "./errors.js";
+import { schemeRegistry } from "./schemes.js";
 import { maxLevel } from "./util.js";
 const SPECIAL = /[\\^$.*+?()[\]{}|/]/gu;
 const PART = /\{(major|minor)\}|\*/gu;
@@ -166,3 +167,45 @@ export const checkLimits = (line, items, { branch, implicit }) => {
         });
     }
 };
+/**
+ * The cut for `item` when a default-line plan releases a new major: the first
+ * maintenance rule with `{major}` and no `*` that targets the item or nothing,
+ * rendered from `from`, at the item's base tag; else undefined.
+ */
+export const maintenanceCut = (workspace, plan, item) => {
+    const base = item.kind === "group"
+        ? plan.groups.find((g) => g.name === item.name)
+        : plan.units.find((u) => u.id === item.name);
+    const unit = workspace.units.find((u) => u.id === item.units[0]);
+    const scheme = unit && schemeRegistry(workspace.schemes).get(unit.scheme);
+    if (plan.line?.kind !== "default" ||
+        !scheme ||
+        !base?.from ||
+        !base.baseTag) {
+        return undefined;
+    }
+    const from = scheme.parse(base.from);
+    const next = scheme.parse(item.version);
+    if (from === undefined || next === undefined) {
+        return undefined;
+    }
+    const { major, minor } = scheme.core(from);
+    const rule = workspace.release.branches.find((r) => r.line === "maintenance" &&
+        r.name.includes("{major}") &&
+        !r.name.includes("*") &&
+        ((r.unit === null && r.group === null) ||
+            (item.kind === "group" ? r.group : r.unit) === item.name));
+    if (!rule || scheme.core(next).major <= major) {
+        return undefined;
+    }
+    const withMinor = rule.name.includes("{minor}");
+    return {
+        branch: rule.name
+            .replace("{major}", String(major))
+            .replace("{minor}", String(minor)),
+        tag: base.baseTag,
+        line: withMinor
+            ? `${String(major)}.${String(minor)}.x`
+            : `${String(major)}.x`,
+    };
+};

package/dist/config.d.ts

@@ -1,7 +1,11 @@
 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. */
+/**
+ * Config overlay for the unit at a root; creates a config-only unit if none is
+ * discovered. A glob key (`*` matches one segment, not dot directories) never
+ * creates units and cannot set `id`, `include`, `exclude` or `versionFiles`.
+ */
 export interface UnitOverlay {
     id?: string;
     include?: string[];
@@ -83,7 +87,7 @@ export interface TallyConfig {
         /** Default `shared`. */
         releasePr?: ReleasePrMode;
     };
-    /** Overlays keyed by unit root. */
+    /** Overlays keyed by unit root or glob; exact keys win over globs per field. */
     units?: Record<string, UnitOverlay>;
     deps?: DepConfig[];
     ignore?: string[];

package/dist/discover.d.ts

@@ -1,9 +1,10 @@
+import type { Warning } from "./errors.js";
 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.
+ * Runs `discover` hooks in config order, applies config overlays (glob keys
+ * first, then exact keys) and fills defaults. Returns units sorted by id.
  */
-export declare const discoverUnits: (active: readonly ActivePlugin[], env: Pick<PluginEnv, "config" | "fs" | "repo">) => Promise<Unit[]>;
+export declare const discoverUnits: (active: readonly ActivePlugin[], env: Pick<PluginEnv, "config" | "fs" | "repo">, warnings?: Warning[]) => Promise<Unit[]>;

package/dist/discover.js

@@ -7,6 +7,41 @@ 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}/`));
+/** Fields a glob overlay cannot set. */
+const GLOB_REJECTED = ["id", "include", "exclude", "versionFiles"];
+/**
+ * Validates a glob key and returns its segments: each is `*` (any segment not
+ * starting with `.`) or a literal.
+ */
+const globSegments = (key, root, overlay) => {
+    const segments = root.split("/");
+    if (segments.some((s) => s !== "*" && s.includes("*"))) {
+        throw new TallyError("E_UNIT_GLOB", `unit overlay "${key}" may use "*" only as a whole path segment`, { key });
+    }
+    const field = GLOB_REJECTED.find((f) => overlay[f] !== undefined);
+    if (field !== undefined) {
+        throw new TallyError("E_UNIT_GLOB", `unit overlay "${key}" cannot set "${field}" on a glob key`, { key, field });
+    }
+    return segments;
+};
+const globMatches = (segments, root) => {
+    const parts = root.split("/");
+    return (parts.length === segments.length &&
+        parts.every((p, i) => segments[i] === "*" ? !p.startsWith(".") : segments[i] === p));
+};
+/** Merges draft fields; sets `release`, `tags` and `initialVersion` when defined. */
+const applyOverlay = (entry, { release, tags, initialVersion, ...overlay }) => {
+    entry.draft = { ...entry.draft, ...overlay };
+    if (release !== undefined) {
+        entry.release = release;
+    }
+    if (tags !== undefined) {
+        entry.tags = tags;
+    }
+    if (initialVersion !== undefined) {
+        entry.initialVersion = initialVersion;
+    }
+};
 /** Drops `.` and empty segments; rejects absolute roots and `..` segments. */
 export const normalizeRoot = (root) => {
     const segments = root.split("/");
@@ -16,10 +51,10 @@ export const normalizeRoot = (root) => {
     return segments.filter((s) => s !== "" && s !== ".").join("/") || ".";
 };
 /**
- * Runs `discover` hooks in config order, applies config overlays and fills
- * defaults. Returns units sorted by id.
+ * Runs `discover` hooks in config order, applies config overlays (glob keys
+ * first, then exact keys) and fills defaults. Returns units sorted by id.
  */
-export const discoverUnits = async (active, env) => {
+export const discoverUnits = async (active, env, warnings = []) => {
     const byRoot = new Map();
     for (const { plugin, ctx } of active) {
         const discover = plugin.discover?.bind(plugin);
@@ -41,33 +76,43 @@ export const discoverUnits = async (active, env) => {
             });
         }
     }
-    for (const [key, { release, tags, initialVersion, ...overlay },] of Object.entries(env.config.units ?? {})) {
+    const exact = [];
+    const globs = [];
+    for (const [key, overlay] of Object.entries(env.config.units ?? {})) {
         const root = normalizeRoot(key);
-        const invalid = tags?.find((t) => !UNIT_TAG.test(t));
+        const invalid = overlay.tags?.find((t) => !UNIT_TAG.test(t));
         if (invalid !== undefined) {
             throw new TallyError("E_UNIT_TAG", `tag "${invalid}" of unit at "${root}" must match ${UNIT_TAG.source}`, { tag: invalid, root });
         }
-        const entry = byRoot.get(root);
-        if (entry) {
-            entry.draft = { ...entry.draft, ...overlay };
-            entry.release = release;
-            entry.tags = tags;
-            entry.initialVersion = initialVersion;
+        if (root.includes("*")) {
+            globs.push([key, globSegments(key, root, overlay), overlay]);
+            continue;
         }
-        else {
-            byRoot.set(root, {
+        let entry = byRoot.get(root);
+        if (!entry) {
+            entry = {
                 plugin: "config",
-                draft: {
-                    ...overlay,
-                    id: overlay.id ?? defaultUnitId(root, env.repo.name),
-                    root,
-                },
+                draft: { id: overlay.id ?? defaultUnitId(root, env.repo.name), root },
                 meta: {},
-                release,
-                tags,
-                initialVersion,
+            };
+            byRoot.set(root, entry);
+        }
+        exact.push([entry, overlay]);
+    }
+    for (const [key, segments, overlay] of globs) {
+        const matched = [...byRoot.entries()].filter(([root]) => globMatches(segments, root));
+        if (matched.length === 0) {
+            warnings.push({
+                code: "W_UNIT_GLOB_UNMATCHED",
+                message: `unit overlay "${key}" matches no unit`,
             });
         }
+        for (const [, entry] of matched) {
+            applyOverlay(entry, overlay);
+        }
+    }
+    for (const [entry, overlay] of exact) {
+        applyOverlay(entry, overlay);
     }
     const byId = new Map();
     for (const entry of byRoot.values()) {

package/dist/explain.js

@@ -1,4 +1,5 @@
 import { attribution, matcher } from "./attribution.js";
+import { changelogPath } from "./changelog.js";
 import { TallyError } from "./errors.js";
 import { planWithFacts } from "./plan.js";
 /** Explains one unit of the plan of `opts.head`; throws `E_UNIT_UNKNOWN`. */
@@ -16,7 +17,16 @@ export const explainUnit = async (workspace, git, { unit: id, ...opts }) => {
     const ignored = matcher(workspace.ignore);
     const isGlobal = matcher(workspace.globalInputs);
     const owners = attribution(workspace.units);
-    const owned = (files, owner) => files.filter((f) => !ignored(f) && !isGlobal(f) && owners(f).includes(owner));
+    // As in `computeAffected`: a released unit owns its changelog.
+    const changelogs = new Map(workspace.units
+        .filter((u) => u.version !== "none")
+        .map((u) => [changelogPath(u), u.id]));
+    const owned = (files, owner) => files.filter((f) => {
+        const own = changelogs.get(f);
+        return own === undefined
+            ? !ignored(f) && !isGlobal(f) && owners(f).includes(owner)
+            : own === owner && !isGlobal(f);
+    });
     const { base } = plan.build;
     const reason = unit?.affected?.reason;
     const files = reason === "global"

package/dist/index.d.ts

@@ -17,6 +17,7 @@ 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 { maintenanceCut } from "./branches.js";
 export { changelogSection, releaseNotes, renderChangelogSection, updateChangelog, } from "./changelog.js";
 export { CONFIG_FILE } from "./config.js";
 export { conventionalCommits, parseCommit } from "./conventional.js";
@@ -30,7 +31,7 @@ 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 { releasedFromTags, withReleased } from "./released.js";
 export { semver } from "./semver.js";
 export { validateRelease, validateTags } from "./validate.js";
 export { releaseFiles, versionFileClaims } from "./version-files.js";

package/dist/index.js

@@ -1,5 +1,6 @@
 export const version = "0.0.0";
 export { computeAffected } from "./affected.js";
+export { maintenanceCut } from "./branches.js";
 export { changelogSection, releaseNotes, renderChangelogSection, updateChangelog, } from "./changelog.js";
 export { CONFIG_FILE } from "./config.js";
 export { conventionalCommits, parseCommit } from "./conventional.js";
@@ -13,7 +14,7 @@ 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 { releasedFromTags, withReleased } from "./released.js";
 export { semver } from "./semver.js";
 export { validateRelease, validateTags } from "./validate.js";
 export { releaseFiles, versionFileClaims } from "./version-files.js";

package/dist/plan.d.ts

@@ -63,9 +63,24 @@ export interface ReleasedUnit {
     tag: string;
     floatingTags: string[];
     releaseSha: string;
+    /** Not built from HEAD by this run (release sha differs from HEAD, or the unit is outside the build set). */
     catchUp: boolean;
-    pr: number | null;
+    /** Null when not looked up (no forge, or a forge error in `plan`). */
+    forge: ReleasedForge | null;
     line: "default" | "maintenance";
+    /** Highest stable version tagged for the unit, never on a maintenance line. */
+    latest: boolean;
+}
+export interface ReleasedForge {
+    /** PR that merged the release sha. */
+    pr: {
+        number: number;
+        url: string;
+    } | null;
+    /** Forge release of the tag. */
+    release: {
+        url: string;
+    } | null;
 }
 /** `tallyrelease plan --json`, schema 1. */
 export interface Plan extends Omit<AffectedDoc, "units"> {

package/dist/released.d.ts

@@ -5,7 +5,8 @@ import type { Workspace } from "./workspace.js";
  * `plan` with `released`: stable unit tags whose commit is on HEAD's
  * first-parent chain and not an ancestor of `build.base`. With a null base
  * only tags at HEAD, warning `W_RELEASED_NO_BASE` when earlier releases on the
- * chain are left out.
+ * chain are left out. A release at HEAD of a unit outside the build set warns
+ * `W_RELEASE_NOT_BUILT`.
  */
 export declare const withReleased: (workspace: Workspace, plan: Plan, { git }: {
     git: GitReader;
@@ -19,7 +20,3 @@ export declare const releasedFromTags: (workspace: Workspace, plan: Plan, { git,
     git: GitReader;
     tags: readonly string[];
 }) => Promise<ReleasedUnit[]>;
-/** Tag of the highest stable version of each released unit with one. */
-export declare const highestReleases: (workspace: Workspace, { git }: {
-    git: GitReader;
-}) => Promise<Set<string>>;

package/dist/released.js

@@ -14,12 +14,14 @@ const stable = (scheme, version) => {
 const releasedEntries = async (workspace, plan, { git, keep, }) => {
     const matched = matchUnitTags(workspace.units, await git.tags(), schemeRegistry(workspace.schemes));
     const line = plan.line?.kind ?? "default";
+    const built = new Set(plan.units.filter((u) => u.affected !== null).map((u) => u.id));
     const candidates = workspace.units.flatMap((unit) => {
         const m = matched.get(unit.id);
         if (!m) {
             return [];
         }
         const names = m.tags.map((t) => t.name);
+        const highest = m.tags.findLast((t) => stable(m.scheme, t.version))?.name;
         return m.tags
             .filter((tag) => stable(m.scheme, tag.version))
             .map((tag) => ({
@@ -33,9 +35,10 @@ const releasedEntries = async (workspace, plan, { git, keep, }) => {
                 formats: workspace.release.floating,
             }),
             releaseSha: tag.sha,
-            catchUp: tag.sha !== plan.head,
-            pr: null,
+            catchUp: tag.sha !== plan.head || !built.has(unit.id),
+            forge: null,
             line,
+            latest: line !== "maintenance" && tag.name === highest,
         }));
     });
     const kept = await Promise.all(candidates.map(async (r) => await keep({ name: r.tag, sha: r.releaseSha, version: r.version })));
@@ -52,7 +55,8 @@ const releasedEntries = async (workspace, plan, { git, keep, }) => {
  * `plan` with `released`: stable unit tags whose commit is on HEAD's
  * first-parent chain and not an ancestor of `build.base`. With a null base
  * only tags at HEAD, warning `W_RELEASED_NO_BASE` when earlier releases on the
- * chain are left out.
+ * chain are left out. A release at HEAD of a unit outside the build set warns
+ * `W_RELEASE_NOT_BUILT`.
  */
 export const withReleased = async (workspace, plan, { git }) => {
     const { head } = plan;
@@ -75,14 +79,23 @@ export const withReleased = async (workspace, plan, { git }) => {
             return true;
         },
     });
-    const warnings = omitted === 0
-        ? []
-        : [
-            {
-                code: "W_RELEASED_NO_BASE",
-                message: "the build base is unknown; released leaves out earlier releases on the first-parent chain",
-            },
-        ];
+    const warnings = [
+        ...(omitted === 0
+            ? []
+            : [
+                {
+                    code: "W_RELEASED_NO_BASE",
+                    message: "the build base is unknown; released leaves out earlier releases on the first-parent chain",
+                },
+            ]),
+        ...released
+            .filter((r) => r.releaseSha === head && r.catchUp)
+            .map((r) => ({
+            code: "W_RELEASE_NOT_BUILT",
+            message: `release ${r.tag} is at HEAD but unit ${r.id} is not in the build set; it is listed as a catch-up`,
+            unit: r.id,
+        })),
+    ];
     return { ...plan, released, warnings: [...plan.warnings, ...warnings] };
 };
 /**
@@ -97,8 +110,3 @@ export const releasedFromTags = async (workspace, plan, { git, tags }) => {
         keep: (tag) => names.has(tag.name),
     });
 };
-/** Tag of the highest stable version of each released unit with one. */
-export const highestReleases = async (workspace, { git }) => {
-    const matched = matchUnitTags(workspace.units, await git.tags(), schemeRegistry(workspace.schemes));
-    return new Set([...matched.values()].flatMap(({ scheme, tags }) => tags.findLast((t) => stable(scheme, t.version))?.name ?? []));
-};

package/dist/workspace.js

@@ -70,7 +70,7 @@ const versionFilesOf = (active, units) => {
 export const loadWorkspace = async (input) => {
     const warnings = [];
     const active = await activatePlugins(input, warnings);
-    const units = await discoverUnits(active, input);
+    const units = await discoverUnits(active, input, warnings);
     const graph = buildGraph(units, await collectEdges(active, input.config, units));
     const globalInputs = await collectGlobalInputs(active, input.config, input.configFile ?? CONFIG_FILE);
     const groups = resolveGroups(units, input.config.groups, warnings);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tallyrelease/core",
-  "version": "0.3.2-beta.4",
+  "version": "0.4.0-beta.10",
   "description": "Pure planning core of tallyrelease",
   "repository": {
     "type": "git",