anchor.diff:  
               | None -> 
                   let create () =
  -                    let n = TaskTreeNode(state, mapping, rootId, t)
  +                    let n = TaskTreeNode<'a>(state, mapping, rootId, t)
                       root <- Some n
                       n.Task.ContinueWith (fun (t : Task<_>) -> MVar.put state.trigger ()) |> ignore
   
  
positive.code:                         match pickTrees with
                          | Some mm ->
                              let trafo = getRootTrafo root
                              let picky = r.State |> Option.map (fun s -> SimplePickTree.ofTreeNode trafo s)
                              transact (fun () -> 
                                  match picky with
                                  | Some picky -> mm.Value <- mm.Value |> HMap.add root picky
  
negative.code:     type TreeNode<'a> =
          {
              original : ILodTreeNode
              value : option<'a>
              children : list<TreeNode<'a>>
          }
  
  
      module SimplePickTree =
          
          let rec ofTreeNode (trafo : IMod<Trafo3d>) (v : TreeNode<GeometryPoolInstance>) : option<SimplePickTree> =
              match v.value with
              | Some value -> 
                  let positions = value.geometry.IndexedAttributes.[DefaultSemantic.Positions] |> unbox<V3f[]>
                  let bounds = v.original.WorldCellBoundingBox
              
                  SimplePickTree (
                      v.original,
                      bounds,
                      positions,
                      trafo,
                      v.original.Root.DataTrafo,
                      value.geometry.IndexedAttributes |> SymDict.toSeq |> MapExt.ofSeq,
                      value.uniforms,
                      lazy (v.children |> List.choose (ofTreeNode trafo))
                  ) |> Some
              | None ->
                  None
  
      module TreeHelpers =
  
  