@releasekit/publish 0.3.0-next.4 → 0.3.1

package/dist/{chunk-GOBII36Q.js → chunk-GIMIZS5B.js}

@@ -1,5 +1,517 @@
-// src/config.ts
-import { loadPublishConfig } from "@releasekit/config";
+// ../core/dist/index.js
+import * as fs from "fs";
+import * as path from "path";
+import { fileURLToPath } from "url";
+import chalk from "chalk";
+function readPackageVersion(importMetaUrl) {
+  try {
+    const dir = path.dirname(fileURLToPath(importMetaUrl));
+    const packageJsonPath = path.resolve(dir, "../package.json");
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+    return packageJson.version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+var LOG_LEVELS = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  debug: 3,
+  trace: 4
+};
+var PREFIXES = {
+  error: "[ERROR]",
+  warn: "[WARN]",
+  info: "[INFO]",
+  debug: "[DEBUG]",
+  trace: "[TRACE]"
+};
+var COLORS = {
+  error: chalk.red,
+  warn: chalk.yellow,
+  info: chalk.blue,
+  debug: chalk.gray,
+  trace: chalk.dim
+};
+var currentLevel = "info";
+var quietMode = false;
+function setLogLevel(level) {
+  currentLevel = level;
+}
+function setJsonMode(_json) {
+}
+function shouldLog(level) {
+  if (quietMode && level !== "error") return false;
+  return LOG_LEVELS[level] <= LOG_LEVELS[currentLevel];
+}
+function log(message, level = "info") {
+  if (!shouldLog(level)) return;
+  const formatted = COLORS[level](`${PREFIXES[level]} ${message}`);
+  console.error(formatted);
+}
+function warn(message) {
+  log(message, "warn");
+}
+function info(message) {
+  log(message, "info");
+}
+function success(message) {
+  if (!shouldLog("info")) return;
+  console.error(chalk.green(`[SUCCESS] ${message}`));
+}
+function debug(message) {
+  log(message, "debug");
+}
+var ReleaseKitError = class _ReleaseKitError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = this.constructor.name;
+  }
+  logError() {
+    log(this.message, "error");
+    if (this.suggestions.length > 0) {
+      log("\nSuggested solutions:", "info");
+      for (const [i, suggestion] of this.suggestions.entries()) {
+        log(`${i + 1}. ${suggestion}`, "info");
+      }
+    }
+  }
+  static isReleaseKitError(error2) {
+    return error2 instanceof _ReleaseKitError;
+  }
+};
+var EXIT_CODES = {
+  SUCCESS: 0,
+  GENERAL_ERROR: 1,
+  CONFIG_ERROR: 2,
+  INPUT_ERROR: 3,
+  TEMPLATE_ERROR: 4,
+  LLM_ERROR: 5,
+  GITHUB_ERROR: 6,
+  GIT_ERROR: 7,
+  VERSION_ERROR: 8,
+  PUBLISH_ERROR: 9
+};
+
+// ../config/dist/index.js
+import * as fs2 from "fs";
+import * as path2 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 fs22 from "fs";
+import * as os from "os";
+import * as path22 from "path";
+function parseCargoToml(cargoPath) {
+  const content = fs2.readFileSync(cargoPath, "utf-8");
+  return TOML.parse(content);
+}
+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"
+    ];
+  }
+};
+function mergeGitConfig(topLevel, packageLevel) {
+  if (!topLevel && !packageLevel) return void 0;
+  const base = topLevel ?? {
+    remote: "origin",
+    branch: "main",
+    pushMethod: "auto"
+  };
+  if (!packageLevel) return base;
+  return {
+    remote: packageLevel.remote ?? base.remote,
+    branch: packageLevel.branch ?? base.branch,
+    pushMethod: packageLevel.pushMethod ?? base.pushMethod,
+    httpsTokenEnv: packageLevel.httpsTokenEnv ?? base.httpsTokenEnv,
+    push: packageLevel.push,
+    skipHooks: packageLevel.skipHooks ?? base.skipHooks
+  };
+}
+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 how release notes are sourced for GitHub releases.
+   * - 'auto': Use RELEASE_NOTES.md if it exists, then per-package changelog
+   *   data from the version output, then GitHub's auto-generated notes.
+   * - 'github': Always use GitHub's auto-generated notes.
+   * - 'none': No notes body.
+   * - Any other string: Treated as a file path to read notes from.
+   */
+  releaseNotes: z.union([z.literal("auto"), z.literal("github"), z.literal("none"), z.string()]).default("auto")
+});
+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",
+    releaseNotes: "auto"
+  }),
+  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 OutputConfigSchema = z.object({
+  format: z.enum(["markdown", "github-release", "json"]),
+  file: z.string().optional(),
+  options: z.record(z.string(), z.unknown()).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 NotesInputConfigSchema = z.object({
+  source: z.string().optional(),
+  file: z.string().optional()
+});
+var NotesConfigSchema = z.object({
+  input: NotesInputConfigSchema.optional(),
+  output: z.array(OutputConfigSchema).default([{ format: "markdown", file: "CHANGELOG.md" }]),
+  monorepo: MonorepoConfigSchema.optional(),
+  templates: TemplateConfigSchema.optional(),
+  llm: LLMConfigSchema.optional(),
+  updateStrategy: z.enum(["prepend", "regenerate"]).default("prepend")
+});
+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("~") ? path22.join(os.homedir(), filePath.slice(1)) : filePath;
+    try {
+      return fs22.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 = path22.join(os.homedir(), ".config", "releasekit");
+var AUTH_FILE = path22.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 cwd = options?.cwd ?? process.cwd();
+  const configPath = options?.configPath ?? path3.join(cwd, CONFIG_FILE);
+  return loadConfigFile(configPath);
+}
+function loadPublishConfig(options) {
+  const config = loadConfig(options);
+  if (!config.publish) return void 0;
+  const mergedGit = mergeGitConfig(config.git, config.publish.git);
+  return {
+    ...config.publish,
+    git: mergedGit ? {
+      push: mergedGit.push ?? true,
+      pushMethod: mergedGit.pushMethod,
+      remote: mergedGit.remote,
+      branch: mergedGit.branch,
+      httpsTokenEnv: mergedGit.httpsTokenEnv,
+      skipHooks: mergedGit.skipHooks
+    } : void 0
+  };
+}
 
 // src/types.ts
 function getDefaultConfig() {
@@ -23,7 +535,7 @@ function getDefaultConfig() {
       push: true,
       pushMethod: "auto",
       remote: "origin",
-      branch: "main",
+      branch: void 0,
       httpsTokenEnv: void 0,
       skipHooks: false
     },
@@ -102,7 +614,7 @@ function toPublishConfig(config) {
 }
 
 // src/config.ts
-function loadConfig(options) {
+function loadConfig2(options) {
   const baseConfig = loadPublishConfig(options);
   return toPublishConfig(baseConfig);
 }
@@ -111,7 +623,6 @@ function getDefaultConfig2() {
 }
 
 // src/errors/index.ts
-import { ReleaseKitError } from "@releasekit/core";
 var BasePublishError = class _BasePublishError extends ReleaseKitError {
   code;
   suggestions;
@@ -250,7 +761,6 @@ function createPublishError(code, details) {
 
 // src/utils/exec.ts
 import { execFile } from "child_process";
-import { debug, info } from "@releasekit/core";
 function redactArg(arg) {
   try {
     const url = new URL(arg);
@@ -270,7 +780,7 @@ async function execCommand(file, args, options = {}) {
     return { stdout: "", stderr: "", exitCode: 0 };
   }
   debug(`Executing: ${displayCommand}`);
-  return new Promise((resolve5, reject) => {
+  return new Promise((resolve6, reject) => {
     execFile(
       file,
       args,
@@ -289,7 +799,7 @@ async function execCommand(file, args, options = {}) {
             })
           );
         } else {
-          resolve5({
+          resolve6({
             stdout: stdout.toString(),
             stderr: stderr.toString(),
             exitCode: 0
@@ -338,15 +848,14 @@ async function detectGitPushMethod(remote, cwd) {
 }
 
 // src/utils/cargo.ts
-import * as fs from "fs";
-import { parseCargoToml } from "@releasekit/config";
-import * as TOML from "smol-toml";
+import * as fs4 from "fs";
+import * as TOML2 from "smol-toml";
 function updateCargoVersion(cargoPath, newVersion) {
   try {
     const cargo = parseCargoToml(cargoPath);
     if (cargo.package) {
       cargo.package.version = newVersion;
-      fs.writeFileSync(cargoPath, TOML.stringify(cargo));
+      fs4.writeFileSync(cargoPath, TOML2.stringify(cargo));
     }
   } catch (error) {
     throw createPublishError(
@@ -383,11 +892,11 @@ function getDistTag(version, defaultTag = "latest") {
 }
 
 // src/utils/package-manager.ts
-import * as fs2 from "fs";
-import * as path from "path";
+import * as fs5 from "fs";
+import * as path4 from "path";
 function detectPackageManager(cwd) {
-  if (fs2.existsSync(path.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
-  if (fs2.existsSync(path.join(cwd, "yarn.lock"))) return "yarn";
+  if (fs5.existsSync(path4.join(cwd, "pnpm-lock.yaml"))) return "pnpm";
+  if (fs5.existsSync(path4.join(cwd, "yarn.lock"))) return "yarn";
   return "npm";
 }
 function buildPublishCommand(pm, packageName, _packageDir, options) {
@@ -412,25 +921,24 @@ function buildViewCommand(pm, packageName, version) {
 }
 
 // src/stages/cargo-publish.ts
-import * as fs3 from "fs";
-import * as path2 from "path";
-import { debug as debug2, success, warn } from "@releasekit/core";
+import * as fs6 from "fs";
+import * as path5 from "path";
 async function runCargoPublishStage(ctx) {
   const { input, config, cliOptions, cwd } = ctx;
   const dryRun = cliOptions.dryRun;
   if (!config.cargo.enabled) {
-    debug2("Cargo publishing disabled in config");
+    debug("Cargo publishing disabled in config");
     return;
   }
   if (!hasCargoAuth() && !dryRun) {
     throw createPublishError("CARGO_AUTH_ERROR" /* CARGO_AUTH_ERROR */, "CARGO_REGISTRY_TOKEN not set");
   }
   const crates = findCrates(
-    input.updates.map((u) => ({ dir: path2.dirname(path2.resolve(cwd, u.filePath)), ...u })),
+    input.updates.map((u) => ({ dir: path5.dirname(path5.resolve(cwd, u.filePath)), ...u })),
     cwd
   );
   if (crates.length === 0) {
-    debug2("No Cargo crates found to publish");
+    debug("No Cargo crates found to publish");
     return;
   }
   const ordered = orderCrates(crates, config.cargo.publishOrder);
@@ -479,8 +987,8 @@ async function runCargoPublishStage(ctx) {
 function findCrates(updates, _cwd) {
   const crates = [];
   for (const update of updates) {
-    const cargoPath = path2.join(update.dir, "Cargo.toml");
-    if (!fs3.existsSync(cargoPath)) {
+    const cargoPath = path5.join(update.dir, "Cargo.toml");
+    if (!fs6.existsSync(cargoPath)) {
       continue;
     }
     try {
@@ -528,9 +1036,9 @@ function topologicalSort(crates) {
   }
   for (const crate of crates) {
     for (const depPath of crate.pathDeps) {
-      const resolvedDir = path2.resolve(crate.dir, depPath);
+      const resolvedDir = path5.resolve(crate.dir, depPath);
       for (const other of crates) {
-        if (path2.resolve(other.dir) === resolvedDir && nameSet.has(other.name)) {
+        if (path5.resolve(other.dir) === resolvedDir && nameSet.has(other.name)) {
           graph.get(crate.name)?.push(other.name);
         }
       }
@@ -572,22 +1080,21 @@ function topologicalSort(crates) {
 }
 
 // src/stages/git-commit.ts
-import * as path3 from "path";
-import { info as info2, success as success2 } from "@releasekit/core";
+import * as path6 from "path";
 async function runGitCommitStage(ctx) {
   const { input, config, cliOptions, cwd } = ctx;
   const dryRun = cliOptions.dryRun;
   const skipHooks = config.git.skipHooks ?? false;
   if (!input.commitMessage) {
-    info2("No commit message provided, skipping git commit");
+    info("No commit message provided, skipping git commit");
     return;
   }
-  const filePaths = input.updates.map((u) => path3.resolve(cwd, u.filePath));
+  const filePaths = input.updates.map((u) => path6.resolve(cwd, u.filePath));
   if (ctx.additionalFiles) {
-    filePaths.push(...ctx.additionalFiles.map((f) => path3.resolve(cwd, f)));
+    filePaths.push(...ctx.additionalFiles.map((f) => path6.resolve(cwd, f)));
   }
   if (filePaths.length === 0) {
-    info2("No files to commit");
+    info("No files to commit");
     return;
   }
   try {
@@ -615,7 +1122,7 @@ async function runGitCommitStage(ctx) {
     });
     ctx.output.git.committed = true;
     if (!dryRun) {
-      success2("Created git commit");
+      success("Created git commit");
     }
   } catch (error) {
     throw createPublishError(
@@ -633,7 +1140,7 @@ async function runGitCommitStage(ctx) {
       });
       ctx.output.git.tags.push(tag);
       if (!dryRun) {
-        success2(`Created tag: ${tag}`);
+        success(`Created tag: ${tag}`);
       }
     } catch (error) {
       throw createPublishError(
@@ -645,7 +1152,6 @@ async function runGitCommitStage(ctx) {
 }
 
 // src/stages/git-push.ts
-import { info as info3, success as success3 } from "@releasekit/core";
 function toGithubAuthedUrl(remoteUrl, token) {
   try {
     const url = new URL(remoteUrl);
@@ -662,14 +1168,14 @@ async function runGitPushStage(ctx) {
   const { config, cliOptions, cwd, output } = ctx;
   const dryRun = cliOptions.dryRun;
   if (!config.git.push) {
-    info3("Git push disabled in config, skipping");
+    info("Git push disabled in config, skipping");
     return;
   }
   if (!output.git.committed && output.git.tags.length === 0) {
-    info3("Nothing to push (no commits or tags created)");
+    info("Nothing to push (no commits or tags created)");
     return;
   }
-  const { remote, branch } = config.git;
+  const { remote } = config.git;
   let pushMethod = config.git.pushMethod;
   if (pushMethod === "auto") {
     try {
@@ -689,7 +1195,19 @@ async function runGitPushStage(ctx) {
         pushRemote = authed;
       }
     }
+    let branch;
     if (output.git.committed) {
+      branch = config.git.branch;
+      if (!branch) {
+        const revResult = await execCommand("git", ["rev-parse", "--abbrev-ref", "HEAD"], { cwd, dryRun: false });
+        branch = revResult.stdout.trim();
+        if (branch === "HEAD") {
+          throw createPublishError(
+            "GIT_PUSH_ERROR" /* GIT_PUSH_ERROR */,
+            "Cannot push: repository is in a detached HEAD state. Set git.branch in your config or pass --branch <name>."
+          );
+        }
+      }
       await execCommand("git", ["push", pushRemote, branch], {
         cwd,
         dryRun,
@@ -705,9 +1223,12 @@ async function runGitPushStage(ctx) {
     }
     ctx.output.git.pushed = true;
     if (!dryRun) {
-      success3(`Pushed to ${remote}/${branch}`);
+      success(`Pushed to ${remote}${branch ? `/${branch}` : ""}`);
     }
   } catch (error) {
+    if (error instanceof PublishError) {
+      throw error;
+    }
     throw createPublishError(
       "GIT_PUSH_ERROR" /* GIT_PUSH_ERROR */,
       `${error instanceof Error ? error.message : String(error)}`
@@ -716,8 +1237,7 @@ async function runGitPushStage(ctx) {
 }
 
 // src/stages/github-release.ts
-import * as fs4 from "fs";
-import { debug as debug3, info as info4, success as success4, warn as warn2 } from "@releasekit/core";
+import * as fs7 from "fs";
 function resolveNotes(notesSetting, tag, changelogs, pipelineNotes) {
   if (notesSetting === "none") {
     return { useGithubNotes: false };
@@ -728,7 +1248,7 @@ function resolveNotes(notesSetting, tag, changelogs, pipelineNotes) {
   if (notesSetting !== "auto") {
     const body = readFileIfExists(notesSetting);
     if (body) return { body, useGithubNotes: false };
-    debug3(`Notes file not found: ${notesSetting}, falling back to GitHub auto-notes`);
+    debug(`Notes file not found: ${notesSetting}, falling back to GitHub auto-notes`);
     return { useGithubNotes: true };
   }
   if (pipelineNotes) {
@@ -756,7 +1276,7 @@ function findNotesForTag(tag, notes) {
 }
 function readFileIfExists(filePath) {
   try {
-    const content = fs4.readFileSync(filePath, "utf-8").trim();
+    const content = fs7.readFileSync(filePath, "utf-8").trim();
     return content || void 0;
   } catch {
     return void 0;
@@ -778,12 +1298,12 @@ async function runGithubReleaseStage(ctx) {
   const { config, cliOptions, output } = ctx;
   const dryRun = cliOptions.dryRun;
   if (!config.githubRelease.enabled) {
-    debug3("GitHub releases disabled in config");
+    debug("GitHub releases disabled in config");
     return;
   }
   const tags = output.git.tags.length > 0 ? output.git.tags : ctx.input.tags;
   if (tags.length === 0) {
-    info4("No tags available for GitHub release");
+    info("No tags available for GitHub release");
     return;
   }
   const firstTag = tags[0];
@@ -829,35 +1349,33 @@ async function runGithubReleaseStage(ctx) {
         result.url = execResult.stdout.trim();
       }
       if (!dryRun) {
-        success4(`Created GitHub release for ${tag}`);
+        success(`Created GitHub release for ${tag}`);
       }
     } catch (error) {
       result.reason = error instanceof Error ? error.message : String(error);
-      warn2(`Failed to create GitHub release for ${tag}: ${result.reason}`);
+      warn(`Failed to create GitHub release for ${tag}: ${result.reason}`);
     }
     ctx.output.githubReleases.push(result);
   }
 }
 
 // src/stages/npm-publish.ts
-import * as fs6 from "fs";
-import * as path5 from "path";
-import { debug as debug5, info as info5, success as success5, warn as warn3 } from "@releasekit/core";
+import * as fs9 from "fs";
+import * as path8 from "path";
 
 // src/utils/npm-env.ts
-import * as fs5 from "fs";
-import * as os from "os";
-import * as path4 from "path";
-import { debug as debug4 } from "@releasekit/core";
+import * as fs8 from "fs";
+import * as os2 from "os";
+import * as path7 from "path";
 function writeTempNpmrc(contents) {
-  const dir = fs5.mkdtempSync(path4.join(os.tmpdir(), "releasekit-npmrc-"));
-  const npmrcPath = path4.join(dir, ".npmrc");
-  fs5.writeFileSync(npmrcPath, contents, "utf-8");
+  const dir = fs8.mkdtempSync(path7.join(os2.tmpdir(), "releasekit-npmrc-"));
+  const npmrcPath = path7.join(dir, ".npmrc");
+  fs8.writeFileSync(npmrcPath, contents, "utf-8");
   return {
     npmrcPath,
     cleanup: () => {
       try {
-        fs5.rmSync(dir, { recursive: true, force: true });
+        fs8.rmSync(dir, { recursive: true, force: true });
       } catch {
       }
     }
@@ -885,7 +1403,7 @@ function createNpmSubprocessIsolation(options) {
   }
   lines.push("");
   const { npmrcPath, cleanup } = writeTempNpmrc(lines.join("\n"));
-  debug4(`Using isolated npm userconfig: ${npmrcPath}`);
+  debug(`Using isolated npm userconfig: ${npmrcPath}`);
   const isOidc = authMethod === "oidc";
   return {
     env: {
@@ -915,7 +1433,7 @@ async function runNpmPublishStage(ctx) {
   const { input, config, cliOptions, cwd } = ctx;
   const dryRun = cliOptions.dryRun;
   if (!config.npm.enabled) {
-    info5("NPM publishing disabled in config");
+    info("NPM publishing disabled in config");
     return;
   }
   const authMethod = config.npm.auth === "auto" ? detectNpmAuth() : config.npm.auth;
@@ -936,16 +1454,16 @@ async function runNpmPublishStage(ctx) {
         success: false,
         skipped: false
       };
-      const pkgJsonPath = path5.resolve(cwd, update.filePath);
+      const pkgJsonPath = path8.resolve(cwd, update.filePath);
       try {
-        const pkgContent = fs6.readFileSync(pkgJsonPath, "utf-8");
+        const pkgContent = fs9.readFileSync(pkgJsonPath, "utf-8");
         const pkgJson = JSON.parse(pkgContent);
         if (pkgJson.private) {
           result.skipped = true;
           result.success = true;
           result.reason = "Package is private";
           ctx.output.npm.push(result);
-          debug5(`Skipping private package: ${update.packageName}`);
+          debug(`Skipping private package: ${update.packageName}`);
           continue;
         }
       } catch {
@@ -974,11 +1492,11 @@ async function runNpmPublishStage(ctx) {
         result.success = true;
         result.reason = "Already published";
         ctx.output.npm.push(result);
-        warn3(`${update.packageName}@${update.newVersion} is already published, skipping`);
+        warn(`${update.packageName}@${update.newVersion} is already published, skipping`);
         continue;
       }
       const distTag = getDistTag(update.newVersion, config.npm.tag);
-      const pkgDir = path5.dirname(path5.resolve(cwd, update.filePath));
+      const pkgDir = path8.dirname(path8.resolve(cwd, update.filePath));
       const { file: pubFile, args: pubArgs } = buildPublishCommand(ctx.packageManager, update.packageName, pkgDir, {
         access: config.npm.access,
         tag: distTag,
@@ -994,11 +1512,11 @@ async function runNpmPublishStage(ctx) {
         });
         result.success = true;
         if (!dryRun) {
-          success5(`Published ${update.packageName}@${update.newVersion} to npm`);
+          success(`Published ${update.packageName}@${update.newVersion} to npm`);
         }
       } catch (error) {
         result.reason = error instanceof Error ? error.message : String(error);
-        warn3(`Failed to publish ${update.packageName}: ${result.reason}`);
+        warn(`Failed to publish ${update.packageName}: ${result.reason}`);
       }
       ctx.output.npm.push(result);
     }
@@ -1008,32 +1526,31 @@ async function runNpmPublishStage(ctx) {
 }
 
 // src/stages/prepare.ts
-import * as fs7 from "fs";
-import * as path6 from "path";
-import { debug as debug6, info as info6 } from "@releasekit/core";
+import * as fs10 from "fs";
+import * as path9 from "path";
 async function runPrepareStage(ctx) {
   const { input, config, cliOptions, cwd } = ctx;
   if (config.npm.enabled && config.npm.copyFiles.length > 0) {
     for (const update of input.updates) {
-      const pkgDir = path6.dirname(path6.resolve(cwd, update.filePath));
+      const pkgDir = path9.dirname(path9.resolve(cwd, update.filePath));
       for (const file of config.npm.copyFiles) {
-        const src = path6.resolve(cwd, file);
-        const dest = path6.join(pkgDir, file);
-        if (!fs7.existsSync(src)) {
-          debug6(`Source file not found, skipping copy: ${src}`);
+        const src = path9.resolve(cwd, file);
+        const dest = path9.join(pkgDir, file);
+        if (!fs10.existsSync(src)) {
+          debug(`Source file not found, skipping copy: ${src}`);
           continue;
         }
-        if (path6.resolve(path6.dirname(src)) === path6.resolve(pkgDir)) {
-          debug6(`Skipping copy of ${file} - same directory as source`);
+        if (path9.resolve(path9.dirname(src)) === path9.resolve(pkgDir)) {
+          debug(`Skipping copy of ${file} - same directory as source`);
           continue;
         }
         if (cliOptions.dryRun) {
-          info6(`[DRY RUN] Would copy ${src} \u2192 ${dest}`);
+          info(`[DRY RUN] Would copy ${src} \u2192 ${dest}`);
           continue;
         }
         try {
-          fs7.copyFileSync(src, dest);
-          debug6(`Copied ${file} \u2192 ${pkgDir}`);
+          fs10.copyFileSync(src, dest);
+          debug(`Copied ${file} \u2192 ${pkgDir}`);
         } catch (error) {
           throw createPublishError(
             "FILE_COPY_ERROR" /* FILE_COPY_ERROR */,
@@ -1045,26 +1562,22 @@ async function runPrepareStage(ctx) {
   }
   if (config.cargo.enabled) {
     for (const update of input.updates) {
-      const pkgDir = path6.dirname(path6.resolve(cwd, update.filePath));
-      const cargoPath = path6.join(pkgDir, "Cargo.toml");
-      if (!fs7.existsSync(cargoPath)) {
+      const pkgDir = path9.dirname(path9.resolve(cwd, update.filePath));
+      const cargoPath = path9.join(pkgDir, "Cargo.toml");
+      if (!fs10.existsSync(cargoPath)) {
         continue;
       }
       if (cliOptions.dryRun) {
-        info6(`[DRY RUN] Would update ${cargoPath} to version ${update.newVersion}`);
+        info(`[DRY RUN] Would update ${cargoPath} to version ${update.newVersion}`);
         continue;
       }
       updateCargoVersion(cargoPath, update.newVersion);
-      debug6(`Updated ${cargoPath} to version ${update.newVersion}`);
+      debug(`Updated ${cargoPath} to version ${update.newVersion}`);
     }
   }
 }
 
-// src/stages/verify.ts
-import { debug as debug8, info as info7, success as success6, warn as warn4 } from "@releasekit/core";
-
 // src/utils/retry.ts
-import { debug as debug7 } from "@releasekit/core";
 async function withRetry(fn, options, shouldRetry) {
   let lastError;
   let delay = options.initialDelay;
@@ -1077,7 +1590,7 @@ async function withRetry(fn, options, shouldRetry) {
         throw error;
       }
       if (attempt < options.maxAttempts) {
-        debug7(`Attempt ${attempt}/${options.maxAttempts} failed, retrying in ${delay}ms...`);
+        debug(`Attempt ${attempt}/${options.maxAttempts} failed, retrying in ${delay}ms...`);
         await sleep(delay);
         delay = Math.floor(delay * options.backoffMultiplier);
       }
@@ -1086,7 +1599,7 @@ async function withRetry(fn, options, shouldRetry) {
   throw lastError;
 }
 function sleep(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
+  return new Promise((resolve6) => setTimeout(resolve6, ms));
 }
 
 // src/stages/verify.ts
@@ -1103,7 +1616,7 @@ async function runVerifyStage(ctx) {
         attempts: 0
       };
       if (cliOptions.dryRun) {
-        info7(`[DRY RUN] Would verify ${pkg.packageName}@${pkg.version} on npm`);
+        info(`[DRY RUN] Would verify ${pkg.packageName}@${pkg.version} on npm`);
         result.verified = true;
         ctx.output.verification.push(result);
         continue;
@@ -1119,12 +1632,12 @@ async function runVerifyStage(ctx) {
           if (viewResult.exitCode !== 0 || !viewResult.stdout.trim()) {
             throw new Error(`${pkg.packageName}@${pkg.version} not yet available on npm`);
           }
-          debug8(`Verified ${pkg.packageName}@${pkg.version} on npm`);
+          debug(`Verified ${pkg.packageName}@${pkg.version} on npm`);
         }, config.verify.npm);
         result.verified = true;
-        success6(`Verified ${pkg.packageName}@${pkg.version} on npm`);
+        success(`Verified ${pkg.packageName}@${pkg.version} on npm`);
       } catch {
-        warn4(`Failed to verify ${pkg.packageName}@${pkg.version} on npm after ${result.attempts} attempts`);
+        warn(`Failed to verify ${pkg.packageName}@${pkg.version} on npm after ${result.attempts} attempts`);
       }
       ctx.output.verification.push(result);
     }
@@ -1140,7 +1653,7 @@ async function runVerifyStage(ctx) {
         attempts: 0
       };
       if (cliOptions.dryRun) {
-        info7(`[DRY RUN] Would verify ${crate.packageName}@${crate.version} on crates.io`);
+        info(`[DRY RUN] Would verify ${crate.packageName}@${crate.version} on crates.io`);
         result.verified = true;
         ctx.output.verification.push(result);
         continue;
@@ -1152,12 +1665,12 @@ async function runVerifyStage(ctx) {
           if (!response.ok) {
             throw new Error(`${crate.packageName}@${crate.version} not yet available on crates.io`);
           }
-          debug8(`Verified ${crate.packageName}@${crate.version} on crates.io`);
+          debug(`Verified ${crate.packageName}@${crate.version} on crates.io`);
         }, config.verify.cargo);
         result.verified = true;
-        success6(`Verified ${crate.packageName}@${crate.version} on crates.io`);
+        success(`Verified ${crate.packageName}@${crate.version} on crates.io`);
       } catch {
-        warn4(`Failed to verify ${crate.packageName}@${crate.version} on crates.io after ${result.attempts} attempts`);
+        warn(`Failed to verify ${crate.packageName}@${crate.version} on crates.io after ${result.attempts} attempts`);
       }
       ctx.output.verification.push(result);
     }
@@ -1237,41 +1750,40 @@ async function runPipeline(input, config, options) {
 }
 
 // src/stages/input.ts
-import * as fs8 from "fs";
-import { info as info8 } from "@releasekit/core";
-import { z } from "zod";
-var VersionChangelogEntrySchema = z.object({
-  type: z.string(),
-  description: z.string(),
-  issueIds: z.array(z.string()).optional(),
-  scope: z.string().optional(),
-  originalType: z.string().optional()
+import * as fs11 from "fs";
+import { z as z3 } from "zod";
+var VersionChangelogEntrySchema = z3.object({
+  type: z3.string(),
+  description: z3.string(),
+  issueIds: z3.array(z3.string()).optional(),
+  scope: z3.string().optional(),
+  originalType: z3.string().optional()
 });
-var VersionPackageChangelogSchema = z.object({
-  packageName: z.string(),
-  version: z.string(),
-  previousVersion: z.string().nullable(),
-  revisionRange: z.string(),
-  repoUrl: z.string().nullable(),
-  entries: z.array(VersionChangelogEntrySchema)
+var VersionPackageChangelogSchema = z3.object({
+  packageName: z3.string(),
+  version: z3.string(),
+  previousVersion: z3.string().nullable(),
+  revisionRange: z3.string(),
+  repoUrl: z3.string().nullable(),
+  entries: z3.array(VersionChangelogEntrySchema)
 });
-var VersionPackageUpdateSchema = z.object({
-  packageName: z.string(),
-  newVersion: z.string(),
-  filePath: z.string()
+var VersionPackageUpdateSchema = z3.object({
+  packageName: z3.string(),
+  newVersion: z3.string(),
+  filePath: z3.string()
 });
-var VersionOutputSchema = z.object({
-  dryRun: z.boolean(),
-  updates: z.array(VersionPackageUpdateSchema),
-  changelogs: z.array(VersionPackageChangelogSchema),
-  commitMessage: z.string().optional(),
-  tags: z.array(z.string())
+var VersionOutputSchema = z3.object({
+  dryRun: z3.boolean(),
+  updates: z3.array(VersionPackageUpdateSchema),
+  changelogs: z3.array(VersionPackageChangelogSchema),
+  commitMessage: z3.string().optional(),
+  tags: z3.array(z3.string())
 });
 async function parseInput(inputPath) {
   let raw;
   if (inputPath) {
     try {
-      raw = fs8.readFileSync(inputPath, "utf-8");
+      raw = fs11.readFileSync(inputPath, "utf-8");
     } catch {
       throw createPublishError("INPUT_PARSE_ERROR" /* INPUT_PARSE_ERROR */, `Could not read file: ${inputPath}`);
     }
@@ -1291,7 +1803,7 @@ async function parseInput(inputPath) {
 ${issues}`);
   }
   if (result.data.updates.length === 0) {
-    info8("No package updates in version output \u2014 pipeline will be a no-op");
+    info("No package updates in version output \u2014 pipeline will be a no-op");
   }
   return result.data;
 }
@@ -1304,7 +1816,12 @@ async function readStdin() {
 }
 
 export {
-  loadConfig,
+  readPackageVersion,
+  setLogLevel,
+  setJsonMode,
+  EXIT_CODES,
+  parseCargoToml,
+  loadConfig2 as loadConfig,
   getDefaultConfig2 as getDefaultConfig,
   BasePublishError,
   PublishError,
@@ -1313,7 +1830,6 @@ export {
   createPublishError,
   detectNpmAuth,
   hasCargoAuth,
-  parseCargoToml,
   updateCargoVersion,
   extractPathDeps,
   isPrerelease,