Move patches to unapplied

2024-12-12 12:22:12 +01:00
parent ff75689b08
commit 45ddf764d9
821 changed files with 0 additions and 0 deletions
--- a/paper-server/patches/unapplied/net/minecraft/network/Connection.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/Connection.java.patch
@@ -0,0 +1,330 @@
+--- a/net/minecraft/network/Connection.java
+++ b/net/minecraft/network/Connection.java
+@@ -82,13 +82,13 @@
+         marker.add(Connection.PACKET_MARKER);
+     });
+     public static final Supplier<NioEventLoopGroup> NETWORK_WORKER_GROUP = Suppliers.memoize(() -> {
+-        return new NioEventLoopGroup(0, (new ThreadFactoryBuilder()).setNameFormat("Netty Client IO #%d").setDaemon(true).build());
+        return new NioEventLoopGroup(0, (new ThreadFactoryBuilder()).setNameFormat("Netty Client IO #%d").setDaemon(true).setUncaughtExceptionHandler(new net.minecraft.DefaultUncaughtExceptionHandlerWithName(LOGGER)).build()); // Paper
+     });
+     public static final Supplier<EpollEventLoopGroup> NETWORK_EPOLL_WORKER_GROUP = Suppliers.memoize(() -> {
+-        return new EpollEventLoopGroup(0, (new ThreadFactoryBuilder()).setNameFormat("Netty Epoll Client IO #%d").setDaemon(true).build());
+        return new EpollEventLoopGroup(0, (new ThreadFactoryBuilder()).setNameFormat("Netty Epoll Client IO #%d").setDaemon(true).setUncaughtExceptionHandler(new net.minecraft.DefaultUncaughtExceptionHandlerWithName(LOGGER)).build()); // Paper
+     });
+     public static final Supplier<DefaultEventLoopGroup> LOCAL_WORKER_GROUP = Suppliers.memoize(() -> {
+-        return new DefaultEventLoopGroup(0, (new ThreadFactoryBuilder()).setNameFormat("Netty Local Client IO #%d").setDaemon(true).build());
+        return new DefaultEventLoopGroup(0, (new ThreadFactoryBuilder()).setNameFormat("Netty Local Client IO #%d").setDaemon(true).setUncaughtExceptionHandler(new net.minecraft.DefaultUncaughtExceptionHandlerWithName(LOGGER)).build()); // Paper
+     });
+     private static final ProtocolInfo<ServerHandshakePacketListener> INITIAL_PROTOCOL = HandshakeProtocols.SERVERBOUND;
+     private final PacketFlow receiving;
+@@ -96,6 +96,11 @@
+     private final Queue<Consumer<Connection>> pendingActions = Queues.newConcurrentLinkedQueue();
+     public Channel channel;
+     public SocketAddress address;
+    // Spigot Start
+    public java.util.UUID spoofedUUID;
+    public com.mojang.authlib.properties.Property[] spoofedProfile;
+    public boolean preparing = true;
+    // Spigot End
+     @Nullable
+     private volatile PacketListener disconnectListener;
+     @Nullable
+@@ -114,7 +119,42 @@
+     private volatile DisconnectionDetails delayedDisconnect;
+     @Nullable
+     BandwidthDebugMonitor bandwidthDebugMonitor;
+    public String hostname = ""; // CraftBukkit - add field
+    // Paper start - NetworkClient implementation
+    public int protocolVersion;
+    public java.net.InetSocketAddress virtualHost;
+    private static boolean enableExplicitFlush = Boolean.getBoolean("paper.explicit-flush"); // Paper - Disable explicit network manager flushing
+    // Paper end
+ 
+    // Paper start - add utility methods
+    public final net.minecraft.server.level.ServerPlayer getPlayer() {
+        if (this.packetListener instanceof net.minecraft.server.network.ServerGamePacketListenerImpl impl) {
+            return impl.player;
+        } else if (this.packetListener instanceof net.minecraft.server.network.ServerCommonPacketListenerImpl impl) {
+            org.bukkit.craftbukkit.entity.CraftPlayer player = impl.getCraftPlayer();
+            return player == null ? null : player.getHandle();
+        }
+        return null;
+    }
+    // Paper end - add utility methods
+    // Paper start - packet limiter
+    protected final Object PACKET_LIMIT_LOCK = new Object();
+    protected final @Nullable io.papermc.paper.util.IntervalledCounter allPacketCounts = io.papermc.paper.configuration.GlobalConfiguration.get().packetLimiter.allPackets.isEnabled() ? new io.papermc.paper.util.IntervalledCounter(
+        (long)(io.papermc.paper.configuration.GlobalConfiguration.get().packetLimiter.allPackets.interval() * 1.0e9)
+    ) : null;
+    protected final java.util.Map<Class<? extends net.minecraft.network.protocol.Packet<?>>, io.papermc.paper.util.IntervalledCounter> packetSpecificLimits = new java.util.HashMap<>();
+
+    private boolean stopReadingPackets;
+    private void killForPacketSpam() {
+        this.sendPacket(new ClientboundDisconnectPacket(io.papermc.paper.adventure.PaperAdventure.asVanilla(io.papermc.paper.configuration.GlobalConfiguration.get().packetLimiter.kickMessage)), PacketSendListener.thenRun(() -> {
+            this.disconnect(io.papermc.paper.adventure.PaperAdventure.asVanilla(io.papermc.paper.configuration.GlobalConfiguration.get().packetLimiter.kickMessage));
+        }), true);
+        this.setReadOnly();
+        this.stopReadingPackets = true;
+    }
+    // Paper end - packet limiter
+    @Nullable public SocketAddress haProxyAddress; // Paper - Add API to get player's proxy address
+
+     public Connection(PacketFlow side) {
+         this.receiving = side;
+     }
+@@ -123,6 +163,9 @@
+         super.channelActive(channelhandlercontext);
+         this.channel = channelhandlercontext.channel();
+         this.address = this.channel.remoteAddress();
+        // Spigot Start
+        this.preparing = false;
+        // Spigot End
+         if (this.delayedDisconnect != null) {
+             this.disconnect(this.delayedDisconnect);
+         }
+@@ -134,6 +177,21 @@
+     }
+ 
+     public void exceptionCaught(ChannelHandlerContext channelhandlercontext, Throwable throwable) {
+        // Paper start - Handle large packets disconnecting client
+        if (throwable instanceof io.netty.handler.codec.EncoderException && throwable.getCause() instanceof PacketEncoder.PacketTooLargeException packetTooLargeException) {
+            final Packet<?> packet = packetTooLargeException.getPacket();
+            if (packet.packetTooLarge(this)) {
+                ProtocolSwapHandler.handleOutboundTerminalPacket(channelhandlercontext, packet);
+                return;
+            } else if (packet.isSkippable()) {
+                Connection.LOGGER.debug("Skipping packet due to errors", throwable.getCause());
+                ProtocolSwapHandler.handleOutboundTerminalPacket(channelhandlercontext, packet);
+                return;
+            } else {
+                throwable = throwable.getCause();
+            }
+        }
+        // Paper end - Handle large packets disconnecting client
+         if (throwable instanceof SkipPacketException) {
+             Connection.LOGGER.debug("Skipping packet due to errors", throwable.getCause());
+         } else {
+@@ -141,8 +199,10 @@
+ 
+             this.handlingFault = true;
+             if (this.channel.isOpen()) {
+                net.minecraft.server.level.ServerPlayer player = this.getPlayer(); // Paper - Add API for quit reason
+                 if (throwable instanceof TimeoutException) {
+                     Connection.LOGGER.debug("Timeout", throwable);
+                    if (player != null) player.quitReason = org.bukkit.event.player.PlayerQuitEvent.QuitReason.TIMED_OUT; // Paper - Add API for quit reason
+                     this.disconnect((Component) Component.translatable("disconnect.timeout"));
+                 } else {
+                     MutableComponent ichatmutablecomponent = Component.translatable("disconnect.genericReason", "Internal Exception: " + String.valueOf(throwable));
+@@ -155,9 +215,11 @@
+                         disconnectiondetails = new DisconnectionDetails(ichatmutablecomponent);
+                     }
+ 
+                    if (player != null) player.quitReason = org.bukkit.event.player.PlayerQuitEvent.QuitReason.ERRONEOUS_STATE; // Paper - Add API for quit reason
+                     if (flag) {
+                         Connection.LOGGER.debug("Failed to sent packet", throwable);
+-                        if (this.getSending() == PacketFlow.CLIENTBOUND) {
+                        boolean doesDisconnectExist = this.packetListener.protocol() != ConnectionProtocol.STATUS && this.packetListener.protocol() != ConnectionProtocol.HANDSHAKING; // Paper
+                        if (this.getSending() == PacketFlow.CLIENTBOUND && doesDisconnectExist) { // Paper
+                             Packet<?> packet = this.sendLoginDisconnect ? new ClientboundLoginDisconnectPacket(ichatmutablecomponent) : new ClientboundDisconnectPacket(ichatmutablecomponent);
+ 
+                             this.send((Packet) packet, PacketSendListener.thenRun(() -> {
+@@ -176,6 +238,7 @@
+ 
+             }
+         }
+        if (net.minecraft.server.MinecraftServer.getServer().isDebugging()) io.papermc.paper.util.TraceUtil.printStackTrace(throwable); // Spigot // Paper
+     }
+ 
+     protected void channelRead0(ChannelHandlerContext channelhandlercontext, Packet<?> packet) {
+@@ -185,11 +248,61 @@
+             if (packetlistener == null) {
+                 throw new IllegalStateException("Received a packet before the packet listener was initialized");
+             } else {
+                // Paper start - packet limiter
+                if (this.stopReadingPackets) {
+                    return;
+                }
+                if (this.allPacketCounts != null ||
+                    io.papermc.paper.configuration.GlobalConfiguration.get().packetLimiter.overrides.containsKey(packet.getClass())) {
+                    long time = System.nanoTime();
+                    synchronized (PACKET_LIMIT_LOCK) {
+                        if (this.allPacketCounts != null) {
+                            this.allPacketCounts.updateAndAdd(1, time);
+                            if (this.allPacketCounts.getRate() >= io.papermc.paper.configuration.GlobalConfiguration.get().packetLimiter.allPackets.maxPacketRate()) {
+                                this.killForPacketSpam();
+                                return;
+                            }
+                        }
+
+                        for (Class<?> check = packet.getClass(); check != Object.class; check = check.getSuperclass()) {
+                            io.papermc.paper.configuration.GlobalConfiguration.PacketLimiter.PacketLimit packetSpecificLimit =
+                                io.papermc.paper.configuration.GlobalConfiguration.get().packetLimiter.overrides.get(check);
+                            if (packetSpecificLimit == null || !packetSpecificLimit.isEnabled()) {
+                                continue;
+                            }
+                            io.papermc.paper.util.IntervalledCounter counter = this.packetSpecificLimits.computeIfAbsent((Class)check, (clazz) -> {
+                                return new io.papermc.paper.util.IntervalledCounter((long)(packetSpecificLimit.interval() * 1.0e9));
+                            });
+                            counter.updateAndAdd(1, time);
+                            if (counter.getRate() >= packetSpecificLimit.maxPacketRate()) {
+                                switch (packetSpecificLimit.action()) {
+                                    case DROP:
+                                        return;
+                                    case KICK:
+                                        String deobfedPacketName = io.papermc.paper.util.ObfHelper.INSTANCE.deobfClassName(check.getName());
+
+                                        String playerName;
+                                        if (this.packetListener instanceof net.minecraft.server.network.ServerCommonPacketListenerImpl impl) {
+                                            playerName = impl.getOwner().getName();
+                                        } else {
+                                            playerName = this.getLoggableAddress(net.minecraft.server.MinecraftServer.getServer().logIPs());
+                                        }
+
+                                        Connection.LOGGER.warn("{} kicked for packet spamming: {}", playerName, deobfedPacketName.substring(deobfedPacketName.lastIndexOf(".") + 1));
+                                        this.killForPacketSpam();
+                                        return;
+                                }
+                            }
+                        }
+                    }
+                }
+                // Paper end - packet limiter
+                 if (packetlistener.shouldHandleMessage(packet)) {
+                     try {
+                         Connection.genericsFtw(packet, packetlistener);
+                     } catch (RunningOnDifferentThreadException cancelledpackethandleexception) {
+                         ;
+                    } catch (io.papermc.paper.util.ServerStopRejectedExecutionException ignored) { // Paper - do not prematurely disconnect players on stop
+                     } catch (RejectedExecutionException rejectedexecutionexception) {
+                         this.disconnect((Component) Component.translatable("multiplayer.disconnect.server_shutdown"));
+                     } catch (ClassCastException classcastexception) {
+@@ -205,7 +318,7 @@
+     }
+ 
+     private static <T extends PacketListener> void genericsFtw(Packet<T> packet, PacketListener listener) {
+-        packet.handle(listener);
+        packet.handle((T) listener); // CraftBukkit - decompile error
+     }
+ 
+     private void validateListener(ProtocolInfo<?> state, PacketListener listener) {
+@@ -418,12 +531,26 @@
+         }
+     }
+ 
+    private static final int MAX_PER_TICK = io.papermc.paper.configuration.GlobalConfiguration.get().misc.maxJoinsPerTick; // Paper - Buffer joins to world
+    private static int joinAttemptsThisTick; // Paper - Buffer joins to world
+    private static int currTick; // Paper - Buffer joins to world
+     public void tick() {
+         this.flushQueue();
+        // Paper start - Buffer joins to world
+        if (Connection.currTick != net.minecraft.server.MinecraftServer.currentTick) {
+            Connection.currTick = net.minecraft.server.MinecraftServer.currentTick;
+            Connection.joinAttemptsThisTick = 0;
+        }
+        // Paper end - Buffer joins to world
+         PacketListener packetlistener = this.packetListener;
+ 
+         if (packetlistener instanceof TickablePacketListener tickablepacketlistener) {
+            // Paper start - Buffer joins to world
+            if (!(this.packetListener instanceof net.minecraft.server.network.ServerLoginPacketListenerImpl loginPacketListener)
+                || loginPacketListener.state != net.minecraft.server.network.ServerLoginPacketListenerImpl.State.VERIFYING
+                || Connection.joinAttemptsThisTick++ < MAX_PER_TICK) {
+             tickablepacketlistener.tick();
+            } // Paper end - Buffer joins to world
+         }
+ 
+         if (!this.isConnected() && !this.disconnectionHandled) {
+@@ -431,7 +558,7 @@
+         }
+ 
+         if (this.channel != null) {
+-            this.channel.flush();
+            if (enableExplicitFlush) this.channel.eventLoop().execute(() -> this.channel.flush()); // Paper - Disable explicit network manager flushing; we don't need to explicit flush here, but allow opt in incase issues are found to a better version
+         }
+ 
+         if (this.tickCount++ % 20 == 0) {
+@@ -464,12 +591,15 @@
+     }
+ 
+     public void disconnect(DisconnectionDetails disconnectionInfo) {
+        // Spigot Start
+        this.preparing = false;
+        // Spigot End
+         if (this.channel == null) {
+             this.delayedDisconnect = disconnectionInfo;
+         }
+ 
+         if (this.isConnected()) {
+-            this.channel.close().awaitUninterruptibly();
+            this.channel.close(); // We can't wait as this may be called from an event loop.
+             this.disconnectionDetails = disconnectionInfo;
+         }
+ 
+@@ -537,7 +667,7 @@
+     }
+ 
+     public void configurePacketHandler(ChannelPipeline pipeline) {
+-        pipeline.addLast("hackfix", new ChannelOutboundHandlerAdapter(this) {
+        pipeline.addLast("hackfix", new ChannelOutboundHandlerAdapter() { // CraftBukkit - decompile error
+             public void write(ChannelHandlerContext channelhandlercontext, Object object, ChannelPromise channelpromise) throws Exception {
+                 super.write(channelhandlercontext, object, channelpromise);
+             }
+@@ -613,6 +743,14 @@
+ 
+     }
+ 
+    // Paper start - add proper async disconnect
+    public void enableAutoRead() {
+        if (this.channel != null) {
+            this.channel.config().setAutoRead(true);
+        }
+    }
+    // Paper end - add proper async disconnect
+
+     public void setupCompression(int compressionThreshold, boolean rejectsBadPackets) {
+         if (compressionThreshold >= 0) {
+             ChannelHandler channelhandler = this.channel.pipeline().get("decompress");
+@@ -633,6 +771,7 @@
+             } else {
+                 this.channel.pipeline().addAfter("prepender", "compress", new CompressionEncoder(compressionThreshold));
+             }
+            this.channel.pipeline().fireUserEventTriggered(io.papermc.paper.network.ConnectionEvent.COMPRESSION_THRESHOLD_SET); // Paper - Add Channel initialization listeners
+         } else {
+             if (this.channel.pipeline().get("decompress") instanceof CompressionDecoder) {
+                 this.channel.pipeline().remove("decompress");
+@@ -641,6 +780,7 @@
+             if (this.channel.pipeline().get("compress") instanceof CompressionEncoder) {
+                 this.channel.pipeline().remove("compress");
+             }
+            this.channel.pipeline().fireUserEventTriggered(io.papermc.paper.network.ConnectionEvent.COMPRESSION_DISABLED); // Paper - Add Channel initialization listeners
+         }
+ 
+     }
+@@ -661,6 +801,27 @@
+ 
+                     packetlistener1.onDisconnect(disconnectiondetails);
+                 }
+                this.pendingActions.clear(); // Free up packet queue.
+                // Paper start - Add PlayerConnectionCloseEvent
+                final PacketListener packetListener = this.getPacketListener();
+                if (packetListener instanceof net.minecraft.server.network.ServerCommonPacketListenerImpl commonPacketListener) {
+                    /* Player was logged in, either game listener or configuration listener */
+                    final com.mojang.authlib.GameProfile profile = commonPacketListener.getOwner();
+                    new com.destroystokyo.paper.event.player.PlayerConnectionCloseEvent(profile.getId(),
+                        profile.getName(), ((InetSocketAddress) this.address).getAddress(), false).callEvent();
+                } else if (packetListener instanceof net.minecraft.server.network.ServerLoginPacketListenerImpl loginListener) {
+                    /* Player is login stage */
+                    switch (loginListener.state) {
+                        case VERIFYING:
+                        case WAITING_FOR_DUPE_DISCONNECT:
+                        case PROTOCOL_SWITCHING:
+                        case ACCEPTED:
+                            final com.mojang.authlib.GameProfile profile = loginListener.authenticatedProfile; /* Should be non-null at this stage */
+                            new com.destroystokyo.paper.event.player.PlayerConnectionCloseEvent(profile.getId(), profile.getName(),
+                                ((InetSocketAddress) this.address).getAddress(), false).callEvent();
+                    }
+                }
+                // Paper end - Add PlayerConnectionCloseEvent
+ 
+             }
+         }
--- a/paper-server/patches/unapplied/net/minecraft/network/FriendlyByteBuf.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/FriendlyByteBuf.java.patch
@@ -0,0 +1,105 @@
+--- a/net/minecraft/network/FriendlyByteBuf.java
+++ b/net/minecraft/network/FriendlyByteBuf.java
+@@ -72,6 +72,7 @@
+ 
+     public static final int DEFAULT_NBT_QUOTA = 2097152;
+     private final ByteBuf source;
+    @Nullable public final java.util.Locale adventure$locale; // Paper - track player's locale for server-side translations
+     public static final short MAX_STRING_LENGTH = Short.MAX_VALUE;
+     public static final int MAX_COMPONENT_STRING_LENGTH = 262144;
+     private static final int PUBLIC_KEY_SIZE = 256;
+@@ -80,6 +81,7 @@
+     private static final Gson GSON = new Gson();
+ 
+     public FriendlyByteBuf(ByteBuf parent) {
+        this.adventure$locale = PacketEncoder.ADVENTURE_LOCALE.get(); // Paper - track player's locale for server-side translations
+         this.source = parent;
+     }
+ 
+@@ -120,11 +122,16 @@
+     }
+ 
+     public <T> void writeJsonWithCodec(Codec<T> codec, T value) {
+        // Paper start - Adventure; add max length parameter
+        this.writeJsonWithCodec(codec, value, MAX_STRING_LENGTH);
+    }
+    public <T> void writeJsonWithCodec(Codec<T> codec, T value, int maxLength) {
+        // Paper end - Adventure; add max length parameter
+         DataResult<JsonElement> dataresult = codec.encodeStart(JsonOps.INSTANCE, value);
+ 
+         this.writeUtf(FriendlyByteBuf.GSON.toJson((JsonElement) dataresult.getOrThrow((s) -> {
+             return new EncoderException("Failed to encode: " + s + " " + String.valueOf(value));
+-        })));
+        })), maxLength); // Paper - Adventure; add max length parameter
+     }
+ 
+     public static <T> IntFunction<T> limitValue(IntFunction<T> applier, int max) {
+@@ -139,7 +146,7 @@
+ 
+     public <T, C extends Collection<T>> C readCollection(IntFunction<C> collectionFactory, StreamDecoder<? super FriendlyByteBuf, T> reader) {
+         int i = this.readVarInt();
+-        C c0 = (Collection) collectionFactory.apply(i);
+        C c0 = collectionFactory.apply(i); // CraftBukkit - decompile error
+ 
+         for (int j = 0; j < i; ++j) {
+             c0.add(reader.decode(this));
+@@ -150,7 +157,7 @@
+ 
+     public <T> void writeCollection(Collection<T> collection, StreamEncoder<? super FriendlyByteBuf, T> writer) {
+         this.writeVarInt(collection.size());
+-        Iterator iterator = collection.iterator();
+        Iterator<T> iterator = collection.iterator(); // CraftBukkit - decompile error
+ 
+         while (iterator.hasNext()) {
+             T t0 = iterator.next();
+@@ -177,12 +184,12 @@
+ 
+     public void writeIntIdList(IntList list) {
+         this.writeVarInt(list.size());
+-        list.forEach(this::writeVarInt);
+        list.forEach((java.util.function.IntConsumer) this::writeVarInt); // CraftBukkit - decompile error
+     }
+ 
+     public <K, V, M extends Map<K, V>> M readMap(IntFunction<M> mapFactory, StreamDecoder<? super FriendlyByteBuf, K> keyReader, StreamDecoder<? super FriendlyByteBuf, V> valueReader) {
+         int i = this.readVarInt();
+-        M m0 = (Map) mapFactory.apply(i);
+        M m0 = mapFactory.apply(i); // CraftBukkit - decompile error
+ 
+         for (int j = 0; j < i; ++j) {
+             K k0 = keyReader.decode(this);
+@@ -216,7 +223,7 @@
+     }
+ 
+     public <E extends Enum<E>> void writeEnumSet(EnumSet<E> enumSet, Class<E> type) {
+-        E[] ae = (Enum[]) type.getEnumConstants();
+        E[] ae = type.getEnumConstants(); // CraftBukkit - decompile error
+         BitSet bitset = new BitSet(ae.length);
+ 
+         for (int i = 0; i < ae.length; ++i) {
+@@ -227,7 +234,7 @@
+     }
+ 
+     public <E extends Enum<E>> EnumSet<E> readEnumSet(Class<E> type) {
+-        E[] ae = (Enum[]) type.getEnumConstants();
+        E[] ae = type.getEnumConstants(); // CraftBukkit - decompile error
+         BitSet bitset = this.readFixedBitSet(ae.length);
+         EnumSet<E> enumset = EnumSet.noneOf(type);
+ 
+@@ -498,7 +505,7 @@
+     }
+ 
+     public <T extends Enum<T>> T readEnum(Class<T> enumClass) {
+-        return ((Enum[]) enumClass.getEnumConstants())[this.readVarInt()];
+        return ((T[]) enumClass.getEnumConstants())[this.readVarInt()]; // CraftBukkit - fix decompile error
+     }
+ 
+     public FriendlyByteBuf writeEnum(Enum<?> instance) {
+@@ -565,7 +572,7 @@
+ 
+         try {
+             NbtIo.writeAnyTag((Tag) nbt, new ByteBufOutputStream(buf));
+-        } catch (IOException ioexception) {
+        } catch (Exception ioexception) { // CraftBukkit - IOException -> Exception
+             throw new EncoderException(ioexception);
+         }
+     }
--- a/paper-server/patches/unapplied/net/minecraft/network/PacketEncoder.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/PacketEncoder.java.patch
@@ -0,0 +1,57 @@
+--- a/net/minecraft/network/PacketEncoder.java
+++ b/net/minecraft/network/PacketEncoder.java
+@@ -17,10 +17,12 @@
+         this.protocolInfo = state;
+     }
+ 
+    static final ThreadLocal<java.util.Locale> ADVENTURE_LOCALE = ThreadLocal.withInitial(() -> null); // Paper - adventure; set player's locale
+     protected void encode(ChannelHandlerContext channelHandlerContext, Packet<T> packet, ByteBuf byteBuf) throws Exception {
+         PacketType<? extends Packet<? super T>> packetType = packet.type();
+ 
+         try {
+            ADVENTURE_LOCALE.set(channelHandlerContext.channel().attr(io.papermc.paper.adventure.PaperAdventure.LOCALE_ATTRIBUTE).get()); // Paper - adventure; set player's locale
+             this.protocolInfo.codec().encode(byteBuf, packet);
+             int i = byteBuf.readableBytes();
+             if (LOGGER.isDebugEnabled()) {
+@@ -31,14 +33,40 @@
+ 
+             JvmProfiler.INSTANCE.onPacketSent(this.protocolInfo.id(), packetType, channelHandlerContext.channel().remoteAddress(), i);
+         } catch (Throwable var9) {
+-            LOGGER.error("Error sending packet {}", packetType, var9);
+            LOGGER.error("Error sending packet {} (skippable? {})", packetType, packet.isSkippable(), var9);
+             if (packet.isSkippable()) {
+                 throw new SkipPacketException(var9);
+             }
+ 
+             throw var9;
+         } finally {
+            // Paper start - Handle large packets disconnecting client
+            int packetLength = byteBuf.readableBytes();
+            if (packetLength > MAX_PACKET_SIZE || (packetLength > MAX_FINAL_PACKET_SIZE && packet.hasLargePacketFallback())) {
+                throw new PacketTooLargeException(packet, packetLength);
+            }
+            // Paper end - Handle large packets disconnecting client
+             ProtocolSwapHandler.handleOutboundTerminalPacket(channelHandlerContext, packet);
+         }
+     }
+
+    // Paper start
+    // packet size is encoded into 3-byte varint
+    private static final int MAX_FINAL_PACKET_SIZE = (1 << 21) - 1;
+    // Vanilla Max size for the encoder (before compression)
+    private static final int MAX_PACKET_SIZE = 8388608;
+
+    public static class PacketTooLargeException extends RuntimeException {
+        private final Packet<?> packet;
+
+        PacketTooLargeException(Packet<?> packet, int packetLength) {
+            super("PacketTooLarge - " + packet.getClass().getSimpleName() + " is " + packetLength + ". Max is " + MAX_PACKET_SIZE);
+            this.packet = packet;
+        }
+
+        public Packet<?> getPacket() {
+            return this.packet;
+        }
+    }
+    // Paper end
+ }
--- a/paper-server/patches/unapplied/net/minecraft/network/VarInt.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/VarInt.java.patch
@@ -0,0 +1,43 @@
+--- a/net/minecraft/network/VarInt.java
+++ b/net/minecraft/network/VarInt.java
+@@ -9,6 +9,18 @@
+     private static final int DATA_BITS_PER_BYTE = 7;
+ 
+     public static int getByteSize(int i) {
+    // Paper start - Optimize VarInts
+        return VARINT_EXACT_BYTE_LENGTHS[Integer.numberOfLeadingZeros(i)];
+    }
+    private static final int[] VARINT_EXACT_BYTE_LENGTHS = new int[33];
+    static {
+        for (int i = 0; i <= 32; ++i) {
+            VARINT_EXACT_BYTE_LENGTHS[i] = (int) Math.ceil((31d - (i - 1)) / 7d);
+        }
+        VARINT_EXACT_BYTE_LENGTHS[32] = 1; // Special case for the number 0.
+    }
+    public static int getByteSizeOld(int i) {
+    // Paper end - Optimize VarInts
+         for (int j = 1; j < 5; j++) {
+             if ((i & -1 << j * 7) == 0) {
+                 return j;
+@@ -39,6 +51,21 @@
+     }
+ 
+     public static ByteBuf write(ByteBuf buf, int i) {
+     // Paper start - Optimize VarInts
+        // Peel the one and two byte count cases explicitly as they are the most common VarInt sizes
+        // that the proxy will write, to improve inlining.
+        if ((i & (0xFFFFFFFF << 7)) == 0) {
+            buf.writeByte(i);
+        } else if ((i & (0xFFFFFFFF << 14)) == 0) {
+            int w = (i & 0x7F | 0x80) << 8 | (i >>> 7);
+            buf.writeShort(w);
+        } else {
+            writeOld(buf, i);
+        }
+        return buf;
+    }
+    public static ByteBuf writeOld(ByteBuf buf, int i) {
+    // Paper end - Optimize VarInts
+         while ((i & -128) != 0) {
+             buf.writeByte(i & 127 | 128);
+             i >>>= 7;
--- a/paper-server/patches/unapplied/net/minecraft/network/Varint21FrameDecoder.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/Varint21FrameDecoder.java.patch
@@ -0,0 +1,15 @@
+--- a/net/minecraft/network/Varint21FrameDecoder.java
+++ b/net/minecraft/network/Varint21FrameDecoder.java
+@@ -39,6 +39,12 @@
+     }
+ 
+     protected void decode(ChannelHandlerContext channelHandlerContext, ByteBuf byteBuf, List<Object> list) {
+        // Paper start - Perf: Optimize exception handling; if channel is not active just discard the packet
+        if (!channelHandlerContext.channel().isActive()) {
+            byteBuf.skipBytes(byteBuf.readableBytes());
+            return;
+        }
+        // Paper end - Perf: Optimize exception handling
+         byteBuf.markReaderIndex();
+         this.helperBuf.clear();
+         if (!copyVarint(byteBuf, this.helperBuf)) {
--- a/paper-server/patches/unapplied/net/minecraft/network/chat/ChatDecorator.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/chat/ChatDecorator.java.patch
@@ -0,0 +1,23 @@
+--- a/net/minecraft/network/chat/ChatDecorator.java
+++ b/net/minecraft/network/chat/ChatDecorator.java
+@@ -2,10 +2,18 @@
+ 
+ import javax.annotation.Nullable;
+ import net.minecraft.server.level.ServerPlayer;
+import java.util.concurrent.CompletableFuture; // Paper
+ 
+ @FunctionalInterface
+ public interface ChatDecorator {
+-    ChatDecorator PLAIN = (sender, message) -> message;
+    ChatDecorator PLAIN = (sender, message) -> CompletableFuture.completedFuture(message); // Paper - adventure; support async chat decoration events
+ 
+-    Component decorate(@Nullable ServerPlayer sender, Component message);
+    @io.papermc.paper.annotation.DoNotUse @Deprecated // Paper - adventure; support chat decoration events (callers should use the overload with CommandSourceStack)
+    CompletableFuture<Component> decorate(@Nullable ServerPlayer sender, Component message); // Paper - adventure; support async chat decoration events
+
+    // Paper start - adventure; support async chat decoration events
+    default CompletableFuture<Component> decorate(@Nullable ServerPlayer sender, @Nullable net.minecraft.commands.CommandSourceStack commandSourceStack, Component message) {
+        throw new UnsupportedOperationException("Must override this implementation");
+    }
+    // Paper end - adventure; support async chat decoration events
+ }
--- a/paper-server/patches/unapplied/net/minecraft/network/chat/Component.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/chat/Component.java.patch
@@ -0,0 +1,27 @@
+--- a/net/minecraft/network/chat/Component.java
+++ b/net/minecraft/network/chat/Component.java
+@@ -37,9 +37,23 @@
+ import net.minecraft.resources.ResourceLocation;
+ import net.minecraft.util.FormattedCharSequence;
+ import net.minecraft.world.level.ChunkPos;
+// CraftBukkit start
+import java.util.stream.Stream;
+// CraftBukkit end
+ 
+-public interface Component extends Message, FormattedText {
+public interface Component extends Message, FormattedText, Iterable<Component> { // CraftBukkit
+
+    // CraftBukkit start
+    default Stream<Component> stream() {
+        return com.google.common.collect.Streams.concat(new Stream[]{Stream.of(this), this.getSiblings().stream().flatMap(Component::stream)});
+    }
+ 
+    @Override
+    default Iterator<Component> iterator() {
+        return this.stream().iterator();
+    }
+    // CraftBukkit end
+
+     Style getStyle();
+ 
+     ComponentContents getContents();
--- a/paper-server/patches/unapplied/net/minecraft/network/chat/ComponentSerialization.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/chat/ComponentSerialization.java.patch
@@ -0,0 +1,99 @@
+--- a/net/minecraft/network/chat/ComponentSerialization.java
+++ b/net/minecraft/network/chat/ComponentSerialization.java
+@@ -37,9 +37,31 @@
+ 
+ public class ComponentSerialization {
+     public static final Codec<Component> CODEC = Codec.recursive("Component", ComponentSerialization::createCodec);
+-    public static final StreamCodec<RegistryFriendlyByteBuf, Component> STREAM_CODEC = ByteBufCodecs.fromCodecWithRegistries(CODEC);
+    public static final StreamCodec<RegistryFriendlyByteBuf, Component> STREAM_CODEC = createTranslationAware(() -> net.minecraft.nbt.NbtAccounter.create(net.minecraft.network.FriendlyByteBuf.DEFAULT_NBT_QUOTA)); // Paper - adventure
+     public static final StreamCodec<RegistryFriendlyByteBuf, Optional<Component>> OPTIONAL_STREAM_CODEC = STREAM_CODEC.apply(ByteBufCodecs::optional);
+-    public static final StreamCodec<RegistryFriendlyByteBuf, Component> TRUSTED_STREAM_CODEC = ByteBufCodecs.fromCodecWithRegistriesTrusted(CODEC);
+    // Paper start - adventure; use locale from bytebuf for translation
+    public static final ThreadLocal<Boolean> DONT_RENDER_TRANSLATABLES = ThreadLocal.withInitial(() -> false);
+    public static final StreamCodec<RegistryFriendlyByteBuf, Component> TRUSTED_STREAM_CODEC = createTranslationAware(net.minecraft.nbt.NbtAccounter::unlimitedHeap);
+    private static StreamCodec<RegistryFriendlyByteBuf, Component> createTranslationAware(final Supplier<net.minecraft.nbt.NbtAccounter> sizeTracker) {
+        return new StreamCodec<>() {
+            final StreamCodec<ByteBuf, net.minecraft.nbt.Tag> streamCodec = ByteBufCodecs.tagCodec(sizeTracker);
+            @Override
+            public Component decode(RegistryFriendlyByteBuf registryFriendlyByteBuf) {
+                net.minecraft.nbt.Tag tag = this.streamCodec.decode(registryFriendlyByteBuf);
+                RegistryOps<net.minecraft.nbt.Tag> registryOps = registryFriendlyByteBuf.registryAccess().createSerializationContext(net.minecraft.nbt.NbtOps.INSTANCE);
+                return CODEC.parse(registryOps, tag).getOrThrow(error -> new io.netty.handler.codec.DecoderException("Failed to decode: " + error + " " + tag));
+            }
+
+            @Override
+            public void encode(RegistryFriendlyByteBuf registryFriendlyByteBuf, Component object) {
+                RegistryOps<net.minecraft.nbt.Tag> registryOps = registryFriendlyByteBuf.registryAccess().createSerializationContext(net.minecraft.nbt.NbtOps.INSTANCE);
+                net.minecraft.nbt.Tag tag = (DONT_RENDER_TRANSLATABLES.get() ? CODEC : ComponentSerialization.localizedCodec(registryFriendlyByteBuf.adventure$locale))
+                    .encodeStart(registryOps, object).getOrThrow(error -> new io.netty.handler.codec.EncoderException("Failed to encode: " + error + " " + object));
+                this.streamCodec.encode(registryFriendlyByteBuf, tag);
+            }
+        };
+    }
+    // Paper end - adventure; use locale from bytebuf for translation
+     public static final StreamCodec<RegistryFriendlyByteBuf, Optional<Component>> TRUSTED_OPTIONAL_STREAM_CODEC = TRUSTED_STREAM_CODEC.apply(
+         ByteBufCodecs::optional
+     );
+@@ -100,7 +122,27 @@
+         return ExtraCodecs.orCompressed(mapCodec3, mapCodec2);
+     }
+ 
+    // Paper start - adventure; create separate codec for each locale
+    private static final java.util.Map<java.util.Locale, Codec<Component>> LOCALIZED_CODECS = new java.util.concurrent.ConcurrentHashMap<>();
+
+    public static Codec<Component> localizedCodec(final java.util.@org.checkerframework.checker.nullness.qual.Nullable Locale locale) {
+        if (locale == null) {
+            return CODEC;
+        }
+        return LOCALIZED_CODECS.computeIfAbsent(locale,
+            loc -> Codec.recursive("Component", selfCodec -> createCodec(selfCodec, loc)));
+    }
+
+
+    // Paper end - adventure; create separate codec for each locale
+
+     private static Codec<Component> createCodec(Codec<Component> selfCodec) {
+        // Paper start - adventure; create separate codec for each locale
+        return createCodec(selfCodec, null);
+    }
+
+    private static Codec<Component> createCodec(Codec<Component> selfCodec, @javax.annotation.Nullable java.util.Locale locale) {
+        // Paper end - adventure; create separate codec for each locale
+         ComponentContents.Type<?>[] types = new ComponentContents.Type[]{
+             PlainTextContents.TYPE, TranslatableContents.TYPE, KeybindContents.TYPE, ScoreContents.TYPE, SelectorContents.TYPE, NbtContents.TYPE
+         };
+@@ -113,6 +155,34 @@
+                     )
+                     .apply(instance, MutableComponent::new)
+         );
+        // Paper start - adventure; create separate codec for each locale
+        final Codec<Component> origCodec = codec;
+        codec = new Codec<>() {
+            @Override
+            public <T> DataResult<com.mojang.datafixers.util.Pair<Component, T>> decode(final DynamicOps<T> ops, final T input) {
+                return origCodec.decode(ops, input);
+            }
+
+            @Override
+            public <T> DataResult<T> encode(final Component input, final DynamicOps<T> ops, final T prefix) {
+                final net.kyori.adventure.text.Component adventureComponent;
+                if (input instanceof io.papermc.paper.adventure.AdventureComponent adv) {
+                    adventureComponent = adv.adventure$component();
+                } else if (locale != null && input.getContents() instanceof TranslatableContents && io.papermc.paper.adventure.PaperAdventure.hasAnyTranslations()) {
+                    adventureComponent = io.papermc.paper.adventure.PaperAdventure.asAdventure(input);
+                } else {
+                    return origCodec.encode(input, ops, prefix);
+                }
+                return io.papermc.paper.adventure.PaperAdventure.localizedCodec(locale)
+                    .encode(adventureComponent, ops, prefix);
+            }
+
+            @Override
+            public String toString() {
+                return origCodec.toString() + "[AdventureComponentAware]";
+            }
+        };
+        // Paper end - adventure; create separate codec for each locale
+         return Codec.either(Codec.either(Codec.STRING, ExtraCodecs.nonEmptyList(selfCodec.listOf())), codec)
+             .xmap(either -> either.map(either2 -> either2.map(Component::literal, ComponentSerialization::createFromList), text -> (Component)text), text -> {
+                 String string = text.tryCollapseToString();
--- a/paper-server/patches/unapplied/net/minecraft/network/chat/ComponentUtils.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/chat/ComponentUtils.java.patch
@@ -0,0 +1,42 @@
+--- a/net/minecraft/network/chat/ComponentUtils.java
+++ b/net/minecraft/network/chat/ComponentUtils.java
+@@ -33,14 +33,39 @@
+         }
+     }
+ 
+    @io.papermc.paper.annotation.DoNotUse // Paper - validate separators - right now this method is only used for separator evaluation. Error on build if this changes to re-evaluate.
+     public static Optional<MutableComponent> updateForEntity(@Nullable CommandSourceStack source, Optional<Component> text, @Nullable Entity sender, int depth) throws CommandSyntaxException {
+         return text.isPresent() ? Optional.of(updateForEntity(source, text.get(), sender, depth)) : Optional.empty();
+     }
+ 
+    // Paper start - validate separator
+    public static Optional<MutableComponent> updateSeparatorForEntity(@Nullable CommandSourceStack source, Optional<Component> text, @Nullable Entity sender, int depth) throws CommandSyntaxException {
+        if (text.isEmpty() || !isValidSelector(text.get())) return Optional.empty();
+        return Optional.of(updateForEntity(source, text.get(), sender, depth));
+    }
+    public static boolean isValidSelector(final Component component) {
+        final ComponentContents contents = component.getContents();
+
+        if (contents instanceof net.minecraft.network.chat.contents.NbtContents || contents instanceof net.minecraft.network.chat.contents.SelectorContents) return false;
+        if (contents instanceof final net.minecraft.network.chat.contents.TranslatableContents translatableContents) {
+            for (final Object arg : translatableContents.getArgs()) {
+                if (arg instanceof final Component argumentAsComponent && !isValidSelector(argumentAsComponent)) return false;
+            }
+        }
+
+        return true;
+    }
+    // Paper end - validate separator
+
+     public static MutableComponent updateForEntity(@Nullable CommandSourceStack source, Component text, @Nullable Entity sender, int depth) throws CommandSyntaxException {
+         if (depth > 100) {
+             return text.copy();
+         } else {
+            // Paper start - adventure; pass actual vanilla component
+            if (text instanceof io.papermc.paper.adventure.AdventureComponent adventureComponent) {
+                text = adventureComponent.deepConverted();
+            }
+            // Paper end - adventure; pass actual vanilla component
+             MutableComponent mutableComponent = text.getContents().resolve(source, sender, depth + 1);
+ 
+             for (Component component : text.getSiblings()) {
--- a/paper-server/patches/unapplied/net/minecraft/network/chat/MessageSignature.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/chat/MessageSignature.java.patch
@@ -0,0 +1,10 @@
+--- a/net/minecraft/network/chat/MessageSignature.java
+++ b/net/minecraft/network/chat/MessageSignature.java
+@@ -13,6 +13,7 @@
+ import net.minecraft.util.SignatureValidator;
+ 
+ public record MessageSignature(byte[] bytes) {
+    public net.kyori.adventure.chat.SignedMessage.Signature adventure() { return () -> this.bytes; } // Paper - adventure; support signed messages
+     public static final Codec<MessageSignature> CODEC = ExtraCodecs.BASE64_STRING.xmap(MessageSignature::new, MessageSignature::bytes);
+     public static final int BYTES = 256;
+ 
--- a/paper-server/patches/unapplied/net/minecraft/network/chat/MutableComponent.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/chat/MutableComponent.java.patch
@@ -0,0 +1,14 @@
+--- a/net/minecraft/network/chat/MutableComponent.java
+++ b/net/minecraft/network/chat/MutableComponent.java
+@@ -94,6 +94,11 @@
+ 
+     @Override
+     public boolean equals(Object object) {
+        // Paper start - make AdventureComponent equivalent
+        if (object instanceof io.papermc.paper.adventure.AdventureComponent adventureComponent) {
+            object = adventureComponent.deepConverted();
+        }
+        // Paper end - make AdventureComponent equivalent
+         return this == object
+             || object instanceof MutableComponent mutableComponent
+                 && this.contents.equals(mutableComponent.contents)
--- a/paper-server/patches/unapplied/net/minecraft/network/chat/OutgoingChatMessage.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/chat/OutgoingChatMessage.java.patch
@@ -0,0 +1,44 @@
+--- a/net/minecraft/network/chat/OutgoingChatMessage.java
+++ b/net/minecraft/network/chat/OutgoingChatMessage.java
+@@ -7,6 +7,12 @@
+ 
+     void sendToPlayer(ServerPlayer sender, boolean filterMaskEnabled, ChatType.Bound params);
+ 
+    // Paper start
+    default void sendToPlayer(ServerPlayer sender, boolean filterMaskEnabled, ChatType.Bound params, @javax.annotation.Nullable Component unsigned) {
+        this.sendToPlayer(sender, filterMaskEnabled, params);
+    }
+    // Paper end
+
+     static OutgoingChatMessage create(PlayerChatMessage message) {
+         return (OutgoingChatMessage)(message.isSystem()
+             ? new OutgoingChatMessage.Disguised(message.decoratedContent())
+@@ -16,8 +22,13 @@
+     public static record Disguised(@Override Component content) implements OutgoingChatMessage {
+         @Override
+         public void sendToPlayer(ServerPlayer sender, boolean filterMaskEnabled, ChatType.Bound params) {
+-            sender.connection.sendDisguisedChatMessage(this.content, params);
+           // Paper start
+            this.sendToPlayer(sender, filterMaskEnabled, params, null);
+         }
+        public void sendToPlayer(ServerPlayer sender, boolean filterMaskEnabled, ChatType.Bound params, @javax.annotation.Nullable Component unsigned) {
+            sender.connection.sendDisguisedChatMessage(unsigned != null ? unsigned : this.content, params);
+            // Paper end
+        }
+     }
+ 
+     public static record Player(PlayerChatMessage message) implements OutgoingChatMessage {
+@@ -28,7 +39,13 @@
+ 
+         @Override
+         public void sendToPlayer(ServerPlayer sender, boolean filterMaskEnabled, ChatType.Bound params) {
+            // Paper start
+            this.sendToPlayer(sender, filterMaskEnabled, params, null);
+        }
+        public void sendToPlayer(ServerPlayer sender, boolean filterMaskEnabled, ChatType.Bound params, @javax.annotation.Nullable Component unsigned) {
+            // Paper end
+             PlayerChatMessage playerChatMessage = this.message.filter(filterMaskEnabled);
+            playerChatMessage = unsigned != null ? playerChatMessage.withUnsignedContent(unsigned) : playerChatMessage; // Paper
+             if (!playerChatMessage.isFullyFiltered()) {
+                 sender.connection.sendPlayerChatMessage(playerChatMessage, params);
+             }
--- a/paper-server/patches/unapplied/net/minecraft/network/chat/PlayerChatMessage.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/chat/PlayerChatMessage.java.patch
@@ -0,0 +1,61 @@
+--- a/net/minecraft/network/chat/PlayerChatMessage.java
+++ b/net/minecraft/network/chat/PlayerChatMessage.java
+@@ -17,6 +17,42 @@
+ public record PlayerChatMessage(
+     SignedMessageLink link, @Nullable MessageSignature signature, SignedMessageBody signedBody, @Nullable Component unsignedContent, FilterMask filterMask
+ ) {
+    // Paper start - adventure; support signed messages
+    public final class AdventureView implements net.kyori.adventure.chat.SignedMessage {
+        private AdventureView() {
+        }
+        @Override
+        public @org.jetbrains.annotations.NotNull Instant timestamp() {
+            return PlayerChatMessage.this.timeStamp();
+        }
+        @Override
+        public long salt() {
+            return PlayerChatMessage.this.salt();
+        }
+        @Override
+        public @org.jetbrains.annotations.Nullable Signature signature() {
+            return PlayerChatMessage.this.signature == null ? null : PlayerChatMessage.this.signature.adventure();
+        }
+        @Override
+        public net.kyori.adventure.text.@org.jetbrains.annotations.Nullable Component unsignedContent() {
+            return PlayerChatMessage.this.unsignedContent() == null ? null : io.papermc.paper.adventure.PaperAdventure.asAdventure(PlayerChatMessage.this.unsignedContent());
+        }
+        @Override
+        public @org.jetbrains.annotations.NotNull String message() {
+            return PlayerChatMessage.this.signedContent();
+        }
+        @Override
+        public @org.jetbrains.annotations.NotNull net.kyori.adventure.identity.Identity identity() {
+            return net.kyori.adventure.identity.Identity.identity(PlayerChatMessage.this.sender());
+        }
+        public PlayerChatMessage playerChatMessage() {
+            return PlayerChatMessage.this;
+        }
+    }
+    public AdventureView adventureView() {
+        return new AdventureView();
+    }
+    // Paper end - adventure; support signed messages
+     public static final MapCodec<PlayerChatMessage> MAP_CODEC = RecordCodecBuilder.mapCodec(
+         instance -> instance.group(
+                     SignedMessageLink.CODEC.fieldOf("link").forGetter(PlayerChatMessage::link),
+@@ -47,7 +83,14 @@
+     }
+ 
+     public PlayerChatMessage withUnsignedContent(Component unsignedContent) {
+-        Component component = !unsignedContent.equals(Component.literal(this.signedContent())) ? unsignedContent : null;
+        // Paper start - adventure
+        final Component component;
+        if (unsignedContent instanceof io.papermc.paper.adventure.AdventureComponent advComponent) {
+            component = this.signedContent().equals(io.papermc.paper.adventure.AdventureCodecs.tryCollapseToString(advComponent.adventure$component())) ? null : unsignedContent;
+        } else {
+            component = !unsignedContent.equals(Component.literal(this.signedContent())) ? unsignedContent : null;
+        }
+        // Paper end - adventure
+         return new PlayerChatMessage(this.link, this.signature, this.signedBody, component, this.filterMask);
+     }
+ 
--- a/paper-server/patches/unapplied/net/minecraft/network/chat/SignedMessageChain.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/chat/SignedMessageChain.java.patch
@@ -0,0 +1,37 @@
+--- a/net/minecraft/network/chat/SignedMessageChain.java
+++ b/net/minecraft/network/chat/SignedMessageChain.java
+@@ -40,14 +40,14 @@
+                 if (signature == null) {
+                     throw new SignedMessageChain.DecodeException(SignedMessageChain.DecodeException.MISSING_PROFILE_KEY);
+                 } else if (playerPublicKey.data().hasExpired()) {
+-                    throw new SignedMessageChain.DecodeException(SignedMessageChain.DecodeException.EXPIRED_PROFILE_KEY);
+                    throw new SignedMessageChain.DecodeException(SignedMessageChain.DecodeException.EXPIRED_PROFILE_KEY,  org.bukkit.event.player.PlayerKickEvent.Cause.EXPIRED_PROFILE_PUBLIC_KEY); // Paper - kick event causes
+                 } else {
+                     SignedMessageLink signedMessageLink = SignedMessageChain.this.nextLink;
+                     if (signedMessageLink == null) {
+                         throw new SignedMessageChain.DecodeException(SignedMessageChain.DecodeException.CHAIN_BROKEN);
+                     } else if (body.timeStamp().isBefore(SignedMessageChain.this.lastTimeStamp)) {
+                         this.setChainBroken();
+-                        throw new SignedMessageChain.DecodeException(SignedMessageChain.DecodeException.OUT_OF_ORDER_CHAT);
+                        throw new SignedMessageChain.DecodeException(SignedMessageChain.DecodeException.OUT_OF_ORDER_CHAT, org.bukkit.event.player.PlayerKickEvent.Cause.OUT_OF_ORDER_CHAT); // Paper - kick event causes
+                     } else {
+                         SignedMessageChain.this.lastTimeStamp = body.timeStamp();
+                         PlayerChatMessage playerChatMessage = new PlayerChatMessage(signedMessageLink, signature, body, null, FilterMask.PASS_THROUGH);
+@@ -80,9 +80,16 @@
+         static final Component INVALID_SIGNATURE = Component.translatable("chat.disabled.invalid_signature");
+         static final Component OUT_OF_ORDER_CHAT = Component.translatable("chat.disabled.out_of_order_chat");
+ 
+-        public DecodeException(Component message) {
+        // Paper start
+        public final org.bukkit.event.player.PlayerKickEvent.Cause kickCause;
+        public DecodeException(Component message, org.bukkit.event.player.PlayerKickEvent.Cause event) {
+             super(message);
+            this.kickCause = event;
+         }
+        // Paper end
+        public DecodeException(Component message) {
+            this(message, org.bukkit.event.player.PlayerKickEvent.Cause.UNKNOWN); // Paper
+        }
+     }
+ 
+     @FunctionalInterface
--- a/paper-server/patches/unapplied/net/minecraft/network/chat/TextColor.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/chat/TextColor.java.patch
@@ -0,0 +1,37 @@
+--- a/net/minecraft/network/chat/TextColor.java
+++ b/net/minecraft/network/chat/TextColor.java
+@@ -17,7 +17,7 @@
+     private static final String CUSTOM_COLOR_PREFIX = "#";
+     public static final Codec<TextColor> CODEC = Codec.STRING.comapFlatMap(TextColor::parseColor, TextColor::serialize);
+     private static final Map<ChatFormatting, TextColor> LEGACY_FORMAT_TO_COLOR = (Map) Stream.of(ChatFormatting.values()).filter(ChatFormatting::isColor).collect(ImmutableMap.toImmutableMap(Function.identity(), (enumchatformat) -> {
+-        return new TextColor(enumchatformat.getColor(), enumchatformat.getName());
+        return new TextColor(enumchatformat.getColor(), enumchatformat.getName(), enumchatformat); // CraftBukkit
+     }));
+     private static final Map<String, TextColor> NAMED_COLORS = (Map) TextColor.LEGACY_FORMAT_TO_COLOR.values().stream().collect(ImmutableMap.toImmutableMap((chathexcolor) -> {
+         return chathexcolor.name;
+@@ -25,16 +25,22 @@
+     private final int value;
+     @Nullable
+     public final String name;
+    // CraftBukkit start
+    @Nullable
+    public final ChatFormatting format;
+ 
+-    private TextColor(int rgb, String name) {
+-        this.value = rgb & 16777215;
+-        this.name = name;
+    private TextColor(int i, String s, ChatFormatting format) {
+        this.value = i & 16777215;
+        this.name = s;
+        this.format = format;
+     }
+ 
+     private TextColor(int rgb) {
+         this.value = rgb & 16777215;
+         this.name = null;
+        this.format = null;
+     }
+    // CraftBukkit end
+ 
+     public int getValue() {
+         return this.value;
--- a/paper-server/patches/unapplied/net/minecraft/network/chat/contents/NbtContents.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/chat/contents/NbtContents.java.patch
@@ -0,0 +1,20 @@
+--- a/net/minecraft/network/chat/contents/NbtContents.java
+++ b/net/minecraft/network/chat/contents/NbtContents.java
+@@ -120,7 +120,7 @@
+             }).map(Tag::getAsString);
+             if (this.interpreting) {
+                 Component component = DataFixUtils.orElse(
+-                    ComponentUtils.updateForEntity(source, this.separator, sender, depth), ComponentUtils.DEFAULT_NO_STYLE_SEPARATOR
+                    ComponentUtils.updateSeparatorForEntity(source, this.separator, sender, depth), ComponentUtils.DEFAULT_NO_STYLE_SEPARATOR // Paper - validate separator
+                 );
+                 return stream.flatMap(text -> {
+                     try {
+@@ -132,7 +132,7 @@
+                     }
+                 }).reduce((accumulator, current) -> accumulator.append(component).append(current)).orElseGet(Component::empty);
+             } else {
+-                return ComponentUtils.updateForEntity(source, this.separator, sender, depth)
+                return ComponentUtils.updateSeparatorForEntity(source, this.separator, sender, depth) // Paper - validate separator
+                     .map(
+                         text -> stream.map(Component::literal)
+                                 .reduce((accumulator, current) -> accumulator.append(text).append(current))
--- a/paper-server/patches/unapplied/net/minecraft/network/chat/contents/SelectorContents.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/chat/contents/SelectorContents.java.patch
@@ -0,0 +1,11 @@
+--- a/net/minecraft/network/chat/contents/SelectorContents.java
+++ b/net/minecraft/network/chat/contents/SelectorContents.java
+@@ -36,7 +36,7 @@
+         if (source == null) {
+             return Component.empty();
+         } else {
+-            Optional<? extends Component> optional = ComponentUtils.updateForEntity(source, this.separator, sender, depth);
+            Optional<? extends Component> optional = ComponentUtils.updateSeparatorForEntity(source, this.separator, sender, depth); // Paper - validate separator
+             return ComponentUtils.formatList(this.selector.resolved().findEntities(source), optional, Entity::getDisplayName);
+         }
+     }
--- a/paper-server/patches/unapplied/net/minecraft/network/chat/contents/TranslatableContents.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/chat/contents/TranslatableContents.java.patch
@@ -0,0 +1,45 @@
+--- a/net/minecraft/network/chat/contents/TranslatableContents.java
+++ b/net/minecraft/network/chat/contents/TranslatableContents.java
+@@ -181,6 +181,15 @@
+ 
+     @Override
+     public <T> Optional<T> visit(FormattedText.ContentConsumer<T> visitor) {
+        // Paper start - Count visited parts
+        try {
+            return this.visit(new TranslatableContentConsumer<>(visitor));
+        } catch (IllegalArgumentException ignored) {
+            return visitor.accept("...");
+        }
+    }
+    private <T> Optional<T> visit(TranslatableContentConsumer<T> visitor) {
+        // Paper end - Count visited parts
+         this.decompose();
+ 
+         for (FormattedText formattedText : this.decomposedParts) {
+@@ -191,7 +200,26 @@
+         }
+ 
+         return Optional.empty();
+    }
+    // Paper start - Count visited parts
+    private static final class TranslatableContentConsumer<T> implements FormattedText.ContentConsumer<T> {
+        private static final IllegalArgumentException EX = new IllegalArgumentException("Too long");
+        private final FormattedText.ContentConsumer<T> visitor;
+        private int visited;
+
+        private TranslatableContentConsumer(FormattedText.ContentConsumer<T> visitor) {
+            this.visitor = visitor;
+        }
+
+        @Override
+        public Optional<T> accept(final String asString) {
+            if (visited++ > 32) {
+                throw EX;
+            }
+            return this.visitor.accept(asString);
+        }
+     }
+    // Paper end - Count visited parts
+ 
+     @Override
+     public MutableComponent resolve(@Nullable CommandSourceStack source, @Nullable Entity sender, int depth) throws CommandSyntaxException {
--- a/paper-server/patches/unapplied/net/minecraft/network/protocol/Packet.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/protocol/Packet.java.patch
@@ -0,0 +1,22 @@
+--- a/net/minecraft/network/protocol/Packet.java
+++ b/net/minecraft/network/protocol/Packet.java
+@@ -11,6 +11,19 @@
+ 
+     void handle(T listener);
+ 
+    // Paper start
+    default boolean hasLargePacketFallback() {
+        return false;
+    }
+
+    /**
+     * override {@link #hasLargePacketFallback()} to return true when overriding in subclasses
+     */
+    default boolean packetTooLarge(net.minecraft.network.Connection manager) {
+        return false;
+    }
+    // Paper end
+
+     default boolean isSkippable() {
+         return false;
+     }
--- a/paper-server/patches/unapplied/net/minecraft/network/protocol/PacketUtils.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/protocol/PacketUtils.java.patch
@@ -0,0 +1,27 @@
+--- a/net/minecraft/network/protocol/PacketUtils.java
+++ b/net/minecraft/network/protocol/PacketUtils.java
+@@ -6,10 +6,15 @@
+ import net.minecraft.CrashReportCategory;
+ import net.minecraft.ReportedException;
+ import net.minecraft.network.PacketListener;
+import org.slf4j.Logger;
+
+// CraftBukkit start
+import net.minecraft.server.MinecraftServer;
+ import net.minecraft.server.RunningOnDifferentThreadException;
+ import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.network.ServerCommonPacketListenerImpl;
+// CraftBukkit end
+ import net.minecraft.util.thread.BlockableEventLoop;
+-import org.slf4j.Logger;
+ 
+ public class PacketUtils {
+ 
+@@ -24,6 +29,7 @@
+     public static <T extends PacketListener> void ensureRunningOnSameThread(Packet<T> packet, T listener, BlockableEventLoop<?> engine) throws RunningOnDifferentThreadException {
+         if (!engine.isSameThread()) {
+             engine.executeIfPossible(() -> {
+                if (listener instanceof ServerCommonPacketListenerImpl serverCommonPacketListener && serverCommonPacketListener.processedDisconnect) return; // CraftBukkit - Don't handle sync packets for kicked players
+                 if (listener.shouldHandleMessage(packet)) {
+                     try {
+                         packet.handle(listener);
--- a/paper-server/patches/unapplied/net/minecraft/network/protocol/common/ServerboundCustomPayloadPacket.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/protocol/common/ServerboundCustomPayloadPacket.java.patch
@@ -0,0 +1,20 @@
+--- a/net/minecraft/network/protocol/common/ServerboundCustomPayloadPacket.java
+++ b/net/minecraft/network/protocol/common/ServerboundCustomPayloadPacket.java
+@@ -2,7 +2,6 @@
+ 
+ import com.google.common.collect.Lists;
+ import java.util.List;
+-import net.minecraft.Util;
+ import net.minecraft.network.FriendlyByteBuf;
+ import net.minecraft.network.codec.StreamCodec;
+ import net.minecraft.network.protocol.Packet;
+@@ -16,8 +15,7 @@
+     private static final int MAX_PAYLOAD_SIZE = 32767;
+     public static final StreamCodec<FriendlyByteBuf, ServerboundCustomPayloadPacket> STREAM_CODEC = CustomPacketPayload.codec((minecraftkey) -> {
+         return DiscardedPayload.codec(minecraftkey, 32767);
+-    }, (List) Util.make(Lists.newArrayList(new CustomPacketPayload.TypeAndCodec[]{new CustomPacketPayload.TypeAndCodec<>(BrandPayload.TYPE, BrandPayload.STREAM_CODEC)}), (arraylist) -> {
+-    })).map(ServerboundCustomPayloadPacket::new, ServerboundCustomPayloadPacket::payload);
+    }, java.util.Collections.emptyList()).map(ServerboundCustomPayloadPacket::new, ServerboundCustomPayloadPacket::payload); // CraftBukkit - treat all packets the same
+ 
+     @Override
+     public PacketType<ServerboundCustomPayloadPacket> type() {
--- a/paper-server/patches/unapplied/net/minecraft/network/protocol/common/custom/DiscardedPayload.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/protocol/common/custom/DiscardedPayload.java.patch
@@ -0,0 +1,24 @@
+--- a/net/minecraft/network/protocol/common/custom/DiscardedPayload.java
+++ b/net/minecraft/network/protocol/common/custom/DiscardedPayload.java
+@@ -4,16 +4,18 @@
+ import net.minecraft.network.codec.StreamCodec;
+ import net.minecraft.resources.ResourceLocation;
+ 
+-public record DiscardedPayload(ResourceLocation id) implements CustomPacketPayload {
+public record DiscardedPayload(ResourceLocation id, io.netty.buffer.ByteBuf data) implements CustomPacketPayload { // CraftBukkit - store data
+ 
+     public static <T extends FriendlyByteBuf> StreamCodec<T, DiscardedPayload> codec(ResourceLocation id, int maxBytes) {
+         return CustomPacketPayload.codec((discardedpayload, packetdataserializer) -> {
+            packetdataserializer.writeBytes(discardedpayload.data); // CraftBukkit - serialize
+         }, (packetdataserializer) -> {
+             int j = packetdataserializer.readableBytes();
+ 
+             if (j >= 0 && j <= maxBytes) {
+-                packetdataserializer.skipBytes(j);
+-                return new DiscardedPayload(id);
+                // CraftBukkit start
+                return new DiscardedPayload(id, packetdataserializer.readBytes(j));
+                // CraftBukkit end
+             } else {
+                 throw new IllegalArgumentException("Payload may not be larger than " + maxBytes + " bytes");
+             }
--- a/paper-server/patches/unapplied/net/minecraft/network/protocol/game/ClientboundBlockEntityDataPacket.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/protocol/game/ClientboundBlockEntityDataPacket.java.patch
@@ -0,0 +1,11 @@
+--- a/net/minecraft/network/protocol/game/ClientboundBlockEntityDataPacket.java
+++ b/net/minecraft/network/protocol/game/ClientboundBlockEntityDataPacket.java
+@@ -29,7 +29,7 @@
+ 
+     public static ClientboundBlockEntityDataPacket create(BlockEntity blockEntity, BiFunction<BlockEntity, RegistryAccess, CompoundTag> nbtGetter) {
+         RegistryAccess registryAccess = blockEntity.getLevel().registryAccess();
+-        return new ClientboundBlockEntityDataPacket(blockEntity.getBlockPos(), blockEntity.getType(), nbtGetter.apply(blockEntity, registryAccess));
+        return new ClientboundBlockEntityDataPacket(blockEntity.getBlockPos(), blockEntity.getType(), blockEntity.sanitizeSentNbt(nbtGetter.apply(blockEntity, registryAccess)));  // Paper - Sanitize sent data
+     }
+ 
+     public static ClientboundBlockEntityDataPacket create(BlockEntity blockEntity) {
--- a/paper-server/patches/unapplied/net/minecraft/network/protocol/game/ClientboundContainerSetContentPacket.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/protocol/game/ClientboundContainerSetContentPacket.java.patch
@@ -0,0 +1,24 @@
+--- a/net/minecraft/network/protocol/game/ClientboundContainerSetContentPacket.java
+++ b/net/minecraft/network/protocol/game/ClientboundContainerSetContentPacket.java
+@@ -36,6 +36,21 @@
+         this.carriedItem = ItemStack.OPTIONAL_STREAM_CODEC.decode(buf);
+     }
+ 
+    // Paper start - Handle large packets disconnecting client
+    @Override
+    public boolean hasLargePacketFallback() {
+        return true;
+    }
+
+    @Override
+    public boolean packetTooLarge(net.minecraft.network.Connection manager) {
+        for (int i = 0 ; i < this.items.size() ; i++) {
+            manager.send(new ClientboundContainerSetSlotPacket(this.containerId, this.stateId, i, this.items.get(i)));
+        }
+        return true;
+    }
+    // Paper end - Handle large packets disconnecting client
+
+     private void write(RegistryFriendlyByteBuf buf) {
+         buf.writeContainerId(this.containerId);
+         buf.writeVarInt(this.stateId);
--- a/paper-server/patches/unapplied/net/minecraft/network/protocol/game/ClientboundInitializeBorderPacket.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/protocol/game/ClientboundInitializeBorderPacket.java.patch
@@ -0,0 +1,15 @@
+--- a/net/minecraft/network/protocol/game/ClientboundInitializeBorderPacket.java
+++ b/net/minecraft/network/protocol/game/ClientboundInitializeBorderPacket.java
+@@ -30,8 +30,10 @@
+     }
+ 
+     public ClientboundInitializeBorderPacket(WorldBorder worldBorder) {
+-        this.newCenterX = worldBorder.getCenterX();
+-        this.newCenterZ = worldBorder.getCenterZ();
+        // CraftBukkit start - multiply out nether border
+        this.newCenterX = worldBorder.getCenterX() * worldBorder.world.dimensionType().coordinateScale();
+        this.newCenterZ = worldBorder.getCenterZ() * worldBorder.world.dimensionType().coordinateScale();
+        // CraftBukkit end
+         this.oldSize = worldBorder.getSize();
+         this.newSize = worldBorder.getLerpTarget();
+         this.lerpTime = worldBorder.getLerpRemainingTime();
--- a/paper-server/patches/unapplied/net/minecraft/network/protocol/game/ClientboundLevelChunkPacketData.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/protocol/game/ClientboundLevelChunkPacketData.java.patch
@@ -0,0 +1,19 @@
+--- a/net/minecraft/network/protocol/game/ClientboundLevelChunkPacketData.java
+++ b/net/minecraft/network/protocol/game/ClientboundLevelChunkPacketData.java
+@@ -52,7 +52,7 @@
+             throw new RuntimeException("Can't read heightmap in packet for [" + x + ", " + z + "]");
+         } else {
+             int i = buf.readVarInt();
+-            if (i > 2097152) {
+            if (i > 2097152) { // Paper - diff on change - if this changes, update PacketEncoder
+                 throw new RuntimeException("Chunk Packet trying to allocate too much memory on read.");
+             } else {
+                 this.buffer = new byte[i];
+@@ -154,6 +154,7 @@
+             CompoundTag compoundTag = blockEntity.getUpdateTag(blockEntity.getLevel().registryAccess());
+             BlockPos blockPos = blockEntity.getBlockPos();
+             int i = SectionPos.sectionRelative(blockPos.getX()) << 4 | SectionPos.sectionRelative(blockPos.getZ());
+            blockEntity.sanitizeSentNbt(compoundTag); // Paper - Sanitize sent data
+             return new ClientboundLevelChunkPacketData.BlockEntityInfo(i, blockPos.getY(), blockEntity.getType(), compoundTag.isEmpty() ? null : compoundTag);
+         }
+     }
--- a/paper-server/patches/unapplied/net/minecraft/network/protocol/game/ClientboundPlayerInfoUpdatePacket.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/protocol/game/ClientboundPlayerInfoUpdatePacket.java.patch
@@ -0,0 +1,114 @@
+--- a/net/minecraft/network/protocol/game/ClientboundPlayerInfoUpdatePacket.java
+++ b/net/minecraft/network/protocol/game/ClientboundPlayerInfoUpdatePacket.java
+@@ -38,7 +38,18 @@
+         this.actions = EnumSet.of(action);
+         this.entries = List.of(new ClientboundPlayerInfoUpdatePacket.Entry(player));
+     }
+    // Paper start - Add Listing API for Player
+    public ClientboundPlayerInfoUpdatePacket(EnumSet<ClientboundPlayerInfoUpdatePacket.Action> actions, List<ClientboundPlayerInfoUpdatePacket.Entry> entries) {
+        this.actions = actions;
+        this.entries = entries;
+    }
+ 
+    public ClientboundPlayerInfoUpdatePacket(EnumSet<ClientboundPlayerInfoUpdatePacket.Action> actions, ClientboundPlayerInfoUpdatePacket.Entry entry) {
+        this.actions = actions;
+        this.entries = List.of(entry);
+    }
+    // Paper end - Add Listing API for Player
+
+     public static ClientboundPlayerInfoUpdatePacket createPlayerInitializing(Collection<ServerPlayer> players) {
+         EnumSet<ClientboundPlayerInfoUpdatePacket.Action> enumSet = EnumSet.of(
+             ClientboundPlayerInfoUpdatePacket.Action.ADD_PLAYER,
+@@ -53,6 +64,46 @@
+         return new ClientboundPlayerInfoUpdatePacket(enumSet, players);
+     }
+ 
+    // Paper start - Add Listing API for Player
+    public static ClientboundPlayerInfoUpdatePacket createPlayerInitializing(Collection<ServerPlayer> players, ServerPlayer forPlayer) {
+        final EnumSet<ClientboundPlayerInfoUpdatePacket.Action> enumSet = EnumSet.of(
+            ClientboundPlayerInfoUpdatePacket.Action.ADD_PLAYER,
+            ClientboundPlayerInfoUpdatePacket.Action.INITIALIZE_CHAT,
+            ClientboundPlayerInfoUpdatePacket.Action.UPDATE_GAME_MODE,
+            ClientboundPlayerInfoUpdatePacket.Action.UPDATE_LISTED,
+            ClientboundPlayerInfoUpdatePacket.Action.UPDATE_LATENCY,
+            ClientboundPlayerInfoUpdatePacket.Action.UPDATE_DISPLAY_NAME,
+            ClientboundPlayerInfoUpdatePacket.Action.UPDATE_HAT,
+            ClientboundPlayerInfoUpdatePacket.Action.UPDATE_LIST_ORDER
+        );
+        final List<ClientboundPlayerInfoUpdatePacket.Entry> entries = new java.util.ArrayList<>(players.size());
+        final org.bukkit.craftbukkit.entity.CraftPlayer bukkitEntity = forPlayer.getBukkitEntity();
+        for (final ServerPlayer player : players) {
+            entries.add(new ClientboundPlayerInfoUpdatePacket.Entry(player, bukkitEntity.isListed(player.getBukkitEntity())));
+        }
+        return new ClientboundPlayerInfoUpdatePacket(enumSet, entries);
+    }
+
+    public static ClientboundPlayerInfoUpdatePacket createSinglePlayerInitializing(ServerPlayer player, boolean listed) {
+        final EnumSet<ClientboundPlayerInfoUpdatePacket.Action> enumSet = EnumSet.of(
+            ClientboundPlayerInfoUpdatePacket.Action.ADD_PLAYER,
+            ClientboundPlayerInfoUpdatePacket.Action.INITIALIZE_CHAT,
+            ClientboundPlayerInfoUpdatePacket.Action.UPDATE_GAME_MODE,
+            ClientboundPlayerInfoUpdatePacket.Action.UPDATE_LISTED,
+            ClientboundPlayerInfoUpdatePacket.Action.UPDATE_LATENCY,
+            ClientboundPlayerInfoUpdatePacket.Action.UPDATE_DISPLAY_NAME,
+            ClientboundPlayerInfoUpdatePacket.Action.UPDATE_HAT,
+            ClientboundPlayerInfoUpdatePacket.Action.UPDATE_LIST_ORDER
+        );
+        final List<ClientboundPlayerInfoUpdatePacket.Entry> entries = List.of(new Entry(player, listed));
+        return new ClientboundPlayerInfoUpdatePacket(enumSet, entries);
+    }
+
+    public static ClientboundPlayerInfoUpdatePacket updateListed(UUID playerInfoId, boolean listed) {
+        EnumSet<ClientboundPlayerInfoUpdatePacket.Action> enumSet = EnumSet.of(ClientboundPlayerInfoUpdatePacket.Action.UPDATE_LISTED);
+        return new ClientboundPlayerInfoUpdatePacket(enumSet, new ClientboundPlayerInfoUpdatePacket.Entry(playerInfoId, listed));
+    }
+    // Paper end - Add Listing API for Player
+     private ClientboundPlayerInfoUpdatePacket(RegistryFriendlyByteBuf buf) {
+         this.actions = buf.readEnumSet(ClientboundPlayerInfoUpdatePacket.Action.class);
+         this.entries = buf.readList(buf2 -> {
+@@ -116,7 +167,15 @@
+         }),
+         INITIALIZE_CHAT(
+             (serialized, buf) -> serialized.chatSession = buf.readNullable(RemoteChatSession.Data::read),
+-            (buf, entry) -> buf.writeNullable(entry.chatSession, RemoteChatSession.Data::write)
+            // Paper start - Prevent causing expired keys from impacting new joins
+            (buf, entry) -> {
+                RemoteChatSession.Data chatSession = entry.chatSession;
+                if (chatSession != null && chatSession.profilePublicKey().hasExpired()) {
+                    chatSession = null;
+                }
+                buf.writeNullable(chatSession, RemoteChatSession.Data::write);
+            }
+            // Paper end - Prevent causing expired keys from impacting new joins
+         ),
+         UPDATE_GAME_MODE((serialized, buf) -> serialized.gameMode = GameType.byId(buf.readVarInt()), (buf, entry) -> buf.writeVarInt(entry.gameMode().getId())),
+         UPDATE_LISTED((serialized, buf) -> serialized.listed = buf.readBoolean(), (buf, entry) -> buf.writeBoolean(entry.listed())),
+@@ -157,10 +216,15 @@
+         @Nullable RemoteChatSession.Data chatSession
+     ) {
+         Entry(ServerPlayer player) {
+        // Paper start - Add Listing API for Player
+            this(player, true);
+        }
+        Entry(ServerPlayer player, boolean listed) {
+             this(
+        // Paper end - Add Listing API for Player
+                 player.getUUID(),
+                 player.getGameProfile(),
+-                true,
+                listed, // Paper - Add Listing API for Player
+                 player.connection.latency(),
+                 player.gameMode.getGameModeForPlayer(),
+                 player.getTabListDisplayName(),
+@@ -169,6 +233,11 @@
+                 Optionull.map(player.getChatSession(), RemoteChatSession::asData)
+             );
+         }
+        // Paper start - Add Listing API for Player
+        Entry(UUID profileId, boolean listed) {
+            this(profileId, null, listed, 0, GameType.DEFAULT_MODE, null, true, 0, null);
+        }
+        // Paper end - Add Listing API for Player
+     }
+ 
+     static class EntryBuilder {
--- a/paper-server/patches/unapplied/net/minecraft/network/protocol/game/ClientboundSectionBlocksUpdatePacket.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/protocol/game/ClientboundSectionBlocksUpdatePacket.java.patch
@@ -0,0 +1,38 @@
+--- a/net/minecraft/network/protocol/game/ClientboundSectionBlocksUpdatePacket.java
+++ b/net/minecraft/network/protocol/game/ClientboundSectionBlocksUpdatePacket.java
+@@ -33,11 +33,19 @@
+             short short0 = (Short) shortiterator.next();
+ 
+             this.positions[j] = short0;
+-            this.states[j] = section.getBlockState(SectionPos.sectionRelativeX(short0), SectionPos.sectionRelativeY(short0), SectionPos.sectionRelativeZ(short0));
+            this.states[j] = (section != null) ? section.getBlockState(SectionPos.sectionRelativeX(short0), SectionPos.sectionRelativeY(short0), SectionPos.sectionRelativeZ(short0)) : net.minecraft.world.level.block.Blocks.AIR.defaultBlockState(); // CraftBukkit - SPIGOT-6076, Mojang bug when empty chunk section notified
+         }
+ 
+     }
+ 
+    // CraftBukkit start - Add constructor
+    public ClientboundSectionBlocksUpdatePacket(SectionPos sectionposition, ShortSet shortset, BlockState[] states) {
+        this.sectionPos = sectionposition;
+        this.positions = shortset.toShortArray();
+        this.states = states;
+    }
+    // CraftBukkit end
+
+     private ClientboundSectionBlocksUpdatePacket(FriendlyByteBuf buf) {
+         this.sectionPos = SectionPos.of(buf.readLong());
+         int i = buf.readVarInt();
+@@ -54,6 +62,14 @@
+ 
+     }
+ 
+    // Paper start - Multi Block Change API
+    public ClientboundSectionBlocksUpdatePacket(SectionPos sectionPos, it.unimi.dsi.fastutil.shorts.Short2ObjectMap<BlockState> blockChanges) {
+        this.sectionPos = sectionPos;
+        this.positions = blockChanges.keySet().toShortArray();
+        this.states = blockChanges.values().toArray(new BlockState[0]);
+    }
+    // Paper end - Multi Block Change API
+
+     private void write(FriendlyByteBuf buf) {
+         buf.writeLong(this.sectionPos.asLong());
+         buf.writeVarInt(this.positions.length);
--- a/paper-server/patches/unapplied/net/minecraft/network/protocol/game/ClientboundSetBorderCenterPacket.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/protocol/game/ClientboundSetBorderCenterPacket.java.patch
@@ -0,0 +1,15 @@
+--- a/net/minecraft/network/protocol/game/ClientboundSetBorderCenterPacket.java
+++ b/net/minecraft/network/protocol/game/ClientboundSetBorderCenterPacket.java
+@@ -13,8 +13,10 @@
+     private final double newCenterZ;
+ 
+     public ClientboundSetBorderCenterPacket(WorldBorder worldBorder) {
+-        this.newCenterX = worldBorder.getCenterX();
+-        this.newCenterZ = worldBorder.getCenterZ();
+        // CraftBukkit start - multiply out nether border
+        this.newCenterX = worldBorder.getCenterX() * (worldBorder.world != null ? worldBorder.world.dimensionType().coordinateScale() : 1.0);
+        this.newCenterZ = worldBorder.getCenterZ() * (worldBorder.world != null ? worldBorder.world.dimensionType().coordinateScale() : 1.0);
+        // CraftBukkit end
+     }
+ 
+     private ClientboundSetBorderCenterPacket(FriendlyByteBuf buf) {
--- a/paper-server/patches/unapplied/net/minecraft/network/protocol/game/ClientboundSetEntityDataPacket.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/protocol/game/ClientboundSetEntityDataPacket.java.patch
@@ -0,0 +1,14 @@
+--- a/net/minecraft/network/protocol/game/ClientboundSetEntityDataPacket.java
+++ b/net/minecraft/network/protocol/game/ClientboundSetEntityDataPacket.java
+@@ -19,9 +19,11 @@
+     }
+ 
+     private static void pack(List<SynchedEntityData.DataValue<?>> trackedValues, RegistryFriendlyByteBuf buf) {
+        try (var ignored = io.papermc.paper.util.DataSanitizationUtil.start(true)) { // Paper - data sanitization
+         for (SynchedEntityData.DataValue<?> dataValue : trackedValues) {
+             dataValue.write(buf);
+         }
+        } // Paper - data sanitization
+ 
+         buf.writeByte(255);
+     }
--- a/paper-server/patches/unapplied/net/minecraft/network/protocol/game/ClientboundSetEquipmentPacket.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/protocol/game/ClientboundSetEquipmentPacket.java.patch
@@ -0,0 +1,32 @@
+--- a/net/minecraft/network/protocol/game/ClientboundSetEquipmentPacket.java
+++ b/net/minecraft/network/protocol/game/ClientboundSetEquipmentPacket.java
+@@ -19,6 +19,13 @@
+     private final List<Pair<EquipmentSlot, ItemStack>> slots;
+ 
+     public ClientboundSetEquipmentPacket(int entityId, List<Pair<EquipmentSlot, ItemStack>> equipmentList) {
+        // Paper start - data sanitization
+        this(entityId, equipmentList, false);
+    }
+    private boolean sanitize;
+    public ClientboundSetEquipmentPacket(int entityId, List<Pair<EquipmentSlot, ItemStack>> equipmentList, boolean sanitize) {
+        this.sanitize = sanitize;
+        // Paper end - data sanitization
+         this.entity = entityId;
+         this.slots = equipmentList;
+     }
+@@ -40,6 +47,7 @@
+         buf.writeVarInt(this.entity);
+         int i = this.slots.size();
+ 
+        try (var ignored = io.papermc.paper.util.DataSanitizationUtil.start(this.sanitize)) {  // Paper - data sanitization
+         for (int j = 0; j < i; j++) {
+             Pair<EquipmentSlot, ItemStack> pair = this.slots.get(j);
+             EquipmentSlot equipmentSlot = pair.getFirst();
+@@ -48,6 +56,7 @@
+             buf.writeByte(bl ? k | -128 : k);
+             ItemStack.OPTIONAL_STREAM_CODEC.encode(buf, pair.getSecond());
+         }
+        } // Paper - data sanitization
+     }
+ 
+     @Override
--- a/paper-server/patches/unapplied/net/minecraft/network/protocol/game/ClientboundSetPlayerTeamPacket.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/protocol/game/ClientboundSetPlayerTeamPacket.java.patch
@@ -0,0 +1,23 @@
+--- a/net/minecraft/network/protocol/game/ClientboundSetPlayerTeamPacket.java
+++ b/net/minecraft/network/protocol/game/ClientboundSetPlayerTeamPacket.java
+@@ -58,6 +58,11 @@
+         );
+     }
+ 
+    // Paper start - Multiple Entries with Scoreboards
+    public static ClientboundSetPlayerTeamPacket createMultiplePlayerPacket(PlayerTeam team, Collection<String> players, ClientboundSetPlayerTeamPacket.Action operation) {
+        return new ClientboundSetPlayerTeamPacket(team.getName(), operation == ClientboundSetPlayerTeamPacket.Action.ADD ? 3 : 4, Optional.empty(), players);
+    }
+    // Paper end - Multiple Entries with Scoreboards
+     private ClientboundSetPlayerTeamPacket(RegistryFriendlyByteBuf buf) {
+         this.name = buf.readUtf();
+         this.method = buf.readByte();
+@@ -200,7 +205,7 @@
+             ComponentSerialization.TRUSTED_STREAM_CODEC.encode(buf, this.displayName);
+             buf.writeByte(this.options);
+             buf.writeUtf(this.nametagVisibility);
+-            buf.writeUtf(this.collisionRule);
+            buf.writeUtf(!io.papermc.paper.configuration.GlobalConfiguration.get().collisions.enablePlayerCollisions ? "never" : this.collisionRule); // Paper - Configurable player collision
+             buf.writeEnum(this.color);
+             ComponentSerialization.TRUSTED_STREAM_CODEC.encode(buf, this.playerPrefix);
+             ComponentSerialization.TRUSTED_STREAM_CODEC.encode(buf, this.playerSuffix);
--- a/paper-server/patches/unapplied/net/minecraft/network/protocol/game/ClientboundSystemChatPacket.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/protocol/game/ClientboundSystemChatPacket.java.patch
@@ -0,0 +1,25 @@
+--- a/net/minecraft/network/protocol/game/ClientboundSystemChatPacket.java
+++ b/net/minecraft/network/protocol/game/ClientboundSystemChatPacket.java
+@@ -1,3 +1,4 @@
+// mc-dev import
+ package net.minecraft.network.protocol.game;
+ 
+ import net.minecraft.network.RegistryFriendlyByteBuf;
+@@ -12,6 +13,17 @@
+ 
+     public static final StreamCodec<RegistryFriendlyByteBuf, ClientboundSystemChatPacket> STREAM_CODEC = StreamCodec.composite(ComponentSerialization.TRUSTED_STREAM_CODEC, ClientboundSystemChatPacket::content, ByteBufCodecs.BOOL, ClientboundSystemChatPacket::overlay, ClientboundSystemChatPacket::new);
+ 
+    // Spigot start
+    public ClientboundSystemChatPacket(net.md_5.bungee.api.chat.BaseComponent[] content, boolean overlay) {
+        this(org.bukkit.craftbukkit.util.CraftChatMessage.fromJSON(net.md_5.bungee.chat.ComponentSerializer.toString(content)), overlay);
+    }
+    // Spigot end
+    // Paper start
+    public ClientboundSystemChatPacket(net.kyori.adventure.text.Component content, boolean overlay) {
+        this(io.papermc.paper.adventure.PaperAdventure.asVanilla(content), overlay);
+    }
+    // Paper end
+
+     @Override
+     public PacketType<ClientboundSystemChatPacket> type() {
+         return GamePacketTypes.CLIENTBOUND_SYSTEM_CHAT;
--- a/paper-server/patches/unapplied/net/minecraft/network/protocol/game/ServerboundCommandSuggestionPacket.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/protocol/game/ServerboundCommandSuggestionPacket.java.patch
@@ -0,0 +1,11 @@
+--- a/net/minecraft/network/protocol/game/ServerboundCommandSuggestionPacket.java
+++ b/net/minecraft/network/protocol/game/ServerboundCommandSuggestionPacket.java
+@@ -19,7 +19,7 @@
+ 
+     private ServerboundCommandSuggestionPacket(FriendlyByteBuf buf) {
+         this.id = buf.readVarInt();
+-        this.command = buf.readUtf(32500);
+        this.command = buf.readUtf(2048); // Paper
+     }
+ 
+     private void write(FriendlyByteBuf buf) {
--- a/paper-server/patches/unapplied/net/minecraft/network/protocol/game/ServerboundInteractPacket.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/protocol/game/ServerboundInteractPacket.java.patch
@@ -0,0 +1,17 @@
+--- a/net/minecraft/network/protocol/game/ServerboundInteractPacket.java
+++ b/net/minecraft/network/protocol/game/ServerboundInteractPacket.java
+@@ -176,4 +176,14 @@
+             buf.writeEnum(this.hand);
+         }
+     }
+
+    // Paper start - PlayerUseUnknownEntityEvent
+    public int getEntityId() {
+        return this.entityId;
+    }
+
+    public boolean isAttack() {
+        return this.action.getType() == ActionType.ATTACK;
+    }
+    // Paper end - PlayerUseUnknownEntityEvent
+ }
--- a/paper-server/patches/unapplied/net/minecraft/network/protocol/game/ServerboundUseItemOnPacket.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/protocol/game/ServerboundUseItemOnPacket.java.patch
@@ -0,0 +1,23 @@
+--- a/net/minecraft/network/protocol/game/ServerboundUseItemOnPacket.java
+++ b/net/minecraft/network/protocol/game/ServerboundUseItemOnPacket.java
+@@ -1,3 +1,4 @@
+// mc-dev import
+ package net.minecraft.network.protocol.game;
+ 
+ import net.minecraft.network.FriendlyByteBuf;
+@@ -13,6 +14,7 @@
+     private final BlockHitResult blockHit;
+     private final InteractionHand hand;
+     private final int sequence;
+    public long timestamp; // Spigot
+ 
+     public ServerboundUseItemOnPacket(InteractionHand hand, BlockHitResult blockHitResult, int sequence) {
+         this.hand = hand;
+@@ -21,6 +23,7 @@
+     }
+ 
+     private ServerboundUseItemOnPacket(FriendlyByteBuf buf) {
+        this.timestamp = System.currentTimeMillis(); // Spigot
+         this.hand = (InteractionHand) buf.readEnum(InteractionHand.class);
+         this.blockHit = buf.readBlockHitResult();
+         this.sequence = buf.readVarInt();
--- a/paper-server/patches/unapplied/net/minecraft/network/protocol/game/ServerboundUseItemPacket.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/protocol/game/ServerboundUseItemPacket.java.patch
@@ -0,0 +1,23 @@
+--- a/net/minecraft/network/protocol/game/ServerboundUseItemPacket.java
+++ b/net/minecraft/network/protocol/game/ServerboundUseItemPacket.java
+@@ -1,3 +1,4 @@
+// mc-dev import
+ package net.minecraft.network.protocol.game;
+ 
+ import net.minecraft.network.FriendlyByteBuf;
+@@ -13,6 +14,7 @@
+     private final int sequence;
+     private final float yRot;
+     private final float xRot;
+    public long timestamp; // Spigot
+ 
+     public ServerboundUseItemPacket(InteractionHand hand, int sequence, float yaw, float pitch) {
+         this.hand = hand;
+@@ -22,6 +24,7 @@
+     }
+ 
+     private ServerboundUseItemPacket(FriendlyByteBuf buf) {
+        this.timestamp = System.currentTimeMillis(); // Spigot
+         this.hand = (InteractionHand) buf.readEnum(InteractionHand.class);
+         this.sequence = buf.readVarInt();
+         this.yRot = buf.readFloat();
--- a/paper-server/patches/unapplied/net/minecraft/network/protocol/game/VecDeltaCodec.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/protocol/game/VecDeltaCodec.java.patch
@@ -0,0 +1,22 @@
+--- a/net/minecraft/network/protocol/game/VecDeltaCodec.java
+++ b/net/minecraft/network/protocol/game/VecDeltaCodec.java
+@@ -5,16 +5,16 @@
+ 
+ public class VecDeltaCodec {
+     private static final double TRUNCATION_STEPS = 4096.0;
+-    private Vec3 base = Vec3.ZERO;
+    public Vec3 base = Vec3.ZERO; // Paper
+ 
+     @VisibleForTesting
+     static long encode(double value) {
+-        return Math.round(value * 4096.0);
+        return Math.round(value * 4096.0); // Paper - Fix MC-4; diff on change
+     }
+ 
+     @VisibleForTesting
+     static double decode(long value) {
+-        return (double)value / 4096.0;
+        return value / 4096.0; // Paper - Fix MC-4; diff on change
+     }
+ 
+     public Vec3 decode(long x, long y, long z) {
--- a/paper-server/patches/unapplied/net/minecraft/network/protocol/handshake/ClientIntentionPacket.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/protocol/handshake/ClientIntentionPacket.java.patch
@@ -0,0 +1,17 @@
+--- a/net/minecraft/network/protocol/handshake/ClientIntentionPacket.java
+++ b/net/minecraft/network/protocol/handshake/ClientIntentionPacket.java
+@@ -1,3 +1,4 @@
+// mc-dev import
+ package net.minecraft.network.protocol.handshake;
+ 
+ import net.minecraft.network.FriendlyByteBuf;
+@@ -11,7 +12,8 @@
+     private static final int MAX_HOST_LENGTH = 255;
+ 
+     private ClientIntentionPacket(FriendlyByteBuf buf) {
+-        this(buf.readVarInt(), buf.readUtf(255), buf.readUnsignedShort(), ClientIntent.byId(buf.readVarInt()));
+        // Spigot - increase max hostName length
+        this(buf.readVarInt(), buf.readUtf(Short.MAX_VALUE), buf.readUnsignedShort(), ClientIntent.byId(buf.readVarInt()));
+     }
+ 
+     private void write(FriendlyByteBuf buf) {
--- a/paper-server/patches/unapplied/net/minecraft/network/protocol/login/ClientboundCustomQueryPacket.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/protocol/login/ClientboundCustomQueryPacket.java.patch
@@ -0,0 +1,17 @@
+--- a/net/minecraft/network/protocol/login/ClientboundCustomQueryPacket.java
+++ b/net/minecraft/network/protocol/login/ClientboundCustomQueryPacket.java
+@@ -47,4 +47,14 @@
+     public void handle(ClientLoginPacketListener listener) {
+         listener.handleCustomQuery(this);
+     }
+
+    // Paper start - MC Utils - default query payloads
+    public static record PlayerInfoChannelPayload(ResourceLocation id, FriendlyByteBuf buffer) implements CustomQueryPayload {
+
+        @Override
+        public void write(final FriendlyByteBuf buf) {
+            buf.writeBytes(this.buffer.copy());
+        }
+    }
+    // Paper end - MC Utils - default query payloads
+ }
--- a/paper-server/patches/unapplied/net/minecraft/network/protocol/login/ClientboundLoginDisconnectPacket.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/protocol/login/ClientboundLoginDisconnectPacket.java.patch
@@ -0,0 +1,21 @@
+--- a/net/minecraft/network/protocol/login/ClientboundLoginDisconnectPacket.java
+++ b/net/minecraft/network/protocol/login/ClientboundLoginDisconnectPacket.java
+@@ -18,11 +18,16 @@
+     }
+ 
+     private ClientboundLoginDisconnectPacket(FriendlyByteBuf buf) {
+-        this.reason = Component.Serializer.fromJsonLenient(buf.readUtf(262144), RegistryAccess.EMPTY);
+        this.reason = Component.Serializer.fromJsonLenient(buf.readUtf(FriendlyByteBuf.MAX_COMPONENT_STRING_LENGTH), RegistryAccess.EMPTY); // Paper - diff on change
+     }
+ 
+     private void write(FriendlyByteBuf buf) {
+-        buf.writeUtf(Component.Serializer.toJson(this.reason, RegistryAccess.EMPTY));
+        // Paper start - Adventure
+        // buf.writeUtf(Component.Serializer.toJson(this.reason, RegistryAccess.EMPTY));
+        // In the login phase, buf.adventure$locale field is most likely null, but plugins may use internals to set it via the channel attribute
+        java.util.Locale bufLocale = buf.adventure$locale;
+        buf.writeJsonWithCodec(net.minecraft.network.chat.ComponentSerialization.localizedCodec(bufLocale == null ? java.util.Locale.US : bufLocale), this.reason, FriendlyByteBuf.MAX_COMPONENT_STRING_LENGTH);
+        // Paper end - Adventure
+     }
+ 
+     @Override
--- a/paper-server/patches/unapplied/net/minecraft/network/protocol/login/ServerboundCustomQueryAnswerPacket.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/protocol/login/ServerboundCustomQueryAnswerPacket.java.patch
@@ -0,0 +1,43 @@
+--- a/net/minecraft/network/protocol/login/ServerboundCustomQueryAnswerPacket.java
+++ b/net/minecraft/network/protocol/login/ServerboundCustomQueryAnswerPacket.java
+@@ -20,7 +20,17 @@
+     }
+ 
+     private static CustomQueryAnswerPayload readPayload(int queryId, FriendlyByteBuf buf) {
+-        return readUnknownPayload(buf);
+        // Paper start - MC Utils - default query payloads
+        FriendlyByteBuf buffer = buf.readNullable((buf2) -> {
+            int i = buf2.readableBytes();
+            if (i >= 0 && i <= MAX_PAYLOAD_SIZE) {
+                return new FriendlyByteBuf(buf2.readBytes(i));
+            } else {
+                throw new IllegalArgumentException("Payload may not be larger than " + MAX_PAYLOAD_SIZE + " bytes");
+            }
+        });
+        return buffer == null ? null : new net.minecraft.network.protocol.login.ServerboundCustomQueryAnswerPacket.QueryAnswerPayload(buffer);
+        // Paper end - MC Utils - default query payloads
+     }
+ 
+     private static CustomQueryAnswerPayload readUnknownPayload(FriendlyByteBuf buf) {
+@@ -47,4 +57,21 @@
+     public void handle(ServerLoginPacketListener listener) {
+         listener.handleCustomQueryPacket(this);
+     }
+
+    // Paper start - MC Utils - default query payloads
+    public static final class QueryAnswerPayload implements CustomQueryAnswerPayload {
+
+        public final FriendlyByteBuf buffer;
+
+        public QueryAnswerPayload(final net.minecraft.network.FriendlyByteBuf buffer) {
+            this.buffer = buffer;
+        }
+
+        @Override
+        public void write(final net.minecraft.network.FriendlyByteBuf buf) {
+            buf.writeBytes(this.buffer.copy());
+        }
+    }
+    // Paper end - MC Utils - default query payloads
+
+ }
--- a/paper-server/patches/unapplied/net/minecraft/network/syncher/SynchedEntityData.java.patch
+++ b/paper-server/patches/unapplied/net/minecraft/network/syncher/SynchedEntityData.java.patch
@@ -0,0 +1,53 @@
+--- a/net/minecraft/network/syncher/SynchedEntityData.java
+++ b/net/minecraft/network/syncher/SynchedEntityData.java
+@@ -50,8 +50,8 @@
+         }
+     }
+ 
+-    private <T> SynchedEntityData.DataItem<T> getItem(EntityDataAccessor<T> key) {
+-        return this.itemsById[key.id()];
+    public <T> SynchedEntityData.DataItem<T> getItem(EntityDataAccessor<T> key) { // Paper - public
+        return (SynchedEntityData.DataItem<T>) this.itemsById[key.id()]; // CraftBukkit - decompile error
+     }
+ 
+     public <T> T get(EntityDataAccessor<T> data) {
+@@ -74,6 +74,13 @@
+ 
+     }
+ 
+    // CraftBukkit start - add method from above
+    public <T> void markDirty(EntityDataAccessor<T> datawatcherobject) {
+        this.getItem(datawatcherobject).setDirty(true);
+        this.isDirty = true;
+    }
+    // CraftBukkit end
+
+     public boolean isDirty() {
+         return this.isDirty;
+     }
+@@ -140,10 +147,24 @@
+         if (!Objects.equals(from.serializer(), to.accessor.serializer())) {
+             throw new IllegalStateException(String.format(Locale.ROOT, "Invalid entity data item type for field %d on entity %s: old=%s(%s), new=%s(%s)", to.accessor.id(), this.entity, to.value, to.value.getClass(), from.value, from.value.getClass()));
+         } else {
+-            to.setValue(from.value);
+            to.setValue((T) from.value); // CraftBukkit - decompile error
+         }
+     }
+ 
+    // Paper start
+    // We need to pack all as we cannot rely on "non default values" or "dirty" ones.
+    // Because these values can possibly be desynced on the client.
+    @Nullable
+    public List<SynchedEntityData.DataValue<?>> packAll() {
+        final List<SynchedEntityData.DataValue<?>> list = new ArrayList<>();
+        for (final DataItem<?> dataItem : this.itemsById) {
+            list.add(dataItem.value());
+        }
+
+        return list;
+    }
+    // Paper end
+
+     public static class DataItem<T> {
+ 
+         final EntityDataAccessor<T> accessor;