Registry Modification API (#10893)

* Registry Modification API

* some fixes

* even more fixes

.editorconfig

@@ -29,6 +29,8 @@ ij_java_names_count_to_use_import_on_demand = 999999
 ij_java_imports_layout = *,|,$*
 ij_java_generate_final_locals = true
 ij_java_generate_final_parameters = true
+ij_java_method_parameters_new_line_after_left_paren = true
+ij_java_method_parameters_right_paren_on_new_line = true
 
 [test-plugin/**/*.java]
 ij_java_use_fq_class_names = false

patches/api/Improve-Registry.patch

@@ -40,6 +40,36 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
 +    // Paper start - improve Registry
 +    /**
++     * Gets the object by its key or throws if it doesn't exist.
++     *
++     * @param key the key to get the object of in this registry
++     * @return the object for the key
++     * @throws java.util.NoSuchElementException if the key doesn't point to an object in the registry
++     */
++    default @NotNull T getOrThrow(final net.kyori.adventure.key.@NotNull Key key) {
++        final T value = this.get(key);
++        if (value == null) {
++            throw new java.util.NoSuchElementException("No value for " + key + " in " + this);
++        }
++        return value;
++    }
++
++    /**
++     * Gets the object by its key or throws if it doesn't exist.
++     *
++     * @param key the key to get the object of in this registry
++     * @return the object for the key
++     * @throws java.util.NoSuchElementException if the key doesn't point to an object in the registry
++     */
++    default @NotNull T getOrThrow(final io.papermc.paper.registry.@NotNull TypedKey<T> key) {
++        final T value = this.get(key);
++        if (value == null) {
++            throw new java.util.NoSuchElementException("No value for " + key + " in " + this);
++        }
++        return value;
++    }
++
++    /**
 +     * Gets the key for this object or throws if it doesn't exist.
 +     * <p>
 +     * Some types can exist without being in a registry

patches/api/Registry-Modification-API.patch

@@ -0,0 +1,893 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Wed, 2 Mar 2022 13:36:21 -0800
+Subject: [PATCH] Registry Modification API
+
+
+diff --git a/src/main/java/io/papermc/paper/registry/RegistryBuilder.java b/src/main/java/io/papermc/paper/registry/RegistryBuilder.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/registry/RegistryBuilder.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.registry;
++
++import org.jetbrains.annotations.ApiStatus;
++
++/**
++ * To be implemented by any type used for modifying registries.
++ *
++ * @param <T> registry value type
++ */
++@ApiStatus.NonExtendable
++@ApiStatus.Experimental
++public interface RegistryBuilder<T> {
++}
+diff --git a/src/main/java/io/papermc/paper/registry/event/RegistryEntryAddEvent.java b/src/main/java/io/papermc/paper/registry/event/RegistryEntryAddEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/registry/event/RegistryEntryAddEvent.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.registry.event;
++
++import io.papermc.paper.registry.RegistryBuilder;
++import io.papermc.paper.registry.TypedKey;
++import io.papermc.paper.registry.tag.Tag;
++import io.papermc.paper.registry.tag.TagKey;
++import org.bukkit.Keyed;
++import org.checkerframework.checker.nullness.qual.NonNull;
++import org.jetbrains.annotations.ApiStatus;
++
++/**
++ * Event object for {@link RegistryEventProvider#entryAdd()}. This
++ * event is fired right before a specific entry is registered in/added to registry.
++ * It provides a way for plugins to modify parts of this entry.
++ *
++ * @param <T> registry entry type
++ * @param <B> registry entry builder type
++ */
++@ApiStatus.Experimental
++@ApiStatus.NonExtendable
++public interface RegistryEntryAddEvent<T, B extends RegistryBuilder<T>> extends RegistryEvent<T> {
++
++    /**
++     * Gets the builder for the entry being added to the registry.
++     *
++     * @return the object builder
++     */
++    @NonNull B builder();
++
++    /**
++     * Gets the key for this entry in the registry.
++     *
++     * @return the key
++     */
++    @NonNull TypedKey<T> key();
++
++    /**
++     * Gets or creates a tag for the given tag key. This tag
++     * is then required to be filled either from the built-in or
++     * custom datapack.
++     *
++     * @param tagKey the tag key
++     * @return the tag
++     * @param <V> the tag value type
++     */
++    @NonNull <V extends Keyed> Tag<V> getOrCreateTag(@NonNull TagKey<V> tagKey);
++}
+diff --git a/src/main/java/io/papermc/paper/registry/event/RegistryEvent.java b/src/main/java/io/papermc/paper/registry/event/RegistryEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/registry/event/RegistryEvent.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.registry.event;
++
++import io.papermc.paper.plugin.lifecycle.event.LifecycleEvent;
++import io.papermc.paper.registry.RegistryKey;
++import org.checkerframework.checker.nullness.qual.NonNull;
++import org.jetbrains.annotations.ApiStatus;
++
++/**
++ * Base type for all registry events.
++ *
++ * @param <T> registry entry type
++ */
++@ApiStatus.Experimental
++@ApiStatus.NonExtendable
++public interface RegistryEvent<T> extends LifecycleEvent {
++
++    /**
++     * Get the key for the registry this event pertains to.
++     *
++     * @return the registry key
++     */
++    @NonNull RegistryKey<T> registryKey();
++}
+diff --git a/src/main/java/io/papermc/paper/registry/event/RegistryEventProvider.java b/src/main/java/io/papermc/paper/registry/event/RegistryEventProvider.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/registry/event/RegistryEventProvider.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.registry.event;
++
++import io.papermc.paper.plugin.bootstrap.BootstrapContext;
++import io.papermc.paper.plugin.lifecycle.event.handler.LifecycleEventHandler;
++import io.papermc.paper.plugin.lifecycle.event.handler.configuration.LifecycleEventHandlerConfiguration;
++import io.papermc.paper.plugin.lifecycle.event.handler.configuration.PrioritizedLifecycleEventHandlerConfiguration;
++import io.papermc.paper.plugin.lifecycle.event.types.LifecycleEventType;
++import io.papermc.paper.registry.RegistryBuilder;
++import io.papermc.paper.registry.RegistryKey;
++import io.papermc.paper.registry.event.type.RegistryEntryAddEventType;
++import org.checkerframework.checker.nullness.qual.NonNull;
++import org.jetbrains.annotations.ApiStatus;
++
++/**
++ * Provider for registry events for a specific registry.
++ * <p>
++ * Supported events are:
++ * <ul>
++ *     <li>{@link RegistryEntryAddEvent} (via {@link #entryAdd()})</li>
++ *     <li>{@link RegistryFreezeEvent} (via {@link #freeze()})</li>
++ * </ul>
++ *
++ * @param <T> registry entry type
++ * @param <B> registry entry builder type
++ */
++@ApiStatus.Experimental
++@ApiStatus.NonExtendable
++public interface RegistryEventProvider<T, B extends RegistryBuilder<T>> {
++
++    /**
++     * Gets the event type for {@link RegistryEntryAddEvent} which is fired just before
++     * an object is added to a registry.
++     * <p>
++     * Can be used in {@link io.papermc.paper.plugin.lifecycle.event.LifecycleEventManager#registerEventHandler(LifecycleEventType, LifecycleEventHandler)}
++     * to register a handler for {@link RegistryEntryAddEvent}.
++     *
++     * @return the registry entry add event type
++     */
++    @NonNull RegistryEntryAddEventType<T, B> entryAdd();
++
++    /**
++     * Gets the event type for {@link RegistryFreezeEvent} which is fired just before
++     * a registry is frozen. It allows for the registration of new objects.
++     * <p>
++     * Can be used in {@link io.papermc.paper.plugin.lifecycle.event.LifecycleEventManager#registerEventHandler(LifecycleEventType, LifecycleEventHandler)}
++     * to register a handler for {@link RegistryFreezeEvent}.
++     *
++     * @return the registry freeze event type
++     */
++    LifecycleEventType.@NonNull Prioritizable<BootstrapContext, RegistryFreezeEvent<T, B>> freeze();
++
++    /**
++     * Gets the registry key associated with this event type provider.
++     *
++     * @return the registry key
++     */
++    @NonNull RegistryKey<T> registryKey();
++}
+diff --git a/src/main/java/io/papermc/paper/registry/event/RegistryEventProviderImpl.java b/src/main/java/io/papermc/paper/registry/event/RegistryEventProviderImpl.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/registry/event/RegistryEventProviderImpl.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.registry.event;
++
++import io.papermc.paper.plugin.bootstrap.BootstrapContext;
++import io.papermc.paper.plugin.lifecycle.event.types.LifecycleEventType;
++import io.papermc.paper.registry.RegistryBuilder;
++import io.papermc.paper.registry.RegistryKey;
++import io.papermc.paper.registry.event.type.RegistryEntryAddEventType;
++import org.checkerframework.checker.nullness.qual.NonNull;
++import org.checkerframework.framework.qual.DefaultQualifier;
++import org.jetbrains.annotations.ApiStatus;
++
++@ApiStatus.Internal
++@DefaultQualifier(NonNull.class)
++record RegistryEventProviderImpl<T, B extends RegistryBuilder<T>>(RegistryKey<T> registryKey) implements RegistryEventProvider<T, B> {
++
++    static <T, B extends RegistryBuilder<T>> RegistryEventProvider<T, B> create(final RegistryKey<T> registryKey) {
++        return new RegistryEventProviderImpl<>(registryKey);
++    }
++
++    @Override
++    public RegistryEntryAddEventType<T, B> entryAdd() {
++        return RegistryEventTypeProvider.provider().registryEntryAdd(this);
++    }
++
++    @Override
++    public LifecycleEventType.Prioritizable<BootstrapContext, RegistryFreezeEvent<T, B>> freeze() {
++        return RegistryEventTypeProvider.provider().registryFreeze(this);
++    }
++
++}
+diff --git a/src/main/java/io/papermc/paper/registry/event/RegistryEventTypeProvider.java b/src/main/java/io/papermc/paper/registry/event/RegistryEventTypeProvider.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/registry/event/RegistryEventTypeProvider.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.registry.event;
++
++import io.papermc.paper.plugin.bootstrap.BootstrapContext;
++import io.papermc.paper.plugin.lifecycle.event.types.LifecycleEventType;
++import io.papermc.paper.registry.RegistryBuilder;
++import io.papermc.paper.registry.event.type.RegistryEntryAddEventType;
++import java.util.Optional;
++import java.util.ServiceLoader;
++import org.jetbrains.annotations.ApiStatus;
++
++@ApiStatus.Internal
++interface RegistryEventTypeProvider {
++
++    Optional<RegistryEventTypeProvider> PROVIDER = ServiceLoader.load(RegistryEventTypeProvider.class)
++        .findFirst();
++
++    static RegistryEventTypeProvider provider() {
++        return PROVIDER.orElseThrow(() -> new IllegalStateException("Could not find a %s service implementation".formatted(RegistryEventTypeProvider.class.getSimpleName())));
++    }
++
++    <T, B extends RegistryBuilder<T>> RegistryEntryAddEventType<T, B> registryEntryAdd(RegistryEventProvider<T, B> type);
++
++    <T, B extends RegistryBuilder<T>> LifecycleEventType.Prioritizable<BootstrapContext, RegistryFreezeEvent<T, B>> registryFreeze(RegistryEventProvider<T, B> type);
++}
+diff --git a/src/main/java/io/papermc/paper/registry/event/RegistryEvents.java b/src/main/java/io/papermc/paper/registry/event/RegistryEvents.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/registry/event/RegistryEvents.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.registry.event;
++
++import org.jetbrains.annotations.ApiStatus;
++
++/**
++ * Holds providers for {@link RegistryEntryAddEvent} and {@link RegistryFreezeEvent}
++ * handlers for each applicable registry.
++ */
++@ApiStatus.Experimental
++public final class RegistryEvents {
++
++    private RegistryEvents() {
++    }
++}
+diff --git a/src/main/java/io/papermc/paper/registry/event/RegistryFreezeEvent.java b/src/main/java/io/papermc/paper/registry/event/RegistryFreezeEvent.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/registry/event/RegistryFreezeEvent.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.registry.event;
++
++import io.papermc.paper.registry.RegistryBuilder;
++import io.papermc.paper.registry.tag.Tag;
++import io.papermc.paper.registry.tag.TagKey;
++import org.bukkit.Keyed;
++import org.checkerframework.checker.nullness.qual.NonNull;
++import org.jetbrains.annotations.ApiStatus;
++
++/**
++ * Event object for {@link RegistryEventProvider#freeze()}. This
++ * event is fired right before a registry is frozen disallowing further changes.
++ * It provides a way for plugins to add new objects to the registry.
++ *
++ * @param <T> registry entry type
++ * @param <B> registry entry builder type
++ */
++@ApiStatus.Experimental
++@ApiStatus.NonExtendable
++public interface RegistryFreezeEvent<T, B extends RegistryBuilder<T>> extends RegistryEvent<T> {
++
++    /**
++     * Get the writable registry.
++     *
++     * @return a writable registry
++     */
++    @NonNull WritableRegistry<T, B> registry();
++
++    /**
++     * Gets or creates a tag for the given tag key. This tag
++     * is then required to be filled either from the built-in or
++     * custom datapack.
++     *
++     * @param tagKey the tag key
++     * @return the tag
++     * @param <V> the tag value type
++     */
++    @NonNull <V extends Keyed> Tag<V> getOrCreateTag(@NonNull TagKey<V> tagKey);
++}
+diff --git a/src/main/java/io/papermc/paper/registry/event/WritableRegistry.java b/src/main/java/io/papermc/paper/registry/event/WritableRegistry.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/registry/event/WritableRegistry.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.registry.event;
++
++import io.papermc.paper.registry.RegistryBuilder;
++import io.papermc.paper.registry.TypedKey;
++import java.util.function.Consumer;
++import org.checkerframework.checker.nullness.qual.NonNull;
++import org.jetbrains.annotations.ApiStatus;
++
++/**
++ * A registry which supports registering new objects.
++ *
++ * @param <T> registry entry type
++ * @param <B> registry entry builder type
++ */
++@ApiStatus.NonExtendable
++@ApiStatus.Experimental
++public interface WritableRegistry<T, B extends RegistryBuilder<T>> {
++
++    /**
++     * Register a new value with the specified key. This will
++     * fire a {@link RegistryEntryAddEvent} for the new entry.
++     *
++     * @param key the entry's key (must be unique from others)
++     * @param value a consumer for the entry's builder
++     */
++    void register(@NonNull TypedKey<T> key, @NonNull Consumer<? super B> value);
++}
+diff --git a/src/main/java/io/papermc/paper/registry/event/type/RegistryEntryAddConfiguration.java b/src/main/java/io/papermc/paper/registry/event/type/RegistryEntryAddConfiguration.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/registry/event/type/RegistryEntryAddConfiguration.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.registry.event.type;
++
++import io.papermc.paper.plugin.bootstrap.BootstrapContext;
++import io.papermc.paper.plugin.lifecycle.event.handler.configuration.PrioritizedLifecycleEventHandlerConfiguration;
++import io.papermc.paper.registry.TypedKey;
++import java.util.function.Predicate;
++import org.checkerframework.checker.nullness.qual.NonNull;
++import org.jetbrains.annotations.Contract;
++
++/**
++ * Specific configuration for {@link io.papermc.paper.registry.event.RegistryEntryAddEvent}s.
++ *
++ * @param <T> registry entry type
++ */
++public interface RegistryEntryAddConfiguration<T> extends PrioritizedLifecycleEventHandlerConfiguration<BootstrapContext> {
++
++    /**
++     * Only call the handler if the value being added matches the specified key.
++     *
++     * @param key the key to match
++     * @return this configuration
++     */
++    @Contract(value = "_ -> this", mutates = "this")
++    default @NonNull RegistryEntryAddConfiguration<T> filter(final @NonNull TypedKey<T> key) {
++        return this.filter(key::equals);
++    }
++
++    /**
++     * Only call the handler if the value being added passes the provided filter.
++     *
++     * @param filter the predicate to match the key against
++     * @return this configuration
++     */
++    @Contract(value = "_ -> this", mutates = "this")
++    @NonNull RegistryEntryAddConfiguration<T> filter(@NonNull Predicate<TypedKey<T>> filter);
++
++    @Override
++    @NonNull RegistryEntryAddConfiguration<T> priority(int priority);
++
++    @Override
++    @NonNull RegistryEntryAddConfiguration<T> monitor();
++}
+diff --git a/src/main/java/io/papermc/paper/registry/event/type/RegistryEntryAddEventType.java b/src/main/java/io/papermc/paper/registry/event/type/RegistryEntryAddEventType.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/registry/event/type/RegistryEntryAddEventType.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.registry.event.type;
++
++import io.papermc.paper.plugin.bootstrap.BootstrapContext;
++import io.papermc.paper.plugin.lifecycle.event.types.LifecycleEventType;
++import io.papermc.paper.registry.RegistryBuilder;
++import io.papermc.paper.registry.event.RegistryEntryAddEvent;
++import org.jetbrains.annotations.ApiStatus;
++
++/**
++ * Lifecycle event type for {@link RegistryEntryAddEvent}s.
++ *
++ * @param <T> registry entry type
++ * @param <B> registry entry builder type
++ */
++@ApiStatus.Experimental
++@ApiStatus.NonExtendable
++public interface RegistryEntryAddEventType<T, B extends RegistryBuilder<T>> extends LifecycleEventType<BootstrapContext, RegistryEntryAddEvent<T, B>, RegistryEntryAddConfiguration<T>> {
++}
+diff --git a/src/main/java/io/papermc/paper/registry/set/RegistryKeySet.java b/src/main/java/io/papermc/paper/registry/set/RegistryKeySet.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/registry/set/RegistryKeySet.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.registry.set;
++
++import io.papermc.paper.registry.TypedKey;
++import java.util.Collection;
++import java.util.Iterator;
++import org.bukkit.Keyed;
++import org.bukkit.Registry;
++import org.checkerframework.checker.nullness.qual.NonNull;
++import org.jetbrains.annotations.ApiStatus;
++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
++
++    @Override
++    default int size() {
++        return this.values().size();
++    }
++
++    /**
++     * Get the keys for the values in this set.
++     *
++     * @return the keys
++     */
++    @NonNull @Unmodifiable Collection<TypedKey<T>> values();
++
++    /**
++     * Resolve this set into a collection of values. Prefer using
++     * {@link #values()}.
++     *
++     * @param registry the registry to resolve the values from (must match {@link #registryKey()})
++     * @return the resolved values
++     * @see RegistryKeySet#values()
++     */
++    @NonNull @Unmodifiable Collection<T> resolve(final @NonNull Registry<T> registry);
++
++    /**
++     * Checks if this set contains the value with the given key.
++     *
++     * @param valueKey the key to check
++     * @return true if the value is in this set
++     */
++    boolean contains(@NonNull TypedKey<T> valueKey);
++
++    @Override
++    default @NonNull Iterator<TypedKey<T>> iterator() {
++        return this.values().iterator();
++    }
++}
+diff --git a/src/main/java/io/papermc/paper/registry/set/RegistryKeySetImpl.java b/src/main/java/io/papermc/paper/registry/set/RegistryKeySetImpl.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/registry/set/RegistryKeySetImpl.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.registry.set;
++
++import com.google.common.base.Preconditions;
++import io.papermc.paper.registry.RegistryAccess;
++import io.papermc.paper.registry.RegistryKey;
++import io.papermc.paper.registry.TypedKey;
++import java.util.ArrayList;
++import java.util.Collection;
++import java.util.Collections;
++import java.util.List;
++import org.bukkit.Keyed;
++import org.bukkit.NamespacedKey;
++import org.bukkit.Registry;
++import org.checkerframework.checker.nullness.qual.NonNull;
++import org.checkerframework.framework.qual.DefaultQualifier;
++import org.jetbrains.annotations.ApiStatus;
++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
++
++    static <T extends Keyed> RegistryKeySet<T> create(final RegistryKey<T> registryKey, final Iterable<? extends T> values) { // TODO remove Keyed
++        final Registry<T> registry = RegistryAccess.registryAccess().getRegistry(registryKey);
++        final ArrayList<TypedKey<T>> keys = new ArrayList<>();
++        for (final T value : values) {
++            final @Nullable NamespacedKey key = registry.getKey(value);
++            Preconditions.checkArgument(key != null, value + " does not have a key in " + registryKey);
++            keys.add(TypedKey.create(registryKey, key));
++        }
++        return new RegistryKeySetImpl<>(registryKey, keys);
++    }
++
++    RegistryKeySetImpl {
++        values = List.copyOf(values);
++    }
++
++    @Override
++    public boolean contains(final TypedKey<T> valueKey) {
++        return this.values.contains(valueKey);
++    }
++
++    @Override
++    public Collection<T> resolve(final Registry<T> registry) {
++        final List<T> values = new ArrayList<>(this.values.size());
++        for (final TypedKey<T> key : this.values) {
++            final @Nullable T value = registry.get(key.key());
++            Preconditions.checkState(value != null, "Trying to access unbound TypedKey: " + key);
++            values.add(value);
++        }
++        return Collections.unmodifiableList(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
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/registry/set/RegistrySet.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.registry.set;
++
++import com.google.common.collect.Lists;
++import io.papermc.paper.registry.RegistryKey;
++import io.papermc.paper.registry.TypedKey;
++import io.papermc.paper.registry.tag.Tag;
++import org.bukkit.Keyed;
++import org.checkerframework.checker.nullness.qual.NonNull;
++import org.jetbrains.annotations.ApiStatus;
++import org.jetbrains.annotations.Contract;
++
++/**
++ * Represents a collection tied to a registry.
++ * <p>
++ * There are 2<!--3--> types of registry sets:
++ * <ul>
++ *     <li>{@link Tag} which is a tag from vanilla or a datapack.
++ *     These are obtained via {@link org.bukkit.Registry#getTag(io.papermc.paper.registry.tag.TagKey)}.</li>
++ *     <li>{@link RegistryKeySet} which is a set of of keys linked to values that are present in the registry. These are
++ *     created via {@link #keySet(RegistryKey, Iterable)} or {@link #keySetFromValues(RegistryKey, Iterable)}.</li>
++ *     <!-- <li>{@link RegistryValueSet} which is a set of values which are anonymous (don't have keys in the registry). These are
++ *     created via {@link #valueSet(RegistryKey, Iterable)}.</li>-->
++ * </ul>
++ *
++ * @param <T> registry value type
++ */
++@ApiStatus.Experimental
++public sealed interface RegistrySet<T> permits RegistryKeySet, RegistryValueSet {
++
++    // TODO uncomment when direct holder sets need to be exposed to the API
++    // /**
++    //  * Creates a {@link RegistryValueSet} from anonymous values.
++    //  * <p>All values provided <b>must not</b> have keys in the given registry.</p>
++    //  *
++    //  * @param registryKey the registry key for the type of these values
++    //  * @param values the values
++    //  * @return a new registry set
++    //  * @param <T> the type of the values
++    //  */
++    // @Contract(value = "_, _ -> new", pure = true)
++    // static <T> @NonNull RegistryValueSet<T> valueSet(final @NonNull RegistryKey<T> registryKey, final @NonNull Iterable<? extends T> values) {
++    //     return RegistryValueSetImpl.create(registryKey, values);
++    // }
++
++    /**
++     * Creates a {@link RegistryKeySet} from registry-backed values.
++     * <p>All values provided <b>must</b> have keys in the given registry.
++     * <!--For anonymous values, use {@link #valueSet(RegistryKey, Iterable)}--></p>
++     * <p>If references to actual objects are not available yet, use {@link #keySet(RegistryKey, Iterable)} to
++     * create an equivalent {@link RegistryKeySet} using just {@link TypedKey TypedKeys}.</p>
++     *
++     * @param registryKey the registry key for the owner of these values
++     * @param values the values
++     * @return a new registry set
++     * @param <T> the type of the values
++     * @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
++        return RegistryKeySetImpl.create(registryKey, values);
++    }
++
++    /**
++     * Creates a direct {@link RegistrySet} from {@link TypedKey TypedKeys}.
++     *
++     * @param registryKey the registry key for the owner of these keys
++     * @param keys the keys for the values
++     * @return a new registry set
++     * @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
++        return keySet(registryKey, Lists.newArrayList(keys));
++    }
++
++    /**
++     * Creates a direct {@link RegistrySet} from {@link TypedKey TypedKeys}.
++     *
++     * @param registryKey the registry key for the owner of these keys
++     * @param keys the keys for the values
++     * @return a new registry set
++     * @param <T> the type of the values
++     */
++    @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
++        return new RegistryKeySetImpl<>(registryKey, Lists.newArrayList(keys));
++    }
++
++    /**
++     * Get the registry key for this set.
++     *
++     * @return the registry key
++     */
++    @NonNull RegistryKey<T> registryKey();
++
++    /**
++     * Get the size of this set.
++     *
++     * @return the size
++     */
++    int size();
++
++    /**
++     * Checks if the registry set is empty.
++     *
++     * @return true, if empty
++     */
++    default boolean isEmpty() {
++        return this.size() == 0;
++    }
++}
+diff --git a/src/main/java/io/papermc/paper/registry/set/RegistryValueSet.java b/src/main/java/io/papermc/paper/registry/set/RegistryValueSet.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/registry/set/RegistryValueSet.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.registry.set;
++
++import java.util.Collection;
++import java.util.Iterator;
++import org.checkerframework.checker.nullness.qual.NonNull;
++import org.jetbrains.annotations.ApiStatus;
++import org.jetbrains.annotations.Unmodifiable;
++
++/**
++ * A collection of anonymous values relating to a registry. These
++ * are values of the same type as the registry, but will not be found
++ * in the registry, hence, anonymous.
++ * @param <T> registry value type
++ */
++@ApiStatus.Experimental
++public sealed interface RegistryValueSet<T> extends Iterable<T>, RegistrySet<T> permits RegistryValueSetImpl {
++
++    @Override
++    default int size() {
++        return this.values().size();
++    }
++
++    /**
++     * Get the collection of values in this direct set.
++     *
++     * @return the values
++     */
++    @NonNull @Unmodifiable Collection<T> values();
++
++    @Override
++    default @NonNull Iterator<T> iterator() {
++        return this.values().iterator();
++    }
++}
+diff --git a/src/main/java/io/papermc/paper/registry/set/RegistryValueSetImpl.java b/src/main/java/io/papermc/paper/registry/set/RegistryValueSetImpl.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/registry/set/RegistryValueSetImpl.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.registry.set;
++
++import com.google.common.collect.Lists;
++import io.papermc.paper.registry.RegistryKey;
++import java.util.List;
++import org.jetbrains.annotations.ApiStatus;
++
++@ApiStatus.Internal
++record RegistryValueSetImpl<T>(RegistryKey<T> registryKey, List<T> values) implements RegistryValueSet<T> {
++
++    RegistryValueSetImpl {
++        values = List.copyOf(values);
++    }
++
++    static <T> RegistryValueSet<T> create(final RegistryKey<T> registryKey, final Iterable<? extends T> values) {
++        return new RegistryValueSetImpl<>(registryKey, Lists.newArrayList(values));
++    }
++}
+diff --git a/src/main/java/io/papermc/paper/registry/tag/Tag.java b/src/main/java/io/papermc/paper/registry/tag/Tag.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/registry/tag/Tag.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.registry.tag;
++
++import io.papermc.paper.registry.set.RegistryKeySet;
++import org.bukkit.Keyed;
++import org.checkerframework.checker.nullness.qual.NonNull;
++import org.jetbrains.annotations.ApiStatus;
++
++/**
++ * A named {@link RegistryKeySet} which are created
++ * via the datapack tag system.
++ *
++ * @param <T>
++ * @see org.bukkit.Tag
++ * @see org.bukkit.Registry#getTag(TagKey)
++ */
++@ApiStatus.Experimental
++public interface Tag<T extends Keyed> extends RegistryKeySet<T> { // TODO remove Keyed
++
++    /**
++     * Get the identifier for this named set.
++     *
++     * @return the tag key identifier
++     */
++    @NonNull TagKey<T> tagKey();
++}
+diff --git a/src/main/java/io/papermc/paper/registry/tag/TagKey.java b/src/main/java/io/papermc/paper/registry/tag/TagKey.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/registry/tag/TagKey.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.registry.tag;
++
++import io.papermc.paper.registry.RegistryKey;
++import net.kyori.adventure.key.Key;
++import net.kyori.adventure.key.Keyed;
++import org.checkerframework.checker.nullness.qual.NonNull;
++import org.jetbrains.annotations.ApiStatus;
++import org.jetbrains.annotations.Contract;
++
++@ApiStatus.Experimental
++public sealed interface TagKey<T> extends Keyed permits TagKeyImpl {
++
++    /**
++     * Creates a new tag key for a registry.
++     *
++     * @param registryKey the registry for the tag
++     * @param key the specific key for the tag
++     * @return a new tag key
++     * @param <T> the registry value type
++     */
++    @Contract(value = "_, _ -> new", pure = true)
++    static <T> @NonNull TagKey<T> create(final @NonNull RegistryKey<T> registryKey, final @NonNull Key key) {
++        return new TagKeyImpl<>(registryKey, key);
++    }
++
++    /**
++     * Get the registry key for this tag key.
++     *
++     * @return the registry key
++     */
++    @NonNull RegistryKey<T> registryKey();
++}
+diff --git a/src/main/java/io/papermc/paper/registry/tag/TagKeyImpl.java b/src/main/java/io/papermc/paper/registry/tag/TagKeyImpl.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/registry/tag/TagKeyImpl.java
+@@ -0,0 +0,0 @@
++package io.papermc.paper.registry.tag;
++
++import io.papermc.paper.registry.RegistryKey;
++import net.kyori.adventure.key.Key;
++import org.checkerframework.checker.nullness.qual.NonNull;
++import org.checkerframework.framework.qual.DefaultQualifier;
++import org.jetbrains.annotations.ApiStatus;
++
++@ApiStatus.Internal
++@DefaultQualifier(NonNull.class)
++record TagKeyImpl<T>(RegistryKey<T> registryKey, Key key) implements TagKey<T> {
++}
+diff --git a/src/main/java/org/bukkit/Registry.java b/src/main/java/org/bukkit/Registry.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/Registry.java
++++ b/src/main/java/org/bukkit/Registry.java
+@@ -0,0 +0,0 @@ public interface Registry<T extends Keyed> extends Iterable<T> {
+      */
+     @Nullable
+     T get(@NotNull NamespacedKey key);
++    // Paper start
++    /**
++     * Get the object by its key.
++     *
++     * @param key non-null key
++     * @return item or null if it does not exist
++     */
++    default @Nullable T get(final net.kyori.adventure.key.@NotNull Key key) {
++        return key instanceof final NamespacedKey nsKey ? this.get(nsKey) : this.get(new NamespacedKey(key.namespace(), key.value()));
++    }
++
++    /**
++     * Get the object by its typed key.
++     *
++     * @param typedKey non-null typed key
++     * @return item or null if it does not exist
++     */
++    default @Nullable T get(final io.papermc.paper.registry.@NotNull TypedKey<T> typedKey) {
++        return this.get(typedKey.key());
++    }
++    // Paper end
+ 
+     // Paper start - improve Registry
+     /**
+@@ -0,0 +0,0 @@ public interface Registry<T extends Keyed> extends Iterable<T> {
+     }
+     // Paper end - improve Registry
+ 
++    // Paper start - RegistrySet API
++    /**
++     * Checks if this registry has a tag with the given key.
++     *
++     * @param key the key to check for
++     * @return true if this registry has a tag with the given key, false otherwise
++     * @see #getTag(io.papermc.paper.registry.tag.TagKey)
++     */
++    @ApiStatus.Experimental
++    default boolean hasTag(final io.papermc.paper.registry.tag.@NotNull TagKey<T> key) {
++        throw new UnsupportedOperationException(this + " doesn't have tags");
++    }
++
++    /**
++     * Gets the named registry set (tag) for the given key.
++     *
++     * @param key the key to get the tag for
++     * @return the tag for the key
++     * @throws java.util.NoSuchElementException if no tag with the given key is found
++     * @throws UnsupportedOperationException if this registry doesn't have or support tags
++     * @see #hasTag(io.papermc.paper.registry.tag.TagKey)
++     */
++    @ApiStatus.Experimental
++    default @NotNull io.papermc.paper.registry.tag.Tag<T> getTag(final io.papermc.paper.registry.tag.@NotNull TagKey<T> key) {
++        throw new UnsupportedOperationException(this + " doesn't have tags");
++    }
++    // Paper end - RegistrySet API
++
+     /**
+      * Returns a new stream, which contains all registry items, which are registered to the registry.
+      *
+@@ -0,0 +0,0 @@ public interface Registry<T extends Keyed> extends Iterable<T> {
+             return value.getKey();
+         }
+         // Paper end - improve Registry
++
++        // Paper start - RegistrySet API
++        @SuppressWarnings("deprecation")
++        @Override
++        public boolean hasTag(final io.papermc.paper.registry.tag.@NotNull TagKey<T> key) {
++            return Bukkit.getUnsafe().getTag(key) != null;
++        }
++
++        @SuppressWarnings("deprecation")
++        @Override
++        public io.papermc.paper.registry.tag.@NotNull Tag<T> getTag(final io.papermc.paper.registry.tag.@NotNull TagKey<T> key) {
++            final io.papermc.paper.registry.tag.Tag<T> tag = Bukkit.getUnsafe().getTag(key);
++            if (tag == null) {
++                throw new java.util.NoSuchElementException("No tag " + key + " found");
++            }
++            return tag;
++        }
++        // Paper end - RegistrySet API
+     }
+ }
+diff --git a/src/main/java/org/bukkit/UnsafeValues.java b/src/main/java/org/bukkit/UnsafeValues.java
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
+--- a/src/main/java/org/bukkit/UnsafeValues.java
++++ b/src/main/java/org/bukkit/UnsafeValues.java
+@@ -0,0 +0,0 @@ public interface UnsafeValues {
+     // Paper end - lifecycle event API
+ 
+     @NotNull java.util.List<net.kyori.adventure.text.Component> computeTooltipLines(@NotNull ItemStack itemStack, @NotNull io.papermc.paper.inventory.tooltip.TooltipContext tooltipContext, @Nullable org.bukkit.entity.Player player); // Paper - expose itemstack tooltip lines
++
++    <A extends Keyed, M> io.papermc.paper.registry.tag.@Nullable Tag<A> getTag(io.papermc.paper.registry.tag.@NotNull TagKey<A> tagKey); // Paper - hack to get tags for non-server backed registries
+ }

patches/api/Test-changes.patch

@@ -132,8 +132,16 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  for (int i = 0; i < paramTypes.length; i++) {
                      if (mustBeAnnotated(paramTypes[i]) ^ isWellAnnotated(method.invisibleParameterAnnotations == null ? null : method.invisibleParameterAnnotations[i])) {
 +                        // Paper start
-+                        if (method.invisibleTypeAnnotations != null || method.visibleTypeAnnotations != null) {
++                        if (method.invisibleTypeAnnotations != null) {
-+                            for (final org.objectweb.asm.tree.TypeAnnotationNode invisibleTypeAnnotation : java.util.Objects.requireNonNullElse(method.invisibleTypeAnnotations, method.visibleTypeAnnotations)) {
++                            for (final org.objectweb.asm.tree.TypeAnnotationNode invisibleTypeAnnotation : method.invisibleTypeAnnotations) {
++                                final org.objectweb.asm.TypeReference ref = new org.objectweb.asm.TypeReference(invisibleTypeAnnotation.typeRef);
++                                if (ref.getSort() == org.objectweb.asm.TypeReference.METHOD_FORMAL_PARAMETER && ref.getTypeParameterIndex() == i && java.util.Arrays.asList(ACCEPTED_ANNOTATIONS).contains(invisibleTypeAnnotation.desc)) {
++                                    continue dancing;
++                                }
++                            }
++                        }
++                        if (method.visibleTypeAnnotations != null) {
++                            for (final org.objectweb.asm.tree.TypeAnnotationNode invisibleTypeAnnotation : method.visibleTypeAnnotations) {
 +                                final org.objectweb.asm.TypeReference ref = new org.objectweb.asm.TypeReference(invisibleTypeAnnotation.typeRef);
 +                                if (ref.getSort() == org.objectweb.asm.TypeReference.METHOD_FORMAL_PARAMETER && ref.getTypeParameterIndex() == i && java.util.Arrays.asList(ACCEPTED_ANNOTATIONS).contains(invisibleTypeAnnotation.desc)) {
 +                                    continue dancing;

patches/api/WIP-Tag-API.patch

@@ -1,62 +0,0 @@
-From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
-From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com>
-Date: Sat, 15 Jun 2024 21:42:19 -0400
-Subject: [PATCH] WIP Tag API
-
-
-diff --git a/src/main/java/io/papermc/paper/registry/tag/TagKey.java b/src/main/java/io/papermc/paper/registry/tag/TagKey.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
---- /dev/null
-+++ b/src/main/java/io/papermc/paper/registry/tag/TagKey.java
-@@ -0,0 +0,0 @@
-+package io.papermc.paper.registry.tag;
-+
-+import io.papermc.paper.registry.RegistryKey;
-+import net.kyori.adventure.key.Key;
-+import net.kyori.adventure.key.Keyed;
-+import org.checkerframework.checker.nullness.qual.NonNull;
-+import org.jetbrains.annotations.ApiStatus;
-+import org.jetbrains.annotations.Contract;
-+
-+@ApiStatus.Experimental
-+public sealed interface TagKey<T> extends Keyed permits TagKeyImpl {
-+
-+    /**
-+     * Creates a new tag key for a registry.
-+     *
-+     * @param registryKey the registry for the tag
-+     * @param key the specific key for the tag
-+     * @return a new tag key
-+     * @param <T> the registry value type
-+     */
-+    @Contract(value = "_, _ -> new", pure = true)
-+    static <T> @NonNull TagKey<T> create(final @NonNull RegistryKey<T> registryKey, final @NonNull Key key) {
-+        return new TagKeyImpl<>(registryKey, key);
-+    }
-+
-+    /**
-+     * Get the registry key for this tag key.
-+     *
-+     * @return the registry key
-+     */
-+    @NonNull RegistryKey<T> registryKey();
-+}
-diff --git a/src/main/java/io/papermc/paper/registry/tag/TagKeyImpl.java b/src/main/java/io/papermc/paper/registry/tag/TagKeyImpl.java
-new file mode 100644
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
---- /dev/null
-+++ b/src/main/java/io/papermc/paper/registry/tag/TagKeyImpl.java
-@@ -0,0 +0,0 @@
-+package io.papermc.paper.registry.tag;
-+
-+import io.papermc.paper.registry.RegistryKey;
-+import net.kyori.adventure.key.Key;
-+import org.checkerframework.checker.nullness.qual.NonNull;
-+import org.checkerframework.framework.qual.DefaultQualifier;
-+import org.jetbrains.annotations.ApiStatus;
-+
-+@ApiStatus.Internal
-+@DefaultQualifier(NonNull.class)
-+record TagKeyImpl<T>(RegistryKey<T> registryKey, Key key) implements TagKey<T> {
-+}

patches/server/Add-Lifecycle-Event-system.patch

@@ -117,15 +117,15 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +
 +    public <O extends LifecycleEventOwner, E extends PaperLifecycleEvent> void callEvent(final LifecycleEventType<O, ? super E, ?> eventType, final E event, final Predicate<? super O> ownerPredicate) {
-+        final AbstractLifecycleEventType<O, ? super E, ?, ?> lifecycleEventType = (AbstractLifecycleEventType<O, ? super E, ?, ?>) eventType;
++        final AbstractLifecycleEventType<O, ? super E, ?> lifecycleEventType = (AbstractLifecycleEventType<O, ? super E, ?>) eventType;
-+        lifecycleEventType.forEachHandler(registeredHandler -> {
++        lifecycleEventType.forEachHandler(event, registeredHandler -> {
 +            try {
 +                if (event instanceof final OwnerAwareLifecycleEvent<?> ownerAwareEvent) {
 +                    ownerAwareGenericHelper(ownerAwareEvent, registeredHandler.owner());
 +                }
 +                registeredHandler.lifecycleEventHandler().run(event);
 +            } catch (final Throwable ex) {
-+                LOGGER.error("Could not run '{}' lifecycle event handler from {}", lifecycleEventType.name(), registeredHandler.owner().getPluginMeta().getDisplayName(), ex);
++                throw new RuntimeException("Could not run '%s' lifecycle event handler from %s".formatted(lifecycleEventType.name(), registeredHandler.owner().getPluginMeta().getDisplayName()), ex);
 +            } finally {
 +                if (event instanceof final OwnerAwareLifecycleEvent<?> ownerAwareEvent) {
 +                    ownerAwareEvent.setOwner(null);
@@ -151,7 +151,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +
 +    private <O extends LifecycleEventOwner> void removeEventHandlersOwnedBy(final LifecycleEventType<O, ?, ?> eventType, final Plugin possibleOwner) {
-+        final AbstractLifecycleEventType<O, ?, ?, ?> lifecycleEventType = (AbstractLifecycleEventType<O, ?, ?, ?>) eventType;
++        final AbstractLifecycleEventType<O, ?, ?> lifecycleEventType = (AbstractLifecycleEventType<O, ?, ?>) eventType;
 +        lifecycleEventType.removeMatching(registeredHandler -> registeredHandler.owner().getPluginMeta().getName().equals(possibleOwner.getPluginMeta().getName()));
 +    }
 +
@@ -213,7 +213,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    @Override
 +    public void registerEventHandler(final LifecycleEventHandlerConfiguration<? super O> handlerConfiguration) {
 +        Preconditions.checkState(this.registrationCheck.getAsBoolean(), "Cannot register lifecycle event handlers");
-+        ((AbstractLifecycleEventHandlerConfiguration<? super O, ?, ?>) handlerConfiguration).registerFrom(this.owner);
++        ((AbstractLifecycleEventHandlerConfiguration<? super O, ?>) handlerConfiguration).registerFrom(this.owner);
 +    }
 +}
 diff --git a/src/main/java/io/papermc/paper/plugin/lifecycle/event/handler/configuration/AbstractLifecycleEventHandlerConfiguration.java b/src/main/java/io/papermc/paper/plugin/lifecycle/event/handler/configuration/AbstractLifecycleEventHandlerConfiguration.java
@@ -232,20 +232,22 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.checkerframework.framework.qual.DefaultQualifier;
 +
 +@DefaultQualifier(NonNull.class)
-+public abstract class AbstractLifecycleEventHandlerConfiguration<O extends LifecycleEventOwner, E extends LifecycleEvent, CI extends AbstractLifecycleEventHandlerConfiguration<O, E, CI>> implements LifecycleEventHandlerConfiguration<O> {
++public abstract class AbstractLifecycleEventHandlerConfiguration<O extends LifecycleEventOwner, E extends LifecycleEvent> implements LifecycleEventHandlerConfiguration<O> {
 +
 +    private final LifecycleEventHandler<? super E> handler;
-+    private final AbstractLifecycleEventType<O, E, ?, CI> type;
++    private final AbstractLifecycleEventType<O, E, ?> type;
 +
-+    protected AbstractLifecycleEventHandlerConfiguration(final LifecycleEventHandler<? super E> handler, final AbstractLifecycleEventType<O, E, ?, CI> type) {
++    protected AbstractLifecycleEventHandlerConfiguration(final LifecycleEventHandler<? super E> handler, final AbstractLifecycleEventType<O, E, ?> type) {
 +        this.handler = handler;
 +        this.type = type;
 +    }
 +
-+    public abstract CI config();
-+
 +    public final void registerFrom(final O owner) {
-+        this.type.tryRegister(owner, this.handler, this.config());
++        this.type.tryRegister(owner, this);
++    }
++
++    public LifecycleEventHandler<? super E> handler() {
++        return this.handler;
 +    }
 +}
 diff --git a/src/main/java/io/papermc/paper/plugin/lifecycle/event/handler/configuration/MonitorLifecycleEventHandlerConfigurationImpl.java b/src/main/java/io/papermc/paper/plugin/lifecycle/event/handler/configuration/MonitorLifecycleEventHandlerConfigurationImpl.java
@@ -264,19 +266,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.checkerframework.framework.qual.DefaultQualifier;
 +
 +@DefaultQualifier(NonNull.class)
-+public class MonitorLifecycleEventHandlerConfigurationImpl<O extends LifecycleEventOwner, E extends LifecycleEvent> extends AbstractLifecycleEventHandlerConfiguration<O, E, MonitorLifecycleEventHandlerConfigurationImpl<O, E>> implements MonitorLifecycleEventHandlerConfiguration<O> {
++public class MonitorLifecycleEventHandlerConfigurationImpl<O extends LifecycleEventOwner, E extends LifecycleEvent> extends AbstractLifecycleEventHandlerConfiguration<O, E> implements MonitorLifecycleEventHandlerConfiguration<O> {
 +
 +    private boolean monitor = false;
 +
-+    public MonitorLifecycleEventHandlerConfigurationImpl(final LifecycleEventHandler<? super E> handler, final AbstractLifecycleEventType<O, E, ?, MonitorLifecycleEventHandlerConfigurationImpl<O, E>> eventType) {
++    public MonitorLifecycleEventHandlerConfigurationImpl(final LifecycleEventHandler<? super E> handler, final AbstractLifecycleEventType<O, E, ?> eventType) {
 +        super(handler, eventType);
 +    }
 +
-+    @Override
-+    public MonitorLifecycleEventHandlerConfigurationImpl<O, E> config() {
-+        return this;
-+    }
-+
 +    public boolean isMonitor() {
 +        return this.monitor;
 +    }
@@ -304,22 +301,19 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.checkerframework.framework.qual.DefaultQualifier;
 +
 +@DefaultQualifier(NonNull.class)
-+public class PrioritizedLifecycleEventHandlerConfigurationImpl<O extends LifecycleEventOwner, E extends LifecycleEvent> extends AbstractLifecycleEventHandlerConfiguration<O, E, PrioritizedLifecycleEventHandlerConfigurationImpl<O, E>> implements PrioritizedLifecycleEventHandlerConfiguration<O> {
++public class PrioritizedLifecycleEventHandlerConfigurationImpl<O extends LifecycleEventOwner, E extends LifecycleEvent>
++    extends AbstractLifecycleEventHandlerConfiguration<O, E>
++    implements PrioritizedLifecycleEventHandlerConfiguration<O> {
 +
 +    private static final OptionalInt DEFAULT_PRIORITY = OptionalInt.of(0);
 +    private static final OptionalInt MONITOR_PRIORITY = OptionalInt.empty();
 +
 +    private OptionalInt priority = DEFAULT_PRIORITY;
 +
-+    public PrioritizedLifecycleEventHandlerConfigurationImpl(final LifecycleEventHandler<? super E> handler, final AbstractLifecycleEventType<O, E, ?, PrioritizedLifecycleEventHandlerConfigurationImpl<O, E>> eventType) {
++    public PrioritizedLifecycleEventHandlerConfigurationImpl(final LifecycleEventHandler<? super E> handler, final AbstractLifecycleEventType<O, E, ?> eventType) {
 +        super(handler, eventType);
 +    }
 +
-+    @Override
-+    public PrioritizedLifecycleEventHandlerConfigurationImpl<O, E> config() {
-+        return this;
-+    }
-+
 +    public OptionalInt priority() {
 +        return this.priority;
 +    }
@@ -453,7 +447,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.checkerframework.framework.qual.DefaultQualifier;
 +
 +@DefaultQualifier(NonNull.class)
-+public abstract class AbstractLifecycleEventType<O extends LifecycleEventOwner, E extends LifecycleEvent, C extends LifecycleEventHandlerConfiguration<O>, CI extends AbstractLifecycleEventHandlerConfiguration<O, E, CI>> implements LifecycleEventType<O, E, C> {
++public abstract class AbstractLifecycleEventType<O extends LifecycleEventOwner, E extends LifecycleEvent, C extends LifecycleEventHandlerConfiguration<O>> implements LifecycleEventType<O, E, C> {
 +
 +    private final String name;
 +    private final Class<? extends O> ownerType;
@@ -474,19 +468,23 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        }
 +    }
 +
-+    public abstract void forEachHandler(Consumer<? super RegisteredHandler<O, E>> consumer, Predicate<? super RegisteredHandler<O, E>> predicate);
++    public abstract void forEachHandler(E event, Consumer<RegisteredHandler<O, E>> consumer, Predicate<RegisteredHandler<O, E>> predicate);
 +
-+    public abstract void removeMatching(Predicate<? super RegisteredHandler<O, E>> predicate);
++    public abstract void removeMatching(Predicate<RegisteredHandler<O, E>> predicate);
 +
-+    protected abstract void register(O owner, LifecycleEventHandler<? super E> handler, CI config);
++    protected abstract void register(O owner, AbstractLifecycleEventHandlerConfiguration<O, E> config);
 +
-+    public final void tryRegister(final O owner, final LifecycleEventHandler<? super E> handler, final CI config) {
++    public final void tryRegister(final O owner, final AbstractLifecycleEventHandlerConfiguration<O, E> config) {
 +        this.verifyOwner(owner);
 +        LifecycleEventRunner.INSTANCE.checkRegisteredHandler(owner, this);
-+        this.register(owner, handler, config);
++        this.register(owner, config);
 +    }
 +
-+    public record RegisteredHandler<O, E extends LifecycleEvent>(O owner, LifecycleEventHandler<? super E> lifecycleEventHandler) {
++    public record RegisteredHandler<O extends LifecycleEventOwner, E extends LifecycleEvent>(O owner, AbstractLifecycleEventHandlerConfiguration<O, E> config) {
++
++        public LifecycleEventHandler<? super E> lifecycleEventHandler() {
++            return this.config().handler();
++        }
 +    }
 +}
 diff --git a/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/LifecycleEventTypeProviderImpl.java b/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/LifecycleEventTypeProviderImpl.java
@@ -517,7 +515,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    @Override
 +    public <O extends LifecycleEventOwner, E extends LifecycleEvent> LifecycleEventType.Prioritizable<O, E> prioritized(final String name, final Class<? extends O> ownerType) {
-+        return LifecycleEventRunner.INSTANCE.addEventType(new PrioritizableLifecycleEventType<>(name, ownerType));
++        return LifecycleEventRunner.INSTANCE.addEventType(new PrioritizableLifecycleEventType.Simple<>(name, ownerType));
 +    }
 +}
 diff --git a/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/MonitorableLifecycleEventType.java b/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/MonitorableLifecycleEventType.java
@@ -531,6 +529,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import io.papermc.paper.plugin.lifecycle.event.LifecycleEvent;
 +import io.papermc.paper.plugin.lifecycle.event.LifecycleEventOwner;
 +import io.papermc.paper.plugin.lifecycle.event.handler.LifecycleEventHandler;
++import io.papermc.paper.plugin.lifecycle.event.handler.configuration.AbstractLifecycleEventHandlerConfiguration;
 +import io.papermc.paper.plugin.lifecycle.event.handler.configuration.MonitorLifecycleEventHandlerConfiguration;
 +import io.papermc.paper.plugin.lifecycle.event.handler.configuration.MonitorLifecycleEventHandlerConfigurationImpl;
 +import java.util.ArrayList;
@@ -541,7 +540,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.checkerframework.framework.qual.DefaultQualifier;
 +
 +@DefaultQualifier(NonNull.class)
-+public class MonitorableLifecycleEventType<O extends LifecycleEventOwner, E extends LifecycleEvent> extends AbstractLifecycleEventType<O, E, MonitorLifecycleEventHandlerConfiguration<O>, MonitorLifecycleEventHandlerConfigurationImpl<O, E>> implements LifecycleEventType.Monitorable<O, E> {
++public class MonitorableLifecycleEventType<O extends LifecycleEventOwner, E extends LifecycleEvent> extends AbstractLifecycleEventType<O, E, MonitorLifecycleEventHandlerConfiguration<O>> implements LifecycleEventType.Monitorable<O, E> {
 +
 +    final List<RegisteredHandler<O, E>> handlers = new ArrayList<>();
 +    int nonMonitorIdx = 0;
@@ -556,9 +555,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +
 +    @Override
-+    protected void register(final O owner, final LifecycleEventHandler<? super E> handler, final MonitorLifecycleEventHandlerConfigurationImpl<O, E> config) {
++    protected void register(final O owner, final AbstractLifecycleEventHandlerConfiguration<O, E> config) {
-+        final RegisteredHandler<O, E> registeredHandler = new RegisteredHandler<>(owner, handler);
++        if (!(config instanceof final MonitorLifecycleEventHandlerConfigurationImpl<?,?> monitor)) {
-+        if (!config.isMonitor()) {
++            throw new IllegalArgumentException("Configuration must be a MonitorLifecycleEventHandlerConfiguration");
++        }
++        final RegisteredHandler<O, E> registeredHandler = new RegisteredHandler<>(owner, config);
++        if (!monitor.isMonitor()) {
 +            this.handlers.add(this.nonMonitorIdx, registeredHandler);
 +            this.nonMonitorIdx++;
 +        } else {
@@ -567,7 +569,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +
 +    @Override
-+    public void forEachHandler(final Consumer<? super RegisteredHandler<O, E>> consumer, final Predicate<? super RegisteredHandler<O, E>> predicate) {
++    public void forEachHandler(final E event, final Consumer<RegisteredHandler<O, E>> consumer, final Predicate<RegisteredHandler<O, E>> predicate) {
 +        for (final RegisteredHandler<O, E> handler : this.handlers) {
 +            if (predicate.test(handler)) {
 +                consumer.accept(handler);
@@ -576,7 +578,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +
 +    @Override
-+    public void removeMatching(final Predicate<? super RegisteredHandler<O, E>> predicate) {
++    public void removeMatching(final Predicate<RegisteredHandler<O, E>> predicate) {
 +        this.handlers.removeIf(predicate);
 +    }
 +}
@@ -609,24 +611,29 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@
 +package io.papermc.paper.plugin.lifecycle.event.types;
 +
++import com.google.common.base.Preconditions;
 +import io.papermc.paper.plugin.lifecycle.event.LifecycleEvent;
 +import io.papermc.paper.plugin.lifecycle.event.LifecycleEventOwner;
 +import io.papermc.paper.plugin.lifecycle.event.handler.LifecycleEventHandler;
++import io.papermc.paper.plugin.lifecycle.event.handler.configuration.AbstractLifecycleEventHandlerConfiguration;
 +import io.papermc.paper.plugin.lifecycle.event.handler.configuration.PrioritizedLifecycleEventHandlerConfiguration;
 +import io.papermc.paper.plugin.lifecycle.event.handler.configuration.PrioritizedLifecycleEventHandlerConfigurationImpl;
 +import java.util.ArrayList;
 +import java.util.Comparator;
 +import java.util.List;
-+import java.util.OptionalInt;
 +import java.util.function.Consumer;
 +import java.util.function.Predicate;
 +import org.checkerframework.checker.nullness.qual.NonNull;
 +import org.checkerframework.framework.qual.DefaultQualifier;
 +
 +@DefaultQualifier(NonNull.class)
-+public class PrioritizableLifecycleEventType<O extends LifecycleEventOwner, E extends LifecycleEvent> extends AbstractLifecycleEventType<O, E, PrioritizedLifecycleEventHandlerConfiguration<O>, PrioritizedLifecycleEventHandlerConfigurationImpl<O, E>> implements LifecycleEventType.Prioritizable<O, E> {
++public abstract class PrioritizableLifecycleEventType<
++    O extends LifecycleEventOwner,
++    E extends LifecycleEvent,
++    C extends PrioritizedLifecycleEventHandlerConfiguration<O>
++> extends AbstractLifecycleEventType<O, E, C> {
 +
-+    private static final Comparator<PrioritizedHandler<?, ?>> COMPARATOR = Comparator.comparing(PrioritizedHandler::priority, (o1, o2) -> {
++    private static final Comparator<RegisteredHandler<?, ?>> COMPARATOR = Comparator.comparing(handler -> ((PrioritizedLifecycleEventHandlerConfigurationImpl<?, ?>) handler.config()).priority(), (o1, o2) -> {
 +        if (o1.equals(o2)) {
 +            return 0;
 +        } else if (o1.isEmpty()) {
@@ -638,38 +645,43 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        }
 +    });
 +
-+    private final List<PrioritizedHandler<O, E>> handlers = new ArrayList<>();
++    private final List<RegisteredHandler<O, E>> handlers = new ArrayList<>();
 +
 +    public PrioritizableLifecycleEventType(final String name, final Class<? extends O> ownerType) {
 +        super(name, ownerType);
 +    }
 +
 +    @Override
++    protected void register(final O owner, final AbstractLifecycleEventHandlerConfiguration<O, E> config) {
++        Preconditions.checkArgument(config instanceof PrioritizedLifecycleEventHandlerConfigurationImpl<?, ?>, "Configuration must be a PrioritizedLifecycleEventHandlerConfiguration");
++        this.handlers.add(new RegisteredHandler<>(owner, config));
++        this.handlers.sort(COMPARATOR);
++    }
++
++    @Override
++    public void forEachHandler(final E event, final Consumer<RegisteredHandler<O, E>> consumer, final Predicate<RegisteredHandler<O, E>> predicate) {
++        for (final RegisteredHandler<O, E> handler : this.handlers) {
++            if (predicate.test(handler)) {
++                consumer.accept(handler);
++            }
++        }
++    }
++
++    @Override
++    public void removeMatching(final Predicate<RegisteredHandler<O, E>> predicate) {
++        this.handlers.removeIf(predicate);
++    }
++
++    public static class Simple<O extends LifecycleEventOwner, E extends LifecycleEvent> extends PrioritizableLifecycleEventType<O, E, PrioritizedLifecycleEventHandlerConfiguration<O>> implements LifecycleEventType.Prioritizable<O, E> {
++        public Simple(final String name, final Class<? extends O> ownerType) {
++            super(name, ownerType);
++        }
++
++        @Override
 +        public PrioritizedLifecycleEventHandlerConfiguration<O> newHandler(final LifecycleEventHandler<? super E> handler) {
 +            return new PrioritizedLifecycleEventHandlerConfigurationImpl<>(handler, this);
 +        }
-+
-+    @Override
-+    protected void register(final O owner, final LifecycleEventHandler<? super E> handler, final PrioritizedLifecycleEventHandlerConfigurationImpl<O, E> config) {
-+        this.handlers.add(new PrioritizedHandler<>(new RegisteredHandler<>(owner, handler), config.priority()));
-+        this.handlers.sort(COMPARATOR);
 +    }
-+
-+    @Override
-+    public void forEachHandler(final Consumer<? super RegisteredHandler<O, E>> consumer, final Predicate<? super RegisteredHandler<O, E>> predicate) {
-+        for (final PrioritizedHandler<O, E> handler : this.handlers) {
-+            if (predicate.test(handler.handler())) {
-+                consumer.accept(handler.handler());
-+            }
-+        }
-+    }
-+
-+    @Override
-+    public void removeMatching(final Predicate<? super RegisteredHandler<O, E>> predicate) {
-+        this.handlers.removeIf(prioritizedHandler -> predicate.test(prioritizedHandler.handler()));
-+    }
-+
-+    private record PrioritizedHandler<O extends LifecycleEventOwner, E extends LifecycleEvent>(RegisteredHandler<O, E> handler, OptionalInt priority) {}
 +}
 diff --git a/src/main/java/io/papermc/paper/plugin/manager/PaperPluginInstanceManager.java b/src/main/java/io/papermc/paper/plugin/manager/PaperPluginInstanceManager.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644

patches/server/Add-RegistryAccess-for-managing-Registries.patch

@@ -18,6 +18,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@
 +package io.papermc.paper.registry;
 +
++import io.papermc.paper.adventure.PaperAdventure;
 +import io.papermc.paper.registry.entry.RegistryEntry;
 +import java.util.Collections;
 +import java.util.IdentityHashMap;
@@ -48,6 +49,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.bukkit.craftbukkit.inventory.trim.CraftTrimPattern;
 +import org.bukkit.craftbukkit.legacy.FieldRename;
 +import org.bukkit.craftbukkit.potion.CraftPotionEffectType;
++import org.bukkit.craftbukkit.util.CraftNamespacedKey;
 +import org.bukkit.damage.DamageType;
 +import org.bukkit.entity.Wolf;
 +import org.bukkit.entity.memory.MemoryKey;
@@ -66,9 +68,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +@DefaultQualifier(NonNull.class)
 +public final class PaperRegistries {
 +
-+    static final List<RegistryEntry<?, ?, ?>> REGISTRY_ENTRIES;
++    static final List<RegistryEntry<?, ?>> REGISTRY_ENTRIES;
-+    private static final Map<RegistryKey<?>, RegistryEntry<?, ?, ?>> BY_REGISTRY_KEY;
++    private static final Map<RegistryKey<?>, RegistryEntry<?, ?>> BY_REGISTRY_KEY;
-+    private static final Map<ResourceKey<?>, RegistryEntry<?, ?, ?>> BY_RESOURCE_KEY;
++    private static final Map<ResourceKey<?>, RegistryEntry<?, ?>> BY_RESOURCE_KEY;
 +    static {
 +        REGISTRY_ENTRIES = List.of(
 +            // built-ins
@@ -105,9 +107,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            apiOnly(Registries.FROG_VARIANT, RegistryKey.FROG_VARIANT, () -> org.bukkit.Registry.FROG_VARIANT),
 +            apiOnly(Registries.MAP_DECORATION_TYPE, RegistryKey.MAP_DECORATION_TYPE, () -> org.bukkit.Registry.MAP_DECORATION_TYPE)
 +        );
-+        final Map<RegistryKey<?>, RegistryEntry<?, ?, ?>> byRegistryKey = new IdentityHashMap<>(REGISTRY_ENTRIES.size());
++        final Map<RegistryKey<?>, RegistryEntry<?, ?>> byRegistryKey = new IdentityHashMap<>(REGISTRY_ENTRIES.size());
-+        final Map<ResourceKey<?>, RegistryEntry<?, ?, ?>> byResourceKey = new IdentityHashMap<>(REGISTRY_ENTRIES.size());
++        final Map<ResourceKey<?>, RegistryEntry<?, ?>> byResourceKey = new IdentityHashMap<>(REGISTRY_ENTRIES.size());
-+        for (final RegistryEntry<?, ?, ?> entry : REGISTRY_ENTRIES) {
++        for (final RegistryEntry<?, ?> entry : REGISTRY_ENTRIES) {
 +            byRegistryKey.put(entry.apiKey(), entry);
 +            byResourceKey.put(entry.mcKey(), entry);
 +        }
@@ -116,25 +118,34 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +
 +    @SuppressWarnings("unchecked")
-+    public static <M, T extends Keyed, R extends org.bukkit.Registry<T>> @Nullable RegistryEntry<M, T, R> getEntry(final ResourceKey<? extends Registry<M>> resourceKey) {
++    public static <M, T extends Keyed> @Nullable RegistryEntry<M, T> getEntry(final ResourceKey<? extends Registry<M>> resourceKey) {
-+        return (RegistryEntry<M, T, R>) BY_RESOURCE_KEY.get(resourceKey);
++        return (RegistryEntry<M, T>) BY_RESOURCE_KEY.get(resourceKey);
 +    }
 +
 +    @SuppressWarnings("unchecked")
-+    public static <M, T extends Keyed, R extends org.bukkit.Registry<T>> @Nullable RegistryEntry<M, T, R> getEntry(final RegistryKey<? super T> registryKey) {
++    public static <M, T extends Keyed> @Nullable RegistryEntry<M, T> getEntry(final RegistryKey<? super T> registryKey) {
-+        return (RegistryEntry<M, T, R>) BY_REGISTRY_KEY.get(registryKey);
++        return (RegistryEntry<M, T>) BY_REGISTRY_KEY.get(registryKey);
 +    }
 +
 +    @SuppressWarnings("unchecked")
-+    public static <M, T> RegistryKey<T> fromNms(final ResourceKey<? extends Registry<M>> registryResourceKey) {
++    public static <M, T> RegistryKey<T> registryFromNms(final ResourceKey<? extends Registry<M>> registryResourceKey) {
 +        return (RegistryKey<T>) Objects.requireNonNull(BY_RESOURCE_KEY.get(registryResourceKey), registryResourceKey + " doesn't have an api RegistryKey").apiKey();
 +    }
 +
 +    @SuppressWarnings("unchecked")
-+    public static <M, T> ResourceKey<? extends Registry<M>> toNms(final RegistryKey<T> registryKey) {
++    public static <M, T> ResourceKey<? extends Registry<M>> registryToNms(final RegistryKey<T> registryKey) {
 +        return (ResourceKey<? extends Registry<M>>) Objects.requireNonNull(BY_REGISTRY_KEY.get(registryKey), registryKey + " doesn't have an mc registry ResourceKey").mcKey();
 +    }
 +
++    public static <M, T> TypedKey<T> fromNms(final ResourceKey<M> resourceKey) {
++        return TypedKey.create(registryFromNms(resourceKey.registryKey()), CraftNamespacedKey.fromMinecraft(resourceKey.location()));
++    }
++
++    @SuppressWarnings({"unchecked", "RedundantCast"})
++    public static <M, T> ResourceKey<M> toNms(final TypedKey<T> typedKey) {
++        return ResourceKey.create((ResourceKey<? extends Registry<M>>) PaperRegistries.registryToNms(typedKey.registryKey()), PaperAdventure.asVanilla(typedKey.key()));
++    }
++
 +    private PaperRegistries() {
 +    }
 +}
@@ -190,7 +201,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    @Override
 +    public <T extends Keyed> @Nullable Registry<T> getRegistry(final Class<T> type) {
 +        final RegistryKey<T> registryKey;
-+        final @Nullable RegistryEntry<?, T, ?> entry;
++        final @Nullable RegistryEntry<?, T> entry;
 +        registryKey = requireNonNull(byType(type), () -> type + " is not a valid registry type");
 +        entry = PaperRegistries.getEntry(registryKey);
 +        final @Nullable RegistryHolder<T> registry = (RegistryHolder<T>) this.registries.get(registryKey);
@@ -198,7 +209,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            // if the registry exists, return right away. Since this is the "legacy" method, we return DelayedRegistry
 +            // for the non-builtin Registry instances stored as fields in Registry.
 +            return registry.get();
-+        } else if (entry instanceof DelayedRegistryEntry<?, T, ?>) {
++        } else if (entry instanceof DelayedRegistryEntry<?, T>) {
 +            // if the registry doesn't exist and the entry is marked as "delayed", we create a registry holder that is empty
 +            // which will later be filled with the actual registry. This is so the fields on org.bukkit.Registry can be populated with
 +            // registries that don't exist at the time org.bukkit.Registry is statically initialized.
@@ -243,7 +254,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    @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) {
-+        final @Nullable RegistryEntry<M, B, R> entry = PaperRegistries.getEntry(resourceKey);
++        final @Nullable RegistryEntry<M, B> entry = PaperRegistries.getEntry(resourceKey);
 +        if (entry == null) { // skip registries that don't have API entries
 +            return;
 +        }
@@ -252,7 +263,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            // if the holder doesn't exist yet, or is marked as "replaceable", put it in the map.
 +            this.registries.put(entry.apiKey(), entry.createRegistryHolder(registry));
 +        } else {
-+            if (registryHolder instanceof RegistryHolder.Delayed<?, ?> && entry instanceof final DelayedRegistryEntry<M, B, R> delayedEntry) {
++            if (registryHolder instanceof RegistryHolder.Delayed<?, ?> && entry instanceof final DelayedRegistryEntry<M, B> delayedEntry) {
 +                // if the registry holder is delayed, and the entry is marked as "delayed", then load the holder with the CraftRegistry instance that wraps the actual nms Registry.
 +                ((RegistryHolder.Delayed<B, R>) registryHolder).loadFrom(delayedEntry, registry);
 +            } else {
@@ -312,7 +323,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            return this.delayedRegistry;
 +        }
 +
-+        <M> void loadFrom(final DelayedRegistryEntry<M, B, R> delayedEntry, final net.minecraft.core.Registry<M> registry) {
++        <M> void loadFrom(final DelayedRegistryEntry<M, B> delayedEntry, final net.minecraft.core.Registry<M> registry) {
 +            final RegistryHolder<B> delegateHolder = delayedEntry.delegate().createRegistryHolder(registry);
 +            if (!(delegateHolder instanceof RegistryHolder.Memoized<B, ?>)) {
 +                throw new IllegalArgumentException(delegateHolder + " must be a memoized holder");
@@ -336,7 +347,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import net.minecraft.resources.ResourceKey;
 +import org.bukkit.Keyed;
 +
-+public class ApiRegistryEntry<M, B extends Keyed> extends BaseRegistryEntry<M, B, org.bukkit.Registry<B>> {
++public class ApiRegistryEntry<M, B extends Keyed> extends BaseRegistryEntry<M, B> {
 +
 +    private final Supplier<org.bukkit.Registry<B>> registrySupplier;
 +
@@ -367,7 +378,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import net.minecraft.resources.ResourceKey;
 +import org.bukkit.Keyed;
 +
-+public abstract class BaseRegistryEntry<M, B extends Keyed, R extends org.bukkit.Registry<B>> implements RegistryEntry<M, B, R> { // TODO remove Keyed
++public abstract class BaseRegistryEntry<M, B extends Keyed> implements RegistryEntry<M, B> { // TODO remove Keyed
 +
 +    private final ResourceKey<? extends Registry<M>> minecraftRegistryKey;
 +    private final RegistryKey<B> apiRegistryKey;
@@ -408,13 +419,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import org.checkerframework.framework.qual.DefaultQualifier;
 +
 +@DefaultQualifier(NonNull.class)
-+public class CraftRegistryEntry<M, B extends Keyed> extends BaseRegistryEntry<M, B, CraftRegistry<B, M>> { // TODO remove Keyed
++public class CraftRegistryEntry<M, B extends Keyed> extends BaseRegistryEntry<M, B> { // TODO remove Keyed
 +
 +    private static final BiFunction<NamespacedKey, ApiVersion, NamespacedKey> EMPTY = (namespacedKey, apiVersion) -> namespacedKey;
 +
 +    protected final Class<?> classToPreload;
 +    protected final BiFunction<NamespacedKey, M, B> minecraftToBukkit;
-+    private BiFunction<NamespacedKey, ApiVersion, NamespacedKey> updater = EMPTY;
++    protected BiFunction<NamespacedKey, ApiVersion, NamespacedKey> updater = EMPTY;
 +
 +    protected CraftRegistryEntry(
 +        final ResourceKey<? extends Registry<M>> mcKey,
@@ -428,7 +439,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +
 +    @Override
-+    public RegistryEntry<M, B, CraftRegistry<B, M>> withSerializationUpdater(final BiFunction<NamespacedKey, ApiVersion, NamespacedKey> updater) {
++    public RegistryEntry<M, B> withSerializationUpdater(final BiFunction<NamespacedKey, ApiVersion, NamespacedKey> updater) {
 +        this.updater = updater;
 +        return this;
 +    }
@@ -459,17 +470,16 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import net.minecraft.resources.ResourceKey;
 +import org.bukkit.Keyed;
 +import org.bukkit.NamespacedKey;
-+import org.bukkit.craftbukkit.CraftRegistry;
 +import org.bukkit.craftbukkit.util.ApiVersion;
 +import org.checkerframework.checker.nullness.qual.NonNull;
 +import org.checkerframework.framework.qual.DefaultQualifier;
 +
 +@DefaultQualifier(NonNull.class)
-+public interface RegistryEntry<M, B extends Keyed, R extends org.bukkit.Registry<B>> extends RegistryEntryInfo<M, B> { // TODO remove Keyed
++public interface RegistryEntry<M, B extends Keyed> extends RegistryEntryInfo<M, B> { // TODO remove Keyed
 +
 +    RegistryHolder<B> createRegistryHolder(Registry<M> nmsRegistry);
 +
-+    default RegistryEntry<M, B, R> withSerializationUpdater(final BiFunction<NamespacedKey, ApiVersion, NamespacedKey> updater) {
++    default RegistryEntry<M, B> withSerializationUpdater(final BiFunction<NamespacedKey, ApiVersion, NamespacedKey> updater) {
 +        return this;
 +    }
 +
@@ -479,11 +489,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +     * as fields, but instead be obtained via {@link io.papermc.paper.registry.RegistryAccess#getRegistry(RegistryKey)}
 +     */
 +    @Deprecated
-+    default RegistryEntry<M, B, R> delayed() {
++    default RegistryEntry<M, B> delayed() {
 +        return new DelayedRegistryEntry<>(this);
 +    }
 +
-+    static <M, B extends Keyed> RegistryEntry<M, B, CraftRegistry<B, M>> entry(
++    static <M, B extends Keyed> RegistryEntry<M, B> entry(
 +        final ResourceKey<? extends Registry<M>> mcKey,
 +        final RegistryKey<B> apiKey,
 +        final Class<?> classToPreload,
@@ -492,7 +502,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        return new CraftRegistryEntry<>(mcKey, apiKey, classToPreload, minecraftToBukkit);
 +    }
 +
-+    static <M, B extends Keyed> RegistryEntry<M, B, org.bukkit.Registry<B>> apiOnly(
++    static <M, B extends Keyed> RegistryEntry<M, B> apiOnly(
 +        final ResourceKey<? extends Registry<M>> mcKey,
 +        final RegistryKey<B> apiKey,
 +        final Supplier<org.bukkit.Registry<B>> apiRegistrySupplier
@@ -605,7 +615,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import net.minecraft.resources.ResourceKey;
 +import org.bukkit.Keyed;
 +
-+public record DelayedRegistryEntry<M, T extends Keyed, R extends org.bukkit.Registry<T>>(RegistryEntry<M, T, R> delegate) implements RegistryEntry<M, T, R> {
++public record DelayedRegistryEntry<M, T extends Keyed>(RegistryEntry<M, T> delegate) implements RegistryEntry<M, T> {
 +
 +    @Override
 +    public ResourceKey<? extends Registry<M>> mcKey() {
@@ -912,6 +922,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  import net.minecraft.resources.ResourceLocation;
 +import org.bukkit.Keyed;
  import org.bukkit.support.AbstractTestingBase;
++import org.checkerframework.checker.nullness.qual.Nullable;
  import org.junit.jupiter.api.BeforeAll;
  import org.junit.jupiter.params.ParameterizedTest;
  import org.junit.jupiter.params.provider.MethodSource;
@@ -929,7 +940,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    @ParameterizedTest
 +    @MethodSource("data")
 +    void testRegistryEntryExists(final RegistryKey<?> key) {
-+        final RegistryEntry<?, ?, ?> entry = PaperRegistries.getEntry(key);
++        final @Nullable RegistryEntry<?, ?> entry = PaperRegistries.getEntry(key);
 +        assertNotNull(entry, "Missing PaperRegistries entry for " + key);
      }
  }

patches/server/Adventure.patch

@@ -1166,6 +1166,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import com.mojang.brigadier.StringReader;
 +import com.mojang.brigadier.exceptions.CommandSyntaxException;
 +import com.mojang.serialization.JavaOps;
++import com.mojang.serialization.JsonOps;
 +import io.netty.util.AttributeKey;
 +import java.io.IOException;
 +import java.util.ArrayList;
@@ -1302,7 +1303,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            return decoded.toString();
 +        }
 +    };
-+    public static final ComponentSerializer<Component, Component, net.minecraft.network.chat.Component> WRAPPER_AWARE_SERIALIZER = new WrapperAwareSerializer();
++    public static final ComponentSerializer<Component, Component, net.minecraft.network.chat.Component> WRAPPER_AWARE_SERIALIZER = new WrapperAwareSerializer(() -> CraftRegistry.getMinecraftRegistry().createSerializationContext(JavaOps.INSTANCE));
 +
 +    private PaperAdventure() {
 +    }
@@ -1647,21 +1648,30 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@
 +package io.papermc.paper.adventure;
 +
++import com.google.common.base.Suppliers;
 +import com.mojang.datafixers.util.Pair;
 +import com.mojang.serialization.JavaOps;
++import java.util.function.Supplier;
 +import net.kyori.adventure.text.Component;
 +import net.kyori.adventure.text.serializer.ComponentSerializer;
 +import net.minecraft.network.chat.ComponentSerialization;
 +import net.minecraft.resources.RegistryOps;
 +import org.bukkit.craftbukkit.CraftRegistry;
 +
-+final class WrapperAwareSerializer implements ComponentSerializer<Component, Component, net.minecraft.network.chat.Component> {
++public final class WrapperAwareSerializer implements ComponentSerializer<Component, Component, net.minecraft.network.chat.Component> {
++
++    private final Supplier<RegistryOps<Object>> javaOps;
++
++    public WrapperAwareSerializer(final Supplier<RegistryOps<Object>> javaOps) {
++        this.javaOps = Suppliers.memoize(javaOps::get);
++    }
++
 +    @Override
 +    public Component deserialize(final net.minecraft.network.chat.Component input) {
 +        if (input instanceof AdventureComponent) {
 +            return ((AdventureComponent) input).adventure;
 +        }
-+        final RegistryOps<Object> ops = CraftRegistry.getMinecraftRegistry().createSerializationContext(JavaOps.INSTANCE);
++        final RegistryOps<Object> ops = this.javaOps.get();
 +        final Object obj = ComponentSerialization.CODEC.encodeStart(ops, input)
 +            .getOrThrow(s -> new RuntimeException("Failed to encode Minecraft Component: " + input + "; " + s));
 +        final Pair<Component, Object> converted = AdventureCodecs.COMPONENT_CODEC.decode(ops, obj)
@@ -1671,7 +1681,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    @Override
 +    public net.minecraft.network.chat.Component serialize(final Component component) {
-+        final RegistryOps<Object> ops = CraftRegistry.getMinecraftRegistry().createSerializationContext(JavaOps.INSTANCE);
++        final RegistryOps<Object> ops = this.javaOps.get();
 +        final Object obj = AdventureCodecs.COMPONENT_CODEC.encodeStart(ops, component)
 +            .getOrThrow(s -> new RuntimeException("Failed to encode adventure Component: " + component + "; " + s));
 +        final Pair<net.minecraft.network.chat.Component, Object> converted = ComponentSerialization.CODEC.decode(ops, obj)

patches/server/Brigadier-based-command-API.patch

@@ -1361,7 +1361,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    @Override
 +    public <T> ArgumentType<TypedKey<T>> resourceKey(final RegistryKey<T> registryKey) {
 +        return this.wrap(
-+            ResourceKeyArgument.key(PaperRegistries.toNms(registryKey)),
++            ResourceKeyArgument.key(PaperRegistries.registryToNms(registryKey)),
 +            nmsRegistryKey -> TypedKey.create(registryKey, CraftNamespacedKey.fromMinecraft(nmsRegistryKey.location()))
 +        );
 +    }
@@ -1375,7 +1375,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    private <T, K extends Keyed> ArgumentType<T> resourceRaw(final RegistryKey registryKeyRaw) { // TODO remove Keyed
 +        final RegistryKey<K> registryKey = registryKeyRaw;
 +        return (ArgumentType<T>) this.wrap(
-+            ResourceArgument.resource(PaperCommands.INSTANCE.getBuildContext(), PaperRegistries.toNms(registryKey)),
++            ResourceArgument.resource(PaperCommands.INSTANCE.getBuildContext(), PaperRegistries.registryToNms(registryKey)),
 +            resource -> requireNonNull(
 +                RegistryAccess.registryAccess()
 +                    .getRegistry(registryKey)

patches/server/Paper-Plugins.patch

@@ -770,6 +770,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +import io.papermc.paper.plugin.storage.BootstrapProviderStorage;
 +import io.papermc.paper.plugin.storage.ProviderStorage;
 +import io.papermc.paper.plugin.storage.ServerPluginProviderStorage;
++import it.unimi.dsi.fastutil.objects.Object2BooleanMap;
++import it.unimi.dsi.fastutil.objects.Object2BooleanOpenHashMap;
 +import org.jetbrains.annotations.ApiStatus;
 +
 +import java.util.HashMap;
@@ -782,9 +784,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +    public static final LaunchEntryPointHandler INSTANCE = new LaunchEntryPointHandler();
 +    private final Map<Entrypoint<?>, ProviderStorage<?>> storage = new HashMap<>();
++    private final Object2BooleanMap<Entrypoint<?>> enteredMap = new Object2BooleanOpenHashMap<>();
 +
 +    LaunchEntryPointHandler() {
 +        this.populateProviderStorage();
++        this.enteredMap.defaultReturnValue(false);
 +    }
 +
 +    // Utility
@@ -800,6 +804,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        }
 +
 +        storage.enter();
++        this.enteredMap.put(entrypoint, true);
 +    }
 +
 +    @Override
@@ -823,6 +828,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        return storage;
 +    }
 +
++    public boolean hasEntered(Entrypoint<?> entrypoint) {
++        return this.enteredMap.getBoolean(entrypoint);
++    }
++
 +    // Reload only
 +    public void populateProviderStorage() {
 +        this.storage.put(Entrypoint.BOOTSTRAPPER, new BootstrapProviderStorage());