diff --git a/patches/unapplied/server/Add-EntityDyeEvent-and-CollarColorable-interface.patch b/patches/server/Add-EntityDyeEvent-and-CollarColorable-interface.patch
similarity index 86%
rename from patches/unapplied/server/Add-EntityDyeEvent-and-CollarColorable-interface.patch
rename to patches/server/Add-EntityDyeEvent-and-CollarColorable-interface.patch
index 304ef2a3e9..1a4c7141d4 100644
--- a/patches/unapplied/server/Add-EntityDyeEvent-and-CollarColorable-interface.patch
+++ b/patches/server/Add-EntityDyeEvent-and-CollarColorable-interface.patch
@@ -8,8 +8,8 @@ diff --git a/src/main/java/net/minecraft/world/entity/animal/Cat.java b/src/main
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/animal/Cat.java
 +++ b/src/main/java/net/minecraft/world/entity/animal/Cat.java
-@@ -0,0 +0,0 @@ public class Cat extends TamableAnimal implements VariantHolder<CatVariant> {
-                     DyeColor enumcolor = ((DyeItem) item).getDyeColor();
+@@ -0,0 +0,0 @@ public class Cat extends TamableAnimal implements VariantHolder<Holder<CatVarian
+                     DyeColor enumcolor = itemdye.getDyeColor();
  
                      if (enumcolor != this.getCollarColor()) {
 +                        // Paper start - Add EntityDyeEvent and CollarColorable interface
@@ -19,14 +19,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                        }
 +                        enumcolor = DyeColor.byId(event.getColor().getWoolData());
 +                        // Paper end - Add EntityDyeEvent and CollarColorable interface
-                         this.setCollarColor(enumcolor);
-                         if (!player.getAbilities().instabuild) {
-                             itemstack.shrink(1);
+                         if (!this.level().isClientSide()) {
+                             this.setCollarColor(enumcolor);
+                             itemstack.consume(1, player);
 diff --git a/src/main/java/net/minecraft/world/entity/animal/Wolf.java b/src/main/java/net/minecraft/world/entity/animal/Wolf.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/animal/Wolf.java
 +++ b/src/main/java/net/minecraft/world/entity/animal/Wolf.java
-@@ -0,0 +0,0 @@ public class Wolf extends TamableAnimal implements NeutralMob {
+@@ -0,0 +0,0 @@ public class Wolf extends TamableAnimal implements NeutralMob, VariantHolder<Hol
                          DyeColor enumcolor = itemdye.getDyeColor();
  
                          if (enumcolor != this.getCollarColor()) {
@@ -39,5 +39,5 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                            // Paper end - Add EntityDyeEvent and CollarColorable interface
 +
                              this.setCollarColor(enumcolor);
-                             if (!player.getAbilities().instabuild) {
-                                 itemstack.shrink(1);
+                             itemstack.consume(1, player);
+                             return InteractionResult.SUCCESS;
diff --git a/patches/unapplied/server/Add-TameableDeathMessageEvent.patch b/patches/server/Add-TameableDeathMessageEvent.patch
similarity index 100%
rename from patches/unapplied/server/Add-TameableDeathMessageEvent.patch
rename to patches/server/Add-TameableDeathMessageEvent.patch
diff --git a/patches/unapplied/server/Allow-changing-the-EnderDragon-podium.patch b/patches/server/Allow-changing-the-EnderDragon-podium.patch
similarity index 100%
rename from patches/unapplied/server/Allow-changing-the-EnderDragon-podium.patch
rename to patches/server/Allow-changing-the-EnderDragon-podium.patch
diff --git a/patches/unapplied/server/Buffer-OOB-setBlock-calls.patch b/patches/server/Buffer-OOB-setBlock-calls.patch
similarity index 67%
rename from patches/unapplied/server/Buffer-OOB-setBlock-calls.patch
rename to patches/server/Buffer-OOB-setBlock-calls.patch
index b97fc24bea..2720580803 100644
--- a/patches/unapplied/server/Buffer-OOB-setBlock-calls.patch
+++ b/patches/server/Buffer-OOB-setBlock-calls.patch
@@ -28,13 +28,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
              return true;
          } else {
+-            Util.logAndPauseIfInIde("Detected setBlock in a far chunk [" + i + ", " + j + "], pos: " + String.valueOf(pos) + ", status: " + String.valueOf(this.generatingStatus) + (this.currentlyGenerating == null ? "" : ", currently generating: " + (String) this.currentlyGenerating.get()));
 +            // Paper start - Buffer OOB setBlock calls
 +            if (!hasSetFarWarned) {
-             Util.logAndPauseIfInIde("Detected setBlock in a far chunk [" + i + ", " + j + "], pos: " + pos + ", status: " + this.generatingStatus + (this.currentlyGenerating == null ? "" : ", currently generating: " + (String) this.currentlyGenerating.get()));
-+            hasSetFarWarned = true;
-+            if (this.getServer() != null && this.getServer().isDebugging()) {
-+                io.papermc.paper.util.TraceUtil.dumpTraceForThread("far setBlock call");
-+            }
++                Util.logAndPauseIfInIde("Detected setBlock in a far chunk [" + i + ", " + j + "], pos: " + String.valueOf(pos) + ", status: " + String.valueOf(this.generatingStatus) + (this.currentlyGenerating == null ? "" : ", currently generating: " + (String) this.currentlyGenerating.get()));
++                hasSetFarWarned = true;
++                if (this.getServer() != null && this.getServer().isDebugging()) {
++                    io.papermc.paper.util.TraceUtil.dumpTraceForThread("far setBlock call");
++                }
 +            }
 +            // Paper end - Buffer OOB setBlock calls
              return false;
diff --git a/patches/unapplied/server/Custom-Potion-Mixes.patch b/patches/server/Custom-Potion-Mixes.patch
similarity index 69%
rename from patches/unapplied/server/Custom-Potion-Mixes.patch
rename to patches/server/Custom-Potion-Mixes.patch
index ce94379de7..297671bdd0 100644
--- a/patches/unapplied/server/Custom-Potion-Mixes.patch
+++ b/patches/server/Custom-Potion-Mixes.patch
@@ -38,8 +38,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
  
              this.worldData.setDataConfiguration(worlddataconfiguration);
-             this.resources.managers.updateRegistryTags(this.registryAccess());
-+            net.minecraft.world.item.alchemy.PotionBrewing.reload(); // Paper - Custom Potion Mixes
+             this.resources.managers.updateRegistryTags();
++            this.potionBrewing.reload(this.worldData.enabledFeatures()); // Paper - Custom Potion Mixes
              this.getPlayerList().saveAll();
              this.getPlayerList().reloadResources();
              this.functionManager.replaceLibrary(this.resources.managers.getFunctionLibrary());
@@ -61,50 +61,50 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/world/item/alchemy/PotionBrewing.java
 +++ b/src/main/java/net/minecraft/world/item/alchemy/PotionBrewing.java
 @@ -0,0 +0,0 @@ public class PotionBrewing {
-     public static final int BREWING_TIME_SECONDS = 20;
-     private static final List<PotionBrewing.Mix<Potion>> POTION_MIXES = Lists.newArrayList();
-     private static final List<PotionBrewing.Mix<Item>> CONTAINER_MIXES = Lists.newArrayList();
+     private final List<Ingredient> containers;
+     private final List<PotionBrewing.Mix<Potion>> potionMixes;
+     private final List<PotionBrewing.Mix<Item>> containerMixes;
 +    private static final it.unimi.dsi.fastutil.objects.Object2ObjectLinkedOpenHashMap<org.bukkit.NamespacedKey, io.papermc.paper.potion.PaperPotionMix> CUSTOM_MIXES = new it.unimi.dsi.fastutil.objects.Object2ObjectLinkedOpenHashMap<>(); // Paper - Custom Potion Mixes
-     private static final List<Ingredient> ALLOWED_CONTAINERS = Lists.newArrayList();
-     private static final Predicate<ItemStack> ALLOWED_CONTAINER = stack -> {
-         for (Ingredient ingredient : ALLOWED_CONTAINERS) {
-@@ -0,0 +0,0 @@ public class PotionBrewing {
-     };
  
-     public static boolean isIngredient(ItemStack stack) {
--        return isContainerIngredient(stack) || isPotionIngredient(stack);
-+        return isContainerIngredient(stack) || isPotionIngredient(stack) || isCustomIngredient(stack); // Paper - Custom Potion Mixes
-     }
- 
-     protected static boolean isContainerIngredient(ItemStack stack) {
+     PotionBrewing(List<Ingredient> potionTypes, List<PotionBrewing.Mix<Potion>> potionRecipes, List<PotionBrewing.Mix<Item>> itemRecipes) {
+         this.containers = potionTypes;
 @@ -0,0 +0,0 @@ public class PotionBrewing {
      }
  
-     public static boolean hasMix(ItemStack input, ItemStack ingredient) {
+     public boolean isIngredient(ItemStack stack) {
+-        return this.isContainerIngredient(stack) || this.isPotionIngredient(stack);
++        return this.isContainerIngredient(stack) || this.isPotionIngredient(stack) || isCustomIngredient(stack); // Paper - Custom Potion Mixes
+     }
+ 
+     private boolean isContainer(ItemStack stack) {
+@@ -0,0 +0,0 @@ public class PotionBrewing {
+     }
+ 
+     public boolean hasMix(ItemStack input, ItemStack ingredient) {
 +        // Paper start - Custom Potion Mixes
 +        if (hasCustomMix(input, ingredient)) {
 +            return true;
 +        }
 +        // Paper end - Custom Potion Mixes
-         return ALLOWED_CONTAINER.test(input) && (hasContainerMix(input, ingredient) || hasPotionMix(input, ingredient));
+         return this.isContainer(input) && (this.hasContainerMix(input, ingredient) || this.hasPotionMix(input, ingredient));
      }
  
 @@ -0,0 +0,0 @@ public class PotionBrewing {
- 
-     public static ItemStack mix(ItemStack ingredient, ItemStack input) {
-         if (!input.isEmpty()) {
-+            // Paper start - Custom Potion Mixes
-+            for (var mix : CUSTOM_MIXES.values()) {
-+                if (mix.input().test(input) && mix.ingredient().test(ingredient)) {
-+                    return mix.result().copy();
+             if (optional.isEmpty()) {
+                 return input;
+             } else {
++                // Paper start - Custom Potion Mixes
++                for (var mix : CUSTOM_MIXES.values()) {
++                    if (mix.input().test(input) && mix.ingredient().test(ingredient)) {
++                        return mix.result().copy();
++                    }
 +                }
-+            }
-+            // Paper end - Custom Potion Mixes
-             Potion potion = PotionUtils.getPotion(input);
-             Item item = input.getItem();
- 
++                // Paper end - Custom Potion Mixes
+                 for (PotionBrewing.Mix<Item> mix : this.containerMixes) {
+                     if (input.is(mix.from) && mix.ingredient.test(ingredient)) {
+                         return PotionContents.createItemStack(mix.to.value(), optional.get());
 @@ -0,0 +0,0 @@ public class PotionBrewing {
-         return input;
+         builder.addMix(Potions.SLOW_FALLING, Items.REDSTONE, Potions.LONG_SLOW_FALLING);
      }
  
 +    // Paper start - Custom Potion Mixes
@@ -146,31 +146,31 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        return CUSTOM_MIXES.remove(key) != null;
 +    }
 +
-+    public static void reload() {
-+        POTION_MIXES.clear();
-+        CONTAINER_MIXES.clear();
-+        ALLOWED_CONTAINERS.clear();
++    public void reload(FeatureFlagSet flags) {
++        potionMixes.clear();
++        containerMixes.clear();
++        containers.clear();
 +        CUSTOM_MIXES.clear();
-+        bootStrap();
++        bootstrap(flags);
 +    }
 +    // Paper end - Custom Potion Mixes
 +
-     public static void bootStrap() {
-         addContainer(Items.POTION);
-         addContainer(Items.SPLASH_POTION);
+     public static class Builder {
+         private final List<Ingredient> containers = new ArrayList<>();
+         private final List<PotionBrewing.Mix<Potion>> potionMixes = new ArrayList<>();
 diff --git a/src/main/java/net/minecraft/world/level/block/entity/BrewingStandBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/BrewingStandBlockEntity.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/level/block/entity/BrewingStandBlockEntity.java
 +++ b/src/main/java/net/minecraft/world/level/block/entity/BrewingStandBlockEntity.java
 @@ -0,0 +0,0 @@ public class BrewingStandBlockEntity extends BaseContainerBlockEntity implements
  
-     @Override
-     public boolean canPlaceItem(int slot, ItemStack stack) {
--        return slot == 3 ? PotionBrewing.isIngredient(stack) : (slot == 4 ? stack.is(Items.BLAZE_POWDER) : (stack.is(Items.POTION) || stack.is(Items.SPLASH_POTION) || stack.is(Items.LINGERING_POTION) || stack.is(Items.GLASS_BOTTLE)) && this.getItem(slot).isEmpty());
-+        return slot == 3 ? PotionBrewing.isIngredient(stack) : (slot == 4 ? stack.is(Items.BLAZE_POWDER) : (stack.is(Items.POTION) || stack.is(Items.SPLASH_POTION) || stack.is(Items.LINGERING_POTION) || stack.is(Items.GLASS_BOTTLE) || PotionBrewing.isCustomInput(stack)) && this.getItem(slot).isEmpty()); // Paper - Custom Potion Mixes
+             return potionbrewer.isIngredient(stack);
+         } else {
+-            return slot == 4 ? stack.is(Items.BLAZE_POWDER) : (stack.is(Items.POTION) || stack.is(Items.SPLASH_POTION) || stack.is(Items.LINGERING_POTION) || stack.is(Items.GLASS_BOTTLE)) && this.getItem(slot).isEmpty();
++            return slot == 4 ? stack.is(Items.BLAZE_POWDER) : (stack.is(Items.POTION) || stack.is(Items.SPLASH_POTION) || stack.is(Items.LINGERING_POTION) || stack.is(Items.GLASS_BOTTLE) || PotionBrewing.isCustomInput(stack)) && this.getItem(slot).isEmpty(); // Paper - Custom Potion Mixes
+         }
      }
  
-     @Override
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
@@ -184,15 +184,6 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      static {
          ConfigurationSerialization.registerClass(CraftOfflinePlayer.class);
 @@ -0,0 +0,0 @@ public final class CraftServer implements Server {
- 
-         CraftRegistry.setMinecraftRegistry(console.registryAccess());
- 
--        Potion.setPotionBrewer(new CraftPotionBrewer());
-+        Potion.setPotionBrewer(potionBrewer); // Paper - Custom Potion Mixes
-         // Ugly hack :(
- 
-         if (!Main.useConsole) {
-@@ -0,0 +0,0 @@ public final class CraftServer implements Server {
          return datapackManager;
      }
  
@@ -220,13 +211,41 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
          if (bukkit == null) {
 diff --git a/src/main/java/org/bukkit/craftbukkit/potion/CraftPotionBrewer.java b/src/main/java/org/bukkit/craftbukkit/potion/CraftPotionBrewer.java
-index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
---- a/src/main/java/org/bukkit/craftbukkit/potion/CraftPotionBrewer.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000
+--- /dev/null
 +++ b/src/main/java/org/bukkit/craftbukkit/potion/CraftPotionBrewer.java
-@@ -0,0 +0,0 @@ public class CraftPotionBrewer implements PotionBrewer {
-     public PotionEffect createEffect(PotionEffectType potion, int duration, int amplifier) {
-         return new PotionEffect(potion, potion.isInstant() ? 1 : (int) (duration * potion.getDurationModifier()), amplifier);
-     }
+@@ -0,0 +0,0 @@
++package org.bukkit.craftbukkit.potion;
++
++import com.google.common.base.Preconditions;
++import java.util.ArrayList;
++import java.util.Collection;
++import org.bukkit.potion.PotionBrewer;
++import org.bukkit.potion.PotionData;
++import org.bukkit.potion.PotionEffect;
++import org.bukkit.potion.PotionEffectType;
++import org.bukkit.potion.PotionType;
++
++public class CraftPotionBrewer implements PotionBrewer {
++
++    @Override
++    public Collection<PotionEffect> getEffects(PotionType type, boolean upgraded, boolean extended) {
++        Preconditions.checkArgument(!type.getKey().getKey().startsWith("strong_"), "Strong potion type cannot be used directly, got %s", type.getKey());
++        Preconditions.checkArgument(!type.getKey().getKey().startsWith("long_"), "Extended potion type cannot be used directly, got %s", type.getKey());
++
++        return CraftPotionUtil.fromBukkit(new PotionData(type, upgraded, extended)).getPotionEffects();
++    }
++
++    @Override
++    public Collection<PotionEffect> getEffectsFromDamage(int damage) {
++        return new ArrayList<PotionEffect>();
++    }
++
++    @Override
++    public PotionEffect createEffect(PotionEffectType potion, int duration, int amplifier) {
++        return new PotionEffect(potion, potion.isInstant() ? 1 : (int) (duration * potion.getDurationModifier()), amplifier);
++    }
 +
 +    // Paper start
 +    @Override
@@ -244,4 +263,4 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        net.minecraft.world.item.alchemy.PotionBrewing.reload();
 +    }
 +    // Paper end
- }
++}
diff --git a/patches/unapplied/server/Don-t-allow-vehicle-movement-from-players-while-tele.patch b/patches/server/Don-t-allow-vehicle-movement-from-players-while-tele.patch
similarity index 100%
rename from patches/unapplied/server/Don-t-allow-vehicle-movement-from-players-while-tele.patch
rename to patches/server/Don-t-allow-vehicle-movement-from-players-while-tele.patch
diff --git a/patches/unapplied/server/Ensure-entity-passenger-world-matches-ridden-entity.patch b/patches/server/Ensure-entity-passenger-world-matches-ridden-entity.patch
similarity index 91%
rename from patches/unapplied/server/Ensure-entity-passenger-world-matches-ridden-entity.patch
rename to patches/server/Ensure-entity-passenger-world-matches-ridden-entity.patch
index 22459bb9cd..b539995f28 100644
--- a/patches/unapplied/server/Ensure-entity-passenger-world-matches-ridden-entity.patch
+++ b/patches/server/Ensure-entity-passenger-world-matches-ridden-entity.patch
@@ -9,7 +9,7 @@ diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/jav
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/Entity.java
 +++ b/src/main/java/net/minecraft/world/entity/Entity.java
-@@ -0,0 +0,0 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+@@ -0,0 +0,0 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
      }
  
      public boolean startRiding(Entity entity, boolean force) {
diff --git a/patches/unapplied/server/Expand-PlayerItemDamageEvent.patch b/patches/server/Expand-PlayerItemDamageEvent.patch
similarity index 94%
rename from patches/unapplied/server/Expand-PlayerItemDamageEvent.patch
rename to patches/server/Expand-PlayerItemDamageEvent.patch
index bf5ee55406..30e1156d6c 100644
--- a/patches/unapplied/server/Expand-PlayerItemDamageEvent.patch
+++ b/patches/server/Expand-PlayerItemDamageEvent.patch
@@ -8,7 +8,7 @@ diff --git a/src/main/java/net/minecraft/world/item/ItemStack.java b/src/main/ja
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/item/ItemStack.java
 +++ b/src/main/java/net/minecraft/world/item/ItemStack.java
-@@ -0,0 +0,0 @@ public final class ItemStack {
+@@ -0,0 +0,0 @@ public final class ItemStack implements DataComponentHolder {
                      }
                  }
  
diff --git a/patches/unapplied/server/Expose-furnace-minecart-push-values.patch b/patches/server/Expose-furnace-minecart-push-values.patch
similarity index 100%
rename from patches/unapplied/server/Expose-furnace-minecart-push-values.patch
rename to patches/server/Expose-furnace-minecart-push-values.patch
diff --git a/patches/unapplied/server/Fix-CME-in-CraftPersistentDataTypeRegistry.patch b/patches/server/Fix-CME-in-CraftPersistentDataTypeRegistry.patch
similarity index 100%
rename from patches/unapplied/server/Fix-CME-in-CraftPersistentDataTypeRegistry.patch
rename to patches/server/Fix-CME-in-CraftPersistentDataTypeRegistry.patch
diff --git a/patches/unapplied/server/Fix-NBT-pieces-overriding-a-block-entity-during-worl.patch b/patches/server/Fix-NBT-pieces-overriding-a-block-entity-during-worl.patch
similarity index 100%
rename from patches/unapplied/server/Fix-NBT-pieces-overriding-a-block-entity-during-worl.patch
rename to patches/server/Fix-NBT-pieces-overriding-a-block-entity-during-worl.patch
diff --git a/patches/unapplied/server/Fix-cancelling-ProjectileHitEvent-for-piercing-arrow.patch b/patches/server/Fix-cancelling-ProjectileHitEvent-for-piercing-arrow.patch
similarity index 89%
rename from patches/unapplied/server/Fix-cancelling-ProjectileHitEvent-for-piercing-arrow.patch
rename to patches/server/Fix-cancelling-ProjectileHitEvent-for-piercing-arrow.patch
index 722057baf6..60fbfd0b48 100644
--- a/patches/unapplied/server/Fix-cancelling-ProjectileHitEvent-for-piercing-arrow.patch
+++ b/patches/server/Fix-cancelling-ProjectileHitEvent-for-piercing-arrow.patch
@@ -23,18 +23,19 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      }
  
 +    // Paper start - Fix cancelling ProjectileHitEvent for piercing arrows
-+    @Override
-+    public void preOnHit(HitResult hitResult) {
-+        super.preOnHit(hitResult);
+     @Override
+-    protected double getDefaultGravity() {
+-        return 0.05D;
++    public ProjectileDeflection preHitTargetOrDeflectSelf(HitResult hitResult) {
 +        if (hitResult instanceof EntityHitResult entityHitResult && this.hitCancelled && this.getPierceLevel() > 0) {
 +            if (this.piercingIgnoreEntityIds == null) {
 +                this.piercingIgnoreEntityIds = new IntOpenHashSet(5);
 +            }
 +            this.piercingIgnoreEntityIds.add(entityHitResult.getEntity().getId());
 +        }
-+    }
++        super.preHitTargetOrDeflectSelf(hitResult);
+     }
 +    // Paper end - Fix cancelling ProjectileHitEvent for piercing arrows
-+
+ 
      private boolean shouldFall() {
          return this.inGround && this.level().noCollision((new AABB(this.position(), this.position())).inflate(0.06D));
-     }
diff --git a/patches/unapplied/server/Fix-falling-block-spawn-methods.patch b/patches/server/Fix-falling-block-spawn-methods.patch
similarity index 89%
rename from patches/unapplied/server/Fix-falling-block-spawn-methods.patch
rename to patches/server/Fix-falling-block-spawn-methods.patch
index 0f3849b87a..5b53087e57 100644
--- a/patches/unapplied/server/Fix-falling-block-spawn-methods.patch
+++ b/patches/server/Fix-falling-block-spawn-methods.patch
@@ -47,11 +47,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntityTypes.java
 +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntityTypes.java
 @@ -0,0 +0,0 @@ public final class CraftEntityTypes {
-         register(new EntityTypeData<>(EntityType.PRIMED_TNT, TNTPrimed.class, CraftTNTPrimed::new, spawnData -> new PrimedTnt(spawnData.minecraftWorld(), spawnData.x(), spawnData.y(), spawnData.z(), null)));
+         register(new EntityTypeData<>(EntityType.TNT, TNTPrimed.class, CraftTNTPrimed::new, spawnData -> new PrimedTnt(spawnData.minecraftWorld(), spawnData.x(), spawnData.y(), spawnData.z(), null)));
          register(new EntityTypeData<>(EntityType.FALLING_BLOCK, FallingBlock.class, CraftFallingBlock::new, spawnData -> {
              BlockPos pos = BlockPos.containing(spawnData.x(), spawnData.y(), spawnData.z());
 -            return FallingBlockEntity.fall(spawnData.minecraftWorld(), pos, spawnData.world().getBlockState(pos));
 +            return new FallingBlockEntity(spawnData.minecraftWorld(), spawnData.x(), spawnData.y(), spawnData.z(), spawnData.world().getBlockState(pos)); // Paper - create falling block entities correctly
          }));
-         register(new EntityTypeData<>(EntityType.FIREWORK, Firework.class, CraftFirework::new, spawnData -> new FireworkRocketEntity(spawnData.minecraftWorld(), spawnData.x(), spawnData.y(), spawnData.z(), net.minecraft.world.item.ItemStack.EMPTY)));
+         register(new EntityTypeData<>(EntityType.FIREWORK_ROCKET, Firework.class, CraftFirework::new, spawnData -> new FireworkRocketEntity(spawnData.minecraftWorld(), spawnData.x(), spawnData.y(), spawnData.z(), net.minecraft.world.item.ItemStack.EMPTY)));
          register(new EntityTypeData<>(EntityType.EVOKER_FANGS, EvokerFangs.class, CraftEvokerFangs::new, spawnData -> new net.minecraft.world.entity.projectile.EvokerFangs(spawnData.minecraftWorld(), spawnData.x(), spawnData.y(), spawnData.z(), (float) Math.toRadians(spawnData.yaw()), 0, null)));
diff --git a/patches/unapplied/server/Fix-new-block-data-for-EntityChangeBlockEvent.patch b/patches/server/Fix-new-block-data-for-EntityChangeBlockEvent.patch
similarity index 95%
rename from patches/unapplied/server/Fix-new-block-data-for-EntityChangeBlockEvent.patch
rename to patches/server/Fix-new-block-data-for-EntityChangeBlockEvent.patch
index af41ec8f4f..d4114b7d17 100644
--- a/patches/unapplied/server/Fix-new-block-data-for-EntityChangeBlockEvent.patch
+++ b/patches/server/Fix-new-block-data-for-EntityChangeBlockEvent.patch
@@ -83,13 +83,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +++ b/src/main/java/net/minecraft/world/entity/boss/wither/WitherBoss.java
 @@ -0,0 +0,0 @@ public class WitherBoss extends Monster implements PowerableMob, RangedAttackMob
  
-                                 if (WitherBoss.canDestroy(iblockdata)) {
-                                     // CraftBukkit start
--                                    if (!CraftEventFactory.callEntityChangeBlockEvent(this, blockposition, Blocks.AIR.defaultBlockState())) {
-+                                    if (!CraftEventFactory.callEntityChangeBlockEvent(this, blockposition, iblockdata.getFluidState().createLegacyBlock())) { // Paper - fix wrong block state
-                                         continue;
-                                     }
-                                     // CraftBukkit end
+                         if (WitherBoss.canDestroy(iblockdata)) {
+                             // CraftBukkit start
+-                            if (!CraftEventFactory.callEntityChangeBlockEvent(this, blockposition, Blocks.AIR.defaultBlockState())) {
++                            if (!CraftEventFactory.callEntityChangeBlockEvent(this, blockposition, iblockdata.getFluidState().createLegacyBlock())) { // Paper - fix wrong block state
+                                 continue;
+                             }
+                             // CraftBukkit end
 diff --git a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java b/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/monster/EnderMan.java
@@ -101,7 +101,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -                if (CraftEventFactory.callEntityChangeBlockEvent(this.enderman, blockposition, Blocks.AIR.defaultBlockState())) { // CraftBukkit - Place event
 +                if (CraftEventFactory.callEntityChangeBlockEvent(this.enderman, blockposition, iblockdata.getFluidState().createLegacyBlock())) { // CraftBukkit - Place event // Paper - fix wrong block state
                  world.removeBlock(blockposition, false);
-                 world.gameEvent(GameEvent.BLOCK_DESTROY, blockposition, GameEvent.Context.of(this.enderman, iblockdata));
+                 world.gameEvent((Holder) GameEvent.BLOCK_DESTROY, blockposition, GameEvent.Context.of(this.enderman, iblockdata));
                  this.enderman.setCarriedBlock(iblockdata.getBlock().defaultBlockState());
 diff --git a/src/main/java/net/minecraft/world/entity/monster/Ravager.java b/src/main/java/net/minecraft/world/entity/monster/Ravager.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
diff --git a/patches/unapplied/server/Fix-saving-in-unloadWorld.patch b/patches/server/Fix-saving-in-unloadWorld.patch
similarity index 100%
rename from patches/unapplied/server/Fix-saving-in-unloadWorld.patch
rename to patches/server/Fix-saving-in-unloadWorld.patch
diff --git a/patches/unapplied/server/Fix-swamp-hut-cat-generation-deadlock.patch b/patches/server/Fix-swamp-hut-cat-generation-deadlock.patch
similarity index 79%
rename from patches/unapplied/server/Fix-swamp-hut-cat-generation-deadlock.patch
rename to patches/server/Fix-swamp-hut-cat-generation-deadlock.patch
index e9ff1f23fe..cafdf56803 100644
--- a/patches/unapplied/server/Fix-swamp-hut-cat-generation-deadlock.patch
+++ b/patches/server/Fix-swamp-hut-cat-generation-deadlock.patch
@@ -13,13 +13,13 @@ diff --git a/src/main/java/net/minecraft/world/entity/animal/Cat.java b/src/main
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/net/minecraft/world/entity/animal/Cat.java
 +++ b/src/main/java/net/minecraft/world/entity/animal/Cat.java
-@@ -0,0 +0,0 @@ public class Cat extends TamableAnimal implements VariantHolder<CatVariant> {
-         });
+@@ -0,0 +0,0 @@ public class Cat extends TamableAnimal implements VariantHolder<Holder<CatVarian
+         BuiltInRegistries.CAT_VARIANT.getRandomElementOf(tagkey, world.getRandom()).ifPresent(this::setVariant);
          ServerLevel worldserver = world.getLevel();
  
 -        if (worldserver.structureManager().getStructureWithPieceAt(this.blockPosition(), StructureTags.CATS_SPAWN_AS_BLACK).isValid()) {
 +        if (worldserver.structureManager().getStructureWithPieceAt(this.blockPosition(), StructureTags.CATS_SPAWN_AS_BLACK, world).isValid()) { // Paper - Fix swamp hut cat generation deadlock
-             this.setVariant((CatVariant) BuiltInRegistries.CAT_VARIANT.getOrThrow(CatVariant.ALL_BLACK));
+             this.setVariant((Holder) BuiltInRegistries.CAT_VARIANT.getHolderOrThrow(CatVariant.ALL_BLACK));
              this.setPersistenceRequired();
          }
 diff --git a/src/main/java/net/minecraft/world/level/StructureManager.java b/src/main/java/net/minecraft/world/level/StructureManager.java
@@ -43,17 +43,22 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public class StructureManager {
      }
  
-     public StructureStart getStructureWithPieceAt(BlockPos pos, TagKey<Structure> structureTag) {
+     public StructureStart getStructureWithPieceAt(BlockPos pos, Predicate<Holder<Structure>> predicate) {
 +        // Paper start - Fix swamp hut cat generation deadlock
-+        return this.getStructureWithPieceAt(pos, structureTag, null);
++        return this.getStructureWithPieceAt(pos, predicate, null);
 +    }
-+    public StructureStart getStructureWithPieceAt(BlockPos pos, TagKey<Structure> structureTag, @Nullable ServerLevelAccessor levelAccessor) {
++
++    public StructureStart getStructureWithPieceAt(BlockPos pos, TagKey<Structure> tag, @Nullable ServerLevelAccessor levelAccessor) {
++        return this.getStructureWithPieceAt(pos, structure -> structure.is(tag), levelAccessor);
++    }
++
++    public StructureStart getStructureWithPieceAt(BlockPos pos, Predicate<Holder<Structure>> predicate, @Nullable ServerLevelAccessor levelAccessor) {
 +        // Paper end - Fix swamp hut cat generation deadlock
          Registry<Structure> registry = this.registryAccess().registryOrThrow(Registries.STRUCTURE);
  
          for (StructureStart structureStart : this.startsForStructure(
--            new ChunkPos(pos), structure -> registry.getHolder(registry.getId(structure)).map(reference -> reference.is(structureTag)).orElse(false)
-+            new ChunkPos(pos), structure -> registry.getHolder(registry.getId(structure)).map(reference -> reference.is(structureTag)).orElse(false), levelAccessor // Paper - Fix swamp hut cat generation deadlock
+-            new ChunkPos(pos), structure -> registry.getHolder(registry.getId(structure)).map(predicate::test).orElse(false)
++            new ChunkPos(pos), structure -> registry.getHolder(registry.getId(structure)).map(predicate::test).orElse(false), levelAccessor // Paper - Fix swamp hut cat generation deadlock
          )) {
              if (this.structureHasPieceAt(pos, structureStart)) {
                  return structureStart;
diff --git a/patches/unapplied/server/Force-close-world-loading-screen.patch b/patches/server/Force-close-world-loading-screen.patch
similarity index 94%
rename from patches/unapplied/server/Force-close-world-loading-screen.patch
rename to patches/server/Force-close-world-loading-screen.patch
index 06544abb2b..223e9a8332 100644
--- a/patches/unapplied/server/Force-close-world-loading-screen.patch
+++ b/patches/server/Force-close-world-loading-screen.patch
@@ -14,9 +14,9 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/players/PlayerList.java
 +++ b/src/main/java/net/minecraft/server/players/PlayerList.java
 @@ -0,0 +0,0 @@ public abstract class PlayerList {
- 
+         }
          // Paper start - Fire PlayerJoinEvent when Player is actually ready; move vehicle into method so it can be called above - short circuit around that code
-         onPlayerJoinFinish(player, worldserver1, s1);
+         this.onPlayerJoinFinish(player, worldserver1, s1);
 +        // Paper start - Send empty chunk, so players aren't stuck in the world loading screen with our chunk system not sending chunks when dead
 +        if (player.isDeadOrDying()) {
 +            net.minecraft.core.Holder<net.minecraft.world.level.biome.Biome> plains = worldserver1.registryAccess().registryOrThrow(net.minecraft.core.registries.Registries.BIOME)
@@ -28,5 +28,5 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        }
 +        // Paper end - Send empty chunk
      }
-     private void mountSavedVehicle(ServerPlayer player, ServerLevel worldserver1, CompoundTag nbttagcompound) {
+     private void mountSavedVehicle(ServerPlayer player, ServerLevel worldserver1, Optional<CompoundTag> optional) {
          // Paper end - Fire PlayerJoinEvent when Player is actually ready
diff --git a/patches/unapplied/server/Implement-enchantWithLevels-API.patch b/patches/server/Implement-enchantWithLevels-API.patch
similarity index 100%
rename from patches/unapplied/server/Implement-enchantWithLevels-API.patch
rename to patches/server/Implement-enchantWithLevels-API.patch
diff --git a/patches/unapplied/server/Implement-getComputedBiome-API.patch b/patches/server/Implement-getComputedBiome-API.patch
similarity index 100%
rename from patches/unapplied/server/Implement-getComputedBiome-API.patch
rename to patches/server/Implement-getComputedBiome-API.patch
diff --git a/patches/unapplied/server/Make-some-itemstacks-nonnull.patch b/patches/server/Make-some-itemstacks-nonnull.patch
similarity index 100%
rename from patches/unapplied/server/Make-some-itemstacks-nonnull.patch
rename to patches/server/Make-some-itemstacks-nonnull.patch
diff --git a/patches/unapplied/server/More-Projectile-API.patch b/patches/server/More-Projectile-API.patch
similarity index 92%
rename from patches/unapplied/server/More-Projectile-API.patch
rename to patches/server/More-Projectile-API.patch
index 7e9dad172e..c986637302 100644
--- a/patches/unapplied/server/More-Projectile-API.patch
+++ b/patches/server/More-Projectile-API.patch
@@ -34,10 +34,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        // Paper end - More projectile API
          if (!this.level().isClientSide) {
              ItemStack itemstack = this.getItem();
-             Potion potionregistry = PotionUtils.getPotion(itemstack);
+             PotionContents potioncontents = (PotionContents) itemstack.getOrDefault(DataComponents.POTION_CONTENTS, PotionContents.EMPTY);
 @@ -0,0 +0,0 @@ public class ThrownPotion extends ThrowableItemProjectile implements ItemSupplie
                  if (this.isLingering()) {
-                     showParticles = this.makeAreaOfEffectCloud(itemstack, potionregistry, hitResult); // CraftBukkit - Pass MovingObjectPosition // Paper
+                     showParticles = this.makeAreaOfEffectCloud(itemstack, hitResult); // CraftBukkit - Pass MovingObjectPosition // Paper
                  } else {
 -                    showParticles = this.applySplash(list, hitResult.getType() == HitResult.Type.ENTITY ? ((EntityHitResult) hitResult).getEntity() : null, hitResult); // CraftBukkit - Pass MovingObjectPosition // Paper
 +                    showParticles = this.applySplash(list, hitResult != null && hitResult.getType() == HitResult.Type.ENTITY ? ((EntityHitResult) hitResult).getEntity() : null, hitResult); // CraftBukkit - Pass MovingObjectPosition // Paper - More projectile API
@@ -48,17 +48,17 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      }
  
--    private boolean applySplash(List<MobEffectInstance> list, @Nullable Entity entity, HitResult position) { // CraftBukkit - Pass MovingObjectPosition // Paper - Fix potions splash events
-+    private boolean applySplash(List<MobEffectInstance> list, @Nullable Entity entity, @Nullable HitResult position) { // CraftBukkit - Pass MovingObjectPosition // Paper - Fix potions splash events & More projectile API
+-    private boolean applySplash(Iterable<MobEffectInstance> iterable, @Nullable Entity entity, HitResult position) { // CraftBukkit - Pass MovingObjectPosition // Paper - Fix potions splash events
++    private boolean applySplash(Iterable<MobEffectInstance> iterable, @Nullable Entity entity, @Nullable HitResult position) { // CraftBukkit - Pass MovingObjectPosition // Paper - Fix potions splash events & More projectile API
          AABB axisalignedbb = this.getBoundingBox().inflate(4.0D, 2.0D, 4.0D);
-         List<net.minecraft.world.entity.LivingEntity> list1 = this.level().getEntitiesOfClass(net.minecraft.world.entity.LivingEntity.class, axisalignedbb);
+         List<net.minecraft.world.entity.LivingEntity> list = this.level().getEntitiesOfClass(net.minecraft.world.entity.LivingEntity.class, axisalignedbb);
          Map<LivingEntity, Double> affected = new HashMap<LivingEntity, Double>(); // CraftBukkit
 @@ -0,0 +0,0 @@ public class ThrownPotion extends ThrowableItemProjectile implements ItemSupplie
  
      }
  
--    private boolean makeAreaOfEffectCloud(ItemStack itemstack, Potion potionregistry, HitResult position) { // CraftBukkit - Pass MovingObjectPosition // Paper - return boolean
-+    private boolean makeAreaOfEffectCloud(ItemStack itemstack, Potion potionregistry, @Nullable HitResult position) { // CraftBukkit - Pass MovingObjectPosition // Paper - return boolean & More projectile API
+-    private boolean makeAreaOfEffectCloud(PotionContents potioncontents, HitResult position) { // CraftBukkit - Pass MovingObjectPosition
++    private boolean makeAreaOfEffectCloud(PotionContents potioncontents, @Nullable HitResult position) { // CraftBukkit - Pass MovingObjectPosition // Paper - More projectile API
          AreaEffectCloud entityareaeffectcloud = new AreaEffectCloud(this.level(), this.getX(), this.getY(), this.getZ());
          Entity entity = this.getOwner();
  
@@ -136,30 +136,8 @@ diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftArrow.java b/src/m
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftArrow.java
 +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftArrow.java
-@@ -0,0 +0,0 @@ public class CraftArrow extends AbstractProjectile implements AbstractArrow {
-         this.getHandle().setCritArrow(critical);
-     }
- 
--    @Override
--    public ProjectileSource getShooter() {
--        return this.getHandle().projectileSource;
--    }
--
--    @Override
--    public void setShooter(ProjectileSource shooter) {
--        if (shooter instanceof Entity) {
--            this.getHandle().setOwner(((CraftEntity) shooter).getHandle());
--        } else {
--            this.getHandle().setOwner(null);
--        }
--        this.getHandle().projectileSource = shooter;
--    }
-+    // Paper - moved to AbstractProjectile
- 
-     @Override
-     public boolean isInBlock() {
-@@ -0,0 +0,0 @@ public class CraftArrow extends AbstractProjectile implements AbstractArrow {
-         this.getHandle().pickup = net.minecraft.world.entity.projectile.AbstractArrow.Pickup.byOrdinal(status.ordinal());
+@@ -0,0 +0,0 @@ public class CraftArrow extends CraftAbstractArrow implements Arrow {
+         return false;
      }
  
 +    // Paper start
@@ -192,8 +170,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    // Paper end
 +
      @Override
-     public void setTicksLived(int value) {
-         super.setTicksLived(value);
+     public boolean hasCustomEffects() {
+         return !this.getHandle().getPotionContents().customEffects().isEmpty();
 diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftFireball.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftFireball.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftFireball.java
@@ -500,7 +478,7 @@ diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftTrident.java b/src
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/craftbukkit/entity/CraftTrident.java
 +++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftTrident.java
-@@ -0,0 +0,0 @@ public class CraftTrident extends CraftArrow implements Trident {
+@@ -0,0 +0,0 @@ public class CraftTrident extends CraftAbstractArrow implements Trident {
          com.google.common.base.Preconditions.checkArgument(loyaltyLevel >= 0 && loyaltyLevel <= 127, "The loyalty level has to be between 0 and 127");
          this.getHandle().setLoyalty((byte) loyaltyLevel);
      }
@@ -592,5 +570,5 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -        switch (CraftItemStack.getType(item)) {
 +        switch (material) {  // Paper
              case WRITTEN_BOOK:
-                 return new CraftMetaBookSigned(item.getTag());
+                 return new CraftMetaBookSigned(item.getComponentsPatch());
              case WRITABLE_BOOK:
diff --git a/patches/unapplied/server/Prevent-tile-entity-copies-loading-chunks.patch b/patches/server/Prevent-tile-entity-copies-loading-chunks.patch
similarity index 92%
rename from patches/unapplied/server/Prevent-tile-entity-copies-loading-chunks.patch
rename to patches/server/Prevent-tile-entity-copies-loading-chunks.patch
index 61d27358bf..3cbf85d91b 100644
--- a/patches/unapplied/server/Prevent-tile-entity-copies-loading-chunks.patch
+++ b/patches/server/Prevent-tile-entity-copies-loading-chunks.patch
@@ -9,7 +9,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
 +++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
 @@ -0,0 +0,0 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
-                 BlockPos blockposition = BlockEntity.getPosFromTag(nbttagcompound);
+                 BlockPos blockposition = BlockEntity.getPosFromTag(customdata.getUnsafe());
  
                  if (this.player.level().isLoaded(blockposition)) {
 -                    BlockEntity tileentity = this.player.level().getBlockEntity(blockposition);
@@ -21,4 +21,4 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                    // Paper end - Prevent tile entity copies loading chunks
  
                      if (tileentity != null) {
-                         tileentity.saveToItem(itemstack);
+                         tileentity.saveToItem(itemstack, this.player.level().registryAccess());
diff --git a/patches/unapplied/server/Trigger-bee_nest_destroyed-trigger-in-the-correct-pl.patch b/patches/server/Trigger-bee_nest_destroyed-trigger-in-the-correct-pl.patch
similarity index 100%
rename from patches/unapplied/server/Trigger-bee_nest_destroyed-trigger-in-the-correct-pl.patch
rename to patches/server/Trigger-bee_nest_destroyed-trigger-in-the-correct-pl.patch
diff --git a/patches/unapplied/server/Use-username-instead-of-display-name-in-PlayerList-g.patch b/patches/server/Use-username-instead-of-display-name-in-PlayerList-g.patch
similarity index 100%
rename from patches/unapplied/server/Use-username-instead-of-display-name-in-PlayerList-g.patch
rename to patches/server/Use-username-instead-of-display-name-in-PlayerList-g.patch
diff --git a/patches/unapplied/server/WorldCreator-keepSpawnLoaded.patch b/patches/server/WorldCreator-keepSpawnLoaded.patch
similarity index 51%
rename from patches/unapplied/server/WorldCreator-keepSpawnLoaded.patch
rename to patches/server/WorldCreator-keepSpawnLoaded.patch
index 50be64fe1b..26f73796d0 100644
--- a/patches/unapplied/server/WorldCreator-keepSpawnLoaded.patch
+++ b/patches/server/WorldCreator-keepSpawnLoaded.patch
@@ -8,20 +8,18 @@ diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/ja
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644
 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
 +++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-@@ -0,0 +0,0 @@ public final class CraftServer implements Server {
- 
-         ServerLevel internal = (ServerLevel) new ServerLevel(this.console, this.console.executor, worldSession, worlddata, worldKey, worlddimension, this.getServer().progressListenerFactory.create(11),
-                 worlddata.isDebugWorld(), j, creator.environment() == Environment.NORMAL ? list : ImmutableList.of(), true, this.console.overworld().getRandomSequences(), creator.environment(), generator, biomeProvider);
--        internal.keepSpawnInMemory = creator.keepSpawnInMemory();
-+        // internal.keepSpawnInMemory = creator.keepSpawnInMemory(); // Paper - replace
- 
-         if (!(this.worlds.containsKey(name.toLowerCase(java.util.Locale.ENGLISH)))) {
-             return null;
 @@ -0,0 +0,0 @@ public final class CraftServer implements Server {
          internal.setSpawnSettings(true, true);
          // Paper - Put world into worldlist before initing the world; move up
  
-+        internal.keepSpawnInMemory = creator.keepSpawnLoaded().toBooleanOrElse(internal.getWorld().getKeepSpawnInMemory()); // Paper
++        // Paper start
++        if (creator.keepSpawnLoaded().toBooleanOrElse(internal.getWorld().getKeepSpawnInMemory())) {
++            GameRules.IntegerValue rule = internal.getGameRules().getRule(GameRules.RULE_SPAWN_CHUNK_RADIUS);
++            rule.deserialize("0");
++            rule.onChanged(internal);
++        }
++        // Paper end
++
          this.getServer().prepareLevels(internal.getChunkSource().chunkMap.progressListener, internal);
          internal.entityManager.tick(); // SPIGOT-6526: Load pending entities so they are available to the API
  
diff --git a/patches/unapplied/server/cache-resource-keys.patch b/patches/server/cache-resource-keys.patch
similarity index 100%
rename from patches/unapplied/server/cache-resource-keys.patch
rename to patches/server/cache-resource-keys.patch
diff --git a/patches/unapplied/server/fix-player-loottables-running-when-mob-loot-gamerule.patch b/patches/server/fix-player-loottables-running-when-mob-loot-gamerule.patch
similarity index 100%
rename from patches/unapplied/server/fix-player-loottables-running-when-mob-loot-gamerule.patch
rename to patches/server/fix-player-loottables-running-when-mob-loot-gamerule.patch