anchor.diff:            Args = args
             Variables = ctx.Variables }
       subscriptionProvider.Add fieldCtx value subdef
  -    |> Observable.bind(fun v ->
  -        buildResolverTree returnType fieldCtx fieldExecuteMap (Some v)
  -        |> AsyncVal.map(treeToDict)
  +    |> Observable.bind(fun v -> 
  +        let dict = asyncVal {
  +            let! tree = buildResolverTree returnType fieldCtx fieldExecuteMap (Some v)
  +            return! treeToDict tree
  +        }
  +        dict
           |> AsyncVal.map(fun (data, err) -> 
               let output = NameValueLookup.ofList[nameOrAlias, data.Value]                
               match err with
  
positive.code:                     provider.Add (identity value) typeName fieldName
                      |> Observable.map (fun v ->
                          let tree = AsyncVal.get (buildResolverTree d.Info.ReturnDef fieldCtx fieldExecuteMap (Some v))
                          let data, err = treeToDict tree
                          mapResult data err path d.Kind)
                      |> Observable.toSeq
                      |> Seq.concat
  
negative.code:                 match ctx.ExecutionPlan.Strategy with
                  | ExecutionStrategy.Parallel -> resultTrees |> AsyncVal.collectParallel
                  | ExecutionStrategy.Sequential -> resultTrees |> AsyncVal.collectSequential
              let! dicts, errors =
                  trees
                  |> Array.fold(fun (kvpsErrs : AsyncVal<KeyValuePair<string, obj> list * Error list>) (tree) -> asyncVal {
                      let! k, e = treeToDict tree
                      let! kvps, errs = kvpsErrs
                      return k::kvps, e@errs}) (Value ([],[]))
              return NameValueLookup(dicts |> List.rev |> List.toArray), (errors |> List.rev)
          }
      let rec traversePath (d : DeferredExecutionInfo) (fieldCtx : ResolveFieldContext) (path: obj list) (tree: AsyncVal<ResolverTree>) (pathAcc: obj list): AsyncVal<(ResolverTree * obj list) []> =
  