Start Moonrise update

This is based on Moonrise's 1.21.2 branch, but this on
1.21.1 so some diffs cannot be applied (and this doesn't
compile).

See moonrise_update_1_21_2.txt for progress

7 files changed, 21344 insertions, 323 deletions

diff --git a/moonrise_update_1_21_2.txt b/moonrise_update_1_21_2.txt
new file mode 100644
index 0000000000..87e5b1546a
--- /dev/null
+++ b/moonrise_update_1_21_2.txt
@@ -0,0 +1,43 @@
+reference comparison:
+https://github.com/Tuinity/Moonrise/compare/6a2c6d27df11d417c1fefa749109d8e87599e8c2...03784b8c69c299db4af4f9984565e5752617d9dc
+need to compare the diffs
+
+
+add notes to moonrise patch:
+ - implemented fast palette patch
+ - implemented better bitstorage magic patch
+ - implemented blockstate property patch (replaced old paper one)
+ - implemented fluid patch
+
+
+todo:
+- double check that the misc changes commit on dev/1.21.2 moonrise is applied
+- implement platformhooks
+- move common diff from moonrise patch to mcutil patch
+- delete old block state table patch
+- in StateHolder, implement getNullableValue from blockstate_propertyaccess
+- ChunkEntitySlices getChunkEntities(), callEntitiesLoadEvent(), callEntitiesUnloadEvent()
+- in ChunkEntitySlices, implement modifySavedEntities() by copying from old
+- in ChunkEntitySlices, implement unload() Entity.setRemoved()
+- change PersistentEntitySectionManager addEntity chunk system call to have event=true 
+- implement PlayerChunkUnloadEvent in PlatformHooks#onChunkUnWatch
+- make sure chunk pos is passed in PlatformHooks#postLoadProtoChunk
+- implement chunk_system.ChunkMapMixin diff from reference 
+- implement chunk_system.ChunkStorageMixin diff from reference
+- implement chunk_system.DistanceManagerMixin diff from reference
+- implement chunk_system.GenerationChunkHolderMixin diff from reference
+- implement chunk_system.LevelChunkMixin diff from reference
+- implement chunk_system.LevelMixin diff from reference
+- implement chunk_system.SectionStorageMixin diff from reference
+- implement chunk_system.SerializableChunkDataMixin diff from reference
+- implement chunk_system.ServerLevelMixin diff from reference
+- implement chunk_tick_iteration
+- implement collisions.ServerExplosionMixin diff from reference
+- implement modifyEntityTrackingRange with org.spigotmc.TrackingRange.getEntityTrackingRange
+- implement random_ticking.BiomeMixin diff from reference
+- implement starlight.LevelLightEngineMixin diff from reference
+- implement starlight.ThreadedLevelLightEngineMixin diff from reference
+- implement starlight.ChunkSerializerMixin diff from reference
+- implement starlight.SerializableChunkData$SectionData diff from reference
+- implement starlight.SerializableChunkDataMixin diff from reference
+
diff --git a/patches/server/0489-Improve-ServerGUI.patch b/patches/server/0489-Improve-ServerGUI.patch
index 8dde1d1a9b..48a151cd82 100644
--- a/patches/server/0489-Improve-ServerGUI.patch
+++ b/patches/server/0489-Improve-ServerGUI.patch
@@ -102,329 +102,330 @@ new file mode 100644
 index 0000000000000000000000000000000000000000..8b924977b7886df9ab8790b1e4ff9b1c04a2af45
 GIT binary patch
 literal 16900
-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
-LFIp>X81%mY^Bg|U
+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
+XXyugpZ1#qMfq}u()z4*}Q$iB}^Bg|U
 
 literal 0
 HcmV?d00001
diff --git a/patches/server/1069-fixup-ConcurrentUtil.patch b/patches/server/1069-fixup-ConcurrentUtil.patch
new file mode 100644
index 0000000000..60d57a1656
--- /dev/null
+++ b/patches/server/1069-fixup-ConcurrentUtil.patch
@@ -0,0 +1,6177 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Spottedleaf <[email protected]>
+Date: Mon, 21 Oct 2024 11:47:34 -0700
+Subject: [PATCH] fixup! ConcurrentUtil
+
+
+diff --git a/src/main/java/ca/spottedleaf/concurrentutil/collection/SRSWLinkedQueue.java b/src/main/java/ca/spottedleaf/concurrentutil/collection/SRSWLinkedQueue.java
+deleted file mode 100644
+index 094eff418b4e3bffce020d650931b4d9e58fa9ed..0000000000000000000000000000000000000000
+--- a/src/main/java/ca/spottedleaf/concurrentutil/collection/SRSWLinkedQueue.java
++++ /dev/null
+@@ -1,149 +0,0 @@
+-package ca.spottedleaf.concurrentutil.collection;
+-
+-import ca.spottedleaf.concurrentutil.util.ConcurrentUtil;
+-import ca.spottedleaf.concurrentutil.util.Validate;
+-
+-import java.lang.invoke.VarHandle;
+-import java.util.ConcurrentModificationException;
+-
+-/**
+- * Single reader thread single writer thread queue. The reader side of the queue is ordered by acquire semantics,
+- * and the writer side of the queue is ordered by release semantics.
+- */
+-// TODO test
+-public class SRSWLinkedQueue<E> {
+-
+-    // always non-null
+-    protected LinkedNode<E> head;
+-
+-    // always non-null
+-    protected LinkedNode<E> tail;
+-
+-    /* IMPL NOTE: Leave hashCode and equals to their defaults */
+-
+-    public SRSWLinkedQueue() {
+-        final LinkedNode<E> dummy = new LinkedNode<>(null, null);
+-        this.head = this.tail = dummy;
+-    }
+-
+-    /**
+-     * Must be the reader thread.
+-     *
+-     * <p>
+-     * Returns, without removing, the first element of this queue.
+-     * </p>
+-     * @return Returns, without removing, the first element of this queue.
+-     */
+-    public E peekFirst() {
+-        LinkedNode<E> head = this.head;
+-        E ret = head.getElementPlain();
+-        if (ret == null) {
+-            head = head.getNextAcquire();
+-            if (head == null) {
+-                // empty
+-                return null;
+-            }
+-            // update head reference for next poll() call
+-            this.head = head;
+-            // guaranteed to be non-null
+-            ret = head.getElementPlain();
+-            if (ret == null) {
+-                throw new ConcurrentModificationException("Multiple reader threads");
+-            }
+-        }
+-
+-        return ret;
+-    }
+-
+-    /**
+-     * Must be the reader thread.
+-     *
+-     * <p>
+-     * Returns and removes the first element of this queue.
+-     * </p>
+-     * @return Returns and removes the first element of this queue.
+-     */
+-    public E poll() {
+-        LinkedNode<E> head = this.head;
+-        E ret = head.getElementPlain();
+-        if (ret == null) {
+-            head = head.getNextAcquire();
+-            if (head == null) {
+-                // empty
+-                return null;
+-            }
+-            // guaranteed to be non-null
+-            ret = head.getElementPlain();
+-            if (ret == null) {
+-                throw new ConcurrentModificationException("Multiple reader threads");
+-            }
+-        }
+-
+-        head.setElementPlain(null);
+-        LinkedNode<E> next = head.getNextAcquire();
+-        this.head = next == null ? head : next;
+-
+-        return ret;
+-    }
+-
+-    /**
+-     * Must be the writer thread.
+-     *
+-     * <p>
+-     * Adds the element to the end of the queue.
+-     * </p>
+-     *
+-     * @throws NullPointerException If the provided element is null
+-     */
+-    public void addLast(final E element) {
+-        Validate.notNull(element, "Provided element cannot be null");
+-        final LinkedNode<E> append = new LinkedNode<>(element, null);
+-
+-        this.tail.setNextRelease(append);
+-        this.tail = append;
+-    }
+-
+-    protected static final class LinkedNode<E> {
+-
+-        protected volatile Object element;
+-        protected volatile LinkedNode<E> next;
+-
+-        protected static final VarHandle ELEMENT_HANDLE = ConcurrentUtil.getVarHandle(LinkedNode.class, "element", Object.class);
+-        protected static final VarHandle NEXT_HANDLE = ConcurrentUtil.getVarHandle(LinkedNode.class, "next", LinkedNode.class);
+-
+-        protected LinkedNode(final Object element, final LinkedNode<E> next) {
+-            ELEMENT_HANDLE.set(this, element);
+-            NEXT_HANDLE.set(this, next);
+-        }
+-
+-        /* element */
+-
+-        @SuppressWarnings("unchecked")
+-        protected final E getElementPlain() {
+-            return (E)ELEMENT_HANDLE.get(this);
+-        }
+-
+-        protected final void setElementPlain(final E update) {
+-            ELEMENT_HANDLE.set(this, (Object)update);
+-        }
+-        /* next */
+-
+-        @SuppressWarnings("unchecked")
+-        protected final LinkedNode<E> getNextPlain() {
+-            return (LinkedNode<E>)NEXT_HANDLE.get(this);
+-        }
+-
+-        @SuppressWarnings("unchecked")
+-        protected final LinkedNode<E> getNextAcquire() {
+-            return (LinkedNode<E>)NEXT_HANDLE.getAcquire(this);
+-        }
+-
+-        protected final void setNextPlain(final LinkedNode<E> next) {
+-            NEXT_HANDLE.set(this, next);
+-        }
+-
+-        protected final void setNextRelease(final LinkedNode<E> next) {
+-            NEXT_HANDLE.setRelease(this, next);
+-        }
+-    }
+-}
+diff --git a/src/main/java/ca/spottedleaf/concurrentutil/completable/CallbackCompletable.java b/src/main/java/ca/spottedleaf/concurrentutil/completable/CallbackCompletable.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..6bad6f8ecc0944d2f406924c7de7e227ff1e70fa
+--- /dev/null
++++ b/src/main/java/ca/spottedleaf/concurrentutil/completable/CallbackCompletable.java
+@@ -0,0 +1,110 @@
++package ca.spottedleaf.concurrentutil.completable;
++
++import ca.spottedleaf.concurrentutil.collection.MultiThreadedQueue;
++import ca.spottedleaf.concurrentutil.executor.Cancellable;
++import ca.spottedleaf.concurrentutil.util.ConcurrentUtil;
++import org.slf4j.Logger;
++import org.slf4j.LoggerFactory;
++import java.util.function.BiConsumer;
++
++public final class CallbackCompletable<T> {
++
++    private static final Logger LOGGER = LoggerFactory.getLogger(CallbackCompletable.class);
++
++    private final MultiThreadedQueue<BiConsumer<T, Throwable>> waiters = new MultiThreadedQueue<>();
++    private T result;
++    private Throwable throwable;
++    private volatile boolean completed;
++
++    public boolean isCompleted() {
++        return this.completed;
++    }
++
++    /**
++     * Note: Can only use after calling {@link #addAsynchronousWaiter(BiConsumer)}, as this function performs zero
++     * synchronisation
++     */
++    public T getResult() {
++        return this.result;
++    }
++
++    /**
++     * Note: Can only use after calling {@link #addAsynchronousWaiter(BiConsumer)}, as this function performs zero
++     * synchronisation
++     */
++    public Throwable getThrowable() {
++        return this.throwable;
++    }
++
++    /**
++     * Adds a waiter that should only be completed asynchronously by the complete() calls. If complete()
++     * has already been called, returns {@code null} and does not invoke the specified consumer.
++     * @param consumer Consumer to be executed on completion
++     * @throws NullPointerException If consumer is null
++     * @return A cancellable which will control the execution of the specified consumer
++     */
++    public Cancellable addAsynchronousWaiter(final BiConsumer<T, Throwable> consumer) {
++        if (this.waiters.add(consumer)) {
++            return new CancellableImpl(consumer);
++        }
++        return null;
++    }
++
++    private void completeAllWaiters(final T result, final Throwable throwable) {
++        this.completed = true;
++        BiConsumer<T, Throwable> waiter;
++        while ((waiter = this.waiters.pollOrBlockAdds()) != null) {
++            this.completeWaiter(waiter, result, throwable);
++        }
++    }
++
++    private void completeWaiter(final BiConsumer<T, Throwable> consumer, final T result, final Throwable throwable) {
++        try {
++            consumer.accept(result, throwable);
++        } catch (final Throwable throwable2) {
++            LOGGER.error("Failed to complete callback " + ConcurrentUtil.genericToString(consumer), throwable2);
++        }
++    }
++
++    /**
++     * Adds a waiter that will be completed asynchronously by the complete() calls. If complete()
++     * has already been called, then invokes the consumer synchronously with the completed result.
++     * @param consumer Consumer to be executed on completion
++     * @throws NullPointerException If consumer is null
++     * @return A cancellable which will control the execution of the specified consumer
++     */
++    public Cancellable addWaiter(final BiConsumer<T, Throwable> consumer) {
++        if (this.waiters.add(consumer)) {
++            return new CancellableImpl(consumer);
++        }
++        this.completeWaiter(consumer, this.result, this.throwable);
++        return new CancellableImpl(consumer);
++    }
++
++    public void complete(final T result) {
++        this.result = result;
++        this.completeAllWaiters(result, null);
++    }
++
++    public void completeWithThrowable(final Throwable throwable) {
++        if (throwable == null) {
++            throw new NullPointerException("Throwable cannot be null");
++        }
++        this.throwable = throwable;
++        this.completeAllWaiters(null, throwable);
++    }
++
++    private final class CancellableImpl implements Cancellable {
++
++        private final BiConsumer<T, Throwable> waiter;
++
++        private CancellableImpl(final BiConsumer<T, Throwable> waiter) {
++            this.waiter = waiter;
++        }
++
++        @Override
++        public boolean cancel() {
++            return CallbackCompletable.this.waiters.remove(this.waiter);
++        }
++    }
++}
+\ No newline at end of file
+diff --git a/src/main/java/ca/spottedleaf/concurrentutil/completable/Completable.java b/src/main/java/ca/spottedleaf/concurrentutil/completable/Completable.java
+index 46d1bd01542ebeeffc0006a5c585a50dbbbff907..365616439fa079017d648ed7f6ddf6950a691adf 100644
+--- a/src/main/java/ca/spottedleaf/concurrentutil/completable/Completable.java
++++ b/src/main/java/ca/spottedleaf/concurrentutil/completable/Completable.java
+@@ -1,112 +1,737 @@
+ package ca.spottedleaf.concurrentutil.completable;
+ 
+-import ca.spottedleaf.concurrentutil.collection.MultiThreadedQueue;
+-import ca.spottedleaf.concurrentutil.executor.Cancellable;
+ import ca.spottedleaf.concurrentutil.util.ConcurrentUtil;
++import ca.spottedleaf.concurrentutil.util.Validate;
+ import org.slf4j.Logger;
+ import org.slf4j.LoggerFactory;
++import java.lang.invoke.VarHandle;
++import java.util.concurrent.CompletableFuture;
++import java.util.concurrent.CompletionException;
++import java.util.concurrent.CompletionStage;
++import java.util.concurrent.Executor;
++import java.util.concurrent.ForkJoinPool;
++import java.util.concurrent.locks.LockSupport;
+ import java.util.function.BiConsumer;
++import java.util.function.BiFunction;
++import java.util.function.Consumer;
++import java.util.function.Function;
++import java.util.function.Supplier;
+ 
+ public final class Completable<T> {
+ 
+     private static final Logger LOGGER = LoggerFactory.getLogger(Completable.class);
++    private static final Function<? super Throwable, ? extends Throwable> DEFAULT_EXCEPTION_HANDLER = (final Throwable thr) -> {
++        LOGGER.error("Unhandled exception during Completable operation", thr);
++        return thr;
++    };
+ 
+-    private final MultiThreadedQueue<BiConsumer<T, Throwable>> waiters = new MultiThreadedQueue<>();
+-    private T result;
+-    private Throwable throwable;
+-    private volatile boolean completed;
++    public static Executor getDefaultExecutor() {
++        return ForkJoinPool.commonPool();
++    }
++
++    private static final Transform<?, ?> COMPLETED_STACK = new Transform<>(null, null, null, null) {
++        @Override
++        public void run() {}
++    };
++    private volatile Transform<?, T> completeStack;
++    private static final VarHandle COMPLETE_STACK_HANDLE = ConcurrentUtil.getVarHandle(Completable.class, "completeStack", Transform.class);
++
++    private static final Object NULL_MASK = new Object();
++    private volatile Object result;
++    private static final VarHandle RESULT_HANDLE = ConcurrentUtil.getVarHandle(Completable.class, "result", Object.class);
+ 
+-    public boolean isCompleted() {
+-        return this.completed;
++    private Object getResultPlain() {
++        return (Object)RESULT_HANDLE.get(this);
+     }
+ 
+-    /**
+-     * Note: Can only use after calling {@link #addAsynchronousWaiter(BiConsumer)}, as this function performs zero
+-     * synchronisation
+-     */
+-    public T getResult() {
+-        return this.result;
++    private Object getResultVolatile() {
++        return (Object)RESULT_HANDLE.getVolatile(this);
+     }
+ 
+-    /**
+-     * Note: Can only use after calling {@link #addAsynchronousWaiter(BiConsumer)}, as this function performs zero
+-     * synchronisation
+-     */
+-    public Throwable getThrowable() {
+-        return this.throwable;
++    private void pushStackOrRun(final Transform<?, T> push) {
++        int failures = 0;
++        for (Transform<?, T> curr = (Transform<?, T>)COMPLETE_STACK_HANDLE.getVolatile(this);;) {
++            if (curr == COMPLETED_STACK) {
++                push.execute();
++                return;
++            }
++
++            push.next = curr;
++
++            for (int i = 0; i < failures; ++i) {
++                ConcurrentUtil.backoff();
++            }
++
++            if (curr == (curr = (Transform<?, T>)COMPLETE_STACK_HANDLE.compareAndExchange(this, curr, push))) {
++                return;
++            }
++            push.next = null;
++            ++failures;
++        }
+     }
+ 
+-    /**
+-     * Adds a waiter that should only be completed asynchronously by the complete() calls. If complete()
+-     * has already been called, returns {@code null} and does not invoke the specified consumer.
+-     * @param consumer Consumer to be executed on completion
+-     * @throws NullPointerException If consumer is null
+-     * @return A cancellable which will control the execution of the specified consumer
+-     */
+-    public Cancellable addAsynchronousWaiter(final BiConsumer<T, Throwable> consumer) {
+-        if (this.waiters.add(consumer)) {
+-            return new CancellableImpl(consumer);
++    private void propagateStack() {
++        Transform<?, T> topStack = (Transform<?, T>)COMPLETE_STACK_HANDLE.getAndSet(this, COMPLETED_STACK);
++        while (topStack != null) {
++            topStack.execute();
++            topStack = topStack.next;
+         }
+-        return null;
+     }
+ 
+-    private void completeAllWaiters(final T result, final Throwable throwable) {
+-        this.completed = true;
+-        BiConsumer<T, Throwable> waiter;
+-        while ((waiter = this.waiters.pollOrBlockAdds()) != null) {
+-            this.completeWaiter(waiter, result, throwable);
++    private static Object maskNull(final Object res) {
++        return res == null ? NULL_MASK : res;
++    }
++
++    private static Object unmaskNull(final Object res) {
++        return res == NULL_MASK ? null : res;
++    }
++
++    private static Executor checkExecutor(final Executor executor) {
++        return Validate.notNull(executor, "Executor may not be null");
++    }
++
++    public Completable() {}
++
++    private Completable(final Object complete) {
++        COMPLETE_STACK_HANDLE.set(this, COMPLETED_STACK);
++        RESULT_HANDLE.setRelease(this, complete);
++    }
++
++    public static <T> Completable<T> completed(final T value) {
++        return new Completable<>(maskNull(value));
++    }
++
++    public static <T> Completable<T> failed(final Throwable ex) {
++        Validate.notNull(ex, "Exception may not be null");
++
++        return new Completable<>(new ExceptionResult(ex));
++    }
++
++    public static <T> Completable<T> supplied(final Supplier<T> supplier) {
++        return supplied(supplier, DEFAULT_EXCEPTION_HANDLER);
++    }
++
++    public static <T> Completable<T> supplied(final Supplier<T> supplier, final Function<? super Throwable, ? extends Throwable> exceptionHandler) {
++        try {
++            return completed(supplier.get());
++        } catch (final Throwable throwable) {
++            Throwable complete;
++            try {
++                complete = exceptionHandler.apply(throwable);
++            } catch (final Throwable thr2) {
++                throwable.addSuppressed(thr2);
++                complete = throwable;
++            }
++            return failed(complete);
+         }
+     }
+ 
+-    private void completeWaiter(final BiConsumer<T, Throwable> consumer, final T result, final Throwable throwable) {
++    public static <T> Completable<T> suppliedAsync(final Supplier<T> supplier, final Executor executor) {
++        return suppliedAsync(supplier, executor, DEFAULT_EXCEPTION_HANDLER);
++    }
++
++    public static <T> Completable<T> suppliedAsync(final Supplier<T> supplier, final Executor executor, final Function<? super Throwable, ? extends Throwable> exceptionHandler) {
++        final Completable<T> ret = new Completable<>();
++
++        class AsyncSuppliedCompletable implements Runnable, CompletableFuture.AsynchronousCompletionTask {
++            @Override
++            public void run() {
++                try {
++                    ret.complete(supplier.get());
++                } catch (final Throwable throwable) {
++                    Throwable complete;
++                    try {
++                        complete = exceptionHandler.apply(throwable);
++                    } catch (final Throwable thr2) {
++                        throwable.addSuppressed(thr2);
++                        complete = throwable;
++                    }
++                    ret.completeExceptionally(complete);
++                }
++            }
++        }
++
+         try {
+-            consumer.accept(result, throwable);
+-        } catch (final ThreadDeath death) {
+-            throw death;
+-        } catch (final Throwable throwable2) {
+-            LOGGER.error("Failed to complete callback " + ConcurrentUtil.genericToString(consumer), throwable2);
++            executor.execute(new AsyncSuppliedCompletable());
++        } catch (final Throwable throwable) {
++            Throwable complete;
++            try {
++                complete = exceptionHandler.apply(throwable);
++            } catch (final Throwable thr2) {
++                throwable.addSuppressed(thr2);
++                complete = throwable;
++            }
++            ret.completeExceptionally(complete);
++        }
++
++        return ret;
++    }
++
++    private boolean completeRaw(final Object value) {
++        if ((Object)RESULT_HANDLE.getVolatile(this) != null || !(boolean)RESULT_HANDLE.compareAndSet(this, (Object)null, value)) {
++            return false;
++        }
++
++        this.propagateStack();
++        return true;
++    }
++
++    public boolean complete(final T result) {
++        return this.completeRaw(maskNull(result));
++    }
++
++    public boolean completeExceptionally(final Throwable exception) {
++        Validate.notNull(exception, "Exception may not be null");
++
++        return this.completeRaw(new ExceptionResult(exception));
++    }
++
++    public boolean isDone() {
++        return this.getResultVolatile() != null;
++    }
++
++    public boolean isNormallyComplete() {
++        return this.getResultVolatile() != null && !(this.getResultVolatile() instanceof ExceptionResult);
++    }
++
++    public boolean isExceptionallyComplete() {
++        return this.getResultVolatile() instanceof ExceptionResult;
++    }
++
++    public Throwable getException() {
++        final Object res = this.getResultVolatile();
++        if (res == null) {
++            return null;
++        }
++
++        if (!(res instanceof ExceptionResult exRes)) {
++            throw new IllegalStateException("Not completed exceptionally");
++        }
++
++        return exRes.ex;
++    }
++
++    public T getNow(final T dfl) throws CompletionException {
++        final Object res = this.getResultVolatile();
++        if (res == null) {
++            return dfl;
++        }
++
++        if (res instanceof ExceptionResult exRes) {
++            throw new CompletionException(exRes.ex);
++        }
++
++        return (T)unmaskNull(res);
++    }
++
++    public T join() throws CompletionException {
++        if (this.isDone()) {
++            return this.getNow(null);
++        }
++
++        final UnparkTransform<T> unparkTransform = new UnparkTransform<>(this, Thread.currentThread());
++
++        this.pushStackOrRun(unparkTransform);
++
++        boolean interuptted = false;
++        while (!unparkTransform.isReleasable()) {
++            try {
++                ForkJoinPool.managedBlock(unparkTransform);
++            } catch (final InterruptedException ex) {
++                interuptted = true;
++            }
++        }
++
++        if (interuptted) {
++            Thread.currentThread().interrupt();
++        }
++
++        return this.getNow(null);
++    }
++
++    public CompletableFuture<T> toFuture() {
++        final Object rawResult = this.getResultVolatile();
++        if (rawResult != null) {
++            if (rawResult instanceof ExceptionResult exRes) {
++                return CompletableFuture.failedFuture(exRes.ex);
++            } else {
++                return CompletableFuture.completedFuture((T)unmaskNull(rawResult));
++            }
++        }
++
++        final CompletableFuture<T> ret = new CompletableFuture<>();
++
++        class ToFuture implements BiConsumer<T, Throwable> {
++
++            @Override
++            public void accept(final T res, final Throwable ex) {
++                if (ex != null) {
++                    ret.completeExceptionally(ex);
++                } else {
++                    ret.complete(res);
++                }
++            }
++        }
++
++        this.whenComplete(new ToFuture());
++
++        return ret;
++    }
++
++    public static <T> Completable<T> fromFuture(final CompletionStage<T> stage) {
++        final Completable<T> ret = new Completable<>();
++
++        class FromFuture implements BiConsumer<T, Throwable> {
++            @Override
++            public void accept(final T res, final Throwable ex) {
++                if (ex != null) {
++                    ret.completeExceptionally(ex);
++                } else {
++                    ret.complete(res);
++                }
++            }
++        }
++
++        stage.whenComplete(new FromFuture());
++
++        return ret;
++    }
++
++
++    public <U> Completable<U> thenApply(final Function<? super T, ? extends U> function) {
++        return this.thenApply(function, DEFAULT_EXCEPTION_HANDLER);
++    }
++
++    public <U> Completable<U> thenApply(final Function<? super T, ? extends U> function, final Function<? super Throwable, ? extends Throwable> exceptionHandler) {
++        Validate.notNull(function, "Function may not be null");
++        Validate.notNull(exceptionHandler, "Exception handler may not be null");
++
++        final Completable<U> ret = new Completable<>();
++        this.pushStackOrRun(new ApplyTransform<>(null, this, ret, exceptionHandler, function));
++        return ret;
++    }
++
++    public <U> Completable<U> thenApplyAsync(final Function<? super T, ? extends U> function) {
++        return this.thenApplyAsync(function, getDefaultExecutor(), DEFAULT_EXCEPTION_HANDLER);
++    }
++
++    public <U> Completable<U> thenApplyAsync(final Function<? super T, ? extends U> function, final Executor executor) {
++        return this.thenApplyAsync(function, executor, DEFAULT_EXCEPTION_HANDLER);
++    }
++
++    public <U> Completable<U> thenApplyAsync(final Function<? super T, ? extends U> function, final Executor executor, final Function<? super Throwable, ? extends Throwable> exceptionHandler) {
++        Validate.notNull(function, "Function may not be null");
++        Validate.notNull(exceptionHandler, "Exception handler may not be null");
++
++        final Completable<U> ret = new Completable<>();
++        this.pushStackOrRun(new ApplyTransform<>(checkExecutor(executor), this, ret, exceptionHandler, function));
++        return ret;
++    }
++
++
++    public Completable<Void> thenAccept(final Consumer<? super T> consumer) {
++        return this.thenAccept(consumer, DEFAULT_EXCEPTION_HANDLER);
++    }
++
++    public Completable<Void> thenAccept(final Consumer<? super T> consumer, final Function<? super Throwable, ? extends Throwable> exceptionHandler) {
++        Validate.notNull(consumer, "Consumer may not be null");
++        Validate.notNull(exceptionHandler, "Exception handler may not be null");
++
++        final Completable<Void> ret = new Completable<>();
++        this.pushStackOrRun(new AcceptTransform<>(null, this, ret, exceptionHandler, consumer));
++        return ret;
++    }
++
++    public Completable<Void> thenAcceptAsync(final Consumer<? super T> consumer) {
++        return this.thenAcceptAsync(consumer, getDefaultExecutor(), DEFAULT_EXCEPTION_HANDLER);
++    }
++
++    public Completable<Void> thenAcceptAsync(final Consumer<? super T> consumer, final Executor executor) {
++        return this.thenAcceptAsync(consumer, executor, DEFAULT_EXCEPTION_HANDLER);
++    }
++
++    public Completable<Void> thenAcceptAsync(final Consumer<? super T> consumer, final Executor executor, final Function<? super Throwable, ? extends Throwable> exceptionHandler) {
++        Validate.notNull(consumer, "Consumer may not be null");
++        Validate.notNull(exceptionHandler, "Exception handler may not be null");
++
++        final Completable<Void> ret = new Completable<>();
++        this.pushStackOrRun(new AcceptTransform<>(checkExecutor(executor), this, ret, exceptionHandler, consumer));
++        return ret;
++    }
++
++
++    public Completable<Void> thenRun(final Runnable run) {
++        return this.thenRun(run, DEFAULT_EXCEPTION_HANDLER);
++    }
++
++    public Completable<Void> thenRun(final Runnable run, final Function<? super Throwable, ? extends Throwable> exceptionHandler) {
++        Validate.notNull(run, "Run may not be null");
++        Validate.notNull(exceptionHandler, "Exception handler may not be null");
++
++        final Completable<Void> ret = new Completable<>();
++        this.pushStackOrRun(new RunTransform<>(null, this, ret, exceptionHandler, run));
++        return ret;
++    }
++
++    public Completable<Void> thenRunAsync(final Runnable run) {
++        return this.thenRunAsync(run, getDefaultExecutor(), DEFAULT_EXCEPTION_HANDLER);
++    }
++
++    public Completable<Void> thenRunAsync(final Runnable run, final Executor executor) {
++        return this.thenRunAsync(run, executor, DEFAULT_EXCEPTION_HANDLER);
++    }
++
++    public Completable<Void> thenRunAsync(final Runnable run, final Executor executor, final Function<? super Throwable, ? extends Throwable> exceptionHandler) {
++        Validate.notNull(run, "Run may not be null");
++        Validate.notNull(exceptionHandler, "Exception handler may not be null");
++
++        final Completable<Void> ret = new Completable<>();
++        this.pushStackOrRun(new RunTransform<>(checkExecutor(executor), this, ret, exceptionHandler, run));
++        return ret;
++    }
++
++
++    public <U> Completable<U> handle(final BiFunction<? super T, ? super Throwable, ? extends U> function) {
++        return this.handle(function, DEFAULT_EXCEPTION_HANDLER);
++    }
++
++    public <U> Completable<U> handle(final BiFunction<? super T, ? super Throwable, ? extends U> function,
++                                     final Function<? super Throwable, ? extends Throwable> exceptionHandler) {
++        Validate.notNull(function, "Function may not be null");
++        Validate.notNull(exceptionHandler, "Exception handler may not be null");
++
++        final Completable<U> ret = new Completable<>();
++        this.pushStackOrRun(new HandleTransform<>(null, this, ret, exceptionHandler, function));
++        return ret;
++    }
++
++    public <U> Completable<U> handleAsync(final BiFunction<? super T, ? super Throwable, ? extends U> function) {
++        return this.handleAsync(function, getDefaultExecutor(), DEFAULT_EXCEPTION_HANDLER);
++    }
++
++    public <U> Completable<U> handleAsync(final BiFunction<? super T, ? super Throwable, ? extends U> function,
++                                          final Executor executor) {
++        return this.handleAsync(function, executor, DEFAULT_EXCEPTION_HANDLER);
++    }
++
++    public <U> Completable<U> handleAsync(final BiFunction<? super T, ? super Throwable, ? extends U> function,
++                                          final Executor executor,
++                                          final Function<? super Throwable, ? extends Throwable> exceptionHandler) {
++        Validate.notNull(function, "Function may not be null");
++        Validate.notNull(exceptionHandler, "Exception handler may not be null");
++
++        final Completable<U> ret = new Completable<>();
++        this.pushStackOrRun(new HandleTransform<>(checkExecutor(executor), this, ret, exceptionHandler, function));
++        return ret;
++    }
++
++
++    public Completable<T> whenComplete(final BiConsumer<? super T, ? super Throwable> consumer) {
++        return this.whenComplete(consumer, DEFAULT_EXCEPTION_HANDLER);
++    }
++
++    public Completable<T> whenComplete(final BiConsumer<? super T, ? super Throwable> consumer, final Function<? super Throwable, ? extends Throwable> exceptionHandler) {
++        Validate.notNull(consumer, "Consumer may not be null");
++        Validate.notNull(exceptionHandler, "Exception handler may not be null");
++
++        final Completable<T> ret = new Completable<>();
++        this.pushStackOrRun(new WhenTransform<>(null, this, ret, exceptionHandler, consumer));
++        return ret;
++    }
++
++    public Completable<T> whenCompleteAsync(final BiConsumer<? super T, ? super Throwable> consumer) {
++        return this.whenCompleteAsync(consumer, getDefaultExecutor(), DEFAULT_EXCEPTION_HANDLER);
++    }
++
++    public Completable<T> whenCompleteAsync(final BiConsumer<? super T, ? super Throwable> consumer, final Executor executor) {
++        return this.whenCompleteAsync(consumer, executor, DEFAULT_EXCEPTION_HANDLER);
++    }
++
++    public Completable<T> whenCompleteAsync(final BiConsumer<? super T, ? super Throwable> consumer, final Executor executor,
++                                            final Function<? super Throwable, ? extends Throwable> exceptionHandler) {
++        Validate.notNull(consumer, "Consumer may not be null");
++        Validate.notNull(exceptionHandler, "Exception handler may not be null");
++
++        final Completable<T> ret = new Completable<>();
++        this.pushStackOrRun(new WhenTransform<>(checkExecutor(executor), this, ret, exceptionHandler, consumer));
++        return ret;
++    }
++
++
++    public Completable<T> exceptionally(final Function<Throwable, ? extends T> function) {
++        return this.exceptionally(function, DEFAULT_EXCEPTION_HANDLER);
++    }
++
++    public Completable<T> exceptionally(final Function<Throwable, ? extends T> function, final Function<? super Throwable, ? extends Throwable> exceptionHandler) {
++        Validate.notNull(function, "Function may not be null");
++        Validate.notNull(exceptionHandler, "Exception handler may not be null");
++
++        final Completable<T> ret = new Completable<>();
++        this.pushStackOrRun(new ExceptionallyTransform<>(null, this, ret, exceptionHandler, function));
++        return ret;
++    }
++
++    public Completable<T> exceptionallyAsync(final Function<Throwable, ? extends T> function) {
++        return this.exceptionallyAsync(function, getDefaultExecutor(), DEFAULT_EXCEPTION_HANDLER);
++    }
++
++    public Completable<T> exceptionallyAsync(final Function<Throwable, ? extends T> function, final Executor executor) {
++        return this.exceptionallyAsync(function, executor, DEFAULT_EXCEPTION_HANDLER);
++    }
++
++    public Completable<T> exceptionallyAsync(final Function<Throwable, ? extends T> function, final Executor executor,
++                                             final Function<? super Throwable, ? extends Throwable> exceptionHandler) {
++        Validate.notNull(function, "Function may not be null");
++        Validate.notNull(exceptionHandler, "Exception handler may not be null");
++
++        final Completable<T> ret = new Completable<>();
++        this.pushStackOrRun(new ExceptionallyTransform<>(checkExecutor(executor), this, ret, exceptionHandler, function));
++        return ret;
++    }
++
++    private static final class ExceptionResult {
++        public final Throwable ex;
++
++        public ExceptionResult(final Throwable ex) {
++            this.ex = ex;
+         }
+     }
+ 
+-    /**
+-     * Adds a waiter that will be completed asynchronously by the complete() calls. If complete()
+-     * has already been called, then invokes the consumer synchronously with the completed result.
+-     * @param consumer Consumer to be executed on completion
+-     * @throws NullPointerException If consumer is null
+-     * @return A cancellable which will control the execution of the specified consumer
+-     */
+-    public Cancellable addWaiter(final BiConsumer<T, Throwable> consumer) {
+-        if (this.waiters.add(consumer)) {
+-            return new CancellableImpl(consumer);
++    private static abstract class Transform<U, T> implements Runnable, CompletableFuture.AsynchronousCompletionTask {
++
++        private Transform<?, T> next;
++
++        private final Executor executor;
++        protected final Completable<T> from;
++        protected final Completable<U> to;
++        protected final Function<? super Throwable, ? extends Throwable> exceptionHandler;
++
++        protected Transform(final Executor executor, final Completable<T> from, final Completable<U> to,
++                            final Function<? super Throwable, ? extends Throwable> exceptionHandler) {
++            this.executor = executor;
++            this.from = from;
++            this.to = to;
++            this.exceptionHandler = exceptionHandler;
++        }
++
++        // force interface call to become virtual call
++        @Override
++        public abstract void run();
++
++        protected void failed(final Throwable throwable) {
++            Throwable complete;
++            try {
++                complete = this.exceptionHandler.apply(throwable);
++            } catch (final Throwable thr2) {
++                throwable.addSuppressed(thr2);
++                complete = throwable;
++            }
++            this.to.completeExceptionally(complete);
++        }
++
++        public void execute() {
++            if (this.executor == null) {
++                this.run();
++                return;
++            }
++
++            try {
++                this.executor.execute(this);
++            } catch (final Throwable throwable) {
++                this.failed(throwable);
++            }
++        }
++    }
++
++    private static final class ApplyTransform<U, T> extends Transform<U, T> {
++
++        private final Function<? super T, ? extends U> function;
++
++        public ApplyTransform(final Executor executor, final Completable<T> from, final Completable<U> to,
++                              final Function<? super Throwable, ? extends Throwable> exceptionHandler,
++                              final Function<? super T, ? extends U> function) {
++            super(executor, from, to, exceptionHandler);
++            this.function = function;
++        }
++
++        @Override
++        public void run() {
++            final Object result = this.from.getResultPlain();
++            try {
++                if (result instanceof ExceptionResult exRes) {
++                    this.to.completeExceptionally(exRes.ex);
++                } else {
++                    this.to.complete(this.function.apply((T)unmaskNull(result)));
++                }
++            } catch (final Throwable throwable) {
++                this.failed(throwable);
++            }
+         }
+-        this.completeWaiter(consumer, this.result, this.throwable);
+-        return new CancellableImpl(consumer);
+     }
+ 
+-    public void complete(final T result) {
+-        this.result = result;
+-        this.completeAllWaiters(result, null);
++    private static final class AcceptTransform<T> extends Transform<Void, T> {
++        private final Consumer<? super T> consumer;
++
++        public AcceptTransform(final Executor executor, final Completable<T> from, final Completable<Void> to,
++                               final Function<? super Throwable, ? extends Throwable> exceptionHandler,
++                               final Consumer<? super T> consumer) {
++            super(executor, from, to, exceptionHandler);
++            this.consumer = consumer;
++        }
++
++        @Override
++        public void run() {
++            final Object result = this.from.getResultPlain();
++            try {
++                if (result instanceof ExceptionResult exRes) {
++                    this.to.completeExceptionally(exRes.ex);
++                } else {
++                    this.consumer.accept((T)unmaskNull(result));
++                    this.to.complete(null);
++                }
++            } catch (final Throwable throwable) {
++                this.failed(throwable);
++            }
++        }
+     }
+ 
+-    public void completeWithThrowable(final Throwable throwable) {
+-        if (throwable == null) {
+-            throw new NullPointerException("Throwable cannot be null");
++    private static final class RunTransform<T> extends Transform<Void, T> {
++        private final Runnable run;
++
++        public RunTransform(final Executor executor, final Completable<T> from, final Completable<Void> to,
++                            final Function<? super Throwable, ? extends Throwable> exceptionHandler,
++                            final Runnable run) {
++            super(executor, from, to, exceptionHandler);
++            this.run = run;
++        }
++
++        @Override
++        public void run() {
++            final Object result = this.from.getResultPlain();
++            try {
++                if (result instanceof ExceptionResult exRes) {
++                    this.to.completeExceptionally(exRes.ex);
++                } else {
++                    this.run.run();
++                    this.to.complete(null);
++                }
++            } catch (final Throwable throwable) {
++                this.failed(throwable);
++            }
+         }
+-        this.throwable = throwable;
+-        this.completeAllWaiters(null, throwable);
+     }
+ 
+-    private final class CancellableImpl implements Cancellable {
++    private static final class HandleTransform<U, T> extends Transform<U, T> {
++
++        private final BiFunction<? super T, ? super Throwable, ? extends U> function;
++
++        public HandleTransform(final Executor executor, final Completable<T> from, final Completable<U> to,
++                               final Function<? super Throwable, ? extends Throwable> exceptionHandler,
++                               final BiFunction<? super T, ? super Throwable, ? extends U> function) {
++            super(executor, from, to, exceptionHandler);
++            this.function = function;
++        }
+ 
+-        private final BiConsumer<T, Throwable> waiter;
++        @Override
++        public void run() {
++            final Object result = this.from.getResultPlain();
++            try {
++                if (result instanceof ExceptionResult exRes) {
++                    this.to.complete(this.function.apply(null, exRes.ex));
++                } else {
++                    this.to.complete(this.function.apply((T)unmaskNull(result), null));
++                }
++            } catch (final Throwable throwable) {
++                this.failed(throwable);
++            }
++        }
++    }
++
++    private static final class WhenTransform<T> extends Transform<T, T> {
++
++        private final BiConsumer<? super T, ? super Throwable> consumer;
++
++        public WhenTransform(final Executor executor, final Completable<T> from, final Completable<T> to,
++                              final Function<? super Throwable, ? extends Throwable> exceptionHandler,
++                              final BiConsumer<? super T, ? super Throwable> consumer) {
++            super(executor, from, to, exceptionHandler);
++            this.consumer = consumer;
++        }
++
++        @Override
++        public void run() {
++            final Object result = this.from.getResultPlain();
++            try {
++                if (result instanceof ExceptionResult exRes) {
++                    this.consumer.accept(null, exRes.ex);
++                    this.to.completeExceptionally(exRes.ex);
++                } else {
++                    final T unmasked = (T)unmaskNull(result);
++                    this.consumer.accept(unmasked, null);
++                    this.to.complete(unmasked);
++                }
++            } catch (final Throwable throwable) {
++                this.failed(throwable);
++            }
++        }
++    }
++
++    private static final class ExceptionallyTransform<T> extends Transform<T, T> {
++        private final Function<Throwable, ? extends T> function;
++
++        public ExceptionallyTransform(final Executor executor, final Completable<T> from, final Completable<T> to,
++                              final Function<? super Throwable, ? extends Throwable> exceptionHandler,
++                              final Function<Throwable, ? extends T> function) {
++            super(executor, from, to, exceptionHandler);
++            this.function = function;
++        }
++
++        @Override
++        public void run() {
++            final Object result = this.from.getResultPlain();
++            try {
++                if (result instanceof ExceptionResult exRes) {
++                    this.to.complete(this.function.apply(exRes.ex));
++                } else {
++                    this.to.complete((T)unmaskNull(result));
++                }
++            } catch (final Throwable throwable) {
++                this.failed(throwable);
++            }
++        }
++    }
++
++    private static final class UnparkTransform<T> extends Transform<Void, T> implements ForkJoinPool.ManagedBlocker {
++
++        private volatile Thread thread;
++
++        public UnparkTransform(final Completable<T> from, final Thread target) {
++            super(null, from, null, null);
++            this.thread = target;
++        }
++
++        @Override
++        public void run() {
++            final Thread t = this.thread;
++            this.thread = null;
++            LockSupport.unpark(t);
++        }
++
++        @Override
++        public boolean block() throws InterruptedException {
++            while (!this.isReleasable()) {
++                if (Thread.interrupted()) {
++                    throw new InterruptedException();
++                }
++                LockSupport.park(this);
++            }
+ 
+-        private CancellableImpl(final BiConsumer<T, Throwable> waiter) {
+-            this.waiter = waiter;
++            return true;
+         }
+ 
+         @Override
+-        public boolean cancel() {
+-            return Completable.this.waiters.remove(this.waiter);
++        public boolean isReleasable() {
++            return this.thread == null;
+         }
+     }
+ }
+diff --git a/src/main/java/ca/spottedleaf/concurrentutil/executor/BaseExecutor.java b/src/main/java/ca/spottedleaf/concurrentutil/executor/BaseExecutor.java
+deleted file mode 100644
+index 18d646676fd022afd64afaac30ec1bd283a73b0e..0000000000000000000000000000000000000000
+--- a/src/main/java/ca/spottedleaf/concurrentutil/executor/BaseExecutor.java
++++ /dev/null
+@@ -1,208 +0,0 @@
+-package ca.spottedleaf.concurrentutil.executor;
+-
+-import ca.spottedleaf.concurrentutil.util.ConcurrentUtil;
+-import java.util.function.BooleanSupplier;
+-
+-/**
+- * Base implementation for an abstract queue of tasks which are executed either synchronously or asynchronously.
+- *
+- * <p>
+- * The implementation supports tracking task executions using {@link #getTotalTasksScheduled()} and
+- * {@link #getTotalTasksExecuted()}, and optionally shutting down the executor using {@link #shutdown()}
+- * </p>
+- *
+- * <p>
+- * The base implementation does not provide a method to queue a task for execution, rather that is specified in
+- * the specific implementation. However, it is required that a specific implementation provides a method to
+- * <i>queue</i> a task or <i>create</i> a task. A <i>queued</i> task is one which will eventually be executed,
+- * and a <i>created</i> task must be queued to execute via {@link BaseTask#queue()} or be executed manually via
+- * {@link BaseTask#execute()}. This choice of delaying the queueing of a task may be useful to provide a task handle
+- * which may be cancelled or adjusted before the actual real task logic is ready to be executed.
+- * </p>
+- */
+-public interface BaseExecutor {
+-
+-    /**
+-     * Returns whether every task scheduled to this queue has been removed and executed or cancelled. If no tasks have been queued,
+-     * returns {@code true}.
+-     *
+-     * @return {@code true} if all tasks that have been queued have finished executing or no tasks have been queued, {@code false} otherwise.
+-     */
+-    public default boolean haveAllTasksExecuted() {
+-        // order is important
+-        // if new tasks are scheduled between the reading of these variables, scheduled is guaranteed to be higher -
+-        // so our check fails, and we try again
+-        final long completed = this.getTotalTasksExecuted();
+-        final long scheduled = this.getTotalTasksScheduled();
+-
+-        return completed == scheduled;
+-    }
+-
+-    /**
+-     * Returns the number of tasks that have been scheduled or execute or are pending to be scheduled.
+-     */
+-    public long getTotalTasksScheduled();
+-
+-    /**
+-     * Returns the number of tasks that have fully been executed.
+-     */
+-    public long getTotalTasksExecuted();
+-
+-    /**
+-     * Waits until this queue has had all of its tasks executed (NOT removed). See {@link #haveAllTasksExecuted()}
+-     * <p>
+-     *     This call is most effective after a {@link #shutdown()} call, as the shutdown call guarantees no tasks can
+-     *     be executed and the waitUntilAllExecuted call makes sure the queue is empty. Effectively, using shutdown then using
+-     *     waitUntilAllExecuted ensures this queue is empty - and most importantly, will remain empty.
+-     * </p>
+-     * <p>
+-     *     This method is not guaranteed to be immediately responsive to queue state, so calls may take significantly more
+-     *     time than expected. Effectively, do not rely on this call being fast - even if there are few tasks scheduled.
+-     * </p>
+-     * <p>
+-     *     Note: Interruptions to the the current thread have no effect. Interrupt status is also not affected by this call.
+-     * </p>
+-     *
+-     * @throws IllegalStateException If the current thread is not allowed to wait
+-     */
+-    public default void waitUntilAllExecuted() throws IllegalStateException {
+-        long failures = 1L; // start at 0.25ms
+-
+-        while (!this.haveAllTasksExecuted()) {
+-            Thread.yield();
+-            failures = ConcurrentUtil.linearLongBackoff(failures, 250_000L, 5_000_000L); // 500us, 5ms
+-        }
+-    }
+-
+-    /**
+-     * Executes the next available task.
+-     *
+-     * @return {@code true} if a task was executed, {@code false} otherwise
+-     * @throws IllegalStateException If the current thread is not allowed to execute a task
+-     */
+-    public boolean executeTask() throws IllegalStateException;
+-
+-    /**
+-     * Executes all queued tasks.
+-     *
+-     * @return {@code true} if a task was executed, {@code false} otherwise
+-     * @throws IllegalStateException If the current thread is not allowed to execute a task
+-     */
+-    public default boolean executeAll() {
+-        if (!this.executeTask()) {
+-            return false;
+-        }
+-
+-        while (this.executeTask());
+-
+-        return true;
+-    }
+-
+-    /**
+-     * Waits and executes tasks until the condition returns {@code true}.
+-     * <p>
+-     *     WARNING: This function is <i>not</i> suitable for waiting until a deadline!
+-     *     Use {@link #executeUntil(long)} or {@link #executeConditionally(BooleanSupplier, long)} instead.
+-     * </p>
+-     */
+-    public default void executeConditionally(final BooleanSupplier condition) {
+-        long failures = 0;
+-        while (!condition.getAsBoolean()) {
+-            if (this.executeTask()) {
+-                failures = failures >>> 2;
+-            } else {
+-                failures = ConcurrentUtil.linearLongBackoff(failures, 100_000L, 10_000_000L); // 100us, 10ms
+-            }
+-        }
+-    }
+-
+-    /**
+-     * Waits and executes tasks until the condition returns {@code true} or {@code System.nanoTime() - deadline >= 0}.
+-     */
+-    public default void executeConditionally(final BooleanSupplier condition, final long deadline) {
+-        long failures = 0;
+-        // double check deadline; we don't know how expensive the condition is
+-        while ((System.nanoTime() - deadline < 0L) && !condition.getAsBoolean() && (System.nanoTime() - deadline < 0L)) {
+-            if (this.executeTask()) {
+-                failures = failures >>> 2;
+-            } else {
+-                failures = ConcurrentUtil.linearLongBackoffDeadline(failures, 100_000L, 10_000_000L, deadline); // 100us, 10ms
+-            }
+-        }
+-    }
+-
+-    /**
+-     * Waits and executes tasks until {@code System.nanoTime() - deadline >= 0}.
+-     */
+-    public default void executeUntil(final long deadline) {
+-        long failures = 0;
+-        while (System.nanoTime() - deadline < 0L) {
+-            if (this.executeTask()) {
+-                failures = failures >>> 2;
+-            } else {
+-                failures = ConcurrentUtil.linearLongBackoffDeadline(failures, 100_000L, 10_000_000L, deadline); // 100us, 10ms
+-            }
+-        }
+-    }
+-
+-    /**
+-     * Prevent further additions to this queue. Attempts to add after this call has completed (potentially during) will
+-     * result in {@link IllegalStateException} being thrown.
+-     * <p>
+-     *     This operation is atomic with respect to other shutdown calls
+-     * </p>
+-     * <p>
+-     *     After this call has completed, regardless of return value, this queue will be shutdown.
+-     * </p>
+-     *
+-     * @return {@code true} if the queue was shutdown, {@code false} if it has shut down already
+-     * @throws UnsupportedOperationException If this queue does not support shutdown
+-     * @see #isShutdown()
+-     */
+-    public default boolean shutdown() throws UnsupportedOperationException {
+-        throw new UnsupportedOperationException();
+-    }
+-
+-    /**
+-     * Returns whether this queue has shut down. Effectively, whether new tasks will be rejected - this method
+-     * does not indicate whether all the tasks scheduled have been executed.
+-     * @return Returns whether this queue has shut down.
+-     * @see #waitUntilAllExecuted()
+-     */
+-    public default boolean isShutdown() {
+-        return false;
+-    }
+-
+-    /**
+-     * Task object returned for any {@link BaseExecutor} scheduled task.
+-     * @see BaseExecutor
+-     */
+-    public static interface BaseTask extends Cancellable {
+-
+-        /**
+-         * Causes a lazily queued task to become queued or executed
+-         *
+-         * @throws IllegalStateException If the backing queue has shutdown
+-         * @return {@code true} If the task was queued, {@code false} if the task was already queued/cancelled/executed
+-         */
+-        public boolean queue();
+-
+-        /**
+-         * Forces this task to be marked as completed.
+-         *
+-         * @return {@code true} if the task was cancelled, {@code false} if the task has already completed or is being completed.
+-         */
+-        @Override
+-        public boolean cancel();
+-
+-        /**
+-         * Executes this task. This will also mark the task as completing.
+-         * <p>
+-         *     Exceptions thrown from the runnable will be rethrown.
+-         * </p>
+-         *
+-         * @return {@code true} if this task was executed, {@code false} if it was already marked as completed.
+-         */
+-        public boolean execute();
+-    }
+-}
+diff --git a/src/main/java/ca/spottedleaf/concurrentutil/executor/PrioritisedExecutor.java b/src/main/java/ca/spottedleaf/concurrentutil/executor/PrioritisedExecutor.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..17cbaee1e89bd3f6d905e640d20d0119ab0570a0
+--- /dev/null
++++ b/src/main/java/ca/spottedleaf/concurrentutil/executor/PrioritisedExecutor.java
+@@ -0,0 +1,271 @@
++package ca.spottedleaf.concurrentutil.executor;
++
++import ca.spottedleaf.concurrentutil.util.Priority;
++
++public interface PrioritisedExecutor {
++
++    /**
++     * Returns the number of tasks that have been scheduled are pending to be scheduled.
++     */
++    public long getTotalTasksScheduled();
++
++    /**
++     * Returns the number of tasks that have been executed.
++     */
++    public long getTotalTasksExecuted();
++
++    /**
++     * Generates the next suborder id.
++     * @return The next suborder id.
++     */
++    public long generateNextSubOrder();
++
++    /**
++     * Executes the next available task.
++     * <p>
++     *     If there is a task with priority {@link Priority#BLOCKING} available, then that such task is executed.
++     * </p>
++     * <p>
++     *     If there is a task with priority {@link Priority#IDLE} available then that task is only executed
++     *     when there are no other tasks available with a higher priority.
++     * </p>
++     * <p>
++     *     If there are no tasks that have priority {@link Priority#BLOCKING} or {@link Priority#IDLE}, then
++     *     this function will be biased to execute tasks that have higher priorities.
++     * </p>
++     *
++     * @return {@code true} if a task was executed, {@code false} otherwise
++     * @throws IllegalStateException If the current thread is not allowed to execute a task
++     */
++    public boolean executeTask() throws IllegalStateException;
++
++    /**
++     * Prevent further additions to this executor. Attempts to add after this call has completed (potentially during) will
++     * result in {@link IllegalStateException} being thrown.
++     * <p>
++     *     This operation is atomic with respect to other shutdown calls
++     * </p>
++     * <p>
++     *     After this call has completed, regardless of return value, this executor will be shutdown.
++     * </p>
++     *
++     * @return {@code true} if the executor was shutdown, {@code false} if it has shut down already
++     * @see #isShutdown()
++     */
++    public boolean shutdown();
++
++    /**
++     * Returns whether this executor has shut down. Effectively, returns whether new tasks will be rejected.
++     * This method does not indicate whether all the tasks scheduled have been executed.
++     * @return Returns whether this executor has shut down.
++     */
++    public boolean isShutdown();
++
++    /**
++     * Queues or executes a task at {@link Priority#NORMAL} priority.
++     * @param task The task to run.
++     *
++     * @throws IllegalStateException If this executor has shutdown.
++     * @throws NullPointerException If the task is null
++     * @return {@code null} if the current thread immediately executed the task, else returns the prioritised task
++     *         associated with the parameter
++     */
++    public PrioritisedTask queueTask(final Runnable task);
++
++    /**
++     * Queues or executes a task.
++     *
++     * @param task The task to run.
++     * @param priority The priority for the task.
++     *
++     * @throws IllegalStateException If this executor has shutdown.
++     * @throws NullPointerException If the task is null
++     * @throws IllegalArgumentException If the priority is invalid.
++     * @return {@code null} if the current thread immediately executed the task, else returns the prioritised task
++     *         associated with the parameter
++     */
++    public PrioritisedTask queueTask(final Runnable task, final Priority priority);
++
++    /**
++     * Queues or executes a task.
++     *
++     * @param task The task to run.
++     * @param priority The priority for the task.
++     * @param subOrder The task's suborder.
++     *
++     * @throws IllegalStateException If this executor has shutdown.
++     * @throws NullPointerException If the task is null
++     * @throws IllegalArgumentException If the priority is invalid.
++     * @return {@code null} if the current thread immediately executed the task, else returns the prioritised task
++     *         associated with the parameter
++     */
++    public PrioritisedTask queueTask(final Runnable task, final Priority priority, final long subOrder);
++
++    /**
++     * Creates, but does not queue or execute, a task at {@link Priority#NORMAL} priority.
++     * @param task The task to run.
++     *
++     * @throws NullPointerException If the task is null
++     * @return {@code null} if the current thread immediately executed the task, else returns the prioritised task
++     *         associated with the parameter
++     */
++    public PrioritisedTask createTask(final Runnable task);
++
++    /**
++     * Creates, but does not queue or execute, a task at {@link Priority#NORMAL} priority.
++     *
++     * @param task The task to run.
++     * @param priority The priority for the task.
++     *
++     * @throws NullPointerException If the task is null
++     * @throws IllegalArgumentException If the priority is invalid.
++     * @return {@code null} if the current thread immediately executed the task, else returns the prioritised task
++     *         associated with the parameter
++     */
++    public PrioritisedTask createTask(final Runnable task, final Priority priority);
++
++    /**
++     * Creates, but does not queue or execute, a task at {@link Priority#NORMAL} priority.
++     *
++     * @param task The task to run.
++     * @param priority The priority for the task.
++     * @param subOrder The task's suborder.
++     *
++     * @throws NullPointerException If the task is null
++     * @throws IllegalArgumentException If the priority is invalid.
++     * @return {@code null} if the current thread immediately executed the task, else returns the prioritised task
++     *         associated with the parameter
++     */
++    public PrioritisedTask createTask(final Runnable task, final Priority priority, final long subOrder);
++
++    public static interface PrioritisedTask extends Cancellable {
++
++        /**
++         * Returns the executor associated with this task.
++         * @return The executor associated with this task.
++         */
++        public PrioritisedExecutor getExecutor();
++
++        /**
++         * Causes a lazily queued task to become queued or executed
++         *
++         * @throws IllegalStateException If the backing executor has shutdown
++         * @return {@code true} If the task was queued, {@code false} if the task was already queued/cancelled/executed
++         */
++        public boolean queue();
++
++        /**
++         * Returns whether this task has been queued and is not completing.
++         * @return {@code true} If the task has been queued, {@code false} if the task has not been queued or is marked
++         *         as completing.
++         */
++        public boolean isQueued();
++
++        /**
++         * Forces this task to be marked as completed.
++         *
++         * @return {@code true} if the task was cancelled, {@code false} if the task has already completed
++         *         or is being completed.
++         */
++        @Override
++        public boolean cancel();
++
++        /**
++         * Executes this task. This will also mark the task as completing.
++         * <p>
++         *     Exceptions thrown from the runnable will be rethrown.
++         * </p>
++         *
++         * @return {@code true} if this task was executed, {@code false} if it was already marked as completed.
++         */
++        public boolean execute();
++
++        /**
++         * Returns the current priority. Note that {@link Priority#COMPLETING} will be returned
++         * if this task is completing or has completed.
++         */
++        public Priority getPriority();
++
++        /**
++         * Attempts to set this task's priority level to the level specified.
++         *
++         * @param priority Specified priority level.
++         *
++         * @throws IllegalArgumentException If the priority is invalid
++         * @return {@code true} if successful, {@code false} if this task is completing or has completed or the queue
++         *         this task was scheduled on was shutdown, or if the priority was already at the specified level.
++         */
++        public boolean setPriority(final Priority priority);
++
++        /**
++         * Attempts to raise the priority to the priority level specified.
++         *
++         * @param priority Priority specified
++         *
++         * @throws IllegalArgumentException If the priority is invalid
++         * @return {@code false} if the current task is completing, {@code true} if the priority was raised to the
++         *          specified level or was already at the specified level or higher.
++         */
++        public boolean raisePriority(final Priority priority);
++
++        /**
++         * Attempts to lower the priority to the priority level specified.
++         *
++         * @param priority Priority specified
++         *
++         * @throws IllegalArgumentException If the priority is invalid
++         * @return {@code false} if the current task is completing, {@code true} if the priority was lowered to the
++         *          specified level or was already at the specified level or lower.
++         */
++        public boolean lowerPriority(final Priority priority);
++
++        /**
++         * Returns the suborder id associated with this task.
++         * @return The suborder id associated with this task.
++         */
++        public long getSubOrder();
++
++        /**
++         * Sets the suborder id associated with this task. Ths function has no effect when this task
++         * is completing or is completed.
++         *
++         * @param subOrder Specified new sub order.
++         *
++         * @return {@code true} if successful, {@code false} if this task is completing or has completed or the queue
++         *         this task was scheduled on was shutdown, or if the current suborder is the same as the new sub order.
++         */
++        public boolean setSubOrder(final long subOrder);
++
++        /**
++         * Attempts to raise the suborder to the suborder specified.
++         *
++         * @param subOrder Specified new sub order.
++         *
++         * @return {@code false} if the current task is completing, {@code true} if the suborder was raised to the
++         *          specified suborder or was already at the specified suborder or higher.
++         */
++        public boolean raiseSubOrder(final long subOrder);
++
++        /**
++         * Attempts to lower the suborder to the suborder specified.
++         *
++         * @param subOrder Specified new sub order.
++         *
++         * @return {@code false} if the current task is completing, {@code true} if the suborder was lowered to the
++         *          specified suborder or was already at the specified suborder or lower.
++         */
++        public boolean lowerSubOrder(final long subOrder);
++
++        /**
++         * Sets the priority and suborder id associated with this task. Ths function has no effect when this task
++         * is completing or is completed.
++         *
++         * @param priority Priority specified
++         * @param subOrder Specified new sub order.
++         * @return {@code true} if successful, {@code false} if this task is completing or has completed or the queue
++         *         this task was scheduled on was shutdown, or if the current priority and suborder are the same as
++         *         the parameters.
++         */
++        public boolean setPriorityAndSubOrder(final Priority priority, final long subOrder);
++    }
++}
+diff --git a/src/main/java/ca/spottedleaf/concurrentutil/executor/queue/PrioritisedTaskQueue.java b/src/main/java/ca/spottedleaf/concurrentutil/executor/queue/PrioritisedTaskQueue.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..edb8c6611bdc9aced2714b963e00bbb7829603d2
+--- /dev/null
++++ b/src/main/java/ca/spottedleaf/concurrentutil/executor/queue/PrioritisedTaskQueue.java
+@@ -0,0 +1,454 @@
++package ca.spottedleaf.concurrentutil.executor.queue;
++
++import ca.spottedleaf.concurrentutil.executor.PrioritisedExecutor;
++import ca.spottedleaf.concurrentutil.util.ConcurrentUtil;
++import ca.spottedleaf.concurrentutil.util.Priority;
++import java.lang.invoke.VarHandle;
++import java.util.Comparator;
++import java.util.Map;
++import java.util.concurrent.ConcurrentSkipListMap;
++import java.util.concurrent.atomic.AtomicBoolean;
++import java.util.concurrent.atomic.AtomicLong;
++
++public final class PrioritisedTaskQueue implements PrioritisedExecutor {
++
++    /**
++     * Required for tie-breaking in the queue
++     */
++    private final AtomicLong taskIdGenerator = new AtomicLong();
++    private final AtomicLong scheduledTasks = new AtomicLong();
++    private final AtomicLong executedTasks = new AtomicLong();
++    private final AtomicLong subOrderGenerator = new AtomicLong();
++    private final AtomicBoolean shutdown = new AtomicBoolean();
++    private final ConcurrentSkipListMap<PrioritisedQueuedTask.Holder, Boolean> tasks = new ConcurrentSkipListMap<>(PrioritisedQueuedTask.COMPARATOR);
++
++    @Override
++    public long getTotalTasksScheduled() {
++        return this.scheduledTasks.get();
++    }
++
++    @Override
++    public long getTotalTasksExecuted() {
++        return this.executedTasks.get();
++    }
++
++    @Override
++    public long generateNextSubOrder() {
++        return this.subOrderGenerator.getAndIncrement();
++    }
++
++    @Override
++    public boolean shutdown() {
++        return !this.shutdown.getAndSet(true);
++    }
++
++    @Override
++    public boolean isShutdown() {
++        return this.shutdown.get();
++    }
++
++    public PrioritisedTask peekFirst() {
++        final Map.Entry<PrioritisedQueuedTask.Holder, Boolean> firstEntry = this.tasks.firstEntry();
++        return firstEntry == null ? null : firstEntry.getKey().task;
++    }
++
++    public Priority getHighestPriority() {
++        final Map.Entry<PrioritisedQueuedTask.Holder, Boolean> firstEntry = this.tasks.firstEntry();
++        return firstEntry == null ? null : Priority.getPriority(firstEntry.getKey().priority);
++    }
++
++    public boolean hasNoScheduledTasks() {
++        final long executedTasks = this.executedTasks.get();
++        final long scheduledTasks = this.scheduledTasks.get();
++
++        return executedTasks == scheduledTasks;
++    }
++
++    public PrioritySubOrderPair getHighestPrioritySubOrder() {
++        final Map.Entry<PrioritisedQueuedTask.Holder, Boolean> firstEntry = this.tasks.firstEntry();
++        if (firstEntry == null) {
++            return null;
++        }
++
++        final PrioritisedQueuedTask.Holder holder = firstEntry.getKey();
++
++        return new PrioritySubOrderPair(Priority.getPriority(holder.priority), holder.subOrder);
++    }
++
++    public Runnable pollTask() {
++        for (;;) {
++            final Map.Entry<PrioritisedQueuedTask.Holder, Boolean> firstEntry = this.tasks.pollFirstEntry();
++            if (firstEntry != null) {
++                final PrioritisedQueuedTask.Holder task = firstEntry.getKey();
++                task.markRemoved();
++                if (!task.task.cancel()) {
++                    continue;
++                }
++                return task.task.execute;
++            }
++
++            return null;
++        }
++    }
++
++    @Override
++    public boolean executeTask() {
++        for (;;) {
++            final Map.Entry<PrioritisedQueuedTask.Holder, Boolean> firstEntry = this.tasks.pollFirstEntry();
++            if (firstEntry != null) {
++                final PrioritisedQueuedTask.Holder task = firstEntry.getKey();
++                task.markRemoved();
++                if (!task.task.execute()) {
++                    continue;
++                }
++                return true;
++            }
++
++            return false;
++        }
++    }
++
++    @Override
++    public PrioritisedTask createTask(final Runnable task) {
++        return this.createTask(task, Priority.NORMAL, this.generateNextSubOrder());
++    }
++
++    @Override
++    public PrioritisedTask createTask(final Runnable task, final Priority priority) {
++        return this.createTask(task, priority, this.generateNextSubOrder());
++    }
++
++    @Override
++    public PrioritisedTask createTask(final Runnable task, final Priority priority, final long subOrder) {
++        return new PrioritisedQueuedTask(task, priority, subOrder);
++    }
++
++    @Override
++    public PrioritisedTask queueTask(final Runnable task) {
++        return this.queueTask(task, Priority.NORMAL, this.generateNextSubOrder());
++    }
++
++    @Override
++    public PrioritisedTask queueTask(final Runnable task, final Priority priority) {
++        return this.queueTask(task, priority, this.generateNextSubOrder());
++    }
++
++    @Override
++    public PrioritisedTask queueTask(final Runnable task, final Priority priority, final long subOrder) {
++        final PrioritisedQueuedTask ret = new PrioritisedQueuedTask(task, priority, subOrder);
++
++        ret.queue();
++
++        return ret;
++    }
++
++    private final class PrioritisedQueuedTask implements PrioritisedExecutor.PrioritisedTask {
++        public static final Comparator<PrioritisedQueuedTask.Holder> COMPARATOR = (final PrioritisedQueuedTask.Holder t1, final PrioritisedQueuedTask.Holder t2) -> {
++            final int priorityCompare = t1.priority - t2.priority;
++            if (priorityCompare != 0) {
++                return priorityCompare;
++            }
++
++            final int subOrderCompare = Long.compare(t1.subOrder, t2.subOrder);
++            if (subOrderCompare != 0) {
++                return subOrderCompare;
++            }
++
++            return Long.compare(t1.id, t2.id);
++        };
++
++        private static final class Holder {
++            private final PrioritisedQueuedTask task;
++            private final int priority;
++            private final long subOrder;
++            private final long id;
++
++            private volatile boolean removed;
++            private static final VarHandle REMOVED_HANDLE = ConcurrentUtil.getVarHandle(Holder.class, "removed", boolean.class);
++
++            private Holder(final PrioritisedQueuedTask task, final int priority, final long subOrder,
++                           final long id) {
++                this.task = task;
++                this.priority = priority;
++                this.subOrder = subOrder;
++                this.id = id;
++            }
++
++            /**
++             * Returns true if marked as removed
++             */
++            public boolean markRemoved() {
++                return !(boolean)REMOVED_HANDLE.getAndSet((Holder)this, (boolean)true);
++            }
++        }
++
++        private final long id;
++        private final Runnable execute;
++
++        private Priority priority;
++        private long subOrder;
++        private Holder holder;
++
++        public PrioritisedQueuedTask(final Runnable execute, final Priority priority, final long subOrder) {
++            if (!Priority.isValidPriority(priority)) {
++                throw new IllegalArgumentException("Invalid priority " + priority);
++            }
++
++            this.execute = execute;
++            this.priority = priority;
++            this.subOrder = subOrder;
++            this.id = PrioritisedTaskQueue.this.taskIdGenerator.getAndIncrement();
++        }
++
++        @Override
++        public PrioritisedExecutor getExecutor() {
++            return PrioritisedTaskQueue.this;
++        }
++
++        @Override
++        public boolean queue() {
++            synchronized (this) {
++                if (this.holder != null || this.priority == Priority.COMPLETING) {
++                    return false;
++                }
++
++                if (PrioritisedTaskQueue.this.isShutdown()) {
++                    throw new IllegalStateException("Queue is shutdown");
++                }
++
++                final Holder holder = new Holder(this, this.priority.priority, this.subOrder, this.id);
++                this.holder = holder;
++
++                PrioritisedTaskQueue.this.scheduledTasks.getAndIncrement();
++                PrioritisedTaskQueue.this.tasks.put(holder, Boolean.TRUE);
++            }
++
++            if (PrioritisedTaskQueue.this.isShutdown()) {
++                this.cancel();
++                throw new IllegalStateException("Queue is shutdown");
++            }
++
++
++            return true;
++        }
++
++        @Override
++        public boolean isQueued() {
++            synchronized (this) {
++                return this.holder != null && this.priority != Priority.COMPLETING;
++            }
++        }
++
++        @Override
++        public boolean cancel() {
++            synchronized (this) {
++                if (this.priority == Priority.COMPLETING) {
++                    return false;
++                }
++
++                this.priority = Priority.COMPLETING;
++
++                if (this.holder != null) {
++                    if (this.holder.markRemoved()) {
++                        PrioritisedTaskQueue.this.tasks.remove(this.holder);
++                    }
++                    PrioritisedTaskQueue.this.executedTasks.getAndIncrement();
++                }
++
++                return true;
++            }
++        }
++
++        @Override
++        public boolean execute() {
++            final boolean increaseExecuted;
++
++            synchronized (this) {
++                if (this.priority == Priority.COMPLETING) {
++                    return false;
++                }
++
++                this.priority = Priority.COMPLETING;
++
++                if (increaseExecuted = (this.holder != null)) {
++                    if (this.holder.markRemoved()) {
++                        PrioritisedTaskQueue.this.tasks.remove(this.holder);
++                    }
++                }
++            }
++
++            try {
++                this.execute.run();
++                return true;
++            } finally {
++                if (increaseExecuted) {
++                    PrioritisedTaskQueue.this.executedTasks.getAndIncrement();
++                }
++            }
++        }
++
++        @Override
++        public Priority getPriority() {
++            synchronized (this) {
++                return this.priority;
++            }
++        }
++
++        @Override
++        public boolean setPriority(final Priority priority) {
++            synchronized (this) {
++                if (this.priority == Priority.COMPLETING || this.priority == priority) {
++                    return false;
++                }
++
++                this.priority = priority;
++
++                if (this.holder != null) {
++                    if (this.holder.markRemoved()) {
++                        PrioritisedTaskQueue.this.tasks.remove(this.holder);
++                    }
++                    this.holder = new Holder(this, priority.priority, this.subOrder, this.id);
++                    PrioritisedTaskQueue.this.tasks.put(this.holder, Boolean.TRUE);
++                }
++
++                return true;
++            }
++        }
++
++        @Override
++        public boolean raisePriority(final Priority priority) {
++            synchronized (this) {
++                if (this.priority == Priority.COMPLETING || this.priority.isHigherOrEqualPriority(priority)) {
++                    return false;
++                }
++
++                this.priority = priority;
++
++                if (this.holder != null) {
++                    if (this.holder.markRemoved()) {
++                        PrioritisedTaskQueue.this.tasks.remove(this.holder);
++                    }
++                    this.holder = new Holder(this, priority.priority, this.subOrder, this.id);
++                    PrioritisedTaskQueue.this.tasks.put(this.holder, Boolean.TRUE);
++                }
++
++                return true;
++            }
++        }
++
++        @Override
++        public boolean lowerPriority(Priority priority) {
++            synchronized (this) {
++                if (this.priority == Priority.COMPLETING || this.priority.isLowerOrEqualPriority(priority)) {
++                    return false;
++                }
++
++                this.priority = priority;
++
++                if (this.holder != null) {
++                    if (this.holder.markRemoved()) {
++                        PrioritisedTaskQueue.this.tasks.remove(this.holder);
++                    }
++                    this.holder = new Holder(this, priority.priority, this.subOrder, this.id);
++                    PrioritisedTaskQueue.this.tasks.put(this.holder, Boolean.TRUE);
++                }
++
++                return true;
++            }
++        }
++
++        @Override
++        public long getSubOrder() {
++            synchronized (this) {
++                return this.subOrder;
++            }
++        }
++
++        @Override
++        public boolean setSubOrder(final long subOrder) {
++            synchronized (this) {
++                if (this.priority == Priority.COMPLETING || this.subOrder == subOrder) {
++                    return false;
++                }
++
++                this.subOrder = subOrder;
++
++                if (this.holder != null) {
++                    if (this.holder.markRemoved()) {
++                        PrioritisedTaskQueue.this.tasks.remove(this.holder);
++                    }
++                    this.holder = new Holder(this, priority.priority, this.subOrder, this.id);
++                    PrioritisedTaskQueue.this.tasks.put(this.holder, Boolean.TRUE);
++                }
++
++                return true;
++            }
++        }
++
++        @Override
++        public boolean raiseSubOrder(long subOrder) {
++            synchronized (this) {
++                if (this.priority == Priority.COMPLETING || this.subOrder >= subOrder) {
++                    return false;
++                }
++
++                this.subOrder = subOrder;
++
++                if (this.holder != null) {
++                    if (this.holder.markRemoved()) {
++                        PrioritisedTaskQueue.this.tasks.remove(this.holder);
++                    }
++                    this.holder = new Holder(this, priority.priority, this.subOrder, this.id);
++                    PrioritisedTaskQueue.this.tasks.put(this.holder, Boolean.TRUE);
++                }
++
++                return true;
++            }
++        }
++
++        @Override
++        public boolean lowerSubOrder(final long subOrder) {
++            synchronized (this) {
++                if (this.priority == Priority.COMPLETING || this.subOrder <= subOrder) {
++                    return false;
++                }
++
++                this.subOrder = subOrder;
++
++                if (this.holder != null) {
++                    if (this.holder.markRemoved()) {
++                        PrioritisedTaskQueue.this.tasks.remove(this.holder);
++                    }
++                    this.holder = new Holder(this, priority.priority, this.subOrder, this.id);
++                    PrioritisedTaskQueue.this.tasks.put(this.holder, Boolean.TRUE);
++                }
++
++                return true;
++            }
++        }
++
++        @Override
++        public boolean setPriorityAndSubOrder(final Priority priority, final long subOrder) {
++            synchronized (this) {
++                if (this.priority == Priority.COMPLETING || (this.priority == priority && this.subOrder == subOrder)) {
++                    return false;
++                }
++
++                this.priority = priority;
++                this.subOrder = subOrder;
++
++                if (this.holder != null) {
++                    if (this.holder.markRemoved()) {
++                        PrioritisedTaskQueue.this.tasks.remove(this.holder);
++                    }
++                    this.holder = new Holder(this, priority.priority, this.subOrder, this.id);
++                    PrioritisedTaskQueue.this.tasks.put(this.holder, Boolean.TRUE);
++                }
++
++                return true;
++            }
++        }
++    }
++
++    public static record PrioritySubOrderPair(Priority priority, long subOrder) {}
++}
+diff --git a/src/main/java/ca/spottedleaf/concurrentutil/executor/standard/DelayedPrioritisedTask.java b/src/main/java/ca/spottedleaf/concurrentutil/executor/standard/DelayedPrioritisedTask.java
+deleted file mode 100644
+index 3ce10053d4ec51855ad7012abb5d97df1c0e557a..0000000000000000000000000000000000000000
+--- a/src/main/java/ca/spottedleaf/concurrentutil/executor/standard/DelayedPrioritisedTask.java
++++ /dev/null
+@@ -1,170 +0,0 @@
+-package ca.spottedleaf.concurrentutil.executor.standard;
+-
+-import ca.spottedleaf.concurrentutil.util.ConcurrentUtil;
+-import java.lang.invoke.VarHandle;
+-
+-public class DelayedPrioritisedTask {
+-
+-    protected volatile int priority;
+-    protected static final VarHandle PRIORITY_HANDLE = ConcurrentUtil.getVarHandle(DelayedPrioritisedTask.class, "priority", int.class);
+-
+-    protected static final int PRIORITY_SET = Integer.MIN_VALUE >>> 0;
+-
+-    protected final int getPriorityVolatile() {
+-        return (int)PRIORITY_HANDLE.getVolatile((DelayedPrioritisedTask)this);
+-    }
+-
+-    protected final int compareAndExchangePriorityVolatile(final int expect, final int update) {
+-        return (int)PRIORITY_HANDLE.compareAndExchange((DelayedPrioritisedTask)this, (int)expect, (int)update);
+-    }
+-
+-    protected final int getAndOrPriorityVolatile(final int val) {
+-        return (int)PRIORITY_HANDLE.getAndBitwiseOr((DelayedPrioritisedTask)this, (int)val);
+-    }
+-
+-    protected final void setPriorityPlain(final int val) {
+-        PRIORITY_HANDLE.set((DelayedPrioritisedTask)this, (int)val);
+-    }
+-
+-    protected volatile PrioritisedExecutor.PrioritisedTask task;
+-    protected static final VarHandle TASK_HANDLE = ConcurrentUtil.getVarHandle(DelayedPrioritisedTask.class, "task", PrioritisedExecutor.PrioritisedTask.class);
+-
+-    protected PrioritisedExecutor.PrioritisedTask getTaskPlain() {
+-        return (PrioritisedExecutor.PrioritisedTask)TASK_HANDLE.get((DelayedPrioritisedTask)this);
+-    }
+-
+-    protected PrioritisedExecutor.PrioritisedTask getTaskVolatile() {
+-        return (PrioritisedExecutor.PrioritisedTask)TASK_HANDLE.getVolatile((DelayedPrioritisedTask)this);
+-    }
+-
+-    protected final PrioritisedExecutor.PrioritisedTask compareAndExchangeTaskVolatile(final PrioritisedExecutor.PrioritisedTask expect, final PrioritisedExecutor.PrioritisedTask update) {
+-        return (PrioritisedExecutor.PrioritisedTask)TASK_HANDLE.compareAndExchange((DelayedPrioritisedTask)this, (PrioritisedExecutor.PrioritisedTask)expect, (PrioritisedExecutor.PrioritisedTask)update);
+-    }
+-
+-    public DelayedPrioritisedTask(final PrioritisedExecutor.Priority priority) {
+-        this.setPriorityPlain(priority.priority);
+-    }
+-
+-    // only public for debugging
+-    public int getPriorityInternal() {
+-        return this.getPriorityVolatile();
+-    }
+-
+-    public PrioritisedExecutor.PrioritisedTask getTask() {
+-        return this.getTaskVolatile();
+-    }
+-
+-    public void setTask(final PrioritisedExecutor.PrioritisedTask task) {
+-        int priority = this.getPriorityVolatile();
+-
+-        if (this.compareAndExchangeTaskVolatile(null, task) != null) {
+-            throw new IllegalStateException("setTask() called twice");
+-        }
+-
+-        int failures = 0;
+-        for (;;) {
+-            task.setPriority(PrioritisedExecutor.Priority.getPriority(priority));
+-
+-            if (priority == (priority = this.compareAndExchangePriorityVolatile(priority, priority | PRIORITY_SET))) {
+-                return;
+-            }
+-
+-            ++failures;
+-            for (int i = 0; i < failures; ++i) {
+-                ConcurrentUtil.backoff();
+-            }
+-        }
+-    }
+-
+-    public PrioritisedExecutor.Priority getPriority() {
+-        final int priority = this.getPriorityVolatile();
+-        if ((priority & PRIORITY_SET) != 0) {
+-            return this.task.getPriority();
+-        }
+-
+-        return PrioritisedExecutor.Priority.getPriority(priority);
+-    }
+-
+-    public void raisePriority(final PrioritisedExecutor.Priority priority) {
+-        if (!PrioritisedExecutor.Priority.isValidPriority(priority)) {
+-            throw new IllegalArgumentException("Invalid priority " + priority);
+-        }
+-
+-        int failures = 0;
+-        for (int curr = this.getPriorityVolatile();;) {
+-            if ((curr & PRIORITY_SET) != 0) {
+-                this.getTaskPlain().raisePriority(priority);
+-                return;
+-            }
+-
+-            if (!priority.isLowerPriority(curr)) {
+-                return;
+-            }
+-
+-            if (curr == (curr = this.compareAndExchangePriorityVolatile(curr, priority.priority))) {
+-                return;
+-            }
+-
+-            // failed, retry
+-
+-            ++failures;
+-            for (int i = 0; i < failures; ++i) {
+-                ConcurrentUtil.backoff();
+-            }
+-        }
+-    }
+-
+-    public void setPriority(final PrioritisedExecutor.Priority priority) {
+-        if (!PrioritisedExecutor.Priority.isValidPriority(priority)) {
+-            throw new IllegalArgumentException("Invalid priority " + priority);
+-        }
+-
+-        int failures = 0;
+-        for (int curr = this.getPriorityVolatile();;) {
+-            if ((curr & PRIORITY_SET) != 0) {
+-                this.getTaskPlain().setPriority(priority);
+-                return;
+-            }
+-
+-            if (curr == (curr = this.compareAndExchangePriorityVolatile(curr, priority.priority))) {
+-                return;
+-            }
+-
+-            // failed, retry
+-
+-            ++failures;
+-            for (int i = 0; i < failures; ++i) {
+-                ConcurrentUtil.backoff();
+-            }
+-        }
+-    }
+-
+-    public void lowerPriority(final PrioritisedExecutor.Priority priority) {
+-        if (!PrioritisedExecutor.Priority.isValidPriority(priority)) {
+-            throw new IllegalArgumentException("Invalid priority " + priority);
+-        }
+-
+-        int failures = 0;
+-        for (int curr = this.getPriorityVolatile();;) {
+-            if ((curr & PRIORITY_SET) != 0) {
+-                this.getTaskPlain().lowerPriority(priority);
+-                return;
+-            }
+-
+-            if (!priority.isHigherPriority(curr)) {
+-                return;
+-            }
+-
+-            if (curr == (curr = this.compareAndExchangePriorityVolatile(curr, priority.priority))) {
+-                return;
+-            }
+-
+-            // failed, retry
+-
+-            ++failures;
+-            for (int i = 0; i < failures; ++i) {
+-                ConcurrentUtil.backoff();
+-            }
+-        }
+-    }
+-}
+diff --git a/src/main/java/ca/spottedleaf/concurrentutil/executor/standard/PrioritisedExecutor.java b/src/main/java/ca/spottedleaf/concurrentutil/executor/standard/PrioritisedExecutor.java
+deleted file mode 100644
+index 91beb6f23f257cf265fe3150f760892e605f217a..0000000000000000000000000000000000000000
+--- a/src/main/java/ca/spottedleaf/concurrentutil/executor/standard/PrioritisedExecutor.java
++++ /dev/null
+@@ -1,276 +0,0 @@
+-package ca.spottedleaf.concurrentutil.executor.standard;
+-
+-import ca.spottedleaf.concurrentutil.executor.BaseExecutor;
+-
+-/**
+- * Implementation of {@link BaseExecutor} which schedules tasks to be executed by a given priority.
+- * @see BaseExecutor
+- */
+-public interface PrioritisedExecutor extends BaseExecutor {
+-
+-    public static enum Priority {
+-
+-        /**
+-         * Priority value indicating the task has completed or is being completed.
+-         * This priority cannot be used to schedule tasks.
+-         */
+-        COMPLETING(-1),
+-
+-        /**
+-         * Absolute highest priority, should only be used for when a task is blocking a time-critical thread.
+-         */
+-        BLOCKING(),
+-
+-        /**
+-         * Should only be used for urgent but not time-critical tasks.
+-         */
+-        HIGHEST(),
+-
+-        /**
+-         * Two priorities above normal.
+-         */
+-        HIGHER(),
+-
+-        /**
+-         * One priority above normal.
+-         */
+-        HIGH(),
+-
+-        /**
+-         * Default priority.
+-         */
+-        NORMAL(),
+-
+-        /**
+-         * One priority below normal.
+-         */
+-        LOW(),
+-
+-        /**
+-         * Two priorities below normal.
+-         */
+-        LOWER(),
+-
+-        /**
+-         * Use for tasks that should eventually execute, but are not needed to.
+-         */
+-        LOWEST(),
+-
+-        /**
+-         * Use for tasks that can be delayed indefinitely.
+-         */
+-        IDLE();
+-
+-        // returns whether the priority can be scheduled
+-        public static boolean isValidPriority(final Priority priority) {
+-            return priority != null && priority != Priority.COMPLETING;
+-        }
+-
+-        // returns the higher priority of the two
+-        public static Priority max(final Priority p1, final Priority p2) {
+-            return p1.isHigherOrEqualPriority(p2) ? p1 : p2;
+-        }
+-
+-        // returns the lower priroity of the two
+-        public static Priority min(final Priority p1, final Priority p2) {
+-            return p1.isLowerOrEqualPriority(p2) ? p1 : p2;
+-        }
+-
+-        public boolean isHigherOrEqualPriority(final Priority than) {
+-            return this.priority <= than.priority;
+-        }
+-
+-        public boolean isHigherPriority(final Priority than) {
+-            return this.priority < than.priority;
+-        }
+-
+-        public boolean isLowerOrEqualPriority(final Priority than) {
+-            return this.priority >= than.priority;
+-        }
+-
+-        public boolean isLowerPriority(final Priority than) {
+-            return this.priority > than.priority;
+-        }
+-
+-        public boolean isHigherOrEqualPriority(final int than) {
+-            return this.priority <= than;
+-        }
+-
+-        public boolean isHigherPriority(final int than) {
+-            return this.priority < than;
+-        }
+-
+-        public boolean isLowerOrEqualPriority(final int than) {
+-            return this.priority >= than;
+-        }
+-
+-        public boolean isLowerPriority(final int than) {
+-            return this.priority > than;
+-        }
+-
+-        public static boolean isHigherOrEqualPriority(final int priority, final int than) {
+-            return priority <= than;
+-        }
+-
+-        public static boolean isHigherPriority(final int priority, final int than) {
+-            return priority < than;
+-        }
+-
+-        public static boolean isLowerOrEqualPriority(final int priority, final int than) {
+-            return priority >= than;
+-        }
+-
+-        public static boolean isLowerPriority(final int priority, final int than) {
+-            return priority > than;
+-        }
+-
+-        static final Priority[] PRIORITIES = Priority.values();
+-
+-        /** includes special priorities */
+-        public static final int TOTAL_PRIORITIES = PRIORITIES.length;
+-
+-        public static final int TOTAL_SCHEDULABLE_PRIORITIES = TOTAL_PRIORITIES - 1;
+-
+-        public static Priority getPriority(final int priority) {
+-            return PRIORITIES[priority + 1];
+-        }
+-
+-        private static int priorityCounter;
+-
+-        private static int nextCounter() {
+-            return priorityCounter++;
+-        }
+-
+-        public final int priority;
+-
+-        Priority() {
+-            this(nextCounter());
+-        }
+-
+-        Priority(final int priority) {
+-            this.priority = priority;
+-        }
+-    }
+-
+-    /**
+-     * Executes the next available task.
+-     * <p>
+-     *     If there is a task with priority {@link PrioritisedExecutor.Priority#BLOCKING} available, then that such task is executed.
+-     * </p>
+-     * <p>
+-     *     If there is a task with priority {@link PrioritisedExecutor.Priority#IDLE} available then that task is only executed
+-     *     when there are no other tasks available with a higher priority.
+-     * </p>
+-     * <p>
+-     *     If there are no tasks that have priority {@link PrioritisedExecutor.Priority#BLOCKING} or {@link PrioritisedExecutor.Priority#IDLE}, then
+-     *     this function will be biased to execute tasks that have higher priorities.
+-     * </p>
+-     *
+-     * @return {@code true} if a task was executed, {@code false} otherwise
+-     * @throws IllegalStateException If the current thread is not allowed to execute a task
+-     */
+-    @Override
+-    public boolean executeTask() throws IllegalStateException;
+-
+-    /**
+-     * Queues or executes a task at {@link Priority#NORMAL} priority.
+-     * @param task The task to run.
+-     *
+-     * @throws IllegalStateException If this queue has shutdown.
+-     * @throws NullPointerException If the task is null
+-     * @return {@code null} if the current thread immediately executed the task, else returns the prioritised task
+-     * associated with the parameter
+-     */
+-    public default PrioritisedTask queueRunnable(final Runnable task) {
+-        return this.queueRunnable(task, Priority.NORMAL);
+-    }
+-
+-    /**
+-     * Queues or executes a task.
+-     *
+-     * @param task The task to run.
+-     * @param priority The priority for the task.
+-     *
+-     * @throws IllegalStateException If this queue has shutdown.
+-     * @throws NullPointerException If the task is null
+-     * @throws IllegalArgumentException If the priority is invalid.
+-     * @return {@code null} if the current thread immediately executed the task, else returns the prioritised task
+-     * associated with the parameter
+-     */
+-    public PrioritisedTask queueRunnable(final Runnable task, final Priority priority);
+-
+-    /**
+-     * Creates, but does not execute or queue the task. The task must later be queued via {@link BaseTask#queue()}.
+-     *
+-     * @param task The task to run.
+-     *
+-     * @throws IllegalStateException If this queue has shutdown.
+-     * @throws NullPointerException If the task is null
+-     * @throws IllegalArgumentException If the priority is invalid.
+-     * @throws UnsupportedOperationException If this executor does not support lazily queueing tasks
+-     * @return The prioritised task associated with the parameters
+-     */
+-    public default PrioritisedTask createTask(final Runnable task) {
+-        return this.createTask(task, Priority.NORMAL);
+-    }
+-
+-    /**
+-     * Creates, but does not execute or queue the task. The task must later be queued via {@link BaseTask#queue()}.
+-     *
+-     * @param task The task to run.
+-     * @param priority The priority for the task.
+-     *
+-     * @throws IllegalStateException If this queue has shutdown.
+-     * @throws NullPointerException If the task is null
+-     * @throws IllegalArgumentException If the priority is invalid.
+-     * @throws UnsupportedOperationException If this executor does not support lazily queueing tasks
+-     * @return The prioritised task associated with the parameters
+-     */
+-    public PrioritisedTask createTask(final Runnable task, final Priority priority);
+-
+-    /**
+-     * Extension of {@link ca.spottedleaf.concurrentutil.executor.BaseExecutor.BaseTask} which adds functions
+-     * to retrieve and modify the task's associated priority.
+-     *
+-     * @see ca.spottedleaf.concurrentutil.executor.BaseExecutor.BaseTask
+-     */
+-    public static interface PrioritisedTask extends BaseTask {
+-
+-        /**
+-         * Returns the current priority. Note that {@link Priority#COMPLETING} will be returned
+-         * if this task is completing or has completed.
+-         */
+-        public Priority getPriority();
+-
+-        /**
+-         * Attempts to set this task's priority level to the level specified.
+-         *
+-         * @param priority Specified priority level.
+-         *
+-         * @throws IllegalArgumentException If the priority is invalid
+-         * @return {@code true} if successful, {@code false} if this task is completing or has completed or the queue
+-         * this task was scheduled on was shutdown, or if the priority was already at the specified level.
+-         */
+-        public boolean setPriority(final Priority priority);
+-
+-        /**
+-         * Attempts to raise the priority to the priority level specified.
+-         *
+-         * @param priority Priority specified
+-         *
+-         * @throws IllegalArgumentException If the priority is invalid
+-         * @return {@code false} if the current task is completing, {@code true} if the priority was raised to the specified level or was already at the specified level or higher.
+-         */
+-        public boolean raisePriority(final Priority priority);
+-
+-        /**
+-         * Attempts to lower the priority to the priority level specified.
+-         *
+-         * @param priority Priority specified
+-         *
+-         * @throws IllegalArgumentException If the priority is invalid
+-         * @return {@code false} if the current task is completing, {@code true} if the priority was lowered to the specified level or was already at the specified level or lower.
+-         */
+-        public boolean lowerPriority(final Priority priority);
+-    }
+-}
+diff --git a/src/main/java/ca/spottedleaf/concurrentutil/executor/standard/PrioritisedThreadPool.java b/src/main/java/ca/spottedleaf/concurrentutil/executor/standard/PrioritisedThreadPool.java
+deleted file mode 100644
+index 2ba36e29d0d8693f2f5e6c6d195ca27f2a5099aa..0000000000000000000000000000000000000000
+--- a/src/main/java/ca/spottedleaf/concurrentutil/executor/standard/PrioritisedThreadPool.java
++++ /dev/null
+@@ -1,632 +0,0 @@
+-package ca.spottedleaf.concurrentutil.executor.standard;
+-
+-import it.unimi.dsi.fastutil.objects.ReferenceOpenHashSet;
+-import org.slf4j.Logger;
+-import org.slf4j.LoggerFactory;
+-import java.util.ArrayList;
+-import java.util.Arrays;
+-import java.util.Comparator;
+-import java.util.TreeSet;
+-import java.util.concurrent.atomic.AtomicBoolean;
+-import java.util.function.BiConsumer;
+-
+-public final class PrioritisedThreadPool {
+-
+-    private static final Logger LOGGER = LoggerFactory.getLogger(PrioritisedThreadPool.class);
+-
+-    private final PrioritisedThread[] threads;
+-    private final TreeSet<PrioritisedPoolExecutorImpl> queues = new TreeSet<>(PrioritisedPoolExecutorImpl.comparator());
+-    private final String name;
+-    private final long queueMaxHoldTime;
+-
+-    private final ReferenceOpenHashSet<PrioritisedPoolExecutorImpl> nonShutdownQueues = new ReferenceOpenHashSet<>();
+-    private final ReferenceOpenHashSet<PrioritisedPoolExecutorImpl> activeQueues = new ReferenceOpenHashSet<>();
+-
+-    private boolean shutdown;
+-
+-    private long schedulingIdGenerator;
+-
+-    private static final long DEFAULT_QUEUE_HOLD_TIME = (long)(5.0e6);
+-
+-    /**
+-     * @param name Specified debug name of this thread pool
+-     * @param threads The number of threads to use
+-     */
+-    public PrioritisedThreadPool(final String name, final int threads) {
+-        this(name, threads, null);
+-    }
+-
+-    /**
+-     * @param name Specified debug name of this thread pool
+-     * @param threads The number of threads to use
+-     * @param threadModifier Invoked for each created thread with its incremental id before starting them
+-     */
+-    public PrioritisedThreadPool(final String name, final int threads, final BiConsumer<Thread, Integer> threadModifier) {
+-        this(name, threads, threadModifier, DEFAULT_QUEUE_HOLD_TIME); // 5ms
+-    }
+-
+-    /**
+-     * @param name Specified debug name of this thread pool
+-     * @param threads The number of threads to use
+-     * @param threadModifier Invoked for each created thread with its incremental id before starting them
+-     * @param queueHoldTime The maximum amount of time to spend executing tasks in a specific queue before attempting
+-     *                      to switch to another queue, per thread
+-     */
+-    public PrioritisedThreadPool(final String name, final int threads, final BiConsumer<Thread, Integer> threadModifier,
+-                                 final long queueHoldTime) { // in ns
+-        if (threads <= 0) {
+-            throw new IllegalArgumentException("Thread count must be > 0, not " + threads);
+-        }
+-        if (name == null) {
+-            throw new IllegalArgumentException("Name cannot be null");
+-        }
+-        this.name = name;
+-        this.queueMaxHoldTime = queueHoldTime;
+-
+-        this.threads = new PrioritisedThread[threads];
+-        for (int i = 0; i < threads; ++i) {
+-            this.threads[i] = new PrioritisedThread(this);
+-
+-            // set default attributes
+-            this.threads[i].setName("Prioritised thread for pool '" + name + "' #" + i);
+-            this.threads[i].setUncaughtExceptionHandler((final Thread thread, final Throwable throwable) -> {
+-                LOGGER.error("Uncaught exception in thread " + thread.getName(), throwable);
+-            });
+-
+-            // let thread modifier override defaults
+-            if (threadModifier != null) {
+-                threadModifier.accept(this.threads[i], Integer.valueOf(i));
+-            }
+-
+-            // now the thread can start
+-            this.threads[i].start();
+-        }
+-    }
+-
+-    /**
+-     * Returns an array representing the threads backing this thread pool.
+-     */
+-    public Thread[] getThreads() {
+-        return Arrays.copyOf(this.threads, this.threads.length, Thread[].class);
+-    }
+-
+-    /**
+-     * Creates and returns a {@link PrioritisedPoolExecutor} to schedule tasks onto. The returned executor will execute
+-     * tasks on this thread pool only.
+-     * @param name The debug name of the executor.
+-     * @param minParallelism The minimum number of threads to be executing tasks from the returned executor
+-     *                       before threads may be allocated to other queues in this thread pool.
+-     * @param parallelism The maximum number of threads which may be executing tasks from the returned executor.
+-     * @throws IllegalStateException If this thread pool is shut down
+-     */
+-    public PrioritisedPoolExecutor createExecutor(final String name, final int minParallelism, final int parallelism) {
+-        synchronized (this.nonShutdownQueues) {
+-            if (this.shutdown) {
+-                throw new IllegalStateException("Queue is shutdown: " + this.toString());
+-            }
+-            final PrioritisedPoolExecutorImpl ret = new PrioritisedPoolExecutorImpl(
+-                    this, name,
+-                    Math.min(Math.max(1, parallelism), this.threads.length),
+-                    Math.min(Math.max(0, minParallelism), this.threads.length)
+-            );
+-
+-            this.nonShutdownQueues.add(ret);
+-
+-            synchronized (this.activeQueues) {
+-                this.activeQueues.add(ret);
+-            }
+-
+-            return ret;
+-        }
+-    }
+-
+-    /**
+-     * Prevents creation of new queues, shutdowns all non-shutdown queues if specified
+-     */
+-    public void halt(final boolean shutdownQueues) {
+-        synchronized (this.nonShutdownQueues) {
+-            this.shutdown = true;
+-        }
+-        if (shutdownQueues) {
+-            final ArrayList<PrioritisedPoolExecutorImpl> queuesToShutdown;
+-            synchronized (this.nonShutdownQueues) {
+-                this.shutdown = true;
+-                queuesToShutdown = new ArrayList<>(this.nonShutdownQueues);
+-            }
+-
+-            for (final PrioritisedPoolExecutorImpl queue : queuesToShutdown) {
+-                queue.shutdown();
+-            }
+-        }
+-
+-
+-        for (final PrioritisedThread thread : this.threads) {
+-            // can't kill queue, queue is null
+-            thread.halt(false);
+-        }
+-    }
+-
+-    /**
+-     * Waits until all threads in this pool have shutdown, or until the specified time has passed.
+-     * @param msToWait Maximum time to wait.
+-     * @return {@code false} if the maximum time passed, {@code true} otherwise.
+-     */
+-    public boolean join(final long msToWait) {
+-        try {
+-            return this.join(msToWait, false);
+-        } catch (final InterruptedException ex) {
+-            throw new IllegalStateException(ex);
+-        }
+-    }
+-
+-    /**
+-     * Waits until all threads in this pool have shutdown, or until the specified time has passed.
+-     * @param msToWait Maximum time to wait.
+-     * @return {@code false} if the maximum time passed, {@code true} otherwise.
+-     * @throws InterruptedException If this thread is interrupted.
+-     */
+-    public boolean joinInterruptable(final long msToWait) throws InterruptedException {
+-        return this.join(msToWait, true);
+-    }
+-
+-    protected final boolean join(final long msToWait, final boolean interruptable) throws InterruptedException {
+-        final long nsToWait = msToWait * (1000 * 1000);
+-        final long start = System.nanoTime();
+-        final long deadline = start + nsToWait;
+-        boolean interrupted = false;
+-        try {
+-            for (final PrioritisedThread thread : this.threads) {
+-                for (;;) {
+-                    if (!thread.isAlive()) {
+-                        break;
+-                    }
+-                    final long current = System.nanoTime();
+-                    if (current >= deadline) {
+-                        return false;
+-                    }
+-
+-                    try {
+-                        thread.join(Math.max(1L, (deadline - current) / (1000 * 1000)));
+-                    } catch (final InterruptedException ex) {
+-                        if (interruptable) {
+-                            throw ex;
+-                        }
+-                        interrupted = true;
+-                    }
+-                }
+-            }
+-
+-            return true;
+-        } finally {
+-            if (interrupted) {
+-                Thread.currentThread().interrupt();
+-            }
+-        }
+-    }
+-
+-    /**
+-     * Shuts down this thread pool, optionally waiting for all tasks to be executed.
+-     * This function will invoke {@link PrioritisedPoolExecutor#shutdown()} on all created executors on this
+-     * thread pool.
+-     * @param wait Whether to wait for tasks to be executed
+-     */
+-    public void shutdown(final boolean wait) {
+-        final ArrayList<PrioritisedPoolExecutorImpl> queuesToShutdown;
+-        synchronized (this.nonShutdownQueues) {
+-            this.shutdown = true;
+-            queuesToShutdown = new ArrayList<>(this.nonShutdownQueues);
+-        }
+-
+-        for (final PrioritisedPoolExecutorImpl queue : queuesToShutdown) {
+-            queue.shutdown();
+-        }
+-
+-        for (final PrioritisedThread thread : this.threads) {
+-            // none of these can be true or else NPE
+-            thread.close(false, false);
+-        }
+-
+-        if (wait) {
+-            final ArrayList<PrioritisedPoolExecutorImpl> queues;
+-            synchronized (this.activeQueues) {
+-                queues = new ArrayList<>(this.activeQueues);
+-            }
+-            for (final PrioritisedPoolExecutorImpl queue : queues) {
+-                queue.waitUntilAllExecuted();
+-            }
+-        }
+-    }
+-
+-    protected static final class PrioritisedThread extends PrioritisedQueueExecutorThread {
+-
+-        protected final PrioritisedThreadPool pool;
+-        protected final AtomicBoolean alertedHighPriority = new AtomicBoolean();
+-
+-        public PrioritisedThread(final PrioritisedThreadPool pool) {
+-            super(null);
+-            this.pool = pool;
+-        }
+-
+-        public boolean alertHighPriorityExecutor() {
+-            if (!this.notifyTasks()) {
+-                if (!this.alertedHighPriority.get()) {
+-                    this.alertedHighPriority.set(true);
+-                }
+-                return false;
+-            }
+-
+-            return true;
+-        }
+-
+-        private boolean isAlertedHighPriority() {
+-            return this.alertedHighPriority.get() && this.alertedHighPriority.getAndSet(false);
+-        }
+-
+-        @Override
+-        protected boolean pollTasks() {
+-            final PrioritisedThreadPool pool = this.pool;
+-            final TreeSet<PrioritisedPoolExecutorImpl> queues = this.pool.queues;
+-
+-            boolean ret = false;
+-            for (;;) {
+-                if (this.halted) {
+-                    break;
+-                }
+-                // try to find a queue
+-                // note that if and ONLY IF the queues set is empty, this means there are no tasks for us to execute.
+-                // so we can only break when it's empty
+-                final PrioritisedPoolExecutorImpl queue;
+-                // select queue
+-                synchronized (queues) {
+-                    queue = queues.pollFirst();
+-                    if (queue == null) {
+-                        // no tasks to execute
+-                        break;
+-                    }
+-
+-                    queue.schedulingId = ++pool.schedulingIdGenerator;
+-                    // we own this queue now, so increment the executor count
+-                    // do we also need to push this queue up for grabs for another executor?
+-                    if (++queue.concurrentExecutors < queue.maximumExecutors) {
+-                        // re-add to queues
+-                        // it's very important this is done in the same synchronised block for polling, as this prevents
+-                        // us from possibly later adding a queue that should not exist in the set
+-                        queues.add(queue);
+-                        queue.isQueued = true;
+-                    } else {
+-                        queue.isQueued = false;
+-                    }
+-                    // note: we cannot drain entries from the queue while holding this lock, as it will cause deadlock
+-                    // the queue addition holds the per-queue lock first then acquires the lock we have now, but if we
+-                    // try to poll now we don't hold the per queue lock but we do hold the global lock...
+-                }
+-
+-                // parse tasks as long as we are allowed
+-                final long start = System.nanoTime();
+-                final long deadline = start + pool.queueMaxHoldTime;
+-                do {
+-                    try {
+-                        if (this.halted) {
+-                            break;
+-                        }
+-                        if (!queue.executeTask()) {
+-                            // no more tasks, try next queue
+-                            break;
+-                        }
+-                        ret = true;
+-                    } catch (final ThreadDeath death) {
+-                        throw death; // goodbye world...
+-                    } catch (final Throwable throwable) {
+-                        LOGGER.error("Exception thrown from thread '" + this.getName() + "' in queue '" + queue.toString() + "'", throwable);
+-                    }
+-                } while (!this.isAlertedHighPriority() && System.nanoTime() <= deadline);
+-
+-                synchronized (queues) {
+-                    // decrement executors, we are no longer executing
+-                    if (queue.isQueued) {
+-                        queues.remove(queue);
+-                        queue.isQueued = false;
+-                    }
+-                    if (--queue.concurrentExecutors == 0 && queue.scheduledPriority == null) {
+-                        // reset scheduling id once the queue is empty again
+-                        // this will ensure empty queues are not prioritised suddenly over active queues once tasks are
+-                        // queued
+-                        queue.schedulingId = 0L;
+-                    }
+-
+-                    // ensure the executor is queued for execution again
+-                    if (!queue.isHalted && queue.scheduledPriority != null) { // make sure it actually has tasks
+-                        queues.add(queue);
+-                        queue.isQueued = true;
+-                    }
+-                }
+-            }
+-
+-            return ret;
+-        }
+-    }
+-
+-    public interface PrioritisedPoolExecutor extends PrioritisedExecutor {
+-
+-        /**
+-         * Removes this queue from the thread pool without shutting the queue down or waiting for queued tasks to be executed
+-         */
+-        public void halt();
+-
+-        /**
+-         * Returns whether this executor is scheduled to run tasks or is running tasks, otherwise it returns whether
+-         * this queue is not halted and not shutdown.
+-         */
+-        public boolean isActive();
+-    }
+-
+-    protected static final class PrioritisedPoolExecutorImpl extends PrioritisedThreadedTaskQueue implements PrioritisedPoolExecutor {
+-
+-        protected final PrioritisedThreadPool pool;
+-        protected final long[] priorityCounts = new long[Priority.TOTAL_SCHEDULABLE_PRIORITIES];
+-        protected long schedulingId;
+-        protected int concurrentExecutors;
+-        protected Priority scheduledPriority;
+-
+-        protected final String name;
+-        protected final int maximumExecutors;
+-        protected final int minimumExecutors;
+-        protected boolean isQueued;
+-
+-        public PrioritisedPoolExecutorImpl(final PrioritisedThreadPool pool, final String name, final int maximumExecutors, final int minimumExecutors) {
+-            this.pool = pool;
+-            this.name = name;
+-            this.maximumExecutors = maximumExecutors;
+-            this.minimumExecutors = minimumExecutors;
+-        }
+-
+-        public static Comparator<PrioritisedPoolExecutorImpl> comparator() {
+-            return (final PrioritisedPoolExecutorImpl p1, final PrioritisedPoolExecutorImpl p2) -> {
+-                if (p1 == p2) {
+-                    return 0;
+-                }
+-
+-                final int belowMin1 = p1.minimumExecutors - p1.concurrentExecutors;
+-                final int belowMin2 = p2.minimumExecutors - p2.concurrentExecutors;
+-
+-                // test minimum executors
+-                if (belowMin1 > 0 || belowMin2 > 0) {
+-                    // want the largest belowMin to be first
+-                    final int minCompare = Integer.compare(belowMin2, belowMin1);
+-
+-                    if (minCompare != 0) {
+-                        return minCompare;
+-                    }
+-                }
+-
+-                // prefer higher priority
+-                final int priorityCompare = p1.scheduledPriority.ordinal() - p2.scheduledPriority.ordinal();
+-                if (priorityCompare != 0) {
+-                    return priorityCompare;
+-                }
+-
+-                // try to spread out the executors so that each can have threads executing
+-                final int executorCompare = p1.concurrentExecutors - p2.concurrentExecutors;
+-                if (executorCompare != 0) {
+-                    return executorCompare;
+-                }
+-
+-                // if all else fails here we just choose whichever executor was queued first
+-                return Long.compare(p1.schedulingId, p2.schedulingId);
+-            };
+-        }
+-
+-        private boolean isHalted;
+-
+-        @Override
+-        public void halt() {
+-            final PrioritisedThreadPool pool = this.pool;
+-            final TreeSet<PrioritisedPoolExecutorImpl> queues = pool.queues;
+-            synchronized (queues) {
+-                if (this.isHalted) {
+-                    return;
+-                }
+-                this.isHalted = true;
+-                if (this.isQueued) {
+-                    queues.remove(this);
+-                    this.isQueued = false;
+-                }
+-            }
+-            synchronized (pool.nonShutdownQueues) {
+-                pool.nonShutdownQueues.remove(this);
+-            }
+-            synchronized (pool.activeQueues) {
+-                pool.activeQueues.remove(this);
+-            }
+-        }
+-
+-        @Override
+-        public boolean isActive() {
+-            final PrioritisedThreadPool pool = this.pool;
+-            final TreeSet<PrioritisedPoolExecutorImpl> queues = pool.queues;
+-
+-            synchronized (queues) {
+-                if (this.concurrentExecutors != 0) {
+-                    return true;
+-                }
+-                synchronized (pool.activeQueues) {
+-                    if (pool.activeQueues.contains(this)) {
+-                        return true;
+-                    }
+-                }
+-            }
+-
+-            return false;
+-        }
+-
+-        private long totalQueuedTasks = 0L;
+-
+-        @Override
+-        protected void priorityChange(final PrioritisedThreadedTaskQueue.PrioritisedTask task, final Priority from, final Priority to) {
+-            // Note: The superclass' queue lock is ALWAYS held when inside this method. So we do NOT need to do any additional synchronisation
+-            // for accessing this queue's state.
+-            final long[] priorityCounts = this.priorityCounts;
+-            final boolean shutdown = this.isShutdown();
+-
+-            if (from == null && to == Priority.COMPLETING) {
+-                throw new IllegalStateException("Cannot complete task without queueing it first");
+-            }
+-
+-            // we should only notify for queueing of tasks, not changing priorities
+-            final boolean shouldNotifyTasks = from == null;
+-
+-            final Priority scheduledPriority = this.scheduledPriority;
+-            if (from != null) {
+-                --priorityCounts[from.priority];
+-            }
+-            if (to != Priority.COMPLETING) {
+-                ++priorityCounts[to.priority];
+-            }
+-            final long totalQueuedTasks;
+-            if (to == Priority.COMPLETING) {
+-                totalQueuedTasks = --this.totalQueuedTasks;
+-            } else if (from == null) {
+-                totalQueuedTasks = ++this.totalQueuedTasks;
+-            } else {
+-                totalQueuedTasks = this.totalQueuedTasks;
+-            }
+-
+-            // find new highest priority
+-            int highest = Math.min(to == Priority.COMPLETING ? Priority.IDLE.priority : to.priority, scheduledPriority == null ? Priority.IDLE.priority : scheduledPriority.priority);
+-            int lowestPriority = priorityCounts.length; // exclusive
+-            for (;highest < lowestPriority; ++highest) {
+-                final long count = priorityCounts[highest];
+-                if (count < 0) {
+-                    throw new IllegalStateException("Priority " + highest + " has " + count + " scheduled tasks");
+-                }
+-
+-                if (count != 0) {
+-                    break;
+-                }
+-            }
+-
+-            final Priority newPriority;
+-            if (highest == lowestPriority) {
+-                // no tasks left
+-                newPriority = null;
+-            } else if (shutdown) {
+-                // whichever is lower, the actual greatest priority or simply HIGHEST
+-                // this is so shutdown automatically gets priority
+-                newPriority = Priority.getPriority(Math.min(highest, Priority.HIGHEST.priority));
+-            } else {
+-                newPriority = Priority.getPriority(highest);
+-            }
+-
+-            final int executorsWanted;
+-            boolean shouldNotifyHighPriority = false;
+-
+-            final PrioritisedThreadPool pool = this.pool;
+-            final TreeSet<PrioritisedPoolExecutorImpl> queues = pool.queues;
+-
+-            synchronized (queues) {
+-                if (!this.isQueued) {
+-                    // see if we need to be queued
+-                    if (newPriority != null) {
+-                        if (this.schedulingId == 0L) {
+-                            this.schedulingId = ++pool.schedulingIdGenerator;
+-                        }
+-                        this.scheduledPriority = newPriority; // must be updated before queue add
+-                        if (!this.isHalted && this.concurrentExecutors < this.maximumExecutors) {
+-                            shouldNotifyHighPriority = newPriority.isHigherOrEqualPriority(Priority.HIGH);
+-                            queues.add(this);
+-                            this.isQueued = true;
+-                        }
+-                    } else {
+-                        // do not queue
+-                        this.scheduledPriority = null;
+-                    }
+-                } else {
+-                    // see if we need to NOT be queued
+-                    if (newPriority == null) {
+-                        queues.remove(this);
+-                        this.scheduledPriority = null;
+-                        this.isQueued = false;
+-                    } else if (scheduledPriority != newPriority) {
+-                        // if our priority changed, we need to update it - which means removing and re-adding into the queue
+-                        queues.remove(this);
+-                        // only now can we update scheduledPriority, since we are no longer in queue
+-                        this.scheduledPriority = newPriority;
+-                        queues.add(this);
+-                        shouldNotifyHighPriority = (scheduledPriority == null || scheduledPriority.isLowerPriority(Priority.HIGH)) && newPriority.isHigherOrEqualPriority(Priority.HIGH);
+-                    }
+-                }
+-
+-                if (this.isQueued) {
+-                    executorsWanted = Math.min(this.maximumExecutors - this.concurrentExecutors, (int)totalQueuedTasks);
+-                } else {
+-                    executorsWanted = 0;
+-                }
+-            }
+-
+-            if (newPriority == null && shutdown) {
+-                synchronized (pool.activeQueues) {
+-                    pool.activeQueues.remove(this);
+-                }
+-            }
+-
+-            // Wake up the number of executors we want
+-            if (executorsWanted > 0 || (shouldNotifyTasks | shouldNotifyHighPriority)) {
+-                int notified = 0;
+-                for (final PrioritisedThread thread : pool.threads) {
+-                    if ((shouldNotifyHighPriority ? thread.alertHighPriorityExecutor() : thread.notifyTasks())
+-                            && (++notified >= executorsWanted)) {
+-                        break;
+-                    }
+-                }
+-            }
+-        }
+-
+-        @Override
+-        public boolean shutdown() {
+-            final boolean ret = super.shutdown();
+-            if (!ret) {
+-                return ret;
+-            }
+-
+-            final PrioritisedThreadPool pool = this.pool;
+-
+-            // remove from active queues
+-            synchronized (pool.nonShutdownQueues) {
+-                pool.nonShutdownQueues.remove(this);
+-            }
+-
+-            final TreeSet<PrioritisedPoolExecutorImpl> queues = pool.queues;
+-
+-            // try and shift around our priority
+-            synchronized (queues) {
+-                if (this.scheduledPriority == null) {
+-                    // no tasks are queued, ensure we aren't in activeQueues
+-                    synchronized (pool.activeQueues) {
+-                        pool.activeQueues.remove(this);
+-                    }
+-
+-                    return ret;
+-                }
+-
+-                // try to set scheduled priority to HIGHEST so it drains faster
+-
+-                if (this.scheduledPriority.isHigherOrEqualPriority(Priority.HIGHEST)) {
+-                    // already at target priority (highest or above)
+-                    return ret;
+-                }
+-
+-                // shift priority to HIGHEST
+-
+-                if (this.isQueued) {
+-                    queues.remove(this);
+-                    this.scheduledPriority = Priority.HIGHEST;
+-                    queues.add(this);
+-                } else {
+-                    this.scheduledPriority = Priority.HIGHEST;
+-                }
+-            }
+-
+-            return ret;
+-        }
+-    }
+-}
+diff --git a/src/main/java/ca/spottedleaf/concurrentutil/executor/standard/PrioritisedThreadedTaskQueue.java b/src/main/java/ca/spottedleaf/concurrentutil/executor/standard/PrioritisedThreadedTaskQueue.java
+deleted file mode 100644
+index 3e8401b1b1f833c4f01bc87059a2f48d761d989f..0000000000000000000000000000000000000000
+--- a/src/main/java/ca/spottedleaf/concurrentutil/executor/standard/PrioritisedThreadedTaskQueue.java
++++ /dev/null
+@@ -1,378 +0,0 @@
+-package ca.spottedleaf.concurrentutil.executor.standard;
+-
+-import java.util.ArrayDeque;
+-import java.util.concurrent.atomic.AtomicLong;
+-
+-public class PrioritisedThreadedTaskQueue implements PrioritisedExecutor {
+-
+-    protected final ArrayDeque<PrioritisedTask>[] queues = new ArrayDeque[Priority.TOTAL_SCHEDULABLE_PRIORITIES]; {
+-        for (int i = 0; i < Priority.TOTAL_SCHEDULABLE_PRIORITIES; ++i) {
+-            this.queues[i] = new ArrayDeque<>();
+-        }
+-    }
+-
+-    // Use AtomicLong to separate from the queue field, we don't want false sharing here.
+-    protected final AtomicLong totalScheduledTasks = new AtomicLong();
+-    protected final AtomicLong totalCompletedTasks = new AtomicLong();
+-
+-    // this is here to prevent failures to queue stalling flush() calls (as the schedule calls would increment totalScheduledTasks without this check)
+-    protected volatile boolean hasShutdown;
+-
+-    protected long taskIdGenerator = 0;
+-
+-    @Override
+-    public PrioritisedExecutor.PrioritisedTask queueRunnable(final Runnable task, final Priority priority) throws IllegalStateException, IllegalArgumentException {
+-        if (!Priority.isValidPriority(priority)) {
+-            throw new IllegalArgumentException("Priority " + priority + " is invalid");
+-        }
+-        if (task == null) {
+-            throw new NullPointerException("Task cannot be null");
+-        }
+-
+-        if (this.hasShutdown) {
+-            // prevent us from stalling flush() calls by incrementing scheduled tasks when we really didn't schedule something
+-            throw new IllegalStateException("Queue has shutdown");
+-        }
+-
+-        final PrioritisedTask ret;
+-
+-        synchronized (this.queues) {
+-            if (this.hasShutdown) {
+-                throw new IllegalStateException("Queue has shutdown");
+-            }
+-            this.getAndAddTotalScheduledTasksVolatile(1L);
+-
+-            ret = new PrioritisedTask(this.taskIdGenerator++, task, priority, this);
+-
+-            this.queues[ret.priority.priority].add(ret);
+-
+-            // call priority change callback (note: only after we successfully queue!)
+-            this.priorityChange(ret, null, priority);
+-        }
+-
+-        return ret;
+-    }
+-
+-    @Override
+-    public PrioritisedExecutor.PrioritisedTask createTask(final Runnable task, final Priority priority) {
+-        if (!Priority.isValidPriority(priority)) {
+-            throw new IllegalArgumentException("Priority " + priority + " is invalid");
+-        }
+-        if (task == null) {
+-            throw new NullPointerException("Task cannot be null");
+-        }
+-
+-        return new PrioritisedTask(task, priority, this);
+-    }
+-
+-    @Override
+-    public long getTotalTasksScheduled() {
+-        return this.totalScheduledTasks.get();
+-    }
+-
+-    @Override
+-    public long getTotalTasksExecuted() {
+-        return this.totalCompletedTasks.get();
+-    }
+-
+-    // callback method for subclasses to override
+-    // from is null when a task is immediately created
+-    protected void priorityChange(final PrioritisedTask task, final Priority from, final Priority to) {}
+-
+-    /**
+-     * Polls the highest priority task currently available. {@code null} if none. This will mark the
+-     * returned task as completed.
+-     */
+-    protected PrioritisedTask poll() {
+-        return this.poll(Priority.IDLE);
+-    }
+-
+-    protected PrioritisedTask poll(final Priority minPriority) {
+-        final ArrayDeque<PrioritisedTask>[] queues = this.queues;
+-        synchronized (queues) {
+-            final int max = minPriority.priority;
+-            for (int i = 0; i <= max; ++i) {
+-                final ArrayDeque<PrioritisedTask> queue = queues[i];
+-                PrioritisedTask task;
+-                while ((task = queue.pollFirst()) != null) {
+-                    if (task.trySetCompleting(i)) {
+-                        return task;
+-                    }
+-                }
+-            }
+-        }
+-
+-        return null;
+-    }
+-
+-    /**
+-     * Polls and executes the highest priority task currently available. Exceptions thrown during task execution will
+-     * be rethrown.
+-     * @return {@code true} if a task was executed, {@code false} otherwise.
+-     */
+-    @Override
+-    public boolean executeTask() {
+-        final PrioritisedTask task = this.poll();
+-
+-        if (task != null) {
+-            task.executeInternal();
+-            return true;
+-        }
+-
+-        return false;
+-    }
+-
+-    @Override
+-    public boolean shutdown() {
+-        synchronized (this.queues) {
+-            if (this.hasShutdown) {
+-                return false;
+-            }
+-            this.hasShutdown = true;
+-        }
+-        return true;
+-    }
+-
+-    @Override
+-    public boolean isShutdown() {
+-        return this.hasShutdown;
+-    }
+-
+-    /* totalScheduledTasks */
+-
+-    protected final long getTotalScheduledTasksVolatile() {
+-        return this.totalScheduledTasks.get();
+-    }
+-
+-    protected final long getAndAddTotalScheduledTasksVolatile(final long value) {
+-        return this.totalScheduledTasks.getAndAdd(value);
+-    }
+-
+-    /* totalCompletedTasks */
+-
+-    protected final long getTotalCompletedTasksVolatile() {
+-        return this.totalCompletedTasks.get();
+-    }
+-
+-    protected final long getAndAddTotalCompletedTasksVolatile(final long value) {
+-        return this.totalCompletedTasks.getAndAdd(value);
+-    }
+-
+-    protected static final class PrioritisedTask implements PrioritisedExecutor.PrioritisedTask {
+-        protected final PrioritisedThreadedTaskQueue queue;
+-        protected long id;
+-        protected static final long NOT_SCHEDULED_ID = -1L;
+-
+-        protected Runnable runnable;
+-        protected volatile Priority priority;
+-
+-        protected PrioritisedTask(final long id, final Runnable runnable, final Priority priority, final PrioritisedThreadedTaskQueue queue) {
+-            if (!Priority.isValidPriority(priority)) {
+-                throw new IllegalArgumentException("Invalid priority " + priority);
+-            }
+-
+-            this.priority = priority;
+-            this.runnable = runnable;
+-            this.queue = queue;
+-            this.id = id;
+-        }
+-
+-        protected PrioritisedTask(final Runnable runnable, final Priority priority, final PrioritisedThreadedTaskQueue queue) {
+-            if (!Priority.isValidPriority(priority)) {
+-                throw new IllegalArgumentException("Invalid priority " + priority);
+-            }
+-
+-            this.priority = priority;
+-            this.runnable = runnable;
+-            this.queue = queue;
+-            this.id = NOT_SCHEDULED_ID;
+-        }
+-
+-        @Override
+-        public boolean queue() {
+-            if (this.queue.hasShutdown) {
+-                throw new IllegalStateException("Queue has shutdown");
+-            }
+-
+-            synchronized (this.queue.queues) {
+-                if (this.queue.hasShutdown) {
+-                    throw new IllegalStateException("Queue has shutdown");
+-                }
+-
+-                final Priority priority = this.priority;
+-                if (priority == Priority.COMPLETING) {
+-                    return false;
+-                }
+-
+-                if (this.id != NOT_SCHEDULED_ID) {
+-                    return false;
+-                }
+-
+-                this.queue.getAndAddTotalScheduledTasksVolatile(1L);
+-                this.id = this.queue.taskIdGenerator++;
+-                this.queue.queues[priority.priority].add(this);
+-
+-                this.queue.priorityChange(this, null, priority);
+-
+-                return true;
+-            }
+-        }
+-
+-        protected boolean trySetCompleting(final int minPriority) {
+-            final Priority oldPriority = this.priority;
+-            if (oldPriority != Priority.COMPLETING && oldPriority.isHigherOrEqualPriority(minPriority)) {
+-                this.priority = Priority.COMPLETING;
+-                if (this.id != NOT_SCHEDULED_ID) {
+-                    this.queue.priorityChange(this, oldPriority, Priority.COMPLETING);
+-                }
+-                return true;
+-            }
+-
+-            return false;
+-        }
+-
+-        @Override
+-        public Priority getPriority() {
+-            return this.priority;
+-        }
+-
+-        @Override
+-        public boolean setPriority(final Priority priority) {
+-            if (!Priority.isValidPriority(priority)) {
+-                throw new IllegalArgumentException("Invalid priority " + priority);
+-            }
+-            synchronized (this.queue.queues) {
+-                final Priority curr = this.priority;
+-
+-                if (curr == Priority.COMPLETING) {
+-                    return false;
+-                }
+-
+-                if (curr == priority) {
+-                    return true;
+-                }
+-
+-                this.priority = priority;
+-                if (this.id != NOT_SCHEDULED_ID) {
+-                    this.queue.queues[priority.priority].add(this);
+-
+-                    // call priority change callback
+-                    this.queue.priorityChange(this, curr, priority);
+-                }
+-            }
+-
+-            return true;
+-        }
+-
+-        @Override
+-        public boolean raisePriority(final Priority priority) {
+-            if (!Priority.isValidPriority(priority)) {
+-                throw new IllegalArgumentException("Invalid priority " + priority);
+-            }
+-
+-            synchronized (this.queue.queues) {
+-                final Priority curr = this.priority;
+-
+-                if (curr == Priority.COMPLETING) {
+-                    return false;
+-                }
+-
+-                if (curr.isHigherOrEqualPriority(priority)) {
+-                    return true;
+-                }
+-
+-                this.priority = priority;
+-                if (this.id != NOT_SCHEDULED_ID) {
+-                    this.queue.queues[priority.priority].add(this);
+-
+-                    // call priority change callback
+-                    this.queue.priorityChange(this, curr, priority);
+-                }
+-            }
+-
+-            return true;
+-        }
+-
+-        @Override
+-        public boolean lowerPriority(final Priority priority) {
+-            if (!Priority.isValidPriority(priority)) {
+-                throw new IllegalArgumentException("Invalid priority " + priority);
+-            }
+-
+-            synchronized (this.queue.queues) {
+-                final Priority curr = this.priority;
+-
+-                if (curr == Priority.COMPLETING) {
+-                    return false;
+-                }
+-
+-                if (curr.isLowerOrEqualPriority(priority)) {
+-                    return true;
+-                }
+-
+-                this.priority = priority;
+-                if (this.id != NOT_SCHEDULED_ID) {
+-                    this.queue.queues[priority.priority].add(this);
+-
+-                    // call priority change callback
+-                    this.queue.priorityChange(this, curr, priority);
+-                }
+-            }
+-
+-            return true;
+-        }
+-
+-        @Override
+-        public boolean cancel() {
+-            final long id;
+-            synchronized (this.queue.queues) {
+-                final Priority oldPriority = this.priority;
+-                if (oldPriority == Priority.COMPLETING) {
+-                    return false;
+-                }
+-
+-                this.priority = Priority.COMPLETING;
+-                // call priority change callback
+-                if ((id = this.id) != NOT_SCHEDULED_ID) {
+-                    this.queue.priorityChange(this, oldPriority, Priority.COMPLETING);
+-                }
+-            }
+-            this.runnable = null;
+-            if (id != NOT_SCHEDULED_ID) {
+-                this.queue.getAndAddTotalCompletedTasksVolatile(1L);
+-            }
+-            return true;
+-        }
+-
+-        protected void executeInternal() {
+-            try {
+-                final Runnable execute = this.runnable;
+-                this.runnable = null;
+-                execute.run();
+-            } finally {
+-                if (this.id != NOT_SCHEDULED_ID) {
+-                    this.queue.getAndAddTotalCompletedTasksVolatile(1L);
+-                }
+-            }
+-        }
+-
+-        @Override
+-        public boolean execute() {
+-            synchronized (this.queue.queues) {
+-                final Priority oldPriority = this.priority;
+-                if (oldPriority == Priority.COMPLETING) {
+-                    return false;
+-                }
+-
+-                this.priority = Priority.COMPLETING;
+-                // call priority change callback
+-                if (this.id != NOT_SCHEDULED_ID) {
+-                    this.queue.priorityChange(this, oldPriority, Priority.COMPLETING);
+-                }
+-            }
+-
+-            this.executeInternal();
+-            return true;
+-        }
+-    }
+-}
+diff --git a/src/main/java/ca/spottedleaf/concurrentutil/executor/standard/PrioritisedQueueExecutorThread.java b/src/main/java/ca/spottedleaf/concurrentutil/executor/thread/PrioritisedQueueExecutorThread.java
+similarity index 60%
+rename from src/main/java/ca/spottedleaf/concurrentutil/executor/standard/PrioritisedQueueExecutorThread.java
+rename to src/main/java/ca/spottedleaf/concurrentutil/executor/thread/PrioritisedQueueExecutorThread.java
+index d1683ba6350e530373944f98192c0f2baf241e70..f5367a13aaa02f0f929813c00a67e6ac7c8652cb 100644
+--- a/src/main/java/ca/spottedleaf/concurrentutil/executor/standard/PrioritisedQueueExecutorThread.java
++++ b/src/main/java/ca/spottedleaf/concurrentutil/executor/thread/PrioritisedQueueExecutorThread.java
+@@ -1,6 +1,8 @@
+-package ca.spottedleaf.concurrentutil.executor.standard;
++package ca.spottedleaf.concurrentutil.executor.thread;
+ 
++import ca.spottedleaf.concurrentutil.executor.PrioritisedExecutor;
+ import ca.spottedleaf.concurrentutil.util.ConcurrentUtil;
++import ca.spottedleaf.concurrentutil.util.Priority;
+ import org.slf4j.Logger;
+ import org.slf4j.LoggerFactory;
+ import java.lang.invoke.VarHandle;
+@@ -11,8 +13,7 @@ import java.util.concurrent.locks.LockSupport;
+  * <p>
+  *     Note: When using this thread, queue additions to the underlying {@link #queue} are not sufficient to get this thread
+  *     to execute the task. The function {@link #notifyTasks()} must be used after scheduling a task. For expected behaviour
+- *     of task scheduling (thread wakes up after tasks are scheduled), use the methods provided on {@link PrioritisedExecutor}
+- *     methods.
++ *     of task scheduling, use the methods provided on this class to schedule tasks.
+  * </p>
+  */
+ public class PrioritisedQueueExecutorThread extends Thread implements PrioritisedExecutor {
+@@ -30,7 +31,7 @@ public class PrioritisedQueueExecutorThread extends Thread implements Prioritise
+ 
+     protected final long spinWaitTime;
+ 
+-    static final long DEFAULT_SPINWAIT_TIME = (long)(0.1e6);// 0.1ms
++    protected static final long DEFAULT_SPINWAIT_TIME = (long)(0.1e6);// 0.1ms
+ 
+     public PrioritisedQueueExecutorThread(final PrioritisedExecutor queue) {
+         this(queue, DEFAULT_SPINWAIT_TIME); // 0.1ms
+@@ -42,7 +43,16 @@ public class PrioritisedQueueExecutorThread extends Thread implements Prioritise
+     }
+ 
+     @Override
+-    public void run() {
++    public final void run() {
++        try {
++            this.begin();
++            this.doRun();
++        } finally {
++            this.die();
++        }
++    }
++
++    public final void doRun() {
+         final long spinWaitTime = this.spinWaitTime;
+ 
+         main_loop:
+@@ -80,7 +90,7 @@ public class PrioritisedQueueExecutorThread extends Thread implements Prioritise
+             this.setThreadParkedVolatile(true);
+ 
+             // We need to parse here to avoid a race condition where a thread queues a task before we set parked to true
+-            // (i.e it will not notify us)
++            // (i.e. it will not notify us)
+             if (this.pollTasks()) {
+                 this.setThreadParkedVolatile(false);
+                 continue;
+@@ -99,6 +109,10 @@ public class PrioritisedQueueExecutorThread extends Thread implements Prioritise
+         }
+     }
+ 
++    protected void begin() {}
++
++    protected void die() {}
++
+     /**
+      * Attempts to poll as many tasks as possible, returning when finished.
+      * @return Whether any tasks were executed.
+@@ -115,8 +129,6 @@ public class PrioritisedQueueExecutorThread extends Thread implements Prioritise
+                     break;
+                 }
+                 ret = true;
+-            } catch (final ThreadDeath death) {
+-                throw death; // goodbye world...
+             } catch (final Throwable throwable) {
+                 LOGGER.error("Exception thrown from prioritized runnable task in thread '" + this.getName() + "'", throwable);
+             }
+@@ -146,95 +158,86 @@ public class PrioritisedQueueExecutorThread extends Thread implements Prioritise
+     }
+ 
+     @Override
+-    public PrioritisedTask createTask(final Runnable task, final Priority priority) {
+-        final PrioritisedTask queueTask = this.queue.createTask(task, priority);
+-
+-        // need to override queue() to notify us of tasks
+-        return new PrioritisedTask() {
+-            @Override
+-            public Priority getPriority() {
+-                return queueTask.getPriority();
+-            }
+-
+-            @Override
+-            public boolean setPriority(final Priority priority) {
+-                return queueTask.setPriority(priority);
+-            }
++    public long getTotalTasksExecuted() {
++        return this.queue.getTotalTasksExecuted();
++    }
+ 
+-            @Override
+-            public boolean raisePriority(final Priority priority) {
+-                return queueTask.raisePriority(priority);
+-            }
++    @Override
++    public long getTotalTasksScheduled() {
++        return this.queue.getTotalTasksScheduled();
++    }
+ 
+-            @Override
+-            public boolean lowerPriority(final Priority priority) {
+-                return queueTask.lowerPriority(priority);
+-            }
++    @Override
++    public long generateNextSubOrder() {
++        return this.queue.generateNextSubOrder();
++    }
+ 
+-            @Override
+-            public boolean queue() {
+-                final boolean ret = queueTask.queue();
+-                if (ret) {
+-                    PrioritisedQueueExecutorThread.this.notifyTasks();
+-                }
+-                return ret;
+-            }
++    @Override
++    public boolean shutdown() {
++        throw new UnsupportedOperationException();
++    }
+ 
+-            @Override
+-            public boolean cancel() {
+-                return queueTask.cancel();
+-            }
++    @Override
++    public boolean isShutdown() {
++        return false;
++    }
+ 
+-            @Override
+-            public boolean execute() {
+-                return queueTask.execute();
+-            }
+-        };
++    /**
++     * {@inheritDoc}
++     * @throws IllegalStateException Always
++     */
++    @Override
++    public boolean executeTask() throws IllegalStateException {
++        throw new IllegalStateException();
+     }
+ 
+     @Override
+-    public PrioritisedTask queueRunnable(final Runnable task, final Priority priority) {
+-        final PrioritisedTask ret = this.queue.queueRunnable(task, priority);
++    public PrioritisedTask queueTask(final Runnable task) {
++        final PrioritisedTask ret = this.createTask(task);
+ 
+-        this.notifyTasks();
++        ret.queue();
+ 
+         return ret;
+     }
+ 
+     @Override
+-    public boolean haveAllTasksExecuted() {
+-        return this.queue.haveAllTasksExecuted();
++    public PrioritisedTask queueTask(final Runnable task, final Priority priority) {
++        final PrioritisedTask ret = this.createTask(task, priority);
++
++        ret.queue();
++
++        return ret;
+     }
+ 
+     @Override
+-    public long getTotalTasksExecuted() {
+-        return this.queue.getTotalTasksExecuted();
++    public PrioritisedTask queueTask(final Runnable task, final Priority priority, final long subOrder) {
++        final PrioritisedTask ret = this.createTask(task, priority, subOrder);
++
++        ret.queue();
++
++        return ret;
+     }
+ 
++
+     @Override
+-    public long getTotalTasksScheduled() {
+-        return this.queue.getTotalTasksScheduled();
++    public PrioritisedTask createTask(Runnable task) {
++        final PrioritisedTask queueTask = this.queue.createTask(task);
++
++        return new WrappedTask(queueTask);
+     }
+ 
+-    /**
+-     * {@inheritDoc}
+-     * @throws IllegalStateException If the current thread is {@code this} thread, or the underlying queue throws this exception.
+-     */
+     @Override
+-    public void waitUntilAllExecuted() throws IllegalStateException {
+-        if (Thread.currentThread() == this) {
+-            throw new IllegalStateException("Cannot block on our own queue");
+-        }
+-        this.queue.waitUntilAllExecuted();
++    public PrioritisedTask createTask(final Runnable task, final Priority priority) {
++        final PrioritisedTask queueTask = this.queue.createTask(task, priority);
++
++        return new WrappedTask(queueTask);
+     }
+ 
+-    /**
+-     * {@inheritDoc}
+-     * @throws IllegalStateException Always
+-     */
+     @Override
+-    public boolean executeTask() throws IllegalStateException {
+-        throw new IllegalStateException();
++    public PrioritisedTask createTask(final Runnable task, final Priority priority, final long subOrder) {
++        final PrioritisedTask queueTask = this.queue.createTask(task, priority, subOrder);
++
++        return new WrappedTask(queueTask);
+     }
+ 
+     /**
+@@ -242,7 +245,7 @@ public class PrioritisedQueueExecutorThread extends Thread implements Prioritise
+      * <p>
+      *     This function is MT-Safe.
+      * </p>
+-     * @param wait If this call is to wait until the queue is empty and there are no tasks executing in the queue.
++     * @param wait If this call is to wait until this thread shuts down.
+      * @param killQueue Whether to shutdown this thread's queue
+      * @return whether this thread shut down the queue
+      * @see #halt(boolean)
+@@ -256,7 +259,20 @@ public class PrioritisedQueueExecutorThread extends Thread implements Prioritise
+         LockSupport.unpark(this);
+ 
+         if (wait) {
+-            this.waitUntilAllExecuted();
++            boolean interrupted = false;
++            for (;;) {
++                if (this.isAlive()) {
++                    if (interrupted) {
++                        Thread.currentThread().interrupt();
++                    }
++                    break;
++                }
++                try {
++                    this.join();
++                } catch (final InterruptedException ex) {
++                    interrupted = true;
++                }
++            }
+         }
+ 
+         return ret;
+@@ -298,4 +314,89 @@ public class PrioritisedQueueExecutorThread extends Thread implements Prioritise
+     protected final void setThreadParkedVolatile(final boolean value) {
+         THREAD_PARKED_HANDLE.setVolatile(this, value);
+     }
++
++    /**
++     * Required so that queue() can notify (unpark) this thread
++     */
++    private final class WrappedTask implements PrioritisedTask {
++        private final PrioritisedTask queueTask;
++
++        public WrappedTask(final PrioritisedTask queueTask) {
++            this.queueTask = queueTask;
++        }
++
++        @Override
++        public PrioritisedExecutor getExecutor() {
++            return PrioritisedQueueExecutorThread.this;
++        }
++
++        @Override
++        public boolean queue() {
++            final boolean ret = this.queueTask.queue();
++            if (ret) {
++                PrioritisedQueueExecutorThread.this.notifyTasks();
++            }
++            return ret;
++        }
++
++        @Override
++        public boolean isQueued() {
++            return this.queueTask.isQueued();
++        }
++
++        @Override
++        public boolean cancel() {
++            return this.queueTask.cancel();
++        }
++
++        @Override
++        public boolean execute() {
++            return this.queueTask.execute();
++        }
++
++        @Override
++        public Priority getPriority() {
++            return this.queueTask.getPriority();
++        }
++
++        @Override
++        public boolean setPriority(final Priority priority) {
++            return this.queueTask.setPriority(priority);
++        }
++
++        @Override
++        public boolean raisePriority(final Priority priority) {
++            return this.queueTask.raisePriority(priority);
++        }
++
++        @Override
++        public boolean lowerPriority(final Priority priority) {
++            return this.queueTask.lowerPriority(priority);
++        }
++
++        @Override
++        public long getSubOrder() {
++            return this.queueTask.getSubOrder();
++        }
++
++        @Override
++        public boolean setSubOrder(final long subOrder) {
++            return this.queueTask.setSubOrder(subOrder);
++        }
++
++        @Override
++        public boolean raiseSubOrder(final long subOrder) {
++            return this.queueTask.raiseSubOrder(subOrder);
++        }
++
++        @Override
++        public boolean lowerSubOrder(final long subOrder) {
++            return this.queueTask.lowerSubOrder(subOrder);
++        }
++
++        @Override
++        public boolean setPriorityAndSubOrder(final Priority priority, final long subOrder) {
++            return this.queueTask.setPriorityAndSubOrder(priority, subOrder);
++        }
++    }
+ }
+diff --git a/src/main/java/ca/spottedleaf/concurrentutil/executor/thread/PrioritisedThreadPool.java b/src/main/java/ca/spottedleaf/concurrentutil/executor/thread/PrioritisedThreadPool.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..cb9df914a9a6d0d3f58fa58d8c93f4f583416cd1
+--- /dev/null
++++ b/src/main/java/ca/spottedleaf/concurrentutil/executor/thread/PrioritisedThreadPool.java
+@@ -0,0 +1,741 @@
++package ca.spottedleaf.concurrentutil.executor.thread;
++
++import ca.spottedleaf.concurrentutil.executor.PrioritisedExecutor;
++import ca.spottedleaf.concurrentutil.executor.queue.PrioritisedTaskQueue;
++import ca.spottedleaf.concurrentutil.util.Priority;
++import ca.spottedleaf.concurrentutil.util.TimeUtil;
++import org.slf4j.Logger;
++import org.slf4j.LoggerFactory;
++import java.lang.reflect.Array;
++import java.util.Arrays;
++import java.util.concurrent.atomic.AtomicBoolean;
++import java.util.concurrent.atomic.AtomicLong;
++import java.util.function.Consumer;
++
++public final class PrioritisedThreadPool {
++
++    private static final Logger LOGGER = LoggerFactory.getLogger(PrioritisedThreadPool.class);
++
++    private final Consumer<Thread> threadModifier;
++    private final COWArrayList<ExecutorGroup> executors = new COWArrayList<>(ExecutorGroup.class);
++    private final COWArrayList<PrioritisedThread> threads = new COWArrayList<>(PrioritisedThread.class);
++    private final COWArrayList<PrioritisedThread> aliveThreads = new COWArrayList<>(PrioritisedThread.class);
++
++    private static final Priority HIGH_PRIORITY_NOTIFY_THRESHOLD = Priority.HIGH;
++    private static final Priority QUEUE_SHUTDOWN_PRIORITY = Priority.HIGH;
++
++    private boolean shutdown;
++
++    public PrioritisedThreadPool(final Consumer<Thread> threadModifier) {
++        this.threadModifier = threadModifier;
++
++        if (threadModifier == null) {
++            throw new NullPointerException("Thread factory may not be null");
++        }
++    }
++
++    public Thread[] getAliveThreads() {
++        final PrioritisedThread[] threads = this.aliveThreads.getArray();
++
++        return Arrays.copyOf(threads, threads.length, Thread[].class);
++    }
++
++    public Thread[] getCoreThreads() {
++        final PrioritisedThread[] threads = this.threads.getArray();
++
++        return Arrays.copyOf(threads, threads.length, Thread[].class);
++    }
++
++    /**
++     * Prevents creation of new queues, shutdowns all non-shutdown queues if specified
++     */
++    public void halt(final boolean shutdownQueues) {
++        synchronized (this) {
++            this.shutdown = true;
++        }
++
++        if (shutdownQueues) {
++            for (final ExecutorGroup group : this.executors.getArray()) {
++                for (final ExecutorGroup.ThreadPoolExecutor executor : group.executors.getArray()) {
++                    executor.shutdown();
++                }
++            }
++        }
++
++        for (final PrioritisedThread thread : this.threads.getArray()) {
++            thread.halt(false);
++        }
++    }
++
++    /**
++     * Waits until all threads in this pool have shutdown, or until the specified time has passed.
++     * @param msToWait Maximum time to wait.
++     * @return {@code false} if the maximum time passed, {@code true} otherwise.
++     */
++    public boolean join(final long msToWait) {
++        try {
++            return this.join(msToWait, false);
++        } catch (final InterruptedException ex) {
++            throw new IllegalStateException(ex);
++        }
++    }
++
++    /**
++     * Waits until all threads in this pool have shutdown, or until the specified time has passed.
++     * @param msToWait Maximum time to wait.
++     * @return {@code false} if the maximum time passed, {@code true} otherwise.
++     * @throws InterruptedException If this thread is interrupted.
++     */
++    public boolean joinInterruptable(final long msToWait) throws InterruptedException {
++        return this.join(msToWait, true);
++    }
++
++    protected final boolean join(final long msToWait, final boolean interruptable) throws InterruptedException {
++        final long nsToWait = msToWait * (1000 * 1000);
++        final long start = System.nanoTime();
++        final long deadline = start + nsToWait;
++        boolean interrupted = false;
++        try {
++            for (final PrioritisedThread thread : this.aliveThreads.getArray()) {
++                for (;;) {
++                    if (!thread.isAlive()) {
++                        break;
++                    }
++                    final long current = System.nanoTime();
++                    if (current >= deadline && msToWait > 0L) {
++                        return false;
++                    }
++
++                    try {
++                        thread.join(msToWait <= 0L ? 0L : Math.max(1L, (deadline - current) / (1000 * 1000)));
++                    } catch (final InterruptedException ex) {
++                        if (interruptable) {
++                            throw ex;
++                        }
++                        interrupted = true;
++                    }
++                }
++            }
++
++            return true;
++        } finally {
++            if (interrupted) {
++                Thread.currentThread().interrupt();
++            }
++        }
++    }
++
++    /**
++     * Shuts down this thread pool, optionally waiting for all tasks to be executed.
++     * This function will invoke {@link PrioritisedExecutor#shutdown()} on all created executors on this
++     * thread pool.
++     * @param wait Whether to wait for tasks to be executed
++     */
++    public void shutdown(final boolean wait) {
++        synchronized (this) {
++            this.shutdown = true;
++        }
++
++        for (final ExecutorGroup group : this.executors.getArray()) {
++            for (final ExecutorGroup.ThreadPoolExecutor executor : group.executors.getArray()) {
++                executor.shutdown();
++            }
++        }
++
++
++        for (final PrioritisedThread thread : this.threads.getArray()) {
++            // none of these can be true or else NPE
++            thread.close(false, false);
++        }
++
++        if (wait) {
++            this.join(0L);
++        }
++    }
++
++    private void die(final PrioritisedThread thread) {
++        this.aliveThreads.remove(thread);
++    }
++
++    public void adjustThreadCount(final int threads) {
++        synchronized (this) {
++            if (this.shutdown) {
++                return;
++            }
++
++            final PrioritisedThread[] currentThreads = this.threads.getArray();
++            if (threads == currentThreads.length) {
++                // no adjustment needed
++                return;
++            }
++
++            if (threads < currentThreads.length) {
++                // we need to trim threads
++                for (int i = 0, difference = currentThreads.length - threads; i < difference; ++i) {
++                    final PrioritisedThread remove = currentThreads[currentThreads.length - i - 1];
++
++                    remove.halt(false);
++                    this.threads.remove(remove);
++                }
++            } else {
++                // we need to add threads
++                for (int i = 0, difference = threads - currentThreads.length; i < difference; ++i) {
++                    final PrioritisedThread thread = new PrioritisedThread();
++
++                    this.threadModifier.accept(thread);
++                    this.aliveThreads.add(thread);
++                    this.threads.add(thread);
++
++                    thread.start();
++                }
++            }
++        }
++    }
++
++    private static int compareInsideGroup(final ExecutorGroup.ThreadPoolExecutor src, final Priority srcPriority,
++                                          final ExecutorGroup.ThreadPoolExecutor dst, final Priority dstPriority) {
++        final int priorityCompare = srcPriority.ordinal() - dstPriority.ordinal();
++        if (priorityCompare != 0) {
++            return priorityCompare;
++        }
++
++        final int parallelismCompare = src.currentParallelism - dst.currentParallelism;
++        if (parallelismCompare != 0) {
++            return parallelismCompare;
++        }
++
++        return TimeUtil.compareTimes(src.lastRetrieved, dst.lastRetrieved);
++    }
++
++    private static int compareOutsideGroup(final ExecutorGroup.ThreadPoolExecutor src, final Priority srcPriority,
++                                           final ExecutorGroup.ThreadPoolExecutor dst, final Priority dstPriority) {
++        if (src.getGroup().division == dst.getGroup().division) {
++            // can only compare priorities inside the same division
++            final int priorityCompare = srcPriority.ordinal() - dstPriority.ordinal();
++            if (priorityCompare != 0) {
++                return priorityCompare;
++            }
++        }
++
++        final int parallelismCompare = src.getGroup().currentParallelism - dst.getGroup().currentParallelism;
++        if (parallelismCompare != 0) {
++            return parallelismCompare;
++        }
++
++        return TimeUtil.compareTimes(src.lastRetrieved, dst.lastRetrieved);
++    }
++
++    private ExecutorGroup.ThreadPoolExecutor obtainQueue() {
++        final long time = System.nanoTime();
++        synchronized (this) {
++            ExecutorGroup.ThreadPoolExecutor ret = null;
++            Priority retPriority = null;
++
++            for (final ExecutorGroup executorGroup : this.executors.getArray()) {
++                ExecutorGroup.ThreadPoolExecutor highest = null;
++                Priority highestPriority = null;
++                for (final ExecutorGroup.ThreadPoolExecutor executor : executorGroup.executors.getArray()) {
++                    final int maxParallelism = executor.maxParallelism;
++                    if (maxParallelism > 0 && executor.currentParallelism >= maxParallelism) {
++                        continue;
++                    }
++
++                    final Priority priority = executor.getTargetPriority();
++
++                    if (priority == null) {
++                        continue;
++                    }
++
++                    if (highestPriority == null || compareInsideGroup(highest, highestPriority, executor, priority) > 0) {
++                        highest = executor;
++                        highestPriority = priority;
++                    }
++                }
++
++                if (highest == null) {
++                    continue;
++                }
++
++                if (ret == null || compareOutsideGroup(ret, retPriority, highest, highestPriority) > 0) {
++                    ret = highest;
++                    retPriority = highestPriority;
++                }
++            }
++
++            if (ret != null) {
++                ret.lastRetrieved = time;
++                ++ret.currentParallelism;
++                ++ret.getGroup().currentParallelism;
++                return ret;
++            }
++
++            return ret;
++        }
++    }
++
++    private void returnQueue(final ExecutorGroup.ThreadPoolExecutor executor) {
++        synchronized (this) {
++            --executor.currentParallelism;
++            --executor.getGroup().currentParallelism;
++        }
++
++        if (executor.isShutdown() && executor.queue.hasNoScheduledTasks()) {
++            executor.getGroup().executors.remove(executor);
++        }
++    }
++
++    private void notifyAllThreads() {
++        for (final PrioritisedThread thread : this.threads.getArray()) {
++            thread.notifyTasks();
++        }
++    }
++
++    public ExecutorGroup createExecutorGroup(final int division, final int flags) {
++        synchronized (this) {
++            if (this.shutdown) {
++                throw new IllegalStateException("Queue is shutdown: " + this.toString());
++            }
++
++            final ExecutorGroup ret = new ExecutorGroup(division, flags);
++
++            this.executors.add(ret);
++
++            return ret;
++        }
++    }
++
++    private final class PrioritisedThread extends PrioritisedQueueExecutorThread {
++
++        private final AtomicBoolean alertedHighPriority = new AtomicBoolean();
++
++        public PrioritisedThread() {
++            super(null);
++        }
++
++        public boolean alertHighPriorityExecutor() {
++            if (!this.notifyTasks()) {
++                if (!this.alertedHighPriority.get()) {
++                    this.alertedHighPriority.set(true);
++                }
++                return false;
++            }
++
++            return true;
++        }
++
++        private boolean isAlertedHighPriority() {
++            return this.alertedHighPriority.get() && this.alertedHighPriority.getAndSet(false);
++        }
++
++        @Override
++        protected void die() {
++            PrioritisedThreadPool.this.die(this);
++        }
++
++        @Override
++        protected boolean pollTasks() {
++            boolean ret = false;
++
++            for (;;) {
++                if (this.halted) {
++                    break;
++                }
++
++                final ExecutorGroup.ThreadPoolExecutor executor = PrioritisedThreadPool.this.obtainQueue();
++                if (executor == null) {
++                    break;
++                }
++                final long deadline = System.nanoTime() + executor.queueMaxHoldTime;
++                do {
++                    try {
++                        if (this.halted || executor.halt) {
++                            break;
++                        }
++                        if (!executor.executeTask()) {
++                            // no more tasks, try next queue
++                            break;
++                        }
++                        ret = true;
++                    } catch (final Throwable throwable) {
++                        LOGGER.error("Exception thrown from thread '" + this.getName() + "' in queue '" + executor.toString() + "'", throwable);
++                    }
++                } while (!this.isAlertedHighPriority() && System.nanoTime() <= deadline);
++
++                PrioritisedThreadPool.this.returnQueue(executor);
++            }
++
++
++            return ret;
++        }
++    }
++
++    public final class ExecutorGroup {
++
++        private final AtomicLong subOrderGenerator = new AtomicLong();
++        private final COWArrayList<ThreadPoolExecutor> executors = new COWArrayList<>(ThreadPoolExecutor.class);
++
++        private final int division;
++        private int currentParallelism;
++
++        private ExecutorGroup(final int division, final int flags) {
++            this.division = division;
++        }
++
++        public ThreadPoolExecutor[] getAllExecutors() {
++            return this.executors.getArray().clone();
++        }
++
++        private PrioritisedThreadPool getThreadPool() {
++            return PrioritisedThreadPool.this;
++        }
++
++        public ThreadPoolExecutor createExecutor(final int maxParallelism, final long queueMaxHoldTime, final int flags) {
++            synchronized (PrioritisedThreadPool.this) {
++                if (PrioritisedThreadPool.this.shutdown) {
++                    throw new IllegalStateException("Queue is shutdown: " + PrioritisedThreadPool.this.toString());
++                }
++
++                final ThreadPoolExecutor ret = new ThreadPoolExecutor(maxParallelism, queueMaxHoldTime, flags);
++
++                this.executors.add(ret);
++
++                return ret;
++            }
++        }
++
++        public final class ThreadPoolExecutor implements PrioritisedExecutor {
++
++            private final PrioritisedTaskQueue queue = new PrioritisedTaskQueue();
++
++            private volatile int maxParallelism;
++            private final long queueMaxHoldTime;
++            private volatile int currentParallelism;
++            private volatile boolean halt;
++            private long lastRetrieved = System.nanoTime();
++
++            private ThreadPoolExecutor(final int maxParallelism, final long queueMaxHoldTime, final int flags) {
++                this.maxParallelism = maxParallelism;
++                this.queueMaxHoldTime = queueMaxHoldTime;
++            }
++
++            private ExecutorGroup getGroup() {
++                return ExecutorGroup.this;
++            }
++
++            private boolean canNotify() {
++                if (this.halt) {
++                    return false;
++                }
++
++                final int max = this.maxParallelism;
++                return max < 0 || this.currentParallelism < max;
++            }
++
++            private void notifyHighPriority() {
++                if (!this.canNotify()) {
++                    return;
++                }
++                for (final PrioritisedThread thread : this.getGroup().getThreadPool().threads.getArray()) {
++                    if (thread.alertHighPriorityExecutor()) {
++                        return;
++                    }
++                }
++            }
++
++            private void notifyScheduled() {
++                if (!this.canNotify()) {
++                    return;
++                }
++                for (final PrioritisedThread thread : this.getGroup().getThreadPool().threads.getArray()) {
++                    if (thread.notifyTasks()) {
++                        return;
++                    }
++                }
++            }
++
++            /**
++             * Removes this queue from the thread pool without shutting the queue down or waiting for queued tasks to be executed
++             */
++            public void halt() {
++                this.halt = true;
++
++                ExecutorGroup.this.executors.remove(this);
++            }
++
++            /**
++             * Returns whether this executor is scheduled to run tasks or is running tasks, otherwise it returns whether
++             * this queue is not halted and not shutdown.
++             */
++            public boolean isActive() {
++                if (this.halt) {
++                    return this.currentParallelism > 0;
++                } else {
++                    if (!this.isShutdown()) {
++                        return true;
++                    }
++
++                    return !this.queue.hasNoScheduledTasks();
++                }
++            }
++
++            @Override
++            public boolean shutdown() {
++                if (!this.queue.shutdown()) {
++                    return false;
++                }
++
++                if (this.queue.hasNoScheduledTasks()) {
++                    ExecutorGroup.this.executors.remove(this);
++                }
++
++                return true;
++            }
++
++            @Override
++            public boolean isShutdown() {
++                return this.queue.isShutdown();
++            }
++
++            public void setMaxParallelism(final int maxParallelism) {
++                this.maxParallelism = maxParallelism;
++                // assume that we could have increased the parallelism
++                if (this.getTargetPriority() != null) {
++                    ExecutorGroup.this.getThreadPool().notifyAllThreads();
++                }
++            }
++
++            Priority getTargetPriority() {
++                final Priority ret = this.queue.getHighestPriority();
++                if (!this.isShutdown()) {
++                    return ret;
++                }
++
++                return ret == null ? QUEUE_SHUTDOWN_PRIORITY : Priority.max(ret, QUEUE_SHUTDOWN_PRIORITY);
++            }
++
++            @Override
++            public long getTotalTasksScheduled() {
++                return this.queue.getTotalTasksScheduled();
++            }
++
++            @Override
++            public long getTotalTasksExecuted() {
++                return this.queue.getTotalTasksExecuted();
++            }
++
++            @Override
++            public long generateNextSubOrder() {
++                return ExecutorGroup.this.subOrderGenerator.getAndIncrement();
++            }
++
++            @Override
++            public boolean executeTask() {
++                return this.queue.executeTask();
++            }
++
++            @Override
++            public PrioritisedTask queueTask(final Runnable task) {
++                final PrioritisedTask ret = this.createTask(task);
++
++                ret.queue();
++
++                return ret;
++            }
++
++            @Override
++            public PrioritisedTask queueTask(final Runnable task, final Priority priority) {
++                final PrioritisedTask ret = this.createTask(task, priority);
++
++                ret.queue();
++
++                return ret;
++            }
++
++            @Override
++            public PrioritisedTask queueTask(final Runnable task, final Priority priority, final long subOrder) {
++                final PrioritisedTask ret = this.createTask(task, priority, subOrder);
++
++                ret.queue();
++
++                return ret;
++            }
++
++            @Override
++            public PrioritisedTask createTask(final Runnable task) {
++                return this.createTask(task, Priority.NORMAL);
++            }
++
++            @Override
++            public PrioritisedTask createTask(final Runnable task, final Priority priority) {
++                return this.createTask(task, priority, this.generateNextSubOrder());
++            }
++
++            @Override
++            public PrioritisedTask createTask(final Runnable task, final Priority priority, final long subOrder) {
++                return new WrappedTask(this.queue.createTask(task, priority, subOrder));
++            }
++
++            private final class WrappedTask implements PrioritisedTask {
++
++                private final PrioritisedTask wrapped;
++
++                private WrappedTask(final PrioritisedTask wrapped) {
++                    this.wrapped = wrapped;
++                }
++
++                @Override
++                public PrioritisedExecutor getExecutor() {
++                    return ThreadPoolExecutor.this;
++                }
++
++                @Override
++                public boolean queue() {
++                    if (this.wrapped.queue()) {
++                        final Priority priority = this.getPriority();
++                        if (priority != Priority.COMPLETING) {
++                            if (priority.isHigherOrEqualPriority(HIGH_PRIORITY_NOTIFY_THRESHOLD)) {
++                                ThreadPoolExecutor.this.notifyHighPriority();
++                            } else {
++                                ThreadPoolExecutor.this.notifyScheduled();
++                            }
++                        }
++                        return true;
++                    }
++
++                    return false;
++                }
++
++                @Override
++                public boolean isQueued() {
++                    return this.wrapped.isQueued();
++                }
++
++                @Override
++                public boolean cancel() {
++                    return this.wrapped.cancel();
++                }
++
++                @Override
++                public boolean execute() {
++                    return this.wrapped.execute();
++                }
++
++                @Override
++                public Priority getPriority() {
++                    return this.wrapped.getPriority();
++                }
++
++                @Override
++                public boolean setPriority(final Priority priority) {
++                    if (this.wrapped.setPriority(priority)) {
++                        if (priority.isHigherOrEqualPriority(HIGH_PRIORITY_NOTIFY_THRESHOLD)) {
++                            ThreadPoolExecutor.this.notifyHighPriority();
++                        }
++                        return true;
++                    }
++
++                    return false;
++                }
++
++                @Override
++                public boolean raisePriority(final Priority priority) {
++                    if (this.wrapped.raisePriority(priority)) {
++                        if (priority.isHigherOrEqualPriority(HIGH_PRIORITY_NOTIFY_THRESHOLD)) {
++                            ThreadPoolExecutor.this.notifyHighPriority();
++                        }
++                        return true;
++                    }
++
++                    return false;
++                }
++
++                @Override
++                public boolean lowerPriority(final Priority priority) {
++                    return this.wrapped.lowerPriority(priority);
++                }
++
++                @Override
++                public long getSubOrder() {
++                    return this.wrapped.getSubOrder();
++                }
++
++                @Override
++                public boolean setSubOrder(final long subOrder) {
++                    return this.wrapped.setSubOrder(subOrder);
++                }
++
++                @Override
++                public boolean raiseSubOrder(final long subOrder) {
++                    return this.wrapped.raiseSubOrder(subOrder);
++                }
++
++                @Override
++                public boolean lowerSubOrder(final long subOrder) {
++                    return this.wrapped.lowerSubOrder(subOrder);
++                }
++
++                @Override
++                public boolean setPriorityAndSubOrder(final Priority priority, final long subOrder) {
++                    if (this.wrapped.setPriorityAndSubOrder(priority, subOrder)) {
++                        if (priority.isHigherOrEqualPriority(HIGH_PRIORITY_NOTIFY_THRESHOLD)) {
++                            ThreadPoolExecutor.this.notifyHighPriority();
++                        }
++                        return true;
++                    }
++
++                    return false;
++                }
++            }
++        }
++    }
++
++    private static final class COWArrayList<E> {
++
++        private volatile E[] array;
++
++        public COWArrayList(final Class<E> clazz) {
++            this.array = (E[])Array.newInstance(clazz, 0);
++        }
++
++        public E[] getArray() {
++            return this.array;
++        }
++
++        public void add(final E element) {
++            synchronized (this) {
++                final E[] array = this.array;
++
++                final E[] copy = Arrays.copyOf(array, array.length + 1);
++                copy[array.length] = element;
++
++                this.array = copy;
++            }
++        }
++
++        public boolean remove(final E element) {
++            synchronized (this) {
++                final E[] array = this.array;
++                int index = -1;
++                for (int i = 0, len = array.length; i < len; ++i) {
++                    if (array[i] == element) {
++                        index = i;
++                        break;
++                    }
++                }
++
++                if (index == -1) {
++                    return false;
++                }
++
++                final E[] copy = (E[])Array.newInstance(array.getClass().getComponentType(), array.length - 1);
++
++                System.arraycopy(array, 0, copy, 0, index);
++                System.arraycopy(array, index + 1, copy, index, (array.length - 1) - index);
++
++                this.array = copy;
++            }
++
++            return true;
++        }
++    }
++}
+diff --git a/src/main/java/ca/spottedleaf/concurrentutil/map/ConcurrentLong2ReferenceChainedHashTable.java b/src/main/java/ca/spottedleaf/concurrentutil/map/ConcurrentLong2ReferenceChainedHashTable.java
+index d701998b376579ec652fb94823befa3cc0bc4090..6918f130099e6c19e20a47bfdb54915cdd13732a 100644
+--- a/src/main/java/ca/spottedleaf/concurrentutil/map/ConcurrentLong2ReferenceChainedHashTable.java
++++ b/src/main/java/ca/spottedleaf/concurrentutil/map/ConcurrentLong2ReferenceChainedHashTable.java
+@@ -43,7 +43,7 @@ import java.util.function.Predicate;
+  * @param <V>
+  * @see java.util.concurrent.ConcurrentMap
+  */
+-public class ConcurrentLong2ReferenceChainedHashTable<V> {
++public class ConcurrentLong2ReferenceChainedHashTable<V> implements Iterable<ConcurrentLong2ReferenceChainedHashTable.TableEntry<V>> {
+ 
+     protected static final int DEFAULT_CAPACITY = 16;
+     protected static final float DEFAULT_LOAD_FACTOR = 0.75f;
+@@ -192,6 +192,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
+             }
+ 
+             if (node.resize) {
++                // noinspection unchecked
+                 table = (TableEntry<V>[])node.getValuePlain();
+                 continue;
+             }
+@@ -274,10 +275,10 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
+     public int size() {
+         final long ret = this.size.sum();
+ 
+-        if (ret <= 0L) {
++        if (ret < 0L) {
+             return 0;
+         }
+-        if (ret >= (long)Integer.MAX_VALUE) {
++        if (ret > (long)Integer.MAX_VALUE) {
+             return Integer.MAX_VALUE;
+         }
+ 
+@@ -341,6 +342,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
+ 
+         // create new table data
+ 
++        // noinspection unchecked
+         final TableEntry<V>[] newTable = new TableEntry[capacity];
+         // noinspection unchecked
+         final TableEntry<V> resizeNode = new TableEntry<>(0L, (V)newTable, true);
+@@ -365,6 +367,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
+             throw new IllegalStateException("Resizing to same size");
+         }
+ 
++        // noinspection unchecked
+         final TableEntry<V>[] work = new TableEntry[1 << capDiffShift]; // typically, capDiffShift = 1
+ 
+         for (int i = 0, len = oldTable.length; i < len; ++i) {
+@@ -538,6 +541,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
+                 }
+ 
+                 if (node.resize) {
++                    // noinspection unchecked
+                     table = (TableEntry<V>[])node.getValuePlain();
+                     continue table_loop;
+                 }
+@@ -599,6 +603,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
+                 }
+ 
+                 if (node.resize) {
++                    // noinspection unchecked
+                     table = (TableEntry<V>[])node.getValuePlain();
+                     continue table_loop;
+                 }
+@@ -653,6 +658,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
+                 }
+ 
+                 if (node.resize) {
++                    // noinspection unchecked
+                     table = (TableEntry<V>[])node.getValuePlain();
+                     continue table_loop;
+                 }
+@@ -704,6 +710,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
+                 }
+ 
+                 if (node.resize) {
++                    // noinspection unchecked
+                     table = (TableEntry<V>[])node.getValuePlain();
+                     continue table_loop;
+                 }
+@@ -772,6 +779,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
+                 }
+ 
+                 if (node.resize) {
++                    // noinspection unchecked
+                     table = (TableEntry<V>[])node.getValuePlain();
+                     continue table_loop;
+                 }
+@@ -848,6 +856,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
+                 }
+ 
+                 if (node.resize) {
++                    // noinspection unchecked
+                     table = (TableEntry<V>[])node.getValuePlain();
+                     continue table_loop;
+                 }
+@@ -944,6 +953,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
+                 }
+ 
+                 if (node.resize) {
++                    // noinspection unchecked
+                     table = (TableEntry<V>[])node.getValuePlain();
+                     continue table_loop;
+                 }
+@@ -1058,6 +1068,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
+                 }
+ 
+                 if (node.resize) {
++                    // noinspection unchecked
+                     table = (TableEntry<V>[])node.getValuePlain();
+                     continue table_loop;
+                 }
+@@ -1126,6 +1137,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
+                 }
+ 
+                 if (node.resize) {
++                    // noinspection unchecked
+                     table = (TableEntry<V>[])node.getValuePlain();
+                     continue table_loop;
+                 }
+@@ -1200,6 +1212,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
+                 }
+ 
+                 if (node.resize) {
++                    // noinspection unchecked
+                     table = (TableEntry<V>[])node.getValuePlain();
+                     continue table_loop;
+                 }
+@@ -1288,6 +1301,11 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
+         return new EntryIterator<>(this);
+     }
+ 
++    @Override
++    public final Iterator<TableEntry<V>> iterator() {
++        return this.entryIterator();
++    }
++
+     /**
+      * Returns an iterator over the keys in this map. The iterator is only guaranteed to see keys that were
+      * added before the beginning of this call, but it may see keys added during.
+@@ -1306,7 +1324,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
+ 
+     protected static final class EntryIterator<V> extends BaseIteratorImpl<V, TableEntry<V>> {
+ 
+-        protected EntryIterator(final ConcurrentLong2ReferenceChainedHashTable<V> map) {
++        public EntryIterator(final ConcurrentLong2ReferenceChainedHashTable<V> map) {
+             super(map);
+         }
+ 
+@@ -1326,7 +1344,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
+ 
+     protected static final class KeyIterator<V> extends BaseIteratorImpl<V, Long> implements PrimitiveIterator.OfLong {
+ 
+-        protected KeyIterator(final ConcurrentLong2ReferenceChainedHashTable<V> map) {
++        public KeyIterator(final ConcurrentLong2ReferenceChainedHashTable<V> map) {
+             super(map);
+         }
+ 
+@@ -1365,7 +1383,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
+ 
+     protected static final class ValueIterator<V> extends BaseIteratorImpl<V, V> {
+ 
+-        protected ValueIterator(final ConcurrentLong2ReferenceChainedHashTable<V> map) {
++        public ValueIterator(final ConcurrentLong2ReferenceChainedHashTable<V> map) {
+             super(map);
+         }
+ 
+@@ -1420,7 +1438,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
+ 
+         @Override
+         public final void remove() {
+-            final TableEntry<V> lastReturned = this.nextToReturn;
++            final TableEntry<V> lastReturned = this.lastReturned;
+             if (lastReturned == null) {
+                 throw new NoSuchElementException();
+             }
+@@ -1492,6 +1510,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
+             final ResizeChain<V> chain = this.resizeChain;
+ 
+             if (chain == null) {
++                // noinspection unchecked
+                 final TableEntry<V>[] nextTable = (TableEntry<V>[])entry.getValuePlain();
+ 
+                 final ResizeChain<V> oldChain = new ResizeChain<>(table, null, null);
+@@ -1506,6 +1525,7 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
+             } else {
+                 ResizeChain<V> currChain = chain.next;
+                 if (currChain == null) {
++                    // noinspection unchecked
+                     final TableEntry<V>[] ret = (TableEntry<V>[])entry.getValuePlain();
+                     currChain = new ResizeChain<>(ret, chain, null);
+                     chain.next = currChain;
+@@ -1586,11 +1606,11 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
+ 
+         protected static final class ResizeChain<V> {
+ 
+-            protected final TableEntry<V>[] table;
+-            protected final ResizeChain<V> prev;
+-            protected ResizeChain<V> next;
++            public final TableEntry<V>[] table;
++            public final ResizeChain<V> prev;
++            public ResizeChain<V> next;
+ 
+-            protected ResizeChain(final TableEntry<V>[] table, final ResizeChain<V> prev, final ResizeChain<V> next) {
++            public ResizeChain(final TableEntry<V>[] table, final ResizeChain<V> prev, final ResizeChain<V> next) {
+                 this.table = table;
+                 this.prev = prev;
+                 this.next = next;
+@@ -1600,64 +1620,64 @@ public class ConcurrentLong2ReferenceChainedHashTable<V> {
+ 
+     public static final class TableEntry<V> {
+ 
+-        protected static final VarHandle TABLE_ENTRY_ARRAY_HANDLE = ConcurrentUtil.getArrayHandle(TableEntry[].class);
++        private static final VarHandle TABLE_ENTRY_ARRAY_HANDLE = ConcurrentUtil.getArrayHandle(TableEntry[].class);
+ 
+-        protected final boolean resize;
++        private final boolean resize;
+ 
+-        protected final long key;
++        private final long key;
+ 
+-        protected volatile V value;
+-        protected static final VarHandle VALUE_HANDLE = ConcurrentUtil.getVarHandle(TableEntry.class, "value", Object.class);
++        private volatile V value;
++        private static final VarHandle VALUE_HANDLE = ConcurrentUtil.getVarHandle(TableEntry.class, "value", Object.class);
+ 
+-        protected final V getValuePlain() {
++        private V getValuePlain() {
+             //noinspection unchecked
+             return (V)VALUE_HANDLE.get(this);
+         }
+ 
+-        protected final V getValueAcquire() {
++        private V getValueAcquire() {
+             //noinspection unchecked
+             return (V)VALUE_HANDLE.getAcquire(this);
+         }
+ 
+-        protected final V getValueVolatile() {
++        private V getValueVolatile() {
+             //noinspection unchecked
+             return (V)VALUE_HANDLE.getVolatile(this);
+         }
+ 
+-        protected final void setValuePlain(final V value) {
++        private void setValuePlain(final V value) {
+             VALUE_HANDLE.set(this, (Object)value);
+         }
+ 
+-        protected final void setValueRelease(final V value) {
++        private void setValueRelease(final V value) {
+             VALUE_HANDLE.setRelease(this, (Object)value);
+         }
+ 
+-        protected final void setValueVolatile(final V value) {
++        private void setValueVolatile(final V value) {
+             VALUE_HANDLE.setVolatile(this, (Object)value);
+         }
+ 
+-        protected volatile TableEntry<V> next;
+-        protected static final VarHandle NEXT_HANDLE = ConcurrentUtil.getVarHandle(TableEntry.class, "next", TableEntry.class);
++        private volatile TableEntry<V> next;
++        private static final VarHandle NEXT_HANDLE = ConcurrentUtil.getVarHandle(TableEntry.class, "next", TableEntry.class);
+ 
+-        protected final TableEntry<V> getNextPlain() {
++        private TableEntry<V> getNextPlain() {
+             //noinspection unchecked
+             return (TableEntry<V>)NEXT_HANDLE.get(this);
+         }
+ 
+-        protected final TableEntry<V> getNextVolatile() {
++        private TableEntry<V> getNextVolatile() {
+             //noinspection unchecked
+             return (TableEntry<V>)NEXT_HANDLE.getVolatile(this);
+         }
+ 
+-        protected final void setNextPlain(final TableEntry<V> next) {
++        private void setNextPlain(final TableEntry<V> next) {
+             NEXT_HANDLE.set(this, next);
+         }
+ 
+-        protected final void setNextRelease(final TableEntry<V> next) {
++        private void setNextRelease(final TableEntry<V> next) {
+             NEXT_HANDLE.setRelease(this, next);
+         }
+ 
+-        protected final void setNextVolatile(final TableEntry<V> next) {
++        private void setNextVolatile(final TableEntry<V> next) {
+             NEXT_HANDLE.setVolatile(this, next);
+         }
+ 
+diff --git a/src/main/java/ca/spottedleaf/concurrentutil/scheduler/SchedulerThreadPool.java b/src/main/java/ca/spottedleaf/concurrentutil/scheduler/SchedulerThreadPool.java
+index 8197ccb1c4e5878dbd8007b5fb514640765ec8e4..85e6ef636d435a0ee4bf3e0760b0c87422c520a1 100644
+--- a/src/main/java/ca/spottedleaf/concurrentutil/scheduler/SchedulerThreadPool.java
++++ b/src/main/java/ca/spottedleaf/concurrentutil/scheduler/SchedulerThreadPool.java
+@@ -13,6 +13,10 @@ import java.util.concurrent.atomic.AtomicLong;
+ import java.util.concurrent.locks.LockSupport;
+ import java.util.function.BooleanSupplier;
+ 
++/**
++ * @deprecated To be replaced
++ */
++@Deprecated
+ public class SchedulerThreadPool {
+ 
+     public static final long DEADLINE_NOT_SET = Long.MIN_VALUE;
+@@ -297,7 +301,9 @@ public class SchedulerThreadPool {
+      * is invoked for any scheduled task - otherwise, {@link #runTasks(BooleanSupplier)} may not be invoked to
+      * parse intermediate tasks.
+      * </p>
++     * @deprecated To be replaced
+      */
++    @Deprecated
+     public static abstract class SchedulableTick {
+         private static final AtomicLong ID_GENERATOR = new AtomicLong();
+         public final long id = ID_GENERATOR.getAndIncrement();
+diff --git a/src/main/java/ca/spottedleaf/concurrentutil/set/LinkedSortedSet.java b/src/main/java/ca/spottedleaf/concurrentutil/set/LinkedSortedSet.java
+index 212bc9ae2fc7d37d4a089a2921b00de1e97f7cc1..82c4c11b0b564c97ac92bd5f54e3754a7ba95184 100644
+--- a/src/main/java/ca/spottedleaf/concurrentutil/set/LinkedSortedSet.java
++++ b/src/main/java/ca/spottedleaf/concurrentutil/set/LinkedSortedSet.java
+@@ -8,8 +8,8 @@ public final class LinkedSortedSet<E> implements Iterable<E> {
+ 
+     public final Comparator<? super E> comparator;
+ 
+-    protected Link<E> head;
+-    protected Link<E> tail;
++    private Link<E> head;
++    private Link<E> tail;
+ 
+     public LinkedSortedSet() {
+         this((Comparator)Comparator.naturalOrder());
+@@ -257,8 +257,6 @@ public final class LinkedSortedSet<E> implements Iterable<E> {
+         private Link<E> prev;
+         private Link<E> next;
+ 
+-        private Link() {}
+-
+         private Link(final E element) {
+             this.element = element;
+         }
+diff --git a/src/main/java/ca/spottedleaf/concurrentutil/set/LinkedUnsortedList.java b/src/main/java/ca/spottedleaf/concurrentutil/set/LinkedUnsortedList.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..bd8eb4f25d1dee00fbf9c05c14b0d94c5c641a55
+--- /dev/null
++++ b/src/main/java/ca/spottedleaf/concurrentutil/set/LinkedUnsortedList.java
+@@ -0,0 +1,204 @@
++package ca.spottedleaf.concurrentutil.set;
++
++import java.util.Iterator;
++import java.util.NoSuchElementException;
++import java.util.Objects;
++
++public final class LinkedUnsortedList<E> implements Iterable<E> {
++
++    private Link<E> head;
++    private Link<E> tail;
++
++    public LinkedUnsortedList() {}
++
++    public void clear() {
++        this.head = this.tail = null;
++    }
++
++    public boolean isEmpty() {
++        return this.head == null;
++    }
++
++    public E first() {
++        final Link<E> head = this.head;
++        return head == null ? null : head.element;
++    }
++
++    public E last() {
++        final Link<E> tail = this.tail;
++        return tail == null ? null : tail.element;
++    }
++
++    public boolean containsFirst(final E element) {
++        for (Link<E> curr = this.head; curr != null; curr = curr.next) {
++            if (Objects.equals(element, curr.element)) {
++                return true;
++            }
++        }
++        return false;
++    }
++
++    public boolean containsLast(final E element) {
++        for (Link<E> curr = this.tail; curr != null; curr = curr.prev) {
++            if (Objects.equals(element, curr.element)) {
++                return true;
++            }
++        }
++        return false;
++    }
++
++    private void removeNode(final Link<E> node) {
++        final Link<E> prev = node.prev;
++        final Link<E> next = node.next;
++
++        // help GC
++        node.element = null;
++        node.prev = null;
++        node.next = null;
++
++        if (prev == null) {
++            this.head = next;
++        } else {
++            prev.next = next;
++        }
++
++        if (next == null) {
++            this.tail = prev;
++        } else {
++            next.prev = prev;
++        }
++    }
++
++    public boolean remove(final Link<E> link) {
++        if (link.element == null) {
++            return false;
++        }
++
++        this.removeNode(link);
++        return true;
++    }
++
++    public boolean removeFirst(final E element) {
++        for (Link<E> curr = this.head; curr != null; curr = curr.next) {
++            if (Objects.equals(element, curr.element)) {
++                this.removeNode(curr);
++                return true;
++            }
++        }
++        return false;
++    }
++
++    public boolean removeLast(final E element) {
++        for (Link<E> curr = this.tail; curr != null; curr = curr.prev) {
++            if (Objects.equals(element, curr.element)) {
++                this.removeNode(curr);
++                return true;
++            }
++        }
++        return false;
++    }
++
++    @Override
++    public Iterator<E> iterator() {
++        return new Iterator<>() {
++            private Link<E> next = LinkedUnsortedList.this.head;
++
++            @Override
++            public boolean hasNext() {
++                return this.next != null;
++            }
++
++            @Override
++            public E next() {
++                final Link<E> next = this.next;
++                if (next == null) {
++                    throw new NoSuchElementException();
++                }
++                this.next = next.next;
++                return next.element;
++            }
++        };
++    }
++
++    public E pollFirst() {
++        final Link<E> head = this.head;
++        if (head == null) {
++            return null;
++        }
++
++        final E ret = head.element;
++        final Link<E> next = head.next;
++
++        // unlink head
++        this.head = next;
++        if (next == null) {
++            this.tail = null;
++        } else {
++            next.prev = null;
++        }
++
++        // help GC
++        head.element = null;
++        head.next = null;
++
++        return ret;
++    }
++
++    public E pollLast() {
++        final Link<E> tail = this.tail;
++        if (tail == null) {
++            return null;
++        }
++
++        final E ret = tail.element;
++        final Link<E> prev = tail.prev;
++
++        // unlink tail
++        this.tail = prev;
++        if (prev == null) {
++            this.head = null;
++        } else {
++            prev.next = null;
++        }
++
++        // help GC
++        tail.element = null;
++        tail.prev = null;
++
++        return ret;
++    }
++
++    public Link<E> addLast(final E element) {
++        final Link<E> curr = this.tail;
++        if (curr != null) {
++            return this.tail = new Link<>(element, curr, null);
++        } else {
++            return this.head = this.tail = new Link<>(element);
++        }
++    }
++
++    public Link<E> addFirst(final E element) {
++        final Link<E> curr = this.head;
++        if (curr != null) {
++            return this.head = new Link<>(element, null, curr);
++        } else {
++            return this.head = this.tail = new Link<>(element);
++        }
++    }
++
++    public static final class Link<E> {
++        private E element;
++        private Link<E> prev;
++        private Link<E> next;
++
++        private Link(final E element) {
++            this.element = element;
++        }
++
++        private Link(final E element, final Link<E> prev, final Link<E> next) {
++            this.element = element;
++            this.prev = prev;
++            this.next = next;
++        }
++    }
++}
+diff --git a/src/main/java/ca/spottedleaf/concurrentutil/util/ArrayUtil.java b/src/main/java/ca/spottedleaf/concurrentutil/util/ArrayUtil.java
+deleted file mode 100644
+index ebb1ab06165addb173fea4d295001fe37f4e79d3..0000000000000000000000000000000000000000
+--- a/src/main/java/ca/spottedleaf/concurrentutil/util/ArrayUtil.java
++++ /dev/null
+@@ -1,816 +0,0 @@
+-package ca.spottedleaf.concurrentutil.util;
+-
+-import java.lang.invoke.VarHandle;
+-
+-public final class ArrayUtil {
+-
+-    public static final VarHandle BOOLEAN_ARRAY_HANDLE = ConcurrentUtil.getArrayHandle(boolean[].class);
+-
+-    public static final VarHandle BYTE_ARRAY_HANDLE = ConcurrentUtil.getArrayHandle(byte[].class);
+-
+-    public static final VarHandle SHORT_ARRAY_HANDLE = ConcurrentUtil.getArrayHandle(short[].class);
+-
+-    public static final VarHandle INT_ARRAY_HANDLE = ConcurrentUtil.getArrayHandle(int[].class);
+-
+-    public static final VarHandle LONG_ARRAY_HANDLE = ConcurrentUtil.getArrayHandle(long[].class);
+-
+-    public static final VarHandle OBJECT_ARRAY_HANDLE = ConcurrentUtil.getArrayHandle(Object[].class);
+-
+-    private ArrayUtil() {
+-        throw new RuntimeException();
+-    }
+-
+-    /* byte array */
+-
+-    public static byte getPlain(final byte[] array, final int index) {
+-        return (byte)BYTE_ARRAY_HANDLE.get(array, index);
+-    }
+-
+-    public static byte getOpaque(final byte[] array, final int index) {
+-        return (byte)BYTE_ARRAY_HANDLE.getOpaque(array, index);
+-    }
+-
+-    public static byte getAcquire(final byte[] array, final int index) {
+-        return (byte)BYTE_ARRAY_HANDLE.getAcquire(array, index);
+-    }
+-
+-    public static byte getVolatile(final byte[] array, final int index) {
+-        return (byte)BYTE_ARRAY_HANDLE.getVolatile(array, index);
+-    }
+-
+-    public static void setPlain(final byte[] array, final int index, final byte value) {
+-        BYTE_ARRAY_HANDLE.set(array, index, value);
+-    }
+-
+-    public static void setOpaque(final byte[] array, final int index, final byte value) {
+-        BYTE_ARRAY_HANDLE.setOpaque(array, index, value);
+-    }
+-
+-    public static void setRelease(final byte[] array, final int index, final byte value) {
+-        BYTE_ARRAY_HANDLE.setRelease(array, index, value);
+-    }
+-
+-    public static void setVolatile(final byte[] array, final int index, final byte value) {
+-        BYTE_ARRAY_HANDLE.setVolatile(array, index, value);
+-    }
+-
+-    public static void setVolatileContended(final byte[] array, final int index, final byte param) {
+-        int failures = 0;
+-
+-        for (byte curr = getVolatile(array, index);;++failures) {
+-            for (int i = 0; i < failures; ++i) {
+-                ConcurrentUtil.backoff();
+-            }
+-
+-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, param))) {
+-                return;
+-            }
+-        }
+-    }
+-
+-    public static byte compareAndExchangeVolatile(final byte[] array, final int index, final byte expect, final byte update) {
+-        return (byte)BYTE_ARRAY_HANDLE.compareAndExchange(array, index, expect, update);
+-    }
+-
+-    public static byte getAndAddVolatile(final byte[] array, final int index, final byte param) {
+-        return (byte)BYTE_ARRAY_HANDLE.getAndAdd(array, index, param);
+-    }
+-
+-    public static byte getAndAndVolatile(final byte[] array, final int index, final byte param) {
+-        return (byte)BYTE_ARRAY_HANDLE.getAndBitwiseAnd(array, index, param);
+-    }
+-
+-    public static byte getAndOrVolatile(final byte[] array, final int index, final byte param) {
+-        return (byte)BYTE_ARRAY_HANDLE.getAndBitwiseOr(array, index, param);
+-    }
+-
+-    public static byte getAndXorVolatile(final byte[] array, final int index, final byte param) {
+-        return (byte)BYTE_ARRAY_HANDLE.getAndBitwiseXor(array, index, param);
+-    }
+-
+-    public static byte getAndSetVolatile(final byte[] array, final int index, final byte param) {
+-        return (byte)BYTE_ARRAY_HANDLE.getAndSet(array, index, param);
+-    }
+-
+-    public static byte compareAndExchangeVolatileContended(final byte[] array, final int index, final byte expect, final byte update) {
+-        return (byte)BYTE_ARRAY_HANDLE.compareAndExchange(array, index, expect, update);
+-    }
+-
+-    public static byte getAndAddVolatileContended(final byte[] array, final int index, final byte param) {
+-        int failures = 0;
+-
+-        for (byte curr = getVolatile(array, index);;++failures) {
+-            for (int i = 0; i < failures; ++i) {
+-                ConcurrentUtil.backoff();
+-            }
+-
+-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (byte) (curr + param)))) {
+-                return curr;
+-            }
+-        }
+-    }
+-
+-    public static byte getAndAndVolatileContended(final byte[] array, final int index, final byte param) {
+-        int failures = 0;
+-
+-        for (byte curr = getVolatile(array, index);;++failures) {
+-            for (int i = 0; i < failures; ++i) {
+-                ConcurrentUtil.backoff();
+-            }
+-
+-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (byte) (curr & param)))) {
+-                return curr;
+-            }
+-        }
+-    }
+-
+-    public static byte getAndOrVolatileContended(final byte[] array, final int index, final byte param) {
+-        int failures = 0;
+-
+-        for (byte curr = getVolatile(array, index);;++failures) {
+-            for (int i = 0; i < failures; ++i) {
+-                ConcurrentUtil.backoff();
+-            }
+-
+-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (byte) (curr | param)))) {
+-                return curr;
+-            }
+-        }
+-    }
+-
+-    public static byte getAndXorVolatileContended(final byte[] array, final int index, final byte param) {
+-        int failures = 0;
+-
+-        for (byte curr = getVolatile(array, index);;++failures) {
+-            for (int i = 0; i < failures; ++i) {
+-                ConcurrentUtil.backoff();
+-            }
+-
+-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (byte) (curr ^ param)))) {
+-                return curr;
+-            }
+-        }
+-    }
+-
+-    public static byte getAndSetVolatileContended(final byte[] array, final int index, final byte param) {
+-        int failures = 0;
+-
+-        for (byte curr = getVolatile(array, index);;++failures) {
+-            for (int i = 0; i < failures; ++i) {
+-                ConcurrentUtil.backoff();
+-            }
+-
+-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, param))) {
+-                return curr;
+-            }
+-        }
+-    }
+-
+-    /* short array */
+-
+-    public static short getPlain(final short[] array, final int index) {
+-        return (short)SHORT_ARRAY_HANDLE.get(array, index);
+-    }
+-
+-    public static short getOpaque(final short[] array, final int index) {
+-        return (short)SHORT_ARRAY_HANDLE.getOpaque(array, index);
+-    }
+-
+-    public static short getAcquire(final short[] array, final int index) {
+-        return (short)SHORT_ARRAY_HANDLE.getAcquire(array, index);
+-    }
+-
+-    public static short getVolatile(final short[] array, final int index) {
+-        return (short)SHORT_ARRAY_HANDLE.getVolatile(array, index);
+-    }
+-
+-    public static void setPlain(final short[] array, final int index, final short value) {
+-        SHORT_ARRAY_HANDLE.set(array, index, value);
+-    }
+-
+-    public static void setOpaque(final short[] array, final int index, final short value) {
+-        SHORT_ARRAY_HANDLE.setOpaque(array, index, value);
+-    }
+-
+-    public static void setRelease(final short[] array, final int index, final short value) {
+-        SHORT_ARRAY_HANDLE.setRelease(array, index, value);
+-    }
+-
+-    public static void setVolatile(final short[] array, final int index, final short value) {
+-        SHORT_ARRAY_HANDLE.setVolatile(array, index, value);
+-    }
+-
+-    public static void setVolatileContended(final short[] array, final int index, final short param) {
+-        int failures = 0;
+-
+-        for (short curr = getVolatile(array, index);;++failures) {
+-            for (int i = 0; i < failures; ++i) {
+-                ConcurrentUtil.backoff();
+-            }
+-
+-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, param))) {
+-                return;
+-            }
+-        }
+-    }
+-
+-    public static short compareAndExchangeVolatile(final short[] array, final int index, final short expect, final short update) {
+-        return (short)SHORT_ARRAY_HANDLE.compareAndExchange(array, index, expect, update);
+-    }
+-
+-    public static short getAndAddVolatile(final short[] array, final int index, final short param) {
+-        return (short)SHORT_ARRAY_HANDLE.getAndAdd(array, index, param);
+-    }
+-
+-    public static short getAndAndVolatile(final short[] array, final int index, final short param) {
+-        return (short)SHORT_ARRAY_HANDLE.getAndBitwiseAnd(array, index, param);
+-    }
+-
+-    public static short getAndOrVolatile(final short[] array, final int index, final short param) {
+-        return (short)SHORT_ARRAY_HANDLE.getAndBitwiseOr(array, index, param);
+-    }
+-
+-    public static short getAndXorVolatile(final short[] array, final int index, final short param) {
+-        return (short)SHORT_ARRAY_HANDLE.getAndBitwiseXor(array, index, param);
+-    }
+-
+-    public static short getAndSetVolatile(final short[] array, final int index, final short param) {
+-        return (short)SHORT_ARRAY_HANDLE.getAndSet(array, index, param);
+-    }
+-
+-    public static short compareAndExchangeVolatileContended(final short[] array, final int index, final short expect, final short update) {
+-        return (short)SHORT_ARRAY_HANDLE.compareAndExchange(array, index, expect, update);
+-    }
+-
+-    public static short getAndAddVolatileContended(final short[] array, final int index, final short param) {
+-        int failures = 0;
+-
+-        for (short curr = getVolatile(array, index);;++failures) {
+-            for (int i = 0; i < failures; ++i) {
+-                ConcurrentUtil.backoff();
+-            }
+-
+-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (short) (curr + param)))) {
+-                return curr;
+-            }
+-        }
+-    }
+-
+-    public static short getAndAndVolatileContended(final short[] array, final int index, final short param) {
+-        int failures = 0;
+-
+-        for (short curr = getVolatile(array, index);;++failures) {
+-            for (int i = 0; i < failures; ++i) {
+-                ConcurrentUtil.backoff();
+-            }
+-
+-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (short) (curr & param)))) {
+-                return curr;
+-            }
+-        }
+-    }
+-
+-    public static short getAndOrVolatileContended(final short[] array, final int index, final short param) {
+-        int failures = 0;
+-
+-        for (short curr = getVolatile(array, index);;++failures) {
+-            for (int i = 0; i < failures; ++i) {
+-                ConcurrentUtil.backoff();
+-            }
+-
+-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (short) (curr | param)))) {
+-                return curr;
+-            }
+-        }
+-    }
+-
+-    public static short getAndXorVolatileContended(final short[] array, final int index, final short param) {
+-        int failures = 0;
+-
+-        for (short curr = getVolatile(array, index);;++failures) {
+-            for (int i = 0; i < failures; ++i) {
+-                ConcurrentUtil.backoff();
+-            }
+-
+-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (short) (curr ^ param)))) {
+-                return curr;
+-            }
+-        }
+-    }
+-
+-    public static short getAndSetVolatileContended(final short[] array, final int index, final short param) {
+-        int failures = 0;
+-
+-        for (short curr = getVolatile(array, index);;++failures) {
+-            for (int i = 0; i < failures; ++i) {
+-                ConcurrentUtil.backoff();
+-            }
+-
+-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, param))) {
+-                return curr;
+-            }
+-        }
+-    }
+-
+-    /* int array */
+-
+-    public static int getPlain(final int[] array, final int index) {
+-        return (int)INT_ARRAY_HANDLE.get(array, index);
+-    }
+-
+-    public static int getOpaque(final int[] array, final int index) {
+-        return (int)INT_ARRAY_HANDLE.getOpaque(array, index);
+-    }
+-
+-    public static int getAcquire(final int[] array, final int index) {
+-        return (int)INT_ARRAY_HANDLE.getAcquire(array, index);
+-    }
+-
+-    public static int getVolatile(final int[] array, final int index) {
+-        return (int)INT_ARRAY_HANDLE.getVolatile(array, index);
+-    }
+-
+-    public static void setPlain(final int[] array, final int index, final int value) {
+-        INT_ARRAY_HANDLE.set(array, index, value);
+-    }
+-
+-    public static void setOpaque(final int[] array, final int index, final int value) {
+-        INT_ARRAY_HANDLE.setOpaque(array, index, value);
+-    }
+-
+-    public static void setRelease(final int[] array, final int index, final int value) {
+-        INT_ARRAY_HANDLE.setRelease(array, index, value);
+-    }
+-
+-    public static void setVolatile(final int[] array, final int index, final int value) {
+-        INT_ARRAY_HANDLE.setVolatile(array, index, value);
+-    }
+-
+-    public static void setVolatileContended(final int[] array, final int index, final int param) {
+-        int failures = 0;
+-
+-        for (int curr = getVolatile(array, index);;++failures) {
+-            for (int i = 0; i < failures; ++i) {
+-                ConcurrentUtil.backoff();
+-            }
+-
+-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, param))) {
+-                return;
+-            }
+-        }
+-    }
+-
+-    public static int compareAndExchangeVolatile(final int[] array, final int index, final int expect, final int update) {
+-        return (int)INT_ARRAY_HANDLE.compareAndExchange(array, index, expect, update);
+-    }
+-
+-    public static int getAndAddVolatile(final int[] array, final int index, final int param) {
+-        return (int)INT_ARRAY_HANDLE.getAndAdd(array, index, param);
+-    }
+-
+-    public static int getAndAndVolatile(final int[] array, final int index, final int param) {
+-        return (int)INT_ARRAY_HANDLE.getAndBitwiseAnd(array, index, param);
+-    }
+-
+-    public static int getAndOrVolatile(final int[] array, final int index, final int param) {
+-        return (int)INT_ARRAY_HANDLE.getAndBitwiseOr(array, index, param);
+-    }
+-
+-    public static int getAndXorVolatile(final int[] array, final int index, final int param) {
+-        return (int)INT_ARRAY_HANDLE.getAndBitwiseXor(array, index, param);
+-    }
+-
+-    public static int getAndSetVolatile(final int[] array, final int index, final int param) {
+-        return (int)INT_ARRAY_HANDLE.getAndSet(array, index, param);
+-    }
+-
+-    public static int compareAndExchangeVolatileContended(final int[] array, final int index, final int expect, final int update) {
+-        return (int)INT_ARRAY_HANDLE.compareAndExchange(array, index, expect, update);
+-    }
+-
+-    public static int getAndAddVolatileContended(final int[] array, final int index, final int param) {
+-        int failures = 0;
+-
+-        for (int curr = getVolatile(array, index);;++failures) {
+-            for (int i = 0; i < failures; ++i) {
+-                ConcurrentUtil.backoff();
+-            }
+-
+-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (int) (curr + param)))) {
+-                return curr;
+-            }
+-        }
+-    }
+-
+-    public static int getAndAndVolatileContended(final int[] array, final int index, final int param) {
+-        int failures = 0;
+-
+-        for (int curr = getVolatile(array, index);;++failures) {
+-            for (int i = 0; i < failures; ++i) {
+-                ConcurrentUtil.backoff();
+-            }
+-
+-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (int) (curr & param)))) {
+-                return curr;
+-            }
+-        }
+-    }
+-
+-    public static int getAndOrVolatileContended(final int[] array, final int index, final int param) {
+-        int failures = 0;
+-
+-        for (int curr = getVolatile(array, index);;++failures) {
+-            for (int i = 0; i < failures; ++i) {
+-                ConcurrentUtil.backoff();
+-            }
+-
+-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (int) (curr | param)))) {
+-                return curr;
+-            }
+-        }
+-    }
+-
+-    public static int getAndXorVolatileContended(final int[] array, final int index, final int param) {
+-        int failures = 0;
+-
+-        for (int curr = getVolatile(array, index);;++failures) {
+-            for (int i = 0; i < failures; ++i) {
+-                ConcurrentUtil.backoff();
+-            }
+-
+-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (int) (curr ^ param)))) {
+-                return curr;
+-            }
+-        }
+-    }
+-
+-    public static int getAndSetVolatileContended(final int[] array, final int index, final int param) {
+-        int failures = 0;
+-
+-        for (int curr = getVolatile(array, index);;++failures) {
+-            for (int i = 0; i < failures; ++i) {
+-                ConcurrentUtil.backoff();
+-            }
+-
+-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, param))) {
+-                return curr;
+-            }
+-        }
+-    }
+-
+-    /* long array */
+-
+-    public static long getPlain(final long[] array, final int index) {
+-        return (long)LONG_ARRAY_HANDLE.get(array, index);
+-    }
+-
+-    public static long getOpaque(final long[] array, final int index) {
+-        return (long)LONG_ARRAY_HANDLE.getOpaque(array, index);
+-    }
+-
+-    public static long getAcquire(final long[] array, final int index) {
+-        return (long)LONG_ARRAY_HANDLE.getAcquire(array, index);
+-    }
+-
+-    public static long getVolatile(final long[] array, final int index) {
+-        return (long)LONG_ARRAY_HANDLE.getVolatile(array, index);
+-    }
+-
+-    public static void setPlain(final long[] array, final int index, final long value) {
+-        LONG_ARRAY_HANDLE.set(array, index, value);
+-    }
+-
+-    public static void setOpaque(final long[] array, final int index, final long value) {
+-        LONG_ARRAY_HANDLE.setOpaque(array, index, value);
+-    }
+-
+-    public static void setRelease(final long[] array, final int index, final long value) {
+-        LONG_ARRAY_HANDLE.setRelease(array, index, value);
+-    }
+-
+-    public static void setVolatile(final long[] array, final int index, final long value) {
+-        LONG_ARRAY_HANDLE.setVolatile(array, index, value);
+-    }
+-
+-    public static void setVolatileContended(final long[] array, final int index, final long param) {
+-        int failures = 0;
+-
+-        for (long curr = getVolatile(array, index);;++failures) {
+-            for (int i = 0; i < failures; ++i) {
+-                ConcurrentUtil.backoff();
+-            }
+-
+-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, param))) {
+-                return;
+-            }
+-        }
+-    }
+-
+-    public static long compareAndExchangeVolatile(final long[] array, final int index, final long expect, final long update) {
+-        return (long)LONG_ARRAY_HANDLE.compareAndExchange(array, index, expect, update);
+-    }
+-
+-    public static long getAndAddVolatile(final long[] array, final int index, final long param) {
+-        return (long)LONG_ARRAY_HANDLE.getAndAdd(array, index, param);
+-    }
+-
+-    public static long getAndAndVolatile(final long[] array, final int index, final long param) {
+-        return (long)LONG_ARRAY_HANDLE.getAndBitwiseAnd(array, index, param);
+-    }
+-
+-    public static long getAndOrVolatile(final long[] array, final int index, final long param) {
+-        return (long)LONG_ARRAY_HANDLE.getAndBitwiseOr(array, index, param);
+-    }
+-
+-    public static long getAndXorVolatile(final long[] array, final int index, final long param) {
+-        return (long)LONG_ARRAY_HANDLE.getAndBitwiseXor(array, index, param);
+-    }
+-
+-    public static long getAndSetVolatile(final long[] array, final int index, final long param) {
+-        return (long)LONG_ARRAY_HANDLE.getAndSet(array, index, param);
+-    }
+-
+-    public static long compareAndExchangeVolatileContended(final long[] array, final int index, final long expect, final long update) {
+-        return (long)LONG_ARRAY_HANDLE.compareAndExchange(array, index, expect, update);
+-    }
+-
+-    public static long getAndAddVolatileContended(final long[] array, final int index, final long param) {
+-        int failures = 0;
+-
+-        for (long curr = getVolatile(array, index);;++failures) {
+-            for (int i = 0; i < failures; ++i) {
+-                ConcurrentUtil.backoff();
+-            }
+-
+-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (long) (curr + param)))) {
+-                return curr;
+-            }
+-        }
+-    }
+-
+-    public static long getAndAndVolatileContended(final long[] array, final int index, final long param) {
+-        int failures = 0;
+-
+-        for (long curr = getVolatile(array, index);;++failures) {
+-            for (int i = 0; i < failures; ++i) {
+-                ConcurrentUtil.backoff();
+-            }
+-
+-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (long) (curr & param)))) {
+-                return curr;
+-            }
+-        }
+-    }
+-
+-    public static long getAndOrVolatileContended(final long[] array, final int index, final long param) {
+-        int failures = 0;
+-
+-        for (long curr = getVolatile(array, index);;++failures) {
+-            for (int i = 0; i < failures; ++i) {
+-                ConcurrentUtil.backoff();
+-            }
+-
+-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (long) (curr | param)))) {
+-                return curr;
+-            }
+-        }
+-    }
+-
+-    public static long getAndXorVolatileContended(final long[] array, final int index, final long param) {
+-        int failures = 0;
+-
+-        for (long curr = getVolatile(array, index);;++failures) {
+-            for (int i = 0; i < failures; ++i) {
+-                ConcurrentUtil.backoff();
+-            }
+-
+-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (long) (curr ^ param)))) {
+-                return curr;
+-            }
+-        }
+-    }
+-
+-    public static long getAndSetVolatileContended(final long[] array, final int index, final long param) {
+-        int failures = 0;
+-
+-        for (long curr = getVolatile(array, index);;++failures) {
+-            for (int i = 0; i < failures; ++i) {
+-                ConcurrentUtil.backoff();
+-            }
+-
+-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, param))) {
+-                return curr;
+-            }
+-        }
+-    }
+-
+-    /* boolean array */
+-
+-    public static boolean getPlain(final boolean[] array, final int index) {
+-        return (boolean)BOOLEAN_ARRAY_HANDLE.get(array, index);
+-    }
+-
+-    public static boolean getOpaque(final boolean[] array, final int index) {
+-        return (boolean)BOOLEAN_ARRAY_HANDLE.getOpaque(array, index);
+-    }
+-
+-    public static boolean getAcquire(final boolean[] array, final int index) {
+-        return (boolean)BOOLEAN_ARRAY_HANDLE.getAcquire(array, index);
+-    }
+-
+-    public static boolean getVolatile(final boolean[] array, final int index) {
+-        return (boolean)BOOLEAN_ARRAY_HANDLE.getVolatile(array, index);
+-    }
+-
+-    public static void setPlain(final boolean[] array, final int index, final boolean value) {
+-        BOOLEAN_ARRAY_HANDLE.set(array, index, value);
+-    }
+-
+-    public static void setOpaque(final boolean[] array, final int index, final boolean value) {
+-        BOOLEAN_ARRAY_HANDLE.setOpaque(array, index, value);
+-    }
+-
+-    public static void setRelease(final boolean[] array, final int index, final boolean value) {
+-        BOOLEAN_ARRAY_HANDLE.setRelease(array, index, value);
+-    }
+-
+-    public static void setVolatile(final boolean[] array, final int index, final boolean value) {
+-        BOOLEAN_ARRAY_HANDLE.setVolatile(array, index, value);
+-    }
+-
+-    public static void setVolatileContended(final boolean[] array, final int index, final boolean param) {
+-        int failures = 0;
+-
+-        for (boolean curr = getVolatile(array, index);;++failures) {
+-            for (int i = 0; i < failures; ++i) {
+-                ConcurrentUtil.backoff();
+-            }
+-
+-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, param))) {
+-                return;
+-            }
+-        }
+-    }
+-
+-    public static boolean compareAndExchangeVolatile(final boolean[] array, final int index, final boolean expect, final boolean update) {
+-        return (boolean)BOOLEAN_ARRAY_HANDLE.compareAndExchange(array, index, expect, update);
+-    }
+-
+-    public static boolean getAndOrVolatile(final boolean[] array, final int index, final boolean param) {
+-        return (boolean)BOOLEAN_ARRAY_HANDLE.getAndBitwiseOr(array, index, param);
+-    }
+-
+-    public static boolean getAndXorVolatile(final boolean[] array, final int index, final boolean param) {
+-        return (boolean)BOOLEAN_ARRAY_HANDLE.getAndBitwiseXor(array, index, param);
+-    }
+-
+-    public static boolean getAndSetVolatile(final boolean[] array, final int index, final boolean param) {
+-        return (boolean)BOOLEAN_ARRAY_HANDLE.getAndSet(array, index, param);
+-    }
+-
+-    public static boolean compareAndExchangeVolatileContended(final boolean[] array, final int index, final boolean expect, final boolean update) {
+-        return (boolean)BOOLEAN_ARRAY_HANDLE.compareAndExchange(array, index, expect, update);
+-    }
+-
+-    public static boolean getAndAndVolatileContended(final boolean[] array, final int index, final boolean param) {
+-        int failures = 0;
+-
+-        for (boolean curr = getVolatile(array, index);;++failures) {
+-            for (int i = 0; i < failures; ++i) {
+-                ConcurrentUtil.backoff();
+-            }
+-
+-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (boolean) (curr & param)))) {
+-                return curr;
+-            }
+-        }
+-    }
+-
+-    public static boolean getAndOrVolatileContended(final boolean[] array, final int index, final boolean param) {
+-        int failures = 0;
+-
+-        for (boolean curr = getVolatile(array, index);;++failures) {
+-            for (int i = 0; i < failures; ++i) {
+-                ConcurrentUtil.backoff();
+-            }
+-
+-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (boolean) (curr | param)))) {
+-                return curr;
+-            }
+-        }
+-    }
+-
+-    public static boolean getAndXorVolatileContended(final boolean[] array, final int index, final boolean param) {
+-        int failures = 0;
+-
+-        for (boolean curr = getVolatile(array, index);;++failures) {
+-            for (int i = 0; i < failures; ++i) {
+-                ConcurrentUtil.backoff();
+-            }
+-
+-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, (boolean) (curr ^ param)))) {
+-                return curr;
+-            }
+-        }
+-    }
+-
+-    public static boolean getAndSetVolatileContended(final boolean[] array, final int index, final boolean param) {
+-        int failures = 0;
+-
+-        for (boolean curr = getVolatile(array, index);;++failures) {
+-            for (int i = 0; i < failures; ++i) {
+-                ConcurrentUtil.backoff();
+-            }
+-
+-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, param))) {
+-                return curr;
+-            }
+-        }
+-    }
+-
+-    @SuppressWarnings("unchecked")
+-    public static <T> T getPlain(final T[] array, final int index) {
+-        final Object ret = OBJECT_ARRAY_HANDLE.get((Object[])array, index);
+-        return (T)ret;
+-    }
+-
+-    @SuppressWarnings("unchecked")
+-    public static <T> T getOpaque(final T[] array, final int index) {
+-        final Object ret = OBJECT_ARRAY_HANDLE.getOpaque((Object[])array, index);
+-        return (T)ret;
+-    }
+-
+-    @SuppressWarnings("unchecked")
+-    public static <T> T getAcquire(final T[] array, final int index) {
+-        final Object ret = OBJECT_ARRAY_HANDLE.getAcquire((Object[])array, index);
+-        return (T)ret;
+-    }
+-
+-    @SuppressWarnings("unchecked")
+-    public static <T> T getVolatile(final T[] array, final int index) {
+-        final Object ret = OBJECT_ARRAY_HANDLE.getVolatile((Object[])array, index);
+-        return (T)ret;
+-    }
+-
+-    public static <T> void setPlain(final T[] array, final int index, final T value) {
+-        OBJECT_ARRAY_HANDLE.set((Object[])array, index, (Object)value);
+-    }
+-
+-    public static <T> void setOpaque(final T[] array, final int index, final T value) {
+-        OBJECT_ARRAY_HANDLE.setOpaque((Object[])array, index, (Object)value);
+-    }
+-
+-    public static <T> void setRelease(final T[] array, final int index, final T value) {
+-        OBJECT_ARRAY_HANDLE.setRelease((Object[])array, index, (Object)value);
+-    }
+-
+-    public static <T> void setVolatile(final T[] array, final int index, final T value) {
+-        OBJECT_ARRAY_HANDLE.setVolatile((Object[])array, index, (Object)value);
+-    }
+-
+-    public static <T> void setVolatileContended(final T[] array, final int index, final T param) {
+-        int failures = 0;
+-
+-        for (T curr = getVolatile(array, index);;++failures) {
+-            for (int i = 0; i < failures; ++i) {
+-                ConcurrentUtil.backoff();
+-            }
+-
+-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, param))) {
+-                return;
+-            }
+-        }
+-    }
+-
+-    @SuppressWarnings("unchecked")
+-    public static <T> T compareAndExchangeVolatile(final T[] array, final int index, final T expect, final T update) {
+-        final Object ret = OBJECT_ARRAY_HANDLE.compareAndExchange((Object[])array, index, (Object)expect, (Object)update);
+-        return (T)ret;
+-    }
+-
+-    @SuppressWarnings("unchecked")
+-    public static <T> T getAndSetVolatile(final T[] array, final int index, final T param) {
+-        final Object ret = BYTE_ARRAY_HANDLE.getAndSet((Object[])array, index, (Object)param);
+-        return (T)ret;
+-    }
+-
+-    @SuppressWarnings("unchecked")
+-    public static <T> T compareAndExchangeVolatileContended(final T[] array, final int index, final T expect, final T update) {
+-        final Object ret = OBJECT_ARRAY_HANDLE.compareAndExchange((Object[])array, index, (Object)expect, (Object)update);
+-        return (T)ret;
+-    }
+-
+-    public static <T> T getAndSetVolatileContended(final T[] array, final int index, final T param) {
+-        int failures = 0;
+-
+-        for (T curr = getVolatile(array, index);;++failures) {
+-            for (int i = 0; i < failures; ++i) {
+-                ConcurrentUtil.backoff();
+-            }
+-
+-            if (curr == (curr = compareAndExchangeVolatileContended(array, index, curr, param))) {
+-                return curr;
+-            }
+-        }
+-    }
+-}
+diff --git a/src/main/java/ca/spottedleaf/concurrentutil/util/IntegerUtil.java b/src/main/java/ca/spottedleaf/concurrentutil/util/IntegerUtil.java
+index 77699c5fa9681f9ec7aa05cbb50eb60828e193ab..9d7b9b8158cd01d12adbd7896ff77bee9828e101 100644
+--- a/src/main/java/ca/spottedleaf/concurrentutil/util/IntegerUtil.java
++++ b/src/main/java/ca/spottedleaf/concurrentutil/util/IntegerUtil.java
+@@ -170,6 +170,26 @@ public final class IntegerUtil {
+         return (mask ^ val) - mask; // if val < 0, then (0 ^ val) - 0 else (-1 ^ val) + 1
+     }
+ 
++    // https://lemire.me/blog/2019/02/08/faster-remainders-when-the-divisor-is-a-constant-beating-compilers-and-libdivide
++    /**
++     *
++     * Usage:
++     * <pre>
++     * {@code
++     *     static final long mult = getSimpleMultiplier(divisor, bits);
++     *     long x = ...;
++     *     long magic = x * mult;
++     *     long divQ = magic >>> bits;
++     *     long divR = ((magic & ((1 << bits) - 1)) * divisor) >>> bits;
++     * }
++     * </pre>
++     *
++     * @param bits The number of bits of precision for the returned result
++     */
++    public static long getUnsignedDivisorMagic(final long divisor, final int bits) {
++        return (((1L << bits) - 1L) / divisor) + 1;
++    }
++
+     private IntegerUtil() {
+         throw new RuntimeException();
+     }
+diff --git a/src/main/java/ca/spottedleaf/concurrentutil/util/Priority.java b/src/main/java/ca/spottedleaf/concurrentutil/util/Priority.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..2919bbaa07b70f182438c3be8f9ebbe0649809b6
+--- /dev/null
++++ b/src/main/java/ca/spottedleaf/concurrentutil/util/Priority.java
+@@ -0,0 +1,145 @@
++package ca.spottedleaf.concurrentutil.util;
++
++public enum Priority {
++
++    /**
++     * Priority value indicating the task has completed or is being completed.
++     * This priority cannot be used to schedule tasks.
++     */
++    COMPLETING(-1),
++
++    /**
++     * Absolute highest priority, should only be used for when a task is blocking a time-critical thread.
++     */
++    BLOCKING(),
++
++    /**
++     * Should only be used for urgent but not time-critical tasks.
++     */
++    HIGHEST(),
++
++    /**
++     * Two priorities above normal.
++     */
++    HIGHER(),
++
++    /**
++     * One priority above normal.
++     */
++    HIGH(),
++
++    /**
++     * Default priority.
++     */
++    NORMAL(),
++
++    /**
++     * One priority below normal.
++     */
++    LOW(),
++
++    /**
++     * Two priorities below normal.
++     */
++    LOWER(),
++
++    /**
++     * Use for tasks that should eventually execute, but are not needed to.
++     */
++    LOWEST(),
++
++    /**
++     * Use for tasks that can be delayed indefinitely.
++     */
++    IDLE();
++
++    // returns whether the priority can be scheduled
++    public static boolean isValidPriority(final Priority priority) {
++        return priority != null && priority != priority.COMPLETING;
++    }
++
++    // returns the higher priority of the two
++    public static Priority max(final Priority p1, final Priority p2) {
++        return p1.isHigherOrEqualPriority(p2) ? p1 : p2;
++    }
++
++    // returns the lower priroity of the two
++    public static Priority min(final Priority p1, final Priority p2) {
++        return p1.isLowerOrEqualPriority(p2) ? p1 : p2;
++    }
++
++    public boolean isHigherOrEqualPriority(final Priority than) {
++        return this.priority <= than.priority;
++    }
++
++    public boolean isHigherPriority(final Priority than) {
++        return this.priority < than.priority;
++    }
++
++    public boolean isLowerOrEqualPriority(final Priority than) {
++        return this.priority >= than.priority;
++    }
++
++    public boolean isLowerPriority(final Priority than) {
++        return this.priority > than.priority;
++    }
++
++    public boolean isHigherOrEqualPriority(final int than) {
++        return this.priority <= than;
++    }
++
++    public boolean isHigherPriority(final int than) {
++        return this.priority < than;
++    }
++
++    public boolean isLowerOrEqualPriority(final int than) {
++        return this.priority >= than;
++    }
++
++    public boolean isLowerPriority(final int than) {
++        return this.priority > than;
++    }
++
++    public static boolean isHigherOrEqualPriority(final int priority, final int than) {
++        return priority <= than;
++    }
++
++    public static boolean isHigherPriority(final int priority, final int than) {
++        return priority < than;
++    }
++
++    public static boolean isLowerOrEqualPriority(final int priority, final int than) {
++        return priority >= than;
++    }
++
++    public static boolean isLowerPriority(final int priority, final int than) {
++        return priority > than;
++    }
++
++    static final Priority[] PRIORITIES = Priority.values();
++
++    /** includes special priorities */
++    public static final int TOTAL_PRIORITIES = PRIORITIES.length;
++
++    public static final int TOTAL_SCHEDULABLE_PRIORITIES = TOTAL_PRIORITIES - 1;
++
++    public static Priority getPriority(final int priority) {
++        return PRIORITIES[priority + 1];
++    }
++
++    private static int priorityCounter;
++
++    private static int nextCounter() {
++        return priorityCounter++;
++    }
++
++    public final int priority;
++
++    private Priority() {
++        this(nextCounter());
++    }
++
++    private Priority(final int priority) {
++        this.priority = priority;
++    }
++}
+\ No newline at end of file
diff --git a/patches/server/1070-fixup-MC-Utils.patch b/patches/server/1070-fixup-MC-Utils.patch
new file mode 100644
index 0000000000..6bca72238a
--- /dev/null
+++ b/patches/server/1070-fixup-MC-Utils.patch
@@ -0,0 +1,87 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Spottedleaf <[email protected]>
+Date: Mon, 21 Oct 2024 12:21:54 -0700
+Subject: [PATCH] fixup! MC Utils
+
+
+diff --git a/src/main/java/ca/spottedleaf/moonrise/common/util/ChunkSystem.java b/src/main/java/ca/spottedleaf/moonrise/common/util/ChunkSystem.java
+index 0abba00741b39b69a7f167e5d2670f2565c9a752..96bbab283eb6c7e7863383fea0ddc62510391091 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/common/util/ChunkSystem.java
++++ b/src/main/java/ca/spottedleaf/moonrise/common/util/ChunkSystem.java
+@@ -1,6 +1,6 @@
+ package ca.spottedleaf.moonrise.common.util;
+ 
+-import ca.spottedleaf.concurrentutil.executor.standard.PrioritisedExecutor;
++import ca.spottedleaf.concurrentutil.util.Priority;
+ import ca.spottedleaf.moonrise.patches.chunk_system.level.ChunkSystemServerLevel;
+ import ca.spottedleaf.moonrise.patches.chunk_system.level.chunk.ChunkSystemLevelChunk;
+ import ca.spottedleaf.moonrise.patches.chunk_system.player.RegionizedPlayerChunkLoader;
+@@ -23,27 +23,27 @@ public final class ChunkSystem {
+     private static final Logger LOGGER = LogUtils.getLogger();
+ 
+     public static void scheduleChunkTask(final ServerLevel level, final int chunkX, final int chunkZ, final Runnable run) {
+-        scheduleChunkTask(level, chunkX, chunkZ, run, PrioritisedExecutor.Priority.NORMAL);
++        scheduleChunkTask(level, chunkX, chunkZ, run, Priority.NORMAL);
+     }
+ 
+-    public static void scheduleChunkTask(final ServerLevel level, final int chunkX, final int chunkZ, final Runnable run, final PrioritisedExecutor.Priority priority) {
++    public static void scheduleChunkTask(final ServerLevel level, final int chunkX, final int chunkZ, final Runnable run, final Priority priority) {
+         ((ChunkSystemServerLevel)level).moonrise$getChunkTaskScheduler().scheduleChunkTask(chunkX, chunkZ, run, priority);
+     }
+ 
+     public static void scheduleChunkLoad(final ServerLevel level, final int chunkX, final int chunkZ, final boolean gen,
+-                                         final ChunkStatus toStatus, final boolean addTicket, final PrioritisedExecutor.Priority priority,
++                                         final ChunkStatus toStatus, final boolean addTicket, final Priority priority,
+                                          final Consumer<ChunkAccess> onComplete) {
+         ((ChunkSystemServerLevel)level).moonrise$getChunkTaskScheduler().scheduleChunkLoad(chunkX, chunkZ, gen, toStatus, addTicket, priority, onComplete);
+     }
+ 
+     public static void scheduleChunkLoad(final ServerLevel level, final int chunkX, final int chunkZ, final ChunkStatus toStatus,
+-                                         final boolean addTicket, final PrioritisedExecutor.Priority priority, final Consumer<ChunkAccess> onComplete) {
++                                         final boolean addTicket, final Priority priority, final Consumer<ChunkAccess> onComplete) {
+         ((ChunkSystemServerLevel)level).moonrise$getChunkTaskScheduler().scheduleChunkLoad(chunkX, chunkZ, toStatus, addTicket, priority, onComplete);
+     }
+ 
+     public static void scheduleTickingState(final ServerLevel level, final int chunkX, final int chunkZ,
+                                             final FullChunkStatus toStatus, final boolean addTicket,
+-                                            final PrioritisedExecutor.Priority priority, final Consumer<LevelChunk> onComplete) {
++                                            final Priority priority, final Consumer<LevelChunk> onComplete) {
+         ((ChunkSystemServerLevel)level).moonrise$getChunkTaskScheduler().scheduleTickingState(chunkX, chunkZ, toStatus, addTicket, priority, onComplete);
+     }
+ 
+@@ -67,7 +67,7 @@ public final class ChunkSystem {
+         return getUpdatingChunkHolderCount(level) != 0;
+     }
+ 
+-    public static boolean screenEntity(final ServerLevel level, final Entity entity) {
++    public static boolean screenEntity(final ServerLevel level, final Entity entity, final boolean fromDisk, final boolean event) {
+         return true;
+     }
+ 
+diff --git a/src/main/java/net/minecraft/world/level/entity/PersistentEntitySectionManager.java b/src/main/java/net/minecraft/world/level/entity/PersistentEntitySectionManager.java
+index 6baa313b8201ed23193d7885c85606b0899ade3c..3eb38271b6ca26099b2da04c2d969e32fd72b2af 100644
+--- a/src/main/java/net/minecraft/world/level/entity/PersistentEntitySectionManager.java
++++ b/src/main/java/net/minecraft/world/level/entity/PersistentEntitySectionManager.java
+@@ -94,15 +94,13 @@ public class PersistentEntitySectionManager<T extends EntityAccess> implements A
+     private boolean addEntity(T entity, boolean existing) {
+         org.spigotmc.AsyncCatcher.catchOp("Entity add"); // Paper
+         // Paper start - chunk system hooks
+-        if (existing) {
+-            // I don't want to know why this is a generic type.
+-            Entity entityCasted = (Entity)entity;
+-            boolean wasRemoved = entityCasted.isRemoved();
+-            boolean screened = ca.spottedleaf.moonrise.common.util.ChunkSystem.screenEntity((net.minecraft.server.level.ServerLevel)entityCasted.level(), entityCasted);
+-            if ((!wasRemoved && entityCasted.isRemoved()) || !screened) {
+-                // removed by callback
+-                return false;
+-            }
++        // I don't want to know why this is a generic type.
++        Entity entityCasted = (Entity)entity;
++        boolean wasRemoved = entityCasted.isRemoved();
++        boolean screened = ca.spottedleaf.moonrise.common.util.ChunkSystem.screenEntity((net.minecraft.server.level.ServerLevel)entityCasted.level(), entityCasted, existing, false);
++        if ((!wasRemoved && entityCasted.isRemoved()) || !screened) {
++            // removed by callback
++            return false;
+         }
+         // Paper end - chunk system hooks
+         if (!this.addEntityUuid(entity)) {
diff --git a/patches/server/1071-Revert-Custom-table-implementation-for-blockstate-st.patch b/patches/server/1071-Revert-Custom-table-implementation-for-blockstate-st.patch
new file mode 100644
index 0000000000..fa362b310f
--- /dev/null
+++ b/patches/server/1071-Revert-Custom-table-implementation-for-blockstate-st.patch
@@ -0,0 +1,345 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Spottedleaf <[email protected]>
+Date: Mon, 21 Oct 2024 12:52:44 -0700
+Subject: [PATCH] Revert "Custom table implementation for blockstate state
+ lookups"
+
+This reverts commit 14a7e6521ba0ce6dc8ebf98a1ccce59a5ec6a194.
+
+TODO Replace via deleting the patch
+
+diff --git a/src/main/java/io/papermc/paper/util/table/ZeroCollidingReferenceStateTable.java b/src/main/java/io/papermc/paper/util/table/ZeroCollidingReferenceStateTable.java
+deleted file mode 100644
+index 57d0cd3ad6f972e986c72a57f1a6e36003f190c2..0000000000000000000000000000000000000000
+--- a/src/main/java/io/papermc/paper/util/table/ZeroCollidingReferenceStateTable.java
++++ /dev/null
+@@ -1,160 +0,0 @@
+-package io.papermc.paper.util.table;
+-
+-import com.google.common.collect.Table;
+-import net.minecraft.world.level.block.state.StateHolder;
+-import net.minecraft.world.level.block.state.properties.Property;
+-import java.util.Collection;
+-import java.util.HashSet;
+-import java.util.Map;
+-import java.util.Set;
+-
+-public final class ZeroCollidingReferenceStateTable {
+-
+-    // upper 32 bits: starting index
+-    // lower 32 bits: bitset for contained ids
+-    protected final long[] this_index_table;
+-    protected final Comparable<?>[] this_table;
+-    protected final StateHolder<?, ?> this_state;
+-
+-    protected long[] index_table;
+-    protected StateHolder<?, ?>[][] value_table;
+-
+-    public ZeroCollidingReferenceStateTable(final StateHolder<?, ?> state, final Map<Property<?>, Comparable<?>> this_map) {
+-        this.this_state = state;
+-        this.this_index_table = this.create_table(this_map.keySet());
+-
+-        int max_id = -1;
+-        for (final Property<?> property : this_map.keySet()) {
+-            final int id = lookup_vindex(property, this.this_index_table);
+-            if (id > max_id) {
+-                max_id = id;
+-            }
+-        }
+-
+-        this.this_table = new Comparable[max_id + 1];
+-        for (final Map.Entry<Property<?>, Comparable<?>> entry : this_map.entrySet()) {
+-            this.this_table[lookup_vindex(entry.getKey(), this.this_index_table)] = entry.getValue();
+-        }
+-    }
+-
+-    public void loadInTable(final Table<Property<?>, Comparable<?>, StateHolder<?, ?>> table,
+-                            final Map<Property<?>, Comparable<?>> this_map) {
+-        final Set<Property<?>> combined = new HashSet<>(table.rowKeySet());
+-        combined.addAll(this_map.keySet());
+-
+-        this.index_table = this.create_table(combined);
+-
+-        int max_id = -1;
+-        for (final Property<?> property : combined) {
+-            final int id = lookup_vindex(property, this.index_table);
+-            if (id > max_id) {
+-                max_id = id;
+-            }
+-        }
+-
+-        this.value_table = new StateHolder[max_id + 1][];
+-
+-        final Map<Property<?>, Map<Comparable<?>, StateHolder<?, ?>>> map = table.rowMap();
+-        for (final Property<?> property : map.keySet()) {
+-            final Map<Comparable<?>, StateHolder<?, ?>> propertyMap = map.get(property);
+-
+-            final int id = lookup_vindex(property, this.index_table);
+-            final StateHolder<?, ?>[] states = this.value_table[id] = new StateHolder[property.getPossibleValues().size()];
+-
+-            for (final Map.Entry<Comparable<?>, StateHolder<?, ?>> entry : propertyMap.entrySet()) {
+-                if (entry.getValue() == null) {
+-                    // TODO what
+-                    continue;
+-                }
+-
+-                states[((Property)property).getIdFor(entry.getKey())] = entry.getValue();
+-            }
+-        }
+-
+-
+-        for (final Map.Entry<Property<?>, Comparable<?>> entry : this_map.entrySet()) {
+-            final Property<?> property = entry.getKey();
+-            final int index = lookup_vindex(property, this.index_table);
+-
+-            if (this.value_table[index] == null) {
+-                this.value_table[index] = new StateHolder[property.getPossibleValues().size()];
+-            }
+-
+-            this.value_table[index][((Property)property).getIdFor(entry.getValue())] = this.this_state;
+-        }
+-    }
+-
+-
+-    protected long[] create_table(final Collection<Property<?>> collection) {
+-        int max_id = -1;
+-        for (final Property<?> property : collection) {
+-            final int id = property.getId();
+-            if (id > max_id) {
+-                max_id = id;
+-            }
+-        }
+-
+-        final long[] ret = new long[((max_id + 1) + 31) >>> 5]; // ceil((max_id + 1) / 32)
+-
+-        for (final Property<?> property : collection) {
+-            final int id = property.getId();
+-
+-            ret[id >>> 5] |= (1L << (id & 31));
+-        }
+-
+-        int total = 0;
+-        for (int i = 1, len = ret.length; i < len; ++i) {
+-            ret[i] |= (long)(total += Long.bitCount(ret[i - 1] & 0xFFFFFFFFL)) << 32;
+-        }
+-
+-        return ret;
+-    }
+-
+-    public Comparable<?> get(final Property<?> state) {
+-        final Comparable<?>[] table = this.this_table;
+-        final int index = lookup_vindex(state, this.this_index_table);
+-
+-        if (index < 0 || index >= table.length) {
+-            return null;
+-        }
+-        return table[index];
+-    }
+-
+-    public StateHolder<?, ?> get(final Property<?> property, final Comparable<?> with) {
+-        final int withId = ((Property)property).getIdFor(with);
+-        if (withId < 0) {
+-            return null;
+-        }
+-
+-        final int index = lookup_vindex(property, this.index_table);
+-        final StateHolder<?, ?>[][] table = this.value_table;
+-        if (index < 0 || index >= table.length) {
+-            return null;
+-        }
+-
+-        final StateHolder<?, ?>[] values = table[index];
+-
+-        if (withId >= values.length) {
+-            return null;
+-        }
+-
+-        return values[withId];
+-    }
+-
+-    protected static int lookup_vindex(final Property<?> property, final long[] index_table) {
+-        final int id = property.getId();
+-        final long bitset_mask = (1L << (id & 31));
+-        final long lower_mask = bitset_mask - 1;
+-        final int index = id >>> 5;
+-        if (index >= index_table.length) {
+-            return -1;
+-        }
+-        final long index_value = index_table[index];
+-        final long contains_check = ((index_value & bitset_mask) - 1) >> (Long.SIZE - 1); // -1L if doesn't contain
+-
+-        // index = total bits set in lower table values (upper 32 bits of index_value) plus total bits set in lower indices below id
+-        // contains_check is 0 if the bitset had id set, else it's -1: so index is unaffected if contains_check == 0,
+-        // otherwise it comes out as -1.
+-        return (int)(((index_value >>> 32) + Long.bitCount(index_value & lower_mask)) | contains_check);
+-    }
+-}
+diff --git a/src/main/java/net/minecraft/world/level/block/state/StateHolder.java b/src/main/java/net/minecraft/world/level/block/state/StateHolder.java
+index 45744d86e9582a93a0cec26009deea091080fbbe..daedcfd867ed6171fb61bdcbded417a11c8a5b0f 100644
+--- a/src/main/java/net/minecraft/world/level/block/state/StateHolder.java
++++ b/src/main/java/net/minecraft/world/level/block/state/StateHolder.java
+@@ -39,13 +39,11 @@ public abstract class StateHolder<O, S> {
+     private final Reference2ObjectArrayMap<Property<?>, Comparable<?>> values;
+     private Table<Property<?>, Comparable<?>, S> neighbours;
+     protected final MapCodec<S> propertiesCodec;
+-    protected final io.papermc.paper.util.table.ZeroCollidingReferenceStateTable optimisedTable; // Paper - optimise state lookup
+ 
+     protected StateHolder(O owner, Reference2ObjectArrayMap<Property<?>, Comparable<?>> propertyMap, MapCodec<S> codec) {
+         this.owner = owner;
+         this.values = propertyMap;
+         this.propertiesCodec = codec;
+-        this.optimisedTable = new io.papermc.paper.util.table.ZeroCollidingReferenceStateTable(this, propertyMap); // Paper - optimise state lookup
+     }
+ 
+     public <T extends Comparable<T>> S cycle(Property<T> property) {
+@@ -86,11 +84,11 @@ public abstract class StateHolder<O, S> {
+     }
+ 
+     public <T extends Comparable<T>> boolean hasProperty(Property<T> property) {
+-        return this.optimisedTable.get(property) != null; // Paper - optimise state lookup
++        return this.values.containsKey(property);
+     }
+ 
+     public <T extends Comparable<T>> T getValue(Property<T> property) {
+-        Comparable<?> comparable = this.optimisedTable.get(property); // Paper - optimise state lookup
++        Comparable<?> comparable = this.values.get(property);
+         if (comparable == null) {
+             throw new IllegalArgumentException("Cannot get property " + property + " as it does not exist in " + this.owner);
+         } else {
+@@ -99,18 +97,24 @@ public abstract class StateHolder<O, S> {
+     }
+ 
+     public <T extends Comparable<T>> Optional<T> getOptionalValue(Property<T> property) {
+-        Comparable<?> comparable = this.optimisedTable.get(property); // Paper - optimise state lookup
++        Comparable<?> comparable = this.values.get(property);
+         return comparable == null ? Optional.empty() : Optional.of(property.getValueClass().cast(comparable));
+     }
+ 
+     public <T extends Comparable<T>, V extends T> S setValue(Property<T> property, V value) {
+-        // Paper start - optimise state lookup
+-        final S ret = (S)this.optimisedTable.get(property, value);
+-        if (ret == null) {
+-            throw new IllegalArgumentException("Cannot set property " + property + " to " + value + " on " + this.owner + ", it is not an allowed value");
++        Comparable<?> comparable = this.values.get(property);
++        if (comparable == null) {
++            throw new IllegalArgumentException("Cannot set property " + property + " as it does not exist in " + this.owner);
++        } else if (comparable.equals(value)) {
++            return (S)this;
++        } else {
++            S object = this.neighbours.get(property, value);
++            if (object == null) {
++                throw new IllegalArgumentException("Cannot set property " + property + " to " + value + " on " + this.owner + ", it is not an allowed value");
++            } else {
++                return object;
++            }
+         }
+-        return ret;
+-        // Paper end - optimise state lookup
+     }
+ 
+     public <T extends Comparable<T>, V extends T> S trySetValue(Property<T> property, V value) {
+@@ -143,7 +147,7 @@ public abstract class StateHolder<O, S> {
+                 }
+             }
+ 
+-            this.neighbours = (Table<Property<?>, Comparable<?>, S>)(table.isEmpty() ? table : ArrayTable.create(table)); this.optimisedTable.loadInTable((Table)this.neighbours, this.values); // Paper - optimise state lookup
++            this.neighbours = (Table<Property<?>, Comparable<?>, S>)(table.isEmpty() ? table : ArrayTable.create(table));
+         }
+     }
+ 
+diff --git a/src/main/java/net/minecraft/world/level/block/state/properties/BooleanProperty.java b/src/main/java/net/minecraft/world/level/block/state/properties/BooleanProperty.java
+index ff5fd91257c4554c523682009efe1db83f53fd5b..b63116b333b6e06494091a82588acfb639bddb71 100644
+--- a/src/main/java/net/minecraft/world/level/block/state/properties/BooleanProperty.java
++++ b/src/main/java/net/minecraft/world/level/block/state/properties/BooleanProperty.java
+@@ -7,13 +7,6 @@ import java.util.Optional;
+ public class BooleanProperty extends Property<Boolean> {
+     private final ImmutableSet<Boolean> values = ImmutableSet.of(true, false);
+ 
+-    // Paper start - optimise iblockdata state lookup
+-    @Override
+-    public final int getIdFor(final Boolean value) {
+-        return value.booleanValue() ? 1 : 0;
+-    }
+-    // Paper end - optimise iblockdata state lookup
+-
+     protected BooleanProperty(String name) {
+         super(name, Boolean.class);
+     }
+diff --git a/src/main/java/net/minecraft/world/level/block/state/properties/EnumProperty.java b/src/main/java/net/minecraft/world/level/block/state/properties/EnumProperty.java
+index 498c5abe0a9d024d77029719c621c1c8485791f3..3097298fe356df98967cf4bdeaaede69dfe8a441 100644
+--- a/src/main/java/net/minecraft/world/level/block/state/properties/EnumProperty.java
++++ b/src/main/java/net/minecraft/world/level/block/state/properties/EnumProperty.java
+@@ -15,15 +15,6 @@ public class EnumProperty<T extends Enum<T> & StringRepresentable> extends Prope
+     private final ImmutableSet<T> values;
+     private final Map<String, T> names = Maps.newHashMap();
+ 
+-    // Paper start - optimise iblockdata state lookup
+-    private int[] idLookupTable;
+-
+-    @Override
+-    public final int getIdFor(final T value) {
+-        return this.idLookupTable[value.ordinal()];
+-    }
+-    // Paper end - optimise iblockdata state lookup
+-
+     protected EnumProperty(String name, Class<T> type, Collection<T> values) {
+         super(name, type);
+         this.values = ImmutableSet.copyOf(values);
+@@ -36,14 +27,6 @@ public class EnumProperty<T extends Enum<T> & StringRepresentable> extends Prope
+ 
+             this.names.put(string, enum_);
+         }
+-        // Paper start - optimise BlockState lookup
+-        int id = 0;
+-        this.idLookupTable = new int[type.getEnumConstants().length];
+-        java.util.Arrays.fill(this.idLookupTable, -1);
+-        for (final T value : this.getPossibleValues()) {
+-            this.idLookupTable[value.ordinal()] = id++;
+-        }
+-        // Paper end - optimise BlockState lookup
+     }
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/level/block/state/properties/IntegerProperty.java b/src/main/java/net/minecraft/world/level/block/state/properties/IntegerProperty.java
+index 977504f2641d0133a572b0d5de85d058609343bb..3a850321a4bcc68058483b5fd53e829c425a68af 100644
+--- a/src/main/java/net/minecraft/world/level/block/state/properties/IntegerProperty.java
++++ b/src/main/java/net/minecraft/world/level/block/state/properties/IntegerProperty.java
+@@ -11,16 +11,6 @@ public class IntegerProperty extends Property<Integer> {
+     public final int min;
+     public final int max;
+ 
+-    // Paper start - optimise iblockdata state lookup
+-    @Override
+-    public final int getIdFor(final Integer value) {
+-        final int val = value.intValue();
+-        final int ret = val - this.min;
+-
+-        return ret | ((this.max - ret) >> 31);
+-    }
+-    // Paper end - optimise iblockdata state lookup
+-
+     protected IntegerProperty(String name, int min, int max) {
+         super(name, Integer.class);
+         if (min < 0) {
+diff --git a/src/main/java/net/minecraft/world/level/block/state/properties/Property.java b/src/main/java/net/minecraft/world/level/block/state/properties/Property.java
+index b9493e3762410aca8e683c32b5aef187c0bee082..9055f15af0cae55effa6942913a9d7edf3857e07 100644
+--- a/src/main/java/net/minecraft/world/level/block/state/properties/Property.java
++++ b/src/main/java/net/minecraft/world/level/block/state/properties/Property.java
+@@ -24,17 +24,6 @@ public abstract class Property<T extends Comparable<T>> {
+         );
+     private final Codec<Property.Value<T>> valueCodec = this.codec.xmap(this::value, Property.Value::value);
+ 
+-    // Paper start - optimise iblockdata state lookup
+-    private static final java.util.concurrent.atomic.AtomicInteger ID_GENERATOR = new java.util.concurrent.atomic.AtomicInteger();
+-    private final int id = ID_GENERATOR.getAndIncrement();
+-
+-    public final int getId() {
+-        return this.id;
+-    }
+-
+-    public abstract int getIdFor(final T value);
+-    // Paper end - optimise state lookup
+-
+     protected Property(String name, Class<T> type) {
+         this.clazz = type;
+         this.name = name;
diff --git a/patches/server/1072-fixup-Optimize-BlockPosition-helper-methods.patch b/patches/server/1072-fixup-Optimize-BlockPosition-helper-methods.patch
new file mode 100644
index 0000000000..f68e9eae92
--- /dev/null
+++ b/patches/server/1072-fixup-Optimize-BlockPosition-helper-methods.patch
@@ -0,0 +1,64 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Spottedleaf <[email protected]>
+Date: Mon, 21 Oct 2024 19:13:43 -0700
+Subject: [PATCH] fixup! Optimize BlockPosition helper methods
+
+
+diff --git a/src/main/java/net/minecraft/core/BlockPos.java b/src/main/java/net/minecraft/core/BlockPos.java
+index 2767d6f97e8b314d23a8e62f22dfd396f5660d31..7362d471f9c1858e0dd7832e1ff59e3e51d7f249 100644
+--- a/src/main/java/net/minecraft/core/BlockPos.java
++++ b/src/main/java/net/minecraft/core/BlockPos.java
+@@ -161,7 +161,7 @@ public class BlockPos extends Vec3i {
+ 
+     @Override
+     public BlockPos above(int distance) {
+-        return distance == 0 ? this : new BlockPos(this.getX(), this.getY() + distance, this.getZ()); // Paper - Perf: Optimize BlockPosition
++        return distance == 0 ? this.immutable() : new BlockPos(this.getX(), this.getY() + distance, this.getZ()); // Paper - Perf: Optimize BlockPosition
+     }
+ 
+     @Override
+@@ -171,7 +171,7 @@ public class BlockPos extends Vec3i {
+ 
+     @Override
+     public BlockPos below(int i) {
+-        return i == 0 ? this : new BlockPos(this.getX(), this.getY() - i, this.getZ()); // Paper - Perf: Optimize BlockPosition
++        return i == 0 ? this.immutable() : new BlockPos(this.getX(), this.getY() - i, this.getZ()); // Paper - Perf: Optimize BlockPosition
+     }
+ 
+     @Override
+@@ -181,7 +181,7 @@ public class BlockPos extends Vec3i {
+ 
+     @Override
+     public BlockPos north(int distance) {
+-        return distance == 0 ? this : new BlockPos(this.getX(), this.getY(), this.getZ() - distance); // Paper - Perf: Optimize BlockPosition
++        return distance == 0 ? this.immutable() : new BlockPos(this.getX(), this.getY(), this.getZ() - distance); // Paper - Perf: Optimize BlockPosition
+     }
+ 
+     @Override
+@@ -191,7 +191,7 @@ public class BlockPos extends Vec3i {
+ 
+     @Override
+     public BlockPos south(int distance) {
+-        return distance == 0 ? this : new BlockPos(this.getX(), this.getY(), this.getZ() + distance); // Paper - Perf: Optimize BlockPosition
++        return distance == 0 ? this.immutable() : new BlockPos(this.getX(), this.getY(), this.getZ() + distance); // Paper - Perf: Optimize BlockPosition
+     }
+ 
+     @Override
+@@ -201,7 +201,7 @@ public class BlockPos extends Vec3i {
+ 
+     @Override
+     public BlockPos west(int distance) {
+-        return distance == 0 ? this : new BlockPos(this.getX() - distance, this.getY(), this.getZ()); // Paper - Perf: Optimize BlockPosition
++        return distance == 0 ? this.immutable() : new BlockPos(this.getX() - distance, this.getY(), this.getZ()); // Paper - Perf: Optimize BlockPosition
+     }
+ 
+     @Override
+@@ -211,7 +211,7 @@ public class BlockPos extends Vec3i {
+ 
+     @Override
+     public BlockPos east(int distance) {
+-        return distance == 0 ? this : new BlockPos(this.getX() + distance, this.getY(), this.getZ()); // Paper - Perf: Optimize BlockPosition
++        return distance == 0 ? this.immutable() : new BlockPos(this.getX() + distance, this.getY(), this.getZ()); // Paper - Perf: Optimize BlockPosition
+     }
+ 
+     @Override
diff --git a/patches/server/1073-fixup-Moonrise-optimisation-patches.patch b/patches/server/1073-fixup-Moonrise-optimisation-patches.patch
new file mode 100644
index 0000000000..42a3be5122
--- /dev/null
+++ b/patches/server/1073-fixup-Moonrise-optimisation-patches.patch
@@ -0,0 +1,14304 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Spottedleaf <[email protected]>
+Date: Mon, 21 Oct 2024 11:06:24 -0700
+Subject: [PATCH] fixup! Moonrise optimisation patches
+
+
+diff --git a/src/main/java/ca/spottedleaf/moonrise/common/PlatformHooks.java b/src/main/java/ca/spottedleaf/moonrise/common/PlatformHooks.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..69a20e9d72b02f28b349f24fd0ea08736888e642
+--- /dev/null
++++ b/src/main/java/ca/spottedleaf/moonrise/common/PlatformHooks.java
+@@ -0,0 +1,115 @@
++package ca.spottedleaf.moonrise.common;
++
++import ca.spottedleaf.moonrise.patches.chunk_system.scheduling.NewChunkHolder;
++import com.mojang.datafixers.DataFixer;
++import net.minecraft.core.BlockPos;
++import net.minecraft.nbt.CompoundTag;
++import net.minecraft.server.level.GenerationChunkHolder;
++import net.minecraft.server.level.ServerLevel;
++import net.minecraft.server.level.ServerPlayer;
++import net.minecraft.util.datafix.DataFixTypes;
++import net.minecraft.world.entity.Entity;
++import net.minecraft.world.level.BlockGetter;
++import net.minecraft.world.level.ChunkPos;
++import net.minecraft.world.level.Level;
++import net.minecraft.world.level.block.state.BlockState;
++import net.minecraft.world.level.chunk.ChunkAccess;
++import net.minecraft.world.level.chunk.LevelChunk;
++import net.minecraft.world.level.chunk.ProtoChunk;
++import net.minecraft.world.level.chunk.storage.SerializableChunkData;
++import net.minecraft.world.level.entity.EntityTypeTest;
++import net.minecraft.world.phys.AABB;
++import java.util.List;
++import java.util.ServiceLoader;
++import java.util.function.Predicate;
++
++public interface PlatformHooks {
++    public static PlatformHooks get() {
++        return Holder.INSTANCE;
++    }
++
++    public String getBrand();
++
++    public int getLightEmission(final BlockState blockState, final BlockGetter world, final BlockPos pos);
++
++    public Predicate<BlockState> maybeHasLightEmission();
++
++    public boolean hasCurrentlyLoadingChunk();
++
++    public LevelChunk getCurrentlyLoadingChunk(final GenerationChunkHolder holder);
++
++    public void setCurrentlyLoading(final GenerationChunkHolder holder, final LevelChunk levelChunk);
++
++    public void chunkFullStatusComplete(final LevelChunk newChunk, final ProtoChunk original);
++
++    public boolean allowAsyncTicketUpdates();
++
++    public void onChunkHolderTicketChange(final ServerLevel world, final NewChunkHolder holder, final int oldLevel, final int newLevel);
++
++    public void chunkUnloadFromWorld(final LevelChunk chunk);
++
++    public void chunkSyncSave(final ServerLevel world, final ChunkAccess chunk, final SerializableChunkData data);
++
++    public void onChunkWatch(final ServerLevel world, final LevelChunk chunk, final ServerPlayer player);
++
++    public void onChunkUnWatch(final ServerLevel world, final ChunkPos chunk, final ServerPlayer player);
++
++    public void addToGetEntities(final Level world, final Entity entity, final AABB boundingBox, final Predicate<? super Entity> predicate,
++                                 final List<Entity> into);
++
++    public <T extends Entity> void addToGetEntities(final Level world, final EntityTypeTest<Entity, T> entityTypeTest,
++                                                    final AABB boundingBox, final Predicate<? super T> predicate,
++                                                    final List<? super T> into, final int maxCount);
++
++    public void entityMove(final Entity entity, final long oldSection, final long newSection);
++
++    public boolean screenEntity(final ServerLevel world, final Entity entity, final boolean fromDisk, final boolean event);
++
++    public boolean configFixMC224294();
++
++    public boolean configAutoConfigSendDistance();
++
++    public double configPlayerMaxLoadRate();
++
++    public double configPlayerMaxGenRate();
++
++    public double configPlayerMaxSendRate();
++
++    public int configPlayerMaxConcurrentLoads();
++
++    public int configPlayerMaxConcurrentGens();
++
++    public long configAutoSaveInterval();
++
++    public int configMaxAutoSavePerTick();
++
++    public boolean configFixMC159283();
++
++    // support for CB chunk mustNotSave
++    public boolean forceNoSave(final ChunkAccess chunk);
++
++    public CompoundTag convertNBT(final DataFixTypes type, final DataFixer dataFixer, final CompoundTag nbt,
++                                  final int fromVersion, final int toVersion);
++
++    public boolean hasMainChunkLoadHook();
++
++    public void mainChunkLoad(final ChunkAccess chunk, final SerializableChunkData chunkData);
++
++    public List<Entity> modifySavedEntities(final ServerLevel world, final int chunkX, final int chunkZ, final List<Entity> entities);
++
++    public void unloadEntity(final Entity entity);
++
++    public int modifyEntityTrackingRange(final Entity entity, final int currentRange);
++
++    public static final class Holder {
++        private Holder() {
++        }
++
++        private static final PlatformHooks INSTANCE;
++
++        static {
++            INSTANCE = ServiceLoader.load(PlatformHooks.class, PlatformHooks.class.getClassLoader()).findFirst()
++                .orElseThrow(() -> new RuntimeException("Failed to locate PlatformHooks"));
++        }
++    }
++}
+diff --git a/src/main/java/ca/spottedleaf/moonrise/common/list/EntityList.java b/src/main/java/ca/spottedleaf/moonrise/common/list/EntityList.java
+index ba68998f6ef57b24c72fd833bd7de440de9501cc..7fed43a1e7bcf35c4d7fd3224837a47fedd59860 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/common/list/EntityList.java
++++ b/src/main/java/ca/spottedleaf/moonrise/common/list/EntityList.java
+@@ -13,15 +13,15 @@ import java.util.NoSuchElementException;
+  */
+ public final class EntityList implements Iterable<Entity> {
+ 
+-    protected final Int2IntOpenHashMap entityToIndex = new Int2IntOpenHashMap(2, 0.8f);
++    private final Int2IntOpenHashMap entityToIndex = new Int2IntOpenHashMap(2, 0.8f);
+     {
+         this.entityToIndex.defaultReturnValue(Integer.MIN_VALUE);
+     }
+ 
+-    protected static final Entity[] EMPTY_LIST = new Entity[0];
++    private static final Entity[] EMPTY_LIST = new Entity[0];
+ 
+-    protected Entity[] entities = EMPTY_LIST;
+-    protected int count;
++    private Entity[] entities = EMPTY_LIST;
++    private int count;
+ 
+     public int size() {
+         return this.count;
+@@ -94,10 +94,9 @@ public final class EntityList implements Iterable<Entity> {
+ 
+     @Override
+     public Iterator<Entity> iterator() {
+-        return new Iterator<Entity>() {
+-
+-            Entity lastRet;
+-            int current;
++        return new Iterator<>() {
++            private Entity lastRet;
++            private int current;
+ 
+             @Override
+             public boolean hasNext() {
+diff --git a/src/main/java/ca/spottedleaf/moonrise/common/list/IBlockDataList.java b/src/main/java/ca/spottedleaf/moonrise/common/list/IBlockDataList.java
+deleted file mode 100644
+index fcfbca333234c09f7c056bbfcd9ac8860b20a8db..0000000000000000000000000000000000000000
+--- a/src/main/java/ca/spottedleaf/moonrise/common/list/IBlockDataList.java
++++ /dev/null
+@@ -1,125 +0,0 @@
+-package ca.spottedleaf.moonrise.common.list;
+-
+-import it.unimi.dsi.fastutil.longs.LongIterator;
+-import it.unimi.dsi.fastutil.shorts.Short2LongOpenHashMap;
+-import java.util.Arrays;
+-import net.minecraft.world.level.block.Block;
+-import net.minecraft.world.level.block.state.BlockState;
+-import net.minecraft.world.level.chunk.GlobalPalette;
+-
+-public final class IBlockDataList {
+-
+-    private static final GlobalPalette<BlockState> GLOBAL_PALETTE = new GlobalPalette<>(Block.BLOCK_STATE_REGISTRY);
+-
+-    // map of location -> (index | (location << 16) | (palette id << 32))
+-    private final Short2LongOpenHashMap map = new Short2LongOpenHashMap(2, 0.8f);
+-    {
+-        this.map.defaultReturnValue(Long.MAX_VALUE);
+-    }
+-
+-    private static final long[] EMPTY_LIST = new long[0];
+-
+-    private long[] byIndex = EMPTY_LIST;
+-    private int size;
+-
+-    public static int getLocationKey(final int x, final int y, final int z) {
+-        return (x & 15) | (((z & 15) << 4)) | ((y & 255) << (4 + 4));
+-    }
+-
+-    public static BlockState getBlockDataFromRaw(final long raw) {
+-        return GLOBAL_PALETTE.valueFor((int)(raw >>> 32));
+-    }
+-
+-    public static int getIndexFromRaw(final long raw) {
+-        return (int)(raw & 0xFFFF);
+-    }
+-
+-    public static int getLocationFromRaw(final long raw) {
+-        return (int)((raw >>> 16) & 0xFFFF);
+-    }
+-
+-    public static long getRawFromValues(final int index, final int location, final BlockState data) {
+-        return (long)index | ((long)location << 16) | (((long)GLOBAL_PALETTE.idFor(data)) << 32);
+-    }
+-
+-    public static long setIndexRawValues(final long value, final int index) {
+-        return value & ~(0xFFFF) | (index);
+-    }
+-
+-    public long add(final int x, final int y, final int z, final BlockState data) {
+-        return this.add(getLocationKey(x, y, z), data);
+-    }
+-
+-    public long add(final int location, final BlockState data) {
+-        final long curr = this.map.get((short)location);
+-
+-        if (curr == Long.MAX_VALUE) {
+-            final int index = this.size++;
+-            final long raw = getRawFromValues(index, location, data);
+-            this.map.put((short)location, raw);
+-
+-            if (index >= this.byIndex.length) {
+-                this.byIndex = Arrays.copyOf(this.byIndex, (int)Math.max(4L, this.byIndex.length * 2L));
+-            }
+-
+-            this.byIndex[index] = raw;
+-            return raw;
+-        } else {
+-            final int index = getIndexFromRaw(curr);
+-            final long raw = this.byIndex[index] = getRawFromValues(index, location, data);
+-
+-            this.map.put((short)location, raw);
+-
+-            return raw;
+-        }
+-    }
+-
+-    public long remove(final int x, final int y, final int z) {
+-        return this.remove(getLocationKey(x, y, z));
+-    }
+-
+-    public long remove(final int location) {
+-        final long ret = this.map.remove((short)location);
+-        final int index = getIndexFromRaw(ret);
+-        if (ret == Long.MAX_VALUE) {
+-            return ret;
+-        }
+-
+-        // move the entry at the end to this index
+-        final int endIndex = --this.size;
+-        final long end = this.byIndex[endIndex];
+-        if (index != endIndex) {
+-            // not empty after this call
+-            this.map.put((short)getLocationFromRaw(end), setIndexRawValues(end, index));
+-        }
+-        this.byIndex[index] = end;
+-        this.byIndex[endIndex] = 0L;
+-
+-        return ret;
+-    }
+-
+-    public int size() {
+-        return this.size;
+-    }
+-
+-    public long getRaw(final int index) {
+-        return this.byIndex[index];
+-    }
+-
+-    public int getLocation(final int index) {
+-        return getLocationFromRaw(this.getRaw(index));
+-    }
+-
+-    public BlockState getData(final int index) {
+-        return getBlockDataFromRaw(this.getRaw(index));
+-    }
+-
+-    public void clear() {
+-        this.size = 0;
+-        this.map.clear();
+-    }
+-
+-    public LongIterator getRawIterator() {
+-        return this.map.values().iterator();
+-    }
+-}
+\ No newline at end of file
+diff --git a/src/main/java/ca/spottedleaf/moonrise/common/list/IntList.java b/src/main/java/ca/spottedleaf/moonrise/common/list/IntList.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..9f3b25bb2439f283f878db93973a02fcdcd14eed
+--- /dev/null
++++ b/src/main/java/ca/spottedleaf/moonrise/common/list/IntList.java
+@@ -0,0 +1,77 @@
++package ca.spottedleaf.moonrise.common.list;
++
++import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap;
++import java.util.Arrays;
++
++public final class IntList {
++
++    private final Int2IntOpenHashMap map = new Int2IntOpenHashMap();
++    {
++        this.map.defaultReturnValue(Integer.MIN_VALUE);
++    }
++
++    private static final int[] EMPTY_LIST = new int[0];
++
++    private int[] byIndex = EMPTY_LIST;
++    private int count;
++
++    public int size() {
++        return this.count;
++    }
++
++    public void setMinCapacity(final int len) {
++        final int[] byIndex = this.byIndex;
++        if (byIndex.length < len) {
++            this.byIndex = Arrays.copyOf(byIndex, len);
++        }
++    }
++
++    public int getRaw(final int index) {
++        return this.byIndex[index];
++    }
++
++    public boolean add(final int value) {
++        final int count = this.count;
++        final int currIndex = this.map.putIfAbsent(value, count);
++
++        if (currIndex != Integer.MIN_VALUE) {
++            return false; // already in this list
++        }
++
++        int[] list = this.byIndex;
++
++        if (list.length == count) {
++            // resize required
++            list = this.byIndex = Arrays.copyOf(list, (int)Math.max(4L, count * 2L)); // overflow results in negative
++        }
++
++        list[count] = value;
++        this.count = count + 1;
++
++        return true;
++    }
++
++    public boolean remove(final int value) {
++        final int index = this.map.remove(value);
++        if (index == Integer.MIN_VALUE) {
++            return false;
++        }
++
++        // move the entry at the end to this index
++        final int endIndex = --this.count;
++        final int end = this.byIndex[endIndex];
++        if (index != endIndex) {
++            // not empty after this call
++            this.map.put(end, index);
++        }
++        this.byIndex[index] = end;
++        this.byIndex[endIndex] = 0;
++
++        return true;
++    }
++
++    public void clear() {
++        this.count = 0;
++        this.map.clear();
++    }
++}
+diff --git a/src/main/java/ca/spottedleaf/moonrise/common/list/ShortList.java b/src/main/java/ca/spottedleaf/moonrise/common/list/ShortList.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..2bae9949ef325d0001aa638150fbbdf968367e75
+--- /dev/null
++++ b/src/main/java/ca/spottedleaf/moonrise/common/list/ShortList.java
+@@ -0,0 +1,77 @@
++package ca.spottedleaf.moonrise.common.list;
++
++import it.unimi.dsi.fastutil.shorts.Short2ShortOpenHashMap;
++import java.util.Arrays;
++
++public final class ShortList {
++
++    private final Short2ShortOpenHashMap map = new Short2ShortOpenHashMap();
++    {
++        this.map.defaultReturnValue(Short.MIN_VALUE);
++    }
++
++    private static final short[] EMPTY_LIST = new short[0];
++
++    private short[] byIndex = EMPTY_LIST;
++    private short count;
++
++    public int size() {
++        return (int)this.count;
++    }
++
++    public short getRaw(final int index) {
++        return this.byIndex[index];
++    }
++
++    public void setMinCapacity(final int len) {
++        final short[] byIndex = this.byIndex;
++        if (byIndex.length < len) {
++            this.byIndex = Arrays.copyOf(byIndex, len);
++        }
++    }
++
++    public boolean add(final short value) {
++        final int count = (int)this.count;
++        final short currIndex = this.map.putIfAbsent(value, (short)count);
++
++        if (currIndex != Short.MIN_VALUE) {
++            return false; // already in this list
++        }
++
++        short[] list = this.byIndex;
++
++        if (list.length == count) {
++            // resize required
++            list = this.byIndex = Arrays.copyOf(list, (int)Math.max(4L, count * 2L)); // overflow results in negative
++        }
++
++        list[count] = value;
++        this.count = (short)(count + 1);
++
++        return true;
++    }
++
++    public boolean remove(final short value) {
++        final short index = this.map.remove(value);
++        if (index == Short.MIN_VALUE) {
++            return false;
++        }
++
++        // move the entry at the end to this index
++        final short endIndex = --this.count;
++        final short end = this.byIndex[endIndex];
++        if (index != endIndex) {
++            // not empty after this call
++            this.map.put(end, index);
++        }
++        this.byIndex[(int)index] = end;
++        this.byIndex[(int)endIndex] = (short)0;
++
++        return true;
++    }
++
++    public void clear() {
++        this.count = (short)0;
++        this.map.clear();
++    }
++}
+diff --git a/src/main/java/ca/spottedleaf/moonrise/common/misc/LazyRunnable.java b/src/main/java/ca/spottedleaf/moonrise/common/misc/LazyRunnable.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..c2d917c2eac55b8a4411a6e159f177f9428b1150
+--- /dev/null
++++ b/src/main/java/ca/spottedleaf/moonrise/common/misc/LazyRunnable.java
+@@ -0,0 +1,22 @@
++package ca.spottedleaf.moonrise.common.misc;
++
++import ca.spottedleaf.concurrentutil.util.ConcurrentUtil;
++import java.lang.invoke.VarHandle;
++
++public final class LazyRunnable implements Runnable {
++
++    private volatile Runnable toRun;
++    private static final VarHandle TO_RUN_HANDLE = ConcurrentUtil.getVarHandle(LazyRunnable.class, "toRun", Runnable.class);
++
++    public void setRunnable(final Runnable run) {
++        final Runnable prev = (Runnable)TO_RUN_HANDLE.compareAndExchange(this, (Runnable)null, run);
++        if (prev != null) {
++            throw new IllegalStateException("Runnable already set");
++        }
++    }
++
++    @Override
++    public void run() {
++        ((Runnable)TO_RUN_HANDLE.getVolatile(this)).run();
++    }
++}
+diff --git a/src/main/java/ca/spottedleaf/moonrise/common/misc/NearbyPlayers.java b/src/main/java/ca/spottedleaf/moonrise/common/misc/NearbyPlayers.java
+index ab093b0e8ac6f762921eb1d15f5217345c4eba05..bb44de17a37082e57f2292a4f470740be1d09b11 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/common/misc/NearbyPlayers.java
++++ b/src/main/java/ca/spottedleaf/moonrise/common/misc/NearbyPlayers.java
+@@ -4,13 +4,17 @@ import ca.spottedleaf.moonrise.common.list.ReferenceList;
+ import ca.spottedleaf.moonrise.common.util.CoordinateUtils;
+ import ca.spottedleaf.moonrise.common.util.MoonriseConstants;
+ import ca.spottedleaf.moonrise.common.util.ChunkSystem;
++import ca.spottedleaf.moonrise.patches.chunk_system.level.ChunkSystemLevel;
++import ca.spottedleaf.moonrise.patches.chunk_system.level.chunk.ChunkData;
+ import ca.spottedleaf.moonrise.patches.chunk_tick_iteration.ChunkTickConstants;
++import ca.spottedleaf.moonrise.patches.chunk_tick_iteration.ChunkTickServerLevel;
+ import it.unimi.dsi.fastutil.longs.Long2ReferenceOpenHashMap;
+ import it.unimi.dsi.fastutil.objects.Reference2ReferenceOpenHashMap;
+ import net.minecraft.core.BlockPos;
+ import net.minecraft.server.level.ServerLevel;
+ import net.minecraft.server.level.ServerPlayer;
+ import net.minecraft.world.level.ChunkPos;
++import java.util.ArrayList;
+ 
+ public final class NearbyPlayers {
+ 
+@@ -20,7 +24,27 @@ public final class NearbyPlayers {
+         GENERAL_REALLY_SMALL,
+         TICK_VIEW_DISTANCE,
+         VIEW_DISTANCE,
+-        SPAWN_RANGE, // Moonrise - chunk tick iteration
++        // Moonrise start - chunk tick iteration
++        SPAWN_RANGE {
++            @Override
++            void addTo(final ServerPlayer player, final ServerLevel world, final int chunkX, final int chunkZ) {
++                ((ChunkTickServerLevel)world).moonrise$addPlayerTickingRequest(chunkX, chunkZ);
++            }
++
++            @Override
++            void removeFrom(final ServerPlayer player, final ServerLevel world, final int chunkX, final int chunkZ) {
++                ((ChunkTickServerLevel)world).moonrise$removePlayerTickingRequest(chunkX, chunkZ);
++            }
++        };
++        // Moonrise end - chunk tick iteration
++
++        void addTo(final ServerPlayer player, final ServerLevel world, final int chunkX, final int chunkZ) {
++
++        }
++
++        void removeFrom(final ServerPlayer player, final ServerLevel world, final int chunkX, final int chunkZ) {
++
++        }
+     }
+ 
+     private static final NearbyMapType[] MAP_TYPES = NearbyMapType.values();
+@@ -37,6 +61,12 @@ public final class NearbyPlayers {
+     private final ServerLevel world;
+     private final Reference2ReferenceOpenHashMap<ServerPlayer, TrackedPlayer[]> players = new Reference2ReferenceOpenHashMap<>();
+     private final Long2ReferenceOpenHashMap<TrackedChunk> byChunk = new Long2ReferenceOpenHashMap<>();
++    private final Long2ReferenceOpenHashMap<ReferenceList<ServerPlayer>>[] directByChunk = new Long2ReferenceOpenHashMap[TOTAL_MAP_TYPES];
++    {
++        for (int i = 0; i < this.directByChunk.length; ++i) {
++            this.directByChunk[i] = new Long2ReferenceOpenHashMap<>();
++        }
++    }
+ 
+     public NearbyPlayers(final ServerLevel world) {
+         this.world = world;
+@@ -70,6 +100,16 @@ public final class NearbyPlayers {
+         }
+     }
+ 
++    public void clear() {
++        if (this.players.isEmpty()) {
++            return;
++        }
++
++        for (final ServerPlayer player : new ArrayList<>(this.players.keySet())) {
++            this.removePlayer(player);
++        }
++    }
++
+     public void tickPlayer(final ServerPlayer player) {
+         final TrackedPlayer[] players = this.players.get(player);
+         if (players == null) {
+@@ -94,38 +134,41 @@ public final class NearbyPlayers {
+         return this.byChunk.get(CoordinateUtils.getChunkKey(pos));
+     }
+ 
+-    public ReferenceList<ServerPlayer> getPlayers(final BlockPos pos, final NearbyMapType type) {
+-        final TrackedChunk chunk = this.byChunk.get(CoordinateUtils.getChunkKey(pos));
++    public TrackedChunk getChunk(final int chunkX, final int chunkZ) {
++        return this.byChunk.get(CoordinateUtils.getChunkKey(chunkX, chunkZ));
++    }
+ 
+-        return chunk == null ? null : chunk.players[type.ordinal()];
++    public ReferenceList<ServerPlayer> getPlayers(final BlockPos pos, final NearbyMapType type) {
++        return this.directByChunk[type.ordinal()].get(CoordinateUtils.getChunkKey(pos));
+     }
+ 
+     public ReferenceList<ServerPlayer> getPlayers(final ChunkPos pos, final NearbyMapType type) {
+-        final TrackedChunk chunk = this.byChunk.get(CoordinateUtils.getChunkKey(pos));
+-
+-        return chunk == null ? null : chunk.players[type.ordinal()];
++        return this.directByChunk[type.ordinal()].get(CoordinateUtils.getChunkKey(pos));
+     }
+ 
+     public ReferenceList<ServerPlayer> getPlayersByChunk(final int chunkX, final int chunkZ, final NearbyMapType type) {
+-        final TrackedChunk chunk = this.byChunk.get(CoordinateUtils.getChunkKey(chunkX, chunkZ));
+-
+-        return chunk == null ? null : chunk.players[type.ordinal()];
++        return this.directByChunk[type.ordinal()].get(CoordinateUtils.getChunkKey(chunkX, chunkZ));
+     }
+ 
+     public ReferenceList<ServerPlayer> getPlayersByBlock(final int blockX, final int blockZ, final NearbyMapType type) {
+-        final TrackedChunk chunk = this.byChunk.get(CoordinateUtils.getChunkKey(blockX >> 4, blockZ >> 4));
+-
+-        return chunk == null ? null : chunk.players[type.ordinal()];
++        return this.directByChunk[type.ordinal()].get(CoordinateUtils.getChunkKey(blockX >> 4, blockZ >> 4));
+     }
+ 
+     public static final class TrackedChunk {
+ 
+         private static final ServerPlayer[] EMPTY_PLAYERS_ARRAY = new ServerPlayer[0];
+ 
++        private final long chunkKey;
++        private final NearbyPlayers nearbyPlayers;
+         private final ReferenceList<ServerPlayer>[] players = new ReferenceList[TOTAL_MAP_TYPES];
+         private int nonEmptyLists;
+         private long updateCount;
+ 
++        public TrackedChunk(final long chunkKey, final NearbyPlayers nearbyPlayers) {
++            this.chunkKey = chunkKey;
++            this.nearbyPlayers = nearbyPlayers;
++        }
++
+         public boolean isEmpty() {
+             return this.nonEmptyLists == 0;
+         }
+@@ -145,7 +188,9 @@ public final class NearbyPlayers {
+             final ReferenceList<ServerPlayer> list = this.players[idx];
+             if (list == null) {
+                 ++this.nonEmptyLists;
+-                (this.players[idx] = new ReferenceList<>(EMPTY_PLAYERS_ARRAY)).add(player);
++                final ReferenceList<ServerPlayer> players = (this.players[idx] = new ReferenceList<>(EMPTY_PLAYERS_ARRAY));
++                this.nearbyPlayers.directByChunk[idx].put(this.chunkKey, players);
++                players.add(player);
+                 return;
+             }
+ 
+@@ -169,6 +214,7 @@ public final class NearbyPlayers {
+ 
+             if (list.size() == 0) {
+                 this.players[idx] = null;
++                this.nearbyPlayers.directByChunk[idx].remove(this.chunkKey);
+                 --this.nonEmptyLists;
+             }
+         }
+@@ -187,9 +233,19 @@ public final class NearbyPlayers {
+         protected void addCallback(final ServerPlayer parameter, final int chunkX, final int chunkZ) {
+             final long chunkKey = CoordinateUtils.getChunkKey(chunkX, chunkZ);
+ 
+-            NearbyPlayers.this.byChunk.computeIfAbsent(chunkKey, (final long keyInMap) -> {
+-                return new TrackedChunk();
+-            }).addPlayer(parameter, this.type);
++            final TrackedChunk chunk = NearbyPlayers.this.byChunk.get(chunkKey);
++            final NearbyMapType type = this.type;
++            if (chunk != null) {
++                chunk.addPlayer(parameter, type);
++                type.addTo(parameter, NearbyPlayers.this.world, chunkX, chunkZ);
++            } else {
++                final TrackedChunk created = new TrackedChunk(chunkKey, NearbyPlayers.this);
++                NearbyPlayers.this.byChunk.put(chunkKey, created);
++                created.addPlayer(parameter, type);
++                type.addTo(parameter, NearbyPlayers.this.world, chunkX, chunkZ);
++
++                ((ChunkSystemLevel)NearbyPlayers.this.world).moonrise$requestChunkData(chunkKey).nearbyPlayers = created;
++            }
+         }
+ 
+         @Override
+@@ -201,10 +257,16 @@ public final class NearbyPlayers {
+                 throw new IllegalStateException("Chunk should exist at " + new ChunkPos(chunkKey));
+             }
+ 
+-            chunk.removePlayer(parameter, this.type);
++            final NearbyMapType type = this.type;
++            chunk.removePlayer(parameter, type);
++            type.removeFrom(parameter, NearbyPlayers.this.world, chunkX, chunkZ);
+ 
+             if (chunk.isEmpty()) {
+                 NearbyPlayers.this.byChunk.remove(chunkKey);
++                final ChunkData chunkData = ((ChunkSystemLevel)NearbyPlayers.this.world).moonrise$releaseChunkData(chunkKey);
++                if (chunkData != null) {
++                    chunkData.nearbyPlayers = null;
++                }
+             }
+         }
+     }
+diff --git a/src/main/java/ca/spottedleaf/moonrise/common/util/ChunkSystem.java b/src/main/java/ca/spottedleaf/moonrise/common/util/ChunkSystem.java
+index 96bbab283eb6c7e7863383fea0ddc62510391091..fc029c8fb22a7c8eeb23bfc171812f6da91c60fa 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/common/util/ChunkSystem.java
++++ b/src/main/java/ca/spottedleaf/moonrise/common/util/ChunkSystem.java
+@@ -1,15 +1,18 @@
+ package ca.spottedleaf.moonrise.common.util;
+ 
+ import ca.spottedleaf.concurrentutil.util.Priority;
++import ca.spottedleaf.moonrise.common.PlatformHooks;
+ import ca.spottedleaf.moonrise.patches.chunk_system.level.ChunkSystemServerLevel;
+ import ca.spottedleaf.moonrise.patches.chunk_system.level.chunk.ChunkSystemLevelChunk;
+ import ca.spottedleaf.moonrise.patches.chunk_system.player.RegionizedPlayerChunkLoader;
+ import ca.spottedleaf.moonrise.patches.chunk_system.world.ChunkSystemServerChunkCache;
++import ca.spottedleaf.moonrise.patches.chunk_tick_iteration.ChunkTickServerLevel;
+ import com.mojang.logging.LogUtils;
+ import net.minecraft.server.level.ChunkHolder;
+ import net.minecraft.server.level.FullChunkStatus;
+ import net.minecraft.server.level.ServerLevel;
+ import net.minecraft.server.level.ServerPlayer;
++import net.minecraft.server.level.progress.ChunkProgressListener;
+ import net.minecraft.world.entity.Entity;
+ import net.minecraft.world.level.chunk.ChunkAccess;
+ import net.minecraft.world.level.chunk.LevelChunk;
+@@ -68,6 +71,9 @@ public final class ChunkSystem {
+     }
+ 
+     public static boolean screenEntity(final ServerLevel level, final Entity entity, final boolean fromDisk, final boolean event) {
++        if (!PlatformHooks.get().screenEntity(level, entity, fromDisk, event)) {
++            return false;
++        }
+         return true;
+     }
+ 
+@@ -76,7 +82,13 @@ public final class ChunkSystem {
+     }
+ 
+     public static void onChunkHolderDelete(final ServerLevel level, final ChunkHolder holder) {
+-
++        // Update progress listener for LevelLoadingScreen
++        final ChunkProgressListener progressListener = level.getChunkSource().chunkMap.progressListener;
++        if (progressListener != null) {
++            ChunkSystem.scheduleChunkTask(level, holder.getPos().x, holder.getPos().z, () -> {
++                progressListener.onStatusChange(holder.getPos(), null);
++            });
++        }
+     }
+ 
+     public static void onChunkPreBorder(final LevelChunk chunk, final ChunkHolder holder) {
+@@ -108,16 +120,18 @@ public final class ChunkSystem {
+                 ((ChunkSystemLevelChunk)chunk).moonrise$getChunkAndHolder()
+         );
+         if (!((ChunkSystemLevelChunk)chunk).moonrise$isPostProcessingDone()) {
+-            chunk.postProcessGeneration();
++            chunk.postProcessGeneration((ServerLevel)chunk.getLevel());
+         }
+         ((ServerLevel)chunk.getLevel()).startTickingChunk(chunk);
+         ((ServerLevel)chunk.getLevel()).getChunkSource().chunkMap.tickingGenerated.incrementAndGet();
++        ((ChunkTickServerLevel)(ServerLevel)chunk.getLevel()).moonrise$markChunkForPlayerTicking(chunk); // Moonrise - chunk tick iteration
+     }
+ 
+     public static void onChunkNotTicking(final LevelChunk chunk, final ChunkHolder holder) {
+         ((ChunkSystemServerLevel)((ServerLevel)chunk.getLevel())).moonrise$getTickingChunks().remove(
+                 ((ChunkSystemLevelChunk)chunk).moonrise$getChunkAndHolder()
+         );
++        ((ChunkTickServerLevel)(ServerLevel)chunk.getLevel()).moonrise$removeChunkForPlayerTicking(chunk); // Moonrise - chunk tick iteration
+     }
+ 
+     public static void onChunkEntityTicking(final LevelChunk chunk, final ChunkHolder holder) {
+diff --git a/src/main/java/ca/spottedleaf/moonrise/common/util/MixinWorkarounds.java b/src/main/java/ca/spottedleaf/moonrise/common/util/MixinWorkarounds.java
+index ac6f284ee4469d16c5655328b2488d7612832353..97848869df61648fc415e4d39f409f433202c274 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/common/util/MixinWorkarounds.java
++++ b/src/main/java/ca/spottedleaf/moonrise/common/util/MixinWorkarounds.java
+@@ -3,8 +3,12 @@ package ca.spottedleaf.moonrise.common.util;
+ public final class MixinWorkarounds {
+ 
+     // mixins tries to find the owner of the clone() method, which doesn't exist and NPEs
++    // https://github.com/FabricMC/Mixin/pull/147
+     public static long[] clone(final long[] values) {
+         return values.clone();
+     }
+ 
++    public static byte[] clone(final byte[] values) {
++        return values.clone();
++    }
+ }
+diff --git a/src/main/java/ca/spottedleaf/moonrise/common/util/MoonriseCommon.java b/src/main/java/ca/spottedleaf/moonrise/common/util/MoonriseCommon.java
+index 3abe0bd2a820352b85306d554bf14a4cf6123091..c125c70a68130be373acc989053a6c0e487be924 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/common/util/MoonriseCommon.java
++++ b/src/main/java/ca/spottedleaf/moonrise/common/util/MoonriseCommon.java
+@@ -1,45 +1,100 @@
+ package ca.spottedleaf.moonrise.common.util;
+ 
+-import ca.spottedleaf.concurrentutil.executor.standard.PrioritisedThreadPool;
++import ca.spottedleaf.concurrentutil.executor.thread.PrioritisedThreadPool;
++import ca.spottedleaf.moonrise.common.PlatformHooks;
+ import org.slf4j.Logger;
+ import org.slf4j.LoggerFactory;
+-import java.io.File;
++import java.util.concurrent.TimeUnit;
++import java.util.concurrent.atomic.AtomicInteger;
++import java.util.function.Consumer;
+ 
+ public final class MoonriseCommon {
+ 
+     private static final Logger LOGGER = LoggerFactory.getLogger(MoonriseCommon.class);
+ 
+-    // Paper start
+-    public static PrioritisedThreadPool WORKER_POOL;
+-    public static int WORKER_THREADS;
+-    public static void init(io.papermc.paper.configuration.GlobalConfiguration.ChunkSystem chunkSystem) {
+-        // Paper end
++    public static final PrioritisedThreadPool WORKER_POOL = new PrioritisedThreadPool(
++            new Consumer<>() {
++                private final AtomicInteger idGenerator = new AtomicInteger();
++
++                @Override
++                public void accept(Thread thread) {
++                    thread.setDaemon(true);
++                    thread.setName(PlatformHooks.get().getBrand() + " Common Worker #" + this.idGenerator.getAndIncrement());
++                    thread.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
++                        @Override
++                        public void uncaughtException(final Thread thread, final Throwable throwable) {
++                            LOGGER.error("Uncaught exception in thread " + thread.getName(), throwable);
++                        }
++                    });
++                }
++            }
++    );
++    public static final long WORKER_QUEUE_HOLD_TIME = (long)(20.0e6); // 20ms
++    public static final int CLIENT_DIVISION = 0;
++    public static final PrioritisedThreadPool.ExecutorGroup RENDER_EXECUTOR_GROUP = MoonriseCommon.WORKER_POOL.createExecutorGroup(CLIENT_DIVISION, 0);
++    public static final int SERVER_DIVISION = 1;
++    public static final PrioritisedThreadPool.ExecutorGroup PARALLEL_GEN_GROUP = MoonriseCommon.WORKER_POOL.createExecutorGroup(SERVER_DIVISION, 0);
++    public static final PrioritisedThreadPool.ExecutorGroup RADIUS_AWARE_GROUP = MoonriseCommon.WORKER_POOL.createExecutorGroup(SERVER_DIVISION, 0);
++    public static final PrioritisedThreadPool.ExecutorGroup LOAD_GROUP         = MoonriseCommon.WORKER_POOL.createExecutorGroup(SERVER_DIVISION, 0);
++
++    public static void adjustWorkerThreads(final int configWorkerThreads, final int configIoThreads) {
+         int defaultWorkerThreads = Runtime.getRuntime().availableProcessors() / 2;
+         if (defaultWorkerThreads <= 4) {
+             defaultWorkerThreads = defaultWorkerThreads <= 3 ? 1 : 2;
+         } else {
+             defaultWorkerThreads = defaultWorkerThreads / 2;
+         }
+-        defaultWorkerThreads = Integer.getInteger("Paper.WorkerThreadCount", Integer.valueOf(defaultWorkerThreads)); // Paper
++        defaultWorkerThreads = Integer.getInteger(PlatformHooks.get().getBrand() + ".WorkerThreadCount", Integer.valueOf(defaultWorkerThreads));
+ 
+-        int workerThreads = chunkSystem.workerThreads; // Paper
++        int workerThreads = configWorkerThreads;
+ 
+         if (workerThreads <= 0) {
+             workerThreads = defaultWorkerThreads;
+         }
+ 
+-        WORKER_POOL = new PrioritisedThreadPool(
+-                "Paper Worker Pool", workerThreads, // Paper
+-                (final Thread thread, final Integer id) -> {
+-                    thread.setName("Paper Common Worker #" + id.intValue()); // Paper
++        final int ioThreads = Math.max(1, configIoThreads);
++
++        WORKER_POOL.adjustThreadCount(workerThreads);
++        IO_POOL.adjustThreadCount(ioThreads);
++
++        LOGGER.info(PlatformHooks.get().getBrand() + " is using " + workerThreads + " worker threads, " + ioThreads + " I/O threads");
++    }
++
++    public static final PrioritisedThreadPool IO_POOL = new PrioritisedThreadPool(
++            new Consumer<>() {
++                private final AtomicInteger idGenerator = new AtomicInteger();
++
++                @Override
++                public void accept(final Thread thread) {
++                    thread.setDaemon(true);
++                    thread.setName(PlatformHooks.get().getBrand() + " I/O Worker #" + this.idGenerator.getAndIncrement());
+                     thread.setUncaughtExceptionHandler(new Thread.UncaughtExceptionHandler() {
+                         @Override
+                         public void uncaughtException(final Thread thread, final Throwable throwable) {
+                             LOGGER.error("Uncaught exception in thread " + thread.getName(), throwable);
+                         }
+                     });
+-                }, (long)(20.0e6)); // 20ms
+-        WORKER_THREADS = workerThreads;
++                }
++            }
++    );
++    public static final long IO_QUEUE_HOLD_TIME = (long)(100.0e6); // 100ms
++    public static final PrioritisedThreadPool.ExecutorGroup CLIENT_PROFILER_IO_GROUP = IO_POOL.createExecutorGroup(CLIENT_DIVISION, 0);
++    public static final PrioritisedThreadPool.ExecutorGroup SERVER_REGION_IO_GROUP = IO_POOL.createExecutorGroup(SERVER_DIVISION, 0);
++
++    public static void haltExecutors() {
++        MoonriseCommon.WORKER_POOL.shutdown(false);
++        LOGGER.info("Awaiting termination of worker pool for up to 60s...");
++        if (!MoonriseCommon.WORKER_POOL.join(TimeUnit.SECONDS.toMillis(60L))) {
++            LOGGER.error("Worker pool did not shut down in time!");
++            MoonriseCommon.WORKER_POOL.halt(false);
++        }
++
++        MoonriseCommon.IO_POOL.shutdown(false);
++        LOGGER.info("Awaiting termination of I/O pool for up to 60s...");
++        if (!MoonriseCommon.IO_POOL.join(TimeUnit.SECONDS.toMillis(60L))) {
++            LOGGER.error("I/O pool did not shut down in time!");
++            MoonriseCommon.IO_POOL.halt(false);
++        }
+     }
+ 
+     private MoonriseCommon() {}
+diff --git a/src/main/java/ca/spottedleaf/moonrise/common/util/MoonriseConstants.java b/src/main/java/ca/spottedleaf/moonrise/common/util/MoonriseConstants.java
+index 1cf32d7d1bbc8a0a3f7cb9024c793f6744199f64..559c959aff3c9deef867b9e425fba3e2e669cac6 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/common/util/MoonriseConstants.java
++++ b/src/main/java/ca/spottedleaf/moonrise/common/util/MoonriseConstants.java
+@@ -1,8 +1,10 @@
+ package ca.spottedleaf.moonrise.common.util;
+ 
++import ca.spottedleaf.moonrise.common.PlatformHooks;
++
+ public final class MoonriseConstants {
+ 
+-    public static final int MAX_VIEW_DISTANCE = 32;
++    public static final int MAX_VIEW_DISTANCE = Integer.getInteger(PlatformHooks.get().getBrand() + ".MaxViewDistance", 32);
+ 
+     private MoonriseConstants() {}
+ 
+diff --git a/src/main/java/ca/spottedleaf/moonrise/common/util/SimpleRandom.java b/src/main/java/ca/spottedleaf/moonrise/common/util/SimpleRandom.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..a9ff1c1a70faf4b7a64b265932f07a8b8f00c1ff
+--- /dev/null
++++ b/src/main/java/ca/spottedleaf/moonrise/common/util/SimpleRandom.java
+@@ -0,0 +1,52 @@
++package ca.spottedleaf.moonrise.common.util;
++
++import net.minecraft.world.level.levelgen.LegacyRandomSource;
++
++/**
++ * Avoid costly CAS of superclass
++ */
++public final class SimpleRandom extends LegacyRandomSource {
++
++    private static final long MULTIPLIER = 25214903917L;
++    private static final long ADDEND = 11L;
++    private static final int BITS = 48;
++    private static final long MASK = (1L << BITS) - 1;
++
++    private long value;
++
++    public SimpleRandom(final long seed) {
++        super(0L);
++        this.value = seed;
++    }
++
++    @Override
++    public void setSeed(final long seed) {
++        this.value = (seed ^ MULTIPLIER) & MASK;
++    }
++
++    private long advanceSeed() {
++        return this.value = ((this.value * MULTIPLIER) + ADDEND) & MASK;
++    }
++
++    @Override
++    public int next(final int bits) {
++        return (int)(this.advanceSeed() >>> (BITS - bits));
++    }
++
++    @Override
++    public int nextInt() {
++        final long seed = this.advanceSeed();
++        return (int)(seed >>> (BITS - Integer.SIZE));
++    }
++
++    @Override
++    public int nextInt(final int bound) {
++        if (bound <= 0) {
++            throw new IllegalArgumentException();
++        }
++
++        // https://lemire.me/blog/2016/06/27/a-fast-alternative-to-the-modulo-reduction/
++        final long value = this.advanceSeed() >>> (BITS - Integer.SIZE);
++        return (int)((value * (long)bound) >>> Integer.SIZE);
++    }
++}
+diff --git a/src/main/java/ca/spottedleaf/moonrise/common/util/TickThread.java b/src/main/java/ca/spottedleaf/moonrise/common/util/TickThread.java
+index 11b7f15755dde766140c29bedca456c80d53293f..217d1f908a36a5177ba3cbb80a33f73d4dab0fa0 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/common/util/TickThread.java
++++ b/src/main/java/ca/spottedleaf/moonrise/common/util/TickThread.java
+@@ -77,11 +77,15 @@ public class TickThread extends Thread {
+     }
+ 
+     public TickThread(final Runnable run, final String name) {
+-        this(run, name, ID_GENERATOR.incrementAndGet());
++        this(null, run, name);
+     }
+ 
+-    private TickThread(final Runnable run, final String name, final int id) {
+-        super(run, name);
++    public TickThread(final ThreadGroup group, final Runnable run, final String name) {
++        this(group, run, name, ID_GENERATOR.incrementAndGet());
++    }
++
++    private TickThread(final ThreadGroup group, final Runnable run, final String name, final int id) {
++        super(group, run, name);
+         this.id = id;
+     }
+ 
+diff --git a/src/main/java/ca/spottedleaf/moonrise/common/util/WorldUtil.java b/src/main/java/ca/spottedleaf/moonrise/common/util/WorldUtil.java
+index af9623240ff2d389aa7090623f507720e7dbab7d..efda2688ae1254a82ba7f6bf8bf597ef224cbb86 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/common/util/WorldUtil.java
++++ b/src/main/java/ca/spottedleaf/moonrise/common/util/WorldUtil.java
+@@ -8,11 +8,19 @@ public final class WorldUtil {
+     // min, max are inclusive
+ 
+     public static int getMaxSection(final LevelHeightAccessor world) {
+-        return world.getMaxSection() - 1; // getMaxSection() is exclusive
++        return world.getMaxSectionY();
++    }
++
++    public static int getMaxSection(final Level world) {
++        return world.getMaxSectionY();
+     }
+ 
+     public static int getMinSection(final LevelHeightAccessor world) {
+-        return world.getMinSection();
++        return world.getMinSectionY();
++    }
++
++    public static int getMinSection(final Level world) {
++        return world.getMinSectionY();
+     }
+ 
+     public static int getMaxLightSection(final LevelHeightAccessor world) {
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/block_counting/BlockCountingBitStorage.java b/src/main/java/ca/spottedleaf/moonrise/patches/block_counting/BlockCountingBitStorage.java
+index aef4fc0d3c272febe675d1ac846b88e58b4e7533..93bc56daec4526f373c84763b8c7ccb4a30e800b 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/block_counting/BlockCountingBitStorage.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/block_counting/BlockCountingBitStorage.java
+@@ -1,10 +1,10 @@
+ package ca.spottedleaf.moonrise.patches.block_counting;
+ 
+ import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
+-import it.unimi.dsi.fastutil.ints.IntArrayList;
++import it.unimi.dsi.fastutil.shorts.ShortArrayList;
+ 
+ public interface BlockCountingBitStorage {
+ 
+-    public Int2ObjectOpenHashMap<IntArrayList> moonrise$countEntries();
++    public Int2ObjectOpenHashMap<ShortArrayList> moonrise$countEntries();
+ 
+ }
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/block_counting/BlockCountingChunkSection.java b/src/main/java/ca/spottedleaf/moonrise/patches/block_counting/BlockCountingChunkSection.java
+index a08ddb0598d44368af5b6bace971ee31edf9919e..0d1443a113c07d7655e7b927a899447f70db8fa9 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/block_counting/BlockCountingChunkSection.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/block_counting/BlockCountingChunkSection.java
+@@ -1,11 +1,11 @@
+ package ca.spottedleaf.moonrise.patches.block_counting;
+ 
+-import ca.spottedleaf.moonrise.common.list.IBlockDataList;
++import ca.spottedleaf.moonrise.common.list.ShortList;
+ 
+ public interface BlockCountingChunkSection {
+ 
+-    public int moonrise$getSpecialCollidingBlocks();
++    public boolean moonrise$hasSpecialCollidingBlocks();
+ 
+-    public IBlockDataList moonrise$getTickingBlockList();
++    public ShortList moonrise$getTickingBlockList();
+ 
+ }
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/blockstate_propertyaccess/PropertyAccess.java b/src/main/java/ca/spottedleaf/moonrise/patches/blockstate_propertyaccess/PropertyAccess.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..89e75b454695e174c5619104eeb15eb923a2d9a7
+--- /dev/null
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/blockstate_propertyaccess/PropertyAccess.java
+@@ -0,0 +1,12 @@
++package ca.spottedleaf.moonrise.patches.blockstate_propertyaccess;
++
++public interface PropertyAccess<T> {
++
++    public int moonrise$getId();
++
++    public int moonrise$getIdFor(final T value);
++
++    public T moonrise$getById(final int id);
++
++    public void moonrise$setById(final T[] values);
++}
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/blockstate_propertyaccess/PropertyAccessStateHolder.java b/src/main/java/ca/spottedleaf/moonrise/patches/blockstate_propertyaccess/PropertyAccessStateHolder.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..01da52b9e8a786824f199a057b62ce0431ecbc43
+--- /dev/null
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/blockstate_propertyaccess/PropertyAccessStateHolder.java
+@@ -0,0 +1,7 @@
++package ca.spottedleaf.moonrise.patches.blockstate_propertyaccess;
++
++public interface PropertyAccessStateHolder {
++
++    public long moonrise$getTableIndex();
++
++}
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/blockstate_propertyaccess/util/ZeroCollidingReferenceStateTable.java b/src/main/java/ca/spottedleaf/moonrise/patches/blockstate_propertyaccess/util/ZeroCollidingReferenceStateTable.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..b5335a2a8cb5dc7637c7112c8f7193389d726489
+--- /dev/null
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/blockstate_propertyaccess/util/ZeroCollidingReferenceStateTable.java
+@@ -0,0 +1,230 @@
++package ca.spottedleaf.moonrise.patches.blockstate_propertyaccess.util;
++
++import ca.spottedleaf.concurrentutil.util.IntegerUtil;
++import ca.spottedleaf.moonrise.patches.blockstate_propertyaccess.PropertyAccess;
++import ca.spottedleaf.moonrise.patches.blockstate_propertyaccess.PropertyAccessStateHolder;
++import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
++import it.unimi.dsi.fastutil.objects.AbstractObjectSet;
++import it.unimi.dsi.fastutil.objects.AbstractReference2ObjectMap;
++import it.unimi.dsi.fastutil.objects.ObjectIterator;
++import it.unimi.dsi.fastutil.objects.ObjectSet;
++import it.unimi.dsi.fastutil.objects.Reference2ObjectMap;
++import it.unimi.dsi.fastutil.objects.ReferenceOpenHashSet;
++import java.util.ArrayList;
++import java.util.Collection;
++import java.util.Collections;
++import java.util.Iterator;
++import java.util.List;
++import java.util.Map;
++import net.minecraft.world.level.block.state.StateHolder;
++import net.minecraft.world.level.block.state.properties.Property;
++
++public final class ZeroCollidingReferenceStateTable<O, S> {
++
++    private final Int2ObjectOpenHashMap<Indexer> propertyToIndexer;
++    private S[] lookup;
++    private final Collection<Property<?>> properties;
++
++    public ZeroCollidingReferenceStateTable(final Collection<Property<?>> properties) {
++        this.propertyToIndexer = new Int2ObjectOpenHashMap<>(properties.size());
++        this.properties = new ReferenceOpenHashSet<>(properties);
++
++        final List<Property<?>> sortedProperties = new ArrayList<>(properties);
++
++        // important that each table sees the same property order given the same _set_ of properties,
++        // as each table will calculate the index for the block state
++        sortedProperties.sort((final Property<?> p1, final Property<?> p2) -> {
++            return Integer.compare(
++                ((PropertyAccess<?>)p1).moonrise$getId(),
++                ((PropertyAccess<?>)p2).moonrise$getId()
++            );
++        });
++
++        int currentMultiple = 1;
++        for (final Property<?> property : sortedProperties) {
++            final int totalValues = property.getPossibleValues().size();
++
++            this.propertyToIndexer.put(
++                ((PropertyAccess<?>)property).moonrise$getId(),
++                new Indexer(
++                    totalValues,
++                    currentMultiple,
++                    IntegerUtil.getUnsignedDivisorMagic((long)currentMultiple, 32),
++                    IntegerUtil.getUnsignedDivisorMagic((long)totalValues, 32)
++                )
++            );
++
++            currentMultiple *= totalValues;
++        }
++    }
++
++    public <T extends Comparable<T>> boolean hasProperty(final Property<T> property) {
++        return this.propertyToIndexer.containsKey(((PropertyAccess<T>)property).moonrise$getId());
++    }
++
++    public long getIndex(final StateHolder<O, S> stateHolder) {
++        long ret = 0L;
++
++        for (final Map.Entry<Property<?>, Comparable<?>> entry : stateHolder.getValues().entrySet()) {
++            final Property<?> property = entry.getKey();
++            final Comparable<?> value = entry.getValue();
++
++            final Indexer indexer = this.propertyToIndexer.get(((PropertyAccess<?>)property).moonrise$getId());
++
++            ret += (((PropertyAccess)property).moonrise$getIdFor(value)) * indexer.multiple;
++        }
++
++        return ret;
++    }
++
++    public boolean isLoaded() {
++        return this.lookup != null;
++    }
++
++    public void loadInTable(final Map<Map<Property<?>, Comparable<?>>, S> universe) {
++        if (this.lookup != null) {
++            throw new IllegalStateException();
++        }
++
++        this.lookup = (S[])new StateHolder[universe.size()];
++
++        for (final Map.Entry<Map<Property<?>, Comparable<?>>, S> entry : universe.entrySet()) {
++            final S value = entry.getValue();
++            if (value == null) {
++                continue;
++            }
++            this.lookup[(int)((PropertyAccessStateHolder)(StateHolder<O, S>)value).moonrise$getTableIndex()] = value;
++        }
++
++        for (final S value : this.lookup) {
++            if (value == null) {
++                throw new IllegalStateException();
++            }
++        }
++    }
++
++    public <T extends Comparable<T>> T get(final long index, final Property<T> property) {
++        final Indexer indexer = this.propertyToIndexer.get(((PropertyAccess<T>)property).moonrise$getId());
++        if (indexer == null) {
++            return null;
++        }
++
++        final long divided = (index * indexer.multipleDivMagic) >>> 32;
++        final long modded = (((divided * indexer.modMagic) & 0xFFFFFFFFL) * indexer.totalValues) >>> 32;
++        // equiv to: divided = index / multiple
++        //           modded = divided % totalValues
++
++        return ((PropertyAccess<T>)property).moonrise$getById((int)modded);
++    }
++
++    public <T extends Comparable<T>> S set(final long index, final Property<T> property, final T with) {
++        final int newValueId = ((PropertyAccess<T>)property).moonrise$getIdFor(with);
++        if (newValueId < 0) {
++            return null;
++        }
++
++        final Indexer indexer = this.propertyToIndexer.get(((PropertyAccess<T>)property).moonrise$getId());
++        if (indexer == null) {
++            return null;
++        }
++
++        final long divided = (index * indexer.multipleDivMagic) >>> 32;
++        final long modded = (((divided * indexer.modMagic) & 0xFFFFFFFFL) * indexer.totalValues) >>> 32;
++        // equiv to: divided = index / multiple
++        //           modded = divided % totalValues
++
++        // subtract out the old value, add in the new
++        final long newIndex = (((long)newValueId - modded) * indexer.multiple) + index;
++
++        return this.lookup[(int)newIndex];
++    }
++
++    public <T extends Comparable<T>> S trySet(final long index, final Property<T> property, final T with, final S dfl) {
++        final Indexer indexer = this.propertyToIndexer.get(((PropertyAccess<T>)property).moonrise$getId());
++        if (indexer == null) {
++            return dfl;
++        }
++
++        final int newValueId = ((PropertyAccess<T>)property).moonrise$getIdFor(with);
++        if (newValueId < 0) {
++            return null;
++        }
++
++        final long divided = (index * indexer.multipleDivMagic) >>> 32;
++        final long modded = (((divided * indexer.modMagic) & 0xFFFFFFFFL) * indexer.totalValues) >>> 32;
++        // equiv to: divided = index / multiple
++        //           modded = divided % totalValues
++
++        // subtract out the old value, add in the new
++        final long newIndex = (((long)newValueId - modded) * indexer.multiple) + index;
++
++        return this.lookup[(int)newIndex];
++    }
++
++    public Collection<Property<?>> getProperties() {
++        return Collections.unmodifiableCollection(this.properties);
++    }
++
++    public Map<Property<?>, Comparable<?>> getMapView(final long stateIndex) {
++        return new MapView(stateIndex);
++    }
++
++    private static final record Indexer(
++        int totalValues, int multiple, long multipleDivMagic, long modMagic
++    ) {}
++
++    private class MapView extends AbstractReference2ObjectMap<Property<?>, Comparable<?>> {
++        private final long stateIndex;
++        private EntrySet entrySet;
++
++        MapView(final long stateIndex) {
++            this.stateIndex = stateIndex;
++        }
++
++        @Override
++        public boolean containsKey(final Object key) {
++            return key instanceof Property<?> prop && ZeroCollidingReferenceStateTable.this.hasProperty(prop);
++        }
++
++        @Override
++        public int size() {
++            return ZeroCollidingReferenceStateTable.this.properties.size();
++        }
++
++        @Override
++        public ObjectSet<Entry<Property<?>, Comparable<?>>> reference2ObjectEntrySet() {
++            if (this.entrySet == null)
++                this.entrySet = new EntrySet();
++            return this.entrySet;
++        }
++
++        @Override
++        public Comparable<?> get(final Object key) {
++            return key instanceof Property<?> prop ? ZeroCollidingReferenceStateTable.this.get(this.stateIndex, prop) : null;
++        }
++
++        class EntrySet extends AbstractObjectSet<Entry<Property<?>, Comparable<?>>> {
++            @Override
++            public ObjectIterator<Reference2ObjectMap.Entry<Property<?>, Comparable<?>>> iterator() {
++                final Iterator<Property<?>> propIterator = ZeroCollidingReferenceStateTable.this.properties.iterator();
++                return new ObjectIterator<>() {
++                    @Override
++                    public boolean hasNext() {
++                        return propIterator.hasNext();
++                    }
++
++                    @Override
++                    public Entry<Property<?>, Comparable<?>> next() {
++                        Property<?> prop = propIterator.next();
++                        return new AbstractReference2ObjectMap.BasicEntry<>(prop, ZeroCollidingReferenceStateTable.this.get(MapView.this.stateIndex, prop));
++                    }
++                };
++            }
++
++            @Override
++            public int size() {
++                return ZeroCollidingReferenceStateTable.this.properties.size();
++            }
++        }
++    }
++}
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/ChunkSystemConverters.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/ChunkSystemConverters.java
+index 5fca5dc7cdfa976bcc58dfcf0d14abb78a931475..cee2c8efbe280e20c63e2d66464dc835cd328e4a 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/ChunkSystemConverters.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/ChunkSystemConverters.java
+@@ -1,5 +1,6 @@
+ package ca.spottedleaf.moonrise.patches.chunk_system;
+ 
++import ca.spottedleaf.moonrise.common.PlatformHooks;
+ import net.minecraft.SharedConstants;
+ import net.minecraft.nbt.CompoundTag;
+ import net.minecraft.nbt.Tag;
+@@ -25,21 +26,13 @@ public final class ChunkSystemConverters {
+     public static CompoundTag convertPoiCompoundTag(final CompoundTag data, final ServerLevel world) {
+         final int dataVersion = getDataVersion(data, DEFAULT_POI_DATA_VERSION);
+ 
+-        // Paper start - dataconverter
+-        return ca.spottedleaf.dataconverter.minecraft.MCDataConverter.convertTag(
+-            ca.spottedleaf.dataconverter.minecraft.datatypes.MCTypeRegistry.POI_CHUNK, data, dataVersion, getCurrentVersion()
+-        );
+-        // Paper end - dataconverter
++        return PlatformHooks.get().convertNBT(DataFixTypes.POI_CHUNK, world.getServer().getFixerUpper(), data, dataVersion, getCurrentVersion());
+     }
+ 
+     public static CompoundTag convertEntityChunkCompoundTag(final CompoundTag data, final ServerLevel world) {
+         final int dataVersion = getDataVersion(data, DEFAULT_ENTITY_CHUNK_DATA_VERSION);
+ 
+-        // Paper start - dataconverter
+-        return ca.spottedleaf.dataconverter.minecraft.MCDataConverter.convertTag(
+-            ca.spottedleaf.dataconverter.minecraft.datatypes.MCTypeRegistry.ENTITY_CHUNK, data, dataVersion, getCurrentVersion()
+-        );
+-        // Paper end - dataconverter
++        return PlatformHooks.get().convertNBT(DataFixTypes.ENTITY_CHUNK, world.getServer().getFixerUpper(), data, dataVersion, getCurrentVersion());
+     }
+ 
+     private ChunkSystemConverters() {}
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/ChunkSystemFeatures.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/ChunkSystemFeatures.java
+deleted file mode 100644
+index 67f6dd9a4855611cfe242c2e37e90f6d27d4c823..0000000000000000000000000000000000000000
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/ChunkSystemFeatures.java
++++ /dev/null
+@@ -1,36 +0,0 @@
+-package ca.spottedleaf.moonrise.patches.chunk_system;
+-
+-import ca.spottedleaf.moonrise.patches.chunk_system.async_save.AsyncChunkSaveData;
+-import net.minecraft.nbt.CompoundTag;
+-import net.minecraft.server.level.ServerLevel;
+-import net.minecraft.world.level.chunk.ChunkAccess;
+-
+-public final class ChunkSystemFeatures {
+-
+-    public static boolean supportsAsyncChunkSave() {
+-        // uncertain how to properly pass AsyncSaveData to ChunkSerializer#write
+-        // additionally, there may be mods hooking into the write() call which may not be thread-safe to call
+-        return true;
+-    }
+-
+-    public static AsyncChunkSaveData getAsyncSaveData(final ServerLevel world, final ChunkAccess chunk) {
+-        return net.minecraft.world.level.chunk.storage.ChunkSerializer.getAsyncSaveData(world, chunk);
+-    }
+-
+-    public static CompoundTag saveChunkAsync(final ServerLevel world, final ChunkAccess chunk, final AsyncChunkSaveData asyncSaveData) {
+-        return net.minecraft.world.level.chunk.storage.ChunkSerializer.saveChunk(world, chunk, asyncSaveData);
+-    }
+-
+-    public static boolean forceNoSave(final ChunkAccess chunk) {
+-        // support for CB chunk mustNotSave
+-        return chunk instanceof net.minecraft.world.level.chunk.LevelChunk levelChunk && levelChunk.mustNotSave;
+-    }
+-
+-    public static boolean supportsAsyncChunkDeserialization() {
+-        // as it stands, the current problem with supporting this in Moonrise is that we are unsure that any mods
+-        // hooking into ChunkSerializer#read() are thread-safe to call
+-        return true;
+-    }
+-
+-    private ChunkSystemFeatures() {}
+-}
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/async_save/AsyncChunkSaveData.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/async_save/AsyncChunkSaveData.java
+deleted file mode 100644
+index becd1c6d54ed6c912aee3a9178a970e2751d3694..0000000000000000000000000000000000000000
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/async_save/AsyncChunkSaveData.java
++++ /dev/null
+@@ -1,11 +0,0 @@
+-package ca.spottedleaf.moonrise.patches.chunk_system.async_save;
+-
+-import net.minecraft.nbt.ListTag;
+-import net.minecraft.nbt.Tag;
+-
+-public record AsyncChunkSaveData(
+-        Tag blockTickList, // non-null if we had to go to the server's tick list
+-        Tag fluidTickList, // non-null if we had to go to the server's tick list
+-        ListTag blockEntities,
+-        long worldTime
+-) {}
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/entity/ChunkSystemEntity.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/entity/ChunkSystemEntity.java
+index 2c279854bdf214538380fa354e4298ec4bd9ac4e..c7da23900228aab3a5673eb5adfada5091140319 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/entity/ChunkSystemEntity.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/entity/ChunkSystemEntity.java
+@@ -1,5 +1,6 @@
+ package ca.spottedleaf.moonrise.patches.chunk_system.entity;
+ 
++import ca.spottedleaf.moonrise.patches.chunk_system.level.chunk.ChunkData;
+ import net.minecraft.server.level.FullChunkStatus;
+ import net.minecraft.world.entity.Entity;
+ import net.minecraft.world.entity.monster.Shulker;
+@@ -19,6 +20,10 @@ public interface ChunkSystemEntity {
+ 
+     public void moonrise$setChunkStatus(final FullChunkStatus status);
+ 
++    public ChunkData moonrise$getChunkData();
++
++    public void moonrise$setChunkData(final ChunkData chunkData);
++
+     public int moonrise$getSectionX();
+ 
+     public void moonrise$setSectionX(final int x);
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/io/ChunkSystemRegionFileStorage.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/io/ChunkSystemRegionFileStorage.java
+index 73df26b27146bbad2106d57b22dd3c792ed3dd1d..a814512fcfb85312474ae2c2c21443843bf57831 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/io/ChunkSystemRegionFileStorage.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/io/ChunkSystemRegionFileStorage.java
+@@ -1,5 +1,6 @@
+ package ca.spottedleaf.moonrise.patches.chunk_system.io;
+ 
++import net.minecraft.nbt.CompoundTag;
+ import net.minecraft.world.level.chunk.storage.RegionFile;
+ import java.io.IOException;
+ 
+@@ -11,4 +12,20 @@ public interface ChunkSystemRegionFileStorage {
+ 
+     public RegionFile moonrise$getRegionFileIfExists(final int chunkX, final int chunkZ) throws IOException;
+ 
++    public MoonriseRegionFileIO.RegionDataController.WriteData moonrise$startWrite(
++            final int chunkX, final int chunkZ, final CompoundTag compound
++    ) throws IOException;
++
++    public void moonrise$finishWrite(
++                    final int chunkX, final int chunkZ, final MoonriseRegionFileIO.RegionDataController.WriteData writeData
++    ) throws IOException;
++
++    public MoonriseRegionFileIO.RegionDataController.ReadData moonrise$readData(
++            final int chunkX, final int chunkZ
++    ) throws IOException;
++
++    // if the return value is null, then the caller needs to re-try with a new call to readData()
++    public CompoundTag moonrise$finishRead(
++            final int chunkX, final int chunkZ, final MoonriseRegionFileIO.RegionDataController.ReadData readData
++    ) throws IOException;
+ }
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/io/MoonriseRegionFileIO.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/io/MoonriseRegionFileIO.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..99f6f3e58b11b8967e6f1c3391c190d9a860ab7f
+--- /dev/null
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/io/MoonriseRegionFileIO.java
+@@ -0,0 +1,1707 @@
++package ca.spottedleaf.moonrise.patches.chunk_system.io;
++
++import ca.spottedleaf.concurrentutil.collection.MultiThreadedQueue;
++import ca.spottedleaf.concurrentutil.completable.CallbackCompletable;
++import ca.spottedleaf.concurrentutil.completable.Completable;
++import ca.spottedleaf.concurrentutil.executor.Cancellable;
++import ca.spottedleaf.concurrentutil.executor.PrioritisedExecutor;
++import ca.spottedleaf.concurrentutil.executor.queue.PrioritisedTaskQueue;
++import ca.spottedleaf.concurrentutil.function.BiLong1Function;
++import ca.spottedleaf.concurrentutil.map.ConcurrentLong2ReferenceChainedHashTable;
++import ca.spottedleaf.concurrentutil.util.ConcurrentUtil;
++import ca.spottedleaf.concurrentutil.util.Priority;
++import ca.spottedleaf.moonrise.common.util.CoordinateUtils;
++import ca.spottedleaf.moonrise.common.util.TickThread;
++import ca.spottedleaf.moonrise.common.util.WorldUtil;
++import ca.spottedleaf.moonrise.patches.chunk_system.level.ChunkSystemServerLevel;
++import it.unimi.dsi.fastutil.objects.ReferenceOpenHashSet;
++import net.minecraft.nbt.CompoundTag;
++import net.minecraft.server.MinecraftServer;
++import net.minecraft.server.level.ServerLevel;
++import net.minecraft.world.level.chunk.storage.RegionFile;
++import net.minecraft.world.level.chunk.storage.RegionFileStorage;
++import org.slf4j.Logger;
++import org.slf4j.LoggerFactory;
++import java.io.DataInputStream;
++import java.io.DataOutputStream;
++import java.io.IOException;
++import java.lang.invoke.VarHandle;
++import java.util.concurrent.CompletableFuture;
++import java.util.concurrent.CompletionException;
++import java.util.concurrent.atomic.AtomicInteger;
++import java.util.concurrent.atomic.AtomicLong;
++import java.util.function.BiConsumer;
++import java.util.function.Consumer;
++
++public final class MoonriseRegionFileIO {
++
++    private static final int REGION_FILE_SHIFT = 5;
++    private static final Logger LOGGER = LoggerFactory.getLogger(MoonriseRegionFileIO.class);
++
++    /**
++     * The types of RegionFiles controlled by the I/O thread(s).
++     */
++    public static enum RegionFileType {
++        CHUNK_DATA,
++        POI_DATA,
++        ENTITY_DATA;
++    }
++
++    public static RegionDataController getControllerFor(final ServerLevel world, final RegionFileType type) {
++        switch (type) {
++            case CHUNK_DATA:
++                return ((ChunkSystemServerLevel)world).moonrise$getChunkDataController();
++            case POI_DATA:
++                return ((ChunkSystemServerLevel)world).moonrise$getPoiChunkDataController();
++            case ENTITY_DATA:
++                return ((ChunkSystemServerLevel)world).moonrise$getEntityChunkDataController();
++            default:
++                throw new IllegalStateException("Unknown controller type " + type);
++        }
++    }
++
++    private static final RegionFileType[] CACHED_REGIONFILE_TYPES = RegionFileType.values();
++
++    /**
++     * Collects RegionFile data for a certain chunk.
++     */
++    public static final class RegionFileData {
++
++        private final boolean[] hasResult = new boolean[CACHED_REGIONFILE_TYPES.length];
++        private final CompoundTag[] data = new CompoundTag[CACHED_REGIONFILE_TYPES.length];
++        private final Throwable[] throwables = new Throwable[CACHED_REGIONFILE_TYPES.length];
++
++        /**
++         * Sets the result associated with the specified RegionFile type. Note that
++         * results can only be set once per RegionFile type.
++         *
++         * @param type The RegionFile type.
++         * @param data The result to set.
++         */
++        public void setData(final MoonriseRegionFileIO.RegionFileType type, final CompoundTag data) {
++            final int index = type.ordinal();
++
++            if (this.hasResult[index]) {
++                throw new IllegalArgumentException("Result already exists for type " + type);
++            }
++            this.hasResult[index] = true;
++            this.data[index] = data;
++        }
++
++        /**
++         * Sets the result associated with the specified RegionFile type. Note that
++         * results can only be set once per RegionFile type.
++         *
++         * @param type The RegionFile type.
++         * @param throwable The result to set.
++         */
++        public void setThrowable(final MoonriseRegionFileIO.RegionFileType type, final Throwable throwable) {
++            final int index = type.ordinal();
++
++            if (this.hasResult[index]) {
++                throw new IllegalArgumentException("Result already exists for type " + type);
++            }
++            this.hasResult[index] = true;
++            this.throwables[index] = throwable;
++        }
++
++        /**
++         * Returns whether there is a result for the specified RegionFile type.
++         *
++         * @param type Specified RegionFile type.
++         *
++         * @return Whether a result exists for {@code type}.
++         */
++        public boolean hasResult(final MoonriseRegionFileIO.RegionFileType type) {
++            return this.hasResult[type.ordinal()];
++        }
++
++        /**
++         * Returns the data result for the RegionFile type.
++         *
++         * @param type Specified RegionFile type.
++         *
++         * @throws IllegalArgumentException If the result has not been set for {@code type}.
++         * @return The data result for the specified type. If the result is a {@code Throwable},
++         * then returns {@code null}.
++         */
++        public CompoundTag getData(final MoonriseRegionFileIO.RegionFileType type) {
++            final int index = type.ordinal();
++
++            if (!this.hasResult[index]) {
++                throw new IllegalArgumentException("Result does not exist for type " + type);
++            }
++
++            return this.data[index];
++        }
++
++        /**
++         * Returns the throwable result for the RegionFile type.
++         *
++         * @param type Specified RegionFile type.
++         *
++         * @throws IllegalArgumentException If the result has not been set for {@code type}.
++         * @return The throwable result for the specified type. If the result is an {@code CompoundTag},
++         * then returns {@code null}.
++         */
++        public Throwable getThrowable(final MoonriseRegionFileIO.RegionFileType type) {
++            final int index = type.ordinal();
++
++            if (!this.hasResult[index]) {
++                throw new IllegalArgumentException("Result does not exist for type " + type);
++            }
++
++            return this.throwables[index];
++        }
++    }
++
++    public static void flushRegionStorages(final ServerLevel world) throws IOException {
++        for (final RegionFileType type : CACHED_REGIONFILE_TYPES) {
++            flushRegionStorages(world, type);
++        }
++    }
++
++    public static void flushRegionStorages(final ServerLevel world, final RegionFileType type) throws IOException {
++        getControllerFor(world, type).getCache().flush();
++    }
++
++    public static void flush(final MinecraftServer server) {
++        for (final ServerLevel world : server.getAllLevels()) {
++            flush(world);
++        }
++    }
++
++    public static void flush(final ServerLevel world) {
++        for (final RegionFileType regionFileType : CACHED_REGIONFILE_TYPES) {
++            flush(world, regionFileType);
++        }
++    }
++
++    public static void flush(final ServerLevel world, final RegionFileType type) {
++        final RegionDataController taskController = getControllerFor(world, type);
++
++        long failures = 1L; // start at 0.13ms
++
++        while (taskController.hasTasks()) {
++            Thread.yield();
++            failures = ConcurrentUtil.linearLongBackoff(failures, 125_000L, 5_000_000L); // 125us, 5ms
++        }
++    }
++
++    public static void partialFlush(final ServerLevel world, final int tasksRemaining) {
++        for (long failures = 1L;;) { // start at 0.13ms
++            long totalTasks = 0L;
++            for (final RegionFileType regionFileType : CACHED_REGIONFILE_TYPES) {
++                totalTasks += getControllerFor(world, regionFileType).getTotalWorkingTasks();
++            }
++
++            if (totalTasks > (long)tasksRemaining) {
++                Thread.yield();
++                failures = ConcurrentUtil.linearLongBackoff(failures, 125_000L, 5_000_000L); // 125us, 5ms
++            } else {
++                return;
++            }
++        }
++    }
++
++    /**
++     * Returns the priority associated with blocking I/O based on the current thread. The goal is to avoid
++     * dumb plugins from taking away priority from threads we consider crucial.
++     * @return The priroity to use with blocking I/O on the current thread.
++     */
++    public static Priority getIOBlockingPriorityForCurrentThread() {
++        if (TickThread.isTickThread()) {
++            return Priority.BLOCKING;
++        }
++        return Priority.HIGHEST;
++    }
++
++    /**
++     * Returns the priority for the specified regionfile type for the specified chunk.
++     * @param world Specified world.
++     * @param chunkX Specified chunk x.
++     * @param chunkZ Specified chunk z.
++     * @param type Specified regionfile type.
++     * @return The priority for the chunk
++     */
++    public static Priority getPriority(final ServerLevel world, final int chunkX, final int chunkZ, final RegionFileType type) {
++        final RegionDataController taskController = getControllerFor(world, type);
++        final ChunkIOTask task = taskController.chunkTasks.get(CoordinateUtils.getChunkKey(chunkX, chunkZ));
++
++        if (task == null) {
++            return Priority.COMPLETING;
++        }
++
++        return task.getPriority();
++    }
++
++    /**
++     * Sets the priority for all regionfile types for the specified chunk. Note that great care should
++     * be taken using this method, as there can be multiple tasks tied to the same chunk that want different
++     * priorities.
++     *
++     * @param world Specified world.
++     * @param chunkX Specified chunk x.
++     * @param chunkZ Specified chunk z.
++     * @param priority New priority.
++     *
++     * @see #raisePriority(ServerLevel, int, int, Priority)
++     * @see #raisePriority(ServerLevel, int, int, RegionFileType, Priority)
++     * @see #lowerPriority(ServerLevel, int, int, Priority)
++     * @see #lowerPriority(ServerLevel, int, int, RegionFileType, Priority)
++     */
++    public static void setPriority(final ServerLevel world, final int chunkX, final int chunkZ,
++                                   final Priority priority) {
++        for (final RegionFileType type : CACHED_REGIONFILE_TYPES) {
++            MoonriseRegionFileIO.setPriority(world, chunkX, chunkZ, type, priority);
++        }
++    }
++
++    /**
++     * Sets the priority for the specified regionfile type for the specified chunk. Note that great care should
++     * be taken using this method, as there can be multiple tasks tied to the same chunk that want different
++     * priorities.
++     *
++     * @param world Specified world.
++     * @param chunkX Specified chunk x.
++     * @param chunkZ Specified chunk z.
++     * @param type Specified regionfile type.
++     * @param priority New priority.
++     *
++     * @see #raisePriority(ServerLevel, int, int, Priority)
++     * @see #raisePriority(ServerLevel, int, int, RegionFileType, Priority)
++     * @see #lowerPriority(ServerLevel, int, int, Priority)
++     * @see #lowerPriority(ServerLevel, int, int, RegionFileType, Priority)
++     */
++    public static void setPriority(final ServerLevel world, final int chunkX, final int chunkZ, final RegionFileType type,
++                                   final Priority priority) {
++        final RegionDataController taskController = getControllerFor(world, type);
++        final ChunkIOTask task = taskController.chunkTasks.get(CoordinateUtils.getChunkKey(chunkX, chunkZ));
++
++        if (task != null) {
++            task.setPriority(priority);
++        }
++    }
++
++    /**
++     * Raises the priority for all regionfile types for the specified chunk.
++     *
++     * @param world Specified world.
++     * @param chunkX Specified chunk x.
++     * @param chunkZ Specified chunk z.
++     * @param priority New priority.
++     *
++     * @see #setPriority(ServerLevel, int, int, Priority)
++     * @see #setPriority(ServerLevel, int, int, RegionFileType, Priority)
++     * @see #lowerPriority(ServerLevel, int, int, Priority)
++     * @see #lowerPriority(ServerLevel, int, int, RegionFileType, Priority)
++     */
++    public static void raisePriority(final ServerLevel world, final int chunkX, final int chunkZ,
++                                     final Priority priority) {
++        for (final RegionFileType type : CACHED_REGIONFILE_TYPES) {
++            MoonriseRegionFileIO.raisePriority(world, chunkX, chunkZ, type, priority);
++        }
++    }
++
++    /**
++     * Raises the priority for the specified regionfile type for the specified chunk.
++     *
++     * @param world Specified world.
++     * @param chunkX Specified chunk x.
++     * @param chunkZ Specified chunk z.
++     * @param type Specified regionfile type.
++     * @param priority New priority.
++     *
++     * @see #setPriority(ServerLevel, int, int, Priority)
++     * @see #setPriority(ServerLevel, int, int, RegionFileType, Priority)
++     * @see #lowerPriority(ServerLevel, int, int, Priority)
++     * @see #lowerPriority(ServerLevel, int, int, RegionFileType, Priority)
++     */
++    public static void raisePriority(final ServerLevel world, final int chunkX, final int chunkZ, final RegionFileType type,
++                                     final Priority priority) {
++        final RegionDataController taskController = getControllerFor(world, type);
++        final ChunkIOTask task = taskController.chunkTasks.get(CoordinateUtils.getChunkKey(chunkX, chunkZ));
++
++        if (task != null) {
++            task.raisePriority(priority);
++        }
++    }
++
++    /**
++     * Lowers the priority for all regionfile types for the specified chunk.
++     *
++     * @param world Specified world.
++     * @param chunkX Specified chunk x.
++     * @param chunkZ Specified chunk z.
++     * @param priority New priority.
++     *
++     * @see #raisePriority(ServerLevel, int, int, Priority)
++     * @see #raisePriority(ServerLevel, int, int, RegionFileType, Priority)
++     * @see #setPriority(ServerLevel, int, int, Priority)
++     * @see #setPriority(ServerLevel, int, int, RegionFileType, Priority)
++     */
++    public static void lowerPriority(final ServerLevel world, final int chunkX, final int chunkZ,
++                                     final Priority priority) {
++        for (final RegionFileType type : CACHED_REGIONFILE_TYPES) {
++            MoonriseRegionFileIO.lowerPriority(world, chunkX, chunkZ, type, priority);
++        }
++    }
++
++    /**
++     * Lowers the priority for the specified regionfile type for the specified chunk.
++     *
++     * @param world Specified world.
++     * @param chunkX Specified chunk x.
++     * @param chunkZ Specified chunk z.
++     * @param type Specified regionfile type.
++     * @param priority New priority.
++     *
++     * @see #raisePriority(ServerLevel, int, int, Priority)
++     * @see #raisePriority(ServerLevel, int, int, RegionFileType, Priority)
++     * @see #setPriority(ServerLevel, int, int, Priority)
++     * @see #setPriority(ServerLevel, int, int, RegionFileType, Priority)
++     */
++    public static void lowerPriority(final ServerLevel world, final int chunkX, final int chunkZ, final RegionFileType type,
++                                     final Priority priority) {
++        final RegionDataController taskController = getControllerFor(world, type);
++        final ChunkIOTask task = taskController.chunkTasks.get(CoordinateUtils.getChunkKey(chunkX, chunkZ));
++
++        if (task != null) {
++            task.lowerPriority(priority);
++        }
++    }
++
++    /**
++     * Schedules the chunk data to be written asynchronously.
++     * <p>
++     *     Impl notes:
++     * </p>
++     * <li>
++     *     This function presumes a chunk load for the coordinates is not called during this function (anytime after is OK). This means
++     *     saves must be scheduled before a chunk is unloaded.
++     * </li>
++     * <li>
++     *     Writes may be called concurrently, although only the "later" write will go through.
++     * </li>
++     *
++     * @param world Chunk's world
++     * @param chunkX Chunk's x coordinate
++     * @param chunkZ Chunk's z coordinate
++     * @param data Chunk's data
++     * @param type The regionfile type to write to.
++     *
++     * @throws IllegalStateException If the file io thread has shutdown.
++     */
++    public static void scheduleSave(final ServerLevel world, final int chunkX, final int chunkZ, final CompoundTag data,
++                                    final RegionFileType type) {
++        MoonriseRegionFileIO.scheduleSave(world, chunkX, chunkZ, data, type, Priority.NORMAL);
++    }
++
++    /**
++     * Schedules the chunk data to be written asynchronously.
++     * <p>
++     *     Impl notes:
++     * </p>
++     * <li>
++     *     This function presumes a chunk load for the coordinates is not called during this function (anytime after is OK). This means
++     *     saves must be scheduled before a chunk is unloaded.
++     * </li>
++     * <li>
++     *     Writes may be called concurrently, although only the "later" write will go through.
++     * </li>
++     *
++     * @param world Chunk's world
++     * @param chunkX Chunk's x coordinate
++     * @param chunkZ Chunk's z coordinate
++     * @param data Chunk's data
++     * @param type The regionfile type to write to.
++     * @param priority The minimum priority to schedule at.
++     *
++     * @throws IllegalStateException If the file io thread has shutdown.
++     */
++    public static void scheduleSave(final ServerLevel world, final int chunkX, final int chunkZ, final CompoundTag data,
++                                    final RegionFileType type, final Priority priority) {
++        scheduleSave(
++            world, chunkX, chunkZ,
++            (final BiConsumer<CompoundTag, Throwable> consumer) -> {
++                consumer.accept(data, null);
++            }, null, type, priority
++        );
++    }
++
++    /**
++     * Schedules the chunk data to be written asynchronously.
++     * <p>
++     *     Impl notes:
++     * </p>
++     * <li>
++     *     This function presumes a chunk load for the coordinates is not called during this function (anytime after is OK). This means
++     *     saves must be scheduled before a chunk is unloaded.
++     * </li>
++     * <li>
++     *     Writes may be called concurrently, although only the "later" write will go through.
++     * </li>
++     * <li>
++     *     The specified write task, if not null, will have its priority controlled by the scheduler.
++     * </li>
++     *
++     * @param world Chunk's world
++     * @param chunkX Chunk's x coordinate
++     * @param chunkZ Chunk's z coordinate
++     * @param completable Chunk's pending data
++     * @param writeTask The task responsible for completing the pending chunk data
++     * @param type The regionfile type to write to.
++     * @param priority The minimum priority to schedule at.
++     *
++     * @throws IllegalStateException If the file io thread has shutdown.
++     */
++    public static void scheduleSave(final ServerLevel world, final int chunkX, final int chunkZ, final CallbackCompletable<CompoundTag> completable,
++                                    final PrioritisedExecutor.PrioritisedTask writeTask, final RegionFileType type, final Priority priority) {
++        scheduleSave(world, chunkX, chunkZ, completable::addWaiter, writeTask, type, priority);
++    }
++
++    /**
++     * Schedules the chunk data to be written asynchronously.
++     * <p>
++     *     Impl notes:
++     * </p>
++     * <li>
++     *     This function presumes a chunk load for the coordinates is not called during this function (anytime after is OK). This means
++     *     saves must be scheduled before a chunk is unloaded.
++     * </li>
++     * <li>
++     *     Writes may be called concurrently, although only the "later" write will go through.
++     * </li>
++     * <li>
++     *     The specified write task, if not null, will have its priority controlled by the scheduler.
++     * </li>
++     *
++     * @param world Chunk's world
++     * @param chunkX Chunk's x coordinate
++     * @param chunkZ Chunk's z coordinate
++     * @param completable Chunk's pending data
++     * @param writeTask The task responsible for completing the pending chunk data
++     * @param type The regionfile type to write to.
++     * @param priority The minimum priority to schedule at.
++     *
++     * @throws IllegalStateException If the file io thread has shutdown.
++     */
++    public static void scheduleSave(final ServerLevel world, final int chunkX, final int chunkZ, final Completable<CompoundTag> completable,
++                                    final PrioritisedExecutor.PrioritisedTask writeTask, final RegionFileType type, final Priority priority) {
++        scheduleSave(world, chunkX, chunkZ, completable::whenComplete, writeTask, type, priority);
++    }
++
++    private static void scheduleSave(final ServerLevel world, final int chunkX, final int chunkZ, final Consumer<BiConsumer<CompoundTag, Throwable>> scheduler,
++                                     final PrioritisedExecutor.PrioritisedTask writeTask, final RegionFileType type, final Priority priority) {
++        final RegionDataController taskController = getControllerFor(world, type);
++
++        final boolean[] created = new boolean[1];
++        final ChunkIOTask.InProgressWrite write = new ChunkIOTask.InProgressWrite(writeTask);
++        final ChunkIOTask task = taskController.chunkTasks.compute(CoordinateUtils.getChunkKey(chunkX, chunkZ),
++            (final long keyInMap, final ChunkIOTask taskRunning) -> {
++                if (taskRunning == null || taskRunning.failedWrite) {
++                    // no task is scheduled or the previous write failed - meaning we need to overwrite it
++
++                    // create task
++                    final ChunkIOTask newTask = new ChunkIOTask(
++                        world, taskController, chunkX, chunkZ, priority, new ChunkIOTask.InProgressRead()
++                    );
++
++                    newTask.pushPendingWrite(write);
++
++                    created[0] = true;
++
++                    return newTask;
++                }
++
++                taskRunning.pushPendingWrite(write);
++
++                return taskRunning;
++            }
++        );
++
++        write.schedule(task, scheduler);
++
++        if (created[0]) {
++            taskController.startTask(task);
++            task.scheduleWriteCompress();
++        } else {
++            task.raisePriority(priority);
++        }
++    }
++
++    /**
++     * Schedules a load to be executed asynchronously. This task will load all regionfile types, and then call
++     * {@code onComplete}. This is a bulk load operation, see {@link #loadDataAsync(ServerLevel, int, int, RegionFileType, BiConsumer, boolean)}
++     * for single load.
++     * <p>
++     *     Impl notes:
++     * </p>
++     * <li>
++     *     The {@code onComplete} parameter may be completed during the execution of this function synchronously or it may
++     *     be completed asynchronously on this file io thread. Interacting with the file IO thread in the completion of
++     *     data is undefined behaviour, and can cause deadlock.
++     * </li>
++     *
++     * @param world Chunk's world
++     * @param chunkX Chunk's x coordinate
++     * @param chunkZ Chunk's z coordinate
++     * @param onComplete Consumer to execute once this task has completed
++     * @param intendingToBlock Whether the caller is intending to block on completion. This only affects the cost
++     *                         of this call.
++     *
++     * @return The {@link Cancellable} for this chunk load. Cancelling it will not affect other loads for the same chunk data.
++     *
++     * @see #loadDataAsync(ServerLevel, int, int, RegionFileType, BiConsumer, boolean)
++     * @see #loadDataAsync(ServerLevel, int, int, RegionFileType, BiConsumer, boolean, Priority)
++     * @see #loadChunkData(ServerLevel, int, int, Consumer, boolean, RegionFileType...)
++     * @see #loadChunkData(ServerLevel, int, int, Consumer, boolean, Priority, RegionFileType...)
++     */
++    public static Cancellable loadAllChunkData(final ServerLevel world, final int chunkX, final int chunkZ,
++                                               final Consumer<RegionFileData> onComplete, final boolean intendingToBlock) {
++        return MoonriseRegionFileIO.loadAllChunkData(world, chunkX, chunkZ, onComplete, intendingToBlock, Priority.NORMAL);
++    }
++
++    /**
++     * Schedules a load to be executed asynchronously. This task will load all regionfile types, and then call
++     * {@code onComplete}. This is a bulk load operation, see {@link #loadDataAsync(ServerLevel, int, int, RegionFileType, BiConsumer, boolean, Priority)}
++     * for single load.
++     * <p>
++     *     Impl notes:
++     * </p>
++     * <li>
++     *     The {@code onComplete} parameter may be completed during the execution of this function synchronously or it may
++     *     be completed asynchronously on this file io thread. Interacting with the file IO thread in the completion of
++     *     data is undefined behaviour, and can cause deadlock.
++     * </li>
++     *
++     * @param world Chunk's world
++     * @param chunkX Chunk's x coordinate
++     * @param chunkZ Chunk's z coordinate
++     * @param onComplete Consumer to execute once this task has completed
++     * @param intendingToBlock Whether the caller is intending to block on completion. This only affects the cost
++     *                         of this call.
++     * @param priority The minimum priority to load the data at.
++     *
++     * @return The {@link Cancellable} for this chunk load. Cancelling it will not affect other loads for the same chunk data.
++     *
++     * @see #loadDataAsync(ServerLevel, int, int, RegionFileType, BiConsumer, boolean)
++     * @see #loadDataAsync(ServerLevel, int, int, RegionFileType, BiConsumer, boolean, Priority)
++     * @see #loadChunkData(ServerLevel, int, int, Consumer, boolean, RegionFileType...)
++     * @see #loadChunkData(ServerLevel, int, int, Consumer, boolean, Priority, RegionFileType...)
++     */
++    public static Cancellable loadAllChunkData(final ServerLevel world, final int chunkX, final int chunkZ,
++                                               final Consumer<RegionFileData> onComplete, final boolean intendingToBlock,
++                                               final Priority priority) {
++        return MoonriseRegionFileIO.loadChunkData(world, chunkX, chunkZ, onComplete, intendingToBlock, priority, CACHED_REGIONFILE_TYPES);
++    }
++
++    /**
++     * Schedules a load to be executed asynchronously. This task will load data for the specified regionfile type(s), and
++     * then call {@code onComplete}. This is a bulk load operation, see {@link #loadDataAsync(ServerLevel, int, int, RegionFileType, BiConsumer, boolean)}
++     * for single load.
++     * <p>
++     *     Impl notes:
++     * </p>
++     * <li>
++     *     The {@code onComplete} parameter may be completed during the execution of this function synchronously or it may
++     *     be completed asynchronously on this file io thread. Interacting with the file IO thread in the completion of
++     *     data is undefined behaviour, and can cause deadlock.
++     * </li>
++     *
++     * @param world Chunk's world
++     * @param chunkX Chunk's x coordinate
++     * @param chunkZ Chunk's z coordinate
++     * @param onComplete Consumer to execute once this task has completed
++     * @param intendingToBlock Whether the caller is intending to block on completion. This only affects the cost
++     *                         of this call.
++     * @param types The regionfile type(s) to load.
++     *
++     * @return The {@link Cancellable} for this chunk load. Cancelling it will not affect other loads for the same chunk data.
++     *
++     * @see #loadDataAsync(ServerLevel, int, int, RegionFileType, BiConsumer, boolean)
++     * @see #loadDataAsync(ServerLevel, int, int, RegionFileType, BiConsumer, boolean, Priority)
++     * @see #loadAllChunkData(ServerLevel, int, int, Consumer, boolean)
++     * @see #loadAllChunkData(ServerLevel, int, int, Consumer, boolean, Priority)
++     */
++    public static Cancellable loadChunkData(final ServerLevel world, final int chunkX, final int chunkZ,
++                                            final Consumer<RegionFileData> onComplete, final boolean intendingToBlock,
++                                            final RegionFileType... types) {
++        return MoonriseRegionFileIO.loadChunkData(world, chunkX, chunkZ, onComplete, intendingToBlock, Priority.NORMAL, types);
++    }
++
++    /**
++     * Schedules a load to be executed asynchronously. This task will load data for the specified regionfile type(s), and
++     * then call {@code onComplete}. This is a bulk load operation, see {@link #loadDataAsync(ServerLevel, int, int, RegionFileType, BiConsumer, boolean, Priority)}
++     * for single load.
++     * <p>
++     *     Impl notes:
++     * </p>
++     * <li>
++     *     The {@code onComplete} parameter may be completed during the execution of this function synchronously or it may
++     *     be completed asynchronously on this file io thread. Interacting with the file IO thread in the completion of
++     *     data is undefined behaviour, and can cause deadlock.
++     * </li>
++     *
++     * @param world Chunk's world
++     * @param chunkX Chunk's x coordinate
++     * @param chunkZ Chunk's z coordinate
++     * @param onComplete Consumer to execute once this task has completed
++     * @param intendingToBlock Whether the caller is intending to block on completion. This only affects the cost
++     *                         of this call.
++     * @param types The regionfile type(s) to load.
++     * @param priority The minimum priority to load the data at.
++     *
++     * @return The {@link Cancellable} for this chunk load. Cancelling it will not affect other loads for the same chunk data.
++     *
++     * @see #loadDataAsync(ServerLevel, int, int, RegionFileType, BiConsumer, boolean)
++     * @see #loadDataAsync(ServerLevel, int, int, RegionFileType, BiConsumer, boolean, Priority)
++     * @see #loadAllChunkData(ServerLevel, int, int, Consumer, boolean)
++     * @see #loadAllChunkData(ServerLevel, int, int, Consumer, boolean, Priority)
++     */
++    public static Cancellable loadChunkData(final ServerLevel world, final int chunkX, final int chunkZ,
++                                            final Consumer<RegionFileData> onComplete, final boolean intendingToBlock,
++                                            final Priority priority, final RegionFileType... types) {
++        if (types == null) {
++            throw new NullPointerException("Types cannot be null");
++        }
++        if (types.length == 0) {
++            throw new IllegalArgumentException("Types cannot be empty");
++        }
++
++        final RegionFileData ret = new RegionFileData();
++
++        final Cancellable[] reads = new CancellableRead[types.length];
++        final AtomicInteger completions = new AtomicInteger();
++        final int expectedCompletions = types.length;
++
++        for (int i = 0; i < expectedCompletions; ++i) {
++            final RegionFileType type = types[i];
++            reads[i] = MoonriseRegionFileIO.loadDataAsync(world, chunkX, chunkZ, type,
++                (final CompoundTag data, final Throwable throwable) -> {
++                    if (throwable != null) {
++                        ret.setThrowable(type, throwable);
++                    } else {
++                        ret.setData(type, data);
++                    }
++
++                    if (completions.incrementAndGet() == expectedCompletions) {
++                        onComplete.accept(ret);
++                    }
++                }, intendingToBlock, priority);
++        }
++
++        return new CancellableReads(reads);
++    }
++
++    /**
++     * Schedules a load to be executed asynchronously. This task will load the specified regionfile type, and then call
++     * {@code onComplete}.
++     * <p>
++     *     Impl notes:
++     * </p>
++     * <li>
++     *     The {@code onComplete} parameter may be completed during the execution of this function synchronously or it may
++     *     be completed asynchronously on this file io thread. Interacting with the file IO thread in the completion of
++     *     data is undefined behaviour, and can cause deadlock.
++     * </li>
++     *
++     * @param world Chunk's world
++     * @param chunkX Chunk's x coordinate
++     * @param chunkZ Chunk's z coordinate
++     * @param onComplete Consumer to execute once this task has completed
++     * @param intendingToBlock Whether the caller is intending to block on completion. This only affects the cost
++     *                         of this call.
++     *
++     * @return The {@link Cancellable} for this chunk load. Cancelling it will not affect other loads for the same chunk data.
++     *
++     * @see #loadChunkData(ServerLevel, int, int, Consumer, boolean, RegionFileType...)
++     * @see #loadChunkData(ServerLevel, int, int, Consumer, boolean, Priority, RegionFileType...)
++     * @see #loadAllChunkData(ServerLevel, int, int, Consumer, boolean)
++     * @see #loadAllChunkData(ServerLevel, int, int, Consumer, boolean, Priority)
++     */
++    public static Cancellable loadDataAsync(final ServerLevel world, final int chunkX, final int chunkZ,
++                                            final RegionFileType type, final BiConsumer<CompoundTag, Throwable> onComplete,
++                                            final boolean intendingToBlock) {
++        return MoonriseRegionFileIO.loadDataAsync(world, chunkX, chunkZ, type, onComplete, intendingToBlock, Priority.NORMAL);
++    }
++
++    /**
++     * Schedules a load to be executed asynchronously. This task will load the specified regionfile type, and then call
++     * {@code onComplete}.
++     * <p>
++     *     Impl notes:
++     * </p>
++     * <li>
++     *     The {@code onComplete} parameter may be completed during the execution of this function synchronously or it may
++     *     be completed asynchronously on this file io thread. Interacting with the file IO thread in the completion of
++     *     data is undefined behaviour, and can cause deadlock.
++     * </li>
++     *
++     * @param world Chunk's world
++     * @param chunkX Chunk's x coordinate
++     * @param chunkZ Chunk's z coordinate
++     * @param onComplete Consumer to execute once this task has completed
++     * @param intendingToBlock Whether the caller is intending to block on completion. This only affects the cost
++     *                         of this call.
++     * @param priority Minimum priority to load the data at.
++     *
++     * @return The {@link Cancellable} for this chunk load. Cancelling it will not affect other loads for the same chunk data.
++     *
++     * @see #loadChunkData(ServerLevel, int, int, Consumer, boolean, RegionFileType...)
++     * @see #loadChunkData(ServerLevel, int, int, Consumer, boolean, Priority, RegionFileType...)
++     * @see #loadAllChunkData(ServerLevel, int, int, Consumer, boolean)
++     * @see #loadAllChunkData(ServerLevel, int, int, Consumer, boolean, Priority)
++     */
++    public static Cancellable loadDataAsync(final ServerLevel world, final int chunkX, final int chunkZ,
++                                            final RegionFileType type, final BiConsumer<CompoundTag, Throwable> onComplete,
++                                            final boolean intendingToBlock, final Priority priority) {
++        final RegionDataController taskController = getControllerFor(world, type);
++
++        final ImmediateCallbackCompletion callbackInfo = new ImmediateCallbackCompletion();
++
++        final long key = CoordinateUtils.getChunkKey(chunkX, chunkZ);
++        final BiLong1Function<ChunkIOTask, ChunkIOTask> compute = (final long keyInMap, final ChunkIOTask running) -> {
++            if (running == null) {
++                // not scheduled
++
++                // set up task
++                final ChunkIOTask newTask = new ChunkIOTask(
++                    world, taskController, chunkX, chunkZ, priority, new ChunkIOTask.InProgressRead()
++                );
++                newTask.inProgressRead.addToAsyncWaiters(onComplete);
++
++                callbackInfo.tasksNeedReadScheduling = true;
++                return newTask;
++            }
++
++            final ChunkIOTask.InProgressWrite pendingWrite = running.inProgressWrite;
++
++            if (pendingWrite == null) {
++                // need to add to waiters here, because the regionfile thread will use compute() to lock and check for cancellations
++                if (!running.inProgressRead.addToAsyncWaiters(onComplete)) {
++                    callbackInfo.data = running.inProgressRead.value;
++                    callbackInfo.throwable = running.inProgressRead.throwable;
++                    callbackInfo.completeNow = true;
++                    return running;
++                }
++
++                callbackInfo.read = running.inProgressRead;
++
++                return running;
++            }
++
++            // at this stage we have to use the in progress write's data to avoid an order issue
++
++            if (!pendingWrite.addToAsyncWaiters(onComplete)) {
++                // data is ready now
++                callbackInfo.data = pendingWrite.value;
++                callbackInfo.throwable = pendingWrite.throwable;
++                callbackInfo.completeNow = true;
++                return running;
++            }
++
++            callbackInfo.write = pendingWrite;
++
++            return running;
++        };
++
++        final ChunkIOTask ret = taskController.chunkTasks.compute(key, compute);
++
++        // needs to be scheduled
++        if (callbackInfo.tasksNeedReadScheduling) {
++            taskController.startTask(ret);
++            ret.scheduleReadIO();
++        } else if (callbackInfo.completeNow) {
++            try {
++                onComplete.accept(callbackInfo.data == null ? null : callbackInfo.data.copy(), callbackInfo.throwable);
++            } catch (final Throwable thr) {
++                LOGGER.error("Callback " + ConcurrentUtil.genericToString(onComplete) + " synchronously failed to handle chunk data for task " + ret.toString(), thr);
++            }
++        } else {
++            // we're waiting on a task we didn't schedule, so raise its priority to what we want
++            ret.raisePriority(priority);
++        }
++
++        return new CancellableRead(onComplete, callbackInfo.read, callbackInfo.write);
++    }
++
++    private static final class ImmediateCallbackCompletion {
++
++        private CompoundTag data;
++        private Throwable throwable;
++        private boolean completeNow;
++        private boolean tasksNeedReadScheduling;
++        private ChunkIOTask.InProgressRead read;
++        private ChunkIOTask.InProgressWrite write;
++
++    }
++
++    /**
++     * Schedules a load task to be executed asynchronously, and blocks on that task.
++     *
++     * @param world Chunk's world
++     * @param chunkX Chunk's x coordinate
++     * @param chunkZ Chunk's z coordinate
++     * @param type Regionfile type
++     * @param priority Minimum priority to load the data at.
++     *
++     * @return The chunk data for the chunk. Note that a {@code null} result means the chunk or regionfile does not exist on disk.
++     *
++     * @throws IOException If the load fails for any reason
++     */
++    public static CompoundTag loadData(final ServerLevel world, final int chunkX, final int chunkZ, final RegionFileType type,
++                                       final Priority priority) throws IOException {
++        final CompletableFuture<CompoundTag> ret = new CompletableFuture<>();
++
++        MoonriseRegionFileIO.loadDataAsync(world, chunkX, chunkZ, type, (final CompoundTag compound, final Throwable thr) -> {
++            if (thr != null) {
++                ret.completeExceptionally(thr);
++            } else {
++                ret.complete(compound);
++            }
++        }, true, priority);
++
++        try {
++            return ret.join();
++        } catch (final CompletionException ex) {
++            throw new IOException(ex);
++        }
++    }
++    
++    private static final class CancellableRead implements Cancellable {
++
++        private BiConsumer<CompoundTag, Throwable> callback;
++        private ChunkIOTask.InProgressRead read;
++        private ChunkIOTask.InProgressWrite write;
++
++        private CancellableRead(final BiConsumer<CompoundTag, Throwable> callback,
++                                final ChunkIOTask.InProgressRead read,
++                                final ChunkIOTask.InProgressWrite write) {
++            this.callback = callback;
++            this.read = read;
++            this.write = write;
++        }
++
++        @Override
++        public boolean cancel() {
++            final BiConsumer<CompoundTag, Throwable> callback = this.callback;
++            final ChunkIOTask.InProgressRead read = this.read;
++            final ChunkIOTask.InProgressWrite write = this.write;
++
++            if (callback == null || (read == null && write == null)) {
++                return false;
++            }
++
++            this.callback = null;
++            this.read = null;
++            this.write = null;
++
++            if (read != null) {
++                return read.cancel(callback);
++            }
++            if (write != null) {
++                return write.cancel(callback);
++            }
++
++            // unreachable
++            throw new InternalError();
++        }
++    }
++
++    private static final class CancellableReads implements Cancellable {
++
++        private Cancellable[] reads;
++        private static final VarHandle READS_HANDLE = ConcurrentUtil.getVarHandle(CancellableReads.class, "reads", Cancellable[].class);
++
++        private CancellableReads(final Cancellable[] reads) {
++            this.reads = reads;
++        }
++
++        @Override
++        public boolean cancel() {
++            final Cancellable[] reads = (Cancellable[])READS_HANDLE.getAndSet((CancellableReads)this, (Cancellable[])null);
++
++            if (reads == null) {
++                return false;
++            }
++
++            boolean ret = false;
++
++            for (final Cancellable read : reads) {
++                ret |= read.cancel();
++            }
++
++            return ret;
++        }
++    }
++
++    private static final class ChunkIOTask {
++
++        private final ServerLevel world;
++        private final RegionDataController regionDataController;
++        private final int chunkX;
++        private final int chunkZ;
++        private Priority priority;
++        private PrioritisedExecutor.PrioritisedTask currentTask;
++
++        private final InProgressRead inProgressRead;
++        private volatile InProgressWrite inProgressWrite;
++        private final ReferenceOpenHashSet<InProgressWrite> allPendingWrites = new ReferenceOpenHashSet<>();
++
++        private RegionDataController.ReadData readData;
++        private RegionDataController.WriteData writeData;
++        private boolean failedWrite;
++
++        public ChunkIOTask(final ServerLevel world, final RegionDataController regionDataController,
++                           final int chunkX, final int chunkZ, final Priority priority, final InProgressRead inProgressRead) {
++            this.world = world;
++            this.regionDataController = regionDataController;
++            this.chunkX = chunkX;
++            this.chunkZ = chunkZ;
++            this.priority = priority;
++            this.inProgressRead = inProgressRead;
++        }
++
++        public Priority getPriority() {
++            synchronized (this) {
++                return this.priority;
++            }
++        }
++
++        // must hold lock on this object
++        private void updatePriority(final Priority priority) {
++            this.priority = priority;
++            if (this.currentTask != null) {
++                this.currentTask.setPriority(priority);
++            }
++            for (final InProgressWrite write : this.allPendingWrites) {
++                if (write.writeTask != null) {
++                    write.writeTask.setPriority(priority);
++                }
++            }
++        }
++
++        public boolean setPriority(final Priority priority) {
++            synchronized (this) {
++                if (this.priority == priority) {
++                    return false;
++                }
++
++                this.updatePriority(priority);
++
++                return true;
++            }
++        }
++
++        public boolean raisePriority(final Priority priority) {
++            synchronized (this) {
++                if (this.priority.isHigherOrEqualPriority(priority)) {
++                    return false;
++                }
++
++                this.updatePriority(priority);
++
++                return true;
++            }
++        }
++
++        public boolean lowerPriority(final Priority priority) {
++            synchronized (this) {
++                if (this.priority.isLowerOrEqualPriority(priority)) {
++                    return false;
++                }
++
++                this.updatePriority(priority);
++
++                return true;
++            }
++        }
++
++        private void pushPendingWrite(final InProgressWrite write) {
++            this.inProgressWrite = write;
++            synchronized (this) {
++                this.allPendingWrites.add(write);
++                if (write.writeTask != null) {
++                    write.writeTask.setPriority(this.priority);
++                }
++            }
++        }
++
++        private void pendingWriteComplete(final InProgressWrite write) {
++            synchronized (this) {
++                this.allPendingWrites.remove(write);
++            }
++        }
++
++        public void scheduleReadIO() {
++            final PrioritisedExecutor.PrioritisedTask task;
++            synchronized (this) {
++                task = this.regionDataController.ioScheduler.createTask(this.chunkX, this.chunkZ, this::performReadIO, this.priority);
++                this.currentTask = task;
++            }
++            task.queue();
++        }
++
++        private void performReadIO() {
++            final InProgressRead read = this.inProgressRead;
++            final long chunkKey = CoordinateUtils.getChunkKey(this.chunkX, this.chunkZ);
++
++            final boolean[] canRead = new boolean[] { true };
++
++            if (read.hasNoWaiters()) {
++                // cancelled read? go to task controller to confirm
++                final ChunkIOTask inMap = this.regionDataController.chunkTasks.compute(chunkKey, (final long keyInMap, final ChunkIOTask valueInMap) -> {
++                    if (valueInMap == null) {
++                        throw new IllegalStateException("Write completed concurrently, expected this task: " + ChunkIOTask.this.toString() + ", report this!");
++                    }
++                    if (valueInMap != ChunkIOTask.this) {
++                        throw new IllegalStateException("Chunk task mismatch, expected this task: " + ChunkIOTask.this.toString() + ", got: " + valueInMap.toString() + ", report this!");
++                    }
++
++                    if (!read.hasNoWaiters()) {
++                        return valueInMap;
++                    } else {
++                        canRead[0] = false;
++                    }
++
++                    if (valueInMap.inProgressWrite != null) {
++                        return valueInMap;
++                    }
++
++                    return null;
++                });
++
++                if (inMap == null) {
++                    this.regionDataController.endTask(this);
++                    // read is cancelled - and no write pending, so we're done
++                    return;
++                }
++                // if there is a write in progress, we don't actually have to worry about waiters gaining new entries -
++                // the readers will just use the in progress write, so the value in canRead is good to use without
++                // further synchronisation.
++            }
++
++            if (canRead[0]) {
++                RegionDataController.ReadData readData = null;
++                Throwable throwable = null;
++
++                try {
++                    readData = this.regionDataController.readData(this.chunkX, this.chunkZ);
++                } catch (final Throwable thr) {
++                    throwable = thr;
++                    LOGGER.error("Failed to read chunk data for task: " + this.toString(), thr);
++                }
++
++                if (throwable != null) {
++                    this.finishRead(null, throwable);
++                } else {
++                    switch (readData.result()) {
++                        case NO_DATA:
++                        case SYNC_READ: {
++                            this.finishRead(readData.syncRead(), null);
++                            break;
++                        }
++                        case HAS_DATA: {
++                            this.readData = readData;
++                            this.scheduleReadDecompress();
++                            // read will handle write scheduling
++                            return;
++                        }
++                        default: {
++                            throw new IllegalStateException("Unknown state: " + readData.result());
++                        }
++                    }
++                }
++            }
++
++            if (!this.tryAbortWrite()) {
++                this.scheduleWriteCompress();
++            }
++        }
++
++        private void scheduleReadDecompress() {
++            final PrioritisedExecutor.PrioritisedTask task;
++            synchronized (this) {
++                task = this.regionDataController.compressionExecutor.createTask(this::performReadDecompress, this.priority);
++                this.currentTask = task;
++            }
++            task.queue();
++        }
++
++        private void performReadDecompress() {
++            final RegionDataController.ReadData readData = this.readData;
++            this.readData = null;
++
++            CompoundTag compoundTag = null;
++            Throwable throwable = null;
++
++            try {
++                compoundTag = this.regionDataController.finishRead(this.chunkX, this.chunkZ, readData);
++            } catch (final Throwable thr) {
++                throwable = thr;
++                LOGGER.error("Failed to decompress chunk data for task: " + this.toString(), thr);
++            }
++
++            if (compoundTag == null) {
++                // need to re-try from the start
++                this.scheduleReadIO();
++                return;
++            }
++
++            this.finishRead(compoundTag, throwable);
++            if (!this.tryAbortWrite()) {
++                this.scheduleWriteCompress();
++            }
++        }
++
++        private void finishRead(final CompoundTag compoundTag, final Throwable throwable) {
++            this.inProgressRead.complete(this, compoundTag, throwable);
++        }
++
++        public void scheduleWriteCompress() {
++            final InProgressWrite inProgressWrite = this.inProgressWrite;
++
++            final PrioritisedExecutor.PrioritisedTask task;
++            synchronized (this) {
++                task = this.regionDataController.compressionExecutor.createTask(() -> {
++                    ChunkIOTask.this.performWriteCompress(inProgressWrite);
++                }, this.priority);
++                this.currentTask = task;
++            }
++
++            inProgressWrite.addToWaiters(this, (final CompoundTag data, final Throwable throwable) -> {
++                task.queue();
++            });
++        }
++
++        private boolean tryAbortWrite() {
++            final long chunkKey = CoordinateUtils.getChunkKey(this.chunkX, this.chunkZ);
++            if (this.inProgressWrite == null) {
++                final ChunkIOTask inMap = this.regionDataController.chunkTasks.compute(chunkKey, (final long keyInMap, final ChunkIOTask valueInMap) -> {
++                    if (valueInMap == null) {
++                        throw new IllegalStateException("Write completed concurrently, expected this task: " + ChunkIOTask.this.toString() + ", report this!");
++                    }
++                    if (valueInMap != ChunkIOTask.this) {
++                        throw new IllegalStateException("Chunk task mismatch, expected this task: " + ChunkIOTask.this.toString() + ", got: " + valueInMap.toString() + ", report this!");
++                    }
++
++                    if (valueInMap.inProgressWrite != null) {
++                        return valueInMap;
++                    }
++
++                    return null;
++                });
++
++                if (inMap == null) {
++                    this.regionDataController.endTask(this);
++                    return true; // set the task value to null, indicating we're done
++                } // else: inProgressWrite changed, so now we have something to write
++            }
++
++            return false;
++        }
++
++        private void performWriteCompress(final InProgressWrite inProgressWrite) {
++            final CompoundTag write = inProgressWrite.value;
++            if (!inProgressWrite.isComplete()) {
++                throw new IllegalStateException("Should be writable");
++            }
++
++            RegionDataController.WriteData writeData = null;
++            boolean failedWrite = false;
++
++            try {
++                writeData = this.regionDataController.startWrite(this.chunkX, this.chunkZ, write);
++            } catch (final Throwable thr) {
++                // TODO implement this?
++                    /*if (thr instanceof RegionFileStorage.RegionFileSizeException) {
++                        final int maxSize = RegionFile.MAX_CHUNK_SIZE / (1024 * 1024);
++                        LOGGER.error("Chunk at (" + this.chunkX + "," + this.chunkZ + ") in '" + WorldUtil.getWorldName(this.world) + "' exceeds max size of " + maxSize + "MiB, it has been deleted from disk.");
++                    } else */
++                {
++                    failedWrite = thr instanceof IOException;
++                    LOGGER.error("Failed to write chunk data for task: " + this.toString(), thr);
++                }
++            }
++
++            if (writeData == null) {
++                // null if a throwable was encountered
++
++                // we cannot continue to the I/O stage here, so try to complete
++
++                if (this.tryCompleteWrite(inProgressWrite, failedWrite)) {
++                    return;
++                } else {
++                    // fetch new data and try again
++                    this.scheduleWriteCompress();
++                    return;
++                }
++            } else {
++                // writeData != null && !failedWrite
++                // we can continue to I/O stage
++                this.writeData = writeData;
++                this.scheduleWriteIO(inProgressWrite);
++                return;
++            }
++        }
++
++        private void scheduleWriteIO(final InProgressWrite inProgressWrite) {
++            final PrioritisedExecutor.PrioritisedTask task;
++            synchronized (this) {
++                task = this.regionDataController.ioScheduler.createTask(this.chunkX, this.chunkZ, () -> {
++                    ChunkIOTask.this.runWriteIO(inProgressWrite);
++                }, this.priority);
++                this.currentTask = task;
++            }
++            task.queue();
++        }
++
++        private void runWriteIO(final InProgressWrite inProgressWrite) {
++            RegionDataController.WriteData writeData = this.writeData;
++            this.writeData = null;
++
++            boolean failedWrite = false;
++
++            try {
++                this.regionDataController.finishWrite(this.chunkX, this.chunkZ, writeData);
++            } catch (final Throwable thr) {
++                failedWrite = thr instanceof IOException;
++                LOGGER.error("Failed to write chunk data for task: " + this.toString(), thr);
++            }
++
++            if (!this.tryCompleteWrite(inProgressWrite, failedWrite)) {
++                // fetch new data and try again
++                this.scheduleWriteCompress();
++            }
++            return;
++        }
++
++        private boolean tryCompleteWrite(final InProgressWrite written, final boolean failedWrite) {
++            final long chunkKey = CoordinateUtils.getChunkKey(this.chunkX, this.chunkZ);
++
++            final boolean[] done = new boolean[] { false };
++
++            this.regionDataController.chunkTasks.compute(chunkKey, (final long keyInMap, final ChunkIOTask valueInMap) -> {
++                if (valueInMap == null) {
++                    throw new IllegalStateException("Write completed concurrently, expected this task: " + ChunkIOTask.this.toString() + ", report this!");
++                }
++                if (valueInMap != ChunkIOTask.this) {
++                    throw new IllegalStateException("Chunk task mismatch, expected this task: " + ChunkIOTask.this.toString() + ", got: " + valueInMap.toString() + ", report this!");
++                }
++                if (valueInMap.inProgressWrite == written) {
++                    valueInMap.failedWrite = failedWrite;
++                    done[0] = true;
++                    // keep the data in map if we failed the write so we can try to prevent data loss
++                    return failedWrite ? valueInMap : null;
++                }
++                // different data than expected, means we need to retry write
++                return valueInMap;
++            });
++
++            if (done[0]) {
++                this.regionDataController.endTask(this);
++                return true;
++            }
++            return false;
++        }
++
++        @Override
++        public String toString() {
++            return "Task for world: '" + WorldUtil.getWorldName(this.world) + "' at (" + this.chunkX + ","
++                    + this.chunkZ + ") type: " + this.regionDataController.type.name() + ", hash: " + this.hashCode();
++        }
++
++        private static final class InProgressRead {
++
++            private static final Logger LOGGER = LoggerFactory.getLogger(InProgressRead.class);
++
++            private CompoundTag value;
++            private Throwable throwable;
++            private final MultiThreadedQueue<BiConsumer<CompoundTag, Throwable>> callbacks = new MultiThreadedQueue<>();
++
++            public boolean hasNoWaiters() {
++                return this.callbacks.isEmpty();
++            }
++
++            public boolean addToAsyncWaiters(final BiConsumer<CompoundTag, Throwable> callback) {
++                return this.callbacks.add(callback);
++            }
++
++            public boolean cancel(final BiConsumer<CompoundTag, Throwable> callback) {
++                return this.callbacks.remove(callback);
++            }
++
++            public void complete(final ChunkIOTask task, final CompoundTag value, final Throwable throwable) {
++                this.value = value;
++                this.throwable = throwable;
++
++                BiConsumer<CompoundTag, Throwable> consumer;
++                while ((consumer = this.callbacks.pollOrBlockAdds()) != null) {
++                    try {
++                        consumer.accept(value == null ? null : value.copy(), throwable);
++                    } catch (final Throwable thr) {
++                        LOGGER.error("Callback " + ConcurrentUtil.genericToString(consumer) + " failed to handle chunk data (read) for task " + task.toString(), thr);
++                    }
++                }
++            }
++        }
++
++        private static final class InProgressWrite {
++
++            private static final Logger LOGGER = LoggerFactory.getLogger(InProgressWrite.class);
++
++            private CompoundTag value;
++            private Throwable throwable;
++            private volatile boolean complete;
++            private final MultiThreadedQueue<BiConsumer<CompoundTag, Throwable>> callbacks = new MultiThreadedQueue<>();
++
++            private final PrioritisedExecutor.PrioritisedTask writeTask;
++
++            public InProgressWrite(final PrioritisedExecutor.PrioritisedTask writeTask) {
++                this.writeTask = writeTask;
++            }
++
++            public boolean isComplete() {
++                return this.complete;
++            }
++
++            public void schedule(final ChunkIOTask task, final Consumer<BiConsumer<CompoundTag, Throwable>> scheduler) {
++                scheduler.accept((final CompoundTag data, final Throwable throwable) -> {
++                    InProgressWrite.this.complete(task, data, throwable);
++                });
++            }
++
++            public boolean addToAsyncWaiters(final BiConsumer<CompoundTag, Throwable> callback) {
++                return this.callbacks.add(callback);
++            }
++
++            public void addToWaiters(final ChunkIOTask task, final BiConsumer<CompoundTag, Throwable> consumer) {
++                if (!this.callbacks.add(consumer)) {
++                    this.syncAccept(task, consumer, this.value, this.throwable);
++                }
++            }
++
++            private void syncAccept(final ChunkIOTask task, final BiConsumer<CompoundTag, Throwable> consumer, final CompoundTag value, final Throwable throwable) {
++                try {
++                    consumer.accept(value == null ? null : value.copy(), throwable);
++                } catch (final Throwable thr) {
++                    LOGGER.error("Callback " + ConcurrentUtil.genericToString(consumer) + " failed to handle chunk data (write) for task " + task.toString(), thr);
++                }
++            }
++
++            public void complete(final ChunkIOTask task, final CompoundTag value, final Throwable throwable) {
++                this.value = value;
++                this.throwable = throwable;
++                this.complete = true;
++
++                task.pendingWriteComplete(this);
++
++                BiConsumer<CompoundTag, Throwable> consumer;
++                while ((consumer = this.callbacks.pollOrBlockAdds()) != null) {
++                    this.syncAccept(task, consumer, value, throwable);
++                }
++            }
++
++            public boolean cancel(final BiConsumer<CompoundTag, Throwable> callback) {
++                return this.callbacks.remove(callback);
++            }
++        }
++    }
++
++    public static abstract class RegionDataController {
++
++        public final RegionFileType type;
++        private final PrioritisedExecutor compressionExecutor;
++        private final IOScheduler ioScheduler;
++        private final ConcurrentLong2ReferenceChainedHashTable<ChunkIOTask> chunkTasks = new ConcurrentLong2ReferenceChainedHashTable<>();
++
++        private final AtomicLong inProgressTasks = new AtomicLong();
++
++        public RegionDataController(final RegionFileType type, final PrioritisedExecutor ioExecutor,
++                                    final PrioritisedExecutor compressionExecutor) {
++            this.type = type;
++            this.compressionExecutor = compressionExecutor;
++            this.ioScheduler = new IOScheduler(ioExecutor);
++        }
++
++        final void startTask(final ChunkIOTask task) {
++            this.inProgressTasks.getAndIncrement();
++        }
++
++        final void endTask(final ChunkIOTask task) {
++            this.inProgressTasks.getAndDecrement();
++        }
++
++        public boolean hasTasks() {
++            return this.inProgressTasks.get() != 0L;
++        }
++
++        public long getTotalWorkingTasks() {
++            return this.inProgressTasks.get();
++        }
++
++        public abstract RegionFileStorage getCache();
++
++        public static record WriteData(CompoundTag input, WriteResult result, DataOutputStream output, IORunnable write) {
++            public static enum WriteResult {
++                WRITE,
++                DELETE;
++            }
++        }
++
++        public abstract WriteData startWrite(final int chunkX, final int chunkZ, final CompoundTag compound) throws IOException;
++
++        public abstract void finishWrite(final int chunkX, final int chunkZ, final WriteData writeData) throws IOException;
++
++        public static record ReadData(ReadResult result, DataInputStream input, CompoundTag syncRead) {
++            public static enum ReadResult {
++                NO_DATA,
++                HAS_DATA,
++                SYNC_READ;
++            }
++        }
++
++        public abstract ReadData readData(final int chunkX, final int chunkZ) throws IOException;
++
++        // if the return value is null, then the caller needs to re-try with a new call to readData()
++        public abstract CompoundTag finishRead(final int chunkX, final int chunkZ, final ReadData readData) throws IOException;
++
++        public static interface IORunnable {
++
++            public void run(final RegionFile regionFile) throws IOException;
++
++        }
++    }
++
++    private static final class IOScheduler {
++
++        private final ConcurrentLong2ReferenceChainedHashTable<RegionIOTasks> regionTasks = new ConcurrentLong2ReferenceChainedHashTable<>();
++        private final PrioritisedExecutor executor;
++
++        public IOScheduler(final PrioritisedExecutor executor) {
++            this.executor = executor;
++        }
++
++        public PrioritisedExecutor.PrioritisedTask createTask(final int chunkX, final int chunkZ,
++                                                              final Runnable run, final Priority priority) {
++            final PrioritisedExecutor.PrioritisedTask[] ret = new PrioritisedExecutor.PrioritisedTask[1];
++            final long subOrder = this.executor.generateNextSubOrder();
++            this.regionTasks.compute(CoordinateUtils.getChunkKey(chunkX >> REGION_FILE_SHIFT, chunkZ >> REGION_FILE_SHIFT),
++                    (final long regionKey, final RegionIOTasks existing) -> {
++                final RegionIOTasks res;
++                if (existing != null) {
++                    res = existing;
++                } else {
++                    res = new RegionIOTasks(regionKey, IOScheduler.this);
++                }
++
++                ret[0] = res.createTask(run, priority, subOrder);
++
++                return res;
++            });
++
++            return ret[0];
++        }
++    }
++
++    private static final class RegionIOTasks implements Runnable {
++
++        private static final Logger LOGGER = LoggerFactory.getLogger(RegionIOTasks.class);
++
++        private final PrioritisedTaskQueue queue = new PrioritisedTaskQueue();
++        private final long regionKey;
++        private final IOScheduler ioScheduler;
++        private long createdTasks;
++        private long executedTasks;
++
++        private PrioritisedExecutor.PrioritisedTask task;
++
++        public RegionIOTasks(final long regionKey, final IOScheduler ioScheduler) {
++            this.regionKey = regionKey;
++            this.ioScheduler = ioScheduler;
++        }
++
++        public PrioritisedExecutor.PrioritisedTask createTask(final Runnable run, final Priority priority,
++                                                              final long subOrder) {
++            ++this.createdTasks;
++            return new WrappedTask(this.queue.createTask(run, priority, subOrder));
++        }
++
++        private void adjustTaskPriority() {
++            final PrioritisedTaskQueue.PrioritySubOrderPair priority = this.queue.getHighestPrioritySubOrder();
++            if (this.task == null) {
++                if (priority == null) {
++                    return;
++                }
++                this.task = this.ioScheduler.executor.createTask(this, priority.priority(), priority.subOrder());
++                this.task.queue();
++            } else {
++                if (priority == null) {
++                    throw new IllegalStateException();
++                } else {
++                    this.task.setPriorityAndSubOrder(priority.priority(), priority.subOrder());
++                }
++            }
++        }
++
++        @Override
++        public void run() {
++            final Runnable run;
++            synchronized (this) {
++                run = this.queue.pollTask();
++            }
++
++            try {
++                run.run();
++            } finally {
++                synchronized (this) {
++                    this.task = null;
++                    this.adjustTaskPriority();
++                }
++                this.ioScheduler.regionTasks.compute(this.regionKey, (final long keyInMap, final RegionIOTasks tasks) -> {
++                    if (tasks != RegionIOTasks.this) {
++                        throw new IllegalStateException("Region task mismatch");
++                    }
++                    ++tasks.executedTasks;
++                    if (tasks.createdTasks != tasks.executedTasks) {
++                        return tasks;
++                    }
++
++                    if (tasks.task != null) {
++                        throw new IllegalStateException("Task may not be null when created==executed");
++                    }
++
++                    return null;
++                });
++            }
++        }
++
++        private final class WrappedTask implements PrioritisedExecutor.PrioritisedTask {
++
++            private final PrioritisedExecutor.PrioritisedTask wrapped;
++
++            public WrappedTask(final PrioritisedExecutor.PrioritisedTask wrap) {
++                this.wrapped = wrap;
++            }
++
++            @Override
++            public PrioritisedExecutor getExecutor() {
++                return RegionIOTasks.this.ioScheduler.executor;
++            }
++
++            @Override
++            public boolean queue() {
++                synchronized (RegionIOTasks.this) {
++                    if (this.wrapped.queue()) {
++                        RegionIOTasks.this.adjustTaskPriority();
++                        return true;
++                    }
++                    return false;
++                }
++            }
++
++            @Override
++            public boolean isQueued() {
++                return this.wrapped.isQueued();
++            }
++
++            @Override
++            public boolean cancel() {
++                throw new UnsupportedOperationException();
++            }
++
++            @Override
++            public boolean execute() {
++                throw new UnsupportedOperationException();
++            }
++
++            @Override
++            public Priority getPriority() {
++                return this.wrapped.getPriority();
++            }
++
++            @Override
++            public boolean setPriority(final Priority priority) {
++                synchronized (RegionIOTasks.this) {
++                    if (this.wrapped.setPriority(priority) && this.wrapped.isQueued()) {
++                        RegionIOTasks.this.adjustTaskPriority();
++                        return true;
++                    }
++                    return false;
++                }
++            }
++
++            @Override
++            public boolean raisePriority(final Priority priority) {
++                synchronized (RegionIOTasks.this) {
++                    if (this.wrapped.raisePriority(priority) && this.wrapped.isQueued()) {
++                        RegionIOTasks.this.adjustTaskPriority();
++                        return true;
++                    }
++                    return false;
++                }
++            }
++
++            @Override
++            public boolean lowerPriority(final Priority priority) {
++                synchronized (RegionIOTasks.this) {
++                    if (this.wrapped.lowerPriority(priority) && this.wrapped.isQueued()) {
++                        RegionIOTasks.this.adjustTaskPriority();
++                        return true;
++                    }
++                    return false;
++                }
++            }
++
++            @Override
++            public long getSubOrder() {
++                return this.wrapped.getSubOrder();
++            }
++
++            @Override
++            public boolean setSubOrder(final long subOrder) {
++                synchronized (RegionIOTasks.this) {
++                    if (this.wrapped.setSubOrder(subOrder) && this.wrapped.isQueued()) {
++                        RegionIOTasks.this.adjustTaskPriority();
++                        return true;
++                    }
++                    return false;
++                }
++            }
++
++            @Override
++            public boolean raiseSubOrder(final long subOrder) {
++                synchronized (RegionIOTasks.this) {
++                    if (this.wrapped.raiseSubOrder(subOrder) && this.wrapped.isQueued()) {
++                        RegionIOTasks.this.adjustTaskPriority();
++                        return true;
++                    }
++                    return false;
++                }
++            }
++
++            @Override
++            public boolean lowerSubOrder(final long subOrder) {
++                synchronized (RegionIOTasks.this) {
++                    if (this.wrapped.lowerSubOrder(subOrder) && this.wrapped.isQueued()) {
++                        RegionIOTasks.this.adjustTaskPriority();
++                        return true;
++                    }
++                    return false;
++                }
++            }
++
++            @Override
++            public boolean setPriorityAndSubOrder(final Priority priority, final long subOrder) {
++                synchronized (RegionIOTasks.this) {
++                    if (this.wrapped.setPriorityAndSubOrder(priority, subOrder) && this.wrapped.isQueued()) {
++                        RegionIOTasks.this.adjustTaskPriority();
++                        return true;
++                    }
++                    return false;
++                }
++            }
++        }
++    }
++}
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/io/RegionFileIOThread.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/io/RegionFileIOThread.java
+deleted file mode 100644
+index 3218cbf84f54daf06e84442d5eb1a36d8da6b215..0000000000000000000000000000000000000000
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/io/RegionFileIOThread.java
++++ /dev/null
+@@ -1,1240 +0,0 @@
+-package ca.spottedleaf.moonrise.patches.chunk_system.io;
+-
+-import ca.spottedleaf.concurrentutil.collection.MultiThreadedQueue;
+-import ca.spottedleaf.concurrentutil.executor.Cancellable;
+-import ca.spottedleaf.concurrentutil.executor.standard.PrioritisedExecutor;
+-import ca.spottedleaf.concurrentutil.executor.standard.PrioritisedQueueExecutorThread;
+-import ca.spottedleaf.concurrentutil.executor.standard.PrioritisedThreadedTaskQueue;
+-import ca.spottedleaf.concurrentutil.function.BiLong1Function;
+-import ca.spottedleaf.concurrentutil.map.ConcurrentLong2ReferenceChainedHashTable;
+-import ca.spottedleaf.concurrentutil.util.ConcurrentUtil;
+-import ca.spottedleaf.moonrise.common.util.CoordinateUtils;
+-import ca.spottedleaf.moonrise.common.util.TickThread;
+-import ca.spottedleaf.moonrise.common.util.WorldUtil;
+-import ca.spottedleaf.moonrise.patches.chunk_system.level.ChunkSystemServerLevel;
+-import net.minecraft.nbt.CompoundTag;
+-import net.minecraft.server.level.ServerLevel;
+-import net.minecraft.world.level.ChunkPos;
+-import net.minecraft.world.level.chunk.storage.RegionFile;
+-import net.minecraft.world.level.chunk.storage.RegionFileStorage;
+-import org.slf4j.Logger;
+-import org.slf4j.LoggerFactory;
+-import java.io.IOException;
+-import java.lang.invoke.VarHandle;
+-import java.util.concurrent.CompletableFuture;
+-import java.util.concurrent.CompletionException;
+-import java.util.concurrent.atomic.AtomicInteger;
+-import java.util.function.BiConsumer;
+-import java.util.function.Consumer;
+-import java.util.function.Function;
+-
+-/**
+- * Prioritised RegionFile I/O executor, responsible for all RegionFile access.
+- * <p>
+- *     All functions provided are MT-Safe, however certain ordering constraints are recommended:
+- *     <li>
+- *         Chunk saves may not occur for unloaded chunks.
+- *     </li>
+- *     <li>
+- *         Tasks must be scheduled on the chunk scheduler thread.
+- *     </li>
+- *     By following these constraints, no chunk data loss should occur with the exception of underlying I/O problems.
+- * </p>
+- */
+-public final class RegionFileIOThread extends PrioritisedQueueExecutorThread {
+-
+-    private static final Logger LOGGER = LoggerFactory.getLogger(RegionFileIOThread.class);
+-
+-    /**
+-     * The kinds of region files controlled by the region file thread. Add more when needed, and ensure
+-     * getControllerFor is updated.
+-     */
+-    public static enum RegionFileType {
+-        CHUNK_DATA,
+-        POI_DATA,
+-        ENTITY_DATA;
+-    }
+-
+-    private static final RegionFileType[] CACHED_REGIONFILE_TYPES = RegionFileType.values();
+-
+-    public static ChunkDataController getControllerFor(final ServerLevel world, final RegionFileType type) {
+-        switch (type) {
+-            case CHUNK_DATA:
+-                return ((ChunkSystemServerLevel)world).moonrise$getChunkDataController();
+-            case POI_DATA:
+-                return ((ChunkSystemServerLevel)world).moonrise$getPoiChunkDataController();
+-            case ENTITY_DATA:
+-                return ((ChunkSystemServerLevel)world).moonrise$getEntityChunkDataController();
+-            default:
+-                throw new IllegalStateException("Unknown controller type " + type);
+-        }
+-    }
+-
+-    /**
+-     * Collects regionfile data for a certain chunk.
+-     */
+-    public static final class RegionFileData {
+-
+-        private final boolean[] hasResult = new boolean[CACHED_REGIONFILE_TYPES.length];
+-        private final CompoundTag[] data = new CompoundTag[CACHED_REGIONFILE_TYPES.length];
+-        private final Throwable[] throwables = new Throwable[CACHED_REGIONFILE_TYPES.length];
+-
+-        /**
+-         * Sets the result associated with the specified regionfile type. Note that
+-         * results can only be set once per regionfile type.
+-         *
+-         * @param type The regionfile type.
+-         * @param data The result to set.
+-         */
+-        public void setData(final RegionFileType type, final CompoundTag data) {
+-            final int index = type.ordinal();
+-
+-            if (this.hasResult[index]) {
+-                throw new IllegalArgumentException("Result already exists for type " + type);
+-            }
+-            this.hasResult[index] = true;
+-            this.data[index] = data;
+-        }
+-
+-        /**
+-         * Sets the result associated with the specified regionfile type. Note that
+-         * results can only be set once per regionfile type.
+-         *
+-         * @param type The regionfile type.
+-         * @param throwable The result to set.
+-         */
+-        public void setThrowable(final RegionFileType type, final Throwable throwable) {
+-            final int index = type.ordinal();
+-
+-            if (this.hasResult[index]) {
+-                throw new IllegalArgumentException("Result already exists for type " + type);
+-            }
+-            this.hasResult[index] = true;
+-            this.throwables[index] = throwable;
+-        }
+-
+-        /**
+-         * Returns whether there is a result for the specified regionfile type.
+-         *
+-         * @param type Specified regionfile type.
+-         *
+-         * @return Whether a result exists for {@code type}.
+-         */
+-        public boolean hasResult(final RegionFileType type) {
+-            return this.hasResult[type.ordinal()];
+-        }
+-
+-        /**
+-         * Returns the data result for the regionfile type.
+-         *
+-         * @param type Specified regionfile type.
+-         *
+-         * @throws IllegalArgumentException If the result has not been set for {@code type}.
+-         * @return The data result for the specified type. If the result is a {@code Throwable},
+-         * then returns {@code null}.
+-         */
+-        public CompoundTag getData(final RegionFileType type) {
+-            final int index = type.ordinal();
+-
+-            if (!this.hasResult[index]) {
+-                throw new IllegalArgumentException("Result does not exist for type " + type);
+-            }
+-
+-            return this.data[index];
+-        }
+-
+-        /**
+-         * Returns the throwable result for the regionfile type.
+-         *
+-         * @param type Specified regionfile type.
+-         *
+-         * @throws IllegalArgumentException If the result has not been set for {@code type}.
+-         * @return The throwable result for the specified type. If the result is an {@code CompoundTag},
+-         * then returns {@code null}.
+-         */
+-        public Throwable getThrowable(final RegionFileType type) {
+-            final int index = type.ordinal();
+-
+-            if (!this.hasResult[index]) {
+-                throw new IllegalArgumentException("Result does not exist for type " + type);
+-            }
+-
+-            return this.throwables[index];
+-        }
+-    }
+-
+-    private static final Object INIT_LOCK = new Object();
+-
+-    static RegionFileIOThread[] threads;
+-
+-    /* needs to be consistent given a set of parameters */
+-    static RegionFileIOThread selectThread(final ServerLevel world, final int chunkX, final int chunkZ, final RegionFileType type) {
+-        if (threads == null) {
+-            throw new IllegalStateException("Threads not initialised");
+-        }
+-
+-        final int regionX = chunkX >> 5;
+-        final int regionZ = chunkZ >> 5;
+-        final int typeOffset = type.ordinal();
+-
+-        return threads[(System.identityHashCode(world) + regionX + regionZ + typeOffset) % threads.length];
+-    }
+-
+-    /**
+-     * Shuts down the I/O executor(s). Watis for all tasks to complete if specified.
+-     * Tasks queued during this call might not be accepted, and tasks queued after will not be accepted.
+-     *
+-     * @param wait Whether to wait until all tasks have completed.
+-     */
+-    public static void close(final boolean wait) {
+-        for (int i = 0, len = threads.length; i < len; ++i) {
+-            threads[i].close(false, true);
+-        }
+-        if (wait) {
+-            RegionFileIOThread.flush();
+-        }
+-    }
+-
+-    public static long[] getExecutedTasks() {
+-        final long[] ret = new long[threads.length];
+-        for (int i = 0, len = threads.length; i < len; ++i) {
+-            ret[i] = threads[i].getTotalTasksExecuted();
+-        }
+-
+-        return ret;
+-    }
+-
+-    public static long[] getTasksScheduled() {
+-        final long[] ret = new long[threads.length];
+-        for (int i = 0, len = threads.length; i < len; ++i) {
+-            ret[i] = threads[i].getTotalTasksScheduled();
+-        }
+-        return ret;
+-    }
+-
+-    public static void flush() {
+-        for (int i = 0, len = threads.length; i < len; ++i) {
+-            threads[i].waitUntilAllExecuted();
+-        }
+-    }
+-
+-    public static void flushRegionStorages(final ServerLevel world) throws IOException {
+-        for (final RegionFileType type : CACHED_REGIONFILE_TYPES) {
+-            getControllerFor(world, type).getCache().flush();
+-        }
+-    }
+-
+-    public static void partialFlush(final int totalTasksRemaining) {
+-        long failures = 1L; // start out at 0.25ms
+-
+-        for (;;) {
+-            final long[] executed = getExecutedTasks();
+-            final long[] scheduled = getTasksScheduled();
+-
+-            long sum = 0;
+-            for (int i = 0; i < executed.length; ++i) {
+-                sum += scheduled[i] - executed[i];
+-            }
+-
+-            if (sum <= totalTasksRemaining) {
+-                break;
+-            }
+-
+-            failures = ConcurrentUtil.linearLongBackoff(failures, 250_000L, 5_000_000L); // 500us, 5ms
+-        }
+-    }
+-
+-    /**
+-     * Inits the executor with the specified number of threads.
+-     *
+-     * @param threads Specified number of threads.
+-     */
+-    public static void init(final int threads) {
+-        synchronized (INIT_LOCK) {
+-            if (RegionFileIOThread.threads != null) {
+-                throw new IllegalStateException("Already initialised threads");
+-            }
+-
+-            RegionFileIOThread.threads = new RegionFileIOThread[threads];
+-
+-            for (int i = 0; i < threads; ++i) {
+-                RegionFileIOThread.threads[i] = new RegionFileIOThread(i);
+-                RegionFileIOThread.threads[i].start();
+-            }
+-        }
+-    }
+-
+-    public static void deinit() {
+-        if (true) { // Paper
+-            // TODO does this cause issues with mods? how to implement
+-            close(true);
+-            synchronized (INIT_LOCK) {
+-                RegionFileIOThread.threads = null;
+-            }
+-        } else { RegionFileIOThread.flush(); }
+-    }
+-
+-    private RegionFileIOThread(final int threadNumber) {
+-        super(new PrioritisedThreadedTaskQueue(), (int)(1.0e6)); // 1.0ms spinwait time
+-        this.setName("RegionFile I/O Thread #" + threadNumber);
+-        this.setPriority(Thread.NORM_PRIORITY - 2); // we keep priority close to normal because threads can wait on us
+-        this.setUncaughtExceptionHandler((final Thread thread, final Throwable thr) -> {
+-            LOGGER.error("Uncaught exception thrown from I/O thread, report this! Thread: " + thread.getName(), thr);
+-        });
+-    }
+-
+-    /**
+-     * Returns whether the current thread is a regionfile I/O executor.
+-     * @return Whether the current thread is a regionfile I/O executor.
+-     */
+-    public static boolean isRegionFileThread() {
+-        return Thread.currentThread() instanceof RegionFileIOThread;
+-    }
+-
+-    /**
+-     * Returns the priority associated with blocking I/O based on the current thread. The goal is to avoid
+-     * dumb plugins from taking away priority from threads we consider crucial.
+-     * @return The priroity to use with blocking I/O on the current thread.
+-     */
+-    public static Priority getIOBlockingPriorityForCurrentThread() {
+-        if (TickThread.isTickThread()) {
+-            return Priority.BLOCKING;
+-        }
+-        return Priority.HIGHEST;
+-    }
+-
+-    /**
+-     * Returns the current {@code CompoundTag} pending for write for the specified chunk & regionfile type.
+-     * Note that this does not copy the result, so do not modify the result returned.
+-     *
+-     * @param world Specified world.
+-     * @param chunkX Specified chunk x.
+-     * @param chunkZ Specified chunk z.
+-     * @param type Specified regionfile type.
+-     *
+-     * @return The compound tag associated for the specified chunk. {@code null} if no write was pending, or if {@code null} is the write pending.
+-     */
+-    public static CompoundTag getPendingWrite(final ServerLevel world, final int chunkX, final int chunkZ, final RegionFileType type) {
+-        final RegionFileIOThread thread = RegionFileIOThread.selectThread(world, chunkX, chunkZ, type);
+-        return thread.getPendingWriteInternal(world, chunkX, chunkZ, type);
+-    }
+-
+-    CompoundTag getPendingWriteInternal(final ServerLevel world, final int chunkX, final int chunkZ, final RegionFileType type) {
+-        final ChunkDataController taskController = getControllerFor(world, type);
+-        final ChunkDataTask task = taskController.tasks.get(CoordinateUtils.getChunkKey(chunkX, chunkZ));
+-
+-        if (task == null) {
+-            return null;
+-        }
+-
+-        final CompoundTag ret = task.inProgressWrite;
+-
+-        return ret == ChunkDataTask.NOTHING_TO_WRITE ? null : ret;
+-    }
+-
+-    /**
+-     * Returns the priority for the specified regionfile type for the specified chunk.
+-     * @param world Specified world.
+-     * @param chunkX Specified chunk x.
+-     * @param chunkZ Specified chunk z.
+-     * @param type Specified regionfile type.
+-     * @return The priority for the chunk
+-     */
+-    public static Priority getPriority(final ServerLevel world, final int chunkX, final int chunkZ, final RegionFileType type) {
+-        final RegionFileIOThread thread = RegionFileIOThread.selectThread(world, chunkX, chunkZ, type);
+-        return thread.getPriorityInternal(world, chunkX, chunkZ, type);
+-    }
+-
+-    Priority getPriorityInternal(final ServerLevel world, final int chunkX, final int chunkZ, final RegionFileType type) {
+-        final ChunkDataController taskController = getControllerFor(world, type);
+-        final ChunkDataTask task = taskController.tasks.get(CoordinateUtils.getChunkKey(chunkX, chunkZ));
+-
+-        if (task == null) {
+-            return Priority.COMPLETING;
+-        }
+-
+-        return task.prioritisedTask.getPriority();
+-    }
+-
+-    /**
+-     * Sets the priority for all regionfile types for the specified chunk. Note that great care should
+-     * be taken using this method, as there can be multiple tasks tied to the same chunk that want different
+-     * priorities.
+-     *
+-     * @param world Specified world.
+-     * @param chunkX Specified chunk x.
+-     * @param chunkZ Specified chunk z.
+-     * @param priority New priority.
+-     *
+-     * @see #raisePriority(ServerLevel, int, int, Priority)
+-     * @see #raisePriority(ServerLevel, int, int, RegionFileType, Priority)
+-     * @see #lowerPriority(ServerLevel, int, int, Priority)
+-     * @see #lowerPriority(ServerLevel, int, int, RegionFileType, Priority)
+-     */
+-    public static void setPriority(final ServerLevel world, final int chunkX, final int chunkZ,
+-                                   final Priority priority) {
+-        for (final RegionFileType type : CACHED_REGIONFILE_TYPES) {
+-            RegionFileIOThread.setPriority(world, chunkX, chunkZ, type, priority);
+-        }
+-    }
+-
+-    /**
+-     * Sets the priority for the specified regionfile type for the specified chunk. Note that great care should
+-     * be taken using this method, as there can be multiple tasks tied to the same chunk that want different
+-     * priorities.
+-     *
+-     * @param world Specified world.
+-     * @param chunkX Specified chunk x.
+-     * @param chunkZ Specified chunk z.
+-     * @param type Specified regionfile type.
+-     * @param priority New priority.
+-     *
+-     * @see #raisePriority(ServerLevel, int, int, Priority)
+-     * @see #raisePriority(ServerLevel, int, int, RegionFileType, Priority)
+-     * @see #lowerPriority(ServerLevel, int, int, Priority)
+-     * @see #lowerPriority(ServerLevel, int, int, RegionFileType, Priority)
+-     */
+-    public static void setPriority(final ServerLevel world, final int chunkX, final int chunkZ, final RegionFileType type,
+-                                   final Priority priority) {
+-        final RegionFileIOThread thread = RegionFileIOThread.selectThread(world, chunkX, chunkZ, type);
+-        thread.setPriorityInternal(world, chunkX, chunkZ, type, priority);
+-    }
+-
+-    void setPriorityInternal(final ServerLevel world, final int chunkX, final int chunkZ, final RegionFileType type,
+-                             final Priority priority) {
+-        final ChunkDataController taskController = getControllerFor(world, type);
+-        final ChunkDataTask task = taskController.tasks.get(CoordinateUtils.getChunkKey(chunkX, chunkZ));
+-
+-        if (task != null) {
+-            task.prioritisedTask.setPriority(priority);
+-        }
+-    }
+-
+-    /**
+-     * Raises the priority for all regionfile types for the specified chunk.
+-     *
+-     * @param world Specified world.
+-     * @param chunkX Specified chunk x.
+-     * @param chunkZ Specified chunk z.
+-     * @param priority New priority.
+-     *
+-     * @see #setPriority(ServerLevel, int, int, Priority)
+-     * @see #setPriority(ServerLevel, int, int, RegionFileType, Priority)
+-     * @see #lowerPriority(ServerLevel, int, int, Priority)
+-     * @see #lowerPriority(ServerLevel, int, int, RegionFileType, Priority)
+-     */
+-    public static void raisePriority(final ServerLevel world, final int chunkX, final int chunkZ,
+-                                     final Priority priority) {
+-        for (final RegionFileType type : CACHED_REGIONFILE_TYPES) {
+-            RegionFileIOThread.raisePriority(world, chunkX, chunkZ, type, priority);
+-        }
+-    }
+-
+-    /**
+-     * Raises the priority for the specified regionfile type for the specified chunk.
+-     *
+-     * @param world Specified world.
+-     * @param chunkX Specified chunk x.
+-     * @param chunkZ Specified chunk z.
+-     * @param type Specified regionfile type.
+-     * @param priority New priority.
+-     *
+-     * @see #setPriority(ServerLevel, int, int, Priority)
+-     * @see #setPriority(ServerLevel, int, int, RegionFileType, Priority)
+-     * @see #lowerPriority(ServerLevel, int, int, Priority)
+-     * @see #lowerPriority(ServerLevel, int, int, RegionFileType, Priority)
+-     */
+-    public static void raisePriority(final ServerLevel world, final int chunkX, final int chunkZ, final RegionFileType type,
+-                                     final Priority priority) {
+-        final RegionFileIOThread thread = RegionFileIOThread.selectThread(world, chunkX, chunkZ, type);
+-        thread.raisePriorityInternal(world, chunkX, chunkZ, type, priority);
+-    }
+-
+-    void raisePriorityInternal(final ServerLevel world, final int chunkX, final int chunkZ, final RegionFileType type,
+-                               final Priority priority) {
+-        final ChunkDataController taskController = getControllerFor(world, type);
+-        final ChunkDataTask task = taskController.tasks.get(CoordinateUtils.getChunkKey(chunkX, chunkZ));
+-
+-        if (task != null) {
+-            task.prioritisedTask.raisePriority(priority);
+-        }
+-    }
+-
+-    /**
+-     * Lowers the priority for all regionfile types for the specified chunk.
+-     *
+-     * @param world Specified world.
+-     * @param chunkX Specified chunk x.
+-     * @param chunkZ Specified chunk z.
+-     * @param priority New priority.
+-     *
+-     * @see #raisePriority(ServerLevel, int, int, Priority)
+-     * @see #raisePriority(ServerLevel, int, int, RegionFileType, Priority)
+-     * @see #setPriority(ServerLevel, int, int, Priority)
+-     * @see #setPriority(ServerLevel, int, int, RegionFileType, Priority)
+-     */
+-    public static void lowerPriority(final ServerLevel world, final int chunkX, final int chunkZ,
+-                                     final Priority priority) {
+-        for (final RegionFileType type : CACHED_REGIONFILE_TYPES) {
+-            RegionFileIOThread.lowerPriority(world, chunkX, chunkZ, type, priority);
+-        }
+-    }
+-
+-    /**
+-     * Lowers the priority for the specified regionfile type for the specified chunk.
+-     *
+-     * @param world Specified world.
+-     * @param chunkX Specified chunk x.
+-     * @param chunkZ Specified chunk z.
+-     * @param type Specified regionfile type.
+-     * @param priority New priority.
+-     *
+-     * @see #raisePriority(ServerLevel, int, int, Priority)
+-     * @see #raisePriority(ServerLevel, int, int, RegionFileType, Priority)
+-     * @see #setPriority(ServerLevel, int, int, Priority)
+-     * @see #setPriority(ServerLevel, int, int, RegionFileType, Priority)
+-     */
+-    public static void lowerPriority(final ServerLevel world, final int chunkX, final int chunkZ, final RegionFileType type,
+-                                     final Priority priority) {
+-        final RegionFileIOThread thread = RegionFileIOThread.selectThread(world, chunkX, chunkZ, type);
+-        thread.lowerPriorityInternal(world, chunkX, chunkZ, type, priority);
+-    }
+-
+-    void lowerPriorityInternal(final ServerLevel world, final int chunkX, final int chunkZ, final RegionFileType type,
+-                               final Priority priority) {
+-        final ChunkDataController taskController = getControllerFor(world, type);
+-        final ChunkDataTask task = taskController.tasks.get(CoordinateUtils.getChunkKey(chunkX, chunkZ));
+-
+-        if (task != null) {
+-            task.prioritisedTask.lowerPriority(priority);
+-        }
+-    }
+-
+-    /**
+-     * Schedules the chunk data to be written asynchronously.
+-     * <p>
+-     *     Impl notes:
+-     * </p>
+-     * <li>
+-     *     This function presumes a chunk load for the coordinates is not called during this function (anytime after is OK). This means
+-     *     saves must be scheduled before a chunk is unloaded.
+-     * </li>
+-     * <li>
+-     *     Writes may be called concurrently, although only the "later" write will go through.
+-     * </li>
+-     *
+-     * @param world Chunk's world
+-     * @param chunkX Chunk's x coordinate
+-     * @param chunkZ Chunk's z coordinate
+-     * @param data Chunk's data
+-     * @param type The regionfile type to write to.
+-     *
+-     * @throws IllegalStateException If the file io thread has shutdown.
+-     */
+-    public static void scheduleSave(final ServerLevel world, final int chunkX, final int chunkZ, final CompoundTag data,
+-                                    final RegionFileType type) {
+-        RegionFileIOThread.scheduleSave(world, chunkX, chunkZ, data, type, Priority.NORMAL);
+-    }
+-
+-    /**
+-     * Schedules the chunk data to be written asynchronously.
+-     * <p>
+-     *     Impl notes:
+-     * </p>
+-     * <li>
+-     *     This function presumes a chunk load for the coordinates is not called during this function (anytime after is OK). This means
+-     *     saves must be scheduled before a chunk is unloaded.
+-     * </li>
+-     * <li>
+-     *     Writes may be called concurrently, although only the "later" write will go through.
+-     * </li>
+-     *
+-     * @param world Chunk's world
+-     * @param chunkX Chunk's x coordinate
+-     * @param chunkZ Chunk's z coordinate
+-     * @param data Chunk's data
+-     * @param type The regionfile type to write to.
+-     * @param priority The minimum priority to schedule at.
+-     *
+-     * @throws IllegalStateException If the file io thread has shutdown.
+-     */
+-    public static void scheduleSave(final ServerLevel world, final int chunkX, final int chunkZ, final CompoundTag data,
+-                                    final RegionFileType type, final Priority priority) {
+-        final RegionFileIOThread thread = RegionFileIOThread.selectThread(world, chunkX, chunkZ, type);
+-        thread.scheduleSaveInternal(world, chunkX, chunkZ, data, type, priority);
+-    }
+-
+-    void scheduleSaveInternal(final ServerLevel world, final int chunkX, final int chunkZ, final CompoundTag data,
+-                              final RegionFileType type, final Priority priority) {
+-        final ChunkDataController taskController = getControllerFor(world, type);
+-
+-        final boolean[] created = new boolean[1];
+-        final long key = CoordinateUtils.getChunkKey(chunkX, chunkZ);
+-        final ChunkDataTask task = taskController.tasks.compute(key, (final long keyInMap, final ChunkDataTask taskRunning) -> {
+-            if (taskRunning == null || taskRunning.failedWrite) {
+-                // no task is scheduled or the previous write failed - meaning we need to overwrite it
+-
+-                // create task
+-                final ChunkDataTask newTask = new ChunkDataTask(world, chunkX, chunkZ, taskController, RegionFileIOThread.this, priority);
+-                newTask.inProgressWrite = data;
+-                created[0] = true;
+-
+-                return newTask;
+-            }
+-
+-            taskRunning.inProgressWrite = data;
+-
+-            return taskRunning;
+-        });
+-
+-        if (created[0]) {
+-            task.prioritisedTask.queue();
+-        } else {
+-            task.prioritisedTask.raisePriority(priority);
+-        }
+-    }
+-
+-    /**
+-     * Schedules a load to be executed asynchronously. This task will load all regionfile types, and then call
+-     * {@code onComplete}. This is a bulk load operation, see {@link #loadDataAsync(ServerLevel, int, int, RegionFileType, BiConsumer, boolean)}
+-     * for single load.
+-     * <p>
+-     *     Impl notes:
+-     * </p>
+-     * <li>
+-     *     The {@code onComplete} parameter may be completed during the execution of this function synchronously or it may
+-     *     be completed asynchronously on this file io thread. Interacting with the file IO thread in the completion of
+-     *     data is undefined behaviour, and can cause deadlock.
+-     * </li>
+-     *
+-     * @param world Chunk's world
+-     * @param chunkX Chunk's x coordinate
+-     * @param chunkZ Chunk's z coordinate
+-     * @param onComplete Consumer to execute once this task has completed
+-     * @param intendingToBlock Whether the caller is intending to block on completion. This only affects the cost
+-     *                         of this call.
+-     *
+-     * @return The {@link Cancellable} for this chunk load. Cancelling it will not affect other loads for the same chunk data.
+-     *
+-     * @see #loadDataAsync(ServerLevel, int, int, RegionFileType, BiConsumer, boolean)
+-     * @see #loadDataAsync(ServerLevel, int, int, RegionFileType, BiConsumer, boolean, Priority)
+-     * @see #loadChunkData(ServerLevel, int, int, Consumer, boolean, RegionFileType...)
+-     * @see #loadChunkData(ServerLevel, int, int, Consumer, boolean, Priority, RegionFileType...)
+-     */
+-    public static Cancellable loadAllChunkData(final ServerLevel world, final int chunkX, final int chunkZ,
+-                                               final Consumer<RegionFileData> onComplete, final boolean intendingToBlock) {
+-        return RegionFileIOThread.loadAllChunkData(world, chunkX, chunkZ, onComplete, intendingToBlock, Priority.NORMAL);
+-    }
+-
+-    /**
+-     * Schedules a load to be executed asynchronously. This task will load all regionfile types, and then call
+-     * {@code onComplete}. This is a bulk load operation, see {@link #loadDataAsync(ServerLevel, int, int, RegionFileType, BiConsumer, boolean, Priority)}
+-     * for single load.
+-     * <p>
+-     *     Impl notes:
+-     * </p>
+-     * <li>
+-     *     The {@code onComplete} parameter may be completed during the execution of this function synchronously or it may
+-     *     be completed asynchronously on this file io thread. Interacting with the file IO thread in the completion of
+-     *     data is undefined behaviour, and can cause deadlock.
+-     * </li>
+-     *
+-     * @param world Chunk's world
+-     * @param chunkX Chunk's x coordinate
+-     * @param chunkZ Chunk's z coordinate
+-     * @param onComplete Consumer to execute once this task has completed
+-     * @param intendingToBlock Whether the caller is intending to block on completion. This only affects the cost
+-     *                         of this call.
+-     * @param priority The minimum priority to load the data at.
+-     *
+-     * @return The {@link Cancellable} for this chunk load. Cancelling it will not affect other loads for the same chunk data.
+-     *
+-     * @see #loadDataAsync(ServerLevel, int, int, RegionFileType, BiConsumer, boolean)
+-     * @see #loadDataAsync(ServerLevel, int, int, RegionFileType, BiConsumer, boolean, Priority)
+-     * @see #loadChunkData(ServerLevel, int, int, Consumer, boolean, RegionFileType...)
+-     * @see #loadChunkData(ServerLevel, int, int, Consumer, boolean, Priority, RegionFileType...)
+-     */
+-    public static Cancellable loadAllChunkData(final ServerLevel world, final int chunkX, final int chunkZ,
+-                                               final Consumer<RegionFileData> onComplete, final boolean intendingToBlock,
+-                                               final Priority priority) {
+-        return RegionFileIOThread.loadChunkData(world, chunkX, chunkZ, onComplete, intendingToBlock, priority, CACHED_REGIONFILE_TYPES);
+-    }
+-
+-    /**
+-     * Schedules a load to be executed asynchronously. This task will load data for the specified regionfile type(s), and
+-     * then call {@code onComplete}. This is a bulk load operation, see {@link #loadDataAsync(ServerLevel, int, int, RegionFileType, BiConsumer, boolean)}
+-     * for single load.
+-     * <p>
+-     *     Impl notes:
+-     * </p>
+-     * <li>
+-     *     The {@code onComplete} parameter may be completed during the execution of this function synchronously or it may
+-     *     be completed asynchronously on this file io thread. Interacting with the file IO thread in the completion of
+-     *     data is undefined behaviour, and can cause deadlock.
+-     * </li>
+-     *
+-     * @param world Chunk's world
+-     * @param chunkX Chunk's x coordinate
+-     * @param chunkZ Chunk's z coordinate
+-     * @param onComplete Consumer to execute once this task has completed
+-     * @param intendingToBlock Whether the caller is intending to block on completion. This only affects the cost
+-     *                         of this call.
+-     * @param types The regionfile type(s) to load.
+-     *
+-     * @return The {@link Cancellable} for this chunk load. Cancelling it will not affect other loads for the same chunk data.
+-     *
+-     * @see #loadDataAsync(ServerLevel, int, int, RegionFileType, BiConsumer, boolean)
+-     * @see #loadDataAsync(ServerLevel, int, int, RegionFileType, BiConsumer, boolean, Priority)
+-     * @see #loadAllChunkData(ServerLevel, int, int, Consumer, boolean)
+-     * @see #loadAllChunkData(ServerLevel, int, int, Consumer, boolean, Priority)
+-     */
+-    public static Cancellable loadChunkData(final ServerLevel world, final int chunkX, final int chunkZ,
+-                                            final Consumer<RegionFileData> onComplete, final boolean intendingToBlock,
+-                                            final RegionFileType... types) {
+-        return RegionFileIOThread.loadChunkData(world, chunkX, chunkZ, onComplete, intendingToBlock, Priority.NORMAL, types);
+-    }
+-
+-    /**
+-     * Schedules a load to be executed asynchronously. This task will load data for the specified regionfile type(s), and
+-     * then call {@code onComplete}. This is a bulk load operation, see {@link #loadDataAsync(ServerLevel, int, int, RegionFileType, BiConsumer, boolean, Priority)}
+-     * for single load.
+-     * <p>
+-     *     Impl notes:
+-     * </p>
+-     * <li>
+-     *     The {@code onComplete} parameter may be completed during the execution of this function synchronously or it may
+-     *     be completed asynchronously on this file io thread. Interacting with the file IO thread in the completion of
+-     *     data is undefined behaviour, and can cause deadlock.
+-     * </li>
+-     *
+-     * @param world Chunk's world
+-     * @param chunkX Chunk's x coordinate
+-     * @param chunkZ Chunk's z coordinate
+-     * @param onComplete Consumer to execute once this task has completed
+-     * @param intendingToBlock Whether the caller is intending to block on completion. This only affects the cost
+-     *                         of this call.
+-     * @param types The regionfile type(s) to load.
+-     * @param priority The minimum priority to load the data at.
+-     *
+-     * @return The {@link Cancellable} for this chunk load. Cancelling it will not affect other loads for the same chunk data.
+-     *
+-     * @see #loadDataAsync(ServerLevel, int, int, RegionFileType, BiConsumer, boolean)
+-     * @see #loadDataAsync(ServerLevel, int, int, RegionFileType, BiConsumer, boolean, Priority)
+-     * @see #loadAllChunkData(ServerLevel, int, int, Consumer, boolean)
+-     * @see #loadAllChunkData(ServerLevel, int, int, Consumer, boolean, Priority)
+-     */
+-    public static Cancellable loadChunkData(final ServerLevel world, final int chunkX, final int chunkZ,
+-                                            final Consumer<RegionFileData> onComplete, final boolean intendingToBlock,
+-                                            final Priority priority, final RegionFileType... types) {
+-        if (types == null) {
+-            throw new NullPointerException("Types cannot be null");
+-        }
+-        if (types.length == 0) {
+-            throw new IllegalArgumentException("Types cannot be empty");
+-        }
+-
+-        final RegionFileData ret = new RegionFileData();
+-
+-        final Cancellable[] reads = new CancellableRead[types.length];
+-        final AtomicInteger completions = new AtomicInteger();
+-        final int expectedCompletions = types.length;
+-
+-        for (int i = 0; i < expectedCompletions; ++i) {
+-            final RegionFileType type = types[i];
+-            reads[i] = RegionFileIOThread.loadDataAsync(world, chunkX, chunkZ, type,
+-                (final CompoundTag data, final Throwable throwable) -> {
+-                    if (throwable != null) {
+-                        ret.setThrowable(type, throwable);
+-                    } else {
+-                        ret.setData(type, data);
+-                    }
+-
+-                    if (completions.incrementAndGet() == expectedCompletions) {
+-                        onComplete.accept(ret);
+-                    }
+-                }, intendingToBlock, priority);
+-        }
+-
+-        return new CancellableReads(reads);
+-    }
+-
+-    /**
+-     * Schedules a load to be executed asynchronously. This task will load the specified regionfile type, and then call
+-     * {@code onComplete}.
+-     * <p>
+-     *     Impl notes:
+-     * </p>
+-     * <li>
+-     *     The {@code onComplete} parameter may be completed during the execution of this function synchronously or it may
+-     *     be completed asynchronously on this file io thread. Interacting with the file IO thread in the completion of
+-     *     data is undefined behaviour, and can cause deadlock.
+-     * </li>
+-     *
+-     * @param world Chunk's world
+-     * @param chunkX Chunk's x coordinate
+-     * @param chunkZ Chunk's z coordinate
+-     * @param onComplete Consumer to execute once this task has completed
+-     * @param intendingToBlock Whether the caller is intending to block on completion. This only affects the cost
+-     *                         of this call.
+-     *
+-     * @return The {@link Cancellable} for this chunk load. Cancelling it will not affect other loads for the same chunk data.
+-     *
+-     * @see #loadChunkData(ServerLevel, int, int, Consumer, boolean, RegionFileType...)
+-     * @see #loadChunkData(ServerLevel, int, int, Consumer, boolean, Priority, RegionFileType...)
+-     * @see #loadAllChunkData(ServerLevel, int, int, Consumer, boolean)
+-     * @see #loadAllChunkData(ServerLevel, int, int, Consumer, boolean, Priority)
+-     */
+-    public static Cancellable loadDataAsync(final ServerLevel world, final int chunkX, final int chunkZ,
+-                                            final RegionFileType type, final BiConsumer<CompoundTag, Throwable> onComplete,
+-                                            final boolean intendingToBlock) {
+-        return RegionFileIOThread.loadDataAsync(world, chunkX, chunkZ, type, onComplete, intendingToBlock, Priority.NORMAL);
+-    }
+-
+-    /**
+-     * Schedules a load to be executed asynchronously. This task will load the specified regionfile type, and then call
+-     * {@code onComplete}.
+-     * <p>
+-     *     Impl notes:
+-     * </p>
+-     * <li>
+-     *     The {@code onComplete} parameter may be completed during the execution of this function synchronously or it may
+-     *     be completed asynchronously on this file io thread. Interacting with the file IO thread in the completion of
+-     *     data is undefined behaviour, and can cause deadlock.
+-     * </li>
+-     *
+-     * @param world Chunk's world
+-     * @param chunkX Chunk's x coordinate
+-     * @param chunkZ Chunk's z coordinate
+-     * @param onComplete Consumer to execute once this task has completed
+-     * @param intendingToBlock Whether the caller is intending to block on completion. This only affects the cost
+-     *                         of this call.
+-     * @param priority Minimum priority to load the data at.
+-     *
+-     * @return The {@link Cancellable} for this chunk load. Cancelling it will not affect other loads for the same chunk data.
+-     *
+-     * @see #loadChunkData(ServerLevel, int, int, Consumer, boolean, RegionFileType...)
+-     * @see #loadChunkData(ServerLevel, int, int, Consumer, boolean, Priority, RegionFileType...)
+-     * @see #loadAllChunkData(ServerLevel, int, int, Consumer, boolean)
+-     * @see #loadAllChunkData(ServerLevel, int, int, Consumer, boolean, Priority)
+-     */
+-    public static Cancellable loadDataAsync(final ServerLevel world, final int chunkX, final int chunkZ,
+-                                            final RegionFileType type, final BiConsumer<CompoundTag, Throwable> onComplete,
+-                                            final boolean intendingToBlock, final Priority priority) {
+-        final RegionFileIOThread thread = RegionFileIOThread.selectThread(world, chunkX, chunkZ, type);
+-        return thread.loadDataAsyncInternal(world, chunkX, chunkZ, type, onComplete, intendingToBlock, priority);
+-    }
+-
+-    Cancellable loadDataAsyncInternal(final ServerLevel world, final int chunkX, final int chunkZ,
+-                                      final RegionFileType type, final BiConsumer<CompoundTag, Throwable> onComplete,
+-                                      final boolean intendingToBlock, final Priority priority) {
+-        final ChunkDataController taskController = getControllerFor(world, type);
+-
+-        final ImmediateCallbackCompletion callbackInfo = new ImmediateCallbackCompletion();
+-
+-        final long key = CoordinateUtils.getChunkKey(chunkX, chunkZ);
+-        final BiLong1Function<ChunkDataTask, ChunkDataTask> compute = (final long keyInMap, final ChunkDataTask running) -> {
+-            if (running == null) {
+-                // not scheduled
+-
+-                // set up task
+-                final ChunkDataTask newTask = new ChunkDataTask(
+-                    world, chunkX, chunkZ, taskController, RegionFileIOThread.this, priority
+-                );
+-                newTask.inProgressRead = new InProgressRead();
+-                newTask.inProgressRead.addToAsyncWaiters(onComplete);
+-
+-                callbackInfo.tasksNeedsScheduling = true;
+-                return newTask;
+-            }
+-
+-            final CompoundTag pendingWrite = running.inProgressWrite;
+-
+-            if (pendingWrite == ChunkDataTask.NOTHING_TO_WRITE) {
+-                // need to add to waiters here, because the regionfile thread will use compute() to lock and check for cancellations
+-                if (!running.inProgressRead.addToAsyncWaiters(onComplete)) {
+-                    callbackInfo.data = running.inProgressRead.value;
+-                    callbackInfo.throwable = running.inProgressRead.throwable;
+-                    callbackInfo.completeNow = true;
+-                }
+-                return running;
+-            }
+-
+-            // at this stage we have to use the in progress write's data to avoid an order issue
+-            callbackInfo.data = pendingWrite;
+-            callbackInfo.throwable = null;
+-            callbackInfo.completeNow = true;
+-            return running;
+-        };
+-
+-        final ChunkDataTask ret = taskController.tasks.compute(key, compute);
+-
+-        // needs to be scheduled
+-        if (callbackInfo.tasksNeedsScheduling) {
+-            ret.prioritisedTask.queue();
+-        } else if (callbackInfo.completeNow) {
+-            try {
+-                onComplete.accept(callbackInfo.data == null ? null : callbackInfo.data.copy(), callbackInfo.throwable);
+-            } catch (final Throwable thr) {
+-                LOGGER.error("Callback " + ConcurrentUtil.genericToString(onComplete) + " synchronously failed to handle chunk data for task " + ret.toString(), thr);
+-            }
+-        } else {
+-            // we're waiting on a task we didn't schedule, so raise its priority to what we want
+-            ret.prioritisedTask.raisePriority(priority);
+-        }
+-
+-        return new CancellableRead(onComplete, ret);
+-    }
+-
+-    /**
+-     * Schedules a load task to be executed asynchronously, and blocks on that task.
+-     *
+-     * @param world Chunk's world
+-     * @param chunkX Chunk's x coordinate
+-     * @param chunkZ Chunk's z coordinate
+-     * @param type Regionfile type
+-     * @param priority Minimum priority to load the data at.
+-     *
+-     * @return The chunk data for the chunk. Note that a {@code null} result means the chunk or regionfile does not exist on disk.
+-     *
+-     * @throws IOException If the load fails for any reason
+-     */
+-    public static CompoundTag loadData(final ServerLevel world, final int chunkX, final int chunkZ, final RegionFileType type,
+-                                       final Priority priority) throws IOException {
+-        final CompletableFuture<CompoundTag> ret = new CompletableFuture<>();
+-
+-        RegionFileIOThread.loadDataAsync(world, chunkX, chunkZ, type, (final CompoundTag compound, final Throwable thr) -> {
+-            if (thr != null) {
+-                ret.completeExceptionally(thr);
+-            } else {
+-                ret.complete(compound);
+-            }
+-        }, true, priority);
+-
+-        try {
+-            return ret.join();
+-        } catch (final CompletionException ex) {
+-            throw new IOException(ex);
+-        }
+-    }
+-
+-    private static final class ImmediateCallbackCompletion {
+-
+-        public CompoundTag data;
+-        public Throwable throwable;
+-        public boolean completeNow;
+-        public boolean tasksNeedsScheduling;
+-
+-    }
+-
+-    private static final class CancellableRead implements Cancellable {
+-
+-        private BiConsumer<CompoundTag, Throwable> callback;
+-        private ChunkDataTask task;
+-
+-        CancellableRead(final BiConsumer<CompoundTag, Throwable> callback, final ChunkDataTask task) {
+-            this.callback = callback;
+-            this.task = task;
+-        }
+-
+-        @Override
+-        public boolean cancel() {
+-            final BiConsumer<CompoundTag, Throwable> callback = this.callback;
+-            final ChunkDataTask task = this.task;
+-
+-            if (callback == null || task == null) {
+-                return false;
+-            }
+-
+-            this.callback = null;
+-            this.task = null;
+-
+-            final InProgressRead read = task.inProgressRead;
+-
+-            // read can be null if no read was scheduled (i.e no regionfile existed or chunk in regionfile didn't)
+-            return read != null && read.cancel(callback);
+-        }
+-    }
+-
+-    private static final class CancellableReads implements Cancellable {
+-
+-        private Cancellable[] reads;
+-
+-        private static final VarHandle READS_HANDLE = ConcurrentUtil.getVarHandle(CancellableReads.class, "reads", Cancellable[].class);
+-
+-        CancellableReads(final Cancellable[] reads) {
+-            this.reads = reads;
+-        }
+-
+-        @Override
+-        public boolean cancel() {
+-            final Cancellable[] reads = (Cancellable[])READS_HANDLE.getAndSet((CancellableReads)this, (Cancellable[])null);
+-
+-            if (reads == null) {
+-                return false;
+-            }
+-
+-            boolean ret = false;
+-
+-            for (final Cancellable read : reads) {
+-                ret |= read.cancel();
+-            }
+-
+-            return ret;
+-        }
+-    }
+-
+-    private static final class InProgressRead {
+-
+-        private static final Logger LOGGER = LoggerFactory.getLogger(InProgressRead.class);
+-
+-        private CompoundTag value;
+-        private Throwable throwable;
+-        private final MultiThreadedQueue<BiConsumer<CompoundTag, Throwable>> callbacks = new MultiThreadedQueue<>();
+-
+-        public boolean hasNoWaiters() {
+-            return this.callbacks.isEmpty();
+-        }
+-
+-        public boolean addToAsyncWaiters(final BiConsumer<CompoundTag, Throwable> callback) {
+-            return this.callbacks.add(callback);
+-        }
+-
+-        public boolean cancel(final BiConsumer<CompoundTag, Throwable> callback) {
+-            return this.callbacks.remove(callback);
+-        }
+-
+-        public void complete(final ChunkDataTask task, final CompoundTag value, final Throwable throwable) {
+-            this.value = value;
+-            this.throwable = throwable;
+-
+-            BiConsumer<CompoundTag, Throwable> consumer;
+-            while ((consumer = this.callbacks.pollOrBlockAdds()) != null) {
+-                try {
+-                    consumer.accept(value == null ? null : value.copy(), throwable);
+-                } catch (final Throwable thr) {
+-                    LOGGER.error("Callback " + ConcurrentUtil.genericToString(consumer) + " failed to handle chunk data for task " + task.toString(), thr);
+-                }
+-            }
+-        }
+-    }
+-
+-    public static abstract class ChunkDataController {
+-
+-        // ConcurrentHashMap synchronizes per chain, so reduce the chance of task's hashes colliding.
+-        private final ConcurrentLong2ReferenceChainedHashTable<ChunkDataTask> tasks = ConcurrentLong2ReferenceChainedHashTable.createWithCapacity(8192, 0.5f);
+-
+-        public final RegionFileType type;
+-
+-        public ChunkDataController(final RegionFileType type) {
+-            this.type = type;
+-        }
+-
+-        public abstract RegionFileStorage getCache();
+-
+-        public abstract void writeData(final int chunkX, final int chunkZ, final CompoundTag compound) throws IOException;
+-
+-        public abstract CompoundTag readData(final int chunkX, final int chunkZ) throws IOException;
+-
+-        public boolean hasTasks() {
+-            return !this.tasks.isEmpty();
+-        }
+-
+-        public boolean doesRegionFileNotExist(final int chunkX, final int chunkZ) {
+-            return ((ChunkSystemRegionFileStorage)(Object)this.getCache()).moonrise$doesRegionFileNotExistNoIO(chunkX, chunkZ);
+-        }
+-
+-        public <T> T computeForRegionFile(final int chunkX, final int chunkZ, final boolean existingOnly, final Function<RegionFile, T> function) {
+-            final RegionFileStorage cache = this.getCache();
+-            final RegionFile regionFile;
+-            synchronized (cache) {
+-                try {
+-                    if (existingOnly) {
+-                        regionFile = ((ChunkSystemRegionFileStorage)(Object)cache).moonrise$getRegionFileIfExists(chunkX, chunkZ);
+-                    } else {
+-                        regionFile = cache.getRegionFile(new ChunkPos(chunkX, chunkZ), existingOnly);
+-                    }
+-                } catch (final IOException ex) {
+-                    throw new RuntimeException(ex);
+-                }
+-
+-                return function.apply(regionFile);
+-            }
+-        }
+-
+-        public <T> T computeForRegionFileIfLoaded(final int chunkX, final int chunkZ, final Function<RegionFile, T> function) {
+-            final RegionFileStorage cache = this.getCache();
+-            final RegionFile regionFile;
+-
+-            synchronized (cache) {
+-                regionFile = ((ChunkSystemRegionFileStorage)(Object)cache).moonrise$getRegionFileIfLoaded(chunkX, chunkZ);
+-
+-                return function.apply(regionFile);
+-            }
+-        }
+-    }
+-
+-    private static final class ChunkDataTask implements Runnable {
+-
+-        private static final CompoundTag NOTHING_TO_WRITE = new CompoundTag();
+-
+-        private static final Logger LOGGER = LoggerFactory.getLogger(ChunkDataTask.class);
+-
+-        private InProgressRead inProgressRead;
+-        private volatile CompoundTag inProgressWrite = NOTHING_TO_WRITE; // only needs to be acquire/release
+-
+-        private boolean failedWrite;
+-
+-        private final ServerLevel world;
+-        private final int chunkX;
+-        private final int chunkZ;
+-        private final ChunkDataController taskController;
+-
+-        private final PrioritisedTask prioritisedTask;
+-
+-        /*
+-         * IO thread will perform reads before writes for a given chunk x and z
+-         *
+-         * How reads/writes are scheduled:
+-         *
+-         * If read is scheduled while scheduling write, take no special action and just schedule write
+-         * If read is scheduled while scheduling read and no write is scheduled, chain the read task
+-         *
+-         *
+-         * If write is scheduled while scheduling read, use the pending write data and ret immediately (so no read is scheduled)
+-         * If write is scheduled while scheduling write (ignore read in progress), overwrite the write in progress data
+-         *
+-         * This allows the reads and writes to act as if they occur synchronously to the thread scheduling them, however
+-         * it fails to properly propagate write failures thanks to writes overwriting each other
+-         */
+-
+-        public ChunkDataTask(final ServerLevel world, final int chunkX, final int chunkZ, final ChunkDataController taskController,
+-                             final PrioritisedExecutor executor, final Priority priority) {
+-            this.world = world;
+-            this.chunkX = chunkX;
+-            this.chunkZ = chunkZ;
+-            this.taskController = taskController;
+-            this.prioritisedTask = executor.createTask(this, priority);
+-        }
+-
+-        @Override
+-        public String toString() {
+-            return "Task for world: '" + WorldUtil.getWorldName(this.world) + "' at (" + this.chunkX + "," + this.chunkZ +
+-                    ") type: " + this.taskController.type.name() + ", hash: " + this.hashCode();
+-        }
+-
+-        @Override
+-        public void run() {
+-            final InProgressRead read = this.inProgressRead;
+-            final long chunkKey = CoordinateUtils.getChunkKey(this.chunkX, this.chunkZ);
+-
+-            if (read != null) {
+-                final boolean[] canRead = new boolean[] { true };
+-
+-                if (read.hasNoWaiters()) {
+-                    // cancelled read? go to task controller to confirm
+-                    final ChunkDataTask inMap = this.taskController.tasks.compute(chunkKey, (final long keyInMap, final ChunkDataTask valueInMap) -> {
+-                        if (valueInMap == null) {
+-                            throw new IllegalStateException("Write completed concurrently, expected this task: " + ChunkDataTask.this.toString() + ", report this!");
+-                        }
+-                        if (valueInMap != ChunkDataTask.this) {
+-                            throw new IllegalStateException("Chunk task mismatch, expected this task: " + ChunkDataTask.this.toString() + ", got: " + valueInMap.toString() + ", report this!");
+-                        }
+-
+-                        if (!read.hasNoWaiters()) {
+-                            return valueInMap;
+-                        } else {
+-                            canRead[0] = false;
+-                        }
+-
+-                        return valueInMap.inProgressWrite == NOTHING_TO_WRITE ? null : valueInMap;
+-                    });
+-
+-                    if (inMap == null) {
+-                        // read is cancelled - and no write pending, so we're done
+-                        return;
+-                    }
+-                    // if there is a write in progress, we don't actually have to worry about waiters gaining new entries -
+-                    // the readers will just use the in progress write, so the value in canRead is good to use without
+-                    // further synchronisation.
+-                }
+-
+-                if (canRead[0]) {
+-                    CompoundTag compound = null;
+-                    Throwable throwable = null;
+-
+-                    try {
+-                        compound = this.taskController.readData(this.chunkX, this.chunkZ);
+-                    } catch (final Throwable thr) {
+-                        throwable = thr;
+-                        LOGGER.error("Failed to read chunk data for task: " + this.toString(), thr);
+-                    }
+-                    read.complete(this, compound, throwable);
+-                }
+-            }
+-
+-            CompoundTag write = this.inProgressWrite;
+-
+-            if (write == NOTHING_TO_WRITE) {
+-                final ChunkDataTask inMap = this.taskController.tasks.compute(chunkKey, (final long keyInMap, final ChunkDataTask valueInMap) -> {
+-                    if (valueInMap == null) {
+-                        throw new IllegalStateException("Write completed concurrently, expected this task: " + ChunkDataTask.this.toString() + ", report this!");
+-                    }
+-                    if (valueInMap != ChunkDataTask.this) {
+-                        throw new IllegalStateException("Chunk task mismatch, expected this task: " + ChunkDataTask.this.toString() + ", got: " + valueInMap.toString() + ", report this!");
+-                    }
+-                    return valueInMap.inProgressWrite == NOTHING_TO_WRITE ? null : valueInMap;
+-                });
+-
+-                if (inMap == null) {
+-                    return; // set the task value to null, indicating we're done
+-                } // else: inProgressWrite changed, so now we have something to write
+-            }
+-
+-            for (;;) {
+-                write = this.inProgressWrite;
+-                final CompoundTag dataWritten = write;
+-
+-                boolean failedWrite = false;
+-
+-                try {
+-                    this.taskController.writeData(this.chunkX, this.chunkZ, write);
+-                } catch (final Throwable thr) {
+-                    if (thr instanceof RegionFileStorage.RegionFileSizeException) {
+-                        final int maxSize = RegionFile.MAX_CHUNK_SIZE / (1024 * 1024);
+-                        LOGGER.error("Chunk at (" + this.chunkX + "," + this.chunkZ + ") in '" + WorldUtil.getWorldName(this.world) + "' exceeds max size of " + maxSize + "MiB, it has been deleted from disk.");
+-                    } else {
+-                        failedWrite = thr instanceof IOException;
+-                        LOGGER.error("Failed to write chunk data for task: " + this.toString(), thr);
+-                    }
+-                }
+-
+-                final boolean finalFailWrite = failedWrite;
+-                final boolean[] done = new boolean[] { false };
+-
+-                this.taskController.tasks.compute(chunkKey, (final long keyInMap, final ChunkDataTask valueInMap) -> {
+-                    if (valueInMap == null) {
+-                        throw new IllegalStateException("Write completed concurrently, expected this task: " + ChunkDataTask.this.toString() + ", report this!");
+-                    }
+-                    if (valueInMap != ChunkDataTask.this) {
+-                        throw new IllegalStateException("Chunk task mismatch, expected this task: " + ChunkDataTask.this.toString() + ", got: " + valueInMap.toString() + ", report this!");
+-                    }
+-                    if (valueInMap.inProgressWrite == dataWritten) {
+-                        valueInMap.failedWrite = finalFailWrite;
+-                        done[0] = true;
+-                        // keep the data in map if we failed the write so we can try to prevent data loss
+-                        return finalFailWrite ? valueInMap : null;
+-                    }
+-                    // different data than expected, means we need to retry write
+-                    return valueInMap;
+-                });
+-
+-                if (done[0]) {
+-                    return;
+-                }
+-
+-                // fetch & write new data
+-                continue;
+-            }
+-        }
+-    }
+-}
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/io/datacontroller/ChunkDataController.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/io/datacontroller/ChunkDataController.java
+index c35e0c29700be48dda3e53e7d2db224766ef17b7..a36ab89f5c37f5f9ab0152f087bb4cf3560f8581 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/io/datacontroller/ChunkDataController.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/io/datacontroller/ChunkDataController.java
+@@ -1,22 +1,24 @@
+ package ca.spottedleaf.moonrise.patches.chunk_system.io.datacontroller;
+ 
+-import ca.spottedleaf.moonrise.patches.chunk_system.io.RegionFileIOThread;
++import ca.spottedleaf.moonrise.patches.chunk_system.io.ChunkSystemRegionFileStorage;
++import ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO;
++import ca.spottedleaf.moonrise.patches.chunk_system.level.ChunkSystemChunkMap;
++import ca.spottedleaf.moonrise.patches.chunk_system.scheduling.ChunkTaskScheduler;
+ import ca.spottedleaf.moonrise.patches.chunk_system.storage.ChunkSystemChunkStorage;
+ import net.minecraft.nbt.CompoundTag;
+ import net.minecraft.server.level.ServerLevel;
+ import net.minecraft.world.level.ChunkPos;
+ import net.minecraft.world.level.chunk.storage.RegionFileStorage;
+ import java.io.IOException;
+-import java.util.Optional;
+ import java.util.concurrent.CompletableFuture;
+ import java.util.concurrent.CompletionException;
+ 
+-public final class ChunkDataController extends RegionFileIOThread.ChunkDataController {
++public final class ChunkDataController extends MoonriseRegionFileIO.RegionDataController {
+ 
+     private final ServerLevel world;
+ 
+-    public ChunkDataController(final ServerLevel world) {
+-        super(RegionFileIOThread.RegionFileType.CHUNK_DATA);
++    public ChunkDataController(final ServerLevel world, final ChunkTaskScheduler taskScheduler) {
++        super(MoonriseRegionFileIO.RegionFileType.CHUNK_DATA, taskScheduler.ioExecutor, taskScheduler.compressionExecutor);
+         this.world = world;
+     }
+ 
+@@ -26,31 +28,23 @@ public final class ChunkDataController extends RegionFileIOThread.ChunkDataContr
+     }
+ 
+     @Override
+-    public void writeData(final int chunkX, final int chunkZ, final CompoundTag compound) throws IOException {
+-        final CompletableFuture<Void> future = this.world.getChunkSource().chunkMap.write(new ChunkPos(chunkX, chunkZ), compound);
+-
+-        try {
+-            if (future != null) {
+-                // rets non-null when sync writing (i.e. future should be completed here)
+-                future.join();
+-            }
+-        } catch (final CompletionException ex) {
+-            if (ex.getCause() instanceof IOException ioException) {
+-                throw ioException;
+-            }
+-            throw ex;
+-        }
++    public WriteData startWrite(final int chunkX, final int chunkZ, final CompoundTag compound) throws IOException {
++        return ((ChunkSystemRegionFileStorage)this.getCache()).moonrise$startWrite(chunkX, chunkZ, compound);
+     }
+ 
+     @Override
+-    public CompoundTag readData(final int chunkX, final int chunkZ) throws IOException {
+-        try {
+-            return this.world.getChunkSource().chunkMap.read(new ChunkPos(chunkX, chunkZ)).join().orElse(null);
+-        } catch (final CompletionException ex) {
+-            if (ex.getCause() instanceof IOException ioException) {
+-                throw ioException;
+-            }
+-            throw ex;
+-        }
++    public void finishWrite(final int chunkX, final int chunkZ, final WriteData writeData) throws IOException {
++        ((ChunkSystemChunkMap)this.world.getChunkSource().chunkMap).moonrise$writeFinishCallback(new ChunkPos(chunkX, chunkZ));
++        ((ChunkSystemRegionFileStorage)this.getCache()).moonrise$finishWrite(chunkX, chunkZ, writeData);
++    }
++
++    @Override
++    public ReadData readData(final int chunkX, final int chunkZ) throws IOException {
++        return ((ChunkSystemRegionFileStorage)this.getCache()).moonrise$readData(chunkX, chunkZ);
++    }
++
++    @Override
++    public CompoundTag finishRead(final int chunkX, final int chunkZ, final ReadData readData) throws IOException {
++        return ((ChunkSystemRegionFileStorage)this.getCache()).moonrise$finishRead(chunkX, chunkZ, readData);
+     }
+ }
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/io/datacontroller/EntityDataController.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/io/datacontroller/EntityDataController.java
+index fdd189ef056187941d43809c5d61cab717aecf60..828c868f68c2a20bf90d0f7ec253fdeb591f15f6 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/io/datacontroller/EntityDataController.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/io/datacontroller/EntityDataController.java
+@@ -1,6 +1,8 @@
+ package ca.spottedleaf.moonrise.patches.chunk_system.io.datacontroller;
+ 
+-import ca.spottedleaf.moonrise.patches.chunk_system.io.RegionFileIOThread;
++import ca.spottedleaf.moonrise.patches.chunk_system.io.ChunkSystemRegionFileStorage;
++import ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO;
++import ca.spottedleaf.moonrise.patches.chunk_system.scheduling.ChunkTaskScheduler;
+ import net.minecraft.nbt.CompoundTag;
+ import net.minecraft.world.level.ChunkPos;
+ import net.minecraft.world.level.chunk.storage.EntityStorage;
+@@ -9,12 +11,12 @@ import net.minecraft.world.level.chunk.storage.RegionStorageInfo;
+ import java.io.IOException;
+ import java.nio.file.Path;
+ 
+-public final class EntityDataController extends RegionFileIOThread.ChunkDataController {
++public final class EntityDataController extends MoonriseRegionFileIO.RegionDataController {
+ 
+     private final EntityRegionFileStorage storage;
+ 
+-    public EntityDataController(final EntityRegionFileStorage storage) {
+-        super(RegionFileIOThread.RegionFileType.ENTITY_DATA);
++    public EntityDataController(final EntityRegionFileStorage storage, final ChunkTaskScheduler taskScheduler) {
++        super(MoonriseRegionFileIO.RegionFileType.ENTITY_DATA, taskScheduler.ioExecutor, taskScheduler.compressionExecutor);
+         this.storage = storage;
+     }
+ 
+@@ -24,13 +26,35 @@ public final class EntityDataController extends RegionFileIOThread.ChunkDataCont
+     }
+ 
+     @Override
+-    public void writeData(final int chunkX, final int chunkZ, final CompoundTag compound) throws IOException {
+-        this.storage.write(new ChunkPos(chunkX, chunkZ), compound);
++    public WriteData startWrite(final int chunkX, final int chunkZ, final CompoundTag compound) throws IOException {
++        checkPosition(new ChunkPos(chunkX, chunkZ), compound);
++
++        return ((ChunkSystemRegionFileStorage)this.getCache()).moonrise$startWrite(chunkX, chunkZ, compound);
++    }
++
++    @Override
++    public void finishWrite(final int chunkX, final int chunkZ, final WriteData writeData) throws IOException {
++        ((ChunkSystemRegionFileStorage)this.getCache()).moonrise$finishWrite(chunkX, chunkZ, writeData);
++    }
++
++    @Override
++    public ReadData readData(final int chunkX, final int chunkZ) throws IOException {
++        return ((ChunkSystemRegionFileStorage)this.getCache()).moonrise$readData(chunkX, chunkZ);
+     }
+ 
+     @Override
+-    public CompoundTag readData(final int chunkX, final int chunkZ) throws IOException {
+-        return this.storage.read(new ChunkPos(chunkX, chunkZ));
++    public CompoundTag finishRead(final int chunkX, final int chunkZ, final ReadData readData) throws IOException {
++        return ((ChunkSystemRegionFileStorage)this.getCache()).moonrise$finishRead(chunkX, chunkZ, readData);
++    }
++
++    private static void checkPosition(final ChunkPos pos, final CompoundTag nbt) {
++        final ChunkPos nbtPos = nbt == null ? null : EntityStorage.readChunkPos(nbt);
++        if (nbtPos != null && !pos.equals(nbtPos)) {
++            throw new IllegalArgumentException(
++                    "Entity chunk coordinate and serialized data do not have matching coordinates, trying to serialize coordinate " + pos.toString()
++                            + " but compound says coordinate is " + nbtPos
++            );
++        }
+     }
+ 
+     public static final class EntityRegionFileStorage extends RegionFileStorage {
+@@ -42,13 +66,7 @@ public final class EntityDataController extends RegionFileIOThread.ChunkDataCont
+ 
+         @Override
+         public void write(final ChunkPos pos, final CompoundTag nbt) throws IOException {
+-            final ChunkPos nbtPos = nbt == null ? null : EntityStorage.readChunkPos(nbt);
+-            if (nbtPos != null && !pos.equals(nbtPos)) {
+-                throw new IllegalArgumentException(
+-                        "Entity chunk coordinate and serialized data do not have matching coordinates, trying to serialize coordinate " + pos.toString()
+-                                + " but compound says coordinate is " + nbtPos + " for world: " + this
+-                );
+-            }
++            checkPosition(pos, nbt);
+             super.write(pos, nbt);
+         }
+     }
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/io/datacontroller/PoiDataController.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/io/datacontroller/PoiDataController.java
+index af867f8fedd0bb8f675e94243aa1a3f17363483b..bd0d782852f9cfe5bc0b5339ecf4d82c10332ec9 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/io/datacontroller/PoiDataController.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/io/datacontroller/PoiDataController.java
+@@ -1,18 +1,20 @@
+ package ca.spottedleaf.moonrise.patches.chunk_system.io.datacontroller;
+ 
+-import ca.spottedleaf.moonrise.patches.chunk_system.io.RegionFileIOThread;
++import ca.spottedleaf.moonrise.patches.chunk_system.io.ChunkSystemRegionFileStorage;
++import ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO;
+ import ca.spottedleaf.moonrise.patches.chunk_system.level.storage.ChunkSystemSectionStorage;
++import ca.spottedleaf.moonrise.patches.chunk_system.scheduling.ChunkTaskScheduler;
+ import net.minecraft.nbt.CompoundTag;
+ import net.minecraft.server.level.ServerLevel;
+ import net.minecraft.world.level.chunk.storage.RegionFileStorage;
+ import java.io.IOException;
+ 
+-public final class PoiDataController extends RegionFileIOThread.ChunkDataController {
++public final class PoiDataController extends MoonriseRegionFileIO.RegionDataController {
+ 
+     private final ServerLevel world;
+ 
+-    public PoiDataController(final ServerLevel world) {
+-        super(RegionFileIOThread.RegionFileType.POI_DATA);
++    public PoiDataController(final ServerLevel world, final ChunkTaskScheduler taskScheduler) {
++        super(MoonriseRegionFileIO.RegionFileType.POI_DATA, taskScheduler.ioExecutor, taskScheduler.compressionExecutor);
+         this.world = world;
+     }
+ 
+@@ -22,12 +24,22 @@ public final class PoiDataController extends RegionFileIOThread.ChunkDataControl
+     }
+ 
+     @Override
+-    public void writeData(final int chunkX, final int chunkZ, final CompoundTag compound) throws IOException {
+-        ((ChunkSystemSectionStorage)this.world.getPoiManager()).moonrise$write(chunkX, chunkZ, compound);
++    public WriteData startWrite(final int chunkX, final int chunkZ, final CompoundTag compound) throws IOException {
++        return ((ChunkSystemRegionFileStorage)this.getCache()).moonrise$startWrite(chunkX, chunkZ, compound);
+     }
+ 
+     @Override
+-    public CompoundTag readData(final int chunkX, final int chunkZ) throws IOException {
+-        return ((ChunkSystemSectionStorage)this.world.getPoiManager()).moonrise$read(chunkX, chunkZ);
++    public void finishWrite(final int chunkX, final int chunkZ, final WriteData writeData) throws IOException {
++        ((ChunkSystemRegionFileStorage)this.getCache()).moonrise$finishWrite(chunkX, chunkZ, writeData);
++    }
++
++    @Override
++    public ReadData readData(final int chunkX, final int chunkZ) throws IOException {
++        return ((ChunkSystemRegionFileStorage)this.getCache()).moonrise$readData(chunkX, chunkZ);
++    }
++
++    @Override
++    public CompoundTag finishRead(final int chunkX, final int chunkZ, final ReadData readData) throws IOException {
++        return ((ChunkSystemRegionFileStorage)this.getCache()).moonrise$finishRead(chunkX, chunkZ, readData);
+     }
+ }
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/ChunkSystemChunkMap.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/ChunkSystemChunkMap.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..47a4d3376d08dde94a39254bec21473ff27f53e6
+--- /dev/null
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/ChunkSystemChunkMap.java
+@@ -0,0 +1,10 @@
++package ca.spottedleaf.moonrise.patches.chunk_system.level;
++
++import net.minecraft.world.level.ChunkPos;
++import java.io.IOException;
++
++public interface ChunkSystemChunkMap {
++
++    public void moonrise$writeFinishCallback(final ChunkPos pos) throws IOException;
++
++}
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/ChunkSystemLevel.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/ChunkSystemLevel.java
+index efcd9057f008f0b9cf0d22b2b21d1851205841e5..5d4d650186b18eb00782429d53d861564d8e4ba9 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/ChunkSystemLevel.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/ChunkSystemLevel.java
+@@ -1,5 +1,6 @@
+ package ca.spottedleaf.moonrise.patches.chunk_system.level;
+ 
++import ca.spottedleaf.moonrise.patches.chunk_system.level.chunk.ChunkData;
+ import ca.spottedleaf.moonrise.patches.chunk_system.level.entity.EntityLookup;
+ import net.minecraft.world.level.chunk.ChunkAccess;
+ import net.minecraft.world.level.chunk.LevelChunk;
+@@ -19,4 +20,14 @@ public interface ChunkSystemLevel {
+ 
+     public void moonrise$midTickTasks();
+ 
++    public ChunkData moonrise$getChunkData(final long chunkKey);
++
++    public ChunkData moonrise$getChunkData(final int chunkX, final int chunkZ);
++
++    public ChunkData moonrise$requestChunkData(final long chunkKey);
++
++    public ChunkData moonrise$releaseChunkData(final long chunkKey);
++
++    public boolean moonrise$areChunksLoaded(final int fromX, final int fromZ, final int toX, final int toZ);
++
+ }
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/ChunkSystemServerLevel.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/ChunkSystemServerLevel.java
+index b8a87b7e6505feb76ce1bd58c84615256cf6faa6..9d46482476f9ed9032a2b0f89afc20e03ed42dbb 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/ChunkSystemServerLevel.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/ChunkSystemServerLevel.java
+@@ -1,12 +1,13 @@
+ package ca.spottedleaf.moonrise.patches.chunk_system.level;
+ 
+-import ca.spottedleaf.concurrentutil.executor.standard.PrioritisedExecutor;
++import ca.spottedleaf.concurrentutil.util.Priority;
+ import ca.spottedleaf.moonrise.common.list.ReferenceList;
+ import ca.spottedleaf.moonrise.common.misc.NearbyPlayers;
+-import ca.spottedleaf.moonrise.patches.chunk_system.io.RegionFileIOThread;
++import ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO;
+ import ca.spottedleaf.moonrise.patches.chunk_system.player.RegionizedPlayerChunkLoader;
+ import ca.spottedleaf.moonrise.patches.chunk_system.scheduling.ChunkTaskScheduler;
+ import net.minecraft.core.BlockPos;
++import net.minecraft.server.level.ChunkHolder;
+ import net.minecraft.server.level.ServerChunkCache;
+ import net.minecraft.world.level.chunk.ChunkAccess;
+ import net.minecraft.world.level.chunk.status.ChunkStatus;
+@@ -17,32 +18,34 @@ public interface ChunkSystemServerLevel extends ChunkSystemLevel {
+ 
+     public ChunkTaskScheduler moonrise$getChunkTaskScheduler();
+ 
+-    public RegionFileIOThread.ChunkDataController moonrise$getChunkDataController();
++    public MoonriseRegionFileIO.RegionDataController moonrise$getChunkDataController();
+ 
+-    public RegionFileIOThread.ChunkDataController moonrise$getPoiChunkDataController();
++    public MoonriseRegionFileIO.RegionDataController moonrise$getPoiChunkDataController();
+ 
+-    public RegionFileIOThread.ChunkDataController moonrise$getEntityChunkDataController();
++    public MoonriseRegionFileIO.RegionDataController moonrise$getEntityChunkDataController();
+ 
+     public int moonrise$getRegionChunkShift();
+ 
+-    // Paper - marked closing not needed on CB
++    public boolean moonrise$isMarkedClosing();
++
++    public void moonrise$setMarkedClosing(final boolean value);
+ 
+     public RegionizedPlayerChunkLoader moonrise$getPlayerChunkLoader();
+ 
+     public void moonrise$loadChunksAsync(final BlockPos pos, final int radiusBlocks,
+-                                         final PrioritisedExecutor.Priority priority,
++                                         final Priority priority,
+                                          final Consumer<List<ChunkAccess>> onLoad);
+ 
+     public void moonrise$loadChunksAsync(final BlockPos pos, final int radiusBlocks,
+-                                         final ChunkStatus chunkStatus, final PrioritisedExecutor.Priority priority,
++                                         final ChunkStatus chunkStatus, final Priority priority,
+                                          final Consumer<List<ChunkAccess>> onLoad);
+ 
+     public void moonrise$loadChunksAsync(final int minChunkX, final int maxChunkX, final int minChunkZ, final int maxChunkZ,
+-                                         final PrioritisedExecutor.Priority priority,
++                                         final Priority priority,
+                                          final Consumer<List<ChunkAccess>> onLoad);
+ 
+     public void moonrise$loadChunksAsync(final int minChunkX, final int maxChunkX, final int minChunkZ, final int maxChunkZ,
+-                                         final ChunkStatus chunkStatus, final PrioritisedExecutor.Priority priority,
++                                         final ChunkStatus chunkStatus, final Priority priority,
+                                          final Consumer<List<ChunkAccess>> onLoad);
+ 
+     public RegionizedPlayerChunkLoader.ViewDistanceHolder moonrise$getViewDistanceHolder();
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/chunk/ChunkData.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/chunk/ChunkData.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..8b9dc582627b46843f4b5ea6f8c3df2d8cac46fa
+--- /dev/null
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/chunk/ChunkData.java
+@@ -0,0 +1,21 @@
++package ca.spottedleaf.moonrise.patches.chunk_system.level.chunk;
++
++import ca.spottedleaf.moonrise.common.misc.NearbyPlayers;
++
++public final class ChunkData {
++
++    private int referenceCount = 0;
++    public NearbyPlayers.TrackedChunk nearbyPlayers; // Moonrise - nearby players
++
++    public ChunkData() {
++
++    }
++
++    public int increaseRef() {
++        return ++this.referenceCount;
++    }
++
++    public int decreaseRef() {
++        return --this.referenceCount;
++    }
++}
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/chunk/ChunkSystemDistanceManager.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/chunk/ChunkSystemDistanceManager.java
+index 883fe6401f1b9711fa544d18a815b4d638f580df..aacd543f03b35908011d0c2891e978cc093ebcf5 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/chunk/ChunkSystemDistanceManager.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/chunk/ChunkSystemDistanceManager.java
+@@ -1,9 +1,12 @@
+ package ca.spottedleaf.moonrise.patches.chunk_system.level.chunk;
+ 
++import ca.spottedleaf.moonrise.patches.chunk_system.scheduling.ChunkHolderManager;
+ import net.minecraft.server.level.ChunkMap;
+ 
+ public interface ChunkSystemDistanceManager {
+ 
+     public ChunkMap moonrise$getChunkMap();
+ 
++    public ChunkHolderManager moonrise$getChunkHolderManager();
++
+ }
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/entity/ChunkEntitySlices.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/entity/ChunkEntitySlices.java
+index 5c7f2471a0b15ac2e714527296ad2aa7291999eb..40dc7569c32b100d4eebbde9024ded2acbb2fb20 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/entity/ChunkEntitySlices.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/entity/ChunkEntitySlices.java
+@@ -1,6 +1,8 @@
+ package ca.spottedleaf.moonrise.patches.chunk_system.level.entity;
+ 
++import ca.spottedleaf.moonrise.common.PlatformHooks;
+ import ca.spottedleaf.moonrise.common.list.EntityList;
++import ca.spottedleaf.moonrise.patches.chunk_system.level.chunk.ChunkData;
+ import ca.spottedleaf.moonrise.patches.chunk_system.entity.ChunkSystemEntity;
+ import com.google.common.collect.ImmutableList;
+ import it.unimi.dsi.fastutil.objects.Reference2ObjectMap;
+@@ -13,6 +15,7 @@ import net.minecraft.server.level.FullChunkStatus;
+ import net.minecraft.server.level.ServerLevel;
+ import net.minecraft.util.Mth;
+ import net.minecraft.world.entity.Entity;
++import net.minecraft.world.entity.EntitySpawnReason;
+ import net.minecraft.world.entity.EntityType;
+ import net.minecraft.world.entity.boss.EnderDragonPart;
+ import net.minecraft.world.entity.boss.enderdragon.EnderDragon;
+@@ -26,7 +29,6 @@ import java.util.Arrays;
+ import java.util.Iterator;
+ import java.util.List;
+ import java.util.function.Predicate;
+-import org.bukkit.event.entity.EntityRemoveEvent;
+ 
+ public final class ChunkEntitySlices {
+ 
+@@ -43,6 +45,7 @@ public final class ChunkEntitySlices {
+     private final EntityList entities = new EntityList();
+ 
+     public FullChunkStatus status;
++    public final ChunkData chunkData;
+ 
+     private boolean isTransient;
+ 
+@@ -55,7 +58,7 @@ public final class ChunkEntitySlices {
+     }
+ 
+     public ChunkEntitySlices(final Level world, final int chunkX, final int chunkZ, final FullChunkStatus status,
+-                             final int minSection, final int maxSection) { // inclusive, inclusive
++                             final ChunkData chunkData, final int minSection, final int maxSection) { // inclusive, inclusive
+         this.minSection = minSection;
+         this.maxSection = maxSection;
+         this.chunkX = chunkX;
+@@ -68,11 +71,12 @@ public final class ChunkEntitySlices {
+         this.entitiesByType = new Reference2ObjectOpenHashMap<>();
+ 
+         this.status = status;
++        this.chunkData = chunkData;
+     }
+ 
+     public static List<Entity> readEntities(final ServerLevel world, final CompoundTag compoundTag) {
+         // TODO check this and below on update for format changes
+-        return EntityType.loadEntitiesRecursive(compoundTag.getList("Entities", 10), world).collect(ImmutableList.toImmutableList());
++        return EntityType.loadEntitiesRecursive(compoundTag.getList("Entities", 10), world, EntitySpawnReason.LOAD).collect(ImmutableList.toImmutableList());
+     }
+ 
+     // Paper start - rewrite chunk system
+@@ -100,18 +104,7 @@ public final class ChunkEntitySlices {
+         }
+ 
+         final ListTag entitiesTag = new ListTag();
+-        final java.util.Map<net.minecraft.world.entity.EntityType<?>, Integer> savedEntityCounts = new java.util.HashMap<>(); // Paper - Entity load/save limit per chunk
+-        for (final Entity entity : entities) {
+-            // Paper start - Entity load/save limit per chunk
+-            final EntityType<?> entityType = entity.getType();
+-            final int saveLimit = world.paperConfig().chunks.entityPerChunkSaveLimit.getOrDefault(entityType, -1);
+-            if (saveLimit > -1) {
+-                if (savedEntityCounts.getOrDefault(entityType, 0) >= saveLimit) {
+-                    continue;
+-                }
+-                savedEntityCounts.merge(entityType, 1, Integer::sum);
+-            }
+-            // Paper end - Entity load/save limit per chunk
++        for (final Entity entity : PlatformHooks.get().modifySavedEntities(world, chunkPos.x, chunkPos.z, entities)) {
+             CompoundTag compoundTag = new CompoundTag();
+             if (entity.save(compoundTag)) {
+                 entitiesTag.add(compoundTag);
+@@ -158,12 +151,12 @@ public final class ChunkEntitySlices {
+                 continue;
+             }
+             if (entity.shouldBeSaved()) {
+-                entity.setRemoved(Entity.RemovalReason.UNLOADED_TO_CHUNK, EntityRemoveEvent.Cause.UNLOAD);
++                PlatformHooks.get().unloadEntity(entity);
+                 if (entity.isVehicle()) {
+                     // we cannot assume that these entities are contained within this chunk, because entities can
+                     // desync - so we need to remove them all
+                     for (final Entity passenger : entity.getIndirectPassengers()) {
+-                        passenger.setRemoved(Entity.RemovalReason.UNLOADED_TO_CHUNK, EntityRemoveEvent.Cause.UNLOAD);
++                        PlatformHooks.get().unloadEntity(passenger);
+                     }
+                 }
+             }
+@@ -172,33 +165,6 @@ public final class ChunkEntitySlices {
+         return this.entities.size() != 0;
+     }
+ 
+-    // Paper start
+-    public org.bukkit.entity.Entity[] getChunkEntities() {
+-        List<org.bukkit.entity.Entity> ret = new java.util.ArrayList<>();
+-        final Entity[] entities = this.entities.getRawData();
+-        for (int i = 0, size = Math.min(entities.length, this.entities.size()); i < size; ++i) {
+-            final Entity entity = entities[i];
+-            if (entity == null) {
+-                continue;
+-            }
+-            final org.bukkit.entity.Entity bukkit = entity.getBukkitEntity();
+-            if (bukkit != null && bukkit.isValid()) {
+-                ret.add(bukkit);
+-            }
+-        }
+-
+-        return ret.toArray(new org.bukkit.entity.Entity[0]);
+-    }
+-
+-    public void callEntitiesLoadEvent() {
+-        org.bukkit.craftbukkit.event.CraftEventFactory.callEntitiesLoadEvent(this.world, new ChunkPos(this.chunkX, this.chunkZ), this.getAllEntities());
+-    }
+-
+-    public void callEntitiesUnloadEvent() {
+-        org.bukkit.craftbukkit.event.CraftEventFactory.callEntitiesUnloadEvent(this.world, new ChunkPos(this.chunkX, this.chunkZ), this.getAllEntities());
+-    }
+-    // Paper end
+-
+     private List<Entity> getAllEntities() {
+         final int len = this.entities.size();
+         if (len == 0) {
+@@ -262,6 +228,7 @@ public final class ChunkEntitySlices {
+             return false;
+         }
+         ((ChunkSystemEntity)entity).moonrise$setChunkStatus(this.status);
++        ((ChunkSystemEntity)entity).moonrise$setChunkData(this.chunkData);
+         final int sectionIndex = chunkSection - this.minSection;
+ 
+         this.allEntities.addEntity(entity, sectionIndex);
+@@ -295,6 +262,7 @@ public final class ChunkEntitySlices {
+             return false;
+         }
+         ((ChunkSystemEntity)entity).moonrise$setChunkStatus(null);
++        ((ChunkSystemEntity)entity).moonrise$setChunkData(null);
+         final int sectionIndex = chunkSection - this.minSection;
+ 
+         this.allEntities.removeEntity(entity, sectionIndex);
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/entity/EntityLookup.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/entity/EntityLookup.java
+index efc0c1acc8239dd7b00211a1d3bfd3fc3b2c810c..93335de8cf514dc8417e4b9b2d495663deda2904 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/entity/EntityLookup.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/entity/EntityLookup.java
+@@ -46,8 +46,6 @@ public abstract class EntityLookup implements LevelEntityGetter<Entity> {
+ 
+     protected final SWMRLong2ObjectHashTable<ChunkSlicesRegion> regions = new SWMRLong2ObjectHashTable<>(128, 0.5f);
+ 
+-    protected final int minSection; // inclusive
+-    protected final int maxSection; // inclusive
+     protected final LevelCallback<Entity> worldCallback;
+ 
+     protected final ConcurrentLong2ReferenceChainedHashTable<Entity> entityById = new ConcurrentLong2ReferenceChainedHashTable<>();
+@@ -56,8 +54,6 @@ public abstract class EntityLookup implements LevelEntityGetter<Entity> {
+ 
+     public EntityLookup(final Level world, final LevelCallback<Entity> worldCallback) {
+         this.world = world;
+-        this.minSection = WorldUtil.getMinSection(world);
+-        this.maxSection = WorldUtil.getMaxSection(world);
+         this.worldCallback = worldCallback;
+     }
+ 
+@@ -91,7 +87,7 @@ public abstract class EntityLookup implements LevelEntityGetter<Entity> {
+ 
+     protected abstract void entityEndTicking(final Entity entity);
+ 
+-    protected abstract boolean screenEntity(final Entity entity);
++    protected abstract boolean screenEntity(final Entity entity, final boolean fromDisk, final boolean event);
+ 
+     private static Entity maskNonAccessible(final Entity entity) {
+         if (entity == null) {
+@@ -347,7 +343,7 @@ public abstract class EntityLookup implements LevelEntityGetter<Entity> {
+     }
+ 
+     protected void addRecursivelySafe(final Entity root, final boolean fromDisk) {
+-        if (!this.addEntity(root, fromDisk)) {
++        if (!this.addEntity(root, fromDisk, true)) {
+             // possible we are a passenger, and so should dismount from any valid entity in the world
+             root.stopRiding();
+             return;
+@@ -386,7 +382,11 @@ public abstract class EntityLookup implements LevelEntityGetter<Entity> {
+     }
+ 
+     public boolean addNewEntity(final Entity entity) {
+-        return this.addEntity(entity, false);
++        return this.addNewEntity(entity, true);
++    }
++
++    public boolean addNewEntity(final Entity entity, final boolean event) {
++        return this.addEntity(entity, false, event);
+     }
+ 
+     public static Visibility getEntityStatus(final Entity entity) {
+@@ -397,10 +397,10 @@ public abstract class EntityLookup implements LevelEntityGetter<Entity> {
+         return Visibility.fromFullChunkStatus(entityStatus == null ? FullChunkStatus.INACCESSIBLE : entityStatus);
+     }
+ 
+-    protected boolean addEntity(final Entity entity, final boolean fromDisk) {
++    protected boolean addEntity(final Entity entity, final boolean fromDisk, final boolean event) {
+         final BlockPos pos = entity.blockPosition();
+         final int sectionX = pos.getX() >> 4;
+-        final int sectionY = Mth.clamp(pos.getY() >> 4, this.minSection, this.maxSection);
++        final int sectionY = Mth.clamp(pos.getY() >> 4, WorldUtil.getMinSection(this.world), WorldUtil.getMaxSection(this.world));
+         final int sectionZ = pos.getZ() >> 4;
+         this.checkThread(sectionX, sectionZ, "Cannot add entity off-main thread");
+ 
+@@ -414,7 +414,7 @@ public abstract class EntityLookup implements LevelEntityGetter<Entity> {
+             return false;
+         }
+ 
+-        if (!this.screenEntity(entity)) {
++        if (!this.screenEntity(entity, fromDisk, event)) {
+             return false;
+         }
+ 
+@@ -519,7 +519,7 @@ public abstract class EntityLookup implements LevelEntityGetter<Entity> {
+         final int sectionZ = ((ChunkSystemEntity)entity).moonrise$getSectionZ();
+         final BlockPos newPos = entity.blockPosition();
+         final int newSectionX = newPos.getX() >> 4;
+-        final int newSectionY = Mth.clamp(newPos.getY() >> 4, this.minSection, this.maxSection);
++        final int newSectionY = Mth.clamp(newPos.getY() >> 4, WorldUtil.getMinSection(this.world), WorldUtil.getMaxSection(this.world));
+         final int newSectionZ = newPos.getZ() >> 4;
+ 
+         if (newSectionX == sectionX && newSectionY == sectionY && newSectionZ == sectionZ) {
+@@ -959,7 +959,7 @@ public abstract class EntityLookup implements LevelEntityGetter<Entity> {
+ 
+     public ChunkEntitySlices getOrCreateChunk(final int chunkX, final int chunkZ) {
+         final ChunkSlicesRegion region = this.getRegion(chunkX >> REGION_SHIFT, chunkZ >> REGION_SHIFT);
+-        ChunkEntitySlices ret;
++        final ChunkEntitySlices ret;
+         if (region == null || (ret = region.get((chunkX & REGION_MASK) | ((chunkZ & REGION_MASK) << REGION_SHIFT))) == null) {
+             return this.createEntityChunk(chunkX, chunkZ, true);
+         }
+@@ -1057,7 +1057,7 @@ public abstract class EntityLookup implements LevelEntityGetter<Entity> {
+         @Override
+         public void onRemove(final Entity.RemovalReason reason) {
+             final Entity entity = this.entity;
+-            EntityLookup.this.checkThread(entity, "Cannot remove entity off-main"); // Paper - rewrite chunk system
++            EntityLookup.this.checkThread(entity, "Cannot remove entity off-main");
+             final Visibility tickingState = EntityLookup.getEntityStatus(entity);
+ 
+             EntityLookup.this.removeEntity(entity);
+@@ -1080,4 +1080,4 @@ public abstract class EntityLookup implements LevelEntityGetter<Entity> {
+         @Override
+         public void onRemove(final Entity.RemovalReason reason) {}
+     }
+-}
+\ No newline at end of file
++}
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/entity/client/ClientEntityLookup.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/entity/client/ClientEntityLookup.java
+index edcde00206d068bd79175fea33efa05b0e8c1562..a038215156a163b0b1cbc870ada5b4ac85ed1335 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/entity/client/ClientEntityLookup.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/entity/client/ClientEntityLookup.java
+@@ -1,5 +1,6 @@
+ package ca.spottedleaf.moonrise.patches.chunk_system.level.entity.client;
+ 
++import ca.spottedleaf.moonrise.common.PlatformHooks;
+ import ca.spottedleaf.moonrise.common.util.CoordinateUtils;
+ import ca.spottedleaf.moonrise.common.util.WorldUtil;
+ import ca.spottedleaf.moonrise.patches.chunk_system.level.entity.ChunkEntitySlices;
+@@ -45,7 +46,8 @@ public final class ClientEntityLookup extends EntityLookup {
+ 
+         final ChunkEntitySlices ret = new ChunkEntitySlices(
+                 this.world, chunkX, chunkZ,
+-                ticking ? FullChunkStatus.ENTITY_TICKING : FullChunkStatus.FULL, WorldUtil.getMinSection(this.world), WorldUtil.getMaxSection(this.world)
++                ticking ? FullChunkStatus.ENTITY_TICKING : FullChunkStatus.FULL, null,
++            WorldUtil.getMinSection(this.world), WorldUtil.getMaxSection(this.world)
+         );
+ 
+         // note: not handled by superclass
+@@ -63,7 +65,11 @@ public final class ClientEntityLookup extends EntityLookup {
+     protected void entitySectionChangeCallback(final Entity entity,
+                                                final int oldSectionX, final int oldSectionY, final int oldSectionZ,
+                                                final int newSectionX, final int newSectionY, final int newSectionZ) {
+-
++        PlatformHooks.get().entityMove(
++            entity,
++            CoordinateUtils.getChunkSectionKey(oldSectionX, oldSectionY, oldSectionZ),
++            CoordinateUtils.getChunkSectionKey(newSectionX, newSectionY, newSectionZ)
++        );
+     }
+ 
+     @Override
+@@ -97,7 +103,7 @@ public final class ClientEntityLookup extends EntityLookup {
+     }
+ 
+     @Override
+-    protected boolean screenEntity(final Entity entity) {
++    protected boolean screenEntity(final Entity entity, final boolean fromDisk, final boolean event) {
+         return true;
+     }
+ 
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/entity/dfl/DefaultEntityLookup.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/entity/dfl/DefaultEntityLookup.java
+index 465469e44346c50f30f3abd6b44f4173ccfcf248..2ff58cf753c60913ee73aae015182e9c5560d529 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/entity/dfl/DefaultEntityLookup.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/entity/dfl/DefaultEntityLookup.java
+@@ -32,7 +32,7 @@ public final class DefaultEntityLookup extends EntityLookup {
+     protected ChunkEntitySlices createEntityChunk(final int chunkX, final int chunkZ, final boolean transientChunk) {
+         final ChunkEntitySlices ret = new ChunkEntitySlices(
+                 this.world, chunkX, chunkZ, FullChunkStatus.FULL,
+-                WorldUtil.getMinSection(this.world), WorldUtil.getMaxSection(this.world)
++                null, WorldUtil.getMinSection(this.world), WorldUtil.getMaxSection(this.world)
+         );
+ 
+         // note: not handled by superclass
+@@ -84,7 +84,7 @@ public final class DefaultEntityLookup extends EntityLookup {
+     }
+ 
+     @Override
+-    protected boolean screenEntity(final Entity entity) {
++    protected boolean screenEntity(final Entity entity, final boolean fromDisk, final boolean event) {
+         return true;
+     }
+ 
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/entity/server/ServerEntityLookup.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/entity/server/ServerEntityLookup.java
+index dacf2b2988ce603879fe525a3418ac77f8a663f7..58d9187adc188b693b6becc400f766e069bf1bf5 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/entity/server/ServerEntityLookup.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/entity/server/ServerEntityLookup.java
+@@ -1,6 +1,8 @@
+ package ca.spottedleaf.moonrise.patches.chunk_system.level.entity.server;
+ 
++import ca.spottedleaf.moonrise.common.PlatformHooks;
+ import ca.spottedleaf.moonrise.common.list.ReferenceList;
++import ca.spottedleaf.moonrise.common.util.CoordinateUtils;
+ import ca.spottedleaf.moonrise.common.util.TickThread;
+ import ca.spottedleaf.moonrise.common.util.ChunkSystem;
+ import ca.spottedleaf.moonrise.patches.chunk_system.level.ChunkSystemServerLevel;
+@@ -17,7 +19,6 @@ public final class ServerEntityLookup extends EntityLookup {
+ 
+     private final ServerLevel serverWorld;
+     public final ReferenceList<Entity> trackerEntities = new ReferenceList<>(EMPTY_ENTITY_ARRAY); // Moonrise - entity tracker
+-    public final ReferenceList<Entity> trackerUnloadedEntities = new ReferenceList<>(EMPTY_ENTITY_ARRAY); // Moonrise - entity tracker
+ 
+     public ServerEntityLookup(final ServerLevel world, final LevelCallback<Entity> worldCallback) {
+         super(world, worldCallback);
+@@ -63,6 +64,11 @@ public final class ServerEntityLookup extends EntityLookup {
+         if (entity instanceof ServerPlayer player) {
+             ((ChunkSystemServerLevel)this.serverWorld).moonrise$getNearbyPlayers().tickPlayer(player);
+         }
++        PlatformHooks.get().entityMove(
++            entity,
++            CoordinateUtils.getChunkSectionKey(oldSectionX, oldSectionY, oldSectionZ),
++            CoordinateUtils.getChunkSectionKey(newSectionX, newSectionY, newSectionZ)
++        );
+     }
+ 
+     @Override
+@@ -77,14 +83,12 @@ public final class ServerEntityLookup extends EntityLookup {
+         if (entity instanceof ServerPlayer player) {
+             ((ChunkSystemServerLevel)this.serverWorld).moonrise$getNearbyPlayers().removePlayer(player);
+         }
+-        this.trackerUnloadedEntities.remove(entity); // Moonrise - entity tracker
+     }
+ 
+     @Override
+     protected void entityStartLoaded(final Entity entity) {
+         // Moonrise start - entity tracker
+         this.trackerEntities.add(entity);
+-        this.trackerUnloadedEntities.remove(entity);
+         // Moonrise end - entity tracker
+     }
+ 
+@@ -92,7 +96,6 @@ public final class ServerEntityLookup extends EntityLookup {
+     protected void entityEndLoaded(final Entity entity) {
+         // Moonrise start - entity tracker
+         this.trackerEntities.remove(entity);
+-        this.trackerUnloadedEntities.add(entity);
+         // Moonrise end - entity tracker
+     }
+ 
+@@ -107,7 +110,7 @@ public final class ServerEntityLookup extends EntityLookup {
+     }
+ 
+     @Override
+-    protected boolean screenEntity(final Entity entity) {
+-        return ChunkSystem.screenEntity(this.serverWorld, entity);
++    protected boolean screenEntity(final Entity entity, final boolean fromDisk, final boolean event) {
++        return ChunkSystem.screenEntity(this.serverWorld, entity, fromDisk, event);
+     }
+ }
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/poi/PoiChunk.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/poi/PoiChunk.java
+index fd35e4db0c8fec8f86b8743bcc2b15ed2e7433f1..bbf9d6c1c9525d97160806819a57be03eca290f1 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/poi/PoiChunk.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/poi/PoiChunk.java
+@@ -3,7 +3,6 @@ package ca.spottedleaf.moonrise.patches.chunk_system.level.poi;
+ import ca.spottedleaf.moonrise.common.util.CoordinateUtils;
+ import ca.spottedleaf.moonrise.common.util.TickThread;
+ import ca.spottedleaf.moonrise.common.util.WorldUtil;
+-import com.mojang.serialization.Codec;
+ import com.mojang.serialization.DataResult;
+ import net.minecraft.SharedConstants;
+ import net.minecraft.nbt.CompoundTag;
+@@ -123,7 +122,6 @@ public final class PoiChunk {
+         ret.putInt("DataVersion", SharedConstants.getCurrentVersion().getDataVersion().getVersion());
+ 
+         final ServerLevel world = this.world;
+-        final PoiManager poiManager = world.getPoiManager();
+         final int chunkX = this.chunkX;
+         final int chunkZ = this.chunkZ;
+ 
+@@ -133,13 +131,8 @@ public final class PoiChunk {
+                 continue;
+             }
+ 
+-            final long key = CoordinateUtils.getChunkSectionKey(chunkX, sectionY, chunkZ);
+-            // codecs are honestly such a fucking disaster. What the fuck is this trash?
+-            final Codec<PoiSection> codec = PoiSection.codec(() -> {
+-                poiManager.setDirty(key);
+-            });
+-
+-            final DataResult<Tag> serializedResult = codec.encodeStart(registryOps, section);
++            // I do not believe asynchronously converting to CompoundTag is worth the scheduling.
++            final DataResult<Tag> serializedResult = PoiSection.Packed.CODEC.encodeStart(registryOps, section.pack());
+             final int finalSectionY = sectionY;
+             final Tag serialized = serializedResult.resultOrPartial((final String description) -> {
+                 LOGGER.error("Failed to serialize poi chunk for world: " + WorldUtil.getWorldName(world) + ", chunk: (" + chunkX + "," + finalSectionY + "," + chunkZ + "); description: " + description);
+@@ -183,19 +176,18 @@ public final class PoiChunk {
+                 continue;
+             }
+ 
+-            final long coordinateKey = CoordinateUtils.getChunkSectionKey(chunkX, sectionY, chunkZ);
+-            // codecs are honestly such a fucking disaster. What the fuck is this trash?
+-            final Codec<PoiSection> codec = PoiSection.codec(() -> {
+-                poiManager.setDirty(coordinateKey);
+-            });
+-
+             final CompoundTag section = sections.getCompound(key);
+-            final DataResult<PoiSection> deserializeResult = codec.parse(registryOps, section);
++            final DataResult<PoiSection.Packed> deserializeResult = PoiSection.Packed.CODEC.parse(registryOps, section);
+             final int finalSectionY = sectionY;
+-            final PoiSection deserialized = deserializeResult.resultOrPartial((final String description) -> {
++            final PoiSection.Packed packed = deserializeResult.resultOrPartial((final String description) -> {
+                 LOGGER.error("Failed to deserialize poi chunk for world: " + WorldUtil.getWorldName(world) + ", chunk: (" + chunkX + "," + finalSectionY + "," + chunkZ + "); description: " + description);
+             }).orElse(null);
+ 
++            final long coordinateKey = CoordinateUtils.getChunkSectionKey(chunkX, sectionY, chunkZ);
++            final PoiSection deserialized = packed == null ? null : packed.unpack(() -> {
++                poiManager.setDirty(coordinateKey);
++            });
++
+             if (deserialized == null || ((ChunkSystemPoiSection)deserialized).moonrise$isEmpty()) {
+                 // completely empty, no point in storing this
+                 continue;
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/storage/ChunkSystemSectionStorage.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/storage/ChunkSystemSectionStorage.java
+index 3f5edb756beb9c31b6f591a24b778d6ac2b0bf51..23bd741dc0bfd48b8064a2b498d71cfa8f8145b2 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/storage/ChunkSystemSectionStorage.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/level/storage/ChunkSystemSectionStorage.java
+@@ -1,12 +1,8 @@
+ package ca.spottedleaf.moonrise.patches.chunk_system.level.storage;
+ 
+-import com.mojang.serialization.Dynamic;
+ import net.minecraft.nbt.CompoundTag;
+-import net.minecraft.nbt.Tag;
+ import net.minecraft.world.level.chunk.storage.RegionFileStorage;
+ import java.io.IOException;
+-import java.util.Optional;
+-import java.util.concurrent.CompletableFuture;
+ 
+ public interface ChunkSystemSectionStorage {
+ 
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/player/RegionizedPlayerChunkLoader.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/player/RegionizedPlayerChunkLoader.java
+index a608f57ebca98eda88ad749d0aad021678be54f9..b2fa9883aefb07f64bb5db7e0052218d2ad09aba 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/player/RegionizedPlayerChunkLoader.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/player/RegionizedPlayerChunkLoader.java
+@@ -1,7 +1,8 @@
+ package ca.spottedleaf.moonrise.patches.chunk_system.player;
+ 
+-import ca.spottedleaf.concurrentutil.executor.standard.PrioritisedExecutor;
+ import ca.spottedleaf.concurrentutil.util.ConcurrentUtil;
++import ca.spottedleaf.concurrentutil.util.Priority;
++import ca.spottedleaf.moonrise.common.PlatformHooks;
+ import ca.spottedleaf.moonrise.common.misc.AllocatingRateLimiter;
+ import ca.spottedleaf.moonrise.common.misc.SingleUserAreaMap;
+ import ca.spottedleaf.moonrise.common.util.CoordinateUtils;
+@@ -412,7 +413,11 @@ public final class RegionizedPlayerChunkLoader {
+             if (this.sentChunks.add(CoordinateUtils.getChunkKey(chunkX, chunkZ))) {
+                 ((ChunkSystemChunkHolder)((ChunkSystemServerLevel)this.world).moonrise$getChunkTaskScheduler().chunkHolderManager
+                         .getChunkHolder(chunkX, chunkZ).vanillaChunkHolder).moonrise$addReceivedChunk(this.player);
+-                PlayerChunkSender.sendChunk(this.player.connection, this.world, ((ChunkSystemLevel)this.world).moonrise$getFullChunkIfLoaded(chunkX, chunkZ));
++
++                final LevelChunk chunk = ((ChunkSystemLevel)this.world).moonrise$getFullChunkIfLoaded(chunkX, chunkZ);
++
++                PlatformHooks.get().onChunkWatch(this.world, chunk, this.player);
++                PlayerChunkSender.sendChunk(this.player.connection, this.world, chunk);
+                 return;
+             }
+             throw new IllegalStateException();
+@@ -426,17 +431,12 @@ public final class RegionizedPlayerChunkLoader {
+         }
+ 
+         private void sendUnloadChunkRaw(final int chunkX, final int chunkZ) {
++            PlatformHooks.get().onChunkUnWatch(this.world, new ChunkPos(chunkX, chunkZ), this.player);
+             // Note: Check PlayerChunkSender#dropChunk for other logic
+             // Note: drop isAlive() check so that chunks properly unload client-side when the player dies
+             ((ChunkSystemChunkHolder)((ChunkSystemServerLevel)this.world).moonrise$getChunkTaskScheduler().chunkHolderManager
+                 .getChunkHolder(chunkX, chunkZ).vanillaChunkHolder).moonrise$removeReceivedChunk(this.player);
+-            final ChunkPos chunkPos = new ChunkPos(chunkX, chunkZ);
+-            this.player.connection.send(new ClientboundForgetLevelChunkPacket(chunkPos));
+-            // Paper start - PlayerChunkUnloadEvent
+-            if (io.papermc.paper.event.packet.PlayerChunkUnloadEvent.getHandlerList().getRegisteredListeners().length > 0) {
+-                new io.papermc.paper.event.packet.PlayerChunkUnloadEvent(this.world.getWorld().getChunkAt(chunkPos.longKey), this.player.getBukkitEntity()).callEvent();
+-            }
+-            // Paper end - PlayerChunkUnloadEvent
++            this.player.connection.send(new ClientboundForgetLevelChunkPacket(new ChunkPos(chunkX, chunkZ)));
+         }
+ 
+         private final SingleUserAreaMap<PlayerChunkLoaderData> broadcastMap = new SingleUserAreaMap<>(this) {
+@@ -529,7 +529,7 @@ public final class RegionizedPlayerChunkLoader {
+                                                final int playerSendViewDistance, final int worldSendViewDistance) {
+             return Math.min(
+                 loadViewDistance - 1,
+-                playerSendViewDistance < 0 ? (!io.papermc.paper.configuration.GlobalConfiguration.get().chunkLoadingAdvanced.autoConfigSendDistance || clientViewDistance < 0 ? (worldSendViewDistance < 0 ? (loadViewDistance - 1) : worldSendViewDistance) : clientViewDistance + 1) : playerSendViewDistance
++                playerSendViewDistance < 0 ? (!PlatformHooks.get().configAutoConfigSendDistance() || clientViewDistance < 0 ? (worldSendViewDistance < 0 ? (loadViewDistance - 1) : worldSendViewDistance) : clientViewDistance + 1) : playerSendViewDistance
+             );
+         }
+ 
+@@ -554,26 +554,26 @@ public final class RegionizedPlayerChunkLoader {
+         }
+ 
+         private double getMaxChunkLoadRate() {
+-            final double configRate = io.papermc.paper.configuration.GlobalConfiguration.get().chunkLoadingBasic.playerMaxChunkLoadRate;
++            final double configRate = PlatformHooks.get().configPlayerMaxLoadRate();
+ 
+             return configRate <= 0.0 || configRate > (double)MAX_RATE ? (double)MAX_RATE : Math.max(1.0, configRate);
+         }
+ 
+         private double getMaxChunkGenRate() {
+-            final double configRate = io.papermc.paper.configuration.GlobalConfiguration.get().chunkLoadingBasic.playerMaxChunkGenerateRate;
++            final double configRate = PlatformHooks.get().configPlayerMaxGenRate();
+ 
+             return configRate <= 0.0 || configRate > (double)MAX_RATE ? (double)MAX_RATE : Math.max(1.0, configRate);
+         }
+ 
+         private double getMaxChunkSendRate() {
+-            final double configRate = io.papermc.paper.configuration.GlobalConfiguration.get().chunkLoadingBasic.playerMaxChunkSendRate;
++            final double configRate = PlatformHooks.get().configPlayerMaxSendRate();
+ 
+             return configRate <= 0.0 || configRate > (double)MAX_RATE ? (double)MAX_RATE : Math.max(1.0, configRate);
+         }
+ 
+         private long getMaxChunkLoads() {
+             final long radiusChunks = (2L * this.lastLoadDistance + 1L) * (2L * this.lastLoadDistance + 1L);
+-            long configLimit = io.papermc.paper.configuration.GlobalConfiguration.get().chunkLoadingAdvanced.playerMaxConcurrentChunkLoads;
++            long configLimit = (long)PlatformHooks.get().configPlayerMaxConcurrentLoads();
+             if (configLimit == 0L) {
+                 // by default, only allow 1/5th of the chunks in the view distance to be concurrently active
+                 configLimit = Math.max(5L, radiusChunks / 5L);
+@@ -587,7 +587,7 @@ public final class RegionizedPlayerChunkLoader {
+ 
+         private long getMaxChunkGenerates() {
+             final long radiusChunks = (2L * this.lastLoadDistance + 1L) * (2L * this.lastLoadDistance + 1L);
+-            long configLimit = io.papermc.paper.configuration.GlobalConfiguration.get().chunkLoadingAdvanced.playerMaxConcurrentChunkGenerates;
++            long configLimit = (long)PlatformHooks.get().configPlayerMaxConcurrentGens();
+             if (configLimit == 0L) {
+                 // by default, only allow 1/5th of the chunks in the view distance to be concurrently active
+                 configLimit = Math.max(5L, radiusChunks / 5L);
+@@ -709,7 +709,7 @@ public final class RegionizedPlayerChunkLoader {
+                     final int queuedChunkX = CoordinateUtils.getChunkX(queuedLoadChunk);
+                     final int queuedChunkZ = CoordinateUtils.getChunkZ(queuedLoadChunk);
+                     ((ChunkSystemServerLevel)this.world).moonrise$getChunkTaskScheduler().scheduleChunkLoad(
+-                        queuedChunkX, queuedChunkZ, ChunkStatus.EMPTY, false, PrioritisedExecutor.Priority.NORMAL, null
++                        queuedChunkX, queuedChunkZ, ChunkStatus.EMPTY, false, Priority.NORMAL, null
+                     );
+                     if (this.removed) {
+                         return;
+@@ -825,7 +825,7 @@ public final class RegionizedPlayerChunkLoader {
+                 }
+                 if (!((ChunkSystemLevelChunk)chunk).moonrise$isPostProcessingDone()) {
+                     // not yet post-processed, need to do this so that tile entities can properly be sent to clients
+-                    chunk.postProcessGeneration();
++                    chunk.postProcessGeneration(this.world);
+                     // check if there was any recursive action
+                     if (this.removed || this.sendQueue.isEmpty() || this.sendQueue.firstLong() != pendingSend) {
+                         return;
+@@ -864,7 +864,6 @@ public final class RegionizedPlayerChunkLoader {
+             final int clientViewDistance = getClientViewDistance(this.player);
+             final int sendViewDistance = getSendViewDistance(loadViewDistance, clientViewDistance, playerDistances.sendViewDistance, worldDistances.sendViewDistance);
+ 
+-            // TODO check PlayerList diff in paper chunk system patch
+             // send view distances
+             this.player.connection.send(this.updateClientChunkRadius(sendViewDistance));
+             this.player.connection.send(this.updateClientSimulationDistance(tickViewDistance));
+@@ -1079,8 +1078,7 @@ public final class RegionizedPlayerChunkLoader {
+             // now all tickets should be removed, which is all of our external state
+         }
+ 
+-        // For external checks
+-        public it.unimi.dsi.fastutil.longs.LongOpenHashSet getSentChunksRaw() {
++        public LongOpenHashSet getSentChunksRaw() {
+             return this.sentChunks;
+         }
+     }
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/ChunkHolderManager.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/ChunkHolderManager.java
+index 58d3d1a47e9f2423c467bb329c2d5f4b58a8b5ef..f98df65eaed2abedc66f3a49790e0cfb65354ed9 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/ChunkHolderManager.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/ChunkHolderManager.java
+@@ -1,14 +1,14 @@
+ package ca.spottedleaf.moonrise.patches.chunk_system.scheduling;
+ 
+-import ca.spottedleaf.concurrentutil.executor.standard.PrioritisedExecutor;
+ import ca.spottedleaf.concurrentutil.lock.ReentrantAreaLock;
+ import ca.spottedleaf.concurrentutil.map.ConcurrentLong2ReferenceChainedHashTable;
++import ca.spottedleaf.concurrentutil.util.Priority;
++import ca.spottedleaf.moonrise.common.PlatformHooks;
+ import ca.spottedleaf.moonrise.common.util.CoordinateUtils;
+-import ca.spottedleaf.moonrise.common.util.MoonriseCommon;
+ import ca.spottedleaf.moonrise.common.util.TickThread;
+ import ca.spottedleaf.moonrise.common.util.WorldUtil;
+ import ca.spottedleaf.moonrise.common.util.ChunkSystem;
+-import ca.spottedleaf.moonrise.patches.chunk_system.io.RegionFileIOThread;
++import ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO;
+ import ca.spottedleaf.moonrise.patches.chunk_system.level.ChunkSystemServerLevel;
+ import ca.spottedleaf.moonrise.patches.chunk_system.level.entity.ChunkEntitySlices;
+ import ca.spottedleaf.moonrise.patches.chunk_system.level.poi.PoiChunk;
+@@ -20,7 +20,6 @@ import ca.spottedleaf.moonrise.patches.chunk_system.ticket.ChunkSystemTicket;
+ import ca.spottedleaf.moonrise.patches.chunk_system.util.ChunkSystemSortedArraySet;
+ import com.google.gson.JsonArray;
+ import com.google.gson.JsonObject;
+-import com.mojang.logging.LogUtils;
+ import it.unimi.dsi.fastutil.longs.Long2ByteLinkedOpenHashMap;
+ import it.unimi.dsi.fastutil.longs.Long2ByteMap;
+ import it.unimi.dsi.fastutil.longs.Long2IntMap;
+@@ -40,7 +39,9 @@ import net.minecraft.server.level.TicketType;
+ import net.minecraft.util.SortedArraySet;
+ import net.minecraft.util.Unit;
+ import net.minecraft.world.level.ChunkPos;
++import net.minecraft.world.level.chunk.LevelChunk;
+ import org.slf4j.Logger;
++import org.slf4j.LoggerFactory;
+ import java.io.IOException;
+ import java.text.DecimalFormat;
+ import java.util.ArrayDeque;
+@@ -58,7 +59,7 @@ import java.util.function.Predicate;
+ 
+ public final class ChunkHolderManager {
+ 
+-    private static final Logger LOGGER = LogUtils.getClassLogger();
++    private static final Logger LOGGER = LoggerFactory.getLogger(ChunkHolderManager.class);
+ 
+     public static final int FULL_LOADED_TICKET_LEVEL    = ChunkLevel.FULL_CHUNK_LEVEL;
+     public static final int BLOCK_TICKING_TICKET_LEVEL  = ChunkLevel.BLOCK_TICKING_LEVEL;
+@@ -189,7 +190,7 @@ public final class ChunkHolderManager {
+         if (halt) {
+             LOGGER.info("Waiting 60s for chunk system to halt for world '" + WorldUtil.getWorldName(this.world) + "'");
+             if (!this.taskScheduler.halt(true, TimeUnit.SECONDS.toNanos(60L))) {
+-                LOGGER.warn("Failed to halt world generation/loading tasks for world '" + WorldUtil.getWorldName(this.world) + "'");
++                LOGGER.warn("Failed to halt generation/loading tasks for world '" + WorldUtil.getWorldName(this.world) + "'");
+             } else {
+                 LOGGER.info("Halted chunk system for world '" + WorldUtil.getWorldName(this.world) + "'");
+             }
+@@ -199,21 +200,21 @@ public final class ChunkHolderManager {
+             this.saveAllChunks(true, true, true);
+         }
+ 
+-        boolean hasTasks = false;
+-        for (final RegionFileIOThread.RegionFileType type : RegionFileIOThread.RegionFileType.values()) {
+-            if (RegionFileIOThread.getControllerFor(this.world, type).hasTasks()) {
+-                hasTasks = true;
+-                break;
++        MoonriseRegionFileIO.flush(this.world);
++
++        if (halt) {
++            LOGGER.info("Waiting 60s for chunk I/O to halt for world '" + WorldUtil.getWorldName(this.world) + "'");
++            if (!this.taskScheduler.haltIO(true, TimeUnit.SECONDS.toNanos(60L))) {
++                LOGGER.warn("Failed to halt I/O tasks for world '" + WorldUtil.getWorldName(this.world) + "'");
++            } else {
++                LOGGER.info("Halted I/O scheduler for world '" + WorldUtil.getWorldName(this.world) + "'");
+             }
+         }
+-        if (hasTasks) {
+-            RegionFileIOThread.flush();
+-        }
+ 
+         // kill regionfile cache
+-        for (final RegionFileIOThread.RegionFileType type : RegionFileIOThread.RegionFileType.values()) {
++        for (final MoonriseRegionFileIO.RegionFileType type : MoonriseRegionFileIO.RegionFileType.values()) {
+             try {
+-                RegionFileIOThread.getControllerFor(this.world, type).getCache().close();
++                MoonriseRegionFileIO.getControllerFor(this.world, type).getCache().close();
+             } catch (final IOException ex) {
+                 LOGGER.error("Failed to close '" + type.name() + "' regionfile cache for world '" + WorldUtil.getWorldName(this.world) + "'", ex);
+             }
+@@ -230,8 +231,8 @@ public final class ChunkHolderManager {
+     public void autoSave() {
+         final List<NewChunkHolder> reschedule = new ArrayList<>();
+         final long currentTick = this.currentTick;
+-        final long maxSaveTime = currentTick - Math.max(1L, this.world.paperConfig().chunks.autoSaveInterval.value());
+-        final int maxToSave = this.world.paperConfig().chunks.maxAutoSaveChunksPerTick;
++        final long maxSaveTime = currentTick - Math.max(1L, PlatformHooks.get().configAutoSaveInterval());
++        final int maxToSave = PlatformHooks.get().configMaxAutoSavePerTick();
+         for (int autoSaved = 0; autoSaved < maxToSave && !this.autoSaveQueue.isEmpty();) {
+             final NewChunkHolder holder = this.autoSaveQueue.first();
+ 
+@@ -271,55 +272,74 @@ public final class ChunkHolderManager {
+ 
+         long start = System.nanoTime();
+         long lastLog = start;
+-        boolean needsFlush = false;
+-        final int flushInterval = 50;
++        final int flushInterval = 200;
++        int lastFlush = 0;
+ 
+         int savedChunk = 0;
+         int savedEntity = 0;
+         int savedPoi = 0;
+ 
++        if (shutdown) {
++            // Normal unload process does not occur during shutdown: fire event manually
++            // for mods that expect ChunkEvent.Unload to fire on shutdown (before LevelEvent.Unload)
++            for (int i = 0, len = holders.size(); i < len; ++i) {
++                final NewChunkHolder holder = holders.get(i);
++                if (holder.getCurrentChunk() instanceof LevelChunk levelChunk) {
++                    PlatformHooks.get().chunkUnloadFromWorld(levelChunk);
++                }
++            }
++        }
+         for (int i = 0, len = holders.size(); i < len; ++i) {
+             final NewChunkHolder holder = holders.get(i);
+             try {
+                 final NewChunkHolder.SaveStat saveStat = holder.save(shutdown);
+                 if (saveStat != null) {
+-                    ++saved;
+-                    needsFlush = flush;
+                     if (saveStat.savedChunk()) {
+                         ++savedChunk;
++                        ++saved;
+                     }
+                     if (saveStat.savedEntityChunk()) {
+                         ++savedEntity;
++                        ++saved;
+                     }
+                     if (saveStat.savedPoiChunk()) {
+                         ++savedPoi;
++                        ++saved;
+                     }
+                 }
+             } catch (final Throwable thr) {
+                 LOGGER.error("Failed to save chunk (" + holder.chunkX + "," + holder.chunkZ + ") in world '" + WorldUtil.getWorldName(this.world) + "'", thr);
+             }
+-            if (needsFlush && (saved % flushInterval) == 0) {
+-                needsFlush = false;
+-                RegionFileIOThread.partialFlush(flushInterval / 2);
++            if (flush && (saved - lastFlush) > (flushInterval / 2)) {
++                lastFlush = saved;
++                MoonriseRegionFileIO.partialFlush(this.world, flushInterval / 2);
+             }
+             if (logProgress) {
+                 final long currTime = System.nanoTime();
+                 if ((currTime - lastLog) > TimeUnit.SECONDS.toNanos(10L)) {
+                     lastLog = currTime;
+-                    LOGGER.info("Saved " + saved + " chunks (" + format.format((double)(i+1)/(double)len * 100.0) + "%) in world '" + WorldUtil.getWorldName(this.world) + "'");
++                    LOGGER.info(
++                            "Saved " + savedChunk + " block chunks, " + savedEntity + " entity chunks, " + savedPoi
++                                    + " poi chunks in world '" + WorldUtil.getWorldName(this.world) + "', progress: "
++                                    + format.format((double)(i+1)/(double)len * 100.0)
++                    );
+                 }
+             }
+         }
+         if (flush) {
+-            RegionFileIOThread.flush();
++            MoonriseRegionFileIO.flush(this.world);
+             try {
+-                RegionFileIOThread.flushRegionStorages(this.world);
++                MoonriseRegionFileIO.flushRegionStorages(this.world);
+             } catch (final IOException ex) {
+                 LOGGER.error("Exception when flushing regions in world '" + WorldUtil.getWorldName(this.world) + "'", ex);
+             }
+         }
+         if (logProgress) {
+-            LOGGER.info("Saved " + savedChunk + " block chunks, " + savedEntity + " entity chunks, " + savedPoi + " poi chunks in world '" + WorldUtil.getWorldName(this.world) + "' in " + format.format(1.0E-9 * (System.nanoTime() - start)) + "s");
++            LOGGER.info(
++                    "Saved " + savedChunk + " block chunks, " + savedEntity + " entity chunks, " + savedPoi
++                            + " poi chunks in world '" + WorldUtil.getWorldName(this.world) + "' in "
++                            + format.format(1.0E-9 * (System.nanoTime() - start)) + "s"
++            );
+         }
+     }
+ 
+@@ -798,21 +818,21 @@ public final class ChunkHolderManager {
+         return this.chunkHolders.get(position);
+     }
+ 
+-    public void raisePriority(final int x, final int z, final PrioritisedExecutor.Priority priority) {
++    public void raisePriority(final int x, final int z, final Priority priority) {
+         final NewChunkHolder chunkHolder = this.getChunkHolder(x, z);
+         if (chunkHolder != null) {
+             chunkHolder.raisePriority(priority);
+         }
+     }
+ 
+-    public void setPriority(final int x, final int z, final PrioritisedExecutor.Priority priority) {
++    public void setPriority(final int x, final int z, final Priority priority) {
+         final NewChunkHolder chunkHolder = this.getChunkHolder(x, z);
+         if (chunkHolder != null) {
+             chunkHolder.setPriority(priority);
+         }
+     }
+ 
+-    public void lowerPriority(final int x, final int z, final PrioritisedExecutor.Priority priority) {
++    public void lowerPriority(final int x, final int z, final Priority priority) {
+         final NewChunkHolder chunkHolder = this.getChunkHolder(x, z);
+         if (chunkHolder != null) {
+             chunkHolder.lowerPriority(priority);
+@@ -895,7 +915,7 @@ public final class ChunkHolderManager {
+                         final ChunkLoadTask.EntityDataLoadTask entityLoad = current.getEntityDataLoadTask();
+ 
+                         if (entityLoad != null) {
+-                            entityLoad.raisePriority(PrioritisedExecutor.Priority.BLOCKING);
++                            entityLoad.raisePriority(Priority.BLOCKING);
+                         }
+                     }
+                 }
+@@ -971,7 +991,7 @@ public final class ChunkHolderManager {
+                     final ChunkLoadTask.PoiDataLoadTask poiLoad = current.getPoiDataLoadTask();
+ 
+                     if (poiLoad != null) {
+-                        poiLoad.raisePriority(PrioritisedExecutor.Priority.BLOCKING);
++                        poiLoad.raisePriority(Priority.BLOCKING);
+                     }
+                 }
+             } finally {
+@@ -1018,7 +1038,7 @@ public final class ChunkHolderManager {
+                 }
+ 
+                 ChunkHolderManager.this.processPendingFullUpdate();
+-            }, PrioritisedExecutor.Priority.HIGHEST);
++            }, Priority.HIGHEST);
+         } else {
+             final ArrayDeque<NewChunkHolder> pendingFullLoadUpdate = this.pendingFullLoadUpdate;
+             for (int i = 0, len = changedFullStatus.size(); i < len; ++i) {
+@@ -1028,11 +1048,10 @@ public final class ChunkHolderManager {
+     }
+ 
+     private void removeChunkHolder(final NewChunkHolder holder) {
+-        holder.markUnloaded();
++        holder.onUnload();
+         this.autoSaveQueue.remove(holder);
+         ChunkSystem.onChunkHolderDelete(this.world, holder.vanillaChunkHolder);
+         this.chunkHolders.remove(CoordinateUtils.getChunkKey(holder.chunkX, holder.chunkZ));
+-
+     }
+ 
+     // note: never call while inside the chunk system, this will absolutely break everything
+@@ -1313,6 +1332,9 @@ public final class ChunkHolderManager {
+         if (BLOCK_TICKET_UPDATES.get() == Boolean.TRUE) {
+             throw new IllegalStateException("Cannot update ticket level while unloading chunks or updating entity manager");
+         }
++        if (!PlatformHooks.get().allowAsyncTicketUpdates() && !TickThread.isTickThread()) {
++            TickThread.ensureTickThread("Cannot asynchronously process ticket updates");
++        }
+ 
+         List<NewChunkHolder> changedFullStatus = null;
+ 
+@@ -1328,10 +1350,15 @@ public final class ChunkHolderManager {
+             }
+             changedFullStatus = new ArrayList<>();
+ 
+-            ret |= this.ticketLevelPropagator.performUpdates(
+-                this.ticketLockArea, this.taskScheduler.schedulingLockArea,
+-                scheduledTasks, changedFullStatus
+-            );
++            this.blockTicketUpdates();
++            try {
++                ret |= this.ticketLevelPropagator.performUpdates(
++                    this.ticketLockArea, this.taskScheduler.schedulingLockArea,
++                    scheduledTasks, changedFullStatus
++                );
++            } finally {
++                this.unblockTicketUpdates(Boolean.FALSE);
++            }
+         }
+ 
+         if (changedFullStatus != null) {
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/ChunkTaskScheduler.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/ChunkTaskScheduler.java
+index 8671a90e969d16c7a57ddc38fedb7cf01815f64c..120ce31729dc8d4bba0901ca06d3212f3158d089 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/ChunkTaskScheduler.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/ChunkTaskScheduler.java
+@@ -1,16 +1,17 @@
+ package ca.spottedleaf.moonrise.patches.chunk_system.scheduling;
+ 
+-import ca.spottedleaf.concurrentutil.executor.standard.PrioritisedExecutor;
+-import ca.spottedleaf.concurrentutil.executor.standard.PrioritisedThreadPool;
+-import ca.spottedleaf.concurrentutil.executor.standard.PrioritisedThreadedTaskQueue;
++import ca.spottedleaf.concurrentutil.executor.PrioritisedExecutor;
++import ca.spottedleaf.concurrentutil.executor.queue.PrioritisedTaskQueue;
++import ca.spottedleaf.concurrentutil.executor.thread.PrioritisedThreadPool;
+ import ca.spottedleaf.concurrentutil.lock.ReentrantAreaLock;
+ import ca.spottedleaf.concurrentutil.util.ConcurrentUtil;
++import ca.spottedleaf.concurrentutil.util.Priority;
++import ca.spottedleaf.moonrise.common.config.moonrise.MoonriseConfig;
+ import ca.spottedleaf.moonrise.common.util.CoordinateUtils;
+ import ca.spottedleaf.moonrise.common.util.JsonUtil;
+ import ca.spottedleaf.moonrise.common.util.MoonriseCommon;
+ import ca.spottedleaf.moonrise.common.util.TickThread;
+ import ca.spottedleaf.moonrise.common.util.WorldUtil;
+-import ca.spottedleaf.moonrise.patches.chunk_system.io.RegionFileIOThread;
+ import ca.spottedleaf.moonrise.patches.chunk_system.level.ChunkSystemServerLevel;
+ import ca.spottedleaf.moonrise.patches.chunk_system.level.chunk.ChunkSystemChunkStatus;
+ import ca.spottedleaf.moonrise.patches.chunk_system.player.ChunkSystemServerPlayer;
+@@ -23,7 +24,6 @@ import ca.spottedleaf.moonrise.patches.chunk_system.scheduling.task.ChunkUpgrade
+ import ca.spottedleaf.moonrise.patches.chunk_system.server.ChunkSystemMinecraftServer;
+ import ca.spottedleaf.moonrise.patches.chunk_system.status.ChunkSystemChunkStep;
+ import ca.spottedleaf.moonrise.patches.chunk_system.util.ParallelSearchRadiusIteration;
+-import com.mojang.logging.LogUtils;
+ import com.google.gson.JsonArray;
+ import com.google.gson.JsonObject;
+ import net.minecraft.CrashReport;
+@@ -48,6 +48,7 @@ import net.minecraft.world.level.chunk.status.ChunkStatus;
+ import net.minecraft.world.level.chunk.status.ChunkStep;
+ import net.minecraft.world.phys.Vec3;
+ import org.slf4j.Logger;
++import org.slf4j.LoggerFactory;
+ import java.io.File;
+ import java.time.LocalDateTime;
+ import java.time.format.DateTimeFormatter;
+@@ -63,51 +64,14 @@ import java.util.function.Consumer;
+ 
+ public final class ChunkTaskScheduler {
+ 
+-    private static final Logger LOGGER = LogUtils.getClassLogger();
++    private static final Logger LOGGER = LoggerFactory.getLogger(ChunkTaskScheduler.class);
+ 
+-    static int newChunkSystemIOThreads;
+-    static int newChunkSystemGenParallelism;
+-    static int newChunkSystemGenPopulationParallelism;
+-    static int newChunkSystemLoadParallelism;
+-
+-    private static boolean initialised = false;
+-
+-    public static void init(io.papermc.paper.configuration.GlobalConfiguration.ChunkSystem chunkSystem) {
+-        if (initialised) {
+-            return;
+-        }
+-        initialised = true;
+-        MoonriseCommon.init(chunkSystem); // Paper
+-        newChunkSystemIOThreads = chunkSystem.ioThreads;
+-        if (newChunkSystemIOThreads <= 0) {
+-            newChunkSystemIOThreads = 1;
+-        } else {
+-            newChunkSystemIOThreads = Math.max(1, newChunkSystemIOThreads);
+-        }
+-
+-        String newChunkSystemGenParallelism = chunkSystem.genParallelism;
+-        if (newChunkSystemGenParallelism.equalsIgnoreCase("default")) {
+-            newChunkSystemGenParallelism = "true";
+-        }
+-
+-        boolean useParallelGen;
+-        if (newChunkSystemGenParallelism.equalsIgnoreCase("on") || newChunkSystemGenParallelism.equalsIgnoreCase("enabled")
+-            || newChunkSystemGenParallelism.equalsIgnoreCase("true")) {
+-            useParallelGen = true;
+-        } else if (newChunkSystemGenParallelism.equalsIgnoreCase("off") || newChunkSystemGenParallelism.equalsIgnoreCase("disabled")
+-            || newChunkSystemGenParallelism.equalsIgnoreCase("false")) {
+-            useParallelGen = false;
+-        } else {
+-            throw new IllegalStateException("Invalid option for gen-parallelism: must be one of [on, off, enabled, disabled, true, false, default]");
++    public static void init(final boolean useParallelGen) {
++        for (final PrioritisedThreadPool.ExecutorGroup.ThreadPoolExecutor executor : MoonriseCommon.RADIUS_AWARE_GROUP.getAllExecutors()) {
++            executor.setMaxParallelism(useParallelGen ? -1 : 1);
+         }
+ 
+-        ChunkTaskScheduler.newChunkSystemGenParallelism = MoonriseCommon.WORKER_THREADS;
+-        ChunkTaskScheduler.newChunkSystemGenPopulationParallelism = useParallelGen ? MoonriseCommon.WORKER_THREADS : 1;
+-        ChunkTaskScheduler.newChunkSystemLoadParallelism = MoonriseCommon.WORKER_THREADS;
+-
+-        RegionFileIOThread.init(newChunkSystemIOThreads);
+-
+-        LOGGER.info("Chunk system is using " + newChunkSystemIOThreads + " I/O threads, " + MoonriseCommon.WORKER_THREADS + " worker threads, and population gen parallelism of " + ChunkTaskScheduler.newChunkSystemGenPopulationParallelism + " threads");
++        LOGGER.info("Chunk system is using population gen parallelism: " + useParallelGen);
+     }
+ 
+     public static final TicketType<Long> CHUNK_LOAD = TicketType.create("chunk_system:chunk_load", Long::compareTo);
+@@ -151,13 +115,15 @@ public final class ChunkTaskScheduler {
+     }
+ 
+     public final ServerLevel world;
+-    public final PrioritisedThreadPool workers;
+     public final RadiusAwarePrioritisedExecutor radiusAwareScheduler;
+-    public final PrioritisedThreadPool.PrioritisedPoolExecutor parallelGenExecutor;
+-    private final PrioritisedThreadPool.PrioritisedPoolExecutor radiusAwareGenExecutor;
+-    public final PrioritisedThreadPool.PrioritisedPoolExecutor loadExecutor;
++    public final PrioritisedThreadPool.ExecutorGroup.ThreadPoolExecutor parallelGenExecutor;
++    private final PrioritisedThreadPool.ExecutorGroup.ThreadPoolExecutor radiusAwareGenExecutor;
++    public final PrioritisedThreadPool.ExecutorGroup.ThreadPoolExecutor loadExecutor;
++    public final PrioritisedThreadPool.ExecutorGroup.ThreadPoolExecutor ioExecutor;
++    public final PrioritisedThreadPool.ExecutorGroup.ThreadPoolExecutor compressionExecutor;
++    public final PrioritisedThreadPool.ExecutorGroup.ThreadPoolExecutor saveExecutor;
+ 
+-    private final PrioritisedThreadedTaskQueue mainThreadExecutor = new PrioritisedThreadedTaskQueue();
++    private final PrioritisedTaskQueue mainThreadExecutor = new PrioritisedTaskQueue();
+ 
+     public final ChunkHolderManager chunkHolderManager;
+ 
+@@ -306,9 +272,8 @@ public final class ChunkTaskScheduler {
+         return this.lockShift;
+     }
+ 
+-    public ChunkTaskScheduler(final ServerLevel world, final PrioritisedThreadPool workers) {
++    public ChunkTaskScheduler(final ServerLevel world) {
+         this.world = world;
+-        this.workers = workers;
+         // must be >= region shift (in paper, doesn't exist) and must be >= ticket propagator section shift
+         // it must be >= region shift since the regioniser assumes ticket updates do not occur in parallel for the region sections
+         // it must be >= ticket propagator section shift so that the ticket propagator can assume that owning a position implies owning
+@@ -317,11 +282,14 @@ public final class ChunkTaskScheduler {
+         this.lockShift = Math.max(((ChunkSystemServerLevel)world).moonrise$getRegionChunkShift(), ThreadedTicketLevelPropagator.SECTION_SHIFT);
+         this.schedulingLockArea = new ReentrantAreaLock(this.getChunkSystemLockShift());
+ 
+-        final String worldName = WorldUtil.getWorldName(world);
+-        this.parallelGenExecutor = workers.createExecutor("Chunk parallel generation executor for world '" + worldName + "'", 1, Math.max(1, newChunkSystemGenParallelism));
+-        this.radiusAwareGenExecutor = workers.createExecutor("Chunk radius aware generator for world '" + worldName + "'", 1, Math.max(1, newChunkSystemGenPopulationParallelism));
+-        this.loadExecutor = workers.createExecutor("Chunk load executor for world '" + worldName + "'", 1, newChunkSystemLoadParallelism);
+-        this.radiusAwareScheduler = new RadiusAwarePrioritisedExecutor(this.radiusAwareGenExecutor, Math.max(2, 1 + newChunkSystemGenPopulationParallelism));
++        this.parallelGenExecutor = MoonriseCommon.PARALLEL_GEN_GROUP.createExecutor(-1, MoonriseCommon.WORKER_QUEUE_HOLD_TIME, 0);
++        this.radiusAwareGenExecutor = MoonriseCommon.RADIUS_AWARE_GROUP.createExecutor(1, MoonriseCommon.WORKER_QUEUE_HOLD_TIME, 0);
++        this.loadExecutor = MoonriseCommon.LOAD_GROUP.createExecutor(-1, MoonriseCommon.WORKER_QUEUE_HOLD_TIME, 0);
++        this.radiusAwareScheduler = new RadiusAwarePrioritisedExecutor(this.radiusAwareGenExecutor, 16);
++        this.ioExecutor = MoonriseCommon.SERVER_REGION_IO_GROUP.createExecutor(-1, MoonriseCommon.IO_QUEUE_HOLD_TIME, 0);
++        // we need a separate executor here so that on shutdown we can continue to process I/O tasks
++        this.compressionExecutor = MoonriseCommon.LOAD_GROUP.createExecutor(-1, MoonriseCommon.WORKER_QUEUE_HOLD_TIME, 0);
++        this.saveExecutor = MoonriseCommon.LOAD_GROUP.createExecutor(-1, MoonriseCommon.WORKER_QUEUE_HOLD_TIME, 0);
+         this.chunkHolderManager = new ChunkHolderManager(world, this);
+     }
+ 
+@@ -360,7 +328,7 @@ public final class ChunkTaskScheduler {
+         };
+ 
+         // this may not be good enough, specifically thanks to stupid ass plugins swallowing exceptions
+-        this.scheduleChunkTask(chunkX, chunkZ, crash, PrioritisedExecutor.Priority.BLOCKING);
++        this.scheduleChunkTask(chunkX, chunkZ, crash, Priority.BLOCKING);
+         // so, make the main thread pick it up
+         ((ChunkSystemMinecraftServer)this.world.getServer()).moonrise$setChunkSystemCrash(new RuntimeException("Chunk system crash propagated from unrecoverableChunkSystemFailure", reportedException));
+     }
+@@ -370,20 +338,20 @@ public final class ChunkTaskScheduler {
+         return this.mainThreadExecutor.executeTask();
+     }
+ 
+-    public void raisePriority(final int x, final int z, final PrioritisedExecutor.Priority priority) {
++    public void raisePriority(final int x, final int z, final Priority priority) {
+         this.chunkHolderManager.raisePriority(x, z, priority);
+     }
+ 
+-    public void setPriority(final int x, final int z, final PrioritisedExecutor.Priority priority) {
++    public void setPriority(final int x, final int z, final Priority priority) {
+         this.chunkHolderManager.setPriority(x, z, priority);
+     }
+ 
+-    public void lowerPriority(final int x, final int z, final PrioritisedExecutor.Priority priority) {
++    public void lowerPriority(final int x, final int z, final Priority priority) {
+         this.chunkHolderManager.lowerPriority(x, z, priority);
+     }
+ 
+     public void scheduleTickingState(final int chunkX, final int chunkZ, final FullChunkStatus toStatus,
+-                                     final boolean addTicket, final PrioritisedExecutor.Priority priority,
++                                     final boolean addTicket, final Priority priority,
+                                      final Consumer<LevelChunk> onComplete) {
+         final int radius = toStatus.ordinal() - 1; // 0 -> BORDER, 1 -> TICKING, 2 -> ENTITY_TICKING
+ 
+@@ -479,7 +447,7 @@ public final class ChunkTaskScheduler {
+     }
+ 
+     public void scheduleChunkLoad(final int chunkX, final int chunkZ, final boolean gen, final ChunkStatus toStatus, final boolean addTicket,
+-                                  final PrioritisedExecutor.Priority priority, final Consumer<ChunkAccess> onComplete) {
++                                  final Priority priority, final Consumer<ChunkAccess> onComplete) {
+         if (gen) {
+             this.scheduleChunkLoad(chunkX, chunkZ, toStatus, addTicket, priority, onComplete);
+             return;
+@@ -503,7 +471,7 @@ public final class ChunkTaskScheduler {
+ 
+     // only appropriate to use with syncLoadNonFull
+     public boolean beginChunkLoadForNonFullSync(final int chunkX, final int chunkZ, final ChunkStatus toStatus,
+-                                                final PrioritisedExecutor.Priority priority) {
++                                                final Priority priority) {
+         final int accessRadius = getAccessRadius(toStatus);
+         final long chunkKey = CoordinateUtils.getChunkKey(chunkX, chunkZ);
+         final int minLevel = ChunkTaskScheduler.getTicketLevel(toStatus);
+@@ -548,6 +516,11 @@ public final class ChunkTaskScheduler {
+         if (status == null || status.isOrAfter(ChunkStatus.FULL)) {
+             throw new IllegalArgumentException("Status: " + status);
+         }
++
++        if (!TickThread.isTickThread()) {
++            return this.world.getChunkSource().getChunk(chunkX, chunkZ, status, true);
++        }
++
+         ChunkAccess loaded = ((ChunkSystemServerLevel)this.world).moonrise$getSpecificChunkIfLoaded(chunkX, chunkZ, status);
+         if (loaded != null) {
+             return loaded;
+@@ -558,7 +531,7 @@ public final class ChunkTaskScheduler {
+         this.chunkHolderManager.addTicketAtLevel(NON_FULL_CHUNK_LOAD, chunkX, chunkZ, ticketLevel, ticketId);
+         this.chunkHolderManager.processTicketUpdates();
+ 
+-        this.beginChunkLoadForNonFullSync(chunkX, chunkZ, status, PrioritisedExecutor.Priority.BLOCKING);
++        this.beginChunkLoadForNonFullSync(chunkX, chunkZ, status, Priority.BLOCKING);
+ 
+         // we could do a simple spinwait here, since we do not need to process tasks while performing this load
+         // but we process tasks only because it's a better use of the time spent
+@@ -578,7 +551,7 @@ public final class ChunkTaskScheduler {
+     }
+ 
+     public void scheduleChunkLoad(final int chunkX, final int chunkZ, final ChunkStatus toStatus, final boolean addTicket,
+-                                  final PrioritisedExecutor.Priority priority, final Consumer<ChunkAccess> onComplete) {
++                                  final Priority priority, final Consumer<ChunkAccess> onComplete) {
+         if (!TickThread.isTickThreadFor(this.world, chunkX, chunkZ)) {
+             this.scheduleChunkTask(chunkX, chunkZ, () -> {
+                 ChunkTaskScheduler.this.scheduleChunkLoad(chunkX, chunkZ, toStatus, addTicket, priority, onComplete);
+@@ -670,7 +643,7 @@ public final class ChunkTaskScheduler {
+ 
+     private ChunkProgressionTask createTask(final int chunkX, final int chunkZ, final ChunkAccess chunk,
+                                             final NewChunkHolder chunkHolder, final StaticCache2D<GenerationChunkHolder> neighbours,
+-                                            final ChunkStatus toStatus, final PrioritisedExecutor.Priority initialPriority) {
++                                            final ChunkStatus toStatus, final Priority initialPriority) {
+         if (toStatus == ChunkStatus.EMPTY) {
+             return new ChunkLoadTask(this, this.world, chunkX, chunkZ, chunkHolder, initialPriority);
+         }
+@@ -686,7 +659,7 @@ public final class ChunkTaskScheduler {
+ 
+     ChunkProgressionTask schedule(final int chunkX, final int chunkZ, final ChunkStatus targetStatus, final NewChunkHolder chunkHolder,
+                                   final List<ChunkProgressionTask> allTasks) {
+-        return this.schedule(chunkX, chunkZ, targetStatus, chunkHolder, allTasks, chunkHolder.getEffectivePriority(PrioritisedExecutor.Priority.NORMAL));
++        return this.schedule(chunkX, chunkZ, targetStatus, chunkHolder, allTasks, chunkHolder.getEffectivePriority(Priority.NORMAL));
+     }
+ 
+     // rets new task scheduled for the _specified_ chunk
+@@ -695,7 +668,7 @@ public final class ChunkTaskScheduler {
+     // schedule will ignore the generation target, so it should be checked by the caller to ensure the target is not regressed!
+     private ChunkProgressionTask schedule(final int chunkX, final int chunkZ, final ChunkStatus targetStatus,
+                                           final NewChunkHolder chunkHolder, final List<ChunkProgressionTask> allTasks,
+-                                          final PrioritisedExecutor.Priority minPriority) {
++                                          final Priority minPriority) {
+         if (!this.schedulingLockArea.isHeldByCurrentThread(chunkX, chunkZ, getAccessRadius(targetStatus))) {
+             throw new IllegalStateException("Not holding scheduling lock");
+         }
+@@ -705,8 +678,8 @@ public final class ChunkTaskScheduler {
+             return null;
+         }
+ 
+-        final PrioritisedExecutor.Priority requestedPriority = PrioritisedExecutor.Priority.max(
+-                minPriority, chunkHolder.getEffectivePriority(PrioritisedExecutor.Priority.NORMAL)
++        final Priority requestedPriority = Priority.max(
++                minPriority, chunkHolder.getEffectivePriority(Priority.NORMAL)
+         );
+         final ChunkStatus currentGenStatus = chunkHolder.getCurrentGenStatus();
+         final ChunkAccess chunk = chunkHolder.getCurrentChunk();
+@@ -743,7 +716,7 @@ public final class ChunkTaskScheduler {
+ 
+         final int neighbourReadRadius = Math.max(
+                 0,
+-                chunkPyramid.getStepTo(toStatus).getAccumulatedRadiusOf(ChunkStatus.EMPTY)
++                chunkStep.getAccumulatedRadiusOf(ChunkStatus.EMPTY)
+         );
+ 
+         boolean unGeneratedNeighbours = false;
+@@ -783,7 +756,7 @@ public final class ChunkTaskScheduler {
+ 
+         final ChunkProgressionTask task = this.createTask(
+                 chunkX, chunkZ, chunk, chunkHolder, neighbours, toStatus,
+-                chunkHolder.getEffectivePriority(PrioritisedExecutor.Priority.NORMAL)
++                chunkHolder.getEffectivePriority(Priority.NORMAL)
+         );
+         allTasks.add(task);
+ 
+@@ -794,7 +767,7 @@ public final class ChunkTaskScheduler {
+ 
+     // rets true if the neighbour is not at the required status, false otherwise
+     private boolean checkNeighbour(final int chunkX, final int chunkZ, final ChunkStatus requiredStatus, final NewChunkHolder center,
+-                                   final List<ChunkProgressionTask> tasks, final PrioritisedExecutor.Priority minPriority) {
++                                   final List<ChunkProgressionTask> tasks, final Priority minPriority) {
+         final NewChunkHolder chunkHolder = this.chunkHolderManager.getChunkHolder(chunkX, chunkZ);
+ 
+         if (chunkHolder == null) {
+@@ -830,41 +803,41 @@ public final class ChunkTaskScheduler {
+      */
+     @Deprecated
+     public PrioritisedExecutor.PrioritisedTask scheduleChunkTask(final Runnable run) {
+-        return this.scheduleChunkTask(run, PrioritisedExecutor.Priority.NORMAL);
++        return this.scheduleChunkTask(run, Priority.NORMAL);
+     }
+ 
+     /**
+      * @deprecated Chunk tasks must be tied to coordinates in the future
+      */
+     @Deprecated
+-    public PrioritisedExecutor.PrioritisedTask scheduleChunkTask(final Runnable run, final PrioritisedExecutor.Priority priority) {
+-        return this.mainThreadExecutor.queueRunnable(run, priority);
++    public PrioritisedExecutor.PrioritisedTask scheduleChunkTask(final Runnable run, final Priority priority) {
++        return this.mainThreadExecutor.queueTask(run, priority);
+     }
+ 
+     public PrioritisedExecutor.PrioritisedTask createChunkTask(final int chunkX, final int chunkZ, final Runnable run) {
+-        return this.createChunkTask(chunkX, chunkZ, run, PrioritisedExecutor.Priority.NORMAL);
++        return this.createChunkTask(chunkX, chunkZ, run, Priority.NORMAL);
+     }
+ 
+     public PrioritisedExecutor.PrioritisedTask createChunkTask(final int chunkX, final int chunkZ, final Runnable run,
+-                                                               final PrioritisedExecutor.Priority priority) {
++                                                               final Priority priority) {
+         return this.mainThreadExecutor.createTask(run, priority);
+     }
+ 
+     public PrioritisedExecutor.PrioritisedTask scheduleChunkTask(final int chunkX, final int chunkZ, final Runnable run) {
+-        return this.scheduleChunkTask(chunkX, chunkZ, run, PrioritisedExecutor.Priority.NORMAL);
++        return this.scheduleChunkTask(chunkX, chunkZ, run, Priority.NORMAL);
+     }
+ 
+     public PrioritisedExecutor.PrioritisedTask scheduleChunkTask(final int chunkX, final int chunkZ, final Runnable run,
+-                                                                 final PrioritisedExecutor.Priority priority) {
+-        return this.mainThreadExecutor.queueRunnable(run, priority);
++                                                                 final Priority priority) {
++        return this.mainThreadExecutor.queueTask(run, priority);
+     }
+ 
+     public boolean halt(final boolean sync, final long maxWaitNS) {
+         this.radiusAwareGenExecutor.halt();
+         this.parallelGenExecutor.halt();
+         this.loadExecutor.halt();
+-        final long time = System.nanoTime();
+         if (sync) {
++            final long time = System.nanoTime();
+             for (long failures = 9L;; failures = ConcurrentUtil.linearLongBackoff(failures, 500_000L, 50_000_000L)) {
+                 if (
+                         !this.radiusAwareGenExecutor.isActive() &&
+@@ -882,6 +855,29 @@ public final class ChunkTaskScheduler {
+         return true;
+     }
+ 
++    public boolean haltIO(final boolean sync, final long maxWaitNS) {
++        this.ioExecutor.halt();
++        this.saveExecutor.halt();
++        this.compressionExecutor.halt();
++        if (sync) {
++            final long time = System.nanoTime();
++            for (long failures = 9L;; failures = ConcurrentUtil.linearLongBackoff(failures, 500_000L, 50_000_000L)) {
++                if (
++                        !this.ioExecutor.isActive() &&
++                        !this.saveExecutor.isActive() &&
++                        !this.compressionExecutor.isActive()
++                ) {
++                    return true;
++                }
++                if ((System.nanoTime() - time) >= maxWaitNS) {
++                    return false;
++                }
++            }
++        }
++
++        return true;
++    }
++
+     public static final ArrayDeque<ChunkInfo> WAITING_CHUNKS = new ArrayDeque<>(); // stack
+ 
+     public static final class ChunkInfo {
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/NewChunkHolder.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/NewChunkHolder.java
+index 45eda96fd8a1acb87dbb69ce5495fec7e451416f..381631e405895ba3eede1cd2e1011c64aadbd662 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/NewChunkHolder.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/NewChunkHolder.java
+@@ -1,18 +1,20 @@
+ package ca.spottedleaf.moonrise.patches.chunk_system.scheduling;
+ 
+-import ca.spottedleaf.concurrentutil.completable.Completable;
++import ca.spottedleaf.concurrentutil.completable.CallbackCompletable;
+ import ca.spottedleaf.concurrentutil.executor.Cancellable;
+-import ca.spottedleaf.concurrentutil.executor.standard.DelayedPrioritisedTask;
+-import ca.spottedleaf.concurrentutil.executor.standard.PrioritisedExecutor;
++import ca.spottedleaf.concurrentutil.executor.PrioritisedExecutor;
+ import ca.spottedleaf.concurrentutil.lock.ReentrantAreaLock;
+ import ca.spottedleaf.concurrentutil.util.ConcurrentUtil;
++import ca.spottedleaf.concurrentutil.util.Priority;
++import ca.spottedleaf.moonrise.common.PlatformHooks;
++import ca.spottedleaf.moonrise.common.misc.LazyRunnable;
+ import ca.spottedleaf.moonrise.common.util.CoordinateUtils;
+ import ca.spottedleaf.moonrise.common.util.TickThread;
+ import ca.spottedleaf.moonrise.common.util.WorldUtil;
+ import ca.spottedleaf.moonrise.common.util.ChunkSystem;
+-import ca.spottedleaf.moonrise.patches.chunk_system.ChunkSystemFeatures;
+-import ca.spottedleaf.moonrise.patches.chunk_system.async_save.AsyncChunkSaveData;
+-import ca.spottedleaf.moonrise.patches.chunk_system.io.RegionFileIOThread;
++import ca.spottedleaf.moonrise.patches.chunk_system.level.chunk.ChunkData;
++import ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO;
++import ca.spottedleaf.moonrise.patches.chunk_system.level.ChunkSystemLevel;
+ import ca.spottedleaf.moonrise.patches.chunk_system.level.ChunkSystemServerLevel;
+ import ca.spottedleaf.moonrise.patches.chunk_system.level.chunk.ChunkSystemChunkHolder;
+ import ca.spottedleaf.moonrise.patches.chunk_system.level.chunk.ChunkSystemChunkStatus;
+@@ -36,13 +38,14 @@ import net.minecraft.server.level.ChunkHolder;
+ import net.minecraft.server.level.ChunkLevel;
+ import net.minecraft.server.level.FullChunkStatus;
+ import net.minecraft.server.level.ServerLevel;
++import net.minecraft.server.level.progress.ChunkProgressListener;
+ import net.minecraft.world.entity.Entity;
+ import net.minecraft.world.level.ChunkPos;
+ import net.minecraft.world.level.chunk.ChunkAccess;
+ import net.minecraft.world.level.chunk.ImposterProtoChunk;
+ import net.minecraft.world.level.chunk.LevelChunk;
+ import net.minecraft.world.level.chunk.status.ChunkStatus;
+-import net.minecraft.world.level.chunk.storage.ChunkSerializer;
++import net.minecraft.world.level.chunk.storage.SerializableChunkData;
+ import org.slf4j.Logger;
+ import org.slf4j.LoggerFactory;
+ import java.lang.invoke.VarHandle;
+@@ -58,6 +61,8 @@ public final class NewChunkHolder {
+ 
+     private static final Logger LOGGER = LoggerFactory.getLogger(NewChunkHolder.class);
+ 
++    public final ChunkData holderData;
++
+     public final ServerLevel world;
+     public final int chunkX;
+     public final int chunkZ;
+@@ -89,7 +94,7 @@ public final class NewChunkHolder {
+             if (this.entityChunk == null) {
+                 ret = this.entityChunk = new ChunkEntitySlices(
+                     this.world, this.chunkX, this.chunkZ, this.getChunkStatus(),
+-                    WorldUtil.getMinSection(this.world), WorldUtil.getMaxSection(this.world)
++                    this.holderData, WorldUtil.getMinSection(this.world), WorldUtil.getMaxSection(this.world)
+                 );
+ 
+                 ret.setTransient(transientChunk);
+@@ -173,7 +178,7 @@ public final class NewChunkHolder {
+                     // no tasks to schedule _for_
+                 } else {
+                     entityDataLoadTask = this.entityDataLoadTask = new ChunkLoadTask.EntityDataLoadTask(
+-                        this.scheduler, this.world, this.chunkX, this.chunkZ, this.getEffectivePriority(PrioritisedExecutor.Priority.NORMAL)
++                        this.scheduler, this.world, this.chunkX, this.chunkZ, this.getEffectivePriority(Priority.NORMAL)
+                     );
+                     entityDataLoadTask.addCallback(this::completeEntityLoad);
+                     // need one schedule() per waiter
+@@ -220,7 +225,7 @@ public final class NewChunkHolder {
+ 
+         if (this.entityDataLoadTask == null) {
+             this.entityDataLoadTask = new ChunkLoadTask.EntityDataLoadTask(
+-                this.scheduler, this.world, this.chunkX, this.chunkZ, this.getEffectivePriority(PrioritisedExecutor.Priority.NORMAL)
++                this.scheduler, this.world, this.chunkX, this.chunkZ, this.getEffectivePriority(Priority.NORMAL)
+             );
+             this.entityDataLoadTask.addCallback(this::completeEntityLoad);
+             this.entityDataLoadTaskWaiters = new ArrayList<>();
+@@ -294,7 +299,7 @@ public final class NewChunkHolder {
+                     // no tasks to schedule _for_
+                 } else {
+                     poiDataLoadTask = this.poiDataLoadTask = new ChunkLoadTask.PoiDataLoadTask(
+-                        this.scheduler, this.world, this.chunkX, this.chunkZ, this.getEffectivePriority(PrioritisedExecutor.Priority.NORMAL)
++                        this.scheduler, this.world, this.chunkX, this.chunkZ, this.getEffectivePriority(Priority.NORMAL)
+                     );
+                     poiDataLoadTask.addCallback(this::completePoiLoad);
+                     // need one schedule() per waiter
+@@ -340,7 +345,7 @@ public final class NewChunkHolder {
+ 
+         if (this.poiDataLoadTask == null) {
+             this.poiDataLoadTask = new ChunkLoadTask.PoiDataLoadTask(
+-                this.scheduler, this.world, this.chunkX, this.chunkZ, this.getEffectivePriority(PrioritisedExecutor.Priority.NORMAL)
++                this.scheduler, this.world, this.chunkX, this.chunkZ, this.getEffectivePriority(Priority.NORMAL)
+             );
+             this.poiDataLoadTask.addCallback(this::completePoiLoad);
+             this.poiDataLoadTaskWaiters = new ArrayList<>();
+@@ -519,15 +524,15 @@ public final class NewChunkHolder {
+     // priority state
+ 
+     // the target priority for this chunk to generate at
+-    private PrioritisedExecutor.Priority priority = null;
++    private Priority priority = null;
+     private boolean priorityLocked;
+ 
+     // the priority neighbouring chunks have requested this chunk generate at
+-    private PrioritisedExecutor.Priority neighbourRequestedPriority = null;
++    private Priority neighbourRequestedPriority = null;
+ 
+-    public PrioritisedExecutor.Priority getEffectivePriority(final PrioritisedExecutor.Priority dfl) {
+-        final PrioritisedExecutor.Priority neighbour = this.neighbourRequestedPriority;
+-        final PrioritisedExecutor.Priority us = this.priority;
++    public Priority getEffectivePriority(final Priority dfl) {
++        final Priority neighbour = this.neighbourRequestedPriority;
++        final Priority us = this.priority;
+ 
+         if (neighbour == null) {
+             return us == null ? dfl : us;
+@@ -536,7 +541,7 @@ public final class NewChunkHolder {
+             return neighbour;
+         }
+ 
+-        return PrioritisedExecutor.Priority.max(us, neighbour);
++        return Priority.max(us, neighbour);
+     }
+ 
+     private void recalculateNeighbourRequestedPriority() {
+@@ -545,18 +550,18 @@ public final class NewChunkHolder {
+             return;
+         }
+ 
+-        PrioritisedExecutor.Priority max = null;
++        Priority max = null;
+ 
+         for (final NewChunkHolder holder : this.neighboursWaitingForUs.keySet()) {
+-            final PrioritisedExecutor.Priority neighbourPriority = holder.getEffectivePriority(null);
++            final Priority neighbourPriority = holder.getEffectivePriority(null);
+             if (neighbourPriority != null && (max == null || neighbourPriority.isHigherPriority(max))) {
+                 max = neighbourPriority;
+             }
+         }
+ 
+-        final PrioritisedExecutor.Priority current = this.getEffectivePriority(PrioritisedExecutor.Priority.NORMAL);
++        final Priority current = this.getEffectivePriority(Priority.NORMAL);
+         this.neighbourRequestedPriority = max;
+-        final PrioritisedExecutor.Priority next = this.getEffectivePriority(PrioritisedExecutor.Priority.NORMAL);
++        final Priority next = this.getEffectivePriority(Priority.NORMAL);
+ 
+         if (current == next) {
+             return;
+@@ -578,7 +583,7 @@ public final class NewChunkHolder {
+     }
+ 
+     // must hold scheduling lock
+-    public void raisePriority(final PrioritisedExecutor.Priority priority) {
++    public void raisePriority(final Priority priority) {
+         if (this.priority != null && this.priority.isHigherOrEqualPriority(priority)) {
+             return;
+         }
+@@ -591,13 +596,13 @@ public final class NewChunkHolder {
+     }
+ 
+     // must hold scheduling lock
+-    public void setPriority(final PrioritisedExecutor.Priority priority) {
++    public void setPriority(final Priority priority) {
+         if (this.priorityLocked) {
+             return;
+         }
+-        final PrioritisedExecutor.Priority old = this.getEffectivePriority(null);
++        final Priority old = this.getEffectivePriority(null);
+         this.priority = priority;
+-        final PrioritisedExecutor.Priority newPriority = this.getEffectivePriority(PrioritisedExecutor.Priority.NORMAL);
++        final Priority newPriority = this.getEffectivePriority(Priority.NORMAL);
+ 
+         if (old != newPriority) {
+             if (this.generationTask != null) {
+@@ -609,7 +614,7 @@ public final class NewChunkHolder {
+     }
+ 
+     // must hold scheduling lock
+-    public void lowerPriority(final PrioritisedExecutor.Priority priority) {
++    public void lowerPriority(final Priority priority) {
+         if (this.priority != null && this.priority.isLowerOrEqualPriority(priority)) {
+             return;
+         }
+@@ -632,7 +637,7 @@ public final class NewChunkHolder {
+     }
+ 
+     // ticket level state
+-    public int oldTicketLevel = ChunkHolderManager.MAX_TICKET_LEVEL + 1;
++    private int oldTicketLevel = ChunkHolderManager.MAX_TICKET_LEVEL + 1;
+     private int currentTicketLevel = ChunkHolderManager.MAX_TICKET_LEVEL + 1;
+ 
+     public int getTicketLevel() {
+@@ -651,6 +656,7 @@ public final class NewChunkHolder {
+                 world.getLightEngine(), null, world.getChunkSource().chunkMap
+         );
+         ((ChunkSystemChunkHolder)this.vanillaChunkHolder).moonrise$setRealChunkHolder(this);
++        this.holderData = ((ChunkSystemLevel)this.world).moonrise$requestChunkData(CoordinateUtils.getChunkKey(chunkX, chunkZ));
+     }
+ 
+     public ChunkAccess getCurrentChunk() {
+@@ -750,8 +756,9 @@ public final class NewChunkHolder {
+     /** Unloaded from chunk map */
+     private boolean unloaded;
+ 
+-    void markUnloaded() {
++    void onUnload() {
+         this.unloaded = true;
++        ((ChunkSystemLevel)this.world).moonrise$releaseChunkData(CoordinateUtils.getChunkKey(this.chunkX, this.chunkZ));
+     }
+ 
+     private boolean inUnloadQueue = false;
+@@ -788,9 +795,10 @@ public final class NewChunkHolder {
+     private UnloadTask entityDataUnload;
+     private UnloadTask poiDataUnload;
+ 
+-    public static final record UnloadTask(Completable<CompoundTag> completable, DelayedPrioritisedTask task) {}
++    public static final record UnloadTask(CallbackCompletable<CompoundTag> completable, PrioritisedExecutor.PrioritisedTask task,
++                                          LazyRunnable toRun) {}
+ 
+-    public UnloadTask getUnloadTask(final RegionFileIOThread.RegionFileType type) {
++    public UnloadTask getUnloadTask(final MoonriseRegionFileIO.RegionFileType type) {
+         switch (type) {
+             case CHUNK_DATA:
+                 return this.chunkDataUnload;
+@@ -803,7 +811,7 @@ public final class NewChunkHolder {
+         }
+     }
+ 
+-    private void removeUnloadTask(final RegionFileIOThread.RegionFileType type) {
++    private void removeUnloadTask(final MoonriseRegionFileIO.RegionFileType type) {
+         switch (type) {
+             case CHUNK_DATA: {
+                 this.chunkDataUnload = null;
+@@ -836,10 +844,10 @@ public final class NewChunkHolder {
+         // chunk state
+         this.currentChunk = null;
+         this.currentGenStatus = null;
+-        this.lastChunkCompletion = null;
+         for (int i = 0; i < this.chunkCompletions.length; ++i) {
+-            CHUNK_COMPLETION_ARRAY_HANDLE.setVolatile(this.chunkCompletions, i, (ChunkCompletion)null);
++            CHUNK_COMPLETION_ARRAY_HANDLE.setRelease(this.chunkCompletions, i, (ChunkCompletion)null);
+         }
++        this.lastChunkCompletion = null;
+         // entity chunk state
+         this.entityChunk = null;
+         this.pendingEntityChunk = null;
+@@ -851,22 +859,23 @@ public final class NewChunkHolder {
+         this.priorityLocked = false;
+ 
+         if (chunk != null) {
+-            this.chunkDataUnload = new UnloadTask(new Completable<>(), new DelayedPrioritisedTask(PrioritisedExecutor.Priority.NORMAL));
++            final LazyRunnable toRun = new LazyRunnable();
++            this.chunkDataUnload = new UnloadTask(new CallbackCompletable<>(), this.scheduler.saveExecutor.createTask(toRun), toRun);
+         }
+         if (poiChunk != null) {
+-            this.poiDataUnload = new UnloadTask(new Completable<>(), null);
++            this.poiDataUnload = new UnloadTask(new CallbackCompletable<>(), null, null);
+         }
+         if (entityChunk != null) {
+-            this.entityDataUnload = new UnloadTask(new Completable<>(), null);
++            this.entityDataUnload = new UnloadTask(new CallbackCompletable<>(), null, null);
+         }
+ 
+         return this.unloadState = (chunk != null || entityChunk != null || poiChunk != null) ? new UnloadState(this, chunk, entityChunk, poiChunk) : null;
+     }
+ 
+     // data is null if failed or does not need to be saved
+-    void completeAsyncUnloadDataSave(final RegionFileIOThread.RegionFileType type, final CompoundTag data) {
++    void completeAsyncUnloadDataSave(final MoonriseRegionFileIO.RegionFileType type, final CompoundTag data) {
+         if (data != null) {
+-            RegionFileIOThread.scheduleSave(this.world, this.chunkX, this.chunkZ, data, type);
++            MoonriseRegionFileIO.scheduleSave(this.world, this.chunkX, this.chunkZ, data, type);
+         }
+ 
+         this.getUnloadTask(type).completable().complete(data);
+@@ -886,18 +895,19 @@ public final class NewChunkHolder {
+         final ChunkEntitySlices entityChunk = state.entityChunk();
+         final PoiChunk poiChunk = state.poiChunk();
+ 
+-        final boolean shouldLevelChunkNotSave = ChunkSystemFeatures.forceNoSave(chunk);
++        final boolean shouldLevelChunkNotSave = PlatformHooks.get().forceNoSave(chunk);
+ 
+         // unload chunk data
+         if (chunk != null) {
+             if (chunk instanceof LevelChunk levelChunk) {
+                 levelChunk.setLoaded(false);
++                PlatformHooks.get().chunkUnloadFromWorld(levelChunk);
+             }
+ 
+             if (!shouldLevelChunkNotSave) {
+                 this.saveChunk(chunk, true);
+             } else {
+-                this.completeAsyncUnloadDataSave(RegionFileIOThread.RegionFileType.CHUNK_DATA, null);
++                this.completeAsyncUnloadDataSave(MoonriseRegionFileIO.RegionFileType.CHUNK_DATA, null);
+             }
+ 
+             if (chunk instanceof LevelChunk levelChunk) {
+@@ -1066,6 +1076,9 @@ public final class NewChunkHolder {
+         if (oldUnloaded != newUnloaded) {
+             this.checkUnload();
+         }
++
++        // Don't really have a choice but to place this hook here
++        PlatformHooks.get().onChunkHolderTicketChange(this.world, this, oldLevel, newLevel);
+     }
+ 
+     static final int NEIGHBOUR_RADIUS = 2;
+@@ -1111,24 +1124,6 @@ public final class NewChunkHolder {
+     private static final long CHUNK_LOADED_MASK_RAD1 = getLoadedMask(1);
+     private static final long CHUNK_LOADED_MASK_RAD2 = getLoadedMask(2);
+ 
+-    public static boolean areNeighboursFullLoaded(final long bitset, final int radius) {
+-        switch (radius) {
+-            case 0: {
+-                return (bitset & CHUNK_LOADED_MASK_RAD0) == CHUNK_LOADED_MASK_RAD0;
+-            }
+-            case 1: {
+-                return (bitset & CHUNK_LOADED_MASK_RAD1) == CHUNK_LOADED_MASK_RAD1;
+-            }
+-            case 2: {
+-                return (bitset & CHUNK_LOADED_MASK_RAD2) == CHUNK_LOADED_MASK_RAD2;
+-            }
+-
+-            default: {
+-                throw new IllegalArgumentException("Radius not recognized: " + radius);
+-            }
+-        }
+-    }
+-
+     // only updated while holding scheduling lock
+     private FullChunkStatus pendingFullChunkStatus = FullChunkStatus.INACCESSIBLE;
+     // updated while holding no locks, but adds a ticket before to prevent pending status from dropping
+@@ -1363,6 +1358,17 @@ public final class NewChunkHolder {
+     }
+ 
+     private void completeStatusConsumers(ChunkStatus status, final ChunkAccess chunk) {
++        // Update progress listener for LevelLoadingScreen
++        if (chunk != null) {
++            final ChunkProgressListener progressListener = this.world.getChunkSource().chunkMap.progressListener;
++            if (progressListener != null) {
++                final ChunkStatus finalStatus = status;
++                this.scheduler.scheduleChunkTask(this.chunkX, this.chunkZ, () -> {
++                    progressListener.onStatusChange(this.vanillaChunkHolder.getPos(), finalStatus);
++                });
++            }
++        }
++
+         // need to tell future statuses to complete if cancelled
+         do {
+             this.completeStatusConsumers0(status, chunk);
+@@ -1386,7 +1392,7 @@ public final class NewChunkHolder {
+                     LOGGER.error("Failed to process chunk status callback", thr);
+                 }
+             }
+-        }, PrioritisedExecutor.Priority.HIGHEST);
++        }, Priority.HIGHEST);
+     }
+ 
+     private final Reference2ObjectOpenHashMap<FullChunkStatus, List<Consumer<LevelChunk>>> fullStatusWaiters = new Reference2ObjectOpenHashMap<>();
+@@ -1414,7 +1420,7 @@ public final class NewChunkHolder {
+                     LOGGER.error("Failed to process chunk status callback", thr);
+                 }
+             }
+-        }, PrioritisedExecutor.Priority.HIGHEST);
++        }, Priority.HIGHEST);
+     }
+ 
+     // note: must hold scheduling lock
+@@ -1670,6 +1676,8 @@ public final class NewChunkHolder {
+ 
+     public static final record SaveStat(boolean savedChunk, boolean savedEntityChunk, boolean savedPoiChunk) {}
+ 
++    private static final MoonriseRegionFileIO.RegionFileType[] REGION_FILE_TYPES = MoonriseRegionFileIO.RegionFileType.values();
++
+     public SaveStat save(final boolean shutdown) {
+         TickThread.ensureTickThread(this.world, this.chunkX, this.chunkZ, "Cannot save data off-main");
+ 
+@@ -1677,6 +1685,7 @@ public final class NewChunkHolder {
+         PoiChunk poi = this.getPoiChunk();
+         ChunkEntitySlices entities = this.getEntityChunk();
+         boolean executedUnloadTask = false;
++        final boolean[] executedUnloadTasks = new boolean[REGION_FILE_TYPES.length];
+ 
+         if (shutdown) {
+             // make sure that the async unloads complete
+@@ -1686,17 +1695,22 @@ public final class NewChunkHolder {
+                 poi = this.unloadState.poiChunk();
+                 entities = this.unloadState.entityChunk();
+             }
+-            final UnloadTask chunkUnloadTask = this.chunkDataUnload;
+-            final DelayedPrioritisedTask chunkDataUnloadTask = chunkUnloadTask == null ? null : chunkUnloadTask.task();
+-            if (chunkDataUnloadTask != null) {
+-                final PrioritisedExecutor.PrioritisedTask unloadTask = chunkDataUnloadTask.getTask();
+-                if (unloadTask != null) {
+-                    executedUnloadTask = unloadTask.execute();
++            for (final MoonriseRegionFileIO.RegionFileType regionFileType : REGION_FILE_TYPES) {
++                final UnloadTask unloadTask = this.getUnloadTask(regionFileType);
++                if (unloadTask == null) {
++                    continue;
++                }
++
++                final PrioritisedExecutor.PrioritisedTask task = unloadTask.task();
++                if (task != null && task.isQueued()) {
++                    final boolean executed = task.execute();
++                    executedUnloadTask |= executed;
++                    executedUnloadTasks[regionFileType.ordinal()] = executed;
+                 }
+             }
+         }
+ 
+-        final boolean forceNoSaveChunk = ChunkSystemFeatures.forceNoSave(chunk);
++        final boolean forceNoSaveChunk = PlatformHooks.get().forceNoSave(chunk);
+ 
+         // can only synchronously save worldgen chunks during shutdown
+         boolean canSaveChunk = !forceNoSaveChunk && (chunk != null && ((shutdown || chunk instanceof LevelChunk) && chunk.isUnsaved()));
+@@ -1717,106 +1731,55 @@ public final class NewChunkHolder {
+             }
+         }
+ 
+-        return executedUnloadTask | canSaveChunk | canSaveEntities | canSavePOI ? new SaveStat(executedUnloadTask || canSaveChunk, canSaveEntities, canSavePOI): null;
+-    }
+-
+-    static final class AsyncChunkSerializeTask implements Runnable {
+-
+-        private final ServerLevel world;
+-        private final ChunkAccess chunk;
+-        private final AsyncChunkSaveData asyncSaveData;
+-        private final NewChunkHolder toComplete;
+-
+-        public AsyncChunkSerializeTask(final ServerLevel world, final ChunkAccess chunk, final AsyncChunkSaveData asyncSaveData,
+-                                       final NewChunkHolder toComplete) {
+-            this.world = world;
+-            this.chunk = chunk;
+-            this.asyncSaveData = asyncSaveData;
+-            this.toComplete = toComplete;
+-        }
+-
+-        @Override
+-        public void run() {
+-            final CompoundTag toSerialize;
+-            try {
+-                toSerialize = ChunkSystemFeatures.saveChunkAsync(this.world, this.chunk, this.asyncSaveData);
+-            } catch (final Throwable throwable) {
+-                LOGGER.error("Failed to asynchronously save chunk " + this.chunk.getPos() + " for world '" + WorldUtil.getWorldName(this.world) + "', falling back to synchronous save", throwable);
+-                final ChunkPos pos = this.chunk.getPos();
+-                ((ChunkSystemServerLevel)this.world).moonrise$getChunkTaskScheduler().scheduleChunkTask(pos.x, pos.z, () -> {
+-                    final CompoundTag synchronousSave;
+-                    try {
+-                        synchronousSave = ChunkSystemFeatures.saveChunkAsync(AsyncChunkSerializeTask.this.world, AsyncChunkSerializeTask.this.chunk, AsyncChunkSerializeTask.this.asyncSaveData);
+-                    } catch (final Throwable throwable2) {
+-                        LOGGER.error("Failed to synchronously save chunk " + AsyncChunkSerializeTask.this.chunk.getPos() + " for world '" + WorldUtil.getWorldName(AsyncChunkSerializeTask.this.world) + "', chunk data will be lost", throwable2);
+-                        AsyncChunkSerializeTask.this.toComplete.completeAsyncUnloadDataSave(RegionFileIOThread.RegionFileType.CHUNK_DATA, null);
+-                        return;
+-                    }
+-
+-                    AsyncChunkSerializeTask.this.toComplete.completeAsyncUnloadDataSave(RegionFileIOThread.RegionFileType.CHUNK_DATA, synchronousSave);
+-                    LOGGER.info("Successfully serialized chunk " + AsyncChunkSerializeTask.this.chunk.getPos() + " for world '" + WorldUtil.getWorldName(AsyncChunkSerializeTask.this.world) + "' synchronously");
+-
+-                }, PrioritisedExecutor.Priority.HIGHEST);
+-                return;
+-            }
+-            this.toComplete.completeAsyncUnloadDataSave(RegionFileIOThread.RegionFileType.CHUNK_DATA, toSerialize);
+-        }
+-
+-        @Override
+-        public String toString() {
+-            return "AsyncChunkSerializeTask{" +
+-                "chunk={pos=" + this.chunk.getPos() + ",world=\"" + WorldUtil.getWorldName(this.world) + "\"}" +
+-                "}";
+-        }
++        return executedUnloadTask | canSaveChunk | canSaveEntities | canSavePOI ?
++                new SaveStat(
++                        canSaveChunk | executedUnloadTasks[MoonriseRegionFileIO.RegionFileType.CHUNK_DATA.ordinal()],
++                        canSaveEntities | executedUnloadTasks[MoonriseRegionFileIO.RegionFileType.ENTITY_DATA.ordinal()],
++                        canSavePOI | executedUnloadTasks[MoonriseRegionFileIO.RegionFileType.POI_DATA.ordinal()]
++                )
++                : null;
+     }
+ 
+     private boolean saveChunk(final ChunkAccess chunk, final boolean unloading) {
+         if (!chunk.isUnsaved()) {
+             if (unloading) {
+-                this.completeAsyncUnloadDataSave(RegionFileIOThread.RegionFileType.CHUNK_DATA, null);
++                this.completeAsyncUnloadDataSave(MoonriseRegionFileIO.RegionFileType.CHUNK_DATA, null);
+             }
+             return false;
+         }
+-        boolean completing = false;
+-        boolean failedAsyncPrepare = false;
+         try {
+-            if (unloading && ChunkSystemFeatures.supportsAsyncChunkSave()) {
+-                try {
+-                    final AsyncChunkSaveData asyncSaveData = ChunkSystemFeatures.getAsyncSaveData(this.world, chunk);
++            final SerializableChunkData chunkData = SerializableChunkData.copyOf(this.world, chunk);
++            PlatformHooks.get().chunkSyncSave(this.world, chunk, chunkData);
+ 
+-                    final PrioritisedExecutor.PrioritisedTask task = this.scheduler.loadExecutor.createTask(new AsyncChunkSerializeTask(this.world, chunk, asyncSaveData, this));
++            chunk.tryMarkSaved();
+ 
+-                    this.chunkDataUnload.task().setTask(task);
++            final CallbackCompletable<CompoundTag> completable = new CallbackCompletable<>();
+ 
+-                    chunk.setUnsaved(false);
++            final Runnable run = () -> {
++                final CompoundTag data = chunkData.write();
+ 
+-                    task.queue();
++                completable.complete(data);
+ 
+-                    return true;
+-                } catch (final Throwable thr) {
+-                    LOGGER.error("Failed to prepare async chunk data (" + this.chunkX + "," + this.chunkZ + ") in world '" + WorldUtil.getWorldName(this.world) + "', falling back to synchronous save", thr);
+-                    failedAsyncPrepare = true;
+-                    // fall through to synchronous save
++                if (unloading) {
++                    NewChunkHolder.this.completeAsyncUnloadDataSave(MoonriseRegionFileIO.RegionFileType.CHUNK_DATA, data);
+                 }
+-            }
+-
+-            final CompoundTag save = ChunkSerializer.write(this.world, chunk);
++            };
+ 
++            final PrioritisedExecutor.PrioritisedTask task;
+             if (unloading) {
+-                completing = true;
+-                this.completeAsyncUnloadDataSave(RegionFileIOThread.RegionFileType.CHUNK_DATA, save);
+-                if (failedAsyncPrepare) {
+-                    LOGGER.info("Successfully serialized chunk data (" + this.chunkX + "," + this.chunkZ + ") in world '" + WorldUtil.getWorldName(this.world) + "' synchronously");
+-                }
++                this.chunkDataUnload.toRun().setRunnable(run);
++                task = this.chunkDataUnload.task();
+             } else {
+-                RegionFileIOThread.scheduleSave(this.world, this.chunkX, this.chunkZ, save, RegionFileIOThread.RegionFileType.CHUNK_DATA);
++                task = this.scheduler.saveExecutor.createTask(run);
+             }
+-            chunk.setUnsaved(false);
++
++            task.queue();
++
++            MoonriseRegionFileIO.scheduleSave(
++                this.world, this.chunkX, this.chunkZ, completable, task, MoonriseRegionFileIO.RegionFileType.CHUNK_DATA, Priority.NORMAL
++            );
+         } catch (final Throwable thr) {
+             LOGGER.error("Failed to save chunk data (" + this.chunkX + "," + this.chunkZ + ") in world '" + WorldUtil.getWorldName(this.world) + "'", thr);
+-            if (unloading && !completing) {
+-                this.completeAsyncUnloadDataSave(RegionFileIOThread.RegionFileType.CHUNK_DATA, null);
+-            }
+         }
+ 
+         return true;
+@@ -1834,7 +1797,7 @@ public final class NewChunkHolder {
+                     return false;
+                 }
+                 try {
+-                    mergeFrom = RegionFileIOThread.loadData(this.world, this.chunkX, this.chunkZ, RegionFileIOThread.RegionFileType.ENTITY_DATA, PrioritisedExecutor.Priority.BLOCKING);
++                    mergeFrom = MoonriseRegionFileIO.loadData(this.world, this.chunkX, this.chunkZ, MoonriseRegionFileIO.RegionFileType.ENTITY_DATA, Priority.BLOCKING);
+                 } catch (final Exception ex) {
+                     LOGGER.error("Cannot merge transient entities for chunk (" + this.chunkX + "," + this.chunkZ + ") in world '" + WorldUtil.getWorldName(this.world) + "', data on disk will be replaced", ex);
+                 }
+@@ -1853,7 +1816,7 @@ public final class NewChunkHolder {
+                 return false;
+             }
+ 
+-            RegionFileIOThread.scheduleSave(this.world, this.chunkX, this.chunkZ, save, RegionFileIOThread.RegionFileType.ENTITY_DATA);
++            MoonriseRegionFileIO.scheduleSave(this.world, this.chunkX, this.chunkZ, save, MoonriseRegionFileIO.RegionFileType.ENTITY_DATA);
+             this.lastEntitySaveNull = save == null;
+             if (unloading) {
+                 this.lastEntityUnload = save;
+@@ -1877,7 +1840,7 @@ public final class NewChunkHolder {
+                 return false;
+             }
+ 
+-            RegionFileIOThread.scheduleSave(this.world, this.chunkX, this.chunkZ, save, RegionFileIOThread.RegionFileType.POI_DATA);
++            MoonriseRegionFileIO.scheduleSave(this.world, this.chunkX, this.chunkZ, save, MoonriseRegionFileIO.RegionFileType.POI_DATA);
+             this.lastPoiSaveNull = save == null;
+             if (unloading) {
+                 this.poiDataUnload.completable().complete(save);
+@@ -1924,7 +1887,7 @@ public final class NewChunkHolder {
+         return element == null ? JsonNull.INSTANCE : new JsonPrimitive(element.toString());
+     }
+ 
+-    private static JsonObject serializeCompletable(final Completable<?> completable) {
++    private static JsonObject serializeCompletable(final CallbackCompletable<?> completable) {
+         final JsonObject ret = new JsonObject();
+ 
+         if (completable == null) {
+@@ -2019,13 +1982,13 @@ public final class NewChunkHolder {
+         ret.add("poi_unload_completable", serializeCompletable(poiDataUnload == null ? null : poiDataUnload.completable()));
+         ret.add("chunk_unload_completable", serializeCompletable(chunkDataUnload == null ? null : chunkDataUnload.completable()));
+ 
+-        final DelayedPrioritisedTask unloadTask = chunkDataUnload == null ? null : chunkDataUnload.task();
++        final PrioritisedExecutor.PrioritisedTask unloadTask = chunkDataUnload == null ? null : chunkDataUnload.task();
+         if (unloadTask == null) {
+             ret.addProperty("unload_task_priority", "null");
+-            ret.addProperty("unload_task_priority_raw", "null");
++            ret.addProperty("unload_task_suborder", Long.valueOf(0L));
+         } else {
+             ret.addProperty("unload_task_priority", Objects.toString(unloadTask.getPriority()));
+-            ret.addProperty("unload_task_priority_raw", Integer.valueOf(unloadTask.getPriorityInternal()));
++            ret.addProperty("unload_task_suborder", Long.valueOf(unloadTask.getSubOrder()));
+         }
+ 
+         ret.addProperty("killed", Boolean.valueOf(this.unloaded));
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/PriorityHolder.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/PriorityHolder.java
+index 261e09454f49d04eb159c984ec695d7c7aa6a3a8..6b468c621b74449a6218391f6477cf63cfc98c7c 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/PriorityHolder.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/PriorityHolder.java
+@@ -1,7 +1,7 @@
+ package ca.spottedleaf.moonrise.patches.chunk_system.scheduling;
+ 
+-import ca.spottedleaf.concurrentutil.executor.standard.PrioritisedExecutor;
+ import ca.spottedleaf.concurrentutil.util.ConcurrentUtil;
++import ca.spottedleaf.concurrentutil.util.Priority;
+ import java.lang.invoke.VarHandle;
+ 
+ public abstract class PriorityHolder {
+@@ -28,8 +28,8 @@ public abstract class PriorityHolder {
+         PRIORITY_HANDLE.set((PriorityHolder)this, (int)val);
+     }
+ 
+-    protected PriorityHolder(final PrioritisedExecutor.Priority priority) {
+-        if (!PrioritisedExecutor.Priority.isValidPriority(priority)) {
++    protected PriorityHolder(final Priority priority) {
++        if (!Priority.isValidPriority(priority)) {
+             throw new IllegalArgumentException("Invalid priority " + priority);
+         }
+         this.setPriorityPlain(priority.priority);
+@@ -69,7 +69,7 @@ public abstract class PriorityHolder {
+             return;
+         }
+ 
+-        this.scheduleTask(PrioritisedExecutor.Priority.getPriority(priority));
++        this.scheduleTask(Priority.getPriority(priority));
+ 
+         int failures = 0;
+         for (;;) {
+@@ -86,7 +86,7 @@ public abstract class PriorityHolder {
+                 return;
+             }
+ 
+-            this.setPriorityScheduled(PrioritisedExecutor.Priority.getPriority(priority));
++            this.setPriorityScheduled(Priority.getPriority(priority));
+ 
+             ++failures;
+             for (int i = 0; i < failures; ++i) {
+@@ -95,19 +95,19 @@ public abstract class PriorityHolder {
+         }
+     }
+ 
+-    public final PrioritisedExecutor.Priority getPriority() {
++    public final Priority getPriority() {
+         final int ret = this.getPriorityVolatile();
+         if ((ret & PRIORITY_EXECUTED) != 0) {
+-            return PrioritisedExecutor.Priority.COMPLETING;
++            return Priority.COMPLETING;
+         }
+         if ((ret & PRIORITY_SCHEDULED) != 0) {
+             return this.getScheduledPriority();
+         }
+-        return PrioritisedExecutor.Priority.getPriority(ret);
++        return Priority.getPriority(ret);
+     }
+ 
+-    public final void lowerPriority(final PrioritisedExecutor.Priority priority) {
+-        if (!PrioritisedExecutor.Priority.isValidPriority(priority)) {
++    public final void lowerPriority(final Priority priority) {
++        if (!Priority.isValidPriority(priority)) {
+             throw new IllegalArgumentException("Invalid priority " + priority);
+         }
+ 
+@@ -139,8 +139,8 @@ public abstract class PriorityHolder {
+         }
+     }
+ 
+-    public final void setPriority(final PrioritisedExecutor.Priority priority) {
+-        if (!PrioritisedExecutor.Priority.isValidPriority(priority)) {
++    public final void setPriority(final Priority priority) {
++        if (!Priority.isValidPriority(priority)) {
+             throw new IllegalArgumentException("Invalid priority " + priority);
+         }
+ 
+@@ -168,8 +168,8 @@ public abstract class PriorityHolder {
+         }
+     }
+ 
+-    public final void raisePriority(final PrioritisedExecutor.Priority priority) {
+-        if (!PrioritisedExecutor.Priority.isValidPriority(priority)) {
++    public final void raisePriority(final Priority priority) {
++        if (!Priority.isValidPriority(priority)) {
+             throw new IllegalArgumentException("Invalid priority " + priority);
+         }
+ 
+@@ -203,13 +203,13 @@ public abstract class PriorityHolder {
+ 
+     protected abstract void cancelScheduled();
+ 
+-    protected abstract PrioritisedExecutor.Priority getScheduledPriority();
++    protected abstract Priority getScheduledPriority();
+ 
+-    protected abstract void scheduleTask(final PrioritisedExecutor.Priority priority);
++    protected abstract void scheduleTask(final Priority priority);
+ 
+-    protected abstract void lowerPriorityScheduled(final PrioritisedExecutor.Priority priority);
++    protected abstract void lowerPriorityScheduled(final Priority priority);
+ 
+-    protected abstract void setPriorityScheduled(final PrioritisedExecutor.Priority priority);
++    protected abstract void setPriorityScheduled(final Priority priority);
+ 
+-    protected abstract void raisePriorityScheduled(final PrioritisedExecutor.Priority priority);
++    protected abstract void raisePriorityScheduled(final Priority priority);
+ }
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/executor/RadiusAwarePrioritisedExecutor.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/executor/RadiusAwarePrioritisedExecutor.java
+index e0b26ccb63596748b80fc6a5e47e373ba811ba8b..5f4b99d8c5453f8ad2e600a57ea4e7dafa2d45f8 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/executor/RadiusAwarePrioritisedExecutor.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/executor/RadiusAwarePrioritisedExecutor.java
+@@ -1,10 +1,10 @@
+ package ca.spottedleaf.moonrise.patches.chunk_system.scheduling.executor;
+ 
+-import ca.spottedleaf.concurrentutil.executor.standard.PrioritisedExecutor;
++import ca.spottedleaf.concurrentutil.executor.PrioritisedExecutor;
++import ca.spottedleaf.concurrentutil.util.Priority;
+ import ca.spottedleaf.moonrise.common.util.CoordinateUtils;
+ import it.unimi.dsi.fastutil.longs.Long2ReferenceOpenHashMap;
+ import it.unimi.dsi.fastutil.objects.ReferenceOpenHashSet;
+-
+ import java.util.ArrayList;
+ import java.util.Comparator;
+ import java.util.List;
+@@ -16,15 +16,36 @@ public class RadiusAwarePrioritisedExecutor {
+         return Long.compare(t1.id, t2.id);
+     };
+ 
+-    private final DependencyTree[] queues = new DependencyTree[PrioritisedExecutor.Priority.TOTAL_SCHEDULABLE_PRIORITIES];
++    private final PrioritisedExecutor executor;
++    private final DependencyTree[] queues = new DependencyTree[Priority.TOTAL_SCHEDULABLE_PRIORITIES];
+     private static final int NO_TASKS_QUEUED = -1;
+     private int selectedQueue = NO_TASKS_QUEUED;
+     private boolean canQueueTasks = true;
+ 
+     public RadiusAwarePrioritisedExecutor(final PrioritisedExecutor executor, final int maxToSchedule) {
++        this.executor = executor;
++
+         for (int i = 0; i < this.queues.length; ++i) {
+-            this.queues[i] = new DependencyTree(this, executor, maxToSchedule, i);
++            this.queues[i] = new DependencyTree(this, executor, maxToSchedule);
++        }
++    }
++
++    public void setMaxToSchedule(final int maxToSchedule) {
++        final List<PrioritisedExecutor.PrioritisedTask> tasks;
++
++        synchronized (this) {
++            for (final DependencyTree dependencyTree : this.queues) {
++                dependencyTree.maxToSchedule = maxToSchedule;
++            }
++
++            if (this.selectedQueue == NO_TASKS_QUEUED || !this.canQueueTasks) {
++                return;
++            }
++
++            tasks = this.queues[this.selectedQueue].tryPushTasks();
+         }
++
++        scheduleTasks(tasks);
+     }
+ 
+     private boolean canQueueTasks() {
+@@ -56,7 +77,7 @@ public class RadiusAwarePrioritisedExecutor {
+         return null;
+     }
+ 
+-    private List<PrioritisedExecutor.PrioritisedTask> queue(final Task task, final PrioritisedExecutor.Priority priority) {
++    private List<PrioritisedExecutor.PrioritisedTask> queue(final Task task, final Priority priority) {
+         final int priorityId = priority.priority;
+         final DependencyTree queue = this.queues[priorityId];
+ 
+@@ -79,7 +100,7 @@ public class RadiusAwarePrioritisedExecutor {
+             return null;
+         }
+ 
+-        if (PrioritisedExecutor.Priority.isHigherPriority(priorityId, this.selectedQueue)) {
++        if (Priority.isHigherPriority(priorityId, this.selectedQueue)) {
+             // prevent the lower priority tree from queueing more tasks
+             this.canQueueTasks = false;
+             return null;
+@@ -90,7 +111,7 @@ public class RadiusAwarePrioritisedExecutor {
+     }
+ 
+     public PrioritisedExecutor.PrioritisedTask createTask(final int chunkX, final int chunkZ, final int radius,
+-                                                          final Runnable run, final PrioritisedExecutor.Priority priority) {
++                                                          final Runnable run, final Priority priority) {
+         if (radius < 0) {
+             throw new IllegalArgumentException("Radius must be > 0: " + radius);
+         }
+@@ -99,11 +120,11 @@ public class RadiusAwarePrioritisedExecutor {
+ 
+     public PrioritisedExecutor.PrioritisedTask createTask(final int chunkX, final int chunkZ, final int radius,
+                                                           final Runnable run) {
+-        return this.createTask(chunkX, chunkZ, radius, run, PrioritisedExecutor.Priority.NORMAL);
++        return this.createTask(chunkX, chunkZ, radius, run, Priority.NORMAL);
+     }
+ 
+     public PrioritisedExecutor.PrioritisedTask queueTask(final int chunkX, final int chunkZ, final int radius,
+-                                                         final Runnable run, final PrioritisedExecutor.Priority priority) {
++                                                         final Runnable run, final Priority priority) {
+         final PrioritisedExecutor.PrioritisedTask ret = this.createTask(chunkX, chunkZ, radius, run, priority);
+ 
+         ret.queue();
+@@ -120,15 +141,15 @@ public class RadiusAwarePrioritisedExecutor {
+         return ret;
+     }
+ 
+-    public PrioritisedExecutor.PrioritisedTask createInfiniteRadiusTask(final Runnable run, final PrioritisedExecutor.Priority priority) {
++    public PrioritisedExecutor.PrioritisedTask createInfiniteRadiusTask(final Runnable run, final Priority priority) {
+         return new Task(this, 0, 0, -1, run, priority);
+     }
+ 
+     public PrioritisedExecutor.PrioritisedTask createInfiniteRadiusTask(final Runnable run) {
+-        return this.createInfiniteRadiusTask(run, PrioritisedExecutor.Priority.NORMAL);
++        return this.createInfiniteRadiusTask(run, Priority.NORMAL);
+     }
+ 
+-    public PrioritisedExecutor.PrioritisedTask queueInfiniteRadiusTask(final Runnable run, final PrioritisedExecutor.Priority priority) {
++    public PrioritisedExecutor.PrioritisedTask queueInfiniteRadiusTask(final Runnable run, final Priority priority) {
+         final PrioritisedExecutor.PrioritisedTask ret = this.createInfiniteRadiusTask(run, priority);
+ 
+         ret.queue();
+@@ -137,20 +158,27 @@ public class RadiusAwarePrioritisedExecutor {
+     }
+ 
+     public PrioritisedExecutor.PrioritisedTask queueInfiniteRadiusTask(final Runnable run) {
+-        final PrioritisedExecutor.PrioritisedTask ret = this.createInfiniteRadiusTask(run, PrioritisedExecutor.Priority.NORMAL);
++        final PrioritisedExecutor.PrioritisedTask ret = this.createInfiniteRadiusTask(run, Priority.NORMAL);
+ 
+         ret.queue();
+ 
+         return ret;
+     }
+ 
++    private static void scheduleTasks(final List<PrioritisedExecutor.PrioritisedTask> toSchedule) {
++        if (toSchedule != null) {
++            for (int i = 0, len = toSchedule.size(); i < len; ++i) {
++                toSchedule.get(i).queue();
++            }
++        }
++    }
++
+     // all accesses must be synchronised by the radius aware object
+     private static final class DependencyTree {
+ 
+         private final RadiusAwarePrioritisedExecutor scheduler;
+         private final PrioritisedExecutor executor;
+-        private final int maxToSchedule;
+-        private final int treeIndex;
++        private int maxToSchedule;
+ 
+         private int currentlyExecuting;
+         private long idGenerator;
+@@ -163,11 +191,10 @@ public class RadiusAwarePrioritisedExecutor {
+         private final Long2ReferenceOpenHashMap<DependencyNode> nodeByPosition = new Long2ReferenceOpenHashMap<>();
+ 
+         public DependencyTree(final RadiusAwarePrioritisedExecutor scheduler, final PrioritisedExecutor executor,
+-                              final int maxToSchedule, final int treeIndex) {
++                              final int maxToSchedule) {
+             this.scheduler = scheduler;
+             this.executor = executor;
+             this.maxToSchedule = maxToSchedule;
+-            this.treeIndex = treeIndex;
+         }
+ 
+         public boolean hasWaitingTasks() {
+@@ -412,13 +439,13 @@ public class RadiusAwarePrioritisedExecutor {
+         private final int chunkZ;
+         private final int radius;
+         private Runnable run;
+-        private PrioritisedExecutor.Priority priority;
++        private Priority priority;
+ 
+         private DependencyNode dependencyNode;
+         private PrioritisedExecutor.PrioritisedTask queuedTask;
+ 
+         private Task(final RadiusAwarePrioritisedExecutor scheduler, final int chunkX, final int chunkZ, final int radius,
+-                     final Runnable run, final PrioritisedExecutor.Priority priority) {
++                     final Runnable run, final Priority priority) {
+             this.scheduler = scheduler;
+             this.chunkX = chunkX;
+             this.chunkZ = chunkZ;
+@@ -441,14 +468,6 @@ public class RadiusAwarePrioritisedExecutor {
+             run.run();
+         }
+ 
+-        private static void scheduleTasks(final List<PrioritisedExecutor.PrioritisedTask> toSchedule) {
+-            if (toSchedule != null) {
+-                for (int i = 0, len = toSchedule.size(); i < len; ++i) {
+-                    toSchedule.get(i).queue();
+-                }
+-            }
+-        }
+-
+         private void returnNode() {
+             final List<PrioritisedExecutor.PrioritisedTask> toSchedule;
+             synchronized (this.scheduler) {
+@@ -460,6 +479,11 @@ public class RadiusAwarePrioritisedExecutor {
+             scheduleTasks(toSchedule);
+         }
+ 
++        @Override
++        public PrioritisedExecutor getExecutor() {
++            return this.scheduler.executor;
++        }
++
+         @Override
+         public void run() {
+             final Runnable run = this.run;
+@@ -475,7 +499,7 @@ public class RadiusAwarePrioritisedExecutor {
+         public boolean queue() {
+             final List<PrioritisedExecutor.PrioritisedTask> toSchedule;
+             synchronized (this.scheduler) {
+-                if (this.queuedTask != null || this.dependencyNode != null || this.priority == PrioritisedExecutor.Priority.COMPLETING) {
++                if (this.queuedTask != null || this.dependencyNode != null || this.priority == Priority.COMPLETING) {
+                     return false;
+                 }
+ 
+@@ -486,16 +510,23 @@ public class RadiusAwarePrioritisedExecutor {
+             return true;
+         }
+ 
++        @Override
++        public boolean isQueued() {
++            synchronized (this.scheduler) {
++                return (this.queuedTask != null || this.dependencyNode != null) && this.priority != Priority.COMPLETING;
++            }
++        }
++
+         @Override
+         public boolean cancel() {
+             final PrioritisedExecutor.PrioritisedTask task;
+             synchronized (this.scheduler) {
+                 if ((task = this.queuedTask) == null) {
+-                    if (this.priority == PrioritisedExecutor.Priority.COMPLETING) {
++                    if (this.priority == Priority.COMPLETING) {
+                         return false;
+                     }
+ 
+-                    this.priority = PrioritisedExecutor.Priority.COMPLETING;
++                    this.priority = Priority.COMPLETING;
+                     if (this.dependencyNode != null) {
+                         this.dependencyNode.purged = true;
+                         this.dependencyNode = null;
+@@ -519,11 +550,11 @@ public class RadiusAwarePrioritisedExecutor {
+             final PrioritisedExecutor.PrioritisedTask task;
+             synchronized (this.scheduler) {
+                 if ((task = this.queuedTask) == null) {
+-                    if (this.priority == PrioritisedExecutor.Priority.COMPLETING) {
++                    if (this.priority == Priority.COMPLETING) {
+                         return false;
+                     }
+ 
+-                    this.priority = PrioritisedExecutor.Priority.COMPLETING;
++                    this.priority = Priority.COMPLETING;
+                     if (this.dependencyNode != null) {
+                         this.dependencyNode.purged = true;
+                         this.dependencyNode = null;
+@@ -543,7 +574,7 @@ public class RadiusAwarePrioritisedExecutor {
+         }
+ 
+         @Override
+-        public PrioritisedExecutor.Priority getPriority() {
++        public Priority getPriority() {
+             final PrioritisedExecutor.PrioritisedTask task;
+             synchronized (this.scheduler) {
+                 if ((task = this.queuedTask) == null) {
+@@ -555,8 +586,8 @@ public class RadiusAwarePrioritisedExecutor {
+         }
+ 
+         @Override
+-        public boolean setPriority(final PrioritisedExecutor.Priority priority) {
+-            if (!PrioritisedExecutor.Priority.isValidPriority(priority)) {
++        public boolean setPriority(final Priority priority) {
++            if (!Priority.isValidPriority(priority)) {
+                 throw new IllegalArgumentException("Invalid priority " + priority);
+             }
+ 
+@@ -564,7 +595,7 @@ public class RadiusAwarePrioritisedExecutor {
+             List<PrioritisedExecutor.PrioritisedTask> toSchedule = null;
+             synchronized (this.scheduler) {
+                 if ((task = this.queuedTask) == null) {
+-                    if (this.priority == PrioritisedExecutor.Priority.COMPLETING) {
++                    if (this.priority == Priority.COMPLETING) {
+                         return false;
+                     }
+ 
+@@ -592,8 +623,8 @@ public class RadiusAwarePrioritisedExecutor {
+         }
+ 
+         @Override
+-        public boolean raisePriority(final PrioritisedExecutor.Priority priority) {
+-            if (!PrioritisedExecutor.Priority.isValidPriority(priority)) {
++        public boolean raisePriority(final Priority priority) {
++            if (!Priority.isValidPriority(priority)) {
+                 throw new IllegalArgumentException("Invalid priority " + priority);
+             }
+ 
+@@ -601,7 +632,7 @@ public class RadiusAwarePrioritisedExecutor {
+             List<PrioritisedExecutor.PrioritisedTask> toSchedule = null;
+             synchronized (this.scheduler) {
+                 if ((task = this.queuedTask) == null) {
+-                    if (this.priority == PrioritisedExecutor.Priority.COMPLETING) {
++                    if (this.priority == Priority.COMPLETING) {
+                         return false;
+                     }
+ 
+@@ -629,8 +660,8 @@ public class RadiusAwarePrioritisedExecutor {
+         }
+ 
+         @Override
+-        public boolean lowerPriority(final PrioritisedExecutor.Priority priority) {
+-            if (!PrioritisedExecutor.Priority.isValidPriority(priority)) {
++        public boolean lowerPriority(final Priority priority) {
++            if (!Priority.isValidPriority(priority)) {
+                 throw new IllegalArgumentException("Invalid priority " + priority);
+             }
+ 
+@@ -638,7 +669,7 @@ public class RadiusAwarePrioritisedExecutor {
+             List<PrioritisedExecutor.PrioritisedTask> toSchedule = null;
+             synchronized (this.scheduler) {
+                 if ((task = this.queuedTask) == null) {
+-                    if (this.priority == PrioritisedExecutor.Priority.COMPLETING) {
++                    if (this.priority == Priority.COMPLETING) {
+                         return false;
+                     }
+ 
+@@ -664,5 +695,35 @@ public class RadiusAwarePrioritisedExecutor {
+ 
+             return true;
+         }
++
++        @Override
++        public long getSubOrder() {
++            // TODO implement
++            return 0;
++        }
++
++        @Override
++        public boolean setSubOrder(final long subOrder) {
++            // TODO implement
++            return false;
++        }
++
++        @Override
++        public boolean raiseSubOrder(final long subOrder) {
++            // TODO implement
++            return false;
++        }
++
++        @Override
++        public boolean lowerSubOrder(final long subOrder) {
++            // TODO implement
++            return false;
++        }
++
++        @Override
++        public boolean setPriorityAndSubOrder(final Priority priority, final long subOrder) {
++            // TODO implement
++            return this.setPriority(priority);
++        }
+     }
+-}
+\ No newline at end of file
++}
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/task/ChunkFullTask.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/task/ChunkFullTask.java
+index fbdf721e8b4cfe6cef4ee60c53c680cbfc858d88..98382575eb6cd48aa163264e4935c812db1f1aff 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/task/ChunkFullTask.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/task/ChunkFullTask.java
+@@ -1,7 +1,9 @@
+ package ca.spottedleaf.moonrise.patches.chunk_system.scheduling.task;
+ 
+-import ca.spottedleaf.concurrentutil.executor.standard.PrioritisedExecutor;
++import ca.spottedleaf.concurrentutil.executor.PrioritisedExecutor;
+ import ca.spottedleaf.concurrentutil.util.ConcurrentUtil;
++import ca.spottedleaf.concurrentutil.util.Priority;
++import ca.spottedleaf.moonrise.common.PlatformHooks;
+ import ca.spottedleaf.moonrise.patches.chunk_system.level.ChunkSystemServerLevel;
+ import ca.spottedleaf.moonrise.patches.chunk_system.level.chunk.ChunkSystemLevelChunk;
+ import ca.spottedleaf.moonrise.patches.chunk_system.level.poi.ChunkSystemPoiManager;
+@@ -29,7 +31,7 @@ public final class ChunkFullTask extends ChunkProgressionTask implements Runnabl
+     private final PrioritisedExecutor.PrioritisedTask convertToFullTask;
+ 
+     public ChunkFullTask(final ChunkTaskScheduler scheduler, final ServerLevel world, final int chunkX, final int chunkZ,
+-                         final NewChunkHolder chunkHolder, final ChunkAccess fromChunk, final PrioritisedExecutor.Priority priority) {
++                         final NewChunkHolder chunkHolder, final ChunkAccess fromChunk, final Priority priority) {
+         super(scheduler, world, chunkX, chunkZ);
+         this.chunkHolder = chunkHolder;
+         this.fromChunk = fromChunk;
+@@ -43,6 +45,8 @@ public final class ChunkFullTask extends ChunkProgressionTask implements Runnabl
+ 
+     @Override
+     public void run() {
++        final PlatformHooks platformHooks = PlatformHooks.get();
++
+         // See Vanilla ChunkPyramid#LOADING_PYRAMID.FULL for what this function should be doing
+         final LevelChunk chunk;
+         try {
+@@ -61,7 +65,7 @@ public final class ChunkFullTask extends ChunkProgressionTask implements Runnabl
+                 final ServerLevel world = this.world;
+                 final ProtoChunk protoChunk = (ProtoChunk)this.fromChunk;
+                 chunk = new LevelChunk(this.world, protoChunk, (final LevelChunk unused) -> {
+-                    ChunkStatusTasks.postLoadProtoChunk(world, protoChunk.getEntities(), protoChunk.getPos()); // Paper - pass chunk pos
++                    ChunkStatusTasks.postLoadProtoChunk(world, protoChunk.getEntities());
+                 });
+                 this.chunkHolder.replaceProtoChunk(new ImposterProtoChunk(chunk, false));
+             }
+@@ -71,16 +75,21 @@ public final class ChunkFullTask extends ChunkProgressionTask implements Runnabl
+             final NewChunkHolder chunkHolder = this.chunkHolder;
+ 
+             chunk.setFullStatus(chunkHolder::getChunkStatus);
+-            chunk.runPostLoad();
+-            // Unlike Vanilla, we load the entity chunk here, as we load the NBT in empty status (unlike Vanilla)
+-            // This brings entity addition back in line with older versions of the game
+-            // Since we load the NBT in the empty status, this will never block for I/O
+-            ((ChunkSystemServerLevel)this.world).moonrise$getChunkTaskScheduler().chunkHolderManager.getOrCreateEntityChunk(this.chunkX, this.chunkZ, false);
+-
+-            // we don't need the entitiesInLevel, not sure why it's there
+-            chunk.setLoaded(true);
+-            chunk.registerAllBlockEntitiesAfterLevelLoad();
+-            chunk.registerTickContainerInLevel(this.world);
++            try {
++                platformHooks.setCurrentlyLoading(this.chunkHolder.vanillaChunkHolder, chunk);
++                chunk.runPostLoad();
++                // Unlike Vanilla, we load the entity chunk here, as we load the NBT in empty status (unlike Vanilla)
++                // This brings entity addition back in line with older versions of the game
++                // Since we load the NBT in the empty status, this will never block for I/O
++                ((ChunkSystemServerLevel)this.world).moonrise$getChunkTaskScheduler().chunkHolderManager.getOrCreateEntityChunk(this.chunkX, this.chunkZ, false);
++                chunk.setLoaded(true);
++                chunk.registerAllBlockEntitiesAfterLevelLoad();
++                chunk.registerTickContainerInLevel(this.world);
++                chunk.setUnsavedListener(this.world.getChunkSource().chunkMap.worldGenContext.unsavedListener());
++                platformHooks.chunkFullStatusComplete(chunk, (ProtoChunk)this.fromChunk);
++            } finally {
++                platformHooks.setCurrentlyLoading(this.chunkHolder.vanillaChunkHolder, null);
++            }
+         } catch (final Throwable throwable) {
+             this.complete(null, throwable);
+             return;
+@@ -112,29 +121,29 @@ public final class ChunkFullTask extends ChunkProgressionTask implements Runnabl
+     }
+ 
+     @Override
+-    public PrioritisedExecutor.Priority getPriority() {
++    public Priority getPriority() {
+         return this.convertToFullTask.getPriority();
+     }
+ 
+     @Override
+-    public void lowerPriority(final PrioritisedExecutor.Priority priority) {
+-        if (!PrioritisedExecutor.Priority.isValidPriority(priority)) {
++    public void lowerPriority(final Priority priority) {
++        if (!Priority.isValidPriority(priority)) {
+             throw new IllegalArgumentException("Invalid priority " + priority);
+         }
+         this.convertToFullTask.lowerPriority(priority);
+     }
+ 
+     @Override
+-    public void setPriority(final PrioritisedExecutor.Priority priority) {
+-        if (!PrioritisedExecutor.Priority.isValidPriority(priority)) {
++    public void setPriority(final Priority priority) {
++        if (!Priority.isValidPriority(priority)) {
+             throw new IllegalArgumentException("Invalid priority " + priority);
+         }
+         this.convertToFullTask.setPriority(priority);
+     }
+ 
+     @Override
+-    public void raisePriority(final PrioritisedExecutor.Priority priority) {
+-        if (!PrioritisedExecutor.Priority.isValidPriority(priority)) {
++    public void raisePriority(final Priority priority) {
++        if (!Priority.isValidPriority(priority)) {
+             throw new IllegalArgumentException("Invalid priority " + priority);
+         }
+         this.convertToFullTask.raisePriority(priority);
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/task/ChunkLightTask.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/task/ChunkLightTask.java
+index 7c2e6752228fac175c4aa97fa3d817b8a938922f..4538ccfaea83d217ed85eaf16e82393c7f286489 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/task/ChunkLightTask.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/task/ChunkLightTask.java
+@@ -1,6 +1,6 @@
+ package ca.spottedleaf.moonrise.patches.chunk_system.scheduling.task;
+ 
+-import ca.spottedleaf.concurrentutil.executor.standard.PrioritisedExecutor;
++import ca.spottedleaf.concurrentutil.util.Priority;
+ import ca.spottedleaf.moonrise.common.util.WorldUtil;
+ import ca.spottedleaf.moonrise.patches.chunk_system.scheduling.ChunkTaskScheduler;
+ import ca.spottedleaf.moonrise.patches.chunk_system.scheduling.PriorityHolder;
+@@ -25,9 +25,9 @@ public final class ChunkLightTask extends ChunkProgressionTask {
+     private final LightTaskPriorityHolder priorityHolder;
+ 
+     public ChunkLightTask(final ChunkTaskScheduler scheduler, final ServerLevel world, final int chunkX, final int chunkZ,
+-                          final ChunkAccess chunk, final PrioritisedExecutor.Priority priority) {
++                          final ChunkAccess chunk, final Priority priority) {
+         super(scheduler, world, chunkX, chunkZ);
+-        if (!PrioritisedExecutor.Priority.isValidPriority(priority)) {
++        if (!Priority.isValidPriority(priority)) {
+             throw new IllegalArgumentException("Invalid priority " + priority);
+         }
+         this.priorityHolder = new LightTaskPriorityHolder(priority, this);
+@@ -55,22 +55,22 @@ public final class ChunkLightTask extends ChunkProgressionTask {
+     }
+ 
+     @Override
+-    public PrioritisedExecutor.Priority getPriority() {
++    public Priority getPriority() {
+         return this.priorityHolder.getPriority();
+     }
+ 
+     @Override
+-    public void lowerPriority(final PrioritisedExecutor.Priority priority) {
++    public void lowerPriority(final Priority priority) {
+         this.priorityHolder.raisePriority(priority);
+     }
+ 
+     @Override
+-    public void setPriority(final PrioritisedExecutor.Priority priority) {
++    public void setPriority(final Priority priority) {
+         this.priorityHolder.setPriority(priority);
+     }
+ 
+     @Override
+-    public void raisePriority(final PrioritisedExecutor.Priority priority) {
++    public void raisePriority(final Priority priority) {
+         this.priorityHolder.raisePriority(priority);
+     }
+ 
+@@ -78,7 +78,7 @@ public final class ChunkLightTask extends ChunkProgressionTask {
+ 
+         private final ChunkLightTask task;
+ 
+-        private LightTaskPriorityHolder(final PrioritisedExecutor.Priority priority, final ChunkLightTask task) {
++        private LightTaskPriorityHolder(final Priority priority, final ChunkLightTask task) {
+             super(priority);
+             this.task = task;
+         }
+@@ -90,13 +90,13 @@ public final class ChunkLightTask extends ChunkProgressionTask {
+         }
+ 
+         @Override
+-        protected PrioritisedExecutor.Priority getScheduledPriority() {
++        protected Priority getScheduledPriority() {
+             final ChunkLightTask task = this.task;
+             return ((StarLightLightingProvider)task.world.getChunkSource().getLightEngine()).starlight$getLightEngine().getServerLightQueue().getPriority(task.chunkX, task.chunkZ);
+         }
+ 
+         @Override
+-        protected void scheduleTask(final PrioritisedExecutor.Priority priority) {
++        protected void scheduleTask(final Priority priority) {
+             final ChunkLightTask task = this.task;
+             final StarLightInterface starLightInterface = ((StarLightLightingProvider)task.world.getChunkSource().getLightEngine()).starlight$getLightEngine();
+             final StarLightInterface.ServerLightQueue lightQueue = starLightInterface.getServerLightQueue();
+@@ -105,7 +105,7 @@ public final class ChunkLightTask extends ChunkProgressionTask {
+         }
+ 
+         @Override
+-        protected void lowerPriorityScheduled(final PrioritisedExecutor.Priority priority) {
++        protected void lowerPriorityScheduled(final Priority priority) {
+             final ChunkLightTask task = this.task;
+             final StarLightInterface starLightInterface = ((StarLightLightingProvider)task.world.getChunkSource().getLightEngine()).starlight$getLightEngine();
+             final StarLightInterface.ServerLightQueue lightQueue = starLightInterface.getServerLightQueue();
+@@ -113,7 +113,7 @@ public final class ChunkLightTask extends ChunkProgressionTask {
+         }
+ 
+         @Override
+-        protected void setPriorityScheduled(final PrioritisedExecutor.Priority priority) {
++        protected void setPriorityScheduled(final Priority priority) {
+             final ChunkLightTask task = this.task;
+             final StarLightInterface starLightInterface = ((StarLightLightingProvider)task.world.getChunkSource().getLightEngine()).starlight$getLightEngine();
+             final StarLightInterface.ServerLightQueue lightQueue = starLightInterface.getServerLightQueue();
+@@ -121,7 +121,7 @@ public final class ChunkLightTask extends ChunkProgressionTask {
+         }
+ 
+         @Override
+-        protected void raisePriorityScheduled(final PrioritisedExecutor.Priority priority) {
++        protected void raisePriorityScheduled(final Priority priority) {
+             final ChunkLightTask task = this.task;
+             final StarLightInterface starLightInterface = ((StarLightLightingProvider)task.world.getChunkSource().getLightEngine()).starlight$getLightEngine();
+             final StarLightInterface.ServerLightQueue lightQueue = starLightInterface.getServerLightQueue();
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/task/ChunkLoadTask.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/task/ChunkLoadTask.java
+index 1ab93f219246d0b4dcdfd0f685f47c13091425f8..e0a88615a8b6d58191f29b1ff1a26427f0a4c1a6 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/task/ChunkLoadTask.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/task/ChunkLoadTask.java
+@@ -1,12 +1,13 @@
+ package ca.spottedleaf.moonrise.patches.chunk_system.scheduling.task;
+ 
+ import ca.spottedleaf.concurrentutil.collection.MultiThreadedQueue;
+-import ca.spottedleaf.concurrentutil.executor.standard.PrioritisedExecutor;
++import ca.spottedleaf.concurrentutil.executor.PrioritisedExecutor;
+ import ca.spottedleaf.concurrentutil.lock.ReentrantAreaLock;
+ import ca.spottedleaf.concurrentutil.util.ConcurrentUtil;
++import ca.spottedleaf.concurrentutil.util.Priority;
++import ca.spottedleaf.moonrise.common.PlatformHooks;
+ import ca.spottedleaf.moonrise.patches.chunk_system.ChunkSystemConverters;
+-import ca.spottedleaf.moonrise.patches.chunk_system.ChunkSystemFeatures;
+-import ca.spottedleaf.moonrise.patches.chunk_system.io.RegionFileIOThread;
++import ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO;
+ import ca.spottedleaf.moonrise.patches.chunk_system.level.poi.PoiChunk;
+ import ca.spottedleaf.moonrise.patches.chunk_system.scheduling.ChunkTaskScheduler;
+ import ca.spottedleaf.moonrise.patches.chunk_system.scheduling.NewChunkHolder;
+@@ -18,7 +19,7 @@ import net.minecraft.world.level.chunk.ChunkAccess;
+ import net.minecraft.world.level.chunk.ProtoChunk;
+ import net.minecraft.world.level.chunk.UpgradeData;
+ import net.minecraft.world.level.chunk.status.ChunkStatus;
+-import net.minecraft.world.level.chunk.storage.ChunkSerializer;
++import net.minecraft.world.level.chunk.storage.SerializableChunkData;
+ import net.minecraft.world.level.levelgen.blending.BlendingData;
+ import org.slf4j.Logger;
+ import org.slf4j.LoggerFactory;
+@@ -41,7 +42,7 @@ public final class ChunkLoadTask extends ChunkProgressionTask {
+     private final AtomicInteger taskCountToComplete = new AtomicInteger(3); // one for poi, one for entity, and one for chunk data
+ 
+     public ChunkLoadTask(final ChunkTaskScheduler scheduler, final ServerLevel world, final int chunkX, final int chunkZ,
+-                         final NewChunkHolder chunkHolder, final PrioritisedExecutor.Priority priority) {
++                         final NewChunkHolder chunkHolder, final Priority priority) {
+         super(scheduler, world, chunkX, chunkZ);
+         this.chunkHolder = chunkHolder;
+         this.loadTask = new ChunkDataLoadTask(scheduler, world, chunkX, chunkZ, priority);
+@@ -170,12 +171,12 @@ public final class ChunkLoadTask extends ChunkProgressionTask {
+     }
+ 
+     @Override
+-    public PrioritisedExecutor.Priority getPriority() {
++    public Priority getPriority() {
+         return this.loadTask.getPriority();
+     }
+ 
+     @Override
+-    public void lowerPriority(final PrioritisedExecutor.Priority priority) {
++    public void lowerPriority(final Priority priority) {
+         final EntityDataLoadTask entityLoad = this.chunkHolder.getEntityDataLoadTask();
+         if (entityLoad != null) {
+             entityLoad.lowerPriority(priority);
+@@ -191,7 +192,7 @@ public final class ChunkLoadTask extends ChunkProgressionTask {
+     }
+ 
+     @Override
+-    public void setPriority(final PrioritisedExecutor.Priority priority) {
++    public void setPriority(final Priority priority) {
+         final EntityDataLoadTask entityLoad = this.chunkHolder.getEntityDataLoadTask();
+         if (entityLoad != null) {
+             entityLoad.setPriority(priority);
+@@ -207,7 +208,7 @@ public final class ChunkLoadTask extends ChunkProgressionTask {
+     }
+ 
+     @Override
+-    public void raisePriority(final PrioritisedExecutor.Priority priority) {
++    public void raisePriority(final Priority priority) {
+         final EntityDataLoadTask entityLoad = this.chunkHolder.getEntityDataLoadTask();
+         if (entityLoad != null) {
+             entityLoad.raisePriority(priority);
+@@ -231,8 +232,8 @@ public final class ChunkLoadTask extends ChunkProgressionTask {
+         protected static final VarHandle COMPLETED_HANDLE = ConcurrentUtil.getVarHandle(CallbackDataLoadTask.class, "completed", boolean.class);
+ 
+         protected CallbackDataLoadTask(final ChunkTaskScheduler scheduler, final ServerLevel world, final int chunkX,
+-                                       final int chunkZ, final RegionFileIOThread.RegionFileType type,
+-                                       final PrioritisedExecutor.Priority priority) {
++                                       final int chunkZ, final MoonriseRegionFileIO.RegionFileType type,
++                                       final Priority priority) {
+             super(scheduler, world, chunkX, chunkZ, type, priority);
+         }
+ 
+@@ -272,10 +273,13 @@ public final class ChunkLoadTask extends ChunkProgressionTask {
+         }
+     }
+ 
+-    private static final class ChunkDataLoadTask extends CallbackDataLoadTask<CompoundTag, ChunkAccess> {
++
++    private static record ReadChunk(ProtoChunk protoChunk, SerializableChunkData chunkData) {}
++
++    private static final class ChunkDataLoadTask extends CallbackDataLoadTask<ReadChunk, ChunkAccess> {
+         private ChunkDataLoadTask(final ChunkTaskScheduler scheduler, final ServerLevel world, final int chunkX,
+-                                    final int chunkZ, final PrioritisedExecutor.Priority priority) {
+-            super(scheduler, world, chunkX, chunkZ, RegionFileIOThread.RegionFileType.CHUNK_DATA, priority);
++                                  final int chunkZ, final Priority priority) {
++            super(scheduler, world, chunkX, chunkZ, MoonriseRegionFileIO.RegionFileType.CHUNK_DATA, priority);
+         }
+ 
+         @Override
+@@ -289,40 +293,42 @@ public final class ChunkLoadTask extends ChunkProgressionTask {
+         }
+ 
+         @Override
+-        protected PrioritisedExecutor.PrioritisedTask createOffMain(final Runnable run, final PrioritisedExecutor.Priority priority) {
++        protected PrioritisedExecutor.PrioritisedTask createOffMain(final Runnable run, final Priority priority) {
+             return this.scheduler.loadExecutor.createTask(run, priority);
+         }
+ 
+         @Override
+-        protected PrioritisedExecutor.PrioritisedTask createOnMain(final Runnable run, final PrioritisedExecutor.Priority priority) {
++        protected PrioritisedExecutor.PrioritisedTask createOnMain(final Runnable run, final Priority priority) {
+             return this.scheduler.createChunkTask(this.chunkX, this.chunkZ, run, priority);
+         }
+ 
+         @Override
+-        protected TaskResult<ChunkAccess, Throwable> completeOnMainOffMain(final CompoundTag data, final Throwable throwable) {
++        protected TaskResult<ChunkAccess, Throwable> completeOnMainOffMain(final ReadChunk data, final Throwable throwable) {
+             if (throwable != null) {
+                 return new TaskResult<>(null, throwable);
+             }
+-            if (data == null) {
++
++            if (data == null || data.protoChunk() == null) {
+                 return new TaskResult<>(this.getEmptyChunk(), null);
+             }
+ 
+-            if (ChunkSystemFeatures.supportsAsyncChunkDeserialization()) {
+-                return this.deserialize(data);
++            if (!PlatformHooks.get().hasMainChunkLoadHook()) {
++                return new TaskResult<>(data.protoChunk(), null);
+             }
+-            // need to deserialize on main thread
++
++            // need to invoke the callback for loading on the main thread
+             return null;
+         }
+ 
+         private ProtoChunk getEmptyChunk() {
+             return new ProtoChunk(
+                 new ChunkPos(this.chunkX, this.chunkZ), UpgradeData.EMPTY, this.world,
+-                this.world.registryAccess().registryOrThrow(Registries.BIOME), (BlendingData)null
++                this.world.registryAccess().lookupOrThrow(Registries.BIOME), (BlendingData)null
+             );
+         }
+ 
+         @Override
+-        protected TaskResult<CompoundTag, Throwable> runOffMain(final CompoundTag data, final Throwable throwable) {
++        protected TaskResult<ReadChunk, Throwable> runOffMain(final CompoundTag data, final Throwable throwable) {
+             if (throwable != null) {
+                 LOGGER.error("Failed to load chunk data for task: " + this.toString() + ", chunk data will be lost", throwable);
+                 return new TaskResult<>(null, null);
+@@ -334,42 +340,43 @@ public final class ChunkLoadTask extends ChunkProgressionTask {
+ 
+             try {
+                 // run converters
+-                final CompoundTag converted = this.world.getChunkSource().chunkMap.upgradeChunkTag(data, new net.minecraft.world.level.ChunkPos(this.chunkX, this.chunkZ));
++                final CompoundTag converted = this.world.getChunkSource().chunkMap.upgradeChunkTag(data);
+ 
+-                return new TaskResult<>(converted, null);
+-            } catch (final Throwable thr2) {
+-                LOGGER.error("Failed to parse chunk data for task: " + this.toString() + ", chunk data will be lost", thr2);
+-                return new TaskResult<>(null, null);
+-            }
+-        }
++                // unpack the data
++                final SerializableChunkData chunkData = SerializableChunkData.parse(
++                    this.world, this.world.registryAccess(), converted
++                );
+ 
+-        private TaskResult<ChunkAccess, Throwable> deserialize(final CompoundTag data) {
+-            try {
+-                final ChunkAccess deserialized = ChunkSerializer.read(
+-                        this.world, this.world.getPoiManager(), this.world.getChunkSource().chunkMap.storageInfo(), new ChunkPos(this.chunkX, this.chunkZ), data
++                if (chunkData == null) {
++                    LOGGER.error("Deserialized chunk for task: " + this.toString() + " produced null, chunk data will be lost?");
++                }
++
++                // read into ProtoChunk
++                final ProtoChunk chunk = chunkData == null ? null : chunkData.read(
++                    this.world, this.world.getPoiManager(), this.world.getChunkSource().chunkMap.storageInfo(),
++                    new ChunkPos(this.chunkX, this.chunkZ)
+                 );
+-                return new TaskResult<>(deserialized, null);
++
++                return new TaskResult<>(new ReadChunk(chunk, chunkData), null);
+             } catch (final Throwable thr2) {
+                 LOGGER.error("Failed to parse chunk data for task: " + this.toString() + ", chunk data will be lost", thr2);
+-                return new TaskResult<>(this.getEmptyChunk(), null);
++                return new TaskResult<>(null, null);
+             }
+         }
+ 
+         @Override
+-        protected TaskResult<ChunkAccess, Throwable> runOnMain(final CompoundTag data, final Throwable throwable) {
+-            // data != null && throwable == null
+-            if (ChunkSystemFeatures.supportsAsyncChunkDeserialization()) {
+-                throw new UnsupportedOperationException();
+-            }
+-            return this.deserialize(data);
++        protected TaskResult<ChunkAccess, Throwable> runOnMain(final ReadChunk data, final Throwable throwable) {
++            PlatformHooks.get().mainChunkLoad(data.protoChunk(), data.chunkData());
++
++            return new TaskResult<>(data.protoChunk(), null);
+         }
+     }
+ 
+     public static final class PoiDataLoadTask extends CallbackDataLoadTask<PoiChunk, PoiChunk> {
+ 
+         public PoiDataLoadTask(final ChunkTaskScheduler scheduler, final ServerLevel world, final int chunkX,
+-                               final int chunkZ, final PrioritisedExecutor.Priority priority) {
+-            super(scheduler, world, chunkX, chunkZ, RegionFileIOThread.RegionFileType.POI_DATA, priority);
++                               final int chunkZ, final Priority priority) {
++            super(scheduler, world, chunkX, chunkZ, MoonriseRegionFileIO.RegionFileType.POI_DATA, priority);
+         }
+ 
+         @Override
+@@ -383,12 +390,12 @@ public final class ChunkLoadTask extends ChunkProgressionTask {
+         }
+ 
+         @Override
+-        protected PrioritisedExecutor.PrioritisedTask createOffMain(final Runnable run, final PrioritisedExecutor.Priority priority) {
++        protected PrioritisedExecutor.PrioritisedTask createOffMain(final Runnable run, final Priority priority) {
+             return this.scheduler.loadExecutor.createTask(run, priority);
+         }
+ 
+         @Override
+-        protected PrioritisedExecutor.PrioritisedTask createOnMain(final Runnable run, final PrioritisedExecutor.Priority priority) {
++        protected PrioritisedExecutor.PrioritisedTask createOnMain(final Runnable run, final Priority priority) {
+             throw new UnsupportedOperationException();
+         }
+ 
+@@ -430,8 +437,8 @@ public final class ChunkLoadTask extends ChunkProgressionTask {
+     public static final class EntityDataLoadTask extends CallbackDataLoadTask<CompoundTag, CompoundTag> {
+ 
+         public EntityDataLoadTask(final ChunkTaskScheduler scheduler, final ServerLevel world, final int chunkX,
+-                                  final int chunkZ, final PrioritisedExecutor.Priority priority) {
+-            super(scheduler, world, chunkX, chunkZ, RegionFileIOThread.RegionFileType.ENTITY_DATA, priority);
++                                  final int chunkZ, final Priority priority) {
++            super(scheduler, world, chunkX, chunkZ, MoonriseRegionFileIO.RegionFileType.ENTITY_DATA, priority);
+         }
+ 
+         @Override
+@@ -445,12 +452,12 @@ public final class ChunkLoadTask extends ChunkProgressionTask {
+         }
+ 
+         @Override
+-        protected PrioritisedExecutor.PrioritisedTask createOffMain(final Runnable run, final PrioritisedExecutor.Priority priority) {
++        protected PrioritisedExecutor.PrioritisedTask createOffMain(final Runnable run, final Priority priority) {
+             return this.scheduler.loadExecutor.createTask(run, priority);
+         }
+ 
+         @Override
+-        protected PrioritisedExecutor.PrioritisedTask createOnMain(final Runnable run, final PrioritisedExecutor.Priority priority) {
++        protected PrioritisedExecutor.PrioritisedTask createOnMain(final Runnable run, final Priority priority) {
+             throw new UnsupportedOperationException();
+         }
+ 
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/task/ChunkProgressionTask.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/task/ChunkProgressionTask.java
+index 70e900b0f9c131900bf8b3f3ecbfbd5df5361205..002ee365aa70d8e6a6e6bd5c95988bd17db4395a 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/task/ChunkProgressionTask.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/task/ChunkProgressionTask.java
+@@ -1,8 +1,8 @@
+ package ca.spottedleaf.moonrise.patches.chunk_system.scheduling.task;
+ 
+ import ca.spottedleaf.concurrentutil.collection.MultiThreadedQueue;
+-import ca.spottedleaf.concurrentutil.executor.standard.PrioritisedExecutor;
+ import ca.spottedleaf.concurrentutil.util.ConcurrentUtil;
++import ca.spottedleaf.concurrentutil.util.Priority;
+ import ca.spottedleaf.moonrise.common.util.WorldUtil;
+ import ca.spottedleaf.moonrise.patches.chunk_system.scheduling.ChunkTaskScheduler;
+ import net.minecraft.server.level.ServerLevel;
+@@ -46,15 +46,15 @@ public abstract class ChunkProgressionTask {
+     /* May be called multiple times */
+     public abstract void cancel();
+ 
+-    public abstract PrioritisedExecutor.Priority getPriority();
++    public abstract Priority getPriority();
+ 
+     /* Schedule lock is always held for the priority update calls */
+ 
+-    public abstract void lowerPriority(final PrioritisedExecutor.Priority priority);
++    public abstract void lowerPriority(final Priority priority);
+ 
+-    public abstract void setPriority(final PrioritisedExecutor.Priority priority);
++    public abstract void setPriority(final Priority priority);
+ 
+-    public abstract void raisePriority(final PrioritisedExecutor.Priority priority);
++    public abstract void raisePriority(final Priority priority);
+ 
+     public final void onComplete(final BiConsumer<ChunkAccess, Throwable> onComplete) {
+         if (!this.waiters.add(onComplete)) {
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/task/ChunkUpgradeGenericStatusTask.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/task/ChunkUpgradeGenericStatusTask.java
+index 2c17d5589f15f1155be08be670d29acbe954a8fa..25d8da4773dcee5096053e7e3788bfc224d705a7 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/task/ChunkUpgradeGenericStatusTask.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/task/ChunkUpgradeGenericStatusTask.java
+@@ -1,7 +1,8 @@
+ package ca.spottedleaf.moonrise.patches.chunk_system.scheduling.task;
+ 
+-import ca.spottedleaf.concurrentutil.executor.standard.PrioritisedExecutor;
++import ca.spottedleaf.concurrentutil.executor.PrioritisedExecutor;
+ import ca.spottedleaf.concurrentutil.util.ConcurrentUtil;
++import ca.spottedleaf.concurrentutil.util.Priority;
+ import ca.spottedleaf.moonrise.common.util.WorldUtil;
+ import ca.spottedleaf.moonrise.patches.chunk_system.level.chunk.ChunkSystemChunkStatus;
+ import ca.spottedleaf.moonrise.patches.chunk_system.scheduling.ChunkTaskScheduler;
+@@ -36,9 +37,9 @@ public final class ChunkUpgradeGenericStatusTask extends ChunkProgressionTask im
+ 
+     public ChunkUpgradeGenericStatusTask(final ChunkTaskScheduler scheduler, final ServerLevel world, final int chunkX,
+                                          final int chunkZ, final ChunkAccess chunk, final StaticCache2D<GenerationChunkHolder> neighbours,
+-                                         final ChunkStatus toStatus, final PrioritisedExecutor.Priority priority) {
++                                         final ChunkStatus toStatus, final Priority priority) {
+         super(scheduler, world, chunkX, chunkZ);
+-        if (!PrioritisedExecutor.Priority.isValidPriority(priority)) {
++        if (!Priority.isValidPriority(priority)) {
+             throw new IllegalArgumentException("Invalid priority " + priority);
+         }
+         this.fromChunk = chunk;
+@@ -187,29 +188,29 @@ public final class ChunkUpgradeGenericStatusTask extends ChunkProgressionTask im
+     }
+ 
+     @Override
+-    public PrioritisedExecutor.Priority getPriority() {
++    public Priority getPriority() {
+         return this.generateTask.getPriority();
+     }
+ 
+     @Override
+-    public void lowerPriority(final PrioritisedExecutor.Priority priority) {
+-        if (!PrioritisedExecutor.Priority.isValidPriority(priority)) {
++    public void lowerPriority(final Priority priority) {
++        if (!Priority.isValidPriority(priority)) {
+             throw new IllegalArgumentException("Invalid priority " + priority);
+         }
+         this.generateTask.lowerPriority(priority);
+     }
+ 
+     @Override
+-    public void setPriority(final PrioritisedExecutor.Priority priority) {
+-        if (!PrioritisedExecutor.Priority.isValidPriority(priority)) {
++    public void setPriority(final Priority priority) {
++        if (!Priority.isValidPriority(priority)) {
+             throw new IllegalArgumentException("Invalid priority " + priority);
+         }
+         this.generateTask.setPriority(priority);
+     }
+ 
+     @Override
+-    public void raisePriority(final PrioritisedExecutor.Priority priority) {
+-        if (!PrioritisedExecutor.Priority.isValidPriority(priority)) {
++    public void raisePriority(final Priority priority) {
++        if (!Priority.isValidPriority(priority)) {
+             throw new IllegalArgumentException("Invalid priority " + priority);
+         }
+         this.generateTask.raisePriority(priority);
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/task/GenericDataLoadTask.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/task/GenericDataLoadTask.java
+index 7a65d351b448873c6f2c145c975c92be314b876c..bdcd1879457bafcca4e76523aac0555968f37c0b 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/task/GenericDataLoadTask.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/scheduling/task/GenericDataLoadTask.java
+@@ -1,12 +1,13 @@
+ package ca.spottedleaf.moonrise.patches.chunk_system.scheduling.task;
+ 
++import ca.spottedleaf.concurrentutil.completable.CallbackCompletable;
+ import ca.spottedleaf.concurrentutil.completable.Completable;
+ import ca.spottedleaf.concurrentutil.executor.Cancellable;
+-import ca.spottedleaf.concurrentutil.executor.standard.DelayedPrioritisedTask;
+-import ca.spottedleaf.concurrentutil.executor.standard.PrioritisedExecutor;
++import ca.spottedleaf.concurrentutil.executor.PrioritisedExecutor;
+ import ca.spottedleaf.concurrentutil.util.ConcurrentUtil;
++import ca.spottedleaf.concurrentutil.util.Priority;
+ import ca.spottedleaf.moonrise.common.util.WorldUtil;
+-import ca.spottedleaf.moonrise.patches.chunk_system.io.RegionFileIOThread;
++import ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO;
+ import ca.spottedleaf.moonrise.patches.chunk_system.level.ChunkSystemServerLevel;
+ import ca.spottedleaf.moonrise.patches.chunk_system.scheduling.ChunkTaskScheduler;
+ import ca.spottedleaf.moonrise.patches.chunk_system.scheduling.NewChunkHolder;
+@@ -47,11 +48,11 @@ public abstract class GenericDataLoadTask<OnMain,FinalCompletion> {
+     protected final ServerLevel world;
+     protected final int chunkX;
+     protected final int chunkZ;
+-    protected final RegionFileIOThread.RegionFileType type;
++    protected final MoonriseRegionFileIO.RegionFileType type;
+ 
+     public GenericDataLoadTask(final ChunkTaskScheduler scheduler, final ServerLevel world, final int chunkX,
+-                               final int chunkZ, final RegionFileIOThread.RegionFileType type,
+-                               final PrioritisedExecutor.Priority priority) {
++                               final int chunkZ, final MoonriseRegionFileIO.RegionFileType type,
++                               final Priority priority) {
+         this.scheduler = scheduler;
+         this.world = world;
+         this.chunkX = chunkX;
+@@ -89,9 +90,9 @@ public abstract class GenericDataLoadTask<OnMain,FinalCompletion> {
+ 
+     protected abstract boolean hasOnMain();
+ 
+-    protected abstract PrioritisedExecutor.PrioritisedTask createOffMain(final Runnable run, final PrioritisedExecutor.Priority priority);
++    protected abstract PrioritisedExecutor.PrioritisedTask createOffMain(final Runnable run, final Priority priority);
+ 
+-    protected abstract PrioritisedExecutor.PrioritisedTask createOnMain(final Runnable run, final PrioritisedExecutor.Priority priority);
++    protected abstract PrioritisedExecutor.PrioritisedTask createOnMain(final Runnable run, final Priority priority);
+ 
+     protected abstract TaskResult<OnMain, Throwable> runOffMain(final CompoundTag data, final Throwable throwable);
+ 
+@@ -108,7 +109,7 @@ public abstract class GenericDataLoadTask<OnMain,FinalCompletion> {
+             ", type: " + this.type.toString() + "}";
+     }
+ 
+-    public PrioritisedExecutor.Priority getPriority() {
++    public Priority getPriority() {
+         if (this.processOnMain != null) {
+             return this.processOnMain.getPriority();
+         } else {
+@@ -116,7 +117,7 @@ public abstract class GenericDataLoadTask<OnMain,FinalCompletion> {
+         }
+     }
+ 
+-    public void lowerPriority(final PrioritisedExecutor.Priority priority) {
++    public void lowerPriority(final Priority priority) {
+         // can't lower I/O tasks, we don't know what they affect
+         if (this.processOffMain != null) {
+             this.processOffMain.lowerPriority(priority);
+@@ -126,7 +127,7 @@ public abstract class GenericDataLoadTask<OnMain,FinalCompletion> {
+         }
+     }
+ 
+-    public void setPriority(final PrioritisedExecutor.Priority priority) {
++    public void setPriority(final Priority priority) {
+         // can't lower I/O tasks, we don't know what they affect
+         this.loadDataFromDiskTask.raisePriority(priority);
+         if (this.processOffMain != null) {
+@@ -137,7 +138,7 @@ public abstract class GenericDataLoadTask<OnMain,FinalCompletion> {
+         }
+     }
+ 
+-    public void raisePriority(final PrioritisedExecutor.Priority priority) {
++    public void raisePriority(final Priority priority) {
+         // can't lower I/O tasks, we don't know what they affect
+         this.loadDataFromDiskTask.raisePriority(priority);
+         if (this.processOffMain != null) {
+@@ -382,10 +383,10 @@ public abstract class GenericDataLoadTask<OnMain,FinalCompletion> {
+         private final int chunkX;
+         private final int chunkZ;
+ 
+-        private final RegionFileIOThread.RegionFileType type;
++        private final MoonriseRegionFileIO.RegionFileType type;
+         private Cancellable dataLoadTask;
+         private Cancellable dataUnloadCancellable;
+-        private DelayedPrioritisedTask dataUnloadTask;
++        private PrioritisedExecutor.PrioritisedTask dataUnloadTask;
+ 
+         private final BiConsumer<CompoundTag, Throwable> onComplete;
+         private final AtomicBoolean scheduled = new AtomicBoolean();
+@@ -393,10 +394,10 @@ public abstract class GenericDataLoadTask<OnMain,FinalCompletion> {
+         // onComplete should be caller sensitive, it may complete synchronously with schedule() - which does
+         // hold a priority lock.
+         public LoadDataFromDiskTask(final ServerLevel world, final int chunkX, final int chunkZ,
+-                                    final RegionFileIOThread.RegionFileType type,
++                                    final MoonriseRegionFileIO.RegionFileType type,
+                                     final BiConsumer<CompoundTag, Throwable> onComplete,
+-                                    final PrioritisedExecutor.Priority priority) {
+-            if (!PrioritisedExecutor.Priority.isValidPriority(priority)) {
++                                    final Priority priority) {
++            if (!Priority.isValidPriority(priority)) {
+                 throw new IllegalArgumentException("Invalid priority " + priority);
+             }
+             this.world = world;
+@@ -426,8 +427,8 @@ public abstract class GenericDataLoadTask<OnMain,FinalCompletion> {
+             return (this.getPriorityVolatile() & PRIORITY_EXECUTED) != 0;
+         }
+ 
+-        public void lowerPriority(final PrioritisedExecutor.Priority priority) {
+-            if (!PrioritisedExecutor.Priority.isValidPriority(priority)) {
++        public void lowerPriority(final Priority priority) {
++            if (!Priority.isValidPriority(priority)) {
+                 throw new IllegalArgumentException("Invalid priority " + priority);
+             }
+ 
+@@ -439,7 +440,7 @@ public abstract class GenericDataLoadTask<OnMain,FinalCompletion> {
+                 }
+ 
+                 if ((curr & PRIORITY_LOAD_SCHEDULED) != 0) {
+-                    RegionFileIOThread.lowerPriority(this.world, this.chunkX, this.chunkZ, this.type, priority);
++                    MoonriseRegionFileIO.lowerPriority(this.world, this.chunkX, this.chunkZ, this.type, priority);
+                     return;
+                 }
+ 
+@@ -467,8 +468,8 @@ public abstract class GenericDataLoadTask<OnMain,FinalCompletion> {
+             }
+         }
+ 
+-        public void setPriority(final PrioritisedExecutor.Priority priority) {
+-            if (!PrioritisedExecutor.Priority.isValidPriority(priority)) {
++        public void setPriority(final Priority priority) {
++            if (!Priority.isValidPriority(priority)) {
+                 throw new IllegalArgumentException("Invalid priority " + priority);
+             }
+ 
+@@ -480,7 +481,7 @@ public abstract class GenericDataLoadTask<OnMain,FinalCompletion> {
+                 }
+ 
+                 if ((curr & PRIORITY_LOAD_SCHEDULED) != 0) {
+-                    RegionFileIOThread.setPriority(this.world, this.chunkX, this.chunkZ, this.type, priority);
++                    MoonriseRegionFileIO.setPriority(this.world, this.chunkX, this.chunkZ, this.type, priority);
+                     return;
+                 }
+ 
+@@ -504,8 +505,8 @@ public abstract class GenericDataLoadTask<OnMain,FinalCompletion> {
+             }
+         }
+ 
+-        public void raisePriority(final PrioritisedExecutor.Priority priority) {
+-            if (!PrioritisedExecutor.Priority.isValidPriority(priority)) {
++        public void raisePriority(final Priority priority) {
++            if (!Priority.isValidPriority(priority)) {
+                 throw new IllegalArgumentException("Invalid priority " + priority);
+             }
+ 
+@@ -517,7 +518,7 @@ public abstract class GenericDataLoadTask<OnMain,FinalCompletion> {
+                 }
+ 
+                 if ((curr & PRIORITY_LOAD_SCHEDULED) != 0) {
+-                    RegionFileIOThread.raisePriority(this.world, this.chunkX, this.chunkZ, this.type, priority);
++                    MoonriseRegionFileIO.raisePriority(this.world, this.chunkX, this.chunkZ, this.type, priority);
+                     return;
+                 }
+ 
+@@ -583,7 +584,7 @@ public abstract class GenericDataLoadTask<OnMain,FinalCompletion> {
+                 } // else: cancelled
+             };
+ 
+-            final PrioritisedExecutor.Priority initialPriority = PrioritisedExecutor.Priority.getPriority(priority);
++            final Priority initialPriority = Priority.getPriority(priority);
+             boolean scheduledUnload = false;
+ 
+             final NewChunkHolder holder = ((ChunkSystemServerLevel)this.world).moonrise$getChunkTaskScheduler().chunkHolderManager.getChunkHolder(this.chunkX, this.chunkZ);
+@@ -593,13 +594,13 @@ public abstract class GenericDataLoadTask<OnMain,FinalCompletion> {
+                         consumer.accept(data, null);
+                     } else {
+                         // need to schedule task
+-                        LoadDataFromDiskTask.this.schedule(false, consumer, PrioritisedExecutor.Priority.getPriority(LoadDataFromDiskTask.this.getPriorityVolatile() & ~PRIORITY_FLAGS));
++                        LoadDataFromDiskTask.this.schedule(false, consumer, Priority.getPriority(LoadDataFromDiskTask.this.getPriorityVolatile() & ~PRIORITY_FLAGS));
+                     }
+                 };
+                 Cancellable unloadCancellable = null;
+                 CompoundTag syncComplete = null;
+                 final NewChunkHolder.UnloadTask unloadTask = holder.getUnloadTask(this.type); // can be null if no task exists
+-                final Completable<CompoundTag> unloadCompletable = unloadTask == null ? null : unloadTask.completable();
++                final CallbackCompletable<CompoundTag> unloadCompletable = unloadTask == null ? null : unloadTask.completable();
+                 if (unloadCompletable != null) {
+                     unloadCancellable = unloadCompletable.addAsynchronousWaiter(unloadConsumer);
+                     if (unloadCancellable == null) {
+@@ -622,7 +623,7 @@ public abstract class GenericDataLoadTask<OnMain,FinalCompletion> {
+             this.schedule(scheduledUnload, consumer, initialPriority);
+         }
+ 
+-        private void schedule(final boolean scheduledUnload, final BiConsumer<CompoundTag, Throwable> consumer, final PrioritisedExecutor.Priority initialPriority) {
++        private void schedule(final boolean scheduledUnload, final BiConsumer<CompoundTag, Throwable> consumer, final Priority initialPriority) {
+             int priority = this.getPriorityVolatile();
+ 
+             if ((priority & PRIORITY_EXECUTED) != 0) {
+@@ -631,9 +632,9 @@ public abstract class GenericDataLoadTask<OnMain,FinalCompletion> {
+             }
+ 
+             if (!scheduledUnload) {
+-                this.dataLoadTask = RegionFileIOThread.loadDataAsync(
++                this.dataLoadTask = MoonriseRegionFileIO.loadDataAsync(
+                     this.world, this.chunkX, this.chunkZ, this.type, consumer,
+-                    initialPriority.isHigherPriority(PrioritisedExecutor.Priority.NORMAL), initialPriority
++                    initialPriority.isHigherPriority(Priority.NORMAL), initialPriority
+                 );
+             }
+ 
+@@ -657,10 +658,10 @@ public abstract class GenericDataLoadTask<OnMain,FinalCompletion> {
+ 
+                 if (scheduledUnload) {
+                     if (this.dataUnloadTask != null) {
+-                        this.dataUnloadTask.setPriority(PrioritisedExecutor.Priority.getPriority(priority & ~PRIORITY_FLAGS));
++                        this.dataUnloadTask.setPriority(Priority.getPriority(priority & ~PRIORITY_FLAGS));
+                     }
+                 } else {
+-                    RegionFileIOThread.setPriority(this.world, this.chunkX, this.chunkZ, this.type, PrioritisedExecutor.Priority.getPriority(priority & ~PRIORITY_FLAGS));
++                    MoonriseRegionFileIO.setPriority(this.world, this.chunkX, this.chunkZ, this.type, Priority.getPriority(priority & ~PRIORITY_FLAGS));
+                 }
+ 
+                 ++failures;
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/storage/ChunkSystemChunkBuffer.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/storage/ChunkSystemChunkBuffer.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..51c126735ace8fdde89ad97b5cab62f244212db0
+--- /dev/null
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/storage/ChunkSystemChunkBuffer.java
+@@ -0,0 +1,12 @@
++package ca.spottedleaf.moonrise.patches.chunk_system.storage;
++
++import net.minecraft.world.level.chunk.storage.RegionFile;
++import java.io.IOException;
++
++public interface ChunkSystemChunkBuffer {
++    public boolean moonrise$getWriteOnClose();
++
++    public void moonrise$setWriteOnClose(final boolean value);
++
++    public void moonrise$write(final RegionFile regionFile) throws IOException;
++}
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/storage/ChunkSystemRegionFile.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/storage/ChunkSystemRegionFile.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..3bd1b59250dbab15097a64d515999b278636795a
+--- /dev/null
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/storage/ChunkSystemRegionFile.java
+@@ -0,0 +1,12 @@
++package ca.spottedleaf.moonrise.patches.chunk_system.storage;
++
++import ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO;
++import net.minecraft.nbt.CompoundTag;
++import net.minecraft.world.level.ChunkPos;
++import java.io.IOException;
++
++public interface ChunkSystemRegionFile {
++
++    public MoonriseRegionFileIO.RegionDataController.WriteData moonrise$startWrite(final CompoundTag data, final ChunkPos pos) throws IOException;
++
++}
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/util/ParallelSearchRadiusIteration.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/util/ParallelSearchRadiusIteration.java
+index 3a9a564edfdb99e006e4816cb8821bd1e9ecff43..93fd23027c00cef76562098306737272fda1350a 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/util/ParallelSearchRadiusIteration.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/util/ParallelSearchRadiusIteration.java
+@@ -1,6 +1,7 @@
+ package ca.spottedleaf.moonrise.patches.chunk_system.util;
+ 
+ import ca.spottedleaf.moonrise.common.util.CoordinateUtils;
++import ca.spottedleaf.moonrise.common.util.MoonriseConstants;
+ import it.unimi.dsi.fastutil.HashCommon;
+ import it.unimi.dsi.fastutil.longs.LongArrayList;
+ import it.unimi.dsi.fastutil.longs.LongIterator;
+@@ -13,7 +14,7 @@ public final class ParallelSearchRadiusIteration {
+ 
+     // expected that this list returns for a given radius, the set of chunks ordered
+     // by manhattan distance
+-    private static final long[][] SEARCH_RADIUS_ITERATION_LIST = new long[64+2+1][];
++    private static final long[][] SEARCH_RADIUS_ITERATION_LIST = new long[MoonriseConstants.MAX_VIEW_DISTANCE+2+1][];
+     static {
+         for (int i = 0; i < SEARCH_RADIUS_ITERATION_LIST.length; ++i) {
+             // a BFS around -x, -z, +x, +z will give increasing manhatten distance
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/util/stream/ExternalChunkStreamMarker.java b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/util/stream/ExternalChunkStreamMarker.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..7ef3dcca89ed7578c6c0f5565131889110063056
+--- /dev/null
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/chunk_system/util/stream/ExternalChunkStreamMarker.java
+@@ -0,0 +1,37 @@
++package ca.spottedleaf.moonrise.patches.chunk_system.util.stream;
++
++import java.io.DataInputStream;
++import java.io.FilterInputStream;
++import java.io.InputStream;
++import java.lang.reflect.Field;
++
++/**
++ * Used to mark chunk data streams that are on external files
++ */
++public class ExternalChunkStreamMarker extends DataInputStream {
++
++    private static final Field IN_FIELD;
++    static {
++        Field field;
++        try {
++            field = FilterInputStream.class.getDeclaredField("in");
++            field.setAccessible(true);
++        } catch (final Throwable throwable) {
++            field = null;
++        }
++
++        IN_FIELD = field;
++    }
++
++    private static InputStream getWrapped(final FilterInputStream in) {
++        try {
++            return (InputStream)IN_FIELD.get(in);
++        } catch (final Throwable throwable) {
++            return in;
++        }
++    }
++
++    public ExternalChunkStreamMarker(final DataInputStream in) {
++        super(getWrapped(in));
++    }
++}
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/collisions/CollisionUtil.java b/src/main/java/ca/spottedleaf/moonrise/patches/collisions/CollisionUtil.java
+index 748ab4d637ce463272bae4fdbab6842a27385126..3abd4ad6379c383c3a31931255292b42d9435694 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/collisions/CollisionUtil.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/collisions/CollisionUtil.java
+@@ -1,15 +1,58 @@
+ package ca.spottedleaf.moonrise.patches.collisions;
+ 
++import ca.spottedleaf.moonrise.common.util.WorldUtil;
++import ca.spottedleaf.moonrise.patches.chunk_system.world.ChunkSystemEntityGetter;
++import ca.spottedleaf.moonrise.patches.collisions.block.CollisionBlockState;
++import ca.spottedleaf.moonrise.patches.chunk_system.entity.ChunkSystemEntity;
++import ca.spottedleaf.moonrise.patches.collisions.shape.CachedShapeData;
++import ca.spottedleaf.moonrise.patches.collisions.shape.CollisionDiscreteVoxelShape;
++import ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape;
++import ca.spottedleaf.moonrise.patches.block_counting.BlockCountingChunkSection;
++import it.unimi.dsi.fastutil.doubles.DoubleArrayList;
++import it.unimi.dsi.fastutil.doubles.DoubleList;
++import net.minecraft.core.BlockPos;
++import net.minecraft.core.Direction;
++import net.minecraft.util.Mth;
++import net.minecraft.world.entity.Entity;
++import net.minecraft.world.item.Item;
++import net.minecraft.world.level.Level;
++import net.minecraft.world.level.block.Blocks;
++import net.minecraft.world.level.block.state.BlockState;
++import net.minecraft.world.level.border.WorldBorder;
++import net.minecraft.world.level.chunk.ChunkAccess;
++import net.minecraft.world.level.chunk.ChunkSource;
++import net.minecraft.world.level.chunk.LevelChunkSection;
++import net.minecraft.world.level.chunk.PalettedContainer;
++import net.minecraft.world.level.chunk.status.ChunkStatus;
++import net.minecraft.world.level.material.FluidState;
++import net.minecraft.world.phys.AABB;
++import net.minecraft.world.phys.Vec3;
++import net.minecraft.world.phys.shapes.ArrayVoxelShape;
++import net.minecraft.world.phys.shapes.BitSetDiscreteVoxelShape;
++import net.minecraft.world.phys.shapes.BooleanOp;
++import net.minecraft.world.phys.shapes.CollisionContext;
++import net.minecraft.world.phys.shapes.DiscreteVoxelShape;
++import net.minecraft.world.phys.shapes.EntityCollisionContext;
++import net.minecraft.world.phys.shapes.OffsetDoubleList;
++import net.minecraft.world.phys.shapes.Shapes;
++import net.minecraft.world.phys.shapes.SliceShape;
++import net.minecraft.world.phys.shapes.VoxelShape;
++import java.util.Arrays;
++import java.util.List;
++import java.util.Objects;
++import java.util.function.BiPredicate;
++import java.util.function.Predicate;
++
+ public final class CollisionUtil {
+ 
+     public static final double COLLISION_EPSILON = 1.0E-7;
+-    public static final it.unimi.dsi.fastutil.doubles.DoubleArrayList ZERO_ONE = it.unimi.dsi.fastutil.doubles.DoubleArrayList.wrap(new double[] { 0.0, 1.0 });
++    public static final DoubleArrayList ZERO_ONE = DoubleArrayList.wrap(new double[] { 0.0, 1.0 });
+ 
+     public static boolean isSpecialCollidingBlock(final net.minecraft.world.level.block.state.BlockBehaviour.BlockStateBase block) {
+-        return block.hasLargeCollisionShape() || block.getBlock() == net.minecraft.world.level.block.Blocks.MOVING_PISTON;
++        return block.hasLargeCollisionShape() || block.getBlock() == Blocks.MOVING_PISTON;
+     }
+ 
+-    public static boolean isEmpty(final net.minecraft.world.phys.AABB aabb) {
++    public static boolean isEmpty(final AABB aabb) {
+         return (aabb.maxX - aabb.minX) < COLLISION_EPSILON || (aabb.maxY - aabb.minY) < COLLISION_EPSILON || (aabb.maxZ - aabb.minZ) < COLLISION_EPSILON;
+     }
+ 
+@@ -18,11 +61,11 @@ public final class CollisionUtil {
+         return (maxX - minX) < COLLISION_EPSILON || (maxY - minY) < COLLISION_EPSILON || (maxZ - minZ) < COLLISION_EPSILON;
+     }
+ 
+-    public static net.minecraft.world.phys.AABB getBoxForChunk(final int chunkX, final int chunkZ) {
++    public static AABB getBoxForChunk(final int chunkX, final int chunkZ) {
+         double x = (double)(chunkX << 4);
+         double z = (double)(chunkZ << 4);
+         // use a bounding box bigger than the chunk to prevent entities from entering it on move
+-        return new net.minecraft.world.phys.AABB(x - 3*COLLISION_EPSILON, Double.NEGATIVE_INFINITY, z - 3*COLLISION_EPSILON,
++        return new AABB(x - 3*COLLISION_EPSILON, Double.NEGATIVE_INFINITY, z - 3*COLLISION_EPSILON,
+             x + (16.0 + 3*COLLISION_EPSILON), Double.POSITIVE_INFINITY, z + (16.0 + 3*COLLISION_EPSILON));
+     }
+ 
+@@ -43,21 +86,21 @@ public final class CollisionUtil {
+                (minZ1 - maxZ2) < -COLLISION_EPSILON && (maxZ1 - minZ2) > COLLISION_EPSILON;
+     }
+ 
+-    public static boolean voxelShapeIntersect(final net.minecraft.world.phys.AABB box, final double minX, final double minY, final double minZ,
++    public static boolean voxelShapeIntersect(final AABB box, final double minX, final double minY, final double minZ,
+                                               final double maxX, final double maxY, final double maxZ) {
+         return (box.minX - maxX) < -COLLISION_EPSILON && (box.maxX - minX) > COLLISION_EPSILON &&
+                (box.minY - maxY) < -COLLISION_EPSILON && (box.maxY - minY) > COLLISION_EPSILON &&
+                (box.minZ - maxZ) < -COLLISION_EPSILON && (box.maxZ - minZ) > COLLISION_EPSILON;
+     }
+ 
+-    public static boolean voxelShapeIntersect(final net.minecraft.world.phys.AABB box1, final net.minecraft.world.phys.AABB box2) {
++    public static boolean voxelShapeIntersect(final AABB box1, final AABB box2) {
+         return (box1.minX - box2.maxX) < -COLLISION_EPSILON && (box1.maxX - box2.minX) > COLLISION_EPSILON &&
+                (box1.minY - box2.maxY) < -COLLISION_EPSILON && (box1.maxY - box2.minY) > COLLISION_EPSILON &&
+                (box1.minZ - box2.maxZ) < -COLLISION_EPSILON && (box1.maxZ - box2.minZ) > COLLISION_EPSILON;
+     }
+ 
+     // assume !isEmpty(target) && abs(source_move) >= COLLISION_EPSILON
+-    public static double collideX(final net.minecraft.world.phys.AABB target, final net.minecraft.world.phys.AABB source, final double source_move) {
++    public static double collideX(final AABB target, final AABB source, final double source_move) {
+         if ((source.minY - target.maxY) < -COLLISION_EPSILON && (source.maxY - target.minY) > COLLISION_EPSILON &&
+             (source.minZ - target.maxZ) < -COLLISION_EPSILON && (source.maxZ - target.minZ) > COLLISION_EPSILON) {
+             if (source_move >= 0.0) {
+@@ -78,7 +121,7 @@ public final class CollisionUtil {
+     }
+ 
+     // assume !isEmpty(target) && abs(source_move) >= COLLISION_EPSILON
+-    public static double collideY(final net.minecraft.world.phys.AABB target, final net.minecraft.world.phys.AABB source, final double source_move) {
++    public static double collideY(final AABB target, final AABB source, final double source_move) {
+         if ((source.minX - target.maxX) < -COLLISION_EPSILON && (source.maxX - target.minX) > COLLISION_EPSILON &&
+             (source.minZ - target.maxZ) < -COLLISION_EPSILON && (source.maxZ - target.minZ) > COLLISION_EPSILON) {
+             if (source_move >= 0.0) {
+@@ -99,7 +142,7 @@ public final class CollisionUtil {
+     }
+ 
+     // assume !isEmpty(target) && abs(source_move) >= COLLISION_EPSILON
+-    public static double collideZ(final net.minecraft.world.phys.AABB target, final net.minecraft.world.phys.AABB source, final double source_move) {
++    public static double collideZ(final AABB target, final AABB source, final double source_move) {
+         if ((source.minX - target.maxX) < -COLLISION_EPSILON && (source.maxX - target.minX) > COLLISION_EPSILON &&
+             (source.minY - target.maxY) < -COLLISION_EPSILON && (source.maxY - target.minY) > COLLISION_EPSILON) {
+             if (source_move >= 0.0) {
+@@ -121,7 +164,8 @@ public final class CollisionUtil {
+ 
+     // startIndex and endIndex inclusive
+     // assumes indices are in range of array
+-    private static int findFloor(final double[] values, final double value, int startIndex, int endIndex) {
++    public static int findFloor(final double[] values, final double value, int startIndex, int endIndex) {
++        Objects.checkFromToIndex(startIndex, endIndex + 1, values.length);
+         do {
+             final int middle = (startIndex + endIndex) >>> 1;
+             final double middleVal = values[middle];
+@@ -136,7 +180,217 @@ public final class CollisionUtil {
+         return startIndex - 1;
+     }
+ 
+-    public static boolean voxelShapeIntersectNoEmpty(final net.minecraft.world.phys.shapes.VoxelShape voxel, final net.minecraft.world.phys.AABB aabb) {
++    private static VoxelShape sliceShapeVanilla(final VoxelShape src, final Direction.Axis axis,
++                                                final int index) {
++        return new SliceShape(src, axis, index);
++    }
++
++    private static DoubleList offsetList(final double[] src, final double by) {
++        final DoubleArrayList wrap = DoubleArrayList.wrap(src);
++        if (by == 0.0) {
++            return wrap;
++        }
++        return new OffsetDoubleList(wrap, by);
++    }
++
++    private static VoxelShape sliceShapeOptimised(final VoxelShape src, final Direction.Axis axis,
++                                                  final int index) {
++        // assume index in range
++        final double off_x = ((CollisionVoxelShape)src).moonrise$offsetX();
++        final double off_y = ((CollisionVoxelShape)src).moonrise$offsetY();
++        final double off_z = ((CollisionVoxelShape)src).moonrise$offsetZ();
++
++        final double[] coords_x = ((CollisionVoxelShape)src).moonrise$rootCoordinatesX();
++        final double[] coords_y = ((CollisionVoxelShape)src).moonrise$rootCoordinatesY();
++        final double[] coords_z = ((CollisionVoxelShape)src).moonrise$rootCoordinatesZ();
++
++        final CachedShapeData cached_shape_data = ((CollisionVoxelShape)src).moonrise$getCachedVoxelData();
++
++        // note: size = coords.length - 1
++        final int size_x = cached_shape_data.sizeX();
++        final int size_y = cached_shape_data.sizeY();
++        final int size_z = cached_shape_data.sizeZ();
++
++        final long[] bitset = cached_shape_data.voxelSet();
++
++        final DoubleList list_x;
++        final DoubleList list_y;
++        final DoubleList list_z;
++        final int shape_sx;
++        final int shape_ex;
++        final int shape_sy;
++        final int shape_ey;
++        final int shape_sz;
++        final int shape_ez;
++
++        switch (axis) {
++            case X: {
++                // validate index
++                if (index < 0 || index >= size_x) {
++                    return Shapes.empty();
++                }
++
++                // test if input is already "sliced"
++                if (coords_x.length == 2 && (coords_x[0] + off_x) == 0.0 && (coords_x[1] + off_x) == 1.0) {
++                    return src;
++                }
++
++                // test if result would be full box
++                if (coords_y.length == 2 && coords_z.length == 2 &&
++                    (coords_y[0] + off_y) == 0.0 && (coords_y[1] + off_y) == 1.0 &&
++                    (coords_z[0] + off_z) == 0.0 && (coords_z[1] + off_z) == 1.0) {
++                    // note: size_y == size_z == 1
++                    final int bitIdx = 0 + 0*size_z + index*(size_z*size_y);
++                    return (bitset[bitIdx >>> 6] & (1L << bitIdx)) == 0L ? Shapes.empty() : Shapes.block();
++                }
++
++                list_x = ZERO_ONE;
++                list_y = offsetList(coords_y, off_y);
++                list_z = offsetList(coords_z, off_z);
++                shape_sx = index;
++                shape_ex = index + 1;
++                shape_sy = 0;
++                shape_ey = size_y;
++                shape_sz = 0;
++                shape_ez = size_z;
++
++                break;
++            }
++            case Y: {
++                // validate index
++                if (index < 0 || index >= size_y) {
++                    return Shapes.empty();
++                }
++
++                // test if input is already "sliced"
++                if (coords_y.length == 2 && (coords_y[0] + off_y) == 0.0 && (coords_y[1] + off_y) == 1.0) {
++                    return src;
++                }
++
++                // test if result would be full box
++                if (coords_x.length == 2 && coords_z.length == 2 &&
++                    (coords_x[0] + off_x) == 0.0 && (coords_x[1] + off_x) == 1.0 &&
++                    (coords_z[0] + off_z) == 0.0 && (coords_z[1] + off_z) == 1.0) {
++                    // note: size_x == size_z == 1
++                    final int bitIdx = 0 + index*size_z + 0*(size_z*size_y);
++                    return (bitset[bitIdx >>> 6] & (1L << bitIdx)) == 0L ? Shapes.empty() : Shapes.block();
++                }
++
++                list_x = offsetList(coords_x, off_x);
++                list_y = ZERO_ONE;
++                list_z = offsetList(coords_z, off_z);
++                shape_sx = 0;
++                shape_ex = size_x;
++                shape_sy = index;
++                shape_ey = index + 1;
++                shape_sz = 0;
++                shape_ez = size_z;
++
++                break;
++            }
++            case Z: {
++                // validate index
++                if (index < 0 || index >= size_z) {
++                    return Shapes.empty();
++                }
++
++                // test if input is already "sliced"
++                if (coords_z.length == 2 && (coords_z[0] + off_z) == 0.0 && (coords_z[1] + off_z) == 1.0) {
++                    return src;
++                }
++
++                // test if result would be full box
++                if (coords_x.length == 2 && coords_y.length == 2 &&
++                    (coords_x[0] + off_x) == 0.0 && (coords_x[1] + off_x) == 1.0 &&
++                    (coords_y[0] + off_y) == 0.0 && (coords_y[1] + off_y) == 1.0) {
++                    // note: size_x == size_y == 1
++                    final int bitIdx = index + 0*size_z + 0*(size_z*size_y);
++                    return (bitset[bitIdx >>> 6] & (1L << bitIdx)) == 0L ? Shapes.empty() : Shapes.block();
++                }
++
++                list_x = offsetList(coords_x, off_x);
++                list_y = offsetList(coords_y, off_y);
++                list_z = ZERO_ONE;
++                shape_sx = 0;
++                shape_ex = size_x;
++                shape_sy = 0;
++                shape_ey = size_y;
++                shape_sz = index;
++                shape_ez = index + 1;
++
++                break;
++            }
++            default: {
++                throw new IllegalStateException("Unknown axis: " + axis);
++            }
++        }
++
++        final int local_len_x = shape_ex - shape_sx;
++        final int local_len_y = shape_ey - shape_sy;
++        final int local_len_z = shape_ez - shape_sz;
++
++        final BitSetDiscreteVoxelShape shape = new BitSetDiscreteVoxelShape(local_len_x, local_len_y, local_len_z);
++
++        final int bitset_mul_x = size_z*size_y;
++        final int idx_off = shape_sz + shape_sy*size_z + shape_sx*bitset_mul_x;
++        final int shape_mul_x = local_len_y*local_len_z;
++        for (int x = 0; x < local_len_x; ++x) {
++            boolean setX = false;
++            for (int y = 0; y < local_len_y; ++y) {
++                boolean setY = false;
++                for (int z = 0; z < local_len_z; ++z) {
++                    final int unslicedIdx = idx_off + z + y*size_z + x*bitset_mul_x;
++                    if ((bitset[unslicedIdx >>> 6] & (1L << unslicedIdx)) == 0L) {
++                        continue;
++                    }
++
++                    setY = true;
++                    setX = true;
++                    shape.zMin = Math.min(shape.zMin, z);
++                    shape.zMax = Math.max(shape.zMax, z + 1);
++
++                    shape.storage.set(
++                        z + y*local_len_z + x*shape_mul_x
++                    );
++                }
++
++                if (setY) {
++                    shape.yMin = Math.min(shape.yMin, y);
++                    shape.yMax = Math.max(shape.yMax, y + 1);
++                }
++            }
++            if (setX) {
++                shape.xMin = Math.min(shape.xMin, x);
++                shape.xMax = Math.max(shape.xMax, x + 1);
++            }
++        }
++
++        return shape.isEmpty() ? Shapes.empty() : new ArrayVoxelShape(
++            shape, list_x, list_y, list_z
++        );
++    }
++
++    private static final boolean DEBUG_SLICE_SHAPE = false;
++
++    public static VoxelShape sliceShape(final VoxelShape src, final Direction.Axis axis,
++                                        final int index) {
++        final VoxelShape ret = sliceShapeOptimised(src, axis, index);
++        if (DEBUG_SLICE_SHAPE) {
++            final VoxelShape vanilla = sliceShapeVanilla(src, axis, index);
++            if (!equals(ret, vanilla)) {
++                // special case: SliceShape is not empty when it should be!
++                if (areAnyFull(ret.shape) || areAnyFull(vanilla.shape)) {
++                    equals(ret, vanilla);
++                    sliceShapeOptimised(src, axis, index);
++                    throw new IllegalStateException("Slice shape mismatch");
++                }
++            }
++        }
++
++        return ret;
++    }
++
++    public static boolean voxelShapeIntersectNoEmpty(final VoxelShape voxel, final AABB aabb) {
+         if (voxel.isEmpty()) {
+             return false;
+         }
+@@ -144,15 +398,15 @@ public final class CollisionUtil {
+         // note: this function assumes that for any i in coords that coord[i + 1] - coord[i] > COLLISION_EPSILON is true
+ 
+         // offsets that should be applied to coords
+-        final double off_x = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)voxel).moonrise$offsetX();
+-        final double off_y = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)voxel).moonrise$offsetY();
+-        final double off_z = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)voxel).moonrise$offsetZ();
++        final double off_x = ((CollisionVoxelShape)voxel).moonrise$offsetX();
++        final double off_y = ((CollisionVoxelShape)voxel).moonrise$offsetY();
++        final double off_z = ((CollisionVoxelShape)voxel).moonrise$offsetZ();
+ 
+-        final double[] coords_x = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)voxel).moonrise$rootCoordinatesX();
+-        final double[] coords_y = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)voxel).moonrise$rootCoordinatesY();
+-        final double[] coords_z = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)voxel).moonrise$rootCoordinatesZ();
++        final double[] coords_x = ((CollisionVoxelShape)voxel).moonrise$rootCoordinatesX();
++        final double[] coords_y = ((CollisionVoxelShape)voxel).moonrise$rootCoordinatesY();
++        final double[] coords_z = ((CollisionVoxelShape)voxel).moonrise$rootCoordinatesZ();
+ 
+-        final ca.spottedleaf.moonrise.patches.collisions.shape.CachedShapeData cached_shape_data = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)voxel).moonrise$getCachedVoxelData();
++        final CachedShapeData cached_shape_data = ((CollisionVoxelShape)voxel).moonrise$getCachedVoxelData();
+ 
+         // note: size = coords.length - 1
+         final int size_x = cached_shape_data.sizeX();
+@@ -246,23 +500,23 @@ public final class CollisionUtil {
+     }
+ 
+     // assume !target.isEmpty() && abs(source_move) >= COLLISION_EPSILON
+-    public static double collideX(final net.minecraft.world.phys.shapes.VoxelShape target, final net.minecraft.world.phys.AABB source, final double source_move) {
+-        final net.minecraft.world.phys.AABB single_aabb = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)target).moonrise$getSingleAABBRepresentation();
++    public static double collideX(final VoxelShape target, final AABB source, final double source_move) {
++        final AABB single_aabb = ((CollisionVoxelShape)target).moonrise$getSingleAABBRepresentation();
+         if (single_aabb != null) {
+             return collideX(single_aabb, source, source_move);
+         }
+         // note: this function assumes that for any i in coords that coord[i + 1] - coord[i] > COLLISION_EPSILON is true
+ 
+         // offsets that should be applied to coords
+-        final double off_x = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)target).moonrise$offsetX();
+-        final double off_y = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)target).moonrise$offsetY();
+-        final double off_z = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)target).moonrise$offsetZ();
++        final double off_x = ((CollisionVoxelShape)target).moonrise$offsetX();
++        final double off_y = ((CollisionVoxelShape)target).moonrise$offsetY();
++        final double off_z = ((CollisionVoxelShape)target).moonrise$offsetZ();
+ 
+-        final double[] coords_x = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)target).moonrise$rootCoordinatesX();
+-        final double[] coords_y = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)target).moonrise$rootCoordinatesY();
+-        final double[] coords_z = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)target).moonrise$rootCoordinatesZ();
++        final double[] coords_x = ((CollisionVoxelShape)target).moonrise$rootCoordinatesX();
++        final double[] coords_y = ((CollisionVoxelShape)target).moonrise$rootCoordinatesY();
++        final double[] coords_z = ((CollisionVoxelShape)target).moonrise$rootCoordinatesZ();
+ 
+-        final ca.spottedleaf.moonrise.patches.collisions.shape.CachedShapeData cached_shape_data = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)target).moonrise$getCachedVoxelData();
++        final CachedShapeData cached_shape_data = ((CollisionVoxelShape)target).moonrise$getCachedVoxelData();
+ 
+         // note: size = coords.length - 1
+         final int size_x = cached_shape_data.sizeX();
+@@ -404,23 +658,23 @@ public final class CollisionUtil {
+         }
+     }
+ 
+-    public static double collideY(final net.minecraft.world.phys.shapes.VoxelShape target, final net.minecraft.world.phys.AABB source, final double source_move) {
+-        final net.minecraft.world.phys.AABB single_aabb = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)target).moonrise$getSingleAABBRepresentation();
++    public static double collideY(final VoxelShape target, final AABB source, final double source_move) {
++        final AABB single_aabb = ((CollisionVoxelShape)target).moonrise$getSingleAABBRepresentation();
+         if (single_aabb != null) {
+             return collideY(single_aabb, source, source_move);
+         }
+         // note: this function assumes that for any i in coords that coord[i + 1] - coord[i] > COLLISION_EPSILON is true
+ 
+         // offsets that should be applied to coords
+-        final double off_x = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)target).moonrise$offsetX();
+-        final double off_y = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)target).moonrise$offsetY();
+-        final double off_z = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)target).moonrise$offsetZ();
++        final double off_x = ((CollisionVoxelShape)target).moonrise$offsetX();
++        final double off_y = ((CollisionVoxelShape)target).moonrise$offsetY();
++        final double off_z = ((CollisionVoxelShape)target).moonrise$offsetZ();
+ 
+-        final double[] coords_x = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)target).moonrise$rootCoordinatesX();
+-        final double[] coords_y = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)target).moonrise$rootCoordinatesY();
+-        final double[] coords_z = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)target).moonrise$rootCoordinatesZ();
++        final double[] coords_x = ((CollisionVoxelShape)target).moonrise$rootCoordinatesX();
++        final double[] coords_y = ((CollisionVoxelShape)target).moonrise$rootCoordinatesY();
++        final double[] coords_z = ((CollisionVoxelShape)target).moonrise$rootCoordinatesZ();
+ 
+-        final ca.spottedleaf.moonrise.patches.collisions.shape.CachedShapeData cached_shape_data = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)target).moonrise$getCachedVoxelData();
++        final CachedShapeData cached_shape_data = ((CollisionVoxelShape)target).moonrise$getCachedVoxelData();
+ 
+         // note: size = coords.length - 1
+         final int size_x = cached_shape_data.sizeX();
+@@ -562,23 +816,23 @@ public final class CollisionUtil {
+         }
+     }
+ 
+-    public static double collideZ(final net.minecraft.world.phys.shapes.VoxelShape target, final net.minecraft.world.phys.AABB source, final double source_move) {
+-        final net.minecraft.world.phys.AABB single_aabb = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)target).moonrise$getSingleAABBRepresentation();
++    public static double collideZ(final VoxelShape target, final AABB source, final double source_move) {
++        final AABB single_aabb = ((CollisionVoxelShape)target).moonrise$getSingleAABBRepresentation();
+         if (single_aabb != null) {
+             return collideZ(single_aabb, source, source_move);
+         }
+         // note: this function assumes that for any i in coords that coord[i + 1] - coord[i] > COLLISION_EPSILON is true
+ 
+         // offsets that should be applied to coords
+-        final double off_x = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)target).moonrise$offsetX();
+-        final double off_y = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)target).moonrise$offsetY();
+-        final double off_z = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)target).moonrise$offsetZ();
++        final double off_x = ((CollisionVoxelShape)target).moonrise$offsetX();
++        final double off_y = ((CollisionVoxelShape)target).moonrise$offsetY();
++        final double off_z = ((CollisionVoxelShape)target).moonrise$offsetZ();
+ 
+-        final double[] coords_x = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)target).moonrise$rootCoordinatesX();
+-        final double[] coords_y = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)target).moonrise$rootCoordinatesY();
+-        final double[] coords_z = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)target).moonrise$rootCoordinatesZ();
++        final double[] coords_x = ((CollisionVoxelShape)target).moonrise$rootCoordinatesX();
++        final double[] coords_y = ((CollisionVoxelShape)target).moonrise$rootCoordinatesY();
++        final double[] coords_z = ((CollisionVoxelShape)target).moonrise$rootCoordinatesZ();
+ 
+-        final ca.spottedleaf.moonrise.patches.collisions.shape.CachedShapeData cached_shape_data = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)target).moonrise$getCachedVoxelData();
++        final CachedShapeData cached_shape_data = ((CollisionVoxelShape)target).moonrise$getCachedVoxelData();
+ 
+         // note: size = coords.length - 1
+         final int size_x = cached_shape_data.sizeX();
+@@ -721,13 +975,13 @@ public final class CollisionUtil {
+     }
+ 
+     // does not use epsilon
+-    public static boolean strictlyContains(final net.minecraft.world.phys.shapes.VoxelShape voxel, final net.minecraft.world.phys.Vec3 point) {
++    public static boolean strictlyContains(final VoxelShape voxel, final Vec3 point) {
+         return strictlyContains(voxel, point.x, point.y, point.z);
+     }
+ 
+     // does not use epsilon
+-    public static boolean strictlyContains(final net.minecraft.world.phys.shapes.VoxelShape voxel, double x, double y, double z) {
+-        final net.minecraft.world.phys.AABB single_aabb = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)voxel).moonrise$getSingleAABBRepresentation();
++    public static boolean strictlyContains(final VoxelShape voxel, double x, double y, double z) {
++        final AABB single_aabb = ((CollisionVoxelShape)voxel).moonrise$getSingleAABBRepresentation();
+         if (single_aabb != null) {
+             return single_aabb.contains(x, y, z);
+         }
+@@ -738,15 +992,15 @@ public final class CollisionUtil {
+         }
+ 
+         // offset input
+-        x -= ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)voxel).moonrise$offsetX();
+-        y -= ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)voxel).moonrise$offsetY();
+-        z -= ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)voxel).moonrise$offsetZ();
++        x -= ((CollisionVoxelShape)voxel).moonrise$offsetX();
++        y -= ((CollisionVoxelShape)voxel).moonrise$offsetY();
++        z -= ((CollisionVoxelShape)voxel).moonrise$offsetZ();
+ 
+-        final double[] coords_x = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)voxel).moonrise$rootCoordinatesX();
+-        final double[] coords_y = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)voxel).moonrise$rootCoordinatesY();
+-        final double[] coords_z = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)voxel).moonrise$rootCoordinatesZ();
++        final double[] coords_x = ((CollisionVoxelShape)voxel).moonrise$rootCoordinatesX();
++        final double[] coords_y = ((CollisionVoxelShape)voxel).moonrise$rootCoordinatesY();
++        final double[] coords_z = ((CollisionVoxelShape)voxel).moonrise$rootCoordinatesZ();
+ 
+-        final ca.spottedleaf.moonrise.patches.collisions.shape.CachedShapeData cached_shape_data = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)voxel).moonrise$getCachedVoxelData();
++        final CachedShapeData cached_shape_data = ((CollisionVoxelShape)voxel).moonrise$getCachedVoxelData();
+ 
+         // note: size = coords.length - 1
+         final int size_x = cached_shape_data.sizeX();
+@@ -788,10 +1042,10 @@ public final class CollisionUtil {
+         return ((ft ? 1 : 0) << 1) | ((tf ? 1 : 0) << 2) | ((tt ? 1 : 0) << 3);
+     }
+ 
+-    private static net.minecraft.world.phys.shapes.BitSetDiscreteVoxelShape merge(final ca.spottedleaf.moonrise.patches.collisions.shape.CachedShapeData shapeDataFirst, final ca.spottedleaf.moonrise.patches.collisions.shape.CachedShapeData shapeDataSecond,
+-                                                                                  final ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.MergedVoxelCoordinateList mergedX, final ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.MergedVoxelCoordinateList mergedY,
+-                                                                                  final ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.MergedVoxelCoordinateList mergedZ,
+-                                                                                  final int booleanOp) {
++    private static BitSetDiscreteVoxelShape merge(final CachedShapeData shapeDataFirst, final CachedShapeData shapeDataSecond,
++                                                  final MergedVoxelCoordinateList mergedX, final MergedVoxelCoordinateList mergedY,
++                                                  final MergedVoxelCoordinateList mergedZ,
++                                                  final int booleanOp) {
+         final int sizeX = mergedX.voxels;
+         final int sizeY = mergedY.voxels;
+         final int sizeZ = mergedZ.voxels;
+@@ -806,7 +1060,7 @@ public final class CollisionUtil {
+         final int s2Mul2 = s2Mul1 * shapeDataSecond.sizeY();
+ 
+         // note: indices may contain -1, but nothing > size
+-        final net.minecraft.world.phys.shapes.BitSetDiscreteVoxelShape ret = new net.minecraft.world.phys.shapes.BitSetDiscreteVoxelShape(sizeX, sizeY, sizeZ);
++        final BitSetDiscreteVoxelShape ret = new BitSetDiscreteVoxelShape(sizeX, sizeY, sizeZ);
+ 
+         boolean empty = true;
+ 
+@@ -823,10 +1077,11 @@ public final class CollisionUtil {
+                     final int s1z = mergedZ.firstIndices[idxZ];
+                     final int s2z = mergedZ.secondIndices[idxZ];
+ 
+-                    int idx;
++                    int idx1;
++                    int idx2;
+ 
+-                    final int isS1Full = (s1x | s1y | s1z) < 0 ? 0 : (int)((s1Voxels[(idx = s1z + s1y*s1Mul1 + s1x*s1Mul2) >>> 6] >>> idx) & 1L);
+-                    final int isS2Full = (s2x | s2y | s2z) < 0 ? 0 : (int)((s2Voxels[(idx = s2z + s2y*s2Mul1 + s2x*s2Mul2) >>> 6] >>> idx) & 1L);
++                    final int isS1Full = (s1x | s1y | s1z) < 0 ? 0 : (int)((s1Voxels[(idx1 = s1z + s1y*s1Mul1 + s1x*s1Mul2) >>> 6] >>> idx1) & 1L);
++                    final int isS2Full = (s2x | s2y | s2z) < 0 ? 0 : (int)((s2Voxels[(idx2 = s2z + s2y*s2Mul1 + s2x*s2Mul2) >>> 6] >>> idx2) & 1L);
+ 
+                     // idx ff -> 0
+                     // idx ft -> 1
+@@ -861,9 +1116,9 @@ public final class CollisionUtil {
+         return empty ? null : ret;
+     }
+ 
+-    private static boolean isMergeEmpty(final ca.spottedleaf.moonrise.patches.collisions.shape.CachedShapeData shapeDataFirst, final ca.spottedleaf.moonrise.patches.collisions.shape.CachedShapeData shapeDataSecond,
+-                                        final ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.MergedVoxelCoordinateList mergedX, final ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.MergedVoxelCoordinateList mergedY,
+-                                        final ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.MergedVoxelCoordinateList mergedZ,
++    private static boolean isMergeEmpty(final CachedShapeData shapeDataFirst, final CachedShapeData shapeDataSecond,
++                                        final MergedVoxelCoordinateList mergedX, final MergedVoxelCoordinateList mergedY,
++                                        final MergedVoxelCoordinateList mergedZ,
+                                         final int booleanOp) {
+         final int sizeX = mergedX.voxels;
+         final int sizeY = mergedY.voxels;
+@@ -889,10 +1144,11 @@ public final class CollisionUtil {
+                     final int s1z = mergedZ.firstIndices[idxZ];
+                     final int s2z = mergedZ.secondIndices[idxZ];
+ 
+-                    int idx;
++                    int idx1;
++                    int idx2;
+ 
+-                    final int isS1Full = (s1x | s1y | s1z) < 0 ? 0 : (int)((s1Voxels[(idx = s1z + s1y*s1Mul1 + s1x*s1Mul2) >>> 6] >>> idx) & 1L);
+-                    final int isS2Full = (s2x | s2y | s2z) < 0 ? 0 : (int)((s2Voxels[(idx = s2z + s2y*s2Mul1 + s2x*s2Mul2) >>> 6] >>> idx) & 1L);
++                    final int isS1Full = (s1x | s1y | s1z) < 0 ? 0 : (int)((s1Voxels[(idx1 = s1z + s1y*s1Mul1 + s1x*s1Mul2) >>> 6] >>> idx1) & 1L);
++                    final int isS2Full = (s2x | s2y | s2z) < 0 ? 0 : (int)((s2Voxels[(idx2 = s2z + s2y*s2Mul1 + s2x*s2Mul2) >>> 6] >>> idx2) & 1L);
+ 
+                     // idx ff -> 0
+                     // idx ft -> 1
+@@ -911,11 +1167,11 @@ public final class CollisionUtil {
+         return true;
+     }
+ 
+-    public static net.minecraft.world.phys.shapes.VoxelShape joinOptimized(final net.minecraft.world.phys.shapes.VoxelShape first, final net.minecraft.world.phys.shapes.VoxelShape second, final net.minecraft.world.phys.shapes.BooleanOp operator) {
++    public static VoxelShape joinOptimized(final VoxelShape first, final VoxelShape second, final BooleanOp operator) {
+         return joinUnoptimized(first, second, operator).optimize();
+     }
+ 
+-    public static net.minecraft.world.phys.shapes.VoxelShape joinUnoptimized(final net.minecraft.world.phys.shapes.VoxelShape first, final net.minecraft.world.phys.shapes.VoxelShape second, final net.minecraft.world.phys.shapes.BooleanOp operator) {
++    public static VoxelShape joinUnoptimized(final VoxelShape first, final VoxelShape second, final BooleanOp operator) {
+         final boolean ff = operator.apply(false, false);
+         if (ff) {
+             // technically, should be an infinite box but that's clearly an error
+@@ -925,23 +1181,23 @@ public final class CollisionUtil {
+         final boolean tt = operator.apply(true, true);
+ 
+         if (first == second) {
+-            return tt ? first : net.minecraft.world.phys.shapes.Shapes.empty();
++            return tt ? first : Shapes.empty();
+         }
+ 
+         final boolean ft = operator.apply(false, true);
+         final boolean tf = operator.apply(true, false);
+ 
+         if (first.isEmpty()) {
+-            return ft ? second : net.minecraft.world.phys.shapes.Shapes.empty();
++            return ft ? second : Shapes.empty();
+         }
+         if (second.isEmpty()) {
+-            return tf ? first : net.minecraft.world.phys.shapes.Shapes.empty();
++            return tf ? first : Shapes.empty();
+         }
+ 
+         if (!tt) {
+             // try to check for no intersection, since tt = false
+-            final net.minecraft.world.phys.AABB aabbF = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)first).moonrise$getSingleAABBRepresentation();
+-            final net.minecraft.world.phys.AABB aabbS = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)second).moonrise$getSingleAABBRepresentation();
++            final AABB aabbF = ((CollisionVoxelShape)first).moonrise$getSingleAABBRepresentation();
++            final AABB aabbS = ((CollisionVoxelShape)second).moonrise$getSingleAABBRepresentation();
+ 
+             final boolean intersect;
+ 
+@@ -962,7 +1218,7 @@ public final class CollisionUtil {
+ 
+             if (!intersect) {
+                 if (!tf & !ft) {
+-                    return net.minecraft.world.phys.shapes.Shapes.empty();
++                    return Shapes.empty();
+                 }
+                 if (!tf | !ft) {
+                     return tf ? first : second;
+@@ -970,50 +1226,50 @@ public final class CollisionUtil {
+             }
+         }
+ 
+-        final ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.MergedVoxelCoordinateList mergedX = ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.MergedVoxelCoordinateList.merge(
+-                ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)first).moonrise$rootCoordinatesX(), ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)first).moonrise$offsetX(),
+-                ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)second).moonrise$rootCoordinatesX(), ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)second).moonrise$offsetX(),
++        final MergedVoxelCoordinateList mergedX = MergedVoxelCoordinateList.merge(
++                ((CollisionVoxelShape)first).moonrise$rootCoordinatesX(), ((CollisionVoxelShape)first).moonrise$offsetX(),
++                ((CollisionVoxelShape)second).moonrise$rootCoordinatesX(), ((CollisionVoxelShape)second).moonrise$offsetX(),
+                 ft, tf
+         );
+-        if (mergedX == ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.MergedVoxelCoordinateList.EMPTY) {
+-            return net.minecraft.world.phys.shapes.Shapes.empty();
++        if (mergedX == null) {
++            return Shapes.empty();
+         }
+-        final ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.MergedVoxelCoordinateList mergedY = ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.MergedVoxelCoordinateList.merge(
+-                ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)first).moonrise$rootCoordinatesY(), ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)first).moonrise$offsetY(),
+-                ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)second).moonrise$rootCoordinatesY(), ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)second).moonrise$offsetY(),
++        final MergedVoxelCoordinateList mergedY = MergedVoxelCoordinateList.merge(
++                ((CollisionVoxelShape)first).moonrise$rootCoordinatesY(), ((CollisionVoxelShape)first).moonrise$offsetY(),
++                ((CollisionVoxelShape)second).moonrise$rootCoordinatesY(), ((CollisionVoxelShape)second).moonrise$offsetY(),
+                 ft, tf
+         );
+-        if (mergedY == ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.MergedVoxelCoordinateList.EMPTY) {
+-            return net.minecraft.world.phys.shapes.Shapes.empty();
++        if (mergedY == null) {
++            return Shapes.empty();
+         }
+-        final ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.MergedVoxelCoordinateList mergedZ = ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.MergedVoxelCoordinateList.merge(
+-                ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)first).moonrise$rootCoordinatesZ(), ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)first).moonrise$offsetZ(),
+-                ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)second).moonrise$rootCoordinatesZ(), ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)second).moonrise$offsetZ(),
++        final MergedVoxelCoordinateList mergedZ = MergedVoxelCoordinateList.merge(
++                ((CollisionVoxelShape)first).moonrise$rootCoordinatesZ(), ((CollisionVoxelShape)first).moonrise$offsetZ(),
++                ((CollisionVoxelShape)second).moonrise$rootCoordinatesZ(), ((CollisionVoxelShape)second).moonrise$offsetZ(),
+                 ft, tf
+         );
+-        if (mergedZ == ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.MergedVoxelCoordinateList.EMPTY) {
+-            return net.minecraft.world.phys.shapes.Shapes.empty();
++        if (mergedZ == null) {
++            return Shapes.empty();
+         }
+ 
+-        final ca.spottedleaf.moonrise.patches.collisions.shape.CachedShapeData shapeDataFirst = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)first).moonrise$getCachedVoxelData();
+-        final ca.spottedleaf.moonrise.patches.collisions.shape.CachedShapeData shapeDataSecond = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)second).moonrise$getCachedVoxelData();
++        final CachedShapeData shapeDataFirst = ((CollisionVoxelShape)first).moonrise$getCachedVoxelData();
++        final CachedShapeData shapeDataSecond = ((CollisionVoxelShape)second).moonrise$getCachedVoxelData();
+ 
+-        final net.minecraft.world.phys.shapes.BitSetDiscreteVoxelShape mergedShape = merge(
++        final BitSetDiscreteVoxelShape mergedShape = merge(
+                 shapeDataFirst, shapeDataSecond,
+                 mergedX, mergedY, mergedZ,
+                 makeBitset(ft, tf, tt)
+         );
+ 
+         if (mergedShape == null) {
+-            return net.minecraft.world.phys.shapes.Shapes.empty();
++            return Shapes.empty();
+         }
+ 
+-        return new net.minecraft.world.phys.shapes.ArrayVoxelShape(
++        return new ArrayVoxelShape(
+                 mergedShape, mergedX.wrapCoords(), mergedY.wrapCoords(), mergedZ.wrapCoords()
+         );
+     }
+ 
+-    public static boolean isJoinNonEmpty(final net.minecraft.world.phys.shapes.VoxelShape first, final net.minecraft.world.phys.shapes.VoxelShape second, final net.minecraft.world.phys.shapes.BooleanOp operator) {
++    public static boolean isJoinNonEmpty(final VoxelShape first, final VoxelShape second, final BooleanOp operator) {
+         final boolean ff = operator.apply(false, false);
+         if (ff) {
+             // technically, should be an infinite box but that's clearly an error
+@@ -1035,8 +1291,8 @@ public final class CollisionUtil {
+         final boolean tf = operator.apply(true, false);
+ 
+         // try to check intersection
+-        final net.minecraft.world.phys.AABB aabbF = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)first).moonrise$getSingleAABBRepresentation();
+-        final net.minecraft.world.phys.AABB aabbS = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)second).moonrise$getSingleAABBRepresentation();
++        final AABB aabbF = ((CollisionVoxelShape)first).moonrise$getSingleAABBRepresentation();
++        final AABB aabbS = ((CollisionVoxelShape)second).moonrise$getSingleAABBRepresentation();
+ 
+         final boolean intersect;
+ 
+@@ -1068,33 +1324,33 @@ public final class CollisionUtil {
+             }
+         }
+ 
+-        final ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.MergedVoxelCoordinateList mergedX = ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.MergedVoxelCoordinateList.merge(
+-                ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)first).moonrise$rootCoordinatesX(), ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)first).moonrise$offsetX(),
+-                ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)second).moonrise$rootCoordinatesX(), ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)second).moonrise$offsetX(),
++        final MergedVoxelCoordinateList mergedX = MergedVoxelCoordinateList.merge(
++                ((CollisionVoxelShape)first).moonrise$rootCoordinatesX(), ((CollisionVoxelShape)first).moonrise$offsetX(),
++                ((CollisionVoxelShape)second).moonrise$rootCoordinatesX(), ((CollisionVoxelShape)second).moonrise$offsetX(),
+                 ft, tf
+         );
+-        if (mergedX == ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.MergedVoxelCoordinateList.EMPTY) {
++        if (mergedX == null) {
+             return false;
+         }
+-        final ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.MergedVoxelCoordinateList mergedY = ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.MergedVoxelCoordinateList.merge(
+-                ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)first).moonrise$rootCoordinatesY(), ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)first).moonrise$offsetY(),
+-                ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)second).moonrise$rootCoordinatesY(), ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)second).moonrise$offsetY(),
++        final MergedVoxelCoordinateList mergedY = MergedVoxelCoordinateList.merge(
++                ((CollisionVoxelShape)first).moonrise$rootCoordinatesY(), ((CollisionVoxelShape)first).moonrise$offsetY(),
++                ((CollisionVoxelShape)second).moonrise$rootCoordinatesY(), ((CollisionVoxelShape)second).moonrise$offsetY(),
+                 ft, tf
+         );
+-        if (mergedY == ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.MergedVoxelCoordinateList.EMPTY) {
++        if (mergedY == null) {
+             return false;
+         }
+-        final ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.MergedVoxelCoordinateList mergedZ = ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.MergedVoxelCoordinateList.merge(
+-                ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)first).moonrise$rootCoordinatesZ(), ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)first).moonrise$offsetZ(),
+-                ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)second).moonrise$rootCoordinatesZ(), ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)second).moonrise$offsetZ(),
++        final MergedVoxelCoordinateList mergedZ = MergedVoxelCoordinateList.merge(
++                ((CollisionVoxelShape)first).moonrise$rootCoordinatesZ(), ((CollisionVoxelShape)first).moonrise$offsetZ(),
++                ((CollisionVoxelShape)second).moonrise$rootCoordinatesZ(), ((CollisionVoxelShape)second).moonrise$offsetZ(),
+                 ft, tf
+         );
+-        if (mergedZ == ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.MergedVoxelCoordinateList.EMPTY) {
++        if (mergedZ == null) {
+             return false;
+         }
+ 
+-        final ca.spottedleaf.moonrise.patches.collisions.shape.CachedShapeData shapeDataFirst = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)first).moonrise$getCachedVoxelData();
+-        final ca.spottedleaf.moonrise.patches.collisions.shape.CachedShapeData shapeDataSecond = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)second).moonrise$getCachedVoxelData();
++        final CachedShapeData shapeDataFirst = ((CollisionVoxelShape)first).moonrise$getCachedVoxelData();
++        final CachedShapeData shapeDataSecond = ((CollisionVoxelShape)second).moonrise$getCachedVoxelData();
+ 
+         return !isMergeEmpty(
+                 shapeDataFirst, shapeDataSecond,
+@@ -1112,10 +1368,6 @@ public final class CollisionUtil {
+             }
+         }
+ 
+-        private static final ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.MergedVoxelCoordinateList EMPTY = new ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.MergedVoxelCoordinateList(
+-                new double[] { 0.0 }, 0.0, new int[0], new int[0], 0
+-        );
+-
+         private static int[] getIndices(final int length) {
+             final int[] ret = new int[length];
+ 
+@@ -1142,25 +1394,25 @@ public final class CollisionUtil {
+             this.voxels = voxels;
+         }
+ 
+-        public it.unimi.dsi.fastutil.doubles.DoubleList wrapCoords() {
++        public DoubleList wrapCoords() {
+             if (this.coordinateOffset == 0.0) {
+-                return it.unimi.dsi.fastutil.doubles.DoubleArrayList.wrap(this.coordinates, this.voxels + 1);
++                return DoubleArrayList.wrap(this.coordinates, this.voxels + 1);
+             }
+-            return new net.minecraft.world.phys.shapes.OffsetDoubleList(it.unimi.dsi.fastutil.doubles.DoubleArrayList.wrap(this.coordinates, this.voxels + 1), this.coordinateOffset);
++            return new OffsetDoubleList(DoubleArrayList.wrap(this.coordinates, this.voxels + 1), this.coordinateOffset);
+         }
+ 
+         // assume coordinates.length > 1
+-        public static ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.MergedVoxelCoordinateList getForSingle(final double[] coordinates, final double offset) {
++        public static MergedVoxelCoordinateList getForSingle(final double[] coordinates, final double offset) {
+             final int voxels = coordinates.length - 1;
+             final int[] indices = voxels < SIMPLE_INDICES_CACHE.length ? SIMPLE_INDICES_CACHE[voxels] : getIndices(voxels);
+ 
+-            return new ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.MergedVoxelCoordinateList(coordinates, offset, indices, indices, voxels);
++            return new MergedVoxelCoordinateList(coordinates, offset, indices, indices, voxels);
+         }
+ 
+         // assume coordinates.length > 1
+-        public static ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.MergedVoxelCoordinateList merge(final double[] firstCoordinates, final double firstOffset,
+-                                                                                                               final double[] secondCoordinates, final double secondOffset,
+-                                                                                                               final boolean ft, final boolean tf) {
++        public static MergedVoxelCoordinateList merge(final double[] firstCoordinates, final double firstOffset,
++                                                      final double[] secondCoordinates, final double secondOffset,
++                                                      final boolean ft, final boolean tf) {
+             if (firstCoordinates == secondCoordinates && firstOffset == secondOffset) {
+                 return getForSingle(firstCoordinates, firstOffset);
+             }
+@@ -1250,13 +1502,13 @@ public final class CollisionUtil {
+                 }
+             }
+ 
+-            return resultSize <= 1 ? EMPTY : new ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.MergedVoxelCoordinateList(coordinates, 0.0, firstIndices, secondIndices, resultSize - 1);
++            return resultSize <= 1 ? null : new MergedVoxelCoordinateList(coordinates, 0.0, firstIndices, secondIndices, resultSize - 1);
+         }
+     }
+ 
+-    public static boolean equals(final net.minecraft.world.phys.shapes.DiscreteVoxelShape shape1, final net.minecraft.world.phys.shapes.DiscreteVoxelShape shape2) {
+-        final ca.spottedleaf.moonrise.patches.collisions.shape.CachedShapeData cachedShapeData1 = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionDiscreteVoxelShape)shape1).moonrise$getOrCreateCachedShapeData();
+-        final ca.spottedleaf.moonrise.patches.collisions.shape.CachedShapeData cachedShapeData2 = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionDiscreteVoxelShape)shape2).moonrise$getOrCreateCachedShapeData();
++    public static boolean equals(final DiscreteVoxelShape shape1, final DiscreteVoxelShape shape2) {
++        final CachedShapeData cachedShapeData1 = ((CollisionDiscreteVoxelShape)shape1).moonrise$getOrCreateCachedShapeData();
++        final CachedShapeData cachedShapeData2 = ((CollisionDiscreteVoxelShape)shape2).moonrise$getOrCreateCachedShapeData();
+ 
+         final boolean isEmpty1 = cachedShapeData1.isEmpty();
+         final boolean isEmpty2 = cachedShapeData2.isEmpty();
+@@ -1265,7 +1517,7 @@ public final class CollisionUtil {
+             return true;
+         } else if (isEmpty1 ^ isEmpty2) {
+             return false;
+-        }
++        } // else: isEmpty1 = isEmpty2 = false
+ 
+         if (cachedShapeData1.hasSingleAABB() != cachedShapeData2.hasSingleAABB()) {
+             return false;
+@@ -1281,153 +1533,237 @@ public final class CollisionUtil {
+             return false;
+         }
+ 
+-        return java.util.Arrays.equals(cachedShapeData1.voxelSet(), cachedShapeData2.voxelSet());
++        return Arrays.equals(cachedShapeData1.voxelSet(), cachedShapeData2.voxelSet());
+     }
+ 
+     // useful only for testing
+-    public static boolean equals(final net.minecraft.world.phys.shapes.VoxelShape shape1, final net.minecraft.world.phys.shapes.VoxelShape shape2) {
++    public static boolean equals(final VoxelShape shape1, final VoxelShape shape2) {
++        if (shape1.isEmpty() & shape2.isEmpty()) {
++            return true;
++        } else if (shape1.isEmpty() ^ shape2.isEmpty()) {
++            return false;
++        }
++
+         if (!equals(shape1.shape, shape2.shape)) {
+             return false;
+         }
+ 
+-        return shape1.getCoords(net.minecraft.core.Direction.Axis.X).equals(shape2.getCoords(net.minecraft.core.Direction.Axis.X)) &&
+-                shape1.getCoords(net.minecraft.core.Direction.Axis.Y).equals(shape2.getCoords(net.minecraft.core.Direction.Axis.Y)) &&
+-                shape1.getCoords(net.minecraft.core.Direction.Axis.Z).equals(shape2.getCoords(net.minecraft.core.Direction.Axis.Z));
++        return shape1.getCoords(Direction.Axis.X).equals(shape2.getCoords(Direction.Axis.X)) &&
++                shape1.getCoords(Direction.Axis.Y).equals(shape2.getCoords(Direction.Axis.Y)) &&
++                shape1.getCoords(Direction.Axis.Z).equals(shape2.getCoords(Direction.Axis.Z));
++    }
++
++    public static boolean areAnyFull(final DiscreteVoxelShape shape) {
++        if (shape.isEmpty()) {
++            return false;
++        }
++
++        final int sizeX = shape.getXSize();
++        final int sizeY = shape.getYSize();
++        final int sizeZ = shape.getZSize();
++
++        for (int x = 0; x < sizeX; ++x) {
++            for (int y = 0; y < sizeY; ++y) {
++                for (int z = 0; z < sizeZ; ++z) {
++                    if (shape.isFull(x, y, z)) {
++                        return true;
++                    }
++                }
++            }
++        }
++
++        return false;
++    }
++
++    public static String shapeMismatch(final DiscreteVoxelShape shape1, final DiscreteVoxelShape shape2) {
++        final CachedShapeData cachedShapeData1 = ((CollisionDiscreteVoxelShape)shape1).moonrise$getOrCreateCachedShapeData();
++        final CachedShapeData cachedShapeData2 = ((CollisionDiscreteVoxelShape)shape2).moonrise$getOrCreateCachedShapeData();
++
++        final boolean isEmpty1 = cachedShapeData1.isEmpty();
++        final boolean isEmpty2 = cachedShapeData2.isEmpty();
++
++        if (isEmpty1 & isEmpty2) {
++            return null;
++        } else if (isEmpty1 ^ isEmpty2) {
++            return null;
++        } // else: isEmpty1 = isEmpty2 = false
++
++        if (cachedShapeData1.sizeX() != cachedShapeData2.sizeX()) {
++            return "size x: " + cachedShapeData1.sizeX() + " != " + cachedShapeData2.sizeX();
++        }
++        if (cachedShapeData1.sizeY() != cachedShapeData2.sizeY()) {
++            return "size y: " + cachedShapeData1.sizeY() + " != " + cachedShapeData2.sizeY();
++        }
++        if (cachedShapeData1.sizeZ() != cachedShapeData2.sizeZ()) {
++            return "size z: " + cachedShapeData1.sizeZ() + " != " + cachedShapeData2.sizeZ();
++        }
++
++        final StringBuilder ret = new StringBuilder();
++
++        final int sizeX = cachedShapeData1.sizeX();;
++        final int sizeY = cachedShapeData1.sizeY();
++        final int sizeZ = cachedShapeData1.sizeZ();
++
++        boolean first = true;
++
++        for (int x = 0; x < sizeX; ++x) {
++            for (int y = 0; y < sizeY; ++y) {
++                for (int z = 0; z < sizeZ; ++z) {
++                    final boolean isFull1 = shape1.isFull(x, y, z);
++                    final boolean isFull2 = shape2.isFull(x, y, z);
++
++                    if (isFull1 == isFull2) {
++                        continue;
++                    }
++
++                    if (first) {
++                        first = false;
++                    } else {
++                        ret.append(", ");
++                    }
++
++                    ret.append("(").append(x).append(",").append(y).append(",").append(z)
++                        .append("): shape1: ").append(isFull1).append(", shape2: ").append(isFull2);
++                }
++            }
++        }
++
++        return ret.isEmpty() ? null : ret.toString();
+     }
+ 
+-    public static net.minecraft.world.phys.AABB offsetX(final net.minecraft.world.phys.AABB box, final double dx) {
+-        return new net.minecraft.world.phys.AABB(box.minX + dx, box.minY, box.minZ, box.maxX + dx, box.maxY, box.maxZ);
++    public static AABB offsetX(final AABB box, final double dx) {
++        return new AABB(box.minX + dx, box.minY, box.minZ, box.maxX + dx, box.maxY, box.maxZ);
+     }
+ 
+-    public static net.minecraft.world.phys.AABB offsetY(final net.minecraft.world.phys.AABB box, final double dy) {
+-        return new net.minecraft.world.phys.AABB(box.minX, box.minY + dy, box.minZ, box.maxX, box.maxY + dy, box.maxZ);
++    public static AABB offsetY(final AABB box, final double dy) {
++        return new AABB(box.minX, box.minY + dy, box.minZ, box.maxX, box.maxY + dy, box.maxZ);
+     }
+ 
+-    public static net.minecraft.world.phys.AABB offsetZ(final net.minecraft.world.phys.AABB box, final double dz) {
+-        return new net.minecraft.world.phys.AABB(box.minX, box.minY, box.minZ + dz, box.maxX, box.maxY, box.maxZ + dz);
++    public static AABB offsetZ(final AABB box, final double dz) {
++        return new AABB(box.minX, box.minY, box.minZ + dz, box.maxX, box.maxY, box.maxZ + dz);
+     }
+ 
+-    public static net.minecraft.world.phys.AABB expandRight(final net.minecraft.world.phys.AABB box, final double dx) { // dx > 0.0
+-        return new net.minecraft.world.phys.AABB(box.minX, box.minY, box.minZ, box.maxX + dx, box.maxY, box.maxZ);
++    public static AABB expandRight(final AABB box, final double dx) { // dx > 0.0
++        return new AABB(box.minX, box.minY, box.minZ, box.maxX + dx, box.maxY, box.maxZ);
+     }
+ 
+-    public static net.minecraft.world.phys.AABB expandLeft(final net.minecraft.world.phys.AABB box, final double dx) { // dx < 0.0
+-        return new net.minecraft.world.phys.AABB(box.minX - dx, box.minY, box.minZ, box.maxX, box.maxY, box.maxZ);
++    public static AABB expandLeft(final AABB box, final double dx) { // dx < 0.0
++        return new AABB(box.minX - dx, box.minY, box.minZ, box.maxX, box.maxY, box.maxZ);
+     }
+ 
+-    public static net.minecraft.world.phys.AABB expandUpwards(final net.minecraft.world.phys.AABB box, final double dy) { // dy > 0.0
+-        return new net.minecraft.world.phys.AABB(box.minX, box.minY, box.minZ, box.maxX, box.maxY + dy, box.maxZ);
++    public static AABB expandUpwards(final AABB box, final double dy) { // dy > 0.0
++        return new AABB(box.minX, box.minY, box.minZ, box.maxX, box.maxY + dy, box.maxZ);
+     }
+ 
+-    public static net.minecraft.world.phys.AABB expandDownwards(final net.minecraft.world.phys.AABB box, final double dy) { // dy < 0.0
+-        return new net.minecraft.world.phys.AABB(box.minX, box.minY - dy, box.minZ, box.maxX, box.maxY, box.maxZ);
++    public static AABB expandDownwards(final AABB box, final double dy) { // dy < 0.0
++        return new AABB(box.minX, box.minY - dy, box.minZ, box.maxX, box.maxY, box.maxZ);
+     }
+ 
+-    public static net.minecraft.world.phys.AABB expandForwards(final net.minecraft.world.phys.AABB box, final double dz) { // dz > 0.0
+-        return new net.minecraft.world.phys.AABB(box.minX, box.minY, box.minZ, box.maxX, box.maxY, box.maxZ + dz);
++    public static AABB expandForwards(final AABB box, final double dz) { // dz > 0.0
++        return new AABB(box.minX, box.minY, box.minZ, box.maxX, box.maxY, box.maxZ + dz);
+     }
+ 
+-    public static net.minecraft.world.phys.AABB expandBackwards(final net.minecraft.world.phys.AABB box, final double dz) { // dz < 0.0
+-        return new net.minecraft.world.phys.AABB(box.minX, box.minY, box.minZ - dz, box.maxX, box.maxY, box.maxZ);
++    public static AABB expandBackwards(final AABB box, final double dz) { // dz < 0.0
++        return new AABB(box.minX, box.minY, box.minZ - dz, box.maxX, box.maxY, box.maxZ);
+     }
+ 
+-    public static net.minecraft.world.phys.AABB cutRight(final net.minecraft.world.phys.AABB box, final double dx) { // dx > 0.0
+-        return new net.minecraft.world.phys.AABB(box.maxX, box.minY, box.minZ, box.maxX + dx, box.maxY, box.maxZ);
++    public static AABB cutRight(final AABB box, final double dx) { // dx > 0.0
++        return new AABB(box.maxX, box.minY, box.minZ, box.maxX + dx, box.maxY, box.maxZ);
+     }
+ 
+-    public static net.minecraft.world.phys.AABB cutLeft(final net.minecraft.world.phys.AABB box, final double dx) { // dx < 0.0
+-        return new net.minecraft.world.phys.AABB(box.minX + dx, box.minY, box.minZ, box.minX, box.maxY, box.maxZ);
++    public static AABB cutLeft(final AABB box, final double dx) { // dx < 0.0
++        return new AABB(box.minX + dx, box.minY, box.minZ, box.minX, box.maxY, box.maxZ);
+     }
+ 
+-    public static net.minecraft.world.phys.AABB cutUpwards(final net.minecraft.world.phys.AABB box, final double dy) { // dy > 0.0
+-        return new net.minecraft.world.phys.AABB(box.minX, box.maxY, box.minZ, box.maxX, box.maxY + dy, box.maxZ);
++    public static AABB cutUpwards(final AABB box, final double dy) { // dy > 0.0
++        return new AABB(box.minX, box.maxY, box.minZ, box.maxX, box.maxY + dy, box.maxZ);
+     }
+ 
+-    public static net.minecraft.world.phys.AABB cutDownwards(final net.minecraft.world.phys.AABB box, final double dy) { // dy < 0.0
+-        return new net.minecraft.world.phys.AABB(box.minX, box.minY + dy, box.minZ, box.maxX, box.minY, box.maxZ);
++    public static AABB cutDownwards(final AABB box, final double dy) { // dy < 0.0
++        return new AABB(box.minX, box.minY + dy, box.minZ, box.maxX, box.minY, box.maxZ);
+     }
+ 
+-    public static net.minecraft.world.phys.AABB cutForwards(final net.minecraft.world.phys.AABB box, final double dz) { // dz > 0.0
+-        return new net.minecraft.world.phys.AABB(box.minX, box.minY, box.maxZ, box.maxX, box.maxY, box.maxZ + dz);
++    public static AABB cutForwards(final AABB box, final double dz) { // dz > 0.0
++        return new AABB(box.minX, box.minY, box.maxZ, box.maxX, box.maxY, box.maxZ + dz);
+     }
+ 
+-    public static net.minecraft.world.phys.AABB cutBackwards(final net.minecraft.world.phys.AABB box, final double dz) { // dz < 0.0
+-        return new net.minecraft.world.phys.AABB(box.minX, box.minY, box.minZ + dz, box.maxX, box.maxY, box.minZ);
++    public static AABB cutBackwards(final AABB box, final double dz) { // dz < 0.0
++        return new AABB(box.minX, box.minY, box.minZ + dz, box.maxX, box.maxY, box.minZ);
+     }
+ 
+-    public static double performAABBCollisionsX(final net.minecraft.world.phys.AABB currentBoundingBox, double value, final java.util.List<net.minecraft.world.phys.AABB> potentialCollisions) {
++    public static double performAABBCollisionsX(final AABB currentBoundingBox, double value, final List<AABB> potentialCollisions) {
+         for (int i = 0, len = potentialCollisions.size(); i < len; ++i) {
+             if (Math.abs(value) < COLLISION_EPSILON) {
+                 return 0.0;
+             }
+-            final net.minecraft.world.phys.AABB target = potentialCollisions.get(i);
++            final AABB target = potentialCollisions.get(i);
+             value = collideX(target, currentBoundingBox, value);
+         }
+ 
+-        return value;
++        return Math.abs(value) < COLLISION_EPSILON ? 0.0 : value;
+     }
+ 
+-    public static double performAABBCollisionsY(final net.minecraft.world.phys.AABB currentBoundingBox, double value, final java.util.List<net.minecraft.world.phys.AABB> potentialCollisions) {
++    public static double performAABBCollisionsY(final AABB currentBoundingBox, double value, final List<AABB> potentialCollisions) {
+         for (int i = 0, len = potentialCollisions.size(); i < len; ++i) {
+             if (Math.abs(value) < COLLISION_EPSILON) {
+                 return 0.0;
+             }
+-            final net.minecraft.world.phys.AABB target = potentialCollisions.get(i);
++            final AABB target = potentialCollisions.get(i);
+             value = collideY(target, currentBoundingBox, value);
+         }
+ 
+-        return value;
++        return Math.abs(value) < COLLISION_EPSILON ? 0.0 : value;
+     }
+ 
+-    public static double performAABBCollisionsZ(final net.minecraft.world.phys.AABB currentBoundingBox, double value, final java.util.List<net.minecraft.world.phys.AABB> potentialCollisions) {
++    public static double performAABBCollisionsZ(final AABB currentBoundingBox, double value, final List<AABB> potentialCollisions) {
+         for (int i = 0, len = potentialCollisions.size(); i < len; ++i) {
+             if (Math.abs(value) < COLLISION_EPSILON) {
+                 return 0.0;
+             }
+-            final net.minecraft.world.phys.AABB target = potentialCollisions.get(i);
++            final AABB target = potentialCollisions.get(i);
+             value = collideZ(target, currentBoundingBox, value);
+         }
+ 
+-        return value;
++        return Math.abs(value) < COLLISION_EPSILON ? 0.0 : value;
+     }
+ 
+-    public static double performVoxelCollisionsX(final net.minecraft.world.phys.AABB currentBoundingBox, double value, final java.util.List<net.minecraft.world.phys.shapes.VoxelShape> potentialCollisions) {
++    public static double performVoxelCollisionsX(final AABB currentBoundingBox, double value, final List<VoxelShape> potentialCollisions) {
+         for (int i = 0, len = potentialCollisions.size(); i < len; ++i) {
+             if (Math.abs(value) < COLLISION_EPSILON) {
+                 return 0.0;
+             }
+-            final net.minecraft.world.phys.shapes.VoxelShape target = potentialCollisions.get(i);
++            final VoxelShape target = potentialCollisions.get(i);
+             value = collideX(target, currentBoundingBox, value);
+         }
+ 
+-        return value;
++        return Math.abs(value) < COLLISION_EPSILON ? 0.0 : value;
+     }
+ 
+-    public static double performVoxelCollisionsY(final net.minecraft.world.phys.AABB currentBoundingBox, double value, final java.util.List<net.minecraft.world.phys.shapes.VoxelShape> potentialCollisions) {
++    public static double performVoxelCollisionsY(final AABB currentBoundingBox, double value, final List<VoxelShape> potentialCollisions) {
+         for (int i = 0, len = potentialCollisions.size(); i < len; ++i) {
+             if (Math.abs(value) < COLLISION_EPSILON) {
+                 return 0.0;
+             }
+-            final net.minecraft.world.phys.shapes.VoxelShape target = potentialCollisions.get(i);
++            final VoxelShape target = potentialCollisions.get(i);
+             value = collideY(target, currentBoundingBox, value);
+         }
+ 
+-        return value;
++        return Math.abs(value) < COLLISION_EPSILON ? 0.0 : value;
+     }
+ 
+-    public static double performVoxelCollisionsZ(final net.minecraft.world.phys.AABB currentBoundingBox, double value, final java.util.List<net.minecraft.world.phys.shapes.VoxelShape> potentialCollisions) {
++    public static double performVoxelCollisionsZ(final AABB currentBoundingBox, double value, final List<VoxelShape> potentialCollisions) {
+         for (int i = 0, len = potentialCollisions.size(); i < len; ++i) {
+             if (Math.abs(value) < COLLISION_EPSILON) {
+                 return 0.0;
+             }
+-            final net.minecraft.world.phys.shapes.VoxelShape target = potentialCollisions.get(i);
++            final VoxelShape target = potentialCollisions.get(i);
+             value = collideZ(target, currentBoundingBox, value);
+         }
+ 
+-        return value;
++        return Math.abs(value) < COLLISION_EPSILON ? 0.0 : value;
+     }
+ 
+-    public static net.minecraft.world.phys.Vec3 performVoxelCollisions(final net.minecraft.world.phys.Vec3 moveVector, net.minecraft.world.phys.AABB axisalignedbb, final java.util.List<net.minecraft.world.phys.shapes.VoxelShape> potentialCollisions) {
++    public static Vec3 performVoxelCollisions(final Vec3 moveVector, AABB axisalignedbb, final List<VoxelShape> potentialCollisions) {
+         double x = moveVector.x;
+         double y = moveVector.y;
+         double z = moveVector.z;
+@@ -1459,10 +1795,10 @@ public final class CollisionUtil {
+             z = performVoxelCollisionsZ(axisalignedbb, z, potentialCollisions);
+         }
+ 
+-        return new net.minecraft.world.phys.Vec3(x, y, z);
++        return new Vec3(x, y, z);
+     }
+ 
+-    public static net.minecraft.world.phys.Vec3 performAABBCollisions(final net.minecraft.world.phys.Vec3 moveVector, net.minecraft.world.phys.AABB axisalignedbb, final java.util.List<net.minecraft.world.phys.AABB> potentialCollisions) {
++    public static Vec3 performAABBCollisions(final Vec3 moveVector, AABB axisalignedbb, final List<AABB> potentialCollisions) {
+         double x = moveVector.x;
+         double y = moveVector.y;
+         double z = moveVector.z;
+@@ -1494,12 +1830,12 @@ public final class CollisionUtil {
+             z = performAABBCollisionsZ(axisalignedbb, z, potentialCollisions);
+         }
+ 
+-        return new net.minecraft.world.phys.Vec3(x, y, z);
++        return new Vec3(x, y, z);
+     }
+ 
+-    public static net.minecraft.world.phys.Vec3 performCollisions(final net.minecraft.world.phys.Vec3 moveVector, net.minecraft.world.phys.AABB axisalignedbb,
+-                                                                  final java.util.List<net.minecraft.world.phys.shapes.VoxelShape> voxels,
+-                                                                  final java.util.List<net.minecraft.world.phys.AABB> aabbs) {
++    public static Vec3 performCollisions(final Vec3 moveVector, AABB axisalignedbb,
++                                         final List<VoxelShape> voxels,
++                                         final List<AABB> aabbs) {
+         if (voxels.isEmpty()) {
+             // fast track only AABBs
+             return performAABBCollisions(moveVector, axisalignedbb, aabbs);
+@@ -1540,14 +1876,14 @@ public final class CollisionUtil {
+             z = performVoxelCollisionsZ(axisalignedbb, z, voxels);
+         }
+ 
+-        return new net.minecraft.world.phys.Vec3(x, y, z);
++        return new Vec3(x, y, z);
+     }
+ 
+-    public static boolean isCollidingWithBorder(final net.minecraft.world.level.border.WorldBorder worldborder, final net.minecraft.world.phys.AABB boundingBox) {
++    public static boolean isCollidingWithBorder(final WorldBorder worldborder, final AABB boundingBox) {
+         return isCollidingWithBorder(worldborder, boundingBox.minX, boundingBox.maxX, boundingBox.minZ, boundingBox.maxZ);
+     }
+ 
+-    public static boolean isCollidingWithBorder(final net.minecraft.world.level.border.WorldBorder worldborder,
++    public static boolean isCollidingWithBorder(final WorldBorder worldborder,
+                                                 final double boxMinX, final double boxMaxX,
+                                                 final double boxMinZ, final double boxMaxZ) {
+         final double borderMinX = Math.floor(worldborder.getMinX()); // -X
+@@ -1557,8 +1893,8 @@ public final class CollisionUtil {
+         final double borderMaxZ = Math.ceil(worldborder.getMaxZ()); // +Z
+ 
+         // inverted check for world border enclosing the specified box expanded by -EPSILON
+-        return (borderMinX - boxMinX) > ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.COLLISION_EPSILON || (borderMaxX - boxMaxX) < -ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.COLLISION_EPSILON ||
+-                (borderMinZ - boxMinZ) > ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.COLLISION_EPSILON || (borderMaxZ - boxMaxZ) < -ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.COLLISION_EPSILON;
++        return (borderMinX - boxMinX) > CollisionUtil.COLLISION_EPSILON || (borderMaxX - boxMaxX) < -CollisionUtil.COLLISION_EPSILON ||
++                (borderMinZ - boxMinZ) > CollisionUtil.COLLISION_EPSILON || (borderMaxZ - boxMaxZ) < -CollisionUtil.COLLISION_EPSILON;
+     }
+ 
+     /* Math.max/min specify that any NaN argument results in a NaN return, unlike these functions */
+@@ -1575,38 +1911,38 @@ public final class CollisionUtil {
+     public static final int COLLISION_FLAG_CHECK_BORDER = 1 << 2;
+     public static final int COLLISION_FLAG_CHECK_ONLY = 1 << 3;
+ 
+-    public static boolean getCollisionsForBlocksOrWorldBorder(final net.minecraft.world.level.Level world, final net.minecraft.world.entity.Entity entity, final net.minecraft.world.phys.AABB aabb,
+-                                                              final java.util.List<net.minecraft.world.phys.shapes.VoxelShape> intoVoxel, final java.util.List<net.minecraft.world.phys.AABB> intoAABB,
+-                                                              final int collisionFlags, final java.util.function.BiPredicate<net.minecraft.world.level.block.state.BlockState, net.minecraft.core.BlockPos> predicate) {
++    public static boolean getCollisionsForBlocksOrWorldBorder(final Level world, final Entity entity, final AABB aabb,
++                                                              final List<VoxelShape> intoVoxel, final List<AABB> intoAABB,
++                                                              final int collisionFlags, final BiPredicate<BlockState, BlockPos> predicate) {
+         final boolean checkOnly = (collisionFlags & COLLISION_FLAG_CHECK_ONLY) != 0;
+         boolean ret = false;
+ 
+         if ((collisionFlags & COLLISION_FLAG_CHECK_BORDER) != 0) {
+-            final net.minecraft.world.level.border.WorldBorder worldBorder = world.getWorldBorder();
+-            if (ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.isCollidingWithBorder(worldBorder, aabb) && entity != null && worldBorder.isInsideCloseToBorder(entity, aabb)) {
++            final WorldBorder worldBorder = world.getWorldBorder();
++            if (CollisionUtil.isCollidingWithBorder(worldBorder, aabb) && entity != null && worldBorder.isInsideCloseToBorder(entity, aabb)) {
+                 if (checkOnly) {
+                     return true;
+                 } else {
+-                    final net.minecraft.world.phys.shapes.VoxelShape borderShape = worldBorder.getCollisionShape();
++                    final VoxelShape borderShape = worldBorder.getCollisionShape();
+                     intoVoxel.add(borderShape);
+                     ret = true;
+                 }
+             }
+         }
+ 
+-        final int minSection = ((ca.spottedleaf.moonrise.patches.collisions.world.CollisionLevel)world).moonrise$getMinSection();
++        final int minSection = WorldUtil.getMinSection(world);
+ 
+-        final int minBlockX = net.minecraft.util.Mth.floor(aabb.minX - COLLISION_EPSILON) - 1;
+-        final int maxBlockX = net.minecraft.util.Mth.floor(aabb.maxX + COLLISION_EPSILON) + 1;
++        final int minBlockX = Mth.floor(aabb.minX - COLLISION_EPSILON) - 1;
++        final int maxBlockX = Mth.floor(aabb.maxX + COLLISION_EPSILON) + 1;
+ 
+-        final int minBlockY = Math.max((minSection << 4) - 1, net.minecraft.util.Mth.floor(aabb.minY - COLLISION_EPSILON) - 1);
+-        final int maxBlockY = Math.min((((ca.spottedleaf.moonrise.patches.collisions.world.CollisionLevel)world).moonrise$getMaxSection() << 4) + 16, net.minecraft.util.Mth.floor(aabb.maxY + COLLISION_EPSILON) + 1);
++        final int minBlockY = Math.max((minSection << 4) - 1, Mth.floor(aabb.minY - COLLISION_EPSILON) - 1);
++        final int maxBlockY = Math.min((WorldUtil.getMaxSection(world) << 4) + 16, Mth.floor(aabb.maxY + COLLISION_EPSILON) + 1);
+ 
+-        final int minBlockZ = net.minecraft.util.Mth.floor(aabb.minZ - COLLISION_EPSILON) - 1;
+-        final int maxBlockZ = net.minecraft.util.Mth.floor(aabb.maxZ + COLLISION_EPSILON) + 1;
++        final int minBlockZ = Mth.floor(aabb.minZ - COLLISION_EPSILON) - 1;
++        final int maxBlockZ = Mth.floor(aabb.maxZ + COLLISION_EPSILON) + 1;
+ 
+-        final net.minecraft.core.BlockPos.MutableBlockPos mutablePos = new net.minecraft.core.BlockPos.MutableBlockPos();
+-        final net.minecraft.world.phys.shapes.CollisionContext collisionShape = new ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.LazyEntityCollisionContext(entity);
++        final BlockPos.MutableBlockPos mutablePos = new BlockPos.MutableBlockPos();
++        final CollisionContext collisionShape = new LazyEntityCollisionContext(entity);
+ 
+         // special cases:
+         if (minBlockY > maxBlockY) {
+@@ -1624,11 +1960,11 @@ public final class CollisionUtil {
+         final int maxChunkZ = maxBlockZ >> 4;
+ 
+         final boolean loadChunks = (collisionFlags & COLLISION_FLAG_LOAD_CHUNKS) != 0;
+-        final net.minecraft.world.level.chunk.ChunkSource chunkSource = world.getChunkSource();
++        final ChunkSource chunkSource = world.getChunkSource();
+ 
+         for (int currChunkZ = minChunkZ; currChunkZ <= maxChunkZ; ++currChunkZ) {
+             for (int currChunkX = minChunkX; currChunkX <= maxChunkX; ++currChunkX) {
+-                final net.minecraft.world.level.chunk.ChunkAccess chunk = chunkSource.getChunk(currChunkX, currChunkZ, net.minecraft.world.level.chunk.status.ChunkStatus.FULL, loadChunks);
++                final ChunkAccess chunk = chunkSource.getChunk(currChunkX, currChunkZ, ChunkStatus.FULL, loadChunks);
+ 
+                 if (chunk == null) {
+                     if ((collisionFlags & COLLISION_FLAG_COLLIDE_WITH_UNLOADED_CHUNKS) != 0) {
+@@ -1642,7 +1978,7 @@ public final class CollisionUtil {
+                     continue;
+                 }
+ 
+-                final net.minecraft.world.level.chunk.LevelChunkSection[] sections = chunk.getSections();
++                final LevelChunkSection[] sections = chunk.getSections();
+ 
+                 // bound y
+                 for (int currChunkY = minChunkY; currChunkY <= maxChunkY; ++currChunkY) {
+@@ -1650,16 +1986,16 @@ public final class CollisionUtil {
+                     if (sectionIdx < 0 || sectionIdx >= sections.length) {
+                         continue;
+                     }
+-                    final net.minecraft.world.level.chunk.LevelChunkSection section = sections[sectionIdx];
+-                    if (section == null || section.hasOnlyAir()) {
++                    final LevelChunkSection section = sections[sectionIdx];
++                    if (section.hasOnlyAir()) {
+                         // empty
+                         continue;
+                     }
+ 
+-                    final boolean hasSpecial = ((ca.spottedleaf.moonrise.patches.block_counting.BlockCountingChunkSection)section).moonrise$getSpecialCollidingBlocks() != 0;
++                    final boolean hasSpecial = ((BlockCountingChunkSection)section).moonrise$hasSpecialCollidingBlocks();
+                     final int sectionAdjust = !hasSpecial ? 1 : 0;
+ 
+-                    final net.minecraft.world.level.chunk.PalettedContainer<net.minecraft.world.level.block.state.BlockState> blocks = section.states;
++                    final PalettedContainer<BlockState> blocks = section.states;
+ 
+                     final int minXIterate = currChunkX == minChunkX ? (minBlockX & 15) + sectionAdjust : 0;
+                     final int maxXIterate = currChunkX == maxChunkX ? (maxBlockX & 15) - sectionAdjust : 15;
+@@ -1683,21 +2019,21 @@ public final class CollisionUtil {
+                                     continue;
+                                 }
+ 
+-                                final net.minecraft.world.level.block.state.BlockState blockData = blocks.get(localBlockIndex);
++                                final BlockState blockData = blocks.get(localBlockIndex);
+ 
+-                                if (((ca.spottedleaf.moonrise.patches.collisions.block.CollisionBlockState)blockData).moonrise$emptyCollisionShape()) {
++                                if (((CollisionBlockState)blockData).moonrise$emptyContextCollisionShape()) {
+                                     continue;
+                                 }
+ 
+-                                net.minecraft.world.phys.shapes.VoxelShape blockCollision = ((ca.spottedleaf.moonrise.patches.collisions.block.CollisionBlockState)blockData).moonrise$getConstantCollisionShape();
++                                VoxelShape blockCollision = ((CollisionBlockState)blockData).moonrise$getConstantContextCollisionShape();
+ 
+-                                if (edgeCount == 0 || ((edgeCount != 1 || blockData.hasLargeCollisionShape()) && (edgeCount != 2 || blockData.getBlock() == net.minecraft.world.level.block.Blocks.MOVING_PISTON))) {
++                                if (edgeCount == 0 || ((edgeCount != 1 || blockData.hasLargeCollisionShape()) && (edgeCount != 2 || blockData.getBlock() == Blocks.MOVING_PISTON))) {
+                                     if (blockCollision == null) {
+                                         mutablePos.set(blockX, blockY, blockZ);
+                                         blockCollision = blockData.getCollisionShape(world, mutablePos, collisionShape);
+                                     }
+ 
+-                                    net.minecraft.world.phys.AABB singleAABB = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)blockCollision).moonrise$getSingleAABBRepresentation();
++                                    AABB singleAABB = ((CollisionVoxelShape)blockCollision).moonrise$getSingleAABBRepresentation();
+                                     if (singleAABB != null) {
+                                         singleAABB = singleAABB.move((double)blockX, (double)blockY, (double)blockZ);
+                                         if (!voxelShapeIntersect(aabb, singleAABB)) {
+@@ -1724,7 +2060,7 @@ public final class CollisionUtil {
+                                         continue;
+                                     }
+ 
+-                                    final net.minecraft.world.phys.shapes.VoxelShape blockCollisionOffset = blockCollision.move((double)blockX, (double)blockY, (double)blockZ);
++                                    final VoxelShape blockCollisionOffset = blockCollision.move((double)blockX, (double)blockY, (double)blockZ);
+ 
+                                     if (!voxelShapeIntersectNoEmpty(blockCollisionOffset, aabb)) {
+                                         continue;
+@@ -1755,8 +2091,8 @@ public final class CollisionUtil {
+         return ret;
+     }
+ 
+-    public static boolean getEntityHardCollisions(final net.minecraft.world.level.Level world, final net.minecraft.world.entity.Entity entity, net.minecraft.world.phys.AABB aabb,
+-                                                  final java.util.List<net.minecraft.world.phys.AABB> into, final int collisionFlags, final java.util.function.Predicate<net.minecraft.world.entity.Entity> predicate) {
++    public static boolean getEntityHardCollisions(final Level world, final Entity entity, AABB aabb,
++                                                  final List<AABB> into, final int collisionFlags, final Predicate<Entity> predicate) {
+         final boolean checkOnly = (collisionFlags & COLLISION_FLAG_CHECK_ONLY) != 0;
+ 
+         boolean ret = false;
+@@ -1765,15 +2101,15 @@ public final class CollisionUtil {
+         // Vanilla for hard collisions has this backwards, and they expand by +epsilon but this causes terrible problems
+         // specifically with boat collisions.
+         aabb = aabb.inflate(-COLLISION_EPSILON, -COLLISION_EPSILON, -COLLISION_EPSILON);
+-        final java.util.List<net.minecraft.world.entity.Entity> entities;
+-        if (entity != null && ((ca.spottedleaf.moonrise.patches.chunk_system.entity.ChunkSystemEntity)entity).moonrise$isHardColliding()) {
++        final List<Entity> entities;
++        if (entity != null && ((ChunkSystemEntity)entity).moonrise$isHardColliding()) {
+             entities = world.getEntities(entity, aabb, predicate);
+         } else {
+-            entities = ((ca.spottedleaf.moonrise.patches.chunk_system.world.ChunkSystemEntityGetter)world).moonrise$getHardCollidingEntities(entity, aabb, predicate);
++            entities = ((ChunkSystemEntityGetter)world).moonrise$getHardCollidingEntities(entity, aabb, predicate);
+         }
+ 
+         for (int i = 0, len = entities.size(); i < len; ++i) {
+-            final net.minecraft.world.entity.Entity otherEntity = entities.get(i);
++            final Entity otherEntity = entities.get(i);
+ 
+             if (otherEntity.isSpectator()) {
+                 continue;
+@@ -1792,10 +2128,10 @@ public final class CollisionUtil {
+         return ret;
+     }
+ 
+-    public static boolean getCollisions(final net.minecraft.world.level.Level world, final net.minecraft.world.entity.Entity entity, final net.minecraft.world.phys.AABB aabb,
+-                                        final java.util.List<net.minecraft.world.phys.shapes.VoxelShape> intoVoxel, final java.util.List<net.minecraft.world.phys.AABB> intoAABB, final int collisionFlags,
+-                                        final java.util.function.BiPredicate<net.minecraft.world.level.block.state.BlockState, net.minecraft.core.BlockPos> blockPredicate,
+-                                        final java.util.function.Predicate<net.minecraft.world.entity.Entity> entityPredicate) {
++    public static boolean getCollisions(final Level world, final Entity entity, final AABB aabb,
++                                        final List<VoxelShape> intoVoxel, final List<AABB> intoAABB, final int collisionFlags,
++                                        final BiPredicate<BlockState, BlockPos> blockPredicate,
++                                        final Predicate<Entity> entityPredicate) {
+         if ((collisionFlags & COLLISION_FLAG_CHECK_ONLY) != 0) {
+             return getCollisionsForBlocksOrWorldBorder(world, entity, aabb, intoVoxel, intoAABB, collisionFlags, blockPredicate)
+                 || getEntityHardCollisions(world, entity, aabb, intoAABB, collisionFlags, entityPredicate);
+@@ -1805,12 +2141,12 @@ public final class CollisionUtil {
+         }
+     }
+ 
+-    public static final class LazyEntityCollisionContext extends net.minecraft.world.phys.shapes.EntityCollisionContext {
++    public static final class LazyEntityCollisionContext extends EntityCollisionContext {
+ 
+-        private net.minecraft.world.phys.shapes.CollisionContext delegate;
++        private CollisionContext delegate;
+         private boolean delegated;
+ 
+-        public LazyEntityCollisionContext(final net.minecraft.world.entity.Entity entity) {
++        public LazyEntityCollisionContext(final Entity entity) {
+             super(false, 0.0, null, null, entity);
+         }
+ 
+@@ -1820,10 +2156,10 @@ public final class CollisionUtil {
+             return delegated;
+         }
+ 
+-        public net.minecraft.world.phys.shapes.CollisionContext getDelegate() {
++        public CollisionContext getDelegate() {
+             this.delegated = true;
+-            final net.minecraft.world.entity.Entity entity = this.getEntity();
+-            return this.delegate == null ? this.delegate = (entity == null ? net.minecraft.world.phys.shapes.CollisionContext.empty() : net.minecraft.world.phys.shapes.CollisionContext.of(entity)) : this.delegate;
++            final Entity entity = this.getEntity();
++            return this.delegate == null ? this.delegate = (entity == null ? CollisionContext.empty() : CollisionContext.of(entity)) : this.delegate;
+         }
+ 
+         @Override
+@@ -1832,17 +2168,17 @@ public final class CollisionUtil {
+         }
+ 
+         @Override
+-        public boolean isAbove(final net.minecraft.world.phys.shapes.VoxelShape shape, final net.minecraft.core.BlockPos pos, final boolean defaultValue) {
++        public boolean isAbove(final VoxelShape shape, final BlockPos pos, final boolean defaultValue) {
+             return this.getDelegate().isAbove(shape, pos, defaultValue);
+         }
+ 
+         @Override
+-        public boolean isHoldingItem(final net.minecraft.world.item.Item item) {
++        public boolean isHoldingItem(final Item item) {
+             return this.getDelegate().isHoldingItem(item);
+         }
+ 
+         @Override
+-        public boolean canStandOnFluid(final net.minecraft.world.level.material.FluidState state, final net.minecraft.world.level.material.FluidState fluidState) {
++        public boolean canStandOnFluid(final FluidState state, final FluidState fluidState) {
+             return this.getDelegate().canStandOnFluid(state, fluidState);
+         }
+     }
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/collisions/ExplosionBlockCache.java b/src/main/java/ca/spottedleaf/moonrise/patches/collisions/ExplosionBlockCache.java
+index eb7200657d5c7ac37ee93868ba43be0aefecac6d..35c8aaf0bfa42717f45eed1d1072e1614874de91 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/collisions/ExplosionBlockCache.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/collisions/ExplosionBlockCache.java
+@@ -1,18 +1,23 @@
+ package ca.spottedleaf.moonrise.patches.collisions;
+ 
++import net.minecraft.core.BlockPos;
++import net.minecraft.world.level.block.state.BlockState;
++import net.minecraft.world.level.material.FluidState;
++import net.minecraft.world.phys.shapes.VoxelShape;
++
+ public final class ExplosionBlockCache {
+ 
+     public final long key;
+-    public final net.minecraft.core.BlockPos immutablePos;
+-    public final net.minecraft.world.level.block.state.BlockState blockState;
+-    public final net.minecraft.world.level.material.FluidState fluidState;
++    public final BlockPos immutablePos;
++    public final BlockState blockState;
++    public final FluidState fluidState;
+     public final float resistance;
+     public final boolean outOfWorld;
+     public Boolean shouldExplode; // null -> not called yet
+-    public net.minecraft.world.phys.shapes.VoxelShape cachedCollisionShape;
++    public VoxelShape cachedCollisionShape;
+ 
+-    public ExplosionBlockCache(final long key, final net.minecraft.core.BlockPos immutablePos, final net.minecraft.world.level.block.state.BlockState blockState,
+-                               final net.minecraft.world.level.material.FluidState fluidState, final float resistance, final boolean outOfWorld) {
++    public ExplosionBlockCache(final long key, final BlockPos immutablePos, final BlockState blockState,
++                               final FluidState fluidState, final float resistance, final boolean outOfWorld) {
+         this.key = key;
+         this.immutablePos = immutablePos;
+         this.blockState = blockState;
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/collisions/block/CollisionBlockState.java b/src/main/java/ca/spottedleaf/moonrise/patches/collisions/block/CollisionBlockState.java
+index 02b29c563a298e06186de010de68a716bccba494..a38ab583200ebf68ca68fdddf2d12077720b72b7 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/collisions/block/CollisionBlockState.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/collisions/block/CollisionBlockState.java
+@@ -1,5 +1,7 @@
+ package ca.spottedleaf.moonrise.patches.collisions.block;
+ 
++import net.minecraft.world.phys.shapes.VoxelShape;
++
+ public interface CollisionBlockState {
+ 
+     // note: this does not consider canOcclude, it is only based on the cached collision shape (i.e hasCache())
+@@ -9,6 +11,9 @@ public interface CollisionBlockState {
+     // whether the cached collision shape exists and is empty
+     public boolean moonrise$emptyCollisionShape();
+ 
++    // whether the context-sensitive shape is constant and is empty
++    public boolean moonrise$emptyContextCollisionShape();
++
+     // indicates that occludesFullBlock is cached for the collision shape
+     public boolean moonrise$hasCache();
+ 
+@@ -20,7 +25,5 @@ public interface CollisionBlockState {
+     // value is still unique
+     public int moonrise$uniqueId2();
+ 
+-    public net.minecraft.world.phys.shapes.VoxelShape moonrise$getConstantCollisionShape();
+-
+-    public net.minecraft.world.phys.AABB moonrise$getConstantCollisionAABB();
++    public VoxelShape moonrise$getConstantContextCollisionShape();
+ }
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/collisions/shape/CachedToAABBs.java b/src/main/java/ca/spottedleaf/moonrise/patches/collisions/shape/CachedToAABBs.java
+index 5fe1dad9dad368911aedbe6ba7fcd8f9b0189d32..9d33ead3a97d86b371e4d9ad9fed80d789bed844 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/collisions/shape/CachedToAABBs.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/collisions/shape/CachedToAABBs.java
+@@ -1,27 +1,31 @@
+ package ca.spottedleaf.moonrise.patches.collisions.shape;
+ 
++import net.minecraft.world.phys.AABB;
++import java.util.ArrayList;
++import java.util.List;
++
+ public record CachedToAABBs(
+-        java.util.List<net.minecraft.world.phys.AABB> aabbs,
++        List<AABB> aabbs,
+         boolean isOffset,
+         double offX, double offY, double offZ
+ ) {
+ 
+-    public ca.spottedleaf.moonrise.patches.collisions.shape.CachedToAABBs removeOffset() {
+-        final java.util.List<net.minecraft.world.phys.AABB> toOffset = this.aabbs;
++    public CachedToAABBs removeOffset() {
++        final List<AABB> toOffset = this.aabbs;
+         final double offX = this.offX;
+         final double offY = this.offY;
+         final double offZ = this.offZ;
+ 
+-        final java.util.List<net.minecraft.world.phys.AABB> ret = new java.util.ArrayList<>(toOffset.size());
++        final List<AABB> ret = new ArrayList<>(toOffset.size());
+ 
+         for (int i = 0, len = toOffset.size(); i < len; ++i) {
+             ret.add(toOffset.get(i).move(offX, offY, offZ));
+         }
+ 
+-        return new ca.spottedleaf.moonrise.patches.collisions.shape.CachedToAABBs(ret, false, 0.0, 0.0, 0.0);
++        return new CachedToAABBs(ret, false, 0.0, 0.0, 0.0);
+     }
+ 
+-    public static ca.spottedleaf.moonrise.patches.collisions.shape.CachedToAABBs offset(final ca.spottedleaf.moonrise.patches.collisions.shape.CachedToAABBs cache, final double offX, final double offY, final double offZ) {
++    public static CachedToAABBs offset(final CachedToAABBs cache, final double offX, final double offY, final double offZ) {
+         if (offX == 0.0 && offY == 0.0 && offZ == 0.0) {
+             return cache;
+         }
+@@ -30,6 +34,6 @@ public record CachedToAABBs(
+         final double resY = cache.offY + offY;
+         final double resZ = cache.offZ + offZ;
+ 
+-        return new ca.spottedleaf.moonrise.patches.collisions.shape.CachedToAABBs(cache.aabbs, true, resX, resY, resZ);
++        return new CachedToAABBs(cache.aabbs, true, resX, resY, resZ);
+     }
+ }
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/collisions/shape/CollisionDiscreteVoxelShape.java b/src/main/java/ca/spottedleaf/moonrise/patches/collisions/shape/CollisionDiscreteVoxelShape.java
+index a09efadea9b733840bbe69830dd8f2a303fe656f..07fe5e02c2d0a27d2fe37bb45761654dc2d02e5d 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/collisions/shape/CollisionDiscreteVoxelShape.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/collisions/shape/CollisionDiscreteVoxelShape.java
+@@ -2,6 +2,6 @@ package ca.spottedleaf.moonrise.patches.collisions.shape;
+ 
+ public interface CollisionDiscreteVoxelShape {
+ 
+-    public ca.spottedleaf.moonrise.patches.collisions.shape.CachedShapeData moonrise$getOrCreateCachedShapeData();
++    public CachedShapeData moonrise$getOrCreateCachedShapeData();
+ 
+ }
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/collisions/shape/CollisionVoxelShape.java b/src/main/java/ca/spottedleaf/moonrise/patches/collisions/shape/CollisionVoxelShape.java
+index 70371eb87c11a106e8513cdbc8d938dda088f745..05d7b3f9d8659c259f3ed0537c57e6e43eb6e288 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/collisions/shape/CollisionVoxelShape.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/collisions/shape/CollisionVoxelShape.java
+@@ -1,5 +1,9 @@
+ package ca.spottedleaf.moonrise.patches.collisions.shape;
+ 
++import net.minecraft.core.Direction;
++import net.minecraft.world.phys.AABB;
++import net.minecraft.world.phys.shapes.VoxelShape;
++
+ public interface CollisionVoxelShape {
+ 
+     public double moonrise$offsetX();
+@@ -14,16 +18,16 @@ public interface CollisionVoxelShape {
+ 
+     public double[] moonrise$rootCoordinatesZ();
+ 
+-    public ca.spottedleaf.moonrise.patches.collisions.shape.CachedShapeData moonrise$getCachedVoxelData();
++    public CachedShapeData moonrise$getCachedVoxelData();
+ 
+     // rets null if not possible to represent this shape as one AABB
+-    public net.minecraft.world.phys.AABB moonrise$getSingleAABBRepresentation();
++    public AABB moonrise$getSingleAABBRepresentation();
+ 
+     // ONLY USE INTERNALLY, ONLY FOR INITIALISING IN CONSTRUCTOR: VOXELSHAPES ARE STATIC
+     public void moonrise$initCache();
+ 
+     // this returns empty if not clamped to 1.0 or 0.0 depending on direction
+-    public net.minecraft.world.phys.shapes.VoxelShape moonrise$getFaceShapeClamped(final net.minecraft.core.Direction direction);
++    public VoxelShape moonrise$getFaceShapeClamped(final Direction direction);
+ 
+     public boolean moonrise$isFullBlock();
+ 
+@@ -32,5 +36,5 @@ public interface CollisionVoxelShape {
+     public boolean moonrise$occludesFullBlockIfCached();
+ 
+     // uses a cache internally
+-    public net.minecraft.world.phys.shapes.VoxelShape moonrise$orUnoptimized(final net.minecraft.world.phys.shapes.VoxelShape other);
++    public VoxelShape moonrise$orUnoptimized(final VoxelShape other);
+ }
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/collisions/shape/MergedORCache.java b/src/main/java/ca/spottedleaf/moonrise/patches/collisions/shape/MergedORCache.java
+index 4217426d3eca5e5cd2bc37e509f84da1d6fed0b2..44831fc18efb7534dc6e4822f3c9b5cdc4dcc33e 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/collisions/shape/MergedORCache.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/collisions/shape/MergedORCache.java
+@@ -1,8 +1,10 @@
+ package ca.spottedleaf.moonrise.patches.collisions.shape;
+ 
++import net.minecraft.world.phys.shapes.VoxelShape;
++
+ public record MergedORCache(
+-    net.minecraft.world.phys.shapes.VoxelShape key,
+-    net.minecraft.world.phys.shapes.VoxelShape result
++    VoxelShape key,
++    VoxelShape result
+ ) {
+ 
+ }
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/collisions/util/EmptyStreamForMoveCall.java b/src/main/java/ca/spottedleaf/moonrise/patches/collisions/util/EmptyStreamForMoveCall.java
+deleted file mode 100644
+index 673103f160cbe577c6e05f998706af4e6850011b..0000000000000000000000000000000000000000
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/collisions/util/EmptyStreamForMoveCall.java
++++ /dev/null
+@@ -1,225 +0,0 @@
+-package ca.spottedleaf.moonrise.patches.collisions.util;
+-
+-import java.util.Iterator;
+-import java.util.Optional;
+-import java.util.Spliterator;
+-import java.util.stream.Stream;
+-
+-public final class EmptyStreamForMoveCall<T> implements java.util.stream.Stream<T> {
+-
+-    public static final ca.spottedleaf.moonrise.patches.collisions.util.EmptyStreamForMoveCall INSTANCE = new ca.spottedleaf.moonrise.patches.collisions.util.EmptyStreamForMoveCall();
+-
+-    @Override
+-    public boolean noneMatch(java.util.function.Predicate<? super T> predicate) {
+-        return false; // important: ret false so the branch is never taken by mojang code
+-    }
+-
+-    @Override
+-    public java.util.stream.Stream<T> filter(java.util.function.Predicate<? super T> predicate) {
+-        return null;
+-    }
+-
+-    @Override
+-    public <R> java.util.stream.Stream<R> map(java.util.function.Function<? super T, ? extends R> mapper) {
+-        return null;
+-    }
+-
+-    @Override
+-    public java.util.stream.IntStream mapToInt(java.util.function.ToIntFunction<? super T> mapper) {
+-        return null;
+-    }
+-
+-    @Override
+-    public java.util.stream.LongStream mapToLong(java.util.function.ToLongFunction<? super T> mapper) {
+-        return null;
+-    }
+-
+-    @Override
+-    public java.util.stream.DoubleStream mapToDouble(java.util.function.ToDoubleFunction<? super T> mapper) {
+-        return null;
+-    }
+-
+-    @Override
+-    public <R> java.util.stream.Stream<R> flatMap(java.util.function.Function<? super T, ? extends java.util.stream.Stream<? extends R>> mapper) {
+-        return null;
+-    }
+-
+-    @Override
+-    public java.util.stream.IntStream flatMapToInt(java.util.function.Function<? super T, ? extends java.util.stream.IntStream> mapper) {
+-        return null;
+-    }
+-
+-    @Override
+-    public java.util.stream.LongStream flatMapToLong(java.util.function.Function<? super T, ? extends java.util.stream.LongStream> mapper) {
+-        return null;
+-    }
+-
+-    @Override
+-    public java.util.stream.DoubleStream flatMapToDouble(java.util.function.Function<? super T, ? extends java.util.stream.DoubleStream> mapper) {
+-        return null;
+-    }
+-
+-    @Override
+-    public java.util.stream.Stream<T> distinct() {
+-        return null;
+-    }
+-
+-    @Override
+-    public java.util.stream.Stream<T> sorted() {
+-        return null;
+-    }
+-
+-    @Override
+-    public java.util.stream.Stream<T> sorted(java.util.Comparator<? super T> comparator) {
+-        return null;
+-    }
+-
+-    @Override
+-    public java.util.stream.Stream<T> peek(java.util.function.Consumer<? super T> action) {
+-        return null;
+-    }
+-
+-    @Override
+-    public java.util.stream.Stream<T> limit(long maxSize) {
+-        return null;
+-    }
+-
+-    @Override
+-    public java.util.stream.Stream<T> skip(long n) {
+-        return null;
+-    }
+-
+-    @Override
+-    public void forEach(java.util.function.Consumer<? super T> action) {
+-
+-    }
+-
+-    @Override
+-    public void forEachOrdered(java.util.function.Consumer<? super T> action) {
+-
+-    }
+-
+-    @org.jetbrains.annotations.NotNull
+-    @Override
+-    public Object[] toArray() {
+-        return new Object[0];
+-    }
+-
+-    @org.jetbrains.annotations.NotNull
+-    @Override
+-    public <A> A[] toArray(java.util.function.IntFunction<A[]> generator) {
+-        return null;
+-    }
+-
+-    @Override
+-    public T reduce(T identity, java.util.function.BinaryOperator<T> accumulator) {
+-        return null;
+-    }
+-
+-    @org.jetbrains.annotations.NotNull
+-    @Override
+-    public Optional<T> reduce(java.util.function.BinaryOperator<T> accumulator) {
+-        return java.util.Optional.empty();
+-    }
+-
+-    @Override
+-    public <U> U reduce(U identity, java.util.function.BiFunction<U, ? super T, U> accumulator, java.util.function.BinaryOperator<U> combiner) {
+-        return null;
+-    }
+-
+-    @Override
+-    public <R> R collect(java.util.function.Supplier<R> supplier, java.util.function.BiConsumer<R, ? super T> accumulator, java.util.function.BiConsumer<R, R> combiner) {
+-        return null;
+-    }
+-
+-    @Override
+-    public <R, A> R collect(java.util.stream.Collector<? super T, A, R> collector) {
+-        return null;
+-    }
+-
+-    @org.jetbrains.annotations.NotNull
+-    @Override
+-    public Optional<T> min(java.util.Comparator<? super T> comparator) {
+-        return java.util.Optional.empty();
+-    }
+-
+-    @org.jetbrains.annotations.NotNull
+-    @Override
+-    public Optional<T> max(java.util.Comparator<? super T> comparator) {
+-        return java.util.Optional.empty();
+-    }
+-
+-    @Override
+-    public long count() {
+-        return 0;
+-    }
+-
+-    @Override
+-    public boolean anyMatch(java.util.function.Predicate<? super T> predicate) {
+-        return false;
+-    }
+-
+-    @Override
+-    public boolean allMatch(java.util.function.Predicate<? super T> predicate) {
+-        return false;
+-    }
+-
+-    @org.jetbrains.annotations.NotNull
+-    @Override
+-    public Optional<T> findFirst() {
+-        return java.util.Optional.empty();
+-    }
+-
+-    @org.jetbrains.annotations.NotNull
+-    @Override
+-    public Optional<T> findAny() {
+-        return java.util.Optional.empty();
+-    }
+-
+-
+-    @org.jetbrains.annotations.NotNull
+-    @Override
+-    public Iterator<T> iterator() {
+-        return null;
+-    }
+-
+-    @org.jetbrains.annotations.NotNull
+-    @Override
+-    public Spliterator<T> spliterator() {
+-        return null;
+-    }
+-
+-    @Override
+-    public boolean isParallel() {
+-        return false;
+-    }
+-
+-    @org.jetbrains.annotations.NotNull
+-    @Override
+-    public Stream<T> sequential() {
+-        return null;
+-    }
+-
+-    @org.jetbrains.annotations.NotNull
+-    @Override
+-    public Stream<T> parallel() {
+-        return null;
+-    }
+-
+-    @org.jetbrains.annotations.NotNull
+-    @Override
+-    public Stream<T> unordered() {
+-        return null;
+-    }
+-
+-    @org.jetbrains.annotations.NotNull
+-    @Override
+-    public Stream<T> onClose(Runnable closeHandler) {
+-        return null;
+-    }
+-
+-    @Override
+-    public void close() {
+-
+-    }
+-}
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/collisions/util/FluidOcclusionCacheKey.java b/src/main/java/ca/spottedleaf/moonrise/patches/collisions/util/FluidOcclusionCacheKey.java
+index 128267ff40b38c7b3ea0feb5133825cc6aae075b..cf9ffdeff6bf0b62a45f7a44dbfe0dd7d17dc4f4 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/collisions/util/FluidOcclusionCacheKey.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/collisions/util/FluidOcclusionCacheKey.java
+@@ -1,4 +1,7 @@
+ package ca.spottedleaf.moonrise.patches.collisions.util;
+ 
+-public record FluidOcclusionCacheKey(net.minecraft.world.level.block.state.BlockState first, net.minecraft.world.level.block.state.BlockState second, net.minecraft.core.Direction direction, boolean result) {
++import net.minecraft.core.Direction;
++import net.minecraft.world.level.block.state.BlockState;
++
++public record FluidOcclusionCacheKey(BlockState first, BlockState second, Direction direction, boolean result) {
+ }
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/collisions/world/CollisionLevel.java b/src/main/java/ca/spottedleaf/moonrise/patches/collisions/world/CollisionLevel.java
+deleted file mode 100644
+index e851e81e13edbad6316df63fcb7095d48f85c5b0..0000000000000000000000000000000000000000
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/collisions/world/CollisionLevel.java
++++ /dev/null
+@@ -1,9 +0,0 @@
+-package ca.spottedleaf.moonrise.patches.collisions.world;
+-
+-public interface CollisionLevel {
+-
+-    public int moonrise$getMinSection();
+-
+-    public int moonrise$getMaxSection();
+-
+-}
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/entity_tracker/EntityTrackerTrackedEntity.java b/src/main/java/ca/spottedleaf/moonrise/patches/entity_tracker/EntityTrackerTrackedEntity.java
+index 1fa07bef57d82c6d5242aaaf66011f0913515231..8e7472157a98de607c03769a91f64c8369fd3ea6 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/entity_tracker/EntityTrackerTrackedEntity.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/entity_tracker/EntityTrackerTrackedEntity.java
+@@ -10,4 +10,6 @@ public interface EntityTrackerTrackedEntity {
+ 
+     public void moonrise$clearPlayers();
+ 
++    public boolean moonrise$hasPlayers();
++
+ }
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/fast_palette/FastPalette.java b/src/main/java/ca/spottedleaf/moonrise/patches/fast_palette/FastPalette.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..4a7abd239a9c59aa98947e7993962d75e9051902
+--- /dev/null
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/fast_palette/FastPalette.java
+@@ -0,0 +1,9 @@
++package ca.spottedleaf.moonrise.patches.fast_palette;
++
++public interface FastPalette<T> {
++
++    public default T[] moonrise$getRawPalette(final FastPaletteData<T> src) {
++        return null;
++    }
++
++}
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/fast_palette/FastPaletteData.java b/src/main/java/ca/spottedleaf/moonrise/patches/fast_palette/FastPaletteData.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..4503f3495846a7d7ed082b9e24636044e4fbccd1
+--- /dev/null
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/fast_palette/FastPaletteData.java
+@@ -0,0 +1,9 @@
++package ca.spottedleaf.moonrise.patches.fast_palette;
++
++public interface FastPaletteData<T> {
++
++    public T[] moonrise$getPalette();
++
++    public void moonrise$setPalette(final T[] palette);
++
++}
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/fluid/FluidFluidState.java b/src/main/java/ca/spottedleaf/moonrise/patches/fluid/FluidFluidState.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..107c97089354edd35f330582f5e0c8a18e792a6e
+--- /dev/null
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/fluid/FluidFluidState.java
+@@ -0,0 +1,5 @@
++package ca.spottedleaf.moonrise.patches.fluid;
++
++public interface FluidFluidState {
++    public void moonrise$initCaches();
++}
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_getblock/GetBlockChunk.java b/src/main/java/ca/spottedleaf/moonrise/patches/getblock/GetBlockChunk.java
+similarity index 75%
+rename from src/main/java/ca/spottedleaf/moonrise/patches/chunk_getblock/GetBlockChunk.java
+rename to src/main/java/ca/spottedleaf/moonrise/patches/getblock/GetBlockChunk.java
+index 08338917dc61c856eaba0b76e05c1497c458399d..540c14a6d2c216cd3ef2a9c4056e15712bf8cb8c 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/chunk_getblock/GetBlockChunk.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/getblock/GetBlockChunk.java
+@@ -1,4 +1,4 @@
+-package ca.spottedleaf.moonrise.patches.chunk_getblock;
++package ca.spottedleaf.moonrise.patches.getblock;
+ 
+ import net.minecraft.world.level.block.state.BlockState;
+ 
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/starlight/blockstate/StarlightAbstractBlockState.java b/src/main/java/ca/spottedleaf/moonrise/patches/starlight/blockstate/StarlightAbstractBlockState.java
+index 2bfdf3721db9a45e36538d71cbefcb1d339e6c58..8e6d79b7c10ef25f5478b72c53c555423d615a2f 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/starlight/blockstate/StarlightAbstractBlockState.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/starlight/blockstate/StarlightAbstractBlockState.java
+@@ -4,6 +4,4 @@ public interface StarlightAbstractBlockState {
+ 
+     public boolean starlight$isConditionallyFullOpaque();
+ 
+-    public int starlight$getOpacityIfCached();
+-
+ }
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/starlight/light/BlockStarLightEngine.java b/src/main/java/ca/spottedleaf/moonrise/patches/starlight/light/BlockStarLightEngine.java
+index 154443ac1ee1d6d18b8ff0f40a307d638b213aeb..fa7b784a89626e8528c249d7889a598bd7ee3d49 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/starlight/light/BlockStarLightEngine.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/starlight/light/BlockStarLightEngine.java
+@@ -1,8 +1,10 @@
+ package ca.spottedleaf.moonrise.patches.starlight.light;
+ 
++import ca.spottedleaf.moonrise.common.PlatformHooks;
+ import ca.spottedleaf.moonrise.patches.starlight.blockstate.StarlightAbstractBlockState;
+ import ca.spottedleaf.moonrise.patches.starlight.chunk.StarlightChunk;
+ import net.minecraft.core.BlockPos;
++import net.minecraft.world.level.BlockGetter;
+ import net.minecraft.world.level.Level;
+ import net.minecraft.world.level.block.state.BlockState;
+ import net.minecraft.world.level.chunk.ChunkAccess;
+@@ -91,7 +93,7 @@ public final class BlockStarLightEngine extends StarLightEngine {
+ 
+         final int currentLevel = this.getLightLevel(worldX, worldY, worldZ);
+         final BlockState blockState = this.getBlockState(worldX, worldY, worldZ);
+-        final int emittedLevel = blockState.getLightEmission() & emittedMask;
++        final int emittedLevel = (PlatformHooks.get().getLightEmission(blockState, lightAccess.getLevel(), this.lightEmissionPos.set(worldX, worldY, worldZ))) & emittedMask;
+ 
+         this.setLightLevel(worldX, worldY, worldZ, emittedLevel);
+         // this accounts for change in emitted light that would cause an increase
+@@ -119,37 +121,32 @@ public final class BlockStarLightEngine extends StarLightEngine {
+     }
+ 
+     protected final BlockPos.MutableBlockPos recalcCenterPos = new BlockPos.MutableBlockPos();
+-    protected final BlockPos.MutableBlockPos recalcNeighbourPos = new BlockPos.MutableBlockPos();
+ 
+     @Override
+     protected int calculateLightValue(final LightChunkGetter lightAccess, final int worldX, final int worldY, final int worldZ,
+                                       final int expect) {
++        this.recalcCenterPos.set(worldX, worldY, worldZ);
++
+         final BlockState centerState = this.getBlockState(worldX, worldY, worldZ);
+-        int level = centerState.getLightEmission() & 0xF;
++        final BlockGetter world = lightAccess.getLevel();
++        int level = (PlatformHooks.get().getLightEmission(centerState, world, this.recalcCenterPos)) & this.emittedLightMask;
+ 
+         if (level >= (15 - 1) || level > expect) {
+             return level;
+         }
+ 
+-        final int sectionOffset = this.chunkSectionIndexOffset;
+-        final BlockState conditionallyOpaqueState;
+-        int opacity = ((StarlightAbstractBlockState)centerState).starlight$getOpacityIfCached();
+-
+-        if (opacity == -1) {
+-            this.recalcCenterPos.set(worldX, worldY, worldZ);
+-            opacity = centerState.getLightBlock(lightAccess.getLevel(), this.recalcCenterPos);
+-            if (((StarlightAbstractBlockState)centerState).starlight$isConditionallyFullOpaque()) {
+-                conditionallyOpaqueState = centerState;
+-            } else {
+-                conditionallyOpaqueState = null;
+-            }
+-        } else if (opacity >= 15) {
++        final int opacity = Math.max(1, centerState.getLightBlock());
++        if (opacity >= 15) {
+             return level;
++        }
++        final BlockState conditionallyOpaqueState;
++        if (((StarlightAbstractBlockState)centerState).starlight$isConditionallyFullOpaque()) {
++            conditionallyOpaqueState = centerState;
+         } else {
+             conditionallyOpaqueState = null;
+         }
+-        opacity = Math.max(1, opacity);
+ 
++        final int sectionOffset = this.chunkSectionIndexOffset;
+         for (final AxisDirection direction : AXIS_DIRECTIONS) {
+             final int offX = worldX + direction.x;
+             final int offY = worldY + direction.y;
+@@ -169,9 +166,8 @@ public final class BlockStarLightEngine extends StarLightEngine {
+                 // here the block can be conditionally opaque (i.e light cannot propagate from it), so we need to test that
+                 // we don't read the blockstate because most of the time this is false, so using the faster
+                 // known transparency lookup results in a net win
+-                this.recalcNeighbourPos.set(offX, offY, offZ);
+-                final VoxelShape neighbourFace = neighbourState.getFaceOcclusionShape(lightAccess.getLevel(), this.recalcNeighbourPos, direction.opposite.nms);
+-                final VoxelShape thisFace = conditionallyOpaqueState == null ? Shapes.empty() : conditionallyOpaqueState.getFaceOcclusionShape(lightAccess.getLevel(), this.recalcCenterPos, direction.nms);
++                final VoxelShape neighbourFace = neighbourState.getFaceOcclusionShape(direction.opposite.nms);
++                final VoxelShape thisFace = conditionallyOpaqueState == null ? Shapes.empty() : conditionallyOpaqueState.getFaceOcclusionShape(direction.nms);
+                 if (Shapes.faceShapeOccludes(thisFace, neighbourFace)) {
+                     // not allowed to propagate
+                     continue;
+@@ -205,30 +201,34 @@ public final class BlockStarLightEngine extends StarLightEngine {
+         final int offX = chunk.getPos().x << 4;
+         final int offZ = chunk.getPos().z << 4;
+ 
++        final PlatformHooks platformHooks = PlatformHooks.get();
++
++        final BlockGetter world = lightAccess.getLevel();
+         final LevelChunkSection[] sections = chunk.getSections();
+         for (int sectionY = this.minSection; sectionY <= this.maxSection; ++sectionY) {
+             final LevelChunkSection section = sections[sectionY - this.minSection];
+-            if (section == null || section.hasOnlyAir()) {
++            if (section.hasOnlyAir()) {
+                 // no sources in empty sections
+                 continue;
+             }
+-            if (!section.maybeHas((final BlockState state) -> {
+-                return state.getLightEmission() > 0;
+-            })) {
++            if (!section.maybeHas(platformHooks.maybeHasLightEmission())) {
+                 // no light sources in palette
+                 continue;
+             }
+             final PalettedContainer<BlockState> states = section.states;
+             final int offY = sectionY << 4;
+ 
++            final BlockPos.MutableBlockPos mutablePos = this.lightEmissionPos;
+             for (int index = 0; index < (16 * 16 * 16); ++index) {
+                 final BlockState state = states.get(index);
+-                if (state.getLightEmission() <= 0) {
++                mutablePos.set(offX | (index & 15), offY | (index >>> 8), offZ | ((index >>> 4) & 15));
++
++                if ((platformHooks.getLightEmission(state, world, mutablePos)) == 0) {
+                     continue;
+                 }
+ 
+                 // index = x | (z << 4) | (y << 8)
+-                sources.add(new BlockPos(offX | (index & 15), offY | (index >>> 8), offZ | ((index >>> 4) & 15)));
++                sources.add(mutablePos.immutable());
+             }
+         }
+ 
+@@ -238,12 +238,15 @@ public final class BlockStarLightEngine extends StarLightEngine {
+     @Override
+     public void lightChunk(final LightChunkGetter lightAccess, final ChunkAccess chunk, final boolean needsEdgeChecks) {
+         // setup sources
++        final BlockGetter world = lightAccess.getLevel();
++        final PlatformHooks platformHooks = PlatformHooks.get();
++
+         final int emittedMask = this.emittedLightMask;
+         final List<BlockPos> positions = this.getSources(lightAccess, chunk);
+         for (int i = 0, len = positions.size(); i < len; ++i) {
+             final BlockPos pos = positions.get(i);
+             final BlockState blockState = this.getBlockState(pos.getX(), pos.getY(), pos.getZ());
+-            final int emittedLight = blockState.getLightEmission() & emittedMask;
++            final int emittedLight = platformHooks.getLightEmission(blockState, world, pos) & emittedMask;
+ 
+             if (emittedLight <= this.getLightLevel(pos.getX(), pos.getY(), pos.getZ())) {
+                 // some other source is brighter
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/starlight/light/SkyStarLightEngine.java b/src/main/java/ca/spottedleaf/moonrise/patches/starlight/light/SkyStarLightEngine.java
+index fdbc015f498164c9d2c578cd84a73def568142a4..f9aef289e9a2d6f63c98c72c56ef32b8793f57f4 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/starlight/light/SkyStarLightEngine.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/starlight/light/SkyStarLightEngine.java
+@@ -290,9 +290,6 @@ public final class SkyStarLightEngine extends StarLightEngine {
+         );
+     }
+ 
+-    protected final BlockPos.MutableBlockPos recalcCenterPos = new BlockPos.MutableBlockPos();
+-    protected final BlockPos.MutableBlockPos recalcNeighbourPos = new BlockPos.MutableBlockPos();
+-
+     @Override
+     protected int calculateLightValue(final LightChunkGetter lightAccess, final int worldX, final int worldY, final int worldZ,
+                                       final int expect) {
+@@ -302,20 +299,13 @@ public final class SkyStarLightEngine extends StarLightEngine {
+ 
+         final int sectionOffset = this.chunkSectionIndexOffset;
+         final BlockState centerState = this.getBlockState(worldX, worldY, worldZ);
+-        int opacity = ((StarlightAbstractBlockState)centerState).starlight$getOpacityIfCached();
+ 
+         final BlockState conditionallyOpaqueState;
+-        if (opacity < 0) {
+-            this.recalcCenterPos.set(worldX, worldY, worldZ);
+-            opacity = Math.max(1, centerState.getLightBlock(lightAccess.getLevel(), this.recalcCenterPos));
+-            if (((StarlightAbstractBlockState)centerState).starlight$isConditionallyFullOpaque()) {
+-                conditionallyOpaqueState = centerState;
+-            } else {
+-                conditionallyOpaqueState = null;
+-            }
++        final int opacity = Math.max(1, centerState.getLightBlock());
++        if (((StarlightAbstractBlockState)centerState).starlight$isConditionallyFullOpaque()) {
++            conditionallyOpaqueState = centerState;
+         } else {
+             conditionallyOpaqueState = null;
+-            opacity = Math.max(1, opacity);
+         }
+ 
+         int level = 0;
+@@ -340,9 +330,8 @@ public final class SkyStarLightEngine extends StarLightEngine {
+                 // here the block can be conditionally opaque (i.e light cannot propagate from it), so we need to test that
+                 // we don't read the blockstate because most of the time this is false, so using the faster
+                 // known transparency lookup results in a net win
+-                this.recalcNeighbourPos.set(offX, offY, offZ);
+-                final VoxelShape neighbourFace = neighbourState.getFaceOcclusionShape(lightAccess.getLevel(), this.recalcNeighbourPos, direction.opposite.nms);
+-                final VoxelShape thisFace = conditionallyOpaqueState == null ? Shapes.empty() : conditionallyOpaqueState.getFaceOcclusionShape(lightAccess.getLevel(), this.recalcCenterPos, direction.nms);
++                final VoxelShape neighbourFace = neighbourState.getFaceOcclusionShape(direction.opposite.nms);
++                final VoxelShape thisFace = conditionallyOpaqueState == null ? Shapes.empty() : conditionallyOpaqueState.getFaceOcclusionShape(direction.nms);
+                 if (Shapes.faceShapeOccludes(thisFace, neighbourFace)) {
+                     // not allowed to propagate
+                     continue;
+@@ -610,7 +599,6 @@ public final class SkyStarLightEngine extends StarLightEngine {
+     // clobbering the light values will result in broken propagation)
+     protected final int tryPropagateSkylight(final BlockGetter world, final int worldX, int startY, final int worldZ,
+                                              final boolean extrudeInitialised, final boolean delayLightSet) {
+-        final BlockPos.MutableBlockPos mutablePos = this.mutablePos3;
+         final int encodeOffset = this.coordinateOffset;
+         final long propagateDirection = AxisDirection.POSITIVE_Y.everythingButThisDirection; // just don't check upwards.
+ 
+@@ -632,8 +620,7 @@ public final class SkyStarLightEngine extends StarLightEngine {
+ 
+             final VoxelShape fromShape;
+             if (((StarlightAbstractBlockState)above).starlight$isConditionallyFullOpaque()) {
+-                this.mutablePos2.set(worldX, startY + 1, worldZ);
+-                fromShape = above.getFaceOcclusionShape(world, this.mutablePos2, AxisDirection.NEGATIVE_Y.nms);
++                fromShape = above.getFaceOcclusionShape(AxisDirection.NEGATIVE_Y.nms);
+                 if (Shapes.faceShapeOccludes(Shapes.empty(), fromShape)) {
+                     // above wont let us propagate
+                     break;
+@@ -642,49 +629,32 @@ public final class SkyStarLightEngine extends StarLightEngine {
+                 fromShape = Shapes.empty();
+             }
+ 
+-            final int opacityIfCached = ((StarlightAbstractBlockState)current).starlight$getOpacityIfCached();
+             // does light propagate from the top down?
+-            if (opacityIfCached != -1) {
+-                if (opacityIfCached != 0) {
+-                    // we cannot propagate 15 through this
+-                    break;
+-                }
+-                // most of the time it falls here.
+-                // add to propagate
+-                // light set delayed until we determine if this nibble section is null
+-                this.appendToIncreaseQueue(
+-                        ((worldX + (worldZ << 6) + (startY << (6 + 6)) + encodeOffset) & ((1L << (6 + 6 + 16)) - 1))
+-                                | (15L << (6 + 6 + 16)) // we know we're at full lit here
+-                                | (propagateDirection << (6 + 6 + 16 + 4))
+-                );
+-            } else {
+-                mutablePos.set(worldX, startY, worldZ);
+-                long flags = 0L;
+-                if (((StarlightAbstractBlockState)current).starlight$isConditionallyFullOpaque()) {
+-                    final VoxelShape cullingFace = current.getFaceOcclusionShape(world, mutablePos, AxisDirection.POSITIVE_Y.nms);
++            long flags = 0L;
++            if (((StarlightAbstractBlockState)current).starlight$isConditionallyFullOpaque()) {
++                final VoxelShape cullingFace = current.getFaceOcclusionShape(AxisDirection.POSITIVE_Y.nms);
+ 
+-                    if (Shapes.faceShapeOccludes(fromShape, cullingFace)) {
+-                        // can't propagate here, we're done on this column.
+-                        break;
+-                    }
+-                    flags |= FLAG_HAS_SIDED_TRANSPARENT_BLOCKS;
+-                }
+-
+-                final int opacity = current.getLightBlock(world, mutablePos);
+-                if (opacity > 0) {
+-                    // let the queued value (if any) handle it from here.
++                if (Shapes.faceShapeOccludes(fromShape, cullingFace)) {
++                    // can't propagate here, we're done on this column.
+                     break;
+                 }
++                flags |= FLAG_HAS_SIDED_TRANSPARENT_BLOCKS;
++            }
+ 
+-                // light set delayed until we determine if this nibble section is null
+-                this.appendToIncreaseQueue(
+-                        ((worldX + (worldZ << 6) + (startY << (6 + 6)) + encodeOffset) & ((1L << (6 + 6 + 16)) - 1))
+-                                | (15L << (6 + 6 + 16)) // we know we're at full lit here
+-                                | (propagateDirection << (6 + 6 + 16 + 4))
+-                                | flags
+-                );
++            final int opacity = current.getLightBlock();
++            if (opacity > 0) {
++                // let the queued value (if any) handle it from here.
++                break;
+             }
+ 
++            // light set delayed until we determine if this nibble section is null
++            this.appendToIncreaseQueue(
++                    ((worldX + (worldZ << 6) + (startY << (6 + 6)) + encodeOffset) & ((1L << (6 + 6 + 16)) - 1))
++                            | (15L << (6 + 6 + 16)) // we know we're at full lit here
++                            | (propagateDirection << (6 + 6 + 16 + 4))
++                            | flags
++            );
++
+             above = current;
+ 
+             if (this.getNibbleFromCache(worldX >> 4, startY >> 4, worldZ >> 4) == null) {
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/starlight/light/StarLightEngine.java b/src/main/java/ca/spottedleaf/moonrise/patches/starlight/light/StarLightEngine.java
+index 382c9e445af0d6ad2428fc22d0f63017c58191e2..8aeb5fb87f94a35659347a09a638420699b52a6f 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/starlight/light/StarLightEngine.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/starlight/light/StarLightEngine.java
+@@ -1,6 +1,7 @@
+ package ca.spottedleaf.moonrise.patches.starlight.light;
+ 
+ import ca.spottedleaf.concurrentutil.util.IntegerUtil;
++import ca.spottedleaf.moonrise.common.PlatformHooks;
+ import ca.spottedleaf.moonrise.common.util.CoordinateUtils;
+ import ca.spottedleaf.moonrise.common.util.WorldUtil;
+ import ca.spottedleaf.moonrise.patches.starlight.blockstate.StarlightAbstractBlockState;
+@@ -43,9 +44,9 @@ public abstract class StarLightEngine {
+     protected static enum AxisDirection {
+ 
+         // Declaration order is important and relied upon. Do not change without modifying propagation code.
+-        POSITIVE_X(1, 0, 0), NEGATIVE_X(-1, 0, 0),
+-        POSITIVE_Z(0, 0, 1), NEGATIVE_Z(0, 0, -1),
+-        POSITIVE_Y(0, 1, 0), NEGATIVE_Y(0, -1, 0);
++        POSITIVE_X(1, 0, 0, Direction.EAST) , NEGATIVE_X(-1, 0, 0, Direction.WEST),
++        POSITIVE_Z(0, 0, 1, Direction.SOUTH), NEGATIVE_Z(0, 0, -1, Direction.NORTH),
++        POSITIVE_Y(0, 1, 0, Direction.UP)   , NEGATIVE_Y(0, -1, 0, Direction.DOWN);
+ 
+         static {
+             POSITIVE_X.opposite = NEGATIVE_X; NEGATIVE_X.opposite = POSITIVE_X;
+@@ -62,11 +63,11 @@ public abstract class StarLightEngine {
+         public final long everythingButThisDirection;
+         public final long everythingButTheOppositeDirection;
+ 
+-        AxisDirection(final int x, final int y, final int z) {
++        AxisDirection(final int x, final int y, final int z, final Direction nms) {
+             this.x = x;
+             this.y = y;
+             this.z = z;
+-            this.nms = Direction.fromDelta(x, y, z);
++            this.nms = nms;
+             this.everythingButThisDirection = (long)(ALL_DIRECTIONS_BITSET ^ (1 << this.ordinal()));
+             // positive is always even, negative is always odd. Flip the 1 bit to get the negative direction.
+             this.everythingButTheOppositeDirection = (long)(ALL_DIRECTIONS_BITSET ^ (1 << (this.ordinal() ^ 1)));
+@@ -106,9 +107,7 @@ public abstract class StarLightEngine {
+     // index = x + (z * 5)
+     protected final boolean[][] emptinessMapCache = new boolean[5 * 5][];
+ 
+-    protected final BlockPos.MutableBlockPos mutablePos1 = new BlockPos.MutableBlockPos();
+-    protected final BlockPos.MutableBlockPos mutablePos2 = new BlockPos.MutableBlockPos();
+-    protected final BlockPos.MutableBlockPos mutablePos3 = new BlockPos.MutableBlockPos();
++    protected final BlockPos.MutableBlockPos lightEmissionPos = new BlockPos.MutableBlockPos();
+ 
+     protected int encodeOffsetX;
+     protected int encodeOffsetY;
+@@ -1150,69 +1149,46 @@ public abstract class StarLightEngine {
+                     if (blockState == null) {
+                         continue;
+                     }
+-                    final int opacityCached = ((StarlightAbstractBlockState)blockState).starlight$getOpacityIfCached();
+-                    if (opacityCached != -1) {
+-                        final int targetLevel = propagatedLightLevel - Math.max(1, opacityCached);
+-                        if (targetLevel > currentLevel) {
+-                            currentNibble.set(localIndex, targetLevel);
+-                            this.postLightUpdate(offX, offY, offZ);
+-
+-                            if (targetLevel > 1) {
+-                                if (queueLength >= queue.length) {
+-                                    queue = this.resizeIncreaseQueue();
+-                                }
+-                                queue[queueLength++] =
+-                                        ((offX + (offZ << 6) + (offY << 12) + encodeOffset) & ((1L << (6 + 6 + 16)) - 1))
+-                                                | ((targetLevel & 0xFL) << (6 + 6 + 16))
+-                                                | (propagate.everythingButTheOppositeDirection << (6 + 6 + 16 + 4));
+-                                continue;
+-                            }
+-                        }
+-                        continue;
+-                    } else {
+-                        this.mutablePos1.set(offX, offY, offZ);
+-                        long flags = 0;
+-                        if (((StarlightAbstractBlockState)blockState).starlight$isConditionallyFullOpaque()) {
+-                            final VoxelShape cullingFace = blockState.getFaceOcclusionShape(world, this.mutablePos1, propagate.getOpposite().nms);
++                    long flags = 0;
++                    if (((StarlightAbstractBlockState)blockState).starlight$isConditionallyFullOpaque()) {
++                        final VoxelShape cullingFace = blockState.getFaceOcclusionShape(propagate.getOpposite().nms);
+ 
+-                            if (Shapes.faceShapeOccludes(Shapes.empty(), cullingFace)) {
+-                                continue;
+-                            }
+-                            flags |= FLAG_HAS_SIDED_TRANSPARENT_BLOCKS;
+-                        }
+-
+-                        final int opacity = blockState.getLightBlock(world, this.mutablePos1);
+-                        final int targetLevel = propagatedLightLevel - Math.max(1, opacity);
+-                        if (targetLevel <= currentLevel) {
++                        if (Shapes.faceShapeOccludes(Shapes.empty(), cullingFace)) {
+                             continue;
+                         }
++                        flags |= FLAG_HAS_SIDED_TRANSPARENT_BLOCKS;
++                    }
+ 
+-                        currentNibble.set(localIndex, targetLevel);
+-                        this.postLightUpdate(offX, offY, offZ);
++                    final int opacity = blockState.getLightBlock();
++                    final int targetLevel = propagatedLightLevel - Math.max(1, opacity);
++                    if (targetLevel <= currentLevel) {
++                        continue;
++                    }
+ 
+-                        if (targetLevel > 1) {
+-                            if (queueLength >= queue.length) {
+-                                queue = this.resizeIncreaseQueue();
+-                            }
+-                            queue[queueLength++] =
+-                                    ((offX + (offZ << 6) + (offY << 12) + encodeOffset) & ((1L << (6 + 6 + 16)) - 1))
+-                                            | ((targetLevel & 0xFL) << (6 + 6 + 16))
+-                                            | (propagate.everythingButTheOppositeDirection << (6 + 6 + 16 + 4))
+-                                            | (flags);
++                    currentNibble.set(localIndex, targetLevel);
++                    this.postLightUpdate(offX, offY, offZ);
++
++                    if (targetLevel > 1) {
++                        if (queueLength >= queue.length) {
++                            queue = this.resizeIncreaseQueue();
+                         }
+-                        continue;
++                        queue[queueLength++] =
++                                ((offX + (offZ << 6) + (offY << 12) + encodeOffset) & ((1L << (6 + 6 + 16)) - 1))
++                                        | ((targetLevel & 0xFL) << (6 + 6 + 16))
++                                        | (propagate.everythingButTheOppositeDirection << (6 + 6 + 16 + 4))
++                                        | (flags);
+                     }
++                    continue;
+                 }
+             } else {
+                 // we actually need to worry about our state here
+                 final BlockState fromBlock = this.getBlockState(posX, posY, posZ);
+-                this.mutablePos2.set(posX, posY, posZ);
+                 for (final AxisDirection propagate : checkDirections) {
+                     final int offX = posX + propagate.x;
+                     final int offY = posY + propagate.y;
+                     final int offZ = posZ + propagate.z;
+ 
+-                    final VoxelShape fromShape = (((StarlightAbstractBlockState)fromBlock).starlight$isConditionallyFullOpaque()) ? fromBlock.getFaceOcclusionShape(world, this.mutablePos2, propagate.nms) : Shapes.empty();
++                    final VoxelShape fromShape = (((StarlightAbstractBlockState)fromBlock).starlight$isConditionallyFullOpaque()) ? fromBlock.getFaceOcclusionShape(propagate.nms) : Shapes.empty();
+ 
+                     if (fromShape != Shapes.empty() && Shapes.faceShapeOccludes(Shapes.empty(), fromShape)) {
+                         continue;
+@@ -1232,58 +1208,36 @@ public abstract class StarLightEngine {
+                     if (blockState == null) {
+                         continue;
+                     }
+-                    final int opacityCached = ((StarlightAbstractBlockState)blockState).starlight$getOpacityIfCached();
+-                    if (opacityCached != -1) {
+-                        final int targetLevel = propagatedLightLevel - Math.max(1, opacityCached);
+-                        if (targetLevel > currentLevel) {
+-                            currentNibble.set(localIndex, targetLevel);
+-                            this.postLightUpdate(offX, offY, offZ);
+-
+-                            if (targetLevel > 1) {
+-                                if (queueLength >= queue.length) {
+-                                    queue = this.resizeIncreaseQueue();
+-                                }
+-                                queue[queueLength++] =
+-                                        ((offX + (offZ << 6) + (offY << 12) + encodeOffset) & ((1L << (6 + 6 + 16)) - 1))
+-                                                | ((targetLevel & 0xFL) << (6 + 6 + 16))
+-                                                | (propagate.everythingButTheOppositeDirection << (6 + 6 + 16 + 4));
+-                                continue;
+-                            }
+-                        }
+-                        continue;
+-                    } else {
+-                        this.mutablePos1.set(offX, offY, offZ);
+-                        long flags = 0;
+-                        if (((StarlightAbstractBlockState)blockState).starlight$isConditionallyFullOpaque()) {
+-                            final VoxelShape cullingFace = blockState.getFaceOcclusionShape(world, this.mutablePos1, propagate.getOpposite().nms);
+-
+-                            if (Shapes.faceShapeOccludes(fromShape, cullingFace)) {
+-                                continue;
+-                            }
+-                            flags |= FLAG_HAS_SIDED_TRANSPARENT_BLOCKS;
+-                        }
++                    long flags = 0;
++                    if (((StarlightAbstractBlockState)blockState).starlight$isConditionallyFullOpaque()) {
++                        final VoxelShape cullingFace = blockState.getFaceOcclusionShape(propagate.getOpposite().nms);
+ 
+-                        final int opacity = blockState.getLightBlock(world, this.mutablePos1);
+-                        final int targetLevel = propagatedLightLevel - Math.max(1, opacity);
+-                        if (targetLevel <= currentLevel) {
++                        if (Shapes.faceShapeOccludes(fromShape, cullingFace)) {
+                             continue;
+                         }
++                        flags |= FLAG_HAS_SIDED_TRANSPARENT_BLOCKS;
++                    }
+ 
+-                        currentNibble.set(localIndex, targetLevel);
+-                        this.postLightUpdate(offX, offY, offZ);
++                    final int opacity = blockState.getLightBlock();
++                    final int targetLevel = propagatedLightLevel - Math.max(1, opacity);
++                    if (targetLevel <= currentLevel) {
++                        continue;
++                    }
+ 
+-                        if (targetLevel > 1) {
+-                            if (queueLength >= queue.length) {
+-                                queue = this.resizeIncreaseQueue();
+-                            }
+-                            queue[queueLength++] =
+-                                    ((offX + (offZ << 6) + (offY << 12) + encodeOffset) & ((1L << (6 + 6 + 16)) - 1))
+-                                            | ((targetLevel & 0xFL) << (6 + 6 + 16))
+-                                            | (propagate.everythingButTheOppositeDirection << (6 + 6 + 16 + 4))
+-                                            | (flags);
++                    currentNibble.set(localIndex, targetLevel);
++                    this.postLightUpdate(offX, offY, offZ);
++
++                    if (targetLevel > 1) {
++                        if (queueLength >= queue.length) {
++                            queue = this.resizeIncreaseQueue();
+                         }
+-                        continue;
++                        queue[queueLength++] =
++                                ((offX + (offZ << 6) + (offY << 12) + encodeOffset) & ((1L << (6 + 6 + 16)) - 1))
++                                        | ((targetLevel & 0xFL) << (6 + 6 + 16))
++                                        | (propagate.everythingButTheOppositeDirection << (6 + 6 + 16 + 4))
++                                        | (flags);
+                     }
++                    continue;
+                 }
+             }
+         }
+@@ -1304,6 +1258,8 @@ public abstract class StarLightEngine {
+         final int sectionOffset = this.chunkSectionIndexOffset;
+         final int emittedMask = this.emittedLightMask;
+ 
++        final PlatformHooks platformHooks = PlatformHooks.get();
++
+         while (queueReadIndex < queueLength) {
+             final long queueValue = queue[queueReadIndex++];
+ 
+@@ -1335,109 +1291,63 @@ public abstract class StarLightEngine {
+                     if (blockState == null) {
+                         continue;
+                     }
+-                    final int opacityCached = ((StarlightAbstractBlockState)blockState).starlight$getOpacityIfCached();
+-                    if (opacityCached != -1) {
+-                        final int targetLevel = Math.max(0, propagatedLightLevel - Math.max(1, opacityCached));
+-                        if (lightLevel > targetLevel) {
+-                            // it looks like another source propagated here, so re-propagate it
+-                            if (increaseQueueLength >= increaseQueue.length) {
+-                                increaseQueue = this.resizeIncreaseQueue();
+-                            }
+-                            increaseQueue[increaseQueueLength++] =
+-                                    ((offX + (offZ << 6) + (offY << 12) + encodeOffset) & ((1L << (6 + 6 + 16)) - 1))
+-                                            | ((lightLevel & 0xFL) << (6 + 6 + 16))
+-                                            | (((long)ALL_DIRECTIONS_BITSET) << (6 + 6 + 16 + 4))
+-                                            | FLAG_RECHECK_LEVEL;
+-                            continue;
+-                        }
+-                        final int emittedLight = blockState.getLightEmission() & emittedMask;
+-                        if (emittedLight != 0) {
+-                            // re-propagate source
+-                            // note: do not set recheck level, or else the propagation will fail
+-                            if (increaseQueueLength >= increaseQueue.length) {
+-                                increaseQueue = this.resizeIncreaseQueue();
+-                            }
+-                            increaseQueue[increaseQueueLength++] =
+-                                    ((offX + (offZ << 6) + (offY << 12) + encodeOffset) & ((1L << (6 + 6 + 16)) - 1))
+-                                            | ((emittedLight & 0xFL) << (6 + 6 + 16))
+-                                            | (((long)ALL_DIRECTIONS_BITSET) << (6 + 6 + 16 + 4))
+-                                            | (((StarlightAbstractBlockState)blockState).starlight$isConditionallyFullOpaque() ? (FLAG_WRITE_LEVEL | FLAG_HAS_SIDED_TRANSPARENT_BLOCKS) : FLAG_WRITE_LEVEL);
+-                        }
+-
+-                        currentNibble.set(localIndex, 0);
+-                        this.postLightUpdate(offX, offY, offZ);
++                    this.lightEmissionPos.set(offX, offY, offZ);
++                    long flags = 0;
++                    if (((StarlightAbstractBlockState)blockState).starlight$isConditionallyFullOpaque()) {
++                        final VoxelShape cullingFace = blockState.getFaceOcclusionShape(propagate.getOpposite().nms);
+ 
+-                        if (targetLevel > 0) { // we actually need to propagate 0 just in case we find a neighbour...
+-                            if (queueLength >= queue.length) {
+-                                queue = this.resizeDecreaseQueue();
+-                            }
+-                            queue[queueLength++] =
+-                                    ((offX + (offZ << 6) + (offY << 12) + encodeOffset) & ((1L << (6 + 6 + 16)) - 1))
+-                                            | ((targetLevel & 0xFL) << (6 + 6 + 16))
+-                                            | ((propagate.everythingButTheOppositeDirection) << (6 + 6 + 16 + 4));
++                        if (Shapes.faceShapeOccludes(Shapes.empty(), cullingFace)) {
+                             continue;
+                         }
+-                        continue;
+-                    } else {
+-                        this.mutablePos1.set(offX, offY, offZ);
+-                        long flags = 0;
+-                        if (((StarlightAbstractBlockState)blockState).starlight$isConditionallyFullOpaque()) {
+-                            final VoxelShape cullingFace = blockState.getFaceOcclusionShape(world, this.mutablePos1, propagate.getOpposite().nms);
+-
+-                            if (Shapes.faceShapeOccludes(Shapes.empty(), cullingFace)) {
+-                                continue;
+-                            }
+-                            flags |= FLAG_HAS_SIDED_TRANSPARENT_BLOCKS;
+-                        }
++                        flags |= FLAG_HAS_SIDED_TRANSPARENT_BLOCKS;
++                    }
+ 
+-                        final int opacity = blockState.getLightBlock(world, this.mutablePos1);
+-                        final int targetLevel = Math.max(0, propagatedLightLevel - Math.max(1, opacity));
+-                        if (lightLevel > targetLevel) {
+-                            // it looks like another source propagated here, so re-propagate it
+-                            if (increaseQueueLength >= increaseQueue.length) {
+-                                increaseQueue = this.resizeIncreaseQueue();
+-                            }
+-                            increaseQueue[increaseQueueLength++] =
+-                                    ((offX + (offZ << 6) + (offY << 12) + encodeOffset) & ((1L << (6 + 6 + 16)) - 1))
+-                                            | ((lightLevel & 0xFL) << (6 + 6 + 16))
+-                                            | (((long)ALL_DIRECTIONS_BITSET) << (6 + 6 + 16 + 4))
+-                                            | (FLAG_RECHECK_LEVEL | flags);
+-                            continue;
++                    final int opacity = blockState.getLightBlock();
++                    final int targetLevel = Math.max(0, propagatedLightLevel - Math.max(1, opacity));
++                    if (lightLevel > targetLevel) {
++                        // it looks like another source propagated here, so re-propagate it
++                        if (increaseQueueLength >= increaseQueue.length) {
++                            increaseQueue = this.resizeIncreaseQueue();
+                         }
+-                        final int emittedLight = blockState.getLightEmission() & emittedMask;
+-                        if (emittedLight != 0) {
+-                            // re-propagate source
+-                            // note: do not set recheck level, or else the propagation will fail
+-                            if (increaseQueueLength >= increaseQueue.length) {
+-                                increaseQueue = this.resizeIncreaseQueue();
+-                            }
+-                            increaseQueue[increaseQueueLength++] =
+-                                    ((offX + (offZ << 6) + (offY << 12) + encodeOffset) & ((1L << (6 + 6 + 16)) - 1))
+-                                            | ((emittedLight & 0xFL) << (6 + 6 + 16))
+-                                            | (((long)ALL_DIRECTIONS_BITSET) << (6 + 6 + 16 + 4))
+-                                            | (flags | FLAG_WRITE_LEVEL);
++                        increaseQueue[increaseQueueLength++] =
++                                ((offX + (offZ << 6) + (offY << 12) + encodeOffset) & ((1L << (6 + 6 + 16)) - 1))
++                                        | ((lightLevel & 0xFL) << (6 + 6 + 16))
++                                        | (((long)ALL_DIRECTIONS_BITSET) << (6 + 6 + 16 + 4))
++                                        | (FLAG_RECHECK_LEVEL | flags);
++                        continue;
++                    }
++                    final int emittedLight = (platformHooks.getLightEmission(blockState, world, this.lightEmissionPos)) & emittedMask;
++                    if (emittedLight != 0) {
++                        // re-propagate source
++                        // note: do not set recheck level, or else the propagation will fail
++                        if (increaseQueueLength >= increaseQueue.length) {
++                            increaseQueue = this.resizeIncreaseQueue();
+                         }
++                        increaseQueue[increaseQueueLength++] =
++                                ((offX + (offZ << 6) + (offY << 12) + encodeOffset) & ((1L << (6 + 6 + 16)) - 1))
++                                        | ((emittedLight & 0xFL) << (6 + 6 + 16))
++                                        | (((long)ALL_DIRECTIONS_BITSET) << (6 + 6 + 16 + 4))
++                                        | (flags | FLAG_WRITE_LEVEL);
++                    }
+ 
+-                        currentNibble.set(localIndex, 0);
+-                        this.postLightUpdate(offX, offY, offZ);
++                    currentNibble.set(localIndex, 0);
++                    this.postLightUpdate(offX, offY, offZ);
+ 
+-                        if (targetLevel > 0) {
+-                            if (queueLength >= queue.length) {
+-                                queue = this.resizeDecreaseQueue();
+-                            }
+-                            queue[queueLength++] =
+-                                    ((offX + (offZ << 6) + (offY << 12) + encodeOffset) & ((1L << (6 + 6 + 16)) - 1))
+-                                            | ((targetLevel & 0xFL) << (6 + 6 + 16))
+-                                            | ((propagate.everythingButTheOppositeDirection) << (6 + 6 + 16 + 4))
+-                                            | flags;
++                    if (targetLevel > 0) {
++                        if (queueLength >= queue.length) {
++                            queue = this.resizeDecreaseQueue();
+                         }
+-                        continue;
++                        queue[queueLength++] =
++                                ((offX + (offZ << 6) + (offY << 12) + encodeOffset) & ((1L << (6 + 6 + 16)) - 1))
++                                        | ((targetLevel & 0xFL) << (6 + 6 + 16))
++                                        | ((propagate.everythingButTheOppositeDirection) << (6 + 6 + 16 + 4))
++                                        | flags;
+                     }
++                    continue;
+                 }
+             } else {
+                 // we actually need to worry about our state here
+                 final BlockState fromBlock = this.getBlockState(posX, posY, posZ);
+-                this.mutablePos2.set(posX, posY, posZ);
+                 for (final AxisDirection propagate : checkDirections) {
+                     final int offX = posX + propagate.x;
+                     final int offY = posY + propagate.y;
+@@ -1446,7 +1356,7 @@ public abstract class StarLightEngine {
+                     final int sectionIndex = (offX >> 4) + 5 * (offZ >> 4) + (5 * 5) * (offY >> 4) + sectionOffset;
+                     final int localIndex = (offX & 15) | ((offZ & 15) << 4) | ((offY & 15) << 8);
+ 
+-                    final VoxelShape fromShape = (((StarlightAbstractBlockState)fromBlock).starlight$isConditionallyFullOpaque()) ? fromBlock.getFaceOcclusionShape(world, this.mutablePos2, propagate.nms) : Shapes.empty();
++                    final VoxelShape fromShape = (((StarlightAbstractBlockState)fromBlock).starlight$isConditionallyFullOpaque()) ? fromBlock.getFaceOcclusionShape(propagate.nms) : Shapes.empty();
+ 
+                     if (fromShape != Shapes.empty() && Shapes.faceShapeOccludes(Shapes.empty(), fromShape)) {
+                         continue;
+@@ -1464,104 +1374,59 @@ public abstract class StarLightEngine {
+                     if (blockState == null) {
+                         continue;
+                     }
+-                    final int opacityCached = ((StarlightAbstractBlockState)blockState).starlight$getOpacityIfCached();
+-                    if (opacityCached != -1) {
+-                        final int targetLevel = Math.max(0, propagatedLightLevel - Math.max(1, opacityCached));
+-                        if (lightLevel > targetLevel) {
+-                            // it looks like another source propagated here, so re-propagate it
+-                            if (increaseQueueLength >= increaseQueue.length) {
+-                                increaseQueue = this.resizeIncreaseQueue();
+-                            }
+-                            increaseQueue[increaseQueueLength++] =
+-                                    ((offX + (offZ << 6) + (offY << 12) + encodeOffset) & ((1L << (6 + 6 + 16)) - 1))
+-                                            | ((lightLevel & 0xFL) << (6 + 6 + 16))
+-                                            | (((long)ALL_DIRECTIONS_BITSET) << (6 + 6 + 16 + 4))
+-                                            | FLAG_RECHECK_LEVEL;
+-                            continue;
+-                        }
+-                        final int emittedLight = blockState.getLightEmission() & emittedMask;
+-                        if (emittedLight != 0) {
+-                            // re-propagate source
+-                            // note: do not set recheck level, or else the propagation will fail
+-                            if (increaseQueueLength >= increaseQueue.length) {
+-                                increaseQueue = this.resizeIncreaseQueue();
+-                            }
+-                            increaseQueue[increaseQueueLength++] =
+-                                    ((offX + (offZ << 6) + (offY << 12) + encodeOffset) & ((1L << (6 + 6 + 16)) - 1))
+-                                            | ((emittedLight & 0xFL) << (6 + 6 + 16))
+-                                            | (((long)ALL_DIRECTIONS_BITSET) << (6 + 6 + 16 + 4))
+-                                            | (((StarlightAbstractBlockState)blockState).starlight$isConditionallyFullOpaque() ? (FLAG_WRITE_LEVEL | FLAG_HAS_SIDED_TRANSPARENT_BLOCKS) : FLAG_WRITE_LEVEL);
+-                        }
+-
+-                        currentNibble.set(localIndex, 0);
+-                        this.postLightUpdate(offX, offY, offZ);
++                    this.lightEmissionPos.set(offX, offY, offZ);
++                    long flags = 0;
++                    if (((StarlightAbstractBlockState)blockState).starlight$isConditionallyFullOpaque()) {
++                        final VoxelShape cullingFace = blockState.getFaceOcclusionShape(propagate.getOpposite().nms);
+ 
+-                        if (targetLevel > 0) { // we actually need to propagate 0 just in case we find a neighbour...
+-                            if (queueLength >= queue.length) {
+-                                queue = this.resizeDecreaseQueue();
+-                            }
+-                            queue[queueLength++] =
+-                                    ((offX + (offZ << 6) + (offY << 12) + encodeOffset) & ((1L << (6 + 6 + 16)) - 1))
+-                                            | ((targetLevel & 0xFL) << (6 + 6 + 16))
+-                                            | ((propagate.everythingButTheOppositeDirection) << (6 + 6 + 16 + 4));
++                        if (Shapes.faceShapeOccludes(fromShape, cullingFace)) {
+                             continue;
+                         }
+-                        continue;
+-                    } else {
+-                        this.mutablePos1.set(offX, offY, offZ);
+-                        long flags = 0;
+-                        if (((StarlightAbstractBlockState)blockState).starlight$isConditionallyFullOpaque()) {
+-                            final VoxelShape cullingFace = blockState.getFaceOcclusionShape(world, this.mutablePos1, propagate.getOpposite().nms);
+-
+-                            if (Shapes.faceShapeOccludes(fromShape, cullingFace)) {
+-                                continue;
+-                            }
+-                            flags |= FLAG_HAS_SIDED_TRANSPARENT_BLOCKS;
+-                        }
++                        flags |= FLAG_HAS_SIDED_TRANSPARENT_BLOCKS;
++                    }
+ 
+-                        final int opacity = blockState.getLightBlock(world, this.mutablePos1);
+-                        final int targetLevel = Math.max(0, propagatedLightLevel - Math.max(1, opacity));
+-                        if (lightLevel > targetLevel) {
+-                            // it looks like another source propagated here, so re-propagate it
+-                            if (increaseQueueLength >= increaseQueue.length) {
+-                                increaseQueue = this.resizeIncreaseQueue();
+-                            }
+-                            increaseQueue[increaseQueueLength++] =
+-                                    ((offX + (offZ << 6) + (offY << 12) + encodeOffset) & ((1L << (6 + 6 + 16)) - 1))
+-                                            | ((lightLevel & 0xFL) << (6 + 6 + 16))
+-                                            | (((long)ALL_DIRECTIONS_BITSET) << (6 + 6 + 16 + 4))
+-                                            | (FLAG_RECHECK_LEVEL | flags);
+-                            continue;
++                    final int opacity = blockState.getLightBlock();
++                    final int targetLevel = Math.max(0, propagatedLightLevel - Math.max(1, opacity));
++                    if (lightLevel > targetLevel) {
++                        // it looks like another source propagated here, so re-propagate it
++                        if (increaseQueueLength >= increaseQueue.length) {
++                            increaseQueue = this.resizeIncreaseQueue();
+                         }
+-                        final int emittedLight = blockState.getLightEmission() & emittedMask;
+-                        if (emittedLight != 0) {
+-                            // re-propagate source
+-                            // note: do not set recheck level, or else the propagation will fail
+-                            if (increaseQueueLength >= increaseQueue.length) {
+-                                increaseQueue = this.resizeIncreaseQueue();
+-                            }
+-                            increaseQueue[increaseQueueLength++] =
+-                                    ((offX + (offZ << 6) + (offY << 12) + encodeOffset) & ((1L << (6 + 6 + 16)) - 1))
+-                                            | ((emittedLight & 0xFL) << (6 + 6 + 16))
+-                                            | (((long)ALL_DIRECTIONS_BITSET) << (6 + 6 + 16 + 4))
+-                                            | (flags | FLAG_WRITE_LEVEL);
++                        increaseQueue[increaseQueueLength++] =
++                                ((offX + (offZ << 6) + (offY << 12) + encodeOffset) & ((1L << (6 + 6 + 16)) - 1))
++                                        | ((lightLevel & 0xFL) << (6 + 6 + 16))
++                                        | (((long)ALL_DIRECTIONS_BITSET) << (6 + 6 + 16 + 4))
++                                        | (FLAG_RECHECK_LEVEL | flags);
++                        continue;
++                    }
++                    final int emittedLight = (platformHooks.getLightEmission(blockState, world, this.lightEmissionPos)) & emittedMask;
++                    if (emittedLight != 0) {
++                        // re-propagate source
++                        // note: do not set recheck level, or else the propagation will fail
++                        if (increaseQueueLength >= increaseQueue.length) {
++                            increaseQueue = this.resizeIncreaseQueue();
+                         }
++                        increaseQueue[increaseQueueLength++] =
++                                ((offX + (offZ << 6) + (offY << 12) + encodeOffset) & ((1L << (6 + 6 + 16)) - 1))
++                                        | ((emittedLight & 0xFL) << (6 + 6 + 16))
++                                        | (((long)ALL_DIRECTIONS_BITSET) << (6 + 6 + 16 + 4))
++                                        | (flags | FLAG_WRITE_LEVEL);
++                    }
+ 
+-                        currentNibble.set(localIndex, 0);
+-                        this.postLightUpdate(offX, offY, offZ);
++                    currentNibble.set(localIndex, 0);
++                    this.postLightUpdate(offX, offY, offZ);
+ 
+-                        if (targetLevel > 0) { // we actually need to propagate 0 just in case we find a neighbour...
+-                            if (queueLength >= queue.length) {
+-                                queue = this.resizeDecreaseQueue();
+-                            }
+-                            queue[queueLength++] =
+-                                    ((offX + (offZ << 6) + (offY << 12) + encodeOffset) & ((1L << (6 + 6 + 16)) - 1))
+-                                            | ((targetLevel & 0xFL) << (6 + 6 + 16))
+-                                            | ((propagate.everythingButTheOppositeDirection) << (6 + 6 + 16 + 4))
+-                                            | flags;
++                    if (targetLevel > 0) { // we actually need to propagate 0 just in case we find a neighbour...
++                        if (queueLength >= queue.length) {
++                            queue = this.resizeDecreaseQueue();
+                         }
+-                        continue;
++                        queue[queueLength++] =
++                                ((offX + (offZ << 6) + (offY << 12) + encodeOffset) & ((1L << (6 + 6 + 16)) - 1))
++                                        | ((targetLevel & 0xFL) << (6 + 6 + 16))
++                                        | ((propagate.everythingButTheOppositeDirection) << (6 + 6 + 16 + 4))
++                                        | flags;
+                     }
++                    continue;
+                 }
+             }
+         }
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/starlight/light/StarLightInterface.java b/src/main/java/ca/spottedleaf/moonrise/patches/starlight/light/StarLightInterface.java
+index c64ab41198a5e0c7cbcbe6452af11f82f5938862..571db5f9bf94745a8afe2cd313e593fb15db5e37 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/starlight/light/StarLightInterface.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/starlight/light/StarLightInterface.java
+@@ -1,8 +1,9 @@
+ package ca.spottedleaf.moonrise.patches.starlight.light;
+ 
+ import ca.spottedleaf.concurrentutil.collection.MultiThreadedQueue;
+-import ca.spottedleaf.concurrentutil.executor.standard.PrioritisedExecutor;
++import ca.spottedleaf.concurrentutil.executor.PrioritisedExecutor;
+ import ca.spottedleaf.concurrentutil.map.ConcurrentLong2ReferenceChainedHashTable;
++import ca.spottedleaf.concurrentutil.util.Priority;
+ import ca.spottedleaf.moonrise.common.util.CoordinateUtils;
+ import ca.spottedleaf.moonrise.common.util.WorldUtil;
+ import ca.spottedleaf.moonrise.patches.chunk_system.level.ChunkSystemLevel;
+@@ -745,34 +746,34 @@ public final class StarLightInterface {
+             super(lightInterface);
+         }
+ 
+-        public void lowerPriority(final int chunkX, final int chunkZ, final PrioritisedExecutor.Priority priority) {
++        public void lowerPriority(final int chunkX, final int chunkZ, final Priority priority) {
+             final ServerChunkTasks task = this.chunkTasks.get(CoordinateUtils.getChunkKey(chunkX, chunkZ));
+             if (task != null) {
+                 task.lowerPriority(priority);
+             }
+         }
+ 
+-        public void setPriority(final int chunkX, final int chunkZ, final PrioritisedExecutor.Priority priority) {
++        public void setPriority(final int chunkX, final int chunkZ, final Priority priority) {
+             final ServerChunkTasks task = this.chunkTasks.get(CoordinateUtils.getChunkKey(chunkX, chunkZ));
+             if (task != null) {
+                 task.setPriority(priority);
+             }
+         }
+ 
+-        public void raisePriority(final int chunkX, final int chunkZ, final PrioritisedExecutor.Priority priority) {
++        public void raisePriority(final int chunkX, final int chunkZ, final Priority priority) {
+             final ServerChunkTasks task = this.chunkTasks.get(CoordinateUtils.getChunkKey(chunkX, chunkZ));
+             if (task != null) {
+                 task.raisePriority(priority);
+             }
+         }
+ 
+-        public PrioritisedExecutor.Priority getPriority(final int chunkX, final int chunkZ) {
++        public Priority getPriority(final int chunkX, final int chunkZ) {
+             final ServerChunkTasks task = this.chunkTasks.get(CoordinateUtils.getChunkKey(chunkX, chunkZ));
+             if (task != null) {
+                 return task.getPriority();
+             }
+ 
+-            return PrioritisedExecutor.Priority.COMPLETING;
++            return Priority.COMPLETING;
+         }
+ 
+         @Override
+@@ -816,7 +817,7 @@ public final class StarLightInterface {
+             return ret;
+         }
+ 
+-        public ServerChunkTasks queueChunkLightTask(final ChunkPos pos, final BooleanSupplier lightTask, final PrioritisedExecutor.Priority priority) {
++        public ServerChunkTasks queueChunkLightTask(final ChunkPos pos, final BooleanSupplier lightTask, final Priority priority) {
+             final ServerChunkTasks ret = this.chunkTasks.compute(CoordinateUtils.getChunkKey(pos), (final long keyInMap, ServerChunkTasks valueInMap) -> {
+                 if (valueInMap == null) {
+                     valueInMap = new ServerChunkTasks(
+@@ -879,11 +880,11 @@ public final class StarLightInterface {
+ 
+             public ServerChunkTasks(final long chunkCoordinate, final StarLightInterface lightEngine,
+                                     final ServerLightQueue queue) {
+-                this(chunkCoordinate, lightEngine, queue, PrioritisedExecutor.Priority.NORMAL);
++                this(chunkCoordinate, lightEngine, queue, Priority.NORMAL);
+             }
+ 
+             public ServerChunkTasks(final long chunkCoordinate, final StarLightInterface lightEngine,
+-                                    final ServerLightQueue queue, final PrioritisedExecutor.Priority priority) {
++                                    final ServerLightQueue queue, final Priority priority) {
+                 super(chunkCoordinate, lightEngine, queue);
+                 this.task = ((ChunkSystemServerLevel)(ServerLevel)lightEngine.getWorld()).moonrise$getChunkTaskScheduler().radiusAwareScheduler.createTask(
+                         CoordinateUtils.getChunkX(chunkCoordinate), CoordinateUtils.getChunkZ(chunkCoordinate),
+@@ -903,19 +904,19 @@ public final class StarLightInterface {
+                 return this.task.cancel();
+             }
+ 
+-            public PrioritisedExecutor.Priority getPriority() {
++            public Priority getPriority() {
+                 return this.task.getPriority();
+             }
+ 
+-            public void lowerPriority(final PrioritisedExecutor.Priority priority) {
++            public void lowerPriority(final Priority priority) {
+                 this.task.lowerPriority(priority);
+             }
+ 
+-            public void setPriority(final PrioritisedExecutor.Priority priority) {
++            public void setPriority(final Priority priority) {
+                 this.task.setPriority(priority);
+             }
+ 
+-            public void raisePriority(final PrioritisedExecutor.Priority priority) {
++            public void raisePriority(final Priority priority) {
+                 this.task.raisePriority(priority);
+             }
+ 
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/starlight/storage/StarlightSectionData.java b/src/main/java/ca/spottedleaf/moonrise/patches/starlight/storage/StarlightSectionData.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..40d004afdc6449530f5bb2d7c7638b8ee3e3a577
+--- /dev/null
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/starlight/storage/StarlightSectionData.java
+@@ -0,0 +1,13 @@
++package ca.spottedleaf.moonrise.patches.starlight.storage;
++
++public interface StarlightSectionData {
++
++    public int starlight$getBlockLightState();
++
++    public void starlight$setBlockLightState(final int state);
++
++    public int starlight$getSkyLightState();
++
++    public void starlight$setSkyLightState(final int state);
++
++}
+diff --git a/src/main/java/ca/spottedleaf/moonrise/patches/starlight/util/SaveUtil.java b/src/main/java/ca/spottedleaf/moonrise/patches/starlight/util/SaveUtil.java
+index 57692a503e147a00ac4e1586cd78e12b71a80d3f..689ce367164e79e0426eeecb81dbbc521d4bc742 100644
+--- a/src/main/java/ca/spottedleaf/moonrise/patches/starlight/util/SaveUtil.java
++++ b/src/main/java/ca/spottedleaf/moonrise/patches/starlight/util/SaveUtil.java
+@@ -14,19 +14,20 @@ import net.minecraft.world.level.chunk.ChunkAccess;
+ import net.minecraft.world.level.chunk.status.ChunkStatus;
+ import org.slf4j.Logger;
+ 
++// note: keep in-sync with SerializableChunkDataMixin
+ public final class SaveUtil {
+ 
+     private static final Logger LOGGER = LogUtils.getLogger();
+ 
+-    private static final int STARLIGHT_LIGHT_VERSION = 9;
++    public static final int STARLIGHT_LIGHT_VERSION = 9;
+ 
+     public static int getLightVersion() {
+         return STARLIGHT_LIGHT_VERSION;
+     }
+ 
+-    private static final String BLOCKLIGHT_STATE_TAG = "starlight.blocklight_state";
+-    private static final String SKYLIGHT_STATE_TAG = "starlight.skylight_state";
+-    private static final String STARLIGHT_VERSION_TAG = "starlight.light_version";
++    public static final String BLOCKLIGHT_STATE_TAG = "starlight.blocklight_state";
++    public static final String SKYLIGHT_STATE_TAG = "starlight.skylight_state";
++    public static final String STARLIGHT_VERSION_TAG = "starlight.light_version";
+ 
+     public static void saveLightHook(final Level world, final ChunkAccess chunk, final CompoundTag nbt) {
+         try {
+diff --git a/src/main/java/io/papermc/paper/configuration/GlobalConfiguration.java b/src/main/java/io/papermc/paper/configuration/GlobalConfiguration.java
+index a9dd0e5216e95afd98fd2200d110e2cc0b1b0dca..8371ce4e3df5ef8e39acd6e005209337cc76b451 100644
+--- a/src/main/java/io/papermc/paper/configuration/GlobalConfiguration.java
++++ b/src/main/java/io/papermc/paper/configuration/GlobalConfiguration.java
+@@ -243,6 +243,7 @@ public class GlobalConfiguration extends ConfigurationPart {
+ 
+         @PostProcess
+         private void postProcess() {
++            ca.spottedleaf.moonrise.common.util.MoonriseCommon.adjustWorkerThreads(this.workerThreads, this.ioThreads);
+             ca.spottedleaf.moonrise.patches.chunk_system.scheduling.ChunkTaskScheduler.init(this);
+         }
+     }
+diff --git a/src/main/java/net/minecraft/core/MappedRegistry.java b/src/main/java/net/minecraft/core/MappedRegistry.java
+index f22d22ebcedcc9c20225677844c86a1ad27c4211..ee1d39b6196c0f87ba473a15d3377e858922696c 100644
+--- a/src/main/java/net/minecraft/core/MappedRegistry.java
++++ b/src/main/java/net/minecraft/core/MappedRegistry.java
+@@ -78,6 +78,19 @@ public class MappedRegistry<T> implements WritableRegistry<T> {
+     };
+     private final Object tagAdditionLock = new Object();
+ 
++    // Paper start - fluid method optimisations
++    private void injectFluidRegister(
++        final ResourceKey<?> resourceKey,
++        final T object
++    ) {
++        if (resourceKey.registryKey() == (Object)net.minecraft.core.registries.Registries.FLUID) {
++            for (final net.minecraft.world.level.material.FluidState possibleState : ((net.minecraft.world.level.material.Fluid)object).getStateDefinition().getPossibleStates()) {
++                ((ca.spottedleaf.moonrise.patches.fluid.FluidFluidState)(Object)possibleState).moonrise$initCaches();
++            }
++        }
++    }
++    // Paper end - fluid method optimisations
++
+     public MappedRegistry(ResourceKey<? extends Registry<T>> key, Lifecycle lifecycle) {
+         this(key, lifecycle, false);
+     }
+@@ -145,6 +158,7 @@ public class MappedRegistry<T> implements WritableRegistry<T> {
+         this.toId.put(value, i);
+         this.registrationInfos.put(key, info);
+         this.registryLifecycle = this.registryLifecycle.add(info.lifecycle());
++        this.injectFluidRegister(key, value); // Paper - fluid method optimisations
+         return reference;
+     }
+ 
+diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java
+index 696d075ca2883f3c37e35f983c4d020e5db89d16..25047b8536bc7e7a91ac0dfb82ad77099af6f125 100644
+--- a/src/main/java/net/minecraft/server/MinecraftServer.java
++++ b/src/main/java/net/minecraft/server/MinecraftServer.java
+@@ -1106,7 +1106,14 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
+         // Spigot end
+ 
+         // Paper end - Improved watchdog support; move final shutdown items here
+-        ca.spottedleaf.moonrise.patches.chunk_system.io.RegionFileIOThread.deinit(); // Paper - rewrite chunk system
++        // Paper start - rewrite chunk system
++        LOGGER.info("Waiting for I/O tasks to complete...");
++        ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO.flush((MinecraftServer)(Object)this);
++        LOGGER.info("All I/O tasks to complete");
++        if ((Object)this instanceof DedicatedServer) {
++            ca.spottedleaf.moonrise.common.util.MoonriseCommon.haltExecutors();
++        }
++        // Paper end - rewrite chunk system
+         // Paper start - move final shutdown items here
+         Util.shutdownExecutors();
+         try {
+diff --git a/src/main/java/net/minecraft/server/level/ChunkHolder.java b/src/main/java/net/minecraft/server/level/ChunkHolder.java
+index 4db96543e2072e47040bb25a9d97ea6a69c4a43d..2b082a644332569f0bcc84011430366150ef504d 100644
+--- a/src/main/java/net/minecraft/server/level/ChunkHolder.java
++++ b/src/main/java/net/minecraft/server/level/ChunkHolder.java
+@@ -245,7 +245,7 @@ public class ChunkHolder extends GenerationChunkHolder implements ca.spottedleaf
+ 
+         if (ichunkaccess != null) {
+             ichunkaccess.setUnsaved(true);
+-            LevelChunk chunk = this.getChunkToSend(); // Paper - rewrite chunk system
++            LevelChunk chunk = this.playersSentChunkTo.size() == 0 ? null : this.getChunkToSend(); // Paper - rewrite chunk system
+ 
+             if (chunk != null) {
+                 int j = this.lightEngine.getMinLightSection();
+diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java
+index af8cb316ac169aa8d98a88765b85bb013b9ba961..38de8d8ed2efa3476d4e906bdc4b5944430bd1b7 100644
+--- a/src/main/java/net/minecraft/server/level/ChunkMap.java
++++ b/src/main/java/net/minecraft/server/level/ChunkMap.java
+@@ -916,7 +916,6 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
+ 
+     // Paper start - optimise entity tracker
+     private void newTrackerTick() {
+-        final ca.spottedleaf.moonrise.common.misc.NearbyPlayers nearbyPlayers = ((ca.spottedleaf.moonrise.patches.chunk_system.level.ChunkSystemServerLevel)this.level).moonrise$getNearbyPlayers();
+         final ca.spottedleaf.moonrise.patches.chunk_system.level.entity.server.ServerEntityLookup entityLookup = (ca.spottedleaf.moonrise.patches.chunk_system.level.entity.server.ServerEntityLookup)((ca.spottedleaf.moonrise.patches.chunk_system.level.ChunkSystemServerLevel)this.level).moonrise$getEntityLookup();;
+ 
+         final ca.spottedleaf.moonrise.common.list.ReferenceList<net.minecraft.world.entity.Entity> trackerEntities = entityLookup.trackerEntities;
+@@ -927,21 +926,11 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
+             if (tracker == null) {
+                 continue;
+             }
+-            ((ca.spottedleaf.moonrise.patches.entity_tracker.EntityTrackerTrackedEntity)tracker).moonrise$tick(nearbyPlayers.getChunk(entity.chunkPosition()));
+-            tracker.serverEntity.sendChanges();
+-        }
+-
+-        // process unloads
+-        final ca.spottedleaf.moonrise.common.list.ReferenceList<net.minecraft.world.entity.Entity> unloadedEntities = entityLookup.trackerUnloadedEntities;
+-        final Entity[] unloadedEntitiesRaw = java.util.Arrays.copyOf(unloadedEntities.getRawDataUnchecked(), unloadedEntities.size());
+-        unloadedEntities.clear();
+-
+-        for (final Entity entity : unloadedEntitiesRaw) {
+-            final ChunkMap.TrackedEntity tracker = ((ca.spottedleaf.moonrise.patches.entity_tracker.EntityTrackerEntity)entity).moonrise$getTrackedEntity();
+-            if (tracker == null) {
+-                continue;
++            ((ca.spottedleaf.moonrise.patches.entity_tracker.EntityTrackerTrackedEntity)tracker).moonrise$tick(((ca.spottedleaf.moonrise.patches.chunk_system.entity.ChunkSystemEntity)entity).moonrise$getChunkData().nearbyPlayers);
++            if (((ca.spottedleaf.moonrise.patches.entity_tracker.EntityTrackerTrackedEntity)tracker).moonrise$hasPlayers()
++                || ((ca.spottedleaf.moonrise.patches.chunk_system.entity.ChunkSystemEntity)entity).moonrise$getChunkStatus().isOrAfter(FullChunkStatus.ENTITY_TICKING)) {
++                tracker.serverEntity.sendChanges();
+             }
+-            ((ca.spottedleaf.moonrise.patches.entity_tracker.EntityTrackerTrackedEntity)tracker).moonrise$clearPlayers();
+         }
+     }
+     // Paper end - optimise entity tracker
+@@ -1178,6 +1167,11 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
+                 this.removePlayer(player);
+             }
+         }
++
++        @Override
++        public final boolean moonrise$hasPlayers() {
++            return !this.seenBy.isEmpty();
++        }
+         // Paper end - optimise entity tracker
+ 
+         public TrackedEntity(final Entity entity, final int i, final int j, final boolean flag) {
+@@ -1283,20 +1277,24 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
+         }
+ 
+         private int getEffectiveRange() {
+-            int i = this.range;
+-            Iterator iterator = this.entity.getIndirectPassengers().iterator();
++            // Paper start - optimise entity tracker
++            final Entity entity = this.entity;
++            int range = ca.spottedleaf.moonrise.common.PlatformHooks.get().modifyEntityTrackingRange(entity, this.range);
+ 
+-            while (iterator.hasNext()) {
+-                Entity entity = (Entity) iterator.next();
+-                int j = entity.getType().clientTrackingRange() * 16;
+-                j = org.spigotmc.TrackingRange.getEntityTrackingRange(entity, j); // Paper
++            if (entity.getPassengers() == ImmutableList.<Entity>of()) {
++                return this.scaledRange(range);
++            }
+ 
+-                if (j > i) {
+-                    i = j;
+-                }
++            // note: we change to List
++            final List<Entity> passengers = (List<Entity>)entity.getIndirectPassengers();
++            for (int i = 0, len = passengers.size(); i < len; ++i) {
++                final Entity passenger = passengers.get(i);
++                // note: max should be branchless
++                range = Math.max(range, ca.spottedleaf.moonrise.common.PlatformHooks.get().modifyEntityTrackingRange(passenger, passenger.getType().clientTrackingRange() << 4));
+             }
+ 
+-            return this.scaledRange(i);
++            return this.scaledRange(range);
++            // Paper end - optimise entity tracker
+         }
+ 
+         public void updatePlayers(List<ServerPlayer> players) {
+diff --git a/src/main/java/net/minecraft/server/level/ServerChunkCache.java b/src/main/java/net/minecraft/server/level/ServerChunkCache.java
+index dcb5651d1d9b10b40430fb2f713beedf68336704..b380509cc942a054ea176216210ba69f5b517ae9 100644
+--- a/src/main/java/net/minecraft/server/level/ServerChunkCache.java
++++ b/src/main/java/net/minecraft/server/level/ServerChunkCache.java
+@@ -92,7 +92,7 @@ public class ServerChunkCache extends ChunkSource implements ca.spottedleaf.moon
+         final ca.spottedleaf.moonrise.patches.chunk_system.scheduling.ChunkTaskScheduler chunkTaskScheduler = ((ca.spottedleaf.moonrise.patches.chunk_system.level.ChunkSystemServerLevel)this.level).moonrise$getChunkTaskScheduler();
+         final CompletableFuture<ChunkAccess> completable = new CompletableFuture<>();
+         chunkTaskScheduler.scheduleChunkLoad(
+-            chunkX, chunkZ, toStatus, true, ca.spottedleaf.concurrentutil.executor.standard.PrioritisedExecutor.Priority.BLOCKING,
++            chunkX, chunkZ, toStatus, true, ca.spottedleaf.concurrentutil.util.Priority.BLOCKING,
+             completable::complete
+         );
+ 
+@@ -123,6 +123,15 @@ public class ServerChunkCache extends ChunkSource implements ca.spottedleaf.moon
+             return ifPresent;
+         }
+ 
++        final ca.spottedleaf.moonrise.common.PlatformHooks platformHooks = ca.spottedleaf.moonrise.common.PlatformHooks.get();
++
++        if (platformHooks.hasCurrentlyLoadingChunk() && currentChunk != null) {
++            final ChunkAccess loading = platformHooks.getCurrentlyLoadingChunk(currentChunk.vanillaChunkHolder);
++            if (loading != null && ca.spottedleaf.moonrise.common.util.TickThread.isTickThread()) {
++                return loading;
++            }
++        }
++
+         return load ? this.syncLoad(chunkX, chunkZ, toStatus) : null;
+     }
+     // Paper end - rewrite chunk system
+@@ -242,7 +251,24 @@ public class ServerChunkCache extends ChunkSource implements ca.spottedleaf.moon
+     @Nullable
+     @Override
+     public LevelChunk getChunkNow(int chunkX, int chunkZ) {
+-        return this.fullChunks.get(ca.spottedleaf.moonrise.common.util.CoordinateUtils.getChunkKey(chunkX, chunkZ)); // Paper - rewrite chunk system
++        // Paper start - rewrite chunk system
++        final LevelChunk ret = this.fullChunks.get(ca.spottedleaf.moonrise.common.util.CoordinateUtils.getChunkKey(chunkX, chunkZ));
++        if (!ca.spottedleaf.moonrise.common.PlatformHooks.get().hasCurrentlyLoadingChunk()) {
++            return ret;
++        }
++
++        if (ret != null || !ca.spottedleaf.moonrise.common.util.TickThread.isTickThread()) {
++            return ret;
++        }
++
++        final ca.spottedleaf.moonrise.patches.chunk_system.scheduling.NewChunkHolder holder = ((ca.spottedleaf.moonrise.patches.chunk_system.level.ChunkSystemServerLevel)this.level).moonrise$getChunkTaskScheduler()
++            .chunkHolderManager.getChunkHolder(chunkX, chunkZ);
++        if (holder == null) {
++            return ret;
++        }
++
++        return ca.spottedleaf.moonrise.common.PlatformHooks.get().getCurrentlyLoadingChunk(holder.vanillaChunkHolder);
++        // Paper end - rewrite chunk system
+     }
+ 
+     private void clearCache() {
+@@ -299,7 +325,7 @@ public class ServerChunkCache extends ChunkSource implements ca.spottedleaf.moon
+ 
+             ((ca.spottedleaf.moonrise.patches.chunk_system.level.ChunkSystemServerLevel)this.level).moonrise$getChunkTaskScheduler().scheduleChunkLoad(
+                 chunkX, chunkZ, leastStatus, true,
+-                ca.spottedleaf.concurrentutil.executor.standard.PrioritisedExecutor.Priority.HIGHER,
++                ca.spottedleaf.concurrentutil.util.Priority.HIGHER,
+                 complete
+             );
+ 
+@@ -556,7 +582,8 @@ public class ServerChunkCache extends ChunkSource implements ca.spottedleaf.moon
+ 
+     private void getFullChunk(long pos, Consumer<LevelChunk> chunkConsumer) {
+         // Paper start - rewrite chunk system
+-        final LevelChunk fullChunk = this.getChunkNow(ca.spottedleaf.moonrise.common.util.CoordinateUtils.getChunkX(pos), ca.spottedleaf.moonrise.common.util.CoordinateUtils.getChunkZ(pos));
++        // note: bypass currentlyLoaded from getChunkNow
++        final LevelChunk fullChunk = this.fullChunks.get(pos);
+         if (fullChunk != null) {
+             chunkConsumer.accept(fullChunk);
+         }
+diff --git a/src/main/java/net/minecraft/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
+index f9abf63e12ea930275121b470e4e4906cff0fc12..55e81892b928a02e240aaa31dd501b0aacef8dbe 100644
+--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
++++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
+@@ -799,11 +799,13 @@ public class ServerLevel extends Level implements WorldGenLevel, ca.spottedleaf.
+     }
+ 
+     // Paper start - optimise random ticking
++    private final ca.spottedleaf.moonrise.common.util.SimpleRandom simpleRandom = new ca.spottedleaf.moonrise.common.util.SimpleRandom(0L);
++
+     private void optimiseRandomTick(final LevelChunk chunk, final int tickSpeed) {
+         final LevelChunkSection[] sections = chunk.getSections();
+         final int minSection = ca.spottedleaf.moonrise.common.util.WorldUtil.getMinSection((ServerLevel)(Object)this);
+-        final RandomSource random = this.random;
+-        final boolean tickFluids = false; // Paper - not configurable - MC-224294
++        final ca.spottedleaf.moonrise.common.util.SimpleRandom simpleRandom = this.simpleRandom;
++        final boolean doubleTickFluids = !ca.spottedleaf.moonrise.common.PlatformHooks.get().configFixMC224294();
+ 
+         final ChunkPos cpos = chunk.getPos();
+         final int offsetX = cpos.x << 4;
+@@ -813,39 +815,32 @@ public class ServerLevel extends Level implements WorldGenLevel, ca.spottedleaf.
+             final int offsetY = (sectionIndex + minSection) << 4;
+             final LevelChunkSection section = sections[sectionIndex];
+             final net.minecraft.world.level.chunk.PalettedContainer<net.minecraft.world.level.block.state.BlockState> states = section.states;
+-            if (section == null || !section.isRandomlyTickingBlocks()) {
++            if (!section.isRandomlyTickingBlocks()) {
+                 continue;
+             }
+ 
+-            final ca.spottedleaf.moonrise.common.list.IBlockDataList tickList = ((ca.spottedleaf.moonrise.patches.block_counting.BlockCountingChunkSection)section).moonrise$getTickingBlockList();
+-            if (tickList.size() == 0) {
+-                continue;
+-            }
++            final ca.spottedleaf.moonrise.common.list.ShortList tickList = ((ca.spottedleaf.moonrise.patches.block_counting.BlockCountingChunkSection)section).moonrise$getTickingBlockList();
+ 
+             for (int i = 0; i < tickSpeed; ++i) {
+                 final int tickingBlocks = tickList.size();
+-                final int index = random.nextInt() & ((16 * 16 * 16) - 1);
++                final int index = simpleRandom.nextInt() & ((16 * 16 * 16) - 1);
+ 
+                 if (index >= tickingBlocks) {
+                     // most of the time we fall here
+                     continue;
+                 }
+ 
+-                final long raw = tickList.getRaw(index);
+-                final int location = ca.spottedleaf.moonrise.common.list.IBlockDataList.getLocationFromRaw(raw);
+-                final int randomX = (location & 15);
+-                final int randomY = ((location >>> (4 + 4)) & 255);
+-                final int randomZ = ((location >>> 4) & 15);
+-                final BlockState state = states.get(randomX | (randomZ << 4) | (randomY << 8));
++                final int location = (int)tickList.getRaw(index) & 0xFFFF;
++                final BlockState state = states.get(location);
+ 
+                 // do not use a mutable pos, as some random tick implementations store the input without calling immutable()!
+-                final BlockPos pos = new BlockPos(randomX | offsetX, randomY | offsetY, randomZ | offsetZ);
++                final BlockPos pos = new BlockPos((location & 15) | offsetX, ((location >>> (4 + 4)) & 15) | offsetY, ((location >>> 4) & 15) | offsetZ);
+ 
+-                state.randomTick((ServerLevel)(Object)this, pos, random);
+-                if (tickFluids) {
++                state.randomTick((ServerLevel)(Object)this, pos, simpleRandom);
++                if (doubleTickFluids) {
+                     final FluidState fluidState = state.getFluidState();
+                     if (fluidState.isRandomlyTicking()) {
+-                        fluidState.randomTick((ServerLevel)(Object)this, pos, random);
++                        fluidState.randomTick((ServerLevel)(Object)this, pos, simpleRandom);
+                     }
+                 }
+             }
+@@ -856,6 +851,7 @@ public class ServerLevel extends Level implements WorldGenLevel, ca.spottedleaf.
+     // Paper end - optimise random ticking
+ 
+     public void tickChunk(LevelChunk chunk, int randomTickSpeed) {
++        final ca.spottedleaf.moonrise.common.util.SimpleRandom simpleRandom = this.simpleRandom; // Paper - optimise random ticking
+         ChunkPos chunkcoordintpair = chunk.getPos();
+         boolean flag = this.isRaining();
+         int j = chunkcoordintpair.getMinBlockX();
+@@ -863,7 +859,7 @@ public class ServerLevel extends Level implements WorldGenLevel, ca.spottedleaf.
+         ProfilerFiller gameprofilerfiller = this.getProfiler();
+ 
+         gameprofilerfiller.push("thunder");
+-        if (!this.paperConfig().environment.disableThunder && flag && this.isThundering() && this.spigotConfig.thunderChance > 0 && this.random.nextInt(this.spigotConfig.thunderChance) == 0) { // Spigot // Paper - Option to disable thunder
++        if (!this.paperConfig().environment.disableThunder && flag && this.isThundering() && this.spigotConfig.thunderChance > 0 && simpleRandom.nextInt(this.spigotConfig.thunderChance) == 0) { // Spigot // Paper - Option to disable thunder // Paper - optimise random ticking
+             BlockPos blockposition = this.findLightningTargetAround(this.getBlockRandomPos(j, 0, k, 15));
+ 
+             if (this.isRainingAt(blockposition)) {
+@@ -895,7 +891,7 @@ public class ServerLevel extends Level implements WorldGenLevel, ca.spottedleaf.
+ 
+         if (!this.paperConfig().environment.disableIceAndSnow) { // Paper - Option to disable ice and snow
+         for (int l = 0; l < randomTickSpeed; ++l) {
+-            if (this.random.nextInt(48) == 0) {
++            if (simpleRandom.nextInt(48) == 0) { // Paper - optimise random ticking
+                 this.tickPrecipitation(this.getBlockRandomPos(j, 0, k, 15));
+             }
+         }
+diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
+index 5e2c4969e77c669acbb4a13c07033cb267c3d586..f1371f3b9ea0cda0cf146d876828a6823632463c 100644
+--- a/src/main/java/net/minecraft/server/players/PlayerList.java
++++ b/src/main/java/net/minecraft/server/players/PlayerList.java
+@@ -1475,7 +1475,7 @@ public abstract class PlayerList {
+ 
+     public void setViewDistance(int viewDistance) {
+         this.viewDistance = viewDistance;
+-        this.broadcastAll(new ClientboundSetChunkCacheRadiusPacket(viewDistance));
++        //this.broadcastAll(new ClientboundSetChunkCacheRadiusPacket(viewDistance)); // Paper - rewrite chunk system
+         Iterator iterator = this.server.getAllLevels().iterator();
+ 
+         while (iterator.hasNext()) {
+diff --git a/src/main/java/net/minecraft/util/BitStorage.java b/src/main/java/net/minecraft/util/BitStorage.java
+index 19661e106612b8e4e152085fb398db7bd06acc23..e4e153cb8899e70273aa150b8ea26907cf68b15c 100644
+--- a/src/main/java/net/minecraft/util/BitStorage.java
++++ b/src/main/java/net/minecraft/util/BitStorage.java
+@@ -24,15 +24,15 @@ public interface BitStorage extends ca.spottedleaf.moonrise.patches.block_counti
+     // Paper start - block counting
+     // provide default impl in case mods implement this...
+     @Override
+-    public default it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap<it.unimi.dsi.fastutil.ints.IntArrayList> moonrise$countEntries() {
+-        final it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap<it.unimi.dsi.fastutil.ints.IntArrayList> ret = new it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap<>();
++    public default it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap<it.unimi.dsi.fastutil.shorts.ShortArrayList> moonrise$countEntries() {
++        final it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap<it.unimi.dsi.fastutil.shorts.ShortArrayList> ret = new it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap<>();
+ 
+         final int size = this.getSize();
+         for (int index = 0; index < size; ++index) {
+             final int paletteIdx = this.get(index);
+             ret.computeIfAbsent(paletteIdx, (final int key) -> {
+-                return new it.unimi.dsi.fastutil.ints.IntArrayList();
+-            }).add(index);
++                return new it.unimi.dsi.fastutil.shorts.ShortArrayList();
++            }).add((short)index);
+         }
+ 
+         return ret;
+diff --git a/src/main/java/net/minecraft/util/CrudeIncrementalIntIdentityHashBiMap.java b/src/main/java/net/minecraft/util/CrudeIncrementalIntIdentityHashBiMap.java
+index 61dee55417bc802e25b9ba2f271d32d8c12844a9..a8a260a3caaa8e5004069b833ecc8b17b2fc8db5 100644
+--- a/src/main/java/net/minecraft/util/CrudeIncrementalIntIdentityHashBiMap.java
++++ b/src/main/java/net/minecraft/util/CrudeIncrementalIntIdentityHashBiMap.java
+@@ -7,7 +7,7 @@ import java.util.Iterator;
+ import javax.annotation.Nullable;
+ import net.minecraft.core.IdMap;
+ 
+-public class CrudeIncrementalIntIdentityHashBiMap<K> implements IdMap<K> {
++public class CrudeIncrementalIntIdentityHashBiMap<K> implements IdMap<K>, ca.spottedleaf.moonrise.patches.fast_palette.FastPalette<K> { // Paper - optimise palette reads
+     private static final int NOT_FOUND = -1;
+     private static final Object EMPTY_SLOT = null;
+     private static final float LOADFACTOR = 0.8F;
+@@ -17,6 +17,16 @@ public class CrudeIncrementalIntIdentityHashBiMap<K> implements IdMap<K> {
+     private int nextId;
+     private int size;
+ 
++    // Paper start - optimise palette reads
++    private ca.spottedleaf.moonrise.patches.fast_palette.FastPaletteData<K> reference;
++
++    @Override
++    public final K[] moonrise$getRawPalette(final ca.spottedleaf.moonrise.patches.fast_palette.FastPaletteData<K> src) {
++        this.reference = src;
++        return this.byId;
++    }
++    // Paper end - optimise palette reads
++
+     private CrudeIncrementalIntIdentityHashBiMap(int size) {
+         this.keys = (K[])(new Object[size]);
+         this.values = new int[size];
+@@ -88,6 +98,12 @@ public class CrudeIncrementalIntIdentityHashBiMap<K> implements IdMap<K> {
+         this.byId = crudeIncrementalIntIdentityHashBiMap.byId;
+         this.nextId = crudeIncrementalIntIdentityHashBiMap.nextId;
+         this.size = crudeIncrementalIntIdentityHashBiMap.size;
++        // Paper start - optimise palette reads
++        final ca.spottedleaf.moonrise.patches.fast_palette.FastPaletteData<K> ref = this.reference;
++        if (ref != null) {
++            ref.moonrise$setPalette(this.byId);
++        }
++        // Paper end - optimise palette reads
+     }
+ 
+     public void addMapping(K value, int id) {
+diff --git a/src/main/java/net/minecraft/util/SimpleBitStorage.java b/src/main/java/net/minecraft/util/SimpleBitStorage.java
+index 8acf2f2491a8d9d13392c5e89b2bd5c9918285e1..d99ec470b4653beab630999a5b2c1a6428b20c38 100644
+--- a/src/main/java/net/minecraft/util/SimpleBitStorage.java
++++ b/src/main/java/net/minecraft/util/SimpleBitStorage.java
+@@ -208,6 +208,20 @@ public class SimpleBitStorage implements BitStorage {
+     private final int divideAdd; private final long divideAddUnsigned; // Paper - Perf: Optimize SimpleBitStorage
+     private final int divideShift;
+ 
++    // Paper start - optimise bitstorage read/write operations
++    private static final int[] BETTER_MAGIC = new int[33];
++    static {
++        // 20 bits of precision
++        // since index is always [0, 4095] (i.e 12 bits), multiplication by a magic value here (20 bits)
++        // fits exactly in an int and allows us to use integer arithmetic
++        for (int bits = 1; bits < BETTER_MAGIC.length; ++bits) {
++            BETTER_MAGIC[bits] = (int)ca.spottedleaf.concurrentutil.util.IntegerUtil.getUnsignedDivisorMagic(64L / bits, 20);
++        }
++    }
++    private final int magic;
++    private final int mulBits;
++    // Paper end - optimise bitstorage read/write operations
++
+     public SimpleBitStorage(int elementBits, int size, int[] data) {
+         this(elementBits, size);
+         int i = 0;
+@@ -261,6 +275,13 @@ public class SimpleBitStorage implements BitStorage {
+         } else {
+             this.data = new long[j];
+         }
++        // Paper start - optimise bitstorage read/write operations
++        this.magic = BETTER_MAGIC[this.bits];
++        this.mulBits = (64 / this.bits) * this.bits;
++        if (this.size > 4096) {
++            throw new IllegalStateException("Size > 4096 not supported");
++        }
++        // Paper end - optimise bitstorage read/write operations
+     }
+ 
+     private int cellIndex(int index) {
+@@ -273,31 +294,54 @@ public class SimpleBitStorage implements BitStorage {
+     public final int getAndSet(int index, int value) { // Paper - Perf: Optimize SimpleBitStorage
+         //Validate.inclusiveBetween(0L, (long)(this.size - 1), (long)index); // Paper - Perf: Optimize SimpleBitStorage
+         //Validate.inclusiveBetween(0L, this.mask, (long)value); // Paper - Perf: Optimize SimpleBitStorage
+-        int i = this.cellIndex(index);
+-        long l = this.data[i];
+-        int j = (index - i * this.valuesPerLong) * this.bits;
+-        int k = (int)(l >> j & this.mask);
+-        this.data[i] = l & ~(this.mask << j) | ((long)value & this.mask) << j;
+-        return k;
++        // Paper start - optimise bitstorage read/write operations
++        final int full = this.magic * index; // 20 bits of magic + 12 bits of index = barely int
++        final int divQ = full >>> 20;
++        final int divR = (full & 0xFFFFF) * this.mulBits >>> 20;
++
++        final long[] dataArray = this.data;
++
++        final long data = dataArray[divQ];
++        final long mask = this.mask;
++
++        final long write = data & ~(mask << divR) | ((long)value & mask) << divR;
++
++        dataArray[divQ] = write;
++
++        return (int)(data >>> divR & mask);
++        // Paper end - optimise bitstorage read/write operations
+     }
+ 
+     @Override
+     public final void set(int index, int value) { // Paper - Perf: Optimize SimpleBitStorage
+         //Validate.inclusiveBetween(0L, (long)(this.size - 1), (long)index); // Paper - Perf: Optimize SimpleBitStorage
+         //Validate.inclusiveBetween(0L, this.mask, (long)value); // Paper - Perf: Optimize SimpleBitStorage
+-        int i = this.cellIndex(index);
+-        long l = this.data[i];
+-        int j = (index - i * this.valuesPerLong) * this.bits;
+-        this.data[i] = l & ~(this.mask << j) | ((long)value & this.mask) << j;
++        // Paper start - optimise bitstorage read/write operations
++        final int full = this.magic * index; // 20 bits of magic + 12 bits of index = barely int
++        final int divQ = full >>> 20;
++        final int divR = (full & 0xFFFFF) * this.mulBits >>> 20;
++
++        final long[] dataArray = this.data;
++
++        final long data = dataArray[divQ];
++        final long mask = this.mask;
++
++        final long write = data & ~(mask << divR) | ((long)value & mask) << divR;
++
++        dataArray[divQ] = write;
++        // Paper end - optimise bitstorage read/write operations
+     }
+ 
+     @Override
+     public final int get(int index) { // Paper - Perf: Optimize SimpleBitStorage
+         //Validate.inclusiveBetween(0L, (long)(this.size - 1), (long)index); // Paper - Perf: Optimize SimpleBitStorage
+-        int i = this.cellIndex(index);
+-        long l = this.data[i];
+-        int j = (index - i * this.valuesPerLong) * this.bits;
+-        return (int)(l >> j & this.mask);
++        // Paper start - optimise bitstorage read/write operations
++        final int full = this.magic * index; // 20 bits of magic + 12 bits of index = barely int
++        final int divQ = full >>> 20;
++        final int divR = (full & 0xFFFFF) * this.mulBits >>> 20;
++
++        return (int)(this.data[divQ] >>> divR & this.mask);
++        // Paper end - optimise bitstorage read/write operations
+     }
+ 
+     @Override
+@@ -364,35 +408,62 @@ public class SimpleBitStorage implements BitStorage {
+ 
+     // Paper start - block counting
+     @Override
+-    public final it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap<it.unimi.dsi.fastutil.ints.IntArrayList> moonrise$countEntries() {
++    public final it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap<it.unimi.dsi.fastutil.shorts.ShortArrayList> moonrise$countEntries() {
+         final int valuesPerLong = this.valuesPerLong;
+         final int bits = this.bits;
+-        final long mask = this.mask;
++        final long mask = (1L << bits) - 1L;
+         final int size = this.size;
+ 
+-        // we may be backed by global palette, so limit bits for init capacity
+-        final it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap<it.unimi.dsi.fastutil.ints.IntArrayList> ret = new it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap<>(
+-            1 << Math.min(6, bits)
+-        );
+-
+-        int index = 0;
+-
+-        for (long value : this.data) {
+-            int li = 0;
+-            do {
+-                final int paletteIdx = (int)(value & mask);
+-                value >>= bits;
++        if (bits <= 6) {
++            final it.unimi.dsi.fastutil.shorts.ShortArrayList[] byId = new it.unimi.dsi.fastutil.shorts.ShortArrayList[1 << bits];
++            final it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap<it.unimi.dsi.fastutil.shorts.ShortArrayList> ret = new it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap<>(1 << bits);
++
++            int index = 0;
++
++            for (long value : this.data) {
++                int li = 0;
++                do {
++                    final int paletteIdx = (int)(value & mask);
++                    value >>= bits;
++                    ++li;
++
++                    final it.unimi.dsi.fastutil.shorts.ShortArrayList coords = byId[paletteIdx];
++                    if (coords != null) {
++                        coords.add((short)index++);
++                        continue;
++                    } else {
++                        final it.unimi.dsi.fastutil.shorts.ShortArrayList newCoords = new it.unimi.dsi.fastutil.shorts.ShortArrayList(64);
++                        byId[paletteIdx] = newCoords;
++                        newCoords.add((short)index++);
++                        ret.put(paletteIdx, newCoords);
++                        continue;
++                    }
++                } while (li < valuesPerLong && index < size);
++            }
+ 
+-                ret.computeIfAbsent(paletteIdx, (final int key) -> {
+-                    return new it.unimi.dsi.fastutil.ints.IntArrayList();
+-                }).add(index);
++            return ret;
++        } else {
++            final it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap<it.unimi.dsi.fastutil.shorts.ShortArrayList> ret = new it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap<>(
++                1 << 6
++            );
++
++            int index = 0;
++
++            for (long value : this.data) {
++                int li = 0;
++                do {
++                    final int paletteIdx = (int)(value & mask);
++                    value >>= bits;
++                    ++li;
++
++                    ret.computeIfAbsent(paletteIdx, (final int key) -> {
++                        return new it.unimi.dsi.fastutil.shorts.ShortArrayList(64);
++                    }).add((short)index++);
++                } while (li < valuesPerLong && index < size);
++            }
+ 
+-                ++li;
+-                ++index;
+-            } while (li < valuesPerLong && index < size);
++            return ret;
+         }
+-
+-        return ret;
+     }
+     // Paper end - block counting
+ 
+diff --git a/src/main/java/net/minecraft/util/ZeroBitStorage.java b/src/main/java/net/minecraft/util/ZeroBitStorage.java
+index 15c5164d0ef41a978c16ee317fa73e97f2480207..1f9c436a632e4f110be61cf76fcfc3b7eb80334e 100644
+--- a/src/main/java/net/minecraft/util/ZeroBitStorage.java
++++ b/src/main/java/net/minecraft/util/ZeroBitStorage.java
+@@ -65,17 +65,17 @@ public class ZeroBitStorage implements BitStorage {
+ 
+     // Paper start - block counting
+     @Override
+-    public final it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap<it.unimi.dsi.fastutil.ints.IntArrayList> moonrise$countEntries() {
++    public final it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap<it.unimi.dsi.fastutil.shorts.ShortArrayList> moonrise$countEntries() {
+         final int size = this.size;
+ 
+-        final int[] raw = new int[size];
++        final short[] raw = new short[size];
+         for (int i = 0; i < size; ++i) {
+-            raw[i] = i;
++            raw[i] = (short)i;
+         }
+ 
+-        final it.unimi.dsi.fastutil.ints.IntArrayList coordinates = it.unimi.dsi.fastutil.ints.IntArrayList.wrap(raw, size);
++        final it.unimi.dsi.fastutil.shorts.ShortArrayList coordinates = it.unimi.dsi.fastutil.shorts.ShortArrayList.wrap(raw, size);
+ 
+-        final it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap<it.unimi.dsi.fastutil.ints.IntArrayList> ret = new it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap<>(1);
++        final it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap<it.unimi.dsi.fastutil.shorts.ShortArrayList> ret = new it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap<>(1);
+         ret.put(0, coordinates);
+         return ret;
+     }
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index 4b54d0ea31062972e68ee8fafe3cfaf68f65a5cd..379456dd5c18ca627b9cf6a473fd0355e8d839ef 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
++++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -461,6 +461,7 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+     // Paper start - rewrite chunk system
+     private final boolean isHardColliding = this.moonrise$isHardCollidingUncached();
+     private net.minecraft.server.level.FullChunkStatus chunkStatus;
++    private ca.spottedleaf.moonrise.patches.chunk_system.level.chunk.ChunkData chunkData;
+     private int sectionX = Integer.MIN_VALUE;
+     private int sectionY = Integer.MIN_VALUE;
+     private int sectionZ = Integer.MIN_VALUE;
+@@ -481,6 +482,16 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+         this.chunkStatus = status;
+     }
+ 
++    @Override
++    public final ca.spottedleaf.moonrise.patches.chunk_system.level.chunk.ChunkData moonrise$getChunkData() {
++        return this.chunkData;
++    }
++
++    @Override
++    public final void moonrise$setChunkData(final ca.spottedleaf.moonrise.patches.chunk_system.level.chunk.ChunkData chunkData) {
++        this.chunkData = chunkData;
++    }
++
+     @Override
+     public final int moonrise$getSectionX() {
+         return this.sectionX;
+@@ -529,6 +540,54 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+         return this.getIndirectPassengersStream().anyMatch((entity) -> entity instanceof Player);
+     }
+     // Paper end - rewrite chunk system
++    // Paper start - optimise collisions
++    private static float[] calculateStepHeights(final AABB box, final List<VoxelShape> voxels, final List<AABB> aabbs, final float stepHeight,
++                                                final float collidedY) {
++        final FloatArraySet ret = new FloatArraySet();
++
++        for (int i = 0, len = voxels.size(); i < len; ++i) {
++            final VoxelShape shape = voxels.get(i);
++
++            final double[] yCoords = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)shape).moonrise$rootCoordinatesY();
++            final double yOffset = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)shape).moonrise$offsetY();
++
++            for (final double yUnoffset : yCoords) {
++                final double y = yUnoffset + yOffset;
++
++                final float step = (float)(y - box.minY);
++
++                if (step > stepHeight) {
++                    break;
++                }
++
++                if (step < 0.0f || !(step != collidedY)) {
++                    continue;
++                }
++
++                ret.add(step);
++            }
++        }
++
++        for (int i = 0, len = aabbs.size(); i < len; ++i) {
++            final AABB shape = aabbs.get(i);
++
++            final float step1 = (float)(shape.minY - box.minY);
++            final float step2 = (float)(shape.maxY - box.minY);
++
++            if (!(step1 < 0.0f) && step1 != collidedY && !(step1 > stepHeight)) {
++                ret.add(step1);
++            }
++
++            if (!(step2 < 0.0f) && step2 != collidedY && !(step2 > stepHeight)) {
++                ret.add(step2);
++            }
++        }
++
++        final float[] steps = ret.toFloatArray();
++        FloatArrays.unstableSort(steps);
++        return steps;
++    }
++    // Paper end - optimise collisions
+     // Paper start - optimise entity tracker
+     private net.minecraft.server.level.ChunkMap.TrackedEntity trackedEntity;
+ 
+@@ -1465,73 +1524,67 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+             return movement;
+         }
+ 
+-        final Level world = this.level;
+-        final AABB currBoundingBox = this.getBoundingBox();
+-
+-        if (ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.isEmpty(currBoundingBox)) {
+-            return movement;
+-        }
++        final AABB currentBox = this.getBoundingBox();
+ 
+-        final List<AABB> potentialCollisionsBB = new ArrayList<>();
+         final List<VoxelShape> potentialCollisionsVoxel = new ArrayList<>();
+-        final double stepHeight = (double)this.maxUpStep();
+-        final AABB collisionBox;
+-        final boolean onGround = this.onGround;
++        final List<AABB> potentialCollisionsBB = new ArrayList<>();
+ 
++        final AABB initialCollisionBox;
+         if (xZero & zZero) {
+-            if (movement.y > 0.0) {
+-                collisionBox = ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.cutUpwards(currBoundingBox, movement.y);
+-            } else {
+-                collisionBox = ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.cutDownwards(currBoundingBox, movement.y);
+-            }
++            // note: xZero & zZero -> collision on x/z == 0 -> no step height calculation
++            // this specifically optimises entities standing still
++            initialCollisionBox = movement.y < 0.0 ?
++                ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.cutDownwards(currentBox, movement.y) : ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.cutUpwards(currentBox, movement.y);
+         } else {
+-            // note: xZero == false or zZero == false
+-            if (stepHeight > 0.0 && (onGround || (movement.y < 0.0))) {
+-                // don't bother getting the collisions if we don't need them.
+-                if (movement.y <= 0.0) {
+-                    collisionBox = ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.expandUpwards(currBoundingBox.expandTowards(movement.x, movement.y, movement.z), stepHeight);
+-                } else {
+-                    collisionBox = currBoundingBox.expandTowards(movement.x, Math.max(stepHeight, movement.y), movement.z);
+-                }
+-            } else {
+-                collisionBox = currBoundingBox.expandTowards(movement.x, movement.y, movement.z);
+-            }
++            initialCollisionBox = currentBox.expandTowards(movement);
+         }
+ 
+-        ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.getCollisions(
+-            world, (Entity)(Object)this, collisionBox, potentialCollisionsVoxel, potentialCollisionsBB,
+-            ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.COLLISION_FLAG_CHECK_BORDER,
+-            null, null
++        final List<AABB> entityAABBs = new ArrayList<>();
++        ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.getEntityHardCollisions(
++            this.level, (Entity)(Object)this, initialCollisionBox, entityAABBs, 0, null
+         );
+ 
+-        if (potentialCollisionsVoxel.isEmpty() && potentialCollisionsBB.isEmpty()) {
+-            return movement;
+-        }
++        ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.getCollisionsForBlocksOrWorldBorder(
++            this.level, (Entity)(Object)this, initialCollisionBox, potentialCollisionsVoxel, potentialCollisionsBB,
++            ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.COLLISION_FLAG_CHECK_BORDER, null
++        );
++        potentialCollisionsBB.addAll(entityAABBs);
++        final Vec3 collided = ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.performCollisions(movement, currentBox, potentialCollisionsVoxel, potentialCollisionsBB);
+ 
+-        final Vec3 limitedMoveVector = ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.performCollisions(movement, currBoundingBox, potentialCollisionsVoxel, potentialCollisionsBB);
++        final boolean collidedX = collided.x != movement.x;
++        final boolean collidedY = collided.y != movement.y;
++        final boolean collidedZ = collided.z != movement.z;
+ 
+-        if (stepHeight > 0.0
+-            && (onGround || (limitedMoveVector.y != movement.y && movement.y < 0.0))
+-            && (limitedMoveVector.x != movement.x || limitedMoveVector.z != movement.z)) {
+-            Vec3 vec3d2 = ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.performCollisions(new Vec3(movement.x, stepHeight, movement.z), currBoundingBox, potentialCollisionsVoxel, potentialCollisionsBB);
+-            final Vec3 vec3d3 = ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.performCollisions(new Vec3(0.0, stepHeight, 0.0), currBoundingBox.expandTowards(movement.x, 0.0, movement.z), potentialCollisionsVoxel, potentialCollisionsBB);
++        final boolean collidedDownwards = collidedY && movement.y < 0.0;
+ 
+-            if (vec3d3.y < stepHeight) {
+-                final Vec3 vec3d4 = ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.performCollisions(new Vec3(movement.x, 0.0D, movement.z), currBoundingBox.move(vec3d3), potentialCollisionsVoxel, potentialCollisionsBB).add(vec3d3);
++        final double stepHeight;
+ 
+-                if (vec3d4.horizontalDistanceSqr() > vec3d2.horizontalDistanceSqr()) {
+-                    vec3d2 = vec3d4;
+-                }
+-            }
++        if ((!collidedDownwards && !this.onGround) || (!collidedX && !collidedZ) || (stepHeight = (double)this.maxUpStep()) <= 0.0) {
++            return collided;
++        }
+ 
+-            if (vec3d2.horizontalDistanceSqr() > limitedMoveVector.horizontalDistanceSqr()) {
+-                return vec3d2.add(ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.performCollisions(new Vec3(0.0D, -vec3d2.y + movement.y, 0.0D), currBoundingBox.move(vec3d2), potentialCollisionsVoxel, potentialCollisionsBB));
+-            }
++        final AABB collidedYBox = collidedDownwards ? currentBox.move(0.0, collided.y, 0.0) : currentBox;
++        AABB stepRetrievalBox = collidedYBox.expandTowards(movement.x, stepHeight, movement.z);
++        if (!collidedDownwards) {
++            stepRetrievalBox = stepRetrievalBox.expandTowards(0.0, (double)-1.0E-5F, 0.0);
++        }
+ 
+-            return limitedMoveVector;
+-        } else {
+-            return limitedMoveVector;
++        final List<VoxelShape> stepVoxels = new ArrayList<>();
++        final List<AABB> stepAABBs = entityAABBs;
++
++        ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.getCollisionsForBlocksOrWorldBorder(
++            this.level, (Entity)(Object)this, stepRetrievalBox, stepVoxels, stepAABBs,
++            ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.COLLISION_FLAG_CHECK_BORDER, null
++        );
++
++        for (final float step : calculateStepHeights(collidedYBox, stepVoxels, stepAABBs, (float)stepHeight, (float)collided.y)) {
++            final Vec3 stepResult = ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.performCollisions(new Vec3(movement.x, (double)step, movement.z), collidedYBox, stepVoxels, stepAABBs);
++            if (stepResult.horizontalDistanceSqr() > collided.horizontalDistanceSqr()) {
++                return stepResult.add(0.0, collidedYBox.minY - currentBox.minY, 0.0);
++            }
+         }
++
++        return collided;
+         // Paper end - optimise collisions
+     }
+ 
+@@ -2853,64 +2906,99 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+             return false;
+         }
+ 
+-        final float reducedWith = this.dimensions.width() * 0.8F;
+-        final AABB box = AABB.ofSize(this.getEyePosition(), reducedWith, 1.0E-6D, reducedWith);
++        final double reducedWith = (double)(this.dimensions.width() * 0.8F);
++        final AABB boundingBox = AABB.ofSize(this.getEyePosition(), reducedWith, 1.0E-6D, reducedWith);
++        final Level world = this.level;
+ 
+-        if (ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.isEmpty(box)) {
++        if (ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.isEmpty(boundingBox)) {
+             return false;
+         }
+ 
+-        final BlockPos.MutableBlockPos tempPos = new BlockPos.MutableBlockPos();
++        final int minBlockX = Mth.floor(boundingBox.minX);
++        final int minBlockY = Mth.floor(boundingBox.minY);
++        final int minBlockZ = Mth.floor(boundingBox.minZ);
++
++        final int maxBlockX = Mth.floor(boundingBox.maxX);
++        final int maxBlockY = Mth.floor(boundingBox.maxY);
++        final int maxBlockZ = Mth.floor(boundingBox.maxZ);
+ 
+-        final int minX = Mth.floor(box.minX);
+-        final int minY = Mth.floor(box.minY);
+-        final int minZ = Mth.floor(box.minZ);
+-        final int maxX = Mth.floor(box.maxX);
+-        final int maxY = Mth.floor(box.maxY);
+-        final int maxZ = Mth.floor(box.maxZ);
++        final int minChunkX = minBlockX >> 4;
++        final int minChunkY = minBlockY >> 4;
++        final int minChunkZ = minBlockZ >> 4;
+ 
+-        final net.minecraft.world.level.chunk.ChunkSource chunkProvider = this.level.getChunkSource();
++        final int maxChunkX = maxBlockX >> 4;
++        final int maxChunkY = maxBlockY >> 4;
++        final int maxChunkZ = maxBlockZ >> 4;
+ 
+-        long lastChunkKey = ChunkPos.INVALID_CHUNK_POS;
+-        net.minecraft.world.level.chunk.LevelChunk lastChunk = null;
+-        for (int fz = minZ; fz <= maxZ; ++fz) {
+-            tempPos.setZ(fz);
+-            for (int fx = minX; fx <= maxX; ++fx) {
+-                final int newChunkX = fx >> 4;
+-                final int newChunkZ = fz >> 4;
+-                final net.minecraft.world.level.chunk.LevelChunk chunk = lastChunkKey == (lastChunkKey = ca.spottedleaf.moonrise.common.util.CoordinateUtils.getChunkKey(newChunkX, newChunkZ)) ?
+-                    lastChunk : (lastChunk = (net.minecraft.world.level.chunk.LevelChunk)chunkProvider.getChunk(newChunkX, newChunkZ, net.minecraft.world.level.chunk.status.ChunkStatus.FULL, true));
+-                tempPos.setX(fx);
+-                for (int fy = minY; fy <= maxY; ++fy) {
+-                    tempPos.setY(fy);
++        final int minSection = ca.spottedleaf.moonrise.common.util.WorldUtil.getMinSection(world);
++        final net.minecraft.world.level.chunk.ChunkSource chunkSource = world.getChunkSource();
++        final BlockPos.MutableBlockPos mutablePos = new BlockPos.MutableBlockPos();
+ 
+-                    final BlockState state = chunk.getBlockState(tempPos);
++        for (int currChunkZ = minChunkZ; currChunkZ <= maxChunkZ; ++currChunkZ) {
++            for (int currChunkX = minChunkX; currChunkX <= maxChunkX; ++currChunkX) {
++                final net.minecraft.world.level.chunk.LevelChunkSection[] sections = chunkSource.getChunk(currChunkX, currChunkZ, net.minecraft.world.level.chunk.status.ChunkStatus.FULL, true).getSections();
+ 
+-                    if (((ca.spottedleaf.moonrise.patches.collisions.block.CollisionBlockState)state).moonrise$emptyCollisionShape() || !state.isSuffocating(this.level, tempPos)) {
++                for (int currChunkY = minChunkY; currChunkY <= maxChunkY; ++currChunkY) {
++                    final int sectionIdx = currChunkY - minSection;
++                    if (sectionIdx < 0 || sectionIdx >= sections.length) {
+                         continue;
+                     }
+-
+-                    // Yes, it does not use the Entity context stuff.
+-                    final VoxelShape collisionShape = state.getCollisionShape(this.level, tempPos);
+-
+-                    if (collisionShape.isEmpty()) {
++                    final net.minecraft.world.level.chunk.LevelChunkSection section = sections[sectionIdx];
++                    if (section.hasOnlyAir()) {
++                        // empty
+                         continue;
+                     }
+ 
+-                    final AABB toCollide = box.move(-(double)fx, -(double)fy, -(double)fz);
++                    final net.minecraft.world.level.chunk.PalettedContainer<net.minecraft.world.level.block.state.BlockState> blocks = section.states;
++
++                    final int minXIterate = currChunkX == minChunkX ? (minBlockX & 15) : 0;
++                    final int maxXIterate = currChunkX == maxChunkX ? (maxBlockX & 15) : 15;
++                    final int minZIterate = currChunkZ == minChunkZ ? (minBlockZ & 15) : 0;
++                    final int maxZIterate = currChunkZ == maxChunkZ ? (maxBlockZ & 15) : 15;
++                    final int minYIterate = currChunkY == minChunkY ? (minBlockY & 15) : 0;
++                    final int maxYIterate = currChunkY == maxChunkY ? (maxBlockY & 15) : 15;
++
++                    for (int currY = minYIterate; currY <= maxYIterate; ++currY) {
++                        final int blockY = currY | (currChunkY << 4);
++                        mutablePos.setY(blockY);
++                        for (int currZ = minZIterate; currZ <= maxZIterate; ++currZ) {
++                            final int blockZ = currZ | (currChunkZ << 4);
++                            mutablePos.setZ(blockZ);
++                            for (int currX = minXIterate; currX <= maxXIterate; ++currX) {
++                                final int blockX = currX | (currChunkX << 4);
++                                mutablePos.setX(blockX);
++
++                                final BlockState blockState = blocks.get((currX) | (currZ << 4) | ((currY) << 8));
++
++                                if (((ca.spottedleaf.moonrise.patches.collisions.block.CollisionBlockState)blockState).moonrise$emptyCollisionShape()
++                                    || !blockState.isSuffocating(world, mutablePos)) {
++                                    continue;
++                                }
+ 
+-                    final AABB singleAABB = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)collisionShape).moonrise$getSingleAABBRepresentation();
+-                    if (singleAABB != null) {
+-                        if (ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.voxelShapeIntersect(singleAABB, toCollide)) {
+-                            return true;
+-                        }
+-                        continue;
+-                    }
++                                // Yes, it does not use the Entity context stuff.
++                                final VoxelShape collisionShape = blockState.getCollisionShape(world, mutablePos);
++
++                                if (collisionShape.isEmpty()) {
++                                    continue;
++                                }
+ 
+-                    if (ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.voxelShapeIntersectNoEmpty(collisionShape, toCollide)) {
+-                        return true;
++                                final AABB toCollide = boundingBox.move(-(double)blockX, -(double)blockY, -(double)blockZ);
++
++                                final AABB singleAABB = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)collisionShape).moonrise$getSingleAABBRepresentation();
++                                if (singleAABB != null) {
++                                    if (ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.voxelShapeIntersect(singleAABB, toCollide)) {
++                                        return true;
++                                    }
++                                    continue;
++                                }
++
++                                if (ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.voxelShapeIntersectNoEmpty(collisionShape, toCollide)) {
++                                    return true;
++                                }
++                                continue;
++                            }
++                        }
+                     }
+-                    continue;
+                 }
+             }
+         }
+@@ -4451,82 +4539,136 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+         return Mth.lerp(delta, this.yRotO, this.yRot);
+     }
+ 
+-    public boolean updateFluidHeightAndDoFluidPushing(TagKey<Fluid> tag, double speed) {
++    // Paper start - optimise collisions
++    public boolean updateFluidHeightAndDoFluidPushing(final TagKey<Fluid> fluid, final double flowScale) {
+         if (this.touchingUnloadedChunk()) {
+             return false;
+-        } else {
+-            AABB axisalignedbb = this.getBoundingBox().deflate(0.001D);
+-            int i = Mth.floor(axisalignedbb.minX);
+-            int j = Mth.ceil(axisalignedbb.maxX);
+-            int k = Mth.floor(axisalignedbb.minY);
+-            int l = Mth.ceil(axisalignedbb.maxY);
+-            int i1 = Mth.floor(axisalignedbb.minZ);
+-            int j1 = Mth.ceil(axisalignedbb.maxZ);
+-            double d1 = 0.0D;
+-            boolean flag = this.isPushedByFluid();
+-            boolean flag1 = false;
+-            Vec3 vec3d = Vec3.ZERO;
+-            int k1 = 0;
+-            BlockPos.MutableBlockPos blockposition_mutableblockposition = new BlockPos.MutableBlockPos();
++        }
+ 
+-            for (int l1 = i; l1 < j; ++l1) {
+-                for (int i2 = k; i2 < l; ++i2) {
+-                    for (int j2 = i1; j2 < j1; ++j2) {
+-                        blockposition_mutableblockposition.set(l1, i2, j2);
+-                        FluidState fluid = this.level().getFluidState(blockposition_mutableblockposition);
++        final AABB boundingBox = this.getBoundingBox().deflate(1.0E-3);
+ 
+-                        if (fluid.is(tag)) {
+-                            double d2 = (double) ((float) i2 + fluid.getHeight(this.level(), blockposition_mutableblockposition));
++        final Level world = this.level;
++        final int minSection = ca.spottedleaf.moonrise.common.util.WorldUtil.getMinSection(world);
+ 
+-                            if (d2 >= axisalignedbb.minY) {
+-                                flag1 = true;
+-                                d1 = Math.max(d2 - axisalignedbb.minY, d1);
+-                                if (flag) {
+-                                    Vec3 vec3d1 = fluid.getFlow(this.level(), blockposition_mutableblockposition);
++        final int minBlockX = Mth.floor(boundingBox.minX);
++        final int minBlockY = Math.max((minSection << 4), Mth.floor(boundingBox.minY));
++        final int minBlockZ = Mth.floor(boundingBox.minZ);
+ 
+-                                    if (d1 < 0.4D) {
+-                                        vec3d1 = vec3d1.scale(d1);
+-                                    }
++        // note: bounds are exclusive in Vanilla, so we subtract 1 - our loop expects bounds to be inclusive
++        final int maxBlockX = Mth.ceil(boundingBox.maxX) - 1;
++        final int maxBlockY = Math.min((ca.spottedleaf.moonrise.common.util.WorldUtil.getMaxSection(world) << 4) | 15, Mth.ceil(boundingBox.maxY) - 1);
++        final int maxBlockZ = Mth.ceil(boundingBox.maxZ) - 1;
++
++        final boolean isPushable = this.isPushedByFluid();
++        final BlockPos.MutableBlockPos mutablePos = new BlockPos.MutableBlockPos();
+ 
+-                                    vec3d = vec3d.add(vec3d1);
+-                                    ++k1;
++        Vec3 pushVector = Vec3.ZERO;
++        double totalPushes = 0.0;
++        double maxHeightDiff = 0.0;
++        boolean inFluid = false;
++
++        final int minChunkX = minBlockX >> 4;
++        final int maxChunkX = maxBlockX >> 4;
++
++        final int minChunkY = minBlockY >> 4;
++        final int maxChunkY = maxBlockY >> 4;
++
++        final int minChunkZ = minBlockZ >> 4;
++        final int maxChunkZ = maxBlockZ >> 4;
++
++        final net.minecraft.world.level.chunk.ChunkSource chunkSource = world.getChunkSource();
++
++        for (int currChunkZ = minChunkZ; currChunkZ <= maxChunkZ; ++currChunkZ) {
++            for (int currChunkX = minChunkX; currChunkX <= maxChunkX; ++currChunkX) {
++                final net.minecraft.world.level.chunk.LevelChunkSection[] sections = chunkSource.getChunk(currChunkX, currChunkZ, net.minecraft.world.level.chunk.status.ChunkStatus.FULL, false).getSections();
++
++                // bound y
++                for (int currChunkY = minChunkY; currChunkY <= maxChunkY; ++currChunkY) {
++                    final int sectionIdx = currChunkY - minSection;
++                    if (sectionIdx < 0 || sectionIdx >= sections.length) {
++                        continue;
++                    }
++                    final net.minecraft.world.level.chunk.LevelChunkSection section = sections[sectionIdx];
++                    if (section.hasOnlyAir()) {
++                        // empty
++                        continue;
++                    }
++
++                    final net.minecraft.world.level.chunk.PalettedContainer<net.minecraft.world.level.block.state.BlockState> blocks = section.states;
++
++                    final int minXIterate = currChunkX == minChunkX ? (minBlockX & 15) : 0;
++                    final int maxXIterate = currChunkX == maxChunkX ? (maxBlockX & 15) : 15;
++                    final int minZIterate = currChunkZ == minChunkZ ? (minBlockZ & 15) : 0;
++                    final int maxZIterate = currChunkZ == maxChunkZ ? (maxBlockZ & 15) : 15;
++                    final int minYIterate = currChunkY == minChunkY ? (minBlockY & 15) : 0;
++                    final int maxYIterate = currChunkY == maxChunkY ? (maxBlockY & 15) : 15;
++
++                    for (int currY = minYIterate; currY <= maxYIterate; ++currY) {
++                        for (int currZ = minZIterate; currZ <= maxZIterate; ++currZ) {
++                            for (int currX = minXIterate; currX <= maxXIterate; ++currX) {
++                                final FluidState fluidState = blocks.get((currX) | (currZ << 4) | ((currY) << 8)).getFluidState();
++
++                                if (fluidState.isEmpty() || !fluidState.is(fluid)) {
++                                    continue;
+                                 }
+-                                // CraftBukkit start - store last lava contact location
+-                                if (tag == FluidTags.LAVA) {
+-                                    this.lastLavaContact = blockposition_mutableblockposition.immutable();
++
++                                mutablePos.set(currX | (currChunkX << 4), currY | (currChunkY << 4), currZ | (currChunkZ << 4));
++
++                                final double height = (double)((float)mutablePos.getY() + fluidState.getHeight(world, mutablePos));
++                                final double diff = height - boundingBox.minY;
++
++                                if (diff < 0.0) {
++                                    continue;
++                                }
++
++                                inFluid = true;
++                                maxHeightDiff = Math.max(maxHeightDiff, diff);
++
++                                if (!isPushable) {
++                                    continue;
++                                }
++
++                                ++totalPushes;
++
++                                final Vec3 flow = fluidState.getFlow(world, mutablePos);
++
++                                if (diff < 0.4) {
++                                    pushVector = pushVector.add(flow.scale(diff));
++                                } else {
++                                    pushVector = pushVector.add(flow);
+                                 }
+-                                // CraftBukkit end
+                             }
+                         }
+                     }
+                 }
+             }
++        }
+ 
+-            if (vec3d.length() > 0.0D) {
+-                if (k1 > 0) {
+-                    vec3d = vec3d.scale(1.0D / (double) k1);
+-                }
++        this.fluidHeight.put(fluid, maxHeightDiff);
+ 
+-                if (!(this instanceof Player)) {
+-                    vec3d = vec3d.normalize();
+-                }
++        if (pushVector.lengthSqr() == 0.0) {
++            return inFluid;
++        }
+ 
+-                Vec3 vec3d2 = this.getDeltaMovement();
++        // note: totalPushes != 0 as pushVector != 0
++        pushVector = pushVector.scale(1.0 / totalPushes);
++        final Vec3 currMovement = this.getDeltaMovement();
+ 
+-                vec3d = vec3d.scale(speed);
+-                double d3 = 0.003D;
++        if (!((Entity)(Object)this instanceof Player)) {
++            pushVector = pushVector.normalize();
++        }
+ 
+-                if (Math.abs(vec3d2.x) < 0.003D && Math.abs(vec3d2.z) < 0.003D && vec3d.length() < 0.0045000000000000005D) {
+-                    vec3d = vec3d.normalize().scale(0.0045000000000000005D);
+-                }
++        pushVector = pushVector.scale(flowScale);
++        if (Math.abs(currMovement.x) < 0.003 && Math.abs(currMovement.z) < 0.003 && pushVector.length() < 0.0045000000000000005) {
++            pushVector = pushVector.normalize().scale(0.0045000000000000005);
++        }
+ 
+-                this.setDeltaMovement(this.getDeltaMovement().add(vec3d));
+-            }
++        this.setDeltaMovement(currMovement.add(pushVector));
+ 
+-            this.fluidHeight.put(tag, d1);
+-            return flag1;
+-        }
++        // note: inFluid = true here as pushVector != 0
++        return true;
+     }
++    // Paper end - optimise collisions
+ 
+     public boolean touchingUnloadedChunk() {
+         AABB axisalignedbb = this.getBoundingBox().inflate(1.0D);
+diff --git a/src/main/java/net/minecraft/world/entity/ai/village/poi/PoiManager.java b/src/main/java/net/minecraft/world/entity/ai/village/poi/PoiManager.java
+index a908bf1dc5e821dcf6981a8c21076fb0bdc6516d..42642b49a4ed6d06f52e4076dfb745b32a964a34 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/village/poi/PoiManager.java
++++ b/src/main/java/net/minecraft/world/entity/ai/village/poi/PoiManager.java
+@@ -73,8 +73,7 @@ public class PoiManager extends SectionStorage<PoiSection> implements ca.spotted
+ 
+         ca.spottedleaf.moonrise.common.util.TickThread.ensureTickThread(this.world, chunkX, chunkZ, "Accessing poi chunk off-main");
+ 
+-        final ca.spottedleaf.moonrise.patches.chunk_system.scheduling.ChunkHolderManager manager = ((ca.spottedleaf.moonrise.patches.chunk_system.level.ChunkSystemServerLevel)this.world).moonrise$getChunkTaskScheduler().chunkHolderManager;
+-        final ca.spottedleaf.moonrise.patches.chunk_system.level.poi.PoiChunk ret = manager.getPoiChunkIfLoaded(chunkX, chunkZ, true);
++        final ca.spottedleaf.moonrise.patches.chunk_system.level.poi.PoiChunk ret = ((ca.spottedleaf.moonrise.patches.chunk_system.level.ChunkSystemServerLevel)this.world).moonrise$getChunkTaskScheduler().chunkHolderManager.getPoiChunkIfLoaded(chunkX, chunkZ, true);
+ 
+         return ret == null ? Optional.empty() : ret.getSectionForVanilla(chunkY);
+     }
+@@ -128,9 +127,13 @@ public class PoiManager extends SectionStorage<PoiSection> implements ca.spotted
+     public final void moonrise$onUnload(final long coordinate) { // Paper - rewrite chunk system
+         final int chunkX = ca.spottedleaf.moonrise.common.util.CoordinateUtils.getChunkX(coordinate);
+         final int chunkZ = ca.spottedleaf.moonrise.common.util.CoordinateUtils.getChunkZ(coordinate);
++
++        final int minY = ca.spottedleaf.moonrise.common.util.WorldUtil.getMinSection(this.world);
++        final int maxY = ca.spottedleaf.moonrise.common.util.WorldUtil.getMaxSection(this.world);
++
+         ca.spottedleaf.moonrise.common.util.TickThread.ensureTickThread(this.world, chunkX, chunkZ, "Unloading poi chunk off-main");
+-        for (int section = this.levelHeightAccessor.getMinSection(); section < this.levelHeightAccessor.getMaxSection(); ++section) {
+-            final long sectionPos = SectionPos.asLong(chunkX, section, chunkZ);
++        for (int sectionY = minY; sectionY <= maxY; ++sectionY) {
++            final long sectionPos = SectionPos.asLong(chunkX, sectionY, chunkZ);
+             this.updateDistanceTracking(sectionPos);
+         }
+     }
+@@ -139,8 +142,12 @@ public class PoiManager extends SectionStorage<PoiSection> implements ca.spotted
+     public final void moonrise$loadInPoiChunk(final ca.spottedleaf.moonrise.patches.chunk_system.level.poi.PoiChunk poiChunk) {
+         final int chunkX = poiChunk.chunkX;
+         final int chunkZ = poiChunk.chunkZ;
++
++        final int minY = ca.spottedleaf.moonrise.common.util.WorldUtil.getMinSection(this.world);
++        final int maxY = ca.spottedleaf.moonrise.common.util.WorldUtil.getMaxSection(this.world);
++
+         ca.spottedleaf.moonrise.common.util.TickThread.ensureTickThread(this.world, chunkX, chunkZ, "Loading poi chunk off-main");
+-        for (int sectionY = this.levelHeightAccessor.getMinSection(); sectionY < this.levelHeightAccessor.getMaxSection(); ++sectionY) {
++        for (int sectionY = minY; sectionY <= maxY; ++sectionY) {
+             final PoiSection section = poiChunk.getSection(sectionY);
+             if (section != null && !((ca.spottedleaf.moonrise.patches.chunk_system.level.poi.ChunkSystemPoiSection)section).moonrise$isEmpty()) {
+                 this.onSectionLoad(SectionPos.asLong(chunkX, sectionY, chunkZ));
+@@ -166,22 +173,15 @@ public class PoiManager extends SectionStorage<PoiSection> implements ca.spotted
+ 
+     @Override
+     public final net.minecraft.nbt.CompoundTag moonrise$read(final int chunkX, final int chunkZ) throws java.io.IOException {
+-        if (!ca.spottedleaf.moonrise.patches.chunk_system.io.RegionFileIOThread.isRegionFileThread()) {
+-            return ca.spottedleaf.moonrise.patches.chunk_system.io.RegionFileIOThread.loadData(
+-                this.world, chunkX, chunkZ, ca.spottedleaf.moonrise.patches.chunk_system.io.RegionFileIOThread.RegionFileType.POI_DATA,
+-                ca.spottedleaf.moonrise.patches.chunk_system.io.RegionFileIOThread.getIOBlockingPriorityForCurrentThread()
+-            );
+-        }
+-        return this.moonrise$getRegionStorage().read(new ChunkPos(chunkX, chunkZ));
++        return ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO.loadData(
++            this.world, chunkX, chunkZ, ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO.RegionFileType.POI_DATA,
++            ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO.getIOBlockingPriorityForCurrentThread()
++        );
+     }
+ 
+     @Override
+     public final void moonrise$write(final int chunkX, final int chunkZ, final net.minecraft.nbt.CompoundTag data) throws java.io.IOException {
+-        if (!ca.spottedleaf.moonrise.patches.chunk_system.io.RegionFileIOThread.isRegionFileThread()) {
+-            ca.spottedleaf.moonrise.patches.chunk_system.io.RegionFileIOThread.scheduleSave(this.world, chunkX, chunkZ, data, ca.spottedleaf.moonrise.patches.chunk_system.io.RegionFileIOThread.RegionFileType.POI_DATA);
+-            return;
+-        }
+-        this.moonrise$getRegionStorage().write(new ChunkPos(chunkX, chunkZ), data);
++        ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO.scheduleSave(this.world, chunkX, chunkZ, data, ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO.RegionFileType.POI_DATA);
+     }
+     // Paper end - rewrite chunk system
+ 
+@@ -359,8 +359,10 @@ public class PoiManager extends SectionStorage<PoiSection> implements ca.spotted
+     }
+ 
+     public int sectionsToVillage(SectionPos pos) {
+-        this.villageDistanceTracker.propagateUpdates(); // Paper - rewrite chunk system
+-        return convertBetweenLevels(this.villageDistanceTracker.getLevel(ca.spottedleaf.moonrise.common.util.CoordinateUtils.getChunkSectionKey(pos))); // Paper - rewrite chunk system
++        // Paper start - rewrite chunk system
++        this.villageDistanceTracker.propagateUpdates();
++        return convertBetweenLevels(this.villageDistanceTracker.getLevel(ca.spottedleaf.moonrise.common.util.CoordinateUtils.getChunkSectionKey(pos)));
++        // Paper end - rewrite chunk system
+     }
+ 
+     boolean isVillageCenter(long pos) {
+diff --git a/src/main/java/net/minecraft/world/entity/ai/village/poi/PoiSection.java b/src/main/java/net/minecraft/world/entity/ai/village/poi/PoiSection.java
+index 11e895d837794d79a76303b912092096bd7d07a8..f1458b0153f6a93875f2e439759324985fa13556 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/village/poi/PoiSection.java
++++ b/src/main/java/net/minecraft/world/entity/ai/village/poi/PoiSection.java
+@@ -43,7 +43,7 @@ public class PoiSection implements ca.spottedleaf.moonrise.patches.chunk_system.
+     }
+ 
+     // Paper start - rewrite chunk system
+-    private final Optional<PoiSection> noAllocOptional = Optional.of((PoiSection)(Object)this);;
++    private final Optional<PoiSection> noAllocOptional = Optional.of((PoiSection)(Object)this);
+ 
+     @Override
+     public final boolean moonrise$isEmpty() {
+diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
+index 507671476c3d2d92a2fdb05be24443af27d26dcf..41ecc30c1e38bf84655464d539ced43549b35d20 100644
+--- a/src/main/java/net/minecraft/world/level/Level.java
++++ b/src/main/java/net/minecraft/world/level/Level.java
+@@ -280,26 +280,13 @@ public abstract class Level implements LevelAccessor, AutoCloseable, ca.spottedl
+     }
+     // Paper end - rewrite chunk system
+     // Paper start - optimise collisions
+-    private final int minSection;
+-    private final int maxSection;
+-
+-    @Override
+-    public final int moonrise$getMinSection() {
+-        return this.minSection;
+-    }
+-
+-    @Override
+-    public final int moonrise$getMaxSection() {
+-        return this.maxSection;
+-    }
+-
+     /**
+      * Route to faster lookup.
+      * See {@link EntityGetter#isUnobstructed(Entity, VoxelShape)} for expected behavior
+      * @author Spottedleaf
+      */
+     @Override
+-    public final boolean isUnobstructed(final Entity entity) {
++    public boolean isUnobstructed(final Entity entity) {
+         final AABB boundingBox = entity.getBoundingBox();
+         if (ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.isEmpty(boundingBox)) {
+             return false;
+@@ -329,7 +316,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable, ca.spottedl
+         final Vec3 to = clipContext.getTo();
+         final Vec3 from = clipContext.getFrom();
+ 
+-        return net.minecraft.world.phys.BlockHitResult.miss(to, Direction.getNearest(from.x - to.x, from.y - to.y, from.z - to.z), BlockPos.containing(to.x, to.y, to.z));
++        return net.minecraft.world.phys.BlockHitResult.miss(to, Direction.getApproximateNearest(from.x - to.x, from.y - to.y, from.z - to.z), BlockPos.containing(to.x, to.y, to.z));
+     }
+ 
+     private static final FluidState AIR_FLUIDSTATE = Fluids.EMPTY.defaultFluidState();
+@@ -383,7 +370,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable, ca.spottedl
+         int lastChunkY = Integer.MIN_VALUE;
+         int lastChunkZ = Integer.MIN_VALUE;
+ 
+-        final int minSection = ((ca.spottedleaf.moonrise.patches.collisions.world.CollisionLevel)level).moonrise$getMinSection();
++        final int minSection = ca.spottedleaf.moonrise.common.util.WorldUtil.getMinSection(level);
+ 
+         for (;;) {
+             currPos.set(currX, currY, currZ);
+@@ -466,7 +453,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable, ca.spottedl
+      * @author Spottedleaf
+      */
+     @Override
+-    public final net.minecraft.world.phys.BlockHitResult clip(final ClipContext clipContext) {
++    public net.minecraft.world.phys.BlockHitResult clip(final ClipContext clipContext) {
+         // can only do this in this class, as not everything that implements BlockGetter can retrieve chunks
+         return fastClip(clipContext.getFrom(), clipContext.getTo(), (Level)(Object)this, clipContext);
+     }
+@@ -476,7 +463,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable, ca.spottedl
+      * @author Spottedleaf
+      */
+     @Override
+-    public final boolean collidesWithSuffocatingBlock(final Entity entity, final AABB box) {
++    public boolean collidesWithSuffocatingBlock(final Entity entity, final AABB box) {
+         return ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.getCollisionsForBlocksOrWorldBorder((Level)(Object)this, entity, box, null, null,
+             ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.COLLISION_FLAG_CHECK_ONLY,
+             (final BlockState state, final BlockPos pos) -> {
+@@ -502,8 +489,8 @@ public abstract class Level implements LevelAccessor, AutoCloseable, ca.spottedl
+      * @author Spottedleaf
+      */
+     @Override
+-    public final java.util.Optional<net.minecraft.world.phys.Vec3> findFreePosition(final Entity entity, final VoxelShape boundsShape, final Vec3 fromPosition,
+-                                                                                    final double rangeX, final double rangeY, final double rangeZ) {
++    public java.util.Optional<net.minecraft.world.phys.Vec3> findFreePosition(final Entity entity, final VoxelShape boundsShape, final Vec3 fromPosition,
++                                                                              final double rangeX, final double rangeY, final double rangeZ) {
+         if (boundsShape.isEmpty()) {
+             return java.util.Optional.empty();
+         }
+@@ -562,103 +549,139 @@ public abstract class Level implements LevelAccessor, AutoCloseable, ca.spottedl
+      * @author Spottedleaf
+      */
+     @Override
+-    public final java.util.Optional<net.minecraft.core.BlockPos> findSupportingBlock(final Entity entity, final AABB aabb) {
++    public java.util.Optional<net.minecraft.core.BlockPos> findSupportingBlock(final Entity entity, final AABB aabb) {
++        final int minSection = ca.spottedleaf.moonrise.common.util.WorldUtil.getMinSection((Level)(Object)this);
++
+         final int minBlockX = Mth.floor(aabb.minX - ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.COLLISION_EPSILON) - 1;
+         final int maxBlockX = Mth.floor(aabb.maxX + ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.COLLISION_EPSILON) + 1;
+ 
+-        final int minBlockY = Mth.floor(aabb.minY - ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.COLLISION_EPSILON) - 1;
+-        final int maxBlockY = Mth.floor(aabb.maxY + ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.COLLISION_EPSILON) + 1;
++        final int minBlockY = Math.max((minSection << 4) - 1, Mth.floor(aabb.minY - ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.COLLISION_EPSILON) - 1);
++        final int maxBlockY = Math.min((ca.spottedleaf.moonrise.common.util.WorldUtil.getMaxSection((Level)(Object)this) << 4) + 16, Mth.floor(aabb.maxY + ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.COLLISION_EPSILON) + 1);
+ 
+         final int minBlockZ = Mth.floor(aabb.minZ - ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.COLLISION_EPSILON) - 1;
+         final int maxBlockZ = Mth.floor(aabb.maxZ + ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.COLLISION_EPSILON) + 1;
+ 
+-        ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.LazyEntityCollisionContext collisionContext = null;
+-
+-        final BlockPos.MutableBlockPos pos = new BlockPos.MutableBlockPos();
++        final BlockPos.MutableBlockPos mutablePos = new BlockPos.MutableBlockPos();
++        final ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.LazyEntityCollisionContext collisionShape = new ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.LazyEntityCollisionContext(entity);
+         BlockPos selected = null;
+         double selectedDistance = Double.MAX_VALUE;
+-
+         final Vec3 entityPos = entity.position();
+ 
+-        LevelChunk lastChunk = null;
+-        int lastChunkX = Integer.MIN_VALUE;
+-        int lastChunkZ = Integer.MIN_VALUE;
++        // special cases:
++        if (minBlockY > maxBlockY) {
++            // no point in checking
++            return java.util.Optional.empty();
++        }
+ 
+-        final ChunkSource chunkSource = this.getChunkSource();
++        final int minChunkX = minBlockX >> 4;
++        final int maxChunkX = maxBlockX >> 4;
+ 
+-        for (int currZ = minBlockZ; currZ <= maxBlockZ; ++currZ) {
+-            pos.setZ(currZ);
+-            for (int currX = minBlockX; currX <= maxBlockX; ++currX) {
+-                pos.setX(currX);
++        final int minChunkY = minBlockY >> 4;
++        final int maxChunkY = maxBlockY >> 4;
+ 
+-                final int newChunkX = currX >> 4;
+-                final int newChunkZ = currZ >> 4;
++        final int minChunkZ = minBlockZ >> 4;
++        final int maxChunkZ = maxBlockZ >> 4;
+ 
+-                if (((newChunkX ^ lastChunkX) | (newChunkZ ^ lastChunkZ)) != 0) {
+-                    lastChunkX = newChunkX;
+-                    lastChunkZ = newChunkZ;
+-                    lastChunk = (LevelChunk)chunkSource.getChunk(newChunkX, newChunkZ, ChunkStatus.FULL, false);
+-                }
++        final ChunkSource chunkSource = this.getChunkSource();
++
++        for (int currChunkZ = minChunkZ; currChunkZ <= maxChunkZ; ++currChunkZ) {
++            for (int currChunkX = minChunkX; currChunkX <= maxChunkX; ++currChunkX) {
++                final ChunkAccess chunk = chunkSource.getChunk(currChunkX, currChunkZ, ChunkStatus.FULL, false);
+ 
+-                if (lastChunk == null) {
++                if (chunk == null) {
+                     continue;
+                 }
+-                for (int currY = minBlockY; currY <= maxBlockY; ++currY) {
+-                    int edgeCount = ((currX == minBlockX || currX == maxBlockX) ? 1 : 0) +
+-                        ((currY == minBlockY || currY == maxBlockY) ? 1 : 0) +
+-                        ((currZ == minBlockZ || currZ == maxBlockZ) ? 1 : 0);
+-                    if (edgeCount == 3) {
+-                        continue;
+-                    }
+ 
+-                    pos.setY(currY);
++                final net.minecraft.world.level.chunk.LevelChunkSection[] sections = chunk.getSections();
+ 
+-                    final double distance = pos.distToCenterSqr(entityPos);
+-                    if (distance > selectedDistance || (distance == selectedDistance && selected.compareTo(pos) >= 0)) {
++                // bound y
++                for (int currChunkY = minChunkY; currChunkY <= maxChunkY; ++currChunkY) {
++                    final int sectionIdx = currChunkY - minSection;
++                    if (sectionIdx < 0 || sectionIdx >= sections.length) {
+                         continue;
+                     }
+-
+-                    final BlockState state = ((ca.spottedleaf.moonrise.patches.chunk_getblock.GetBlockChunk)lastChunk).moonrise$getBlock(currX, currY, currZ);
+-                    if (((ca.spottedleaf.moonrise.patches.collisions.block.CollisionBlockState)state).moonrise$emptyCollisionShape()) {
++                    final net.minecraft.world.level.chunk.LevelChunkSection section = sections[sectionIdx];
++                    if (section.hasOnlyAir()) {
++                        // empty
+                         continue;
+                     }
+ 
+-                    VoxelShape blockCollision = ((ca.spottedleaf.moonrise.patches.collisions.block.CollisionBlockState)state).moonrise$getConstantCollisionShape();
+-
+-                    if ((edgeCount != 1 || state.hasLargeCollisionShape()) && (edgeCount != 2 || state.getBlock() == Blocks.MOVING_PISTON)) {
+-                        if (collisionContext == null) {
+-                            collisionContext = new ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.LazyEntityCollisionContext(entity);
+-                        }
+-
+-                        if (blockCollision == null) {
+-                            blockCollision = state.getCollisionShape((Level)(Object)this, pos, collisionContext);
+-                        }
+-
+-                        if (blockCollision.isEmpty()) {
+-                            continue;
+-                        }
+-
+-                        // avoid VoxelShape#move by shifting the entity collision shape instead
+-                        final AABB shiftedAABB = aabb.move(-(double)currX, -(double)currY, -(double)currZ);
+-
+-                        final AABB singleAABB = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)blockCollision).moonrise$getSingleAABBRepresentation();
+-                        if (singleAABB != null) {
+-                            if (!ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.voxelShapeIntersect(singleAABB, shiftedAABB)) {
+-                                continue;
++                    final boolean hasSpecial = ((ca.spottedleaf.moonrise.patches.block_counting.BlockCountingChunkSection)section).moonrise$hasSpecialCollidingBlocks();
++                    final int sectionAdjust = !hasSpecial ? 1 : 0;
++
++                    final net.minecraft.world.level.chunk.PalettedContainer<net.minecraft.world.level.block.state.BlockState> blocks = section.states;
++
++                    final int minXIterate = currChunkX == minChunkX ? (minBlockX & 15) + sectionAdjust : 0;
++                    final int maxXIterate = currChunkX == maxChunkX ? (maxBlockX & 15) - sectionAdjust : 15;
++                    final int minZIterate = currChunkZ == minChunkZ ? (minBlockZ & 15) + sectionAdjust : 0;
++                    final int maxZIterate = currChunkZ == maxChunkZ ? (maxBlockZ & 15) - sectionAdjust : 15;
++                    final int minYIterate = currChunkY == minChunkY ? (minBlockY & 15) + sectionAdjust : 0;
++                    final int maxYIterate = currChunkY == maxChunkY ? (maxBlockY & 15) - sectionAdjust : 15;
++
++                    for (int currY = minYIterate; currY <= maxYIterate; ++currY) {
++                        final int blockY = currY | (currChunkY << 4);
++                        mutablePos.setY(blockY);
++                        for (int currZ = minZIterate; currZ <= maxZIterate; ++currZ) {
++                            final int blockZ = currZ | (currChunkZ << 4);
++                            mutablePos.setZ(blockZ);
++                            for (int currX = minXIterate; currX <= maxXIterate; ++currX) {
++                                final int localBlockIndex = (currX) | (currZ << 4) | ((currY) << 8);
++                                final int blockX = currX | (currChunkX << 4);
++                                mutablePos.setX(blockX);
++
++                                final int edgeCount = hasSpecial ? ((blockX == minBlockX || blockX == maxBlockX) ? 1 : 0) +
++                                    ((blockY == minBlockY || blockY == maxBlockY) ? 1 : 0) +
++                                    ((blockZ == minBlockZ || blockZ == maxBlockZ) ? 1 : 0) : 0;
++                                if (edgeCount == 3) {
++                                    continue;
++                                }
++
++                                final double distance = mutablePos.distToCenterSqr(entityPos);
++                                if (distance > selectedDistance || (distance == selectedDistance && selected.compareTo(mutablePos) >= 0)) {
++                                    continue;
++                                }
++
++                                final BlockState blockData = blocks.get(localBlockIndex);
++
++                                if (((ca.spottedleaf.moonrise.patches.collisions.block.CollisionBlockState)blockData).moonrise$emptyContextCollisionShape()) {
++                                    continue;
++                                }
++
++                                VoxelShape blockCollision = ((ca.spottedleaf.moonrise.patches.collisions.block.CollisionBlockState)blockData).moonrise$getConstantContextCollisionShape();
++
++                                if (edgeCount == 0 || ((edgeCount != 1 || blockData.hasLargeCollisionShape()) && (edgeCount != 2 || blockData.getBlock() == Blocks.MOVING_PISTON))) {
++                                    if (blockCollision == null) {
++                                        blockCollision = blockData.getCollisionShape((Level)(Object)this, mutablePos, collisionShape);
++
++                                        if (blockCollision.isEmpty()) {
++                                            continue;
++                                        }
++                                    }
++
++                                    // avoid VoxelShape#move by shifting the entity collision shape instead
++                                    final AABB shiftedAABB = aabb.move(-(double)blockX, -(double)blockY, -(double)blockZ);
++
++                                    final AABB singleAABB = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)blockCollision).moonrise$getSingleAABBRepresentation();
++                                    if (singleAABB != null) {
++                                        if (!ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.voxelShapeIntersect(singleAABB, shiftedAABB)) {
++                                            continue;
++                                        }
++
++                                        selected = mutablePos.immutable();
++                                        selectedDistance = distance;
++                                        continue;
++                                    }
++
++                                    if (!ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.voxelShapeIntersectNoEmpty(blockCollision, shiftedAABB)) {
++                                        continue;
++                                    }
++
++                                    selected = mutablePos.immutable();
++                                    selectedDistance = distance;
++                                    continue;
++                                }
+                             }
+-
+-                            selected = pos.immutable();
+-                            selectedDistance = distance;
+-                            continue;
+                         }
+-
+-                        if (!ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.voxelShapeIntersectNoEmpty(blockCollision, shiftedAABB)) {
+-                            continue;
+-                        }
+-
+-                        selected = pos.immutable();
+-                        selectedDistance = distance;
+-                        continue;
+                     }
+                 }
+             }
+@@ -667,6 +690,74 @@ public abstract class Level implements LevelAccessor, AutoCloseable, ca.spottedl
+         return java.util.Optional.ofNullable(selected);
+     }
+     // Paper end - optimise collisions
++    // Paper start - getblock optimisations - cache world height/sections
++    private final int minY;
++    private final int height;
++    private final int maxY;
++    private final int minSectionY;
++    private final int maxSectionY;
++    private final int sectionsCount;
++
++    @Override
++    public int getMinY() {
++        return this.minY;
++    }
++
++    @Override
++    public int getHeight() {
++        return this.height;
++    }
++
++    @Override
++    public int getMaxY() {
++        return this.maxY;
++    }
++
++    @Override
++    public int getSectionsCount() {
++        return this.sectionsCount;
++    }
++
++    @Override
++    public int getMinSectionY() {
++        return this.minSectionY;
++    }
++
++    @Override
++    public int getMaxSectionY() {
++        return this.maxSectionY;
++    }
++
++    @Override
++    public boolean isInsideBuildHeight(final int blockY) {
++        return blockY >= this.minY && blockY <= this.maxY;
++    }
++
++    @Override
++    public boolean isOutsideBuildHeight(final BlockPos pos) {
++        return this.isOutsideBuildHeight(pos.getY());
++    }
++
++    @Override
++    public boolean isOutsideBuildHeight(final int blockY) {
++        return blockY < this.minY || blockY > this.maxY;
++    }
++
++    @Override
++    public int getSectionIndex(final int blockY) {
++        return (blockY >> 4) - this.minSectionY;
++    }
++
++    @Override
++    public int getSectionIndexFromSectionY(final int sectionY) {
++        return sectionY - this.minSectionY;
++    }
++
++    @Override
++    public int getSectionYFromSectionIndex(final int sectionIdx) {
++        return sectionIdx + this.minSectionY;
++    }
++    // Paper end - getblock optimisations - cache world height/sections
+     // Paper start - optimise random ticking
+     @Override
+     public abstract Holder<Biome> getUncachedNoiseBiome(final int x, final int y, final int z);
+@@ -685,6 +776,15 @@ public abstract class Level implements LevelAccessor, AutoCloseable, ca.spottedl
+     // Paper end - optimise random ticking
+ 
+     protected Level(WritableLevelData worlddatamutable, ResourceKey<Level> resourcekey, RegistryAccess iregistrycustom, Holder<DimensionType> holder, Supplier<ProfilerFiller> supplier, boolean flag, boolean flag1, long i, int j, org.bukkit.generator.ChunkGenerator gen, org.bukkit.generator.BiomeProvider biomeProvider, org.bukkit.World.Environment env, java.util.function.Function<org.spigotmc.SpigotWorldConfig, io.papermc.paper.configuration.WorldConfiguration> paperWorldConfigCreator, java.util.concurrent.Executor executor) { // Paper - create paper world config & Anti-Xray
++        // Paper start - getblock optimisations - cache world height/sections
++        final DimensionType dimType = holder.value();
++        this.minY = dimType.minY();
++        this.height = dimType.height();
++        this.maxY = this.minY + this.height - 1;
++        this.minSectionY = this.minY >> 4;
++        this.maxSectionY = this.maxY >> 4;
++        this.sectionsCount = this.maxSectionY - this.minSectionY + 1;
++        // Paper end - getblock optimisations - cache world height/sections
+         this.spigotConfig = new org.spigotmc.SpigotWorldConfig(((net.minecraft.world.level.storage.PrimaryLevelData) worlddatamutable).getLevelName()); // Spigot
+         this.paperConfig = paperWorldConfigCreator.apply(this.spigotConfig); // Paper - create paper world config
+         this.generator = gen;
+diff --git a/src/main/java/net/minecraft/world/level/biome/BiomeManager.java b/src/main/java/net/minecraft/world/level/biome/BiomeManager.java
+index 01352cc83b25eb0e30b7e0ff521fc7c1b3d5155b..90f8360f547ce709fd13ee34f8e67d8bfa94b498 100644
+--- a/src/main/java/net/minecraft/world/level/biome/BiomeManager.java
++++ b/src/main/java/net/minecraft/world/level/biome/BiomeManager.java
+@@ -98,8 +98,7 @@ public class BiomeManager {
+     }
+ 
+     private static double getFiddle(long l) {
+-        double d = (double)Math.floorMod(l >> 24, 1024) / 1024.0;
+-        return (d - 0.5) * 0.9;
++        return (double)(((l >> 24) & (1024 - 1)) - (1024/2)) * (0.9 / 1024.0); // Paper - avoid floorMod, fp division, and fp subtraction
+     }
+ 
+     public interface NoiseBiomeSource {
+diff --git a/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java b/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java
+index d0109633e8bdf109cfc9178963d7b6cf92f8b189..ad9c85c19146970371106050ec009a96075769c1 100644
+--- a/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java
++++ b/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java
+@@ -796,18 +796,12 @@ public abstract class BlockBehaviour implements FeatureElement {
+         private boolean isRandomlyTicking;
+ 
+         // Paper start - rewrite chunk system
+-        private int opacityIfCached;
+         private boolean isConditionallyFullOpaque;
+ 
+         @Override
+         public final boolean starlight$isConditionallyFullOpaque() {
+             return this.isConditionallyFullOpaque;
+         }
+-
+-        @Override
+-        public final int starlight$getOpacityIfCached() {
+-            return this.opacityIfCached;
+-        }
+         // Paper end - rewrite chunk system
+         // Paper start - optimise collisions
+         private static final int RANDOM_OFFSET = 704237939;
+@@ -817,16 +811,22 @@ public abstract class BlockBehaviour implements FeatureElement {
+         private final int id2 = it.unimi.dsi.fastutil.HashCommon.murmurHash3(it.unimi.dsi.fastutil.HashCommon.murmurHash3(ID_GENERATOR.getAndIncrement() + RANDOM_OFFSET) + RANDOM_OFFSET);
+         private boolean occludesFullBlock;
+         private boolean emptyCollisionShape;
++        private boolean emptyConstantCollisionShape;
+         private VoxelShape constantCollisionShape;
+-        private AABB constantAABBCollision;
+ 
+-        private static void initCaches(final VoxelShape shape) {
++        private static void initCaches(final VoxelShape shape, final boolean neighbours) {
+             ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)shape).moonrise$isFullBlock();
+             ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)shape).moonrise$occludesFullBlock();
+             shape.toAabbs();
+             if (!shape.isEmpty()) {
+                 shape.bounds();
+             }
++            if (neighbours) {
++                for (final Direction direction : DIRECTIONS_CACHED) {
++                    initCaches(((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)shape).moonrise$getFaceShapeClamped(direction), false);
++                    initCaches(shape.getFaceShape(direction), false);
++                }
++            }
+         }
+ 
+         @Override
+@@ -844,6 +844,11 @@ public abstract class BlockBehaviour implements FeatureElement {
+             return this.emptyCollisionShape;
+         }
+ 
++        @Override
++        public final boolean moonrise$emptyContextCollisionShape() {
++            return this.emptyConstantCollisionShape;
++        }
++
+         @Override
+         public final int moonrise$uniqueId1() {
+             return this.id1;
+@@ -855,14 +860,9 @@ public abstract class BlockBehaviour implements FeatureElement {
+         }
+ 
+         @Override
+-        public final VoxelShape moonrise$getConstantCollisionShape() {
++        public final VoxelShape moonrise$getConstantContextCollisionShape() {
+             return this.constantCollisionShape;
+         }
+-
+-        @Override
+-        public final AABB moonrise$getConstantCollisionAABB() {
+-            return this.constantAABBCollision;
+-        }
+         // Paper end - optimise collisions
+ 
+         protected BlockStateBase(Block block, Reference2ObjectArrayMap<Property<?>, Comparable<?>> propertyMap, MapCodec<BlockState> codec) {
+@@ -931,39 +931,37 @@ public abstract class BlockBehaviour implements FeatureElement {
+             this.legacySolid = this.calculateSolid();
+             // Paper start - rewrite chunk system
+             this.isConditionallyFullOpaque = this.canOcclude & this.useShapeForLightOcclusion;
+-            this.opacityIfCached = this.cache == null || this.isConditionallyFullOpaque ? -1 : this.cache.lightBlock;
+             // Paper end - rewrite chunk system
+             // Paper start - optimise collisions
+             if (this.cache != null) {
+                 final VoxelShape collisionShape = this.cache.collisionShape;
+                 try {
+                     this.constantCollisionShape = this.getCollisionShape(null, null, null);
+-                    this.constantAABBCollision = this.constantCollisionShape == null ? null : ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)this.constantCollisionShape).moonrise$getSingleAABBRepresentation();
+                 } catch (final Throwable throwable) {
+                     this.constantCollisionShape = null;
+-                    this.constantAABBCollision = null;
+                 }
+                 this.occludesFullBlock = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)collisionShape).moonrise$occludesFullBlock();
+                 this.emptyCollisionShape = collisionShape.isEmpty();
++                this.emptyConstantCollisionShape = this.constantCollisionShape != null && this.constantCollisionShape.isEmpty();
+                 // init caches
+-                initCaches(collisionShape);
+-                if (collisionShape != Shapes.empty() && collisionShape != Shapes.block()) {
+-                    for (final Direction direction : DIRECTIONS_CACHED) {
+-                        // initialise the directional face shape cache as well
+-                        final VoxelShape shape = Shapes.getFaceShape(collisionShape, direction);
+-                        initCaches(shape);
+-                    }
+-                }
+-                if (this.cache.occlusionShapes != null) {
+-                    for (final VoxelShape shape : this.cache.occlusionShapes) {
+-                        initCaches(shape);
+-                    }
++                initCaches(collisionShape, true);
++                if (this.constantCollisionShape != null) {
++                    initCaches(this.constantCollisionShape, true);
+                 }
+             } else {
+                 this.occludesFullBlock = false;
+                 this.emptyCollisionShape = false;
++                this.emptyConstantCollisionShape = false;
+                 this.constantCollisionShape = null;
+-                this.constantAABBCollision = null;
++            }
++
++            if (this.occlusionShape != null) {
++                initCaches(this.occlusionShape, true);
++            }
++            if (this.occlusionShapesByFace != null) {
++                for (final VoxelShape shape : this.occlusionShapesByFace) {
++                    initCaches(shape, true);
++                }
+             }
+             // Paper end - optimise collisions
+         }
+diff --git a/src/main/java/net/minecraft/world/level/block/state/StateHolder.java b/src/main/java/net/minecraft/world/level/block/state/StateHolder.java
+index daedcfd867ed6171fb61bdcbded417a11c8a5b0f..97a7860b66be418399912307f8e68db9b4edf121 100644
+--- a/src/main/java/net/minecraft/world/level/block/state/StateHolder.java
++++ b/src/main/java/net/minecraft/world/level/block/state/StateHolder.java
+@@ -17,7 +17,7 @@ import java.util.stream.Collectors;
+ import javax.annotation.Nullable;
+ import net.minecraft.world.level.block.state.properties.Property;
+ 
+-public abstract class StateHolder<O, S> {
++public abstract class StateHolder<O, S> implements ca.spottedleaf.moonrise.patches.blockstate_propertyaccess.PropertyAccessStateHolder { // Paper - optimise blockstate property access
+     public static final String NAME_TAG = "Name";
+     public static final String PROPERTIES_TAG = "Properties";
+     public static final Function<Entry<Property<?>, Comparable<?>>, String> PROPERTY_ENTRY_TO_STRING_FUNCTION = new Function<Entry<Property<?>, Comparable<?>>, String>() {
+@@ -36,14 +36,28 @@ public abstract class StateHolder<O, S> {
+         }
+     };
+     protected final O owner;
+-    private final Reference2ObjectArrayMap<Property<?>, Comparable<?>> values;
++    private Reference2ObjectArrayMap<Property<?>, Comparable<?>> values; // Paper - optimise blockstate property access - remove final
+     private Table<Property<?>, Comparable<?>, S> neighbours;
+     protected final MapCodec<S> propertiesCodec;
+ 
++    // Paper start - optimise blockstate property access
++    protected ca.spottedleaf.moonrise.patches.blockstate_propertyaccess.util.ZeroCollidingReferenceStateTable<O, S> optimisedTable;
++    protected final long tableIndex;
++
++    @Override
++    public final long moonrise$getTableIndex() {
++        return this.tableIndex;
++    }
++    // Paper end - optimise blockstate property access
++
+     protected StateHolder(O owner, Reference2ObjectArrayMap<Property<?>, Comparable<?>> propertyMap, MapCodec<S> codec) {
+         this.owner = owner;
+         this.values = propertyMap;
+         this.propertiesCodec = codec;
++        // Paper start - optimise blockstate property access
++        this.optimisedTable = new ca.spottedleaf.moonrise.patches.blockstate_propertyaccess.util.ZeroCollidingReferenceStateTable<>(this.values.keySet());
++        this.tableIndex = this.optimisedTable.getIndex((StateHolder<O, S>)(Object)this);
++        // Paper end - optimise blockstate property access
+     }
+ 
+     public <T extends Comparable<T>> S cycle(Property<T> property) {
+@@ -80,20 +94,21 @@ public abstract class StateHolder<O, S> {
+     }
+ 
+     public Collection<Property<?>> getProperties() {
+-        return Collections.unmodifiableCollection(this.values.keySet());
++        return this.optimisedTable.getProperties(); // Paper - optimise blockstate property access
+     }
+ 
+     public <T extends Comparable<T>> boolean hasProperty(Property<T> property) {
+-        return this.values.containsKey(property);
++        return property != null && this.optimisedTable.hasProperty(property); // Paper - optimise blockstate property access
+     }
+ 
+     public <T extends Comparable<T>> T getValue(Property<T> property) {
+-        Comparable<?> comparable = this.values.get(property);
+-        if (comparable == null) {
+-            throw new IllegalArgumentException("Cannot get property " + property + " as it does not exist in " + this.owner);
+-        } else {
+-            return property.getValueClass().cast(comparable);
++        // Paper start - optimise blockstate property access
++        final T ret = this.optimisedTable.get(this.tableIndex, property);
++        if (ret != null) {
++            return ret;
+         }
++        throw new IllegalArgumentException("Cannot get property " + property + " as it does not exist in " + this.owner);
++        // Paper end - optimise blockstate property access
+     }
+ 
+     public <T extends Comparable<T>> Optional<T> getOptionalValue(Property<T> property) {
+@@ -102,36 +117,52 @@ public abstract class StateHolder<O, S> {
+     }
+ 
+     public <T extends Comparable<T>, V extends T> S setValue(Property<T> property, V value) {
+-        Comparable<?> comparable = this.values.get(property);
+-        if (comparable == null) {
+-            throw new IllegalArgumentException("Cannot set property " + property + " as it does not exist in " + this.owner);
+-        } else if (comparable.equals(value)) {
+-            return (S)this;
+-        } else {
+-            S object = this.neighbours.get(property, value);
+-            if (object == null) {
+-                throw new IllegalArgumentException("Cannot set property " + property + " to " + value + " on " + this.owner + ", it is not an allowed value");
+-            } else {
+-                return object;
+-            }
++        // Paper start - optimise blockstate property access
++        final S ret = this.optimisedTable.set(this.tableIndex, property, value);
++        if (ret != null) {
++            return ret;
+         }
++        throw new IllegalArgumentException("Cannot set property " + property + " to " + value + " on " + this.owner);
++        // Paper end - optimise blockstate property access
+     }
+ 
+     public <T extends Comparable<T>, V extends T> S trySetValue(Property<T> property, V value) {
+-        Comparable<?> comparable = this.values.get(property);
+-        if (comparable != null && !comparable.equals(value)) {
+-            S object = this.neighbours.get(property, value);
+-            if (object == null) {
+-                throw new IllegalArgumentException("Cannot set property " + property + " to " + value + " on " + this.owner + ", it is not an allowed value");
+-            } else {
+-                return object;
+-            }
+-        } else {
+-            return (S)this;
++        // Paper start - optimise blockstate property access
++        if (property == null) {
++            return (S)(StateHolder<O, S>)(Object)this;
+         }
++        final S ret = this.optimisedTable.trySet(this.tableIndex, property, value, (S)(StateHolder<O, S>)(Object)this);
++        if (ret != null) {
++            return ret;
++        }
++        throw new IllegalArgumentException("Cannot set property " + property + " to " + value + " on " + this.owner);
++        // Paper end - optimise blockstate property access
+     }
+ 
+     public void populateNeighbours(Map<Map<Property<?>, Comparable<?>>, S> states) {
++        // Paper start - optimise blockstate property access
++        final Map<Map<Property<?>, Comparable<?>>, S> map = states;
++        if (true) {
++            if (this.optimisedTable.isLoaded()) {
++                return;
++            }
++            this.optimisedTable.loadInTable(map);
++
++            // de-duplicate the tables
++            for (final Map.Entry<Map<Property<?>, Comparable<?>>, S> entry : map.entrySet()) {
++                final S value = entry.getValue();
++                ((StateHolder<O, S>)value).optimisedTable = this.optimisedTable;
++            }
++
++            // remove values arrays
++            for (final Map.Entry<Map<Property<?>, Comparable<?>>, S> entry : map.entrySet()) {
++                final S value = entry.getValue();
++                ((StateHolder<O, S>)value).values = null;
++            }
++
++            return;
++        }
++        // Paper end - optimise blockstate property access
+         if (this.neighbours != null) {
+             throw new IllegalStateException();
+         } else {
+@@ -158,7 +189,11 @@ public abstract class StateHolder<O, S> {
+     }
+ 
+     public Map<Property<?>, Comparable<?>> getValues() {
+-        return this.values;
++        // Paper start - optimise blockstate property access
++        ca.spottedleaf.moonrise.patches.blockstate_propertyaccess.util.ZeroCollidingReferenceStateTable<O, S> table = this.optimisedTable;
++        // We have to use this.values until the table is loaded
++        return table.isLoaded() ? table.getMapView(this.tableIndex) : this.values;
++        // Paper end - optimise blockstate property access
+     }
+ 
+     protected static <O, S extends StateHolder<O, S>> Codec<S> codec(Codec<O> codec, Function<O, S> ownerToStateFunction) {
+diff --git a/src/main/java/net/minecraft/world/level/block/state/properties/BooleanProperty.java b/src/main/java/net/minecraft/world/level/block/state/properties/BooleanProperty.java
+index b63116b333b6e06494091a82588acfb639bddb71..054a2569b5b103835facef1e34867c60884e5c29 100644
+--- a/src/main/java/net/minecraft/world/level/block/state/properties/BooleanProperty.java
++++ b/src/main/java/net/minecraft/world/level/block/state/properties/BooleanProperty.java
+@@ -4,11 +4,21 @@ import com.google.common.collect.ImmutableSet;
+ import java.util.Collection;
+ import java.util.Optional;
+ 
+-public class BooleanProperty extends Property<Boolean> {
++public class BooleanProperty extends Property<Boolean> implements ca.spottedleaf.moonrise.patches.blockstate_propertyaccess.PropertyAccess<Boolean> { // Paper - optimise blockstate property access
+     private final ImmutableSet<Boolean> values = ImmutableSet.of(true, false);
+ 
++    // Paper start - optimise blockstate property access
++    private static final Boolean[] BY_ID = new Boolean[]{ Boolean.FALSE, Boolean.TRUE };
++
++    @Override
++    public final int moonrise$getIdFor(final Boolean value) {
++        return value.booleanValue() ? 1 : 0;
++    }
++    // Paper end - optimise blockstate property access
++
+     protected BooleanProperty(String name) {
+         super(name, Boolean.class);
++        this.moonrise$setById(BY_ID); // Paper - optimise blockstate property access
+     }
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/level/block/state/properties/EnumProperty.java b/src/main/java/net/minecraft/world/level/block/state/properties/EnumProperty.java
+index 3097298fe356df98967cf4bdeaaede69dfe8a441..c23cb4ac167799e61ab9a4e1f43a5722d596332e 100644
+--- a/src/main/java/net/minecraft/world/level/block/state/properties/EnumProperty.java
++++ b/src/main/java/net/minecraft/world/level/block/state/properties/EnumProperty.java
+@@ -11,10 +11,38 @@ import java.util.function.Predicate;
+ import java.util.stream.Collectors;
+ import net.minecraft.util.StringRepresentable;
+ 
+-public class EnumProperty<T extends Enum<T> & StringRepresentable> extends Property<T> {
++public class EnumProperty<T extends Enum<T> & StringRepresentable> extends Property<T> implements ca.spottedleaf.moonrise.patches.blockstate_propertyaccess.PropertyAccess<T> { // Paper - optimise blockstate property access
+     private final ImmutableSet<T> values;
+     private final Map<String, T> names = Maps.newHashMap();
+ 
++    // Paper start - optimise blockstate property access
++    private int[] idLookupTable;
++
++    @Override
++    public final int moonrise$getIdFor(final T value) {
++        final Class<T> target = this.getValueClass();
++        return ((value.getClass() != target && value.getDeclaringClass() != target)) ? -1 : this.idLookupTable[value.ordinal()];
++    }
++
++    private void init() {
++        final Collection<T> values = this.getPossibleValues();
++        final Class<T> clazz = this.getValueClass();
++
++        int id = 0;
++        this.idLookupTable = new int[clazz.getEnumConstants().length];
++        Arrays.fill(this.idLookupTable, -1);
++        final T[] byId = (T[])java.lang.reflect.Array.newInstance(clazz, values.size());
++
++        for (final T value : values) {
++            final int valueId = id++;
++            this.idLookupTable[value.ordinal()] = valueId;
++            byId[valueId] = value;
++        }
++
++        this.moonrise$setById(byId);
++    }
++    // Paper end - optimise blockstate property access
++
+     protected EnumProperty(String name, Class<T> type, Collection<T> values) {
+         super(name, type);
+         this.values = ImmutableSet.copyOf(values);
+@@ -27,6 +55,7 @@ public class EnumProperty<T extends Enum<T> & StringRepresentable> extends Prope
+ 
+             this.names.put(string, enum_);
+         }
++        this.init(); // Paper - optimise blockstate property access
+     }
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/level/block/state/properties/IntegerProperty.java b/src/main/java/net/minecraft/world/level/block/state/properties/IntegerProperty.java
+index 3a850321a4bcc68058483b5fd53e829c425a68af..4a21ec538d7410159bb26b9bf3701605b5ef317f 100644
+--- a/src/main/java/net/minecraft/world/level/block/state/properties/IntegerProperty.java
++++ b/src/main/java/net/minecraft/world/level/block/state/properties/IntegerProperty.java
+@@ -6,11 +6,33 @@ import java.util.Collection;
+ import java.util.Optional;
+ import java.util.Set;
+ 
+-public class IntegerProperty extends Property<Integer> {
++public class IntegerProperty extends Property<Integer> implements ca.spottedleaf.moonrise.patches.blockstate_propertyaccess.PropertyAccess<Integer> { // Paper - optimise blockstate property access
+     private final ImmutableSet<Integer> values;
+     public final int min;
+     public final int max;
+ 
++    // Paper start - optimise blockstate property access
++    @Override
++    public final int moonrise$getIdFor(final Integer value) {
++        final int val = value.intValue();
++        final int ret = val - this.min;
++
++        return ret | ((this.max - ret) >> 31);
++    }
++
++    private void init() {
++        final int min = this.min;
++        final int max = this.max;
++
++        final Integer[] byId = new Integer[max - min + 1];
++        for (int i = min; i <= max; ++i) {
++            byId[i - min] = Integer.valueOf(i);
++        }
++
++        this.moonrise$setById(byId);
++    }
++    // Paper end - optimise blockstate property access
++
+     protected IntegerProperty(String name, int min, int max) {
+         super(name, Integer.class);
+         if (min < 0) {
+@@ -28,6 +50,7 @@ public class IntegerProperty extends Property<Integer> {
+ 
+             this.values = ImmutableSet.copyOf(set);
+         }
++        this.init(); // Paper - optimise blockstate property access
+     }
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/level/block/state/properties/Property.java b/src/main/java/net/minecraft/world/level/block/state/properties/Property.java
+index 9055f15af0cae55effa6942913a9d7edf3857e07..e63a7541f43e5c8f92f348c4e49756b33698c668 100644
+--- a/src/main/java/net/minecraft/world/level/block/state/properties/Property.java
++++ b/src/main/java/net/minecraft/world/level/block/state/properties/Property.java
+@@ -10,7 +10,7 @@ import java.util.stream.Stream;
+ import javax.annotation.Nullable;
+ import net.minecraft.world.level.block.state.StateHolder;
+ 
+-public abstract class Property<T extends Comparable<T>> {
++public abstract class Property<T extends Comparable<T>> implements ca.spottedleaf.moonrise.patches.blockstate_propertyaccess.PropertyAccess<T> { // Paper - optimise blockstate property access
+     private final Class<T> clazz;
+     private final String name;
+     @Nullable
+@@ -24,9 +24,38 @@ public abstract class Property<T extends Comparable<T>> {
+         );
+     private final Codec<Property.Value<T>> valueCodec = this.codec.xmap(this::value, Property.Value::value);
+ 
++    // Paper start - optimise blockstate property access
++    private static final java.util.concurrent.atomic.AtomicInteger ID_GENERATOR = new java.util.concurrent.atomic.AtomicInteger();
++    private final int id;
++    private T[] byId;
++
++    @Override
++    public final int moonrise$getId() {
++        return this.id;
++    }
++
++    @Override
++    public final T moonrise$getById(final int id) {
++        final T[] byId = this.byId;
++        return id < 0 || id >= byId.length ? null : this.byId[id];
++    }
++
++    @Override
++    public final void moonrise$setById(final T[] byId) {
++        if (this.byId != null) {
++            throw new IllegalStateException();
++        }
++        this.byId = byId;
++    }
++
++    @Override
++    public abstract int moonrise$getIdFor(final T value);
++    // Paper end - optimise blockstate property access
++
+     protected Property(String name, Class<T> type) {
+         this.clazz = type;
+         this.name = name;
++        this.id = ID_GENERATOR.getAndIncrement(); // Paper - optimise blockstate property access
+     }
+ 
+     public Property.Value<T> value(T value) {
+diff --git a/src/main/java/net/minecraft/world/level/chunk/HashMapPalette.java b/src/main/java/net/minecraft/world/level/chunk/HashMapPalette.java
+index c5e1040c239874dcf20b79472bf690ee7f0a9e5f..0f403e0c257b1304be2ede89b8529676dbe8c32b 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/HashMapPalette.java
++++ b/src/main/java/net/minecraft/world/level/chunk/HashMapPalette.java
+@@ -8,12 +8,19 @@ import net.minecraft.network.FriendlyByteBuf;
+ import net.minecraft.network.VarInt;
+ import net.minecraft.util.CrudeIncrementalIntIdentityHashBiMap;
+ 
+-public class HashMapPalette<T> implements Palette<T> {
++public class HashMapPalette<T> implements Palette<T>, ca.spottedleaf.moonrise.patches.fast_palette.FastPalette<T> { // Paper - optimise palette reads
+     private final IdMap<T> registry;
+     private final CrudeIncrementalIntIdentityHashBiMap<T> values;
+     private final PaletteResize<T> resizeHandler;
+     private final int bits;
+ 
++    // Paper start - optimise palette reads
++    @Override
++    public final T[] moonrise$getRawPalette(final ca.spottedleaf.moonrise.patches.fast_palette.FastPaletteData<T> container) {
++        return ((ca.spottedleaf.moonrise.patches.fast_palette.FastPalette<T>)this.values).moonrise$getRawPalette(container);
++    }
++    // Paper end - optimise palette reads
++
+     public HashMapPalette(IdMap<T> idList, int bits, PaletteResize<T> listener, List<T> entries) {
+         this(idList, bits, listener);
+         entries.forEach(this.values::add);
+diff --git a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
+index 7c11853c5090fbc4fa5b3e73a69acf166158fdec..170df85f42410f4766b04e73fc3a95e6dc4a3b8a 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
++++ b/src/main/java/net/minecraft/world/level/chunk/LevelChunk.java
+@@ -53,7 +53,7 @@ import net.minecraft.world.ticks.LevelChunkTicks;
+ import net.minecraft.world.ticks.TickContainerAccess;
+ import org.slf4j.Logger;
+ 
+-public class LevelChunk extends ChunkAccess implements ca.spottedleaf.moonrise.patches.chunk_system.level.chunk.ChunkSystemLevelChunk, ca.spottedleaf.moonrise.patches.starlight.chunk.StarlightChunk, ca.spottedleaf.moonrise.patches.chunk_getblock.GetBlockChunk { // Paper - rewrite chunk system // Paper - get block chunk optimisation
++public class LevelChunk extends ChunkAccess implements ca.spottedleaf.moonrise.patches.chunk_system.level.chunk.ChunkSystemLevelChunk, ca.spottedleaf.moonrise.patches.starlight.chunk.StarlightChunk, ca.spottedleaf.moonrise.patches.getblock.GetBlockChunk { // Paper - rewrite chunk system // Paper - get block chunk optimisation
+ 
+     static final Logger LOGGER = LogUtils.getLogger();
+     private static final TickingBlockEntity NULL_TICKER = new TickingBlockEntity() {
+diff --git a/src/main/java/net/minecraft/world/level/chunk/LevelChunkSection.java b/src/main/java/net/minecraft/world/level/chunk/LevelChunkSection.java
+index c3b1caa352b988ec44fa2b2eb0536517711f5460..df1b3f3ae48f66137484e0eb3f4c7323269e1a74 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/LevelChunkSection.java
++++ b/src/main/java/net/minecraft/world/level/chunk/LevelChunkSection.java
+@@ -27,15 +27,17 @@ public class LevelChunkSection implements ca.spottedleaf.moonrise.patches.block_
+     private PalettedContainer<Holder<Biome>> biomes;
+ 
+     // Paper start - block counting
+-    private static final it.unimi.dsi.fastutil.ints.IntArrayList FULL_LIST = new it.unimi.dsi.fastutil.ints.IntArrayList(16*16*16);
++    private static final it.unimi.dsi.fastutil.shorts.ShortArrayList FULL_LIST = new it.unimi.dsi.fastutil.shorts.ShortArrayList(16*16*16);
+     static {
+-        for (int i = 0; i < (16*16*16); ++i) {
++        for (short i = 0; i < (16*16*16); ++i) {
+             FULL_LIST.add(i);
+         }
+     }
+ 
+-    private int specialCollidingBlocks;
+-    private final ca.spottedleaf.moonrise.common.list.IBlockDataList tickingBlocks = new ca.spottedleaf.moonrise.common.list.IBlockDataList();
++    private boolean isClient;
++    private static final short CLIENT_FORCED_SPECIAL_COLLIDING_BLOCKS = (short)9999;
++    private short specialCollidingBlocks;
++    private final ca.spottedleaf.moonrise.common.list.ShortList tickingBlocks = new ca.spottedleaf.moonrise.common.list.ShortList();
+ 
+     @Override
+     public final int moonrise$getSpecialCollidingBlocks() {
+@@ -43,7 +45,7 @@ public class LevelChunkSection implements ca.spottedleaf.moonrise.patches.block_
+     }
+ 
+     @Override
+-    public final ca.spottedleaf.moonrise.common.list.IBlockDataList moonrise$getTickingBlockList() {
++    public final ca.spottedleaf.moonrise.common.list.ShortList moonrise$getTickingBlockList() {
+         return this.tickingBlocks;
+     }
+     // Paper end - block counting
+@@ -83,6 +85,45 @@ public class LevelChunkSection implements ca.spottedleaf.moonrise.patches.block_
+         return this.setBlockState(x, y, z, state, true);
+     }
+ 
++    // Paper start - block counting
++    private void updateBlockCallback(final int x, final int y, final int z, final BlockState newState,
++                                     final BlockState oldState) {
++        if (oldState == newState) {
++            return;
++        }
++
++        if (this.isClient) {
++            if (ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.isSpecialCollidingBlock(newState)) {
++                this.specialCollidingBlocks = CLIENT_FORCED_SPECIAL_COLLIDING_BLOCKS;
++            }
++            return;
++        }
++
++        final boolean isSpecialOld = ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.isSpecialCollidingBlock(oldState);
++        final boolean isSpecialNew = ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.isSpecialCollidingBlock(newState);
++        if (isSpecialOld != isSpecialNew) {
++            if (isSpecialOld) {
++                --this.specialCollidingBlocks;
++            } else {
++                ++this.specialCollidingBlocks;
++            }
++        }
++
++        final boolean oldTicking = oldState.isRandomlyTicking();
++        final boolean newTicking = newState.isRandomlyTicking();
++        if (oldTicking != newTicking) {
++            final ca.spottedleaf.moonrise.common.list.ShortList tickingBlocks = this.tickingBlocks;
++            final short position = (short)(x | (z << 4) | (y << (4+4)));
++
++            if (oldTicking) {
++                tickingBlocks.remove(position);
++            } else {
++                tickingBlocks.add(position);
++            }
++        }
++    }
++    // Paper end - block counting
++
+     public BlockState setBlockState(int x, int y, int z, BlockState state, boolean lock) {
+         BlockState iblockdata1;
+ 
+@@ -102,7 +143,7 @@ public class LevelChunkSection implements ca.spottedleaf.moonrise.patches.block_
+             }
+         }
+ 
+-        if (!fluid.isEmpty()) {
++        if (!!fluid.isRandomlyTicking()) { // Paper - block counting
+             --this.tickingFluidCount;
+         }
+ 
+@@ -113,25 +154,11 @@ public class LevelChunkSection implements ca.spottedleaf.moonrise.patches.block_
+             }
+         }
+ 
+-        if (!fluid1.isEmpty()) {
++        if (!!fluid1.isRandomlyTicking()) { // Paper - block counting
+             ++this.tickingFluidCount;
+         }
+ 
+-        // Paper start - block counting
+-        if (ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.isSpecialCollidingBlock(iblockdata1)) {
+-            --this.specialCollidingBlocks;
+-        }
+-        if (ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.isSpecialCollidingBlock(state)) {
+-            ++this.specialCollidingBlocks;
+-        }
+-
+-        if (iblockdata1.isRandomlyTicking()) {
+-            this.tickingBlocks.remove(x, y, z);
+-        }
+-        if (state.isRandomlyTicking()) {
+-            this.tickingBlocks.add(x, y, z, state);
+-        }
+-        // Paper end - block counting
++        this.updateBlockCallback(x, y, z, state, iblockdata1); // Paper - block counting
+ 
+         return iblockdata1;
+     }
+@@ -167,7 +194,7 @@ public class LevelChunkSection implements ca.spottedleaf.moonrise.patches.block_
+             final int paletteSize = palette.getSize();
+             final net.minecraft.util.BitStorage storage = data.storage();
+ 
+-            final it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap<it.unimi.dsi.fastutil.ints.IntArrayList> counts;
++            final it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap<it.unimi.dsi.fastutil.shorts.ShortArrayList> counts;
+             if (paletteSize == 1) {
+                 counts = new it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap<>(1);
+                 counts.put(0, FULL_LIST);
+@@ -175,10 +202,10 @@ public class LevelChunkSection implements ca.spottedleaf.moonrise.patches.block_
+                 counts = ((ca.spottedleaf.moonrise.patches.block_counting.BlockCountingBitStorage)storage).moonrise$countEntries();
+             }
+ 
+-            for (final java.util.Iterator<it.unimi.dsi.fastutil.ints.Int2ObjectMap.Entry<it.unimi.dsi.fastutil.ints.IntArrayList>> iterator = counts.int2ObjectEntrySet().fastIterator(); iterator.hasNext();) {
+-                final it.unimi.dsi.fastutil.ints.Int2ObjectMap.Entry<it.unimi.dsi.fastutil.ints.IntArrayList> entry = iterator.next();
++            for (final java.util.Iterator<it.unimi.dsi.fastutil.ints.Int2ObjectMap.Entry<it.unimi.dsi.fastutil.shorts.ShortArrayList>> iterator = counts.int2ObjectEntrySet().fastIterator(); iterator.hasNext();) {
++                final it.unimi.dsi.fastutil.ints.Int2ObjectMap.Entry<it.unimi.dsi.fastutil.shorts.ShortArrayList> entry = iterator.next();
+                 final int paletteIdx = entry.getIntKey();
+-                final it.unimi.dsi.fastutil.ints.IntArrayList coordinates = entry.getValue();
++                final it.unimi.dsi.fastutil.shorts.ShortArrayList coordinates = entry.getValue();
+                 final int paletteCount = coordinates.size();
+ 
+                 final BlockState state = palette.valueFor(paletteIdx);
+@@ -188,25 +215,30 @@ public class LevelChunkSection implements ca.spottedleaf.moonrise.patches.block_
+                 }
+ 
+                 if (ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.isSpecialCollidingBlock(state)) {
+-                    this.specialCollidingBlocks += paletteCount;
++                    this.specialCollidingBlocks += (short)paletteCount;
+                 }
+-                this.nonEmptyBlockCount += paletteCount;
++                this.nonEmptyBlockCount += (short)paletteCount;
+                 if (state.isRandomlyTicking()) {
+-                    this.tickingBlockCount += paletteCount;
+-                    final int[] raw = coordinates.elements();
++                    this.tickingBlockCount += (short)paletteCount;
++                    final short[] raw = coordinates.elements();
++                    final int rawLen = raw.length;
++
++                    final ca.spottedleaf.moonrise.common.list.ShortList tickingBlocks = this.tickingBlocks;
++
++                    tickingBlocks.setMinCapacity(Math.min((rawLen + tickingBlocks.size()) * 3 / 2, 16*16*16));
+ 
+                     java.util.Objects.checkFromToIndex(0, paletteCount, raw.length);
+                     for (int i = 0; i < paletteCount; ++i) {
+-                        this.tickingBlocks.add(raw[i], state);
++                        tickingBlocks.add(raw[i]);
+                     }
+                 }
+ 
+                 final FluidState fluid = state.getFluidState();
+ 
+                 if (!fluid.isEmpty()) {
+-                    //this.nonEmptyBlockCount += count; // fix vanilla bug: make non empty block count correct
++                    //this.nonEmptyBlockCount += count; // fix vanilla bug: make non-empty block count correct
+                     if (fluid.isRandomlyTicking()) {
+-                        this.tickingFluidCount += paletteCount;
++                        this.tickingFluidCount += (short)paletteCount;
+                     }
+                 }
+             }
+@@ -229,7 +261,11 @@ public class LevelChunkSection implements ca.spottedleaf.moonrise.patches.block_
+ 
+         datapaletteblock.read(buf);
+         this.biomes = datapaletteblock;
+-        this.recalcBlockCounts(); // Paper - block counting
++        // Paper start - block counting
++        this.isClient = true;
++        // force has special colliding blocks to be true
++        this.specialCollidingBlocks = this.nonEmptyBlockCount != (short)0 && this.maybeHas(ca.spottedleaf.moonrise.patches.collisions.CollisionUtil::isSpecialCollidingBlock) ? CLIENT_FORCED_SPECIAL_COLLIDING_BLOCKS : (short)0;
++        // Paper end - block counting
+     }
+ 
+     public void readBiomes(FriendlyByteBuf buf) {
+diff --git a/src/main/java/net/minecraft/world/level/chunk/LinearPalette.java b/src/main/java/net/minecraft/world/level/chunk/LinearPalette.java
+index f4c3f2a49b8d023b8ef67529eba30cf31467d8bf..716eb6f406db4b81b8854de0ea693a72f9ca9d13 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/LinearPalette.java
++++ b/src/main/java/net/minecraft/world/level/chunk/LinearPalette.java
+@@ -7,13 +7,20 @@ import net.minecraft.network.FriendlyByteBuf;
+ import net.minecraft.network.VarInt;
+ import org.apache.commons.lang3.Validate;
+ 
+-public class LinearPalette<T> implements Palette<T> {
++public class LinearPalette<T> implements Palette<T>, ca.spottedleaf.moonrise.patches.fast_palette.FastPalette<T> { // Paper - optimise palette reads
+     private final IdMap<T> registry;
+     private final T[] values;
+     private final PaletteResize<T> resizeHandler;
+     private final int bits;
+     private int size;
+ 
++    // Paper start - optimise palette reads
++    @Override
++    public final T[] moonrise$getRawPalette(final ca.spottedleaf.moonrise.patches.fast_palette.FastPaletteData<T> container) {
++        return this.values;
++    }
++    // Paper end - optimise palette reads
++
+     private LinearPalette(IdMap<T> idList, int bits, PaletteResize<T> listener, List<T> list) {
+         this.registry = idList;
+         this.values = (T[])(new Object[1 << bits]);
+diff --git a/src/main/java/net/minecraft/world/level/chunk/Palette.java b/src/main/java/net/minecraft/world/level/chunk/Palette.java
+index e379f39cc6e03723a5323d8392b4c10bfde65115..882284fe7beeb56a8b35ac6153ff41e84ebad27e 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/Palette.java
++++ b/src/main/java/net/minecraft/world/level/chunk/Palette.java
+@@ -5,7 +5,7 @@ import java.util.function.Predicate;
+ import net.minecraft.core.IdMap;
+ import net.minecraft.network.FriendlyByteBuf;
+ 
+-public interface Palette<T> {
++public interface Palette<T> extends ca.spottedleaf.moonrise.patches.fast_palette.FastPalette<T> { // Paper - optimise palette reads
+     int idFor(T object);
+ 
+     boolean maybeHas(Predicate<T> predicate);
+diff --git a/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java b/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java
+index 13d3c877b006a4975e7370713e3919c661e7890f..955862559b8c751b82082a5c0e02031324bf4805 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java
++++ b/src/main/java/net/minecraft/world/level/chunk/PalettedContainer.java
+@@ -41,6 +41,33 @@ public class PalettedContainer<T> implements PaletteResize<T>, PalettedContainer
+         // this.threadingDetector.checkAndUnlock(); // Paper - disable this
+     }
+ 
++    // Paper start - optimise palette reads
++    private void updateData(final PalettedContainer.Data<T> data) {
++        if (data != null) {
++            ((ca.spottedleaf.moonrise.patches.fast_palette.FastPaletteData<T>)(Object)data).moonrise$setPalette(
++                ((ca.spottedleaf.moonrise.patches.fast_palette.FastPalette<T>)data.palette).moonrise$getRawPalette((ca.spottedleaf.moonrise.patches.fast_palette.FastPaletteData<T>)(Object)data)
++            );
++        }
++    }
++
++    private T readPaletteSlow(final PalettedContainer.Data<T> data, final int paletteIdx) {
++        return data.palette.valueFor(paletteIdx);
++    }
++
++    private T readPalette(final PalettedContainer.Data<T> data, final int paletteIdx) {
++        final T[] palette = ((ca.spottedleaf.moonrise.patches.fast_palette.FastPaletteData<T>)(Object)data).moonrise$getPalette();
++        if (palette == null) {
++            return this.readPaletteSlow(data, paletteIdx);
++        }
++
++        final T ret = palette[paletteIdx];
++        if (ret == null) {
++            throw new IllegalArgumentException("Palette index out of bounds");
++        }
++        return ret;
++    }
++    // Paper end - optimise palette reads
++
+     // Paper start - Anti-Xray - Add preset values
+     @Deprecated @io.papermc.paper.annotation.DoNotUse public static <T> Codec<PalettedContainer<T>> codecRW(IdMap<T> idList, Codec<T> entryCodec, PalettedContainer.Strategy paletteProvider, T defaultValue) { return PalettedContainer.codecRW(idList, entryCodec, paletteProvider, defaultValue, null); }
+     public static <T> Codec<PalettedContainer<T>> codecRW(IdMap<T> idList, Codec<T> entryCodec, PalettedContainer.Strategy paletteProvider, T defaultValue, T @org.jetbrains.annotations.Nullable [] presetValues) {
+@@ -113,6 +140,7 @@ public class PalettedContainer<T> implements PaletteResize<T>, PalettedContainer
+             }
+         }
+         // Paper end
++        this.updateData(this.data); // Paper - optimise palette reads
+     }
+ 
+     // Paper start - Anti-Xray - Add preset values
+@@ -122,6 +150,7 @@ public class PalettedContainer<T> implements PaletteResize<T>, PalettedContainer
+         this.registry = idList;
+         this.strategy = paletteProvider;
+         this.data = data;
++        this.updateData(this.data); // Paper - optimise palette reads
+     }
+ 
+     // Paper start - Anti-Xray - Add preset values
+@@ -133,6 +162,7 @@ public class PalettedContainer<T> implements PaletteResize<T>, PalettedContainer
+         this.registry = idList;
+         this.data = this.createOrReuseData(null, 0);
+         this.data.palette.idFor(object);
++        this.updateData(this.data); // Paper - optimise palette reads
+     }
+ 
+     private PalettedContainer.Data<T> createOrReuseData(@Nullable PalettedContainer.Data<T> previousData, int bits) {
+@@ -158,6 +188,7 @@ public class PalettedContainer<T> implements PaletteResize<T>, PalettedContainer
+         PalettedContainer.Data<T> data2 = this.createOrReuseData(data, newBits);
+         data2.copyFrom(data.palette, data.storage);
+         this.data = data2;
++        this.updateData(this.data); // Paper - optimise palette reads
+         this.addPresetValues();
+         return object == null ? -1 : data2.palette.idFor(object);
+         // Paper end
+@@ -191,9 +222,12 @@ public class PalettedContainer<T> implements PaletteResize<T>, PalettedContainer
+     }
+ 
+     private synchronized T getAndSet(int index, T value) { // Paper - synchronize
+-        int i = this.data.palette.idFor(value);
+-        int j = this.data.storage.getAndSet(index, i);
+-        return this.data.palette.valueFor(j);
++        // Paper start - optimise palette reads
++        final int paletteIdx = this.data.palette.idFor(value);
++        final PalettedContainer.Data<T> data = this.data;
++        final int prev = data.storage.getAndSet(index, paletteIdx);
++        return this.readPalette(data, prev);
++        // Paper end - optimise palette reads
+     }
+ 
+     public void set(int x, int y, int z, T value) {
+@@ -217,8 +251,10 @@ public class PalettedContainer<T> implements PaletteResize<T>, PalettedContainer
+     }
+ 
+     public T get(int index) { // Paper - public
+-        PalettedContainer.Data<T> data = this.data;
+-        return data.palette.valueFor(data.storage.get(index));
++        // Paper start - optimise palette reads
++        final PalettedContainer.Data<T> data = this.data;
++        return this.readPalette(data, data.storage.get(index));
++        // Paper end - optimise palette reads
+     }
+ 
+     @Override
+@@ -238,6 +274,7 @@ public class PalettedContainer<T> implements PaletteResize<T>, PalettedContainer
+             data.palette.read(buf);
+             buf.readLongArray(data.storage.getRaw());
+             this.data = data;
++            this.updateData(this.data); // Paper - optimise palette reads
+             this.addPresetValues(); // Paper - Anti-Xray - Add preset values (inefficient, but this isn't used by the server)
+         } finally {
+             this.release();
+@@ -386,7 +423,44 @@ public class PalettedContainer<T> implements PaletteResize<T>, PalettedContainer
+         void accept(T object, int count);
+     }
+ 
+-    static record Data<T>(PalettedContainer.Configuration<T> configuration, BitStorage storage, Palette<T> palette) {
++    // Paper start - optimise palette reads
++    public static final class Data<T> implements ca.spottedleaf.moonrise.patches.fast_palette.FastPaletteData<T> {
++
++        private final PalettedContainer.Configuration<T> configuration;
++        private final BitStorage storage;
++        private final Palette<T> palette;
++
++        private T[] moonrise$palette;
++
++        public Data(final PalettedContainer.Configuration<T> configuration, final BitStorage storage, final Palette<T> palette) {
++            this.configuration = configuration;
++            this.storage = storage;
++            this.palette = palette;
++        }
++
++        public PalettedContainer.Configuration<T> configuration() {
++            return this.configuration;
++        }
++
++        public BitStorage storage() {
++            return this.storage;
++        }
++
++        public Palette<T> palette() {
++            return this.palette;
++        }
++
++        @Override
++        public final T[] moonrise$getPalette() {
++            return this.moonrise$palette;
++        }
++
++        @Override
++        public final void moonrise$setPalette(final T[] palette) {
++            this.moonrise$palette = palette;
++        }
++        // Paper end - optimise palette reads
++
+         public void copyFrom(Palette<T> palette, BitStorage storage) {
+             for (int i = 0; i < storage.getSize(); i++) {
+                 T object = palette.valueFor(storage.get(i));
+diff --git a/src/main/java/net/minecraft/world/level/chunk/SingleValuePalette.java b/src/main/java/net/minecraft/world/level/chunk/SingleValuePalette.java
+index 24b608cfcd6f39db02e682e5d8162dc4ad9fd6d6..3a06392a327f26d78c28fdcce39f74b130c4d906 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/SingleValuePalette.java
++++ b/src/main/java/net/minecraft/world/level/chunk/SingleValuePalette.java
+@@ -8,12 +8,24 @@ import net.minecraft.network.FriendlyByteBuf;
+ import net.minecraft.network.VarInt;
+ import org.apache.commons.lang3.Validate;
+ 
+-public class SingleValuePalette<T> implements Palette<T> {
++public class SingleValuePalette<T> implements Palette<T>, ca.spottedleaf.moonrise.patches.fast_palette.FastPalette<T> { // Paper - optimise palette reads
+     private final IdMap<T> registry;
+     @Nullable
+     private T value;
+     private final PaletteResize<T> resizeHandler;
+ 
++    // Paper start - optimise palette reads
++    private T[] rawPalette;
++
++    @Override
++    public final T[] moonrise$getRawPalette(final ca.spottedleaf.moonrise.patches.fast_palette.FastPaletteData<T> container) {
++        if (this.rawPalette != null) {
++            return this.rawPalette;
++        }
++        return this.rawPalette = (T[])new Object[] { this.value };
++    }
++    // Paper end - optimise palette reads
++
+     public SingleValuePalette(IdMap<T> idList, PaletteResize<T> listener, List<T> entries) {
+         this.registry = idList;
+         this.resizeHandler = listener;
+@@ -33,6 +45,11 @@ public class SingleValuePalette<T> implements Palette<T> {
+             return this.resizeHandler.onResize(1, object);
+         } else {
+             this.value = object;
++            // Paper start - optimise palette reads
++            if (this.rawPalette != null) {
++                this.rawPalette[0] = object;
++            }
++            // Paper end - optimise palette reads
+             return 0;
+         }
+     }
+@@ -58,6 +75,11 @@ public class SingleValuePalette<T> implements Palette<T> {
+     @Override
+     public void read(FriendlyByteBuf buf) {
+         this.value = this.registry.byIdOrThrow(buf.readVarInt());
++        // Paper start - optimise palette reads
++        if (this.rawPalette != null) {
++            this.rawPalette[0] = this.value;
++        }
++        // Paper end - optimise palette reads
+     }
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java
+index 1e0439cf3f4008fa430acb90b45f5bc4cdd6d7f2..e46bdcbf3514eaa6f4990a797a63c5041a142807 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java
++++ b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java
+@@ -28,7 +28,7 @@ import net.minecraft.nbt.NbtIo; // Paper
+ import net.minecraft.world.level.ChunkPos;
+ import org.slf4j.Logger;
+ 
+-public class RegionFile implements AutoCloseable {
++public class RegionFile implements AutoCloseable, ca.spottedleaf.moonrise.patches.chunk_system.storage.ChunkSystemRegionFile { // Paper - rewrite chunk system
+ 
+     private static final Logger LOGGER = LogUtils.getLogger();
+     private static final int SECTOR_BYTES = 4096;
+@@ -51,6 +51,20 @@ public class RegionFile implements AutoCloseable {
+     private final IntBuffer timestamps;
+     @VisibleForTesting
+     protected final RegionBitmap usedSectors;
++    // Paper start - rewrite chunk system
++    @Override
++    public final ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO.RegionDataController.WriteData moonrise$startWrite(final CompoundTag data, final ChunkPos pos) throws IOException {
++        final RegionFile.ChunkBuffer buffer = ((RegionFile)(Object)this).new ChunkBuffer(pos);
++        ((ca.spottedleaf.moonrise.patches.chunk_system.storage.ChunkSystemChunkBuffer)buffer).moonrise$setWriteOnClose(false);
++
++        final DataOutputStream out = new DataOutputStream(this.version.wrap(buffer));
++
++        return new ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO.RegionDataController.WriteData(
++            data, ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO.RegionDataController.WriteData.WriteResult.WRITE,
++            out, ((ca.spottedleaf.moonrise.patches.chunk_system.storage.ChunkSystemChunkBuffer)buffer)::moonrise$write
++        );
++    }
++    // Paper end - rewrite chunk system
+     // Paper start - Attempt to recalculate regionfile header if it is corrupt
+     private static long roundToSectors(long bytes) {
+         long sectors = bytes >>> 12; // 4096 = 2^12
+@@ -682,6 +696,16 @@ public class RegionFile implements AutoCloseable {
+ 
+     @Nullable
+     private DataInputStream createExternalChunkInputStream(ChunkPos pos, byte flags) throws IOException {
++        // Paper start - rewrite chunk system
++        final DataInputStream is = this.createExternalChunkInputStream0(pos, flags);
++        if (is == null) {
++            return is;
++        }
++        return new ca.spottedleaf.moonrise.patches.chunk_system.util.stream.ExternalChunkStreamMarker(is);
++    }
++    @Nullable
++    private DataInputStream createExternalChunkInputStream0(ChunkPos pos, byte flags) throws IOException {
++        // Paper end - rewrite chunk system
+         Path path = this.getExternalChunkPath(pos);
+ 
+         if (!Files.isRegularFile(path, new LinkOption[0])) {
+@@ -978,10 +1002,29 @@ public class RegionFile implements AutoCloseable {
+ 
+     }
+     // Paper end
+-    private class ChunkBuffer extends ByteArrayOutputStream {
++    private class ChunkBuffer extends ByteArrayOutputStream implements ca.spottedleaf.moonrise.patches.chunk_system.storage.ChunkSystemChunkBuffer { // Paper - rewrite chunk system
+ 
+         private final ChunkPos pos;
+ 
++        // Paper start - rewrite chunk system
++        private boolean writeOnClose = true;
++
++        @Override
++        public final boolean moonrise$getWriteOnClose() {
++            return this.writeOnClose;
++        }
++
++        @Override
++        public final void moonrise$setWriteOnClose(final boolean value) {
++            this.writeOnClose = value;
++        }
++
++        @Override
++        public final void moonrise$write(final RegionFile regionFile) throws IOException {
++            regionFile.write(this.pos, ByteBuffer.wrap(this.buf, 0, this.count));
++        }
++        // Paper end - rewrite chunk system
++
+         public ChunkBuffer(final ChunkPos chunkcoordintpair) {
+             super(8096);
+             super.write(0);
+@@ -1015,7 +1058,7 @@ public class RegionFile implements AutoCloseable {
+ 
+             JvmProfiler.INSTANCE.onRegionFileWrite(RegionFile.this.info, this.pos, RegionFile.this.version, i);
+             bytebuffer.putInt(0, i);
+-            RegionFile.this.write(this.pos, bytebuffer);
++            if (this.writeOnClose) { RegionFile.this.write(this.pos, bytebuffer); } // Paper - rewrite chunk system
+         }
+     }
+ 
+diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java
+index 40689256711cc94a806ca1da346f4f62eda31526..b0ace4c7f25425a58c0707e7a7992446164bef88 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java
++++ b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileStorage.java
+@@ -28,8 +28,8 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
+ 
+     // Paper start - rewrite chunk system
+     private static final int REGION_SHIFT = 5;
+-    private static final int MAX_NON_EXISTING_CACHE = 1024 * 64;
+-    private final it.unimi.dsi.fastutil.longs.LongLinkedOpenHashSet nonExistingRegionFiles = new it.unimi.dsi.fastutil.longs.LongLinkedOpenHashSet(MAX_NON_EXISTING_CACHE+1);
++    private static final int MAX_NON_EXISTING_CACHE = 1024 * 4;
++    private final it.unimi.dsi.fastutil.longs.LongLinkedOpenHashSet nonExistingRegionFiles = new it.unimi.dsi.fastutil.longs.LongLinkedOpenHashSet();
+     private static String getRegionFileName(final int chunkX, final int chunkZ) {
+         return "r." + (chunkX >> REGION_SHIFT) + "." + (chunkZ >> REGION_SHIFT) + ".mca";
+     }
+@@ -104,6 +104,97 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
+ 
+         return ret;
+     }
++
++    @Override
++    public final ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO.RegionDataController.WriteData moonrise$startWrite(
++        final int chunkX, final int chunkZ, final CompoundTag compound
++    ) throws IOException {
++        if (compound == null) {
++            return new ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO.RegionDataController.WriteData(
++                compound, ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO.RegionDataController.WriteData.WriteResult.DELETE,
++                null, null
++            );
++        }
++
++        final ChunkPos pos = new ChunkPos(chunkX, chunkZ);
++        final RegionFile regionFile = this.getRegionFile(pos);
++
++        // note: not required to keep regionfile loaded after this call, as the write param takes a regionfile as input
++        // (and, the regionfile parameter is unused for writing until the write call)
++        final ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO.RegionDataController.WriteData writeData = ((ca.spottedleaf.moonrise.patches.chunk_system.storage.ChunkSystemRegionFile)regionFile).moonrise$startWrite(compound, pos);
++
++        try {
++            NbtIo.write(compound, writeData.output());
++        } finally {
++            writeData.output().close();
++        }
++
++        return writeData;
++    }
++
++    @Override
++    public final void moonrise$finishWrite(
++        final int chunkX, final int chunkZ, final ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO.RegionDataController.WriteData writeData
++    ) throws IOException {
++        final ChunkPos pos = new ChunkPos(chunkX, chunkZ);
++        if (writeData.result() == ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO.RegionDataController.WriteData.WriteResult.DELETE) {
++            final RegionFile regionFile = this.moonrise$getRegionFileIfExists(chunkX, chunkZ);
++            if (regionFile != null) {
++                regionFile.clear(pos);
++            } // else: didn't exist
++
++            return;
++        }
++
++        writeData.write().run(this.getRegionFile(pos));
++    }
++
++    @Override
++    public final ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO.RegionDataController.ReadData moonrise$readData(
++        final int chunkX, final int chunkZ
++    ) throws IOException {
++        final RegionFile regionFile = this.moonrise$getRegionFileIfExists(chunkX, chunkZ);
++
++        final DataInputStream input = regionFile == null ? null : regionFile.getChunkDataInputStream(new ChunkPos(chunkX, chunkZ));
++
++        if (input == null) {
++            return new ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO.RegionDataController.ReadData(
++                ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO.RegionDataController.ReadData.ReadResult.NO_DATA, null, null
++            );
++        }
++
++        final ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO.RegionDataController.ReadData ret = new ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO.RegionDataController.ReadData(
++            ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO.RegionDataController.ReadData.ReadResult.HAS_DATA, input, null
++        );
++
++        if (!(input instanceof ca.spottedleaf.moonrise.patches.chunk_system.util.stream.ExternalChunkStreamMarker)) {
++            // internal stream, which is fully read
++            return ret;
++        }
++
++        final CompoundTag syncRead = this.moonrise$finishRead(chunkX, chunkZ, ret);
++
++        if (syncRead == null) {
++            // need to try again
++            return this.moonrise$readData(chunkX, chunkZ);
++        }
++
++        return new ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO.RegionDataController.ReadData(
++            ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO.RegionDataController.ReadData.ReadResult.SYNC_READ, null, syncRead
++        );
++    }
++
++    // if the return value is null, then the caller needs to re-try with a new call to readData()
++    @Override
++    public final CompoundTag moonrise$finishRead(
++        final int chunkX, final int chunkZ, final ca.spottedleaf.moonrise.patches.chunk_system.io.MoonriseRegionFileIO.RegionDataController.ReadData readData
++    ) throws IOException {
++        try {
++            return NbtIo.read(readData.input());
++        } finally {
++            readData.input().close();
++        }
++    }
+     // Paper end - rewrite chunk system
+     // Paper start - recalculate region file headers
+     private final boolean isChunkData;
+@@ -143,6 +234,12 @@ public class RegionFileStorage implements AutoCloseable, ca.spottedleaf.moonrise
+         this.isChunkData = isChunkDataFolder(this.folder); // Paper - recalculate region file headers
+     }
+ 
++    // Paper start - rewrite chunk system
++    public RegionFile getRegionFile(ChunkPos chunkcoordintpair) throws IOException {
++        return this.getRegionFile(chunkcoordintpair, false);
++    }
++    // Paper end - rewrite chunk system
++
+     public RegionFile getRegionFile(ChunkPos chunkcoordintpair, boolean existingOnly) throws IOException { // CraftBukkit // Paper - public
+         // Paper start - rewrite chunk system
+         if (existingOnly) {
+diff --git a/src/main/java/net/minecraft/world/level/material/FlowingFluid.java b/src/main/java/net/minecraft/world/level/material/FlowingFluid.java
+index 1c0712295695727ee9c4d430d4157b8e17cbd71f..7b8e5be1648ef8741aadabd6cbdcf991012c3ce2 100644
+--- a/src/main/java/net/minecraft/world/level/material/FlowingFluid.java
++++ b/src/main/java/net/minecraft/world/level/material/FlowingFluid.java
+@@ -55,6 +55,48 @@ public abstract class FlowingFluid extends Fluid {
+     });
+     private final Map<FluidState, VoxelShape> shapes = Maps.newIdentityHashMap();
+ 
++    // Paper start - fluid method optimisations
++    private FluidState sourceFalling;
++    private FluidState sourceNotFalling;
++
++    private static final int TOTAL_FLOWING_STATES = FALLING.getPossibleValues().size() * LEVEL.getPossibleValues().size();
++    private static final int MIN_LEVEL = LEVEL.getPossibleValues().stream().sorted().findFirst().get().intValue();
++
++    // index = (falling ? 1 : 0) + level*2
++    private FluidState[] flowingLookUp;
++    private volatile boolean init;
++
++    private static final int COLLISION_OCCLUSION_CACHE_SIZE = 2048;
++    private static final ThreadLocal<ca.spottedleaf.moonrise.patches.collisions.util.FluidOcclusionCacheKey[]> COLLISION_OCCLUSION_CACHE = ThreadLocal.withInitial(() -> new ca.spottedleaf.moonrise.patches.collisions.util.FluidOcclusionCacheKey[COLLISION_OCCLUSION_CACHE_SIZE]);
++
++
++    /**
++     * Due to init order, we need to use callbacks to initialise our state
++     */
++    private void init() {
++        synchronized (this) {
++            if (this.init) {
++                return;
++            }
++            this.flowingLookUp = new FluidState[TOTAL_FLOWING_STATES];
++            final FluidState defaultFlowState = this.getFlowing().defaultFluidState();
++            for (int i = 0; i < TOTAL_FLOWING_STATES; ++i) {
++                final int falling = i & 1;
++                final int level = (i >>> 1) + MIN_LEVEL;
++
++                this.flowingLookUp[i] = defaultFlowState.setValue(FALLING, falling == 1 ? Boolean.TRUE : Boolean.FALSE)
++                    .setValue(LEVEL, Integer.valueOf(level));
++            }
++
++            final FluidState defaultFallState = this.getSource().defaultFluidState();
++            this.sourceFalling = defaultFallState.setValue(FALLING, Boolean.TRUE);
++            this.sourceNotFalling = defaultFallState.setValue(FALLING, Boolean.FALSE);
++
++            this.init = true;
++        }
++    }
++    // Paper end - fluid method optimisations
++
+     public FlowingFluid() {}
+ 
+     @Override
+@@ -239,53 +281,70 @@ public abstract class FlowingFluid extends Fluid {
+         }
+     }
+ 
+-    private boolean canPassThroughWall(Direction face, BlockGetter world, BlockPos pos, BlockState state, BlockPos fromPos, BlockState fromState) {
+-        Object2ByteLinkedOpenHashMap object2bytelinkedopenhashmap;
++    // Paper start - fluid method optimisations
++    private static boolean canPassThroughWall(final Direction direction, final BlockGetter level,
++                                             final BlockPos fromPos, final BlockState fromState,
++                                             final BlockPos toPos, final BlockState toState) {
++        if (((ca.spottedleaf.moonrise.patches.collisions.block.CollisionBlockState)fromState).moonrise$emptyCollisionShape() & ((ca.spottedleaf.moonrise.patches.collisions.block.CollisionBlockState)toState).moonrise$emptyCollisionShape()) {
++            // don't even try to cache simple cases
++            return true;
++        }
+ 
+-        if (!state.getBlock().hasDynamicShape() && !fromState.getBlock().hasDynamicShape()) {
+-            object2bytelinkedopenhashmap = (Object2ByteLinkedOpenHashMap) FlowingFluid.OCCLUSION_CACHE.get();
+-        } else {
+-            object2bytelinkedopenhashmap = null;
++        if (((ca.spottedleaf.moonrise.patches.collisions.block.CollisionBlockState)fromState).moonrise$occludesFullBlock() | ((ca.spottedleaf.moonrise.patches.collisions.block.CollisionBlockState)toState).moonrise$occludesFullBlock()) {
++            // don't even try to cache simple cases
++            return false;
+         }
+ 
+-        Block.BlockStatePairKey block_a;
++        final ca.spottedleaf.moonrise.patches.collisions.util.FluidOcclusionCacheKey[] cache = ((ca.spottedleaf.moonrise.patches.collisions.block.CollisionBlockState)fromState).moonrise$hasCache() & ((ca.spottedleaf.moonrise.patches.collisions.block.CollisionBlockState)toState).moonrise$hasCache() ?
++            COLLISION_OCCLUSION_CACHE.get() : null;
+ 
+-        if (object2bytelinkedopenhashmap != null) {
+-            block_a = new Block.BlockStatePairKey(state, fromState, face);
+-            byte b0 = object2bytelinkedopenhashmap.getAndMoveToFirst(block_a);
++        final int keyIndex
++            = (((ca.spottedleaf.moonrise.patches.collisions.block.CollisionBlockState)fromState).moonrise$uniqueId1() ^ ((ca.spottedleaf.moonrise.patches.collisions.block.CollisionBlockState)toState).moonrise$uniqueId2() ^ ((ca.spottedleaf.moonrise.patches.collisions.util.CollisionDirection)(Object)direction).moonrise$uniqueId())
++            & (COLLISION_OCCLUSION_CACHE_SIZE - 1);
+ 
+-            if (b0 != 127) {
+-                return b0 != 0;
++        if (cache != null) {
++            final ca.spottedleaf.moonrise.patches.collisions.util.FluidOcclusionCacheKey cached = cache[keyIndex];
++            if (cached != null && cached.first() == fromState && cached.second() == toState && cached.direction() == direction) {
++                return cached.result();
+             }
+-        } else {
+-            block_a = null;
+         }
+ 
+-        VoxelShape voxelshape = state.getCollisionShape(world, pos);
+-        VoxelShape voxelshape1 = fromState.getCollisionShape(world, fromPos);
+-        boolean flag = !Shapes.mergedFaceOccludes(voxelshape, voxelshape1, face);
++        final VoxelShape shape1 = fromState.getCollisionShape(level, fromPos);
++        final VoxelShape shape2 = toState.getCollisionShape(level, toPos);
+ 
+-        if (object2bytelinkedopenhashmap != null) {
+-            if (object2bytelinkedopenhashmap.size() == 200) {
+-                object2bytelinkedopenhashmap.removeLastByte();
+-            }
++        final boolean result = !Shapes.mergedFaceOccludes(shape1, shape2, direction);
+ 
+-            object2bytelinkedopenhashmap.putAndMoveToFirst(block_a, (byte) (flag ? 1 : 0));
++        if (cache != null) {
++            // we can afford to replace in-use keys more often due to the excessive caching the collision patch does in mergedFaceOccludes
++            cache[keyIndex] = new ca.spottedleaf.moonrise.patches.collisions.util.FluidOcclusionCacheKey(fromState, toState, direction, result);
+         }
+ 
+-        return flag;
++        return result;
+     }
++    // Paper end - fluid method optimisations
+ 
+     public abstract Fluid getFlowing();
+ 
+     public FluidState getFlowing(int level, boolean falling) {
+-        return (FluidState) ((FluidState) this.getFlowing().defaultFluidState().setValue(FlowingFluid.LEVEL, level)).setValue(FlowingFluid.FALLING, falling);
++        // Paper start - fluid method optimisations
++        final int amount = level;
++        if (!this.init) {
++            this.init();
++        }
++        final int index = (falling ? 1 : 0) | ((amount - MIN_LEVEL) << 1);
++        return this.flowingLookUp[index];
++        // Paper end - fluid method optimisations
+     }
+ 
+     public abstract Fluid getSource();
+ 
+     public FluidState getSource(boolean falling) {
+-        return (FluidState) this.getSource().defaultFluidState().setValue(FlowingFluid.FALLING, falling);
++        // Paper start - fluid method optimisations
++        if (!this.init) {
++            this.init();
++        }
++        return falling ? this.sourceFalling : this.sourceNotFalling;
++        // Paper end - fluid method optimisations
+     }
+ 
+     protected abstract boolean canConvertToSource(Level world);
+diff --git a/src/main/java/net/minecraft/world/level/material/FluidState.java b/src/main/java/net/minecraft/world/level/material/FluidState.java
+index 14bb12d2a0066e8b020f2e0e670a7a5c74633623..8ceeb053a391d1a53083eb0680cf34c453afcba2 100644
+--- a/src/main/java/net/minecraft/world/level/material/FluidState.java
++++ b/src/main/java/net/minecraft/world/level/material/FluidState.java
+@@ -21,12 +21,30 @@ import net.minecraft.world.level.block.state.properties.Property;
+ import net.minecraft.world.phys.Vec3;
+ import net.minecraft.world.phys.shapes.VoxelShape;
+ 
+-public final class FluidState extends StateHolder<Fluid, FluidState> {
++public final class FluidState extends StateHolder<Fluid, FluidState> implements ca.spottedleaf.moonrise.patches.fluid.FluidFluidState { // Paper - fluid method optimisations
+     public static final Codec<FluidState> CODEC = codec(BuiltInRegistries.FLUID.byNameCodec(), Fluid::defaultFluidState).stable();
+     public static final int AMOUNT_MAX = 9;
+     public static final int AMOUNT_FULL = 8;
+     protected final boolean isEmpty; // Paper - Perf: moved from isEmpty()
+ 
++    // Paper start - fluid method optimisations
++    private int amount;
++    //private boolean isEmpty;
++    private boolean isSource;
++    private float ownHeight;
++    private boolean isRandomlyTicking;
++    private BlockState legacyBlock;
++
++    @Override
++    public final void moonrise$initCaches() {
++        this.amount = this.getType().getAmount((FluidState)(Object)this);
++        //this.isEmpty = this.getType().isEmpty();
++        this.isSource = this.getType().isSource((FluidState)(Object)this);
++        this.ownHeight = this.getType().getOwnHeight((FluidState)(Object)this);
++        this.isRandomlyTicking = this.getType().isRandomlyTicking();
++    }
++    // Paper end - fluid method optimisations
++
+     public FluidState(Fluid fluid, Reference2ObjectArrayMap<Property<?>, Comparable<?>> propertyMap, MapCodec<FluidState> codec) {
+         super(fluid, propertyMap, codec);
+         this.isEmpty = fluid.isEmpty(); // Paper - Perf: moved from isEmpty()
+@@ -37,11 +55,11 @@ public final class FluidState extends StateHolder<Fluid, FluidState> {
+     }
+ 
+     public boolean isSource() {
+-        return this.getType().isSource(this);
++        return this.isSource; // Paper - fluid method optimisations
+     }
+ 
+     public boolean isSourceOfType(Fluid fluid) {
+-        return this.owner == fluid && this.owner.isSource(this);
++        return this.isSource && this.owner == fluid;  // Paper - fluid method optimisations
+     }
+ 
+     public boolean isEmpty() {
+@@ -53,11 +71,11 @@ public final class FluidState extends StateHolder<Fluid, FluidState> {
+     }
+ 
+     public float getOwnHeight() {
+-        return this.getType().getOwnHeight(this);
++        return this.ownHeight; // Paper - fluid method optimisations
+     }
+ 
+     public int getAmount() {
+-        return this.getType().getAmount(this);
++        return this.amount; // Paper - fluid method optimisations
+     }
+ 
+     public boolean shouldRenderBackwardUpFace(BlockGetter world, BlockPos pos) {
+@@ -83,7 +101,7 @@ public final class FluidState extends StateHolder<Fluid, FluidState> {
+     }
+ 
+     public boolean isRandomlyTicking() {
+-        return this.getType().isRandomlyTicking();
++        return this.isRandomlyTicking; // Paper - fluid method optimisations
+     }
+ 
+     public void randomTick(Level world, BlockPos pos, RandomSource random) {
+@@ -95,7 +113,12 @@ public final class FluidState extends StateHolder<Fluid, FluidState> {
+     }
+ 
+     public BlockState createLegacyBlock() {
+-        return this.getType().createLegacyBlock(this);
++        // Paper start - fluid method optimisations
++        if (this.legacyBlock != null) {
++            return this.legacyBlock;
++        }
++        return this.legacyBlock = this.getType().createLegacyBlock((FluidState)(Object)this);
++        // Paper end - fluid method optimisations
+     }
+ 
+     @Nullable
+diff --git a/src/main/java/net/minecraft/world/phys/shapes/DiscreteVoxelShape.java b/src/main/java/net/minecraft/world/phys/shapes/DiscreteVoxelShape.java
+index 1d36f8dcffd22cf844448d3d8351fb8718cf5227..fbe0c4b0fdbb992b7002f6afe1e74d63cbb420f2 100644
+--- a/src/main/java/net/minecraft/world/phys/shapes/DiscreteVoxelShape.java
++++ b/src/main/java/net/minecraft/world/phys/shapes/DiscreteVoxelShape.java
+@@ -57,7 +57,7 @@ public abstract class DiscreteVoxelShape implements ca.spottedleaf.moonrise.patc
+             }
+         }
+ 
+-        final boolean hasSingleAABB = sizeX == 1 && sizeY == 1 && sizeZ == 1 && !isEmpty && discreteVoxelShape.isFull(0, 0, 0);
++        final boolean hasSingleAABB = sizeX == 1 && sizeY == 1 && sizeZ == 1 && !isEmpty && (voxelSet[0] & 1L) != 0L;
+ 
+         final int minFullX = discreteVoxelShape.firstFull(Direction.Axis.X);
+         final int minFullY = discreteVoxelShape.firstFull(Direction.Axis.Y);
+diff --git a/src/main/java/net/minecraft/world/phys/shapes/Shapes.java b/src/main/java/net/minecraft/world/phys/shapes/Shapes.java
+index c348171c150bf69d24303d0862e45ab78baddcab..4c8185fbc560a5c5304729e5827ae7762933ec36 100644
+--- a/src/main/java/net/minecraft/world/phys/shapes/Shapes.java
++++ b/src/main/java/net/minecraft/world/phys/shapes/Shapes.java
+@@ -180,13 +180,13 @@ public final class Shapes {
+                     final VoxelShape first = tmp[i];
+                     final VoxelShape second = tmp[next];
+ 
+-                    tmp[newSize++] = Shapes.or(first, second);
++                    tmp[newSize++] = Shapes.joinUnoptimized(first, second, BooleanOp.OR);
+                 }
+             }
+             size = newSize;
+         }
+ 
+-        return tmp[0];
++        return tmp[0].optimize();
+         // Paper end - optimise collisions
+     }
+ 
+@@ -255,7 +255,22 @@ public final class Shapes {
+     }
+ 
+     public static VoxelShape getFaceShape(VoxelShape shape, Direction direction) {
+-        return ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)shape).moonrise$getFaceShapeClamped(direction); // Paper - optimise collisions
++        if (shape == block()) {
++            return block();
++        } else {
++            Direction.Axis axis = direction.getAxis();
++            boolean bl;
++            int i;
++            if (direction.getAxisDirection() == Direction.AxisDirection.POSITIVE) {
++                bl = DoubleMath.fuzzyEquals(shape.max(axis), 1.0, 1.0E-7);
++                i = shape.shape.getSize(axis) - 1;
++            } else {
++                bl = DoubleMath.fuzzyEquals(shape.min(axis), 0.0, 1.0E-7);
++                i = 0;
++            }
++
++            return (VoxelShape)(!bl ? empty() : new SliceShape(shape, axis, i));
++        }
+     }
+ 
+     // Paper start - optimise collisions
+diff --git a/src/main/java/net/minecraft/world/phys/shapes/VoxelShape.java b/src/main/java/net/minecraft/world/phys/shapes/VoxelShape.java
+index 11824d39e72fa003b3a56aa9b8d679fe8e23a1a4..c207e54dc52e67ba91dac5c6ce1391a77f597bcd 100644
+--- a/src/main/java/net/minecraft/world/phys/shapes/VoxelShape.java
++++ b/src/main/java/net/minecraft/world/phys/shapes/VoxelShape.java
+@@ -162,13 +162,13 @@ public abstract class VoxelShape implements ca.spottedleaf.moonrise.patches.coll
+ 
+         if (direction.getAxisDirection() == Direction.AxisDirection.POSITIVE) {
+             if (DoubleMath.fuzzyEquals(this.max(axis), 1.0, ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.COLLISION_EPSILON)) {
+-                ret = tryForceBlock(new SliceShape((VoxelShape)(Object)this, axis, this.shape.getSize(axis) - 1));
++                ret = ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.sliceShape((VoxelShape)(Object)this, axis, this.shape.getSize(axis) - 1);
+             } else {
+                 ret = Shapes.empty();
+             }
+         } else {
+             if (DoubleMath.fuzzyEquals(this.min(axis), 0.0, ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.COLLISION_EPSILON)) {
+-                ret = tryForceBlock(new SliceShape((VoxelShape)(Object)this, axis, 0));
++                ret = ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.sliceShape((VoxelShape)(Object)this, axis, 0);
+             } else {
+                 ret = Shapes.empty();
+             }
+@@ -179,23 +179,6 @@ public abstract class VoxelShape implements ca.spottedleaf.moonrise.patches.coll
+         return ret;
+     }
+ 
+-    private static VoxelShape tryForceBlock(final VoxelShape other) {
+-        if (other == Shapes.block()) {
+-            return other;
+-        }
+-
+-        final AABB otherAABB = ((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)other).moonrise$getSingleAABBRepresentation();
+-        if (otherAABB == null) {
+-            return other;
+-        }
+-
+-        if (((ca.spottedleaf.moonrise.patches.collisions.shape.CollisionVoxelShape)Shapes.block()).moonrise$getSingleAABBRepresentation().equals(otherAABB)) {
+-            return Shapes.block();
+-        }
+-
+-        return other;
+-    }
+-
+     private boolean computeOccludesFullBlock() {
+         if (this.isEmpty) {
+             this.occludesFullBlock = Boolean.FALSE;
+@@ -293,18 +276,21 @@ public abstract class VoxelShape implements ca.spottedleaf.moonrise.patches.coll
+         return result;
+     }
+ 
+-    private static DoubleList offsetList(final DoubleList src, final double by) {
+-        if (src instanceof OffsetDoubleList offsetDoubleList) {
+-            return new OffsetDoubleList(offsetDoubleList.delegate, by + offsetDoubleList.offset);
++    private static DoubleList offsetList(final double[] src, final double by) {
++        final it.unimi.dsi.fastutil.doubles.DoubleArrayList wrap = it.unimi.dsi.fastutil.doubles.DoubleArrayList.wrap(src);
++        if (by == 0.0) {
++            return wrap;
+         }
+-        return new OffsetDoubleList(src, by);
++        return new OffsetDoubleList(wrap, by);
+     }
+ 
+     private List<AABB> toAabbsUncached() {
+-        final List<AABB> ret = new java.util.ArrayList<>();
++        final List<AABB> ret;
+         if (this.singleAABBRepresentation != null) {
++            ret = new java.util.ArrayList<>(1);
+             ret.add(this.singleAABBRepresentation);
+         } else {
++            ret = new java.util.ArrayList<>();
+             final double[] coordsX = this.rootCoordinatesX;
+             final double[] coordsY = this.rootCoordinatesY;
+             final double[] coordsZ = this.rootCoordinatesZ;
+@@ -426,6 +412,26 @@ public abstract class VoxelShape implements ca.spottedleaf.moonrise.patches.coll
+         final double minDistance = minDistanceArr[0];
+         return new BlockHitResult(from.add(minDistance * diffX, minDistance * diffY, minDistance * diffZ), direction, offset, false);
+     }
++
++    private VoxelShape calculateFaceDirect(final Direction direction, final Direction.Axis axis, final double[] coords, final double offset) {
++        if (coords.length == 2 &&
++            DoubleMath.fuzzyEquals(coords[0] + offset, 0.0, ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.COLLISION_EPSILON) &&
++            DoubleMath.fuzzyEquals(coords[1] + offset, 1.0, ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.COLLISION_EPSILON)) {
++            return (VoxelShape)(Object)this;
++        }
++
++        final boolean positiveDir = direction.getAxisDirection() == Direction.AxisDirection.POSITIVE;
++
++        // see findIndex
++        final int index = ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.findFloor(
++            coords, (positiveDir ? (1.0 - ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.COLLISION_EPSILON) : (0.0 + ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.COLLISION_EPSILON)) - offset,
++            0, coords.length - 1
++        );
++
++        return ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.sliceShape(
++            (VoxelShape)(Object)this, axis, index
++        );
++    }
+     // Paper end - optimise collisions
+ 
+     protected VoxelShape(DiscreteVoxelShape voxels) {
+@@ -517,20 +523,32 @@ public abstract class VoxelShape implements ca.spottedleaf.moonrise.patches.coll
+     }
+ 
+     public VoxelShape singleEncompassing() {
+-        return this.isEmpty()
+-            ? Shapes.empty()
+-            : Shapes.box(
+-                this.min(Direction.Axis.X),
+-                this.min(Direction.Axis.Y),
+-                this.min(Direction.Axis.Z),
+-                this.max(Direction.Axis.X),
+-                this.max(Direction.Axis.Y),
+-                this.max(Direction.Axis.Z)
+-            );
++        // Paper start - optimise collisions
++        if (this.isEmpty) {
++            return Shapes.empty();
++        }
++        return Shapes.create(this.bounds());
++        // Paper end - optimise collisions
+     }
+ 
+     protected double get(Direction.Axis axis, int index) {
+-        return this.getCoords(axis).getDouble(index);
++        // Paper start - optimise collisions
++        final int idx = index;
++        switch (axis) {
++            case X: {
++                return this.rootCoordinatesX[idx] + this.offsetX;
++            }
++            case Y: {
++                return this.rootCoordinatesY[idx] + this.offsetY;
++            }
++            case Z: {
++                return this.rootCoordinatesZ[idx] + this.offsetZ;
++            }
++            default: {
++                throw new IllegalStateException("Unknown axis: " + axis);
++            }
++        }
++        // Paper end - optimise collisions
+     }
+ 
+     public abstract DoubleList getCoords(Direction.Axis axis);
+@@ -547,9 +565,9 @@ public abstract class VoxelShape implements ca.spottedleaf.moonrise.patches.coll
+ 
+         final ArrayVoxelShape ret = new ArrayVoxelShape(
+             this.shape,
+-            offsetList(this.getCoords(Direction.Axis.X), x),
+-            offsetList(this.getCoords(Direction.Axis.Y), y),
+-            offsetList(this.getCoords(Direction.Axis.Z), z)
++            offsetList(this.rootCoordinatesX, this.offsetX + x),
++            offsetList(this.rootCoordinatesY, this.offsetY + y),
++            offsetList(this.rootCoordinatesZ, this.offsetZ + z)
+         );
+ 
+         final ca.spottedleaf.moonrise.patches.collisions.shape.CachedToAABBs cachedToAABBs = this.cachedToAABBs;
+@@ -574,6 +592,11 @@ public abstract class VoxelShape implements ca.spottedleaf.moonrise.patches.coll
+ 
+         final List<AABB> aabbs = this.toAabbs();
+ 
++        if (aabbs.isEmpty()) {
++            // We are a SliceShape, which does not properly fill isEmpty for every case
++            return Shapes.empty();
++        }
++
+         if (aabbs.size() == 1) {
+             final AABB singleAABB = aabbs.get(0);
+             final VoxelShape ret = Shapes.create(singleAABB);
+@@ -700,7 +723,32 @@ public abstract class VoxelShape implements ca.spottedleaf.moonrise.patches.coll
+     }
+ 
+     protected int findIndex(Direction.Axis axis, double coord) {
+-        return Mth.binarySearch(0, this.shape.getSize(axis) + 1, i -> coord < this.get(axis, i)) - 1;
++        // Paper start - optimise collisions
++        final double value = coord;
++        switch (axis) {
++            case X: {
++                final double[] values = this.rootCoordinatesX;
++                return ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.findFloor(
++                    values, value - this.offsetX, 0, values.length - 1
++                );
++            }
++            case Y: {
++                final double[] values = this.rootCoordinatesY;
++                return ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.findFloor(
++                    values, value - this.offsetY, 0, values.length - 1
++                );
++            }
++            case Z: {
++                final double[] values = this.rootCoordinatesZ;
++                return ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.findFloor(
++                    values, value - this.offsetZ, 0, values.length - 1
++                );
++            }
++            default: {
++                throw new IllegalStateException("Unknown axis: " + axis);
++            }
++        }
++        // Paper end - optimise collisions
+     }
+ 
+     @Nullable
+@@ -723,13 +771,13 @@ public abstract class VoxelShape implements ca.spottedleaf.moonrise.patches.coll
+         final AABB singleAABB = this.singleAABBRepresentation;
+         if (singleAABB != null) {
+             if (singleAABB.contains(fromBehindOffsetX, fromBehindOffsetY, fromBehindOffsetZ)) {
+-                return new BlockHitResult(fromBehind, Direction.getNearest(directionOpposite.x, directionOpposite.y, directionOpposite.z).getOpposite(), offset, true);
++                return new BlockHitResult(fromBehind, Direction.getApproximateNearest(directionOpposite.x, directionOpposite.y, directionOpposite.z).getOpposite(), offset, true);
+             }
+             return clip(singleAABB, from, to, offset);
+         }
+ 
+         if (ca.spottedleaf.moonrise.patches.collisions.CollisionUtil.strictlyContains((VoxelShape)(Object)this, fromBehindOffsetX, fromBehindOffsetY, fromBehindOffsetZ)) {
+-            return new BlockHitResult(fromBehind, Direction.getNearest(directionOpposite.x, directionOpposite.y, directionOpposite.z).getOpposite(), offset, true);
++            return new BlockHitResult(fromBehind, Direction.getApproximateNearest(directionOpposite.x, directionOpposite.y, directionOpposite.z).getOpposite(), offset, true);
+         }
+ 
+         return AABB.clip(((VoxelShape)(Object)this).toAabbs(), from, to, offset);
+@@ -783,17 +831,23 @@ public abstract class VoxelShape implements ca.spottedleaf.moonrise.patches.coll
+     }
+ 
+     private VoxelShape calculateFace(Direction direction) {
+-        Direction.Axis axis = direction.getAxis();
+-        DoubleList doubleList = this.getCoords(axis);
+-        if (doubleList.size() == 2
+-            && DoubleMath.fuzzyEquals(doubleList.getDouble(0), 0.0, 1.0E-7)
+-            && DoubleMath.fuzzyEquals(doubleList.getDouble(1), 1.0, 1.0E-7)) {
+-            return this;
+-        } else {
+-            Direction.AxisDirection axisDirection = direction.getAxisDirection();
+-            int i = this.findIndex(axis, axisDirection == Direction.AxisDirection.POSITIVE ? 0.9999999 : 1.0E-7);
+-            return new SliceShape(this, axis, i);
++        // Paper start - optimise collisions
++        final Direction.Axis axis = direction.getAxis();
++        switch (axis) {
++            case X: {
++                return this.calculateFaceDirect(direction, axis, this.rootCoordinatesX, this.offsetX);
++            }
++            case Y: {
++                return this.calculateFaceDirect(direction, axis, this.rootCoordinatesY, this.offsetY);
++            }
++            case Z: {
++                return this.calculateFaceDirect(direction, axis, this.rootCoordinatesZ, this.offsetZ);
++            }
++            default: {
++                throw new IllegalStateException("Unknown axis: " + axis);
++            }
+         }
++        // Paper end - optimise collisions
+     }
+ 
+     // Paper start - optimise collisions