pubm 0.1.4 → 0.1.6

package/dist/index.cjs

@@ -1960,6 +1960,80 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
+// 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
+var import_promises = require("fs/promises");
+var import_node_path = __toESM(require("path"), 1);
+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 = import_node_path.default.join(cwd, file);
+    try {
+      if ((await (0, import_promises.stat)(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/options.ts
 var defaultOptions = {
   testScript: "test",
@@ -1969,13 +2043,16 @@ var defaultOptions = {
   registries: ["npm", "jsr"]
 };
 function resolveOptions(options) {
-  const nextOptions = { ...options, ...defaultOptions };
+  const defined = Object.fromEntries(
+    Object.entries(options).filter(([, v]) => v !== void 0)
+  );
+  const nextOptions = { ...defaultOptions, ...defined };
   return nextOptions;
 }
 
 // src/tasks/runner.ts
 var import_node_process8 = __toESM(require("process"), 1);
-var import_promise_spawn2 = __toESM(require("@npmcli/promise-spawn"), 1);
+var import_promise_spawn3 = __toESM(require("@npmcli/promise-spawn"), 1);
 
 // node_modules/.pnpm/eventemitter3@5.0.1/node_modules/eventemitter3/index.mjs
 var import_index = __toESM(require_eventemitter3(), 1);
@@ -1996,15 +2073,15 @@ var isCompatibleTerminal = tty && tty.isatty && tty.isatty(1) && env.TERM && !is
 var isCI = "CI" in env && ("GITHUB_ACTIONS" in env || "GITLAB_CI" in env || "CIRCLECI" in env);
 var isColorSupported = !isDisabled && (isForced || isWindows && !isDumbTerminal || isCompatibleTerminal || isCI);
 var replaceClose = (index, string, close, replace, head = string.substring(0, index) + replace, tail = string.substring(index + close.length), next = tail.indexOf(close)) => head + (next < 0 ? tail : replaceClose(next, tail, close, replace));
-var clearBleed = (index, string, open3, close, replace) => index < 0 ? open3 + string + close : open3 + replaceClose(index, string, close, replace) + close;
-var filterEmpty = (open3, close, replace = open3, at = open3.length + 1) => (string) => string || !(string === "" || string === void 0) ? clearBleed(
+var clearBleed = (index, string, open4, close, replace) => index < 0 ? open4 + string + close : open4 + replaceClose(index, string, close, replace) + close;
+var filterEmpty = (open4, close, replace = open4, at = open4.length + 1) => (string) => string || !(string === "" || string === void 0) ? clearBleed(
   ("" + string).indexOf(close, at),
   string,
-  open3,
+  open4,
   close,
   replace
 ) : "";
-var init = (open3, close, replace) => filterEmpty(`\x1B[${open3}m`, `\x1B[${close}m`, replace);
+var init = (open4, close, replace) => filterEmpty(`\x1B[${open4}m`, `\x1B[${close}m`, replace);
 var colors = {
   reset: init(0, 0),
   bold: init(1, 22, "\x1B[22m\x1B[1m"),
@@ -4530,7 +4607,8 @@ var Git = class {
   async revisionDiffsCount() {
     try {
       return Number.parseInt(
-        await this.git(["rev-list", "@{u}...HEAD", "--count", "--left-only"])
+        await this.git(["rev-list", "@{u}...HEAD", "--count", "--left-only"]),
+        10
       );
     } catch (error) {
       throw new GitError(
@@ -4776,9 +4854,71 @@ function createListr(...args) {
 }
 
 // src/utils/package.ts
-var import_promises = require("fs/promises");
-var import_node_path = __toESM(require("path"), 1);
+var import_promises3 = require("fs/promises");
+var import_node_path3 = __toESM(require("path"), 1);
 var import_node_process5 = __toESM(require("process"), 1);
+
+// src/ecosystem/rust.ts
+var import_promises2 = require("fs/promises");
+var import_node_path2 = __toESM(require("path"), 1);
+var import_smol_toml = require("smol-toml");
+
+// src/ecosystem/ecosystem.ts
+var Ecosystem = class {
+  constructor(packagePath) {
+    this.packagePath = packagePath;
+  }
+};
+
+// src/ecosystem/rust.ts
+var RustEcosystem = class extends Ecosystem {
+  static async detect(packagePath) {
+    try {
+      return (await (0, import_promises2.stat)(import_node_path2.default.join(packagePath, "Cargo.toml"))).isFile();
+    } catch {
+      return false;
+    }
+  }
+  async readCargoToml() {
+    const raw = await (0, import_promises2.readFile)(
+      import_node_path2.default.join(this.packagePath, "Cargo.toml"),
+      "utf-8"
+    );
+    return (0, import_smol_toml.parse)(raw);
+  }
+  async packageName() {
+    const cargo = await this.readCargoToml();
+    const pkg = cargo.package;
+    return pkg.name;
+  }
+  async readVersion() {
+    const cargo = await this.readCargoToml();
+    const pkg = cargo.package;
+    return pkg.version;
+  }
+  async writeVersion(newVersion) {
+    const filePath = import_node_path2.default.join(this.packagePath, "Cargo.toml");
+    const raw = await (0, import_promises2.readFile)(filePath, "utf-8");
+    const cargo = (0, import_smol_toml.parse)(raw);
+    const pkg = cargo.package;
+    pkg.version = newVersion;
+    await (0, import_promises2.writeFile)(filePath, (0, import_smol_toml.stringify)(cargo));
+  }
+  manifestFiles() {
+    return ["Cargo.toml"];
+  }
+  defaultTestCommand() {
+    return "cargo test";
+  }
+  defaultBuildCommand() {
+    return "cargo build --release";
+  }
+  supportedRegistries() {
+    return ["crates"];
+  }
+};
+
+// src/utils/package.ts
 var cachedPackageJson = {};
 var cachedJsrJson = {};
 function patchCachedJsrJson(contents, { cwd = import_node_process5.default.cwd() } = {}) {
@@ -4787,16 +4927,16 @@ function patchCachedJsrJson(contents, { cwd = import_node_process5.default.cwd()
 async function findOutFile(file, { cwd = import_node_process5.default.cwd() } = {}) {
   let directory = cwd;
   let filePath = "";
-  const { root } = import_node_path.default.parse(cwd);
+  const { root } = import_node_path3.default.parse(cwd);
   while (directory) {
-    filePath = import_node_path.default.join(directory, file);
+    filePath = import_node_path3.default.join(directory, file);
     try {
-      if ((await (0, import_promises.stat)(filePath)).isFile()) {
+      if ((await (0, import_promises3.stat)(filePath)).isFile()) {
         break;
       }
     } catch {
     }
-    directory = import_node_path.default.dirname(directory);
+    directory = import_node_path3.default.dirname(directory);
     if (directory === root) return null;
   }
   return filePath;
@@ -4808,7 +4948,7 @@ async function getPackageJson({
   if (cachedPackageJson[cwd]) return cachedPackageJson[cwd];
   try {
     const packageJsonPath = await findOutFile("package.json");
-    const raw = packageJsonPath && (await (0, import_promises.readFile)(packageJsonPath)).toString();
+    const raw = packageJsonPath && (await (0, import_promises3.readFile)(packageJsonPath)).toString();
     if (!raw) {
       if (!fallbackJsr) {
         throw new Error(
@@ -4841,7 +4981,7 @@ async function getJsrJson({
   if (cachedJsrJson[cwd]) return cachedJsrJson[cwd];
   try {
     const jsrJsonPath = await findOutFile("jsr.json");
-    const raw = jsrJsonPath && (await (0, import_promises.readFile)(jsrJsonPath)).toString();
+    const raw = jsrJsonPath && (await (0, import_promises3.readFile)(jsrJsonPath)).toString();
     if (!raw) {
       if (!fallbackPackage) {
         throw new Error(
@@ -4925,14 +5065,14 @@ async function version({ cwd = import_node_process5.default.cwd() } = {}) {
   return version2;
 }
 var versionRegex = /("version"\s*:\s*")[^"]*(")/;
-async function replaceVersion(version2) {
+async function replaceVersion(version2, packages) {
   const results = await Promise.all([
     (async () => {
       const packageJsonPath = await findOutFile("package.json");
       if (!packageJsonPath) return void 0;
-      const packageJson = (await (0, import_promises.readFile)(packageJsonPath)).toString();
+      const packageJson = (await (0, import_promises3.readFile)(packageJsonPath)).toString();
       try {
-        await (0, import_promises.writeFile)(
+        await (0, import_promises3.writeFile)(
           packageJsonPath,
           packageJson.replace(versionRegex, `$1${version2}$2`)
         );
@@ -4947,9 +5087,9 @@ async function replaceVersion(version2) {
     (async () => {
       const jsrJsonPath = await findOutFile("jsr.json");
       if (!jsrJsonPath) return void 0;
-      const jsrJson = (await (0, import_promises.readFile)(jsrJsonPath)).toString();
+      const jsrJson = (await (0, import_promises3.readFile)(jsrJsonPath)).toString();
       try {
-        await (0, import_promises.writeFile)(
+        await (0, import_promises3.writeFile)(
           jsrJsonPath,
           jsrJson.replace(versionRegex, `$1${version2}$2`)
         );
@@ -4960,7 +5100,19 @@ async function replaceVersion(version2) {
         );
       }
       return "jsr.json";
-    })()
+    })(),
+    ...(packages ?? []).filter((pkg) => pkg.registries.includes("crates")).map(async (pkg) => {
+      const eco = new RustEcosystem(import_node_path3.default.resolve(pkg.path));
+      try {
+        await eco.writeVersion(version2);
+      } catch (error) {
+        throw new AbstractError(
+          `Failed to write version to Cargo.toml at ${pkg.path}: ${error instanceof Error ? error.message : error}`,
+          { cause: error }
+        );
+      }
+      return import_node_path3.default.join(pkg.path, "Cargo.toml");
+    })
   ]);
   return results.filter((v) => v);
 }
@@ -4981,67 +5133,26 @@ async function getPackageManager() {
   return "npm";
 }
 
-// src/ecosystem/rust.ts
-var import_promises2 = require("fs/promises");
-var import_node_path2 = __toESM(require("path"), 1);
-var import_smol_toml = require("smol-toml");
-
-// src/ecosystem/ecosystem.ts
-var Ecosystem = class {
-  constructor(packagePath) {
-    this.packagePath = packagePath;
-  }
-};
-
-// src/ecosystem/rust.ts
-var RustEcosystem = class extends Ecosystem {
-  static async detect(packagePath) {
-    try {
-      return (await (0, import_promises2.stat)(import_node_path2.default.join(packagePath, "Cargo.toml"))).isFile();
-    } catch {
-      return false;
+// src/utils/registries.ts
+function collectRegistries(ctx) {
+  if (ctx.packages?.length) {
+    const seen = /* @__PURE__ */ new Set();
+    const result = [];
+    for (const pkg of ctx.packages) {
+      for (const reg of pkg.registries) {
+        if (!seen.has(reg)) {
+          seen.add(reg);
+          result.push(reg);
+        }
+      }
     }
+    return result;
   }
-  async readCargoToml() {
-    const raw = await (0, import_promises2.readFile)(
-      import_node_path2.default.join(this.packagePath, "Cargo.toml"),
-      "utf-8"
-    );
-    return (0, import_smol_toml.parse)(raw);
-  }
-  async packageName() {
-    const cargo = await this.readCargoToml();
-    const pkg = cargo.package;
-    return pkg.name;
-  }
-  async readVersion() {
-    const cargo = await this.readCargoToml();
-    const pkg = cargo.package;
-    return pkg.version;
-  }
-  async writeVersion(newVersion) {
-    const filePath = import_node_path2.default.join(this.packagePath, "Cargo.toml");
-    const raw = await (0, import_promises2.readFile)(filePath, "utf-8");
-    const cargo = (0, import_smol_toml.parse)(raw);
-    const pkg = cargo.package;
-    pkg.version = newVersion;
-    await (0, import_promises2.writeFile)(filePath, (0, import_smol_toml.stringify)(cargo));
-  }
-  manifestFiles() {
-    return ["Cargo.toml"];
-  }
-  defaultTestCommand() {
-    return "cargo test";
-  }
-  defaultBuildCommand() {
-    return "cargo build --release";
-  }
-  supportedRegistries() {
-    return ["crates"];
-  }
-};
+  return ctx.registries;
+}
 
 // src/registry/crates.ts
+var import_node_path4 = __toESM(require("path"), 1);
 var import_tinyexec2 = require("tinyexec");
 
 // src/registry/registry.ts
@@ -5115,9 +5226,13 @@ var CratesRegistry = class extends Registry {
       );
     }
   }
-  async publish() {
+  async publish(manifestDir) {
     try {
-      await (0, import_tinyexec2.exec)("cargo", ["publish"], { throwOnError: true });
+      const args = ["publish"];
+      if (manifestDir) {
+        args.push("--manifest-path", import_node_path4.default.join(manifestDir, "Cargo.toml"));
+      }
+      await (0, import_tinyexec2.exec)("cargo", args, { throwOnError: true });
       return true;
     } catch (error) {
       throw new CratesError("Failed to run `cargo publish`", {
@@ -5173,39 +5288,48 @@ var CratesError2 = class extends AbstractError {
     this.stack = "";
   }
 };
-async function getCrateName() {
-  const eco = new RustEcosystem(process.cwd());
+async function getCrateName(packagePath) {
+  const eco = new RustEcosystem(packagePath ?? 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."
-      );
+function createCratesAvailableCheckTask(packagePath) {
+  const label = packagePath ? ` (${packagePath})` : "";
+  return {
+    title: `Checking crates.io availability${label}`,
+    task: async () => {
+      const packageName = await getCrateName(packagePath);
+      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."
+        );
+      }
     }
-    if (!await registry.hasPermission()) {
-      throw new CratesError2(
-        "No crates.io credentials found. Run `cargo login` or set CARGO_REGISTRY_TOKEN."
-      );
+  };
+}
+function createCratesPublishTask(packagePath) {
+  const label = packagePath ? ` (${packagePath})` : "";
+  return {
+    title: `Publishing to crates.io${label}`,
+    task: async () => {
+      const packageName = await getCrateName(packagePath);
+      const registry = new CratesRegistry(packageName);
+      await registry.publish(packagePath);
     }
-  }
-};
-var cratesPublishTasks = {
-  title: "Publishing to crates.io",
-  task: async () => {
-    const packageName = await getCrateName();
-    const registry = new CratesRegistry(packageName);
-    await registry.publish();
-  }
-};
+  };
+}
+var cratesAvailableCheckTasks = createCratesAvailableCheckTask();
+var cratesPublishTasks = createCratesPublishTask();
 
 // src/tasks/jsr.ts
 var import_node_process6 = __toESM(require("process"), 1);
 var import_prompt_adapter_enquirer = require("@listr2/prompt-adapter-enquirer");
+var import_promise_spawn = __toESM(require("@npmcli/promise-spawn"), 1);
 
 // src/registry/jsr.ts
 var import_tinyexec3 = require("tinyexec");
@@ -5213,7 +5337,7 @@ var import_tinyexec3 = require("tinyexec");
 // src/utils/db.ts
 var import_node_crypto = require("crypto");
 var import_node_fs = require("fs");
-var import_node_path3 = __toESM(require("path"), 1);
+var import_node_path5 = __toESM(require("path"), 1);
 var import_meta = {};
 var a = "aes-256-cbc";
 var n = (0, import_node_fs.statSync)(import_meta.dirname);
@@ -5229,7 +5353,7 @@ function d(g, h) {
 }
 var Db = class {
   constructor() {
-    __publicField(this, "path", import_node_path3.default.resolve(import_meta.dirname, ".pubm"));
+    __publicField(this, "path", import_node_path5.default.resolve(import_meta.dirname, ".pubm"));
     try {
       if (!(0, import_node_fs.statSync)(this.path).isDirectory()) {
         (0, import_node_fs.mkdirSync)(this.path);
@@ -5247,7 +5371,7 @@ var Db = class {
   set(field, value) {
     try {
       (0, import_node_fs.writeFileSync)(
-        import_node_path3.default.resolve(
+        import_node_path5.default.resolve(
           this.path,
           Buffer.from(e(field, field)).toString("base64")
         ),
@@ -5261,7 +5385,7 @@ var Db = class {
     }
   }
   get(field) {
-    const filePath = import_node_path3.default.resolve(
+    const filePath = import_node_path5.default.resolve(
       this.path,
       Buffer.from(e(field, field)).toString("base64")
     );
@@ -5344,6 +5468,7 @@ var JsrRegisry = class extends Registry {
     super(packageName, registry);
     __publicField(this, "registry", "https://jsr.io");
     __publicField(this, "client");
+    __publicField(this, "packageCreationUrls");
     this.client = new JsrClient(getApiEndpoint(this.registry));
   }
   async jsr(args) {
@@ -5385,9 +5510,19 @@ var JsrRegisry = class extends Registry {
           throwOnError: true
         }
       );
+      this.packageCreationUrls = void 0;
       return true;
     } catch (error) {
       const stderr = error instanceof import_tinyexec3.NonZeroExitError ? error.output?.stderr : void 0;
+      if (stderr?.includes("don't exist")) {
+        const urls = [...stderr.matchAll(/https:\/\/jsr\.io\/new\S+/g)].map(
+          (m) => m[0]
+        );
+        if (urls.length > 0) {
+          this.packageCreationUrls = urls;
+          return false;
+        }
+      }
       throw new JsrError(
         `Failed to run \`jsr publish --allow-dirty --token ***\`${stderr ? `
 ${stderr}` : ""}`,
@@ -5828,6 +5963,7 @@ async function npmRegistry() {
 }
 
 // src/tasks/jsr.ts
+var { open } = import_promise_spawn.default;
 var JsrAvailableError = class extends AbstractError {
   constructor(message, { cause } = {}) {
     super(message, { cause });
@@ -6008,7 +6144,39 @@ var jsrPublishTasks = {
       }
       JsrClient.token = jsrTokenEnv;
     }
-    await jsr.publish();
+    let result = await jsr.publish();
+    if (!result && jsr.packageCreationUrls) {
+      if (ctx.promptEnabled) {
+        task.title = "Running jsr publish (package creation needed)";
+        const urls = jsr.packageCreationUrls;
+        const maxAttempts = 3;
+        task.output = `Package doesn't exist on jsr. Create it at:
+${urls.map((url) => `  ${color.cyan(url)}`).join("\n")}`;
+        open(urls[0]);
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+          await task.prompt(import_prompt_adapter_enquirer.ListrEnquirerPromptAdapter).run({
+            type: "input",
+            message: `Press ${color.bold("enter")} after creating the package on jsr.io${attempt > 1 ? ` (attempt ${attempt}/${maxAttempts})` : ""}`
+          });
+          result = await jsr.publish();
+          if (result) break;
+          if (attempt < maxAttempts) {
+            task.output = "Package still doesn't exist. Please create it and try again.";
+          }
+        }
+        if (!result) {
+          throw new JsrAvailableError(
+            "Package creation not completed after 3 attempts."
+          );
+        }
+        task.title = "Running jsr publish (package created)";
+      } else {
+        throw new JsrAvailableError(
+          `Package doesn't exist on jsr. Create it at:
+${jsr.packageCreationUrls.join("\n")}`
+        );
+      }
+    }
   }
 };
 
@@ -6016,8 +6184,8 @@ var jsrPublishTasks = {
 var import_node_child_process = require("child_process");
 var import_node_process7 = __toESM(require("process"), 1);
 var import_prompt_adapter_enquirer2 = require("@listr2/prompt-adapter-enquirer");
-var import_promise_spawn = __toESM(require("@npmcli/promise-spawn"), 1);
-var { open } = import_promise_spawn.default;
+var import_promise_spawn2 = __toESM(require("@npmcli/promise-spawn"), 1);
+var { open: open2 } = import_promise_spawn2.default;
 var NpmAvailableError = class extends AbstractError {
   constructor(message, { cause } = {}) {
     super(message, { cause });
@@ -6047,7 +6215,7 @@ var npmAvailableCheckTasks = {
               if (urlMatch && !opened) {
                 opened = true;
                 task.output = `Login at: ${color.cyan(urlMatch[0])}`;
-                open(urlMatch[0]);
+                open2(urlMatch[0]);
                 child.stdin?.write("\n");
               }
             };
@@ -6055,9 +6223,7 @@ var npmAvailableCheckTasks = {
             child.stderr?.on("data", onData);
             child.on(
               "close",
-              (code) => code === 0 ? resolve() : reject(
-                new Error(`npm login exited with code ${code}`)
-              )
+              (code) => code === 0 ? resolve() : reject(new Error(`npm login exited with code ${code}`))
             );
             child.on("error", reject);
           });
@@ -6361,7 +6527,7 @@ var requiredConditionsCheckTask = (options) => createListr({
       {
         title: "Ping registries",
         task: (ctx, parentTask2) => parentTask2.newListr(
-          ctx.registries.map((registryKey) => ({
+          collectRegistries(ctx).map((registryKey) => ({
             title: `Ping to ${registryKey}`,
             task: async () => {
               const registry = await getRegistry(registryKey);
@@ -6378,7 +6544,9 @@ var requiredConditionsCheckTask = (options) => createListr({
         task: async (_2, parentTask2) => parentTask2.newListr(
           [
             {
-              enabled: (ctx) => ctx.registries.some((registry) => registry !== "jsr"),
+              enabled: (ctx) => collectRegistries(ctx).some(
+                (registry) => registry !== "jsr"
+              ),
               title: "Verifying if npm are installed",
               task: async () => {
                 const npm = await npmRegistry();
@@ -6390,7 +6558,9 @@ var requiredConditionsCheckTask = (options) => createListr({
               }
             },
             {
-              enabled: (ctx) => ctx.registries.some((registry) => registry === "jsr"),
+              enabled: (ctx) => collectRegistries(ctx).some(
+                (registry) => registry === "jsr"
+              ),
               title: "Verifying if jsr are installed",
               task: async (_3, task) => {
                 const jsr = await jsrRegistry();
@@ -6421,7 +6591,7 @@ var requiredConditionsCheckTask = (options) => createListr({
       },
       {
         title: "Checking if test and build scripts exist",
-        skip: (ctx) => !needsPackageScripts(ctx.registries),
+        skip: (ctx) => !needsPackageScripts(collectRegistries(ctx)),
         task: async (ctx) => {
           const { scripts } = await getPackageJson();
           const errors = [];
@@ -6449,23 +6619,42 @@ var requiredConditionsCheckTask = (options) => createListr({
       },
       {
         title: "Checking available registries for publishing",
-        task: (ctx, parentTask2) => parentTask2.newListr(
-          ctx.registries.map((registryKey) => {
-            switch (registryKey) {
-              case "npm":
-                return npmAvailableCheckTasks;
-              case "jsr":
-                return jsrAvailableCheckTasks;
-              case "crates":
-                return cratesAvailableCheckTasks;
-              default:
-                return npmAvailableCheckTasks;
-            }
-          }),
-          {
-            concurrent: true
+        task: (ctx, parentTask2) => {
+          if (ctx.packages?.length) {
+            const tasks = ctx.packages.flatMap(
+              (pkg) => pkg.registries.map((registryKey) => {
+                switch (registryKey) {
+                  case "npm":
+                    return npmAvailableCheckTasks;
+                  case "jsr":
+                    return jsrAvailableCheckTasks;
+                  case "crates":
+                    return createCratesAvailableCheckTask(pkg.path);
+                  default:
+                    return npmAvailableCheckTasks;
+                }
+              })
+            );
+            return parentTask2.newListr(tasks, { concurrent: true });
           }
-        )
+          return parentTask2.newListr(
+            collectRegistries(ctx).map((registryKey) => {
+              switch (registryKey) {
+                case "npm":
+                  return npmAvailableCheckTasks;
+                case "jsr":
+                  return jsrAvailableCheckTasks;
+                case "crates":
+                  return cratesAvailableCheckTasks;
+                default:
+                  return npmAvailableCheckTasks;
+              }
+            }),
+            {
+              concurrent: true
+            }
+          );
+        }
       }
     ],
     {
@@ -6475,8 +6664,30 @@ var requiredConditionsCheckTask = (options) => createListr({
 });
 
 // src/tasks/runner.ts
-var { open: open2 } = import_promise_spawn2.default;
+var { open: open3 } = import_promise_spawn3.default;
 var { prerelease } = import_semver3.default;
+function registryTask(registry) {
+  switch (registry) {
+    case "npm":
+      return npmPublishTasks;
+    case "jsr":
+      return jsrPublishTasks;
+    case "crates":
+      return cratesPublishTasks;
+    default:
+      return npmPublishTasks;
+  }
+}
+function collectPublishTasks(ctx) {
+  if (ctx.packages?.length) {
+    return ctx.packages.flatMap(
+      (pkg) => pkg.registries.map(
+        (reg) => reg === "crates" ? createCratesPublishTask(pkg.path) : registryTask(reg)
+      )
+    );
+  }
+  return collectRegistries(ctx).map(registryTask);
+}
 async function run(options) {
   const ctx = {
     ...options,
@@ -6495,21 +6706,9 @@ async function run(options) {
     await createListr(
       options.publishOnly ? {
         title: "Publishing",
-        task: (ctx2, parentTask) => parentTask.newListr(
-          ctx2.registries.map((registry) => {
-            switch (registry) {
-              case "npm":
-                return npmPublishTasks;
-              case "jsr":
-                return jsrPublishTasks;
-              case "crates":
-                return cratesPublishTasks;
-              default:
-                return npmPublishTasks;
-            }
-          }),
-          { concurrent: true }
-        )
+        task: (ctx2, parentTask) => parentTask.newListr(collectPublishTasks(ctx2), {
+          concurrent: true
+        })
       } : [
         {
           skip: options.skipTests,
@@ -6578,7 +6777,10 @@ async function run(options) {
               }
             }, ctx2);
             await git.reset();
-            const replaced = await replaceVersion(ctx2.version);
+            const replaced = await replaceVersion(
+              ctx2.version,
+              ctx2.packages
+            );
             for (const replacedFile of replaced) {
               await git.stage(replacedFile);
             }
@@ -6593,21 +6795,9 @@ async function run(options) {
         {
           skip: (ctx2) => options.skipPublish || !!ctx2.preview,
           title: "Publishing",
-          task: (ctx2, parentTask) => parentTask.newListr(
-            ctx2.registries.map((registry) => {
-              switch (registry) {
-                case "npm":
-                  return npmPublishTasks;
-                case "jsr":
-                  return jsrPublishTasks;
-                case "crates":
-                  return cratesPublishTasks;
-                default:
-                  return npmPublishTasks;
-              }
-            }),
-            { concurrent: true }
-          )
+          task: (ctx2, parentTask) => parentTask.newListr(collectPublishTasks(ctx2), {
+            concurrent: true
+          })
         },
         {
           title: "Pushing tags to GitHub",
@@ -6647,7 +6837,7 @@ ${repositoryUrl}/compare/${lastRev}...${latestTag}`;
             );
             const linkUrl = link2("Link", releaseDraftUrl.toString());
             task.title += ` ${linkUrl}`;
-            await open2(releaseDraftUrl.toString());
+            await open3(releaseDraftUrl.toString());
           }
         }
       ]
@@ -6709,11 +6899,11 @@ function generateChangelog(version2, entries, depUpdates) {
 
 // src/changeset/migrate.ts
 var import_node_fs2 = require("fs");
-var import_node_path4 = __toESM(require("path"), 1);
+var import_node_path6 = __toESM(require("path"), 1);
 var import_node_process9 = __toESM(require("process"), 1);
 var SKIPPED_FILES = /* @__PURE__ */ new Set(["config.json", "README.md"]);
 function migrateFromChangesets(cwd = import_node_process9.default.cwd()) {
-  const changesetDir = import_node_path4.default.join(cwd, ".changeset");
+  const changesetDir = import_node_path6.default.join(cwd, ".changeset");
   if (!(0, import_node_fs2.existsSync)(changesetDir)) {
     return {
       success: false,
@@ -6722,7 +6912,7 @@ function migrateFromChangesets(cwd = import_node_process9.default.cwd()) {
       configMigrated: false
     };
   }
-  const pubmDir = import_node_path4.default.join(cwd, ".pubm", "changesets");
+  const pubmDir = import_node_path6.default.join(cwd, ".pubm", "changesets");
   (0, import_node_fs2.mkdirSync)(pubmDir, { recursive: true });
   const files = (0, import_node_fs2.readdirSync)(changesetDir);
   const migratedFiles = [];
@@ -6737,15 +6927,15 @@ function migrateFromChangesets(cwd = import_node_process9.default.cwd()) {
     }
     if (file === "pre.json") {
       (0, import_node_fs2.copyFileSync)(
-        import_node_path4.default.join(changesetDir, file),
-        import_node_path4.default.resolve(cwd, ".pubm", "pre.json")
+        import_node_path6.default.join(changesetDir, file),
+        import_node_path6.default.resolve(cwd, ".pubm", "pre.json")
       );
       migratedFiles.push(file);
       continue;
     }
     if (file.endsWith(".md")) {
-      const src = import_node_path4.default.join(changesetDir, file);
-      const dest = import_node_path4.default.join(pubmDir, file);
+      const src = import_node_path6.default.join(changesetDir, file);
+      const dest = import_node_path6.default.join(pubmDir, file);
       (0, import_node_fs2.copyFileSync)(src, dest);
       migratedFiles.push(file);
     }
@@ -6792,10 +6982,10 @@ function parseChangeset(content, fileName) {
 
 // src/changeset/reader.ts
 var import_node_fs3 = require("fs");
-var import_node_path5 = __toESM(require("path"), 1);
+var import_node_path7 = __toESM(require("path"), 1);
 var import_node_process10 = __toESM(require("process"), 1);
 function readChangesets(cwd = import_node_process10.default.cwd()) {
-  const changesetsDir = import_node_path5.default.join(cwd, ".pubm", "changesets");
+  const changesetsDir = import_node_path7.default.join(cwd, ".pubm", "changesets");
   if (!(0, import_node_fs3.existsSync)(changesetsDir)) {
     return [];
   }
@@ -6805,7 +6995,7 @@ function readChangesets(cwd = import_node_process10.default.cwd()) {
     if (!file.endsWith(".md") || file === "README.md") {
       continue;
     }
-    const filePath = import_node_path5.default.join(changesetsDir, file);
+    const filePath = import_node_path7.default.join(changesetsDir, file);
     const content = (0, import_node_fs3.readFileSync)(filePath, "utf-8");
     changesets.push(parseChangeset(content, file));
   }
@@ -6875,7 +7065,7 @@ function calculateVersionBumps(currentVersions, cwd = import_node_process12.defa
 
 // src/changeset/writer.ts
 var import_node_fs4 = require("fs");
-var import_node_path6 = __toESM(require("path"), 1);
+var import_node_path8 = __toESM(require("path"), 1);
 var import_node_process13 = __toESM(require("process"), 1);
 var import_yaml2 = require("yaml");
 var adjectives = [
@@ -6970,90 +7160,16 @@ ${summary}
   return content;
 }
 function writeChangeset(releases, summary, cwd = import_node_process13.default.cwd()) {
-  const changesetsDir = import_node_path6.default.join(cwd, ".pubm", "changesets");
+  const changesetsDir = import_node_path8.default.join(cwd, ".pubm", "changesets");
   (0, import_node_fs4.mkdirSync)(changesetsDir, { recursive: true });
   const id = generateChangesetId();
   const fileName = `${id}.md`;
-  const filePath = import_node_path6.default.join(changesetsDir, fileName);
+  const filePath = import_node_path8.default.join(changesetsDir, fileName);
   const content = generateChangesetContent(releases, summary);
   (0, import_node_fs4.writeFileSync)(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
-var import_promises3 = require("fs/promises");
-var import_node_path7 = __toESM(require("path"), 1);
-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 = import_node_path7.default.join(cwd, file);
-    try {
-      if ((await (0, import_promises3.stat)(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;
@@ -7107,23 +7223,23 @@ function topologicalSort(graph) {
 
 // src/monorepo/discover.ts
 var import_node_fs6 = require("fs");
-var import_node_path9 = __toESM(require("path"), 1);
+var import_node_path10 = __toESM(require("path"), 1);
 var import_micromatch = __toESM(require("micromatch"), 1);
 
 // src/monorepo/workspace.ts
 var import_node_fs5 = require("fs");
-var import_node_path8 = require("path");
+var import_node_path9 = require("path");
 var import_yaml3 = require("yaml");
 function detectWorkspace(cwd) {
   const root = cwd ?? process.cwd();
-  const pnpmWorkspacePath = (0, import_node_path8.join)(root, "pnpm-workspace.yaml");
+  const pnpmWorkspacePath = (0, import_node_path9.join)(root, "pnpm-workspace.yaml");
   if ((0, import_node_fs5.existsSync)(pnpmWorkspacePath)) {
     const content = (0, import_node_fs5.readFileSync)(pnpmWorkspacePath, "utf-8");
     const parsed = (0, import_yaml3.parse)(content);
     const packages = parsed?.packages ?? [];
     return { type: "pnpm", patterns: packages };
   }
-  const packageJsonPath = (0, import_node_path8.join)(root, "package.json");
+  const packageJsonPath = (0, import_node_path9.join)(root, "package.json");
   if ((0, import_node_fs5.existsSync)(packageJsonPath)) {
     const content = (0, import_node_fs5.readFileSync)(packageJsonPath, "utf-8");
     const pkg = JSON.parse(content);
@@ -7184,9 +7300,9 @@ function applyLinkedGroup(bumps, group) {
 
 // src/prerelease/pre.ts
 var import_node_fs7 = require("fs");
-var import_node_path10 = __toESM(require("path"), 1);
+var import_node_path11 = __toESM(require("path"), 1);
 function getPreStatePath(cwd) {
-  return import_node_path10.default.resolve(cwd ?? process.cwd(), ".pubm", "pre.json");
+  return import_node_path11.default.resolve(cwd ?? process.cwd(), ".pubm", "pre.json");
 }
 function readPreState(cwd) {
   const filePath = getPreStatePath(cwd);
@@ -7203,7 +7319,7 @@ function enterPreMode(tag, cwd) {
       "Already in pre mode. Exit pre mode first before entering a new one."
     );
   }
-  const dir = import_node_path10.default.dirname(filePath);
+  const dir = import_node_path11.default.dirname(filePath);
   if (!(0, import_node_fs7.existsSync)(dir)) {
     (0, import_node_fs7.mkdirSync)(dir, { recursive: true });
   }
@@ -7245,10 +7361,10 @@ function generateSnapshotVersion(options) {
 
 // src/validate/entry-points.ts
 var import_node_fs8 = require("fs");
-var import_node_path11 = __toESM(require("path"), 1);
+var import_node_path12 = __toESM(require("path"), 1);
 var SIMPLE_FIELDS = ["main", "module", "types", "typings"];
 function checkPath(filePath, cwd) {
-  return (0, import_node_fs8.existsSync)(import_node_path11.default.resolve(cwd, filePath));
+  return (0, import_node_fs8.existsSync)(import_node_path12.default.resolve(cwd, filePath));
 }
 function validateExports(exports2, cwd, prefix = "exports") {
   const errors = [];
@@ -7352,7 +7468,18 @@ function detectExtraneousFiles(files) {
 
 // src/index.ts
 async function pubm(options) {
-  const resolvedOptions = resolveOptions({ ...options });
+  const config = await loadConfig();
+  const configOptions = {};
+  if (config) {
+    const resolved = resolveConfig(config);
+    if (resolved.packages) {
+      configOptions.packages = resolved.packages;
+    }
+    if (!options.registries && resolved.registries) {
+      configOptions.registries = resolved.registries;
+    }
+  }
+  const resolvedOptions = resolveOptions({ ...configOptions, ...options });
   await run(resolvedOptions);
 }
 // Annotate the CommonJS export names for ESM import in node: