@releasekit/version 0.7.45 → 0.7.46

package/dist/{chunk-45DJUNXI.js → chunk-V44UWRAP.js}

@@ -1,413 +1,13 @@
 import {
-  BaseVersionError,
-  ReleaseKitError,
-  sanitizePackageName
-} from "./chunk-Q3FHZORY.js";
+  BaseVersionError
+} from "./chunk-3FG6RVHS.js";
 import {
   execAsync,
   execSync
 } from "./chunk-LMPZV35Z.js";
 
-// ../config/dist/index.js
-import * as fs from "fs";
-import * as path from "path";
-import * as TOML from "smol-toml";
-import * as fs3 from "fs";
-import * as path3 from "path";
-import { z as z2 } from "zod";
-import { z } from "zod";
-import * as fs2 from "fs";
-import * as os from "os";
-import * as path2 from "path";
-function parseCargoToml(cargoPath) {
-  const content = fs.readFileSync(cargoPath, "utf-8");
-  return TOML.parse(content);
-}
-function isCargoToml(filePath) {
-  return path.basename(filePath) === "Cargo.toml";
-}
-var ConfigError = class extends ReleaseKitError {
-  code = "CONFIG_ERROR";
-  suggestions;
-  constructor(message, suggestions) {
-    super(message);
-    this.suggestions = suggestions ?? [
-      "Check that releasekit.config.json exists and is valid JSON",
-      "Run with --verbose for more details"
-    ];
-  }
-};
-var MAX_JSONC_LENGTH = 1e5;
-function parseJsonc(content) {
-  if (content.length > MAX_JSONC_LENGTH) {
-    throw new Error(`JSONC content too long: ${content.length} characters (max ${MAX_JSONC_LENGTH})`);
-  }
-  try {
-    return JSON.parse(content);
-  } catch {
-    const cleaned = content.replace(/\/\/[^\r\n]{0,10000}$/gm, "").replace(/\/\*[\s\S]{0,50000}?\*\//g, "").trim();
-    return JSON.parse(cleaned);
-  }
-}
-var GitConfigSchema = z.object({
-  remote: z.string().default("origin"),
-  branch: z.string().default("main"),
-  pushMethod: z.enum(["auto", "ssh", "https"]).default("auto"),
-  /**
-   * Optional env var name containing a GitHub token for HTTPS pushes.
-   * When set, publish steps can use this token without mutating git remotes.
-   */
-  httpsTokenEnv: z.string().optional(),
-  push: z.boolean().optional(),
-  skipHooks: z.boolean().optional()
-});
-var MonorepoConfigSchema = z.object({
-  mode: z.enum(["root", "packages", "both"]).optional(),
-  rootPath: z.string().optional(),
-  packagesPath: z.string().optional(),
-  mainPackage: z.string().optional()
-});
-var BranchPatternSchema = z.object({
-  pattern: z.string(),
-  releaseType: z.enum(["major", "minor", "patch", "prerelease"])
-});
-var VersionCargoConfigSchema = z.object({
-  enabled: z.boolean().default(true),
-  paths: z.array(z.string()).optional()
-});
-var VersionConfigSchema = z.object({
-  tagTemplate: z.string().default("v{version}"),
-  packageSpecificTags: z.boolean().default(false),
-  preset: z.string().default("conventional"),
-  sync: z.boolean().default(true),
-  packages: z.array(z.string()).default([]),
-  mainPackage: z.string().optional(),
-  updateInternalDependencies: z.enum(["major", "minor", "patch", "no-internal-update"]).default("minor"),
-  skip: z.array(z.string()).optional(),
-  commitMessage: z.string().optional(),
-  versionStrategy: z.enum(["branchPattern", "commitMessage"]).default("commitMessage"),
-  branchPatterns: z.array(BranchPatternSchema).optional(),
-  defaultReleaseType: z.enum(["major", "minor", "patch", "prerelease"]).optional(),
-  mismatchStrategy: z.enum(["error", "warn", "ignore", "prefer-package", "prefer-git"]).default("warn"),
-  versionPrefix: z.string().default(""),
-  prereleaseIdentifier: z.string().optional(),
-  strictReachable: z.boolean().default(false),
-  cargo: VersionCargoConfigSchema.optional()
-});
-var NpmConfigSchema = z.object({
-  enabled: z.boolean().default(true),
-  auth: z.enum(["auto", "oidc", "token"]).default("auto"),
-  provenance: z.boolean().default(true),
-  access: z.enum(["public", "restricted"]).default("public"),
-  registry: z.string().default("https://registry.npmjs.org"),
-  copyFiles: z.array(z.string()).default(["LICENSE"]),
-  tag: z.string().default("latest")
-});
-var CargoPublishConfigSchema = z.object({
-  enabled: z.boolean().default(false),
-  noVerify: z.boolean().default(false),
-  publishOrder: z.array(z.string()).default([]),
-  clean: z.boolean().default(false)
-});
-var PublishGitConfigSchema = z.object({
-  push: z.boolean().default(true),
-  pushMethod: z.enum(["auto", "ssh", "https"]).optional(),
-  remote: z.string().optional(),
-  branch: z.string().optional(),
-  httpsTokenEnv: z.string().optional(),
-  skipHooks: z.boolean().optional()
-});
-var GitHubReleaseConfigSchema = z.object({
-  enabled: z.boolean().default(true),
-  draft: z.boolean().default(true),
-  perPackage: z.boolean().default(true),
-  prerelease: z.union([z.literal("auto"), z.boolean()]).default("auto"),
-  /**
-   * Controls the source for the GitHub release body.
-   * - 'auto': Use release notes if enabled, else changelog, else GitHub auto-generated.
-   * - 'releaseNotes': Use LLM-generated release notes (requires notes.releaseNotes.enabled: true).
-   * - 'changelog': Use formatted changelog entries.
-   * - 'generated': Use GitHub's auto-generated notes.
-   * - 'none': No body.
-   */
-  body: z.enum(["auto", "releaseNotes", "changelog", "generated", "none"]).default("auto"),
-  /**
-   * Template string for the GitHub release title when a package name is resolved.
-   * Available variables: ${packageName} (original scoped name), ${version} (e.g. "v1.0.0").
-   * Version-only tags (e.g. "v1.0.0") always use the tag as-is.
-   */
-  /* biome-ignore lint/suspicious/noTemplateCurlyInString: default template value */
-  titleTemplate: z.string().default("${packageName}: ${version}")
-});
-var VerifyRegistryConfigSchema = z.object({
-  enabled: z.boolean().default(true),
-  maxAttempts: z.number().int().positive().default(5),
-  initialDelay: z.number().int().positive().default(15e3),
-  backoffMultiplier: z.number().positive().default(2)
-});
-var VerifyConfigSchema = z.object({
-  npm: VerifyRegistryConfigSchema.default({
-    enabled: true,
-    maxAttempts: 5,
-    initialDelay: 15e3,
-    backoffMultiplier: 2
-  }),
-  cargo: VerifyRegistryConfigSchema.default({
-    enabled: true,
-    maxAttempts: 10,
-    initialDelay: 3e4,
-    backoffMultiplier: 2
-  })
-});
-var PublishConfigSchema = z.object({
-  git: PublishGitConfigSchema.optional(),
-  npm: NpmConfigSchema.default({
-    enabled: true,
-    auth: "auto",
-    provenance: true,
-    access: "public",
-    registry: "https://registry.npmjs.org",
-    copyFiles: ["LICENSE"],
-    tag: "latest"
-  }),
-  cargo: CargoPublishConfigSchema.default({
-    enabled: false,
-    noVerify: false,
-    publishOrder: [],
-    clean: false
-  }),
-  githubRelease: GitHubReleaseConfigSchema.default({
-    enabled: true,
-    draft: true,
-    perPackage: true,
-    prerelease: "auto",
-    body: "auto",
-    /* biome-ignore lint/suspicious/noTemplateCurlyInString: default template value */
-    titleTemplate: "${packageName}: ${version}"
-  }),
-  verify: VerifyConfigSchema.default({
-    npm: {
-      enabled: true,
-      maxAttempts: 5,
-      initialDelay: 15e3,
-      backoffMultiplier: 2
-    },
-    cargo: {
-      enabled: true,
-      maxAttempts: 10,
-      initialDelay: 3e4,
-      backoffMultiplier: 2
-    }
-  })
-});
-var TemplateConfigSchema = z.object({
-  path: z.string().optional(),
-  engine: z.enum(["handlebars", "liquid", "ejs"]).optional()
-});
-var LocationModeSchema = z.enum(["root", "packages", "both"]);
-var ChangelogConfigSchema = z.object({
-  mode: LocationModeSchema.optional(),
-  file: z.string().optional(),
-  templates: TemplateConfigSchema.optional()
-});
-var LLMOptionsSchema = z.object({
-  timeout: z.number().optional(),
-  maxTokens: z.number().optional(),
-  temperature: z.number().optional()
-});
-var LLMRetryConfigSchema = z.object({
-  maxAttempts: z.number().int().positive().optional(),
-  initialDelay: z.number().nonnegative().optional(),
-  maxDelay: z.number().positive().optional(),
-  backoffFactor: z.number().positive().optional()
-});
-var LLMTasksConfigSchema = z.object({
-  summarize: z.boolean().optional(),
-  enhance: z.boolean().optional(),
-  categorize: z.boolean().optional(),
-  releaseNotes: z.boolean().optional()
-});
-var LLMCategorySchema = z.object({
-  name: z.string(),
-  description: z.string(),
-  scopes: z.array(z.string()).optional()
-});
-var ScopeRulesSchema = z.object({
-  allowed: z.array(z.string()).optional(),
-  caseSensitive: z.boolean().default(false),
-  invalidScopeAction: z.enum(["remove", "keep", "fallback"]).default("remove"),
-  fallbackScope: z.string().optional()
-});
-var ScopeConfigSchema = z.object({
-  mode: z.enum(["restricted", "packages", "none", "unrestricted"]).default("unrestricted"),
-  rules: ScopeRulesSchema.optional()
-});
-var LLMPromptOverridesSchema = z.object({
-  enhance: z.string().optional(),
-  categorize: z.string().optional(),
-  enhanceAndCategorize: z.string().optional(),
-  summarize: z.string().optional(),
-  releaseNotes: z.string().optional()
-});
-var LLMPromptsConfigSchema = z.object({
-  instructions: LLMPromptOverridesSchema.optional(),
-  templates: LLMPromptOverridesSchema.optional()
-});
-var LLMConfigSchema = z.object({
-  provider: z.string(),
-  model: z.string(),
-  baseURL: z.string().optional(),
-  apiKey: z.string().optional(),
-  options: LLMOptionsSchema.optional(),
-  concurrency: z.number().int().positive().optional(),
-  retry: LLMRetryConfigSchema.optional(),
-  tasks: LLMTasksConfigSchema.optional(),
-  categories: z.array(LLMCategorySchema).optional(),
-  style: z.string().optional(),
-  scopes: ScopeConfigSchema.optional(),
-  prompts: LLMPromptsConfigSchema.optional()
-});
-var ReleaseNotesConfigSchema = z.object({
-  mode: LocationModeSchema.optional(),
-  file: z.string().optional(),
-  templates: TemplateConfigSchema.optional(),
-  llm: LLMConfigSchema.optional()
-});
-var NotesInputConfigSchema = z.object({
-  source: z.string().optional(),
-  file: z.string().optional()
-});
-var NotesConfigSchema = z.object({
-  changelog: z.union([z.literal(false), ChangelogConfigSchema]).optional(),
-  releaseNotes: z.union([z.literal(false), ReleaseNotesConfigSchema]).optional(),
-  updateStrategy: z.enum(["prepend", "regenerate"]).optional()
-});
-var CILabelsConfigSchema = z.object({
-  stable: z.string().default("release:stable"),
-  prerelease: z.string().default("release:prerelease"),
-  skip: z.string().default("release:skip"),
-  major: z.string().default("release:major"),
-  minor: z.string().default("release:minor"),
-  patch: z.string().default("release:patch")
-});
-var CIConfigSchema = z.object({
-  releaseStrategy: z.enum(["manual", "direct", "standing-pr", "scheduled"]).default("direct"),
-  releaseTrigger: z.enum(["commit", "label"]).default("label"),
-  prPreview: z.boolean().default(true),
-  autoRelease: z.boolean().default(false),
-  /**
-   * Commit message prefixes that should not trigger a release.
-   * Defaults to `['chore: release ']` to match the release commit template
-   * (`chore: release ${packageName} v${version}`) and provide a
-   * secondary loop-prevention guard alongside `[skip ci]`.
-   */
-  skipPatterns: z.array(z.string()).default(["chore: release "]),
-  minChanges: z.number().int().positive().default(1),
-  labels: CILabelsConfigSchema.default({
-    stable: "release:stable",
-    prerelease: "release:prerelease",
-    skip: "release:skip",
-    major: "release:major",
-    minor: "release:minor",
-    patch: "release:patch"
-  })
-});
-var ReleaseCIConfigSchema = z.object({
-  skipPatterns: z.array(z.string().min(1)).optional(),
-  minChanges: z.number().int().positive().optional(),
-  /** Set to `false` to disable GitHub release creation in CI. */
-  githubRelease: z.literal(false).optional(),
-  /** Set to `false` to disable changelog generation in CI. */
-  notes: z.literal(false).optional()
-});
-var ReleaseConfigSchema = z.object({
-  /**
-   * Optional steps to enable. The version step always runs; only 'notes' and
-   * 'publish' can be opted out. Omitting a step is equivalent to --skip-<step>.
-   */
-  steps: z.array(z.enum(["notes", "publish"])).min(1).optional(),
-  ci: ReleaseCIConfigSchema.optional()
-});
-var ReleaseKitConfigSchema = z.object({
-  git: GitConfigSchema.optional(),
-  monorepo: MonorepoConfigSchema.optional(),
-  version: VersionConfigSchema.optional(),
-  publish: PublishConfigSchema.optional(),
-  notes: NotesConfigSchema.optional(),
-  ci: CIConfigSchema.optional(),
-  release: ReleaseConfigSchema.optional()
-});
-var MAX_INPUT_LENGTH = 1e4;
-function substituteVariables(value) {
-  if (value.length > MAX_INPUT_LENGTH) {
-    throw new Error(`Input too long: ${value.length} characters (max ${MAX_INPUT_LENGTH})`);
-  }
-  const envPattern = /\{env:([^}]{1,1000})\}/g;
-  const filePattern = /\{file:([^}]{1,1000})\}/g;
-  let result = value;
-  result = result.replace(envPattern, (_, varName) => {
-    return process.env[varName] ?? "";
-  });
-  result = result.replace(filePattern, (_, filePath) => {
-    const expandedPath = filePath.startsWith("~") ? path2.join(os.homedir(), filePath.slice(1)) : filePath;
-    try {
-      return fs2.readFileSync(expandedPath, "utf-8").trim();
-    } catch {
-      return "";
-    }
-  });
-  return result;
-}
-var SOLE_REFERENCE_PATTERN = /^\{(?:env|file):[^}]+\}$/;
-function substituteInObject(obj) {
-  if (typeof obj === "string") {
-    const result = substituteVariables(obj);
-    if (result === "" && SOLE_REFERENCE_PATTERN.test(obj)) {
-      return void 0;
-    }
-    return result;
-  }
-  if (Array.isArray(obj)) {
-    return obj.map((item) => substituteInObject(item));
-  }
-  if (obj && typeof obj === "object") {
-    const result = {};
-    for (const [key, value] of Object.entries(obj)) {
-      result[key] = substituteInObject(value);
-    }
-    return result;
-  }
-  return obj;
-}
-var AUTH_DIR = path2.join(os.homedir(), ".config", "releasekit");
-var AUTH_FILE = path2.join(AUTH_DIR, "auth.json");
-var CONFIG_FILE = "releasekit.config.json";
-function loadConfigFile(configPath) {
-  if (!fs3.existsSync(configPath)) {
-    return {};
-  }
-  try {
-    const content = fs3.readFileSync(configPath, "utf-8");
-    const parsed = parseJsonc(content);
-    const substituted = substituteInObject(parsed);
-    return ReleaseKitConfigSchema.parse(substituted);
-  } catch (error) {
-    if (error instanceof z2.ZodError) {
-      const issues = error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n");
-      throw new ConfigError(`Config validation errors:
-${issues}`);
-    }
-    if (error instanceof SyntaxError) {
-      throw new ConfigError(`Invalid JSON in config file: ${error.message}`);
-    }
-    throw error;
-  }
-}
-function loadConfig(options) {
-  const cwd3 = options?.cwd ?? process.cwd();
-  const configPath = options?.configPath ?? path3.join(cwd3, CONFIG_FILE);
-  return loadConfigFile(configPath);
-}
+// src/config.ts
+import { loadConfig as loadReleaseKitConfig } from "@releasekit/config";
 
 // src/types.ts
 function toVersionConfig(config, gitConfig) {
@@ -448,8 +48,8 @@ function toVersionConfig(config, gitConfig) {
 }
 
 // src/config.ts
-function loadConfig2(options) {
-  const fullConfig = loadConfig(options);
+function loadConfig(options) {
+  const fullConfig = loadReleaseKitConfig(options);
   return toVersionConfig(fullConfig.version, fullConfig.git);
 }
 
@@ -511,7 +111,7 @@ function createVersionError(code, details) {
 }
 
 // src/utils/jsonOutput.ts
-import fs4 from "fs";
+import fs from "fs";
 var _jsonOutputMode = false;
 var _pendingWrites = [];
 var _jsonData = {
@@ -531,14 +131,14 @@ function enableJsonOutput(dryRun = false) {
   _jsonData.commitMessage = void 0;
   _pendingWrites.length = 0;
 }
-function recordPendingWrite(path11, content) {
+function recordPendingWrite(path7, content) {
   if (!_jsonOutputMode) return;
-  _pendingWrites.push({ path: path11, content });
+  _pendingWrites.push({ path: path7, content });
 }
 function flushPendingWrites() {
   try {
-    for (const { path: path11, content } of _pendingWrites) {
-      fs4.writeFileSync(path11, content);
+    for (const { path: path7, content } of _pendingWrites) {
+      fs.writeFileSync(path7, content);
     }
   } finally {
     _pendingWrites.length = 0;
@@ -582,690 +182,13 @@ function printJsonOutput() {
 
 // src/core/versionCalculator.ts
 import { cwd } from "process";
-
-// ../../node_modules/.pnpm/@conventional-changelog+git-client@2.5.1_conventional-commits-filter@5.0.0_conventional-commits-parser@6.2.1/node_modules/@conventional-changelog/git-client/dist/utils.js
-function formatArgs(...args) {
-  return args.reduce((finalArgs, arg) => {
-    if (arg) {
-      finalArgs.push(String(arg));
-    }
-    return finalArgs;
-  }, []);
-}
-function toArray(value) {
-  return Array.isArray(value) ? value : [value];
-}
-
-// ../../node_modules/.pnpm/@conventional-changelog+git-client@2.5.1_conventional-commits-filter@5.0.0_conventional-commits-parser@6.2.1/node_modules/@conventional-changelog/git-client/dist/GitClient.js
-import { spawn } from "child_process";
-
-// ../../node_modules/.pnpm/@simple-libs+stream-utils@1.1.0/node_modules/@simple-libs/stream-utils/dist/index.js
-import { Readable } from "stream";
-async function toArray2(iterable) {
-  const result = [];
-  for await (const item of iterable) {
-    result.push(item);
-  }
-  return result;
-}
-async function concatBufferStream(iterable) {
-  return Buffer.concat(await toArray2(iterable));
-}
-async function firstFromStream(stream) {
-  for await (const tag of stream) {
-    return tag;
-  }
-  return null;
-}
-async function* splitStream(stream, separator) {
-  let chunk;
-  let payload;
-  let buffer = "";
-  for await (chunk of stream) {
-    buffer += chunk.toString();
-    if (buffer.includes(separator)) {
-      payload = buffer.split(separator);
-      buffer = payload.pop() || "";
-      yield* payload;
-    }
-  }
-  if (buffer) {
-    yield buffer;
-  }
-}
-
-// ../../node_modules/.pnpm/@simple-libs+child-process-utils@1.0.1/node_modules/@simple-libs/child-process-utils/dist/index.js
-async function exitCode(process2) {
-  if (process2.exitCode !== null) {
-    return process2.exitCode;
-  }
-  return new Promise((resolve2) => process2.once("close", resolve2));
-}
-async function catchProcessError(process2) {
-  let error = new Error("Process exited with non-zero code");
-  let stderr = "";
-  process2.on("error", (err) => {
-    error = err;
-  });
-  if (process2.stderr) {
-    let chunk;
-    for await (chunk of process2.stderr) {
-      stderr += chunk.toString();
-    }
-  }
-  const code = await exitCode(process2);
-  if (stderr) {
-    error = new Error(stderr);
-  }
-  return code ? error : null;
-}
-async function* outputStream(process2) {
-  const { stdout } = process2;
-  const errorPromise = catchProcessError(process2);
-  if (stdout) {
-    stdout.on("error", (err) => {
-      if (err.name === "AbortError" && process2.exitCode === null) {
-        process2.kill("SIGKILL");
-      }
-    });
-    yield* stdout;
-  }
-  const error = await errorPromise;
-  if (error) {
-    throw error;
-  }
-}
-function output(process2) {
-  return concatBufferStream(outputStream(process2));
-}
-
-// ../../node_modules/.pnpm/@conventional-changelog+git-client@2.5.1_conventional-commits-filter@5.0.0_conventional-commits-parser@6.2.1/node_modules/@conventional-changelog/git-client/dist/GitClient.js
-var SCISSOR = "------------------------ >8 ------------------------";
-var GitClient = class {
-  cwd;
-  debug;
-  constructor(cwd3, debug) {
-    this.cwd = cwd3;
-    this.debug = debug;
-  }
-  formatArgs(...args) {
-    const finalArgs = formatArgs(...args);
-    if (this.debug) {
-      this.debug(finalArgs);
-    }
-    return finalArgs;
-  }
-  /**
-   * Raw exec method to run git commands.
-   * @param args
-   * @returns Stdout string output of the command.
-   */
-  async exec(...args) {
-    return (await output(spawn("git", this.formatArgs(...args), {
-      cwd: this.cwd
-    }))).toString().trim();
-  }
-  /**
-   * Raw exec method to run git commands with stream output.
-   * @param args
-   * @returns Stdout stream of the command.
-   */
-  execStream(...args) {
-    return outputStream(spawn("git", this.formatArgs(...args), {
-      cwd: this.cwd
-    }));
-  }
-  /**
-   * Initialize a new git repository.
-   * @returns Boolean result.
-   */
-  async init() {
-    try {
-      await this.exec("init");
-      return true;
-    } catch (err) {
-      return false;
-    }
-  }
-  /**
-   * Get raw commits stream.
-   * @param params
-   * @param params.path - Read commits from specific path.
-   * @param params.from - Start commits range.
-   * @param params.to - End commits range.
-   * @param params.format - Commits format.
-   * @yields Raw commits data.
-   */
-  async *getRawCommits(params = {}) {
-    const { path: path11, from = "", to = "HEAD", format = "%B", ignore, reverse, merges, since } = params;
-    const shouldNotIgnore = ignore ? (chunk2) => !ignore.test(chunk2) : () => true;
-    const stdout = this.execStream("log", `--format=${format}%n${SCISSOR}`, since && `--since=${since instanceof Date ? since.toISOString() : since}`, reverse && "--reverse", merges && "--merges", merges === false && "--no-merges", [from, to].filter(Boolean).join(".."), ...path11 ? ["--", ...toArray(path11)] : []);
-    const commitsStream = splitStream(stdout, `${SCISSOR}
-`);
-    let chunk;
-    for await (chunk of commitsStream) {
-      if (shouldNotIgnore(chunk)) {
-        yield chunk;
-      }
-    }
-  }
-  /**
-   * Get tags stream.
-   * @param params
-   * @yields Tags
-   */
-  async *getTags(params = {}) {
-    const { path: path11, from = "", to = "HEAD", since } = params;
-    const tagRegex = /tag:\s*(.+?)[,)]/gi;
-    const stdout = this.execStream("log", "--decorate", "--no-color", "--date-order", since && `--since=${since instanceof Date ? since.toISOString() : since}`, [from, to].filter(Boolean).join(".."), ...path11 ? ["--", ...toArray(path11)] : []);
-    let chunk;
-    let matches;
-    let tag;
-    for await (chunk of stdout) {
-      matches = chunk.toString().trim().matchAll(tagRegex);
-      for ([, tag] of matches) {
-        yield tag;
-      }
-    }
-  }
-  /**
-   * Get last tag.
-   * @param params
-   * @returns Last tag, `null` if not found.
-   */
-  async getLastTag(params) {
-    return firstFromStream(this.getTags(params));
-  }
-  /**
-   * Check file is ignored via .gitignore.
-   * @param file - Path to target file.
-   * @returns Boolean value.
-   */
-  async checkIgnore(file) {
-    try {
-      await this.exec("check-ignore", "--", file);
-      return true;
-    } catch (err) {
-      return false;
-    }
-  }
-  /**
-   * Add files to git index.
-   * @param files - Files to stage.
-   */
-  async add(files) {
-    await this.exec("add", "--", ...toArray(files));
-  }
-  /**
-   * Commit changes.
-   * @param params
-   * @param params.verify
-   * @param params.sign
-   * @param params.files
-   * @param params.allowEmpty
-   * @param params.message
-   */
-  async commit(params) {
-    const { verify = true, sign = false, files = [], allowEmpty = false, message } = params;
-    await this.exec("commit", !verify && "--no-verify", sign && "-S", allowEmpty && "--allow-empty", "-m", message, "--", ...files);
-  }
-  /**
-   * Create a tag for the current commit.
-   * @param params
-   * @param params.sign
-   * @param params.name
-   * @param params.message
-   */
-  async tag(params) {
-    let { sign = false, name, message } = params;
-    if (sign) {
-      message = "";
-    }
-    await this.exec("tag", sign && "-s", message && "-a", ...message ? ["-m", message] : [], "--", name);
-  }
-  /**
-   * Get current branch name.
-   * @returns Current branch name.
-   */
-  async getCurrentBranch() {
-    const branch = await this.exec("rev-parse", "--abbrev-ref", "HEAD");
-    return branch;
-  }
-  /**
-   * Get default branch name.
-   * @returns Default branch name.
-   */
-  async getDefaultBranch() {
-    const branch = (await this.exec("rev-parse", "--abbrev-ref", "origin/HEAD")).replace(/^origin\//, "");
-    return branch;
-  }
-  /**
-   * Push changes to remote.
-   * @param branch
-   * @param params
-   * @param params.verify
-   */
-  async push(branch, params = {}) {
-    const { verify = true, tags = false, followTags = false, force = false } = params;
-    await this.exec("push", followTags && "--follow-tags", tags && "--tags", !verify && "--no-verify", force && "--force", "origin", "--", branch);
-  }
-  /**
-   * Verify rev exists.
-   * @param rev
-   * @param safe - If `true`, will not throw error if rev not found.
-   * @returns Target hash.
-   */
-  async verify(rev, safe) {
-    let git = this.exec("rev-parse", "--verify", rev);
-    if (safe) {
-      git = git.catch(() => "");
-    }
-    return await git;
-  }
-  /**
-   * Get config value by key.
-   * @param key - Config key.
-   * @returns Config value.
-   */
-  async getConfig(key) {
-    return await this.exec("config", "--get", "--", key);
-  }
-  /**
-   * Set config value by key.
-   * @param key - Config key.
-   * @param value - Config value.
-   */
-  async setConfig(key, value) {
-    await this.exec("config", "--", key, value);
-  }
-  /**
-   * Fetch changes from remote.
-   * @param params
-   */
-  async fetch(params = {}) {
-    const { prune = false, unshallow = false, tags = false, all = false, remote, branch } = params;
-    await this.exec("fetch", prune && "--prune", unshallow && "--unshallow", tags && "--tags", all && "--all", ...remote && branch ? [
-      "--",
-      remote,
-      branch
-    ] : []);
-  }
-  /**
-   * Create a new branch.
-   * @param branch - Branch name.
-   */
-  async createBranch(branch) {
-    await this.exec("checkout", "-b", branch);
-  }
-  /**
-   * Delete a branch.
-   * @param branch - Branch name.
-   */
-  async deleteBranch(branch) {
-    await this.exec("branch", "-D", "--", branch);
-  }
-  /**
-   * Checkout a branch.
-   * @param branch - Branch name.
-   */
-  async checkout(branch) {
-    await this.exec("checkout", branch);
-  }
-};
-
-// ../../node_modules/.pnpm/@conventional-changelog+git-client@2.5.1_conventional-commits-filter@5.0.0_conventional-commits-parser@6.2.1/node_modules/@conventional-changelog/git-client/dist/ConventionalGitClient.js
-import semver from "semver";
-var ConventionalGitClient = class extends GitClient {
-  deps = null;
-  loadDeps() {
-    if (this.deps) {
-      return this.deps;
-    }
-    this.deps = Promise.all([
-      import("./dist-3B6ZXCEH.js").then(({ parseCommits }) => parseCommits),
-      import("./dist-XFQOB6BJ.js").then(({ filterRevertedCommits }) => filterRevertedCommits)
-    ]);
-    return this.deps;
-  }
-  /**
-   * Get parsed commits stream.
-   * @param params
-   * @param params.path - Read commits from specific path.
-   * @param params.from - Start commits range.
-   * @param params.to - End commits range.
-   * @param params.format - Commits format.
-   * @param parserOptions - Commit parser options.
-   * @yields Raw commits data.
-   */
-  async *getCommits(params = {}, parserOptions = {}) {
-    const { filterReverts, ...gitLogParams } = params;
-    const [parseCommits, filterRevertedCommits] = await this.loadDeps();
-    if (filterReverts) {
-      yield* filterRevertedCommits(this.getCommits(gitLogParams, parserOptions));
-      return;
-    }
-    const parse2 = parseCommits(parserOptions);
-    const commitsStream = this.getRawCommits(gitLogParams);
-    yield* parse2(commitsStream);
-  }
-  /**
-   * Get semver tags stream.
-   * @param params
-   * @param params.prefix - Get semver tags with specific prefix.
-   * @param params.skipUnstable - Skip semver tags with unstable versions.
-   * @param params.clean - Clean version from prefix and trash.
-   * @yields Semver tags.
-   */
-  async *getSemverTags(params = {}) {
-    const { prefix, skipUnstable, clean } = params;
-    const tagsStream = this.getTags();
-    const unstableTagRegex = /\d+\.\d+\.\d+-.+/;
-    const cleanTag = clean ? (tag2, unprefixed2) => semver.clean(unprefixed2 || tag2) : (tag2) => tag2;
-    let unprefixed;
-    let tag;
-    for await (tag of tagsStream) {
-      if (skipUnstable && unstableTagRegex.test(tag)) {
-        continue;
-      }
-      if (prefix) {
-        const isPrefixed = typeof prefix === "string" ? tag.startsWith(prefix) : prefix.test(tag);
-        if (isPrefixed) {
-          unprefixed = tag.replace(prefix, "");
-          if (semver.valid(unprefixed)) {
-            tag = cleanTag(tag, unprefixed);
-            if (tag) {
-              yield tag;
-            }
-          }
-        }
-      } else if (semver.valid(tag)) {
-        tag = cleanTag(tag);
-        if (tag) {
-          yield tag;
-        }
-      }
-    }
-  }
-  /**
-   * Get last semver tag.
-   * @param params - getSemverTags params.
-   * @returns Last semver tag, `null` if not found.
-   */
-  async getLastSemverTag(params = {}) {
-    return firstFromStream(this.getSemverTags(params));
-  }
-  /**
-   * Get current sematic version from git tags.
-   * @param params - Additional git params.
-   * @returns Current sematic version, `null` if not found.
-   */
-  async getVersionFromTags(params = {}) {
-    const semverTagsStream = this.getSemverTags({
-      clean: true,
-      ...params
-    });
-    const semverTags = [];
-    for await (const tag of semverTagsStream) {
-      semverTags.push(tag);
-    }
-    if (!semverTags.length) {
-      return null;
-    }
-    return semverTags.sort(semver.rcompare)[0] || null;
-  }
-};
-
-// ../../node_modules/.pnpm/conventional-changelog-preset-loader@5.0.0/node_modules/conventional-changelog-preset-loader/dist/presetLoader.js
-import path4 from "path";
-function resolvePresetNameVariants(preset) {
-  if (path4.isAbsolute(preset)) {
-    return [preset];
-  }
-  let scope = "";
-  let name = preset.toLocaleLowerCase();
-  if (preset.startsWith("@")) {
-    const parts = preset.split("/");
-    scope = `${parts.shift()}/`;
-    if (scope === "@conventional-changelog/") {
-      return [preset];
-    }
-    name = parts.join("/");
-  }
-  if (!name.startsWith("conventional-changelog-")) {
-    name = `conventional-changelog-${name}`;
-  }
-  const altPreset = `${scope}${name}`;
-  if (altPreset !== preset) {
-    return [altPreset, preset];
-  }
-  return [preset];
-}
-function getModuleDefaultExport(module) {
-  if (("__esModule" in module || Object.getPrototypeOf(module) === null) && "default" in module) {
-    return module.default;
-  }
-  return module;
-}
-async function loadWithFallbacks(moduleLoader, variants) {
-  let error = null;
-  for (const variant of variants) {
-    try {
-      return getModuleDefaultExport(await moduleLoader(variant));
-    } catch (err) {
-      if (!error) {
-        error = err;
-      }
-    }
-  }
-  throw error;
-}
-function createPresetLoader(moduleLoader) {
-  return async function loadPreset2(presetOrParams) {
-    let preset = "";
-    let params = null;
-    if (typeof presetOrParams === "string") {
-      preset = presetOrParams;
-    } else if (typeof presetOrParams === "object" && typeof presetOrParams.name === "string") {
-      preset = presetOrParams.name;
-      params = presetOrParams;
-    } else {
-      throw Error("Preset must be string or object with property `name`");
-    }
-    const presetNameVariants = resolvePresetNameVariants(preset);
-    let createPreset = null;
-    try {
-      createPreset = await loadWithFallbacks(moduleLoader, presetNameVariants);
-    } catch (err) {
-      throw new Error(`Unable to load the "${preset}" preset. Please make sure it's installed.`, {
-        cause: err
-      });
-    }
-    if (typeof createPreset !== "function") {
-      throw new Error(`The "${preset}" preset does not export a function. Maybe you are using an old version of the preset. Please upgrade.`);
-    }
-    return params ? await createPreset(params) : await createPreset();
-  };
-}
-var loadPreset = createPresetLoader((preset) => import(preset));
-
-// ../../node_modules/.pnpm/conventional-recommended-bump@11.2.0/node_modules/conventional-recommended-bump/dist/utils.js
-function isIterable(value) {
-  return value !== null && (typeof value[Symbol.iterator] === "function" || typeof value[Symbol.asyncIterator] === "function");
-}
-function bindLogNamespace(namespace, logger) {
-  return (messages) => logger(namespace, messages);
-}
-
-// ../../node_modules/.pnpm/conventional-recommended-bump@11.2.0/node_modules/conventional-recommended-bump/dist/bumper.js
-var VERSIONS = [
-  "major",
-  "minor",
-  "patch"
-];
-var Bumper = class {
-  gitClient;
-  params;
-  whatBump;
-  tagGetter;
-  commitsGetter;
-  constructor(cwdOrGitClient = process.cwd()) {
-    this.gitClient = typeof cwdOrGitClient === "string" ? new ConventionalGitClient(cwdOrGitClient) : cwdOrGitClient;
-    this.whatBump = null;
-    this.params = Promise.resolve({
-      commits: {
-        format: "%B%n-hash-%n%H",
-        filterReverts: true
-      }
-    });
-    this.tagGetter = () => this.getLastSemverTag();
-    this.commitsGetter = () => this.getCommits();
-  }
-  composeParams(params) {
-    this.params = Promise.all([params, this.params]).then(([params2, prevParams]) => ({
-      options: {
-        ...prevParams.options,
-        ...params2.options
-      },
-      tags: {
-        ...prevParams.tags,
-        ...params2.tags
-      },
-      commits: {
-        ...prevParams.commits,
-        ...params2.commits
-      },
-      parser: {
-        ...prevParams.parser,
-        ...params2.parser
-      }
-    }));
-  }
-  async getLastSemverTag() {
-    const { tags } = await this.params;
-    return await this.gitClient.getLastSemverTag(tags);
-  }
-  async *getCommits() {
-    const { options, commits, parser } = await this.params;
-    const parserParams = {
-      ...parser
-    };
-    if (!parserParams.warn && options?.warn) {
-      parserParams.warn = bindLogNamespace("parser", options.warn);
-    }
-    yield* this.gitClient.getCommits({
-      from: await this.tagGetter() || "",
-      ...commits
-    }, parserParams);
-  }
-  /**
-   * Load configs from a preset
-   * @param preset
-   * @param loader - Preset module loader, if not provided, will use default loader
-   * @returns this
-   */
-  loadPreset(preset, loader) {
-    const loadPreset2 = loader ? createPresetLoader(loader) : loadPreset;
-    const config = loadPreset2(preset).then((config2) => {
-      if (!config2) {
-        throw Error("Preset is not loaded or have incorrect exports");
-      }
-      return config2;
-    });
-    this.whatBump = async (commits) => {
-      const { whatBump } = await config;
-      return whatBump(commits);
-    };
-    this.composeParams(config);
-    return this;
-  }
-  /**
-   * Set config directly
-   * @param config - Config object
-   * @returns this
-   */
-  config(config) {
-    this.composeParams(config);
-    return this;
-  }
-  /**
-   * Set bumper options
-   * @param options - Bumper options
-   * @returns this
-   */
-  options(options) {
-    this.composeParams({
-      options
-    });
-    return this;
-  }
-  /**
-   * Set params to get the last semver tag
-   * @param paramsOrTag - Params to get the last semver tag or a tag name
-   * @returns this
-   */
-  tag(paramsOrTag) {
-    if (typeof paramsOrTag === "string") {
-      this.tagGetter = () => paramsOrTag;
-    } else {
-      this.tagGetter = () => this.getLastSemverTag();
-      this.composeParams({
-        tags: paramsOrTag
-      });
-    }
-    return this;
-  }
-  commits(paramsOrCommits, parserOptions) {
-    if (isIterable(paramsOrCommits)) {
-      this.commitsGetter = () => paramsOrCommits;
-    } else {
-      this.commitsGetter = () => this.getCommits();
-      this.composeParams({
-        commits: paramsOrCommits,
-        parser: parserOptions
-      });
-    }
-    return this;
-  }
-  /**
-   * Recommend a bump by `whatBump` function
-   * @param whatBump - Function to recommend a bump from commits
-   * @returns Bump recommendation
-   */
-  async bump(whatBump = this.whatBump) {
-    if (typeof whatBump !== "function") {
-      throw Error("`whatBump` must be a function");
-    }
-    const { gitClient } = this;
-    const { options } = await this.params;
-    if (!gitClient.debug && options?.debug) {
-      gitClient.debug = bindLogNamespace("git-client", options.debug);
-    }
-    const commitsStream = this.commitsGetter();
-    const commits = [];
-    let commit;
-    for await (commit of commitsStream) {
-      commits.push(commit);
-    }
-    const result = await whatBump(commits);
-    if (result && "level" in result) {
-      return {
-        ...result,
-        releaseType: VERSIONS[result.level],
-        commits
-      };
-    }
-    return {
-      commits
-    };
-  }
-};
-
-// src/core/versionCalculator.ts
-import semver4 from "semver";
+import { sanitizePackageName as sanitizePackageName2 } from "@releasekit/core";
+import { Bumper } from "conventional-recommended-bump";
+import semver3 from "semver";
 
 // src/git/repository.ts
-import { existsSync as existsSync3, statSync } from "fs";
-import { join as join3 } from "path";
+import { existsSync, statSync } from "fs";
+import { join } from "path";
 function getCurrentBranch() {
   const result = execSync("git", ["rev-parse", "--abbrev-ref", "HEAD"]);
   return result.toString().trim();
@@ -1273,7 +196,10 @@ function getCurrentBranch() {
 
 // src/git/tagsAndBranches.ts
 import { getSemverTags } from "git-semver-tags";
-import semver2 from "semver";
+import semver from "semver";
+
+// src/utils/formatting.ts
+import { sanitizePackageName } from "@releasekit/core";
 
 // src/utils/logging.ts
 import chalk from "chalk";
@@ -1391,9 +317,9 @@ async function getLatestTag(versionPrefix) {
     }
     const chronologicalLatest = tags[0];
     const sortedTags = [...tags].sort((a, b) => {
-      const versionA = semver2.clean(a) || "0.0.0";
-      const versionB = semver2.clean(b) || "0.0.0";
-      return semver2.rcompare(versionA, versionB);
+      const versionA = semver.clean(a) || "0.0.0";
+      const versionB = semver.clean(b) || "0.0.0";
+      return semver.rcompare(versionA, versionB);
     });
     const semanticLatest = sortedTags[0];
     if (semanticLatest !== chronologicalLatest) {
@@ -1484,15 +410,16 @@ async function getLatestTagForPackage(packageName, versionPrefix, options) {
 }
 
 // src/utils/manifestHelpers.ts
-import fs6 from "fs";
-import path6 from "path";
+import fs3 from "fs";
+import path2 from "path";
 
 // src/cargo/cargoHandler.ts
-import fs5 from "fs";
-import path5 from "path";
-import * as TOML2 from "smol-toml";
+import fs2 from "fs";
+import path from "path";
+import { isCargoToml, parseCargoToml } from "@releasekit/config";
+import * as TOML from "smol-toml";
 function getCargoInfo(cargoPath) {
-  if (!fs5.existsSync(cargoPath)) {
+  if (!fs2.existsSync(cargoPath)) {
     log(`Cargo.toml file not found at: ${cargoPath}`, "error");
     throw new Error(`Cargo.toml file not found at: ${cargoPath}`);
   }
@@ -1506,7 +433,7 @@ function getCargoInfo(cargoPath) {
       name: cargo.package.name,
       version: cargo.package.version || "0.0.0",
       path: cargoPath,
-      dir: path5.dirname(cargoPath),
+      dir: path.dirname(cargoPath),
       content: cargo
     };
   } catch (error) {
@@ -1530,11 +457,11 @@ function updateCargoVersion(cargoPath, version, dryRun = false) {
     } else {
       cargo.package.version = version;
     }
-    const updatedContent = TOML2.stringify(cargo);
+    const updatedContent = TOML.stringify(cargo);
     if (dryRun) {
       recordPendingWrite(cargoPath, updatedContent);
     } else {
-      fs5.writeFileSync(cargoPath, updatedContent);
+      fs2.writeFileSync(cargoPath, updatedContent);
     }
     addPackageUpdate(packageName, version, cargoPath);
     log(`${dryRun ? "[DRY RUN] Would update" : "Updated"} Cargo.toml at ${cargoPath} to version ${version}`, "success");
@@ -1549,11 +476,11 @@ function updateCargoVersion(cargoPath, version, dryRun = false) {
 
 // src/utils/manifestHelpers.ts
 function getVersionFromManifests(packageDir) {
-  const packageJsonPath = path6.join(packageDir, "package.json");
-  const cargoTomlPath = path6.join(packageDir, "Cargo.toml");
-  if (fs6.existsSync(packageJsonPath)) {
+  const packageJsonPath = path2.join(packageDir, "package.json");
+  const cargoTomlPath = path2.join(packageDir, "Cargo.toml");
+  if (fs3.existsSync(packageJsonPath)) {
     try {
-      const packageJson = JSON.parse(fs6.readFileSync(packageJsonPath, "utf-8"));
+      const packageJson = JSON.parse(fs3.readFileSync(packageJsonPath, "utf-8"));
       if (packageJson.version) {
         log(`Found version ${packageJson.version} in package.json`, "debug");
         return {
@@ -1569,7 +496,7 @@ function getVersionFromManifests(packageDir) {
       log(`Error reading package.json: ${errMsg}`, "warning");
     }
   }
-  if (fs6.existsSync(cargoTomlPath)) {
+  if (fs3.existsSync(cargoTomlPath)) {
     try {
       const cargoInfo = getCargoInfo(cargoTomlPath);
       if (cargoInfo.version) {
@@ -1596,8 +523,9 @@ function getVersionFromManifests(packageDir) {
 }
 
 // src/utils/versionUtils.ts
-import fs7 from "fs";
-import semver3 from "semver";
+import fs4 from "fs";
+import { parseCargoToml as parseCargoToml2 } from "@releasekit/config";
+import semver2 from "semver";
 
 // src/git/tagVerification.ts
 function verifyTag(tagName, cwd3) {
@@ -1639,33 +567,33 @@ function normalizePrereleaseIdentifier(prereleaseIdentifier, config) {
   return void 0;
 }
 function bumpVersion(currentVersion, bumpType, prereleaseIdentifier) {
-  if (prereleaseIdentifier && STANDARD_BUMP_TYPES.includes(bumpType) && !semver3.prerelease(currentVersion)) {
+  if (prereleaseIdentifier && STANDARD_BUMP_TYPES.includes(bumpType) && !semver2.prerelease(currentVersion)) {
     const preBumpType = `pre${bumpType}`;
     log(`Creating prerelease version with identifier '${prereleaseIdentifier}' using ${preBumpType}`, "debug");
-    return semver3.inc(currentVersion, preBumpType, prereleaseIdentifier) || "";
+    return semver2.inc(currentVersion, preBumpType, prereleaseIdentifier) || "";
   }
-  if (semver3.prerelease(currentVersion) && STANDARD_BUMP_TYPES.includes(bumpType)) {
-    const parsed = semver3.parse(currentVersion);
+  if (semver2.prerelease(currentVersion) && STANDARD_BUMP_TYPES.includes(bumpType)) {
+    const parsed = semver2.parse(currentVersion);
     if (!parsed) {
-      return semver3.inc(currentVersion, bumpType) || "";
+      return semver2.inc(currentVersion, bumpType) || "";
     }
     if (bumpType === "major" && parsed.minor === 0 && parsed.patch === 0 || bumpType === "minor" && parsed.patch === 0 || bumpType === "patch") {
       log(`Cleaning prerelease identifier from ${currentVersion} for ${bumpType} bump`, "debug");
       return `${parsed.major}.${parsed.minor}.${parsed.patch}`;
     }
     log(`Standard increment for ${currentVersion} with ${bumpType} bump`, "debug");
-    return semver3.inc(currentVersion, bumpType) || "";
+    return semver2.inc(currentVersion, bumpType) || "";
   }
   if (prereleaseIdentifier) {
-    return semver3.inc(currentVersion, bumpType, prereleaseIdentifier) || "";
+    return semver2.inc(currentVersion, bumpType, prereleaseIdentifier) || "";
   }
-  return semver3.inc(currentVersion, bumpType) || "";
+  return semver2.inc(currentVersion, bumpType) || "";
 }
 function detectVersionMismatch(tagVersion, packageVersion) {
-  const tagIsPrerelease = semver3.prerelease(tagVersion) !== null;
-  const packageIsPrerelease = semver3.prerelease(packageVersion) !== null;
-  const tagParsed = semver3.parse(tagVersion);
-  const packageParsed = semver3.parse(packageVersion);
+  const tagIsPrerelease = semver2.prerelease(tagVersion) !== null;
+  const packageIsPrerelease = semver2.prerelease(packageVersion) !== null;
+  const tagParsed = semver2.parse(tagVersion);
+  const packageParsed = semver2.parse(packageVersion);
   if (!tagParsed || !packageParsed) {
     return { isMismatch: false, severity: "minor", message: "" };
   }
@@ -1676,9 +604,9 @@ function detectVersionMismatch(tagVersion, packageVersion) {
       message: `Git tag ${tagVersion} (stable) is ahead of package ${packageVersion} (prerelease). This may indicate a reverted release. Consider deleting tag ${tagVersion} or updating package.json.`
     };
   }
-  const tagHigher = semver3.gt(tagVersion, packageVersion);
+  const tagHigher = semver2.gt(tagVersion, packageVersion);
   if (tagHigher) {
-    const diff = semver3.diff(packageVersion, tagVersion);
+    const diff = semver2.diff(packageVersion, tagVersion);
     if (diff === "major" || diff === "minor") {
       return {
         isMismatch: true,
@@ -1777,7 +705,7 @@ To resolve: delete the conflicting tag, update package.json, or change mismatchS
           };
       }
     }
-    if (semver3.gt(cleanPackageVersion, cleanTagVersion)) {
+    if (semver2.gt(cleanPackageVersion, cleanTagVersion)) {
       log(`Package version ${packageVersion} is newer than git tag ${tagName}, using package version`, "info");
       return {
         source: "package",
@@ -1786,7 +714,7 @@ To resolve: delete the conflicting tag, update package.json, or change mismatchS
         mismatch: mismatchInfo
       };
     }
-    if (semver3.gt(cleanTagVersion, cleanPackageVersion)) {
+    if (semver2.gt(cleanTagVersion, cleanPackageVersion)) {
       log(`Git tag ${tagName} is newer than package version ${packageVersion}, using git tag`, "info");
       return {
         source: "git",
@@ -1838,7 +766,7 @@ async function calculateVersion(config, options) {
   try {
     let buildTagStripPattern2 = function(packageName, prefix) {
       if (!packageName) return escapeRegExp(prefix);
-      const sanitized = sanitizePackageName(packageName);
+      const sanitized = sanitizePackageName2(packageName);
       const escapedRaw = escapeRegExp(`${packageName}@${prefix}`);
       const escapedDash = escapeRegExp(`${sanitized}-${prefix}`);
       return `(?:${escapedRaw}|${escapedDash})`;
@@ -1847,12 +775,12 @@ async function calculateVersion(config, options) {
         if (hasNoTags) {
           return initialVersion;
         }
-        const cleanedTag = semver4.clean(latestTag) || latestTag;
-        return semver4.clean(cleanedTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
+        const cleanedTag = semver3.clean(latestTag) || latestTag;
+        return semver3.clean(cleanedTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
       }
       if (versionSource.source === "git") {
-        const cleanedTag = semver4.clean(versionSource.version) || versionSource.version;
-        return semver4.clean(cleanedTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
+        const cleanedTag = semver3.clean(versionSource.version) || versionSource.version;
+        return semver3.clean(cleanedTag.replace(new RegExp(`^${escapedTagPattern}`), "")) || "0.0.0";
       }
       return versionSource.version;
     };
@@ -1876,7 +804,7 @@ async function calculateVersion(config, options) {
     const specifiedType = type;
     if (specifiedType) {
       const currentVersion = getCurrentVersionFromSource2();
-      const isCurrentPrerelease = semver4.prerelease(currentVersion);
+      const isCurrentPrerelease = semver3.prerelease(currentVersion);
       const explicitlyRequestedPrerelease = config.isPrerelease;
       if (STANDARD_BUMP_TYPES.includes(specifiedType) && (isCurrentPrerelease || explicitlyRequestedPrerelease)) {
         const prereleaseId2 = explicitlyRequestedPrerelease || isCurrentPrerelease ? normalizedPrereleaseId : void 0;
@@ -1971,8 +899,8 @@ async function calculateVersion(config, options) {
 }
 
 // src/package/packageProcessor.ts
-import * as fs9 from "fs";
-import path8 from "path";
+import * as fs6 from "fs";
+import path4 from "path";
 
 // src/changelog/commitParser.ts
 var CONVENTIONAL_COMMIT_REGEX = /^(\w+)(?:\(([^)]+)\))?(!)?: (.+)(?:\n\n([\s\S]*))?/;
@@ -1980,8 +908,8 @@ var BREAKING_CHANGE_REGEX = /BREAKING CHANGE: ([\s\S]+?)(?:\n\n|$)/;
 function extractAllChangelogEntriesWithHash(projectDir, revisionRange) {
   try {
     const args = ["log", revisionRange, "--pretty=format:%H|||%B---COMMIT_DELIMITER---", "--no-merges"];
-    const output2 = execSync("git", args, { cwd: projectDir, encoding: "utf8" }).toString();
-    const commits = output2.split("---COMMIT_DELIMITER---").filter((commit) => commit.trim() !== "");
+    const output = execSync("git", args, { cwd: projectDir, encoding: "utf8" }).toString();
+    const commits = output.split("---COMMIT_DELIMITER---").filter((commit) => commit.trim() !== "");
     return commits.map((commit) => {
       const [hash, ...messageParts] = commit.split("|||");
       const message = messageParts.join("|||").trim();
@@ -1999,14 +927,14 @@ function extractAllChangelogEntriesWithHash(projectDir, revisionRange) {
 }
 function commitTouchesAnyPackage(projectDir, commitHash, packageDirs, sharedPackageDirs = []) {
   try {
-    const output2 = execSync("git", ["diff-tree", "--no-commit-id", "--name-only", "-r", commitHash], {
+    const output = execSync("git", ["diff-tree", "--no-commit-id", "--name-only", "-r", commitHash], {
       cwd: projectDir,
       encoding: "utf8"
     }).toString().trim();
-    if (!output2) {
+    if (!output) {
       return false;
     }
-    const changedFiles = output2.split("\n");
+    const changedFiles = output.split("\n");
     return changedFiles.some((file) => {
       return packageDirs.some((pkgDir) => {
         if (sharedPackageDirs.some((sharedDir) => pkgDir.includes(sharedDir))) {
@@ -2053,8 +981,8 @@ function extractCommitsFromGitLog(projectDir, revisionRange, filterToPath) {
     if (filterToPath) {
       args.push("--", ".");
     }
-    const output2 = execSync("git", args, { cwd: projectDir, encoding: "utf8" }).toString();
-    const commits = output2.split("---COMMIT_DELIMITER---").filter((commit) => commit.trim() !== "");
+    const output = execSync("git", args, { cwd: projectDir, encoding: "utf8" }).toString();
+    const commits = output.split("---COMMIT_DELIMITER---").filter((commit) => commit.trim() !== "");
     return commits.map((commit) => parseCommitMessage(commit)).filter((entry) => entry !== null);
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
@@ -2176,15 +1104,15 @@ function shouldProcessPackage(packageName, skip = []) {
 }
 
 // src/package/packageManagement.ts
-import fs8 from "fs";
-import path7 from "path";
+import fs5 from "fs";
+import path3 from "path";
 function updatePackageVersion(packagePath, version, dryRun = false) {
   if (isCargoToml(packagePath)) {
     updateCargoVersion(packagePath, version, dryRun);
     return;
   }
   try {
-    const packageContent = fs8.readFileSync(packagePath, "utf8");
+    const packageContent = fs5.readFileSync(packagePath, "utf8");
     const packageJson = JSON.parse(packageContent);
     const packageName = packageJson.name;
     const updatedContent = `${JSON.stringify({ ...packageJson, version }, null, 2)}
@@ -2192,7 +1120,7 @@ function updatePackageVersion(packagePath, version, dryRun = false) {
     if (dryRun) {
       recordPendingWrite(packagePath, updatedContent);
     } else {
-      fs8.writeFileSync(packagePath, updatedContent);
+      fs5.writeFileSync(packagePath, updatedContent);
     }
     addPackageUpdate(packageName, version, packagePath);
     log(
@@ -2362,9 +1290,9 @@ var PackageProcessor = class {
       }
       let repoUrl;
       try {
-        const packageJsonPath2 = path8.join(pkgPath, "package.json");
-        if (fs9.existsSync(packageJsonPath2)) {
-          const packageJson = JSON.parse(fs9.readFileSync(packageJsonPath2, "utf8"));
+        const packageJsonPath2 = path4.join(pkgPath, "package.json");
+        if (fs6.existsSync(packageJsonPath2)) {
+          const packageJson = JSON.parse(fs6.readFileSync(packageJsonPath2, "utf8"));
           if (packageJson.repository) {
             if (typeof packageJson.repository === "string") {
               repoUrl = packageJson.repository;
@@ -2390,8 +1318,8 @@ var PackageProcessor = class {
         repoUrl: repoUrl || null,
         entries: changelogEntries
       });
-      const packageJsonPath = path8.join(pkgPath, "package.json");
-      if (fs9.existsSync(packageJsonPath)) {
+      const packageJsonPath = path4.join(pkgPath, "package.json");
+      if (fs6.existsSync(packageJsonPath)) {
         updatePackageVersion(packageJsonPath, nextVersion, this.dryRun);
       }
       const cargoEnabled = this.fullConfig.cargo?.enabled !== false;
@@ -2401,9 +1329,9 @@ var PackageProcessor = class {
         log(`Cargo paths config for ${name}: ${JSON.stringify(cargoPaths)}`, "debug");
         if (cargoPaths && cargoPaths.length > 0) {
           for (const cargoPath of cargoPaths) {
-            const resolvedCargoPath = path8.resolve(pkgPath, cargoPath, "Cargo.toml");
+            const resolvedCargoPath = path4.resolve(pkgPath, cargoPath, "Cargo.toml");
             log(`Checking cargo path for ${name}: ${resolvedCargoPath}`, "debug");
-            if (fs9.existsSync(resolvedCargoPath)) {
+            if (fs6.existsSync(resolvedCargoPath)) {
               log(`Found Cargo.toml for ${name} at ${resolvedCargoPath}, updating...`, "debug");
               updatePackageVersion(resolvedCargoPath, nextVersion, this.dryRun);
             } else {
@@ -2411,9 +1339,9 @@ var PackageProcessor = class {
             }
           }
         } else {
-          const cargoTomlPath = path8.join(pkgPath, "Cargo.toml");
+          const cargoTomlPath = path4.join(pkgPath, "Cargo.toml");
           log(`Checking default cargo path for ${name}: ${cargoTomlPath}`, "debug");
-          if (fs9.existsSync(cargoTomlPath)) {
+          if (fs6.existsSync(cargoTomlPath)) {
             log(`Found Cargo.toml for ${name} at ${cargoTomlPath}, updating...`, "debug");
             updatePackageVersion(cargoTomlPath, nextVersion, this.dryRun);
           } else {
@@ -2479,8 +1407,8 @@ var PackageProcessor = class {
 };
 
 // src/core/versionStrategies.ts
-import fs10 from "fs";
-import * as path9 from "path";
+import fs7 from "fs";
+import * as path5 from "path";
 function shouldProcessPackage2(pkg, config) {
   const pkgName = pkg.packageJson.name;
   return shouldProcessPackage(pkgName, config.skip);
@@ -2494,15 +1422,15 @@ function updateCargoFiles(packageDir, version, cargoConfig, dryRun = false) {
   const cargoPaths = cargoConfig?.paths;
   if (cargoPaths && cargoPaths.length > 0) {
     for (const cargoPath of cargoPaths) {
-      const resolvedCargoPath = path9.resolve(packageDir, cargoPath, "Cargo.toml");
-      if (fs10.existsSync(resolvedCargoPath)) {
+      const resolvedCargoPath = path5.resolve(packageDir, cargoPath, "Cargo.toml");
+      if (fs7.existsSync(resolvedCargoPath)) {
         updatePackageVersion(resolvedCargoPath, version, dryRun);
         updatedFiles.push(resolvedCargoPath);
       }
     }
   } else {
-    const cargoTomlPath = path9.join(packageDir, "Cargo.toml");
-    if (fs10.existsSync(cargoTomlPath)) {
+    const cargoTomlPath = path5.join(packageDir, "Cargo.toml");
+    if (fs7.existsSync(cargoTomlPath)) {
       updatePackageVersion(cargoTomlPath, version, dryRun);
       updatedFiles.push(cargoTomlPath);
     }
@@ -2582,8 +1510,8 @@ function createSyncStrategy(config) {
       const processedPaths = /* @__PURE__ */ new Set();
       try {
         if (packages.root) {
-          const rootPkgPath = path9.join(packages.root, "package.json");
-          if (fs10.existsSync(rootPkgPath)) {
+          const rootPkgPath = path5.join(packages.root, "package.json");
+          if (fs7.existsSync(rootPkgPath)) {
             updatePackageVersion(rootPkgPath, nextVersion, dryRun);
             files.push(rootPkgPath);
             updatedPackages.push("root");
@@ -2602,7 +1530,7 @@ function createSyncStrategy(config) {
         if (!shouldProcessPackage2(pkg, config)) {
           continue;
         }
-        const packageJsonPath = path9.join(pkg.dir, "package.json");
+        const packageJsonPath = path5.join(pkg.dir, "package.json");
         if (processedPaths.has(packageJsonPath)) {
           continue;
         }
@@ -2661,9 +1589,9 @@ function createSyncStrategy(config) {
       let repoUrl = null;
       for (const searchPath of [mainPkgPath, versionSourcePath].filter(Boolean)) {
         try {
-          const pkgJsonPath = path9.join(searchPath, "package.json");
-          if (fs10.existsSync(pkgJsonPath)) {
-            const pkgJson = JSON.parse(fs10.readFileSync(pkgJsonPath, "utf8"));
+          const pkgJsonPath = path5.join(searchPath, "package.json");
+          if (fs7.existsSync(pkgJsonPath)) {
+            const pkgJson = JSON.parse(fs7.readFileSync(pkgJsonPath, "utf8"));
             let url;
             if (typeof pkgJson.repository === "string") {
               url = pkgJson.repository;
@@ -2830,9 +1758,9 @@ function createSingleStrategy(config) {
       }
       let repoUrl;
       try {
-        const packageJsonPath2 = path9.join(pkgPath, "package.json");
-        if (fs10.existsSync(packageJsonPath2)) {
-          const packageJson = JSON.parse(fs10.readFileSync(packageJsonPath2, "utf8"));
+        const packageJsonPath2 = path5.join(pkgPath, "package.json");
+        if (fs7.existsSync(packageJsonPath2)) {
+          const packageJson = JSON.parse(fs7.readFileSync(packageJsonPath2, "utf8"));
           if (packageJson.repository) {
             if (typeof packageJson.repository === "string") {
               repoUrl = packageJson.repository;
@@ -2858,7 +1786,7 @@ function createSingleStrategy(config) {
         repoUrl: repoUrl || null,
         entries: changelogEntries
       });
-      const packageJsonPath = path9.join(pkgPath, "package.json");
+      const packageJsonPath = path5.join(pkgPath, "package.json");
       updatePackageVersion(packageJsonPath, nextVersion, dryRun);
       const filesToCommit = [packageJsonPath];
       const cargoFiles = updateCargoFiles(pkgPath, nextVersion, config.cargo, dryRun);
@@ -2964,7 +1892,7 @@ var GitError = class extends BaseVersionError {
 };
 
 // src/utils/packageFiltering.ts
-import path10 from "path";
+import path6 from "path";
 import { minimatch as minimatch2 } from "minimatch";
 function filterPackagesByConfig(packages, configTargets, workspaceRoot) {
   if (configTargets.length === 0) {
@@ -2990,7 +1918,7 @@ function filterByDirectoryPattern(packages, pattern, workspaceRoot) {
   }
   const normalizedPattern = pattern.replace(/\\/g, "/");
   return packages.filter((pkg) => {
-    const relativePath = path10.relative(workspaceRoot, pkg.dir);
+    const relativePath = path6.relative(workspaceRoot, pkg.dir);
     const normalizedRelativePath = relativePath.replace(/\\/g, "/");
     if (normalizedPattern === normalizedRelativePath) {
       return true;
@@ -3151,7 +2079,7 @@ function createVersionCommand() {
           );
         }
       }
-      const config = loadConfig2({ cwd: options.projectDir, configPath: options.config });
+      const config = loadConfig({ cwd: options.projectDir, configPath: options.config });
       log(`Loaded configuration from ${options.config || "releasekit.config.json"}`, "info");
       if (options.dryRun) config.dryRun = true;
       if (options.sync) config.sync = true;
@@ -3195,7 +2123,7 @@ function createVersionCommand() {
       log("Versioning process completed.", "success");
       printJsonOutput();
     } catch (error) {
-      const { BaseVersionError: BaseVersionError2 } = await import("./baseError-DQHIJACF.js");
+      const { BaseVersionError: BaseVersionError2 } = await import("./baseError-6PKATI6Z.js");
       if (BaseVersionError2.isVersionError(error)) {
         error.logError();
       } else {
@@ -3207,7 +2135,7 @@ function createVersionCommand() {
 }
 
 export {
-  loadConfig2 as loadConfig,
+  loadConfig,
   VersionErrorCode,
   createVersionError,
   enableJsonOutput,