pubm 0.0.4 → 0.1.2

package/bin/cli.js

@@ -453,7 +453,7 @@ __export(base_exports, {
   scrollDown: () => scrollDown,
   scrollUp: () => scrollUp
 });
-import process2 from "node:process";
+import process6 from "node:process";
 var ESC, OSC, BEL, SEP, isTerminalApp, isWindows3, cwdFunction, cursorTo, cursorMove, cursorUp, cursorDown, cursorForward, cursorBackward, cursorLeft, cursorSavePosition, cursorRestorePosition, cursorGetPosition, cursorNextLine, cursorPrevLine, cursorHide, cursorShow, eraseLines, eraseEndLine, eraseStartLine, eraseLine, eraseDown, eraseUp, eraseScreen, scrollUp, scrollDown, clearScreen, clearTerminal, enterAlternativeScreen, exitAlternativeScreen, beep, link, image, iTerm;
 var init_base = __esm({
   "node_modules/.pnpm/ansi-escapes@7.0.0/node_modules/ansi-escapes/base.js"() {
@@ -463,11 +463,11 @@ var init_base = __esm({
     OSC = "\x1B]";
     BEL = "\x07";
     SEP = ";";
-    isTerminalApp = !isBrowser && process2.env.TERM_PROGRAM === "Apple_Terminal";
-    isWindows3 = !isBrowser && process2.platform === "win32";
+    isTerminalApp = !isBrowser && process6.env.TERM_PROGRAM === "Apple_Terminal";
+    isWindows3 = !isBrowser && process6.platform === "win32";
     cwdFunction = isBrowser ? () => {
       throw new Error("`process.cwd()` only works in Node.js, not the browser.");
-    } : process2.cwd;
+    } : process6.cwd;
     cursorTo = (x, y) => {
       if (typeof x !== "number") {
         throw new TypeError("The `x` argument is required");
@@ -543,32 +543,32 @@ var init_base = __esm({
       SEP,
       BEL
     ].join("");
-    image = (data, options2 = {}) => {
+    image = (data, options = {}) => {
       let returnValue = `${OSC}1337;File=inline=1`;
-      if (options2.width) {
-        returnValue += `;width=${options2.width}`;
+      if (options.width) {
+        returnValue += `;width=${options.width}`;
       }
-      if (options2.height) {
-        returnValue += `;height=${options2.height}`;
+      if (options.height) {
+        returnValue += `;height=${options.height}`;
       }
-      if (options2.preserveAspectRatio === false) {
+      if (options.preserveAspectRatio === false) {
         returnValue += ";preserveAspectRatio=0";
       }
       return returnValue + ":" + Buffer.from(data).toString("base64") + BEL;
     };
     iTerm = {
       setCwd: (cwd = cwdFunction()) => `${OSC}50;CurrentDir=${cwd}${BEL}`,
-      annotation(message, options2 = {}) {
+      annotation(message, options = {}) {
         let returnValue = `${OSC}1337;`;
-        const hasX = options2.x !== void 0;
-        const hasY = options2.y !== void 0;
-        if ((hasX || hasY) && !(hasX && hasY && options2.length !== void 0)) {
+        const hasX = options.x !== void 0;
+        const hasY = options.y !== void 0;
+        if ((hasX || hasY) && !(hasX && hasY && options.length !== void 0)) {
           throw new Error("`x`, `y` and `length` must be defined when `x` or `y` is defined");
         }
         message = message.replaceAll("|", "");
-        returnValue += options2.isHidden ? "AddHiddenAnnotation=" : "AddAnnotation=";
-        if (options2.length > 0) {
-          returnValue += (hasX ? [message, options2.length, options2.x, options2.y] : [options2.length, message]).join("|");
+        returnValue += options.isHidden ? "AddHiddenAnnotation=" : "AddAnnotation=";
+        if (options.length > 0) {
+          returnValue += (hasX ? [message, options.length, options.x, options.y] : [options.length, message]).join("|");
         } else {
           returnValue += message;
         }
@@ -646,7 +646,7 @@ var init_onetime = __esm({
     "use strict";
     init_mimic_function();
     calledFunctions = /* @__PURE__ */ new WeakMap();
-    onetime = (function_, options2 = {}) => {
+    onetime = (function_, options = {}) => {
       if (typeof function_ !== "function") {
         throw new TypeError("Expected a function");
       }
@@ -658,7 +658,7 @@ var init_onetime = __esm({
         if (callCount === 1) {
           returnValue = function_.apply(this, arguments_);
           function_ = void 0;
-        } else if (options2.throw === true) {
+        } else if (options.throw === true) {
           throw new Error(`Function \`${functionName}\` can only be called once`);
         }
         return returnValue;
@@ -708,12 +708,12 @@ var init_signals = __esm({
 });
 
 // node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/index.js
-var processOk, kExitEmitter, global, ObjectDefineProperty, Emitter, SignalExitBase, signalExitWrap, SignalExitFallback, _hupSig, _emitter, _process, _originalProcessEmit, _originalProcessReallyExit, _sigListeners, _loaded, _SignalExit_instances, processReallyExit_fn, processEmit_fn, SignalExit, process3, onExit, load, unload;
+var processOk, kExitEmitter, global, ObjectDefineProperty, Emitter, SignalExitBase, signalExitWrap, SignalExitFallback, _hupSig, _emitter, _process, _originalProcessEmit, _originalProcessReallyExit, _sigListeners, _loaded, _SignalExit_instances, processReallyExit_fn, processEmit_fn, SignalExit, process7, onExit, load, unload;
 var init_mjs = __esm({
   "node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/index.js"() {
     "use strict";
     init_signals();
-    processOk = (process11) => !!process11 && typeof process11 === "object" && typeof process11.removeListener === "function" && typeof process11.emit === "function" && typeof process11.reallyExit === "function" && typeof process11.listeners === "function" && typeof process11.kill === "function" && typeof process11.pid === "number" && typeof process11.on === "function";
+    processOk = (process16) => !!process16 && typeof process16 === "object" && typeof process16.removeListener === "function" && typeof process16.emit === "function" && typeof process16.reallyExit === "function" && typeof process16.listeners === "function" && typeof process16.kill === "function" && typeof process16.pid === "number" && typeof process16.on === "function";
     kExitEmitter = Symbol.for("signal-exit emitter");
     global = globalThis;
     ObjectDefineProperty = Object.defineProperty.bind(Object);
@@ -795,13 +795,13 @@ var init_mjs = __esm({
       }
     };
     SignalExit = class extends SignalExitBase {
-      constructor(process11) {
+      constructor(process16) {
         super();
         __privateAdd(this, _SignalExit_instances);
         // "SIGHUP" throws an `ENOSYS` error on Windows,
         // so use a supported signal instead
         /* c8 ignore start */
-        __privateAdd(this, _hupSig, process3.platform === "win32" ? "SIGINT" : "SIGHUP");
+        __privateAdd(this, _hupSig, process7.platform === "win32" ? "SIGINT" : "SIGHUP");
         /* c8 ignore stop */
         __privateAdd(this, _emitter, new Emitter());
         __privateAdd(this, _process);
@@ -809,13 +809,13 @@ var init_mjs = __esm({
         __privateAdd(this, _originalProcessReallyExit);
         __privateAdd(this, _sigListeners, {});
         __privateAdd(this, _loaded, false);
-        __privateSet(this, _process, process11);
+        __privateSet(this, _process, process16);
         __privateSet(this, _sigListeners, {});
         for (const sig of signals) {
           __privateGet(this, _sigListeners)[sig] = () => {
             const listeners = __privateGet(this, _process).listeners(sig);
             let { count } = __privateGet(this, _emitter);
-            const p = process11;
+            const p = process16;
             if (typeof p.__signal_exit_emitter__ === "object" && typeof p.__signal_exit_emitter__.count === "number") {
               count += p.__signal_exit_emitter__.count;
             }
@@ -824,12 +824,12 @@ var init_mjs = __esm({
               const ret = __privateGet(this, _emitter).emit("exit", null, sig);
               const s = sig === "SIGHUP" ? __privateGet(this, _hupSig) : sig;
               if (!ret)
-                process11.kill(process11.pid, s);
+                process16.kill(process16.pid, s);
             }
           };
         }
-        __privateSet(this, _originalProcessReallyExit, process11.reallyExit);
-        __privateSet(this, _originalProcessEmit, process11.emit);
+        __privateSet(this, _originalProcessReallyExit, process16.reallyExit);
+        __privateSet(this, _originalProcessEmit, process16.emit);
       }
       onExit(cb, opts) {
         if (!processOk(__privateGet(this, _process))) {
@@ -918,7 +918,7 @@ var init_mjs = __esm({
         return og.call(__privateGet(this, _process), ev, ...args);
       }
     };
-    process3 = globalThis.process;
+    process7 = globalThis.process;
     ({
       onExit: (
         /**
@@ -952,19 +952,19 @@ var init_mjs = __esm({
          */
         unload
       )
-    } = signalExitWrap(processOk(process3) ? new SignalExit(process3) : new SignalExitFallback()));
+    } = signalExitWrap(processOk(process7) ? new SignalExit(process7) : new SignalExitFallback()));
   }
 });
 
 // node_modules/.pnpm/restore-cursor@5.1.0/node_modules/restore-cursor/index.js
-import process4 from "node:process";
+import process8 from "node:process";
 var terminal, restoreCursor, restore_cursor_default;
 var init_restore_cursor = __esm({
   "node_modules/.pnpm/restore-cursor@5.1.0/node_modules/restore-cursor/index.js"() {
     "use strict";
     init_onetime();
     init_mjs();
-    terminal = process4.stderr.isTTY ? process4.stderr : process4.stdout.isTTY ? process4.stdout : void 0;
+    terminal = process8.stderr.isTTY ? process8.stderr : process8.stdout.isTTY ? process8.stdout : void 0;
     restoreCursor = terminal ? onetime_default(() => {
       onExit(() => {
         terminal.write("\x1B[?25h");
@@ -976,7 +976,7 @@ var init_restore_cursor = __esm({
 });
 
 // node_modules/.pnpm/cli-cursor@5.0.0/node_modules/cli-cursor/index.js
-import process5 from "node:process";
+import process9 from "node:process";
 var isHidden, cliCursor, cli_cursor_default;
 var init_cli_cursor = __esm({
   "node_modules/.pnpm/cli-cursor@5.0.0/node_modules/cli-cursor/index.js"() {
@@ -984,14 +984,14 @@ var init_cli_cursor = __esm({
     init_restore_cursor();
     isHidden = false;
     cliCursor = {};
-    cliCursor.show = (writableStream = process5.stderr) => {
+    cliCursor.show = (writableStream = process9.stderr) => {
       if (!writableStream.isTTY) {
         return;
       }
       isHidden = false;
       writableStream.write("\x1B[?25h");
     };
-    cliCursor.hide = (writableStream = process5.stderr) => {
+    cliCursor.hide = (writableStream = process9.stderr) => {
       if (!writableStream.isTTY) {
         return;
       }
@@ -1092,14 +1092,14 @@ var init_emoji_regex = __esm({
 });
 
 // node_modules/.pnpm/string-width@7.2.0/node_modules/string-width/index.js
-function stringWidth(string, options2 = {}) {
+function stringWidth(string, options = {}) {
   if (typeof string !== "string" || string.length === 0) {
     return 0;
   }
   const {
     ambiguousIsNarrow = true,
     countAnsiEscapeCodes = false
-  } = options2;
+  } = options;
   if (!countAnsiEscapeCodes) {
     string = stripAnsi(string);
   }
@@ -1345,8 +1345,8 @@ var wrap_ansi_exports = {};
 __export(wrap_ansi_exports, {
   default: () => wrapAnsi
 });
-function wrapAnsi(string, columns, options2) {
-  return String(string).normalize().replaceAll("\r\n", "\n").split("\n").map((line) => exec(line, columns, options2)).join("\n");
+function wrapAnsi(string, columns, options) {
+  return String(string).normalize().replaceAll("\r\n", "\n").split("\n").map((line) => exec(line, columns, options)).join("\n");
 }
 var ESCAPES, END_CODE, ANSI_ESCAPE_BELL, ANSI_CSI, ANSI_OSC, ANSI_SGR_TERMINATOR, ANSI_ESCAPE_LINK, wrapAnsiCode, wrapAnsiHyperlink, wordLengths, wrapWord, stringVisibleTrimSpacesRight, exec;
 var init_wrap_ansi = __esm({
@@ -1421,8 +1421,8 @@ var init_wrap_ansi = __esm({
       }
       return words.slice(0, last).join(" ") + words.slice(last).join("");
     };
-    exec = (string, columns, options2 = {}) => {
-      if (options2.trim !== false && string.trim() === "") {
+    exec = (string, columns, options = {}) => {
+      if (options.trim !== false && string.trim() === "") {
         return "";
       }
       let returnValue = "";
@@ -1431,21 +1431,21 @@ var init_wrap_ansi = __esm({
       const lengths = wordLengths(string);
       let rows = [""];
       for (const [index, word] of string.split(" ").entries()) {
-        if (options2.trim !== false) {
+        if (options.trim !== false) {
           rows[rows.length - 1] = rows.at(-1).trimStart();
         }
         let rowLength = stringWidth(rows.at(-1));
         if (index !== 0) {
-          if (rowLength >= columns && (options2.wordWrap === false || options2.trim === false)) {
+          if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
             rows.push("");
             rowLength = 0;
           }
-          if (rowLength > 0 || options2.trim === false) {
+          if (rowLength > 0 || options.trim === false) {
             rows[rows.length - 1] += " ";
             rowLength++;
           }
         }
-        if (options2.hard && lengths[index] > columns) {
+        if (options.hard && lengths[index] > columns) {
           const remainingColumns = columns - rowLength;
           const breaksStartingThisLine = 1 + Math.floor((lengths[index] - remainingColumns - 1) / columns);
           const breaksStartingNextLine = Math.floor((lengths[index] - 1) / columns);
@@ -1456,19 +1456,19 @@ var init_wrap_ansi = __esm({
           continue;
         }
         if (rowLength + lengths[index] > columns && rowLength > 0 && lengths[index] > 0) {
-          if (options2.wordWrap === false && rowLength < columns) {
+          if (options.wordWrap === false && rowLength < columns) {
             wrapWord(rows, word, columns);
             continue;
           }
           rows.push("");
         }
-        if (rowLength + lengths[index] > columns && options2.wordWrap === false) {
+        if (rowLength + lengths[index] > columns && options.wordWrap === false) {
           wrapWord(rows, word, columns);
           continue;
         }
         rows[rows.length - 1] += word;
       }
-      if (options2.trim !== false) {
+      if (options.trim !== false) {
         rows = rows.map((row) => stringVisibleTrimSpacesRight(row));
       }
       const preString = rows.join("\n");
@@ -1667,7 +1667,7 @@ __export(log_update_exports, {
   default: () => log_update_default,
   logUpdateStderr: () => logUpdateStderr
 });
-import process6 from "node:process";
+import process10 from "node:process";
 function createLogUpdate(stream, { showCursor = false } = {}) {
   let previousLineCount = 0;
   let previousWidth = getWidth(stream);
@@ -1721,9 +1721,9 @@ var init_log_update = __esm({
       const toRemove = Math.max(0, lines.length - terminalHeight);
       return toRemove ? sliceAnsi(text, stripAnsi(lines.slice(0, toRemove).join("\n")).length + 1) : text;
     };
-    logUpdate = createLogUpdate(process6.stdout);
+    logUpdate = createLogUpdate(process10.stdout);
     log_update_default = logUpdate;
-    logUpdateStderr = createLogUpdate(process6.stderr);
+    logUpdateStderr = createLogUpdate(process10.stderr);
   }
 });
 
@@ -1864,13 +1864,13 @@ function getIndexOfNearestSpace(string, wantedIndex, shouldSearchRight) {
   }
   return wantedIndex;
 }
-function cliTruncate(text, columns, options2 = {}) {
+function cliTruncate(text, columns, options = {}) {
   const {
     position = "end",
     space = false,
     preferTruncationOnSpace = false
-  } = options2;
-  let { truncationCharacter = "\u2026" } = options2;
+  } = options;
+  let { truncationCharacter = "\u2026" } = options;
   if (typeof text !== "string") {
     throw new TypeError(`Expected \`input\` to be a string, got ${typeof text}`);
   }
@@ -1934,6 +1934,469 @@ import cac from "cac";
 import semver3 from "semver";
 import { isCI as isCI3 } from "std-env";
 
+// src/changeset/writer.ts
+import { mkdirSync, writeFileSync } from "node:fs";
+import path from "node:path";
+import process2 from "node:process";
+import { stringify as stringifyYaml } from "yaml";
+var adjectives = [
+  "brave",
+  "calm",
+  "dark",
+  "eager",
+  "fair",
+  "glad",
+  "happy",
+  "idle",
+  "jolly",
+  "keen",
+  "lame",
+  "mild",
+  "neat",
+  "odd",
+  "pale",
+  "quick",
+  "rare",
+  "safe",
+  "tall",
+  "ugly",
+  "vast",
+  "warm",
+  "young",
+  "zany",
+  "bold",
+  "cool",
+  "dry",
+  "fast",
+  "good",
+  "hot",
+  "icy",
+  "loud"
+];
+var nouns = [
+  "ant",
+  "bear",
+  "cat",
+  "dog",
+  "elk",
+  "fox",
+  "goat",
+  "hawk",
+  "ibis",
+  "jay",
+  "kite",
+  "lion",
+  "mole",
+  "newt",
+  "owl",
+  "puma",
+  "quail",
+  "ram",
+  "seal",
+  "toad",
+  "urchin",
+  "vole",
+  "wolf",
+  "yak",
+  "zebra",
+  "ape",
+  "bat",
+  "cow",
+  "deer",
+  "emu",
+  "frog",
+  "gull"
+];
+function generateChangesetId() {
+  const adjective = adjectives[Math.floor(Math.random() * adjectives.length)];
+  const noun = nouns[Math.floor(Math.random() * nouns.length)];
+  const suffix = Math.random().toString(36).slice(2, 6);
+  return `${adjective}-${noun}-${suffix}`;
+}
+function generateChangesetContent(releases, summary) {
+  let content = "---\n";
+  if (releases.length > 0) {
+    const yamlObj = {};
+    for (const release of releases) {
+      yamlObj[release.name] = release.type;
+    }
+    content += stringifyYaml(yamlObj);
+  }
+  content += "---\n";
+  if (summary) {
+    content += `
+${summary}
+`;
+  }
+  return content;
+}
+function writeChangeset(releases, summary, cwd = process2.cwd()) {
+  const changesetsDir = path.join(cwd, ".pubm", "changesets");
+  mkdirSync(changesetsDir, { recursive: true });
+  const id = generateChangesetId();
+  const fileName = `${id}.md`;
+  const filePath = path.join(changesetsDir, fileName);
+  const content = generateChangesetContent(releases, summary);
+  writeFileSync(filePath, content, "utf-8");
+  return filePath;
+}
+
+// src/commands/add.ts
+function registerAddCommand(cli2) {
+  cli2.command("add", "Create a new changeset").option("--empty", "Create an empty changeset").option("--packages <list>", "Comma-separated package names").option("--bump <type>", "Bump type: patch, minor, major").option("--message <text>", "Changeset summary").action(
+    async (options) => {
+      if (options.empty) {
+        const filePath = writeChangeset([], "");
+        console.log(`Created empty changeset: ${filePath}`);
+        return;
+      }
+      if (options.packages && options.bump && options.message) {
+        const VALID_BUMP_TYPES2 = /* @__PURE__ */ new Set(["patch", "minor", "major"]);
+        if (!VALID_BUMP_TYPES2.has(options.bump)) {
+          throw new Error(
+            `Invalid bump type "${options.bump}". Expected: patch, minor, or major.`
+          );
+        }
+        const packages = options.packages.split(",").map((p) => p.trim());
+        const releases = packages.map((name) => ({
+          name,
+          type: options.bump
+        }));
+        const filePath = writeChangeset(releases, options.message);
+        console.log(`Created changeset: ${filePath}`);
+        return;
+      }
+      console.log(
+        "Interactive changeset creation coming soon. Use --packages, --bump, and --message flags for now."
+      );
+    }
+  );
+}
+
+// src/commands/init.ts
+import { existsSync, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import path2 from "node:path";
+function registerInitCommand(cli2) {
+  cli2.command("init", "Initialize pubm configuration").action(async () => {
+    const pubmDir = path2.resolve(".pubm", "changesets");
+    if (!existsSync(pubmDir)) {
+      mkdirSync2(pubmDir, { recursive: true });
+      console.log("Created .pubm/changesets/");
+    }
+    const configPath = path2.resolve("pubm.config.ts");
+    if (!existsSync(configPath)) {
+      writeFileSync2(
+        configPath,
+        [
+          "import { defineConfig } from 'pubm'",
+          "",
+          "export default defineConfig({})",
+          ""
+        ].join("\n")
+      );
+      console.log("Created pubm.config.ts");
+    }
+    console.log("pubm initialized successfully.");
+  });
+}
+
+// src/changeset/migrate.ts
+import { copyFileSync, existsSync as existsSync2, mkdirSync as mkdirSync3, readdirSync } from "node:fs";
+import path3 from "node:path";
+import process3 from "node:process";
+var SKIPPED_FILES = /* @__PURE__ */ new Set(["config.json", "README.md"]);
+function migrateFromChangesets(cwd = process3.cwd()) {
+  const changesetDir = path3.join(cwd, ".changeset");
+  if (!existsSync2(changesetDir)) {
+    return {
+      success: false,
+      error: ".changeset/ directory not found",
+      migratedFiles: [],
+      configMigrated: false
+    };
+  }
+  const pubmDir = path3.join(cwd, ".pubm", "changesets");
+  mkdirSync3(pubmDir, { recursive: true });
+  const files = readdirSync(changesetDir);
+  const migratedFiles = [];
+  let configMigrated = false;
+  for (const file of files) {
+    if (file === "config.json") {
+      configMigrated = true;
+      continue;
+    }
+    if (SKIPPED_FILES.has(file)) {
+      continue;
+    }
+    if (file === "pre.json") {
+      copyFileSync(
+        path3.join(changesetDir, file),
+        path3.resolve(cwd, ".pubm", "pre.json")
+      );
+      migratedFiles.push(file);
+      continue;
+    }
+    if (file.endsWith(".md")) {
+      const src = path3.join(changesetDir, file);
+      const dest = path3.join(pubmDir, file);
+      copyFileSync(src, dest);
+      migratedFiles.push(file);
+    }
+  }
+  return {
+    success: true,
+    migratedFiles,
+    configMigrated
+  };
+}
+
+// src/commands/migrate.ts
+function registerMigrateCommand(cli2) {
+  cli2.command("migrate", "Migrate from .changeset/ to .pubm/").action(async () => {
+    const result = migrateFromChangesets();
+    if (!result.success) {
+      console.error(result.error);
+      process.exit(1);
+    }
+    console.log(`Migrated ${result.migratedFiles.length} changeset files.`);
+    if (result.configMigrated) {
+      console.log(
+        "Note: .changeset/config.json detected. Please manually create pubm.config.ts."
+      );
+    }
+  });
+}
+
+// src/prerelease/pre.ts
+import {
+  existsSync as existsSync3,
+  mkdirSync as mkdirSync4,
+  readFileSync,
+  rmSync,
+  writeFileSync as writeFileSync3
+} from "node:fs";
+import path4 from "node:path";
+function getPreStatePath(cwd) {
+  return path4.resolve(cwd ?? process.cwd(), ".pubm", "pre.json");
+}
+function enterPreMode(tag, cwd) {
+  const filePath = getPreStatePath(cwd);
+  if (existsSync3(filePath)) {
+    throw new Error(
+      "Already in pre mode. Exit pre mode first before entering a new one."
+    );
+  }
+  const dir = path4.dirname(filePath);
+  if (!existsSync3(dir)) {
+    mkdirSync4(dir, { recursive: true });
+  }
+  const state = {
+    mode: "pre",
+    tag,
+    packages: {}
+  };
+  writeFileSync3(filePath, JSON.stringify(state, null, 2), "utf-8");
+}
+function exitPreMode(cwd) {
+  const filePath = getPreStatePath(cwd);
+  if (!existsSync3(filePath)) {
+    throw new Error("Not in pre mode. Enter pre mode first before exiting.");
+  }
+  rmSync(filePath);
+}
+
+// src/commands/pre.ts
+function registerPreCommand(cli2) {
+  cli2.command("pre <action> [tag]", "Manage pre-release mode").action(async (action, tag) => {
+    if (action === "enter") {
+      if (!tag) {
+        console.error("Usage: pubm pre enter <tag>");
+        process.exit(1);
+      }
+      enterPreMode(tag);
+      console.log(`Entered pre-release mode (${tag})`);
+    } else if (action === "exit") {
+      exitPreMode();
+      console.log("Exited pre-release mode");
+    } else {
+      console.error(`Unknown pre action: ${action}. Use "enter" or "exit".`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/snapshot.ts
+function registerSnapshotCommand(cli2) {
+  cli2.command("snapshot [tag]", "Create a snapshot release").action(async (tag) => {
+    console.log(`pubm snapshot ${tag ?? ""} \u2014 coming in next phase`);
+  });
+}
+
+// src/changeset/status.ts
+import process5 from "node:process";
+
+// src/changeset/bump-utils.ts
+var BUMP_ORDER = {
+  patch: 0,
+  minor: 1,
+  major: 2
+};
+function maxBump(a2, b) {
+  return BUMP_ORDER[a2] >= BUMP_ORDER[b] ? a2 : b;
+}
+
+// src/changeset/reader.ts
+import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync2 } from "node:fs";
+import path5 from "node:path";
+import process4 from "node:process";
+
+// src/changeset/parser.ts
+import { parse as parseYaml } from "yaml";
+var VALID_BUMP_TYPES = /* @__PURE__ */ new Set(["patch", "minor", "major"]);
+function parseChangeset(content, fileName) {
+  const frontmatterRegex = /^---\n([\s\S]*?)---/;
+  const match = content.match(frontmatterRegex);
+  if (!match) {
+    throw new Error(
+      `Invalid changeset format in "${fileName}": missing frontmatter`
+    );
+  }
+  const yamlContent = match[1];
+  const body = content.slice(match[0].length).trim();
+  const parsed = parseYaml(yamlContent);
+  const releases = [];
+  if (parsed) {
+    for (const [name, type] of Object.entries(parsed)) {
+      if (!VALID_BUMP_TYPES.has(type)) {
+        throw new Error(
+          `Invalid bump type "${type}" for package "${name}" in "${fileName}". Expected: patch, minor, or major.`
+        );
+      }
+      releases.push({ name, type });
+    }
+  }
+  const id = fileName.replace(/\.md$/, "");
+  return {
+    id,
+    summary: body,
+    releases
+  };
+}
+
+// src/changeset/reader.ts
+function readChangesets(cwd = process4.cwd()) {
+  const changesetsDir = path5.join(cwd, ".pubm", "changesets");
+  if (!existsSync4(changesetsDir)) {
+    return [];
+  }
+  const files = readdirSync2(changesetsDir);
+  const changesets = [];
+  for (const file of files) {
+    if (!file.endsWith(".md") || file === "README.md") {
+      continue;
+    }
+    const filePath = path5.join(changesetsDir, file);
+    const content = readFileSync2(filePath, "utf-8");
+    changesets.push(parseChangeset(content, file));
+  }
+  return changesets;
+}
+
+// src/changeset/status.ts
+function getStatus(cwd = process5.cwd()) {
+  const changesets = readChangesets(cwd);
+  const packages = /* @__PURE__ */ new Map();
+  for (const changeset of changesets) {
+    for (const release of changeset.releases) {
+      const existing = packages.get(release.name);
+      if (existing) {
+        existing.bumpType = maxBump(existing.bumpType, release.type);
+        existing.changesetCount += 1;
+        existing.summaries.push(changeset.summary);
+      } else {
+        packages.set(release.name, {
+          bumpType: release.type,
+          changesetCount: 1,
+          summaries: [changeset.summary]
+        });
+      }
+    }
+  }
+  return {
+    packages,
+    changesets,
+    hasChangesets: changesets.length > 0
+  };
+}
+
+// src/commands/status.ts
+function registerStatusCommand(cli2) {
+  cli2.command("status", "Show pending changeset status").option("--verbose", "Show full changeset contents").option("--since <ref>", "Only check changesets since git ref").action(async (options) => {
+    const status = getStatus();
+    if (!status.hasChangesets) {
+      if (options.since) {
+        console.log("No changesets found.");
+        process.exit(1);
+      }
+      console.log("No pending changesets.");
+      return;
+    }
+    console.log("Pending changesets:");
+    for (const [name, info] of status.packages) {
+      console.log(
+        `  ${name}: ${info.bumpType} (${info.changesetCount} changeset${info.changesetCount > 1 ? "s" : ""})`
+      );
+      if (options.verbose) {
+        for (const summary of info.summaries) {
+          console.log(`    - ${summary}`);
+        }
+      }
+    }
+  });
+}
+
+// src/commands/update.ts
+import { UpdateKit } from "update-kit";
+function registerUpdateCommand(cli2) {
+  cli2.command("update", "Update pubm to the latest version").action(async () => {
+    const kit = await UpdateKit.create({
+      sources: [{ type: "npm", packageName: "pubm" }],
+      delegateMode: "execute"
+    });
+    const result = await kit.autoUpdate({
+      onProgress: (p) => {
+        if (p.phase === "downloading" && p.totalBytes) {
+          const pct = Math.round(p.bytesDownloaded / p.totalBytes * 100);
+          process.stderr.write(`\rDownloading... ${pct}%`);
+        } else {
+          console.error(`${p.phase}...`);
+        }
+      }
+    });
+    switch (result.kind) {
+      case "success":
+        console.log(
+          `Updated from ${result.fromVersion} to ${result.toVersion}`
+        );
+        break;
+      case "needs-restart":
+        console.log(result.message);
+        break;
+      case "failed":
+        console.error(`Update failed: ${result.error.message}`);
+        process.exitCode = 1;
+        break;
+    }
+  });
+}
+
+// src/commands/version-cmd.ts
+function registerVersionCommand(cli2) {
+  cli2.command("version", "Consume changesets and bump versions").action(async () => {
+    console.log("pubm version \u2014 coming in next phase");
+  });
+}
+
 // node_modules/.pnpm/eventemitter3@5.0.1/node_modules/eventemitter3/index.mjs
 var import_index = __toESM(require_eventemitter3(), 1);
 var eventemitter3_default = import_index.default;
@@ -2244,39 +2707,39 @@ var LISTR_LOGGER_STDERR_LEVELS = [
 ];
 var _a3;
 var ListrLogger = (_a3 = class {
-  constructor(options2) {
+  constructor(options) {
     __publicField(this, "process");
     var _a24, _b, _c;
-    this.options = options2;
+    this.options = options;
     this.options = {
       useIcons: true,
       toStderr: [],
-      ...options2 ?? {}
+      ...options ?? {}
     };
     (_a24 = this.options).fields ?? (_a24.fields = {});
     (_b = this.options.fields).prefix ?? (_b.prefix = []);
     (_c = this.options.fields).suffix ?? (_c.suffix = []);
     this.process = this.options.processOutput ?? new ProcessOutput();
   }
-  log(level, message, options2) {
-    const output = this.format(level, message, options2);
+  log(level, message, options) {
+    const output = this.format(level, message, options);
     if (this.options.toStderr.includes(level)) {
       this.process.toStderr(output);
       return;
     }
     this.process.toStdout(output);
   }
-  toStdout(message, options2, eol = true) {
-    this.process.toStdout(this.format(null, message, options2), eol);
+  toStdout(message, options, eol = true) {
+    this.process.toStdout(this.format(null, message, options), eol);
   }
-  toStderr(message, options2, eol = true) {
-    this.process.toStderr(this.format(null, message, options2), eol);
+  toStderr(message, options, eol = true) {
+    this.process.toStderr(this.format(null, message, options), eol);
   }
-  wrap(message, options2) {
+  wrap(message, options) {
     if (!message) {
       return message;
     }
-    return this.applyFormat(`[${message}]`, options2);
+    return this.applyFormat(`[${message}]`, options);
   }
   splat(...args) {
     const message = args.shift() ?? "";
@@ -2316,15 +2779,15 @@ var ListrLogger = (_a3 = class {
     });
     return message;
   }
-  fields(message, options2) {
+  fields(message, options) {
     if (this.options?.fields?.prefix) {
       message = this.prefix(message, ...this.options.fields.prefix);
     }
-    if (options2?.prefix) {
-      message = this.prefix(message, ...options2.prefix);
+    if (options?.prefix) {
+      message = this.prefix(message, ...options.prefix);
     }
-    if (options2?.suffix) {
-      message = this.suffix(message, ...options2.suffix);
+    if (options?.suffix) {
+      message = this.suffix(message, ...options.suffix);
     }
     if (this.options?.fields?.suffix) {
       message = this.suffix(message, ...this.options.fields.suffix);
@@ -2342,7 +2805,7 @@ var ListrLogger = (_a3 = class {
     }
     return icon;
   }
-  format(level, message, options2) {
+  format(level, message, options) {
     if (!Array.isArray(message)) {
       message = [message];
     }
@@ -2350,8 +2813,8 @@ var ListrLogger = (_a3 = class {
       return this.style(
         level,
         this.fields(m, {
-          prefix: Array.isArray(options2?.prefix) ? options2.prefix : [options2?.prefix],
-          suffix: Array.isArray(options2?.suffix) ? options2.suffix : [options2?.suffix]
+          prefix: Array.isArray(options?.prefix) ? options.prefix : [options?.prefix],
+          suffix: Array.isArray(options?.suffix) ? options.suffix : [options?.suffix]
         })
       );
     }).join(EOL);
@@ -2367,9 +2830,9 @@ var ListrLogger = (_a3 = class {
     }
     return message;
   }
-  applyFormat(message, options2) {
-    if (options2?.format) {
-      return options2.format(message);
+  applyFormat(message, options) {
+    if (options?.format) {
+      return options.format(message);
     }
     return message;
   }
@@ -2379,10 +2842,10 @@ var ListrLogger = (_a3 = class {
 }, __name(_a3, "ListrLogger"), _a3);
 var _a4;
 var ProcessOutputBuffer = (_a4 = class {
-  constructor(options2) {
+  constructor(options) {
     __publicField(this, "buffer", []);
     __publicField(this, "decoder", new StringDecoder());
-    this.options = options2;
+    this.options = options;
   }
   get all() {
     return this.buffer;
@@ -2441,10 +2904,10 @@ var ProcessOutputStream = (_a5 = class {
 }, __name(_a5, "ProcessOutputStream"), _a5);
 var _a6;
 var ProcessOutput = (_a6 = class {
-  constructor(stdout, stderr, options2) {
+  constructor(stdout, stderr, options) {
     __publicField(this, "stream");
     __publicField(this, "active");
-    this.options = options2;
+    this.options = options;
     this.stream = {
       stdout: new ProcessOutputStream(stdout ?? process.stdout),
       stderr: new ProcessOutputStream(stderr ?? process.stderr)
@@ -2452,7 +2915,7 @@ var ProcessOutput = (_a6 = class {
     this.options = {
       dump: ["stdout", "stderr"],
       leaveEmptyLine: true,
-      ...options2
+      ...options
     };
   }
   get stdout() {
@@ -2716,7 +3179,7 @@ function parseTimestamp() {
 __name(parseTimestamp, "parseTimestamp");
 var _a9;
 var DefaultRenderer = (_a9 = class {
-  constructor(tasks, options2, events) {
+  constructor(tasks, options, events) {
     __publicField(this, "prompt");
     __publicField(this, "activePrompt");
     __publicField(this, "spinner");
@@ -2734,18 +3197,18 @@ var DefaultRenderer = (_a9 = class {
       rendererTaskOptions: /* @__PURE__ */ new Map()
     });
     this.tasks = tasks;
-    this.options = options2;
+    this.options = options;
     this.events = events;
     this.options = {
       ..._a9.rendererOptions,
       ...this.options,
       icon: {
         ...LISTR_DEFAULT_RENDERER_STYLE.icon,
-        ...options2?.icon ?? {}
+        ...options?.icon ?? {}
       },
       color: {
         ...LISTR_DEFAULT_RENDERER_STYLE.color,
-        ...options2?.color ?? {}
+        ...options?.color ?? {}
       }
     };
     this.spinner = this.options.spinner ?? new Spinner();
@@ -2782,27 +3245,27 @@ var DefaultRenderer = (_a9 = class {
     }
     this.logger.process.release();
   }
-  create(options2) {
-    options2 = {
+  create(options) {
+    options = {
       tasks: true,
       bottomBar: true,
       prompt: true,
-      ...options2
+      ...options
     };
     const render = [];
     const renderTasks = this.renderer(this.tasks);
     const renderBottomBar = this.renderBottomBar();
     const renderPrompt = this.renderPrompt();
-    if (options2.tasks && renderTasks.length > 0) {
+    if (options.tasks && renderTasks.length > 0) {
       render.push(...renderTasks);
     }
-    if (options2.bottomBar && renderBottomBar.length > 0) {
+    if (options.bottomBar && renderBottomBar.length > 0) {
       if (render.length > 0) {
         render.push("");
       }
       render.push(...renderBottomBar);
     }
-    if (options2.prompt && renderPrompt.length > 0) {
+    if (options.prompt && renderPrompt.length > 0) {
       if (render.length > 0) {
         render.push("");
       }
@@ -3183,9 +3646,9 @@ var DefaultRenderer = (_a9 = class {
 }), _a9);
 var _a10;
 var SilentRenderer = (_a10 = class {
-  constructor(tasks, options2) {
+  constructor(tasks, options) {
     this.tasks = tasks;
-    this.options = options2;
+    this.options = options;
   }
   render() {
     return;
@@ -3196,24 +3659,24 @@ var SilentRenderer = (_a10 = class {
 }, __name(_a10, "SilentRenderer"), __publicField(_a10, "nonTTY", true), __publicField(_a10, "rendererOptions"), __publicField(_a10, "rendererTaskOptions"), _a10);
 var _a11;
 var SimpleRenderer = (_a11 = class {
-  constructor(tasks, options2) {
+  constructor(tasks, options) {
     __publicField(this, "logger");
     __publicField(this, "cache", {
       rendererOptions: /* @__PURE__ */ new Map(),
       rendererTaskOptions: /* @__PURE__ */ new Map()
     });
     this.tasks = tasks;
-    this.options = options2;
+    this.options = options;
     this.options = {
       ..._a11.rendererOptions,
-      ...options2,
+      ...options,
       icon: {
         ...LISTR_LOGGER_STYLE.icon,
-        ...options2?.icon ?? {}
+        ...options?.icon ?? {}
       },
       color: {
         ...LISTR_LOGGER_STYLE.color,
-        ...options2?.color ?? {}
+        ...options?.color ?? {}
       }
     };
     this.logger = this.options.logger ?? new ListrLogger({ useIcons: true, toStderr: LISTR_LOGGER_STDERR_LEVELS });
@@ -3349,8 +3812,8 @@ var SimpleRenderer = (_a11 = class {
 }), __publicField(_a11, "rendererTaskOptions", {}), _a11);
 var _a12;
 var TestRendererSerializer = (_a12 = class {
-  constructor(options2) {
-    this.options = options2;
+  constructor(options) {
+    this.options = options;
   }
   serialize(event, data, task) {
     return JSON.stringify(this.generate(event, data, task));
@@ -3379,11 +3842,11 @@ var TestRendererSerializer = (_a12 = class {
 }, __name(_a12, "TestRendererSerializer"), _a12);
 var _a13;
 var TestRenderer = (_a13 = class {
-  constructor(tasks, options2) {
+  constructor(tasks, options) {
     __publicField(this, "logger");
     __publicField(this, "serializer");
     this.tasks = tasks;
-    this.options = options2;
+    this.options = options;
     this.options = { ..._a13.rendererOptions, ...this.options };
     this.logger = this.options.logger ?? new ListrLogger({ useIcons: false });
     this.serializer = new TestRendererSerializer(this.options);
@@ -3472,24 +3935,24 @@ var TestRenderer = (_a13 = class {
 }), __publicField(_a13, "rendererTaskOptions"), _a13);
 var _a14;
 var VerboseRenderer = (_a14 = class {
-  constructor(tasks, options2) {
+  constructor(tasks, options) {
     __publicField(this, "logger");
     __publicField(this, "cache", {
       rendererOptions: /* @__PURE__ */ new Map(),
       rendererTaskOptions: /* @__PURE__ */ new Map()
     });
     this.tasks = tasks;
-    this.options = options2;
+    this.options = options;
     this.options = {
       ..._a14.rendererOptions,
       ...this.options,
       icon: {
         ...LISTR_LOGGER_STYLE.icon,
-        ...options2?.icon ?? {}
+        ...options?.icon ?? {}
       },
       color: {
         ...LISTR_LOGGER_STYLE.color,
-        ...options2?.color ?? {}
+        ...options?.color ?? {}
       }
     };
     this.logger = this.options.logger ?? new ListrLogger({ useIcons: false, toStderr: LISTR_LOGGER_STDERR_LEVELS });
@@ -3621,8 +4084,8 @@ function getRendererClass(renderer) {
   return typeof renderer === "function" ? renderer : RENDERERS.default;
 }
 __name(getRendererClass, "getRendererClass");
-function getRenderer(options2) {
-  if (assertFunctionOrSelf(options2?.silentRendererCondition)) {
+function getRenderer(options) {
+  if (assertFunctionOrSelf(options?.silentRendererCondition)) {
     return {
       renderer: getRendererClass("silent"),
       selection: "SILENT"
@@ -3630,15 +4093,15 @@ function getRenderer(options2) {
     };
   }
   const r = {
-    renderer: getRendererClass(options2.renderer),
-    options: options2.rendererOptions,
+    renderer: getRendererClass(options.renderer),
+    options: options.rendererOptions,
     selection: "PRIMARY"
     /* PRIMARY */
   };
-  if (!isRendererSupported(r.renderer) || assertFunctionOrSelf(options2?.fallbackRendererCondition)) {
+  if (!isRendererSupported(r.renderer) || assertFunctionOrSelf(options?.fallbackRendererCondition)) {
     return {
-      renderer: getRendererClass(options2.fallbackRenderer),
-      options: options2.fallbackRendererOptions,
+      renderer: getRendererClass(options.fallbackRenderer),
+      options: options.fallbackRendererOptions,
       selection: "SECONDARY"
       /* SECONDARY */
     };
@@ -3661,11 +4124,11 @@ function cloneObject(obj) {
 __name(cloneObject, "cloneObject");
 var _a15;
 var Concurrency = (_a15 = class {
-  constructor(options2) {
+  constructor(options) {
     __publicField(this, "concurrency");
     __publicField(this, "count");
     __publicField(this, "queue");
-    this.concurrency = options2.concurrency;
+    this.concurrency = options.concurrency;
     this.count = 0;
     this.queue = /* @__PURE__ */ new Set();
   }
@@ -3772,14 +4235,14 @@ var TaskWrapper = (_a19 = class {
    *
    * @see {@link https://listr2.kilic.dev/task/subtasks.html}
    */
-  newListr(task, options2) {
+  newListr(task, options) {
     let tasks;
     if (typeof task === "function") {
       tasks = task(this);
     } else {
       tasks = task;
     }
-    return new Listr(tasks, options2, this.task);
+    return new Listr(tasks, options, this.task);
   }
   /**
    * Report an error that has to be collected and handled.
@@ -3853,7 +4316,7 @@ var ListrTaskEventManager = (_a20 = class extends EventManager {
 }, __name(_a20, "ListrTaskEventManager"), _a20);
 var _a21;
 var Task = (_a21 = class extends ListrTaskEventManager {
-  constructor(listr, task, options2, rendererOptions, rendererTaskOptions) {
+  constructor(listr, task, options, rendererOptions, rendererTaskOptions) {
     super();
     /** Unique id per task, can be used for identifying a Task. */
     __publicField(this, "id", randomUUID());
@@ -3887,7 +4350,7 @@ var Task = (_a21 = class extends ListrTaskEventManager {
     __publicField(this, "closed");
     this.listr = listr;
     this.task = task;
-    this.options = options2;
+    this.options = options;
     this.rendererOptions = rendererOptions;
     this.rendererTaskOptions = rendererTaskOptions;
     if (task.title) {
@@ -4204,7 +4667,7 @@ var ListrEventManager = (_a22 = class extends EventManager {
 }, __name(_a22, "ListrEventManager"), _a22);
 var _a23;
 var Listr = (_a23 = class {
-  constructor(task, options2, parentTask) {
+  constructor(task, options, parentTask) {
     __publicField(this, "tasks", []);
     __publicField(this, "errors", []);
     __publicField(this, "ctx");
@@ -4217,7 +4680,7 @@ var Listr = (_a23 = class {
     __publicField(this, "concurrency");
     __publicField(this, "renderer");
     this.task = task;
-    this.options = options2;
+    this.options = options;
     this.parentTask = parentTask;
     this.options = {
       concurrent: false,
@@ -4228,7 +4691,7 @@ var Listr = (_a23 = class {
       collectErrors: false,
       registerSignalListeners: true,
       ...this.parentTask?.options ?? {},
-      ...options2
+      ...options
     };
     if (this.options.concurrent === true) {
       this.options.concurrent = Infinity;
@@ -4376,10 +4839,13 @@ function replaceCode(code) {
 }
 function formatError(error) {
   if (!(error instanceof Error)) return `${error}`;
-  const message = typeof error.message === "string" ? replaceCode(error.message) : formatError(error);
+  const message = typeof error.message === "string" ? replaceCode(error.message) : (
+    /* v8 ignore next */
+    formatError(error)
+  );
   let stringifyError = `${color.bgRed(` ${error.name} `)}${color.reset("")} ${message}
 `;
-  stringifyError += error.stack?.split("\n").slice(1).join("\n").replace(/at/g, color.dim("at")).replace(/\(([^\(].+)\)/g, `(${color.blue("$1")})`);
+  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);
@@ -4410,8 +4876,7 @@ var GitError = class extends AbstractError {
 };
 var Git = class {
   async git(args) {
-    const { stdout, stderr } = await exec2("git", args);
-    if (stderr) throw stderr;
+    const { stdout } = await exec2("git", args, { throwOnError: true });
     return stdout;
   }
   async userName() {
@@ -4432,7 +4897,7 @@ var Git = class {
   }
   async tags() {
     try {
-      return (await this.git(["tag", "-l"])).trim().split("\n").map((v) => v.slice(1)).sort(semver.compareIdentifiers);
+      return (await this.git(["tag", "-l"])).trim().split("\n").sort(semver.compareIdentifiers);
     } catch (error) {
       throw new GitError("Failed to run `git config --get user.name`", {
         cause: error
@@ -4442,7 +4907,8 @@ var Git = class {
   async previousTag(tag) {
     try {
       const tags = await this.tags();
-      return tags.at(tags.findIndex((t) => t === tag) - 1) ?? null;
+      const strip = (t) => t.replace(/^v/, "");
+      return tags.at(tags.findIndex((t) => strip(t) === strip(tag)) - 1) ?? null;
     } catch {
       return null;
     }
@@ -4547,13 +5013,8 @@ var Git = class {
   async checkTagExist(tag) {
     try {
       return (await this.git(["rev-parse", "-q", "--verify", `refs/tags/${tag}`])).trim() !== "";
-    } catch (error) {
-      throw new GitError(
-        `Failed to run \`git rev-parse -q --verify refs/tags/${tag}\``,
-        {
-          cause: error
-        }
-      );
+    } catch {
+      return false;
     }
   }
   async deleteTag(tag) {
@@ -4665,8 +5126,8 @@ var Git = class {
       });
     }
   }
-  async push(options2) {
-    const args = ["push", options2].filter((v) => v);
+  async push(options) {
+    const args = ["push", options].filter((v) => v);
     try {
       const { stderr } = await exec2("git", args, { throwOnError: true });
       if (`${stderr}`.includes("GH006")) {
@@ -4692,17 +5153,17 @@ var defaultOptions = {
   tag: "latest",
   registries: ["npm", "jsr"]
 };
-function resolveOptions(options2) {
-  const nextOptions = { ...options2, ...defaultOptions };
+function resolveOptions(options) {
+  const nextOptions = { ...options, ...defaultOptions };
   return nextOptions;
 }
 
 // src/tasks/runner.ts
-import process10 from "node:process";
+import process14 from "node:process";
 import npmCli from "@npmcli/promise-spawn";
 import SemVer from "semver";
 import { isCI as isCI2 } from "std-env";
-import { exec as exec6 } from "tinyexec";
+import { exec as exec7 } from "tinyexec";
 
 // src/utils/cli.ts
 var warningBadge = color.bgYellow(" Warning ");
@@ -4735,32 +5196,32 @@ function createListr(...args) {
 
 // src/utils/package.ts
 import { readFile, stat, writeFile } from "node:fs/promises";
-import path from "node:path";
-import process7 from "node:process";
+import path6 from "node:path";
+import process11 from "node:process";
 var cachedPackageJson = {};
 var cachedJsrJson = {};
-function patchCachedJsrJson(contents, { cwd = process7.cwd() } = {}) {
+function patchCachedJsrJson(contents, { cwd = process11.cwd() } = {}) {
   cachedJsrJson[cwd] = { ...cachedJsrJson[cwd], ...contents };
 }
-async function findOutFile(file, { cwd = process7.cwd() } = {}) {
+async function findOutFile(file, { cwd = process11.cwd() } = {}) {
   let directory = cwd;
   let filePath = "";
-  const { root } = path.parse(cwd);
+  const { root } = path6.parse(cwd);
   while (directory) {
-    filePath = path.join(directory, file);
+    filePath = path6.join(directory, file);
     try {
       if ((await stat(filePath)).isFile()) {
         break;
       }
     } catch {
     }
-    directory = path.dirname(directory);
+    directory = path6.dirname(directory);
     if (directory === root) return null;
   }
   return filePath;
 }
 async function getPackageJson({
-  cwd = process7.cwd(),
+  cwd = process11.cwd(),
   fallbackJsr = true
 } = {}) {
   if (cachedPackageJson[cwd]) return cachedPackageJson[cwd];
@@ -4793,7 +5254,7 @@ async function getPackageJson({
   }
 }
 async function getJsrJson({
-  cwd = process7.cwd(),
+  cwd = process11.cwd(),
   fallbackPackage = true
 } = {}) {
   if (cachedJsrJson[cwd]) return cachedJsrJson[cwd];
@@ -4871,7 +5332,7 @@ function jsrJsonToPackageJson(jsrJson) {
     return convertedExports;
   }
 }
-async function version({ cwd = process7.cwd() } = {}) {
+async function version({ cwd = process11.cwd() } = {}) {
   let version2 = (await getPackageJson({ cwd }))?.version;
   if (!version2) {
     version2 = (await getJsrJson({ cwd }))?.version;
@@ -4924,17 +5385,222 @@ async function getPackageManager() {
   return "npm";
 }
 
+// src/ecosystem/rust.ts
+import { readFile as readFile2, stat as stat2, writeFile as writeFile2 } from "node:fs/promises";
+import path7 from "node:path";
+import { parse, stringify } from "smol-toml";
+
+// 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 stat2(path7.join(packagePath, "Cargo.toml"))).isFile();
+    } catch {
+      return false;
+    }
+  }
+  async readCargoToml() {
+    const raw = await readFile2(
+      path7.join(this.packagePath, "Cargo.toml"),
+      "utf-8"
+    );
+    return 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 = path7.join(this.packagePath, "Cargo.toml");
+    const raw = await readFile2(filePath, "utf-8");
+    const cargo = parse(raw);
+    const pkg = cargo.package;
+    pkg.version = newVersion;
+    await writeFile2(filePath, stringify(cargo));
+  }
+  manifestFiles() {
+    return ["Cargo.toml"];
+  }
+  defaultTestCommand() {
+    return "cargo test";
+  }
+  defaultBuildCommand() {
+    return "cargo build --release";
+  }
+  supportedRegistries() {
+    return ["crates"];
+  }
+};
+
+// src/registry/crates.ts
+import { exec as exec3 } from "tinyexec";
+
+// src/registry/registry.ts
+var Registry = class {
+  constructor(packageName, registry) {
+    this.packageName = packageName;
+    this.registry = registry;
+  }
+};
+
+// src/registry/crates.ts
+var CratesError = class extends AbstractError {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "name", "crates.io Error");
+  }
+};
+var USER_AGENT = "pubm (https://github.com/syi0808/pubm)";
+var CratesRegistry = class extends Registry {
+  constructor() {
+    super(...arguments);
+    __publicField(this, "registry", "https://crates.io");
+  }
+  get headers() {
+    return { "User-Agent": USER_AGENT };
+  }
+  async ping() {
+    try {
+      const response = await fetch(`${this.registry}/api/v1`, {
+        headers: this.headers
+      });
+      return response.ok;
+    } catch (error) {
+      throw new CratesError("Failed to ping crates.io", { cause: error });
+    }
+  }
+  async isInstalled() {
+    try {
+      await exec3("cargo", ["--version"]);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async distTags() {
+    return [];
+  }
+  async version() {
+    try {
+      const response = await fetch(
+        `${this.registry}/api/v1/crates/${this.packageName}`,
+        { headers: this.headers }
+      );
+      if (!response.ok) {
+        throw new Error(`Crate '${this.packageName}' not found`);
+      }
+      const data = await response.json();
+      return data.crate.max_version;
+    } catch (error) {
+      throw new CratesError(
+        `Failed to fetch version for crate '${this.packageName}'`,
+        { cause: error }
+      );
+    }
+  }
+  async publish() {
+    try {
+      await exec3("cargo", ["publish"], { throwOnError: true });
+      return true;
+    } catch (error) {
+      throw new CratesError("Failed to run `cargo publish`", {
+        cause: error
+      });
+    }
+  }
+  async isPublished() {
+    try {
+      const response = await fetch(
+        `${this.registry}/api/v1/crates/${this.packageName}`,
+        { headers: this.headers }
+      );
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  async hasPermission() {
+    if (process.env.CARGO_REGISTRY_TOKEN) return true;
+    return this.isInstalled();
+  }
+  async isPackageNameAvaliable() {
+    try {
+      const response = await fetch(
+        `${this.registry}/api/v1/crates/${this.packageName}`,
+        { headers: this.headers }
+      );
+      return !response.ok;
+    } catch {
+      return true;
+    }
+  }
+};
+async function cratesRegistry(packageName) {
+  return new CratesRegistry(packageName);
+}
+
+// src/tasks/crates.ts
+var CratesError2 = class extends AbstractError {
+  constructor(message, { cause } = {}) {
+    super(message, { cause });
+    __publicField(this, "name", "crates.io Error");
+    this.stack = "";
+  }
+};
+async function getCrateName() {
+  const eco = new RustEcosystem(process.cwd());
+  return await eco.packageName();
+}
+var cratesAvailableCheckTasks = {
+  title: "Checking crates.io availability",
+  task: async () => {
+    const packageName = await getCrateName();
+    const registry = new CratesRegistry(packageName);
+    if (!await registry.isInstalled()) {
+      throw new CratesError2(
+        "cargo is not installed. Please install Rust toolchain to proceed."
+      );
+    }
+    if (!await registry.hasPermission()) {
+      throw new CratesError2(
+        "No crates.io credentials found. Run `cargo login` or set CARGO_REGISTRY_TOKEN."
+      );
+    }
+  }
+};
+var cratesPublishTasks = {
+  title: "Publishing to crates.io",
+  task: async () => {
+    const packageName = await getCrateName();
+    const registry = new CratesRegistry(packageName);
+    await registry.publish();
+  }
+};
+
 // src/tasks/jsr.ts
-import process8 from "node:process";
+import process12 from "node:process";
 import { ListrEnquirerPromptAdapter } from "@listr2/prompt-adapter-enquirer";
 
 // src/registry/jsr.ts
-import { exec as exec3 } from "tinyexec";
+import { NonZeroExitError, exec as exec4 } from "tinyexec";
 
 // src/utils/db.ts
 import { createCipheriv, createDecipheriv, createHash } from "node:crypto";
-import { mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
-import path2 from "node:path";
+import { mkdirSync as mkdirSync5, readFileSync as readFileSync3, statSync, writeFileSync as writeFileSync4 } from "node:fs";
+import path8 from "node:path";
 var a = "aes-256-cbc";
 var n = statSync(import.meta.dirname);
 var k = `${n.rdev}${n.birthtimeMs}${n.nlink}${n.gid}`;
@@ -4949,18 +5615,18 @@ function d(g, h) {
 }
 var Db = class {
   constructor() {
-    __publicField(this, "path", path2.resolve(import.meta.dirname, ".pubm"));
+    __publicField(this, "path", path8.resolve(import.meta.dirname, ".pubm"));
     try {
       if (!statSync(this.path).isDirectory()) {
-        mkdirSync(this.path);
+        mkdirSync5(this.path);
       }
     } catch {
-      mkdirSync(this.path);
+      mkdirSync5(this.path);
     }
   }
   set(field, value) {
-    writeFileSync(
-      path2.resolve(this.path, Buffer.from(e(field, field)).toString("base64")),
+    writeFileSync4(
+      path8.resolve(this.path, Buffer.from(e(field, field)).toString("base64")),
       Buffer.from(e(`${value}`, field)),
       { encoding: "binary" }
     );
@@ -4969,8 +5635,8 @@ var Db = class {
     try {
       return d(
         Buffer.from(
-          readFileSync(
-            path2.resolve(
+          readFileSync3(
+            path8.resolve(
               this.path,
               Buffer.from(e(field, field)).toString("base64")
             )
@@ -5025,14 +5691,6 @@ function isValidPackageName(packageName) {
   return true;
 }
 
-// src/registry/registry.ts
-var Registry = class {
-  constructor(packageName, registry) {
-    this.packageName = packageName;
-    this.registry = registry;
-  }
-};
-
 // src/registry/jsr.ts
 var JsrError = class extends AbstractError {
   constructor() {
@@ -5053,13 +5711,12 @@ var JsrRegisry = class extends Registry {
     this.client = new JsrClient(getApiEndpoint(this.registry));
   }
   async jsr(args) {
-    const { stdout, stderr } = await exec3("jsr", args);
-    if (stderr) throw stderr;
+    const { stdout } = await exec4("jsr", args, { throwOnError: true });
     return stdout;
   }
   async isInstalled() {
     try {
-      await this.jsr(["--help"]);
+      await this.jsr(["--version"]);
       return true;
     } catch {
       return false;
@@ -5070,12 +5727,11 @@ var JsrRegisry = class extends Registry {
   }
   async ping() {
     try {
-      const { stdout, stderr } = await exec3("ping", [
-        new URL(this.registry).hostname,
-        "-c",
-        "1"
-      ]);
-      if (stderr) throw stderr;
+      const { stdout } = await exec4(
+        "ping",
+        [new URL(this.registry).hostname, "-c", "1"],
+        { throwOnError: true }
+      );
       return stdout.includes("1 packets transmitted");
     } catch (error) {
       throw new JsrError(
@@ -5086,7 +5742,7 @@ var JsrRegisry = class extends Registry {
   }
   async publish() {
     try {
-      await exec3(
+      await exec4(
         "jsr",
         ["publish", "--allow-dirty", "--token", `${JsrClient.token}`],
         {
@@ -5095,8 +5751,10 @@ var JsrRegisry = class extends Registry {
       );
       return true;
     } catch (error) {
+      const stderr = error instanceof NonZeroExitError ? error.output?.stderr : void 0;
       throw new JsrError(
-        "Failed to run `jsr publish --allow-dirty --token ***`",
+        `Failed to run \`jsr publish --allow-dirty --token ***\`${stderr ? `
+${stderr}` : ""}`,
         {
           cause: error
         }
@@ -5277,7 +5935,7 @@ async function jsrRegistry() {
 }
 
 // src/registry/npm.ts
-import { exec as exec4 } from "tinyexec";
+import { NonZeroExitError as NonZeroExitError2, exec as exec5 } from "tinyexec";
 var NpmError = class extends AbstractError {
   constructor() {
     super(...arguments);
@@ -5290,13 +5948,12 @@ var NpmRegistry = class extends Registry {
     __publicField(this, "registry", "https://registry.npmjs.org");
   }
   async npm(args) {
-    const { stdout, stderr } = await exec4("npm", args);
-    if (stderr) throw stderr;
+    const { stdout } = await exec5("npm", args, { throwOnError: true });
     return stdout;
   }
   async isInstalled() {
     try {
-      await this.npm(["--help"]);
+      await this.npm(["--version"]);
       return true;
     } catch {
       return false;
@@ -5335,7 +5992,7 @@ var NpmRegistry = class extends Registry {
       await this.npm(["whoami"]);
       return true;
     } catch (error) {
-      if (`${error}`.includes("ENEEDAUTH")) {
+      if (error instanceof NonZeroExitError2 && error.output?.stderr.includes("ENEEDAUTH")) {
         return false;
       }
       throw new NpmError("Failed to run `npm whoami`", { cause: error });
@@ -5387,7 +6044,7 @@ var NpmRegistry = class extends Registry {
   }
   async ping() {
     try {
-      await exec4("npm", ["ping"], { throwOnError: true });
+      await exec5("npm", ["ping"], { throwOnError: true });
       return true;
     } catch (error) {
       throw new NpmError("Failed to run `npm ping`", { cause: error });
@@ -5395,15 +6052,12 @@ var NpmRegistry = class extends Registry {
   }
   async publishProvenance() {
     try {
-      try {
-        await this.npm(["publish", "--provenance", "--access", "public"]);
-      } catch (error) {
-        if (`${error}`.includes("EOTP")) {
-          return false;
-        }
-      }
+      await this.npm(["publish", "--provenance", "--access", "public"]);
       return true;
     } catch (error) {
+      if (error instanceof NonZeroExitError2 && error.output?.stderr.includes("EOTP")) {
+        return false;
+      }
       throw new NpmError(
         "Failed to run `npm publish --provenance --access public`",
         {
@@ -5415,15 +6069,12 @@ var NpmRegistry = class extends Registry {
   async publish(otp) {
     const args = otp ? ["publish", "--otp", otp] : ["publish"];
     try {
-      try {
-        await this.npm(args);
-      } catch (error) {
-        if (`${error}`.includes("EOTP")) {
-          return false;
-        }
-      }
+      await this.npm(args);
       return true;
     } catch (error) {
+      if (error instanceof NonZeroExitError2 && error.output?.stderr.includes("EOTP")) {
+        return false;
+      }
       throw new NpmError(`Failed to run \`npm ${args.join(" ")}\``, {
         cause: error
       });
@@ -5477,7 +6128,7 @@ Generate a token from ${color.bold(link2("jsr.io", "https://jsr.io/account/token
           }
         }
       } else {
-        const jsrTokenEnv = process8.env.JSR_TOKEN;
+        const jsrTokenEnv = process12.env.JSR_TOKEN;
         if (!jsrTokenEnv)
           throw new JsrAvailableError(
             "JSR_TOKEN not found in the environment variables. Please set the token and try again."
@@ -5594,7 +6245,7 @@ var jsrPublishTasks = {
     const jsr = await jsrRegistry();
     task.output = "Publishing on jsr...";
     if (!JsrClient.token && !ctx.promptEnabled) {
-      const jsrTokenEnv = process8.env.JSR_TOKEN;
+      const jsrTokenEnv = process12.env.JSR_TOKEN;
       if (!jsrTokenEnv) {
         throw new JsrAvailableError(
           "JSR_TOKEN not found in the environment variables. Please set the token and try again."
@@ -5607,7 +6258,7 @@ var jsrPublishTasks = {
 };
 
 // src/tasks/npm.ts
-import process9 from "node:process";
+import process13 from "node:process";
 import { ListrEnquirerPromptAdapter as ListrEnquirerPromptAdapter2 } from "@listr2/prompt-adapter-enquirer";
 var NpmAvailableError = class extends AbstractError {
   constructor(message, { cause } = {}) {
@@ -5666,7 +6317,7 @@ var npmPublishTasks = {
         task.title = "Running npm publish (2FA passed)";
       }
     } else {
-      const npmTokenEnv = process9.env.NODE_AUTH_TOKEN;
+      const npmTokenEnv = process13.env.NODE_AUTH_TOKEN;
       if (!npmTokenEnv) {
         throw new NpmAvailableError(
           "NODE_AUTH_TOKEN not found in the environment variables. Please set the token and try again."
@@ -5691,10 +6342,10 @@ var PrerequisitesCheckError = class extends AbstractError {
     this.stack = "";
   }
 };
-var prerequisitesCheckTask = (options2) => {
+var prerequisitesCheckTask = (options) => {
   const git = new Git();
   return createListr({
-    ...options2,
+    ...options,
     exitOnError: true,
     title: "Prerequisites check (for deployment reliability)",
     task: (_, parentTask) => parentTask.newListr([
@@ -5831,14 +6482,14 @@ var prerequisitesCheckTask = (options2) => {
 import { ListrEnquirerPromptAdapter as ListrEnquirerPromptAdapter4 } from "@listr2/prompt-adapter-enquirer";
 
 // src/registry/custom-registry.ts
-import { exec as exec5 } from "tinyexec";
+import { exec as exec6 } from "tinyexec";
 var CustomRegistry = class extends NpmRegistry {
   async npm(args) {
-    const { stdout, stderr } = await exec5(
+    const { stdout } = await exec6(
       "npm",
-      args.concat("--registry", this.registry)
+      args.concat("--registry", this.registry),
+      { throwOnError: true }
     );
-    if (stderr) throw stderr;
     return stdout;
   }
 };
@@ -5852,7 +6503,10 @@ var registryMap = {
   npm: npmRegistry,
   jsr: jsrRegistry
 };
-async function getRegistry(registryKey) {
+async function getRegistry(registryKey, packageName) {
+  if (registryKey === "crates") {
+    return await cratesRegistry(packageName ?? "unknown");
+  }
   const registry = registryMap[registryKey];
   if (!registry) {
     return await customRegistry();
@@ -5879,8 +6533,8 @@ var RequiredConditionCheckError = class extends AbstractError {
     this.stack = "";
   }
 };
-var requiredConditionsCheckTask = (options2) => createListr({
-  ...options2,
+var requiredConditionsCheckTask = (options) => createListr({
+  ...options,
   title: "Required conditions check (for pubm tasks)",
   task: (_, parentTask) => parentTask.newListr(
     [
@@ -5982,6 +6636,8 @@ var requiredConditionsCheckTask = (options2) => createListr({
                 return npmAvailableCheckTasks;
               case "jsr":
                 return jsrAvailableCheckTasks;
+              case "crates":
+                return cratesAvailableCheckTasks;
               default:
                 return npmAvailableCheckTasks;
             }
@@ -6001,25 +6657,25 @@ var requiredConditionsCheckTask = (options2) => createListr({
 // src/tasks/runner.ts
 var { open } = npmCli;
 var { prerelease } = SemVer;
-async function run(options2) {
+async function run(options) {
   const ctx = {
-    ...options2,
-    promptEnabled: !isCI2 && process10.stdin.isTTY,
-    npmOnly: options2.registries.every((registry) => registry !== "jsr"),
-    jsrOnly: options2.registries.every((registry) => registry === "jsr")
+    ...options,
+    promptEnabled: !isCI2 && process14.stdin.isTTY,
+    npmOnly: options.registries.every((registry) => registry !== "jsr"),
+    jsrOnly: options.registries.every((registry) => registry === "jsr")
   };
   try {
-    if (options2.contents) process10.chdir(options2.contents);
-    if (!options2.publishOnly) {
+    if (options.contents) process14.chdir(options.contents);
+    if (!options.publishOnly) {
       await prerequisitesCheckTask({
-        skip: options2.skipPrerequisitesCheck
+        skip: options.skipPrerequisitesCheck
       }).run(ctx);
       await requiredConditionsCheckTask({
-        skip: options2.skipConditionsCheck
+        skip: options.skipConditionsCheck
       }).run(ctx);
     }
     await createListr(
-      options2.publishOnly ? {
+      options.publishOnly ? {
         title: "Publishing",
         task: (ctx2, parentTask) => parentTask.newListr(
           ctx2.registries.map((registry) => {
@@ -6028,6 +6684,8 @@ async function run(options2) {
                 return npmPublishTasks;
               case "jsr":
                 return jsrPublishTasks;
+              case "crates":
+                return cratesPublishTasks;
               default:
                 return npmPublishTasks;
             }
@@ -6036,29 +6694,22 @@ async function run(options2) {
         )
       } : [
         {
-          skip: options2.skipTests,
+          skip: options.skipTests,
           title: "Running tests",
           task: async (ctx2) => {
             const packageManager = await getPackageManager();
-            const { stderr } = await exec6(packageManager, [
-              "run",
-              ctx2.testScript
-            ]);
-            if (stderr) {
-              throw new AbstractError(
-                `Failed to run \`${packageManager} run ${ctx2.testScript}\``,
-                { cause: stderr }
-              );
-            }
+            await exec7(packageManager, ["run", ctx2.testScript], {
+              throwOnError: true
+            });
           }
         },
         {
-          skip: options2.skipBuild,
+          skip: options.skipBuild,
           title: "Building the project",
           task: async (ctx2) => {
             const packageManager = await getPackageManager();
             try {
-              await exec6(packageManager, ["run", ctx2.buildScript], {
+              await exec7(packageManager, ["run", ctx2.buildScript], {
                 throwOnError: true
               });
             } catch (error) {
@@ -6103,7 +6754,7 @@ async function run(options2) {
           }
         },
         {
-          skip: (ctx2) => options2.skipPublish || !!ctx2.preview,
+          skip: (ctx2) => options.skipPublish || !!ctx2.preview,
           title: "Publishing",
           task: (ctx2, parentTask) => parentTask.newListr(
             ctx2.registries.map((registry) => {
@@ -6112,6 +6763,8 @@ async function run(options2) {
                   return npmPublishTasks;
                 case "jsr":
                   return jsrPublishTasks;
+                case "crates":
+                  return cratesPublishTasks;
                 default:
                   return npmPublishTasks;
               }
@@ -6132,7 +6785,7 @@ async function run(options2) {
           }
         },
         {
-          skip: (ctx2) => options2.skipReleaseDraft || !!ctx2.preview,
+          skip: (ctx2) => options.skipReleaseDraft || !!ctx2.preview,
           title: "Creating release draft on GitHub",
           task: async (ctx2, task) => {
             const git = new Git();
@@ -6173,13 +6826,36 @@ ${repositoryUrl}/compare/${lastRev}...${latestTag}`;
   } catch (e2) {
     consoleError(e2);
     await rollback();
-    process10.exit(1);
+    process14.exit(1);
   }
 }
 
+// src/changeset/version.ts
+import process15 from "node:process";
+import { inc } from "semver";
+
+// src/config/loader.ts
+import { stat as stat3 } from "node:fs/promises";
+import path9 from "node:path";
+
+// src/monorepo/groups.ts
+import micromatch from "micromatch";
+
+// src/monorepo/workspace.ts
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "node:fs";
+import { join } from "node:path";
+import { parse as parse2 } from "yaml";
+
+// src/validate/entry-points.ts
+import { existsSync as existsSync6 } from "node:fs";
+import path10 from "node:path";
+
+// src/validate/extraneous-files.ts
+import micromatch2 from "micromatch";
+
 // src/index.ts
-async function pubm(options2) {
-  const resolvedOptions = resolveOptions({ ...options2 });
+async function pubm(options) {
+  const resolvedOptions = resolveOptions({ ...options });
   await run(resolvedOptions);
 }
 
@@ -6187,8 +6863,8 @@ async function pubm(options2) {
 import { ListrEnquirerPromptAdapter as ListrEnquirerPromptAdapter5 } from "@listr2/prompt-adapter-enquirer";
 import semver2 from "semver";
 var { RELEASE_TYPES, SemVer: SemVer2, prerelease: prerelease2 } = semver2;
-var requiredMissingInformationTasks = (options2) => createListr({
-  ...options2,
+var requiredMissingInformationTasks = (options) => createListr({
+  ...options,
   title: "Checking required information",
   task: (_, parentTask) => parentTask.newListr([
     {
@@ -6259,63 +6935,18 @@ var requiredMissingInformationTasks = (options2) => createListr({
 });
 
 // src/utils/notify-new-version.ts
-import { exec as exec7 } from "tinyexec";
+import { UpdateKit as UpdateKit2 } from "update-kit";
 async function notifyNewVersion() {
-  const currentVersion = await version({ cwd: import.meta.dirname });
-  await Promise.all([
-    (async () => {
-      try {
-        const packageJson = await findOutFile("package.json", {
-          cwd: import.meta.dirname
-        });
-        if (!packageJson) return void 0;
-        const { name } = await getPackageJson({
-          cwd: import.meta.dirname,
-          fallbackJsr: false
-        });
-        const { stdout } = await exec7("npm", ["info", name, "version"]);
-        const newVersion = stdout.trim();
-        if (newVersion !== currentVersion) {
-          console.log(
-            `
-Update available! \`${name}\` ${color.red(currentVersion)} \u2192 ${color.green(newVersion)}
-`
-          );
-        }
-      } catch {
-      }
-    })(),
-    (async () => {
-      try {
-        const jsrJson = await findOutFile("jsr.json", {
-          cwd: import.meta.dirname
-        });
-        if (!jsrJson) return void 0;
-        const { name } = await getJsrJson({
-          cwd: import.meta.dirname,
-          fallbackPackage: false
-        });
-        const [scope, packageName] = getScopeAndName(name);
-        const response = await fetch(
-          `https://api.jsr.io/scopes/${scope}/packages/${packageName}/versions`
-        );
-        const newVersion = (await response.json())?.[0]?.version;
-        if (newVersion && newVersion !== currentVersion) {
-          console.log(
-            `
-Update available! \`${name}\` ${color.red(currentVersion)} \u2192 ${color.green(newVersion)}
-`
-          );
-        }
-      } catch {
-      }
-    })()
-  ]);
+  const kit = await UpdateKit2.create({
+    sources: [{ type: "npm", packageName: "pubm" }]
+  });
+  const banner = await kit.checkAndNotify();
+  if (banner) console.error(banner);
 }
 
 // src/cli.ts
 var { RELEASE_TYPES: RELEASE_TYPES2, valid } = semver3;
-var options = [
+var publishOptions = [
   {
     rawName: "--test-script <script>",
     description: "The npm script to run tests before publishing",
@@ -6338,7 +6969,7 @@ var options = [
   },
   {
     rawName: "-a, --any-branch",
-    description: "Show tasks without actually executing publish",
+    description: "Allow publishing from any branch",
     options: { type: Boolean }
   },
   {
@@ -6397,35 +7028,44 @@ var options = [
     options: { type: String, default: "npm,jsr" }
   }
 ];
-var cli = cac("pubm");
-for (const option of options) {
-  cli.option(option.rawName, option.description, option.options);
-}
-function resolveCliOptions(options2) {
+function resolveCliOptions(options) {
   return {
-    ...options2,
-    skipPublish: !options2.publish,
-    skipReleaseDraft: !options2.releaseDraft,
-    skipTests: !options2.tests,
-    skipBuild: !options2.build,
-    registries: options2.registry?.split(","),
-    skipPrerequisitesCheck: !options2.preCheck,
-    skipConditionsCheck: !options2.conditionCheck
+    ...options,
+    skipPublish: !options.publish,
+    skipReleaseDraft: !options.releaseDraft,
+    skipTests: !options.tests,
+    skipBuild: !options.build,
+    registries: options.registry?.split(","),
+    skipPrerequisitesCheck: !options.preCheck,
+    skipConditionsCheck: !options.conditionCheck
   };
 }
-cli.command("[version]").action(
-  async (nextVersion, options2) => {
+var cli = cac("pubm");
+registerAddCommand(cli);
+registerVersionCommand(cli);
+registerStatusCommand(cli);
+registerPreCommand(cli);
+registerSnapshotCommand(cli);
+registerInitCommand(cli);
+registerMigrateCommand(cli);
+registerUpdateCommand(cli);
+var defaultCmd = cli.command("[version]", "Publish packages to registries");
+for (const option of publishOptions) {
+  defaultCmd.option(option.rawName, option.description, option.options);
+}
+defaultCmd.action(
+  async (nextVersion, options) => {
     console.clear();
     if (!isCI3) {
       await notifyNewVersion();
     }
     const context = {
       version: nextVersion,
-      tag: options2.tag
+      tag: options.tag
     };
     try {
       if (isCI3) {
-        if (options2.publishOnly) {
+        if (options.publishOnly) {
           const git = new Git();
           const latestVersion = (await git.latestTag())?.slice(1);
           if (!latestVersion) {
@@ -6449,7 +7089,7 @@ cli.command("[version]").action(
       }
       await pubm(
         resolveCliOptions({
-          ...options2,
+          ...options,
           version: context.version,
           tag: context.tag
         })
@@ -6474,3 +7114,6 @@ cli.help((sections) => {
   cli.version(await version({ cwd: import.meta.dirname }));
   cli.parse();
 })();
+export {
+  resolveCliOptions
+};