pubm 0.0.4 → 0.1.2

package/dist/index.js

@@ -711,7 +711,7 @@ 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);
@@ -793,7 +793,7 @@ var init_mjs = __esm({
       }
     };
     SignalExit = class extends SignalExitBase {
-      constructor(process11) {
+      constructor(process16) {
         super();
         __privateAdd(this, _SignalExit_instances);
         // "SIGHUP" throws an `ENOSYS` error on Windows,
@@ -807,13 +807,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;
             }
@@ -822,12 +822,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))) {
@@ -4376,7 +4376,7 @@ var Listr = (_a23 = class {
 // src/tasks/runner.ts
 import SemVer from "semver";
 import { isCI as isCI2 } from "std-env";
-import { exec as exec6 } from "tinyexec";
+import { exec as exec7 } from "tinyexec";
 
 // src/error.ts
 var AbstractError = class extends Error {
@@ -4391,10 +4391,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);
@@ -4425,8 +4428,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() {
@@ -4447,7 +4449,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
@@ -4457,7 +4459,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;
     }
@@ -4562,13 +4565,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) {
@@ -4919,17 +4917,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 path2 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(path2.join(packagePath, "Cargo.toml"))).isFile();
+    } catch {
+      return false;
+    }
+  }
+  async readCargoToml() {
+    const raw = await readFile2(
+      path2.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 = path2.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 { 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 path3 from "node:path";
 var a = "aes-256-cbc";
 var n = statSync(import.meta.dirname);
 var k = `${n.rdev}${n.birthtimeMs}${n.nlink}${n.gid}`;
@@ -4944,7 +5147,7 @@ function d(g, h) {
 }
 var Db = class {
   constructor() {
-    __publicField(this, "path", path2.resolve(import.meta.dirname, ".pubm"));
+    __publicField(this, "path", path3.resolve(import.meta.dirname, ".pubm"));
     try {
       if (!statSync(this.path).isDirectory()) {
         mkdirSync(this.path);
@@ -4955,7 +5158,7 @@ var Db = class {
   }
   set(field, value) {
     writeFileSync(
-      path2.resolve(this.path, Buffer.from(e(field, field)).toString("base64")),
+      path3.resolve(this.path, Buffer.from(e(field, field)).toString("base64")),
       Buffer.from(e(`${value}`, field)),
       { encoding: "binary" }
     );
@@ -4965,7 +5168,7 @@ var Db = class {
       return d(
         Buffer.from(
           readFileSync(
-            path2.resolve(
+            path3.resolve(
               this.path,
               Buffer.from(e(field, field)).toString("base64")
             )
@@ -5020,14 +5223,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() {
@@ -5048,13 +5243,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;
@@ -5065,12 +5259,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(
@@ -5081,7 +5274,7 @@ var JsrRegisry = class extends Registry {
   }
   async publish() {
     try {
-      await exec3(
+      await exec4(
         "jsr",
         ["publish", "--allow-dirty", "--token", `${JsrClient.token}`],
         {
@@ -5090,8 +5283,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
         }
@@ -5272,7 +5467,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);
@@ -5285,13 +5480,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;
@@ -5330,7 +5524,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 });
@@ -5382,7 +5576,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 });
@@ -5390,15 +5584,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`",
         {
@@ -5410,15 +5601,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
       });
@@ -5826,14 +6014,14 @@ var prerequisitesCheckTask = (options) => {
 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;
   }
 };
@@ -5847,7 +6035,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();
@@ -5977,6 +6168,8 @@ var requiredConditionsCheckTask = (options) => createListr({
                 return npmAvailableCheckTasks;
               case "jsr":
                 return jsrAvailableCheckTasks;
+              case "crates":
+                return cratesAvailableCheckTasks;
               default:
                 return npmAvailableCheckTasks;
             }
@@ -6023,6 +6216,8 @@ async function run(options) {
                 return npmPublishTasks;
               case "jsr":
                 return jsrPublishTasks;
+              case "crates":
+                return cratesPublishTasks;
               default:
                 return npmPublishTasks;
             }
@@ -6035,16 +6230,9 @@ async function run(options) {
           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
+            });
           }
         },
         {
@@ -6053,7 +6241,7 @@ async function run(options) {
           task: async (ctx2) => {
             const packageManager = await getPackageManager();
             try {
-              await exec6(packageManager, ["run", ctx2.buildScript], {
+              await exec7(packageManager, ["run", ctx2.buildScript], {
                 throwOnError: true
               });
             } catch (error) {
@@ -6107,6 +6295,8 @@ async function run(options) {
                   return npmPublishTasks;
                 case "jsr":
                   return jsrPublishTasks;
+                case "crates":
+                  return cratesPublishTasks;
                 default:
                   return npmPublishTasks;
               }
@@ -6172,11 +6362,719 @@ ${repositoryUrl}/compare/${lastRev}...${latestTag}`;
   }
 }
 
+// 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/changelog.ts
+var SECTION_ORDER = [
+  { type: "major", heading: "Major Changes" },
+  { type: "minor", heading: "Minor Changes" },
+  { type: "patch", heading: "Patch Changes" }
+];
+function generateChangelog(version2, entries, depUpdates) {
+  const lines = [`## ${version2}`];
+  for (const section of SECTION_ORDER) {
+    const sectionEntries = entries.filter((e2) => e2.type === section.type);
+    if (sectionEntries.length === 0) continue;
+    lines.push("");
+    lines.push(`### ${section.heading}`);
+    lines.push("");
+    for (const entry of sectionEntries) {
+      lines.push(`- ${entry.summary}`);
+    }
+  }
+  if (depUpdates && depUpdates.length > 0) {
+    lines.push("");
+    lines.push("### Dependency Updates");
+    lines.push("");
+    for (const dep of depUpdates) {
+      lines.push(`- Updated \`${dep.name}\` to ${dep.version}`);
+    }
+  }
+  return `${lines.join("\n")}
+`;
+}
+
+// src/changeset/migrate.ts
+import { copyFileSync, existsSync, mkdirSync as mkdirSync2, readdirSync } from "node:fs";
+import path4 from "node:path";
+import process11 from "node:process";
+var SKIPPED_FILES = /* @__PURE__ */ new Set(["config.json", "README.md"]);
+function migrateFromChangesets(cwd = process11.cwd()) {
+  const changesetDir = path4.join(cwd, ".changeset");
+  if (!existsSync(changesetDir)) {
+    return {
+      success: false,
+      error: ".changeset/ directory not found",
+      migratedFiles: [],
+      configMigrated: false
+    };
+  }
+  const pubmDir = path4.join(cwd, ".pubm", "changesets");
+  mkdirSync2(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(
+        path4.join(changesetDir, file),
+        path4.resolve(cwd, ".pubm", "pre.json")
+      );
+      migratedFiles.push(file);
+      continue;
+    }
+    if (file.endsWith(".md")) {
+      const src = path4.join(changesetDir, file);
+      const dest = path4.join(pubmDir, file);
+      copyFileSync(src, dest);
+      migratedFiles.push(file);
+    }
+  }
+  return {
+    success: true,
+    migratedFiles,
+    configMigrated
+  };
+}
+
+// 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
+import { existsSync as existsSync2, readdirSync as readdirSync2, readFileSync as readFileSync2 } from "node:fs";
+import path5 from "node:path";
+import process12 from "node:process";
+function readChangesets(cwd = process12.cwd()) {
+  const changesetsDir = path5.join(cwd, ".pubm", "changesets");
+  if (!existsSync2(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
+import process13 from "node:process";
+function getStatus(cwd = process13.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/changeset/version.ts
+import process14 from "node:process";
+import { inc } from "semver";
+function calculateVersionBumps(currentVersions, cwd = process14.cwd()) {
+  const changesets = readChangesets(cwd);
+  const bumpTypes = /* @__PURE__ */ new Map();
+  for (const changeset of changesets) {
+    for (const release of changeset.releases) {
+      if (!currentVersions.has(release.name)) continue;
+      const existing = bumpTypes.get(release.name);
+      if (existing) {
+        bumpTypes.set(release.name, maxBump(existing, release.type));
+      } else {
+        bumpTypes.set(release.name, release.type);
+      }
+    }
+  }
+  const result = /* @__PURE__ */ new Map();
+  for (const [name, bumpType] of bumpTypes) {
+    const currentVersion = currentVersions.get(name);
+    if (!currentVersion) continue;
+    const newVersion = inc(currentVersion, bumpType);
+    if (newVersion) {
+      result.set(name, {
+        currentVersion,
+        newVersion,
+        bumpType
+      });
+    }
+  }
+  return result;
+}
+
+// src/changeset/writer.ts
+import { mkdirSync as mkdirSync3, writeFileSync as writeFileSync2 } from "node:fs";
+import path6 from "node:path";
+import process15 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 = process15.cwd()) {
+  const changesetsDir = path6.join(cwd, ".pubm", "changesets");
+  mkdirSync3(changesetsDir, { recursive: true });
+  const id = generateChangesetId();
+  const fileName = `${id}.md`;
+  const filePath = path6.join(changesetsDir, fileName);
+  const content = generateChangesetContent(releases, summary);
+  writeFileSync2(filePath, content, "utf-8");
+  return filePath;
+}
+
+// src/config/defaults.ts
+var defaultValidate = {
+  cleanInstall: true,
+  entryPoints: true,
+  extraneousFiles: true
+};
+var defaultSnapshot = {
+  useCalculatedVersion: false,
+  prereleaseTemplate: "{tag}-{timestamp}"
+};
+var defaultConfig = {
+  versioning: "independent",
+  branch: "main",
+  changelog: true,
+  changelogFormat: "default",
+  commit: false,
+  access: "public",
+  fixed: [],
+  linked: [],
+  updateInternalDependencies: "patch",
+  ignore: [],
+  tag: "latest",
+  contents: ".",
+  saveToken: true,
+  releaseDraft: true,
+  releaseNotes: true,
+  registries: ["npm", "jsr"],
+  rollbackStrategy: "individual"
+};
+function resolveConfig(config) {
+  const packages = config.packages ?? [
+    { path: ".", registries: ["npm", "jsr"] }
+  ];
+  return {
+    ...defaultConfig,
+    ...config,
+    packages,
+    validate: { ...defaultValidate, ...config.validate },
+    snapshot: { ...defaultSnapshot, ...config.snapshot }
+  };
+}
+
+// src/config/loader.ts
+import { stat as stat3 } from "node:fs/promises";
+import path7 from "node:path";
+var CONFIG_FILES = [
+  "pubm.config.ts",
+  "pubm.config.mts",
+  "pubm.config.cts",
+  "pubm.config.js",
+  "pubm.config.mjs",
+  "pubm.config.cjs"
+];
+async function findConfigFile(cwd) {
+  for (const file of CONFIG_FILES) {
+    const filePath = path7.join(cwd, file);
+    try {
+      if ((await stat3(filePath)).isFile()) {
+        return filePath;
+      }
+    } catch {
+    }
+  }
+  return null;
+}
+async function loadConfig(cwd = process.cwd()) {
+  const configPath = await findConfigFile(cwd);
+  if (!configPath) return null;
+  const { createJiti } = await import("jiti");
+  const jiti = createJiti(cwd, { interopDefault: true });
+  const mod = await jiti.import(configPath);
+  return mod.default ?? mod;
+}
+
+// src/config/types.ts
+function defineConfig(config) {
+  return config;
+}
+
+// src/monorepo/dependency-graph.ts
+function buildDependencyGraph(packages) {
+  const packageNames = new Set(packages.map((pkg) => pkg.name));
+  const graph = /* @__PURE__ */ new Map();
+  for (const pkg of packages) {
+    const internalDeps = Object.keys(pkg.dependencies).filter(
+      (dep) => packageNames.has(dep)
+    );
+    graph.set(pkg.name, internalDeps);
+  }
+  return graph;
+}
+function topologicalSort(graph) {
+  const inDegree = /* @__PURE__ */ new Map();
+  for (const name of graph.keys()) {
+    inDegree.set(name, 0);
+  }
+  for (const [, deps] of graph) {
+    for (const dep of deps) {
+      inDegree.set(dep, (inDegree.get(dep) ?? 0) + 1);
+    }
+  }
+  const queue = [];
+  for (const [name, degree] of inDegree) {
+    if (degree === 0) {
+      queue.push(name);
+    }
+  }
+  const sorted = [];
+  while (queue.length > 0) {
+    const node = queue.shift();
+    sorted.push(node);
+    for (const dep of graph.get(node) ?? []) {
+      const newDegree = (inDegree.get(dep) ?? 0) - 1;
+      inDegree.set(dep, newDegree);
+      if (newDegree === 0) {
+        queue.push(dep);
+      }
+    }
+  }
+  if (sorted.length !== graph.size) {
+    throw new Error("Circular dependency detected");
+  }
+  return sorted.reverse();
+}
+
+// src/monorepo/groups.ts
+import micromatch from "micromatch";
+function resolveGroups(groups, allPackages) {
+  return groups.map((group) => {
+    const resolved = /* @__PURE__ */ new Set();
+    for (const pattern of group) {
+      const matches = micromatch(allPackages, pattern);
+      for (const match of matches) {
+        resolved.add(match);
+      }
+    }
+    return [...resolved];
+  });
+}
+function applyFixedGroup(bumps, group) {
+  let max = null;
+  for (const pkg of group) {
+    const bump = bumps.get(pkg);
+    if (bump) {
+      max = max ? maxBump(max, bump) : bump;
+    }
+  }
+  if (!max) return;
+  for (const pkg of group) {
+    bumps.set(pkg, max);
+  }
+}
+function applyLinkedGroup(bumps, group) {
+  let max = null;
+  for (const pkg of group) {
+    const bump = bumps.get(pkg);
+    if (bump) {
+      max = max ? maxBump(max, bump) : bump;
+    }
+  }
+  if (!max) return;
+  for (const pkg of group) {
+    if (bumps.has(pkg)) {
+      bumps.set(pkg, max);
+    }
+  }
+}
+
+// src/monorepo/workspace.ts
+import { existsSync as existsSync3, readFileSync as readFileSync3 } from "node:fs";
+import { join } from "node:path";
+import { parse as parse2 } from "yaml";
+function detectWorkspace(cwd) {
+  const root = cwd ?? process.cwd();
+  const pnpmWorkspacePath = join(root, "pnpm-workspace.yaml");
+  if (existsSync3(pnpmWorkspacePath)) {
+    const content = readFileSync3(pnpmWorkspacePath, "utf-8");
+    const parsed = parse2(content);
+    const packages = parsed?.packages ?? [];
+    return { type: "pnpm", patterns: packages };
+  }
+  const packageJsonPath = join(root, "package.json");
+  if (existsSync3(packageJsonPath)) {
+    const content = readFileSync3(packageJsonPath, "utf-8");
+    const pkg = JSON.parse(content);
+    if (pkg.workspaces) {
+      if (Array.isArray(pkg.workspaces)) {
+        return { type: "npm", patterns: pkg.workspaces };
+      }
+      if (typeof pkg.workspaces === "object" && Array.isArray(pkg.workspaces.packages)) {
+        return { type: "yarn", patterns: pkg.workspaces.packages };
+      }
+    }
+  }
+  return null;
+}
+
+// src/prerelease/pre.ts
+import {
+  existsSync as existsSync4,
+  mkdirSync as mkdirSync4,
+  readFileSync as readFileSync4,
+  rmSync,
+  writeFileSync as writeFileSync3
+} from "node:fs";
+import path8 from "node:path";
+function getPreStatePath(cwd) {
+  return path8.resolve(cwd ?? process.cwd(), ".pubm", "pre.json");
+}
+function readPreState(cwd) {
+  const filePath = getPreStatePath(cwd);
+  if (!existsSync4(filePath)) {
+    return null;
+  }
+  const content = readFileSync4(filePath, "utf-8");
+  return JSON.parse(content);
+}
+function enterPreMode(tag, cwd) {
+  const filePath = getPreStatePath(cwd);
+  if (existsSync4(filePath)) {
+    throw new Error(
+      "Already in pre mode. Exit pre mode first before entering a new one."
+    );
+  }
+  const dir = path8.dirname(filePath);
+  if (!existsSync4(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 (!existsSync4(filePath)) {
+    throw new Error("Not in pre mode. Enter pre mode first before exiting.");
+  }
+  rmSync(filePath);
+}
+
+// src/prerelease/snapshot.ts
+function formatTimestamp(date) {
+  const year = date.getUTCFullYear();
+  const month = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const day = String(date.getUTCDate()).padStart(2, "0");
+  const hours = String(date.getUTCHours()).padStart(2, "0");
+  const minutes = String(date.getUTCMinutes()).padStart(2, "0");
+  const seconds = String(date.getUTCSeconds()).padStart(2, "0");
+  return `${year}${month}${day}T${hours}${minutes}${seconds}`;
+}
+function generateSnapshotVersion(options) {
+  const tag = options.tag ?? "snapshot";
+  const base = options.useCalculatedVersion && options.baseVersion ? options.baseVersion : "0.0.0";
+  const now = /* @__PURE__ */ new Date();
+  const timestamp = formatTimestamp(now);
+  if (options.template) {
+    return options.template.replace(/\{base\}/g, base).replace(/\{tag\}/g, tag).replace(/\{timestamp\}/g, timestamp).replace(/\{commit\}/g, options.commit ?? "").replace(/\{datetime\}/g, timestamp);
+  }
+  return `${base}-${tag}-${timestamp}`;
+}
+
+// src/validate/entry-points.ts
+import { existsSync as existsSync5 } from "node:fs";
+import path9 from "node:path";
+var SIMPLE_FIELDS = ["main", "module", "types", "typings"];
+function checkPath(filePath, cwd) {
+  return existsSync5(path9.resolve(cwd, filePath));
+}
+function validateExports(exports, cwd, prefix = "exports") {
+  const errors = [];
+  if (typeof exports === "string") {
+    if (!checkPath(exports, cwd)) {
+      errors.push({ field: prefix, path: exports });
+    }
+    return errors;
+  }
+  if (typeof exports === "object" && exports !== null) {
+    for (const [key, value] of Object.entries(exports)) {
+      if (typeof value === "string") {
+        if (!checkPath(value, cwd)) {
+          errors.push({ field: `${prefix}["${key}"]`, path: value });
+        }
+      } else if (typeof value === "object" && value !== null) {
+        errors.push(...validateExports(value, cwd, `${prefix}["${key}"]`));
+      }
+    }
+  }
+  return errors;
+}
+function validateEntryPoints(pkg, cwd) {
+  const errors = [];
+  for (const field of SIMPLE_FIELDS) {
+    const value = pkg[field];
+    if (typeof value === "string" && !checkPath(value, cwd)) {
+      errors.push({ field, path: value });
+    }
+  }
+  if (pkg.exports !== void 0) {
+    errors.push(...validateExports(pkg.exports, cwd));
+  }
+  if (pkg.bin !== void 0) {
+    if (typeof pkg.bin === "string") {
+      if (!checkPath(pkg.bin, cwd)) {
+        errors.push({ field: "bin", path: pkg.bin });
+      }
+    } else if (typeof pkg.bin === "object" && pkg.bin !== null) {
+      for (const [name, binPath] of Object.entries(
+        pkg.bin
+      )) {
+        if (!checkPath(binPath, cwd)) {
+          errors.push({ field: `bin.${name}`, path: binPath });
+        }
+      }
+    }
+  }
+  return errors;
+}
+
+// src/validate/extraneous-files.ts
+import micromatch2 from "micromatch";
+var PATTERNS = [
+  {
+    pattern: [".env", ".env.*"],
+    reason: "potentially contains secrets",
+    basename: true
+  },
+  {
+    pattern: ["*.test.*", "*.spec.*"],
+    reason: "test file",
+    basename: true
+  },
+  {
+    pattern: ["**/__tests__/**"],
+    reason: "test file"
+  },
+  { pattern: ["*.map"], reason: "source map", basename: true },
+  {
+    pattern: [
+      ".eslintrc*",
+      ".prettierrc*",
+      "tsconfig.json",
+      "tsconfig.*.json",
+      ".babelrc*",
+      "jest.config.*",
+      "vitest.config.*",
+      ".editorconfig",
+      "biome.json"
+    ],
+    reason: "development config file",
+    basename: true
+  }
+];
+function detectExtraneousFiles(files) {
+  const result = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const { pattern, reason, basename } of PATTERNS) {
+    const options = basename ? { basename: true } : {};
+    const matched = micromatch2(files, pattern, options);
+    for (const file of matched) {
+      if (!seen.has(file)) {
+        seen.add(file);
+        result.push({ file, reason });
+      }
+    }
+  }
+  return result;
+}
+
 // src/index.ts
 async function pubm(options) {
   const resolvedOptions = resolveOptions({ ...options });
   await run(resolvedOptions);
 }
 export {
-  pubm
+  applyFixedGroup,
+  applyLinkedGroup,
+  buildDependencyGraph,
+  calculateVersionBumps,
+  defineConfig,
+  detectExtraneousFiles,
+  detectWorkspace,
+  enterPreMode,
+  exitPreMode,
+  generateChangelog,
+  generateChangesetContent,
+  generateChangesetId,
+  generateSnapshotVersion,
+  getStatus,
+  loadConfig,
+  migrateFromChangesets,
+  parseChangeset,
+  pubm,
+  readChangesets,
+  readPreState,
+  resolveConfig,
+  resolveGroups,
+  topologicalSort,
+  validateEntryPoints,
+  writeChangeset
 };