@tallyrelease/core 0.5.0-beta.34 → 0.5.0-beta.41

package/README.md

@@ -24,9 +24,23 @@ export const example = definePlugin({
 
 See `Plugin` in [`src/plugin.ts`](https://github.com/abinnovision/tallyrelease/blob/main/packages/core/src/plugin.ts) for the available hooks (`discover`, `edges`, `inputs`, `versionFiles`, `schemes`, `intent`).
 
+Core always registers the `semver` scheme and the Conventional Commits intent source. A plugin that reads commit messages can use `parseCommit` for the same parsing.
+
+### Tag formats
+
+A plugin that sets `tagFormat` on its units can check the format with the same rules core applies. `compileTagFormat(format, unitId)` throws `E_TAG_FORMAT` unless `{version}` occurs exactly once, and returns a `TagFormat` whose `match(tag)` gives the `{version}` part of a matching tag. `renderTag(unit, version)` renders the tag of a version.
+
+```ts
+import { compileTagFormat, renderTag } from "@tallyrelease/core";
+
+const format = compileTagFormat("{id}-v{version}", "web");
+format.match("web-v1.2.0"); // "1.2.0"
+renderTag({ id: "web", tagFormat: "{id}-v{version}" }, "1.2.0"); // "web-v1.2.0"
+```
+
 ## Testing
 
-The `@tallyrelease/core/testing` export provides in-memory fakes: `memoryFs`, `memoryCtx` and `memoryGit`. The `@tallyrelease/core/testing/conformance` export provides `gitReaderConformance`, a shared `GitReader` spec that requires vitest.
+The `@tallyrelease/core/testing` export provides in-memory fakes: `memoryFs`, `memoryCtx` and `memoryGit`. The `@tallyrelease/core/testing/conformance` export provides `gitReaderConformance` and `schemeConformance`, shared `GitReader` and `VersionScheme` specs that require vitest.
 
 ## Licence
 

package/dist/branches.js

@@ -1,5 +1,4 @@
 import { coreCodes } from "./codes.js";
-import { schemeRegistry } from "./schemes.js";
 import { maxLevel } from "./util.js";
 const SPECIAL = /[\\^$.*+?()[\]{}|/]/gu;
 const PART = /\{(major|minor)\}|\*/gu;
@@ -177,7 +176,7 @@ export const maintenanceCut = (workspace, plan, item) => {
         ? 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);
+    const scheme = unit && workspace.schemes.get(unit.scheme);
     if (plan.line?.kind !== "default" ||
         !scheme ||
         !base?.from ||

package/dist/changelog.js

@@ -1,4 +1,3 @@
-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. */
@@ -238,7 +237,7 @@ export const updateChangelog = (content, section, { baseVersion, scheme, }) => {
  */
 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 scheme = unit && workspace.schemes.get(unit.scheme);
     const content = unit && read(changelogPath(unit));
     if (!scheme || content === undefined) {
         return undefined;

package/dist/discover.d.ts

@@ -1,10 +1,11 @@
 import type { Warning } from "./errors.js";
 import type { Unit } from "./plugin.js";
-import type { ActivePlugin, PluginEnv } from "./plugins.js";
+import type { ActivePlugin } from "./plugins.js";
+import type { WorkspaceInput } from "./workspace.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 (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">, warnings?: Warning[]) => Promise<Unit[]>;
+export declare const discoverUnits: (active: readonly ActivePlugin[], env: Pick<WorkspaceInput, "config" | "fs" | "repo">, warnings?: Warning[]) => Promise<Unit[]>;

package/dist/facts.js

@@ -1,7 +1,6 @@
 import { attribution, matcher } from "./attribution.js";
 import { coreCodes } from "./codes.js";
 import { pluginCtx, runHook } from "./plugins.js";
-import { schemeRegistry } from "./schemes.js";
 import { matchUnitTags } from "./tags.js";
 import { compare, uniqueSorted } from "./util.js";
 const instant = (commit) => {
@@ -78,7 +77,7 @@ export const lineFacts = async (git, head) => {
 /** Tags of every unit and fixed group, relative to `head`. */
 export const tagFacts = async (workspace, git, line) => {
     const { head } = line;
-    const schemes = schemeRegistry(workspace.schemes);
+    const { schemes } = workspace;
     const allTags = await git.tags();
     const tags = matchUnitTags(workspace.units, allTags, schemes);
     const merged = new Set((await git.tagsMerged(head)).map((t) => t.name));

package/dist/index.d.ts

@@ -1,7 +1,6 @@
 /** @deprecated Unused, will be removed in 1.0. */
 export declare const version = "0.0.0";
 export type { AffectedDoc, AffectedOptions, AffectedReason, AffectedUnit, BaseSource, } from "./model/affected-types.js";
-export type { ChangelogDependency, ChangelogInput } from "./changelog.js";
 export type { CodeDoc, CodeOf, CodeRegistry, ErrorCode, WarningCode, } from "./codes.js";
 export type { ParsedCommit } from "./conventional.js";
 export type { ExplainedChange, ExplainOptions, ReleaseAsFooter, UnitExplanation, } from "./explain.js";
@@ -9,34 +8,30 @@ export type { BranchRule, Line as PlanLine } from "./model/branch-types.js";
 export type { GroupPlan, Plan, PlanChange, PlanOptions, ReleasedUnit, UnitPlan, } from "./model/plan-types.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 { Graph } 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 { ReleaseSettings } from "./release-settings.js";
-export type { SchemeEntry } from "./schemes.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 { maintenanceCut } from "./branches.js";
-export { changelogSection, releaseNotes, renderChangelogSection, updateChangelog, } from "./changelog.js";
+export { releaseNotes } from "./changelog.js";
 export { coreCodes, defineCodes } from "./codes.js";
 export { CONFIG_FILE } from "./config.js";
-export { conventionalCommits, parseCommit } from "./conventional.js";
-export { discoverUnits } from "./discover.js";
+export { parseCommit } from "./conventional.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 { releasedFromTags, withReleased } from "./released.js";
 export { semver } from "./semver.js";
+export { compileTagFormat, renderTag } from "./tags.js";
 export { validateRelease, validateTags } from "./validate.js";
 export { releaseFiles, versionFileClaims } from "./version-files.js";
 export { loadWorkspace } from "./workspace.js";

package/dist/index.js

@@ -2,22 +2,19 @@
 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 { releaseNotes } from "./changelog.js";
 export { coreCodes, defineCodes } from "./codes.js";
 export { CONFIG_FILE } from "./config.js";
-export { conventionalCommits, parseCommit } from "./conventional.js";
-export { discoverUnits } from "./discover.js";
+export { parseCommit } from "./conventional.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 { releasedFromTags, withReleased } from "./released.js";
 export { semver } from "./semver.js";
+export { compileTagFormat, renderTag } from "./tags.js";
 export { validateRelease, validateTags } from "./validate.js";
 export { releaseFiles, versionFileClaims } from "./version-files.js";
 export { loadWorkspace } from "./workspace.js";

package/dist/plan.js

@@ -327,7 +327,7 @@ const resolveReleases = (workspace, input) => {
 export const resolvePlan = (workspace, input) => resolveReleases(workspace, input).plan;
 /** `computePlan` keeping the collected facts, for `explainUnit`. */
 export const planWithFacts = async (workspace, git, opts) => {
-    const schemes = validateRelease(workspace);
+    validateRelease(workspace);
     const affected = await computeAffected(workspace, git, opts);
     const facts = await collectPlanFacts(workspace, git, {
         head: opts.head,
@@ -337,7 +337,7 @@ export const planWithFacts = async (workspace, git, opts) => {
     const { plan, releases } = resolveReleases(workspace, {
         affected,
         facts,
-        schemes,
+        schemes: workspace.schemes,
         all: opts.all ?? false,
     });
     return { plan, facts, releases };

package/dist/plugins.d.ts

@@ -1,6 +1,6 @@
-import type { TallyConfig } from "./config.js";
 import type { Warning } from "./errors.js";
-import type { Ctx, MaybePromise, Plugin, ReadonlyFs } from "./plugin.js";
+import type { Ctx, MaybePromise, Plugin } from "./plugin.js";
+import type { WorkspaceInput } from "./workspace.js";
 /** An enabled plugin with its validated options. */
 export interface ActivePlugin {
     readonly plugin: Plugin;
@@ -8,19 +8,12 @@ export interface ActivePlugin {
     /** False when `plugins.<name>.globalInputs: false`. */
     readonly globalInputs: boolean;
 }
-export interface PluginEnv {
-    config: TallyConfig;
-    /** Available plugins; `config.plugins` selects and orders them. */
-    plugins: readonly Plugin[];
-    fs: ReadonlyFs;
-    repo: {
-        name: string;
-    };
-    debug?: (message: string) => void;
-}
 /** Frozen `Ctx` factory; warnings are tagged with the plugin name. */
-export declare const pluginCtx: (env: Pick<PluginEnv, "fs" | "repo" | "debug">, warnings: Warning[]) => (name: string, options: unknown) => Ctx;
-/** Resolves enabled plugins in config order and validates their options. */
-export declare const activatePlugins: (env: PluginEnv, warnings: Warning[]) => Promise<ActivePlugin[]>;
+export declare const pluginCtx: (env: Pick<WorkspaceInput, "fs" | "repo" | "debug">, warnings: Warning[]) => (name: string, options: unknown) => Ctx;
+/**
+ * Resolves core, then enabled plugins in config order, and validates their
+ * options.
+ */
+export declare const activatePlugins: (env: WorkspaceInput, warnings: Warning[]) => Promise<ActivePlugin[]>;
 /** Awaits a plugin hook, wrapping thrown errors as `E_PLUGIN_HOOK`. */
 export declare const runHook: <T>(plugin: string, hook: string, call: () => MaybePromise<T>) => Promise<T>;

package/dist/plugins.js

@@ -1,4 +1,4 @@
-import { CORE_PLUGIN } from "./builtin.js";
+import { CORE_PLUGIN, corePlugin } from "./builtin.js";
 import { coreCodes } from "./codes.js";
 import { assertPlugin } from "./plugin.js";
 /** Frozen `Ctx` factory; warnings are tagged with the plugin name. */
@@ -13,9 +13,18 @@ export const pluginCtx = (env, warnings) => (name, options) => Object.freeze({
         debug: (message) => env.debug?.(`${name}: ${message}`),
     }),
 });
-/** Resolves enabled plugins in config order and validates their options. */
+/**
+ * Resolves core, then enabled plugins in config order, and validates their
+ * options.
+ */
 export const activatePlugins = async (env, warnings) => {
-    const active = [];
+    const active = [
+        {
+            plugin: corePlugin,
+            ctx: pluginCtx(env, warnings)(CORE_PLUGIN, {}),
+            globalInputs: true,
+        },
+    ];
     for (const [name, raw] of Object.entries(env.config.plugins)) {
         const plugin = env.plugins.find((p) => p.name === name);
         if (!plugin) {

package/dist/released.js

@@ -1,6 +1,5 @@
 import { coreCodes } from "./codes.js";
 import { renderFloatingTags } from "./floating.js";
-import { schemeRegistry } from "./schemes.js";
 import { matchUnitTags } from "./tags.js";
 import { compare } from "./util.js";
 const stable = (scheme, version) => {
@@ -13,7 +12,7 @@ const stable = (scheme, version) => {
  * tag name.
  */
 const releasedEntries = async (workspace, plan, { git, keep, }) => {
-    const matched = matchUnitTags(workspace.units, await git.tags(), schemeRegistry(workspace.schemes));
+    const matched = matchUnitTags(workspace.units, await git.tags(), 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) => {

package/dist/schemes.d.ts

@@ -1,12 +1,8 @@
 import type { Plugin, VersionScheme } from "./plugin.js";
-export interface SchemeEntry {
-    readonly plugin: string;
-    readonly name: string;
-    readonly scheme: VersionScheme<any>;
-}
-/** Schemes of core and the given plugins, in that order. */
-export declare const collectSchemes: (active: readonly {
-    readonly plugin: Plugin;
-}[]) => SchemeEntry[];
-/** Name to scheme; throws `E_SCHEME_CLASH` on a duplicate name. */
-export declare const schemeRegistry: (list: readonly SchemeEntry[]) => ReadonlyMap<string, VersionScheme<any>>;
+/**
+ * Name to scheme of `plugins`; the first registration of a name wins and a
+ * duplicate is recorded for `assertSchemes`.
+ */
+export declare const schemeRegistry: (plugins: readonly Plugin[]) => ReadonlyMap<string, VersionScheme<any>>;
+/** Throws the `E_SCHEME_CLASH` recorded by `schemeRegistry`. */
+export declare const assertSchemes: (registry: ReadonlyMap<string, unknown>) => void;

package/dist/schemes.js

@@ -1,22 +1,34 @@
-import { corePlugin } from "./builtin.js";
 import { coreCodes } from "./codes.js";
-/** Schemes of core and the given plugins, in that order. */
-export const collectSchemes = (active) => [corePlugin, ...active.map((a) => a.plugin)].flatMap((plugin) => Object.entries(plugin.schemes ?? {}).map(([name, scheme]) => ({
-    plugin: plugin.name,
-    name,
-    scheme,
-})));
-/** Name to scheme; throws `E_SCHEME_CLASH` on a duplicate name. */
-export const schemeRegistry = (list) => {
+const clashes = new WeakMap();
+/**
+ * Name to scheme of `plugins`; the first registration of a name wins and a
+ * duplicate is recorded for `assertSchemes`.
+ */
+export const schemeRegistry = (plugins) => {
     const owners = new Map();
     const registry = new Map();
-    for (const { plugin, name, scheme } of list) {
-        const owner = owners.get(name);
-        if (owner !== undefined) {
-            throw coreCodes.error("E_SCHEME_CLASH", `scheme "${name}" is registered by "${owner}" and "${plugin}"`, { scheme: name, plugins: [owner, plugin] });
+    let clash;
+    for (const plugin of plugins) {
+        for (const [name, scheme] of Object.entries(plugin.schemes ?? {})) {
+            const owner = owners.get(name);
+            if (owner !== undefined) {
+                clash ??= { scheme: name, plugins: [owner, plugin.name] };
+                continue;
+            }
+            owners.set(name, plugin.name);
+            registry.set(name, scheme);
         }
-        owners.set(name, plugin);
-        registry.set(name, scheme);
+    }
+    if (clash) {
+        clashes.set(registry, clash);
     }
     return registry;
 };
+/** Throws the `E_SCHEME_CLASH` recorded by `schemeRegistry`. */
+export const assertSchemes = (registry) => {
+    const clash = clashes.get(registry);
+    if (clash) {
+        const [first, second] = clash.plugins;
+        throw coreCodes.error("E_SCHEME_CLASH", `scheme "${clash.scheme}" is registered by "${first}" and "${second}"`, { scheme: clash.scheme, plugins: [first, second] });
+    }
+};

package/dist/testing/conformance.d.ts

@@ -1,5 +1,5 @@
 import type { Dag } from "./index.js";
-import type { GitReader, MaybePromise } from "../plugin.js";
+import type { GitReader, MaybePromise, VersionScheme } from "../plugin.js";
 /** Builds a reader for `dag`; `sha` maps a commit id to the reader's sha. */
 export type ReaderFactory = (dag: Dag) => MaybePromise<{
     git: GitReader;
@@ -13,3 +13,9 @@ export type ReaderFactory = (dag: Dag) => MaybePromise<{
  * `introduced` runs on its own fixture.
  */
 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.
+ */
+export declare const schemeConformance: <V>(scheme: VersionScheme<V>) => void;

package/dist/testing/conformance.js

@@ -202,3 +202,94 @@ export const gitReaderConformance = (makeReader) => {
         });
     });
 };
+const LEVELS = ["major", "minor", "patch"];
+const PRE_CTX = {
+    unit: {
+        id: "u",
+        root: ".",
+        plugin: "conformance",
+        include: [],
+        exclude: [],
+        version: "tag",
+        scheme: "conformance",
+        tagFormat: "v{version}",
+        propagate: "auto",
+        tags: [],
+        initialVersion: null,
+        meta: {},
+    },
+    head: "0".repeat(40),
+    baseTag: null,
+    tags: [],
+    firstParent: { sinceLineBase: 3, total: 7 },
+    channel: "rc",
+};
+/**
+ * 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.
+ */
+export const schemeConformance = (scheme) => {
+    describe("VersionScheme conformance", () => {
+        const initial = scheme.initial();
+        const bumped = (level) => scheme.bump(initial, level);
+        it("round-trips parse and format", () => {
+            for (const v of [initial, ...LEVELS.map(bumped)]) {
+                const raw = scheme.format(v);
+                const parsed = scheme.parse(raw);
+                expect(parsed).toBeDefined();
+                expect(scheme.format(parsed)).toBe(raw);
+                expect(scheme.compare(parsed, v)).toBe(0);
+            }
+        });
+        it("rejects input that is not a version", () => {
+            expect(scheme.parse("")).toBeUndefined();
+            expect(scheme.parse("not a version")).toBeUndefined();
+        });
+        it("compares consistently", () => {
+            const low = initial;
+            const high = bumped("patch");
+            expect(scheme.compare(low, low)).toBe(0);
+            expect(scheme.compare(low, high)).toBeLessThan(0);
+            expect(scheme.compare(high, low)).toBeGreaterThan(0);
+        });
+        it.each(LEVELS)("bumps %s above the previous version", (level) => {
+            const next = bumped(level);
+            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,
+            });
+            expect(scheme.core(bumped("minor"))).toEqual({
+                major,
+                minor: minor + 1,
+                patch: 0,
+            });
+            expect(scheme.core(bumped("patch"))).toEqual({
+                major,
+                minor,
+                patch: patch + 1,
+            });
+        });
+        it("keeps the core when releasing or prereleasing", () => {
+            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.d.ts

@@ -1,5 +1,4 @@
 import type { Ctx, GitReader, ReadonlyFs } from "../plugin.js";
-import type { ReaderFactory } from "./conformance.js";
 /** In-memory `ReadonlyFs` over a path-to-content map. */
 export declare const memoryFs: (files: Record<string, string>) => ReadonlyFs;
 export interface MemoryCtxOptions<O> {
@@ -43,6 +42,3 @@ export interface MemoryGit extends GitReader {
 }
 /** In-memory `GitReader` over a commit graph. */
 export declare const memoryGit: (dag: Dag) => MemoryGit;
-export type { ReaderFactory } from "./conformance.js";
-/** Re-export of `@tallyrelease/core/testing/conformance`; requires vitest. */
-export declare const gitReaderConformance: (makeReader: ReaderFactory) => void;

package/dist/testing/index.js

@@ -1,13 +1,5 @@
 import picomatch from "picomatch/posix.js";
 import { compare, uniqueSorted } from "../util.js";
-// Loaded optionally so the fakes work without vitest installed.
-// eslint-disable-next-line no-restricted-syntax
-const conformance = await import("./conformance.js").catch((error) => {
-    if (error.code === "ERR_MODULE_NOT_FOUND") {
-        return null;
-    }
-    throw error;
-});
 const SKIPPED = new Set([".git", "node_modules"]);
 const changed = (a, b) => uniqueSorted([...a.keys(), ...b.keys()]).filter((p) => a.get(p) !== b.get(p));
 /** In-memory `ReadonlyFs` over a path-to-content map. */
@@ -149,10 +141,3 @@ export const memoryGit = (dag) => {
         parents: (ref) => [...node(ref).parents],
     };
 };
-/** Re-export of `@tallyrelease/core/testing/conformance`; requires vitest. */
-export const gitReaderConformance = (makeReader) => {
-    if (conformance === null) {
-        throw new Error("gitReaderConformance requires vitest");
-    }
-    conformance.gitReaderConformance(makeReader);
-};

package/dist/validate.d.ts

@@ -1,13 +1,13 @@
 import type { Warning } from "./errors.js";
-import type { TagRef, VersionScheme } from "./plugin.js";
+import type { TagRef } from "./plugin.js";
 import type { Workspace } from "./workspace.js";
 /**
  * Release-only checks, never run by `affected`: scheme registry, schemes, tag
  * formats and initial versions of released units, group members, branch rules,
  * their absolute check targets and channels, release items, floating tag
- * formats and version file templates. Returns the scheme registry.
+ * formats and version file templates.
  */
-export declare const validateRelease: (workspace: Workspace) => ReadonlyMap<string, VersionScheme<any>>;
+export declare const validateRelease: (workspace: Workspace) => void;
 /**
  * Checks `tags` against the released units: throws `E_TAG_FORMAT_OVERLAP`,
  * returns `W_NO_MATCHING_TAG` warnings.

package/dist/validate.js

@@ -2,7 +2,7 @@ import { validateBranches } from "./branches.js";
 import { coreCodes } from "./codes.js";
 import { validateFloating } from "./floating.js";
 import { validateReleaseItems } from "./release-items.js";
-import { schemeRegistry } from "./schemes.js";
+import { assertSchemes } from "./schemes.js";
 import { compileTagFormat, matchUnitTags, noMatchingTag } from "./tags.js";
 import { uniqueSorted } from "./util.js";
 import { validateTemplates } from "./version-files.js";
@@ -10,10 +10,11 @@ import { validateTemplates } from "./version-files.js";
  * Release-only checks, never run by `affected`: scheme registry, schemes, tag
  * formats and initial versions of released units, group members, branch rules,
  * their absolute check targets and channels, release items, floating tag
- * formats and version file templates. Returns the scheme registry.
+ * formats and version file templates.
  */
 export const validateRelease = (workspace) => {
-    const schemes = schemeRegistry(workspace.schemes);
+    const { schemes } = workspace;
+    assertSchemes(schemes);
     for (const unit of workspace.units) {
         if (unit.version === "none") {
             continue;
@@ -62,13 +63,12 @@ export const validateRelease = (workspace) => {
     validateReleaseItems(workspace);
     validateFloating(workspace.release.floating);
     validateTemplates(workspace);
-    return schemes;
 };
 /**
  * Checks `tags` against the released units: throws `E_TAG_FORMAT_OVERLAP`,
  * returns `W_NO_MATCHING_TAG` warnings.
  */
 export const validateTags = (workspace, tags) => {
-    const matched = matchUnitTags(workspace.units, tags, schemeRegistry(workspace.schemes));
+    const matched = matchUnitTags(workspace.units, tags, workspace.schemes);
     return noMatchingTag(workspace.units, [...matched].map(([id, m]) => ({ id, tags: m.tags })), uniqueSorted(tags.map((t) => t.name)));
 };

package/dist/version-files.js

@@ -2,7 +2,6 @@ import { changelogPath, changelogSection, updateChangelog, } from "./changelog.j
 import { coreCodes } from "./codes.js";
 import { normalizeRoot } from "./discover.js";
 import { runHook } from "./plugins.js";
-import { schemeRegistry } from "./schemes.js";
 const TOKEN = /\{([^{}]*)\}/gu;
 const SPECIAL = /[\\^$.*+?()[\]{}|/]/gu;
 const CORE_TOKENS = ["major", "minor", "patch"];
@@ -229,7 +228,7 @@ export const versionFileClaims = async (workspace) => {
 export const releaseFiles = async (workspace, plan, opts) => {
     const { fs, items, repoUrl, date } = opts;
     const pluginFiles = await versionFileClaims(workspace);
-    const schemes = schemeRegistry(workspace.schemes);
+    const { schemes } = workspace;
     const units = new Map(workspace.units.map((u) => [u.id, u]));
     const planned = new Map(plan.units.map((u) => [u.id, u]));
     const versions = new Map(items.flatMap((i) => i.units.map((id) => [id, i.version])));

package/dist/workspace.d.ts

@@ -1,17 +1,24 @@
+import type { TallyConfig } from "./config.js";
 import type { Warning } from "./errors.js";
 import type { Graph } from "./graph.js";
 import type { Group } from "./groups.js";
-import type { IntentSource, Unit, VersionFile } from "./plugin.js";
-import type { PluginEnv } from "./plugins.js";
+import type { IntentSource, Plugin, ReadonlyFs, Unit, VersionFile, VersionScheme } from "./plugin.js";
 import type { ReleaseSettings } from "./release-settings.js";
-import type { SchemeEntry } from "./schemes.js";
 /** An intent source with its plugin's validated options; callers build the `Ctx`. */
 export interface IntentEntry {
     readonly plugin: string;
     readonly options: unknown;
     readonly source: IntentSource;
 }
-export interface WorkspaceInput extends PluginEnv {
+export interface WorkspaceInput {
+    config: TallyConfig;
+    /** Available plugins; `config.plugins` selects and orders them. */
+    plugins: readonly Plugin[];
+    fs: ReadonlyFs;
+    repo: {
+        name: string;
+    };
+    debug?: (message: string) => void;
     /** Repo-relative config file path, a global input; defaults to `CONFIG_FILE`. */
     configFile?: string;
 }
@@ -25,8 +32,8 @@ export interface Workspace {
     readonly globalInputs: readonly string[];
     readonly ignore: readonly string[];
     readonly warnings: readonly Warning[];
-    /** Registered schemes, core first; clashes are checked on release. */
-    readonly schemes: readonly SchemeEntry[];
+    /** Registered schemes by name; `validateRelease` throws on a clash. */
+    readonly schemes: ReadonlyMap<string, VersionScheme<any>>;
     /** Core sources first, then enabled plugins in config order. */
     readonly intents: readonly IntentEntry[];
     /** Bumps and branch rules with defaults applied. */

package/dist/workspace.js

@@ -1,11 +1,10 @@
-import { corePlugin } from "./builtin.js";
 import { CONFIG_FILE } from "./config.js";
 import { discoverUnits } from "./discover.js";
 import { buildGraph } from "./graph.js";
 import { resolveGroups } from "./groups.js";
 import { activatePlugins, runHook } from "./plugins.js";
 import { releaseSettings } from "./release-settings.js";
-import { collectSchemes } from "./schemes.js";
+import { schemeRegistry } from "./schemes.js";
 import { uniqueSorted } from "./util.js";
 const collectEdges = async (active, config, units) => {
     const edges = [];
@@ -74,12 +73,9 @@ export const loadWorkspace = async (input) => {
     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);
-    const intents = [
-        { plugin: corePlugin, options: {} },
-        ...active.map(({ plugin, ctx }) => ({ plugin, options: ctx.options })),
-    ].flatMap(({ plugin, options }) => (plugin.intent ?? []).map((source) => ({
+    const intents = active.flatMap(({ plugin, ctx }) => (plugin.intent ?? []).map((source) => ({
         plugin: plugin.name,
-        options,
+        options: ctx.options,
         source,
     })));
     return {
@@ -89,7 +85,7 @@ export const loadWorkspace = async (input) => {
         globalInputs,
         ignore: input.config.ignore ?? [],
         warnings: [...warnings, ...graph.warnings],
-        schemes: collectSchemes(active),
+        schemes: schemeRegistry(active.map((a) => a.plugin)),
         intents,
         release: releaseSettings(input.config, units),
         groups,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tallyrelease/core",
-  "version": "0.5.0-beta.34",
+  "version": "0.5.0-beta.41",
   "description": "Pure planning core of tallyrelease",
   "repository": {
     "type": "git",
@@ -66,7 +66,7 @@
     "eslint": "^10.13.0",
     "prettier": "^3.9.10",
     "typescript": "^6.0.3",
-    "vite": "^8.3.4",
+    "vite": "^8.3.5",
     "vitest": "^5.0.5",
     "yaml": "^2.9.1"
   },