fix(terrain): reconcile chunk tracker with loaded chunks

The tracker's only event sources are the loadChunk/unloadChunk hooks, so any
chunk transition that bypasses them (chunk data written to a chunk the
tracker never saw load, mods mutating the loaded-chunk map directly) leaves
the tracker permanently out of sync: the affected chunks never satisfy the
3x3 neighbor-readiness gate, are never published to the renderer, and produce
holes that approaching does not heal until the world is re-entered.

ChunkTracker.reconcile diffs the tracked set against the world's
authoritative loaded set and replays the difference through the regular
event methods, and the client-chunk-manager mixin invokes it once per client
tick; in steady state the diff is empty and no events fire.

Author: DHJComical

celeritas-common/src/main/java/org/embeddedt/embeddium/impl/render/chunk/map/ChunkTracker.java

@@ -112,6 +112,64 @@ public synchronized void onChunkStatusRemoved(int x, int z, int flags) {
         this.updateNeighbors(x, z);
     }
 
+    /**
+     * Reconciles the tracked state with the chunks actually loaded by the world.
+     *
+     * The normal load/unload event stream can miss transitions (e.g. chunk data written to a
+     * chunk the tracker never saw load, or mods mutating the world's chunk map directly),
+     * which leaves the tracker permanently out of sync with no way to recover: affected chunks
+     * never satisfy the neighbor-readiness gate and are never published to subscribers. This
+     * method diffs the tracked set against the world's authoritative loaded set and replays
+     * the difference through the regular event methods, so neighbor-readiness gating and
+     * subscription notifications behave exactly as if the events had arrived normally.
+     *
+     * @param actuallyLoadedChunkKeys packed coordinates of the chunks currently loaded in the
+     *                                world; not modified by this method
+     */
+    public synchronized void reconcile(LongSet actuallyLoadedChunkKeys) {
+        int unknown = this.chunkStatus.defaultReturnValue();
+
+        // Collect the diff first: replaying the events mutates chunkStatus, which must not
+        // happen while either set is being iterated.
+        LongList missingFromTracker = null;
+        var loadedIterator = actuallyLoadedChunkKeys.iterator();
+        while (loadedIterator.hasNext()) {
+            long key = loadedIterator.nextLong();
+            if (this.chunkStatus.get(key) == unknown) {
+                if (missingFromTracker == null) {
+                    missingFromTracker = new LongArrayList();
+                }
+                missingFromTracker.add(key);
+            }
+        }
+
+        LongList missingFromWorld = null;
+        var trackedIterator = this.chunkStatus.keySet().iterator();
+        while (trackedIterator.hasNext()) {
+            long key = trackedIterator.nextLong();
+            if (!actuallyLoadedChunkKeys.contains(key)) {
+                if (missingFromWorld == null) {
+                    missingFromWorld = new LongArrayList();
+                }
+                missingFromWorld.add(key);
+            }
+        }
+
+        if (missingFromTracker != null) {
+            for (int i = 0; i < missingFromTracker.size(); i++) {
+                long key = missingFromTracker.getLong(i);
+                this.onChunkStatusAdded(PositionUtil.unpackChunkX(key), PositionUtil.unpackChunkZ(key), ChunkStatus.FLAG_ALL);
+            }
+        }
+
+        if (missingFromWorld != null) {
+            for (int i = 0; i < missingFromWorld.size(); i++) {
+                long key = missingFromWorld.getLong(i);
+                this.onChunkStatusRemoved(PositionUtil.unpackChunkX(key), PositionUtil.unpackChunkZ(key), ChunkStatus.FLAG_ALL);
+            }
+        }
+    }
+
     private void updateNeighbors(int x, int z) {
         int r = this.requiredNeighborRadius;
         for (int ox = -r; ox <= r; ox++) {

src/main/java/com/dhj/actinium/mixin/vintage/core/terrain/MixinClientChunkManager.java

@@ -1,5 +1,6 @@
 package com.dhj.actinium.mixin.vintage.core.terrain;
 
+import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
 import net.minecraft.client.multiplayer.ChunkProviderClient;
 import net.minecraft.world.World;
 import net.minecraft.world.chunk.Chunk;
@@ -19,6 +20,10 @@ public abstract class MixinClientChunkManager {
     @Final
     private World world;
 
+    @Shadow
+    @Final
+    private Long2ObjectMap<Chunk> loadedChunks;
+
     @Inject(method = "loadChunk", at = @At("RETURN"))
     private void afterLoadChunkFromPacket(int x, int z, CallbackInfoReturnable<Chunk> cir) {
         ChunkTrackerHolder.get(this.world).onChunkStatusAdded(x, z, ChunkStatus.FLAG_ALL);
@@ -28,5 +33,14 @@ private void afterLoadChunkFromPacket(int x, int z, CallbackInfoReturnable<Chunk
     private void afterUnloadChunk(int x, int z, CallbackInfo ci) {
         ChunkTrackerHolder.get(this.world).onChunkStatusRemoved(x, z, ChunkStatus.FLAG_ALL);
     }
+
+    /**
+     * Repairs any drift between the chunk tracker and the authoritative loaded set once per
+     * client tick; in steady state the diff is empty and no events fire.
+     */
+    @Inject(method = "tick", at = @At("RETURN"))
+    private void reconcileTrackerWithLoadedChunks(CallbackInfoReturnable<Boolean> cir) {
+        ChunkTrackerHolder.get(this.world).reconcile(this.loadedChunks.keySet());
+    }
 }
 

src/test/java/org/embeddedt/embeddium/impl/render/chunk/map/ChunkTrackerReconcileTest.java

@@ -0,0 +1,114 @@
+package org.embeddedt.embeddium.impl.render.chunk.map;
+
+import it.unimi.dsi.fastutil.longs.LongOpenHashSet;
+import it.unimi.dsi.fastutil.longs.LongSet;
+import org.embeddedt.embeddium.impl.util.PositionUtil;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class ChunkTrackerReconcileTest {
+    @Test
+    void worldChunksUnknownToTrackerBecomeReadyOnceNeighborsSatisfyRadius() {
+        ChunkTracker tracker = new ChunkTracker(1);
+        ChunkTracker.Subscription subscription = tracker.subscribe();
+
+        tracker.reconcile(loadedArea(10, 20));
+
+        assertEquals(9, tracker.getReadyChunks().size());
+        assertEquals(readyEvents("load:", 10, 20), sortedDrain(subscription));
+    }
+
+    @Test
+    void trackerChunksMissingFromWorldAreRemoved() {
+        ChunkTracker tracker = new ChunkTracker(1);
+        ChunkTracker.Subscription subscription = tracker.subscribe();
+
+        tracker.reconcile(loadedArea(10, 20));
+        drain(subscription);
+        assertEquals(9, tracker.getReadyChunks().size());
+
+        tracker.reconcile(new LongOpenHashSet());
+
+        assertTrue(tracker.getReadyChunks().isEmpty());
+        assertEquals(readyEvents("unload:", 10, 20), sortedDrain(subscription));
+    }
+
+    @Test
+    void reconcileIsIdempotent() {
+        ChunkTracker tracker = new ChunkTracker(1);
+        ChunkTracker.Subscription subscription = tracker.subscribe();
+
+        LongSet loaded = loadedArea(10, 20);
+        tracker.reconcile(loaded);
+        assertEquals(9, drain(subscription).size());
+
+        tracker.reconcile(loaded);
+        tracker.reconcile(loaded);
+
+        assertEquals(List.of(), drain(subscription));
+        assertEquals(9, tracker.getReadyChunks().size());
+    }
+
+    @Test
+    void isolatedChunkDoesNotBecomeReadyWithoutNeighbors() {
+        ChunkTracker tracker = new ChunkTracker(1);
+        ChunkTracker.Subscription subscription = tracker.subscribe();
+
+        LongSet isolated = new LongOpenHashSet();
+        isolated.add(PositionUtil.packChunk(10, 20));
+        tracker.reconcile(isolated);
+
+        assertTrue(tracker.getReadyChunks().isEmpty());
+        assertEquals(List.of(), drain(subscription));
+
+        // The isolated chunk was still registered: once its neighbors appear, readiness resolves normally.
+        tracker.reconcile(loadedArea(10, 20));
+        assertEquals(9, tracker.getReadyChunks().size());
+        assertEquals(9, drain(subscription).size());
+    }
+
+    /**
+     * A 5x5 square of loaded chunks around the center; with neighbor radius 1 exactly the
+     * inner 3x3 chunks satisfy the readiness gate.
+     */
+    private static LongSet loadedArea(int centerX, int centerZ) {
+        LongSet keys = new LongOpenHashSet();
+        for (int x = centerX - 2; x <= centerX + 2; x++) {
+            for (int z = centerZ - 2; z <= centerZ + 2; z++) {
+                keys.add(PositionUtil.packChunk(x, z));
+            }
+        }
+        return keys;
+    }
+
+    private static List<String> readyEvents(String prefix, int centerX, int centerZ) {
+        List<String> events = new ArrayList<>();
+        for (int x = centerX - 1; x <= centerX + 1; x++) {
+            for (int z = centerZ - 1; z <= centerZ + 1; z++) {
+                events.add(prefix + x + "," + z);
+            }
+        }
+        events.sort(null);
+        return events;
+    }
+
+    private static List<String> sortedDrain(ChunkTracker.Subscription subscription) {
+        List<String> events = drain(subscription);
+        events.sort(null);
+        return events;
+    }
+
+    private static List<String> drain(ChunkTracker.Subscription subscription) {
+        List<String> events = new ArrayList<>();
+        subscription.forEachEvent(
+            (x, z) -> events.add("load:" + x + "," + z),
+            (x, z) -> events.add("unload:" + x + "," + z)
+        );
+        return events;
+    }
+}