@releasekit/publish 0.2.0 → 0.2.1

package/dist/cli.cjs

@@ -1,1311 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-
-// src/cli.ts
-var import_core13 = require("@releasekit/core");
-var import_commander = require("commander");
-
-// src/config.ts
-var import_config = require("@releasekit/config");
-
-// src/types.ts
-function getDefaultConfig() {
-  return {
-    npm: {
-      enabled: true,
-      auth: "auto",
-      provenance: true,
-      access: "public",
-      registry: "https://registry.npmjs.org",
-      copyFiles: ["LICENSE"],
-      tag: "latest"
-    },
-    cargo: {
-      enabled: false,
-      noVerify: false,
-      publishOrder: [],
-      clean: false
-    },
-    git: {
-      push: true,
-      pushMethod: "auto",
-      remote: "origin",
-      branch: "main",
-      httpsTokenEnv: void 0,
-      skipHooks: false
-    },
-    githubRelease: {
-      enabled: true,
-      draft: true,
-      generateNotes: true,
-      perPackage: false,
-      prerelease: "auto"
-    },
-    verify: {
-      npm: {
-        enabled: true,
-        maxAttempts: 5,
-        initialDelay: 15e3,
-        backoffMultiplier: 2
-      },
-      cargo: {
-        enabled: true,
-        maxAttempts: 10,
-        initialDelay: 3e4,
-        backoffMultiplier: 2
-      }
-    }
-  };
-}
-function toPublishConfig(config) {
-  const defaults = getDefaultConfig();
-  if (!config) return defaults;
-  return {
-    npm: {
-      enabled: config.npm?.enabled ?? defaults.npm.enabled,
-      auth: config.npm?.auth ?? defaults.npm.auth,
-      provenance: config.npm?.provenance ?? defaults.npm.provenance,
-      access: config.npm?.access ?? defaults.npm.access,
-      registry: config.npm?.registry ?? defaults.npm.registry,
-      copyFiles: config.npm?.copyFiles ?? defaults.npm.copyFiles,
-      tag: config.npm?.tag ?? defaults.npm.tag
-    },
-    cargo: {
-      enabled: config.cargo?.enabled ?? defaults.cargo.enabled,
-      noVerify: config.cargo?.noVerify ?? defaults.cargo.noVerify,
-      publishOrder: config.cargo?.publishOrder ?? defaults.cargo.publishOrder,
-      clean: config.cargo?.clean ?? defaults.cargo.clean
-    },
-    git: config.git ? {
-      push: config.git.push ?? defaults.git.push,
-      pushMethod: config.git.pushMethod ?? defaults.git.pushMethod,
-      remote: config.git.remote ?? defaults.git.remote,
-      branch: config.git.branch ?? defaults.git.branch,
-      httpsTokenEnv: config.git.httpsTokenEnv ?? defaults.git.httpsTokenEnv,
-      skipHooks: config.git.skipHooks ?? defaults.git.skipHooks
-    } : defaults.git,
-    githubRelease: {
-      enabled: config.githubRelease?.enabled ?? defaults.githubRelease.enabled,
-      draft: config.githubRelease?.draft ?? defaults.githubRelease.draft,
-      generateNotes: config.githubRelease?.generateNotes ?? defaults.githubRelease.generateNotes,
-      perPackage: config.githubRelease?.perPackage ?? defaults.githubRelease.perPackage,
-      prerelease: config.githubRelease?.prerelease ?? defaults.githubRelease.prerelease,
-      notesFile: config.githubRelease?.notesFile
-    },
-    verify: {
-      npm: {
-        enabled: config.verify?.npm?.enabled ?? defaults.verify.npm.enabled,
-        maxAttempts: config.verify?.npm?.maxAttempts ?? defaults.verify.npm.maxAttempts,
-        initialDelay: config.verify?.npm?.initialDelay ?? defaults.verify.npm.initialDelay,
-        backoffMultiplier: config.verify?.npm?.backoffMultiplier ?? defaults.verify.npm.backoffMultiplier
-      },
-      cargo: {
-        enabled: config.verify?.cargo?.enabled ?? defaults.verify.cargo.enabled,
-        maxAttempts: config.verify?.cargo?.maxAttempts ?? defaults.verify.cargo.maxAttempts,
-        initialDelay: config.verify?.cargo?.initialDelay ?? defaults.verify.cargo.initialDelay,
-        backoffMultiplier: config.verify?.cargo?.backoffMultiplier ?? defaults.verify.cargo.backoffMultiplier
-      }
-    }
-  };
-}
-
-// src/config.ts
-function loadConfig(options) {
-  const baseConfig = (0, import_config.loadPublishConfig)(options);
-  return toPublishConfig(baseConfig);
-}
-
-// src/errors/index.ts
-var import_core = require("@releasekit/core");
-var BasePublishError = class _BasePublishError extends import_core.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 PipelineError = class extends BasePublishError {
-  partialOutput;
-  failedStage;
-  cause;
-  constructor(message, failedStage, partialOutput, cause) {
-    super(message, "PIPELINE_STAGE_ERROR" /* PIPELINE_STAGE_ERROR */, [
-      "Check the partial output for results from stages that completed before the failure",
-      "Use --json to get structured error output with partial results"
-    ]);
-    this.failedStage = failedStage;
-    this.partialOutput = partialOutput;
-    this.cause = cause;
-  }
-};
-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",
-    ["PIPELINE_STAGE_ERROR" /* PIPELINE_STAGE_ERROR */]: "Pipeline stage failed"
-  };
-  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"
-    ],
-    ["PIPELINE_STAGE_ERROR" /* PIPELINE_STAGE_ERROR */]: [
-      "Check the partial output for results from stages that completed before the failure",
-      "Use --json to get structured error output with partial results"
-    ]
-  };
-  const baseMessage = messages[code];
-  const fullMessage = details ? `${baseMessage}: ${details}` : baseMessage;
-  return new PublishError(fullMessage, code, suggestions[code]);
-}
-
-// src/stages/cargo-publish.ts
-var fs2 = __toESM(require("fs"), 1);
-var path = __toESM(require("path"), 1);
-var import_core3 = require("@releasekit/core");
-
-// src/utils/exec.ts
-var import_node_child_process = require("child_process");
-var import_core2 = require("@releasekit/core");
-function redactArg(arg) {
-  try {
-    const url = new URL(arg);
-    if (url.username || url.password) {
-      url.username = url.username ? "***" : "";
-      url.password = url.password ? "***" : "";
-      return url.toString();
-    }
-  } catch {
-  }
-  return arg;
-}
-async function execCommand(file, args, options = {}) {
-  const displayCommand = options.label ?? [file, ...args.map(redactArg)].join(" ");
-  if (options.dryRun) {
-    (0, import_core2.info)(`[DRY RUN] Would execute: ${displayCommand}`);
-    return { stdout: "", stderr: "", exitCode: 0 };
-  }
-  (0, import_core2.debug)(`Executing: ${displayCommand}`);
-  return new Promise((resolve5, reject) => {
-    (0, import_node_child_process.execFile)(
-      file,
-      args,
-      {
-        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(file, args, options = {}) {
-  try {
-    return await execCommand(file, args, 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 || process.env.NODE_AUTH_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/cargo.ts
-var fs = __toESM(require("fs"), 1);
-var import_config2 = require("@releasekit/config");
-var TOML = __toESM(require("smol-toml"), 1);
-function updateCargoVersion(cargoPath, newVersion) {
-  try {
-    const cargo = (0, import_config2.parseCargoToml)(cargoPath);
-    if (cargo.package) {
-      cargo.package.version = newVersion;
-      fs.writeFileSync(cargoPath, TOML.stringify(cargo));
-    }
-  } catch (error) {
-    throw createPublishError(
-      "CARGO_TOML_ERROR" /* CARGO_TOML_ERROR */,
-      `${cargoPath}: ${error instanceof Error ? error.message : String(error)}`
-    );
-  }
-}
-function extractPathDeps(manifest) {
-  const pathDeps = [];
-  const deps = manifest.dependencies;
-  if (deps) {
-    for (const dep of Object.values(deps)) {
-      if (dep && typeof dep === "object" && "path" in dep) {
-        pathDeps.push(dep.path);
-      }
-    }
-  }
-  return pathDeps;
-}
-
-// src/stages/cargo-publish.ts
-async function runCargoPublishStage(ctx) {
-  const { input, config, cliOptions, cwd } = ctx;
-  const dryRun = cliOptions.dryRun;
-  if (!config.cargo.enabled) {
-    (0, import_core3.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: path.dirname(path.resolve(cwd, u.filePath)), ...u })),
-    cwd
-  );
-  if (crates.length === 0) {
-    (0, import_core3.debug)("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);
-      (0, import_core3.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 publishArgs = ["publish", "--manifest-path", crate.manifestPath];
-    if (config.cargo.noVerify) {
-      publishArgs.push("--no-verify");
-    }
-    try {
-      await execCommand("cargo", publishArgs, {
-        cwd,
-        dryRun,
-        label: `cargo publish ${crate.name}@${crate.version}`
-      });
-      result.success = true;
-      if (!dryRun) {
-        (0, import_core3.success)(`Published ${crate.name}@${crate.version} to crates.io`);
-      }
-    } catch (error) {
-      result.reason = error instanceof Error ? error.message : String(error);
-      (0, import_core3.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 = path.join(update.dir, "Cargo.toml");
-    if (!fs2.existsSync(cargoPath)) {
-      continue;
-    }
-    try {
-      const cargo = (0, import_config2.parseCargoToml)(cargoPath);
-      if (!cargo.package?.name) {
-        continue;
-      }
-      const pathDeps = extractPathDeps(cargo);
-      crates.push({
-        name: cargo.package.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 = path.resolve(crate.dir, depPath);
-      for (const other of crates) {
-        if (path.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();
-    if (!name) break;
-    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
-var path2 = __toESM(require("path"), 1);
-var import_core4 = require("@releasekit/core");
-async function runGitCommitStage(ctx) {
-  const { input, config, cliOptions, cwd } = ctx;
-  const dryRun = cliOptions.dryRun;
-  const skipHooks = config.git.skipHooks ?? false;
-  if (!input.commitMessage) {
-    (0, import_core4.info)("No commit message provided, skipping git commit");
-    return;
-  }
-  const filePaths = input.updates.map((u) => path2.resolve(cwd, u.filePath));
-  if (filePaths.length === 0) {
-    (0, import_core4.info)("No files to commit");
-    return;
-  }
-  try {
-    await execCommand("git", ["add", ...filePaths], {
-      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 commitArgs = ["commit"];
-  if (skipHooks) {
-    commitArgs.push("--no-verify");
-  }
-  commitArgs.push("-m", input.commitMessage);
-  try {
-    await execCommand("git", commitArgs, {
-      cwd,
-      dryRun,
-      label: `git commit -m "${input.commitMessage}"`
-    });
-    ctx.output.git.committed = true;
-    if (!dryRun) {
-      (0, import_core4.success)("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}`;
-      await execCommand("git", ["tag", "-a", tag, "-m", tagMessage], {
-        cwd,
-        dryRun,
-        label: `git tag ${tag}`
-      });
-      ctx.output.git.tags.push(tag);
-      if (!dryRun) {
-        (0, import_core4.success)(`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
-var import_core5 = require("@releasekit/core");
-function toGithubAuthedUrl(remoteUrl, token) {
-  try {
-    const url = new URL(remoteUrl);
-    if (url.protocol !== "https:") return void 0;
-    if (url.host !== "github.com") return void 0;
-    url.username = "x-access-token";
-    url.password = token;
-    return url.toString();
-  } catch {
-    return void 0;
-  }
-}
-async function runGitPushStage(ctx) {
-  const { config, cliOptions, cwd, output } = ctx;
-  const dryRun = cliOptions.dryRun;
-  if (!config.git.push) {
-    (0, import_core5.info)("Git push disabled in config, skipping");
-    return;
-  }
-  if (!output.git.committed && output.git.tags.length === 0) {
-    (0, import_core5.info)("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";
-    }
-  }
-  const httpsTokenEnv = config.git.httpsTokenEnv;
-  const httpsToken = httpsTokenEnv ? process.env[httpsTokenEnv] : void 0;
-  try {
-    let pushRemote = remote;
-    if (pushMethod === "https" && httpsToken) {
-      const remoteUrlResult = await execCommand("git", ["remote", "get-url", remote], { cwd, dryRun: false });
-      const authed = toGithubAuthedUrl(remoteUrlResult.stdout.trim(), httpsToken);
-      if (authed) {
-        pushRemote = authed;
-      }
-    }
-    if (output.git.committed) {
-      await execCommand("git", ["push", pushRemote, branch], {
-        cwd,
-        dryRun,
-        label: `git push ${remote} ${branch}`
-      });
-    }
-    if (output.git.tags.length > 0) {
-      await execCommand("git", ["push", pushRemote, "--tags"], {
-        cwd,
-        dryRun,
-        label: `git push ${remote} --tags`
-      });
-    }
-    ctx.output.git.pushed = true;
-    if (!dryRun) {
-      (0, import_core5.success)(`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
-var fs3 = __toESM(require("fs"), 1);
-var import_core6 = require("@releasekit/core");
-
-// src/utils/semver.ts
-var import_semver = __toESM(require("semver"), 1);
-function isPrerelease(version) {
-  return import_semver.default.prerelease(version) !== null;
-}
-function getDistTag(version, defaultTag = "latest") {
-  const pre = import_semver.default.prerelease(version);
-  if (pre && pre.length > 0) {
-    const identifier = pre[0];
-    return typeof identifier === "string" ? identifier : "next";
-  }
-  return defaultTag;
-}
-
-// src/stages/github-release.ts
-async function runGithubReleaseStage(ctx) {
-  const { config, cliOptions, output } = ctx;
-  const dryRun = cliOptions.dryRun;
-  if (!config.githubRelease.enabled) {
-    (0, import_core6.debug)("GitHub releases disabled in config");
-    return;
-  }
-  const tags = output.git.tags.length > 0 ? output.git.tags : ctx.input.tags;
-  if (tags.length === 0) {
-    (0, import_core6.info)("No tags available for GitHub release");
-    return;
-  }
-  let notesBody;
-  if (config.githubRelease.notesFile) {
-    try {
-      notesBody = fs3.readFileSync(config.githubRelease.notesFile, "utf-8");
-    } catch {
-      (0, import_core6.debug)(`Could not read notes file: ${config.githubRelease.notesFile}`);
-    }
-  }
-  const firstTag = tags[0];
-  if (!firstTag) return;
-  const tagsToRelease = config.githubRelease.perPackage ? tags : [firstTag];
-  for (const tag of tagsToRelease) {
-    const MAX_TAG_LENGTH = 1e3;
-    const truncatedTag = tag.length > MAX_TAG_LENGTH ? tag.slice(0, MAX_TAG_LENGTH) : tag;
-    const versionMatch = truncatedTag.match(/(\d{1,20}\.\d{1,20}\.\d{1,20}(?:[-+.]?[a-zA-Z0-9.-]{0,100})?)$/);
-    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 ghArgs = ["release", "create", tag];
-    if (config.githubRelease.draft) {
-      ghArgs.push("--draft");
-    }
-    if (isPreRel) {
-      ghArgs.push("--prerelease");
-    }
-    if (notesBody) {
-      ghArgs.push("--notes", notesBody);
-    } else if (config.githubRelease.generateNotes) {
-      ghArgs.push("--generate-notes");
-    }
-    try {
-      const execResult = await execCommand("gh", ghArgs, {
-        dryRun,
-        label: `gh release create ${tag}`
-      });
-      result.success = true;
-      if (!dryRun && execResult.stdout.trim()) {
-        result.url = execResult.stdout.trim();
-      }
-      if (!dryRun) {
-        (0, import_core6.success)(`Created GitHub release for ${tag}`);
-      }
-    } catch (error) {
-      result.reason = error instanceof Error ? error.message : String(error);
-      (0, import_core6.warn)(`Failed to create GitHub release for ${tag}: ${result.reason}`);
-    }
-    ctx.output.githubReleases.push(result);
-  }
-}
-
-// src/stages/npm-publish.ts
-var fs6 = __toESM(require("fs"), 1);
-var path5 = __toESM(require("path"), 1);
-var import_core8 = require("@releasekit/core");
-
-// src/utils/npm-env.ts
-var fs4 = __toESM(require("fs"), 1);
-var os = __toESM(require("os"), 1);
-var path3 = __toESM(require("path"), 1);
-var import_core7 = require("@releasekit/core");
-function writeTempNpmrc(contents) {
-  const dir = fs4.mkdtempSync(path3.join(os.tmpdir(), "releasekit-npmrc-"));
-  const npmrcPath = path3.join(dir, ".npmrc");
-  fs4.writeFileSync(npmrcPath, contents, "utf-8");
-  return {
-    npmrcPath,
-    cleanup: () => {
-      try {
-        fs4.rmSync(dir, { recursive: true, force: true });
-      } catch {
-      }
-    }
-  };
-}
-function createNpmSubprocessIsolation(options) {
-  const { authMethod, registryUrl } = options;
-  const baseEnv = {};
-  if (!authMethod) return { env: baseEnv, cleanup: () => {
-  } };
-  const token = process.env.NPM_TOKEN ?? process.env.NODE_AUTH_TOKEN;
-  const registryHost = (() => {
-    try {
-      return new URL(registryUrl).host;
-    } catch {
-      return "registry.npmjs.org";
-    }
-  })();
-  const lines = [`registry=${registryUrl}`];
-  if (authMethod === "oidc") {
-    lines.push("always-auth=false");
-  }
-  if (authMethod === "token" && token) {
-    lines.push(`//${registryHost}/:_authToken=${token}`);
-  }
-  lines.push("");
-  const { npmrcPath, cleanup } = writeTempNpmrc(lines.join("\n"));
-  (0, import_core7.debug)(`Using isolated npm userconfig: ${npmrcPath}`);
-  const isOidc = authMethod === "oidc";
-  return {
-    env: {
-      ...baseEnv,
-      // Ensure npm and tools that read npm_config_* pick up our temp file
-      NPM_CONFIG_USERCONFIG: npmrcPath,
-      npm_config_userconfig: npmrcPath,
-      // Auth-specific hardening
-      ...isOidc ? {
-        // Prevent setup-node's always-auth from forcing token lookups
-        NPM_CONFIG_ALWAYS_AUTH: "false",
-        npm_config_always_auth: "false",
-        // Explicitly prevent token-based publishing from being selected implicitly
-        NODE_AUTH_TOKEN: void 0,
-        NPM_TOKEN: void 0
-      } : {
-        // Ensure CLIs that expect NODE_AUTH_TOKEN can still work
-        NODE_AUTH_TOKEN: token
-      }
-    },
-    cleanup
-  };
-}
-
-// src/utils/package-manager.ts
-var fs5 = __toESM(require("fs"), 1);
-var path4 = __toESM(require("path"), 1);
-function detectPackageManager(cwd) {
-  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) {
-  const args = ["publish"];
-  let file;
-  if (pm === "pnpm") {
-    file = "pnpm";
-    args.push("--filter", packageName, "--access", options.access, "--tag", options.tag);
-    if (options.noGitChecks) args.push("--no-git-checks");
-  } else {
-    file = "npm";
-    args.push("--access", options.access, "--tag", options.tag);
-  }
-  if (options.provenance) {
-    args.push("--provenance");
-  }
-  return { file, args };
-}
-function buildViewCommand(pm, packageName, version) {
-  const file = pm === "pnpm" ? "pnpm" : "npm";
-  return { file, args: ["view", `${packageName}@${version}`, "version", "--json"] };
-}
-
-// src/stages/npm-publish.ts
-async function runNpmPublishStage(ctx) {
-  const { input, config, cliOptions, cwd } = ctx;
-  const dryRun = cliOptions.dryRun;
-  if (!config.npm.enabled) {
-    (0, import_core8.info)("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";
-  const npmIsolation = createNpmSubprocessIsolation({
-    authMethod,
-    registryUrl: config.npm.registry
-  });
-  try {
-    for (const update of input.updates) {
-      const result = {
-        packageName: update.packageName,
-        version: update.newVersion,
-        registry: "npm",
-        success: false,
-        skipped: false
-      };
-      const pkgJsonPath = path5.resolve(cwd, update.filePath);
-      try {
-        const pkgContent = fs6.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);
-          (0, import_core8.debug)(`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 { file: viewFile, args: viewArgs } = buildViewCommand(
-        ctx.packageManager,
-        update.packageName,
-        update.newVersion
-      );
-      const viewResult = await execCommandSafe(viewFile, viewArgs, {
-        cwd,
-        dryRun: false,
-        // Always check, even in dry-run
-        env: npmIsolation.env
-      });
-      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);
-        (0, import_core8.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 { file: pubFile, args: pubArgs } = buildPublishCommand(ctx.packageManager, update.packageName, pkgDir, {
-        access: config.npm.access,
-        tag: distTag,
-        provenance: useProvenance,
-        noGitChecks: true
-      });
-      try {
-        await execCommand(pubFile, pubArgs, {
-          cwd,
-          dryRun,
-          label: `npm publish ${update.packageName}@${update.newVersion}`,
-          env: npmIsolation.env
-        });
-        result.success = true;
-        if (!dryRun) {
-          (0, import_core8.success)(`Published ${update.packageName}@${update.newVersion} to npm`);
-        }
-      } catch (error) {
-        result.reason = error instanceof Error ? error.message : String(error);
-        (0, import_core8.warn)(`Failed to publish ${update.packageName}: ${result.reason}`);
-      }
-      ctx.output.npm.push(result);
-    }
-  } finally {
-    npmIsolation.cleanup();
-  }
-}
-
-// src/stages/prepare.ts
-var fs7 = __toESM(require("fs"), 1);
-var path6 = __toESM(require("path"), 1);
-var import_core9 = require("@releasekit/core");
-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));
-      for (const file of config.npm.copyFiles) {
-        const src = path6.resolve(cwd, file);
-        const dest = path6.join(pkgDir, file);
-        if (!fs7.existsSync(src)) {
-          (0, import_core9.debug)(`Source file not found, skipping copy: ${src}`);
-          continue;
-        }
-        if (path6.resolve(path6.dirname(src)) === path6.resolve(pkgDir)) {
-          (0, import_core9.debug)(`Skipping copy of ${file} - same directory as source`);
-          continue;
-        }
-        if (cliOptions.dryRun) {
-          (0, import_core9.info)(`[DRY RUN] Would copy ${src} \u2192 ${dest}`);
-          continue;
-        }
-        try {
-          fs7.copyFileSync(src, dest);
-          (0, import_core9.debug)(`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 = path6.dirname(path6.resolve(cwd, update.filePath));
-      const cargoPath = path6.join(pkgDir, "Cargo.toml");
-      if (!fs7.existsSync(cargoPath)) {
-        continue;
-      }
-      if (cliOptions.dryRun) {
-        (0, import_core9.info)(`[DRY RUN] Would update ${cargoPath} to version ${update.newVersion}`);
-        continue;
-      }
-      updateCargoVersion(cargoPath, update.newVersion);
-      (0, import_core9.debug)(`Updated ${cargoPath} to version ${update.newVersion}`);
-    }
-  }
-}
-
-// src/stages/verify.ts
-var import_core11 = require("@releasekit/core");
-
-// src/utils/retry.ts
-var import_core10 = require("@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) {
-        (0, import_core10.debug)(`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) {
-        (0, import_core11.info)(`[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 { file: viewFile, args: viewArgs } = buildViewCommand(ctx.packageManager, pkg.packageName, pkg.version);
-          const viewResult = await execCommandSafe(viewFile, viewArgs, {
-            cwd,
-            dryRun: false
-          });
-          if (viewResult.exitCode !== 0 || !viewResult.stdout.trim()) {
-            throw new Error(`${pkg.packageName}@${pkg.version} not yet available on npm`);
-          }
-          (0, import_core11.debug)(`Verified ${pkg.packageName}@${pkg.version} on npm`);
-        }, config.verify.npm);
-        result.verified = true;
-        (0, import_core11.success)(`Verified ${pkg.packageName}@${pkg.version} on npm`);
-      } catch {
-        (0, import_core11.warn)(`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) {
-        (0, import_core11.info)(`[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`);
-          }
-          (0, import_core11.debug)(`Verified ${crate.packageName}@${crate.version} on crates.io`);
-        }, config.verify.cargo);
-        result.verified = true;
-        (0, import_core11.success)(`Verified ${crate.packageName}@${crate.version} on crates.io`);
-      } catch {
-        (0, import_core11.warn)(`Failed to verify ${crate.packageName}@${crate.version} on crates.io after ${result.attempts} attempts`);
-      }
-      ctx.output.verification.push(result);
-    }
-  }
-}
-
-// src/pipeline/index.ts
-function inferStageName(error) {
-  if (error instanceof BasePublishError) {
-    const codeToStage = {
-      FILE_COPY_ERROR: "prepare",
-      CARGO_TOML_ERROR: "prepare",
-      GIT_COMMIT_ERROR: "git-commit",
-      GIT_TAG_ERROR: "git-commit",
-      NPM_PUBLISH_ERROR: "npm-publish",
-      NPM_AUTH_ERROR: "npm-publish",
-      CARGO_PUBLISH_ERROR: "cargo-publish",
-      CARGO_AUTH_ERROR: "cargo-publish",
-      VERIFICATION_FAILED: "verify",
-      GIT_PUSH_ERROR: "git-push",
-      GITHUB_RELEASE_ERROR: "github-release"
-    };
-    return codeToStage[error.code] ?? "unknown";
-  }
-  return "unknown";
-}
-async function runPipeline(input, config, options) {
-  const cwd = process.cwd();
-  const ctx = {
-    input,
-    config,
-    cliOptions: options,
-    packageManager: detectPackageManager(cwd),
-    cwd,
-    output: {
-      dryRun: options.dryRun,
-      git: { committed: false, tags: [], pushed: false },
-      npm: [],
-      cargo: [],
-      verification: [],
-      githubReleases: []
-    }
-  };
-  try {
-    await runPrepareStage(ctx);
-    if (options.skipGitCommit && !options.skipGit) {
-      ctx.output.git.committed = !!input.commitMessage;
-      ctx.output.git.tags = [...input.tags];
-    } else 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);
-    }
-  } catch (error) {
-    const stageName = inferStageName(error);
-    const message = error instanceof Error ? error.message : String(error);
-    throw new PipelineError(message, stageName, ctx.output, error instanceof Error ? error : void 0);
-  }
-  return ctx.output;
-}
-
-// src/stages/input.ts
-var fs8 = __toESM(require("fs"), 1);
-var import_core12 = require("@releasekit/core");
-var import_zod = require("zod");
-var VersionChangelogEntrySchema = import_zod.z.object({
-  type: import_zod.z.string(),
-  description: import_zod.z.string(),
-  issueIds: import_zod.z.array(import_zod.z.string()).optional(),
-  scope: import_zod.z.string().optional(),
-  originalType: import_zod.z.string().optional()
-});
-var VersionPackageChangelogSchema = import_zod.z.object({
-  packageName: import_zod.z.string(),
-  version: import_zod.z.string(),
-  previousVersion: import_zod.z.string().nullable(),
-  revisionRange: import_zod.z.string(),
-  repoUrl: import_zod.z.string().nullable(),
-  entries: import_zod.z.array(VersionChangelogEntrySchema)
-});
-var VersionPackageUpdateSchema = import_zod.z.object({
-  packageName: import_zod.z.string(),
-  newVersion: import_zod.z.string(),
-  filePath: import_zod.z.string()
-});
-var VersionOutputSchema = import_zod.z.object({
-  dryRun: import_zod.z.boolean(),
-  updates: import_zod.z.array(VersionPackageUpdateSchema),
-  changelogs: import_zod.z.array(VersionPackageChangelogSchema),
-  commitMessage: import_zod.z.string().optional(),
-  tags: import_zod.z.array(import_zod.z.string())
-});
-async function parseInput(inputPath) {
-  let raw;
-  if (inputPath) {
-    try {
-      raw = fs8.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}`);
-  }
-  if (result.data.updates.length === 0) {
-    (0, import_core12.info)("No package updates in version output \u2014 pipeline will be a no-op");
-  }
-  return result.data;
-}
-async function readStdin() {
-  const chunks = [];
-  for await (const chunk of process.stdin) {
-    chunks.push(chunk);
-  }
-  return chunks.join("");
-}
-
-// src/cli.ts
-var program = new import_commander.Command();
-program.name("releasekit-publish").description("Publish packages to registries with git tagging and GitHub releases").version("0.1.0").option("--input <path>", "Path to version output JSON (default: stdin)").option("--config <path>", "Path to releasekit config").option("--registry <type>", "Registry to publish to (npm, cargo, all)", "all").option("--npm-auth <method>", "NPM auth method (oidc, token, auto)", "auto").option("--dry-run", "Simulate all operations", false).option("--skip-git", "Skip git commit/tag/push", false).option("--skip-publish", "Skip registry publishing", false).option("--skip-github-release", "Skip GitHub Release creation", false).option("--skip-verification", "Skip post-publish verification", false).option("--json", "Output results as JSON", false).option("--verbose", "Verbose logging", false).action(async (options) => {
-  if (options.verbose) (0, import_core13.setLogLevel)("debug");
-  if (options.json) (0, import_core13.setJsonMode)(true);
-  try {
-    const config = loadConfig({ configPath: options.config });
-    const input = await parseInput(options.input);
-    if (options.npmAuth !== "auto") {
-      config.npm.auth = options.npmAuth;
-    }
-    const cliOptions = {
-      input: options.input,
-      config: options.config,
-      registry: options.registry,
-      npmAuth: options.npmAuth,
-      dryRun: options.dryRun,
-      skipGit: options.skipGit,
-      skipPublish: options.skipPublish,
-      skipGithubRelease: options.skipGithubRelease,
-      skipVerification: options.skipVerification,
-      json: options.json,
-      verbose: options.verbose
-    };
-    const output = await runPipeline(input, config, cliOptions);
-    if (options.json) {
-      console.log(JSON.stringify(output, null, 2));
-    }
-  } catch (err) {
-    if (err instanceof PipelineError && options.json) {
-      console.log(
-        JSON.stringify(
-          {
-            error: err.message,
-            failedStage: err.failedStage,
-            partialOutput: err.partialOutput
-          },
-          null,
-          2
-        )
-      );
-      process.exit(import_core13.EXIT_CODES.PUBLISH_ERROR);
-    }
-    if (BasePublishError.isPublishError(err)) {
-      err.logError();
-      process.exit(import_core13.EXIT_CODES.PUBLISH_ERROR);
-    }
-    console.error(err instanceof Error ? err.message : String(err));
-    process.exit(import_core13.EXIT_CODES.GENERAL_ERROR);
-  }
-});
-program.parse();