tegami 0.1.6 → 0.2.0

package/dist/{types-DexeJdl7.d.ts → types-CurHqnWl.d.ts}

@@ -1,19 +1,19 @@
-import z$1, { z } from "zod";
+import z, { z as z$1 } from "zod";
 import { AgentName } from "package-manager-detector";
 
 //#region src/utils/semver.d.ts
 type BumpType = "major" | "minor" | "patch";
 //#endregion
 //#region src/changelog/shared.d.ts
-declare const changelogPackageConfigSchema: z$1.ZodObject<{
-  type: z$1.ZodOptional<z$1.ZodEnum<{
+declare const changelogPackageConfigSchema: z.ZodObject<{
+  type: z.ZodOptional<z.ZodEnum<{
     major: "major";
     minor: "minor";
     patch: "patch";
   }>>;
-  replay: z$1.ZodOptional<z$1.ZodArray<z$1.ZodString>>;
-}, z$1.core.$strip>;
-type ChangelogPackageConfig = z$1.output<typeof changelogPackageConfigSchema>;
+  replay: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type ChangelogPackageConfig = z.output<typeof changelogPackageConfigSchema>;
 //#endregion
 //#region src/changelog/parse.d.ts
 interface ChangelogEntry {
@@ -28,69 +28,69 @@ interface ChangelogEntry {
     title: string;
     content: string;
   }[];
+  /** Generated in memory and not yet written to `changelogDir`. */
+  virtual?: boolean;
   getRawContent: () => string;
 }
 //#endregion
 //#region src/plans/draft.d.ts
-interface PackagePlan {
+interface PackageDraft {
   type?: BumpType;
+  prerelease?: string;
   bumpReasons?: Set<string>;
   changelogs?: ChangelogEntry[];
-  prerelease?: string;
-  publish?: boolean;
   npm?: {
     /** npm dist-tag used when publishing. */distTag?: string;
   };
   /** get the bumped version of a package */
   bumpVersion: (pkg: WorkspacePackage) => string;
 }
-declare class DraftPlan {
+/** a draft describes all operations to perform before the actual publishing, such as version bumps. */
+declare class Draft {
   #private;
   private readonly context;
+  /** package id -> draft */
   private readonly packages;
+  /** id -> changelog */
   private readonly changelogs;
   private readonly policies;
   constructor(context: TegamiContext);
-  getPackagePlans(): Map<string, PackagePlan>;
-  getPackagePlan(id: string): PackagePlan | undefined;
+  getPackageDrafts(): Map<string, PackageDraft>;
+  getPackageDraft(id: string): PackageDraft | undefined;
   bumpPackage(pkg: WorkspacePackage, {
     type,
     reason
   }: {
     type: BumpType;
     reason?: string;
-  }): PackagePlan;
-  dispatchPackage(pkg: WorkspacePackage, dispatch: (plan: PackagePlan) => void, onUpdate?: (plan: PackagePlan) => void): PackagePlan;
-  getOrInitPackage(pkg: WorkspacePackage): PackagePlan;
+  }): PackageDraft;
+  dispatchPackage(pkg: WorkspacePackage, dispatch: (draft: PackageDraft) => void, onUpdate?: (draft: PackageDraft) => void): PackageDraft;
+  getOrInitPackage(pkg: WorkspacePackage): PackageDraft;
   hasPending(): boolean;
   getChangelogs(): ChangelogEntry[];
   getChangelog(id: string): ChangelogEntry | undefined;
   addChangelog(entry: ChangelogEntry): void;
   deleteChangelog(id: string): boolean;
-  /** Apply the publish plan: update package versions, write the plan file, and consume changelog files. */
-  applyPlan(): Promise<void>;
-  addPolicy(policy: PlanPolicy): void;
-  removePolicy(policy: PlanPolicy): void;
+  /** Apply version bumps, lock file, and changelog files. */
+  apply(): Promise<void>;
+  /** write persistent data to publish lock */
+  private writeLockFile;
+  addPolicy(policy: DraftPolicy): void;
+  removePolicy(policy: DraftPolicy): void;
   canApply(): boolean;
   /** Attach replaying changelog entries to packages (already bumped), and return the updated changelog entries. */
   private applyReplays;
   private appendChangelog;
-  /** {@link applyPlan} but for `await using` syntax */
+  /** {@link apply} but for `await using` syntax */
   [Symbol.asyncDispose](): Promise<void>;
 }
-interface PlanPolicy {
+interface DraftPolicy {
   id: string;
-  onUpdate?: (this: DraftPlan, opts: {
-    plan: PackagePlan;
+  onUpdate?: (this: Draft, opts: {
+    packageDraft: PackageDraft;
     pkg: WorkspacePackage;
   }) => void;
 }
-type CleanupResult = {
-  state: "removed";
-} | {
-  state: "skipped";
-  reason: "missing" | "pending";
-};
 //#endregion
 //#region src/graph.d.ts
 /** Package discovered in the workspace. */
@@ -104,10 +104,10 @@ declare abstract class WorkspacePackage {
   /** note: this will only be available after package graph is resolved */
   getPackageOptions(): PackageOptions;
   setPackageOptions(options: PackageOptions): void;
-  /** create the initial draft plan. */
-  initPlan(): PackagePlan;
-  /** configure an initial draft plan to match script-level configs. */
-  configurePlan(plan: PackagePlan, group?: PackageGroup): void;
+  /** create the initial draft. */
+  initDraft(): PackageDraft;
+  /** configure an initial draft to match script-level configs. */
+  configureDraft(draft: PackageDraft, group?: PackageGroup): void;
 }
 interface PackageGroup {
   name: string;
@@ -143,12 +143,10 @@ interface TegamiContext {
   /** absolute path */
   changelogDir: string;
   /** absolute path */
-  planPath: string;
+  lockPath: string;
   options: TegamiOptions;
   plugins: TegamiPlugin[];
   graph: PackageGraph;
-  /** error if doesn't exist */
-  getRegistryClient(pkgOrId: WorkspacePackage | string): RegistryClient;
   /** additional context when GitHub plugin is configured */
   github?: {
     repo?: string;
@@ -160,96 +158,14 @@ interface TegamiContext {
   };
 }
 //#endregion
-//#region src/plans/store.d.ts
-declare const packagePlanStoreSchema: z$1.ZodObject<{
-  type: z$1.ZodOptional<z$1.ZodEnum<{
-    major: "major";
-    minor: "minor";
-    patch: "patch";
-  }>>;
-  changelogIds: z$1.ZodOptional<z$1.ZodArray<z$1.ZodString>>;
-  bumpReasons: z$1.ZodOptional<z$1.ZodArray<z$1.ZodString>>;
-  npm: z$1.ZodOptional<z$1.ZodObject<{
-    distTag: z$1.ZodOptional<z$1.ZodString>;
-  }, z$1.core.$strip>>;
-  publish: z$1.ZodBoolean;
-}, z$1.core.$strip>;
-/** the persisted plan data for actual publishing */
-declare const planStoreSchema: z$1.ZodCodec<z$1.ZodString, z$1.ZodObject<{
-  id: z$1.ZodString;
-  createdAt: z$1.ZodISODateTime;
-  version: z$1.ZodDefault<z$1.ZodLiteral<"0.0.0">>;
-  changelogs: z$1.ZodRecord<z$1.ZodString, z$1.ZodObject<{
-    filename: z$1.ZodString;
-    content: z$1.ZodString;
-  }, z$1.core.$strip>>;
-  packages: z$1.ZodRecord<z$1.ZodString, z$1.ZodObject<{
-    type: z$1.ZodOptional<z$1.ZodEnum<{
-      major: "major";
-      minor: "minor";
-      patch: "patch";
-    }>>;
-    changelogIds: z$1.ZodOptional<z$1.ZodArray<z$1.ZodString>>;
-    bumpReasons: z$1.ZodOptional<z$1.ZodArray<z$1.ZodString>>;
-    npm: z$1.ZodOptional<z$1.ZodObject<{
-      distTag: z$1.ZodOptional<z$1.ZodString>;
-    }, z$1.core.$strip>>;
-    publish: z$1.ZodBoolean;
-  }, z$1.core.$strip>>;
-}, z$1.core.$strip>>;
-type PlanStore = z$1.output<typeof planStoreSchema>;
-type PackagePlanStore = z$1.output<typeof packagePlanStoreSchema>;
-//#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[]; /** the persisted plan object. This is not a public API, can be changed without notice */
-  _rawPlan: PlanStore;
-} | {
-  state: "failed";
-  error?: string;
-  packages: PackagePublishResult[]; /** the persisted plan object. This is not a public API, can be changed without notice */
-  _rawPlan: PlanStore;
-} | {
-  state: "skipped";
-};
-type PackagePublishResult = ({
-  state: "failed";
-  error?: string;
-} | {
-  state: "success";
-}) & {
-  id: string;
-  name: string;
-  version: string;
-  npm?: {
-    distTag?: string;
-  };
-  git?: {
-    /** will be defined even if publishing fails */tag: string;
-    tagState: "created" | "skipped" | "failed";
-  };
-  changelogs: ChangelogEntry[];
-};
-//#endregion
 //#region src/changelog/generate.d.ts
-interface GenerateChangelogOptions {
+interface GenerateFromCommitsOptions {
   /** Start revision. Defaults to the latest reachable git tag, or all history if none exists. */
   from?: string;
   /** End revision. Defaults to HEAD. */
   to?: string;
-  /**
-   * Write changelog files to disk.
-   *
-   * @default true
-   */
-  write?: boolean;
 }
-interface GeneratedChangelog {
+interface CommitChangelog {
   filename: string;
   content: string;
   packages: Record<string, BumpType | ChangelogPackageConfig>;
@@ -264,16 +180,88 @@ interface CommitChange {
   title: string;
 }
 //#endregion
+//#region src/plans/publish.d.ts
+interface PublishPlan {
+  options: PublishOptions;
+  /** id -> entry */
+  changelogs: Map<string, ChangelogEntry>;
+  /** id -> package data. The package id will always exist in package graph, stale items will be pruned at init-time */
+  packages: Map<string, PackagePublishPlan>;
+}
+interface PackagePublishPlan {
+  changelogs: ChangelogEntry[];
+  /** whether this package was version-bumped when the lock was written */
+  updated: boolean;
+  /** generated by Git plugin */
+  git?: {
+    /** the associated Git tag of package */tag: string;
+  };
+  /** generated by npm plugin */
+  npm?: {
+    /** dist tag to use if published */distTag?: string;
+  };
+  /** publish result, generated for all packages in publish plan after publishing */
+  publishResult?: PackagePublishResult;
+  /** preflight result, generated for all packages in publish plan after preflights */
+  preflight?: PublishPreflight;
+}
+interface PublishOptions {
+  /** Validate the publish plan without publishing packages, creating tags, or running release plugins. */
+  dryRun?: boolean;
+}
+type PackagePublishResult = {
+  type: "published" | "skipped";
+} | {
+  type: "failed";
+  error: string;
+};
+//#endregion
+//#region src/plans/lock.d.ts
+/**
+ * the data structure of `publish-lock.yaml` file.
+ */
+declare class PublishLock {
+  /** namespace -> data array */
+  private readonly data;
+  constructor(/** namespace -> data array */
+
+  data?: Map<string, unknown[]>);
+  /** write data to namespace, note that the `data` must be serializable in yaml */
+  write(namespace: string, data: unknown): void;
+  read(namespace: string): unknown | undefined;
+  size(namespace: string): number;
+  serialize(): string;
+}
+//#endregion
 //#region src/index.d.ts
+interface GenerateChangelogOptions extends GenerateFromCommitsOptions {
+  /**
+   * Write changelog files to disk.
+   *
+   * @default true
+   */
+  write?: boolean;
+}
 interface Tegami {
   /** Create pending changelog files from git commit history. */
-  generateChangelog(options?: GenerateChangelogOptions): Promise<GeneratedChangelog[]>;
+  generateChangelog(options?: GenerateChangelogOptions): Promise<CommitChangelog[]>;
   /** Build a draft from pending changelog files. */
-  draft(): Promise<DraftPlan>;
-  /** Publish the current publish plan. */
-  publish(options?: PublishOptions): Promise<PublishResult>;
-  /** Remove the publish plan file after it has finished successfully. */
-  cleanup(): Promise<CleanupResult>;
+  draft(): Promise<Draft>;
+  /** Publish packages from the publish lock. */
+  publish(options?: PublishOptions): Promise<PublishPlan | "skipped">;
+  /**
+   * Check publish status.
+   *
+   * Prefer `publish()` over this if you are publishing packages, it will also check the publish status.
+   */
+  publishStatus(): Promise<"pending" | "success" | "idle">;
+  /** Remove the publish lock file after publishing has finished successfully. */
+  cleanup(): Promise<{
+    state: "removed";
+  } | {
+    state: "skipped";
+    reason: "no-plan" | "pending";
+  }>;
   /** Internal APIs, do not use it unless you know what you are doing */
   _internal: {
     context(): Promise<TegamiContext>;
@@ -285,25 +273,25 @@ interface Tegami {
 declare function tegami<const Groups extends string = string>(options?: TegamiOptions<Groups>): Tegami;
 //#endregion
 //#region src/schemas.d.ts
-declare const packageManifestSchema: z.ZodObject<{
-  name: z.ZodString;
-  version: z.ZodOptional<z.ZodString>;
-  private: z.ZodOptional<z.ZodBoolean>;
-  publishConfig: z.ZodOptional<z.ZodObject<{
-    access: z.ZodOptional<z.ZodEnum<{
+declare const packageManifestSchema: z$1.ZodObject<{
+  name: z$1.ZodString;
+  version: z$1.ZodOptional<z$1.ZodString>;
+  private: z$1.ZodOptional<z$1.ZodBoolean>;
+  publishConfig: z$1.ZodOptional<z$1.ZodObject<{
+    access: z$1.ZodOptional<z$1.ZodEnum<{
       public: "public";
       restricted: "restricted";
     }>>;
-    registry: z.ZodOptional<z.ZodString>;
-    tag: z.ZodOptional<z.ZodString>;
-  }, z.core.$loose>>;
-  workspaces: z.ZodOptional<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>;
+    registry: z$1.ZodOptional<z$1.ZodString>;
+    tag: z$1.ZodOptional<z$1.ZodString>;
+  }, z$1.core.$loose>>;
+  workspaces: z$1.ZodOptional<z$1.ZodArray<z$1.ZodString>>;
+  dependencies: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodString>>;
+  devDependencies: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodString>>;
+  peerDependencies: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodString>>;
+  optionalDependencies: z$1.ZodOptional<z$1.ZodRecord<z$1.ZodString, z$1.ZodString>>;
+}, z$1.core.$loose>;
+type PackageManifest = z$1.infer<typeof packageManifestSchema>;
 //#endregion
 //#region src/providers/npm.d.ts
 declare const DEP_FIELDS$1: readonly ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"];
@@ -315,22 +303,7 @@ declare class NpmPackage extends WorkspacePackage {
   get name(): string;
   get version(): string;
   write(): Promise<void>;
-  initPlan(): PackagePlan;
-}
-declare class NpmRegistryClient implements RegistryClient {
-  #private;
-  private readonly cwd;
-  private readonly client;
-  readonly id = "npm";
-  constructor(cwd: string, client: AgentName, _graph: PackageGraph);
-  supports(pkg: WorkspacePackage): boolean;
-  isPackagePublished(pkg: NpmPackage): Promise<boolean>;
-  publish(pkg: NpmPackage, {
-    packageStore
-  }: {
-    store: PlanStore;
-    packageStore: PackagePlanStore;
-  }): Promise<void>;
+  initDraft(): PackageDraft;
 }
 type DependencySpec = {
   protocol: "npm";
@@ -371,7 +344,7 @@ interface NpmPluginOptions {
    * Note: `workspace:` protocols are not included.
    */
   onBreakPeerDep?: "set" | "error" | "ignore";
-  /** update lockfile after appling publish plan */
+  /** update lockfile after applying a draft @default true */
   updateLockFile?: boolean;
 }
 declare function npm({
@@ -396,35 +369,17 @@ declare class CargoPackage extends WorkspacePackage {
   constructor(path: string, manifest: TomlTable, content: string, workspaceManifest?: TomlTable | undefined);
   get name(): string;
   get version(): string;
-  initPlan(): PackagePlan;
   setVersion(version: string): void;
   write(): Promise<void>;
   patch(path: string, value: unknown): void;
   get packageInfo(): TomlTable;
   private get workspaceVersion();
 }
-declare class CargoRegistryClient implements RegistryClient {
-  #private;
-  private readonly graph;
-  readonly id = "cargo";
-  constructor(graph: PackageGraph);
-  supports(pkg: WorkspacePackage): boolean;
-  isPackagePublished(pkg: CargoPackage): Promise<boolean>;
-  publishPreflight(pkg: CargoPackage, {
-    store
-  }: {
-    store: PlanStore;
-  }): PublishPreflight;
-  publish(pkg: CargoPackage, _env: {
-    store: PlanStore;
-    packageStore: PackagePlanStore;
-  }): Promise<void>;
-}
 interface CargoPluginOptions {
   /**
    * Update lock file after versioning.
    *
-   * @default false
+   * @default true
    */
   updateLockFile?: boolean;
   bumpDep?: (opts: {
@@ -442,12 +397,9 @@ declare function cargo({
 /** Generates changelog content for a package release. */
 interface LogGenerator {
   generate(this: TegamiContext, opts: {
-    packageId: string;
-    packageName: string;
-    version: string;
-    changelogs: ChangelogEntry[];
-    plan: PackagePlan;
-    unstable_draft: DraftPlan;
+    pkg: WorkspacePackage;
+    packageDraft: PackageDraft;
+    draft: Draft;
   }): string | Promise<string>;
 }
 interface TegamiOptions<Groups extends string = string> {
@@ -455,9 +407,9 @@ interface TegamiOptions<Groups extends string = string> {
   cwd?: string;
   /** Directory containing pending changelog markdown files. */
   changelogDir?: string;
-  /** Path to the publish plan file. */
-  planPath?: string;
-  /** Changelog generator used when applying a publish plan. */
+  /** Path to the publish lock file. Defaults to `.tegami/publish-lock.yaml`. */
+  lockPath?: string;
+  /** Changelog generator used when applying a draft. */
   generator?: LogGenerator;
   /** Per-package release and publish options keyed by package name. */
   packages?: Record<string, PackageOptions<NoInfer<Groups>>>;
@@ -465,6 +417,14 @@ interface TegamiOptions<Groups extends string = string> {
   groups?: Record<Groups, GroupOptions>;
   /** Package names, ids, or regex patterns to exclude from the dependency graph. */
   ignore?: (string | RegExp)[];
+  /**
+   * When creating draft, automatically generate changelogs from conventional commits.
+   *
+   * When disabled (default), it requires you to run `generateChangelog()` to pre-generate changelogs before draft.
+   *
+   * @default false
+   */
+  conventionalCommits?: boolean;
   npm?: NpmPluginOptions;
   cargo?: CargoPluginOptions;
 }
@@ -483,8 +443,6 @@ interface GroupOptions {
 interface PackageOptions<Group extends string = string> {
   /** Prerelease identifier appended to bumped versions (e.g. `alpha` → `1.1.0-alpha.0`). */
   prerelease?: string;
-  /** Set to false to keep this package out of npm publishing. */
-  publish?: boolean;
   /** the group of this package, ignored if the group doesn't exist */
   group?: Group;
   /** npm-specific options. */
@@ -500,56 +458,68 @@ interface TegamiPlugin {
   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 when Tegami creates an empty draft plan. */
-  initPlan?(this: TegamiContext, plan: DraftPlan): Awaitable<DraftPlan | void | undefined>;
-  /** Called when Tegami applies the draft plan. */
-  applyPlan?(this: TegamiContext, draft: DraftPlan): Awaitable<void>;
-  /** resolve the plan status, crucial to check if the plan is finished successfully, or needs retries */
-  resolvePlanStatus?(this: TegamiContext, status: PublishPlanStatus, env: {
-    plan: PlanStore;
-  }): Awaitable<PublishPlanStatus>;
+  /** Called when Tegami creates an empty draft. */
+  initDraft?(this: TegamiContext, draft: Draft): Awaitable<Draft | void | undefined>;
+  /** Called when Tegami applies the draft. */
+  applyDraft?(this: TegamiContext, draft: Draft): Awaitable<void>;
+  /** Called when Tegami creates publish lock. */
+  initPublishLock?(this: TegamiContext, opts: {
+    lock: PublishLock;
+    draft: Draft;
+  }): Awaitable<void>;
+  /** Called when Tegami creates publish plan. */
+  initPublishPlan?(this: TegamiContext, opts: {
+    lock: PublishLock;
+    plan: PublishPlan;
+  }): Awaitable<void>;
+  /** Collect data before publishing a package, will be merged if multiple plugins return preflight data for this package. */
+  publishPreflight?(this: TegamiContext, opts: {
+    pkg: WorkspacePackage;
+    plan: PublishPlan;
+  }): Awaitable<PublishPreflight | void | undefined>;
+  /** 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;
+    plan: PublishPlan;
+  }): Promise<PackagePublishResult | undefined | void>;
+  /**
+   * Resolve publish plan status, used to check if the plan is finished successfully, or needs retries.
+   *
+   * Each plugin should only report the status of its own tasks, Tegami will summarize the results from all plugins.
+   */
+  resolvePlanStatus?(this: TegamiContext, opts: {
+    plan: PublishPlan;
+  }): Awaitable<"success" | "pending" | undefined | void>;
   /** Called before a package will be published, return `false` to prevent from publishing. */
   willPublish?(this: TegamiContext, opts: {
     pkg: WorkspacePackage;
-  }): Awaitable<PackagePublishResult | false | void | undefined>;
-  /** Called after a package is published. */
+  }): Awaitable<false | void | undefined>;
+  /** Called after a package is published, skipped, or failed. */
   afterPublish?(this: TegamiContext, opts: {
     pkg: WorkspacePackage;
-    result: PackagePublishResult;
-  }): Awaitable<PackagePublishResult | void | undefined>;
-  /** Called after publishing finishes. */
-  afterPublishAll?(this: TegamiContext & {
-    publishOptions: PublishOptions;
-  }, result: PublishResult): Awaitable<PublishResult | void | undefined>;
+    plan: PublishPlan;
+  }): Awaitable<void>;
+  /** Called after all publishing finishes. */
+  afterPublishAll?(this: TegamiContext, opts: {
+    plan: PublishPlan;
+  }): Awaitable<void>;
   /** CLI lifecycle hooks. */
   cli?: {
-    /** Called once before a CLI command runs. */init?(this: TegamiContext): Awaitable<void>; /** Called after `tegami version` returns a draft plan. */
-    publishPlanCreated?(this: TegamiContext, draft: DraftPlan): Awaitable<void>; /** Called after `tegami version` applies a publish plan. */
-    publishPlanApplied?(this: TegamiContext, draft: DraftPlan): Awaitable<void>;
+    /** Called once before a CLI command runs. */init?(this: TegamiContext): Awaitable<void>; /** Called after `tegami version` returns a draft. */
+    draftCreated?(this: TegamiContext, draft: Draft): Awaitable<void>; /** Called after `tegami version` applies a draft. */
+    draftApplied?(this: TegamiContext, draft: Draft): Awaitable<void>;
   };
 }
 type Awaitable<T> = T | Promise<T>;
-interface PublishPlanStatus {
-  state: "pending" | "success" | "missing";
-}
 interface PublishPreflight {
-  /** Package ids that must be published before this one, this will automatically disallow circular dependency. */
-  wait: string[];
-}
-interface RegistryClient {
-  id: string;
-  supports(pkg: WorkspacePackage): boolean;
-  isPackagePublished(pkg: WorkspacePackage): Promise<boolean>;
-  publishPreflight?(pkg: WorkspacePackage, env: {
-    store: PlanStore;
-    packageStore: PackagePlanStore;
-  }): Awaitable<PublishPreflight | void | undefined>;
-  publish(pkg: WorkspacePackage, env: {
-    store: PlanStore;
-    packageStore: PackagePlanStore;
-  }): Promise<void>;
+  /** if the package should be published, default to `true`. */
+  publish?: boolean;
+  /**
+   * Package ids that must be published before this one, this will automatically disallow circular dependency.
+   *
+   * It is okay to add unpublished packages to `wait`, they will be ignored.
+   */
+  wait?: string[];
 }
 //#endregion
-export { PackagePlan as A, PublishOptions as C, PackageGroup as D, PackageGraph as E, WorkspacePackage as O, PackagePublishResult as S, TegamiContext as T, npm as _, PublishPreflight as a, GenerateChangelogOptions as b, TegamiPlugin as c, CargoPluginOptions as d, CargoRegistryClient as f, NpmRegistryClient as g, NpmPluginOptions as h, PackageOptions as i, DraftPlan as k, TegamiPluginOption as l, NpmPackage as m, GroupOptions as n, RegistryClient as o, cargo as p, LogGenerator as r, TegamiOptions as s, Awaitable as t, CargoPackage as u, Tegami as v, PublishResult as w, GeneratedChangelog as x, tegami as y };
+export { PackageDraft as A, CommitChangelog as C, WorkspacePackage as D, PackageGroup as E, Draft as O, PublishPlan as S, PackageGraph as T, tegami as _, PublishPreflight as a, PackagePublishResult as b, TegamiPluginOption as c, cargo as d, NpmPackage as f, Tegami as g, GenerateChangelogOptions as h, PackageOptions as i, DraftPolicy as k, CargoPackage as l, npm as m, GroupOptions as n, TegamiOptions as o, NpmPluginOptions as p, LogGenerator as r, TegamiPlugin as s, Awaitable as t, CargoPluginOptions as u, PublishLock as v, TegamiContext as w, PublishOptions as x, PackagePublishPlan as y };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tegami",
-  "version": "0.1.6",
+  "version": "0.2.0",
   "description": "Utility for package versioning & publish",
   "license": "MIT",
   "author": "Fuma Nama",
@@ -26,24 +26,23 @@
     "access": "public"
   },
   "dependencies": {
-    "@clack/prompts": "^1.5.1",
+    "@clack/prompts": "^1.6.0",
     "@rainbowatcher/toml-edit-js": "^0.6.5",
     "commander": "^15.0.0",
-    "js-yaml": "^4.2.0",
+    "js-yaml": "^5.1.0",
     "mdast-util-from-markdown": "^2.0.3",
     "mdast-util-to-markdown": "^2.1.2",
     "package-manager-detector": "^1.6.0",
-    "semver": "^7.8.4",
+    "semver": "^7.8.5",
     "tinyexec": "^1.2.4",
     "tinyglobby": "^0.2.17",
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@types/js-yaml": "^4.0.9",
     "@types/mdast": "^4.0.4",
-    "@types/node": "^25.5.0",
+    "@types/node": "^26.0.0",
     "@types/semver": "^7.7.1",
-    "tsdown": "^0.22.2",
+    "tsdown": "^0.22.3",
     "typescript": "6.0.3",
     "@repo/typescript-config": "0.0.0"
   },