tegami 1.1.0 → 1.1.2

package/dist/npm-Cj685Ddn.js

@@ -1,681 +0,0 @@
-import { c as somePromise, i as isNodeError, n as execFailure, r as handlePluginError, s as joinPath } from "./error-BhMYq9iW.js";
-import { n as WorkspacePackage } from "./graph-BmXTJZxx.js";
-import { a as parseChangelogFile, i as parsePublishLock, r as packageStoreSchema, t as changelogStoreSchema } from "./draft-BLbt4bSG.js";
-import fs, { readFile, writeFile } from "node:fs/promises";
-import path, { join } from "node:path";
-import { x } from "tinyexec";
-import * as semver$1 from "semver";
-import z from "zod";
-import { load } from "js-yaml";
-import { glob } from "tinyglobby";
-import { detect } from "package-manager-detector";
-import { tmpdir } from "node:os";
-import { intro, note, outro } from "@clack/prompts";
-//#region src/providers/npm/schema.ts
-const stringRecordSchema = z.record(z.string(), z.string());
-const pnpmWorkspaceSchema = z.looseObject({ packages: z.array(z.string()).optional() });
-const packageManifestSchema = z.looseObject({
-	name: z.string(),
-	version: z.string().optional(),
-	private: z.boolean().optional(),
-	publishConfig: z.looseObject({
-		access: z.enum(["public", "restricted"]).optional(),
-		registry: z.string().optional(),
-		tag: z.string().optional()
-	}).optional(),
-	scripts: z.record(z.string(), z.string()).optional(),
-	workspaces: z.array(z.string()).optional(),
-	dependencies: stringRecordSchema.optional(),
-	devDependencies: stringRecordSchema.optional(),
-	peerDependencies: stringRecordSchema.optional(),
-	optionalDependencies: stringRecordSchema.optional()
-});
-//#endregion
-//#region src/plans/publish.ts
-async function initPublishPlan(context, options) {
-	let lock;
-	try {
-		lock = parsePublishLock(await fs.readFile(context.lockPath, "utf8"));
-	} catch {
-		return;
-	}
-	let data;
-	const packages = /* @__PURE__ */ new Map();
-	const changelogs = /* @__PURE__ */ new Map();
-	while (data = lock.read("core:changelogs")) {
-		const entry = changelogStoreSchema.safeParse(data).data;
-		if (!entry) continue;
-		const parsed = parseChangelogFile(entry.filename, entry.content);
-		if (!parsed) continue;
-		changelogs.set(parsed.id, parsed);
-	}
-	while (data = lock.read("core:packages")) {
-		const parsed = packageStoreSchema.safeParse(data).data;
-		if (!parsed) continue;
-		if (!context.graph.get(parsed.id)) continue;
-		const pkgChangelogs = [];
-		for (const id of parsed.changelogIds ?? []) {
-			const entry = changelogs.get(id);
-			if (entry) pkgChangelogs.push(entry);
-		}
-		packages.set(parsed.id, {
-			changelogs: pkgChangelogs,
-			updated: parsed.updated
-		});
-	}
-	const plan = {
-		options,
-		changelogs,
-		packages
-	};
-	for (const plugin of context.plugins) await handlePluginError(plugin, "initPublishPlan", () => plugin.initPublishPlan?.call(context, {
-		lock,
-		plan
-	}));
-	return plan;
-}
-function resolvePublishTargets(plan) {
-	const ordered = [];
-	const scanned = /* @__PURE__ */ new Set();
-	function scan(id, stack) {
-		const preflight = plan.packages.get(id)?.preflight;
-		if (!preflight || !preflight.shouldPublish) return;
-		if (stack.has(id)) throw new Error(`circular reference of deps: ${[...stack, id].join(" -> ")}`);
-		if (scanned.has(id)) return;
-		if (preflight.wait) {
-			stack.add(id);
-			for (const dep of preflight.wait) scan(dep, stack);
-			stack.delete(id);
-		}
-		ordered.push(id);
-		scanned.add(id);
-	}
-	const stack = /* @__PURE__ */ new Set();
-	for (const id of plan.packages.keys()) scan(id, stack);
-	return ordered;
-}
-async function runPublishPlan(context, plan) {
-	const { dryRun = false } = plan.options;
-	const onPublishResult = async (pkg, publishResult) => {
-		const packagePlan = plan.packages.get(pkg.id);
-		if (!packagePlan) return;
-		packagePlan.publishResult = publishResult;
-		if (publishResult.type === "skipped") return;
-		for (const plugin of context.plugins) await handlePluginError(plugin, "afterPublish", () => plugin.afterPublish?.call(context, {
-			pkg,
-			plan
-		}));
-	};
-	publishLoop: for (const id of resolvePublishTargets(plan)) {
-		const pkg = context.graph.get(id);
-		if (dryRun) {
-			await onPublishResult(pkg, { type: "published" });
-			continue;
-		}
-		for (const plugin of context.plugins) if (await handlePluginError(plugin, "willPublish", () => plugin.willPublish?.call(context, { pkg })) === false) continue publishLoop;
-		for (const plugin of context.plugins) {
-			const publishResult = await handlePluginError(plugin, "publish", () => plugin.publish?.call(context, {
-				pkg,
-				plan
-			}));
-			if (publishResult) {
-				await onPublishResult(pkg, publishResult);
-				continue publishLoop;
-			}
-		}
-		await onPublishResult(pkg, {
-			type: "failed",
-			error: `There is no plugin to publish package "${pkg.id}", please make sure the package has a supported provider plugin.`
-		});
-	}
-	for (const packagePlan of plan.packages.values()) packagePlan.publishResult ??= { type: "skipped" };
-	for (const plugin of context.plugins) await handlePluginError(plugin, "afterPublishAll", () => plugin.afterPublishAll?.call(context, { plan }));
-}
-async function runPreflights(context, plan) {
-	const promises = [];
-	for (const [id, packagePlan] of plan.packages) {
-		const pkg = context.graph.get(id);
-		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) {
-		const status = await handlePluginError(plugin, "resolvePlanStatus", () => plugin.resolvePlanStatus?.call(context, { plan }));
-		if (Array.isArray(status) && await somePromise(status, (v) => v === "pending")) return "pending";
-		if (status === "pending") return "pending";
-	}
-	return "success";
-}
-//#endregion
-//#region src/providers/npm/cli.ts
-const PLACEHOLDER_VERSION = "0.0.0-tegami-trusted-publish-setup";
-const PLACEHOLDER_DIST_TAG = "temp";
-const PROJECT_FLAG = {
-	gitlab: "--project",
-	github: "--repo"
-};
-function registerNpmCli(cli, options) {
-	cli.command("npm pretrust", { description: "publish empty placeholder packages and configure npm trusted publishing for new packages" }).option("dry-run", {
-		type: "boolean",
-		description: "show packages that would be configured without publishing"
-	}).action(async ({ context, values }) => {
-		intro("npm pretrust");
-		if (!context.graph.getPackages().some((pkg) => pkg instanceof NpmPackage)) throw new Error("No npm packages found in the workspace.");
-		const dryRun = values["dry-run"] ?? false;
-		let repo;
-		if (options.provider === "github") {
-			if (!context.github?.repo) throw new Error("The GitHub plugin must be configured with `repo` specified.");
-			repo = context.github.repo;
-		} else if (options.provider === "gitlab") {
-			if (!context.gitlab?.repo) throw new Error("The GitLab plugin must be configured with `repo` specified.");
-			repo = context.gitlab.repo;
-		} else throw new Error(`Invalid npm trusted publishing provider: ${options.provider}`);
-		const targets = await resolvePretrustTargets(context);
-		if (targets.length === 0) {
-			outro("All publishable packages in the publish lock already exist on npm.");
-			return;
-		}
-		const prepareLines = ["Make sure to run login command first, it will publish empty packages."];
-		for (const pkg of targets) prepareLines.push(`${pkg.name}: will publish a placeholder under dist-tag "${PLACEHOLDER_DIST_TAG}", then configure trusted publishing.`);
-		note(prepareLines.join("\n"), dryRun ? "Dry run" : "Configure trusted publishing");
-		const lines = [];
-		let lock;
-		if (!dryRun) try {
-			lock = parsePublishLock(await fs.readFile(context.lockPath, "utf8"));
-		} catch {}
-		for (const pkg of targets) {
-			if (dryRun) {
-				lines.push(`would configure ${pkg.name} (placeholder ${PLACEHOLDER_VERSION}@${PLACEHOLDER_DIST_TAG})`);
-				continue;
-			}
-			await publishPlaceholder(pkg);
-			await npmTrust(context, pkg, options, repo);
-			lines.push(`configured ${pkg.name} (placeholder ${PLACEHOLDER_VERSION}@${PLACEHOLDER_DIST_TAG})`);
-			lock?.write("npm:mark-latest", { id: pkg.id });
-		}
-		if (lock) await fs.writeFile(context.lockPath, lock.serialize());
-		note(lines.join("\n"), "Result");
-		outro(dryRun ? "Dry run complete. Re-run without --dry-run to publish placeholders and configure trusted publishing." : "Trusted publishing configured. CI can now publish real package versions with OIDC.");
-	});
-}
-async function resolvePretrustTargets(context) {
-	const plan = await initPublishPlan(context, {});
-	if (!plan) throw new Error(`No publish lock found at ${context.lockPath}. Run "tegami version" before configuring trusted publishing.`);
-	await runPreflights(context, plan);
-	return (await Promise.all(Array.from(plan.packages, async ([id, { preflight }]) => {
-		if (!preflight?.shouldPublish) return;
-		const pkg = context.graph.get(id);
-		if (!pkg || !(pkg instanceof NpmPackage)) return;
-		if (await isPackageOnRegistry(pkg.name, pkg.getRegistry())) return;
-		return pkg;
-	}))).filter((pkg) => pkg !== void 0);
-}
-async function isPackageOnRegistry(name, registry = "https://registry.npmjs.org") {
-	const response = await fetch(joinPath(registry, name), { headers: { Accept: "application/json" } });
-	if (response.status === 404) return false;
-	if (!response.ok) throw new Error(`Unable to check whether ${name} exists on the npm registry${registry ? ` "${registry}"` : ""}.`);
-	return true;
-}
-async function publishPlaceholder(pkg) {
-	const registry = pkg.getRegistry();
-	const access = pkg.manifest.publishConfig?.access;
-	const dir = await fs.mkdtemp(join(tmpdir(), "tegami-npm-placeholder-"));
-	try {
-		await fs.writeFile(join(dir, "package.json"), `${JSON.stringify({
-			name: pkg.name,
-			version: PLACEHOLDER_VERSION,
-			description: "Placeholder published by Tegami for npm trusted publishing setup."
-		}, null, 2)}\n`);
-		await fs.writeFile(join(dir, "README.md"), `# Placeholder package
-
-This empty package was published by [Tegami](https://tegami.fuma-nama.dev) to configure npm trusted publishing.
-
-The real package contents will be published via CI with OIDC.
-`);
-		const args = [
-			"publish",
-			"--tag",
-			PLACEHOLDER_DIST_TAG,
-			"--ignore-scripts",
-			"--registry",
-			registry
-		];
-		if (access) args.push("--access", access);
-		const result = await x("npm", args, { nodeOptions: {
-			cwd: dir,
-			stdio: "inherit"
-		} });
-		if (result.exitCode !== 0) {
-			const hint = result.stderr.includes("EOTP") ? " Complete npm 2FA in the terminal, or publish with an OTP-capable session." : "";
-			throw execFailure(`Failed to publish placeholder ${pkg.name}@${PLACEHOLDER_VERSION} with dist-tag "${PLACEHOLDER_DIST_TAG}".${hint}`, result);
-		}
-	} finally {
-		await fs.rm(dir, {
-			recursive: true,
-			force: true
-		});
-	}
-}
-async function npmTrust(context, pkg, options, repo) {
-	const result = await x("npm", [
-		"trust",
-		options.provider,
-		pkg.name,
-		PROJECT_FLAG[options.provider],
-		repo,
-		"--file",
-		options.workflow,
-		"--allow-publish",
-		"-y",
-		"--registry",
-		pkg.getRegistry()
-	], { nodeOptions: {
-		cwd: context.cwd,
-		stdio: "inherit"
-	} });
-	if (result.exitCode !== 0) {
-		const hint = result.stderr.includes("EOTP") ? " Complete npm 2FA in the terminal when prompted." : "";
-		throw execFailure(`Failed to configure trusted publishing for ${pkg.name}.${hint}`, result);
-	}
-}
-//#endregion
-//#region src/providers/npm.ts
-const DEP_FIELDS = [
-	"dependencies",
-	"devDependencies",
-	"peerDependencies",
-	"optionalDependencies"
-];
-var NpmPackage = class extends WorkspacePackage {
-	path;
-	manifest;
-	manager = "npm";
-	constructor(path, manifest) {
-		super();
-		this.path = path;
-		this.manifest = manifest;
-	}
-	get name() {
-		return this.manifest.name;
-	}
-	get version() {
-		return this.manifest.version;
-	}
-	async write() {
-		await writeFile(path.join(this.path, "package.json"), `${JSON.stringify(this.manifest, null, 2)}\n`);
-	}
-	initDraft() {
-		const defaults = super.initDraft();
-		defaults.npm = { distTag: this.manifest.publishConfig?.tag };
-		return defaults;
-	}
-	getRegistry() {
-		return this.manifest.publishConfig?.registry ?? "https://registry.npmjs.org";
-	}
-	configureDraft({ draft }) {
-		super.configureDraft({ draft });
-		const { distTag = this.group?.options?.npm?.distTag } = this.options.npm ?? {};
-		if (distTag) {
-			draft.npm ??= {};
-			draft.npm.distTag = distTag;
-		} else if (draft.prerelease) {
-			draft.npm ??= {};
-			draft.npm.distTag ??= draft.prerelease;
-		}
-	}
-};
-function parseDependencySpec(context, dependent, name, range) {
-	const { graph } = context;
-	if (range.startsWith("workspace:")) return {
-		range: range.slice(10),
-		linked: graph.get(`npm:${name}`),
-		protocol: "workspace"
-	};
-	if (range.startsWith("file:")) {
-		let target = path.resolve(dependent.path, range.slice(5));
-		if (path.basename(target) === "package.json") target = path.dirname(target);
-		return {
-			protocol: "file",
-			raw: range,
-			linked: graph.getPackages().find((pkg) => pkg instanceof NpmPackage && pkg.path === target)
-		};
-	}
-	if (range.startsWith("npm:")) {
-		const spec = range.slice(4);
-		const separator = spec.lastIndexOf("@");
-		if (separator <= 0) return;
-		const alias = spec.slice(0, separator);
-		return {
-			alias,
-			linked: graph.get(`npm:${alias}`),
-			range: spec.slice(separator + 1),
-			protocol: "npm"
-		};
-	}
-	return {
-		linked: graph.get(`npm:${name}`),
-		range
-	};
-}
-function formatDependencySpec(spec) {
-	if (spec.protocol === "workspace") return `workspace:${spec.range}`;
-	if (spec.protocol === "file") return spec.raw;
-	if (spec.protocol === "npm") return `npm:${spec.alias}@${spec.range}`;
-	return spec.range;
-}
-const packageLockSchema = z.object({
-	id: z.string(),
-	distTag: z.string().optional()
-});
-const markLatestLockSchema = z.object({ id: z.string() });
-function npm({ client: defaultClient, onBreakPeerDep = "set", updateLockFile = true, trustedPublish, bumpDep: getBumpDepType = ({ kind }) => {
-	switch (kind) {
-		case "dependencies":
-		case "optionalDependencies": return "patch";
-		case "devDependencies": return false;
-		case "peerDependencies":
-			if (onBreakPeerDep === "ignore") return false;
-			return "major";
-	}
-} } = {}) {
-	let active = false;
-	let client;
-	return {
-		name: "npm",
-		enforce: "pre",
-		async init() {
-			if (defaultClient) client = defaultClient;
-			else client = (await detect({ cwd: this.cwd }))?.name ?? "npm";
-			this.npm = { client };
-		},
-		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;
-			return { shouldPublish: pkg.version !== void 0 && pkg.manifest.private !== true };
-		},
-		resolvePlanStatus({ plan }) {
-			if (!active) return;
-			return Array.from(plan.packages, async ([id, { preflight }]) => {
-				if (!preflight.shouldPublish) return;
-				const pkg = this.graph.get(id);
-				if (!(pkg instanceof NpmPackage) || !pkg.version) return;
-				if (!await isPackagePublished(pkg.name, pkg.version, pkg.getRegistry())) return "pending";
-			});
-		},
-		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 };
-			}
-			while (data = lock.read("npm:mark-latest")) {
-				const parsed = markLatestLockSchema.safeParse(data).data;
-				if (!parsed) continue;
-				const packagePlan = plan.packages.get(parsed.id);
-				if (!packagePlan) continue;
-				packagePlan.npm ??= {};
-				packagePlan.npm.markLatest = true;
-			}
-		},
-		async publish({ pkg, plan }) {
-			if (!(pkg instanceof NpmPackage)) return;
-			const { distTag, markLatest } = plan.packages.get(pkg.id)?.npm ?? {};
-			const result = await publish(client, pkg, distTag);
-			if (result.type === "published" && markLatest) {
-				const tagResult = await x("npm", [
-					"dist-tag",
-					"add",
-					`${pkg.name}@${pkg.version}`,
-					"latest",
-					"--registry",
-					pkg.getRegistry()
-				], { nodeOptions: { cwd: pkg.path } });
-				if (tagResult.exitCode !== 0) return {
-					type: "failed",
-					error: execFailure("Failed to mark package as latest", tagResult).message
-				};
-			}
-			return result;
-		},
-		initDraft(plan) {
-			if (!active) return;
-			plan.addPolicy(depsPolicy(this, getBumpDepType));
-		},
-		async applyDraft(draft) {
-			if (!active) return;
-			const { graph } = this;
-			const writes = [];
-			for (const pkg of graph.getPackages()) {
-				if (!(pkg instanceof NpmPackage)) continue;
-				const bumped = draft.getPackageDraft(pkg.id)?.bumpVersion(pkg);
-				if (bumped) pkg.manifest.version = bumped;
-			}
-			for (const pkg of graph.getPackages()) {
-				if (!(pkg instanceof NpmPackage)) continue;
-				for (const field of DEP_FIELDS) {
-					const dependencies = pkg.manifest[field];
-					if (!dependencies) continue;
-					for (const [k, v] of Object.entries(dependencies)) {
-						const spec = parseDependencySpec(this, pkg, k, v);
-						if (!spec?.linked || spec.protocol === "workspace" || spec.protocol === "file") continue;
-						if (!semver$1.validRange(spec.range)) continue;
-						if (!spec.linked.version || semver$1.satisfies(spec.linked.version, spec.range)) continue;
-						let updatedRange;
-						const isPeer = field === "peerDependencies";
-						if (isPeer && onBreakPeerDep === "ignore") continue;
-						if (isPeer && onBreakPeerDep === "set") updatedRange = spec.linked.version;
-						else if (isPeer && onBreakPeerDep === "error") throw new Error(`[Tegami] the version of "${spec.linked.name}" is beyond its peer dependency constraint "${v}" in package "${pkg.name}", please update the constraint to satisfy.`);
-						else if (spec.range.startsWith("^")) updatedRange = `^${spec.linked.version}`;
-						else if (spec.range.startsWith("~")) updatedRange = `~${spec.linked.version}`;
-						else updatedRange = spec.linked.version;
-						dependencies[k] = formatDependencySpec({
-							...spec,
-							range: updatedRange
-						});
-					}
-				}
-				writes.push(pkg.write());
-			}
-			await Promise.all(writes);
-		},
-		async applyCliDraft() {
-			if (!active || !updateLockFile) return;
-			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);
-		},
-		initCli(cli) {
-			if (!trustedPublish) return;
-			registerNpmCli(cli, trustedPublish);
-		}
-	};
-}
-function depsPolicy(context, getBumpDepType) {
-	const { graph } = context;
-	const dependentMap = /* @__PURE__ */ new Map();
-	for (const pkg of graph.getPackages()) {
-		if (!(pkg instanceof NpmPackage)) continue;
-		for (const kind of DEP_FIELDS) {
-			const dependencies = pkg.manifest[kind];
-			if (!dependencies) continue;
-			for (const [name, range] of Object.entries(dependencies)) {
-				const spec = parseDependencySpec(context, pkg, name, range);
-				if (!spec?.linked) continue;
-				const refs = dependentMap.get(spec.linked.id);
-				if (refs) refs.push({
-					dependent: pkg,
-					kind,
-					name,
-					spec
-				});
-				else dependentMap.set(spec.linked.id, [{
-					dependent: pkg,
-					kind,
-					name,
-					spec
-				}]);
-			}
-		}
-	}
-	function needsUpdate(spec, target) {
-		if (spec.linked && spec.protocol === "workspace") switch (spec.range) {
-			case "":
-			case "*": return true;
-			case "^":
-			case "~": return !semver$1.satisfies(target, `${spec.range}${spec.linked.version}`);
-		}
-		if (spec.linked && spec.protocol === "file") return true;
-		if (spec.protocol === "file" || !semver$1.validRange(spec.range)) return false;
-		return !semver$1.satisfies(target, spec.range);
-	}
-	return {
-		id: "npm:deps",
-		onUpdate({ pkg, packageDraft: plan }) {
-			if (!(pkg instanceof NpmPackage)) return;
-			const deps = dependentMap.get(pkg.id);
-			if (!deps) return;
-			const bumped = plan.bumpVersion(pkg);
-			if (!bumped) return;
-			for (const dep of deps) {
-				if (pkg.group?.options.syncBump && dep.dependent.group === pkg.group) continue;
-				if (!needsUpdate(dep.spec, bumped)) continue;
-				const bumpType = getBumpDepType(dep);
-				if (bumpType === false) continue;
-				this.bumpPackage(dep.dependent, {
-					type: bumpType,
-					reason: `update dependency "${dep.name}"`
-				});
-			}
-		}
-	};
-}
-async function publish(client, pkg, distTag) {
-	if (!pkg.version || await isPackagePublished(pkg.name, pkg.version, pkg.getRegistry())) return { type: "skipped" };
-	if (client === "bun") {
-		for (const script of [
-			"prepublishOnly",
-			"prepack",
-			"prepare"
-		]) {
-			if (!pkg.manifest.scripts?.[script]) continue;
-			const result = await x("bun", ["run", script], { nodeOptions: { cwd: pkg.path } });
-			if (result.exitCode === 0) continue;
-			return {
-				type: "failed",
-				error: execFailure(`Failed to run ${script} script for ${pkg.name}@${pkg.version}.`, result).message
-			};
-		}
-		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" };
-}
-async function isPackagePublished(name, version, registry) {
-	const response = await fetch(joinPath(registry, name, version), { headers: { Accept: "application/json" } });
-	if (response.status === 404) return false;
-	if (!response.ok) throw new Error(`Unable to validate ${name}@${version} against the npm registry${registry ? ` "${registry}"` : ""}.`);
-	return true;
-}
-async function discoverNpmPackages(cwd, add) {
-	const rootManifest = await readManifest(cwd).catch(() => void 0);
-	const pnpmPatterns = await readFile(path.join(cwd, "pnpm-workspace.yaml"), "utf8").then((content) => pnpmWorkspaceSchema.parse(load(content) ?? {})).catch((error) => {
-		if (isNodeError(error) && error.code === "ENOENT") return void 0;
-		throw error;
-	});
-	if (rootManifest?.name) add(new NpmPackage(cwd, rootManifest));
-	const patterns = pnpmPatterns?.packages ?? rootManifest?.workspaces;
-	if (!patterns || patterns.length === 0) return;
-	const candidatePaths = await expandWorkspacePatterns(cwd, patterns);
-	const manifests = await Promise.all(candidatePaths.map((path) => readManifest(path).then((manifest) => ({
-		path,
-		manifest
-	})).catch(() => void 0)));
-	for (const entry of manifests) {
-		if (!entry) continue;
-		add(new NpmPackage(entry.path, entry.manifest));
-	}
-}
-async function expandWorkspacePatterns(cwd, patterns) {
-	if (patterns.length === 0) return [];
-	return (await glob(patterns, {
-		absolute: true,
-		cwd,
-		ignore: ["**/node_modules/**", "**/dist/**"],
-		onlyDirectories: true,
-		onlyFiles: false
-	})).map((item) => {
-		return item.endsWith(path.sep) ? item.slice(0, -1) : item;
-	});
-}
-async function readManifest(packagePath) {
-	const content = await readFile(path.join(packagePath, "package.json"), "utf8");
-	const parsed = JSON.parse(content);
-	packageManifestSchema.parse(parsed);
-	return parsed;
-}
-//#endregion
-export { runPreflights as a, publishPlanStatus as i, npm as n, runPublishPlan as o, initPublishPlan as r, NpmPackage as t };