@releasekit/publish 0.3.0-next.3 → 0.3.0

package/dist/chunk-GOBII36Q.js

@@ -1,1324 +0,0 @@
-// src/config.ts
-import { loadPublishConfig } from "@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,
-      perPackage: true,
-      prerelease: "auto",
-      releaseNotes: "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,
-      perPackage: config.githubRelease?.perPackage ?? defaults.githubRelease.perPackage,
-      prerelease: config.githubRelease?.prerelease ?? defaults.githubRelease.prerelease,
-      releaseNotes: config.githubRelease?.releaseNotes ?? defaults.githubRelease.releaseNotes
-    },
-    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 = loadPublishConfig(options);
-  return toPublishConfig(baseConfig);
-}
-function getDefaultConfig2() {
-  return toPublishConfig(void 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 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;
-  }
-};
-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";
-  PublishErrorCode2["PIPELINE_STAGE_ERROR"] = "PIPELINE_STAGE_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",
-    ["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/utils/exec.ts
-import { execFile } from "child_process";
-import { debug, info } from "@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) {
-    info(`[DRY RUN] Would execute: ${displayCommand}`);
-    return { stdout: "", stderr: "", exitCode: 0 };
-  }
-  debug(`Executing: ${displayCommand}`);
-  return new Promise((resolve5, reject) => {
-    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
-import * as fs from "fs";
-import { parseCargoToml } from "@releasekit/config";
-import * as TOML 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));
-    }
-  } 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/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/utils/package-manager.ts
-import * as fs2 from "fs";
-import * as path 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";
-  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/cargo-publish.ts
-import * as fs3 from "fs";
-import * as path2 from "path";
-import { debug as debug2, success, warn } 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 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) {
-        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 (!fs3.existsSync(cargoPath)) {
-      continue;
-    }
-    try {
-      const cargo = 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 = 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();
-    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
-import * as path3 from "path";
-import { info as info2, success as success2 } from "@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) {
-    info2("No commit message provided, skipping git commit");
-    return;
-  }
-  const filePaths = input.updates.map((u) => path3.resolve(cwd, u.filePath));
-  if (ctx.additionalFiles) {
-    filePaths.push(...ctx.additionalFiles.map((f) => path3.resolve(cwd, f)));
-  }
-  if (filePaths.length === 0) {
-    info2("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) {
-      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}`;
-      await execCommand("git", ["tag", "-a", tag, "-m", tagMessage], {
-        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 info3, success as success3 } from "@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) {
-    info3("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)");
-    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) {
-      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 fs4 from "fs";
-import { debug as debug3, info as info4, success as success4, warn as warn2 } from "@releasekit/core";
-function resolveNotes(notesSetting, tag, changelogs, pipelineNotes) {
-  if (notesSetting === "none") {
-    return { useGithubNotes: false };
-  }
-  if (notesSetting === "github") {
-    return { useGithubNotes: true };
-  }
-  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`);
-    return { useGithubNotes: true };
-  }
-  if (pipelineNotes) {
-    const body = findNotesForTag(tag, pipelineNotes);
-    if (body) return { body, useGithubNotes: false };
-  }
-  const packageBody = formatChangelogForTag(tag, changelogs);
-  if (packageBody) {
-    return { body: packageBody, useGithubNotes: false };
-  }
-  return { useGithubNotes: true };
-}
-function isVersionOnlyTag(tag) {
-  return /^v?\d+\.\d+\.\d+/.test(tag);
-}
-function findNotesForTag(tag, notes) {
-  for (const [packageName, body] of Object.entries(notes)) {
-    if (tag.startsWith(`${packageName}@`) && body.trim()) {
-      return body;
-    }
-  }
-  const entries = Object.values(notes).filter((b) => b.trim());
-  if (entries.length === 1 && isVersionOnlyTag(tag)) return entries[0];
-  return void 0;
-}
-function readFileIfExists(filePath) {
-  try {
-    const content = fs4.readFileSync(filePath, "utf-8").trim();
-    return content || void 0;
-  } catch {
-    return void 0;
-  }
-}
-function formatChangelogForTag(tag, changelogs) {
-  if (changelogs.length === 0) return void 0;
-  const changelog = changelogs.find((c) => tag.startsWith(`${c.packageName}@`));
-  const target = changelog ?? (changelogs.length === 1 && isVersionOnlyTag(tag) ? changelogs[0] : void 0);
-  if (!target || target.entries.length === 0) return void 0;
-  const lines = [];
-  for (const entry of target.entries) {
-    const scope = entry.scope ? `**${entry.scope}:** ` : "";
-    lines.push(`- ${scope}${entry.description}`);
-  }
-  return lines.join("\n");
-}
-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) {
-    info4("No tags available for GitHub release");
-    return;
-  }
-  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");
-    }
-    const { body, useGithubNotes } = resolveNotes(
-      config.githubRelease.releaseNotes,
-      tag,
-      ctx.input.changelogs,
-      ctx.releaseNotes
-    );
-    if (body) {
-      ghArgs.push("--notes", body);
-    } else if (useGithubNotes) {
-      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) {
-        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 fs6 from "fs";
-import * as path5 from "path";
-import { debug as debug5, info as info5, success as success5, warn as warn3 } from "@releasekit/core";
-
-// 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";
-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");
-  return {
-    npmrcPath,
-    cleanup: () => {
-      try {
-        fs5.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"));
-  debug4(`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/stages/npm-publish.ts
-async function runNpmPublishStage(ctx) {
-  const { input, config, cliOptions, cwd } = ctx;
-  const dryRun = cliOptions.dryRun;
-  if (!config.npm.enabled) {
-    info5("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);
-          debug5(`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);
-        warn3(`${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) {
-          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);
-    }
-  } finally {
-    npmIsolation.cleanup();
-  }
-}
-
-// src/stages/prepare.ts
-import * as fs7 from "fs";
-import * as path6 from "path";
-import { debug as debug6, info as info6 } from "@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)) {
-          debug6(`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`);
-          continue;
-        }
-        if (cliOptions.dryRun) {
-          info6(`[DRY RUN] Would copy ${src} \u2192 ${dest}`);
-          continue;
-        }
-        try {
-          fs7.copyFileSync(src, dest);
-          debug6(`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) {
-        info6(`[DRY RUN] Would update ${cargoPath} to version ${update.newVersion}`);
-        continue;
-      }
-      updateCargoVersion(cargoPath, update.newVersion);
-      debug6(`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;
-  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) {
-        debug7(`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) {
-        info7(`[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`);
-          }
-          debug8(`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) {
-        info7(`[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`);
-          }
-          debug8(`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
-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,
-    releaseNotes: options.releaseNotes,
-    additionalFiles: options.additionalFiles,
-    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
-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()
-});
-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 VersionPackageUpdateSchema = z.object({
-  packageName: z.string(),
-  newVersion: z.string(),
-  filePath: z.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())
-});
-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) {
-    info8("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("");
-}
-
-export {
-  loadConfig,
-  getDefaultConfig2 as getDefaultConfig,
-  BasePublishError,
-  PublishError,
-  PipelineError,
-  PublishErrorCode,
-  createPublishError,
-  detectNpmAuth,
-  hasCargoAuth,
-  parseCargoToml,
-  updateCargoVersion,
-  extractPathDeps,
-  isPrerelease,
-  getDistTag,
-  detectPackageManager,
-  runPipeline,
-  parseInput
-};