Restore compatibility with Java 17

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Copilot-Session: bc4164a2-025e-45ca-9dac-4d5ee4213627

.gitattributes

@@ -1 +1,2 @@
 * text=auto eol=lf
+.github/workflows/*.lock.yml linguist-generated=true merge=ours

.github/CONTRIBUTING.md

@@ -1,38 +1,72 @@
-Contributing to ProtocolLib
-===========================
-This page will detail specific things that must be done if you intend to contribute to this project.
+# Contributing to ProtocolLib
 
-## Updating ProtocolLib to a New Protocol Version
-#### Before we get started:
-1. **When do we need to update the protocol version?**
-    _A Minecraft protocol version is a number for each specification of the Minecraft protocol.
-    This means it is incremented when there is a change to the [Protocol Specification](http://wiki.vg/Protocol),
-    but not necessarily for each Minecraft version update. If the latest Minecraft version contains a protocol change,
-    that means ProtocolLib needs to be updated._
-2. **When do we need to update other parts of ProtocolLib?**
-    _When the package version guard changes. The package version guard is the version string inserted
-    into the package identifier for CraftBukkit and net.minecraft.server (e.g. v1_9_R2). It is incremented
-    by Spigot if there is a major breaking change in the internal server code. This is to encourage plugins
-    that interact directly with CraftBukkit/nms code to update more specifically. However, since most of
-    ProtocolLib uses reflection, and the structure of packet classes is generally static, one will have
-    to go through the code and change imports from nms/CraftBukkit._
+ProtocolLib supports a wide range of Minecraft versions through reflection and compatibility wrappers. Changes to packet
+registration, reflection, or public wrappers can affect plugins on versions other than the one currently used for
+development, so keep changes focused and preserve existing behavior unless a break is unavoidable.
 
-#### Ready? Let's get started!
-1. Read the [Protocol Changes](http://wiki.vg/Protocol_History). Always make sure the list is both
-complete and correct. If you're unsure, don't hesitate to ask in #mcdevs (the people who maintain wiki.vg) on [libera.chat](http://libera.chat)
-or #spigot on [irc.spi.gt](http://irc.spi.gt) ([webchat](https://irc.spi.gt/iris/?channels=spigot)).
-2. Search for usages of the now-defunct NMS package guard and change them.
-3. The class `com.comphenix.protocol.PacketType` contains a list of all the packets. If any packets were added or removed
-(or had their ID changed), make sure to update this list. If a packet was removed
-in favor of usage of another packet, instead of removing it, move it to the bottom of the list
-in its section, add a deprecation warning to it, and redirect it to the packet that replaced it.
-4. `mvn` in the root directory to build the project.
-5. If tests fail in the maven build, go through the tests to make sure you removed references to any removed packets
-and changed the NMS version guards.
-6. Increment the package version in `com.comphenix.protocol.utility.Constants`.
-7. `com.comphenix.protocol.ProtocolLibrary` contains several constants that must be updated, including the Minecraft version
-and the release date.
-8. `com.comphenix.protocol.utility.MinecraftProtocolVersion` contains a map of all the protocol version integers.
-If the protocol version has been incremented, add a new line to the map.
-9. `mvn` in root directory again. If it builds successfully, test on the appropriate version of a Spigot server. If
-the build fails, debug!
+## Building ProtocolLib
+
+Use the Gradle wrapper from the repository root. The build uses the Java 25 toolchain and resolves the current Spigot
+server dependency from the CodeMC repository.
+
+```shell
+./gradlew test
+./gradlew build shadowJar
+```
+
+`shadowJar` produces `build/libs/ProtocolLib.jar` with the required Byte Buddy classes included.
+
+ProtocolLib uses the Java 25 toolchain to compile against the current server, but production classes target Java 17 for
+compatibility with older supported servers.
+
+## Updating ProtocolLib for a Minecraft Release
+
+Start by reviewing the [Java Edition protocol](https://minecraft.wiki/w/Java_Edition_protocol) and the corresponding
+server classes. The server packet classes and codecs are authoritative when documentation and implementation differ.
+
+### 1. Update version metadata
+
+- Update `mcVersion` in `build.gradle.kts`.
+- Add the release to `MinecraftVersion` and update `MinecraftVersion.LATEST`.
+- Update `ProtocolLibrary.MAXIMUM_MINECRAFT_VERSION` and `ProtocolLibrary.MINECRAFT_LAST_RELEASE_DATE`.
+- Update `MinecraftProtocolVersion` if the release changed the protocol number.
+
+### 2. Reconcile packet types
+
+`PacketType` must contain a matching definition for every packet in the current server protocol registries. Compare the
+serverbound and clientbound packet classes and codecs against every protocol phase, including configuration.
+
+- Add new, renamed, or split packets and update their current IDs and aliases.
+- Do not remove an existing public `PacketType` constant. Move removed types to the deprecated section and document their
+  replacement when one exists.
+- Represent split packets as separate packet types instead of redirecting incompatible packet shapes.
+- Run the packet registry tests after changing packet definitions. A missing definition can prevent later packets in the
+  same protocol registry from being registered.
+
+### 3. Update reflection and wrappers
+
+- Inspect changed fields, constructors, records, nested classes, and stream codecs instead of relying only on class names.
+- Prefer structural or type-based reflection where names are unstable.
+- Put version checks at the narrowest compatibility boundary and leave the older path unchanged.
+- If an NMS concept was removed, report it as unsupported or absent rather than treating a different class as equivalent.
+- Preserve packet fields that are unrelated to the value being changed.
+- Keep converters symmetric and preserve wrapper cloning and equality semantics.
+- A custom `StructureModifier` must maintain the complete modifier contract, including safe reads and writes, field count,
+  metadata, introspection, defaults, and `withTarget()`.
+
+### 4. Add regression coverage
+
+- Initialize the test environment with `BukkitInitialization` when tests access CraftBukkit or NMS classes.
+- Exercise the actual packet structure supplied by the current Spigot dependency.
+- Cover both sides of a version guard when feasible.
+- Re-enable previously disabled tests when the underlying incompatibility is fixed.
+- Run targeted tests while developing, followed by `./gradlew test`.
+- Before declaring a Minecraft release supported, build the shaded plugin and test it on the corresponding server.
+
+## Pull Request Expectations
+
+- Keep the change limited to the reported problem or release update.
+- Include regression tests for packet, reflection, converter, or wrapper behavior changes.
+- Preserve public API signatures and binary compatibility where possible.
+- Clearly document any unavoidable compatibility change.
+- Do not hide reflection failures with broad exception handling or silent fallbacks.

.github/workflows/build.yml

@@ -1,18 +1,20 @@
 name: ProtocolLib full build lifecycle
 
 on:
-  - push
-  - pull_request
+  push:
+    branches-ignore:
+      - 'gh-pages'
+  pull_request:
 
 jobs:
   build:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Setup java
-        uses: actions/setup-java@v3
+        uses: actions/setup-java@v4
         with:
           distribution: 'temurin'
           java-version: '21'
@@ -22,7 +24,7 @@ jobs:
         run: ./gradlew build shadowJar --no-daemon
 
       - name: Upload plugin file
-        uses: actions/upload-artifact@v2
+        uses: actions/upload-artifact@v4
         with:
           name: ProtocolLib
           path: build/libs/ProtocolLib.jar

.github/workflows/codeql-analysis.yml

@@ -20,17 +20,17 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
 
       - name: Setup java
-        uses: actions/setup-java@v3
+        uses: actions/setup-java@v4
         with:
           distribution: 'temurin'
           java-version: '21'
           cache: 'gradle'
 
       - name: Initialize CodeQL
-        uses: github/codeql-action/init@v2
+        uses: github/codeql-action/init@v3
         with:
           languages: 'java'
 
@@ -38,4 +38,4 @@ jobs:
         run: ./gradlew build -x test --no-daemon
 
       - name: Perform CodeQL Analysis
-        uses: github/codeql-action/analyze@v2
+        uses: github/codeql-action/analyze@v3

.github/workflows/dev-build.yml

@@ -0,0 +1,43 @@
+name: ProtocolLib development build
+
+on:
+  push:
+    branches:
+      - master
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Setup java
+        uses: actions/setup-java@v4
+        with:
+          distribution: 'temurin'
+          java-version: '21'
+          cache: 'gradle'
+
+      - name: Run gradle build lifecycle
+        run: |
+          COMMIT_SHA=${{ github.sha }} ./gradlew build shadowJar --no-daemon
+
+      - name: Upload plugin file
+        uses: actions/upload-artifact@v4
+        with:
+          name: ProtocolLib
+          path: build/libs/ProtocolLib.jar
+
+      - name: Create or update GitHub pre-release
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          COMMIT_MSG=$(git log -1 --pretty=%B)
+          SHORT_HASH=$(echo "${{ github.sha }}" | cut -c1-7)
+          RELEASE_NOTES=$(gh release view dev-build --repo ${{ github.repository }} --json body -q ".body" 2>/dev/null || echo "")
+          gh release view dev-build --repo ${{ github.repository }} || \
+            gh release create dev-build --prerelease --title "Development Build" --notes "## Changelog" --repo ${{ github.repository }}
+          NEW_NOTES="$RELEASE_NOTES"$'\n'"* [$SHORT_HASH] $COMMIT_MSG"
+          gh release edit dev-build --notes "$NEW_NOTES" --repo ${{ github.repository }}
+          gh release upload dev-build build/libs/ProtocolLib.jar#ProtocolLib.jar --clobber --repo ${{ github.repository }}

.gitignore

@@ -181,4 +181,3 @@ logs/
 build/
 logs/
 .java-version
-gradle.properties

AGENTS.md

@@ -0,0 +1,123 @@
+# ProtocolLib Agent Guide
+
+This file applies to the entire repository. Read `.github/CONTRIBUTING.md` before changing Minecraft support, packet
+definitions, reflection, or public wrappers.
+
+## Repository Basics
+
+- The main project uses the Gradle wrapper. Do not use `TinyProtocol/pom.xml` to build ProtocolLib.
+- The Java toolchain and current Spigot dependency are defined in `build.gradle.kts`.
+- Keep the Java 25 build toolchain separate from the Java 17 production bytecode target.
+- Production code is under `src/main/java`; JUnit tests and NMS test initialization are under `src/test/java`.
+- Keep changes focused. Do not combine protocol fixes with unrelated cleanup or formatting.
+- Preserve public API and binary compatibility unless the task explicitly requires a breaking change.
+
+## Build and Test Commands
+
+```shell
+./gradlew test
+./gradlew build shadowJar
+```
+
+Run the smallest relevant test while developing:
+
+```shell
+./gradlew test --tests fully.qualified.TestClass
+./gradlew test --tests fully.qualified.TestClass.testMethod
+```
+
+After changing production Java code, run the targeted tests and then the complete test suite. Use `build shadowJar` when
+the task affects packaging, dependencies, release support, or the final plugin artifact.
+
+Do not introduce another build system, test runner, formatter, or lint tool unless the repository adopts it separately.
+
+## Important Code Areas
+
+- `PacketType.java`: public packet constants, current IDs, aliases, and deprecated packet definitions.
+- `injector/packet/internal/ProtocolRegistry_1_20_5.java`: current packet discovery and codec registration.
+- `utility/MinecraftVersion.java`: named Minecraft versions and the latest supported release.
+- `utility/MinecraftProtocolVersion.java`: Minecraft release to protocol-number mappings.
+- `ProtocolLibrary.java`: supported version bounds and latest release date.
+- `utility/MinecraftReflection.java`: centralized NMS and CraftBukkit class discovery.
+- `reflect/StructureModifier.java`: indexed packet field access and conversion contract.
+- `wrappers/`: stable public representations of unstable NMS structures.
+- `events/PacketContainer.java` and `events/AbstractStructure.java`: packet construction and typed field access.
+- `src/test/java/com/comphenix/protocol/BukkitInitialization.java`: test bootstrap for CraftBukkit and NMS access.
+
+## Minecraft Release Updates
+
+Follow the complete checklist in `.github/CONTRIBUTING.md`. In particular:
+
+- Update all version metadata together; do not bump only the Gradle dependency.
+- Reconcile every serverbound and clientbound packet in every protocol phase with `PacketType`.
+- Add packet types for newly split packets instead of forcing incompatible shapes through an older packet constant.
+- Preserve removed public `PacketType` constants in the deprecated section.
+- Update `MinecraftProtocolVersion` only when the protocol number actually changed.
+
+Every packet exposed by the current NMS protocol registries must have a matching `PacketType`. An undefined or incorrectly
+renamed packet can abort registration of later packets in the same registry.
+
+## Version Compatibility
+
+- Put version checks at the narrowest affected boundary.
+- Keep the pre-change code path intact whenever possible.
+- Use named `MinecraftVersion` constants with `atOrAbove()` instead of scattered version strings.
+- A public method should keep the same signature and broad contract across versions.
+- If Minecraft removed a concept, return an unsupported or absent result consistent with existing APIs. Do not claim an
+  unrelated packet or class is the removed type.
+- When Minecraft splits one packet into several packets, expose and use the new packet types explicitly.
+- Preserve unrelated packet fields when adapting or rewriting one logical value.
+
+The current test dependency exercises the latest supported server. Review older guarded paths carefully because they may
+not execute in the local test run.
+
+## Packet and Reflection Rules
+
+- Treat the current server packet classes, record components, constructors, and codecs as authoritative.
+- Prefer existing `MinecraftReflection`, `FuzzyReflection`, and accessor helpers over new direct reflection.
+- Prefer structural and type-based matching where obfuscated names are unstable.
+- Search for an existing class resolver, converter, or accessor before adding another one.
+- Cache stable reflective lookups following nearby patterns; do not repeatedly scan classes on packet hot paths.
+- Do not hide reflection failures with broad catches, silent defaults, or unrelated fallback types.
+- Account for static fields, inherited fields, records, nested implementations, and duplicate field types when writing
+  fuzzy contracts.
+
+## `StructureModifier` Contract
+
+Typed accessors returned from packet APIs must behave like normal `StructureModifier` instances.
+
+- `size()`, `getFields()`, `getField()`, target metadata, and field metadata must agree.
+- `readSafely()` returns `null` for an absent index.
+- `writeSafely()` ignores an absent index without throwing.
+- `withTarget()` must preserve the modifier's behavior for the new target.
+- `writeDefaults()` must remain safe.
+- Converters must be applied symmetrically on reads and writes.
+
+If a packet no longer contains a real backing field, prefer an empty modifier when compatible. If a virtual field is
+required for API compatibility, initialize all modifier metadata and test its inherited methods.
+
+## Wrapper and Converter Rules
+
+- Wrapper factories, converters, getters, setters, and `deepClone()` must describe the same logical value.
+- Preserve converter symmetry: converting specific to generic and back must not unexpectedly lose represented state.
+- If a wrapper handle changes from a nested value to an entire packet, define logical `equals()` and `hashCode()` so
+  unrelated packet metadata does not affect equality.
+- Clones that represent the same logical value should compare equal.
+- Do not fabricate legacy states that the modern wire format cannot distinguish; document or surface the limitation.
+- Record or immutable packet updates must retain entity IDs, flags, and other components not owned by the wrapper.
+
+## Tests
+
+- Call `BukkitInitialization.initializeAll()` before tests that resolve CraftBukkit or NMS classes.
+- Prefer regression tests using the actual Spigot packet classes supplied by the test dependency.
+- Test reads, writes, safe access, cloning, equality, and preservation of unrelated fields when changing wrappers.
+- Test modifier metadata and inherited methods when introducing a custom `StructureModifier`.
+- Re-enable disabled tests when fixing the incompatibility that caused them to be disabled.
+- Do not weaken assertions or encode known incorrect behavior merely to make a new Minecraft version pass.
+
+## Documentation and Review
+
+- Update Javadocs when version support, nullability, or unsupported behavior changes.
+- Update `.github/CONTRIBUTING.md` when the repository-wide build or release workflow changes.
+- Keep this file operational and durable; do not add task-specific notes, temporary workarounds, or current PR details.
+- Before finishing, inspect the complete diff for accidental API changes and unrelated edits.

PacketWrappers.md

@@ -0,0 +1,368 @@
+# Packet Wrappers
+
+Type-safe wrappers around ProtocolLib `PacketContainer` objects.
+Each wrapper lives under `net.dmulloy2.protocol.wrappers`, organized by protocol phase then direction.
+
+---
+
+## Package layout
+
+```
+net.dmulloy2.protocol/
+  AbstractPacket.java                          # base class for all wrappers
+
+  wrappers/
+    game/
+      clientbound/
+        WrappedClientbound<PacketName>Packet.java
+      serverbound/
+        WrappedServerbound<PacketName>Packet.java
+    login/
+      clientbound/ …
+      serverbound/ …
+    status/
+      clientbound/ …
+      serverbound/ …
+```
+
+New NMS types that are reusable across multiple packets belong in the core ProtocolLib packages, not here:
+
+| What | Where                                                                                 |
+|---|---------------------------------------------------------------------------------------|
+| New enum wrapper | inner enum + registration in `com.comphenix.protocol.wrappers.EnumWrappers            |
+| New structure wrapper | `com.comphenix.protocol.wrappers.Wrapped<Name>.java` + getter in `AbstractStructure`  |
+| Packet wrapper | `net.dmulloy2.protocol.wrappers.<phase>.<direction>.Wrapped<NMSPacketName>`           |
+
+---
+
+## Class Structure
+
+* Every wrapper extends `AbstractPacket`
+* There should be 3 constructors: no-args (create new packet with default values), all-args (create new packet with specified values), and from-container (wrap existing packet)
+* Then create getters and setters for each field in the packet, using the appropriate `StructureModifier` methods from `AbstractStructure`.
+
+```java
+package net.dmulloy2.protocol.wrappers.game.serverbound;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.events.PacketContainer;
+import com.comphenix.protocol.injector.PacketConstructor;
+import net.dmulloy2.protocol.AbstractPacket;
+
+public class WrappedServerboundAcceptTeleportationPacket extends AbstractPacket {
+
+    public static final PacketType TYPE = PacketType.Play.Client.TELEPORT_ACCEPT;
+
+    public WrappedServerboundAcceptTeleportationPacket() {
+        super(new PacketContainer(TYPE), TYPE);
+        handle.getModifier().writeDefaults();
+    }
+
+    public WrappedServerboundAcceptTeleportationPacket(int id) {
+        this(PacketConstructor.DEFAULT.withPacket(TYPE, new Class<?>[] { int.class }).createPacket(id));
+    }
+
+    public WrappedServerboundAcceptTeleportationPacket(PacketContainer packet) {
+        super(packet, TYPE);
+    }
+
+    // getters and setters for packet fields
+}
+```
+
+`AbstractPacket` validates the type and exposes `getHandle()`, `sendPacket(Player)`, and `receivePacket(Player)`.
+
+---
+
+## Reading and writing packet fields
+
+Always go through `AbstractStructure`'s typed getters. Never touch `getModifier()` directly or read raw field indices without a type-checked accessor.
+
+### Primitives
+
+```java
+handle.getIntegers().read(0)          // int
+handle.getIntegers().write(0, value)
+
+handle.getBooleans().read(0)          // boolean
+handle.getBooleans().write(0, value)
+
+handle.getFloat().read(0)             // float  (note: singular, not getFloats)
+handle.getFloat().write(0, value)
+
+handle.getLongs() / getDoubles() / getBytes() / getShorts() / getStrings() …
+```
+
+Field indices within a type are zero-based and ordered by their declaration order in the NMS class.
+
+### Bukkit / ProtocolLib wrapper types
+
+```java
+handle.getVectors().read(0)                     // org.bukkit.util.Vector  ↔  Vec3
+handle.getPositionMoveRotations().read(0)       // WrappedPositionMoveRotation  ↔  PositionMoveRotation
+handle.getEntityModifier(world).read(0)         // org.bukkit.entity.Entity
+handle.getItemModifier().read(0)                // org.bukkit.inventory.ItemStack
+handle.getBlockPositionModifier().read(0)       // BlockPosition
+handle.getNbtModifier().read(0)                 // NbtBase<?>
+handle.getDataWatcherModifier().read(0)         // WrappedDataWatcher
+// …see AbstractStructure for the full list
+```
+
+### Enums
+
+Use `EnumWrappers.get<Name>Converter()` with the appropriate accessor:
+
+```java
+// Single enum field
+handle.getEnumModifier(EnumWrappers.Hand.class, EnumWrappers.getHandClass()).read(0)
+
+// Set of enum values (e.g. RelativeArgument)
+handle.getSets(EnumWrappers.getRelativeArgumentConverter()).read(0)
+handle.getSets(EnumWrappers.getRelativeArgumentConverter()).write(0, set)
+```
+
+### Nested structures (InternalStructure)
+
+Only use `getStructures()` when you genuinely need to inspect a sub-structure that has no dedicated typed wrapper yet. Once you have written a `Wrapped<Name>` class, add a getter to `AbstractStructure` and use that instead.
+
+---
+
+## Adding a new NMS enum wrapper
+
+1. **Declare** the enum as an inner class of `EnumWrappers`, matching NMS constant names exactly:
+
+```java
+// EnumWrappers.java
+public enum RelativeArgument {
+    X, Y, Z, Y_ROT, X_ROT, DELTA_X, DELTA_Y, DELTA_Z, ROTATE_DELTA
+}
+```
+
+2. **Register** the NMS class, class getter, converter, and `associate()` call — all following the same pattern as `Hand`, `Direction`, etc.:
+
+```java
+// static field
+private static Class<?> RELATIVE_CLASS = null;
+
+// inside initialize() — class loading
+RELATIVE_CLASS = MinecraftReflection.getMinecraftClass("world.entity.Relative");
+
+// inside initialize() — association
+associate(RELATIVE_CLASS, RelativeArgument.class, getRelativeArgumentConverter());
+
+// public API
+public static Class<?> getRelativeArgumentClass() {
+    initialize();
+    return RELATIVE_CLASS;
+}
+
+public static EquivalentConverter<RelativeArgument> getRelativeArgumentConverter() {
+    return new EnumConverter<>(getRelativeArgumentClass(), RelativeArgument.class);
+}
+```
+
+`EnumConverter` maps by constant name (`Enum.valueOf`). Use it whenever the NMS class **is** a real Java enum and the constant names match. Use `FauxEnumConverter` only for NMS classes that are enum-like but not `java.lang.Enum`.
+
+---
+
+## Adding a new NMS structure wrapper
+
+`PositionMoveRotation` is the reference example.
+
+### 1 — Create `com.comphenix.protocol.wrappers.Wrapped<Name>.java`
+
+```java
+public class WrappedPositionMoveRotation {
+
+    // mutable fields matching the NMS record
+
+    /** Read from a live InternalStructure using AbstractStructure typed getters. */
+    public static WrappedPositionMoveRotation fromHandle(InternalStructure handle) {
+        WrappedPositionMoveRotation w = new WrappedPositionMoveRotation();
+        Vector pos   = handle.getVectors().read(0);
+        Vector delta = handle.getVectors().read(1);
+        w.x = pos.getX();  w.y = pos.getY();  w.z = pos.getZ();
+        w.deltaX = delta.getX(); …
+        w.yaw   = handle.getFloat().read(0);
+        w.pitch = handle.getFloat().read(1);
+        return w;
+    }
+
+    /**
+     * Returns an EquivalentConverter for use in StructureModifier.withType().
+     *
+     * getSpecific — delegates to fromHandle(InternalStructure)
+     * getGeneric  — constructs a new NMS record via its public constructor
+     */
+    public static EquivalentConverter<WrappedPositionMoveRotation> getConverter() {
+        return new EquivalentConverter<>() {
+            @Override
+            public WrappedPositionMoveRotation getSpecific(Object generic) {
+                return fromHandle(InternalStructure.getConverter().getSpecific(generic));
+            }
+            @Override
+            public Object getGeneric(WrappedPositionMoveRotation s) {
+                try {
+                    Class<?> vec3 = MinecraftReflection.getVec3DClass();
+                    Class<?> pmr  = MinecraftReflection.getMinecraftClass("world.entity.PositionMoveRotation");
+                    Constructor<?> v = vec3.getDeclaredConstructor(double.class, double.class, double.class);
+                    Constructor<?> p = pmr.getDeclaredConstructor(vec3, vec3, float.class, float.class);
+                    return p.newInstance(v.newInstance(s.x, s.y, s.z),
+                                        v.newInstance(s.deltaX, s.deltaY, s.deltaZ),
+                                        s.yaw, s.pitch);
+                } catch (ReflectiveOperationException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            @Override public Class<WrappedPositionMoveRotation> getSpecificType() {
+                return WrappedPositionMoveRotation.class;
+            }
+        };
+    }
+}
+```
+
+**Reading** always goes through `AbstractStructure` getters (`getVectors()`, `getFloat()`, …) — never raw field accessors.
+**Writing** must construct a fresh NMS instance when the NMS type is an immutable record (final fields). Mutable NMS classes can be modified via their own `InternalStructure` instead.
+
+### 2 — Add a getter to `AbstractStructure`
+
+```java
+// AbstractStructure.java — alongside getVectors(), getIntegers(), etc.
+public StructureModifier<WrappedPositionMoveRotation> getPositionMoveRotations() {
+    return structureModifier.withType(
+            MinecraftReflection.getMinecraftClass("world.entity.PositionMoveRotation"),
+            WrappedPositionMoveRotation.getConverter());
+}
+```
+
+### 3 — Use it in the packet wrapper
+
+```java
+public WrappedPositionMoveRotation getChange() {
+    return handle.getPositionMoveRotations().read(0);
+}
+
+public void setChange(WrappedPositionMoveRotation change) {
+    handle.getPositionMoveRotations().write(0, change);
+}
+```
+
+---
+
+## Unit tests
+
+Each wrapper class gets its own test file named `<WrapperClassName>Test.java`, co-located with the wrapper under `src/test/java/net/dmulloy2/protocol/wrappers/<phase>/<direction>/`. Do not combine tests for multiple wrappers in a single file.
+
+Every test class must call `BukkitInitialization.initializeAll()` in a `@BeforeAll` method — this bootstraps the Minecraft registry and mocked Bukkit server required for `PacketContainer` and NMS reflection to work.
+
+Cover these scenarios for each wrapper:
+
+* testAllArgsCreate
+  * Construct a fresh wrapper using the all-args constructor with known test values
+  * Get the NMS handle packet via `getHandle()`
+  * Assert that all fields in the NMS handle match the known test values
+* testNoArgsCreate
+    * Construct a fresh wrapper using the no-args constructor
+    * Get the NMS handle packet via `getHandle()`
+    * Assert that all fields in the NMS handle are not null
+* testModifyExistingPacket
+  * Create the NMS handle packet directly from its constructor, passing known test values
+  * Create a packet container from the NMS handle via `PacketContainer.fromPacket()`
+  * Construct the wrapper using the packet container
+  * Assert that all fields in the wrapper match the known test values
+  * Change all fields in the wrapper to new test values
+  * Verify that the NMS handle packet reflects the new test values
+* testWrongPacketTypeThrows
+  * Create a packet container for a different packet type
+  * Attempt to construct the wrapper using this incorrect packet container
+  * Assert that an appropriate exception is thrown (e.g. IllegalArgumentException)
+
+### Appropriate test values
+
+* For numeric fields, use a mix of positive, negative, and zero values (e.g. -5, 0, 3)
+* For enum fields, prefer the 2nd or 3rd constant rather than the first, to ensure the wrapper correctly handles non-default enum values
+  * Additionally, if the enum constant is @Deprecated, do not use it
+
+Here's a good example of a complete test class for `WrappedClientboundSetExperiencePacket`:
+
+```java
+class WrappedClientboundSetExperiencePacketTest {
+
+    @BeforeAll
+    static void beforeAll() {
+        BukkitInitialization.initializeAll();
+    }
+
+    @Test
+    void testAllArgsCreate() {
+        WrappedClientboundSetExperiencePacket w = new WrappedClientboundSetExperiencePacket(0.75f, 350, 12);
+
+        assertEquals(PacketType.Play.Server.EXPERIENCE, w.getHandle().getType());
+
+        ClientboundSetExperiencePacket p = (ClientboundSetExperiencePacket) w.getHandle().getHandle();
+
+        assertEquals(0.75f, p.getExperienceProgress(), 1e-4f);
+        assertEquals(350,   p.getTotalExperience());
+        assertEquals(12,    p.getExperienceLevel());
+    }
+    
+    @Test
+    void testNoArgsCreate() {
+        WrappedClientboundSetExperiencePacket w = new WrappedClientboundSetExperiencePacket();
+
+        assertEquals(PacketType.Play.Server.EXPERIENCE, w.getHandle().getType());
+
+        ClientboundSetExperiencePacket p = (ClientboundSetExperiencePacket) w.getHandle().getHandle();
+
+        assertEquals(0.0f, p.getExperienceProgress(), 1e-4f);
+        assertEquals(0,    p.getTotalExperience());
+        assertEquals(0,    p.getExperienceLevel());
+    }
+
+    @Test
+    void testModifyExistingPacket() {
+        ClientboundSetExperiencePacket nmsPacket = new ClientboundSetExperiencePacket(
+                0.5f, 100, 5
+        );
+
+        PacketContainer container = PacketContainer.fromPacket(nmsPacket);
+        WrappedClientboundSetExperiencePacket wrapper = new WrappedClientboundSetExperiencePacket(container);
+
+        assertEquals(0.5f, wrapper.getExperienceProgress(), 1e-4f);
+        assertEquals(100, wrapper.getTotalExperience());
+        assertEquals(5,   wrapper.getExperienceLevel());
+        
+        wrapper.setExperienceProgress(0.25f);
+        wrapper.setTotalExperience(200);
+        wrapper.setExperienceLevel(10);
+        
+        assertEquals(0.25f, nmsPacket.getExperienceProgress(), 1e-4f);
+        assertEquals(200, nmsPacket.getTotalExperience());
+        assertEquals(10, nmsPacket.getExperienceLevel());
+    }
+
+    @Test
+    void testModifyExistingPacket() {
+        ClientboundSetExperiencePacket nmsPacket = new ClientboundSetExperiencePacket(
+                0.5f, 100, 5
+        );
+
+        PacketContainer container = PacketContainer.fromPacket(nmsPacket);
+        WrappedClientboundSetExperiencePacket wrapper = new WrappedClientboundSetExperiencePacket(container);
+
+        wrapper.setTotalExperience(200);
+
+        assertEquals(0.5f, wrapper.getExperienceProgress(), 1e-4f);
+        assertEquals(200, wrapper.getTotalExperience());
+        assertEquals(5,   wrapper.getExperienceLevel());
+    }
+
+    @Test
+    void testWrongPacketTypeThrows() {
+        assertThrows(IllegalArgumentException.class,
+                () -> new WrappedClientboundSetExperiencePacket(
+                        new PacketContainer(PacketType.Play.Server.CHAT)));
+    }
+}
+```

Readme.md

@@ -2,7 +2,7 @@
 
 Certain tasks are impossible to perform with the standard Bukkit API, and may require
 working with and even modifying Minecraft directly. A common technique is to modify incoming
-and outgoing [packets](https://wiki.vg/Protocol), or inject custom packets into the
+and outgoing packets, or inject custom packets into the
 stream. This is quite cumbersome to do, however, and most implementations will break
 as soon as a new version of Minecraft has been released, mostly due to obfuscation.
 
@@ -12,9 +12,11 @@ lead to more subtle bugs.
 
 ### Resources
 
-* [Resource Page](https://www.spigotmc.org/resources/protocollib.1997/)
-* [Dev Builds](https://ci.dmulloy2.net/job/ProtocolLib)
-* [JavaDoc](https://ci.dmulloy2.net/job/ProtocolLib/javadoc/index.html)
+* [Spigot Page](https://spigotmc.org/resources/protocollib.1997/)
+* [Releases](https://github.com/dmulloy2/ProtocolLib/releases)
+* [Dev Build](https://github.com/dmulloy2/ProtocolLib/releases/tag/dev-build)
+* [JavaDoc](https://dmulloy2.net/ProtocolLib/javadoc/)
+* [Protocol Wiki](https://minecraft.wiki/w/Minecraft_Wiki:Projects/wiki.vg_merge/Protocol)
 
 ### Compilation
 
@@ -42,18 +44,11 @@ depend: [ ProtocolLib ]
 You can also add ProtocolLib as a Maven dependency:
 
 ````xml
-<repositories>
-  <repository>
-    <id>dmulloy2-repo</id>
-    <url>https://repo.dmulloy2.net/repository/public/</url>
-  </repository>
-</repositories>
-
 <dependencies>
   <dependency>
-    <groupId>com.comphenix.protocol</groupId>
+    <groupId>net.dmulloy2</groupId>
     <artifactId>ProtocolLib</artifactId>
-    <version>5.1.0</version>
+    <version>5.4.0</version>
     <scope>provided</scope>
   </dependency>
 </dependencies>
@@ -63,11 +58,11 @@ Or use the maven dependency with gradle:
 
 ```gradle
 repositories {
-    maven { url "https://repo.dmulloy2.net/repository/public/" }
+    mavenCentral()
 }
 
 dependencies {
-    compileOnly 'com.comphenix.protocol:ProtocolLib:5.1.0'
+    compileOnly 'net.dmulloy2:ProtocolLib:5.4.0'
 }
 ```
 

TinyProtocol/src/main/java/com/comphenix/tinyprotocol/TinyProtocol.java

@@ -64,7 +64,7 @@ public abstract class TinyProtocol {
 
     // Packets we have to intercept
     private static final Class<?> PACKET_LOGIN_IN_START = Reflection.getClass("{nms}.PacketLoginInStart", "net.minecraft.network.protocol.login.PacketLoginInStart");
-    private static final FieldAccessor<GameProfile> getGameProfile = Reflection.getField(PACKET_LOGIN_IN_START, GameProfile.class, 0);
+    private static final FieldAccessor<String> getPlayerName = new PlayerNameAccessor();
 
     // Speedup channel lookup
     private Map<String, Channel> channelLookup = new MapMaker().weakValues().makeMap();
@@ -492,6 +492,59 @@ public abstract class TinyProtocol {
         }
     }
 
+    /**
+     * Get the player name from the login start packet.
+     * This fixes the issue from 1.19 where the GameProfile field has been removed from this login packet.
+     *
+     * @author gamerover98
+     */
+    private static class PlayerNameAccessor implements FieldAccessor<String> {
+
+        private FieldAccessor<String> getPlayerName;
+        private FieldAccessor<GameProfile> getGameProfile;
+
+        PlayerNameAccessor() {
+            try {
+                this.getGameProfile = Reflection.getField(PACKET_LOGIN_IN_START, GameProfile.class, 0);
+            } catch (IllegalArgumentException illegalArgumentException) {
+                // nothing to do.
+            }
+
+            try {
+                //HOT-FIX for 1.19+
+                this.getPlayerName = Reflection.getField(PACKET_LOGIN_IN_START, String.class, 0);
+            } catch (IllegalArgumentException illegalArgumentException) {
+                // nothing to do.
+            }
+
+            if (getGameProfile == null && getPlayerName == null) {
+                throw new UnsupportedOperationException("The current server version is not supported by TinyProtocol");
+            }
+        }
+
+        @Override
+        public String get(Object target) {
+            if (getPlayerName != null) {
+                String playerName = getPlayerName.get(target);
+                return playerName.substring(0, Math.min(16, playerName.length()));
+            }
+
+            return getGameProfile.get(target).getName();
+        }
+
+        @Override
+        public void set(Object target, Object value) {
+            throw new UnsupportedOperationException("Not supported");
+        }
+
+        @Override
+        public boolean hasField(Object target) {
+            return getPlayerName != null
+                    ? getPlayerName.hasField(target)
+                    : getGameProfile.hasField(target);
+        }
+    }
+
     /**
      * Channel handler that is inserted into the player's channel pipeline, allowing us to intercept sent and received packets.
      * 
@@ -533,8 +586,7 @@ public abstract class TinyProtocol {
 
         private void handleLoginStart(Channel channel, Object packet) {
             if (PACKET_LOGIN_IN_START.isInstance(packet)) {
-                GameProfile profile = getGameProfile.get(packet);
-                channelLookup.put(profile.getName(), channel);
+                channelLookup.put(getPlayerName.get(packet), channel);
             }
         }
     }

build.gradle

@@ -1,130 +0,0 @@
-plugins {
-    id 'java-library'
-    id 'maven-publish'
-    id 'com.github.johnrengelman.shadow' version '8.1.1'
-}
-
-group = 'com.comphenix.protocol'
-version = '5.3.0-SNAPSHOT'
-description = 'Provides access to the Minecraft protocol'
-
-def isSnapshot = version.endsWith('-SNAPSHOT')
-
-repositories {
-    // mavenLocal() // can speed up build, but may fail in CI
-    mavenCentral()
-
-    maven {
-        url 'https://repo.dmulloy2.net/repository/public/'
-    }
-
-    maven {
-        url 'https://hub.spigotmc.org/nexus/content/groups/public/'
-    }
-
-    maven {
-        url 'https://libraries.minecraft.net/'
-        metadataSources {
-            mavenPom()
-            artifact()
-            ignoreGradleMetadataRedirection()
-        }
-    }
-}
-
-dependencies {
-    implementation 'net.bytebuddy:byte-buddy:1.14.14'
-    compileOnly 'org.spigotmc:spigot-api:1.20.6-R0.1-SNAPSHOT'
-    compileOnly 'org.spigotmc:spigot:1.21-R0.1-SNAPSHOT'
-    compileOnly 'io.netty:netty-all:4.0.23.Final'
-    compileOnly 'net.kyori:adventure-text-serializer-gson:4.14.0'
-    compileOnly 'com.googlecode.json-simple:json-simple:1.1.1'
-
-    testImplementation 'org.junit.jupiter:junit-jupiter-engine:5.10.0'
-    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.10.0'
-    testRuntimeOnly 'org.junit.platform:junit-platform-launcher:1.10.0'
-    testImplementation 'org.mockito:mockito-core:5.6.0'
-    testImplementation 'io.netty:netty-common:4.1.97.Final'
-    testImplementation 'io.netty:netty-transport:4.1.97.Final'
-    testImplementation 'org.spigotmc:spigot:1.21-R0.1-SNAPSHOT'
-    testImplementation 'net.kyori:adventure-text-serializer-gson:4.14.0'
-    testImplementation 'net.kyori:adventure-text-serializer-plain:4.14.0'
-}
-
-java {
-    sourceCompatibility = JavaVersion.VERSION_1_8
-    targetCompatibility = JavaVersion.VERSION_1_8
-
-    withJavadocJar()
-    withSourcesJar()
-}
-
-jar {
-    manifest {
-        attributes(
-                'paperweight-mappings-namespace': 'mojang'
-        )
-    }
-}
-
-shadowJar {
-    dependencies {
-        include(dependency('net.bytebuddy:byte-buddy:.*'))
-    }
-    relocate 'net.bytebuddy', 'com.comphenix.net.bytebuddy'
-    archiveFileName = 'ProtocolLib.jar'
-}
-
-test {
-    useJUnitPlatform()
-    testLogging {
-        exceptionFormat = 'full'
-    }
-}
-
-compileTestJava {
-    sourceCompatibility = JavaVersion.VERSION_21
-    targetCompatibility = JavaVersion.VERSION_21
-}
-
-processResources {
-    def includeBuild = isSnapshot && System.getenv('BUILD_NUMBER')
-    def fullVersion = includeBuild
-        ? version + '-' + System.getenv('BUILD_NUMBER')
-        : version
-
-    eachFile { expand(['version': fullVersion]) }
-}
-
-publishing {
-    publications {
-        mavenJava(MavenPublication) {
-            from components.java
-
-            afterEvaluate {
-                artifactId = 'ProtocolLib'
-            }
-        }
-    }
-
-    repositories {
-        maven {
-            url isSnapshot
-                ? 'https://repo.dmulloy2.net/repository/snapshots/'
-                : 'https://repo.dmulloy2.net/repository/releases/'
-
-            credentials {
-                username project.nexusUsername
-                password project.nexusPassword
-            }
-        }
-    }
-}
-
-tasks.withType(JavaCompile) {
-    options.encoding = 'UTF-8'
-}
-
-tasks.withType(Javadoc) {
-    options.encoding = 'UTF-8'
-}

build.gradle.kts

@@ -0,0 +1,167 @@
+import org.gradle.api.tasks.testing.logging.TestExceptionFormat
+
+plugins {
+    `java-library`
+    `maven-publish`
+    signing
+    id("com.gradleup.shadow") version "9.4.0"
+    id("io.github.patrick.remapper") version "1.4.3"
+    id("com.vanniktech.maven.publish") version "0.36.0"
+}
+
+group = "net.dmulloy2"
+description = "Provides access to the Minecraft protocol"
+
+val mcVersion = "26.2"
+val isSnapshot = version.toString().endsWith("-SNAPSHOT")
+val isJitPack = System.getenv("JITPACK")?.equals("true", ignoreCase = true) ?: false
+val commitHash = System.getenv("COMMIT_SHA") ?: ""
+val isCI = commitHash.isNotEmpty()
+
+repositories {
+    if (!isCI) {
+        mavenLocal()
+    }
+
+    mavenCentral()
+
+    maven {
+        url = uri("https://repo.codemc.io/repository/nms/")
+    }
+
+    maven {
+        url = uri("https://hub.spigotmc.org/nexus/content/groups/public/")
+    }
+
+    maven {
+        url = uri("https://libraries.minecraft.net/")
+        metadataSources {
+            mavenPom()
+            artifact()
+            ignoreGradleMetadataRedirection()
+        }
+    }
+}
+
+dependencies {
+    implementation("net.bytebuddy:byte-buddy:1.18.2")
+    compileOnly("org.spigotmc:spigot-api:${mcVersion}-R0.1-SNAPSHOT")
+    compileOnly("org.spigotmc:spigot:${mcVersion}-R0.1-SNAPSHOT")//:remapped-mojang")
+    compileOnly("io.netty:netty-all:4.2.8.Final")
+    compileOnly("net.kyori:adventure-text-serializer-gson:4.25.0")
+    compileOnly("com.googlecode.json-simple:json-simple:1.1.1")
+
+    testImplementation("org.junit.jupiter:junit-jupiter-engine:6.0.1")
+    testRuntimeOnly("org.junit.jupiter:junit-jupiter-engine:6.0.1")
+    testRuntimeOnly("org.junit.platform:junit-platform-launcher:6.0.1")
+    testImplementation("org.mockito:mockito-core:5.21.0")
+    testImplementation("io.netty:netty-common:4.2.8.Final")
+    testImplementation("io.netty:netty-transport:4.2.8.Final")
+    testImplementation("org.spigotmc:spigot:${mcVersion}-R0.1-SNAPSHOT")//:remapped-mojang")
+    testImplementation("net.kyori:adventure-text-serializer-gson:4.25.0")
+    testImplementation("net.kyori:adventure-text-serializer-plain:4.25.0")
+}
+
+java {
+    toolchain {
+        languageVersion.set(JavaLanguageVersion.of(25))
+    }
+}
+
+tasks {
+    processResources {
+        val fullVersion = if (isSnapshot && isCI) "${version}-${commitHash.take(7)}" else version
+
+        eachFile {
+            expand("version" to fullVersion)
+        }
+    }
+
+    test {
+        useJUnitPlatform()
+        testLogging {
+            exceptionFormat = TestExceptionFormat.FULL
+        }
+    }
+
+    shadowJar {
+        dependencies {
+            include(dependency("net.bytebuddy:byte-buddy:.*"))
+        }
+        relocate("net.bytebuddy", "com.comphenix.net.bytebuddy")
+
+        manifest {
+            attributes(
+                "paperweight-mappings-namespace" to "mojang"
+            )
+        }
+
+        archiveFileName = "ProtocolLib.jar"
+    }
+
+    /*remap {
+        dependsOn("shadowJar")
+
+        inputTask.set(getByName<ShadowJar>("shadowJar"))
+        version.set(mcVersion)
+        action.set(RemapTask.Action.MOJANG_TO_SPIGOT)
+    }
+
+    assemble {
+        dependsOn("remap")
+    }*/
+
+    javadoc {
+        options.encoding = "UTF-8"
+    }
+
+    compileJava {
+        options.encoding = "UTF-8"
+        options.release.set(17)
+    }
+}
+
+mavenPublishing {
+    publishToMavenCentral()
+    if (!isSnapshot && !isJitPack) {
+        signAllPublications()
+    }
+
+    coordinates("$group", project.name, "$version")
+
+    pom {
+        name.set(project.name)
+        description.set(project.description)
+        inceptionYear.set("2012")
+        url.set("https://github.com/dmulloy2/ProtocolLib")
+
+        developers {
+            developer {
+                id.set("dmulloy2")
+                name.set("Dan Mulloy")
+                url.set("https://dmulloy2.net/")
+                email.set("dev@dmulloy2.net")
+            }
+        }
+
+        licenses {
+            license {
+                name.set("GNU GENERAL PUBLIC LICENSE - Version 2, June 1991")
+                url.set("https://www.gnu.org/licenses/gpl-2.0.txt")
+                distribution.set("repo")
+            }
+        }
+
+        scm {
+            tag.set("HEAD")
+            url.set("https://github.com/dmulloy2/ProtocolLib")
+            connection.set("scm:git:git://github.com/dmulloy2/ProtocolLib.git")
+            developerConnection.set("scm:git:git@github.com:dmulloy2/ProtocolLib.git")
+        }
+
+        issueManagement {
+            system.set("GitHub Issues")
+            url.set("https://github.com/dmulloy2/ProtocolLib/issues")
+        }
+    }
+}

gradle.properties

@@ -1,2 +1,6 @@
-nexusUsername=""
-nexusPassword=""
+version=5.5.0-SNAPSHOT
+mavenCentralUsername=
+mavenCentralPassword=
+signing.keyId=
+signing.password=
+signing.secretKeyRingFile=

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.5-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.4.1-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

gradlew

@@ -1,7 +1,7 @@
 #!/bin/sh
 
 #
-# Copyright © 2015-2021 the original authors.
+# Copyright © 2015 the original authors.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -15,6 +15,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+# SPDX-License-Identifier: Apache-2.0
+#
 
 ##############################################################################
 #
@@ -55,7 +57,7 @@
 #       Darwin, MinGW, and NonStop.
 #
 #   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/HEAD/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       https://github.com/gradle/gradle/blob/2d6327017519d23b96af35865dc997fcb544fb40/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
 #       within the Gradle project.
 #
 #       You can find Gradle at https://github.com/gradle/gradle/.
@@ -84,7 +86,7 @@ done
 # shellcheck disable=SC2034
 APP_BASE_NAME=${0##*/}
 # Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
-APP_HOME=$( cd "${APP_HOME:-./}" > /dev/null && pwd -P ) || exit
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD=maximum
@@ -112,7 +114,6 @@ case "$( uname )" in                #(
   NONSTOP* )        nonstop=true ;;
 esac
 
-CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
 
 # Determine the Java command to use to start the JVM.
@@ -170,7 +171,6 @@ fi
 # For Cygwin or MSYS, switch paths to Windows format before running java
 if "$cygwin" || "$msys" ; then
     APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
-    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
 
     JAVACMD=$( cygpath --unix "$JAVACMD" )
 
@@ -203,15 +203,14 @@ fi
 DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
 
 # Collect all arguments for the java command:
-#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
 #     and any embedded shellness will be escaped.
 #   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
 #     treated as '${Hostname}' itself on the command line.
 
 set -- \
         "-Dorg.gradle.appname=$APP_BASE_NAME" \
-        -classpath "$CLASSPATH" \
-        org.gradle.wrapper.GradleWrapperMain \
+        -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
         "$@"
 
 # Stop when "xargs" is not available.

gradlew.bat

@@ -13,6 +13,8 @@
 @rem See the License for the specific language governing permissions and
 @rem limitations under the License.
 @rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
 
 @if "%DEBUG%"=="" @echo off
 @rem ##########################################################################
@@ -43,11 +45,11 @@ set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
 if %ERRORLEVEL% equ 0 goto execute
 
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
 
 goto fail
 
@@ -57,22 +59,21 @@ set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
 if exist "%JAVA_EXE%" goto execute
 
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
 
 goto fail
 
 :execute
 @rem Setup the command line
 
-set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
 
 @rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %*
 
 :end
 @rem End local scope for the variables with windows NT shell

src/main/java/com/comphenix/protocol/PacketType.java

@@ -14,18 +14,18 @@ import java.util.Map;
 import java.util.UUID;
 import java.util.function.BiConsumer;
 
+import org.apache.commons.lang.WordUtils;
+import org.bukkit.Bukkit;
+
 import com.comphenix.protocol.PacketTypeLookup.ClassLookup;
 import com.comphenix.protocol.events.ConnectionSide;
 import com.comphenix.protocol.injector.packet.PacketRegistry;
 import com.comphenix.protocol.scheduler.UniversalRunnable;
 import com.comphenix.protocol.utility.MinecraftReflection;
 import com.comphenix.protocol.utility.MinecraftVersion;
-
 import com.google.common.base.Preconditions;
 import com.google.common.collect.ComparisonChain;
 import com.google.common.collect.Iterables;
-import org.apache.commons.lang.WordUtils;
-import org.bukkit.Bukkit;
 /**
  * Represents the type of a packet in a specific protocol.
  * <p>
@@ -109,130 +109,145 @@ public class PacketType implements Serializable, Cloneable, Comparable<PacketTyp
 
             public static final PacketType BUNDLE =                       new PacketType(PROTOCOL, SENDER, 0x00, "BundleDelimiter", "Delimiter", "BundleDelimiterPacket");
             public static final PacketType SPAWN_ENTITY =                 new PacketType(PROTOCOL, SENDER, 0x01, "AddEntity", "SpawnEntity", "SPacketSpawnObject");
-            public static final PacketType SPAWN_ENTITY_EXPERIENCE_ORB =  new PacketType(PROTOCOL, SENDER, 0x02, "AddExperienceOrb", "SpawnEntityExperienceOrb", "SPacketSpawnExperienceOrb");
-            public static final PacketType ANIMATION =                    new PacketType(PROTOCOL, SENDER, 0x03, "Animate", "Animation", "SPacketAnimation");
-            public static final PacketType STATISTIC =                    new PacketType(PROTOCOL, SENDER, 0x04, "AwardStats", "Statistic", "SPacketStatistics");
-            public static final PacketType BLOCK_CHANGED_ACK =            new PacketType(PROTOCOL, SENDER, 0x05, "BlockChangedAck");
-            public static final PacketType BLOCK_BREAK_ANIMATION =        new PacketType(PROTOCOL, SENDER, 0x06, "BlockDestruction", "BlockBreakAnimation", "SPacketBlockBreakAnim");
-            public static final PacketType TILE_ENTITY_DATA =             new PacketType(PROTOCOL, SENDER, 0x07, "BlockEntityData", "TileEntityData", "SPacketUpdateTileEntity");
-            public static final PacketType BLOCK_ACTION =                 new PacketType(PROTOCOL, SENDER, 0x08, "BlockEvent", "BlockAction", "SPacketBlockAction");
-            public static final PacketType BLOCK_CHANGE =                 new PacketType(PROTOCOL, SENDER, 0x09, "BlockUpdate", "BlockChange", "SPacketBlockChange");
-            public static final PacketType BOSS =                         new PacketType(PROTOCOL, SENDER, 0x0A, "BossEvent", "Boss", "SPacketUpdateBossInfo");
-            public static final PacketType SERVER_DIFFICULTY =            new PacketType(PROTOCOL, SENDER, 0x0B, "ChangeDifficulty", "ServerDifficulty", "SPacketServerDifficulty");
-            public static final PacketType CHUNK_BATCH_FINISHED =         new PacketType(PROTOCOL, SENDER, 0x0C, "ChunkBatchFinished");
-            public static final PacketType CHUNK_BATCH_START =            new PacketType(PROTOCOL, SENDER, 0x0D, "ChunkBatchStart");
-            public static final PacketType CHUNKS_BIOMES =                new PacketType(PROTOCOL, SENDER, 0x0E, "ChunksBiomes", "ClientboundChunksBiomesPacket");
-            public static final PacketType CLEAR_TITLES =                 new PacketType(PROTOCOL, SENDER, 0x0F, "ClearTitles");
-            public static final PacketType TAB_COMPLETE =                 new PacketType(PROTOCOL, SENDER, 0x10, "CommandSuggestions", "TabComplete", "SPacketTabComplete");
-            public static final PacketType COMMANDS =                     new PacketType(PROTOCOL, SENDER, 0x11, "Commands");
-            public static final PacketType CLOSE_WINDOW =                 new PacketType(PROTOCOL, SENDER, 0x12, "ContainerClose", "CloseWindow", "SPacketCloseWindow");
-            public static final PacketType WINDOW_ITEMS =                 new PacketType(PROTOCOL, SENDER, 0x13, "ContainerSetContent", "WindowItems", "SPacketWindowItems");
-            public static final PacketType WINDOW_DATA =                  new PacketType(PROTOCOL, SENDER, 0x14, "ContainerSetData", "WindowData", "SPacketWindowProperty");
-            public static final PacketType SET_SLOT =                     new PacketType(PROTOCOL, SENDER, 0x15, "ContainerSetSlot", "SetSlot", "SPacketSetSlot");
-            public static final PacketType COOKIE_REQUEST =               new PacketType(PROTOCOL, SENDER, 0x16, "CookieRequest");
-            public static final PacketType SET_COOLDOWN =                 new PacketType(PROTOCOL, SENDER, 0x17, "Cooldown", "SetCooldown", "SPacketCooldown");
-            public static final PacketType CUSTOM_CHAT_COMPLETIONS =      new PacketType(PROTOCOL, SENDER, 0x18, "CustomChatCompletions");
-            public static final PacketType CUSTOM_PAYLOAD =               new PacketType(PROTOCOL, SENDER, 0x19, "CustomPayload", "SPacketCustomPayload");
-            public static final PacketType DAMAGE_EVENT =                 new PacketType(PROTOCOL, SENDER, 0x1A, "DamageEvent", "ClientboundDamageEventPacket");
-            public static final PacketType DEBUG_SAMPLE =                 new PacketType(PROTOCOL, SENDER, 0x1B, "DebugSample");
-            public static final PacketType DELETE_CHAT_MESSAGE =          new PacketType(PROTOCOL, SENDER, 0x1C, "DeleteChat");
-            public static final PacketType KICK_DISCONNECT =              new PacketType(PROTOCOL, SENDER, 0x1D, "Disconnect", "KickDisconnect", "SPacketDisconnect");
-            public static final PacketType DISGUISED_CHAT =               new PacketType(PROTOCOL, SENDER, 0x1E, "DisguisedChat");
-            public static final PacketType ENTITY_STATUS =                new PacketType(PROTOCOL, SENDER, 0x1F, "EntityEvent", "EntityStatus", "SPacketEntityStatus");
-            public static final PacketType EXPLOSION =                    new PacketType(PROTOCOL, SENDER, 0x20, "Explode", "Explosion", "SPacketExplosion");
-            public static final PacketType UNLOAD_CHUNK =                 new PacketType(PROTOCOL, SENDER, 0x21, "ForgetLevelChunk", "UnloadChunk", "SPacketUnloadChunk");
-            public static final PacketType GAME_STATE_CHANGE =            new PacketType(PROTOCOL, SENDER, 0x22, "GameEvent", "GameStateChange", "SPacketChangeGameState");
-            public static final PacketType OPEN_WINDOW_HORSE =            new PacketType(PROTOCOL, SENDER, 0x23, "HorseScreenOpen", "OpenWindowHorse");
-            public static final PacketType HURT_ANIMATION =               new PacketType(PROTOCOL, SENDER, 0x24, "HurtAnimation", "ClientboundHurtAnimationPacket");
-            public static final PacketType INITIALIZE_BORDER =            new PacketType(PROTOCOL, SENDER, 0x25, "InitializeBorder");
-            public static final PacketType KEEP_ALIVE =                   new PacketType(PROTOCOL, SENDER, 0x26, "KeepAlive", "SPacketKeepAlive");
-            public static final PacketType MAP_CHUNK =                    new PacketType(PROTOCOL, SENDER, 0x27, "LevelChunkWithLight", "MapChunk", "SPacketChunkData");
-            public static final PacketType WORLD_EVENT =                  new PacketType(PROTOCOL, SENDER, 0x28, "LevelEvent", "WorldEvent", "SPacketEffect");
-            public static final PacketType WORLD_PARTICLES =              new PacketType(PROTOCOL, SENDER, 0x29, "LevelParticles", "WorldParticles", "SPacketParticles");
-            public static final PacketType LIGHT_UPDATE =                 new PacketType(PROTOCOL, SENDER, 0x2A, "LightUpdate");
-            public static final PacketType LOGIN =                        new PacketType(PROTOCOL, SENDER, 0x2B, "Login", "SPacketJoinGame");
-            public static final PacketType MAP =                          new PacketType(PROTOCOL, SENDER, 0x2C, "MapItemData", "Map", "SPacketMaps");
-            public static final PacketType OPEN_WINDOW_MERCHANT =         new PacketType(PROTOCOL, SENDER, 0x2D, "MerchantOffers", "OpenWindowMerchant");
-            public static final PacketType REL_ENTITY_MOVE =              new PacketType(PROTOCOL, SENDER, 0x2E, "net.minecraft.network.protocol.game.ClientboundMoveEntityPacket$Pos", "Entity$RelEntityMove", "Entity$PacketPlayOutRelEntityMove");
-            public static final PacketType REL_ENTITY_MOVE_LOOK =         new PacketType(PROTOCOL, SENDER, 0x2F, "net.minecraft.network.protocol.game.ClientboundMoveEntityPacket$PosRot", "Entity$RelEntityMoveLook", "Entity$PacketPlayOutRelEntityMoveLook");
-            public static final PacketType ENTITY_LOOK =                  new PacketType(PROTOCOL, SENDER, 0x30, "net.minecraft.network.protocol.game.ClientboundMoveEntityPacket$Rot", "Entity$EntityLook", "Entity$PacketPlayOutEntityLook");
-            public static final PacketType VEHICLE_MOVE =                 new PacketType(PROTOCOL, SENDER, 0x31, "MoveVehicle", "VehicleMove", "SPacketMoveVehicle");
-            public static final PacketType OPEN_BOOK =                    new PacketType(PROTOCOL, SENDER, 0x32, "OpenBook");
-            public static final PacketType OPEN_WINDOW =                  new PacketType(PROTOCOL, SENDER, 0x33, "OpenScreen", "OpenWindow", "SPacketOpenWindow");
-            public static final PacketType OPEN_SIGN_EDITOR =             new PacketType(PROTOCOL, SENDER, 0x34, "OpenSignEditor", "SPacketSignEditorOpen");
-            public static final PacketType PING =                         new PacketType(PROTOCOL, SENDER, 0x35, "Ping");
-            public static final PacketType PONG_RESPONSE =                new PacketType(PROTOCOL, SENDER, 0x36, "PongResponse");
-            public static final PacketType AUTO_RECIPE =                  new PacketType(PROTOCOL, SENDER, 0x37, "PlaceGhostRecipe", "AutoRecipe", "SPacketPlaceGhostRecipe");
-            public static final PacketType ABILITIES =                    new PacketType(PROTOCOL, SENDER, 0x38, "PlayerAbilities", "Abilities", "SPacketPlayerAbilities");
-            public static final PacketType CHAT =                         new PacketType(PROTOCOL, SENDER, 0x39, "PlayerChat", "Chat", "SPacketChat");
-            public static final PacketType PLAYER_COMBAT_END =            new PacketType(PROTOCOL, SENDER, 0x3A, "PlayerCombatEnd");
-            public static final PacketType PLAYER_COMBAT_ENTER =          new PacketType(PROTOCOL, SENDER, 0x3B, "PlayerCombatEnter");
-            public static final PacketType PLAYER_COMBAT_KILL =           new PacketType(PROTOCOL, SENDER, 0x3C, "PlayerCombatKill");
-            public static final PacketType PLAYER_INFO_REMOVE =           new PacketType(PROTOCOL, SENDER, 0x3D, "PlayerInfoRemove");
-            public static final PacketType PLAYER_INFO =                  new PacketType(PROTOCOL, SENDER, 0x3E, "PlayerInfoUpdate", "PlayerInfo");
-            public static final PacketType LOOK_AT =                      new PacketType(PROTOCOL, SENDER, 0x3F, "PlayerLookAt", "LookAt", "SPacketPlayerPosLook");
-            public static final PacketType POSITION =                     new PacketType(PROTOCOL, SENDER, 0x40, "PlayerPosition", "Position");
-            public static final PacketType RECIPES =                      new PacketType(PROTOCOL, SENDER, 0x41, "Recipe", "Recipes", "SPacketRecipeBook");
-            public static final PacketType ENTITY_DESTROY =               new PacketType(PROTOCOL, SENDER, 0x42, "RemoveEntities", "EntityDestroy", "SPacketDestroyEntities");
-            public static final PacketType REMOVE_ENTITY_EFFECT =         new PacketType(PROTOCOL, SENDER, 0x43, "RemoveMobEffect", "RemoveEntityEffect", "SPacketRemoveEntityEffect");
-            public static final PacketType RESET_SCORE =                  new PacketType(PROTOCOL, SENDER, 0x44, "ResetScore", "ResetScorePacket");
-            public static final PacketType REMOVE_RESOURCE_PACK =         new PacketType(PROTOCOL, SENDER, 0x45, "ResourcePackPop", "ResourcePackPopPacket");
-            public static final PacketType ADD_RESOURCE_PACK =            new PacketType(PROTOCOL, SENDER, 0x46, "ResourcePackPush", "ResourcePackPushPacket");
-            public static final PacketType RESPAWN =                      new PacketType(PROTOCOL, SENDER, 0x47, "Respawn", "SPacketRespawn");
-            public static final PacketType ENTITY_HEAD_ROTATION =         new PacketType(PROTOCOL, SENDER, 0x48, "RotateHead", "EntityHeadRotation", "SPacketEntityHeadLook");
-            public static final PacketType MULTI_BLOCK_CHANGE =           new PacketType(PROTOCOL, SENDER, 0x49, "SectionBlocksUpdate", "MultiBlockChange", "SPacketMultiBlockChange");
-            public static final PacketType SELECT_ADVANCEMENT_TAB =       new PacketType(PROTOCOL, SENDER, 0x4A, "SelectAdvancementsTab", "SelectAdvancementTab", "SPacketSelectAdvancementsTab");
-            public static final PacketType SERVER_DATA =                  new PacketType(PROTOCOL, SENDER, 0x4B, "ServerData");
-            public static final PacketType SET_ACTION_BAR_TEXT =          new PacketType(PROTOCOL, SENDER, 0x4C, "SetActionBarText");
-            public static final PacketType SET_BORDER_CENTER =            new PacketType(PROTOCOL, SENDER, 0x4D, "SetBorderCenter");
-            public static final PacketType SET_BORDER_LERP_SIZE =         new PacketType(PROTOCOL, SENDER, 0x4E, "SetBorderLerpSize");
-            public static final PacketType SET_BORDER_SIZE =              new PacketType(PROTOCOL, SENDER, 0x4F, "SetBorderSize");
-            public static final PacketType SET_BORDER_WARNING_DELAY =     new PacketType(PROTOCOL, SENDER, 0x50, "SetBorderWarningDelay");
-            public static final PacketType SET_BORDER_WARNING_DISTANCE =  new PacketType(PROTOCOL, SENDER, 0x51, "SetBorderWarningDistance");
-            public static final PacketType CAMERA =                       new PacketType(PROTOCOL, SENDER, 0x52, "SetCamera", "Camera", "SPacketCamera");
-            public static final PacketType HELD_ITEM_SLOT =               new PacketType(PROTOCOL, SENDER, 0x53, "SetCarriedItem", "HeldItemSlot", "SPacketHeldItemChange");
-            public static final PacketType VIEW_CENTRE =                  new PacketType(PROTOCOL, SENDER, 0x54, "SetChunkCacheCenter", "ViewCentre");
-            public static final PacketType VIEW_DISTANCE =                new PacketType(PROTOCOL, SENDER, 0x55, "SetChunkCacheRadius", "ViewDistance");
-            public static final PacketType SPAWN_POSITION =               new PacketType(PROTOCOL, SENDER, 0x56, "SetDefaultSpawnPosition", "SpawnPosition", "SPacketSpawnPosition");
-            public static final PacketType SCOREBOARD_DISPLAY_OBJECTIVE = new PacketType(PROTOCOL, SENDER, 0x57, "SetDisplayObjective", "ScoreboardDisplayObjective", "SPacketDisplayObjective");
-            public static final PacketType ENTITY_METADATA =              new PacketType(PROTOCOL, SENDER, 0x58, "SetEntityData", "EntityMetadata", "SPacketEntityMetadata");
-            public static final PacketType ATTACH_ENTITY =                new PacketType(PROTOCOL, SENDER, 0x59, "SetEntityLink", "AttachEntity", "SPacketEntityAttach");
-            public static final PacketType ENTITY_VELOCITY =              new PacketType(PROTOCOL, SENDER, 0x5A, "SetEntityMotion", "EntityVelocity", "SPacketEntityVelocity");
-            public static final PacketType ENTITY_EQUIPMENT =             new PacketType(PROTOCOL, SENDER, 0x5B, "SetEquipment", "EntityEquipment", "SPacketEntityEquipment");
-            public static final PacketType EXPERIENCE =                   new PacketType(PROTOCOL, SENDER, 0x5C, "SetExperience", "Experience", "SPacketSetExperience");
-            public static final PacketType UPDATE_HEALTH =                new PacketType(PROTOCOL, SENDER, 0x5D, "SetHealth", "UpdateHealth", "SPacketUpdateHealth");
-            public static final PacketType SCOREBOARD_OBJECTIVE =         new PacketType(PROTOCOL, SENDER, 0x5E, "SetObjective", "ScoreboardObjective", "SPacketScoreboardObjective");
-            public static final PacketType MOUNT =                        new PacketType(PROTOCOL, SENDER, 0x5F, "SetPassengers", "Mount", "SPacketSetPassengers");
-            public static final PacketType SCOREBOARD_TEAM =              new PacketType(PROTOCOL, SENDER, 0x60, "SetPlayerTeam", "ScoreboardTeam", "SPacketTeams");
-            public static final PacketType SCOREBOARD_SCORE =             new PacketType(PROTOCOL, SENDER, 0x61, "SetScore", "ScoreboardScore", "SPacketUpdateScore");
-            public static final PacketType UPDATE_SIMULATION_DISTANCE =   new PacketType(PROTOCOL, SENDER, 0x62, "SetSimulationDistance");
-            public static final PacketType SET_SUBTITLE_TEXT =            new PacketType(PROTOCOL, SENDER, 0x63, "SetSubtitleText");
-            public static final PacketType UPDATE_TIME =                  new PacketType(PROTOCOL, SENDER, 0x64, "SetTime", "UpdateTime", "SPacketTimeUpdate");
-            public static final PacketType SET_TITLE_TEXT =               new PacketType(PROTOCOL, SENDER, 0x65, "SetTitleText");
-            public static final PacketType SET_TITLES_ANIMATION =         new PacketType(PROTOCOL, SENDER, 0x66, "SetTitlesAnimation");
-            public static final PacketType ENTITY_SOUND =                 new PacketType(PROTOCOL, SENDER, 0x67, "SoundEntity", "EntitySound", "SPacketSoundEffect");
-            public static final PacketType NAMED_SOUND_EFFECT =           new PacketType(PROTOCOL, SENDER, 0x68, "Sound", "NamedSoundEffect");
-            public static final PacketType START_CONFIGURATION =          new PacketType(PROTOCOL, SENDER, 0x69, "StartConfiguration");
-            public static final PacketType STOP_SOUND =                   new PacketType(PROTOCOL, SENDER, 0x6A, "StopSound");
-            public static final PacketType STORE_COOKIE =                 new PacketType(PROTOCOL, SENDER, 0x6B, "StoreCookie");
-            public static final PacketType SYSTEM_CHAT =                  new PacketType(PROTOCOL, SENDER, 0x6C, "SystemChat");
-            public static final PacketType PLAYER_LIST_HEADER_FOOTER =    new PacketType(PROTOCOL, SENDER, 0x6D, "TabList", "PlayerListHeaderFooter", "SPacketPlayerListHeaderFooter");
-            public static final PacketType NBT_QUERY =                    new PacketType(PROTOCOL, SENDER, 0x6E, "TagQuery", "NBTQuery");
-            public static final PacketType COLLECT =                      new PacketType(PROTOCOL, SENDER, 0x6F, "TakeItemEntity", "Collect", "SPacketCollectItem");
-            public static final PacketType ENTITY_TELEPORT =              new PacketType(PROTOCOL, SENDER, 0x70, "TeleportEntity", "EntityTeleport", "SPacketEntityTeleport");
-            public static final PacketType TICKING_STATE =                new PacketType(PROTOCOL, SENDER, 0x71, "TickingState", "TickingStatePacket");
-            public static final PacketType TICKING_STEP_STATE =           new PacketType(PROTOCOL, SENDER, 0x72, "TickingStep", "TickingStepPacket");
-            public static final PacketType TRANSFER =                     new PacketType(PROTOCOL, SENDER, 0x73, "Transfer");
-            public static final PacketType ADVANCEMENTS =                 new PacketType(PROTOCOL, SENDER, 0x74, "UpdateAdvancements", "Advancements", "SPacketAdvancementInfo");
-            public static final PacketType UPDATE_ATTRIBUTES =            new PacketType(PROTOCOL, SENDER, 0x75, "UpdateAttributes", "SPacketEntityProperties");
-            public static final PacketType ENTITY_EFFECT =                new PacketType(PROTOCOL, SENDER, 0x76, "UpdateMobEffect", "EntityEffect", "SPacketEntityEffect");
-            public static final PacketType RECIPE_UPDATE =                new PacketType(PROTOCOL, SENDER, 0x77, "UpdateRecipes", "RecipeUpdate");
-            public static final PacketType TAGS =                         new PacketType(PROTOCOL, SENDER, 0x78, "UpdateTags", "Tags");
-            public static final PacketType PROJECTILE_POWER =             new PacketType(PROTOCOL, SENDER, 0x79, "ProjectilePower");
-            public static final PacketType REPORT_DETAILS =               new PacketType(PROTOCOL, SENDER, 0x7A, "CustomReportDetails");
-            public static final PacketType SERVER_LINKS =                 new PacketType(PROTOCOL, SENDER, 0x7B, "ServerLinks");
-
-            // ---- Removed in 1.9
+            public static final PacketType ANIMATION =                    new PacketType(PROTOCOL, SENDER, 0x02, "Animate", "Animation", "SPacketAnimation");
+            public static final PacketType STATISTIC =                    new PacketType(PROTOCOL, SENDER, 0x03, "AwardStats", "Statistic", "SPacketStatistics");
+            public static final PacketType BLOCK_CHANGED_ACK =            new PacketType(PROTOCOL, SENDER, 0x04, "BlockChangedAck");
+            public static final PacketType BLOCK_BREAK_ANIMATION =        new PacketType(PROTOCOL, SENDER, 0x05, "BlockDestruction", "BlockBreakAnimation", "SPacketBlockBreakAnim");
+            public static final PacketType TILE_ENTITY_DATA =             new PacketType(PROTOCOL, SENDER, 0x06, "BlockEntityData", "TileEntityData", "SPacketUpdateTileEntity");
+            public static final PacketType BLOCK_ACTION =                 new PacketType(PROTOCOL, SENDER, 0x07, "BlockEvent", "BlockAction", "SPacketBlockAction");
+            public static final PacketType BLOCK_CHANGE =                 new PacketType(PROTOCOL, SENDER, 0x08, "BlockUpdate", "BlockChange", "SPacketBlockChange");
+            public static final PacketType BOSS =                         new PacketType(PROTOCOL, SENDER, 0x09, "BossEvent", "Boss", "SPacketUpdateBossInfo");
+            public static final PacketType SERVER_DIFFICULTY =            new PacketType(PROTOCOL, SENDER, 0x0A, "ChangeDifficulty", "ServerDifficulty", "SPacketServerDifficulty");
+            public static final PacketType CHUNK_BATCH_FINISHED =         new PacketType(PROTOCOL, SENDER, 0x0B, "ChunkBatchFinished");
+            public static final PacketType CHUNK_BATCH_START =            new PacketType(PROTOCOL, SENDER, 0x0C, "ChunkBatchStart");
+            public static final PacketType CHUNKS_BIOMES =                new PacketType(PROTOCOL, SENDER, 0x0D, "ChunksBiomes", "ClientboundChunksBiomesPacket");
+            public static final PacketType CLEAR_TITLES =                 new PacketType(PROTOCOL, SENDER, 0x0E, "ClearTitles");
+            public static final PacketType TAB_COMPLETE =                 new PacketType(PROTOCOL, SENDER, 0x0F, "CommandSuggestions", "TabComplete", "SPacketTabComplete");
+            public static final PacketType COMMANDS =                     new PacketType(PROTOCOL, SENDER, 0x10, "Commands");
+            public static final PacketType CLOSE_WINDOW =                 new PacketType(PROTOCOL, SENDER, 0x11, "ContainerClose", "CloseWindow", "SPacketCloseWindow");
+            public static final PacketType WINDOW_ITEMS =                 new PacketType(PROTOCOL, SENDER, 0x12, "ContainerSetContent", "WindowItems", "SPacketWindowItems");
+            public static final PacketType WINDOW_DATA =                  new PacketType(PROTOCOL, SENDER, 0x13, "ContainerSetData", "WindowData", "SPacketWindowProperty");
+            public static final PacketType SET_SLOT =                     new PacketType(PROTOCOL, SENDER, 0x14, "ContainerSetSlot", "SetSlot", "SPacketSetSlot");
+            public static final PacketType COOKIE_REQUEST =               new PacketType(PROTOCOL, SENDER, 0x15, "CookieRequest");
+            public static final PacketType SET_COOLDOWN =                 new PacketType(PROTOCOL, SENDER, 0x16, "Cooldown", "SetCooldown", "SPacketCooldown");
+            public static final PacketType CUSTOM_CHAT_COMPLETIONS =      new PacketType(PROTOCOL, SENDER, 0x17, "CustomChatCompletions");
+            public static final PacketType CUSTOM_PAYLOAD =               new PacketType(PROTOCOL, SENDER, 0x18, "CustomPayload", "SPacketCustomPayload");
+            public static final PacketType DAMAGE_EVENT =                 new PacketType(PROTOCOL, SENDER, 0x19, "DamageEvent", "ClientboundDamageEventPacket");
+            public static final PacketType DEBUG_BLOCK_VALUE =            new PacketType(PROTOCOL, SENDER, 0x1A, "DebugBlockValue");
+            public static final PacketType DEBUG_CHUNK_VALUE =            new PacketType(PROTOCOL, SENDER, 0x1B, "DebugChunkValue");
+            public static final PacketType DEBUG_ENTITY_VALUE =           new PacketType(PROTOCOL, SENDER, 0x1C, "DebugEntityValue");
+            public static final PacketType DEBUG_EVENT =                  new PacketType(PROTOCOL, SENDER, 0x1D, "DebugEvent");
+            public static final PacketType DEBUG_SAMPLE =                 new PacketType(PROTOCOL, SENDER, 0x1E, "DebugSample");
+            public static final PacketType DELETE_CHAT_MESSAGE =          new PacketType(PROTOCOL, SENDER, 0x1F, "DeleteChat");
+            public static final PacketType KICK_DISCONNECT =              new PacketType(PROTOCOL, SENDER, 0x20, "Disconnect", "KickDisconnect", "SPacketDisconnect");
+            public static final PacketType DISGUISED_CHAT =               new PacketType(PROTOCOL, SENDER, 0x21, "DisguisedChat");
+            public static final PacketType ENTITY_STATUS =                new PacketType(PROTOCOL, SENDER, 0x22, "EntityEvent", "EntityStatus", "SPacketEntityStatus");
+            public static final PacketType ENTITY_POSITION_SYNC =         new PacketType(PROTOCOL, SENDER, 0x23, "EntityPositionSync");
+            public static final PacketType EXPLOSION =                    new PacketType(PROTOCOL, SENDER, 0x24, "Explode", "Explosion", "SPacketExplosion");
+            public static final PacketType UNLOAD_CHUNK =                 new PacketType(PROTOCOL, SENDER, 0x25, "ForgetLevelChunk", "UnloadChunk", "SPacketUnloadChunk");
+            public static final PacketType GAME_STATE_CHANGE =            new PacketType(PROTOCOL, SENDER, 0x26, "GameEvent", "GameStateChange", "SPacketChangeGameState");
+            public static final PacketType GAME_RULE_VALUES =             new PacketType(PROTOCOL, SENDER, 0x27, "GameRuleValues");
+            public static final PacketType GAME_TEST_HIGHLIGHT_POS =      new PacketType(PROTOCOL, SENDER, 0x28, "GameTestHighlightPos");
+            public static final PacketType OPEN_WINDOW_HORSE =            new PacketType(PROTOCOL, SENDER, 0x29, "MountScreenOpen", "HorseScreenOpen", "OpenWindowHorse");
+            public static final PacketType HURT_ANIMATION =               new PacketType(PROTOCOL, SENDER, 0x2A, "HurtAnimation", "ClientboundHurtAnimationPacket");
+            public static final PacketType INITIALIZE_BORDER =            new PacketType(PROTOCOL, SENDER, 0x2B, "InitializeBorder");
+            public static final PacketType KEEP_ALIVE =                   new PacketType(PROTOCOL, SENDER, 0x2C, "KeepAlive", "SPacketKeepAlive");
+            public static final PacketType MAP_CHUNK =                    new PacketType(PROTOCOL, SENDER, 0x2D, "LevelChunkWithLight", "MapChunk", "SPacketChunkData");
+            public static final PacketType WORLD_EVENT =                  new PacketType(PROTOCOL, SENDER, 0x2E, "LevelEvent", "WorldEvent", "SPacketEffect");
+            public static final PacketType WORLD_PARTICLES =              new PacketType(PROTOCOL, SENDER, 0x2F, "LevelParticles", "WorldParticles", "SPacketParticles");
+            public static final PacketType LIGHT_UPDATE =                 new PacketType(PROTOCOL, SENDER, 0x30, "LightUpdate");
+            public static final PacketType LOGIN =                        new PacketType(PROTOCOL, SENDER, 0x31, "Login", "SPacketJoinGame");
+            public static final PacketType LOW_DISK_SPACE_WARNING =       new PacketType(PROTOCOL, SENDER, 0x32, "LowDiskSpaceWarning");
+            public static final PacketType MAP =                          new PacketType(PROTOCOL, SENDER, 0x33, "MapItemData", "Map", "SPacketMaps");
+            public static final PacketType OPEN_WINDOW_MERCHANT =         new PacketType(PROTOCOL, SENDER, 0x34, "MerchantOffers", "OpenWindowMerchant");
+            public static final PacketType REL_ENTITY_MOVE =              new PacketType(PROTOCOL, SENDER, 0x35, "net.minecraft.network.protocol.game.ClientboundMoveEntityPacket$Pos", "Entity$RelEntityMove", "Entity$PacketPlayOutRelEntityMove");
+            public static final PacketType REL_ENTITY_MOVE_LOOK =         new PacketType(PROTOCOL, SENDER, 0x36, "net.minecraft.network.protocol.game.ClientboundMoveEntityPacket$PosRot", "Entity$RelEntityMoveLook", "Entity$PacketPlayOutRelEntityMoveLook");
+            public static final PacketType MOVE_MINECART =                new PacketType(PROTOCOL, SENDER, 0x37, "MoveMinecart");
+            public static final PacketType ENTITY_LOOK =                  new PacketType(PROTOCOL, SENDER, 0x38, "net.minecraft.network.protocol.game.ClientboundMoveEntityPacket$Rot", "Entity$EntityLook", "Entity$PacketPlayOutEntityLook");
+            public static final PacketType VEHICLE_MOVE =                 new PacketType(PROTOCOL, SENDER, 0x39, "MoveVehicle", "VehicleMove", "SPacketMoveVehicle");
+            public static final PacketType OPEN_BOOK =                    new PacketType(PROTOCOL, SENDER, 0x3A, "OpenBook");
+            public static final PacketType OPEN_WINDOW =                  new PacketType(PROTOCOL, SENDER, 0x3B, "OpenScreen", "OpenWindow", "SPacketOpenWindow");
+            public static final PacketType OPEN_SIGN_EDITOR =             new PacketType(PROTOCOL, SENDER, 0x3C, "OpenSignEditor", "SPacketSignEditorOpen");
+            public static final PacketType PING =                         new PacketType(PROTOCOL, SENDER, 0x3D, "Ping");
+            public static final PacketType PONG_RESPONSE =                new PacketType(PROTOCOL, SENDER, 0x3E, "PongResponse");
+            public static final PacketType AUTO_RECIPE =                  new PacketType(PROTOCOL, SENDER, 0x3F, "PlaceGhostRecipe", "AutoRecipe", "SPacketPlaceGhostRecipe");
+            public static final PacketType ABILITIES =                    new PacketType(PROTOCOL, SENDER, 0x40, "PlayerAbilities", "Abilities", "SPacketPlayerAbilities");
+            public static final PacketType CHAT =                         new PacketType(PROTOCOL, SENDER, 0x41, "PlayerChat", "Chat", "SPacketChat");
+            public static final PacketType PLAYER_COMBAT_END =            new PacketType(PROTOCOL, SENDER, 0x42, "PlayerCombatEnd");
+            public static final PacketType PLAYER_COMBAT_ENTER =          new PacketType(PROTOCOL, SENDER, 0x43, "PlayerCombatEnter");
+            public static final PacketType PLAYER_COMBAT_KILL =           new PacketType(PROTOCOL, SENDER, 0x44, "PlayerCombatKill");
+            public static final PacketType PLAYER_INFO_REMOVE =           new PacketType(PROTOCOL, SENDER, 0x45, "PlayerInfoRemove");
+            public static final PacketType PLAYER_INFO =                  new PacketType(PROTOCOL, SENDER, 0x46, "PlayerInfoUpdate", "PlayerInfo");
+            public static final PacketType LOOK_AT =                      new PacketType(PROTOCOL, SENDER, 0x47, "PlayerLookAt", "LookAt", "SPacketPlayerPosLook");
+            public static final PacketType POSITION =                     new PacketType(PROTOCOL, SENDER, 0x48, "PlayerPosition", "Position");
+            public static final PacketType PLAYER_ROTATION =              new PacketType(PROTOCOL, SENDER, 0x49, "PlayerRotation");
+            public static final PacketType RECIPE_BOOK_ADD =              new PacketType(PROTOCOL, SENDER, 0x4A, "RecipeBookAdd");
+            public static final PacketType RECIPE_BOOK_REMOVE =           new PacketType(PROTOCOL, SENDER, 0x4B, "RecipeBookRemove");
+            public static final PacketType RECIPE_BOOK_SETTINGS =         new PacketType(PROTOCOL, SENDER, 0x4C, "RecipeBookSettings");
+            public static final PacketType ENTITY_DESTROY =               new PacketType(PROTOCOL, SENDER, 0x4D, "RemoveEntities", "EntityDestroy", "SPacketDestroyEntities");
+            public static final PacketType REMOVE_ENTITY_EFFECT =         new PacketType(PROTOCOL, SENDER, 0x4E, "RemoveMobEffect", "RemoveEntityEffect", "SPacketRemoveEntityEffect");
+            public static final PacketType RESET_SCORE =                  new PacketType(PROTOCOL, SENDER, 0x4F, "ResetScore", "ResetScorePacket");
+            public static final PacketType REMOVE_RESOURCE_PACK =         new PacketType(PROTOCOL, SENDER, 0x50, "ResourcePackPop", "ResourcePackPopPacket");
+            public static final PacketType ADD_RESOURCE_PACK =            new PacketType(PROTOCOL, SENDER, 0x51, "ResourcePackPush", "ResourcePackPushPacket");
+            public static final PacketType RESPAWN =                      new PacketType(PROTOCOL, SENDER, 0x52, "Respawn", "SPacketRespawn");
+            public static final PacketType ENTITY_HEAD_ROTATION =         new PacketType(PROTOCOL, SENDER, 0x53, "RotateHead", "EntityHeadRotation", "SPacketEntityHeadLook");
+            public static final PacketType MULTI_BLOCK_CHANGE =           new PacketType(PROTOCOL, SENDER, 0x54, "SectionBlocksUpdate", "MultiBlockChange", "SPacketMultiBlockChange");
+            public static final PacketType SELECT_ADVANCEMENT_TAB =       new PacketType(PROTOCOL, SENDER, 0x55, "SelectAdvancementsTab", "SelectAdvancementTab", "SPacketSelectAdvancementsTab");
+            public static final PacketType SERVER_DATA =                  new PacketType(PROTOCOL, SENDER, 0x56, "ServerData");
+            public static final PacketType SET_ACTION_BAR_TEXT =          new PacketType(PROTOCOL, SENDER, 0x57, "SetActionBarText");
+            public static final PacketType SET_BORDER_CENTER =            new PacketType(PROTOCOL, SENDER, 0x58, "SetBorderCenter");
+            public static final PacketType SET_BORDER_LERP_SIZE =         new PacketType(PROTOCOL, SENDER, 0x59, "SetBorderLerpSize");
+            public static final PacketType SET_BORDER_SIZE =              new PacketType(PROTOCOL, SENDER, 0x5A, "SetBorderSize");
+            public static final PacketType SET_BORDER_WARNING_DELAY =     new PacketType(PROTOCOL, SENDER, 0x5B, "SetBorderWarningDelay");
+            public static final PacketType SET_BORDER_WARNING_DISTANCE =  new PacketType(PROTOCOL, SENDER, 0x5C, "SetBorderWarningDistance");
+            public static final PacketType CAMERA =                       new PacketType(PROTOCOL, SENDER, 0x5D, "SetCamera", "Camera", "SPacketCamera");
+            public static final PacketType VIEW_CENTRE =                  new PacketType(PROTOCOL, SENDER, 0x5E, "SetChunkCacheCenter", "ViewCentre");
+            public static final PacketType VIEW_DISTANCE =                new PacketType(PROTOCOL, SENDER, 0x5F, "SetChunkCacheRadius", "ViewDistance");
+            public static final PacketType SET_CURSOR_ITEM =              new PacketType(PROTOCOL, SENDER, 0x60, "SetCursorItem");
+            public static final PacketType SPAWN_POSITION =               new PacketType(PROTOCOL, SENDER, 0x61, "SetDefaultSpawnPosition", "SpawnPosition", "SPacketSpawnPosition");
+            public static final PacketType SCOREBOARD_DISPLAY_OBJECTIVE = new PacketType(PROTOCOL, SENDER, 0x62, "SetDisplayObjective", "ScoreboardDisplayObjective", "SPacketDisplayObjective");
+            public static final PacketType ENTITY_METADATA =              new PacketType(PROTOCOL, SENDER, 0x63, "SetEntityData", "EntityMetadata", "SPacketEntityMetadata");
+            public static final PacketType ATTACH_ENTITY =                new PacketType(PROTOCOL, SENDER, 0x64, "SetEntityLink", "AttachEntity", "SPacketEntityAttach");
+            public static final PacketType ENTITY_VELOCITY =              new PacketType(PROTOCOL, SENDER, 0x65, "SetEntityMotion", "EntityVelocity", "SPacketEntityVelocity");
+            public static final PacketType ENTITY_EQUIPMENT =             new PacketType(PROTOCOL, SENDER, 0x66, "SetEquipment", "EntityEquipment", "SPacketEntityEquipment");
+            public static final PacketType EXPERIENCE =                   new PacketType(PROTOCOL, SENDER, 0x67, "SetExperience", "Experience", "SPacketSetExperience");
+            public static final PacketType UPDATE_HEALTH =                new PacketType(PROTOCOL, SENDER, 0x68, "SetHealth", "UpdateHealth", "SPacketUpdateHealth");
+            public static final PacketType HELD_ITEM_SLOT =               new PacketType(PROTOCOL, SENDER, 0x69, "SetHeldSlot", "SetCarriedItem", "HeldItemSlot", "SPacketHeldItemChange");
+            public static final PacketType SCOREBOARD_OBJECTIVE =         new PacketType(PROTOCOL, SENDER, 0x6A, "SetObjective", "ScoreboardObjective", "SPacketScoreboardObjective");
+            public static final PacketType MOUNT =                        new PacketType(PROTOCOL, SENDER, 0x6B, "SetPassengers", "Mount", "SPacketSetPassengers");
+            public static final PacketType SET_PLAYER_INVENTORY =         new PacketType(PROTOCOL, SENDER, 0x6C, "SetPlayerInventory");
+            public static final PacketType SCOREBOARD_TEAM =              new PacketType(PROTOCOL, SENDER, 0x6D, "SetPlayerTeam", "ScoreboardTeam", "SPacketTeams");
+            public static final PacketType SCOREBOARD_SCORE =             new PacketType(PROTOCOL, SENDER, 0x6E, "SetScore", "ScoreboardScore", "SPacketUpdateScore");
+            public static final PacketType UPDATE_SIMULATION_DISTANCE =   new PacketType(PROTOCOL, SENDER, 0x6F, "SetSimulationDistance");
+            public static final PacketType SET_SUBTITLE_TEXT =            new PacketType(PROTOCOL, SENDER, 0x70, "SetSubtitleText");
+            public static final PacketType UPDATE_TIME =                  new PacketType(PROTOCOL, SENDER, 0x71, "SetTime", "UpdateTime", "SPacketTimeUpdate");
+            public static final PacketType SET_TITLE_TEXT =               new PacketType(PROTOCOL, SENDER, 0x72, "SetTitleText");
+            public static final PacketType SET_TITLES_ANIMATION =         new PacketType(PROTOCOL, SENDER, 0x73, "SetTitlesAnimation");
+            public static final PacketType ENTITY_SOUND =                 new PacketType(PROTOCOL, SENDER, 0x74, "SoundEntity", "EntitySound", "SPacketSoundEffect");
+            public static final PacketType NAMED_SOUND_EFFECT =           new PacketType(PROTOCOL, SENDER, 0x75, "Sound", "NamedSoundEffect");
+            public static final PacketType START_CONFIGURATION =          new PacketType(PROTOCOL, SENDER, 0x76, "StartConfiguration");
+            public static final PacketType STOP_SOUND =                   new PacketType(PROTOCOL, SENDER, 0x77, "StopSound");
+            public static final PacketType STORE_COOKIE =                 new PacketType(PROTOCOL, SENDER, 0x78, "StoreCookie");
+            public static final PacketType SYSTEM_CHAT =                  new PacketType(PROTOCOL, SENDER, 0x79, "SystemChat");
+            public static final PacketType PLAYER_LIST_HEADER_FOOTER =    new PacketType(PROTOCOL, SENDER, 0x7A, "TabList", "PlayerListHeaderFooter", "SPacketPlayerListHeaderFooter");
+            public static final PacketType NBT_QUERY =                    new PacketType(PROTOCOL, SENDER, 0x7B, "TagQuery", "NBTQuery");
+            public static final PacketType COLLECT =                      new PacketType(PROTOCOL, SENDER, 0x7C, "TakeItemEntity", "Collect", "SPacketCollectItem");
+            public static final PacketType ENTITY_TELEPORT =              new PacketType(PROTOCOL, SENDER, 0x7D, "TeleportEntity", "EntityTeleport", "SPacketEntityTeleport");
+            public static final PacketType TEST_INSTANCE_BLOCK_STATUS =   new PacketType(PROTOCOL, SENDER, 0x7E, "ClientboundTestInstanceBlockStatus");
+            public static final PacketType TICKING_STATE =                new PacketType(PROTOCOL, SENDER, 0x7F, "TickingState", "TickingStatePacket");
+            public static final PacketType TICKING_STEP_STATE =           new PacketType(PROTOCOL, SENDER, 0x80, "TickingStep", "TickingStepPacket");
+            public static final PacketType TRANSFER =                     new PacketType(PROTOCOL, SENDER, 0x81, "Transfer");
+            public static final PacketType ADVANCEMENTS =                 new PacketType(PROTOCOL, SENDER, 0x82, "UpdateAdvancements", "Advancements", "SPacketAdvancementInfo");
+            public static final PacketType UPDATE_ATTRIBUTES =            new PacketType(PROTOCOL, SENDER, 0x83, "UpdateAttributes", "SPacketEntityProperties");
+            public static final PacketType ENTITY_EFFECT =                new PacketType(PROTOCOL, SENDER, 0x84, "UpdateMobEffect", "EntityEffect", "SPacketEntityEffect");
+            public static final PacketType RECIPE_UPDATE =                new PacketType(PROTOCOL, SENDER, 0x85, "UpdateRecipes", "RecipeUpdate");
+            public static final PacketType TAGS =                         new PacketType(PROTOCOL, SENDER, 0x86, "UpdateTags", "Tags");
+            public static final PacketType PROJECTILE_POWER =             new PacketType(PROTOCOL, SENDER, 0x87, "ProjectilePower");
+            public static final PacketType REPORT_DETAILS =               new PacketType(PROTOCOL, SENDER, 0x88, "CustomReportDetails");
+            public static final PacketType SERVER_LINKS =                 new PacketType(PROTOCOL, SENDER, 0x89, "ServerLinks");
+            public static final PacketType TRACKED_WAYPOINT =             new PacketType(PROTOCOL, SENDER, 0x8A, "TrackedWaypoint");
+            public static final PacketType CLEAR_DIALOG =                 new PacketType(PROTOCOL, SENDER, 0x8B, "ClearDialog");
+            public static final PacketType SHOW_DIALOG =                  new PacketType(PROTOCOL, SENDER, 0x8C, "ShowDialog");
 
             /**
              * @deprecated Removed in 1.9
@@ -252,8 +267,6 @@ public class PacketType implements Serializable, Cloneable, Comparable<PacketTyp
             @Deprecated
             public static final PacketType UPDATE_ENTITY_NBT =           new PacketType(PROTOCOL, SENDER, 253, "UpdateEntityNBT");
 
-            // ----- Renamed packets
-
             /**
              * @deprecated Renamed to {@link #WINDOW_DATA}
              */
@@ -278,8 +291,6 @@ public class PacketType implements Serializable, Cloneable, Comparable<PacketTyp
             @Deprecated
             public static final PacketType OPEN_SIGN_ENTITY =             OPEN_SIGN_EDITOR.clone();
 
-            // ----- Replaced in 1.9.4
-
             /**
              * @deprecated Replaced by {@link #TILE_ENTITY_DATA}
              */
@@ -287,8 +298,6 @@ public class PacketType implements Serializable, Cloneable, Comparable<PacketTyp
             public static final PacketType UPDATE_SIGN =                  MinecraftReflection.signUpdateExists() ? new PacketType(PROTOCOL, SENDER, 252, "UpdateSign") :
                                                                               TILE_ENTITY_DATA.clone();
 
-            // ---- Removed in 1.14
-
             /**
              * @deprecated Removed in 1.14
              */
@@ -403,6 +412,18 @@ public class PacketType implements Serializable, Cloneable, Comparable<PacketTyp
             @Deprecated
             public static final PacketType RESOURCE_PACK_SEND =           new PacketType(PROTOCOL, SENDER, 234, "ResourcePackSend", "SPacketResourcePackSend");
 
+            /**
+             * @deprecated Removed in 1.21.2: replaced with individual packets for adding/removing recipes
+             */
+            @Deprecated
+            public static final PacketType RECIPES =                      new PacketType(PROTOCOL, SENDER, 233, "Recipe", "Recipes", "SPacketRecipeBook");
+
+            /**
+             * @deprecated Removed in 1.21.5; replace by SPAWN_ENTITY
+             */
+            @Deprecated
+            public static final PacketType SPAWN_ENTITY_EXPERIENCE_ORB =  new PacketType(PROTOCOL, SENDER, 232, "AddExperienceOrb", "SpawnEntityExperienceOrb", "SPacketSpawnExperienceOrb");
+
             private static final Server INSTANCE = new Server();
 
             // Prevent accidental construction
@@ -424,63 +445,74 @@ public class PacketType implements Serializable, Cloneable, Comparable<PacketTyp
             private static final Sender SENDER = Sender.CLIENT;
 
             public static final PacketType TELEPORT_ACCEPT =              new PacketType(PROTOCOL, SENDER, 0x00, "AcceptTeleportation", "TeleportAccept", "CPacketConfirmTeleport");
-            public static final PacketType TILE_NBT_QUERY =               new PacketType(PROTOCOL, SENDER, 0x01, "BlockEntityTagQuery", "TileNBTQuery");
-            public static final PacketType DIFFICULTY_CHANGE =            new PacketType(PROTOCOL, SENDER, 0x02, "ChangeDifficulty", "DifficultyChange");
-            public static final PacketType CHAT_ACK =                     new PacketType(PROTOCOL, SENDER, 0x03, "ChatAck");
-            public static final PacketType CHAT_COMMAND =                 new PacketType(PROTOCOL, SENDER, 0x04, "ChatCommand");
-            public static final PacketType CHAT_COMMAND_SIGNED =          new PacketType(PROTOCOL, SENDER, 0x05, "ChatCommandSigned");
-            public static final PacketType CHAT =                         new PacketType(PROTOCOL, SENDER, 0x06, "Chat", "CPacketChatMessage");
-            public static final PacketType CHAT_SESSION_UPDATE =          new PacketType(PROTOCOL, SENDER, 0x07, "ChatSessionUpdate");
-            public static final PacketType CHUNK_BATCH_RECEIVED =         new PacketType(PROTOCOL, SENDER, 0x08, "ChunkBatchReceived");
-            public static final PacketType CLIENT_COMMAND =               new PacketType(PROTOCOL, SENDER, 0x09, "ClientCommand", "CPacketClientStatus");
-            public static final PacketType SETTINGS =                     new PacketType(PROTOCOL, SENDER, 0x0A, "ClientInformation", "Settings", "CPacketClientSettings");
-            public static final PacketType TAB_COMPLETE =                 new PacketType(PROTOCOL, SENDER, 0x0B, "CommandSuggestion", "TabComplete", "CPacketTabComplete");
-            public static final PacketType CONFIGURATION_ACK =            new PacketType(PROTOCOL, SENDER, 0x0C, "ConfigurationAcknowledged");
-            public static final PacketType ENCHANT_ITEM =                 new PacketType(PROTOCOL, SENDER, 0x0D, "ContainerButtonClick", "EnchantItem", "CPacketEnchantItem");
-            public static final PacketType WINDOW_CLICK =                 new PacketType(PROTOCOL, SENDER, 0x0E, "ContainerClick", "WindowClick", "CPacketClickWindow");
-            public static final PacketType CLOSE_WINDOW =                 new PacketType(PROTOCOL, SENDER, 0x0F, "ContainerClose", "CloseWindow", "CPacketCloseWindow");
-            public static final PacketType CONTAINER_SLOT_STATE_CHANGED = new PacketType(PROTOCOL, SENDER, 0x10, "ContainerSlotStateChanged", "ContainerSlotStateChangedPacket");
-            public static final PacketType COOKIE_RESPONSE =              new PacketType(PROTOCOL, SENDER, 0x11, "CookieResponse");
-            public static final PacketType CUSTOM_PAYLOAD =               new PacketType(PROTOCOL, SENDER, 0x12, "CustomPayload", "CPacketCustomPayload");
-            public static final PacketType DEBUG_SAMPLE_SUBSCRIPTION =    new PacketType(PROTOCOL, SENDER, 0x13, "DebugSampleSubscription");
-            public static final PacketType B_EDIT =                       new PacketType(PROTOCOL, SENDER, 0x14, "EditBook", "BEdit");
-            public static final PacketType ENTITY_NBT_QUERY =             new PacketType(PROTOCOL, SENDER, 0x15, "EntityTagQuery", "EntityNBTQuery");
-            public static final PacketType USE_ENTITY =                   new PacketType(PROTOCOL, SENDER, 0x16, "Interact", "UseEntity", "CPacketUseEntity");
-            public static final PacketType JIGSAW_GENERATE =              new PacketType(PROTOCOL, SENDER, 0x17, "JigsawGenerate");
-            public static final PacketType KEEP_ALIVE =                   new PacketType(PROTOCOL, SENDER, 0x18, "KeepAlive", "CPacketKeepAlive");
-            public static final PacketType DIFFICULTY_LOCK =              new PacketType(PROTOCOL, SENDER, 0x19, "LockDifficulty", "DifficultyLock");
-            public static final PacketType POSITION =                     new PacketType(PROTOCOL, SENDER, 0x1A, "net.minecraft.network.protocol.game.ServerboundMovePlayerPacket$Pos", "Flying$Position", "Flying$PacketPlayInPosition", "CPacketPlayer$Position");
-            public static final PacketType POSITION_LOOK =                new PacketType(PROTOCOL, SENDER, 0x1B, "net.minecraft.network.protocol.game.ServerboundMovePlayerPacket$PosRot", "Flying$PositionLook", "Flying$PacketPlayInPositionLook", "CPacketPlayer$PositionRotation");
-            public static final PacketType LOOK =                         new PacketType(PROTOCOL, SENDER, 0x1C, "net.minecraft.network.protocol.game.ServerboundMovePlayerPacket$Rot", "Flying$Look", "Flying$PacketPlayInLook", "CPacketPlayer$Rotation");
-            public static final PacketType GROUND =                       new PacketType(PROTOCOL, SENDER, 0x1D, "net.minecraft.network.protocol.game.ServerboundMovePlayerPacket$StatusOnly", "Flying$d");
-            public static final PacketType VEHICLE_MOVE =                 new PacketType(PROTOCOL, SENDER, 0x1E, "MoveVehicle", "VehicleMove", "CPacketVehicleMove");
-            public static final PacketType BOAT_MOVE =                    new PacketType(PROTOCOL, SENDER, 0x1F, "PaddleBoat", "BoatMove", "CPacketSteerBoat");
-            public static final PacketType PICK_ITEM =                    new PacketType(PROTOCOL, SENDER, 0x20, "PickItem");
-            public static final PacketType PING_REQUEST =                 new PacketType(PROTOCOL, SENDER, 0x21, "PingRequest");
-            public static final PacketType AUTO_RECIPE =                  new PacketType(PROTOCOL, SENDER, 0x22, "PlaceRecipe", "AutoRecipe", "CPacketPlaceRecipe");
-            public static final PacketType ABILITIES =                    new PacketType(PROTOCOL, SENDER, 0x23, "PlayerAbilities", "Abilities", "CPacketPlayerAbilities");
-            public static final PacketType BLOCK_DIG =                    new PacketType(PROTOCOL, SENDER, 0x24, "PlayerAction", "BlockDig", "CPacketPlayerDigging");
-            public static final PacketType ENTITY_ACTION =                new PacketType(PROTOCOL, SENDER, 0x25, "PlayerCommand", "EntityAction", "CPacketEntityAction");
-            public static final PacketType STEER_VEHICLE =                new PacketType(PROTOCOL, SENDER, 0x26, "PlayerInput", "SteerVehicle", "CPacketInput");
-            public static final PacketType PONG =                         new PacketType(PROTOCOL, SENDER, 0x27, "Pong");
-            public static final PacketType RECIPE_SETTINGS =              new PacketType(PROTOCOL, SENDER, 0x28, "RecipeBookChangeSettings", "RecipeSettings");
-            public static final PacketType RECIPE_DISPLAYED =             new PacketType(PROTOCOL, SENDER, 0x29, "RecipeBookSeenRecipe", "RecipeDisplayed", "CPacketRecipeInfo");
-            public static final PacketType ITEM_NAME =                    new PacketType(PROTOCOL, SENDER, 0x2A, "RenameItem", "ItemName");
-            public static final PacketType RESOURCE_PACK_STATUS =         new PacketType(PROTOCOL, SENDER, 0x2B, "ResourcePack", "ResourcePackStatus", "CPacketResourcePackStatus");
-            public static final PacketType ADVANCEMENTS =                 new PacketType(PROTOCOL, SENDER, 0x2C, "SeenAdvancements", "Advancements", "CPacketSeenAdvancements");
-            public static final PacketType TR_SEL =                       new PacketType(PROTOCOL, SENDER, 0x2D, "SelectTrade", "TrSel");
-            public static final PacketType BEACON =                       new PacketType(PROTOCOL, SENDER, 0x2E, "SetBeacon", "Beacon");
-            public static final PacketType HELD_ITEM_SLOT =               new PacketType(PROTOCOL, SENDER, 0x2F, "SetCarriedItem", "HeldItemSlot", "CPacketHeldItemChange");
-            public static final PacketType SET_COMMAND_BLOCK =            new PacketType(PROTOCOL, SENDER, 0x30, "SetCommandBlock");
-            public static final PacketType SET_COMMAND_MINECART =         new PacketType(PROTOCOL, SENDER, 0x31, "SetCommandMinecart");
-            public static final PacketType SET_CREATIVE_SLOT =            new PacketType(PROTOCOL, SENDER, 0x32, "SetCreativeModeSlot", "SetCreativeSlot", "CPacketCreativeInventoryAction");
-            public static final PacketType SET_JIGSAW =                   new PacketType(PROTOCOL, SENDER, 0x33, "SetJigsawBlock", "SetJigsaw");
-            public static final PacketType STRUCT =                       new PacketType(PROTOCOL, SENDER, 0x34, "SetStructureBlock", "Struct");
-            public static final PacketType UPDATE_SIGN =                  new PacketType(PROTOCOL, SENDER, 0x35, "SignUpdate", "UpdateSign", "CPacketUpdateSign");
-            public static final PacketType ARM_ANIMATION =                new PacketType(PROTOCOL, SENDER, 0x36, "Swing", "ArmAnimation", "CPacketAnimation");
-            public static final PacketType SPECTATE =                     new PacketType(PROTOCOL, SENDER, 0x37, "TeleportToEntity", "Spectate", "CPacketSpectate");
-            public static final PacketType USE_ITEM_ON =                  new PacketType(PROTOCOL, SENDER, 0x38, "UseItemOn", "BlockPlace", "CPacketPlayerTryUseItemOnBlock");
-            public static final PacketType USE_ITEM =                     new PacketType(PROTOCOL, SENDER, 0x39, "UseItem", "CPacketPlayerTryUseItem");
+            public static final PacketType ATTACK =                       new PacketType(PROTOCOL, SENDER, 0x01, "Attack");
+            public static final PacketType TILE_NBT_QUERY =               new PacketType(PROTOCOL, SENDER, 0x02, "BlockEntityTagQuery", "TileNBTQuery");
+            public static final PacketType SELECT_BUNDLE_ITEM =           new PacketType(PROTOCOL, SENDER, 0x03, "SelectBundleItem");
+            public static final PacketType DIFFICULTY_CHANGE =            new PacketType(PROTOCOL, SENDER, 0x04, "ChangeDifficulty", "DifficultyChange");
+            public static final PacketType CHANGE_GAME_MODE =             new PacketType(PROTOCOL, SENDER, 0x05, "ChangeGameMode");
+            public static final PacketType CHAT_ACK =                     new PacketType(PROTOCOL, SENDER, 0x06, "ChatAck");
+            public static final PacketType CHAT_COMMAND =                 new PacketType(PROTOCOL, SENDER, 0x07, "ChatCommand");
+            public static final PacketType CHAT_COMMAND_SIGNED =          new PacketType(PROTOCOL, SENDER, 0x08, "ChatCommandSigned");
+            public static final PacketType CHAT =                         new PacketType(PROTOCOL, SENDER, 0x09, "Chat", "CPacketChatMessage");
+            public static final PacketType CHAT_SESSION_UPDATE =          new PacketType(PROTOCOL, SENDER, 0x0A, "ChatSessionUpdate");
+            public static final PacketType CHUNK_BATCH_RECEIVED =         new PacketType(PROTOCOL, SENDER, 0x0B, "ChunkBatchReceived");
+            public static final PacketType CLIENT_COMMAND =               new PacketType(PROTOCOL, SENDER, 0x0C, "ClientCommand", "CPacketClientStatus");
+            public static final PacketType CLIENT_TICK_END =              new PacketType(PROTOCOL, SENDER, 0x0D, "ClientTickEnd");
+            public static final PacketType SETTINGS =                     new PacketType(PROTOCOL, SENDER, 0x0E, "ClientInformation", "Settings", "CPacketClientSettings");
+            public static final PacketType TAB_COMPLETE =                 new PacketType(PROTOCOL, SENDER, 0x0F, "CommandSuggestion", "TabComplete", "CPacketTabComplete");
+            public static final PacketType CONFIGURATION_ACK =            new PacketType(PROTOCOL, SENDER, 0x10, "ConfigurationAcknowledged");
+            public static final PacketType ENCHANT_ITEM =                 new PacketType(PROTOCOL, SENDER, 0x11, "ContainerButtonClick", "EnchantItem", "CPacketEnchantItem");
+            public static final PacketType WINDOW_CLICK =                 new PacketType(PROTOCOL, SENDER, 0x12, "ContainerClick", "WindowClick", "CPacketClickWindow");
+            public static final PacketType CLOSE_WINDOW =                 new PacketType(PROTOCOL, SENDER, 0x13, "ContainerClose", "CloseWindow", "CPacketCloseWindow");
+            public static final PacketType CONTAINER_SLOT_STATE_CHANGED = new PacketType(PROTOCOL, SENDER, 0x14, "ContainerSlotStateChanged", "ContainerSlotStateChangedPacket");
+            public static final PacketType COOKIE_RESPONSE =              new PacketType(PROTOCOL, SENDER, 0x15, "CookieResponse");
+            public static final PacketType CUSTOM_PAYLOAD =               new PacketType(PROTOCOL, SENDER, 0x16, "CustomPayload", "CPacketCustomPayload");
+            public static final PacketType DEBUG_SUBSCRIPTION_REQUEST =   new PacketType(PROTOCOL, SENDER, 0x17, "DebugSubscriptionRequest");
+            public static final PacketType B_EDIT =                       new PacketType(PROTOCOL, SENDER, 0x18, "EditBook", "BEdit");
+            public static final PacketType ENTITY_NBT_QUERY =             new PacketType(PROTOCOL, SENDER, 0x19, "EntityTagQuery", "EntityNBTQuery");
+            public static final PacketType USE_ENTITY =                   new PacketType(PROTOCOL, SENDER, 0x1A, "Interact", "UseEntity", "CPacketUseEntity");
+            public static final PacketType JIGSAW_GENERATE =              new PacketType(PROTOCOL, SENDER, 0x1B, "JigsawGenerate");
+            public static final PacketType KEEP_ALIVE =                   new PacketType(PROTOCOL, SENDER, 0x1C, "KeepAlive", "CPacketKeepAlive");
+            public static final PacketType DIFFICULTY_LOCK =              new PacketType(PROTOCOL, SENDER, 0x1D, "LockDifficulty", "DifficultyLock");
+            public static final PacketType POSITION =                     new PacketType(PROTOCOL, SENDER, 0x1E, "net.minecraft.network.protocol.game.ServerboundMovePlayerPacket$Pos", "Flying$Position", "Flying$PacketPlayInPosition", "CPacketPlayer$Position");
+            public static final PacketType POSITION_LOOK =                new PacketType(PROTOCOL, SENDER, 0x1F, "net.minecraft.network.protocol.game.ServerboundMovePlayerPacket$PosRot", "Flying$PositionLook", "Flying$PacketPlayInPositionLook", "CPacketPlayer$PositionRotation");
+            public static final PacketType LOOK =                         new PacketType(PROTOCOL, SENDER, 0x20, "net.minecraft.network.protocol.game.ServerboundMovePlayerPacket$Rot", "Flying$Look", "Flying$PacketPlayInLook", "CPacketPlayer$Rotation");
+            public static final PacketType GROUND =                       new PacketType(PROTOCOL, SENDER, 0x21, "net.minecraft.network.protocol.game.ServerboundMovePlayerPacket$StatusOnly", "Flying$d");
+            public static final PacketType VEHICLE_MOVE =                 new PacketType(PROTOCOL, SENDER, 0x22, "MoveVehicle", "VehicleMove", "CPacketVehicleMove");
+            public static final PacketType BOAT_MOVE =                    new PacketType(PROTOCOL, SENDER, 0x23, "PaddleBoat", "BoatMove", "CPacketSteerBoat");
+            public static final PacketType PICK_ITEM_FROM_BLOCK =         new PacketType(PROTOCOL, SENDER, 0x24, "PickItemFromBlock");
+            public static final PacketType PICK_ITEM =                    new PacketType(PROTOCOL, SENDER, 0x25, "PickItemFromEntity", "PickItem");
+            public static final PacketType PING_REQUEST =                 new PacketType(PROTOCOL, SENDER, 0x26, "PingRequest");
+            public static final PacketType AUTO_RECIPE =                  new PacketType(PROTOCOL, SENDER, 0x27, "PlaceRecipe", "AutoRecipe", "CPacketPlaceRecipe");
+            public static final PacketType ABILITIES =                    new PacketType(PROTOCOL, SENDER, 0x28, "PlayerAbilities", "Abilities", "CPacketPlayerAbilities");
+            public static final PacketType BLOCK_DIG =                    new PacketType(PROTOCOL, SENDER, 0x29, "PlayerAction", "BlockDig", "CPacketPlayerDigging");
+            public static final PacketType ENTITY_ACTION =                new PacketType(PROTOCOL, SENDER, 0x2A, "PlayerCommand", "EntityAction", "CPacketEntityAction");
+            public static final PacketType STEER_VEHICLE =                new PacketType(PROTOCOL, SENDER, 0x2B, "PlayerInput", "SteerVehicle", "CPacketInput");
+            public static final PacketType PLAYER_LOADED =                new PacketType(PROTOCOL, SENDER, 0x2C, "PlayerLoaded");
+            public static final PacketType PONG =                         new PacketType(PROTOCOL, SENDER, 0x2D, "Pong");
+            public static final PacketType RECIPE_SETTINGS =              new PacketType(PROTOCOL, SENDER, 0x2E, "RecipeBookChangeSettings", "RecipeSettings");
+            public static final PacketType RECIPE_DISPLAYED =             new PacketType(PROTOCOL, SENDER, 0x2F, "RecipeBookSeenRecipe", "RecipeDisplayed", "CPacketRecipeInfo");
+            public static final PacketType ITEM_NAME =                    new PacketType(PROTOCOL, SENDER, 0x30, "RenameItem", "ItemName");
+            public static final PacketType RESOURCE_PACK_STATUS =         new PacketType(PROTOCOL, SENDER, 0x31, "ResourcePack", "ResourcePackStatus", "CPacketResourcePackStatus");
+            public static final PacketType ADVANCEMENTS =                 new PacketType(PROTOCOL, SENDER, 0x32, "SeenAdvancements", "Advancements", "CPacketSeenAdvancements");
+            public static final PacketType TR_SEL =                       new PacketType(PROTOCOL, SENDER, 0x33, "SelectTrade", "TrSel");
+            public static final PacketType BEACON =                       new PacketType(PROTOCOL, SENDER, 0x34, "SetBeacon", "Beacon");
+            public static final PacketType HELD_ITEM_SLOT =               new PacketType(PROTOCOL, SENDER, 0x35, "SetCarriedItem", "HeldItemSlot", "CPacketHeldItemChange");
+            public static final PacketType SET_COMMAND_BLOCK =            new PacketType(PROTOCOL, SENDER, 0x36, "SetCommandBlock");
+            public static final PacketType SET_COMMAND_MINECART =         new PacketType(PROTOCOL, SENDER, 0x37, "SetCommandMinecart");
+            public static final PacketType SET_CREATIVE_SLOT =            new PacketType(PROTOCOL, SENDER, 0x38, "SetCreativeModeSlot", "SetCreativeSlot", "CPacketCreativeInventoryAction");
+            public static final PacketType SET_GAME_RULE =                new PacketType(PROTOCOL, SENDER, 0x39, "SetGameRule");
+            public static final PacketType SET_JIGSAW =                   new PacketType(PROTOCOL, SENDER, 0x3A, "SetJigsawBlock", "SetJigsaw");
+            public static final PacketType STRUCT =                       new PacketType(PROTOCOL, SENDER, 0x3B, "SetStructureBlock", "Struct");
+            public static final PacketType SET_TEST_BLOCK =               new PacketType(PROTOCOL, SENDER, 0x3C, "SetTestBlock");
+            public static final PacketType UPDATE_SIGN =                  new PacketType(PROTOCOL, SENDER, 0x3D, "SignUpdate", "UpdateSign", "CPacketUpdateSign");
+            public static final PacketType SPECTATE_ENTITY =              new PacketType(PROTOCOL, SENDER, 0x3E, "SpectatorAction", "SpectateEntity");
+            public static final PacketType ARM_ANIMATION =                new PacketType(PROTOCOL, SENDER, 0x3F, "Swing", "ArmAnimation", "CPacketAnimation");
+            public static final PacketType SPECTATE =                     new PacketType(PROTOCOL, SENDER, 0x40, "TeleportToEntity", "Spectate", "CPacketSpectate");
+            public static final PacketType TEST_INSTANCE_BLOCK_ACTION =   new PacketType(PROTOCOL, SENDER, 0x41, "TestInstanceBlockAction");
+            public static final PacketType USE_ITEM_ON =                  new PacketType(PROTOCOL, SENDER, 0x42, "UseItemOn", "BlockPlace", "CPacketPlayerTryUseItemOnBlock");
+            public static final PacketType USE_ITEM =                     new PacketType(PROTOCOL, SENDER, 0x43, "UseItem", "CPacketPlayerTryUseItem");
+            public static final PacketType CUSTOM_CLICK_ACTION =          new PacketType(PROTOCOL, SENDER, 0x44, "CustomClickAction");
 
             /**
              * @deprecated Removed in 1.17
@@ -500,6 +532,12 @@ public class PacketType implements Serializable, Cloneable, Comparable<PacketTyp
             @Deprecated
             public static final PacketType CHAT_PREVIEW =                 new PacketType(PROTOCOL, SENDER, 253, "ChatPreview");
 
+            /**
+             * deprecated Removed in 1.21.9
+             */
+            @Deprecated
+            public static final PacketType DEBUG_SAMPLE_SUBSCRIPTION =    new PacketType(PROTOCOL, SENDER, 0x16, "DebugSampleSubscription");
+
             /**
              * @deprecated Renamed to USE_ITEM_ON
              */
@@ -609,7 +647,7 @@ public class PacketType implements Serializable, Cloneable, Comparable<PacketTyp
             @ForceAsync
             public static final PacketType DISCONNECT =                   new PacketType(PROTOCOL, SENDER, 0x00, "LoginDisconnect", "Disconnect", "SPacketDisconnect");
             public static final PacketType ENCRYPTION_BEGIN =             new PacketType(PROTOCOL, SENDER, 0x01, "Hello", "EncryptionBegin", "SPacketEncryptionRequest");
-            public static final PacketType SUCCESS =                      new PacketType(PROTOCOL, SENDER, 0x02, "GameProfile", "Success", "SPacketLoginSuccess");
+            public static final PacketType SUCCESS =                      new PacketType(PROTOCOL, SENDER, 0x02, "LoginFinished", "GameProfile", "Success", "SPacketLoginSuccess");
             public static final PacketType SET_COMPRESSION =              new PacketType(PROTOCOL, SENDER, 0x03, "LoginCompression", "SetCompression", "SPacketEnableCompression");
             public static final PacketType CUSTOM_PAYLOAD =               new PacketType(PROTOCOL, SENDER, 0x04, "CustomQuery", "CustomPayload", "SPacketCustomPayload");
             public static final PacketType COOKIE_REQUEST =               new PacketType(PROTOCOL, SENDER, 0x05, "CookieRequest");
@@ -688,6 +726,9 @@ public class PacketType implements Serializable, Cloneable, Comparable<PacketTyp
             public static final PacketType SELECT_KNOWN_PACKS =           new PacketType(PROTOCOL, SENDER, 0x0E, "ClientboundSelectKnownPacks");
             public static final PacketType REPORT_DETAILS =               new PacketType(PROTOCOL, SENDER, 0x0F, "CustomReportDetails");
             public static final PacketType SERVER_LINKS =                 new PacketType(PROTOCOL, SENDER, 0x10, "ServerLinks");
+            public static final PacketType CLEAR_DIALOG =                 new PacketType(PROTOCOL, SENDER, 0x11, "ClearDialog");
+            public static final PacketType SHOW_DIALOG =                  new PacketType(PROTOCOL, SENDER, 0x12, "ShowDialog");
+            public static final PacketType CODE_OF_CONDUCT =              new PacketType(PROTOCOL, SENDER, 0x13, "CodeOfConduct");
 
             /**
              * @deprecated Removed in 1.20.4: replaced with new packets for removing and sending resource packs
@@ -719,6 +760,8 @@ public class PacketType implements Serializable, Cloneable, Comparable<PacketTyp
             public static final PacketType PONG =                         new PacketType(PROTOCOL, SENDER, 0x05, "Pong");
             public static final PacketType RESOURCE_PACK_ACK =            new PacketType(PROTOCOL, SENDER, 0x06, "ResourcePack");
             public static final PacketType SELECT_KNOWN_PACKS =           new PacketType(PROTOCOL, SENDER, 0x07, "ServerboundSelectKnownPacks");
+            public static final PacketType CUSTOM_CLICK_ACTION =          new PacketType(PROTOCOL, SENDER, 0x08, "CustomClickAction");
+            public static final PacketType ACCEPT_CODE_OF_CONDUCT =       new PacketType(PROTOCOL, SENDER, 0x09, "AcceptCodeOfConduct");
 
             private static final Client INSTANCE = new Client();
 

src/main/java/com/comphenix/protocol/ProtocolLib.java

@@ -504,6 +504,17 @@ public class ProtocolLib extends JavaPlugin {
     }
 
     private void checkUpdates() {
+        // Do not run updater if no supported updater is loaded
+        if (this.updater == null) {
+            highlyVisibleError(
+                    " WARNING ",
+                    " ProtocolLib is unable to check for updates. ",
+                    " You are likely not using a supported version (Such as CraftBukkit). "
+            );
+            ProtocolLibrary.disableUpdates();
+            return;
+        }
+
         // Ignore milliseconds - it's pointless
         long currentTime = System.currentTimeMillis() / MILLI_PER_SECOND;
 

src/main/java/com/comphenix/protocol/ProtocolLibrary.java

@@ -17,9 +17,7 @@ package com.comphenix.protocol;
 import com.comphenix.protocol.error.BasicErrorReporter;
 import com.comphenix.protocol.error.ErrorReporter;
 import com.comphenix.protocol.scheduler.ProtocolScheduler;
-import com.comphenix.protocol.utility.MinecraftVersion;
-import java.util.List;
-import com.google.common.collect.ImmutableList;
+
 import org.apache.commons.lang.Validate;
 import org.bukkit.plugin.Plugin;
 
@@ -37,17 +35,12 @@ public class ProtocolLibrary {
     /**
      * The maximum version ProtocolLib has been tested with.
      */
-    public static final String MAXIMUM_MINECRAFT_VERSION = "1.20.4";
+    public static final String MAXIMUM_MINECRAFT_VERSION = "26.2";
 
     /**
-     * The date (with ISO 8601 or YYYY-MM-DD) when the most recent version (1.20.4) was released.
+     * The date (with ISO 8601 or YYYY-MM-DD) when the most recent version (26.2) was released.
      */
-    public static final String MINECRAFT_LAST_RELEASE_DATE = "2023-12-07";
-
-    /**
-     * Plugins that are currently incompatible with ProtocolLib.
-     */
-    public static final List<String> INCOMPATIBLE = ImmutableList.of("TagAPI");
+    public static final String MINECRAFT_LAST_RELEASE_DATE = "2026-06-16";
 
     private static Plugin plugin;
     private static ProtocolConfig config;

src/main/java/com/comphenix/protocol/async/AsyncFilterManager.java

@@ -17,14 +17,6 @@
 
 package com.comphenix.protocol.async;
 
-import java.util.List;
-import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.atomic.AtomicInteger;
-
-import org.bukkit.entity.Player;
-import org.bukkit.plugin.Plugin;
-
 import com.comphenix.protocol.AsynchronousManager;
 import com.comphenix.protocol.PacketStream;
 import com.comphenix.protocol.PacketType;
@@ -35,10 +27,19 @@ import com.comphenix.protocol.events.PacketEvent;
 import com.comphenix.protocol.events.PacketListener;
 import com.comphenix.protocol.injector.collection.InboundPacketListenerSet;
 import com.comphenix.protocol.injector.collection.OutboundPacketListenerSet;
+import com.comphenix.protocol.injector.netty.Injector;
 import com.comphenix.protocol.scheduler.ProtocolScheduler;
 import com.google.common.base.Objects;
+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.Iterables;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.Plugin;
+
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
 
 /**
  * Represents a filter manager for asynchronous packets.
@@ -274,7 +275,7 @@ public class AsyncFilterManager implements AsynchronousManager {
      * @return TRUE if we are, FALSE otherwise.
      */
     private boolean onMainThread() {
-        return Thread.currentThread().getId() == mainThread.getId();
+        return Thread.currentThread() == mainThread;
     }
     
     @Override
@@ -284,9 +285,9 @@ public class AsyncFilterManager implements AsynchronousManager {
     }
     
     private void unregisterAsyncHandlers(PacketProcessingQueue processingQueue, Plugin plugin) {
-        
+
         // Iterate through every packet listener
-        for (AsyncListenerHandler listener : processingQueue.values()) {
+        for (AsyncListenerHandler listener : ImmutableList.copyOf(processingQueue.values())) {
             // Remove the listener
             if (Objects.equal(listener.getPlugin(), plugin)) {
                 unregisterAsyncHandler(listener);
@@ -347,8 +348,8 @@ public class AsyncFilterManager implements AsynchronousManager {
      * Construct a asynchronous marker with all the default values.
      * @return Asynchronous marker.
      */
-    public AsyncMarker createAsyncMarker() {
-        return createAsyncMarker(AsyncMarker.DEFAULT_TIMEOUT_DELTA);
+    public AsyncMarker createAsyncMarker(Injector injector) {
+        return createAsyncMarker(injector, AsyncMarker.DEFAULT_TIMEOUT_DELTA);
     }
     
     /**
@@ -356,13 +357,13 @@ public class AsyncFilterManager implements AsynchronousManager {
      * @param timeoutDelta - how long (in ms) until the packet expire.
      * @return An async marker.
      */
-    public AsyncMarker createAsyncMarker(long timeoutDelta) {
-        return createAsyncMarker(timeoutDelta, currentSendingIndex.incrementAndGet());
+    public AsyncMarker createAsyncMarker(Injector injector, long timeoutDelta) {
+        return createAsyncMarker(injector, timeoutDelta, currentSendingIndex.incrementAndGet());
     }
     
     // Helper method
-    private AsyncMarker createAsyncMarker(long timeoutDelta, long sendingIndex) {
-        return new AsyncMarker(manager, sendingIndex, System.currentTimeMillis(), timeoutDelta);
+    private AsyncMarker createAsyncMarker(Injector injector, long timeoutDelta, long sendingIndex) {
+        return new AsyncMarker(injector, sendingIndex, System.currentTimeMillis(), timeoutDelta);
     }
     
     @Override

src/main/java/com/comphenix/protocol/async/AsyncListenerHandler.java

@@ -538,7 +538,7 @@ public class AsyncListenerHandler {
      */
     private void listenerLoop(int workerID) {
         // Danger, danger!
-        if (Thread.currentThread().getId() == mainThread.getId())
+        if (Thread.currentThread() == mainThread)
             throw new IllegalStateException("Do not call this method from the main thread.");
         if (cancelled)
             throw new IllegalStateException("Listener has been cancelled. Create a new listener instead.");

src/main/java/com/comphenix/protocol/async/AsyncMarker.java

@@ -23,14 +23,18 @@ import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.util.Iterator;
 import java.util.List;
+import java.util.Objects;
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.logging.Level;
 
 import com.comphenix.protocol.PacketStream;
 import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.ProtocolLibrary;
 import com.comphenix.protocol.ProtocolLogger;
 import com.comphenix.protocol.events.NetworkMarker;
 import com.comphenix.protocol.events.PacketEvent;
+import com.comphenix.protocol.injector.netty.Injector;
 import com.comphenix.protocol.reflect.FieldAccessException;
 import com.comphenix.protocol.reflect.FuzzyReflection;
 import com.comphenix.protocol.utility.MinecraftReflection;
@@ -64,7 +68,7 @@ public class AsyncMarker implements Serializable, Comparable<AsyncMarker> {
     /**
      * The packet stream responsible for transmitting the packet when it's done processing.
      */
-    private transient PacketStream packetStream;
+    private final Injector injector;
 
     /**
      * Current list of async packet listeners.
@@ -86,7 +90,7 @@ public class AsyncMarker implements Serializable, Comparable<AsyncMarker> {
     private volatile boolean processed;
 
     // Whether or not the packet has been sent
-    private volatile boolean transmitted;
+    private final AtomicBoolean transmitted = new AtomicBoolean(false);
 
     // Whether or not the asynchronous processing itself should be cancelled
     private volatile boolean asyncCancelled;
@@ -109,11 +113,8 @@ public class AsyncMarker implements Serializable, Comparable<AsyncMarker> {
      * Create a container for asyncronous packets.
      * @param initialTime - the current time in milliseconds since 01.01.1970 00:00.
      */
-    AsyncMarker(PacketStream packetStream, long sendingIndex, long initialTime, long timeoutDelta) {
-        if (packetStream == null)
-            throw new IllegalArgumentException("packetStream cannot be NULL");
-
-        this.packetStream = packetStream;
+    AsyncMarker(Injector injector, long sendingIndex, long initialTime, long timeoutDelta) {
+        this.injector = Objects.requireNonNull(injector, "injector is nul");
 
         // Timeout
         this.initialTime = initialTime;
@@ -180,16 +181,18 @@ public class AsyncMarker implements Serializable, Comparable<AsyncMarker> {
      * Retrieve the packet stream responsible for transmitting this packet.
      * @return The packet stream.
      */
+    @Deprecated
     public PacketStream getPacketStream() {
-        return packetStream;
+        return ProtocolLibrary.getProtocolManager();
     }
 
     /**
      * Sets the output packet stream responsible for transmitting this packet.
      * @param packetStream - new output packet stream.
      */
+    @Deprecated
     public void setPacketStream(PacketStream packetStream) {
-        this.packetStream = packetStream;
+        // NOOP
     }
 
     /**
@@ -285,7 +288,7 @@ public class AsyncMarker implements Serializable, Comparable<AsyncMarker> {
      * @return TRUE if it has been sent before, FALSE otherwise.
      */
     public boolean isTransmitted() {
-        return transmitted;
+        return transmitted.get();
     }
 
     /**
@@ -383,13 +386,18 @@ public class AsyncMarker implements Serializable, Comparable<AsyncMarker> {
      * @throws IOException If the packet couldn't be sent.
      */
     void sendPacket(PacketEvent event) throws IOException {
-        if (event.isServerPacket()) {
-            packetStream.sendServerPacket(event.getPlayer(), event.getPacket(), NetworkMarker.getNetworkMarker(event), false);
-        } else {
-            packetStream.receiveClientPacket(event.getPlayer(), event.getPacket(), NetworkMarker.getNetworkMarker(event),
-                    false);
+        if (!this.transmitted.compareAndSet(false, true)) {
+            return;
+        }
+
+        Object handle = event.getPacket().getHandle();
+
+        if (event.isServerPacket()) {
+            NetworkMarker marker = NetworkMarker.getNetworkMarker(event);
+            this.injector.sendClientboundPacket(handle, marker, false);
+        } else {
+            this.injector.readServerboundPacket(handle);
         }
-        transmitted = true;
     }
 
     /**

src/main/java/com/comphenix/protocol/async/PacketProcessingQueue.java

@@ -30,6 +30,8 @@ import com.comphenix.protocol.error.Report;
 import com.comphenix.protocol.error.ReportType;
 import com.comphenix.protocol.events.ListeningWhitelist;
 import com.comphenix.protocol.events.PacketEvent;
+
+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableSet;
 import com.google.common.collect.MinMaxPriorityQueue;
 
@@ -209,7 +211,7 @@ class PacketProcessingQueue {
     
     public void cleanupAll() {
         // Cancel all the threads and every listener
-        for (AsyncListenerHandler handler : map.values()) {
+        for (AsyncListenerHandler handler : ImmutableList.copyOf(map.values())) {
             handler.cancel();
         }
         

src/main/java/com/comphenix/protocol/events/AbstractStructure.java

@@ -55,6 +55,7 @@ import com.comphenix.protocol.wrappers.WrappedLevelChunkData;
 import com.comphenix.protocol.wrappers.WrappedMessageSignature;
 import com.comphenix.protocol.wrappers.WrappedNumberFormat;
 import com.comphenix.protocol.wrappers.WrappedParticle;
+import com.comphenix.protocol.wrappers.WrappedPositionMoveRotation;
 import com.comphenix.protocol.wrappers.WrappedProfilePublicKey;
 import com.comphenix.protocol.wrappers.WrappedProfilePublicKey.WrappedProfileKeyData;
 import com.comphenix.protocol.wrappers.WrappedRegistrable;
@@ -65,6 +66,7 @@ import com.comphenix.protocol.wrappers.WrappedServerPing;
 import com.comphenix.protocol.wrappers.WrappedStatistic;
 import com.comphenix.protocol.wrappers.WrappedTeamParameters;
 import com.comphenix.protocol.wrappers.WrappedWatchableObject;
+import com.comphenix.protocol.wrappers.WrappedWeightedList;
 import com.comphenix.protocol.wrappers.nbt.NbtBase;
 import com.comphenix.protocol.wrappers.nbt.NbtCompound;
 import com.comphenix.protocol.wrappers.nbt.NbtFactory;
@@ -418,6 +420,16 @@ public abstract class AbstractStructure {
                 BukkitConverters.getVectorConverter());
     }
 
+    /**
+     * Retrieves a read/write structure for PositionMoveRotation fields.
+     * @return A modifier for PositionMoveRotation fields.
+     */
+    public StructureModifier<WrappedPositionMoveRotation> getPositionMoveRotations() {
+        return structureModifier.withType(
+                MinecraftReflection.getMinecraftClass("world.entity.PositionMoveRotation"),
+                WrappedPositionMoveRotation.getConverter());
+    }
+
     /**
      * Retrieves a read/write structure for collections of attribute snapshots.
      * <p>
@@ -597,9 +609,7 @@ public abstract class AbstractStructure {
      */
     public StructureModifier<List<PlayerInfoData>> getPlayerInfoDataLists() {
         // Convert to and from the ProtocolLib wrapper
-        return structureModifier.withType(
-                Collection.class,
-                BukkitConverters.getListConverter(PlayerInfoData.getConverter()));
+        return getLists(PlayerInfoData.getConverter());
     }
 
     /**
@@ -804,6 +814,20 @@ public abstract class AbstractStructure {
         );
     }
 
+    /**
+     * Retrieve a read/write structure for WeightedList fields.
+     *
+     * @param elementConverter converter for the element type inside each weighted entry
+     * @param <T> the Bukkit-side element type
+     * @return A modifier for WeightedList fields.
+     */
+    public <T> StructureModifier<WrappedWeightedList<T>> getWeightedLists(
+            EquivalentConverter<T> elementConverter) {
+        return structureModifier.withType(
+                WrappedWeightedList.getNmsClass(),
+                WrappedWeightedList.getConverter(elementConverter));
+    }
+
     /**
      * Retrieve a read/write structure for the MobEffectList class in 1.9.
      * @return A modifier for MobEffectList fields.
@@ -819,6 +843,15 @@ public abstract class AbstractStructure {
                 BukkitConverters.getEffectTypeConverter());
     }
 
+    /**
+     * Retrieve a read/write structure for Bukkit {@code DamageType} values
+     * stored in NMS {@code Holder<DamageType>} fields.
+     * @return A modifier for Bukkit DamageType values.
+     */
+    public StructureModifier<org.bukkit.damage.DamageType> getDamageTypes() {
+        return getHolders(MinecraftReflection.getDamageTypeClass(), BukkitConverters.getDamageTypeConverter());
+    }
+
     /**
      * Retrieve a read/write structure for the SoundCategory enum in 1.9.
      * @return A modifier for SoundCategory enum fields.
@@ -1297,6 +1330,20 @@ public abstract class AbstractStructure {
         ));
     }
 
+    /**
+     * Retrieve a read/write structure for {@link WrappedPositionMoveRotation} (available since Minecraft 1.21.2).
+     * <p>
+     * This is used in packets such as {@code ENTITY_TELEPORT} and {@code ENTITY_POSITION_SYNC}.
+     *
+     * @return A modifier for PositionMoveRotation fields.
+     */
+    public StructureModifier<WrappedPositionMoveRotation> getPositionMoveRotation() {
+        return structureModifier.withType(
+                MinecraftReflection.getPositionMoveRotationClass(),
+                WrappedPositionMoveRotation.getConverter()
+        );
+    }
+
     /**
      * Represents an equivalent converter for ItemStack arrays.
      * @author Kristian

src/main/java/com/comphenix/protocol/events/PacketAdapter.java

@@ -232,13 +232,13 @@ public abstract class PacketAdapter implements PacketListener {
     @Override
     public void onPacketReceiving(PacketEvent event) {
         // Lets prevent some bugs
-        throw new IllegalStateException("Override onPacketReceiving to get notifcations of received packets!");
+        throw new IllegalStateException("Override onPacketReceiving to get notifications of received packets!");
     }
 
     @Override
     public void onPacketSending(PacketEvent event) {
         // Lets prevent some bugs
-        throw new IllegalStateException("Override onPacketSending to get notifcations of sent packets!");
+        throw new IllegalStateException("Override onPacketSending to get notifications of sent packets!");
     }
 
     @Override

src/main/java/com/comphenix/protocol/injector/EquivalentConstructor.java

@@ -0,0 +1,93 @@
+package com.comphenix.protocol.injector;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.reflect.EquivalentConverter;
+import com.comphenix.protocol.reflect.FuzzyReflection;
+import com.comphenix.protocol.reflect.accessors.Accessors;
+import com.comphenix.protocol.reflect.accessors.ConstructorAccessor;
+import com.comphenix.protocol.reflect.fuzzy.FuzzyMethodContract;
+import com.comphenix.protocol.utility.Tuple;
+
+import java.lang.reflect.Constructor;
+import java.util.ArrayList;
+import java.util.List;
+
+public class EquivalentConstructor {
+    private final PacketType packetType;
+    private final List<Tuple<Class<?>, Object>> converters = new ArrayList<>();
+
+    private volatile ConstructorAccessor constructorAccessor;
+
+    public EquivalentConstructor(PacketType packetType) {
+        this.packetType = packetType;
+    }
+
+    public EquivalentConstructor withParam(Class<?> param, EquivalentConverter<?> converter) {
+        converters.add(new Tuple<>(param, converter));
+        return this;
+    }
+
+    public EquivalentConstructor withParam(Class<?> param, PacketConstructor.Unwrapper unwrapper) {
+        converters.add(new Tuple<>(param, unwrapper));
+        return this;
+    }
+
+    public EquivalentConstructor withParam(Class<?> param) {
+        converters.add(new Tuple<>(param, null));
+        return this;
+    }
+
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    public Object create(Object... args) {
+        if (args.length != converters.size()) {
+            throw new IllegalArgumentException("Expected " + converters.size() + " args, got " + args.length);
+        }
+
+        ConstructorAccessor accessor = getConstructorAccessor();
+        Object[] convertedArgs = new Object[converters.size()];
+
+        int i = 0;
+        for (Tuple<Class<?>, Object> entry : converters) {
+            Object rawConverter = entry.second();
+            if (rawConverter == null) {
+                convertedArgs[i] = args[i];
+            } else if (rawConverter instanceof EquivalentConverter converter) {
+                convertedArgs[i] = converter.getGeneric(args[i]);
+            } else if (rawConverter instanceof PacketConstructor.Unwrapper unwrapper) {
+                convertedArgs[i] = unwrapper.unwrapItem(args[i]);
+            } else {
+                throw new IllegalStateException("Invalid converter type: " + rawConverter.getClass());
+            }
+
+            i++;
+        }
+
+        return accessor.invoke(convertedArgs);
+    }
+
+    private ConstructorAccessor getConstructorAccessor() {
+        ConstructorAccessor accessor = constructorAccessor;
+        if (accessor == null) {
+            synchronized (this) {
+                accessor = constructorAccessor;
+                if (accessor != null) {
+                    return accessor;
+                }
+
+                constructorAccessor = accessor = createConstructorAccessor();
+            }
+        }
+        return accessor;
+    }
+
+    private ConstructorAccessor createConstructorAccessor() {
+        Class<?>[] params = new Class<?>[converters.size()];
+        for (int i = 0; i < converters.size(); i++) {
+            params[i] = converters.get(i).first();
+        }
+
+        Constructor<?> ctor = FuzzyReflection.fromClass(packetType.getPacketClass(), true)
+                    .getConstructor(FuzzyMethodContract.newBuilder().parameterExactArray(params).build());
+        return Accessors.getConstructorAccessor(ctor);
+    }
+}

src/main/java/com/comphenix/protocol/injector/PacketFilterManager.java

@@ -43,6 +43,7 @@ import com.comphenix.protocol.injector.PluginVerifier.VerificationResult;
 import com.comphenix.protocol.injector.collection.InboundPacketListenerSet;
 import com.comphenix.protocol.injector.collection.OutboundPacketListenerSet;
 import com.comphenix.protocol.injector.collection.PacketListenerSet;
+import com.comphenix.protocol.injector.netty.Injector;
 import com.comphenix.protocol.injector.netty.WirePacket;
 import com.comphenix.protocol.injector.netty.manager.NetworkManagerInjector;
 import com.comphenix.protocol.injector.packet.PacketRegistry;
@@ -151,29 +152,20 @@ public class PacketFilterManager implements ListenerManager, InternalManager {
 
     @Override
     public void sendServerPacket(Player receiver, PacketContainer packet, NetworkMarker marker, boolean filters) {
-        if (!this.closed) {
-            // if we skip the packet events later when actually writing into the pipeline we at least notify all
-            // monitor listeners before doing so - they will not be able to change the event tho
-            if (!filters) {
-                // ensure we are on the main thread if any listener requires that
-                if (this.hasMainThreadListener(packet.getType()) && !this.server.isPrimaryThread()) {
-                    NetworkMarker copy = marker; // okay fine
-                    ProtocolLibrary.getScheduler().scheduleSyncDelayedTask(
-                            () -> this.sendServerPacket(receiver, packet, copy, false), 1L);
-                    return;
-                }
-
-                // construct the event and post to all monitor listeners
+        if (this.closed) {
+            return;
+        }
+        
+        // A monitor listener should never modify a packet/event so we can simply invoke monitor listeners
+        // independently of our injector pipeline 
+        if (!filters) {
+            this.runMonitorListeners(packet, () -> {
                 PacketEvent event = PacketEvent.fromServer(this, packet, marker, receiver, false);
                 this.outboundListeners.invoke(event, ListenerPriority.MONITOR);
-
-                // update the marker of the event without accidentally constructing it
-                marker = NetworkMarker.getNetworkMarker(event);
-            }
-
-            // process outbound
-            this.networkManagerInjector.getInjector(receiver).sendClientboundPacket(packet.getHandle(), marker, filters);
+            });
         }
+
+        this.networkManagerInjector.getInjector(receiver).sendClientboundPacket(packet.getHandle(), marker, filters);
     }
 
     @Override
@@ -200,34 +192,40 @@ public class PacketFilterManager implements ListenerManager, InternalManager {
 
     @Override
     public void receiveClientPacket(Player sender, PacketContainer packet, NetworkMarker marker, boolean filters) {
-        if (!this.closed) {
-            // make sure we are on the main thread if any listener of the packet needs it
-            if (this.hasMainThreadListener(packet.getType()) && !this.server.isPrimaryThread()) {
-                ProtocolLibrary.getScheduler().runTask(
-                        () -> this.receiveClientPacket(sender, packet, marker, filters));
+        if (this.closed) {
+            return;
+        }
+
+        // make sure we are on the main thread if any listener of the packet needs it
+        if (filters && this.requiresMainThread(packet)) {
+            ProtocolLibrary.getScheduler().runTask(
+                    () -> this.receiveClientPacket(sender, packet, marker, filters));
+            return;
+        }
+
+        Object nmsPacket = packet.getHandle();
+
+        if (filters) {
+            PacketEvent event = PacketEvent.fromClient(this, packet, marker, sender, false);
+            this.invokeInboundPacketListeners(event);
+
+            if (event.isCancelled()) {
                 return;
             }
 
-            Object nmsPacket = packet.getHandle();
-            // check to which listeners we need to post the packet
-            if (filters) {
-                // post to all listeners
-            	PacketEvent event = PacketEvent.fromClient(this.networkManagerInjector, packet, null, sender);
-                this.invokeInboundPacketListeners(event);
-                if (event.isCancelled()) {
-                    return;
-                }
-
-                // prevent possible de-sync
-                nmsPacket = event.getPacket().getHandle();
-            } else {
+            // Prevent possible de-sync if the packet was replaced by a listener.
+            nmsPacket = event.getPacket().getHandle();
+        } else {
+            // A monitor listener should never modify a packet/event so we can simply invoke monitor listeners
+            // independently of our injector pipeline 
+            this.runMonitorListeners(packet, () -> {
                 PacketEvent event = PacketEvent.fromClient(this, packet, marker, sender, false);
                 this.inboundListeners.invoke(event, ListenerPriority.MONITOR);
-            }
-
-            // post to the player inject, reset our cancel state change
-            this.networkManagerInjector.getInjector(sender).readServerboundPacket(nmsPacket);
+            });
         }
+
+        // post to the player inject, reset our cancel state change
+        this.networkManagerInjector.getInjector(sender).readServerboundPacket(nmsPacket);
     }
 
     @Override
@@ -516,12 +514,25 @@ public class PacketFilterManager implements ListenerManager, InternalManager {
             this.postPacketToListeners(this.outboundListeners, event, true);
         }
     }
+    
+    private boolean requiresMainThread(PacketContainer packet) {
+        return this.hasMainThreadListener(packet.getType()) && !this.server.isPrimaryThread();
+    }
+
+    private void runMonitorListeners(PacketContainer packet, Runnable notifyMonitor) {
+        if (this.requiresMainThread(packet)) {
+            ProtocolLibrary.getScheduler().runTask(notifyMonitor);
+        } else {
+            notifyMonitor.run();
+        }
+    }
 
     private void postPacketToListeners(PacketListenerSet listeners, PacketEvent event, boolean outbound) {
         try {
             // append async marker if any async listener for the packet was registered
             if (this.asyncFilterManager.hasAsynchronousListeners(event)) {
-                event.setAsyncMarker(this.asyncFilterManager.createAsyncMarker());
+                Injector injector = this.networkManagerInjector.getInjector(event.getPlayer());
+                event.setAsyncMarker(this.asyncFilterManager.createAsyncMarker(injector));
             }
 
             // post to sync listeners

src/main/java/com/comphenix/protocol/injector/StructureCache.java

@@ -287,8 +287,8 @@ public class StructureCache {
 
         if (registryByteBuf.isPresent()) {
             ConstructorAccessor accessor = Accessors.getConstructorAccessor(FuzzyReflection.fromClass(serializerBase, true).getConstructor(FuzzyMethodContract.newBuilder()
-                    .parameterDerivedOf(ByteBuf.class)
-                    .parameterDerivedOf(MinecraftReflection.getRegistryAccessClass())
+                    .parameterExactType(ByteBuf.class)
+                    .parameterExactType(MinecraftReflection.getRegistryAccessClass())
                     .build()));
             TRICKED_DATA_SERIALIZER_BASE = (buf) -> accessor.invoke(buf, MinecraftRegistryAccess.get());
         } else {

src/main/java/com/comphenix/protocol/injector/collection/OutboundPacketListenerSet.java

@@ -58,11 +58,13 @@ public class OutboundPacketListenerSet extends PacketListenerSet {
                 }
             }
 
-            if (packets.iterator().hasNext()) {
-                event.getPacket().getPacketBundles().write(0, outPackets);
-            } else {
-                // cancel entire packet if each individual packet has been cancelled
-                event.setCancelled(true);
+            if (!event.isReadOnly()) {
+                if (packets.iterator().hasNext()) {
+                    event.getPacket().getPacketBundles().write(0, outPackets);
+                } else {
+                    // cancel entire packet if each individual packet has been cancelled
+                    event.setCancelled(true);
+                }
             }
         }
     }

src/main/java/com/comphenix/protocol/injector/collection/PacketListenerSet.java

@@ -1,5 +1,6 @@
 package com.comphenix.protocol.injector.collection;
 
+import java.util.Iterator;
 import java.util.Set;
 
 import javax.annotation.Nullable;
@@ -45,7 +46,9 @@ public abstract class PacketListenerSet {
     public void addListener(PacketListener packetListener) {
         ListeningWhitelist listeningWhitelist = getListeningWhitelist(packetListener);
 
-        for (PacketType packetType : listeningWhitelist.getTypes()) {
+        for (Iterator<PacketType> packet = listeningWhitelist.getTypes().iterator(); packet.hasNext();) {
+            PacketType packetType = packet.next();
+
             Set<PacketType> supportedPacketTypes = (packetType.getSender() == Sender.SERVER)
                     ? PacketRegistry.getServerPacketTypes()
                     : PacketRegistry.getClientPacketTypes();
@@ -56,7 +59,7 @@ public abstract class PacketListenerSet {
                         .build());
                 
                 // remove unknown packet types
-                listeningWhitelist.getTypes().remove(packetType);
+                packet.remove();
             }
         }
 

src/main/java/com/comphenix/protocol/injector/netty/channel/NettyChannelInjector.java

@@ -29,6 +29,7 @@ import com.comphenix.protocol.injector.NetworkProcessor;
 import com.comphenix.protocol.injector.netty.Injector;
 import com.comphenix.protocol.injector.netty.WirePacket;
 import com.comphenix.protocol.injector.packet.PacketRegistry;
+import com.comphenix.protocol.injector.temporary.TemporaryPlayer;
 import com.comphenix.protocol.reflect.FuzzyReflection;
 import com.comphenix.protocol.reflect.accessors.Accessors;
 import com.comphenix.protocol.reflect.accessors.FieldAccessor;
@@ -242,7 +243,7 @@ public class NettyChannelInjector implements Injector {
             this.uninject();
 
             // remove any outgoing references
-            this.channel.attr(INJECTOR).remove();
+            this.channel.attr(INJECTOR).set(null);
 
             // cleanup
             this.savedMarkers.clear();
@@ -289,8 +290,7 @@ public class NettyChannelInjector implements Injector {
         
         this.ensureInEventLoop(() -> {
             try {
-                // try to invoke the method, this should normally not fail
-                this.listenerInvoker.read(packet);
+                this.channel.pipeline().context(INBOUND_INTERCEPTOR_NAME).fireChannelRead(packet);
             } catch (Exception exception) {
                 this.errorReporter.reportWarning(this, Report.newBuilder(REPORT_CANNOT_READ_PACKET)
                         .messageParam(packet, this.playerName)
@@ -344,14 +344,15 @@ public class NettyChannelInjector implements Injector {
     @Override
     public Player getPlayer() {
         // if the player was already resolved there is no need to do further lookups
-        if (this.player != null) {
+        if (this.player != null && !(this.player instanceof TemporaryPlayer)) {
             return this.player;
         }
 
         // check if the name of the player is already known to the injector
         if (this.playerName != null) {
-            this.player = Bukkit.getPlayerExact(this.playerName);
-            if (this.player != null) {
+            Player bukkitPlayer = Bukkit.getPlayerExact(this.playerName);
+            if (bukkitPlayer != null) {
+                this.player = bukkitPlayer;
                 this.injectionFactory.cacheInjector(this.player, this);
             }
         }

src/main/java/com/comphenix/protocol/injector/netty/channel/NettyChannelProxy.java

@@ -5,6 +5,7 @@ import io.netty.buffer.ByteBufAllocator;
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelConfig;
 import io.netty.channel.ChannelFuture;
+import io.netty.channel.ChannelId;
 import io.netty.channel.ChannelMetadata;
 import io.netty.channel.ChannelPipeline;
 import io.netty.channel.ChannelProgressivePromise;
@@ -33,6 +34,11 @@ final class NettyChannelProxy implements Channel {
         this.injector = injector;
     }
 
+    @Override
+    public ChannelId id() {
+        return this.delegate.id();
+    }
+
     @Override
     public EventLoop eventLoop() {
         return this.eventLoop;
@@ -238,6 +244,11 @@ final class NettyChannelProxy implements Channel {
         return this.delegate.attr(key);
     }
 
+    @Override
+    public <T> boolean hasAttr(AttributeKey<T> attributeKey) {
+        return this.delegate.hasAttr(attributeKey);
+    }
+
     @Override
     public int compareTo(@NotNull Channel o) {
         return this.delegate.compareTo(o);

src/main/java/com/comphenix/protocol/injector/netty/channel/NettyEventLoopProxy.java

@@ -10,11 +10,13 @@ import java.util.concurrent.TimeUnit;
 import java.util.concurrent.TimeoutException;
 import java.util.function.Consumer;
 
+import io.netty.channel.AbstractEventLoop;
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelFuture;
 import io.netty.channel.ChannelPromise;
 import io.netty.channel.EventLoop;
 import io.netty.channel.EventLoopGroup;
+import io.netty.util.concurrent.AbstractEventExecutor;
 import io.netty.util.concurrent.EventExecutor;
 import io.netty.util.concurrent.Future;
 import io.netty.util.concurrent.ProgressivePromise;
@@ -25,7 +27,7 @@ import io.netty.util.concurrent.ScheduledFuture;
  * An abstract event loop implementation which delegates all calls to a given event loop, but proxies all calls which
  * schedule something on the event loop to methods which decide what should happen to the scheduled task.
  */
-final class NettyEventLoopProxy implements EventLoop {
+final class NettyEventLoopProxy extends AbstractEventLoop {
 
     private static final Callable<?> EMPTY_CALLABLE = () -> null;
     private static final Runnable EMPTY_RUNNABLE = () -> {
@@ -236,6 +238,15 @@ final class NettyEventLoopProxy implements EventLoop {
         }
     }
 
+    // ShreddedPaper uses this method
+    @Override
+    public void lazyExecute(Runnable command) {
+        Runnable proxied = this.proxyRunnable(command);
+        if (proxied != null) {
+            ((AbstractEventExecutor)this.delegate).lazyExecute(proxied);
+        }
+    }
+
     @Override
     public void forEach(Consumer<? super EventExecutor> action) {
         this.delegate.forEach(action);
@@ -251,6 +262,12 @@ final class NettyEventLoopProxy implements EventLoop {
         return this.delegate.register(channel);
     }
 
+    @Override
+    public ChannelFuture register(ChannelPromise channelPromise) {
+        return this.delegate.register(channelPromise);
+    }
+
+    @Deprecated
     @Override
     public ChannelFuture register(Channel channel, ChannelPromise promise) {
         return this.delegate.register(channel, promise);

src/main/java/com/comphenix/protocol/injector/netty/channel/PacketListenerInvoker.java

@@ -14,13 +14,11 @@ import com.comphenix.protocol.reflect.fuzzy.FuzzyMethodContract;
 import com.comphenix.protocol.utility.MinecraftReflection;
 import com.comphenix.protocol.wrappers.WrappedChatComponent;
 
-import io.netty.channel.ChannelHandlerContext;
-
 /**
  * This class facilitates the invocation of methods on the current packet listener.
- * It attempts to execute the <code>send</code>, <code>read</code>, and <code>disconnect</code> 
- * methods and, upon failure (either due to the absence of the method or the packet 
- * listener being of an incorrect type), it delegates the call to the network manager.
+ * It attempts to execute the <code>send</code>, and <code>disconnect</code> methods, upon failure
+ * (either due to the absence of the method or the packet listener being of an incorrect type),
+ * it delegates the call to the network manager.
  * 
  * <p>Supported packet listener types include CONFIGURATION and PLAY. If the packet
  * listener does not match these types, or if the required method is missing, the 
@@ -43,7 +41,6 @@ public class PacketListenerInvoker {
     private static final boolean DOES_PACKET_LISTENER_DISCONNECT_USE_COMPONENT = doesPacketListenerDisconnectUseComponent();
 
     private static final MethodAccessor NETWORK_MANAGER_SEND = getNetworkManagerSend();
-    private static final MethodAccessor NETWORK_MANAGER_READ = getNetworkManagerRead();
     private static final MethodAccessor NETWORK_MANAGER_DISCONNECT = getNetworkManagerDisconnect();
     private static final MethodAccessor NETWORK_MANAGER_PACKET_LISTENER = getNetworkManagerPacketListener();
 
@@ -117,15 +114,6 @@ public class PacketListenerInvoker {
         return Accessors.getMethodAccessor(send);
     }
 
-    private static MethodAccessor getNetworkManagerRead() {
-        FuzzyReflection networkManager = FuzzyReflection.fromClass(MinecraftReflection.getNetworkManagerClass(), true);
-
-        Method read = networkManager
-            .getMethodByParameters("read", ChannelHandlerContext.class, MinecraftReflection.getPacketClass());
-
-        return Accessors.getMethodAccessor(read);
-    }
-
     private static MethodAccessor getNetworkManagerDisconnect() {
         FuzzyReflection networkManager = FuzzyReflection.fromClass(MinecraftReflection.getNetworkManagerClass());
 
@@ -190,7 +178,7 @@ public class PacketListenerInvoker {
     }
 
     /**
-     * Sends a packet using the current packet listener if available and valid; otherwise, 
+     * Sends a packet using the current packet listener if available and valid; otherwise,
      * falls back to the network manager.
      *
      * @param packet The packet to be sent.
@@ -204,15 +192,6 @@ public class PacketListenerInvoker {
         }
     }
 
-    /**
-     * Reads a packet directly using the network manager.
-     *
-     * @param packet The packet to be read.
-     */
-    public void read(Object packet) {
-        NETWORK_MANAGER_READ.invoke(this.networkManager, null, packet);
-    }
-
     /**
      * Disconnects the player using the current packet listener if available and valid; otherwise, 
      * falls back to the network manager.

src/main/java/com/comphenix/protocol/injector/packet/PacketRegistry.java

@@ -19,8 +19,6 @@ package com.comphenix.protocol.injector.packet;
 
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
-import java.lang.reflect.ParameterizedType;
-import java.lang.reflect.Type;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.HashMap;
@@ -31,18 +29,15 @@ import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
-import java.util.function.Function;
 
 import javax.annotation.Nullable;
 
 import com.comphenix.protocol.PacketType;
 import com.comphenix.protocol.PacketType.Sender;
 import com.comphenix.protocol.ProtocolLogger;
+import com.comphenix.protocol.injector.packet.internal.ProtocolRegistry_1_20_5;
 import com.comphenix.protocol.reflect.FuzzyReflection;
 import com.comphenix.protocol.reflect.StructureModifier;
-import com.comphenix.protocol.reflect.accessors.Accessors;
-import com.comphenix.protocol.reflect.accessors.FieldAccessor;
-import com.comphenix.protocol.reflect.accessors.MethodAccessor;
 import com.comphenix.protocol.reflect.fuzzy.FuzzyClassContract;
 import com.comphenix.protocol.reflect.fuzzy.FuzzyFieldContract;
 import com.comphenix.protocol.reflect.fuzzy.FuzzyMethodContract;
@@ -70,7 +65,7 @@ public class PacketRegistry {
      * 
      * @author Kristian
      */
-    private static class Register {
+    public static class Register {
         // The main lookup table
         final Map<PacketType, Optional<Class<?>>> typeToClass = new ConcurrentHashMap<>();
 
@@ -82,14 +77,18 @@ public class PacketRegistry {
         volatile Set<PacketType> clientPackets = new HashSet<>();
         final List<MapContainer> containers = new ArrayList<>();
 
-        public Register() {
+        private Register() {
         }
 
-        public void registerPacket(PacketType type, Class<?> clazz, Sender sender) {
-            typeToClass.put(type, Optional.of(clazz));
+        public void registerPacket(PacketType type, Class<?> packetClass, Sender sender, WrappedStreamCodec codec) {
+            typeToClass.put(type, Optional.of(packetClass));
+            classToType.put(packetClass, type);
 
-            classToType.put(clazz, type);
-            protocolClassToType.computeIfAbsent(type.getProtocol(), __ -> new ConcurrentHashMap<>()).put(clazz, type);
+            if (codec != null) {
+                classToCodec.put(packetClass, codec);
+            }
+
+            protocolClassToType.computeIfAbsent(type.getProtocol(), __ -> new ConcurrentHashMap<>()).put(packetClass, type);
 
             if (sender == Sender.CLIENT) {
                 clientPackets.add(type);
@@ -293,206 +292,9 @@ public class PacketRegistry {
         return result;
     }
 
-    @SuppressWarnings("unchecked")
     private static synchronized Register createRegisterV1_20_5() {
-        Object[] protocols = ENUM_PROTOCOL.getEnumConstants();
-
-        // PacketType<?> to class map
-        final Map<Object, Class<?>> packetTypeMap = new HashMap<>();
-
-        // List of all class containing PacketTypes
-        String[] packetTypesClassNames = new String[] {
-                "common.CommonPacketTypes",
-                "configuration.ConfigurationPacketTypes",
-                "cookie.CookiePacketTypes",
-                "game.GamePacketTypes",
-                "handshake.HandshakePacketTypes",
-                "login.LoginPacketTypes",
-                "ping.PingPacketTypes",
-                "status.StatusPacketTypes"
-        };
-
-        Class<?> packetTypeClass = MinecraftReflection.getMinecraftClass("network.protocol.PacketType");
-
-        for (String packetTypesClassName : packetTypesClassNames) {
-            Class<?> packetTypesClass = MinecraftReflection
-                    .getOptionalNMS("network.protocol." + packetTypesClassName)
-                    .orElse(null);
-            if (packetTypesClass == null) {
-                ProtocolLogger.debug("Can't find PacketType class: {0}, will skip it", packetTypesClassName);
-                continue;
-            }
-
-            // check every field for "static final PacketType<?>"
-            for (Field field : packetTypesClass.getDeclaredFields()) {
-                try {
-                    if (!Modifier.isFinal(field.getModifiers()) || !Modifier.isStatic(field.getModifiers())) {
-                        continue;
-                    }
-
-                    Object packetType = field.get(null);
-                    if (!packetTypeClass.isInstance(packetType)) {
-                        continue;
-                    }
-
-                    // retrieve the generic type T of the PacketType<T> field
-                    Type packet = ((ParameterizedType) field.getGenericType()).getActualTypeArguments()[0];
-                    if (packet instanceof Class<?>) {
-                        packetTypeMap.put(packetType, (Class<?>) packet);
-                    }
-                } catch (Exception e) {
-                    e.printStackTrace();
-                    continue;
-                }
-            }
-        }
-
-        // ID to Packet class maps
-        final Map<Object, Map<Class<?>, Integer>> serverMaps = new LinkedHashMap<>();
-        final Map<Object, Map<Class<?>, Integer>> clientMaps = new LinkedHashMap<>();
-
-        // global registry instance
         final Register result = new Register();
-
-        // List of all class containing ProtocolInfos
-        String[] protocolClassNames = new String[] {
-                "configuration.ConfigurationProtocols",
-                "game.GameProtocols",
-                "handshake.HandshakeProtocols",
-                "login.LoginProtocols",
-                "status.StatusProtocols"
-        };
-
-        Class<?> protocolInfoClass = MinecraftReflection.getProtocolInfoClass();
-        Class<?> protocolInfoUnboundClass = MinecraftReflection.getProtocolInfoUnboundClass();
-        Class<?> streamCodecClass = MinecraftReflection.getStreamCodecClass();
-        Class<?> idCodecClass = MinecraftReflection.getMinecraftClass("network.codec.IdDispatchCodec");
-        Class<?> idCodecEntryClass = MinecraftReflection.getMinecraftClass("network.codec.IdDispatchCodec$Entry", "network.codec.IdDispatchCodec$b");
-        Class<?> protocolDirectionClass = MinecraftReflection.getPacketFlowClass();
-
-        Function<?, ?> emptyFunction = input -> input;
-
-        FuzzyReflection protocolInfoReflection = FuzzyReflection.fromClass(protocolInfoClass);
-
-        MethodAccessor protocolAccessor = Accessors.getMethodAccessor(protocolInfoReflection
-                .getMethodByReturnTypeAndParameters("id", MinecraftReflection.getEnumProtocolClass(), new Class[0]));
-
-        MethodAccessor directionAccessor = Accessors.getMethodAccessor(protocolInfoReflection
-                .getMethodByReturnTypeAndParameters("flow", protocolDirectionClass, new Class[0]));
-
-        MethodAccessor codecAccessor = Accessors.getMethodAccessor(
-                protocolInfoReflection.getMethodByReturnTypeAndParameters("codec", streamCodecClass, new Class[0]));
-
-        MethodAccessor bindAccessor = Accessors.getMethodAccessor(FuzzyReflection.fromClass(protocolInfoUnboundClass)
-                .getMethodByReturnTypeAndParameters("bind", protocolInfoClass, new Class[] { Function.class }));
-
-        FuzzyReflection idCodecReflection = FuzzyReflection.fromClass(idCodecClass, true);
-
-        FieldAccessor byIdAccessor = Accessors.getFieldAccessor(idCodecReflection
-                .getField(FuzzyFieldContract.newBuilder().typeDerivedOf(List.class).build()));
-
-        FieldAccessor toIdAccessor = Accessors.getFieldAccessor(idCodecReflection
-                .getField(FuzzyFieldContract.newBuilder().typeDerivedOf(Map.class).build()));
-
-        FuzzyReflection idCodecEntryReflection = FuzzyReflection.fromClass(idCodecEntryClass, true);
-
-        MethodAccessor idCodecEntryTypeAccessor = Accessors.getMethodAccessor(idCodecEntryReflection
-                .getMethodByReturnTypeAndParameters("type", Object.class, new Class[0]));
-
-        MethodAccessor idCodecEntrySerializerAccessor = Accessors.getMethodAccessor(idCodecEntryReflection
-                .getMethodByReturnTypeAndParameters("serializer", streamCodecClass, new Class[0]));
-
-        for (String protocolClassName : protocolClassNames) {
-            Class<?> protocolClass = MinecraftReflection
-                    .getOptionalNMS("network.protocol." + protocolClassName)
-                    .orElse(null);
-            if (protocolClass == null) {
-                ProtocolLogger.debug("Can't find protocol class: {0}, will skip it", protocolClassName);
-                continue;
-            }
-
-            for (Field field : protocolClass.getDeclaredFields()) {
-                try {
-                    // ignore none static and final fields
-                    if (!Modifier.isFinal(field.getModifiers()) || !Modifier.isStatic(field.getModifiers())) {
-                        continue;
-                    }
-
-                    Object protocolInfo = field.get(null);
-
-                    // bind unbound ProtocolInfo to empty function to get real ProtocolInfo
-                    if (protocolInfoUnboundClass.isInstance(protocolInfo)) {
-                        protocolInfo = bindAccessor.invoke(protocolInfo, new Object[] { emptyFunction });
-                    }
-
-                    // ignore any field that isn't a ProtocolInfo
-                    if (!protocolInfoClass.isInstance(protocolInfo)) {
-                        continue;
-                    }
-
-                    // get codec and check if codec is instance of IdDispatchCodec
-                    // since that is the only support codec as of now
-                    Object codec = codecAccessor.invoke(protocolInfo);
-                    if (!idCodecClass.isInstance(codec)) {
-                        continue;
-                    }
-
-                    // retrieve packetTypeMap and convert it to packetIdMap
-                    Map<Class<?>, Integer> packetMap = new HashMap<>();
-                    List<Object> serializerList = (List<Object>) byIdAccessor.get(codec);
-                    Map<Object, Integer> packetTypeIdMap = (Map<Object, Integer>) toIdAccessor.get(codec);
-
-                    for (Map.Entry<Object, Integer> entry : packetTypeIdMap.entrySet()) {
-                        Class<?> packetClass = packetTypeMap.get(entry.getKey());
-                        if (packetClass == null) {
-                            throw new RuntimeException("packetType missing packet " + entry.getKey());
-                        }
-
-                        packetMap.put(packetClass, entry.getValue());
-                    }
-
-                    // retrieve packet codecs for packet construction and write methods
-                    for (Object entry : serializerList) {
-                        Object packetType = idCodecEntryTypeAccessor.invoke(entry);
-
-                        Class<?> packetClass = packetTypeMap.get(packetType);
-                        if (packetClass == null) {
-                            throw new RuntimeException("packetType missing packet " + packetType);
-                        }
-
-                        Object serializer = idCodecEntrySerializerAccessor.invoke(entry);
-                        result.classToCodec.put(packetClass, new WrappedStreamCodec(serializer));
-                    }
-
-                    // get EnumProtocol and Direction of protocol info
-                    Object protocol = protocolAccessor.invoke(protocolInfo);
-                    String direction = directionAccessor.invoke(protocolInfo).toString();
-
-                    if (direction.contains("CLIENTBOUND")) { // Sent by Server
-                        serverMaps.put(protocol, packetMap);
-                    } else if (direction.contains("SERVERBOUND")) { // Sent by Client
-                        clientMaps.put(protocol, packetMap);
-                    }
-                } catch (Exception e) {
-                    e.printStackTrace();
-                    continue;
-                }
-            }
-        }
-
-        for (Object protocol : protocols) {
-            Enum<?> enumProtocol = (Enum<?>) protocol;
-            PacketType.Protocol equivalent = PacketType.Protocol.fromVanilla(enumProtocol);
-
-            // Associate known types
-            if (serverMaps.containsKey(protocol)) {
-                associatePackets(result, reverse(serverMaps.get(protocol)), equivalent, Sender.SERVER);
-            }
-            if (clientMaps.containsKey(protocol)) {
-                associatePackets(result, reverse(clientMaps.get(protocol)), equivalent, Sender.CLIENT);
-            }
-        }
-
+        ProtocolRegistry_1_20_5.fillRegister(result);
         return result;
     }
 
@@ -517,7 +319,7 @@ public class PacketRegistry {
             PacketType type = PacketType.fromCurrent(protocol, sender, packetId, packetClass);
 
             try {
-                register.registerPacket(type, packetClass, sender);
+                register.registerPacket(type, packetClass, sender, null);
             } catch (Exception ex) {
                 ProtocolLogger.debug("Encountered an exception associating packet " + type, ex);
             }
@@ -610,8 +412,8 @@ public class PacketRegistry {
     private static Class<?> searchForPacket(List<String> classNames) {
         for (String name : classNames) {
             try {
-                Class<?> clazz = MinecraftReflection.getMinecraftClass(name);
-                if (MinecraftReflection.getPacketClass().isAssignableFrom(clazz)
+                Class<?> clazz = resolvePacketClassName(name);
+                if (clazz != null && MinecraftReflection.getPacketClass().isAssignableFrom(clazz)
                         && !Modifier.isAbstract(clazz.getModifiers())) {
                     return clazz;
                 }
@@ -622,6 +424,22 @@ public class PacketRegistry {
         return null;
     }
 
+    /**
+     * Resolve a single packet class name. Fully-qualified names (those already containing their
+     * package, e.g. {@code net.minecraft.network.protocol.game.XPacket}) are loaded directly, since
+     * {@link MinecraftReflection#getMinecraftClass(String)} would otherwise prepend the Minecraft
+     * package and fail to find them. Relative names continue to be resolved against the Minecraft
+     * package.
+     */
+    private static Class<?> resolvePacketClassName(String name) {
+        Optional<Class<?>> direct = MinecraftReflection.getOptionalClass(name);
+        if (direct.isPresent()) {
+            return direct.get();
+        }
+
+        return MinecraftReflection.getMinecraftClass(name);
+    }
+
     /**
      * Retrieves the correct packet class from a given type.
      *

src/main/java/com/comphenix/protocol/injector/packet/internal/IdCodecWrapper.java

@@ -0,0 +1,71 @@
+package com.comphenix.protocol.injector.packet.internal;
+
+import java.util.Arrays;
+import java.util.List;
+
+import com.comphenix.protocol.reflect.FuzzyReflection;
+import com.comphenix.protocol.reflect.accessors.Accessors;
+import com.comphenix.protocol.reflect.accessors.FieldAccessor;
+import com.comphenix.protocol.reflect.accessors.MethodAccessor;
+import com.comphenix.protocol.reflect.fuzzy.FuzzyFieldContract;
+import com.comphenix.protocol.utility.MinecraftReflection;
+import com.comphenix.protocol.wrappers.AbstractWrapper;
+import com.comphenix.protocol.wrappers.WrappedStreamCodec;
+
+/**
+ * Class only works for version 1.20.5+
+ */
+public class IdCodecWrapper extends AbstractWrapper {
+
+    private static final Class<?> ID_CODEC_CLASS;
+    private static final FieldAccessor BY_ID_ACCESSOR;
+
+    private static final Class<?> ID_CODEC_ENTRY_CLASS;
+    private static final MethodAccessor ENTRY_TYPE_ACCESSOR;
+    private static final MethodAccessor ENTRY_SERIALIZER_ACCESSOR;
+
+    static {
+        ID_CODEC_CLASS = MinecraftReflection.getMinecraftClass("network.codec.IdDispatchCodec");
+        BY_ID_ACCESSOR = Accessors.getFieldAccessor(FuzzyReflection.fromClass(ID_CODEC_CLASS, true)
+                .getField(FuzzyFieldContract.newBuilder().typeDerivedOf(List.class).build()));
+
+        ID_CODEC_ENTRY_CLASS = Arrays.stream(ID_CODEC_CLASS.getNestMembers())
+            .filter(Class::isRecord)
+            .findFirst()
+            .orElseThrow(() -> new RuntimeException("Failed to find entry class for: " + ID_CODEC_CLASS));
+
+        FuzzyReflection entryReflection = FuzzyReflection.fromClass(ID_CODEC_ENTRY_CLASS, true);
+        ENTRY_TYPE_ACCESSOR = Accessors.getMethodAccessor(entryReflection
+                .getMethodByReturnTypeAndParameters("type", Object.class, new Class[0]));
+        ENTRY_SERIALIZER_ACCESSOR = Accessors.getMethodAccessor(entryReflection
+                .getMethodByReturnTypeAndParameters("serializer", MinecraftReflection.getStreamCodecClass(), new Class[0]));
+    }
+
+    public IdCodecWrapper(Object handle) {
+        super(ID_CODEC_CLASS);
+        setHandle(handle);
+    }
+
+    public List<Entry> getById() {
+        // list represents a packet-id to {type, codec} lookup
+        List<?> byId = (List<?>) BY_ID_ACCESSOR.get(this.handle);
+        return byId.stream().map(Entry::new).toList();
+    }
+
+    public class Entry extends AbstractWrapper {
+
+        public Entry(Object handle) {
+            super(ID_CODEC_ENTRY_CLASS);
+            setHandle(handle);
+        }
+
+        public Object type() {
+            return ENTRY_TYPE_ACCESSOR.invoke(this.handle);
+        }
+
+        public WrappedStreamCodec serializer() {
+            Object serializer = ENTRY_SERIALIZER_ACCESSOR.invoke(this.handle);
+            return new WrappedStreamCodec(serializer);
+        }
+    }
+}

src/main/java/com/comphenix/protocol/injector/packet/internal/ProtocolContexts.java

@@ -0,0 +1,44 @@
+package com.comphenix.protocol.injector.packet.internal;
+
+import java.lang.reflect.InvocationHandler;
+import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
+
+import com.comphenix.protocol.utility.MinecraftReflection;
+
+/**
+ * Class only works for version 1.21.5+
+ */
+public class ProtocolContexts {
+
+    private static final Class<?> GAME_PROTOCOL_CONTEXT_CLASS;
+
+    static {
+        GAME_PROTOCOL_CONTEXT_CLASS = MinecraftReflection.getNullableNMS(
+                "network.protocol.game.GameProtocols$a" /*Spigot Mapping*/,
+                "network.protocol.game.GameProtocols$Context" /*Mojang Mapping*/);
+    }
+
+    public static Object createGameProtocolContext() {
+        return createContext(GAME_PROTOCOL_CONTEXT_CLASS, (proxy, method, args) -> {
+            if (method.getName().equals("hasInfiniteMaterials") || (method.getReturnType() == boolean.class && method.getParameterCount() == 0)) {
+                return true;
+            }
+            return null;
+        });
+    }
+
+    private static Object createContext(Class<?> interfaceClass, InvocationHandler handler) {
+    	if (interfaceClass == null) {
+    		return null;
+    	}
+
+        return Proxy.newProxyInstance(ProtocolContexts.class.getClassLoader(), new Class[] { interfaceClass }, new InvocationHandler() {
+
+            @Override
+            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+                return handler.invoke(proxy, method, args);
+            }
+        });
+    }
+}

src/main/java/com/comphenix/protocol/injector/packet/internal/ProtocolInfoWrapper.java

@@ -0,0 +1,102 @@
+package com.comphenix.protocol.injector.packet.internal;
+
+import java.util.Objects;
+import java.util.function.Function;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.reflect.FuzzyReflection;
+import com.comphenix.protocol.reflect.accessors.Accessors;
+import com.comphenix.protocol.reflect.accessors.MethodAccessor;
+import com.comphenix.protocol.utility.MinecraftReflection;
+import com.comphenix.protocol.wrappers.AbstractWrapper;
+
+/**
+ * Class only works for version 1.20.5+
+ */
+public class ProtocolInfoWrapper extends AbstractWrapper {
+
+    private static final @NotNull Class<?> SIMPLE_UNBOUND_PROTOCOL_CLASS;
+    private static final @NotNull MethodAccessor BIND_SIMPLE_ACCESSOR;
+
+    private static final @Nullable Class<?> UNBOUND_PROTOCOL_CLASS;
+    private static final @Nullable MethodAccessor BIND_CONTEXT_ACCESSOR;
+
+    private static final @NotNull MethodAccessor ID_ACCESSOR;
+    private static final @NotNull MethodAccessor FLOW_ACCESSOR;
+    private static final @NotNull MethodAccessor CODEC_ACCESSOR;
+
+    static {
+        SIMPLE_UNBOUND_PROTOCOL_CLASS = MinecraftReflection.getMinecraftClass(
+                "network.protocol.SimpleUnboundProtocol" /* 1.21.5+ */,
+                "network.protocol.UnboundProtocol" /* 1.21.8+ Alternative */,
+                "network.ProtocolInfo$a" /* Spigot Mappings */,
+                "network.ProtocolInfo$Unbound" /* Mojang Mappings */);
+        BIND_SIMPLE_ACCESSOR = Accessors.getMethodAccessor(FuzzyReflection.fromClass(SIMPLE_UNBOUND_PROTOCOL_CLASS)
+                .getMethodByReturnTypeAndParameters("bind", MinecraftReflection.getProtocolInfoClass(), new Class[] { Function.class }));
+
+        UNBOUND_PROTOCOL_CLASS = MinecraftReflection.getNullableNMS("network.protocol.UnboundProtocol");
+        if (UNBOUND_PROTOCOL_CLASS != null) {
+            BIND_CONTEXT_ACCESSOR = Accessors.getMethodAccessor(FuzzyReflection.fromClass(UNBOUND_PROTOCOL_CLASS)
+                    .getMethodByReturnTypeAndParameters("bind", MinecraftReflection.getProtocolInfoClass(), new Class[] { Function.class, Object.class }));
+        } else {
+            BIND_CONTEXT_ACCESSOR = null;
+        }
+
+        FuzzyReflection protocolInfoReflection = FuzzyReflection.fromClass(MinecraftReflection.getProtocolInfoClass());
+        ID_ACCESSOR = Accessors.getMethodAccessor(protocolInfoReflection
+                .getMethodByReturnTypeAndParameters("id", MinecraftReflection.getEnumProtocolClass(), new Class[0]));
+        FLOW_ACCESSOR = Accessors.getMethodAccessor(protocolInfoReflection
+                .getMethodByReturnTypeAndParameters("flow", MinecraftReflection.getPacketFlowClass(), new Class[0]));
+        CODEC_ACCESSOR = Accessors.getMethodAccessor(protocolInfoReflection
+                .getMethodByReturnTypeAndParameters("codec", MinecraftReflection.getStreamCodecClass(), new Class[0]));
+    }
+
+    public static boolean isUnboundProtocol(Object protocol) {
+        return SIMPLE_UNBOUND_PROTOCOL_CLASS.isInstance(protocol) || (UNBOUND_PROTOCOL_CLASS != null && UNBOUND_PROTOCOL_CLASS.isInstance(protocol));
+    }
+
+    public static ProtocolInfoWrapper fromUnbound(Object protocol, Object context) {
+        // bind to identity function in-order to map directly to FriendlyByteBuf instead of ByteBuf
+
+        if (SIMPLE_UNBOUND_PROTOCOL_CLASS.isInstance(protocol)) {
+            Object protocolInfo = BIND_SIMPLE_ACCESSOR.invoke(protocol, Function.identity());
+            return new ProtocolInfoWrapper(protocolInfo);
+        }
+
+        if (UNBOUND_PROTOCOL_CLASS != null && UNBOUND_PROTOCOL_CLASS.isInstance(protocol)) {
+            Object protocolInfo = BIND_CONTEXT_ACCESSOR.invoke(protocol, Function.identity(), Objects.requireNonNull(context));
+            return new ProtocolInfoWrapper(protocolInfo);
+        }
+
+        throw new RuntimeException("Unknown protocol implementation: " + protocol);
+    }
+
+    private ProtocolInfoWrapper(Object handle) {
+        super(MinecraftReflection.getProtocolInfoClass());
+        setHandle(handle);
+    }
+
+    public PacketType.Protocol id() {
+        Object protocol = ID_ACCESSOR.invoke(this.handle);
+        return PacketType.Protocol.fromVanilla((Enum<?>) protocol);
+    }
+
+    public PacketType.Sender flow() {
+        String packetFlow = FLOW_ACCESSOR.invoke(this.handle).toString();
+
+        if (packetFlow.contains("CLIENTBOUND")) {
+            return PacketType.Sender.SERVER;
+        } else if (packetFlow.contains("SERVERBOUND")) {
+            return PacketType.Sender.CLIENT;
+        }
+
+        throw new RuntimeException("Unknown packet flow: " + packetFlow);
+    }
+
+    public IdCodecWrapper codec() {
+        return new IdCodecWrapper(CODEC_ACCESSOR.invoke(this.handle));
+    }
+}

src/main/java/com/comphenix/protocol/injector/packet/internal/ProtocolRegistry_1_20_5.java

@@ -0,0 +1,150 @@
+package com.comphenix.protocol.injector.packet.internal;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Supplier;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.ProtocolLogger;
+import com.comphenix.protocol.injector.packet.PacketRegistry.Register;
+import com.comphenix.protocol.utility.MinecraftReflection;
+
+/**
+ * Class only works for version 1.20.5+
+ */
+public class ProtocolRegistry_1_20_5 {
+
+    private static final Class<?> PACKET_TYPE_CLASS = MinecraftReflection.getMinecraftClass("network.protocol.PacketType");;
+
+    /**
+     * List of all class containing PacketTypes
+     */
+    public static final List<String> PACKET_TYPES_CLASS_NAMES = List.of(
+            "common.CommonPacketTypes",
+            "configuration.ConfigurationPacketTypes",
+            "cookie.CookiePacketTypes",
+            "game.GamePacketTypes",
+            "handshake.HandshakePacketTypes",
+            "login.LoginPacketTypes",
+            "ping.PingPacketTypes",
+            "status.StatusPacketTypes");
+
+    /**
+     * List of all class containing ProtocolInfos
+     */
+    public static final List<Protocol> PROTOCOLS = List.of(
+            new Protocol("configuration.ConfigurationProtocols", null),
+            new Protocol("game.GameProtocols", ProtocolContexts::createGameProtocolContext),
+            new Protocol("handshake.HandshakeProtocols", null),
+            new Protocol("login.LoginProtocols", null),
+            new Protocol("status.StatusProtocols", null));
+
+    public static void fillRegister(Register register) {
+        final Map<Object, Class<?>> packetTypeMap = getPacketTypes();
+
+        for (Protocol protocol : PROTOCOLS) {
+            Class<?> protocolClass = MinecraftReflection.getNullableNMS("network.protocol." + protocol.className());
+            if (protocolClass == null) {
+                ProtocolLogger.debug("Can't find protocol class: {0}, will skip it", protocol);
+                continue;
+            }
+
+            for (Field field : protocolClass.getDeclaredFields()) {
+                try {
+                    // ignore none static and final fields
+                    if (!Modifier.isFinal(field.getModifiers()) || !Modifier.isStatic(field.getModifiers())) {
+                        continue;
+                    }
+
+                    Object fieldValue = field.get(null);
+                    
+                    // Skip any field that isn't a unbound ProtocolInfo.
+                    // We need to bind the ProtocolInfo ourself as we apply our own stream mapping
+                    // inside the ProtocolInfoWrapper::fromUnbound method
+                    if (!ProtocolInfoWrapper.isUnboundProtocol(fieldValue)) {
+                        continue;
+                    }
+
+                    // create optional context object to bind protocol to
+                    Object context = protocol.context() != null
+                            ? protocol.context().get()
+                            : null;
+
+                    // wrap bound protocol info for ease of use
+                    ProtocolInfoWrapper protocolInfo = ProtocolInfoWrapper.fromUnbound(fieldValue, context);
+                    PacketType.Protocol packetProtocol = protocolInfo.id();
+                    PacketType.Sender packetSender = protocolInfo.flow();
+
+                    // register each packet to Register instance
+                    List<IdCodecWrapper.Entry> entries = protocolInfo.codec().getById();
+                    for (int id = 0; id < entries.size(); id++) {
+                        IdCodecWrapper.Entry entry = entries.get(id);
+
+                        Class<?> packetClass = packetTypeMap.get(entry.type());
+                        if (packetClass == null) {
+                            throw new RuntimeException("packetType missing packet " + entry.type());
+                        }
+
+                        PacketType packetType = PacketType.fromCurrent(packetProtocol, packetSender, id, packetClass);
+                        // TODO(fix): validate that every codec expects FriendlyByteBuf
+                        register.registerPacket(packetType, packetClass, packetSender, entry.serializer());
+                    }
+                } catch (Exception e) {
+                    e.printStackTrace();
+                    continue;
+                }
+            }
+        }
+    }
+
+    /**
+     * Returns a PacketType to packet class lookup map
+     */
+    private static Map<Object, Class<?>> getPacketTypes() {
+        Map<Object, Class<?>> packetTypeMap = new HashMap<>();
+
+        for (String packetTypesClassName : PACKET_TYPES_CLASS_NAMES) {
+            Class<?> packetTypesClass = MinecraftReflection.getNullableNMS("network.protocol." + packetTypesClassName);
+            if (packetTypesClass == null) {
+                ProtocolLogger.debug("Can't find PacketType class: {0}, will skip it", packetTypesClassName);
+                continue;
+            }
+
+            // check every field for "static final PacketType<?>"
+            for (Field field : packetTypesClass.getDeclaredFields()) {
+                try {
+                    if (!Modifier.isFinal(field.getModifiers()) || !Modifier.isStatic(field.getModifiers())) {
+                        continue;
+                    }
+
+                    Object packetType = field.get(null);
+                    if (!PACKET_TYPE_CLASS.isInstance(packetType)) {
+                        continue;
+                    }
+
+                    // retrieve the generic type T of the PacketType<T> field
+                    Type packet = ((ParameterizedType) field.getGenericType()).getActualTypeArguments()[0];
+                    if (packet instanceof Class<?>) {
+                        packetTypeMap.put(packetType, (Class<?>) packet);
+                    }
+                } catch (Exception e) {
+                    e.printStackTrace();
+                    continue;
+                }
+            }
+        }
+
+        return packetTypeMap;
+    }
+
+    private record Protocol(@NotNull String className, @Nullable Supplier<Object> context) {
+    }
+}

src/main/java/com/comphenix/protocol/utility/CachedPackage.java

@@ -88,20 +88,23 @@ final class CachedPackage {
      * @throws RuntimeException If we are unable to find the given class.
      */
     public Optional<Class<?>> getPackageClass(String className, String... aliases) {
-        return cache.computeIfAbsent(className, x -> {
-            Optional<Class<?>> clazz = resolveClass(className);
-            if (clazz.isPresent()) {
-                return clazz;
-            }
+        Optional<Class<?>> cached = cache.get(className);
+        if (cached != null) {
+            return cached;
+        }
 
+        Optional<Class<?>> clazz = resolveClass(className);
+        if (!clazz.isPresent()) {
             for (String alias : aliases) {
-                clazz = resolveClass(alias);
-                if (clazz.isPresent()) {
-                    return clazz;
+                Optional<Class<?>> aliasClazz = resolveClass(alias);
+                if (aliasClazz.isPresent()) {
+                    clazz = aliasClazz;
+                    break;
                 }
             }
+        }
 
-            return Optional.empty();
-        });
+        cache.put(className, clazz);
+        return clazz;
     }
 }

src/main/java/com/comphenix/protocol/utility/MinecraftProtocolVersion.java

@@ -93,6 +93,14 @@ public final class MinecraftProtocolVersion {
         map.put(new MinecraftVersion(1, 20, 5), 766);
 
         map.put(new MinecraftVersion(1, 21, 0), 767);
+        map.put(new MinecraftVersion(1, 21, 2), 768);
+        map.put(new MinecraftVersion(1, 21, 6), 771);
+        map.put(new MinecraftVersion(1, 21, 8), 772);
+        map.put(new MinecraftVersion(1, 21, 9), 773);
+        map.put(new MinecraftVersion(1, 21, 11), 774);
+
+        map.put(new MinecraftVersion(26, 1, 0), 775);
+        map.put(new MinecraftVersion(26, 2, 0), 776);
         return map;
     }
 

src/main/java/com/comphenix/protocol/utility/MinecraftReflection.java

@@ -553,6 +553,10 @@ public final class MinecraftReflection {
         return getClass("com.mojang.authlib.GameProfile");
     }
 
+    public static Class<?> getGameProfilePropertyMapClass() {
+        return getClass("com.mojang.authlib.properties.PropertyMap");
+    }
+
     /**
      * Retrieve the entity (NMS) class.
      *
@@ -685,7 +689,8 @@ public final class MinecraftReflection {
      * @throws IllegalStateException If the class could not be found or deduced.
      */
     public static Class<?> getChatSerializerClass() {
-        return getMinecraftClass("network.chat.IChatBaseComponent$ChatSerializer", "network.chat.Component$Serializer", "IChatBaseComponent$ChatSerializer");
+        return getMinecraftClass("network.chat.IChatBaseComponent$ChatSerializer",
+                "network.chat.Component$Serializer", "network.chat.ComponentSerialization", "IChatBaseComponent$ChatSerializer");
     }
 
     /**
@@ -916,15 +921,19 @@ public final class MinecraftReflection {
     }
 
     public static Class<?> getMinecraftKeyClass() {
-        return getMinecraftClass("resources.MinecraftKey", "resources.ResourceLocation", "MinecraftKey");
+        return getMinecraftClass("resources.MinecraftKey", "resources.Identifier", "resources.ResourceLocation", "MinecraftKey");
     }
 
     public static Class<?> getMobEffectListClass() {
-        return getMinecraftClass("world.effect.MobEffectList", "MobEffectList", "world.effect.MobEffect");
+        return getMinecraftClass("world.effect.MobEffectList", "MobEffectList", "world.effect.MobEffect", "world.effect.MobEffects");
+    }
+
+    public static Class<?> getDamageTypeClass() {
+        return getMinecraftClass("world.damagesource.DamageType");
     }
 
     public static Class<?> getSoundEffectClass() {
-        return getNullableNMS("sounds.SoundEffect", "sounds.SoundEvent", "SoundEffect");
+        return getNullableNMS("sounds.SoundEffect", "sounds.SoundEvent", "SoundEffect", "sounds.SoundEvents");
     }
 
     /**
@@ -1113,6 +1122,15 @@ public final class MinecraftReflection {
         return getOptionalNMS("network.chat.numbers.StyledFormat");
     }
 
+    /**
+     * Retrieve the NMS TeamColor class, added in 26.2.
+     *
+     * @return The TeamColor class.
+     */
+    public static Optional<Class<?>> getTeamColorClass() {
+        return getOptionalNMS("world.scores.TeamColor");
+    }
+
     /**
      * Retrieve the Gson class used by Minecraft.
      *
@@ -1475,6 +1493,18 @@ public final class MinecraftReflection {
             .orElseThrow(() -> new RuntimeException("Cannot find class " + className));
     }
 
+    /**
+     * Attempt to load a class by its fully-qualified canonical name, without prepending the
+     * Minecraft package. Unlike {@link #getMinecraftClass(String)}, this can resolve names that
+     * already include their package (e.g. {@code net.minecraft.network.protocol.game.XPacket}).
+     *
+     * @param className - the fully-qualified class name.
+     * @return Optional that may contain the class.
+     */
+    public static Optional<Class<?>> getOptionalClass(String className) {
+        return getClassSource().loadClass(className);
+    }
+
     /**
      * Retrieve the class object of a specific CraftBukkit class.
      *
@@ -1679,7 +1709,7 @@ public final class MinecraftReflection {
     }
 
     public static Class<?> getEntityTypes() {
-        return getMinecraftClass("world.entity.EntityTypes", "world.entity.EntityType", "EntityTypes");
+        return getMinecraftClass("world.entity.EntityType", "world.entity.EntityTypes", "EntityTypes");
     }
 
     public static Class<?> getParticleParam() {
@@ -1898,4 +1928,13 @@ public final class MinecraftReflection {
 
         return isMojangMapped;
     }
+
+    /**
+     * Retrieves the PositionMoveRotation class (introduced in 1.21.2).
+     *
+     * @return The PositionMoveRotation class.
+     */
+    public static Class<?> getPositionMoveRotationClass() {
+        return getMinecraftClass("world.entity.PositionMoveRotation");
+    }
 }

src/main/java/com/comphenix/protocol/utility/MinecraftRegistryAccess.java

@@ -2,6 +2,7 @@ package com.comphenix.protocol.utility;
 
 import java.lang.reflect.Modifier;
 
+import com.comphenix.protocol.wrappers.codecs.WrappedDynamicOps;
 import org.bukkit.Bukkit;
 
 import com.comphenix.protocol.reflect.FuzzyReflection;
@@ -17,6 +18,7 @@ public class MinecraftRegistryAccess {
 
 	private static MethodAccessor GET_SERVER = null;
 	private static MethodAccessor REGISTRY_ACCESS = null;
+	private static MethodAccessor CREATE_SERIALIZATION_CONTEXT = null;
 
 	// lazy initialized
 	private static Object registryAccess = null;
@@ -36,6 +38,14 @@ public class MinecraftRegistryAccess {
 							.banModifier(Modifier.STATIC)
 							.returnDerivedOf(MinecraftReflection.getRegistryAccessClass())
 							.build()));
+
+			CREATE_SERIALIZATION_CONTEXT = Accessors.getMethodAccessor(
+					FuzzyReflection.fromClass(MinecraftReflection.getHolderLookupProviderClass(), false)
+							.getMethod(FuzzyMethodContract.newBuilder()
+									.banModifier(Modifier.STATIC)
+									.returnDerivedOf(MinecraftReflection.getDynamicOpsClass())
+									.parameterDerivedOf(MinecraftReflection.getDynamicOpsClass())
+									.build()));
 		}
 	}
 
@@ -57,4 +67,13 @@ public class MinecraftRegistryAccess {
 
 		return registryAccess;
 	}
+
+	/**
+	 * Returns a RegistryOps using the given DynamicOps as the underlying ops.
+	 *
+	 * @return a RegistryOps
+	 */
+	public static WrappedDynamicOps createSerializationContext(WrappedDynamicOps dynamicOps) {
+		return WrappedDynamicOps.fromHandle(CREATE_SERIALIZATION_CONTEXT.invoke(get(), dynamicOps.getHandle()));
+	}
 }

src/main/java/com/comphenix/protocol/utility/MinecraftVersion.java

@@ -36,6 +36,51 @@ import org.bukkit.Server;
  * @author Kristian
  */
 public final class MinecraftVersion implements Comparable<MinecraftVersion>, Serializable {
+    /**
+     * Version 26.2 - chaos cubed
+     */
+    public static final MinecraftVersion v26_2 = new MinecraftVersion("26.2");
+
+    /**
+     * Version 26.1 - tiny takeover
+     */
+    public static final MinecraftVersion v26_1 = new MinecraftVersion("26.1");
+
+    /**
+     * Version 1.21.11 - mounts of mayhem
+     */
+    public static final MinecraftVersion v1_21_11 = new MinecraftVersion("1.21.11");
+
+    /**
+     * Version 1.21.10 - hotfix for 1.21.9
+     */
+    public static final MinecraftVersion v1_21_10 = new MinecraftVersion("1.21.10");
+
+    /**
+     * Version 1.21.9 - the copper age drop
+     */
+    public static final MinecraftVersion v1_21_9 = new MinecraftVersion("1.21.9");
+
+    /**
+     * Version 1.21.6 - chase the skies
+     */
+    public static final MinecraftVersion v1_21_6 = new MinecraftVersion("1.21.6");
+
+    /**
+     * Version 1.21.5 - spring to life drop
+     */
+    public static final MinecraftVersion v1_21_5 = new MinecraftVersion("1.21.5");
+
+    /**
+     * Version 1.21.4 - the garden awakens drop
+     */
+    public static final MinecraftVersion v1_21_4 = new MinecraftVersion("1.21.4");
+
+    /**
+     * Version 1.21.2 - the bundles of bravery drop
+     */
+    public static final MinecraftVersion v1_21_2 = new MinecraftVersion("1.21.2");
+
     /**
      * Version 1.21.0 - the tricky trials update
      */
@@ -149,7 +194,7 @@ public final class MinecraftVersion implements Comparable<MinecraftVersion>, Ser
     /**
      * The latest release version of minecraft.
      */
-    public static final MinecraftVersion LATEST = v1_21_0;
+    public static final MinecraftVersion LATEST = v26_2;
 
     // used when serializing
     private static final long serialVersionUID = -8695133558996459770L;

src/main/java/com/comphenix/protocol/utility/StreamSerializer.java

@@ -10,7 +10,9 @@ import java.util.Base64;
 import com.comphenix.protocol.injector.netty.NettyByteBufAdapter;
 import com.comphenix.protocol.reflect.FuzzyReflection;
 import com.comphenix.protocol.reflect.accessors.Accessors;
+import com.comphenix.protocol.reflect.accessors.FieldAccessor;
 import com.comphenix.protocol.reflect.accessors.MethodAccessor;
+import com.comphenix.protocol.reflect.fuzzy.FuzzyFieldContract;
 import com.comphenix.protocol.reflect.fuzzy.FuzzyMethodContract;
 import com.comphenix.protocol.wrappers.nbt.NbtCompound;
 import com.comphenix.protocol.wrappers.nbt.NbtFactory;
@@ -31,6 +33,7 @@ public class StreamSerializer {
     private static final StreamSerializer DEFAULT = new StreamSerializer();
 
     // Cached methods
+    private static FieldAccessor STREAM_CODEC;
     private static MethodAccessor READ_ITEM_METHOD;
     private static MethodAccessor WRITE_ITEM_METHOD;
 
@@ -235,14 +238,35 @@ public class StreamSerializer {
         Object serializer = MinecraftReflection.getPacketDataSerializer(buf);
 
         if (READ_ITEM_METHOD == null) {
-            READ_ITEM_METHOD = Accessors.getMethodAccessor(FuzzyReflection
-                    .fromClass(serializer.getClass(), false)
-                    .getMethodByReturnTypeAndParameters("readItemStack", MinecraftReflection.getItemStackClass()));
+            if (MinecraftVersion.v1_21_0.atOrAbove()) {
+                if (STREAM_CODEC == null) {
+                    STREAM_CODEC = Accessors.getFieldAccessor(FuzzyReflection
+                            .fromClass(MinecraftReflection.getItemStackClass())
+                            .getFieldList(FuzzyFieldContract.newBuilder()
+                                    .typeExact(MinecraftReflection.getStreamCodecClass())
+                                    .build()).get(1)); //skip OPTIONAL_STREAM_CODEC
+                }
+
+                READ_ITEM_METHOD = Accessors.getMethodAccessor(FuzzyReflection.fromObject(STREAM_CODEC.get(null), true)
+                        .getMethod(FuzzyMethodContract.newBuilder()
+                                .parameterExactType(MinecraftReflection.getRegistryFriendlyByteBufClass().get())
+                                .returnTypeExact(MinecraftReflection.getItemStackClass())
+                                .build()));
+            } else {
+                READ_ITEM_METHOD = Accessors.getMethodAccessor(FuzzyReflection
+                        .fromClass(serializer.getClass(), false)
+                        .getMethodByReturnTypeAndParameters("readItemStack", MinecraftReflection.getItemStackClass()));
+            }
         }
 
         try {
             // unwrap the item
-            Object nmsItem = READ_ITEM_METHOD.invoke(serializer);
+            Object nmsItem;
+            if (MinecraftVersion.v1_21_0.atOrAbove()) {
+                nmsItem = READ_ITEM_METHOD.invoke(STREAM_CODEC.get(null), serializer);
+            } else {
+                nmsItem = READ_ITEM_METHOD.invoke(serializer);
+            }
             return nmsItem != null ? MinecraftReflection.getBukkitItemStack(nmsItem) : null;
         } finally {
             ReferenceCountUtil.safeRelease(buf);
@@ -262,11 +286,26 @@ public class StreamSerializer {
      * @throws IOException If the operation fails due to reflection problems.
      */
     public void serializeItemStack(DataOutputStream output, ItemStack stack) throws IOException {
-        // TODO this functionality was replaced by the CODEC field in the nms ItemStack
         if (WRITE_ITEM_METHOD == null) {
-            WRITE_ITEM_METHOD = Accessors.getMethodAccessor(FuzzyReflection
-                    .fromClass(MinecraftReflection.getPacketDataSerializerClass(), true)
-                    .getMethodByParameters("writeStack", MinecraftReflection.getItemStackClass()));
+            if (MinecraftVersion.v1_21_0.atOrAbove()) {
+                if (STREAM_CODEC == null) {
+                    STREAM_CODEC = Accessors.getFieldAccessor(FuzzyReflection
+                            .fromClass(MinecraftReflection.getItemStackClass())
+                            .getFieldList(FuzzyFieldContract.newBuilder()
+                                    .typeExact(MinecraftReflection.getStreamCodecClass())
+                                    .build()).get(1)); //skip OPTIONAL_STREAM_CODEC
+                }
+
+                WRITE_ITEM_METHOD = Accessors.getMethodAccessor(FuzzyReflection.fromObject(STREAM_CODEC.get(null), true)
+                        .getMethod(FuzzyMethodContract.newBuilder()
+                                .parameterExactArray(MinecraftReflection.getRegistryFriendlyByteBufClass().get(), MinecraftReflection.getItemStackClass())
+                                .returnTypeExact(void.class)
+                                .build()));
+            } else {
+                WRITE_ITEM_METHOD = Accessors.getMethodAccessor(FuzzyReflection
+                        .fromClass(MinecraftReflection.getPacketDataSerializerClass(), true)
+                        .getMethodByParameters("writeStack", MinecraftReflection.getItemStackClass()));
+            }
         }
 
         ByteBuf buf = Unpooled.buffer();
@@ -274,7 +313,12 @@ public class StreamSerializer {
 
         // Get the NMS version of the ItemStack and write it into the buffer
         Object nmsItem = MinecraftReflection.getMinecraftItemStack(stack);
-        WRITE_ITEM_METHOD.invoke(serializer, nmsItem);
+
+        if (MinecraftVersion.v1_21_0.atOrAbove()) {
+            WRITE_ITEM_METHOD.invoke(STREAM_CODEC.get(null), serializer, nmsItem);
+        } else {
+            WRITE_ITEM_METHOD.invoke(serializer, nmsItem);
+        }
 
         // write the serialized content to the stream
         output.write(this.getBytesAndRelease(buf));

src/main/java/com/comphenix/protocol/utility/Tuple.java

@@ -0,0 +1,3 @@
+package com.comphenix.protocol.utility;
+
+public record Tuple<A, B>(A first, B second) {}

src/main/java/com/comphenix/protocol/utility/ZeroBuffer.java

@@ -2,12 +2,14 @@ package com.comphenix.protocol.utility;
 
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.ByteBufAllocator;
-import io.netty.buffer.ByteBufProcessor;
+import io.netty.util.ByteProcessor;
+
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
+import java.nio.channels.FileChannel;
 import java.nio.channels.GatheringByteChannel;
 import java.nio.channels.ScatteringByteChannel;
 import java.nio.charset.Charset;
@@ -54,6 +56,16 @@ public class ZeroBuffer extends ByteBuf {
         return false;
     }
 
+    @Override
+    public boolean isReadOnly() {
+        return false;
+    }
+
+    @Override
+    public ByteBuf asReadOnly() {
+        return null;
+    }
+
     @Override
     public int readerIndex() {
         return 0;
@@ -179,36 +191,71 @@ public class ZeroBuffer extends ByteBuf {
         return 0;
     }
 
+    @Override
+    public short getShortLE(int i) {
+        return 0;
+    }
+
     @Override
     public int getUnsignedShort(int i) {
         return 0;
     }
 
+    @Override
+    public int getUnsignedShortLE(int i) {
+        return 0;
+    }
+
     @Override
     public int getMedium(int i) {
         return 0;
     }
 
+    @Override
+    public int getMediumLE(int i) {
+        return 0;
+    }
+
     @Override
     public int getUnsignedMedium(int i) {
         return 0;
     }
 
+    @Override
+    public int getUnsignedMediumLE(int i) {
+        return 0;
+    }
+
     @Override
     public int getInt(int i) {
         return 0;
     }
 
+    @Override
+    public int getIntLE(int i) {
+        return 0;
+    }
+
     @Override
     public long getUnsignedInt(int i) {
         return 0;
     }
 
+    @Override
+    public long getUnsignedIntLE(int i) {
+        return 0;
+    }
+
     @Override
     public long getLong(int i) {
         return 0;
     }
 
+    @Override
+    public long getLongLE(int i) {
+        return 0;
+    }
+
     @Override
     public char getChar(int i) {
         return 0;
@@ -264,6 +311,16 @@ public class ZeroBuffer extends ByteBuf {
         return 0;
     }
 
+    @Override
+    public int getBytes(int i, FileChannel fileChannel, long l, int i1) throws IOException {
+        return 0;
+    }
+
+    @Override
+    public CharSequence getCharSequence(int i, int i1, Charset charset) {
+        return "";
+    }
+
     @Override
     public ByteBuf setBoolean(int i, boolean b) {
         return null;
@@ -279,21 +336,41 @@ public class ZeroBuffer extends ByteBuf {
         return null;
     }
 
+    @Override
+    public ByteBuf setShortLE(int i, int i1) {
+        return null;
+    }
+
     @Override
     public ByteBuf setMedium(int i, int i1) {
         return null;
     }
 
+    @Override
+    public ByteBuf setMediumLE(int i, int i1) {
+        return null;
+    }
+
     @Override
     public ByteBuf setInt(int i, int i1) {
         return null;
     }
 
+    @Override
+    public ByteBuf setIntLE(int i, int i1) {
+        return null;
+    }
+
     @Override
     public ByteBuf setLong(int i, long l) {
         return null;
     }
 
+    @Override
+    public ByteBuf setLongLE(int i, long l) {
+        return null;
+    }
+
     @Override
     public ByteBuf setChar(int i, int i1) {
         return null;
@@ -349,11 +426,21 @@ public class ZeroBuffer extends ByteBuf {
         return 0;
     }
 
+    @Override
+    public int setBytes(int i, FileChannel fileChannel, long l, int i1) {
+        return 0;
+    }
+
     @Override
     public ByteBuf setZero(int i, int i1) {
         return null;
     }
 
+    @Override
+    public int setCharSequence(int i, CharSequence charSequence, Charset charset) {
+        return 0;
+    }
+
     @Override
     public boolean readBoolean() {
         return false;
@@ -374,36 +461,71 @@ public class ZeroBuffer extends ByteBuf {
         return 0;
     }
 
+    @Override
+    public short readShortLE() {
+        return 0;
+    }
+
     @Override
     public int readUnsignedShort() {
         return 0;
     }
 
+    @Override
+    public int readUnsignedShortLE() {
+        return 0;
+    }
+
     @Override
     public int readMedium() {
         return 0;
     }
 
+    @Override
+    public int readMediumLE() {
+        return 0;
+    }
+
     @Override
     public int readUnsignedMedium() {
         return 0;
     }
 
+    @Override
+    public int readUnsignedMediumLE() {
+        return 0;
+    }
+
     @Override
     public int readInt() {
         return 0;
     }
 
+    @Override
+    public int readIntLE() {
+        return 0;
+    }
+
     @Override
     public long readUnsignedInt() {
         return 0;
     }
 
+    @Override
+    public long readUnsignedIntLE() {
+        return 0;
+    }
+
     @Override
     public long readLong() {
         return 0;
     }
 
+    @Override
+    public long readLongLE() {
+        return 0;
+    }
+
     @Override
     public char readChar() {
         return 0;
@@ -429,6 +551,11 @@ public class ZeroBuffer extends ByteBuf {
         return null;
     }
 
+    @Override
+    public ByteBuf readRetainedSlice(int i) {
+        return null;
+    }
+
     @Override
     public ByteBuf readBytes(ByteBuf byteBuf) {
         return null;
@@ -469,6 +596,16 @@ public class ZeroBuffer extends ByteBuf {
         return 0;
     }
 
+    @Override
+    public CharSequence readCharSequence(int i, Charset charset) {
+        return "";
+    }
+
+    @Override
+    public int readBytes(FileChannel fileChannel, long l, int i) {
+        return 0;
+    }
+
     @Override
     public ByteBuf skipBytes(int i) {
         return null;
@@ -489,21 +626,41 @@ public class ZeroBuffer extends ByteBuf {
         return null;
     }
 
+    @Override
+    public ByteBuf writeShortLE(int i) {
+        return null;
+    }
+
     @Override
     public ByteBuf writeMedium(int i) {
         return null;
     }
 
+    @Override
+    public ByteBuf writeMediumLE(int i) {
+        return null;
+    }
+
     @Override
     public ByteBuf writeInt(int i) {
         return null;
     }
 
+    @Override
+    public ByteBuf writeIntLE(int i) {
+        return null;
+    }
+
     @Override
     public ByteBuf writeLong(long l) {
         return null;
     }
 
+    @Override
+    public ByteBuf writeLongLE(long l) {
+        return null;
+    }
+
     @Override
     public ByteBuf writeChar(int i) {
         return null;
@@ -559,11 +716,21 @@ public class ZeroBuffer extends ByteBuf {
         return 0;
     }
 
+    @Override
+    public int writeBytes(FileChannel fileChannel, long l, int i) {
+        return 0;
+    }
+
     @Override
     public ByteBuf writeZero(int i) {
         return null;
     }
 
+    @Override
+    public int writeCharSequence(CharSequence charSequence, Charset charset) {
+        return 0;
+    }
+
     @Override
     public int indexOf(int i, int i1, byte b) {
         return 0;
@@ -585,22 +752,22 @@ public class ZeroBuffer extends ByteBuf {
     }
 
     @Override
-    public int forEachByte(ByteBufProcessor byteBufProcessor) {
+    public int forEachByte(ByteProcessor byteProcessor) {
         return 0;
     }
 
     @Override
-    public int forEachByte(int i, int i1, ByteBufProcessor byteBufProcessor) {
+    public int forEachByte(int i, int i1, ByteProcessor byteProcessor) {
         return 0;
     }
 
     @Override
-    public int forEachByteDesc(ByteBufProcessor byteBufProcessor) {
+    public int forEachByteDesc(ByteProcessor byteProcessor) {
         return 0;
     }
 
     @Override
-    public int forEachByteDesc(int i, int i1, ByteBufProcessor byteBufProcessor) {
+    public int forEachByteDesc(int i, int i1, ByteProcessor byteProcessor) {
         return 0;
     }
 
@@ -619,16 +786,31 @@ public class ZeroBuffer extends ByteBuf {
         return null;
     }
 
+    @Override
+    public ByteBuf retainedSlice() {
+        return null;
+    }
+
     @Override
     public ByteBuf slice(int i, int i1) {
         return null;
     }
 
+    @Override
+    public ByteBuf retainedSlice(int i, int i1) {
+        return null;
+    }
+
     @Override
     public ByteBuf duplicate() {
         return null;
     }
 
+    @Override
+    public ByteBuf retainedDuplicate() {
+        return null;
+    }
+
     @Override
     public int nioBufferCount() {
         return 0;
@@ -738,4 +920,14 @@ public class ZeroBuffer extends ByteBuf {
     public ByteBuf retain() {
         return null;
     }
+
+    @Override
+    public ByteBuf touch() {
+        return null;
+    }
+
+    @Override
+    public ByteBuf touch(Object o) {
+        return null;
+    }
 }

src/main/java/com/comphenix/protocol/wrappers/AutoWrapper.java

@@ -22,6 +22,7 @@ import com.comphenix.protocol.reflect.accessors.FieldAccessor;
 import com.google.common.base.Defaults;
 import com.google.common.base.Preconditions;
 
+import java.lang.reflect.Constructor;
 import java.lang.reflect.Modifier;
 import java.util.Arrays;
 import java.util.HashMap;
@@ -165,16 +166,67 @@ public class AutoWrapper<T> implements EquivalentConverter<T> {
                 nmsInstanceCreator = noArgs;
                 nmsDefaultArgs = NO_ARGS;
             } else {
-                // use the first constructor of the class
-                nmsInstanceCreator = Accessors.getConstructorAccessor(nmsClass.getDeclaredConstructors()[0]);
-                nmsDefaultArgs = Arrays
-                        .stream(nmsInstanceCreator.getConstructor().getParameterTypes())
-                        .map(type -> type.isPrimitive() ? Defaults.defaultValue(type) : null)
-                        .toArray(Object[]::new);
+                // No no-arg constructor. For records (and most NMS data classes) the canonical
+                // constructor has one parameter per non-static field; that's the one we want.
+                // Other constructors (e.g. FriendlyByteBuf decoders) take a single network-buffer
+                // argument and would call methods on it during construction, so they're unsafe to
+                // invoke with default values.
+                Constructor<?>[] ctors = nmsClass.getDeclaredConstructors();
+                Constructor<?> chosen = selectConstructor(ctors);
+                nmsInstanceCreator = Accessors.getConstructorAccessor(chosen);
+                Class<?>[] paramTypes = chosen.getParameterTypes();
+                nmsDefaultArgs = new Object[paramTypes.length];
+                for (int i = 0; i < paramTypes.length; i++) {
+                    nmsDefaultArgs[i] = paramTypes[i].isPrimitive()
+                            ? Defaults.defaultValue(paramTypes[i])
+                            : null;
+                }
             }
         }
     }
 
+    private Constructor<?> selectConstructor(Constructor<?>[] ctors) {
+        Constructor<?> fallback = null;
+        for (Constructor<?> ctor : ctors) {
+            if (isNetworkBufferConstructor(ctor)) {
+                continue;
+            }
+
+            if (ctor.getParameterCount() == nmsAccessors.length) {
+                return ctor;
+            }
+
+            if (fallback == null || ctor.getParameterCount() > fallback.getParameterCount()) {
+                fallback = ctor;
+            }
+        }
+
+        if (fallback != null) {
+            return fallback;
+        }
+
+        throw new InvalidWrapperException(nmsClass.getSimpleName()
+                + " has no safe constructor for default instantiation", null);
+    }
+
+    private boolean isNetworkBufferConstructor(Constructor<?> ctor) {
+        Class<?> packetDataSerializer = MinecraftReflection.getPacketDataSerializerClass();
+        Class<?> registryByteBuf = MinecraftReflection.getRegistryFriendlyByteBufClass().orElse(null);
+        for (Class<?> param : ctor.getParameterTypes()) {
+            // Only treat the parameter as a network buffer if it's the buffer type itself or a subtype.
+            // Using the reverse direction (param.isAssignableFrom(...)) would also exclude legitimate
+            // ctors taking ByteBuf / Object / etc. as record components.
+            if (packetDataSerializer.isAssignableFrom(param)) {
+                return true;
+            }
+
+            if (registryByteBuf != null && registryByteBuf.isAssignableFrom(param)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
     // ---- Equivalent conversion
 
     @Override

src/main/java/com/comphenix/protocol/wrappers/BukkitConverters.java

@@ -70,6 +70,7 @@ import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Lists;
 import org.bukkit.Bukkit;
 import org.bukkit.Material;
+import org.bukkit.NamespacedKey;
 import org.bukkit.Sound;
 import org.bukkit.World;
 import org.bukkit.WorldType;
@@ -873,6 +874,13 @@ public class BukkitConverters {
         return ignoreNull(new EquivalentConverter<EntityType>() {
             @Override
             public Object getGeneric(EntityType specific) {
+                if (MinecraftVersion.v26_2.atOrAbove()) {
+                    // EntityType.byString was removed in 26.2, resolve through the registry instead
+                    WrappedRegistry registry = WrappedRegistry.getRegistry(MinecraftReflection.getEntityTypes());
+                    NamespacedKey key = specific.getKey();
+                    return registry.get(new MinecraftKey(key.getNamespace(), key.getKey()));
+                }
+
                 if (entityTypeFromName == null) {
                     Class<?> entityTypesClass = MinecraftReflection.getEntityTypes();
                     entityTypeFromName = Accessors.getMethodAccessor(
@@ -1428,6 +1436,67 @@ public class BukkitConverters {
         });
     }
 
+    // Lazily-resolved CraftDamageType reflection. volatile + DCL keeps the publish safe
+    // and avoids re-running fuzzy lookups in concurrent injection paths.
+    private static volatile MethodAccessor damageTypeToNms = null;
+    private static volatile MethodAccessor damageTypeFromNms = null;
+
+    private static FuzzyReflection craftDamageTypeFuzzy() {
+        return FuzzyReflection.fromClass(getCraftBukkitClass("damage.CraftDamageType"), false);
+    }
+
+    private static MethodAccessor resolveDamageTypeToNms() {
+        MethodAccessor accessor = damageTypeToNms;
+        if (accessor != null) return accessor;
+        synchronized (BukkitConverters.class) {
+            accessor = damageTypeToNms;
+            if (accessor != null) return accessor;
+            accessor = Accessors.getMethodAccessor(craftDamageTypeFuzzy().getMethod(FuzzyMethodContract.newBuilder()
+                    .parameterExactArray(org.bukkit.damage.DamageType.class)
+                    .returnTypeExact(MinecraftReflection.getDamageTypeClass())
+                    .requireModifier(Modifier.STATIC)
+                    .build()));
+            damageTypeToNms = accessor;
+            return accessor;
+        }
+    }
+
+    private static MethodAccessor resolveDamageTypeFromNms() {
+        MethodAccessor accessor = damageTypeFromNms;
+        if (accessor != null) return accessor;
+        synchronized (BukkitConverters.class) {
+            accessor = damageTypeFromNms;
+            if (accessor != null) return accessor;
+            accessor = Accessors.getMethodAccessor(craftDamageTypeFuzzy().getMethod(FuzzyMethodContract.newBuilder()
+                    .parameterExactArray(MinecraftReflection.getDamageTypeClass())
+                    .returnTypeExact(org.bukkit.damage.DamageType.class)
+                    .requireModifier(Modifier.STATIC)
+                    .build()));
+            damageTypeFromNms = accessor;
+            return accessor;
+        }
+    }
+
+    public static EquivalentConverter<org.bukkit.damage.DamageType> getDamageTypeConverter() {
+        return ignoreNull(new EquivalentConverter<org.bukkit.damage.DamageType>() {
+
+            @Override
+            public Class<org.bukkit.damage.DamageType> getSpecificType() {
+                return org.bukkit.damage.DamageType.class;
+            }
+
+            @Override
+            public Object getGeneric(org.bukkit.damage.DamageType specific) {
+                return resolveDamageTypeToNms().invoke(null, specific);
+            }
+
+            @Override
+            public org.bukkit.damage.DamageType getSpecific(Object generic) {
+                return (org.bukkit.damage.DamageType) resolveDamageTypeFromNms().invoke(null, generic);
+            }
+        });
+    }
+
     private static Class<?> dimensionManager;
     private static FauxEnumConverter<Dimension> dimensionConverter;
     private static FauxEnumConverter<DimensionImpl> dimensionImplConverter;

src/main/java/com/comphenix/protocol/wrappers/CustomPacketPayloadWrapper.java

@@ -46,8 +46,13 @@ public final class CustomPacketPayloadWrapper {
     private static final ConstructorAccessor PAYLOAD_WRAPPER_CONSTRUCTOR;
 
     private static final MethodAccessor GET_ID_PAYLOAD_METHOD;
+    private static final MethodAccessor GET_TYPE_PAYLOAD_METHOD;
+    private static final MethodAccessor GET_ID_PAYLOAD_TYPE_METHOD;
     private static final MethodAccessor SERIALIZE_PAYLOAD_METHOD;
 
+    /** True when running on MC 1.21.5+ where DiscardedPayload is used instead of the ByteBuddy proxy. */
+    private static final boolean USE_DISCARDED_PAYLOAD;
+
     private static final EquivalentConverter<CustomPacketPayloadWrapper> CONVERTER;
 
     static {
@@ -55,22 +60,54 @@ public final class CustomPacketPayloadWrapper {
             MINECRAFT_KEY_CLASS = MinecraftReflection.getMinecraftKeyClass();
             CUSTOM_PACKET_PAYLOAD_CLASS = MinecraftReflection.getMinecraftClass("network.protocol.common.custom.CustomPacketPayload");
 
-            Method getPayloadId = FuzzyReflection.fromClass(CUSTOM_PACKET_PAYLOAD_CLASS).getMethod(FuzzyMethodContract.newBuilder()
-                    .banModifier(Modifier.STATIC)
-                    .returnTypeExact(MINECRAFT_KEY_CLASS)
-                    .parameterCount(0)
-                    .build());
-            GET_ID_PAYLOAD_METHOD = Accessors.getMethodAccessor(getPayloadId);
+            // MC 1.21.5+: CustomPacketPayload no longer has id(); DiscardedPayload is the fallback payload
+            // MC < 1.21.5: CustomPacketPayload.id() returns Identifier directly
+            Method getPayloadId = null;
+            Method getPayloadType = null;
+            Method getPayloadTypeId = null;
+            boolean useDiscardedPayload = false;
+            try {
+                getPayloadId = FuzzyReflection.fromClass(CUSTOM_PACKET_PAYLOAD_CLASS).getMethod(FuzzyMethodContract.newBuilder()
+                        .banModifier(Modifier.STATIC)
+                        .returnTypeExact(MINECRAFT_KEY_CLASS)
+                        .parameterCount(0)
+                        .build());
+            } catch (IllegalArgumentException ignored) {
+                // New API: CustomPacketPayload.type().id() exposes the identifier for every payload type.
+                getPayloadType = CUSTOM_PACKET_PAYLOAD_CLASS.getMethod("type");
+                getPayloadTypeId = getPayloadType.getReturnType().getMethod("id");
+                useDiscardedPayload = true;
+            }
+            GET_ID_PAYLOAD_METHOD = getPayloadId != null ? Accessors.getMethodAccessor(getPayloadId) : null;
+            GET_TYPE_PAYLOAD_METHOD = getPayloadType != null ? Accessors.getMethodAccessor(getPayloadType) : null;
+            GET_ID_PAYLOAD_TYPE_METHOD = getPayloadTypeId != null ? Accessors.getMethodAccessor(getPayloadTypeId) : null;
+            USE_DISCARDED_PAYLOAD = useDiscardedPayload;
 
-            Method serializePayloadData = FuzzyReflection.fromClass(CUSTOM_PACKET_PAYLOAD_CLASS).getMethod(FuzzyMethodContract.newBuilder()
-                    .banModifier(Modifier.STATIC)
-                    .returnTypeVoid()
-                    .parameterCount(1)
-                    .parameterDerivedOf(ByteBuf.class, 0)
-                    .build());
-            SERIALIZE_PAYLOAD_METHOD = Accessors.getMethodAccessor(serializePayloadData);
+            // serialize method may not exist in new API
+            Method serializePayloadData = null;
+            try {
+                serializePayloadData = FuzzyReflection.fromClass(CUSTOM_PACKET_PAYLOAD_CLASS).getMethod(FuzzyMethodContract.newBuilder()
+                        .banModifier(Modifier.STATIC)
+                        .returnTypeVoid()
+                        .parameterCount(1)
+                        .parameterDerivedOf(ByteBuf.class, 0)
+                        .build());
+            } catch (IllegalArgumentException ignored) {
+                // Not present in new API
+            }
+            SERIALIZE_PAYLOAD_METHOD = serializePayloadData != null
+                    ? Accessors.getMethodAccessor(serializePayloadData) : null;
 
-            Constructor<?> payloadWrapperConstructor = makePayloadWrapper();
+            Constructor<?> payloadWrapperConstructor;
+            if (useDiscardedPayload) {
+                // New API: use DiscardedPayload(Identifier, ByteBuf) as the payload handle
+                Class<?> discardedPayloadClass = MinecraftReflection.getMinecraftClass(
+                        "network.protocol.common.custom.DiscardedPayload");
+                payloadWrapperConstructor = discardedPayloadClass.getConstructor(
+                        MINECRAFT_KEY_CLASS, ByteBuf.class);
+            } else {
+                payloadWrapperConstructor = makePayloadWrapper();
+            }
             PAYLOAD_WRAPPER_CONSTRUCTOR = Accessors.getConstructorAccessor(payloadWrapperConstructor);
 
             CONVERTER = new EquivalentConverter<CustomPacketPayloadWrapper>() {
@@ -171,8 +208,7 @@ public final class CustomPacketPayloadWrapper {
      * @return a wrapper holding the minecraft key and payload of the given custom payload instance.
      */
     public static CustomPacketPayloadWrapper fromUnknownPayload(Object payload) {
-        Object messageId = GET_ID_PAYLOAD_METHOD.invoke(payload);
-        MinecraftKey id = MinecraftKey.getConverter().getSpecific(messageId);
+        MinecraftKey id = getPayloadId(payload);
 
         // we read and retain the underlying buffer in case the class uses a buffer to store the data
         // this way, when passing the packet to further handling, the buffer is not released and can be re-used
@@ -185,6 +221,12 @@ public final class CustomPacketPayloadWrapper {
                     return data;
                 })
                 .orElseGet(() -> {
+                    if (SERIALIZE_PAYLOAD_METHOD == null) {
+                        throw new UnsupportedOperationException(
+                                "Cannot extract raw custom payload bytes from " + payload.getClass().getName()
+                                        + ": payload has no ByteBuf field and this Minecraft version does not "
+                                        + "expose CustomPacketPayload serialization");
+                    }
                     ByteBuf buffer = Unpooled.buffer();
                     Object serializer = MinecraftReflection.getPacketDataSerializer(buffer);
                     SERIALIZE_PAYLOAD_METHOD.invoke(payload, serializer);
@@ -194,6 +236,17 @@ public final class CustomPacketPayloadWrapper {
         return new CustomPacketPayloadWrapper(messagePayload, id);
     }
 
+    private static MinecraftKey getPayloadId(Object payload) {
+        Object messageId;
+        if (GET_ID_PAYLOAD_METHOD != null) {
+            messageId = GET_ID_PAYLOAD_METHOD.invoke(payload);
+        } else {
+            Object payloadType = GET_TYPE_PAYLOAD_METHOD.invoke(payload);
+            messageId = GET_ID_PAYLOAD_TYPE_METHOD.invoke(payloadType);
+        }
+        return MinecraftKey.getConverter().getSpecific(messageId);
+    }
+
     /**
      * Get the generic id of the wrapped message id.
      *
@@ -230,6 +283,11 @@ public final class CustomPacketPayloadWrapper {
      * @return a new payload wrapper instance using the provided message id and payload.
      */
     public Object newHandle() {
+        if (USE_DISCARDED_PAYLOAD) {
+            // New API: DiscardedPayload(Identifier, ByteBuf)
+            ByteBuf buf = Unpooled.copiedBuffer(this.payload);
+            return PAYLOAD_WRAPPER_CONSTRUCTOR.invoke(this.getGenericId(), buf);
+        }
         return PAYLOAD_WRAPPER_CONSTRUCTOR.invoke(this.getGenericId(), this.payload);
     }
 

src/main/java/com/comphenix/protocol/wrappers/EnumWrappers.java

@@ -36,6 +36,12 @@ public abstract class EnumWrappers {
     public enum ClientCommand {
         PERFORM_RESPAWN,
         REQUEST_STATS,
+        REQUEST_GAMERULE_VALUES,
+
+        /**
+         * @deprecated Removed in 26.1
+         */
+        @Deprecated
         OPEN_INVENTORY_ACHIEVEMENT
     }
 
@@ -140,6 +146,8 @@ public abstract class EnumWrappers {
         UPDATE_LISTED,
         UPDATE_LATENCY,
         UPDATE_DISPLAY_NAME,
+        UPDATE_LIST_ORDER,
+        UPDATE_HAT,
         /**
          * @deprecated Removed in 1.19.3
          */
@@ -178,7 +186,8 @@ public abstract class EnumWrappers {
         DROP_ALL_ITEMS,
         DROP_ITEM,
         RELEASE_USE_ITEM,
-        SWAP_HELD_ITEMS("SWAP_ITEM_WITH_OFFHAND");
+        SWAP_HELD_ITEMS("SWAP_ITEM_WITH_OFFHAND"),
+        STAB;
 
         final String[] aliases;
         PlayerDigType(String... aliases) {
@@ -191,8 +200,18 @@ public abstract class EnumWrappers {
     }
 
     public enum PlayerAction implements AliasedEnum {
+        /**
+         * @deprecated Removed in 1.21.6
+         */
+        @Deprecated
         START_SNEAKING("PRESS_SHIFT_KEY"),
+
+        /**
+         * @deprecated Removed in 1.21.6
+         */
+        @Deprecated
         STOP_SNEAKING("RELEASE_SHIFT_KEY"),
+
         STOP_SLEEPING,
         START_SPRINTING,
         STOP_SPRINTING,
@@ -332,7 +351,8 @@ public abstract class EnumWrappers {
         NEUTRAL("neutral"),
         PLAYERS("player"),
         AMBIENT("ambient"),
-        VOICE("voice");
+        VOICE("voice"),
+        UI("ui");
 
         private static final Map<String, SoundCategory> LOOKUP;
         static {
@@ -364,7 +384,8 @@ public abstract class EnumWrappers {
         LEGS,
         CHEST,
         HEAD,
-        BODY
+        BODY,
+        SADDLE
     }
 
     public enum Hand {
@@ -638,6 +659,76 @@ public abstract class EnumWrappers {
         TRANSFER;
     }
 
+    public enum TeamCollisionRule {
+
+        ALWAYS("always"),
+        NEVER("never"),
+        PUSH_OTHER_TEAMS("pushOtherTeams"),
+        PUSH_OWN_TEAM("pushOwnTeam");
+
+        public static TeamCollisionRule fromName(String name) {
+            for (TeamCollisionRule value : values()) {
+                if (value.name.equals(name)) {
+                    return value;
+                }
+            }
+            throw new IllegalArgumentException("Unknown team collision rule: " + name);
+        }
+
+        private final String name;
+
+        TeamCollisionRule(String name) {
+            this.name = name;
+        }
+
+        @Override
+        public String toString() {
+            return name;
+        }
+    }
+
+    public enum TeamVisibility {
+
+        ALWAYS("always"),
+        NEVER("never"),
+        HIDE_FOR_OTHER_TEAMS("hideForOtherTeams"),
+        HIDE_FOR_OWN_TEAM("hideForOwnTeam");
+
+        public static TeamVisibility fromName(String name) {
+            for (TeamVisibility value : values()) {
+                if (value.name.equals(name)) {
+                    return value;
+                }
+            }
+            throw new IllegalArgumentException("Unknown team visibility: " + name);
+        }
+
+        private final String name;
+
+        TeamVisibility(String name) {
+            this.name = name;
+        }
+
+        @Override
+        public String toString() {
+            return name;
+        }
+    }
+
+    public enum HeightmapType {
+        WORLD_SURFACE_WG,
+        WORLD_SURFACE,
+        OCEAN_FLOOR_WG,
+        OCEAN_FLOOR,
+        MOTION_BLOCKING,
+        MOTION_BLOCKING_NO_LEAVES,
+    }
+
+    public enum RelativeArgument {
+        // Order must match the NMS Relative enum exactly.
+        X, Y, Z, Y_ROT, X_ROT, DELTA_X, DELTA_Y, DELTA_Z, ROTATE_DELTA
+    }
+
     private static Class<?> PROTOCOL_CLASS = null;
     private static Class<?> CLIENT_COMMAND_CLASS = null;
     private static Class<?> CHAT_VISIBILITY_CLASS = null;
@@ -663,6 +754,10 @@ public abstract class EnumWrappers {
     private static Class<?> RENDER_TYPE_CLASS = null;
     private static Class<?> CHAT_FORMATTING_CLASS = null;
     private static Class<?> CLIENT_INTENT_CLASS = null;
+    private static Class<?> TEAM_COLLISION_RULE_CLASS = null;
+    private static Class<?> TEAM_VISIBILITY_CLASS = null;
+    private static Class<?> HEIGHTMAP_TYPE_CLASS = null;
+    private static Class<?> RELATIVE_CLASS = null;
 
     private static boolean INITIALIZING = false;
     private static boolean INITIALIZED = false;
@@ -723,7 +818,7 @@ public abstract class EnumWrappers {
             }
 
             try {
-                SOUND_CATEGORY_CLASS = MinecraftReflection.getMinecraftClass("sounds.SoundCategory");
+                SOUND_CATEGORY_CLASS = MinecraftReflection.getMinecraftClass("sounds.SoundCategory", "sounds.SoundSource");
             } catch (Exception ex) {
                 SOUND_CATEGORY_CLASS = getEnum(PacketType.Play.Server.NAMED_SOUND_EFFECT.getPacketClass(), 0);
             }
@@ -739,13 +834,17 @@ public abstract class EnumWrappers {
             if (MinecraftVersion.CAVES_CLIFFS_1.atOrAbove()) {
                 HAND_CLASS = MinecraftReflection.getMinecraftClass("world.EnumHand", "world.InteractionHand");
 
-                FuzzyReflection fuzzy = FuzzyReflection.fromClass(MinecraftReflection.getEnumEntityUseActionClass(), true);
-                Method getType = fuzzy.getMethod(FuzzyMethodContract.newBuilder()
-                    .parameterCount(0)
-                    .returnTypeMatches(FuzzyMatchers.except(Void.class))
-                    .build());
+                if (MinecraftVersion.v26_1.atOrAbove()) {
+                    // TODO
+                } else {
+                    FuzzyReflection fuzzy = FuzzyReflection.fromClass(MinecraftReflection.getEnumEntityUseActionClass(), true);
+                    Method getType = fuzzy.getMethod(FuzzyMethodContract.newBuilder()
+                            .parameterCount(0)
+                            .returnTypeMatches(FuzzyMatchers.except(Void.class))
+                            .build());
 
-                ENTITY_USE_ACTION_CLASS = getType.getReturnType();
+                    ENTITY_USE_ACTION_CLASS = getType.getReturnType();
+                }
             } else {
                 HAND_CLASS = getEnum(PacketType.Play.Client.USE_ENTITY.getPacketClass(), 1);
                 ENTITY_USE_ACTION_CLASS = getEnum(PacketType.Play.Client.USE_ENTITY.getPacketClass(), 0);
@@ -770,6 +869,19 @@ public abstract class EnumWrappers {
 
             CLIENT_INTENT_CLASS = getEnum(PacketType.Handshake.Client.SET_PROTOCOL.getPacketClass(), 0);
 
+            TEAM_COLLISION_RULE_CLASS = MinecraftReflection.getNullableNMS(
+                    "world.scores.ScoreboardTeamBase$EnumTeamPush" /* Spigot Mapping */,
+                    "world.scores.Team$CollisionRule" /* Mojang Mapping */);
+            TEAM_VISIBILITY_CLASS = MinecraftReflection.getNullableNMS(
+                    "world.scores.ScoreboardTeamBase$EnumNameTagVisibility" /* Spigot Mapping */,
+                    "world.scores.Team$Visibility" /* Mojang Mapping */);
+
+            HEIGHTMAP_TYPE_CLASS = MinecraftReflection.getNullableNMS(
+                    "world.level.levelgen.HeightMap$Type" /* Spigot Mapping */,
+                    "world.level.levelgen.Heightmap$Types" /* Mojang Mapping */);
+
+            RELATIVE_CLASS = MinecraftReflection.getMinecraftClass("world.entity.Relative");
+
             associate(PROTOCOL_CLASS, Protocol.class, getProtocolConverter());
             associate(CLIENT_COMMAND_CLASS, ClientCommand.class, getClientCommandConverter());
             associate(CHAT_VISIBILITY_CLASS, ChatVisibility.class, getChatVisibilityConverter());
@@ -794,6 +906,10 @@ public abstract class EnumWrappers {
             associate(RENDER_TYPE_CLASS, RenderType.class, getRenderTypeConverter());
             associate(CHAT_FORMATTING_CLASS, ChatFormatting.class, getChatFormattingConverter());
             associate(CLIENT_INTENT_CLASS, ClientIntent.class, getClientIntentConverter());
+            associate(TEAM_COLLISION_RULE_CLASS, TeamCollisionRule.class, getTeamCollisionRuleConverter());
+            associate(TEAM_VISIBILITY_CLASS, TeamVisibility.class, getTeamVisibilityConverter());
+            associate(HEIGHTMAP_TYPE_CLASS, HeightmapType.class, getHeightmapTypeConverter());
+            associate(RELATIVE_CLASS, RelativeArgument.class, getRelativeArgumentConverter());
 
             if (ENTITY_POSE_CLASS != null) {
                 associate(ENTITY_POSE_CLASS, EntityPose.class, getEntityPoseConverter());
@@ -968,6 +1084,26 @@ public abstract class EnumWrappers {
         return CLIENT_INTENT_CLASS;
     }
 
+    public static Class<?> getTeamCollisionRuleClass() {
+        initialize();
+        return TEAM_COLLISION_RULE_CLASS;
+    }
+
+    public static Class<?> getTeamVisibilityClass() {
+        initialize();
+        return TEAM_VISIBILITY_CLASS;
+    }
+
+    public static Class<?> getHeightmapTypeClass() {
+        initialize();
+        return HEIGHTMAP_TYPE_CLASS;
+    }
+
+    public static Class<?> getRelativeArgumentClass() {
+        initialize();
+        return RELATIVE_CLASS;
+    }
+
     // Get the converters
     public static EquivalentConverter<Protocol> getProtocolConverter() {
         return new EnumConverter<>(getProtocolClass(), Protocol.class);
@@ -1065,6 +1201,22 @@ public abstract class EnumWrappers {
         return new EnumConverter<>(getClientIntentClass(), ClientIntent.class);
     }
 
+    public static EquivalentConverter<TeamCollisionRule> getTeamCollisionRuleConverter() {
+        return new EnumConverter<>(getTeamCollisionRuleClass(), TeamCollisionRule.class);
+    }
+
+    public static EquivalentConverter<TeamVisibility> getTeamVisibilityConverter() {
+        return new EnumConverter<>(getTeamVisibilityClass(), TeamVisibility.class);
+    }
+
+    public static EquivalentConverter<HeightmapType> getHeightmapTypeConverter() {
+        return new EnumConverter<>(getHeightmapTypeClass(), HeightmapType.class);
+    }
+
+    public static EquivalentConverter<RelativeArgument> getRelativeArgumentConverter() {
+        return new EnumConverter<>(getRelativeArgumentClass(), RelativeArgument.class);
+    }
+
     /**
      * @since 1.13+
      * @return {@link EnumConverter} or null (if bellow 1.13 / nms EnumPose class cannot be found)

src/main/java/com/comphenix/protocol/wrappers/MutablePropertyMap.java

@@ -0,0 +1,29 @@
+package com.comphenix.protocol.wrappers;
+
+import com.google.common.collect.HashMultimap;
+import com.google.common.collect.ImmutableMultimap;
+import com.google.common.collect.Multimap;
+import com.mojang.authlib.properties.Property;
+import com.mojang.authlib.properties.PropertyMap;
+
+/**
+ * Mutable version of PropertyMap
+ * Credit to PaperMC: https://github.com/PaperMC/Paper/blob/main/paper-server/src/main/java/io/papermc/paper/profile/MutablePropertyMap.java
+ */
+public class MutablePropertyMap extends PropertyMap {
+    private final Multimap<String, Property> properties = HashMultimap.create();
+
+    public MutablePropertyMap() {
+        super(ImmutableMultimap.of());
+    }
+
+    public MutablePropertyMap(final Multimap<String, Property> properties) {
+        this();
+        this.putAll(properties);
+    }
+
+    @Override
+    protected Multimap<String, Property> delegate() {
+        return this.properties;
+    }
+}

src/main/java/com/comphenix/protocol/wrappers/PlayerInfoData.java

@@ -16,12 +16,12 @@
  */
 package com.comphenix.protocol.wrappers;
 
-import com.comphenix.protocol.wrappers.WrappedProfilePublicKey.WrappedProfileKeyData;
 import java.lang.reflect.Constructor;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
 import java.util.UUID;
+import javax.annotation.Nullable;
 
 import com.comphenix.protocol.PacketType;
 import com.comphenix.protocol.reflect.EquivalentConverter;
@@ -29,8 +29,7 @@ import com.comphenix.protocol.reflect.StructureModifier;
 import com.comphenix.protocol.utility.MinecraftReflection;
 import com.comphenix.protocol.utility.MinecraftVersion;
 import com.comphenix.protocol.wrappers.EnumWrappers.NativeGameMode;
-
-import javax.annotation.Nullable;
+import com.comphenix.protocol.wrappers.WrappedProfilePublicKey.WrappedProfileKeyData;
 
 /**
  * Represents an immutable PlayerInfoData in the PLAYER_INFO packet.
@@ -41,7 +40,9 @@ public class PlayerInfoData {
 
     private final UUID profileId;
     private final int latency;
+    private final int listOrder;
     private final boolean listed;
+    private final boolean showHat;
     private final NativeGameMode gameMode;
     private final WrappedGameProfile profile;
     private final WrappedChatComponent displayName;
@@ -74,6 +75,21 @@ public class PlayerInfoData {
         this(profileId, latency, listed, gameMode, profile, displayName, (WrappedRemoteChatSessionData) null);
     }
 
+    /**
+     * Constructs a new PlayerInfoData for Minecraft 1.19.3 or later.
+     *
+     * @param profileId the id of the profile (has to be non-null)
+     * @param latency the latency in milliseconds
+     * @param listed whether the player is listed in the tab list
+     * @param gameMode the game mode
+     * @param profile the game profile
+     * @param displayName display name in tab list (optional)
+     * @param remoteChatSession the remote chat session for this profile or null
+     */
+    public PlayerInfoData(UUID profileId, int latency, boolean listed, NativeGameMode gameMode, WrappedGameProfile profile, WrappedChatComponent displayName, @Nullable WrappedRemoteChatSessionData remoteChatSession) {
+        this(profileId, latency, listed, gameMode, profile, displayName, false, remoteChatSession);
+    }
+
     /**
      * Constructs a new PlayerInfoData for Minecraft 1.19. This is incompatible on 1.19.3.
      * @see PlayerInfoData#PlayerInfoData(UUID, int, boolean, NativeGameMode, WrappedGameProfile, WrappedChatComponent, WrappedRemoteChatSessionData)
@@ -96,10 +112,12 @@ public class PlayerInfoData {
         this.displayName = displayName;
         this.profileKeyData = profileKeyData;
         this.remoteChatSessionData = null;
+        this.showHat = false;
+        this.listOrder = 0;
     }
 
     /**
-     * Constructs a new PlayerInfoData for Minecraft 1.19.3 or later.
+     * Constructs a new PlayerInfoData for Minecraft 1.21.2 or later.
      *
      * @param profileId the id of the profile (has to be non-null)
      * @param latency the latency in milliseconds
@@ -107,9 +125,43 @@ public class PlayerInfoData {
      * @param gameMode the game mode
      * @param profile the game profile
      * @param displayName display name in tab list (optional)
+     * @param listOrder the priority of this entry in the tab list
      * @param remoteChatSession the remote chat session for this profile or null
      */
-    public PlayerInfoData(UUID profileId, int latency, boolean listed, NativeGameMode gameMode, WrappedGameProfile profile, WrappedChatComponent displayName, @Nullable WrappedRemoteChatSessionData remoteChatSession) {
+    public PlayerInfoData(UUID profileId, int latency, boolean listed, NativeGameMode gameMode, WrappedGameProfile profile, WrappedChatComponent displayName, int listOrder, @Nullable WrappedRemoteChatSessionData remoteChatSession) {
+        this(profileId, latency, listed, gameMode, profile, displayName, false, listOrder, remoteChatSession);
+    }
+
+    /**
+     * Constructs a new PlayerInfoData for Minecraft 1.21.4 or later.
+     *
+     * @param profileId the id of the profile (has to be non-null)
+     * @param latency the latency in milliseconds
+     * @param listed whether the player is listed in the tab list
+     * @param gameMode the game mode
+     * @param profile the game profile
+     * @param displayName display name in tab list (optional)
+     * @param showHat whether a hat should be shown
+     * @param remoteChatSession the remote chat session for this profile or null
+     */
+    public PlayerInfoData(UUID profileId, int latency, boolean listed, NativeGameMode gameMode, WrappedGameProfile profile, WrappedChatComponent displayName, boolean showHat, @Nullable WrappedRemoteChatSessionData remoteChatSession) {
+        this(profileId, latency, listed, gameMode, profile, displayName, showHat, 0, remoteChatSession);
+    }
+
+    /**
+     * Constructs a new PlayerInfoData for Minecraft 1.21.4 or later.
+     *
+     * @param profileId the id of the profile (has to be non-null)
+     * @param latency the latency in milliseconds
+     * @param listed whether the player is listed in the tab list
+     * @param gameMode the game mode
+     * @param profile the game profile
+     * @param displayName display name in tab list (optional)
+     * @param showHat whether a hat should be shown
+     * @param listOrder the priority of this entry in the tab list
+     * @param remoteChatSession the remote chat session for this profile or null
+     */
+    public PlayerInfoData(UUID profileId, int latency, boolean listed, NativeGameMode gameMode, WrappedGameProfile profile, WrappedChatComponent displayName, boolean showHat, int listOrder, @Nullable WrappedRemoteChatSessionData remoteChatSession) {
         this.profileId = profileId;
         this.latency = latency;
         this.listed = listed;
@@ -118,6 +170,8 @@ public class PlayerInfoData {
         this.displayName = displayName;
         this.profileKeyData = null;
         this.remoteChatSessionData = remoteChatSession;
+        this.showHat = showHat;
+        this.listOrder = listOrder;
     }
 
     /**
@@ -179,6 +233,22 @@ public class PlayerInfoData {
         return displayName;
     }
 
+    /**
+     * Gets if a hat is shown (since 1.21.4)
+     * @return if the hat is shown
+     */
+    public boolean isShowHat() {
+        return showHat;
+    }
+
+    /**
+     * Gets the priority of this entry in the tab list (since 1.21.2)
+     * @return the priority of this entry in the tab list
+     */
+    public int getListOrder() {
+        return listOrder;
+    }
+
     /**
      * Returns the public key of the profile (since 1.19). Returns the public key of the remote chat session since 1.19.3
      * @return The public key of the profile.
@@ -202,7 +272,9 @@ public class PlayerInfoData {
      * @return A new converter.
      */
     public static EquivalentConverter<PlayerInfoData> getConverter() {
-        return new EquivalentConverter<PlayerInfoData>() {
+        return new EquivalentConverter<>() {
+            private static final Class<?>[] EMPTY_CLASS_ARRAY = new Class<?>[0];
+
             @Override
             public Object getGeneric(PlayerInfoData specific) {
                 if (constructor == null) {
@@ -225,13 +297,20 @@ public class PlayerInfoData {
                         args.add(EnumWrappers.getGameModeClass());
                         args.add(MinecraftReflection.getIChatBaseComponentClass());
 
+                        if (MinecraftVersion.v1_21_4.atOrAbove()) {
+                            args.add(boolean.class);
+                        }
+                        if (MinecraftVersion.v1_21_2.atOrAbove()) {
+                            args.add(int.class);
+                        }
+
                         if (MinecraftVersion.FEATURE_PREVIEW_UPDATE.atOrAbove()) {
                             args.add(MinecraftReflection.getRemoteChatSessionDataClass());
                         } else if (MinecraftVersion.WILD_UPDATE.atOrAbove()) {
                             args.add(MinecraftReflection.getProfilePublicKeyDataClass());
                         }
 
-                        constructor = MinecraftReflection.getPlayerInfoDataClass().getConstructor(args.toArray(new Class<?>[0]));
+                        constructor = MinecraftReflection.getPlayerInfoDataClass().getConstructor(args.toArray(EMPTY_CLASS_ARRAY));
                     } catch (Exception e) {
                         throw new RuntimeException("Cannot find PlayerInfoData constructor.", e);
                     }
@@ -240,32 +319,72 @@ public class PlayerInfoData {
                 // Attempt to construct the underlying PlayerInfoData
 
                 try {
-                    Object gameMode = EnumWrappers.getGameModeConverter().getGeneric(specific.gameMode);
+                    Object gameMode = Converters.ignoreNull(EnumWrappers.getGameModeConverter()).getGeneric(specific.gameMode);
                     Object displayName = specific.displayName != null ? specific.displayName.handle : null;
-
                     Object profile = specific.profile != null ? specific.profile.handle : null;
-                    if (MinecraftVersion.FEATURE_PREVIEW_UPDATE.atOrAbove()) {
-                        return constructor.newInstance(
-                                specific.profileId,
-                                profile,
-                                specific.listed,
-                                specific.latency,
-                                gameMode,
-                                displayName,
-                                specific.remoteChatSessionData != null ? BukkitConverters.getWrappedRemoteChatSessionDataConverter().getGeneric(specific.remoteChatSessionData) : null
-                        );
+                    Object remoteChatSessionData = specific.remoteChatSessionData != null ? BukkitConverters.getWrappedRemoteChatSessionDataConverter().getGeneric(specific.remoteChatSessionData) : null;
+
+                    Object[] args;
+
+                    if (MinecraftVersion.v1_21_4.atOrAbove()) {
+                        args = new Object[] {
+                            specific.profileId,
+                            profile,
+                            specific.listed,
+                            specific.latency,
+                            gameMode,
+                            displayName,
+                            specific.showHat,
+                            specific.listOrder,
+                            remoteChatSessionData
+                        };
+                    } else if (MinecraftVersion.v1_21_2.atOrAbove()) {
+                        args = new Object[] {
+                            specific.profileId,
+                            profile,
+                            specific.listed,
+                            specific.latency,
+                            gameMode,
+                            displayName,
+                            specific.listOrder,
+                            remoteChatSessionData
+                        };
+                    } else if (MinecraftVersion.FEATURE_PREVIEW_UPDATE.atOrAbove()) {
+                        args = new Object[] {
+                            specific.profileId,
+                            profile,
+                            specific.listed,
+                            specific.latency,
+                            gameMode,
+                            displayName,
+                            remoteChatSessionData
+                        };
                     } else if (MinecraftVersion.WILD_UPDATE.atOrAbove()) {
-                        return constructor.newInstance(
-                                profile,
-                                specific.latency,
-                                gameMode,
-                                displayName,
-                                specific.profileKeyData == null ? null : specific.profileKeyData.handle);
+                        args = new Object[] {
+                            profile,
+                            specific.latency,
+                            gameMode,
+                            displayName,
+                            specific.profileKeyData == null ? null : specific.profileKeyData.handle
+                        };
                     } else if (MinecraftVersion.CAVES_CLIFFS_1.atOrAbove()) {
-                        return constructor.newInstance(profile, specific.latency, gameMode, displayName);
+                        args = new Object[] {
+                            profile,
+                            specific.latency,
+                            gameMode,
+                            displayName
+                        };
                     } else {
-                        return constructor.newInstance(null, profile, specific.latency, gameMode, displayName);
+                        args = new Object[] {
+                            null,
+                            profile,
+                            specific.latency,
+                            gameMode,
+                            displayName
+                        };
                     }
+
+                    return constructor.newInstance(args);
                 } catch (Exception e) {
                     throw new RuntimeException("Failed to construct PlayerInfoData.", e);
                 }
@@ -275,37 +394,60 @@ public class PlayerInfoData {
             public PlayerInfoData getSpecific(Object generic) {
                 if (MinecraftReflection.isPlayerInfoData(generic)) {
                     StructureModifier<Object> modifier = new StructureModifier<>(generic.getClass(), null, false)
-                            .withTarget(generic);
+                        .withTarget(generic);
 
                     StructureModifier<WrappedGameProfile> gameProfiles = modifier.withType(
-                            MinecraftReflection.getGameProfileClass(), BukkitConverters.getWrappedGameProfileConverter());
+                        MinecraftReflection.getGameProfileClass(), BukkitConverters.getWrappedGameProfileConverter());
                     WrappedGameProfile gameProfile = gameProfiles.read(0);
 
                     StructureModifier<Integer> ints = modifier.withType(int.class);
                     int latency = ints.read(0);
 
                     StructureModifier<NativeGameMode> gameModes = modifier.withType(
-                            EnumWrappers.getGameModeClass(), EnumWrappers.getGameModeConverter());
+                        EnumWrappers.getGameModeClass(), Converters.ignoreNull(EnumWrappers.getGameModeConverter()));
                     NativeGameMode gameMode = gameModes.read(0);
 
                     StructureModifier<WrappedChatComponent> displayNames = modifier.withType(
-                            MinecraftReflection.getIChatBaseComponentClass(), BukkitConverters.getWrappedChatComponentConverter());
+                        MinecraftReflection.getIChatBaseComponentClass(), BukkitConverters.getWrappedChatComponentConverter());
                     WrappedChatComponent displayName = displayNames.read(0);
 
-                    if(MinecraftVersion.FEATURE_PREVIEW_UPDATE.atOrAbove()) {
+                    if (MinecraftVersion.v1_21_4.atOrAbove()) {
                         return new PlayerInfoData(modifier.<UUID>withType(UUID.class).read(0),
-                                latency,
-                                modifier.<Boolean>withType(boolean.class).read(0),
-                                gameMode,
-                                gameProfile,
-                                displayName,
-                                modifier.withType(MinecraftReflection.getRemoteChatSessionDataClass(), BukkitConverters.getWrappedRemoteChatSessionDataConverter()).read(0)
-                                );
+                            latency,
+                            modifier.<Boolean>withType(boolean.class).read(0),
+                            gameMode,
+                            gameProfile,
+                            displayName,
+                            modifier.<Boolean>withType(boolean.class).read(1),
+                            ints.read(1),
+                            modifier.withType(MinecraftReflection.getRemoteChatSessionDataClass(), BukkitConverters.getWrappedRemoteChatSessionDataConverter()).read(0)
+                        );
+                    }
+                    if (MinecraftVersion.v1_21_2.atOrAbove()) {
+                        return new PlayerInfoData(modifier.<UUID>withType(UUID.class).read(0),
+                            latency,
+                            modifier.<Boolean>withType(boolean.class).read(0),
+                            gameMode,
+                            gameProfile,
+                            displayName,
+                            ints.read(1),
+                            modifier.withType(MinecraftReflection.getRemoteChatSessionDataClass(), BukkitConverters.getWrappedRemoteChatSessionDataConverter()).read(0)
+                        );
+                    }
+                    if (MinecraftVersion.FEATURE_PREVIEW_UPDATE.atOrAbove()) {
+                        return new PlayerInfoData(modifier.<UUID>withType(UUID.class).read(0),
+                            latency,
+                            modifier.<Boolean>withType(boolean.class).read(0),
+                            gameMode,
+                            gameProfile,
+                            displayName,
+                            modifier.withType(MinecraftReflection.getRemoteChatSessionDataClass(), BukkitConverters.getWrappedRemoteChatSessionDataConverter()).read(0)
+                        );
                     }
                     WrappedProfileKeyData key = null;
                     if (MinecraftVersion.WILD_UPDATE.atOrAbove()) {
                         StructureModifier<WrappedProfileKeyData> keyData = modifier.withType(
-                                MinecraftReflection.getProfilePublicKeyDataClass(), BukkitConverters.getWrappedPublicKeyDataConverter());
+                            MinecraftReflection.getProfilePublicKeyDataClass(), BukkitConverters.getWrappedPublicKeyDataConverter());
                         key = keyData.read(0);
                     }
 

src/main/java/com/comphenix/protocol/wrappers/WrappedBlockData.java

@@ -45,7 +45,7 @@ public abstract class WrappedBlockData extends AbstractWrapper implements Clonab
         private static MethodAccessor TO_LEGACY_DATA;
         private static MethodAccessor GET_BLOCK;
         private static MethodAccessor BLOCK_FROM_MATERIAL;
-        private static MethodAccessor GET_BLOCK_DATA;
+        private static MethodAccessor DEFAULT_BLOCK_DATA;
         private static MethodAccessor FROM_LEGACY_DATA;
         private static MethodAccessor GET_HANDLE;
 
@@ -100,7 +100,7 @@ public abstract class WrappedBlockData extends AbstractWrapper implements Clonab
                         .parameterCount(0)
                         .returnTypeExact(IBLOCK_DATA)
                         .build();
-                GET_BLOCK_DATA = Accessors.getMethodAccessor(fuzzy.getMethod(contract));
+                DEFAULT_BLOCK_DATA = Accessors.getMethodAccessor(fuzzy.getMethod(contract));
 
                 fuzzy = FuzzyReflection.fromClass(MinecraftReflection.getCraftBukkitClass("block.data.CraftBlockData"));
                 contract = FuzzyMethodContract
@@ -131,7 +131,7 @@ public abstract class WrappedBlockData extends AbstractWrapper implements Clonab
         @Override
         public void setType(Material material) {
             Object block = BLOCK_FROM_MATERIAL.invoke(null, material);
-            setHandle(GET_BLOCK_DATA.invoke(block));
+            setHandle(DEFAULT_BLOCK_DATA.invoke(block));
         }
 
         @Override
@@ -141,7 +141,7 @@ public abstract class WrappedBlockData extends AbstractWrapper implements Clonab
 
         @Override
         public void setTypeAndData(Material material, int data) {
-            setHandle(TO_LEGACY_DATA.invoke(null, material, (byte) data));
+            setHandle(FROM_LEGACY_DATA.invoke(null, material, (byte) data));
         }
 
         @Override
@@ -151,7 +151,7 @@ public abstract class WrappedBlockData extends AbstractWrapper implements Clonab
 
         private static WrappedBlockData createNewData(Material material) {
             Object block = BLOCK_FROM_MATERIAL.invoke(null, material);
-            return new NewBlockData(GET_BLOCK_DATA.invoke(block));
+            return new NewBlockData(DEFAULT_BLOCK_DATA.invoke(block));
         }
 
         private static WrappedBlockData createNewData(Material material, int data) {

src/main/java/com/comphenix/protocol/wrappers/WrappedChatComponent.java

@@ -1,8 +1,13 @@
 package com.comphenix.protocol.wrappers;
 
 import java.io.StringReader;
+import java.lang.reflect.Field;
 import java.util.Optional;
 
+import com.comphenix.protocol.wrappers.codecs.WrappedCodec;
+import com.comphenix.protocol.wrappers.codecs.WrappedDynamicOps;
+import com.google.gson.JsonParseException;
+import com.google.gson.JsonParser;
 import org.bukkit.ChatColor;
 
 import com.comphenix.protocol.reflect.FuzzyReflection;
@@ -35,41 +40,51 @@ public class WrappedChatComponent extends AbstractWrapper implements ClonableWra
 
     private static ConstructorAccessor CONSTRUCT_TEXT_COMPONENT = null;
 
-    static {
-        FuzzyReflection reflection = FuzzyReflection.fromClass(SERIALIZER, true);
+    private static WrappedCodec CODEC;
+    private static WrappedDynamicOps REGISTRY_JSON_OPS;
 
-        // Retrieve the correct methods
-        if (MinecraftVersion.v1_20_5.atOrAbove()) {
-            SERIALIZE_COMPONENT = Accessors.getMethodAccessor(reflection.getMethod(FuzzyMethodContract.newBuilder()
+    static {
+        FuzzyReflection fuzzy = FuzzyReflection.fromClass(SERIALIZER, true);
+
+        if (MinecraftVersion.v1_21_6.atOrAbove()) {
+            Field codecField = fuzzy.getFieldByType("CODEC", MinecraftReflection.getCodecClass());
+            CODEC = WrappedCodec.fromHandle(Accessors.getFieldAccessor(codecField).get(null));
+            REGISTRY_JSON_OPS = MinecraftRegistryAccess.createSerializationContext(WrappedDynamicOps.json(false));
+        } else if (MinecraftVersion.v1_20_5.atOrAbove()) {
+            SERIALIZE_COMPONENT = Accessors.getMethodAccessor(fuzzy.getMethod(FuzzyMethodContract.newBuilder()
         			.returnTypeExact(String.class)
         			.parameterDerivedOf(COMPONENT)
         			.parameterDerivedOf(MinecraftReflection.getHolderLookupProviderClass())
         			.build()));
         } else {
-            SERIALIZE_COMPONENT = Accessors.getMethodAccessor(reflection.getMethodByReturnTypeAndParameters("serialize", /* a */
+            SERIALIZE_COMPONENT = Accessors.getMethodAccessor(fuzzy.getMethodByReturnTypeAndParameters("serialize", /* a */
                     String.class, new Class<?>[] { COMPONENT }));
         }
 
-        GSON = Accessors.getFieldAccessor(reflection.getFieldByType("gson", GSON_CLASS)).get(null);
+        if (!MinecraftVersion.v1_20_4.atOrAbove()) {
+            GSON = Accessors.getFieldAccessor(fuzzy.getFieldByType("gson", GSON_CLASS)).get(null);
+        }
 
-        if (MinecraftVersion.v1_20_5.atOrAbove()) {
-			DESERIALIZE = Accessors.getMethodAccessor(reflection.getMethod(FuzzyMethodContract.newBuilder()
-        			.returnDerivedOf(COMPONENT)
-        			.parameterExactType(String.class)
-        			.parameterDerivedOf(MinecraftReflection.getHolderLookupProviderClass())
-        			.build()));
-        } else if (MinecraftVersion.v1_20_4.atOrAbove()) {
-			DESERIALIZE = Accessors.getMethodAccessor(reflection
-					.getMethodByReturnTypeAndParameters("fromJson", MUTABLE_COMPONENT_CLASS.get(), new Class[] { String.class }));
-		} else {
-			try {
-				DESERIALIZE = Accessors.getMethodAccessor(FuzzyReflection.fromClass(MinecraftReflection.getChatDeserializer(), true)
-					.getMethodByReturnTypeAndParameters("deserialize", Object.class, new Class<?>[] { GSON_CLASS, String.class, Class.class, boolean.class }));
-			} catch (IllegalArgumentException ex) {
-				// We'll handle it in the ComponentParser
-				DESERIALIZE = null;
-			}
-		}
+        if (!MinecraftVersion.v1_21_6.atOrAbove()) {
+            if (MinecraftVersion.v1_20_5.atOrAbove()) {
+                DESERIALIZE = Accessors.getMethodAccessor(fuzzy.getMethod(FuzzyMethodContract.newBuilder()
+                        .returnDerivedOf(COMPONENT)
+                        .parameterExactType(String.class)
+                        .parameterDerivedOf(MinecraftReflection.getHolderLookupProviderClass())
+                        .build()));
+            } else if (MinecraftVersion.v1_20_4.atOrAbove()) {
+                DESERIALIZE = Accessors.getMethodAccessor(fuzzy
+                        .getMethodByReturnTypeAndParameters("fromJson", MUTABLE_COMPONENT_CLASS.get(), new Class[]{String.class}));
+            } else {
+                try {
+                    DESERIALIZE = Accessors.getMethodAccessor(FuzzyReflection.fromClass(MinecraftReflection.getChatDeserializer(), true)
+                            .getMethodByReturnTypeAndParameters("deserialize", Object.class, new Class<?>[]{GSON_CLASS, String.class, Class.class, boolean.class}));
+                } catch (IllegalArgumentException ex) {
+                    // We'll handle it in the ComponentParser
+                    DESERIALIZE = null;
+                }
+            }
+        }
 
         // Get a component from a standard Minecraft message
         CONSTRUCT_COMPONENT = Accessors.getMethodAccessor(MinecraftReflection.getCraftChatMessage(), "fromString", String.class, boolean.class);
@@ -83,6 +98,11 @@ public class WrappedChatComponent extends AbstractWrapper implements ClonableWra
     }
 
     private static Object serialize(Object handle) {
+        if (CODEC != null) {
+            Object jobj = CODEC.encode(handle, REGISTRY_JSON_OPS).getOrThrow(JsonParseException::new);
+            return jobj.toString();
+        }
+
     	if (MinecraftVersion.v1_20_5.atOrAbove()) {
     		return SERIALIZE_COMPONENT.invoke(null, handle, MinecraftRegistryAccess.get());
     	}
@@ -91,6 +111,10 @@ public class WrappedChatComponent extends AbstractWrapper implements ClonableWra
     }
 
     private static Object deserialize(String json) {
+        if (CODEC != null) {
+            return CODEC.parse(JsonParser.parseString(json), REGISTRY_JSON_OPS).getOrThrow(JsonParseException::new);
+        }
+
     	if (MinecraftVersion.v1_20_5.atOrAbove()) {
     		return DESERIALIZE.invoke(null, json, MinecraftRegistryAccess.get());
     	}

src/main/java/com/comphenix/protocol/wrappers/WrappedChatTypeBound.java

@@ -0,0 +1,119 @@
+package com.comphenix.protocol.wrappers;
+
+import com.comphenix.protocol.reflect.EquivalentConverter;
+import com.comphenix.protocol.reflect.accessors.Accessors;
+import com.comphenix.protocol.reflect.accessors.ConstructorAccessor;
+import com.comphenix.protocol.reflect.accessors.MethodAccessor;
+import com.comphenix.protocol.utility.MinecraftReflection;
+
+import java.util.Objects;
+import java.util.Optional;
+
+/**
+ * Wrapper for {@code ChatType.Bound}.
+ */
+public final class WrappedChatTypeBound {
+
+    private static final Class<?> HANDLE_TYPE = MinecraftReflection.getMinecraftClass("network.chat.ChatType$Bound");
+    private static final ConstructorAccessor CONSTRUCTOR = Accessors.getConstructorAccessor(
+            HANDLE_TYPE,
+            MinecraftReflection.getHolderClass(),
+            MinecraftReflection.getIChatBaseComponentClass(),
+            Optional.class);
+    private static final MethodAccessor GET_CHAT_TYPE = Accessors.getMethodAccessor(HANDLE_TYPE, "chatType");
+    private static final MethodAccessor GET_NAME = Accessors.getMethodAccessor(HANDLE_TYPE, "name");
+    private static final MethodAccessor GET_TARGET_NAME = Accessors.getMethodAccessor(HANDLE_TYPE, "targetName");
+
+    private static final EquivalentConverter<MinecraftKey> CHAT_TYPE_HOLDER_CONVERTER =
+            new EquivalentConverter<>() {
+                @Override
+                public Object getGeneric(MinecraftKey specific) {
+                    return chatTypeHolderConverter().getGeneric(specific);
+                }
+
+                @Override
+                public MinecraftKey getSpecific(Object generic) {
+                    return chatTypeHolderConverter().getSpecific(generic);
+                }
+
+                @Override
+                public Class<MinecraftKey> getSpecificType() {
+                    return MinecraftKey.class;
+                }
+            };
+
+    public static final EquivalentConverter<WrappedChatTypeBound> CONVERTER =
+            Converters.ignoreNull(new EquivalentConverter<>() {
+                @Override
+                public Object getGeneric(WrappedChatTypeBound specific) {
+                    return CONSTRUCTOR.invoke(
+                            CHAT_TYPE_HOLDER_CONVERTER.getGeneric(specific.chatType),
+                            BukkitConverters.getWrappedChatComponentConverter().getGeneric(specific.name),
+                            Converters.optional(BukkitConverters.getWrappedChatComponentConverter())
+                                    .getGeneric(specific.targetName));
+                }
+
+                @Override
+                public WrappedChatTypeBound getSpecific(Object generic) {
+                    return new WrappedChatTypeBound(
+                            CHAT_TYPE_HOLDER_CONVERTER.getSpecific(GET_CHAT_TYPE.invoke(generic)),
+                            BukkitConverters.getWrappedChatComponentConverter().getSpecific(GET_NAME.invoke(generic)),
+                            Converters.optional(BukkitConverters.getWrappedChatComponentConverter())
+                                    .getSpecific(GET_TARGET_NAME.invoke(generic)));
+                }
+
+                @Override
+                public Class<WrappedChatTypeBound> getSpecificType() {
+                    return WrappedChatTypeBound.class;
+                }
+            });
+
+    private final MinecraftKey chatType;
+    private final WrappedChatComponent name;
+    private final Optional<WrappedChatComponent> targetName;
+
+    public WrappedChatTypeBound(MinecraftKey chatType, WrappedChatComponent name,
+            Optional<WrappedChatComponent> targetName) {
+        this.chatType = chatType;
+        this.name = name;
+        this.targetName = targetName;
+    }
+
+    public MinecraftKey getChatType() {
+        return chatType;
+    }
+
+    public WrappedChatComponent getName() {
+        return name;
+    }
+
+    public Optional<WrappedChatComponent> getTargetName() {
+        return targetName;
+    }
+
+    private static EquivalentConverter<MinecraftKey> chatTypeHolderConverter() {
+        WrappedRegistry registry = WrappedRegistry.getRegistryByNmsKey("core.registries.Registries", "CHAT_TYPE");
+        if (registry == null) {
+            throw new IllegalStateException("ChatType registry is not available");
+        }
+        return Converters.holder(registry.valueConverter(), registry);
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof WrappedChatTypeBound that)) {
+            return false;
+        }
+        return Objects.equals(chatType, that.chatType)
+                && Objects.equals(name, that.name)
+                && Objects.equals(targetName, that.targetName);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(chatType, name, targetName);
+    }
+}

src/main/java/com/comphenix/protocol/wrappers/WrappedChunkBiomeData.java

@@ -0,0 +1,86 @@
+package com.comphenix.protocol.wrappers;
+
+import com.comphenix.protocol.reflect.EquivalentConverter;
+import com.comphenix.protocol.reflect.accessors.Accessors;
+import com.comphenix.protocol.reflect.accessors.ConstructorAccessor;
+import com.comphenix.protocol.reflect.accessors.MethodAccessor;
+import com.comphenix.protocol.utility.MinecraftReflection;
+
+import java.util.Arrays;
+import java.util.Objects;
+
+/**
+ * Wrapper for {@code ClientboundChunksBiomesPacket.ChunkBiomeData}.
+ */
+public final class WrappedChunkBiomeData {
+
+    private static final Class<?> HANDLE_TYPE = MinecraftReflection.getMinecraftClass(
+            "network.protocol.game.ClientboundChunksBiomesPacket$ChunkBiomeData");
+    private static final ConstructorAccessor CONSTRUCTOR = Accessors.getConstructorAccessor(
+            HANDLE_TYPE,
+            MinecraftReflection.getChunkCoordIntPair(),
+            byte[].class);
+    private static final MethodAccessor GET_POS = Accessors.getMethodAccessor(HANDLE_TYPE, "pos");
+    private static final MethodAccessor GET_BUFFER = Accessors.getMethodAccessor(HANDLE_TYPE, "buffer");
+
+    public static final EquivalentConverter<WrappedChunkBiomeData> CONVERTER =
+            Converters.ignoreNull(new EquivalentConverter<>() {
+                @Override
+                public Object getGeneric(WrappedChunkBiomeData specific) {
+                    return CONSTRUCTOR.invoke(
+                            ChunkCoordIntPair.getConverter().getGeneric(specific.position),
+                            specific.buffer.clone());
+                }
+
+                @Override
+                public WrappedChunkBiomeData getSpecific(Object generic) {
+                    return new WrappedChunkBiomeData(
+                            ChunkCoordIntPair.getConverter().getSpecific(GET_POS.invoke(generic)),
+                            ((byte[]) GET_BUFFER.invoke(generic)).clone());
+                }
+
+                @Override
+                public Class<WrappedChunkBiomeData> getSpecificType() {
+                    return WrappedChunkBiomeData.class;
+                }
+            });
+
+    private final ChunkCoordIntPair position;
+    private final byte[] buffer;
+
+    public WrappedChunkBiomeData(ChunkCoordIntPair position, byte[] buffer) {
+        this.position = position;
+        this.buffer = buffer.clone();
+    }
+
+    public ChunkCoordIntPair getPosition() {
+        return position;
+    }
+
+    public byte[] getBuffer() {
+        return buffer.clone();
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof WrappedChunkBiomeData that)) {
+            return false;
+        }
+        return Objects.equals(position, that.position) && Arrays.equals(buffer, that.buffer);
+    }
+
+    @Override
+    public int hashCode() {
+        int result = Objects.hash(position);
+        result = 31 * result + Arrays.hashCode(buffer);
+        return result;
+    }
+
+    @Override
+    public String toString() {
+        return "WrappedChunkBiomeData{position=" + position + ", buffer=" + Arrays.toString(buffer) + '}';
+    }
+}

src/main/java/com/comphenix/protocol/wrappers/WrappedDataWatcher.java

@@ -24,6 +24,7 @@ import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Optional;
 import java.util.Set;
 import java.util.UUID;
@@ -40,7 +41,6 @@ import com.comphenix.protocol.wrappers.EnumWrappers.EntityPose;
 import com.comphenix.protocol.wrappers.nbt.NbtCompound;
 
 import com.google.common.collect.ImmutableBiMap;
-import com.google.common.collect.ImmutableMap;
 import org.apache.commons.lang.Validate;
 import org.bukkit.entity.Entity;
 import org.bukkit.inventory.ItemStack;
@@ -66,7 +66,7 @@ public class WrappedDataWatcher implements IDataWatcher {
      * Constructs a new DataWatcher wrapper around a NMS handle. The resulting
      * DataWatcher will likely have existing values that can be removed with
      * {@link #clear()}.
-     * 
+     *
      * @param handle DataWatcher handle
      */
     public WrappedDataWatcher(Object handle) {
@@ -90,7 +90,7 @@ public class WrappedDataWatcher implements IDataWatcher {
      * Constructs a new DataWatcher using a real entity. The resulting
      * DataWatcher will not have any keys or values and new ones will have to
      * be added using watcher objects.
-     * 
+     *
      * @param entity The entity
      */
     public WrappedDataWatcher(Entity entity) {
@@ -102,7 +102,7 @@ public class WrappedDataWatcher implements IDataWatcher {
     /**
      * Constructs a new DataWatcher using a fake egg entity and a given
      * list of watchable objects.
-     * 
+     *
      * @param objects The list of objects
      */
     public WrappedDataWatcher(List<WrappedWatchableObject> objects) {
@@ -152,7 +152,7 @@ public class WrappedDataWatcher implements IDataWatcher {
 
     /**
      * Gets the item at a given index.
-     * 
+     *
      * @param index Index to get
      * @return The watchable object, or null if none exists
      */
@@ -170,7 +170,7 @@ public class WrappedDataWatcher implements IDataWatcher {
 
     /**
      * Removes the item at a given index.
-     * 
+     *
      * @param index Index to remove
      * @return The previous value, or null if none existed
      */
@@ -180,7 +180,7 @@ public class WrappedDataWatcher implements IDataWatcher {
 
     /**
      * Whether or not this DataWatcher has an object at a given index.
-     * 
+     *
      * @param index Index to check for
      * @return True if it does, false if not
      */
@@ -209,7 +209,7 @@ public class WrappedDataWatcher implements IDataWatcher {
 
     /**
      * Get a watched byte.
-     * 
+     *
      * @param index - index of the watched byte.
      * @return The watched byte, or NULL if this value doesn't exist.
      */
@@ -225,7 +225,7 @@ public class WrappedDataWatcher implements IDataWatcher {
 
     /**
      * Get a watched short.
-     * 
+     *
      * @param index - index of the watched short.
      * @return The watched short, or NULL if this value doesn't exist.
      */
@@ -237,7 +237,7 @@ public class WrappedDataWatcher implements IDataWatcher {
 
     /**
      * Get a watched integer.
-     * 
+     *
      * @param index - index of the watched integer.
      * @return The watched integer, or NULL if this value doesn't exist.
      */
@@ -263,7 +263,7 @@ public class WrappedDataWatcher implements IDataWatcher {
 
     /**
      * Get a watched float.
-     * 
+     *
      * @param index - index of the watched float.
      * @return The watched float, or NULL if this value doesn't exist.
      */
@@ -279,7 +279,7 @@ public class WrappedDataWatcher implements IDataWatcher {
 
     /**
      * Get a watched string.
-     * 
+     *
      * @param index - index of the watched string.
      * @return The watched string, or NULL if this value doesn't exist.
      */
@@ -315,7 +315,7 @@ public class WrappedDataWatcher implements IDataWatcher {
 
     /**
      * Get a watched string.
-     * 
+     *
      * @param index - index of the watched string.
      * @return The watched string, or NULL if this value doesn't exist.
      */
@@ -477,7 +477,7 @@ public class WrappedDataWatcher implements IDataWatcher {
 
     /**
      * Retrieve a watchable object by index.
-     * 
+     *
      * @param index Index of the object to retrieve.
      * @return The watched object or null if it doesn't exist.
      */
@@ -487,7 +487,7 @@ public class WrappedDataWatcher implements IDataWatcher {
 
     /**
      * Retrieve a watchable object by watcher object.
-     * 
+     *
      * @param object The watcher object
      * @return The watched object or null if it doesn't exist.
      */
@@ -500,11 +500,11 @@ public class WrappedDataWatcher implements IDataWatcher {
     /**
      * Sets the DataWatcher Item at a given index to a new value. In 1.9 and up,
      * you cannot register objects without a watcher object.
-     * 
+     *
      * @param index Index of the object to set
      * @param value New value
      * @param update Whether or not to inform the client
-     * 
+     *
      * @see WrappedDataWatcher#setObject(WrappedDataWatcherObject, Object, boolean)
      * @throws IllegalArgumentException in 1.9 and up if there isn't already an
      *      object at this index
@@ -526,12 +526,12 @@ public class WrappedDataWatcher implements IDataWatcher {
 
     /**
      * Sets the DataWatcher Item at a given index to a new value.
-     * 
+     *
      * @param index Index of the object to set
      * @param serializer Serializer from {@link Registry#get(Class)}
      * @param value New value
      * @param update Whether or not to inform the client
-     * 
+     *
      * @see WrappedDataWatcher#setObject(WrappedDataWatcherObject, Object)
      */
     public void setObject(int index, Serializer serializer, Object value, boolean update) {
@@ -547,11 +547,11 @@ public class WrappedDataWatcher implements IDataWatcher {
 
     /**
      * Sets the DataWatcher Item at a given index to a new value.
-     * 
+     *
      * @param index Index of the object to set
      * @param value New value
      * @param update Whether or not to inform the client
-     * 
+     *
      * @see WrappedDataWatcher#setObject(int, Object, boolean)
      */
     public void setObject(int index, WrappedWatchableObject value, boolean update) {
@@ -567,11 +567,11 @@ public class WrappedDataWatcher implements IDataWatcher {
 
     /**
      * Sets the DataWatcher Item associated with a given watcher object to a new value.
-     * 
+     *
      * @param object Associated watcher object
      * @param value Wrapped value
      * @param update Whether or not to inform the client
-     * 
+     *
      * @see #setObject(WrappedDataWatcherObject, Object)
      */
     public void setObject(WrappedDataWatcherObject object, WrappedWatchableObject value, boolean update) {
@@ -589,10 +589,10 @@ public class WrappedDataWatcher implements IDataWatcher {
      * Sets the DataWatcher Item associated with a given watcher object to a
      * new value. If there is not already an object at this index, the
      * specified watcher object must have a serializer.
-     * 
+     *
      * @param object Associated watcher object
      * @param value New value
-     * 
+     *
      * @throws IllegalArgumentException If the watcher object is null or must
      *          have a serializer and does not have one.
      */
@@ -611,7 +611,7 @@ public class WrappedDataWatcher implements IDataWatcher {
 
     /**
      * Clone the content of the current DataWatcher.
-     * 
+     *
      * @return A cloned data watcher.
      */
     public WrappedDataWatcher deepClone() {
@@ -628,7 +628,7 @@ public class WrappedDataWatcher implements IDataWatcher {
 
     /**
      * Retrieve the data watcher associated with an entity.
-     * 
+     *
      * @param entity - the entity to read from.
      * @return Associated data watcher.
      */
@@ -682,7 +682,7 @@ public class WrappedDataWatcher implements IDataWatcher {
     /**
      * Retrieves the type ID associated with a given class. No longer supported
      * in 1.9 and up due to the removal of type IDs.
-     * 
+     *
      * @param clazz Class to find ID for
      * @return The ID, or null if not found
      */
@@ -693,7 +693,7 @@ public class WrappedDataWatcher implements IDataWatcher {
     /**
      * Retrieves the class associated with a given type ID. No longer
      * supported in 1.9 and up due to the removal of type IDs.
-     * 
+     *
      * @param typeID ID to find Class for
      * @return The Class, or null if not found
      */
@@ -729,7 +729,7 @@ public class WrappedDataWatcher implements IDataWatcher {
     /**
      * Represents a DataWatcherObject in 1.9. In order to register an object,
      * the serializer must be specified.
-     * 
+     *
      * @author dmulloy2
      */
     public static class WrappedDataWatcherObject {
@@ -745,7 +745,7 @@ public class WrappedDataWatcher implements IDataWatcher {
 
         /**
          * Creates a new watcher object from a NMS handle.
-         * 
+         *
          * @param handle The handle
          */
         public WrappedDataWatcherObject(Object handle) {
@@ -755,7 +755,7 @@ public class WrappedDataWatcher implements IDataWatcher {
 
         /**
          * Creates a new watcher object from an index and serializer.
-         * 
+         *
          * @param index Index
          * @param serializer Serializer, see {@link Registry}
          */
@@ -795,7 +795,7 @@ public class WrappedDataWatcher implements IDataWatcher {
 
         /**
          * Gets this watcher object's index.
-         * 
+         *
          * @return The index
          */
         public int getIndex() {
@@ -805,7 +805,7 @@ public class WrappedDataWatcher implements IDataWatcher {
         /**
          * Gets this watcher object's serializer. Will return null if the
          * serializer was never specified.
-         * 
+         *
          * @return The serializer, or null
          */
         public Serializer getSerializer() {
@@ -911,23 +911,36 @@ public class WrappedDataWatcher implements IDataWatcher {
     /**
      * Represents a DataWatcherSerializer in 1.9. If a Serializer is optional,
      * values must be wrapped in a {@link Optional}.
-     * 
+     *
      * @author dmulloy2
      */
     public static class Serializer extends AbstractWrapper {
         private static final Class<?> HANDLE_TYPE = MinecraftReflection.getDataWatcherSerializerClass();
 
-        private final Class<?> type;
+        private final Type type;
         private final boolean optional;
 
         /**
          * Constructs a new Serializer
-         * 
+         *
+         * @param type Type it serializes
+         * @param handle NMS handle
+         * @param optional Whether or not it's {@link Optional}
+         * @deprecated Use {@link Serializer#Serializer(Type, Object, boolean)} instead.
+         */
+        @Deprecated(forRemoval = true)
+        public Serializer(Class<?> type, Object handle, boolean optional) {
+            this((Type) type, handle, optional);
+        }
+
+        /**
+         * Constructs a new Serializer
+         *
          * @param type Type it serializes
          * @param handle NMS handle
          * @param optional Whether or not it's {@link Optional}
          */
-        public Serializer(Class<?> type, Object handle, boolean optional) {
+        public Serializer(Type type, Object handle, boolean optional) {
             super(HANDLE_TYPE);
             this.type = type;
             this.optional = optional;
@@ -937,17 +950,32 @@ public class WrappedDataWatcher implements IDataWatcher {
 
         /**
          * Gets the type this serializer serializes.
-         * 
+         *
          * @return The type
+         * @deprecated use {@link #getGenericType()} instead.
          */
+        @Deprecated(forRemoval = true)
         public Class<?> getType() {
-            return type;
+            if (this.type instanceof Class<?> c) {
+                return c;
+            }
+
+            throw new IllegalStateException("Serializer does not serialize a class");
+        }
+
+        /**
+         * Gets the type this serializer serializes.
+         *
+         * @return The type.
+         */
+        public Type getGenericType() {
+            return this.type;
         }
 
         /**
          * Whether or not this serializer is optional, that is whether or not
          * the return type is wrapped in a {@link Optional}.
-         * 
+         *
          * @return True if it is, false if not
          */
         public boolean isOptional() {
@@ -986,11 +1014,19 @@ public class WrappedDataWatcher implements IDataWatcher {
     public static class Registry {
         private static boolean INITIALIZED = false;
 
-        private static Map<Class<?>, Serializer> RAW_REGISTRY = null;
-        private static Map<Class<?>, Serializer> OPTIONAL_REGISTRY = null;
+        private static Map<Type, Serializer> RAW_REGISTRY = null;
+        private static Map<Type, Serializer> OPTIONAL_REGISTRY = null;
 
         /**
-         * Gets the first serializer associated with a given class.
+         * @deprecated use {@link #get(Type)} instead.
+         */
+        @Deprecated(forRemoval = true)
+        public static Serializer get(Class<?> clazz) {
+            return get((Type) clazz);
+        }
+
+        /**
+         * Gets the first serializer associated with a given type.
          *
          * <p><b>Note</b>: If {@link Serializer#isOptional() the serializer is optional},
          *   values <i>must</i> be wrapped in an {@link Optional}.</p>
@@ -998,39 +1034,46 @@ public class WrappedDataWatcher implements IDataWatcher {
          * <p>If there are multiple serializers for a given class (i.e. BlockPosition),
          *   you should use {@link #get(Class, boolean)} for more precision.</p>
          *
-         * @param clazz Class to find serializer for
+         * @param type Type to find serializer for
          * @return The serializer, or null if none exists
          */
-        public static Serializer get(Class<?> clazz) {
-            Validate.notNull(clazz,"Class cannot be null!");
+        public static Serializer get(Type type) {
+            Validate.notNull(type,"Type cannot be null!");
             initialize();
 
-            Serializer serializer = RAW_REGISTRY.getOrDefault(clazz,
-                OPTIONAL_REGISTRY.getOrDefault(clazz, null));
+            Serializer serializer = RAW_REGISTRY.getOrDefault(type, OPTIONAL_REGISTRY.get(type));
             if (serializer == null) {
-                throw new IllegalArgumentException("No serializer found for " + clazz);
+                throw new IllegalArgumentException("No serializer found for " + type);
             }
 
             return serializer;
         }
 
         /**
-         * Gets the first serializer associated with a given class and optional state.
+         * @deprecated use {@link #get(Type, boolean)} instead.
+         */
+        @Deprecated(forRemoval = true)
+        public static Serializer get(Class<?> clazz, boolean optional) {
+            return get((Type) clazz, optional);
+        }
+
+        /**
+         * Gets the first serializer associated with a given type and optional state.
          * <br/>
          * <b>Note</b>: If the serializer is optional, values <i>must</i> be
          * wrapped in an {@link Optional}
          *
-         * @param clazz Class to find serializer for
+         * @param type Type to find serializer for
          * @param optional Optional state
          * @return The serializer, or null if none exists
          */
-        public static Serializer get(Class<?> clazz, boolean optional) {
-            Validate.notNull(clazz, "Class cannot be null!");
+        public static Serializer get(Type type, boolean optional) {
+            Validate.notNull(type, "Type cannot be null!");
             initialize();
 
-            Serializer serializer = optional ? OPTIONAL_REGISTRY.get(clazz) : RAW_REGISTRY.get(clazz);
+            Serializer serializer = optional ? OPTIONAL_REGISTRY.get(type) : RAW_REGISTRY.get(type);
             if (serializer == null) {
-                throw new IllegalArgumentException("No serializer found for " + (optional ? "Optional<" + clazz + ">" : clazz));
+                throw new IllegalArgumentException("No serializer found for " + (optional ? "Optional<" + type + ">" : type));
             }
 
             return serializer;
@@ -1067,52 +1110,41 @@ public class WrappedDataWatcher implements IDataWatcher {
                 return;
             }
 
-            Map<Class<?>, Serializer> rawRegistry = new HashMap<>();
-            Map<Class<?>, Serializer> optionalRegistry = new HashMap<>();
+            Map<Type, Serializer> rawRegistry = new HashMap<>();
+            Map<Type, Serializer> optionalRegistry = new HashMap<>();
 
             List<Field> candidates = FuzzyReflection.fromClass(MinecraftReflection.getDataWatcherRegistryClass(), true)
                     .getFieldListByType(MinecraftReflection.getDataWatcherSerializerClass());
             for (Field candidate : candidates) {
-                Type generic = candidate.getGenericType();
-                if (generic instanceof ParameterizedType) {
-                    ParameterizedType type = (ParameterizedType) generic;
-                    Type[] args = type.getActualTypeArguments();
-                    Type arg = args[0];
-
-                    Class<?> innerClass;
-                    boolean optional = false;
-
-                    if (arg instanceof Class<?>) {
-                        innerClass = (Class<?>) arg;
-                    } else if (arg instanceof ParameterizedType) {
-                        innerClass = (Class<?>) ((ParameterizedType) arg).getActualTypeArguments()[0];
-                        optional = true;
-                    } else {
-                        throw new IllegalStateException("Failed to find inner class of field " + candidate);
-                    }
-
+                if (candidate.getGenericType() instanceof ParameterizedType cpt) {
                     Object serializer;
-
                     try {
                         serializer = candidate.get(null);
+                        Objects.requireNonNull(serializer, "Failed to read serializer: " + candidate.getName());
                     } catch (ReflectiveOperationException e) {
                         throw new IllegalStateException("Failed to read field " + candidate);
                     }
 
-                    if (serializer == null) {
-                        throw new RuntimeException("Failed to read serializer: " + candidate.getName());
+                    // all types are wrapped in EntityDataSerializer<?>
+                    Type serializingType = cpt.getActualTypeArguments()[0];
+                    if (serializingType instanceof ParameterizedType spt) {
+                        Class<?> root = (Class<?>) spt.getRawType();
+                        if (root == Optional.class) {
+                            // special case: EntityDataSerializer<Optional<?>>
+                            Type actualType = spt.getActualTypeArguments()[0];
+                            Serializer wrappedSerializer = new Serializer(actualType, serializer, true);
+                            optionalRegistry.put(actualType, wrappedSerializer);
+                            continue;
+                        }
                     }
 
-                    if (optional) {
-                        optionalRegistry.put(innerClass, new Serializer(innerClass, serializer, true));
-                    } else {
-                        rawRegistry.put(innerClass, new Serializer(innerClass, serializer, false));
-                    }
+                    Serializer wrappedSerializer = new Serializer(serializingType, serializer, false);
+                    rawRegistry.put(serializingType, wrappedSerializer);
                 }
             }
 
-            RAW_REGISTRY = ImmutableMap.copyOf(rawRegistry);
-            OPTIONAL_REGISTRY = ImmutableMap.copyOf(optionalRegistry);
+            RAW_REGISTRY = Map.copyOf(rawRegistry);
+            OPTIONAL_REGISTRY = Map.copyOf(optionalRegistry);
         }
 
         // ---- Helper methods

src/main/java/com/comphenix/protocol/wrappers/WrappedExplosionParticleInfo.java

@@ -0,0 +1,140 @@
+package com.comphenix.protocol.wrappers;
+
+import java.util.Objects;
+
+import com.comphenix.protocol.events.InternalStructure;
+import com.comphenix.protocol.reflect.EquivalentConverter;
+import com.comphenix.protocol.reflect.accessors.Accessors;
+import com.comphenix.protocol.reflect.accessors.ConstructorAccessor;
+import com.comphenix.protocol.utility.MinecraftReflection;
+
+/**
+ * Wraps the NMS {@code ExplosionParticleInfo} record, which pairs a
+ * {@link WrappedParticle} with scaling and speed float values.
+ *
+ * <p>NMS record: {@code ExplosionParticleInfo(ParticleOptions particle, float scaling, float speed)}
+ */
+public class WrappedExplosionParticleInfo {
+
+    private static final Class<?> NMS_CLASS;
+    private static final ConstructorAccessor NMS_CTOR;
+
+    static {
+        NMS_CLASS = MinecraftReflection.getMinecraftClass("core.particles.ExplosionParticleInfo");
+        NMS_CTOR = Accessors.getConstructorAccessor(
+                NMS_CLASS,
+                MinecraftReflection.getParticleParam(),
+                float.class,
+                float.class);
+    }
+
+    /**
+     * Returns the NMS {@code ExplosionParticleInfo} class.
+     */
+    public static Class<?> getNmsClass() {
+        return NMS_CLASS;
+    }
+
+    // ── Instance data ────────────────────────────────────────────────────
+
+    private WrappedParticle<?> particle;
+    private float scaling;
+    private float speed;
+
+    public WrappedExplosionParticleInfo() {
+        this.scaling = 1.0f;
+        this.speed = 1.0f;
+    }
+
+    public WrappedExplosionParticleInfo(WrappedParticle<?> particle, float scaling, float speed) {
+        this.particle = particle;
+        this.scaling = scaling;
+        this.speed = speed;
+    }
+
+    public WrappedParticle<?> getParticle() {
+        return particle;
+    }
+
+    public void setParticle(WrappedParticle<?> particle) {
+        this.particle = particle;
+    }
+
+    public float getScaling() {
+        return scaling;
+    }
+
+    public void setScaling(float scaling) {
+        this.scaling = scaling;
+    }
+
+    public float getSpeed() {
+        return speed;
+    }
+
+    public void setSpeed(float speed) {
+        this.speed = speed;
+    }
+
+    // ── Converter ────────────────────────────────────────────────────────
+
+    /**
+     * Reads an NMS {@code ExplosionParticleInfo} into this wrapper via
+     * {@link InternalStructure} typed getters.
+     */
+    public static WrappedExplosionParticleInfo fromHandle(InternalStructure handle) {
+        WrappedParticle<?> particle = handle.getNewParticles().read(0);
+        float scaling = handle.getFloat().read(0);
+        float speed = handle.getFloat().read(1);
+        return new WrappedExplosionParticleInfo(particle, scaling, speed);
+    }
+
+    /**
+     * Returns an {@link EquivalentConverter} between {@code WrappedExplosionParticleInfo}
+     * and the NMS {@code ExplosionParticleInfo} record.
+     */
+    public static EquivalentConverter<WrappedExplosionParticleInfo> getConverter() {
+        return new EquivalentConverter<>() {
+
+            @Override
+            public WrappedExplosionParticleInfo getSpecific(Object generic) {
+                InternalStructure structure = InternalStructure.getConverter().getSpecific(generic);
+                return fromHandle(structure);
+            }
+
+            @Override
+            public Object getGeneric(WrappedExplosionParticleInfo specific) {
+                EquivalentConverter<WrappedParticle> particleConverter = BukkitConverters.getParticleConverter();
+                Object nmsParticle = particleConverter.getGeneric(specific.particle);
+                return NMS_CTOR.invoke(nmsParticle, specific.scaling, specific.speed);
+            }
+
+            @Override
+            public Class<WrappedExplosionParticleInfo> getSpecificType() {
+                return WrappedExplosionParticleInfo.class;
+            }
+        };
+    }
+
+    // ── Object methods ───────────────────────────────────────────────────
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof WrappedExplosionParticleInfo that)) return false;
+        return Float.compare(scaling, that.scaling) == 0
+                && Float.compare(speed, that.speed) == 0
+                && Objects.equals(particle, that.particle);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(particle, scaling, speed);
+    }
+
+    @Override
+    public String toString() {
+        return "WrappedExplosionParticleInfo{particle=" + particle
+                + ", scaling=" + scaling + ", speed=" + speed + "}";
+    }
+}

src/main/java/com/comphenix/protocol/wrappers/WrappedGameProfile.java

@@ -35,18 +35,30 @@ public class WrappedGameProfile extends AbstractWrapper {
             GAME_PROFILE, String.class, String.class);
     private static final ConstructorAccessor CREATE_UUID_STRING = Accessors.getConstructorAccessorOrNull(
             GAME_PROFILE, UUID.class, String.class);
+    private static final ConstructorAccessor CREATE_UUID_STRING_PROPERTIES = Accessors.getConstructorAccessorOrNull(
+            GAME_PROFILE, UUID.class, String.class, MinecraftReflection.getGameProfilePropertyMapClass());
 
     private static final FieldAccessor GET_UUID_STRING = Accessors.getFieldAccessorOrNull(
             GAME_PROFILE, "id", String.class);
 
-    private static final MethodAccessor GET_ID = Accessors.getMethodAccessorOrNull(
-            GAME_PROFILE, "getId");
-    private static final MethodAccessor GET_NAME = Accessors.getMethodAccessorOrNull(
-            GAME_PROFILE, "getName");
-    private static final MethodAccessor GET_PROPERTIES = Accessors.getMethodAccessorOrNull(
-            GAME_PROFILE, "getProperties");
-    private static final MethodAccessor IS_COMPLETE = Accessors.getMethodAccessorOrNull(
-            GAME_PROFILE, "isComplete");
+    private static MethodAccessor GET_ID;
+    private static MethodAccessor GET_NAME;
+    private static MethodAccessor GET_PROPERTIES;
+    private static MethodAccessor IS_COMPLETE;
+
+    static {
+        GET_ID = Accessors.getMethodAccessorOrNull(GAME_PROFILE, "getId");
+        if (GET_ID == null) {
+            GET_ID = Accessors.getMethodAccessorOrNull(GAME_PROFILE, "id");
+            GET_NAME = Accessors.getMethodAccessorOrNull(GAME_PROFILE, "name");
+            GET_PROPERTIES = Accessors.getMethodAccessorOrNull(GAME_PROFILE, "properties");
+            IS_COMPLETE = Accessors.getMethodAccessorOrNull(GAME_PROFILE, "complete");
+        } else {
+            GET_NAME = Accessors.getMethodAccessorOrNull(GAME_PROFILE, "getName");
+            GET_PROPERTIES = Accessors.getMethodAccessorOrNull(GAME_PROFILE, "getProperties");
+            IS_COMPLETE = Accessors.getMethodAccessorOrNull(GAME_PROFILE, "isComplete");
+        }
+    }
 
     // Fetching game profile
     private static FieldAccessor PLAYER_PROFILE;
@@ -117,6 +129,51 @@ public class WrappedGameProfile extends AbstractWrapper {
         this(parseUUID(id), name);
     }
 
+    private static Object createHandle(UUID uuid, String name, Multimap<String, WrappedSignedProperty> properties) {
+        if (CREATE_STRING_STRING != null) {
+            return CREATE_STRING_STRING.invoke(uuid != null ? uuid.toString() : null, name);
+        }
+
+        if (CREATE_UUID_STRING == null) {
+            throw new IllegalArgumentException("Unsupported GameProfile constructor.");
+        }
+
+        if (!MinecraftVersion.CONFIG_PHASE_PROTOCOL_UPDATE.atOrAbove()) {
+            return CREATE_UUID_STRING.invoke(uuid, name);
+        }
+
+        // 1.20.2+ requires all fields to have a value: null uuid -> UUID(0,0), null name -> empty name
+        // it's not allowed to pass null for both, so we need to pre-check that
+        if (uuid == null && (name == null || name.isEmpty())) {
+            throw new IllegalArgumentException("Name and ID cannot both be blank");
+        }
+
+        // 1.21.9+ made PropertyMap's underlying map immutable, so we need to override it with a mutable map
+        if (MinecraftVersion.v1_21_9.atOrAbove()) {
+            return CREATE_UUID_STRING_PROPERTIES.invoke(uuid == null ? MinecraftGenerator.SYS_UUID : uuid, name == null ? "" : name,
+                    convertPropertyMap(properties));
+        }
+
+        return CREATE_UUID_STRING.invoke(uuid == null ? MinecraftGenerator.SYS_UUID : uuid, name == null ? "" : name);
+    }
+
+    private static Object convertPropertyMap(Multimap<String, WrappedSignedProperty> properties) {
+        com.comphenix.protocol.wrappers.MutablePropertyMap map =
+                new com.comphenix.protocol.wrappers.MutablePropertyMap();
+
+        if (properties == null || properties.isEmpty()) {
+            return map;
+        }
+
+        for (String key : properties.keySet()) {
+            for (WrappedSignedProperty property : properties.get(key)) {
+                map.put(key, (com.mojang.authlib.properties.Property) property.getHandle());
+            }
+        }
+
+        return map;
+    }
+
     /**
      * Construct a new game profile with the given properties.
      * <p>
@@ -127,24 +184,12 @@ public class WrappedGameProfile extends AbstractWrapper {
      */
     public WrappedGameProfile(UUID uuid, String name) {
         super(GAME_PROFILE);
+        setHandle(createHandle(uuid, name, null));
+    }
 
-        if (CREATE_STRING_STRING != null) {
-            setHandle(CREATE_STRING_STRING.invoke(uuid != null ? uuid.toString() : null, name));
-        } else if (CREATE_UUID_STRING != null) {
-            if (MinecraftVersion.CONFIG_PHASE_PROTOCOL_UPDATE.atOrAbove()) {
-                // 1.20.2+ requires all fields to have a value: null uuid -> UUID(0,0), null name -> empty name
-                // it's not allowed to pass null for both, so we need to pre-check that
-                if (uuid == null && (name == null || name.isEmpty())) {
-                    throw new IllegalArgumentException("Name and ID cannot both be blank");
-                }
-
-                setHandle(CREATE_UUID_STRING.invoke(uuid == null ? MinecraftGenerator.SYS_UUID : uuid, name == null ? "" : name));
-            } else {
-                setHandle(CREATE_UUID_STRING.invoke(uuid, name));
-            }
-        } else {
-            throw new IllegalArgumentException("Unsupported GameProfile constructor.");
-        }
+    public WrappedGameProfile(UUID uuid, String name, Multimap<String, WrappedSignedProperty> properties) {
+        super(GAME_PROFILE);
+        setHandle(createHandle(uuid, name, properties));
     }
 
     /**
@@ -157,7 +202,12 @@ public class WrappedGameProfile extends AbstractWrapper {
         if (handle == null)
             return null;
 
-        return new WrappedGameProfile(handle);
+        WrappedGameProfile delegate = new WrappedGameProfile(handle);
+        if (MinecraftVersion.v1_21_9.atOrAbove()) {
+            return new WrappedGameProfile(delegate.getUUID(), delegate.getName(), delegate.getProperties());
+        } else {
+            return delegate;
+        }
     }
 
     /**
@@ -269,7 +319,15 @@ public class WrappedGameProfile extends AbstractWrapper {
 
         if (result == null) {
             Multimap properties = (Multimap) GET_PROPERTIES.invoke(handle);
-            result = new ConvertedMultimap<String, Object, WrappedSignedProperty>(GuavaWrappers.getBukkitMultimap(properties)) {
+
+            Multimap inner;
+            if (MinecraftVersion.v1_21_9.atOrAbove()) {
+                inner = properties;
+            } else {
+                inner = GuavaWrappers.getBukkitMultimap(properties);
+            }
+
+            result = new ConvertedMultimap<String, Object, WrappedSignedProperty>(inner) {
                 @Override
                 protected Object toInner(WrappedSignedProperty outer) {
                     return outer.handle;

src/main/java/com/comphenix/protocol/wrappers/WrappedKnownPack.java

@@ -0,0 +1,95 @@
+package com.comphenix.protocol.wrappers;
+
+import com.comphenix.protocol.reflect.EquivalentConverter;
+import com.comphenix.protocol.reflect.accessors.Accessors;
+import com.comphenix.protocol.reflect.accessors.ConstructorAccessor;
+import com.comphenix.protocol.reflect.accessors.MethodAccessor;
+import com.comphenix.protocol.utility.MinecraftReflection;
+
+import java.util.Objects;
+
+/**
+ * Wrapper for {@code net.minecraft.server.packs.repository.KnownPack}.
+ */
+public final class WrappedKnownPack {
+
+    private static final Class<?> HANDLE_TYPE = MinecraftReflection.getMinecraftClass("server.packs.repository.KnownPack");
+    private static final ConstructorAccessor CONSTRUCTOR = Accessors.getConstructorAccessor(
+            HANDLE_TYPE,
+            String.class,
+            String.class,
+            String.class);
+    private static final MethodAccessor GET_NAMESPACE = Accessors.getMethodAccessor(HANDLE_TYPE, "namespace");
+    private static final MethodAccessor GET_ID = Accessors.getMethodAccessor(HANDLE_TYPE, "id");
+    private static final MethodAccessor GET_VERSION = Accessors.getMethodAccessor(HANDLE_TYPE, "version");
+
+    public static final EquivalentConverter<WrappedKnownPack> CONVERTER =
+            Converters.ignoreNull(new EquivalentConverter<>() {
+                @Override
+                public Object getGeneric(WrappedKnownPack specific) {
+                    return CONSTRUCTOR.invoke(specific.namespace, specific.id, specific.version);
+                }
+
+                @Override
+                public WrappedKnownPack getSpecific(Object generic) {
+                    return new WrappedKnownPack(
+                            (String) GET_NAMESPACE.invoke(generic),
+                            (String) GET_ID.invoke(generic),
+                            (String) GET_VERSION.invoke(generic));
+                }
+
+                @Override
+                public Class<WrappedKnownPack> getSpecificType() {
+                    return WrappedKnownPack.class;
+                }
+            });
+
+    private final String namespace;
+    private final String id;
+    private final String version;
+
+    public WrappedKnownPack(String namespace, String id, String version) {
+        this.namespace = namespace;
+        this.id = id;
+        this.version = version;
+    }
+
+    public String getNamespace() {
+        return namespace;
+    }
+
+    public String getId() {
+        return id;
+    }
+
+    public String getVersion() {
+        return version;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof WrappedKnownPack that)) {
+            return false;
+        }
+        return Objects.equals(namespace, that.namespace)
+                && Objects.equals(id, that.id)
+                && Objects.equals(version, that.version);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(namespace, id, version);
+    }
+
+    @Override
+    public String toString() {
+        return "WrappedKnownPack{"
+                + "namespace='" + namespace + '\''
+                + ", id='" + id + '\''
+                + ", version='" + version + '\''
+                + '}';
+    }
+}

src/main/java/com/comphenix/protocol/wrappers/WrappedLastSeenMessagesUpdate.java

@@ -0,0 +1,96 @@
+package com.comphenix.protocol.wrappers;
+
+import com.comphenix.protocol.reflect.EquivalentConverter;
+import com.comphenix.protocol.reflect.accessors.Accessors;
+import com.comphenix.protocol.reflect.accessors.ConstructorAccessor;
+import com.comphenix.protocol.reflect.accessors.MethodAccessor;
+import com.comphenix.protocol.utility.MinecraftReflection;
+
+import java.util.BitSet;
+import java.util.Objects;
+
+/**
+ * Wrapper for {@code LastSeenMessages.Update}.
+ */
+public final class WrappedLastSeenMessagesUpdate {
+
+    private static final Class<?> HANDLE_TYPE = MinecraftReflection.getMinecraftClass("network.chat.LastSeenMessages$Update");
+    private static final ConstructorAccessor CONSTRUCTOR = Accessors.getConstructorAccessor(
+            HANDLE_TYPE,
+            int.class,
+            BitSet.class,
+            byte.class);
+    private static final MethodAccessor GET_OFFSET = Accessors.getMethodAccessor(HANDLE_TYPE, "offset");
+    private static final MethodAccessor GET_ACKNOWLEDGED = Accessors.getMethodAccessor(HANDLE_TYPE, "acknowledged");
+    private static final MethodAccessor GET_CHECKSUM = Accessors.getMethodAccessor(HANDLE_TYPE, "checksum");
+
+    public static final EquivalentConverter<WrappedLastSeenMessagesUpdate> CONVERTER =
+            Converters.ignoreNull(new EquivalentConverter<>() {
+                @Override
+                public Object getGeneric(WrappedLastSeenMessagesUpdate specific) {
+                    return CONSTRUCTOR.invoke(specific.offset, specific.getAcknowledged(), specific.checksum);
+                }
+
+                @Override
+                public WrappedLastSeenMessagesUpdate getSpecific(Object generic) {
+                    return new WrappedLastSeenMessagesUpdate(
+                            (int) GET_OFFSET.invoke(generic),
+                            (BitSet) GET_ACKNOWLEDGED.invoke(generic),
+                            (byte) GET_CHECKSUM.invoke(generic));
+                }
+
+                @Override
+                public Class<WrappedLastSeenMessagesUpdate> getSpecificType() {
+                    return WrappedLastSeenMessagesUpdate.class;
+                }
+            });
+
+    private final int offset;
+    private final BitSet acknowledged;
+    private final byte checksum;
+
+    public WrappedLastSeenMessagesUpdate(int offset, BitSet acknowledged, byte checksum) {
+        this.offset = offset;
+        this.acknowledged = (BitSet) acknowledged.clone();
+        this.checksum = checksum;
+    }
+
+    public int getOffset() {
+        return offset;
+    }
+
+    public BitSet getAcknowledged() {
+        return (BitSet) acknowledged.clone();
+    }
+
+    public byte getChecksum() {
+        return checksum;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof WrappedLastSeenMessagesUpdate that)) {
+            return false;
+        }
+        return offset == that.offset
+                && checksum == that.checksum
+                && Objects.equals(acknowledged, that.acknowledged);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(offset, acknowledged, checksum);
+    }
+
+    @Override
+    public String toString() {
+        return "WrappedLastSeenMessagesUpdate{"
+                + "offset=" + offset
+                + ", acknowledged=" + acknowledged
+                + ", checksum=" + checksum
+                + '}';
+    }
+}

src/main/java/com/comphenix/protocol/wrappers/WrappedLevelChunkData.java

@@ -4,7 +4,9 @@ import java.lang.reflect.Field;
 import java.util.ArrayList;
 import java.util.BitSet;
 import java.util.List;
+import java.util.Map;
 
+import com.comphenix.protocol.reflect.EquivalentConverter;
 import org.jetbrains.annotations.Nullable;
 
 import com.comphenix.protocol.injector.StructureCache;
@@ -41,6 +43,7 @@ public final class WrappedLevelChunkData {
 
         private static final FieldAccessor BLOCK_ENTITIES_DATA_ACCESSOR;
         private static final FieldAccessor HEIGHTMAPS_ACCESSOR;
+        private static final EquivalentConverter<Map<EnumWrappers.HeightmapType, long[]>> HEIGHTMAPS_CONVERTER;
         private static final FieldAccessor BUFFER_ACCESSOR;
 
         static {
@@ -54,9 +57,17 @@ public final class WrappedLevelChunkData {
             BLOCK_ENTITIES_DATA_ACCESSOR = Accessors.getFieldAccessor(reflection.getField(FuzzyFieldContract.newBuilder()
                     .typeExact(List.class)
                     .build()));
-            HEIGHTMAPS_ACCESSOR = Accessors.getFieldAccessor(reflection.getField(FuzzyFieldContract.newBuilder()
-                    .typeExact(MinecraftReflection.getNBTCompoundClass())
-                    .build()));
+            if (MinecraftVersion.v1_21_5.atOrAbove()) {
+                HEIGHTMAPS_ACCESSOR = Accessors.getFieldAccessor(reflection.getField(FuzzyFieldContract.newBuilder()
+                        .typeExact(Map.class)
+                        .build()));
+                HEIGHTMAPS_CONVERTER = BukkitConverters.getMapConverter(EnumWrappers.getHeightmapTypeConverter(), Converters.passthrough(long[].class));
+            } else {
+                HEIGHTMAPS_ACCESSOR = Accessors.getFieldAccessor(reflection.getField(FuzzyFieldContract.newBuilder()
+                        .typeExact(MinecraftReflection.getNBTCompoundClass())
+                        .build()));
+                HEIGHTMAPS_CONVERTER = null;
+            }
             BUFFER_ACCESSOR = Accessors.getFieldAccessor(reflection.getField(FuzzyFieldContract.newBuilder().typeExact(byte[].class).build()));
         }
 
@@ -68,22 +79,50 @@ public final class WrappedLevelChunkData {
 
         /**
          * The heightmap of this chunk.
+         * <p>
+         * Removed in Minecraft 1.21.5.
          *
          * @return an NBT-Tag
+         * @deprecated Use {@link ChunkData#getHeightmaps()} instead.
          */
+        @Deprecated
         public NbtCompound getHeightmapsTag() {
             return NbtFactory.fromNMSCompound(HEIGHTMAPS_ACCESSOR.get(handle));
         }
 
         /**
          * Sets the heightmap tag of this chunk.
+         * <p>
+         * Removed in Minecraft 1.21.5.
          *
          * @param heightmapsTag the new heightmaps tag.
+         * @deprecated Use {@link ChunkData#setHeightmaps(Map)} instead.
          */
+        @Deprecated
         public void setHeightmapsTag(NbtCompound heightmapsTag) {
             HEIGHTMAPS_ACCESSOR.set(handle, NbtFactory.fromBase(heightmapsTag).getHandle());
         }
 
+        /**
+         * The heightmap of this chunk.
+         *
+         * @return a map containing the heightmaps
+         */
+        public Map<EnumWrappers.HeightmapType, long[]> getHeightmaps() {
+            return HEIGHTMAPS_CONVERTER.getSpecific(HEIGHTMAPS_ACCESSOR.get(handle));
+        }
+
+        /**
+         * Sets the heightmap tag of this chunk.
+         * <p>
+         * Removed in Minecraft 1.21.5.
+         *
+         * @param heightmaps the new heightmaps.
+         */
+        public void setHeightmaps(Map<EnumWrappers.HeightmapType, long[]> heightmaps) {
+            HEIGHTMAPS_ACCESSOR.set(handle, HEIGHTMAPS_CONVERTER.getGeneric(heightmaps));
+        }
+
         /**
          * The actual structural data of this chunk as bytes.
          *
@@ -130,12 +169,16 @@ public final class WrappedLevelChunkData {
 
         /**
          * Creates a new wrapper using predefined values.
+         * <p>
+         * Removed in Minecraft 1.21.5.
          *
          * @param heightmapsTag   the heightmaps tag
          * @param buffer          the buffer
          * @param blockEntityInfo a list of wrapped block entities
          * @return a newly created wrapper
+         * @deprecated Use {@link ChunkData#fromValues(Map, byte[], List)} instead.
          */
+        @Deprecated
         public static ChunkData fromValues(NbtCompound heightmapsTag, byte[] buffer, List<BlockEntityInfo> blockEntityInfo) {
             ChunkData data = new ChunkData(LEVEL_CHUNK_PACKET_DATA_CONSTRUCTOR.invoke(StructureCache.newNullDataSerializer(), 0, 0));
 
@@ -145,6 +188,24 @@ public final class WrappedLevelChunkData {
 
             return new ChunkData(data);
         }
+
+        /**
+         * Creates a new wrapper using predefined values.
+         *
+         * @param heightmaps      the heightmaps
+         * @param buffer          the buffer
+         * @param blockEntityInfo a list of wrapped block entities
+         * @return a newly created wrapper
+         */
+        public static ChunkData fromValues(Map<EnumWrappers.HeightmapType, long[]> heightmaps, byte[] buffer, List<BlockEntityInfo> blockEntityInfo) {
+            ChunkData data = new ChunkData(LEVEL_CHUNK_PACKET_DATA_CONSTRUCTOR.invoke(StructureCache.newNullDataSerializer(), 0, 0));
+
+            data.setHeightmaps(heightmaps);
+            data.setBuffer(buffer);
+            data.setBlockEntityInfo(blockEntityInfo);
+
+            return new ChunkData(data);
+        }
     }
 
     /**

src/main/java/com/comphenix/protocol/wrappers/WrappedMinecartStep.java

@@ -0,0 +1,126 @@
+package com.comphenix.protocol.wrappers;
+
+import com.comphenix.protocol.reflect.EquivalentConverter;
+import com.comphenix.protocol.reflect.accessors.Accessors;
+import com.comphenix.protocol.reflect.accessors.ConstructorAccessor;
+import com.comphenix.protocol.reflect.accessors.MethodAccessor;
+import com.comphenix.protocol.utility.MinecraftReflection;
+import org.bukkit.util.Vector;
+
+import java.util.Objects;
+
+/**
+ * Wrapper for {@code NewMinecartBehavior.MinecartStep}.
+ */
+public final class WrappedMinecartStep {
+
+    private static final Class<?> HANDLE_TYPE = MinecraftReflection.getMinecraftClass(
+            "world.entity.vehicle.minecart.NewMinecartBehavior$MinecartStep");
+    private static final ConstructorAccessor CONSTRUCTOR = Accessors.getConstructorAccessor(
+            HANDLE_TYPE,
+            MinecraftReflection.getVec3DClass(),
+            MinecraftReflection.getVec3DClass(),
+            float.class,
+            float.class,
+            float.class);
+    private static final MethodAccessor GET_POSITION = Accessors.getMethodAccessor(HANDLE_TYPE, "position");
+    private static final MethodAccessor GET_MOVEMENT = Accessors.getMethodAccessor(HANDLE_TYPE, "movement");
+    private static final MethodAccessor GET_Y_ROT = Accessors.getMethodAccessor(HANDLE_TYPE, "yRot");
+    private static final MethodAccessor GET_X_ROT = Accessors.getMethodAccessor(HANDLE_TYPE, "xRot");
+    private static final MethodAccessor GET_WEIGHT = Accessors.getMethodAccessor(HANDLE_TYPE, "weight");
+
+    public static final EquivalentConverter<WrappedMinecartStep> CONVERTER =
+            Converters.ignoreNull(new EquivalentConverter<>() {
+                @Override
+                public Object getGeneric(WrappedMinecartStep specific) {
+                    EquivalentConverter<Vector> vectorConverter = BukkitConverters.getVectorConverter();
+                    return CONSTRUCTOR.invoke(
+                            vectorConverter.getGeneric(specific.position),
+                            vectorConverter.getGeneric(specific.movement),
+                            specific.yRot,
+                            specific.xRot,
+                            specific.weight);
+                }
+
+                @Override
+                public WrappedMinecartStep getSpecific(Object generic) {
+                    EquivalentConverter<Vector> vectorConverter = BukkitConverters.getVectorConverter();
+                    return new WrappedMinecartStep(
+                            vectorConverter.getSpecific(GET_POSITION.invoke(generic)),
+                            vectorConverter.getSpecific(GET_MOVEMENT.invoke(generic)),
+                            (float) GET_Y_ROT.invoke(generic),
+                            (float) GET_X_ROT.invoke(generic),
+                            (float) GET_WEIGHT.invoke(generic));
+                }
+
+                @Override
+                public Class<WrappedMinecartStep> getSpecificType() {
+                    return WrappedMinecartStep.class;
+                }
+            });
+
+    private final Vector position;
+    private final Vector movement;
+    private final float yRot;
+    private final float xRot;
+    private final float weight;
+
+    public WrappedMinecartStep(Vector position, Vector movement, float yRot, float xRot, float weight) {
+        this.position = position.clone();
+        this.movement = movement.clone();
+        this.yRot = yRot;
+        this.xRot = xRot;
+        this.weight = weight;
+    }
+
+    public Vector getPosition() {
+        return position.clone();
+    }
+
+    public Vector getMovement() {
+        return movement.clone();
+    }
+
+    public float getYRot() {
+        return yRot;
+    }
+
+    public float getXRot() {
+        return xRot;
+    }
+
+    public float getWeight() {
+        return weight;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof WrappedMinecartStep that)) {
+            return false;
+        }
+        return Float.compare(yRot, that.yRot) == 0
+                && Float.compare(xRot, that.xRot) == 0
+                && Float.compare(weight, that.weight) == 0
+                && Objects.equals(position, that.position)
+                && Objects.equals(movement, that.movement);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(position, movement, yRot, xRot, weight);
+    }
+
+    @Override
+    public String toString() {
+        return "WrappedMinecartStep{"
+                + "position=" + position
+                + ", movement=" + movement
+                + ", yRot=" + yRot
+                + ", xRot=" + xRot
+                + ", weight=" + weight
+                + '}';
+    }
+}

src/main/java/com/comphenix/protocol/wrappers/WrappedParticle.java

@@ -183,59 +183,80 @@ public class WrappedParticle<T> {
     }
 
     private static Object getRedstone(Object handle) {
-        int r, g, b;
-        float size;
+        Color color;
+        float scale;
 
-        if (MinecraftVersion.FEATURE_PREVIEW_UPDATE.atOrAbove()) {
-            StructureModifier<Object> modifier = new StructureModifier<>(handle.getClass()).withTarget(handle);
+        StructureModifier<Object> modifier = new StructureModifier<>(handle.getClass()).withTarget(handle);
+
+        if (MinecraftVersion.v1_21_2.atOrAbove()) {
+            int rgb = (int) modifier.withType(int.class).read(0);
+            color = Color.fromRGB(rgb);
+            scale = (float) modifier.withType(float.class).read(0);
+        } else if (MinecraftVersion.FEATURE_PREVIEW_UPDATE.atOrAbove()) {
             org.joml.Vector3f rgb = (org.joml.Vector3f) modifier.withType(org.joml.Vector3f.class).read(0);
 
-            r = (int) (rgb.x() * 255);
-            g = (int) (rgb.y() * 255);
-            b = (int) (rgb.z() * 255);
-            size = (float) modifier.withType(float.class).read(0);
+            int red = (int) (rgb.x() * 255);
+            int green = (int) (rgb.y() * 255);
+            int blue = (int) (rgb.z() * 255);
+
+            color = Color.fromRGB(red, green, blue);
+            scale = (float) modifier.withType(float.class).read(0);
         } else if (MinecraftVersion.CAVES_CLIFFS_1.atOrAbove()) {
             if (VECTOR_3FA == null) {
                 VECTOR_3FA = MinecraftReflection.getLibraryClass("com.mojang.math.Vector3fa");
             }
 
-            StructureModifier<Object> modifier = new StructureModifier<>(handle.getClass()).withTarget(handle);
-
             Object rgb = modifier.withType(VECTOR_3FA).read(0);
             StructureModifier<Object> rgbModifier = new StructureModifier<>(VECTOR_3FA).withTarget(rgb);
 
-            r = (int) (rgbModifier.<Float>withType(float.class).read(0) * 255);
-            g = (int) (rgbModifier.<Float>withType(float.class).read(1) * 255);
-            b = (int) (rgbModifier.<Float>withType(float.class).read(2) * 255);
-            size = (float) modifier.withType(float.class).read(0);
+            int red = (int) (rgbModifier.<Float>withType(float.class).read(0) * 255);
+            int green = (int) (rgbModifier.<Float>withType(float.class).read(1) * 255);
+            int blue = (int) (rgbModifier.<Float>withType(float.class).read(2) * 255);
+
+            color = Color.fromRGB(red, green, blue);
+            scale = (float) modifier.withType(float.class).read(0);
         } else {
-            StructureModifier<Float> modifier = new StructureModifier<>(handle.getClass()).withTarget(handle).withType(float.class);
-            r = (int) (modifier.read(0) * 255);
-            g = (int) (modifier.read(1) * 255);
-            b = (int) (modifier.read(2) * 255);
-            size = modifier.read(3);
+            StructureModifier<Float> floatModifier = modifier.withType(float.class);
+
+            int red = (int) (floatModifier.read(0) * 255);
+            int green = (int) (floatModifier.read(1) * 255);
+            int blue = (int) (floatModifier.read(2) * 255);
+
+            color = Color.fromRGB(red, green, blue);
+            scale = floatModifier.read(3);
         }
 
-        return new Particle.DustOptions(Color.fromRGB(r, g, b), size);
+        return new Particle.DustOptions(color, scale);
     }
 
     private static Object getDustTransition(Object handle) {
-        int fromR, fromG, fromB, toR, toG, toB;
-        float size;
+        Color fromColor, toColor;
+        float scale;
 
-        if (MinecraftVersion.FEATURE_PREVIEW_UPDATE.atOrAbove()) {
+        if (MinecraftVersion.v1_21_2.atOrAbove()) {
+            StructureModifier<Object> modifier = new StructureModifier<>(handle.getClass()).withTarget(handle);
+            int fromRgb = (int) modifier.withType(int.class).read(0);
+            fromColor = Color.fromRGB(fromRgb);
+
+            int toRgb = (int) modifier.withType(int.class).read(1);
+            toColor = Color.fromRGB(toRgb);
+
+            scale = (float) modifier.withType(float.class).read(0);
+        } else if (MinecraftVersion.FEATURE_PREVIEW_UPDATE.atOrAbove()) {
             StructureModifier<Object> modifier = new StructureModifier<>(handle.getClass()).withTarget(handle);
             org.joml.Vector3f toRGB = (org.joml.Vector3f) modifier.withType(org.joml.Vector3f.class).read(1);
             org.joml.Vector3f fromRGB = (org.joml.Vector3f) modifier.withType(org.joml.Vector3f.class).read(0);
-            size = (float) modifier.withType(float.class).read(0);
+            scale = (float) modifier.withType(float.class).read(0);
 
-            fromR = (int) (fromRGB.x() * 255);
-            fromG = (int) (fromRGB.y() * 255);
-            fromB = (int) (fromRGB.z() * 255);
+            int fromR = (int) (fromRGB.x() * 255);
+            int fromG = (int) (fromRGB.y() * 255);
+            int fromB = (int) (fromRGB.z() * 255);
+            fromColor = Color.fromRGB(fromR, fromG, fromB);
 
-            toR = (int) (toRGB.x() * 255);
-            toG = (int) (toRGB.y() * 255);
-            toB = (int) (toRGB.z() * 255);
+            int toR = (int) (toRGB.x() * 255);
+            int toG = (int) (toRGB.y() * 255);
+            int toB = (int) (toRGB.z() * 255);
+            toColor = Color.fromRGB(toR, toG, toB);
         } else if (MinecraftVersion.CAVES_CLIFFS_1.atOrAbove()) {
             if (VECTOR_3FA == null) {
                 VECTOR_3FA = MinecraftReflection.getLibraryClass("com.mojang.math.Vector3fa");
@@ -245,37 +266,42 @@ public class WrappedParticle<T> {
 
             Object toRGB = modifier.withType(VECTOR_3FA).read(0);
             Object fromRGB = modifier.withType(VECTOR_3FA).read(1);
-            size = (float) modifier.withType(float.class).read(0);
+            scale = (float) modifier.withType(float.class).read(0);
             StructureModifier<Object> rgbModifier = new StructureModifier<>(VECTOR_3FA).withTarget(fromRGB);
             StructureModifier<Object> rgbModifier2 = new StructureModifier<>(VECTOR_3FA).withTarget(toRGB);
 
-            fromR = (int) (rgbModifier.<Float>withType(float.class).read(0) * 255);
-            fromG = (int) (rgbModifier.<Float>withType(float.class).read(1) * 255);
-            fromB = (int) (rgbModifier.<Float>withType(float.class).read(2) * 255);
+            int fromR = (int) (rgbModifier.<Float>withType(float.class).read(0) * 255);
+            int fromG = (int) (rgbModifier.<Float>withType(float.class).read(1) * 255);
+            int fromB = (int) (rgbModifier.<Float>withType(float.class).read(2) * 255);
+            fromColor = Color.fromRGB(fromR, fromG, fromB);
 
-            toR = (int) (rgbModifier2.<Float>withType(float.class).read(0) * 255);
-            toG = (int) (rgbModifier2.<Float>withType(float.class).read(1) * 255);
-            toB = (int) (rgbModifier2.<Float>withType(float.class).read(2) * 255);
+            int toR = (int) (rgbModifier2.<Float>withType(float.class).read(0) * 255);
+            int toG = (int) (rgbModifier2.<Float>withType(float.class).read(1) * 255);
+            int toB = (int) (rgbModifier2.<Float>withType(float.class).read(2) * 255);
+            toColor = Color.fromRGB(toR, toG, toB);
         } else {
             StructureModifier<Float> modifier = new StructureModifier<>(handle.getClass()).withTarget(handle).withType(float.class);
-            toR = (int) (modifier.read(0) * 255);
-            toG = (int) (modifier.read(1) * 255);
-            toB = (int) (modifier.read(2) * 255);
-            size = modifier.read(3);
-            fromR = (int) (modifier.read(4) * 255);
-            fromG = (int) (modifier.read(5) * 255);
-            fromB = (int) (modifier.read(6) * 255);
+            int toR = (int) (modifier.read(0) * 255);
+            int toG = (int) (modifier.read(1) * 255);
+            int toB = (int) (modifier.read(2) * 255);
+            toColor = Color.fromRGB(toR, toG, toB);
+
+            scale = modifier.read(3);
+
+            int fromR = (int) (modifier.read(4) * 255);
+            int fromG = (int) (modifier.read(5) * 255);
+            int fromB = (int) (modifier.read(6) * 255);
+            fromColor = Color.fromRGB(fromR, fromG, fromB);
         }
 
-        return new Particle.DustTransition(Color.fromRGB(fromR, fromG, fromB), Color.fromRGB(toR, toG, toB), size);
+        return new Particle.DustTransition(fromColor, toColor, scale);
     }
 
     public static <T> WrappedParticle<T> create(Particle particle, T data) {
         ensureMethods();
 
         Object bukkitData = data;
-        if (data instanceof WrappedBlockData) {
-            WrappedBlockData blockData = (WrappedBlockData) data;
+        if (data instanceof WrappedBlockData blockData) {
             bukkitData = toCraftData.invoke(null, blockData.getHandle());
         }
 

src/main/java/com/comphenix/protocol/wrappers/WrappedPositionMoveRotation.java

@@ -0,0 +1,183 @@
+package com.comphenix.protocol.wrappers;
+
+import com.comphenix.protocol.reflect.EquivalentConverter;
+import com.comphenix.protocol.reflect.StructureModifier;
+import com.comphenix.protocol.reflect.accessors.Accessors;
+import com.comphenix.protocol.reflect.accessors.ConstructorAccessor;
+import com.comphenix.protocol.utility.MinecraftReflection;
+
+import org.bukkit.util.Vector;
+
+/**
+ * Wrapper around the NMS {@code PositionMoveRotation} record, introduced in Minecraft 1.21.2.
+ * <p>
+ * This type is used in packets such as {@code ENTITY_TELEPORT} and {@code ENTITY_POSITION_SYNC}
+ * to represent combined position, movement delta and rotation.
+ * <p>
+ * Example usage:
+ * <pre>{@code
+ * WrappedPositionMoveRotation posRot = WrappedPositionMoveRotation.create(
+ *         new Vector(x, y, z),   // position
+ *         new Vector(0, 0, 0),   // deltaMovement
+ *         yaw,                   // yRot
+ *         pitch                  // xRot
+ * );
+ * packet.getPositionMoveRotation().write(0, posRot);
+ * }</pre>
+ */
+public class WrappedPositionMoveRotation extends AbstractWrapper {
+
+    private static Class<?> NMS_CLASS;
+    private static ConstructorAccessor CONSTRUCTOR;
+    private static StructureModifier<Object> BASE_MODIFIER;
+
+    private final StructureModifier<Object> modifier;
+
+    private WrappedPositionMoveRotation(Object handle) {
+        super(getNmsClass());
+        setHandle(handle);
+        this.modifier = getBaseModifier().withTarget(handle);
+    }
+
+    private static Class<?> getNmsClass() {
+        if (NMS_CLASS == null) {
+            NMS_CLASS = MinecraftReflection.getPositionMoveRotationClass();
+        }
+        return NMS_CLASS;
+    }
+
+    private static StructureModifier<Object> getBaseModifier() {
+        if (BASE_MODIFIER == null) {
+            BASE_MODIFIER = new StructureModifier<>(getNmsClass());
+        }
+        return BASE_MODIFIER;
+    }
+
+    private static ConstructorAccessor getConstructor() {
+        if (CONSTRUCTOR == null) {
+            CONSTRUCTOR = Accessors.getConstructorAccessor(
+                    getNmsClass(),
+                    MinecraftReflection.getVec3DClass(),
+                    MinecraftReflection.getVec3DClass(),
+                    float.class,
+                    float.class
+            );
+        }
+        return CONSTRUCTOR;
+    }
+
+    /**
+     * Creates a new {@code WrappedPositionMoveRotation} from the given NMS handle.
+     *
+     * @param handle - the NMS {@code PositionMoveRotation} instance.
+     * @return the wrapper.
+     */
+    public static WrappedPositionMoveRotation fromHandle(Object handle) {
+        return new WrappedPositionMoveRotation(handle);
+    }
+
+    /**
+     * Creates a new {@code WrappedPositionMoveRotation} with the given values.
+     *
+     * @param position      - the absolute position.
+     * @param deltaMovement - the movement delta (velocity).
+     * @param yRot          - the yaw rotation.
+     * @param xRot          - the pitch rotation.
+     * @return a new wrapper instance.
+     */
+    public static WrappedPositionMoveRotation create(Vector position, Vector deltaMovement, float yRot, float xRot) {
+        EquivalentConverter<Vector> conv = BukkitConverters.getVectorConverter();
+        Object handle = getConstructor().invoke(
+                conv.getGeneric(position),
+                conv.getGeneric(deltaMovement),
+                yRot,
+                xRot
+        );
+        return new WrappedPositionMoveRotation(handle);
+    }
+
+    /**
+     * Retrieves the absolute position component.
+     *
+     * @return the position as a Bukkit {@link Vector}.
+     */
+    public Vector getPosition() {
+        return modifier.withType(MinecraftReflection.getVec3DClass(), BukkitConverters.getVectorConverter()).read(0);
+    }
+
+    /**
+     * Sets the absolute position component.
+     *
+     * @param position - the new position.
+     */
+    public void setPosition(Vector position) {
+        modifier.withType(MinecraftReflection.getVec3DClass(), BukkitConverters.getVectorConverter()).write(0, position);
+    }
+
+    /**
+     * Retrieves the movement delta (velocity) component.
+     *
+     * @return the delta movement as a Bukkit {@link Vector}.
+     */
+    public Vector getDeltaMovement() {
+        return modifier.withType(MinecraftReflection.getVec3DClass(), BukkitConverters.getVectorConverter()).read(1);
+    }
+
+    /**
+     * Sets the movement delta (velocity) component.
+     *
+     * @param deltaMovement - the new delta movement.
+     */
+    public void setDeltaMovement(Vector deltaMovement) {
+        modifier.withType(MinecraftReflection.getVec3DClass(), BukkitConverters.getVectorConverter()).write(1, deltaMovement);
+    }
+
+    /**
+     * Retrieves the yaw rotation (y-axis rotation).
+     *
+     * @return the yaw as a float.
+     */
+    public float getYRot() {
+        StructureModifier<Float> floats = modifier.withType(float.class);
+        return floats.read(0);
+    }
+
+    /**
+     * Sets the yaw rotation (y-axis rotation).
+     *
+     * @param yRot - the new yaw value.
+     */
+    public void setYRot(float yRot) {
+        modifier.withType(float.class).write(0, yRot);
+    }
+
+    /**
+     * Retrieves the pitch rotation (x-axis rotation).
+     *
+     * @return the pitch as a float.
+     */
+    public float getXRot() {
+        StructureModifier<Float> floats = modifier.withType(float.class);
+        return floats.read(1);
+    }
+
+    /**
+     * Sets the pitch rotation (x-axis rotation).
+     *
+     * @param xRot - the new pitch value.
+     */
+    public void setXRot(float xRot) {
+        modifier.withType(float.class).write(1, xRot);
+    }
+
+    /**
+     * Returns an {@link EquivalentConverter} that converts between {@code WrappedPositionMoveRotation}
+     * and the underlying NMS handle.
+     *
+     * @return the converter.
+     */
+    public static EquivalentConverter<WrappedPositionMoveRotation> getConverter() {
+        return Converters.handle(AbstractWrapper::getHandle,
+                WrappedPositionMoveRotation::fromHandle, WrappedPositionMoveRotation.class);
+    }
+}

src/main/java/com/comphenix/protocol/wrappers/WrappedRegistry.java

@@ -1,28 +1,48 @@
 package com.comphenix.protocol.wrappers;
 
+import com.comphenix.protocol.ProtocolLogger;
+import com.comphenix.protocol.reflect.EquivalentConverter;
 import com.comphenix.protocol.reflect.FuzzyReflection;
 import com.comphenix.protocol.reflect.accessors.Accessors;
 import com.comphenix.protocol.reflect.accessors.MethodAccessor;
 import com.comphenix.protocol.reflect.fuzzy.FuzzyMatchers;
 import com.comphenix.protocol.reflect.fuzzy.FuzzyMethodContract;
 import com.comphenix.protocol.utility.MinecraftReflection;
+import com.comphenix.protocol.utility.MinecraftRegistryAccess;
 import com.comphenix.protocol.utility.MinecraftVersion;
 import com.google.common.collect.ImmutableMap;
+import org.jetbrains.annotations.Nullable;
 
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
 import java.lang.reflect.WildcardType;
+import java.util.Collections;
 import java.util.HashMap;
+import java.util.LinkedHashSet;
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 
 public class WrappedRegistry {
-    // map of NMS class to registry instance
+    // map of NMS class to registry instance (static/built-in registries)
     private static final Map<Class<?>, WrappedRegistry> REGISTRY;
 
+    // map of NMS class to ResourceKey for dynamic (datapack) registries
+    private static final Map<Class<?>, Object> DYNAMIC_REGISTRY_KEYS;
+
+    // ResourceKeys to try when generic metadata is unavailable or incomplete
+    private static final Set<Object> DYNAMIC_REGISTRY_FALLBACK_KEYS;
+
+    // cache of dynamically resolved registries
+    private static final Map<Class<?>, WrappedRegistry> DYNAMIC_REGISTRY_CACHE = new ConcurrentHashMap<>();
+    private static final Map<Object, WrappedRegistry> DYNAMIC_REGISTRY_KEY_CACHE = new ConcurrentHashMap<>();
+
+    // RegistryAccess.lookup(ResourceKey) -> Optional<Registry>
+    private static final MethodAccessor REGISTRY_ACCESS_LOOKUP;
+
     private static final MethodAccessor GET;
     private static final MethodAccessor GET_ID;
     private static final MethodAccessor GET_KEY;
@@ -78,13 +98,69 @@ public class WrappedRegistry {
                             }
                         }
                     }
-                } catch (ReflectiveOperationException ignored) {
+                } catch (ReflectiveOperationException ex) {
+                    ProtocolLogger.debug("Failed to inspect built-in registry field " + field, ex);
                 }
             }
         }
 
         REGISTRY = ImmutableMap.copyOf(regMap);
 
+        // Build dynamic registry key map from Registries class (ResourceKey<Registry<T>> fields)
+        // These cover datapack registries like DamageType that are not in BuiltInRegistries
+        Map<Class<?>, Object> dynKeyMap = new HashMap<>();
+        // LinkedHashSet so the generics-stripped fallback iterates in declaration order
+        // on Registries, giving deterministic resolution across JVM runs.
+        Set<Object> dynKeyFallbacks = new LinkedHashSet<>();
+        try {
+            Class<?> registriesClass = MinecraftReflection.getNullableNMS("core.registries.Registries");
+            Class<?> resourceKeyClass = MinecraftReflection.getResourceKey();
+            if (registriesClass != null) {
+                for (Field field : registriesClass.getFields()) {
+                    if (!Modifier.isStatic(field.getModifiers())) continue;
+                    if (!resourceKeyClass.isAssignableFrom(field.getType())) continue;
+
+                    Object registryKey;
+                    try {
+                        registryKey = field.get(null);
+                    } catch (ReflectiveOperationException ex) {
+                        ProtocolLogger.debug("Failed to read dynamic registry key field " + field, ex);
+                        continue;
+                    }
+                    dynKeyFallbacks.add(registryKey);
+
+                    // looking for ResourceKey<Registry<T>> fields
+                    Class<?> entryClass = getRegistryEntryClass(field, iRegistry);
+                    if (entryClass != null && !regMap.containsKey(entryClass)) {
+                        dynKeyMap.put(entryClass, registryKey);
+                    }
+                }
+            }
+        } catch (Exception ex) {
+            ProtocolLogger.debug("Failed to inspect dynamic registry keys", ex);
+        }
+        DYNAMIC_REGISTRY_KEYS = ImmutableMap.copyOf(dynKeyMap);
+        DYNAMIC_REGISTRY_FALLBACK_KEYS = Collections.unmodifiableSet(dynKeyFallbacks);
+
+        // Set up RegistryAccess.lookup(ResourceKey) -> Optional<Registry>
+        MethodAccessor registryAccessLookup = null;
+        try {
+            Class<?> registryAccessClass = MinecraftReflection.getRegistryAccessClass();
+            if (registryAccessClass != null) {
+                registryAccessLookup = Accessors.getMethodAccessor(
+                        FuzzyReflection.fromClass(registryAccessClass, false).getMethod(
+                                FuzzyMethodContract.newBuilder()
+                                        .parameterExactArray(MinecraftReflection.getResourceKey())
+                                        .returnTypeExact(Optional.class)
+                                        .build()
+                        )
+                );
+            }
+        } catch (Exception ex) {
+            ProtocolLogger.debug("Failed to find RegistryAccess.lookup(ResourceKey)", ex);
+        }
+        REGISTRY_ACCESS_LOOKUP = registryAccessLookup;
+
         FuzzyReflection fuzzy = FuzzyReflection.fromClass(iRegistry, false);
         GET = Accessors.getMethodAccessor(fuzzy.getMethod(FuzzyMethodContract
                 .newBuilder()
@@ -117,17 +193,53 @@ public class WrappedRegistry {
                         .returnTypeExact(MinecraftReflection.getHolderClass())
                         .requireModifier(Modifier.PUBLIC)
                         .build()));
-            } catch (IllegalArgumentException ignored) {
+            } catch (IllegalArgumentException ex) {
+                ProtocolLogger.debug("Failed to find Registry.getHolder method", ex);
             }
         }
 
         GET_HOLDER = getHolder;
     }
 
+    @Nullable
+    private static Class<?> getRegistryEntryClass(Field field, Class<?> iRegistry) {
+        Type genType = field.getGenericType();
+        if (!(genType instanceof ParameterizedType)) return null;
+        ParameterizedType outer = (ParameterizedType) genType;
+        if (outer.getActualTypeArguments().length != 1) return null;
+
+        Type innerType = outer.getActualTypeArguments()[0];
+        if (!(innerType instanceof ParameterizedType)) return null;
+        ParameterizedType registryType = (ParameterizedType) innerType;
+        if (!(registryType.getRawType() instanceof Class<?>)) return null;
+
+        Class<?> rawRegistry = (Class<?>) registryType.getRawType();
+        if (iRegistry != null && !iRegistry.isAssignableFrom(rawRegistry)) return null;
+        if (registryType.getActualTypeArguments().length != 1) return null;
+
+        Type entryType = registryType.getActualTypeArguments()[0];
+        if (entryType instanceof Class<?>) {
+            return (Class<?>) entryType;
+        } else if (entryType instanceof ParameterizedType) {
+            Type raw = ((ParameterizedType) entryType).getRawType();
+            if (raw instanceof Class<?>) return (Class<?>) raw;
+        }
+        return null;
+    }
+
     private final Object handle;
 
+    /** The NMS {@code ResourceKey<Registry<T>>} for this registry, if known. */
+    @Nullable
+    private final Object registryKey;
+
     private WrappedRegistry(Object handle) {
+        this(handle, null);
+    }
+
+    private WrappedRegistry(Object handle, @Nullable Object registryKey) {
         this.handle = handle;
+        this.registryKey = registryKey;
     }
 
     public Object get(MinecraftKey key) {
@@ -155,6 +267,10 @@ public class WrappedRegistry {
     }
 
     public Object getHolder(Object generic) {
+        if (GET_HOLDER == null) {
+            throw new UnsupportedOperationException(
+                    "Registry holder conversion is not available on this Minecraft version");
+        }
         return GET_HOLDER.invoke(handle, generic);
     }
 
@@ -170,7 +286,193 @@ public class WrappedRegistry {
         return getRegistry(MinecraftReflection.getSoundEffectClass());
     }
 
+    // Sentinel for negative dynamic-registry lookups. ConcurrentHashMap forbids null
+    // values, so we cache this to avoid re-walking every fallback registry on every miss.
+    private static final WrappedRegistry MISS_SENTINEL = new WrappedRegistry(new Object());
+
     public static WrappedRegistry getRegistry(Class<?> type) {
-        return REGISTRY.get(type);
+        WrappedRegistry registry = REGISTRY.get(type);
+        if (registry != null) {
+            return registry;
+        }
+
+        // Fall back to dynamic (datapack) registry lookup via RegistryAccess
+        WrappedRegistry cached = DYNAMIC_REGISTRY_CACHE.computeIfAbsent(type, t -> {
+            Object resourceKey = DYNAMIC_REGISTRY_KEYS.get(t);
+            WrappedRegistry dynamicRegistry = lookupDynamicRegistry(resourceKey);
+            if (dynamicRegistry != null) {
+                return dynamicRegistry;
+            }
+
+            WrappedRegistry byValueType = findDynamicRegistryByValueType(t);
+            return byValueType != null ? byValueType : MISS_SENTINEL;
+        });
+        return cached == MISS_SENTINEL ? null : cached;
+    }
+
+    @Nullable
+    private static WrappedRegistry findDynamicRegistryByValueType(Class<?> type) {
+        for (Object resourceKey : DYNAMIC_REGISTRY_FALLBACK_KEYS) {
+            WrappedRegistry registry = lookupDynamicRegistry(resourceKey);
+            if (registry != null && registryContainsValueType(registry.handle, type)) {
+                return registry;
+            }
+        }
+        return null;
+    }
+
+    private static boolean registryContainsValueType(Object registryHandle, Class<?> type) {
+        if (!(registryHandle instanceof Iterable<?> iterable)) {
+            return false;
+        }
+
+        for (Object entry : iterable) {
+            if (type.isInstance(entry)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    @Nullable
+    private static WrappedRegistry lookupDynamicRegistry(@Nullable Object resourceKey) {
+        if (resourceKey == null || REGISTRY_ACCESS_LOOKUP == null) {
+            return null;
+        }
+
+        return DYNAMIC_REGISTRY_KEY_CACHE.computeIfAbsent(resourceKey, key -> {
+            Object registryAccess = MinecraftRegistryAccess.get();
+            if (registryAccess == null) {
+                return null;
+            }
+
+            Optional<?> optRegistry = (Optional<?>) REGISTRY_ACCESS_LOOKUP.invoke(registryAccess, key);
+            if (optRegistry == null || optRegistry.isEmpty()) {
+                return null;
+            }
+
+            return new WrappedRegistry(optRegistry.get(), key);
+        });
+    }
+
+    // -------------------------------------------------------------------------
+    // ResourceKey helpers
+    // -------------------------------------------------------------------------
+
+    /**
+     * Returns the NMS {@code ResourceKey<Registry<T>>} that identifies this registry,
+     * or {@code null} if it is not known (e.g. for built-in registries resolved only
+     * by type scanning).
+     */
+    @Nullable
+    public Object getRegistryKey() {
+        return registryKey;
+    }
+
+    /**
+     * Converts a {@link MinecraftKey} entry location to the corresponding NMS
+     * {@code ResourceKey<T>} scoped to this registry.
+     *
+     * @param key the entry identifier (e.g. {@code minecraft:diamond})
+     * @return the NMS {@code ResourceKey<T>} handle
+     * @throws IllegalStateException if this registry's own key is not known
+     */
+    public Object toResourceKey(MinecraftKey key) {
+        if (registryKey == null) {
+            throw new IllegalStateException("Registry key is not known for this WrappedRegistry instance");
+        }
+        return WrappedResourceKey.of(registryKey, key).getHandle();
+    }
+
+    /**
+     * Converts a NMS {@code ResourceKey<T>} back to the {@link MinecraftKey}
+     * representing the entry location.
+     *
+     * @param nmsResourceKey the NMS {@code ResourceKey} object
+     * @return the entry identifier
+     */
+    public static MinecraftKey fromResourceKey(Object nmsResourceKey) {
+        return WrappedResourceKey.fromHandle(nmsResourceKey).getLocation();
+    }
+
+    /**
+     * Returns an {@link EquivalentConverter} between
+     * {@link MinecraftKey} and NMS {@code ResourceKey<T>} for this registry.
+     *
+     * @throws IllegalStateException if this registry's own key is not known
+     */
+    public EquivalentConverter<MinecraftKey> resourceKeyConverter() {
+        if (registryKey == null) {
+            throw new IllegalStateException("Registry key is not known for this WrappedRegistry instance");
+        }
+        return WrappedResourceKey.converterFor(registryKey);
+    }
+
+    /**
+     * Returns an {@link EquivalentConverter} between
+     * {@link MinecraftKey} and the NMS registry value type {@code T} (e.g. {@code MenuType<?>},
+     * {@code SoundEvent}). The converter resolves both directions through this registry's
+     * {@code get(ResourceLocation)} / {@code getKey(value)} methods.
+     *
+     * <p>Use this for fields whose declared NMS type is the registry value itself, as opposed
+     * to {@code ResourceKey<T>} (use {@link #resourceKeyConverter()}) or {@code Holder<T>}
+     * (use {@link Converters#holder}).
+     */
+    public EquivalentConverter<MinecraftKey> valueConverter() {
+        final WrappedRegistry self = this;
+        return new EquivalentConverter<>() {
+            @Override
+            public Object getGeneric(MinecraftKey specific) {
+                return specific == null ? null : self.get(specific);
+            }
+
+            @Override
+            public MinecraftKey getSpecific(Object generic) {
+                return generic == null ? null : self.getKey(generic);
+            }
+
+            @Override
+            public Class<MinecraftKey> getSpecificType() {
+                return MinecraftKey.class;
+            }
+        };
+    }
+
+    // -------------------------------------------------------------------------
+    // Named registry accessors
+    // -------------------------------------------------------------------------
+
+    /**
+     * Returns a {@link WrappedRegistry} backed by the NMS {@code GameRule} registry
+     * ({@code Registries.GAME_RULE}).  The returned instance supports
+     * {@link #toResourceKey(MinecraftKey)} and {@link #resourceKeyConverter()}.
+     *
+     * @return the game-rule registry, or {@code null} if unavailable at this time
+     */
+    @Nullable
+    public static WrappedRegistry getGameRuleRegistry() {
+        return getRegistryByNmsKey("core.registries.Registries", "GAME_RULE");
+    }
+
+    /**
+     * Looks up a registry by the name of a static {@code ResourceKey<Registry<T>>}
+     * field on the NMS {@code Registries} class.
+     *
+     * @param registriesClassName the NMS class name (e.g. {@code "core.registries.Registries"})
+     * @param fieldName           the field name on that class (e.g. {@code "GAME_RULE"})
+     * @return a {@link WrappedRegistry} with both the handle and the registry key set,
+     *         or {@code null} if the lookup fails
+     */
+    @Nullable
+    public static WrappedRegistry getRegistryByNmsKey(String registriesClassName, String fieldName) {
+        try {
+            Class<?> registriesClass = MinecraftReflection.getMinecraftClass(registriesClassName);
+            Object regKey = registriesClass.getField(fieldName).get(null);
+
+            return lookupDynamicRegistry(regKey);
+        } catch (Exception ex) {
+            ProtocolLogger.debug("Failed to resolve registry key " + registriesClassName + "." + fieldName, ex);
+        }
+        return null;
     }
 }

src/main/java/com/comphenix/protocol/wrappers/WrappedResourceKey.java

@@ -0,0 +1,168 @@
+package com.comphenix.protocol.wrappers;
+
+import com.comphenix.protocol.reflect.EquivalentConverter;
+import com.comphenix.protocol.reflect.FuzzyReflection;
+import com.comphenix.protocol.reflect.accessors.Accessors;
+import com.comphenix.protocol.reflect.accessors.MethodAccessor;
+import com.comphenix.protocol.reflect.fuzzy.FuzzyMethodContract;
+import com.comphenix.protocol.utility.MinecraftReflection;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+
+/**
+ * Wrapper around the NMS {@code ResourceKey<T>} class.
+ *
+ * <p>A {@code ResourceKey} pairs a registry identifier (e.g. {@code minecraft:item})
+ * with an entry location (e.g. {@code minecraft:diamond}) to form a fully-qualified
+ * reference into a Minecraft registry.
+ *
+ * <p>All reflective lookups are done with {@link FuzzyReflection} so they are
+ * independent of Mojang vs. Yarn/intermediary method names.
+ */
+public final class WrappedResourceKey {
+
+    // ResourceKey#location() / ResourceKey#identifier() → ResourceLocation
+    private static final MethodAccessor GET_LOCATION;
+
+    // static ResourceKey#create(ResourceKey<Registry<T>>, ResourceLocation) → ResourceKey<T>
+    private static final MethodAccessor CREATE;
+
+    static {
+        Class<?> resourceKeyClass    = MinecraftReflection.getResourceKey();
+        Class<?> resourceLocClass    = MinecraftReflection.getMinecraftKeyClass();
+        FuzzyReflection fuzzy        = FuzzyReflection.fromClass(resourceKeyClass, false);
+
+        // Resolve location() / identifier() by name first (mapping-specific names are known),
+        // then fall back to fuzzy if neither exists.  We must NOT pick registry() by accident —
+        // that also returns ResourceLocation but is the registry namespace, not the entry path.
+        MethodAccessor getLocation = null;
+        for (String candidate : new String[]{"location", "identifier", "getLocation"}) {
+            try {
+                Method m = resourceKeyClass.getMethod(candidate);
+                if (m.getReturnType().equals(resourceLocClass)) {
+                    getLocation = Accessors.getMethodAccessor(m);
+                    break;
+                }
+            } catch (NoSuchMethodException ignored) {
+            }
+        }
+        if (getLocation == null) {
+            // Last-resort fuzzy: pick the method whose simple name contains "location" or "identifier"
+            getLocation = Accessors.getMethodAccessor(
+                    fuzzy.getMethodList(FuzzyMethodContract.newBuilder()
+                            .parameterCount(0)
+                            .banModifier(Modifier.STATIC)
+                            .returnTypeExact(resourceLocClass)
+                            .build())
+                    .stream()
+                    .filter(m -> {
+                        String n = m.getName().toLowerCase();
+                        return n.contains("location") || n.contains("identifier");
+                    })
+                    .findFirst()
+                    .orElseThrow(() -> new IllegalStateException("Cannot find ResourceKey#location() method"))
+            );
+        }
+        GET_LOCATION = getLocation;
+
+        // Find the static two-arg factory: create(ResourceKey<Registry<T>>, ResourceLocation)
+        CREATE = Accessors.getMethodAccessor(fuzzy.getMethod(FuzzyMethodContract.newBuilder()
+                .parameterCount(2)
+                .requireModifier(Modifier.STATIC)
+                .parameterExactArray(resourceKeyClass, resourceLocClass)
+                .returnTypeExact(resourceKeyClass)
+                .build()));
+    }
+
+    private final Object handle;
+
+    private WrappedResourceKey(Object handle) {
+        this.handle = handle;
+    }
+
+    // -------------------------------------------------------------------------
+    // Factory / unwrap
+    // -------------------------------------------------------------------------
+
+    /**
+     * Wraps an existing NMS {@code ResourceKey} handle.
+     *
+     * @param handle the NMS object; must be an instance of {@code ResourceKey}
+     * @return a new wrapper
+     */
+    public static WrappedResourceKey fromHandle(Object handle) {
+        if (handle == null) throw new NullPointerException("handle");
+        return new WrappedResourceKey(handle);
+    }
+
+    /**
+     * Creates a new {@code ResourceKey<T>} pointing into the given registry.
+     *
+     * @param registryKey the NMS {@code ResourceKey<Registry<T>>} that identifies the registry
+     *                    (e.g. the value of {@code Registries.ITEM})
+     * @param location    the entry identifier within that registry
+     * @return a wrapper around the newly created {@code ResourceKey<T>}
+     */
+    public static WrappedResourceKey of(Object registryKey, MinecraftKey location) {
+        Object resourceLocation = MinecraftKey.getConverter().getGeneric(location);
+        return new WrappedResourceKey(CREATE.invoke(null, registryKey, resourceLocation));
+    }
+
+    /**
+     * Returns the raw NMS {@code ResourceKey} handle.
+     */
+    public Object getHandle() {
+        return handle;
+    }
+
+    // -------------------------------------------------------------------------
+    // Accessors
+    // -------------------------------------------------------------------------
+
+    /**
+     * Returns the entry location part of this key (e.g. {@code minecraft:diamond}).
+     * This is the {@code ResourceLocation} / {@code Identifier} component, NOT the
+     * registry identifier.
+     */
+    public MinecraftKey getLocation() {
+        Object resourceLocation = GET_LOCATION.invoke(handle);
+        return MinecraftKey.getConverter().getSpecific(resourceLocation);
+    }
+
+    // -------------------------------------------------------------------------
+    // EquivalentConverter factory
+    // -------------------------------------------------------------------------
+
+    /**
+     * Returns an {@link EquivalentConverter} that converts
+     * between {@link MinecraftKey} (the entry location) and a NMS
+     * {@code ResourceKey<T>} belonging to the supplied registry key.
+     *
+     * @param registryKey the NMS {@code ResourceKey<Registry<T>>} (e.g. {@code Registries.ITEM})
+     */
+    public static EquivalentConverter<MinecraftKey> converterFor(Object registryKey) {
+        return new EquivalentConverter<MinecraftKey>() {
+            @Override
+            public MinecraftKey getSpecific(Object generic) {
+                return WrappedResourceKey.fromHandle(generic).getLocation();
+            }
+
+            @Override
+            public Object getGeneric(MinecraftKey specific) {
+                return WrappedResourceKey.of(registryKey, specific).getHandle();
+            }
+
+            @Override
+            public Class<MinecraftKey> getSpecificType() {
+                return MinecraftKey.class;
+            }
+        };
+    }
+
+    @Override
+    public String toString() {
+        return "WrappedResourceKey{" + handle + "}";
+    }
+}
+

src/main/java/com/comphenix/protocol/wrappers/WrappedTagPayload.java

@@ -0,0 +1,122 @@
+package com.comphenix.protocol.wrappers;
+
+import com.comphenix.protocol.reflect.EquivalentConverter;
+import com.comphenix.protocol.reflect.accessors.Accessors;
+import com.comphenix.protocol.reflect.accessors.ConstructorAccessor;
+import com.comphenix.protocol.reflect.accessors.FieldAccessor;
+import com.comphenix.protocol.reflect.accessors.MethodAccessor;
+import com.comphenix.protocol.utility.MinecraftReflection;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * Wrapper for {@code TagNetworkSerialization.NetworkPayload}.
+ */
+public final class WrappedTagPayload {
+
+    private static final Class<?> HANDLE_TYPE = MinecraftReflection.getMinecraftClass(
+            "tags.TagNetworkSerialization$NetworkPayload");
+    private static final ConstructorAccessor CONSTRUCTOR = Accessors.getConstructorAccessor(HANDLE_TYPE, Map.class);
+    private static final FieldAccessor TAGS = Accessors.getFieldAccessor(HANDLE_TYPE, Map.class, true);
+    private static final ConstructorAccessor INT_ARRAY_LIST_CONSTRUCTOR =
+            Accessors.getConstructorAccessor(MinecraftReflection.getIntArrayListClass(), Collection.class);
+    private static final MethodAccessor CREATE_REGISTRY_KEY = Accessors.getMethodAccessor(
+            MinecraftReflection.getResourceKey(),
+            "createRegistryKey",
+            MinecraftReflection.getMinecraftKeyClass());
+
+    public static final EquivalentConverter<MinecraftKey> REGISTRY_KEY_CONVERTER =
+            Converters.ignoreNull(new EquivalentConverter<>() {
+                @Override
+                public Object getGeneric(MinecraftKey specific) {
+                    return CREATE_REGISTRY_KEY.invoke(null, MinecraftKey.getConverter().getGeneric(specific));
+                }
+
+                @Override
+                public MinecraftKey getSpecific(Object generic) {
+                    return WrappedResourceKey.fromHandle(generic).getLocation();
+                }
+
+                @Override
+                public Class<MinecraftKey> getSpecificType() {
+                    return MinecraftKey.class;
+                }
+            });
+
+    public static final EquivalentConverter<WrappedTagPayload> CONVERTER =
+            Converters.ignoreNull(new EquivalentConverter<>() {
+                @Override
+                public Object getGeneric(WrappedTagPayload specific) {
+                    Map<Object, Object> tags = new HashMap<>();
+                    for (Map.Entry<MinecraftKey, List<Integer>> entry : specific.tags.entrySet()) {
+                        tags.put(
+                                MinecraftKey.getConverter().getGeneric(entry.getKey()),
+                                INT_ARRAY_LIST_CONSTRUCTOR.invoke(entry.getValue()));
+                    }
+                    return CONSTRUCTOR.invoke(tags);
+                }
+
+                @Override
+                public WrappedTagPayload getSpecific(Object generic) {
+                    Map<?, ?> genericTags = (Map<?, ?>) TAGS.get(generic);
+                    Map<MinecraftKey, List<Integer>> tags = new HashMap<>();
+                    for (Map.Entry<?, ?> entry : genericTags.entrySet()) {
+                        List<Integer> ids = new ArrayList<>();
+                        for (Object id : (Iterable<?>) entry.getValue()) {
+                            ids.add((Integer) id);
+                        }
+                        tags.put(MinecraftKey.getConverter().getSpecific(entry.getKey()), ids);
+                    }
+                    return new WrappedTagPayload(tags);
+                }
+
+                @Override
+                public Class<WrappedTagPayload> getSpecificType() {
+                    return WrappedTagPayload.class;
+                }
+            });
+
+    private final Map<MinecraftKey, List<Integer>> tags;
+
+    public WrappedTagPayload(Map<MinecraftKey, List<Integer>> tags) {
+        this.tags = copy(tags);
+    }
+
+    public Map<MinecraftKey, List<Integer>> getTags() {
+        return copy(tags);
+    }
+
+    private static Map<MinecraftKey, List<Integer>> copy(Map<MinecraftKey, List<Integer>> tags) {
+        Map<MinecraftKey, List<Integer>> copy = new HashMap<>();
+        for (Map.Entry<MinecraftKey, List<Integer>> entry : tags.entrySet()) {
+            copy.put(entry.getKey(), List.copyOf(entry.getValue()));
+        }
+        return copy;
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof WrappedTagPayload that)) {
+            return false;
+        }
+        return Objects.equals(tags, that.tags);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(tags);
+    }
+
+    @Override
+    public String toString() {
+        return "WrappedTagPayload{tags=" + tags + '}';
+    }
+}

src/main/java/com/comphenix/protocol/wrappers/WrappedTeamParameters.java

@@ -1,11 +1,17 @@
 package com.comphenix.protocol.wrappers;
 
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Optional;
+
 import com.comphenix.protocol.injector.StructureCache;
 import com.comphenix.protocol.reflect.StructureModifier;
 import com.comphenix.protocol.utility.MinecraftReflection;
+import com.comphenix.protocol.utility.MinecraftVersion;
+import com.comphenix.protocol.wrappers.EnumWrappers.TeamCollisionRule;
+import com.comphenix.protocol.wrappers.EnumWrappers.TeamVisibility;
 import com.google.common.base.Preconditions;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 
 /**
  * A wrapper around the team parameters NMS class.
@@ -35,11 +41,16 @@ public class WrappedTeamParameters extends AbstractWrapper {
     }
 
     private final StructureModifier<Object> modifier;
+    private final StructureModifier<TeamVisibility> visiblityModifier;
+    private final StructureModifier<TeamCollisionRule> collisionRuleModifier;
 
     public WrappedTeamParameters(Object handle) {
         super(getNmsClassOrThrow());
         setHandle(handle);
+
         this.modifier = new StructureModifier<>(getNmsClassOrThrow()).withTarget(handle);
+        this.visiblityModifier = this.modifier.withType(EnumWrappers.getTeamVisibilityClass(), EnumWrappers.getTeamVisibilityConverter());
+        this.collisionRuleModifier = this.modifier.withType(EnumWrappers.getTeamCollisionRuleClass(), EnumWrappers.getTeamCollisionRuleConverter());
     }
 
     @NotNull
@@ -58,22 +69,49 @@ public class WrappedTeamParameters extends AbstractWrapper {
     }
 
     @NotNull
-    public String getNametagVisibility() {
-        return modifier.<String>withType(String.class).read(0);
+    public TeamVisibility getNametagVisibility() {
+        TeamVisibility visibility = this.visiblityModifier.readSafely(0);
+
+        if (visibility == null) {
+            return TeamVisibility.fromName(modifier.<String>withType(String.class).read(0));
+        } else {
+            return visibility;
+        }
     }
 
     @NotNull
-    public String getCollisionRule() {
-        return modifier.<String>withType(String.class).read(1);
+    public TeamCollisionRule getCollisionRule() {
+        TeamCollisionRule collisionRule = this.collisionRuleModifier.readSafely(0);
+
+        if (collisionRule == null) {
+            return TeamCollisionRule.fromName(modifier.<String>withType(String.class).read(1));
+        } else {
+            return collisionRule;
+        }
     }
 
     @NotNull
     public EnumWrappers.ChatFormatting getColor() {
-        Object handle = modifier.withType(EnumWrappers.getChatFormattingClass()).read(0);
-        return EnumWrappers.getChatFormattingConverter().getSpecific(handle);
+        if (MinecraftVersion.v26_2.atOrAbove()) {
+            Optional<?> optional = modifier.<Optional<?>>withType(Optional.class).read(0);
+            Object teamColor = optional != null ? optional.orElse(null) : null;
+            if (teamColor == null) {
+                return EnumWrappers.ChatFormatting.RESET;
+            }
+
+            return EnumWrappers.ChatFormatting.valueOf(((Enum<?>) teamColor).name());
+        }
+
+        return modifier
+                .withType(EnumWrappers.getChatFormattingClass(), EnumWrappers.getChatFormattingConverter())
+                .read(0);
     }
 
     public int getOptions() {
+        if (MinecraftVersion.v26_2.atOrAbove()) {
+            return (byte) modifier.withType(byte.class).read(0);
+        }
+
         return (int) modifier.withType(int.class).read(0);
     }
 
@@ -88,7 +126,8 @@ public class WrappedTeamParameters extends AbstractWrapper {
 
     public static class Builder {
         private WrappedChatComponent displayName, prefix, suffix;
-        private String nametagVisibility, collisionRule;
+        private TeamVisibility nametagVisibility;
+        private TeamCollisionRule collisionRule;
         private EnumWrappers.ChatFormatting color;
         private int options;
 
@@ -122,18 +161,36 @@ public class WrappedTeamParameters extends AbstractWrapper {
             return this;
         }
 
-        public Builder nametagVisibility(@NotNull String nametagVisibility) {
+        public Builder nametagVisibility(@NotNull TeamVisibility nametagVisibility) {
             Preconditions.checkNotNull(nametagVisibility);
             this.nametagVisibility = nametagVisibility;
             return this;
         }
 
-        public Builder collisionRule(@NotNull String collisionRule) {
+        /**
+         * Compatibility stub for FeatherBoard – accepts raw String visibility.
+         */
+        public Builder nametagVisibility(@NotNull String visibility) {
+            Preconditions.checkNotNull(visibility, "visibility string cannot be null");
+            this.nametagVisibility = TeamVisibility.fromName(visibility);
+            return this;
+        }
+
+        public Builder collisionRule(@NotNull TeamCollisionRule collisionRule) {
             Preconditions.checkNotNull(collisionRule);
             this.collisionRule = collisionRule;
             return this;
         }
 
+        /**
+         * Compatibility stub for FeatherBoard – accepts raw String collision rules.
+         */
+        public Builder collisionRule(@NotNull String rule) {
+            Preconditions.checkNotNull(rule, "collision rule cannot be null");
+            this.collisionRule = TeamCollisionRule.fromName(rule);
+            return this;
+        }
+
         public Builder color(@NotNull EnumWrappers.ChatFormatting color) {
             Preconditions.checkNotNull(color);
             this.color = color;
@@ -160,11 +217,36 @@ public class WrappedTeamParameters extends AbstractWrapper {
             wrapped.writeComponent(0, displayName);
             wrapped.writeComponent(1, prefix);
             wrapped.writeComponent(2, suffix);
-            wrapped.modifier.withType(String.class).write(0, nametagVisibility);
-            wrapped.modifier.withType(String.class).write(1, collisionRule);
-            wrapped.modifier.withType(EnumWrappers.getChatFormattingClass()).write(0, EnumWrappers.getChatFormattingConverter().getGeneric(color));
-            wrapped.modifier.withType(int.class).write(0, options);
+
+            if (MinecraftVersion.v1_21_5.atOrAbove()) {
+                wrapped.visiblityModifier.writeSafely(0, nametagVisibility);
+                wrapped.collisionRuleModifier.writeSafely(0, collisionRule);
+            } else {
+                wrapped.modifier.withType(String.class).writeSafely(0, nametagVisibility.toString());
+                wrapped.modifier.withType(String.class).writeSafely(1, collisionRule.toString());
+            }
+
+            if (MinecraftVersion.v26_2.atOrAbove()) {
+                wrapped.modifier.withType(Optional.class).write(0, Optional.ofNullable(toNmsTeamColor(color)));
+                wrapped.modifier.withType(byte.class).write(0, (byte) options);
+            } else {
+                wrapped.modifier.withType(EnumWrappers.getChatFormattingClass()).write(0, EnumWrappers.getChatFormattingConverter().getGeneric(color));
+                wrapped.modifier.withType(int.class).write(0, options);
+            }
             return wrapped;
         }
+
+        @SuppressWarnings({"unchecked", "rawtypes"})
+        private static Object toNmsTeamColor(EnumWrappers.ChatFormatting color) {
+            Class<?> teamColorClass = MinecraftReflection.getTeamColorClass()
+                    .orElseThrow(() -> new IllegalStateException("TeamColor class doesn't exist on this server version"));
+
+            try {
+                return Enum.valueOf((Class) teamColorClass, color.name());
+            } catch (IllegalArgumentException ex) {
+                // formatting-only values (e.g. RESET) don't map to a team color
+                return null;
+            }
+        }
     }
 }

src/main/java/com/comphenix/protocol/wrappers/WrappedWeightedList.java

@@ -0,0 +1,194 @@
+package com.comphenix.protocol.wrappers;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+
+import com.comphenix.protocol.reflect.EquivalentConverter;
+import com.comphenix.protocol.reflect.accessors.Accessors;
+import com.comphenix.protocol.reflect.accessors.ConstructorAccessor;
+import com.comphenix.protocol.reflect.accessors.MethodAccessor;
+import com.comphenix.protocol.utility.MinecraftReflection;
+
+/**
+ * Wraps the NMS {@code WeightedList<E>} type, representing a list of weighted
+ * entries where each entry has a value and an integer weight.
+ *
+ * <p>The element type {@code T} is the <em>Bukkit / ProtocolLib</em> representation
+ * of the NMS element type, converted via the supplied {@link EquivalentConverter}.
+ *
+ * @param <T> the Bukkit-side element type
+ */
+public class WrappedWeightedList<T> {
+
+    // ── NMS reflection handles (eagerly resolved at class load) ──────────
+
+    private static final Class<?> WEIGHTED_LIST_CLASS;
+    private static final Class<?> WEIGHTED_CLASS;
+
+    private static final MethodAccessor WEIGHTED_LIST_OF;     // static WeightedList.of(List<Weighted>)
+    private static final MethodAccessor WEIGHTED_LIST_UNWRAP; // WeightedList.unwrap() → List<Weighted>
+    private static final ConstructorAccessor WEIGHTED_CTOR;   // new Weighted(Object value, int weight)
+    private static final MethodAccessor WEIGHTED_VALUE;       // Weighted.value()
+    private static final MethodAccessor WEIGHTED_WEIGHT;      // Weighted.weight()
+
+    static {
+        WEIGHTED_LIST_CLASS = MinecraftReflection.getMinecraftClass("util.random.WeightedList");
+        WEIGHTED_CLASS = MinecraftReflection.getMinecraftClass("util.random.Weighted");
+
+        WEIGHTED_LIST_OF = Accessors.getMethodAccessor(WEIGHTED_LIST_CLASS, "of", List.class);
+        WEIGHTED_LIST_UNWRAP = Accessors.getMethodAccessor(WEIGHTED_LIST_CLASS, "unwrap");
+
+        WEIGHTED_CTOR = Accessors.getConstructorAccessor(WEIGHTED_CLASS, Object.class, int.class);
+        WEIGHTED_VALUE = Accessors.getMethodAccessor(WEIGHTED_CLASS, "value");
+        WEIGHTED_WEIGHT = Accessors.getMethodAccessor(WEIGHTED_CLASS, "weight");
+    }
+
+    /**
+     * Returns the NMS {@code WeightedList} class.
+     */
+    public static Class<?> getNmsClass() {
+        return WEIGHTED_LIST_CLASS;
+    }
+
+    // ── Instance data ────────────────────────────────────────────────────
+
+    private final List<Entry<T>> entries;
+
+    public WrappedWeightedList() {
+        this.entries = new ArrayList<>();
+    }
+
+    public WrappedWeightedList(List<Entry<T>> entries) {
+        this.entries = new ArrayList<>(entries);
+    }
+
+    /**
+     * Returns a mutable view of the entries in this weighted list. Mutations are
+     * reflected on this wrapper.
+     */
+    public List<Entry<T>> getEntries() {
+        return entries;
+    }
+
+    /**
+     * Replaces all entries with the given list. The argument is copied; subsequent
+     * modifications to it are not reflected on this wrapper.
+     */
+    public void setEntries(List<Entry<T>> entries) {
+        this.entries.clear();
+        this.entries.addAll(entries);
+    }
+
+    /**
+     * Appends a single entry.
+     */
+    public void addEntry(Entry<T> entry) {
+        this.entries.add(entry);
+    }
+
+    /**
+     * Appends a single value/weight entry.
+     */
+    public void addEntry(T value, int weight) {
+        this.entries.add(new Entry<>(value, weight));
+    }
+
+    // ── Entry record ─────────────────────────────────────────────────────
+
+    /**
+     * A single weighted entry pairing a value with an integer weight.
+     *
+     * @param <T> the Bukkit-side element type
+     */
+    public record Entry<T>(T value, int weight) {
+        /** Backwards-compatible accessor for callers that used {@code getValue()}. */
+        public T getValue() {
+            return value;
+        }
+
+        /** Backwards-compatible accessor for callers that used {@code getWeight()}. */
+        public int getWeight() {
+            return weight;
+        }
+    }
+
+    // ── Converter factory ────────────────────────────────────────────────
+
+    /**
+     * Creates an {@link EquivalentConverter} that converts between
+     * {@code WrappedWeightedList<T>} and the NMS {@code WeightedList<E>}.
+     *
+     * @param elementConverter converter between the Bukkit type {@code T}
+     *                         and the NMS element type {@code E}
+     * @param <T> Bukkit-side element type
+     * @return the converter
+     */
+    public static <T> EquivalentConverter<WrappedWeightedList<T>> getConverter(
+            EquivalentConverter<T> elementConverter) {
+        return new EquivalentConverter<>() {
+
+            @Override
+            @SuppressWarnings("unchecked")
+            public WrappedWeightedList<T> getSpecific(Object generic) {
+                List<Object> nmsWeightedEntries = (List<Object>) WEIGHTED_LIST_UNWRAP.invoke(generic);
+                List<Entry<T>> entries = new ArrayList<>(nmsWeightedEntries.size());
+                for (Object nmsWeighted : nmsWeightedEntries) {
+                    Object nmsValue = WEIGHTED_VALUE.invoke(nmsWeighted);
+                    int weight = (int) WEIGHTED_WEIGHT.invoke(nmsWeighted);
+                    T value = elementConverter.getSpecific(nmsValue);
+                    entries.add(new Entry<>(value, weight));
+                }
+                return new WrappedWeightedList<>(entries);
+            }
+
+            @Override
+            public Object getGeneric(WrappedWeightedList<T> specific) {
+
+                List<Object> nmsWeightedEntries = new ArrayList<>(specific.entries.size());
+                for (Entry<T> entry : specific.entries) {
+                    Object nmsValue = elementConverter.getGeneric(entry.getValue());
+                    Object nmsWeighted = WEIGHTED_CTOR.invoke(nmsValue, entry.getWeight());
+                    nmsWeightedEntries.add(nmsWeighted);
+                }
+                return WEIGHTED_LIST_OF.invoke(null, nmsWeightedEntries);
+            }
+
+            @Override
+            @SuppressWarnings("unchecked")
+            public Class<WrappedWeightedList<T>> getSpecificType() {
+                return (Class<WrappedWeightedList<T>>) (Class<?>) WrappedWeightedList.class;
+            }
+        };
+    }
+
+    // ── Convenience factories ────────────────────────────────────────────
+
+    /**
+     * Creates an empty weighted list.
+     */
+    public static <T> WrappedWeightedList<T> empty() {
+        return new WrappedWeightedList<>(Collections.emptyList());
+    }
+
+    // ── Object methods ───────────────────────────────────────────────────
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (!(o instanceof WrappedWeightedList<?> that)) return false;
+        return Objects.equals(entries, that.entries);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(entries);
+    }
+
+    @Override
+    public String toString() {
+        return "WrappedWeightedList{entries=" + entries + "}";
+    }
+}
+

src/main/java/com/comphenix/protocol/wrappers/nbt/NbtList.java

@@ -23,7 +23,7 @@ public interface NbtList<TType> extends NbtBase<List<NbtBase<TType>>>, Iterable<
     String EMPTY_NAME = "";
     
     /**
-     * Get the type of each element.
+     * Get the type of each element. For heterogeneous lists this will return {@link NbtType#TAG_COMPOUND TAG_COMPOUND}.
      * <p>
      * This will be {@link NbtType#TAG_END TAG_END} if the NBT list has just been created.
      * @return Element type.
@@ -32,8 +32,12 @@ public interface NbtList<TType> extends NbtBase<List<NbtBase<TType>>>, Iterable<
 
     /**
      * Set the type of each element.
+     * <p>
+     * In 1.21.5 and up lists can be heterogeneous, here the type is only used to convert elements added with {@link NbtList#addClosest(Object)}
      * @param type - type of each element.
+     * @deprecated since 1.21.5 lists can be heterogeneous
      */
+    @Deprecated
     void setElementType(NbtType type);
     
     /**
@@ -41,9 +45,19 @@ public interface NbtList<TType> extends NbtBase<List<NbtBase<TType>>>, Iterable<
      * <p>
      * Note that the list must be typed by setting {@link #setElementType(NbtType)} before calling this function.
      * @param value - the value to add.
+     * @deprecated since 1.21.5 lists can be heterogeneous. Use {@link NbtList#addClosest(Object, NbtType)}
      */
+    @Deprecated
     void addClosest(Object value);
-    
+
+    /**
+     * Add a value to a typed list by attempting to convert it to the nearest value.
+     * <p>
+     * @param value - the value to add.
+     * @param type - the resulting type of the entry
+     */
+    void addClosest(Object value, NbtType type);
+
     /**
      * Add a NBT list or NBT compound to the list.
      * @param element Element to add

src/main/java/com/comphenix/protocol/wrappers/nbt/TileEntityAccessor.java

@@ -1,29 +1,27 @@
 package com.comphenix.protocol.wrappers.nbt;
 
+import java.io.IOException;
+import java.lang.reflect.Modifier;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.bukkit.block.BlockState;
+
 import com.comphenix.protocol.injector.BukkitUnwrapper;
 import com.comphenix.protocol.reflect.FuzzyReflection;
 import com.comphenix.protocol.reflect.accessors.Accessors;
 import com.comphenix.protocol.reflect.accessors.FieldAccessor;
 import com.comphenix.protocol.reflect.accessors.MethodAccessor;
 import com.comphenix.protocol.reflect.fuzzy.FuzzyMethodContract;
-import com.comphenix.protocol.utility.ByteBuddyFactory;
-import com.comphenix.protocol.utility.MinecraftMethods;
 import com.comphenix.protocol.utility.MinecraftReflection;
+import com.comphenix.protocol.utility.MinecraftRegistryAccess;
 import com.comphenix.protocol.utility.MinecraftVersion;
-import java.io.IOException;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Modifier;
-import java.util.HashMap;
-import java.util.Map;
-import net.bytebuddy.dynamic.loading.ClassLoadingStrategy;
-import net.bytebuddy.implementation.InvocationHandlerAdapter;
+
 import net.bytebuddy.jar.asm.ClassReader;
 import net.bytebuddy.jar.asm.ClassVisitor;
 import net.bytebuddy.jar.asm.MethodVisitor;
 import net.bytebuddy.jar.asm.Opcodes;
 import net.bytebuddy.jar.asm.Type;
-import net.bytebuddy.matcher.ElementMatchers;
-import org.bukkit.block.BlockState;
 
 /**
  * Manipulate tile entities.
@@ -34,6 +32,10 @@ class TileEntityAccessor<T extends BlockState> {
 
     private static final boolean BLOCK_DATA_INCL = MinecraftVersion.NETHER_UPDATE.atOrAbove()
             && !MinecraftVersion.CAVES_CLIFFS_1.atOrAbove();
+    private static final boolean USE_HOLDER_LOOKUP = MinecraftVersion.v1_21_5.atOrAbove();
+    private static final boolean USE_TAG_VALUE_INPUT = MinecraftVersion.v1_21_6.atOrAbove();
+
+    private static final Class<?> TAG_VALUE_INPUT = MinecraftReflection.getNullableNMS("world.level.storage.TagValueInput");
 
     /**
      * Token indicating that the given block state doesn't contain any tile entities.
@@ -45,7 +47,7 @@ class TileEntityAccessor<T extends BlockState> {
      */
     private static final Map<Class<?>, TileEntityAccessor<?>> cachedAccessors = new HashMap<>();
 
-    private static Constructor<?> nbtCompoundParserConstructor;
+    private MethodAccessor createInputWrapper;
 
     private FieldAccessor tileEntityField;
     private MethodAccessor readCompound;
@@ -104,11 +106,50 @@ class TileEntityAccessor<T extends BlockState> {
     }
 
     void findMethods(Class<?> type, T state) {
-        if (BLOCK_DATA_INCL) {
-            Class<?> tileEntityClass = MinecraftReflection.getTileEntityClass();
-            Class<?> iBlockData = MinecraftReflection.getIBlockDataClass();
-            Class<?> nbtCompound = MinecraftReflection.getNBTCompoundClass();
+        Class<?> tileEntityClass = MinecraftReflection.getTileEntityClass();
+        Class<?> nbtCompound = MinecraftReflection.getNBTCompoundClass();
+        
+        if (USE_HOLDER_LOOKUP) {
+            Class<?> holderLookup = MinecraftReflection.getHolderLookupProviderClass();
 
+            FuzzyReflection fuzzy = FuzzyReflection.fromClass(tileEntityClass, false);
+            // should be equiv. to `CompoundTag saveWithFullMetadata(HolderLookup.Provider)`
+            writeCompound = Accessors.getMethodAccessor(fuzzy.getMethod(
+                    FuzzyMethodContract.newBuilder()
+                            .banModifier(Modifier.STATIC)
+                            .requireModifier(Modifier.FINAL)
+                            .returnTypeExact(nbtCompound)
+                            .parameterExactArray(holderLookup)
+                            .build()));
+
+            if (USE_TAG_VALUE_INPUT) {
+                createInputWrapper = Accessors.getMethodAccessor(FuzzyReflection.fromClass(TAG_VALUE_INPUT).getMethod(
+                        FuzzyMethodContract.newBuilder()
+                                .requireModifier(Modifier.STATIC)
+                                .parameterExactArray(MinecraftReflection.getMinecraftClass("util.ProblemReporter"), holderLookup, nbtCompound)
+                                .build()));
+
+                // should be equiv. to `void loadWithComponents(ValueInput)`
+                readCompound = Accessors.getMethodAccessor(fuzzy.getMethod(
+                        FuzzyMethodContract.newBuilder()
+                                .banModifier(Modifier.STATIC)
+                                .requireModifier(Modifier.FINAL)
+                                .returnTypeVoid()
+                                .parameterSuperOf(TAG_VALUE_INPUT)
+                                .build()));
+            } else {
+                // should be equiv. to `void loadWithComponents(CompoundTag, HolderLookup.Provider)`
+                readCompound = Accessors.getMethodAccessor(fuzzy.getMethod(
+                        FuzzyMethodContract.newBuilder()
+                                .banModifier(Modifier.STATIC)
+                                .requireModifier(Modifier.FINAL)
+                                .returnTypeVoid()
+                                .parameterExactArray(nbtCompound, holderLookup)
+                                .build()));
+            }
+        } else if (BLOCK_DATA_INCL) {
+            Class<?> iBlockData = MinecraftReflection.getIBlockDataClass();
+            
             FuzzyReflection fuzzy = FuzzyReflection.fromClass(tileEntityClass, false);
             writeCompound = Accessors.getMethodAccessor(fuzzy.getMethod(
                     FuzzyMethodContract.newBuilder()
@@ -214,12 +255,17 @@ class TileEntityAccessor<T extends BlockState> {
      * @return The compound.
      */
     public NbtCompound readBlockState(T state) {
-        NbtCompound output = NbtFactory.ofCompound("");
         Object tileEntity = tileEntityField.get(state);
 
         // Write the block state to the output compound
-        writeCompound.invoke(tileEntity, NbtFactory.fromBase(output).getHandle());
-        return output;
+        if (USE_HOLDER_LOOKUP) {
+            Object tag = writeCompound.invoke(tileEntity, MinecraftRegistryAccess.get());
+            return new WrappedCompound(tag);
+        } else {
+            NbtCompound output = NbtFactory.ofCompound("");
+            writeCompound.invoke(tileEntity, NbtFactory.fromBase(output).getHandle());
+            return output;
+        }
     }
 
     /**
@@ -232,7 +278,14 @@ class TileEntityAccessor<T extends BlockState> {
         Object tileEntity = tileEntityField.get(state);
 
         // Ensure the block state is set to the compound
-        if (BLOCK_DATA_INCL) {
+        if (USE_HOLDER_LOOKUP) {
+            if (USE_TAG_VALUE_INPUT) {
+                Object tagValueInput = createInputWrapper.invoke(null, null,  MinecraftRegistryAccess.get(), NbtFactory.fromBase(compound).getHandle());
+                readCompound.invoke(tileEntity, tagValueInput);
+            } else {
+                readCompound.invoke(tileEntity, NbtFactory.fromBase(compound).getHandle(), MinecraftRegistryAccess.get());
+            }
+        } else if (BLOCK_DATA_INCL) {
             Object blockData = BukkitUnwrapper.getInstance().unwrapItem(state);
             readCompound.invoke(tileEntity, blockData, NbtFactory.fromBase(compound).getHandle());
         } else {

src/main/java/com/comphenix/protocol/wrappers/nbt/WrappedList.java

@@ -17,6 +17,7 @@
 
 package com.comphenix.protocol.wrappers.nbt;
 
+import com.comphenix.protocol.utility.MinecraftVersion;
 import com.comphenix.protocol.wrappers.collection.ConvertedList;
 import com.comphenix.protocol.wrappers.nbt.io.NbtBinarySerializer;
 import com.google.common.base.Joiner;
@@ -103,7 +104,9 @@ class WrappedList<TType> implements NbtWrapper<List<NbtBase<TType>>>, NbtList<TT
      */
     public WrappedList(Object handle) {
         this.container = new WrappedElement<>(handle);
-        this.elementType = container.getSubType();
+        if (!MinecraftVersion.v1_21_5.atOrAbove()) {
+            this.elementType = container.getSubType();
+        }
     }
     
     /**
@@ -113,7 +116,9 @@ class WrappedList<TType> implements NbtWrapper<List<NbtBase<TType>>>, NbtList<TT
      */
     public WrappedList(Object handle, String name) {
         this.container = new WrappedElement<>(handle, name);
-        this.elementType = container.getSubType();
+        if (!MinecraftVersion.v1_21_5.atOrAbove()) {
+            this.elementType = container.getSubType();
+        }
     }
 
     @Override
@@ -141,13 +146,28 @@ class WrappedList<TType> implements NbtWrapper<List<NbtBase<TType>>>, NbtList<TT
     
     @Override
     public NbtType getElementType() {
-        return elementType;
+        if (!MinecraftVersion.v1_21_5.atOrAbove()) {
+            return elementType;
+        } else {
+            List<NbtBase<TType>> value = getValue();
+            NbtType type = NbtType.TAG_END;
+            for (NbtBase<TType> entry : value) {
+                if (type == NbtType.TAG_END) {
+                    type = entry.getType();
+                } else if (type != entry.getType()) {
+                    return NbtType.TAG_COMPOUND;
+                }
+            }
+            return type;
+        }
     }
     
     @Override
     public void setElementType(NbtType type) {
         this.elementType = type;
-        container.setSubType(type);
+        if (!MinecraftVersion.v1_21_5.atOrAbove()) {
+            container.setSubType(type);
+        }
     }
 
     @Override
@@ -171,14 +191,16 @@ class WrappedList<TType> implements NbtWrapper<List<NbtBase<TType>>>, NbtList<TT
                     if (!element.getName().equals(EMPTY_NAME))
                         throw new IllegalArgumentException("Cannot add a the named NBT tag " + element + " to a list.");
                     
-                    // Check element type
-                    if (getElementType() != NbtType.TAG_END) {
-                        if (!element.getType().equals(getElementType())) {
-                            throw new IllegalArgumentException(
-                                    "Cannot add " + element + " of " + element.getType() + " to a list of type " + getElementType());
+                    if (!MinecraftVersion.v1_21_5.atOrAbove()) {
+                        // Check element type
+                        if (getElementType() != NbtType.TAG_END) {
+                            if (!element.getType().equals(getElementType())) {
+                                throw new IllegalArgumentException(
+                                        "Cannot add " + element + " of " + element.getType() + " to a list of type " + getElementType());
+                            }
+                        } else {
+                            container.setSubType(element.getType());
                         }
-                    } else {
-                        container.setSubType(element.getType());
                     }
                 }
                 
@@ -235,16 +257,21 @@ class WrappedList<TType> implements NbtWrapper<List<NbtBase<TType>>>, NbtList<TT
     }
     
     @Override
-    @SuppressWarnings("unchecked")
     public void addClosest(Object value) {
-        if (getElementType() == NbtType.TAG_END)
+        if (elementType == NbtType.TAG_END)
             throw new IllegalStateException("This list has not been typed yet.");
-        
+
+        addClosest(value, elementType);
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public void addClosest(Object value, NbtType type) {
         if (value instanceof Number) {
             Number number = (Number) value;
             
             // Convert the number
-            switch (getElementType()) {
+            switch (type) {
                 case TAG_BYTE: add(number.byteValue()); break;
                 case TAG_SHORT: add(number.shortValue()); break;
                 case TAG_INT: add(number.intValue()); break;
@@ -262,7 +289,7 @@ class WrappedList<TType> implements NbtWrapper<List<NbtBase<TType>>>, NbtList<TT
             
         } else {
             // Just add it
-            add((NbtBase<TType>) NbtFactory.ofWrapper(getElementType(), EMPTY_NAME, value));
+            add((NbtBase<TType>) NbtFactory.ofWrapper(type, EMPTY_NAME, value));
         }
     }
     
@@ -355,7 +382,7 @@ class WrappedList<TType> implements NbtWrapper<List<NbtBase<TType>>>, NbtList<TT
         }
         
         // Update the sub type as well
-        if (lastElement != null) {
+        if (lastElement != null && !MinecraftVersion.v1_21_5.atOrAbove()) {
             container.setSubType(lastElement.getType());
         }
     }

src/main/java/com/comphenix/protocol/wrappers/nbt/io/NbtConfigurationSerializer.java

@@ -261,10 +261,9 @@ public class NbtConfigurationSerializer {
 
             if (node instanceof List) {
                 NbtList<Object> list = NbtFactory.ofList(decoded[0]);
-                list.setElementType(type);
                 
                 for (Object value : (List<Object>) node) {
-                    list.addClosest(toNodeValue(value, type));
+                    list.addClosest(toNodeValue(value, type), type);
                 }
                 
                 // Add the list

src/main/java/com/comphenix/protocol/wrappers/nbt/io/NbtTextSerializer.java

@@ -5,8 +5,7 @@ import java.io.ByteArrayOutputStream;
 import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.IOException;
-
-import org.yaml.snakeyaml.external.biz.base64Coder.Base64Coder;
+import java.util.Base64;
 
 import com.comphenix.protocol.wrappers.nbt.NbtBase;
 import com.comphenix.protocol.wrappers.nbt.NbtCompound;
@@ -23,7 +22,7 @@ public class NbtTextSerializer {
      * A default instance of this serializer.
      */
     public static final NbtTextSerializer DEFAULT = new NbtTextSerializer();
-    
+
     private NbtBinarySerializer binarySerializer;
     
     public NbtTextSerializer() {
@@ -59,7 +58,7 @@ public class NbtTextSerializer {
          binarySerializer.serialize(value, dataOutput);
          
          // Serialize that array
-         return Base64Coder.encodeLines(outputStream.toByteArray());
+         return Base64.getEncoder().encodeToString(outputStream.toByteArray());
     }
     
     /**
@@ -70,7 +69,7 @@ public class NbtTextSerializer {
      * @throws IOException If we are unable to parse the input.
      */
     public <TType> NbtWrapper<TType> deserialize(String input) throws IOException {
-        ByteArrayInputStream inputStream = new ByteArrayInputStream(Base64Coder.decodeLines(input));
+        ByteArrayInputStream inputStream = new ByteArrayInputStream(Base64.getDecoder().decode(input));
         
         return binarySerializer.deserialize(new DataInputStream(inputStream));
     }

src/main/java/com/comphenix/protocol/wrappers/ping/ServerPingRecord.java

@@ -7,6 +7,8 @@ import com.comphenix.protocol.reflect.accessors.Accessors;
 import com.comphenix.protocol.reflect.accessors.ConstructorAccessor;
 import com.comphenix.protocol.reflect.accessors.FieldAccessor;
 import com.comphenix.protocol.reflect.accessors.MethodAccessor;
+import com.comphenix.protocol.reflect.instances.DefaultInstances;
+import com.comphenix.protocol.reflect.instances.MinecraftGenerator;
 import com.comphenix.protocol.utility.MinecraftProtocolVersion;
 import com.comphenix.protocol.utility.MinecraftReflection;
 import com.comphenix.protocol.utility.MinecraftVersion;
@@ -23,6 +25,7 @@ public final class ServerPingRecord implements ServerPingImpl {
     private static Class<?> SERVER_PING;
     private static Class<?> PLAYER_SAMPLE_CLASS;
     private static Class<?> SERVER_DATA_CLASS;
+    private static Class<?> NAME_AND_ID_CLASS;
 
     private static Class<?> GSON_CLASS;
     private static MethodAccessor GSON_TO_JSON;
@@ -56,13 +59,37 @@ public final class ServerPingRecord implements ServerPingImpl {
                 PLAYER_SAMPLE_CLASS = MinecraftReflection.getServerPingPlayerSampleClass();
                 SERVER_DATA_CLASS = MinecraftReflection.getServerPingServerDataClass();
 
-                PING_CTOR = Accessors.getConstructorAccessor(SERVER_PING.getConstructors()[0]);
+                PING_CTOR = Accessors.getConstructorAccessor(SERVER_PING, MinecraftReflection.getIChatBaseComponentClass(), Optional.class, Optional.class, Optional.class, boolean.class);
 
                 DATA_WRAPPER = AutoWrapper.wrap(ServerData.class, SERVER_DATA_CLASS);
                 SAMPLE_WRAPPER = AutoWrapper.wrap(PlayerSample.class, PLAYER_SAMPLE_CLASS);
                 FAVICON_WRAPPER = AutoWrapper.wrap(Favicon.class, MinecraftReflection.getMinecraftClass("network.protocol.status.ServerPing$a", "network.protocol.status.ServerStatus$Favicon"));
 
-                PROFILE_LIST_CONVERTER = BukkitConverters.getListConverter(BukkitConverters.getWrappedGameProfileConverter());
+                if (MinecraftVersion.v1_21_10.atOrAbove()) {
+                    NAME_AND_ID_CLASS = MinecraftReflection.getMinecraftClass("server.players.NameAndId");
+                    NAME_AND_ID_WRAPPER = AutoWrapper.wrap(NameAndId.class, NAME_AND_ID_CLASS);
+
+                    PROFILE_LIST_CONVERTER = BukkitConverters.getListConverter(new EquivalentConverter<>() {
+                        @Override
+                        public Object getGeneric(WrappedGameProfile specific) {
+                            NameAndId wrapper = new NameAndId(specific.getUUID(), specific.getName());
+                            return NAME_AND_ID_WRAPPER.getGeneric(wrapper);
+                        }
+
+                        @Override
+                        public WrappedGameProfile getSpecific(Object generic) {
+                            NameAndId wrapper = NAME_AND_ID_WRAPPER.getSpecific(generic);
+                            return new WrappedGameProfile(wrapper.id, wrapper.name);
+                        }
+
+                        @Override
+                        public Class<WrappedGameProfile> getSpecificType() {
+                            return WrappedGameProfile.class;
+                        }
+                    });
+                } else {
+                    PROFILE_LIST_CONVERTER = BukkitConverters.getListConverter(BukkitConverters.getWrappedGameProfileConverter());
+                }
 
                 DEFAULT_DESCRIPTION = WrappedChatComponent.fromLegacyText("A Minecraft Server");
 
@@ -124,11 +151,24 @@ public final class ServerPingRecord implements ServerPingImpl {
         }
     }
 
+    public static final class NameAndId {
+        public UUID id;
+        public String name;
+
+        public NameAndId(UUID id, String name) {
+            this.id = id;
+            this.name = name;
+        }
+
+        public NameAndId() {
+            this(MinecraftGenerator.SYS_UUID, "");
+        }
+    }
+
     private static AutoWrapper<PlayerSample> SAMPLE_WRAPPER;
-
     private static AutoWrapper<ServerData> DATA_WRAPPER;
-
     private static AutoWrapper<Favicon> FAVICON_WRAPPER;
+    private static AutoWrapper<NameAndId> NAME_AND_ID_WRAPPER;
 
     private WrappedChatComponent description;
     private PlayerSample playerSample;

src/main/java/net/dmulloy2/protocol/AbstractPacket.java

@@ -0,0 +1,69 @@
+package net.dmulloy2.protocol;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.ProtocolLibrary;
+import com.comphenix.protocol.events.PacketContainer;
+import java.util.Objects;
+import org.bukkit.entity.Player;
+
+/**
+ * Base class for all packet wrappers. Provides access to the underlying
+ * {@link PacketContainer} and convenience methods for sending/receiving.
+ */
+public abstract class AbstractPacket {
+
+    protected final PacketContainer handle;
+
+    protected AbstractPacket(PacketContainer handle, PacketType type) {
+        if (handle == null) {
+            throw new IllegalArgumentException("Packet handle cannot be null");
+        }
+        if (type == null) {
+            throw new IllegalArgumentException("Packet type cannot be null");
+        }
+        if (!handle.getType().equals(type)) {
+            throw new IllegalArgumentException(
+                    "Invalid packet type: expected " + type + ", got " + handle.getType());
+        }
+        this.handle = handle;
+    }
+
+    /**
+     * Returns the underlying {@link PacketContainer}.
+     */
+    public PacketContainer getHandle() {
+        return handle;
+    }
+
+    /**
+     * Sends this packet to a player (server → client).
+     */
+    public void sendPacket(Player receiver) {
+        ProtocolLibrary.getProtocolManager().sendServerPacket(receiver, getHandle());
+    }
+
+    /**
+     * Simulates receiving this packet from a player (client → server).
+     */
+    public void receivePacket(Player player) {
+        ProtocolLibrary.getProtocolManager().receiveClientPacket(player, getHandle());
+    }
+
+    @Override
+    public boolean equals(Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        AbstractPacket other = (AbstractPacket) o;
+        return Objects.equals(handle, other.handle);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hashCode(handle);
+    }
+
+    @Override
+    public String toString() {
+        return getClass().getSimpleName() + "{handle=" + handle + "}";
+    }
+}

src/main/java/net/dmulloy2/protocol/wrappers/configuration/clientbound/WrappedClientboundCodeOfConductPacket.java

@@ -0,0 +1,36 @@
+package net.dmulloy2.protocol.wrappers.configuration.clientbound;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.events.PacketContainer;
+import com.comphenix.protocol.injector.EquivalentConstructor;
+import net.dmulloy2.protocol.AbstractPacket;
+
+/**
+ * Wrapper for {@code ClientboundCodeOfConductPacket} (configuration phase, clientbound).
+ */
+public class WrappedClientboundCodeOfConductPacket extends AbstractPacket {
+
+    public static final PacketType TYPE = PacketType.Configuration.Server.CODE_OF_CONDUCT;
+    private static final EquivalentConstructor CONSTRUCTOR = new EquivalentConstructor(TYPE)
+            .withParam(String.class);
+
+    public WrappedClientboundCodeOfConductPacket() {
+        super(new PacketContainer(TYPE), TYPE);
+    }
+
+    public WrappedClientboundCodeOfConductPacket(String codeOfConduct) {
+        this(PacketContainer.fromPacket(CONSTRUCTOR.create(codeOfConduct)));
+    }
+
+    public WrappedClientboundCodeOfConductPacket(PacketContainer packet) {
+        super(packet, TYPE);
+    }
+
+    public String getCodeOfConduct() {
+        return handle.getStrings().read(0);
+    }
+
+    public void setCodeOfConduct(String codeOfConduct) {
+        handle.getStrings().write(0, codeOfConduct);
+    }
+}

src/main/java/net/dmulloy2/protocol/wrappers/configuration/clientbound/WrappedClientboundCookieRequestPacket.java

@@ -0,0 +1,43 @@
+package net.dmulloy2.protocol.wrappers.configuration.clientbound;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.events.PacketContainer;
+import com.comphenix.protocol.injector.EquivalentConstructor;
+import com.comphenix.protocol.utility.MinecraftReflection;
+import com.comphenix.protocol.wrappers.MinecraftKey;
+import net.dmulloy2.protocol.AbstractPacket;
+
+/**
+ * Wrapper for {@code ClientboundCookieRequestPacket} (configuration phase, clientbound).
+ *
+ * <p>Packet structure:
+ * <ul>
+ *   <li>{@code Identifier key} – namespaced key identifying the cookie to request</li>
+ * </ul>
+ */
+public class WrappedClientboundCookieRequestPacket extends AbstractPacket {
+
+    public static final PacketType TYPE = PacketType.Configuration.Server.COOKIE_REQUEST;
+    private static final EquivalentConstructor CONSTRUCTOR = new EquivalentConstructor(TYPE)
+            .withParam(MinecraftReflection.getMinecraftKeyClass(), MinecraftKey.getConverter());
+
+    public WrappedClientboundCookieRequestPacket() {
+        super(new PacketContainer(TYPE), TYPE);
+    }
+
+    public WrappedClientboundCookieRequestPacket(MinecraftKey key) {
+        this(new PacketContainer(TYPE, CONSTRUCTOR.create(key)));
+    }
+
+    public WrappedClientboundCookieRequestPacket(PacketContainer packet) {
+        super(packet, TYPE);
+    }
+
+    public MinecraftKey getKey() {
+        return handle.getMinecraftKeys().read(0);
+    }
+
+    public void setKey(MinecraftKey key) {
+        handle.getMinecraftKeys().write(0, key);
+    }
+}

src/main/java/net/dmulloy2/protocol/wrappers/configuration/clientbound/WrappedClientboundCustomPayloadPacket.java

@@ -0,0 +1,42 @@
+package net.dmulloy2.protocol.wrappers.configuration.clientbound;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.events.PacketContainer;
+import com.comphenix.protocol.injector.EquivalentConstructor;
+import com.comphenix.protocol.wrappers.CustomPacketPayloadWrapper;
+import net.dmulloy2.protocol.AbstractPacket;
+
+/**
+ * Wrapper for {@code ClientboundCustomPayloadPacket} (configuration phase, clientbound).
+ *
+ * <p>Packet structure:
+ * <ul>
+ *   <li>{@code CustomPacketPayload payload} – channel-specific payload</li>
+ * </ul>
+ */
+public class WrappedClientboundCustomPayloadPacket extends AbstractPacket {
+
+    public static final PacketType TYPE = PacketType.Configuration.Server.CUSTOM_PAYLOAD;
+    private static final EquivalentConstructor CONSTRUCTOR = new EquivalentConstructor(TYPE)
+            .withParam(CustomPacketPayloadWrapper.getCustomPacketPayloadClass(), CustomPacketPayloadWrapper.getConverter());
+
+    public WrappedClientboundCustomPayloadPacket() {
+        super(new PacketContainer(TYPE), TYPE);
+    }
+
+    public WrappedClientboundCustomPayloadPacket(CustomPacketPayloadWrapper payload) {
+        this(new PacketContainer(TYPE, CONSTRUCTOR.create(payload)));
+    }
+
+    public WrappedClientboundCustomPayloadPacket(PacketContainer packet) {
+        super(packet, TYPE);
+    }
+
+    public CustomPacketPayloadWrapper getPayload() {
+        return handle.getCustomPacketPayloads().read(0);
+    }
+
+    public void setPayload(CustomPacketPayloadWrapper payload) {
+        handle.getCustomPacketPayloads().write(0, payload);
+    }
+}

src/main/java/net/dmulloy2/protocol/wrappers/configuration/clientbound/WrappedClientboundCustomReportDetailsPacket.java

@@ -0,0 +1,48 @@
+package net.dmulloy2.protocol.wrappers.configuration.clientbound;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.events.PacketContainer;
+import com.comphenix.protocol.injector.EquivalentConstructor;
+import com.comphenix.protocol.wrappers.Converters;
+import java.util.Map;
+import net.dmulloy2.protocol.AbstractPacket;
+
+/**
+ * Wrapper for {@code ClientboundCustomReportDetailsPacket} (configuration phase, clientbound).
+ *
+ * <p>Packet structure:
+ * <ul>
+ *   <li>{@code Map<String, String> details} – custom crash report detail entries</li>
+ * </ul>
+ */
+public class WrappedClientboundCustomReportDetailsPacket extends AbstractPacket {
+
+    public static final PacketType TYPE = PacketType.Configuration.Server.REPORT_DETAILS;
+
+    private static final EquivalentConstructor CONSTRUCTOR = new EquivalentConstructor(TYPE)
+            .withParam(Map.class);
+
+    public WrappedClientboundCustomReportDetailsPacket() {
+        super(new PacketContainer(TYPE), TYPE);
+    }
+
+    public WrappedClientboundCustomReportDetailsPacket(Map<String, String> details) {
+        this(new PacketContainer(TYPE, CONSTRUCTOR.create(details)));
+    }
+
+    public WrappedClientboundCustomReportDetailsPacket(PacketContainer packet) {
+        super(packet, TYPE);
+    }
+
+    public Map<String, String> getDetails() {
+        return handle.getMaps(
+                Converters.passthrough(String.class),
+                Converters.passthrough(String.class)).readSafely(0);
+    }
+
+    public void setDetails(Map<String, String> details) {
+        handle.getMaps(
+                Converters.passthrough(String.class),
+                Converters.passthrough(String.class)).writeSafely(0, details);
+    }
+}

src/main/java/net/dmulloy2/protocol/wrappers/configuration/clientbound/WrappedClientboundDisconnectPacket.java

@@ -0,0 +1,39 @@
+package net.dmulloy2.protocol.wrappers.configuration.clientbound;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.events.PacketContainer;
+import com.comphenix.protocol.injector.EquivalentConstructor;
+import com.comphenix.protocol.utility.MinecraftReflection;
+import com.comphenix.protocol.wrappers.BukkitConverters;
+import com.comphenix.protocol.wrappers.WrappedChatComponent;
+import net.dmulloy2.protocol.AbstractPacket;
+
+/**
+ * Wrapper for {@code ClientboundDisconnectPacket} (configuration phase, clientbound).
+ */
+public class WrappedClientboundDisconnectPacket extends AbstractPacket {
+
+    public static final PacketType TYPE = PacketType.Configuration.Server.DISCONNECT;
+    private static final EquivalentConstructor CONSTRUCTOR = new EquivalentConstructor(TYPE)
+            .withParam(MinecraftReflection.getIChatBaseComponentClass(), BukkitConverters.getWrappedChatComponentConverter());
+
+    public WrappedClientboundDisconnectPacket() {
+        super(new PacketContainer(TYPE), TYPE);
+    }
+
+    public WrappedClientboundDisconnectPacket(WrappedChatComponent reason) {
+        this(new PacketContainer(TYPE, CONSTRUCTOR.create(reason)));
+    }
+
+    public WrappedClientboundDisconnectPacket(PacketContainer packet) {
+        super(packet, TYPE);
+    }
+
+    public WrappedChatComponent getReason() {
+        return handle.getChatComponents().read(0);
+    }
+
+    public void setReason(WrappedChatComponent reason) {
+        handle.getChatComponents().write(0, reason);
+    }
+}

src/main/java/net/dmulloy2/protocol/wrappers/configuration/clientbound/WrappedClientboundKeepAlivePacket.java

@@ -0,0 +1,36 @@
+package net.dmulloy2.protocol.wrappers.configuration.clientbound;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.events.PacketContainer;
+import com.comphenix.protocol.injector.EquivalentConstructor;
+import net.dmulloy2.protocol.AbstractPacket;
+
+/**
+ * Wrapper for {@code ClientboundKeepAlivePacket} (configuration phase, clientbound).
+ */
+public class WrappedClientboundKeepAlivePacket extends AbstractPacket {
+
+    public static final PacketType TYPE = PacketType.Configuration.Server.KEEP_ALIVE;
+    private static final EquivalentConstructor CONSTRUCTOR = new EquivalentConstructor(TYPE)
+            .withParam(long.class);
+
+    public WrappedClientboundKeepAlivePacket() {
+        super(new PacketContainer(TYPE), TYPE);
+    }
+
+    public WrappedClientboundKeepAlivePacket(long id) {
+        this(new PacketContainer(TYPE, CONSTRUCTOR.create(id)));
+    }
+
+    public WrappedClientboundKeepAlivePacket(PacketContainer packet) {
+        super(packet, TYPE);
+    }
+
+    public long getId() {
+        return handle.getLongs().read(0);
+    }
+
+    public void setId(long id) {
+        handle.getLongs().write(0, id);
+    }
+}

src/main/java/net/dmulloy2/protocol/wrappers/configuration/clientbound/WrappedClientboundPingPacket.java

@@ -0,0 +1,36 @@
+package net.dmulloy2.protocol.wrappers.configuration.clientbound;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.events.PacketContainer;
+import com.comphenix.protocol.injector.EquivalentConstructor;
+import net.dmulloy2.protocol.AbstractPacket;
+
+/**
+ * Wrapper for {@code ClientboundPingPacket} (configuration phase, clientbound).
+ */
+public class WrappedClientboundPingPacket extends AbstractPacket {
+
+    public static final PacketType TYPE = PacketType.Configuration.Server.PING;
+    private static final EquivalentConstructor CONSTRUCTOR = new EquivalentConstructor(TYPE)
+            .withParam(int.class);
+
+    public WrappedClientboundPingPacket() {
+        super(new PacketContainer(TYPE), TYPE);
+    }
+
+    public WrappedClientboundPingPacket(int id) {
+        this(new PacketContainer(TYPE, CONSTRUCTOR.create(id)));
+    }
+
+    public WrappedClientboundPingPacket(PacketContainer packet) {
+        super(packet, TYPE);
+    }
+
+    public int getId() {
+        return handle.getIntegers().read(0);
+    }
+
+    public void setId(int id) {
+        handle.getIntegers().write(0, id);
+    }
+}

src/main/java/net/dmulloy2/protocol/wrappers/configuration/clientbound/WrappedClientboundRegistryDataPacket.java

@@ -0,0 +1,27 @@
+package net.dmulloy2.protocol.wrappers.configuration.clientbound;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.events.PacketContainer;
+import net.dmulloy2.protocol.AbstractPacket;
+
+/**
+ * Wrapper for {@code ClientboundRegistryDataPacket} (configuration phase, clientbound).
+ */
+public class WrappedClientboundRegistryDataPacket extends AbstractPacket {
+
+    public static final PacketType TYPE = PacketType.Configuration.Server.REGISTRY_DATA;
+
+    public WrappedClientboundRegistryDataPacket() {
+        super(new PacketContainer(TYPE), TYPE);
+    }
+
+    public WrappedClientboundRegistryDataPacket(PacketContainer packet) {
+        super(packet, TYPE);
+    }
+
+    // TODO: missing field 'registry' (NMS type: ResourceKey<? extends Registry<?>>)
+    //   Use getMinecraftKeys().read(0) for the registry key identifier, or getSpecificModifier(ResourceKey.class).read(0).
+    // TODO: missing field 'entries' (NMS type: List<RegistrySynchronization.PackedRegistryEntry>)
+    //   Each entry has an id (Identifier) and an optional NBT tag. Use handle.getModifier().read(1)
+    //   for the raw List, or add a dedicated WrappedPackedRegistryEntry class.
+}

src/main/java/net/dmulloy2/protocol/wrappers/configuration/clientbound/WrappedClientboundResourcePackPopPacket.java

@@ -0,0 +1,45 @@
+package net.dmulloy2.protocol.wrappers.configuration.clientbound;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.events.PacketContainer;
+import com.comphenix.protocol.injector.EquivalentConstructor;
+import com.comphenix.protocol.wrappers.Converters;
+import java.util.Optional;
+import java.util.UUID;
+import net.dmulloy2.protocol.AbstractPacket;
+
+/**
+ * Wrapper for {@code ClientboundResourcePackPopPacket} (configuration phase, clientbound).
+ *
+ * <p>Packet structure:
+ * <ul>
+ *   <li>{@code Optional<UUID> id} – UUID of the resource pack to remove, or empty to remove all</li>
+ * </ul>
+ */
+public class WrappedClientboundResourcePackPopPacket extends AbstractPacket {
+
+    public static final PacketType TYPE = PacketType.Configuration.Server.REMOVE_RESOURCE_PACK;
+
+    private static final EquivalentConstructor CONSTRUCTOR = new EquivalentConstructor(TYPE)
+            .withParam(Optional.class);
+
+    public WrappedClientboundResourcePackPopPacket() {
+        super(new PacketContainer(TYPE), TYPE);
+    }
+
+    public WrappedClientboundResourcePackPopPacket(Optional<UUID> id) {
+        this(new PacketContainer(TYPE, CONSTRUCTOR.create(id)));
+    }
+
+    public WrappedClientboundResourcePackPopPacket(PacketContainer packet) {
+        super(packet, TYPE);
+    }
+
+    public Optional<UUID> getId() {
+        return handle.getOptionals(Converters.passthrough(UUID.class)).readSafely(0);
+    }
+
+    public void setId(Optional<UUID> id) {
+        handle.getOptionals(Converters.passthrough(UUID.class)).writeSafely(0, id);
+    }
+}

src/main/java/net/dmulloy2/protocol/wrappers/configuration/clientbound/WrappedClientboundResourcePackPushPacket.java

@@ -0,0 +1,79 @@
+package net.dmulloy2.protocol.wrappers.configuration.clientbound;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.events.PacketContainer;
+import com.comphenix.protocol.injector.EquivalentConstructor;
+import com.comphenix.protocol.wrappers.BukkitConverters;
+import com.comphenix.protocol.wrappers.Converters;
+import com.comphenix.protocol.wrappers.WrappedChatComponent;
+import java.util.Optional;
+import java.util.UUID;
+import net.dmulloy2.protocol.AbstractPacket;
+
+/**
+ * Wrapper for {@code ClientboundResourcePackPushPacket} (configuration phase, clientbound).
+ */
+public class WrappedClientboundResourcePackPushPacket extends AbstractPacket {
+
+    public static final PacketType TYPE = PacketType.Configuration.Server.ADD_RESOURCE_PACK;
+
+    // NMS constructor order: (UUID id, String url, String hash, boolean required, Optional<Component> prompt)
+    private static final EquivalentConstructor CONSTRUCTOR = new EquivalentConstructor(TYPE)
+            .withParam(UUID.class)
+            .withParam(String.class)
+            .withParam(String.class)
+            .withParam(boolean.class)
+            .withParam(Optional.class, Converters.optional(BukkitConverters.getWrappedChatComponentConverter()));
+
+    public WrappedClientboundResourcePackPushPacket() {
+        super(new PacketContainer(TYPE), TYPE);
+    }
+
+    public WrappedClientboundResourcePackPushPacket(String url, String hash, boolean required, UUID id, Optional<WrappedChatComponent> prompt) {
+        this(new PacketContainer(TYPE, CONSTRUCTOR.create(id, url, hash, required, prompt)));
+    }
+
+    public WrappedClientboundResourcePackPushPacket(PacketContainer packet) {
+        super(packet, TYPE);
+    }
+
+    public String getUrl() {
+        return handle.getStrings().read(0);
+    }
+
+    public void setUrl(String url) {
+        handle.getStrings().write(0, url);
+    }
+
+    public String getHash() {
+        return handle.getStrings().read(1);
+    }
+
+    public void setHash(String hash) {
+        handle.getStrings().write(1, hash);
+    }
+
+    public boolean isRequired() {
+        return handle.getBooleans().read(0);
+    }
+
+    public void setRequired(boolean required) {
+        handle.getBooleans().write(0, required);
+    }
+
+    public UUID getId() {
+        return handle.getUUIDs().read(0);
+    }
+
+    public void setId(UUID id) {
+        handle.getUUIDs().write(0, id);
+    }
+
+    public Optional<WrappedChatComponent> getPrompt() {
+        return handle.getOptionals(BukkitConverters.getWrappedChatComponentConverter()).read(0);
+    }
+
+    public void setPrompt(Optional<WrappedChatComponent> prompt) {
+        handle.getOptionals(BukkitConverters.getWrappedChatComponentConverter()).write(0, prompt);
+    }
+}

src/main/java/net/dmulloy2/protocol/wrappers/configuration/clientbound/WrappedClientboundSelectKnownPacksPacket.java

@@ -0,0 +1,42 @@
+package net.dmulloy2.protocol.wrappers.configuration.clientbound;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.events.PacketContainer;
+import com.comphenix.protocol.injector.EquivalentConstructor;
+import com.comphenix.protocol.wrappers.BukkitConverters;
+import com.comphenix.protocol.wrappers.WrappedKnownPack;
+import net.dmulloy2.protocol.AbstractPacket;
+
+import java.util.List;
+
+/**
+ * Wrapper for {@code ClientboundSelectKnownPacks} (configuration phase, clientbound).
+ * Selects known packs.
+ */
+public class WrappedClientboundSelectKnownPacksPacket extends AbstractPacket {
+
+    public static final PacketType TYPE = PacketType.Configuration.Server.SELECT_KNOWN_PACKS;
+
+    private static final EquivalentConstructor CONSTRUCTOR = new EquivalentConstructor(TYPE)
+            .withParam(List.class, BukkitConverters.getListConverter(WrappedKnownPack.CONVERTER));
+
+    public WrappedClientboundSelectKnownPacksPacket() {
+        super(new PacketContainer(TYPE), TYPE);
+    }
+
+    public WrappedClientboundSelectKnownPacksPacket(List<WrappedKnownPack> knownPacks) {
+        this(new PacketContainer(TYPE, CONSTRUCTOR.create(knownPacks)));
+    }
+
+    public WrappedClientboundSelectKnownPacksPacket(PacketContainer packet) {
+        super(packet, TYPE);
+    }
+
+    public List<WrappedKnownPack> getKnownPacks() {
+        return handle.getLists(WrappedKnownPack.CONVERTER).read(0);
+    }
+
+    public void setKnownPacks(List<WrappedKnownPack> knownPacks) {
+        handle.getLists(WrappedKnownPack.CONVERTER).write(0, knownPacks);
+    }
+}

src/main/java/net/dmulloy2/protocol/wrappers/configuration/clientbound/WrappedClientboundServerLinksPacket.java

@@ -0,0 +1,84 @@
+package net.dmulloy2.protocol.wrappers.configuration.clientbound;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.events.PacketContainer;
+import com.comphenix.protocol.reflect.EquivalentConverter;
+import com.comphenix.protocol.utility.MinecraftReflection;
+import com.comphenix.protocol.wrappers.AutoWrapper;
+import com.comphenix.protocol.wrappers.BukkitConverters;
+import com.comphenix.protocol.wrappers.Either;
+import com.comphenix.protocol.wrappers.EnumWrappers;
+import com.comphenix.protocol.wrappers.WrappedChatComponent;
+import net.dmulloy2.protocol.AbstractPacket;
+
+import java.util.List;
+
+/**
+ * Wrapper for {@code ClientboundServerLinksPacket} (configuration phase, clientbound).
+ *
+ * <p>Fields:
+ * <ul>
+ *   <li>{@code List<ServerLinks.UntrustedEntry> links} – server-provided links</li>
+ * </ul>
+ *
+ * <p>NMS: {@code record UntrustedEntry(Either<KnownLinkType, Component> type, String link)}
+ */
+public class WrappedClientboundServerLinksPacket extends AbstractPacket {
+
+    public static final PacketType TYPE = PacketType.Configuration.Server.SERVER_LINKS;
+
+    /** Mirrors NMS {@code ServerLinks.KnownLinkType}; constant order must match. */
+    public enum KnownLinkType {
+        BUG_REPORT, COMMUNITY_GUIDELINES, SUPPORT, STATUS, FEEDBACK,
+        COMMUNITY, WEBSITE, FORUMS, NEWS, ANNOUNCEMENTS
+    }
+
+    private static final Class<?> NMS_KNOWN_LINK_TYPE_CLASS =
+            MinecraftReflection.getMinecraftClass("server.ServerLinks$KnownLinkType");
+
+    private static final EquivalentConverter<Either<KnownLinkType, WrappedChatComponent>> TYPE_CONVERTER =
+            BukkitConverters.getEitherConverter(
+                    EnumWrappers.getGenericConverter(NMS_KNOWN_LINK_TYPE_CLASS, KnownLinkType.class),
+                    BukkitConverters.getWrappedChatComponentConverter());
+
+    private static final AutoWrapper<WrappedUntrustedEntry> ENTRY_WRAPPER =
+            AutoWrapper.wrap(WrappedUntrustedEntry.class, "server.ServerLinks$UntrustedEntry")
+                    .field(0, TYPE_CONVERTER);
+
+    public WrappedClientboundServerLinksPacket() {
+        super(new PacketContainer(TYPE), TYPE);
+    }
+
+    public WrappedClientboundServerLinksPacket(PacketContainer packet) {
+        super(packet, TYPE);
+    }
+
+    /**
+     * Returns the list of server links.
+     */
+    public List<WrappedUntrustedEntry> getLinks() {
+        List<WrappedUntrustedEntry> links = handle.getLists(ENTRY_WRAPPER).read(0);
+        return links != null ? links : List.of();
+    }
+
+    public void setLinks(List<WrappedUntrustedEntry> links) {
+        handle.getLists(ENTRY_WRAPPER).write(0, links);
+    }
+
+    /**
+     * POJO mirroring {@code record ServerLinks.UntrustedEntry(Either<KnownLinkType, Component> type, String link)}.
+     */
+    public static final class WrappedUntrustedEntry {
+        /** Either a {@link KnownLinkType} (left) or a custom {@link WrappedChatComponent} display name (right). */
+        public Either<KnownLinkType, WrappedChatComponent> type;
+        /** The URL string. */
+        public String link;
+
+        public WrappedUntrustedEntry() {}
+
+        public WrappedUntrustedEntry(Either<KnownLinkType, WrappedChatComponent> type, String link) {
+            this.type = type;
+            this.link = link;
+        }
+    }
+}

src/main/java/net/dmulloy2/protocol/wrappers/configuration/clientbound/WrappedClientboundShowDialogPacket.java

@@ -0,0 +1,25 @@
+package net.dmulloy2.protocol.wrappers.configuration.clientbound;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.events.PacketContainer;
+import net.dmulloy2.protocol.AbstractPacket;
+
+/**
+ * Wrapper for {@code ClientboundShowDialogPacket} (configuration phase, clientbound).
+ * Sends a dialog to the client.
+ */
+public class WrappedClientboundShowDialogPacket extends AbstractPacket {
+
+    public static final PacketType TYPE = PacketType.Configuration.Server.SHOW_DIALOG;
+
+    public WrappedClientboundShowDialogPacket() {
+        super(new PacketContainer(TYPE), TYPE);
+    }
+
+    public WrappedClientboundShowDialogPacket(PacketContainer packet) {
+        super(packet, TYPE);
+    }
+
+    // TODO: missing field 'dialog' (NMS type: Holder<Dialog> — registry-backed dialog definition)
+    //   Same as the game-phase ShowDialog packet. Use handle.getModifier().read(0) for the raw Holder<Dialog>.
+}

src/main/java/net/dmulloy2/protocol/wrappers/configuration/clientbound/WrappedClientboundStoreCookiePacket.java

@@ -0,0 +1,53 @@
+package net.dmulloy2.protocol.wrappers.configuration.clientbound;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.events.PacketContainer;
+import com.comphenix.protocol.injector.EquivalentConstructor;
+import com.comphenix.protocol.utility.MinecraftReflection;
+import com.comphenix.protocol.wrappers.MinecraftKey;
+import net.dmulloy2.protocol.AbstractPacket;
+
+/**
+ * Wrapper for {@code ClientboundStoreCookiePacket} (configuration phase, clientbound).
+ *
+ * <p>Packet structure:
+ * <ul>
+ *   <li>{@code Identifier key} – namespaced key identifying the cookie</li>
+ *   <li>{@code byte[] payload} – cookie data (max 5120 bytes)</li>
+ * </ul>
+ */
+public class WrappedClientboundStoreCookiePacket extends AbstractPacket {
+
+    public static final PacketType TYPE = PacketType.Configuration.Server.STORE_COOKIE;
+    private static final EquivalentConstructor CONSTRUCTOR = new EquivalentConstructor(TYPE)
+            .withParam(MinecraftReflection.getMinecraftKeyClass(), MinecraftKey.getConverter())
+            .withParam(byte[].class);
+
+    public WrappedClientboundStoreCookiePacket() {
+        super(new PacketContainer(TYPE), TYPE);
+    }
+
+    public WrappedClientboundStoreCookiePacket(MinecraftKey key, byte[] payload) {
+        this(new PacketContainer(TYPE, CONSTRUCTOR.create(key, payload)));
+    }
+
+    public WrappedClientboundStoreCookiePacket(PacketContainer packet) {
+        super(packet, TYPE);
+    }
+
+    public MinecraftKey getKey() {
+        return handle.getMinecraftKeys().read(0);
+    }
+
+    public void setKey(MinecraftKey key) {
+        handle.getMinecraftKeys().write(0, key);
+    }
+
+    public byte[] getPayload() {
+        return handle.getByteArrays().read(0);
+    }
+
+    public void setPayload(byte[] payload) {
+        handle.getByteArrays().write(0, payload);
+    }
+}

src/main/java/net/dmulloy2/protocol/wrappers/configuration/clientbound/WrappedClientboundTransferPacket.java

@@ -0,0 +1,45 @@
+package net.dmulloy2.protocol.wrappers.configuration.clientbound;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.events.PacketContainer;
+import com.comphenix.protocol.injector.EquivalentConstructor;
+import net.dmulloy2.protocol.AbstractPacket;
+
+/**
+ * Wrapper for {@code ClientboundTransferPacket} (configuration phase, clientbound).
+ */
+public class WrappedClientboundTransferPacket extends AbstractPacket {
+
+    public static final PacketType TYPE = PacketType.Configuration.Server.TRANSFER;
+    private static final EquivalentConstructor CONSTRUCTOR = new EquivalentConstructor(TYPE)
+            .withParam(String.class)
+            .withParam(int.class);
+
+    public WrappedClientboundTransferPacket() {
+        super(new PacketContainer(TYPE), TYPE);
+    }
+
+    public WrappedClientboundTransferPacket(String host, int port) {
+        this(new PacketContainer(TYPE, CONSTRUCTOR.create(host, port)));
+    }
+
+    public WrappedClientboundTransferPacket(PacketContainer packet) {
+        super(packet, TYPE);
+    }
+
+    public String getHost() {
+        return handle.getStrings().read(0);
+    }
+
+    public void setHost(String host) {
+        handle.getStrings().write(0, host);
+    }
+
+    public int getPort() {
+        return handle.getIntegers().read(0);
+    }
+
+    public void setPort(int port) {
+        handle.getIntegers().write(0, port);
+    }
+}

src/main/java/net/dmulloy2/protocol/wrappers/configuration/clientbound/WrappedClientboundUpdateEnabledFeaturesPacket.java

@@ -0,0 +1,45 @@
+package net.dmulloy2.protocol.wrappers.configuration.clientbound;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.events.PacketContainer;
+import com.comphenix.protocol.injector.EquivalentConstructor;
+import com.comphenix.protocol.wrappers.BukkitConverters;
+import com.comphenix.protocol.wrappers.MinecraftKey;
+import java.util.Set;
+import net.dmulloy2.protocol.AbstractPacket;
+
+/**
+ * Wrapper for {@code ClientboundUpdateEnabledFeaturesPacket} (configuration phase, clientbound).
+ *
+ * <p>Packet structure:
+ * <ul>
+ *   <li>{@code Set<ResourceLocation> features} – set of enabled feature flag identifiers</li>
+ * </ul>
+ */
+public class WrappedClientboundUpdateEnabledFeaturesPacket extends AbstractPacket {
+
+    public static final PacketType TYPE = PacketType.Configuration.Server.UPDATE_ENABLED_FEATURES;
+
+    private static final EquivalentConstructor CONSTRUCTOR = new EquivalentConstructor(TYPE)
+            .withParam(Set.class, BukkitConverters.getSetConverter(MinecraftKey.getConverter()));
+
+    public WrappedClientboundUpdateEnabledFeaturesPacket() {
+        super(new PacketContainer(TYPE), TYPE);
+    }
+
+    public WrappedClientboundUpdateEnabledFeaturesPacket(Set<MinecraftKey> features) {
+        this(new PacketContainer(TYPE, CONSTRUCTOR.create(features)));
+    }
+
+    public WrappedClientboundUpdateEnabledFeaturesPacket(PacketContainer packet) {
+        super(packet, TYPE);
+    }
+
+    public Set<MinecraftKey> getFeatures() {
+        return handle.getSets(MinecraftKey.getConverter()).readSafely(0);
+    }
+
+    public void setFeatures(Set<MinecraftKey> features) {
+        handle.getSets(MinecraftKey.getConverter()).writeSafely(0, features);
+    }
+}

src/main/java/net/dmulloy2/protocol/wrappers/configuration/clientbound/WrappedClientboundUpdateTagsPacket.java

@@ -0,0 +1,44 @@
+package net.dmulloy2.protocol.wrappers.configuration.clientbound;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.events.PacketContainer;
+import com.comphenix.protocol.injector.EquivalentConstructor;
+import com.comphenix.protocol.wrappers.BukkitConverters;
+import com.comphenix.protocol.wrappers.MinecraftKey;
+import com.comphenix.protocol.wrappers.WrappedTagPayload;
+import net.dmulloy2.protocol.AbstractPacket;
+
+import java.util.Map;
+
+/**
+ * Wrapper for {@code ClientboundUpdateTagsPacket} (configuration phase, clientbound).
+ */
+public class WrappedClientboundUpdateTagsPacket extends AbstractPacket {
+
+    public static final PacketType TYPE = PacketType.Configuration.Server.UPDATE_TAGS;
+
+    private static final EquivalentConstructor CONSTRUCTOR = new EquivalentConstructor(TYPE)
+            .withParam(Map.class, BukkitConverters.getMapConverter(
+                    WrappedTagPayload.REGISTRY_KEY_CONVERTER,
+                    WrappedTagPayload.CONVERTER));
+
+    public WrappedClientboundUpdateTagsPacket() {
+        super(new PacketContainer(TYPE), TYPE);
+    }
+
+    public WrappedClientboundUpdateTagsPacket(Map<MinecraftKey, WrappedTagPayload> tags) {
+        this(new PacketContainer(TYPE, CONSTRUCTOR.create(tags)));
+    }
+
+    public WrappedClientboundUpdateTagsPacket(PacketContainer packet) {
+        super(packet, TYPE);
+    }
+
+    public Map<MinecraftKey, WrappedTagPayload> getTags() {
+        return handle.getMaps(WrappedTagPayload.REGISTRY_KEY_CONVERTER, WrappedTagPayload.CONVERTER).read(0);
+    }
+
+    public void setTags(Map<MinecraftKey, WrappedTagPayload> tags) {
+        handle.getMaps(WrappedTagPayload.REGISTRY_KEY_CONVERTER, WrappedTagPayload.CONVERTER).write(0, tags);
+    }
+}

src/main/java/net/dmulloy2/protocol/wrappers/configuration/serverbound/WrappedServerboundClientInformationPacket.java

@@ -0,0 +1,81 @@
+package net.dmulloy2.protocol.wrappers.configuration.serverbound;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.events.PacketContainer;
+import com.comphenix.protocol.utility.MinecraftReflection;
+import com.comphenix.protocol.wrappers.AutoWrapper;
+import com.comphenix.protocol.wrappers.EnumWrappers;
+import net.dmulloy2.protocol.AbstractPacket;
+
+/**
+ * Wrapper for {@code ServerboundClientInformationPacket} (configuration phase, serverbound).
+ *
+ * <p>The packet wraps a single {@code ClientInformation} record, exposed via
+ * {@link #getInformation()} / {@link #setInformation(WrappedClientInformation)}.
+ *
+ * <p>NMS: {@code record ClientInformation(String language, int viewDistance,
+ * ChatVisiblity chatVisibility, boolean chatColors, int modelCustomisation,
+ * HumanoidArm mainHand, boolean textFilteringEnabled, boolean allowsListing,
+ * ParticleStatus particleStatus)}
+ */
+public class WrappedServerboundClientInformationPacket extends AbstractPacket {
+
+    public static final PacketType TYPE = PacketType.Configuration.Client.CLIENT_INFORMATION;
+
+    private static final Class<?> CLIENT_INFORMATION_CLASS =
+            MinecraftReflection.getMinecraftClass("server.level.ClientInformation");
+    private static final Class<?> HUMANOID_ARM_CLASS =
+            MinecraftReflection.getMinecraftClass("world.entity.HumanoidArm");
+    private static final Class<?> PARTICLE_STATUS_CLASS =
+            MinecraftReflection.getMinecraftClass("server.level.ParticleStatus");
+
+    private static final EnumWrappers.EnumConverter<MainHand> MAIN_HAND_CONVERTER =
+            new EnumWrappers.EnumConverter<>(HUMANOID_ARM_CLASS, MainHand.class);
+
+    private static final AutoWrapper<WrappedClientInformation> INFORMATION_WRAPPER =
+            AutoWrapper.wrap(WrappedClientInformation.class, CLIENT_INFORMATION_CLASS)
+                    .field(2, EnumWrappers.getChatVisibilityConverter())
+                    .field(5, MAIN_HAND_CONVERTER)
+                    .field(8, EnumWrappers.getGenericConverter(PARTICLE_STATUS_CLASS, ParticleStatus.class));
+
+    public WrappedServerboundClientInformationPacket() {
+        super(new PacketContainer(TYPE), TYPE);
+    }
+
+    public WrappedServerboundClientInformationPacket(PacketContainer packet) {
+        super(packet, TYPE);
+    }
+
+    /** Returns the client settings, read from the underlying NMS {@code ClientInformation} record. */
+    public WrappedClientInformation getInformation() {
+        return handle.getModifier().withType(CLIENT_INFORMATION_CLASS, INFORMATION_WRAPPER).read(0);
+    }
+
+    /** Writes the client settings back to the underlying NMS {@code ClientInformation} record. */
+    public void setInformation(WrappedClientInformation info) {
+        handle.getModifier().withType(CLIENT_INFORMATION_CLASS, INFORMATION_WRAPPER).write(0, info);
+    }
+
+    /** POJO mirroring {@code record ClientInformation(...)}. */
+    public static final class WrappedClientInformation {
+        public String language;
+        public int viewDistance;
+        /** ProtocolLib {@link EnumWrappers.ChatVisibility}. */
+        public EnumWrappers.ChatVisibility chatVisibility;
+        public boolean chatColors;
+        public int modelCustomisation;
+        /** Dominant arm: {@link MainHand#LEFT} or {@link MainHand#RIGHT}. */
+        public MainHand mainHand;
+        public boolean textFilteringEnabled;
+        public boolean allowsListing;
+        public ParticleStatus particleStatus;
+
+        public WrappedClientInformation() {}
+    }
+
+    /** Mirrors {@code HumanoidArm}: the player's dominant arm setting. */
+    public enum MainHand { LEFT, RIGHT }
+
+    /** Mirrors NMS {@code ParticleStatus}; constant order must match. */
+    public enum ParticleStatus { ALL, DECREASED, MINIMAL }
+}

src/main/java/net/dmulloy2/protocol/wrappers/configuration/serverbound/WrappedServerboundCookieResponsePacket.java

@@ -0,0 +1,54 @@
+package net.dmulloy2.protocol.wrappers.configuration.serverbound;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.events.PacketContainer;
+import com.comphenix.protocol.injector.EquivalentConstructor;
+import com.comphenix.protocol.utility.MinecraftReflection;
+import com.comphenix.protocol.wrappers.MinecraftKey;
+import net.dmulloy2.protocol.AbstractPacket;
+
+/**
+ * Wrapper for {@code ServerboundCookieResponsePacket} (configuration phase, serverbound).
+ *
+ * <p>Packet structure:
+ * <ul>
+ *   <li>{@code Identifier key} – namespaced key identifying the cookie</li>
+ *   <li>{@code byte[] payload} – cookie bytes, or {@code null} if the client has no value</li>
+ * </ul>
+ */
+public class WrappedServerboundCookieResponsePacket extends AbstractPacket {
+
+    public static final PacketType TYPE = PacketType.Configuration.Client.COOKIE_RESPONSE;
+
+    private static final EquivalentConstructor CONSTRUCTOR = new EquivalentConstructor(TYPE)
+            .withParam(MinecraftReflection.getMinecraftKeyClass(), MinecraftKey.getConverter())
+            .withParam(byte[].class);
+
+    public WrappedServerboundCookieResponsePacket() {
+        super(new PacketContainer(TYPE), TYPE);
+    }
+
+    public WrappedServerboundCookieResponsePacket(MinecraftKey key, byte[] payload) {
+        this(new PacketContainer(TYPE, CONSTRUCTOR.create(key, payload)));
+    }
+
+    public WrappedServerboundCookieResponsePacket(PacketContainer packet) {
+        super(packet, TYPE);
+    }
+
+    public MinecraftKey getKey() {
+        return handle.getMinecraftKeys().readSafely(0);
+    }
+
+    public void setKey(MinecraftKey key) {
+        handle.getMinecraftKeys().writeSafely(0, key);
+    }
+
+    public byte[] getPayload() {
+        return handle.getByteArrays().readSafely(0);
+    }
+
+    public void setPayload(byte[] payload) {
+        handle.getByteArrays().writeSafely(0, payload);
+    }
+}

src/main/java/net/dmulloy2/protocol/wrappers/configuration/serverbound/WrappedServerboundCustomClickActionPacket.java

@@ -0,0 +1,45 @@
+package net.dmulloy2.protocol.wrappers.configuration.serverbound;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.events.PacketContainer;
+import com.comphenix.protocol.injector.EquivalentConstructor;
+import com.comphenix.protocol.utility.MinecraftReflection;
+import com.comphenix.protocol.wrappers.BukkitConverters;
+import com.comphenix.protocol.wrappers.Converters;
+import com.comphenix.protocol.wrappers.MinecraftKey;
+import com.comphenix.protocol.wrappers.nbt.NbtBase;
+import net.dmulloy2.protocol.AbstractPacket;
+import java.util.Optional;
+
+/**
+ * Wrapper for {@code ServerboundCustomClickActionPacket} (configuration phase, serverbound).
+ *
+ * <p>Sent when the client clicks a custom button identified by a resource-location key.
+ */
+public class WrappedServerboundCustomClickActionPacket extends AbstractPacket {
+
+    public static final PacketType TYPE = PacketType.Configuration.Client.CUSTOM_CLICK_ACTION;
+    private static final EquivalentConstructor CONSTRUCTOR = new EquivalentConstructor(TYPE)
+            .withParam(MinecraftReflection.getMinecraftKeyClass(), MinecraftKey.getConverter())
+            .withParam(Optional.class, Converters.optional(BukkitConverters.getNbtConverter()));
+
+    public WrappedServerboundCustomClickActionPacket() {
+        super(new PacketContainer(TYPE), TYPE);
+    }
+
+    public WrappedServerboundCustomClickActionPacket(MinecraftKey id, Optional<NbtBase<?>> payload) {
+        this(new PacketContainer(TYPE, CONSTRUCTOR.create(id, payload)));
+    }
+
+    public WrappedServerboundCustomClickActionPacket(PacketContainer packet) {
+        super(packet, TYPE);
+    }
+
+    public MinecraftKey getId() {
+        return handle.getMinecraftKeys().read(0);
+    }
+
+    public void setId(MinecraftKey id) {
+        handle.getMinecraftKeys().write(0, id);
+    }
+}

src/main/java/net/dmulloy2/protocol/wrappers/configuration/serverbound/WrappedServerboundCustomPayloadPacket.java

@@ -0,0 +1,42 @@
+package net.dmulloy2.protocol.wrappers.configuration.serverbound;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.events.PacketContainer;
+import com.comphenix.protocol.injector.EquivalentConstructor;
+import com.comphenix.protocol.wrappers.CustomPacketPayloadWrapper;
+import net.dmulloy2.protocol.AbstractPacket;
+
+/**
+ * Wrapper for {@code ServerboundCustomPayloadPacket} (configuration phase, serverbound).
+ *
+ * <p>Packet structure:
+ * <ul>
+ *   <li>{@code CustomPacketPayload payload} – channel-specific payload data</li>
+ * </ul>
+ */
+public class WrappedServerboundCustomPayloadPacket extends AbstractPacket {
+
+    public static final PacketType TYPE = PacketType.Configuration.Client.CUSTOM_PAYLOAD;
+    private static final EquivalentConstructor CONSTRUCTOR = new EquivalentConstructor(TYPE)
+            .withParam(CustomPacketPayloadWrapper.getCustomPacketPayloadClass(), CustomPacketPayloadWrapper.getConverter());
+
+    public WrappedServerboundCustomPayloadPacket() {
+        super(new PacketContainer(TYPE), TYPE);
+    }
+
+    public WrappedServerboundCustomPayloadPacket(CustomPacketPayloadWrapper payload) {
+        this(new PacketContainer(TYPE, CONSTRUCTOR.create(payload)));
+    }
+
+    public WrappedServerboundCustomPayloadPacket(PacketContainer packet) {
+        super(packet, TYPE);
+    }
+
+    public CustomPacketPayloadWrapper getPayload() {
+        return handle.getCustomPacketPayloads().read(0);
+    }
+
+    public void setPayload(CustomPacketPayloadWrapper payload) {
+        handle.getCustomPacketPayloads().write(0, payload);
+    }
+}