[ci skip] Add more identifying patch comments

patches/server/Add-Alternate-Current-redstone-implementation.patch

@@ -2028,7 +2028,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    public alternate.current.wire.WireHandler getWireHandler() {
 +        return wireHandler;
 +    }
-+    // Paper end
++    // Paper end - optimize redstone (Alternate Current)
 +
      private final class EntityCallbacks implements LevelCallback<Entity> {
  
@@ -2077,7 +2077,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            } else {
 +                this.updateSurroundingRedstone(world, pos, state, null); // vanilla/Eigencraft
 +            }
-+            // Paper end
++            // Paper end - optimize redstone
              Iterator iterator = Direction.Plane.VERTICAL.iterator();
  
              while (iterator.hasNext()) {
@@ -2092,7 +2092,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                } else {
 +                    this.updateSurroundingRedstone(world, pos, state, null); // vanilla/Eigencraft
 +                }
-+                // Paper end
++                // Paper end - optimize redstone
                  this.updateNeighborsOfNeighboringWires(world, pos);
              }
          }
@@ -2105,7 +2105,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            if (world.paperConfig().misc.redstoneImplementation == io.papermc.paper.configuration.WorldConfiguration.Misc.RedstoneImplementation.ALTERNATE_CURRENT) {
 +                world.getWireHandler().onWireUpdated(pos);
 +            } else
-+            // Paper end
++            // Paper end - optimize redstone (Alternate Current)
              if (state.canSurvive(world, pos)) {
 -                this.updateSurroundingRedstone(world, pos, state, sourcePos); // Paper - Optimize redstone
 +                this.updateSurroundingRedstone(world, pos, state, sourcePos); // Paper - Optimize redstone (Eigencraft)

patches/server/Add-EntityDyeEvent-and-CollarColorable-interface.patch

@@ -12,13 +12,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                      DyeColor enumcolor = ((DyeItem) item).getDyeColor();
  
                      if (enumcolor != this.getCollarColor()) {
-+                        // Paper start
++                        // Paper start - Add EntityDyeEvent and CollarColorable interface
 +                        final io.papermc.paper.event.entity.EntityDyeEvent event = new io.papermc.paper.event.entity.EntityDyeEvent(this.getBukkitEntity(), org.bukkit.DyeColor.getByWoolData((byte) enumcolor.getId()), ((net.minecraft.server.level.ServerPlayer) player).getBukkitEntity());
 +                        if (!event.callEvent()) {
 +                            return InteractionResult.FAIL;
 +                        }
 +                        enumcolor = DyeColor.byId(event.getColor().getWoolData());
-+                        // Paper end
++                        // Paper end - Add EntityDyeEvent and CollarColorable interface
                          this.setCollarColor(enumcolor);
                          if (!player.getAbilities().instabuild) {
                              itemstack.shrink(1);
@@ -30,13 +30,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                          DyeColor enumcolor = itemdye.getDyeColor();
  
                          if (enumcolor != this.getCollarColor()) {
-+                            // Paper start
++                            // Paper start - Add EntityDyeEvent and CollarColorable interface
 +                            final io.papermc.paper.event.entity.EntityDyeEvent event = new io.papermc.paper.event.entity.EntityDyeEvent(this.getBukkitEntity(), org.bukkit.DyeColor.getByWoolData((byte) enumcolor.getId()), ((net.minecraft.server.level.ServerPlayer) player).getBukkitEntity());
 +                            if (!event.callEvent()) {
 +                                return InteractionResult.FAIL;
 +                            }
 +                            enumcolor = DyeColor.byId(event.getColor().getWoolData());
-+                            // Paper end
++                            // Paper end - Add EntityDyeEvent and CollarColorable interface
 +
                              this.setCollarColor(enumcolor);
                              if (!player.getAbilities().instabuild) {

patches/server/Add-PlayerStopUsingItemEvent.patch

@@ -12,7 +12,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      public void releaseUsingItem() {
          if (!this.useItem.isEmpty()) {
-+            if (this instanceof ServerPlayer) new io.papermc.paper.event.player.PlayerStopUsingItemEvent((Player) getBukkitEntity(), useItem.asBukkitMirror(), getTicksUsingItem()).callEvent(); // Paper
++            if (this instanceof ServerPlayer) new io.papermc.paper.event.player.PlayerStopUsingItemEvent((Player) getBukkitEntity(), useItem.asBukkitMirror(), getTicksUsingItem()).callEvent(); // Paper - Add PlayerStopUsingItemEvent
              this.useItem.releaseUsing(this.level(), this, this.getUseItemRemainingTicks());
              if (this.useItem.useOnRelease()) {
                  this.updatingUsingItem();

patches/server/Add-TameableDeathMessageEvent.patch

@@ -13,12 +13,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public void die(DamageSource damageSource) {
          if (!this.level().isClientSide && this.level().getGameRules().getBoolean(GameRules.RULE_SHOWDEATHMESSAGES) && this.getOwner() instanceof ServerPlayer) {
 -            this.getOwner().sendSystemMessage(this.getCombatTracker().getDeathMessage());
-+            // Paper start - TameableDeathMessageEvent
++            // Paper start - Add TameableDeathMessageEvent
 +            io.papermc.paper.event.entity.TameableDeathMessageEvent event = new io.papermc.paper.event.entity.TameableDeathMessageEvent((org.bukkit.entity.Tameable) getBukkitEntity(), io.papermc.paper.adventure.PaperAdventure.asAdventure(this.getCombatTracker().getDeathMessage()));
 +            if (event.callEvent()) {
 +                this.getOwner().sendSystemMessage(io.papermc.paper.adventure.PaperAdventure.asVanilla(event.deathMessage()));
 +            }
-+            // Paper end - TameableDeathMessageEvent
++            // Paper end - Add TameableDeathMessageEvent
          }
  
          super.die(damageSource);

patches/server/Add-WardenAngerChangeEvent.patch

@@ -13,7 +13,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          boolean bl = !this.angerBySuspect.containsKey(entity);
          int i = this.angerBySuspect.computeInt(entity, (suspect, anger) -> {
 -            return Math.min(150, (anger == null ? 0 : anger) + amount);
-+            return Math.min(150, (anger == null ? 0 : anger) + amount); // Paper - diff on change
++            return Math.min(150, (anger == null ? 0 : anger) + amount); // Paper - diff on change (Warden#increaseAngerAt WardenAngerChangeEvent)
          });
          if (bl) {
              int j = this.angerByUuid.removeInt(entity.getUUID());
@@ -25,7 +25,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      @VisibleForTesting
      public void increaseAngerAt(@Nullable Entity entity, int amount, boolean listening) {
          if (!this.isNoAi() && this.canTargetEntity(entity)) {
-+            // Paper start
++            // Paper start - Add WardenAngerChangeEvent
 +            int activeAnger = this.angerManagement.getActiveAnger(entity);
 +            io.papermc.paper.event.entity.WardenAngerChangeEvent event = new io.papermc.paper.event.entity.WardenAngerChangeEvent((org.bukkit.entity.Warden) this.getBukkitEntity(), entity.getBukkitEntity(), activeAnger, Math.min(150, activeAnger + amount));
 +            this.level().getCraftServer().getPluginManager().callEvent(event);
@@ -33,7 +33,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                return;
 +            }
 +            amount = event.getNewAnger() - activeAnger;
-+            // Paper end
++            // Paper end - Add WardenAngerChangeEvent
              WardenAi.setDigCooldown(this);
              boolean flag1 = !(this.getBrain().getMemory(MemoryModuleType.ATTACK_TARGET).orElse(null) instanceof Player); // CraftBukkit - decompile error
              int j = this.angerManagement.increaseAnger(entity, amount);

patches/server/Add-support-for-Proxy-Protocol.patch

@@ -24,11 +24,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              ServerConnectionListener.LOGGER.info("Paper: Using " + com.velocitypowered.natives.util.Natives.cipher.getLoadedVariant() + " cipher from Velocity.");
              // Paper end
  
-+            // Paper start - indicate Proxy Protocol usage
++            // Paper start - Add support for proxy protocol
 +            if (io.papermc.paper.configuration.GlobalConfiguration.get().proxies.proxyProtocol) {
 +                ServerConnectionListener.LOGGER.info("Paper: Using Proxy Protocol");
 +            }
-+            // Paper end
++            // Paper end - Add support for proxy protocol
 +
              this.channels.add(((ServerBootstrap) ((ServerBootstrap) (new ServerBootstrap()).channel(oclass)).childHandler(new ChannelInitializer<Channel>() {
                  protected void initChannel(Channel channel) {
@@ -59,7 +59,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                            }
 +                        });
 +                    }
-+                    // Paper end
++                    // Paper end - Add support for proxy protocol
                      pending.add(object); // Paper
                      ((Connection) object).configurePacketHandler(channelpipeline);
                      ((Connection) object).setListenerForServerboundHandshake(new ServerHandshakePacketListenerImpl(ServerConnectionListener.this.server, (Connection) object));

patches/server/Allow-changing-the-EnderDragon-podium.patch

@@ -1,7 +1,7 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Doc <nachito94@msn.com>
 Date: Sun, 3 Apr 2022 11:31:42 -0400
-Subject: [PATCH] Allow to change the podium for the EnderDragon
+Subject: [PATCH] Allow changing the EnderDragon podium
 
 
 diff --git a/src/main/java/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java b/src/main/java/net/minecraft/world/entity/boss/enderdragon/EnderDragon.java
@@ -12,10 +12,10 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      private final int[] nodeAdjacency;
      private final BinaryHeap openSet;
      private final Explosion explosionSource; // CraftBukkit - reusable source for CraftTNTPrimed.getSource()
-+    // Paper start - add var for save custom podium
++    // Paper start - Allow changing the EnderDragon podium
 +    @Nullable
 +    private BlockPos podium;
-+    // Paper end
++    // Paper end - Allow changing the EnderDragon podium
  
      public EnderDragon(EntityType<? extends EnderDragon> entitytypes, Level world) {
          super(EntityType.ENDER_DRAGON, world);
@@ -23,7 +23,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          return Mob.createMobAttributes().add(Attributes.MAX_HEALTH, 200.0D);
      }
  
-+    // Paper start
++    // Paper start - Allow changing the EnderDragon podium
 +    public BlockPos getPodium() {
 +        if (this.podium == null) {
 +            return EndPodiumFeature.getLocation(this.getFightOrigin());
@@ -34,7 +34,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    public void setPodium(@Nullable BlockPos blockPos) {
 +        this.podium = blockPos;
 +    }
-+    // Paper end
++    // Paper end - Allow changing the EnderDragon podium
 +
      @Override
      public boolean isFlapping() {
@@ -44,7 +44,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              }
          } else {
 -            BlockPos blockposition = this.level().getHeightmapPos(Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, EndPodiumFeature.getLocation(this.fightOrigin));
-+            BlockPos blockposition = this.level().getHeightmapPos(Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, this.getPodium()); // Paper - use custom podium
++            BlockPos blockposition = this.level().getHeightmapPos(Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, this.getPodium()); // Paper - Allow changing the EnderDragon podium
              double d1 = Math.max(Math.sqrt(blockposition.distToCenterSqr(this.position())) / 4.0D, 1.0D);
  
              d0 = (double) segmentOffset / d1;
@@ -53,7 +53,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              }
          } else {
 -            BlockPos blockposition = this.level().getHeightmapPos(Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, EndPodiumFeature.getLocation(this.fightOrigin));
-+            BlockPos blockposition = this.level().getHeightmapPos(Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, this.getPodium()); // Paper - use custom podium
++            BlockPos blockposition = this.level().getHeightmapPos(Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, this.getPodium()); // Paper - Allow changing the EnderDragon podium
  
              f1 = Math.max((float) Math.sqrt(blockposition.distToCenterSqr(this.position())) / 4.0F, 1.0F);
              float f3 = 6.0F / f1;
@@ -66,7 +66,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          ++this.time;
          if (this.targetLocation == null) {
 -            BlockPos blockPos = this.dragon.level().getHeightmapPos(Heightmap.Types.MOTION_BLOCKING, EndPodiumFeature.getLocation(this.dragon.getFightOrigin()));
-+            BlockPos blockPos = this.dragon.level().getHeightmapPos(Heightmap.Types.MOTION_BLOCKING, this.dragon.getPodium()); // Paper - use custom podium
++            BlockPos blockPos = this.dragon.level().getHeightmapPos(Heightmap.Types.MOTION_BLOCKING, this.dragon.getPodium()); // Paper - Allow changing the EnderDragon podium
              this.targetLocation = Vec3.atBottomCenterOf(blockPos);
          }
  
@@ -79,7 +79,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      private void findNewTarget() {
          if (this.currentPath != null && this.currentPath.isDone()) {
 -            BlockPos blockPos = this.dragon.level().getHeightmapPos(Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, new BlockPos(EndPodiumFeature.getLocation(this.dragon.getFightOrigin())));
-+            BlockPos blockPos = this.dragon.level().getHeightmapPos(Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, this.dragon.getPodium()); // Paper - use custom podium
++            BlockPos blockPos = this.dragon.level().getHeightmapPos(Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, this.dragon.getPodium()); // Paper - Allow changing the EnderDragon podium
              int i = this.dragon.getDragonFight() == null ? 0 : this.dragon.getDragonFight().getCrystalsAlive();
              if (this.dragon.getRandom().nextInt(i + 3) == 0) {
                  this.dragon.getPhaseManager().setPhase(EnderDragonPhase.LANDING_APPROACH);
@@ -92,7 +92,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          if (this.currentPath == null || this.currentPath.isDone()) {
              int i = this.dragon.findClosestNode();
 -            BlockPos blockPos = this.dragon.level().getHeightmapPos(Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, EndPodiumFeature.getLocation(this.dragon.getFightOrigin()));
-+            BlockPos blockPos = this.dragon.level().getHeightmapPos(Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, this.dragon.getPodium()); // Paper - use custom podium
++            BlockPos blockPos = this.dragon.level().getHeightmapPos(Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, this.dragon.getPodium()); // Paper - Allow changing the EnderDragon podium
              Player player = this.dragon.level().getNearestPlayer(NEAR_EGG_TARGETING, this.dragon, (double)blockPos.getX(), (double)blockPos.getY(), (double)blockPos.getZ());
              int j;
              if (player != null) {
@@ -105,7 +105,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public void doServerTick() {
          if (this.targetLocation == null) {
 -            this.targetLocation = Vec3.atBottomCenterOf(this.dragon.level().getHeightmapPos(Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, EndPodiumFeature.getLocation(this.dragon.getFightOrigin())));
-+            this.targetLocation = Vec3.atBottomCenterOf(this.dragon.level().getHeightmapPos(Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, this.dragon.getPodium())); // Paper - use custom podium
++            this.targetLocation = Vec3.atBottomCenterOf(this.dragon.level().getHeightmapPos(Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, this.dragon.getPodium())); // Paper - Allow changing the EnderDragon podium
          }
  
          if (this.targetLocation.distanceToSqr(this.dragon.getX(), this.dragon.getY(), this.dragon.getZ()) < 1.0D) {
@@ -118,7 +118,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public void doServerTick() {
          if (!this.firstTick && this.currentPath != null) {
 -            BlockPos blockPos = this.dragon.level().getHeightmapPos(Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, EndPodiumFeature.getLocation(this.dragon.getFightOrigin()));
-+            BlockPos blockPos = this.dragon.level().getHeightmapPos(Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, this.dragon.getPodium()); // Paper - use custom podium
++            BlockPos blockPos = this.dragon.level().getHeightmapPos(Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, this.dragon.getPodium()); // Paper - Allow changing the EnderDragon podium
              if (!blockPos.closerToCenterThan(this.dragon.position(), 10.0D)) {
                  this.dragon.getPhaseManager().setPhase(EnderDragonPhase.HOLDING_PATTERN);
              }
@@ -131,7 +131,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          return this.getHandle().dragonDeathTime;
      }
 +
-+    // Paper start
++    // Paper start - Allow changing the EnderDragon podium
 +    @Override
 +    public org.bukkit.Location getPodium() {
 +        net.minecraft.core.BlockPos blockPosOrigin = this.getHandle().getPodium();
@@ -147,5 +147,5 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            this.getHandle().setPodium(io.papermc.paper.util.MCUtil.toBlockPos(location));
 +        }
 +    }
-+    // Paper end
++    // Paper end - Allow changing the EnderDragon podium
  }

patches/server/Buffer-OOB-setBlock-calls.patch

@@ -20,7 +20,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          }
      }
  
-+    private boolean hasSetFarWarned = false; // Paper
++    private boolean hasSetFarWarned = false; // Paper - Buffer OOB setBlock calls
      @Override
      public boolean ensureCanWrite(BlockPos pos) {
          int i = SectionPos.blockToSectionCoord(pos.getX());
@@ -28,7 +28,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
              return true;
          } else {
-+            // Paper start
++            // Paper start - Buffer OOB setBlock calls
 +            if (!hasSetFarWarned) {
              Util.logAndPauseIfInIde("Detected setBlock in a far chunk [" + i + ", " + j + "], pos: " + pos + ", status: " + this.generatingStatus + (this.currentlyGenerating == null ? "" : ", currently generating: " + (String) this.currentlyGenerating.get()));
 +            hasSetFarWarned = true;
@@ -36,7 +36,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                io.papermc.paper.util.TraceUtil.dumpTraceForThread("far setBlock call");
 +            }
 +            }
-+            // Paper end
++            // Paper end - Buffer OOB setBlock calls
              return false;
          }
      }

patches/server/Custom-Potion-Mixes.patch

@@ -39,7 +39,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
              this.worldData.setDataConfiguration(worlddataconfiguration);
              this.resources.managers.updateRegistryTags(this.registryAccess());
-+            net.minecraft.world.item.alchemy.PotionBrewing.reload(); // Paper
++            net.minecraft.world.item.alchemy.PotionBrewing.reload(); // Paper - Custom Potion Mixes
              // Paper start
              if (Thread.currentThread() != this.serverThread) {
                  return;
@@ -52,7 +52,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
          public static boolean mayPlaceItem(ItemStack stack) {
 -            return stack.is(Items.POTION) || stack.is(Items.SPLASH_POTION) || stack.is(Items.LINGERING_POTION) || stack.is(Items.GLASS_BOTTLE);
-+            return stack.is(Items.POTION) || stack.is(Items.SPLASH_POTION) || stack.is(Items.LINGERING_POTION) || stack.is(Items.GLASS_BOTTLE) || PotionBrewing.isCustomInput(stack); // Paper
++            return stack.is(Items.POTION) || stack.is(Items.SPLASH_POTION) || stack.is(Items.LINGERING_POTION) || stack.is(Items.GLASS_BOTTLE) || PotionBrewing.isCustomInput(stack); // Paper - Custom Potion Mixes
          }
      }
  
@@ -64,7 +64,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public static final int BREWING_TIME_SECONDS = 20;
      private static final List<PotionBrewing.Mix<Potion>> POTION_MIXES = Lists.newArrayList();
      private static final List<PotionBrewing.Mix<Item>> CONTAINER_MIXES = Lists.newArrayList();
-+    private static final it.unimi.dsi.fastutil.objects.Object2ObjectLinkedOpenHashMap<org.bukkit.NamespacedKey, io.papermc.paper.potion.PaperPotionMix> CUSTOM_MIXES = new it.unimi.dsi.fastutil.objects.Object2ObjectLinkedOpenHashMap<>(); // Paper
++    private static final it.unimi.dsi.fastutil.objects.Object2ObjectLinkedOpenHashMap<org.bukkit.NamespacedKey, io.papermc.paper.potion.PaperPotionMix> CUSTOM_MIXES = new it.unimi.dsi.fastutil.objects.Object2ObjectLinkedOpenHashMap<>(); // Paper - Custom Potion Mixes
      private static final List<Ingredient> ALLOWED_CONTAINERS = Lists.newArrayList();
      private static final Predicate<ItemStack> ALLOWED_CONTAINER = (stack) -> {
          for(Ingredient ingredient : ALLOWED_CONTAINERS) {
@@ -73,7 +73,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      public static boolean isIngredient(ItemStack stack) {
 -        return isContainerIngredient(stack) || isPotionIngredient(stack);
-+        return isContainerIngredient(stack) || isPotionIngredient(stack) || isCustomIngredient(stack); // Paper
++        return isContainerIngredient(stack) || isPotionIngredient(stack) || isCustomIngredient(stack); // Paper - Custom Potion Mixes
      }
  
      protected static boolean isContainerIngredient(ItemStack stack) {
@@ -81,11 +81,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      }
  
      public static boolean hasMix(ItemStack input, ItemStack ingredient) {
-+        // Paper start
++        // Paper start - Custom Potion Mixes
 +        if (hasCustomMix(input, ingredient)) {
 +            return true;
 +        }
-+        // Paper end
++        // Paper end - Custom Potion Mixes
          if (!ALLOWED_CONTAINER.test(input)) {
              return false;
          } else {
@@ -93,13 +93,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      public static ItemStack mix(ItemStack ingredient, ItemStack input) {
          if (!input.isEmpty()) {
-+            // Paper start
++            // Paper start - Custom Potion Mixes
 +            for (var mix : CUSTOM_MIXES.values()) {
 +                if (mix.input().test(input) && mix.ingredient().test(ingredient)) {
 +                    return mix.result().copy();
 +                }
 +            }
-+            // Paper end
++            // Paper end - Custom Potion Mixes
              Potion potion = PotionUtils.getPotion(input);
              Item item = input.getItem();
  
@@ -107,7 +107,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          return input;
      }
  
-+    // Paper start
++    // Paper start - Custom Potion Mixes
 +    public static boolean isCustomIngredient(ItemStack stack) {
 +        for (var mix : CUSTOM_MIXES.values()) {
 +            if (mix.ingredient().test(stack)) {
@@ -153,7 +153,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        CUSTOM_MIXES.clear();
 +        bootStrap();
 +    }
-+    // Paper end
++    // Paper end - Custom Potion Mixes
 +
      public static void bootStrap() {
          addContainer(Items.POTION);
@@ -167,7 +167,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      @Override
      public boolean canPlaceItem(int slot, ItemStack stack) {
 -        return slot == 3 ? PotionBrewing.isIngredient(stack) : (slot == 4 ? stack.is(Items.BLAZE_POWDER) : (stack.is(Items.POTION) || stack.is(Items.SPLASH_POTION) || stack.is(Items.LINGERING_POTION) || stack.is(Items.GLASS_BOTTLE)) && this.getItem(slot).isEmpty());
-+        return slot == 3 ? PotionBrewing.isIngredient(stack) : (slot == 4 ? stack.is(Items.BLAZE_POWDER) : (stack.is(Items.POTION) || stack.is(Items.SPLASH_POTION) || stack.is(Items.LINGERING_POTION) || stack.is(Items.GLASS_BOTTLE) || PotionBrewing.isCustomInput(stack)) && this.getItem(slot).isEmpty()); // Paper
++        return slot == 3 ? PotionBrewing.isIngredient(stack) : (slot == 4 ? stack.is(Items.BLAZE_POWDER) : (stack.is(Items.POTION) || stack.is(Items.SPLASH_POTION) || stack.is(Items.LINGERING_POTION) || stack.is(Items.GLASS_BOTTLE) || PotionBrewing.isCustomInput(stack)) && this.getItem(slot).isEmpty()); // Paper - Custom Potion Mixes
      }
  
      @Override
@@ -179,7 +179,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      private final io.papermc.paper.datapack.PaperDatapackManager datapackManager; // Paper
      public static Exception excessiveVelEx; // Paper - Velocity warnings
      private final io.papermc.paper.logging.SysoutCatcher sysoutCatcher = new io.papermc.paper.logging.SysoutCatcher(); // Paper
-+    private final CraftPotionBrewer potionBrewer = new CraftPotionBrewer(); // Paper
++    private final CraftPotionBrewer potionBrewer = new CraftPotionBrewer(); // Paper - Custom Potion Mixes
  
      static {
          ConfigurationSerialization.registerClass(CraftOfflinePlayer.class);
@@ -188,7 +188,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          CraftRegistry.setMinecraftRegistry(console.registryAccess());
  
 -        Potion.setPotionBrewer(new CraftPotionBrewer());
-+        Potion.setPotionBrewer(potionBrewer); // Paper
++        Potion.setPotionBrewer(potionBrewer); // Paper - Custom Potion Mixes
          // Ugly hack :(
  
          if (!Main.useConsole) {

patches/server/Disable-component-selector-resolving-in-books-by-def.patch

@@ -13,7 +13,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public static boolean resolveBookComponents(ItemStack book, @Nullable CommandSourceStack commandSource, @Nullable Player player) {
          CompoundTag compoundTag = book.getTag();
 -        if (compoundTag != null && !compoundTag.getBoolean("resolved")) {
-+        if (io.papermc.paper.configuration.GlobalConfiguration.get().itemValidation.resolveSelectorsInBooks && compoundTag != null && !compoundTag.getBoolean("resolved")) { // Paper
++        if (io.papermc.paper.configuration.GlobalConfiguration.get().itemValidation.resolveSelectorsInBooks && compoundTag != null && !compoundTag.getBoolean("resolved")) { // Paper - Disable component selector resolving in books by default
              compoundTag.putBoolean("resolved", true);
              if (!makeSureTagIsValid(compoundTag)) {
                  return false;

patches/server/Don-t-allow-vehicle-movement-from-players-while-tele.patch

@@ -14,11 +14,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              this.disconnect(Component.translatable("multiplayer.disconnect.invalid_vehicle_movement"), org.bukkit.event.player.PlayerKickEvent.Cause.INVALID_VEHICLE_MOVEMENT); // Paper - kick event cause
          } else {
              Entity entity = this.player.getRootVehicle();
-+            // Paper start
++            // Paper start - Don't allow vehicle movement from players while teleporting
 +            if (this.awaitingPositionFromClient != null || this.player.isImmobile() || entity.isRemoved()) {
 +                return;
 +            }
-+            // Paper end
++            // Paper end - Don't allow vehicle movement from players while teleporting
  
              if (entity != this.player && entity.getControllingPassenger() == this.player && entity == this.lastVehicle) {
                  ServerLevel worldserver = this.player.serverLevel();

patches/server/Don-t-tick-markers.patch

@@ -18,7 +18,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  info.left++;
                  info.right.put(chunk, info.right.getOrDefault(chunk, 0) + 1);
 -                if (!chunkProviderServer.isPositionTicking(e)) {
-+                if (!chunkProviderServer.isPositionTicking(e) || (e instanceof net.minecraft.world.entity.Marker && !world.paperConfig().entities.markers.tick)) { // Configurable marker ticking
++                if (!chunkProviderServer.isPositionTicking(e) || (e instanceof net.minecraft.world.entity.Marker && !world.paperConfig().entities.markers.tick)) { // Paper - Configurable marker ticking
                      nonEntityTicking.merge(key, 1, Integer::sum);
                  }
              });
@@ -42,14 +42,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
              // Paper start
              java.util.List<Entity> entities = world.getEntities((Entity)null, ActivationRange.maxBB, null);
-+            boolean tickMarkers = world.paperConfig().entities.markers.tick; // Paper - configurable marker ticking
++            boolean tickMarkers = world.paperConfig().entities.markers.tick; // Paper - Configurable marker ticking
              for (int i = 0; i < entities.size(); i++) {
                  Entity entity = entities.get(i);
-+                // Paper start - configurable marker ticking
++                // Paper start - Configurable marker ticking
 +                if (!tickMarkers && entity instanceof net.minecraft.world.entity.Marker) {
 +                    continue;
 +                }
-+                // Paper end - configurable marker ticking
++                // Paper end - Configurable marker ticking
                  ActivationRange.activateEntity(entity);
              }
              // Paper end

patches/server/Ensure-entity-passenger-world-matches-ridden-entity.patch

@@ -14,7 +14,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      public boolean startRiding(Entity entity, boolean force) {
 -        if (entity == this.vehicle) {
-+        if (entity == this.vehicle || entity.level != this.level) { // Paper - check level
++        if (entity == this.vehicle || entity.level != this.level) { // Paper - Ensure entity passenger world matches ridden entity (bad plugins)
              return false;
          } else if (!entity.couldAcceptPassenger()) {
              return false;

patches/server/Expand-FallingBlock-API.patch

@@ -20,7 +20,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      @Nullable
      public CompoundTag blockData;
      protected static final EntityDataAccessor<BlockPos> DATA_START_POS = SynchedEntityData.defineId(FallingBlockEntity.class, EntityDataSerializers.BLOCK_POS);
-+    public boolean autoExpire = true; // Paper - Auto expire setting
++    public boolean autoExpire = true; // Paper - Expand FallingBlock API
  
      public FallingBlockEntity(EntityType<? extends FallingBlockEntity> type, Level world) {
          super(type, world);
@@ -29,7 +29,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
                  if (!this.onGround() && !flag1) {
 -                    if (!this.level().isClientSide && (this.time > 100 && (blockposition.getY() <= this.level().getMinBuildHeight() || blockposition.getY() > this.level().getMaxBuildHeight()) || this.time > 600)) {
-+                    if (!this.level().isClientSide && ((this.time > 100 && autoExpire) && (blockposition.getY() <= this.level().getMinBuildHeight() || blockposition.getY() > this.level().getMaxBuildHeight()) || (this.time > 600 && autoExpire))) { // Paper - Auto expire setting
++                    if (!this.level().isClientSide && ((this.time > 100 && autoExpire) && (blockposition.getY() <= this.level().getMinBuildHeight() || blockposition.getY() > this.level().getMaxBuildHeight()) || (this.time > 600 && autoExpire))) { // Paper - Expand FallingBlock API
                          if (this.dropItem && this.level().getGameRules().getBoolean(GameRules.RULE_DOENTITYDROPS)) {
                              this.spawnAtLocation((ItemLike) block);
                          }
@@ -37,7 +37,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          }
  
          nbt.putBoolean("CancelDrop", this.cancelDrop);
-+        if (!autoExpire) {nbt.putBoolean("Paper.AutoExpire", false);} // Paper - AutoExpire setting
++        if (!autoExpire) {nbt.putBoolean("Paper.AutoExpire", false);} // Paper - Expand FallingBlock API
      }
  
      @Override
@@ -45,11 +45,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              this.setOrigin(new org.bukkit.Location(this.level().getWorld(), srcX, srcY, srcZ));
          }
          // Paper end
-+        // Paper start
++        // Paper start - Expand FallingBlock API
 +         if (nbt.contains("Paper.AutoExpire")) {
 +            this.autoExpire = nbt.getBoolean("Paper.AutoExpire");
 +         }
-+        // Paper end
++        // Paper end - Expand FallingBlock API
      }
  
      public void setHurtsEntities(float fallHurtAmount, int fallHurtMax) {
@@ -61,7 +61,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public BlockData getBlockData() {
          return CraftBlockData.fromData(this.getHandle().getBlockState());
      }
-+    // Paper start
++    // Paper start - Expand FallingBlock API
 +    @Override
 +    public void setBlockData(final BlockData blockData) {
 +        Preconditions.checkArgument(blockData != null, "blockData");
@@ -85,7 +85,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        this.setBlockData(blockState.getBlockData());
 +        if (blockState instanceof final org.bukkit.craftbukkit.block.CraftBlockEntityState<?> tileEntity) this.getHandle().blockData = tileEntity.getSnapshotNBT();
 +    }
-+    // Paper end
++    // Paper end - Expand FallingBlock API
  
      @Override
      public boolean getDropItem() {
@@ -93,7 +93,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              this.setHurtEntities(true);
          }
      }
-+    // Paper Start - Auto expire setting
++    // Paper Start - Expand FallingBlock API
 +    @Override
 +    public boolean doesAutoExpire() {
 +        return this.getHandle().autoExpire;
@@ -103,5 +103,5 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    public void shouldAutoExpire(boolean autoExpires) {
 +        this.getHandle().autoExpire = autoExpires;
 +    }
-+    // Paper End - Auto expire setting
++    // Paper End - Expand FallingBlock API
  }

patches/server/Expand-PlayerItemDamageEvent.patch

@@ -1,7 +1,7 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: HexedHero <6012891+HexedHero@users.noreply.github.com>
 Date: Sun, 10 Apr 2022 06:26:32 +0100
-Subject: [PATCH] Add pre-unbreaking amount to PlayerItemDamageEvent
+Subject: [PATCH] Expand PlayerItemDamageEvent
 
 
 diff --git a/src/main/java/net/minecraft/world/item/ItemStack.java b/src/main/java/net/minecraft/world/item/ItemStack.java
@@ -12,12 +12,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                      }
                  }
  
-+                int originalDamage = amount; // Paper
++                int originalDamage = amount; // Paper - Expand PlayerItemDamageEvent
                  amount -= k;
                  // CraftBukkit start
                  if (player instanceof ServerPlayer serverPlayer) { // Paper
 -                    PlayerItemDamageEvent event = new PlayerItemDamageEvent(serverPlayer.getBukkitEntity(), CraftItemStack.asCraftMirror(this), amount); // Paper
-+                    PlayerItemDamageEvent event = new PlayerItemDamageEvent(serverPlayer.getBukkitEntity(), CraftItemStack.asCraftMirror(this), amount, originalDamage); // Paper
++                    PlayerItemDamageEvent event = new PlayerItemDamageEvent(serverPlayer.getBukkitEntity(), CraftItemStack.asCraftMirror(this), amount, originalDamage); // Paper - Expand PlayerItemDamageEvent
                      event.getPlayer().getServer().getPluginManager().callEvent(event);
  
                      if (amount != event.getDamage() || event.isCancelled()) {

patches/server/Fire-CauldronLevelChange-on-initial-fill.patch

@@ -15,7 +15,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  if (!world.isClientSide) {
                      // CraftBukkit start
 -                    if (!LayeredCauldronBlock.changeLevel(iblockdata, world, blockposition, Blocks.WATER_CAULDRON.defaultBlockState(), entityhuman, CauldronLevelChangeEvent.ChangeReason.BOTTLE_EMPTY)) {
-+                    if (!LayeredCauldronBlock.changeLevel(iblockdata, world, blockposition, Blocks.WATER_CAULDRON.defaultBlockState(), entityhuman, CauldronLevelChangeEvent.ChangeReason.BOTTLE_EMPTY, false)) { // Paper
++                    if (!LayeredCauldronBlock.changeLevel(iblockdata, world, blockposition, Blocks.WATER_CAULDRON.defaultBlockState(), entityhuman, CauldronLevelChangeEvent.ChangeReason.BOTTLE_EMPTY, false)) { // Paper - Call CauldronLevelChange
                          return InteractionResult.SUCCESS;
                      }
                      // CraftBukkit end
@@ -24,7 +24,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  if (!world.isClientSide) {
                      // CraftBukkit start
 -                    if (!LayeredCauldronBlock.changeLevel(iblockdata, world, blockposition, iblockdata.cycle(LayeredCauldronBlock.LEVEL), entityhuman, CauldronLevelChangeEvent.ChangeReason.BOTTLE_EMPTY)) {
-+                    if (!LayeredCauldronBlock.changeLevel(iblockdata, world, blockposition, iblockdata.cycle(LayeredCauldronBlock.LEVEL), entityhuman, CauldronLevelChangeEvent.ChangeReason.BOTTLE_EMPTY, false)) { // Paper
++                    if (!LayeredCauldronBlock.changeLevel(iblockdata, world, blockposition, iblockdata.cycle(LayeredCauldronBlock.LEVEL), entityhuman, CauldronLevelChangeEvent.ChangeReason.BOTTLE_EMPTY, false)) { // Paper - Call CauldronLevelChange
                          return InteractionResult.SUCCESS;
                      }
                      // CraftBukkit end
@@ -33,7 +33,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              if (!world.isClientSide) {
                  // CraftBukkit start
 -                if (!LayeredCauldronBlock.changeLevel(state, world, pos, Blocks.CAULDRON.defaultBlockState(), player, CauldronLevelChangeEvent.ChangeReason.BUCKET_FILL)) {
-+                if (!LayeredCauldronBlock.changeLevel(state, world, pos, Blocks.CAULDRON.defaultBlockState(), player, CauldronLevelChangeEvent.ChangeReason.BUCKET_FILL, false)) { // Paper
++                if (!LayeredCauldronBlock.changeLevel(state, world, pos, Blocks.CAULDRON.defaultBlockState(), player, CauldronLevelChangeEvent.ChangeReason.BUCKET_FILL, false)) { // Paper - Call CauldronLevelChange
                      return InteractionResult.SUCCESS;
                  }
                  // CraftBukkit end
@@ -42,7 +42,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          if (!world.isClientSide) {
              // CraftBukkit start
 -            if (!LayeredCauldronBlock.changeLevel(state, world, pos, state, player, CauldronLevelChangeEvent.ChangeReason.BUCKET_EMPTY)) {
-+            if (!LayeredCauldronBlock.changeLevel(state, world, pos, state, player, CauldronLevelChangeEvent.ChangeReason.BUCKET_EMPTY, false)) { // Paper
++            if (!LayeredCauldronBlock.changeLevel(state, world, pos, state, player, CauldronLevelChangeEvent.ChangeReason.BUCKET_EMPTY, false)) { // Paper - Call CauldronLevelChange
                  return InteractionResult.SUCCESS;
              }
              // CraftBukkit end
@@ -55,19 +55,19 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          if (CauldronBlock.shouldHandlePrecipitation(world, precipitation)) {
              if (precipitation == Biome.Precipitation.RAIN) {
 -                world.setBlockAndUpdate(pos, Blocks.WATER_CAULDRON.defaultBlockState());
-+                // Paper start - call event for initial fill
++                // Paper start - Call CauldronLevelChange
 +                if (!LayeredCauldronBlock.changeLevel(state, world, pos, Blocks.WATER_CAULDRON.defaultBlockState(), null, CauldronLevelChangeEvent.ChangeReason.NATURAL_FILL, false)) { // avoid duplicate game event
 +                    return;
 +                }
-+                // Paper end
++                // Paper end - Call CauldronLevelChange
                  world.gameEvent((Entity) null, GameEvent.BLOCK_CHANGE, pos);
              } else if (precipitation == Biome.Precipitation.SNOW) {
 -                world.setBlockAndUpdate(pos, Blocks.POWDER_SNOW_CAULDRON.defaultBlockState());
-+                // Paper start - call event for initial fill
++                // Paper start - Call CauldronLevelChange
 +                if (!LayeredCauldronBlock.changeLevel(state, world, pos, Blocks.POWDER_SNOW_CAULDRON.defaultBlockState(), null, CauldronLevelChangeEvent.ChangeReason.NATURAL_FILL, false)) { // avoid duplicate game event
 +                    return;
 +                }
-+                // Paper end
++                // Paper end - Call CauldronLevelChange
                  world.gameEvent((Entity) null, GameEvent.BLOCK_CHANGE, pos);
              }
  
@@ -76,20 +76,20 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          if (fluid == Fluids.WATER) {
              iblockdata1 = Blocks.WATER_CAULDRON.defaultBlockState();
 -            LayeredCauldronBlock.changeLevel(state, world, pos, iblockdata1, null, CauldronLevelChangeEvent.ChangeReason.NATURAL_FILL); // CraftBukkit
-+            // Paper start - don't send level event or game event if cancelled
++            // Paper start - Call CauldronLevelChange; don't send level event or game event if cancelled
 +            if (!LayeredCauldronBlock.changeLevel(state, world, pos, iblockdata1, null, CauldronLevelChangeEvent.ChangeReason.NATURAL_FILL)) { // CraftBukkit
 +                return;
 +            }
-+            // Paper end
++            // Paper end - Call CauldronLevelChange
              world.levelEvent(1047, pos, 0);
          } else if (fluid == Fluids.LAVA) {
              iblockdata1 = Blocks.LAVA_CAULDRON.defaultBlockState();
 -            LayeredCauldronBlock.changeLevel(state, world, pos, iblockdata1, null, CauldronLevelChangeEvent.ChangeReason.NATURAL_FILL); // CraftBukkit
-+            // Paper start - don't send level event or game event if cancelled
++            // Paper start - Call CauldronLevelChange; don't send level event or game event if cancelled
 +            if (!LayeredCauldronBlock.changeLevel(state, world, pos, iblockdata1, null, CauldronLevelChangeEvent.ChangeReason.NATURAL_FILL)) { // CraftBukkit
 +                return;
 +            }
-+            // Paper end
++            // Paper end - Call CauldronLevelChange
              world.levelEvent(1046, pos, 0);
          }
  
@@ -102,13 +102,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      // CraftBukkit start
 -    public static boolean changeLevel(BlockState iblockdata, Level world, BlockPos blockposition, BlockState newBlock, Entity entity, CauldronLevelChangeEvent.ChangeReason reason) {
-+    // Paper start
++    // Paper start - Call CauldronLevelChange
 +    public static boolean changeLevel(BlockState iblockdata, Level world, BlockPos blockposition, BlockState newBlock, @javax.annotation.Nullable Entity entity, CauldronLevelChangeEvent.ChangeReason reason) { // Paper - entity is nullable
 +        return changeLevel(iblockdata, world, blockposition, newBlock, entity, reason, true);
 +    }
 +
 +    public static boolean changeLevel(BlockState iblockdata, Level world, BlockPos blockposition, BlockState newBlock, @javax.annotation.Nullable Entity entity, CauldronLevelChangeEvent.ChangeReason reason, boolean sendGameEvent) { // Paper - entity is nullable
-+    // Paper end
++    // Paper end - Call CauldronLevelChange
          CraftBlockState newState = CraftBlockStates.getBlockState(world, blockposition);
          newState.setData(newBlock);
  
@@ -117,7 +117,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          }
          newState.update(true);
 -        world.gameEvent(GameEvent.BLOCK_CHANGE, blockposition, GameEvent.Context.of(newBlock));
-+        if (sendGameEvent) world.gameEvent(GameEvent.BLOCK_CHANGE, blockposition, GameEvent.Context.of(newBlock)); // Paper
++        if (sendGameEvent) world.gameEvent(GameEvent.BLOCK_CHANGE, blockposition, GameEvent.Context.of(newBlock)); // Paper - Call CauldronLevelChange
          return true;
      }
      // CraftBukkit end

patches/server/Fix-Entity-Position-Desync.patch

@@ -17,7 +17,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  boolean flag5 = false;
  
 -                if (this.tickCount > 0 || this.entity instanceof AbstractArrow) {
-+                if (!(this.entity instanceof net.minecraft.world.entity.decoration.HangingEntity) || this.tickCount > 0 || this.entity instanceof AbstractArrow) { // Paper - Always update position
++                if (!(this.entity instanceof net.minecraft.world.entity.decoration.HangingEntity) || this.tickCount > 0 || this.entity instanceof AbstractArrow) { // Paper - Always update position to fix first-tick teleports
                      long k = this.positionCodec.encodeX(vec3d);
                      long l = this.positionCodec.encodeY(vec3d);
                      long i1 = this.positionCodec.encodeZ(vec3d);

patches/server/Fix-FurnaceInventory-for-smokers-and-blast-furnaces.patch

@@ -25,7 +25,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    }
 +
 +    public static abstract class AbstractFurnaceInventoryConverter extends CraftTileInventoryConverter {
-+    // Paper end
++    // Paper end - abstract furnace converter to apply to all 3 furnaces
          // Paper start
          @Override
          public Inventory createInventory(InventoryHolder owner, InventoryType type, net.kyori.adventure.text.Component title) {

patches/server/Fix-NBT-pieces-overriding-a-block-entity-during-worl.patch

@@ -21,7 +21,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                            if (!(world instanceof net.minecraft.world.level.WorldGenLevel)) {
 +                                Clearable.tryClear(tileentity);
 +                            }
-+                            // Paper end
++                            // Paper end - Fix NBT pieces overriding a block entity during worldgen deadlock
                              world.setBlock(blockposition2, Blocks.BARRIER.defaultBlockState(), 20);
                          }
                          // CraftBukkit start
@@ -34,7 +34,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                                if (!(world instanceof net.minecraft.world.level.WorldGenLevel)) {
 +                                    tileentity.setChanged();
 +                                }
-+                                // Paper end
++                                // Paper end - Fix NBT pieces overriding a block entity during worldgen deadlock
                              }
                          }
                      }

patches/server/Fix-cancelling-ProjectileHitEvent-for-piercing-arrow.patch

@@ -22,7 +22,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          }
      }
  
-+    // Paper start
++    // Paper start - Fix cancelling ProjectileHitEvent for piercing arrows
 +    @Override
 +    public void preOnHit(HitResult hitResult) {
 +        super.preOnHit(hitResult);
@@ -33,7 +33,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            this.piercingIgnoreEntityIds.add(entityHitResult.getEntity().getId());
 +        }
 +    }
-+    // Paper end
++    // Paper end - Fix cancelling ProjectileHitEvent for piercing arrows
 +
      private boolean shouldFall() {
          return this.inGround && this.level().noCollision((new AABB(this.position(), this.position())).inflate(0.06D));

patches/server/Fix-falling-block-spawn-methods.patch

@@ -24,7 +24,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        entity.time = 1;
 +
 +        this.world.addFreshEntity(entity, SpawnReason.CUSTOM);
-+        // Paper end
++        // Paper end - restore API behavior for spawning falling blocks
          return (FallingBlock) entity.getBukkitEntity();
      }
  
@@ -38,7 +38,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +        entity.time = 1;
 +
 +        this.world.addFreshEntity(entity, SpawnReason.CUSTOM);
-+        // Paper end
++        // Paper end - restore API behavior for spawning falling blocks
          return (FallingBlock) entity.getBukkitEntity();
      }
  

patches/server/Fix-saving-in-unloadWorld.patch

@@ -14,7 +14,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          try {
              if (save) {
 -                handle.save(null, true, true);
-+                handle.save(null, true, false); // Paper - don't disable saving
++                handle.save(null, true, false); // Paper - Fix saving in unloadWorld
              }
  
              handle.getChunkSource().close(save);

patches/server/Fix-swamp-hut-cat-generation-deadlock.patch

@@ -18,7 +18,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          ServerLevel worldserver = world.getLevel();
  
 -        if (worldserver.structureManager().getStructureWithPieceAt(this.blockPosition(), StructureTags.CATS_SPAWN_AS_BLACK).isValid()) {
-+        if (worldserver.structureManager().getStructureWithPieceAt(this.blockPosition(), StructureTags.CATS_SPAWN_AS_BLACK, world).isValid()) { // Paper - fix deadlock
++        if (worldserver.structureManager().getStructureWithPieceAt(this.blockPosition(), StructureTags.CATS_SPAWN_AS_BLACK, world).isValid()) { // Paper - Fix swamp hut cat generation deadlock
              this.setVariant((CatVariant) BuiltInRegistries.CAT_VARIANT.getOrThrow(CatVariant.ALL_BLACK));
              this.setPersistenceRequired();
          }
@@ -31,12 +31,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      public List<StructureStart> startsForStructure(ChunkPos pos, Predicate<Structure> predicate) {
 -        Map<Structure, LongSet> map = this.level.getChunk(pos.x, pos.z, ChunkStatus.STRUCTURE_REFERENCES).getAllReferences();
-+        // Paper start
++        // Paper start - Fix swamp hut cat generation deadlock
 +        return this.startsForStructure(pos, predicate, null);
 +    }
 +    public List<StructureStart> startsForStructure(ChunkPos pos, Predicate<Structure> predicate, @Nullable ServerLevelAccessor levelAccessor) {
 +        Map<Structure, LongSet> map = (levelAccessor == null ? this.level : levelAccessor).getChunk(pos.x, pos.z, ChunkStatus.STRUCTURE_REFERENCES).getAllReferences();
-+        // Paper end
++        // Paper end - Fix swamp hut cat generation deadlock
          ImmutableList.Builder<StructureStart> builder = ImmutableList.builder();
  
          for(Map.Entry<Structure, LongSet> entry : map.entrySet()) {
@@ -44,11 +44,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      }
  
      public StructureStart getStructureWithPieceAt(BlockPos pos, TagKey<Structure> structureTag) {
-+        // Paper start
++        // Paper start - Fix swamp hut cat generation deadlock
 +        return this.getStructureWithPieceAt(pos, structureTag, null);
 +    }
 +    public StructureStart getStructureWithPieceAt(BlockPos pos, TagKey<Structure> structureTag, @Nullable ServerLevelAccessor levelAccessor) {
-+        // Paper end
++        // Paper end - Fix swamp hut cat generation deadlock
          Registry<Structure> registry = this.registryAccess().registryOrThrow(Registries.STRUCTURE);
  
          for(StructureStart structureStart : this.startsForStructure(new ChunkPos(pos), (structure) -> {
@@ -56,7 +56,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  return reference.is(structureTag);
              }).orElse(false);
 -        })) {
-+        }, levelAccessor)) { // Paper
++        }, levelAccessor)) { // Paper - Fix swamp hut cat generation deadlock
              if (this.structureHasPieceAt(pos, structureStart)) {
                  return structureStart;
              }

patches/server/Folia-scheduler-and-owned-region-API.patch

@@ -1256,7 +1256,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
 @@ -0,0 +0,0 @@ public final class CraftServer implements Server {
      private final io.papermc.paper.logging.SysoutCatcher sysoutCatcher = new io.papermc.paper.logging.SysoutCatcher(); // Paper
-     private final CraftPotionBrewer potionBrewer = new CraftPotionBrewer(); // Paper
+     private final CraftPotionBrewer potionBrewer = new CraftPotionBrewer(); // Paper - Custom Potion Mixes
  
 +    // Paper start - Folia region threading API
 +    private final io.papermc.paper.threadedregions.scheduler.FallbackRegionScheduler regionizedScheduler = new io.papermc.paper.threadedregions.scheduler.FallbackRegionScheduler();

patches/server/Force-close-world-loading-screen.patch

@@ -26,7 +26,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                worldserver1.getLightEngine(), (java.util.BitSet)null, (java.util.BitSet) null, false)
 +            );
 +        }
-+        // Paper end
++        // Paper end - Send empty chunk
      }
      private void mountSavedVehicle(ServerPlayer player, ServerLevel worldserver1, CompoundTag nbttagcompound) {
          // Paper end

patches/server/Lag-compensation-ticks.patch

@@ -14,7 +14,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 @@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
      public volatile Thread shutdownThread; // Paper
      public volatile boolean abnormalExit = false; // Paper
-     public boolean isIteratingOverLevels = false; // Paper
+     public boolean isIteratingOverLevels = false; // Paper - Throw exception on world create while being ticked
 +    // Paper start - lag compensation
 +    public static final long SERVER_INIT = System.nanoTime();
 +    // Paper end - lag compensation
@@ -22,7 +22,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public static <S extends MinecraftServer> S spin(Function<Thread, S> serverFactory) {
          AtomicReference<S> atomicreference = new AtomicReference();
 @@ -0,0 +0,0 @@ public abstract class MinecraftServer extends ReentrantBlockableEventLoop<TickTa
-         Iterator iterator = this.getAllLevels().iterator(); // Paper - move down
+         Iterator iterator = this.getAllLevels().iterator(); // Paper - Throw exception on world create while being ticked; move down
          while (iterator.hasNext()) {
              ServerLevel worldserver = (ServerLevel) iterator.next();
 +            worldserver.updateLagCompensationTick(); // Paper - lag compensation

patches/server/More-Projectile-API.patch

@@ -40,7 +40,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                      showParticles = this.makeAreaOfEffectCloud(itemstack, potionregistry, hitResult); // CraftBukkit - Pass MovingObjectPosition // Paper
                  } else {
 -                    showParticles = this.applySplash(list, hitResult.getType() == HitResult.Type.ENTITY ? ((EntityHitResult) hitResult).getEntity() : null, hitResult); // CraftBukkit - Pass MovingObjectPosition // Paper
-+                    showParticles = this.applySplash(list, hitResult != null && hitResult.getType() == HitResult.Type.ENTITY ? ((EntityHitResult) hitResult).getEntity() : null, hitResult); // CraftBukkit - Pass MovingObjectPosition // Paper - nullable hitResult
++                    showParticles = this.applySplash(list, hitResult != null && hitResult.getType() == HitResult.Type.ENTITY ? ((EntityHitResult) hitResult).getEntity() : null, hitResult); // CraftBukkit - Pass MovingObjectPosition // Paper - More projectile API
                  }
              }
  
@@ -49,7 +49,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      }
  
 -    private boolean applySplash(List<MobEffectInstance> list, @Nullable Entity entity, HitResult position) { // CraftBukkit - Pass MovingObjectPosition // Paper - return boolean
-+    private boolean applySplash(List<MobEffectInstance> list, @Nullable Entity entity, @Nullable HitResult position) { // CraftBukkit - Pass MovingObjectPosition // Paper - return boolean & nullable hitResult
++    private boolean applySplash(List<MobEffectInstance> list, @Nullable Entity entity, @Nullable HitResult position) { // CraftBukkit - Pass MovingObjectPosition // Paper - return boolean & More projectile API
          AABB axisalignedbb = this.getBoundingBox().inflate(4.0D, 2.0D, 4.0D);
          List<net.minecraft.world.entity.LivingEntity> list1 = this.level().getEntitiesOfClass(net.minecraft.world.entity.LivingEntity.class, axisalignedbb);
          Map<LivingEntity, Double> affected = new HashMap<LivingEntity, Double>(); // CraftBukkit
@@ -58,7 +58,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      }
  
 -    private boolean makeAreaOfEffectCloud(ItemStack itemstack, Potion potionregistry, HitResult position) { // CraftBukkit - Pass MovingObjectPosition // Paper - return boolean
-+    private boolean makeAreaOfEffectCloud(ItemStack itemstack, Potion potionregistry, @Nullable HitResult position) { // CraftBukkit - Pass MovingObjectPosition // Paper - return boolean & nullable hitResult
++    private boolean makeAreaOfEffectCloud(ItemStack itemstack, Potion potionregistry, @Nullable HitResult position) { // CraftBukkit - Pass MovingObjectPosition // Paper - return boolean & More projectile API
          AreaEffectCloud entityareaeffectcloud = new AreaEffectCloud(this.level(), this.getX(), this.getY(), this.getZ());
          Entity entity = this.getOwner();
  
@@ -70,7 +70,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      @Override
      public void setBounce(boolean doesBounce) {}
  
-+    // Paper start
++    // Paper start - More projectile API
 +    @Override
 +    public boolean hasLeftShooter() {
 +        return this.getHandle().leftOwner;
@@ -130,7 +130,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +    public java.util.UUID getOwnerUniqueId() {
 +        return this.getHandle().ownerUUID;
 +    }
-+    // Paper end
++    // Paper end - More projectile API
  }
 diff --git a/src/main/java/org/bukkit/craftbukkit/entity/CraftArrow.java b/src/main/java/org/bukkit/craftbukkit/entity/CraftArrow.java
 index 0000000000000000000000000000000000000000..0000000000000000000000000000000000000000 100644

patches/server/Option-to-have-default-CustomSpawners-in-custom-worl.patch

@@ -26,7 +26,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +                    spawners = Collections.emptyList();
 +                }
 +                world = new ServerLevel(this, this.executor, worldSession, iworlddataserver, worldKey, worlddimension, worldloadlistener, flag, j, spawners, true, this.overworld().getRandomSequences(), org.bukkit.World.Environment.getEnvironment(dimension), gen, biomeProvider);
-+                // Paper end
++                // Paper end - option to use the dimension_type to check if spawners should be added
              }
  
              worlddata.setModdedInfo(this.getServerModName(), this.getModdedStatus().shouldReportAsModified());

patches/server/Pass-ServerLevel-for-gamerule-callbacks.patch

@@ -13,7 +13,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              //DedicatedServer.LOGGER.info("Done ({})! For help, type \"help\"", s); // Paper moved to after init
              if (dedicatedserverproperties.announcePlayerAchievements != null) {
 -                ((GameRules.BooleanValue) this.getGameRules().getRule(GameRules.RULE_ANNOUNCE_ADVANCEMENTS)).set(dedicatedserverproperties.announcePlayerAchievements, this);
-+                ((GameRules.BooleanValue) this.getGameRules().getRule(GameRules.RULE_ANNOUNCE_ADVANCEMENTS)).set(dedicatedserverproperties.announcePlayerAchievements, null); // Paper
++                ((GameRules.BooleanValue) this.getGameRules().getRule(GameRules.RULE_ANNOUNCE_ADVANCEMENTS)).set(dedicatedserverproperties.announcePlayerAchievements, null); // Paper - Pass ServerLevel for gamerule callbacks
              }
  
              if (dedicatedserverproperties.enableQuery) {
@@ -26,7 +26,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                      if (this.server.isHardcore()) {
                          this.player.setGameMode(GameType.SPECTATOR, org.bukkit.event.player.PlayerGameModeChangeEvent.Cause.HARDCORE_DEATH, null); // Paper
 -                        ((GameRules.BooleanValue) this.player.level().getGameRules().getRule(GameRules.RULE_SPECTATORSGENERATECHUNKS)).set(false, this.server);
-+                        ((GameRules.BooleanValue) this.player.level().getGameRules().getRule(GameRules.RULE_SPECTATORSGENERATECHUNKS)).set(false, this.player.serverLevel()); // Paper
++                        ((GameRules.BooleanValue) this.player.level().getGameRules().getRule(GameRules.RULE_SPECTATORSGENERATECHUNKS)).set(false, this.player.serverLevel()); // Paper - Pass ServerLevel for gamerule callbacks
                      }
                  }
                  break;
@@ -39,7 +39,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public static final GameRules.Key<GameRules.BooleanValue> RULE_REDUCEDDEBUGINFO = GameRules.register("reducedDebugInfo", GameRules.Category.MISC, GameRules.BooleanValue.create(false, (minecraftserver, gamerules_gameruleboolean) -> {
          int i = gamerules_gameruleboolean.get() ? 22 : 23;
 -        Iterator iterator = minecraftserver.getPlayerList().getPlayers().iterator();
-+        Iterator iterator = minecraftserver.players().iterator(); // Paper
++        Iterator iterator = minecraftserver.players().iterator(); // Paper - Pass ServerLevel for gamerule callbacks
  
          while (iterator.hasNext()) {
              ServerPlayer entityplayer = (ServerPlayer) iterator.next();
@@ -48,7 +48,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public static final GameRules.Key<GameRules.BooleanValue> RULE_WEATHER_CYCLE = GameRules.register("doWeatherCycle", GameRules.Category.UPDATES, GameRules.BooleanValue.create(true));
      public static final GameRules.Key<GameRules.BooleanValue> RULE_LIMITED_CRAFTING = GameRules.register("doLimitedCrafting", GameRules.Category.PLAYER, GameRules.BooleanValue.create(false, (minecraftserver, gamerules_gameruleboolean) -> {
 -        Iterator iterator = minecraftserver.getPlayerList().getPlayers().iterator();
-+        Iterator iterator = minecraftserver.players().iterator(); // Paper
++        Iterator iterator = minecraftserver.players().iterator(); // Paper - Pass ServerLevel for gamerule callbacks
  
          while (iterator.hasNext()) {
              ServerPlayer entityplayer = (ServerPlayer) iterator.next();
@@ -57,7 +57,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      public static final GameRules.Key<GameRules.BooleanValue> RULE_DOINSOMNIA = GameRules.register("doInsomnia", GameRules.Category.SPAWNING, GameRules.BooleanValue.create(true));
      public static final GameRules.Key<GameRules.BooleanValue> RULE_DO_IMMEDIATE_RESPAWN = GameRules.register("doImmediateRespawn", GameRules.Category.PLAYER, GameRules.BooleanValue.create(false, (minecraftserver, gamerules_gameruleboolean) -> {
 -        Iterator iterator = minecraftserver.getPlayerList().getPlayers().iterator();
-+        Iterator iterator = minecraftserver.players().iterator(); // Paper
++        Iterator iterator = minecraftserver.players().iterator(); // Paper - Pass ServerLevel for gamerule callbacks
  
          while (iterator.hasNext()) {
              ServerPlayer entityplayer = (ServerPlayer) iterator.next();
@@ -66,14 +66,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      }
  
 -    public void assignFrom(GameRules rules, @Nullable MinecraftServer server) {
-+    public void assignFrom(GameRules rules, @Nullable net.minecraft.server.level.ServerLevel server) { // Paper
++    public void assignFrom(GameRules rules, @Nullable net.minecraft.server.level.ServerLevel server) { // Paper - Pass ServerLevel for gamerule callbacks
          rules.rules.keySet().forEach((gamerules_gamerulekey) -> {
              this.assignCap(gamerules_gamerulekey, rules, server);
          });
      }
  
 -    private <T extends GameRules.Value<T>> void assignCap(GameRules.Key<T> key, GameRules rules, @Nullable MinecraftServer server) {
-+    private <T extends GameRules.Value<T>> void assignCap(GameRules.Key<T> key, GameRules rules, @Nullable net.minecraft.server.level.ServerLevel server) { // Paper
++    private <T extends GameRules.Value<T>> void assignCap(GameRules.Key<T> key, GameRules rules, @Nullable net.minecraft.server.level.ServerLevel server) { // Paper - Pass ServerLevel for gamerule callbacks
          T t0 = rules.getRule(key);
  
          this.getRule(key).setFrom(t0, server);
@@ -82,11 +82,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          private final Supplier<ArgumentType<?>> argument;
          private final Function<GameRules.Type<T>, T> constructor;
 -        final BiConsumer<MinecraftServer, T> callback;
-+        final BiConsumer<net.minecraft.server.level.ServerLevel, T> callback; // Paper
++        final BiConsumer<net.minecraft.server.level.ServerLevel, T> callback; // Paper - Pass ServerLevel for gamerule callbacks
          private final GameRules.VisitorCaller<T> visitorCaller;
  
 -        Type(Supplier<ArgumentType<?>> argumentType, Function<GameRules.Type<T>, T> ruleFactory, BiConsumer<MinecraftServer, T> changeCallback, GameRules.VisitorCaller<T> ruleAcceptor) {
-+        Type(Supplier<ArgumentType<?>> argumentType, Function<GameRules.Type<T>, T> ruleFactory, BiConsumer<net.minecraft.server.level.ServerLevel, T> changeCallback, GameRules.VisitorCaller<T> ruleAcceptor) { // Paper
++        Type(Supplier<ArgumentType<?>> argumentType, Function<GameRules.Type<T>, T> ruleFactory, BiConsumer<net.minecraft.server.level.ServerLevel, T> changeCallback, GameRules.VisitorCaller<T> ruleAcceptor) { // Paper - Pass ServerLevel for gamerule callbacks
              this.argument = argumentType;
              this.constructor = ruleFactory;
              this.callback = changeCallback;
@@ -95,11 +95,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          public void setFromArgument(CommandContext<CommandSourceStack> context, String name, GameRules.Key<T> gameRuleKey) { // Paper
              this.updateFromArgument(context, name, gameRuleKey); // Paper
 -            this.onChanged(((CommandSourceStack) context.getSource()).getServer());
-+            this.onChanged(((CommandSourceStack) context.getSource()).getLevel()); // Paper
++            this.onChanged(((CommandSourceStack) context.getSource()).getLevel()); // Paper - Pass ServerLevel for gamerule callbacks
          }
  
 -        public void onChanged(@Nullable MinecraftServer server) {
-+        public void onChanged(@Nullable net.minecraft.server.level.ServerLevel server) { // Paper
++        public void onChanged(@Nullable net.minecraft.server.level.ServerLevel server) { // Paper - Pass ServerLevel for gamerule callbacks
              if (server != null) {
                  this.type.callback.accept(server, this.getSelf());
              }
@@ -108,7 +108,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          protected abstract T copy();
  
 -        public abstract void setFrom(T rule, @Nullable MinecraftServer server);
-+        public abstract void setFrom(T rule, @Nullable net.minecraft.server.level.ServerLevel level); // Paper
++        public abstract void setFrom(T rule, @Nullable net.minecraft.server.level.ServerLevel level); // Paper - Pass ServerLevel for gamerule callbacks
      }
  
      public interface GameRuleTypeVisitor {
@@ -117,7 +117,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          private boolean value;
  
 -        static GameRules.Type<GameRules.BooleanValue> create(boolean initialValue, BiConsumer<MinecraftServer, GameRules.BooleanValue> changeCallback) {
-+        static GameRules.Type<GameRules.BooleanValue> create(boolean initialValue, BiConsumer<net.minecraft.server.level.ServerLevel, GameRules.BooleanValue> changeCallback) { // Paper
++        static GameRules.Type<GameRules.BooleanValue> create(boolean initialValue, BiConsumer<net.minecraft.server.level.ServerLevel, GameRules.BooleanValue> changeCallback) { // Paper - Pass ServerLevel for gamerule callbacks
              return new GameRules.Type<>(BoolArgumentType::bool, (gamerules_gameruledefinition) -> {
                  return new GameRules.BooleanValue(gamerules_gameruledefinition, initialValue);
              }, changeCallback, GameRules.GameRuleTypeVisitor::visitBoolean);
@@ -126,7 +126,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          }
  
 -        public void set(boolean value, @Nullable MinecraftServer server) {
-+        public void set(boolean value, @Nullable net.minecraft.server.level.ServerLevel server) { // Paper
++        public void set(boolean value, @Nullable net.minecraft.server.level.ServerLevel server) { // Paper - Pass ServerLevel for gamerule callbacks
              this.value = value;
              this.onChanged(server);
          }
@@ -135,7 +135,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          }
  
 -        public void setFrom(GameRules.BooleanValue rule, @Nullable MinecraftServer server) {
-+        public void setFrom(GameRules.BooleanValue rule, @Nullable net.minecraft.server.level.ServerLevel server) { // Paper
++        public void setFrom(GameRules.BooleanValue rule, @Nullable net.minecraft.server.level.ServerLevel server) { // Paper - Pass ServerLevel for gamerule callbacks
              this.value = rule.value;
              this.onChanged(server);
          }
@@ -144,7 +144,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          private int value;
  
 -        private static GameRules.Type<GameRules.IntegerValue> create(int initialValue, BiConsumer<MinecraftServer, GameRules.IntegerValue> changeCallback) {
-+        private static GameRules.Type<GameRules.IntegerValue> create(int initialValue, BiConsumer<net.minecraft.server.level.ServerLevel, GameRules.IntegerValue> changeCallback) { // Paper
++        private static GameRules.Type<GameRules.IntegerValue> create(int initialValue, BiConsumer<net.minecraft.server.level.ServerLevel, GameRules.IntegerValue> changeCallback) { // Paper - Pass ServerLevel for gamerule callbacks
              return new GameRules.Type<>(IntegerArgumentType::integer, (gamerules_gameruledefinition) -> {
                  return new GameRules.IntegerValue(gamerules_gameruledefinition, initialValue);
              }, changeCallback, GameRules.GameRuleTypeVisitor::visitInteger);
@@ -153,7 +153,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          }
  
 -        public void set(int value, @Nullable MinecraftServer server) {
-+        public void set(int value, @Nullable net.minecraft.server.level.ServerLevel server) { // Paper
++        public void set(int value, @Nullable net.minecraft.server.level.ServerLevel server) { // Paper - Pass ServerLevel for gamerule callbacks
              this.value = value;
              this.onChanged(server);
          }
@@ -162,7 +162,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          }
  
 -        public void setFrom(GameRules.IntegerValue rule, @Nullable MinecraftServer server) {
-+        public void setFrom(GameRules.IntegerValue rule, @Nullable net.minecraft.server.level.ServerLevel server) { // Paper
++        public void setFrom(GameRules.IntegerValue rule, @Nullable net.minecraft.server.level.ServerLevel server) { // Paper - Pass ServerLevel for gamerule callbacks
              this.value = rule.value;
              this.onChanged(server);
          }
@@ -175,7 +175,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          GameRules.Value<?> handle = this.getHandle().getGameRules().getRule(CraftWorld.getGameRulesNMS().get(rule));
          handle.deserialize(event.getValue()); // Paper
 -        handle.onChanged(this.getHandle().getServer());
-+        handle.onChanged(this.getHandle()); // Paper
++        handle.onChanged(this.getHandle()); // Paper - Pass ServerLevel for gamerule callbacks
          return true;
      }
  
@@ -184,7 +184,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          GameRules.Value<?> handle = this.getHandle().getGameRules().getRule(CraftWorld.getGameRulesNMS().get(rule.getName()));
          handle.deserialize(event.getValue()); // Paper
 -        handle.onChanged(this.getHandle().getServer());
-+        handle.onChanged(this.getHandle()); // Paper
++        handle.onChanged(this.getHandle()); // Paper - Pass ServerLevel for gamerule callbacks
          return true;
      }
  

patches/server/Prevent-entity-loading-causing-async-lookups.patch

@@ -12,7 +12,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      public void baseTick() {
          this.level().getProfiler().push("entityBaseTick");
-+        if (firstTick && this instanceof net.minecraft.world.entity.NeutralMob neutralMob) neutralMob.tickInitialPersistentAnger(level); // Paper - Update last hurt when ticking
++        if (firstTick && this instanceof net.minecraft.world.entity.NeutralMob neutralMob) neutralMob.tickInitialPersistentAnger(level); // Paper - Prevent entity loading causing async lookups
          this.feetBlockState = null;
          if (this.isPassenger() && this.getVehicle().isRemoved()) {
              this.stopRiding();
@@ -36,7 +36,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -                    }
 -
 -                }
-+                // Paper - Moved diff to separate method
++                // Paper - Prevent entity loading causing async lookups; Moved diff to separate method
 +                // If this entity already survived its first tick, e.g. is loaded and ticked in sync, actively
 +                // tick the initial persistent anger.
 +                // If not, let the first tick on the baseTick call the method later down the line.
@@ -49,7 +49,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
      @Nullable
      LivingEntity getTarget();
 +
-+    // Paper start - Update last hurt when ticking
++    // Paper start - Prevent entity loading causing async lookups
++    // Update last hurt when ticking
 +    default void tickInitialPersistentAnger(Level level) {
 +        UUID target = getPersistentAngerTarget();
 +        if (target == null) {
@@ -69,5 +70,5 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +
 +        }
 +    }
-+    // Paper end
++    // Paper end - Prevent entity loading causing async lookups
  }

patches/server/Prevent-tile-entity-copies-loading-chunks.patch

@@ -13,12 +13,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
                  if (this.player.level().isLoaded(blockposition)) {
 -                    BlockEntity tileentity = this.player.level().getBlockEntity(blockposition);
-+                    // Paper start
++                    // Paper start - Prevent tile entity copies loading chunks
 +                    BlockEntity tileentity = null;
 +                    if (this.player.distanceToSqr(blockposition.getX(), blockposition.getY(), blockposition.getZ()) < 32 * 32 && this.player.serverLevel().isLoadedAndInBounds(blockposition)) {
 +                        tileentity = this.player.level().getBlockEntity(blockposition);
 +                    }
-+                    // Paper end
++                    // Paper end - Prevent tile entity copies loading chunks
  
                      if (tileentity != null) {
                          tileentity.saveToItem(itemstack);

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

@@ -13,7 +13,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 --- a/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
 +++ b/src/main/java/net/minecraft/server/level/ServerPlayerGameMode.java
 @@ -0,0 +0,0 @@ public class ServerPlayerGameMode {
-                     isCorrectTool = flag1; // Paper
+                     isCorrectTool = flag1; // Paper - Trigger bee_nest_destroyed trigger in the correct place
  
                      itemstack.mineBlock(this.level, iblockdata1, pos, this.player);
 -                    if (flag && flag1 && event.isDropItems()) { // CraftBukkit - Check if block should drop items

patches/server/Put-world-into-worldlist-before-initing-the-world.patch

@@ -14,11 +14,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              }
  
              worlddata.setModdedInfo(this.getServerModName(), this.getModdedStatus().shouldReportAsModified());
-+            this.addLevel(world); // Paper - move up
++            this.addLevel(world); // Paper - Put world into worldlist before initing the world; move up
              this.initWorld(world, worlddata, this.worldData, worldoptions);
  
 -            this.addLevel(world);
-+            // Paper - move up
++            // Paper - Put world into worldlist before initing the world; move up
              this.getPlayerList().addWorldborderListener(world);
  
              if (worlddata.getCustomBossEvents() != null) {
@@ -30,12 +30,12 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              return null;
          }
  
-+        this.console.addLevel(internal); // Paper - move up
++        this.console.addLevel(internal); // Paper - Put world into worldlist before initing the world; move up
          this.console.initWorld(internal, worlddata, worlddata, worlddata.worldGenOptions());
  
          internal.setSpawnSettings(true, true);
 -        this.console.addLevel(internal);
-+        // Paper - move up
++        // Paper - Put world into worldlist before initing the world; move up
  
          this.getServer().prepareLevels(internal.getChunkSource().chunkMap.progressListener, internal);
          //internal.entityManager.tick(); // SPIGOT-6526: Load pending entities so they are available to the API // Paper - rewrite chunk system

patches/server/Restore-vanilla-entity-drops-behavior.patch

@@ -28,7 +28,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  }
              }
          }
-         if (this.shouldDropLoot() && this.level().getGameRules().getBoolean(GameRules.RULE_DOMOBLOOT)) { // Paper - preserve this check from vanilla
+         if (this.shouldDropLoot() && this.level().getGameRules().getBoolean(GameRules.RULE_DOMOBLOOT)) { // Paper - fix player loottables running when mob loot gamerule is false
          // SPIGOT-5071: manually add player loot tables (SPIGOT-5195 - ignores keepInventory rule)
          this.dropFromLootTable(damageSource, this.lastHurtByPlayerTime > 0);
 -        for (org.bukkit.inventory.ItemStack item : this.drops) {
@@ -36,7 +36,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 -        }
 +        loot.addAll(this.drops); // Paper
          this.drops.clear(); // SPIGOT-5188: make sure to clear
-         } // Paper
+         } // Paper - fix player loottables running when mob loot gamerule is false
  
 @@ -0,0 +0,0 @@ public class ServerPlayer extends Player {
      }

patches/server/Sanitize-sent-BlockEntity-NBT.patch

@@ -1,7 +1,7 @@
 From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
 From: Owen1212055 <23108066+Owen1212055@users.noreply.github.com>
 Date: Fri, 3 Dec 2021 16:55:50 -0500
-Subject: [PATCH] Sanitize Sent BlockEntity NBT
+Subject: [PATCH] Sanitize sent BlockEntity NBT
 
 
 diff --git a/src/main/java/net/minecraft/network/protocol/game/ClientboundBlockEntityDataPacket.java b/src/main/java/net/minecraft/network/protocol/game/ClientboundBlockEntityDataPacket.java
@@ -37,12 +37,11 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          return null;
      }
      // CraftBukkit end
-+    // Paper start
++    // Paper start - Sanitize sent data
 +    public CompoundTag sanitizeSentNbt(CompoundTag tag) {
 +        tag.remove("PublicBukkitValues");
 +
 +        return tag;
 +    }
-+    // Paper end
++    // Paper end - Sanitize sent data
-+
  }

patches/server/Throw-exception-on-world-create-while-being-ticked.patch

@@ -14,7 +14,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      public volatile Thread shutdownThread; // Paper
      public volatile boolean abnormalExit = false; // Paper
-+    public boolean isIteratingOverLevels = false; // Paper
++    public boolean isIteratingOverLevels = false; // Paper - Throw exception on world create while being ticked
  
      public static <S extends MinecraftServer> S spin(Function<Thread, S> serverFactory) {
          AtomicReference<S> atomicreference = new AtomicReference();
@@ -23,7 +23,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          MinecraftTimings.commandFunctionsTimer.stopTiming(); // Spigot // Paper
          this.profiler.popPush("levels");
 -        Iterator iterator = this.getAllLevels().iterator();
-+        //Iterator iterator = this.getAllLevels().iterator(); // Paper - moved down
++        //Iterator iterator = this.getAllLevels().iterator(); // Paper - Throw exception on world create while being ticked; moved down
  
          // CraftBukkit start
          // Run tasks that are waiting on processing
@@ -31,8 +31,8 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          // Paper end
          MinecraftTimings.timeUpdateTimer.stopTiming(); // Spigot // Paper
  
-+        this.isIteratingOverLevels = true; // Paper
++        this.isIteratingOverLevels = true; // Paper - Throw exception on world create while being ticked
-+        Iterator iterator = this.getAllLevels().iterator(); // Paper - move down
++        Iterator iterator = this.getAllLevels().iterator(); // Paper - Throw exception on world create while being ticked; move down
          while (iterator.hasNext()) {
              ServerLevel worldserver = (ServerLevel) iterator.next();
              worldserver.hasPhysicsEvent =  org.bukkit.event.block.BlockPhysicsEvent.getHandlerList().getRegisteredListeners().length > 0; // Paper
@@ -40,7 +40,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              this.profiler.pop();
              worldserver.explosionDensityCache.clear(); // Paper - Optimize explosions
          }
-+        this.isIteratingOverLevels = false; // Paper
++        this.isIteratingOverLevels = false; // Paper - Throw exception on world create while being ticked
  
          this.profiler.popPush("connection");
          MinecraftTimings.connectionTimer.startTiming(); // Spigot // Paper

patches/server/Trigger-bee_nest_destroyed-trigger-in-the-correct-pl.patch

@@ -12,16 +12,16 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                      block.destroy(this.level, pos, iblockdata1);
                  }
  
-+                ItemStack mainHandStack = null; // Paper
++                ItemStack mainHandStack = null; // Paper - Trigger bee_nest_destroyed trigger in the correct place
-+                boolean isCorrectTool = false; // Paper
++                boolean isCorrectTool = false; // Paper - Trigger bee_nest_destroyed trigger in the correct place
                  if (this.isCreative()) {
                      // return true; // CraftBukkit
                  } else {
                      ItemStack itemstack = this.player.getMainHandItem();
                      ItemStack itemstack1 = itemstack.copy();
                      boolean flag1 = this.player.hasCorrectToolForDrops(iblockdata1);
-+                    mainHandStack = itemstack1; // Paper
++                    mainHandStack = itemstack1; // Paper - Trigger bee_nest_destroyed trigger in the correct place
-+                    isCorrectTool = flag1; // Paper
++                    isCorrectTool = flag1; // Paper - Trigger bee_nest_destroyed trigger in the correct place
  
                      itemstack.mineBlock(this.level, iblockdata1, pos, this.player);
                      if (flag && flag1 && event.isDropItems()) { // CraftBukkit - Check if block should drop items
@@ -29,13 +29,13 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  if (flag && event != null) {
                      iblockdata.getBlock().popExperience(this.level, pos, event.getExpToDrop(), this.player); // Paper
                  }
-+                // Paper start - trigger after items are dropped (check impls of block#playerDestroy)
++                // Paper start - Trigger bee_nest_destroyed trigger in the correct place (check impls of block#playerDestroy)
 +                if (mainHandStack != null) {
 +                    if (flag && isCorrectTool && event.isDropItems() && block instanceof net.minecraft.world.level.block.BeehiveBlock && tileentity instanceof net.minecraft.world.level.block.entity.BeehiveBlockEntity beehiveBlockEntity) { // simulates the guard on block#playerDestroy above
 +                        CriteriaTriggers.BEE_NEST_DESTROYED.trigger(player, iblockdata, mainHandStack, beehiveBlockEntity.getOccupantCount());
 +                    }
 +                }
-+                // Paper end
++                // Paper end - Trigger bee_nest_destroyed trigger in the correct place
  
                  return true;
                  // CraftBukkit end
@@ -48,7 +48,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              }
  
 -            CriteriaTriggers.BEE_NEST_DESTROYED.trigger((ServerPlayer) player, state, tool, tileentitybeehive.getOccupantCount());
-+            // CriteriaTriggers.BEE_NEST_DESTROYED.trigger((ServerPlayer) player, state, tool, tileentitybeehive.getOccupantCount()); // Paper - moved until after items are dropped
++            // CriteriaTriggers.BEE_NEST_DESTROYED.trigger((ServerPlayer) player, state, tool, tileentitybeehive.getOccupantCount()); // Paper - Trigger bee_nest_destroyed trigger in the correct place; moved until after items are dropped
          }
  
      }

patches/server/WorldCreator-keepSpawnLoaded.patch

@@ -19,7 +19,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
              return null;
 @@ -0,0 +0,0 @@ public final class CraftServer implements Server {
          internal.setSpawnSettings(true, true);
-         // Paper - move up
+         // Paper - Put world into worldlist before initing the world; move up
  
 +        internal.keepSpawnInMemory = creator.keepSpawnLoaded().toBooleanOrElse(internal.getWorld().getKeepSpawnInMemory()); // Paper
          this.getServer().prepareLevels(internal.getChunkSource().chunkMap.progressListener, internal);

patches/server/fix-player-loottables-running-when-mob-loot-gamerule.patch

@@ -12,14 +12,14 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
                  }
              }
          }
-+        if (this.shouldDropLoot() && this.level().getGameRules().getBoolean(GameRules.RULE_DOMOBLOOT)) { // Paper - preserve this check from vanilla
++        if (this.shouldDropLoot() && this.level().getGameRules().getBoolean(GameRules.RULE_DOMOBLOOT)) { // Paper - fix player loottables running when mob loot gamerule is false
          // SPIGOT-5071: manually add player loot tables (SPIGOT-5195 - ignores keepInventory rule)
          this.dropFromLootTable(damageSource, this.lastHurtByPlayerTime > 0);
          for (org.bukkit.inventory.ItemStack item : this.drops) {
              loot.add(item);
          }
          this.drops.clear(); // SPIGOT-5188: make sure to clear
-+        } // Paper
++        } // Paper - fix player loottables running when mob loot gamerule is false
  
          Component defaultMessage = this.getCombatTracker().getDeathMessage();
  

patches/server/fix-powder-snow-cauldrons-not-turning-to-water.patch

@@ -23,7 +23,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
  
      }
  
-+    @Deprecated // Paper - use #handleEntityOnFireInsideWithEvent
++    @Deprecated // Paper - fix powdered snow cauldron extinguishing entities; use #handleEntityOnFireInsideWithEvent
      private void handleEntityOnFireInside(BlockState state, Level world, BlockPos pos) {
          if (this.precipitationType == Biome.Precipitation.SNOW) {
              LayeredCauldronBlock.lowerFillLevel((BlockState) Blocks.WATER_CAULDRON.defaultBlockState().setValue(LayeredCauldronBlock.LEVEL, (Integer) state.getValue(LayeredCauldronBlock.LEVEL)), world, pos);
@@ -31,7 +31,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
          }
  
      }
-+    // Paper start
++    // Paper start - fix powdered snow cauldron extinguishing entities
 +    protected boolean handleEntityOnFireInsideWithEvent(BlockState state, Level world, BlockPos pos, Entity entity) {
 +        if (this.precipitationType == Biome.Precipitation.SNOW) {
 +            return LayeredCauldronBlock.lowerFillLevel((BlockState) Blocks.WATER_CAULDRON.defaultBlockState().setValue(LayeredCauldronBlock.LEVEL, (Integer) state.getValue(LayeredCauldronBlock.LEVEL)), world, pos, entity, CauldronLevelChangeEvent.ChangeReason.EXTINGUISH);
@@ -39,7 +39,7 @@ index 0000000000000000000000000000000000000000..00000000000000000000000000000000
 +            return LayeredCauldronBlock.lowerFillLevel(state, world, pos, entity, CauldronLevelChangeEvent.ChangeReason.EXTINGUISH);
 +        }
 +    }
-+    // Paper end
++    // Paper end - fix powdered snow cauldron extinguishing entities
  
      public static void lowerFillLevel(BlockState state, Level world, BlockPos pos) {
          // CraftBukkit start