tegami 0.1.0 → 0.1.3

package/dist/plugins/git.js

@@ -1,4 +1,4 @@
-import { t as execFailure } from "../error-DBK-9uBa.js";
+import { n as execFailure } from "../error-qpTCB2ld.js";
 import { t as isCI } from "../constants-B9qjNfvr.js";
 import { x } from "tinyexec";
 //#region src/plugins/git.ts
@@ -13,8 +13,7 @@ function git(options = {}) {
 	function resolveGitTag(context, result) {
 		const { graph } = context;
 		const pkg = graph.get(result.id);
-		if (!pkg) return `${result.name}@${result.version}`;
-		const group = graph.getPackageGroup(pkg.id);
+		const group = pkg && graph.getPackageGroup(pkg.id);
 		if (group?.options.syncGitTag) return `${group.name}@${result.version}`;
 		return `${result.name}@${result.version}`;
 	}
@@ -39,9 +38,10 @@ function git(options = {}) {
 		} },
 		async afterPublishAll(result) {
 			const { cwd, publishOptions: { dryRun = false } } = this;
-			if (dryRun || !createTags || result.state !== "created") return result;
+			if (dryRun || !createTags || result.state === "skipped") return result;
 			const pendingTags = /* @__PURE__ */ new Set();
 			for (const pkg of result.packages) {
+				if (pkg.state !== "success") continue;
 				pkg.gitTag = resolveGitTag(this, pkg);
 				pendingTags.add(pkg.gitTag);
 			}

package/dist/plugins/github.d.ts

@@ -1,4 +1,4 @@
-import { O as DraftPlan, s as TegamiPlugin, t as Awaitable, w as TegamiContext, x as PackagePublishResult } from "../types-UjsZkz42.js";
+import { S as PackagePublishResult, T as TegamiContext, c as TegamiPlugin, k as DraftPlan, t as Awaitable } from "../types-Di--A9X1.js";
 import { GitPluginOptions } from "./git.js";
 
 //#region src/plugins/github.d.ts
@@ -42,6 +42,12 @@ interface GitHubPluginOptions extends GitPluginOptions {
   repo?: string;
   /** Optional GitHub token for Git & GitHub operations. */
   token?: string;
+  /**
+   * Create GitHub release immediately after successful publish, without waiting for others.
+   *
+   * @default false
+   */
+  eagerRelease?: boolean;
   /** Override release details for a single package, return `false` to skip. */
   onCreateRelease?: (this: TegamiContext, result: PackagePublishResult) => Awaitable<GithubRelease | false>;
   /** Override release details when multiple packages share a git tag, return `false` to skip. */

package/dist/plugins/github.js

@@ -1,5 +1,5 @@
-import { t as execFailure } from "../error-DBK-9uBa.js";
-import { n as formatNpmDistTag, r as formatPackageVersion } from "../semver-mWK2Khi2.js";
+import { i as formatPackageVersion, r as formatNpmDistTag } from "../semver-cnZp9koa.js";
+import { n as execFailure } from "../error-qpTCB2ld.js";
 import { t as isCI } from "../constants-B9qjNfvr.js";
 import { git } from "./git.js";
 import { join, relative } from "node:path";
@@ -8,7 +8,8 @@ import { prerelease } from "semver";
 //#region src/plugins/github.ts
 /** Create GitHub releases for successfully published packages after the whole plan succeeds. */
 function github(options = {}) {
-	async function runGithubRelease(gitTag, title, notes, prerelease) {
+	const { eagerRelease = false, onCreateGroupedRelease, onCreateRelease, onCreateVersionPullRequest, cli: cliOptions = {} } = options;
+	async function runGithubRelease(gitTag, title, notes, prerelease, repo) {
 		const args = [
 			"release",
 			"create",
@@ -18,26 +19,27 @@ function github(options = {}) {
 			"--notes",
 			notes
 		];
-		if (options.repo) args.push("--repo", options.repo);
+		if (repo) args.push("--repo", repo);
 		if (prerelease) args.push("--prerelease");
 		const result = await x("gh", args);
 		if (result.exitCode !== 0) throw execFailure(`Failed to create GitHub release for ${gitTag}.`, result);
 	}
 	async function createRelease(context, pkg) {
-		if (!pkg.gitTag) return;
-		const release = await options.onCreateRelease?.call(context, pkg) ?? {};
+		if (!pkg.gitTag || pkg.state === "failed") return;
+		const release = await onCreateRelease?.call(context, pkg) ?? {};
 		if (release === false) return;
-		await runGithubRelease(pkg.gitTag, release.title ?? defaultTitle(pkg), release.notes ?? await defaultNotes(context, pkg), release.prerelease ?? prerelease(pkg.version) !== null);
+		await runGithubRelease(pkg.gitTag, release.title ?? defaultTitle(pkg), release.notes ?? await defaultNotes(context, pkg), release.prerelease ?? prerelease(pkg.version) !== null, context.github?.repo);
 	}
 	async function createGroupedRelease(context, packages) {
 		const primary = packages[0];
 		if (!primary?.gitTag) return;
-		const release = await options.onCreateGroupedRelease?.call(context, packages) ?? {};
+		if (packages.some((member) => member.state === "failed")) return;
+		const release = await onCreateGroupedRelease?.call(context, packages) ?? {};
 		if (release === false) return;
-		await runGithubRelease(primary.gitTag, release.title ?? defaultGroupedTitle(packages), release.notes ?? await defaultGroupedNotes(context, packages), release.prerelease ?? packages.some((pkg) => prerelease(pkg.version) !== null));
+		await runGithubRelease(primary.gitTag, release.title ?? defaultGroupedTitle(packages), release.notes ?? await defaultGroupedNotes(context, packages), release.prerelease ?? packages.some((pkg) => prerelease(pkg.version) !== null), context.github?.repo);
 	}
 	function resolvePROptions() {
-		const setting = options.cli?.versionPr ?? isCI();
+		const setting = cliOptions.versionPr ?? isCI();
 		if (setting === false) return [false];
 		if (setting === true) return [true, {}];
 		if (setting.forceCreate || isCI()) return [true, setting];
@@ -77,24 +79,21 @@ function github(options = {}) {
 	return [git(options), {
 		name: "github",
 		init() {
-			const repository = options.repo ?? process.env.GITHUB_REPOSITORY;
-			const token = options.token ?? process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN;
 			this.github = {
-				repo: repository,
-				token
+				repo: options.repo ?? process.env.GITHUB_REPOSITORY,
+				token: options.token ?? process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN
 			};
 		},
 		cli: {
 			async init() {
 				if (!isCI()) return;
-				const repository = this.github?.repo;
-				const token = this.github?.token;
-				if (!token || !repository) return;
+				const { repo, token } = this.github ?? {};
+				if (!token || !repo) return;
 				const result = await x("git", [
 					"remote",
 					"set-url",
 					"origin",
-					`https://x-access-token:${token}@github.com/${repository}.git`
+					`https://x-access-token:${token}@github.com/${repo}.git`
 				], { nodeOptions: { cwd: this.cwd } });
 				if (result.exitCode !== 0) throw execFailure("Failed to configure git remote for GitHub Actions.", result);
 			},
@@ -104,9 +103,10 @@ function github(options = {}) {
 			async publishPlanApplied(draft) {
 				const { cwd } = this;
 				const [enabled, config] = resolvePROptions();
+				const repo = this.github?.repo;
 				if (!enabled || !await hasGitChanges(cwd)) return;
 				const { branch = "tegami/version-packages", base = "main" } = config;
-				const basePR = await options.onCreateVersionPullRequest?.call(this, draft);
+				const basePR = await onCreateVersionPullRequest?.call(this, draft);
 				if (basePR === false) return;
 				const pr = {
 					title: basePR?.title ?? "Version Packages",
@@ -135,7 +135,7 @@ function github(options = {}) {
 					branch
 				], gitOptions);
 				if (result.exitCode !== 0) throw execFailure("Failed to push the version branch to origin. Ensure `origin` is configured and you have push access.", result);
-				const openPr = await findOpenPullRequest(branch, options.repo);
+				const openPr = await findOpenPullRequest(branch, repo);
 				if (openPr !== void 0) {
 					const editArgs = [
 						"pr",
@@ -146,7 +146,7 @@ function github(options = {}) {
 						"--body",
 						pr.body
 					];
-					if (options.repo) editArgs.push("--repo", options.repo);
+					if (repo) editArgs.push("--repo", repo);
 					const editResult = await x("gh", editArgs);
 					if (editResult.exitCode !== 0) throw execFailure("Failed to update the version pull request.", editResult);
 					return;
@@ -163,13 +163,14 @@ function github(options = {}) {
 					"--base",
 					base
 				];
-				if (options.repo) args.push("--repo", options.repo);
+				if (repo) args.push("--repo", repo);
 				const prResult = await x("gh", args);
 				if (prResult.exitCode !== 0) throw execFailure("Failed to create the version pull request.", prResult);
 			}
 		},
 		async afterPublishAll(result) {
-			if (result.state !== "created") return;
+			if (!eagerRelease && result.state === "failed") return;
+			if (result.state === "skipped") return;
 			for (const packages of groupPackagesByGitTag(result.packages).values()) if (packages.length > 1) await createGroupedRelease(this, packages);
 			else await createRelease(this, packages[0]);
 		}

package/dist/providers/cargo.d.ts

@@ -1,2 +1,2 @@
-import { d as CargoRegistryClient, f as cargo, l as CargoPackage, u as CargoPluginOptions } from "../types-UjsZkz42.js";
+import { d as CargoPluginOptions, f as CargoRegistryClient, p as cargo, u as CargoPackage } from "../types-Di--A9X1.js";
 export { CargoPackage, CargoPluginOptions, CargoRegistryClient, cargo };

package/dist/providers/cargo.js

@@ -1,10 +1,10 @@
-import { r as isNodeError } from "../error-DBK-9uBa.js";
-import { n as WorkspacePackage } from "../graph-CUgwuRW5.js";
+import { i as isNodeError, n as execFailure } from "../error-qpTCB2ld.js";
+import { n as WorkspacePackage } from "../graph-hBQUWKQA.js";
 import { readFile, writeFile } from "node:fs/promises";
 import { join, normalize } from "node:path";
 import { x } from "tinyexec";
-import initToml, { edit, parse } from "@rainbowatcher/toml-edit-js";
 import * as semver from "semver";
+import initToml, { edit, parse as parse$1 } from "@rainbowatcher/toml-edit-js";
 import { glob } from "tinyglobby";
 //#region src/providers/cargo.ts
 const DEP_FIELDS = [
@@ -31,8 +31,8 @@ var CargoPackage = class extends WorkspacePackage {
 	get version() {
 		return stringValue(this.packageInfo.version) ?? this.workspaceVersion ?? "0.0.0";
 	}
-	onPlan(context) {
-		const defaults = super.onPlan(context);
+	initPlan() {
+		const defaults = super.initPlan();
 		defaults.publish ??= this.packageInfo.publish !== false;
 		return defaults;
 	}
@@ -55,9 +55,12 @@ var CargoPackage = class extends WorkspacePackage {
 	}
 };
 var CargoRegistryClient = class {
+	graph;
 	id = "cargo";
 	#versionMap = /* @__PURE__ */ new Map();
-	constructor(_graph) {}
+	constructor(graph) {
+		this.graph = graph;
+	}
 	supports(pkg) {
 		return pkg instanceof CargoPackage;
 	}
@@ -74,14 +77,24 @@ var CargoRegistryClient = class {
 		}
 		return info;
 	}
-	async publish(pkg) {
-		await x("cargo", ["publish"], {
-			nodeOptions: { cwd: pkg.path },
-			throwOnError: true
-		});
+	publishPreflight(pkg, { store }) {
+		const wait = [];
+		for (const { table } of dependencyTables(pkg.manifest, "")) for (const [rawName, rawSpec] of Object.entries(table)) {
+			if (!isTableValue(rawSpec) || typeof rawSpec.path !== "string") continue;
+			const id = `cargo:${stringValue(rawSpec.package) ?? rawName}`;
+			if (!store.packages[id]?.publish) continue;
+			const linked = this.graph.get(id);
+			if (!linked || !(linked instanceof CargoPackage)) continue;
+			wait.push(id);
+		}
+		return { wait };
+	}
+	async publish(pkg, _env) {
+		const result = await x("cargo", ["publish"], { nodeOptions: { cwd: pkg.path } });
+		if (result.exitCode !== 0) throw execFailure(`Failed to publish ${pkg.name}@${pkg.version}.`, result);
 	}
 };
-function cargo({ bumpDep: getBumpDepType = ({ kind }) => {
+function cargo({ updateLockFile = false, bumpDep: getBumpDepType = ({ kind }) => {
 	switch (kind) {
 		case "dependencies": return "patch";
 		case "build-dependencies":
@@ -159,7 +172,12 @@ function cargo({ bumpDep: getBumpDepType = ({ kind }) => {
 				writes.push(pkg.write());
 			}
 			await Promise.all(writes);
-		}
+		},
+		cli: { async publishPlanApplied() {
+			if (!updateLockFile) return;
+			const result = await x("cargo", ["update", "--workspace"], { nodeOptions: { cwd: this.cwd } });
+			if (result.exitCode !== 0) throw execFailure("Failed to update Cargo lock file", result);
+		} }
 	};
 }
 async function discoverCargoPackages(cwd, add) {
@@ -249,7 +267,7 @@ function parseSpec(v) {
 async function readCargoManifest(path) {
 	const content = await readFile(join(path, "Cargo.toml"), "utf8");
 	return {
-		manifest: parse(content),
+		manifest: parse$1(content),
 		content
 	};
 }

package/dist/providers/npm.d.ts

@@ -1,2 +1,2 @@
-import { g as npm, h as NpmRegistryClient, m as NpmPluginOptions, p as NpmPackage } from "../types-UjsZkz42.js";
+import { _ as npm, g as NpmRegistryClient, h as NpmPluginOptions, m as NpmPackage } from "../types-Di--A9X1.js";
 export { NpmPackage, NpmPluginOptions, NpmRegistryClient, npm };

package/dist/providers/npm.js

@@ -1,12 +1,12 @@
-import { r as isNodeError, t as execFailure } from "../error-DBK-9uBa.js";
-import { n as WorkspacePackage } from "../graph-CUgwuRW5.js";
+import { i as isNodeError, n as execFailure } from "../error-qpTCB2ld.js";
 import { i as pnpmWorkspaceSchema, r as packageManifestSchema } from "../schemas-CurBAaW5.js";
+import { n as WorkspacePackage } from "../graph-hBQUWKQA.js";
 import { readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { x } from "tinyexec";
 import * as semver from "semver";
-import { glob } from "tinyglobby";
 import { load } from "js-yaml";
+import { glob } from "tinyglobby";
 import { detect } from "package-manager-detector";
 //#region src/providers/npm.ts
 const DEP_FIELDS = [
@@ -33,8 +33,8 @@ var NpmPackage = class extends WorkspacePackage {
 	async write() {
 		await writeFile(path.join(this.path, "package.json"), `${JSON.stringify(this.manifest, null, 2)}\n`);
 	}
-	onPlan(context) {
-		const defaults = super.onPlan(context);
+	initPlan() {
+		const defaults = super.initPlan();
 		defaults.publish ??= this.manifest.private !== true;
 		if (this.manifest.publishConfig?.tag) {
 			defaults.npm ??= {};
@@ -70,9 +70,8 @@ var NpmRegistryClient = class {
 				if (registry) args.push("--registry", registry);
 				const result = await x(this.client === "pnpm" ? "pnpm" : "npm", args, { nodeOptions: { cwd: this.cwd } });
 				if (result.exitCode === 0) return true;
-				const output = commandOutput(result);
-				if (isMissingRegistryEntry(output)) return false;
-				throw new Error(`Unable to validate ${pkg.name}@${pkg.version} against the npm registry${registry ? ` "${registry}"` : ""}: ${output.trim() || `command exited with code ${result.exitCode}`}`);
+				if (isMissingRegistryEntry(result.stderr) || isMissingRegistryEntry(result.stdout)) return false;
+				throw execFailure(`Unable to validate ${pkg.name}@${pkg.version} against the npm registry${registry ? ` "${registry}"` : ""}.`, result);
 			};
 			info = run();
 			this.#versionMap.set(cacheKey, info);
@@ -80,18 +79,34 @@ var NpmRegistryClient = class {
 		return info;
 	}
 	async publish(pkg, { packageStore }) {
-		const args = ["publish"];
 		const distTag = packageStore.npm?.distTag;
+		if (this.client === "bun") {
+			const tarball = "pkg.tgz";
+			const packResult = await x("bun", [
+				"pm",
+				"pack",
+				"--filename",
+				tarball
+			], { nodeOptions: { cwd: pkg.path } });
+			if (packResult.exitCode !== 0) throw execFailure(`Failed to pack ${pkg.name}@${pkg.version}.`, packResult);
+			const publishArgs = ["publish", tarball];
+			if (distTag) publishArgs.push("--tag", distTag);
+			const publishResult = await x("npm", publishArgs, { nodeOptions: { cwd: pkg.path } });
+			if (publishResult.exitCode !== 0) throw execFailure(`Failed to publish ${pkg.name}@${pkg.version}${distTag ? ` with dist-tag "${distTag}"` : ""}.`, publishResult);
+			return;
+		}
+		const args = ["publish"];
 		if (distTag) args.push("--tag", distTag);
-		const client = this.client === "pnpm" ? "pnpm" : "npm";
-		if (client === "pnpm") args.push("--no-git-checks");
+		let client;
+		if (this.client === "pnpm") {
+			client = "pnpm";
+			args.push("--no-git-checks");
+		} else if (this.client === "yarn") client = "yarn";
+		else client = "npm";
 		const result = await x(client, args, { nodeOptions: { cwd: pkg.path } });
 		if (result.exitCode !== 0) throw execFailure(`Failed to publish ${pkg.name}@${pkg.version}${distTag ? ` with dist-tag "${distTag}"` : ""}.`, result);
 	}
 };
-function commandOutput(result) {
-	return [result.stdout, result.stderr].filter(Boolean).join("\n");
-}
 function isMissingRegistryEntry(output) {
 	const normalized = output.toLowerCase();
 	return normalized.includes("e404") || normalized.includes("404") || normalized.includes("no match") || normalized.includes("no matching version") || normalized.includes("not found");
@@ -200,8 +215,7 @@ function npm({ client: defaultClient, onBreakPeerDep = "set", updateLockFile = f
 				client = defaultClient;
 				return;
 			}
-			if ((await detect({ cwd: this.cwd }))?.name === "pnpm") client = "pnpm";
-			else client = "npm";
+			client = (await detect({ cwd: this.cwd }))?.name ?? "npm";
 		},
 		async resolve() {
 			await discoverNpmPackages(this.cwd, (pkg) => this.graph.add(pkg));
@@ -253,6 +267,7 @@ function npm({ client: defaultClient, onBreakPeerDep = "set", updateLockFile = f
 			let args;
 			if (client === "npm") args = ["ci"];
 			else if (client === "yarn") args = ["install", "--immutable"];
+			else if (client === "bun") args = ["install", "--frozen-lockfile"];
 			else args = ["install", "--frozen-lockfile"];
 			const result = await x(client, args, { nodeOptions: { cwd: this.cwd } });
 			if (result.exitCode !== 0) throw execFailure("Failed to update lockfile.", result);
@@ -273,9 +288,9 @@ async function discoverNpmPackages(cwd, add) {
 		path,
 		manifest
 	})).catch(() => void 0)));
-	if (rootManifest) add(new NpmPackage(cwd, rootManifest));
+	if (rootManifest?.version) add(new NpmPackage(cwd, rootManifest));
 	for (const entry of manifests) {
-		if (!entry?.manifest) continue;
+		if (!entry?.manifest.version) continue;
 		add(new NpmPackage(entry.path, entry.manifest));
 	}
 }

package/dist/{semver-mWK2Khi2.js → semver-cnZp9koa.js}

@@ -11,6 +11,11 @@ const WEIGHTS = {
 	minor: 2,
 	patch: 1
 };
+const DEPTH = {
+	major: 1,
+	minor: 2,
+	patch: 3
+};
 const PRE = {
 	major: "premajor",
 	minor: "preminor",
@@ -20,14 +25,20 @@ function maxBump(a, b) {
 	if (WEIGHTS[a] > WEIGHTS[b]) return a;
 	return b;
 }
+function bumpDepth(type) {
+	return DEPTH[type];
+}
 function bumpVersion(version, type, prerelease) {
 	let next = version;
-	if (prerelease) {
-		if (parse(version)?.prerelease[0] === prerelease) next = inc(version, "prerelease", prerelease);
-		else if (type) next = inc(version, PRE[type], prerelease);
-	} else if (type) next = inc(version, type);
+	const parsed = parse(version);
+	if (!parsed) next = null;
+	else if (prerelease) {
+		if (parsed.prerelease[0] === prerelease) next = inc(parsed, "prerelease", prerelease);
+		else if (type) next = inc(parsed, PRE[type], prerelease);
+	} else if (type) next = inc(parsed, type);
+	else if (parsed.prerelease.length > 0) next = inc(parsed, "release");
 	if (!next) throw new Error(`Invalid semver version: ${version}`);
 	return next;
 }
 //#endregion
-export { maxBump as i, formatNpmDistTag as n, formatPackageVersion as r, bumpVersion as t };
+export { maxBump as a, formatPackageVersion as i, bumpVersion as n, formatNpmDistTag as r, bumpDepth as t };

package/dist/{types-UjsZkz42.d.ts → types-Di--A9X1.d.ts}

@@ -4,19 +4,31 @@ import { AgentName } from "package-manager-detector";
 //#region src/utils/semver.d.ts
 type BumpType = "major" | "minor" | "patch";
 //#endregion
+//#region src/changelog/shared.d.ts
+declare const changelogPackageConfigSchema: z$1.ZodObject<{
+  type: z$1.ZodOptional<z$1.ZodEnum<{
+    major: "major";
+    minor: "minor";
+    patch: "patch";
+  }>>;
+  replay: z$1.ZodOptional<z$1.ZodArray<z$1.ZodString>>;
+}, z$1.core.$strip>;
+type ChangelogPackageConfig = z$1.output<typeof changelogPackageConfigSchema>;
+//#endregion
 //#region src/changelog/parse.d.ts
 interface ChangelogEntry {
   id: string;
   /** file name like `my-change.md` */
   filename: string;
   subject?: string;
-  packages: Map<string, BumpType>;
+  packages: Map<string, ChangelogPackageConfig>;
   /** will not be empty */
   sections: {
     depth: number;
     title: string;
     content: string;
   }[];
+  getRawContent: () => string;
 }
 //#endregion
 //#region src/plans/draft.d.ts
@@ -48,17 +60,20 @@ declare class DraftPlan {
     type: BumpType;
     reason?: string;
   }): PackagePlan;
+  dispatchPackage(pkg: WorkspacePackage, dispatch: (plan: PackagePlan) => void, onUpdate?: (plan: PackagePlan) => void): PackagePlan;
+  private getOrInitPackage;
   hasPending(): boolean;
   getChangelogs(): ChangelogEntry[];
   getChangelog(id: string): ChangelogEntry | undefined;
   addChangelog(entry: ChangelogEntry): void;
   deleteChangelog(id: string): boolean;
-  private initPackagePlan;
   /** Apply the publish plan: update package versions, write the plan file, and consume changelog files. */
   applyPlan(): Promise<void>;
   addPolicy(policy: PlanPolicy): void;
   removePolicy(policy: PlanPolicy): void;
   canApply(): boolean;
+  /** Attach replaying changelog entries to packages (already bumped), and return the updated changelog entries. */
+  private applyReplays;
   private appendChangelog;
   /** {@link applyPlan} but for `await using` syntax */
   [Symbol.asyncDispose](): Promise<void>;
@@ -89,8 +104,10 @@ declare abstract class WorkspacePackage {
   /** note: this will only be available after package graph is resolved */
   getPackageOptions(): PackageOptions;
   setPackageOptions(options: PackageOptions): void;
-  /** create an empty draft plan. */
-  onPlan(_context: TegamiContext): PackagePlan;
+  /** create the initial draft plan. */
+  initPlan(): PackagePlan;
+  /** configure an initial draft plan to match script-level configs. */
+  configurePlan(plan: PackagePlan): void;
 }
 interface PackageGroup {
   name: string;
@@ -160,17 +177,7 @@ declare const planStoreSchema: z$1.ZodCodec<z$1.ZodString, z$1.ZodObject<{
   version: z$1.ZodDefault<z$1.ZodLiteral<"0.0.0">>;
   changelogs: z$1.ZodRecord<z$1.ZodString, z$1.ZodObject<{
     filename: z$1.ZodString;
-    subject: z$1.ZodOptional<z$1.ZodString>;
-    packages: z$1.ZodRecord<z$1.ZodString, z$1.ZodEnum<{
-      major: "major";
-      minor: "minor";
-      patch: "patch";
-    }>>;
-    sections: z$1.ZodArray<z$1.ZodObject<{
-      depth: z$1.ZodNumber;
-      title: z$1.ZodString;
-      content: z$1.ZodString;
-    }, z$1.core.$strip>>;
+    content: z$1.ZodString;
   }, z$1.core.$strip>>;
   packages: z$1.ZodRecord<z$1.ZodString, z$1.ZodObject<{
     type: z$1.ZodOptional<z$1.ZodEnum<{
@@ -228,12 +235,26 @@ interface CreateChangelogOptions {
   from?: string;
   /** End revision. Defaults to HEAD. */
   to?: string;
+  /**
+   * Write changelog files to disk.
+   *
+   * @default true
+   */
+  write?: boolean;
 }
 interface CreatedChangelog {
   filename: string;
-  path: string;
+  content: string;
+  packages: Record<string, BumpType | ChangelogPackageConfig>;
+  changes: CommitChange[];
+}
+interface CommitChange {
+  hash: string;
+  subject: string;
+  body: string;
   packages: string[];
-  changes: number;
+  type: BumpType;
+  title: string;
 }
 //#endregion
 //#region src/index.d.ts
@@ -287,7 +308,7 @@ declare class NpmPackage extends WorkspacePackage {
   get name(): string;
   get version(): string;
   write(): Promise<void>;
-  onPlan(context: TegamiContext): PackagePlan;
+  initPlan(): PackagePlan;
 }
 declare class NpmRegistryClient implements RegistryClient {
   #private;
@@ -368,7 +389,7 @@ declare class CargoPackage extends WorkspacePackage {
   constructor(path: string, manifest: TomlTable, content: string, workspaceManifest?: TomlTable | undefined);
   get name(): string;
   get version(): string;
-  onPlan(context: TegamiContext): PackagePlan;
+  initPlan(): PackagePlan;
   setVersion(version: string): void;
   write(): Promise<void>;
   patch(path: string, value: unknown): void;
@@ -377,13 +398,28 @@ declare class CargoPackage extends WorkspacePackage {
 }
 declare class CargoRegistryClient implements RegistryClient {
   #private;
+  private readonly graph;
   readonly id = "cargo";
-  constructor(_graph: PackageGraph);
+  constructor(graph: PackageGraph);
   supports(pkg: WorkspacePackage): boolean;
   isPackagePublished(pkg: CargoPackage): Promise<boolean>;
-  publish(pkg: CargoPackage): Promise<void>;
+  publishPreflight(pkg: CargoPackage, {
+    store
+  }: {
+    store: PlanStore;
+  }): PublishPreflight;
+  publish(pkg: CargoPackage, _env: {
+    store: PlanStore;
+    packageStore: PackagePlanStore;
+  }): Promise<void>;
 }
 interface CargoPluginOptions {
+  /**
+   * Update lock file after versioning.
+   *
+   * @default false
+   */
+  updateLockFile?: boolean;
   bumpDep?: (opts: {
     kind: (typeof DEP_FIELDS)[number];
     name: string;
@@ -391,6 +427,7 @@ interface CargoPluginOptions {
   }) => BumpType | false;
 }
 declare function cargo({
+  updateLockFile,
   bumpDep: getBumpDepType
 }?: CargoPluginOptions): TegamiPlugin;
 //#endregion
@@ -403,7 +440,7 @@ interface LogGenerator {
     version: string;
     changelogs: ChangelogEntry[];
     plan: PackagePlan;
-    _draft: DraftPlan;
+    unstable_draft: DraftPlan;
   }): string | Promise<string>;
 }
 interface TegamiOptions<Groups extends string = string> {
@@ -486,14 +523,22 @@ type Awaitable<T> = T | Promise<T>;
 interface PublishPlanStatus {
   state: "pending" | "success" | "missing";
 }
+interface PublishPreflight {
+  /** Package ids that must be published before this one, this will automatically disallow circular dependency. */
+  wait: string[];
+}
 interface RegistryClient {
   id: string;
   supports(pkg: WorkspacePackage): boolean;
   isPackagePublished(pkg: WorkspacePackage): Promise<boolean>;
+  publishPreflight?(pkg: WorkspacePackage, env: {
+    store: PlanStore;
+    packageStore: PackagePlanStore;
+  }): Awaitable<PublishPreflight | void | undefined>;
   publish(pkg: WorkspacePackage, env: {
     store: PlanStore;
     packageStore: PackagePlanStore;
   }): Promise<void>;
 }
 //#endregion
-export { PublishResult as C, WorkspacePackage as D, PackageGroup as E, DraftPlan as O, PublishOptions as S, PackageGraph as T, Tegami as _, RegistryClient as a, CreatedChangelog as b, TegamiPluginOption as c, CargoRegistryClient as d, cargo as f, npm as g, NpmRegistryClient as h, PackageOptions as i, PackagePlan as k, CargoPackage as l, NpmPluginOptions as m, GroupOptions as n, TegamiOptions as o, NpmPackage as p, LogGenerator as r, TegamiPlugin as s, Awaitable as t, CargoPluginOptions as u, tegami as v, TegamiContext as w, PackagePublishResult as x, CreateChangelogOptions as y };
+export { PackagePlan as A, PublishOptions as C, PackageGroup as D, PackageGraph as E, WorkspacePackage as O, PackagePublishResult as S, TegamiContext as T, npm as _, PublishPreflight as a, CreateChangelogOptions as b, TegamiPlugin as c, CargoPluginOptions as d, CargoRegistryClient as f, NpmRegistryClient as g, NpmPluginOptions as h, PackageOptions as i, DraftPlan as k, TegamiPluginOption as l, NpmPackage as m, GroupOptions as n, RegistryClient as o, cargo as p, LogGenerator as r, TegamiOptions as s, Awaitable as t, CargoPackage as u, Tegami as v, PublishResult as w, CreatedChangelog as x, tegami as y };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tegami",
-  "version": "0.1.0",
+  "version": "0.1.3",
   "description": "Utility for package versioning & publish",
   "license": "MIT",
   "author": "Fuma Nama",