Remove Keyed from Registry generic qualifierfeature/improve-Registry

6 files changed, 903 insertions, 1 deletions

diff --git a/patches/api/0487-Remove-Keyed-from-Registry-generic-qualifier.patch b/patches/api/0487-Remove-Keyed-from-Registry-generic-qualifier.patch
new file mode 100644
index 0000000000..daf60ad446
--- /dev/null
+++ b/patches/api/0487-Remove-Keyed-from-Registry-generic-qualifier.patch
@@ -0,0 +1,150 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <[email protected]>
+Date: Wed, 20 Dec 2023 02:03:10 -0800
+Subject: [PATCH] Remove Keyed from Registry generic qualifier
+
+Keyed is no longer viable for future/current registry types.
+
+diff --git a/src/main/java/org/bukkit/Art.java b/src/main/java/org/bukkit/Art.java
+index dbbd997d4693f1d9f551bae2ed1d7906c9f39c12..808633907b21528d9d0af1f13cbd1fb4b783c2e1 100644
+--- a/src/main/java/org/bukkit/Art.java
++++ b/src/main/java/org/bukkit/Art.java
+@@ -105,7 +105,7 @@ public enum Art implements Keyed {
+ 
+     // Paper start - deprecate getKey
+     /**
+-     * @deprecated use {@link Registry#getKey(Keyed)} and {@link Registry#ART}. Painting variants
++     * @deprecated use {@link Registry#getKey(Object)} and {@link Registry#ART}. Painting variants
+      * can exist without a key.
+      */
+     @Deprecated(since = "1.21")
+diff --git a/src/main/java/org/bukkit/MusicInstrument.java b/src/main/java/org/bukkit/MusicInstrument.java
+index 98fdfc8978fea1937e31a7427433a1927d42ec7d..2a46d9d24afcffa26fa3ad398abddd0ed32351b8 100644
+--- a/src/main/java/org/bukkit/MusicInstrument.java
++++ b/src/main/java/org/bukkit/MusicInstrument.java
+@@ -55,7 +55,7 @@ public abstract class MusicInstrument implements Keyed, net.kyori.adventure.tran
+ 
+     // Paper start - deprecate getKey
+     /**
+-     * @deprecated use {@link Registry#getKey(Keyed)} and {@link Registry#INSTRUMENT}. MusicInstruments
++     * @deprecated use {@link Registry#getKey(Object)} and {@link Registry#INSTRUMENT}. MusicInstruments
+      * can exist without a key.
+      */
+     @Deprecated(forRemoval = true, since = "1.20.5")
+diff --git a/src/main/java/org/bukkit/Registry.java b/src/main/java/org/bukkit/Registry.java
+index 20015393f91af405c99db2635a471fb6ff19e4bf..3a222cad7310f19b02471b04f1f24c8ef283655f 100644
+--- a/src/main/java/org/bukkit/Registry.java
++++ b/src/main/java/org/bukkit/Registry.java
+@@ -43,7 +43,7 @@ import org.jetbrains.annotations.Nullable;
+  *
+  * @param <T> type of item in the registry
+  */
+-public interface Registry<T extends Keyed> extends Iterable<T> {
++public interface Registry<T> extends Iterable<T> { // Paper - improve Registry
+ 
+     /**
+      * Server advancements.
+@@ -421,7 +421,7 @@ public interface Registry<T extends Keyed> extends Iterable<T> {
+      * @param value the value to get the key of in this registry
+      * @return the key for the value
+      * @throws java.util.NoSuchElementException if the value doesn't exist in this registry
+-     * @see #getKey(Keyed)
++     * @see #getKey(Object)
+      */
+     default @NotNull NamespacedKey getKeyOrThrow(final @NotNull T value) {
+         Preconditions.checkArgument(value != null, "value cannot be null");
+@@ -441,13 +441,12 @@ public interface Registry<T extends Keyed> extends Iterable<T> {
+      *
+      * @param value the value to get the key of in this registry
+      * @return the key for the value or null if not in the registry
+-     * @see #getKeyOrThrow(Keyed)
++     * @see #getKeyOrThrow(Object)
+      */
+     default @Nullable NamespacedKey getKey(final @NotNull T value) {
+         Preconditions.checkArgument(value != null, "value cannot be null");
+-        //noinspection ConstantValue (it might not be in the future...)
+-        if (value instanceof Keyed) {
+-            return value.getKey();
++        if (value instanceof final Keyed keyed) {
++            return keyed.getKey();
+         }
+         return null;
+     }
+diff --git a/src/main/java/org/bukkit/Sound.java b/src/main/java/org/bukkit/Sound.java
+index 7a35120c82b88774de777d3c3176ef553a8e9244..f67749a4e1072a3d604cfc9d0d9e84fd02796a64 100644
+--- a/src/main/java/org/bukkit/Sound.java
++++ b/src/main/java/org/bukkit/Sound.java
+@@ -1638,7 +1638,7 @@ public enum Sound implements Keyed, net.kyori.adventure.sound.Sound.Type { // Pa
+ 
+     // Paper start - deprecate getKey
+     /**
+-     * @deprecated use {@link Registry#getKey(Keyed)} and {@link Registry#SOUNDS}. Sounds
++     * @deprecated use {@link Registry#getKey(Object)} and {@link Registry#SOUNDS}. Sounds
+      * can exist without a key.
+      */
+     @Deprecated(since = "1.20.5")
+diff --git a/src/main/java/org/bukkit/Tag.java b/src/main/java/org/bukkit/Tag.java
+index 8bfec649f7c6dda956bc388a21b489f3565ff384..0ab13cbf60bf07b6868b2cd11da6007e06474339 100644
+--- a/src/main/java/org/bukkit/Tag.java
++++ b/src/main/java/org/bukkit/Tag.java
+@@ -17,7 +17,7 @@ import org.jetbrains.annotations.NotNull;
+  *
+  * @param <T> the type of things grouped by this tag
+  */
+-public interface Tag<T extends Keyed> extends Keyed {
++public interface Tag<T> extends Keyed {
+ 
+     /**
+      * Key for the built in block registry.
+diff --git a/src/main/java/org/bukkit/block/banner/PatternType.java b/src/main/java/org/bukkit/block/banner/PatternType.java
+index e2afb2582a27b94a922754115dbb6b4ca35e0154..1ac45205c16fb0bdebea610bd88b48b757cceafc 100644
+--- a/src/main/java/org/bukkit/block/banner/PatternType.java
++++ b/src/main/java/org/bukkit/block/banner/PatternType.java
+@@ -58,7 +58,7 @@ public interface PatternType extends OldEnum<PatternType>, Keyed {
+ 
+     // Paper start - deprecate getKey
+     /**
+-     * @deprecated use {@link Registry#getKey(Keyed)} and {@link Registry#BANNER_PATTERN}. PatternTypes
++     * @deprecated use {@link Registry#getKey(Object)} and {@link Registry#BANNER_PATTERN}. PatternTypes
+      * can exist without a key.
+      */
+     @Deprecated(since = "1.20.5")
+diff --git a/src/main/java/org/bukkit/generator/structure/Structure.java b/src/main/java/org/bukkit/generator/structure/Structure.java
+index 978054ee364f9a3330525b9b50da5325ebb6ef57..0bb73cf7b1c2ef2e3cf0d1d9121e8b2c5a133c0d 100644
+--- a/src/main/java/org/bukkit/generator/structure/Structure.java
++++ b/src/main/java/org/bukkit/generator/structure/Structure.java
+@@ -62,7 +62,7 @@ public abstract class Structure implements Keyed {
+     public abstract StructureType getStructureType();
+     // Paper start - deprecate getKey
+     /**
+-     * @deprecated use {@link Registry#getKey(Keyed)} and {@link Registry#STRUCTURE}. Structures
++     * @deprecated use {@link Registry#getKey(Object)} and {@link Registry#STRUCTURE}. Structures
+      * can exist without a key.
+      */
+     @Override
+diff --git a/src/main/java/org/bukkit/inventory/meta/trim/TrimMaterial.java b/src/main/java/org/bukkit/inventory/meta/trim/TrimMaterial.java
+index 74816d6da4d7c8d2fa8a7b93fdc4bf29c8d12803..f3ce71ddf57c03c050f4832a36dff2c2714a94ac 100644
+--- a/src/main/java/org/bukkit/inventory/meta/trim/TrimMaterial.java
++++ b/src/main/java/org/bukkit/inventory/meta/trim/TrimMaterial.java
+@@ -71,7 +71,7 @@ public interface TrimMaterial extends Keyed, Translatable {
+ 
+     // Paper start - Registry#getKey
+     /**
+-     * @deprecated use {@link Registry#getKey(Keyed)} and {@link Registry#TRIM_MATERIAL}. TrimMaterials
++     * @deprecated use {@link Registry#getKey(Object)} and {@link Registry#TRIM_MATERIAL}. TrimMaterials
+      * can exist without a key.
+      */
+     @Deprecated(forRemoval = true, since = "1.20.4")
+diff --git a/src/main/java/org/bukkit/inventory/meta/trim/TrimPattern.java b/src/main/java/org/bukkit/inventory/meta/trim/TrimPattern.java
+index 087e99ed281c0b282d91345067bfca80762faa0b..e0c89036e2da05e837a214f7b485ae5de6587729 100644
+--- a/src/main/java/org/bukkit/inventory/meta/trim/TrimPattern.java
++++ b/src/main/java/org/bukkit/inventory/meta/trim/TrimPattern.java
+@@ -103,7 +103,7 @@ public interface TrimPattern extends Keyed, Translatable {
+ 
+     // Paper start - Registry#getKey
+     /**
+-     * @deprecated use {@link Registry#getKey(Keyed)} and {@link Registry#TRIM_PATTERN}. TrimPatterns
++     * @deprecated use {@link Registry#getKey(Object)} and {@link Registry#TRIM_PATTERN}. TrimPatterns
+      * can exist without a key.
+      */
+     @Deprecated(forRemoval = true, since = "1.20.4")
diff --git a/patches/api/0488-remove-some-extends-Keyed-generic-qualifiers.patch b/patches/api/0488-remove-some-extends-Keyed-generic-qualifiers.patch
new file mode 100644
index 0000000000..8d9c542b98
--- /dev/null
+++ b/patches/api/0488-remove-some-extends-Keyed-generic-qualifiers.patch
@@ -0,0 +1,125 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <[email protected]>
+Date: Tue, 27 Aug 2024 22:07:38 -0700
+Subject: [PATCH] remove some extends Keyed generic qualifiers
+
+
+diff --git a/src/main/java/io/papermc/paper/registry/RegistryAccess.java b/src/main/java/io/papermc/paper/registry/RegistryAccess.java
+index 86ab67ff5023bf6adea80b02648b6f67476e30e5..5cf423b1f54557ed497b2af2d6cd27b8cd1a7753 100644
+--- a/src/main/java/io/papermc/paper/registry/RegistryAccess.java
++++ b/src/main/java/io/papermc/paper/registry/RegistryAccess.java
+@@ -45,5 +45,5 @@ public interface RegistryAccess {
+      */
+     // Future note: We should have no trouble removing this generic qualifier when
+     // registry types no longer have to be "keyed" as it shouldn't break ABI or API.
+-    <T extends Keyed> @NotNull Registry<T> getRegistry(@NotNull RegistryKey<T> registryKey);
++    <T> @NotNull Registry<T> getRegistry(@NotNull RegistryKey<T> registryKey);
+ }
+diff --git a/src/main/java/io/papermc/paper/registry/event/RegistryEntryAddEvent.java b/src/main/java/io/papermc/paper/registry/event/RegistryEntryAddEvent.java
+index a5d7385eae9dfb88b52aed0e42c09a10ef807385..2f8741237a98e3d04ff47ddd312d22611a70522f 100644
+--- a/src/main/java/io/papermc/paper/registry/event/RegistryEntryAddEvent.java
++++ b/src/main/java/io/papermc/paper/registry/event/RegistryEntryAddEvent.java
+@@ -43,5 +43,5 @@ public interface RegistryEntryAddEvent<T, B extends RegistryBuilder<T>> extends
+      * @return the tag
+      * @param <V> the tag value type
+      */
+-    @NonNull <V extends Keyed> Tag<V> getOrCreateTag(@NonNull TagKey<V> tagKey);
++    @NonNull <V> Tag<V> getOrCreateTag(@NonNull TagKey<V> tagKey);
+ }
+diff --git a/src/main/java/io/papermc/paper/registry/event/RegistryFreezeEvent.java b/src/main/java/io/papermc/paper/registry/event/RegistryFreezeEvent.java
+index 12ec7e794a5047a30354a485acd40fa0f3438eea..5e67833850b160363566929a7a8bc6da7107e16e 100644
+--- a/src/main/java/io/papermc/paper/registry/event/RegistryFreezeEvent.java
++++ b/src/main/java/io/papermc/paper/registry/event/RegistryFreezeEvent.java
+@@ -35,5 +35,5 @@ public interface RegistryFreezeEvent<T, B extends RegistryBuilder<T>> extends Re
+      * @return the tag
+      * @param <V> the tag value type
+      */
+-    @NonNull <V extends Keyed> Tag<V> getOrCreateTag(@NonNull TagKey<V> tagKey);
++    @NonNull <V> Tag<V> getOrCreateTag(@NonNull TagKey<V> tagKey);
+ }
+diff --git a/src/main/java/io/papermc/paper/registry/set/RegistryKeySet.java b/src/main/java/io/papermc/paper/registry/set/RegistryKeySet.java
+index b891101b43148f63c96b7dd611914c85d7b29dbf..3683fd7222711a3c26022a291ce74fd733c1bbb1 100644
+--- a/src/main/java/io/papermc/paper/registry/set/RegistryKeySet.java
++++ b/src/main/java/io/papermc/paper/registry/set/RegistryKeySet.java
+@@ -11,7 +11,7 @@ import org.jetbrains.annotations.Unmodifiable;
+ 
+ @ApiStatus.Experimental
+ @ApiStatus.NonExtendable
+-public non-sealed interface RegistryKeySet<T extends Keyed> extends Iterable<TypedKey<T>>, RegistrySet<T> { // TODO remove Keyed
++public non-sealed interface RegistryKeySet<T> extends Iterable<TypedKey<T>>, RegistrySet<T> {
+ 
+     @Override
+     default int size() {
+diff --git a/src/main/java/io/papermc/paper/registry/set/RegistryKeySetImpl.java b/src/main/java/io/papermc/paper/registry/set/RegistryKeySetImpl.java
+index c712181ad4c6a9d00bc04f8a48515a388c692f48..def9afa67af6c22ee8c71a30d73247e49505e485 100644
+--- a/src/main/java/io/papermc/paper/registry/set/RegistryKeySetImpl.java
++++ b/src/main/java/io/papermc/paper/registry/set/RegistryKeySetImpl.java
+@@ -18,9 +18,9 @@ import org.jetbrains.annotations.Nullable;
+ 
+ @ApiStatus.Internal
+ @DefaultQualifier(NonNull.class)
+-record RegistryKeySetImpl<T extends Keyed>(RegistryKey<T> registryKey, List<TypedKey<T>> values) implements RegistryKeySet<T> { // TODO remove Keyed
++record RegistryKeySetImpl<T>(RegistryKey<T> registryKey, List<TypedKey<T>> values) implements RegistryKeySet<T> {
+ 
+-    static <T extends Keyed> RegistryKeySet<T> create(final RegistryKey<T> registryKey, final Iterable<? extends T> values) { // TODO remove Keyed
++    static <T> RegistryKeySet<T> create(final RegistryKey<T> registryKey, final Iterable<? extends T> values) {
+         final Registry<T> registry = RegistryAccess.registryAccess().getRegistry(registryKey);
+         final ArrayList<TypedKey<T>> keys = new ArrayList<>();
+         for (final T value : values) {
+diff --git a/src/main/java/io/papermc/paper/registry/set/RegistrySet.java b/src/main/java/io/papermc/paper/registry/set/RegistrySet.java
+index 108df480e16131781a52c7bbba2ca6581e4c1ca1..f9ff65b9f556f157da562990890d3b0039b5a4d5 100644
+--- a/src/main/java/io/papermc/paper/registry/set/RegistrySet.java
++++ b/src/main/java/io/papermc/paper/registry/set/RegistrySet.java
+@@ -56,7 +56,7 @@ public sealed interface RegistrySet<T> permits RegistryKeySet, RegistryValueSet
+      * @throws IllegalArgumentException if the registry isn't available yet or if any value doesn't have a key in that registry
+      */
+     @Contract(value = "_, _ -> new", pure = true)
+-    static <T extends Keyed> @NonNull RegistryKeySet<T> keySetFromValues(final @NonNull RegistryKey<T> registryKey, final @NonNull Iterable<? extends T> values) { // TODO remove Keyed
++    static <T> @NonNull RegistryKeySet<T> keySetFromValues(final @NonNull RegistryKey<T> registryKey, final @NonNull Iterable<? extends T> values) {
+         return RegistryKeySetImpl.create(registryKey, values);
+     }
+ 
+@@ -69,7 +69,7 @@ public sealed interface RegistrySet<T> permits RegistryKeySet, RegistryValueSet
+      * @param <T> the type of the values
+      */
+     @SafeVarargs
+-    static <T extends Keyed> RegistryKeySet<T> keySet(final @NonNull RegistryKey<T> registryKey, final @NonNull TypedKey<T> @NonNull... keys) { // TODO remove Keyed
++    static <T> RegistryKeySet<T> keySet(final @NonNull RegistryKey<T> registryKey, final @NonNull TypedKey<T> @NonNull... keys) {
+         return keySet(registryKey, Lists.newArrayList(keys));
+     }
+ 
+@@ -83,7 +83,7 @@ public sealed interface RegistrySet<T> permits RegistryKeySet, RegistryValueSet
+      */
+     @SuppressWarnings("BoundedWildcard")
+     @Contract(value = "_, _ -> new", pure = true)
+-    static <T extends Keyed> @NonNull RegistryKeySet<T> keySet(final @NonNull RegistryKey<T> registryKey, final @NonNull Iterable<TypedKey<T>> keys) { // TODO remove Keyed
++    static <T> @NonNull RegistryKeySet<T> keySet(final @NonNull RegistryKey<T> registryKey, final @NonNull Iterable<TypedKey<T>> keys) {
+         return new RegistryKeySetImpl<>(registryKey, Lists.newArrayList(keys));
+     }
+ 
+diff --git a/src/main/java/io/papermc/paper/registry/tag/Tag.java b/src/main/java/io/papermc/paper/registry/tag/Tag.java
+index ae374f68ef9baa16ed90c371f1622de0c0159873..3a1f864bd9421ab38a021d272ff41e491f7cf76f 100644
+--- a/src/main/java/io/papermc/paper/registry/tag/Tag.java
++++ b/src/main/java/io/papermc/paper/registry/tag/Tag.java
+@@ -14,7 +14,7 @@ import org.jetbrains.annotations.ApiStatus;
+  * @see org.bukkit.Registry#getTag(TagKey)
+  */
+ @ApiStatus.Experimental
+-public interface Tag<T extends Keyed> extends RegistryKeySet<T> { // TODO remove Keyed
++public interface Tag<T> extends RegistryKeySet<T> {
+ 
+     /**
+      * Get the identifier for this named set.
+diff --git a/src/test/java/io/papermc/paper/registry/TestRegistryAccess.java b/src/test/java/io/papermc/paper/registry/TestRegistryAccess.java
+index f5ece852f97017f71bc129e194cb212979b2537b..b1ac725ef5ea408b2c7f884787446fd371fd7ea7 100644
+--- a/src/test/java/io/papermc/paper/registry/TestRegistryAccess.java
++++ b/src/test/java/io/papermc/paper/registry/TestRegistryAccess.java
+@@ -14,7 +14,7 @@ public class TestRegistryAccess implements RegistryAccess {
+     }
+ 
+     @Override
+-    public @NotNull <T extends Keyed> Registry<T> getRegistry(final @NotNull RegistryKey<T> registryKey) {
++    public <T> @NotNull Registry<T> getRegistry(final @NotNull RegistryKey<T> registryKey) {
+         throw new UnsupportedOperationException("Not supported");
+     }
+ }
diff --git a/patches/server/1057-Remove-Keyed-from-Registry-generic-qualifier.patch b/patches/server/1057-Remove-Keyed-from-Registry-generic-qualifier.patch
new file mode 100644
index 0000000000..5c5fb8ecfc
--- /dev/null
+++ b/patches/server/1057-Remove-Keyed-from-Registry-generic-qualifier.patch
@@ -0,0 +1,149 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <[email protected]>
+Date: Wed, 20 Dec 2023 02:03:05 -0800
+Subject: [PATCH] Remove Keyed from Registry generic qualifier
+
+Keyed is no longer viable for future/current registry types.
+
+diff --git a/src/main/java/io/papermc/paper/plugin/entrypoint/classloader/bytecode/PaperClassloaderBytecodeModifier.java b/src/main/java/io/papermc/paper/plugin/entrypoint/classloader/bytecode/PaperClassloaderBytecodeModifier.java
+index d7a789af72e5a1ef5e42c7e855897b65fdeda805..f0383c6df4d8ce15f2e04bf589e0c9524e07befb 100644
+--- a/src/main/java/io/papermc/paper/plugin/entrypoint/classloader/bytecode/PaperClassloaderBytecodeModifier.java
++++ b/src/main/java/io/papermc/paper/plugin/entrypoint/classloader/bytecode/PaperClassloaderBytecodeModifier.java
+@@ -3,6 +3,7 @@ package io.papermc.paper.plugin.entrypoint.classloader.bytecode;
+ import com.google.common.collect.Iterators;
+ import io.papermc.paper.plugin.configuration.PluginMeta;
+ import io.papermc.paper.plugin.entrypoint.classloader.ClassloaderBytecodeModifier;
++import io.papermc.paper.plugin.entrypoint.classloader.bytecode.versions.API_1_21_1;
+ import java.util.Iterator;
+ import java.util.LinkedHashMap;
+ import java.util.List;
+@@ -15,6 +16,7 @@ import org.objectweb.asm.Opcodes;
+ public class PaperClassloaderBytecodeModifier implements ClassloaderBytecodeModifier {
+ 
+     private static final Map<ApiVersion, List<ModifierFactory>> MODIFIERS = Util.make(new LinkedHashMap<>(), map -> {
++        map.put(API_1_21_1.API_VERSION, List.of(API_1_21_1::new));
+     });
+ 
+     private final Map<ApiVersion, List<VersionedClassloaderBytecodeModifier>> constructedModifiers = MODIFIERS.entrySet().stream()
+diff --git a/src/main/java/io/papermc/paper/plugin/entrypoint/classloader/bytecode/versions/API_1_21_1.java b/src/main/java/io/papermc/paper/plugin/entrypoint/classloader/bytecode/versions/API_1_21_1.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..e8175d837d611270e873693e88355512a3ec794d
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/plugin/entrypoint/classloader/bytecode/versions/API_1_21_1.java
+@@ -0,0 +1,72 @@
++package io.papermc.paper.plugin.entrypoint.classloader.bytecode.versions;
++
++import io.papermc.asm.rules.RewriteRule;
++import io.papermc.asm.rules.builder.matcher.method.MethodMatcher;
++import io.papermc.asm.rules.builder.matcher.method.targeted.TargetedMethodMatcher;
++import io.papermc.paper.plugin.entrypoint.classloader.bytecode.VersionedClassloaderBytecodeModifier;
++import java.lang.constant.ClassDesc;
++import java.lang.constant.ConstantDescs;
++import java.lang.reflect.Method;
++import org.bukkit.Keyed;
++import org.bukkit.NamespacedKey;
++import org.bukkit.Registry;
++import org.bukkit.Tag;
++import org.bukkit.craftbukkit.util.ApiVersion;
++import org.checkerframework.checker.nullness.qual.Nullable;
++
++import static io.papermc.asm.rules.RewriteRule.chain;
++import static io.papermc.asm.util.DescriptorUtils.desc;
++
++public class API_1_21_1 extends VersionedClassloaderBytecodeModifier {
++
++    public static final ApiVersion API_VERSION = ApiVersion.getOrCreateVersion("1.21.1");
++
++    private static final Method REGISTRY_KEYED_HANDLER;
++    static {
++        try {
++            REGISTRY_KEYED_HANDLER = API_1_21_1.class.getDeclaredMethod("tryCastKeyed", Object.class);
++        } catch (final ReflectiveOperationException exception) {
++            throw new RuntimeException(exception);
++        }
++    }
++
++    private static final ClassDesc KEYED = desc(Keyed.class);
++    private static final ClassDesc NAMESPACED_KEY = desc(NamespacedKey.class);
++
++    public API_1_21_1(final int api) {
++        super(api);
++    }
++
++    @Override
++    protected RewriteRule createRule() {
++        return chain(
++            this.forOwnerClass(Registry.class, rf -> {
++                rf.changeReturnTypeDirect(
++                    Object.class,
++                    REGISTRY_KEYED_HANDLER,
++                    TargetedMethodMatcher.builder()
++                        .match("get", b -> b.itf().hasParam(NAMESPACED_KEY, 0))
++                        .targetReturn(KEYED)
++                        .build()
++                    );
++            }),
++            this.forOwnerClass(Tag.class, rf -> {
++                rf.changeParamToSuper(
++                    KEYED,
++                    ConstantDescs.CD_Object,
++                    MethodMatcher.builder()
++                        .match("isTagged", b -> b.hasParam(KEYED, 0))
++                        .build()
++                );
++            })
++        );
++    }
++
++    public static @Nullable Keyed tryCastKeyed(final @Nullable Object maybeKeyed) {
++        if (maybeKeyed == null) return null;
++        if (maybeKeyed instanceof final Keyed keyed) {
++            return keyed;
++        }
++        throw new IllegalStateException(maybeKeyed + " does not implement Keyed");
++    }
++}
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftRegistry.java b/src/main/java/org/bukkit/craftbukkit/CraftRegistry.java
+index cacbb35d365c66881f2a42d099bb88c494b584ee..711f0949444d24e7a354e96e05b90d69351dafe2 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftRegistry.java
++++ b/src/main/java/org/bukkit/craftbukkit/CraftRegistry.java
+@@ -56,7 +56,7 @@ import org.bukkit.map.MapCursor;
+ import org.bukkit.potion.PotionEffectType;
+ import org.jetbrains.annotations.NotNull;
+ 
+-public class CraftRegistry<B extends Keyed, M> implements Registry<B> {
++public class CraftRegistry<B, M> implements Registry<B> { // Paper - improve Registry
+ 
+     private static RegistryAccess registry;
+ 
+diff --git a/src/test/java/org/bukkit/registry/PerRegistryTest.java b/src/test/java/org/bukkit/registry/PerRegistryTest.java
+index dad7935f9a4c7c8bb2a755cc0631330a59834233..05d8f3ed102a7e1399d234107d85a48832983efa 100644
+--- a/src/test/java/org/bukkit/registry/PerRegistryTest.java
++++ b/src/test/java/org/bukkit/registry/PerRegistryTest.java
+@@ -48,7 +48,7 @@ public class PerRegistryTest extends AbstractTestingBase {
+ 
+     @ParameterizedTest
+     @MethodSource("data")
+-    public <T extends Keyed> void testGet(Registry<T> registry) { // Paper - improve Registry
++    public <T> void testGet(Registry<T> registry) { // Paper - improve Registry
+         registry.forEach(element -> {
+             NamespacedKey key = registry.getKey(element); // Paper - improve Registry
+             assertNotNull(key); // Paper - improve Registry
+@@ -60,7 +60,7 @@ public class PerRegistryTest extends AbstractTestingBase {
+ 
+     @ParameterizedTest
+     @MethodSource("data")
+-    public <T extends Keyed> void testMatch(Registry<T> registry) { // Paper - improve Registry
++    public <T> void testMatch(Registry<T> registry) { // Paper - improve Registry
+         registry.forEach(element -> {
+             NamespacedKey key = registry.getKey(element); // Paper - improve Registry
+             assertNotNull(key); // Paper - improve Registry
+@@ -74,7 +74,7 @@ public class PerRegistryTest extends AbstractTestingBase {
+         });
+     }
+ 
+-    private <T extends Keyed> void assertSameMatchWithKeyMessage(Registry<T> registry, T element, String key) { // Paper - improve Registry
++    private <T> void assertSameMatchWithKeyMessage(Registry<T> registry, T element, String key) { // Paper - improve Registry
+         assertSame(element, registry.match(key), key);
+     }
+ 
diff --git a/patches/server/1058-remove-some-extends-Keyed-generic-qualifiers.patch b/patches/server/1058-remove-some-extends-Keyed-generic-qualifiers.patch
new file mode 100644
index 0000000000..8ac806a0c9
--- /dev/null
+++ b/patches/server/1058-remove-some-extends-Keyed-generic-qualifiers.patch
@@ -0,0 +1,437 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <[email protected]>
+Date: Tue, 27 Aug 2024 22:07:29 -0700
+Subject: [PATCH] remove some extends Keyed generic qualifiers
+
+
+diff --git a/src/main/java/io/papermc/paper/command/brigadier/argument/VanillaArgumentProviderImpl.java b/src/main/java/io/papermc/paper/command/brigadier/argument/VanillaArgumentProviderImpl.java
+index 38fb7d13abfcb55fe4a132b9b27e0c91f8c3d891..ca713fbf5561ea1432c66119561874761a5c9373 100644
+--- a/src/main/java/io/papermc/paper/command/brigadier/argument/VanillaArgumentProviderImpl.java
++++ b/src/main/java/io/papermc/paper/command/brigadier/argument/VanillaArgumentProviderImpl.java
+@@ -304,13 +304,7 @@ public class VanillaArgumentProviderImpl implements VanillaArgumentProvider {
+ 
+     @Override
+     public <T> ArgumentType<T> resource(final RegistryKey<T> registryKey) {
+-        return this.resourceRaw(registryKey);
+-    }
+-
+-    @SuppressWarnings({"unchecked", "rawtypes", "UnnecessaryLocalVariable"})
+-    private <T, K extends Keyed> ArgumentType<T> resourceRaw(final RegistryKey registryKeyRaw) { // TODO remove Keyed
+-        final RegistryKey<K> registryKey = registryKeyRaw;
+-        return (ArgumentType<T>) this.wrap(
++        return this.wrap(
+             ResourceArgument.resource(PaperCommands.INSTANCE.getBuildContext(), PaperRegistries.registryToNms(registryKey)),
+             resource -> requireNonNull(
+                 RegistryAccess.registryAccess()
+diff --git a/src/main/java/io/papermc/paper/registry/PaperRegistries.java b/src/main/java/io/papermc/paper/registry/PaperRegistries.java
+index 6ec9d9b9acf557aa2ebf39d38a14225b0205fae1..1149ee93289ed4ae993972e8a68299f160eb1a60 100644
+--- a/src/main/java/io/papermc/paper/registry/PaperRegistries.java
++++ b/src/main/java/io/papermc/paper/registry/PaperRegistries.java
+@@ -114,12 +114,12 @@ public final class PaperRegistries {
+     }
+ 
+     @SuppressWarnings("unchecked")
+-    public static <M, T extends Keyed> @Nullable RegistryEntry<M, T> getEntry(final ResourceKey<? extends Registry<M>> resourceKey) {
++    public static <M, T> @Nullable RegistryEntry<M, T> getEntry(final ResourceKey<? extends Registry<M>> resourceKey) {
+         return (RegistryEntry<M, T>) BY_RESOURCE_KEY.get(resourceKey);
+     }
+ 
+     @SuppressWarnings("unchecked")
+-    public static <M, T extends Keyed> @Nullable RegistryEntry<M, T> getEntry(final RegistryKey<? super T> registryKey) {
++    public static <M, T> @Nullable RegistryEntry<M, T> getEntry(final RegistryKey<? super T> registryKey) {
+         return (RegistryEntry<M, T>) BY_REGISTRY_KEY.get(registryKey);
+     }
+ 
+diff --git a/src/main/java/io/papermc/paper/registry/PaperRegistryAccess.java b/src/main/java/io/papermc/paper/registry/PaperRegistryAccess.java
+index f05ebf453406a924da3de6fb250f4793a1b3c612..324cca4d7e276fe11c9d6f93a0a4fa3405419171 100644
+--- a/src/main/java/io/papermc/paper/registry/PaperRegistryAccess.java
++++ b/src/main/java/io/papermc/paper/registry/PaperRegistryAccess.java
+@@ -67,7 +67,7 @@ public class PaperRegistryAccess implements RegistryAccess {
+ 
+     @SuppressWarnings("unchecked")
+     @Override
+-    public <T extends Keyed> Registry<T> getRegistry(final RegistryKey<T> key) {
++    public <T> Registry<T> getRegistry(final RegistryKey<T> key) {
+         if (PaperRegistries.getEntry(key) == null) {
+             throw new NoSuchElementException(key + " is not a valid registry key");
+         }
+@@ -80,7 +80,7 @@ public class PaperRegistryAccess implements RegistryAccess {
+         return possiblyUnwrap(registryHolder.get());
+     }
+ 
+-    public <M, T extends Keyed, B extends PaperRegistryBuilder<M, T>> WritableCraftRegistry<M, T, B> getWritableRegistry(final RegistryKey<T> key) {
++    public <M, T, B extends PaperRegistryBuilder<M, T>> WritableCraftRegistry<M, T, B> getWritableRegistry(final RegistryKey<T> key) {
+         final Registry<T> registry = this.getRegistry(key);
+         if (registry instanceof WritableCraftRegistry<?, T, ?>) {
+             return (WritableCraftRegistry<M, T, B>) registry;
+@@ -88,7 +88,7 @@ public class PaperRegistryAccess implements RegistryAccess {
+         throw new IllegalArgumentException(key + " does not point to a writable registry");
+     }
+ 
+-    private static <T extends Keyed> Registry<T> possiblyUnwrap(final Registry<T> registry) {
++    private static <T> Registry<T> possiblyUnwrap(final Registry<T> registry) {
+         if (registry instanceof final DelayedRegistry<T, ?> delayedRegistry) { // if not coming from legacy, unwrap the delayed registry
+             return delayedRegistry.delegate();
+         }
+@@ -104,7 +104,7 @@ public class PaperRegistryAccess implements RegistryAccess {
+     }
+ 
+     @SuppressWarnings("unchecked") // this method should be called right after any new MappedRegistry instances are created to later be used by the server.
+-    private <M, B extends Keyed, R extends Registry<B>> void registerRegistry(final ResourceKey<? extends net.minecraft.core.Registry<M>> resourceKey, final net.minecraft.core.Registry<M> registry, final boolean replace) {
++    private <M, B, R extends Registry<B>> void registerRegistry(final ResourceKey<? extends net.minecraft.core.Registry<M>> resourceKey, final net.minecraft.core.Registry<M> registry, final boolean replace) {
+         final @Nullable RegistryEntry<M, B> entry = PaperRegistries.getEntry(resourceKey);
+         if (entry == null) { // skip registries that don't have API entries
+             return;
+diff --git a/src/main/java/io/papermc/paper/registry/PaperRegistryListenerManager.java b/src/main/java/io/papermc/paper/registry/PaperRegistryListenerManager.java
+index a7f2b264d4f37f5293ae72195b4c78faf35351c9..8529fe4cb36f02f4d2459c03e183a2e8b5e2f859 100644
+--- a/src/main/java/io/papermc/paper/registry/PaperRegistryListenerManager.java
++++ b/src/main/java/io/papermc/paper/registry/PaperRegistryListenerManager.java
+@@ -86,8 +86,7 @@ public final class PaperRegistryListenerManager {
+         this.registerWithListeners(registry, key, nms, registrationInfo, WritableRegistry::register, conversions);
+     }
+ 
+-    // TODO remove Keyed
+-    public <M, T extends org.bukkit.Keyed, B extends PaperRegistryBuilder<M, T>, R> R registerWithListeners(
++    public <M, T, B extends PaperRegistryBuilder<M, T>, R> R registerWithListeners(
+         final Registry<M> registry,
+         final ResourceKey<M> key,
+         final M nms,
+@@ -106,7 +105,7 @@ public final class PaperRegistryListenerManager {
+         return this.registerWithListeners(registry, modifiableEntry, key, nms, builder, registrationInfo, registerMethod, conversions);
+     }
+ 
+-    <M, T extends org.bukkit.Keyed, B extends PaperRegistryBuilder<M, T>> void registerWithListeners( // TODO remove Keyed
++    <M, T, B extends PaperRegistryBuilder<M, T>> void registerWithListeners(
+         final WritableRegistry<M> registry,
+         final RegistryEntryInfo<M, T> entry,
+         final ResourceKey<M> key,
+@@ -121,7 +120,7 @@ public final class PaperRegistryListenerManager {
+         this.registerWithListeners(registry, RegistryEntry.Modifiable.asModifiable(entry), key, null, builder, registrationInfo, WritableRegistry::register, conversions);
+     }
+ 
+-    public <M, T extends org.bukkit.Keyed, B extends PaperRegistryBuilder<M, T>, R> R registerWithListeners( // TODO remove Keyed
++    public <M, T, B extends PaperRegistryBuilder<M, T>, R> R registerWithListeners(
+         final Registry<M> registry,
+         final RegistryEntry.Modifiable<M, T, B> entry,
+         final ResourceKey<M> key,
+@@ -156,7 +155,7 @@ public final class PaperRegistryListenerManager {
+         R register(WritableRegistry<M> writableRegistry, ResourceKey<M> key, M value, RegistrationInfo registrationInfo);
+     }
+ 
+-    public <M, T extends org.bukkit.Keyed, B extends PaperRegistryBuilder<M, T>> void runFreezeListeners(final ResourceKey<? extends Registry<M>> resourceKey, final Conversions conversions) {
++    public <M, T, B extends PaperRegistryBuilder<M, T>> void runFreezeListeners(final ResourceKey<? extends Registry<M>> resourceKey, final Conversions conversions) {
+         final @Nullable RegistryEntryInfo<M, T> entry = PaperRegistries.getEntry(resourceKey);
+         if (!RegistryEntry.Addable.isAddable(entry) || !this.freezeHooks.hasHooks(entry.apiKey())) {
+             return;
+diff --git a/src/main/java/io/papermc/paper/registry/RegistryHolder.java b/src/main/java/io/papermc/paper/registry/RegistryHolder.java
+index a31bdd9f02fe75a87fceb2ebe8c36b3232a561cc..8724eaf02a57452953f085e8b1becccddf7a2781 100644
+--- a/src/main/java/io/papermc/paper/registry/RegistryHolder.java
++++ b/src/main/java/io/papermc/paper/registry/RegistryHolder.java
+@@ -10,11 +10,11 @@ import org.checkerframework.checker.nullness.qual.NonNull;
+ import org.checkerframework.framework.qual.DefaultQualifier;
+ 
+ @DefaultQualifier(NonNull.class)
+-public interface RegistryHolder<B extends Keyed> {
++public interface RegistryHolder<B> {
+ 
+     Registry<B> get();
+ 
+-    final class Memoized<B extends Keyed, R extends Registry<B>> implements RegistryHolder<B> {
++    final class Memoized<B, R extends Registry<B>> implements RegistryHolder<B> {
+ 
+         private final Supplier<R> memoizedSupplier;
+ 
+@@ -27,7 +27,7 @@ public interface RegistryHolder<B extends Keyed> {
+         }
+     }
+ 
+-    final class Delayed<B extends Keyed, R extends Registry<B>> implements RegistryHolder<B> {
++    final class Delayed<B, R extends Registry<B>> implements RegistryHolder<B> {
+ 
+         private final DelayedRegistry<B, R> delayedRegistry = new DelayedRegistry<>();
+ 
+diff --git a/src/main/java/io/papermc/paper/registry/WritableCraftRegistry.java b/src/main/java/io/papermc/paper/registry/WritableCraftRegistry.java
+index 78317c7ab42a666f19634593a8f3b696700764c8..bb71763a5374c91e4dbcaa5e283aed2b73cf0eda 100644
+--- a/src/main/java/io/papermc/paper/registry/WritableCraftRegistry.java
++++ b/src/main/java/io/papermc/paper/registry/WritableCraftRegistry.java
+@@ -17,7 +17,7 @@ import org.bukkit.craftbukkit.CraftRegistry;
+ import org.bukkit.craftbukkit.util.ApiVersion;
+ import org.checkerframework.checker.nullness.qual.Nullable;
+ 
+-public class WritableCraftRegistry<M, T extends Keyed, B extends PaperRegistryBuilder<M, T>> extends CraftRegistry<T, M> {
++public class WritableCraftRegistry<M, T, B extends PaperRegistryBuilder<M, T>> extends CraftRegistry<T, M> {
+ 
+     private static final RegistrationInfo FROM_PLUGIN = new RegistrationInfo(Optional.empty(), Lifecycle.experimental());
+ 
+diff --git a/src/main/java/io/papermc/paper/registry/entry/AddableRegistryEntry.java b/src/main/java/io/papermc/paper/registry/entry/AddableRegistryEntry.java
+index aeec9b3ae2911f041d000b3db72f37974020ba60..a982ae85d54f63c6ca3a14c885516d4090c52e75 100644
+--- a/src/main/java/io/papermc/paper/registry/entry/AddableRegistryEntry.java
++++ b/src/main/java/io/papermc/paper/registry/entry/AddableRegistryEntry.java
+@@ -13,7 +13,7 @@ import net.minecraft.resources.ResourceKey;
+ import org.bukkit.Keyed;
+ import org.bukkit.NamespacedKey;
+ 
+-public class AddableRegistryEntry<M, T extends Keyed, B extends PaperRegistryBuilder<M, T>> extends CraftRegistryEntry<M, T> implements RegistryEntry.Addable<M, T, B> {
++public class AddableRegistryEntry<M, T, B extends PaperRegistryBuilder<M, T>> extends CraftRegistryEntry<M, T> implements RegistryEntry.Addable<M, T, B> {
+ 
+     private final PaperRegistryBuilder.Filler<M, T, B> builderFiller;
+ 
+diff --git a/src/main/java/io/papermc/paper/registry/entry/ApiRegistryEntry.java b/src/main/java/io/papermc/paper/registry/entry/ApiRegistryEntry.java
+index 2295b0d145cbaabef5d29482c817575dcbe2ba54..17617defef16f56a65a03c35b2e00d97f274baa0 100644
+--- a/src/main/java/io/papermc/paper/registry/entry/ApiRegistryEntry.java
++++ b/src/main/java/io/papermc/paper/registry/entry/ApiRegistryEntry.java
+@@ -7,7 +7,7 @@ import net.minecraft.core.Registry;
+ import net.minecraft.resources.ResourceKey;
+ import org.bukkit.Keyed;
+ 
+-public class ApiRegistryEntry<M, B extends Keyed> extends BaseRegistryEntry<M, B> {
++public class ApiRegistryEntry<M, B> extends BaseRegistryEntry<M, B> {
+ 
+     private final Supplier<org.bukkit.Registry<B>> registrySupplier;
+ 
+diff --git a/src/main/java/io/papermc/paper/registry/entry/BaseRegistryEntry.java b/src/main/java/io/papermc/paper/registry/entry/BaseRegistryEntry.java
+index ceb217dbbb84e8bd51365dd47bf91971e364d298..88a8e2170fa82213df8f52ec1b5f7d3821b92e96 100644
+--- a/src/main/java/io/papermc/paper/registry/entry/BaseRegistryEntry.java
++++ b/src/main/java/io/papermc/paper/registry/entry/BaseRegistryEntry.java
+@@ -5,7 +5,7 @@ import net.minecraft.core.Registry;
+ import net.minecraft.resources.ResourceKey;
+ import org.bukkit.Keyed;
+ 
+-public abstract class BaseRegistryEntry<M, B extends Keyed> implements RegistryEntry<M, B> { // TODO remove Keyed
++public abstract class BaseRegistryEntry<M, B> implements RegistryEntry<M, B> {
+ 
+     private final ResourceKey<? extends Registry<M>> minecraftRegistryKey;
+     private final RegistryKey<B> apiRegistryKey;
+diff --git a/src/main/java/io/papermc/paper/registry/entry/CraftRegistryEntry.java b/src/main/java/io/papermc/paper/registry/entry/CraftRegistryEntry.java
+index 568984894a5463ccfa68bb6944b409ab0a2d7ad7..93ea40ea78e6d00ef60844447ee25b6f3db83859 100644
+--- a/src/main/java/io/papermc/paper/registry/entry/CraftRegistryEntry.java
++++ b/src/main/java/io/papermc/paper/registry/entry/CraftRegistryEntry.java
+@@ -13,7 +13,7 @@ import org.checkerframework.checker.nullness.qual.NonNull;
+ import org.checkerframework.framework.qual.DefaultQualifier;
+ 
+ @DefaultQualifier(NonNull.class)
+-public class CraftRegistryEntry<M, B extends Keyed> extends BaseRegistryEntry<M, B> { // TODO remove Keyed
++public class CraftRegistryEntry<M, B> extends BaseRegistryEntry<M, B> {
+ 
+     private static final BiFunction<NamespacedKey, ApiVersion, NamespacedKey> EMPTY = (namespacedKey, apiVersion) -> namespacedKey;
+ 
+diff --git a/src/main/java/io/papermc/paper/registry/entry/ModifiableRegistryEntry.java b/src/main/java/io/papermc/paper/registry/entry/ModifiableRegistryEntry.java
+index 515a995e3862f8e7cb93d149315ea32e04a08716..e6ddd4b58908b112a1b2d4284dec17b0932522c3 100644
+--- a/src/main/java/io/papermc/paper/registry/entry/ModifiableRegistryEntry.java
++++ b/src/main/java/io/papermc/paper/registry/entry/ModifiableRegistryEntry.java
+@@ -10,7 +10,7 @@ import net.minecraft.resources.ResourceKey;
+ import org.bukkit.Keyed;
+ import org.bukkit.NamespacedKey;
+ 
+-public class ModifiableRegistryEntry<M, T extends Keyed, B extends PaperRegistryBuilder<M, T>> extends CraftRegistryEntry<M, T> implements RegistryEntry.Modifiable<M, T, B> {
++public class ModifiableRegistryEntry<M, T, B extends PaperRegistryBuilder<M, T>> extends CraftRegistryEntry<M, T> implements RegistryEntry.Modifiable<M, T, B> {
+ 
+     protected final PaperRegistryBuilder.Filler<M, T, B> builderFiller;
+ 
+diff --git a/src/main/java/io/papermc/paper/registry/entry/RegistryEntry.java b/src/main/java/io/papermc/paper/registry/entry/RegistryEntry.java
+index f2e919705301cb23ed1938ca3c1976378249172c..93e1ca735e662c4a988b32229e39e654cfe31576 100644
+--- a/src/main/java/io/papermc/paper/registry/entry/RegistryEntry.java
++++ b/src/main/java/io/papermc/paper/registry/entry/RegistryEntry.java
+@@ -21,7 +21,7 @@ import org.checkerframework.checker.nullness.qual.Nullable;
+ import org.checkerframework.framework.qual.DefaultQualifier;
+ 
+ @DefaultQualifier(NonNull.class)
+-public interface RegistryEntry<M, B extends Keyed> extends RegistryEntryInfo<M, B> { // TODO remove Keyed
++public interface RegistryEntry<M, B> extends RegistryEntryInfo<M, B> {
+ 
+     RegistryHolder<B> createRegistryHolder(Registry<M> nmsRegistry);
+ 
+@@ -53,7 +53,7 @@ public interface RegistryEntry<M, B extends Keyed> extends RegistryEntryInfo<M,
+             return entry instanceof RegistryEntry.Modifiable<?, ?, ?> || (entry instanceof final DelayedRegistryEntry<?, ?> delayed && delayed.delegate() instanceof RegistryEntry.Modifiable<?, ?, ?>);
+         }
+ 
+-        static <M, T extends Keyed, B extends PaperRegistryBuilder<M, T>> Modifiable<M, T, B> asModifiable(final RegistryEntryInfo<M, T> entry) { // TODO remove Keyed
++        static <M, T, B extends PaperRegistryBuilder<M, T>> Modifiable<M, T, B> asModifiable(final RegistryEntryInfo<M, T> entry) {
+             return (Modifiable<M, T, B>) possiblyUnwrap(entry);
+         }
+ 
+@@ -65,7 +65,7 @@ public interface RegistryEntry<M, B extends Keyed> extends RegistryEntryInfo<M,
+     /**
+      * Can only add new values to the registry, not modify any values.
+      */
+-    interface Addable<M, T extends Keyed, B extends PaperRegistryBuilder<M, T>> extends BuilderHolder<M, T, B> { // TODO remove Keyed
++    interface Addable<M, T, B extends PaperRegistryBuilder<M, T>> extends BuilderHolder<M, T, B> {
+ 
+         default RegistryFreezeEventImpl<T, B> createFreezeEvent(final WritableCraftRegistry<M, T, B> writableRegistry, final Conversions conversions) {
+             return new RegistryFreezeEventImpl<>(this.apiKey(), writableRegistry.createApiWritableRegistry(conversions), conversions);
+@@ -75,7 +75,7 @@ public interface RegistryEntry<M, B extends Keyed> extends RegistryEntryInfo<M,
+             return entry instanceof RegistryEntry.Addable<?, ?, ?> || (entry instanceof final DelayedRegistryEntry<?, ?> delayed && delayed.delegate() instanceof RegistryEntry.Addable<?, ?, ?>);
+         }
+ 
+-        static <M, T extends Keyed, B extends PaperRegistryBuilder<M, T>> Addable<M, T, B> asAddable(final RegistryEntryInfo<M, T> entry) {
++        static <M, T, B extends PaperRegistryBuilder<M, T>> Addable<M, T, B> asAddable(final RegistryEntryInfo<M, T> entry) {
+             return (Addable<M, T, B>) possiblyUnwrap(entry);
+         }
+     }
+@@ -83,22 +83,22 @@ public interface RegistryEntry<M, B extends Keyed> extends RegistryEntryInfo<M,
+     /**
+      * Can mutate values and add new values.
+      */
+-    interface Writable<M, T extends Keyed, B extends PaperRegistryBuilder<M, T>> extends Modifiable<M, T, B>, Addable<M, T, B> { // TODO remove Keyed
++    interface Writable<M, T, B extends PaperRegistryBuilder<M, T>> extends Modifiable<M, T, B>, Addable<M, T, B> {
+ 
+         static boolean isWritable(final @Nullable RegistryEntryInfo<?, ?> entry) {
+             return entry instanceof RegistryEntry.Writable<?, ?, ?> || (entry instanceof final DelayedRegistryEntry<?, ?> delayed && delayed.delegate() instanceof RegistryEntry.Writable<?, ?, ?>);
+         }
+ 
+-        static <M, T extends Keyed, B extends PaperRegistryBuilder<M, T>> Writable<M, T, B> asWritable(final RegistryEntryInfo<M, T> entry) { // TODO remove Keyed
++        static <M, T, B extends PaperRegistryBuilder<M, T>> Writable<M, T, B> asWritable(final RegistryEntryInfo<M, T> entry) {
+             return (Writable<M, T, B>) possiblyUnwrap(entry);
+         }
+     }
+ 
+-    private static <M, B extends Keyed> RegistryEntryInfo<M, B> possiblyUnwrap(final RegistryEntryInfo<M, B> entry) {
++    private static <M, B> RegistryEntryInfo<M, B> possiblyUnwrap(final RegistryEntryInfo<M, B> entry) {
+         return entry instanceof final DelayedRegistryEntry<M, B> delayed ? delayed.delegate() : entry;
+     }
+ 
+-    static <M, B extends Keyed> RegistryEntry<M, B> entry(
++    static <M, B> RegistryEntry<M, B> entry(
+         final ResourceKey<? extends Registry<M>> mcKey,
+         final RegistryKey<B> apiKey,
+         final Class<?> classToPreload,
+@@ -107,7 +107,7 @@ public interface RegistryEntry<M, B extends Keyed> extends RegistryEntryInfo<M,
+         return new CraftRegistryEntry<>(mcKey, apiKey, classToPreload, minecraftToBukkit);
+     }
+ 
+-    static <M, B extends Keyed> RegistryEntry<M, B> apiOnly(
++    static <M, B> RegistryEntry<M, B> apiOnly(
+         final ResourceKey<? extends Registry<M>> mcKey,
+         final RegistryKey<B> apiKey,
+         final Supplier<org.bukkit.Registry<B>> apiRegistrySupplier
+@@ -115,7 +115,7 @@ public interface RegistryEntry<M, B extends Keyed> extends RegistryEntryInfo<M,
+         return new ApiRegistryEntry<>(mcKey, apiKey, apiRegistrySupplier);
+     }
+ 
+-    static <M, T extends Keyed, B extends PaperRegistryBuilder<M, T>> RegistryEntry<M, T> modifiable(
++    static <M, T, B extends PaperRegistryBuilder<M, T>> RegistryEntry<M, T> modifiable(
+         final ResourceKey<? extends Registry<M>> mcKey,
+         final RegistryKey<T> apiKey,
+         final Class<?> toPreload,
+@@ -125,7 +125,7 @@ public interface RegistryEntry<M, B extends Keyed> extends RegistryEntryInfo<M,
+         return new ModifiableRegistryEntry<>(mcKey, apiKey, toPreload, minecraftToBukkit, filler);
+     }
+ 
+-    static <M, T extends Keyed, B extends PaperRegistryBuilder<M, T>> RegistryEntry<M, T> writable(
++    static <M, T, B extends PaperRegistryBuilder<M, T>> RegistryEntry<M, T> writable(
+         final ResourceKey<? extends Registry<M>> mcKey,
+         final RegistryKey<T> apiKey,
+         final Class<?> toPreload,
+diff --git a/src/main/java/io/papermc/paper/registry/entry/WritableRegistryEntry.java b/src/main/java/io/papermc/paper/registry/entry/WritableRegistryEntry.java
+index 562accce731630327d116afd1c9d559df7e386bd..ff2c1d8332dca8ea474eb0d1acc58c7aebfa9bce 100644
+--- a/src/main/java/io/papermc/paper/registry/entry/WritableRegistryEntry.java
++++ b/src/main/java/io/papermc/paper/registry/entry/WritableRegistryEntry.java
+@@ -8,7 +8,7 @@ import net.minecraft.resources.ResourceKey;
+ import org.bukkit.Keyed;
+ import org.bukkit.NamespacedKey;
+ 
+-public class WritableRegistryEntry<M, T extends Keyed, B extends PaperRegistryBuilder<M, T>> extends AddableRegistryEntry<M, T, B> implements RegistryEntry.Writable<M, T, B> { // TODO remove Keyed
++public class WritableRegistryEntry<M, T, B extends PaperRegistryBuilder<M, T>> extends AddableRegistryEntry<M, T, B> implements RegistryEntry.Writable<M, T, B> {
+ 
+     protected WritableRegistryEntry(
+         final ResourceKey<? extends Registry<M>> mcKey,
+diff --git a/src/main/java/io/papermc/paper/registry/event/RegistryEntryAddEventImpl.java b/src/main/java/io/papermc/paper/registry/event/RegistryEntryAddEventImpl.java
+index cc9c8fd313f530777af80ad79e03903f3f8f9829..613cfbc6cf2d33c8f2077b1c5ce17a3702678294 100644
+--- a/src/main/java/io/papermc/paper/registry/event/RegistryEntryAddEventImpl.java
++++ b/src/main/java/io/papermc/paper/registry/event/RegistryEntryAddEventImpl.java
+@@ -22,7 +22,7 @@ public record RegistryEntryAddEventImpl<T, B extends RegistryBuilder<T>>(
+ ) implements RegistryEntryAddEvent<T, B>, PaperLifecycleEvent {
+ 
+     @Override
+-    public @NonNull <V extends Keyed> Tag<V> getOrCreateTag(final TagKey<V> tagKey) {
++    public @NonNull <V> Tag<V> getOrCreateTag(final TagKey<V> tagKey) {
+         final RegistryOps.RegistryInfo<Object> registryInfo = this.conversions.lookup().lookup(PaperRegistries.registryToNms(tagKey.registryKey())).orElseThrow();
+         final HolderSet.Named<?> tagSet = registryInfo.getter().getOrThrow(PaperRegistries.toNms(tagKey));
+         return new NamedRegistryKeySetImpl<>(tagKey, tagSet);
+diff --git a/src/main/java/io/papermc/paper/registry/event/RegistryFreezeEventImpl.java b/src/main/java/io/papermc/paper/registry/event/RegistryFreezeEventImpl.java
+index 63957d2509e68ccc6eb2fd9ecaa35bfad7b71b81..aba718d563f53115aa64d445f9d61f9245ee0e9e 100644
+--- a/src/main/java/io/papermc/paper/registry/event/RegistryFreezeEventImpl.java
++++ b/src/main/java/io/papermc/paper/registry/event/RegistryFreezeEventImpl.java
+@@ -20,7 +20,7 @@ public record RegistryFreezeEventImpl<T, B extends RegistryBuilder<T>>(
+ ) implements RegistryFreezeEvent<T, B>, PaperLifecycleEvent {
+ 
+     @Override
+-    public @NonNull <V extends Keyed> Tag<V> getOrCreateTag(final TagKey<V> tagKey) {
++    public @NonNull <V> Tag<V> getOrCreateTag(final TagKey<V> tagKey) {
+         final RegistryOps.RegistryInfo<Object> registryInfo = this.conversions.lookup().lookup(PaperRegistries.registryToNms(tagKey.registryKey())).orElseThrow();
+         final HolderSet.Named<?> tagSet = registryInfo.getter().getOrThrow(PaperRegistries.toNms(tagKey));
+         return new NamedRegistryKeySetImpl<>(tagKey, tagSet);
+diff --git a/src/main/java/io/papermc/paper/registry/legacy/DelayedRegistry.java b/src/main/java/io/papermc/paper/registry/legacy/DelayedRegistry.java
+index e5880f76cdb8ebf01fcefdf77ba9b95674b997a8..b2f2aa25751b002d909fed3e911ffa95380ae9ca 100644
+--- a/src/main/java/io/papermc/paper/registry/legacy/DelayedRegistry.java
++++ b/src/main/java/io/papermc/paper/registry/legacy/DelayedRegistry.java
+@@ -16,7 +16,7 @@ import org.jetbrains.annotations.NotNull;
+  * This is to support the now-deprecated fields in {@link Registry} for
+  * data-driven registries.
+  */
+-public final class DelayedRegistry<T extends Keyed, R extends Registry<T>> implements Registry<T> {
++public final class DelayedRegistry<T, R extends Registry<T>> implements Registry<T> {
+ 
+     private @MonotonicNonNull Supplier<? extends R> delegate;
+ 
+diff --git a/src/main/java/io/papermc/paper/registry/legacy/DelayedRegistryEntry.java b/src/main/java/io/papermc/paper/registry/legacy/DelayedRegistryEntry.java
+index 110b8d559f49f9e4f181b47663962a139a273a72..dfae528518f25dab7825795d82f183fb07b3ba96 100644
+--- a/src/main/java/io/papermc/paper/registry/legacy/DelayedRegistryEntry.java
++++ b/src/main/java/io/papermc/paper/registry/legacy/DelayedRegistryEntry.java
+@@ -7,7 +7,7 @@ import net.minecraft.core.Registry;
+ import net.minecraft.resources.ResourceKey;
+ import org.bukkit.Keyed;
+ 
+-public record DelayedRegistryEntry<M, T extends Keyed>(RegistryEntry<M, T> delegate) implements RegistryEntry<M, T> {
++public record DelayedRegistryEntry<M, T>(RegistryEntry<M, T> delegate) implements RegistryEntry<M, T> {
+ 
+     @Override
+     public ResourceKey<? extends Registry<M>> mcKey() {
+diff --git a/src/main/java/io/papermc/paper/registry/set/NamedRegistryKeySetImpl.java b/src/main/java/io/papermc/paper/registry/set/NamedRegistryKeySetImpl.java
+index e8c2c18a1ed5cd587266bd415170610781531a12..f48b45421eb4e6420a69a9eb048e29a3871963ab 100644
+--- a/src/main/java/io/papermc/paper/registry/set/NamedRegistryKeySetImpl.java
++++ b/src/main/java/io/papermc/paper/registry/set/NamedRegistryKeySetImpl.java
+@@ -23,7 +23,7 @@ import org.jetbrains.annotations.NotNull;
+ import org.jetbrains.annotations.Unmodifiable;
+ 
+ @DefaultQualifier(NonNull.class)
+-public record NamedRegistryKeySetImpl<T extends Keyed, M>( // TODO remove Keyed
++public record NamedRegistryKeySetImpl<T, M>(
+     TagKey<T> tagKey,
+     HolderSet.Named<M> namedSet
+ ) implements Tag<T>, org.bukkit.Tag<T> {
+diff --git a/src/main/java/io/papermc/paper/registry/set/PaperRegistrySets.java b/src/main/java/io/papermc/paper/registry/set/PaperRegistrySets.java
+index f09ce9c8547ef05153847245746473dd9a8acbe6..0ecd651b32fc6c0d954f37999b67a9ea1128a957 100644
+--- a/src/main/java/io/papermc/paper/registry/set/PaperRegistrySets.java
++++ b/src/main/java/io/papermc/paper/registry/set/PaperRegistrySets.java
+@@ -17,7 +17,7 @@ import org.checkerframework.framework.qual.DefaultQualifier;
+ @DefaultQualifier(NonNull.class)
+ public final class PaperRegistrySets {
+ 
+-    public static <A extends Keyed, M> HolderSet<M> convertToNms(final ResourceKey<? extends Registry<M>> resourceKey, final RegistryOps.RegistryInfoLookup lookup, final RegistryKeySet<A> registryKeySet) { // TODO remove Keyed
++    public static <A, M> HolderSet<M> convertToNms(final ResourceKey<? extends Registry<M>> resourceKey, final RegistryOps.RegistryInfoLookup lookup, final RegistryKeySet<A> registryKeySet) {
+         if (registryKeySet instanceof NamedRegistryKeySetImpl<A, ?>) {
+             return ((NamedRegistryKeySetImpl<A, M>) registryKeySet).namedSet();
+         } else {
+@@ -28,7 +28,7 @@ public final class PaperRegistrySets {
+         }
+     }
+ 
+-    public static <A extends Keyed, M> RegistryKeySet<A> convertToApi(final RegistryKey<A> registryKey, final HolderSet<M> holders) { // TODO remove Keyed
++    public static <A, M> RegistryKeySet<A> convertToApi(final RegistryKey<A> registryKey, final HolderSet<M> holders) {
+         if (holders instanceof final HolderSet.Named<M> named) {
+             return new NamedRegistryKeySetImpl<>(PaperRegistries.fromNms(named.key()), named);
+         } else {
+diff --git a/src/main/java/org/bukkit/craftbukkit/legacy/MaterialRerouting.java b/src/main/java/org/bukkit/craftbukkit/legacy/MaterialRerouting.java
+index db8d8e2a07296d62c3097f02b03319e2e1ba9394..d050f41a75f5a79568e1bdab0ce685fe25bab57b 100644
+--- a/src/main/java/org/bukkit/craftbukkit/legacy/MaterialRerouting.java
++++ b/src/main/java/org/bukkit/craftbukkit/legacy/MaterialRerouting.java
+@@ -551,7 +551,7 @@ public class MaterialRerouting {
+         return server.createBlockData(MaterialRerouting.transformToBlockType(material), data);
+     }
+ 
+-    public static <T extends Keyed> boolean isTagged(Tag<T> tag, T item) {
++    public static <T> boolean isTagged(Tag<T> tag, T item) {
+         if (tag instanceof CraftBlockTag) {
+             return tag.isTagged((T) MaterialRerouting.transformToBlockType((Material) item));
+         } else if (tag instanceof CraftItemTag) {
diff --git a/test-plugin/build.gradle.kts b/test-plugin/build.gradle.kts
index 9f7d9da599..4c35008558 100644
--- a/test-plugin/build.gradle.kts
+++ b/test-plugin/build.gradle.kts
@@ -1,7 +1,11 @@
 version = "1.0.0-SNAPSHOT"
+repositories {
+    maven("https://repo.papermc.io/repository/maven-public/")
+}
 
 dependencies {
-    compileOnly(project(":paper-api"))
+    // compileOnly(project(":paper-api"))
+    compileOnly("io.papermc.paper:paper-api:1.21.1-R0.1-SNAPSHOT")
 }
 
 tasks.processResources {
diff --git a/test-plugin/src/main/java/io/papermc/testplugin/TestPlugin.java b/test-plugin/src/main/java/io/papermc/testplugin/TestPlugin.java
index 671c37fa40..16d9e5a3ac 100644
--- a/test-plugin/src/main/java/io/papermc/testplugin/TestPlugin.java
+++ b/test-plugin/src/main/java/io/papermc/testplugin/TestPlugin.java
@@ -1,5 +1,17 @@
 package io.papermc.testplugin;
 
+import io.papermc.paper.event.player.ChatEvent;
+import java.util.function.BiFunction;
+import java.util.function.Function;
+import org.bukkit.GameEvent;
+import org.bukkit.Keyed;
+import org.bukkit.Material;
+import org.bukkit.NamespacedKey;
+import org.bukkit.Registry;
+import org.bukkit.Tag;
+import org.bukkit.block.Biome;
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
 import org.bukkit.plugin.java.JavaPlugin;
 
@@ -10,6 +22,31 @@ public final class TestPlugin extends JavaPlugin implements Listener {
         this.getServer().getPluginManager().registerEvents(this, this);
 
         // io.papermc.testplugin.brigtests.Registration.registerViaOnEnable(this);
+        this.test();
+    }
+
+    @EventHandler
+    public void onChat(ChatEvent event) {
+        this.test();
+    }
+
+    void test() {
+        final Function<NamespacedKey, Keyed> GET_KEYED = Registry.BIOME::get;
+        final BiFunction<Registry<?>, NamespacedKey, Keyed> GET_KEYED_2 = Registry::get;
+
+        final Keyed keyed = GET_KEYED.apply(Biome.PLAINS.getKey());
+        System.out.println(keyed.getKey() + " " + keyed.getClass().getSimpleName());
+        final Keyed keyed2 = GET_KEYED_2.apply(Registry.GAME_EVENT, GameEvent.EAT.getKey());
+        System.out.println(keyed2.getKey() + " " + keyed2.getClass().getSimpleName());
+
+        final Keyed keyed3 = Registry.BIOME.get(Biome.BEACH.getKey());
+        System.out.println(keyed3.getKey() + " " + keyed3.getClass().getSimpleName());
+
+        final Keyed keyed4 = Registry.ENCHANTMENT.get(Enchantment.FORTUNE.getKey());
+        System.out.println(keyed4.getKey() + " " + keyed4.getClass().getSimpleName());
+
+        System.out.println(Tag.ACACIA_LOGS.isTagged(Material.WRITTEN_BOOK));
+        System.out.println(Tag.ACACIA_LOGS.isTagged(Material.ACACIA_LOG));
     }
 
 }