tegami 1.0.1 → 1.0.2

package/dist/cli/index.d.ts

@@ -1,4 +1,4 @@
-import { T as Draft, p as Tegami, t as Awaitable, y as PublishPlan } from "../types-DItu_YCc.js";
+import { k as Draft, p as Tegami, t as Awaitable, y as PublishPlan } from "../types-DHddSAez.js";
 
 //#region src/cli/index.d.ts
 interface TegamiCLIOptions {

package/dist/cli/index.js

@@ -124,14 +124,11 @@ async function promptPackageSelection(graph, cwd) {
 		groups.push([group, changed]);
 	}
 	groups.sort((a, b) => (a[1] ? 0 : 1) - (b[1] ? 0 : 1));
-	for (const [group, changed] of groups) {
-		if (changed) initialValues.add(`group:${group.name}`);
-		selectOptions.push({
-			label: `(Group) ${group.name}` + (changed ? "*" : ""),
-			value: `group:${group.name}`,
-			hint: group.packages.map(getPackageLabel).join(", ")
-		});
-	}
+	for (const [group, changed] of groups) selectOptions.push({
+		label: `(Group) ${group.name}` + (changed ? "*" : ""),
+		value: `group:${group.name}`,
+		hint: group.packages.map(getPackageLabel).join(", ")
+	});
 	const packages = graph.getPackages().toSorted((a, b) => (changedPackages.has(a) ? 0 : 1) - (changedPackages.has(b) ? 0 : 1));
 	for (const pkg of packages) {
 		const changed = changedPackages.has(pkg);

package/dist/generators/simple.d.ts

@@ -1,4 +1,4 @@
-import { r as LogGenerator } from "../types-DItu_YCc.js";
+import { r as LogGenerator } from "../types-DHddSAez.js";
 
 //#region src/generators/simple.d.ts
 declare function simpleGenerator(): LogGenerator;

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-import { C as PackageGroup, D as PackageDraft, E as DraftPolicy, O as BumpType, S as PackageGraph, T as Draft, _ as PackagePublishResult, a as PublishPreflight, b as CommitChangelog, c as TegamiPluginOption, f as GenerateChangelogOptions, g as PackagePublishPlan, h as PublishLock, i as PackageOptions, m as tegami, n as GroupOptions, o as TegamiOptions, p as Tegami, r as LogGenerator, s as TegamiPlugin, v as PublishOptions, w as WorkspacePackage, x as TegamiContext, y as PublishPlan } from "./types-DItu_YCc.js";
+import { A as DraftPolicy, D as PackageGroup, E as PackageGraph, M as BumpType, O as WorkspacePackage, _ as PackagePublishResult, a as PublishPreflight, b as CommitChangelog, c as TegamiPluginOption, f as GenerateChangelogOptions, g as PackagePublishPlan, h as PublishLock, i as PackageOptions, j as PackageDraft, k as Draft, m as tegami, n as GroupOptions, o as TegamiOptions, p as Tegami, r as LogGenerator, s as TegamiPlugin, v as PublishOptions, x as TegamiContext, y as PublishPlan } from "./types-DHddSAez.js";
 export { type BumpType, type CommitChangelog, type Draft, type DraftPolicy, GenerateChangelogOptions, type GroupOptions, type LogGenerator, type PackageDraft, PackageGraph, type PackageGroup, type PackageOptions, type PackagePublishPlan, type PackagePublishResult, type PublishLock, type PublishOptions, type PublishPlan, type PublishPreflight, Tegami, type TegamiContext, type TegamiOptions, type TegamiPlugin, type TegamiPluginOption, WorkspacePackage, tegami };

package/dist/index.js

@@ -1,6 +1,6 @@
 import { n as generateFromCommits } from "./generate-Rvz4Lu98.js";
 import { r as handlePluginError } from "./error-BhMYq9iW.js";
-import { a as runPreflights, i as publishPlanStatus, n as npm, o as runPublishPlan, r as initPublishPlan } from "./npm-1iEegfHg.js";
+import { a as runPreflights, i as publishPlanStatus, n as npm, o as runPublishPlan, r as initPublishPlan } from "./npm-5cG02krT.js";
 import { n as WorkspacePackage, t as PackageGraph } from "./graph-gThXu8Cz.js";
 import { a as parseChangelogFile, n as createDraft, o as readChangelogEntries } from "./draft-BqHcSCeX.js";
 import { mkdir, rm, writeFile } from "node:fs/promises";

package/dist/{npm-1iEegfHg.js → npm-5cG02krT.js}

@@ -133,27 +133,25 @@ async function runPublishPlan(context, plan) {
 }
 async function runPreflights(context, plan) {
 	const promises = [];
-	const runPreflight = async (pkg) => {
-		for (const plugin of context.plugins) {
-			const res = await handlePluginError(plugin, "publishPreflight", () => plugin.publishPreflight?.call(context, {
-				pkg,
-				plan
-			}));
-			if (res) return res;
-		}
-		return { shouldPublish: false };
-	};
 	for (const [id, packagePlan] of plan.packages) {
 		const pkg = context.graph.get(id);
-		if (!packagePlan.updated) {
-			packagePlan.preflight = { shouldPublish: false };
-			continue;
-		}
-		promises.push(runPreflight(pkg).then((preflight) => {
-			packagePlan.preflight = preflight;
-		}));
+		packagePlan.preflight = { shouldPublish: false };
+		if (!packagePlan.updated) continue;
+		promises.push((async () => {
+			for (const plugin of context.plugins) {
+				const res = await handlePluginError(plugin, "publishPreflight", () => plugin.publishPreflight?.call(context, {
+					pkg,
+					plan
+				}));
+				if (res) {
+					packagePlan.preflight = res;
+					break;
+				}
+			}
+		})());
 	}
 	await Promise.all(promises);
+	for (const plugin of context.plugins) await handlePluginError(plugin, "afterPreflight", () => plugin.afterPreflight?.call(context, { plan }));
 }
 async function publishPlanStatus(plan, context) {
 	for (const plugin of context.plugins) {

package/dist/plugins/cargo.d.ts

@@ -1,97 +1,2 @@
-import { O as BumpType, s as TegamiPlugin, w as WorkspacePackage } from "../types-DItu_YCc.js";
-import z from "zod";
-
-//#region src/plugins/cargo/schema.d.ts
-declare const cargoManifestSchema: z.ZodObject<{
-  package: z.ZodObject<{
-    name: z.ZodString;
-    version: z.ZodOptional<z.ZodString>;
-    publish: z.ZodOptional<z.ZodBoolean>;
-  }, z.core.$strip>;
-  workspace: z.ZodOptional<z.ZodObject<{
-    members: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    package: z.ZodOptional<z.ZodObject<{
-      version: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-  }, z.core.$strip>>;
-  dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-    version: z.ZodString;
-    package: z.ZodOptional<z.ZodString>;
-    path: z.ZodOptional<z.ZodString>;
-  }, z.core.$strip>]>>>;
-  "dev-dependencies": z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-    version: z.ZodString;
-    package: z.ZodOptional<z.ZodString>;
-    path: z.ZodOptional<z.ZodString>;
-  }, z.core.$strip>]>>>;
-  "build-dependencies": z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-    version: z.ZodString;
-    package: z.ZodOptional<z.ZodString>;
-    path: z.ZodOptional<z.ZodString>;
-  }, z.core.$strip>]>>>;
-  target: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-    dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-      version: z.ZodString;
-      package: z.ZodOptional<z.ZodString>;
-      path: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>]>>>;
-    "dev-dependencies": z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-      version: z.ZodString;
-      package: z.ZodOptional<z.ZodString>;
-      path: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>]>>>;
-    "build-dependencies": z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
-      version: z.ZodString;
-      package: z.ZodOptional<z.ZodString>;
-      path: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>]>>>;
-  }, z.core.$strip>>>;
-}, z.core.$strip>;
-type CargoManifest = z.infer<typeof cargoManifestSchema>;
-//#endregion
-//#region src/plugins/cargo.d.ts
-declare const DEP_FIELDS: readonly ["dependencies", "dev-dependencies", "build-dependencies"];
-declare class CargoPackage extends WorkspacePackage {
-  readonly path: string;
-  readonly manifest: CargoManifest;
-  private content;
-  private readonly workspaceManifest?;
-  readonly manager = "cargo";
-  constructor(path: string, manifest: CargoManifest, content: string, workspaceManifest?: CargoManifest | undefined);
-  get name(): string;
-  get version(): string | undefined;
-  setVersion(version: string): void;
-  write(): Promise<void>;
-  patch(path: string, value: unknown): void;
-  get packageInfo(): {
-    name: string;
-    version?: string | undefined;
-    publish?: boolean | undefined;
-  };
-  private get workspaceVersion();
-}
-interface DependentRef {
-  dependent: CargoPackage;
-  kind: (typeof DEP_FIELDS)[number];
-  name: string;
-  version: string;
-}
-interface CargoPluginOptions {
-  /**
-   * Update lock file after versioning.
-   *
-   * @default true
-   */
-  updateLockFile?: boolean;
-  /**
-   * Decide how to bump the dependents of a bumped package.
-   */
-  bumpDep?: (opts: DependentRef) => BumpType | false;
-}
-declare function cargo({
-  updateLockFile,
-  bumpDep: getBumpDepType
-}?: CargoPluginOptions): TegamiPlugin;
-//#endregion
-export { CargoPackage, CargoPluginOptions, cargo };
+import { C as CargoPackage, S as CargoGraph, T as cargo, w as CargoPluginOptions } from "../types-DHddSAez.js";
+export { CargoGraph, CargoPackage, CargoPluginOptions, cargo };

package/dist/plugins/cargo.js

@@ -1,40 +1,76 @@
 import { n as execFailure } from "../error-BhMYq9iW.js";
 import { n as WorkspacePackage } from "../graph-gThXu8Cz.js";
 import { readFile, writeFile } from "node:fs/promises";
-import { join, normalize } from "node:path";
+import path from "node:path";
 import { x } from "tinyexec";
 import * as semver$1 from "semver";
 import z from "zod";
 import { glob } from "tinyglobby";
 import initToml, { edit, parse as parse$1 } from "@rainbowatcher/toml-edit-js";
 //#region src/plugins/cargo/schema.ts
-const cargoDependencySchema = z.union([z.string(), z.object({
-	version: z.string(),
+const baseDepSchema = z.object({
 	package: z.string().optional(),
-	path: z.string().optional()
-})]);
-const cargoTargetConfigSchema = z.object({
-	dependencies: z.record(z.string(), cargoDependencySchema).optional(),
-	"dev-dependencies": z.record(z.string(), cargoDependencySchema).optional(),
-	"build-dependencies": z.record(z.string(), cargoDependencySchema).optional()
+	features: z.array(z.string()).optional(),
+	optional: z.boolean().optional(),
+	"default-features": z.boolean().optional()
+});
+/** `{ workspace = true }` — inherit from `[workspace.dependencies]` */
+const workspaceDependencySchema = baseDepSchema.extend({ workspace: z.literal(true) });
+/** `{ path = "../lib" }` — optional `version` for publishing */
+const pathDependencySchema = baseDepSchema.extend({
+	path: z.string(),
+	version: z.string().optional()
+});
+/** `{ git = "…" }` — exactly one of `branch`, `tag`, or `rev` in practice */
+const gitDependencySchema = baseDepSchema.extend({
+	git: z.string(),
+	branch: z.string().optional(),
+	tag: z.string().optional(),
+	rev: z.string().optional(),
+	version: z.string().optional()
 });
-const cargoPackageSchema = z.object({
-	name: z.string(),
-	version: z.string().optional(),
-	publish: z.boolean().optional()
+/** `{ version = "1.0" }` — crates.io or `[registries]` */
+const registryDependencySchema = baseDepSchema.extend({
+	version: z.string(),
+	registry: z.string().optional()
 });
-const cargoWorkspaceSchema = z.object({
+/**
+* @see https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html
+*/
+const cargoDependencySchema = z.union([
+	z.string(),
+	workspaceDependencySchema,
+	pathDependencySchema,
+	gitDependencySchema,
+	registryDependencySchema
+]);
+const cargoInheritSchema = z.looseObject({ workspace: z.literal(true) });
+const cargoWorkspaceSchema = z.looseObject({
 	members: z.array(z.string()).optional(),
 	exclude: z.array(z.string()).optional(),
-	package: z.object({ version: z.string().optional() }).optional()
+	package: z.looseObject({
+		version: z.string().optional(),
+		publish: z.boolean().optional()
+	}).optional(),
+	dependencies: z.record(z.string(), cargoDependencySchema).optional(),
+	"dev-dependencies": z.record(z.string(), cargoDependencySchema).optional(),
+	"build-dependencies": z.record(z.string(), cargoDependencySchema).optional()
 });
-const cargoManifestSchema = z.object({
-	package: cargoPackageSchema,
+const cargoManifestSchema = z.looseObject({
+	package: z.looseObject({
+		name: z.string(),
+		version: z.string().or(cargoInheritSchema),
+		publish: z.boolean().or(cargoInheritSchema).optional()
+	}).optional(),
 	workspace: cargoWorkspaceSchema.optional(),
 	dependencies: z.record(z.string(), cargoDependencySchema).optional(),
 	"dev-dependencies": z.record(z.string(), cargoDependencySchema).optional(),
 	"build-dependencies": z.record(z.string(), cargoDependencySchema).optional(),
-	target: z.record(z.string(), cargoTargetConfigSchema).optional()
+	target: z.record(z.string(), z.looseObject({
+		dependencies: z.record(z.string(), cargoDependencySchema).optional(),
+		"dev-dependencies": z.record(z.string(), cargoDependencySchema).optional(),
+		"build-dependencies": z.record(z.string(), cargoDependencySchema).optional()
+	})).optional()
 });
 //#endregion
 //#region src/plugins/cargo.ts
@@ -45,42 +81,46 @@ const DEP_FIELDS = [
 ];
 var CargoPackage = class extends WorkspacePackage {
 	path;
-	manifest;
-	content;
-	workspaceManifest;
+	file;
+	workspaceFile;
 	manager = "cargo";
-	constructor(path, manifest, content, workspaceManifest) {
+	manifest;
+	constructor(path, file, workspaceFile) {
 		super();
 		this.path = path;
-		this.manifest = manifest;
-		this.content = content;
-		this.workspaceManifest = workspaceManifest;
+		this.file = file;
+		this.workspaceFile = workspaceFile;
+		this.manifest = file.data;
 	}
 	get name() {
-		return this.packageInfo.name;
+		return this.manifest.package.name;
 	}
 	get version() {
-		return this.packageInfo.version ?? this.workspaceVersion;
+		const packageVersion = this.manifest.package.version;
+		if (typeof packageVersion === "string") return packageVersion;
+		const inherited = this.workspaceFile?.data.workspace.package;
+		if (packageVersion.workspace && inherited?.version) return inherited.version;
+		throw new Error(`Invalid Cargo.toml in "${this.path}".`);
 	}
 	setVersion(version) {
-		this.packageInfo.version = version;
-		this.patch("package.version", version);
-	}
-	async write() {
-		await writeFile(join(this.path, "Cargo.toml"), this.content + "\n");
-	}
-	patch(path, value) {
-		this.content = edit(this.content, path, value);
-	}
-	get packageInfo() {
-		return this.manifest.package;
-	}
-	get workspaceVersion() {
-		return this.workspaceManifest?.workspace?.package?.version;
+		const packageInfo = this.manifest.package;
+		if (typeof packageInfo.version === "string") {
+			packageInfo.version = version;
+			patchFile(this.file, "package.version", version);
+			return;
+		}
+		if (packageInfo.version.workspace && this.workspaceFile?.data.workspace.package) {
+			this.workspaceFile.data.workspace.package.version = version;
+			patchFile(this.workspaceFile, "workspace.package.version", version);
+			return;
+		}
+		throw new Error(`Invalid Cargo.toml in "${this.path}".`);
 	}
 };
+function patchFile(file, path, value) {
+	file.content = edit(file.content, path, value);
+}
 function cargo({ updateLockFile = true, bumpDep: getBumpDepType } = {}) {
-	let active = false;
 	return {
 		name: "cargo",
 		enforce: "pre",
@@ -88,34 +128,37 @@ function cargo({ updateLockFile = true, bumpDep: getBumpDepType } = {}) {
 			await initToml();
 		},
 		async resolve() {
-			await discoverCargoPackages(this.cwd, (pkg) => this.graph.add(pkg));
-			active = this.graph.getPackages().some((pkg) => pkg instanceof CargoPackage);
+			const graph = await resolveCargoGraph(this.cwd);
+			if (graph.packages.size === 0) return;
+			this.cargo = { graph };
+			for (const pkg of graph.packages.values()) this.graph.add(pkg);
 		},
 		initDraft(plan) {
-			if (!active) return;
+			if (!this.cargo) return;
 			plan.addPolicy(depsPolicy(this, getBumpDepType));
 		},
 		async publishPreflight({ pkg }) {
-			if (!(pkg instanceof CargoPackage)) return;
+			if (!(pkg instanceof CargoPackage) || !this.cargo) return;
+			let shouldPublish = true;
+			if (typeof pkg.manifest.package.publish === "boolean") shouldPublish = pkg.manifest.package.publish;
+			else if (pkg.manifest.package.publish?.workspace) shouldPublish = pkg.workspaceFile?.data.workspace?.package?.publish ?? shouldPublish;
 			const wait = [];
-			for (const { table } of dependencyTables(pkg.manifest, "")) for (const [rawName, dep] of Object.entries(table)) {
-				if (!dep || typeof dep === "string" || !dep.path) continue;
-				const id = `cargo:${dep.package ?? rawName}`;
-				const linked = this.graph.get(id);
-				if (!linked || !(linked instanceof CargoPackage)) continue;
-				wait.push(id);
+			for (const { table, tablePath } of dependencyTables(pkg.manifest)) for (const [rawName, spec] of Object.entries(table)) {
+				const resolved = resolveLinkedDep(pkg.workspaceFile, pkg.file, this.cargo.graph, tablePath, rawName, spec);
+				if (!resolved) continue;
+				wait.push(resolved.linked.id);
 			}
 			return {
-				shouldPublish: pkg.version !== void 0 && pkg.packageInfo.publish !== false,
+				shouldPublish,
 				wait
 			};
 		},
 		resolvePlanStatus({ plan }) {
-			if (!active) return;
+			if (!this.cargo) return;
 			return Array.from(plan.packages, async ([id, { preflight }]) => {
 				if (!preflight.shouldPublish) return;
 				const pkg = this.graph.get(id);
-				if (!(pkg instanceof CargoPackage) || !pkg.version) return;
+				if (!(pkg instanceof CargoPackage)) return;
 				if (!await isPackagePublished(pkg.name, pkg.version)) return "pending";
 			});
 		},
@@ -132,70 +175,59 @@ function cargo({ updateLockFile = true, bumpDep: getBumpDepType } = {}) {
 			return { type: "published" };
 		},
 		async applyDraft(draft) {
-			if (!active) return;
-			const { graph } = this;
-			const writes = [];
-			for (const pkg of graph.getPackages()) {
-				if (!(pkg instanceof CargoPackage)) continue;
+			if (!this.cargo) return;
+			const graph = this.cargo.graph;
+			for (const pkg of graph.packages.values()) {
 				const bumped = draft.getPackageDraft(pkg.id)?.bumpVersion(pkg);
 				if (bumped) pkg.setVersion(bumped);
 			}
-			for (const pkg of graph.getPackages()) {
-				if (!(pkg instanceof CargoPackage)) continue;
-				for (const { table, path: tablePath } of dependencyTables(pkg.manifest, "")) for (const [rawName, rawSpec] of Object.entries(table)) {
-					const spec = parseSpec(rawSpec);
-					if (!spec || !semver$1.validRange(spec.version)) continue;
-					const packageName = spec.package ?? rawName;
-					const linked = graph.get(`cargo:${packageName}`);
-					if (!linked || !(linked instanceof CargoPackage)) continue;
-					if (!linked.version || semver$1.satisfies(linked.version, spec.version)) continue;
-					let updatedRange;
-					if (spec.version.startsWith("^")) updatedRange = `^${linked.version}`;
-					else if (spec.version.startsWith("~")) updatedRange = `~${linked.version}`;
-					else updatedRange = linked.version;
-					table[rawName] = spec.setVersion(updatedRange);
-					pkg.patch(typeof rawSpec === "string" ? `${tablePath}.${rawName}` : `${tablePath}.${rawName}.version`, updatedRange);
-				}
-				writes.push(pkg.write());
+			for (const pkg of graph.packages.values()) for (const { table, tablePath } of dependencyTables(pkg.manifest)) for (const [rawName, spec] of Object.entries(table)) {
+				const resolved = resolveLinkedDep(pkg.workspaceFile, pkg.file, graph, tablePath, rawName, spec);
+				if (!resolved || !resolved.range || !resolved.setRange || semver$1.satisfies(resolved.linked.version, resolved.range)) continue;
+				let updatedRange;
+				if (resolved.range.startsWith("^")) updatedRange = `^${resolved.linked.version}`;
+				else if (resolved.range.startsWith("~")) updatedRange = `~${resolved.linked.version}`;
+				else updatedRange = resolved.linked.version;
+				table[rawName] = resolved.setRange(updatedRange);
 			}
-			await Promise.all(writes);
+			await Promise.all(Array.from(graph.files.values(), (file) => writeFile(file.path, file.content + "\n")));
 		},
 		async applyCliDraft() {
-			if (!active || !updateLockFile) return;
+			if (!this.cargo || !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);
 		}
 	};
 }
-function depsPolicy({ graph }, getBumpDepType = ({ kind }) => {
+function depsPolicy({ graph, cargo }, getBumpDepType = ({ kind }) => {
 	switch (kind) {
 		case "dependencies": return "patch";
 		case "build-dependencies":
 		case "dev-dependencies": return false;
 	}
 }) {
+	const cargoGraph = cargo.graph;
 	const dependentMap = /* @__PURE__ */ new Map();
-	for (const pkg of graph.getPackages()) {
-		if (!(pkg instanceof CargoPackage)) continue;
-		for (const { table, kind } of dependencyTables(pkg.manifest, "")) for (const [rawName, rawSpec] of Object.entries(table)) {
-			const spec = parseSpec(rawSpec);
-			if (!spec || !semver$1.validRange(spec.version)) continue;
-			const name = spec.package ?? rawName;
-			const id = `cargo:${name}`;
-			const refs = dependentMap.get(id);
-			if (refs) refs.push({
-				dependent: pkg,
-				kind,
-				name,
-				version: spec.version
-			});
-			else dependentMap.set(id, [{
-				dependent: pkg,
-				kind,
-				name,
-				version: spec.version
-			}]);
-		}
+	for (const pkg of cargoGraph.packages.values()) for (const { table, tablePath } of dependencyTables(pkg.manifest)) for (const [name, spec] of Object.entries(table)) {
+		const resolved = resolveLinkedDep(pkg.workspaceFile, pkg.file, cargoGraph, tablePath, name, spec);
+		if (!resolved) continue;
+		const id = resolved.linked.id;
+		const refs = dependentMap.get(id);
+		const kind = tablePath.at(-1);
+		if (refs) refs.push({
+			dependent: pkg,
+			kind,
+			name,
+			spec,
+			version: resolved.range
+		});
+		else dependentMap.set(id, [{
+			dependent: pkg,
+			kind,
+			name,
+			spec,
+			version: resolved.range
+		}]);
 	}
 	return {
 		id: "cargo:deps",
@@ -208,12 +240,12 @@ function depsPolicy({ graph }, getBumpDepType = ({ kind }) => {
 			if (!bumped) return;
 			for (const dep of deps) {
 				if (group?.options.syncBump && graph.getPackageGroup(dep.dependent.id) === group) continue;
-				if (semver$1.satisfies(bumped, dep.version)) continue;
+				if (dep.version && semver$1.satisfies(bumped, dep.version)) continue;
 				const bumpType = getBumpDepType(dep);
 				if (bumpType === false) continue;
 				this.bumpPackage(dep.dependent, {
 					type: bumpType,
-					reason: `update dependency "${dep.name}"`
+					reason: `update dependency "${pkg.name}"`
 				});
 			}
 		}
@@ -225,81 +257,146 @@ async function isPackagePublished(name, version) {
 	if (response.status === 404) return false;
 	throw new Error(`Unable to validate ${name}@${version} against crates.io: ${await response.text()}`);
 }
-async function buildEntry(path) {
+async function buildEntry(dir) {
 	try {
-		const content = await readFile(join(path, "Cargo.toml"), "utf8");
+		const filePath = path.join(dir, "Cargo.toml");
+		const content = await readFile(filePath, "utf8");
 		return {
-			manifest: cargoManifestSchema.parse(parse$1(content)),
-			content,
-			path
+			path: filePath,
+			data: cargoManifestSchema.parse(parse$1(content)),
+			content
 		};
 	} catch {
 		return;
 	}
 }
-async function discoverCargoPackages(cwd, add) {
+async function resolveCargoGraph(cwd) {
+	const out = {
+		packages: /* @__PURE__ */ new Map(),
+		files: /* @__PURE__ */ new Map()
+	};
 	const root = await buildEntry(cwd);
-	if (!root) return;
-	if (root.manifest.package?.name) add(new CargoPackage(cwd, root.manifest, root.content, root.manifest));
-	const workspace = root.manifest.workspace;
-	if (!workspace?.members) return;
-	const paths = await expandWorkspaceMembers(cwd, workspace.members, workspace.exclude);
-	const manifests = await Promise.all(paths.map(buildEntry));
-	for (const entry of manifests) if (entry?.manifest.package?.name) add(new CargoPackage(entry.path, entry.manifest, entry.content, root.manifest));
+	if (!root) return out;
+	const rootWorkspace = root.data.workspace;
+	out.files.set(root.path, root);
+	if (root.data.package) {
+		const pkg = new CargoPackage(cwd, root, rootWorkspace ? root : void 0);
+		out.packages.set(pkg.name, pkg);
+	}
+	if (!rootWorkspace || !rootWorkspace.members) return out;
+	const dirs = await expandWorkspaceMembers(cwd, rootWorkspace.members, rootWorkspace.exclude);
+	await Promise.all(dirs.map(async (dir) => {
+		const entry = await buildEntry(dir);
+		if (!entry || !entry.data.package) return;
+		const pkg = new CargoPackage(dir, entry, root);
+		out.files.set(entry.path, entry);
+		out.packages.set(pkg.name, pkg);
+	}));
+	return out;
 }
 async function expandWorkspaceMembers(cwd, members, exclude = []) {
-	const paths = members.includes(".") ? [cwd] : [];
 	const patterns = members.filter((member) => member !== ".");
-	if (patterns.length > 0) paths.push(...await glob(patterns, {
+	if (patterns.length === 0) return [];
+	return (await glob(patterns, {
 		absolute: true,
 		cwd,
 		ignore: ["**/target/**", ...exclude],
 		onlyDirectories: true,
 		onlyFiles: false
-	}));
-	return paths.map(normalize);
+	})).map((item) => {
+		return item.endsWith(path.sep) ? item.slice(0, -1) : item;
+	});
 }
-function dependencyTables(manifest, prefix) {
+function dependencyTables(manifest, prefix = []) {
 	const tables = [];
 	for (const field of DEP_FIELDS) {
 		const table = manifest[field];
-		if (table) {
-			const path = prefix ? `${prefix}.${field}` : field;
-			tables.push({
-				kind: field,
-				table,
-				path
-			});
-		}
+		if (!table) continue;
+		tables.push({
+			table,
+			tablePath: [...prefix, field]
+		});
 	}
 	const target = manifest.target;
-	if (target) for (const [targetKey, targetConfig] of Object.entries(target)) {
-		const targetPath = prefix ? `${prefix}.target.${targetKey}` : `target.${targetKey}`;
-		for (const field of DEP_FIELDS) {
-			const table = targetConfig[field];
-			if (table) tables.push({
-				kind: field,
-				table,
-				path: `${targetPath}.${field}`
-			});
-		}
+	if (target) for (const [targetKey, targetConfig] of Object.entries(target)) for (const field of DEP_FIELDS) {
+		const table = targetConfig[field];
+		if (!table) continue;
+		tables.push({
+			table,
+			tablePath: [
+				...prefix,
+				"target",
+				targetKey,
+				field
+			]
+		});
 	}
 	return tables;
 }
-function parseSpec(v) {
-	if (typeof v === "string") return {
-		version: v,
-		setVersion(version) {
-			return version;
+function resolveLinkedDep(workspaceFile, file, graph, tablePath, rawName, spec) {
+	if (typeof spec === "string") {
+		const linked = graph.packages.get(rawName);
+		if (!linked) return;
+		return {
+			linked,
+			range: spec,
+			setRange(v) {
+				patchFile(file, [...tablePath, rawName].join("."), v);
+				return v;
+			}
+		};
+	}
+	if ("git" in spec) return;
+	if ("workspace" in spec) {
+		const kind = tablePath[tablePath.length - 1];
+		const entry = workspaceFile?.data.workspace?.[kind]?.[rawName];
+		if (!entry) return;
+		const resolved = resolveLinkedDep(void 0, workspaceFile, graph, ["workspace", kind], rawName, entry);
+		if (!resolved || !resolved.setRange) return resolved;
+		return {
+			...resolved,
+			setRange(v) {
+				workspaceFile.data.workspace[kind][rawName] = resolved.setRange(v);
+				return spec;
+			}
+		};
+	}
+	if ("path" in spec) {
+		const pkgPath = path.resolve(path.dirname(file.path), spec.path);
+		for (const pkg of graph.packages.values()) {
+			if (pkg.path !== pkgPath) continue;
+			return {
+				linked: pkg,
+				range: spec.version,
+				setRange(v) {
+					patchFile(file, [
+						...tablePath,
+						rawName,
+						"version"
+					].join("."), v);
+					return {
+						...spec,
+						version: v
+					};
+				}
+			};
 		}
-	};
+		return;
+	}
+	const linked = graph.packages.get(spec.package ?? rawName);
+	if (!linked) return;
 	return {
-		package: v.package,
-		version: v.version,
-		setVersion(version) {
+		linked,
+		range: spec.version,
+		setRange(v) {
+			patchFile(file, [
+				...tablePath,
+				rawName,
+				"version"
+			].join("."), v);
 			return {
-				...v,
-				version
+				...spec,
+				version: v
 			};
 		}
 	};

package/dist/plugins/git.d.ts

@@ -1,4 +1,4 @@
-import { s as TegamiPlugin } from "../types-DItu_YCc.js";
+import { s as TegamiPlugin } from "../types-DHddSAez.js";
 
 //#region src/plugins/git.d.ts
 interface GitPluginOptions {

package/dist/plugins/github.d.ts

@@ -1,4 +1,4 @@
-import { T as Draft, s as TegamiPlugin, t as Awaitable, w as WorkspacePackage, x as TegamiContext, y as PublishPlan } from "../types-DItu_YCc.js";
+import { O as WorkspacePackage, k as Draft, s as TegamiPlugin, t as Awaitable, x as TegamiContext, y as PublishPlan } from "../types-DHddSAez.js";
 import { GitPluginOptions } from "./git.js";
 
 //#region src/plugins/github.d.ts

package/dist/plugins/gitlab.d.ts

@@ -1,4 +1,4 @@
-import { T as Draft, s as TegamiPlugin, t as Awaitable, w as WorkspacePackage, x as TegamiContext, y as PublishPlan } from "../types-DItu_YCc.js";
+import { O as WorkspacePackage, k as Draft, s as TegamiPlugin, t as Awaitable, x as TegamiContext, y as PublishPlan } from "../types-DHddSAez.js";
 import { GitPluginOptions } from "./git.js";
 
 //#region src/plugins/gitlab.d.ts

package/dist/plugins/go.d.ts

@@ -1,4 +1,4 @@
-import { O as BumpType, s as TegamiPlugin, w as WorkspacePackage } from "../types-DItu_YCc.js";
+import { M as BumpType, O as WorkspacePackage, s as TegamiPlugin } from "../types-DHddSAez.js";
 
 //#region src/plugins/go.d.ts
 interface GoModFile {

package/dist/providers/npm.d.ts

@@ -1,2 +1,2 @@
-import { d as npm, l as NpmPackage, u as NpmPluginOptions } from "../types-DItu_YCc.js";
+import { d as npm, l as NpmPackage, u as NpmPluginOptions } from "../types-DHddSAez.js";
 export { NpmPackage, NpmPluginOptions, npm };

package/dist/providers/npm.js

@@ -1,2 +1,2 @@
-import { n as npm, t as NpmPackage } from "../npm-1iEegfHg.js";
+import { n as npm, t as NpmPackage } from "../npm-5cG02krT.js";
 export { NpmPackage, npm };

package/dist/{types-DItu_YCc.d.ts → types-DHddSAez.d.ts}

@@ -144,6 +144,395 @@ interface GitLabToken {
   type: "private-token" | "job-token";
 }
 //#endregion
+//#region src/plugins/cargo/schema.d.ts
+/**
+ * @see https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html
+ */
+declare const cargoDependencySchema: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+  package: z.ZodOptional<z.ZodString>;
+  features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  optional: z.ZodOptional<z.ZodBoolean>;
+  "default-features": z.ZodOptional<z.ZodBoolean>;
+  workspace: z.ZodLiteral<true>;
+}, z.core.$strip>, z.ZodObject<{
+  package: z.ZodOptional<z.ZodString>;
+  features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  optional: z.ZodOptional<z.ZodBoolean>;
+  "default-features": z.ZodOptional<z.ZodBoolean>;
+  path: z.ZodString;
+  version: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  package: z.ZodOptional<z.ZodString>;
+  features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  optional: z.ZodOptional<z.ZodBoolean>;
+  "default-features": z.ZodOptional<z.ZodBoolean>;
+  git: z.ZodString;
+  branch: z.ZodOptional<z.ZodString>;
+  tag: z.ZodOptional<z.ZodString>;
+  rev: z.ZodOptional<z.ZodString>;
+  version: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  package: z.ZodOptional<z.ZodString>;
+  features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  optional: z.ZodOptional<z.ZodBoolean>;
+  "default-features": z.ZodOptional<z.ZodBoolean>;
+  version: z.ZodString;
+  registry: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>]>;
+declare const cargoManifestSchema: z.ZodObject<{
+  package: z.ZodOptional<z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodUnion<[z.ZodString, z.ZodObject<{
+      workspace: z.ZodLiteral<true>;
+    }, z.core.$loose>]>;
+    publish: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodObject<{
+      workspace: z.ZodLiteral<true>;
+    }, z.core.$loose>]>>;
+  }, z.core.$loose>>;
+  workspace: z.ZodOptional<z.ZodObject<{
+    members: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    package: z.ZodOptional<z.ZodObject<{
+      version: z.ZodOptional<z.ZodString>;
+      publish: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$loose>>;
+    dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+      package: z.ZodOptional<z.ZodString>;
+      features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      optional: z.ZodOptional<z.ZodBoolean>;
+      "default-features": z.ZodOptional<z.ZodBoolean>;
+      workspace: z.ZodLiteral<true>;
+    }, z.core.$strip>, z.ZodObject<{
+      package: z.ZodOptional<z.ZodString>;
+      features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      optional: z.ZodOptional<z.ZodBoolean>;
+      "default-features": z.ZodOptional<z.ZodBoolean>;
+      path: z.ZodString;
+      version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      package: z.ZodOptional<z.ZodString>;
+      features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      optional: z.ZodOptional<z.ZodBoolean>;
+      "default-features": z.ZodOptional<z.ZodBoolean>;
+      git: z.ZodString;
+      branch: z.ZodOptional<z.ZodString>;
+      tag: z.ZodOptional<z.ZodString>;
+      rev: z.ZodOptional<z.ZodString>;
+      version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      package: z.ZodOptional<z.ZodString>;
+      features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      optional: z.ZodOptional<z.ZodBoolean>;
+      "default-features": z.ZodOptional<z.ZodBoolean>;
+      version: z.ZodString;
+      registry: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>>;
+    "dev-dependencies": z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+      package: z.ZodOptional<z.ZodString>;
+      features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      optional: z.ZodOptional<z.ZodBoolean>;
+      "default-features": z.ZodOptional<z.ZodBoolean>;
+      workspace: z.ZodLiteral<true>;
+    }, z.core.$strip>, z.ZodObject<{
+      package: z.ZodOptional<z.ZodString>;
+      features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      optional: z.ZodOptional<z.ZodBoolean>;
+      "default-features": z.ZodOptional<z.ZodBoolean>;
+      path: z.ZodString;
+      version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      package: z.ZodOptional<z.ZodString>;
+      features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      optional: z.ZodOptional<z.ZodBoolean>;
+      "default-features": z.ZodOptional<z.ZodBoolean>;
+      git: z.ZodString;
+      branch: z.ZodOptional<z.ZodString>;
+      tag: z.ZodOptional<z.ZodString>;
+      rev: z.ZodOptional<z.ZodString>;
+      version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      package: z.ZodOptional<z.ZodString>;
+      features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      optional: z.ZodOptional<z.ZodBoolean>;
+      "default-features": z.ZodOptional<z.ZodBoolean>;
+      version: z.ZodString;
+      registry: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>>;
+    "build-dependencies": z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+      package: z.ZodOptional<z.ZodString>;
+      features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      optional: z.ZodOptional<z.ZodBoolean>;
+      "default-features": z.ZodOptional<z.ZodBoolean>;
+      workspace: z.ZodLiteral<true>;
+    }, z.core.$strip>, z.ZodObject<{
+      package: z.ZodOptional<z.ZodString>;
+      features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      optional: z.ZodOptional<z.ZodBoolean>;
+      "default-features": z.ZodOptional<z.ZodBoolean>;
+      path: z.ZodString;
+      version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      package: z.ZodOptional<z.ZodString>;
+      features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      optional: z.ZodOptional<z.ZodBoolean>;
+      "default-features": z.ZodOptional<z.ZodBoolean>;
+      git: z.ZodString;
+      branch: z.ZodOptional<z.ZodString>;
+      tag: z.ZodOptional<z.ZodString>;
+      rev: z.ZodOptional<z.ZodString>;
+      version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      package: z.ZodOptional<z.ZodString>;
+      features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      optional: z.ZodOptional<z.ZodBoolean>;
+      "default-features": z.ZodOptional<z.ZodBoolean>;
+      version: z.ZodString;
+      registry: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>>;
+  }, z.core.$loose>>;
+  dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    package: z.ZodOptional<z.ZodString>;
+    features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    optional: z.ZodOptional<z.ZodBoolean>;
+    "default-features": z.ZodOptional<z.ZodBoolean>;
+    workspace: z.ZodLiteral<true>;
+  }, z.core.$strip>, z.ZodObject<{
+    package: z.ZodOptional<z.ZodString>;
+    features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    optional: z.ZodOptional<z.ZodBoolean>;
+    "default-features": z.ZodOptional<z.ZodBoolean>;
+    path: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>, z.ZodObject<{
+    package: z.ZodOptional<z.ZodString>;
+    features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    optional: z.ZodOptional<z.ZodBoolean>;
+    "default-features": z.ZodOptional<z.ZodBoolean>;
+    git: z.ZodString;
+    branch: z.ZodOptional<z.ZodString>;
+    tag: z.ZodOptional<z.ZodString>;
+    rev: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>, z.ZodObject<{
+    package: z.ZodOptional<z.ZodString>;
+    features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    optional: z.ZodOptional<z.ZodBoolean>;
+    "default-features": z.ZodOptional<z.ZodBoolean>;
+    version: z.ZodString;
+    registry: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>]>>>;
+  "dev-dependencies": z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    package: z.ZodOptional<z.ZodString>;
+    features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    optional: z.ZodOptional<z.ZodBoolean>;
+    "default-features": z.ZodOptional<z.ZodBoolean>;
+    workspace: z.ZodLiteral<true>;
+  }, z.core.$strip>, z.ZodObject<{
+    package: z.ZodOptional<z.ZodString>;
+    features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    optional: z.ZodOptional<z.ZodBoolean>;
+    "default-features": z.ZodOptional<z.ZodBoolean>;
+    path: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>, z.ZodObject<{
+    package: z.ZodOptional<z.ZodString>;
+    features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    optional: z.ZodOptional<z.ZodBoolean>;
+    "default-features": z.ZodOptional<z.ZodBoolean>;
+    git: z.ZodString;
+    branch: z.ZodOptional<z.ZodString>;
+    tag: z.ZodOptional<z.ZodString>;
+    rev: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>, z.ZodObject<{
+    package: z.ZodOptional<z.ZodString>;
+    features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    optional: z.ZodOptional<z.ZodBoolean>;
+    "default-features": z.ZodOptional<z.ZodBoolean>;
+    version: z.ZodString;
+    registry: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>]>>>;
+  "build-dependencies": z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    package: z.ZodOptional<z.ZodString>;
+    features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    optional: z.ZodOptional<z.ZodBoolean>;
+    "default-features": z.ZodOptional<z.ZodBoolean>;
+    workspace: z.ZodLiteral<true>;
+  }, z.core.$strip>, z.ZodObject<{
+    package: z.ZodOptional<z.ZodString>;
+    features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    optional: z.ZodOptional<z.ZodBoolean>;
+    "default-features": z.ZodOptional<z.ZodBoolean>;
+    path: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>, z.ZodObject<{
+    package: z.ZodOptional<z.ZodString>;
+    features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    optional: z.ZodOptional<z.ZodBoolean>;
+    "default-features": z.ZodOptional<z.ZodBoolean>;
+    git: z.ZodString;
+    branch: z.ZodOptional<z.ZodString>;
+    tag: z.ZodOptional<z.ZodString>;
+    rev: z.ZodOptional<z.ZodString>;
+    version: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>, z.ZodObject<{
+    package: z.ZodOptional<z.ZodString>;
+    features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    optional: z.ZodOptional<z.ZodBoolean>;
+    "default-features": z.ZodOptional<z.ZodBoolean>;
+    version: z.ZodString;
+    registry: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>]>>>;
+  target: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+    dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+      package: z.ZodOptional<z.ZodString>;
+      features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      optional: z.ZodOptional<z.ZodBoolean>;
+      "default-features": z.ZodOptional<z.ZodBoolean>;
+      workspace: z.ZodLiteral<true>;
+    }, z.core.$strip>, z.ZodObject<{
+      package: z.ZodOptional<z.ZodString>;
+      features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      optional: z.ZodOptional<z.ZodBoolean>;
+      "default-features": z.ZodOptional<z.ZodBoolean>;
+      path: z.ZodString;
+      version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      package: z.ZodOptional<z.ZodString>;
+      features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      optional: z.ZodOptional<z.ZodBoolean>;
+      "default-features": z.ZodOptional<z.ZodBoolean>;
+      git: z.ZodString;
+      branch: z.ZodOptional<z.ZodString>;
+      tag: z.ZodOptional<z.ZodString>;
+      rev: z.ZodOptional<z.ZodString>;
+      version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      package: z.ZodOptional<z.ZodString>;
+      features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      optional: z.ZodOptional<z.ZodBoolean>;
+      "default-features": z.ZodOptional<z.ZodBoolean>;
+      version: z.ZodString;
+      registry: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>>;
+    "dev-dependencies": z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+      package: z.ZodOptional<z.ZodString>;
+      features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      optional: z.ZodOptional<z.ZodBoolean>;
+      "default-features": z.ZodOptional<z.ZodBoolean>;
+      workspace: z.ZodLiteral<true>;
+    }, z.core.$strip>, z.ZodObject<{
+      package: z.ZodOptional<z.ZodString>;
+      features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      optional: z.ZodOptional<z.ZodBoolean>;
+      "default-features": z.ZodOptional<z.ZodBoolean>;
+      path: z.ZodString;
+      version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      package: z.ZodOptional<z.ZodString>;
+      features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      optional: z.ZodOptional<z.ZodBoolean>;
+      "default-features": z.ZodOptional<z.ZodBoolean>;
+      git: z.ZodString;
+      branch: z.ZodOptional<z.ZodString>;
+      tag: z.ZodOptional<z.ZodString>;
+      rev: z.ZodOptional<z.ZodString>;
+      version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      package: z.ZodOptional<z.ZodString>;
+      features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      optional: z.ZodOptional<z.ZodBoolean>;
+      "default-features": z.ZodOptional<z.ZodBoolean>;
+      version: z.ZodString;
+      registry: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>>;
+    "build-dependencies": z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+      package: z.ZodOptional<z.ZodString>;
+      features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      optional: z.ZodOptional<z.ZodBoolean>;
+      "default-features": z.ZodOptional<z.ZodBoolean>;
+      workspace: z.ZodLiteral<true>;
+    }, z.core.$strip>, z.ZodObject<{
+      package: z.ZodOptional<z.ZodString>;
+      features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      optional: z.ZodOptional<z.ZodBoolean>;
+      "default-features": z.ZodOptional<z.ZodBoolean>;
+      path: z.ZodString;
+      version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      package: z.ZodOptional<z.ZodString>;
+      features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      optional: z.ZodOptional<z.ZodBoolean>;
+      "default-features": z.ZodOptional<z.ZodBoolean>;
+      git: z.ZodString;
+      branch: z.ZodOptional<z.ZodString>;
+      tag: z.ZodOptional<z.ZodString>;
+      rev: z.ZodOptional<z.ZodString>;
+      version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      package: z.ZodOptional<z.ZodString>;
+      features: z.ZodOptional<z.ZodArray<z.ZodString>>;
+      optional: z.ZodOptional<z.ZodBoolean>;
+      "default-features": z.ZodOptional<z.ZodBoolean>;
+      version: z.ZodString;
+      registry: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>>;
+  }, z.core.$loose>>>;
+}, z.core.$loose>;
+type CargoDependency = z.infer<typeof cargoDependencySchema>;
+type CargoManifest = z.infer<typeof cargoManifestSchema>;
+//#endregion
+//#region src/plugins/cargo.d.ts
+declare const DEP_FIELDS$1: readonly ["dependencies", "dev-dependencies", "build-dependencies"];
+interface CargoToml<Data extends CargoManifest = CargoManifest> {
+  path: string;
+  content: string;
+  data: Data;
+}
+declare class CargoPackage extends WorkspacePackage {
+  readonly path: string;
+  /** a crate must have `package` field defined, otherwise it is merely a virutal workspace file, and Tegami should not include it. */
+  readonly file: CargoToml<RequireFields<CargoManifest, "package">>;
+  readonly workspaceFile?: CargoToml<RequireFields<CargoManifest, "workspace">> | undefined;
+  readonly manager = "cargo";
+  readonly manifest: RequireFields<CargoManifest, "package">;
+  constructor(path: string, /** a crate must have `package` field defined, otherwise it is merely a virutal workspace file, and Tegami should not include it. */
+
+  file: CargoToml<RequireFields<CargoManifest, "package">>, workspaceFile?: CargoToml<RequireFields<CargoManifest, "workspace">> | undefined);
+  get name(): string;
+  get version(): string;
+  setVersion(version: string): void;
+}
+interface DependentRef$1 {
+  dependent: CargoPackage;
+  kind: (typeof DEP_FIELDS$1)[number];
+  name: string;
+  spec: CargoDependency;
+  version?: string;
+}
+interface CargoPluginOptions {
+  /**
+   * Update lock file after versioning.
+   *
+   * @default true
+   */
+  updateLockFile?: boolean;
+  /**
+   * Decide how to bump the dependents of a bumped package.
+   */
+  bumpDep?: (opts: DependentRef$1) => BumpType | false;
+}
+declare function cargo({
+  updateLockFile,
+  bumpDep: getBumpDepType
+}?: CargoPluginOptions): TegamiPlugin;
+interface CargoGraph {
+  /** path -> Cargo.toml */
+  files: Map<string, CargoToml>;
+  /** name -> package */
+  packages: Map<string, CargoPackage>;
+}
+//#endregion
 //#region src/context.d.ts
 interface TegamiContext {
   /** absolute path */
@@ -171,6 +560,9 @@ interface TegamiContext {
   npm?: {
     client: AgentName;
   };
+  cargo?: {
+    graph: CargoGraph;
+  };
 }
 //#endregion
 //#region src/providers/npm/schema.d.ts
@@ -516,6 +908,10 @@ interface TegamiPlugin {
     pkg: WorkspacePackage;
     plan: PublishPlan;
   }): Awaitable<PublishPreflight | void | undefined>;
+  /** Called when all preflights finished */
+  afterPreflight?(this: TegamiContext, opts: {
+    plan: PublishPlan;
+  }): Awaitable<void>;
   /** Publish package, return a result object indicating if the package is published, skipped, or failed. Return `undefined` if the package is not handled by this plugin. */
   publish?(this: TegamiContext, opts: {
     pkg: WorkspacePackage;
@@ -548,6 +944,7 @@ interface TegamiPlugin {
   applyCliDraft?(this: TegamiContext, draft: Draft): Awaitable<void>;
 }
 type Awaitable<T> = T | Promise<T>;
+type RequireFields<Obj, K extends keyof Obj> = Obj & { [R in K]-?: NonNullable<Obj[R]> };
 interface PublishPreflight {
   /**
    * Whether the package should be published, the state **must not** be changed across different runs.
@@ -563,4 +960,4 @@ interface PublishPreflight {
   wait?: string[];
 }
 //#endregion
-export { PackageGroup as C, PackageDraft as D, DraftPolicy as E, BumpType as O, PackageGraph as S, Draft as T, PackagePublishResult as _, PublishPreflight as a, CommitChangelog as b, TegamiPluginOption as c, npm as d, GenerateChangelogOptions as f, PackagePublishPlan as g, PublishLock as h, PackageOptions as i, NpmPackage as l, tegami as m, GroupOptions as n, TegamiOptions as o, Tegami as p, LogGenerator as r, TegamiPlugin as s, Awaitable as t, NpmPluginOptions as u, PublishOptions as v, WorkspacePackage as w, TegamiContext as x, PublishPlan as y };
+export { DraftPolicy as A, CargoPackage as C, PackageGroup as D, PackageGraph as E, BumpType as M, WorkspacePackage as O, CargoGraph as S, cargo as T, PackagePublishResult as _, PublishPreflight as a, CommitChangelog as b, TegamiPluginOption as c, npm as d, GenerateChangelogOptions as f, PackagePublishPlan as g, PublishLock as h, PackageOptions as i, PackageDraft as j, Draft as k, NpmPackage as l, tegami as m, GroupOptions as n, TegamiOptions as o, Tegami as p, LogGenerator as r, TegamiPlugin as s, Awaitable as t, NpmPluginOptions as u, PublishOptions as v, CargoPluginOptions as w, TegamiContext as x, PublishPlan as y };

package/package.json

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