refactor registry entry to detach 'delayed' from other meta

Also fixes an issue with direct holders

paper-server/src/main/java/io/papermc/paper/registry/PaperRegistries.java

@@ -104,7 +104,7 @@ public final class PaperRegistries {
             start(Registries.TRIM_PATTERN, RegistryKey.TRIM_PATTERN).craft(TrimPattern.class, CraftTrimPattern::new).build().delayed(),
             start(Registries.DAMAGE_TYPE, RegistryKey.DAMAGE_TYPE).craft(DamageType.class, CraftDamageType::new).build().delayed(),
             start(Registries.WOLF_VARIANT, RegistryKey.WOLF_VARIANT).craft(Wolf.Variant.class, CraftWolf.CraftVariant::new).build().delayed(),
-            start(Registries.ENCHANTMENT, RegistryKey.ENCHANTMENT).craft(Enchantment.class, CraftEnchantment::new).writable(PaperEnchantmentRegistryEntry.PaperBuilder::new).withSerializationUpdater(FieldRename.ENCHANTMENT_RENAME).delayed(),
+            start(Registries.ENCHANTMENT, RegistryKey.ENCHANTMENT).craft(Enchantment.class, CraftEnchantment::new).serializationUpdater(FieldRename.ENCHANTMENT_RENAME).writable(PaperEnchantmentRegistryEntry.PaperBuilder::new).delayed(),
             start(Registries.JUKEBOX_SONG, RegistryKey.JUKEBOX_SONG).craft(JukeboxSong.class, CraftJukeboxSong::new).build().delayed(),
             start(Registries.BANNER_PATTERN, RegistryKey.BANNER_PATTERN).craft(PatternType.class, CraftPatternType::new).build().delayed(),
             start(Registries.PAINTING_VARIANT, RegistryKey.PAINTING_VARIANT).craft(Art.class, CraftArt::new).writable(PaperPaintingVariantRegistryEntry.PaperBuilder::new).delayed(),

paper-server/src/main/java/io/papermc/paper/registry/PaperRegistryAccess.java

@@ -1,7 +1,7 @@
 package io.papermc.paper.registry;
 
-import io.papermc.paper.registry.entry.ApiRegistryEntry;
 import io.papermc.paper.registry.entry.RegistryEntry;
+import io.papermc.paper.registry.entry.RegistryEntryMeta;
 import io.papermc.paper.registry.legacy.DelayedRegistry;
 import io.papermc.paper.registry.legacy.DelayedRegistryEntry;
 import io.papermc.paper.registry.legacy.LegacyRegistryIdentifiers;
@@ -31,7 +31,10 @@ public static PaperRegistryAccess instance() {
 
     @VisibleForTesting
     public Set<RegistryKey<?>> getLoadedServerBackedRegistries() {
-        return this.registries.keySet().stream().filter(registryHolder -> !(PaperRegistries.getEntry(registryHolder) instanceof ApiRegistryEntry)).collect(Collectors.toUnmodifiableSet());
+        return this.registries.keySet().stream().filter(registryHolder -> {
+            final RegistryEntry<?, ?> entry = PaperRegistries.getEntry(registryHolder);
+            return entry != null && !(entry.meta() instanceof RegistryEntryMeta.ApiOnly<?,?>);
+        }).collect(Collectors.toUnmodifiableSet());
     }
 
     @SuppressWarnings("unchecked")

paper-server/src/main/java/io/papermc/paper/registry/PaperRegistryBuilder.java

@@ -12,14 +12,8 @@ interface Filler<M, T, B extends PaperRegistryBuilder<M, T>> {
 
         B fill(Conversions conversions, @Nullable M nms);
 
-        default Factory<M, T, B> asFactory() {
-            return (lookup) -> this.fill(lookup, null);
+        default B create(final Conversions conversions) {
+            return this.fill(conversions, null);
         }
     }
-
-    @FunctionalInterface
-    interface Factory<M, T, B extends PaperRegistryBuilder<M, T>> {
-
-        B create(Conversions conversions);
-    }
 }

paper-server/src/main/java/io/papermc/paper/registry/PaperRegistryListenerManager.java

@@ -9,7 +9,7 @@
 import io.papermc.paper.plugin.lifecycle.event.types.LifecycleEventType;
 import io.papermc.paper.registry.data.util.Conversions;
 import io.papermc.paper.registry.entry.RegistryEntry;
-import io.papermc.paper.registry.entry.RegistryEntryInfo;
+import io.papermc.paper.registry.entry.RegistryEntryMeta;
 import io.papermc.paper.registry.event.RegistryEntryAddEventImpl;
 import io.papermc.paper.registry.event.RegistryEventMap;
 import io.papermc.paper.registry.event.RegistryEventProvider;
@@ -28,6 +28,7 @@
 import net.minecraft.core.registries.BuiltInRegistries;
 import net.minecraft.resources.ResourceKey;
 import net.minecraft.resources.ResourceLocation;
+import org.bukkit.Keyed;
 import org.intellij.lang.annotations.Subst;
 import org.jspecify.annotations.Nullable;
 
@@ -86,8 +87,7 @@ public <M> void registerWithListeners(
         this.registerWithListeners(registry, key, nms, registrationInfo, WritableRegistry::register, conversions);
     }
 
-    // TODO remove Keyed
-    public <M, T extends org.bukkit.Keyed, B extends PaperRegistryBuilder<M, T>, R> R registerWithListeners(
+    public <M, T extends Keyed, B extends PaperRegistryBuilder<M, T>, R> R registerWithListeners( // TODO remove Keyed
         final Registry<M> registry,
         final ResourceKey<M> key,
         final M nms,
@@ -96,34 +96,33 @@ public <M, T extends org.bukkit.Keyed, B extends PaperRegistryBuilder<M, T>, R>
         final Conversions conversions
     ) {
         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 RegistryEntryInfo<M, T> entry = PaperRegistries.getEntry(registry.key());
-        if (!RegistryEntry.Modifiable.isModifiable(entry) || !this.valueAddEventTypes.hasHandlers(entry.apiKey())) {
+        final RegistryEntry<M, T> entry = PaperRegistries.getEntry(registry.key());
+        if (entry == null || !entry.meta().modificationApiSupport().canModify() || !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);
-        @SuppressWarnings("PatternValidation") final TypedKey<T> typedKey = TypedKey.create(entry.apiKey(), Key.key(key.location().getNamespace(), key.location().getPath()));
-        final B builder = modifiableEntry.fillBuilder(conversions, nms);
+        final RegistryEntryMeta.Buildable<M, T, B> modifiableEntry = (RegistryEntryMeta.Buildable<M, T, B>) entry.meta();
+        final B builder = modifiableEntry.builderFiller().fill(conversions, nms);
         return this.registerWithListeners(registry, modifiableEntry, key, nms, builder, registrationInfo, registerMethod, conversions);
     }
 
-    <M, T extends org.bukkit.Keyed, B extends PaperRegistryBuilder<M, T>> void registerWithListeners( // TODO remove Keyed
+    <M, T extends Keyed, B extends PaperRegistryBuilder<M, T>> void registerWithListeners( // TODO remove Keyed
         final WritableRegistry<M> registry,
-        final RegistryEntryInfo<M, T> entry,
+        final RegistryEntryMeta.Buildable<M, T, B> entry,
         final ResourceKey<M> key,
         final B builder,
         final RegistrationInfo registrationInfo,
         final Conversions conversions
     ) {
-        if (!RegistryEntry.Modifiable.isModifiable(entry) || !this.valueAddEventTypes.hasHandlers(entry.apiKey())) {
+        if (!entry.modificationApiSupport().canModify() || !this.valueAddEventTypes.hasHandlers(entry.apiKey())) {
             registry.register(key, builder.build(), registrationInfo);
             return;
         }
-        this.registerWithListeners(registry, RegistryEntry.Modifiable.asModifiable(entry), key, null, builder, registrationInfo, WritableRegistry::register, conversions);
+        this.registerWithListeners(registry, entry, key, null, builder, registrationInfo, WritableRegistry::register, conversions);
     }
 
-    public <M, T extends org.bukkit.Keyed, B extends PaperRegistryBuilder<M, T>, R> R registerWithListeners( // TODO remove Keyed
+    public <M, T extends Keyed, B extends PaperRegistryBuilder<M, T>, R> R registerWithListeners( // TODO remove Keyed
         final Registry<M> registry,
-        final RegistryEntry.Modifiable<M, T, B> entry,
+        final RegistryEntryMeta.Buildable<M, T, B> entry,
         final ResourceKey<M> key,
         final @Nullable M oldNms,
         final B builder,
@@ -156,26 +155,28 @@ public interface RegisterMethod<M, R> {
         R register(WritableRegistry<M> writableRegistry, ResourceKey<M> key, M value, RegistrationInfo registrationInfo);
     }
 
-    public <M, T extends org.bukkit.Keyed, B extends PaperRegistryBuilder<M, T>> void runFreezeListeners(final ResourceKey<? extends Registry<M>> resourceKey, final Conversions conversions) {
-        final RegistryEntryInfo<M, T> entry = PaperRegistries.getEntry(resourceKey);
-        if (!RegistryEntry.Addable.isAddable(entry) || !this.freezeEventTypes.hasHandlers(entry.apiKey())) {
+    public <M, T extends Keyed, B extends PaperRegistryBuilder<M, T>> void runFreezeListeners(final ResourceKey<? extends Registry<M>> resourceKey, final Conversions conversions) {
+        final RegistryEntry<M, T> entry = PaperRegistries.getEntry(resourceKey);
+        if (entry == null || !entry.meta().modificationApiSupport().canAdd() || !this.freezeEventTypes.hasHandlers(entry.apiKey())) {
             return;
         }
-        final RegistryEntry.Addable<M, T, B> writableEntry = RegistryEntry.Addable.asAddable(entry);
+        final RegistryEntryMeta.Buildable<M, T, B> writableEntry = (RegistryEntryMeta.Buildable<M, T, B>) entry.meta();
         final WritableCraftRegistry<M, T, B> writableRegistry = PaperRegistryAccess.instance().getWritableRegistry(entry.apiKey());
         final RegistryFreezeEventImpl<T, B> event = writableEntry.createFreezeEvent(writableRegistry, conversions);
         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()))) {
+        final RegistryEntry<?, ?> entry = PaperRegistries.getEntry(type.registryKey());
+        if (entry == null || !entry.meta().modificationApiSupport().canModify()) {
             throw new IllegalArgumentException(type.registryKey() + " does not support RegistryEntryAddEvent");
         }
         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()))) {
+        final RegistryEntry<?, ?> entry = PaperRegistries.getEntry(type.registryKey());
+        if (entry == null || !entry.meta().modificationApiSupport().canAdd()) {
             throw new IllegalArgumentException(type.registryKey() + " does not support RegistryFreezeEvent");
         }
         return this.freezeEventTypes.getOrCreate(type.registryKey(), RegistryLifecycleEventType::new);

paper-server/src/main/java/io/papermc/paper/registry/WritableCraftRegistry.java

@@ -3,6 +3,7 @@
 import com.mojang.serialization.Lifecycle;
 import io.papermc.paper.registry.data.util.Conversions;
 import io.papermc.paper.registry.entry.RegistryEntry;
+import io.papermc.paper.registry.entry.RegistryEntryMeta;
 import io.papermc.paper.registry.entry.RegistryTypeMapper;
 import io.papermc.paper.registry.event.WritableRegistry;
 import java.util.Optional;
@@ -20,22 +21,16 @@ public class WritableCraftRegistry<M, T extends Keyed, B extends PaperRegistryBu
 
     private static final RegistrationInfo FROM_PLUGIN = new RegistrationInfo(Optional.empty(), Lifecycle.experimental());
 
-    private final RegistryEntry.BuilderHolder<M, T, B> entry;
+    private final RegistryEntryMeta.Buildable<M, T, B> meta;
     private final MappedRegistry<M> registry;
-    private final PaperRegistryBuilder.Factory<M, T, ? extends B> builderFactory;
 
     public WritableCraftRegistry(
-        final RegistryEntry.BuilderHolder<M, T, B> entry,
-        final Class<?> classToPreload,
         final MappedRegistry<M> registry,
-        final BiFunction<NamespacedKey, ApiVersion, NamespacedKey> serializationUpdater,
-        final PaperRegistryBuilder.Factory<M, T, ? extends B> builderFactory,
-        final RegistryTypeMapper<M, T> minecraftToBukkit
+        final RegistryEntryMeta.Buildable<M, T, B> meta
     ) {
-        super(classToPreload, registry, minecraftToBukkit, serializationUpdater);
-        this.entry = entry;
+        super(meta, registry);
         this.registry = registry;
-        this.builderFactory = builderFactory;
+        this.meta = meta;
     }
 
     public void register(final TypedKey<T> key, final Consumer<? super B> value, final Conversions conversions) {
@@ -45,7 +40,7 @@ public void register(final TypedKey<T> key, final Consumer<? super B> value, fin
         value.accept(builder);
         PaperRegistryListenerManager.INSTANCE.registerWithListeners(
             this.registry,
-            RegistryEntry.Modifiable.asModifiable(this.entry),
+            this.meta,
             resourceKey,
             builder,
             FROM_PLUGIN,
@@ -58,7 +53,7 @@ public WritableRegistry<T, B> createApiWritableRegistry(final Conversions conver
     }
 
     protected B newBuilder(final Conversions conversions) {
-        return this.builderFactory.create(conversions);
+        return this.meta.builderFiller().create(conversions);
     }
 
     public class ApiWritableRegistry implements WritableRegistry<T, B> {