pubm 0.1.3 → 0.1.5

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_spawn = __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, open2, close, replace) => index < 0 ? open2 + string + close : open2 + replaceClose(index, string, close, replace) + close;
-var filterEmpty = (open2, close, replace = open2, at = open2.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,
-  open2,
+  open4,
   close,
   replace
 ) : "";
-var init = (open2, close, replace) => filterEmpty(`\x1B[${open2}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"),
@@ -4484,7 +4561,7 @@ var Git = class {
     try {
       return (await this.git(["tag", "-l"])).trim().split("\n").sort(import_semver.default.compareIdentifiers);
     } catch (error) {
-      throw new GitError("Failed to run `git config --get user.name`", {
+      throw new GitError("Failed to run `git tag -l`", {
         cause: error
       });
     }
@@ -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(
@@ -4747,8 +4825,24 @@ async function rollback() {
   called = true;
   if (rollbacks.length <= 0) return void 0;
   console.log("Rollback...");
-  await Promise.all(rollbacks.map(({ fn, ctx }) => fn(ctx)));
-  console.log("Rollback completed");
+  const results = await Promise.allSettled(
+    rollbacks.map(({ fn, ctx }) => fn(ctx))
+  );
+  const failures = results.filter(
+    (r) => r.status === "rejected"
+  );
+  if (failures.length > 0) {
+    for (const failure of failures) {
+      console.error(
+        `Rollback operation failed: ${failure.reason instanceof Error ? failure.reason.message : failure.reason}`
+      );
+    }
+    console.log(
+      "Rollback completed with errors. Some operations may require manual recovery."
+    );
+  } else {
+    console.log("Rollback completed");
+  }
 }
 
 // src/utils/listr.ts
@@ -4760,8 +4854,8 @@ function createListr(...args) {
 }
 
 // src/utils/package.ts
-var import_promises = require("fs/promises");
-var import_node_path = __toESM(require("path"), 1);
+var import_promises2 = require("fs/promises");
+var import_node_path2 = __toESM(require("path"), 1);
 var import_node_process5 = __toESM(require("process"), 1);
 var cachedPackageJson = {};
 var cachedJsrJson = {};
@@ -4771,16 +4865,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_path2.default.parse(cwd);
   while (directory) {
-    filePath = import_node_path.default.join(directory, file);
+    filePath = import_node_path2.default.join(directory, file);
     try {
-      if ((await (0, import_promises.stat)(filePath)).isFile()) {
+      if ((await (0, import_promises2.stat)(filePath)).isFile()) {
         break;
       }
     } catch {
     }
-    directory = import_node_path.default.dirname(directory);
+    directory = import_node_path2.default.dirname(directory);
     if (directory === root) return null;
   }
   return filePath;
@@ -4792,7 +4886,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_promises2.readFile)(packageJsonPath)).toString();
     if (!raw) {
       if (!fallbackJsr) {
         throw new Error(
@@ -4825,7 +4919,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_promises2.readFile)(jsrJsonPath)).toString();
     if (!raw) {
       if (!fallbackPackage) {
         throw new Error(
@@ -4914,21 +5008,35 @@ async function replaceVersion(version2) {
     (async () => {
       const packageJsonPath = await findOutFile("package.json");
       if (!packageJsonPath) return void 0;
-      const packageJson = (await (0, import_promises.readFile)(packageJsonPath)).toString();
-      await (0, import_promises.writeFile)(
-        packageJsonPath,
-        packageJson.replace(versionRegex, `$1${version2}$2`)
-      );
+      const packageJson = (await (0, import_promises2.readFile)(packageJsonPath)).toString();
+      try {
+        await (0, import_promises2.writeFile)(
+          packageJsonPath,
+          packageJson.replace(versionRegex, `$1${version2}$2`)
+        );
+      } catch (error) {
+        throw new AbstractError(
+          `Failed to write version to package.json: ${error instanceof Error ? error.message : error}`,
+          { cause: error }
+        );
+      }
       return "package.json";
     })(),
     (async () => {
       const jsrJsonPath = await findOutFile("jsr.json");
       if (!jsrJsonPath) return void 0;
-      const jsrJson = (await (0, import_promises.readFile)(jsrJsonPath)).toString();
-      await (0, import_promises.writeFile)(
-        jsrJsonPath,
-        jsrJson.replace(versionRegex, `$1${version2}$2`)
-      );
+      const jsrJson = (await (0, import_promises2.readFile)(jsrJsonPath)).toString();
+      try {
+        await (0, import_promises2.writeFile)(
+          jsrJsonPath,
+          jsrJson.replace(versionRegex, `$1${version2}$2`)
+        );
+      } catch (error) {
+        throw new AbstractError(
+          `Failed to write version to jsr.json: ${error instanceof Error ? error.message : error}`,
+          { cause: error }
+        );
+      }
       return "jsr.json";
     })()
   ]);
@@ -4947,12 +5055,13 @@ async function getPackageManager() {
       if (await findOutFile(lockFile2)) return packageManager;
     }
   }
+  console.warn("No lock file found, defaulting to npm.");
   return "npm";
 }
 
 // src/ecosystem/rust.ts
-var import_promises2 = require("fs/promises");
-var import_node_path2 = __toESM(require("path"), 1);
+var import_promises3 = require("fs/promises");
+var import_node_path3 = __toESM(require("path"), 1);
 var import_smol_toml = require("smol-toml");
 
 // src/ecosystem/ecosystem.ts
@@ -4966,14 +5075,14 @@ var Ecosystem = class {
 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();
+      return (await (0, import_promises3.stat)(import_node_path3.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"),
+    const raw = await (0, import_promises3.readFile)(
+      import_node_path3.default.join(this.packagePath, "Cargo.toml"),
       "utf-8"
     );
     return (0, import_smol_toml.parse)(raw);
@@ -4989,12 +5098,12 @@ var RustEcosystem = class extends Ecosystem {
     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 filePath = import_node_path3.default.join(this.packagePath, "Cargo.toml");
+    const raw = await (0, import_promises3.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));
+    await (0, import_promises3.writeFile)(filePath, (0, import_smol_toml.stringify)(cargo));
   }
   manifestFiles() {
     return ["Cargo.toml"];
@@ -5065,13 +5174,21 @@ var CratesRegistry = class extends Registry {
         { headers: this.headers }
       );
       if (!response.ok) {
-        throw new Error(`Crate '${this.packageName}' not found`);
+        if (response.status === 404) {
+          throw new CratesError(
+            `Crate '${this.packageName}' not found on crates.io`
+          );
+        }
+        throw new CratesError(
+          `crates.io API error (HTTP ${response.status}) for crate '${this.packageName}'`
+        );
       }
       const data = await response.json();
       return data.crate.max_version;
     } catch (error) {
+      if (error instanceof CratesError) throw error;
       throw new CratesError(
-        `Failed to fetch version for crate '${this.packageName}'`,
+        `Cannot reach crates.io to fetch version for '${this.packageName}'`,
         { cause: error }
       );
     }
@@ -5101,6 +5218,12 @@ var CratesRegistry = class extends Registry {
     if (process.env.CARGO_REGISTRY_TOKEN) return true;
     return this.isInstalled();
   }
+  getRequirements() {
+    return {
+      needsPackageScripts: false,
+      requiredManifest: "Cargo.toml"
+    };
+  }
   async isPackageNameAvaliable() {
     try {
       const response = await fetch(
@@ -5108,8 +5231,11 @@ var CratesRegistry = class extends Registry {
         { headers: this.headers }
       );
       return !response.ok;
-    } catch {
-      return true;
+    } catch (error) {
+      throw new CratesError(
+        `Failed to check package name availability on crates.io`,
+        { cause: error }
+      );
     }
   }
 };
@@ -5158,6 +5284,7 @@ var cratesPublishTasks = {
 // 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");
@@ -5165,7 +5292,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_path4 = __toESM(require("path"), 1);
 var import_meta = {};
 var a = "aes-256-cbc";
 var n = (0, import_node_fs.statSync)(import_meta.dirname);
@@ -5181,38 +5308,56 @@ 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_path4.default.resolve(import_meta.dirname, ".pubm"));
     try {
       if (!(0, import_node_fs.statSync)(this.path).isDirectory()) {
         (0, import_node_fs.mkdirSync)(this.path);
       }
     } catch {
-      (0, import_node_fs.mkdirSync)(this.path);
+      try {
+        (0, import_node_fs.mkdirSync)(this.path);
+      } catch (error) {
+        throw new Error(
+          `Failed to create token storage directory at '${this.path}': ${error instanceof Error ? error.message : error}`
+        );
+      }
     }
   }
   set(field, value) {
-    (0, import_node_fs.writeFileSync)(
-      import_node_path3.default.resolve(this.path, Buffer.from(e(field, field)).toString("base64")),
-      Buffer.from(e(`${value}`, field)),
-      { encoding: "binary" }
-    );
+    try {
+      (0, import_node_fs.writeFileSync)(
+        import_node_path4.default.resolve(
+          this.path,
+          Buffer.from(e(field, field)).toString("base64")
+        ),
+        Buffer.from(e(`${value}`, field)),
+        { encoding: "binary" }
+      );
+    } catch (error) {
+      throw new Error(
+        `Failed to save token for '${field}': ${error instanceof Error ? error.message : error}`
+      );
+    }
   }
   get(field) {
+    const filePath = import_node_path4.default.resolve(
+      this.path,
+      Buffer.from(e(field, field)).toString("base64")
+    );
+    let raw;
     try {
-      return d(
-        Buffer.from(
-          (0, import_node_fs.readFileSync)(
-            import_node_path3.default.resolve(
-              this.path,
-              Buffer.from(e(field, field)).toString("base64")
-            )
-          )
-        ).toString(),
-        field
-      );
+      raw = (0, import_node_fs.readFileSync)(filePath);
     } catch {
       return null;
     }
+    try {
+      return d(Buffer.from(raw).toString(), field);
+    } catch {
+      console.warn(
+        `Stored token for '${field}' appears corrupted. It will be re-requested.`
+      );
+      return null;
+    }
   }
 };
 
@@ -5226,9 +5371,12 @@ function getScope(packageName) {
 }
 function getScopeAndName(packageName) {
   const matches = packageName.match(/^@([a-zA-Z0-9]+)\/([a-zA-Z0-9]+)$/);
-  const scope = matches?.[1];
-  const name = matches?.[2];
-  return [`${scope}`, `${name}`];
+  if (!matches) {
+    throw new Error(
+      `Invalid scoped package name: '${packageName}'. Expected format: @scope/name`
+    );
+  }
+  return [matches[1], matches[2]];
 }
 var scopedPackagePattern = /^(?:@([^/]+?)[/])?([^/]+?)$/;
 var blacklist = ["node_modules", "favicon.ico"];
@@ -5275,6 +5423,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) {
@@ -5316,9 +5465,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}` : ""}`,
@@ -5348,6 +5507,12 @@ ${stderr}` : ""}`,
   async isPackageNameAvaliable() {
     return isValidPackageName(this.packageName);
   }
+  getRequirements() {
+    return {
+      needsPackageScripts: false,
+      requiredManifest: "jsr.json"
+    };
+  }
 };
 var _JsrClient = class _JsrClient {
   constructor(apiEndpoint) {
@@ -5369,9 +5534,7 @@ var _JsrClient = class _JsrClient {
       const response = await this.fetch("/user");
       if (response.status === 401) return null;
       if (!response.ok) {
-        throw new Error(
-          `HTTP ${response.status}: ${response.statusText}`
-        );
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
       }
       return await response.json();
     } catch (error) {
@@ -5385,9 +5548,7 @@ var _JsrClient = class _JsrClient {
       const response = await this.fetch(`/user/member/${scope}`);
       if (response.status === 401) return null;
       if (!response.ok) {
-        throw new Error(
-          `HTTP ${response.status}: ${response.statusText}`
-        );
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
       }
       return await response.json();
     } catch (error) {
@@ -5404,15 +5565,11 @@ var _JsrClient = class _JsrClient {
       const response = await this.fetch("/user/scopes");
       if (response.status === 401) return [];
       if (!response.ok) {
-        throw new Error(
-          `HTTP ${response.status}: ${response.statusText}`
-        );
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
       }
       const body = await response.json();
       if (!Array.isArray(body)) {
-        throw new Error(
-          `Expected array response but got ${typeof body}`
-        );
+        throw new Error(`Expected array response but got ${typeof body}`);
       }
       return body.map(({ scope }) => scope);
     } catch (error) {
@@ -5428,9 +5585,15 @@ var _JsrClient = class _JsrClient {
     const [scope, name] = getScopeAndName(packageName);
     try {
       const response = await this.fetch(`/scopes/${scope}/packages/${name}`);
-      if (!response.ok) return null;
+      if (response.status === 404) return null;
+      if (!response.ok) {
+        throw new JsrError(
+          `JSR API error (HTTP ${response.status}) for package '${packageName}'`
+        );
+      }
       return await response.json();
     } catch (error) {
+      if (error instanceof JsrError) throw error;
       throw new JsrError(
         `Failed to fetch \`${this.apiEndpoint}/scopes/${scope}/packages/${name}\``,
         {
@@ -5445,8 +5608,18 @@ var _JsrClient = class _JsrClient {
         method: "POST",
         body: JSON.stringify({ scope })
       });
-      return response.status === 200 || response.status === 201;
+      if (response.status === 200 || response.status === 201) return true;
+      let detail = "";
+      try {
+        const body = await response.json();
+        detail = body.message || body.error || JSON.stringify(body);
+      } catch {
+      }
+      throw new JsrError(
+        `Failed to create scope '${scope}': HTTP ${response.status}${detail ? ` \u2014 ${detail}` : ""}`
+      );
     } catch (error) {
+      if (error instanceof JsrError) throw error;
       throw new JsrError(`Failed to fetch \`${this.apiEndpoint}/scopes\``, {
         cause: error
       });
@@ -5457,8 +5630,18 @@ var _JsrClient = class _JsrClient {
       const response = await this.fetch(`/scopes/${scope}`, {
         method: "DELETE"
       });
-      return response.status === 200 || response.status === 204;
+      if (response.status === 200 || response.status === 204) return true;
+      let detail = "";
+      try {
+        const body = await response.json();
+        detail = body.message || body.error || JSON.stringify(body);
+      } catch {
+      }
+      throw new JsrError(
+        `Failed to delete scope '${scope}': HTTP ${response.status}${detail ? ` \u2014 ${detail}` : ""}`
+      );
     } catch (error) {
+      if (error instanceof JsrError) throw error;
       throw new JsrError(
         `Failed to fetch \`${this.apiEndpoint}/scopes/${scope}\``,
         {
@@ -5474,8 +5657,18 @@ var _JsrClient = class _JsrClient {
         method: "POST",
         body: JSON.stringify({ package: name })
       });
-      return response.status === 200 || response.status === 201;
+      if (response.status === 200 || response.status === 201) return true;
+      let detail = "";
+      try {
+        const body = await response.json();
+        detail = body.message || body.error || JSON.stringify(body);
+      } catch {
+      }
+      throw new JsrError(
+        `Failed to create package '${packageName}': HTTP ${response.status}${detail ? ` \u2014 ${detail}` : ""}`
+      );
     } catch (error) {
+      if (error instanceof JsrError) throw error;
       throw new JsrError(
         `Failed to fetch \`${this.apiEndpoint}/scopes/${scope}/packages\``,
         {
@@ -5490,8 +5683,18 @@ var _JsrClient = class _JsrClient {
       const response = await this.fetch(`/scopes/${scope}/packages/${name}`, {
         method: "DELETE"
       });
-      return response.status === 200 || response.status === 204;
+      if (response.status === 200 || response.status === 204) return true;
+      let detail = "";
+      try {
+        const body = await response.json();
+        detail = body.message || body.error || JSON.stringify(body);
+      } catch {
+      }
+      throw new JsrError(
+        `Failed to delete package '${packageName}': HTTP ${response.status}${detail ? ` \u2014 ${detail}` : ""}`
+      );
     } catch (error) {
+      if (error instanceof JsrError) throw error;
       throw new JsrError(
         `Failed to fetch \`${this.apiEndpoint}/scopes/${scope}/packages/${name}\``,
         {
@@ -5504,9 +5707,7 @@ var _JsrClient = class _JsrClient {
     try {
       const response = await this.fetch(`/packages?query=${query}`);
       if (!response.ok) {
-        throw new Error(
-          `HTTP ${response.status}: ${response.statusText}`
-        );
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
       }
       return await response.json();
     } catch (error) {
@@ -5584,7 +5785,7 @@ var NpmRegistry = class extends Registry {
       await this.npm(["whoami"]);
       return true;
     } catch (error) {
-      if (error instanceof import_tinyexec4.NonZeroExitError && error.output?.stderr.includes("ENEEDAUTH")) {
+      if (error instanceof import_tinyexec4.NonZeroExitError) {
         return false;
       }
       throw new NpmError("Failed to run `npm whoami`", { cause: error });
@@ -5592,16 +5793,22 @@ var NpmRegistry = class extends Registry {
   }
   async collaborators() {
     try {
-      return JSON.parse(
-        await this.npm([
-          "access",
-          "list",
-          "collaborators",
-          this.packageName,
-          "--json"
-        ])
-      );
+      const output = await this.npm([
+        "access",
+        "list",
+        "collaborators",
+        this.packageName,
+        "--json"
+      ]);
+      try {
+        return JSON.parse(output);
+      } catch {
+        throw new NpmError(
+          `Unexpected response from npm registry for collaborators of '${this.packageName}'`
+        );
+      }
     } catch (error) {
+      if (error instanceof NpmError) throw error;
       throw new NpmError(
         `Failed to run \`npm access list collaborators ${this.packageName} --json\``,
         { cause: error }
@@ -5615,12 +5822,21 @@ var NpmRegistry = class extends Registry {
   }
   async distTags() {
     try {
-      return Object.keys(
-        JSON.parse(
-          await this.npm(["view", this.packageName, "dist-tags", "--json"])
-        )
-      );
+      const output = await this.npm([
+        "view",
+        this.packageName,
+        "dist-tags",
+        "--json"
+      ]);
+      try {
+        return Object.keys(JSON.parse(output));
+      } catch {
+        throw new NpmError(
+          `Unexpected response from npm registry for dist-tags of '${this.packageName}'`
+        );
+      }
     } catch (error) {
+      if (error instanceof NpmError) throw error;
       throw new NpmError(
         `Failed to run \`npm view ${this.packageName} dist-tags --json\``,
         { cause: error }
@@ -5650,12 +5866,7 @@ var NpmRegistry = class extends Registry {
       if (error instanceof import_tinyexec4.NonZeroExitError && error.output?.stderr.includes("EOTP")) {
         return false;
       }
-      throw new NpmError(
-        "Failed to run `npm publish --provenance --access public`",
-        {
-          cause: error
-        }
-      );
+      throw this.classifyPublishError(error);
     }
   }
   async publish(otp) {
@@ -5667,14 +5878,39 @@ var NpmRegistry = class extends Registry {
       if (error instanceof import_tinyexec4.NonZeroExitError && error.output?.stderr.includes("EOTP")) {
         return false;
       }
-      throw new NpmError(`Failed to run \`npm ${args.join(" ")}\``, {
-        cause: error
-      });
+      throw this.classifyPublishError(error);
     }
   }
   async isPackageNameAvaliable() {
     return isValidPackageName(this.packageName);
   }
+  getRequirements() {
+    return {
+      needsPackageScripts: true,
+      requiredManifest: "package.json"
+    };
+  }
+  classifyPublishError(error) {
+    if (error instanceof import_tinyexec4.NonZeroExitError) {
+      const stderr = error.output?.stderr ?? "";
+      if (stderr.includes("EOTP")) {
+        return new NpmError("OTP required for publishing", { cause: error });
+      }
+      if (stderr.includes("403") || stderr.includes("Forbidden")) {
+        return new NpmError(
+          "Permission denied (403 Forbidden). Check your npm access token permissions.",
+          { cause: error }
+        );
+      }
+      if (stderr.includes("429") || stderr.includes("Too Many Requests")) {
+        return new NpmError(
+          "Rate limited by npm registry. Please wait and try again.",
+          { cause: error }
+        );
+      }
+    }
+    return new NpmError("Failed to publish to npm", { cause: error });
+  }
 };
 async function npmRegistry() {
   const packageJson = await getPackageJson();
@@ -5682,6 +5918,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 });
@@ -5706,17 +5943,34 @@ var jsrAvailableCheckTasks = {
     if (!JsrClient.token) {
       task.output = "Retrieving jsr API token";
       if (ctx.promptEnabled) {
-        while (true) {
+        const maxAttempts = 3;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
           JsrClient.token = await task.prompt(import_prompt_adapter_enquirer.ListrEnquirerPromptAdapter).run({
             type: "password",
-            message: `Please enter the jsr ${color.bold("API token")}`,
+            message: `Please enter the jsr ${color.bold("API token")}${attempt > 1 ? ` (attempt ${attempt}/${maxAttempts})` : ""}`,
             footer: `
 Generate a token from ${color.bold(link2("jsr.io", "https://jsr.io/account/tokens/create/"))}. ${color.red("You should select")} ${color.bold("'Interact with the JSR API'")}.`
           });
           try {
             if (await jsr.client.user()) break;
-            task.output = "The jsr API token is invalid. Please re-enter a valid token.";
-          } catch {
+            if (attempt < maxAttempts) {
+              task.output = "The jsr API token is invalid. Please re-enter a valid token.";
+            }
+          } catch (error) {
+            if (error instanceof Error && (error.message.includes("fetch") || error.message.includes("network") || error.message.includes("ENOTFOUND"))) {
+              throw new JsrAvailableError(
+                "JSR API is unreachable. Check your network connection.",
+                { cause: error }
+              );
+            }
+            if (attempt < maxAttempts) {
+              task.output = "The jsr API token is invalid. Please re-enter a valid token.";
+            }
+          }
+          if (attempt === maxAttempts) {
+            throw new JsrAvailableError(
+              "JSR token verification failed after 3 attempts."
+            );
           }
         }
       } else {
@@ -5845,13 +6099,48 @@ 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")}`
+        );
+      }
+    }
   }
 };
 
 // src/tasks/npm.ts
+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_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 });
@@ -5862,12 +6151,55 @@ var NpmAvailableError = class extends AbstractError {
 var npmAvailableCheckTasks = {
   title: "Checking npm avaliable for publising",
   skip: (ctx) => !!ctx.preview,
-  task: async () => {
+  task: async (ctx, task) => {
     const npm = await npmRegistry();
     if (!await npm.isLoggedIn()) {
-      throw new NpmAvailableError(
-        "You are not logged in. Please log in first using `npm login`."
-      );
+      if (ctx.promptEnabled) {
+        try {
+          task.output = "Launching npm login...";
+          await new Promise((resolve, reject) => {
+            const child = (0, import_node_child_process.spawn)("npm", ["login"], {
+              stdio: ["pipe", "pipe", "pipe"]
+            });
+            let opened = false;
+            const onData = (data) => {
+              const text = data.toString();
+              const urlMatch = text.match(
+                /https:\/\/www\.npmjs\.com\/login[^\s]*/
+              );
+              if (urlMatch && !opened) {
+                opened = true;
+                task.output = `Login at: ${color.cyan(urlMatch[0])}`;
+                open2(urlMatch[0]);
+                child.stdin?.write("\n");
+              }
+            };
+            child.stdout?.on("data", onData);
+            child.stderr?.on("data", onData);
+            child.on(
+              "close",
+              (code) => code === 0 ? resolve() : reject(
+                new Error(`npm login exited with code ${code}`)
+              )
+            );
+            child.on("error", reject);
+          });
+        } catch (error) {
+          throw new NpmAvailableError(
+            "npm login failed. Please run `npm login` manually and try again.",
+            { cause: error }
+          );
+        }
+        if (!await npm.isLoggedIn()) {
+          throw new NpmAvailableError(
+            "Still not logged in after npm login. Please verify your credentials."
+          );
+        }
+      } else {
+        throw new NpmAvailableError(
+          "Not logged in to npm. Set NODE_AUTH_TOKEN in your CI environment. For GitHub Actions, add it as a repository secret."
+        );
+      }
     }
     if (await npm.isPublished()) {
       if (!await npm.hasPermission()) {
@@ -5895,24 +6227,31 @@ var npmPublishTasks = {
       let result = await npm.publish();
       if (!result) {
         task.title = "Running npm publish (OTP code needed)";
-        while (!result) {
+        const maxAttempts = 3;
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
           result = await npm.publish(
             await task.prompt(import_prompt_adapter_enquirer2.ListrEnquirerPromptAdapter).run({
               type: "password",
-              message: "npm OTP code"
+              message: `npm OTP code${attempt > 1 ? ` (attempt ${attempt}/${maxAttempts})` : ""}`
             })
           );
-          if (!result) {
-            task.output = "2FA failed";
+          if (result) break;
+          if (attempt < maxAttempts) {
+            task.output = "2FA failed. Please try again.";
           }
         }
+        if (!result) {
+          throw new NpmAvailableError(
+            "OTP verification failed after 3 attempts."
+          );
+        }
         task.title = "Running npm publish (2FA passed)";
       }
     } else {
       const npmTokenEnv = import_node_process7.default.env.NODE_AUTH_TOKEN;
       if (!npmTokenEnv) {
         throw new NpmAvailableError(
-          "NODE_AUTH_TOKEN not found in the environment variables. Please set the token and try again."
+          "NODE_AUTH_TOKEN not found in environment variables. Set it in your CI configuration:\n  GitHub Actions: Add NODE_AUTH_TOKEN as a repository secret\n  Other CI: Export NODE_AUTH_TOKEN with your npm access token"
         );
       }
       const result = await npm.publishProvenance();
@@ -6018,6 +6357,7 @@ var prerequisitesCheckTask = (options) => {
               );
             }
             ctx.cleanWorkingTree = false;
+            return;
           }
           ctx.cleanWorkingTree = true;
         }
@@ -6119,6 +6459,16 @@ async function validateEngineVersion(engine, version2) {
 }
 
 // src/tasks/required-conditions-check.ts
+var registryRequirementsMap = {
+  npm: { needsPackageScripts: true },
+  jsr: { needsPackageScripts: false },
+  crates: { needsPackageScripts: false }
+};
+function needsPackageScripts(registries) {
+  return registries.some(
+    (r) => registryRequirementsMap[r]?.needsPackageScripts ?? true
+  );
+}
 var RequiredConditionCheckError = class extends AbstractError {
   constructor(message, { cause } = {}) {
     super(message, { cause });
@@ -6194,7 +6544,7 @@ var requiredConditionsCheckTask = (options) => createListr({
       },
       {
         title: "Checking if test and build scripts exist",
-        skip: (ctx) => ctx.jsrOnly,
+        skip: (ctx) => !needsPackageScripts(ctx.registries),
         task: async (ctx) => {
           const { scripts } = await getPackageJson();
           const errors = [];
@@ -6248,14 +6598,28 @@ var requiredConditionsCheckTask = (options) => createListr({
 });
 
 // src/tasks/runner.ts
-var { open } = import_promise_spawn.default;
+var { open: open3 } = import_promise_spawn3.default;
 var { prerelease } = import_semver3.default;
+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;
+  }
+  return ctx.registries;
+}
 async function run(options) {
   const ctx = {
     ...options,
-    promptEnabled: !import_std_env.isCI && import_node_process8.default.stdin.isTTY,
-    npmOnly: options.registries.every((registry) => registry !== "jsr"),
-    jsrOnly: options.registries.every((registry) => registry === "jsr")
+    promptEnabled: !import_std_env.isCI && import_node_process8.default.stdin.isTTY
   };
   try {
     if (options.contents) import_node_process8.default.chdir(options.contents);
@@ -6271,7 +6635,7 @@ async function run(options) {
       options.publishOnly ? {
         title: "Publishing",
         task: (ctx2, parentTask) => parentTask.newListr(
-          ctx2.registries.map((registry) => {
+          collectRegistries(ctx2).map((registry) => {
             switch (registry) {
               case "npm":
                 return npmPublishTasks;
@@ -6291,9 +6655,16 @@ async function run(options) {
           title: "Running tests",
           task: async (ctx2) => {
             const packageManager = await getPackageManager();
-            await (0, import_tinyexec6.exec)(packageManager, ["run", ctx2.testScript], {
-              throwOnError: true
-            });
+            try {
+              await (0, import_tinyexec6.exec)(packageManager, ["run", ctx2.testScript], {
+                throwOnError: true
+              });
+            } catch (error) {
+              throw new AbstractError(
+                `Test script '${ctx2.testScript}' failed. Run \`${packageManager} run ${ctx2.testScript}\` locally to see full output.`,
+                { cause: error }
+              );
+            }
           }
         },
         {
@@ -6307,7 +6678,7 @@ async function run(options) {
               });
             } catch (error) {
               throw new AbstractError(
-                `Failed to run \`${packageManager} run ${ctx2.buildScript}\``,
+                `Build script '${ctx2.buildScript}' failed. Run \`${packageManager} run ${ctx2.buildScript}\` locally to see full output.`,
                 { cause: error }
               );
             }
@@ -6322,15 +6693,27 @@ async function run(options) {
             let commited = false;
             addRollback(async () => {
               if (tagCreated) {
-                console.log("Deleting tag...");
-                await git.deleteTag(`${await git.latestTag()}`);
+                try {
+                  console.log("Deleting tag...");
+                  await git.deleteTag(`${await git.latestTag()}`);
+                } catch (error) {
+                  console.error(
+                    `Failed to delete tag: ${error instanceof Error ? error.message : error}`
+                  );
+                }
               }
               if (commited) {
-                console.log("Reset commits...");
-                await git.reset();
-                await git.stash();
-                await git.reset("HEAD^", "--hard");
-                await git.popStash();
+                try {
+                  console.log("Reset commits...");
+                  await git.reset();
+                  await git.stash();
+                  await git.reset("HEAD^", "--hard");
+                  await git.popStash();
+                } catch (error) {
+                  console.error(
+                    `Failed to reset commits: ${error instanceof Error ? error.message : error}`
+                  );
+                }
               }
             }, ctx2);
             await git.reset();
@@ -6350,7 +6733,7 @@ async function run(options) {
           skip: (ctx2) => options.skipPublish || !!ctx2.preview,
           title: "Publishing",
           task: (ctx2, parentTask) => parentTask.newListr(
-            ctx2.registries.map((registry) => {
+            collectRegistries(ctx2).map((registry) => {
               switch (registry) {
                 case "npm":
                   return npmPublishTasks;
@@ -6403,7 +6786,7 @@ ${repositoryUrl}/compare/${lastRev}...${latestTag}`;
             );
             const linkUrl = link2("Link", releaseDraftUrl.toString());
             task.title += ` ${linkUrl}`;
-            await open(releaseDraftUrl.toString());
+            await open3(releaseDraftUrl.toString());
           }
         }
       ]
@@ -6465,11 +6848,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_path5 = __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_path5.default.join(cwd, ".changeset");
   if (!(0, import_node_fs2.existsSync)(changesetDir)) {
     return {
       success: false,
@@ -6478,7 +6861,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_path5.default.join(cwd, ".pubm", "changesets");
   (0, import_node_fs2.mkdirSync)(pubmDir, { recursive: true });
   const files = (0, import_node_fs2.readdirSync)(changesetDir);
   const migratedFiles = [];
@@ -6493,15 +6876,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_path5.default.join(changesetDir, file),
+        import_node_path5.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_path5.default.join(changesetDir, file);
+      const dest = import_node_path5.default.join(pubmDir, file);
       (0, import_node_fs2.copyFileSync)(src, dest);
       migratedFiles.push(file);
     }
@@ -6548,10 +6931,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_path6 = __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_path6.default.join(cwd, ".pubm", "changesets");
   if (!(0, import_node_fs3.existsSync)(changesetsDir)) {
     return [];
   }
@@ -6561,7 +6944,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_path6.default.join(changesetsDir, file);
     const content = (0, import_node_fs3.readFileSync)(filePath, "utf-8");
     changesets.push(parseChangeset(content, file));
   }
@@ -6631,7 +7014,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_path7 = __toESM(require("path"), 1);
 var import_node_process13 = __toESM(require("process"), 1);
 var import_yaml2 = require("yaml");
 var adjectives = [
@@ -6726,90 +7109,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_path7.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_path7.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;
@@ -6861,13 +7170,47 @@ function topologicalSort(graph) {
   return sorted.reverse();
 }
 
-// src/monorepo/groups.ts
+// src/monorepo/discover.ts
+var import_node_fs6 = require("fs");
+var import_node_path9 = __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_yaml3 = require("yaml");
+function detectWorkspace(cwd) {
+  const root = cwd ?? process.cwd();
+  const pnpmWorkspacePath = (0, import_node_path8.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");
+  if ((0, import_node_fs5.existsSync)(packageJsonPath)) {
+    const content = (0, import_node_fs5.readFileSync)(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/monorepo/groups.ts
+var import_micromatch2 = __toESM(require("micromatch"), 1);
 function resolveGroups(groups, allPackages) {
   return groups.map((group) => {
     const resolved = /* @__PURE__ */ new Set();
     for (const pattern of group) {
-      const matches = (0, import_micromatch.default)(allPackages, pattern);
+      const matches = (0, import_micromatch2.default)(allPackages, pattern);
       for (const match of matches) {
         resolved.add(match);
       }
@@ -6904,73 +7247,44 @@ function applyLinkedGroup(bumps, group) {
   }
 }
 
-// src/monorepo/workspace.ts
-var import_node_fs5 = require("fs");
-var import_node_path8 = 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");
-  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");
-  if ((0, import_node_fs5.existsSync)(packageJsonPath)) {
-    const content = (0, import_node_fs5.readFileSync)(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
-var import_node_fs6 = require("fs");
-var import_node_path9 = __toESM(require("path"), 1);
+var import_node_fs7 = require("fs");
+var import_node_path10 = __toESM(require("path"), 1);
 function getPreStatePath(cwd) {
-  return import_node_path9.default.resolve(cwd ?? process.cwd(), ".pubm", "pre.json");
+  return import_node_path10.default.resolve(cwd ?? process.cwd(), ".pubm", "pre.json");
 }
 function readPreState(cwd) {
   const filePath = getPreStatePath(cwd);
-  if (!(0, import_node_fs6.existsSync)(filePath)) {
+  if (!(0, import_node_fs7.existsSync)(filePath)) {
     return null;
   }
-  const content = (0, import_node_fs6.readFileSync)(filePath, "utf-8");
+  const content = (0, import_node_fs7.readFileSync)(filePath, "utf-8");
   return JSON.parse(content);
 }
 function enterPreMode(tag, cwd) {
   const filePath = getPreStatePath(cwd);
-  if ((0, import_node_fs6.existsSync)(filePath)) {
+  if ((0, import_node_fs7.existsSync)(filePath)) {
     throw new Error(
       "Already in pre mode. Exit pre mode first before entering a new one."
     );
   }
-  const dir = import_node_path9.default.dirname(filePath);
-  if (!(0, import_node_fs6.existsSync)(dir)) {
-    (0, import_node_fs6.mkdirSync)(dir, { recursive: true });
+  const dir = import_node_path10.default.dirname(filePath);
+  if (!(0, import_node_fs7.existsSync)(dir)) {
+    (0, import_node_fs7.mkdirSync)(dir, { recursive: true });
   }
   const state = {
     mode: "pre",
     tag,
     packages: {}
   };
-  (0, import_node_fs6.writeFileSync)(filePath, JSON.stringify(state, null, 2), "utf-8");
+  (0, import_node_fs7.writeFileSync)(filePath, JSON.stringify(state, null, 2), "utf-8");
 }
 function exitPreMode(cwd) {
   const filePath = getPreStatePath(cwd);
-  if (!(0, import_node_fs6.existsSync)(filePath)) {
+  if (!(0, import_node_fs7.existsSync)(filePath)) {
     throw new Error("Not in pre mode. Enter pre mode first before exiting.");
   }
-  (0, import_node_fs6.rmSync)(filePath);
+  (0, import_node_fs7.rmSync)(filePath);
 }
 
 // src/prerelease/snapshot.ts
@@ -6995,11 +7309,11 @@ function generateSnapshotVersion(options) {
 }
 
 // src/validate/entry-points.ts
-var import_node_fs7 = require("fs");
-var import_node_path10 = __toESM(require("path"), 1);
+var import_node_fs8 = require("fs");
+var import_node_path11 = __toESM(require("path"), 1);
 var SIMPLE_FIELDS = ["main", "module", "types", "typings"];
 function checkPath(filePath, cwd) {
-  return (0, import_node_fs7.existsSync)(import_node_path10.default.resolve(cwd, filePath));
+  return (0, import_node_fs8.existsSync)(import_node_path11.default.resolve(cwd, filePath));
 }
 function validateExports(exports2, cwd, prefix = "exports") {
   const errors = [];
@@ -7052,7 +7366,7 @@ function validateEntryPoints(pkg, cwd) {
 }
 
 // src/validate/extraneous-files.ts
-var import_micromatch2 = __toESM(require("micromatch"), 1);
+var import_micromatch3 = __toESM(require("micromatch"), 1);
 var PATTERNS = [
   {
     pattern: [".env", ".env.*"],
@@ -7090,7 +7404,7 @@ function detectExtraneousFiles(files) {
   const seen = /* @__PURE__ */ new Set();
   for (const { pattern, reason, basename } of PATTERNS) {
     const options = basename ? { basename: true } : {};
-    const matched = (0, import_micromatch2.default)(files, pattern, options);
+    const matched = (0, import_micromatch3.default)(files, pattern, options);
     for (const file of matched) {
       if (!seen.has(file)) {
         seen.add(file);
@@ -7103,7 +7417,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: