Filter is null when trying to World.(Any)Update(deltaTime) about morpeh HOT 6 CLOSED

using System;
using System.Linq;
using Core.Extensions;
using Core.Extensions.Views;
using Core.Movement;
using Cysharp.Threading.Tasks;
using Engine.Factories.SystemsFactories;
using Scellecs.Morpeh;
using TriInspector;
using UnityEngine;
using Zenject;
using EntityProvider = Engine.Providers.EntityProvider;

public sealed class GameplayStartup : BaseInstaller
{
    [ReadOnly]
    [SerializeReference] private BaseMorpehFeature[] _activeFeatures = Array.Empty<BaseMorpehFeature>();
    private IFeaturesFactory _featuresesFactory;
    private IMoveLoopService _moveLoopService;
    private SystemFactoryArgs _systemFactoryArgs;

    [Inject]
    public void Constructor(World world, IFeaturesFactory featuresesFactory, SystemFactoryArgs systemFactoryArgs)
    {
        _systemFactoryArgs = systemFactoryArgs;
        World = world;
        World.UpdateByUnity = true;
        _featuresesFactory = featuresesFactory;

        CreateFeatures();
    }

    protected override async void OnEnable()
    {
        await EnableFeatures();
    }

    protected override void OnDisable()
    {
        DisableFeatures();
    }

    private async UniTask EnableFeatures()
    {
        var order = 0;
        for (var i = 0; i < _activeFeatures.Length; i++, order++)
            await World.AddFeatureAsync(order, _activeFeatures[i]);
    }

    private void DisableFeatures()
    {
        for (var i = 0; i < _activeFeatures.Length; i++)
            World.RemoveFeature(_activeFeatures[i]);
    }

    private void Start()
    {
        foreach (var entity in FindObjectsOfType<EntityProvider>())
        {
            entity.Init(World);
        }
    }

    private void OnDestroy()
    {
        World?.Dispose();
    }

    private void CreateFeatures()
    {
        _activeFeatures = _featuresesFactory.CreateFeatures(_systemFactoryArgs).ToArray();
    }
}

using Scellecs.Morpeh;
using UnityEngine;

public class Bootstrap : MonoBehaviour {
    private void Start() {
        World.Default.UpdateByUnity = false;
        var sg = World.Default.CreateSystemsGroup();
        sg.AddSystem(new FooSystem());
        World.Default.AddSystemsGroup(0, sg);
    }

    private void Update() {
        World.Default.Update(Time.deltaTime);
    }

    private void FixedUpdate() {
        World.Default.FixedUpdate(Time.fixedDeltaTime);
    }

    private void LateUpdate() {
        World.Default.LateUpdate(Time.deltaTime);
    }
}

public struct TestComponent0 : IComponent {
    public int test;
}

public class FooSystem : ISystem {
    public World World { get; set; }

    private Filter filter;
    private Stash<TestComponent0> stash;

    public void OnAwake() {
        this.filter = this.World.Filter.With<TestComponent0>().Build();
        this.stash = this.World.GetStash<TestComponent0>();
        
        for (int i = 0, length = 1000; i < length; i++) {
            var e = this.World.CreateEntity();
            e.AddComponent<TestComponent0>();
        }
    }
    public void OnUpdate(float deltaTime) {
        foreach (var entity in this.filter) {
            this.stash.Get(entity).test++;
        }
        
    }
    
    public void Dispose() {
    }
}

using Core.Characteristics.EnergyLimits.Components;
using Core.Extensions;
using Scellecs.Morpeh;
using UnityEngine;

namespace Core.Characteristics.EnergyLimits.Systems
{
#if ENABLE_IL2CPP
    using Unity.IL2CPP.CompilerServices;
  
    [Il2CppSetOption(Option.NullChecks, false)]
    [Il2CppSetOption(Option.ArrayBoundsChecks, false)]
#endif
    
    public sealed class ChargeSystem : ISystem
    {
        private Filter _filter;
        private Stash<Energy> _energyPool;
        private Stash<ChargeRequest> _chargeRequestPool;

        public World World { get; set; }

        public void OnAwake()
        {
            _filter = World.Filter.With<ChargeRequest>().Build();
            _energyPool = World.GetStash<Energy>();
            _chargeRequestPool = World.GetStash<ChargeRequest>();
        }

        public void OnUpdate(float deltaTime)
        {
            foreach (var requestEntity in _filter)
            {
                ref var chargeRequest = ref _chargeRequestPool.Get(requestEntity);
                ref var chargeRequestEntity = ref chargeRequest.Entity;
                ref var energy = ref _energyPool.Get(chargeRequestEntity);
                var chargeAmount = chargeRequest.Value;
                energy.Value = Mathf.Min(energy.MaxValue, energy.Value + chargeAmount);

                World.SendMessage(new EnergyChangedEvent { Entity = chargeRequestEntity });

                World.RemoveEntity(requestEntity);
            }
        }

        public void Dispose()
        {
        }
    }
}