@pubm/core 0.5.1 → 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.1",
+    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.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"),
@@ -22075,11 +22075,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"];
@@ -23608,13 +23613,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 = 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"];
@@ -23755,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",
@@ -23769,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
@@ -35519,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();
@@ -35608,20 +35626,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 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", {
@@ -35799,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
@@ -35974,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();
@@ -36159,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)
@@ -36173,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)
@@ -36181,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)
@@ -36284,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)
@@ -36342,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) {
@@ -36360,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)
@@ -36471,24 +36535,158 @@ ${repositoryUrl}/compare/${lastRev}...${tag}`;
 init_catalog2();
 init_error4();
 init_i18n();
+import path14 from "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);
+    }
   }
-  return [...seen];
+  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 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 = 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(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();
@@ -36501,29 +36699,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(", ")
       });
     }
   };
@@ -36535,29 +36728,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(", ")
       });
     }
   };
@@ -36565,13 +36753,13 @@ function createBuildTask(hasPrepare, skipBuild) {
 
 // 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");
@@ -36636,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
@@ -36657,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$/, "");
@@ -36671,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 [];
   }
@@ -36681,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);
     }
@@ -36747,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);
@@ -36804,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) {
@@ -36864,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));
               }
             }
@@ -37124,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,
@@ -37137,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 = [];
@@ -37151,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);
     }
@@ -37232,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",
@@ -37328,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;
@@ -37340,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,
@@ -37385,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;
@@ -37406,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,
@@ -37427,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: {
@@ -37451,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 = [
@@ -37511,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;
@@ -37532,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;
     }
@@ -37556,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;
   }
@@ -37627,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);
     }
@@ -37642,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;
     }
@@ -37656,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) {
@@ -37722,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",
@@ -37780,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";',
@@ -38034,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,
@@ -38059,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) {
@@ -38079,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 {
@@ -38097,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,
@@ -38128,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}`);
@@ -38208,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);
       }
@@ -38468,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",
@@ -38486,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" });
@@ -38498,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 {}
@@ -38509,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: [] };
     }
@@ -38544,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");
@@ -38578,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",
@@ -38688,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");
@@ -38710,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 {
@@ -38730,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",
@@ -38761,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"] ?? {};
   }
@@ -38876,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");
@@ -38898,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 {
@@ -38929,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",
@@ -39025,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);
@@ -39139,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");
@@ -39161,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 {
@@ -39180,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/,
@@ -39205,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];
@@ -39214,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(`
 `)) {
@@ -39457,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);
@@ -39466,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.");
     }
@@ -39531,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);
       }
@@ -39733,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;
@@ -39744,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 = [];
@@ -40494,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";
@@ -40503,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";
@@ -40924,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);
@@ -40940,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 {
@@ -40967,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;
   }
@@ -40984,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 {
@@ -41021,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];
@@ -41033,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;
 }
@@ -41047,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);
@@ -41067,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 {
@@ -41783,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;
@@ -42506,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 = [];
@@ -42559,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.*"],
@@ -42597,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);