anchor.diff:      member private c.TryElevateToDistributed() =
           match state with
           | Canceled -> None
  -        | Distributed rk -> Some rk
  +        | Distributed token -> Some token
           | Localized _ ->
               lock state (fun () ->
                   match state with
                   | Canceled -> None
  -                | Distributed id -> Some id
  +                | Distributed token -> Some token
                   | Localized None ->
  -                    match tryCreateToken source None |> Async.RunSync with
  -                    | None -> state <- Canceled ; None
  -                    | Some id -> state <- Distributed id ; localToken <- None ; Some id
  +                    let token = source.CreateCancellationTokenSource() |> Async.RunSync
  +                    state <- Distributed token ; localToken <- None ; 
  +                    Some token
   
                   | Localized (Some parent) ->
                       // elevate parent to distributed source
                       match parent.TryElevateToDistributed() with
                       | None -> state <- Canceled ; None // parent canceled ; declare canceled
  -                    | Some parentId ->
  +                    | Some parentToken ->
                           // create token entity using for current cts
  -                        match tryCreateToken source (Some parentId) |> Async.RunSync with
  +                        match source.TryCreateLinkedCancellationTokenSource parentToken |> Async.RunSync with
                           | None -> state <- Canceled ; None
                           | Some id -> state <- Distributed id ; localToken <- None ; Some id)
   
  
positive.code:     /// <param name="source">Backend source for distributed cancellation tokens.</param>
      /// <param name="parent">Parent distributed cancellation token source. Defaults to no parent.</param>
      /// <param name="elevate">Directly elevate cancellation token to distributed. Defaults to false.</param>
      static member internal Create(source : ICloudDictionary<DistributedCancellationTokenInfo>, ?parent : DistributedCancellationToken, ?elevate : bool) = async {
          let elevate = defaultArg elevate false
          match parent with
          | None when elevate ->
              let! id = tryCreateToken source None
              return new DistributedCancellationToken(source, Distributed <| Option.get id)
          | _ ->
              let dcts = new DistributedCancellationToken(source, Localized(parent))
              if elevate then dcts.TryElevateToDistributed() |> ignore
              return dcts
      }
  
  and [<Sealed;DataContract>] DistributedCancellationTokenFactory private (source : ICloudDictionary<DistributedCancellationTokenInfo>) =
      
      [<DataMember(Name = "Source")>]
      let source = source
  
      /// <summary>
      ///     Creates a distributed cancellation token source with lazy elevation to distributed cancellation semantics.
      /// </summary>
      /// <param name="source">Backend source for distributed cancellation tokens.</param>
      /// <param name="parent">Parent distributed cancellation token source. Defaults to no parent.</param>
      /// <param name="elevate">Directly elevate cancellation token to distributed. Defaults to false.</param>
      member __.Create(?parent : DistributedCancellationToken, ?elevate : bool) =
          DistributedCancellationToken.Create(source, ?parent = parent, ?elevate = elevate)
  
      static member Create(dictionaryProvider : ICloudDictionaryProvider) = async {
          let! dict = dictionaryProvider.Create<DistributedCancellationTokenInfo>()
          return new DistributedCancellationTokenFactory(dict)
      }
  
      interface ICancellationTokenSourceFactory with
          member x.CreateCancellationTokenSource() = async {
              let! dcts = DistributedCancellationToken.Create(source)
              return dcts :> ICloudCancellationTokenSource
          }
          
          member x.CreateLinkedCancellationTokenSource(parent: ICloudCancellationToken) = async {
              match parent with
              | :? DistributedCancellationToken as pdcts ->
                  let! dcts = DistributedCancellationToken.Create(pdcts.Source, parent = pdcts)
                  return dcts :> ICloudCancellationTokenSource        
              | _ -> return invalidArg "parent" "invalid cancellation token type."
          }
negative.code:     interface ICloudCancellationTokenSource with
          member this.Cancel() : unit = this.Cancel()
          member this.Token : ICloudCancellationToken = this :> ICloudCancellationToken
  
  //    /// <summary>
  //    ///     Creates a distributed cancellation token source with lazy elevation to distributed cancellation semantics.
  //    /// </summary>
  //    /// <param name="source">Backend source for distributed cancellation tokens.</param>
  //    /// <param name="parent">Parent distributed cancellation token source. Defaults to no parent.</param>
  //    /// <param name="elevate">Directly elevate cancellation token to distributed. Defaults to false.</param>
      static member internal Create(source : IGlobalCancellationTokenFactory<'Token>, ?parent : DistributedCancellationToken<'Token>, ?elevate : bool) = async {
          let elevate = defaultArg elevate false
          match parent with
          | None when elevate ->
              let! token = source.CreateCancellationTokenSource()
              return new DistributedCancellationToken<'Token>(source, Distributed token)
          | _ ->
              let dcts = new DistributedCancellationToken<'Token>(source, Localized(parent))
              if elevate then dcts.TryElevateToDistributed() |> ignore
              return dcts
      }
  
  
  [<Sealed; DataContract>]
  type DistributedCancellationTokenFactory<'Token when 'Token :> IGlobalCancellationToken> (factory : IGlobalCancellationTokenFactory<'Token>) =
  
      [<DataMember(Name = "GlobalFactory")>]
      let factory = factory
  
      /// <summary>
      ///     Creates a distributed cancellation token source with lazy elevation to distributed cancellation semantics.
  