anchor.diff:                  |> Set.ofSeq
   
               let isDirectDependency package = 
  -                dependenciesFile.GetDependenciesInGroup(groupName)
  +                dependenciesFile.GetDependenciesInGroup(group.Name)
                   |> Map.exists (fun p _ -> p = package)
   
               let isTransitiveDependency package =
  
positive.code:             |> Map.filter (fun p _ -> isDirectDependency p || isTransitiveDependency p)
  
          { ResolvedPackages = Resolution.Ok resolution
            ResolvedSourceFiles = lockFile.Groups.[groupName].RemoteFiles }
  
      let resolution =
          match UpdateMode.Mode updateAll package with
  
negative.code:                 |> DependencyChangeDetection.PinUnchangedDependencies dependenciesFile lockFile
              resolve dependenciesFile None
          | SelectiveUpdate(groupName,package) -> 
              let lockFileGroup = 
                  lockFile.Groups
                  |> Map.filter (fun g _ -> g = groupName)
                  |> Seq.map (fun kv -> kv.Value)
                  |> Seq.tryHead
              
              let lockFileGroup =
                  match lockFileGroup with
                  | Some g -> g
                  | None ->
                      { Name = groupName
                        Options = InstallOptions.Default
                        Resolution = Map.empty
                        RemoteFiles = List.empty }
  
              lockFile.Groups
              |> Map.map (fun _ group ->
                  { ResolvedPackages = Resolution.Ok group.Resolution
                    ResolvedSourceFiles = group.RemoteFiles })
              |> Map.add groupName (selectiveUpdate lockFileGroup package)
  
      let groups = 
          resolution
  