@tallyrelease/core 0.1.1 → 0.2.0

package/dist/plan.js

@@ -0,0 +1,351 @@
+import { computeAffected } from "./affected.js";
+import { checkLimits, matchBranch } from "./branches.js";
+import { collectPlanFacts } from "./facts.js";
+import { propagate } from "./propagate.js";
+import { changeLevel, footerOf, reach, releaseAsWarnings, releaseGroup, releaseUnit, unitIntent, } from "./release.js";
+import { noMatchingTag } from "./tags.js";
+import { maxLevel } from "./util.js";
+import { validateRelease } from "./validate.js";
+const lineWarnings = (workspace, branch, line) => {
+    if (!line) {
+        return [
+            {
+                code: "W_NO_BRANCH_RULE",
+                message: `no branch rule matches "${branch}"; versions are null`,
+            },
+        ];
+    }
+    return workspace.units.every((u) => u.version === "none")
+        ? [
+            {
+                code: "W_NO_RELEASED_UNITS",
+                message: `branch rule "${line.rule}" matches, but no unit is released`,
+            },
+        ]
+        : [];
+};
+const planChanges = (intent) => (intent?.changes ?? []).map(({ change, via }) => {
+    const releaseAs = change.sha === undefined
+        ? undefined
+        : intent?.releaseAsBySha.get(change.sha);
+    return {
+        ...(change.sha === undefined ? {} : { sha: change.sha }),
+        type: change.type,
+        breaking: change.breaking,
+        ...(change.scope === undefined ? {} : { scope: change.scope }),
+        subject: change.subject,
+        ...(change.pr === undefined ? {} : { pr: change.pr }),
+        ...(via === undefined ? {} : { via }),
+        ...(releaseAs === undefined ? {} : { releaseAs }),
+    };
+});
+/**
+ * Release inputs of the released units with a scheme and range; the same set
+ * bounds absorption here and propagation in `resolvePlan`.
+ */
+const releaseInputs = (workspace, { facts, schemes }, channel) => {
+    const units = new Map(workspace.units.map((u) => [u.id, u]));
+    const entries = facts.units.flatMap((unitFacts) => {
+        const unit = units.get(unitFacts.id);
+        const scheme = unit && schemes.get(unit.scheme);
+        const range = facts.ranges.find((r) => r.from === unitFacts.from);
+        return unit && scheme && range ? [{ unit, scheme, unitFacts, range }] : [];
+    });
+    const released = new Set(entries.map((e) => e.unit.id));
+    return new Map(entries.map(({ unit, scheme, unitFacts, range }) => [
+        unit.id,
+        {
+            unit,
+            scheme,
+            settings: workspace.release,
+            facts: unitFacts,
+            range,
+            absorbed: reach(unit.id, workspace.graph.dependencies, released),
+            head: facts.head,
+            channel,
+        },
+    ]));
+};
+const UNRELEASED = {
+    from: null,
+    bump: null,
+    releaseAs: null,
+    releaseAsFooter: null,
+    next: null,
+    nextSource: null,
+    prerelease: null,
+};
+/** The unit's plan entry; undefined when it is not listed. */
+const unitPlan = (entry, all) => {
+    const { unit, hit, facts } = entry;
+    const release = entry.release ?? UNRELEASED;
+    if (!hit && !(release.next !== null && all)) {
+        return undefined;
+    }
+    const { prerelease } = release;
+    const kind = !hit ? "none" : prerelease === null ? "rebuild" : "prerelease";
+    return {
+        id: unit.id,
+        path: unit.root,
+        plugin: unit.plugin,
+        scheme: unit.scheme,
+        tags: [...unit.tags],
+        group: entry.group,
+        affected: hit ? { reason: hit.reason, via: hit.via } : null,
+        kind,
+        baseTag: facts?.baseTag?.name ?? null,
+        lineBaseTag: facts?.lineBaseTag?.name ?? null,
+        from: release.from,
+        bump: release.bump,
+        releaseAs: release.releaseAs,
+        propagatedFrom: [...entry.propagatedFrom],
+        absorbedFrom: [...(entry.intent?.absorbedFrom ?? [])],
+        next: release.next,
+        version: kind === "prerelease" ? prerelease : null,
+        sha: entry.head,
+        changes: planChanges(entry.intent),
+    };
+};
+/** The only release item (ungrouped released unit or group), else null. */
+const singleItem = (workspace) => {
+    const grouped = new Set(workspace.groups.flatMap((g) => g.members));
+    const items = [
+        ...workspace.groups.map((g) => ({ unit: null, group: g.name })),
+        ...workspace.units
+            .filter((u) => u.version !== "none" && !grouped.has(u.id))
+            .map((u) => ({ unit: u.id, group: null })),
+    ];
+    return items.length === 1 ? (items[0] ?? null) : null;
+};
+/**
+ * Limit input of a release item over its member ids: the changes and
+ * Release-As values that produce `next`.
+ */
+const limitItem = (item, units) => {
+    const first = item.ids
+        .map((id) => units.inputs.get(id))
+        .find((i) => i !== undefined);
+    if (!first) {
+        return undefined;
+    }
+    const { scheme, settings } = first;
+    const core = (version) => {
+        const parsed = version === null ? undefined : scheme.parse(version);
+        if (parsed === undefined || version === null) {
+            return null;
+        }
+        const { major, minor } = scheme.core(parsed);
+        return { major, minor, version };
+    };
+    const from = core(item.from);
+    // Keyed by sha, file-based changes by identity; members merge.
+    const commits = new Map();
+    for (const id of item.ids) {
+        const input = units.inputs.get(id);
+        const intent = units.intents.get(id);
+        for (const unitChange of intent?.changes ?? []) {
+            const { change, via } = unitChange;
+            const key = change.sha ?? change;
+            const prev = commits.get(key);
+            const level = changeLevel(unitChange, settings, from?.major === 0);
+            const entry = {
+                ...(change.sha === undefined ? {} : { sha: change.sha }),
+                subject: change.subject,
+                level,
+                ...(via === undefined ? {} : { via }),
+            };
+            // The highest level wins; a direct change wins over an absorbed one.
+            const kept = prev !== undefined &&
+                maxLevel(prev.level, level) === prev.level &&
+                (level !== prev.level || via !== undefined);
+            commits.set(key, kept
+                ? prev
+                : { ...entry, ...(prev?.releaseAs && { releaseAs: prev.releaseAs }) });
+        }
+        const releaseAs = intent?.releaseAs;
+        if (input && releaseAs) {
+            const { sha } = releaseAs;
+            const key = sha ?? `Release-As: ${releaseAs.raw}`;
+            const { major, minor } = scheme.core(releaseAs.version);
+            commits.set(key, {
+                ...(sha === undefined ? {} : { sha }),
+                subject: input.range.changes.find((c) => sha !== undefined && c.change.sha === sha)?.change.subject ?? key,
+                level: null,
+                ...commits.get(key),
+                releaseAs: {
+                    major,
+                    minor,
+                    version: scheme.format(releaseAs.version),
+                },
+            });
+        }
+    }
+    return {
+        unit: item.unit,
+        group: item.group,
+        from,
+        next: core(item.next),
+        commits: [...commits.values()],
+    };
+};
+/** Releases of fixed group members, by unit id, and the group entries. */
+const resolveGroupReleases = ({ facts, affected }, units, warnings) => {
+    const hits = new Set(affected.units.map((u) => u.id));
+    const releases = new Map();
+    const groups = [];
+    for (const group of facts.groups) {
+        const members = group.members.flatMap((id) => {
+            const input = units.inputs.get(id);
+            const intent = units.intents.get(id);
+            return input && intent
+                ? [
+                    {
+                        input,
+                        bump: units.propagated.get(id)?.bump ?? intent.bump,
+                        releaseAs: intent.releaseAs,
+                    },
+                ]
+                : [];
+        });
+        if (members.length === 0) {
+            continue;
+        }
+        const release = releaseGroup(group, members, warnings);
+        for (const { input, releaseAs } of members) {
+            releases.set(input.unit.id, {
+                ...release,
+                from: input.facts.baseTag?.version ?? null,
+                releaseAs: releaseAs === undefined
+                    ? null
+                    : input.scheme.format(releaseAs.version),
+                releaseAsFooter: footerOf(releaseAs),
+            });
+        }
+        groups.push({
+            name: group.name,
+            members: [...group.members],
+            baseTag: group.baseTag?.name ?? null,
+            from: release.from,
+            bump: release.bump,
+            next: release.next,
+            version: group.members.some((id) => hits.has(id))
+                ? release.prerelease
+                : null,
+        });
+    }
+    return { releases, groups };
+};
+/** `resolvePlan` with the release of each released unit. */
+const resolveReleases = (workspace, input) => {
+    const { affected, facts } = input;
+    const { units: _, ...doc } = affected;
+    const line = matchBranch(workspace.release.branches, affected.branch, singleItem(workspace));
+    const warnings = [
+        ...affected.warnings,
+        ...lineWarnings(workspace, affected.branch, line),
+        ...facts.warnings,
+        ...releaseAsWarnings(workspace.units, facts.ranges),
+    ];
+    const rank = new Map(workspace.graph.order.map((id, i) => [id, i]));
+    const ordered = [...workspace.units].sort((a, b) => (rank.get(a.id) ?? 0) - (rank.get(b.id) ?? 0));
+    const hits = new Map(affected.units.map((u) => [u.id, u]));
+    const factsById = new Map(facts.units.map((f) => [f.id, f]));
+    const inputs = releaseInputs(workspace, input, line?.channel ?? null);
+    const intents = new Map([...inputs].map(([id, i]) => [id, unitIntent(i, warnings)]));
+    const groupOf = new Map(workspace.groups.flatMap((g) => g.members.map((id) => [id, g.name])));
+    const propagated = propagate(workspace.graph, workspace.units, new Map([...intents].map(([id, i]) => {
+        const group = groupOf.get(id);
+        return [
+            id,
+            {
+                bump: i.bump,
+                pending: i.bump !== null || i.releaseAs !== undefined,
+                ...(group === undefined ? {} : { group }),
+            },
+        ];
+    })));
+    const { releases: groupReleases, groups } = resolveGroupReleases(input, { inputs, intents, propagated }, warnings);
+    const units = [];
+    const releases = new Map();
+    for (const unit of ordered) {
+        const { id } = unit;
+        const unitInput = inputs.get(id);
+        const intent = intents.get(id);
+        const state = propagated.get(id);
+        const release = groupReleases.get(id) ??
+            (unitInput && intent
+                ? releaseUnit(unitInput, { bump: state?.bump ?? intent.bump, releaseAs: intent.releaseAs }, warnings)
+                : undefined);
+        if (release) {
+            releases.set(id, release);
+        }
+        const entry = unitPlan({
+            unit,
+            group: groupOf.get(id) ?? null,
+            hit: hits.get(id),
+            facts: factsById.get(id),
+            intent,
+            release,
+            propagatedFrom: state?.propagatedFrom ?? [],
+            head: facts.head,
+        }, input.all);
+        if (entry) {
+            units.push(entry);
+        }
+    }
+    const limits = { inputs, intents };
+    const rule = workspace.release.branches.find((r) => r.name === line?.rule);
+    checkLimits(line, [
+        ...groups.flatMap((g) => limitItem({
+            unit: null,
+            group: g.name,
+            ids: g.members,
+            from: g.from,
+            next: g.next,
+        }, limits) ?? []),
+        ...ordered.flatMap((u) => {
+            const release = releases.get(u.id);
+            return groupOf.has(u.id) || !release
+                ? []
+                : (limitItem({
+                    unit: u.id,
+                    group: null,
+                    ids: [u.id],
+                    from: release.from,
+                    next: release.next,
+                }, limits) ?? []);
+        }),
+    ], {
+        branch: affected.branch,
+        implicit: rule?.unit === null && rule.group === null,
+    });
+    warnings.push(...noMatchingTag(workspace.units, facts.units, facts.tagNames));
+    return {
+        plan: { ...doc, line, units, groups, released: [], warnings },
+        releases,
+    };
+};
+/** Release math over collected facts; no I/O. */
+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);
+    const affected = await computeAffected(workspace, git, opts);
+    const facts = await collectPlanFacts(workspace, git, {
+        head: opts.head,
+        fs: opts.fs,
+        ...(opts.debug && { debug: opts.debug }),
+    });
+    const { plan, releases } = resolveReleases(workspace, {
+        affected,
+        facts,
+        schemes,
+        all: opts.all ?? false,
+    });
+    return { plan, facts, releases };
+};
+/**
+ * Plans `head`: validates release config, computes the build set, collects
+ * git and intent facts and resolves versions and kinds.
+ */
+export const computePlan = async (workspace, git, opts) => (await planWithFacts(workspace, git, opts)).plan;

package/dist/plugin.d.ts

@@ -99,6 +99,8 @@ export interface Unit {
     readonly propagate: Propagate;
     /** From the config overlay; sorted, unique. */
     readonly tags: readonly string[];
+    /** Config overlay, else `defaults.initialVersion`; null uses `scheme.initial()`. */
+    readonly initialVersion: string | null;
     readonly meta: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
 }
 /** `to` depends on `from`. */
@@ -166,6 +168,11 @@ export interface IntentSource<O = unknown> {
         commits: readonly RawCommit[];
     }) => MaybePromise<Change[]>;
 }
+/** A `Release-As` value; `unit` is set by the qualified form `<unit>@<version>`. */
+export interface ReleaseAsValue {
+    unit?: string;
+    version: string;
+}
 export interface Change {
     /** Commit-derived changes are attributed via that commit's files. */
     sha?: string;
@@ -176,7 +183,7 @@ export interface Change {
     scope?: string;
     subject: string;
     body?: string;
-    releaseAs?: string;
+    releaseAs?: ReleaseAsValue[];
     pr?: number;
     date?: string;
 }

package/dist/plugins.d.ts

@@ -18,6 +18,8 @@ export interface PluginEnv {
     };
     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[]>;
 /** Awaits a plugin hook, wrapping thrown errors as `E_PLUGIN_HOOK`. */

package/dist/plugins.js

@@ -1,5 +1,18 @@
+import { CORE_PLUGIN } from "./builtin.js";
 import { TallyError } from "./errors.js";
 import { assertPlugin } from "./plugin.js";
+/** Frozen `Ctx` factory; warnings are tagged with the plugin name. */
+export const pluginCtx = (env, warnings) => (name, options) => Object.freeze({
+    options,
+    repo: Object.freeze({ name: env.repo.name }),
+    fs: env.fs,
+    log: Object.freeze({
+        warn: (message) => {
+            warnings.push({ code: "W_PLUGIN", message, plugin: name });
+        },
+        debug: (message) => env.debug?.(`${name}: ${message}`),
+    }),
+});
 /** Resolves enabled plugins in config order and validates their options. */
 export const activatePlugins = async (env, warnings) => {
     const active = [];
@@ -11,6 +24,9 @@ export const activatePlugins = async (env, warnings) => {
             });
         }
         assertPlugin(plugin);
+        if (plugin.name === CORE_PLUGIN) {
+            throw new TallyError("E_PLUGIN_NAME", `plugin name "${CORE_PLUGIN}" is reserved for core built-ins`, { plugin: name });
+        }
         const { globalInputs, ...rest } = raw ?? {};
         let options = rest;
         if (plugin.options) {
@@ -21,17 +37,7 @@ export const activatePlugins = async (env, warnings) => {
             }
             options = result.value;
         }
-        const ctx = Object.freeze({
-            options,
-            repo: Object.freeze({ name: env.repo.name }),
-            fs: env.fs,
-            log: Object.freeze({
-                warn: (message) => {
-                    warnings.push({ code: "W_PLUGIN", message, plugin: name });
-                },
-                debug: (message) => env.debug?.(`${name}: ${message}`),
-            }),
-        });
+        const ctx = pluginCtx(env, warnings)(name, options);
         active.push({ plugin, ctx, globalInputs: globalInputs !== false });
     }
     return active;

package/dist/propagate.d.ts

@@ -0,0 +1,22 @@
+import type { Graph } from "./graph.js";
+import type { BumpLevel, Unit } from "./plugin.js";
+/** Bump state of a released unit. */
+export interface Pending {
+    readonly bump: BumpLevel | null;
+    /** Has a bump or a Release-As value. */
+    readonly pending: boolean;
+    /** Fixed group name. */
+    readonly group?: string;
+}
+export interface Propagated extends Pending {
+    /** Sorted. */
+    readonly propagatedFrom: readonly string[];
+}
+/**
+ * Propagation and group fixpoint over released units in graph order. For a
+ * pending `from`, the dependent's policy (`auto` = pinned ? patch : rebuild)
+ * decides: `patch` raises it to at least patch, `rebuild` changes nothing. A
+ * group with a pending member makes every member pending at the members' max
+ * bump. Terminates because bumps only increase.
+ */
+export declare const propagate: (graph: Pick<Graph, "edges" | "order">, units: readonly Pick<Unit, "id" | "propagate">[], states: ReadonlyMap<string, Pending>) => Map<string, Propagated>;

package/dist/propagate.js

@@ -0,0 +1,98 @@
+import { maxLevel, uniqueSorted } from "./util.js";
+/**
+ * Edges between released units, `to` to `from` to `pinned`. A path through
+ * unreleased units counts as an edge with the first hop's `pinned`; several
+ * paths are OR-combined.
+ */
+const releasedEdges = (edges, released) => {
+    const out = new Map();
+    for (const e of edges) {
+        const list = out.get(e.from) ?? [];
+        list.push(e);
+        out.set(e.from, list);
+    }
+    const result = new Map();
+    for (const from of released) {
+        const seen = new Set();
+        const queue = (out.get(from) ?? []).map((e) => ({
+            to: e.to,
+            pinned: e.pinned,
+        }));
+        for (const { to, pinned } of queue) {
+            const key = `${to}\0${String(pinned)}`;
+            if (to === from || seen.has(key)) {
+                continue;
+            }
+            seen.add(key);
+            if (released.has(to)) {
+                const incoming = result.get(to) ?? new Map();
+                incoming.set(from, (incoming.get(from) ?? false) || pinned);
+                result.set(to, incoming);
+            }
+            else {
+                queue.push(...(out.get(to) ?? []).map((e) => ({ to: e.to, pinned })));
+            }
+        }
+    }
+    return result;
+};
+/**
+ * Propagation and group fixpoint over released units in graph order. For a
+ * pending `from`, the dependent's policy (`auto` = pinned ? patch : rebuild)
+ * decides: `patch` raises it to at least patch, `rebuild` changes nothing. A
+ * group with a pending member makes every member pending at the members' max
+ * bump. Terminates because bumps only increase.
+ */
+export const propagate = (graph, units, states) => {
+    const policies = new Map(units.map((u) => [u.id, u.propagate]));
+    const groups = new Map();
+    for (const [id, { group }] of states) {
+        if (group !== undefined) {
+            groups.set(group, [...(groups.get(group) ?? []), id]);
+        }
+    }
+    const edges = releasedEdges(graph.edges, new Set(states.keys()));
+    const result = new Map([...states].map(([id, s]) => [
+        id,
+        { bump: s.bump, pending: s.pending, propagatedFrom: new Set() },
+    ]));
+    let changed = true;
+    while (changed) {
+        changed = false;
+        for (const id of graph.order) {
+            const state = result.get(id);
+            for (const [from, pinned] of edges.get(id) ?? []) {
+                const policy = policies.get(id) ?? "auto";
+                const patch = policy === "auto" ? pinned : policy === "patch";
+                if (!state ||
+                    !patch ||
+                    !result.get(from)?.pending ||
+                    state.propagatedFrom.has(from)) {
+                    continue;
+                }
+                state.propagatedFrom.add(from);
+                state.bump = maxLevel(state.bump, "patch");
+                state.pending = true;
+                changed = true;
+            }
+        }
+        for (const members of groups.values()) {
+            const raised = members.flatMap((id) => result.get(id) ?? []);
+            if (!raised.some((s) => s.pending)) {
+                continue;
+            }
+            const bump = raised.reduce((level, s) => maxLevel(level, s.bump), null);
+            for (const s of raised) {
+                if (!s.pending || s.bump !== bump) {
+                    s.pending = true;
+                    s.bump = bump;
+                    changed = true;
+                }
+            }
+        }
+    }
+    return new Map([...result].map(([id, s]) => [
+        id,
+        { ...s, propagatedFrom: uniqueSorted(s.propagatedFrom) },
+    ]));
+};

package/dist/release.d.ts

@@ -0,0 +1,133 @@
+import type { TallyConfig } from "./config.js";
+import type { Warning } from "./errors.js";
+import type { GroupFacts, RangeFacts, UnitFacts } from "./facts.js";
+import type { BumpLevel, Change, Unit, VersionScheme } from "./plugin.js";
+/**
+ * Level of one change. While the major is 0, breaking changes use
+ * `preMajor.breaking` and changes whose type level is minor `preMajor.feat`.
+ * An absorbed change contributes `bumps.absorbed` when its own level is set
+ * (`minor` caps it at minor).
+ */
+declare const changeLevel: ({ change, via }: UnitChange, settings: ReleaseSettings, preMajor: boolean) => BumpLevel | null;
+/** The Release-As footer value that applies to a unit. */
+export interface ReleaseAsWinner<V> {
+    readonly sha?: string;
+    /** As written in the footer. */
+    readonly raw: string;
+    readonly version: V;
+}
+/** A normalized branch rule. */
+export interface BranchRule {
+    readonly name: string;
+    readonly line: "default" | "maintenance";
+    readonly channel: string | null;
+    /** Release item of the absolute maintenance check. */
+    readonly unit: string | null;
+    readonly group: string | null;
+}
+/** Release config with defaults applied. */
+export interface ReleaseSettings {
+    /** Commit type to level. */
+    readonly bumps: ReadonlyMap<string, BumpLevel>;
+    /** Levels used while `core(from).major == 0`. */
+    readonly preMajor: {
+        readonly breaking: BumpLevel;
+        readonly feat: BumpLevel;
+    };
+    /** Level cap of absorbed changes with a bump. */
+    readonly absorbed: "patch" | "minor";
+    /** In config order. */
+    readonly branches: readonly BranchRule[];
+}
+/**
+ * A Change of a released unit; `via` names the first absorbed unit (by id) a
+ * change not attributed to the unit came through.
+ */
+export interface UnitChange {
+    readonly change: Change;
+    readonly via?: string;
+}
+/** Bump inputs of a released unit, before propagation. */
+export interface UnitIntent<V> {
+    /** Own and absorbed level. */
+    readonly bump: BumpLevel | null;
+    readonly releaseAs: ReleaseAsWinner<V> | undefined;
+    /** Core commit order. */
+    readonly changes: readonly UnitChange[];
+    /** Absorbed units of the changes with `via`, sorted. */
+    readonly absorbedFrom: readonly string[];
+    /** Release-As value per commit sha, for the plan's change list. */
+    readonly releaseAsBySha: ReadonlyMap<string, string>;
+}
+export interface UnitRelease {
+    readonly from: string | null;
+    readonly bump: BumpLevel | null;
+    readonly releaseAs: string | null;
+    /** The footer that set `releaseAs`. */
+    readonly releaseAsFooter: {
+        readonly sha?: string;
+        readonly raw: string;
+    } | null;
+    /** Null without a pending bump or Release-As. */
+    readonly next: string | null;
+    /** What set `next`. */
+    readonly nextSource: "bump" | "initial" | "release-as" | null;
+    /** Prerelease of `next` on `channel`; null without a channel or `next`. */
+    readonly prerelease: string | null;
+}
+export interface ReleaseInput<V> {
+    readonly unit: Unit;
+    readonly scheme: VersionScheme<V>;
+    readonly settings: ReleaseSettings;
+    readonly facts: UnitFacts;
+    /** The range of `facts.from`. */
+    readonly range: RangeFacts;
+    /** Unreleased units absorbed by the unit (`reach`). */
+    readonly absorbed: ReadonlySet<string>;
+    readonly head: string;
+    readonly channel: string | null;
+}
+/**
+ * Unreleased units reachable over `id`'s dependencies, never stepping into or
+ * through a released unit.
+ */
+export declare const reach: (id: string, dependencies: ReadonlyMap<string, readonly string[]>, released: ReadonlySet<string>) => Set<string>;
+/** Applies the defaults to `bumps` and `branches`. */
+export declare const releaseSettings: (config: TallyConfig) => ReleaseSettings;
+/**
+ * Warns for qualified Release-As values naming unknown or unreleased units and
+ * for plain values on commits attributed to no released unit.
+ */
+export declare const releaseAsWarnings: (units: readonly Unit[], ranges: readonly RangeFacts[]) => Warning[];
+/**
+ * Own and absorbed bump and Release-As of a released unit. Release-As values
+ * are read newest first (core commit order); a single leading `v` is
+ * stripped, as release-please does. Footers are not absorbed.
+ */
+export declare const unitIntent: <V>(input: ReleaseInput<V>, warnings: Warning[]) => UnitIntent<V>;
+/** The recorded footer of a Release-As winner. */
+export declare const footerOf: <V>(winner: ReleaseAsWinner<V> | undefined) => UnitRelease["releaseAsFooter"];
+/**
+ * `next` and prerelease of a released unit from its bump after propagation;
+ * Release-As overrides `next`.
+ */
+export declare const releaseUnit: <V>(input: ReleaseInput<V>, intent: {
+    bump: BumpLevel | null;
+    releaseAs: ReleaseAsWinner<V> | undefined;
+}, warnings: Warning[]) => UnitRelease;
+/** A fixed group member; `input.facts.fromTag` is the group base tag. */
+export interface GroupMember<V> {
+    readonly input: ReleaseInput<V>;
+    /** After propagation and group raising. */
+    readonly bump: BumpLevel | null;
+    readonly releaseAs: ReleaseAsWinner<V> | undefined;
+}
+/**
+ * Release of a fixed group with members sorted by id:
+ * `next = max(bump(groupFrom, L), max_i releaseAs_i)`, the initial version
+ * (max over members) instead of the bump on a first release. One `PreCtx`:
+ * first member, group base tag, union of member tags, group line base
+ * counter, max total.
+ */
+export declare const releaseGroup: <V>(group: GroupFacts, members: readonly GroupMember<V>[], warnings: Warning[]) => Omit<UnitRelease, "releaseAsFooter">;
+export { changeLevel };