anchor.diff:              | ResolverObjectNode node ->
                   let value = tree.Value
                   let typeName = getObjectName d.Info.ReturnDef value ctx.Schema.GetPossibleTypes
  -                let fieldName = getFieldName node
  +                let! fieldName = getFieldName node
                   let provider = ctx.Schema.LiveFieldSubscriptionProvider
                   let identity = provider.TryFind typeName fieldName |> Option.map (fun x -> x.Identity)
                   match identity, toOption value with
                   | Some identity, Some value ->
  -                    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 = AsyncVal.get (treeToDict tree)
  -                        mapResult data err path d.Kind)
  -                    |> Observable.toSeq
  -                    |> Seq.concat
  -                | _ -> Seq.empty
  -            | _ -> Seq.empty
  -        | _ -> Seq.empty
  +                    return 
  +                        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 = AsyncVal.get (treeToDict tree)
  +                            mapResult data err path d.Kind)
  +                        |> Observable.toSeq
  +                        |> Seq.concat
  +                | _ -> return Seq.empty
  +            | _ -> return Seq.empty
  +        | _ -> return Seq.empty
  +    }
       let rec deferredResult (tree : ResolverTree) (d : DeferredExecutionInfo) =
           let fdef = d.Info.Definition
           let args = getArgumentValues fdef.Args d.Info.Ast.Arguments ctx.Variables
  
positive.code:                                 match d.Kind with
                                  | LiveExecution -> Seq.empty
                                  | _ -> mapResult data err path d.Kind
                              let live = mapLiveResult tree path d fieldCtx
                              return Seq.append deferred live
                          }) >> AsyncVal.collectParallel))
                  |> Array.ofList
  
negative.code:                         | _ -> 
                              let data, err = treeToDict tree |> AsyncVal.get
                              mapResult data err path d.Kind
                      let! live = mapLiveResult tree path d fieldCtx
                      return Seq.append deferred live
                  } |> Array.singleton |> AsyncVal.collectParallel
              let innerResult =
  