Tag Lifecycle Events (#10993)

* wip tags

* use generics in tag registrars

* comment out varargs methods for now

* split up patch

* cache loaded service provider

* finish renames

* use builderWithExpectedSize

* finalize

patches/api/0443-Add-Lifecycle-Event-system.patch

@@ -8,7 +8,7 @@ meant for managing resources across reloads and from points in the
 PluginBootstrap.
 
 diff --git a/src/main/java/io/papermc/paper/plugin/bootstrap/BootstrapContext.java b/src/main/java/io/papermc/paper/plugin/bootstrap/BootstrapContext.java
-index 08f2050356acaf74e3210416760e3873c2dafd2c..37dfdcfcbd14947e0550e7528aca68f452e53eb6 100644
+index 70d5f9802f90605a5120ff2a000a2e9395f0aecc..c319f3bbfabdd39ee571c59d7bfc144c58232abc 100644
 --- a/src/main/java/io/papermc/paper/plugin/bootstrap/BootstrapContext.java
 +++ b/src/main/java/io/papermc/paper/plugin/bootstrap/BootstrapContext.java
 @@ -1,6 +1,9 @@
@@ -447,23 +447,27 @@ index 0000000000000000000000000000000000000000..92ea0374079a228ccc59c00fcf58abff
 +}
 diff --git a/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/LifecycleEventTypeProvider.java b/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/LifecycleEventTypeProvider.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..1588f6943a909bed053a952e650e043c44028c2d
+index 0000000000000000000000000000000000000000..3b17f056d162dd42cae0d33cbbb22fece82fe525
 --- /dev/null
 +++ b/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/LifecycleEventTypeProvider.java
-@@ -0,0 +1,18 @@
+@@ -0,0 +1,22 @@
 +package io.papermc.paper.plugin.lifecycle.event.types;
 +
 +import io.papermc.paper.plugin.lifecycle.event.LifecycleEvent;
 +import io.papermc.paper.plugin.lifecycle.event.LifecycleEventOwner;
++import java.util.Optional;
 +import java.util.ServiceLoader;
 +import org.jetbrains.annotations.ApiStatus;
 +
 +@ApiStatus.Internal
 +interface LifecycleEventTypeProvider {
 +
-+    LifecycleEventTypeProvider PROVIDER = ServiceLoader.load(LifecycleEventTypeProvider.class)
-+        .findFirst()
-+        .orElseThrow();
++    Optional<LifecycleEventTypeProvider> INSTANCE = ServiceLoader.load(LifecycleEventTypeProvider.class)
++        .findFirst();
++
++    static LifecycleEventTypeProvider provider() {
++        return INSTANCE.orElseThrow();
++    }
 +
 +    <O extends LifecycleEventOwner, E extends LifecycleEvent> LifecycleEventType.Monitorable<O, E> monitor(String name, Class<? extends O> ownerType);
 +
@@ -471,7 +475,7 @@ index 0000000000000000000000000000000000000000..1588f6943a909bed053a952e650e043c
 +}
 diff --git a/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/LifecycleEvents.java b/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/LifecycleEvents.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..304f978e40e1759bb19704cc5cec399500905195
+index 0000000000000000000000000000000000000000..29476a1a82b3526ac03f21011d297d01462d153e
 --- /dev/null
 +++ b/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/LifecycleEvents.java
 @@ -0,0 +1,52 @@
@@ -494,33 +498,33 @@ index 0000000000000000000000000000000000000000..304f978e40e1759bb19704cc5cec3995
 +
 +    //<editor-fold desc="helper methods" defaultstate="collapsed">
 +    @ApiStatus.Internal
-+    private static <E extends LifecycleEvent> LifecycleEventType.Monitorable<Plugin, E> plugin(final String name) {
++    static <E extends LifecycleEvent> LifecycleEventType.Monitorable<Plugin, E> plugin(final String name) {
 +        return monitor(name, Plugin.class);
 +    }
 +
 +    @ApiStatus.Internal
-+    private static <E extends LifecycleEvent> LifecycleEventType.Prioritizable<Plugin, E> pluginPrioritized(final String name) {
++    static <E extends LifecycleEvent> LifecycleEventType.Prioritizable<Plugin, E> pluginPrioritized(final String name) {
 +        return prioritized(name, Plugin.class);
 +    }
 +
 +    @ApiStatus.Internal
-+    private static <E extends LifecycleEvent> LifecycleEventType.Monitorable<BootstrapContext, E> bootstrap(final String name) {
++    static <E extends LifecycleEvent> LifecycleEventType.Monitorable<BootstrapContext, E> bootstrap(final String name) {
 +        return monitor(name, BootstrapContext.class);
 +    }
 +
 +    @ApiStatus.Internal
-+    private static <E extends LifecycleEvent> LifecycleEventType.Prioritizable<BootstrapContext, E> bootstrapPrioritized(final String name) {
++    static <E extends LifecycleEvent> LifecycleEventType.Prioritizable<BootstrapContext, E> bootstrapPrioritized(final String name) {
 +        return prioritized(name, BootstrapContext.class);
 +    }
 +
 +    @ApiStatus.Internal
-+    private static <O extends LifecycleEventOwner, E extends LifecycleEvent, O2 extends O> LifecycleEventType.Monitorable<O, E> monitor(final String name, final Class<O2> ownerType) {
-+        return LifecycleEventTypeProvider.PROVIDER.monitor(name, ownerType);
++    static <O extends LifecycleEventOwner, E extends LifecycleEvent, O2 extends O> LifecycleEventType.Monitorable<O, E> monitor(final String name, final Class<O2> ownerType) {
++        return LifecycleEventTypeProvider.provider().monitor(name, ownerType);
 +    }
 +
 +    @ApiStatus.Internal
-+    private static <O extends LifecycleEventOwner, E extends LifecycleEvent> LifecycleEventType.Prioritizable<O, E> prioritized(final String name, final Class<? extends O> ownerType) {
-+        return LifecycleEventTypeProvider.PROVIDER.prioritized(name, ownerType);
++    static <O extends LifecycleEventOwner, E extends LifecycleEvent> LifecycleEventType.Prioritizable<O, E> prioritized(final String name, final Class<? extends O> ownerType) {
++        return LifecycleEventTypeProvider.provider().prioritized(name, ownerType);
 +    }
 +    //</editor-fold>
 +

patches/api/0468-Brigadier-based-command-API.patch

@@ -1540,7 +1540,7 @@ index 0000000000000000000000000000000000000000..159b691e7a1a7066f3e706e80d75ca8f
 +}
 diff --git a/src/main/java/io/papermc/paper/command/brigadier/argument/VanillaArgumentProvider.java b/src/main/java/io/papermc/paper/command/brigadier/argument/VanillaArgumentProvider.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..e8c1c0f781bfc852af4a0f01452566ae994dc285
+index 0000000000000000000000000000000000000000..a36a36a46b5d71489e1b3e183d48e6e83721ebdf
 --- /dev/null
 +++ b/src/main/java/io/papermc/paper/command/brigadier/argument/VanillaArgumentProvider.java
 @@ -0,0 +1,107 @@
@@ -1914,7 +1914,7 @@ index 0000000000000000000000000000000000000000..906ce6eff30ebd9ec3010ce03b471418
 +public interface SelectorArgumentResolver<T> extends ArgumentResolver<T> {
 +}
 diff --git a/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/LifecycleEvents.java b/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/LifecycleEvents.java
-index 304f978e40e1759bb19704cc5cec399500905195..1fab48593c567fe05b085ac6e12dc22556cf0b92 100644
+index 29476a1a82b3526ac03f21011d297d01462d153e..dae4935d8e9f46c52f700927a43a9202dac13df6 100644
 --- a/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/LifecycleEvents.java
 +++ b/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/LifecycleEvents.java
 @@ -1,9 +1,11 @@
@@ -1942,7 +1942,7 @@ index 304f978e40e1759bb19704cc5cec399500905195..1fab48593c567fe05b085ac6e12dc225
 +
      //<editor-fold desc="helper methods" defaultstate="collapsed">
      @ApiStatus.Internal
-     private static <E extends LifecycleEvent> LifecycleEventType.Monitorable<Plugin, E> plugin(final String name) {
+     static <E extends LifecycleEvent> LifecycleEventType.Monitorable<Plugin, E> plugin(final String name) {
 diff --git a/src/main/java/org/bukkit/command/Command.java b/src/main/java/org/bukkit/command/Command.java
 index 03d2643d166824458c88a49f20270e93b14f3988..0a26fffe9b1e5080b5639767a03af11006108b4a 100644
 --- a/src/main/java/org/bukkit/command/Command.java
@@ -2046,7 +2046,7 @@ index 3ec32b46264cfff857b50129b5e0fa5584943ec6..bdfe68b386b5ca2878475e548d3c9a38
  
          return true;
 diff --git a/src/main/java/org/bukkit/event/server/TabCompleteEvent.java b/src/main/java/org/bukkit/event/server/TabCompleteEvent.java
-index b43c3cb5c88eada186d6f81712c244aaa18fb53e..ea26cb90d988d693f26e37229fbdee975c0b11f4 100644
+index 6465e290c090d82986352d5ab7ba5dc65bd3dc17..c71c122ccc4775d030688f7b8df0b4feb49136f4 100644
 --- a/src/main/java/org/bukkit/event/server/TabCompleteEvent.java
 +++ b/src/main/java/org/bukkit/event/server/TabCompleteEvent.java
 @@ -18,6 +18,8 @@ import org.jetbrains.annotations.NotNull;

patches/api/0475-Registry-Modification-API.patch

@@ -773,10 +773,10 @@ index 0000000000000000000000000000000000000000..a49d328e95f7fda6567ee6c4f5f1878a
 +}
 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..11d19e339c7c62f2eb4467277552c27e4e83069c
+index 0000000000000000000000000000000000000000..5fde17e97eddcd1d01ee39694c9159d0ff2a09e3
 --- /dev/null
 +++ b/src/main/java/io/papermc/paper/registry/tag/TagKeyImpl.java
-@@ -0,0 +1,12 @@
+@@ -0,0 +1,17 @@
 +package io.papermc.paper.registry.tag;
 +
 +import io.papermc.paper.registry.RegistryKey;
@@ -788,9 +788,14 @@ index 0000000000000000000000000000000000000000..11d19e339c7c62f2eb4467277552c27e
 +@ApiStatus.Internal
 +@DefaultQualifier(NonNull.class)
 +record TagKeyImpl<T>(RegistryKey<T> registryKey, Key key) implements TagKey<T> {
++
++    @Override
++    public String toString() {
++        return "#" + this.key + " (in " + this.registryKey + ")";
++    }
 +}
 diff --git a/src/main/java/org/bukkit/Registry.java b/src/main/java/org/bukkit/Registry.java
-index cd1e38debbec745dd13cd895327f544dcf42594d..c0428edee6ecbbd646c0e58da39a7ca476914fd1 100644
+index 5d21459e9128c515508a2b4b2265d9824e10d9d5..20015393f91af405c99db2635a471fb6ff19e4bf 100644
 --- a/src/main/java/org/bukkit/Registry.java
 +++ b/src/main/java/org/bukkit/Registry.java
 @@ -358,6 +358,27 @@ public interface Registry<T extends Keyed> extends Iterable<T> {

patches/api/0489-Tag-Lifecycle-Events.patch

@@ -0,0 +1,406 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Thu, 20 Jun 2024 09:40:53 -0700
+Subject: [PATCH] Tag Lifecycle Events
+
+
+diff --git a/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/LifecycleEventTypeProvider.java b/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/LifecycleEventTypeProvider.java
+index 3b17f056d162dd42cae0d33cbbb22fece82fe525..a52ab9e09420768d89385c881fb7a4c424e5b8d6 100644
+--- a/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/LifecycleEventTypeProvider.java
++++ b/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/LifecycleEventTypeProvider.java
+@@ -19,4 +19,6 @@ interface LifecycleEventTypeProvider {
+     <O extends LifecycleEventOwner, E extends LifecycleEvent> LifecycleEventType.Monitorable<O, E> monitor(String name, Class<? extends O> ownerType);
+ 
+     <O extends LifecycleEventOwner, E extends LifecycleEvent> LifecycleEventType.Prioritizable<O, E> prioritized(String name, Class<? extends O> ownerType);
++
++    TagEventTypeProvider tagProvider();
+ }
+diff --git a/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/LifecycleEvents.java b/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/LifecycleEvents.java
+index dae4935d8e9f46c52f700927a43a9202dac13df6..720fe2546015838708ce794c291ca187cf7bca9c 100644
+--- a/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/LifecycleEvents.java
++++ b/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/LifecycleEvents.java
+@@ -24,6 +24,12 @@ public final class LifecycleEvents {
+      */
+     public static final LifecycleEventType.Prioritizable<LifecycleEventOwner, ReloadableRegistrarEvent<Commands>> COMMANDS = prioritized("commands", LifecycleEventOwner.class);
+ 
++    /**
++     * These events are for registering tags to the server's tag system. You can register a handler for these events
++     * only in {@link io.papermc.paper.plugin.bootstrap.PluginBootstrap#bootstrap(BootstrapContext)}.
++     */
++    public static final TagEventTypeProvider TAGS = LifecycleEventTypeProvider.provider().tagProvider();
++
+     //<editor-fold desc="helper methods" defaultstate="collapsed">
+     @ApiStatus.Internal
+     static <E extends LifecycleEvent> LifecycleEventType.Monitorable<Plugin, E> plugin(final String name) {
+diff --git a/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/TagEventTypeProvider.java b/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/TagEventTypeProvider.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..61c5f6cc6986193eab596ee55e1a414afcf4fbd1
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/TagEventTypeProvider.java
+@@ -0,0 +1,40 @@
++package io.papermc.paper.plugin.lifecycle.event.types;
++
++import io.papermc.paper.plugin.bootstrap.BootstrapContext;
++import io.papermc.paper.plugin.lifecycle.event.registrar.ReloadableRegistrarEvent;
++import io.papermc.paper.registry.RegistryKey;
++import io.papermc.paper.tag.PostFlattenTagRegistrar;
++import io.papermc.paper.tag.PreFlattenTagRegistrar;
++import org.checkerframework.checker.nullness.qual.NonNull;
++import org.jetbrains.annotations.ApiStatus;
++
++/**
++ * Provides event types for tag registration.
++ *
++ * @see PreFlattenTagRegistrar
++ * @see PostFlattenTagRegistrar
++ */
++@ApiStatus.Experimental
++@ApiStatus.NonExtendable
++public interface TagEventTypeProvider {
++
++    /**
++     * Get a prioritizable, reloadable registrar event for tags before they are flattened.
++     *
++     * @param registryKey the registry key for the tag type
++     * @return the registry event type
++     * @param <T> the type of value in the tag
++     * @see PreFlattenTagRegistrar
++     */
++    <T> LifecycleEventType.@NonNull Prioritizable<BootstrapContext, ReloadableRegistrarEvent<PreFlattenTagRegistrar<T>>> preFlatten(@NonNull RegistryKey<T> registryKey);
++
++    /**
++     * Get a prioritizable, reloadable registrar event for tags after they are flattened.
++     *
++     * @param registryKey the registry key for the tag type
++     * @return the registry event type
++     * @param <T> the type of value in the tag
++     * @see PostFlattenTagRegistrar
++     */
++    <T> LifecycleEventType.@NonNull Prioritizable<BootstrapContext, ReloadableRegistrarEvent<PostFlattenTagRegistrar<T>>> postFlatten(@NonNull RegistryKey<T> registryKey);
++}
+diff --git a/src/main/java/io/papermc/paper/tag/PostFlattenTagRegistrar.java b/src/main/java/io/papermc/paper/tag/PostFlattenTagRegistrar.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..32d79dac18c402c3d95edb642eef1563eddf5e9e
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/tag/PostFlattenTagRegistrar.java
+@@ -0,0 +1,103 @@
++package io.papermc.paper.tag;
++
++import io.papermc.paper.plugin.lifecycle.event.registrar.Registrar;
++import io.papermc.paper.registry.RegistryKey;
++import io.papermc.paper.registry.TypedKey;
++import io.papermc.paper.registry.tag.TagKey;
++import java.util.Collection;
++import java.util.Map;
++import org.checkerframework.checker.nullness.qual.NonNull;
++import org.jetbrains.annotations.ApiStatus;
++import org.jetbrains.annotations.Contract;
++import org.jetbrains.annotations.Unmodifiable;
++
++/**
++ * Registrar for tags after they have been flattened. Flattened
++ * tags are tags which have any nested tags resolved to the tagged
++ * values the nested tags point to. This registrar, being a post-flatten
++ * registrar, allows for modification after that flattening has happened, when
++ * tags only point to individual entries and not other nested tags.
++ * <p>
++ * An example of a custom enchant being registered to the vanilla
++ * {@code #minecraft:in_enchanting_table} tag.
++ * <pre>{@code
++ * class YourBootstrapClass implements PluginBootstrap {
++ *
++ *     @Override
++ *     public void bootstrap(@NotNull BootstrapContext context) {
++ *         LifecycleEventManager<BootstrapContext> manager = context.getLifecycleManager();
++ *         manager.registerEventHandler(LifecycleEvents.TAGS.postFlatten(RegistryKey.ENCHANTMENT), event -> {
++ *             final PostFlattenTagRegistrar<Enchantment> registrar = event.registrar();
++ *             registrar.addToTag(
++ *                 EnchantmentTagKeys.IN_ENCHANTING_TABLE,
++ *                 Set.of(CUSTOM_ENCHANT)
++ *             );
++ *         });
++ *     }
++ * }
++ * }</pre>
++ *
++ * @param <T> the type of value in the tag
++ * @see PreFlattenTagRegistrar
++ */
++@ApiStatus.Experimental
++@ApiStatus.NonExtendable
++public interface PostFlattenTagRegistrar<T> extends Registrar {
++
++    /**
++     * Get the registry key for this tag registrar.
++     *
++     * @return the registry key
++     */
++    @NonNull RegistryKey<T> registryKey();
++
++    /**
++     * Get a copy of all tags currently held in this registrar.
++     *
++     * @return an immutable map of all tags
++     */
++    @Contract(value = "-> new", pure = true)
++    @Unmodifiable @NonNull Map<TagKey<T>, Collection<TypedKey<T>>> getAllTags();
++
++    /**
++     * Checks if this registrar has a tag with the given key.
++     *
++     * @param tagKey the key to check for
++     * @return true if the tag exists, false otherwise
++     */
++    @Contract(pure = true)
++    boolean hasTag(@NonNull TagKey<T> tagKey);
++
++    /**
++     * Get the tag with the given key. Use {@link #hasTag(TagKey)} to check
++     * if a tag exists first.
++     *
++     * @param tagKey the key of the tag to get
++     * @return an immutable list of tag entries
++     * @throws java.util.NoSuchElementException if the tag does not exist
++     * @see #hasTag(TagKey)
++     */
++    @Contract(value = "_ -> new", pure = true)
++    @Unmodifiable @NonNull Collection<TypedKey<T>> getTag(@NonNull TagKey<T> tagKey);
++
++    /**
++     * Adds values to the given tag. If the tag does not exist, it will be created.
++     *
++     * @param tagKey the key of the tag to add to
++     * @param values the values to add
++     * @see #setTag(TagKey, Collection)
++     */
++    @Contract(mutates = "this")
++    void addToTag(@NonNull TagKey<T> tagKey, @NonNull Collection<TypedKey<T>> values);
++
++    /**
++     * Sets the values of the given tag. If the tag does not exist, it will be created.
++     * If the tag does exist, it will be overwritten.
++     *
++     * @param tagKey the key of the tag to set
++     * @param values the values to set
++     * @see #addToTag(TagKey, Collection)
++     */
++    @Contract(mutates = "this")
++    void setTag(@NonNull TagKey<T> tagKey, @NonNull Collection<TypedKey<T>> values);
++}
+diff --git a/src/main/java/io/papermc/paper/tag/PreFlattenTagRegistrar.java b/src/main/java/io/papermc/paper/tag/PreFlattenTagRegistrar.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..44f7a9d3c2734fb00d11890ece9dc4ce2fafa796
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/tag/PreFlattenTagRegistrar.java
+@@ -0,0 +1,102 @@
++package io.papermc.paper.tag;
++
++import io.papermc.paper.plugin.lifecycle.event.registrar.Registrar;
++import io.papermc.paper.registry.RegistryKey;
++import io.papermc.paper.registry.tag.TagKey;
++import java.util.Collection;
++import java.util.List;
++import java.util.Map;
++import org.checkerframework.checker.nullness.qual.NonNull;
++import org.jetbrains.annotations.ApiStatus;
++import org.jetbrains.annotations.Contract;
++import org.jetbrains.annotations.Unmodifiable;
++
++/**
++ * Registrar for tags before they are flattened. Flattened
++ * tags are tags which have any nested tags resolved to the tagged
++ * values the nested tags point to. This registrar, being a pre-flatten
++ * registrar, allows for modification before that flattening has happened, when
++ * tags both point to individual entries and other nested tags.
++ * <p>
++ * An example of a tag being created in a pre-flatten registrar:
++ * <pre>{@code
++ * class YourBootstrapClass implements PluginBootstrap {
++ *
++ *     @Override
++ *     public void bootstrap(@NotNull BootstrapContext context) {
++ *         LifecycleEventManager<BootstrapContext> manager = context.getLifecycleManager();
++ *         manager.registerEventHandler(LifecycleEvents.TAGS.preFlatten(RegistryKey.ITEM), event -> {
++ *             final PreFlattenTagRegistrar<ItemType> registrar = event.registrar();
++ *             registrar.setTag(AXE_PICKAXE, Set.of(
++ *                 TagEntry.tagEntry(ItemTypeTagKeys.PICKAXES),
++ *                 TagEntry.tagEntry(ItemTypeTagKeys.AXES)
++ *             ));
++ *         });
++ *     }
++ * }
++ * }</pre>
++ *
++ * @param <T> the type of value in the tag
++ * @see PostFlattenTagRegistrar
++ */
++@ApiStatus.Experimental
++@ApiStatus.NonExtendable
++public interface PreFlattenTagRegistrar<T> extends Registrar {
++
++    /**
++     * Get the registry key for this tag registrar.
++     *
++     * @return the registry key
++     */
++    @NonNull RegistryKey<T> registryKey();
++
++    /**
++     * Get a copy of all tags currently held in this registrar.
++     *
++     * @return an immutable map of all tags
++     */
++    @Contract(value = "-> new", pure = true)
++    @Unmodifiable @NonNull Map<TagKey<T>, Collection<TagEntry<T>>> getAllTags();
++
++    /**
++     * Checks if this registrar has a tag with the given key.
++     *
++     * @param tagKey the key to check for
++     * @return true if the tag exists, false otherwise
++     */
++    @Contract(pure = true)
++    boolean hasTag(@NonNull TagKey<T> tagKey);
++
++    /**
++     * Get the tag with the given key. Use {@link #hasTag(TagKey)} to check
++     * if a tag exists first.
++     *
++     * @param tagKey the key of the tag to get
++     * @return an immutable list of tag entries
++     * @throws java.util.NoSuchElementException if the tag does not exist
++     * @see #hasTag(TagKey)
++     */
++    @Contract(value = "_ -> new", pure = true)
++    @Unmodifiable @NonNull List<TagEntry<T>> getTag(@NonNull TagKey<T> tagKey);
++
++    /**
++     * Adds entries to the given tag. If the tag does not exist, it will be created.
++     *
++     * @param tagKey the key of the tag to add to
++     * @param entries the entries to add
++     * @see #setTag(TagKey, Collection)
++     */
++    @Contract(mutates = "this")
++    void addToTag(@NonNull TagKey<T> tagKey, @NonNull Collection<TagEntry<T>> entries);
++
++    /**
++     * Sets the entries of the given tag. If the tag does not exist, it will be created.
++     * If the tag does exist, it will be overwritten.
++     *
++     * @param tagKey the key of the tag to set
++     * @param entries the entries to set
++     * @see #addToTag(TagKey, Collection)
++     */
++    @Contract(mutates = "this")
++    void setTag(@NonNull TagKey<T> tagKey, @NonNull Collection<TagEntry<T>> entries);
++}
+diff --git a/src/main/java/io/papermc/paper/tag/TagEntry.java b/src/main/java/io/papermc/paper/tag/TagEntry.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..436b701f1231354a78a9e0ab04ffd9097343ecfc
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/tag/TagEntry.java
+@@ -0,0 +1,89 @@
++package io.papermc.paper.tag;
++
++import io.papermc.paper.registry.TypedKey;
++import io.papermc.paper.registry.tag.TagKey;
++import net.kyori.adventure.key.Keyed;
++import org.checkerframework.checker.nullness.qual.NonNull;
++import org.jetbrains.annotations.ApiStatus;
++import org.jetbrains.annotations.Contract;
++
++/**
++ * An entry is a pre-flattened tag. Represents
++ * either an individual registry entry or a whole tag.
++ *
++ * @param <T> the type of value in the tag
++ * @see PreFlattenTagRegistrar
++ */
++@ApiStatus.Experimental
++@ApiStatus.NonExtendable
++public interface TagEntry<T> extends Keyed {
++
++    /**
++     * Create required tag entry for a single value.
++     *
++     * @param entryKey the key of the entry
++     * @return a new tag entry for a value
++     * @param <T> the type of value
++     */
++    @Contract(value = "_ -> new", pure = true)
++    static <T> @NonNull TagEntry<T> valueEntry(final @NonNull TypedKey<T> entryKey) {
++        return valueEntry(entryKey, true);
++    }
++
++    /**
++     * Create tag entry for a single value.
++     *
++     * @param entryKey the key of the entry
++     * @param isRequired if this entry is required (see {@link #isRequired()})
++     * @return a new tag entry for a value
++     * @param <T> the type of value
++     */
++    @Contract(value = "_, _ -> new", pure = true)
++    static <T> @NonNull TagEntry<T> valueEntry(final @NonNull TypedKey<T> entryKey, final boolean isRequired) {
++        return new TagEntryImpl<>(entryKey.key(), false, isRequired);
++    }
++
++    /**
++     * Create a required tag entry for a nested tag.
++     *
++     * @param tagKey they key for the tag
++     * @return a new tag entry for a tag
++     * @param <T> the type of value
++     */
++    @Contract(value = "_ -> new", pure = true)
++    static <T> @NonNull TagEntry<T> tagEntry(final @NonNull TagKey<T> tagKey) {
++        return tagEntry(tagKey, true);
++    }
++
++    /**
++     * Create a tag entry for a nested tag.
++     *
++     * @param tagKey they key for the tag
++     * @param isRequired if this entry is required (see {@link #isRequired()})
++     * @return a new tag entry for a tag
++     * @param <T> the type of value
++     */
++    @Contract(value = "_, _ -> new", pure = true)
++    static <T> @NonNull TagEntry<T> tagEntry(final @NonNull TagKey<T> tagKey, final boolean isRequired) {
++        return new TagEntryImpl<>(tagKey.key(), true, isRequired);
++    }
++
++    /**
++     * Returns if this entry represents a tag.
++     *
++     * @return true if this entry is a tag, false if it is an individual entry
++     */
++    @Contract(pure = true)
++    boolean isTag();
++
++    /**
++     * Returns if this entry is required. If an entry is required,
++     * the value or tag must exist on the server in order for the tag
++     * to load correctly. A missing value will prevent the tag holding
++     * that missing value from being created.
++     *
++     * @return true if this entry is required, false if it is optional
++     */
++    @Contract(pure = true)
++    boolean isRequired();
++}
+diff --git a/src/main/java/io/papermc/paper/tag/TagEntryImpl.java b/src/main/java/io/papermc/paper/tag/TagEntryImpl.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..c0ffd2b9f814d92d0d9b370dfa7e352f1241f614
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/tag/TagEntryImpl.java
+@@ -0,0 +1,8 @@
++package io.papermc.paper.tag;
++
++import net.kyori.adventure.key.Key;
++import org.jetbrains.annotations.ApiStatus;
++
++@ApiStatus.Internal
++record TagEntryImpl<T>(Key key, boolean isTag, boolean isRequired) implements TagEntry<T> {
++}

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

@@ -429,10 +429,10 @@ index 0000000000000000000000000000000000000000..6d530c52aaf0dc2cdfe3bd56af557274
 +}
 diff --git a/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/AbstractLifecycleEventType.java b/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/AbstractLifecycleEventType.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..9359a36d26970742da3a7abb0050158cd6c64e8e
+index 0000000000000000000000000000000000000000..30f47879f87fc991c651416546c2f068209545f2
 --- /dev/null
 +++ b/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/AbstractLifecycleEventType.java
-@@ -0,0 +1,54 @@
+@@ -0,0 +1,56 @@
 +package io.papermc.paper.plugin.lifecycle.event.types;
 +
 +import io.papermc.paper.plugin.lifecycle.event.LifecycleEvent;
@@ -468,6 +468,8 @@ index 0000000000000000000000000000000000000000..9359a36d26970742da3a7abb0050158c
 +        }
 +    }
 +
++    public abstract boolean hasHandlers();
++
 +    public abstract void forEachHandler(E event, Consumer<RegisteredHandler<O, E>> consumer, Predicate<RegisteredHandler<O, E>> predicate);
 +
 +    public abstract void removeMatching(Predicate<RegisteredHandler<O, E>> predicate);
@@ -489,7 +491,7 @@ index 0000000000000000000000000000000000000000..9359a36d26970742da3a7abb0050158c
 +}
 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
 new file mode 100644
-index 0000000000000000000000000000000000000000..af0cb3298d9c737417c6e54b360f8dc50a5caf04
+index 0000000000000000000000000000000000000000..7e84e0acd50ef04fa1ee2577f49e51c63f5ba5c3
 --- /dev/null
 +++ b/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/LifecycleEventTypeProviderImpl.java
 @@ -0,0 +1,25 @@
@@ -505,7 +507,7 @@ index 0000000000000000000000000000000000000000..af0cb3298d9c737417c6e54b360f8dc5
 +public final class LifecycleEventTypeProviderImpl implements LifecycleEventTypeProvider {
 +
 +    public static LifecycleEventTypeProviderImpl instance() {
-+        return (LifecycleEventTypeProviderImpl) LifecycleEventTypeProvider.PROVIDER;
++        return (LifecycleEventTypeProviderImpl) LifecycleEventTypeProvider.provider();
 +    }
 +
 +    @Override
@@ -520,10 +522,10 @@ index 0000000000000000000000000000000000000000..af0cb3298d9c737417c6e54b360f8dc5
 +}
 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
 new file mode 100644
-index 0000000000000000000000000000000000000000..c71912f0050ce0cc6e416948a354c8a66da606a8
+index 0000000000000000000000000000000000000000..abb969cf6ed967fe7720c56d3b3157bd1b74700d
 --- /dev/null
 +++ b/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/MonitorableLifecycleEventType.java
-@@ -0,0 +1,58 @@
+@@ -0,0 +1,63 @@
 +package io.papermc.paper.plugin.lifecycle.event.types;
 +
 +import io.papermc.paper.plugin.lifecycle.event.LifecycleEvent;
@@ -550,6 +552,11 @@ index 0000000000000000000000000000000000000000..c71912f0050ce0cc6e416948a354c8a6
 +    }
 +
 +    @Override
++    public boolean hasHandlers() {
++        return !this.handlers.isEmpty();
++    }
++
++    @Override
 +    public MonitorLifecycleEventHandlerConfigurationImpl<O, E> newHandler(final LifecycleEventHandler<? super E> handler) {
 +        return new MonitorLifecycleEventHandlerConfigurationImpl<>(handler, this);
 +    }
@@ -605,10 +612,10 @@ index 0000000000000000000000000000000000000000..3e7e7474f301c0725fa2bcd6e19e476f
 +}
 diff --git a/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/PrioritizableLifecycleEventType.java b/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/PrioritizableLifecycleEventType.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..76f92a6fc84c0315f3973dc4e92649b66babc3d5
+index 0000000000000000000000000000000000000000..2ed622a61ddc37b11888867770b513909b9a2ecc
 --- /dev/null
 +++ b/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/PrioritizableLifecycleEventType.java
-@@ -0,0 +1,74 @@
+@@ -0,0 +1,79 @@
 +package io.papermc.paper.plugin.lifecycle.event.types;
 +
 +import com.google.common.base.Preconditions;
@@ -652,6 +659,11 @@ index 0000000000000000000000000000000000000000..76f92a6fc84c0315f3973dc4e92649b6
 +    }
 +
 +    @Override
++    public boolean hasHandlers() {
++        return !this.handlers.isEmpty();
++    }
++
++    @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));

patches/server/1019-Registry-Modification-API.patch

@@ -97,7 +97,7 @@ index 0000000000000000000000000000000000000000..528c6ee1739d92f766f3904acd7fc573
 +}
 diff --git a/src/main/java/io/papermc/paper/registry/PaperRegistryListenerManager.java b/src/main/java/io/papermc/paper/registry/PaperRegistryListenerManager.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..a7f2b264d4f37f5293ae72195b4c78faf35351c9
+index 0000000000000000000000000000000000000000..69e946173407eb05b18a2b19b0d45cbb3213570b
 --- /dev/null
 +++ b/src/main/java/io/papermc/paper/registry/PaperRegistryListenerManager.java
 @@ -0,0 +1,183 @@
@@ -134,12 +134,12 @@ index 0000000000000000000000000000000000000000..a7f2b264d4f37f5293ae72195b4c78fa
 +import org.checkerframework.checker.nullness.qual.Nullable;
 +import org.intellij.lang.annotations.Subst;
 +
-+public final class PaperRegistryListenerManager {
++public class PaperRegistryListenerManager {
 +
 +    public static final PaperRegistryListenerManager INSTANCE = new PaperRegistryListenerManager();
 +
-+    public final RegistryEventMap valueAddHooks = new RegistryEventMap("value add");
-+    public final RegistryEventMap freezeHooks = new RegistryEventMap("freeze");
++    public final RegistryEventMap valueAddEventTypes = new RegistryEventMap("value add");
++    public final RegistryEventMap freezeEventTypes = new RegistryEventMap("freeze");
 +
 +    private PaperRegistryListenerManager() {
 +    }
@@ -200,7 +200,7 @@ index 0000000000000000000000000000000000000000..a7f2b264d4f37f5293ae72195b4c78fa
 +    ) {
 +        Preconditions.checkState(LaunchEntryPointHandler.INSTANCE.hasEntered(Entrypoint.BOOTSTRAPPER), registry.key() + " tried to run modification listeners before bootstrappers have been called"); // verify that bootstrappers have been called
 +        final @Nullable RegistryEntryInfo<M, T> entry = PaperRegistries.getEntry(registry.key());
-+        if (!RegistryEntry.Modifiable.isModifiable(entry) || !this.valueAddHooks.hasHooks(entry.apiKey())) {
++        if (!RegistryEntry.Modifiable.isModifiable(entry) || !this.valueAddEventTypes.hasHandlers(entry.apiKey())) {
 +            return registerMethod.register((WritableRegistry<M>) registry, key, nms, registrationInfo);
 +        }
 +        final RegistryEntry.Modifiable<M, T, B> modifiableEntry = RegistryEntry.Modifiable.asModifiable(entry);
@@ -217,7 +217,7 @@ index 0000000000000000000000000000000000000000..a7f2b264d4f37f5293ae72195b4c78fa
 +        final RegistrationInfo registrationInfo,
 +        final Conversions conversions
 +    ) {
-+        if (!RegistryEntry.Modifiable.isModifiable(entry) || !this.valueAddHooks.hasHooks(entry.apiKey())) {
++        if (!RegistryEntry.Modifiable.isModifiable(entry) || !this.valueAddEventTypes.hasHandlers(entry.apiKey())) {
 +            registry.register(key, builder.build(), registrationInfo);
 +            return;
 +        }
@@ -237,7 +237,7 @@ index 0000000000000000000000000000000000000000..a7f2b264d4f37f5293ae72195b4c78fa
 +        @Subst("namespace:key") final ResourceLocation beingAdded = key.location();
 +        @SuppressWarnings("PatternValidation") final TypedKey<T> typedKey = TypedKey.create(entry.apiKey(), Key.key(beingAdded.getNamespace(), beingAdded.getPath()));
 +        final RegistryEntryAddEventImpl<T, B> event = entry.createEntryAddEvent(typedKey, builder, conversions);
-+        LifecycleEventRunner.INSTANCE.callEvent(this.valueAddHooks.getHook(entry.apiKey()), event);
++        LifecycleEventRunner.INSTANCE.callEvent(this.valueAddEventTypes.getEventType(entry.apiKey()), event);
 +        if (oldNms != null) {
 +            ((MappedRegistry<M>) registry).clearIntrusiveHolder(oldNms);
 +        }
@@ -261,27 +261,27 @@ index 0000000000000000000000000000000000000000..a7f2b264d4f37f5293ae72195b4c78fa
 +
 +    public <M, T extends org.bukkit.Keyed, 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())) {
++        if (!RegistryEntry.Addable.isAddable(entry) || !this.freezeEventTypes.hasHandlers(entry.apiKey())) {
 +            return;
 +        }
 +        final RegistryEntry.Addable<M, T, B> writableEntry = RegistryEntry.Addable.asAddable(entry);
 +        final WritableCraftRegistry<M, T, B> writableRegistry = PaperRegistryAccess.instance().getWritableRegistry(entry.apiKey());
 +        final RegistryFreezeEventImpl<T, B> event = writableEntry.createFreezeEvent(writableRegistry, conversions);
-+        LifecycleEventRunner.INSTANCE.callEvent(this.freezeHooks.getHook(entry.apiKey()), event);
++        LifecycleEventRunner.INSTANCE.callEvent(this.freezeEventTypes.getEventType(entry.apiKey()), event);
 +    }
 +
 +    public <T, B extends RegistryBuilder<T>> RegistryEntryAddEventType<T, B> getRegistryValueAddEventType(final RegistryEventProvider<T, B> type) {
 +        if (!RegistryEntry.Modifiable.isModifiable(PaperRegistries.getEntry(type.registryKey()))) {
 +            throw new IllegalArgumentException(type.registryKey() + " does not support RegistryEntryAddEvent");
 +        }
-+        return this.valueAddHooks.getOrCreate(type, RegistryEntryAddEventTypeImpl::new);
++        return this.valueAddEventTypes.getOrCreate(type.registryKey(), RegistryEntryAddEventTypeImpl::new);
 +    }
 +
 +    public <T, B extends RegistryBuilder<T>> LifecycleEventType.Prioritizable<BootstrapContext, RegistryFreezeEvent<T, B>> getRegistryFreezeEventType(final RegistryEventProvider<T, B> type) {
 +        if (!RegistryEntry.Addable.isAddable(PaperRegistries.getEntry(type.registryKey()))) {
 +            throw new IllegalArgumentException(type.registryKey() + " does not support RegistryFreezeEvent");
 +        }
-+        return this.freezeHooks.getOrCreate(type, RegistryLifecycleEventType::new);
++        return this.freezeEventTypes.getOrCreate(type.registryKey(), RegistryLifecycleEventType::new);
 +    }
 +}
 diff --git a/src/main/java/io/papermc/paper/registry/WritableCraftRegistry.java b/src/main/java/io/papermc/paper/registry/WritableCraftRegistry.java
@@ -695,16 +695,17 @@ index 0000000000000000000000000000000000000000..cc9c8fd313f530777af80ad79e03903f
 +}
 diff --git a/src/main/java/io/papermc/paper/registry/event/RegistryEventMap.java b/src/main/java/io/papermc/paper/registry/event/RegistryEventMap.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..f5ea23173dcbe491742c3dd051c147ef397307a0
+index 0000000000000000000000000000000000000000..5e09cebc3893ab788f7b1d169c5ac48a3e45afc1
 --- /dev/null
 +++ b/src/main/java/io/papermc/paper/registry/event/RegistryEventMap.java
-@@ -0,0 +1,44 @@
+@@ -0,0 +1,46 @@
 +package io.papermc.paper.registry.event;
 +
 +import io.papermc.paper.plugin.bootstrap.BootstrapContext;
++import io.papermc.paper.plugin.lifecycle.event.LifecycleEvent;
 +import io.papermc.paper.plugin.lifecycle.event.LifecycleEventRunner;
++import io.papermc.paper.plugin.lifecycle.event.types.AbstractLifecycleEventType;
 +import io.papermc.paper.plugin.lifecycle.event.types.LifecycleEventType;
-+import io.papermc.paper.registry.RegistryBuilder;
 +import io.papermc.paper.registry.RegistryKey;
 +import java.util.HashMap;
 +import java.util.Map;
@@ -713,7 +714,7 @@ index 0000000000000000000000000000000000000000..f5ea23173dcbe491742c3dd051c147ef
 +
 +public final class RegistryEventMap {
 +
-+    private final Map<RegistryKey<?>, LifecycleEventType<BootstrapContext, ? extends RegistryEvent<?>, ?>> hooks = new HashMap<>();
++    private final Map<RegistryKey<?>, LifecycleEventType<BootstrapContext, ? extends LifecycleEvent, ?>> eventTypes = new HashMap<>();
 +    private final String name;
 +
 +    public RegistryEventMap(final String name) {
@@ -721,25 +722,26 @@ index 0000000000000000000000000000000000000000..f5ea23173dcbe491742c3dd051c147ef
 +    }
 +
 +    @SuppressWarnings("unchecked")
-+    public <T, B extends RegistryBuilder<T>, E extends RegistryEvent<T>, ET extends LifecycleEventType<BootstrapContext, E, ?>> ET getOrCreate(final RegistryEventProvider<T, B> type, final BiFunction<? super RegistryEventProvider<T, B>, ? super String, ET> eventTypeCreator) {
-+        final ET registerHook;
-+        if (this.hooks.containsKey(type.registryKey())) {
-+            registerHook = (ET) this.hooks.get(type.registryKey());
++    public <T, E extends LifecycleEvent, ET extends LifecycleEventType<BootstrapContext, E, ?>> ET getOrCreate(final RegistryKey<T> registryKey, final BiFunction<? super RegistryKey<T>, ? super String, ET> eventTypeCreator) {
++        final ET eventType;
++        if (this.eventTypes.containsKey(registryKey)) {
++            eventType = (ET) this.eventTypes.get(registryKey);
 +        } else {
-+            registerHook = eventTypeCreator.apply(type, this.name);
-+            LifecycleEventRunner.INSTANCE.addEventType(registerHook);
-+            this.hooks.put(type.registryKey(), registerHook);
++            eventType = eventTypeCreator.apply(registryKey, this.name);
++            LifecycleEventRunner.INSTANCE.addEventType(eventType);
++            this.eventTypes.put(registryKey, eventType);
 +        }
-+        return registerHook;
++        return eventType;
 +    }
 +
 +    @SuppressWarnings("unchecked")
-+    public <T, E extends RegistryEvent<T>> LifecycleEventType<BootstrapContext, E, ?> getHook(final RegistryKey<T> registryKey) {
-+        return (LifecycleEventType<BootstrapContext, E, ?>) Objects.requireNonNull(this.hooks.get(registryKey), "No hook for " + registryKey);
++    public <T, E extends LifecycleEvent> LifecycleEventType<BootstrapContext, E, ?> getEventType(final RegistryKey<T> registryKey) {
++        return (LifecycleEventType<BootstrapContext, E, ?>) Objects.requireNonNull(this.eventTypes.get(registryKey), "No hook for " + registryKey);
 +    }
 +
-+    public boolean hasHooks(final RegistryKey<?> registryKey) {
-+        return this.hooks.containsKey(registryKey);
++    public boolean hasHandlers(final RegistryKey<?> registryKey) {
++        final AbstractLifecycleEventType<?, ?, ?> type = ((AbstractLifecycleEventType<?, ?, ?>) this.eventTypes.get(registryKey));
++        return type != null && type.hasHandlers();
 +    }
 +
 +}
@@ -820,7 +822,7 @@ index 0000000000000000000000000000000000000000..14d2d9766b8dee763f220c397aba3ad4
 +import org.checkerframework.framework.qual.DefaultQualifier;
 diff --git a/src/main/java/io/papermc/paper/registry/event/type/RegistryEntryAddEventTypeImpl.java b/src/main/java/io/papermc/paper/registry/event/type/RegistryEntryAddEventTypeImpl.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..5d709ed04e1078b631f5b9c74ca35f042251e14f
+index 0000000000000000000000000000000000000000..0655386f85148cdb840d43ada97ab86bb773a765
 --- /dev/null
 +++ b/src/main/java/io/papermc/paper/registry/event/type/RegistryEntryAddEventTypeImpl.java
 @@ -0,0 +1,32 @@
@@ -830,15 +832,15 @@ index 0000000000000000000000000000000000000000..5d709ed04e1078b631f5b9c74ca35f04
 +import io.papermc.paper.plugin.lifecycle.event.handler.LifecycleEventHandler;
 +import io.papermc.paper.plugin.lifecycle.event.types.PrioritizableLifecycleEventType;
 +import io.papermc.paper.registry.RegistryBuilder;
++import io.papermc.paper.registry.RegistryKey;
 +import io.papermc.paper.registry.event.RegistryEntryAddEvent;
-+import io.papermc.paper.registry.event.RegistryEventProvider;
 +import java.util.function.Consumer;
 +import java.util.function.Predicate;
 +
 +public class RegistryEntryAddEventTypeImpl<T, B extends RegistryBuilder<T>> extends PrioritizableLifecycleEventType<BootstrapContext, RegistryEntryAddEvent<T, B>, RegistryEntryAddConfiguration<T>> implements RegistryEntryAddEventType<T, B> {
 +
-+    public RegistryEntryAddEventTypeImpl(final RegistryEventProvider<T, B> type, final String eventName) {
-+        super(type.registryKey() + " / " + eventName, BootstrapContext.class);
++    public RegistryEntryAddEventTypeImpl(final RegistryKey<T> registryKey, final String eventName) {
++        super(registryKey + " / " + eventName, BootstrapContext.class);
 +    }
 +
 +    @Override
@@ -906,22 +908,21 @@ index 0000000000000000000000000000000000000000..548f5bf979e88708e98d04dfe22ccaa3
 +}
 diff --git a/src/main/java/io/papermc/paper/registry/event/type/RegistryLifecycleEventType.java b/src/main/java/io/papermc/paper/registry/event/type/RegistryLifecycleEventType.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..dcc0f6b337840a78d38abdf2eb3f4bbd1676f58f
+index 0000000000000000000000000000000000000000..159bb82c27e8fc8f350985f03082fe218fda3568
 --- /dev/null
 +++ b/src/main/java/io/papermc/paper/registry/event/type/RegistryLifecycleEventType.java
-@@ -0,0 +1,14 @@
+@@ -0,0 +1,13 @@
 +package io.papermc.paper.registry.event.type;
 +
 +import io.papermc.paper.plugin.bootstrap.BootstrapContext;
 +import io.papermc.paper.plugin.lifecycle.event.types.PrioritizableLifecycleEventType;
-+import io.papermc.paper.registry.RegistryBuilder;
++import io.papermc.paper.registry.RegistryKey;
 +import io.papermc.paper.registry.event.RegistryEvent;
-+import io.papermc.paper.registry.event.RegistryEventProvider;
 +
-+public final class RegistryLifecycleEventType<T, B extends RegistryBuilder<T>, E extends RegistryEvent<T>> extends PrioritizableLifecycleEventType.Simple<BootstrapContext, E> {
++public final class RegistryLifecycleEventType<T, E extends RegistryEvent<T>> extends PrioritizableLifecycleEventType.Simple<BootstrapContext, E> {
 +
-+    public RegistryLifecycleEventType(final RegistryEventProvider<T, B> type, final String eventName) {
-+        super(type.registryKey() + " / " + eventName, BootstrapContext.class);
++    public RegistryLifecycleEventType(final RegistryKey<T> registryKey, final String eventName) {
++        super(registryKey + " / " + eventName, BootstrapContext.class);
 +    }
 +}
 diff --git a/src/main/java/io/papermc/paper/registry/legacy/DelayedRegistry.java b/src/main/java/io/papermc/paper/registry/legacy/DelayedRegistry.java

patches/server/1020-Add-registry-entry-and-builders.patch

@@ -37,7 +37,7 @@ index 32ade3ed8533b127e8f5c1cc8b3466249e5444a3..6ec9d9b9acf557aa2ebf39d38a14225b
  
 diff --git a/src/main/java/io/papermc/paper/registry/data/PaperEnchantmentRegistryEntry.java b/src/main/java/io/papermc/paper/registry/data/PaperEnchantmentRegistryEntry.java
 new file mode 100644
-index 0000000000000000000000000000000000000000..b9501554a0738776c265852184c7dbae3fe98c8c
+index 0000000000000000000000000000000000000000..481f5f0cfae1fada3bc3f873fb7e04c3086ea9bf
 --- /dev/null
 +++ b/src/main/java/io/papermc/paper/registry/data/PaperEnchantmentRegistryEntry.java
 @@ -0,0 +1,234 @@
@@ -96,7 +96,7 @@ index 0000000000000000000000000000000000000000..b9501554a0738776c265852184c7dbae
 +    protected HolderSet<Enchantment> exclusiveWith = HolderSet.empty(); // Paper added default to empty.
 +
 +    // Effects
-+    protected final DataComponentMap effects;
++    protected DataComponentMap effects;
 +
 +    protected final Conversions conversions;
 +

patches/server/1059-Tag-Lifecycle-Events.patch

@@ -0,0 +1,537 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Thu, 20 Jun 2024 09:40:57 -0700
+Subject: [PATCH] Tag Lifecycle Events
+
+== AT ==
+public net/minecraft/tags/TagEntry id
+public net/minecraft/tags/TagEntry tag
+public net/minecraft/tags/TagEntry required
+
+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
+index 7e84e0acd50ef04fa1ee2577f49e51c63f5ba5c3..05ceb6a0556c5e958237cd8e17525343dc3e8458 100644
+--- 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
+@@ -13,6 +13,8 @@ public final class LifecycleEventTypeProviderImpl implements LifecycleEventTypeP
+         return (LifecycleEventTypeProviderImpl) LifecycleEventTypeProvider.provider();
+     }
+ 
++    private final PaperTagEventTypeProvider provider = new PaperTagEventTypeProvider();
++
+     @Override
+     public <O extends LifecycleEventOwner, E extends LifecycleEvent> LifecycleEventType.Monitorable<O, E> monitor(final String name, final Class<? extends O> ownerType) {
+         return LifecycleEventRunner.INSTANCE.addEventType(new MonitorableLifecycleEventType<>(name, ownerType));
+@@ -22,4 +24,9 @@ public final class LifecycleEventTypeProviderImpl implements LifecycleEventTypeP
+     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.Simple<>(name, ownerType));
+     }
++
++    @Override
++    public PaperTagEventTypeProvider tagProvider() {
++        return this.provider;
++    }
+ }
+diff --git a/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/PaperTagEventTypeProvider.java b/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/PaperTagEventTypeProvider.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..1cf4a3caa8d630e95eb569eef2cd577bba1a97a9
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/plugin/lifecycle/event/types/PaperTagEventTypeProvider.java
+@@ -0,0 +1,24 @@
++package io.papermc.paper.plugin.lifecycle.event.types;
++
++import io.papermc.paper.plugin.bootstrap.BootstrapContext;
++import io.papermc.paper.plugin.lifecycle.event.registrar.ReloadableRegistrarEvent;
++import io.papermc.paper.registry.RegistryKey;
++import io.papermc.paper.tag.PaperTagListenerManager;
++import io.papermc.paper.tag.PostFlattenTagRegistrar;
++import io.papermc.paper.tag.PreFlattenTagRegistrar;
++import org.checkerframework.checker.nullness.qual.NonNull;
++import org.checkerframework.framework.qual.DefaultQualifier;
++
++@DefaultQualifier(NonNull.class)
++public class PaperTagEventTypeProvider implements TagEventTypeProvider {
++
++    @Override
++    public <T> PrioritizableLifecycleEventType.Simple<BootstrapContext, ReloadableRegistrarEvent<PreFlattenTagRegistrar<T>>> preFlatten(final RegistryKey<T> registryKey) {
++        return PaperTagListenerManager.INSTANCE.getPreFlattenType(registryKey);
++    }
++
++    @Override
++    public <T> PrioritizableLifecycleEventType.Simple<BootstrapContext, ReloadableRegistrarEvent<PostFlattenTagRegistrar<T>>> postFlatten(final RegistryKey<T> registryKey) {
++        return PaperTagListenerManager.INSTANCE.getPostFlattenType(registryKey);
++    }
++}
+diff --git a/src/main/java/io/papermc/paper/tag/PaperPostFlattenTagRegistrar.java b/src/main/java/io/papermc/paper/tag/PaperPostFlattenTagRegistrar.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..cc37618cbbad7f21d65c7753f4dd4416042d2146
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/tag/PaperPostFlattenTagRegistrar.java
+@@ -0,0 +1,118 @@
++package io.papermc.paper.tag;
++
++import com.google.common.collect.Collections2;
++import com.google.common.collect.ImmutableMap;
++import io.papermc.paper.adventure.PaperAdventure;
++import io.papermc.paper.plugin.bootstrap.BootstrapContext;
++import io.papermc.paper.plugin.lifecycle.event.registrar.PaperRegistrar;
++import io.papermc.paper.registry.RegistryKey;
++import io.papermc.paper.registry.TypedKey;
++import io.papermc.paper.registry.tag.TagKey;
++import java.util.ArrayList;
++import java.util.Collection;
++import java.util.Collections;
++import java.util.List;
++import java.util.Map;
++import java.util.NoSuchElementException;
++import java.util.Optional;
++import java.util.function.Function;
++import net.minecraft.resources.ResourceLocation;
++import org.bukkit.craftbukkit.util.CraftNamespacedKey;
++import org.checkerframework.checker.nullness.qual.NonNull;
++import org.checkerframework.checker.nullness.qual.Nullable;
++import org.checkerframework.framework.qual.DefaultQualifier;
++
++@SuppressWarnings("BoundedWildcard")
++@DefaultQualifier(NonNull.class)
++public class PaperPostFlattenTagRegistrar<M, T> implements PaperRegistrar<BootstrapContext>, PostFlattenTagRegistrar<T> {
++
++    public final Map<ResourceLocation, Collection<M>> tags;
++    private final Function<ResourceLocation, Optional<? extends M>> fromIdConverter;
++    private final Function<M, ResourceLocation> toIdConverter;
++    private final RegistryKey<T> registryKey;
++
++    public PaperPostFlattenTagRegistrar(
++        final Map<ResourceLocation, Collection<M>> tags,
++        final TagEventConfig<M, T> config
++    ) {
++        this.tags = tags;
++        this.fromIdConverter = config.fromIdConverter();
++        this.toIdConverter = config.toIdConverter();
++        this.registryKey = config.apiRegistryKey();
++    }
++
++    @Override
++    public void setCurrentContext(final @Nullable BootstrapContext owner) {
++    }
++
++    @Override
++    public RegistryKey<T> registryKey() {
++        return this.registryKey;
++    }
++
++    @Override
++    public Map<TagKey<T>, Collection<TypedKey<T>>> getAllTags() {
++        final ImmutableMap.Builder<TagKey<T>, Collection<TypedKey<T>>> tags = ImmutableMap.builderWithExpectedSize(this.tags.size());
++        for (final Map.Entry<ResourceLocation, Collection<M>> entry : this.tags.entrySet()) {
++            final TagKey<T> key = TagKey.create(this.registryKey, CraftNamespacedKey.fromMinecraft(entry.getKey()));
++            tags.put(key, this.convert(entry.getValue()));
++        }
++        return tags.build();
++    }
++
++    private Collection<TypedKey<T>> convert(final Collection<M> nms) {
++        return Collections.unmodifiableCollection(
++            Collections2.transform(nms, m -> this.convert(this.toIdConverter.apply(m)))
++        );
++    }
++
++    private TypedKey<T> convert(final ResourceLocation location) {
++        return TypedKey.create(this.registryKey, CraftNamespacedKey.fromMinecraft(location));
++    }
++
++    private M convert(final TypedKey<T> key) {
++        final Optional<? extends M> optional = this.fromIdConverter.apply(PaperAdventure.asVanilla(key.key()));
++        if (optional.isEmpty()) {
++            throw new IllegalArgumentException(key + " doesn't exist");
++        }
++        return optional.get();
++    }
++
++    @Override
++    public boolean hasTag(final TagKey<T> tagKey) {
++        return this.tags.containsKey(PaperAdventure.asVanilla(tagKey.key()));
++    }
++
++    private Collection<M> getNmsTag(final TagKey<T> tagKey, final boolean create) {
++        final ResourceLocation vanillaKey = PaperAdventure.asVanilla(tagKey.key());
++        Collection<M> tag = this.tags.get(vanillaKey);
++        if (tag == null) {
++            if (create) {
++                tag = this.tags.computeIfAbsent(vanillaKey, k -> new ArrayList<>());
++            } else {
++                throw new NoSuchElementException("Tag " + tagKey + " is not present");
++            }
++        }
++        return tag;
++    }
++
++    @Override
++    public Collection<TypedKey<T>> getTag(final TagKey<T> tagKey) {
++        return this.convert(this.getNmsTag(tagKey, false));
++    }
++
++    @Override
++    public void addToTag(final TagKey<T> tagKey, final Collection<TypedKey<T>> values) {
++        final Collection<M> nmsTag = new ArrayList<>(this.getNmsTag(tagKey, true));
++        for (final TypedKey<T> key : values) {
++            nmsTag.add(this.convert(key));
++        }
++        this.tags.put(PaperAdventure.asVanilla(tagKey.key()), nmsTag);
++    }
++
++    @Override
++    public void setTag(final TagKey<T> tagKey, final Collection<TypedKey<T>> values) {
++        final List<M> newList = List.copyOf(Collections2.transform(values, this::convert));
++        this.tags.put(PaperAdventure.asVanilla(tagKey.key()), newList);
++    }
++}
+diff --git a/src/main/java/io/papermc/paper/tag/PaperPreFlattenTagRegistrar.java b/src/main/java/io/papermc/paper/tag/PaperPreFlattenTagRegistrar.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..44111b55eaa6d1cc93e2c556b23bb5c97953caac
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/tag/PaperPreFlattenTagRegistrar.java
+@@ -0,0 +1,128 @@
++package io.papermc.paper.tag;
++
++import com.google.common.base.Preconditions;
++import com.google.common.collect.Collections2;
++import com.google.common.collect.ImmutableMap;
++import com.google.common.collect.Lists;
++import io.papermc.paper.adventure.PaperAdventure;
++import io.papermc.paper.plugin.bootstrap.BootstrapContext;
++import io.papermc.paper.plugin.lifecycle.event.registrar.PaperRegistrar;
++import io.papermc.paper.registry.RegistryKey;
++import io.papermc.paper.registry.tag.TagKey;
++import java.util.ArrayList;
++import java.util.Collection;
++import java.util.Collections;
++import java.util.HashMap;
++import java.util.List;
++import java.util.Map;
++import java.util.NoSuchElementException;
++import net.minecraft.resources.ResourceLocation;
++import net.minecraft.tags.TagLoader;
++import org.bukkit.craftbukkit.util.CraftNamespacedKey;
++import org.checkerframework.checker.nullness.qual.NonNull;
++import org.checkerframework.checker.nullness.qual.Nullable;
++import org.checkerframework.framework.qual.DefaultQualifier;
++
++@SuppressWarnings("BoundedWildcard")
++@DefaultQualifier(NonNull.class)
++public class PaperPreFlattenTagRegistrar<T> implements PaperRegistrar<BootstrapContext>, PreFlattenTagRegistrar<T> {
++
++    public final Map<ResourceLocation, List<TagLoader.EntryWithSource>> tags;
++    private final RegistryKey<T> registryKey;
++
++    private @Nullable BootstrapContext owner;
++
++    public PaperPreFlattenTagRegistrar(
++        final Map<ResourceLocation, List<TagLoader.EntryWithSource>> tags,
++        final TagEventConfig<?, T> config
++    ) {
++        this.tags = new HashMap<>(tags);
++        this.registryKey = config.apiRegistryKey();
++    }
++
++    @Override
++    public void setCurrentContext(final @Nullable BootstrapContext owner) {
++        this.owner = owner;
++    }
++
++    @Override
++    public RegistryKey<T> registryKey() {
++        return this.registryKey;
++    }
++
++    @Override
++    public Map<TagKey<T>, Collection<TagEntry<T>>> getAllTags() {
++        final ImmutableMap.Builder<TagKey<T>, Collection<io.papermc.paper.tag.TagEntry<T>>> builder = ImmutableMap.builderWithExpectedSize(this.tags.size());
++        for (final Map.Entry<ResourceLocation, List<TagLoader.EntryWithSource>> entry : this.tags.entrySet()) {
++            final TagKey<T> key = TagKey.create(this.registryKey, CraftNamespacedKey.fromMinecraft(entry.getKey()));
++            builder.put(key, convert(entry.getValue()));
++        }
++        return builder.build();
++    }
++
++    private static <T> List<io.papermc.paper.tag.TagEntry<T>> convert(final List<TagLoader.EntryWithSource> nmsEntries) {
++        return Collections.unmodifiableList(Lists.transform(nmsEntries, PaperPreFlattenTagRegistrar::convert));
++    }
++
++    private static <T> io.papermc.paper.tag.TagEntry<T> convert(final TagLoader.EntryWithSource nmsEntry) {
++        return new TagEntryImpl<>(CraftNamespacedKey.fromMinecraft(nmsEntry.entry().id), nmsEntry.entry().tag, nmsEntry.entry().required);
++    }
++
++    private TagLoader.EntryWithSource convert(final TagEntry<T> entry) {
++        Preconditions.checkState(this.owner != null, "Owner is not set");
++        final ResourceLocation vanilla = PaperAdventure.asVanilla(entry.key());
++        final net.minecraft.tags.TagEntry nmsEntry;
++        if (entry.isTag()) {
++            if (entry.isRequired()) {
++                nmsEntry = net.minecraft.tags.TagEntry.tag(vanilla);
++            } else {
++                nmsEntry = net.minecraft.tags.TagEntry.optionalTag(vanilla);
++            }
++        } else {
++            if (entry.isRequired()) {
++                nmsEntry = net.minecraft.tags.TagEntry.element(vanilla);
++            } else {
++                nmsEntry = net.minecraft.tags.TagEntry.optionalElement(vanilla);
++            }
++        }
++        return new TagLoader.EntryWithSource(nmsEntry, this.owner.getPluginMeta().getDisplayName());
++    }
++
++    @Override
++    public boolean hasTag(final TagKey<T> tagKey) {
++        return this.tags.containsKey(PaperAdventure.asVanilla(tagKey.key()));
++    }
++
++    private List<TagLoader.EntryWithSource> getNmsTag(final TagKey<T> tagKey, boolean create) {
++        final ResourceLocation vanillaKey = PaperAdventure.asVanilla(tagKey.key());
++        List<TagLoader.EntryWithSource> tag = this.tags.get(vanillaKey);
++        if (tag == null) {
++            if (create) {
++                tag = this.tags.computeIfAbsent(vanillaKey, k -> new ArrayList<>());
++            } else {
++                throw new NoSuchElementException("Tag " + tagKey + " is not present");
++            }
++        }
++        return tag;
++    }
++
++    @Override
++    public List<TagEntry<T>> getTag(final TagKey<T> tagKey) {
++        return convert(this.getNmsTag(tagKey, false));
++    }
++
++    @Override
++    public void addToTag(final TagKey<T> tagKey, final Collection<TagEntry<T>> entries) {
++        final List<TagLoader.EntryWithSource> nmsTag = new ArrayList<>(this.getNmsTag(tagKey, true));
++        for (final TagEntry<T> tagEntry : entries) {
++            nmsTag.add(this.convert(tagEntry));
++        }
++        this.tags.put(PaperAdventure.asVanilla(tagKey.key()), nmsTag);
++    }
++
++    @Override
++    public void setTag(final TagKey<T> tagKey, final Collection<TagEntry<T>> entries) {
++        final List<TagLoader.EntryWithSource> newList = List.copyOf(Collections2.transform(entries, this::convert));
++        this.tags.put(PaperAdventure.asVanilla(tagKey.key()), newList);
++    }
++}
+diff --git a/src/main/java/io/papermc/paper/tag/PaperTagListenerManager.java b/src/main/java/io/papermc/paper/tag/PaperTagListenerManager.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..f3e4019f9d55d3cce34248a806bf0ccb37c8e7b1
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/tag/PaperTagListenerManager.java
+@@ -0,0 +1,105 @@
++package io.papermc.paper.tag;
++
++import io.papermc.paper.plugin.bootstrap.BootstrapContext;
++import io.papermc.paper.plugin.lifecycle.event.LifecycleEventRunner;
++import io.papermc.paper.plugin.lifecycle.event.registrar.ReloadableRegistrarEvent;
++import io.papermc.paper.plugin.lifecycle.event.types.AbstractLifecycleEventType;
++import io.papermc.paper.plugin.lifecycle.event.types.PrioritizableLifecycleEventType;
++import io.papermc.paper.registry.PaperRegistries;
++import io.papermc.paper.registry.RegistryKey;
++import io.papermc.paper.registry.event.RegistryEventMap;
++import java.util.Collection;
++import java.util.List;
++import java.util.Map;
++import net.minecraft.core.Holder;
++import net.minecraft.core.Registry;
++import net.minecraft.resources.ResourceLocation;
++import net.minecraft.tags.TagLoader;
++import org.checkerframework.checker.nullness.qual.NonNull;
++import org.checkerframework.checker.nullness.qual.Nullable;
++import org.checkerframework.framework.qual.DefaultQualifier;
++
++@DefaultQualifier(NonNull.class)
++public class PaperTagListenerManager {
++
++    public static final String PRE_FLATTEN_EVENT_NAME = "pre-flatten";
++    public static final String POST_FLATTEN_EVENT_NAME = "post-flatten";
++
++    public static final PaperTagListenerManager INSTANCE = new PaperTagListenerManager();
++
++    public final RegistryEventMap preFlatten = new RegistryEventMap(PRE_FLATTEN_EVENT_NAME);
++    public final RegistryEventMap postFlatten = new RegistryEventMap(POST_FLATTEN_EVENT_NAME);
++
++    private PaperTagListenerManager() {
++    }
++
++    public <A> Map<ResourceLocation, List<TagLoader.EntryWithSource>> firePreFlattenEvent(
++        final Map<ResourceLocation, List<TagLoader.EntryWithSource>> initial,
++        final @Nullable TagEventConfig<?, A> config
++    ) {
++        if (config == null || config.preFlatten() == null || !config.preFlatten().hasHandlers()) {
++            return initial;
++        }
++        final PaperPreFlattenTagRegistrar<A> registrar = new PaperPreFlattenTagRegistrar<>(initial, config);
++        LifecycleEventRunner.INSTANCE.callReloadableRegistrarEvent(
++            config.preFlatten(),
++            registrar,
++            BootstrapContext.class,
++            config.cause()
++        );
++        return Map.copyOf(registrar.tags);
++    }
++
++    public <M, A> Map<ResourceLocation, Collection<M>> firePostFlattenEvent(
++        final Map<ResourceLocation, Collection<M>> initial,
++        final @Nullable TagEventConfig<M, A> config
++    ) {
++        if (config == null || config.postFlatten() == null || !config.postFlatten().hasHandlers()) {
++            return initial;
++        }
++        final PaperPostFlattenTagRegistrar<M, A> registrar = new PaperPostFlattenTagRegistrar<>(initial, config);
++        LifecycleEventRunner.INSTANCE.callReloadableRegistrarEvent(
++            config.postFlatten(),
++            registrar,
++            BootstrapContext.class,
++            config.cause()
++        );
++        return Map.copyOf(registrar.tags);
++    }
++
++    public <M, B> @Nullable TagEventConfig<Holder<M>, B> createEventConfig(final Registry<M> registry, final ReloadableRegistrarEvent.Cause cause) {
++        if (PaperRegistries.getEntry(registry.key()) == null) {
++            // TODO probably should be able to modify every registry
++            return null;
++        }
++        final RegistryKey<B> registryKey = PaperRegistries.registryFromNms(registry.key());
++        @Nullable AbstractLifecycleEventType<BootstrapContext, ReloadableRegistrarEvent<PreFlattenTagRegistrar<B>>, ?> preFlatten = null;
++        if (this.preFlatten.hasHandlers(registryKey)) {
++            preFlatten = (AbstractLifecycleEventType<BootstrapContext, ReloadableRegistrarEvent<PreFlattenTagRegistrar<B>>, ?>) this.preFlatten.<B, ReloadableRegistrarEvent<PreFlattenTagRegistrar<B>>>getEventType(registryKey);
++        }
++        @Nullable AbstractLifecycleEventType<BootstrapContext, ReloadableRegistrarEvent<PostFlattenTagRegistrar<B>>, ?> postFlatten = null;
++        if (this.postFlatten.hasHandlers(registryKey)) {
++            postFlatten = (AbstractLifecycleEventType<BootstrapContext, ReloadableRegistrarEvent<PostFlattenTagRegistrar<B>>, ?>) this.postFlatten.<B, ReloadableRegistrarEvent<PostFlattenTagRegistrar<B>>>getEventType(registryKey);
++        }
++        return new TagEventConfig<>(
++            preFlatten,
++            postFlatten,
++            cause,
++            registry::getHolder,
++            h -> ((Holder.Reference<M>) h).key().location(),
++            PaperRegistries.registryFromNms(registry.key())
++        );
++    }
++
++    public <T> PrioritizableLifecycleEventType.Simple<BootstrapContext, ReloadableRegistrarEvent<PreFlattenTagRegistrar<T>>> getPreFlattenType(final RegistryKey<T> registryKey) {
++        return this.preFlatten.getOrCreate(registryKey, (ignored, name) -> {
++            return new PrioritizableLifecycleEventType.Simple<>(name, BootstrapContext.class);
++        });
++    }
++
++    public <T> PrioritizableLifecycleEventType.Simple<BootstrapContext, ReloadableRegistrarEvent<PostFlattenTagRegistrar<T>>> getPostFlattenType(final RegistryKey<T> registryKey) {
++        return this.postFlatten.getOrCreate(registryKey, (ignored, name) -> {
++            return new PrioritizableLifecycleEventType.Simple<>(name, BootstrapContext.class);
++        });
++    }
++}
+diff --git a/src/main/java/io/papermc/paper/tag/TagEventConfig.java b/src/main/java/io/papermc/paper/tag/TagEventConfig.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..d6d4bfc6f45d646afeace422a038c670e10aaf80
+--- /dev/null
++++ b/src/main/java/io/papermc/paper/tag/TagEventConfig.java
+@@ -0,0 +1,23 @@
++package io.papermc.paper.tag;
++
++import io.papermc.paper.plugin.bootstrap.BootstrapContext;
++import io.papermc.paper.plugin.lifecycle.event.registrar.ReloadableRegistrarEvent;
++import io.papermc.paper.plugin.lifecycle.event.types.AbstractLifecycleEventType;
++import io.papermc.paper.registry.RegistryKey;
++import java.util.Optional;
++import java.util.function.Function;
++import net.minecraft.resources.ResourceLocation;
++import org.checkerframework.checker.nullness.qual.NonNull;
++import org.checkerframework.checker.nullness.qual.Nullable;
++import org.checkerframework.framework.qual.DefaultQualifier;
++
++@DefaultQualifier(NonNull.class)
++public record TagEventConfig<M, A>(
++    @Nullable AbstractLifecycleEventType<BootstrapContext, ? extends ReloadableRegistrarEvent<PreFlattenTagRegistrar<A>>, ?> preFlatten,
++    @Nullable AbstractLifecycleEventType<BootstrapContext, ? extends ReloadableRegistrarEvent<PostFlattenTagRegistrar<A>>, ?> postFlatten,
++    ReloadableRegistrarEvent.Cause cause,
++    Function<ResourceLocation, Optional<? extends M>> fromIdConverter,
++    Function<M, ResourceLocation> toIdConverter,
++    RegistryKey<A> apiRegistryKey
++) {
++}
+diff --git a/src/main/java/net/minecraft/server/ServerFunctionLibrary.java b/src/main/java/net/minecraft/server/ServerFunctionLibrary.java
+index 8ae2ca2435d84fee930d2931e45ad440245cbe0f..9fff5ca1e9707e4e6be5ecb92be936332d24bb96 100644
+--- a/src/main/java/net/minecraft/server/ServerFunctionLibrary.java
++++ b/src/main/java/net/minecraft/server/ServerFunctionLibrary.java
+@@ -118,7 +118,7 @@ public class ServerFunctionLibrary implements PreparableReloadListener {
+                             return null;
+                         }).join());
+                     this.functions = builder.build();
+-                    this.tags = this.tagsLoader.build((Map<ResourceLocation, List<TagLoader.EntryWithSource>>)intermediate.getFirst());
++                    this.tags = this.tagsLoader.build((Map<ResourceLocation, List<TagLoader.EntryWithSource>>)intermediate.getFirst(), null); // Paper - command function tags are not implemented yet
+                 },
+                 applyExecutor
+             );
+diff --git a/src/main/java/net/minecraft/tags/TagLoader.java b/src/main/java/net/minecraft/tags/TagLoader.java
+index b47afb0ce8d9517ac7ee9c651c160f99d70f8a98..0bde4f7ae7d1897c630513261d1d5fb75a762634 100644
+--- a/src/main/java/net/minecraft/tags/TagLoader.java
++++ b/src/main/java/net/minecraft/tags/TagLoader.java
+@@ -79,7 +79,10 @@ public class TagLoader<T> {
+         return list.isEmpty() ? Either.right(builder.build()) : Either.left(list);
+     }
+ 
+-    public Map<ResourceLocation, Collection<T>> build(Map<ResourceLocation, List<TagLoader.EntryWithSource>> tags) {
++    // Paper start - fire tag registrar events
++    public Map<ResourceLocation, Collection<T>> build(Map<ResourceLocation, List<TagLoader.EntryWithSource>> tags, @Nullable io.papermc.paper.tag.TagEventConfig<T, ?> eventConfig) {
++        tags = io.papermc.paper.tag.PaperTagListenerManager.INSTANCE.firePreFlattenEvent(tags, eventConfig);
++        // Paper end - fire tag registrar events
+         final Map<ResourceLocation, Collection<T>> map = Maps.newHashMap();
+         TagEntry.Lookup<T> lookup = new TagEntry.Lookup<T>() {
+             @Nullable
+@@ -107,11 +110,13 @@ public class TagLoader<T> {
+                     )
+                     .ifRight(resolvedEntries -> map.put(id, (Collection<T>)resolvedEntries))
+         );
+-        return map;
++        return io.papermc.paper.tag.PaperTagListenerManager.INSTANCE.firePostFlattenEvent(map, eventConfig); // Paper - fire tag registrar events
+     }
+ 
+-    public Map<ResourceLocation, Collection<T>> loadAndBuild(ResourceManager manager) {
+-        return this.build(this.load(manager));
++    // Paper start - fire tag registrar events
++    public Map<ResourceLocation, Collection<T>> loadAndBuild(ResourceManager manager, @Nullable io.papermc.paper.tag.TagEventConfig<T, ?> eventConfig) {
++        return this.build(this.load(manager), eventConfig);
++        // Paper end - fire tag registrar events
+     }
+ 
+     public static record EntryWithSource(TagEntry entry, String source) {
+diff --git a/src/main/java/net/minecraft/tags/TagManager.java b/src/main/java/net/minecraft/tags/TagManager.java
+index 7116362d798d7c28a4880c873a60507afa4673e6..2188274de5d1fe1aa5419be6247da6a3a2414a3b 100644
+--- a/src/main/java/net/minecraft/tags/TagManager.java
++++ b/src/main/java/net/minecraft/tags/TagManager.java
+@@ -39,7 +39,7 @@ public class TagManager implements PreparableReloadListener {
+     ) {
+         List<? extends CompletableFuture<? extends TagManager.LoadResult<?>>> list = this.registryAccess
+             .registries()
+-            .map(registry -> this.createLoader(manager, prepareExecutor, (RegistryAccess.RegistryEntry<?>)registry))
++            .map(registry -> this.createLoader(manager, prepareExecutor, (RegistryAccess.RegistryEntry<?>)registry, applyExecutor instanceof net.minecraft.server.MinecraftServer ? io.papermc.paper.plugin.lifecycle.event.registrar.ReloadableRegistrarEvent.Cause.INITIAL : io.papermc.paper.plugin.lifecycle.event.registrar.ReloadableRegistrarEvent.Cause.RELOAD)) // Paper - add registrar event cause
+             .toList();
+         return CompletableFuture.allOf(list.toArray(CompletableFuture[]::new))
+             .thenCompose(synchronizer::wait)
+@@ -48,11 +48,15 @@ public class TagManager implements PreparableReloadListener {
+ 
+     private <T> CompletableFuture<TagManager.LoadResult<T>> createLoader(
+         ResourceManager resourceManager, Executor prepareExecutor, RegistryAccess.RegistryEntry<T> requirement
++        , io.papermc.paper.plugin.lifecycle.event.registrar.ReloadableRegistrarEvent.Cause cause // Paper - add registrar event cause
+     ) {
+         ResourceKey<? extends Registry<T>> resourceKey = requirement.key();
+         Registry<T> registry = requirement.value();
+         TagLoader<Holder<T>> tagLoader = new TagLoader<>(registry::getHolder, Registries.tagsDirPath(resourceKey));
+-        return CompletableFuture.supplyAsync(() -> new TagManager.LoadResult<>(resourceKey, tagLoader.loadAndBuild(resourceManager)), prepareExecutor);
++        // Paper start - fire tag registrar events
++        final io.papermc.paper.tag.TagEventConfig<Holder<T>, ?> config = io.papermc.paper.tag.PaperTagListenerManager.INSTANCE.createEventConfig(registry, cause);
++        return CompletableFuture.supplyAsync(() -> new TagManager.LoadResult<>(resourceKey, tagLoader.loadAndBuild(resourceManager, config)), prepareExecutor);
++        // Paper end - fire tag registrar events
+     }
+ 
+     public static record LoadResult<T>(ResourceKey<? extends Registry<T>> key, Map<ResourceLocation, Collection<Holder<T>>> tags) {