anchor.diff:    // incompatible source/desc. Algorithm TBD.
     PackageDep _mergeDeps(Iterable<PackageDep> deps);
   
  -  // Intersect two deps, return `null` if they aren't compatible (diff name, diff
  +  // Intersect [deps], return `null` if they aren't compatible (diff name, diff
     // source, diff desc, or non-overlapping).
     //
  -  // Should this reduce gaps? Are gaps possible if the inputs are fully merged?
  -  PackageDep _intersectDeps(PackageDep dep1, PackageDep dep2);
  +  // Doesn't need to reduce gaps if everything's already maximized.
  +  PackageDep _intersectDeps(Iterable<PackageDep> deps);
   
     // Returns packages allowed by [minuend] but not also [subtrahend]. `null` if
     // the resulting constraint is empty.
  
positive.code:       assert(dependency.depender.toRef() == depender.toRef());
        return dependency.depender;
      }));
      if (!mergedDepender.constraint.allowsAll(depender.constraint)) return null;
  
      // If the dependencies cover all of [depender], try to union the allowed
      // versions to get the narrowest possible constraint that covers all
  
negative.code:           // * a [3, 4) depends on b [1, 3)
            _removeDependency(dependency);
  
            var intersection = _intersectDeps([dependency.depender, fact.depender]);
            _fromCurrent.add(new Dependency(
                intersection,
                _intersectDeps([dependency.allowed, fact.allowed]),
                [dependency, fact]));
  
            var dependencyDifference = _depMinus(dependency, intersection);
  