Applied all patches

patches/server/0926-Ability-to-control-player-s-insomnia-and-phantoms.patch

@@ -0,0 +1,67 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jan Villim <jan.villim@student.tuke.sk>
+Date: Sat, 22 Jan 2022 17:56:19 +0100
+Subject: [PATCH] Ability to control player's insomnia and phantoms
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/EntitySelector.java b/src/main/java/net/minecraft/world/entity/EntitySelector.java
+index a00c3d96f2fc7131d1f4afa7af4e41ace3cfce89..72abebff2018cde2922e97ad6478f93da9aed3ec 100644
+--- a/src/main/java/net/minecraft/world/entity/EntitySelector.java
++++ b/src/main/java/net/minecraft/world/entity/EntitySelector.java
+@@ -27,7 +27,18 @@ public final class EntitySelector {
+         return !entity.isSpectator();
+     };
+     public static final Predicate<Entity> CAN_BE_COLLIDED_WITH = EntitySelector.NO_SPECTATORS.and(Entity::canBeCollidedWith);
+-    public static Predicate<Player> isInsomniac = (player) -> net.minecraft.util.Mth.clamp(((net.minecraft.server.level.ServerPlayer) player).getStats().getValue(net.minecraft.stats.Stats.CUSTOM.get(net.minecraft.stats.Stats.TIME_SINCE_REST)), 1, Integer.MAX_VALUE) >= 72000; // Paper
++    // Paper start
++    public static Predicate<Player> isInsomniac = (player) -> {
++        net.minecraft.server.level.ServerPlayer serverPlayer = (net.minecraft.server.level.ServerPlayer) player;
++        int playerInsomniaTicks = serverPlayer.getLevel().paperConfig().entities.behavior.playerInsomniaStartTicks;
++
++        if (playerInsomniaTicks <= 0) {
++            return false;
++        }
++
++        return net.minecraft.util.Mth.clamp(serverPlayer.getStats().getValue(net.minecraft.stats.Stats.CUSTOM.get(net.minecraft.stats.Stats.TIME_SINCE_REST)), 1, Integer.MAX_VALUE) >= playerInsomniaTicks;
++    };
++    // Paper end
+ 
+     private EntitySelector() {}
+     // Paper start
+diff --git a/src/main/java/net/minecraft/world/level/levelgen/PhantomSpawner.java b/src/main/java/net/minecraft/world/level/levelgen/PhantomSpawner.java
+index 66ac41d8fce4176feecf9a7e89e15244f47d261d..e8ae4449696d73c8c9b8b27d4d2e20db933a72cc 100644
+--- a/src/main/java/net/minecraft/world/level/levelgen/PhantomSpawner.java
++++ b/src/main/java/net/minecraft/world/level/levelgen/PhantomSpawner.java
+@@ -35,13 +35,22 @@ public class PhantomSpawner implements CustomSpawner {
+         } else if (!world.getGameRules().getBoolean(GameRules.RULE_DOINSOMNIA)) {
+             return 0;
+         } else {
++            // Paper start
++            if (world.paperConfig().entities.behavior.phantomsSpawnAttemptMaxSeconds <= 0) {
++                return 0;
++            }
++            // Paper end
+             RandomSource randomsource = world.random;
+ 
+             --this.nextTick;
+             if (this.nextTick > 0) {
+                 return 0;
+             } else {
+-                this.nextTick += (60 + randomsource.nextInt(60)) * 20;
++                // Paper start
++                int spawnAttemptMinSeconds = world.paperConfig().entities.behavior.phantomsSpawnAttemptMinSeconds;
++                int spawnAttemptMaxSeconds = world.paperConfig().entities.behavior.phantomsSpawnAttemptMaxSeconds;
++                this.nextTick += (spawnAttemptMinSeconds + randomsource.nextInt(spawnAttemptMaxSeconds - spawnAttemptMinSeconds + 1)) * 20;
++                // Paper end
+                 if (world.getSkyDarken() < 5 && world.dimensionType().hasSkyLight()) {
+                     return 0;
+                 } else {
+@@ -62,7 +71,7 @@ public class PhantomSpawner implements CustomSpawner {
+                                     int j = Mth.clamp(serverstatisticmanager.getValue(Stats.CUSTOM.get(Stats.TIME_SINCE_REST)), 1, Integer.MAX_VALUE);
+                                     boolean flag2 = true;
+ 
+-                                    if (randomsource.nextInt(j) >= 72000) {
++                                    if (randomsource.nextInt(j) >= world.paperConfig().entities.behavior.playerInsomniaStartTicks) { // Paper
+                                         BlockPos blockposition1 = blockposition.above(20 + randomsource.nextInt(15)).east(-10 + randomsource.nextInt(21)).south(-10 + randomsource.nextInt(21));
+                                         BlockState iblockdata = world.getBlockState(blockposition1);
+                                         FluidState fluid = world.getFluidState(blockposition1);

patches/server/0927-Fix-player-kick-on-shutdown.patch

@@ -0,0 +1,23 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Denery <dorofeevij@gmail.com>
+Date: Sun, 6 Nov 2022 02:02:46 +0300
+Subject: [PATCH] Fix player kick on shutdown
+
+Fix preemptive player kick on a server shutdown.
+If you update minecraft version / upstream and something is changed in this method make sure that a server doesn't disconnect a player preemptively,
+also check if all packets are ignored during the shutdown process.
+See net.minecraft.network.Connection#channelRead0(ChannelHandlerContext, Packet) and net.minecraft.util.thread.BlockableEventLoop#executeIfPossible(Runnable)
+
+diff --git a/src/main/java/net/minecraft/network/protocol/PacketUtils.java b/src/main/java/net/minecraft/network/protocol/PacketUtils.java
+index 23c81b3a96056f0b755735ad75fc81af9b046475..10ce342d663527601a638a9904257648b867e8f3 100644
+--- a/src/main/java/net/minecraft/network/protocol/PacketUtils.java
++++ b/src/main/java/net/minecraft/network/protocol/PacketUtils.java
+@@ -41,7 +41,7 @@ public class PacketUtils {
+ 
+     public static <T extends PacketListener> void ensureRunningOnSameThread(Packet<T> packet, T listener, BlockableEventLoop<?> engine) throws RunningOnDifferentThreadException {
+         if (!engine.isSameThread()) {
+-            engine.executeIfPossible(() -> {
++            engine.execute(() -> { // Paper - Fix preemptive player kick on a server shutdown.
+                 packetProcessing.push(listener); // Paper - detailed watchdog information
+                 try { // Paper - detailed watchdog information
+                 if (MinecraftServer.getServer().hasStopped() || (listener instanceof ServerGamePacketListenerImpl && ((ServerGamePacketListenerImpl) listener).processedDisconnect)) return; // CraftBukkit, MC-142590

patches/server/0928-Sync-offhand-slot-in-menus.patch

@@ -0,0 +1,51 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Fri, 14 Jan 2022 10:20:40 -0800
+Subject: [PATCH] Sync offhand slot in menus
+
+Menus don't add slots for the offhand, so on sendAllDataToRemote calls the
+offhand slot isn't sent. This is not correct because you *can* put stuff into the offhand
+by pressing the offhand swap item
+
+diff --git a/src/main/java/net/minecraft/server/level/ServerPlayer.java b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+index b18d8e23e98a01d095a27227516d9ff44fd1d14c..ca5291a9573a62cb5c19539cf5c7aceff11f9829 100644
+--- a/src/main/java/net/minecraft/server/level/ServerPlayer.java
++++ b/src/main/java/net/minecraft/server/level/ServerPlayer.java
+@@ -296,6 +296,13 @@ public class ServerPlayer extends Player {
+ 
+             }
+ 
++            // Paper start
++            @Override
++            public void sendOffHandSlotChange() {
++                ServerPlayer.this.connection.send(new ClientboundContainerSetSlotPacket(ServerPlayer.this.inventoryMenu.containerId, ServerPlayer.this.inventoryMenu.incrementStateId(), net.minecraft.world.inventory.InventoryMenu.SHIELD_SLOT, ServerPlayer.this.inventoryMenu.getSlot(net.minecraft.world.inventory.InventoryMenu.SHIELD_SLOT).getItem().copy()));
++            }
++            // Paper end
++
+             @Override
+             public void sendSlotChange(AbstractContainerMenu handler, int slot, ItemStack stack) {
+                 ServerPlayer.this.connection.send(new ClientboundContainerSetSlotPacket(handler.containerId, handler.incrementStateId(), slot, stack));
+diff --git a/src/main/java/net/minecraft/world/inventory/AbstractContainerMenu.java b/src/main/java/net/minecraft/world/inventory/AbstractContainerMenu.java
+index 0954e834ca4c777de61f5d45812008cc7c2ac733..c84908095a93d42826b21bf5f3490410fb0a5708 100644
+--- a/src/main/java/net/minecraft/world/inventory/AbstractContainerMenu.java
++++ b/src/main/java/net/minecraft/world/inventory/AbstractContainerMenu.java
+@@ -200,6 +200,7 @@ public abstract class AbstractContainerMenu {
+ 
+         if (this.synchronizer != null) {
+             this.synchronizer.sendInitialData(this, this.remoteSlots, this.remoteCarried, this.remoteDataSlots.toIntArray());
++            this.synchronizer.sendOffHandSlotChange(); // Paper - update player's offhand since the offhand slot is not added to the slots for menus but can be changed by swapping from a menu slot
+         }
+ 
+     }
+diff --git a/src/main/java/net/minecraft/world/inventory/ContainerSynchronizer.java b/src/main/java/net/minecraft/world/inventory/ContainerSynchronizer.java
+index ff4fa86f9408e83e505f7e27692d3423f8570c48..db6c290dcbb8f5cb502f85e154b42ac89350a460 100644
+--- a/src/main/java/net/minecraft/world/inventory/ContainerSynchronizer.java
++++ b/src/main/java/net/minecraft/world/inventory/ContainerSynchronizer.java
+@@ -6,6 +6,7 @@ import net.minecraft.world.item.ItemStack;
+ public interface ContainerSynchronizer {
+     void sendInitialData(AbstractContainerMenu handler, NonNullList<ItemStack> stacks, ItemStack cursorStack, int[] properties);
+ 
++    default void sendOffHandSlotChange() {} // Paper
+     void sendSlotChange(AbstractContainerMenu handler, int slot, ItemStack stack);
+ 
+     void sendCarriedChange(AbstractContainerMenu handler, ItemStack stack);

patches/server/0929-Player-Entity-Tracking-Events.patch

@@ -0,0 +1,34 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Yannick Lamprecht <yannicklamprecht@live.de>
+Date: Wed, 30 Mar 2022 18:16:52 +0200
+Subject: [PATCH] Player Entity Tracking Events
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index 9796c6fc7c114e3e2af0dc433a87cda910683e06..071b241de8f6e00f57e8564bb3feb757ee1f05eb 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
++++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -3894,9 +3894,21 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+         EnchantmentHelper.doPostDamageEffects(attacker, target);
+     }
+ 
+-    public void startSeenByPlayer(ServerPlayer player) {}
++    // Paper start
++    public void startSeenByPlayer(ServerPlayer player) {
++        if (io.papermc.paper.event.player.PlayerTrackEntityEvent.getHandlerList().getRegisteredListeners().length > 0) {
++            new io.papermc.paper.event.player.PlayerTrackEntityEvent(player.getBukkitEntity(), this.getBukkitEntity()).callEvent();
++        }
++    }
++    // Paper end
+ 
+-    public void stopSeenByPlayer(ServerPlayer player) {}
++    // Paper start
++    public void stopSeenByPlayer(ServerPlayer player) {
++        if(io.papermc.paper.event.player.PlayerUntrackEntityEvent.getHandlerList().getRegisteredListeners().length > 0) {
++            new io.papermc.paper.event.player.PlayerUntrackEntityEvent(player.getBukkitEntity(), this.getBukkitEntity()).callEvent();
++        }
++    }
++    // Paper end
+ 
+     public float rotate(Rotation rotation) {
+         float f = Mth.wrapDegrees(this.getYRot());

patches/server/0930-Limit-pet-look-distance.patch

@@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Noah van der Aa <ndvdaa@gmail.com>
+Date: Tue, 6 Dec 2022 18:45:54 +0100
+Subject: [PATCH] Limit pet look distance
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/ai/goal/FollowOwnerGoal.java b/src/main/java/net/minecraft/world/entity/ai/goal/FollowOwnerGoal.java
+index e4ecad5cca182ead780b1b4d78ea1e7be62bd1ca..4fe177c950c769f5c6e76b522019b5d5b78259a5 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/goal/FollowOwnerGoal.java
++++ b/src/main/java/net/minecraft/world/entity/ai/goal/FollowOwnerGoal.java
+@@ -93,7 +93,7 @@ public class FollowOwnerGoal extends Goal {
+ 
+     @Override
+     public void tick() {
+-        this.tamable.getLookControl().setLookAt(this.owner, 10.0F, (float) this.tamable.getMaxHeadXRot());
++        if (this.tamable.distanceToSqr(this.owner) <= 16 * 16) this.tamable.getLookControl().setLookAt(this.owner, 10.0F, (float) this.tamable.getMaxHeadXRot()); // Paper
+         if (--this.timeToRecalcPath <= 0) {
+             this.timeToRecalcPath = this.adjustedTickDelay(10);
+             if (this.tamable.distanceToSqr((Entity) this.owner) >= 144.0D) {

patches/server/0931-Properly-resend-entities.patch

@@ -0,0 +1,107 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com>
+Date: Wed, 7 Dec 2022 17:25:19 -0500
+Subject: [PATCH] Properly resend entities
+
+This resolves some issues which caused entities to not be resent correctly.
+Entities that are interacted with need to be resent to the client, so we resend all the entity
+data to the player whilst making sure not to clear dirty entries from the tracker. This makes
+sure that values will be correctly updated to other players.
+
+See: https://github.com/PaperMC/Paper/pull/1896
+
+== AT ==
+public net.minecraft.server.level.ChunkMap$TrackedEntity serverEntity
+
+diff --git a/src/main/java/net/minecraft/network/syncher/SynchedEntityData.java b/src/main/java/net/minecraft/network/syncher/SynchedEntityData.java
+index a276aed4821eb992e0f20e2d2c6229e0b96eef73..ff7ba7a161cfed7521354bc6e3f21ba0f17f3760 100644
+--- a/src/main/java/net/minecraft/network/syncher/SynchedEntityData.java
++++ b/src/main/java/net/minecraft/network/syncher/SynchedEntityData.java
+@@ -249,14 +249,46 @@ public class SynchedEntityData {
+     // CraftBukkit start
+     public void refresh(ServerPlayer to) {
+         if (!this.isEmpty()) {
+-            List<SynchedEntityData.DataValue<?>> list = this.getNonDefaultValues();
++            List<SynchedEntityData.DataValue<?>> list = this.packAll(); // Paper - Update EVERYTHING not just not default
+ 
+             if (list != null) {
++                if (to.getBukkitEntity().canSee(this.entity.getBukkitEntity())) { // Paper
+                 to.connection.send(new ClientboundSetEntityDataPacket(this.entity.getId(), list));
++                } // Paper
+             }
+         }
+     }
+     // CraftBukkit end
++    // Paper start
++    // We need to pack all as we cannot rely on "non default values" or "dirty" ones.
++    // Because these values can possibly be desynced on the client.
++    @Nullable
++    private List<SynchedEntityData.DataValue<?>> packAll() {
++        if (this.isEmpty()) {
++            return null;
++        }
++
++        List<SynchedEntityData.DataValue<?>> list = new ArrayList<>();
++        for (DataItem<?> dataItem : this.itemsById.values()) {
++            list.add(dataItem.value());
++        }
++
++        return list;
++    }
++
++    // This method should only be used if the data of an entity could have became desynced
++    // due to interactions on the client.
++    public void resendPossiblyDesyncedEntity(ServerPlayer player) {
++        if (this.entity.tracker == null) {
++            return;
++        }
++
++        net.minecraft.server.level.ServerEntity serverEntity = this.entity.tracker.serverEntity;
++        if (player.getBukkitEntity().canSee(entity.getBukkitEntity())) {
++            serverEntity.sendPairingData(player.connection::send, player);
++        }
++    }
++    // Paper end
+ 
+     public static class DataItem<T> {
+ 
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index e5caa9cbd1444698409bb6c4e46ee4086a37ebf5..5ddb75e6f60e4a4960018055991ea087ec473beb 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
++++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -2790,7 +2790,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
+ 
+                             // Entity in bucket - SPIGOT-4048 and SPIGOT-6859a
+                             if ((entity instanceof Bucketable && entity instanceof LivingEntity && origItem != null && origItem.asItem() == Items.WATER_BUCKET) && (event.isCancelled() || ServerGamePacketListenerImpl.this.player.getInventory().getSelected() == null || ServerGamePacketListenerImpl.this.player.getInventory().getSelected().getItem() != origItem)) {
+-                                ServerGamePacketListenerImpl.this.send(new ClientboundAddEntityPacket(entity));
++                                entity.getEntityData().resendPossiblyDesyncedEntity(player); // Paper - The entire mob gets deleted, so resend it.
+                                 player.containerMenu.sendAllDataToRemote();
+                             }
+ 
+diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
+index fc404bc963fbe510b81d2317d694e30c71f23eb0..3793cc8a2cc917ba33b18c5af7fac25e9c1da288 100644
+--- a/src/main/java/net/minecraft/server/players/PlayerList.java
++++ b/src/main/java/net/minecraft/server/players/PlayerList.java
+@@ -357,7 +357,7 @@ public abstract class PlayerList {
+         ((ServerLevel)player.level).getChunkSource().chunkMap.addEntity(player); // Paper - track entity now
+         // CraftBukkit end
+ 
+-        player.getEntityData().refresh(player); // CraftBukkit - BungeeCord#2321, send complete data to self on spawn
++        //player.getEntityData().refresh(player); // CraftBukkit - BungeeCord#2321, send complete data to self on spawn Paper - THIS IS NOT NEEDED ANYMORE
+ 
+         this.sendLevelInfo(player, worldserver1);
+ 
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Bucketable.java b/src/main/java/net/minecraft/world/entity/animal/Bucketable.java
+index 09654dd8895669109246f9bff36ab5ff5f533f65..9695a80c45b36c84f5fdef651b26a2c09d7f1f9b 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Bucketable.java
++++ b/src/main/java/net/minecraft/world/entity/animal/Bucketable.java
+@@ -109,8 +109,7 @@ public interface Bucketable {
+             itemstack1 = CraftItemStack.asNMSCopy(playerBucketFishEvent.getEntityBucket());
+             if (playerBucketFishEvent.isCancelled()) {
+                 ((ServerPlayer) player).containerMenu.sendAllDataToRemote(); // We need to update inventory to resync client's bucket
+-                ((ServerPlayer) player).connection.send(new ClientboundAddEntityPacket(entity)); // We need to play out these packets as the client assumes the fish is gone
+-                entity.getEntityData().refresh((ServerPlayer) player); // Need to send data such as the display name to client
++                entity.getEntityData().resendPossiblyDesyncedEntity((ServerPlayer) player); // Paper
+                 return Optional.of(InteractionResult.FAIL);
+             }
+             entity.playSound(((Bucketable) entity).getPickupSound(), 1.0F, 1.0F);

patches/server/0932-Fixes-and-additions-to-the-SpawnReason-API.patch

@@ -0,0 +1,71 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Sun, 25 Sep 2022 11:21:01 -0700
+Subject: [PATCH] Fixes and additions to the SpawnReason API
+
+Fixes some wrong reasons, and adds missing spawn reasons for entities.
+
+Co-authored-by: Doc <nachito94@msn.com>
+
+diff --git a/src/main/java/net/minecraft/world/entity/EntityType.java b/src/main/java/net/minecraft/world/entity/EntityType.java
+index 51274302ad0d500b9291c000d457be24caf52a74..fa10d60cf7f80c429690f20c3bccdd8bbe7752e8 100644
+--- a/src/main/java/net/minecraft/world/entity/EntityType.java
++++ b/src/main/java/net/minecraft/world/entity/EntityType.java
+@@ -348,7 +348,7 @@ public class EntityType<T extends Entity> implements FeatureElement, EntityTypeT
+     @Nullable
+     public T spawn(ServerLevel world, @Nullable ItemStack stack, @Nullable Player player, BlockPos pos, MobSpawnType spawnReason, boolean alignPosition, boolean invertY) {
+         // CraftBukkit start
+-        return this.spawn(world, stack, player, pos, spawnReason, alignPosition, invertY, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.SPAWNER_EGG);
++        return this.spawn(world, stack, player, pos, spawnReason, alignPosition, invertY, spawnReason == MobSpawnType.DISPENSER ? org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.DISPENSE_EGG : org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.SPAWNER_EGG); // Paper - use correct spawn reason for dispenser spawn eggs
+     }
+ 
+     @Nullable
+diff --git a/src/main/java/net/minecraft/world/entity/projectile/DragonFireball.java b/src/main/java/net/minecraft/world/entity/projectile/DragonFireball.java
+index 6afe37e42d88701af38df5793a9ea9d7d2cda5c5..c72ab3c9f7cb20f22b051981fe1fc41965d2b2af 100644
+--- a/src/main/java/net/minecraft/world/entity/projectile/DragonFireball.java
++++ b/src/main/java/net/minecraft/world/entity/projectile/DragonFireball.java
+@@ -54,7 +54,7 @@ public class DragonFireball extends AbstractHurtingProjectile {
+ 
+                 if (new com.destroystokyo.paper.event.entity.EnderDragonFireballHitEvent((org.bukkit.entity.DragonFireball) this.getBukkitEntity(), list.stream().map(LivingEntity::getBukkitLivingEntity).collect(java.util.stream.Collectors.toList()), (org.bukkit.entity.AreaEffectCloud) areaEffectCloud.getBukkitEntity()).callEvent()) { // Paper
+                 this.level.levelEvent(2006, this.blockPosition(), this.isSilent() ? -1 : 1);
+-                this.level.addFreshEntity(areaEffectCloud);
++                this.level.addFreshEntity(areaEffectCloud, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.EXPLOSION); // Paper
+                 } else areaEffectCloud.discard(); // Paper
+                 this.discard();
+             }
+diff --git a/src/main/java/net/minecraft/world/level/block/CarvedPumpkinBlock.java b/src/main/java/net/minecraft/world/level/block/CarvedPumpkinBlock.java
+index 86365234d6c0ff5f0d5545a6ecc0bb08e6609108..05112bc416019daba885a3de1b7f96177665135f 100644
+--- a/src/main/java/net/minecraft/world/level/block/CarvedPumpkinBlock.java
++++ b/src/main/java/net/minecraft/world/level/block/CarvedPumpkinBlock.java
+@@ -90,7 +90,17 @@ public class CarvedPumpkinBlock extends HorizontalDirectionalBlock implements Eq
+         // clearPatternBlocks(world, shapedetector_shapedetectorcollection); // CraftBukkit - moved down
+         entity.moveTo((double) pos.getX() + 0.5D, (double) pos.getY() + 0.05D, (double) pos.getZ() + 0.5D, 0.0F, 0.0F);
+         // CraftBukkit start
+-        if (!world.addFreshEntity(entity, SpawnReason.BUILD_IRONGOLEM)) {
++        // Paper start - correct spawn reason
++        final SpawnReason spawnReason;
++        if (entity.getType() == EntityType.SNOW_GOLEM) {
++            spawnReason = SpawnReason.BUILD_SNOWMAN;
++        } else if (entity.getType() == EntityType.IRON_GOLEM) {
++            spawnReason = SpawnReason.BUILD_IRONGOLEM;
++        } else {
++            spawnReason = SpawnReason.DEFAULT;
++        }
++        if (!world.addFreshEntity(entity, spawnReason)) {
++        // Paper end
+             return;
+         }
+         CarvedPumpkinBlock.clearPatternBlocks(world, patternResult); // CraftBukkit - from above
+diff --git a/src/main/java/net/minecraft/world/level/block/FrogspawnBlock.java b/src/main/java/net/minecraft/world/level/block/FrogspawnBlock.java
+index 294d22b6b27e96b59c77527efcfefa9410b756e4..bebcdc70c4cb01764428836fff76f03b94f2eae8 100644
+--- a/src/main/java/net/minecraft/world/level/block/FrogspawnBlock.java
++++ b/src/main/java/net/minecraft/world/level/block/FrogspawnBlock.java
+@@ -110,7 +110,7 @@ public class FrogspawnBlock extends Block {
+                 int k = random.nextInt(1, 361);
+                 tadpole.moveTo(d, (double)pos.getY() - 0.5D, e, (float)k, 0.0F);
+                 tadpole.setPersistenceRequired();
+-                world.addFreshEntity(tadpole);
++                world.addFreshEntity(tadpole, org.bukkit.event.entity.CreatureSpawnEvent.SpawnReason.EGG); // Paper
+             }
+         }
+ 

patches/server/0933-fix-Instruments.patch

@@ -0,0 +1,85 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Fri, 9 Dec 2022 01:47:23 -0800
+Subject: [PATCH] fix Instruments
+
+properly handle Player#playNote
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index 7944f6a130da8f370f8018fad495694c61a94338..c3c4bc73310993f3a92d8aa171289fc61da8949f 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -768,62 +768,18 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+     public void playNote(Location loc, Instrument instrument, Note note) {
+         if (this.getHandle().connection == null) return;
+ 
+-        String instrumentName = null;
+-        switch (instrument.ordinal()) {
+-            case 0:
+-                instrumentName = "harp";
+-                break;
+-            case 1:
+-                instrumentName = "basedrum";
+-                break;
+-            case 2:
+-                instrumentName = "snare";
+-                break;
+-            case 3:
+-                instrumentName = "hat";
+-                break;
+-            case 4:
+-                instrumentName = "bass";
+-                break;
+-            case 5:
+-                instrumentName = "flute";
+-                break;
+-            case 6:
+-                instrumentName = "bell";
+-                break;
+-            case 7:
+-                instrumentName = "guitar";
+-                break;
+-            case 8:
+-                instrumentName = "chime";
+-                break;
+-            case 9:
+-                instrumentName = "xylophone";
+-                break;
+-            case 10:
+-                instrumentName = "iron_xylophone";
+-                break;
+-            case 11:
+-                instrumentName = "cow_bell";
+-                break;
+-            case 12:
+-                instrumentName = "didgeridoo";
+-                break;
+-            case 13:
+-                instrumentName = "bit";
+-                break;
+-            case 14:
+-                instrumentName = "banjo";
+-                break;
+-            case 15:
+-                instrumentName = "pling";
+-                break;
+-            case 16:
+-                instrumentName = "xylophone";
+-                break;
++        // Paper start - fix all this (modeled off of NoteBlock)
++        net.minecraft.world.level.block.state.properties.NoteBlockInstrument nms = CraftBlockData.toNMS(instrument, net.minecraft.world.level.block.state.properties.NoteBlockInstrument.class);
++        float f;
++        if (nms.isTunable()) {
++            f = (float) Math.pow(2.0D, (note.getId() - 12.0D) / 12.0D);
++        } else {
++            f = 1.0f;
+         }
+-        float f = (float) Math.pow(2.0D, (note.getId() - 12.0D) / 12.0D);
+-        this.getHandle().connection.send(new ClientboundSoundPacket(BuiltInRegistries.SOUND_EVENT.wrapAsHolder(CraftSound.getSoundEffect("block.note_block." + instrumentName)), net.minecraft.sounds.SoundSource.RECORDS, loc.getBlockX(), loc.getBlockY(), loc.getBlockZ(), 3.0f, f, this.getHandle().getRandom().nextLong()));
++        if (!nms.hasCustomSound()) {
++            this.getHandle().connection.send(new ClientboundSoundPacket(nms.getSoundEvent(), net.minecraft.sounds.SoundSource.RECORDS, loc.getBlockX(), loc.getBlockY(), loc.getBlockZ(), 3.0f, f, this.getHandle().getRandom().nextLong()));
++        }
++        // Paper end
+     }
+ 
+     @Override

patches/server/0934-Fix-chunk-snapshot-biome-getter.patch

@@ -0,0 +1,29 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Lulu13022002 <41980282+Lulu13022002@users.noreply.github.com>
+Date: Sat, 10 Dec 2022 13:01:52 +0100
+Subject: [PATCH] Fix chunk snapshot biome getter
+
+Fixes SPIGOT-7188: https://hub.spigotmc.org/jira/browse/SPIGOT-7188
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/CraftChunkSnapshot.java b/src/main/java/org/bukkit/craftbukkit/CraftChunkSnapshot.java
+index 05512cc19eb213b6be5c869e133376ee42827806..c6416b3db0166374065d537e379d05da0f093b21 100644
+--- a/src/main/java/org/bukkit/craftbukkit/CraftChunkSnapshot.java
++++ b/src/main/java/org/bukkit/craftbukkit/CraftChunkSnapshot.java
+@@ -149,7 +149,7 @@ public class CraftChunkSnapshot implements ChunkSnapshot {
+         Preconditions.checkState(this.biome != null, "ChunkSnapshot created without biome. Please call getSnapshot with includeBiome=true");
+         this.validateChunkCoordinates(x, y, z);
+ 
+-        PalettedContainerRO<Holder<net.minecraft.world.level.biome.Biome>> biome = this.biome[this.getSectionIndex(y >> 2)];
++        PalettedContainerRO<Holder<net.minecraft.world.level.biome.Biome>> biome = this.biome[this.getSectionIndex(y)]; // Paper
+         return CraftBlock.biomeBaseToBiome(biomeRegistry, biome.get(x >> 2, (y & 0xF) >> 2, z >> 2));
+     }
+ 
+@@ -163,7 +163,7 @@ public class CraftChunkSnapshot implements ChunkSnapshot {
+         Preconditions.checkState(this.biome != null, "ChunkSnapshot created without biome. Please call getSnapshot with includeBiome=true");
+         this.validateChunkCoordinates(x, y, z);
+ 
+-        PalettedContainerRO<Holder<net.minecraft.world.level.biome.Biome>> biome = this.biome[this.getSectionIndex(y >> 2)];
++        PalettedContainerRO<Holder<net.minecraft.world.level.biome.Biome>> biome = this.biome[this.getSectionIndex(y)]; // Paper
+         return biome.get(x >> 2, (y & 0xF) >> 2, z >> 2).value().getTemperature(new BlockPos((this.x << 4) | x, y, (this.z << 4) | z));
+     }
+ 

patches/server/0935-Improve-inlining-for-some-hot-BlockBehavior-and-Flui.patch

@@ -0,0 +1,79 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Spottedleaf <Spottedleaf@users.noreply.github.com>
+Date: Mon, 6 Jul 2020 20:46:50 -0700
+Subject: [PATCH] Improve inlining for some hot BlockBehavior and FluidState
+ methods
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java b/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java
+index cd939384f022609c96b055c25db7e098e4256336..505503a3f59d4b747649275c6f6faa504b7c7b64 100644
+--- a/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java
++++ b/src/main/java/net/minecraft/world/level/block/state/BlockBehaviour.java
+@@ -876,15 +876,15 @@ public abstract class BlockBehaviour implements FeatureElement {
+             return this.shapeExceedsCube; // Paper - moved into shape cache init
+         }
+ 
+-        public boolean useShapeForLightOcclusion() {
++        public final boolean useShapeForLightOcclusion() { // Paper
+             return this.useShapeForLightOcclusion;
+         }
+ 
+-        public int getLightEmission() {
++        public final int getLightEmission() { // Paper
+             return this.lightEmission;
+         }
+ 
+-        public boolean isAir() {
++        public final boolean isAir() { // Paper
+             return this.isAir;
+         }
+ 
+@@ -958,7 +958,7 @@ public abstract class BlockBehaviour implements FeatureElement {
+             }
+         }
+ 
+-        public boolean canOcclude() {
++        public final boolean canOcclude() { // Paper
+             return this.canOcclude;
+         }
+ 
+@@ -1155,11 +1155,11 @@ public abstract class BlockBehaviour implements FeatureElement {
+             return this.getBlock() == block;
+         }
+ 
+-        public FluidState getFluidState() {
++        public final FluidState getFluidState() { // Paper
+             return this.fluidState;
+         }
+ 
+-        public boolean isRandomlyTicking() {
++        public final boolean isRandomlyTicking() { // Paper
+             return this.isRandomlyTicking;
+         }
+ 
+diff --git a/src/main/java/net/minecraft/world/level/material/FluidState.java b/src/main/java/net/minecraft/world/level/material/FluidState.java
+index ea2a04e5298832177fac93568656ac45784d5eb6..27f136815afc360387704fa1f2773e3816cccff6 100644
+--- a/src/main/java/net/minecraft/world/level/material/FluidState.java
++++ b/src/main/java/net/minecraft/world/level/material/FluidState.java
+@@ -26,8 +26,12 @@ public final class FluidState extends StateHolder<Fluid, FluidState> {
+     public static final int AMOUNT_MAX = 9;
+     public static final int AMOUNT_FULL = 8;
+ 
++    // Paper start
++    protected final boolean isEmpty;
++    // Paper end
+     public FluidState(Fluid fluid, ImmutableMap<Property<?>, Comparable<?>> propertiesMap, MapCodec<FluidState> codec) {
+         super(fluid, propertiesMap, codec);
++        this.isEmpty = fluid.isEmpty(); // Paper - moved from isEmpty()
+     }
+ 
+     public Fluid getType() {
+@@ -43,7 +47,7 @@ public final class FluidState extends StateHolder<Fluid, FluidState> {
+     }
+ 
+     public boolean isEmpty() {
+-        return this.getType().isEmpty();
++        return this.isEmpty; // Paper - moved into constructor
+     }
+ 
+     public float getHeight(BlockGetter world, BlockPos pos) {

patches/server/0936-Fix-MapLike-Codec-missing-key-selector.patch

@@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Fri, 9 Dec 2022 12:11:39 -0800
+Subject: [PATCH] Fix MapLike Codec missing key 'selector'
+
+
+diff --git a/src/main/java/net/minecraft/world/level/gameevent/vibrations/VibrationListener.java b/src/main/java/net/minecraft/world/level/gameevent/vibrations/VibrationListener.java
+index 586d0a40cc4f36e80236e87232bb58f81ec089a5..103e12ec589dcbe6dbad7432b50e0644c3a37b1b 100644
+--- a/src/main/java/net/minecraft/world/level/gameevent/vibrations/VibrationListener.java
++++ b/src/main/java/net/minecraft/world/level/gameevent/vibrations/VibrationListener.java
+@@ -99,7 +99,7 @@ public class VibrationListener implements GameEventListener {
+                 return vibrationlistener.listenerRange;
+             }), VibrationInfo.CODEC.optionalFieldOf("event").forGetter((vibrationlistener) -> {
+                 return Optional.ofNullable(vibrationlistener.currentVibration);
+-            }), VibrationSelector.CODEC.fieldOf("selector").forGetter((vibrationlistener) -> {
++            }), Codec.optionalField("selector", VibrationSelector.CODEC).xmap(o -> o.orElseGet(VibrationSelector::new), Optional::of).forGetter((vibrationlistener) -> { // Paper - fix MapLike spam for missing "selector" in 1.19.2
+                 return vibrationlistener.selectionStrategy;
+             }), ExtraCodecs.NON_NEGATIVE_INT.fieldOf("event_delay").orElse(0).forGetter((vibrationlistener) -> {
+                 return vibrationlistener.travelTimeInTicks;

patches/server/0937-Fix-inconsistencies-in-dispense-events-regarding-sta.patch

@@ -0,0 +1,525 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Sun, 11 Dec 2022 23:47:22 -0800
+Subject: [PATCH] Fix inconsistencies in dispense events regarding stack size
+
+The javadocs for BlockDispenseEvent suggest the ItemStack is a single
+item which is being dispensed. Before this fix, sometimes it was the whole
+stack before a single item had been taken. This fixes that so the stack size
+is always 1.
+
+diff --git a/src/main/java/net/minecraft/core/dispenser/AbstractProjectileDispenseBehavior.java b/src/main/java/net/minecraft/core/dispenser/AbstractProjectileDispenseBehavior.java
+index 2542cf94ac76871f4ff02c3524e8606c96f50cc7..309ad5a1da6b3a297d5526cd9247359ac5f49406 100644
+--- a/src/main/java/net/minecraft/core/dispenser/AbstractProjectileDispenseBehavior.java
++++ b/src/main/java/net/minecraft/core/dispenser/AbstractProjectileDispenseBehavior.java
+@@ -28,7 +28,7 @@ public abstract class AbstractProjectileDispenseBehavior extends DefaultDispense
+ 
+         // CraftBukkit start
+         // iprojectile.shoot((double) enumdirection.getStepX(), (double) ((float) enumdirection.getStepY() + 0.1F), (double) enumdirection.getStepZ(), this.getPower(), this.getUncertainty());
+-        ItemStack itemstack1 = stack.split(1);
++        ItemStack itemstack1 = stack.copyWithCount(1); // Paper - shrink below and single item in event
+         org.bukkit.block.Block block = worldserver.getWorld().getBlockAt(pointer.getPos().getX(), pointer.getPos().getY(), pointer.getPos().getZ());
+         CraftItemStack craftItem = CraftItemStack.asCraftMirror(itemstack1);
+ 
+@@ -38,12 +38,13 @@ public abstract class AbstractProjectileDispenseBehavior extends DefaultDispense
+         }
+ 
+         if (event.isCancelled()) {
+-            stack.grow(1);
++            // stack.grow(1); // Paper - shrink below
+             return stack;
+         }
+ 
++        boolean shrink = true; // Paper
+         if (!event.getItem().equals(craftItem)) {
+-            stack.grow(1);
++            shrink = false; // Paper - shrink below
+             // Chain to handler for new item
+             ItemStack eventStack = CraftItemStack.asNMSCopy(event.getItem());
+             DispenseItemBehavior idispensebehavior = (DispenseItemBehavior) DispenserBlock.DISPENSER_REGISTRY.get(eventStack.getItem());
+@@ -57,7 +58,7 @@ public abstract class AbstractProjectileDispenseBehavior extends DefaultDispense
+         ((Entity) iprojectile).projectileSource = new org.bukkit.craftbukkit.projectiles.CraftBlockProjectileSource((DispenserBlockEntity) pointer.getEntity());
+         // CraftBukkit end
+         worldserver.addFreshEntity(iprojectile);
+-        // itemstack.shrink(1); // CraftBukkit - Handled during event processing
++        if (shrink) stack.shrink(1); // Paper - actually handle here
+         return stack;
+     }
+ 
+diff --git a/src/main/java/net/minecraft/core/dispenser/BoatDispenseItemBehavior.java b/src/main/java/net/minecraft/core/dispenser/BoatDispenseItemBehavior.java
+index eb55015f4c867fbf08430288744f58a3b9d86e89..958134519befadc27a5b647caf64acf272ee2db4 100644
+--- a/src/main/java/net/minecraft/core/dispenser/BoatDispenseItemBehavior.java
++++ b/src/main/java/net/minecraft/core/dispenser/BoatDispenseItemBehavior.java
+@@ -53,7 +53,7 @@ public class BoatDispenseItemBehavior extends DefaultDispenseItemBehavior {
+ 
+         // EntityBoat entityboat = new EntityBoat(worldserver, d0, d1 + d3, d2);
+         // CraftBukkit start
+-        ItemStack itemstack1 = stack.split(1);
++        ItemStack itemstack1 = stack.copyWithCount(1); // Paper - shrink at end and single item in event
+         org.bukkit.block.Block block = worldserver.getWorld().getBlockAt(pointer.getPos().getX(), pointer.getPos().getY(), pointer.getPos().getZ());
+         CraftItemStack craftItem = CraftItemStack.asCraftMirror(itemstack1);
+ 
+@@ -63,12 +63,13 @@ public class BoatDispenseItemBehavior extends DefaultDispenseItemBehavior {
+         }
+ 
+         if (event.isCancelled()) {
+-            stack.grow(1);
++            // stack.grow(1); // Paper - shrink below
+             return stack;
+         }
+ 
++        boolean shrink = true; // Paper
+         if (!event.getItem().equals(craftItem)) {
+-            stack.grow(1);
++            shrink = false; // Paper - shrink below
+             // Chain to handler for new item
+             ItemStack eventStack = CraftItemStack.asNMSCopy(event.getItem());
+             DispenseItemBehavior idispensebehavior = (DispenseItemBehavior) DispenserBlock.DISPENSER_REGISTRY.get(eventStack.getItem());
+@@ -83,8 +84,7 @@ public class BoatDispenseItemBehavior extends DefaultDispenseItemBehavior {
+ 
+         ((Boat) object).setVariant(this.type);
+         ((Boat) object).setYRot(enumdirection.toYRot());
+-        if (!worldserver.addFreshEntity((Entity) object)) stack.grow(1); // CraftBukkit
+-        // itemstack.shrink(1); // CraftBukkit - handled during event processing
++        if (worldserver.addFreshEntity((Entity) object) && shrink) stack.shrink(1); // Paper - if entity add was successful and supposed to shrink
+         return stack;
+     }
+ 
+diff --git a/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java b/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java
+index 6b5602a6b112c579cd39fffd167f316ea96511f5..9598aa381978194fee859721731196f0e6ee08fc 100644
+--- a/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java
++++ b/src/main/java/net/minecraft/core/dispenser/DispenseItemBehavior.java
+@@ -217,7 +217,7 @@ public interface DispenseItemBehavior {
+ 
+                 // CraftBukkit start
+                 ServerLevel worldserver = pointer.getLevel();
+-                ItemStack itemstack1 = stack.split(1);
++                ItemStack itemstack1 = stack.copyWithCount(1); // Paper - shrink below and single item in event
+                 org.bukkit.block.Block block = worldserver.getWorld().getBlockAt(pointer.getPos().getX(), pointer.getPos().getY(), pointer.getPos().getZ());
+                 CraftItemStack craftItem = CraftItemStack.asCraftMirror(itemstack1);
+ 
+@@ -227,12 +227,13 @@ public interface DispenseItemBehavior {
+                 }
+ 
+                 if (event.isCancelled()) {
+-                    stack.grow(1);
++                    // stack.grow(1); // Paper - shrink below
+                     return stack;
+                 }
+ 
++                boolean shrink = true; // Paper
+                 if (!event.getItem().equals(craftItem)) {
+-                    stack.grow(1);
++                    shrink = false; // Paper - shrink below
+                     // Chain to handler for new item
+                     ItemStack eventStack = CraftItemStack.asNMSCopy(event.getItem());
+                     DispenseItemBehavior idispensebehavior = (DispenseItemBehavior) DispenserBlock.DISPENSER_REGISTRY.get(eventStack.getItem());
+@@ -249,7 +250,7 @@ public interface DispenseItemBehavior {
+                     return ItemStack.EMPTY;
+                 }
+ 
+-                // itemstack.shrink(1); // Handled during event processing
++                if (shrink) stack.shrink(1); // Paper - actually handle here
+                 // CraftBukkit end
+                 pointer.getLevel().gameEvent((Entity) null, GameEvent.ENTITY_PLACE, pointer.getPos());
+                 return stack;
+@@ -271,7 +272,7 @@ public interface DispenseItemBehavior {
+                 ServerLevel worldserver = pointer.getLevel();
+ 
+                 // CraftBukkit start
+-                ItemStack itemstack1 = stack.split(1);
++                ItemStack itemstack1 = stack.copyWithCount(1); // Paper - shrink below and single item in event
+                 org.bukkit.block.Block block = worldserver.getWorld().getBlockAt(pointer.getPos().getX(), pointer.getPos().getY(), pointer.getPos().getZ());
+                 CraftItemStack craftItem = CraftItemStack.asCraftMirror(itemstack1);
+ 
+@@ -281,12 +282,13 @@ public interface DispenseItemBehavior {
+                 }
+ 
+                 if (event.isCancelled()) {
+-                    stack.grow(1);
++                    // stack.grow(1); // Paper - shrink below
+                     return stack;
+                 }
+ 
++                boolean shrink = true; // Paper
+                 if (!event.getItem().equals(craftItem)) {
+-                    stack.grow(1);
++                    shrink = false; // Paper - shrink below
+                     // Chain to handler for new item
+                     ItemStack eventStack = CraftItemStack.asNMSCopy(event.getItem());
+                     DispenseItemBehavior idispensebehavior = (DispenseItemBehavior) DispenserBlock.DISPENSER_REGISTRY.get(eventStack.getItem());
+@@ -303,7 +305,7 @@ public interface DispenseItemBehavior {
+                 ArmorStand entityarmorstand = (ArmorStand) EntityType.ARMOR_STAND.spawn(worldserver, stack.getTag(), consumer, blockposition, MobSpawnType.DISPENSER, false, false);
+ 
+                 if (entityarmorstand != null) {
+-                    // itemstack.shrink(1); // CraftBukkit - Handled during event processing
++                    if (shrink) stack.shrink(1); // Paper - actually handle here
+                 }
+ 
+                 return stack;
+@@ -325,7 +327,7 @@ public interface DispenseItemBehavior {
+ 
+                 if (!list.isEmpty()) {
+                     // CraftBukkit start
+-                    ItemStack itemstack1 = stack.split(1);
++                    ItemStack itemstack1 = stack.copyWithCount(1); // Paper - shrink below and single item in event
+                     Level world = pointer.getLevel();
+                     org.bukkit.block.Block block = world.getWorld().getBlockAt(pointer.getPos().getX(), pointer.getPos().getY(), pointer.getPos().getZ());
+                     CraftItemStack craftItem = CraftItemStack.asCraftMirror(itemstack1);
+@@ -336,12 +338,13 @@ public interface DispenseItemBehavior {
+                     }
+ 
+                     if (event.isCancelled()) {
+-                        stack.grow(1);
++                        // stack.grow(1); // Paper - shrink below
+                         return stack;
+                     }
+ 
++                    boolean shrink = true; // Paper
+                     if (!event.getItem().equals(craftItem)) {
+-                        stack.grow(1);
++                        shrink = false; // Paper - shrink below
+                         // Chain to handler for new item
+                         ItemStack eventStack = CraftItemStack.asNMSCopy(event.getItem());
+                         DispenseItemBehavior idispensebehavior = (DispenseItemBehavior) DispenserBlock.DISPENSER_REGISTRY.get(eventStack.getItem());
+@@ -352,7 +355,7 @@ public interface DispenseItemBehavior {
+                     }
+                     // CraftBukkit end
+                     ((Saddleable) list.get(0)).equipSaddle(SoundSource.BLOCKS, CraftItemStack.asNMSCopy(event.getItem())); // Paper - Fix saddles losing nbt data - MC-191591
+-                    // itemstack.shrink(1); // CraftBukkit - handled above
++                    if (shrink) stack.shrink(1); // Paper - actually handle here
+                     this.setSuccess(true);
+                     return stack;
+                 } else {
+@@ -380,7 +383,7 @@ public interface DispenseItemBehavior {
+                 } while (!entityhorseabstract.isArmor(stack) || entityhorseabstract.isWearingArmor() || !entityhorseabstract.isTamed());
+ 
+                 // CraftBukkit start
+-                ItemStack itemstack1 = stack.split(1);
++                ItemStack itemstack1 = stack.copyWithCount(1); // Paper - shrink below and single item in event
+                 Level world = pointer.getLevel();
+                 org.bukkit.block.Block block = world.getWorld().getBlockAt(pointer.getPos().getX(), pointer.getPos().getY(), pointer.getPos().getZ());
+                 CraftItemStack craftItem = CraftItemStack.asCraftMirror(itemstack1);
+@@ -391,12 +394,13 @@ public interface DispenseItemBehavior {
+                 }
+ 
+                 if (event.isCancelled()) {
+-                    stack.grow(1);
++                    // stack.grow(1); // Paper - shrink below
+                     return stack;
+                 }
+ 
++                boolean shrink = true; // Paper
+                 if (!event.getItem().equals(craftItem)) {
+-                    stack.grow(1);
++                    shrink = false; // Paper - shrink below
+                     // Chain to handler for new item
+                     ItemStack eventStack = CraftItemStack.asNMSCopy(event.getItem());
+                     DispenseItemBehavior idispensebehavior = (DispenseItemBehavior) DispenserBlock.DISPENSER_REGISTRY.get(eventStack.getItem());
+@@ -406,6 +410,7 @@ public interface DispenseItemBehavior {
+                     }
+                 }
+ 
++                if (shrink) stack.shrink(1); // Paper - shrink here
+                 entityhorseabstract.getSlot(401).set(CraftItemStack.asNMSCopy(event.getItem()));
+                 // CraftBukkit end
+                 this.setSuccess(true);
+@@ -452,7 +457,7 @@ public interface DispenseItemBehavior {
+                     entityhorsechestedabstract = (AbstractChestedHorse) iterator1.next();
+                     // CraftBukkit start
+                 } while (!entityhorsechestedabstract.isTamed());
+-                ItemStack itemstack1 = stack.split(1);
++                ItemStack itemstack1 = stack.copyWithCount(1); // Paper - shrink below
+                 Level world = pointer.getLevel();
+                 org.bukkit.block.Block block = world.getWorld().getBlockAt(pointer.getPos().getX(), pointer.getPos().getY(), pointer.getPos().getZ());
+                 CraftItemStack craftItem = CraftItemStack.asCraftMirror(itemstack1);
+@@ -463,10 +468,13 @@ public interface DispenseItemBehavior {
+                 }
+ 
+                 if (event.isCancelled()) {
++                    // stack.grow(1); // Paper - shrink below (this was actually missing and should be here, added it commented out just for less confusion)
+                     return stack;
+                 }
+ 
++                boolean shrink = true; // Paper
+                 if (!event.getItem().equals(craftItem)) {
++                    shrink = false; // Paper - shrink below (this was actually missing and should be here, added it commented out just for less confusion)
+                     // Chain to handler for new item
+                     ItemStack eventStack = CraftItemStack.asNMSCopy(event.getItem());
+                     DispenseItemBehavior idispensebehavior = (DispenseItemBehavior) DispenserBlock.DISPENSER_REGISTRY.get(eventStack.getItem());
+@@ -478,7 +486,7 @@ public interface DispenseItemBehavior {
+                 entityhorsechestedabstract.getSlot(499).set(CraftItemStack.asNMSCopy(event.getItem()));
+                 // CraftBukkit end
+ 
+-                // itemstack.shrink(1); // CraftBukkit - handled above
++                if (shrink) stack.shrink(1); // Paper - actually handle here
+                 this.setSuccess(true);
+                 return stack;
+             }
+@@ -489,7 +497,7 @@ public interface DispenseItemBehavior {
+                 Direction enumdirection = (Direction) pointer.getBlockState().getValue(DispenserBlock.FACING);
+                 // CraftBukkit start
+                 ServerLevel worldserver = pointer.getLevel();
+-                ItemStack itemstack1 = stack.split(1);
++                ItemStack itemstack1 = stack.copyWithCount(1); // Paper - shrink below and single item in event
+                 org.bukkit.block.Block block = worldserver.getWorld().getBlockAt(pointer.getPos().getX(), pointer.getPos().getY(), pointer.getPos().getZ());
+                 CraftItemStack craftItem = CraftItemStack.asCraftMirror(itemstack1);
+ 
+@@ -499,12 +507,13 @@ public interface DispenseItemBehavior {
+                 }
+ 
+                 if (event.isCancelled()) {
+-                    stack.grow(1);
++                    // stack.grow(1); // Paper - shrink below
+                     return stack;
+                 }
+ 
++                boolean shrink = true; // Paper
+                 if (!event.getItem().equals(craftItem)) {
+-                    stack.grow(1);
++                    shrink = false; // Paper - shrink below
+                     // Chain to handler for new item
+                     ItemStack eventStack = CraftItemStack.asNMSCopy(event.getItem());
+                     DispenseItemBehavior idispensebehavior = (DispenseItemBehavior) DispenserBlock.DISPENSER_REGISTRY.get(eventStack.getItem());
+@@ -521,7 +530,7 @@ public interface DispenseItemBehavior {
+                 DispenseItemBehavior.setEntityPokingOutOfBlock(pointer, entityfireworks, enumdirection);
+                 entityfireworks.shoot((double) enumdirection.getStepX(), (double) enumdirection.getStepY(), (double) enumdirection.getStepZ(), 0.5F, 1.0F);
+                 pointer.getLevel().addFreshEntity(entityfireworks);
+-                // itemstack.shrink(1); // Handled during event processing
++                if (shrink) stack.shrink(1); // Paper - actually handle here
+                 // CraftBukkit end
+                 return stack;
+             }
+@@ -546,7 +555,7 @@ public interface DispenseItemBehavior {
+                 double d5 = randomsource.triangle((double) enumdirection.getStepZ(), 0.11485000000000001D);
+ 
+                 // CraftBukkit start
+-                ItemStack itemstack1 = stack.split(1);
++                ItemStack itemstack1 = stack.copyWithCount(1); // Paper - shrink below and single item in event
+                 org.bukkit.block.Block block = worldserver.getWorld().getBlockAt(pointer.getPos().getX(), pointer.getPos().getY(), pointer.getPos().getZ());
+                 CraftItemStack craftItem = CraftItemStack.asCraftMirror(itemstack1);
+ 
+@@ -556,12 +565,13 @@ public interface DispenseItemBehavior {
+                 }
+ 
+                 if (event.isCancelled()) {
+-                    stack.grow(1);
++                    // stack.grow(1); // Paper - shrink at end
+                     return stack;
+                 }
+ 
++                boolean shrink = true; // Paper
+                 if (!event.getItem().equals(craftItem)) {
+-                    stack.grow(1);
++                    shrink = false; // Paper - shrink at end
+                     // Chain to handler for new item
+                     ItemStack eventStack = CraftItemStack.asNMSCopy(event.getItem());
+                     DispenseItemBehavior idispensebehavior = (DispenseItemBehavior) DispenserBlock.DISPENSER_REGISTRY.get(eventStack.getItem());
+@@ -576,7 +586,7 @@ public interface DispenseItemBehavior {
+                 entitysmallfireball.projectileSource = new org.bukkit.craftbukkit.projectiles.CraftBlockProjectileSource((DispenserBlockEntity) pointer.getEntity());
+ 
+                 worldserver.addFreshEntity(entitysmallfireball);
+-                // itemstack.shrink(1); // Handled during event processing
++                if (shrink) stack.shrink(1); // Paper - actually handle here
+                 // CraftBukkit end
+                 return stack;
+             }
+@@ -621,7 +631,7 @@ public interface DispenseItemBehavior {
+                 Material material = iblockdata.getMaterial();
+                 if (worldserver.isEmptyBlock(blockposition) || !material.isSolid() || material.isReplaceable() || (dispensiblecontaineritem instanceof BucketItem && iblockdata.getBlock() instanceof LiquidBlockContainer && ((LiquidBlockContainer) iblockdata.getBlock()).canPlaceLiquid(worldserver, blockposition, iblockdata, ((BucketItem) dispensiblecontaineritem).content))) {
+                     org.bukkit.block.Block block = worldserver.getWorld().getBlockAt(pointer.getPos().getX(), pointer.getPos().getY(), pointer.getPos().getZ());
+-                    CraftItemStack craftItem = CraftItemStack.asCraftMirror(stack);
++                    CraftItemStack craftItem = CraftItemStack.asCraftMirror(stack.copyWithCount(1)); // Paper - single item in event
+ 
+                     BlockDispenseEvent event = new BlockDispenseEvent(block, craftItem.clone(), new org.bukkit.util.Vector(x, y, z));
+                     if (!DispenserBlock.eventFired) {
+@@ -694,7 +704,7 @@ public interface DispenseItemBehavior {
+ 
+                         // CraftBukkit start
+                         org.bukkit.block.Block bukkitBlock = worldserver.getWorld().getBlockAt(pointer.getPos().getX(), pointer.getPos().getY(), pointer.getPos().getZ());
+-                        CraftItemStack craftItem = CraftItemStack.asCraftMirror(stack);
++                        CraftItemStack craftItem = CraftItemStack.asCraftMirror(stack.copyWithCount(1)); // Paper - single item in event
+ 
+                         BlockDispenseEvent event = new BlockDispenseEvent(bukkitBlock, craftItem.clone(), new org.bukkit.util.Vector(blockposition.getX(), blockposition.getY(), blockposition.getZ()));
+                         if (!DispenserBlock.eventFired) {
+@@ -741,7 +751,7 @@ public interface DispenseItemBehavior {
+ 
+                 // CraftBukkit start
+                 org.bukkit.block.Block bukkitBlock = worldserver.getWorld().getBlockAt(pointer.getPos().getX(), pointer.getPos().getY(), pointer.getPos().getZ());
+-                CraftItemStack craftItem = CraftItemStack.asCraftMirror(stack);
++                CraftItemStack craftItem = CraftItemStack.asCraftMirror(stack); // Paper - ignore stack size on damageable items
+ 
+                 BlockDispenseEvent event = new BlockDispenseEvent(bukkitBlock, craftItem.clone(), new org.bukkit.util.Vector(0, 0, 0));
+                 if (!DispenserBlock.eventFired) {
+@@ -802,7 +812,7 @@ public interface DispenseItemBehavior {
+                 BlockPos blockposition = pointer.getPos().relative((Direction) pointer.getBlockState().getValue(DispenserBlock.FACING));
+                 // CraftBukkit start
+                 org.bukkit.block.Block block = worldserver.getWorld().getBlockAt(pointer.getPos().getX(), pointer.getPos().getY(), pointer.getPos().getZ());
+-                CraftItemStack craftItem = CraftItemStack.asCraftMirror(stack);
++                CraftItemStack craftItem = CraftItemStack.asCraftMirror(stack.copyWithCount(1)); // Paper - single item in event
+ 
+                 BlockDispenseEvent event = new BlockDispenseEvent(block, craftItem.clone(), new org.bukkit.util.Vector(0, 0, 0));
+                 if (!DispenserBlock.eventFired) {
+@@ -868,7 +878,7 @@ public interface DispenseItemBehavior {
+                 // CraftBukkit start
+                 // EntityTNTPrimed entitytntprimed = new EntityTNTPrimed(worldserver, (double) blockposition.getX() + 0.5D, (double) blockposition.getY(), (double) blockposition.getZ() + 0.5D, (EntityLiving) null);
+ 
+-                ItemStack itemstack1 = stack.split(1);
++                ItemStack itemstack1 = stack.copyWithCount(1); // Paper - shrink at end and single item in event
+                 org.bukkit.block.Block block = worldserver.getWorld().getBlockAt(pointer.getPos().getX(), pointer.getPos().getY(), pointer.getPos().getZ());
+                 CraftItemStack craftItem = CraftItemStack.asCraftMirror(itemstack1);
+ 
+@@ -878,12 +888,13 @@ public interface DispenseItemBehavior {
+                 }
+ 
+                 if (event.isCancelled()) {
+-                    stack.grow(1);
++                    // stack.grow(1); // Paper - shrink below
+                     return stack;
+                 }
+ 
++                boolean shrink = true; // Paper
+                 if (!event.getItem().equals(craftItem)) {
+-                    stack.grow(1);
++                    shrink = false; // Paper - shrink below
+                     // Chain to handler for new item
+                     ItemStack eventStack = CraftItemStack.asNMSCopy(event.getItem());
+                     DispenseItemBehavior idispensebehavior = (DispenseItemBehavior) DispenserBlock.DISPENSER_REGISTRY.get(eventStack.getItem());
+@@ -899,7 +910,7 @@ public interface DispenseItemBehavior {
+                 worldserver.addFreshEntity(entitytntprimed);
+                 worldserver.playSound((Player) null, entitytntprimed.getX(), entitytntprimed.getY(), entitytntprimed.getZ(), SoundEvents.TNT_PRIMED, SoundSource.BLOCKS, 1.0F, 1.0F);
+                 worldserver.gameEvent((Entity) null, GameEvent.ENTITY_PLACE, blockposition);
+-                // itemstack.shrink(1); // CraftBukkit - handled above
++                if (shrink) stack.shrink(1); // Paper - actually handle here
+                 return stack;
+             }
+         });
+@@ -926,7 +937,7 @@ public interface DispenseItemBehavior {
+ 
+                 // CraftBukkit start
+                 org.bukkit.block.Block bukkitBlock = worldserver.getWorld().getBlockAt(pointer.getPos().getX(), pointer.getPos().getY(), pointer.getPos().getZ());
+-                CraftItemStack craftItem = CraftItemStack.asCraftMirror(stack);
++                CraftItemStack craftItem = CraftItemStack.asCraftMirror(stack.copyWithCount(1)); // Paper - single item in event
+ 
+                 BlockDispenseEvent event = new BlockDispenseEvent(bukkitBlock, craftItem.clone(), new org.bukkit.util.Vector(blockposition.getX(), blockposition.getY(), blockposition.getZ()));
+                 if (!DispenserBlock.eventFired) {
+@@ -975,7 +986,7 @@ public interface DispenseItemBehavior {
+ 
+                 // CraftBukkit start
+                 org.bukkit.block.Block bukkitBlock = worldserver.getWorld().getBlockAt(pointer.getPos().getX(), pointer.getPos().getY(), pointer.getPos().getZ());
+-                CraftItemStack craftItem = CraftItemStack.asCraftMirror(stack);
++                CraftItemStack craftItem = CraftItemStack.asCraftMirror(stack.copyWithCount(1)); // Paper - single item in event
+ 
+                 BlockDispenseEvent event = new BlockDispenseEvent(bukkitBlock, craftItem.clone(), new org.bukkit.util.Vector(blockposition.getX(), blockposition.getY(), blockposition.getZ()));
+                 if (!DispenserBlock.eventFired) {
+@@ -1048,7 +1059,7 @@ public interface DispenseItemBehavior {
+ 
+                 // CraftBukkit start
+                 org.bukkit.block.Block bukkitBlock = worldserver.getWorld().getBlockAt(pointer.getPos().getX(), pointer.getPos().getY(), pointer.getPos().getZ());
+-                CraftItemStack craftItem = CraftItemStack.asCraftMirror(stack);
++                CraftItemStack craftItem = CraftItemStack.asCraftMirror(stack.copyWithCount(1)); // Paper - only single item in event
+ 
+                 BlockDispenseEvent event = new BlockDispenseEvent(bukkitBlock, craftItem.clone(), new org.bukkit.util.Vector(blockposition.getX(), blockposition.getY(), blockposition.getZ()));
+                 if (!DispenserBlock.eventFired) {
+diff --git a/src/main/java/net/minecraft/core/dispenser/ShearsDispenseItemBehavior.java b/src/main/java/net/minecraft/core/dispenser/ShearsDispenseItemBehavior.java
+index 2366d411bf64f88c7296e888cd3bf584825ae4a9..d1127d93a85a837933d0d73c24cacac4adc3a5b9 100644
+--- a/src/main/java/net/minecraft/core/dispenser/ShearsDispenseItemBehavior.java
++++ b/src/main/java/net/minecraft/core/dispenser/ShearsDispenseItemBehavior.java
+@@ -37,7 +37,7 @@ public class ShearsDispenseItemBehavior extends OptionalDispenseItemBehavior {
+         ServerLevel worldserver = pointer.getLevel();
+         // CraftBukkit start
+         org.bukkit.block.Block bukkitBlock = worldserver.getWorld().getBlockAt(pointer.getPos().getX(), pointer.getPos().getY(), pointer.getPos().getZ());
+-        CraftItemStack craftItem = CraftItemStack.asCraftMirror(stack);
++        CraftItemStack craftItem = CraftItemStack.asCraftMirror(stack); // Paper - ignore stack size on damageable items
+ 
+         BlockDispenseEvent event = new BlockDispenseEvent(bukkitBlock, craftItem.clone(), new org.bukkit.util.Vector(0, 0, 0));
+         if (!DispenserBlock.eventFired) {
+diff --git a/src/main/java/net/minecraft/core/dispenser/ShulkerBoxDispenseBehavior.java b/src/main/java/net/minecraft/core/dispenser/ShulkerBoxDispenseBehavior.java
+index 38b5d8f7b66f5130dbd126957a4a1e59ec543e4a..0159ed9cbc644c39fa79e62327f13375193fdc98 100644
+--- a/src/main/java/net/minecraft/core/dispenser/ShulkerBoxDispenseBehavior.java
++++ b/src/main/java/net/minecraft/core/dispenser/ShulkerBoxDispenseBehavior.java
+@@ -34,7 +34,7 @@ public class ShulkerBoxDispenseBehavior extends OptionalDispenseItemBehavior {
+ 
+             // CraftBukkit start
+             org.bukkit.block.Block bukkitBlock = pointer.getLevel().getWorld().getBlockAt(pointer.getPos().getX(), pointer.getPos().getY(), pointer.getPos().getZ());
+-            CraftItemStack craftItem = CraftItemStack.asCraftMirror(stack);
++            CraftItemStack craftItem = CraftItemStack.asCraftMirror(stack.copyWithCount(1)); // Paper - single item in event
+ 
+             BlockDispenseEvent event = new BlockDispenseEvent(bukkitBlock, craftItem.clone(), new org.bukkit.util.Vector(blockposition.getX(), blockposition.getY(), blockposition.getZ()));
+             if (!DispenserBlock.eventFired) {
+diff --git a/src/main/java/net/minecraft/world/item/ArmorItem.java b/src/main/java/net/minecraft/world/item/ArmorItem.java
+index 98aae5bb3cff07fcc081ad4d6c2be8728f3d1637..d7a0cbde8f8c99276307502674c71463fbe7e89c 100644
+--- a/src/main/java/net/minecraft/world/item/ArmorItem.java
++++ b/src/main/java/net/minecraft/world/item/ArmorItem.java
+@@ -61,7 +61,7 @@ public class ArmorItem extends Item implements Equipable {
+         } else {
+             LivingEntity entityliving = (LivingEntity) list.get(0);
+             EquipmentSlot enumitemslot = Mob.getEquipmentSlotForItem(armor);
+-            ItemStack itemstack1 = armor.split(1);
++            ItemStack itemstack1 = armor.copyWithCount(1); // Paper - shrink below and single item in event
+             // CraftBukkit start
+             Level world = pointer.getLevel();
+             org.bukkit.block.Block block = world.getWorld().getBlockAt(pointer.getPos().getX(), pointer.getPos().getY(), pointer.getPos().getZ());
+@@ -73,12 +73,13 @@ public class ArmorItem extends Item implements Equipable {
+             }
+ 
+             if (event.isCancelled()) {
+-                armor.grow(1);
++                // armor.grow(1); // Paper - shrink below
+                 return false;
+             }
+ 
++            boolean shrink = true; // Paper
+             if (!event.getItem().equals(craftItem)) {
+-                armor.grow(1);
++                shrink = false; // Paper - shrink below
+                 // Chain to handler for new item
+                 ItemStack eventStack = CraftItemStack.asNMSCopy(event.getItem());
+                 DispenseItemBehavior idispensebehavior = (DispenseItemBehavior) DispenserBlock.DISPENSER_REGISTRY.get(eventStack.getItem());
+@@ -95,6 +96,7 @@ public class ArmorItem extends Item implements Equipable {
+                 ((Mob) entityliving).setPersistenceRequired();
+             }
+ 
++            if (shrink) armor.shrink(1); // Paper
+             return true;
+         }
+     }
+diff --git a/src/main/java/net/minecraft/world/item/MinecartItem.java b/src/main/java/net/minecraft/world/item/MinecartItem.java
+index 127a799f7848b32664b77bf67847ca6b8ac9a90d..c6d2f764efa9b8bec730bbe757d480e365b25ccc 100644
+--- a/src/main/java/net/minecraft/world/item/MinecartItem.java
++++ b/src/main/java/net/minecraft/world/item/MinecartItem.java
+@@ -62,7 +62,7 @@ public class MinecartItem extends Item {
+ 
+             // CraftBukkit start
+             // EntityMinecartAbstract entityminecartabstract = EntityMinecartAbstract.createMinecart(worldserver, d0, d1 + d3, d2, ((ItemMinecart) itemstack.getItem()).type);
+-            ItemStack itemstack1 = stack.split(1);
++            ItemStack itemstack1 = stack.copyWithCount(1); // Paper - shrink below and single item in event
+             org.bukkit.block.Block block2 = worldserver.getWorld().getBlockAt(pointer.getPos().getX(), pointer.getPos().getY(), pointer.getPos().getZ());
+             CraftItemStack craftItem = CraftItemStack.asCraftMirror(itemstack1);
+ 
+@@ -72,12 +72,13 @@ public class MinecartItem extends Item {
+             }
+ 
+             if (event.isCancelled()) {
+-                stack.grow(1);
++                // stack.grow(1); // Paper - shrink below
+                 return stack;
+             }
+ 
++            boolean shrink = true; // Paper
+             if (!event.getItem().equals(craftItem)) {
+-                stack.grow(1);
++                shrink = false; // Paper - shrink below
+                 // Chain to handler for new item
+                 ItemStack eventStack = CraftItemStack.asNMSCopy(event.getItem());
+                 DispenseItemBehavior idispensebehavior = (DispenseItemBehavior) DispenserBlock.DISPENSER_REGISTRY.get(eventStack.getItem());
+@@ -94,8 +95,7 @@ public class MinecartItem extends Item {
+                 entityminecartabstract.setCustomName(stack.getHoverName());
+             }
+ 
+-            if (!worldserver.addFreshEntity(entityminecartabstract)) stack.grow(1);
+-            // itemstack.shrink(1); // CraftBukkit - handled during event processing
++            if (worldserver.addFreshEntity(entityminecartabstract) && shrink) stack.shrink(1); // Paper - actually handle here
+             // CraftBukkit end
+             return stack;
+         }

patches/server/0938-Improve-logging-and-errors.patch

@@ -0,0 +1,44 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Wed, 14 Dec 2022 15:52:11 -0800
+Subject: [PATCH] Improve logging and errors
+
+
+diff --git a/src/main/java/net/minecraft/server/packs/PathPackResources.java b/src/main/java/net/minecraft/server/packs/PathPackResources.java
+index 0232c29d96e1021a9f5a9678996993dc55fe7254..8ad8ad1189d7cdb58caaa39c482d32685afa3f9a 100644
+--- a/src/main/java/net/minecraft/server/packs/PathPackResources.java
++++ b/src/main/java/net/minecraft/server/packs/PathPackResources.java
+@@ -105,6 +105,12 @@ public class PathPackResources extends AbstractPackResources {
+         try (DirectoryStream<Path> directoryStream = Files.newDirectoryStream(path)) {
+             for(Path path2 : directoryStream) {
+                 String string = path2.getFileName().toString();
++                // Paper start
++                if (!Files.isDirectory(path2)) {
++                    LOGGER.error("Invalid directory entry: {} in {}.", string, this.root, new java.nio.file.NotDirectoryException(string));
++                    continue;
++                }
++                // Paper end
+                 if (string.equals(string.toLowerCase(Locale.ROOT))) {
+                     set.add(string);
+                 } else {
+diff --git a/src/main/java/org/bukkit/craftbukkit/legacy/CraftLegacy.java b/src/main/java/org/bukkit/craftbukkit/legacy/CraftLegacy.java
+index 6a083e269b828ef53f943cae56b029f2e0021ef1..110503062b3043cffa082a1cda6b8d57152869aa 100644
+--- a/src/main/java/org/bukkit/craftbukkit/legacy/CraftLegacy.java
++++ b/src/main/java/org/bukkit/craftbukkit/legacy/CraftLegacy.java
+@@ -44,6 +44,7 @@ import org.bukkit.material.MaterialData;
+  */
+ @Deprecated
+ public final class CraftLegacy {
++    private static final org.slf4j.Logger LOGGER = com.mojang.logging.LogUtils.getLogger(); // Paper
+ 
+     private static final Map<Byte, Material> SPAWN_EGGS = new HashMap<>();
+     private static final Set<String> whitelistedStates = new HashSet<>(Arrays.asList("explode", "check_decay", "decayable", "facing"));
+@@ -255,7 +256,7 @@ public final class CraftLegacy {
+     }
+ 
+     static {
+-        System.err.println("Initializing Legacy Material Support. Unless you have legacy plugins and/or data this is a bug!");
++        LOGGER.warn("Initializing Legacy Material Support. Unless you have legacy plugins and/or data this is a bug!"); // Paper - doesn't need to be an error
+         if (MinecraftServer.getServer() != null && MinecraftServer.getServer().isDebugging()) {
+             new Exception().printStackTrace();
+         }

patches/server/0939-Add-BlockLockCheckEvent.patch

@@ -0,0 +1,70 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Sat, 21 May 2022 20:59:45 -0700
+Subject: [PATCH] Add BlockLockCheckEvent
+
+
+diff --git a/src/main/java/net/minecraft/world/level/block/entity/BaseContainerBlockEntity.java b/src/main/java/net/minecraft/world/level/block/entity/BaseContainerBlockEntity.java
+index f1acd19432877a833f0d4339f9de4830a0f7b890..8d38ebfdc976b9695ed367591e58de8ca18f00f3 100644
+--- a/src/main/java/net/minecraft/world/level/block/entity/BaseContainerBlockEntity.java
++++ b/src/main/java/net/minecraft/world/level/block/entity/BaseContainerBlockEntity.java
+@@ -69,17 +69,44 @@ public abstract class BaseContainerBlockEntity extends BlockEntity implements Co
+     protected abstract Component getDefaultName();
+ 
+     public boolean canOpen(Player player) {
+-        return BaseContainerBlockEntity.canUnlock(player, this.lockKey, this.getDisplayName());
++        return BaseContainerBlockEntity.canUnlock(player, this.lockKey, this.getDisplayName(), this); // Paper
+     }
+ 
++    @Deprecated @io.papermc.paper.annotation.DoNotUse // Paper
+     public static boolean canUnlock(Player player, LockCode lock, Component containerName) {
++        // Paper start
++        return canUnlock(player, lock, containerName, null);
++    }
++    public static boolean canUnlock(Player player, LockCode lock, Component containerName, @Nullable BlockEntity blockEntity) {
++        if (player instanceof net.minecraft.server.level.ServerPlayer serverPlayer && blockEntity != null && blockEntity.getLevel() != null && blockEntity.getLevel().getBlockEntity(blockEntity.getBlockPos()) == blockEntity) {
++            final org.bukkit.block.Block block = org.bukkit.craftbukkit.block.CraftBlock.at(blockEntity.getLevel(), blockEntity.getBlockPos());
++            net.kyori.adventure.text.Component lockedMessage = net.kyori.adventure.text.Component.translatable("container.isLocked", io.papermc.paper.adventure.PaperAdventure.asAdventure(containerName));
++            net.kyori.adventure.sound.Sound lockedSound = net.kyori.adventure.sound.Sound.sound(org.bukkit.Sound.BLOCK_CHEST_LOCKED, net.kyori.adventure.sound.Sound.Source.BLOCK, 1.0F, 1.0F);
++            final io.papermc.paper.event.block.BlockLockCheckEvent event = new io.papermc.paper.event.block.BlockLockCheckEvent(block, (io.papermc.paper.block.LockableTileState) block.getState(), serverPlayer.getBukkitEntity(), lockedMessage, lockedSound);
++            event.callEvent();
++            if (event.getResult() == org.bukkit.event.Event.Result.ALLOW) {
++                return true;
++            } else if (event.getResult() == org.bukkit.event.Event.Result.DENY || (!player.isSpectator() && !lock.unlocksWith(event.isUsingCustomKeyItemStack() ? org.bukkit.craftbukkit.inventory.CraftItemStack.asNMSCopy(event.getKeyItem()) : player.getMainHandItem()))) {
++                if (event.getLockedMessage() != null) {
++                    event.getPlayer().sendActionBar(event.getLockedMessage());
++                }
++                if (event.getLockedSound() != null) {
++                    event.getPlayer().playSound(event.getLockedSound());
++                }
++                return false;
++            } else {
++                return true;
++            }
++        } else { // logic below is replaced by logic above
++        // Paper end
+         if (!player.isSpectator() && !lock.unlocksWith(player.getMainHandItem())) {
+-            player.displayClientMessage(Component.translatable("container.isLocked", containerName), true);
++            player.displayClientMessage(Component.translatable("container.isLocked", containerName), true); // Paper - diff on change
+             player.playNotifySound(SoundEvents.CHEST_LOCKED, SoundSource.BLOCKS, 1.0F, 1.0F);
+             return false;
+         } else {
+             return true;
+         }
++        } // Paper
+     }
+ 
+     @Nullable
+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 79a7178ff474c516eada83f2be3e1bb0eacb368c..ef740d1ad6352ca4af299001a081b720bc472d2e 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
+@@ -444,7 +444,7 @@ public class BeaconBlockEntity extends BlockEntity implements MenuProvider, Name
+     @Nullable
+     @Override
+     public AbstractContainerMenu createMenu(int syncId, Inventory playerInventory, Player player) {
+-        return BaseContainerBlockEntity.canUnlock(player, this.lockKey, this.getDisplayName()) ? new BeaconMenu(syncId, playerInventory, this.dataAccess, ContainerLevelAccess.create(this.level, this.getBlockPos())) : null;
++        return BaseContainerBlockEntity.canUnlock(player, this.lockKey, this.getDisplayName(), this) ? new BeaconMenu(syncId, playerInventory, this.dataAccess, ContainerLevelAccess.create(this.level, this.getBlockPos())) : null;
+     }
+ 
+     @Override

patches/server/0940-Add-Sneaking-API-for-Entities.patch

@@ -0,0 +1,29 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: dawon <dawon@dawon.eu>
+Date: Wed, 19 Oct 2022 23:31:53 +0200
+Subject: [PATCH] Add Sneaking API for Entities
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+index b6fc36af0fccf1a4ab0262b36da79d5eb63e73e3..57a0dbb23a32123d30c3b3572f4d129be9d97847 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftEntity.java
+@@ -1198,6 +1198,18 @@ public abstract class CraftEntity implements org.bukkit.entity.Entity {
+         return Pose.values()[this.getHandle().getPose().ordinal()];
+     }
+ 
++    // Paper start
++    @Override
++    public void setSneaking(boolean sneak) {
++        this.getHandle().setShiftKeyDown(sneak);
++    }
++
++    @Override
++    public boolean isSneaking() {
++        return this.getHandle().isShiftKeyDown();
++    }
++    // Paper end
++
+     @Override
+     public SpawnCategory getSpawnCategory() {
+         return CraftSpawnCategory.toBukkit(this.getHandle().getType().getCategory());

patches/server/0941-Improve-PortalEvents.patch

@@ -0,0 +1,26 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Thu, 15 Dec 2022 10:33:39 -0800
+Subject: [PATCH] Improve PortalEvents
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index 071b241de8f6e00f57e8564bb3feb757ee1f05eb..56e7e423ef3f1016ea095ef98dc9c06e7763ac3b 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
++++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -3561,7 +3561,14 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+         Location enter = bukkitEntity.getLocation();
+         Location exit = new Location(exitWorldServer.getWorld(), exitPosition.x(), exitPosition.y(), exitPosition.z());
+ 
+-        EntityPortalEvent event = new EntityPortalEvent(bukkitEntity, enter, exit, searchRadius);
++        // Paper start
++        final org.bukkit.PortalType portalType = switch (cause) {
++            case END_PORTAL -> org.bukkit.PortalType.ENDER;
++            case NETHER_PORTAL -> org.bukkit.PortalType.NETHER;
++            default -> org.bukkit.PortalType.CUSTOM;
++        };
++        EntityPortalEvent event = new EntityPortalEvent(bukkitEntity, enter, exit, searchRadius, portalType);
++        // Paper end
+         event.getEntity().getServer().getPluginManager().callEvent(event);
+         if (event.isCancelled() || event.getTo() == null || event.getTo().getWorld() == null || !entity.isAlive()) {
+             return null;

patches/server/0942-Add-config-option-for-spider-worldborder-climbing.patch

@@ -0,0 +1,40 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <blake.galbreath@gmail.com>
+Date: Thu, 27 Oct 2022 15:35:47 +0200
+Subject: [PATCH] Add config option for spider worldborder climbing
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index 56e7e423ef3f1016ea095ef98dc9c06e7763ac3b..1a302abc9864b727288de748a8e1627f771c17f1 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
++++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -398,6 +398,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+     @javax.annotation.Nullable
+     private UUID originWorld;
+     public boolean freezeLocked = false; // Paper - Freeze Tick Lock API
++    public boolean collidingWithWorldBorder; // Paper
+ 
+     public void setOrigin(@javax.annotation.Nonnull Location location) {
+         this.origin = location.toVector();
+@@ -1392,7 +1393,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+             io.papermc.paper.util.CollisionUtil.getCollisions(world, this, collisionBox, potentialCollisions, false, this.level.paperConfig().chunks.preventMovingIntoUnloadedChunks,
+                 false, false, null, null);
+ 
+-            if (io.papermc.paper.util.CollisionUtil.isCollidingWithBorderEdge(world.getWorldBorder(), collisionBox)) {
++            if (collidingWithWorldBorder = io.papermc.paper.util.CollisionUtil.isCollidingWithBorderEdge(world.getWorldBorder(), collisionBox)) { // Paper - this line *is* correct, ignore the IDE warning about assignments being used as a condition
+                 io.papermc.paper.util.CollisionUtil.addBoxesToIfIntersects(world.getWorldBorder().getCollisionShape(), collisionBox, potentialCollisions);
+             }
+ 
+diff --git a/src/main/java/net/minecraft/world/entity/monster/Spider.java b/src/main/java/net/minecraft/world/entity/monster/Spider.java
+index 61fd27992516e1238195f8e60766428f01719ba7..0c36bb47bd7040f1544817810e1c87157cdaff96 100644
+--- a/src/main/java/net/minecraft/world/entity/monster/Spider.java
++++ b/src/main/java/net/minecraft/world/entity/monster/Spider.java
+@@ -84,7 +84,7 @@ public class Spider extends Monster {
+     public void tick() {
+         super.tick();
+         if (!this.level.isClientSide) {
+-            this.setClimbing(this.horizontalCollision);
++            this.setClimbing(this.horizontalCollision && (this.level.paperConfig().entities.behavior.allowSpiderWorldBorderClimbing || !collidingWithWorldBorder)); // Paper
+         }
+ 
+     }

patches/server/0943-Add-missing-SpigotConfig-logCommands-check.patch

@@ -0,0 +1,20 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: NonSwag <mrminecraft00@gmail.com>
+Date: Thu, 8 Dec 2022 20:25:05 +0100
+Subject: [PATCH] Add missing SpigotConfig logCommands check
+
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index 5ddb75e6f60e4a4960018055991ea087ec473beb..3bec358de0348ba64ddbd83b63814fdc7b375b55 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
++++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -2248,7 +2248,9 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
+     private void performChatCommand(ServerboundChatCommandPacket packet, LastSeenMessages lastSeenMessages) {
+         // CraftBukkit start
+         String command = "/" + packet.command();
++        if (org.spigotmc.SpigotConfig.logCommands) { // Paper
+         ServerGamePacketListenerImpl.LOGGER.info(this.player.getScoreboardName() + " issued server command: " + command);
++        } // Paper
+ 
+         PlayerCommandPreprocessEvent event = new PlayerCommandPreprocessEvent(this.getCraftPlayer(), command, new LazyPlayerSet(this.server));
+         this.cserver.getPluginManager().callEvent(event);

patches/server/0944-Fix-NPE-on-Allay-stopDancing-while-not-dancing.patch

@@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: NonSwag <mrminecraft00@gmail.com>
+Date: Tue, 6 Dec 2022 23:04:21 +0100
+Subject: [PATCH] Fix NPE on Allay#stopDancing while not dancing
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftAllay.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftAllay.java
+index 0c09acc98d12cdac46b2f51dcce1edbc8890c931..a0fed289f1f6b6addd60ccbd1344ad2c1202c78b 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftAllay.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftAllay.java
+@@ -83,7 +83,7 @@ public class CraftAllay extends CraftCreature implements org.bukkit.entity.Allay
+     public void stopDancing() {
+         this.getHandle().forceDancing = false;
+         this.getHandle().jukeboxPos = null;
+-        this.getHandle().setJukeboxPlaying(null, false);
++        this.getHandle().setDancing(false); // Paper - Directly modify set dancing to avoid NPE
+     }
+ 
+     @Override

patches/server/0945-Flying-Fall-Damage.patch

@@ -0,0 +1,51 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: TreyRuffy <TreyRuffy@users.noreply.github.com>
+Date: Fri, 27 May 2022 02:26:08 -0600
+Subject: [PATCH] Flying Fall Damage
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/player/Player.java b/src/main/java/net/minecraft/world/entity/player/Player.java
+index 11c6fc510ae03005060782a675ed1cd370a07596..922dd1f4bc5975aa1a3cdc76fa2979c68c9df1dc 100644
+--- a/src/main/java/net/minecraft/world/entity/player/Player.java
++++ b/src/main/java/net/minecraft/world/entity/player/Player.java
+@@ -184,6 +184,7 @@ public abstract class Player extends LivingEntity {
+     protected float hurtDir;
+     // Paper start
+     public boolean affectsSpawning = true;
++    public net.kyori.adventure.util.TriState flyingFallDamage = net.kyori.adventure.util.TriState.NOT_SET;
+     // Paper end
+ 
+     // CraftBukkit start
+@@ -1748,7 +1749,7 @@ public abstract class Player extends LivingEntity {
+ 
+     @Override
+     public boolean causeFallDamage(float fallDistance, float damageMultiplier, DamageSource damageSource) {
+-        if (this.abilities.mayfly) {
++        if (this.abilities.mayfly && !this.flyingFallDamage.toBooleanOrElse(false)) { // Paper - flying fall damage
+             return false;
+         } else {
+             if (fallDistance >= 2.0F) {
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index c3c4bc73310993f3a92d8aa171289fc61da8949f..974509844a004690f52b751f23dd1159bfa23b62 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -2281,6 +2281,19 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+         this.getHandle().onUpdateAbilities();
+     }
+ 
++    // Paper start - flying fall damage
++    @Override
++    public void setFlyingFallDamage(@NotNull net.kyori.adventure.util.TriState flyingFallDamage) {
++        getHandle().flyingFallDamage = flyingFallDamage;
++    }
++
++    @NotNull
++    @Override
++    public net.kyori.adventure.util.TriState hasFlyingFallDamage() {
++        return getHandle().flyingFallDamage;
++    }
++    // Paper end
++
+     @Override
+     public int getNoDamageTicks() {
+         if (this.getHandle().spawnInvulnerableTime > 0) {

patches/server/0946-Expose-pre-collision-moving-velocity-to-VehicleBlock.patch

@@ -0,0 +1,20 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: SoSeDiK <mrsosedik@gmail.com>
+Date: Tue, 11 Oct 2022 23:30:32 +0300
+Subject: [PATCH] Expose pre-collision moving velocity to
+ VehicleBlockCollisionEvent
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/Entity.java b/src/main/java/net/minecraft/world/entity/Entity.java
+index 1a302abc9864b727288de748a8e1627f771c17f1..9a1e8589e6b371869b2199650172d61ae186c907 100644
+--- a/src/main/java/net/minecraft/world/entity/Entity.java
++++ b/src/main/java/net/minecraft/world/entity/Entity.java
+@@ -1104,7 +1104,7 @@ public abstract class Entity implements Nameable, EntityAccess, CommandSource {
+                     }
+ 
+                     if (!bl.getType().isAir()) {
+-                        VehicleBlockCollisionEvent event = new VehicleBlockCollisionEvent(vehicle, bl);
++                        VehicleBlockCollisionEvent event = new VehicleBlockCollisionEvent(vehicle, bl, org.bukkit.craftbukkit.util.CraftVector.toBukkit(moveVector)); // Paper - Expose pre-collision velocity
+                         this.level.getCraftServer().getPluginManager().callEvent(event);
+                     }
+                 }

patches/server/0947-config-for-disabling-entity-tag-tags.patch

@@ -0,0 +1,24 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Wed, 15 Sep 2021 14:52:42 -0700
+Subject: [PATCH] config for disabling entity tag tags
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/EntityType.java b/src/main/java/net/minecraft/world/entity/EntityType.java
+index fa10d60cf7f80c429690f20c3bccdd8bbe7752e8..ceacc0d383e2ee674783d3c0a7df0a951595faca 100644
+--- a/src/main/java/net/minecraft/world/entity/EntityType.java
++++ b/src/main/java/net/minecraft/world/entity/EntityType.java
+@@ -492,6 +492,13 @@ public class EntityType<T extends Entity> implements FeatureElement, EntityTypeT
+                 if (world.isClientSide || !entity.onlyOpCanSetNbt() || player != null && minecraftserver.getPlayerList().isOp(player.getGameProfile())) {
+                     CompoundTag nbttagcompound1 = entity.saveWithoutId(new CompoundTag());
+                     UUID uuid = entity.getUUID();
++                    // Paper start - filter out protected tags
++                    if (player == null || !player.getBukkitEntity().hasPermission("minecraft.nbt.place")) {
++                        for (net.minecraft.commands.arguments.NbtPathArgument.NbtPath tag : world.paperConfig().entities.spawning.filteredEntityTagNbtPaths) {
++                            tag.remove(itemNbt.getCompound("EntityTag"));
++                        }
++                    }
++                    // Paper end
+ 
+                     nbttagcompound1.merge(itemNbt.getCompound("EntityTag"));
+                     entity.setUUID(uuid);

patches/server/0948-Use-single-player-info-update-packet-on-join.patch

@@ -0,0 +1,73 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Sun, 8 Jan 2023 17:38:28 -0800
+Subject: [PATCH] Use single player info update packet on join
+
+
+diff --git a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+index 3bec358de0348ba64ddbd83b63814fdc7b375b55..ed09fc864a400f8a12e4097e28542a5792d1a902 100644
+--- a/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
++++ b/src/main/java/net/minecraft/server/network/ServerGamePacketListenerImpl.java
+@@ -3625,7 +3625,7 @@ public class ServerGamePacketListenerImpl implements ServerPlayerConnection, Tic
+         this.signedMessageDecoder = session.createMessageDecoder(this.player.getUUID());
+         this.chatMessageChain.append((executor) -> {
+             this.player.setChatSession(session);
+-            this.server.getPlayerList().broadcastAll(new ClientboundPlayerInfoUpdatePacket(EnumSet.of(ClientboundPlayerInfoUpdatePacket.Action.INITIALIZE_CHAT), List.of(this.player)));
++            this.server.getPlayerList().broadcastAll(new ClientboundPlayerInfoUpdatePacket(EnumSet.of(ClientboundPlayerInfoUpdatePacket.Action.INITIALIZE_CHAT), List.of(this.player)), this.player); // Paper
+             return CompletableFuture.completedFuture((Object) null);
+         });
+     }
+diff --git a/src/main/java/net/minecraft/server/players/PlayerList.java b/src/main/java/net/minecraft/server/players/PlayerList.java
+index 3793cc8a2cc917ba33b18c5af7fac25e9c1da288..c0c14766adaac855112f85a203a6163b8adfdded 100644
+--- a/src/main/java/net/minecraft/server/players/PlayerList.java
++++ b/src/main/java/net/minecraft/server/players/PlayerList.java
+@@ -303,7 +303,7 @@ public abstract class PlayerList {
+             player.sendServerStatus(serverping);
+         }
+ 
+-        player.connection.send(ClientboundPlayerInfoUpdatePacket.createPlayerInitializing(this.players));
++        // player.connection.send(ClientboundPlayerInfoUpdatePacket.createPlayerInitializing(this.players)); // Paper
+         this.players.add(player);
+         this.playersByName.put(player.getScoreboardName().toLowerCase(java.util.Locale.ROOT), player); // Spigot
+         this.playersByUUID.put(player.getUUID(), player);
+@@ -339,6 +339,7 @@ public abstract class PlayerList {
+         // CraftBukkit start - sendAll above replaced with this loop
+         ClientboundPlayerInfoUpdatePacket packet = ClientboundPlayerInfoUpdatePacket.createPlayerInitializing(List.of(player));
+ 
++        final List<ServerPlayer> onlinePlayers = Lists.newArrayListWithExpectedSize(this.players.size() - 1); // Paper - use single player info update packet
+         for (int i = 0; i < this.players.size(); ++i) {
+             ServerPlayer entityplayer1 = (ServerPlayer) this.players.get(i);
+ 
+@@ -346,12 +347,17 @@ public abstract class PlayerList {
+                 entityplayer1.connection.send(packet);
+             }
+ 
+-            if (!bukkitPlayer.canSee(entityplayer1.getBukkitEntity())) {
++            if (entityplayer1 == player || !bukkitPlayer.canSee(entityplayer1.getBukkitEntity())) { // Paper - don't include joining player
+                 continue;
+             }
+ 
+-            player.connection.send(ClientboundPlayerInfoUpdatePacket.createPlayerInitializing(List.of(entityplayer1)));
++            onlinePlayers.add(entityplayer1); // Paper - use single player info update packet
+         }
++        // Paper start - use single player info update packet
++        if (!onlinePlayers.isEmpty()) {
++            player.connection.send(ClientboundPlayerInfoUpdatePacket.createPlayerInitializing(onlinePlayers));
++        }
++        // Paper end
+         player.sentListPacket = true;
+         player.supressTrackerForLogin = false; // Paper
+         ((ServerLevel)player.level).getChunkSource().chunkMap.addEntity(player); // Paper - track entity now
+diff --git a/src/main/java/net/minecraft/world/damagesource/DamageSources.java b/src/main/java/net/minecraft/world/damagesource/DamageSources.java
+index 6d46908692637ace5d81a9948f5ed42e142f549a..31b515fd19555585d6e3a6f1da3bcd7fac380a50 100644
+--- a/src/main/java/net/minecraft/world/damagesource/DamageSources.java
++++ b/src/main/java/net/minecraft/world/damagesource/DamageSources.java
+@@ -242,8 +242,4 @@ public class DamageSources {
+     public DamageSource sonicBoom(Entity attacker) {
+         return this.source(DamageTypes.SONIC_BOOM, attacker);
+     }
+-
+-    public DamageSource badRespawnPointExplosion(Vec3 position) {
+-        return new DamageSource(this.damageTypes.getHolderOrThrow(DamageTypes.BAD_RESPAWN_POINT), position);
+-    }
+ }

patches/server/0949-Correctly-shrink-items-during-EntityResurrectEvent.patch

@@ -0,0 +1,36 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Bjarne Koll <lynxplay101@gmail.com>
+Date: Tue, 10 Jan 2023 21:06:42 +0100
+Subject: [PATCH] Correctly shrink items during EntityResurrectEvent
+
+The EntityResurrectEvent logic is supposed to locate a totem of undying
+in any of the interaction slots of the player inventory and then, if the
+called EntityResurrectEvent is not cancelled, shrink that item by 1,
+usually reducing it to zero.
+
+For this, the logic iterates over the items in the interaction slots and
+breaks out the loop if a totem of undying was found.
+However, even if no totem of undying was found, the iteration item stack
+variable remains as a refernce to the last interaction slot probed.
+
+Plugins uncancelling a EntityResurrectEvent, which is published
+pre-cancelled to listeners if no totem of undying could be found,
+would hence cause the server logic to shrink completely unrelated items
+found in, at the writing of this patch, the players off hand slot.
+
+This patch corrects this behaviour by only shrinking the item if a totem
+of undying was found and the event was called uncancelled.
+
+diff --git a/src/main/java/net/minecraft/world/entity/LivingEntity.java b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+index 24bcbe515dac7f6cab28a4148afb23d1f44be94b..6ed2bd15b9f69b58f02034a8679912b608555b61 100644
+--- a/src/main/java/net/minecraft/world/entity/LivingEntity.java
++++ b/src/main/java/net/minecraft/world/entity/LivingEntity.java
+@@ -1543,7 +1543,7 @@ public abstract class LivingEntity extends Entity implements Attackable {
+             this.level.getCraftServer().getPluginManager().callEvent(event);
+ 
+             if (!event.isCancelled()) {
+-                if (!itemstack1.isEmpty()) {
++                if (!itemstack1.isEmpty() && itemstack != null) { // Paper - only reduce item if actual totem was found
+                     itemstack1.shrink(1);
+                 }
+                 if (itemstack != null && this instanceof ServerPlayer) {

patches/server/0950-Win-Screen-API.patch

@@ -0,0 +1,38 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Lama06 <andreasprues36@gmail.com>
+Date: Sat, 21 Jan 2023 13:53:23 +0100
+Subject: [PATCH] Win Screen API
+
+== AT ==
+public net.minecraft.server.level.ServerPlayer seenCredits
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+index 974509844a004690f52b751f23dd1159bfa23b62..d7df13dcbf45b46f31f7e3a85ba38d9f57e5d583 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftPlayer.java
+@@ -1208,6 +1208,25 @@ public class CraftPlayer extends CraftHumanEntity implements Player {
+         this.getHandle().connection.send(packet);
+     }
+ 
++    // Paper start
++    @Override
++    public void showWinScreen() {
++        if (getHandle().connection == null) return;
++        var packet = new ClientboundGameEventPacket(ClientboundGameEventPacket.WIN_GAME, 1);
++        getHandle().connection.send(packet);
++    }
++
++    @Override
++    public boolean hasSeenWinScreen() {
++        return getHandle().seenCredits;
++    }
++
++    @Override
++    public void setHasSeenWinScreen(boolean hasSeenWinScreen) {
++        getHandle().seenCredits = hasSeenWinScreen;
++    }
++    // Paper end
++
+     @Override
+     public void setRotation(float yaw, float pitch) {
+         // Paper start - Teleport API

patches/server/0951-Remove-CraftItemStack-setAmount-null-assignment.patch

@@ -0,0 +1,30 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Josh Roy <joshroy126@gmail.com>
+Date: Mon, 23 Jan 2023 19:19:01 -0500
+Subject: [PATCH] Remove CraftItemStack#setAmount null assignment
+
+This creates a problem with Paper's item serialization
+api where deserialized items, which are internally
+created as a CraftItemStack, will be completely lost if
+#setAmount(0) is invoked (since the underlying handle
+is set to null), while a regular Bukkit ItemStack
+simply sets the amount field to zero, retaining the
+item's data.
+
+Vanilla treats items with zero amounts the same as items
+with less than zero amounts, so this code doesn't create
+a problem with operations on the vanilla ItemStack.
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java
+index d95d37d9dedbd9f74311b47826a74b16ba6ce3e9..f45e4acee69bd95ff2e41feaf44f5414d2e40df0 100644
+--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java
++++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftItemStack.java
+@@ -146,7 +146,7 @@ public final class CraftItemStack extends ItemStack {
+         }
+ 
+         this.handle.setCount(amount);
+-        if (amount == 0) {
++        if (false && amount == 0) { // Paper - remove CraftItemStack#setAmount null assignment
+             this.handle = null;
+         }
+     }

patches/server/0952-Fix-force-opening-enchantment-tables.patch

@@ -0,0 +1,30 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Thu, 26 Jan 2023 16:19:26 -0800
+Subject: [PATCH] Fix force-opening enchantment tables
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
+index d69c05223fca71fc5e282095d02bc39fee7ec757..11a06cd0a9cee01107941a2294fbcb493a11ab63 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
+@@ -396,7 +396,18 @@ public class CraftHumanEntity extends CraftLivingEntity implements HumanEntity {
+ 
+         // If there isn't an enchant table we can force create one, won't be very useful though.
+         BlockPos pos = new BlockPos(location.getBlockX(), location.getBlockY(), location.getBlockZ());
+-        this.getHandle().openMenu(((EnchantmentTableBlock) Blocks.ENCHANTING_TABLE).getMenuProvider(null, this.getHandle().level, pos));
++        // Paper start
++        MenuProvider menuProvider = ((EnchantmentTableBlock) Blocks.ENCHANTING_TABLE).getMenuProvider(null, this.getHandle().level, pos);
++        if (menuProvider == null) {
++            if (!force) {
++                return null;
++            }
++            menuProvider = new net.minecraft.world.SimpleMenuProvider((syncId, inventory, player) -> {
++                return new net.minecraft.world.inventory.EnchantmentMenu(syncId, inventory, net.minecraft.world.inventory.ContainerLevelAccess.create(this.getHandle().level, pos));
++            }, Component.translatable("container.enchant"));
++        }
++        this.getHandle().openMenu(menuProvider);
++        // Paper end
+ 
+         if (force) {
+             this.getHandle().containerMenu.checkReachable = false;

patches/server/0953-Add-Entity-Body-Yaw-API.patch

@@ -0,0 +1,27 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: TheTuso <piotrekpasztor@gmail.com>
+Date: Thu, 2 Feb 2023 16:40:41 +0100
+Subject: [PATCH] Add Entity Body Yaw API
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+index 62b5df7e3bcf1037d96897b41f25038c535515d5..bc3d3dc4e2efb54896233fd0a4aa140972cb02f6 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftLivingEntity.java
+@@ -1034,6 +1034,16 @@ public class CraftLivingEntity extends CraftEntity implements LivingEntity {
+         this.damageItemStack0(this.getHandle().getItemBySlot(nmsSlot), amount, nmsSlot);
+     }
+ 
++    @Override
++    public float getBodyYaw() {
++        return this.getHandle().getVisualRotationYInDegrees();
++    }
++
++    @Override
++    public void setBodyYaw(float bodyYaw) {
++        this.getHandle().setYBodyRot(bodyYaw);
++    }
++
+     private void damageItemStack0(net.minecraft.world.item.ItemStack nmsStack, int amount, net.minecraft.world.entity.EquipmentSlot slot) {
+         nmsStack.hurtAndBreak(amount, this.getHandle(), livingEntity -> {
+             if (slot != null) {

patches/server/0954-Add-missing-isFuel-Material-entries.patch

@@ -0,0 +1,24 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Sun, 12 Feb 2023 10:52:35 -0800
+Subject: [PATCH] Add missing isFuel Material entries
+
+
+diff --git a/src/test/java/org/bukkit/support/AbstractTestingBase.java b/src/test/java/org/bukkit/support/AbstractTestingBase.java
+index 5226604f2a88e08d94c59d7eb052edea3621c857..75a0b2dac14881c0cc485373d68becee23025902 100644
+--- a/src/test/java/org/bukkit/support/AbstractTestingBase.java
++++ b/src/test/java/org/bukkit/support/AbstractTestingBase.java
+@@ -43,7 +43,12 @@ public abstract class AbstractTestingBase {
+         SharedConstants.tryDetectVersion();
+         Bootstrap.bootStrap();
+         // Set up resource manager
+-        MultiPackResourceManager resourceManager = new MultiPackResourceManager(PackType.SERVER_DATA, Collections.singletonList(new ServerPacksSource().getVanillaPack()));
++        // Paper start - make sure to actually load the packs you add API for
++        final List<net.minecraft.server.packs.PackResources> packs = new java.util.ArrayList<>();
++        // don't worry about closing them, the only pack types should be VanillaPackResources (empty close) and PackPackResources (also empty close)
++        new ServerPacksSource().loadPacks(pack -> packs.add(pack.open()));
++        final MultiPackResourceManager resourceManager = new MultiPackResourceManager(PackType.SERVER_DATA, packs);
++        // Paper end
+         // add tags and loot tables for unit tests
+         LayeredRegistryAccess<RegistryLayer> layers = RegistryLayer.createRegistryAccess();
+         layers = WorldLoader.loadAndReplaceLayer(resourceManager, layers, RegistryLayer.WORLDGEN, RegistryDataLoader.WORLDGEN_REGISTRIES);

patches/server/0955-Fix-MC-157464-Prevent-sleeping-villagers-moving-towa.patch

@@ -0,0 +1,24 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Warrior <50800980+Warriorrrr@users.noreply.github.com>
+Date: Mon, 27 Feb 2023 19:16:07 +0100
+Subject: [PATCH] Fix MC-157464 Prevent sleeping villagers moving towards food
+
+Fixes sleeping villagers moving to nearby food by adding an !isSleeping predicate
+
+Relevant links:
+https://bugs.mojang.com/browse/MC-157464
+https://github.com/PaperMC/Paper/issues/8569
+
+diff --git a/src/main/java/net/minecraft/world/entity/ai/behavior/VillagerGoalPackages.java b/src/main/java/net/minecraft/world/entity/ai/behavior/VillagerGoalPackages.java
+index 9400556aca4cd06ad311975d74a9e7eb2ccd9c73..cd7a90ec1073b2b452ca70decefe6a594445003b 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/behavior/VillagerGoalPackages.java
++++ b/src/main/java/net/minecraft/world/entity/ai/behavior/VillagerGoalPackages.java
+@@ -22,7 +22,7 @@ public class VillagerGoalPackages {
+     private static final float STROLL_SPEED_MODIFIER = 0.4F;
+ 
+     public static ImmutableList<Pair<Integer, ? extends BehaviorControl<? super Villager>>> getCorePackage(VillagerProfession profession, float speed) {
+-        return ImmutableList.of(Pair.of(0, new Swim(0.8F)), Pair.of(0, InteractWithDoor.create()), Pair.of(0, new LookAtTargetSink(45, 90)), Pair.of(0, new VillagerPanicTrigger()), Pair.of(0, WakeUp.create()), Pair.of(0, ReactToBell.create()), Pair.of(0, SetRaidStatus.create()), Pair.of(0, ValidateNearbyPoi.create(profession.heldJobSite(), MemoryModuleType.JOB_SITE)), Pair.of(0, ValidateNearbyPoi.create(profession.acquirableJobSite(), MemoryModuleType.POTENTIAL_JOB_SITE)), Pair.of(1, new MoveToTargetSink()), Pair.of(2, PoiCompetitorScan.create()), Pair.of(3, new LookAndFollowTradingPlayerSink(speed)), Pair.of(5, GoToWantedItem.create(speed, false, 4)), Pair.of(6, AcquirePoi.create(profession.acquirableJobSite(), MemoryModuleType.JOB_SITE, MemoryModuleType.POTENTIAL_JOB_SITE, true, Optional.empty())), Pair.of(7, new GoToPotentialJobSite(speed)), Pair.of(8, YieldJobSite.create(speed)), Pair.of(10, AcquirePoi.create((poiType) -> {
++        return ImmutableList.of(Pair.of(0, new Swim(0.8F)), Pair.of(0, InteractWithDoor.create()), Pair.of(0, new LookAtTargetSink(45, 90)), Pair.of(0, new VillagerPanicTrigger()), Pair.of(0, WakeUp.create()), Pair.of(0, ReactToBell.create()), Pair.of(0, SetRaidStatus.create()), Pair.of(0, ValidateNearbyPoi.create(profession.heldJobSite(), MemoryModuleType.JOB_SITE)), Pair.of(0, ValidateNearbyPoi.create(profession.acquirableJobSite(), MemoryModuleType.POTENTIAL_JOB_SITE)), Pair.of(1, new MoveToTargetSink()), Pair.of(2, PoiCompetitorScan.create()), Pair.of(3, new LookAndFollowTradingPlayerSink(speed)), Pair.of(5, GoToWantedItem.create(villager -> !villager.isSleeping(), speed, false, 4)), Pair.of(6, AcquirePoi.create(profession.acquirableJobSite(), MemoryModuleType.JOB_SITE, MemoryModuleType.POTENTIAL_JOB_SITE, true, Optional.empty())), Pair.of(7, new GoToPotentialJobSite(speed)), Pair.of(8, YieldJobSite.create(speed)), Pair.of(10, AcquirePoi.create((poiType) -> { // Paper - Fix MC-157464
+             return poiType.is(PoiTypes.HOME);
+         }, MemoryModuleType.HOME, false, Optional.of((byte)14))), Pair.of(10, AcquirePoi.create((poiType) -> {
+             return poiType.is(PoiTypes.MEETING);

patches/server/0956-Update-the-flag-when-a-captured-block-state-is-outda.patch

@@ -0,0 +1,18 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Lulu13022002 <41980282+Lulu13022002@users.noreply.github.com>
+Date: Sat, 18 Feb 2023 16:23:18 +0100
+Subject: [PATCH] Update the flag when a captured block state is outdated
+
+
+diff --git a/src/main/java/net/minecraft/world/level/Level.java b/src/main/java/net/minecraft/world/level/Level.java
+index 174f5ff8f827dab2d85cee525429d46bbeae7183..973ecd50f9cb6b86c353586e84d15dcb118ccb60 100644
+--- a/src/main/java/net/minecraft/world/level/Level.java
++++ b/src/main/java/net/minecraft/world/level/Level.java
+@@ -532,6 +532,7 @@ public abstract class Level implements LevelAccessor, AutoCloseable {
+                 blockstate = CapturedBlockState.getTreeBlockState(this, pos, flags);
+                 this.capturedBlockStates.put(pos.immutable(), blockstate);
+             }
++            blockstate.setFlag(flags); // Paper - update the flag also
+             blockstate.setData(state);
+             return true;
+         }

patches/server/0957-Add-EntityFertilizeEggEvent.patch

@@ -0,0 +1,74 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Lulu13022002 <41980282+Lulu13022002@users.noreply.github.com>
+Date: Fri, 24 Jun 2022 12:39:34 +0200
+Subject: [PATCH] Add EntityFertilizeEggEvent
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/animal/Turtle.java b/src/main/java/net/minecraft/world/entity/animal/Turtle.java
+index 1c2f927974aab4d9751088449edbc777677d6cd0..81dab77f525ae667614f940c4ff5ec308a9579a2 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/Turtle.java
++++ b/src/main/java/net/minecraft/world/entity/animal/Turtle.java
+@@ -441,6 +441,17 @@ public class Turtle extends Animal {
+             if (entityplayer == null && this.partner.getLoveCause() != null) {
+                 entityplayer = this.partner.getLoveCause();
+             }
++            // Paper start
++            RandomSource randomsource = this.animal.getRandom();
++            int experience = randomsource.nextInt(7) + 1;
++            io.papermc.paper.event.entity.EntityFertilizeEggEvent event = new io.papermc.paper.event.entity.EntityFertilizeEggEvent((org.bukkit.entity.LivingEntity) turtle.getBukkitEntity(), (org.bukkit.entity.LivingEntity) partner.getBukkitEntity(), entityplayer == null ? null : entityplayer.getBukkitEntity(), turtle.breedItem == null ? null : org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(turtle.breedItem).clone(), experience);
++            if (!event.callEvent()) {
++                animal.resetLove();
++                partner.resetLove(); // stop the pathfinding to avoid infinite loop
++                return;
++            }
++            experience = event.getExperience();
++            // Paper end
+ 
+             if (entityplayer != null) {
+                 entityplayer.awardStat(Stats.ANIMALS_BRED);
+@@ -452,10 +463,9 @@ public class Turtle extends Animal {
+             this.partner.setAge(6000);
+             this.animal.resetLove();
+             this.partner.resetLove();
+-            RandomSource randomsource = this.animal.getRandom();
+ 
+-            if (this.level.getGameRules().getBoolean(GameRules.RULE_DOMOBLOOT)) {
+-                this.level.addFreshEntity(new ExperienceOrb(this.level, this.animal.getX(), this.animal.getY(), this.animal.getZ(), randomsource.nextInt(7) + 1, org.bukkit.entity.ExperienceOrb.SpawnReason.BREED, entityplayer)); // Paper;
++            if (experience > 0 && this.level.getGameRules().getBoolean(GameRules.RULE_DOMOBLOOT)) { // Paper
++                this.level.addFreshEntity(new ExperienceOrb(this.level, this.animal.getX(), this.animal.getY(), this.animal.getZ(), experience, org.bukkit.entity.ExperienceOrb.SpawnReason.BREED, entityplayer)); // Paper
+             }
+ 
+         }
+diff --git a/src/main/java/net/minecraft/world/entity/animal/frog/Frog.java b/src/main/java/net/minecraft/world/entity/animal/frog/Frog.java
+index 1b3d462e1e229970c53f763b5cdce7d21f1b1703..a65cec3c9837882df5b61de58f03d276d4db6bfc 100644
+--- a/src/main/java/net/minecraft/world/entity/animal/frog/Frog.java
++++ b/src/main/java/net/minecraft/world/entity/animal/frog/Frog.java
+@@ -252,6 +252,17 @@ public class Frog extends Animal implements VariantHolder<FrogVariant> {
+             serverPlayer = other.getLoveCause();
+         }
+ 
++        // Paper start
++        int experience = this.getRandom().nextInt(7) + 1;
++        io.papermc.paper.event.entity.EntityFertilizeEggEvent event = new io.papermc.paper.event.entity.EntityFertilizeEggEvent((org.bukkit.entity.LivingEntity) this.getBukkitEntity(), (org.bukkit.entity.LivingEntity) other.getBukkitEntity(), serverPlayer == null ? null : serverPlayer.getBukkitEntity(), this.breedItem == null ? null : org.bukkit.craftbukkit.inventory.CraftItemStack.asCraftMirror(this.breedItem).clone(), experience);
++        if (!event.callEvent()) {
++            resetLove();
++            other.resetLove(); // stop the pathfinding to avoid infinite loop
++            return;
++        }
++        experience = event.getExperience();
++        // Paper end
++
+         if (serverPlayer != null) {
+             serverPlayer.awardStat(Stats.ANIMALS_BRED);
+             CriteriaTriggers.BRED_ANIMALS.trigger(serverPlayer, this, other, (AgeableMob)null);
+@@ -263,8 +274,8 @@ public class Frog extends Animal implements VariantHolder<FrogVariant> {
+         other.resetLove();
+         this.getBrain().setMemory(MemoryModuleType.IS_PREGNANT, Unit.INSTANCE);
+         world.broadcastEntityEvent(this, (byte)18);
+-        if (world.getGameRules().getBoolean(GameRules.RULE_DOMOBLOOT)) {
+-            world.addFreshEntity(new ExperienceOrb(world, this.getX(), this.getY(), this.getZ(), this.getRandom().nextInt(7) + 1, org.bukkit.entity.ExperienceOrb.SpawnReason.BREED, serverPlayer)); // Paper
++        if (experience > 0 && world.getGameRules().getBoolean(GameRules.RULE_DOMOBLOOT)) { // Paper
++            world.addFreshEntity(new ExperienceOrb(world, this.getX(), this.getY(), this.getZ(), experience, org.bukkit.entity.ExperienceOrb.SpawnReason.BREED, serverPlayer)); // Paper
+         }
+ 
+     }

patches/server/0958-Fix-HumanEntity-drop-not-updating-the-client-inv.patch

@@ -0,0 +1,30 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Sun, 10 Oct 2021 18:18:01 -0700
+Subject: [PATCH] Fix HumanEntity#drop not updating the client inv
+
+== AT ==
+public net.minecraft.server.level.ServerPlayer containerSynchronizer
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
+index 11a06cd0a9cee01107941a2294fbcb493a11ab63..e54574c60c5cbc4e083c4ca11e0b7dd49bd03478 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftHumanEntity.java
+@@ -749,8 +749,15 @@ public class CraftHumanEntity extends CraftLivingEntity implements HumanEntity {
+     // Paper end
+     @Override
+     public boolean dropItem(boolean dropAll) {
+-        if (!(this.getHandle() instanceof ServerPlayer)) return false;
+-        return ((ServerPlayer) this.getHandle()).drop(dropAll);
++        // Paper start - notify client of remote slot change
++        if (!(this.getHandle() instanceof ServerPlayer player)) return false;
++        boolean success = player.drop(dropAll);
++        if (!success) return false;
++        final net.minecraft.world.entity.player.Inventory inv = player.getInventory();
++        final java.util.OptionalInt optionalSlot = player.containerMenu.findSlot(inv, inv.selected);
++        optionalSlot.ifPresent(slot -> player.containerSynchronizer.sendSlotChange(player.containerMenu, slot, inv.getSelected()));
++        return true;
++        // Paper end
+     }
+ 
+     @Override

patches/server/0959-Add-CompostItemEvent-and-EntityCompostItemEvent.patch

@@ -0,0 +1,82 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Noah van der Aa <ndvdaa@gmail.com>
+Date: Sun, 8 Aug 2021 19:56:02 +0200
+Subject: [PATCH] Add CompostItemEvent and EntityCompostItemEvent
+
+
+diff --git a/src/main/java/net/minecraft/world/entity/ai/behavior/WorkAtComposter.java b/src/main/java/net/minecraft/world/entity/ai/behavior/WorkAtComposter.java
+index 05c1e8c9f013547d4fcdbbd299329166a8ece1b0..aff235c019ae5c6ed5227127d5424b34af5f36dd 100644
+--- a/src/main/java/net/minecraft/world/entity/ai/behavior/WorkAtComposter.java
++++ b/src/main/java/net/minecraft/world/entity/ai/behavior/WorkAtComposter.java
+@@ -58,7 +58,7 @@ public class WorkAtComposter extends WorkAtPoi {
+                     i -= p;
+ 
+                     for(int q = 0; q < p; ++q) {
+-                        blockState = ComposterBlock.insertItem(entity, blockState, world, itemStack, blockPos);
++                        blockState = ComposterBlock.insertItem(entity, blockState, world, itemStack, blockPos, entity); // Paper
+                         if (blockState.getValue(ComposterBlock.LEVEL) == 7) {
+                             this.spawnComposterFillEffects(world, composterState, blockPos, blockState);
+                             return;
+diff --git a/src/main/java/net/minecraft/world/level/block/ComposterBlock.java b/src/main/java/net/minecraft/world/level/block/ComposterBlock.java
+index e81bda56c58df6c3109382c17e86f4cc0f16cf81..fc3f08db8e3747e6e9d6f448c91e51144d480585 100644
+--- a/src/main/java/net/minecraft/world/level/block/ComposterBlock.java
++++ b/src/main/java/net/minecraft/world/level/block/ComposterBlock.java
+@@ -235,7 +235,10 @@ public class ComposterBlock extends Block implements WorldlyContainerHolder {
+                 if (state != dummyBlockState && org.bukkit.craftbukkit.event.CraftEventFactory.callEntityChangeBlockEvent(player, pos, dummyBlockState).isCancelled()) { // if block state will change and event cancelled
+                     return InteractionResult.sidedSuccess(world.isClientSide);
+                 }
+-                BlockState iblockdata1 = ComposterBlock.addItem(player, state, world, pos, itemstack, rand);
++                BlockState iblockdata1 = ComposterBlock.addItem(player, state, world, pos, itemstack);
++                if (iblockdata1 == null) {
++                    return InteractionResult.PASS;
++                }
+                 // Paper end
+ 
+                 world.levelEvent(1500, pos, state != iblockdata1 ? 1 : 0);
+@@ -265,6 +268,11 @@ public class ComposterBlock extends Block implements WorldlyContainerHolder {
+                 return state;
+             }
+             iblockdata1 = ComposterBlock.addItem(user, state, world, pos, stack, rand);
++            // Paper start
++            if (iblockdata1 == null) {
++                return state;
++            }
++            // Paper end
+             // CraftBukkit end
+ 
+             stack.shrink(1);
+@@ -315,7 +323,21 @@ public class ComposterBlock extends Block implements WorldlyContainerHolder {
+         int i = (Integer) iblockdata.getValue(ComposterBlock.LEVEL);
+         float f = ComposterBlock.COMPOSTABLES.getFloat(itemstack.getItem());
+ 
+-        if ((i != 0 || f <= 0.0F) && rand >= (double) f) {
++        // Paper start
++        io.papermc.paper.event.block.CompostItemEvent event;
++        boolean willRaiseLevel = !((i != 0 || f <= 0.0F) && rand >= (double) f);
++        if (entity == null) {
++            event = new io.papermc.paper.event.block.CompostItemEvent(org.bukkit.craftbukkit.block.CraftBlock.at(generatoraccess, blockposition), itemstack.getBukkitStack(), willRaiseLevel);
++        } else {
++            event = new io.papermc.paper.event.entity.EntityCompostItemEvent(entity.getBukkitEntity(), org.bukkit.craftbukkit.block.CraftBlock.at(generatoraccess, blockposition), itemstack.getBukkitStack(), willRaiseLevel);
++        }
++
++        if (!event.callEvent()) {
++            return null;
++        }
++
++        if (!event.willRaiseLevel()) {
++            // Paper end
+             return iblockdata;
+         } else {
+             int j = i + 1;
+@@ -460,6 +482,11 @@ public class ComposterBlock extends Block implements WorldlyContainerHolder {
+                 this.changed = true;
+                 BlockState iblockdata = ComposterBlock.addItem((Entity) null, this.state, this.level, this.pos, itemstack);
+ 
++                // Paper start
++                if (iblockdata == null) {
++                    return;
++                }
++                // Paper end
+                 this.level.levelEvent(1500, this.pos, iblockdata != this.state ? 1 : 0);
+                 this.removeItemNoUpdate(0);
+             }

patches/server/0960-Correctly-handle-ArmorStand-invisibility.patch

@@ -0,0 +1,25 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Jake Potrebic <jake.m.potrebic@gmail.com>
+Date: Sun, 5 Mar 2023 14:38:21 -0800
+Subject: [PATCH] Correctly handle ArmorStand invisibility
+
+
+diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftArmorStand.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftArmorStand.java
+index f80cafe3544c7e6c3c29073ba6539783adf6666c..17d08d2c90047ebfc4098b087be091b83111a40f 100644
+--- a/src/main/java/org/bukkit/craftbukkit/entity/CraftArmorStand.java
++++ b/src/main/java/org/bukkit/craftbukkit/entity/CraftArmorStand.java
+@@ -158,6 +158,14 @@ public class CraftArmorStand extends CraftLivingEntity implements ArmorStand {
+         this.getHandle().noPhysics = !gravity;
+     }
+ 
++    // Paper start - Armor Stand has its own invisible field
++    @Override
++    public void setInvisible(final boolean invisible) {
++        this.getHandle().setInvisible(invisible);
++        super.setInvisible(invisible);
++    }
++    // Paper end
++
+     @Override
+     public boolean isVisible() {
+         return !this.getHandle().isInvisible();