Patches!!! MORE MORE MORE MOOOOORE

2023-12-06 11:34:54 -05:00 · 2023-12-06 11:34:54 -05:00 · 9546b9c587
commit 9546b9c587
parent cd61b5d98e
73 changed files with 265 additions and 267 deletions
--- a/patches/server/0945-Call-BlockGrowEvent-for-missing-blocks.patch
+++ b/patches/server/0945-Call-BlockGrowEvent-for-missing-blocks.patch
@ -0,0 +1,39 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Lulu13022002 <41980282+Lulu13022002@users.noreply.github.com>
+Date: Fri, 9 Jun 2023 13:04:42 +0200
+Subject: [PATCH] Call BlockGrowEvent for missing blocks
+
+Call the event for pitcher crops and sniffer egg
+
+diff --git a/src/main/java/net/minecraft/world/level/block/PitcherCropBlock.java b/src/main/java/net/minecraft/world/level/block/PitcherCropBlock.java
+index ba94ff948ccaddc16d3452306722759c115bb90a..acaa13f195467c3ebe70677b8440a88369d41b06 100644
+--- a/src/main/java/net/minecraft/world/level/block/PitcherCropBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/PitcherCropBlock.java
+@@ -130,7 +130,7 @@ public class PitcherCropBlock extends DoublePlantBlock implements BonemealableBl
+         int i = Math.min(state.getValue(AGE) + amount, 4);
+         if (this.canGrow(world, pos, state, i)) {
+             BlockState blockState = state.setValue(AGE, Integer.valueOf(i));
+-            world.setBlock(pos, blockState, 2);
+            if (!org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockGrowEvent(world, pos, blockState, 2)) return; // Paper
+             if (isDouble(i)) {
+                 world.setBlock(pos.above(), blockState.setValue(HALF, DoubleBlockHalf.UPPER), 3);
+             }
+diff --git a/src/main/java/net/minecraft/world/level/block/SnifferEggBlock.java b/src/main/java/net/minecraft/world/level/block/SnifferEggBlock.java
+index 6c025c0fac9bd6373b99e374b773ca626d47ee6d..02939518ead6463e677ecf5b045ec89aae154e8c 100644
+--- a/src/main/java/net/minecraft/world/level/block/SnifferEggBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/SnifferEggBlock.java
+@@ -72,8 +72,13 @@ public class SnifferEggBlock extends Block {
+     @Override
+     public void tick(BlockState state, ServerLevel world, BlockPos pos, RandomSource random) {
+         if (!this.isReadyToHatch(state)) {
+            // Paper start
+            if (!org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockGrowEvent(world, pos, state.setValue(HATCH, Integer.valueOf(this.getHatchLevel(state) + 1)), 2)) {
+                rescheduleTick(world, pos);
+                return;
+            }
+            // Paper end
+             world.playSound((Player)null, pos, SoundEvents.SNIFFER_EGG_CRACK, SoundSource.BLOCKS, 0.7F, 0.9F + random.nextFloat() * 0.2F);
+-            world.setBlock(pos, state.setValue(HATCH, Integer.valueOf(this.getHatchLevel(state) + 1)), 2);
+         } else {
+             // Paper start - Call BlockFadeEvent
+             if (org.bukkit.craftbukkit.event.CraftEventFactory.callBlockFadeEvent(world, pos, state.getFluidState().createLegacyBlock()).isCancelled()) {
--- a/patches/server/0946-Don-t-enforce-icanhasbukkit-default-if-alias-block-e.patch
+++ b/patches/server/0946-Don-t-enforce-icanhasbukkit-default-if-alias-block-e.patch
@ -0,0 +1,23 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: TheMeinerLP <p.glanz@madfix.me>
+Date: Tue, 13 Jun 2023 16:10:59 +0200
+Subject: [PATCH] Don't enforce icanhasbukkit default if alias block exists
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+index 97a32d1d4bc4042c72c488eee92dff69f8336464..d1d81ad90ee1c007b46c9afd1f4e918af2834d38 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -356,7 +356,11 @@ public final class CraftServer implements Server {
+         }
+         this.commandsConfiguration = YamlConfiguration.loadConfiguration(this.getCommandsConfigFile());
+         this.commandsConfiguration.options().copyDefaults(true);
+-        this.commandsConfiguration.setDefaults(YamlConfiguration.loadConfiguration(new InputStreamReader(this.getClass().getClassLoader().getResourceAsStream("configurations/commands.yml"), Charsets.UTF_8)));
+        // Paper start - don't enforce icanhasbukkit default if alias block exists
+        final YamlConfiguration commandsDefaults = YamlConfiguration.loadConfiguration(new InputStreamReader(this.getClass().getClassLoader().getResourceAsStream("configurations/commands.yml"), Charsets.UTF_8));
+        if (this.commandsConfiguration.contains("aliases")) commandsDefaults.set("aliases", null);
+        this.commandsConfiguration.setDefaults(commandsDefaults);
+        // Paper stop - dont enforce icanhasbukkit default if alias block exists
+         this.saveCommandsConfig();
+ 
+         // Migrate aliases from old file and add previously implicit $1- to pass all arguments
--- a/patches/server/0947-fix-MapLike-spam-for-missing-key-selector.patch
+++ b/patches/server/0947-fix-MapLike-spam-for-missing-key-selector.patch
@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Wed, 14 Jun 2023 13:17:40 -0700
+Subject: [PATCH] fix MapLike spam for missing key 'selector'
+
+
+diff --git a/src/main/java/net/minecraft/world/level/gameevent/vibrations/VibrationSystem.java b/src/main/java/net/minecraft/world/level/gameevent/vibrations/VibrationSystem.java
+index e7bd45e9834ffc6b94dd07cf69a685de66c9c37a..af5019716f487d9e4259b259712cf022f987603b 100644
+--- a/src/main/java/net/minecraft/world/level/gameevent/vibrations/VibrationSystem.java
+++ b/src/main/java/net/minecraft/world/level/gameevent/vibrations/VibrationSystem.java
+@@ -347,7 +347,7 @@ public interface VibrationSystem {
+         public static Codec<VibrationSystem.Data> CODEC = RecordCodecBuilder.create((instance) -> {
+             return instance.group(VibrationInfo.CODEC.optionalFieldOf("event").forGetter((vibrationsystem_a) -> {
+                 return Optional.ofNullable(vibrationsystem_a.currentVibration);
+-            }), VibrationSelector.CODEC.fieldOf("selector").forGetter(VibrationSystem.Data::getSelectionStrategy), ExtraCodecs.NON_NEGATIVE_INT.fieldOf("event_delay").orElse(0).forGetter(VibrationSystem.Data::getTravelTimeInTicks)).apply(instance, (optional, vibrationselector, integer) -> {
+            }), Codec.optionalField("selector", VibrationSelector.CODEC).xmap(o -> o.orElseGet(VibrationSelector::new), Optional::of).forGetter(VibrationSystem.Data::getSelectionStrategy), ExtraCodecs.NON_NEGATIVE_INT.fieldOf("event_delay").orElse(0).forGetter(VibrationSystem.Data::getTravelTimeInTicks)).apply(instance, (optional, vibrationselector, integer) -> { // Paper - fix MapLike spam for missing "selector" in 1.19.2
+                 return new VibrationSystem.Data((VibrationInfo) optional.orElse(null), vibrationselector, integer, true); // CraftBukkit - decompile error
+             });
+         });
--- a/patches/server/0948-Fix-sniffer-removeExploredLocation.patch
+++ b/patches/server/0948-Fix-sniffer-removeExploredLocation.patch
@ -0,0 +1,29 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Lulu13022002 <41980282+Lulu13022002@users.noreply.github.com>
+Date: Sun, 11 Jun 2023 19:02:46 +0200
+Subject: [PATCH] Fix sniffer removeExploredLocation
+
+Add support to remove explored location in different world
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftSniffer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftSniffer.java
+index 60251107371ef876d29fc9aa578835250715c4bc..555337018fe218ac5a296a5e6a1d82720fee05e1 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftSniffer.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftSniffer.java
+@@ -34,12 +34,13 @@ public class CraftSniffer extends CraftAnimals implements Sniffer {
+     @Override
+     public void removeExploredLocation(Location location) {
+         Preconditions.checkArgument(location != null, "location cannot be null");
+-        if (location.getWorld() != this.getWorld()) {
+-            return;
+-        }
+ 
+         BlockPos blockPosition = CraftLocation.toBlockPosition(location);
+-        this.getHandle().getBrain().setMemory(MemoryModuleType.SNIFFER_EXPLORED_POSITIONS, this.getHandle().getExploredPositions().filter(blockPositionExplored -> !blockPositionExplored.equals(blockPosition)).collect(Collectors.toList()));
+        // Paper start
+        net.minecraft.world.level.Level level = location.getWorld() != null ? ((org.bukkit.craftbukkit.CraftWorld) location.getWorld()).getHandle() : this.getHandle().level();
+        net.minecraft.core.GlobalPos globalPos = net.minecraft.core.GlobalPos.of(level.dimension(), blockPosition);
+        this.getHandle().getBrain().setMemory(MemoryModuleType.SNIFFER_EXPLORED_POSITIONS, this.getHandle().getExploredPositions().filter(blockPositionExplored -> !blockPositionExplored.equals(globalPos)).collect(Collectors.toList()));
+        // Paper end
+     }
+ 
+     @Override
--- a/patches/server/0949-Add-method-to-remove-all-active-potion-effects.patch
+++ b/patches/server/0949-Add-method-to-remove-all-active-potion-effects.patch
@ -0,0 +1,24 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Sat, 17 Jun 2023 13:17:25 -0700
+Subject: [PATCH] Add method to remove all active potion effects
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+index c7381ceae2d15738b72d6bb48ea7d40f7de11c3e..ba2cd9c4cdbd5ddab1300320d7e0ede4d4b7a31a 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+@@ -504,6 +504,13 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
+         return effects;
+     }
+ 
+    // Paper start - LivingEntity#clearActivePotionEffects();
+    @Override
+    public boolean clearActivePotionEffects() {
+        return this.getHandle().removeAllEffects(EntityPotionEffectEvent.Cause.PLUGIN);
+    }
+    // Paper end
+
+     @Override
+     public <T extends Projectile> T launchProjectile(Class<? extends T> projectile) {
+         return this.launchProjectile(projectile, null);
--- a/patches/server/0950-Temp-Pre-init-PlayerChunkLoaderData-in-order-to-prep.patch
+++ b/patches/server/0950-Temp-Pre-init-PlayerChunkLoaderData-in-order-to-prep.patch
@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Shane Freeder <theboyetronic@gmail.com>
+Date: Sun, 18 Jun 2023 13:48:11 +0100
+Subject: [PATCH] Temp: Pre-init PlayerChunkLoaderData in order to prepopulate
+ the BFS lookup cache because potatos
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/Main.java b/src/main/java/org/bukkit/craftbukkit/Main.java
+index f37ac6edc60545600ccd22bfac072585d11b449b..4b457cbfc56e55e0ae0fee5b69e2e75349702aab 100644
+--- a/src/main/java/org/bukkit/craftbukkit/Main.java
+++ b/src/main/java/org/bukkit/craftbukkit/Main.java
+@@ -368,6 +368,7 @@ public class Main {
+             tryPreloadClass(net.minecraft.world.level.lighting.LayerLightEventListener.DummyLightLayerEventListener.class.getName());
+             tryPreloadClass(net.minecraft.world.level.lighting.LayerLightEventListener.class.getName());
+             tryPreloadClass(net.minecraft.util.ExceptionCollector.class.getName());
+            tryPreloadClass(io.papermc.paper.chunk.system.RegionizedPlayerChunkLoader.PlayerChunkLoaderData.class.getName());
+             // Paper end
+         }
+     }
--- a/patches/server/0951-Fix-incorrect-crafting-result-amount-for-fireworks.patch
+++ b/patches/server/0951-Fix-incorrect-crafting-result-amount-for-fireworks.patch
@ -0,0 +1,20 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Redned <redned235@gmail.com>
+Date: Mon, 12 Jun 2023 11:54:12 -0500
+Subject: [PATCH] Fix incorrect crafting result amount for fireworks
+
+Although vanilla does not specifically call this method anywhere, this fixes a bug where the result using the Bukkit API returns the wrong amount.
+
+diff --git a/src/main/java/net/minecraft/world/item/crafting/FireworkRocketRecipe.java b/src/main/java/net/minecraft/world/item/crafting/FireworkRocketRecipe.java
+index af7e7a63eacad2367453924806ffb002c33db951..25405c8eb76e428e689b3afad2c00529f687f550 100644
+--- a/src/main/java/net/minecraft/world/item/crafting/FireworkRocketRecipe.java
+++ b/src/main/java/net/minecraft/world/item/crafting/FireworkRocketRecipe.java
+@@ -81,7 +81,7 @@ public class FireworkRocketRecipe extends CustomRecipe {
+ 
+     @Override
+     public ItemStack getResultItem(RegistryAccess registryManager) {
+-        return new ItemStack(Items.FIREWORK_ROCKET);
+        return new ItemStack(Items.FIREWORK_ROCKET, 3); // Paper - Fix incorrect crafting result amount
+     }
+ 
+     @Override
--- a/patches/server/0952-Properly-Cancel-Usable-Items.patch
+++ b/patches/server/0952-Properly-Cancel-Usable-Items.patch
@ -0,0 +1,63 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com>
+Date: Tue, 23 May 2023 22:33:36 -0400
+Subject: [PATCH] Properly Cancel Usable Items
+
+This fixes the bug causing cancelling PlayerInteractEvent to cause items to continue to be used despite being cancelled on the server.
+
+For example, items being consumed but never finishing, shields being put up, etc.
+The underlying issue of this is that the client modifies their synced data values, and so we have to (forcibly) resend
+them in order for the client to reset their using item state.
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
+index f58386e952d29a16d160b628a23efbe102791277..82f26186156a487f29ad3abff3f68852e5b8a1f9 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
+++ b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
+@@ -557,6 +557,7 @@ public class ServerPlayerGameMode {
+             }
+             // Paper end - extend Player Interact cancellation
+             player.getBukkitEntity().updateInventory(); // SPIGOT-2867
+            this.player.resyncUsingItem(this.player); // Paper - Resend player's using item status
+             enuminteractionresult = (event.useItemInHand() != Event.Result.ALLOW) ? InteractionResult.SUCCESS : InteractionResult.PASS;
+         } else if (this.gameModeForPlayer == GameType.SPECTATOR) {
+             MenuProvider itileinventory = iblockdata.getMenuProvider(world, blockposition);
+@@ -600,6 +601,11 @@ public class ServerPlayerGameMode {
+ 
+                 return enuminteractionresult1;
+             }
+            // Paper start - Cancel only if cancelled + if the interact result is different from default response
+            else if (this.interactResult && this.interactResult != cancelledItem) {
+                this.player.resyncUsingItem(this.player);
+            }
+            // Paper end
+         }
+         return enuminteractionresult;
+         // CraftBukkit end
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index 28c61453d37132f9bab143202b7d59d368020f6a..09e5d0790b87a4747dd50eb790cdd1ce83de2550 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -1951,6 +1951,7 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+             }
+ 
+             if (cancelled) {
+                this.player.resyncUsingItem(this.player); // Paper - Resend player's using item status
+                 this.player.getBukkitEntity().updateInventory(); // SPIGOT-2524
+                 return;
+             }
+diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+index f359f63ac8cf3133b63096dad4e3142c6c4b1cbf..bed0a01be1703aad8fbfa549d5799e3f84759f32 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
+++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -3813,6 +3813,11 @@ public abstract class LivingEntity extends Entity implements Attackable {
+         return ((Byte) this.entityData.get(LivingEntity.DATA_LIVING_ENTITY_FLAGS) & 2) > 0 ? InteractionHand.OFF_HAND : InteractionHand.MAIN_HAND;
+     }
+ 
+    // Paper start
+    public void resyncUsingItem(ServerPlayer serverPlayer) {
+        this.getEntityData().resendPossiblyDesyncedDataValues(java.util.List.of(DATA_LIVING_ENTITY_FLAGS), serverPlayer);
+    }
+    // Paper end
+     private void updatingUsingItem() {
+         if (this.isUsingItem()) {
+             if (ItemStack.isSameItem(this.getItemInHand(this.getUsedItemHand()), this.useItem)) {
--- a/patches/server/0953-Add-event-for-player-editing-sign.patch
+++ b/patches/server/0953-Add-event-for-player-editing-sign.patch
@ -0,0 +1,93 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: by77er <by77er@gmail.com>
+Date: Mon, 12 Jun 2023 12:56:46 -0400
+Subject: [PATCH] Add event for player editing sign
+
+
+diff --git a/src/main/java/net/minecraft/world/item/ItemStack.java b/src/main/java/net/minecraft/world/item/ItemStack.java
+index ef2f9cae4b06a020f0b9209b69316733df055438..d4df53d022eb58cf43d787ed84bd94fdf1684d69 100644
+--- a/src/main/java/net/minecraft/world/item/ItemStack.java
+++ b/src/main/java/net/minecraft/world/item/ItemStack.java
+@@ -523,7 +523,7 @@ public final class ItemStack {
+                         try {
+                             if (world.getBlockEntity(SignItem.openSign) instanceof SignBlockEntity tileentitysign) {
+                                 if (world.getBlockState(SignItem.openSign).getBlock() instanceof SignBlock blocksign) {
+-                                    blocksign.openTextEdit(entityhuman, tileentitysign, true, org.bukkit.event.player.PlayerSignOpenEvent.Cause.PLACE); // Craftbukkit
+                                    blocksign.openTextEdit(entityhuman, tileentitysign, true, io.papermc.paper.event.player.PlayerOpenSignEvent.Cause.PLACE); // Paper
+                                 }
+                             }
+                         } finally {
+diff --git a/src/main/java/net/minecraft/world/level/block/SignBlock.java b/src/main/java/net/minecraft/world/level/block/SignBlock.java
+index 8d7295a949280f233d12d24894cd9dd07af1e325..28cba43e42354b87e08ef87b70c274a2fdc0bb48 100644
+--- a/src/main/java/net/minecraft/world/level/block/SignBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/SignBlock.java
+@@ -118,7 +118,7 @@ public abstract class SignBlock extends BaseEntityBlock implements SimpleWaterlo
+                 } else if (flag2) {
+                     return InteractionResult.SUCCESS;
+                 } else if (!this.otherPlayerIsEditingSign(player, tileentitysign) && player.mayBuild() && this.hasEditableText(player, tileentitysign, flag1)) {
+-                    this.openTextEdit(player, tileentitysign, flag1, org.bukkit.event.player.PlayerSignOpenEvent.Cause.INTERACT); // CraftBukkit
+                    this.openTextEdit(player, tileentitysign, flag1, io.papermc.paper.event.player.PlayerOpenSignEvent.Cause.INTERACT); // Paper
+                     return this.getInteractionResult(flag);
+                 } else {
+                     return InteractionResult.PASS;
+@@ -170,16 +170,33 @@ public abstract class SignBlock extends BaseEntityBlock implements SimpleWaterlo
+         return blockpropertywood;
+     }
+ 
+    @io.papermc.paper.annotation.DoNotUse @Deprecated // Paper
+     public void openTextEdit(Player player, SignBlockEntity blockEntity, boolean front) {
+-        // Craftbukkit start
+-        this.openTextEdit(player, blockEntity, front, org.bukkit.event.player.PlayerSignOpenEvent.Cause.UNKNOWN);
+-    }
+-
+-    public void openTextEdit(Player entityhuman, SignBlockEntity tileentitysign, boolean flag, org.bukkit.event.player.PlayerSignOpenEvent.Cause cause) {
+-        if (!org.bukkit.craftbukkit.event.CraftEventFactory.callPlayerSignOpenEvent(entityhuman, tileentitysign, flag, cause)) {
+        // Paper start - PlayerOpenSignEvent
+        this.openTextEdit(player, blockEntity, front, io.papermc.paper.event.player.PlayerOpenSignEvent.Cause.UNKNOWN);
+    }
+    public void openTextEdit(Player entityhuman, SignBlockEntity tileentitysign, boolean flag, io.papermc.paper.event.player.PlayerOpenSignEvent.Cause cause) {
+        org.bukkit.entity.Player bukkitPlayer = (org.bukkit.entity.Player) entityhuman.getBukkitEntity();
+        org.bukkit.block.Block bukkitBlock = org.bukkit.craftbukkit.block.CraftBlock.at(tileentitysign.getLevel(), tileentitysign.getBlockPos());
+        org.bukkit.craftbukkit.block.CraftSign<?> bukkitSign = (org.bukkit.craftbukkit.block.CraftSign<?>) org.bukkit.craftbukkit.block.CraftBlockStates.getBlockState(bukkitBlock);
+        io.papermc.paper.event.player.PlayerOpenSignEvent event = new io.papermc.paper.event.player.PlayerOpenSignEvent(
+            bukkitPlayer,
+            bukkitSign,
+            flag ? org.bukkit.block.sign.Side.FRONT : org.bukkit.block.sign.Side.BACK,
+            cause);
+        if (!event.callEvent()) return;
+        if (org.bukkit.event.player.PlayerSignOpenEvent.getHandlerList().getRegisteredListeners().length > 0) {
+            final org.bukkit.event.player.PlayerSignOpenEvent.Cause legacyCause = switch (cause) {
+                case PLACE -> org.bukkit.event.player.PlayerSignOpenEvent.Cause.PLACE;
+                case PLUGIN -> org.bukkit.event.player.PlayerSignOpenEvent.Cause.PLUGIN;
+                case INTERACT -> org.bukkit.event.player.PlayerSignOpenEvent.Cause.INTERACT;
+                case UNKNOWN -> org.bukkit.event.player.PlayerSignOpenEvent.Cause.UNKNOWN;
+            };
+        // Paper end - PlayerOpenSignEvent
+        if (!org.bukkit.craftbukkit.event.CraftEventFactory.callPlayerSignOpenEvent(entityhuman, tileentitysign, flag, legacyCause)) { // Paper
+             return;
+         }
+-        // Craftbukkit end
+        } // Paper
+         tileentitysign.setAllowedPlayerEditor(entityhuman.getUUID());
+         entityhuman.openTextEdit(tileentitysign, flag);
+     }
+diff --git a/src/main/java/org/bukkit/craftbukkit/block/CraftSign.java b/src/main/java/org/bukkit/craftbukkit/block/CraftSign.java
+index 94caa0915e1a9ec1c46c7a0380db840901cc8063..3b33aed51a84ee30b1e7bceecb0d3840866e0748 100644
+--- a/src/main/java/org/bukkit/craftbukkit/block/CraftSign.java
+++ b/src/main/java/org/bukkit/craftbukkit/block/CraftSign.java
+@@ -139,9 +139,15 @@ public class CraftSign<T extends SignBlockEntity> extends CraftBlockEntityState<
+         Preconditions.checkArgument(sign.isPlaced(), "Sign must be placed");
+         Preconditions.checkArgument(sign.getWorld() == player.getWorld(), "Sign must be in same world as Player");
+ 
+        // Paper start
+        io.papermc.paper.event.player.PlayerOpenSignEvent event = new io.papermc.paper.event.player.PlayerOpenSignEvent((Player) player, sign, side, io.papermc.paper.event.player.PlayerOpenSignEvent.Cause.PLUGIN);
+        if (!event.callEvent()) return;
+        if (PlayerSignOpenEvent.getHandlerList().getRegisteredListeners().length > 0) {
+            // Paper end
+         if (!CraftEventFactory.callPlayerSignOpenEvent(player, sign, side, PlayerSignOpenEvent.Cause.PLUGIN)) {
+             return;
+         }
+        } // Paper
+ 
+         SignBlockEntity handle = ((CraftSign<?>) sign).getTileEntity();
+         handle.setAllowedPlayerEditor(player.getUniqueId());
--- a/patches/server/0954-Only-tick-item-frames-if-players-can-see-it.patch
+++ b/patches/server/0954-Only-tick-item-frames-if-players-can-see-it.patch
@ -0,0 +1,20 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Redned <redned235@gmail.com>
+Date: Mon, 19 Jun 2023 15:45:53 -0500
+Subject: [PATCH] Only tick item frames if players can see it
+
+In the event that an item frame cannot be seen by any players, ticking the item frame every tick is unnecessary. This can be a very hot section of the entity tracker when lots of item frames are present on a server, so this reduces the logic which speeds it up.
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerEntity.java b/src/main/java/net/minecraft/server/level/ServerEntity.java
+index 9d5d32705f9d8aadb51019f17b4db76a9bc6a04b..625a598eb5f3c9c5ea60ae9ea50974bb08abbf85 100644
+--- a/src/main/java/net/minecraft/server/level/ServerEntity.java
+++ b/src/main/java/net/minecraft/server/level/ServerEntity.java
+@@ -111,7 +111,7 @@ public class ServerEntity {
+ 
+         Entity entity = this.entity;
+ 
+-        if (entity instanceof ItemFrame) {
+        if (!this.trackedPlayers.isEmpty() && entity instanceof ItemFrame) { // Paper - Only tick item frames if players can see it
+             ItemFrame entityitemframe = (ItemFrame) entity;
+ 
+             if (true || this.tickCount % 10 == 0) { // CraftBukkit - Moved below, should always enter this block
--- a/patches/server/0955-Improve-command-function-perm-level-checks.patch
+++ b/patches/server/0955-Improve-command-function-perm-level-checks.patch
@ -0,0 +1,27 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Tue, 27 Jun 2023 16:32:39 -0700
+Subject: [PATCH] Improve command function perm level checks
+
+
+diff --git a/src/main/java/net/minecraft/commands/CommandSourceStack.java b/src/main/java/net/minecraft/commands/CommandSourceStack.java
+index 20b2cbbc73f6420b6ace9746016527b90d9f01b9..14f4c0a93372a58cf36dc95265b5e210ea1605e5 100644
+--- a/src/main/java/net/minecraft/commands/CommandSourceStack.java
+++ b/src/main/java/net/minecraft/commands/CommandSourceStack.java
+@@ -206,8 +206,14 @@ public class CommandSourceStack implements ExecutionCommandSource<CommandSourceS
+ 
+     // CraftBukkit start
+     public boolean hasPermission(int i, String bukkitPermission) {
+-        // World is null when loading functions
+-        return ((this.getLevel() == null || !this.getLevel().getCraftServer().ignoreVanillaPermissions) && this.permissionLevel >= i) || this.getBukkitSender().hasPermission(bukkitPermission);
+        // Paper start
+        boolean hasPermissionLevel = this.permissionLevel >= i;
+        if (this.source == CommandSource.NULL) {
+            return hasPermissionLevel;
+        } else {
+            return (!this.getLevel().getCraftServer().ignoreVanillaPermissions && hasPermissionLevel) || this.getBukkitSender().hasPermission(bukkitPermission);
+        }
+        // Paper end
+     }
+     // CraftBukkit end
+ 
--- a/patches/server/0956-Add-option-to-disable-block-updates.patch
+++ b/patches/server/0956-Add-option-to-disable-block-updates.patch
@ -0,0 +1,175 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Boy <sivertpaulsen2@gmail.com>
+Date: Sun, 18 Jun 2023 17:45:33 +0200
+Subject: [PATCH] Add option to disable block updates
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/ChorusPlantBlock.java b/src/main/java/net/minecraft/world/level/block/ChorusPlantBlock.java
+index a0f63f17eb4e4bcf986f0573dc13be5c11c37f15..d811ed3623446000d3aa0be59c573f7c759bf55a 100644
+--- a/src/main/java/net/minecraft/world/level/block/ChorusPlantBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/ChorusPlantBlock.java
+@@ -29,6 +29,7 @@ public class ChorusPlantBlock extends PipeBlock {
+ 
+     @Override
+     public BlockState getStateForPlacement(BlockPlaceContext ctx) {
+        if (io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableChorusPlantUpdates) return this.defaultBlockState(); // Paper - add option to disable block updates
+         return getStateWithConnections(ctx.getLevel(), ctx.getClickedPos(), this.defaultBlockState());
+     }
+ 
+@@ -45,6 +46,7 @@ public class ChorusPlantBlock extends PipeBlock {
+ 
+     @Override
+     public BlockState updateShape(BlockState state, Direction direction, BlockState neighborState, LevelAccessor world, BlockPos pos, BlockPos neighborPos) {
+        if (io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableChorusPlantUpdates) return state; // Paper - add option to disable block updates
+         if (!state.canSurvive(world, pos)) {
+             world.scheduleTick(pos, this, 1);
+             return super.updateShape(state, direction, neighborState, world, pos, neighborPos);
+@@ -56,6 +58,7 @@ public class ChorusPlantBlock extends PipeBlock {
+ 
+     @Override
+     public void tick(BlockState state, ServerLevel world, BlockPos pos, RandomSource random) {
+        if (io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableChorusPlantUpdates) return; // Paper - add option to disable block updates
+         if (!state.canSurvive(world, pos)) {
+             world.destroyBlock(pos, true);
+         }
+@@ -64,6 +67,7 @@ public class ChorusPlantBlock extends PipeBlock {
+ 
+     @Override
+     public boolean canSurvive(BlockState state, LevelReader world, BlockPos pos) {
+        if (io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableChorusPlantUpdates) return true; // Paper - add option to disable block updates
+         BlockState blockState = world.getBlockState(pos.below());
+         boolean bl = !world.getBlockState(pos.above()).isAir() && !blockState.isAir();
+ 
+diff --git a/src/main/java/net/minecraft/world/level/block/HugeMushroomBlock.java b/src/main/java/net/minecraft/world/level/block/HugeMushroomBlock.java
+index 4fe30b867d7fc39c53307496458b3e438d4f2397..e049e702f58053431bf3e438ea37850c86ae3b7b 100644
+--- a/src/main/java/net/minecraft/world/level/block/HugeMushroomBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/HugeMushroomBlock.java
+@@ -34,6 +34,7 @@ public class HugeMushroomBlock extends Block {
+ 
+     @Override
+     public BlockState getStateForPlacement(BlockPlaceContext ctx) {
+        if (io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableMushroomBlockUpdates) return this.defaultBlockState(); // Paper - add option to disable block updates
+         BlockGetter blockGetter = ctx.getLevel();
+         BlockPos blockPos = ctx.getClickedPos();
+         return this.defaultBlockState().setValue(DOWN, Boolean.valueOf(!blockGetter.getBlockState(blockPos.below()).is(this))).setValue(UP, Boolean.valueOf(!blockGetter.getBlockState(blockPos.above()).is(this))).setValue(NORTH, Boolean.valueOf(!blockGetter.getBlockState(blockPos.north()).is(this))).setValue(EAST, Boolean.valueOf(!blockGetter.getBlockState(blockPos.east()).is(this))).setValue(SOUTH, Boolean.valueOf(!blockGetter.getBlockState(blockPos.south()).is(this))).setValue(WEST, Boolean.valueOf(!blockGetter.getBlockState(blockPos.west()).is(this)));
+@@ -41,16 +42,19 @@ public class HugeMushroomBlock extends Block {
+ 
+     @Override
+     public BlockState updateShape(BlockState state, Direction direction, BlockState neighborState, LevelAccessor world, BlockPos pos, BlockPos neighborPos) {
+        if (io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableMushroomBlockUpdates) return state; // Paper - add option to disable block updates
+         return neighborState.is(this) ? state.setValue(PROPERTY_BY_DIRECTION.get(direction), Boolean.valueOf(false)) : super.updateShape(state, direction, neighborState, world, pos, neighborPos);
+     }
+ 
+     @Override
+     public BlockState rotate(BlockState state, Rotation rotation) {
+        if (io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableMushroomBlockUpdates) return state; // Paper - add option to disable block updates
+         return state.setValue(PROPERTY_BY_DIRECTION.get(rotation.rotate(Direction.NORTH)), state.getValue(NORTH)).setValue(PROPERTY_BY_DIRECTION.get(rotation.rotate(Direction.SOUTH)), state.getValue(SOUTH)).setValue(PROPERTY_BY_DIRECTION.get(rotation.rotate(Direction.EAST)), state.getValue(EAST)).setValue(PROPERTY_BY_DIRECTION.get(rotation.rotate(Direction.WEST)), state.getValue(WEST)).setValue(PROPERTY_BY_DIRECTION.get(rotation.rotate(Direction.UP)), state.getValue(UP)).setValue(PROPERTY_BY_DIRECTION.get(rotation.rotate(Direction.DOWN)), state.getValue(DOWN));
+     }
+ 
+     @Override
+     public BlockState mirror(BlockState state, Mirror mirror) {
+        if (io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableMushroomBlockUpdates) return state; // Paper - add option to disable block updates
+         return state.setValue(PROPERTY_BY_DIRECTION.get(mirror.mirror(Direction.NORTH)), state.getValue(NORTH)).setValue(PROPERTY_BY_DIRECTION.get(mirror.mirror(Direction.SOUTH)), state.getValue(SOUTH)).setValue(PROPERTY_BY_DIRECTION.get(mirror.mirror(Direction.EAST)), state.getValue(EAST)).setValue(PROPERTY_BY_DIRECTION.get(mirror.mirror(Direction.WEST)), state.getValue(WEST)).setValue(PROPERTY_BY_DIRECTION.get(mirror.mirror(Direction.UP)), state.getValue(UP)).setValue(PROPERTY_BY_DIRECTION.get(mirror.mirror(Direction.DOWN)), state.getValue(DOWN));
+     }
+ 
+diff --git a/src/main/java/net/minecraft/world/level/block/NoteBlock.java b/src/main/java/net/minecraft/world/level/block/NoteBlock.java
+index f32334f9e0f13a227bef8ffb135dda82b2ec39f2..ff16075fbfe664c73a46bc4b002450867974114e 100644
+--- a/src/main/java/net/minecraft/world/level/block/NoteBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/NoteBlock.java
+@@ -65,11 +65,13 @@ public class NoteBlock extends Block {
+ 
+     @Override
+     public BlockState getStateForPlacement(BlockPlaceContext ctx) {
+        if (io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableNoteblockUpdates) return this.defaultBlockState(); // Paper - place without considering instrument
+         return this.setInstrument(ctx.getLevel(), ctx.getClickedPos(), this.defaultBlockState());
+     }
+ 
+     @Override
+     public BlockState updateShape(BlockState state, Direction direction, BlockState neighborState, LevelAccessor world, BlockPos pos, BlockPos neighborPos) {
+        if (io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableNoteblockUpdates) return state; // Paper - prevent noteblock instrument from updating
+         boolean flag = direction.getAxis() == Direction.Axis.Y;
+ 
+         return flag ? this.setInstrument(world, pos, state) : super.updateShape(state, direction, neighborState, world, pos, neighborPos);
+@@ -77,6 +79,7 @@ public class NoteBlock extends Block {
+ 
+     @Override
+     public void neighborChanged(BlockState state, Level world, BlockPos pos, Block sourceBlock, BlockPos sourcePos, boolean notify) {
+        if (io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableNoteblockUpdates) return; // Paper - prevent noteblock powered-state from updating
+         boolean flag1 = world.hasNeighborSignal(pos);
+ 
+         if (flag1 != (Boolean) state.getValue(NoteBlock.POWERED)) {
+@@ -114,7 +117,7 @@ public class NoteBlock extends Block {
+         } else if (world.isClientSide) {
+             return InteractionResult.SUCCESS;
+         } else {
+-            state = (BlockState) state.cycle(NoteBlock.NOTE);
+            if (!io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableNoteblockUpdates) state = (BlockState) state.cycle(NoteBlock.NOTE); // Paper - prevent noteblock note from updating
+             world.setBlock(pos, state, 3);
+             this.playNote(player, state, world, pos);
+             player.awardStat(Stats.TUNE_NOTEBLOCK);
+diff --git a/src/main/java/net/minecraft/world/level/block/TripWireBlock.java b/src/main/java/net/minecraft/world/level/block/TripWireBlock.java
+index 1a0c5fb62e80681604110e95c1ae7b3684c21946..2f947997ca746d18544940ef67ff550a95946edd 100644
+--- a/src/main/java/net/minecraft/world/level/block/TripWireBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/TripWireBlock.java
+@@ -66,6 +66,7 @@ public class TripWireBlock extends Block {
+ 
+     @Override
+     public BlockState getStateForPlacement(BlockPlaceContext ctx) {
+        if (io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableTripwireUpdates) return this.defaultBlockState(); // Paper - place tripwire without updating
+         Level world = ctx.getLevel();
+         BlockPos blockposition = ctx.getClickedPos();
+ 
+@@ -74,11 +75,13 @@ public class TripWireBlock extends Block {
+ 
+     @Override
+     public BlockState updateShape(BlockState state, Direction direction, BlockState neighborState, LevelAccessor world, BlockPos pos, BlockPos neighborPos) {
+        if (io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableTripwireUpdates) return state; // Paper - prevent tripwire from updating
+         return direction.getAxis().isHorizontal() ? (BlockState) state.setValue((Property) TripWireBlock.PROPERTY_BY_DIRECTION.get(direction), this.shouldConnectTo(neighborState, direction)) : super.updateShape(state, direction, neighborState, world, pos, neighborPos);
+     }
+ 
+     @Override
+     public void onPlace(BlockState state, Level world, BlockPos pos, BlockState oldState, boolean notify) {
+        if (io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableTripwireUpdates) return; // Paper - prevent adjacent tripwires from updating
+         if (!oldState.is(state.getBlock())) {
+             this.updateSource(world, pos, state);
+         }
+@@ -86,6 +89,7 @@ public class TripWireBlock extends Block {
+ 
+     @Override
+     public void onRemove(BlockState state, Level world, BlockPos pos, BlockState newState, boolean moved) {
+        if (io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableTripwireUpdates) return; // Paper - prevent adjacent tripwires from updating
+         if (!moved && !state.is(newState.getBlock())) {
+             this.updateSource(world, pos, (BlockState) state.setValue(TripWireBlock.POWERED, true), true); // Paper - fix state inconsistency
+         }
+@@ -93,6 +97,7 @@ public class TripWireBlock extends Block {
+ 
+     @Override
+     public BlockState playerWillDestroy(Level world, BlockPos pos, BlockState state, Player player) {
+        if (io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableTripwireUpdates) return state; // Paper - prevent disarming tripwires
+         if (!world.isClientSide && !player.getMainHandItem().isEmpty() && player.getMainHandItem().is(Items.SHEARS)) {
+             world.setBlock(pos, (BlockState) state.setValue(TripWireBlock.DISARMED, true), 4);
+             world.gameEvent((Entity) player, GameEvent.SHEAR, pos);
+@@ -102,6 +107,7 @@ public class TripWireBlock extends Block {
+     }
+ 
+     private void updateSource(Level world, BlockPos pos, BlockState state) {
+        if (io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableTripwireUpdates) return; // Paper - prevent adjacent tripwires from updating
+         // Paper start - fix state inconsistency
+         this.updateSource(world, pos, state, false);
+     }
+@@ -140,6 +146,7 @@ public class TripWireBlock extends Block {
+ 
+     @Override
+     public void entityInside(BlockState state, Level world, BlockPos pos, Entity entity) {
+        if (io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableTripwireUpdates) return; // Paper - prevent tripwires from detecting collision
+         if (!new io.papermc.paper.event.entity.EntityInsideBlockEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(world, pos)).callEvent()) { return; } // Paper
+         if (!world.isClientSide) {
+             if (!(Boolean) state.getValue(TripWireBlock.POWERED)) {
+@@ -150,6 +157,7 @@ public class TripWireBlock extends Block {
+ 
+     @Override
+     public void tick(BlockState state, ServerLevel world, BlockPos pos, RandomSource random) {
+        if (io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableTripwireUpdates) return; // Paper - prevent tripwire pressed check
+         if ((Boolean) world.getBlockState(pos).getValue(TripWireBlock.POWERED)) {
+             this.checkPressed(world, pos);
+         }
--- a/patches/server/0957-Call-missing-BlockDispenseEvent.patch
+++ b/patches/server/0957-Call-missing-BlockDispenseEvent.patch
@ -0,0 +1,88 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Lulu13022002 <41980282+Lulu13022002@users.noreply.github.com>
+Date: Sat, 29 Oct 2022 15:41:56 +0200
+Subject: [PATCH] Call missing BlockDispenseEvent
+
+
+diff --git a/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java b/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java
+index dd017c33ff89a516022378160410bc41cce9222e..105bb94b844c5ee85b53aca95360e7b2caf374cc 100644
+--- a/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java
+++ b/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java
+@@ -1114,6 +1114,13 @@ public interface DispenseItemBehavior {
+                 this.setSuccess(true);
+                 if (iblockdata.is(Blocks.RESPAWN_ANCHOR)) {
+                     if ((Integer) iblockdata.getValue(RespawnAnchorBlock.CHARGE) != 4) {
+                        // Paper start
+                        ItemStack result = org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockDispenseEvent(pointer, blockposition, stack, this);
+                        if (result != null) {
+                            this.setSuccess(false);
+                            return result;
+                        }
+                        // Paper end
+                         RespawnAnchorBlock.charge((Entity) null, worldserver, blockposition, iblockdata);
+                         stack.shrink(1);
+                     } else {
+@@ -1136,6 +1143,13 @@ public interface DispenseItemBehavior {
+                 Optional<BlockState> optional = HoneycombItem.getWaxed(iblockdata);
+ 
+                 if (optional.isPresent()) {
+                    // Paper start
+                    ItemStack result = org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockDispenseEvent(pointer, blockposition, stack, this);
+                    if (result != null) {
+                        this.setSuccess(false);
+                        return result;
+                    }
+                    // Paper end
+                     worldserver.setBlockAndUpdate(blockposition, (BlockState) optional.get());
+                     worldserver.levelEvent(3003, blockposition, 0);
+                     stack.shrink(1);
+@@ -1161,6 +1175,12 @@ public interface DispenseItemBehavior {
+                     if (!worldserver.getBlockState(blockposition1).is(BlockTags.CONVERTABLE_TO_MUD)) {
+                         return this.defaultDispenseItemBehavior.dispense(pointer, stack);
+                     } else {
+                        // Paper start
+                        ItemStack result = org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockDispenseEvent(pointer, blockposition1, stack, this);
+                        if (result != null) {
+                            return result;
+                        }
+                        // Paper end
+                         if (!worldserver.isClientSide) {
+                             for (int k = 0; k < 5; ++k) {
+                                 worldserver.sendParticles(ParticleTypes.SPLASH, (double) blockposition.getX() + worldserver.random.nextDouble(), (double) (blockposition.getY() + 1), (double) blockposition.getZ() + worldserver.random.nextDouble(), 1, 0.0D, 0.0D, 0.0D, 1.0D);
+diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+index 4c14bcf9396b4ee9649c4647b485797f6fce06f3..e4551a6d984928457af4fb6cc2d0bf3673ef8fb1 100644
+--- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+@@ -2101,6 +2101,32 @@ public class CraftEventFactory {
+     }
+     // Paper end
+ 
+    // Paper start - missing BlockDispenseEvent calls
+    @Nullable
+    public static ItemStack handleBlockDispenseEvent(net.minecraft.core.dispenser.BlockSource pointer, BlockPos to, ItemStack itemStack, net.minecraft.core.dispenser.DispenseItemBehavior instance) {
+        org.bukkit.block.Block bukkitBlock = pointer.level().getWorld().getBlockAt(pointer.pos().getX(), pointer.pos().getY(), pointer.pos().getZ());
+        CraftItemStack craftItem = CraftItemStack.asCraftMirror(itemStack.copyWithCount(1));
+
+        org.bukkit.event.block.BlockDispenseEvent event = new org.bukkit.event.block.BlockDispenseEvent(bukkitBlock, craftItem.clone(), new org.bukkit.util.Vector(to.getX(), to.getY(), to.getZ()));
+        if (!net.minecraft.world.level.block.DispenserBlock.eventFired) {
+            if (!event.callEvent()) {
+                return itemStack;
+            }
+        }
+
+        if (!event.getItem().equals(craftItem)) {
+            // Chain to handler for new item
+            ItemStack eventStack = CraftItemStack.asNMSCopy(event.getItem());
+            net.minecraft.core.dispenser.DispenseItemBehavior idispensebehavior = net.minecraft.world.level.block.DispenserBlock.DISPENSER_REGISTRY.get(eventStack.getItem());
+            if (idispensebehavior != net.minecraft.core.dispenser.DispenseItemBehavior.NOOP && idispensebehavior != instance) {
+                idispensebehavior.dispense(pointer, eventStack);
+                return itemStack;
+            }
+        }
+        return null;
+    }
+    // Paper end - missing BlockDispenseEvent calls
+
+     // Paper start - add EntityFertilizeEggEvent
+     /**
+      * Calls the io.papermc.paper.event.entity.EntityFertilizeEggEvent.
--- a/patches/server/0958-Don-t-load-chunks-for-supporting-block-checks.patch
+++ b/patches/server/0958-Don-t-load-chunks-for-supporting-block-checks.patch
@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Shane Freeder <theboyetronic@gmail.com>
+Date: Wed, 5 Jul 2023 23:11:53 +0100
+Subject: [PATCH] Don't load chunks for supporting block checks
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index dfa077ad2e632bc71be41917d5923edae12f7738..36a6eb05f983f0137590c8ed1ec154affd9cdbd3 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
+++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -1361,7 +1361,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+     }
+ 
+     protected BlockPos getOnPos(float offset) {
+-        if (this.mainSupportingBlockPos.isPresent()) {
+        if (this.mainSupportingBlockPos.isPresent() && this.level().getChunkIfLoadedImmediately(this.mainSupportingBlockPos.get()) != null) { // Paper - ensure no loads
+             BlockPos blockposition = (BlockPos) this.mainSupportingBlockPos.get();
+ 
+             if (offset <= 1.0E-5F) {
--- a/patches/server/0959-Optimize-player-lookups-for-beacons.patch
+++ b/patches/server/0959-Optimize-player-lookups-for-beacons.patch
@ -0,0 +1,36 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Spottedleaf <Spottedleaf@users.noreply.github.com>
+Date: Thu, 6 Jul 2023 20:17:37 -0700
+Subject: [PATCH] Optimize player lookups for beacons
+
+For larger ranges, it's better to iterate over the player list
+than the entity slices.
+
+diff --git a/src/main/java/net/minecraft/world/level/block/entity/BeaconBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/BeaconBlockEntity.java
+index 2f12a1054c9c9e311e02dc5c3244ad3688db15ba..f13943db6f2fb923c52dcf9e8bf7000041d0a362 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/BeaconBlockEntity.java
+++ b/src/main/java/net/minecraft/world/level/block/entity/BeaconBlockEntity.java
+@@ -329,7 +329,22 @@ public class BeaconBlockEntity extends BlockEntity implements MenuProvider, Name
+             double d0 = blockEntity != null ? blockEntity.getEffectRange() : (i * 10 + 10);// Paper - custom beacon ranges
+ 
+             AABB axisalignedbb = (new AABB(blockposition)).inflate(d0).expandTowards(0.0D, (double) world.getHeight(), 0.0D);
+-            List<Player> list = world.getEntitiesOfClass(Player.class, axisalignedbb);
+            // Paper start - optimize player lookup for beacons
+            List<Player> list;
+            if (d0 <= 128.0) {
+                list = world.getEntitiesOfClass(Player.class, axisalignedbb);
+            } else {
+                list = new java.util.ArrayList<>();
+                for (Player player : world.players()) {
+                    if (player.isSpectator()) {
+                        continue;
+                    }
+                    if (player.getBoundingBox().intersects(axisalignedbb)) {
+                        list.add(player);
+                    }
+                }
+            }
+            // Paper end - optimize player lookup for beacons
+ 
+             return list;
+         }
--- a/patches/server/0960-Add-Sign-getInteractableSideFor.patch
+++ b/patches/server/0960-Add-Sign-getInteractableSideFor.patch
@ -0,0 +1,50 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Fri, 23 Jun 2023 12:16:28 -0700
+Subject: [PATCH] Add Sign#getInteractableSideFor
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/entity/SignBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/SignBlockEntity.java
+index 6a876198008d4c6487e96989c38c331b71818ad3..68f95a8eb4aa659e62394bf98ecd5f5d46879cbf 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/SignBlockEntity.java
+++ b/src/main/java/net/minecraft/world/level/block/entity/SignBlockEntity.java
+@@ -66,13 +66,18 @@ public class SignBlockEntity extends BlockEntity implements CommandSource { // C
+     }
+ 
+     public boolean isFacingFrontText(net.minecraft.world.entity.player.Player player) {
+        // Paper start
+        return this.isFacingFrontText(player.getX(), player.getZ());
+    }
+    public boolean isFacingFrontText(double x, double z) {
+        // Paper end
+         Block block = this.getBlockState().getBlock();
+ 
+         if (block instanceof SignBlock) {
+             SignBlock blocksign = (SignBlock) block;
+             Vec3 vec3d = blocksign.getSignHitboxCenterPosition(this.getBlockState());
+-            double d0 = player.getX() - ((double) this.getBlockPos().getX() + vec3d.x);
+-            double d1 = player.getZ() - ((double) this.getBlockPos().getZ() + vec3d.z);
+            double d0 = x - ((double) this.getBlockPos().getX() + vec3d.x); // Paper
+            double d1 = z - ((double) this.getBlockPos().getZ() + vec3d.z); // Paper
+             float f = blocksign.getYRotationDegrees(this.getBlockState());
+             float f1 = (float) (Mth.atan2(d1, d0) * 57.2957763671875D) - 90.0F;
+ 
+diff --git a/src/main/java/org/bukkit/craftbukkit/block/CraftSign.java b/src/main/java/org/bukkit/craftbukkit/block/CraftSign.java
+index 3b33aed51a84ee30b1e7bceecb0d3840866e0748..2a70c68af92967851f5caf8e67e433355ff48d44 100644
+--- a/src/main/java/org/bukkit/craftbukkit/block/CraftSign.java
+++ b/src/main/java/org/bukkit/craftbukkit/block/CraftSign.java
+@@ -169,6 +169,14 @@ public class CraftSign<T extends SignBlockEntity> extends CraftBlockEntityState<
+     }
+     // Paper end
+ 
+    // Paper start - side facing API
+    @Override
+    public Side getInteractableSideFor(final double x, final double z) {
+        this.requirePlaced();
+        return this.getSnapshot().isFacingFrontText(x, z) ? Side.FRONT : Side.BACK;
+    }
+    // Paper end
+
+     public static Component[] sanitizeLines(String[] lines) {
+         Component[] components = new Component[4];
+ 
--- a/patches/server/0961-Array-backed-synched-entity-data.patch
+++ b/patches/server/0961-Array-backed-synched-entity-data.patch
@ -0,0 +1,56 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: jellysquid3 <jellysquid3@users.noreply.github.com>
+Date: Sat, 8 Jul 2023 21:38:05 +0200
+Subject: [PATCH] Array backed synched entity data
+
+Original code by jellysquid3 in Lithium, licensed under the GNU Lesser General Public License v3.0 (https://www.gnu.org/licenses/lgpl-3.0.html)
+
+diff --git a/src/main/java/net/minecraft/network/syncher/SynchedEntityData.java b/src/main/java/net/minecraft/network/syncher/SynchedEntityData.java
+index ccb7d92b6c36b6225a2e640f8cea6c0da37464c8..a043c382c37058032548a5192e17f5f816abe5a6 100644
+--- a/src/main/java/net/minecraft/network/syncher/SynchedEntityData.java
+++ b/src/main/java/net/minecraft/network/syncher/SynchedEntityData.java
+@@ -34,6 +34,11 @@ public class SynchedEntityData {
+     private final Int2ObjectMap<SynchedEntityData.DataItem<?>> itemsById = new Int2ObjectOpenHashMap();
+     // private final ReadWriteLock lock = new ReentrantReadWriteLock(); // Spigot - not required
+     private boolean isDirty;
+    // Paper start - array backed synched entity data
+    private static final int DEFAULT_ENTRY_COUNT = 10;
+    private static final int GROW_FACTOR = 8;
+    private SynchedEntityData.DataItem<?>[] itemsArray = new SynchedEntityData.DataItem<?>[DEFAULT_ENTRY_COUNT];
+    // Paper end
+ 
+     public SynchedEntityData(Entity trackedEntity) {
+         this.entity = trackedEntity;
+@@ -103,6 +108,15 @@ public class SynchedEntityData {
+         // this.lock.writeLock().lock(); // Spigot - not required
+         this.itemsById.put(key.getId(), datawatcher_item);
+         // this.lock.writeLock().unlock(); // Spigot - not required
+        // Paper start - array backed synched entity data
+        if (this.itemsArray.length <= key.getId()) {
+            final int newSize = Math.min(key.getId() + GROW_FACTOR, MAX_ID_VALUE);
+
+            this.itemsArray = java.util.Arrays.copyOf(this.itemsArray, newSize);
+        }
+
+        this.itemsArray[key.getId()] = datawatcher_item;
+        // Paper end
+     }
+ 
+     public <T> boolean hasItem(EntityDataAccessor<T> key) {
+@@ -130,7 +144,15 @@ public class SynchedEntityData {
+ 
+         return datawatcher_item;
+         */
+-        return (SynchedEntityData.DataItem) this.itemsById.get(key.getId());
+        // Paper start - array backed synched entity data
+        final int id = key.getId();
+
+        if (id < 0 || id >= this.itemsArray.length) {
+            return null;
+        }
+
+        return (DataItem<T>) this.itemsArray[id];
+        // Paper end
+         // Spigot end
+     }
+ 
--- a/patches/server/0962-fix-item-meta-for-tadpole-buckets.patch
+++ b/patches/server/0962-fix-item-meta-for-tadpole-buckets.patch
@ -0,0 +1,74 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Tue, 11 Jul 2023 11:22:30 -0700
+Subject: [PATCH] fix item meta for tadpole buckets
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemFactory.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemFactory.java
+index 5f6b93be9e81df8fae9a5ab160a232b65ce7b8bc..c77634ec9c4e7a9eaacc81de7f95e9452b393a52 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemFactory.java
+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemFactory.java
+@@ -358,6 +358,7 @@ public final class CraftItemFactory implements ItemFactory {
+         case COD_BUCKET:
+         case PUFFERFISH_BUCKET:
+         case SALMON_BUCKET:
+        case TADPOLE_BUCKET: // Paper
+         case ITEM_FRAME:
+         case GLOW_ITEM_FRAME:
+         case PAINTING:
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java
+index 220ccd03d6f326b3747602e0e4e7ffee8173dc03..3660ad55cc7e1f6e571887aac9c0215803f1ce41 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java
+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java
+@@ -603,6 +603,7 @@ public final class CraftItemStack extends ItemStack {
+             case COD_BUCKET:
+             case PUFFERFISH_BUCKET:
+             case SALMON_BUCKET:
+            case TADPOLE_BUCKET: // Paper
+             case ITEM_FRAME:
+             case GLOW_ITEM_FRAME:
+             case PAINTING:
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaEntityTag.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaEntityTag.java
+index 6aa64334943a22da8cfcac88d48ae8156ad7a9b4..630e16403cb1fc0f4ba798993bb0c3139196a97c 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaEntityTag.java
+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaEntityTag.java
+@@ -16,6 +16,7 @@ public class CraftMetaEntityTag extends CraftMetaItem {
+             Material.COD_BUCKET,
+             Material.PUFFERFISH_BUCKET,
+             Material.SALMON_BUCKET,
+            Material.TADPOLE_BUCKET, // Paper
+             Material.ITEM_FRAME,
+             Material.GLOW_ITEM_FRAME,
+             Material.PAINTING
+diff --git a/src/test/java/org/bukkit/craftbukkit/inventory/ItemMetaTest.java b/src/test/java/org/bukkit/craftbukkit/inventory/ItemMetaTest.java
+index 937ddd3a2b9e1df2c8835079923c339178f08459..ceca8b6a4a11753bef7ad341c34ccda60114c6b5 100644
+--- a/src/test/java/org/bukkit/craftbukkit/inventory/ItemMetaTest.java
+++ b/src/test/java/org/bukkit/craftbukkit/inventory/ItemMetaTest.java
+@@ -236,6 +236,27 @@ public class ItemMetaTest extends AbstractTestingBase {
+         }
+     }
+ 
+    // Paper start - check entity tag metas
+    private static final java.util.Set<Class<?>> ENTITY_TAG_METAS = java.util.Set.of(
+        CraftMetaEntityTag.class,
+        CraftMetaTropicalFishBucket.class,
+        CraftMetaAxolotlBucket.class
+    );
+    @Test
+    public void testEntityTagMeta() {
+        for (final Item item : BuiltInRegistries.ITEM) {
+            if (item instanceof net.minecraft.world.item.HangingEntityItem || item instanceof net.minecraft.world.item.MobBucketItem) {
+                ItemStack stack = new ItemStack(CraftMagicNumbers.getMaterial(item));
+                assertTrue(ENTITY_TAG_METAS.contains(stack.getItemMeta().getClass()), "missing entity tag meta handling for " + item);
+                stack = CraftItemStack.asNewCraftStack(net.minecraft.world.item.Items.STONE);
+                stack.editMeta(meta -> meta.displayName(net.kyori.adventure.text.Component.text("hello")));
+                stack.setType(CraftMagicNumbers.getMaterial(item));
+                assertTrue(ENTITY_TAG_METAS.contains(stack.getItemMeta().getClass()), "missing entity tag meta handling for " + item);
+            }
+        }
+    }
+    // Paper end
+
+     @Test
+     public void testEachExtraData() {
+         final List<StackProvider> providers = Arrays.asList(
--- a/patches/server/0963-Suppress-Item-Meta-Validation-Checks.patch
+++ b/patches/server/0963-Suppress-Item-Meta-Validation-Checks.patch
@ -0,0 +1,86 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com>
+Date: Mon, 12 Jun 2023 14:42:49 -0400
+Subject: [PATCH] Suppress Item Meta Validation Checks
+
+In some cases ItemMeta could validate tags in an ItemStack. This suppresses those warnings and ignores reading the value.
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaArmor.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaArmor.java
+index f393e0844889c967d9e83d9a1e73c134fcb6e33b..f8996ee643a46db301577f6c523f24e973e8f309 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaArmor.java
+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaArmor.java
+@@ -68,13 +68,33 @@ public class CraftMetaArmor extends CraftMetaItem implements ArmorMeta {
+             CompoundTag trimCompound = tag.getCompound(CraftMetaArmor.TRIM.NBT);
+ 
+             if (trimCompound.contains(CraftMetaArmor.TRIM_MATERIAL.NBT, net.minecraft.nbt.Tag.TAG_STRING) && trimCompound.contains(CraftMetaArmor.TRIM_PATTERN.NBT, net.minecraft.nbt.Tag.TAG_STRING)) { // Paper - for now, ignore inline definitions of trim material & pattern
+-                TrimMaterial trimMaterial = Registry.TRIM_MATERIAL.get(NamespacedKey.fromString(trimCompound.getString(CraftMetaArmor.TRIM_MATERIAL.NBT)));
+-                TrimPattern trimPattern = Registry.TRIM_PATTERN.get(NamespacedKey.fromString(trimCompound.getString(CraftMetaArmor.TRIM_PATTERN.NBT)));
+                // Paper start
+                TrimMaterial trimMaterial = getRegistry(Registry.TRIM_MATERIAL, trimCompound.getString(TRIM_MATERIAL.NBT));
+                TrimPattern trimPattern = getRegistry(Registry.TRIM_PATTERN, trimCompound.getString(TRIM_PATTERN.NBT));
+                // Paper end
+ 
+-                this.trim = new ArmorTrim(trimMaterial, trimPattern);
+                this.trim = trimMaterial == null || trimPattern == null ? null : new ArmorTrim(trimMaterial, trimPattern); // Paper
+             }
+         }
+     }
+    // Paper start
+    public <T extends org.bukkit.Keyed> T getRegistry(Registry<T> registry, String value) {
+        if (value == null || value.isEmpty()) {
+            return null;
+        }
+        NamespacedKey namespacedKey = NamespacedKey.fromString(value);
+        if (namespacedKey == null) {
+            return null;
+        }
+
+        T registryValue = registry.get(namespacedKey);
+        if (registryValue == null) {
+            return null;
+        }
+
+        return registryValue;
+    }
+    // Paper end
+ 
+     CraftMetaArmor(Map<String, Object> map) {
+         super(map);
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java
+index cbf1a518406bf478811c737e6dabf0a8c451d16c..039197efb05432b8139fbabe92338572c1bf078e 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java
+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java
+@@ -490,7 +490,14 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
+                 continue;
+             }
+ 
+-            Attribute attribute = CraftAttribute.stringToBukkit(attributeName);
+            // Paper start
+            Attribute attribute;
+            try {
+                attribute = CraftAttribute.stringToBukkit(attributeName);
+            } catch (IllegalArgumentException e) {
+                attribute = null;
+            }
+            // Paper end
+             if (attribute == null) {
+                 continue;
+             }
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaSkull.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaSkull.java
+index b2bab2d79c969bc81b160312a996fb9cd87d0f95..173d2ae0b4fd6677250ded24576c5420a93e73bf 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaSkull.java
+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaSkull.java
+@@ -71,11 +71,13 @@ class CraftMetaSkull extends CraftMetaItem implements SkullMeta {
+     CraftMetaSkull(CompoundTag tag) {
+         super(tag);
+ 
+        try { // Paper - Ignore invalid game profiles
+         if (tag.contains(CraftMetaSkull.SKULL_OWNER.NBT, CraftMagicNumbers.NBT.TAG_COMPOUND)) {
+             this.setProfile(NbtUtils.readGameProfile(tag.getCompound(CraftMetaSkull.SKULL_OWNER.NBT)));
+         } else if (tag.contains(CraftMetaSkull.SKULL_OWNER.NBT, CraftMagicNumbers.NBT.TAG_STRING) && !tag.getString(CraftMetaSkull.SKULL_OWNER.NBT).isEmpty()) {
+             this.setProfile(new GameProfile(Util.NIL_UUID, tag.getString(CraftMetaSkull.SKULL_OWNER.NBT)));
+         }
+        } catch (Exception ignored) {} // Paper
+ 
+         if (tag.contains(CraftMetaSkull.BLOCK_ENTITY_TAG.NBT, CraftMagicNumbers.NBT.TAG_COMPOUND)) {
+             CompoundTag nbtTagCompound = tag.getCompound(CraftMetaSkull.BLOCK_ENTITY_TAG.NBT).copy();
--- a/patches/server/0964-Fix-BanList-API.patch
+++ b/patches/server/0964-Fix-BanList-API.patch
@ -0,0 +1,351 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Tue, 4 Jul 2023 11:27:10 -0700
+Subject: [PATCH] Fix BanList API
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftOfflinePlayer.java b/src/main/java/org/bukkit/craftbukkit/CraftOfflinePlayer.java
+index a0fcd11e6b0ca2a7055a4d1910124b20bd9c0b94..9daec0782774ab51ea8091cb8ed9d0a106e34cfa 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftOfflinePlayer.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftOfflinePlayer.java
+@@ -114,17 +114,17 @@ public class CraftOfflinePlayer implements OfflinePlayer, ConfigurationSerializa
+     }
+ 
+     @Override
+-    public BanEntry<PlayerProfile> ban(String reason, Date expires, String source) {
+    public BanEntry<com.destroystokyo.paper.profile.PlayerProfile> ban(String reason, Date expires, String source) { // Paper - fix ban list API
+         return ((ProfileBanList) this.server.getBanList(BanList.Type.PROFILE)).addBan(this.getPlayerProfile(), reason, expires, source);
+     }
+ 
+     @Override
+-    public BanEntry<PlayerProfile> ban(String reason, Instant expires, String source) {
+    public BanEntry<com.destroystokyo.paper.profile.PlayerProfile> ban(String reason, Instant expires, String source) { // Paper - fix ban list API
+         return ((ProfileBanList) this.server.getBanList(BanList.Type.PROFILE)).addBan(this.getPlayerProfile(), reason, expires, source);
+     }
+ 
+     @Override
+-    public BanEntry<PlayerProfile> ban(String reason, Duration duration, String source) {
+    public BanEntry<com.destroystokyo.paper.profile.PlayerProfile> ban(String reason, Duration duration, String source) { // Paper - fix ban list API
+         return ((ProfileBanList) this.server.getBanList(BanList.Type.PROFILE)).addBan(this.getPlayerProfile(), reason, duration, source);
+     }
+ 
+diff --git a/src/main/java/org/bukkit/craftbukkit/ban/CraftProfileBanEntry.java b/src/main/java/org/bukkit/craftbukkit/ban/CraftProfileBanEntry.java
+index 13e5e44b069121e51b9486c445902937f1d6c6d8..4a37c8172b42b10472bb90c9310c7ae3eeaa3481 100644
+--- a/src/main/java/org/bukkit/craftbukkit/ban/CraftProfileBanEntry.java
+++ b/src/main/java/org/bukkit/craftbukkit/ban/CraftProfileBanEntry.java
+@@ -9,7 +9,7 @@ import org.bukkit.BanEntry;
+ import org.bukkit.craftbukkit.profile.CraftPlayerProfile;
+ import org.bukkit.profile.PlayerProfile;
+ 
+-public final class CraftProfileBanEntry implements BanEntry<PlayerProfile> {
+public final class CraftProfileBanEntry implements BanEntry<com.destroystokyo.paper.profile.PlayerProfile> { // Paper
+     private static final Date minorDate = Date.from(Instant.parse("1899-12-31T04:00:00Z"));
+     private final UserBanList list;
+     private final GameProfile profile;
+@@ -33,8 +33,8 @@ public final class CraftProfileBanEntry implements BanEntry<PlayerProfile> {
+     }
+ 
+     @Override
+-    public PlayerProfile getBanTarget() {
+-        return new CraftPlayerProfile(this.profile);
+    public com.destroystokyo.paper.profile.PlayerProfile getBanTarget() { // Paper
+        return new com.destroystokyo.paper.profile.CraftPlayerProfile(this.profile); // Paper
+     }
+ 
+     @Override
+diff --git a/src/main/java/org/bukkit/craftbukkit/ban/CraftProfileBanList.java b/src/main/java/org/bukkit/craftbukkit/ban/CraftProfileBanList.java
+index 172202accf4448a933fcf1ff820316c7910dd7f7..50ee7656580d386db473c054f5c5ec57bb2b1424 100644
+--- a/src/main/java/org/bukkit/craftbukkit/ban/CraftProfileBanList.java
+++ b/src/main/java/org/bukkit/craftbukkit/ban/CraftProfileBanList.java
+@@ -24,42 +24,80 @@ public class CraftProfileBanList implements ProfileBanList {
+     }
+ 
+     @Override
+-    public BanEntry<PlayerProfile> getBanEntry(String target) {
+    public BanEntry<com.destroystokyo.paper.profile.PlayerProfile> getBanEntry(String target) { // Paper
+         Preconditions.checkArgument(target != null, "Target cannot be null");
+ 
+         return this.getBanEntry(CraftProfileBanList.getProfile(target));
+     }
+ 
+     @Override
+-    public BanEntry<PlayerProfile> getBanEntry(PlayerProfile target) {
+    public BanEntry<com.destroystokyo.paper.profile.PlayerProfile> getBanEntry(PlayerProfile target) { // Paper
+         Preconditions.checkArgument(target != null, "Target cannot be null");
+ 
+-        return this.getBanEntry(((CraftPlayerProfile) target).buildGameProfile());
+        return this.getBanEntry(((com.destroystokyo.paper.profile.SharedPlayerProfile) target).buildGameProfile()); // Paper
+    }
+    // Paper start - fix ban list API
+    @Override
+    public BanEntry<com.destroystokyo.paper.profile.PlayerProfile> getBanEntry(final com.destroystokyo.paper.profile.PlayerProfile target) {
+        Preconditions.checkArgument(target != null, "target cannot be null");
+
+        return this.getBanEntry(((com.destroystokyo.paper.profile.SharedPlayerProfile) target).buildGameProfile());
+    }
+
+    @Override
+    public BanEntry<com.destroystokyo.paper.profile.PlayerProfile> addBan(final com.destroystokyo.paper.profile.PlayerProfile target, final String reason, final Date expires, final String source) {
+        Preconditions.checkArgument(target != null, "PlayerProfile cannot be null");
+        Preconditions.checkArgument(target.getId() != null, "The PlayerProfile UUID cannot be null");
+
+        return this.addBan(((com.destroystokyo.paper.profile.SharedPlayerProfile) target).buildGameProfile(), reason, expires, source);
+    }
+
+    @Override
+    public boolean isBanned(final com.destroystokyo.paper.profile.PlayerProfile target) {
+        return this.isBanned((com.destroystokyo.paper.profile.SharedPlayerProfile) target);
+    }
+
+    @Override
+    public void pardon(final com.destroystokyo.paper.profile.PlayerProfile target) {
+        this.pardon((com.destroystokyo.paper.profile.SharedPlayerProfile) target);
+     }
+ 
+     @Override
+-    public BanEntry<PlayerProfile> addBan(String target, String reason, Date expires, String source) {
+    public BanEntry<com.destroystokyo.paper.profile.PlayerProfile> addBan(final com.destroystokyo.paper.profile.PlayerProfile target, final String reason, final Instant expires, final String source) {
+        Date date = expires != null ? Date.from(expires) : null;
+        return this.addBan(target, reason, date, source);
+    }
+
+    @Override
+    public BanEntry<com.destroystokyo.paper.profile.PlayerProfile> addBan(final com.destroystokyo.paper.profile.PlayerProfile target, final String reason, final Duration duration, final String source) {
+        Instant instant = duration != null ? Instant.now().plus(duration) : null;
+        return this.addBan(target, reason, instant, source);
+    }
+    // Paper end - fix ban list API
+
+    @Override
+    public BanEntry<com.destroystokyo.paper.profile.PlayerProfile> addBan(String target, String reason, Date expires, String source) { // Paper - fix ban list API
+         Preconditions.checkArgument(target != null, "Ban target cannot be null");
+ 
+         return this.addBan(CraftProfileBanList.getProfileByName(target), reason, expires, source);
+     }
+ 
+     @Override
+-    public BanEntry<PlayerProfile> addBan(PlayerProfile target, String reason, Date expires, String source) {
+    public BanEntry<com.destroystokyo.paper.profile.PlayerProfile> addBan(PlayerProfile target, String reason, Date expires, String source) { // Paper - fix ban list API
+         Preconditions.checkArgument(target != null, "PlayerProfile cannot be null");
+         Preconditions.checkArgument(target.getUniqueId() != null, "The PlayerProfile UUID cannot be null");
+ 
+-        return this.addBan(((CraftPlayerProfile) target).buildGameProfile(), reason, expires, source);
+        return this.addBan(((com.destroystokyo.paper.profile.SharedPlayerProfile) target).buildGameProfile(), reason, expires, source); // Paper
+     }
+ 
+     @Override
+-    public BanEntry<PlayerProfile> addBan(PlayerProfile target, String reason, Instant expires, String source) {
+    public BanEntry<com.destroystokyo.paper.profile.PlayerProfile> addBan(PlayerProfile target, String reason, Instant expires, String source) { // Paper - fix ban list API
+         Date date = expires != null ? Date.from(expires) : null;
+         return this.addBan(target, reason, date, source);
+     }
+ 
+     @Override
+-    public BanEntry<PlayerProfile> addBan(PlayerProfile target, String reason, Duration duration, String source) {
+    public BanEntry<com.destroystokyo.paper.profile.PlayerProfile> addBan(PlayerProfile target, String reason, Duration duration, String source) { // Paper - fix ban list API
+         Instant instant = duration != null ? Instant.now().plus(duration) : null;
+         return this.addBan(target, reason, instant, source);
+     }
+@@ -76,8 +114,8 @@ public class CraftProfileBanList implements ProfileBanList {
+     }
+ 
+     @Override
+-    public Set<BanEntry<PlayerProfile>> getEntries() {
+-        ImmutableSet.Builder<BanEntry<PlayerProfile>> builder = ImmutableSet.builder();
+    public Set<BanEntry<com.destroystokyo.paper.profile.PlayerProfile>> getEntries() { // Paper
+        ImmutableSet.Builder<BanEntry<com.destroystokyo.paper.profile.PlayerProfile>> builder = ImmutableSet.builder(); // Paper
+         for (UserBanListEntry entry : this.list.getEntries()) {
+             GameProfile profile = entry.getUser();
+             builder.add(new CraftProfileBanEntry(profile, entry, this.list));
+@@ -88,9 +126,14 @@ public class CraftProfileBanList implements ProfileBanList {
+ 
+     @Override
+     public boolean isBanned(PlayerProfile target) {
+        // Paper start
+        return this.isBanned((com.destroystokyo.paper.profile.SharedPlayerProfile) target);
+    }
+    private boolean isBanned(com.destroystokyo.paper.profile.SharedPlayerProfile target) {
+        // Paper end
+         Preconditions.checkArgument(target != null, "Target cannot be null");
+ 
+-        return this.isBanned(((CraftPlayerProfile) target).buildGameProfile());
+        return this.isBanned(target.buildGameProfile()); // Paper
+     }
+ 
+     @Override
+@@ -102,9 +145,14 @@ public class CraftProfileBanList implements ProfileBanList {
+ 
+     @Override
+     public void pardon(PlayerProfile target) {
+        // Paper start
+        this.pardon((com.destroystokyo.paper.profile.SharedPlayerProfile) target);
+    }
+    private void pardon(com.destroystokyo.paper.profile.SharedPlayerProfile target) {
+        // Paper end
+         Preconditions.checkArgument(target != null, "Target cannot be null");
+ 
+-        this.pardon(((CraftPlayerProfile) target).buildGameProfile());
+        this.pardon(target.buildGameProfile()); // Paper
+     }
+ 
+     @Override
+@@ -114,7 +162,7 @@ public class CraftProfileBanList implements ProfileBanList {
+         this.pardon(CraftProfileBanList.getProfile(target));
+     }
+ 
+-    public BanEntry<PlayerProfile> getBanEntry(GameProfile profile) {
+    public BanEntry<com.destroystokyo.paper.profile.PlayerProfile> getBanEntry(GameProfile profile) { // Paper
+         if (profile == null) {
+             return null;
+         }
+@@ -127,7 +175,7 @@ public class CraftProfileBanList implements ProfileBanList {
+         return new CraftProfileBanEntry(profile, entry, this.list);
+     }
+ 
+-    public BanEntry<PlayerProfile> addBan(GameProfile profile, String reason, Date expires, String source) {
+    public BanEntry<com.destroystokyo.paper.profile.PlayerProfile> addBan(GameProfile profile, String reason, Date expires, String source) { // Paper
+         if (profile == null) {
+             return null;
+         }
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index 4c4594e96c57ae374bcf2d70004bd12d1da1b758..d252f0313b1d73758782249060e7c57afb5c5418 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -1648,23 +1648,23 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+     }
+ 
+     @Override
+-    public BanEntry<PlayerProfile> ban(String reason, Date expires, String source) {
+    public BanEntry<com.destroystokyo.paper.profile.PlayerProfile> ban(String reason, Date expires, String source) { // Paper - fix ban list API
+         return this.ban(reason, expires, source, true);
+     }
+ 
+     @Override
+-    public BanEntry<PlayerProfile> ban(String reason, Instant expires, String source) {
+    public BanEntry<com.destroystokyo.paper.profile.PlayerProfile> ban(String reason, Instant expires, String source) { // Paper - fix ban list API
+         return this.ban(reason, expires != null ? Date.from(expires) : null, source);
+     }
+ 
+     @Override
+-    public BanEntry<PlayerProfile> ban(String reason, Duration duration, String source) {
+    public BanEntry<com.destroystokyo.paper.profile.PlayerProfile> ban(String reason, Duration duration, String source) { // Paper - fix ban list API
+         return this.ban(reason, duration != null ? Instant.now().plus(duration) : null, source);
+     }
+ 
+     @Override
+-    public BanEntry<PlayerProfile> ban(String reason, Date expires, String source, boolean kickPlayer) {
+-        BanEntry<PlayerProfile> banEntry = ((ProfileBanList) this.server.getBanList(BanList.Type.PROFILE)).addBan(this.getPlayerProfile(), reason, expires, source);
+    public BanEntry<com.destroystokyo.paper.profile.PlayerProfile> ban(String reason, Date expires, String source, boolean kickPlayer) { // Paper - fix ban list API
+        BanEntry<com.destroystokyo.paper.profile.PlayerProfile> banEntry = ((ProfileBanList) this.server.getBanList(BanList.Type.PROFILE)).addBan(this.getPlayerProfile(), reason, expires, source); // Paper - fix ban list API
+         if (kickPlayer) {
+             this.kickPlayer(reason);
+         }
+@@ -1672,12 +1672,12 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+     }
+ 
+     @Override
+-    public BanEntry<PlayerProfile> ban(String reason, Instant instant, String source, boolean kickPlayer) {
+    public BanEntry<com.destroystokyo.paper.profile.PlayerProfile> ban(String reason, Instant instant, String source, boolean kickPlayer) { // Paper - fix ban list API
+         return this.ban(reason, instant != null ? Date.from(instant) : null, source, kickPlayer);
+     }
+ 
+     @Override
+-    public BanEntry<PlayerProfile> ban(String reason, Duration duration, String source, boolean kickPlayer) {
+    public BanEntry<com.destroystokyo.paper.profile.PlayerProfile> ban(String reason, Duration duration, String source, boolean kickPlayer) { // Paper - fix ban list API
+         return this.ban(reason, duration != null ? Instant.now().plus(duration) : null, source, kickPlayer);
+     }
+ 
+diff --git a/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerProfile.java b/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerProfile.java
+index 6422c58907ee289359a11054fec1e4de6f495ae3..bc6151cfeb7ace4755414614723ee830081094af 100644
+--- a/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerProfile.java
+++ b/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerProfile.java
+@@ -28,7 +28,7 @@ import org.bukkit.profile.PlayerProfile;
+ import org.bukkit.profile.PlayerTextures;
+ 
+ @SerializableAs("PlayerProfile")
+-public final class CraftPlayerProfile implements PlayerProfile, com.destroystokyo.paper.profile.SharedPlayerProfile { // Paper
+public final class CraftPlayerProfile implements PlayerProfile, com.destroystokyo.paper.profile.SharedPlayerProfile, com.destroystokyo.paper.profile.PlayerProfile { // Paper
+ 
+     @Nonnull
+     public static GameProfile validateSkullProfile(@Nonnull GameProfile gameProfile) {
+@@ -123,7 +123,7 @@ public final class CraftPlayerProfile implements PlayerProfile, com.destroystoky
+     }
+ 
+     @Override
+-    public CompletableFuture<PlayerProfile> update() {
+    public CompletableFuture update() { // Paper - have to remove generic to avoid clashing between bukkit.PlayerProfile and paper.PlayerProfile
+         return CompletableFuture.supplyAsync(this::getUpdatedProfile, Util.PROFILE_EXECUTOR); // Paper - not a good idea to use BLOCKING OPERATIONS on the worldgen executor
+     }
+ 
+@@ -277,4 +277,71 @@ public final class CraftPlayerProfile implements PlayerProfile, com.destroystoky
+         // Paper - diff on change
+         return profile;
+     }
+
+    // Paper start - This must implement our PlayerProfile so generic casts succeed from cb.CraftPlayerProfile to paper.PlayerProfile
+    // The methods don't actually have to be implemented, because the profile should immediately be cast to SharedPlayerProfile
+    @Override
+    public String setName(final String name) {
+        throw new UnsupportedOperationException("Do not cast to com.destroystokyo.paper.profile.PlayerProfile");
+    }
+
+    @Override
+    public UUID getId() {
+        throw new UnsupportedOperationException("Do not cast to com.destroystokyo.paper.profile.PlayerProfile");
+    }
+
+    @Override
+    public UUID setId(final UUID uuid) {
+        throw new UnsupportedOperationException("Do not cast to com.destroystokyo.paper.profile.PlayerProfile");
+    }
+
+    @Override
+    public java.util.Set<com.destroystokyo.paper.profile.ProfileProperty> getProperties() {
+        throw new UnsupportedOperationException("Do not cast to com.destroystokyo.paper.profile.PlayerProfile");
+    }
+
+    @Override
+    public boolean hasProperty(final String property) {
+        throw new UnsupportedOperationException("Do not cast to com.destroystokyo.paper.profile.PlayerProfile");
+    }
+
+    @Override
+    public void setProperty(final com.destroystokyo.paper.profile.ProfileProperty property) {
+        throw new UnsupportedOperationException("Do not cast to com.destroystokyo.paper.profile.PlayerProfile");
+    }
+
+    @Override
+    public void setProperties(final java.util.Collection<com.destroystokyo.paper.profile.ProfileProperty> properties) {
+        throw new UnsupportedOperationException("Do not cast to com.destroystokyo.paper.profile.PlayerProfile");
+    }
+
+    @Override
+    public void clearProperties() {
+        throw new UnsupportedOperationException("Do not cast to com.destroystokyo.paper.profile.PlayerProfile");
+    }
+
+    @Override
+    public boolean completeFromCache() {
+        throw new UnsupportedOperationException("Do not cast to com.destroystokyo.paper.profile.PlayerProfile");
+    }
+
+    @Override
+    public boolean completeFromCache(final boolean onlineMode) {
+        throw new UnsupportedOperationException("Do not cast to com.destroystokyo.paper.profile.PlayerProfile");
+    }
+
+    @Override
+    public boolean completeFromCache(final boolean lookupUUID, final boolean onlineMode) {
+        throw new UnsupportedOperationException("Do not cast to com.destroystokyo.paper.profile.PlayerProfile");
+    }
+
+    @Override
+    public boolean complete(final boolean textures) {
+        throw new UnsupportedOperationException("Do not cast to com.destroystokyo.paper.profile.PlayerProfile");
+    }
+
+    @Override
+    public boolean complete(final boolean textures, final boolean onlineMode) {
+        throw new UnsupportedOperationException("Do not cast to com.destroystokyo.paper.profile.PlayerProfile");
+    }
+ }
--- a/patches/server/0965-Determine-lava-and-water-fluid-explosion-resistance-.patch
+++ b/patches/server/0965-Determine-lava-and-water-fluid-explosion-resistance-.patch
@ -0,0 +1,36 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: galacticwarrior9 <zareef1@yahoo.com>
+Date: Thu, 13 Jul 2023 21:32:13 +0100
+Subject: [PATCH] Determine lava and water fluid explosion resistance by their
+ block explosion resistance
+
+When selecting which explosion resistance to use for lava and water, vanilla selects the highest value between their block explosion resistance and fluid explosion resistance.
+
+Problems emerge when we want to reduce the explosion resistance of water or lava, since the fluid explosion resistance is hardcoded to return 100.0F and can't be changed by a plugin. This simply makes the fluid explosion resistance the same as the block explosion resistance, which allows plugin to change the value. Since both are the same in vanilla, this has no side effects on servers that do not need to do this.
+
+diff --git a/src/main/java/net/minecraft/world/level/material/LavaFluid.java b/src/main/java/net/minecraft/world/level/material/LavaFluid.java
+index 72f8b72c6436ca3b8eaeb39c7d3efe2c1462ae1d..c3f8e1e2dd89c168b8b4a15b589109db486bc8d7 100644
+--- a/src/main/java/net/minecraft/world/level/material/LavaFluid.java
+++ b/src/main/java/net/minecraft/world/level/material/LavaFluid.java
+@@ -232,7 +232,7 @@ public abstract class LavaFluid extends FlowingFluid {
+ 
+     @Override
+     protected float getExplosionResistance() {
+-        return 100.0F;
+        return Blocks.LAVA.getExplosionResistance(); // Paper
+     }
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/level/material/WaterFluid.java b/src/main/java/net/minecraft/world/level/material/WaterFluid.java
+index 82e85fbbd45244d02df90fa00c9046e7f51275a2..d280c98aed5262c4ce39526c917de884f25a8584 100644
+--- a/src/main/java/net/minecraft/world/level/material/WaterFluid.java
+++ b/src/main/java/net/minecraft/world/level/material/WaterFluid.java
+@@ -109,7 +109,7 @@ public abstract class WaterFluid extends FlowingFluid {
+ 
+     @Override
+     protected float getExplosionResistance() {
+-        return 100.0F;
+        return Blocks.WATER.getExplosionResistance(); // Paper
+     }
+ 
+     @Override
--- a/patches/server/0966-Fix-possible-NPE-on-painting-creation.patch
+++ b/patches/server/0966-Fix-possible-NPE-on-painting-creation.patch
@ -0,0 +1,28 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Sat, 24 Jun 2023 09:42:53 -0700
+Subject: [PATCH] Fix possible NPE on painting creation
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java b/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java
+index 096e1cc920f5f48fe59b9419827c3cbb7adefe14..ee8819884868b70f2a3644141eca1d92abe2b7a8 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java
+@@ -951,6 +951,7 @@ public abstract class CraftRegionAccessor implements RegionAccessor {
+                         AABB bb = (ItemFrame.class.isAssignableFrom(clazz))
+                                 ? net.minecraft.world.entity.decoration.ItemFrame.calculateBoundingBox(null, pos, CraftBlock.blockFaceToNotch(dir).getOpposite(), width, height)
+                                 : HangingEntity.calculateBoundingBox(null, pos, CraftBlock.blockFaceToNotch(dir).getOpposite(), width, height);
+                        if (!this.getHandle().noCollision(bb)) continue; // Paper - add collision check
+                         List<net.minecraft.world.entity.Entity> list = (List<net.minecraft.world.entity.Entity>) this.getHandle().getEntities(null, bb);
+                         for (Iterator<net.minecraft.world.entity.Entity> it = list.iterator(); !taken && it.hasNext(); ) {
+                             net.minecraft.world.entity.Entity e = it.next();
+@@ -977,7 +978,8 @@ public abstract class CraftRegionAccessor implements RegionAccessor {
+                 if (Painting.class.isAssignableFrom(clazz)) {
+                     if (this.isNormalWorld() && randomizeData) {
+                         entity = net.minecraft.world.entity.decoration.Painting.create(world, pos, dir).orElse(null);
+-                    } else {
+                    } // Paper
+                    if (entity == null) { // Paper - if randomizeData fails, force it
+                         entity = new net.minecraft.world.entity.decoration.Painting(net.minecraft.world.entity.EntityType.PAINTING, this.getHandle().getMinecraftWorld());
+                         entity.absMoveTo(x, y, z, yaw, pitch);
+                         ((net.minecraft.world.entity.decoration.Painting) entity).setDirection(dir);
--- a/patches/server/0967-Only-set-despawnTimer-for-Wandering-Traders-spawned-.patch
+++ b/patches/server/0967-Only-set-despawnTimer-for-Wandering-Traders-spawned-.patch
@ -0,0 +1,33 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jason Penilla <11360596+jpenilla@users.noreply.github.com>
+Date: Fri, 19 Mar 2021 16:07:21 -0700
+Subject: [PATCH] Only set despawnTimer for Wandering Traders spawned by
+ WanderingTraderSpawner
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/npc/WanderingTrader.java b/src/main/java/net/minecraft/world/entity/npc/WanderingTrader.java
+index 96115fe8a8c32ce5992d779b5db540b9d81e3b82..833563e237462ccfc1b730b8f5fb35340d0db854 100644
+--- a/src/main/java/net/minecraft/world/entity/npc/WanderingTrader.java
+++ b/src/main/java/net/minecraft/world/entity/npc/WanderingTrader.java
+@@ -67,7 +67,7 @@ public class WanderingTrader extends net.minecraft.world.entity.npc.AbstractVill
+ 
+     public WanderingTrader(EntityType<? extends WanderingTrader> type, Level world) {
+         super(type, world);
+-        this.setDespawnDelay(48000); // CraftBukkit - set default from MobSpawnerTrader
+        //this.setDespawnDelay(48000); // CraftBukkit - set default from MobSpawnerTrader // Paper - move back to MobSpawnerTrader - Vanilla behavior is that only traders spawned by it have this value set.
+     }
+ 
+     @Override
+diff --git a/src/main/java/net/minecraft/world/entity/npc/WanderingTraderSpawner.java b/src/main/java/net/minecraft/world/entity/npc/WanderingTraderSpawner.java
+index 5d199fe497bd852827d3d18fb7566a09e70331a3..8385eb1d60f377da94e3178ab506feefb43563fd 100644
+--- a/src/main/java/net/minecraft/world/entity/npc/WanderingTraderSpawner.java
+++ b/src/main/java/net/minecraft/world/entity/npc/WanderingTraderSpawner.java
+@@ -120,7 +120,7 @@ public class WanderingTraderSpawner implements CustomSpawner {
+                     return false;
+                 }
+ 
+-                WanderingTrader entityvillagertrader = (WanderingTrader) EntityType.WANDERING_TRADER.spawn(world, blockposition2, MobSpawnType.EVENT, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.NATURAL); // CraftBukkit
+                WanderingTrader entityvillagertrader = (WanderingTrader) EntityType.WANDERING_TRADER.spawn(world, null, trader -> trader.setDespawnDelay(48000), blockposition2, MobSpawnType.EVENT, false, false, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.NATURAL); // CraftBukkit // Paper - set despawnTimer before spawn events called
+ 
+                 if (entityvillagertrader != null) {
+                     for (int i = 0; i < 2; ++i) {
--- a/patches/server/0968-ExperienceOrb-should-call-EntitySpawnEvent.patch
+++ b/patches/server/0968-ExperienceOrb-should-call-EntitySpawnEvent.patch
@ -0,0 +1,22 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Golfing8 <atroo@me.com>
+Date: Mon, 8 May 2023 09:18:17 -0400
+Subject: [PATCH] ExperienceOrb should call EntitySpawnEvent
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+index e4551a6d984928457af4fb6cc2d0bf3673ef8fb1..8f78b9e714c472f59f3abf565c53bd87a6811674 100644
+--- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+@@ -737,7 +737,10 @@ public class CraftEventFactory {
+         // Spigot start - SPIGOT-7523: Merge after spawn event and only merge if the event was not cancelled (gets checked above)
+         if (entity instanceof net.minecraft.world.entity.ExperienceOrb xp) {
+             double radius = world.spigotConfig.expMerge;
+-            if (radius > 0) {
+            // Paper start - Call EntitySpawnEvent for ExperienceOrb entities.
+            event = CraftEventFactory.callEntitySpawnEvent(entity);
+            if (radius > 0 && !event.isCancelled() && !entity.isRemoved()) {
+            // Paper end
+                 // Paper start - Maximum exp value when merging - Whole section has been tweaked, see comments for specifics
+                 final int maxValue = world.paperConfig().entities.behavior.experienceMergeMaxValue;
+                 final boolean mergeUnconditionally = world.paperConfig().entities.behavior.experienceMergeMaxValue <= 0;
--- a/patches/server/0969-Don-t-tick-signs.patch
+++ b/patches/server/0969-Don-t-tick-signs.patch
@ -0,0 +1,63 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com>
+Date: Wed, 12 Jul 2023 17:38:26 -0400
+Subject: [PATCH] Don't tick signs
+
+Minecraft now ticks signs in order to validate the playerWhoMayEdit field. This is a horrible idea, as this means that even waxed signs are ticked for essentially no reason. This moves the logic lazily onto the getter.
+
+== AT ==
+private net.minecraft.world.level.block.entity.SignBlockEntity playerWhoMayEdit
+
+diff --git a/src/main/java/net/minecraft/world/level/block/CeilingHangingSignBlock.java b/src/main/java/net/minecraft/world/level/block/CeilingHangingSignBlock.java
+index cee371fde78e7e95e166b138d9437e5e8087f7c7..90fe181d035e43c4cc220cbb984f8f8c7fd29602 100644
+--- a/src/main/java/net/minecraft/world/level/block/CeilingHangingSignBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/CeilingHangingSignBlock.java
+@@ -154,6 +154,6 @@ public class CeilingHangingSignBlock extends SignBlock {
+     @Nullable
+     @Override
+     public <T extends BlockEntity> BlockEntityTicker<T> getTicker(Level world, BlockState state, BlockEntityType<T> type) {
+-        return createTickerHelper(type, BlockEntityType.HANGING_SIGN, SignBlockEntity::tick);
+        return null; // Paper
+     }
+ }
+diff --git a/src/main/java/net/minecraft/world/level/block/SignBlock.java b/src/main/java/net/minecraft/world/level/block/SignBlock.java
+index 28cba43e42354b87e08ef87b70c274a2fdc0bb48..ade170b4c76ad4a36eb2fba831d438642c096205 100644
+--- a/src/main/java/net/minecraft/world/level/block/SignBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/SignBlock.java
+@@ -210,6 +210,6 @@ public abstract class SignBlock extends BaseEntityBlock implements SimpleWaterlo
+     @Nullable
+     @Override
+     public <T extends BlockEntity> BlockEntityTicker<T> getTicker(Level world, BlockState state, BlockEntityType<T> type) {
+-        return createTickerHelper(type, BlockEntityType.SIGN, SignBlockEntity::tick);
+        return null; // Paper
+     }
+ }
+diff --git a/src/main/java/net/minecraft/world/level/block/WallHangingSignBlock.java b/src/main/java/net/minecraft/world/level/block/WallHangingSignBlock.java
+index 32a463104593ecf00d44c449edda24a13ac8224e..484a2a689f240f1916e911459111782e91c20940 100644
+--- a/src/main/java/net/minecraft/world/level/block/WallHangingSignBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/WallHangingSignBlock.java
+@@ -177,6 +177,6 @@ public class WallHangingSignBlock extends SignBlock {
+     @Nullable
+     @Override
+     public <T extends BlockEntity> BlockEntityTicker<T> getTicker(Level world, BlockState state, BlockEntityType<T> type) {
+-        return createTickerHelper(type, BlockEntityType.HANGING_SIGN, SignBlockEntity::tick);
+        return null; // Paper
+     }
+ }
+diff --git a/src/main/java/net/minecraft/world/level/block/entity/SignBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/SignBlockEntity.java
+index 68f95a8eb4aa659e62394bf98ecd5f5d46879cbf..bc01970c5ef9cde4a75394d6977837e924a38463 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/SignBlockEntity.java
+++ b/src/main/java/net/minecraft/world/level/block/entity/SignBlockEntity.java
+@@ -365,6 +365,12 @@ public class SignBlockEntity extends BlockEntity implements CommandSource { // C
+ 
+     @Nullable
+     public UUID getPlayerWhoMayEdit() {
+        // Paper start
+        if (this.hasLevel() && this.playerWhoMayEdit != null) {
+            // Manually invalidate the value lazily.
+            this.clearInvalidPlayerWhoMayEdit(this, this.getLevel(), this.playerWhoMayEdit);
+        }
+        // Paper end
+         return this.playerWhoMayEdit;
+     }
+ 
--- a/patches/server/0970-Make-Amethyst-throw-both-Spread-and-Grow-Events.patch
+++ b/patches/server/0970-Make-Amethyst-throw-both-Spread-and-Grow-Events.patch
@ -0,0 +1,24 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jacob Litewski <jacob.litewski@gmail.com>
+Date: Tue, 13 Jun 2023 19:16:39 -0400
+Subject: [PATCH] Make Amethyst throw both Spread and Grow Events
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/BuddingAmethystBlock.java b/src/main/java/net/minecraft/world/level/block/BuddingAmethystBlock.java
+index 79f1fb45447350b5bedee8ce3efe6c150aa9772c..ee24eac5e37a2fd0c8c37365ea10d03749beb9a7 100644
+--- a/src/main/java/net/minecraft/world/level/block/BuddingAmethystBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/BuddingAmethystBlock.java
+@@ -45,7 +45,13 @@ public class BuddingAmethystBlock extends AmethystBlock {
+             if (block != null) {
+                 BlockState iblockdata2 = (BlockState) ((BlockState) block.defaultBlockState().setValue(AmethystClusterBlock.FACING, enumdirection)).setValue(AmethystClusterBlock.WATERLOGGED, iblockdata1.getFluidState().getType() == Fluids.WATER);
+ 
+                // Paper Start - Have Amethyst throw both spread and grow events
+                if (block == Blocks.SMALL_AMETHYST_BUD) {
+                 org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockSpreadEvent(world, pos, blockposition1, iblockdata2); // CraftBukkit
+                } else {
+                    org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockGrowEvent(world, blockposition1, iblockdata2);
+                }
+                // Paper end
+             }
+ 
+         }
--- a/patches/server/0971-Add-whitelist-events.patch
+++ b/patches/server/0971-Add-whitelist-events.patch
@ -0,0 +1,34 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: SageSphinx63920 <sage@sagesphinx63920.dev>
+Date: Sun, 14 May 2023 12:57:15 +0200
+Subject: [PATCH] Add whitelist events
+
+
+diff --git a/src/main/java/net/minecraft/server/players/UserWhiteList.java b/src/main/java/net/minecraft/server/players/UserWhiteList.java
+index a6c70decad1a496595944a5dd2aeeb387757fef3..e5c218833f5bcb1c908cd62bdc57cc5152d37be5 100644
+--- a/src/main/java/net/minecraft/server/players/UserWhiteList.java
+++ b/src/main/java/net/minecraft/server/players/UserWhiteList.java
+@@ -30,4 +30,23 @@ public class UserWhiteList extends StoredUserList<GameProfile, UserWhiteListEntr
+     protected String getKeyForUser(GameProfile gameProfile) {
+         return gameProfile.getId().toString();
+     }
+    // Paper start - Add whitelist events
+    @Override
+    public void add(UserWhiteListEntry entry) {
+        if (!new io.papermc.paper.event.server.WhitelistStateUpdateEvent(com.destroystokyo.paper.profile.CraftPlayerProfile.asBukkitCopy(entry.getUser()), io.papermc.paper.event.server.WhitelistStateUpdateEvent.WhitelistStatus.ADDED).callEvent()) {
+            return;
+        }
+
+        super.add(entry);
+    }
+
+    @Override
+    public void remove(GameProfile profile) {
+        if (!new io.papermc.paper.event.server.WhitelistStateUpdateEvent(com.destroystokyo.paper.profile.CraftPlayerProfile.asBukkitCopy(profile), io.papermc.paper.event.server.WhitelistStateUpdateEvent.WhitelistStatus.REMOVED).callEvent()) {
+            return;
+        }
+
+        super.remove(profile);
+    }
+    // Paper end
+ }
--- a/patches/server/0972-Implement-PlayerFailMoveEvent.patch
+++ b/patches/server/0972-Implement-PlayerFailMoveEvent.patch
@ -0,0 +1,113 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Moulberry <james.jenour@protonmail.com>
+Date: Wed, 26 Jul 2023 20:13:31 +0800
+Subject: [PATCH] Implement PlayerFailMoveEvent
+
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index 09e5d0790b87a4747dd50eb790cdd1ce83de2550..c01d38b673303b06ad0a932641446b1a8f4fda8c 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -1317,8 +1317,8 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+                     double d0 = ServerGamePacketListenerImpl.clampHorizontal(packet.getX(this.player.getX())); final double toX = d0; // Paper - OBFHELPER
+                     double d1 = ServerGamePacketListenerImpl.clampVertical(packet.getY(this.player.getY())); final double toY = d1;
+                     double d2 = ServerGamePacketListenerImpl.clampHorizontal(packet.getZ(this.player.getZ())); final double toZ = d2; // Paper - OBFHELPER
+-                    float f = Mth.wrapDegrees(packet.getYRot(this.player.getYRot()));
+-                    float f1 = Mth.wrapDegrees(packet.getXRot(this.player.getXRot()));
+                    float f = Mth.wrapDegrees(packet.getYRot(this.player.getYRot())); final float toYaw = f; // Paper - OBFHELPER
+                    float f1 = Mth.wrapDegrees(packet.getXRot(this.player.getXRot())); final float toPitch = f1; // Paper - OBFHELPER
+ 
+                     if (this.player.isPassenger()) {
+                         this.player.absMoveTo(this.player.getX(), this.player.getY(), this.player.getZ(), f, f1);
+@@ -1385,8 +1385,14 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+                                 }
+                             // Paper start - Prevent moving into unloaded chunks
+                             if (this.player.level().paperConfig().chunks.preventMovingIntoUnloadedChunks && (this.player.getX() != toX || this.player.getZ() != toZ) && !worldserver.areChunksLoadedForMove(this.player.getBoundingBox().expandTowards(new Vec3(toX, toY, toZ).subtract(this.player.position())))) {
+                                // Paper start - Add fail move event
+                                io.papermc.paper.event.player.PlayerFailMoveEvent event = fireFailMove(io.papermc.paper.event.player.PlayerFailMoveEvent.FailReason.MOVED_INTO_UNLOADED_CHUNK,
+                                    toX, toY, toZ, toYaw, toPitch, false);
+                                if (!event.isAllowed()) {
+                                 this.internalTeleport(this.player.getX(), this.player.getY(), this.player.getZ(), this.player.getYRot(), this.player.getXRot(), Collections.emptySet());
+                                 return;
+                                }
+                                // Paper end
+                             }
+                             // Paper end
+ 
+@@ -1395,9 +1401,16 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+ 
+                                     if (d10 - d9 > Math.max(f2, Math.pow((double) (org.spigotmc.SpigotConfig.movedTooQuicklyMultiplier * (float) i * speed), 2)) && !this.isSingleplayerOwner()) {
+                                     // CraftBukkit end
+                                        // Paper start - Add fail move event
+                                        io.papermc.paper.event.player.PlayerFailMoveEvent event = fireFailMove(io.papermc.paper.event.player.PlayerFailMoveEvent.FailReason.MOVED_TOO_QUICKLY,
+                                            toX, toY, toZ, toYaw, toPitch, true);
+                                        if (!event.isAllowed()) {
+                                            if (event.getLogWarning())
+                                         ServerGamePacketListenerImpl.LOGGER.warn("{} moved too quickly! {},{},{}", new Object[]{this.player.getName().getString(), d6, d7, d8});
+                                         this.teleport(this.player.getX(), this.player.getY(), this.player.getZ(), this.player.getYRot(), this.player.getXRot());
+                                         return;
+                                        }
+                                        // Paper end
+                                     }
+                                 }
+                             }
+@@ -1436,6 +1449,8 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+                                     from = event.getFrom();
+                                     this.internalTeleport(from.getX(), from.getY(), from.getZ(), from.getYaw(), from.getPitch(), Collections.emptySet());
+                                     return;
+                                    }
+                                    // Paper end
+                                 }
+                                 // Paper end
+                             }
+@@ -1463,8 +1478,15 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+                             boolean flag2 = false;
+ 
+                             if (!this.player.isChangingDimension() && d10 > org.spigotmc.SpigotConfig.movedWronglyThreshold && !this.player.isSleeping() && !this.player.gameMode.isCreative() && this.player.gameMode.getGameModeForPlayer() != GameType.SPECTATOR) { // Spigot
+                                // Paper start - Add fail move event
+                                io.papermc.paper.event.player.PlayerFailMoveEvent event = fireFailMove(io.papermc.paper.event.player.PlayerFailMoveEvent.FailReason.MOVED_WRONGLY,
+                                    toX, toY, toZ, toYaw, toPitch, true);
+                                if (!event.isAllowed()) {
+                                 flag2 = true; // Paper - diff on change, this should be moved wrongly
+                                    if (event.getLogWarning())
+                                 ServerGamePacketListenerImpl.LOGGER.warn("{} moved wrongly!", this.player.getName().getString());
+                                }
+                                // Paper end
+                             }
+ 
+                             // Paper start - optimise out extra getCubes
+@@ -1477,6 +1499,15 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+                                 if (didCollide || !axisalignedbb.equals(newBox)) {
+                                     // note: only call after setLocation, or else getBoundingBox is wrong
+                                     teleportBack = this.hasNewCollision(worldserver, this.player, axisalignedbb, newBox);
+                                    // Paper start - Add fail move event
+                                    if (teleportBack) {
+                                        io.papermc.paper.event.player.PlayerFailMoveEvent event = fireFailMove(io.papermc.paper.event.player.PlayerFailMoveEvent.FailReason.CLIPPED_INTO_BLOCK,
+                                            toX, toY, toZ, toYaw, toPitch, false);
+                                        if (event.isAllowed()) {
+                                            teleportBack = false;
+                                        }
+                                    }
+                                    // Paper end
+                                 } // else: no collision at all detected, why do we care?
+                             }
+                             if (!this.player.noPhysics && !this.player.isSleeping() && teleportBack) { // Paper end - optimise out extra getCubes
+@@ -1565,6 +1596,18 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+         }
+     }
+ 
+    // Paper start - Add fail move event
+    private io.papermc.paper.event.player.PlayerFailMoveEvent fireFailMove(io.papermc.paper.event.player.PlayerFailMoveEvent.FailReason failReason,
+               double toX, double toY, double toZ, float toYaw, float toPitch, boolean logWarning) {
+        Player player = this.getCraftPlayer();
+        Location from = new Location(player.getWorld(), this.lastPosX, this.lastPosY, this.lastPosZ, this.lastYaw, this.lastPitch);
+        Location to = new Location(player.getWorld(), toX, toY, toZ, toYaw, toPitch);
+        io.papermc.paper.event.player.PlayerFailMoveEvent event = new io.papermc.paper.event.player.PlayerFailMoveEvent(player, failReason,
+            false, logWarning, from, to);
+        event.callEvent();
+        return event;
+    }
+    // Paper end
+     // Paper start - optimise out extra getCubes
+     private boolean hasNewCollision(final ServerLevel world, final Entity entity, final AABB oldBox, final AABB newBox) {
+         final List<AABB> collisionsBB = new java.util.ArrayList<>();
--- a/patches/server/0973-Folia-scheduler-and-owned-region-API.patch
+++ b/patches/server/0973-Folia-scheduler-and-owned-region-API.patch
--- a/patches/server/0974-Only-erase-allay-memory-on-non-item-targets.patch
+++ b/patches/server/0974-Only-erase-allay-memory-on-non-item-targets.patch
@ -0,0 +1,29 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Bjarne Koll <lynxplay101@gmail.com>
+Date: Fri, 4 Aug 2023 15:53:36 +0200
+Subject: [PATCH] Only erase allay memory on non-item targets
+
+Spigot incorrectly instanceOf checks the EntityTargetEvent#getTarget
+against the internal ItemEntity type and removes the nearest wanted item
+memory if said instanceOf check fails, (which is always the case)
+causing allays to behave differently as they constantly loose their
+target item.
+
+This commit fixes the faulty behaviour by instance performing a check
+against the CraftItem type.
+
+diff --git a/src/main/java/net/minecraft/world/entity/ai/behavior/GoToWantedItem.java b/src/main/java/net/minecraft/world/entity/ai/behavior/GoToWantedItem.java
+index bd9aa4a5443da862be3403c1941113373741a87c..2f92eb39cde7b30a894db347ca85a506d880411e 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/behavior/GoToWantedItem.java
+++ b/src/main/java/net/minecraft/world/entity/ai/behavior/GoToWantedItem.java
+@@ -35,8 +35,9 @@ public class GoToWantedItem {
+                             if (event.isCancelled()) {
+                                 return false;
+                             }
+-                            if (!(event.getTarget() instanceof ItemEntity)) {
+                            if (!(event.getTarget() instanceof org.bukkit.craftbukkit.entity.CraftItem)) { // Paper - only erase allay memory on non-item targets
+                                 memoryaccessor2.erase();
+                                return false; // Paper - only erase allay memory on non-item targets
+                             }
+ 
+                             entityitem = (ItemEntity) ((org.bukkit.craftbukkit.entity.CraftEntity) event.getTarget()).getHandle();
--- a/patches/server/0975-API-for-updating-recipes-on-clients.patch
+++ b/patches/server/0975-API-for-updating-recipes-on-clients.patch
@ -0,0 +1,114 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Sat, 21 Aug 2021 17:25:38 -0700
+Subject: [PATCH] API for updating recipes on clients
+
+
+diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
+index 20eb64a88b887b539b24ea8cd8d9e63add8852df..c1790d8f13af1ff7059dfe952cbdcdcca22d8df4 100644
+--- a/src/main/java/net/minecraft/server/players/PlayerList.java
+++ b/src/main/java/net/minecraft/server/players/PlayerList.java
+@@ -1539,6 +1539,13 @@ public abstract class PlayerList {
+     }
+ 
+     public void reloadResources() {
+        // Paper start - split this method up into separate methods
+        this.reloadAdvancementData();
+        this.reloadTagData();
+        this.reloadRecipeData();
+    }
+    public void reloadAdvancementData() {
+        // Paper end
+         // CraftBukkit start
+         /*Iterator iterator = this.advancements.values().iterator();
+ 
+@@ -1554,7 +1561,15 @@ public abstract class PlayerList {
+         }
+         // CraftBukkit end
+ 
+        // Paper start
+    }
+    public void reloadTagData() {
+        // Paper end
+         this.broadcastAll(new ClientboundUpdateTagsPacket(TagNetworkSerialization.serializeTagsToNetwork(this.registries)));
+        // Paper start
+    }
+    public void reloadRecipeData() {
+        // Paper end
+         ClientboundUpdateRecipesPacket packetplayoutrecipeupdate = new ClientboundUpdateRecipesPacket(this.server.getRecipeManager().getRecipes());
+         Iterator iterator1 = this.players.iterator();
+ 
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+index 99d02cfed25b10c1418d2ee40c7f3d4f054897e4..4282f3c585877a477c52074059e9a5a7c1244e93 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -1128,6 +1128,18 @@ public final class CraftServer implements Server {
+         ReloadCommand.reload(this.console);
+     }
+ 
+    // Paper start
+    @Override
+    public void updateResources() {
+        this.playerList.reloadResources();
+    }
+
+    @Override
+    public void updateRecipes() {
+        this.playerList.reloadRecipeData();
+    }
+    // Paper end
+
+     private void loadIcon() {
+         this.icon = new CraftIconCache(null);
+         try {
+@@ -1508,6 +1520,13 @@ public final class CraftServer implements Server {
+ 
+     @Override
+     public boolean addRecipe(Recipe recipe) {
+        // Paper start
+        return this.addRecipe(recipe, false);
+    }
+
+    @Override
+    public boolean addRecipe(Recipe recipe, boolean resendRecipes) {
+        // Paper end
+         CraftRecipe toAdd;
+         if (recipe instanceof CraftRecipe) {
+             toAdd = (CraftRecipe) recipe;
+@@ -1537,6 +1556,11 @@ public final class CraftServer implements Server {
+             }
+         }
+         toAdd.addToCraftingManager();
+        // Paper start
+        if (resendRecipes) {
+            this.playerList.reloadRecipeData();
+        }
+        // Paper end
+         return true;
+     }
+ 
+@@ -1717,10 +1741,23 @@ public final class CraftServer implements Server {
+ 
+     @Override
+     public boolean removeRecipe(NamespacedKey recipeKey) {
+        // Paper start
+        return this.removeRecipe(recipeKey, false);
+    }
+
+    @Override
+    public boolean removeRecipe(NamespacedKey recipeKey, boolean resendRecipes) {
+        // Paper end
+         Preconditions.checkArgument(recipeKey != null, "recipeKey == null");
+ 
+         ResourceLocation mcKey = CraftNamespacedKey.toMinecraft(recipeKey);
+-        return this.getServer().getRecipeManager().removeRecipe(mcKey);
+        // Paper start - resend recipes on successful removal
+        boolean removed = this.getServer().getRecipeManager().removeRecipe(mcKey);
+        if (removed && resendRecipes) {
+            this.playerList.reloadRecipeData();
+        }
+        return removed;
+        // Paper end
+     }
+ 
+     @Override
--- a/patches/server/0976-Fix-rotation-when-spawning-display-entities.patch
+++ b/patches/server/0976-Fix-rotation-when-spawning-display-entities.patch
@ -0,0 +1,18 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Gameoholic <viner.atmic@gmail.com>
+Date: Sun, 30 Jul 2023 13:30:34 +0300
+Subject: [PATCH] Fix rotation when spawning display entities
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java b/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java
+index ee8819884868b70f2a3644141eca1d92abe2b7a8..b8043e9f92736ebfa0707613f2fec78b14c1fe72 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java
+@@ -1021,6 +1021,7 @@ public abstract class CraftRegionAccessor implements RegionAccessor {
+ 
+             if (entity != null) {
+                 entity.setPos(x, y, z);
+                entity.setRot(yaw, pitch); // Paper - Set Display Rotation
+             }
+         }
+ 
--- a/patches/server/0977-Only-capture-actual-tree-growth.patch
+++ b/patches/server/0977-Only-capture-actual-tree-growth.patch
@ -0,0 +1,70 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Sat, 21 Aug 2021 18:53:03 -0700
+Subject: [PATCH] Only capture actual tree growth
+
+
+diff --git a/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java b/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java
+index 105bb94b844c5ee85b53aca95360e7b2caf374cc..e6ac20a38f31bb0cd6b8840b2518f6992ef7f518 100644
+--- a/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java
+++ b/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java
+@@ -866,6 +866,7 @@ public interface DispenseItemBehavior {
+                     if (!fertilizeEvent.isCancelled()) {
+                         for (org.bukkit.block.BlockState blockstate : blocks) {
+                             blockstate.update(true);
+                            worldserver.checkCapturedTreeStateForObserverNotify(blockposition, (org.bukkit.craftbukkit.block.CraftBlockState) blockstate); // Paper - notify observers even if grow failed
+                         }
+                     }
+                 }
+diff --git a/src/main/java/net/minecraft/world/item/ItemStack.java b/src/main/java/net/minecraft/world/item/ItemStack.java
+index d4df53d022eb58cf43d787ed84bd94fdf1684d69..c4228284145c27f6fe995bd1875d3f17f4786ddd 100644
+--- a/src/main/java/net/minecraft/world/item/ItemStack.java
+++ b/src/main/java/net/minecraft/world/item/ItemStack.java
+@@ -422,6 +422,7 @@ public final class ItemStack {
+                     }
+                     for (CraftBlockState blockstate : blocks) {
+                         world.setBlock(blockstate.getPosition(),blockstate.getHandle(), blockstate.getFlag()); // SPIGOT-7248 - manual update to avoid physics where appropriate
+                        world.checkCapturedTreeStateForObserverNotify(blockposition, blockstate); // Paper - notify observers even if grow failed
+                         if (blockstate instanceof org.bukkit.craftbukkit.block.CapturedBlockState capturedBlockState) capturedBlockState.checkTreeBlockHack(); // Paper
+                     }
+                     entityhuman.awardStat(Stats.ITEM_USED.get(item)); // SPIGOT-7236 - award stat
+diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
+index 74e68160dc650c0426785b0f88892c29edadb29c..0afad3487a3939981abda6a2342e90683816a39f 100644
+--- a/src/main/java/net/minecraft/world/level/Level.java
+++ b/src/main/java/net/minecraft/world/level/Level.java
+@@ -1888,4 +1888,11 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+         return null;
+     }
+     // Paper end - optimize redstone (Alternate Current)
+    // Paper start - notify observers even if grow failed
+    public void checkCapturedTreeStateForObserverNotify(final BlockPos pos, final CraftBlockState craftBlockState) {
+        if (craftBlockState.getPosition().getY() == pos.getY() && this.getBlockState(craftBlockState.getPosition()) == craftBlockState.getHandle()) { // notify observers if the block state is the same and the Y level equals the original y level (for mega trees)
+            this.notifyAndUpdatePhysics(craftBlockState.getPosition(), null, craftBlockState.getHandle(), craftBlockState.getHandle(), craftBlockState.getHandle(), craftBlockState.getFlag(), 512);
+        }
+    }
+    // Paper end - notify observers even if grow failed
+ }
+diff --git a/src/main/java/net/minecraft/world/level/block/SaplingBlock.java b/src/main/java/net/minecraft/world/level/block/SaplingBlock.java
+index 7e6ee9c1ccef3eaa6b2edc39e414bd186426aee5..836c86104ed4f0d375330c9123af5d502efefa4d 100644
+--- a/src/main/java/net/minecraft/world/level/block/SaplingBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/SaplingBlock.java
+@@ -85,6 +85,7 @@ public class SaplingBlock extends BushBlock implements BonemealableBlock {
+                     if (event == null || !event.isCancelled()) {
+                         for (BlockState blockstate : blocks) {
+                             blockstate.update(true);
+                            world.checkCapturedTreeStateForObserverNotify(pos, (org.bukkit.craftbukkit.block.CraftBlockState) blockstate); // Paper - notify observers even if grow failed
+                         }
+                     }
+                 }
+diff --git a/src/main/java/org/bukkit/craftbukkit/block/CraftBlock.java b/src/main/java/org/bukkit/craftbukkit/block/CraftBlock.java
+index 0a96b00a98227714ef99005e0a223765feae8fe9..e5506a7d074a9f89d41f4d5d7549a458779bef20 100644
+--- a/src/main/java/org/bukkit/craftbukkit/block/CraftBlock.java
+++ b/src/main/java/org/bukkit/craftbukkit/block/CraftBlock.java
+@@ -566,6 +566,7 @@ public class CraftBlock implements Block {
+             if (!event.isCancelled()) {
+                 for (BlockState blockstate : blocks) {
+                     blockstate.update(true);
+                    world.checkCapturedTreeStateForObserverNotify(this.position, (org.bukkit.craftbukkit.block.CraftBlockState) blockstate); // Paper - notify observers even if grow failed
+                 }
+             }
+         }
--- a/patches/server/0978-Use-correct-source-for-mushroom-block-spread-event.patch
+++ b/patches/server/0978-Use-correct-source-for-mushroom-block-spread-event.patch
@ -0,0 +1,27 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Warrior <50800980+Warriorrrr@users.noreply.github.com>
+Date: Tue, 8 Aug 2023 11:49:32 +0200
+Subject: [PATCH] Use correct source for mushroom block spread event
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/MushroomBlock.java b/src/main/java/net/minecraft/world/level/block/MushroomBlock.java
+index 5889cb1cdb64875f0d7a7c681808b45cdc661d8e..7368c76a01275223a7bd3df1d36e80a15f66edbb 100644
+--- a/src/main/java/net/minecraft/world/level/block/MushroomBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/MushroomBlock.java
+@@ -68,6 +68,7 @@ public class MushroomBlock extends BushBlock implements BonemealableBlock {
+             }
+ 
+             BlockPos blockposition2 = pos.offset(random.nextInt(3) - 1, random.nextInt(2) - random.nextInt(2), random.nextInt(3) - 1);
+            final BlockPos sourcePos = pos; // Paper
+ 
+             for (int j = 0; j < 4; ++j) {
+                 if (world.isEmptyBlock(blockposition2) && state.canSurvive(world, blockposition2)) {
+@@ -78,7 +79,7 @@ public class MushroomBlock extends BushBlock implements BonemealableBlock {
+             }
+ 
+             if (world.isEmptyBlock(blockposition2) && state.canSurvive(world, blockposition2)) {
+-                org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockSpreadEvent(world, pos, blockposition2, state, 2); // CraftBukkit
+                org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockSpreadEvent(world, sourcePos, blockposition2, state, 2); // CraftBukkit // Paper
+             }
+         }
+ 
--- a/patches/server/0979-Respect-randomizeData-on-more-entities-when-spawning.patch
+++ b/patches/server/0979-Respect-randomizeData-on-more-entities-when-spawning.patch
@ -0,0 +1,61 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Thu, 13 Jul 2023 16:10:07 -0700
+Subject: [PATCH] Respect randomizeData on more entities when spawning
+
+* ItemEntity
+* PrimedTNT
+* FireworkRocketEntity
+* ExperienceOrb
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java b/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java
+index b8043e9f92736ebfa0707613f2fec78b14c1fe72..c343577efccfc95274b5f2a870d057ec57529484 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftRegionAccessor.java
+@@ -634,6 +634,11 @@ public abstract class CraftRegionAccessor implements RegionAccessor {
+         } else if (org.bukkit.entity.Item.class.isAssignableFrom(clazz)) {
+             entity = new net.minecraft.world.entity.item.ItemEntity(world, x, y, z, new net.minecraft.world.item.ItemStack(net.minecraft.world.item.Items.DIRT));
+             // Paper end
+            // Paper start - respect randomizeData
+            if (!randomizeData) {
+                entity.setDeltaMovement(net.minecraft.world.phys.Vec3.ZERO);
+            }
+            // Paper end - respect randomizeData
+         } else if (FallingBlock.class.isAssignableFrom(clazz)) {
+             BlockPos pos = BlockPos.containing(x, y, z);
+             entity = new FallingBlockEntity(world, x, y, z, this.getHandle().getBlockState(pos)); // Paper
+@@ -691,6 +696,14 @@ public abstract class CraftRegionAccessor implements RegionAccessor {
+                 entity.moveTo(x, y, z, yaw, pitch);
+             } else if (Firework.class.isAssignableFrom(clazz)) {
+                 entity = new FireworkRocketEntity(world, x, y, z, net.minecraft.world.item.ItemStack.EMPTY);
+                // Paper start - respect randomizeData
+                if (!randomizeData) {
+                    // logic below was taken from FireworkRocketEntity constructor
+                    entity.setDeltaMovement(0, 0.05, 0);
+                    //noinspection PointlessArithmeticExpression
+                    ((FireworkRocketEntity) entity).lifetime = 10 * 1 + 6;
+                }
+                // Paper end - respect randomizeData
+             }
+         } else if (Minecart.class.isAssignableFrom(clazz)) {
+             if (PoweredMinecart.class.isAssignableFrom(clazz)) {
+@@ -994,8 +1007,19 @@ public abstract class CraftRegionAccessor implements RegionAccessor {
+             }
+         } else if (TNTPrimed.class.isAssignableFrom(clazz)) {
+             entity = new PrimedTnt(world, x, y, z, null);
+            // Paper start - respect randomizeData
+            if (!randomizeData) {
+                entity.setDeltaMovement(net.minecraft.world.phys.Vec3.ZERO);
+            }
+            // Paper end - respect randomizeData
+         } else if (ExperienceOrb.class.isAssignableFrom(clazz)) {
+             entity = new net.minecraft.world.entity.ExperienceOrb(world, x, y, z, 0, org.bukkit.entity.ExperienceOrb.SpawnReason.CUSTOM, null, null); // Paper
+            // Paper start - respect randomizeData
+            if (!randomizeData) {
+                entity.setDeltaMovement(net.minecraft.world.phys.Vec3.ZERO);
+                entity.setYRot(0);
+            }
+            // Paper end - respect randomizeData
+         } else if (LightningStrike.class.isAssignableFrom(clazz)) {
+             entity = net.minecraft.world.entity.EntityType.LIGHTNING_BOLT.create(world);
+             entity.moveTo(location.getX(), location.getY(), location.getZ());
--- a/patches/server/0980-Use-correct-seed-on-api-world-load.patch
+++ b/patches/server/0980-Use-correct-seed-on-api-world-load.patch
@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Florian Schmidt <florian@f012.dev>
+Date: Fri, 28 Jul 2023 14:14:35 +0200
+Subject: [PATCH] Use correct seed on api world load
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+index 4282f3c585877a477c52074059e9a5a7c1244e93..b64d08d5fed98a919fcdfda1592a1f825525075d 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -1346,7 +1346,7 @@ public final class CraftServer implements Server {
+ 
+         // Paper - move down
+ 
+-        long j = BiomeManager.obfuscateSeed(creator.seed());
+        long j = BiomeManager.obfuscateSeed(worlddata.worldGenOptions().seed()); // Paper - use world seed
+         List<CustomSpawner> list = ImmutableList.of(new PhantomSpawner(), new PatrolSpawner(), new CatSpawner(), new VillageSiege(), new WanderingTraderSpawner(worlddata));
+         LevelStem worlddimension = iregistry.get(actualDimension);
+ 
--- a/patches/server/0981-Remove-UpgradeData-neighbour-ticks-outside-of-range.patch
+++ b/patches/server/0981-Remove-UpgradeData-neighbour-ticks-outside-of-range.patch
@ -0,0 +1,49 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Spottedleaf <Spottedleaf@users.noreply.github.com>
+Date: Wed, 9 Aug 2023 14:00:40 -0700
+Subject: [PATCH] Remove UpgradeData neighbour ticks outside of range
+
+The lists are only supposed to contain ticks for the 1 radius
+neighbours of the chunk.
+
+diff --git a/src/main/java/net/minecraft/world/level/chunk/UpgradeData.java b/src/main/java/net/minecraft/world/level/chunk/UpgradeData.java
+index 8943081f270d5328b4f333b7bc1ae1a449d1788c..0f94af3502ef517c33d04841a80ea2ace077f0af 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/UpgradeData.java
+++ b/src/main/java/net/minecraft/world/level/chunk/UpgradeData.java
+@@ -99,6 +99,24 @@ public class UpgradeData {
+ 
+     }
+ 
+    // Paper start - filter out relocated neighbour ticks
+    private static <T> void filterTickList(int chunkX, int chunkZ, List<SavedTick<T>> ticks) {
+        for (java.util.Iterator<SavedTick<T>> iterator = ticks.iterator(); iterator.hasNext();) {
+            SavedTick<T> tick = iterator.next();
+            BlockPos tickPos = tick.pos();
+            int tickCX = tickPos.getX() >> 4;
+            int tickCZ = tickPos.getZ() >> 4;
+
+            int dist = Math.max(Math.abs(chunkX - tickCX), Math.abs(chunkZ - tickCZ));
+
+            if (dist != 1) {
+                LOGGER.warn("Neighbour tick '" + tick + "' serialized in chunk (" + chunkX + "," + chunkZ + ") is too far (" + tickCX + "," + tickCZ + ")");
+                iterator.remove();
+            }
+        }
+    }
+    // Paper end - filter out relocated neighbour ticks
+
+     public void upgrade(LevelChunk chunk) {
+         this.upgradeInside(chunk);
+ 
+@@ -106,6 +124,11 @@ public class UpgradeData {
+             upgradeSides(chunk, direction8);
+         }
+ 
+        // Paper start - filter out relocated neighbour ticks
+        filterTickList(chunk.locX, chunk.locZ, this.neighborBlockTicks);
+        filterTickList(chunk.locX, chunk.locZ, this.neighborFluidTicks);
+        // Paper end - filter out relocated neighbour ticks
+
+         Level level = chunk.getLevel();
+         this.neighborBlockTicks.forEach((tick) -> {
+             Block block = tick.type() == Blocks.AIR ? level.getBlockState(tick.pos()).getBlock() : tick.type();
--- a/patches/server/0982-Cache-map-ids-on-item-frames.patch
+++ b/patches/server/0982-Cache-map-ids-on-item-frames.patch
@ -0,0 +1,39 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Warrior <50800980+Warriorrrr@users.noreply.github.com>
+Date: Mon, 7 Aug 2023 12:58:28 +0200
+Subject: [PATCH] Cache map ids on item frames
+
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerEntity.java b/src/main/java/net/minecraft/server/level/ServerEntity.java
+index 625a598eb5f3c9c5ea60ae9ea50974bb08abbf85..9f1b424f8437f0f859d4f177ecc52233ad8e3357 100644
+--- a/src/main/java/net/minecraft/server/level/ServerEntity.java
+++ b/src/main/java/net/minecraft/server/level/ServerEntity.java
+@@ -118,7 +118,7 @@ public class ServerEntity {
+                 ItemStack itemstack = entityitemframe.getItem();
+ 
+                 if (this.level.paperConfig().maps.itemFrameCursorUpdateInterval > 0 && this.tickCount % this.level.paperConfig().maps.itemFrameCursorUpdateInterval == 0 && itemstack.getItem() instanceof MapItem) { // CraftBukkit - Moved this.tickCounter % 10 logic here so item frames do not enter the other blocks // Paper - Make item frame map cursor update interval configurable
+-                    Integer integer = MapItem.getMapId(itemstack);
+                    Integer integer = entityitemframe.cachedMapId; // Paper
+                     MapItemSavedData worldmap = MapItem.getSavedData(integer, this.level);
+ 
+                     if (worldmap != null) {
+diff --git a/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java b/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java
+index 9c11d0af958ec47408d238d34d30750d29ecdd88..69912c5b300b67394dce3876d2d96872033cf156 100644
+--- a/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java
+++ b/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java
+@@ -50,6 +50,7 @@ public class ItemFrame extends HangingEntity {
+     public static final int NUM_ROTATIONS = 8;
+     public float dropChance;
+     public boolean fixed;
+    public Integer cachedMapId; // Paper
+ 
+     public ItemFrame(EntityType<? extends ItemFrame> type, Level world) {
+         super(type, world);
+@@ -388,6 +389,7 @@ public class ItemFrame extends HangingEntity {
+     }
+ 
+     private void onItemChanged(ItemStack stack) {
+        this.cachedMapId = MapItem.getMapId(stack); // Paper
+         if (!stack.isEmpty() && stack.getFrame() != this) {
+             stack.setEntityRepresentation(this);
+         }
--- a/patches/server/0983-Fix-custom-statistic-criteria-creation.patch
+++ b/patches/server/0983-Fix-custom-statistic-criteria-creation.patch
@ -0,0 +1,23 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Noah van der Aa <ndvdaa@gmail.com>
+Date: Sat, 12 Aug 2023 15:33:49 +0200
+Subject: [PATCH] Fix custom statistic criteria creation
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
+index 7cfb8ffd7d107aef20a86d044b453c49e9f59b7f..c0e36388652e89059c91117722945645119a5738 100644
+--- a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
+++ b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
+@@ -614,6 +614,12 @@ public final class CraftMagicNumbers implements UnsafeValues {
+         net.minecraft.core.Holder<net.minecraft.world.level.biome.Biome> biomeBase = cra.getHandle().registryAccess().registryOrThrow(net.minecraft.core.registries.Registries.BIOME).getHolderOrThrow(net.minecraft.resources.ResourceKey.create(net.minecraft.core.registries.Registries.BIOME, org.bukkit.craftbukkit.util.CraftNamespacedKey.toMinecraft(biomeKey)));
+         cra.setBiome(x, y, z, biomeBase);
+     }
+
+    @Override
+    public String getStatisticCriteriaKey(org.bukkit.Statistic statistic) {
+        if (statistic.getType() != org.bukkit.Statistic.Type.UNTYPED) return "minecraft.custom:minecraft." + statistic.getKey().getKey();
+        return org.bukkit.craftbukkit.CraftStatistic.getNMSStatistic(statistic).getName();
+    }
+     // Paper end
+ 
+     /**
--- a/patches/server/0984-Bandaid-fix-for-Effect.patch
+++ b/patches/server/0984-Bandaid-fix-for-Effect.patch
@ -0,0 +1,142 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Fri, 28 Jul 2023 15:02:44 -0700
+Subject: [PATCH] Bandaid fix for Effect
+
+Effect or LevelEvent needs to be replaced
+but ideally after the enum PR has been merged
+upstream. Until then, this test and these fixes
+should address all the known issues with them
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftEffect.java b/src/main/java/org/bukkit/craftbukkit/CraftEffect.java
+index 5a5a8945c786e16ff0df62494ddd1ac85c42b53f..63f9735d356dafd579cee4423d3037eb4ed9b2c6 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftEffect.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftEffect.java
+@@ -15,12 +15,15 @@ public class CraftEffect {
+     public static <T> int getDataValue(Effect effect, T data) {
+         int datavalue;
+         switch (effect) {
+        case PARTICLES_SCULK_CHARGE: // Paper - add missing effects
+         case VILLAGER_PLANT_GROW:
+             datavalue = (Integer) data;
+             break;
+         case POTION_BREAK:
+            if (data instanceof Potion) { // Paper - use Color for POTION_BREAK
+             datavalue = ((Potion) data).toDamageValue() & 0x3F;
+             break;
+            } // Paper - Color will fall through to cast below
+         case INSTANT_POTION_BREAK:
+             datavalue = ((Color) data).asRGB();
+             break;
+@@ -59,8 +62,15 @@ public class CraftEffect {
+             }
+             break;
+         case STEP_SOUND:
+            if (data instanceof Material) { // Paper - support BlockData
+             Preconditions.checkArgument(((Material) data).isBlock(), "Material %s is not a block!", data);
+             datavalue = Block.getId(CraftMagicNumbers.getBlock((Material) data).defaultBlockState());
+            // Paper start - support BlockData
+                break;
+            }
+        case PARTICLES_AND_SOUND_BRUSH_BLOCK_COMPLETE:
+            datavalue = Block.getId(((org.bukkit.craftbukkit.block.data.CraftBlockData) data).getState());
+            // Paper end
+             break;
+         case COMPOSTER_FILL_ATTEMPT:
+             datavalue = ((Boolean) data) ? 1 : 0;
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+index c77fec78636805a496ecea3e56f26290dbcbffff..abb14719496971a780650782bdce17c638c7b270 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+@@ -1382,7 +1382,7 @@ public class CraftWorld extends CraftRegionAccessor implements World {
+     public <T> void playEffect(Location loc, Effect effect, T data, int radius) {
+         if (data != null) {
+             Preconditions.checkArgument(effect.getData() != null, "Effect.%s does not have a valid Data", effect);
+-            Preconditions.checkArgument(effect.getData().isAssignableFrom(data.getClass()), "%s data cannot be used for the %s effect", data.getClass().getName(), effect);
+            Preconditions.checkArgument(effect.isApplicable(data), "%s data cannot be used for the %s effect", data.getClass().getName(), effect); // Paper
+         } else {
+             // Special case: the axis is optional for ELECTRIC_SPARK
+             Preconditions.checkArgument(effect.getData() == null || effect == Effect.ELECTRIC_SPARK, "Wrong kind of data for the %s effect", effect);
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index d252f0313b1d73758782249060e7c57afb5c5418..082350f866eaef5fc8f98ebc217aa02cdcab5a46 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -875,7 +875,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+         Preconditions.checkArgument(effect != null, "Effect cannot be null");
+         if (data != null) {
+             Preconditions.checkArgument(effect.getData() != null, "Effect.%s does not have a valid Data", effect);
+-            Preconditions.checkArgument(effect.getData().isAssignableFrom(data.getClass()), "%s data cannot be used for the %s effect", data.getClass().getName(), effect);
+            Preconditions.checkArgument(effect.isApplicable(data), "%s data cannot be used for the %s effect", data.getClass().getName(), effect); // Paper
+         } else {
+             // Special case: the axis is optional for ELECTRIC_SPARK
+             Preconditions.checkArgument(effect.getData() == null || effect == Effect.ELECTRIC_SPARK, "Wrong kind of data for the %s effect", effect);
+diff --git a/src/test/java/org/bukkit/EffectTest.java b/src/test/java/org/bukkit/EffectTest.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..875eacc2e5776901ba8593d0183844db2571f71b
+--- /dev/null
+++ b/src/test/java/org/bukkit/EffectTest.java
+@@ -0,0 +1,64 @@
+package org.bukkit;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Modifier;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import net.minecraft.world.level.block.LevelEvent;
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+public class EffectTest {
+
+    private static List<Integer> collectNmsLevelEvents() throws ReflectiveOperationException {
+        final List<Integer> events = new ArrayList<>();
+        for (final Field field : LevelEvent.class.getFields()) {
+            if (Modifier.isStatic(field.getModifiers()) && Modifier.isFinal(field.getModifiers()) && field.getType() == int.class) {
+                events.add((int) field.get(null));
+            }
+        }
+        return events;
+    }
+
+    private static boolean isNotDeprecated(Effect effect) throws ReflectiveOperationException {
+        return !Effect.class.getDeclaredField(effect.name()).isAnnotationPresent(Deprecated.class);
+    }
+
+    @SuppressWarnings("deprecation")
+    @Test
+    public void checkAllApiExists() throws ReflectiveOperationException {
+        Map<Integer, Effect> toId = new HashMap<>();
+        for (final Effect effect : Effect.values()) {
+            if (isNotDeprecated(effect)) {
+                final Effect put = toId.put(effect.getId(), effect);
+                assertNull(put, "duplicate API effect: " + put);
+            }
+        }
+
+        for (final Integer event : collectNmsLevelEvents()) {
+            assertNotNull(toId.get(event), "missing API Effect: " + event);
+        }
+    }
+
+    @SuppressWarnings("deprecation")
+    @Test
+    public void checkNoExtraApi() throws ReflectiveOperationException {
+        Map<Integer, Effect> toId = new HashMap<>();
+        for (final Effect effect : Effect.values()) {
+            if (isNotDeprecated(effect)) {
+                final Effect put = toId.put(effect.getId(), effect);
+                assertNull(put, "duplicate API effect: " + put);
+            }
+        }
+
+        final List<Integer> nmsEvents = collectNmsLevelEvents();
+        for (final Map.Entry<Integer, Effect> entry : toId.entrySet()) {
+            assertTrue(nmsEvents.contains(entry.getKey()), "Extra API Effect: " + entry.getValue());
+        }
+    }
+}
--- a/patches/server/0985-SculkCatalyst-bloom-API.patch
+++ b/patches/server/0985-SculkCatalyst-bloom-API.patch
@ -0,0 +1,33 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Oliwier Miodun <naczs@blueflow.pl>
+Date: Mon, 10 Jul 2023 17:59:42 +0200
+Subject: [PATCH] SculkCatalyst bloom API
+
+== AT ==
+public net.minecraft.world.level.block.entity.SculkCatalystBlockEntity$CatalystListener bloom(Lnet/minecraft/server/level/ServerLevel;Lnet/minecraft/core/BlockPos;Lnet/minecraft/world/level/block/state/BlockState;Lnet/minecraft/util/RandomSource;)V
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/block/CraftSculkCatalyst.java b/src/main/java/org/bukkit/craftbukkit/block/CraftSculkCatalyst.java
+index 139026c06589bb9c4201e20cd200887a8527fe55..a4ad8a90d0c2e4978370f9631dbd3a430e951b1c 100644
+--- a/src/main/java/org/bukkit/craftbukkit/block/CraftSculkCatalyst.java
+++ b/src/main/java/org/bukkit/craftbukkit/block/CraftSculkCatalyst.java
+@@ -32,4 +32,20 @@ public class CraftSculkCatalyst extends CraftBlockEntityState<SculkCatalystBlock
+     public CraftSculkCatalyst copy() {
+         return new CraftSculkCatalyst(this);
+     }
+
+    // Paper start - SculkCatalyst bloom API
+    @Override
+    public void bloom(@org.jetbrains.annotations.NotNull io.papermc.paper.math.Position position, int charge) {
+        com.google.common.base.Preconditions.checkNotNull(position);
+        requirePlaced();
+
+        getTileEntity().getListener().bloom(
+            world.getHandle(),
+            getTileEntity().getBlockPos(),
+            getTileEntity().getBlockState(),
+            world.getHandle().getRandom()
+        );
+        getTileEntity().getListener().getSculkSpreader().addCursors(io.papermc.paper.util.MCUtil.toBlockPos(position), charge);
+    }
+    // Paper end
+ }
--- a/patches/server/0986-API-for-an-entity-s-scoreboard-name.patch
+++ b/patches/server/0986-API-for-an-entity-s-scoreboard-name.patch
@ -0,0 +1,24 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Sun, 9 Jul 2023 11:55:02 -0700
+Subject: [PATCH] API for an entity's scoreboard name
+
+Was obtainable through different methods, but you had to use different
+methods depending on the implementation of Entity you were working with.
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+index 3b730c298c0e902bd1888d69e426513c57514c93..c4343cbdea19a0dd671ed136a6a19ebf831ce8ab 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+@@ -1550,4 +1550,11 @@ public abstract class CraftEntity implements org.bukkit.entity.Entity {
+         return !this.getHandle().level().noCollision(this.getHandle(), aabb);
+     }
+     // Paper End - Collision API
+
+    // Paper start - entity scoreboard name
+    @Override
+    public String getScoreboardEntryName() {
+        return this.getHandle().getScoreboardName();
+    }
+    // Paper end - entity scoreboard name
+ }
--- a/patches/server/0987-Improve-cancelling-PreCreatureSpawnEvent-with-per-pl.patch
+++ b/patches/server/0987-Improve-cancelling-PreCreatureSpawnEvent-with-per-pl.patch
@ -0,0 +1,90 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: kickash32 <kickash32@gmail.com>
+Date: Mon, 5 Apr 2021 01:42:35 -0400
+Subject: [PATCH] Improve cancelling PreCreatureSpawnEvent with per player mob
+ spawns
+
+
+diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java
+index c081842b4416d15342cbfc583ef367901dab2b7e..4d406ced4a1996b8883574ce0b785dc17370793b 100644
+--- a/src/main/java/net/minecraft/server/level/ChunkMap.java
+++ b/src/main/java/net/minecraft/server/level/ChunkMap.java
+@@ -387,8 +387,26 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
+         }
+     }
+ 
+    // Paper start - per player mob count backoff
+    public void updateFailurePlayerMobTypeMap(int chunkX, int chunkZ, net.minecraft.world.entity.MobCategory mobCategory) {
+        if (!this.level.paperConfig().entities.spawning.perPlayerMobSpawns) {
+            return;
+        }
+        int idx = mobCategory.ordinal();
+        final com.destroystokyo.paper.util.maplist.ReferenceList<ServerPlayer> inRange =
+            this.getNearbyPlayers().getPlayersByChunk(chunkX, chunkZ, io.papermc.paper.util.player.NearbyPlayers.NearbyMapType.TICK_VIEW_DISTANCE);
+        if (inRange == null) {
+            return;
+        }
+        final Object[] backingSet = inRange.getRawData();
+        for (int i = 0, len = inRange.size(); i < len; i++) {
+            ++((ServerPlayer)backingSet[i]).mobBackoffCounts[idx];
+        }
+    }
+    // Paper end - per player mob count backoff
+
+     public int getMobCountNear(ServerPlayer entityPlayer, net.minecraft.world.entity.MobCategory mobCategory) {
+-        return entityPlayer.mobCounts[mobCategory.ordinal()];
+        return entityPlayer.mobCounts[mobCategory.ordinal()] + entityPlayer.mobBackoffCounts[mobCategory.ordinal()]; // Paper - per player mob count backoff
+     }
+     // Paper end
+ 
+diff --git a/src/main/java/net/minecraft/server/level/ServerChunkCache.java b/src/main/java/net/minecraft/server/level/ServerChunkCache.java
+index 1f7586b71c579d48de32a307c0ce543130f0851b..bf14dbec0a08370364bf652ababadac27917b7f1 100644
+--- a/src/main/java/net/minecraft/server/level/ServerChunkCache.java
+++ b/src/main/java/net/minecraft/server/level/ServerChunkCache.java
+@@ -539,7 +539,17 @@ public class ServerChunkCache extends ChunkSource {
+                 if ((this.spawnFriendlies || this.spawnEnemies) && this.level.paperConfig().entities.spawning.perPlayerMobSpawns) { // don't count mobs when animals and monsters are disabled
+                     // re-set mob counts
+                     for (ServerPlayer player : this.level.players) {
+-                        Arrays.fill(player.mobCounts, 0);
+                        // Paper start - per player mob spawning backoff
+                        for (int ii = 0; ii < ServerPlayer.MOBCATEGORY_TOTAL_ENUMS; ii++) {
+                            player.mobCounts[ii] = 0;
+
+                            int newBackoff = player.mobBackoffCounts[ii] - 1; // TODO make configurable bleed // TODO use nonlinear algorithm?
+                            if (newBackoff < 0) {
+                                newBackoff = 0;
+                            }
+                            player.mobBackoffCounts[ii] = newBackoff;
+                        }
+                        // Paper end - per player mob spawning backoff
+                     }
+                     spawnercreature_d = NaturalSpawner.createState(naturalSpawnChunkCount, this.level.getAllEntities(), this::getFullChunk, null, true);
+                 } else {
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+index cca1f44ba8cefcc0ee3e6dadd175bd67b311b2de..25772043f3b4483b9f5e32ba9489da52add6941a 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -260,6 +260,7 @@ public class ServerPlayer extends Player {
+     public static final int MOBCATEGORY_TOTAL_ENUMS = net.minecraft.world.entity.MobCategory.values().length;
+     public final int[] mobCounts = new int[MOBCATEGORY_TOTAL_ENUMS]; // Paper
+     // Paper end - mob spawning rework
+    public final int[] mobBackoffCounts = new int[MOBCATEGORY_TOTAL_ENUMS]; // Paper - per player mob count backoff
+ 
+     // CraftBukkit start
+     public String displayName;
+diff --git a/src/main/java/net/minecraft/world/level/NaturalSpawner.java b/src/main/java/net/minecraft/world/level/NaturalSpawner.java
+index d08c7b0b52065980f1f13c5533ff6355028322db..3cdddda9c0618e95288b81b975d499c8dd30c05f 100644
+--- a/src/main/java/net/minecraft/world/level/NaturalSpawner.java
+++ b/src/main/java/net/minecraft/world/level/NaturalSpawner.java
+@@ -277,6 +277,11 @@ public final class NaturalSpawner {
+ 
+                                     // Paper start
+                                     PreSpawnStatus doSpawning = isValidSpawnPostitionForType(world, group, structuremanager, chunkgenerator, biomesettingsmobs_c, blockposition_mutableblockposition, d2);
+                                    // Paper start - mob count backoff
+                                    if (doSpawning == PreSpawnStatus.ABORT || doSpawning == PreSpawnStatus.CANCELLED) {
+                                        world.getChunkSource().chunkMap.updateFailurePlayerMobTypeMap(blockposition_mutableblockposition.getX() >> 4, blockposition_mutableblockposition.getZ() >> 4, group);
+                                    }
+                                    // Paper end - mob count backoff
+                                     if (doSpawning == PreSpawnStatus.ABORT) {
+                                         return j; // Paper
+                                     }
--- a/patches/server/0988-Deprecate-and-replace-methods-with-old-StructureType.patch
+++ b/patches/server/0988-Deprecate-and-replace-methods-with-old-StructureType.patch
@ -0,0 +1,54 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Sat, 10 Dec 2022 17:52:38 -0800
+Subject: [PATCH] Deprecate and replace methods with old StructureType
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+index b64d08d5fed98a919fcdfda1592a1f825525075d..782bb8ca67517dde5dba8f0a133eb8699353dd01 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -1950,6 +1950,11 @@ public final class CraftServer implements Server {
+ 
+         ServerLevel worldServer = ((CraftWorld) world).getHandle();
+         Location structureLocation = world.locateNearestStructure(location, structureType, radius, findUnexplored);
+        // Paper start - don't throw NPE
+        if (structureLocation == null) {
+            throw new IllegalStateException("Could not find a structure for " + structureType);
+        }
+        // Paper end
+         BlockPos structurePosition = CraftLocation.toBlockPosition(structureLocation);
+ 
+         // Create map with trackPlayer = true, unlimitedTracking = true
+@@ -1960,6 +1965,31 @@ public final class CraftServer implements Server {
+ 
+         return CraftItemStack.asBukkitCopy(stack);
+     }
+    // Paper start - copied from above (uses un-deprecated StructureType type)
+    @Override
+    public ItemStack createExplorerMap(World world, Location location, org.bukkit.generator.structure.StructureType structureType, org.bukkit.map.MapCursor.Type mapIcon, int radius, boolean findUnexplored) {
+        Preconditions.checkArgument(world != null, "World cannot be null");
+        Preconditions.checkArgument(location != null, "Location cannot be null");
+        Preconditions.checkArgument(structureType != null, "StructureType cannot be null");
+        Preconditions.checkArgument(mapIcon != null, "mapIcon cannot be null");
+
+        ServerLevel worldServer = ((CraftWorld) world).getHandle();
+        final org.bukkit.util.StructureSearchResult structureSearchResult = world.locateNearestStructure(location, structureType, radius, findUnexplored);
+        if (structureSearchResult == null) {
+            return null;
+        }
+        Location structureLocation = structureSearchResult.getLocation();
+        BlockPos structurePosition = new BlockPos(structureLocation.getBlockX(), structureLocation.getBlockY(), structureLocation.getBlockZ());
+
+        // Create map with showIcons = true, unlimitedTracking = true
+        net.minecraft.world.item.ItemStack stack = MapItem.create(worldServer, structurePosition.getX(), structurePosition.getZ(), MapView.Scale.NORMAL.getValue(), true, true);
+        MapItem.renderBiomePreviewMap(worldServer, stack);
+        // "+" map ID taken from VillagerTrades$TreasureMapForEmeralds
+        MapItem.getSavedData(stack, worldServer).addTargetDecoration(stack, structurePosition, "+", MapDecoration.Type.byIcon(mapIcon.getValue()));
+
+        return CraftItemStack.asBukkitCopy(stack);
+    }
+    // Paper end
+ 
+     @Override
+     public void shutdown() {
--- a/patches/server/0989-Don-t-tab-complete-namespaced-commands-if-send-names.patch
+++ b/patches/server/0989-Don-t-tab-complete-namespaced-commands-if-send-names.patch
@ -0,0 +1,28 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: EpicPlayerA10 <adasko.lesiak@gmail.com>
+Date: Sun, 18 Jun 2023 12:38:24 +0200
+Subject: [PATCH] Don't tab-complete namespaced commands if send-namespaced is
+ false
+
+Tab-complete packet is supposed to tab-complete args for commands, but
+it also can suggest commands like in version 1.12.2 or lower.
+
+This patch prevents server from sending namespaced commands when player
+requests tab-complete only commands.
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index c01d38b673303b06ad0a932641446b1a8f4fda8c..e49a4044710cabb8a74d9aa83b28bddf025af1f2 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -809,6 +809,11 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+                         ParseResults<CommandSourceStack> parseresults = this.server.getCommands().getDispatcher().parse(stringreader, this.player.createCommandSourceStack());
+ 
+                         this.server.getCommands().getDispatcher().getCompletionSuggestions(parseresults).thenAccept((suggestions) -> {
+                            // Paper start - Don't tab-complete namespaced commands if send-namespaced is false
+                            if (!org.spigotmc.SpigotConfig.sendNamespaced && suggestions.getRange().getStart() <= 1) {
+                                suggestions.getList().removeIf(suggestion -> suggestion.getText().contains(":"));
+                            }
+                            // Paper end
+                             // Paper start - Brigadier API
+                             com.destroystokyo.paper.event.brigadier.AsyncPlayerSendSuggestionsEvent suggestEvent = new com.destroystokyo.paper.event.brigadier.AsyncPlayerSendSuggestionsEvent(this.getCraftPlayer(), suggestions, command);
+                             suggestEvent.setCancelled(suggestions.isEmpty());
--- a/patches/server/0990-Properly-handle-BlockBreakEvent-isDropItems.patch
+++ b/patches/server/0990-Properly-handle-BlockBreakEvent-isDropItems.patch
@ -0,0 +1,161 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Sat, 4 Mar 2023 10:52:52 -0800
+Subject: [PATCH] Properly handle BlockBreakEvent#isDropItems
+
+Setting whether a block break dropped items controlled
+far more than just whether blocks dropped, like stat increases
+food consumption, turtle egg count decreases, ice to water
+conversions and beehive releases
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
+index 82f26186156a487f29ad3abff3f68852e5b8a1f9..511221a686c1d2cad3b4abf79ee32b26058dad27 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
+++ b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
+@@ -433,8 +433,8 @@ public class ServerPlayerGameMode {
+                     isCorrectTool = flag1; // Paper
+ 
+                     itemstack.mineBlock(this.level, iblockdata1, pos, this.player);
+-                    if (flag && flag1 && event.isDropItems()) { // CraftBukkit - Check if block should drop items
+-                        block.playerDestroy(this.level, this.player, pos, iblockdata1, tileentity, itemstack1);
+                    if (flag && flag1 && event.isDropItems()/* && event.isDropItems() */) { // CraftBukkit - Check if block should drop items // Paper - fix drops not preventing stats/food exhaustion
+                        block.playerDestroy(this.level, this.player, pos, iblockdata1, tileentity, itemstack1, event.isDropItems()); // Paper
+                     }
+ 
+                     // return true; // CraftBukkit
+diff --git a/src/main/java/net/minecraft/world/level/block/BeehiveBlock.java b/src/main/java/net/minecraft/world/level/block/BeehiveBlock.java
+index 6e7a9f68aa3a5084c8eea9fd8721272260734289..7d1f3c367efcf8def56b961993136e02e05ba59c 100644
+--- a/src/main/java/net/minecraft/world/level/block/BeehiveBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/BeehiveBlock.java
+@@ -84,8 +84,8 @@ public class BeehiveBlock extends BaseEntityBlock {
+     }
+ 
+     @Override
+-    public void playerDestroy(Level world, Player player, BlockPos pos, BlockState state, @Nullable BlockEntity blockEntity, ItemStack tool) {
+-        super.playerDestroy(world, player, pos, state, blockEntity, tool);
+    public void playerDestroy(Level world, Player player, BlockPos pos, BlockState state, @Nullable BlockEntity blockEntity, ItemStack tool, boolean includeDrops) { // Paper
+        super.playerDestroy(world, player, pos, state, blockEntity, tool, includeDrops); // Paper
+         if (!world.isClientSide && blockEntity instanceof BeehiveBlockEntity) {
+             BeehiveBlockEntity tileentitybeehive = (BeehiveBlockEntity) blockEntity;
+ 
+diff --git a/src/main/java/net/minecraft/world/level/block/Block.java b/src/main/java/net/minecraft/world/level/block/Block.java
+index 7ac98b4e8b6dcc23777732d377ee73ae5671ebef..4d50dd92a7f3187ee1d8edb926e7c273c8156549 100644
+--- a/src/main/java/net/minecraft/world/level/block/Block.java
+++ b/src/main/java/net/minecraft/world/level/block/Block.java
+@@ -423,10 +423,18 @@ public class Block extends BlockBehaviour implements ItemLike {
+         return this.defaultBlockState();
+     }
+ 
+    @io.papermc.paper.annotation.DoNotUse // Paper - method below allows better control of item drops
+     public void playerDestroy(Level world, Player player, BlockPos pos, BlockState state, @Nullable BlockEntity blockEntity, ItemStack tool) {
+        // Paper start
+        this.playerDestroy(world, player, pos, state, blockEntity, tool, true);
+    }
+    public void playerDestroy(Level world, Player player, BlockPos pos, BlockState state, @Nullable BlockEntity blockEntity, ItemStack tool, boolean includeDrops) {
+        // Paper end
+         player.awardStat(Stats.BLOCK_MINED.get(this));
+         player.causeFoodExhaustion(0.005F, org.bukkit.event.entity.EntityExhaustionEvent.ExhaustionReason.BLOCK_MINED); // CraftBukkit - EntityExhaustionEvent
+        if (includeDrops) { // Paper
+         Block.dropResources(state, world, pos, blockEntity, player, tool);
+        } // Paper
+     }
+ 
+     public void setPlacedBy(Level world, BlockPos pos, BlockState state, @Nullable LivingEntity placer, ItemStack itemStack) {}
+diff --git a/src/main/java/net/minecraft/world/level/block/DoublePlantBlock.java b/src/main/java/net/minecraft/world/level/block/DoublePlantBlock.java
+index 0f0750f8c790d0db72a0e6b277449a1461674890..81d2140351775ad55546af52eb635ccdc8509d89 100644
+--- a/src/main/java/net/minecraft/world/level/block/DoublePlantBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/DoublePlantBlock.java
+@@ -96,8 +96,8 @@ public class DoublePlantBlock extends BushBlock {
+     }
+ 
+     @Override
+-    public void playerDestroy(Level world, Player player, BlockPos pos, BlockState state, @Nullable BlockEntity blockEntity, ItemStack tool) {
+-        super.playerDestroy(world, player, pos, Blocks.AIR.defaultBlockState(), blockEntity, tool);
+    public void playerDestroy(Level world, Player player, BlockPos pos, BlockState state, @Nullable BlockEntity blockEntity, ItemStack tool, boolean includeDrops) { // Paper
+        super.playerDestroy(world, player, pos, Blocks.AIR.defaultBlockState(), blockEntity, tool, includeDrops); // Paper
+     }
+ 
+     protected static void preventDropFromBottomPart(Level world, BlockPos pos, BlockState state, Player player) {
+diff --git a/src/main/java/net/minecraft/world/level/block/IceBlock.java b/src/main/java/net/minecraft/world/level/block/IceBlock.java
+index f05998e0af1e844f19bf86b74f652a9901088c37..4ab6997dad5b112f5105f786a6cee78c6c5667e8 100644
+--- a/src/main/java/net/minecraft/world/level/block/IceBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/IceBlock.java
+@@ -33,8 +33,8 @@ public class IceBlock extends HalfTransparentBlock {
+     }
+ 
+     @Override
+-    public void playerDestroy(Level world, Player player, BlockPos pos, BlockState state, @Nullable BlockEntity blockEntity, ItemStack tool) {
+-        super.playerDestroy(world, player, pos, state, blockEntity, tool);
+    public void playerDestroy(Level world, Player player, BlockPos pos, BlockState state, @Nullable BlockEntity blockEntity, ItemStack tool, boolean includeDrops) { // Paper
+        super.playerDestroy(world, player, pos, state, blockEntity, tool, includeDrops); // Paper
+         // Paper start
+         this.afterDestroy(world, pos, tool);
+     }
+diff --git a/src/main/java/net/minecraft/world/level/block/TurtleEggBlock.java b/src/main/java/net/minecraft/world/level/block/TurtleEggBlock.java
+index c79f3a8885a5ffc9ebac51992e63df14929d9f24..b0199e071cba4c7ad51799132d00b22b616953fc 100644
+--- a/src/main/java/net/minecraft/world/level/block/TurtleEggBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/TurtleEggBlock.java
+@@ -173,8 +173,8 @@ public class TurtleEggBlock extends Block {
+     }
+ 
+     @Override
+-    public void playerDestroy(Level world, Player player, BlockPos pos, BlockState state, @Nullable BlockEntity blockEntity, ItemStack tool) {
+-        super.playerDestroy(world, player, pos, state, blockEntity, tool);
+    public void playerDestroy(Level world, Player player, BlockPos pos, BlockState state, @Nullable BlockEntity blockEntity, ItemStack tool, boolean includeDrops) { // Paper
+        super.playerDestroy(world, player, pos, state, blockEntity, tool, includeDrops); // Paper
+         this.decreaseEggs(world, pos, state);
+     }
+ 
+diff --git a/src/test/java/io/papermc/paper/world/block/BlockPlayerDestroyOverrideTest.java b/src/test/java/io/papermc/paper/world/block/BlockPlayerDestroyOverrideTest.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..7c435f7079b429873f33d7bade82eca0c6b45842
+--- /dev/null
+++ b/src/test/java/io/papermc/paper/world/block/BlockPlayerDestroyOverrideTest.java
+@@ -0,0 +1,47 @@
+package io.papermc.paper.world.block;
+
+import io.github.classgraph.ClassGraph;
+import io.github.classgraph.ClassInfo;
+import io.github.classgraph.MethodInfo;
+import io.github.classgraph.MethodInfoList;
+import io.github.classgraph.MethodParameterInfo;
+import io.github.classgraph.ScanResult;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Stream;
+import org.bukkit.support.AbstractTestingBase;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class BlockPlayerDestroyOverrideTest extends AbstractTestingBase {
+
+    public static Stream<ClassInfo> parameters() {
+        final List<ClassInfo> classInfo = new ArrayList<>();
+        try (ScanResult scanResult = new ClassGraph()
+            .enableClassInfo()
+            .enableMethodInfo()
+            .whitelistPackages("net.minecraft")
+            .scan()
+        ) {
+            for (final ClassInfo subclass : scanResult.getSubclasses("net.minecraft.world.level.block.Block")) {
+                final MethodInfoList playerDestroy = subclass.getDeclaredMethodInfo("playerDestroy");
+                if (!playerDestroy.isEmpty()) {
+                    classInfo.add(subclass);
+                }
+            }
+        }
+        return classInfo.stream();
+    }
+
+    @ParameterizedTest
+    @MethodSource("parameters")
+    public void checkPlayerDestroyOverrides(ClassInfo overridesPlayerDestroy) {
+        final MethodInfoList playerDestroy = overridesPlayerDestroy.getDeclaredMethodInfo("playerDestroy");
+        assertEquals(1, playerDestroy.size(), overridesPlayerDestroy.getName() + " has multiple playerDestroy methods");
+        final MethodInfo next = playerDestroy.iterator().next();
+        final MethodParameterInfo[] parameterInfo = next.getParameterInfo();
+        assertEquals("boolean", parameterInfo[parameterInfo.length - 1].getTypeDescriptor().toStringWithSimpleNames(), overridesPlayerDestroy.getName() + " needs to change its override of playerDestroy");
+    }
+}
--- a/patches/server/0991-Fire-entity-death-event-for-ender-dragon.patch
+++ b/patches/server/0991-Fire-entity-death-event-for-ender-dragon.patch
@ -0,0 +1,26 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Trevor Bedson <78997566+Prorickey@users.noreply.github.com>
+Date: Fri, 14 Jul 2023 20:47:02 -0400
+Subject: [PATCH] Fire entity death event for ender dragon
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java b/src/main/java/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java
+index 389c45748732781595b773bc033446ace06fcbb0..f56bb431be7d5f1a1b8edec41af1f3a28289316d 100644
+--- a/src/main/java/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java
+++ b/src/main/java/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java
+@@ -642,6 +642,15 @@ public class EnderDragon extends Mob implements Enemy {
+ 
+     @Override
+     public void kill() {
+        // Paper start
+        this.silentDeath = true;
+        org.bukkit.event.entity.EntityDeathEvent deathEvent =  org.bukkit.craftbukkit.event.CraftEventFactory.callEntityDeathEvent(this);
+        if (deathEvent.isCancelled()) {
+            this.silentDeath = false; // Reset to default if event was cancelled
+            return;
+        }
+        // Paper end
+
+         this.remove(Entity.RemovalReason.KILLED);
+         this.gameEvent(GameEvent.ENTITY_DIE);
+         if (this.dragonFight != null) {
--- a/patches/server/0992-Configurable-entity-tracking-range-by-Y-coordinate.patch
+++ b/patches/server/0992-Configurable-entity-tracking-range-by-Y-coordinate.patch
@ -0,0 +1,27 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: ruViolence <78062896+ruViolence@users.noreply.github.com>
+Date: Tue, 27 Jun 2023 15:38:18 +0800
+Subject: [PATCH] Configurable entity tracking range by Y coordinate
+
+Options to configure entity tracking by Y coordinate, also for each entity category.
+
+diff --git a/src/main/java/net/minecraft/server/level/ChunkMap.java b/src/main/java/net/minecraft/server/level/ChunkMap.java
+index 4d406ced4a1996b8883574ce0b785dc17370793b..e3c1015a5538ad74b9f109837df5916e6ce7e711 100644
+--- a/src/main/java/net/minecraft/server/level/ChunkMap.java
+++ b/src/main/java/net/minecraft/server/level/ChunkMap.java
+@@ -1420,6 +1420,15 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
+                 double d1 = vec3d.x * vec3d.x + vec3d.z * vec3d.z;
+                 double d2 = d0 * d0;
+                 boolean flag = d1 <= d2 && this.entity.broadcastToPlayer(player) && ChunkMap.this.isChunkTracked(player, this.entity.chunkPosition().x, this.entity.chunkPosition().z);
+                // Paper start - check Y
+                if (flag && level.paperConfig().entities.trackingRangeY.enabled) {
+                    double rangeY = level.paperConfig().entities.trackingRangeY.get(this.entity, -1);
+                    if (rangeY != -1) {
+                        double vec3d_dy = player.getY() - this.entity.getY();
+                        flag = vec3d_dy * vec3d_dy <= rangeY * rangeY;
+                    }
+                }
+                // Paper end - check Y
+ 
+                 // CraftBukkit start - respect vanish API
+                 if (!player.getBukkitEntity().canSee(this.entity.getBukkitEntity())) {
--- a/patches/server/0993-Add-Listing-API-for-Player.patch
+++ b/patches/server/0993-Add-Listing-API-for-Player.patch
@ -0,0 +1,179 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Corey Shupe <coreyshupe101@gmail.com>
+Date: Wed, 11 Jan 2023 16:40:39 -0500
+Subject: [PATCH] Add Listing API for Player
+
+
+diff --git a/src/main/java/net/minecraft/network/protocol/game/ClientboundPlayerInfoUpdatePacket.java b/src/main/java/net/minecraft/network/protocol/game/ClientboundPlayerInfoUpdatePacket.java
+index aa1c6de4d6cb7bbca33d25895c54707d220ab62a..9810d62c99f5d7dfca61ddfbbc356aebad2f7001 100644
+--- a/src/main/java/net/minecraft/network/protocol/game/ClientboundPlayerInfoUpdatePacket.java
+++ b/src/main/java/net/minecraft/network/protocol/game/ClientboundPlayerInfoUpdatePacket.java
+@@ -29,12 +29,46 @@ public class ClientboundPlayerInfoUpdatePacket implements Packet<ClientGamePacke
+         this.actions = EnumSet.of(action);
+         this.entries = List.of(new ClientboundPlayerInfoUpdatePacket.Entry(player));
+     }
+    // Paper start
+    public ClientboundPlayerInfoUpdatePacket(EnumSet<ClientboundPlayerInfoUpdatePacket.Action> actions, List<ClientboundPlayerInfoUpdatePacket.Entry> entries) {
+        this.actions = actions;
+        this.entries = entries;
+    }
+
+    public ClientboundPlayerInfoUpdatePacket(EnumSet<ClientboundPlayerInfoUpdatePacket.Action> actions, ClientboundPlayerInfoUpdatePacket.Entry entry) {
+        this.actions = actions;
+        this.entries = List.of(entry);
+    }
+    // Paper end
+ 
+     public static ClientboundPlayerInfoUpdatePacket createPlayerInitializing(Collection<ServerPlayer> players) {
+         EnumSet<ClientboundPlayerInfoUpdatePacket.Action> enumSet = EnumSet.of(ClientboundPlayerInfoUpdatePacket.Action.ADD_PLAYER, ClientboundPlayerInfoUpdatePacket.Action.INITIALIZE_CHAT, ClientboundPlayerInfoUpdatePacket.Action.UPDATE_GAME_MODE, ClientboundPlayerInfoUpdatePacket.Action.UPDATE_LISTED, ClientboundPlayerInfoUpdatePacket.Action.UPDATE_LATENCY, ClientboundPlayerInfoUpdatePacket.Action.UPDATE_DISPLAY_NAME);
+         return new ClientboundPlayerInfoUpdatePacket(enumSet, players);
+     }
+ 
+    // Paper start
+    public static ClientboundPlayerInfoUpdatePacket createPlayerInitializing(Collection<ServerPlayer> players, ServerPlayer forPlayer) {
+        final EnumSet<ClientboundPlayerInfoUpdatePacket.Action> enumSet = EnumSet.of(ClientboundPlayerInfoUpdatePacket.Action.ADD_PLAYER, ClientboundPlayerInfoUpdatePacket.Action.INITIALIZE_CHAT, ClientboundPlayerInfoUpdatePacket.Action.UPDATE_GAME_MODE, ClientboundPlayerInfoUpdatePacket.Action.UPDATE_LISTED, ClientboundPlayerInfoUpdatePacket.Action.UPDATE_LATENCY, ClientboundPlayerInfoUpdatePacket.Action.UPDATE_DISPLAY_NAME);
+        final List<ClientboundPlayerInfoUpdatePacket.Entry> entries = new java.util.ArrayList<>(players.size());
+        final org.bukkit.craftbukkit.entity.CraftPlayer bukkitEntity = forPlayer.getBukkitEntity();
+        for (final ServerPlayer player : players) {
+            entries.add(new ClientboundPlayerInfoUpdatePacket.Entry(player, bukkitEntity.isListed(player.getBukkitEntity())));
+        }
+        return new ClientboundPlayerInfoUpdatePacket(enumSet, entries);
+    }
+
+    public static ClientboundPlayerInfoUpdatePacket createSinglePlayerInitializing(ServerPlayer player, boolean listed) {
+        final EnumSet<ClientboundPlayerInfoUpdatePacket.Action> enumSet = EnumSet.of(ClientboundPlayerInfoUpdatePacket.Action.ADD_PLAYER, ClientboundPlayerInfoUpdatePacket.Action.INITIALIZE_CHAT, ClientboundPlayerInfoUpdatePacket.Action.UPDATE_GAME_MODE, ClientboundPlayerInfoUpdatePacket.Action.UPDATE_LISTED, ClientboundPlayerInfoUpdatePacket.Action.UPDATE_LATENCY, ClientboundPlayerInfoUpdatePacket.Action.UPDATE_DISPLAY_NAME);
+        final List<ClientboundPlayerInfoUpdatePacket.Entry> entries = List.of(new Entry(player, listed));
+        return new ClientboundPlayerInfoUpdatePacket(enumSet, entries);
+    }
+
+    public static ClientboundPlayerInfoUpdatePacket updateListed(UUID playerInfoId, boolean listed) {
+        EnumSet<ClientboundPlayerInfoUpdatePacket.Action> enumSet = EnumSet.of(ClientboundPlayerInfoUpdatePacket.Action.UPDATE_LISTED);
+        return new ClientboundPlayerInfoUpdatePacket(enumSet, new ClientboundPlayerInfoUpdatePacket.Entry(playerInfoId, listed));
+    }
+    // Paper end
+
+     public ClientboundPlayerInfoUpdatePacket(FriendlyByteBuf buf) {
+         this.actions = buf.readEnumSet(ClientboundPlayerInfoUpdatePacket.Action.class);
+         this.entries = buf.readList((buf2) -> {
+@@ -144,8 +178,18 @@ public class ClientboundPlayerInfoUpdatePacket implements Packet<ClientGamePacke
+ 
+     public static record Entry(UUID profileId, @Nullable GameProfile profile, boolean listed, int latency, GameType gameMode, @Nullable Component displayName, @Nullable RemoteChatSession.Data chatSession) {
+         Entry(ServerPlayer player) {
+-            this(player.getUUID(), player.getGameProfile(), true, player.connection.latency(), player.gameMode.getGameModeForPlayer(), player.getTabListDisplayName(), Optionull.map(player.getChatSession(), RemoteChatSession::asData));
+            // Paper start - add listed
+            this(player, true);
+        }
+        Entry(ServerPlayer player, boolean listed) {
+            this(player.getUUID(), player.getGameProfile(), listed, player.connection.latency(), player.gameMode.getGameModeForPlayer(), player.getTabListDisplayName(), Optionull.map(player.getChatSession(), RemoteChatSession::asData));
+            // Paper end - add listed
+        }
+        // Paper start
+        Entry(UUID profileId, boolean listed) {
+            this(profileId, null, listed, 0, GameType.DEFAULT_MODE, null, null);
+         }
+        // Paper end
+     }
+ 
+     static class EntryBuilder {
+diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
+index c1790d8f13af1ff7059dfe952cbdcdcca22d8df4..e1bd408336a80d819e760b76d9636de06fdf0abe 100644
+--- a/src/main/java/net/minecraft/server/players/PlayerList.java
+++ b/src/main/java/net/minecraft/server/players/PlayerList.java
+@@ -356,14 +356,22 @@ public abstract class PlayerList {
+         // CraftBukkit end
+ 
+         // CraftBukkit start - sendAll above replaced with this loop
+-        ClientboundPlayerInfoUpdatePacket packet = ClientboundPlayerInfoUpdatePacket.createPlayerInitializing(List.of(player));
+        ClientboundPlayerInfoUpdatePacket packet = ClientboundPlayerInfoUpdatePacket.createPlayerInitializing(List.of(player)); // Paper
+ 
+         final List<ServerPlayer> onlinePlayers = Lists.newArrayListWithExpectedSize(this.players.size() - 1); // Paper - use single player info update packet
+         for (int i = 0; i < this.players.size(); ++i) {
+             ServerPlayer entityplayer1 = (ServerPlayer) this.players.get(i);
+ 
+             if (entityplayer1.getBukkitEntity().canSee(bukkitPlayer)) {
+                // Paper start
+                if (entityplayer1.getBukkitEntity().isListed(bukkitPlayer)) {
+                // Paper end
+                 entityplayer1.connection.send(packet);
+                // Paper start
+                } else {
+                    entityplayer1.connection.send(ClientboundPlayerInfoUpdatePacket.createSinglePlayerInitializing(player, false));
+                }
+                // Paper end
+             }
+ 
+             if (entityplayer1 == player || !bukkitPlayer.canSee(entityplayer1.getBukkitEntity())) { // Paper - don't include joining player
+@@ -374,7 +382,7 @@ public abstract class PlayerList {
+         }
+         // Paper start - use single player info update packet
+         if (!onlinePlayers.isEmpty()) {
+-            player.connection.send(ClientboundPlayerInfoUpdatePacket.createPlayerInitializing(onlinePlayers));
+            player.connection.send(ClientboundPlayerInfoUpdatePacket.createPlayerInitializing(onlinePlayers, player));
+         }
+         // Paper end
+         player.sentListPacket = true;
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index 082350f866eaef5fc8f98ebc217aa02cdcab5a46..ad602abca07e3a0d6e2889843c5849616f2c23a7 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -185,6 +185,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+     private final ConversationTracker conversationTracker = new ConversationTracker();
+     private final Set<String> channels = new HashSet<String>();
+     private final Map<UUID, Set<WeakReference<Plugin>>> invertedVisibilityEntities = new HashMap<>();
+    private final Set<UUID> unlistedEntities = new HashSet<>(); // Paper
+     private static final WeakHashMap<Plugin, WeakReference<Plugin>> pluginWeakReferences = new WeakHashMap<>();
+     private int hash = 0;
+     private double health = 20;
+@@ -1988,7 +1989,7 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+                 otherPlayer.setUUID(uuidOverride);
+             }
+             // Paper end
+-            this.getHandle().connection.send(ClientboundPlayerInfoUpdatePacket.createPlayerInitializing(List.of(otherPlayer)));
+            this.getHandle().connection.send(ClientboundPlayerInfoUpdatePacket.createPlayerInitializing(List.of(otherPlayer), this.getHandle())); // Paper
+             if (original != null) otherPlayer.setUUID(original); // Paper - uuid override
+         }
+ 
+@@ -2097,6 +2098,43 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+         return (entity != null) ? this.canSee(entity) : false; // If we can't find it, we can't see it
+     }
+ 
+    // Paper start
+    @Override
+    public boolean isListed(Player other) {
+        return !this.unlistedEntities.contains(other.getUniqueId());
+    }
+
+    @Override
+    public boolean unlistPlayer(@NotNull Player other) {
+        Preconditions.checkNotNull(other, "hidden entity cannot be null");
+        if (this.getHandle().connection == null) return false;
+        if (this.equals(other)) return false;
+        if (!this.canSee(other)) return false;
+
+        if (unlistedEntities.add(other.getUniqueId())) {
+            this.getHandle().connection.send(ClientboundPlayerInfoUpdatePacket.updateListed(other.getUniqueId(), false));
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    @Override
+    public boolean listPlayer(@NotNull Player other) {
+        Preconditions.checkNotNull(other, "hidden entity cannot be null");
+        if (this.getHandle().connection == null) return false;
+        if (this.equals(other)) return false;
+        if (!this.canSee(other)) throw new IllegalStateException("Player cannot see other player");
+
+        if (this.unlistedEntities.remove(other.getUniqueId())) {
+            this.getHandle().connection.send(ClientboundPlayerInfoUpdatePacket.updateListed(other.getUniqueId(), true));
+            return true;
+        } else {
+            return false;
+        }
+    }
+    // Paper end
+
+     @Override
+     public Map<String, Object> serialize() {
+         Map<String, Object> result = new LinkedHashMap<String, Object>();
--- a/patches/server/0994-Configurable-Region-Compression-Format.patch
+++ b/patches/server/0994-Configurable-Region-Compression-Format.patch
@ -0,0 +1,46 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Astralchroma <astralchroma@proton.me>
+Date: Thu, 27 Oct 2022 22:19:31 +0100
+Subject: [PATCH] Configurable Region Compression Format
+
+
+diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java
+index 84b2fd9db39e0cdf3e1cbe6444579f7ca839bc45..9248769e6d357f6eec68945fd7700e79b2942c41 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java
+++ b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFile.java
+@@ -424,11 +424,11 @@ public class RegionFile implements AutoCloseable {
+     // Paper end
+ 
+     public RegionFile(Path file, Path directory, boolean dsync) throws IOException {
+-        this(file, directory, RegionFileVersion.VERSION_DEFLATE, dsync);
+        this(file, directory, RegionFileVersion.getCompressionFormat(), dsync); // Paper - Configurable region compression format
+     }
+     // Paper start - add can recalc flag
+     public RegionFile(Path file, Path directory, boolean dsync, boolean canRecalcHeader) throws IOException {
+-        this(file, directory, RegionFileVersion.VERSION_DEFLATE, dsync, canRecalcHeader);
+        this(file, directory, RegionFileVersion.getCompressionFormat(), dsync, canRecalcHeader); // Paper - Configurable region compression format
+     }
+     // Paper end - add can recalc flag
+ 
+diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileVersion.java b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileVersion.java
+index 4411e427d3b6b592f8a18e61b6c59309cf699d3f..ee27a553b426d3e1e1317bbeb39a3c2d46520e59 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileVersion.java
+++ b/src/main/java/net/minecraft/world/level/chunk/storage/RegionFileVersion.java
+@@ -30,6 +30,17 @@ public class RegionFileVersion {
+     }, (stream) -> {
+         return stream;
+     }));
+
+    // Paper Start - Configurable region compression format
+    public static RegionFileVersion getCompressionFormat() {
+        return switch (io.papermc.paper.configuration.GlobalConfiguration.get().unsupportedSettings.compressionFormat) {
+            case GZIP -> VERSION_GZIP;
+            case ZLIB -> VERSION_DEFLATE;
+            case NONE -> VERSION_NONE;
+        };
+    }
+    // Paper End
+
+     private final int id;
+     private final RegionFileVersion.StreamWrapper<InputStream> inputWrapper;
+     private final RegionFileVersion.StreamWrapper<OutputStream> outputWrapper;
--- a/patches/server/0995-Expose-clicked-BlockFace-during-BlockDamageEvent.patch
+++ b/patches/server/0995-Expose-clicked-BlockFace-during-BlockDamageEvent.patch
@ -0,0 +1,39 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: aerulion <aerulion@gmail.com>
+Date: Mon, 21 Aug 2023 04:36:07 +0200
+Subject: [PATCH] Expose clicked BlockFace during BlockDamageEvent
+
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
+index 511221a686c1d2cad3b4abf79ee32b26058dad27..899439e0af639e8d9124522b3cb6a10601b17fe2 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
+++ b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
+@@ -253,7 +253,7 @@ public class ServerPlayerGameMode {
+                     }
+                     return;
+                 }
+-                org.bukkit.event.block.BlockDamageEvent blockEvent = CraftEventFactory.callBlockDamageEvent(this.player, pos, this.player.getInventory().getSelected(), f >= 1.0f);
+                org.bukkit.event.block.BlockDamageEvent blockEvent = CraftEventFactory.callBlockDamageEvent(this.player, pos, direction, this.player.getInventory().getSelected(), f >= 1.0f); // Paper - Expose BlockFace
+ 
+                 if (blockEvent.isCancelled()) {
+                     // Let the client know the block still exists
+diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+index 8f78b9e714c472f59f3abf565c53bd87a6811674..704ba208d5cbaef8bc2eb0a87d6fbb1be42e0460 100644
+--- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+@@ -652,13 +652,13 @@ public class CraftEventFactory {
+     /**
+      * BlockDamageEvent
+      */
+-    public static BlockDamageEvent callBlockDamageEvent(ServerPlayer who, BlockPos pos, ItemStack itemstack, boolean instaBreak) {
+    public static BlockDamageEvent callBlockDamageEvent(ServerPlayer who, BlockPos pos, Direction direction, ItemStack itemstack, boolean instaBreak) { // Paper - Expose BlockFace
+         Player player = who.getBukkitEntity();
+         CraftItemStack itemInHand = CraftItemStack.asCraftMirror(itemstack);
+ 
+         Block blockClicked = CraftBlock.at(who.level(), pos);
+ 
+-        BlockDamageEvent event = new BlockDamageEvent(player, blockClicked, itemInHand, instaBreak);
+        BlockDamageEvent event = new BlockDamageEvent(player, blockClicked, CraftBlock.notchToBlockFace(direction), itemInHand, instaBreak); // Paper - Expose BlockFace
+         player.getServer().getPluginManager().callEvent(event);
+ 
+         return event;
--- a/patches/server/0996-Fix-NPE-on-Boat-getStatus.patch
+++ b/patches/server/0996-Fix-NPE-on-Boat-getStatus.patch
@ -0,0 +1,32 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: LemonCaramel <admin@caramel.moe>
+Date: Mon, 10 Apr 2023 20:48:26 +0900
+Subject: [PATCH] Fix NPE on Boat getStatus
+
+Boat status is null until the entity is added to the world and the tick() method is called.
+
+== AT ==
+public net.minecraft.world.entity.vehicle.Boat getStatus()Lnet/minecraft/world/entity/vehicle/Boat$Status;
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftBoat.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftBoat.java
+index d161cbf9c83cd78593864850b98f688da2c85aa5..859f233197ebe738511011e36668c4eb5d4b7d8e 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftBoat.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftBoat.java
+@@ -88,6 +88,17 @@ public class CraftBoat extends CraftVehicle implements Boat {
+ 
+     @Override
+     public Status getStatus() {
+        // Paper start
+        final net.minecraft.world.entity.vehicle.Boat handle = this.getHandle();
+        if (handle.status == null) {
+            if (handle.valid && !handle.updatingSectionStatus) {
+                // Don't actually set the status because it would skew the old status check in the next tick
+                return CraftBoat.boatStatusFromNms(handle.getStatus());
+            } else {
+                return Status.NOT_IN_WORLD;
+            }
+        }
+        // Paper end
+         return CraftBoat.boatStatusFromNms(this.getHandle().status);
+     }
+ 
--- a/patches/server/0997-Expand-Pose-API.patch
+++ b/patches/server/0997-Expand-Pose-API.patch
@ -0,0 +1,51 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: SoSeDiK <mrsosedik@gmail.com>
+Date: Wed, 11 Jan 2023 20:59:01 +0200
+Subject: [PATCH] Expand Pose API
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index 703825e9956201ddf211816553a1f1b509e1592f..92508e9ea17d2ea00b4da20a249325c390442016 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
+++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -422,6 +422,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+     private UUID originWorld;
+     public boolean freezeLocked = false; // Paper - Freeze Tick Lock API
+     public boolean collidingWithWorldBorder; // Paper
+    public boolean fixedPose = false; // Paper
+ 
+     public void setOrigin(@javax.annotation.Nonnull Location location) {
+         this.origin = location.toVector();
+@@ -706,6 +707,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource, S
+     public void onClientRemoval() {}
+ 
+     public void setPose(net.minecraft.world.entity.Pose pose) {
+        if (this.fixedPose) return; // Paper
+         // CraftBukkit start
+         if (pose == this.getPose()) {
+             return;
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+index c4343cbdea19a0dd671ed136a6a19ebf831ce8ab..0349d9b6ad12e0a426cb1307be8633240b7426fe 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+@@ -1251,6 +1251,20 @@ public abstract class CraftEntity implements org.bukkit.entity.Entity {
+     public boolean isSneaking() {
+         return this.getHandle().isShiftKeyDown();
+     }
+
+    @Override
+    public void setPose(Pose pose, boolean fixed) {
+        Preconditions.checkNotNull(pose, "Pose cannot be null");
+        final Entity handle = this.getHandle();
+        handle.fixedPose = false;
+        handle.setPose(net.minecraft.world.entity.Pose.values()[pose.ordinal()]);
+        handle.fixedPose = fixed;
+    }
+
+    @Override
+    public boolean hasFixedPose() {
+        return this.getHandle().fixedPose;
+    }
+     // Paper end
+ 
+     @Override
--- a/patches/server/0998-More-DragonBattle-API.patch
+++ b/patches/server/0998-More-DragonBattle-API.patch
@ -0,0 +1,91 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Sun, 18 Dec 2022 13:40:05 -0800
+Subject: [PATCH] More DragonBattle API
+
+== AT ==
+public net.minecraft.world.level.dimension.end.EndDragonFight GATEWAY_COUNT
+public net.minecraft.world.level.dimension.end.EndDragonFight gateways
+public net.minecraft.world.level.dimension.end.EndDragonFight respawnCrystals
+public net.minecraft.world.level.dimension.end.EndDragonFight spawnNewGateway(Lnet/minecraft/core/BlockPos;)V
+
+diff --git a/src/main/java/net/minecraft/world/level/dimension/end/EndDragonFight.java b/src/main/java/net/minecraft/world/level/dimension/end/EndDragonFight.java
+index 390542c42fe957e8e2d21c879c1c8908c8970b44..b2a57cb75916d2724f18779c922005ef9bcc0b0e 100644
+--- a/src/main/java/net/minecraft/world/level/dimension/end/EndDragonFight.java
+++ b/src/main/java/net/minecraft/world/level/dimension/end/EndDragonFight.java
+@@ -439,6 +439,24 @@ public class EndDragonFight {
+         this.gateways.clear();
+     }
+ 
+    // Paper start
+    public boolean spawnNewGatewayIfPossible() {
+        if (!this.gateways.isEmpty()) {
+            this.spawnNewGateway();
+            return true;
+        }
+        return false;
+    }
+
+    public List<EndCrystal> getSpikeCrystals() {
+        final List<EndCrystal> endCrystals = new java.util.ArrayList<>();
+        for (final SpikeFeature.EndSpike spike : SpikeFeature.getSpikesForLevel(this.level)) {
+            endCrystals.addAll(this.level.getEntitiesOfClass(EndCrystal.class, spike.getTopBoundingBox()));
+        }
+        return endCrystals;
+    }
+    // Paper end
+
+     private void spawnNewGateway() {
+         if (!this.gateways.isEmpty()) {
+             int i = (Integer) this.gateways.remove(this.gateways.size() - 1);
+diff --git a/src/main/java/org/bukkit/craftbukkit/boss/CraftDragonBattle.java b/src/main/java/org/bukkit/craftbukkit/boss/CraftDragonBattle.java
+index 58f1562373bab8d082172e4a5db22493fb913ca8..716327137c3528a74871d2aad4849812d7113d22 100644
+--- a/src/main/java/org/bukkit/craftbukkit/boss/CraftDragonBattle.java
+++ b/src/main/java/org/bukkit/craftbukkit/boss/CraftDragonBattle.java
+@@ -132,4 +132,46 @@ public class CraftDragonBattle implements DragonBattle {
+     private DragonRespawnAnimation toNMSRespawnPhase(RespawnPhase phase) {
+         return (phase != RespawnPhase.NONE) ? DragonRespawnAnimation.values()[phase.ordinal()] : null;
+     }
+    // Paper start
+    @Override
+    public int getGatewayCount() {
+        return EndDragonFight.GATEWAY_COUNT - this.handle.gateways.size();
+    }
+
+    @Override
+    public boolean spawnNewGateway() {
+        return this.handle.spawnNewGatewayIfPossible();
+    }
+
+    @Override
+    public void spawnNewGateway(final io.papermc.paper.math.Position position) {
+        this.handle.spawnNewGateway(io.papermc.paper.util.MCUtil.toBlockPos(position));
+    }
+
+    @Override
+    public java.util.List<org.bukkit.entity.EnderCrystal> getRespawnCrystals() {
+        if (this.handle.respawnCrystals == null) {
+            return java.util.Collections.emptyList();
+        }
+
+        final java.util.List<org.bukkit.entity.EnderCrystal> enderCrystals = new java.util.ArrayList<>();
+        for (final net.minecraft.world.entity.boss.enderdragon.EndCrystal endCrystal : this.handle.respawnCrystals) {
+            if (!endCrystal.isRemoved() && endCrystal.isAlive() && endCrystal.valid) {
+                enderCrystals.add(((org.bukkit.entity.EnderCrystal) endCrystal.getBukkitEntity()));
+            }
+        }
+        return java.util.Collections.unmodifiableList(enderCrystals);
+    }
+
+    @Override
+    public java.util.List<org.bukkit.entity.EnderCrystal> getHealingCrystals() {
+        final java.util.List<org.bukkit.entity.EnderCrystal> enderCrystals = new java.util.ArrayList<>();
+        for (final net.minecraft.world.entity.boss.enderdragon.EndCrystal endCrystal : this.handle.getSpikeCrystals()) {
+            if (!endCrystal.isRemoved() && endCrystal.isAlive() && endCrystal.valid) {
+                enderCrystals.add(((org.bukkit.entity.EnderCrystal) endCrystal.getBukkitEntity()));
+            }
+        }
+        return java.util.Collections.unmodifiableList(enderCrystals);
+    }
+    // Paper end
+ }
--- a/patches/server/0999-Deep-clone-unhandled-nbt-tags.patch
+++ b/patches/server/0999-Deep-clone-unhandled-nbt-tags.patch
@ -0,0 +1,61 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: SoSeDiK <mrsosedik@gmail.com>
+Date: Thu, 26 May 2022 03:30:05 +0300
+Subject: [PATCH] Deep clone unhandled nbt tags
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java
+index 039197efb05432b8139fbabe92338572c1bf078e..8762a7a22723150a1a42b3459f3744b8235da142 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java
+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaItem.java
+@@ -305,7 +305,7 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
+     private static final CraftPersistentDataTypeRegistry DATA_TYPE_REGISTRY = new CraftPersistentDataTypeRegistry();
+ 
+     private CompoundTag internalTag;
+-    final Map<String, Tag> unhandledTags = new TreeMap<String, Tag>(); // Visible for testing only // Paper
+    Map<String, Tag> unhandledTags = new TreeMap<String, Tag>(); // Visible for testing only // Paper // Paper - remove final
+     private CraftPersistentDataContainer persistentDataContainer = new CraftPersistentDataContainer(CraftMetaItem.DATA_TYPE_REGISTRY);
+ 
+     private int version = CraftMagicNumbers.INSTANCE.getDataVersion(); // Internal use only
+@@ -346,8 +346,10 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
+             this.destroyableKeys = new java.util.HashSet<>(meta.destroyableKeys);
+         }
+         // Paper end
+-        this.unhandledTags.putAll(meta.unhandledTags);
+-        this.persistentDataContainer.putAll(meta.persistentDataContainer.getRaw());
+        // Paper start - Deep clone unhandled nbt tags
+        meta.unhandledTags.forEach((key, tag) -> this.unhandledTags.put(key, tag.copy()));
+        this.persistentDataContainer.putAll(meta.persistentDataContainer.getTagsCloned());
+        // Paper end
+ 
+         this.internalTag = meta.internalTag;
+         if (this.internalTag != null) {
+@@ -1395,7 +1397,11 @@ class CraftMetaItem implements ItemMeta, Damageable, Repairable, BlockDataMeta {
+             if (this.hasAttributeModifiers()) {
+                 clone.attributeModifiers = LinkedHashMultimap.create(this.attributeModifiers);
+             }
+-            clone.persistentDataContainer = new CraftPersistentDataContainer(this.persistentDataContainer.getRaw(), CraftMetaItem.DATA_TYPE_REGISTRY);
+            // Paper start - Deep clone unhandled nbt tags
+            clone.persistentDataContainer = new CraftPersistentDataContainer(this.persistentDataContainer.getTagsCloned(), CraftMetaItem.DATA_TYPE_REGISTRY);
+            clone.unhandledTags = new TreeMap<>(this.unhandledTags);
+            clone.unhandledTags.replaceAll((key, tag) -> tag.copy());
+            // Paper end - Deep clone unhandled nbt tags
+             clone.hideFlag = this.hideFlag;
+             clone.unbreakable = this.unbreakable;
+             clone.damage = this.damage;
+diff --git a/src/main/java/org/bukkit/craftbukkit/persistence/CraftPersistentDataContainer.java b/src/main/java/org/bukkit/craftbukkit/persistence/CraftPersistentDataContainer.java
+index 3351962e85438ed05215ce0d159799ed4707afde..8d5789cc6001fdf68c2d3f7ee3dd8fcafb9c831f 100644
+--- a/src/main/java/org/bukkit/craftbukkit/persistence/CraftPersistentDataContainer.java
+++ b/src/main/java/org/bukkit/craftbukkit/persistence/CraftPersistentDataContainer.java
+@@ -189,5 +189,11 @@ public class CraftPersistentDataContainer implements PersistentDataContainer {
+             this.putAll(compound);
+         }
+     }
+
+    public Map<String, Tag> getTagsCloned() {
+        final Map<String, Tag> tags = new HashMap<>();
+        this.customDataTags.forEach((key, tag) -> tags.put(key, tag.copy()));
+        return tags;
+    }
+     // Paper end
+ }
--- a/patches/server/1000-Add-PlayerPickItemEvent.patch
+++ b/patches/server/1000-Add-PlayerPickItemEvent.patch
@ -0,0 +1,45 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: RodneyMKay <36546810+RodneyMKay@users.noreply.github.com>
+Date: Wed, 8 Sep 2021 21:34:01 +0200
+Subject: [PATCH] Add PlayerPickItemEvent
+
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index e49a4044710cabb8a74d9aa83b28bddf025af1f2..c8858b9f72f57356f47575c01cbb159d341e0825 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -946,7 +946,14 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+             this.disconnect("Invalid hotbar selection (Hacking?)", org.bukkit.event.player.PlayerKickEvent.Cause.ILLEGAL_ACTION); // Paper - kick event cause
+             return;
+         }
+-        this.player.getInventory().pickSlot(packet.getSlot()); // Paper - Diff above if changed
+        Player bukkitPlayer = this.player.getBukkitEntity();
+        int targetSlot = this.player.getInventory().getSuitableHotbarSlot();
+        int sourceSlot = packet.getSlot();
+
+        io.papermc.paper.event.player.PlayerPickItemEvent event = new io.papermc.paper.event.player.PlayerPickItemEvent(bukkitPlayer, targetSlot, sourceSlot);
+        if (!event.callEvent()) return;
+
+        this.player.getInventory().pickSlot(event.getSourceSlot(), event.getTargetSlot());
+         // Paper end
+         this.player.connection.send(new ClientboundContainerSetSlotPacket(-2, 0, this.player.getInventory().selected, this.player.getInventory().getItem(this.player.getInventory().selected)));
+         this.player.connection.send(new ClientboundContainerSetSlotPacket(-2, 0, packet.getSlot(), this.player.getInventory().getItem(packet.getSlot())));
+diff --git a/src/main/java/net/minecraft/world/entity/player/Inventory.java b/src/main/java/net/minecraft/world/entity/player/Inventory.java
+index 395cecc385e4126a7534ac9aeb15cf323efab03e..96d664c28738d6090f7067761c2978dd1aa0fd0e 100644
+--- a/src/main/java/net/minecraft/world/entity/player/Inventory.java
+++ b/src/main/java/net/minecraft/world/entity/player/Inventory.java
+@@ -174,7 +174,13 @@ public class Inventory implements Container, Nameable {
+     }
+ 
+     public void pickSlot(int slot) {
+-        this.selected = this.getSuitableHotbarSlot();
+        // Paper start - Add PlayerPickItemEvent
+        pickSlot(slot, this.getSuitableHotbarSlot());
+    }
+
+    public void pickSlot(int slot, int targetSlot) {
+        this.selected = targetSlot;
+        // Paper end
+         ItemStack itemstack = (ItemStack) this.items.get(this.selected);
+ 
+         this.items.set(this.selected, (ItemStack) this.items.get(slot));
--- a/patches/server/1001-Improve-performance-of-mass-crafts.patch
+++ b/patches/server/1001-Improve-performance-of-mass-crafts.patch
@ -0,0 +1,83 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Sun, 13 Aug 2023 15:41:52 -0700
+Subject: [PATCH] Improve performance of mass crafts
+
+When the server crafts all available items in CraftingMenu or InventoryMenu the game
+checks either 4 or 9 times for each individual craft for a matching recipe for that container.
+This check can be expensive if 64 total crafts are being performed with the recipe matching logic
+being run 64 * 9 + 64 times. A breakdown of those times is below. This patch caches the last matching
+recipe so that it is checked first and only if it doesn't match does the rest of the matching logic run.
+
+Shift-click crafts are processed one at a time, so shift clicking on an item in the result of a iron block craft
+where all the 9 inputs are full stacks of iron will run 64 iron block crafts. For each of those crafts, the
+'remaining' blocks are calculated. This is due to recipes that have leftover items like buckets. This is done
+for each craft, and done once to get the full 9 leftover items which are usually air. Then 1 item is removed
+from each of the 9 inputs and each time that happens, logic is triggered to update the result itemstack. So
+for each craft, that logic is run 9 times (hence the 64 * 9). The + 64 is from the 64 checks for remaining items.
+
+After this patch, the full iteration over all recipes checking for a match should run once for a full craft to find the
+initial recipe match. Then that recipe will be checked first for all future recipe match checks.
+
+diff --git a/src/main/java/net/minecraft/world/inventory/CraftingMenu.java b/src/main/java/net/minecraft/world/inventory/CraftingMenu.java
+index a7aa2a4845cbf5a0843dcb93f7bdc5501f62a145..4c8ce073094e55ea0df67fe02c0d1cc8aef76562 100644
+--- a/src/main/java/net/minecraft/world/inventory/CraftingMenu.java
+++ b/src/main/java/net/minecraft/world/inventory/CraftingMenu.java
+@@ -76,7 +76,8 @@ public class CraftingMenu extends RecipeBookMenu<CraftingContainer> {
+         if (!world.isClientSide) {
+             ServerPlayer entityplayer = (ServerPlayer) player;
+             ItemStack itemstack = ItemStack.EMPTY;
+-            Optional<RecipeHolder<CraftingRecipe>> optional = world.getServer().getRecipeManager().getRecipeFor(RecipeType.CRAFTING, craftingInventory, world);
+            final RecipeHolder<?> currentRecipe = craftingInventory.getCurrentRecipe(); // Paper - check last recipe used first
+            Optional<RecipeHolder<CraftingRecipe>> optional = currentRecipe == null ? world.getServer().getRecipeManager().getRecipeFor(RecipeType.CRAFTING, craftingInventory, world) : world.getServer().getRecipeManager().getRecipeFor(RecipeType.CRAFTING, craftingInventory, world, currentRecipe.id()).map(com.mojang.datafixers.util.Pair::getSecond); // Paper - check last recipe used first
+ 
+             if (optional.isPresent()) {
+                 RecipeHolder<CraftingRecipe> recipeholder = (RecipeHolder) optional.get();
+diff --git a/src/main/java/net/minecraft/world/inventory/ResultSlot.java b/src/main/java/net/minecraft/world/inventory/ResultSlot.java
+index 7b2ac37e8bd305919f04ded043e50f13b3fe4253..8c97a7269040436cacc65fd182fa8e5f931b6c16 100644
+--- a/src/main/java/net/minecraft/world/inventory/ResultSlot.java
+++ b/src/main/java/net/minecraft/world/inventory/ResultSlot.java
+@@ -59,7 +59,7 @@ public class ResultSlot extends Slot {
+     @Override
+     public void onTake(Player player, ItemStack stack) {
+         this.checkTakeAchievements(stack);
+-        NonNullList<ItemStack> nonNullList = player.level().getRecipeManager().getRemainingItemsFor(RecipeType.CRAFTING, this.craftSlots, player.level());
+        NonNullList<ItemStack> nonNullList = player.level().getRecipeManager().getRemainingItemsFor(RecipeType.CRAFTING, this.craftSlots, player.level(), this.craftSlots.getCurrentRecipe() != null ? this.craftSlots.getCurrentRecipe().id() : null); // Paper - check last recipe used first
+ 
+         for(int i = 0; i < nonNullList.size(); ++i) {
+             ItemStack itemStack = this.craftSlots.getItem(i);
+diff --git a/src/main/java/net/minecraft/world/item/crafting/RecipeManager.java b/src/main/java/net/minecraft/world/item/crafting/RecipeManager.java
+index 93e7d350a4176250d9ae3f0e1e7e6a4197d613b0..b81e1802c8dcc8ebdef96d70088c18379598a66b 100644
+--- a/src/main/java/net/minecraft/world/item/crafting/RecipeManager.java
+++ b/src/main/java/net/minecraft/world/item/crafting/RecipeManager.java
+@@ -122,13 +122,16 @@ public class RecipeManager extends SimpleJsonResourceReloadListener {
+             RecipeHolder<T> recipeholder = (RecipeHolder) map.get(id);
+ 
+             if (recipeholder != null && recipeholder.value().matches(inventory, world)) {
+                inventory.setCurrentRecipe(recipeholder); // Paper
+                 return Optional.of(Pair.of(id, recipeholder));
+             }
+         }
+ 
+        inventory.setCurrentRecipe(null); // Paper - clear before it might be set again
+         return map.entrySet().stream().filter((entry) -> {
+             return ((RecipeHolder) entry.getValue()).value().matches(inventory, world);
+         }).findFirst().map((entry) -> {
+            inventory.setCurrentRecipe(entry.getValue()); // Paper
+             return Pair.of((ResourceLocation) entry.getKey(), (RecipeHolder) entry.getValue());
+         });
+     }
+@@ -150,7 +153,12 @@ public class RecipeManager extends SimpleJsonResourceReloadListener {
+     }
+ 
+     public <C extends Container, T extends Recipe<C>> NonNullList<ItemStack> getRemainingItemsFor(RecipeType<T> type, C inventory, Level world) {
+-        Optional<RecipeHolder<T>> optional = this.getRecipeFor(type, inventory, world);
+        // Paper start - check last recipe used first
+        return this.getRemainingItemsFor(type, inventory, world, null);
+    }
+    public <C extends Container, T extends Recipe<C>> NonNullList<ItemStack> getRemainingItemsFor(RecipeType<T> type, C inventory, Level world, @Nullable ResourceLocation firstToCheck) {
+        Optional<RecipeHolder<T>> optional = firstToCheck == null ? this.getRecipeFor(type, inventory, world) : this.getRecipeFor(type, inventory, world, firstToCheck).map(Pair::getSecond);
+        // Paper end
+ 
+         if (optional.isPresent()) {
+             return ((RecipeHolder) optional.get()).value().getRemainingItems(inventory);
--- a/patches/server/1002-Allow-trident-custom-damage.patch
+++ b/patches/server/1002-Allow-trident-custom-damage.patch
@ -0,0 +1,45 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Lulu13022002 <41980282+Lulu13022002@users.noreply.github.com>
+Date: Tue, 12 Jul 2022 18:01:14 +0200
+Subject: [PATCH] Allow trident custom damage
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java b/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java
+index 6272b0e1e332789b983a486ee25226e2a1c9fdda..42ebd91196ae420eee57f4380abc558555457163 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java
+++ b/src/main/java/net/minecraft/world/entity/projectile/AbstractArrow.java
+@@ -66,7 +66,7 @@ public abstract class AbstractArrow extends Projectile {
+     public AbstractArrow.Pickup pickup;
+     public int shakeTime;
+     public int life;
+-    private double baseDamage;
+    protected double baseDamage; // Paper - private -> protected
+     public int knockback;
+     public SoundEvent soundEvent;
+     @Nullable
+diff --git a/src/main/java/net/minecraft/world/entity/projectile/ThrownTrident.java b/src/main/java/net/minecraft/world/entity/projectile/ThrownTrident.java
+index cbe8593cecd84f1598649801bebcb46364044eef..01e8f6f36a17c484b825879c377f7d6cc08e1fda 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/ThrownTrident.java
+++ b/src/main/java/net/minecraft/world/entity/projectile/ThrownTrident.java
+@@ -34,10 +34,12 @@ public class ThrownTrident extends AbstractArrow {
+ 
+     public ThrownTrident(EntityType<? extends ThrownTrident> type, Level world) {
+         super(type, world, ThrownTrident.DEFAULT_ARROW_STACK);
+        this.baseDamage = net.minecraft.world.item.TridentItem.BASE_DAMAGE; // Paper
+     }
+ 
+     public ThrownTrident(Level world, LivingEntity owner, ItemStack stack) {
+         super(EntityType.TRIDENT, owner, world, stack);
+        this.baseDamage = net.minecraft.world.item.TridentItem.BASE_DAMAGE; // Paper
+         this.entityData.set(ThrownTrident.ID_LOYALTY, (byte) EnchantmentHelper.getLoyalty(stack));
+         this.entityData.set(ThrownTrident.ID_FOIL, stack.hasFoil());
+     }
+@@ -121,7 +123,7 @@ public class ThrownTrident extends AbstractArrow {
+     @Override
+     protected void onHitEntity(EntityHitResult entityHitResult) {
+         Entity entity = entityHitResult.getEntity();
+-        float f = 8.0F;
+        float f = (float) this.baseDamage; // Paper
+ 
+         if (entity instanceof LivingEntity) {
+             LivingEntity entityliving = (LivingEntity) entity;
--- a/patches/server/1003-Expose-hand-during-BlockCanBuildEvent.patch
+++ b/patches/server/1003-Expose-hand-during-BlockCanBuildEvent.patch
@ -0,0 +1,32 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: The456gamer <the456gamer@the456gamer.dev>
+Date: Mon, 21 Aug 2023 14:13:42 +0100
+Subject: [PATCH] Expose hand during BlockCanBuildEvent
+
+
+diff --git a/src/main/java/net/minecraft/world/item/BlockItem.java b/src/main/java/net/minecraft/world/item/BlockItem.java
+index 6819cea2858f0035a4fbf3671612d43fead883b6..ce0a22b5084cb382b7c1036960793e3a8314a26f 100644
+--- a/src/main/java/net/minecraft/world/item/BlockItem.java
+++ b/src/main/java/net/minecraft/world/item/BlockItem.java
+@@ -214,7 +214,7 @@ public class BlockItem extends Item {
+         boolean defaultReturn = (!this.mustSurvive() || state.canSurvive(context.getLevel(), context.getClickedPos())) && world.checkEntityCollision(state, entityhuman, voxelshapecollision, context.getClickedPos(), true); // Paper
+         org.bukkit.entity.Player player = (context.getPlayer() instanceof ServerPlayer) ? (org.bukkit.entity.Player) context.getPlayer().getBukkitEntity() : null;
+ 
+-        BlockCanBuildEvent event = new BlockCanBuildEvent(CraftBlock.at(context.getLevel(), context.getClickedPos()), player, CraftBlockData.fromData(state), defaultReturn);
+        BlockCanBuildEvent event = new BlockCanBuildEvent(CraftBlock.at(context.getLevel(), context.getClickedPos()), player, CraftBlockData.fromData(state), defaultReturn, org.bukkit.craftbukkit.CraftEquipmentSlot.getHand(context.getHand())); // Paper - expose hand
+         context.getLevel().getCraftServer().getPluginManager().callEvent(event);
+ 
+         return event.isBuildable();
+diff --git a/src/main/java/net/minecraft/world/item/StandingAndWallBlockItem.java b/src/main/java/net/minecraft/world/item/StandingAndWallBlockItem.java
+index 39b8b3675ac58409e05fac07e07c8016c5280d81..88072259a9de205db428351c5c9f6114e199e402 100644
+--- a/src/main/java/net/minecraft/world/item/StandingAndWallBlockItem.java
+++ b/src/main/java/net/minecraft/world/item/StandingAndWallBlockItem.java
+@@ -59,7 +59,7 @@ public class StandingAndWallBlockItem extends BlockItem {
+             boolean defaultReturn = world.isUnobstructed(iblockdata1, blockposition, CollisionContext.empty());
+             org.bukkit.entity.Player player = (context.getPlayer() instanceof ServerPlayer) ? (org.bukkit.entity.Player) context.getPlayer().getBukkitEntity() : null;
+ 
+-            BlockCanBuildEvent event = new BlockCanBuildEvent(CraftBlock.at(world, blockposition), player, CraftBlockData.fromData(iblockdata1), defaultReturn);
+            BlockCanBuildEvent event = new BlockCanBuildEvent(CraftBlock.at(world, blockposition), player, CraftBlockData.fromData(iblockdata1), defaultReturn, org.bukkit.craftbukkit.CraftEquipmentSlot.getHand(context.getHand())); // Paper - expose hand
+             context.getLevel().getCraftServer().getPluginManager().callEvent(event);
+ 
+             return (event.isBuildable()) ? iblockdata1 : null;
--- a/patches/server/1004-Optimize-nearest-structure-border-iteration.patch
+++ b/patches/server/1004-Optimize-nearest-structure-border-iteration.patch
@ -0,0 +1,39 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Martijn Muijsers <martijnmuijsers@live.nl>
+Date: Mon, 21 Aug 2023 21:05:09 +0200
+Subject: [PATCH] Optimize nearest structure border iteration
+
+Getting the nearest generated structure contains a nested set of loops that
+iterates over all chunks at a specific chessboard distance. It does this by
+iterating over the entire square of chunks within that distance, and checking
+if the coordinates are at exactly the right distance to be on the border.
+
+This patch optimizes the iteration by only iterating over the border chunks.
+This evaluated chunks are the same, and in the same order, as before, to
+ensure that the returned found structure (which may for example be a buried
+treasure that will be marked on a treasure map) is the same as in vanilla.
+
+diff --git a/src/main/java/net/minecraft/world/level/chunk/ChunkGenerator.java b/src/main/java/net/minecraft/world/level/chunk/ChunkGenerator.java
+index 8bab3fcfc6aa6c0b37621474a69f15e94bda2113..d5c2a608e1b4c8099c96b33d9d758e968350a46d 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/ChunkGenerator.java
+++ b/src/main/java/net/minecraft/world/level/chunk/ChunkGenerator.java
+@@ -260,12 +260,15 @@ public abstract class ChunkGenerator {
+         int i1 = placement.spacing();
+ 
+         for (int j1 = -radius; j1 <= radius; ++j1) {
+-            boolean flag1 = j1 == -radius || j1 == radius;
+            // Paper start - iterate over border chunks instead of entire square chunk area
+            boolean flag1 = j1 == -radius || j1 == radius; final boolean onBorderAlongZAxis = flag1; // Paper - OBFHELPER
+ 
+-            for (int k1 = -radius; k1 <= radius; ++k1) {
+-                boolean flag2 = k1 == -radius || k1 == radius;
+            for (int k1 = -radius; k1 <= radius; k1 += onBorderAlongZAxis ? 1 : radius * 2) {
+                // boolean flag2 = k1 == -radius || k1 == radius;
+ 
+-                if (flag1 || flag2) {
+                // if (flag1 || flag2) {
+                if (true) {
+                    // Paper end
+                     int l1 = centerChunkX + i1 * j1;
+                     int i2 = centerChunkZ + i1 * k1;
+                     ChunkPos chunkcoordintpair = placement.getPotentialStructureChunk(seed, l1, i2);
--- a/patches/server/1005-Implement-OfflinePlayer-isConnected.patch
+++ b/patches/server/1005-Implement-OfflinePlayer-isConnected.patch
@ -0,0 +1,42 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aeltumn <daniel@goossens.ch>
+Date: Thu, 24 Aug 2023 13:05:30 +0200
+Subject: [PATCH] Implement OfflinePlayer#isConnected
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftOfflinePlayer.java b/src/main/java/org/bukkit/craftbukkit/CraftOfflinePlayer.java
+index 9daec0782774ab51ea8091cb8ed9d0a106e34cfa..2bbc39c257965ad91ee360cdfcd3538a0f041c7e 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftOfflinePlayer.java
+++ b/src/main/java/org/bukkit/craftbukkit/CraftOfflinePlayer.java
+@@ -53,6 +53,13 @@ public class CraftOfflinePlayer implements OfflinePlayer, ConfigurationSerializa
+         return this.getPlayer() != null;
+     }
+ 
+    // Paper start
+    @Override
+    public boolean isConnected() {
+        return false;
+    }
+    // Paper end
+
+     @Override
+     public String getName() {
+         Player player = this.getPlayer();
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index ad602abca07e3a0d6e2889843c5849616f2c23a7..7b81dd72bc107648f2c0df19adeaa8ca7de7b204 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -281,6 +281,13 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+         return this.server.getPlayer(this.getUniqueId()) != null;
+     }
+ 
+    // Paper start
+    @Override
+    public boolean isConnected() {
+        return !this.getHandle().hasDisconnected();
+    }
+    // Paper end
+
+     @Override
+     public InetSocketAddress getAddress() {
+         if (this.getHandle().connection == null) return null;
--- a/patches/server/1006-Fix-inventory-desync.patch
+++ b/patches/server/1006-Fix-inventory-desync.patch
@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Wed, 23 Aug 2023 13:22:09 -0700
+Subject: [PATCH] Fix inventory desync
+
+
+diff --git a/src/main/java/net/minecraft/world/item/BlockItem.java b/src/main/java/net/minecraft/world/item/BlockItem.java
+index ce0a22b5084cb382b7c1036960793e3a8314a26f..efdf56044396b4ce486948d2c993971f99174a5e 100644
+--- a/src/main/java/net/minecraft/world/item/BlockItem.java
+++ b/src/main/java/net/minecraft/world/item/BlockItem.java
+@@ -116,7 +116,7 @@ public class BlockItem extends Item {
+                             if (placeEvent != null && (placeEvent.isCancelled() || !placeEvent.canBuild())) {
+                                 blockstate.update(true, false);
+ 
+-                                if (this instanceof SolidBucketItem) {
+                                if (true) { // Paper - if the event is called here, the inventory should be updated
+                                     ((ServerPlayer) entityhuman).getBukkitEntity().updateInventory(); // SPIGOT-4541
+                                 }
+                                 return InteractionResult.FAIL;
--- a/patches/server/1007-Add-titleOverride-to-InventoryOpenEvent.patch
+++ b/patches/server/1007-Add-titleOverride-to-InventoryOpenEvent.patch
@ -0,0 +1,120 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Fri, 4 Mar 2022 12:45:03 -0800
+Subject: [PATCH] Add titleOverride to InventoryOpenEvent
+
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+index 25772043f3b4483b9f5e32ba9489da52add6941a..695a103f2517f3e888e86e76f3615bd69b00a175 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
+++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -1572,12 +1572,17 @@ public class ServerPlayer extends Player {
+             this.nextContainerCounter();
+             AbstractContainerMenu container = factory.createMenu(this.containerCounter, this.getInventory(), this);
+ 
+            Component title = null; // Paper
+             // CraftBukkit start - Inventory open hook
+             if (container != null) {
+                 container.setTitle(factory.getDisplayName());
+ 
+                 boolean cancelled = false;
+-                container = CraftEventFactory.callInventoryOpenEvent(this, container, cancelled);
+                // Paper start
+                final com.mojang.datafixers.util.Pair<net.kyori.adventure.text.Component, AbstractContainerMenu> result = CraftEventFactory.callInventoryOpenEventWithTitle(this, container, cancelled);
+                container = result.getSecond();
+                title = PaperAdventure.asVanilla(result.getFirst());
+                // Paper end
+                 if (container == null && !cancelled) { // Let pre-cancelled events fall through
+                     // SPIGOT-5263 - close chest if cancelled
+                     if (factory instanceof Container) {
+@@ -1599,7 +1604,7 @@ public class ServerPlayer extends Player {
+             } else {
+                 // CraftBukkit start
+                 this.containerMenu = container;
+-                if (!this.isImmobile()) this.connection.send(new ClientboundOpenScreenPacket(container.containerId, container.getType(), container.getTitle())); // Paper
+                if (!this.isImmobile()) this.connection.send(new ClientboundOpenScreenPacket(container.containerId, container.getType(), Objects.requireNonNullElseGet(title, container::getTitle))); // Paper
+                 // CraftBukkit end
+                 this.initMenu(container);
+                 return OptionalInt.of(this.containerCounter);
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
+index c6b3bc218ac440cc66dee97c21b3db4ad86938be..8a1e765363aeb61078fd23980d3856dc680cb05e 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
+++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
+@@ -358,12 +358,16 @@ public class CraftHumanEntity extends CraftLivingEntity implements HumanEntity {
+         Preconditions.checkArgument(windowType != null, "Unknown windowType");
+         AbstractContainerMenu container = new CraftContainer(inventory, player, player.nextContainerCounter());
+ 
+-        container = CraftEventFactory.callInventoryOpenEvent(player, container);
+        // Paper start
+        final com.mojang.datafixers.util.Pair<net.kyori.adventure.text.Component, AbstractContainerMenu> result = CraftEventFactory.callInventoryOpenEventWithTitle(player, container);
+        container = result.getSecond();
+        // Paper end
+         if (container == null) return;
+ 
+         //String title = container.getBukkitView().getTitle(); // Paper - comment
+         net.kyori.adventure.text.Component adventure$title = container.getBukkitView().title(); // Paper
+         if (adventure$title == null) adventure$title = net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(container.getBukkitView().getTitle()); // Paper
+        if (result.getFirst() != null) adventure$title = result.getFirst(); // Paper
+ 
+         //player.connection.send(new ClientboundOpenScreenPacket(container.containerId, windowType, CraftChatMessage.fromString(title)[0])); // Paper - comment
+         if (!player.isImmobile()) player.connection.send(new ClientboundOpenScreenPacket(container.containerId, windowType, io.papermc.paper.adventure.PaperAdventure.asVanilla(adventure$title))); // Paper
+@@ -439,7 +443,10 @@ public class CraftHumanEntity extends CraftLivingEntity implements HumanEntity {
+         }
+ 
+         // Trigger an INVENTORY_OPEN event
+-        container = CraftEventFactory.callInventoryOpenEvent(player, container);
+        // Paper start
+        final com.mojang.datafixers.util.Pair<net.kyori.adventure.text.Component, AbstractContainerMenu> result = CraftEventFactory.callInventoryOpenEventWithTitle(player, container);
+        container = result.getSecond();
+        // Paper end
+         if (container == null) {
+             return;
+         }
+@@ -450,6 +457,7 @@ public class CraftHumanEntity extends CraftLivingEntity implements HumanEntity {
+         //String title = inventory.getTitle(); // Paper - comment
+         net.kyori.adventure.text.Component adventure$title = inventory.title(); // Paper
+         if (adventure$title == null) adventure$title = net.kyori.adventure.text.serializer.legacy.LegacyComponentSerializer.legacySection().deserialize(inventory.getTitle()); // Paper
+        if (result.getFirst() != null) adventure$title = result.getFirst(); // Paper
+         //player.connection.send(new ClientboundOpenScreenPacket(container.containerId, windowType, CraftChatMessage.fromString(title)[0])); // Paper - comment
+         if (!player.isImmobile()) player.connection.send(new ClientboundOpenScreenPacket(container.containerId, windowType, io.papermc.paper.adventure.PaperAdventure.asVanilla(adventure$title))); // Paper
+         player.containerMenu = container;
+diff --git a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+index 704ba208d5cbaef8bc2eb0a87d6fbb1be42e0460..916b29914f77bed0dbfdcd5eae8a6ef22948b9b0 100644
+--- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+@@ -1443,10 +1443,21 @@ public class CraftEventFactory {
+     }
+ 
+     public static AbstractContainerMenu callInventoryOpenEvent(ServerPlayer player, AbstractContainerMenu container) {
+-        return CraftEventFactory.callInventoryOpenEvent(player, container, false);
+        // Paper start
+        return callInventoryOpenEventWithTitle(player, container).getSecond();
+    }
+    public static com.mojang.datafixers.util.Pair<net.kyori.adventure.text.@org.jetbrains.annotations.Nullable Component, @org.jetbrains.annotations.Nullable AbstractContainerMenu> callInventoryOpenEventWithTitle(ServerPlayer player, AbstractContainerMenu container) {
+        return CraftEventFactory.callInventoryOpenEventWithTitle(player, container, false);
+        // Paper end
+     }
+ 
+    @Deprecated @io.papermc.paper.annotation.DoNotUse // Paper - use method that acknowledges title overrides
+     public static AbstractContainerMenu callInventoryOpenEvent(ServerPlayer player, AbstractContainerMenu container, boolean cancelled) {
+        // Paper start
+        return callInventoryOpenEventWithTitle(player, container, cancelled).getSecond();
+    }
+    public static com.mojang.datafixers.util.Pair<net.kyori.adventure.text.@org.jetbrains.annotations.Nullable Component, @org.jetbrains.annotations.Nullable AbstractContainerMenu> callInventoryOpenEventWithTitle(ServerPlayer player, AbstractContainerMenu container, boolean cancelled) {
+        // Paper end
+         if (player.containerMenu != player.inventoryMenu) { // fire INVENTORY_CLOSE if one already open
+             player.connection.handleContainerClose(new ServerboundContainerClosePacket(player.containerMenu.containerId), InventoryCloseEvent.Reason.OPEN_NEW); // Paper
+         }
+@@ -1461,10 +1472,10 @@ public class CraftEventFactory {
+ 
+         if (event.isCancelled()) {
+             container.transferTo(player.containerMenu, craftPlayer);
+-            return null;
+            return com.mojang.datafixers.util.Pair.of(null, null); // Paper - title override
+         }
+ 
+-        return container;
+        return com.mojang.datafixers.util.Pair.of(event.titleOverride(), container); // Paper - title override
+     }
+ 
+     public static ItemStack callPreCraftEvent(Container matrix, Container resultInventory, ItemStack result, InventoryView lastCraftView, boolean isRepair) {
--- a/patches/server/1008-Configure-sniffer-egg-hatch-time.patch
+++ b/patches/server/1008-Configure-sniffer-egg-hatch-time.patch
@ -0,0 +1,28 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Lulu13022002 <41980282+Lulu13022002@users.noreply.github.com>
+Date: Tue, 27 Jun 2023 13:26:06 +0200
+Subject: [PATCH] Configure sniffer egg hatch time
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/SnifferEggBlock.java b/src/main/java/net/minecraft/world/level/block/SnifferEggBlock.java
+index 02939518ead6463e677ecf5b045ec89aae154e8c..cb431b6027019ca95879129e88967ee6ae03c313 100644
+--- a/src/main/java/net/minecraft/world/level/block/SnifferEggBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/SnifferEggBlock.java
+@@ -63,7 +63,7 @@ public class SnifferEggBlock extends Block {
+ 
+     // Paper start
+     private void rescheduleTick(ServerLevel world, BlockPos pos) {
+-        int baseDelay = hatchBoost(world, pos) ? BOOSTED_HATCH_TIME_TICKS : REGULAR_HATCH_TIME_TICKS;
+        int baseDelay = hatchBoost(world, pos) ? world.paperConfig().entities.sniffer.boostedHatchTime.or(BOOSTED_HATCH_TIME_TICKS) : world.paperConfig().entities.sniffer.hatchTime.or(REGULAR_HATCH_TIME_TICKS);
+         world.scheduleTick(pos, this, (baseDelay / 3) + world.random.nextInt(RANDOM_HATCH_OFFSET_TICKS));
+         // reschedule to avoid being stuck here and behave like the other calls (see #onPlace)
+     }
+@@ -106,7 +106,7 @@ public class SnifferEggBlock extends Block {
+             world.levelEvent(3009, pos, 0);
+         }
+ 
+-        int i = bl ? 12000 : 24000;
+        int i = bl ? world.paperConfig().entities.sniffer.boostedHatchTime.or(BOOSTED_HATCH_TIME_TICKS) : world.paperConfig().entities.sniffer.hatchTime.or(REGULAR_HATCH_TIME_TICKS); // Paper
+         int j = i / 3;
+         world.gameEvent(GameEvent.BLOCK_PLACE, pos, GameEvent.Context.of(state));
+         world.scheduleTick(pos, this, j + world.random.nextInt(300));
--- a/patches/server/1009-Do-crystal-portal-proximity-check-before-entity-look.patch
+++ b/patches/server/1009-Do-crystal-portal-proximity-check-before-entity-look.patch
@ -0,0 +1,75 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Martijn Muijsers <martijnmuijsers@live.nl>
+Date: Tue, 15 Aug 2023 21:04:55 +0200
+Subject: [PATCH] Do crystal-portal proximity check before entity lookup
+
+This adds a very cheap distance check when an end crystal is placed.
+
+Attempting to respawn the dragon, which involves looking up the end crystal
+entities near the portal, every time an end crystal is placed, can be slow on
+some servers that have players placing end crystals as a style of combat.
+
+The very cheap distance check prevents running the entity lookup every time.
+
+diff --git a/src/main/java/net/minecraft/world/item/EndCrystalItem.java b/src/main/java/net/minecraft/world/item/EndCrystalItem.java
+index ca1edc083847b47bb450b291723aca778a5912dc..5a19875cbc603acea95193d969d2e1dc1e0bfd78 100644
+--- a/src/main/java/net/minecraft/world/item/EndCrystalItem.java
+++ b/src/main/java/net/minecraft/world/item/EndCrystalItem.java
+@@ -29,7 +29,7 @@ public class EndCrystalItem extends Item {
+         if (!iblockdata.is(Blocks.OBSIDIAN) && !iblockdata.is(Blocks.BEDROCK)) {
+             return InteractionResult.FAIL;
+         } else {
+-            BlockPos blockposition1 = blockposition.above();
+            BlockPos blockposition1 = blockposition.above(); final BlockPos aboveBlockPosition = blockposition1; // Paper - OBFHELPER
+ 
+             if (!world.isEmptyBlock(blockposition1)) {
+                 return InteractionResult.FAIL;
+@@ -56,7 +56,7 @@ public class EndCrystalItem extends Item {
+                         EndDragonFight enderdragonbattle = ((ServerLevel) world).getDragonFight();
+ 
+                         if (enderdragonbattle != null) {
+-                            enderdragonbattle.tryRespawn();
+                            enderdragonbattle.tryRespawn(aboveBlockPosition); // Paper - pass placed end crystal position to pre-check proximity to portal
+                         }
+                     }
+ 
+diff --git a/src/main/java/net/minecraft/world/level/dimension/end/EndDragonFight.java b/src/main/java/net/minecraft/world/level/dimension/end/EndDragonFight.java
+index b2a57cb75916d2724f18779c922005ef9bcc0b0e..c1ff2e15bc5da1a642872ac0fdcdc457e8abb063 100644
+--- a/src/main/java/net/minecraft/world/level/dimension/end/EndDragonFight.java
+++ b/src/main/java/net/minecraft/world/level/dimension/end/EndDragonFight.java
+@@ -558,6 +558,12 @@ public class EndDragonFight {
+     }
+ 
+     public boolean tryRespawn() { // CraftBukkit - return boolean
+        // Paper start - pass null (indicating no placed end crystal involved) by default
+        return this.tryRespawn(null);
+    }
+
+    public boolean tryRespawn(@Nullable BlockPos placedEndCrystalPos) { // placedEndCrystalPos is null if the tryRespawn() call was not caused by a placed end crystal
+        // Paper end
+         if (this.dragonKilled && this.respawnStage == null) {
+             BlockPos blockposition = this.portalLocation;
+ 
+@@ -575,6 +581,22 @@ public class EndDragonFight {
+                 blockposition = this.portalLocation;
+             }
+ 
+            // Paper start - check placed end crystal to portal proximity before attempting to respawn dragon
+            if (placedEndCrystalPos != null) {
+                // The end crystal must be 0 or 1 higher than the portal origin
+                int dy = placedEndCrystalPos.getY() - blockposition.getY();
+                if (dy != 0 && dy != 1) {
+                    return false;
+                }
+                // The end crystal must be within a distance of 1 in one planar direction, and 3 in the other
+                int dx = placedEndCrystalPos.getX() - blockposition.getX();
+                int dz = placedEndCrystalPos.getZ() - blockposition.getZ();
+                if (!((dx >= -1 && dx <= 1 && dz >= -3 && dz <= 3) || (dx >= -3 && dx <= 3 && dz >= -1 && dz <= 1))) {
+                    return false;
+                }
+            }
+            // Paper end
+
+             List<EndCrystal> list = Lists.newArrayList();
+             BlockPos blockposition1 = blockposition.above(1);
+             Iterator iterator = Direction.Plane.HORIZONTAL.iterator();
--- a/patches/server/1010-Skip-POI-finding-if-stuck-in-vehicle.patch
+++ b/patches/server/1010-Skip-POI-finding-if-stuck-in-vehicle.patch
@ -0,0 +1,32 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Paul Sauve <paul@technove.co>
+Date: Thu, 18 Feb 2021 13:13:27 -0600
+Subject: [PATCH] Skip POI finding if stuck in vehicle
+
+Copyright (C) 2020 Technove LLC
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+diff --git a/src/main/java/net/minecraft/world/entity/ai/behavior/AcquirePoi.java b/src/main/java/net/minecraft/world/entity/ai/behavior/AcquirePoi.java
+index d4c91e0a0c64fcb7f1145de3f30134cb1f1f8ee6..8f8b29f80d1573981ccffd207dd6e0941e71a352 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/behavior/AcquirePoi.java
+++ b/src/main/java/net/minecraft/world/entity/ai/behavior/AcquirePoi.java
+@@ -47,6 +47,7 @@ public class AcquirePoi {
+                         return false;
+                     } else {
+                         mutableLong.setValue(time + 20L + (long)world.getRandom().nextInt(20));
+                        if (entity.getNavigation().isStuck()) mutableLong.add(200); // Paper - Wait an additional 10s to check again if they're stuck
+                         PoiManager poiManager = world.getPoiManager();
+                         long2ObjectMap.long2ObjectEntrySet().removeIf((entry) -> {
+                             return !entry.getValue().isStillValid(time);
--- a/patches/server/1011-Add-slot-sanity-checks-in-container-clicks.patch
+++ b/patches/server/1011-Add-slot-sanity-checks-in-container-clicks.patch
@ -0,0 +1,35 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Nassim Jahnke <nassim@njahnke.dev>
+Date: Mon, 11 Sep 2023 12:01:57 +1000
+Subject: [PATCH] Add slot sanity checks in container clicks
+
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index c8858b9f72f57356f47575c01cbb159d341e0825..555555786d5be31d10a8aee5d8b1972e61806262 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -2991,6 +2991,12 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+                             break;
+                         case SWAP:
+                             if ((packet.getButtonNum() >= 0 && packet.getButtonNum() < 9) || packet.getButtonNum() == 40) {
+                                // Paper start
+                                if (packet.getSlotNum() < 0) {
+                                    action = InventoryAction.NOTHING;
+                                    break;
+                                }
+                                // Paper end
+                                 click = (packet.getButtonNum() == 40) ? ClickType.SWAP_OFFHAND : ClickType.NUMBER_KEY;
+                                 Slot clickedSlot = this.player.containerMenu.getSlot(packet.getSlotNum());
+                                 if (clickedSlot.mayPickup(this.player)) {
+diff --git a/src/main/java/net/minecraft/world/inventory/AbstractContainerMenu.java b/src/main/java/net/minecraft/world/inventory/AbstractContainerMenu.java
+index 9ee3c2e0dcfaa4280be4973479c6490ded33809c..96a2d06e8da8bf0f0a3b0af813bf79d448940a3a 100644
+--- a/src/main/java/net/minecraft/world/inventory/AbstractContainerMenu.java
+++ b/src/main/java/net/minecraft/world/inventory/AbstractContainerMenu.java
+@@ -423,6 +423,7 @@ public abstract class AbstractContainerMenu {
+                     this.resetQuickCraft();
+                 }
+             } else if (this.quickcraftStatus == 1) {
+                if (slotIndex < 0) return; // Paper
+                 slot = (Slot) this.slots.get(slotIndex);
+                 itemstack = this.getCarried();
+                 if (AbstractContainerMenu.canItemQuickReplace(slot, itemstack, true) && slot.mayPlace(itemstack) && (this.quickcraftType == 2 || itemstack.getCount() > this.quickcraftSlots.size()) && this.canDragTo(slot)) {
--- a/patches/server/1012-Call-BlockRedstoneEvents-for-lecterns.patch
+++ b/patches/server/1012-Call-BlockRedstoneEvents-for-lecterns.patch
@ -0,0 +1,27 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Warrior <50800980+Warriorrrr@users.noreply.github.com>
+Date: Wed, 13 Sep 2023 05:46:10 +0200
+Subject: [PATCH] Call BlockRedstoneEvents for lecterns
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/LecternBlock.java b/src/main/java/net/minecraft/world/level/block/LecternBlock.java
+index f14f35e0f5a087845f7229a68e996feb06c946d4..38f68917119b30be2787363697a0501080362a90 100644
+--- a/src/main/java/net/minecraft/world/level/block/LecternBlock.java
+++ b/src/main/java/net/minecraft/world/level/block/LecternBlock.java
+@@ -178,6 +178,16 @@ public class LecternBlock extends BaseEntityBlock {
+     }
+ 
+     private static void changePowered(Level world, BlockPos pos, BlockState state, boolean powered) {
+        // Paper start - call BlockRedstoneEvents for lecterns
+        final int currentRedstoneLevel = state.getValue(LecternBlock.POWERED) ? 15 : 0, targetRedstoneLevel = powered ? 15 : 0;
+        if (currentRedstoneLevel != targetRedstoneLevel) {
+            final org.bukkit.event.block.BlockRedstoneEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callRedstoneChange(world, pos, currentRedstoneLevel, targetRedstoneLevel);
+
+            if (event.getNewCurrent() != targetRedstoneLevel) {
+                return;
+            }
+        }
+        // Paper end
+         world.setBlock(pos, (BlockState) state.setValue(LecternBlock.POWERED, powered), 3);
+         LecternBlock.updateBelow(world, pos, state);
+     }
--- a/patches/server/1013-Allow-proper-checking-of-empty-item-stacks.patch
+++ b/patches/server/1013-Allow-proper-checking-of-empty-item-stacks.patch
@ -0,0 +1,31 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Aeltumn <daniel@goossens.ch>
+Date: Mon, 28 Aug 2023 13:44:09 +0200
+Subject: [PATCH] Allow proper checking of empty item stacks
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java
+index 3660ad55cc7e1f6e571887aac9c0215803f1ce41..f9ae1d0889e7f8ff8753d27619bfeb6e9c23f5fe 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java
+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java
+@@ -33,12 +33,19 @@ public final class CraftItemStack extends ItemStack {
+     }
+     // Paper end - MC Utils
+ 
+    // Paper start - override isEmpty to use vanilla's impl
+    @Override
+    public boolean isEmpty() {
+        return handle == null || handle.isEmpty();
+    }
+    // Paper end
+
+     public static net.minecraft.world.item.ItemStack asNMSCopy(ItemStack original) {
+         if (original instanceof CraftItemStack) {
+             CraftItemStack stack = (CraftItemStack) original;
+             return stack.handle == null ? net.minecraft.world.item.ItemStack.EMPTY : stack.handle.copy();
+         }
+-        if (original == null || original.getType() == Material.AIR) {
+        if (original == null || original.isEmpty()) { // Paper - use isEmpty
+             return net.minecraft.world.item.ItemStack.EMPTY;
+         }
+ 
--- a/patches/server/1014-Fix-silent-equipment-change-for-mobs.patch
+++ b/patches/server/1014-Fix-silent-equipment-change-for-mobs.patch
@ -0,0 +1,121 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Lulu13022002 <41980282+Lulu13022002@users.noreply.github.com>
+Date: Thu, 31 Aug 2023 17:32:48 +0200
+Subject: [PATCH] Fix silent equipment change for mobs
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/Mob.java b/src/main/java/net/minecraft/world/entity/Mob.java
+index 16d84042e2575418880897c728a99d1b8bbcdd15..5af48151159135b869ec4753bbcf79dd257c1570 100644
+--- a/src/main/java/net/minecraft/world/entity/Mob.java
+++ b/src/main/java/net/minecraft/world/entity/Mob.java
+@@ -1059,13 +1059,20 @@ public abstract class Mob extends LivingEntity implements Targeting {
+ 
+     @Override
+     public void setItemSlot(EquipmentSlot slot, ItemStack stack) {
+        // Paper start
+        setItemSlot(slot, stack, false);
+    }
+
+    @Override
+    public void setItemSlot(EquipmentSlot slot, ItemStack stack, boolean silent) {
+        // Paper end
+         this.verifyEquippedItem(stack);
+         switch (slot.getType()) {
+             case HAND:
+-                this.onEquipItem(slot, (ItemStack) this.handItems.set(slot.getIndex(), stack), stack);
+                this.onEquipItem(slot, (ItemStack) this.handItems.set(slot.getIndex(), stack), stack, silent); // Paper
+                 break;
+             case ARMOR:
+-                this.onEquipItem(slot, (ItemStack) this.armorItems.set(slot.getIndex(), stack), stack);
+                this.onEquipItem(slot, (ItemStack) this.armorItems.set(slot.getIndex(), stack), stack, silent); // Paper
+         }
+ 
+     }
+diff --git a/src/main/java/net/minecraft/world/entity/monster/AbstractSkeleton.java b/src/main/java/net/minecraft/world/entity/monster/AbstractSkeleton.java
+index 8e9469fec42f7b6a132cf173f6f5a95777a29b3b..b319021b22c5dceba6199ed27814b2dcf47b8d50 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/AbstractSkeleton.java
+++ b/src/main/java/net/minecraft/world/entity/monster/AbstractSkeleton.java
+@@ -250,8 +250,8 @@ public abstract class AbstractSkeleton extends Monster implements RangedAttackMo
+     // Paper end
+ 
+     @Override
+-    public void setItemSlot(EquipmentSlot slot, ItemStack stack) {
+-        super.setItemSlot(slot, stack);
+    public void setItemSlot(EquipmentSlot slot, ItemStack stack, boolean silent) { // Paper
+        super.setItemSlot(slot, stack, silent); // Paper
+         if (!this.level().isClientSide) {
+             this.reassessWeaponGoal();
+         }
+diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
+index 0afad3487a3939981abda6a2342e90683816a39f..396d32cde12ea7022714c4971ecbba3d215bb15b 100644
+--- a/src/main/java/net/minecraft/world/level/Level.java
+++ b/src/main/java/net/minecraft/world/level/Level.java
+@@ -1890,7 +1890,10 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+     // Paper end - optimize redstone (Alternate Current)
+     // Paper start - notify observers even if grow failed
+     public void checkCapturedTreeStateForObserverNotify(final BlockPos pos, final CraftBlockState craftBlockState) {
+-        if (craftBlockState.getPosition().getY() == pos.getY() && this.getBlockState(craftBlockState.getPosition()) == craftBlockState.getHandle()) { // notify observers if the block state is the same and the Y level equals the original y level (for mega trees)
+        // notify observers if the block state is the same and the Y level equals the original y level (for mega trees)
+        // blocks at the same Y level with the same state can be assumed to be saplings which trigger observers regardless of if the
+        // tree grew or not
+        if (craftBlockState.getPosition().getY() == pos.getY() && this.getBlockState(craftBlockState.getPosition()) == craftBlockState.getHandle()) {
+             this.notifyAndUpdatePhysics(craftBlockState.getPosition(), null, craftBlockState.getHandle(), craftBlockState.getHandle(), craftBlockState.getHandle(), craftBlockState.getFlag(), 512);
+         }
+     }
+diff --git a/src/test/java/io/papermc/paper/entity/EntitySetItemSlotSilentOverrideTest.java b/src/test/java/io/papermc/paper/entity/EntitySetItemSlotSilentOverrideTest.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..81947843d1f2f7dc6f59d7b52f327d60b17d0dcc
+--- /dev/null
+++ b/src/test/java/io/papermc/paper/entity/EntitySetItemSlotSilentOverrideTest.java
+@@ -0,0 +1,51 @@
+package io.papermc.paper.entity;
+
+import io.github.classgraph.ClassGraph;
+import io.github.classgraph.ClassInfo;
+import io.github.classgraph.MethodInfo;
+import io.github.classgraph.MethodInfoList;
+import io.github.classgraph.MethodParameterInfo;
+import io.github.classgraph.ScanResult;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.Stream;
+import org.bukkit.support.AbstractTestingBase;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import static org.junit.jupiter.api.Assertions.fail;
+
+public class EntitySetItemSlotSilentOverrideTest extends AbstractTestingBase {
+
+    public static Stream<ClassInfo> parameters() {
+        final List<ClassInfo> classInfo = new ArrayList<>();
+        try (ScanResult scanResult = new ClassGraph()
+            .enableClassInfo()
+            .enableMethodInfo()
+            .whitelistPackages("net.minecraft")
+            .scan()
+        ) {
+            for (final ClassInfo subclass : scanResult.getSubclasses("net.minecraft.world.entity.LivingEntity")) {
+                final MethodInfoList setItemSlot = subclass.getDeclaredMethodInfo("setItemSlot");
+                if (!setItemSlot.isEmpty()) {
+                    classInfo.add(subclass);
+                }
+            }
+        }
+        return classInfo.stream();
+    }
+
+    @ParameterizedTest
+    @MethodSource("parameters")
+    public void checkSetItemSlotSilentOverrides(ClassInfo overridesSetItemSlot) {
+        final MethodInfoList setItemSlot = overridesSetItemSlot.getDeclaredMethodInfo("setItemSlot");
+        for (final MethodInfo methodInfo : setItemSlot) {
+            for (final MethodParameterInfo methodParameterInfo : methodInfo.getParameterInfo()) {
+                if ("boolean".equals(methodParameterInfo.getTypeDescriptor().toStringWithSimpleNames())) {
+                    return;
+                }
+            }
+        }
+        fail(overridesSetItemSlot.getName() + " needs to override setItemSlot with the boolean silent parameter as well");
+    }
+}
--- a/patches/server/1015-Fix-spigot-s-Forced-Stats.patch
+++ b/patches/server/1015-Fix-spigot-s-Forced-Stats.patch
@ -0,0 +1,49 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: The456gamer <the456gamer@the456gamer.dev>
+Date: Mon, 28 Aug 2023 01:32:39 +0100
+Subject: [PATCH] Fix spigot's Forced-Stats
+
+moves the loading after vanilla loading, so it overrides the values.
+disables saving any forced stats, so it stays at the same value (without enabling disableStatSaving)
+fixes stat initialization to not cause a NullPointerException
+
+diff --git a/src/main/java/net/minecraft/stats/ServerStatsCounter.java b/src/main/java/net/minecraft/stats/ServerStatsCounter.java
+index 9501e5f25f5c4d3069e554d4dc82b0e094156682..9bb8d4d7be6a937980aa653db82be084d066a563 100644
+--- a/src/main/java/net/minecraft/stats/ServerStatsCounter.java
+++ b/src/main/java/net/minecraft/stats/ServerStatsCounter.java
+@@ -48,13 +48,6 @@ public class ServerStatsCounter extends StatsCounter {
+     public ServerStatsCounter(MinecraftServer server, File file) {
+         this.server = server;
+         this.file = file;
+-        // Spigot start
+-        for ( Map.Entry<ResourceLocation, Integer> entry : org.spigotmc.SpigotConfig.forcedStats.entrySet() )
+-        {
+-            Stat<ResourceLocation> wrapper = Stats.CUSTOM.get( entry.getKey() );
+-            this.stats.put( wrapper, entry.getValue().intValue() );
+-        }
+-        // Spigot end
+         if (file.isFile()) {
+             try {
+                 this.parseLocal(server.getFixerUpper(), FileUtils.readFileToString(file));
+@@ -65,6 +58,13 @@ public class ServerStatsCounter extends StatsCounter {
+             }
+         }
+ 
+        // Spigot start // Paper start - moved after stat fetching for player state file.
+        for ( Map.Entry<ResourceLocation, Integer> entry : org.spigotmc.SpigotConfig.forcedStats.entrySet() )
+        {
+            Stat<ResourceLocation> wrapper = Stats.CUSTOM.get(java.util.Objects.requireNonNull(BuiltInRegistries.CUSTOM_STAT.get(entry.getKey()))); // Paper - ensured by SpigotConfig#stats
+            this.stats.put( wrapper, entry.getValue().intValue() );
+        }
+        // Spigot end // Paper end - moved after stat fetching for player state file.
+     }
+ 
+     public void save() {
+@@ -80,6 +80,7 @@ public class ServerStatsCounter extends StatsCounter {
+     @Override
+     public void setValue(Player player, Stat<?> stat, int value) {
+         if ( org.spigotmc.SpigotConfig.disableStatSaving ) return; // Spigot
+        if (stat.getType() == Stats.CUSTOM && stat.getValue() instanceof final ResourceLocation resourceLocation && org.spigotmc.SpigotConfig.forcedStats.get(resourceLocation) != null) return; // Paper - disable saving forced stats
+         super.setValue(player, stat, value);
+         this.dirty.add(stat);
+     }
--- a/patches/server/1016-Add-missing-InventoryHolders-to-inventories.patch
+++ b/patches/server/1016-Add-missing-InventoryHolders-to-inventories.patch
@ -0,0 +1,302 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Mon, 24 Jan 2022 00:09:02 -0800
+Subject: [PATCH] Add missing InventoryHolders to inventories
+
+
+diff --git a/src/main/java/net/minecraft/world/Container.java b/src/main/java/net/minecraft/world/Container.java
+index da5ff65fade5cdf14fad3705c08b48896bc4c36d..d6cbe98e67fdbf8db46338a88ab1356dd63b50a3 100644
+--- a/src/main/java/net/minecraft/world/Container.java
+++ b/src/main/java/net/minecraft/world/Container.java
+@@ -100,7 +100,7 @@ public interface Container extends Clearable {
+ 
+     java.util.List<org.bukkit.entity.HumanEntity> getViewers();
+ 
+-    org.bukkit.inventory.InventoryHolder getOwner();
+    org.bukkit.inventory.@org.jetbrains.annotations.Nullable InventoryHolder getOwner(); // Paper - annotation
+ 
+     void setMaxStackSize(int size);
+ 
+diff --git a/src/main/java/net/minecraft/world/SimpleContainer.java b/src/main/java/net/minecraft/world/SimpleContainer.java
+index 061e870e0cdd5bf00351b7e8104361bce86809f3..0259d188e6e16384069bf2a1c6e0197fe631ab6b 100644
+--- a/src/main/java/net/minecraft/world/SimpleContainer.java
+++ b/src/main/java/net/minecraft/world/SimpleContainer.java
+@@ -30,7 +30,7 @@ public class SimpleContainer implements Container, StackedContentsCompatible {
+     // CraftBukkit start - add fields and methods
+     public List<HumanEntity> transaction = new java.util.ArrayList<HumanEntity>();
+     private int maxStack = MAX_STACK;
+-    protected org.bukkit.inventory.InventoryHolder bukkitOwner;
+    protected @Nullable org.bukkit.inventory.InventoryHolder bukkitOwner; // Paper - annotation
+ 
+     public List<ItemStack> getContents() {
+         return this.items;
+@@ -58,6 +58,11 @@ public class SimpleContainer implements Container, StackedContentsCompatible {
+     }
+ 
+     public org.bukkit.inventory.InventoryHolder getOwner() {
+        // Paper start
+        if (this.bukkitOwner == null && this.bukkitOwnerCreator != null) {
+            this.bukkitOwner = this.bukkitOwnerCreator.get();
+        }
+        // Paper end
+         return this.bukkitOwner;
+     }
+ 
+@@ -86,6 +91,13 @@ public class SimpleContainer implements Container, StackedContentsCompatible {
+     public SimpleContainer(int size) {
+         this(size, null);
+     }
+    // Paper start
+    private @Nullable java.util.function.Supplier<? extends org.bukkit.inventory.InventoryHolder> bukkitOwnerCreator;
+    public SimpleContainer(java.util.function.Supplier<? extends org.bukkit.inventory.InventoryHolder> bukkitOwnerCreator, int size) {
+        this(size);
+        this.bukkitOwnerCreator = bukkitOwnerCreator;
+    }
+    // Paper end
+ 
+     public SimpleContainer(int i, org.bukkit.inventory.InventoryHolder owner) {
+         this.bukkitOwner = owner;
+diff --git a/src/main/java/net/minecraft/world/inventory/AbstractContainerMenu.java b/src/main/java/net/minecraft/world/inventory/AbstractContainerMenu.java
+index 96a2d06e8da8bf0f0a3b0af813bf79d448940a3a..97426fe50149123e6a94989ee98c6d0aad4ca1cb 100644
+--- a/src/main/java/net/minecraft/world/inventory/AbstractContainerMenu.java
+++ b/src/main/java/net/minecraft/world/inventory/AbstractContainerMenu.java
+@@ -1028,4 +1028,15 @@ public abstract class AbstractContainerMenu {
+         this.stateId = this.stateId + 1 & 32767;
+         return this.stateId;
+     }
+
+    // Paper start - add missing BlockInventoryHolder to inventories
+    // The reason this is a supplier, is that the createHolder method uses the bukkit InventoryView#getTopInventory to get the inventory in question
+    // and that can't be obtained safely until the AbstractContainerMenu has been fully constructed. Using a supplier lazily
+    // initializes the InventoryHolder safely.
+    protected final Supplier<org.bukkit.inventory.BlockInventoryHolder> createBlockHolder(final ContainerLevelAccess context) {
+        //noinspection ConstantValue
+        Preconditions.checkArgument(context != null, "context was null");
+        return () -> context.createBlockHolder(this);
+    }
+    // Paper end
+ }
+diff --git a/src/main/java/net/minecraft/world/inventory/BeaconMenu.java b/src/main/java/net/minecraft/world/inventory/BeaconMenu.java
+index a6e712606ece631502ae4c7513403092df77524f..25af92ec0d086160020cade97b0ddf7f6546e159 100644
+--- a/src/main/java/net/minecraft/world/inventory/BeaconMenu.java
+++ b/src/main/java/net/minecraft/world/inventory/BeaconMenu.java
+@@ -41,7 +41,7 @@ public class BeaconMenu extends AbstractContainerMenu {
+     public BeaconMenu(int syncId, Container inventory, ContainerData propertyDelegate, ContainerLevelAccess context) {
+         super(MenuType.BEACON, syncId);
+         this.player = (Inventory) inventory; // CraftBukkit - TODO: check this
+-        this.beacon = new SimpleContainer(1) {
+        this.beacon = new SimpleContainer(this.createBlockHolder(context), 1) { // Paper
+             @Override
+             public boolean canPlaceItem(int slot, ItemStack stack) {
+                 return stack.is(ItemTags.BEACON_PAYMENT_ITEMS);
+diff --git a/src/main/java/net/minecraft/world/inventory/CartographyTableMenu.java b/src/main/java/net/minecraft/world/inventory/CartographyTableMenu.java
+index 819187dbcf468d9278ce33bd97688476aab53f8e..09be5db3c09262e8bc56c4e20a48fe648f09237c 100644
+--- a/src/main/java/net/minecraft/world/inventory/CartographyTableMenu.java
+++ b/src/main/java/net/minecraft/world/inventory/CartographyTableMenu.java
+@@ -52,7 +52,7 @@ public class CartographyTableMenu extends AbstractContainerMenu {
+ 
+     public CartographyTableMenu(int syncId, Inventory inventory, final ContainerLevelAccess context) {
+         super(MenuType.CARTOGRAPHY_TABLE, syncId);
+-        this.container = new SimpleContainer(2) {
+        this.container = new SimpleContainer(this.createBlockHolder(context), 2) { // Paper
+             @Override
+             public void setChanged() {
+                 CartographyTableMenu.this.slotsChanged(this);
+@@ -66,7 +66,7 @@ public class CartographyTableMenu extends AbstractContainerMenu {
+             }
+             // CraftBukkit end
+         };
+-        this.resultContainer = new ResultContainer() {
+        this.resultContainer = new ResultContainer(this.createBlockHolder(context)) { // Paper
+             @Override
+             public void setChanged() {
+                 CartographyTableMenu.this.slotsChanged(this);
+diff --git a/src/main/java/net/minecraft/world/inventory/ContainerLevelAccess.java b/src/main/java/net/minecraft/world/inventory/ContainerLevelAccess.java
+index f00a957a0f55e69f93e6d7dc80193304447c3dcb..d2f19b44ce4ab663a68ee330de4d4582ae9f3f00 100644
+--- a/src/main/java/net/minecraft/world/inventory/ContainerLevelAccess.java
+++ b/src/main/java/net/minecraft/world/inventory/ContainerLevelAccess.java
+@@ -21,6 +21,18 @@ public interface ContainerLevelAccess {
+         return new org.bukkit.Location(this.getWorld().getWorld(), this.getPosition().getX(), this.getPosition().getY(), this.getPosition().getZ());
+     }
+     // CraftBukkit end
+    // Paper start
+    default boolean isBlock() {
+        return false;
+    }
+
+    default org.bukkit.inventory.@org.jetbrains.annotations.Nullable BlockInventoryHolder createBlockHolder(AbstractContainerMenu menu) {
+        if (!this.isBlock()) {
+            return null;
+        }
+        return new org.bukkit.craftbukkit.inventory.CraftBlockInventoryHolder(this, menu.getBukkitView().getTopInventory());
+    }
+    // Paper end
+ 
+     ContainerLevelAccess NULL = new ContainerLevelAccess() {
+         @Override
+@@ -48,6 +60,12 @@ public interface ContainerLevelAccess {
+                 return pos;
+             }
+             // CraftBukkit end
+            // Paper start
+            @Override
+            public boolean isBlock() {
+                return true;
+            }
+            // Paper end
+ 
+             @Override
+             public <T> Optional<T> evaluate(BiFunction<Level, BlockPos, T> getter) {
+diff --git a/src/main/java/net/minecraft/world/inventory/EnchantmentMenu.java b/src/main/java/net/minecraft/world/inventory/EnchantmentMenu.java
+index c2d6265933dc4ceed80e2bd517970d02164a63df..c5c509fbb915c60dfa95aac8510684d0b9f8b0ff 100644
+--- a/src/main/java/net/minecraft/world/inventory/EnchantmentMenu.java
+++ b/src/main/java/net/minecraft/world/inventory/EnchantmentMenu.java
+@@ -61,7 +61,7 @@ public class EnchantmentMenu extends AbstractContainerMenu {
+ 
+     public EnchantmentMenu(int syncId, Inventory playerInventory, ContainerLevelAccess context) {
+         super(MenuType.ENCHANTMENT, syncId);
+-        this.enchantSlots = new SimpleContainer(2) {
+        this.enchantSlots = new SimpleContainer(this.createBlockHolder(context), 2) { // Paper
+             @Override
+             public void setChanged() {
+                 super.setChanged();
+diff --git a/src/main/java/net/minecraft/world/inventory/GrindstoneMenu.java b/src/main/java/net/minecraft/world/inventory/GrindstoneMenu.java
+index 24187a7ce812cb83a9a736bec8dce9e68ccc0798..076c2b2938c9b88b7e71dbc2aa9d8c7e90d4fe75 100644
+--- a/src/main/java/net/minecraft/world/inventory/GrindstoneMenu.java
+++ b/src/main/java/net/minecraft/world/inventory/GrindstoneMenu.java
+@@ -59,8 +59,8 @@ public class GrindstoneMenu extends AbstractContainerMenu {
+ 
+     public GrindstoneMenu(int syncId, Inventory playerInventory, final ContainerLevelAccess context) {
+         super(MenuType.GRINDSTONE, syncId);
+-        this.resultSlots = new ResultContainer();
+-        this.repairSlots = new SimpleContainer(2) {
+        this.resultSlots = new ResultContainer(this.createBlockHolder(context)); // Paper
+        this.repairSlots = new SimpleContainer(this.createBlockHolder(context), 2) { // Paper
+             @Override
+             public void setChanged() {
+                 super.setChanged();
+diff --git a/src/main/java/net/minecraft/world/inventory/ItemCombinerMenu.java b/src/main/java/net/minecraft/world/inventory/ItemCombinerMenu.java
+index ff770b9ce68a62418de0c7ed389650626fa1dcb2..c2cf5a8e788637c6264cf43d712a5be223ff1cc5 100644
+--- a/src/main/java/net/minecraft/world/inventory/ItemCombinerMenu.java
+++ b/src/main/java/net/minecraft/world/inventory/ItemCombinerMenu.java
+@@ -18,7 +18,7 @@ public abstract class ItemCombinerMenu extends AbstractContainerMenu {
+     protected final Player player;
+     protected final Container inputSlots;
+     private final List<Integer> inputSlotIndexes;
+-    protected final ResultContainer resultSlots = new ResultContainer();
+    protected final ResultContainer resultSlots; // Paper - delay field init
+     private final int resultSlotIndex;
+ 
+     protected abstract boolean mayPickup(Player player, boolean present);
+@@ -30,6 +30,7 @@ public abstract class ItemCombinerMenu extends AbstractContainerMenu {
+     public ItemCombinerMenu(@Nullable MenuType<?> type, int syncId, Inventory playerInventory, ContainerLevelAccess context) {
+         super(type, syncId);
+         this.access = context;
+        this.resultSlots = new ResultContainer(this.createBlockHolder(this.access)); // Paper - delay field init
+         this.player = playerInventory.player;
+         ItemCombinerMenuSlotDefinition itemcombinermenuslotdefinition = this.createInputSlotDefinitions();
+ 
+@@ -96,7 +97,7 @@ public abstract class ItemCombinerMenu extends AbstractContainerMenu {
+     protected abstract ItemCombinerMenuSlotDefinition createInputSlotDefinitions();
+ 
+     private SimpleContainer createContainer(int size) {
+-        return new SimpleContainer(size) {
+        return new SimpleContainer(this.createBlockHolder(this.access), size) { // Paper
+             @Override
+             public void setChanged() {
+                 super.setChanged();
+diff --git a/src/main/java/net/minecraft/world/inventory/LoomMenu.java b/src/main/java/net/minecraft/world/inventory/LoomMenu.java
+index e28c1cdf4763e9db3e29b3c0f08d65f978017931..146006af2af0881de199a0607a1b8f33de4c3f4f 100644
+--- a/src/main/java/net/minecraft/world/inventory/LoomMenu.java
+++ b/src/main/java/net/minecraft/world/inventory/LoomMenu.java
+@@ -73,7 +73,7 @@ public class LoomMenu extends AbstractContainerMenu {
+         this.selectablePatterns = List.of();
+         this.slotUpdateListener = () -> {
+         };
+-        this.inputContainer = new SimpleContainer(3) {
+        this.inputContainer = new SimpleContainer(this.createBlockHolder(context), 3) { // Paper
+             @Override
+             public void setChanged() {
+                 super.setChanged();
+@@ -88,7 +88,7 @@ public class LoomMenu extends AbstractContainerMenu {
+             }
+             // CraftBukkit end
+         };
+-        this.outputContainer = new SimpleContainer(1) {
+        this.outputContainer = new SimpleContainer(this.createBlockHolder(context), 1) { // Paper
+             @Override
+             public void setChanged() {
+                 super.setChanged();
+diff --git a/src/main/java/net/minecraft/world/inventory/ResultContainer.java b/src/main/java/net/minecraft/world/inventory/ResultContainer.java
+index d4592218d761eb38402e3d95c642e80a708cb333..3e268c4d93241fad72a366c8c8f477e650d5a3db 100644
+--- a/src/main/java/net/minecraft/world/inventory/ResultContainer.java
+++ b/src/main/java/net/minecraft/world/inventory/ResultContainer.java
+@@ -29,7 +29,12 @@ public class ResultContainer implements Container, RecipeCraftingHolder {
+     }
+ 
+     public org.bukkit.inventory.InventoryHolder getOwner() {
+-        return null; // Result slots don't get an owner
+        // Paper start
+        if (this.holder == null && this.holderCreator != null) {
+            this.holder = this.holderCreator.get();
+        }
+        return this.holder; // Result slots don't get an owner
+        // Paper end - yes they do
+     }
+ 
+     // Don't need a transaction; the InventoryCrafting keeps track of it for us
+@@ -53,6 +58,14 @@ public class ResultContainer implements Container, RecipeCraftingHolder {
+         return null;
+     }
+     // CraftBukkit end
+    // Paper start
+    private @Nullable java.util.function.Supplier<? extends org.bukkit.inventory.InventoryHolder> holderCreator;
+    private @Nullable org.bukkit.inventory.InventoryHolder holder;
+    public ResultContainer(java.util.function.Supplier<? extends org.bukkit.inventory.InventoryHolder> holderCreator) {
+        this();
+        this.holderCreator = holderCreator;
+    }
+    // Paper end
+ 
+     public ResultContainer() {
+         this.itemStacks = NonNullList.withSize(1, ItemStack.EMPTY);
+diff --git a/src/main/java/net/minecraft/world/inventory/StonecutterMenu.java b/src/main/java/net/minecraft/world/inventory/StonecutterMenu.java
+index aa1d1466d0a7b76967a41d948b7a4114fe06242f..f8129dcdcae12ed66ec58e8c749fa88ec3cd85d8 100644
+--- a/src/main/java/net/minecraft/world/inventory/StonecutterMenu.java
+++ b/src/main/java/net/minecraft/world/inventory/StonecutterMenu.java
+@@ -68,7 +68,7 @@ public class StonecutterMenu extends AbstractContainerMenu {
+         this.input = ItemStack.EMPTY;
+         this.slotUpdateListener = () -> {
+         };
+-        this.container = new SimpleContainer(1) {
+        this.container = new SimpleContainer(this.createBlockHolder(context), 1) { // Paper
+             @Override
+             public void setChanged() {
+                 super.setChanged();
+@@ -83,7 +83,7 @@ public class StonecutterMenu extends AbstractContainerMenu {
+             }
+             // CraftBukkit end
+         };
+-        this.resultContainer = new ResultContainer();
+        this.resultContainer = new ResultContainer(this.createBlockHolder(context)); // Paper
+         this.access = context;
+         this.level = playerInventory.player.level();
+         this.inputSlot = this.addSlot(new Slot(this.container, 0, 20, 33));
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftBlockInventoryHolder.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftBlockInventoryHolder.java
+index 7ae484b0fa5bf5494c6ead15f7f1c0fa840ae270..04585d2bc27dc8a165238ee9d2612e179b66fb63 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftBlockInventoryHolder.java
+++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftBlockInventoryHolder.java
+@@ -17,6 +17,13 @@ public class CraftBlockInventoryHolder implements BlockInventoryHolder {
+         this.block = CraftBlock.at(world, pos);
+         this.inventory = new CraftInventory(inv);
+     }
+    // Paper start
+    public CraftBlockInventoryHolder(net.minecraft.world.inventory.ContainerLevelAccess levelAccess, Inventory inventory) {
+        com.google.common.base.Preconditions.checkArgument(levelAccess.isBlock());
+        this.block = CraftBlock.at(levelAccess.getWorld(), levelAccess.getPosition());
+        this.inventory = inventory;
+    }
+    // Paper end
+ 
+     @Override
+     public Block getBlock() {
--- a/patches/server/1017-Do-not-read-tile-entities-in-chunks-that-are-positio.patch
+++ b/patches/server/1017-Do-not-read-tile-entities-in-chunks-that-are-positio.patch
@ -0,0 +1,50 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Spottedleaf <Spottedleaf@users.noreply.github.com>
+Date: Sun, 18 Jun 2023 23:04:46 -0700
+Subject: [PATCH] Do not read tile entities in chunks that are positioned
+ outside of the chunk
+
+The tile entities are not accessible and so should not be loaded.
+This can happen as a result of users moving regionfiles around,
+which would cause a crash on Folia but would appear to function
+fine on Paper.
+
+diff --git a/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java b/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java
+index e1ad2152bbd55435495bdad57a0984842e55fcb8..1379084a80ce25644f13736b4a5ee5fabbd9ec1f 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java
+++ b/src/main/java/net/minecraft/world/level/chunk/storage/ChunkSerializer.java
+@@ -381,6 +381,13 @@ public class ChunkSerializer {
+             for (int k1 = 0; k1 < nbttaglist3.size(); ++k1) {
+                 CompoundTag nbttagcompound4 = nbttaglist3.getCompound(k1);
+ 
+                // Paper start - do not read tile entities positioned outside the chunk
+                BlockPos blockposition = BlockEntity.getPosFromTag(nbttagcompound4);
+                if ((blockposition.getX() >> 4) != chunkPos.x || (blockposition.getZ() >> 4) != chunkPos.z) {
+                    LOGGER.warn("Tile entity serialized in chunk " + chunkPos + " in world '" + world.getWorld().getName() + "' positioned at " + blockposition + " is located outside of the chunk");
+                    continue;
+                }
+                // Paper end - do not read tile entities positioned outside the chunk
+                 ((ChunkAccess) object1).setBlockEntityNbt(nbttagcompound4);
+             }
+ 
+@@ -679,10 +686,19 @@ public class ChunkSerializer {
+                     CompoundTag nbttagcompound1 = nbttaglist1.getCompound(i);
+                     boolean flag = nbttagcompound1.getBoolean("keepPacked");
+ 
+                    // Paper start - do not read tile entities positioned outside the chunk
+                    BlockPos blockposition = BlockEntity.getPosFromTag(nbttagcompound1); //  moved up
+                    ChunkPos chunkPos = chunk.getPos();
+                    if ((blockposition.getX() >> 4) != chunkPos.x || (blockposition.getZ() >> 4) != chunkPos.z) {
+                        LOGGER.warn("Tile entity serialized in chunk " + chunkPos + " in world '" + world.getWorld().getName() + "' positioned at " + blockposition + " is located outside of the chunk");
+                        continue;
+                    }
+                    // Paper end - do not read tile entities positioned outside the chunk
+
+                     if (flag) {
+                         chunk.setBlockEntityNbt(nbttagcompound1);
+                     } else {
+-                        BlockPos blockposition = BlockEntity.getPosFromTag(nbttagcompound1);
+                        // Paper - do not read tile entities positioned outside the chunk - move up
+                         BlockEntity tileentity = BlockEntity.loadStatic(blockposition, chunk.getBlockState(blockposition), nbttagcompound1);
+ 
+                         if (tileentity != null) {