Patches, patches, patches

patches/server/0821-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 bc0f1aa61e68d2a8638d89c10bc5c71922d057f9..3cdcc4f44608d24550f2a8c6f3f5ce675d7777c5 100644
+--- a/src/main/java/net/minecraft/server/level/ServerEntity.java
++++ b/src/main/java/net/minecraft/server/level/ServerEntity.java
+@@ -116,7 +116,7 @@ public class ServerEntity {
+ 
+         Entity entity = this.entity;
+ 
+-        if (entity instanceof ItemFrame entityitemframe) {
++        if (!this.trackedPlayers.isEmpty() && entity instanceof ItemFrame entityitemframe) { // Paper - Perf: Only tick item frames if players can see it
+             if (true || this.tickCount % 10 == 0) { // CraftBukkit - Moved below, should always enter this block
+                 ItemStack itemstack = entityitemframe.getItem();
+ 

patches/server/0822-Fix-cmd-permission-levels-for-command-blocks.patch

@@ -0,0 +1,90 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Mon, 24 Jan 2022 15:32:02 -0800
+Subject: [PATCH] Fix cmd permission levels for command blocks
+
+
+diff --git a/src/main/java/net/minecraft/commands/CommandSourceStack.java b/src/main/java/net/minecraft/commands/CommandSourceStack.java
+index f31c5d665678c3163ed4469f8e9d395b890c1bbe..fc0c60b22844ed010aede2fa125b9fa440d3de80 100644
+--- a/src/main/java/net/minecraft/commands/CommandSourceStack.java
++++ b/src/main/java/net/minecraft/commands/CommandSourceStack.java
+@@ -206,10 +206,29 @@ public class CommandSourceStack implements ExecutionCommandSource<CommandSourceS
+         return this.permissionLevel >= level;
+     }
+ 
++    // Paper start - Fix permission levels for command blocks
++    private boolean forceRespectPermissionLevel() {
++        return this.source == CommandSource.NULL || (this.source instanceof final net.minecraft.world.level.BaseCommandBlock commandBlock && commandBlock.getLevel().paperConfig().commandBlocks.forceFollowPermLevel);
++    }
++    // Paper end - Fix permission levels for command blocks
++
+     // 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 - Fix permission levels for command blocks
++        final java.util.function.BooleanSupplier hasBukkitPerm = () -> this.source == CommandSource.NULL /*treat NULL as having all bukkit perms*/ || this.getBukkitSender().hasPermission(bukkitPermission); // lazily check bukkit perms to the benefit of custom permission setups
++        // if the server is null, we must check the vanilla perm level system
++        // if ignoreVanillaPermissions is true, we can skip vanilla perms and just run the bukkit perm check
++        //noinspection ConstantValue
++        if (this.getServer() == null || !this.getServer().server.ignoreVanillaPermissions) { // server & level are null for command function loading
++            final boolean hasPermLevel = this.permissionLevel >= i;
++            if (this.forceRespectPermissionLevel()) { // NULL CommandSource and command blocks (if setting is enabled) should always pass the vanilla perm check
++                return hasPermLevel && hasBukkitPerm.getAsBoolean();
++            } else { // otherwise check vanilla perm first then bukkit perm, matching upstream behavior
++                return hasPermLevel || hasBukkitPerm.getAsBoolean();
++            }
++        }
++        return hasBukkitPerm.getAsBoolean();
++        // Paper end - Fix permission levels for command blocks
+     }
+     // CraftBukkit end
+ 
+diff --git a/src/main/java/net/minecraft/commands/Commands.java b/src/main/java/net/minecraft/commands/Commands.java
+index fd12046fab797fd845ad8521f94147480dfba5da..fe9f638db3525893beed565ef9b7ac2fc76318bd 100644
+--- a/src/main/java/net/minecraft/commands/Commands.java
++++ b/src/main/java/net/minecraft/commands/Commands.java
+@@ -300,16 +300,7 @@ public class Commands {
+         String[] args = command.split(" ");
+         if (args.length == 0) return; // Paper - empty commands shall not be dispatched
+ 
+-        String cmd = args[0];
+-        if (cmd.startsWith("minecraft:")) cmd = cmd.substring("minecraft:".length());
+-        if (cmd.startsWith("bukkit:")) cmd = cmd.substring("bukkit:".length());
+-
+-        // Block disallowed commands
+-        if (cmd.equalsIgnoreCase("stop") || cmd.equalsIgnoreCase("kick") || cmd.equalsIgnoreCase("op")
+-                || cmd.equalsIgnoreCase("deop") || cmd.equalsIgnoreCase("ban") || cmd.equalsIgnoreCase("ban-ip")
+-                || cmd.equalsIgnoreCase("pardon") || cmd.equalsIgnoreCase("pardon-ip") || cmd.equalsIgnoreCase("reload")) {
+-            return;
+-        }
++        // Paper - Fix permission levels for command blocks
+ 
+         // Handle vanilla commands;
+         if (sender.getLevel().getCraftServer().getCommandBlockOverride(args[0])) {
+diff --git a/src/main/java/net/minecraft/world/entity/vehicle/MinecartCommandBlock.java b/src/main/java/net/minecraft/world/entity/vehicle/MinecartCommandBlock.java
+index d7321275cf963ba4fd838226c7f705ea0f2e1ac6..56bae8ea1e7b115e85a701209f3badbd29912b28 100644
+--- a/src/main/java/net/minecraft/world/entity/vehicle/MinecartCommandBlock.java
++++ b/src/main/java/net/minecraft/world/entity/vehicle/MinecartCommandBlock.java
+@@ -133,7 +133,7 @@ public class MinecartCommandBlock extends AbstractMinecart {
+ 
+         @Override
+         public CommandSourceStack createCommandSourceStack() {
+-            return new CommandSourceStack(this, MinecartCommandBlock.this.position(), MinecartCommandBlock.this.getRotationVector(), this.getLevel(), 2, this.getName().getString(), MinecartCommandBlock.this.getDisplayName(), this.getLevel().getServer(), MinecartCommandBlock.this);
++            return new CommandSourceStack(this, MinecartCommandBlock.this.position(), MinecartCommandBlock.this.getRotationVector(), this.getLevel(), this.getLevel().paperConfig().commandBlocks.permissionsLevel, this.getName().getString(), MinecartCommandBlock.this.getDisplayName(), this.getLevel().getServer(), MinecartCommandBlock.this); // Paper - configurable command block perm level
+         }
+ 
+         @Override
+diff --git a/src/main/java/net/minecraft/world/level/block/entity/CommandBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/CommandBlockEntity.java
+index faa0a3248217fb27dae5b918099f8a63eee6f586..a02c5feb8f2ffe6bb6070650a45762476e1ff9ac 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/CommandBlockEntity.java
++++ b/src/main/java/net/minecraft/world/level/block/entity/CommandBlockEntity.java
+@@ -58,7 +58,7 @@ public class CommandBlockEntity extends BlockEntity {
+         public CommandSourceStack createCommandSourceStack() {
+             Direction enumdirection = (Direction) CommandBlockEntity.this.getBlockState().getValue(CommandBlock.FACING);
+ 
+-            return new CommandSourceStack(this, Vec3.atCenterOf(CommandBlockEntity.this.worldPosition), new Vec2(0.0F, enumdirection.toYRot()), this.getLevel(), 2, this.getName().getString(), this.getName(), this.getLevel().getServer(), (Entity) null);
++            return new CommandSourceStack(this, Vec3.atCenterOf(CommandBlockEntity.this.worldPosition), new Vec2(0.0F, enumdirection.toYRot()), this.getLevel(), this.getLevel().paperConfig().commandBlocks.permissionsLevel, this.getName().getString(), this.getName(), this.getLevel().getServer(), (Entity) null); // Paper - configurable command block perm level
+         }
+ 
+         @Override

patches/server/0823-Add-option-to-disable-block-updates.patch

@@ -0,0 +1,179 @@
+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 bf2790fae091ab9d7f4ec4b2ab0f103190c31984..5d3ca961b325a39efcd6b398a27f9a4d300b35e5 100644
+--- a/src/main/java/net/minecraft/world/level/block/ChorusPlantBlock.java
++++ b/src/main/java/net/minecraft/world/level/block/ChorusPlantBlock.java
+@@ -38,6 +38,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());
+     }
+ 
+@@ -68,6 +69,7 @@ public class ChorusPlantBlock extends PipeBlock {
+         BlockState neighborState,
+         RandomSource random
+     ) {
++        if (io.papermc.paper.configuration.GlobalConfiguration.get().blockUpdates.disableChorusPlantUpdates) return state; // Paper - add option to disable block updates
+         if (!state.canSurvive(world, pos)) {
+             tickView.scheduleTick(pos, this, 1);
+             return super.updateShape(state, world, tickView, pos, direction, neighborPos, neighborState, random);
+@@ -79,6 +81,7 @@ public class ChorusPlantBlock extends PipeBlock {
+ 
+     @Override
+     protected 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);
+         }
+@@ -86,6 +89,7 @@ public class ChorusPlantBlock extends PipeBlock {
+ 
+     @Override
+     protected 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 0e0441646bd21a14a8bea576e5400ce937ebea01..437ad7051bad2d7dccc1a9ae764bdc5dcbe88612 100644
+--- a/src/main/java/net/minecraft/world/level/block/HugeMushroomBlock.java
++++ b/src/main/java/net/minecraft/world/level/block/HugeMushroomBlock.java
+@@ -45,6 +45,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()
+@@ -67,6 +68,7 @@ public class HugeMushroomBlock extends Block {
+         BlockState neighborState,
+         RandomSource random
+     ) {
++        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, world, tickView, pos, direction, neighborPos, neighborState, random);
+@@ -74,6 +76,7 @@ public class HugeMushroomBlock extends Block {
+ 
+     @Override
+     protected 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))
+@@ -84,6 +87,7 @@ public class HugeMushroomBlock extends Block {
+ 
+     @Override
+     protected 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))
+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 71fd7a467a4cb89cad8d2541366fd4add9115e04..6582db84c5307257f16c321453491cf24e40c9c7 100644
+--- a/src/main/java/net/minecraft/world/level/block/NoteBlock.java
++++ b/src/main/java/net/minecraft/world/level/block/NoteBlock.java
+@@ -68,11 +68,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
+     protected BlockState updateShape(BlockState state, LevelReader world, ScheduledTickAccess tickView, BlockPos pos, Direction direction, BlockPos neighborPos, BlockState neighborState, RandomSource random) {
++        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, world, tickView, pos, direction, neighborPos, neighborState, random);
+@@ -80,6 +82,7 @@ public class NoteBlock extends Block {
+ 
+     @Override
+     protected void neighborChanged(BlockState state, Level world, BlockPos pos, Block sourceBlock, @Nullable Orientation wireOrientation, 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)) {
+@@ -116,7 +119,7 @@ public class NoteBlock extends Block {
+     @Override
+     protected InteractionResult useWithoutItem(BlockState state, Level world, BlockPos pos, Player player, BlockHitResult hit) {
+         if (!world.isClientSide) {
+-            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 f079e5a9aa098225acf09ed9b4aa7ddbc2381270..74cce7874809dcbce2718ec3840bb6bb3127e871 100644
+--- a/src/main/java/net/minecraft/world/level/block/TripWireBlock.java
++++ b/src/main/java/net/minecraft/world/level/block/TripWireBlock.java
+@@ -68,6 +68,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();
+ 
+@@ -76,11 +77,13 @@ public class TripWireBlock extends Block {
+ 
+     @Override
+     protected BlockState updateShape(BlockState state, LevelReader world, ScheduledTickAccess tickView, BlockPos pos, Direction direction, BlockPos neighborPos, BlockState neighborState, RandomSource random) {
++        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, world, tickView, pos, direction, neighborPos, neighborState, random);
+     }
+ 
+     @Override
+     protected 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);
+         }
+@@ -88,6 +91,7 @@ public class TripWireBlock extends Block {
+ 
+     @Override
+     protected 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));
+         }
+@@ -95,6 +99,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, (Holder) GameEvent.SHEAR, pos);
+@@ -104,6 +109,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
+         Direction[] aenumdirection = new Direction[]{Direction.SOUTH, Direction.WEST};
+         int i = aenumdirection.length;
+         int j = 0;
+@@ -141,6 +147,7 @@ public class TripWireBlock extends Block {
+ 
+     @Override
+     protected 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 - Add EntityInsideBlockEvent
+         if (!world.isClientSide) {
+             if (!(Boolean) state.getValue(TripWireBlock.POWERED)) {
+@@ -151,6 +158,7 @@ public class TripWireBlock extends Block {
+ 
+     @Override
+     protected 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);
+         }

patches/server/0824-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 5793569ae8a088f21b0d8d6771a5099b1e88be09..f8f570a97789ab16e57774f233506a289277d5d9 100644
+--- a/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java
++++ b/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java
+@@ -768,6 +768,13 @@ public interface DispenseItemBehavior {
+                 this.setSuccess(true);
+                 if (iblockdata.is(Blocks.RESPAWN_ANCHOR)) {
+                     if ((Integer) iblockdata.getValue(RespawnAnchorBlock.CHARGE) != 4) {
++                        // Paper start - Call missing BlockDispenseEvent
++                        ItemStack result = org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockDispenseEvent(pointer, blockposition, stack, this);
++                        if (result != null) {
++                            this.setSuccess(false);
++                            return result;
++                        }
++                        // Paper end - Call missing BlockDispenseEvent
+                         RespawnAnchorBlock.charge((Entity) null, worldserver, blockposition, iblockdata);
+                         stack.shrink(1);
+                     } else {
+@@ -845,6 +852,13 @@ public interface DispenseItemBehavior {
+                 Optional<BlockState> optional = HoneycombItem.getWaxed(iblockdata);
+ 
+                 if (optional.isPresent()) {
++                    // Paper start - Call missing BlockDispenseEvent
++                    ItemStack result = org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockDispenseEvent(pointer, blockposition, stack, this);
++                    if (result != null) {
++                        this.setSuccess(false);
++                        return result;
++                    }
++                    // Paper end - Call missing BlockDispenseEvent
+                     worldserver.setBlockAndUpdate(blockposition, (BlockState) optional.get());
+                     worldserver.levelEvent(3003, blockposition, 0);
+                     stack.shrink(1);
+@@ -872,6 +886,12 @@ public interface DispenseItemBehavior {
+                     if (!worldserver.getBlockState(blockposition1).is(BlockTags.CONVERTABLE_TO_MUD)) {
+                         return this.defaultDispenseItemBehavior.dispense(pointer, stack);
+                     } else {
++                        // Paper start - Call missing BlockDispenseEvent
++                        ItemStack result = org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockDispenseEvent(pointer, blockposition1, stack, this);
++                        if (result != null) {
++                            return result;
++                        }
++                        // Paper end - Call missing BlockDispenseEvent
+                         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 ac25a5c933b8748ca44ca02100058992b1aad358..22244f38bfee746f14c969de05bc028c934c6d6b 100644
+--- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
++++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+@@ -2196,6 +2196,32 @@ populateFields(victim, event); // Paper - make cancellable
+     }
+     // Paper end
+ 
++    // Paper start - Call missing BlockDispenseEvent
++    @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 = CraftBlock.at(pointer.level(), pointer.pos());
++        CraftItemStack craftItem = CraftItemStack.asCraftMirror(itemStack.copyWithCount(1));
++
++        org.bukkit.event.block.BlockDispenseEvent event = new org.bukkit.event.block.BlockDispenseEvent(bukkitBlock, craftItem.clone(), CraftVector.toBukkit(to));
++        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 itemBehavior = net.minecraft.world.level.block.DispenserBlock.DISPENSER_REGISTRY.get(eventStack.getItem());
++            if (itemBehavior != net.minecraft.core.dispenser.DispenseItemBehavior.NOOP && itemBehavior != instance) {
++                itemBehavior.dispense(pointer, eventStack);
++                return itemStack;
++            }
++        }
++        return null;
++    }
++    // Paper end - Call missing BlockDispenseEvent
++
+     // Paper start - add EntityFertilizeEggEvent
+     /**
+      * Calls the {@link io.papermc.paper.event.entity.EntityFertilizeEggEvent}.

patches/server/0825-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 8cdef637f6343119fc77f87e7478ee23e9b8efab..3ef1352030bf1d6f4d2053158caea852552e91a7 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
++++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -1228,7 +1228,7 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+     }
+ 
+     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) {

patches/server/0826-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 2a7d896dd9a02acf6e3596e2e2e7ed50f4b88377..0e0d178f2793ab014358f534c8dc53218b89f083 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
+@@ -333,7 +333,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 - Perf: 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 - Perf: optimize player lookup for beacons
+ 
+             return list;
+         }

patches/server/0827-More-Sign-Block-API.patch

@@ -0,0 +1,62 @@
+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] More Sign Block API
+
+Co-authored-by: SoSeDiK <mrsosedik@gmail.com>
+
+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 a34c2fc6ac1418a89d789b8945ca3dad57f64151..8ac19e1e052e73ff3fd09089bb8e3fd687390ee4 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
+@@ -68,12 +68,17 @@ public class SignBlockEntity extends BlockEntity {
+     }
+ 
+     public boolean isFacingFrontText(net.minecraft.world.entity.player.Player player) {
++        // Paper start - More Sign Block API
++        return this.isFacingFrontText(player.getX(), player.getZ());
++    }
++    public boolean isFacingFrontText(double x, double z) {
++        // Paper end - More Sign Block API
+         Block block = this.getBlockState().getBlock();
+ 
+         if (block instanceof SignBlock blocksign) {
+             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 - More Sign Block API
++            double d1 = z - ((double) this.getBlockPos().getZ() + vec3d.z); // Paper - More Sign Block API
+             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 8303343ecca91076839f4436d6b3a3bf4739c2fd..e3c333d26dea9af9dd51e1662f81f1d472ab0233 100644
+--- a/src/main/java/org/bukkit/craftbukkit/block/CraftSign.java
++++ b/src/main/java/org/bukkit/craftbukkit/block/CraftSign.java
+@@ -198,6 +198,26 @@ public class CraftSign<T extends SignBlockEntity> extends CraftBlockEntityState<
+     }
+     // Paper end
+ 
++    // Paper start - More Sign Block API
++    @Override
++    public java.util.UUID getAllowedEditorUniqueId() {
++        this.ensureNoWorldGeneration();
++        return this.getTileEntity().getPlayerWhoMayEdit();
++    }
++
++    @Override
++    public void setAllowedEditorUniqueId(java.util.UUID uuid) {
++        this.ensureNoWorldGeneration();
++        this.getTileEntity().setAllowedPlayerEditor(uuid);
++    }
++
++    @Override
++    public Side getInteractableSideFor(final double x, final double z) {
++        this.requirePlaced();
++        return this.getSnapshot().isFacingFrontText(x, z) ? Side.FRONT : Side.BACK;
++    }
++    // Paper end - More Sign Block API
++
+     public static Component[] sanitizeLines(String[] lines) {
+         Component[] components = new Component[4];
+ 

patches/server/0828-fix-item-meta-for-tadpole-buckets.patch

@@ -0,0 +1,63 @@
+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/CraftItemMetas.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemMetas.java
+index 4f5568707d725195ee19b65274454fec8bf99d64..d29f4dd9808e2001c79535d663ca77d6840f6092 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemMetas.java
++++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemMetas.java
+@@ -265,7 +265,7 @@ public final class CraftItemMetas {
+         if (itemType == ItemType.SUSPICIOUS_STEW) {
+             return CraftItemMetas.asType(CraftItemMetas.SUSPICIOUS_STEW_META_DATA);
+         }
+-        if (itemType == ItemType.COD_BUCKET || itemType == ItemType.PUFFERFISH_BUCKET
++        if (itemType == ItemType.COD_BUCKET || itemType == ItemType.PUFFERFISH_BUCKET || itemType == ItemType.TADPOLE_BUCKET // Paper
+                 || itemType == ItemType.SALMON_BUCKET || itemType == ItemType.ITEM_FRAME
+                 || itemType == ItemType.GLOW_ITEM_FRAME || itemType == ItemType.PAINTING) {
+             return CraftItemMetas.asType(CraftItemMetas.ENTITY_TAG_META_DATA);
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaEntityTag.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaEntityTag.java
+index 27af7ca9d62bdb4a24be5af139c181d7bc271ba5..3ff0340c40e9dc9a6e690de15ccade7a0c4e8f02 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaEntityTag.java
++++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftMetaEntityTag.java
+@@ -19,6 +19,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 50faaaa48dffcaf53823caed1e3f7263cd5c441f..ba5c958f322dc34baff3c9d1b99741a4ffeee135 100644
+--- a/src/test/java/org/bukkit/craftbukkit/inventory/ItemMetaTest.java
++++ b/src/test/java/org/bukkit/craftbukkit/inventory/ItemMetaTest.java
+@@ -209,6 +209,27 @@ public class ItemMetaTest {
+         }
+     }
+ 
++    // 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(CraftItemType.minecraftToBukkit(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(CraftItemType.minecraftToBukkit(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(

patches/server/0829-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 30c1c203022c2ed777dcddfd68ef2e3752c62ea1..2c2c4db31a746b4eb853dc04c6b3e5631bbfa034 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftOfflinePlayer.java
++++ b/src/main/java/org/bukkit/craftbukkit/CraftOfflinePlayer.java
+@@ -115,17 +115,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 cdc53abb5572fa57b4ec98a694c5583ad0982a05..79e35265978357eeb27c43205433d6b24335f401 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -1760,23 +1760,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);
+         }
+@@ -1784,12 +1784,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 d9cc76d7e60001957c0f59fdc32d016f3589aa08..f58dec12326734c61f4bc2298a87fb38f1ac1dc4 100644
+--- a/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerProfile.java
++++ b/src/main/java/org/bukkit/craftbukkit/profile/CraftPlayerProfile.java
+@@ -31,7 +31,7 @@ import org.bukkit.profile.PlayerTextures;
+ import org.jetbrains.annotations.ApiStatus;
+ 
+ @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) {
+@@ -162,7 +162,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 - don't submit BLOCKING PROFILE LOOKUPS to the world gen thread
+     }
+ 
+@@ -321,4 +321,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");
++    }
+ }

patches/server/0830-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 a27ceed2cac6c16eb4e5f2959db9e482e67e9de6..884db3e64cb22ed765beec8f11ea309fcf810207 100644
+--- a/src/main/java/net/minecraft/world/level/material/LavaFluid.java
++++ b/src/main/java/net/minecraft/world/level/material/LavaFluid.java
+@@ -233,7 +233,7 @@ public abstract class LavaFluid extends FlowingFluid {
+ 
+     @Override
+     protected float getExplosionResistance() {
+-        return 100.0F;
++        return Blocks.LAVA.getExplosionResistance(); // Paper - Get explosion resistance from actual block
+     }
+ 
+     @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 0a7c05c08bf8c6c331b91e399dc4103a91dc20fe..552925ba47c7475e2e1ec2ded0966f28ed3e50a5 100644
+--- a/src/main/java/net/minecraft/world/level/material/WaterFluid.java
++++ b/src/main/java/net/minecraft/world/level/material/WaterFluid.java
+@@ -126,7 +126,7 @@ public abstract class WaterFluid extends FlowingFluid {
+ 
+     @Override
+     protected float getExplosionResistance() {
+-        return 100.0F;
++        return Blocks.WATER.getExplosionResistance(); // Paper - Get explosion resistance from actual block
+     }
+ 
+     @Override

patches/server/0831-Fix-possible-NPE-on-painting-creation.patch

@@ -0,0 +1,34 @@
+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/entity/CraftEntityTypes.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntityTypes.java
+index 39ea25d2145acaa7c7b458800adc674a3e73e7c1..8715d8e790b6735610e2f880f8c1f88a89967f21 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntityTypes.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntityTypes.java
+@@ -361,8 +361,13 @@ public final class CraftEntityTypes {
+         // Hanging
+         register(new EntityTypeData<>(EntityType.PAINTING, Painting.class, CraftPainting::new, createHanging(Painting.class, (spawnData, hangingData) -> {
+                     if (spawnData.normalWorld && hangingData.randomize()) {
+-                        return net.minecraft.world.entity.decoration.Painting.create(spawnData.minecraftWorld(), hangingData.position(), hangingData.direction()).orElse(null);
+-                    } else {
++                        // Paper start - if randomizeData fails, force it
++                        final net.minecraft.world.entity.decoration.Painting entity = net.minecraft.world.entity.decoration.Painting.create(spawnData.minecraftWorld(), hangingData.position(), hangingData.direction()).orElse(null);
++                        if (entity != null) {
++                            return entity;
++                        }
++                    } /*else*/ {
++                        // Paper end - if randomizeData fails, force it
+                         net.minecraft.world.entity.decoration.Painting entity = new net.minecraft.world.entity.decoration.Painting(net.minecraft.world.entity.EntityType.PAINTING, spawnData.minecraftWorld());
+                         entity.absMoveTo(spawnData.x(), spawnData.y(), spawnData.z(), spawnData.yaw(), spawnData.pitch());
+                         entity.setDirection(hangingData.direction());
+@@ -523,6 +528,7 @@ public final class CraftEntityTypes {
+                     AABB bb = (ItemFrame.class.isAssignableFrom(clazz))
+                             ? net.minecraft.world.entity.decoration.ItemFrame.calculateBoundingBoxStatic(pos, CraftBlock.blockFaceToNotch(dir).getOpposite())
+                             : net.minecraft.world.entity.decoration.Painting.calculateBoundingBoxStatic(pos, CraftBlock.blockFaceToNotch(dir).getOpposite(), width, height);
++                    if (!spawnData.world.noCollision(bb)) continue; // Paper - add collision check
+                     List<net.minecraft.world.entity.Entity> list = spawnData.world().getEntities(null, bb);
+                     for (Iterator<net.minecraft.world.entity.Entity> it = list.iterator(); !taken && it.hasNext(); ) {
+                         net.minecraft.world.entity.Entity e = it.next();

patches/server/0832-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 a65fba5621c067c453858efb7fee64cbee1e7916..1e77cce428d9e53142aaa2cf780b7f862d536eca 100644
+--- a/src/main/java/net/minecraft/world/entity/npc/WanderingTrader.java
++++ b/src/main/java/net/minecraft/world/entity/npc/WanderingTrader.java
+@@ -69,7 +69,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 08a3c7140867f339dd99a95094ed0fd8ff344fca..9d206bed5b982603f39bc1f70ae23ea38e4d9bc9 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, EntitySpawnReason.EVENT, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.NATURAL); // CraftBukkit
++                WanderingTrader entityvillagertrader = (WanderingTrader) EntityType.WANDERING_TRADER.spawn(world, trader -> trader.setDespawnDelay(48000), blockposition2, EntitySpawnReason.EVENT, false, false, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.NATURAL); // CraftBu // Paper - set despawnTimer before spawn events calledkkit
+ 
+                 if (entityvillagertrader != null) {
+                     for (int i = 0; i < 2; ++i) {

patches/server/0833-ExperienceOrb-should-call-EntitySpawnEvent.patch

@@ -0,0 +1,20 @@
+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 22244f38bfee746f14c969de05bc028c934c6d6b..03afabc3ab4b264f84698627b79e58f502a8cea9 100644
+--- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
++++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+@@ -744,7 +744,8 @@ 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) {
++            event = CraftEventFactory.callEntitySpawnEvent(entity); // Call spawn event for ExperienceOrb entities
++            if (radius > 0 && !event.isCancelled() && !entity.isRemoved()) {
+                 // Paper start - Maximum exp value when merging; Whole section has been tweaked, see comments for specifics
+                 final long maxValue = world.paperConfig().entities.behavior.experienceMergeMaxValue;
+                 final boolean mergeUnconditionally = maxValue <= 0;

patches/server/0834-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 6c402bfd9bed54cbb9b337d3528fdcffbd3d87c0..8920855b07a31715327b8102c7faafc9f916825d 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 - Have Amethyst throw both spread and grow events
+             }
+ 
+         }

patches/server/0835-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 3226a3b69453fb5e13003e941ccbc2d941e047b0..aaa3d5769e0e184e19d01109a76a65be634f830d 100644
+--- a/src/main/java/net/minecraft/server/players/UserWhiteList.java
++++ b/src/main/java/net/minecraft/server/players/UserWhiteList.java
+@@ -28,4 +28,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 - Add whitelist events
+ }

patches/server/0836-Implement-PlayerFailMoveEvent.patch

@@ -0,0 +1,111 @@
+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 5d261106b0cd12e9ed737833b1f6d2572d15ab4e..618c620b4bca535c454691f9a87c9b36a36021e2 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
++++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -1263,8 +1263,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; // Paper - OBFHELPER
+                     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);
+@@ -1331,8 +1331,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())))) {
+-                                    this.internalTeleport(PositionMoveRotation.of(this.player), Collections.emptySet());
+-                                    return;
++                                    // 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(PositionMoveRotation.of(this.player), Collections.emptySet());
++                                        return;
++                                    }
++                                    // Paper end - Add fail move event
+                                 }
+                                 // Paper end - Prevent moving into unloaded chunks
+ 
+@@ -1341,9 +1347,16 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+ 
+                                     if (d10 - d9 > Math.max(f2, Math.pow((double) (org.spigotmc.SpigotConfig.movedTooQuicklyMultiplier * (float) i * speed), 2))) {
+                                     // CraftBukkit end
+-                                        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 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 - Add fail move event
+                                     }
+                                 }
+                             }
+@@ -1405,14 +1418,31 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+ 
+                             d8 = d2 - this.player.getZ();
+                             d10 = d6 * d6 + d7 * d7 + d8 * d8;
+-                            boolean flag3 = false;
++                            boolean movedWrongly = false; // Paper - Add fail move event; rename
+ 
+                             if (!this.player.isChangingDimension() && d10 > org.spigotmc.SpigotConfig.movedWronglyThreshold && !this.player.isSleeping() && !this.player.gameMode.isCreative() && this.player.gameMode.getGameModeForPlayer() != GameType.SPECTATOR) { // Spigot
+-                                flag3 = true;
++                                // 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()) {
++                                    movedWrongly = true;
++                                    if (event.getLogWarning())
++                                // Paper end
+                                 ServerGamePacketListenerImpl.LOGGER.warn("{} moved wrongly!", this.player.getName().getString());
++                                } // Paper
+                             }
+ 
+-                            if (!this.player.noPhysics && !this.player.isSleeping() && (flag3 && worldserver.noCollision(this.player, axisalignedbb) || this.isPlayerCollidingWithAnythingNew(worldserver, axisalignedbb, d0, d1, d2))) {
++                            // Paper start - Add fail move event
++                            boolean teleportBack = !this.player.noPhysics && !this.player.isSleeping() && (movedWrongly && worldserver.noCollision(this.player, axisalignedbb) || this.isPlayerCollidingWithAnythingNew(worldserver, axisalignedbb, d0, d1, d2));
++                            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;
++                                }
++                            }
++                            if (teleportBack) {
++                            // Paper end - Add fail move event
+                                 this.internalTeleport(d3, d4, d5, f, f1); // CraftBukkit - SPIGOT-1807: Don't call teleport event, when the client thinks the player is falling, because the chunks are not loaded on the client yet.
+                                 this.player.doCheckFallDamage(this.player.getX() - d3, this.player.getY() - d4, this.player.getZ() - d5, packet.isOnGround());
+                             } else {
+@@ -3529,4 +3559,17 @@ public class ServerGamePacketListenerImpl extends ServerCommonPacketListenerImpl
+ 
+         InteractionResult run(ServerPlayer player, Entity entity, InteractionHand hand);
+     }
++
++    // 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 - Add fail move event
+ }

patches/server/0838-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 07db92870f9efd515751453569f0dd7b6fada8fc..7d814e5b4b634674995d55ab97155f949f14ef3b 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();

patches/server/0839-Fix-rotation-when-spawning-display-entities.patch

@@ -0,0 +1,32 @@
+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/entity/CraftEntityTypes.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntityTypes.java
+index 8715d8e790b6735610e2f880f8c1f88a89967f21..6cf57640b3bd2bb0417129256ed77d9d67fcf04a 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntityTypes.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntityTypes.java
+@@ -254,6 +254,7 @@ public final class CraftEntityTypes {
+         Vector direction = spawnData.location().getDirection();
+         entity.assignDirectionalMovement(new Vec3(direction.getX(), direction.getY(), direction.getZ()), 1.0);
+     };
++    private static final BiConsumer<SpawnData, net.minecraft.world.entity.Entity> ROT = (spawnData, entity) -> entity.setRot(spawnData.yaw(), spawnData.pitch()); // Paper
+     private static final Map<Class<?>, EntityTypeData<?, ?>> CLASS_TYPE_DATA = new HashMap<>();
+     private static final Map<EntityType, EntityTypeData<?, ?>> ENTITY_TYPE_DATA = new HashMap<>();
+ 
+@@ -415,10 +416,10 @@ public final class CraftEntityTypes {
+ 
+         // Set pos
+         register(new EntityTypeData<>(EntityType.MARKER, Marker.class, CraftMarker::new, createAndSetPos(net.minecraft.world.entity.EntityType.MARKER)));
+-        register(new EntityTypeData<>(EntityType.BLOCK_DISPLAY, BlockDisplay.class, CraftBlockDisplay::new, createAndSetPos(net.minecraft.world.entity.EntityType.BLOCK_DISPLAY)));
++        register(new EntityTypeData<>(EntityType.BLOCK_DISPLAY, BlockDisplay.class, CraftBlockDisplay::new, combine(createAndSetPos(net.minecraft.world.entity.EntityType.BLOCK_DISPLAY), ROT))); // Paper
+         register(new EntityTypeData<>(EntityType.INTERACTION, Interaction.class, CraftInteraction::new, createAndSetPos(net.minecraft.world.entity.EntityType.INTERACTION)));
+-        register(new EntityTypeData<>(EntityType.ITEM_DISPLAY, ItemDisplay.class, CraftItemDisplay::new, createAndSetPos(net.minecraft.world.entity.EntityType.ITEM_DISPLAY)));
+-        register(new EntityTypeData<>(EntityType.TEXT_DISPLAY, TextDisplay.class, CraftTextDisplay::new, createAndSetPos(net.minecraft.world.entity.EntityType.TEXT_DISPLAY)));
++        register(new EntityTypeData<>(EntityType.ITEM_DISPLAY, ItemDisplay.class, CraftItemDisplay::new, combine(createAndSetPos(net.minecraft.world.entity.EntityType.ITEM_DISPLAY), ROT))); // Paper
++        register(new EntityTypeData<>(EntityType.TEXT_DISPLAY, TextDisplay.class, CraftTextDisplay::new, combine(createAndSetPos(net.minecraft.world.entity.EntityType.TEXT_DISPLAY), ROT))); // Paper
+ 
+         // MISC
+         register(new EntityTypeData<>(EntityType.ITEM, Item.class, CraftItem::new, spawnData -> {

patches/server/0840-Only-capture-actual-tree-growth.patch

@@ -0,0 +1,75 @@
+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 f8f570a97789ab16e57774f233506a289277d5d9..18304349c9ab24657c4152aff800dba969174665 100644
+--- a/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java
++++ b/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java
+@@ -550,6 +550,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/server/level/ServerLevel.java b/src/main/java/net/minecraft/server/level/ServerLevel.java
+index 509a67aff07bcdcad47eb77e923d442349a4f20c..1cb5e107a391ab56942cdb2d1cae7d5646a85ec6 100644
+--- a/src/main/java/net/minecraft/server/level/ServerLevel.java
++++ b/src/main/java/net/minecraft/server/level/ServerLevel.java
+@@ -2228,6 +2228,16 @@ public class ServerLevel extends Level implements ServerEntityGetter, WorldGenLe
+         return range <= 0 ? 64.0 * 64.0 : range * range; // 64 is taken from default in ServerLevel#levelEvent
+     }
+     // Paper end - respect global sound events gamerule
++    // Paper start - notify observers even if grow failed
++    public void checkCapturedTreeStateForObserverNotify(final BlockPos pos, final org.bukkit.craftbukkit.block.CraftBlockState craftBlockState) {
++        // 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);
++        }
++    }
++    // Paper end - notify observers even if grow failed
+ 
+     @Override
+     public CrashReportCategory fillReportDetails(CrashReport report) {
+diff --git a/src/main/java/net/minecraft/world/item/ItemStack.java b/src/main/java/net/minecraft/world/item/ItemStack.java
+index 612eb27b471a9ebfdea29a58e5a32931f869bfb6..db971851a9e219ead89d71bb97d65ff73d9fd285 100644
+--- a/src/main/java/net/minecraft/world/item/ItemStack.java
++++ b/src/main/java/net/minecraft/world/item/ItemStack.java
+@@ -469,6 +469,7 @@ public final class ItemStack implements DataComponentHolder {
+                     for (CraftBlockState blockstate : blocks) {
+                         // SPIGOT-7572 - Move fix for SPIGOT-7248 to CapturedBlockState, to allow bees in bee nest
+                         CapturedBlockState.setBlockState(blockstate);
++                        world.checkCapturedTreeStateForObserverNotify(blockposition, blockstate); // Paper - notify observers even if grow failed
+                     }
+                     entityhuman.awardStat(Stats.ITEM_USED.get(item)); // SPIGOT-7236 - award stat
+                 }
+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 2d7290ace5fc8890325a8ec623075ad32f9b1d44..d262a5a6da57ef9ba9a6fe0dfbc88f577105e74f 100644
+--- a/src/main/java/net/minecraft/world/level/block/SaplingBlock.java
++++ b/src/main/java/net/minecraft/world/level/block/SaplingBlock.java
+@@ -86,6 +86,7 @@ public class SaplingBlock extends BushBlock implements BonemealableBlock {
+                     if (event == null || !event.isCancelled()) {
+                         for (BlockState blockstate : blocks) {
+                             CapturedBlockState.setBlockState(blockstate);
++                            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 490a4f023491aaabd3966cb67901335c2b02bb52..a34e888f63ead250c41b6bbe6850a5e5b4254c3d 100644
+--- a/src/main/java/org/bukkit/craftbukkit/block/CraftBlock.java
++++ b/src/main/java/org/bukkit/craftbukkit/block/CraftBlock.java
+@@ -572,6 +572,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
+                 }
+             }
+         }

patches/server/0841-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 61fb134686c7cd538ae2f8fefe78fd9618a9990b..7900856c9e86afe907c00c9ac31bec93ece50abe 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 - Use correct source for mushroom block spread event
+ 
+             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 - Use correct source for mushroom block spread event
+             }
+         }
+ 

patches/server/0842-Respect-randomizeData-on-more-entities-when-spawning.patch

@@ -0,0 +1,68 @@
+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/entity/CraftEntityTypes.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntityTypes.java
+index 6cf57640b3bd2bb0417129256ed77d9d67fcf04a..3b5277f90b5bba30d40d79ba67903a8d04d2c0df 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntityTypes.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntityTypes.java
+@@ -255,6 +255,13 @@ public final class CraftEntityTypes {
+         entity.assignDirectionalMovement(new Vec3(direction.getX(), direction.getY(), direction.getZ()), 1.0);
+     };
+     private static final BiConsumer<SpawnData, net.minecraft.world.entity.Entity> ROT = (spawnData, entity) -> entity.setRot(spawnData.yaw(), spawnData.pitch()); // Paper
++    // Paper start - respect randomizeData
++    private static final BiConsumer<SpawnData, net.minecraft.world.entity.Entity> CLEAR_MOVE_IF_NOT_RANDOMIZED = (spawnData, entity) -> {
++        if (!spawnData.randomizeData()) {
++            entity.setDeltaMovement(net.minecraft.world.phys.Vec3.ZERO);
++        }
++    };
++    // Paper end - respect randomizeData
+     private static final Map<Class<?>, EntityTypeData<?, ?>> CLASS_TYPE_DATA = new HashMap<>();
+     private static final Map<EntityType, EntityTypeData<?, ?>> ENTITY_TYPE_DATA = new HashMap<>();
+ 
+@@ -428,11 +435,12 @@ public final class CraftEntityTypes {
+             net.minecraft.world.item.ItemStack itemStack = new net.minecraft.world.item.ItemStack(Items.STONE);
+             ItemEntity item = new ItemEntity(spawnData.minecraftWorld(), spawnData.x(), spawnData.y(), spawnData.z(), itemStack);
+             item.setPickUpDelay(10);
++            CLEAR_MOVE_IF_NOT_RANDOMIZED.accept(spawnData, item); // Paper - respect randomizeData
+ 
+             return item;
+         }));
+         register(new EntityTypeData<>(EntityType.EXPERIENCE_ORB, ExperienceOrb.class, CraftExperienceOrb::new,
+-                spawnData -> new net.minecraft.world.entity.ExperienceOrb(spawnData.minecraftWorld(), spawnData.x(), spawnData.y(), spawnData.z(), 0, org.bukkit.entity.ExperienceOrb.SpawnReason.CUSTOM, null, null) // Paper
++                combine(combine(spawnData -> new net.minecraft.world.entity.ExperienceOrb(spawnData.minecraftWorld(), spawnData.x(), spawnData.y(), spawnData.z(), 0, org.bukkit.entity.ExperienceOrb.SpawnReason.CUSTOM, null, null), CLEAR_MOVE_IF_NOT_RANDOMIZED), (spawnData, experienceOrb) -> { if (!spawnData.randomizeData()) { experienceOrb.setYRot(0); } }) // Paper - respect randomizeData
+         ));
+         register(new EntityTypeData<>(EntityType.AREA_EFFECT_CLOUD, AreaEffectCloud.class, CraftAreaEffectCloud::new, createAndMove(net.minecraft.world.entity.EntityType.AREA_EFFECT_CLOUD))); // Paper - set area effect cloud rotation
+         register(new EntityTypeData<>(EntityType.EGG, Egg.class, CraftEgg::new, spawnData -> new ThrownEgg(spawnData.minecraftWorld(), spawnData.x(), spawnData.y(), spawnData.z(), new net.minecraft.world.item.ItemStack(Items.EGG))));
+@@ -443,12 +451,23 @@ public final class CraftEntityTypes {
+             net.minecraft.world.entity.projectile.ThrownPotion entity = new net.minecraft.world.entity.projectile.ThrownPotion(spawnData.minecraftWorld(), spawnData.x(), spawnData.y(), spawnData.z(), new net.minecraft.world.item.ItemStack(Items.SPLASH_POTION));
+             return entity;
+         }));
+-        register(new EntityTypeData<>(EntityType.TNT, TNTPrimed.class, CraftTNTPrimed::new, spawnData -> new PrimedTnt(spawnData.minecraftWorld(), spawnData.x(), spawnData.y(), spawnData.z(), null)));
++        register(new EntityTypeData<>(EntityType.TNT, TNTPrimed.class, CraftTNTPrimed::new, combine(spawnData -> new PrimedTnt(spawnData.minecraftWorld(), spawnData.x(), spawnData.y(), spawnData.z(), null), CLEAR_MOVE_IF_NOT_RANDOMIZED))); // Paper - respect randomizeData
+         register(new EntityTypeData<>(EntityType.FALLING_BLOCK, FallingBlock.class, CraftFallingBlock::new, spawnData -> {
+             BlockPos pos = BlockPos.containing(spawnData.x(), spawnData.y(), spawnData.z());
+             return new FallingBlockEntity(spawnData.minecraftWorld(), spawnData.x(), spawnData.y(), spawnData.z(), spawnData.world().getBlockState(pos)); // Paper - create falling block entities correctly
+         }));
+-        register(new EntityTypeData<>(EntityType.FIREWORK_ROCKET, Firework.class, CraftFirework::new, spawnData -> new FireworkRocketEntity(spawnData.minecraftWorld(), spawnData.x(), spawnData.y(), spawnData.z(), FireworkRocketEntity.getDefaultItem()))); // Paper - pass correct default to rocket for data storage
++        // Paper start - respect randomizeData
++        register(new EntityTypeData<>(EntityType.FIREWORK_ROCKET, Firework.class, CraftFirework::new, spawnData -> {
++            FireworkRocketEntity entity = new FireworkRocketEntity(spawnData.minecraftWorld(), spawnData.x(), spawnData.y(), spawnData.z(), FireworkRocketEntity.getDefaultItem()); // Paper - pass correct default to rocket for data storage
++            if (!spawnData.randomizeData()) {
++                // logic below was taken from FireworkRocketEntity constructor
++                entity.setDeltaMovement(0, 0.05, 0);
++                //noinspection PointlessArithmeticExpression
++                entity.lifetime = 10 * 1 + 6;
++            }
++            return entity;
++        }));
++        // Paper end - respect randomizeData
+         register(new EntityTypeData<>(EntityType.EVOKER_FANGS, EvokerFangs.class, CraftEvokerFangs::new, spawnData -> new net.minecraft.world.entity.projectile.EvokerFangs(spawnData.minecraftWorld(), spawnData.x(), spawnData.y(), spawnData.z(), (float) Math.toRadians(spawnData.yaw()), 0, null)));
+         register(new EntityTypeData<>(EntityType.COMMAND_BLOCK_MINECART, CommandMinecart.class, CraftMinecartCommand::new, createMinecart(net.minecraft.world.entity.EntityType.COMMAND_BLOCK_MINECART)));
+         register(new EntityTypeData<>(EntityType.MINECART, RideableMinecart.class, CraftMinecartRideable::new, createMinecart(net.minecraft.world.entity.EntityType.MINECART)));

patches/server/0843-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 b5da166e147bff2ded9d295b1bf84cf71a3e7b8d..6bafb10ddbb1a4a73370b8cefac79e61d0c35ffc 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
++++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -1389,7 +1389,7 @@ public final class CraftServer implements Server {
+             net.minecraft.server.Main.forceUpgrade(worldSession, DataFixers.getDataFixer(), this.console.options.has("eraseCache"), () -> true, iregistrycustom_dimension, this.console.options.has("recreateRegionFiles"));
+         }
+ 
+-        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.getValue(actualDimension);
+ 

patches/server/0844-Remove-UpgradeData-neighbour-ticks-outside-of-range.patch

@@ -0,0 +1,50 @@
+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 5c7c8fb3c67047ddc1b92f03e889839b5a303ff4..ce3d79ebc7f933d0b34b3f8f71bbec872076847a 100644
+--- a/src/main/java/net/minecraft/world/level/chunk/UpgradeData.java
++++ b/src/main/java/net/minecraft/world/level/chunk/UpgradeData.java
+@@ -113,6 +113,25 @@ public class UpgradeData {
+         }
+     }
+ 
++    // Paper start - filter out relocated neighbour ticks
++    // The lists are only supposed to contain ticks for the 1 radius neighbours of the chunk
++    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);
+ 
+@@ -120,6 +139,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();

patches/server/0845-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 3cdcc4f44608d24550f2a8c6f3f5ce675d7777c5..7118e1f806af98159ec292f9340d7e4004e2b486 100644
+--- a/src/main/java/net/minecraft/server/level/ServerEntity.java
++++ b/src/main/java/net/minecraft/server/level/ServerEntity.java
+@@ -121,7 +121,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
+-                    MapId mapid = (MapId) itemstack.get(DataComponents.MAP_ID);
++                    MapId mapid = entityitemframe.cachedMapId; // Paper - Perf: Cache map ids on item frames
+                     MapItemSavedData worldmap = MapItem.getSavedData(mapid, 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 07c143c3eac263848fc5daf6f958d16a1a163e92..f046a866215fea7df10963af1a235ba9d04d4242 100644
+--- a/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java
++++ b/src/main/java/net/minecraft/world/entity/decoration/ItemFrame.java
+@@ -51,6 +51,7 @@ public class ItemFrame extends HangingEntity {
+     private static final float HEIGHT = 0.75F;
+     public float dropChance;
+     public boolean fixed;
++    public @Nullable MapId cachedMapId; // Paper - Perf: Cache map ids on item frames
+ 
+     public ItemFrame(EntityType<? extends ItemFrame> type, Level world) {
+         super(type, world);
+@@ -334,6 +335,7 @@ public class ItemFrame extends HangingEntity {
+     }
+ 
+     private void onItemChanged(ItemStack stack) {
++        this.cachedMapId = stack.getComponents().get(net.minecraft.core.component.DataComponents.MAP_ID); // Paper - Perf: Cache map ids on item frames
+         if (!stack.isEmpty() && stack.getFrame() != this) {
+             stack.setEntityRepresentation(this);
+         }

patches/server/0846-Fix-custom-statistic-criteria-creation.patch

@@ -0,0 +1,25 @@
+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 a5a3a0f0460252415c243dfe3019d103b9589c5b..a4998c2df341a1b9a337afb24284428cd98e59d8 100644
+--- a/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
++++ b/src/main/java/org/bukkit/craftbukkit/util/CraftMagicNumbers.java
+@@ -599,6 +599,14 @@ public final class CraftMagicNumbers implements UnsafeValues {
+     }
+     // Paper end - namespaced key biome methods
+ 
++    // Paper start - fix custom stats criteria creation
++    @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 - fix custom stats criteria creation
++
+     @Override
+     public String get(Class<?> aClass, String s) {
+         if (aClass == Enchantment.class) {

patches/server/0847-Bandaid-fix-for-Effect.patch

@@ -0,0 +1,179 @@
+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 71733f918ed84b9879ac1b142ef6205c5e768a9c..c856384019eff2f2d0bb831ebe1ccb0fb9210782 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftEffect.java
++++ b/src/main/java/org/bukkit/craftbukkit/CraftEffect.java
+@@ -15,6 +15,14 @@ public class CraftEffect {
+     public static <T> int getDataValue(Effect effect, T data) {
+         int datavalue;
+         switch (effect) {
++        // Paper start - add missing effects
++        case PARTICLES_SCULK_CHARGE:
++        case TRIAL_SPAWNER_DETECT_PLAYER:
++        case BEE_GROWTH:
++        case TURTLE_EGG_PLACEMENT:
++        case SMASH_ATTACK:
++        case TRIAL_SPAWNER_DETECT_PLAYER_OMINOUS:
++        // Paper end - add missing effects
+         case VILLAGER_PLANT_GROW:
+             datavalue = (Integer) data;
+             break;
+@@ -26,6 +34,13 @@ public class CraftEffect {
+             Preconditions.checkArgument(data == Material.AIR || ((Material) data).isRecord(), "Invalid record type for Material %s!", data);
+             datavalue = Item.getId(CraftItemType.bukkitToMinecraft((Material) data));
+             break;
++        // Paper start - handle shoot white smoke event
++        case SHOOT_WHITE_SMOKE:
++            final BlockFace face = (BlockFace) data;
++            Preconditions.checkArgument(face.isCartesian(), face + " isn't cartesian");
++            datavalue = org.bukkit.craftbukkit.block.CraftBlock.blockFaceToNotch(face).get3DDataValue();
++            break;
++        // Paper end - handle shoot white smoke event
+         case SMOKE:
+             switch ((BlockFace) data) {
+             case DOWN:
+@@ -57,10 +72,25 @@ 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(CraftBlockType.bukkitToMinecraft((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:
++        // Paper start - add missing effects
++        case TRIAL_SPAWNER_SPAWN:
++        case TRIAL_SPAWNER_SPAWN_MOB_AT:
++        case VAULT_ACTIVATE:
++        case VAULT_DEACTIVATE:
++        case TRIAL_SPAWNER_BECOME_OMINOUS:
++        case TRIAL_SPAWNER_SPAWN_ITEM:
++        // Paper end - add missing effects
+             datavalue = ((Boolean) data) ? 1 : 0;
+             break;
+         case BONE_MEAL_USE:
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftWorld.java b/src/main/java/org/bukkit/craftbukkit/CraftWorld.java
+index 03cef3e33de1cf2a1ad4c7a5ba9a65ee3b69ee52..536ad499e893c5b9898fb02582eeca541c917890 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 79e35265978357eeb27c43205433d6b24335f401..e20e8ba103a0ba094e00ef08ff0fc3b741a9bce5 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -930,7 +930,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..3129212415c151aa028995b6e698f81b638e4c35
+--- /dev/null
++++ b/src/test/java/org/bukkit/EffectTest.java
+@@ -0,0 +1,78 @@
++package org.bukkit;
++
++import com.google.common.base.Joiner;
++import java.lang.reflect.Field;
++import java.lang.reflect.Modifier;
++import java.util.ArrayList;
++import java.util.HashMap;
++import java.util.HashSet;
++import java.util.List;
++import java.util.Map;
++import java.util.Set;
++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;
++import static org.junit.jupiter.api.Assertions.fail;
++
++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);
++    }
++
++    @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);
++            }
++        }
++
++        final Set<Integer> missingEvents = new HashSet<>();
++        for (final Integer event : collectNmsLevelEvents()) {
++            if (toId.get(event) == null) {
++                missingEvents.add(event);
++            }
++        }
++        if (!missingEvents.isEmpty()) {
++            fail("Missing API Effects:\n" + Joiner.on("\n").join(missingEvents));
++        }
++    }
++
++    @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();
++        final Set<Effect> extraApiEffects = new HashSet<>();
++        for (final Map.Entry<Integer, Effect> entry : toId.entrySet()) {
++            if (!nmsEvents.contains(entry.getKey())) {
++                extraApiEffects.add(entry.getValue());
++            }
++        }
++        if (!extraApiEffects.isEmpty()) {
++            fail("Extra API Effects:\n" + Joiner.on("\n").join(extraApiEffects));
++        }
++    }
++}

patches/server/0848-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 5211dc80f449cec09f992a42667e869ab9e7115e..407d5b1d87d14e18878f0ebf1d676a7f49e7cfaf 100644
+--- a/src/main/java/org/bukkit/craftbukkit/block/CraftSculkCatalyst.java
++++ b/src/main/java/org/bukkit/craftbukkit/block/CraftSculkCatalyst.java
+@@ -38,4 +38,20 @@ public class CraftSculkCatalyst extends CraftBlockEntityState<SculkCatalystBlock
+     public CraftSculkCatalyst copy(Location location) {
+         return new CraftSculkCatalyst(this, location);
+     }
++
++    // 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
+ }

patches/server/0849-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 d57798d6a53334eacf8235c0fd0f28d7719593fe..0d2d1b6eab153aea6015bd69f2bad58e67d065c3 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+@@ -1264,4 +1264,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
+ }

patches/server/0850-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 6bafb10ddbb1a4a73370b8cefac79e61d0c35ffc..2934e232c84603224470fdaba0103d42fc06e8b4 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
++++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
+@@ -1970,6 +1970,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
+@@ -1980,6 +1985,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, "+", CraftMapCursor.CraftType.bukkitToMinecraftHolder(mapIcon));
++
++        return CraftItemStack.asBukkitCopy(stack);
++    }
++    // Paper end
+ 
+     @Override
+     public void shutdown() {

patches/server/0851-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 618c620b4bca535c454691f9a87c9b36a36021e2..f21a5b9de17db9a094b22267b33bbffbf7ef8966 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
++++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -824,6 +824,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 - Don't tab-complete namespaced commands if send-namespaced is false
+             // Paper start - Brigadier API
+             com.destroystokyo.paper.event.brigadier.AsyncPlayerSendSuggestionsEvent suggestEvent = new com.destroystokyo.paper.event.brigadier.AsyncPlayerSendSuggestionsEvent(this.getCraftPlayer(), suggestions, packet.getCommand());
+             suggestEvent.setCancelled(suggestions.isEmpty());

patches/server/0852-Properly-handle-BlockBreakEvent-isDropItems.patch

@@ -0,0 +1,162 @@
+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 2aee9c2fbe38076317a3de7c3fdbd6988b64b389..3bd4ab8161c29bb8df2ba496a4430393b6593476 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
++++ b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
+@@ -437,8 +437,8 @@ public class ServerPlayerGameMode {
+                     isCorrectTool = flag1; // Paper - Trigger bee_nest_destroyed trigger in the correct place
+ 
+                     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() */) { // 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(), false); // Paper - fix drops not preventing stats/food exhaustion
+                     }
+ 
+                     // 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 90f69a0c4d0707fd2319db71aea7dfdc14636d82..9591870420390fe1a69d44855a8f4de779332b7d 100644
+--- a/src/main/java/net/minecraft/world/level/block/BeehiveBlock.java
++++ b/src/main/java/net/minecraft/world/level/block/BeehiveBlock.java
+@@ -94,8 +94,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, boolean dropExp) { // Paper - fix drops not preventing stats/food exhaustion
++        super.playerDestroy(world, player, pos, state, blockEntity, tool, includeDrops, dropExp); // Paper - fix drops not preventing stats/food exhaustion
+         if (!world.isClientSide && blockEntity instanceof BeehiveBlockEntity tileentitybeehive) {
+             if (!EnchantmentHelper.hasTag(tool, EnchantmentTags.PREVENTS_BEE_SPAWNS_WHEN_MINING)) {
+                 tileentitybeehive.emptyAllLivingFromHive(player, state, BeehiveBlockEntity.BeeReleaseStatus.EMERGENCY);
+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 4d140bd83ca0e1554afad80ec4fc6186188a79d8..6fb3f551f432d7e668c606fb7bd3514408e0478a 100644
+--- a/src/main/java/net/minecraft/world/level/block/Block.java
++++ b/src/main/java/net/minecraft/world/level/block/Block.java
+@@ -405,10 +405,18 @@ public class Block extends BlockBehaviour implements ItemLike {
+         return this.defaultBlockState();
+     }
+ 
++    @io.papermc.paper.annotation.DoNotUse @Deprecated // Paper - fix drops not preventing stats/food exhaustion
+     public void playerDestroy(Level world, Player player, BlockPos pos, BlockState state, @Nullable BlockEntity blockEntity, ItemStack tool) {
++        // Paper start - fix drops not preventing stats/food exhaustion
++        this.playerDestroy(world, player, pos, state, blockEntity, tool, true, true);
++    }
++    public void playerDestroy(Level world, Player player, BlockPos pos, BlockState state, @Nullable BlockEntity blockEntity, ItemStack tool, boolean includeDrops, boolean dropExp) {
++        // Paper end - fix drops not preventing stats/food exhaustion
+         player.awardStat(Stats.BLOCK_MINED.get(this));
+         player.causeFoodExhaustion(0.005F, org.bukkit.event.entity.EntityExhaustionEvent.ExhaustionReason.BLOCK_MINED); // CraftBukkit - EntityExhaustionEvent
++        if (includeDrops) { // Paper - fix drops not preventing stats/food exhaustion
+         Block.dropResources(state, world, pos, blockEntity, player, tool);
++        } // Paper - fix drops not preventing stats/food exhaustion
+     }
+ 
+     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 edb3b6cdb617c48140539728af1373993e78648f..4fe83bd0f355549847b66afb7e61f6f2a6d97016 100644
+--- a/src/main/java/net/minecraft/world/level/block/DoublePlantBlock.java
++++ b/src/main/java/net/minecraft/world/level/block/DoublePlantBlock.java
+@@ -98,8 +98,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, boolean dropExp) { // Paper - fix drops not preventing stats/food exhaustion
++        super.playerDestroy(world, player, pos, Blocks.AIR.defaultBlockState(), blockEntity, tool, includeDrops, dropExp); // Paper - fix drops not preventing stats/food exhaustion
+     }
+ 
+     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 067a2d969ca0979ae67b600e303deec93eda0251..a94762e65853ccad38cf90b0049ca256106c0c9f 100644
+--- a/src/main/java/net/minecraft/world/level/block/IceBlock.java
++++ b/src/main/java/net/minecraft/world/level/block/IceBlock.java
+@@ -34,8 +34,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, boolean dropExp) { // Paper - fix drops not preventing stats/food exhaustion
++        super.playerDestroy(world, player, pos, state, blockEntity, tool, includeDrops, dropExp); // Paper - fix drops not preventing stats/food exhaustion
+         // Paper start - Improve Block#breakNaturally API
+         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 85d9829e979ef5f22aee9c346800612f479786b7..953ddb2ea6fd48e57712e30a6addf23e188e5312 100644
+--- a/src/main/java/net/minecraft/world/level/block/TurtleEggBlock.java
++++ b/src/main/java/net/minecraft/world/level/block/TurtleEggBlock.java
+@@ -175,8 +175,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, boolean dropExp) { // Paper - fix drops not preventing stats/food exhaustion
++        super.playerDestroy(world, player, pos, state, blockEntity, tool, includeDrops, dropExp); // Paper - fix drops not preventing stats/food exhaustion
+         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..22145bf698b3d1ff0a07a3aaa8d55a19905f99ad
+--- /dev/null
++++ b/src/test/java/io/papermc/paper/world/block/BlockPlayerDestroyOverrideTest.java
+@@ -0,0 +1,48 @@
++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.environment.Normal;
++import org.junit.jupiter.params.ParameterizedTest;
++import org.junit.jupiter.params.provider.MethodSource;
++
++import static org.junit.jupiter.api.Assertions.assertEquals;
++
++@Normal
++public class BlockPlayerDestroyOverrideTest {
++
++    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");
++    }
++}

patches/server/0853-Fire-entity-death-event-for-ender-dragon.patch

@@ -0,0 +1,25 @@
+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 38456d3901e495e4c401cff0de7ae38544c1b2a7..2df8bf818345246cc1f88b93e4a3b62e61772efb 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
+@@ -627,6 +627,14 @@ public class EnderDragon extends Mob implements Enemy {
+ 
+     @Override
+     public void kill(ServerLevel world) {
++        // Paper start - Fire entity death event
++        this.silentDeath = true;
++        org.bukkit.event.entity.EntityDeathEvent deathEvent = org.bukkit.craftbukkit.event.CraftEventFactory.callEntityDeathEvent(this, this.damageSources().genericKill());
++        if (deathEvent.isCancelled()) {
++            this.silentDeath = false; // Reset to default if event was cancelled
++            return;
++        }
++        // Paper end - Fire entity death event
+         this.remove(Entity.RemovalReason.KILLED, EntityRemoveEvent.Cause.DEATH); // CraftBukkit - add Bukkit remove cause
+         this.gameEvent(GameEvent.ENTITY_DIE);
+         if (this.dragonFight != null) {

patches/server/0854-Configurable-entity-tracking-range-by-Y-coordinate.patch

@@ -0,0 +1,30 @@
+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 ec19eb88705a07db45f1a3541571fb7f43efb5a9..49d926313b0d0f2ed2e93ca824009c8d0a988f67 100644
+--- a/src/main/java/net/minecraft/server/level/ChunkMap.java
++++ b/src/main/java/net/minecraft/server/level/ChunkMap.java
+@@ -1583,7 +1583,17 @@ public class ChunkMap extends ChunkStorage implements ChunkHolder.PlayerProvider
+                 double d0 = (double) Math.min(this.getEffectiveRange(), i * 16);
+                 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 - Configurable entity tracking range by Y
++                boolean flag = d1 <= d2;
++                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;
++                    }
++                }
++                flag = flag && this.entity.broadcastToPlayer(player) && ChunkMap.this.isChunkTracked(player, this.entity.chunkPosition().x, this.entity.chunkPosition().z);
++                // Paper end - Configurable entity tracking range by Y
+ 
+                 // CraftBukkit start - respect vanish API
+                 if (!player.getBukkitEntity().canSee(this.entity.getBukkitEntity())) {

patches/server/0855-Add-Listing-API-for-Player.patch

@@ -0,0 +1,186 @@
+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 29b465fc1dc50e0e84ddb889c5303e80fe662874..4d67d98257b2cb9045d03c999cfd4ba2caf8453c 100644
+--- a/src/main/java/net/minecraft/network/protocol/game/ClientboundPlayerInfoUpdatePacket.java
++++ b/src/main/java/net/minecraft/network/protocol/game/ClientboundPlayerInfoUpdatePacket.java
+@@ -37,6 +37,17 @@ public class ClientboundPlayerInfoUpdatePacket implements Packet<ClientGamePacke
+         this.actions = EnumSet.of(action);
+         this.entries = List.of(new ClientboundPlayerInfoUpdatePacket.Entry(player));
+     }
++    // Paper start - Add Listing API for Player
++    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 - Add Listing API for Player
+ 
+     public static ClientboundPlayerInfoUpdatePacket createPlayerInitializing(Collection<ServerPlayer> players) {
+         EnumSet<ClientboundPlayerInfoUpdatePacket.Action> enumSet = EnumSet.of(
+@@ -51,6 +62,28 @@ public class ClientboundPlayerInfoUpdatePacket implements Packet<ClientGamePacke
+         return new ClientboundPlayerInfoUpdatePacket(enumSet, players);
+     }
+ 
++    // Paper start - Add Listing API for Player
++    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 - Add Listing API for Player
+     private ClientboundPlayerInfoUpdatePacket(RegistryFriendlyByteBuf buf) {
+         this.actions = buf.readEnumSet(ClientboundPlayerInfoUpdatePacket.Action.class);
+         this.entries = buf.readList(buf2 -> {
+@@ -161,10 +194,15 @@ public class ClientboundPlayerInfoUpdatePacket implements Packet<ClientGamePacke
+         @Nullable RemoteChatSession.Data chatSession
+     ) {
+         Entry(ServerPlayer player) {
++        // Paper start - Add Listing API for Player
++            this(player, true);
++        }
++        Entry(ServerPlayer player, boolean listed) {
+             this(
++        // Paper end - Add Listing API for Player
+                 player.getUUID(),
+                 player.getGameProfile(),
+-                true,
++                listed, // Paper - Add Listing API for Player
+                 player.connection.latency(),
+                 player.gameMode.getGameModeForPlayer(),
+                 player.getTabListDisplayName(),
+@@ -172,6 +210,11 @@ public class ClientboundPlayerInfoUpdatePacket implements Packet<ClientGamePacke
+                 Optionull.map(player.getChatSession(), RemoteChatSession::asData)
+             );
+         }
++        // Paper start - Add Listing API for Player
++        Entry(UUID profileId, boolean listed) {
++            this(profileId, null, listed, 0, GameType.DEFAULT_MODE, null, 0, null);
++        }
++        // Paper end - Add Listing API for Player
+     }
+ 
+     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 7356a027ae3bca3a9f2056ef6849d5fab38a0df3..a4937d11b79cef41f3fbf79282c0c435e794dbfe 100644
+--- a/src/main/java/net/minecraft/server/players/PlayerList.java
++++ b/src/main/java/net/minecraft/server/players/PlayerList.java
+@@ -363,14 +363,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 - Add Listing API for Player
+ 
+         final List<ServerPlayer> onlinePlayers = Lists.newArrayListWithExpectedSize(this.players.size() - 1); // Paper - Use single player info update packet on join
+         for (int i = 0; i < this.players.size(); ++i) {
+             ServerPlayer entityplayer1 = (ServerPlayer) this.players.get(i);
+ 
+             if (entityplayer1.getBukkitEntity().canSee(bukkitPlayer)) {
++                // Paper start - Add Listing API for Player
++                if (entityplayer1.getBukkitEntity().isListed(bukkitPlayer)) {
++                // Paper end - Add Listing API for Player
+                 entityplayer1.connection.send(packet);
++                // Paper start - Add Listing API for Player
++                } else {
++                    entityplayer1.connection.send(ClientboundPlayerInfoUpdatePacket.createSinglePlayerInitializing(player, false));
++                }
++                // Paper end - Add Listing API for Player
+             }
+ 
+             if (entityplayer1 == player || !bukkitPlayer.canSee(entityplayer1.getBukkitEntity())) { // Paper - Use single player info update packet on join; Don't include joining player
+@@ -381,7 +389,7 @@ public abstract class PlayerList {
+         }
+         // Paper start - Use single player info update packet on join
+         if (!onlinePlayers.isEmpty()) {
+-            player.connection.send(ClientboundPlayerInfoUpdatePacket.createPlayerInitializing(onlinePlayers));
++            player.connection.send(ClientboundPlayerInfoUpdatePacket.createPlayerInitializing(onlinePlayers, player)); // Paper - Add Listing API for Player
+         }
+         // Paper end - Use single player info update packet on join
+         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 e20e8ba103a0ba094e00ef08ff0fc3b741a9bce5..b6093a1bbd8176cde85ef034373ae71f9dd8f1c1 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -202,6 +202,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 - Add Listing API for Player
+     private static final WeakHashMap<Plugin, WeakReference<Plugin>> pluginWeakReferences = new WeakHashMap<>();
+     private int hash = 0;
+     private double health = 20;
+@@ -2105,7 +2106,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 - Add Listing API for Player
+             if (original != null) otherPlayer.setUUID(original); // Paper - uuid override
+         }
+ 
+@@ -2209,6 +2210,41 @@ 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 - Add Listing API for Player
++    @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.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.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 - Add Listing API for Player
++
+     @Override
+     public Map<String, Object> serialize() {
+         Map<String, Object> result = new LinkedHashMap<String, Object>();

patches/server/0856-Configurable-Region-Compression-Format.patch

@@ -0,0 +1,39 @@
+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 f1237f6fd6414900ffbad0caee31aa83310eeef4..e858436bcf1b234d4bc6e6a117f5224d5c2d9f90 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
+@@ -50,7 +50,7 @@ public class RegionFile implements AutoCloseable {
+     protected final RegionBitmap usedSectors;
+ 
+     public RegionFile(RegionStorageInfo storageKey, Path directory, Path path, boolean dsync) throws IOException {
+-        this(storageKey, directory, path, RegionFileVersion.getSelected(), dsync);
++        this(storageKey, directory, path, RegionFileVersion.getCompressionFormat(), dsync); // Paper - Configurable region compression format
+     }
+ 
+     public RegionFile(RegionStorageInfo storageKey, Path path, Path directory, RegionFileVersion compressionFormat, boolean dsync) throws IOException {
+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 cbd892598287c9358c1c2a3840c517462820b389..ef68b57ef1d8d7cb317c417569dd23a777fba4ad 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
+@@ -58,6 +58,15 @@ public class RegionFileVersion {
+     private final RegionFileVersion.StreamWrapper<InputStream> inputWrapper;
+     private final RegionFileVersion.StreamWrapper<OutputStream> outputWrapper;
+ 
++    // 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 - Configurable region compression format
+     private RegionFileVersion(
+         int id,
+         @Nullable String name,

patches/server/0857-Add-BlockFace-to-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] Add BlockFace to BlockDamageEvent
+
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
+index 3bd4ab8161c29bb8df2ba496a4430393b6593476..0da6496c18341c01fc4551ead7e740a6037dcf31 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
++++ b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
+@@ -259,7 +259,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 - Add BlockFace to BlockDamageEvent
+ 
+                 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 03afabc3ab4b264f84698627b79e58f502a8cea9..0bf830b51f078d1a642e1bbec6cd8b6e83501135 100644
+--- a/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
++++ b/src/main/java/org/bukkit/craftbukkit/event/CraftEventFactory.java
+@@ -660,13 +660,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 - Add BlockFace to BlockDamageEvent
+         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 - Add BlockFace to BlockDamageEvent
+         player.getServer().getPluginManager().callEvent(event);
+ 
+         return event;

patches/server/0858-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 5de1ada561d11c247a597effab1e0aa363b7c90f..412fd9e87ec81cf50cb8bc82fe2dad5dd0029039 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftBoat.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftBoat.java
+@@ -87,6 +87,17 @@ public abstract class CraftBoat extends CraftVehicle implements Boat {
+ 
+     @Override
+     public Status getStatus() {
++        // Paper start - Fix NPE on Boat getStatus
++        final net.minecraft.world.entity.vehicle.Boat handle = this.getHandle();
++        if (handle.status == null) {
++            if (handle.valid) {
++                // 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 - Fix NPE on Boat getStatus
+         return CraftBoat.boatStatusFromNms(this.getHandle().status);
+     }
+ 

patches/server/0859-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 aeeb90481a9ac0a8ec9e3c5af08a32ca3e32bfb6..a8a5b28d95f7c3ce944f51993dd0c0eb98e3c550 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
++++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -427,6 +427,7 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+     @javax.annotation.Nullable
+     private UUID originWorld;
+     public boolean freezeLocked = false; // Paper - Freeze Tick Lock API
++    public boolean fixedPose = false; // Paper - Expand Pose API
+ 
+     public void setOrigin(@javax.annotation.Nonnull Location location) {
+         this.origin = location.toVector();
+@@ -625,6 +626,7 @@ public abstract class Entity implements SyncedDataHolder, Nameable, EntityAccess
+     public void onRemoval(Entity.RemovalReason reason) {}
+ 
+     public void setPose(net.minecraft.world.entity.Pose pose) {
++        if (this.fixedPose) return; // Paper - Expand Pose API
+         // 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 0d2d1b6eab153aea6015bd69f2bad58e67d065c3..9c8e2731ca37a16cb538da27190c085bbc9791e3 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+@@ -900,6 +900,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