@tallyrelease/core 0.5.0-beta.52 → 0.5.0-beta.60

package/dist/builtin.js

@@ -1,3 +1,4 @@
+import { calver } from "./calver.js";
 import { conventionalCommits } from "./conventional.js";
 import { PLUGIN_API_VERSION } from "./plugin.js";
 import { semver } from "./semver.js";
@@ -7,6 +8,6 @@ export const CORE_PLUGIN = "core";
 export const corePlugin = {
     apiVersion: PLUGIN_API_VERSION,
     name: CORE_PLUGIN,
-    schemes: { semver },
+    schemes: { semver, calver },
     intent: [conventionalCommits],
 };

package/dist/calver.d.ts

@@ -0,0 +1,8 @@
+import type { VersionScheme } from "./plugin.js";
+import type { SemVer } from "./semver.js";
+/**
+ * Calendar versions `Y.M.N` with SemVer syntax: every bump increments `N`,
+ * releasing moves to `Y.M.0` of the planned commit's UTC date when that
+ * month is newer.
+ */
+export declare const calver: VersionScheme<SemVer>;

package/dist/calver.js

@@ -0,0 +1,37 @@
+import { semver } from "./semver.js";
+/** Year and month of `ctx.date` in UTC. */
+const monthOf = (ctx) => {
+    if (ctx.date === undefined) {
+        throw new Error("calver needs the commit date; the git reader does not provide commitDate");
+    }
+    const date = Date.parse(ctx.date);
+    if (Number.isNaN(date)) {
+        throw new Error(`calver cannot parse the commit date "${ctx.date}"`);
+    }
+    const utc = new Date(date);
+    return { year: utc.getUTCFullYear(), month: utc.getUTCMonth() + 1 };
+};
+/** `next`, or `Y.M.0` of the commit date when that month is newer. */
+const release = (next, ctx) => {
+    const { year, month } = monthOf(ctx);
+    const newer = year > next.major || (year === next.major && month > next.minor);
+    return newer
+        ? { major: year, minor: month, patch: 0, prerelease: [], build: [] }
+        : next;
+};
+/**
+ * Calendar versions `Y.M.N` with SemVer syntax: every bump increments `N`,
+ * releasing moves to `Y.M.0` of the planned commit's UTC date when that
+ * month is newer.
+ */
+export const calver = {
+    ...semver,
+    parse: (raw) => {
+        const v = semver.parse(raw);
+        return v && v.build.length === 0 ? v : undefined;
+    },
+    initial: () => ({ major: 0, minor: 0, patch: 0, prerelease: [], build: [] }),
+    bump: (v) => semver.bump(v, "patch"),
+    release,
+    prerelease: (next, ctx) => semver.prerelease(release(next, ctx), ctx),
+};

package/dist/codes.js

@@ -94,7 +94,7 @@ export const coreCodes = defineCodes({
         fix: "Fix the options named in the message, or remove them.",
     },
     E_PLUGIN_UNKNOWN: {
-        cause: "`plugins` lists a name that matches no built-in plugin (`node`, `php`, `kustomize`).",
+        cause: "`plugins` lists a name that matches no built-in plugin (`node`, `php`, `kustomize`, `dart`).",
         fix: "Correct the plugin name in `plugins`, or remove the entry.",
     },
     E_RELEASE_ITEM_NAME: {

package/dist/facts.js

@@ -212,7 +212,12 @@ export const rangeFacts = (workspace, git, opts) => {
         const changes = [];
         for (const { plugin, source, ctx: sourceCtx } of intents) {
             // eslint-disable-next-line no-await-in-loop -- hooks run sequentially in config order
-            const collected = await runHook(plugin, "intent", () => source.collect(sourceCtx, { from, to: head, commits }));
+            const collected = await runHook(plugin, "intent", () => source.collect(sourceCtx, {
+                from,
+                to: head,
+                commits,
+                units: workspace.units,
+            }));
             warnUnknown(plugin, collected);
             changes.push(...collected);
         }
@@ -234,6 +239,7 @@ export const rangeFacts = (workspace, git, opts) => {
 /** Runs every `GitReader` and intent source call a plan needs. */
 export const collectPlanFacts = async (workspace, git, opts) => {
     const { head } = opts;
+    const date = await git.commitDate?.(head);
     const line = await lineFacts(git, head);
     const { tags, bases, groups, isAncestor, tagNames } = await tagFacts(workspace, git, line);
     const { range, all, warnings } = rangeFacts(workspace, git, opts);
@@ -278,5 +284,13 @@ export const collectPlanFacts = async (workspace, git, opts) => {
             }))),
         });
     }
-    return { head, units, ranges: all(), groups, tagNames, warnings };
+    return {
+        head,
+        ...(date === undefined ? {} : { date }),
+        units,
+        ranges: all(),
+        groups,
+        tagNames,
+        warnings,
+    };
 };

package/dist/flutter.d.ts

@@ -0,0 +1,14 @@
+import type { VersionScheme } from "./plugin.js";
+/** A parsed flutter version `x.y.z+build`. */
+export interface FlutterVersion {
+    major: number;
+    minor: number;
+    patch: number;
+    build: number;
+}
+/**
+ * Flutter `x.y.z+build` scheme. The build number is the larger of the
+ * first-parent total plus the owning plugin's `buildOffset` meta and the
+ * highest tagged build plus one.
+ */
+export declare const flutter: VersionScheme<FlutterVersion>;

package/dist/flutter.js

@@ -0,0 +1,48 @@
+const RE = /^(\d+)\.(\d+)\.(\d+)\+(\d+)$/u;
+/** A version at the end of a tag name. */
+const TAG_VERSION = /\d+\.\d+\.\d+\+\d+$/u;
+const bumpCore = (v, level) => {
+    switch (level) {
+        case "major":
+            return { ...v, major: v.major + 1, minor: 0, patch: 0 };
+        case "minor":
+            return { ...v, minor: v.minor + 1, patch: 0 };
+        case "patch":
+            return { ...v, patch: v.patch + 1 };
+    }
+};
+const parse = (raw) => {
+    const m = RE.exec(raw);
+    return m
+        ? {
+            major: Number(m[1]),
+            minor: Number(m[2]),
+            patch: Number(m[3]),
+            build: Number(m[4]),
+        }
+        : undefined;
+};
+const buildNo = (ctx) => {
+    const tagged = ctx.tags.map((t) => parse(TAG_VERSION.exec(t)?.[0] ?? "")?.build ?? 0);
+    const offset = Number(ctx.unit.meta[ctx.unit.plugin]?.["buildOffset"] ?? 0);
+    return Math.max(ctx.firstParent.total + offset, Math.max(0, ...tagged) + 1);
+};
+/**
+ * Flutter `x.y.z+build` scheme. The build number is the larger of the
+ * first-parent total plus the owning plugin's `buildOffset` meta and the
+ * highest tagged build plus one.
+ */
+export const flutter = {
+    parse,
+    format: (v) => `${[v.major, v.minor, v.patch].join(".")}+${String(v.build)}`,
+    compare: (a, b) => a.major - b.major ||
+        a.minor - b.minor ||
+        a.patch - b.patch ||
+        a.build - b.build,
+    core: ({ major, minor, patch }) => ({ major, minor, patch }),
+    isPrerelease: () => false,
+    initial: () => ({ major: 0, minor: 1, patch: 0, build: 0 }),
+    bump: (v, level) => bumpCore(v, level),
+    release: (next, ctx) => ({ ...next, build: buildNo(ctx) }),
+    prerelease: (next, ctx) => ({ ...next, build: buildNo(ctx) }),
+};

package/dist/index.d.ts

@@ -14,10 +14,12 @@ export type { BumpLevel, Change, Ctx, Edge, EdgeDraft, GitReader, IntentSource,
 export type { Marker, MarkerRelease } from "./marker.js";
 export type { ReleaseItem } from "./release-items.js";
 export type { ReleaseSettings } from "./release-settings.js";
+export type { FlutterVersion } from "./flutter.js";
 export type { SemVer } from "./semver.js";
 export type { TagFormat } from "./tags.js";
 export type { IntentEntry, Workspace, WorkspaceInput } from "./workspace.js";
 export { computeAffected } from "./affected.js";
+export { calver } from "./calver.js";
 export { maintenanceCut } from "./branches.js";
 export { releaseNotes } from "./changelog.js";
 export { coreCodes, defineCodes } from "./codes.js";
@@ -25,6 +27,7 @@ export { CONFIG_FILE } from "./config.js";
 export { parseCommit } from "./conventional.js";
 export { TallyError } from "./errors.js";
 export { explainUnit } from "./explain.js";
+export { flutter } from "./flutter.js";
 export { definePlugin, defaultUnitId, PLUGIN_API_VERSION } from "./plugin.js";
 export { computePlan } from "./plan.js";
 export { decodeMarker, encodeMarker } from "./marker.js";

package/dist/index.js

@@ -1,6 +1,7 @@
 /** @deprecated Unused, will be removed in 1.0. */
 export const version = "0.0.0";
 export { computeAffected } from "./affected.js";
+export { calver } from "./calver.js";
 export { maintenanceCut } from "./branches.js";
 export { releaseNotes } from "./changelog.js";
 export { coreCodes, defineCodes } from "./codes.js";
@@ -8,6 +9,7 @@ export { CONFIG_FILE } from "./config.js";
 export { parseCommit } from "./conventional.js";
 export { TallyError } from "./errors.js";
 export { explainUnit } from "./explain.js";
+export { flutter } from "./flutter.js";
 export { definePlugin, defaultUnitId, PLUGIN_API_VERSION } from "./plugin.js";
 export { computePlan } from "./plan.js";
 export { decodeMarker, encodeMarker } from "./marker.js";

package/dist/model/facts-types.d.ts

@@ -70,6 +70,8 @@ export interface GroupFacts {
 /** Git and intent data of every released unit, collected before release math. */
 export interface PlanFacts {
     readonly head: string;
+    /** Committer date of `head`; set when the git reader has `commitDate`. */
+    readonly date?: string;
     /** Released units, sorted by id. */
     readonly units: readonly UnitFacts[];
     /** One entry per distinct base tag commit. */

package/dist/model/plan-types.d.ts

@@ -16,6 +16,10 @@ export interface PlanChange {
     via?: string;
     /** Release-As value of this commit for the unit. */
     releaseAs?: string;
+    /** Units the change names; set with `files`. */
+    units?: string[];
+    /** Files consumed once every unit named by the changes with them releases. */
+    files?: string[];
 }
 export interface UnitPlan {
     id: string;

package/dist/plan.js

@@ -36,6 +36,9 @@ const planChanges = (intent) => (intent?.changes ?? []).map(({ change, via }) =>
         ...(change.pr === undefined ? {} : { pr: change.pr }),
         ...(via === undefined ? {} : { via }),
         ...(releaseAs === undefined ? {} : { releaseAs }),
+        ...(change.files === undefined
+            ? {}
+            : { units: [...(change.units ?? [])], files: [...change.files] }),
     };
 });
 /**
@@ -61,6 +64,7 @@ const releaseInputs = (workspace, { facts, schemes }, channel) => {
             range,
             absorbed: reach(unit.id, workspace.graph.dependencies, released),
             head: facts.head,
+            ...(facts.date === undefined ? {} : { date: facts.date }),
             channel,
         },
     ]));

package/dist/plugin.d.ts

@@ -74,6 +74,8 @@ export interface GitReader {
      * `path`; null if none.
      */
     introduced: (path: string, to: string) => MaybePromise<string | null>;
+    /** Committer date of `ref`, ISO 8601. */
+    commitDate?: (ref: string) => MaybePromise<string>;
 }
 export interface TagRef {
     name: string;
@@ -174,6 +176,8 @@ export interface PreCtx {
     /** Full sha of the planned commit. */
     head: string;
     baseTag: string | null;
+    /** Committer date of `head`, ISO 8601; set when the git reader has `commitDate`. */
+    date?: string;
     /** All tags of this unit, reachable or not, scheme-sorted. */
     tags: readonly string[];
     firstParent: {
@@ -187,6 +191,8 @@ export interface IntentSource<O = unknown> {
         from: string | null;
         to: string;
         commits: readonly RawCommit[];
+        /** All units of the workspace. */
+        units: readonly Unit[];
     }) => MaybePromise<Change[]>;
 }
 /** A `Release-As` value; `unit` is set by the qualified form `<unit>@<version>`. */
@@ -209,6 +215,11 @@ export interface Change {
     releaseAs?: ReleaseAsValue[];
     pr?: number;
     date?: string;
+    /**
+     * Files consumed when the change is released: deleted in the release
+     * commit that releases every unit named by the changes with the file.
+     */
+    files?: string[];
 }
 /** Throws `E_PLUGIN_API` or `E_PLUGIN_NAME` for an unsupported plugin. */
 export declare const assertPlugin: (plugin: {

package/dist/release.d.ts

@@ -42,6 +42,8 @@ export interface ReleaseInput<V> {
     /** Unreleased units absorbed by the unit (`reach`). */
     readonly absorbed: ReadonlySet<string>;
     readonly head: string;
+    /** Committer date of `head`. */
+    readonly date?: string;
     readonly channel: string | null;
 }
 /**

package/dist/release.js

@@ -43,8 +43,12 @@ export const releaseUnit = (input, intent, warnings) => {
     const from = fromOf(scheme, facts);
     const initial = initialOf(unit, scheme);
     const bumped = bumpedOf(scheme, bump, { from, initial });
+    const ctx = ctxOf(unit, input, {
+        ...facts,
+        tags: facts.tags.map((t) => t.name),
+    });
     if (from === undefined && releaseAs === undefined && bumped !== undefined) {
-        warnings.push(...initialBelowPrerelease(scheme, initial, facts));
+        warnings.push(...initialBelowPrerelease(scheme, scheme.release(initial, ctx), facts));
     }
     const raw = releaseAs ?? bumped;
     return {
@@ -59,15 +63,7 @@ export const releaseUnit = (input, intent, warnings) => {
                 : from === undefined
                     ? "initial"
                     : "bump",
-        ...render({
-            scheme,
-            raw,
-            ctx: ctxOf(unit, input.head, {
-                ...facts,
-                tags: facts.tags.map((t) => t.name),
-            }),
-            channel: input.channel,
-        }),
+        ...render({ scheme, raw, ctx, channel: input.channel }),
     };
 };
 /**
@@ -82,18 +78,13 @@ export const releaseGroup = (group, members, warnings) => {
     if (!first) {
         throw new TypeError("a group has at least one member");
     }
-    const { scheme, facts, channel, head } = first.input;
+    const { scheme, facts, channel } = first.input;
     const max = (a, b) => a === undefined || (b !== undefined && scheme.compare(b, a) > 0) ? b : a;
     const from = fromOf(scheme, facts);
     const bump = members.reduce((level, m) => maxLevel(level, m.bump), null);
     const releaseAs = members.reduce((value, m) => max(value, m.releaseAs?.version), undefined);
     const initial = members.reduce((value, m) => max(value, initialOf(m.input.unit, scheme)) ?? value, initialOf(first.input.unit, scheme));
     const bumped = bumpedOf(scheme, bump, { from, initial });
-    if (from === undefined && releaseAs === undefined && bumped !== undefined) {
-        for (const m of members) {
-            warnings.push(...initialBelowPrerelease(scheme, initial, m.input.facts));
-        }
-    }
     const tags = members
         .flatMap((m) => m.input.facts.tags)
         .flatMap((t) => {
@@ -102,6 +93,18 @@ export const releaseGroup = (group, members, warnings) => {
     })
         .sort((a, b) => scheme.compare(a.version, b.version) || compare(a.name, b.name))
         .map((t) => t.name);
+    const ctx = ctxOf(first.input.unit, first.input, {
+        baseTag: group.baseTag,
+        tags,
+        sinceLineBase: group.sinceLineBase,
+        total: Math.max(...members.map((m) => m.input.facts.total)),
+    });
+    if (from === undefined && releaseAs === undefined && bumped !== undefined) {
+        const released = scheme.release(initial, ctx);
+        for (const m of members) {
+            warnings.push(...initialBelowPrerelease(scheme, released, m.input.facts));
+        }
+    }
     const raw = max(bumped, releaseAs);
     const byReleaseAs = releaseAs !== undefined &&
         (bumped === undefined || scheme.compare(releaseAs, bumped) > 0);
@@ -116,16 +119,6 @@ export const releaseGroup = (group, members, warnings) => {
                 : from === undefined
                     ? "initial"
                     : "bump",
-        ...render({
-            scheme,
-            raw,
-            ctx: ctxOf(first.input.unit, head, {
-                baseTag: group.baseTag,
-                tags,
-                sinceLineBase: group.sinceLineBase,
-                total: Math.max(...members.map((m) => m.input.facts.total)),
-            }),
-            channel,
-        }),
+        ...render({ scheme, raw, ctx, channel }),
     };
 };

package/dist/testing/conformance.d.ts

@@ -16,6 +16,9 @@ export declare const gitReaderConformance: (makeReader: ReaderFactory) => void;
 /**
  * Shared `VersionScheme` spec. Versions are derived from `initial()`:
  * `parse`/`format` round-trip, `compare` order, `bump` monotonicity per level,
- * and `release`/`prerelease` keeping the core triple.
+ * and `release`/`prerelease` keeping the core triple. With `dateDriven` the
+ * level order, the core reset and the core-keeping checks are skipped.
  */
-export declare const schemeConformance: <V>(scheme: VersionScheme<V>) => void;
+export declare const schemeConformance: <V>(scheme: VersionScheme<V>, { dateDriven }?: {
+    dateDriven?: boolean;
+}) => void;

package/dist/testing/conformance.js

@@ -133,6 +133,18 @@ export const gitReaderConformance = (makeReader) => {
             expect(Date.parse(byId("a")?.date ?? "")).toBe(Date.parse("2024-01-01T10:00:00Z"));
             expect(Date.parse(byId("e")?.date ?? "")).toBe(Date.parse("2024-01-02T12:30:00Z"));
         });
+        it("reads the committer date of a commit when supported", async () => {
+            if (git.commitDate === undefined) {
+                return;
+            }
+            const commits = await git.log(null, sha("e"));
+            for (const id of ["a", "e"]) {
+                // eslint-disable-next-line no-await-in-loop -- one commit at a time
+                const date = await git.commitDate(sha(id));
+                expect(date).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/u);
+                expect(date).toBe(commits.find((c) => c.sha === sha(id))?.date);
+            }
+        });
         it("lists every commit before its parents", async () => {
             const commits = await git.log(null, sha("e"));
             const index = new Map(commits.map((c, i) => [c.sha, i]));
@@ -219,6 +231,7 @@ const PRE_CTX = {
         meta: {},
     },
     head: "0".repeat(40),
+    date: "2024-01-01T00:00:00Z",
     baseTag: null,
     tags: [],
     firstParent: { sinceLineBase: 3, total: 7 },
@@ -227,9 +240,10 @@ const PRE_CTX = {
 /**
  * Shared `VersionScheme` spec. Versions are derived from `initial()`:
  * `parse`/`format` round-trip, `compare` order, `bump` monotonicity per level,
- * and `release`/`prerelease` keeping the core triple.
+ * and `release`/`prerelease` keeping the core triple. With `dateDriven` the
+ * level order, the core reset and the core-keeping checks are skipped.
  */
-export const schemeConformance = (scheme) => {
+export const schemeConformance = (scheme, { dateDriven = false } = {}) => {
     describe("VersionScheme conformance", () => {
         const initial = scheme.initial();
         const bumped = (level) => scheme.bump(initial, level);
@@ -258,35 +272,41 @@ export const schemeConformance = (scheme) => {
             expect(scheme.compare(next, initial)).toBeGreaterThan(0);
             expect(scheme.isPrerelease(next)).toBe(false);
         });
-        it("orders bump levels major > minor > patch", () => {
-            const [major, minor, patch] = LEVELS.map(bumped);
-            expect(scheme.compare(major, minor)).toBeGreaterThan(0);
-            expect(scheme.compare(minor, patch)).toBeGreaterThan(0);
-        });
-        it("resets lower core parts on a bump", () => {
-            const { major, minor, patch } = scheme.core(initial);
-            expect(scheme.core(bumped("major"))).toEqual({
-                major: major + 1,
-                minor: 0,
-                patch: 0,
+        // A date-driven scheme takes the core from the commit date.
+        if (!dateDriven) {
+            it("orders bump levels major > minor > patch", () => {
+                const [major, minor, patch] = LEVELS.map(bumped);
+                expect(scheme.compare(major, minor)).toBeGreaterThan(0);
+                expect(scheme.compare(minor, patch)).toBeGreaterThan(0);
             });
-            expect(scheme.core(bumped("minor"))).toEqual({
-                major,
-                minor: minor + 1,
-                patch: 0,
+            it("resets lower core parts on a bump", () => {
+                const { major, minor, patch } = scheme.core(initial);
+                expect(scheme.core(bumped("major"))).toEqual({
+                    major: major + 1,
+                    minor: 0,
+                    patch: 0,
+                });
+                expect(scheme.core(bumped("minor"))).toEqual({
+                    major,
+                    minor: minor + 1,
+                    patch: 0,
+                });
+                expect(scheme.core(bumped("patch"))).toEqual({
+                    major,
+                    minor,
+                    patch: patch + 1,
+                });
             });
-            expect(scheme.core(bumped("patch"))).toEqual({
-                major,
-                minor,
-                patch: patch + 1,
+            it("keeps the core when releasing or prereleasing", () => {
+                const next = bumped("minor");
+                expect(scheme.core(scheme.release(next, PRE_CTX))).toEqual(scheme.core(next));
+                expect(scheme.core(scheme.prerelease(next, PRE_CTX))).toEqual(scheme.core(next));
             });
-        });
-        it("keeps the core when releasing or prereleasing", () => {
+        }
+        it("orders a prerelease at or below its release", () => {
             const next = bumped("minor");
             const release = scheme.release(next, PRE_CTX);
             const pre = scheme.prerelease(next, PRE_CTX);
-            expect(scheme.core(release)).toEqual(scheme.core(next));
-            expect(scheme.core(pre)).toEqual(scheme.core(next));
             expect(scheme.isPrerelease(release)).toBe(false);
             expect(scheme.compare(pre, release)).toBeLessThanOrEqual(0);
             expect(scheme.parse(scheme.format(pre))).toBeDefined();

package/dist/testing/index.js

@@ -137,6 +137,7 @@ export const memoryGit = (dag) => {
                 .find((n) => changed(n.parents[0] === undefined ? new Map() : node(n.parents[0]).tree, n.tree).some(under));
             return intro?.id ?? null;
         },
+        commitDate: (ref) => node(ref).date,
         tree: (ref) => Object.fromEntries(node(ref).tree),
         parents: (ref) => [...node(ref).parents],
     };

package/dist/version-files.d.ts

@@ -15,7 +15,8 @@ export declare const versionFileClaims: (workspace: Workspace) => Promise<Readon
  * Files of a release of `items` (stable `next`): plugin version files,
  * templates, markers and `<root>/CHANGELOG.md` per unit, read through `fs`; the
  * owning plugin's `changelog` hook may replace a unit's section. Returns
- * only files whose content changes, and each unit's changelog section;
+ * only files whose content changes, the consumed files of changes whose
+ * named units all release in `items`, and each unit's changelog section;
  * checks claims first. Templates skip first releases and warn
  * `W_VERSION_FILE_NO_MATCH` without any match, markers warn
  * `W_MARKER_NO_MATCH`; a missing version file is
@@ -30,6 +31,8 @@ export declare const releaseFiles: (workspace: Workspace, plan: Plan, opts: {
     date: string;
 }) => Promise<{
     files: Map<string, string>;
+    /** Files consumed by released changes, deleted by the release. */
+    deletes: Set<string>;
     /** Changelog section of each unit, by unit id. */
     sections: Map<string, string>;
     warnings: Warning[];

package/dist/version-files.js

@@ -259,6 +259,24 @@ const changelogStep = async (staged, step) => {
     }
     return section;
 };
+/**
+ * Readable files of the plan's changes where every unit named by a change
+ * with the file is in `released`; `written` files are kept.
+ */
+const consumedFiles = (plan, released, { fs, written }) => {
+    const named = new Map();
+    for (const { files = [], units = [] } of plan.units.flatMap((u) => u.changes)) {
+        for (const path of files) {
+            named.set(path, [...(named.get(path) ?? []), ...units]);
+        }
+    }
+    return new Set([...named]
+        .filter(([path, units]) => units.length > 0 &&
+        units.every((id) => released.has(id)) &&
+        !written.has(path) &&
+        fs.read(path) !== undefined)
+        .map(([path]) => path));
+};
 /** Checks template files and patterns (`E_CONFIG`); runs no plugin hook. */
 export const validateTemplates = (workspace) => {
     for (const [id, templates] of workspace.release.templates) {
@@ -310,7 +328,8 @@ export const versionFileClaims = async (workspace) => {
  * Files of a release of `items` (stable `next`): plugin version files,
  * templates, markers and `<root>/CHANGELOG.md` per unit, read through `fs`; the
  * owning plugin's `changelog` hook may replace a unit's section. Returns
- * only files whose content changes, and each unit's changelog section;
+ * only files whose content changes, the consumed files of changes whose
+ * named units all release in `items`, and each unit's changelog section;
  * checks claims first. Templates skip first releases and warn
  * `W_VERSION_FILE_NO_MATCH` without any match, markers warn
  * `W_MARKER_NO_MATCH`; a missing version file is
@@ -371,6 +390,10 @@ export const releaseFiles = async (workspace, plan, opts) => {
     }
     return {
         files: new Map([...files].filter(([path, c]) => fs.read(path) !== c)),
+        deletes: consumedFiles(plan, new Set(versions.keys()), {
+            fs,
+            written: files,
+        }),
         sections,
         warnings,
     };

package/dist/version-math.d.ts

@@ -14,7 +14,10 @@ export declare const bumpedOf: <V>(scheme: VersionScheme<V>, bump: BumpLevel | n
     from: From<V> | undefined;
     initial: V;
 }) => V | undefined;
-export declare const ctxOf: (unit: Unit, head: string, at: {
+export declare const ctxOf: (unit: Unit, { head, date }: {
+    head: string;
+    date?: string;
+}, at: {
     baseTag: {
         name: string;
     } | null;

package/dist/version-math.js

@@ -21,9 +21,10 @@ export const bumpedOf = (scheme, bump, { from, initial }) => bump === null
     : from === undefined
         ? initial
         : scheme.bump(from.version, bump);
-export const ctxOf = (unit, head, at) => ({
+export const ctxOf = (unit, { head, date }, at) => ({
     unit,
     head,
+    ...(date === undefined ? {} : { date }),
     baseTag: at.baseTag?.name ?? null,
     tags: at.tags,
     firstParent: { sinceLineBase: at.sinceLineBase, total: at.total },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tallyrelease/core",
-  "version": "0.5.0-beta.52",
+  "version": "0.5.0-beta.60",
   "description": "Pure planning core of tallyrelease",
   "repository": {
     "type": "git",