@pubm/core 0.5.1 → 0.5.2

package/dist/index.cjs

@@ -17641,7 +17641,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@pubm/core",
-    version: "0.5.1",
+    version: "0.5.2",
     type: "module",
     description: "Core SDK for pubm - publish manager for multiple registries",
     types: "./dist/index.d.ts",
@@ -17720,7 +17720,7 @@ var coreEngines, PUBM_VERSION, PUBM_ENGINES;
 var init_pubm_metadata = __esm(() => {
   init_package();
   coreEngines = package_default.engines ?? {};
-  PUBM_VERSION = resolveDefine("0.5.1", package_default.version);
+  PUBM_VERSION = resolveDefine("0.5.2", package_default.version);
   PUBM_ENGINES = {
     node: resolveDefine(">=24", coreEngines.node ?? ">=18"),
     git: resolveDefine(">=2.11.0", coreEngines.git ?? ">=2.11.0"),
@@ -22097,11 +22097,16 @@ var init_rust = __esm(() => {
     manifestFiles() {
       return ["Cargo.toml"];
     }
-    defaultTestCommand(_scriptName) {
-      return "cargo test";
+    resolveTestCommand(script) {
+      const parts = script.split(/\s+/);
+      return Promise.resolve({ cmd: "cargo", args: parts });
     }
-    defaultBuildCommand(_scriptName) {
-      return "cargo build --release";
+    resolveBuildCommand(script) {
+      const parts = script.split(/\s+/);
+      return Promise.resolve({ cmd: "cargo", args: parts });
+    }
+    validateScript(_script, _type) {
+      return Promise.resolve(null);
     }
     supportedRegistries() {
       return ["crates"];
@@ -23636,13 +23641,26 @@ var init_js = __esm(() => {
     manifestFiles() {
       return ["package.json"];
     }
-    async defaultTestCommand(scriptName) {
+    async resolveTestCommand(script) {
       const pm = await getPackageManager();
-      return `${pm} run ${scriptName ?? "test"}`;
+      return { cmd: pm, args: ["run", script] };
     }
-    async defaultBuildCommand(scriptName) {
+    async resolveBuildCommand(script) {
       const pm = await getPackageManager();
-      return `${pm} run ${scriptName ?? "build"}`;
+      return { cmd: pm, args: ["run", script] };
+    }
+    async validateScript(script, _type) {
+      const pkgPath = import_node_path8.default.join(this.packagePath, "package.json");
+      try {
+        const raw = await import_promises6.readFile(pkgPath, "utf-8");
+        const { scripts } = JSON.parse(raw);
+        if (!scripts?.[script]) {
+          return `Script '${script}' not found in ${pkgPath}`;
+        }
+        return null;
+      } catch {
+        return `Cannot read ${pkgPath}`;
+      }
     }
     supportedRegistries() {
       return ["npm", "jsr"];
@@ -23783,13 +23801,6 @@ var init_catalog2 = __esm(() => {
   init_js();
   init_rust();
   ecosystemCatalog = new EcosystemCatalog;
-  ecosystemCatalog.register({
-    key: "js",
-    label: "JavaScript",
-    defaultRegistries: ["npm", "jsr"],
-    ecosystemClass: JsEcosystem,
-    detect: (path6) => JsEcosystem.detect(path6)
-  });
   ecosystemCatalog.register({
     key: "rust",
     label: "Rust",
@@ -23797,6 +23808,13 @@ var init_catalog2 = __esm(() => {
     ecosystemClass: RustEcosystem,
     detect: (path6) => RustEcosystem.detect(path6)
   });
+  ecosystemCatalog.register({
+    key: "js",
+    label: "JavaScript",
+    defaultRegistries: ["npm", "jsr"],
+    ecosystemClass: JsEcosystem,
+    detect: (path6) => JsEcosystem.detect(path6)
+  });
 });
 
 // src/plugin/runner.ts
@@ -35657,8 +35675,8 @@ var prerequisitesCheckTask = (options) => {
 };
 
 // src/tasks/required-conditions-check.ts
-var import_promises8 = require("node:fs/promises");
-var import_node_path21 = require("node:path");
+var import_node_path21 = __toESM(require("node:path"));
+init_catalog2();
 init_error4();
 init_git();
 init_i18n();
@@ -35746,20 +35764,66 @@ var requiredConditionsCheckTask = (options) => {
       },
       {
         title: t("task.conditions.checkScripts"),
-        skip: (ctx2) => !ctx2.config.packages.some((pkg) => (pkg.ecosystem ?? "js") === "js"),
+        skip: (ctx2) => !!ctx2.options.skipTests && !!ctx2.options.skipBuild,
         task: async (ctx2) => {
-          const raw = await import_promises8.readFile(import_node_path21.join(ctx2.cwd, "package.json"), "utf-8");
-          const { scripts } = JSON.parse(raw);
           const errors = [];
-          if (!ctx2.options.skipTests && !scripts?.[ctx2.options.testScript]) {
-            errors.push(t("error.conditions.testScriptMissing", {
-              script: ctx2.options.testScript
-            }));
+          const JS_WS_TYPES = new Set([
+            "pnpm",
+            "npm",
+            "yarn",
+            "bun",
+            "deno"
+          ]);
+          const workspaces = detectWorkspace(ctx2.cwd);
+          const byEcosystem = new Map;
+          for (const pkg of ctx2.config.packages) {
+            const key = pkg.ecosystem ?? "js";
+            if (!byEcosystem.has(key))
+              byEcosystem.set(key, []);
+            byEcosystem.get(key).push(pkg);
           }
-          if (!ctx2.options.skipBuild && !scripts?.[ctx2.options.buildScript]) {
-            errors.push(t("error.conditions.buildScriptMissing", {
-              script: ctx2.options.buildScript
-            }));
+          for (const [ecosystemKey, packages] of byEcosystem) {
+            const descriptor = ecosystemCatalog.get(ecosystemKey);
+            if (!descriptor)
+              continue;
+            const hasWorkspace = ecosystemKey === "js" ? workspaces.some((w2) => JS_WS_TYPES.has(w2.type)) : ecosystemKey === "rust" ? workspaces.some((w2) => w2.type === "cargo") : false;
+            const ecoConfig = ctx2.config.ecosystems?.[ecosystemKey];
+            let testGroupValidated = false;
+            let buildGroupValidated = false;
+            for (const pkg of packages) {
+              if (!ctx2.options.skipTests) {
+                const hasCommand = pkg.testCommand ?? ecoConfig?.testCommand;
+                if (!hasCommand) {
+                  const script = pkg.testScript ?? ecoConfig?.testScript ?? ctx2.options.testScript;
+                  const isPackageOverride = !!pkg.testScript;
+                  const validateCwd = hasWorkspace && !isPackageOverride ? ctx2.cwd : import_node_path21.default.resolve(ctx2.cwd, pkg.path);
+                  if (!hasWorkspace || isPackageOverride || !testGroupValidated) {
+                    const instance = new descriptor.ecosystemClass(validateCwd);
+                    const error4 = await instance.validateScript(script, "test");
+                    if (error4)
+                      errors.push(error4);
+                    if (hasWorkspace && !isPackageOverride)
+                      testGroupValidated = true;
+                  }
+                }
+              }
+              if (!ctx2.options.skipBuild) {
+                const hasCommand = pkg.buildCommand ?? ecoConfig?.buildCommand;
+                if (!hasCommand) {
+                  const script = pkg.buildScript ?? ecoConfig?.buildScript ?? ctx2.options.buildScript;
+                  const isPackageOverride = !!pkg.buildScript;
+                  const validateCwd = hasWorkspace && !isPackageOverride ? ctx2.cwd : import_node_path21.default.resolve(ctx2.cwd, pkg.path);
+                  if (!hasWorkspace || isPackageOverride || !buildGroupValidated) {
+                    const instance = new descriptor.ecosystemClass(validateCwd);
+                    const error4 = await instance.validateScript(script, "build");
+                    if (error4)
+                      errors.push(error4);
+                    if (hasWorkspace && !isPackageOverride)
+                      buildGroupValidated = true;
+                  }
+                }
+              }
+            }
           }
           if (errors.length) {
             throw new RequiredConditionCheckError(t("error.conditions.scriptsMissing", {
@@ -36609,24 +36673,158 @@ ${repositoryUrl}/compare/${lastRev}...${tag}`;
 init_catalog2();
 init_error4();
 init_i18n();
+var import_node_path24 = __toESM(require("node:path"));
 init_exec();
-function collectUniqueEcosystems(ctx) {
-  const seen = new Set;
+var JS_WORKSPACE_TYPES = new Set(["pnpm", "npm", "yarn", "bun", "deno"]);
+var ECOSYSTEM_DEFAULTS = {
+  js: { test: "test", build: "build" },
+  rust: { test: "test", build: "build --release" }
+};
+function hasWorkspaceForEcosystem(cwd, ecosystemKey) {
+  const workspaces = detectWorkspace(cwd);
+  if (ecosystemKey === "js") {
+    return workspaces.some((w2) => JS_WORKSPACE_TYPES.has(w2.type));
+  }
+  if (ecosystemKey === "rust") {
+    return workspaces.some((w2) => w2.type === "cargo");
+  }
+  return false;
+}
+function hasPackageLevelOverride(pkg, type) {
+  return type === "test" ? !!(pkg.testCommand || pkg.testScript) : !!(pkg.buildCommand || pkg.buildScript);
+}
+function resolveScript(pkg, ecosystemKey, ctx, type) {
+  const sf = type === "test" ? "testScript" : "buildScript";
+  const cf = type === "test" ? "testCommand" : "buildCommand";
+  if (pkg[cf])
+    return { command: pkg[cf] };
+  if (pkg[sf])
+    return { script: pkg[sf] };
+  const eco = ctx.config.ecosystems?.[ecosystemKey];
+  if (eco?.[cf])
+    return { command: eco[cf] };
+  if (eco?.[sf])
+    return { script: eco[sf] };
+  const globalScript = type === "test" ? ctx.options.testScript : ctx.options.buildScript;
+  if (globalScript)
+    return { script: globalScript };
+  return { script: ECOSYSTEM_DEFAULTS[ecosystemKey]?.[type] ?? type };
+}
+function groupByEcosystem(ctx, type) {
+  const map = new Map;
   for (const pkg of ctx.config.packages) {
-    seen.add(pkg.ecosystem ?? "js");
+    const key = pkg.ecosystem ?? "js";
+    if (!map.has(key))
+      map.set(key, { group: [], individual: [] });
+    const entry = map.get(key);
+    if (hasPackageLevelOverride(pkg, type)) {
+      entry.individual.push(pkg);
+    } else {
+      entry.group.push(pkg);
+    }
+  }
+  const result = [];
+  for (const descriptor of ecosystemCatalog.all()) {
+    const entry = map.get(descriptor.key);
+    if (!entry)
+      continue;
+    if (entry.group.length === 0 && entry.individual.length === 0)
+      continue;
+    result.push({
+      ecosystemKey: descriptor.key,
+      groupPackages: entry.group,
+      individualPackages: entry.individual,
+      hasWorkspace: hasWorkspaceForEcosystem(ctx.cwd, descriptor.key)
+    });
   }
-  return [...seen];
+  return result;
 }
-async function execEcosystemCommand(ctx, task, command) {
-  const parts = command.split(/\s+/);
-  const [cmd, ...args] = parts;
-  const liveOutput = shouldRenderLiveCommandOutput(ctx) ? createLiveCommandOutput(task, command) : undefined;
-  task.output = `Executing \`${command}\``;
+async function resolveExecutions(ctx, type) {
+  const groups = groupByEcosystem(ctx, type);
+  const executions = [];
+  for (const group of groups) {
+    const descriptor = ecosystemCatalog.get(group.ecosystemKey);
+    if (!descriptor)
+      continue;
+    if (group.groupPackages.length > 0) {
+      const resolved = resolveScript(group.groupPackages[0], group.ecosystemKey, ctx, type);
+      if (resolved.command) {
+        if (group.hasWorkspace) {
+          executions.push({
+            label: resolved.command,
+            cmd: "sh",
+            args: ["-c", resolved.command],
+            cwd: ctx.cwd
+          });
+        } else {
+          for (const pkg of group.groupPackages) {
+            const pkgCwd = import_node_path24.default.resolve(ctx.cwd, pkg.path);
+            executions.push({
+              label: `${resolved.command} (${pkg.path})`,
+              cmd: "sh",
+              args: ["-c", resolved.command],
+              cwd: pkgCwd
+            });
+          }
+        }
+      } else if (resolved.script) {
+        if (group.hasWorkspace) {
+          const instance = new descriptor.ecosystemClass(ctx.cwd);
+          const { cmd, args } = type === "test" ? await instance.resolveTestCommand(resolved.script) : await instance.resolveBuildCommand(resolved.script);
+          executions.push({
+            label: `${cmd} ${args.join(" ")}`,
+            cmd,
+            args,
+            cwd: ctx.cwd
+          });
+        } else {
+          for (const pkg of group.groupPackages) {
+            const pkgCwd = import_node_path24.default.resolve(ctx.cwd, pkg.path);
+            const instance = new descriptor.ecosystemClass(pkgCwd);
+            const { cmd, args } = type === "test" ? await instance.resolveTestCommand(resolved.script) : await instance.resolveBuildCommand(resolved.script);
+            executions.push({
+              label: `${cmd} ${args.join(" ")} (${pkg.path})`,
+              cmd,
+              args,
+              cwd: pkgCwd
+            });
+          }
+        }
+      }
+    }
+    for (const pkg of group.individualPackages) {
+      const pkgCwd = import_node_path24.default.resolve(ctx.cwd, pkg.path);
+      const resolved = resolveScript(pkg, group.ecosystemKey, ctx, type);
+      if (resolved.command) {
+        executions.push({
+          label: `${resolved.command} (${pkg.path})`,
+          cmd: "sh",
+          args: ["-c", resolved.command],
+          cwd: pkgCwd
+        });
+      } else if (resolved.script) {
+        const instance = new descriptor.ecosystemClass(pkgCwd);
+        const { cmd, args } = type === "test" ? await instance.resolveTestCommand(resolved.script) : await instance.resolveBuildCommand(resolved.script);
+        executions.push({
+          label: `${cmd} ${args.join(" ")} (${pkg.path})`,
+          cmd,
+          args,
+          cwd: pkgCwd
+        });
+      }
+    }
+  }
+  return executions;
+}
+async function runExecution(execution, ctx, task) {
+  const liveOutput = shouldRenderLiveCommandOutput(ctx) ? createLiveCommandOutput(task, execution.label) : undefined;
+  task.output = `Executing \`${execution.label}\``;
   try {
-    await exec3(cmd, args, {
+    await exec3(execution.cmd, execution.args, {
       onStdout: liveOutput?.onStdout,
       onStderr: liveOutput?.onStderr,
-      throwOnError: true
+      throwOnError: true,
+      nodeOptions: { cwd: execution.cwd }
     });
   } finally {
     liveOutput?.finish();
@@ -36639,29 +36837,24 @@ function createTestTask(hasPrepare, skipTests) {
     task: async (ctx, task) => {
       task.output = t("task.test.runningBeforeHooks");
       await ctx.runtime.pluginRunner.runHook("beforeTest", ctx);
-      const ecosystems = collectUniqueEcosystems(ctx);
-      const executedCommands = [];
-      for (const key of ecosystems) {
-        const descriptor = ecosystemCatalog.get(key);
-        if (!descriptor)
-          continue;
-        const instance = new descriptor.ecosystemClass(ctx.cwd);
-        const command = await instance.defaultTestCommand(ctx.options.testScript);
-        executedCommands.push(command);
-        task.title = t("task.test.titleWithCommand", { command });
+      const executions = await resolveExecutions(ctx, "test");
+      for (const execution of executions) {
+        task.title = t("task.test.titleWithCommand", {
+          command: execution.label
+        });
         try {
-          await execEcosystemCommand(ctx, task, command);
+          await runExecution(execution, ctx, task);
         } catch (error4) {
           throw new AbstractError(t("error.test.failedWithHint", {
-            script: command,
-            command
+            script: execution.label,
+            command: execution.label
           }), { cause: error4 });
         }
       }
       task.output = t("task.test.runningAfterHooks");
       await ctx.runtime.pluginRunner.runHook("afterTest", ctx);
       task.output = t("task.test.completed", {
-        command: executedCommands.join(", ")
+        command: executions.map((e3) => e3.label).join(", ")
       });
     }
   };
@@ -36673,29 +36866,24 @@ function createBuildTask(hasPrepare, skipBuild) {
     task: async (ctx, task) => {
       task.output = t("task.build.runningBeforeHooks");
       await ctx.runtime.pluginRunner.runHook("beforeBuild", ctx);
-      const ecosystems = collectUniqueEcosystems(ctx);
-      const executedCommands = [];
-      for (const key of ecosystems) {
-        const descriptor = ecosystemCatalog.get(key);
-        if (!descriptor)
-          continue;
-        const instance = new descriptor.ecosystemClass(ctx.cwd);
-        const command = await instance.defaultBuildCommand(ctx.options.buildScript);
-        executedCommands.push(command);
-        task.title = t("task.build.titleWithCommand", { command });
+      const executions = await resolveExecutions(ctx, "build");
+      for (const execution of executions) {
+        task.title = t("task.build.titleWithCommand", {
+          command: execution.label
+        });
         try {
-          await execEcosystemCommand(ctx, task, command);
+          await runExecution(execution, ctx, task);
         } catch (error4) {
           throw new AbstractError(t("error.build.failedWithHint", {
-            script: command,
-            command
+            script: execution.label,
+            command: execution.label
           }), { cause: error4 });
         }
       }
       task.output = t("task.build.runningAfterHooks");
       await ctx.runtime.pluginRunner.runHook("afterBuild", ctx);
       task.output = t("task.build.completed", {
-        command: executedCommands.join(", ")
+        command: executions.map((e3) => e3.label).join(", ")
       });
     }
   };
@@ -36703,13 +36891,13 @@ function createBuildTask(hasPrepare, skipBuild) {
 
 // src/tasks/phases/version.ts
 init_dist2();
-var import_node_path26 = __toESM(require("node:path"));
+var import_node_path27 = __toESM(require("node:path"));
 
 // src/changelog/file.ts
 var import_node_fs15 = require("node:fs");
-var import_node_path24 = __toESM(require("node:path"));
+var import_node_path25 = __toESM(require("node:path"));
 function writeChangelogToFile(cwd, newContent) {
-  const changelogPath = import_node_path24.default.join(cwd, "CHANGELOG.md");
+  const changelogPath = import_node_path25.default.join(cwd, "CHANGELOG.md");
   let existing = "";
   if (import_node_fs15.existsSync(changelogPath)) {
     existing = import_node_fs15.readFileSync(changelogPath, "utf-8");
@@ -36774,7 +36962,7 @@ function buildChangelogEntries(changesets, packagePath) {
 
 // src/changeset/reader.ts
 var import_node_fs16 = require("node:fs");
-var import_node_path25 = __toESM(require("node:path"));
+var import_node_path26 = __toESM(require("node:path"));
 var import_node_process18 = __toESM(require("node:process"));
 
 // src/changeset/parser.ts
@@ -36795,8 +36983,8 @@ function parseChangeset(content, fileName, resolveKey) {
       if (!VALID_BUMP_TYPES.has(type)) {
         throw new Error(`Invalid bump type "${type}" for package "${key}" in "${fileName}". Expected: patch, minor, or major.`);
       }
-      const path14 = resolveKey ? resolveKey(key) : key;
-      releases.push({ path: path14, type });
+      const path16 = resolveKey ? resolveKey(key) : key;
+      releases.push({ path: path16, type });
     }
   }
   const id = fileName.replace(/\.md$/, "");
@@ -36809,7 +36997,7 @@ function parseChangeset(content, fileName, resolveKey) {
 
 // src/changeset/reader.ts
 function readChangesets(cwd = import_node_process18.default.cwd(), resolveKey) {
-  const changesetsDir = import_node_path25.default.join(cwd, ".pubm", "changesets");
+  const changesetsDir = import_node_path26.default.join(cwd, ".pubm", "changesets");
   if (!import_node_fs16.existsSync(changesetsDir)) {
     return [];
   }
@@ -36819,16 +37007,16 @@ function readChangesets(cwd = import_node_process18.default.cwd(), resolveKey) {
     if (!file.endsWith(".md") || file === "README.md") {
       continue;
     }
-    const filePath = import_node_path25.default.join(changesetsDir, file);
+    const filePath = import_node_path26.default.join(changesetsDir, file);
     const content = import_node_fs16.readFileSync(filePath, "utf-8");
     changesets.push(parseChangeset(content, file, resolveKey));
   }
   return changesets;
 }
 function deleteChangesetFiles(cwd, changesets) {
-  const changesetsDir = import_node_path25.default.join(cwd, ".pubm", "changesets");
+  const changesetsDir = import_node_path26.default.join(cwd, ".pubm", "changesets");
   for (const changeset of changesets) {
-    const filePath = import_node_path25.default.join(changesetsDir, `${changeset.id}.md`);
+    const filePath = import_node_path26.default.join(changesetsDir, `${changeset.id}.md`);
     if (import_node_fs16.existsSync(filePath)) {
       import_node_fs16.rmSync(filePath);
     }
@@ -36885,7 +37073,7 @@ function createVersionTask(hasPrepare, dryRun) {
           const changesets = readChangesets(ctx.cwd, resolver);
           if (changesets.length > 0) {
             registerChangesetBackups(ctx, changesets);
-            const changelogPath = import_node_path26.default.join(ctx.cwd, "CHANGELOG.md");
+            const changelogPath = import_node_path27.default.join(ctx.cwd, "CHANGELOG.md");
             registerChangelogBackup(ctx, changelogPath);
             const pkgPath = ctx.config.packages[0]?.path ?? "";
             const entries = buildChangelogEntries(changesets, pkgPath);
@@ -36942,7 +37130,7 @@ ${ctx.config.packages.map((pkg) => `- ${pkg.name}: ${plan.version}`).join(`
           const changesets = readChangesets(ctx.cwd, resolver);
           if (changesets.length > 0) {
             registerChangesetBackups(ctx, changesets);
-            const changelogPath = import_node_path26.default.join(ctx.cwd, "CHANGELOG.md");
+            const changelogPath = import_node_path27.default.join(ctx.cwd, "CHANGELOG.md");
             registerChangelogBackup(ctx, changelogPath);
             const allEntries = [...plan.packages.keys()].flatMap((pkgPath) => buildChangelogEntries(changesets, pkgPath));
             if (allEntries.length > 0) {
@@ -37002,15 +37190,15 @@ ${[...plan.packages].map(([pkgPath]) => `- ${getPackageName(ctx, pkgPath)}: ${pl
             registerChangesetBackups(ctx, changesets);
             for (const [pkgPath] of plan.packages) {
               const pkgConfig = ctx.config.packages.find((p2) => p2.path === pkgPath);
-              const changelogDir = pkgConfig ? import_node_path26.default.resolve(ctx.cwd, pkgConfig.path) : ctx.cwd;
-              const changelogPath = import_node_path26.default.join(changelogDir, "CHANGELOG.md");
+              const changelogDir = pkgConfig ? import_node_path27.default.resolve(ctx.cwd, pkgConfig.path) : ctx.cwd;
+              const changelogPath = import_node_path27.default.join(changelogDir, "CHANGELOG.md");
               registerChangelogBackup(ctx, changelogPath);
             }
             for (const [pkgPath, pkgVersion] of plan.packages) {
               const entries = buildChangelogEntries(changesets, pkgPath);
               if (entries.length > 0) {
                 const pkgConfig = ctx.config.packages.find((p2) => p2.path === pkgPath);
-                const changelogDir = pkgConfig ? import_node_path26.default.resolve(ctx.cwd, pkgConfig.path) : ctx.cwd;
+                const changelogDir = pkgConfig ? import_node_path27.default.resolve(ctx.cwd, pkgConfig.path) : ctx.cwd;
                 writeChangelogToFile(changelogDir, generateChangelog(pkgVersion, entries));
               }
             }
@@ -37262,11 +37450,11 @@ function maxBump(a3, b2) {
 }
 // src/changeset/migrate.ts
 var import_node_fs17 = require("node:fs");
-var import_node_path27 = __toESM(require("node:path"));
+var import_node_path28 = __toESM(require("node:path"));
 var import_node_process20 = __toESM(require("node:process"));
 var SKIPPED_FILES = new Set(["config.json", "README.md"]);
 function migrateFromChangesets(cwd = import_node_process20.default.cwd()) {
-  const changesetDir = import_node_path27.default.join(cwd, ".changeset");
+  const changesetDir = import_node_path28.default.join(cwd, ".changeset");
   if (!import_node_fs17.existsSync(changesetDir)) {
     return {
       success: false,
@@ -37275,7 +37463,7 @@ function migrateFromChangesets(cwd = import_node_process20.default.cwd()) {
       configMigrated: false
     };
   }
-  const pubmDir = import_node_path27.default.join(cwd, ".pubm", "changesets");
+  const pubmDir = import_node_path28.default.join(cwd, ".pubm", "changesets");
   import_node_fs17.mkdirSync(pubmDir, { recursive: true });
   const files = import_node_fs17.readdirSync(changesetDir);
   const migratedFiles = [];
@@ -37289,13 +37477,13 @@ function migrateFromChangesets(cwd = import_node_process20.default.cwd()) {
       continue;
     }
     if (file === "pre.json") {
-      import_node_fs17.copyFileSync(import_node_path27.default.join(changesetDir, file), import_node_path27.default.resolve(cwd, ".pubm", "pre.json"));
+      import_node_fs17.copyFileSync(import_node_path28.default.join(changesetDir, file), import_node_path28.default.resolve(cwd, ".pubm", "pre.json"));
       migratedFiles.push(file);
       continue;
     }
     if (file.endsWith(".md")) {
-      const src = import_node_path27.default.join(changesetDir, file);
-      const dest = import_node_path27.default.join(pubmDir, file);
+      const src = import_node_path28.default.join(changesetDir, file);
+      const dest = import_node_path28.default.join(pubmDir, file);
       import_node_fs17.copyFileSync(src, dest);
       migratedFiles.push(file);
     }
@@ -37369,7 +37557,7 @@ function calculateVersionBumps(currentVersions, cwd = import_node_process22.defa
 }
 // src/changeset/writer.ts
 var import_node_fs18 = require("node:fs");
-var import_node_path28 = __toESM(require("node:path"));
+var import_node_path29 = __toESM(require("node:path"));
 var import_node_process23 = __toESM(require("node:process"));
 var import_yaml3 = __toESM(require_dist(), 1);
 var adjectives = [
@@ -37466,11 +37654,11 @@ ${summary}
   return content;
 }
 function writeChangeset(releases, summary, cwd = import_node_process23.default.cwd()) {
-  const changesetsDir = import_node_path28.default.join(cwd, ".pubm", "changesets");
+  const changesetsDir = import_node_path29.default.join(cwd, ".pubm", "changesets");
   import_node_fs18.mkdirSync(changesetsDir, { recursive: true });
   const id = generateChangesetId();
   const fileName = `${id}.md`;
-  const filePath = import_node_path28.default.join(changesetsDir, fileName);
+  const filePath = import_node_path29.default.join(changesetsDir, fileName);
   const content = generateChangesetContent(releases, summary);
   import_node_fs18.writeFileSync(filePath, content, "utf-8");
   return filePath;
@@ -37478,6 +37666,8 @@ function writeChangeset(releases, summary, cwd = import_node_process23.default.c
 // src/config/defaults.ts
 init_catalog2();
 init_i18n();
+var import_node_path30 = __toESM(require("node:path"));
+var import_micromatch4 = __toESM(require_micromatch(), 1);
 init_catalog();
 var defaultValidate = {
   cleanInstall: true,
@@ -37523,6 +37713,16 @@ async function resolveConfig(config, cwd) {
       }
     }
   }
+  if (config.ecosystems) {
+    for (const key of Object.keys(config.ecosystems)) {
+      if (!ecosystemCatalog.get(key)) {
+        throw new Error(t("error.config.unknownEcosystem", {
+          ecosystem: key,
+          list: ecosystemCatalog.all().map((d3) => d3.key).join(", ")
+        }));
+      }
+    }
+  }
   const configPackages = config.packages?.map((pkg) => {
     if (!pkg.registries)
       return pkg;
@@ -37544,15 +37744,29 @@ async function resolveConfig(config, cwd) {
     discoveryEmpty = true;
     packages = [];
   } else {
-    packages = discovered.map((pkg) => ({
-      path: pkg.path,
-      name: pkg.name,
-      version: pkg.version,
-      dependencies: pkg.dependencies,
-      ecosystem: pkg.ecosystem,
-      registries: pkg.registries,
-      ...pkg.registryVersions ? { registryVersions: pkg.registryVersions } : {}
-    }));
+    packages = discovered.map((pkg) => {
+      const configPkg = configPackages?.find((cp) => {
+        const normalized = cp.path.replace(/\\/g, "/");
+        const pkgPathForward = pkg.path.replace(/\\/g, "/");
+        if (import_micromatch4.default.scan(normalized).isGlob) {
+          return import_micromatch4.default.isMatch(pkgPathForward, normalized);
+        }
+        return import_node_path30.default.normalize(cp.path) === pkg.path;
+      });
+      return {
+        path: pkg.path,
+        name: pkg.name,
+        version: pkg.version,
+        dependencies: pkg.dependencies,
+        ecosystem: pkg.ecosystem,
+        registries: pkg.registries,
+        ...pkg.registryVersions ? { registryVersions: pkg.registryVersions } : {},
+        ...configPkg?.testScript ? { testScript: configPkg.testScript } : {},
+        ...configPkg?.testCommand ? { testCommand: configPkg.testCommand } : {},
+        ...configPkg?.buildScript ? { buildScript: configPkg.buildScript } : {},
+        ...configPkg?.buildCommand ? { buildCommand: configPkg.buildCommand } : {}
+      };
+    });
   }
   return {
     ...defaultConfig,
@@ -37565,6 +37779,7 @@ async function resolveConfig(config, cwd) {
       ...config.rollback
     },
     snapshotTemplate: config.snapshotTemplate ?? defaultConfig.snapshotTemplate,
+    ecosystems: config.ecosystems ?? {},
     plugins: config.plugins ?? [],
     versionSources: config.versionSources ?? defaultConfig.versionSources,
     conventionalCommits: {
@@ -37586,10 +37801,10 @@ function resolveEcosystemKey(pkg, _entry) {
 }
 // src/config/loader.ts
 var import_node_child_process = require("node:child_process");
-var import_promises9 = require("node:fs/promises");
+var import_promises8 = require("node:fs/promises");
 var import_node_module2 = require("node:module");
 var import_node_os5 = require("node:os");
-var import_node_path29 = __toESM(require("node:path"));
+var import_node_path31 = __toESM(require("node:path"));
 var import_node_url = require("node:url");
 var import_node_vm = __toESM(require("node:vm"));
 var CONFIG_FILES = [
@@ -37642,9 +37857,9 @@ var CONFIG_MODULE_SHIMS = {
 };
 async function findConfigFile(cwd) {
   for (const file of CONFIG_FILES) {
-    const filePath = import_node_path29.default.join(cwd, file);
+    const filePath = import_node_path31.default.join(cwd, file);
     try {
-      if ((await import_promises9.stat(filePath)).isFile()) {
+      if ((await import_promises8.stat(filePath)).isFile()) {
         return filePath;
       }
     } catch {}
@@ -37663,15 +37878,15 @@ function isBareSpecifier(specifier) {
   return !specifier.startsWith(".") && !specifier.startsWith("/") && !specifier.startsWith("file:") && !specifier.startsWith("node:");
 }
 async function findClosestPackageManifest(filePath) {
-  let current = import_node_path29.default.dirname(filePath);
+  let current = import_node_path31.default.dirname(filePath);
   while (true) {
-    const manifestPath = import_node_path29.default.join(current, "package.json");
+    const manifestPath = import_node_path31.default.join(current, "package.json");
     try {
-      if ((await import_promises9.stat(manifestPath)).isFile()) {
+      if ((await import_promises8.stat(manifestPath)).isFile()) {
         return manifestPath;
       }
     } catch {}
-    const parent = import_node_path29.default.dirname(current);
+    const parent = import_node_path31.default.dirname(current);
     if (parent === current) {
       return null;
     }
@@ -37687,7 +37902,7 @@ async function isOptionalDependencyImport(specifier, importerPath) {
     return false;
   }
   const packageName = getPackageName2(specifier);
-  const manifest = JSON.parse(await import_promises9.readFile(manifestPath, "utf8"));
+  const manifest = JSON.parse(await import_promises8.readFile(manifestPath, "utf8"));
   if (manifest.optionalDependencies?.[packageName]) {
     return true;
   }
@@ -37758,7 +37973,7 @@ async function collectOptionalDependenciesForInputs(inputPaths) {
   }
   const optionalDependencies = new Set;
   for (const manifestPath of manifestPaths) {
-    const manifest = JSON.parse(await import_promises9.readFile(manifestPath, "utf8"));
+    const manifest = JSON.parse(await import_promises8.readFile(manifestPath, "utf8"));
     for (const dependency of Object.keys(manifest.optionalDependencies ?? {})) {
       optionalDependencies.add(dependency);
     }
@@ -37773,13 +37988,13 @@ async function collectOptionalDependenciesForInputs(inputPaths) {
 async function findInstalledPackagePath(startDir, dependency) {
   let current = startDir;
   while (true) {
-    const packageDir = import_node_path29.default.join(current, "node_modules", dependency);
+    const packageDir = import_node_path31.default.join(current, "node_modules", dependency);
     try {
-      if ((await import_promises9.stat(packageDir)).isDirectory()) {
+      if ((await import_promises8.stat(packageDir)).isDirectory()) {
         return packageDir;
       }
     } catch {}
-    const parent = import_node_path29.default.dirname(current);
+    const parent = import_node_path31.default.dirname(current);
     if (parent === current) {
       return null;
     }
@@ -37787,19 +38002,19 @@ async function findInstalledPackagePath(startDir, dependency) {
   }
 }
 async function writeOptionalDependencyStubs(moduleDir, resolveFromDir, optionalDependencies) {
-  const nodeModulesDir = import_node_path29.default.join(moduleDir, "node_modules");
+  const nodeModulesDir = import_node_path31.default.join(moduleDir, "node_modules");
   for (const dependency of optionalDependencies) {
     if (await findInstalledPackagePath(resolveFromDir, dependency)) {
       continue;
     }
-    const packageDir = import_node_path29.default.join(nodeModulesDir, dependency);
-    await import_promises9.mkdir(packageDir, { recursive: true });
-    await import_promises9.writeFile(import_node_path29.default.join(packageDir, "package.json"), JSON.stringify({
+    const packageDir = import_node_path31.default.join(nodeModulesDir, dependency);
+    await import_promises8.mkdir(packageDir, { recursive: true });
+    await import_promises8.writeFile(import_node_path31.default.join(packageDir, "package.json"), JSON.stringify({
       name: dependency,
       private: true,
       main: "./index.js"
     }, null, 2), "utf8");
-    await import_promises9.writeFile(import_node_path29.default.join(packageDir, "index.js"), createOptionalDependencyProxyPackage(dependency), "utf8");
+    await import_promises8.writeFile(import_node_path31.default.join(packageDir, "index.js"), createOptionalDependencyProxyPackage(dependency), "utf8");
   }
 }
 function createOptionalDependencyPlugin(specifiers) {
@@ -37853,7 +38068,7 @@ function createConfigModuleShimPlugin() {
   };
 }
 async function runBunBuild(build, entrypoint, format3 = "esm", optionalDynamicImports = []) {
-  const entrypointSource = await import_promises9.readFile(entrypoint, "utf8");
+  const entrypointSource = await import_promises8.readFile(entrypoint, "utf8");
   const result = await build({
     entrypoints: [entrypoint],
     target: "bun",
@@ -37911,12 +38126,12 @@ async function buildConfigWithFormat(entrypoint, format3) {
 }
 async function buildConfigWithChildProcess(entrypoint, format3 = "esm") {
   const extension = format3 === "esm" ? "mjs" : "cjs";
-  const tempDir = await import_promises9.mkdtemp(import_node_path29.default.join(import_node_os5.tmpdir(), "pubm-config-"));
-  const buildScript = import_node_path29.default.join(tempDir, "build-config.mjs");
-  const outfile = import_node_path29.default.join(tempDir, `pubm.config.${extension}`);
-  const resultFile = import_node_path29.default.join(tempDir, "build-result.json");
+  const tempDir = await import_promises8.mkdtemp(import_node_path31.default.join(import_node_os5.tmpdir(), "pubm-config-"));
+  const buildScript = import_node_path31.default.join(tempDir, "build-config.mjs");
+  const outfile = import_node_path31.default.join(tempDir, `pubm.config.${extension}`);
+  const resultFile = import_node_path31.default.join(tempDir, "build-result.json");
   try {
-    await import_promises9.writeFile(buildScript, [
+    await import_promises8.writeFile(buildScript, [
       'import { readFile, stat, writeFile } from "node:fs/promises";',
       'import path from "node:path";',
       'import { pathToFileURL } from "node:url";',
@@ -38165,8 +38380,8 @@ async function buildConfigWithChildProcess(entrypoint, format3 = "esm") {
         resolve2();
       });
     });
-    const result = JSON.parse(await import_promises9.readFile(resultFile, "utf8"));
-    const contents = result.hasEntrypoint ? await import_promises9.readFile(outfile, "utf8") : null;
+    const result = JSON.parse(await import_promises8.readFile(resultFile, "utf8"));
+    const contents = result.hasEntrypoint ? await import_promises8.readFile(outfile, "utf8") : null;
     return {
       success: result.success,
       logs: result.logs,
@@ -38185,16 +38400,16 @@ async function buildConfigWithChildProcess(entrypoint, format3 = "esm") {
       outputs: []
     };
   } finally {
-    await import_promises9.rm(tempDir, { recursive: true, force: true });
+    await import_promises8.rm(tempDir, { recursive: true, force: true });
   }
 }
 function rewriteImportMeta(source, configPath) {
   const replacements = [
-    ["import.meta.dirname", JSON.stringify(import_node_path29.default.dirname(configPath))],
+    ["import.meta.dirname", JSON.stringify(import_node_path31.default.dirname(configPath))],
     ["import.meta.filename", JSON.stringify(configPath)],
     ["import.meta.path", JSON.stringify(configPath)],
     ["import.meta.url", JSON.stringify(import_node_url.pathToFileURL(configPath).href)],
-    ["import.meta.dir", JSON.stringify(import_node_path29.default.dirname(configPath))]
+    ["import.meta.dir", JSON.stringify(import_node_path31.default.dirname(configPath))]
   ];
   let rewritten = source;
   for (const [pattern, value] of replacements) {
@@ -38210,14 +38425,14 @@ async function importConfigModule(configPath) {
   return normalizeConfigNamespace(namespace);
 }
 async function importBundledConfig(source, configPath, optionalDependencies) {
-  const tempDir = await import_promises9.mkdtemp(import_node_path29.default.join(import_node_path29.default.dirname(configPath), ".pubm-config-module-"));
-  const tempFile = import_node_path29.default.join(tempDir, "pubm.config.mjs");
+  const tempDir = await import_promises8.mkdtemp(import_node_path31.default.join(import_node_path31.default.dirname(configPath), ".pubm-config-module-"));
+  const tempFile = import_node_path31.default.join(tempDir, "pubm.config.mjs");
   try {
-    await writeOptionalDependencyStubs(tempDir, import_node_path29.default.dirname(configPath), optionalDependencies);
-    await import_promises9.writeFile(tempFile, source, "utf8");
+    await writeOptionalDependencyStubs(tempDir, import_node_path31.default.dirname(configPath), optionalDependencies);
+    await import_promises8.writeFile(tempFile, source, "utf8");
     return importConfigModule(tempFile);
   } finally {
-    await import_promises9.rm(tempDir, { recursive: true, force: true });
+    await import_promises8.rm(tempDir, { recursive: true, force: true });
   }
 }
 async function executeBundledConfigInVm(source, configPath) {
@@ -38228,7 +38443,7 @@ async function executeBundledConfigInVm(source, configPath) {
     exports: module2.exports,
     require: require2,
     __filename: configPath,
-    __dirname: import_node_path29.default.dirname(configPath),
+    __dirname: import_node_path31.default.dirname(configPath),
     console,
     process,
     Buffer,
@@ -38259,9 +38474,9 @@ function formatStageError(stage, error4) {
 async function loadConfig(cwd = process.cwd(), configPath) {
   let resolvedConfigPath;
   if (configPath) {
-    resolvedConfigPath = import_node_path29.default.resolve(cwd, configPath);
+    resolvedConfigPath = import_node_path31.default.resolve(cwd, configPath);
     try {
-      if (!(await import_promises9.stat(resolvedConfigPath)).isFile()) {
+      if (!(await import_promises8.stat(resolvedConfigPath)).isFile()) {
         throw new Error(`Config path is not a file: ${resolvedConfigPath}`);
       }
     } catch (e3) {
@@ -38339,12 +38554,12 @@ function defineConfig(config) {
 init_context();
 
 // src/conventional-commit/scope-resolver.ts
-var import_node_path30 = __toESM(require("node:path"));
+var import_node_path32 = __toESM(require("node:path"));
 function resolveCommitPackages(commit, packagePaths) {
   const matched = new Set;
   if (commit.scope) {
     for (const pkgPath of packagePaths) {
-      const dirName = import_node_path30.default.basename(pkgPath);
+      const dirName = import_node_path32.default.basename(pkgPath);
       if (dirName === commit.scope) {
         matched.add(pkgPath);
       }
@@ -38599,7 +38814,7 @@ function inspectPackages(config, cwd) {
 init_manifest_reader();
 // src/migrate/adapters/changesets.ts
 var import_node_fs19 = require("node:fs");
-var import_node_path31 = __toESM(require("node:path"));
+var import_node_path33 = __toESM(require("node:path"));
 var SKIPPED_DIR_ENTRIES = new Set(["config.json", "README.md", ".gitkeep"]);
 var CHANGELOG_PRESET_MAP = {
   "@changesets/changelog-github": "github",
@@ -38617,11 +38832,11 @@ var changesetsAdapter = {
   name: "changesets",
   configFilePatterns: [".changeset/config.json"],
   async detect(cwd) {
-    const configFile = import_node_path31.default.join(cwd, ".changeset", "config.json");
+    const configFile = import_node_path33.default.join(cwd, ".changeset", "config.json");
     if (!import_node_fs19.existsSync(configFile)) {
       return { found: false, configFiles: [], relatedFiles: [] };
     }
-    const changesetDir = import_node_path31.default.dirname(configFile);
+    const changesetDir = import_node_path33.default.dirname(configFile);
     const relatedFiles = [];
     try {
       const entries = import_node_fs19.readdirSync(changesetDir, { encoding: "utf-8" });
@@ -38629,7 +38844,7 @@ var changesetsAdapter = {
         if (SKIPPED_DIR_ENTRIES.has(entry))
           continue;
         if (entry.endsWith(".md") || entry === "pre.json") {
-          relatedFiles.push(import_node_path31.default.join(changesetDir, entry));
+          relatedFiles.push(import_node_path33.default.join(changesetDir, entry));
         }
       }
     } catch {}
@@ -38640,7 +38855,7 @@ var changesetsAdapter = {
     };
   },
   async parse(files, cwd) {
-    const configFile = files.find((f2) => f2.endsWith(`${import_node_path31.default.sep}config.json`) || f2.endsWith("/config.json"));
+    const configFile = files.find((f2) => f2.endsWith(`${import_node_path33.default.sep}config.json`) || f2.endsWith("/config.json"));
     if (configFile === undefined) {
       return { source: "changesets", unmappable: [] };
     }
@@ -38675,7 +38890,7 @@ var changesetsAdapter = {
       if (hasUpdateInternalDeps)
         result.monorepo.updateInternalDeps = config.updateInternalDependencies;
     }
-    const preJsonPath = import_node_path31.default.join(cwd, ".changeset", "pre.json");
+    const preJsonPath = import_node_path33.default.join(cwd, ".changeset", "pre.json");
     if (import_node_fs19.existsSync(preJsonPath)) {
       try {
         const preRaw = import_node_fs19.readFileSync(preJsonPath, "utf-8");
@@ -38709,12 +38924,12 @@ var changesetsAdapter = {
     const configFile = detected.configFiles[0];
     if (configFile === undefined)
       return [];
-    return [import_node_path31.default.dirname(configFile)];
+    return [import_node_path33.default.dirname(configFile)];
   }
 };
 // src/migrate/adapters/np.ts
 var import_node_fs20 = require("node:fs");
-var import_node_path32 = __toESM(require("node:path"));
+var import_node_path34 = __toESM(require("node:path"));
 var import_node_url2 = require("node:url");
 var STANDALONE_CONFIG_FILES = [
   ".np-config.json",
@@ -38819,12 +39034,12 @@ var npAdapter = {
   async detect(cwd) {
     const configFiles = [];
     for (const filename of STANDALONE_CONFIG_FILES) {
-      const filePath = import_node_path32.default.join(cwd, filename);
+      const filePath = import_node_path34.default.join(cwd, filename);
       if (import_node_fs20.existsSync(filePath)) {
         configFiles.push(filePath);
       }
     }
-    const pkgJsonPath = import_node_path32.default.join(cwd, PACKAGE_JSON);
+    const pkgJsonPath = import_node_path34.default.join(cwd, PACKAGE_JSON);
     if (import_node_fs20.existsSync(pkgJsonPath)) {
       try {
         const raw = import_node_fs20.readFileSync(pkgJsonPath, "utf-8");
@@ -38841,8 +39056,8 @@ var npAdapter = {
     };
   },
   async parse(files, _cwd) {
-    const standaloneFile = files.find((f2) => STANDALONE_CONFIG_FILES.some((name) => f2.endsWith(import_node_path32.default.sep + name) || f2.endsWith(`/${name}`)));
-    const pkgJsonFile = files.find((f2) => f2.endsWith(import_node_path32.default.sep + PACKAGE_JSON) || f2.endsWith(`/${PACKAGE_JSON}`));
+    const standaloneFile = files.find((f2) => STANDALONE_CONFIG_FILES.some((name) => f2.endsWith(import_node_path34.default.sep + name) || f2.endsWith(`/${name}`)));
+    const pkgJsonFile = files.find((f2) => f2.endsWith(import_node_path34.default.sep + PACKAGE_JSON) || f2.endsWith(`/${PACKAGE_JSON}`));
     const configFile = standaloneFile ?? pkgJsonFile;
     if (configFile === undefined) {
       return {
@@ -38861,12 +39076,12 @@ var npAdapter = {
     };
   },
   getCleanupTargets(detected) {
-    return detected.configFiles.filter((f2) => !f2.endsWith(import_node_path32.default.sep + PACKAGE_JSON) && !f2.endsWith(`/${PACKAGE_JSON}`));
+    return detected.configFiles.filter((f2) => !f2.endsWith(import_node_path34.default.sep + PACKAGE_JSON) && !f2.endsWith(`/${PACKAGE_JSON}`));
   }
 };
 // src/migrate/adapters/release-it.ts
 var import_node_fs21 = require("node:fs");
-var import_node_path33 = __toESM(require("node:path"));
+var import_node_path35 = __toESM(require("node:path"));
 var import_node_url3 = require("node:url");
 var import_yaml4 = __toESM(require_dist(), 1);
 var STANDALONE_CONFIG_FILES2 = [
@@ -38892,7 +39107,7 @@ async function loadConfigFile(filePath) {
   if (filePath.endsWith(".yaml") || filePath.endsWith(".yml")) {
     return import_yaml4.default.parse(raw);
   }
-  if (filePath.endsWith(import_node_path33.default.sep + PACKAGE_JSON2) || filePath.endsWith(`/${PACKAGE_JSON2}`)) {
+  if (filePath.endsWith(import_node_path35.default.sep + PACKAGE_JSON2) || filePath.endsWith(`/${PACKAGE_JSON2}`)) {
     const parsed = JSON.parse(raw);
     return parsed["release-it"] ?? {};
   }
@@ -39007,12 +39222,12 @@ var releaseItAdapter = {
   async detect(cwd) {
     const configFiles = [];
     for (const filename of STANDALONE_CONFIG_FILES2) {
-      const filePath = import_node_path33.default.join(cwd, filename);
+      const filePath = import_node_path35.default.join(cwd, filename);
       if (import_node_fs21.existsSync(filePath)) {
         configFiles.push(filePath);
       }
     }
-    const pkgJsonPath = import_node_path33.default.join(cwd, PACKAGE_JSON2);
+    const pkgJsonPath = import_node_path35.default.join(cwd, PACKAGE_JSON2);
     if (import_node_fs21.existsSync(pkgJsonPath)) {
       try {
         const raw = import_node_fs21.readFileSync(pkgJsonPath, "utf-8");
@@ -39029,8 +39244,8 @@ var releaseItAdapter = {
     };
   },
   async parse(files, _cwd) {
-    const standaloneFile = files.find((f2) => STANDALONE_CONFIG_FILES2.some((name) => f2.endsWith(import_node_path33.default.sep + name) || f2.endsWith(`/${name}`)));
-    const pkgJsonFile = files.find((f2) => f2.endsWith(import_node_path33.default.sep + PACKAGE_JSON2) || f2.endsWith(`/${PACKAGE_JSON2}`));
+    const standaloneFile = files.find((f2) => STANDALONE_CONFIG_FILES2.some((name) => f2.endsWith(import_node_path35.default.sep + name) || f2.endsWith(`/${name}`)));
+    const pkgJsonFile = files.find((f2) => f2.endsWith(import_node_path35.default.sep + PACKAGE_JSON2) || f2.endsWith(`/${PACKAGE_JSON2}`));
     const configFile = standaloneFile ?? pkgJsonFile;
     if (configFile === undefined) {
       return {
@@ -39060,12 +39275,12 @@ var releaseItAdapter = {
     };
   },
   getCleanupTargets(detected) {
-    return detected.configFiles.filter((f2) => !f2.endsWith(import_node_path33.default.sep + PACKAGE_JSON2) && !f2.endsWith(`/${PACKAGE_JSON2}`));
+    return detected.configFiles.filter((f2) => !f2.endsWith(import_node_path35.default.sep + PACKAGE_JSON2) && !f2.endsWith(`/${PACKAGE_JSON2}`));
   }
 };
 // src/migrate/adapters/semantic-release.ts
 var import_node_fs22 = require("node:fs");
-var import_node_path34 = __toESM(require("node:path"));
+var import_node_path36 = __toESM(require("node:path"));
 var import_node_url4 = require("node:url");
 var import_yaml5 = __toESM(require_dist(), 1);
 var STANDALONE_CONFIG_FILES3 = [
@@ -39156,11 +39371,11 @@ async function loadConfigFile2(filePath) {
   if (filePath.endsWith(".yaml") || filePath.endsWith(".yml")) {
     return import_yaml5.default.parse(raw);
   }
-  if (filePath.endsWith(import_node_path34.default.sep + PACKAGE_JSON3) || filePath.endsWith(`/${PACKAGE_JSON3}`)) {
+  if (filePath.endsWith(import_node_path36.default.sep + PACKAGE_JSON3) || filePath.endsWith(`/${PACKAGE_JSON3}`)) {
     const parsed = JSON.parse(raw);
     return parsed.release ?? {};
   }
-  const basename4 = import_node_path34.default.basename(filePath);
+  const basename4 = import_node_path36.default.basename(filePath);
   if (basename4 === ".releaserc") {
     try {
       return JSON.parse(raw);
@@ -39270,12 +39485,12 @@ var semanticReleaseAdapter = {
   async detect(cwd) {
     const configFiles = [];
     for (const filename of STANDALONE_CONFIG_FILES3) {
-      const filePath = import_node_path34.default.join(cwd, filename);
+      const filePath = import_node_path36.default.join(cwd, filename);
       if (import_node_fs22.existsSync(filePath)) {
         configFiles.push(filePath);
       }
     }
-    const pkgJsonPath = import_node_path34.default.join(cwd, PACKAGE_JSON3);
+    const pkgJsonPath = import_node_path36.default.join(cwd, PACKAGE_JSON3);
     if (import_node_fs22.existsSync(pkgJsonPath)) {
       try {
         const raw = import_node_fs22.readFileSync(pkgJsonPath, "utf-8");
@@ -39292,8 +39507,8 @@ var semanticReleaseAdapter = {
     };
   },
   async parse(files, _cwd) {
-    const standaloneFile = files.find((f2) => STANDALONE_CONFIG_FILES3.some((name) => f2.endsWith(import_node_path34.default.sep + name) || f2.endsWith(`/${name}`)));
-    const pkgJsonFile = files.find((f2) => f2.endsWith(import_node_path34.default.sep + PACKAGE_JSON3) || f2.endsWith(`/${PACKAGE_JSON3}`));
+    const standaloneFile = files.find((f2) => STANDALONE_CONFIG_FILES3.some((name) => f2.endsWith(import_node_path36.default.sep + name) || f2.endsWith(`/${name}`)));
+    const pkgJsonFile = files.find((f2) => f2.endsWith(import_node_path36.default.sep + PACKAGE_JSON3) || f2.endsWith(`/${PACKAGE_JSON3}`));
     const configFile = standaloneFile ?? pkgJsonFile;
     if (configFile === undefined) {
       return {
@@ -39311,12 +39526,12 @@ var semanticReleaseAdapter = {
     };
   },
   getCleanupTargets(detected) {
-    return detected.configFiles.filter((f2) => !f2.endsWith(import_node_path34.default.sep + PACKAGE_JSON3) && !f2.endsWith(`/${PACKAGE_JSON3}`));
+    return detected.configFiles.filter((f2) => !f2.endsWith(import_node_path36.default.sep + PACKAGE_JSON3) && !f2.endsWith(`/${PACKAGE_JSON3}`));
   }
 };
 // src/migrate/ci-advisor.ts
 var import_node_fs23 = require("node:fs");
-var import_node_path35 = require("node:path");
+var import_node_path37 = require("node:path");
 var CI_PATTERNS = {
   "semantic-release": [
     /npx\s+semantic-release/,
@@ -39336,7 +39551,7 @@ var CI_PATTERNS = {
   np: [/npx\s+np\b/, /yarn\s+np\b/]
 };
 function scanCiWorkflows(cwd, source) {
-  const workflowsDir = import_node_path35.join(cwd, ".github", "workflows");
+  const workflowsDir = import_node_path37.join(cwd, ".github", "workflows");
   if (!import_node_fs23.existsSync(workflowsDir))
     return [];
   const patterns = CI_PATTERNS[source];
@@ -39345,7 +39560,7 @@ function scanCiWorkflows(cwd, source) {
   for (const filename of files) {
     if (!filename.endsWith(".yml") && !filename.endsWith(".yaml"))
       continue;
-    const filePath = import_node_path35.join(workflowsDir, filename);
+    const filePath = import_node_path37.join(workflowsDir, filename);
     const content = import_node_fs23.readFileSync(filePath, "utf-8");
     for (const line of content.split(`
 `)) {
@@ -39588,7 +39803,7 @@ async function detectMigrationSources(cwd, adapters, from) {
 }
 // src/migrate/pipeline.ts
 var import_node_fs25 = require("node:fs");
-var import_node_path36 = require("node:path");
+var import_node_path38 = require("node:path");
 async function executeMigration(options) {
   const { adapter, detected, cwd, dryRun, clean } = options;
   const parsed = await adapter.parse(detected.configFiles, cwd);
@@ -39597,7 +39812,7 @@ async function executeMigration(options) {
   const configString = generateConfigString(convertResult.config);
   const ciAdvice = scanCiWorkflows(cwd, adapter.name);
   if (!dryRun) {
-    const outFile = import_node_path36.join(cwd, "pubm.config.ts");
+    const outFile = import_node_path38.join(cwd, "pubm.config.ts");
     if (import_node_fs25.existsSync(outFile)) {
       throw new Error("pubm.config.ts already exists. Remove or rename it before migrating.");
     }
@@ -39662,12 +39877,12 @@ function topologicalSort(graph) {
   return sorted.reverse();
 }
 // src/monorepo/groups.ts
-var import_micromatch4 = __toESM(require_micromatch(), 1);
+var import_micromatch5 = __toESM(require_micromatch(), 1);
 function resolveGroups(groups, allPackages) {
   return groups.map((group) => {
     const resolved = new Set;
     for (const pattern of group) {
-      const matches = import_micromatch4.default(allPackages, pattern);
+      const matches = import_micromatch5.default(allPackages, pattern);
       for (const match of matches) {
         resolved.add(match);
       }
@@ -39864,7 +40079,7 @@ class ChangesetSource {
   }
 }
 // src/version-source/conventional-commit-source.ts
-var import_node_path37 = __toESM(require("node:path"));
+var import_node_path39 = __toESM(require("node:path"));
 class ConventionalCommitSource {
   name = "conventional-commit";
   typeOverrides;
@@ -39875,7 +40090,7 @@ class ConventionalCommitSource {
     const packagePaths = [...context.packages.keys()];
     const recommendations = [];
     for (const packagePath of packagePaths) {
-      const packageName = import_node_path37.default.basename(packagePath);
+      const packageName = import_node_path39.default.basename(packagePath);
       const ref = findLastReleaseRef(context.cwd, packageName);
       const rawCommits = getCommitsSinceRef(context.cwd, ref);
       const parsed = [];
@@ -40621,33 +40836,33 @@ init_exec();
 var import_child_process = require("child_process");
 var import_child_process2 = require("child_process");
 var import_fs = require("fs");
-var import_promises10 = __toESM(require("fs/promises"));
+var import_promises9 = __toESM(require("fs/promises"));
 var import_path = __toESM(require("path"));
 var import_stream2 = require("stream");
-var import_promises11 = require("stream/promises");
+var import_promises10 = require("stream/promises");
 var import_util6 = require("util");
-var import_promises12 = __toESM(require("fs/promises"));
+var import_promises11 = __toESM(require("fs/promises"));
 var import_crypto2 = __toESM(require("crypto"));
 var import_fs2 = require("fs");
 var import_crypto3 = __toESM(require("crypto"));
 var import_semver12 = __toESM(require_semver2(), 1);
-var import_promises13 = __toESM(require("fs/promises"));
+var import_promises12 = __toESM(require("fs/promises"));
 var import_path2 = __toESM(require("path"));
 var import_semver13 = __toESM(require_semver2(), 1);
 var import_semver14 = __toESM(require_semver2(), 1);
-var import_promises14 = require("fs/promises");
+var import_promises13 = require("fs/promises");
 var import_child_process3 = require("child_process");
 var import_util7 = require("util");
 var import_child_process4 = require("child_process");
-var import_promises15 = require("fs/promises");
+var import_promises14 = require("fs/promises");
 var import_util8 = require("util");
-var import_promises16 = require("fs/promises");
+var import_promises15 = require("fs/promises");
 var import_os2 = require("os");
 var import_path3 = require("path");
 var import_os3 = __toESM(require("os"));
 var import_path4 = __toESM(require("path"));
 var import_fs3 = require("fs");
-var import_promises17 = require("fs/promises");
+var import_promises16 = require("fs/promises");
 var import_path5 = require("path");
 var import_url = require("url");
 var DEFAULT_CHECK_INTERVAL_MS = 72000000;
@@ -40842,7 +41057,7 @@ function isBrewAlreadyInstalled(stdout, stderr) {
 }
 async function atomicReplace(newPath, targetPath) {
   try {
-    await import_promises12.default.access(targetPath, import_promises12.default.constants.W_OK);
+    await import_promises11.default.access(targetPath, import_promises11.default.constants.W_OK);
   } catch {
     throw new UpdateKitError(PERMISSION_DENIED, `No write permission: ${targetPath}. Run with appropriate permissions.`);
   }
@@ -40855,12 +41070,12 @@ async function atomicReplace(newPath, targetPath) {
 async function unixReplace(newPath, targetPath) {
   const tmpInPlace = `${targetPath}.new.${process.pid}`;
   try {
-    await import_promises12.default.copyFile(newPath, tmpInPlace);
-    await import_promises12.default.chmod(tmpInPlace, 493);
-    await import_promises12.default.rename(tmpInPlace, targetPath);
+    await import_promises11.default.copyFile(newPath, tmpInPlace);
+    await import_promises11.default.chmod(tmpInPlace, 493);
+    await import_promises11.default.rename(tmpInPlace, targetPath);
   } catch (error4) {
     try {
-      await import_promises12.default.unlink(tmpInPlace);
+      await import_promises11.default.unlink(tmpInPlace);
     } catch {}
     throw error4;
   }
@@ -40868,21 +41083,21 @@ async function unixReplace(newPath, targetPath) {
 async function windowsReplace(newPath, targetPath) {
   const backupPath = `${targetPath}.old`;
   try {
-    await import_promises12.default.unlink(backupPath);
+    await import_promises11.default.unlink(backupPath);
   } catch {}
-  await import_promises12.default.rename(targetPath, backupPath);
+  await import_promises11.default.rename(targetPath, backupPath);
   try {
-    await import_promises12.default.copyFile(newPath, targetPath);
+    await import_promises11.default.copyFile(newPath, targetPath);
   } catch (copyError) {
     try {
-      await import_promises12.default.rename(backupPath, targetPath);
+      await import_promises11.default.rename(backupPath, targetPath);
     } catch (rollbackError) {
       throw new UpdateKitError(APPLY_FAILED, `Update failed and rollback also failed. Original binary may be at ${backupPath}. Copy error: ${copyError instanceof Error ? copyError.message : String(copyError)}. Rollback error: ${rollbackError instanceof Error ? rollbackError.message : String(rollbackError)}.`);
     }
     throw copyError;
   }
   try {
-    await import_promises12.default.unlink(backupPath);
+    await import_promises11.default.unlink(backupPath);
   } catch {}
 }
 async function fetchWithTimeout(url, options = {}) {
@@ -41067,12 +41282,12 @@ async function downloadArtifact(url, tmpDir, options) {
       totalBytes
     });
   });
-  await import_promises11.pipeline(nodeStream, writeStream);
+  await import_promises10.pipeline(nodeStream, writeStream);
   return destPath;
 }
 async function extractBinary(archivePath, tmpDir) {
   const extractDir = import_path.default.join(tmpDir, "extracted");
-  await import_promises10.default.mkdir(extractDir, { recursive: true });
+  await import_promises9.default.mkdir(extractDir, { recursive: true });
   if (archivePath.endsWith(".tar.gz") || archivePath.endsWith(".tgz")) {
     try {
       await execFileAsync("tar", ["xzf", archivePath, "-C", extractDir]);
@@ -41099,14 +41314,14 @@ async function extractBinary(archivePath, tmpDir) {
     }
   } else {
     const destPath = import_path.default.join(extractDir, import_path.default.basename(archivePath));
-    await import_promises10.default.copyFile(archivePath, destPath);
+    await import_promises9.default.copyFile(archivePath, destPath);
     return destPath;
   }
   return findBinaryInDir(extractDir);
 }
 async function findBinaryInDir(dir) {
-  const resolvedDir = await import_promises10.default.realpath(dir);
-  const entries = await import_promises10.default.readdir(dir, {
+  const resolvedDir = await import_promises9.default.realpath(dir);
+  const entries = await import_promises9.default.readdir(dir, {
     withFileTypes: true,
     recursive: true
   });
@@ -41117,7 +41332,7 @@ async function findBinaryInDir(dir) {
     const parentDir = e3.parentPath ?? ("path" in e3 ? e3.path : dir);
     const filePath = import_path.default.join(parentDir, e3.name);
     try {
-      const resolvedFile = await import_promises10.default.realpath(filePath);
+      const resolvedFile = await import_promises9.default.realpath(filePath);
       if (!resolvedFile.startsWith(resolvedDir + import_path.default.sep) && resolvedFile !== resolvedDir) {
         continue;
       }
@@ -41134,7 +41349,7 @@ async function findBinaryInDir(dir) {
   }
   for (const file of files) {
     try {
-      await import_promises10.default.access(file, import_promises10.default.constants.X_OK);
+      await import_promises9.default.access(file, import_promises9.default.constants.X_OK);
       return file;
     } catch {}
   }
@@ -41166,16 +41381,16 @@ function extractFilename(url) {
 async function createTempDir(targetPath) {
   const targetDir = import_path.default.dirname(targetPath);
   const tmpDir = import_path.default.join(targetDir, `.update-kit-tmp-${process.pid}-${Date.now()}`);
-  await import_promises10.default.mkdir(tmpDir, { recursive: true });
+  await import_promises9.default.mkdir(tmpDir, { recursive: true });
   return tmpDir;
 }
 async function cleanupTempDir(tmpDir) {
   try {
-    await import_promises10.default.rm(tmpDir, { recursive: true, force: true });
+    await import_promises9.default.rm(tmpDir, { recursive: true, force: true });
   } catch {}
 }
 async function setExecutablePermission(filePath) {
-  await import_promises10.default.chmod(filePath, 493);
+  await import_promises9.default.chmod(filePath, 493);
 }
 function getCachePath(cacheDir, appName) {
   return import_path2.default.join(cacheDir, appName, "update-check.json");
@@ -41183,7 +41398,7 @@ function getCachePath(cacheDir, appName) {
 async function readCache(cacheDir, appName) {
   const filePath = getCachePath(cacheDir, appName);
   try {
-    const raw = await import_promises13.default.readFile(filePath, "utf-8");
+    const raw = await import_promises12.default.readFile(filePath, "utf-8");
     const parsed = JSON.parse(raw);
     if (typeof parsed.latestVersion !== "string" || typeof parsed.currentVersionAtCheck !== "string" || typeof parsed.lastCheckedAt !== "string" || typeof parsed.source !== "string") {
       return null;
@@ -41199,16 +41414,16 @@ async function readCache(cacheDir, appName) {
 async function writeCache(cacheDir, appName, entry) {
   const filePath = getCachePath(cacheDir, appName);
   const dir = import_path2.default.dirname(filePath);
-  await import_promises13.default.mkdir(dir, { recursive: true });
+  await import_promises12.default.mkdir(dir, { recursive: true });
   const tmpPath = `${filePath}.${process.pid}-${Date.now()}.tmp`;
   try {
     const data = `${JSON.stringify(entry, null, 2)}
 `;
-    await import_promises13.default.writeFile(tmpPath, data, "utf-8");
-    await import_promises13.default.rename(tmpPath, filePath);
+    await import_promises12.default.writeFile(tmpPath, data, "utf-8");
+    await import_promises12.default.rename(tmpPath, filePath);
   } catch (error4) {
     try {
-      await import_promises13.default.unlink(tmpPath);
+      await import_promises12.default.unlink(tmpPath);
     } catch {}
     throw new UpdateKitError(CACHE_ERROR, `Failed to write cache for ${appName}: ${error4 instanceof Error ? error4.message : String(error4)}`, { cause: error4 instanceof Error ? error4 : undefined });
   }
@@ -41892,9 +42107,9 @@ async function detectFromNpm(execPath) {
     }
   } catch {}
   try {
-    const stats = await import_promises15.lstat(execPath);
+    const stats = await import_promises14.lstat(execPath);
     if (stats.isSymbolicLink()) {
-      const target = await import_promises15.readlink(execPath);
+      const target = await import_promises14.readlink(execPath);
       if (target.includes("node_modules")) {
         evidence.push({
           source: "symlink",
@@ -41917,7 +42132,7 @@ async function detectFromReceipt(config, receiptDir) {
   const dir = receiptDir ?? import_path3.join(import_os2.homedir(), ".config", config.appName);
   const receiptPath = import_path3.join(dir, "install-receipt.json");
   try {
-    const content = await import_promises16.readFile(receiptPath, "utf-8");
+    const content = await import_promises15.readFile(receiptPath, "utf-8");
     const receipt = JSON.parse(content);
     if (receipt.appName !== config.appName) {
       return null;
@@ -41939,7 +42154,7 @@ async function detectFromReceipt(config, receiptDir) {
 async function detectInstall(execPath, config) {
   let resolvedPath;
   try {
-    resolvedPath = await import_promises14.realpath(execPath);
+    resolvedPath = await import_promises13.realpath(execPath);
   } catch {
     resolvedPath = execPath;
   }
@@ -42210,7 +42425,7 @@ async function findPackageJson(startDir) {
   for (;; ) {
     const candidate = import_path5.join(current, "package.json");
     try {
-      const content = await import_promises17.readFile(candidate, "utf-8");
+      const content = await import_promises16.readFile(candidate, "utf-8");
       const result = parsePackageJson(content, candidate);
       if (result)
         return result;
@@ -42637,10 +42852,10 @@ init_ui();
 
 // src/validate/entry-points.ts
 var import_node_fs26 = require("node:fs");
-var import_node_path38 = __toESM(require("node:path"));
+var import_node_path40 = __toESM(require("node:path"));
 var SIMPLE_FIELDS = ["main", "module", "types", "typings"];
 function checkPath(filePath, cwd) {
-  return import_node_fs26.existsSync(import_node_path38.default.resolve(cwd, filePath));
+  return import_node_fs26.existsSync(import_node_path40.default.resolve(cwd, filePath));
 }
 function validateExports(exports2, cwd, prefix = "exports") {
   const errors = [];
@@ -42690,7 +42905,7 @@ function validateEntryPoints(pkg, cwd) {
   return errors;
 }
 // src/validate/extraneous-files.ts
-var import_micromatch5 = __toESM(require_micromatch(), 1);
+var import_micromatch6 = __toESM(require_micromatch(), 1);
 var PATTERNS = [
   {
     pattern: [".env", ".env.*"],
@@ -42728,7 +42943,7 @@ function detectExtraneousFiles(files) {
   const seen = new Set;
   for (const { pattern, reason, basename: basename4 } of PATTERNS) {
     const options = basename4 ? { basename: true } : {};
-    const matched = import_micromatch5.default(files, pattern, options);
+    const matched = import_micromatch6.default(files, pattern, options);
     for (const file of matched) {
       if (!seen.has(file)) {
         seen.add(file);