pm-dedup-core 2.1.0 → 2.2.2

package/src/identifyLockstepClusterFixes.ts

@@ -103,9 +103,6 @@ export interface ClusterFix {
   anchor: string | null;
   // open ranges that could have reused the anchored version and did not
   reuseFixes: ClusterReuseFix[];
-  // members the package manager has to re-resolve, at a version only it can
-  // pick: nothing pins them, so the result has to be verified after installing
-  floatingMembers: string[];
   // workspace ranges to edit before installing, exact pins included: a pin is a
   // decision, so it is a last resort (see `betterCandidate`), not immutable. A
   // declaration made through an alias key is the exception — it binds
@@ -126,12 +123,12 @@ const accepts = (version: string, range: string): boolean =>
 
 interface Candidate {
   version: string;
+  // every member that lands on this version, duplicated or not
+  converging: Set<string>;
   // duplicated members that collapse onto this version
   convergentMembers: string[];
   // duplicated members that do not, with the third-party ranges to blame
   excluded: Map<string, ClusterExternalConstraint[]>;
-  // members the resolver has to move, version unknown
-  floatingMembers: string[];
   // workspace pins that would have to be edited to reach this version
   pinsToEdit: ClusterExternalConstraint[];
   // members this version is installed for, among those free to move
@@ -366,29 +363,6 @@ export const identifyLockstepClusterFixes = (
         return floor !== null && semver.eq(floor, version);
       });
 
-    // Whether a member could hold a version it does not hold today. When every
-    // requester asks through an open range (`*`, `0.83 - 0.86`), its current
-    // version is an accident of resolution rather than a constraint: the
-    // resolver is free to land it elsewhere, and which version that is is not
-    // ours to name. Anything exactly pinned, or pinned to the line it already
-    // carries (`^0.87.0` on an 0.87.0), is not re-resolvable.
-    const isReResolvable = (member: string): boolean => {
-      const ranges = externalRangesOn(member);
-      if (ranges.length === 0) return true;
-
-      const floors = ranges.map(rangeFloor);
-      if (floors.includes(null)) return false;
-
-      const highestFloor = floors
-        .filter((floor): floor is string => floor !== null)
-        .toSorted((a, b) => semver.rcompare(a, b))[0]!;
-
-      return (
-        ranges.every((range) => accepts(highestFloor, range)) &&
-        !isInstalled(member, highestFloor)
-      );
-    };
-
     const duplicatedSet = new Set(duplicatedMembers);
 
     // Members that end up on `version`, as a fixed point: start from those free
@@ -397,27 +371,11 @@ export const identifyLockstepClusterFixes = (
     // whoever an in-cluster requester pins elsewhere. Iterating matters because
     // such a requester only stops pinning if it converges too, and the family's
     // dependency edges run both ways.
-    // Members whose version the resolver will choose: they hold a version the
-    // family is leaving, and nothing pins them to it. Their current pins do not
-    // block the family — the install round-trip moves them — but the version
-    // they land on has to be verified afterwards, not asserted here.
-    const floatingFor = (version: string): Set<string> =>
-      new Set(
-        clusterMembers.filter(
-          (member) =>
-            // a duplicated member is what the fix is about: it converges or it
-            // is excluded, never "the resolver will sort it out"
-            !duplicatedSet.has(member) &&
-            !isInstalled(member, version) &&
-            !canReResolve(member, version) &&
-            isReResolvable(member),
-        ),
-      );
-
-    const convergentSetFor = (
-      version: string,
-      floating: Set<string>,
-    ): Set<string> => {
+    //
+    // A requester its own requesters only ask for through an open range (`*`,
+    // `^21.0.2`) is no exception: a resolver keeps a locked version they still
+    // accept, so nothing moves it, and its pins block like any other.
+    const convergentSetFor = (version: string): Set<string> => {
       const converging = new Set(
         clusterMembers.filter(
           (member) =>
@@ -434,8 +392,7 @@ export const identifyLockstepClusterFixes = (
           const pinnedElsewhere = (internalByMember.get(member) ?? []).some(
             (internal) =>
               !accepts(version, internal.range) &&
-              !converging.has(internal.requesterName) &&
-              !floating.has(internal.requesterName),
+              !converging.has(internal.requesterName),
           );
           if (pinnedElsewhere) {
             converging.delete(member);
@@ -448,17 +405,14 @@ export const identifyLockstepClusterFixes = (
     };
 
     const candidates = candidateVersions.map((version): Candidate => {
-      const floating = floatingFor(version);
-      const converging = convergentSetFor(version, floating);
+      const converging = convergentSetFor(version);
 
       return {
         version,
-        floatingMembers: [...floating].toSorted((a, b) => a.localeCompare(b)),
+        converging,
         // a pin the user would have to edit makes a candidate a last resort
         pinsToEdit: workspaceConstraints.filter(
-          (constraint) =>
-            !floating.has(constraint.packageName) &&
-            !accepts(version, constraint.range),
+          (constraint) => !accepts(version, constraint.range),
         ),
         convergentMembers: duplicatedMembers.filter((member) =>
           converging.has(member),
@@ -534,7 +488,6 @@ export const identifyLockstepClusterFixes = (
         excludedMembers: [],
         anchor,
         reuseFixes,
-        floatingMembers: [],
         workspaceChanges: [],
         reResolutionSet: [],
         externalConstraints,
@@ -550,15 +503,22 @@ export const identifyLockstepClusterFixes = (
       .filter((constraint) => canMove(constraint.packageName, target))
       .map((constraint) => ({ ...constraint, to: target }));
 
+    // Editing the pin moves the anchor along with it: a range repointed at the
+    // version being left would split the family again.
+    const movesAnchor = workspaceChanges.some(
+      (change) => change.range === anchor,
+    );
+
     // re-resolution set: members free to move that are pulled from outside the
     // cluster and do not carry the target version, so a pure-lock copy is
-    // impossible. Internal-only members cascade from these.
-    const floatingSet = new Set(best.floatingMembers);
+    // impossible. Internal-only members cascade from these. A member that is
+    // not duplicated also has to survive the converging fixed point: one an
+    // excluded sibling pins elsewhere would only become a new duplicate.
     const reResolutionSet = clusterMembers
       .filter(
         (member) =>
           membersWithExternalDependent.has(member) &&
-          !floatingSet.has(member) &&
+          (duplicatedSet.has(member) || best.converging.has(member)) &&
           canMove(member, target) &&
           canReResolve(member, target) &&
           !isInstalled(member, target),
@@ -585,14 +545,10 @@ export const identifyLockstepClusterFixes = (
         blockedBy,
       })),
       anchor,
-      reuseFixes,
-      floatingMembers: best.floatingMembers,
+      reuseFixes: movesAnchor ? [] : reuseFixes,
       workspaceChanges,
       reResolutionSet,
-      needsRoundTrip:
-        reResolutionSet.length > 0 ||
-        workspaceChanges.length > 0 ||
-        best.floatingMembers.length > 0,
+      needsRoundTrip: reResolutionSet.length > 0 || workspaceChanges.length > 0,
       externalConstraints,
       applicable: true,
     });

package/src/index.ts

@@ -116,6 +116,15 @@ export type {
 } from "./planClusterApply.ts";
 export { diffDuplicates } from "./duplicateSnapshot.ts";
 export type { DuplicateDiff, DuplicateSnapshot } from "./duplicateSnapshot.ts";
+export {
+  heldOverrides,
+  outstandingOverrides,
+  reuseKeys,
+} from "./clusterOverrides.ts";
+export type {
+  OverrideRoundStates,
+  OverrideTargetState,
+} from "./clusterOverrides.ts";
 export { partitionUnconditionalOverrides } from "./unconditionalOverrides.ts";
 export type {
   PartitionedOverrides,

package/src/planClusterApply.test.ts

@@ -14,7 +14,6 @@ const fix = (overrides: Partial<ClusterFix>): ClusterFix => ({
   excludedMembers: [],
   anchor: null,
   reuseFixes: [],
-  floatingMembers: [],
   workspaceChanges: [],
   reResolutionSet: [],
   externalConstraints: [],
@@ -106,25 +105,38 @@ describe("planClusterApply", () => {
     ]);
   });
 
-  it("lets the anchored reuse win over a computed target", () => {
-    const plan = planClusterApply([
-      fix({
-        applicable: true,
-        target: "0.87.0",
-        convergentMembers: ["mini-metro-config"],
-        anchor: "0.84.5",
-        reuseFixes: [
-          {
-            requester: "mini-plugin@1.0.0",
-            requesterName: "mini-plugin",
-            packageName: "mini-metro-config",
-            range: "*",
-            from: "0.87.0",
-            to: "0.84.5",
-          },
-        ],
-      }),
+  const anchoredFix = fix({
+    applicable: true,
+    target: "0.87.0",
+    convergentMembers: ["mini-metro-config"],
+    anchor: "0.84.5",
+    reuseFixes: [
+      {
+        requester: "mini-plugin@1.0.0",
+        requesterName: "mini-plugin",
+        packageName: "mini-metro-config",
+        range: "*",
+        from: "0.87.0",
+        to: "0.84.5",
+      },
+    ],
+  });
+
+  it("leaves the reuse out when asked, before it can outrank the target", () => {
+    const plan = planClusterApply([anchoredFix], { reuse: false });
+
+    deepStrictEqual(plan.overrides, [
+      {
+        packageName: "mini-metro-config",
+        version: "0.87.0",
+        reason: "converge",
+      },
     ]);
+    deepStrictEqual(plan.conflicts, []);
+  });
+
+  it("lets the anchored reuse win over a computed target", () => {
+    const plan = planClusterApply([anchoredFix]);
 
     deepStrictEqual(plan.overrides, [
       {

package/src/planClusterApply.ts

@@ -37,9 +37,14 @@ export interface ClusterApplyPlan {
  * `excludedMembers` lists.
  *
  * `reuseFixes` come first: they converge on `anchor`, the version the user
- * pinned, and a pin outranks a version the detector merely computed.
+ * pinned, and a pin outranks a version the detector merely computed. A package
+ * manager that cannot hold a reuse without an override passes `reuse: false`,
+ * so they are left out before they can outrank a convergence.
  */
-export const planClusterApply = (fixes: ClusterFix[]): ClusterApplyPlan => {
+export const planClusterApply = (
+  fixes: ClusterFix[],
+  { reuse = true }: { reuse?: boolean } = {},
+): ClusterApplyPlan => {
   const manifestEdits: PlannedManifestEdit[] = [];
   const unresolvableChanges: string[] = [];
   const conflicts: ClusterApplyPlan["conflicts"] = [];
@@ -64,9 +69,9 @@ export const planClusterApply = (fixes: ClusterFix[]): ClusterApplyPlan => {
     overrides.set(packageName, { packageName, version, reason });
   };
 
-  for (const fix of fixes) {
-    for (const reuse of fix.reuseFixes) {
-      addOverride(reuse.packageName, reuse.to, "reuse");
+  for (const fix of reuse ? fixes : []) {
+    for (const reuseFix of fix.reuseFixes) {
+      addOverride(reuseFix.packageName, reuseFix.to, "reuse");
     }
   }
 

package/src/renderDuplicatesReport.test.ts

@@ -32,7 +32,6 @@ const clusterFix = (overrides: Partial<ClusterFix> = {}): ClusterFix => ({
   excludedMembers: [],
   anchor: null,
   reuseFixes: [],
-  floatingMembers: [],
   workspaceChanges: [],
   reResolutionSet: ["metro"],
   externalConstraints: [metroPin],
@@ -443,13 +442,6 @@ describe("renderDuplicatesReport", () => {
     ok(render({ clusterFixes: [clusterFix()] }).includes("(1 member follows)"));
   });
 
-  it("names the members whose version the resolver picks", () => {
-    const output = render({
-      clusterFixes: [clusterFix({ floatingMembers: ["metro-config"] })],
-    });
-    ok(output.includes("    Resolver picks: metro-config"));
-  });
-
   it("has no Dedupe section for an unfixable cluster", () => {
     const output = render({
       clusterFixes: [
@@ -678,7 +670,6 @@ describe("renderDuplicatesReport", () => {
               nonNpmCount: 0,
             },
           },
-          floatingMembers: ["metro-config-long-name"],
           anchor: "0.84.5",
           reuseFixes: [
             {

package/src/renderDuplicatesReport.ts

@@ -493,13 +493,6 @@ const renderCluster = (
         `    ${color("dim", "Driven by:")} ${nameList(color, fix.driverMembers)}${follow}`,
       );
     }
-    // nothing pins these, so the package manager picks their version: the
-    // fixable count above is not a guarantee for them
-    if (fix.floatingMembers.length > 0) {
-      log(
-        `    ${color("dim", "Resolver picks:")} ${nameList(color, fix.floatingMembers)}`,
-      );
-    }
   }
 
   if (fix.excludedMembers.length > 0) {

package/src/unconditionalOverrides.test.ts

@@ -31,7 +31,6 @@ const fixWith = (constraints: ClusterExternalConstraint[]): ClusterFix => ({
   excludedMembers: [],
   anchor: null,
   reuseFixes: [],
-  floatingMembers: [],
   workspaceChanges: [],
   reResolutionSet: [],
   externalConstraints: constraints,

package/src/unconditionalOverrides.ts

@@ -31,7 +31,8 @@ const accepts = (version: string, range: string): boolean =>
  * dependent onto a version it never allowed.
  *
  * The `converge` overrides are safe by construction: the detector only converges
- * a member no third-party range holds elsewhere. A `reuse` override is derived
+ * a member no third-party range holds elsewhere, and only re-resolves one no
+ * in-cluster requester pins elsewhere either. A `reuse` override is derived
  * from a single requester's range, and another requester can still reject it.
  */
 export const partitionUnconditionalOverrides = (