anchor.diff:      /// </summary>
       /// <param name="receiver">User provided assembly submit operation.</param>
       /// <param name="assemblies">Assemblies to be exported.</param>
  -    member v.SubmitAssemblies(receiver : IRemoteAssemblyReceiver, assemblies : seq<Assembly>) = async {
  -        let index = assemblies |> Seq.map (fun a -> a.AssemblyId, a) |> Map.ofSeq
  +    member v.SubmitAssemblies(receiver : IRemoteAssemblyReceiver, dependencies : seq<AssemblyId>) = async {
  +        let dependencies = Seq.toList dependencies
   
           // Step 1. submit assembly identifiers to receiver; get back loaded state
  -        let headers = index |> Map.toList |> List.map fst
  -        let! info = receiver.GetLoadedAssemblyInfo headers
  +        let! info = receiver.GetLoadedAssemblyInfo dependencies
           
           // Step 2. detect dependencies that require posting
           let tryGetAssemblyPackage (info : AssemblyLoadInfo) =
  
positive.code:         let! dependencies = publisher.GetRequiredAssemblyInfo()
  
          // step 2. resolve dependencies that are missing from client
          let tryCheckLoadStatus (id : AssemblyId) =
              if v.IsLocalDynamicAssemblySlice id then None
              else
                  match v.GetAssemblyLoadInfo(id, ?loadPolicy = loadPolicy) with
                  | NotLoaded id
                  | LoadFault (id,_) -> Some id
                  | Loaded (id,_, Some info) when info.IsPartial -> Some id
                  | Loaded _ -> None
  
          let missing = dependencies |> List.choose tryCheckLoadStatus
  
  
negative.code: /// Defines an abstract assembly exporter; to be used by VagabondClient.
  type IRemoteAssemblyPublisher =
      /// receives a collection of dependencies required by remote publisher.
      abstract GetRequiredAssemblyInfo : unit -> Async<(AssemblyId * VagabondMetadata option) list>
      /// request assembly packages from publisher.
      abstract PullAssemblies : AssemblyId list -> Async<VagabondAssembly list>
  
  