anchor.diff:      member this.Publish<'d> eventName (eventData : 'd) publisher world =
           match systemSubscriptions.TryGetValue eventName with
           | (true, subscriptions) ->
  -            Seq.fold (fun world (callback : obj) ->
  +            (Some world, subscriptions.Values) ||>
  +            Seq.fold (fun worldOpt (callback : obj) ->
                   match callback with
                   | :? SystemCallback<obj, 'w> as objCallback ->
                       let evt = { SystemEventData = eventData :> obj; SystemPublisher = publisher }
  -                    objCallback evt publisher this world
  -                | _ -> failwithumf ())
  -                world subscriptions.Values
  +                    objCallback evt publisher this worldOpt
  +                | _ -> failwithumf ()) |>
  +            Option.get
           | (false, _) -> world
   
       member this.PublishParallel<'d> eventName (eventData : 'd) publisher =
  
positive.code:             | ArrayObjsBuffered buffered -> buffered.ArrayObjsUnbuffered |> Seq.cast<'c ArrayRef> |> Seq.toArray
          | (false, _) -> [||]
  
      member this.WithComponentArraysBuffered<'c when 'c : struct and 'c :> 'c Component> fn (world : 'w) =
          let componentName = typeof<'c>.Name
          match arrayObjss.TryGetValue componentName with
          | (true, arrayObjs) ->
              match arrayObjs with
              | ArrayObjs unbuffered ->
                  let arefs = unbuffered |> Seq.cast<'c ArrayRef> |> Seq.toArray
                  fn arefs world
              | ArrayObjsBuffered buffered ->
                  lock arrayObjs $ fun () ->
                      let arefsBuffered = buffered.ArrayObjsBuffered |> Seq.cast<'c ArrayRef> |> Seq.toArray
                      fn arefsBuffered world
          | (false, _) -> world
  
      member this.BufferComponentArrays<'c when 'c : struct and 'c :> 'c Component> () =
          let componentName = typeof<'c>.Name
  
negative.code:     do this.RegisterSystemGeneralized globalSystem
  
      member private this.BoxCallback<'a> (callback : SystemCallback<'a, 'w>) =
          let boxableCallback = fun (evt : SystemEvent<obj, 'w>) system ->
              let evt =
                  { SystemEventData = evt.SystemEventData :?> 'a
                    SystemPublisher = evt.SystemPublisher }
              callback evt system
          boxableCallback :> obj
  
      member private this.Correlations 
  