pubm 0.2.7 → 0.2.9

package/dist/index.cjs

@@ -4486,9 +4486,129 @@ var Listr = (_a23 = class {
 // src/tasks/runner.ts
 var import_semver3 = __toESM(require("semver"), 1);
 var import_std_env = require("std-env");
-var import_tinyexec8 = require("tinyexec");
+var import_tinyexec9 = require("tinyexec");
+
+// src/ecosystem/rust.ts
+var import_promises2 = require("fs/promises");
+var import_node_path2 = __toESM(require("path"), 1);
+var import_smol_toml = require("smol-toml");
+var import_tinyexec = require("tinyexec");
+
+// src/ecosystem/ecosystem.ts
+var Ecosystem = class {
+  constructor(packagePath) {
+    this.packagePath = packagePath;
+  }
+};
+
+// src/ecosystem/rust.ts
+var RustEcosystem = class extends Ecosystem {
+  static async detect(packagePath) {
+    try {
+      return (await (0, import_promises2.stat)(import_node_path2.default.join(packagePath, "Cargo.toml"))).isFile();
+    } catch {
+      return false;
+    }
+  }
+  async readCargoToml() {
+    const raw = await (0, import_promises2.readFile)(
+      import_node_path2.default.join(this.packagePath, "Cargo.toml"),
+      "utf-8"
+    );
+    return (0, import_smol_toml.parse)(raw);
+  }
+  async packageName() {
+    const cargo = await this.readCargoToml();
+    const pkg = cargo.package;
+    return pkg.name;
+  }
+  async readVersion() {
+    const cargo = await this.readCargoToml();
+    const pkg = cargo.package;
+    return pkg.version;
+  }
+  async writeVersion(newVersion) {
+    const filePath = import_node_path2.default.join(this.packagePath, "Cargo.toml");
+    const raw = await (0, import_promises2.readFile)(filePath, "utf-8");
+    const cargo = (0, import_smol_toml.parse)(raw);
+    const pkg = cargo.package;
+    pkg.version = newVersion;
+    await (0, import_promises2.writeFile)(filePath, (0, import_smol_toml.stringify)(cargo));
+  }
+  /**
+   * Update the `version` field of dependencies that match sibling crate names.
+   * This ensures `cargo publish` works when crates depend on each other via path.
+   */
+  async updateSiblingDependencyVersions(siblingVersions) {
+    const filePath = import_node_path2.default.join(this.packagePath, "Cargo.toml");
+    const raw = await (0, import_promises2.readFile)(filePath, "utf-8");
+    const cargo = (0, import_smol_toml.parse)(raw);
+    let modified = false;
+    for (const section of ["dependencies", "build-dependencies"]) {
+      const sectionData = cargo[section];
+      if (!sectionData) continue;
+      for (const [depName, depValue] of Object.entries(sectionData)) {
+        if (typeof depValue === "object" && depValue !== null && "path" in depValue && siblingVersions.has(depName)) {
+          const dep = depValue;
+          dep.version = siblingVersions.get(depName);
+          modified = true;
+        }
+      }
+    }
+    if (modified) {
+      await (0, import_promises2.writeFile)(filePath, (0, import_smol_toml.stringify)(cargo));
+    }
+    return modified;
+  }
+  async syncLockfile() {
+    const lockfilePath = await this.findLockfile();
+    if (!lockfilePath) return void 0;
+    const name = await this.packageName();
+    await (0, import_tinyexec.exec)("cargo", ["update", "--package", name], {
+      nodeOptions: { cwd: import_node_path2.default.dirname(lockfilePath) }
+    });
+    return lockfilePath;
+  }
+  async findLockfile() {
+    let dir = this.packagePath;
+    const { root } = import_node_path2.default.parse(dir);
+    while (dir !== root) {
+      const candidate = import_node_path2.default.join(dir, "Cargo.lock");
+      try {
+        if ((await (0, import_promises2.stat)(candidate)).isFile()) return candidate;
+      } catch {
+      }
+      dir = import_node_path2.default.dirname(dir);
+    }
+    return void 0;
+  }
+  async dependencies() {
+    const cargo = await this.readCargoToml();
+    const deps = [];
+    for (const section of ["dependencies", "build-dependencies"]) {
+      const sectionData = cargo[section];
+      if (sectionData) {
+        deps.push(...Object.keys(sectionData));
+      }
+    }
+    return deps;
+  }
+  manifestFiles() {
+    return ["Cargo.toml"];
+  }
+  defaultTestCommand() {
+    return "cargo test";
+  }
+  defaultBuildCommand() {
+    return "cargo build --release";
+  }
+  supportedRegistries() {
+    return ["crates"];
+  }
+};
 
 // src/error.ts
+var import_tinyexec2 = require("tinyexec");
 var AbstractError = class extends Error {
   constructor(message, { cause } = {}) {
     super(message, { cause });
@@ -4499,20 +4619,49 @@ var AbstractError = class extends Error {
 function replaceCode(code) {
   return code.replace(/`([^`].+)`/g, color.bold(color.underline("$1")));
 }
+function formatStderr(stderr) {
+  return stderr.split("\n").map((line) => `  ${color.dim("\u2502")} ${line}`).join("\n");
+}
+function isNoisyCause(cause) {
+  if (cause instanceof import_tinyexec2.NonZeroExitError) return true;
+  if (cause instanceof Error && /Process exited with non-zero status/i.test(cause.message))
+    return true;
+  return false;
+}
 function formatError(error) {
   if (!(error instanceof Error)) return `${error}`;
-  const message = typeof error.message === "string" ? replaceCode(error.message) : (
+  const rawMessage = typeof error.message === "string" ? error.message : (
     /* v8 ignore next */
-    formatError(error)
+    String(error)
   );
-  let stringifyError = `${color.bgRed(` ${error.name} `)}${color.reset("")} ${message}
+  const newlineIndex = rawMessage.indexOf("\n");
+  let summary;
+  let detail;
+  if (newlineIndex !== -1) {
+    summary = rawMessage.slice(0, newlineIndex);
+    detail = rawMessage.slice(newlineIndex + 1);
+  } else {
+    summary = rawMessage;
+  }
+  let result = `${color.bgRed(` ${error.name} `)}${color.reset("")} ${replaceCode(summary)}
+`;
+  if (detail) {
+    result += `
+${formatStderr(detail)}
 `;
-  stringifyError += error.stack?.split("\n").slice(1).join("\n").replace(/at/g, color.dim("at")).replace(/\(([^(].+)\)/g, `(${color.blue("$1")})`);
-  if (error.cause) {
-    stringifyError += "\n\nCaused: ";
-    stringifyError += formatError(error.cause);
   }
-  return stringifyError;
+  if (process.env.DEBUG === "pubm" && error.stack) {
+    result += error.stack.split("\n").slice(1).join("\n").replace(/at/g, color.dim("at")).replace(/\(([^(].+)\)/g, `(${color.blue("$1")})`);
+  }
+  if (error.cause && !isNoisyCause(error.cause)) {
+    const causeMsg = error.cause instanceof Error ? error.cause.message : String(error.cause);
+    if (causeMsg !== summary) {
+      result += `
+${color.dim("Caused by:")} `;
+      result += formatError(error.cause);
+    }
+  }
+  return result;
 }
 function consoleError(error) {
   let errorText = "\n";
@@ -4529,7 +4678,7 @@ function consoleError(error) {
 
 // src/git.ts
 var import_semver = __toESM(require("semver"), 1);
-var import_tinyexec = require("tinyexec");
+var import_tinyexec3 = require("tinyexec");
 var GitError = class extends AbstractError {
   constructor() {
     super(...arguments);
@@ -4538,7 +4687,7 @@ var GitError = class extends AbstractError {
 };
 var Git = class {
   async git(args) {
-    const { stdout } = await (0, import_tinyexec.exec)("git", args, { throwOnError: true });
+    const { stdout } = await (0, import_tinyexec3.exec)("git", args, { throwOnError: true });
     return stdout;
   }
   async userName() {
@@ -4792,7 +4941,7 @@ var Git = class {
   async push(options) {
     const args = ["push", options].filter((v) => v);
     try {
-      const { stderr } = await (0, import_tinyexec.exec)("git", args, { throwOnError: true });
+      const { stderr } = await (0, import_tinyexec3.exec)("git", args, { throwOnError: true });
       if (`${stderr}`.includes("GH006")) {
         return false;
       }
@@ -4814,125 +4963,6 @@ function link2(text, url) {
   return `\x1B]8;;${url}\x07${text}\x1B]8;;\x07`;
 }
 
-// src/ecosystem/rust.ts
-var import_promises2 = require("fs/promises");
-var import_node_path2 = __toESM(require("path"), 1);
-var import_smol_toml = require("smol-toml");
-var import_tinyexec2 = require("tinyexec");
-
-// src/ecosystem/ecosystem.ts
-var Ecosystem = class {
-  constructor(packagePath) {
-    this.packagePath = packagePath;
-  }
-};
-
-// src/ecosystem/rust.ts
-var RustEcosystem = class extends Ecosystem {
-  static async detect(packagePath) {
-    try {
-      return (await (0, import_promises2.stat)(import_node_path2.default.join(packagePath, "Cargo.toml"))).isFile();
-    } catch {
-      return false;
-    }
-  }
-  async readCargoToml() {
-    const raw = await (0, import_promises2.readFile)(
-      import_node_path2.default.join(this.packagePath, "Cargo.toml"),
-      "utf-8"
-    );
-    return (0, import_smol_toml.parse)(raw);
-  }
-  async packageName() {
-    const cargo = await this.readCargoToml();
-    const pkg = cargo.package;
-    return pkg.name;
-  }
-  async readVersion() {
-    const cargo = await this.readCargoToml();
-    const pkg = cargo.package;
-    return pkg.version;
-  }
-  async writeVersion(newVersion) {
-    const filePath = import_node_path2.default.join(this.packagePath, "Cargo.toml");
-    const raw = await (0, import_promises2.readFile)(filePath, "utf-8");
-    const cargo = (0, import_smol_toml.parse)(raw);
-    const pkg = cargo.package;
-    pkg.version = newVersion;
-    await (0, import_promises2.writeFile)(filePath, (0, import_smol_toml.stringify)(cargo));
-  }
-  /**
-   * Update the `version` field of dependencies that match sibling crate names.
-   * This ensures `cargo publish` works when crates depend on each other via path.
-   */
-  async updateSiblingDependencyVersions(siblingVersions) {
-    const filePath = import_node_path2.default.join(this.packagePath, "Cargo.toml");
-    const raw = await (0, import_promises2.readFile)(filePath, "utf-8");
-    const cargo = (0, import_smol_toml.parse)(raw);
-    let modified = false;
-    for (const section of ["dependencies", "build-dependencies"]) {
-      const sectionData = cargo[section];
-      if (!sectionData) continue;
-      for (const [depName, depValue] of Object.entries(sectionData)) {
-        if (typeof depValue === "object" && depValue !== null && "path" in depValue && siblingVersions.has(depName)) {
-          const dep = depValue;
-          dep.version = siblingVersions.get(depName);
-          modified = true;
-        }
-      }
-    }
-    if (modified) {
-      await (0, import_promises2.writeFile)(filePath, (0, import_smol_toml.stringify)(cargo));
-    }
-    return modified;
-  }
-  async syncLockfile() {
-    const lockfilePath = await this.findLockfile();
-    if (!lockfilePath) return void 0;
-    const name = await this.packageName();
-    await (0, import_tinyexec2.exec)("cargo", ["update", "--package", name], {
-      nodeOptions: { cwd: import_node_path2.default.dirname(lockfilePath) }
-    });
-    return lockfilePath;
-  }
-  async findLockfile() {
-    let dir = this.packagePath;
-    const { root } = import_node_path2.default.parse(dir);
-    while (dir !== root) {
-      const candidate = import_node_path2.default.join(dir, "Cargo.lock");
-      try {
-        if ((await (0, import_promises2.stat)(candidate)).isFile()) return candidate;
-      } catch {
-      }
-      dir = import_node_path2.default.dirname(dir);
-    }
-    return void 0;
-  }
-  async dependencies() {
-    const cargo = await this.readCargoToml();
-    const deps = [];
-    for (const section of ["dependencies", "build-dependencies"]) {
-      const sectionData = cargo[section];
-      if (sectionData) {
-        deps.push(...Object.keys(sectionData));
-      }
-    }
-    return deps;
-  }
-  manifestFiles() {
-    return ["Cargo.toml"];
-  }
-  defaultTestCommand() {
-    return "cargo test";
-  }
-  defaultBuildCommand() {
-    return "cargo build --release";
-  }
-  supportedRegistries() {
-    return ["crates"];
-  }
-};
-
 // src/utils/crate-graph.ts
 async function sortCratesByDependencyOrder(cratePaths) {
   if (cratePaths.length <= 1) return cratePaths;
@@ -4985,12 +5015,19 @@ var rollbacks = [];
 function addRollback(rollback2, context) {
   rollbacks.push({ fn: rollback2, ctx: context });
 }
+function rollbackLog(message) {
+  console.log(`  ${color.yellow("\u21A9")} ${message}`);
+}
+function rollbackError(message) {
+  console.error(`  ${color.red("\u2717")} ${message}`);
+}
 var called = false;
 async function rollback() {
   if (called) return void 0;
   called = true;
   if (rollbacks.length <= 0) return void 0;
-  console.log("Rollback...");
+  console.log(`
+${color.yellow("\u27F2")} ${color.yellow("Rolling back...")}`);
   const results = await Promise.allSettled(
     rollbacks.map(({ fn, ctx }) => fn(ctx))
   );
@@ -4999,15 +5036,15 @@ async function rollback() {
   );
   if (failures.length > 0) {
     for (const failure of failures) {
-      console.error(
-        `Rollback operation failed: ${failure.reason instanceof Error ? failure.reason.message : failure.reason}`
+      rollbackError(
+        failure.reason instanceof Error ? failure.reason.message : failure.reason
       );
     }
     console.log(
-      "Rollback completed with errors. Some operations may require manual recovery."
+      `${color.red("\u2717")} ${color.red("Rollback completed with errors.")} Some operations may require manual recovery.`
     );
   } else {
-    console.log("Rollback completed");
+    console.log(`${color.green("\u2713")} Rollback completed`);
   }
 }
 
@@ -5415,7 +5452,7 @@ function injectTokensToEnv(tokens) {
 
 // src/registry/crates.ts
 var import_node_path5 = __toESM(require("path"), 1);
-var import_tinyexec3 = require("tinyexec");
+var import_tinyexec4 = require("tinyexec");
 
 // src/registry/registry.ts
 var Registry = class {
@@ -5435,6 +5472,14 @@ var CratesError = class extends AbstractError {
   }
 };
 var USER_AGENT = "pubm (https://github.com/syi0808/pubm)";
+function cleanCargoStderr(stderr) {
+  return stderr.split("\n").filter((line) => {
+    const trimmed = line.trim();
+    if (trimmed === "Updating crates.io index") return false;
+    if (trimmed === "") return false;
+    return true;
+  }).join("\n");
+}
 var CratesRegistry = class extends Registry {
   constructor() {
     super(...arguments);
@@ -5455,7 +5500,7 @@ var CratesRegistry = class extends Registry {
   }
   async isInstalled() {
     try {
-      await (0, import_tinyexec3.exec)("cargo", ["--version"]);
+      await (0, import_tinyexec4.exec)("cargo", ["--version"]);
       return true;
     } catch {
       return false;
@@ -5496,29 +5541,43 @@ var CratesRegistry = class extends Registry {
       if (manifestDir) {
         args.push("--manifest-path", import_node_path5.default.join(manifestDir, "Cargo.toml"));
       }
-      await (0, import_tinyexec3.exec)("cargo", args, { throwOnError: true });
+      await (0, import_tinyexec4.exec)("cargo", args, { throwOnError: true });
       return true;
     } catch (error) {
-      const stderr = error instanceof import_tinyexec3.NonZeroExitError ? error.output?.stderr : void 0;
+      const stderr = error instanceof import_tinyexec4.NonZeroExitError ? error.output?.stderr : void 0;
       const message = stderr ? `Failed to run \`cargo publish\`:
-${stderr}` : "Failed to run `cargo publish`";
+${cleanCargoStderr(stderr)}` : "Failed to run `cargo publish`";
       throw new CratesError(message, { cause: error });
     }
   }
   async dryRunPublish(manifestDir) {
     try {
-      const args = ["publish", "--dry-run", "--no-verify"];
+      const args = ["publish", "--dry-run"];
       if (manifestDir) {
         args.push("--manifest-path", import_node_path5.default.join(manifestDir, "Cargo.toml"));
       }
-      await (0, import_tinyexec3.exec)("cargo", args, { throwOnError: true });
+      await (0, import_tinyexec4.exec)("cargo", args, { throwOnError: true });
     } catch (error) {
-      const stderr = error instanceof import_tinyexec3.NonZeroExitError ? error.output?.stderr : void 0;
+      const stderr = error instanceof import_tinyexec4.NonZeroExitError ? error.output?.stderr : void 0;
       const message = stderr ? `Failed to run \`cargo publish --dry-run\`:
-${stderr}` : "Failed to run `cargo publish --dry-run`";
+${cleanCargoStderr(stderr)}` : "Failed to run `cargo publish --dry-run`";
       throw new CratesError(message, { cause: error });
     }
   }
+  async isVersionPublished(version2) {
+    try {
+      const response = await fetch(
+        `${this.registry}/api/v1/crates/${this.packageName}/${version2}`,
+        { headers: this.headers }
+      );
+      return response.ok;
+    } catch (error) {
+      throw new CratesError(
+        `Failed to check version ${version2} for '${this.packageName}' on crates.io`,
+        { cause: error }
+      );
+    }
+  }
   async isPublished() {
     try {
       const response = await fetch(
@@ -5595,10 +5654,24 @@ function createCratesPublishTask(packagePath) {
   const label = packagePath ? ` (${packagePath})` : "";
   return {
     title: `Publishing to crates.io${label}`,
-    task: async () => {
+    task: async (ctx, task) => {
       const packageName = await getCrateName(packagePath);
       const registry = new CratesRegistry(packageName);
-      await registry.publish(packagePath);
+      if (await registry.isVersionPublished(ctx.version)) {
+        task.title = `[SKIPPED] crates.io${label}: v${ctx.version} already published`;
+        task.output = `\u26A0 ${packageName}@${ctx.version} is already published on crates.io`;
+        return task.skip();
+      }
+      try {
+        await registry.publish(packagePath);
+      } catch (error) {
+        if (error instanceof Error && error.message.includes("is already uploaded")) {
+          task.title = `[SKIPPED] crates.io${label}: v${ctx.version} already published`;
+          task.output = `\u26A0 ${packageName}@${ctx.version} is already published on crates.io`;
+          return task.skip();
+        }
+        throw error;
+      }
     }
   };
 }
@@ -5609,7 +5682,7 @@ var cratesPublishTasks = createCratesPublishTask();
 var import_prompt_adapter_enquirer = require("@listr2/prompt-adapter-enquirer");
 
 // src/registry/jsr.ts
-var import_tinyexec4 = require("tinyexec");
+var import_tinyexec5 = require("tinyexec");
 
 // src/utils/package-name.ts
 var import_node_module = require("module");
@@ -5677,7 +5750,7 @@ var JsrRegisry = class extends Registry {
     this.client = new JsrClient(getApiEndpoint(this.registry));
   }
   async jsr(args) {
-    const { stdout } = await (0, import_tinyexec4.exec)("jsr", args, { throwOnError: true });
+    const { stdout } = await (0, import_tinyexec5.exec)("jsr", args, { throwOnError: true });
     return stdout;
   }
   async isInstalled() {
@@ -5693,7 +5766,7 @@ var JsrRegisry = class extends Registry {
   }
   async ping() {
     try {
-      const { stdout } = await (0, import_tinyexec4.exec)(
+      const { stdout } = await (0, import_tinyexec5.exec)(
         "ping",
         [new URL(this.registry).hostname, "-c", "1"],
         { throwOnError: true }
@@ -5708,7 +5781,7 @@ var JsrRegisry = class extends Registry {
   }
   async publish() {
     try {
-      await (0, import_tinyexec4.exec)(
+      await (0, import_tinyexec5.exec)(
         "jsr",
         ["publish", "--allow-dirty", "--token", `${JsrClient.token}`],
         {
@@ -5718,7 +5791,7 @@ var JsrRegisry = class extends Registry {
       this.packageCreationUrls = void 0;
       return true;
     } catch (error) {
-      const stderr = error instanceof import_tinyexec4.NonZeroExitError ? error.output?.stderr : void 0;
+      const stderr = error instanceof import_tinyexec5.NonZeroExitError ? error.output?.stderr : void 0;
       if (stderr?.includes("don't exist")) {
         const urls = [...stderr.matchAll(/https:\/\/jsr\.io\/new\S+/g)].map(
           (m) => m[0]
@@ -5739,7 +5812,7 @@ ${stderr}` : ""}`,
   }
   async dryRunPublish() {
     try {
-      await (0, import_tinyexec4.exec)(
+      await (0, import_tinyexec5.exec)(
         "jsr",
         [
           "publish",
@@ -5770,6 +5843,20 @@ ${stderr}` : ""}`,
       );
     }
   }
+  async isVersionPublished(version2) {
+    try {
+      const [scope, name] = getScopeAndName(this.packageName);
+      const response = await fetch(
+        `${this.registry}/@${scope}/${name}/${version2}`
+      );
+      return response.status === 200;
+    } catch (error) {
+      throw new JsrError(
+        `Failed to fetch \`${this.registry}/${this.packageName}/${version2}\``,
+        { cause: error }
+      );
+    }
+  }
   async hasPermission() {
     return this.client.scopePermission(`${getScope(this.packageName)}`) !== null;
   }
@@ -5999,7 +6086,7 @@ async function jsrRegistry() {
 // src/registry/npm.ts
 var import_node_os = require("os");
 var import_node_path6 = require("path");
-var import_tinyexec5 = require("tinyexec");
+var import_tinyexec6 = require("tinyexec");
 var NpmError = class extends AbstractError {
   constructor() {
     super(...arguments);
@@ -6012,7 +6099,7 @@ var NpmRegistry = class extends Registry {
     __publicField(this, "registry", "https://registry.npmjs.org");
   }
   async npm(args) {
-    const { stdout } = await (0, import_tinyexec5.exec)("npm", args, { throwOnError: true });
+    const { stdout } = await (0, import_tinyexec6.exec)("npm", args, { throwOnError: true });
     return stdout;
   }
   async isInstalled() {
@@ -6044,6 +6131,19 @@ var NpmRegistry = class extends Registry {
       );
     }
   }
+  async isVersionPublished(version2) {
+    try {
+      const response = await fetch(
+        `${this.registry}/${this.packageName}/${version2}`
+      );
+      return response.status === 200;
+    } catch (error) {
+      throw new NpmError(
+        `Failed to fetch \`${this.registry}/${this.packageName}/${version2}\``,
+        { cause: error }
+      );
+    }
+  }
   async userName() {
     try {
       return (await this.npm(["whoami"])).trim();
@@ -6056,7 +6156,7 @@ var NpmRegistry = class extends Registry {
       await this.npm(["whoami"]);
       return true;
     } catch (error) {
-      if (error instanceof import_tinyexec5.NonZeroExitError) {
+      if (error instanceof import_tinyexec6.NonZeroExitError) {
         return false;
       }
       throw new NpmError("Failed to run `npm whoami`", { cause: error });
@@ -6123,7 +6223,7 @@ var NpmRegistry = class extends Registry {
   }
   async ping() {
     try {
-      await (0, import_tinyexec5.exec)("npm", ["ping"], { throwOnError: true });
+      await (0, import_tinyexec6.exec)("npm", ["ping"], { throwOnError: true });
       return true;
     } catch (error) {
       throw new NpmError("Failed to run `npm ping`", { cause: error });
@@ -6134,7 +6234,7 @@ var NpmRegistry = class extends Registry {
       await this.npm(["publish", "--provenance", "--access", "public"]);
       return true;
     } catch (error) {
-      if (error instanceof import_tinyexec5.NonZeroExitError && error.output?.stderr.includes("EOTP")) {
+      if (error instanceof import_tinyexec6.NonZeroExitError && error.output?.stderr.includes("EOTP")) {
         return false;
       }
       throw this.classifyPublishError(error);
@@ -6146,7 +6246,7 @@ var NpmRegistry = class extends Registry {
       await this.npm(args);
       return true;
     } catch (error) {
-      if (error instanceof import_tinyexec5.NonZeroExitError && error.output?.stderr.includes("EOTP")) {
+      if (error instanceof import_tinyexec6.NonZeroExitError && error.output?.stderr.includes("EOTP")) {
         return false;
       }
       throw this.classifyPublishError(error);
@@ -6154,7 +6254,7 @@ var NpmRegistry = class extends Registry {
   }
   async dryRunPublish() {
     try {
-      await (0, import_tinyexec5.exec)("npm", ["publish", "--dry-run"], {
+      await (0, import_tinyexec6.exec)("npm", ["publish", "--dry-run"], {
         throwOnError: true,
         nodeOptions: {
           env: {
@@ -6164,7 +6264,7 @@ var NpmRegistry = class extends Registry {
         }
       });
     } catch (error) {
-      const stderr = error instanceof import_tinyexec5.NonZeroExitError ? error.output?.stderr : void 0;
+      const stderr = error instanceof import_tinyexec6.NonZeroExitError ? error.output?.stderr : void 0;
       throw new NpmError(
         `Failed to run \`npm publish --dry-run\`${stderr ? `
 ${stderr}` : ""}`,
@@ -6191,7 +6291,7 @@ ${stderr}` : ""}`,
     };
   }
   classifyPublishError(error) {
-    if (error instanceof import_tinyexec5.NonZeroExitError) {
+    if (error instanceof import_tinyexec6.NonZeroExitError) {
       const stderr = error.output?.stderr ?? "";
       if (stderr.includes("EOTP")) {
         return new NpmError("OTP required for publishing", { cause: error });
@@ -6249,20 +6349,30 @@ async function withTokenRetry(registryKey, task, action) {
 }
 var npmDryRunPublishTask = {
   title: "Dry-run npm publish",
-  task: async (_, task) => {
+  task: async (ctx, task) => {
+    const npm = await npmRegistry();
+    if (await npm.isVersionPublished(ctx.version)) {
+      task.title = `[SKIPPED] Dry-run npm publish: v${ctx.version} already published`;
+      task.output = `\u26A0 ${npm.packageName}@${ctx.version} is already published on npm`;
+      return task.skip();
+    }
     task.output = "Running npm publish --dry-run...";
     await withTokenRetry("npm", task, async () => {
-      const npm = await npmRegistry();
       await npm.dryRunPublish();
     });
   }
 };
 var jsrDryRunPublishTask = {
   title: "Dry-run jsr publish",
-  task: async (_, task) => {
+  task: async (ctx, task) => {
+    const jsr = await jsrRegistry();
+    if (await jsr.isVersionPublished(ctx.version)) {
+      task.title = `[SKIPPED] Dry-run jsr publish: v${ctx.version} already published`;
+      task.output = `\u26A0 ${jsr.packageName}@${ctx.version} is already published on jsr`;
+      return task.skip();
+    }
     task.output = "Running jsr publish --dry-run...";
     await withTokenRetry("jsr", task, async () => {
-      const jsr = await jsrRegistry();
       await jsr.dryRunPublish();
     });
   }
@@ -6271,17 +6381,58 @@ async function getCrateName2(packagePath) {
   const eco = new RustEcosystem(packagePath ?? process.cwd());
   return await eco.packageName();
 }
-function createCratesDryRunPublishTask(packagePath) {
+var MISSING_CRATE_PATTERN = /no matching package named `([^`]+)` found/;
+async function findUnpublishedSiblingDeps(packagePath, siblingCrateNames) {
+  const eco = new RustEcosystem(packagePath ?? process.cwd());
+  const deps = await eco.dependencies();
+  const siblingDeps = deps.filter((d2) => siblingCrateNames.includes(d2));
+  const results = await Promise.all(
+    siblingDeps.map(async (name) => {
+      const registry = new CratesRegistry(name);
+      const published = await registry.isPublished();
+      return published ? null : name;
+    })
+  );
+  return results.filter((name) => name !== null);
+}
+function createCratesDryRunPublishTask(packagePath, siblingCrateNames) {
   const label = packagePath ? ` (${packagePath})` : "";
   return {
     title: `Dry-run crates.io publish${label}`,
-    task: async (_, task) => {
+    task: async (ctx, task) => {
+      const packageName = await getCrateName2(packagePath);
+      const registry = new CratesRegistry(packageName);
+      if (await registry.isVersionPublished(ctx.version)) {
+        task.title = `[SKIPPED] Dry-run crates.io publish${label}: v${ctx.version} already published`;
+        task.output = `\u26A0 ${packageName}@${ctx.version} is already published on crates.io`;
+        return task.skip();
+      }
+      if (siblingCrateNames?.length) {
+        const unpublished = await findUnpublishedSiblingDeps(
+          packagePath,
+          siblingCrateNames
+        );
+        if (unpublished.length > 0) {
+          task.title = `Dry-run crates.io publish${label} [skipped: sibling crate \`${unpublished.join("`, `")}\` not yet published]`;
+          return;
+        }
+      }
       task.output = "Running cargo publish --dry-run...";
-      await withTokenRetry("crates", task, async () => {
-        const packageName = await getCrateName2(packagePath);
-        const registry = new CratesRegistry(packageName);
-        await registry.dryRunPublish(packagePath);
-      });
+      try {
+        await withTokenRetry("crates", task, async () => {
+          const packageName2 = await getCrateName2(packagePath);
+          const registry2 = new CratesRegistry(packageName2);
+          await registry2.dryRunPublish(packagePath);
+        });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        const match = message.match(MISSING_CRATE_PATTERN);
+        if (match && siblingCrateNames?.includes(match[1])) {
+          task.title = `Dry-run crates.io publish${label} [skipped: sibling crate \`${match[1]}\` not yet published]`;
+          return;
+        }
+        throw error;
+      }
     }
   };
 }
@@ -6462,48 +6613,62 @@ var jsrPublishTasks = {
   title: "Running jsr publish",
   task: async (ctx, task) => {
     const jsr = await jsrRegistry();
+    if (await jsr.isVersionPublished(ctx.version)) {
+      task.title = `[SKIPPED] jsr: v${ctx.version} already published`;
+      task.output = `\u26A0 ${jsr.packageName}@${ctx.version} is already published on jsr`;
+      return task.skip();
+    }
     task.output = "Publishing on jsr...";
-    if (!JsrClient.token && !ctx.promptEnabled) {
-      const jsrTokenEnv = import_node_process6.default.env.JSR_TOKEN;
-      if (!jsrTokenEnv) {
-        throw new JsrAvailableError(
-          "JSR_TOKEN not found in the environment variables. Please set the token and try again."
-        );
+    try {
+      if (!JsrClient.token && !ctx.promptEnabled) {
+        const jsrTokenEnv = import_node_process6.default.env.JSR_TOKEN;
+        if (!jsrTokenEnv) {
+          throw new JsrAvailableError(
+            "JSR_TOKEN not found in the environment variables. Please set the token and try again."
+          );
+        }
+        JsrClient.token = jsrTokenEnv;
       }
-      JsrClient.token = jsrTokenEnv;
-    }
-    let result = await jsr.publish();
-    if (!result && jsr.packageCreationUrls) {
-      if (ctx.promptEnabled) {
-        task.title = "Running jsr publish (package creation needed)";
-        const urls = jsr.packageCreationUrls;
-        const maxAttempts = 3;
-        task.output = `Package doesn't exist on jsr. Create it at:
+      let result = await jsr.publish();
+      if (!result && jsr.packageCreationUrls) {
+        if (ctx.promptEnabled) {
+          task.title = "Running jsr publish (package creation needed)";
+          const urls = jsr.packageCreationUrls;
+          const maxAttempts = 3;
+          task.output = `Package doesn't exist on jsr. Create it at:
 ${urls.map((url) => `  ${color.cyan(url)}`).join("\n")}`;
-        open(urls[0]);
-        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-          await task.prompt(import_prompt_adapter_enquirer2.ListrEnquirerPromptAdapter).run({
-            type: "input",
-            message: `Press ${color.bold("enter")} after creating the package on jsr.io${attempt > 1 ? ` (attempt ${attempt}/${maxAttempts})` : ""}`
-          });
-          result = await jsr.publish();
-          if (result) break;
-          if (attempt < maxAttempts) {
-            task.output = "Package still doesn't exist. Please create it and try again.";
+          open(urls[0]);
+          for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            await task.prompt(import_prompt_adapter_enquirer2.ListrEnquirerPromptAdapter).run({
+              type: "input",
+              message: `Press ${color.bold("enter")} after creating the package on jsr.io${attempt > 1 ? ` (attempt ${attempt}/${maxAttempts})` : ""}`
+            });
+            result = await jsr.publish();
+            if (result) break;
+            if (attempt < maxAttempts) {
+              task.output = "Package still doesn't exist. Please create it and try again.";
+            }
           }
-        }
-        if (!result) {
+          if (!result) {
+            throw new JsrAvailableError(
+              "Package creation not completed after 3 attempts."
+            );
+          }
+          task.title = "Running jsr publish (package created)";
+        } else {
           throw new JsrAvailableError(
-            "Package creation not completed after 3 attempts."
+            `Package doesn't exist on jsr. Create it at:
+${jsr.packageCreationUrls.join("\n")}`
           );
         }
-        task.title = "Running jsr publish (package created)";
-      } else {
-        throw new JsrAvailableError(
-          `Package doesn't exist on jsr. Create it at:
-${jsr.packageCreationUrls.join("\n")}`
-        );
       }
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("already published")) {
+        task.title = `[SKIPPED] jsr: v${ctx.version} already published`;
+        task.output = `\u26A0 ${jsr.packageName}@${ctx.version} is already published on jsr`;
+        return task.skip();
+      }
+      throw error;
     }
   }
 };
@@ -6600,44 +6765,62 @@ var npmPublishTasks = {
   skip: (ctx) => !!ctx.preview,
   task: async (ctx, task) => {
     const npm = await npmRegistry();
+    if (await npm.isVersionPublished(ctx.version)) {
+      task.title = `[SKIPPED] npm: v${ctx.version} already published`;
+      task.output = `\u26A0 ${npm.packageName}@${ctx.version} is already published on npm`;
+      return task.skip();
+    }
     task.output = "Publishing on npm...";
-    if (ctx.promptEnabled) {
-      let result = await npm.publish();
-      if (!result) {
-        task.title = "Running npm publish (OTP code needed)";
-        const maxAttempts = 3;
-        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-          result = await npm.publish(
-            await task.prompt(import_prompt_adapter_enquirer3.ListrEnquirerPromptAdapter).run({
-              type: "password",
-              message: `npm OTP code${attempt > 1 ? ` (attempt ${attempt}/${maxAttempts})` : ""}`
-            })
-          );
-          if (result) break;
-          if (attempt < maxAttempts) {
-            task.output = "2FA failed. Please try again.";
+    try {
+      if (ctx.promptEnabled) {
+        let result = await npm.publish();
+        if (!result) {
+          task.title = "Running npm publish (OTP code needed)";
+          const maxAttempts = 3;
+          for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            result = await npm.publish(
+              await task.prompt(import_prompt_adapter_enquirer3.ListrEnquirerPromptAdapter).run({
+                type: "password",
+                message: `npm OTP code${attempt > 1 ? ` (attempt ${attempt}/${maxAttempts})` : ""}`
+              })
+            );
+            if (result) break;
+            if (attempt < maxAttempts) {
+              task.output = "2FA failed. Please try again.";
+            }
+          }
+          if (!result) {
+            throw new NpmAvailableError(
+              "OTP verification failed after 3 attempts."
+            );
           }
+          task.title = "Running npm publish (2FA passed)";
+        }
+      } else {
+        const npmTokenEnv = import_node_process7.default.env.NODE_AUTH_TOKEN;
+        if (!npmTokenEnv) {
+          throw new NpmAvailableError(
+            "NODE_AUTH_TOKEN not found in environment variables. Set it in your CI configuration:\n  GitHub Actions: Add NODE_AUTH_TOKEN as a repository secret\n  Other CI: Export NODE_AUTH_TOKEN with your npm access token"
+          );
         }
+        const result = await npm.publishProvenance();
         if (!result) {
           throw new NpmAvailableError(
-            "OTP verification failed after 3 attempts."
+            `In CI environment, publishing with 2FA is not allowed. Please disable 2FA when accessing with a token from https://www.npmjs.com/package/${npm.packageName}/access `
           );
         }
-        task.title = "Running npm publish (2FA passed)";
-      }
-    } else {
-      const npmTokenEnv = import_node_process7.default.env.NODE_AUTH_TOKEN;
-      if (!npmTokenEnv) {
-        throw new NpmAvailableError(
-          "NODE_AUTH_TOKEN not found in environment variables. Set it in your CI configuration:\n  GitHub Actions: Add NODE_AUTH_TOKEN as a repository secret\n  Other CI: Export NODE_AUTH_TOKEN with your npm access token"
-        );
       }
-      const result = await npm.publishProvenance();
-      if (!result) {
-        throw new NpmAvailableError(
-          `In CI environment, publishing with 2FA is not allowed. Please disable 2FA when accessing with a token from https://www.npmjs.com/package/${npm.packageName}/access `
-        );
+    } catch (error) {
+      if (error instanceof Error && (error.message.includes(
+        "cannot publish over the previously published"
+      ) || error.message.includes(
+        "You cannot publish over the previously published"
+      ))) {
+        task.title = `[SKIPPED] npm: v${ctx.version} already published`;
+        task.output = `\u26A0 ${npm.packageName}@${ctx.version} is already published on npm`;
+        return task.skip();
       }
+      throw error;
     }
   }
 };
@@ -6645,7 +6828,7 @@ var npmPublishTasks = {
 // src/tasks/preflight.ts
 var import_node_crypto2 = require("crypto");
 var import_prompt_adapter_enquirer4 = require("@listr2/prompt-adapter-enquirer");
-var import_tinyexec6 = require("tinyexec");
+var import_tinyexec7 = require("tinyexec");
 var PreflightError = class extends AbstractError {
   constructor() {
     super(...arguments);
@@ -6672,7 +6855,7 @@ async function syncGhSecrets(tokens) {
   for (const [registry, token] of Object.entries(tokens)) {
     const config = TOKEN_CONFIG[registry];
     if (!config) continue;
-    const result = (0, import_tinyexec6.exec)("gh", ["secret", "set", config.ghSecretName], {
+    const result = (0, import_tinyexec7.exec)("gh", ["secret", "set", config.ghSecretName], {
       throwOnError: true
     });
     const proc = result.process;
@@ -6866,10 +7049,10 @@ var prerequisitesCheckTask = (options) => {
 var import_prompt_adapter_enquirer6 = require("@listr2/prompt-adapter-enquirer");
 
 // src/registry/custom-registry.ts
-var import_tinyexec7 = require("tinyexec");
+var import_tinyexec8 = require("tinyexec");
 var CustomRegistry = class extends NpmRegistry {
   async npm(args) {
-    const { stdout } = await (0, import_tinyexec7.exec)(
+    const { stdout } = await (0, import_tinyexec8.exec)(
       "npm",
       args.concat("--registry", this.registry),
       { throwOnError: true }
@@ -7128,10 +7311,15 @@ async function collectDryRunPublishTasks(ctx) {
       return nonCratesTasks;
     }
     const sortedPaths = await sortCratesByDependencyOrder(cratesPaths);
+    const siblingCrateNames = await Promise.all(
+      cratesPaths.map((p) => new RustEcosystem(p).packageName())
+    );
     const sequentialCratesTask = {
       title: "Dry-run crates.io publish (sequential)",
       task: (_ctx, task) => task.newListr(
-        sortedPaths.map((p) => createCratesDryRunPublishTask(p)),
+        sortedPaths.map(
+          (p) => createCratesDryRunPublishTask(p, siblingCrateNames)
+        ),
         { concurrent: false }
       )
     };
@@ -7186,7 +7374,7 @@ async function run(options) {
           task: async (ctx2) => {
             const packageManager = await getPackageManager();
             try {
-              await (0, import_tinyexec8.exec)(packageManager, ["run", ctx2.testScript], {
+              await (0, import_tinyexec9.exec)(packageManager, ["run", ctx2.testScript], {
                 throwOnError: true
               });
             } catch (error) {
@@ -7203,7 +7391,7 @@ async function run(options) {
           task: async (ctx2) => {
             const packageManager = await getPackageManager();
             try {
-              await (0, import_tinyexec8.exec)(packageManager, ["run", ctx2.buildScript], {
+              await (0, import_tinyexec9.exec)(packageManager, ["run", ctx2.buildScript], {
                 throwOnError: true
               });
             } catch (error) {
@@ -7224,23 +7412,23 @@ async function run(options) {
             addRollback(async () => {
               if (tagCreated) {
                 try {
-                  console.log("Deleting tag...");
+                  rollbackLog("Deleting tag");
                   await git.deleteTag(`${await git.latestTag()}`);
                 } catch (error) {
-                  console.error(
+                  rollbackError(
                     `Failed to delete tag: ${error instanceof Error ? error.message : error}`
                   );
                 }
               }
               if (commited) {
                 try {
-                  console.log("Reset commits...");
+                  rollbackLog("Resetting commits");
                   await git.reset();
                   await git.stash();
                   await git.reset("HEAD^", "--hard");
                   await git.popStash();
                 } catch (error) {
-                  console.error(
+                  rollbackError(
                     `Failed to reset commits: ${error instanceof Error ? error.message : error}`
                   );
                 }