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

package/dist/changelog.d.ts

@@ -1,6 +1,8 @@
 import type { PlanChange, Plan } from "./model/plan-types.js";
 import type { Unit, VersionScheme } from "./plugin.js";
 import type { Workspace } from "./workspace.js";
+/** Version of a version heading line, else undefined. */
+export declare const headingVersion: <V>(line: string, scheme: VersionScheme<V>) => V | undefined;
 /** `<root>/CHANGELOG.md` of a unit. */
 export declare const changelogPath: (unit: Pick<Unit, "root">) => string;
 export interface ChangelogDependency {

package/dist/changelog.js

@@ -85,7 +85,7 @@ const dependencyLines = (deps) => {
     ].join("\n");
 };
 /** Version of a version heading line, else undefined. */
-const headingVersion = (line, scheme) => {
+export const headingVersion = (line, scheme) => {
     const m = VERSION_HEADING.exec(line);
     const raw = m?.[1] ?? m?.[2];
     return raw === undefined ? undefined : scheme.parse(raw);

package/dist/codes.d.ts

@@ -22,5 +22,5 @@ export declare const defineCodes: <R extends Record<string, CodeDoc>>(docs: R &
 /**
  * Codes raised by core. Codes are only added, never removed or renamed.
  */
-export declare const coreCodes: CodeRegistry<"E_BRANCH_RULE" | "E_CAP" | "E_CAP_BASE" | "E_CHANNEL_DUPLICATE" | "E_CHANNEL_INVALID" | "E_CHANNEL_WILDCARD" | "E_CONFIG" | "E_DUPLICATE_ROOT" | "E_DUPLICATE_UNIT" | "E_EDGE_SELF" | "E_EDGE_UNKNOWN_UNIT" | "E_GIT_DATE" | "E_GROUP_NOT_RELEASED" | "E_GROUP_OVERLAP" | "E_GROUP_SCHEME" | "E_GROUP_UNKNOWN_UNIT" | "E_INITIAL_VERSION" | "E_PLUGIN_API" | "E_PLUGIN_HOOK" | "E_PLUGIN_NAME" | "E_PLUGIN_OPTIONS" | "E_PLUGIN_UNKNOWN" | "E_RELEASE_ITEM_NAME" | "E_RELEASE_PR_SPLIT_EDGE" | "E_ROOT_INVALID" | "E_ROOT_MISSING" | "E_SCHEME_CLASH" | "E_SCHEME_UNKNOWN" | "E_TAG_FORMAT" | "E_TAG_FORMAT_OVERLAP" | "E_UNIT_GLOB" | "E_UNIT_ID" | "E_UNIT_TAG" | "E_UNIT_UNKNOWN" | "E_VERSION_FILE_CLAIM" | "E_VERSION_FILE_MISSING" | "E_VERSION_INVALID" | "W_CYCLE" | "W_GROUP_EMPTY" | "W_INITIAL_BELOW_PRERELEASE" | "W_NO_BRANCH_RULE" | "W_NO_MATCHING_TAG" | "W_NO_RELEASED_UNITS" | "W_PLUGIN" | "W_RELEASED_NO_BASE" | "W_RELEASE_AS_CONFLICT" | "W_RELEASE_AS_IGNORED" | "W_RELEASE_AS_INVALID" | "W_RELEASE_AS_UNKNOWN" | "W_RELEASE_NOT_BUILT" | "W_UNIT_GLOB_UNMATCHED" | "W_UNIT_UNKNOWN" | "W_VERSION_FILE_NO_MATCH">;
+export declare const coreCodes: CodeRegistry<"E_BRANCH_RULE" | "E_CAP" | "E_CAP_BASE" | "E_CHANNEL_DUPLICATE" | "E_CHANNEL_INVALID" | "E_CHANNEL_WILDCARD" | "E_CONFIG" | "E_DUPLICATE_ROOT" | "E_DUPLICATE_UNIT" | "E_EDGE_SELF" | "E_EDGE_UNKNOWN_UNIT" | "E_GIT_DATE" | "E_GROUP_NOT_RELEASED" | "E_GROUP_OVERLAP" | "E_GROUP_SCHEME" | "E_GROUP_UNKNOWN_UNIT" | "E_INITIAL_VERSION" | "E_PLUGIN_API" | "E_PLUGIN_HOOK" | "E_PLUGIN_NAME" | "E_PLUGIN_OPTIONS" | "E_PLUGIN_UNKNOWN" | "E_RELEASE_ITEM_NAME" | "E_RELEASE_PR_SPLIT_EDGE" | "E_ROOT_INVALID" | "E_ROOT_MISSING" | "E_SCHEME_CLASH" | "E_SCHEME_UNKNOWN" | "E_TAG_FORMAT" | "E_TAG_FORMAT_OVERLAP" | "E_UNIT_GLOB" | "E_UNIT_ID" | "E_UNIT_TAG" | "E_UNIT_UNKNOWN" | "E_VERSION_FILE_CLAIM" | "E_VERSION_FILE_MISSING" | "E_VERSION_INVALID" | "W_CYCLE" | "W_GROUP_EMPTY" | "W_INITIAL_BELOW_PRERELEASE" | "W_MARKER_NO_MATCH" | "W_NO_BRANCH_RULE" | "W_NO_MATCHING_TAG" | "W_NO_RELEASED_UNITS" | "W_PLUGIN" | "W_RELEASED_NO_BASE" | "W_RELEASE_AS_CONFLICT" | "W_RELEASE_AS_IGNORED" | "W_RELEASE_AS_INVALID" | "W_RELEASE_AS_UNKNOWN" | "W_RELEASE_NOT_BUILT" | "W_UNIT_GLOB_UNMATCHED" | "W_UNIT_UNKNOWN" | "W_VERSION_FILE_NO_MATCH">;
 export {};

package/dist/codes.js

@@ -146,7 +146,7 @@ export const coreCodes = defineCodes({
         fix: "Pass an existing unit id. List ids with `tallyrelease graph`.",
     },
     E_VERSION_FILE_CLAIM: {
-        cause: "A file is the version file of two units, or is both a plugin version file and a `versionFiles` template target.",
+        cause: "A file is the version file of two units, is both a plugin version file and a `versionFiles` template target, or is a `versionFiles` marker file of two units (markers carry no unit id).",
         fix: "Remove the duplicate `versionFiles` entry, or set one file per unit.",
     },
     E_VERSION_FILE_MISSING: {
@@ -169,6 +169,10 @@ export const coreCodes = defineCodes({
         cause: "A unit's initial version does not exceed an existing prerelease tag of that unit.",
         fix: "Raise `initialVersion` above the prerelease tag named in the message, or remove the stale tag.",
     },
+    W_MARKER_NO_MATCH: {
+        cause: "A `versionFiles` entry without `pattern` names a file with no line that carries an `x-tallyrelease-version` marker and a version of the unit's scheme, so the file is not updated for the release.",
+        fix: "Add `# x-tallyrelease-version` or `<!-- x-tallyrelease-version -->` to the line that holds the version, set a `pattern`, or remove the entry.",
+    },
     W_NO_BRANCH_RULE: {
         cause: "No `branches` rule matches the branch, so versions in the plan are null.",
         fix: "Add a rule for the branch under `branches`, for example `{ name: main, line: default }`, or pass `--branch`.",

package/dist/config.d.ts

@@ -29,10 +29,12 @@ export interface UnitOverlay {
 /**
  * A text file holding a unit's version. `file` is relative to the repository
  * root; `pattern` uses `{id}`, `{version}`, `{major}`, `{minor}` and `{patch}`.
+ * Without `pattern`, lines marked `# x-tallyrelease-version` or
+ * `<!-- x-tallyrelease-version -->` are rewritten.
  */
 export interface VersionTemplate {
     file: string;
-    pattern: string;
+    pattern?: string;
 }
 /** A branch rule; the first rule whose `name` matches the branch wins. */
 export interface BranchConfig {

package/dist/plan.d.ts

@@ -16,6 +16,7 @@ export interface PlanResult {
 export declare const planWithFacts: (workspace: Workspace, git: GitReader, opts: PlanOptions) => Promise<PlanResult>;
 /**
  * Plans `head`: validates release config, computes the build set, collects
- * git and intent facts and resolves versions and kinds.
+ * git and intent facts, resolves versions and kinds and runs the plugins'
+ * `validate` hooks.
  */
 export declare const computePlan: (workspace: Workspace, git: GitReader, opts: PlanOptions) => Promise<Plan>;

package/dist/plan.js

@@ -3,11 +3,12 @@ import { checkLimits, matchBranch } from "./branches.js";
 import { changeLevel, reach } from "./bump.js";
 import { coreCodes } from "./codes.js";
 import { collectPlanFacts } from "./facts.js";
+import { pluginCtx, runHook } from "./plugins.js";
 import { propagate } from "./propagate.js";
 import { releaseAsWarnings } from "./release-as.js";
 import { footerOf, releaseGroup, releaseUnit, unitIntent } from "./release.js";
 import { noMatchingTag } from "./tags.js";
-import { maxLevel } from "./util.js";
+import { frozenCopy, maxLevel } from "./util.js";
 import { validateRelease } from "./validate.js";
 const lineWarnings = (workspace, branch, line) => {
     if (!line) {
@@ -323,6 +324,30 @@ const resolveReleases = (workspace, input) => {
         releases,
     };
 };
+/** Warnings of the plugins' `validate` hooks, run in config order on one frozen copy of the plan. */
+const pluginValidation = async (workspace, plan, opts) => {
+    const warnings = [];
+    const ctx = pluginCtx({ ...opts, repo: { name: workspace.repo } }, warnings);
+    let frozen;
+    for (const { plugin, options } of workspace.plugins) {
+        const { validate } = plugin;
+        if (validate) {
+            const copy = (frozen ??= frozenCopy(plan));
+            // eslint-disable-next-line no-await-in-loop -- hooks run in config order
+            const messages = await runHook(plugin.name, "validate", async () => {
+                const result = await validate(ctx(plugin.name, options), copy);
+                if (result !== undefined && !Array.isArray(result)) {
+                    throw new TypeError("validate must return string[] or nothing");
+                }
+                return result ?? [];
+            });
+            for (const message of messages) {
+                warnings.push(coreCodes.warning("W_PLUGIN", message, { plugin: plugin.name }));
+            }
+        }
+    }
+    return warnings;
+};
 /** Release math over collected facts; no I/O. */
 export const resolvePlan = (workspace, input) => resolveReleases(workspace, input).plan;
 /** `computePlan` keeping the collected facts, for `explainUnit`. */
@@ -340,10 +365,12 @@ export const planWithFacts = async (workspace, git, opts) => {
         schemes: workspace.schemes,
         all: opts.all ?? false,
     });
+    plan.warnings.push(...(await pluginValidation(workspace, plan, opts)));
     return { plan, facts, releases };
 };
 /**
  * Plans `head`: validates release config, computes the build set, collects
- * git and intent facts and resolves versions and kinds.
+ * git and intent facts, resolves versions and kinds and runs the plugins'
+ * `validate` hooks.
  */
 export const computePlan = async (workspace, git, opts) => (await planWithFacts(workspace, git, opts)).plan;

package/dist/plugin.d.ts

@@ -1,3 +1,4 @@
+import type { Plan } from "./model/plan-types.js";
 import type { StandardSchemaV1 } from "@standard-schema/spec";
 export type MaybePromise<T> = T | Promise<T>;
 export declare const PLUGIN_API_VERSION = 1;
@@ -16,6 +17,18 @@ export interface Plugin<O = unknown> {
     versionFiles?: (ctx: Ctx<O>, unit: Unit) => MaybePromise<VersionFile[]>;
     schemes?: Record<string, VersionScheme<any>>;
     intent?: IntentSource<O>[];
+    /** Checks the computed plan; returned messages become `W_PLUGIN` warnings. */
+    validate?: (ctx: Ctx<O>, plan: Plan) => MaybePromise<string[] | void>;
+    /**
+     * Called only for units owned by this plugin with a changelog section.
+     * Returns the section that replaces the default `section`; it must start
+     * with a version heading of the released version and have no other.
+     */
+    changelog?: (ctx: Ctx<O>, input: {
+        unit: Unit;
+        plan: Plan;
+        section: string;
+    }) => MaybePromise<string>;
 }
 export interface Ctx<O = unknown> {
     readonly options: O;

package/dist/util.d.ts

@@ -5,3 +5,8 @@ export declare const compare: (a: string, b: string) => number;
 export declare const uniqueSorted: (values: Iterable<string>) => string[];
 /** The higher of two levels; null is lowest. */
 export declare const maxLevel: (a: BumpLevel | null, b: BumpLevel | null) => BumpLevel | null;
+/**
+ * Deep-frozen copy of a JSON value, for hooks that must not change it.
+ * Expensive (a full copy plus a walk over it): make one per pass and share it.
+ */
+export declare const frozenCopy: <T>(value: T) => T;

package/dist/util.js

@@ -5,3 +5,19 @@ export const compare = (a, b) => a < b ? -1 : a > b ? 1 : 0;
 export const uniqueSorted = (values) => [...new Set(values)].sort(compare);
 /** The higher of two levels; null is lowest. */
 export const maxLevel = (a, b) => a === null || (b !== null && LEVELS.indexOf(b) > LEVELS.indexOf(a)) ? b : a;
+/** Freezes every nested object; walks the whole value, so keep it off hot paths. */
+const deepFreeze = (value) => {
+    if (typeof value === "object" && value !== null) {
+        Object.values(value).forEach(deepFreeze);
+        Object.freeze(value);
+    }
+};
+/**
+ * Deep-frozen copy of a JSON value, for hooks that must not change it.
+ * Expensive (a full copy plus a walk over it): make one per pass and share it.
+ */
+export const frozenCopy = (value) => {
+    const copy = JSON.parse(JSON.stringify(value));
+    deepFreeze(copy);
+    return copy;
+};

package/dist/version-files.d.ts

@@ -7,16 +7,18 @@ import type { Workspace } from "./workspace.js";
 export declare const validateTemplates: (workspace: Workspace) => void;
 /**
  * Plugin version files by unit id. Throws `E_VERSION_FILE_CLAIM` when a path
- * is a plugin version file of two units or also a template. Templates may
- * share a file.
+ * is a plugin version file of two units or also a template, or a marker file
+ * of two units. Templates may share a file.
  */
 export declare const versionFileClaims: (workspace: Workspace) => Promise<ReadonlyMap<string, readonly VersionFile[]>>;
 /**
  * Files of a release of `items` (stable `next`): plugin version files,
- * templates and `<root>/CHANGELOG.md` per unit, read through `fs`. Returns
+ * 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;
  * checks claims first. Templates skip first releases and warn
- * `W_VERSION_FILE_NO_MATCH` without any match; a missing version file is
+ * `W_VERSION_FILE_NO_MATCH` without any match, markers warn
+ * `W_MARKER_NO_MATCH`; a missing version file is
  * `E_VERSION_FILE_MISSING`.
  */
 export declare const releaseFiles: (workspace: Workspace, plan: Plan, opts: {

package/dist/version-files.js

@@ -1,12 +1,15 @@
-import { changelogPath, changelogSection, updateChangelog, } from "./changelog.js";
+import { changelogPath, changelogSection, headingVersion, updateChangelog, } from "./changelog.js";
 import { coreCodes } from "./codes.js";
 import { normalizeRoot } from "./discover.js";
-import { runHook } from "./plugins.js";
+import { pluginCtx, runHook } from "./plugins.js";
+import { frozenCopy } from "./util.js";
 const TOKEN = /\{([^{}]*)\}/gu;
 const SPECIAL = /[\\^$.*+?()[\]{}|/]/gu;
 const CORE_TOKENS = ["major", "minor", "patch"];
 const VERSION = "\\d+\\.\\d+\\.\\d+(?:-[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)?(?:\\+[0-9A-Za-z-]+(?:\\.[0-9A-Za-z-]+)*)?";
 const ALNUM = /[0-9A-Za-z]/u;
+const MARKERS = ["# x-tallyrelease-version", "<!-- x-tallyrelease-version -->"];
+const WORD = /[0-9A-Za-z](?:[0-9A-Za-z.+-]*[0-9A-Za-z])?/gu;
 const escape = (text) => text.replace(SPECIAL, "\\$&");
 const configError = (pattern, unit, problem) => coreCodes.error("E_CONFIG", `version file pattern "${pattern}" of unit "${unit}" ${problem}`, { unit, pattern });
 /**
@@ -107,6 +110,32 @@ const applyTemplate = (content, { pattern, unit, from, next, scheme, }) => {
     });
     return { content: replaced, hit };
 };
+/**
+ * Replaces, on each marker line, the first word the scheme parses (after an
+ * optional `v`) with `next`. `hit` is false when no marker line has one.
+ */
+const applyMarkers = (content, { next, scheme }) => {
+    let hit = false;
+    const lines = content.split("\n").map((line) => {
+        if (!MARKERS.some((m) => line.includes(m))) {
+            return line;
+        }
+        for (const m of line.matchAll(WORD)) {
+            const [word] = m;
+            const start = word.startsWith("v") && scheme.parse(word.slice(1)) !== undefined
+                ? m.index + 1
+                : scheme.parse(word) !== undefined
+                    ? m.index
+                    : undefined;
+            if (start !== undefined) {
+                hit = true;
+                return `${line.slice(0, start)}${next}${line.slice(m.index + word.length)}`;
+            }
+        }
+        return line;
+    });
+    return { content: lines.join("\n"), hit };
+};
 /** Repo-relative template file; `E_CONFIG` for `.`, absolute or `..` paths. */
 const templateFile = (file, unit) => {
     const invalid = () => coreCodes.error("E_CONFIG", `version file "${file}" of unit "${unit}" must be a repo-relative file without ".." segments`, { unit, file });
@@ -140,18 +169,34 @@ const versionFileStep = async (staged, step, pluginFiles) => {
         staged.files.set(file.path, written);
     }
 };
-/** Rewrites the version templates of the unit; skips first releases. */
+/**
+ * Rewrites the version templates and markers of the unit; templates skip
+ * first releases.
+ */
 const templateStep = (staged, step) => {
     const { workspace, item, unit, scheme, from } = step;
     const warnings = [];
-    const templates = from === null ? [] : (workspace.release.templates.get(unit.id) ?? []);
-    for (const template of templates) {
+    for (const template of workspace.release.templates.get(unit.id) ?? []) {
         const { pattern } = template;
         const file = templateFile(template.file, unit.id);
+        if (pattern === undefined) {
+            const result = applyMarkers(required(staged, file, unit.id), {
+                next: item.version,
+                scheme,
+            });
+            staged.files.set(file, result.content);
+            if (!result.hit) {
+                warnings.push(coreCodes.warning("W_MARKER_NO_MATCH", `version file "${file}" of unit "${unit.id}" has no x-tallyrelease-version marker with a version`, { unit: unit.id }));
+            }
+            continue;
+        }
+        if (from === null) {
+            continue;
+        }
         const result = applyTemplate(required(staged, file, unit.id), {
             pattern,
             unit: unit.id,
-            from: from ?? "",
+            from,
             next: item.version,
             scheme,
         });
@@ -162,15 +207,49 @@ const templateStep = (staged, step) => {
     }
     return warnings;
 };
+/**
+ * The owning plugin's `changelog` section, which must have one version
+ * heading, of the released version, on its first line; else `section`.
+ */
+const pluginSection = async (step, section) => {
+    const { workspace, item, unit, scheme, ctx, hookPlan } = step;
+    const owner = workspace.plugins.find((p) => p.plugin.name === unit.plugin);
+    const hook = owner?.plugin.changelog;
+    if (!owner || !hook) {
+        return section;
+    }
+    return await runHook(unit.plugin, "changelog", async () => {
+        const result = await hook(ctx(unit.plugin, owner.options), {
+            unit,
+            plan: hookPlan(),
+            section,
+        });
+        if (typeof result !== "string") {
+            throw new TypeError("changelog must return a string");
+        }
+        const text = result.trim();
+        const [first = "", ...rest] = text.split("\n");
+        const version = headingVersion(first, scheme);
+        const next = scheme.parse(item.version);
+        if (version === undefined ||
+            next === undefined ||
+            scheme.compare(version, next) !== 0 ||
+            rest.some((line) => headingVersion(line, scheme) !== undefined)) {
+            throw new Error(`section of unit "${unit.id}" must start with a heading of version ${item.version} and have no other version heading`);
+        }
+        return text;
+    });
+};
 /** Updates the unit's changelog; returns the new section, if any. */
-const changelogStep = (staged, step) => {
+const changelogStep = async (staged, step) => {
     const { workspace, plan, unit, scheme, from, repoUrl, date, prUnits } = step;
-    const section = changelogSection(workspace, plan, {
+    const fallback = changelogSection(workspace, plan, {
         id: unit.id,
         repoUrl,
         date,
         prUnits,
     });
+    const section = fallback === undefined ? undefined : await pluginSection(step, fallback);
     if (section !== undefined) {
         const path = changelogPath(unit);
         staged.files.set(path, updateChangelog(staged.read(path), section, {
@@ -185,14 +264,16 @@ export const validateTemplates = (workspace) => {
     for (const [id, templates] of workspace.release.templates) {
         for (const { file, pattern } of templates) {
             templateFile(file, id);
-            compileTemplate(pattern, id);
+            if (pattern !== undefined) {
+                compileTemplate(pattern, id);
+            }
         }
     }
 };
 /**
  * Plugin version files by unit id. Throws `E_VERSION_FILE_CLAIM` when a path
- * is a plugin version file of two units or also a template. Templates may
- * share a file.
+ * is a plugin version file of two units or also a template, or a marker file
+ * of two units. Templates may share a file.
  */
 export const versionFileClaims = async (workspace) => {
     const files = await workspace.versionFiles();
@@ -206,23 +287,33 @@ export const versionFileClaims = async (workspace) => {
             claims.set(path, id);
         }
     }
+    const markers = new Map();
     for (const [id, templates] of workspace.release.templates) {
-        for (const { file } of templates) {
+        for (const { file, pattern } of templates) {
             const path = templateFile(file, id);
             const owner = claims.get(path);
             if (owner !== undefined) {
                 throw coreCodes.error("E_VERSION_FILE_CLAIM", `version file template of unit "${id}" targets "${path}", a version file of unit "${owner}"`, { path, units: [owner, id] });
             }
+            if (pattern === undefined) {
+                const marked = markers.get(path);
+                if (marked !== undefined && marked !== id) {
+                    throw coreCodes.error("E_VERSION_FILE_CLAIM", `version file "${path}" holds markers of units "${marked}" and "${id}"`, { path, units: [marked, id] });
+                }
+                markers.set(path, id);
+            }
         }
     }
     return files;
 };
 /**
  * Files of a release of `items` (stable `next`): plugin version files,
- * templates and `<root>/CHANGELOG.md` per unit, read through `fs`. Returns
+ * 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;
  * checks claims first. Templates skip first releases and warn
- * `W_VERSION_FILE_NO_MATCH` without any match; a missing version file is
+ * `W_VERSION_FILE_NO_MATCH` without any match, markers warn
+ * `W_MARKER_NO_MATCH`; a missing version file is
  * `E_VERSION_FILE_MISSING`.
  */
 export const releaseFiles = async (workspace, plan, opts) => {
@@ -240,6 +331,9 @@ export const releaseFiles = async (workspace, plan, opts) => {
     };
     const sections = new Map();
     const warnings = [];
+    const ctx = pluginCtx({ fs, repo: { name: workspace.repo } }, warnings);
+    let frozen;
+    const hookPlan = () => (frozen ??= frozenCopy(plan));
     for (const item of items) {
         const prUnits = items
             .filter((i) => pr(i) === pr(item))
@@ -262,11 +356,14 @@ export const releaseFiles = async (workspace, plan, opts) => {
                 prUnits,
                 repoUrl,
                 date,
+                ctx,
+                hookPlan,
             };
             // eslint-disable-next-line no-await-in-loop -- files are written in order
             await versionFileStep(staged, step, pluginFiles.get(id) ?? []);
             warnings.push(...templateStep(staged, step));
-            const section = changelogStep(staged, step);
+            // eslint-disable-next-line no-await-in-loop -- files are written in order
+            const section = await changelogStep(staged, step);
             if (section !== undefined) {
                 sections.set(id, section);
             }

package/dist/workspace.d.ts

@@ -36,6 +36,11 @@ export interface Workspace {
     readonly schemes: ReadonlyMap<string, VersionScheme<any>>;
     /** Core sources first, then enabled plugins in config order. */
     readonly intents: readonly IntentEntry[];
+    /** Core first, then enabled plugins in config order, with their options. */
+    readonly plugins: readonly {
+        readonly plugin: Plugin;
+        readonly options: unknown;
+    }[];
     /** Bumps and branch rules with defaults applied. */
     readonly release: ReleaseSettings;
     /** Fixed groups, sorted by name. */

package/dist/workspace.js

@@ -87,6 +87,10 @@ export const loadWorkspace = async (input) => {
         warnings: [...warnings, ...graph.warnings],
         schemes: schemeRegistry(active.map((a) => a.plugin)),
         intents,
+        plugins: active.map(({ plugin, ctx }) => ({
+            plugin,
+            options: ctx.options,
+        })),
         release: releaseSettings(input.config, units),
         groups,
         versionFiles: versionFilesOf(active, units),

package/package.json

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