Function buildSnapshotReleasePlan

packages/bumpy/src/core/snapshot.ts:117–153

(
  stablePlan: ReleasePlan,
  snapshot: ResolvedSnapshot,
  packages: Map<string, WorkspacePackage>,
)

 * re-running on the same commit is a no-op; `timestamp` versions essentially never collide.
 */
export async function buildSnapshotReleasePlan(
  stablePlan: ReleasePlan,
  snapshot: ResolvedSnapshot,
  packages: Map<string, WorkspacePackage>,
): Promise<SnapshotReleasePlanResult> {
  const warnings = [...stablePlan.warnings];
  const alreadyPublished: Array<{ name: string; version: string }> = [];
  const releases: PlannedRelease[] = [];

  await Promise.all(
    stablePlan.releases.map(async (release) => {
      const pkg = packages.get(release.name);
      if (!pkg) return;
      // Unpublishable packages can't be installed from a dist-tag — nothing to snapshot
      if (pkg.private && !pkg.bumpy?.publishCommand) return;

      const target = release.newVersion; // stable target from the bump files
      const version = snapshotVersion(target, snapshot);

      // The version embeds its own uniqueness (sha/timestamp), so a collision means we
      // already published this exact snapshot — skip to stay idempotent (re-run on the
      // same commit). Only registry-backed packages can be checked this way.
      if (usesNpmRegistry(pkg)) {
        const versions = await fetchPublishedVersions(pkg.name, pkg.bumpy?.registry);
        if (versions.includes(version)) {
          alreadyPublished.push({ name: release.name, version });
          return;
        }
      }

      releases.push({ ...release, newVersion: version });
    }),
  );

  releases.sort((a, b) => a.name.localeCompare(b.name));
  return { plan: { bumpFiles: stablePlan.bumpFiles, releases, warnings }, alreadyPublished, warnings };
}

/** One-line summary of a snapshot plan's versions, for logs and PR comments */
export function formatSnapshotVersionSummary(releases: PlannedRelease[]): string {