anchor.diff:              | None ->
                   systemTree |> ListTree.tryAdd tautology system
           if Option.isSome addedOpt then
  +            hierarchyChanges.Add (NodeAdded (nodeId, parentIdOpt))
               systemDict.Add (nodeId, system)
               Some nodeId
           else None
   
       member this.RemoveNode nodeId =
  -        let nodeIdStr = string nodeId
  +
  +        // infer system name
  +        let systemName = string nodeId
  +
  +        // unregister all correlated components from node's system
           systemTree |>
  -        ListTree.findAll (fun system -> system.Name = nodeIdStr) |>
  +        ListTree.findAll (fun system -> system.Name = systemName) |>
           Seq.iter (fun system ->
               system.GetEntitiesCorrelated () |>
  -            Seq.map (fun correlated -> changes.Add (HierarchyRemove (nodeId, correlated)); correlated) |>
  -            Seq.iter (fun correlated -> system.UnregisterCorrelated correlated |> ignore<bool>))
  -        systemDict.Remove nodeId
  +            Seq.iter (fun correlated ->
  +                hierarchyChanges.Add (ComponentRemovedFromNode (nodeId, correlated))
  +                system.UnregisterCorrelated correlated |> ignore<bool>))
  +
  +        // remove node's system from tree
  +        systemTree |> ListTree.removeFirst (fun system -> system.Name = systemName) |> ignore<bool>
  +
  +        // remove entry from dict
  +        let result = systemDict.Remove nodeId
  +
  +        // log change
  +        if result then hierarchyChanges.Add (NodeRemoved nodeId)
  +
  +        // fin
  +        result
   
       member this.QualifyHierarchical nodeId entityId =
           match systemDict.TryGetValue nodeId with
  
positive.code: 
      let systemTree = ListTree.makeEmpty<SystemCorrelated<'c, 'w>> ()
      let systemDict = dictPlus<Guid, SystemCorrelated<'c, 'w>> HashIdentity.Structural []
      let mutable changes = List<HierarchyChange> ()
  
      new (ecs) = SystemHierarchical (false, false, ecs)
  
      member this.Components with get () =
          systemTree |> ListTree.map (fun system -> system.Correlateds)
  
      member this.WithComponentsBuffered fn worldOpt =
          systemTree |> ListTree.map (fun system -> system.WithCorrelatedsBuffered fn worldOpt)
  
      member this.PopHierarchyChanges () =
          let popped = changes
          changes <- List<HierarchyChange> ()
          popped
  
      member this.IndexNode nodeId =
  
negative.code: 
          // track registration
          if unregistered then
              hierarchyChanges.Add (ComponentAddedToNode (nodeId, entityId))
  
          // unregister correlation
          if unregistered && not isolated then
  