fix: handle multi-ecosystem collisions in path-to-key maps and package lookups

Several places used one-to-one Map<path, key> or find() that silently
dropped entries when multiple ecosystems shared the same directory.
Changed to one-to-many maps and filter() to handle all ecosystems.
Also added name ambiguity detection in createKeyResolver and fixed
fallback displays leaking internal path::ecosystem format.

Author: syi0808

packages/core/src/changeset/resolve.ts

@@ -4,19 +4,32 @@ import { packageKey } from "../utils/package-key.js";
 export function createKeyResolver(
   packages: { name: string; path: string; ecosystem: EcosystemKey }[],
 ): (key: string) => string {
-  const nameToKey = new Map(packages.map((p) => [p.name, packageKey(p)]));
   const validKeys = new Set(packages.map((p) => packageKey(p)));
   const pathEcosystems = new Map<string, EcosystemKey[]>();
+  const nameEcosystems = new Map<string, EcosystemKey[]>();
   for (const p of packages) {
-    const existing = pathEcosystems.get(p.path) ?? [];
-    existing.push(p.ecosystem);
-    pathEcosystems.set(p.path, existing);
+    const existingPath = pathEcosystems.get(p.path) ?? [];
+    existingPath.push(p.ecosystem);
+    pathEcosystems.set(p.path, existingPath);
+
+    const existingName = nameEcosystems.get(p.name) ?? [];
+    existingName.push(p.ecosystem);
+    nameEcosystems.set(p.name, existingName);
   }
 
   return (key: string): string => {
     if (validKeys.has(key)) return key;
-    const fromName = nameToKey.get(key);
-    if (fromName) return fromName;
+    const nameEcos = nameEcosystems.get(key);
+    if (nameEcos) {
+      if (nameEcos.length === 1) {
+        const pkg = packages.find((p) => p.name === key);
+        if (pkg) return packageKey(pkg);
+      }
+      throw new Error(
+        `Ambiguous changeset key "${key}": name is shared across ecosystems (${nameEcos.join(", ")}). ` +
+          `Use the path::ecosystem format to specify.`,
+      );
+    }
     const ecosystems = pathEcosystems.get(key);
     if (ecosystems) {
       if (ecosystems.length === 1) {

packages/core/src/tasks/prompts/independent-mode.ts

@@ -63,7 +63,12 @@ export async function handleMultiPackage(
 ): Promise<void> {
   const graph = buildGraphFromPackages(packageInfos);
   const currentVersions = new Map(packageInfos.map((p) => [p.path, p.version]));
-  const pathToKey = new Map(packageInfos.map((p) => [p.path, packageKey(p)]));
+  const pathToKeys = new Map<string, string[]>();
+  for (const p of packageInfos) {
+    const existing = pathToKeys.get(p.path) ?? [];
+    existing.push(packageKey(p));
+    pathToKeys.set(p.path, existing);
+  }
   const recommendations = await analyzeAllSources(ctx);
 
   // CI mode: auto-accept
@@ -74,17 +79,19 @@ export async function handleMultiPackage(
       if (!current) continue;
       const newVer = semver.inc(current, rec.bumpType);
       if (newVer) {
-        const key = pathToKey.get(rec.packagePath) ?? rec.packagePath;
-        packages.set(key, newVer);
+        const keys = pathToKeys.get(rec.packagePath) ?? [rec.packagePath];
+        for (const key of keys) {
+          packages.set(key, newVer);
+        }
       }
     }
     ctx.runtime.versionPlan = buildVersionPlan(
       ctx.config.versioning ?? "independent",
       packages,
     );
     ctx.runtime.changesetConsumed = recommendations.some((r) => {
-      const key = pathToKey.get(r.packagePath) ?? r.packagePath;
-      return r.source === "changeset" && packages.has(key);
+      const keys = pathToKeys.get(r.packagePath) ?? [r.packagePath];
+      return r.source === "changeset" && keys.some((k) => packages.has(k));
     });
     return;
   }
@@ -127,8 +134,10 @@ export async function handleMultiPackage(
       if (!current) continue;
       const newVer = semver.inc(current, rec.bumpType);
       if (newVer) {
-        const key = pathToKey.get(rec.packagePath) ?? rec.packagePath;
-        selectedVersions.set(key, newVer);
+        const keys = pathToKeys.get(rec.packagePath) ?? [rec.packagePath];
+        for (const key of keys) {
+          selectedVersions.set(key, newVer);
+        }
       }
     }
   } else {
@@ -178,8 +187,8 @@ export async function handleMultiPackage(
     ctx.runtime.changesetConsumed = recommendations.some((r) => {
       if (r.source !== "changeset" || !plan || !("packages" in plan))
         return false;
-      const key = pathToKey.get(r.packagePath) ?? r.packagePath;
-      return plan.packages.has(key);
+      const keys = pathToKeys.get(r.packagePath) ?? [r.packagePath];
+      return keys.some((k) => plan.packages.has(k));
     });
     return;
   }
@@ -191,8 +200,8 @@ export async function handleMultiPackage(
     selectedVersions,
   );
   ctx.runtime.changesetConsumed = recommendations.some((r) => {
-    const key = pathToKey.get(r.packagePath) ?? r.packagePath;
-    return r.source === "changeset" && selectedVersions.has(key);
+    const keys = pathToKeys.get(r.packagePath) ?? [r.packagePath];
+    return r.source === "changeset" && keys.some((k) => selectedVersions.has(k));
   });
 }
 
@@ -330,8 +339,8 @@ export async function handleIndependentMode(
           currentVersions.get(pkgPath) ??
           (packageVersionByPath.get(pkgPath) as string);
         const patchVersion = new SemVer(currentVersion).inc("patch").toString();
-        const pkg = packageInfos.find((p) => p.path === pkgPath);
-        if (pkg) {
+        const pkgs = packageInfos.filter((p) => p.path === pkgPath);
+        for (const pkg of pkgs) {
           versions.set(packageKey(pkg), patchVersion);
         }
       }

packages/core/src/tasks/runner-utils/rollback-handlers.ts

@@ -18,7 +18,10 @@ export function isReleaseExcluded(
 }
 
 export function getPackageName(ctx: PubmContext, key: string): string {
-  return ctx.config.packages.find((p) => packageKey(p) === key)?.name ?? key;
+  return (
+    ctx.config.packages.find((p) => packageKey(p) === key)?.name ??
+    pathFromKey(key)
+  );
 }
 
 export function requireVersionPlan(ctx: PubmContext) {

packages/core/src/tasks/runner-utils/version-pr.ts

@@ -86,7 +86,7 @@ export function buildPrBodyFromContext(
   if (plan.mode === "independent") {
     for (const [key, pkgVersion] of plan.packages) {
       const pkgConfig = ctx.config.packages.find((p) => packageKey(p) === key);
-      const name = pkgConfig?.name ?? key;
+      const name = pkgConfig?.name ?? pathFromKey(key);
       packages.push({ name, version: pkgVersion, bump: "" });
 
       const changelogDir = pkgConfig

packages/core/src/tasks/snapshot-runner.ts

@@ -220,7 +220,7 @@ export async function runSnapshotPipeline(
             if (plan.mode === "independent") {
               for (const [key, pkgVersion] of plan.packages) {
                 const pkgName =
-                  ctx.config.packages.find((p) => p.path === pathFromKey(key))
+                  ctx.config.packages.find((p) => packageKey(p) === key)
                     ?.name ?? pathFromKey(key);
                 const tagName = `${pkgName}@${pkgVersion}`;
                 task.output = t("task.snapshot.creatingTag", { tag: tagName });

packages/pubm/src/cli.ts

@@ -320,10 +320,13 @@ export function createProgram(): Command {
             const currentVersions = new Map(
               resolvedConfig.packages.map((p) => [p.path, p.version]),
             );
-            // pathToKey maps filesystem path → packageKey for building the version plan
-            const pathToKey = new Map(
-              resolvedConfig.packages.map((p) => [p.path, packageKey(p)]),
-            );
+            // pathToKeys maps filesystem path → packageKey[] for building the version plan
+            const pathToKeys = new Map<string, string[]>();
+            for (const p of resolvedConfig.packages) {
+              const existing = pathToKeys.get(p.path) ?? [];
+              existing.push(packageKey(p));
+              pathToKeys.set(p.path, existing);
+            }
 
             const sources: VersionSource[] = [];
             const versionSources = resolvedConfig.versionSources ?? "all";
@@ -355,8 +358,14 @@ export function createProgram(): Command {
                 if (!currentVersion) continue;
                 const newVersion = semver.inc(currentVersion, rec.bumpType);
                 // Use packageKey as the map key for the version plan
-                const key = pathToKey.get(rec.packagePath) ?? rec.packagePath;
-                if (newVersion) packages.set(key, newVersion);
+                const keys = pathToKeys.get(rec.packagePath) ?? [
+                  rec.packagePath,
+                ];
+                if (newVersion) {
+                  for (const key of keys) {
+                    packages.set(key, newVersion);
+                  }
+                }
               }
 
               if (packages.size === 1) {

packages/pubm/src/commands/version-cmd.ts

@@ -89,13 +89,16 @@ export async function runVersionCommand(
     if (!currentVersion) continue;
     const newVersion = inc(currentVersion, rec.bumpType);
     if (!newVersion) continue;
-    const pkg = config.packages.find((p) => p.path === rec.packagePath);
-    if (!pkg) continue;
-    bumps.set(packageKey(pkg), {
-      currentVersion,
-      newVersion,
-      bumpType: rec.bumpType,
-    });
+    const matchingPkgs = config.packages.filter(
+      (p) => p.path === rec.packagePath,
+    );
+    for (const pkg of matchingPkgs) {
+      bumps.set(packageKey(pkg), {
+        currentVersion,
+        newVersion,
+        bumpType: rec.bumpType,
+      });
+    }
   }
 
   if (bumps.size === 0) {