DOTS NativeContainers error

Hey, nice job! While I fail to reproduce issue you described I noticed something different:

 foreach( int2 chunk in LoadedChunks )
     if( !ActiveChunks.Contains(chunk) )
         LoadedChunks.RemoveAt( LoadedChunks.IndexOf(chunk) );

This code gives me compiler warning ( entities 0.16.0-preview.21 here). And I suspect, on your machine, this code is not throwing anything (or maybe is? not sure) because it's being auto-magically replaced with standard for loop syntax:

 for( int i=0 ; i<LoadedChunks.Length ; i++ )
 {
     int2 chunk = LoadedChunks[i];
     if( !ActiveChunks.Contains(chunk) )
         LoadedChunks.RemoveAt( LoadedChunks.IndexOf(chunk) );
 }

Which is bad because it obfuscate what's happening here really: some indices are being skipped in the process. Visually producing this pattern:

To fix this replace it with for loop that counts indices from last to first:

 for( int i=LoadedChunks.Length-1 ; i!=-1 ; i-- )
 {
     int2 chunk = LoadedChunks[i];
     if( !ActiveChunks.Contains(chunk) )
         LoadedChunks.RemoveAt( LoadedChunks.IndexOf(chunk) );
 }

This is the proper way of removing items from a list while in a loop.

includes code for this mouse-operated debug gizmo:

 using UnityEngine;
 using Unity.Collections;
 using Unity.Mathematics;
 using Unity.Entities;
 using Unity.Jobs;
 
 public class WorldMaster : MonoBehaviour
 {
     [SerializeField] float2 _position;
     [SerializeField] float _chunkSize = 20;
     [SerializeField] int _loadDistance = 40;
     NativeList<int2> _activeChunks;
     NativeList<int2> _loadedChunks;
     JobHandle _dependency;
     void Start ()
     {
         _activeChunks = new NativeList<int2>(0, Allocator.Persistent);
         _loadedChunks = new NativeList<int2>(0, Allocator.Persistent);
     }
     void Update ()
     {
         _dependency.Complete();
         // Debug.Log($"num active:{_activeChunks.Length}, num loaded:{_loadedChunks.Length}");
 
         _dependency = ActivateChunks( _position , _chunkSize , _loadDistance , _activeChunks );
         _dependency = LoadChunks( _activeChunks , _loadedChunks , _dependency );
     }
     void OnDestroy ()
     {
         _activeChunks.Dispose();
         _loadedChunks.Dispose();
     }
     #if UNITY_EDITOR
     void OnDrawGizmos ()
     {
         if( !Application.isPlaying ) return;
 
         _dependency.Complete();
 
         Gizmos.color = new Color{ r=0 , g=1 , b=1 , a=0.3f };
         foreach( int2 i2 in _loadedChunks )
             Gizmos.DrawCube( new Vector3{ x=i2.x*_chunkSize + _chunkSize*0.5f , z=i2.y*_chunkSize + _chunkSize*0.5f } , new Vector3{ x=_chunkSize , z=_chunkSize } );
         
         Gizmos.color = new Color{ r=1 , g=0.92f , b=0.016f , a=0.3f };
         foreach( int2 i2 in _activeChunks )
             Gizmos.DrawWireCube( new Vector3{ x=i2.x*_chunkSize + _chunkSize*0.5f , z=i2.y*_chunkSize + _chunkSize*0.5f } , new Vector3{ x=_chunkSize , z=_chunkSize } );
         
         Gizmos.color = Color.red;
         Gizmos.DrawWireSphere( new Vector3{ x=_position.x , z=_position.y }  , _chunkSize*0.1f );
 
         {
             Ray ray = UnityEditor.HandleUtility.GUIPointToWorldRay( Event.current.mousePosition );
             new Plane( inNormal:Vector3.up , inPoint:Vector3.zero ).Raycast( ray , out float dist );
             float3 hit = ray.origin + ray.direction*dist;
             _position = new float2{ x=hit.x , y=hit.z };
         }
     }
     #endif
     public JobHandle ActivateChunks ( float2 position , float chunkSize , int loadDistance , NativeList<int2> activeChunks , JobHandle dependency = default(JobHandle) )
     {
         ActivateChunksJob job = new ActivateChunksJob();
         job.position = position;
         job.chunkSize = chunkSize;
         job.loadDistance = loadDistance;
         job.activeChunks = activeChunks;
         return job.Schedule( dependency );
     }
     public JobHandle LoadChunks ( NativeList<int2> activeChunks , NativeList<int2> loadedChunks , JobHandle dependency = default(JobHandle) )
     {
         LoadChunksJob job = new LoadChunksJob();
         job.activeChunks = activeChunks;
         job.loadedChunks = loadedChunks;
         return job.Schedule( dependency );
     }
 }
 public struct ActivateChunksJob : IJob
 {
     public float2 position;
     public float chunkSize;
     public int loadDistance;
     public NativeList<int2> activeChunks;
     void IJob.Execute ()
     {
         activeChunks.Clear();
         for( int x=0 ; x<loadDistance ; x++ )
         for( int y=0 ; y<loadDistance ; y++ )
         {
             int2 chunk = GetChunkFromWorld( position , chunkSize ) + new int2{ x = x - loadDistance/2 , y = y - loadDistance/2 };
             if( !activeChunks.Contains(chunk) )
                 activeChunks.Add( chunk );
         }
     }
     int2 GetChunkFromWorld ( float2 worldPosition , float chunkSize )
         => (int2) math.floor( worldPosition/chunkSize );
 }
 public struct LoadChunksJob : IJob
 {
     public NativeList<int2> activeChunks;
     public NativeList<int2> loadedChunks;
     void IJob.Execute ()
     {
         for( int i=0 ; i<activeChunks.Length ; i++ )
         {
             int2 chunk = activeChunks[i];
             if( !loadedChunks.Contains(chunk) )
                 loadedChunks.Add(chunk);
         }
         for( int i=loadedChunks.Length-1 ; i!=-1 ; i-- )
         {
             int2 chunk = loadedChunks[i];
             if( !activeChunks.Contains(chunk) )
                 loadedChunks.RemoveAt( loadedChunks.IndexOf(chunk) );
         }
     }
 }