@pubm/core 0.5.0 → 0.5.2

package/dist/index.js

@@ -17614,7 +17614,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@pubm/core",
-    version: "0.5.0",
+    version: "0.5.2",
     type: "module",
     description: "Core SDK for pubm - publish manager for multiple registries",
     types: "./dist/index.d.ts",
@@ -17693,7 +17693,7 @@ var coreEngines, PUBM_VERSION, PUBM_ENGINES;
 var init_pubm_metadata = __esm(() => {
   init_package();
   coreEngines = package_default.engines ?? {};
-  PUBM_VERSION = resolveDefine("0.5.0", 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"),
@@ -20492,7 +20492,6 @@ ${stderr}` : ""}`, {
     }
     getRequirements() {
       return {
-        needsPackageScripts: false,
         requiredManifest: "jsr.json or deno.json"
       };
     }
@@ -21897,7 +21896,6 @@ ${cleanCargoStderr(stderr)}` : "Failed to run `cargo publish --dry-run`";
     }
     getRequirements() {
       return {
-        needsPackageScripts: false,
         requiredManifest: "Cargo.toml"
       };
     }
@@ -22077,11 +22075,16 @@ var init_rust = __esm(() => {
     manifestFiles() {
       return ["Cargo.toml"];
     }
-    defaultTestCommand() {
-      return "cargo test";
+    resolveTestCommand(script) {
+      const parts = script.split(/\s+/);
+      return Promise.resolve({ cmd: "cargo", args: parts });
     }
-    defaultBuildCommand() {
-      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"];
@@ -22949,7 +22952,6 @@ function registerPrivateRegistry(config, ecosystemKey, catalog = registryCatalog
       tokenUrl: config.url,
       tokenUrlLabel: key
     },
-    needsPackageScripts: false,
     concurrentPublish: true,
     unpublishLabel: "Unpublish",
     requiresEarlyAuth: false,
@@ -22992,7 +22994,6 @@ var init_catalog = __esm(() => {
       tokenUrl: "https://www.npmjs.com/settings/~/tokens/granular-access-tokens/new",
       tokenUrlLabel: "npmjs.com"
     },
-    needsPackageScripts: true,
     additionalEnvVars: (token) => ({
       "npm_config_//registry.npmjs.org/:_authToken": token
     }),
@@ -23040,7 +23041,6 @@ var init_catalog = __esm(() => {
       tokenUrl: "https://jsr.io/account/tokens/create",
       tokenUrlLabel: "jsr.io"
     },
-    needsPackageScripts: false,
     validateToken: async (token) => {
       const res = await fetch("https://jsr.io/api/user", {
         headers: { Authorization: `Bearer ${token}` }
@@ -23078,7 +23078,6 @@ var init_catalog = __esm(() => {
       tokenUrl: "https://crates.io/settings/tokens/new",
       tokenUrlLabel: "crates.io"
     },
-    needsPackageScripts: false,
     validateToken: async (token) => {
       return token.trim().length >= 32;
     },
@@ -23454,7 +23453,6 @@ ${stderr}` : ""}`, { cause: error4 });
     }
     getRequirements() {
       return {
-        needsPackageScripts: true,
         requiredManifest: "package.json"
       };
     }
@@ -23615,13 +23613,26 @@ var init_js = __esm(() => {
     manifestFiles() {
       return ["package.json"];
     }
-    async defaultTestCommand() {
+    async resolveTestCommand(script) {
       const pm = await getPackageManager();
-      return `${pm} run test`;
+      return { cmd: pm, args: ["run", script] };
     }
-    async defaultBuildCommand() {
+    async resolveBuildCommand(script) {
       const pm = await getPackageManager();
-      return `${pm} run build`;
+      return { cmd: pm, args: ["run", script] };
+    }
+    async validateScript(script, _type) {
+      const pkgPath = path5.join(this.packagePath, "package.json");
+      try {
+        const raw = await readFile5(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"];
@@ -23762,13 +23773,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",
@@ -23776,6 +23780,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
@@ -35526,8 +35537,8 @@ var prerequisitesCheckTask = (options) => {
 };
 
 // src/tasks/required-conditions-check.ts
-import { readFile as readFile7 } from "node:fs/promises";
-import { join as join9 } from "node:path";
+import path12 from "node:path";
+init_catalog2();
 init_error4();
 init_git();
 init_i18n();
@@ -35554,10 +35565,6 @@ async function validateEngineVersion(engine, version) {
 }
 
 // src/tasks/required-conditions-check.ts
-function needsPackageScripts(registries) {
-  return registries.some((r2) => registryCatalog.get(r2)?.needsPackageScripts ?? true);
-}
-
 class RequiredConditionCheckError extends AbstractError {
   name = t("error.conditions.name");
   constructor(message, { cause } = {}) {
@@ -35619,20 +35626,66 @@ var requiredConditionsCheckTask = (options) => {
       },
       {
         title: t("task.conditions.checkScripts"),
-        skip: (ctx2) => !needsPackageScripts(collectRegistries(ctx2.config)),
+        skip: (ctx2) => !!ctx2.options.skipTests && !!ctx2.options.skipBuild,
         task: async (ctx2) => {
-          const raw = await readFile7(join9(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 : path12.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 : path12.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", {
@@ -35810,7 +35863,7 @@ function createPublishTasks(hasPublish, dryRun, skipPublish) {
 init_dist2();
 var import_semver4 = __toESM(require_semver2(), 1);
 import { existsSync as existsSync6, readFileSync as readFileSync9, rmSync } from "node:fs";
-import { join as join10 } from "node:path";
+import { join as join9 } from "node:path";
 import process19 from "node:process";
 
 // src/changeset/changelog-parser.ts
@@ -35985,7 +36038,7 @@ async function deleteGitHubRelease(releaseId) {
 
 // src/tasks/runner-utils/version-pr.ts
 import { existsSync as existsSync5, readFileSync as readFileSync8 } from "node:fs";
-import path12 from "node:path";
+import path13 from "node:path";
 import process18 from "node:process";
 init_error4();
 init_git();
@@ -36170,8 +36223,8 @@ function buildPrBodyFromContext(ctx, plan) {
       const pkgConfig = ctx.config.packages.find((p2) => p2.path === pkgPath);
       const name = pkgConfig?.name ?? pkgPath;
       packages.push({ name, version: pkgVersion, bump: "" });
-      const changelogDir = pkgConfig ? path12.resolve(ctx.cwd, pkgConfig.path) : ctx.cwd;
-      const changelogPath = path12.join(changelogDir, "CHANGELOG.md");
+      const changelogDir = pkgConfig ? path13.resolve(ctx.cwd, pkgConfig.path) : ctx.cwd;
+      const changelogPath = path13.join(changelogDir, "CHANGELOG.md");
       if (existsSync5(changelogPath)) {
         const section = parseChangelogSection(readFileSync8(changelogPath, "utf-8"), pkgVersion);
         if (section)
@@ -36184,7 +36237,7 @@ function buildPrBodyFromContext(ctx, plan) {
       packages.push({ name: pkg.name, version, bump: "" });
     }
     if (plan.mode === "single") {
-      const changelogPath = path12.join(ctx.cwd, "CHANGELOG.md");
+      const changelogPath = path13.join(ctx.cwd, "CHANGELOG.md");
       if (existsSync5(changelogPath)) {
         const section = parseChangelogSection(readFileSync8(changelogPath, "utf-8"), version);
         if (section)
@@ -36192,7 +36245,7 @@ function buildPrBodyFromContext(ctx, plan) {
       }
     } else {
       for (const pkg of ctx.config.packages) {
-        const changelogPath = path12.join(ctx.cwd, pkg.path, "CHANGELOG.md");
+        const changelogPath = path13.join(ctx.cwd, pkg.path, "CHANGELOG.md");
         if (existsSync5(changelogPath)) {
           const section = parseChangelogSection(readFileSync8(changelogPath, "utf-8"), version);
           if (section)
@@ -36295,7 +36348,7 @@ function createReleaseTask(hasPublish, dryRun, mode, skipReleaseDraft) {
             let changelogBody;
             const pkgConfig = ctx.config.packages.find((p2) => p2.path === pkgPath);
             if (pkgConfig) {
-              const changelogPath = join10(ctx.cwd, pkgConfig.path, "CHANGELOG.md");
+              const changelogPath = join9(ctx.cwd, pkgConfig.path, "CHANGELOG.md");
               if (existsSync6(changelogPath)) {
                 const section = parseChangelogSection(readFileSync9(changelogPath, "utf-8"), pkgVersion);
                 if (section)
@@ -36353,7 +36406,7 @@ function createReleaseTask(hasPublish, dryRun, mode, skipReleaseDraft) {
               const pkgConfig = ctx.config.packages.find((p2) => p2.path === pkgPath2);
               if (!pkgConfig)
                 continue;
-              const changelogPath = join10(ctx.cwd, pkgConfig.path, "CHANGELOG.md");
+              const changelogPath = join9(ctx.cwd, pkgConfig.path, "CHANGELOG.md");
               if (existsSync6(changelogPath)) {
                 const section = parseChangelogSection(readFileSync9(changelogPath, "utf-8"), pkgVersion);
                 if (section) {
@@ -36371,7 +36424,7 @@ ${section}`);
 `);
             }
           } else {
-            const changelogPath = join10(ctx.cwd, "CHANGELOG.md");
+            const changelogPath = join9(ctx.cwd, "CHANGELOG.md");
             if (existsSync6(changelogPath)) {
               const section = parseChangelogSection(readFileSync9(changelogPath, "utf-8"), version);
               if (section)
@@ -36479,10 +36532,166 @@ ${repositoryUrl}/compare/${lastRev}...${tag}`;
 }
 
 // src/tasks/phases/test-build.ts
+init_catalog2();
 init_error4();
 init_i18n();
+import path14 from "node:path";
 init_exec();
-init_package_manager();
+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) {
+    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 result;
+}
+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 = path14.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 = path14.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 = path14.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(execution.cmd, execution.args, {
+      onStdout: liveOutput?.onStdout,
+      onStderr: liveOutput?.onStderr,
+      throwOnError: true,
+      nodeOptions: { cwd: execution.cwd }
+    });
+  } finally {
+    liveOutput?.finish();
+  }
+}
 function createTestTask(hasPrepare, skipTests) {
   return {
     enabled: hasPrepare && !skipTests,
@@ -36490,28 +36699,25 @@ function createTestTask(hasPrepare, skipTests) {
     task: async (ctx, task) => {
       task.output = t("task.test.runningBeforeHooks");
       await ctx.runtime.pluginRunner.runHook("beforeTest", ctx);
-      const packageManager = await getPackageManager();
-      const command = `${packageManager} run ${ctx.options.testScript}`;
-      task.title = t("task.test.titleWithCommand", { command });
-      const liveOutput = shouldRenderLiveCommandOutput(ctx) ? createLiveCommandOutput(task, command) : undefined;
-      task.output = `Executing \`${command}\``;
-      try {
-        await exec3(packageManager, ["run", ctx.options.testScript], {
-          onStdout: liveOutput?.onStdout,
-          onStderr: liveOutput?.onStderr,
-          throwOnError: true
+      const executions = await resolveExecutions(ctx, "test");
+      for (const execution of executions) {
+        task.title = t("task.test.titleWithCommand", {
+          command: execution.label
         });
-      } catch (error4) {
-        liveOutput?.finish();
-        throw new AbstractError(t("error.test.failedWithHint", {
-          script: ctx.options.testScript,
-          command
-        }), { cause: error4 });
+        try {
+          await runExecution(execution, ctx, task);
+        } catch (error4) {
+          throw new AbstractError(t("error.test.failedWithHint", {
+            script: execution.label,
+            command: execution.label
+          }), { cause: error4 });
+        }
       }
-      liveOutput?.finish();
       task.output = t("task.test.runningAfterHooks");
       await ctx.runtime.pluginRunner.runHook("afterTest", ctx);
-      task.output = t("task.test.completed", { command });
+      task.output = t("task.test.completed", {
+        command: executions.map((e3) => e3.label).join(", ")
+      });
     }
   };
 }
@@ -36522,41 +36728,38 @@ function createBuildTask(hasPrepare, skipBuild) {
     task: async (ctx, task) => {
       task.output = t("task.build.runningBeforeHooks");
       await ctx.runtime.pluginRunner.runHook("beforeBuild", ctx);
-      const packageManager = await getPackageManager();
-      const command = `${packageManager} run ${ctx.options.buildScript}`;
-      task.title = t("task.build.titleWithCommand", { command });
-      const liveOutput = shouldRenderLiveCommandOutput(ctx) ? createLiveCommandOutput(task, command) : undefined;
-      task.output = `Executing \`${command}\``;
-      try {
-        await exec3(packageManager, ["run", ctx.options.buildScript], {
-          onStdout: liveOutput?.onStdout,
-          onStderr: liveOutput?.onStderr,
-          throwOnError: true
+      const executions = await resolveExecutions(ctx, "build");
+      for (const execution of executions) {
+        task.title = t("task.build.titleWithCommand", {
+          command: execution.label
         });
-      } catch (error4) {
-        liveOutput?.finish();
-        throw new AbstractError(t("error.build.failedWithHint", {
-          script: ctx.options.buildScript,
-          command
-        }), { cause: error4 });
+        try {
+          await runExecution(execution, ctx, task);
+        } catch (error4) {
+          throw new AbstractError(t("error.build.failedWithHint", {
+            script: execution.label,
+            command: execution.label
+          }), { cause: error4 });
+        }
       }
-      liveOutput?.finish();
       task.output = t("task.build.runningAfterHooks");
       await ctx.runtime.pluginRunner.runHook("afterBuild", ctx);
-      task.output = t("task.build.completed", { command });
+      task.output = t("task.build.completed", {
+        command: executions.map((e3) => e3.label).join(", ")
+      });
     }
   };
 }
 
 // src/tasks/phases/version.ts
 init_dist2();
-import path15 from "node:path";
+import path17 from "node:path";
 
 // src/changelog/file.ts
 import { existsSync as existsSync7, readFileSync as readFileSync10, writeFileSync as writeFileSync8 } from "node:fs";
-import path13 from "node:path";
+import path15 from "node:path";
 function writeChangelogToFile(cwd, newContent) {
-  const changelogPath = path13.join(cwd, "CHANGELOG.md");
+  const changelogPath = path15.join(cwd, "CHANGELOG.md");
   let existing = "";
   if (existsSync7(changelogPath)) {
     existing = readFileSync10(changelogPath, "utf-8");
@@ -36621,7 +36824,7 @@ function buildChangelogEntries(changesets, packagePath) {
 
 // src/changeset/reader.ts
 import { existsSync as existsSync8, readdirSync as readdirSync3, readFileSync as readFileSync11, rmSync as rmSync2 } from "node:fs";
-import path14 from "node:path";
+import path16 from "node:path";
 import process20 from "node:process";
 
 // src/changeset/parser.ts
@@ -36642,8 +36845,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$/, "");
@@ -36656,7 +36859,7 @@ function parseChangeset(content, fileName, resolveKey) {
 
 // src/changeset/reader.ts
 function readChangesets(cwd = process20.cwd(), resolveKey) {
-  const changesetsDir = path14.join(cwd, ".pubm", "changesets");
+  const changesetsDir = path16.join(cwd, ".pubm", "changesets");
   if (!existsSync8(changesetsDir)) {
     return [];
   }
@@ -36666,16 +36869,16 @@ function readChangesets(cwd = process20.cwd(), resolveKey) {
     if (!file.endsWith(".md") || file === "README.md") {
       continue;
     }
-    const filePath = path14.join(changesetsDir, file);
+    const filePath = path16.join(changesetsDir, file);
     const content = readFileSync11(filePath, "utf-8");
     changesets.push(parseChangeset(content, file, resolveKey));
   }
   return changesets;
 }
 function deleteChangesetFiles(cwd, changesets) {
-  const changesetsDir = path14.join(cwd, ".pubm", "changesets");
+  const changesetsDir = path16.join(cwd, ".pubm", "changesets");
   for (const changeset of changesets) {
-    const filePath = path14.join(changesetsDir, `${changeset.id}.md`);
+    const filePath = path16.join(changesetsDir, `${changeset.id}.md`);
     if (existsSync8(filePath)) {
       rmSync2(filePath);
     }
@@ -36732,7 +36935,7 @@ function createVersionTask(hasPrepare, dryRun) {
           const changesets = readChangesets(ctx.cwd, resolver);
           if (changesets.length > 0) {
             registerChangesetBackups(ctx, changesets);
-            const changelogPath = path15.join(ctx.cwd, "CHANGELOG.md");
+            const changelogPath = path17.join(ctx.cwd, "CHANGELOG.md");
             registerChangelogBackup(ctx, changelogPath);
             const pkgPath = ctx.config.packages[0]?.path ?? "";
             const entries = buildChangelogEntries(changesets, pkgPath);
@@ -36789,7 +36992,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 = path15.join(ctx.cwd, "CHANGELOG.md");
+            const changelogPath = path17.join(ctx.cwd, "CHANGELOG.md");
             registerChangelogBackup(ctx, changelogPath);
             const allEntries = [...plan.packages.keys()].flatMap((pkgPath) => buildChangelogEntries(changesets, pkgPath));
             if (allEntries.length > 0) {
@@ -36849,15 +37052,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 ? path15.resolve(ctx.cwd, pkgConfig.path) : ctx.cwd;
-              const changelogPath = path15.join(changelogDir, "CHANGELOG.md");
+              const changelogDir = pkgConfig ? path17.resolve(ctx.cwd, pkgConfig.path) : ctx.cwd;
+              const changelogPath = path17.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 ? path15.resolve(ctx.cwd, pkgConfig.path) : ctx.cwd;
+                const changelogDir = pkgConfig ? path17.resolve(ctx.cwd, pkgConfig.path) : ctx.cwd;
                 writeChangelogToFile(changelogDir, generateChangelog(pkgVersion, entries));
               }
             }
@@ -37109,11 +37312,11 @@ function maxBump(a3, b2) {
 }
 // src/changeset/migrate.ts
 import { copyFileSync, existsSync as existsSync9, mkdirSync as mkdirSync3, readdirSync as readdirSync4 } from "node:fs";
-import path16 from "node:path";
+import path18 from "node:path";
 import process22 from "node:process";
 var SKIPPED_FILES = new Set(["config.json", "README.md"]);
 function migrateFromChangesets(cwd = process22.cwd()) {
-  const changesetDir = path16.join(cwd, ".changeset");
+  const changesetDir = path18.join(cwd, ".changeset");
   if (!existsSync9(changesetDir)) {
     return {
       success: false,
@@ -37122,7 +37325,7 @@ function migrateFromChangesets(cwd = process22.cwd()) {
       configMigrated: false
     };
   }
-  const pubmDir = path16.join(cwd, ".pubm", "changesets");
+  const pubmDir = path18.join(cwd, ".pubm", "changesets");
   mkdirSync3(pubmDir, { recursive: true });
   const files = readdirSync4(changesetDir);
   const migratedFiles = [];
@@ -37136,13 +37339,13 @@ function migrateFromChangesets(cwd = process22.cwd()) {
       continue;
     }
     if (file === "pre.json") {
-      copyFileSync(path16.join(changesetDir, file), path16.resolve(cwd, ".pubm", "pre.json"));
+      copyFileSync(path18.join(changesetDir, file), path18.resolve(cwd, ".pubm", "pre.json"));
       migratedFiles.push(file);
       continue;
     }
     if (file.endsWith(".md")) {
-      const src = path16.join(changesetDir, file);
-      const dest = path16.join(pubmDir, file);
+      const src = path18.join(changesetDir, file);
+      const dest = path18.join(pubmDir, file);
       copyFileSync(src, dest);
       migratedFiles.push(file);
     }
@@ -37217,7 +37420,7 @@ function calculateVersionBumps(currentVersions, cwd = process24.cwd(), resolveKe
 // src/changeset/writer.ts
 var import_yaml3 = __toESM(require_dist(), 1);
 import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync9 } from "node:fs";
-import path17 from "node:path";
+import path19 from "node:path";
 import process25 from "node:process";
 var adjectives = [
   "brave",
@@ -37313,11 +37516,11 @@ ${summary}
   return content;
 }
 function writeChangeset(releases, summary, cwd = process25.cwd()) {
-  const changesetsDir = path17.join(cwd, ".pubm", "changesets");
+  const changesetsDir = path19.join(cwd, ".pubm", "changesets");
   mkdirSync4(changesetsDir, { recursive: true });
   const id = generateChangesetId();
   const fileName = `${id}.md`;
-  const filePath = path17.join(changesetsDir, fileName);
+  const filePath = path19.join(changesetsDir, fileName);
   const content = generateChangesetContent(releases, summary);
   writeFileSync9(filePath, content, "utf-8");
   return filePath;
@@ -37325,6 +37528,8 @@ function writeChangeset(releases, summary, cwd = process25.cwd()) {
 // src/config/defaults.ts
 init_catalog2();
 init_i18n();
+var import_micromatch4 = __toESM(require_micromatch(), 1);
+import path20 from "node:path";
 init_catalog();
 var defaultValidate = {
   cleanInstall: true,
@@ -37370,6 +37575,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;
@@ -37391,15 +37606,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 path20.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,
@@ -37412,6 +37641,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: {
@@ -37436,14 +37666,14 @@ import { execFile } from "node:child_process";
 import {
   mkdir,
   mkdtemp,
-  readFile as readFile8,
+  readFile as readFile7,
   rm,
   stat as stat6,
   writeFile as writeFile3
 } from "node:fs/promises";
 import { createRequire as createRequire2 } from "node:module";
 import { tmpdir as tmpdir3 } from "node:os";
-import path18 from "node:path";
+import path21 from "node:path";
 import { pathToFileURL } from "node:url";
 import vm from "node:vm";
 var CONFIG_FILES = [
@@ -37496,7 +37726,7 @@ var CONFIG_MODULE_SHIMS = {
 };
 async function findConfigFile(cwd) {
   for (const file of CONFIG_FILES) {
-    const filePath = path18.join(cwd, file);
+    const filePath = path21.join(cwd, file);
     try {
       if ((await stat6(filePath)).isFile()) {
         return filePath;
@@ -37517,15 +37747,15 @@ function isBareSpecifier(specifier) {
   return !specifier.startsWith(".") && !specifier.startsWith("/") && !specifier.startsWith("file:") && !specifier.startsWith("node:");
 }
 async function findClosestPackageManifest(filePath) {
-  let current = path18.dirname(filePath);
+  let current = path21.dirname(filePath);
   while (true) {
-    const manifestPath = path18.join(current, "package.json");
+    const manifestPath = path21.join(current, "package.json");
     try {
       if ((await stat6(manifestPath)).isFile()) {
         return manifestPath;
       }
     } catch {}
-    const parent = path18.dirname(current);
+    const parent = path21.dirname(current);
     if (parent === current) {
       return null;
     }
@@ -37541,7 +37771,7 @@ async function isOptionalDependencyImport(specifier, importerPath) {
     return false;
   }
   const packageName = getPackageName2(specifier);
-  const manifest = JSON.parse(await readFile8(manifestPath, "utf8"));
+  const manifest = JSON.parse(await readFile7(manifestPath, "utf8"));
   if (manifest.optionalDependencies?.[packageName]) {
     return true;
   }
@@ -37612,7 +37842,7 @@ async function collectOptionalDependenciesForInputs(inputPaths) {
   }
   const optionalDependencies = new Set;
   for (const manifestPath of manifestPaths) {
-    const manifest = JSON.parse(await readFile8(manifestPath, "utf8"));
+    const manifest = JSON.parse(await readFile7(manifestPath, "utf8"));
     for (const dependency of Object.keys(manifest.optionalDependencies ?? {})) {
       optionalDependencies.add(dependency);
     }
@@ -37627,13 +37857,13 @@ async function collectOptionalDependenciesForInputs(inputPaths) {
 async function findInstalledPackagePath(startDir, dependency) {
   let current = startDir;
   while (true) {
-    const packageDir = path18.join(current, "node_modules", dependency);
+    const packageDir = path21.join(current, "node_modules", dependency);
     try {
       if ((await stat6(packageDir)).isDirectory()) {
         return packageDir;
       }
     } catch {}
-    const parent = path18.dirname(current);
+    const parent = path21.dirname(current);
     if (parent === current) {
       return null;
     }
@@ -37641,19 +37871,19 @@ async function findInstalledPackagePath(startDir, dependency) {
   }
 }
 async function writeOptionalDependencyStubs(moduleDir, resolveFromDir, optionalDependencies) {
-  const nodeModulesDir = path18.join(moduleDir, "node_modules");
+  const nodeModulesDir = path21.join(moduleDir, "node_modules");
   for (const dependency of optionalDependencies) {
     if (await findInstalledPackagePath(resolveFromDir, dependency)) {
       continue;
     }
-    const packageDir = path18.join(nodeModulesDir, dependency);
+    const packageDir = path21.join(nodeModulesDir, dependency);
     await mkdir(packageDir, { recursive: true });
-    await writeFile3(path18.join(packageDir, "package.json"), JSON.stringify({
+    await writeFile3(path21.join(packageDir, "package.json"), JSON.stringify({
       name: dependency,
       private: true,
       main: "./index.js"
     }, null, 2), "utf8");
-    await writeFile3(path18.join(packageDir, "index.js"), createOptionalDependencyProxyPackage(dependency), "utf8");
+    await writeFile3(path21.join(packageDir, "index.js"), createOptionalDependencyProxyPackage(dependency), "utf8");
   }
 }
 function createOptionalDependencyPlugin(specifiers) {
@@ -37707,7 +37937,7 @@ function createConfigModuleShimPlugin() {
   };
 }
 async function runBunBuild(build, entrypoint, format3 = "esm", optionalDynamicImports = []) {
-  const entrypointSource = await readFile8(entrypoint, "utf8");
+  const entrypointSource = await readFile7(entrypoint, "utf8");
   const result = await build({
     entrypoints: [entrypoint],
     target: "bun",
@@ -37765,10 +37995,10 @@ async function buildConfigWithFormat(entrypoint, format3) {
 }
 async function buildConfigWithChildProcess(entrypoint, format3 = "esm") {
   const extension = format3 === "esm" ? "mjs" : "cjs";
-  const tempDir = await mkdtemp(path18.join(tmpdir3(), "pubm-config-"));
-  const buildScript = path18.join(tempDir, "build-config.mjs");
-  const outfile = path18.join(tempDir, `pubm.config.${extension}`);
-  const resultFile = path18.join(tempDir, "build-result.json");
+  const tempDir = await mkdtemp(path21.join(tmpdir3(), "pubm-config-"));
+  const buildScript = path21.join(tempDir, "build-config.mjs");
+  const outfile = path21.join(tempDir, `pubm.config.${extension}`);
+  const resultFile = path21.join(tempDir, "build-result.json");
   try {
     await writeFile3(buildScript, [
       'import { readFile, stat, writeFile } from "node:fs/promises";',
@@ -38019,8 +38249,8 @@ async function buildConfigWithChildProcess(entrypoint, format3 = "esm") {
         resolve2();
       });
     });
-    const result = JSON.parse(await readFile8(resultFile, "utf8"));
-    const contents = result.hasEntrypoint ? await readFile8(outfile, "utf8") : null;
+    const result = JSON.parse(await readFile7(resultFile, "utf8"));
+    const contents = result.hasEntrypoint ? await readFile7(outfile, "utf8") : null;
     return {
       success: result.success,
       logs: result.logs,
@@ -38044,11 +38274,11 @@ async function buildConfigWithChildProcess(entrypoint, format3 = "esm") {
 }
 function rewriteImportMeta(source, configPath) {
   const replacements = [
-    ["import.meta.dirname", JSON.stringify(path18.dirname(configPath))],
+    ["import.meta.dirname", JSON.stringify(path21.dirname(configPath))],
     ["import.meta.filename", JSON.stringify(configPath)],
     ["import.meta.path", JSON.stringify(configPath)],
     ["import.meta.url", JSON.stringify(pathToFileURL(configPath).href)],
-    ["import.meta.dir", JSON.stringify(path18.dirname(configPath))]
+    ["import.meta.dir", JSON.stringify(path21.dirname(configPath))]
   ];
   let rewritten = source;
   for (const [pattern, value] of replacements) {
@@ -38064,10 +38294,10 @@ async function importConfigModule(configPath) {
   return normalizeConfigNamespace(namespace);
 }
 async function importBundledConfig(source, configPath, optionalDependencies) {
-  const tempDir = await mkdtemp(path18.join(path18.dirname(configPath), ".pubm-config-module-"));
-  const tempFile = path18.join(tempDir, "pubm.config.mjs");
+  const tempDir = await mkdtemp(path21.join(path21.dirname(configPath), ".pubm-config-module-"));
+  const tempFile = path21.join(tempDir, "pubm.config.mjs");
   try {
-    await writeOptionalDependencyStubs(tempDir, path18.dirname(configPath), optionalDependencies);
+    await writeOptionalDependencyStubs(tempDir, path21.dirname(configPath), optionalDependencies);
     await writeFile3(tempFile, source, "utf8");
     return importConfigModule(tempFile);
   } finally {
@@ -38082,7 +38312,7 @@ async function executeBundledConfigInVm(source, configPath) {
     exports: module.exports,
     require: require2,
     __filename: configPath,
-    __dirname: path18.dirname(configPath),
+    __dirname: path21.dirname(configPath),
     console,
     process,
     Buffer,
@@ -38113,7 +38343,7 @@ function formatStageError(stage, error4) {
 async function loadConfig(cwd = process.cwd(), configPath) {
   let resolvedConfigPath;
   if (configPath) {
-    resolvedConfigPath = path18.resolve(cwd, configPath);
+    resolvedConfigPath = path21.resolve(cwd, configPath);
     try {
       if (!(await stat6(resolvedConfigPath)).isFile()) {
         throw new Error(`Config path is not a file: ${resolvedConfigPath}`);
@@ -38193,12 +38423,12 @@ function defineConfig(config) {
 init_context();
 
 // src/conventional-commit/scope-resolver.ts
-import path19 from "node:path";
+import path22 from "node:path";
 function resolveCommitPackages(commit, packagePaths) {
   const matched = new Set;
   if (commit.scope) {
     for (const pkgPath of packagePaths) {
-      const dirName = path19.basename(pkgPath);
+      const dirName = path22.basename(pkgPath);
       if (dirName === commit.scope) {
         matched.add(pkgPath);
       }
@@ -38453,7 +38683,7 @@ function inspectPackages(config, cwd) {
 init_manifest_reader();
 // src/migrate/adapters/changesets.ts
 import { existsSync as existsSync10, readdirSync as readdirSync5, readFileSync as readFileSync12 } from "node:fs";
-import path20 from "node:path";
+import path23 from "node:path";
 var SKIPPED_DIR_ENTRIES = new Set(["config.json", "README.md", ".gitkeep"]);
 var CHANGELOG_PRESET_MAP = {
   "@changesets/changelog-github": "github",
@@ -38471,11 +38701,11 @@ var changesetsAdapter = {
   name: "changesets",
   configFilePatterns: [".changeset/config.json"],
   async detect(cwd) {
-    const configFile = path20.join(cwd, ".changeset", "config.json");
+    const configFile = path23.join(cwd, ".changeset", "config.json");
     if (!existsSync10(configFile)) {
       return { found: false, configFiles: [], relatedFiles: [] };
     }
-    const changesetDir = path20.dirname(configFile);
+    const changesetDir = path23.dirname(configFile);
     const relatedFiles = [];
     try {
       const entries = readdirSync5(changesetDir, { encoding: "utf-8" });
@@ -38483,7 +38713,7 @@ var changesetsAdapter = {
         if (SKIPPED_DIR_ENTRIES.has(entry))
           continue;
         if (entry.endsWith(".md") || entry === "pre.json") {
-          relatedFiles.push(path20.join(changesetDir, entry));
+          relatedFiles.push(path23.join(changesetDir, entry));
         }
       }
     } catch {}
@@ -38494,7 +38724,7 @@ var changesetsAdapter = {
     };
   },
   async parse(files, cwd) {
-    const configFile = files.find((f2) => f2.endsWith(`${path20.sep}config.json`) || f2.endsWith("/config.json"));
+    const configFile = files.find((f2) => f2.endsWith(`${path23.sep}config.json`) || f2.endsWith("/config.json"));
     if (configFile === undefined) {
       return { source: "changesets", unmappable: [] };
     }
@@ -38529,7 +38759,7 @@ var changesetsAdapter = {
       if (hasUpdateInternalDeps)
         result.monorepo.updateInternalDeps = config.updateInternalDependencies;
     }
-    const preJsonPath = path20.join(cwd, ".changeset", "pre.json");
+    const preJsonPath = path23.join(cwd, ".changeset", "pre.json");
     if (existsSync10(preJsonPath)) {
       try {
         const preRaw = readFileSync12(preJsonPath, "utf-8");
@@ -38563,12 +38793,12 @@ var changesetsAdapter = {
     const configFile = detected.configFiles[0];
     if (configFile === undefined)
       return [];
-    return [path20.dirname(configFile)];
+    return [path23.dirname(configFile)];
   }
 };
 // src/migrate/adapters/np.ts
 import { existsSync as existsSync11, readFileSync as readFileSync13 } from "node:fs";
-import path21 from "node:path";
+import path24 from "node:path";
 import { pathToFileURL as pathToFileURL2 } from "node:url";
 var STANDALONE_CONFIG_FILES = [
   ".np-config.json",
@@ -38673,12 +38903,12 @@ var npAdapter = {
   async detect(cwd) {
     const configFiles = [];
     for (const filename of STANDALONE_CONFIG_FILES) {
-      const filePath = path21.join(cwd, filename);
+      const filePath = path24.join(cwd, filename);
       if (existsSync11(filePath)) {
         configFiles.push(filePath);
       }
     }
-    const pkgJsonPath = path21.join(cwd, PACKAGE_JSON);
+    const pkgJsonPath = path24.join(cwd, PACKAGE_JSON);
     if (existsSync11(pkgJsonPath)) {
       try {
         const raw = readFileSync13(pkgJsonPath, "utf-8");
@@ -38695,8 +38925,8 @@ var npAdapter = {
     };
   },
   async parse(files, _cwd) {
-    const standaloneFile = files.find((f2) => STANDALONE_CONFIG_FILES.some((name) => f2.endsWith(path21.sep + name) || f2.endsWith(`/${name}`)));
-    const pkgJsonFile = files.find((f2) => f2.endsWith(path21.sep + PACKAGE_JSON) || f2.endsWith(`/${PACKAGE_JSON}`));
+    const standaloneFile = files.find((f2) => STANDALONE_CONFIG_FILES.some((name) => f2.endsWith(path24.sep + name) || f2.endsWith(`/${name}`)));
+    const pkgJsonFile = files.find((f2) => f2.endsWith(path24.sep + PACKAGE_JSON) || f2.endsWith(`/${PACKAGE_JSON}`));
     const configFile = standaloneFile ?? pkgJsonFile;
     if (configFile === undefined) {
       return {
@@ -38715,13 +38945,13 @@ var npAdapter = {
     };
   },
   getCleanupTargets(detected) {
-    return detected.configFiles.filter((f2) => !f2.endsWith(path21.sep + PACKAGE_JSON) && !f2.endsWith(`/${PACKAGE_JSON}`));
+    return detected.configFiles.filter((f2) => !f2.endsWith(path24.sep + PACKAGE_JSON) && !f2.endsWith(`/${PACKAGE_JSON}`));
   }
 };
 // src/migrate/adapters/release-it.ts
 var import_yaml4 = __toESM(require_dist(), 1);
 import { existsSync as existsSync12, readFileSync as readFileSync14 } from "node:fs";
-import path22 from "node:path";
+import path25 from "node:path";
 import { pathToFileURL as pathToFileURL3 } from "node:url";
 var STANDALONE_CONFIG_FILES2 = [
   ".release-it.json",
@@ -38746,7 +38976,7 @@ async function loadConfigFile(filePath) {
   if (filePath.endsWith(".yaml") || filePath.endsWith(".yml")) {
     return import_yaml4.default.parse(raw);
   }
-  if (filePath.endsWith(path22.sep + PACKAGE_JSON2) || filePath.endsWith(`/${PACKAGE_JSON2}`)) {
+  if (filePath.endsWith(path25.sep + PACKAGE_JSON2) || filePath.endsWith(`/${PACKAGE_JSON2}`)) {
     const parsed = JSON.parse(raw);
     return parsed["release-it"] ?? {};
   }
@@ -38861,12 +39091,12 @@ var releaseItAdapter = {
   async detect(cwd) {
     const configFiles = [];
     for (const filename of STANDALONE_CONFIG_FILES2) {
-      const filePath = path22.join(cwd, filename);
+      const filePath = path25.join(cwd, filename);
       if (existsSync12(filePath)) {
         configFiles.push(filePath);
       }
     }
-    const pkgJsonPath = path22.join(cwd, PACKAGE_JSON2);
+    const pkgJsonPath = path25.join(cwd, PACKAGE_JSON2);
     if (existsSync12(pkgJsonPath)) {
       try {
         const raw = readFileSync14(pkgJsonPath, "utf-8");
@@ -38883,8 +39113,8 @@ var releaseItAdapter = {
     };
   },
   async parse(files, _cwd) {
-    const standaloneFile = files.find((f2) => STANDALONE_CONFIG_FILES2.some((name) => f2.endsWith(path22.sep + name) || f2.endsWith(`/${name}`)));
-    const pkgJsonFile = files.find((f2) => f2.endsWith(path22.sep + PACKAGE_JSON2) || f2.endsWith(`/${PACKAGE_JSON2}`));
+    const standaloneFile = files.find((f2) => STANDALONE_CONFIG_FILES2.some((name) => f2.endsWith(path25.sep + name) || f2.endsWith(`/${name}`)));
+    const pkgJsonFile = files.find((f2) => f2.endsWith(path25.sep + PACKAGE_JSON2) || f2.endsWith(`/${PACKAGE_JSON2}`));
     const configFile = standaloneFile ?? pkgJsonFile;
     if (configFile === undefined) {
       return {
@@ -38914,13 +39144,13 @@ var releaseItAdapter = {
     };
   },
   getCleanupTargets(detected) {
-    return detected.configFiles.filter((f2) => !f2.endsWith(path22.sep + PACKAGE_JSON2) && !f2.endsWith(`/${PACKAGE_JSON2}`));
+    return detected.configFiles.filter((f2) => !f2.endsWith(path25.sep + PACKAGE_JSON2) && !f2.endsWith(`/${PACKAGE_JSON2}`));
   }
 };
 // src/migrate/adapters/semantic-release.ts
 var import_yaml5 = __toESM(require_dist(), 1);
 import { existsSync as existsSync13, readFileSync as readFileSync15 } from "node:fs";
-import path23 from "node:path";
+import path26 from "node:path";
 import { pathToFileURL as pathToFileURL4 } from "node:url";
 var STANDALONE_CONFIG_FILES3 = [
   ".releaserc",
@@ -39010,11 +39240,11 @@ async function loadConfigFile2(filePath) {
   if (filePath.endsWith(".yaml") || filePath.endsWith(".yml")) {
     return import_yaml5.default.parse(raw);
   }
-  if (filePath.endsWith(path23.sep + PACKAGE_JSON3) || filePath.endsWith(`/${PACKAGE_JSON3}`)) {
+  if (filePath.endsWith(path26.sep + PACKAGE_JSON3) || filePath.endsWith(`/${PACKAGE_JSON3}`)) {
     const parsed = JSON.parse(raw);
     return parsed.release ?? {};
   }
-  const basename4 = path23.basename(filePath);
+  const basename4 = path26.basename(filePath);
   if (basename4 === ".releaserc") {
     try {
       return JSON.parse(raw);
@@ -39124,12 +39354,12 @@ var semanticReleaseAdapter = {
   async detect(cwd) {
     const configFiles = [];
     for (const filename of STANDALONE_CONFIG_FILES3) {
-      const filePath = path23.join(cwd, filename);
+      const filePath = path26.join(cwd, filename);
       if (existsSync13(filePath)) {
         configFiles.push(filePath);
       }
     }
-    const pkgJsonPath = path23.join(cwd, PACKAGE_JSON3);
+    const pkgJsonPath = path26.join(cwd, PACKAGE_JSON3);
     if (existsSync13(pkgJsonPath)) {
       try {
         const raw = readFileSync15(pkgJsonPath, "utf-8");
@@ -39146,8 +39376,8 @@ var semanticReleaseAdapter = {
     };
   },
   async parse(files, _cwd) {
-    const standaloneFile = files.find((f2) => STANDALONE_CONFIG_FILES3.some((name) => f2.endsWith(path23.sep + name) || f2.endsWith(`/${name}`)));
-    const pkgJsonFile = files.find((f2) => f2.endsWith(path23.sep + PACKAGE_JSON3) || f2.endsWith(`/${PACKAGE_JSON3}`));
+    const standaloneFile = files.find((f2) => STANDALONE_CONFIG_FILES3.some((name) => f2.endsWith(path26.sep + name) || f2.endsWith(`/${name}`)));
+    const pkgJsonFile = files.find((f2) => f2.endsWith(path26.sep + PACKAGE_JSON3) || f2.endsWith(`/${PACKAGE_JSON3}`));
     const configFile = standaloneFile ?? pkgJsonFile;
     if (configFile === undefined) {
       return {
@@ -39165,12 +39395,12 @@ var semanticReleaseAdapter = {
     };
   },
   getCleanupTargets(detected) {
-    return detected.configFiles.filter((f2) => !f2.endsWith(path23.sep + PACKAGE_JSON3) && !f2.endsWith(`/${PACKAGE_JSON3}`));
+    return detected.configFiles.filter((f2) => !f2.endsWith(path26.sep + PACKAGE_JSON3) && !f2.endsWith(`/${PACKAGE_JSON3}`));
   }
 };
 // src/migrate/ci-advisor.ts
 import { existsSync as existsSync14, readdirSync as readdirSync6, readFileSync as readFileSync16 } from "node:fs";
-import { join as join11 } from "node:path";
+import { join as join10 } from "node:path";
 var CI_PATTERNS = {
   "semantic-release": [
     /npx\s+semantic-release/,
@@ -39190,7 +39420,7 @@ var CI_PATTERNS = {
   np: [/npx\s+np\b/, /yarn\s+np\b/]
 };
 function scanCiWorkflows(cwd, source) {
-  const workflowsDir = join11(cwd, ".github", "workflows");
+  const workflowsDir = join10(cwd, ".github", "workflows");
   if (!existsSync14(workflowsDir))
     return [];
   const patterns = CI_PATTERNS[source];
@@ -39199,7 +39429,7 @@ function scanCiWorkflows(cwd, source) {
   for (const filename of files) {
     if (!filename.endsWith(".yml") && !filename.endsWith(".yaml"))
       continue;
-    const filePath = join11(workflowsDir, filename);
+    const filePath = join10(workflowsDir, filename);
     const content = readFileSync16(filePath, "utf-8");
     for (const line of content.split(`
 `)) {
@@ -39442,7 +39672,7 @@ async function detectMigrationSources(cwd, adapters, from) {
 }
 // src/migrate/pipeline.ts
 import { existsSync as existsSync15, writeFileSync as writeFileSync10 } from "node:fs";
-import { join as join12 } from "node:path";
+import { join as join11 } from "node:path";
 async function executeMigration(options) {
   const { adapter, detected, cwd, dryRun, clean } = options;
   const parsed = await adapter.parse(detected.configFiles, cwd);
@@ -39451,7 +39681,7 @@ async function executeMigration(options) {
   const configString = generateConfigString(convertResult.config);
   const ciAdvice = scanCiWorkflows(cwd, adapter.name);
   if (!dryRun) {
-    const outFile = join12(cwd, "pubm.config.ts");
+    const outFile = join11(cwd, "pubm.config.ts");
     if (existsSync15(outFile)) {
       throw new Error("pubm.config.ts already exists. Remove or rename it before migrating.");
     }
@@ -39516,12 +39746,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);
       }
@@ -39586,8 +39816,8 @@ init_catalog();
 
 // src/tasks/prompts/independent-mode.ts
 init_dist2();
-init_i18n();
 var import_semver9 = __toESM(require_semver2(), 1);
+init_i18n();
 
 // src/utils/filter-config.ts
 function filterConfigPackages(ctx, publishPaths) {
@@ -39718,7 +39948,7 @@ class ChangesetSource {
   }
 }
 // src/version-source/conventional-commit-source.ts
-import path24 from "node:path";
+import path27 from "node:path";
 class ConventionalCommitSource {
   name = "conventional-commit";
   typeOverrides;
@@ -39729,7 +39959,7 @@ class ConventionalCommitSource {
     const packagePaths = [...context.packages.keys()];
     const recommendations = [];
     for (const packagePath of packagePaths) {
-      const packageName = path24.basename(packagePath);
+      const packageName = path27.basename(packagePath);
       const ref = findLastReleaseRef(context.cwd, packageName);
       const rawCommits = getCommitsSinceRef(context.cwd, ref);
       const parsed = [];
@@ -39960,7 +40190,7 @@ async function handleMultiPackage(ctx, task, packageInfos) {
   const graph = buildGraphFromPackages(packageInfos);
   const currentVersions = new Map(packageInfos.map((p2) => [p2.path, p2.version]));
   const recommendations = await analyzeAllSources(ctx);
-  if (!ctx.runtime.promptEnabled && recommendations.length > 0) {
+  if (m && recommendations.length > 0) {
     const packages = new Map;
     for (const rec of recommendations) {
       const current = currentVersions.get(rec.packagePath);
@@ -40132,8 +40362,8 @@ async function handleIndependentMode(ctx, task, packageInfos, currentVersions, g
 
 // src/tasks/prompts/single-package.ts
 init_dist2();
-init_i18n();
 var import_semver10 = __toESM(require_semver2(), 1);
+init_i18n();
 async function handleSinglePackage(ctx, task) {
   const pkg = ctx.config.packages[0];
   const currentVersion = pkg?.version ?? "0.0.0";
@@ -40142,7 +40372,7 @@ async function handleSinglePackage(ctx, task) {
   if (rec) {
     const newVer = import_semver10.default.inc(currentVersion, rec.bumpType);
     if (newVer) {
-      if (!ctx.runtime.promptEnabled) {
+      if (m) {
         ctx.runtime.versionPlan = {
           mode: "single",
           version: newVer,
@@ -40479,7 +40709,7 @@ import { spawn } from "child_process";
 import { execFile as execFile2 } from "child_process";
 import { createWriteStream } from "fs";
 import fs2 from "fs/promises";
-import path25 from "path";
+import path28 from "path";
 import { Readable } from "stream";
 import { pipeline } from "stream/promises";
 import { promisify } from "util";
@@ -40488,16 +40718,16 @@ import crypto2 from "crypto";
 import { createReadStream } from "fs";
 import crypto from "crypto";
 import fs3 from "fs/promises";
-import path26 from "path";
+import path29 from "path";
 import { realpath } from "fs/promises";
 import { execFile as execFile22 } from "child_process";
 import { promisify as promisify2 } from "util";
 import { execFile as execFile3 } from "child_process";
 import { lstat, readlink } from "fs/promises";
 import { promisify as promisify3 } from "util";
-import { readFile as readFile9 } from "fs/promises";
+import { readFile as readFile8 } from "fs/promises";
 import { homedir as homedir2 } from "os";
-import { join as join13 } from "path";
+import { join as join12 } from "path";
 import os2 from "os";
 import path32 from "path";
 import { readFileSync as readFileSync17 } from "fs";
@@ -40909,7 +41139,7 @@ async function downloadArtifact(url, tmpDir, options) {
   }
   const totalBytes = Number(response.headers.get("content-length")) || undefined;
   const filename = extractFilename(url);
-  const destPath = path25.join(tmpDir, filename);
+  const destPath = path28.join(tmpDir, filename);
   let bytesDownloaded = 0;
   const nodeStream = Readable.fromWeb(response.body);
   const writeStream = createWriteStream(destPath);
@@ -40925,7 +41155,7 @@ async function downloadArtifact(url, tmpDir, options) {
   return destPath;
 }
 async function extractBinary(archivePath, tmpDir) {
-  const extractDir = path25.join(tmpDir, "extracted");
+  const extractDir = path28.join(tmpDir, "extracted");
   await fs2.mkdir(extractDir, { recursive: true });
   if (archivePath.endsWith(".tar.gz") || archivePath.endsWith(".tgz")) {
     try {
@@ -40952,7 +41182,7 @@ async function extractBinary(archivePath, tmpDir) {
       });
     }
   } else {
-    const destPath = path25.join(extractDir, path25.basename(archivePath));
+    const destPath = path28.join(extractDir, path28.basename(archivePath));
     await fs2.copyFile(archivePath, destPath);
     return destPath;
   }
@@ -40969,10 +41199,10 @@ async function findBinaryInDir(dir) {
     if (!e3.isFile())
       continue;
     const parentDir = e3.parentPath ?? ("path" in e3 ? e3.path : dir);
-    const filePath = path25.join(parentDir, e3.name);
+    const filePath = path28.join(parentDir, e3.name);
     try {
       const resolvedFile = await fs2.realpath(filePath);
-      if (!resolvedFile.startsWith(resolvedDir + path25.sep) && resolvedFile !== resolvedDir) {
+      if (!resolvedFile.startsWith(resolvedDir + path28.sep) && resolvedFile !== resolvedDir) {
         continue;
       }
     } catch {
@@ -41006,8 +41236,8 @@ async function findBinaryInDir(dir) {
     ".css"
   ]);
   const binaryCandidates = files.filter((file) => {
-    const ext = path25.extname(file).toLowerCase();
-    const basename4 = path25.basename(file).toLowerCase();
+    const ext = path28.extname(file).toLowerCase();
+    const basename4 = path28.basename(file).toLowerCase();
     return !NON_BINARY_EXTENSIONS.has(ext) && basename4 !== "license" && basename4 !== "readme";
   });
   return binaryCandidates.length > 0 ? binaryCandidates[0] : files[0];
@@ -41018,8 +41248,8 @@ function extractFilename(url) {
   return segments[segments.length - 1] || "artifact";
 }
 async function createTempDir(targetPath) {
-  const targetDir = path25.dirname(targetPath);
-  const tmpDir = path25.join(targetDir, `.update-kit-tmp-${process.pid}-${Date.now()}`);
+  const targetDir = path28.dirname(targetPath);
+  const tmpDir = path28.join(targetDir, `.update-kit-tmp-${process.pid}-${Date.now()}`);
   await fs2.mkdir(tmpDir, { recursive: true });
   return tmpDir;
 }
@@ -41032,7 +41262,7 @@ async function setExecutablePermission(filePath) {
   await fs2.chmod(filePath, 493);
 }
 function getCachePath(cacheDir, appName) {
-  return path26.join(cacheDir, appName, "update-check.json");
+  return path29.join(cacheDir, appName, "update-check.json");
 }
 async function readCache(cacheDir, appName) {
   const filePath = getCachePath(cacheDir, appName);
@@ -41052,7 +41282,7 @@ async function readCache(cacheDir, appName) {
 }
 async function writeCache(cacheDir, appName, entry) {
   const filePath = getCachePath(cacheDir, appName);
-  const dir = path26.dirname(filePath);
+  const dir = path29.dirname(filePath);
   await fs3.mkdir(dir, { recursive: true });
   const tmpPath = `${filePath}.${process.pid}-${Date.now()}.tmp`;
   try {
@@ -41768,10 +41998,10 @@ async function detectFromNpm(execPath) {
   };
 }
 async function detectFromReceipt(config, receiptDir) {
-  const dir = receiptDir ?? join13(homedir2(), ".config", config.appName);
-  const receiptPath = join13(dir, "install-receipt.json");
+  const dir = receiptDir ?? join12(homedir2(), ".config", config.appName);
+  const receiptPath = join12(dir, "install-receipt.json");
   try {
-    const content = await readFile9(receiptPath, "utf-8");
+    const content = await readFile8(receiptPath, "utf-8");
     const receipt = JSON.parse(content);
     if (receipt.appName !== config.appName) {
       return null;
@@ -42491,10 +42721,10 @@ init_ui();
 
 // src/validate/entry-points.ts
 import { existsSync as existsSync16 } from "node:fs";
-import path27 from "node:path";
+import path30 from "node:path";
 var SIMPLE_FIELDS = ["main", "module", "types", "typings"];
 function checkPath(filePath, cwd) {
-  return existsSync16(path27.resolve(cwd, filePath));
+  return existsSync16(path30.resolve(cwd, filePath));
 }
 function validateExports(exports, cwd, prefix = "exports") {
   const errors = [];
@@ -42544,7 +42774,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.*"],
@@ -42582,7 +42812,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);