@releasekit/publish 0.1.0 → 0.2.0-next.0

package/dist/chunk-PQ775B2I.js

@@ -1,1019 +0,0 @@
-// src/errors/index.ts
-import { ReleaseKitError } from "@releasekit/core";
-var BasePublishError = class _BasePublishError extends ReleaseKitError {
-  code;
-  suggestions;
-  constructor(message, code, suggestions) {
-    super(message);
-    this.code = code;
-    this.suggestions = suggestions ?? [];
-  }
-  static isPublishError(error) {
-    return error instanceof _BasePublishError;
-  }
-};
-var PublishError = class extends BasePublishError {
-};
-var PublishErrorCode = /* @__PURE__ */ ((PublishErrorCode2) => {
-  PublishErrorCode2["INPUT_PARSE_ERROR"] = "INPUT_PARSE_ERROR";
-  PublishErrorCode2["INPUT_VALIDATION_ERROR"] = "INPUT_VALIDATION_ERROR";
-  PublishErrorCode2["CONFIG_ERROR"] = "CONFIG_ERROR";
-  PublishErrorCode2["GIT_COMMIT_ERROR"] = "GIT_COMMIT_ERROR";
-  PublishErrorCode2["GIT_TAG_ERROR"] = "GIT_TAG_ERROR";
-  PublishErrorCode2["GIT_PUSH_ERROR"] = "GIT_PUSH_ERROR";
-  PublishErrorCode2["NPM_PUBLISH_ERROR"] = "NPM_PUBLISH_ERROR";
-  PublishErrorCode2["NPM_AUTH_ERROR"] = "NPM_AUTH_ERROR";
-  PublishErrorCode2["CARGO_PUBLISH_ERROR"] = "CARGO_PUBLISH_ERROR";
-  PublishErrorCode2["CARGO_AUTH_ERROR"] = "CARGO_AUTH_ERROR";
-  PublishErrorCode2["VERIFICATION_FAILED"] = "VERIFICATION_FAILED";
-  PublishErrorCode2["GITHUB_RELEASE_ERROR"] = "GITHUB_RELEASE_ERROR";
-  PublishErrorCode2["FILE_COPY_ERROR"] = "FILE_COPY_ERROR";
-  PublishErrorCode2["CARGO_TOML_ERROR"] = "CARGO_TOML_ERROR";
-  return PublishErrorCode2;
-})(PublishErrorCode || {});
-function createPublishError(code, details) {
-  const messages = {
-    ["INPUT_PARSE_ERROR" /* INPUT_PARSE_ERROR */]: "Failed to parse version output",
-    ["INPUT_VALIDATION_ERROR" /* INPUT_VALIDATION_ERROR */]: "Version output validation failed",
-    ["CONFIG_ERROR" /* CONFIG_ERROR */]: "Invalid publish configuration",
-    ["GIT_COMMIT_ERROR" /* GIT_COMMIT_ERROR */]: "Failed to create git commit",
-    ["GIT_TAG_ERROR" /* GIT_TAG_ERROR */]: "Failed to create git tag",
-    ["GIT_PUSH_ERROR" /* GIT_PUSH_ERROR */]: "Failed to push to remote",
-    ["NPM_PUBLISH_ERROR" /* NPM_PUBLISH_ERROR */]: "Failed to publish to npm",
-    ["NPM_AUTH_ERROR" /* NPM_AUTH_ERROR */]: "NPM authentication failed",
-    ["CARGO_PUBLISH_ERROR" /* CARGO_PUBLISH_ERROR */]: "Failed to publish to crates.io",
-    ["CARGO_AUTH_ERROR" /* CARGO_AUTH_ERROR */]: "Cargo authentication failed",
-    ["VERIFICATION_FAILED" /* VERIFICATION_FAILED */]: "Package verification failed",
-    ["GITHUB_RELEASE_ERROR" /* GITHUB_RELEASE_ERROR */]: "Failed to create GitHub release",
-    ["FILE_COPY_ERROR" /* FILE_COPY_ERROR */]: "Failed to copy files",
-    ["CARGO_TOML_ERROR" /* CARGO_TOML_ERROR */]: "Failed to update Cargo.toml"
-  };
-  const suggestions = {
-    ["INPUT_PARSE_ERROR" /* INPUT_PARSE_ERROR */]: [
-      "Ensure the input is valid JSON from @releasekit/version --json",
-      "Check that stdin is piped correctly or --input path is valid"
-    ],
-    ["INPUT_VALIDATION_ERROR" /* INPUT_VALIDATION_ERROR */]: [
-      "Ensure the input matches the expected VersionOutput schema",
-      "Run @releasekit/version with --json to generate valid output"
-    ],
-    ["CONFIG_ERROR" /* CONFIG_ERROR */]: [
-      "Validate publish.config.json syntax",
-      "Check configuration against the schema",
-      "Review documentation for valid configuration options"
-    ],
-    ["GIT_COMMIT_ERROR" /* GIT_COMMIT_ERROR */]: [
-      "Ensure there are staged changes to commit",
-      "Check git user.name and user.email are configured",
-      "Verify you have write access to the repository"
-    ],
-    ["GIT_TAG_ERROR" /* GIT_TAG_ERROR */]: [
-      "Check if the tag already exists: git tag -l <tag>",
-      "Delete existing tag if needed: git tag -d <tag>"
-    ],
-    ["GIT_PUSH_ERROR" /* GIT_PUSH_ERROR */]: [
-      "Verify remote repository access",
-      "Check SSH key or deploy key configuration",
-      "Ensure the branch is not protected or you have push access"
-    ],
-    ["NPM_PUBLISH_ERROR" /* NPM_PUBLISH_ERROR */]: [
-      "Check npm registry availability",
-      "Verify package name is not already taken by another owner",
-      "Ensure package version has not already been published"
-    ],
-    ["NPM_AUTH_ERROR" /* NPM_AUTH_ERROR */]: [
-      "Set NPM_TOKEN environment variable for token-based auth",
-      "Enable OIDC trusted publishing in GitHub Actions for provenance",
-      "Run npm login for local publishing"
-    ],
-    ["CARGO_PUBLISH_ERROR" /* CARGO_PUBLISH_ERROR */]: [
-      "Check crates.io registry availability",
-      "Verify crate name ownership on crates.io",
-      "Ensure Cargo.toml metadata is complete (description, license, etc.)"
-    ],
-    ["CARGO_AUTH_ERROR" /* CARGO_AUTH_ERROR */]: [
-      "Set CARGO_REGISTRY_TOKEN environment variable",
-      "Generate a token at https://crates.io/settings/tokens"
-    ],
-    ["VERIFICATION_FAILED" /* VERIFICATION_FAILED */]: [
-      "Registry propagation may take longer than expected",
-      "Try increasing verify.maxAttempts or verify.initialDelay in config",
-      "Check registry status pages for outages"
-    ],
-    ["GITHUB_RELEASE_ERROR" /* GITHUB_RELEASE_ERROR */]: [
-      "Ensure gh CLI is installed and authenticated",
-      "Verify GITHUB_TOKEN has contents:write permission",
-      "Check that the tag exists in the remote repository"
-    ],
-    ["FILE_COPY_ERROR" /* FILE_COPY_ERROR */]: [
-      "Verify the source file exists in the project root",
-      "Check file permissions"
-    ],
-    ["CARGO_TOML_ERROR" /* CARGO_TOML_ERROR */]: [
-      "Ensure Cargo.toml exists and is valid TOML",
-      "Check that the [package] section has a version field"
-    ]
-  };
-  const baseMessage = messages[code];
-  const fullMessage = details ? `${baseMessage}: ${details}` : baseMessage;
-  return new PublishError(fullMessage, code, suggestions[code]);
-}
-
-// src/config.ts
-import * as fs from "fs";
-import * as path from "path";
-import { z } from "zod";
-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 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 CargoConfigSchema = z.object({
-  enabled: z.boolean().default(false),
-  noVerify: z.boolean().default(false),
-  publishOrder: z.array(z.string()).default([]),
-  clean: z.boolean().default(false)
-});
-var GitConfigSchema = z.object({
-  push: z.boolean().default(true),
-  pushMethod: z.enum(["auto", "ssh", "https"]).default("auto"),
-  remote: z.string().default("origin"),
-  branch: z.string().default("main")
-});
-var GitHubReleaseConfigSchema = z.object({
-  enabled: z.boolean().default(true),
-  draft: z.boolean().default(true),
-  generateNotes: z.boolean().default(true),
-  perPackage: z.boolean().default(false),
-  prerelease: z.union([z.literal("auto"), z.boolean()]).default("auto"),
-  notesFile: z.string().optional()
-});
-var VerifyConfigSchema = z.object({
-  npm: VerifyRegistryConfigSchema.default({}),
-  cargo: VerifyRegistryConfigSchema.default({
-    enabled: true,
-    maxAttempts: 10,
-    initialDelay: 3e4,
-    backoffMultiplier: 2
-  })
-});
-var PublishConfigSchema = z.object({
-  npm: NpmConfigSchema.default({}),
-  cargo: CargoConfigSchema.default({}),
-  git: GitConfigSchema.default({}),
-  githubRelease: GitHubReleaseConfigSchema.default({}),
-  verify: VerifyConfigSchema.default({})
-});
-function loadConfig(projectDir, configFile) {
-  const configPath = configFile ?? path.join(projectDir, "publish.config.json");
-  if (!fs.existsSync(configPath)) {
-    return getDefaultConfig();
-  }
-  try {
-    const content = fs.readFileSync(configPath, "utf-8");
-    const raw = JSON.parse(content);
-    return PublishConfigSchema.parse(raw);
-  } catch (error) {
-    if (error instanceof z.ZodError) {
-      const issues = error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n");
-      throw createPublishError("CONFIG_ERROR" /* CONFIG_ERROR */, `Validation errors:
-${issues}`);
-    }
-    if (error instanceof SyntaxError) {
-      throw createPublishError("CONFIG_ERROR" /* CONFIG_ERROR */, `Invalid JSON: ${error.message}`);
-    }
-    throw error;
-  }
-}
-function getDefaultConfig() {
-  return PublishConfigSchema.parse({});
-}
-
-// src/utils/exec.ts
-import { exec } from "child_process";
-import { debug, info } from "@releasekit/core";
-async function execCommand(command, options = {}) {
-  if (options.dryRun) {
-    info(`[DRY RUN] Would execute: ${options.label ?? command}`);
-    return { stdout: "", stderr: "", exitCode: 0 };
-  }
-  debug(`Executing: ${command}`);
-  return new Promise((resolve5, reject) => {
-    exec(
-      command,
-      {
-        maxBuffer: 1024 * 1024 * 10,
-        cwd: options.cwd,
-        env: options.env ? { ...process.env, ...options.env } : void 0
-      },
-      (error, stdout, stderr) => {
-        if (error) {
-          reject(
-            Object.assign(new Error(error.message), {
-              stdout: stdout.toString(),
-              stderr: stderr.toString(),
-              exitCode: error.code ?? 1
-            })
-          );
-        } else {
-          resolve5({
-            stdout: stdout.toString(),
-            stderr: stderr.toString(),
-            exitCode: 0
-          });
-        }
-      }
-    );
-  });
-}
-async function execCommandSafe(command, options = {}) {
-  try {
-    return await execCommand(command, options);
-  } catch (error) {
-    if (error && typeof error === "object" && "stdout" in error) {
-      const execError = error;
-      return {
-        stdout: execError.stdout ?? "",
-        stderr: execError.stderr ?? "",
-        exitCode: execError.exitCode ?? 1
-      };
-    }
-    return { stdout: "", stderr: error instanceof Error ? error.message : String(error), exitCode: 1 };
-  }
-}
-
-// src/utils/auth.ts
-function detectNpmAuth() {
-  if (process.env.ACTIONS_ID_TOKEN_REQUEST_URL) {
-    return "oidc";
-  }
-  if (process.env.NPM_TOKEN) {
-    return "token";
-  }
-  return null;
-}
-function hasCargoAuth() {
-  return !!process.env.CARGO_REGISTRY_TOKEN;
-}
-async function detectGitPushMethod(remote, cwd) {
-  const result = await execCommand(`git remote get-url ${remote}`, { cwd });
-  const url = result.stdout.trim();
-  if (url.startsWith("git@") || url.startsWith("ssh://")) {
-    return "ssh";
-  }
-  return "https";
-}
-
-// src/utils/semver.ts
-import semver from "semver";
-function isPrerelease(version) {
-  return semver.prerelease(version) !== null;
-}
-function getDistTag(version, defaultTag = "latest") {
-  const pre = semver.prerelease(version);
-  if (pre && pre.length > 0) {
-    const identifier = pre[0];
-    return typeof identifier === "string" ? identifier : "next";
-  }
-  return defaultTag;
-}
-
-// src/stages/cargo-publish.ts
-import * as fs2 from "fs";
-import * as path2 from "path";
-import * as TOML from "smol-toml";
-import { success, warn, debug as debug2 } from "@releasekit/core";
-async function runCargoPublishStage(ctx) {
-  const { input, config, cliOptions, cwd } = ctx;
-  const dryRun = cliOptions.dryRun;
-  if (!config.cargo.enabled) {
-    debug2("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 })), cwd);
-  if (crates.length === 0) {
-    debug2("No Cargo crates found to publish");
-    return;
-  }
-  const ordered = orderCrates(crates, config.cargo.publishOrder);
-  for (const crate of ordered) {
-    const result = {
-      packageName: crate.name,
-      version: crate.version,
-      registry: "cargo",
-      success: false,
-      skipped: false
-    };
-    const searchResult = await execCommandSafe(`cargo search ${crate.name} --limit 1`, { cwd, dryRun: false });
-    if (searchResult.exitCode === 0 && searchResult.stdout.includes(`"${crate.version}"`)) {
-      result.alreadyPublished = true;
-      result.skipped = true;
-      result.success = true;
-      result.reason = "Already published on crates.io";
-      ctx.output.cargo.push(result);
-      warn(`${crate.name}@${crate.version} is already published on crates.io, skipping`);
-      continue;
-    }
-    if (config.cargo.clean) {
-      await execCommand("cargo clean", { cwd: crate.dir, dryRun, label: `cargo clean (${crate.name})` });
-    }
-    const parts = ["cargo publish", `--manifest-path "${crate.manifestPath}"`];
-    if (config.cargo.noVerify) {
-      parts.push("--no-verify");
-    }
-    const command = parts.join(" ");
-    try {
-      await execCommand(command, {
-        cwd,
-        dryRun,
-        label: `cargo publish ${crate.name}@${crate.version}`
-      });
-      result.success = true;
-      if (!dryRun) {
-        success(`Published ${crate.name}@${crate.version} to crates.io`);
-      }
-    } catch (error) {
-      result.reason = error instanceof Error ? error.message : String(error);
-      warn(`Failed to publish ${crate.name}: ${result.reason}`);
-    }
-    ctx.output.cargo.push(result);
-  }
-}
-function findCrates(updates, cwd) {
-  const crates = [];
-  for (const update of updates) {
-    const cargoPath = path2.join(update.dir, "Cargo.toml");
-    if (!fs2.existsSync(cargoPath)) {
-      continue;
-    }
-    try {
-      const content = fs2.readFileSync(cargoPath, "utf-8");
-      const cargo = TOML.parse(content);
-      const pkg = cargo["package"];
-      if (!pkg?.["name"]) {
-        continue;
-      }
-      const pathDeps = [];
-      const deps = cargo["dependencies"];
-      if (deps) {
-        for (const dep of Object.values(deps)) {
-          if (dep && typeof dep === "object" && "path" in dep) {
-            pathDeps.push(dep.path);
-          }
-        }
-      }
-      crates.push({
-        name: pkg["name"],
-        version: update.newVersion,
-        dir: update.dir,
-        manifestPath: cargoPath,
-        pathDeps
-      });
-    } catch {
-    }
-  }
-  return crates;
-}
-function orderCrates(crates, explicitOrder) {
-  if (explicitOrder.length > 0) {
-    const ordered = [];
-    const byName = new Map(crates.map((c) => [c.name, c]));
-    for (const name of explicitOrder) {
-      const crate = byName.get(name);
-      if (crate) {
-        ordered.push(crate);
-        byName.delete(name);
-      }
-    }
-    for (const crate of byName.values()) {
-      ordered.push(crate);
-    }
-    return ordered;
-  }
-  return topologicalSort(crates);
-}
-function topologicalSort(crates) {
-  const nameSet = new Set(crates.map((c) => c.name));
-  const graph = /* @__PURE__ */ new Map();
-  const crateMap = new Map(crates.map((c) => [c.name, c]));
-  for (const crate of crates) {
-    graph.set(crate.name, []);
-  }
-  for (const crate of crates) {
-    for (const depPath of crate.pathDeps) {
-      const resolvedDir = path2.resolve(crate.dir, depPath);
-      for (const other of crates) {
-        if (path2.resolve(other.dir) === resolvedDir && nameSet.has(other.name)) {
-          graph.get(crate.name)?.push(other.name);
-        }
-      }
-    }
-  }
-  const inDegree = /* @__PURE__ */ new Map();
-  for (const name of nameSet) {
-    inDegree.set(name, 0);
-  }
-  for (const deps of graph.values()) {
-    for (const dep of deps) {
-      inDegree.set(dep, (inDegree.get(dep) ?? 0) + 1);
-    }
-  }
-  const queue = [];
-  for (const [name, degree] of inDegree) {
-    if (degree === 0) {
-      queue.push(name);
-    }
-  }
-  const result = [];
-  while (queue.length > 0) {
-    const name = queue.shift();
-    const crate = crateMap.get(name);
-    if (crate) {
-      result.push(crate);
-    }
-    for (const dep of graph.get(name) ?? []) {
-      const newDegree = (inDegree.get(dep) ?? 1) - 1;
-      inDegree.set(dep, newDegree);
-      if (newDegree === 0) {
-        queue.push(dep);
-      }
-    }
-  }
-  result.reverse();
-  return result;
-}
-
-// src/stages/git-commit.ts
-import * as path3 from "path";
-import { info as info3, success as success2 } from "@releasekit/core";
-async function runGitCommitStage(ctx) {
-  const { input, cliOptions, cwd } = ctx;
-  const dryRun = cliOptions.dryRun;
-  if (!input.commitMessage) {
-    info3("No commit message provided, skipping git commit");
-    return;
-  }
-  const filePaths = input.updates.map((u) => path3.resolve(cwd, u.filePath));
-  if (filePaths.length === 0) {
-    info3("No files to commit");
-    return;
-  }
-  try {
-    await execCommand(`git add ${filePaths.map((f) => `"${f}"`).join(" ")}`, {
-      cwd,
-      dryRun,
-      label: `git add ${filePaths.length} file(s)`
-    });
-  } catch (error) {
-    throw createPublishError(
-      "GIT_COMMIT_ERROR" /* GIT_COMMIT_ERROR */,
-      `git add failed: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-  const escapedMessage = input.commitMessage.replace(/"/g, '\\"');
-  try {
-    await execCommand(`git commit -m "${escapedMessage}"`, {
-      cwd,
-      dryRun,
-      label: `git commit -m "${input.commitMessage}"`
-    });
-    ctx.output.git.committed = true;
-    if (!dryRun) {
-      success2("Created git commit");
-    }
-  } catch (error) {
-    throw createPublishError(
-      "GIT_COMMIT_ERROR" /* GIT_COMMIT_ERROR */,
-      `git commit failed: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-  for (const tag of input.tags) {
-    try {
-      const tagMessage = `Release ${tag}`;
-      const escapedTagMessage = tagMessage.replace(/"/g, '\\"');
-      await execCommand(`git tag -a "${tag}" -m "${escapedTagMessage}"`, {
-        cwd,
-        dryRun,
-        label: `git tag ${tag}`
-      });
-      ctx.output.git.tags.push(tag);
-      if (!dryRun) {
-        success2(`Created tag: ${tag}`);
-      }
-    } catch (error) {
-      throw createPublishError(
-        "GIT_TAG_ERROR" /* GIT_TAG_ERROR */,
-        `Failed to create tag ${tag}: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-}
-
-// src/stages/git-push.ts
-import { info as info4, success as success3 } from "@releasekit/core";
-async function runGitPushStage(ctx) {
-  const { config, cliOptions, cwd, output } = ctx;
-  const dryRun = cliOptions.dryRun;
-  if (!config.git.push) {
-    info4("Git push disabled in config, skipping");
-    return;
-  }
-  if (!output.git.committed && output.git.tags.length === 0) {
-    info4("Nothing to push (no commits or tags created)");
-    return;
-  }
-  const { remote, branch } = config.git;
-  let pushMethod = config.git.pushMethod;
-  if (pushMethod === "auto") {
-    try {
-      pushMethod = await detectGitPushMethod(remote, cwd);
-    } catch {
-      pushMethod = "https";
-    }
-  }
-  try {
-    if (output.git.committed) {
-      await execCommand(`git push ${remote} ${branch}`, {
-        cwd,
-        dryRun,
-        label: `git push ${remote} ${branch}`
-      });
-    }
-    if (output.git.tags.length > 0) {
-      await execCommand(`git push ${remote} --tags`, {
-        cwd,
-        dryRun,
-        label: `git push ${remote} --tags`
-      });
-    }
-    ctx.output.git.pushed = true;
-    if (!dryRun) {
-      success3(`Pushed to ${remote}/${branch}`);
-    }
-  } catch (error) {
-    throw createPublishError(
-      "GIT_PUSH_ERROR" /* GIT_PUSH_ERROR */,
-      `${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-}
-
-// src/stages/github-release.ts
-import * as fs3 from "fs";
-import { info as info5, success as success4, warn as warn2, debug as debug3 } from "@releasekit/core";
-async function runGithubReleaseStage(ctx) {
-  const { config, cliOptions, output } = ctx;
-  const dryRun = cliOptions.dryRun;
-  if (!config.githubRelease.enabled) {
-    debug3("GitHub releases disabled in config");
-    return;
-  }
-  const tags = output.git.tags.length > 0 ? output.git.tags : ctx.input.tags;
-  if (tags.length === 0) {
-    info5("No tags available for GitHub release");
-    return;
-  }
-  let notesBody;
-  if (config.githubRelease.notesFile) {
-    try {
-      notesBody = fs3.readFileSync(config.githubRelease.notesFile, "utf-8");
-    } catch {
-      debug3(`Could not read notes file: ${config.githubRelease.notesFile}`);
-    }
-  }
-  const tagsToRelease = config.githubRelease.perPackage ? tags : [tags[0]];
-  for (const tag of tagsToRelease) {
-    const versionMatch = tag.match(/(\d+\.\d+\.\d+.*)$/);
-    const version = versionMatch?.[1] ?? "";
-    const isPreRel = config.githubRelease.prerelease === "auto" ? version ? isPrerelease(version) : false : config.githubRelease.prerelease;
-    const result = {
-      tag,
-      draft: config.githubRelease.draft,
-      prerelease: isPreRel,
-      success: false
-    };
-    const parts = ["gh release create", `"${tag}"`];
-    if (config.githubRelease.draft) {
-      parts.push("--draft");
-    }
-    if (isPreRel) {
-      parts.push("--prerelease");
-    }
-    if (notesBody) {
-      const escapedNotes = notesBody.replace(/"/g, '\\"');
-      parts.push(`--notes "${escapedNotes}"`);
-    } else if (config.githubRelease.generateNotes) {
-      parts.push("--generate-notes");
-    }
-    const command = parts.join(" ");
-    try {
-      const execResult = await execCommand(command, {
-        dryRun,
-        label: `gh release create ${tag}`
-      });
-      result.success = true;
-      if (!dryRun && execResult.stdout.trim()) {
-        result.url = execResult.stdout.trim();
-      }
-      if (!dryRun) {
-        success4(`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}`);
-    }
-    ctx.output.githubReleases.push(result);
-  }
-}
-
-// src/stages/npm-publish.ts
-import * as fs4 from "fs";
-import * as path4 from "path";
-import { info as info6, success as success5, warn as warn3, debug as debug4 } from "@releasekit/core";
-async function runNpmPublishStage(ctx) {
-  const { input, config, cliOptions, cwd } = ctx;
-  const dryRun = cliOptions.dryRun;
-  if (!config.npm.enabled) {
-    info6("NPM publishing disabled in config");
-    return;
-  }
-  const authMethod = config.npm.auth === "auto" ? detectNpmAuth() : config.npm.auth;
-  if (!authMethod && !dryRun) {
-    throw createPublishError("NPM_AUTH_ERROR" /* NPM_AUTH_ERROR */, "No NPM authentication method detected");
-  }
-  const useProvenance = config.npm.provenance && authMethod === "oidc";
-  for (const update of input.updates) {
-    const result = {
-      packageName: update.packageName,
-      version: update.newVersion,
-      registry: "npm",
-      success: false,
-      skipped: false
-    };
-    const pkgJsonPath = path4.resolve(cwd, update.filePath);
-    try {
-      const pkgContent = fs4.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);
-        debug4(`Skipping private package: ${update.packageName}`);
-        continue;
-      }
-    } catch {
-      if (update.filePath.endsWith("Cargo.toml")) {
-        result.skipped = true;
-        result.success = true;
-        result.reason = "Not an npm package";
-        ctx.output.npm.push(result);
-        continue;
-      }
-    }
-    const viewResult = await execCommandSafe(`npm view ${update.packageName}@${update.newVersion} version --json`, {
-      cwd,
-      dryRun: false
-      // Always check, even in dry-run
-    });
-    if (viewResult.exitCode === 0 && viewResult.stdout.trim()) {
-      result.alreadyPublished = true;
-      result.skipped = true;
-      result.success = true;
-      result.reason = "Already published";
-      ctx.output.npm.push(result);
-      warn3(`${update.packageName}@${update.newVersion} is already published, skipping`);
-      continue;
-    }
-    const distTag = getDistTag(update.newVersion, config.npm.tag);
-    const parts = ["pnpm publish", `--filter ${update.packageName}`, "--no-git-checks", `--access ${config.npm.access}`, `--tag ${distTag}`];
-    if (useProvenance) {
-      parts.push("--provenance");
-    }
-    const command = parts.join(" ");
-    try {
-      await execCommand(command, {
-        cwd,
-        dryRun,
-        label: `npm publish ${update.packageName}@${update.newVersion}`
-      });
-      result.success = true;
-      if (!dryRun) {
-        success5(`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}`);
-    }
-    ctx.output.npm.push(result);
-  }
-}
-
-// src/stages/prepare.ts
-import * as fs5 from "fs";
-import * as path5 from "path";
-import { debug as debug5, info as info7 } from "@releasekit/core";
-import * as TOML2 from "smol-toml";
-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 = path5.dirname(path5.resolve(cwd, update.filePath));
-      for (const file of config.npm.copyFiles) {
-        const src = path5.resolve(cwd, file);
-        const dest = path5.join(pkgDir, file);
-        if (!fs5.existsSync(src)) {
-          debug5(`Source file not found, skipping copy: ${src}`);
-          continue;
-        }
-        if (path5.resolve(path5.dirname(src)) === path5.resolve(pkgDir)) {
-          debug5(`Skipping copy of ${file} - same directory as source`);
-          continue;
-        }
-        if (cliOptions.dryRun) {
-          info7(`[DRY RUN] Would copy ${src} \u2192 ${dest}`);
-          continue;
-        }
-        try {
-          fs5.copyFileSync(src, dest);
-          debug5(`Copied ${file} \u2192 ${pkgDir}`);
-        } catch (error) {
-          throw createPublishError(
-            "FILE_COPY_ERROR" /* FILE_COPY_ERROR */,
-            `Failed to copy ${src} to ${dest}: ${error instanceof Error ? error.message : String(error)}`
-          );
-        }
-      }
-    }
-  }
-  if (config.cargo.enabled) {
-    for (const update of input.updates) {
-      const pkgDir = path5.dirname(path5.resolve(cwd, update.filePath));
-      const cargoPath = path5.join(pkgDir, "Cargo.toml");
-      if (!fs5.existsSync(cargoPath)) {
-        continue;
-      }
-      if (cliOptions.dryRun) {
-        info7(`[DRY RUN] Would update ${cargoPath} to version ${update.newVersion}`);
-        continue;
-      }
-      try {
-        const content = fs5.readFileSync(cargoPath, "utf-8");
-        const cargo = TOML2.parse(content);
-        const pkg = cargo["package"];
-        if (pkg) {
-          pkg["version"] = update.newVersion;
-          fs5.writeFileSync(cargoPath, TOML2.stringify(cargo));
-          debug5(`Updated ${cargoPath} to version ${update.newVersion}`);
-        }
-      } catch (error) {
-        throw createPublishError(
-          "CARGO_TOML_ERROR" /* CARGO_TOML_ERROR */,
-          `${cargoPath}: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-  }
-}
-
-// src/stages/verify.ts
-import { info as info8, success as success6, warn as warn4, debug as debug7 } from "@releasekit/core";
-
-// src/utils/retry.ts
-import { debug as debug6 } from "@releasekit/core";
-async function withRetry(fn, options, shouldRetry) {
-  let lastError;
-  let delay = options.initialDelay;
-  for (let attempt = 1; attempt <= options.maxAttempts; attempt++) {
-    try {
-      return await fn();
-    } catch (error) {
-      lastError = error;
-      if (shouldRetry && !shouldRetry(error)) {
-        throw error;
-      }
-      if (attempt < options.maxAttempts) {
-        debug6(`Attempt ${attempt}/${options.maxAttempts} failed, retrying in ${delay}ms...`);
-        await sleep(delay);
-        delay = Math.floor(delay * options.backoffMultiplier);
-      }
-    }
-  }
-  throw lastError;
-}
-function sleep(ms) {
-  return new Promise((resolve5) => setTimeout(resolve5, ms));
-}
-
-// src/stages/verify.ts
-async function runVerifyStage(ctx) {
-  const { config, cliOptions, output, cwd } = ctx;
-  if (config.verify.npm.enabled) {
-    const published = output.npm.filter((r) => r.success && !r.skipped && !r.alreadyPublished);
-    for (const pkg of published) {
-      const result = {
-        packageName: pkg.packageName,
-        version: pkg.version,
-        registry: "npm",
-        verified: false,
-        attempts: 0
-      };
-      if (cliOptions.dryRun) {
-        info8(`[DRY RUN] Would verify ${pkg.packageName}@${pkg.version} on npm`);
-        result.verified = true;
-        ctx.output.verification.push(result);
-        continue;
-      }
-      try {
-        await withRetry(
-          async () => {
-            result.attempts++;
-            const viewResult = await execCommandSafe(
-              `pnpm view ${pkg.packageName}@${pkg.version} version --json`,
-              { cwd, dryRun: false }
-            );
-            if (viewResult.exitCode !== 0 || !viewResult.stdout.trim()) {
-              throw new Error(`${pkg.packageName}@${pkg.version} not yet available on npm`);
-            }
-            debug7(`Verified ${pkg.packageName}@${pkg.version} on npm`);
-          },
-          config.verify.npm
-        );
-        result.verified = true;
-        success6(`Verified ${pkg.packageName}@${pkg.version} on npm`);
-      } catch {
-        warn4(`Failed to verify ${pkg.packageName}@${pkg.version} on npm after ${result.attempts} attempts`);
-      }
-      ctx.output.verification.push(result);
-    }
-  }
-  if (config.verify.cargo.enabled) {
-    const published = output.cargo.filter((r) => r.success && !r.skipped && !r.alreadyPublished);
-    for (const crate of published) {
-      const result = {
-        packageName: crate.packageName,
-        version: crate.version,
-        registry: "cargo",
-        verified: false,
-        attempts: 0
-      };
-      if (cliOptions.dryRun) {
-        info8(`[DRY RUN] Would verify ${crate.packageName}@${crate.version} on crates.io`);
-        result.verified = true;
-        ctx.output.verification.push(result);
-        continue;
-      }
-      try {
-        await withRetry(
-          async () => {
-            result.attempts++;
-            const response = await fetch(
-              `https://crates.io/api/v1/crates/${crate.packageName}/${crate.version}`
-            );
-            if (!response.ok) {
-              throw new Error(`${crate.packageName}@${crate.version} not yet available on crates.io`);
-            }
-            debug7(`Verified ${crate.packageName}@${crate.version} on crates.io`);
-          },
-          config.verify.cargo
-        );
-        result.verified = true;
-        success6(`Verified ${crate.packageName}@${crate.version} on crates.io`);
-      } catch {
-        warn4(`Failed to verify ${crate.packageName}@${crate.version} on crates.io after ${result.attempts} attempts`);
-      }
-      ctx.output.verification.push(result);
-    }
-  }
-}
-
-// src/pipeline/index.ts
-async function runPipeline(input, config, options) {
-  const ctx = {
-    input,
-    config,
-    cliOptions: options,
-    cwd: process.cwd(),
-    output: {
-      dryRun: options.dryRun,
-      git: { committed: false, tags: [], pushed: false },
-      npm: [],
-      cargo: [],
-      verification: [],
-      githubReleases: []
-    }
-  };
-  await runPrepareStage(ctx);
-  if (!options.skipGit) {
-    await runGitCommitStage(ctx);
-  }
-  if (!options.skipPublish) {
-    if (options.registry === "all" || options.registry === "npm") {
-      await runNpmPublishStage(ctx);
-    }
-    if (options.registry === "all" || options.registry === "cargo") {
-      await runCargoPublishStage(ctx);
-    }
-  }
-  if (!options.skipVerification && !options.skipPublish) {
-    await runVerifyStage(ctx);
-  }
-  if (!options.skipGit) {
-    await runGitPushStage(ctx);
-  }
-  if (!options.skipGithubRelease) {
-    await runGithubReleaseStage(ctx);
-  }
-  return ctx.output;
-}
-
-// src/stages/input.ts
-import * as fs6 from "fs";
-import { z as z2 } from "zod";
-var VersionChangelogEntrySchema = z2.object({
-  type: z2.string(),
-  description: z2.string(),
-  issueIds: z2.array(z2.string()).optional(),
-  scope: z2.string().optional(),
-  originalType: z2.string().optional()
-});
-var VersionPackageChangelogSchema = z2.object({
-  packageName: z2.string(),
-  version: z2.string(),
-  previousVersion: z2.string().nullable(),
-  revisionRange: z2.string(),
-  repoUrl: z2.string().nullable(),
-  entries: z2.array(VersionChangelogEntrySchema)
-});
-var VersionPackageUpdateSchema = z2.object({
-  packageName: z2.string(),
-  newVersion: z2.string(),
-  filePath: z2.string()
-});
-var VersionOutputSchema = z2.object({
-  dryRun: z2.boolean(),
-  updates: z2.array(VersionPackageUpdateSchema),
-  changelogs: z2.array(VersionPackageChangelogSchema),
-  commitMessage: z2.string().optional(),
-  tags: z2.array(z2.string())
-});
-async function parseInput(inputPath) {
-  let raw;
-  if (inputPath) {
-    try {
-      raw = fs6.readFileSync(inputPath, "utf-8");
-    } catch {
-      throw createPublishError("INPUT_PARSE_ERROR" /* INPUT_PARSE_ERROR */, `Could not read file: ${inputPath}`);
-    }
-  } else {
-    raw = await readStdin();
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    throw createPublishError("INPUT_PARSE_ERROR" /* INPUT_PARSE_ERROR */, "Input is not valid JSON");
-  }
-  const result = VersionOutputSchema.safeParse(parsed);
-  if (!result.success) {
-    const issues = result.error.issues.map((i) => `  ${i.path.join(".")}: ${i.message}`).join("\n");
-    throw createPublishError("INPUT_VALIDATION_ERROR" /* INPUT_VALIDATION_ERROR */, `Schema validation failed:
-${issues}`);
-  }
-  return result.data;
-}
-async function readStdin() {
-  const chunks = [];
-  for await (const chunk of process.stdin) {
-    chunks.push(chunk);
-  }
-  return chunks.join("");
-}
-
-export {
-  BasePublishError,
-  PublishError,
-  PublishErrorCode,
-  createPublishError,
-  loadConfig,
-  getDefaultConfig,
-  detectNpmAuth,
-  hasCargoAuth,
-  isPrerelease,
-  getDistTag,
-  runPipeline,
-  parseInput
-};