tegami 0.1.6 → 0.2.0

package/dist/providers/cargo.js

@@ -1,5 +1,5 @@
 import { i as isNodeError, n as execFailure } from "../error-DNy8R5ue.js";
-import { n as WorkspacePackage } from "../graph-DLKPUXSD.js";
+import { n as WorkspacePackage } from "../graph-DrzluXw8.js";
 import { readFile, writeFile } from "node:fs/promises";
 import { join, normalize } from "node:path";
 import { x } from "tinyexec";
@@ -31,17 +31,12 @@ var CargoPackage = class extends WorkspacePackage {
 	get version() {
 		return stringValue(this.packageInfo.version) ?? this.workspaceVersion ?? "0.0.0";
 	}
-	initPlan() {
-		const defaults = super.initPlan();
-		defaults.publish ??= this.packageInfo.publish !== false;
-		return defaults;
-	}
 	setVersion(version) {
 		this.packageInfo.version = version;
 		this.patch("package.version", version);
 	}
 	async write() {
-		await writeFile(join(this.path, "Cargo.toml"), this.content);
+		await writeFile(join(this.path, "Cargo.toml"), this.content + "\n");
 	}
 	patch(path, value) {
 		this.content = edit(this.content, path, value);
@@ -54,85 +49,8 @@ var CargoPackage = class extends WorkspacePackage {
 		return stringValue(tableValue(tableValue(this.workspaceManifest?.workspace)?.package)?.version);
 	}
 };
-var CargoRegistryClient = class {
-	graph;
-	id = "cargo";
-	#versionMap = /* @__PURE__ */ new Map();
-	constructor(graph) {
-		this.graph = graph;
-	}
-	supports(pkg) {
-		return pkg instanceof CargoPackage;
-	}
-	async isPackagePublished(pkg) {
-		const cacheKey = `${pkg.id}@${pkg.version}`;
-		let info = this.#versionMap.get(cacheKey);
-		if (!info) {
-			info = fetch(`https://crates.io/api/v1/crates/${encodeURIComponent(pkg.name)}/${pkg.version}`).then(async (response) => {
-				if (response.status === 200) return true;
-				if (response.status === 404) return false;
-				throw new Error(`Unable to validate ${pkg.name}@${pkg.version} against crates.io: ${await response.text()}`);
-			});
-			this.#versionMap.set(cacheKey, info);
-		}
-		return info;
-	}
-	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({ updateLockFile = false, bumpDep: getBumpDepType = ({ kind }) => {
-	switch (kind) {
-		case "dependencies": return "patch";
-		case "build-dependencies":
-		case "dev-dependencies": return false;
-	}
-} } = {}) {
-	function updateRange(range, next) {
-		if (!semver.validRange(range)) return false;
-		if (new semver.Range(range).test(next)) return false;
-		return next;
-	}
-	function depsPolicy({ graph }) {
-		return {
-			id: "cargo:deps",
-			onUpdate({ pkg, plan }) {
-				for (const other of graph.getPackages()) {
-					if (!(other instanceof CargoPackage)) continue;
-					for (const { table, kind } of dependencyTables(other.manifest, "")) for (const [rawName, rawSpec] of Object.entries(table)) {
-						const spec = parseSpec(rawSpec);
-						if (!spec) continue;
-						const packageName = spec.package ?? rawName;
-						if (pkg.id !== `cargo:${packageName}`) continue;
-						if (updateRange(spec.version, plan.bumpVersion(pkg)) === false) continue;
-						const bumpType = getBumpDepType({
-							kind,
-							name: packageName,
-							version: spec.version
-						});
-						if (bumpType === false) continue;
-						this.bumpPackage(other, {
-							type: bumpType,
-							reason: `update dependency "${rawName}"`
-						});
-					}
-				}
-			}
-		};
-	}
+function cargo({ updateLockFile = true, bumpDep: getBumpDepType } = {}) {
+	let active = false;
 	return {
 		name: "cargo",
 		enforce: "pre",
@@ -141,45 +59,113 @@ function cargo({ updateLockFile = false, bumpDep: getBumpDepType = ({ kind }) =>
 		},
 		async resolve() {
 			await discoverCargoPackages(this.cwd, (pkg) => this.graph.add(pkg));
+			active = this.graph.getPackages().some((pkg) => pkg instanceof CargoPackage);
 		},
-		createRegistryClient() {
-			return new CargoRegistryClient(this.graph);
+		initDraft(plan) {
+			if (!active) return;
+			plan.addPolicy(depsPolicy(this, getBumpDepType));
 		},
-		initPlan(plan) {
-			plan.addPolicy(depsPolicy(this));
+		async publishPreflight({ pkg }) {
+			if (!(pkg instanceof CargoPackage)) return;
+			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}`;
+				const linked = this.graph.get(id);
+				if (!linked || !(linked instanceof CargoPackage)) continue;
+				wait.push(id);
+			}
+			return {
+				publish: pkg.packageInfo.publish !== false && !await isPackagePublished(pkg.name, pkg.version),
+				wait
+			};
+		},
+		async publish({ pkg }) {
+			if (!(pkg instanceof CargoPackage)) return;
+			const result = await x("cargo", ["publish"], { nodeOptions: { cwd: pkg.path } });
+			if (result.exitCode !== 0) return {
+				type: "failed",
+				error: execFailure(`Failed to publish ${pkg.name}@${pkg.version}.`, result).message
+			};
+			return { type: "published" };
 		},
-		async applyPlan(draft) {
+		async applyDraft(draft) {
+			if (!active) return;
 			const { graph } = this;
 			const writes = [];
 			for (const pkg of graph.getPackages()) {
 				if (!(pkg instanceof CargoPackage)) continue;
-				const plan = draft.getPackagePlan(pkg.id);
+				const plan = draft.getPackageDraft(pkg.id);
 				if (plan) pkg.setVersion(plan.bumpVersion(pkg));
 			}
 			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) continue;
+					if (!spec || !semver.validRange(spec.version)) continue;
 					const packageName = spec.package ?? rawName;
 					const linked = graph.get(`cargo:${packageName}`);
 					if (!linked || !(linked instanceof CargoPackage)) continue;
-					const result = updateRange(spec.version, linked.version);
-					if (result === false) continue;
-					table[rawName] = spec.setVersion(result);
-					pkg.patch(typeof rawSpec === "string" ? `${tablePath}.${rawName}` : `${tablePath}.${rawName}.version`, result);
+					if (semver.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());
 			}
 			await Promise.all(writes);
 		},
-		cli: { async publishPlanApplied() {
-			if (!updateLockFile) return;
+		cli: { async draftApplied() {
+			if (!active || !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 }) => {
+	switch (kind) {
+		case "dependencies": return "patch";
+		case "build-dependencies":
+		case "dev-dependencies": return false;
+	}
+}) {
+	return {
+		id: "cargo:deps",
+		onUpdate({ pkg, packageDraft: plan }) {
+			if (!(pkg instanceof CargoPackage)) return;
+			const group = graph.getPackageGroup(pkg.id);
+			for (const dependent of graph.getPackages()) {
+				if (!(dependent instanceof CargoPackage)) continue;
+				for (const { table, kind } of dependencyTables(dependent.manifest, "")) for (const [rawName, rawSpec] of Object.entries(table)) {
+					const spec = parseSpec(rawSpec);
+					if (!spec || !semver.validRange(spec.version)) continue;
+					if (pkg.id !== `cargo:${spec.package ?? rawName}`) continue;
+					if (group?.options.syncBump && graph.getPackageGroup(dependent.id) === group) continue;
+					if (semver.satisfies(plan.bumpVersion(pkg), spec.version)) continue;
+					const bumpType = getBumpDepType({
+						kind,
+						name: pkg.name,
+						version: spec.version
+					});
+					if (bumpType === false) continue;
+					this.bumpPackage(dependent, {
+						type: bumpType,
+						reason: `update dependency "${rawName}"`
+					});
+				}
+			}
+		}
+	};
+}
+async function isPackagePublished(name, version) {
+	const response = await fetch(`https://crates.io/api/v1/crates/${encodeURIComponent(name)}/${version}`);
+	if (response.status === 200) return true;
+	if (response.status === 404) return false;
+	throw new Error(`Unable to validate ${name}@${version} against crates.io: ${await response.text()}`);
+}
 async function discoverCargoPackages(cwd, add) {
 	const root = await readCargoManifest(cwd).catch((error) => {
 		if (isNodeError(error) && error.code === "ENOENT") return void 0;
@@ -282,4 +268,4 @@ function stringValue(value) {
 	return typeof value === "string" ? value : void 0;
 }
 //#endregion
-export { CargoPackage, CargoRegistryClient, cargo };
+export { CargoPackage, cargo };

package/dist/providers/npm.d.ts

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

package/dist/providers/npm.js

@@ -1,10 +1,11 @@
 import { i as isNodeError, n as execFailure } from "../error-DNy8R5ue.js";
-import { i as pnpmWorkspaceSchema, r as packageManifestSchema } from "../schemas-CurBAaW5.js";
-import { n as WorkspacePackage } from "../graph-DLKPUXSD.js";
+import { n as packageManifestSchema, r as pnpmWorkspaceSchema } from "../schemas-B7N6EE2k.js";
+import { n as WorkspacePackage } from "../graph-DrzluXw8.js";
 import { readFile, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { x } from "tinyexec";
 import * as semver from "semver";
+import z from "zod";
 import { load } from "js-yaml";
 import { glob } from "tinyglobby";
 import { detect } from "package-manager-detector";
@@ -33,9 +34,8 @@ var NpmPackage = class extends WorkspacePackage {
 	async write() {
 		await writeFile(path.join(this.path, "package.json"), `${JSON.stringify(this.manifest, null, 2)}\n`);
 	}
-	initPlan() {
-		const defaults = super.initPlan();
-		defaults.publish ??= this.manifest.private !== true;
+	initDraft() {
+		const defaults = super.initDraft();
 		if (this.manifest.publishConfig?.tag) {
 			defaults.npm ??= {};
 			defaults.npm.distTag ??= this.manifest.publishConfig.tag;
@@ -43,74 +43,6 @@ var NpmPackage = class extends WorkspacePackage {
 		return defaults;
 	}
 };
-var NpmRegistryClient = class {
-	cwd;
-	client;
-	id = "npm";
-	#versionMap = /* @__PURE__ */ new Map();
-	constructor(cwd, client, _graph) {
-		this.cwd = cwd;
-		this.client = client;
-	}
-	supports(pkg) {
-		return pkg instanceof NpmPackage;
-	}
-	async isPackagePublished(pkg) {
-		const cacheKey = `${pkg.id}@${pkg.version}`;
-		let info = this.#versionMap.get(cacheKey);
-		if (!info) {
-			const run = async () => {
-				const registry = pkg.manifest.publishConfig?.registry;
-				const args = [
-					"view",
-					`${pkg.name}@${pkg.version}`,
-					"version",
-					"--json"
-				];
-				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;
-				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);
-		}
-		return info;
-	}
-	async publish(pkg, { packageStore }) {
-		const distTag = packageStore.npm?.distTag;
-		if (this.client === "bun") {
-			const tarballPath = path.resolve(pkg.path, "pkg.tgz");
-			const packResult = await x("bun", [
-				"pm",
-				"pack",
-				"--filename",
-				tarballPath
-			], { nodeOptions: { cwd: pkg.path } });
-			if (packResult.exitCode !== 0) throw execFailure(`Failed to pack ${pkg.name}@${pkg.version}.`, packResult);
-			const publishArgs = ["publish", tarballPath];
-			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);
-		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 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");
-}
 function parseDependencySpec(context, dependent, name, range) {
 	const { graph } = context;
 	if (range.startsWith("workspace:")) return {
@@ -150,7 +82,11 @@ function formatDependencySpec(spec) {
 	if (spec.protocol === "npm") return `npm:${spec.alias}@${spec.range}`;
 	return spec.range;
 }
-function npm({ client: defaultClient, onBreakPeerDep = "set", updateLockFile = false, bumpDep: getBumpDepType = ({ kind }) => {
+const packageLockSchema = z.object({
+	id: z.string(),
+	distTag: z.string().optional()
+});
+function npm({ client: defaultClient, onBreakPeerDep = "set", updateLockFile = true, bumpDep: getBumpDepType = ({ kind }) => {
 	switch (kind) {
 		case "dependencies":
 		case "optionalDependencies": return "patch";
@@ -160,53 +96,8 @@ function npm({ client: defaultClient, onBreakPeerDep = "set", updateLockFile = f
 			return "major";
 	}
 } } = {}) {
+	let active = false;
 	let client;
-	function depsPolicy(context) {
-		const { graph } = context;
-		function needsUpdate(dependent, spec, target) {
-			if (spec.linked) {
-				const group = graph.getPackageGroup(dependent.id);
-				if (group?.options.syncBump && graph.getPackageGroup(spec.linked.id) === group) return false;
-				if (spec.protocol === "workspace") switch (spec.range) {
-					case "":
-					case "*": return true;
-					case "^":
-					case "~": return !semver.satisfies(target, `${spec.range}${spec.linked.version}`);
-				}
-				if (spec.protocol === "file") return true;
-			}
-			if (spec.protocol === "file" || !semver.validRange(spec.range)) return false;
-			return !semver.satisfies(target, spec.range);
-		}
-		return {
-			id: "npm:deps",
-			onUpdate({ pkg, plan }) {
-				if (!(pkg instanceof NpmPackage)) return;
-				for (const dependent of graph.getPackages()) {
-					if (!(dependent instanceof NpmPackage)) continue;
-					for (const field of DEP_FIELDS) {
-						const dependencies = dependent.manifest[field];
-						if (!dependencies) continue;
-						for (const [k, v] of Object.entries(dependencies)) {
-							const spec = parseDependencySpec(context, dependent, k, v);
-							if (!spec || spec.linked !== pkg) continue;
-							if (!needsUpdate(dependent, spec, plan.bumpVersion(pkg))) continue;
-							const bumpType = getBumpDepType({
-								kind: field,
-								spec,
-								name: k
-							});
-							if (bumpType === false) continue;
-							this.bumpPackage(dependent, {
-								type: bumpType,
-								reason: `update dependency "${k}"`
-							});
-						}
-					}
-				}
-			}
-		};
-	}
 	return {
 		name: "npm",
 		enforce: "pre",
@@ -217,19 +108,87 @@ function npm({ client: defaultClient, onBreakPeerDep = "set", updateLockFile = f
 		},
 		async resolve() {
 			await discoverNpmPackages(this.cwd, (pkg) => this.graph.add(pkg));
+			active = this.graph.getPackages().some((pkg) => pkg instanceof NpmPackage);
+		},
+		async publishPreflight({ pkg }) {
+			if (!(pkg instanceof NpmPackage)) return;
+			if (pkg.manifest.private === true) return { publish: false };
+			const registry = pkg.manifest.publishConfig?.registry;
+			const base = (registry ?? "https://registry.npmjs.org").replace(/\/$/, "");
+			const response = await fetch(`${base}/${pkg.name}/${pkg.version}`, { headers: { Accept: "application/json" } });
+			if (response.status === 404) return { publish: true };
+			if (!response.ok) throw new Error(`Unable to validate ${pkg.name}@${pkg.version} against the npm registry${registry ? ` "${registry}"` : ""}.`);
+			return { publish: false };
+		},
+		initPublishLock({ lock, draft }) {
+			for (const [id, pkg] of draft.getPackageDrafts()) {
+				if (!pkg.npm) continue;
+				lock.write("npm:packages", {
+					id,
+					distTag: pkg.npm.distTag
+				});
+			}
+		},
+		initPublishPlan({ lock, plan }) {
+			let data;
+			while (data = lock.read("npm:packages")) {
+				const parsed = packageLockSchema.safeParse(data).data;
+				if (!parsed) continue;
+				const packagePlan = plan.packages.get(parsed.id);
+				if (!packagePlan) continue;
+				packagePlan.npm = { distTag: parsed.distTag };
+			}
 		},
-		createRegistryClient() {
-			return new NpmRegistryClient(this.cwd, client, this.graph);
+		async publish({ pkg, plan }) {
+			if (!(pkg instanceof NpmPackage)) return;
+			const distTag = plan.packages.get(pkg.id).npm?.distTag;
+			if (client === "bun") {
+				const tarballPath = path.resolve(pkg.path, "pkg.tgz");
+				const packResult = await x("bun", [
+					"pm",
+					"pack",
+					"--filename",
+					tarballPath
+				], { nodeOptions: { cwd: pkg.path } });
+				if (packResult.exitCode !== 0) return {
+					type: "failed",
+					error: execFailure(`Failed to pack ${pkg.name}@${pkg.version}.`, packResult).message
+				};
+				const publishArgs = ["publish", tarballPath];
+				if (distTag) publishArgs.push("--tag", distTag);
+				const publishResult = await x("npm", publishArgs, { nodeOptions: { cwd: pkg.path } });
+				if (publishResult.exitCode !== 0) return {
+					type: "failed",
+					error: execFailure(`Failed to publish ${pkg.name}@${pkg.version}${distTag ? ` with dist-tag "${distTag}"` : ""}.`, publishResult).message
+				};
+				return { type: "published" };
+			}
+			let command;
+			const args = ["publish"];
+			if (distTag) args.push("--tag", distTag);
+			if (client === "pnpm") {
+				command = "pnpm";
+				args.push("--no-git-checks");
+			} else if (client === "yarn") command = "yarn";
+			else command = "npm";
+			const result = await x(command, args, { nodeOptions: { cwd: pkg.path } });
+			if (result.exitCode !== 0) return {
+				type: "failed",
+				error: execFailure(`Failed to publish ${pkg.name}@${pkg.version}${distTag ? ` with dist-tag "${distTag}"` : ""}.`, result).message
+			};
+			return { type: "published" };
 		},
-		initPlan(plan) {
-			plan.addPolicy(depsPolicy(this));
+		initDraft(plan) {
+			if (!active) return;
+			plan.addPolicy(depsPolicy(this, getBumpDepType));
 		},
-		async applyPlan(draft) {
+		async applyDraft(draft) {
+			if (!active) return;
 			const { graph } = this;
 			const writes = [];
 			for (const pkg of graph.getPackages()) {
 				if (!(pkg instanceof NpmPackage)) continue;
-				const plan = draft.getPackagePlan(pkg.id);
+				const plan = draft.getPackageDraft(pkg.id);
 				if (plan) pkg.manifest.version = plan.bumpVersion(pkg);
 			}
 			for (const pkg of graph.getPackages()) {
@@ -260,8 +219,8 @@ function npm({ client: defaultClient, onBreakPeerDep = "set", updateLockFile = f
 			}
 			await Promise.all(writes);
 		},
-		cli: { async publishPlanApplied() {
-			if (!updateLockFile) return;
+		cli: { async draftApplied() {
+			if (!active || !updateLockFile) return;
 			let args;
 			if (client === "npm") args = ["ci"];
 			else if (client === "yarn") args = ["install", "--immutable"];
@@ -272,6 +231,50 @@ function npm({ client: defaultClient, onBreakPeerDep = "set", updateLockFile = f
 		} }
 	};
 }
+function depsPolicy(context, getBumpDepType) {
+	const { graph } = context;
+	function needsUpdate(spec, target) {
+		if (spec.linked && spec.protocol === "workspace") switch (spec.range) {
+			case "":
+			case "*": return true;
+			case "^":
+			case "~": return !semver.satisfies(target, `${spec.range}${spec.linked.version}`);
+		}
+		if (spec.linked && spec.protocol === "file") return true;
+		if (spec.protocol === "file" || !semver.validRange(spec.range)) return false;
+		return !semver.satisfies(target, spec.range);
+	}
+	return {
+		id: "npm:deps",
+		onUpdate({ pkg, packageDraft: plan }) {
+			if (!(pkg instanceof NpmPackage)) return;
+			const group = graph.getPackageGroup(pkg.id);
+			for (const dependent of graph.getPackages()) {
+				if (!(dependent instanceof NpmPackage)) continue;
+				for (const field of DEP_FIELDS) {
+					const dependencies = dependent.manifest[field];
+					if (!dependencies) continue;
+					for (const [k, v] of Object.entries(dependencies)) {
+						const spec = parseDependencySpec(context, dependent, k, v);
+						if (!spec || spec.linked !== pkg) continue;
+						if (group?.options.syncBump && graph.getPackageGroup(dependent.id) === group) continue;
+						if (!needsUpdate(spec, plan.bumpVersion(pkg))) continue;
+						const bumpType = getBumpDepType({
+							kind: field,
+							spec,
+							name: k
+						});
+						if (bumpType === false) continue;
+						this.bumpPackage(dependent, {
+							type: bumpType,
+							reason: `update dependency "${k}"`
+						});
+					}
+				}
+			}
+		}
+	};
+}
 async function discoverNpmPackages(cwd, add) {
 	let patterns;
 	const rootManifest = await readManifest(cwd).catch(() => void 0);
@@ -311,4 +314,4 @@ async function readManifest(packagePath) {
 	return parsed;
 }
 //#endregion
-export { NpmPackage, NpmRegistryClient, npm };
+export { NpmPackage, npm };

package/dist/schemas-B7N6EE2k.js

@@ -0,0 +1,26 @@
+import { z as z$1 } from "zod";
+//#region src/schemas.ts
+const stringRecordSchema = z$1.record(z$1.string(), z$1.string());
+const bumpTypeSchema = z$1.enum([
+	"major",
+	"minor",
+	"patch"
+]);
+const pnpmWorkspaceSchema = z$1.looseObject({ packages: z$1.array(z$1.string()).optional() });
+const packageManifestSchema = z$1.looseObject({
+	name: z$1.string(),
+	version: z$1.string().optional(),
+	private: z$1.boolean().optional(),
+	publishConfig: z$1.looseObject({
+		access: z$1.enum(["public", "restricted"]).optional(),
+		registry: z$1.string().optional(),
+		tag: z$1.string().optional()
+	}).optional(),
+	workspaces: z$1.array(z$1.string()).optional(),
+	dependencies: stringRecordSchema.optional(),
+	devDependencies: stringRecordSchema.optional(),
+	peerDependencies: stringRecordSchema.optional(),
+	optionalDependencies: stringRecordSchema.optional()
+});
+//#endregion
+export { packageManifestSchema as n, pnpmWorkspaceSchema as r, bumpTypeSchema as t };