@williamthorsen/release-kit 4.8.0 → 5.1.0

package/dist/esm/loadConfig.js

@@ -1,13 +1,41 @@
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
-import { component } from "./component.js";
 import {
   DEFAULT_CHANGELOG_JSON_CONFIG,
+  DEFAULT_PROJECT_TAG_PREFIX,
   DEFAULT_RELEASE_NOTES_CONFIG,
   DEFAULT_VERSION_PATTERNS,
   DEFAULT_WORK_TYPES
 } from "./defaults.js";
+import { deriveWorkspaceConfig } from "./deriveWorkspaceConfig.js";
 import { isRecord } from "./typeGuards.js";
+const ROOT_PACKAGE_JSON_PATH = "package.json";
+function readRootPackageVersion() {
+  const absolutePath = path.resolve(process.cwd(), ROOT_PACKAGE_JSON_PATH);
+  if (!existsSync(absolutePath)) {
+    return { exists: false, version: void 0 };
+  }
+  let contents;
+  try {
+    contents = readFileSync(absolutePath, "utf8");
+  } catch (error) {
+    throw new Error(
+      `Failed to read root ${ROOT_PACKAGE_JSON_PATH}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(contents);
+  } catch (error) {
+    throw new Error(
+      `Failed to parse root ${ROOT_PACKAGE_JSON_PATH}: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+  if (!isRecord(parsed)) {
+    return { exists: true, version: void 0 };
+  }
+  return { exists: true, version: typeof parsed.version === "string" ? parsed.version : void 0 };
+}
 const CONFIG_FILE_PATH = ".config/release-kit.config.ts";
 async function loadConfig() {
   const absoluteConfigPath = path.resolve(process.cwd(), CONFIG_FILE_PATH);
@@ -28,26 +56,42 @@ async function loadConfig() {
   }
   return resolved;
 }
-function mergeMonorepoConfig(discoveredPaths, userConfig) {
-  let components = discoveredPaths.map((workspacePath) => component(workspacePath));
-  if (userConfig?.components !== void 0) {
-    const overrides = new Map(userConfig.components.map((c) => [c.dir, c]));
-    components = components.filter((c) => {
-      const override = overrides.get(c.dir);
+function mergeMonorepoConfig(discoveredPaths, userConfig, rootPackage) {
+  let workspaces = discoveredPaths.map((workspacePath) => deriveWorkspaceConfig(workspacePath));
+  assertUniqueTagPrefixes(workspaces);
+  if (userConfig?.workspaces !== void 0) {
+    const overrides = new Map(userConfig.workspaces.map((w) => [w.dir, w]));
+    workspaces = workspaces.filter((w) => {
+      const override = overrides.get(w.dir);
       return override?.shouldExclude !== true;
+    }).map((w) => {
+      const override = overrides.get(w.dir);
+      if (override?.legacyIdentities === void 0) {
+        return w;
+      }
+      assertLegacyIdentityDoesNotMatchCurrent(w.dir, w.name, w.tagPrefix, override.legacyIdentities);
+      return { ...w, legacyIdentities: override.legacyIdentities.map((identity) => ({ ...identity })) };
     });
   }
-  const workTypes = userConfig?.workTypes === void 0 ? { ...DEFAULT_WORK_TYPES } : { ...DEFAULT_WORK_TYPES, ...userConfig.workTypes };
+  if (userConfig?.retiredPackages !== void 0) {
+    assertRetiredPackagesDoNotCollideWithActive(workspaces, userConfig.retiredPackages);
+  }
+  const project = resolveProjectConfig(userConfig?.project, rootPackage);
+  const workTypes = resolveWorkTypes(userConfig?.workTypes);
   const versionPatterns = userConfig?.versionPatterns === void 0 ? { ...DEFAULT_VERSION_PATTERNS } : { ...userConfig.versionPatterns };
   const changelogJson = mergeChangelogJsonConfig(userConfig?.changelogJson);
   const releaseNotes = mergeReleaseNotesConfig(userConfig?.releaseNotes);
+  assertNoTagPrefixCollisions(workspaces, userConfig?.retiredPackages, project);
   const result = {
-    components,
+    workspaces,
     workTypes,
     versionPatterns,
     changelogJson,
     releaseNotes
   };
+  if (project !== void 0) {
+    result.project = project;
+  }
   const formatCommand = userConfig?.formatCommand;
   if (formatCommand !== void 0) {
     result.formatCommand = formatCommand;
@@ -63,7 +107,10 @@ function mergeMonorepoConfig(discoveredPaths, userConfig) {
   return result;
 }
 function mergeSinglePackageConfig(userConfig) {
-  const workTypes = userConfig?.workTypes === void 0 ? { ...DEFAULT_WORK_TYPES } : { ...DEFAULT_WORK_TYPES, ...userConfig.workTypes };
+  if (userConfig?.project !== void 0) {
+    throw new Error("project block is not supported in single-package mode");
+  }
+  const workTypes = resolveWorkTypes(userConfig?.workTypes);
   const versionPatterns = userConfig?.versionPatterns === void 0 ? { ...DEFAULT_VERSION_PATTERNS } : { ...userConfig.versionPatterns };
   const changelogJson = mergeChangelogJsonConfig(userConfig?.changelogJson);
   const releaseNotes = mergeReleaseNotesConfig(userConfig?.releaseNotes);
@@ -90,6 +137,9 @@ function mergeSinglePackageConfig(userConfig) {
   }
   return result;
 }
+function resolveWorkTypes(userWorkTypes) {
+  return userWorkTypes === void 0 ? { ...DEFAULT_WORK_TYPES } : { ...DEFAULT_WORK_TYPES, ...userWorkTypes };
+}
 function mergeChangelogJsonConfig(partial) {
   if (partial === void 0) {
     return { ...DEFAULT_CHANGELOG_JSON_CONFIG };
@@ -100,18 +150,115 @@ function mergeChangelogJsonConfig(partial) {
     devOnlySections: partial.devOnlySections ?? [...DEFAULT_CHANGELOG_JSON_CONFIG.devOnlySections]
   };
 }
+function assertLegacyIdentityDoesNotMatchCurrent(dir, currentName, currentTagPrefix, legacyIdentities) {
+  for (const identity of legacyIdentities) {
+    if (identity.name === currentName && identity.tagPrefix === currentTagPrefix) {
+      throw new Error(
+        `Workspace '${dir}': legacyIdentities must not match the current identity (name='${currentName}', tagPrefix='${currentTagPrefix}'). The current identity is always searched; listing it again is a no-op.`
+      );
+    }
+  }
+}
+function assertRetiredPackagesDoNotCollideWithActive(workspaces, retiredPackages) {
+  const workspaceByDerivedPrefix = /* @__PURE__ */ new Map();
+  for (const workspace of workspaces) {
+    workspaceByDerivedPrefix.set(workspace.tagPrefix, workspace);
+  }
+  for (const retired of retiredPackages) {
+    const active = workspaceByDerivedPrefix.get(retired.tagPrefix);
+    if (active !== void 0) {
+      throw new Error(
+        `retiredPackages: tagPrefix '${retired.tagPrefix}' collides with active workspace '${active.dir}' (derived prefix '${active.tagPrefix}'). A retired package's tagPrefix cannot belong to an active workspace.`
+      );
+    }
+  }
+}
+function resolveProjectConfig(userProject, rootPackage) {
+  if (userProject === void 0) {
+    return void 0;
+  }
+  if (rootPackage === void 0 || !rootPackage.exists) {
+    throw new Error(
+      `project block requires a root ${ROOT_PACKAGE_JSON_PATH}; create one with a 'version' field at the repo root`
+    );
+  }
+  if (rootPackage.version === void 0) {
+    throw new Error(
+      `project block requires root ${ROOT_PACKAGE_JSON_PATH} to have a 'version' field; add a 'version' field to your root package.json`
+    );
+  }
+  return { tagPrefix: userProject.tagPrefix ?? DEFAULT_PROJECT_TAG_PREFIX };
+}
+function assertNoTagPrefixCollisions(workspaces, retiredPackages, project) {
+  const sources = [];
+  for (const workspace of workspaces) {
+    const owner = `ws:${workspace.dir}`;
+    sources.push({ prefix: workspace.tagPrefix, label: `workspace '${workspace.dir}'`, owner });
+    for (const identity of workspace.legacyIdentities ?? []) {
+      sources.push({
+        prefix: identity.tagPrefix,
+        label: `workspace '${workspace.dir}' legacyIdentities entry (name='${identity.name}')`,
+        owner
+      });
+    }
+  }
+  for (const [index, retired] of (retiredPackages ?? []).entries()) {
+    sources.push({
+      prefix: retired.tagPrefix,
+      label: `retiredPackages entry (name='${retired.name}')`,
+      owner: `retired:${index}`
+    });
+  }
+  if (project !== void 0) {
+    sources.push({ prefix: project.tagPrefix, label: "project", owner: "project" });
+  }
+  for (let i = 0; i < sources.length; i++) {
+    for (let j = i + 1; j < sources.length; j++) {
+      const a = sources[i];
+      const b = sources[j];
+      if (a === void 0 || b === void 0) continue;
+      if (a.owner === b.owner) continue;
+      if (isPrefixCollision(a.prefix, b.prefix)) {
+        throw new Error(
+          `Tag prefix collision: '${a.prefix}' (${a.label}) and '${b.prefix}' (${b.label}). One prefix is identical to or a strict prefix of the other; this would cause \`git describe --match=<prefix>*\` to return cross-matches.`
+        );
+      }
+    }
+  }
+}
+function isPrefixCollision(a, b) {
+  return a === b || a.startsWith(b) || b.startsWith(a);
+}
+function assertUniqueTagPrefixes(workspaces) {
+  const pathsByPrefix = /* @__PURE__ */ new Map();
+  for (const workspace of workspaces) {
+    const existing = pathsByPrefix.get(workspace.tagPrefix);
+    if (existing === void 0) {
+      pathsByPrefix.set(workspace.tagPrefix, [workspace.workspacePath]);
+    } else {
+      existing.push(workspace.workspacePath);
+    }
+  }
+  for (const [prefix, paths] of pathsByPrefix) {
+    if (paths.length > 1) {
+      throw new Error(`Duplicate tag prefix '${prefix}' for workspaces: ${paths.join(", ")}`);
+    }
+  }
+}
 function mergeReleaseNotesConfig(partial) {
   if (partial === void 0) {
     return { ...DEFAULT_RELEASE_NOTES_CONFIG };
   }
   return {
-    shouldInjectIntoReadme: partial.shouldInjectIntoReadme ?? DEFAULT_RELEASE_NOTES_CONFIG.shouldInjectIntoReadme,
-    shouldCreateGithubRelease: partial.shouldCreateGithubRelease ?? DEFAULT_RELEASE_NOTES_CONFIG.shouldCreateGithubRelease
+    shouldInjectIntoReadme: partial.shouldInjectIntoReadme ?? DEFAULT_RELEASE_NOTES_CONFIG.shouldInjectIntoReadme
   };
 }
 export {
   CONFIG_FILE_PATH,
+  ROOT_PACKAGE_JSON_PATH,
   loadConfig,
   mergeMonorepoConfig,
-  mergeSinglePackageConfig
+  mergeSinglePackageConfig,
+  readRootPackageVersion,
+  resolveWorkTypes
 };

package/dist/esm/parseRequestedTags.d.ts

@@ -0,0 +1 @@
+export declare function parseRequestedTags(flagValue: string | undefined): string[] | undefined;

package/dist/esm/parseRequestedTags.js

@@ -0,0 +1,10 @@
+function parseRequestedTags(flagValue) {
+  if (flagValue === void 0) {
+    return void 0;
+  }
+  const segments = flagValue.split(",").filter(Boolean);
+  return segments.length === 0 ? void 0 : segments;
+}
+export {
+  parseRequestedTags
+};

package/dist/esm/prepareCommand.d.ts

@@ -1,4 +1,4 @@
-import type { WriteResult } from '@williamthorsen/node-monorepo-core';
+import type { WriteResult } from '@williamthorsen/nmr-core';
 import type { ReleaseType } from './types.ts';
 export declare const RELEASE_TAGS_FILE = "tmp/.release-tags";
 export declare const RELEASE_SUMMARY_FILE = "tmp/.release-summary";
@@ -8,6 +8,8 @@ export declare function parseArgs(argv: string[]): {
     noGitChecks: boolean;
     bumpOverride: ReleaseType | undefined;
     only: string[] | undefined;
+    setVersion: string | undefined;
+    withReleaseNotes: boolean;
 };
 export declare function writeReleaseTags(tags: string[], dryRun: boolean): WriteResult | undefined;
 export declare function prepareCommand(argv: string[]): Promise<void>;

package/dist/esm/prepareCommand.js

@@ -1,20 +1,20 @@
-import {
-  parseArgs as coreParseArgs,
-  translateParseError,
-  writeFileWithCheck
-} from "@williamthorsen/node-monorepo-core";
+import { parseArgs as coreParseArgs, translateParseError, writeFileWithCheck } from "@williamthorsen/nmr-core";
 import { assertCleanWorkingTree } from "./assertCleanWorkingTree.js";
+import { buildDependencyGraph } from "./buildDependencyGraph.js";
 import { buildReleaseSummary } from "./buildReleaseSummary.js";
 import { discoverWorkspaces } from "./discoverWorkspaces.js";
 import { dim } from "./format.js";
-import { loadConfig, mergeMonorepoConfig, mergeSinglePackageConfig } from "./loadConfig.js";
+import { getCommitsSinceTarget } from "./getCommitsSinceTarget.js";
+import { loadConfig, mergeMonorepoConfig, mergeSinglePackageConfig, readRootPackageVersion } from "./loadConfig.js";
 import { releasePrepare } from "./releasePrepare.js";
 import { releasePrepareMono } from "./releasePrepareMono.js";
 import { reportPrepare } from "./reportPrepare.js";
 import { validateConfig } from "./validateConfig.js";
+import { validateOnlyExcludesStrandedDependents } from "./validateOnlyExcludesStrandedDependents.js";
 const RELEASE_TAGS_FILE = "tmp/.release-tags";
 const RELEASE_SUMMARY_FILE = "tmp/.release-summary";
 const VALID_BUMP_TYPES = ["major", "minor", "patch"];
+const CANONICAL_SEMVER_PATTERN = /^\d+\.\d+\.\d+$/;
 function isReleaseType(value) {
   return VALID_BUMP_TYPES.includes(value);
 }
@@ -24,10 +24,18 @@ Usage: npx @williamthorsen/release-kit prepare [options]
 
 Options:
   --dry-run             Run without modifying any files
-  --bump=major|minor|patch  Override the bump type for all components
-  --force               Force a release even when there are no commits since the last tag (requires --bump)
+  --bump=major|minor|patch  Override the bump type for all workspaces
+  --set-version=X.Y.Z   Set an explicit version; bypasses commit-derived bumps.
+                         Requires --only in monorepo mode (rejected when a 'project' block is configured).
+  --force               Release even when no commits or no bump-worthy commits exist
+                         since the last tag. Defaults to patch when --bump is not given;
+                         use --bump=X to release at a different level.
   --no-git-checks, -n   Skip the clean-working-tree check
-  --only=name1,name2    Only process the named components (comma-separated, monorepo only)
+  --only=name1,name2    Only process the named workspaces (comma-separated, monorepo only;
+                         rejected when a 'project' block is configured)
+  --with-release-notes  Also write per-workspace release-notes previews under {workspacePath}/docs/
+                         (docs/README.v{version}.md and docs/RELEASE_NOTES.v{version}.md).
+                         Recommended .gitignore entry: packages/*/docs/*.v*.md (or docs/*.v*.md).
   --help                Show this help message
 `);
 }
@@ -40,7 +48,9 @@ const prepareFlagSchema = {
     short: "-n"
   },
   bump: { long: "--bump", type: "string" },
+  setVersion: { long: "--set-version", type: "string" },
   only: { long: "--only", type: "string" },
+  withReleaseNotes: { long: "--with-release-notes", type: "boolean" },
   help: { long: "--help", type: "boolean", short: "-h" }
 };
 function parseArgs(argv) {
@@ -62,19 +72,33 @@ function parseArgs(argv) {
     }
     bumpOverride = flags.bump;
   }
+  let setVersion;
+  if (flags.setVersion !== void 0) {
+    if (!CANONICAL_SEMVER_PATTERN.test(flags.setVersion)) {
+      throw new Error(
+        `Invalid --set-version value "${flags.setVersion}". Must be canonical semver (N.N.N, no pre-release suffix).`
+      );
+    }
+    setVersion = flags.setVersion;
+  }
   let only;
   if (flags.only !== void 0) {
     only = flags.only.split(",");
   }
-  if (flags.force && bumpOverride === void 0) {
-    throw new Error("--force requires --bump to specify the version bump type");
+  if (setVersion !== void 0 && bumpOverride !== void 0) {
+    throw new Error("--set-version cannot be combined with --bump");
+  }
+  if (setVersion !== void 0 && flags.force) {
+    throw new Error("--set-version cannot be combined with --force");
   }
   return {
     dryRun: flags.dryRun,
     force: flags.force,
     noGitChecks: flags.noGitChecks,
     bumpOverride,
-    only
+    only,
+    setVersion,
+    withReleaseNotes: flags.withReleaseNotes
   };
 }
 function writeReleaseTags(tags, dryRun) {
@@ -92,8 +116,10 @@ async function prepareCommand(argv) {
   let noGitChecks;
   let bumpOverride;
   let only;
+  let setVersion;
+  let withReleaseNotes;
   try {
-    ({ dryRun, force, noGitChecks, bumpOverride, only } = parseArgs(argv));
+    ({ dryRun, force, noGitChecks, bumpOverride, only, setVersion, withReleaseNotes } = parseArgs(argv));
   } catch (error) {
     console.error(`Error: ${error instanceof Error ? error.message : String(error)}`);
     process.exit(1);
@@ -101,7 +127,9 @@ async function prepareCommand(argv) {
   const options = {
     dryRun,
     force,
-    ...bumpOverride === void 0 ? {} : { bumpOverride }
+    ...bumpOverride === void 0 ? {} : { bumpOverride },
+    ...setVersion === void 0 ? {} : { setVersion },
+    ...withReleaseNotes ? { withReleaseNotes: true } : {}
   };
   if (dryRun) {
     console.info("\n\u{1F50D} DRY RUN \u2014 no files will be modified\n");
@@ -123,26 +151,88 @@ async function prepareCommand(argv) {
     process.exit(1);
   }
   if (discoveredPaths === void 0) {
-    if (only !== void 0) {
-      console.error("Error: --only is only supported for monorepo configurations");
-      process.exit(1);
-    }
-    const config = mergeSinglePackageConfig(userConfig);
-    runAndReport(() => releasePrepare(config, options), dryRun);
+    runSinglePackageMode(userConfig, options, only, dryRun);
   } else {
-    const config = mergeMonorepoConfig(discoveredPaths, userConfig);
-    if (only !== void 0) {
-      const knownNames = config.components.map((c) => c.dir);
-      for (const name of only) {
-        if (!knownNames.includes(name)) {
-          console.error(`Error: Unknown component "${name}". Known components: ${knownNames.join(", ")}`);
-          process.exit(1);
-        }
+    runMonorepoMode(discoveredPaths, userConfig, options, only, setVersion, dryRun);
+  }
+}
+function runSinglePackageMode(userConfig, options, only, dryRun) {
+  if (only !== void 0) {
+    console.error("Error: --only is only supported for monorepo configurations");
+    process.exit(1);
+  }
+  if (options.force && options.bumpOverride === void 0) {
+    console.error(
+      "Error: --force without --bump is only supported for monorepo configurations. Use --bump=major|minor|patch to set the level for a single-package release."
+    );
+    process.exit(1);
+  }
+  const config = mergeSinglePackageConfig(userConfig);
+  runAndReport(() => releasePrepare(config, options), dryRun);
+}
+function runMonorepoMode(discoveredPaths, userConfig, options, only, setVersion, dryRun) {
+  let config;
+  try {
+    const rootPackage = readRootPackageVersion();
+    config = mergeMonorepoConfig(discoveredPaths, userConfig, rootPackage);
+  } catch (error) {
+    console.error(`Error resolving workspaces: ${error instanceof Error ? error.message : String(error)}`);
+    process.exit(1);
+  }
+  if (setVersion !== void 0 && config.project !== void 0) {
+    console.error(
+      "Error: --set-version cannot be combined with a project release. --set-version operates on a single workspace; a project release rolls up every contributing workspace. To use --set-version, run on a config without a `project` block."
+    );
+    process.exit(1);
+  }
+  if (only !== void 0 && config.project !== void 0) {
+    console.error(
+      "Error: --only cannot be combined with a project release. To release a single workspace, use a config without a `project` block, or run a full `prepare` (no --only) to include the project release."
+    );
+    process.exit(1);
+  }
+  if (only !== void 0) {
+    const knownNames = config.workspaces.map((w) => w.dir);
+    for (const name of only) {
+      if (!knownNames.includes(name)) {
+        console.error(`Error: Unknown workspace "${name}". Known workspaces: ${knownNames.join(", ")}`);
+        process.exit(1);
+      }
+    }
+    const graph = buildDependencyGraph(config.workspaces);
+    const violations = validateOnlyExcludesStrandedDependents(config.workspaces, only, graph, (workspace) => {
+      const tagPrefixes = [
+        workspace.tagPrefix,
+        ...workspace.legacyIdentities?.map((identity) => identity.tagPrefix) ?? []
+      ];
+      const result = getCommitsSinceTarget(tagPrefixes, workspace.paths);
+      return { has: result.commits.length > 0, tag: result.tag };
+    });
+    if (violations !== void 0) {
+      console.error("Error: --only excludes packages with changes that would be stranded by the release.");
+      console.error("The following packages must be added to --only or have their dependencies removed:");
+      for (const violation of violations) {
+        const since = violation.tag ?? "the beginning";
+        console.error(`  - ${violation.dir} (downstream of ${violation.downstreamOf}; has commits since ${since})`);
       }
-      config.components = config.components.filter((c) => only.includes(c.dir));
+      console.error("Alternatively, run `release-kit prepare` without --only to release everything.");
+      process.exit(1);
+    }
+    config.workspaces = config.workspaces.filter((w) => only.includes(w.dir));
+  }
+  if (setVersion !== void 0) {
+    if (only === void 0) {
+      console.error("Error: --set-version requires --only in monorepo mode");
+      process.exit(1);
+    }
+    if (config.workspaces.length !== 1) {
+      console.error(
+        `Error: --set-version requires --only to match exactly one workspace; matched ${config.workspaces.length}`
+      );
+      process.exit(1);
     }
-    runAndReport(() => releasePrepareMono(config, options), dryRun);
   }
+  runAndReport(() => releasePrepareMono(config, options), dryRun);
 }
 async function loadAndValidateConfig() {
   let rawConfig;
@@ -173,7 +263,7 @@ function runAndReport(execute, dryRun) {
   try {
     result = execute();
   } catch (error) {
-    console.error("Error preparing release:", error instanceof Error ? error.message : String(error));
+    console.error(error instanceof Error ? error.message : String(error));
     process.exit(1);
   }
   process.stdout.write(reportPrepare(result) + "\n");

package/dist/esm/previewTagPrefixes.d.ts

@@ -0,0 +1,30 @@
+import type { UndeclaredTagPrefix } from './detectUndeclaredTagPrefixes.ts';
+export interface TagPrefixPreviewRow {
+    workspacePath: string;
+    dir: string;
+    derivedPrefix: string | null;
+    derivationError: string | null;
+    derivedTagCount: number;
+    legacyEntries: LegacyTagPrefixEntry[];
+}
+export interface LegacyTagPrefixEntry {
+    prefix: string;
+    tagCount: number;
+}
+export interface RetiredPackagePreviewEntry {
+    name: string;
+    tagPrefix: string;
+    successor?: string;
+    tagCount: number;
+}
+export interface TagPrefixCollision {
+    tagPrefix: string;
+    workspacePaths: string[];
+}
+export interface TagPrefixPreview {
+    workspaces: TagPrefixPreviewRow[];
+    collisions: TagPrefixCollision[];
+    undeclaredCandidates: UndeclaredTagPrefix[];
+    retiredPackages: RetiredPackagePreviewEntry[];
+}
+export declare function previewTagPrefixes(): Promise<TagPrefixPreview>;

package/dist/esm/previewTagPrefixes.js

@@ -0,0 +1,120 @@
+import { execFileSync } from "node:child_process";
+import { basename } from "node:path";
+import { deriveWorkspaceConfig } from "./deriveWorkspaceConfig.js";
+import { detectUndeclaredTagPrefixes } from "./detectUndeclaredTagPrefixes.js";
+import { discoverWorkspaces } from "./discoverWorkspaces.js";
+import { loadConfig } from "./loadConfig.js";
+import { validateConfig } from "./validateConfig.js";
+async function previewTagPrefixes() {
+  const workspacePaths = await discoverWorkspaces() ?? [];
+  const userConfig = await loadUserConfig();
+  const overridesByDir = buildOverrideMap(userConfig);
+  const workspaces = [];
+  for (const workspacePath of workspacePaths) {
+    workspaces.push(buildPreviewRow(workspacePath, overridesByDir));
+  }
+  const retiredPackages = buildRetiredPreviewEntries(userConfig?.retiredPackages ?? []);
+  const collisions = detectCollisions(workspaces);
+  const knownPrefixes = collectKnownPrefixes(workspaces, retiredPackages);
+  const undeclaredCandidates = detectUndeclaredTagPrefixes(knownPrefixes);
+  return { workspaces, collisions, undeclaredCandidates, retiredPackages };
+}
+async function loadUserConfig() {
+  let raw;
+  try {
+    raw = await loadConfig();
+  } catch {
+    return void 0;
+  }
+  if (raw === void 0) return void 0;
+  const { config, errors } = validateConfig(raw);
+  return errors.length === 0 ? config : void 0;
+}
+function buildOverrideMap(userConfig) {
+  const map = /* @__PURE__ */ new Map();
+  if (userConfig?.workspaces === void 0) return map;
+  for (const entry of userConfig.workspaces) {
+    if (entry.legacyIdentities !== void 0) {
+      map.set(entry.dir, entry.legacyIdentities);
+    }
+  }
+  return map;
+}
+function buildPreviewRow(workspacePath, overridesByDir) {
+  const dir = basename(workspacePath);
+  let derivedPrefix = null;
+  let derivationError = null;
+  try {
+    derivedPrefix = deriveWorkspaceConfig(workspacePath).tagPrefix;
+  } catch (error) {
+    derivationError = error instanceof Error ? error.message : String(error);
+  }
+  const derivedTagCount = derivedPrefix === null ? 0 : countTagsMatching(derivedPrefix);
+  const declaredIdentities = overridesByDir.get(dir) ?? [];
+  const legacyEntries = declaredIdentities.map((identity) => ({
+    prefix: identity.tagPrefix,
+    tagCount: countTagsMatching(identity.tagPrefix)
+  }));
+  return {
+    workspacePath,
+    dir,
+    derivedPrefix,
+    derivationError,
+    derivedTagCount,
+    legacyEntries
+  };
+}
+function countTagsMatching(prefix) {
+  try {
+    const output = execFileSync("git", ["tag", "--list", `${prefix}*`], {
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return output.split("\n").filter((line) => line.trim() !== "").length;
+  } catch {
+    return 0;
+  }
+}
+function detectCollisions(rows) {
+  const pathsByPrefix = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (row.derivedPrefix === null) continue;
+    const existing = pathsByPrefix.get(row.derivedPrefix);
+    if (existing === void 0) {
+      pathsByPrefix.set(row.derivedPrefix, [row.workspacePath]);
+    } else {
+      existing.push(row.workspacePath);
+    }
+  }
+  const collisions = [];
+  for (const [tagPrefix, workspacePaths] of pathsByPrefix) {
+    if (workspacePaths.length > 1) {
+      collisions.push({ tagPrefix, workspacePaths });
+    }
+  }
+  return collisions;
+}
+function collectKnownPrefixes(rows, retiredPackages) {
+  const known = /* @__PURE__ */ new Set();
+  for (const row of rows) {
+    if (row.derivedPrefix !== null) known.add(row.derivedPrefix);
+    for (const entry of row.legacyEntries) {
+      known.add(entry.prefix);
+    }
+  }
+  for (const retired of retiredPackages) {
+    known.add(retired.tagPrefix);
+  }
+  return [...known];
+}
+function buildRetiredPreviewEntries(retiredPackages) {
+  return retiredPackages.map((retired) => ({
+    name: retired.name,
+    tagPrefix: retired.tagPrefix,
+    tagCount: countTagsMatching(retired.tagPrefix),
+    ...retired.successor !== void 0 ? { successor: retired.successor } : {}
+  }));
+}
+export {
+  previewTagPrefixes
+};

package/dist/esm/propagateBumps.d.ts

@@ -3,6 +3,7 @@ import type { PropagationSource, ReleaseType } from './types.ts';
 export interface ReleaseEntry {
     releaseType: ReleaseType;
     propagatedFrom?: PropagationSource[];
+    newVersionOverride?: string;
 }
 export type CurrentVersions = Map<string, string>;
 export declare function propagateBumps(directBumps: Map<string, ReleaseEntry>, graph: DependencyGraph, currentVersions: CurrentVersions): Map<string, ReleaseEntry>;

package/dist/esm/propagateBumps.js

@@ -24,7 +24,7 @@ function propagateBumps(directBumps, graph, currentVersions) {
     if (currentVersion === void 0 || entry === void 0) {
       continue;
     }
-    const newVersion = bumpVersion(currentVersion, entry.releaseType);
+    const newVersion = entry.newVersionOverride ?? bumpVersion(currentVersion, entry.releaseType);
     const dependents = graph.dependentsOf.get(packageName);
     if (dependents === void 0) {
       continue;

package/dist/esm/publish.d.ts

@@ -2,7 +2,6 @@ import type { PackageManager } from './detectPackageManager.ts';
 import type { ResolvedTag } from './resolveReleaseTags.ts';
 export interface PublishOptions {
     dryRun: boolean;
-    noGitChecks: boolean;
     provenance: boolean;
 }
 export declare function publishPackage(resolvedTag: ResolvedTag, packageManager: PackageManager, options: PublishOptions): void;