tegami 0.0.1 → 0.1.0-beta.1

package/dist/context-CC36jtz1.d.mts

@@ -1,297 +0,0 @@
-import * as semver from "semver";
-import { SemVer } from "semver";
-import { z } from "zod";
-
-//#region src/utils/semver.d.ts
-type BumpType = "major" | "minor" | "patch";
-//#endregion
-//#region src/changelog/parse.d.ts
-interface ChangelogEntry {
-  id: string;
-  /** file name like `my-change.md` */
-  filename: string;
-  subject?: string;
-  packages: Set<string>;
-  type: BumpType;
-  title: string;
-  content: string;
-}
-//#endregion
-//#region src/draft.d.ts
-/** Per-package options applied when creating publish plans. */
-interface PackageOptions {
-  /** npm dist-tag used when publishing. */
-  distTag?: string;
-  /** Set to false to keep this package out of npm publishing. */
-  publish?: boolean;
-}
-interface PackagePlan {
-  type: BumpType;
-  changelogIds: Set<string>;
-  distTag?: string;
-  publish: boolean;
-}
-declare class DraftPlan {
-  #private;
-  private readonly changelogs;
-  private readonly packages;
-  private readonly context;
-  constructor(changelogs: Map<string, ChangelogEntry>, packages: Map<string, PackagePlan>, context: TegamiContext);
-  getPackageIds(): string[];
-  getPackage(id: string): PackagePlan | undefined;
-  setPackage(id: string, plan?: Partial<PackagePlan>): void;
-  deletePackage(id: string): boolean;
-  getChangelogIds(): string[];
-  getChangelog(id: string): ChangelogEntry | undefined;
-  setChangelog(id: string, entry: ChangelogEntry): void;
-  deleteChangelog(id: string): boolean;
-  /** Write the publish plan, update package versions, and consume changelog files. */
-  createPublishPlan(): Promise<void>;
-  editable(): boolean;
-  private assertPublishPlanFinished;
-  private applyVersionChanges;
-  private removeConsumedChangelogs;
-  private assertEditable;
-  private appendChangelog;
-  /** {@link createPublishPlan} but for `await using` syntax */
-  [Symbol.asyncDispose](): Promise<void>;
-}
-//#endregion
-//#region src/schemas.d.ts
-declare const packageManifestSchema: z.ZodObject<{
-  name: z.ZodOptional<z.ZodString>;
-  version: z.ZodOptional<z.ZodString>;
-  private: z.ZodOptional<z.ZodBoolean>;
-  publishConfig: z.ZodOptional<z.ZodObject<{
-    access: z.ZodOptional<z.ZodEnum<{
-      public: "public";
-      restricted: "restricted";
-    }>>;
-    registry: z.ZodOptional<z.ZodString>;
-    tag: z.ZodOptional<z.ZodString>;
-  }, z.core.$loose>>;
-  workspaces: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodPipe<z.ZodObject<{
-    packages: z.ZodOptional<z.ZodArray<z.ZodString>>;
-  }, z.core.$loose>, z.ZodTransform<string[], {
-    [x: string]: unknown;
-    packages?: string[] | undefined;
-  }>>]>, z.ZodArray<z.ZodString>>>;
-  dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-  devDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-  peerDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-  optionalDependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-}, z.core.$loose>;
-type PackageManifest = z.infer<typeof packageManifestSchema>;
-/** the persisted plan data for actual publishing */
-declare const planStoreSchema: z.ZodCodec<z.ZodString, z.ZodObject<{
-  id: z.ZodString;
-  createdAt: z.ZodISODateTime;
-  changelogs: z.ZodRecord<z.ZodString, z.ZodObject<{
-    filename: z.ZodString;
-    subject: z.ZodOptional<z.ZodString>;
-    packages: z.ZodArray<z.ZodString>;
-    type: z.ZodEnum<{
-      major: "major";
-      minor: "minor";
-      patch: "patch";
-    }>;
-    title: z.ZodString;
-    content: z.ZodString;
-  }, z.core.$strip>>;
-  packages: z.ZodRecord<z.ZodString, z.ZodObject<{
-    type: z.ZodEnum<{
-      major: "major";
-      minor: "minor";
-      patch: "patch";
-    }>;
-    changelogIds: z.ZodCodec<z.ZodArray<z.ZodString>, z.ZodSet<z.ZodString>>;
-    distTag: z.ZodOptional<z.ZodString>;
-    publish: z.ZodBoolean;
-  }, z.core.$strip>>;
-}, z.core.$strip>>;
-type PlanStore = z.output<typeof planStoreSchema>;
-//#endregion
-//#region src/publish.d.ts
-interface PublishOptions {
-  /** Validate the publish plan without publishing packages, creating tags, or running release plugins. */
-  dryRun?: boolean;
-}
-type PublishResult = {
-  state: "created";
-  packages: PackagePublishResult[]; /** Path to the publish plan that was executed. */
-  planPath: string; /** the persisted plan object. This is not a public API, can be changed without notice */
-  _rawPlan: PlanStore;
-} | {
-  state: "failed";
-  error?: string;
-  packages: PackagePublishResult[]; /** Path to the publish plan that was executed. */
-  planPath: string; /** the persisted plan object. This is not a public API, can be changed without notice */
-  _rawPlan: PlanStore;
-} | {
-  state: "skipped"; /** Path to the publish plan that was executed or missing. */
-  planPath: string;
-};
-type PackagePublishResult = ({
-  state: "failed";
-  error?: string;
-} | {
-  state: "success";
-}) & {
-  id: string;
-  name: string;
-  version: string;
-  distTag: string | undefined; /** added by the `git` plugin */
-  gitTag?: string;
-  changelogs: ChangelogEntry[];
-};
-//#endregion
-//#region src/workspace.d.ts
-/** Package discovered in the workspace. */
-declare abstract class WorkspacePackage {
-  abstract readonly name: string;
-  abstract readonly path: string;
-  abstract readonly manager: string;
-  abstract readonly version: string;
-  abstract readonly publish: boolean;
-  get distTag(): string | undefined;
-  get id(): string;
-  setVersion?(version: string): void;
-  updateDependency?(target: WorkspacePackage, version: string, context: TegamiContext): Awaitable<void>;
-  write?(): Awaitable<void>;
-  protected updateRange(context: TegamiContext, spec: DependencySpec, next: semver.SemVer): Promise<DependencySpec>;
-}
-/** Dependency graph for discovered workspace packages. */
-declare class PackageGraph {
-  private readonly byId;
-  private readonly byName;
-  constructor(packages?: WorkspacePackage[]);
-  getPackages(): WorkspacePackage[];
-  /** Get a package by exact id. */
-  get(id: string): WorkspacePackage | undefined;
-  /** Get packages by id, or every package matching a name. */
-  getByName(nameOrId: string): WorkspacePackage[];
-  /** scan package into graph, if the package id already exists, replace the existing one in graph */
-  add(pkg: WorkspacePackage): void;
-  delete(pkg: WorkspacePackage): void;
-}
-//#endregion
-//#region src/providers/npm.d.ts
-declare class NpmPackage extends WorkspacePackage {
-  readonly path: string;
-  readonly manifest: PackageManifest;
-  readonly manager = "npm";
-  constructor(path: string, manifest: PackageManifest);
-  get name(): string;
-  get version(): string;
-  get publish(): boolean;
-  get distTag(): string | undefined;
-  setVersion(version: string): void;
-  updateDependency(target: WorkspacePackage, version: string, context: TegamiContext): Promise<void>;
-  write(): Promise<void>;
-}
-type NpmClient = "npm" | "pnpm";
-declare class NpmRegistryClient implements RegistryClient {
-  #private;
-  private readonly cwd;
-  private readonly npmClient;
-  private readonly graph;
-  readonly id = "npm";
-  constructor(cwd: string, npmClient: NpmClient | undefined, graph: {
-    get(id: string): WorkspacePackage | undefined;
-  });
-  supports(pkg: WorkspacePackage): boolean;
-  packageVersionExists(pkg: WorkspacePackage, version: string): Promise<boolean>;
-  publish(pkg: WorkspacePackage, options?: {
-    distTag?: string;
-  }): Promise<void>;
-  publishPlanStatus(plan: PlanStore): Promise<PublishPlanStatus>;
-  private resolveClient;
-}
-declare function npm(client?: NpmClient): TegamiPlugin;
-//#endregion
-//#region src/types.d.ts
-/** Generates changelog content for a package release. */
-interface LogGenerator {
-  generate(this: TegamiContext, opts: {
-    packageName: string;
-    version: string;
-    distTag?: string;
-    changelogs: ChangelogEntry[];
-  }): string | Promise<string>;
-}
-interface TegamiOptions {
-  /** Workspace root. Defaults to the current working directory. */
-  cwd?: string;
-  /** Directory containing pending changelog markdown files. */
-  changelogDir?: string;
-  /** Path to the publish plan file. */
-  planPath?: string;
-  /** Changelog generator used when creating a publish plan. */
-  generator?: LogGenerator;
-  /** Per-package release and publish options keyed by package name. */
-  packages?: Record<string, PackageOptions>;
-  plugins?: TegamiPluginOption[];
-  /** Package manager command used for npm registry operations. */
-  npmClient?: NpmClient;
-}
-type TegamiPluginOption = TegamiPlugin | TegamiPluginOption[];
-interface TegamiPlugin {
-  name: string;
-  enforce?: "pre" | "default" | "post";
-  /** when Tegami initializes */
-  init?(this: TegamiContext): Awaitable<void>;
-  /** Resolve workspace packages and dependency metadata into the shared graph. */
-  resolve?(this: TegamiContext): Awaitable<void>;
-  /** Register registry clients used to handle packages for different package managers. */
-  createRegistryClient?(this: TegamiContext): Awaitable<RegistryClient | RegistryClient[] | void | undefined>;
-  /** Called after Tegami builds the initial draft plan and before it is returned. */
-  initPlan?(this: TegamiContext, plan: DraftPlan): Awaitable<DraftPlan | void | undefined>;
-  /** Called after publishing finishes. */
-  afterPublish?(this: TegamiContext & {
-    publishOptions: PublishOptions;
-  }, result: PublishResult): Awaitable<PublishResult | void | undefined>;
-  /** CLI lifecycle hooks. */
-  cli?: {
-    /** Called once before a CLI command runs. */init?(this: TegamiContext): Awaitable<void>; /** Called after `tegami version` creates a publish plan. */
-    afterVersion?(this: TegamiContext, draft: DraftPlan): Awaitable<void>;
-  };
-  /**
-   * @param pkg - the package that referenced the dependency
-   * @param spec - the referenced dependency & its range
-   * @param target - the target version to update to
-   * @returns fallback to the default behaviour if `undefined`, otherwise replace with updated spec (can reuse the same instance, as long as a value is returned).
-   */
-  onUpdateRange?(this: TegamiContext, pkg: WorkspacePackage, spec: DependencySpec, target: SemVer): Awaitable<DependencySpec | void | undefined>;
-}
-type Awaitable<T> = T | Promise<T>;
-interface PublishPlanStatus {
-  state: "pending" | "success";
-  error?: string;
-}
-interface RegistryClient {
-  id: string;
-  supports?(pkg: WorkspacePackage): boolean;
-  packageVersionExists(pkg: WorkspacePackage, version: string): Promise<boolean>;
-  publish(pkg: WorkspacePackage, options?: {
-    distTag?: string;
-  }): Promise<void>;
-  publishPlanStatus(plan: PlanStore): Promise<PublishPlanStatus>;
-}
-interface DependencySpec {
-  name: string;
-  range: string;
-}
-//#endregion
-//#region src/context.d.ts
-interface TegamiContext {
-  cwd: string;
-  changelogDir: string;
-  planPath: string;
-  options: TegamiOptions;
-  plugins: TegamiPlugin[];
-  graph: PackageGraph;
-  /** error if doesn't exist */
-  getRegistryClient(pkgOrId: WorkspacePackage | string): RegistryClient;
-}
-//#endregion
-export { PublishResult as _, RegistryClient as a, PackageOptions as b, TegamiPluginOption as c, NpmRegistryClient as d, npm as f, PublishOptions as g, PackagePublishResult as h, PublishPlanStatus as i, NpmClient as l, WorkspacePackage as m, Awaitable as n, TegamiOptions as o, PackageGraph as p, LogGenerator as r, TegamiPlugin as s, TegamiContext as t, NpmPackage as u, PlanStore as v, PackagePlan as x, DraftPlan as y };

package/dist/exec-hOS852t5.mjs

@@ -1,12 +0,0 @@
-//#region src/utils/exec.ts
-function commandOutput(result) {
-	return [result.stdout, result.stderr].filter(Boolean).join("\n").trim();
-}
-function execFailure(context, result) {
-	const lines = [context, `(exit ${result.exitCode})`];
-	const output = commandOutput(result);
-	if (output) lines.push(output);
-	return lines.join("\n");
-}
-//#endregion
-export { execFailure as t };

package/dist/index-DJ7YxxdM.d.mts

@@ -1,35 +0,0 @@
-import { _ as PublishResult, g as PublishOptions, o as TegamiOptions, p as PackageGraph, t as TegamiContext, y as DraftPlan } from "./context-CC36jtz1.mjs";
-
-//#region src/changelog/create.d.ts
-interface CreateChangelogOptions {
-  /** Start revision. Defaults to the latest reachable git tag, or all history if none exists. */
-  from?: string;
-  /** End revision. Defaults to HEAD. */
-  to?: string;
-}
-interface CreatedChangelog {
-  filename: string;
-  path: string;
-  packages: string[];
-  changes: number;
-}
-//#endregion
-//#region src/index.d.ts
-interface Tegami {
-  /** Create pending changelog files from git commit history. */
-  generateChangelog(options?: CreateChangelogOptions): Promise<CreatedChangelog[]>;
-  /** Build an editable draft from pending changelog files. */
-  draft(): Promise<DraftPlan>;
-  /** Publish the current publish plan. */
-  publish(options?: PublishOptions): Promise<PublishResult>;
-  /** Internal APIs, do not use it unless you know what you are doing */
-  _internal: {
-    context(): Promise<TegamiContext>;
-    graph(): Promise<PackageGraph>;
-    options: TegamiOptions;
-  };
-}
-/** Create a Tegami project handle. */
-declare function tegami(options?: TegamiOptions): Tegami;
-//#endregion
-export { CreatedChangelog as i, tegami as n, CreateChangelogOptions as r, Tegami as t };

package/dist/index.d.mts

@@ -1,3 +0,0 @@
-import { _ as PublishResult, a as RegistryClient, b as PackageOptions, c as TegamiPluginOption, g as PublishOptions, h as PackagePublishResult, m as WorkspacePackage, o as TegamiOptions, p as PackageGraph, r as LogGenerator, s as TegamiPlugin, x as PackagePlan, y as DraftPlan } from "./context-CC36jtz1.mjs";
-import { i as CreatedChangelog, n as tegami, r as CreateChangelogOptions, t as Tegami } from "./index-DJ7YxxdM.mjs";
-export { type CreateChangelogOptions, type CreatedChangelog, type DraftPlan, type LogGenerator, type PackageGraph, type PackageOptions, type PackagePlan, type PackagePublishResult, type PublishOptions, type PublishResult, type RegistryClient, Tegami, type TegamiOptions, type TegamiPlugin, type TegamiPluginOption, type WorkspacePackage, tegami };

package/dist/npm-BpFlXy8I.mjs

@@ -1,281 +0,0 @@
-import { n as WorkspacePackage, r as isNodeError } from "./workspace-B5_i21S0.mjs";
-import { t as execFailure } from "./exec-hOS852t5.mjs";
-import { readFile, writeFile } from "node:fs/promises";
-import { join, normalize } from "node:path";
-import { x } from "tinyexec";
-import * as semver from "semver";
-import { glob } from "tinyglobby";
-import { load } from "js-yaml";
-import { z } from "zod";
-import { detect } from "package-manager-detector";
-//#region src/schemas.ts
-const changelogFrontmatterSchema = z.object({
-	subject: z.string().optional(),
-	packages: z.array(z.string()).default([])
-});
-const stringRecordSchema = z.record(z.string(), z.string());
-const jsonCodec = (schema) => z.codec(z.string(), schema, {
-	decode: (jsonString, ctx) => {
-		try {
-			return JSON.parse(jsonString);
-		} catch (err) {
-			ctx.issues.push({
-				code: "invalid_format",
-				format: "json",
-				input: jsonString,
-				message: err.message
-			});
-			return z.NEVER;
-		}
-	},
-	encode: (value) => JSON.stringify(value)
-});
-const workspacePatternsSchema = z.union([z.array(z.string()), z.looseObject({ packages: z.array(z.string()).optional() }).transform((workspaces) => workspaces.packages ?? ["."])]).pipe(z.array(z.string()));
-const packageManifestSchema = z.looseObject({
-	name: z.string().optional(),
-	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(),
-	workspaces: workspacePatternsSchema.optional(),
-	dependencies: stringRecordSchema.optional(),
-	devDependencies: stringRecordSchema.optional(),
-	peerDependencies: stringRecordSchema.optional(),
-	optionalDependencies: stringRecordSchema.optional()
-});
-/** the persisted plan data for actual publishing */
-const planStoreSchema = jsonCodec(z.object({
-	id: z.string(),
-	createdAt: z.iso.datetime(),
-	/** release note entries */
-	changelogs: z.record(z.string(), z.object({
-		filename: z.string(),
-		subject: z.string().optional(),
-		packages: z.array(z.string()),
-		type: z.enum([
-			"major",
-			"minor",
-			"patch"
-		]),
-		title: z.string(),
-		content: z.string()
-	})),
-	/** package id -> package info */
-	packages: z.record(z.string(), z.object({
-		type: z.enum([
-			"major",
-			"minor",
-			"patch"
-		]),
-		changelogIds: z.codec(z.array(z.string()), z.set(z.string()), {
-			encode: (v) => Array.from(v),
-			decode: (v) => new Set(v)
-		}),
-		distTag: z.string().optional(),
-		publish: z.boolean()
-	}))
-}));
-//#endregion
-//#region src/providers/npm.ts
-const DEP_FIELDS = [
-	"dependencies",
-	"devDependencies",
-	"peerDependencies",
-	"optionalDependencies"
-];
-var NpmPackage = class NpmPackage 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 ?? "0.0.0";
-	}
-	get publish() {
-		return this.manifest.private !== true;
-	}
-	get distTag() {
-		return this.manifest.publishConfig?.tag;
-	}
-	setVersion(version) {
-		this.manifest.version = version;
-	}
-	async updateDependency(target, version, context) {
-		if (!(target instanceof NpmPackage)) return;
-		const next = semver.parse(version);
-		if (!next) return;
-		for (const field of DEP_FIELDS) {
-			const dependencies = this.manifest[field];
-			if (!dependencies) continue;
-			for (const [rawName, rawRange] of Object.entries(dependencies)) {
-				const spec = parseNpmDependency(rawName, rawRange);
-				if (!spec || spec.name !== target.name) continue;
-				dependencies[rawName] = formatNpmDependency(await this.updateRange(context, spec, next));
-			}
-		}
-	}
-	async write() {
-		await writeFile(join(this.path, "package.json"), `${JSON.stringify(this.manifest, null, 2)}\n`);
-	}
-};
-var NpmRegistryClient = class {
-	cwd;
-	npmClient;
-	graph;
-	id = "npm";
-	#versionMap = /* @__PURE__ */ new Map();
-	#resolvedClient;
-	constructor(cwd, npmClient = void 0, graph) {
-		this.cwd = cwd;
-		this.npmClient = npmClient;
-		this.graph = graph;
-	}
-	supports(pkg) {
-		return pkg instanceof NpmPackage;
-	}
-	async packageVersionExists(pkg, version) {
-		const cacheKey = `${pkg.id}@${version}`;
-		let info = this.#versionMap.get(cacheKey);
-		if (!info) {
-			const run = async () => {
-				if (!(pkg instanceof NpmPackage)) return false;
-				const registry = pkg.manifest.publishConfig?.registry;
-				const args = [
-					"view",
-					`${pkg.name}@${version}`,
-					"version",
-					"--json"
-				];
-				if (registry) args.push("--registry", registry);
-				const result = await x(await this.resolveClient(), args, { nodeOptions: { cwd: this.cwd } });
-				if (result.exitCode === 0) return true;
-				const output = commandOutput(result);
-				if (isMissingRegistryEntry(output)) return false;
-				throw new Error(`Unable to validate ${pkg.name}@${version} against the npm registry${registry ? ` "${registry}"` : ""}: ${output.trim() || `command exited with code ${result.exitCode}`}`);
-			};
-			info = run();
-			this.#versionMap.set(cacheKey, info);
-		}
-		return info;
-	}
-	async publish(pkg, options = {}) {
-		const client = await this.resolveClient();
-		const args = ["publish"];
-		const distTag = options.distTag ?? pkg.distTag;
-		if (distTag) args.push("--tag", distTag);
-		if (client === "pnpm") args.push("--no-git-checks");
-		const result = await x(client, args, { nodeOptions: { cwd: pkg.path } });
-		if (result.exitCode !== 0) throw new Error(execFailure(`Failed to publish ${pkg.name}@${pkg.version}${distTag ? ` with dist-tag "${distTag}"` : ""}.`, result));
-	}
-	async publishPlanStatus(plan) {
-		for (const [name, pkgPlan] of Object.entries(plan.packages)) {
-			const pkg = this.graph.get(name);
-			if (!(pkg instanceof NpmPackage) || !pkgPlan.publish) continue;
-			if (!await this.packageVersionExists(pkg, pkg.version)) return { state: "pending" };
-		}
-		return { state: "success" };
-	}
-	resolveClient() {
-		if (!this.#resolvedClient) this.#resolvedClient = this.npmClient ?? detect({ cwd: this.cwd }).then((result) => {
-			if (result?.name === "pnpm") return "pnpm";
-			return "npm";
-		});
-		return this.#resolvedClient;
-	}
-};
-function commandOutput(result) {
-	return [result.stdout, result.stderr].filter(Boolean).join("\n");
-}
-function isMissingRegistryEntry(output) {
-	const normalized = output.toLowerCase();
-	return normalized.includes("e404") || normalized.includes("404") || normalized.includes("no match") || normalized.includes("no matching version") || normalized.includes("not found");
-}
-function parseNpmDependency(rawName, rawRange) {
-	if (rawRange.startsWith("workspace:")) return {
-		name: rawName,
-		range: rawRange.slice(10),
-		protocol: "workspace"
-	};
-	if (rawRange.startsWith("npm:")) {
-		const spec = rawRange.slice(4);
-		const separator = spec.lastIndexOf("@");
-		if (separator <= 0) return void 0;
-		return {
-			name: spec.slice(0, separator),
-			range: spec.slice(separator + 1),
-			protocol: "npm"
-		};
-	}
-	return {
-		name: rawName,
-		range: rawRange
-	};
-}
-function formatNpmDependency(spec) {
-	const npmSpec = spec;
-	if (npmSpec.protocol === "workspace") return `workspace:${spec.range}`;
-	if (npmSpec.protocol === "npm") return `npm:${spec.name}@${spec.range}`;
-	return spec.range;
-}
-function npm(client) {
-	return {
-		name: "npm",
-		enforce: "pre",
-		async resolve() {
-			await discoverNpmPackages(this.cwd, (pkg) => this.graph.add(pkg));
-		},
-		createRegistryClient() {
-			return new NpmRegistryClient(this.cwd, client, this.graph);
-		}
-	};
-}
-async function discoverNpmPackages(cwd, add) {
-	const candidatePaths = await expandWorkspacePatterns(cwd, await readWorkspacePatterns(cwd));
-	const rootManifestPromise = readManifest(cwd).catch(() => void 0);
-	const manifests = await Promise.all(candidatePaths.map((path) => readManifest(path).then((manifest) => ({
-		path,
-		manifest
-	})).catch(() => void 0)));
-	const rootManifest = await rootManifestPromise;
-	if (rootManifest?.name && rootManifest.version && rootManifest.private !== true) add(new NpmPackage(cwd, rootManifest));
-	for (const entry of manifests) {
-		if (!entry?.manifest.name || !entry.manifest.version) continue;
-		add(new NpmPackage(entry.path, entry.manifest));
-	}
-}
-async function readWorkspacePatterns(cwd) {
-	const pnpmPatterns = await readFile(join(cwd, "pnpm-workspace.yaml"), "utf8").then((content) => workspacePatternsSchema.parse(load(content) ?? {})).catch((error) => {
-		if (isNodeError(error) && error.code === "ENOENT") return void 0;
-		throw error;
-	});
-	if (pnpmPatterns) return pnpmPatterns;
-	return (await readManifest(cwd).catch(() => void 0))?.workspaces ?? ["."];
-}
-async function expandWorkspacePatterns(cwd, patterns) {
-	const paths = patterns.includes(".") ? [cwd] : [];
-	const globPatterns = patterns.filter((pattern) => pattern !== ".");
-	if (globPatterns.length > 0) paths.push(...await glob(globPatterns, {
-		absolute: true,
-		cwd,
-		ignore: ["**/node_modules/**"],
-		onlyDirectories: true,
-		onlyFiles: false
-	}));
-	return paths.map(normalize);
-}
-async function readManifest(packagePath) {
-	const content = await readFile(join(packagePath, "package.json"), "utf8");
-	return packageManifestSchema.parse(JSON.parse(content));
-}
-//#endregion
-export { planStoreSchema as a, changelogFrontmatterSchema as i, NpmRegistryClient as n, npm as r, NpmPackage as t };