anchor.diff:          match arrayObjss.TryGetValue componentName with
           | (true, arrayObjs) ->
               match arrayObjs with
  -            | UnbufferedArrayObjs unbuffered -> unbuffered |> Seq.cast<'c ArrayRef> |> Seq.toArray
  -            | BufferedArrayObjs buffered -> buffered.WritableArrayObjs |> Seq.cast<'c ArrayRef> |> Seq.toArray
  +            | ArrayObjs unbuffered -> unbuffered |> Seq.cast<'c ArrayRef> |> Seq.toArray
  +            | ArrayObjsBuffered buffered -> buffered.ArrayObjs |> Seq.cast<'c ArrayRef> |> Seq.toArray
           | (false, _) -> [||]
   
       member this.BufferComponentArrays<'c when 'c : struct and 'c :> 'c Component> () =
  
positive.code:         | (true, _) -> failwith ("Array already initally allocated for '" + componentName + "'.")
          | (false, _) ->
              if buffered then
                  let arr = { Array = Array.zeroCreate<'c> Constants.Ecs.ArrayReserve }
                  arrayObjss.Add (componentName, UnbufferedArrayObjs (List [box arr]))
                  (arr, arr)
              else
                  let writableAref = { Array = Array.zeroCreate<'c> Constants.Ecs.ArrayReserve }
                  let readOnlyAref = { Array = Array.zeroCreate<'c> Constants.Ecs.ArrayReserve }
                  arrayObjss.Add (componentName, BufferedArrayObjs { WritableArrayObjs = List [box writableAref]; ReadOnlyArrayObjs = List [box readOnlyAref] })
                  (writableAref, readOnlyAref)
  
      member this.AllocateJunction<'c when 'c : struct and 'c :> 'c Component> () =
          let componentName = typeof<'c>.Name
          match arrayObjss.TryGetValue componentName with
          | (true, found) ->
              match found with
              | UnbufferedArrayObjs arrayObjs ->
                  let aref = { Array = Array.zeroCreate<'c> Constants.Ecs.ArrayReserve }
                  arrayObjs.Add (box aref)
                  (box aref, box aref)
              | BufferedArrayObjs arrayObjs ->
                  let readOnlyAref = { Array = Array.zeroCreate<'c> Constants.Ecs.ArrayReserve }
                  let writableAref = { Array = Array.zeroCreate<'c> Constants.Ecs.ArrayReserve }
                  arrayObjs.WritableArrayObjs.Add (box writableAref)
                  arrayObjs.ReadOnlyArrayObjs.Add (box readOnlyAref)
                  (box writableAref, box readOnlyAref)
          | (false, _) -> failwith ("No array initially allocated for '" + componentName + "'.")
  
      member this.GetComponentArrays<'c when 'c : struct and 'c :> 'c Component> () =
  
negative.code:         match arrayObjss.TryGetValue componentName with
          | (true, arrayObjs) ->
              match arrayObjs with
              | ArrayObjs _ -> ()
              | ArrayObjsBuffered buffered ->
                  lock arrayObjs $ fun () ->
                      for i in 0 .. buffered.ArrayObjs.Count - 1 do
                          let aref = buffered.ArrayObjs.[i] :?> 'c ArrayRef
                          let arefBuffered = buffered.ArrayObjsBuffered.[i] :?> 'c ArrayRef
                          lock arefBuffered (fun () ->
                              if arefBuffered.Array.Length = aref.Array.Length
                              then aref.Array.CopyTo (arefBuffered.Array, 0)
                              else arefBuffered.Array <- Array.copy aref.Array)
          | (false, _) -> ()
  
      member this.WithComponentArraysBuffered<'c when 'c : struct and 'c :> 'c Component> fn =
  