@tallyrelease/core 0.0.0-stage → 0.0.0

package/dist/affected.d.ts

@@ -0,0 +1,42 @@
+import type { Warning } from "./errors.js";
+import type { GitReader } from "./plugin.js";
+import type { Workspace } from "./workspace.js";
+export type BaseSource = "cli" | "push-before" | "pr-merge-base" | "merge-group" | "forge-last-success" | "none";
+export type AffectedReason = "direct" | "dependent" | "global" | "all";
+export interface AffectedUnit {
+    id: string;
+    /** Unit root, `.` for the repo root. */
+    path: string;
+    plugin: string;
+    reason: AffectedReason;
+    /** Affected direct dependencies that made a dependent affected. */
+    via: string[];
+}
+/** `tallyrelease affected --json`, schema 1. */
+export interface AffectedDoc {
+    schema: 1;
+    tool: string;
+    repo: string;
+    branch: string;
+    head: string;
+    build: {
+        base: string | null;
+        baseSource: BaseSource;
+        all: boolean;
+        globalInputs: string[];
+    };
+    units: AffectedUnit[];
+    unattributed: string[];
+    warnings: Warning[];
+}
+export interface AffectedOptions {
+    /** For example `tallyrelease@0.1.0`. */
+    tool: string;
+    branch: string;
+    head: string;
+    /** Null marks every unit affected without a diff. */
+    base: string | null;
+    baseSource: BaseSource;
+}
+/** Computes the build set for `base..head` from a tree-to-tree diff. */
+export declare const computeAffected: (workspace: Workspace, git: GitReader, opts: AffectedOptions) => Promise<AffectedDoc>;

package/dist/affected.js

@@ -0,0 +1,74 @@
+import { attribution, matcher } from "./attribution.js";
+import { uniqueSorted } from "./util.js";
+/** Computes the build set for `base..head` from a tree-to-tree diff. */
+export const computeAffected = async (workspace, git, opts) => {
+    const { units, graph } = workspace;
+    const doc = (affected, build, unattributed) => ({
+        schema: 1,
+        tool: opts.tool,
+        repo: workspace.repo,
+        branch: opts.branch,
+        head: opts.head,
+        build: { base: opts.base, baseSource: opts.baseSource, ...build },
+        units: affected,
+        unattributed,
+        warnings: [...workspace.warnings],
+    });
+    const everything = (reason) => units.map((u) => ({
+        id: u.id,
+        path: u.root,
+        plugin: u.plugin,
+        reason,
+        via: [],
+    }));
+    if (opts.base === null) {
+        return doc(everything("all"), { all: true, globalInputs: [] }, []);
+    }
+    const ignored = matcher(workspace.ignore);
+    const isGlobal = matcher(workspace.globalInputs);
+    const owners = attribution(units);
+    const files = (await git.diffFiles(opts.base, opts.head)).filter((f) => !ignored(f));
+    const hits = uniqueSorted(files.filter(isGlobal));
+    const direct = new Set();
+    const unattributed = [];
+    for (const file of files) {
+        if (isGlobal(file)) {
+            continue;
+        }
+        const ids = owners(file);
+        if (ids.length === 0) {
+            unattributed.push(file);
+        }
+        for (const id of ids) {
+            direct.add(id);
+        }
+    }
+    if (hits.length > 0) {
+        return doc(everything("global"), { all: true, globalInputs: hits }, uniqueSorted(unattributed));
+    }
+    const affected = new Set(direct);
+    const queue = [...direct];
+    for (const id of queue) {
+        for (const dependent of graph.dependents.get(id) ?? []) {
+            if (!affected.has(dependent)) {
+                affected.add(dependent);
+                queue.push(dependent);
+            }
+        }
+    }
+    const result = units
+        .filter((u) => affected.has(u.id))
+        .map((u) => {
+        const isDirect = direct.has(u.id);
+        return {
+            id: u.id,
+            path: u.root,
+            plugin: u.plugin,
+            reason: isDirect ? "direct" : "dependent",
+            via: isDirect
+                ? []
+                : (graph.dependencies.get(u.id) ?? []).filter((d) => affected.has(d)),
+        };
+    });
+    return doc(result, { all: false, globalInputs: [] }, uniqueSorted(unattributed));
+};

package/dist/attribution.d.ts

@@ -0,0 +1,6 @@
+import type { Unit } from "./plugin.js";
+export type PathMatcher = (path: string) => boolean;
+/** Matches any of `patterns`; an empty list matches nothing. */
+export declare const matcher: (patterns: readonly string[]) => PathMatcher;
+/** Returns the ids of units owning a path: `include` matches, `exclude` does not. */
+export declare const attribution: (units: readonly Unit[]) => ((path: string) => string[]);

package/dist/attribution.js

@@ -0,0 +1,12 @@
+import picomatch from "picomatch/posix.js";
+/** Matches any of `patterns`; an empty list matches nothing. */
+export const matcher = (patterns) => patterns.length === 0 ? () => false : picomatch([...patterns], { dot: true });
+/** Returns the ids of units owning a path: `include` matches, `exclude` does not. */
+export const attribution = (units) => {
+    const owners = units.map((u) => ({
+        id: u.id,
+        include: matcher(u.include),
+        exclude: matcher(u.exclude),
+    }));
+    return (path) => owners.filter((o) => o.include(path) && !o.exclude(path)).map((o) => o.id);
+};

package/dist/config.d.ts

@@ -0,0 +1,36 @@
+import type { Propagate, VersionMode } from "./plugin.js";
+/** Config overlay for the unit at a root; creates a config-only unit if none is discovered. */
+export interface UnitOverlay {
+    id?: string;
+    include?: string[];
+    exclude?: string[];
+    version?: VersionMode;
+    scheme?: string;
+    tagFormat?: string;
+    propagate?: Propagate;
+}
+export interface DepConfig {
+    from: string;
+    to: string;
+    pinned?: boolean;
+    reason?: string;
+}
+/** Parsed `tallyrelease.yaml`, as passed by the cli. */
+export interface TallyConfig {
+    /**
+     * Enabled plugins in run order, mapped to their raw options. The core-owned
+     * key `globalInputs: false` disables that plugin's default global inputs.
+     */
+    plugins: Record<string, Record<string, unknown> | null>;
+    defaults?: {
+        tagFormat?: string;
+        propagate?: Propagate;
+    };
+    /** Overlays keyed by unit root. */
+    units?: Record<string, UnitOverlay>;
+    deps?: DepConfig[];
+    ignore?: string[];
+    globalInputs?: string[];
+}
+/** Global input owned by core. */
+export declare const CONFIG_FILE = "tallyrelease.yaml";

package/dist/config.js

@@ -0,0 +1,2 @@
+/** Global input owned by core. */
+export const CONFIG_FILE = "tallyrelease.yaml";

package/dist/discover.d.ts

@@ -0,0 +1,7 @@
+import type { Unit } from "./plugin.js";
+import type { ActivePlugin, PluginEnv } from "./plugins.js";
+/**
+ * Runs `discover` hooks in config order, applies config overlays and fills
+ * defaults. Returns units sorted by id.
+ */
+export declare const discoverUnits: (active: readonly ActivePlugin[], env: Pick<PluginEnv, "config" | "fs" | "repo">) => Promise<Unit[]>;

package/dist/discover.js

@@ -0,0 +1,110 @@
+import { TallyError } from "./errors.js";
+import { defaultUnitId } from "./plugin.js";
+import { runHook } from "./plugins.js";
+import { compare } from "./util.js";
+const UNIT_ID = /^(?!\.\.?$)[A-Za-z0-9._-]+$/;
+/** Drops `.` and empty segments; rejects absolute roots and `..` segments. */
+const normalizeRoot = (root) => {
+    const segments = root.split("/");
+    if (root.startsWith("/") || segments.includes("..")) {
+        throw new TallyError("E_ROOT_INVALID", `root "${root}" must be repo-relative without ".." segments`, { root });
+    }
+    return segments.filter((s) => s !== "" && s !== ".").join("/") || ".";
+};
+/** Escapes glob metacharacters so a root matches literally. */
+const escapeGlob = (path) => path.replace(/[[\]{}()!*?+@\\]/g, "\\$&");
+const isInside = (path, root) => path !== root && (root === "." || path.startsWith(`${root}/`));
+/**
+ * Runs `discover` hooks in config order, applies config overlays and fills
+ * defaults. Returns units sorted by id.
+ */
+export const discoverUnits = async (active, env) => {
+    const byRoot = new Map();
+    for (const { plugin, ctx } of active) {
+        const discover = plugin.discover?.bind(plugin);
+        if (!discover) {
+            continue;
+        }
+        // eslint-disable-next-line no-await-in-loop -- hooks run sequentially in config order
+        const drafts = await runHook(plugin.name, "discover", () => discover(ctx));
+        for (const { meta, ...draft } of drafts) {
+            const root = normalizeRoot(draft.root);
+            const prior = byRoot.get(root);
+            if (prior) {
+                throw new TallyError("E_DUPLICATE_ROOT", `root "${root}" is discovered by "${prior.plugin}" and "${plugin.name}"`, { root, plugins: [prior.plugin, plugin.name] });
+            }
+            byRoot.set(root, {
+                plugin: plugin.name,
+                draft: { ...draft, root },
+                meta: meta ? { [plugin.name]: Object.freeze({ ...meta }) } : {},
+            });
+        }
+    }
+    for (const [key, overlay] of Object.entries(env.config.units ?? {})) {
+        const root = normalizeRoot(key);
+        const entry = byRoot.get(root);
+        if (entry) {
+            entry.draft = { ...entry.draft, ...overlay };
+        }
+        else {
+            byRoot.set(root, {
+                plugin: "config",
+                draft: {
+                    ...overlay,
+                    id: overlay.id ?? defaultUnitId(root, env.repo.name),
+                    root,
+                },
+                meta: {},
+            });
+        }
+    }
+    const byId = new Map();
+    for (const entry of byRoot.values()) {
+        const { id, root } = entry.draft;
+        if (!UNIT_ID.test(id)) {
+            throw new TallyError("E_UNIT_ID", `unit id "${id}" at "${root}" must match ${UNIT_ID.source}`, { id, root, plugin: entry.plugin });
+        }
+        const prior = byId.get(id);
+        if (prior) {
+            throw new TallyError("E_DUPLICATE_UNIT", `unit id "${id}" is used by "${prior.plugin}" at "${prior.draft.root}" and "${entry.plugin}" at "${root}"`, {
+                id,
+                owners: [
+                    { plugin: prior.plugin, root: prior.draft.root },
+                    { plugin: entry.plugin, root },
+                ],
+            });
+        }
+        byId.set(id, entry);
+        if (root !== "." && !env.fs.exists(root)) {
+            throw new TallyError("E_ROOT_MISSING", `root "${root}" of unit "${id}" does not exist`, { id, root });
+        }
+    }
+    const roots = [...byRoot.keys()].sort(compare);
+    const { defaults } = env.config;
+    return [...byId.values()]
+        .map(({ plugin, draft, meta }) => {
+        const { root } = draft;
+        const nested = roots
+            .filter((r) => isInside(r, root))
+            .map((r) => `${escapeGlob(r)}/**`);
+        return Object.freeze({
+            id: draft.id,
+            root,
+            plugin,
+            include: Object.freeze([
+                ...(draft.include ?? [
+                    root === "." ? "**" : `${escapeGlob(root)}/**`,
+                ]),
+            ]),
+            exclude: Object.freeze([...nested, ...(draft.exclude ?? [])]),
+            version: draft.version ?? "tag",
+            scheme: draft.scheme ?? "semver",
+            tagFormat: draft.tagFormat ??
+                defaults?.tagFormat ??
+                (root === "." ? "v{version}" : "{id}-v{version}"),
+            propagate: draft.propagate ?? defaults?.propagate ?? "auto",
+            meta: Object.freeze(meta),
+        });
+    })
+        .sort((a, b) => compare(a.id, b.id));
+};

package/dist/errors.d.ts

@@ -0,0 +1,13 @@
+/** Fatal error with a stable `E_*` code. */
+export declare class TallyError extends Error {
+    readonly name = "TallyError";
+    readonly code: string;
+    readonly details: Readonly<Record<string, unknown>>;
+    constructor(code: string, message: string, details?: Record<string, unknown>);
+}
+/** Non-fatal finding with a stable `W_*` code. */
+export interface Warning {
+    code: string;
+    message: string;
+    plugin?: string;
+}

package/dist/errors.js

@@ -0,0 +1,11 @@
+/** Fatal error with a stable `E_*` code. */
+export class TallyError extends Error {
+    name = "TallyError";
+    code;
+    details;
+    constructor(code, message, details = {}) {
+        super(message);
+        this.code = code;
+        this.details = details;
+    }
+}

package/dist/graph.d.ts

@@ -0,0 +1,19 @@
+import type { Warning } from "./errors.js";
+import type { Edge, EdgeDraft, Unit } from "./plugin.js";
+/** Edge draft with its origin: a plugin name or `config`. */
+export interface SourcedEdge extends EdgeDraft {
+    source: string;
+}
+export interface Graph {
+    /** Deduplicated edges sorted by `from`, then `to`. */
+    readonly edges: readonly Edge[];
+    /** Unit id to the sorted ids of units depending on it. */
+    readonly dependents: ReadonlyMap<string, readonly string[]>;
+    /** Unit id to the sorted ids of units it depends on. */
+    readonly dependencies: ReadonlyMap<string, readonly string[]>;
+    /** Dependencies before dependents; members of a cycle by id. */
+    readonly order: readonly string[];
+    readonly warnings: readonly Warning[];
+}
+/** Validates and deduplicates edges, then derives adjacency and order. */
+export declare const buildGraph: (units: readonly Unit[], drafts: readonly SourcedEdge[]) => Graph;

package/dist/graph.js

@@ -0,0 +1,129 @@
+import { TallyError } from "./errors.js";
+import { compare, uniqueSorted } from "./util.js";
+/** Tarjan's algorithm; components are emitted after everything they reach. */
+const stronglyConnected = (ids, next) => {
+    const index = new Map();
+    const low = new Map();
+    const stack = [];
+    const onStack = new Set();
+    const components = [];
+    const visit = (v) => {
+        const own = index.size;
+        index.set(v, own);
+        low.set(v, own);
+        stack.push(v);
+        onStack.add(v);
+        for (const w of next.get(v) ?? []) {
+            if (!index.has(w)) {
+                visit(w);
+                low.set(v, Math.min(low.get(v) ?? own, low.get(w) ?? own));
+            }
+            else if (onStack.has(w)) {
+                low.set(v, Math.min(low.get(v) ?? own, index.get(w) ?? own));
+            }
+        }
+        if (low.get(v) === own) {
+            const component = [];
+            let w;
+            do {
+                w = stack.pop();
+                if (w !== undefined) {
+                    onStack.delete(w);
+                    component.push(w);
+                }
+            } while (w !== undefined && w !== v);
+            components.push(component.sort(compare));
+        }
+    };
+    for (const id of ids) {
+        if (!index.has(id)) {
+            visit(id);
+        }
+    }
+    return components;
+};
+/** Shortest cycle through the smallest member id, following dependents. */
+const cyclePath = (component, dependents) => {
+    const members = new Set(component);
+    const start = component[0] ?? "";
+    const parent = new Map();
+    const queue = [start];
+    for (const v of queue) {
+        for (const w of dependents.get(v) ?? []) {
+            if (w === start) {
+                const path = [];
+                for (let n = v; n !== undefined; n = parent.get(n)) {
+                    path.unshift(n);
+                }
+                return [...path, start];
+            }
+            if (members.has(w) && !parent.has(w)) {
+                parent.set(w, v);
+                queue.push(w);
+            }
+        }
+    }
+    return [start, start];
+};
+/** Validates and deduplicates edges, then derives adjacency and order. */
+export const buildGraph = (units, drafts) => {
+    const ids = units.map((u) => u.id).sort(compare);
+    const known = new Set(ids);
+    const merged = new Map();
+    for (const { from, to, reason, pinned, source } of drafts) {
+        for (const id of [from, to]) {
+            if (!known.has(id)) {
+                throw new TallyError("E_EDGE_UNKNOWN_UNIT", `edge ${from} -> ${to} from "${source}" names unknown unit "${id}"`, { from, to, source, unit: id });
+            }
+        }
+        if (from === to) {
+            throw new TallyError("E_EDGE_SELF", `edge ${from} -> ${to} from "${source}" points to itself`, { from, to, source });
+        }
+        const key = `${from}\n${to}`;
+        const edge = merged.get(key);
+        if (edge) {
+            edge.pinned ||= pinned;
+            edge.reasons.push(reason);
+            edge.sources.push(source);
+        }
+        else {
+            merged.set(key, {
+                from,
+                to,
+                reasons: [reason],
+                pinned,
+                sources: [source],
+            });
+        }
+    }
+    const edges = [...merged.values()]
+        .map((e) => ({
+        ...e,
+        reasons: uniqueSorted(e.reasons),
+        sources: uniqueSorted(e.sources),
+    }))
+        .sort((a, b) => compare(a.from, b.from) || compare(a.to, b.to));
+    const dependents = new Map(ids.map((id) => [id, []]));
+    const dependencies = new Map(ids.map((id) => [id, []]));
+    for (const { from, to } of edges) {
+        dependents.get(from)?.push(to);
+        dependencies.get(to)?.push(from);
+    }
+    for (const list of dependencies.values()) {
+        list.sort(compare);
+    }
+    const components = stronglyConnected(ids, dependencies);
+    const warnings = components
+        .filter((c) => c.length > 1)
+        .map((c) => ({
+        code: "W_CYCLE",
+        message: `dependency cycle: ${cyclePath(c, dependents).join(" -> ")}`,
+    }));
+    return {
+        edges,
+        dependents,
+        dependencies,
+        order: components.flat(),
+        warnings,
+    };
+};

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+export declare const version = "0.0.0";
+export type { AffectedDoc, AffectedOptions, AffectedReason, AffectedUnit, BaseSource, } from "./affected.js";
+export type { DepConfig, TallyConfig, UnitOverlay } from "./config.js";
+export type { Warning } from "./errors.js";
+export type { Graph, SourcedEdge } from "./graph.js";
+export type { BumpLevel, Change, Ctx, Edge, EdgeDraft, GitReader, IntentSource, MaybePromise, Plugin, PreCtx, Propagate, RawCommit, ReadonlyFs, TagRef, Unit, UnitDraft, VersionFile, VersionMode, VersionScheme, WriteCtx, } from "./plugin.js";
+export type { ActivePlugin, PluginEnv } from "./plugins.js";
+export type { Workspace, WorkspaceInput } from "./workspace.js";
+export { computeAffected } from "./affected.js";
+export { CONFIG_FILE } from "./config.js";
+export { discoverUnits } from "./discover.js";
+export { TallyError } from "./errors.js";
+export { buildGraph } from "./graph.js";
+export { definePlugin, defaultUnitId, PLUGIN_API_VERSION } from "./plugin.js";
+export { activatePlugins } from "./plugins.js";
+export { loadWorkspace } from "./workspace.js";

package/dist/index.js

@@ -0,0 +1,9 @@
+export const version = "0.0.0";
+export { computeAffected } from "./affected.js";
+export { CONFIG_FILE } from "./config.js";
+export { discoverUnits } from "./discover.js";
+export { TallyError } from "./errors.js";
+export { buildGraph } from "./graph.js";
+export { definePlugin, defaultUnitId, PLUGIN_API_VERSION } from "./plugin.js";
+export { activatePlugins } from "./plugins.js";
+export { loadWorkspace } from "./workspace.js";

package/dist/plugin.d.ts

@@ -0,0 +1,186 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+export type MaybePromise<T> = T | Promise<T>;
+export declare const PLUGIN_API_VERSION = 1;
+export interface Plugin<O = unknown> {
+    apiVersion: typeof PLUGIN_API_VERSION;
+    name: string;
+    /** Validates `plugins.<name>` minus core-owned keys (`globalInputs`). */
+    options?: StandardSchemaV1<unknown, O>;
+    discover?: (ctx: Ctx<O>) => MaybePromise<UnitDraft[]>;
+    edges?: (ctx: Ctx<O>, units: readonly Unit[]) => MaybePromise<EdgeDraft[]>;
+    /** Default global inputs of this plugin. */
+    inputs?: (ctx: Ctx<O>) => MaybePromise<{
+        global?: string[];
+    }>;
+    /** Called only for units owned by this plugin. */
+    versionFiles?: (ctx: Ctx<O>, unit: Unit) => MaybePromise<VersionFile[]>;
+    schemes?: Record<string, VersionScheme<any>>;
+    intent?: IntentSource<O>[];
+}
+export interface Ctx<O = unknown> {
+    readonly options: O;
+    readonly repo: {
+        readonly name: string;
+    };
+    readonly fs: ReadonlyFs;
+    /** Warnings land in the output document's `warnings`. */
+    readonly log: {
+        warn: (msg: string) => void;
+        debug: (msg: string) => void;
+    };
+}
+/** Read-only file access with repo-relative POSIX paths. */
+export interface ReadonlyFs {
+    /** UTF-8 content, undefined if missing. */
+    read: (path: string) => string | undefined;
+    exists: (path: string) => boolean;
+    /** Sorted matches; skips `.git`, `node_modules` and the top-level `vendor`. */
+    glob: (patterns: string[], opts?: {
+        dirs?: boolean;
+    }) => string[];
+}
+/** Read-only git access. */
+export interface GitReader {
+    /** All tags, peeled to commits. */
+    tags: () => MaybePromise<readonly TagRef[]>;
+    /** Tags reachable from `ref` (`git tag --merged`). */
+    tagsMerged: (ref: string) => MaybePromise<readonly TagRef[]>;
+    /** True if `a` is reachable from `b` (inclusive). */
+    isAncestor: (a: string, b: string) => MaybePromise<boolean>;
+    /** True if `a` is on the first-parent chain of `b` (inclusive). */
+    isFirstParentAncestor: (a: string, b: string) => MaybePromise<boolean>;
+    /** Commits in `from..to` without merges; files listed without rename detection. */
+    log: (from: string | null, to: string) => MaybePromise<readonly RawCommit[]>;
+    /** Commits on the first-parent chain of `to` not reachable from `from`. */
+    countFirstParent: (from: string | null, to: string) => MaybePromise<number>;
+    /** Tree-to-tree changed paths without rename detection, sorted. */
+    diffFiles: (from: string, to: string) => MaybePromise<readonly string[]>;
+}
+export interface TagRef {
+    name: string;
+    sha: string;
+}
+export interface RawCommit {
+    sha: string;
+    parents: string[];
+    message: string;
+    files: string[];
+    /** Committer date, ISO 8601. */
+    date: string;
+}
+export type Propagate = "auto" | "patch" | "rebuild";
+/** `file`: tags and version files; `tag`: tags only; `none`: build-only. */
+export type VersionMode = "file" | "tag" | "none";
+export interface UnitDraft {
+    id: string;
+    root: string;
+    include?: string[];
+    exclude?: string[];
+    version?: VersionMode;
+    scheme?: string;
+    tagFormat?: string;
+    propagate?: Propagate;
+    /** Stored at `unit.meta[plugin.name]`. */
+    meta?: Record<string, unknown>;
+}
+export interface Unit {
+    readonly id: string;
+    readonly root: string;
+    /** Owning plugin, `config` for config-only units. */
+    readonly plugin: string;
+    readonly include: readonly string[];
+    readonly exclude: readonly string[];
+    readonly version: VersionMode;
+    readonly scheme: string;
+    readonly tagFormat: string;
+    readonly propagate: Propagate;
+    readonly meta: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+}
+/** `to` depends on `from`. */
+export interface EdgeDraft {
+    from: string;
+    to: string;
+    reason: string;
+    /** True when `to`'s published manifest changes with `from`'s version. */
+    pinned: boolean;
+}
+export interface Edge {
+    from: string;
+    to: string;
+    reasons: string[];
+    pinned: boolean;
+    sources: string[];
+}
+export interface VersionFile {
+    path: string;
+    read: (content: string) => string | undefined;
+    write: (content: string, next: string, ctx: WriteCtx) => string;
+}
+export interface WriteCtx {
+    unit: Unit;
+    /** Unit id to version in the current plan. */
+    versions: ReadonlyMap<string, string>;
+}
+export type BumpLevel = "major" | "minor" | "patch";
+export interface VersionScheme<V> {
+    /** Undefined when `raw` is not a version of this scheme. */
+    parse: (raw: string) => V | undefined;
+    format: (v: V) => string;
+    compare: (a: V, b: V) => number;
+    core: (v: V) => {
+        major: number;
+        minor: number;
+        patch: number;
+    };
+    isPrerelease: (v: V) => boolean;
+    initial: () => V;
+    bump: (v: V, level: BumpLevel) => V;
+    release: (next: V, ctx: PreCtx) => V;
+    prerelease: (next: V, ctx: PreCtx & {
+        channel: string;
+    }) => V;
+}
+/** Git-derived data passed to a scheme. */
+export interface PreCtx {
+    unit: Unit;
+    /** Full sha of the planned commit. */
+    head: string;
+    baseTag: string | null;
+    /** All tags of this unit, reachable or not, scheme-sorted. */
+    tags: readonly string[];
+    firstParent: {
+        sinceLineBase: number;
+        total: number;
+    };
+}
+export interface IntentSource<O = unknown> {
+    name: string;
+    collect: (ctx: Ctx<O>, input: {
+        from: string | null;
+        to: string;
+        commits: readonly RawCommit[];
+    }) => MaybePromise<Change[]>;
+}
+export interface Change {
+    /** Commit-derived changes are attributed via that commit's files. */
+    sha?: string;
+    /** Explicit attribution. */
+    units?: string[];
+    type: string;
+    breaking: boolean;
+    scope?: string;
+    subject: string;
+    body?: string;
+    releaseAs?: string;
+    pr?: number;
+    date?: string;
+}
+/** Throws `E_PLUGIN_API` or `E_PLUGIN_NAME` for an unsupported plugin. */
+export declare const assertPlugin: (plugin: {
+    apiVersion: unknown;
+    name: unknown;
+}) => void;
+/** Validates name and API version, returns the plugin unchanged. */
+export declare const definePlugin: <O>(plugin: Plugin<O>) => Plugin<O>;
+/** `.` maps to the repo name, any other root to its last segment. */
+export declare const defaultUnitId: (root: string, repoName: string) => string;

package/dist/plugin.js

@@ -0,0 +1,20 @@
+import { TallyError } from "./errors.js";
+const PLUGIN_NAME = /^[a-z][a-z0-9-]*$/;
+export const PLUGIN_API_VERSION = 1;
+/** Throws `E_PLUGIN_API` or `E_PLUGIN_NAME` for an unsupported plugin. */
+export const assertPlugin = (plugin) => {
+    const name = String(plugin.name);
+    if (plugin.apiVersion !== PLUGIN_API_VERSION) {
+        throw new TallyError("E_PLUGIN_API", `plugin "${name}" uses API version ${String(plugin.apiVersion)}, supported is ${String(PLUGIN_API_VERSION)}`, { plugin: name, apiVersion: plugin.apiVersion });
+    }
+    if (typeof plugin.name !== "string" || !PLUGIN_NAME.test(plugin.name)) {
+        throw new TallyError("E_PLUGIN_NAME", `plugin name "${name}" must match ${PLUGIN_NAME.source}`, { plugin: name });
+    }
+};
+/** Validates name and API version, returns the plugin unchanged. */
+export const definePlugin = (plugin) => {
+    assertPlugin(plugin);
+    return plugin;
+};
+/** `.` maps to the repo name, any other root to its last segment. */
+export const defaultUnitId = (root, repoName) => root === "." ? repoName : (root.split("/").at(-1) ?? root);

package/dist/plugins.d.ts

@@ -0,0 +1,24 @@
+import type { TallyConfig } from "./config.js";
+import type { Warning } from "./errors.js";
+import type { Ctx, MaybePromise, Plugin, ReadonlyFs } from "./plugin.js";
+/** An enabled plugin with its validated options. */
+export interface ActivePlugin {
+    readonly plugin: Plugin;
+    readonly ctx: Ctx;
+    /** 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;
+}
+/** 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`. */
+export declare const runHook: <T>(plugin: string, hook: string, call: () => MaybePromise<T>) => Promise<T>;

package/dist/plugins.js

@@ -0,0 +1,48 @@
+import { TallyError } from "./errors.js";
+import { assertPlugin } from "./plugin.js";
+/** Resolves enabled plugins in config order and validates their options. */
+export const activatePlugins = async (env, warnings) => {
+    const active = [];
+    for (const [name, raw] of Object.entries(env.config.plugins)) {
+        const plugin = env.plugins.find((p) => p.name === name);
+        if (!plugin) {
+            throw new TallyError("E_PLUGIN_UNKNOWN", `unknown plugin "${name}"`, {
+                plugin: name,
+            });
+        }
+        assertPlugin(plugin);
+        const { globalInputs, ...rest } = raw ?? {};
+        let options = rest;
+        if (plugin.options) {
+            // eslint-disable-next-line no-await-in-loop -- plugins load sequentially in config order
+            const result = await plugin.options["~standard"].validate(rest);
+            if (result.issues) {
+                throw new TallyError("E_PLUGIN_OPTIONS", `invalid options for plugin "${name}": ${result.issues.map((i) => i.message).join("; ")}`, { plugin: name, issues: result.issues });
+            }
+            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}`),
+            }),
+        });
+        active.push({ plugin, ctx, globalInputs: globalInputs !== false });
+    }
+    return active;
+};
+/** Awaits a plugin hook, wrapping thrown errors as `E_PLUGIN_HOOK`. */
+export const runHook = async (plugin, hook, call) => {
+    try {
+        return await call();
+    }
+    catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        throw new TallyError("E_PLUGIN_HOOK", `plugin "${plugin}" failed in ${hook}: ${reason}`, { plugin, hook, error });
+    }
+};

package/dist/testing.d.ts

@@ -0,0 +1,53 @@
+import type { Ctx, GitReader, MaybePromise, ReadonlyFs } from "./plugin.js";
+/** In-memory `ReadonlyFs` over a path-to-content map. */
+export declare const memoryFs: (files: Record<string, string>) => ReadonlyFs;
+export interface MemoryCtxOptions<O> {
+    options?: O;
+    /** Defaults to `repo`. */
+    repo?: string;
+    files?: Record<string, string>;
+}
+/** Plugin `Ctx` over `memoryFs`; collects `log.warn` messages in `warnings`. */
+export declare const memoryCtx: <O = Record<string, never>>(opts?: MemoryCtxOptions<O>) => Ctx<O> & {
+    readonly warnings: string[];
+};
+export interface DagCommit {
+    id: string;
+    /** Defaults to the previous commit in the list, none for the first. */
+    parents?: string[];
+    message?: string;
+    /** Committer date, ISO 8601. */
+    date?: string;
+    /**
+     * Changes applied on top of the parents' tree; `null` deletes. A merge
+     * starts from a three-way merge of its parents (later parents win conflicts).
+     */
+    files?: Record<string, string | null>;
+}
+export interface DagTag {
+    name: string;
+    commit: string;
+    annotated?: boolean;
+}
+/** Commit graph in parent-before-child order. Commit ids double as shas. */
+export interface Dag {
+    commits: DagCommit[];
+    tags?: DagTag[];
+}
+export interface MemoryGit extends GitReader {
+    /** File contents at a commit id, tag name or `HEAD` (the last commit). */
+    tree: (ref: string) => Record<string, string>;
+}
+/** In-memory `GitReader` over a commit graph. */
+export declare const memoryGit: (dag: Dag) => MemoryGit;
+/** Builds a reader for `dag`; `sha` maps a commit id to the reader's sha. */
+export type ReaderFactory = (dag: Dag) => MaybePromise<{
+    git: GitReader;
+    sha: (id: string) => string;
+}>;
+/**
+ * Shared `GitReader` spec. Fixture: a - b - d - m - e - f on the first-parent
+ * chain, c branches from b and merges into m, d renames pkg/x.ts to pkg/y.ts,
+ * f adds a path with a quote, a tab and a non-ASCII character.
+ */
+export declare const gitReaderConformance: (makeReader: ReaderFactory) => void;

package/dist/testing.js

@@ -0,0 +1,267 @@
+import picomatch from "picomatch/posix.js";
+import { beforeAll, describe, expect, it } from "vitest";
+import { compare, uniqueSorted } from "./util.js";
+const SKIPPED = new Set([".git", "node_modules"]);
+const changed = (a, b) => uniqueSorted([...a.keys(), ...b.keys()]).filter((p) => a.get(p) !== b.get(p));
+/** Path git would C-quote without `-z`. */
+const ODD_PATH = 'odd/a "q"\tü.txt';
+const CONFORMANCE_DAG = {
+    commits: [
+        {
+            id: "a",
+            message: "chore: init",
+            date: "2024-01-01T10:00:00Z",
+            files: { "README.md": "a\n", "pkg/x.ts": "x\n", "lib/keep.ts": "k\n" },
+        },
+        { id: "b", message: "feat: b", files: { "README.md": "b\n" } },
+        { id: "c", message: "feat: side", files: { "side.txt": "side\n" } },
+        {
+            id: "d",
+            parents: ["b"],
+            message: "refactor: rename",
+            files: { "pkg/x.ts": null, "pkg/y.ts": "x\n" },
+        },
+        { id: "m", parents: ["d", "c"], message: "Merge side" },
+        {
+            id: "e",
+            message: "fix: e\n\nbody line",
+            date: "2024-01-02T12:30:00Z",
+            files: { "README.md": "e\n" },
+        },
+        { id: "f", message: "chore: odd", files: { [ODD_PATH]: "f\n" } },
+    ],
+    tags: [
+        { name: "v1", commit: "a" },
+        { name: "v2", commit: "b", annotated: true },
+        { name: "side", commit: "c" },
+    ],
+};
+/** In-memory `ReadonlyFs` over a path-to-content map. */
+export const memoryFs = (files) => {
+    const paths = Object.keys(files).sort(compare);
+    const dirs = uniqueSorted(paths.flatMap((p) => {
+        const parts = p.split("/");
+        return parts.slice(1).map((_, i) => parts.slice(0, i + 1).join("/"));
+    }));
+    const visible = (p) => {
+        const segments = p.split("/");
+        return segments[0] !== "vendor" && !segments.some((s) => SKIPPED.has(s));
+    };
+    return {
+        read: (path) => (Object.hasOwn(files, path) ? files[path] : undefined),
+        exists: (path) => path === "." || Object.hasOwn(files, path) || dirs.includes(path),
+        glob: (patterns, opts) => {
+            const match = picomatch(patterns, { dot: true });
+            return (opts?.dirs ? dirs : paths).filter((p) => visible(p) && match(p));
+        },
+    };
+};
+/** Plugin `Ctx` over `memoryFs`; collects `log.warn` messages in `warnings`. */
+export const memoryCtx = (opts = {}) => {
+    const warnings = [];
+    const options = opts.options ?? {};
+    return {
+        options: options,
+        repo: { name: opts.repo ?? "repo" },
+        fs: memoryFs(opts.files ?? {}),
+        log: { warn: (msg) => warnings.push(msg), debug: () => undefined },
+        warnings,
+    };
+};
+/** In-memory `GitReader` over a commit graph. */
+export const memoryGit = (dag) => {
+    const nodes = new Map();
+    const node = (ref) => {
+        const id = ref === "HEAD" ? dag.commits.at(-1)?.id : ref;
+        const found = nodes.get(id ?? "") ??
+            nodes.get(dag.tags?.find((t) => t.name === ref)?.commit ?? "");
+        if (!found) {
+            throw new Error(`unknown ref "${ref}"`);
+        }
+        return found;
+    };
+    const mergeBase = (a, b) => {
+        const common = [...a.ancestors].filter((id) => b.ancestors.has(id));
+        const best = common.find((id) => !common.some((o) => o !== id && node(o).ancestors.has(id)));
+        return best === undefined ? new Map() : node(best).tree;
+    };
+    dag.commits.forEach((c, i) => {
+        const prior = dag.commits[i - 1];
+        const parents = (c.parents ?? (prior ? [prior.id] : [])).map(node);
+        const [first, ...others] = parents;
+        const tree = new Map(first?.tree);
+        for (const other of others) {
+            const base = first ? mergeBase(first, other) : new Map();
+            for (const path of changed(base, other.tree)) {
+                const content = other.tree.get(path);
+                if (content === undefined) {
+                    tree.delete(path);
+                }
+                else {
+                    tree.set(path, content);
+                }
+            }
+        }
+        for (const [path, content] of Object.entries(c.files ?? {})) {
+            if (content === null) {
+                tree.delete(path);
+            }
+            else {
+                tree.set(path, content);
+            }
+        }
+        nodes.set(c.id, {
+            id: c.id,
+            parents: parents.map((p) => p.id),
+            message: c.message ?? c.id,
+            date: c.date ?? new Date(Date.UTC(2024, 0, 1, 0, i)).toISOString(),
+            tree,
+            ancestors: new Set([c.id, ...parents.flatMap((p) => [...p.ancestors])]),
+        });
+    });
+    const firstParentChain = (to) => {
+        const chain = [];
+        for (let n = node(to); n;) {
+            chain.push(n);
+            const parent = n.parents[0];
+            n = parent === undefined ? undefined : node(parent);
+        }
+        return chain;
+    };
+    const tagRefs = () => (dag.tags ?? [])
+        .map((t) => ({ name: t.name, sha: node(t.commit).id }))
+        .sort((a, b) => compare(a.name, b.name));
+    const excluded = (from) => from === null ? new Set() : node(from).ancestors;
+    return {
+        tags: tagRefs,
+        tagsMerged: (ref) => {
+            const reachable = node(ref).ancestors;
+            return tagRefs().filter((t) => reachable.has(t.sha));
+        },
+        isAncestor: (a, b) => node(b).ancestors.has(node(a).id),
+        isFirstParentAncestor: (a, b) => {
+            const id = node(a).id;
+            return firstParentChain(b).some((n) => n.id === id);
+        },
+        log: (from, to) => {
+            const skip = excluded(from);
+            const reachable = node(to).ancestors;
+            return dag.commits
+                .map((c) => node(c.id))
+                .filter((n) => reachable.has(n.id) && !skip.has(n.id))
+                .filter((n) => n.parents.length <= 1)
+                .reverse()
+                .map((n) => ({
+                sha: n.id,
+                parents: [...n.parents],
+                message: n.message,
+                files: changed(n.parents[0] === undefined ? new Map() : node(n.parents[0]).tree, n.tree),
+                date: n.date,
+            }));
+        },
+        countFirstParent: (from, to) => {
+            const skip = excluded(from);
+            return firstParentChain(to).filter((n) => !skip.has(n.id)).length;
+        },
+        diffFiles: (from, to) => changed(node(from).tree, node(to).tree),
+        tree: (ref) => Object.fromEntries(node(ref).tree),
+    };
+};
+/**
+ * Shared `GitReader` spec. Fixture: a - b - d - m - e - f on the first-parent
+ * chain, c branches from b and merges into m, d renames pkg/x.ts to pkg/y.ts,
+ * f adds a path with a quote, a tab and a non-ASCII character.
+ */
+export const gitReaderConformance = (makeReader) => {
+    describe("GitReader conformance", () => {
+        let git;
+        let sha;
+        const shas = (ids) => ids.map((id) => sha(id)).sort(compare);
+        const logShas = async (from, to) => (await git.log(from === null ? null : sha(from), sha(to)))
+            .map((c) => c.sha)
+            .sort(compare);
+        beforeAll(async () => {
+            ({ git, sha } = await makeReader(CONFORMANCE_DAG));
+        });
+        it("lists tags peeled to commits", async () => {
+            const tags = [...(await git.tags())].sort((x, y) => compare(x.name, y.name));
+            expect(tags).toEqual([
+                { name: "side", sha: sha("c") },
+                { name: "v1", sha: sha("a") },
+                { name: "v2", sha: sha("b") },
+            ]);
+        });
+        it("lists tags merged into a ref", async () => {
+            const names = async (id) => (await git.tagsMerged(sha(id))).map((t) => t.name).sort(compare);
+            expect(await names("d")).toEqual(["v1", "v2"]);
+            expect(await names("e")).toEqual(["side", "v1", "v2"]);
+        });
+        it("checks ancestry", async () => {
+            const check = (a, b) => git.isAncestor(sha(a), sha(b));
+            expect(await check("a", "e")).toBe(true);
+            expect(await check("c", "e")).toBe(true);
+            expect(await check("d", "d")).toBe(true);
+            expect(await check("e", "a")).toBe(false);
+            expect(await check("c", "d")).toBe(false);
+        });
+        it("checks first-parent ancestry", async () => {
+            const check = (a, b) => git.isFirstParentAncestor(sha(a), sha(b));
+            expect(await check("a", "e")).toBe(true);
+            expect(await check("d", "e")).toBe(true);
+            expect(await check("e", "e")).toBe(true);
+            expect(await check("c", "e")).toBe(false);
+        });
+        it("logs commits without merges", async () => {
+            expect(await logShas(null, "e")).toEqual(shas(["a", "b", "c", "d", "e"]));
+            expect(await logShas("b", "e")).toEqual(shas(["c", "d", "e"]));
+            expect(await logShas("d", "e")).toEqual(shas(["c", "e"]));
+            expect(await logShas("e", "e")).toEqual([]);
+        });
+        it("logs commit details with renames as delete plus add", async () => {
+            const commits = await git.log(null, sha("e"));
+            const byId = (id) => commits.find((c) => c.sha === sha(id));
+            expect(byId("a")).toMatchObject({
+                parents: [],
+                message: "chore: init",
+                files: ["README.md", "lib/keep.ts", "pkg/x.ts"],
+            });
+            expect(byId("d")).toMatchObject({
+                parents: [sha("b")],
+                message: "refactor: rename",
+                files: ["pkg/x.ts", "pkg/y.ts"],
+            });
+            expect(byId("e")).toMatchObject({
+                parents: [sha("m")],
+                message: "fix: e\n\nbody line",
+                files: ["README.md"],
+            });
+            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("counts first-parent commits", async () => {
+            const count = (from, to) => git.countFirstParent(from === null ? null : sha(from), sha(to));
+            expect(await count(null, "e")).toBe(5);
+            expect(await count("b", "e")).toBe(3);
+            expect(await count("c", "e")).toBe(3);
+            expect(await count("e", "e")).toBe(0);
+        });
+        it("diffs trees", async () => {
+            const diff = async (a, b) => await git.diffFiles(sha(a), sha(b));
+            expect(await diff("b", "e")).toEqual([
+                "README.md",
+                "pkg/x.ts",
+                "pkg/y.ts",
+                "side.txt",
+            ]);
+            expect(await diff("e", "b")).toEqual(await diff("b", "e"));
+            expect(await diff("d", "m")).toEqual(["side.txt"]);
+            expect(await diff("e", "e")).toEqual([]);
+        });
+        it("lists paths with quotes, tabs and non-ASCII characters verbatim", async () => {
+            expect(await git.diffFiles(sha("e"), sha("f"))).toEqual([ODD_PATH]);
+            expect((await git.log(sha("e"), sha("f"))).map((c) => c.files)).toEqual([
+                [ODD_PATH],
+            ]);
+        });
+    });
+};

package/dist/util.d.ts

@@ -0,0 +1,4 @@
+/** Code-unit string order, independent of locale. */
+export declare const compare: (a: string, b: string) => number;
+/** Sorted distinct values. */
+export declare const uniqueSorted: (values: Iterable<string>) => string[];

package/dist/util.js

@@ -0,0 +1,4 @@
+/** Code-unit string order, independent of locale. */
+export const compare = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+/** Sorted distinct values. */
+export const uniqueSorted = (values) => [...new Set(values)].sort(compare);

package/dist/workspace.d.ts

@@ -0,0 +1,21 @@
+import type { Warning } from "./errors.js";
+import type { Graph } from "./graph.js";
+import type { Unit } from "./plugin.js";
+import type { PluginEnv } from "./plugins.js";
+export interface WorkspaceInput extends PluginEnv {
+    /** Repo-relative config file path, a global input; defaults to `CONFIG_FILE`. */
+    configFile?: string;
+}
+/** Units, graph and path rules of a repo at one commit. */
+export interface Workspace {
+    readonly repo: string;
+    /** Sorted by id. */
+    readonly units: readonly Unit[];
+    readonly graph: Graph;
+    /** Sorted globs. */
+    readonly globalInputs: readonly string[];
+    readonly ignore: readonly string[];
+    readonly warnings: readonly Warning[];
+}
+/** Runs plugin hooks sequentially in config order and builds the graph. */
+export declare const loadWorkspace: (input: WorkspaceInput) => Promise<Workspace>;

package/dist/workspace.js

@@ -0,0 +1,57 @@
+import { CONFIG_FILE } from "./config.js";
+import { discoverUnits } from "./discover.js";
+import { buildGraph } from "./graph.js";
+import { activatePlugins, runHook } from "./plugins.js";
+import { uniqueSorted } from "./util.js";
+const collectEdges = async (active, config, units) => {
+    const edges = [];
+    const frozen = Object.freeze([...units]);
+    for (const { plugin, ctx } of active) {
+        const hook = plugin.edges?.bind(plugin);
+        if (!hook) {
+            continue;
+        }
+        // eslint-disable-next-line no-await-in-loop -- hooks run sequentially in config order
+        const drafts = await runHook(plugin.name, "edges", () => hook(ctx, frozen));
+        edges.push(...drafts.map((d) => ({ ...d, source: plugin.name })));
+    }
+    for (const { from, to, pinned, reason } of config.deps ?? []) {
+        edges.push({
+            from,
+            to,
+            pinned: pinned ?? false,
+            reason: reason ?? "config",
+            source: "config",
+        });
+    }
+    return edges;
+};
+const collectGlobalInputs = async (active, config, configFile) => {
+    const globs = [configFile, ...(config.globalInputs ?? [])];
+    for (const { plugin, ctx, globalInputs } of active) {
+        const hook = plugin.inputs?.bind(plugin);
+        if (!hook || !globalInputs) {
+            continue;
+        }
+        // eslint-disable-next-line no-await-in-loop -- hooks run sequentially in config order
+        const inputs = await runHook(plugin.name, "inputs", () => hook(ctx));
+        globs.push(...(inputs.global ?? []));
+    }
+    return uniqueSorted(globs);
+};
+/** Runs plugin hooks sequentially in config order and builds the graph. */
+export const loadWorkspace = async (input) => {
+    const warnings = [];
+    const active = await activatePlugins(input, warnings);
+    const units = await discoverUnits(active, input);
+    const graph = buildGraph(units, await collectEdges(active, input.config, units));
+    const globalInputs = await collectGlobalInputs(active, input.config, input.configFile ?? CONFIG_FILE);
+    return {
+        repo: input.repo.name,
+        units,
+        graph,
+        globalInputs,
+        ignore: input.config.ignore ?? [],
+        warnings: [...warnings, ...graph.warnings],
+    };
+};

package/package.json

@@ -1,6 +1,94 @@
 {
   "name": "@tallyrelease/core",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.0.0",
+  "description": "Pure planning core of tallyrelease",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/abinnovision/tally-release.git",
+    "directory": "packages/core"
+  },
+  "license": "Apache-2.0",
+  "author": {
+    "name": "abi group GmbH",
+    "email": "info@abigroup.io",
+    "url": "https://abigroup.io"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./testing": {
+      "types": "./dist/testing.d.ts",
+      "import": "./dist/testing.js",
+      "default": "./dist/testing.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc --build tsconfig.build.json",
+    "check:purity": "node scripts/check-purity.mjs src/index.ts",
+    "format:check": "prettier --check '{{src,test}/**/*,*}.{{t,j}s{,x},json{,5},md,y{,a}ml,css,html,gql,graphql}'",
+    "format:fix": "prettier --write '{{src,test}/**/*,*}.{{t,j}s{,x},json{,5},md,y{,a}ml,css,html,gql,graphql}'",
+    "lint:check": "eslint '{{src,test}/**/*,*}.{t,j}s{,x}'",
+    "lint:fix": "eslint '{{src,test}/**/*,*}.{t,j}s{,x}' --fix",
+    "test-unit": "vitest --passWithNoTests --run --coverage --config vitest.config.ts --project='*#unit'",
+    "test-unit:watch": "vitest --passWithNoTests --config vitest.config.ts --project='*#unit'",
+    "typecheck": "tsc -p tsconfig.json"
+  },
+  "lint-staged": {
+    "{{src,test}/**/*,*}.{{t,j}s{,x},json{,5},md,y{,a}ml,css,html,gql,graphql}": "prettier --write",
+    "{{src,test}/**/*,*}.{t,j}s{,x}": "eslint --fix"
+  },
+  "prettier": "@abinnovision/prettier-config",
+  "dependencies": {
+    "@standard-schema/spec": "^1.1.0",
+    "picomatch": "^4.0.7"
+  },
+  "devDependencies": {
+    "@abinnovision/eslint-config-base": "^3.4.2",
+    "@abinnovision/prettier-config": "^2.2.0",
+    "@internal/tsconfig": "0.0.0",
+    "@types/node": "^24.0.0",
+    "@types/picomatch": "^4.0.3",
+    "@vitest/coverage-v8": "^5.0.3",
+    "esbuild": "^0.25.0",
+    "eslint": "^10.12.0",
+    "prettier": "^3.9.9",
+    "typescript": "^6.0.3",
+    "vite": "^8.3.4",
+    "vitest": "^5.0.3",
+    "yaml": "^2.9.1"
+  },
+  "peerDependencies": {
+    "vitest": "^5.0.3"
+  },
+  "peerDependenciesMeta": {
+    "vitest": {
+      "optional": true
+    }
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "publishConfig": {
+    "access": "public",
+    "exports": {
+      ".": {
+        "types": "./dist/index.d.ts",
+        "import": "./dist/index.js",
+        "default": "./dist/index.js"
+      },
+      "./testing": {
+        "types": "./dist/testing.d.ts",
+        "import": "./dist/testing.js",
+        "default": "./dist/testing.js"
+      }
+    },
+    "npm": true
+  }
 }

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.