Updated Upstream (Pufferfish) (#1575)

Upstream has released updates that appear to apply and compile correctly

Pufferfish Changes:
pufferfish-gg/Pufferfish@c9f4e20 Final 1.20.4 Update
pufferfish-gg/Pufferfish@1f3ad02 Final 1.20.4 update, for realzies
pufferfish-gg/Pufferfish@b1ab664 Enable SIMD on java 21
pufferfish-gg/Pufferfish@0674c2b 1.21 compiles
pufferfish-gg/Pufferfish@98ea973 Fix 1.21 version checkers
pufferfish-gg/Pufferfish@68f859c Fix lambda/tick guard patch
pufferfish-gg/Pufferfish@eaa18d5 Updated Upstream (Paper)
pufferfish-gg/Pufferfish@1d72eea Updated Upstream (Paper)
pufferfish-gg/Pufferfish@1d3c743 Update pufferfish version detector stuff
pufferfish-gg/Pufferfish@5e30963 Fix crash bug
pufferfish-gg/Pufferfish@12571eb Use mojmapped paperclip jar instead (CI only)
pufferfish-gg/Pufferfish@4d16ae0 Drop a patch - moonrise includes it
pufferfish-gg/Pufferfish@52c2d05 Revert "Drop a patch - moonrise includes it"
pufferfish-gg/Pufferfish@bdb56f1 Fix entity interactions with fluids
pufferfish-gg/Pufferfish@469e5c1 Updated Upstream (Paper)
pufferfish-gg/Pufferfish@d75961f 1.21.1 Update (Updated Upstream (Paper))

patches/api/0001-Pufferfish-API-Changes.patch

@@ -0,0 +1,527 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: Kevin Raneri <kevin.raneri@gmail.com>
+Date: Tue, 9 Nov 2021 14:01:56 -0500
+Subject: [PATCH] Pufferfish API Changes
+
+Pufferfish
+Copyright (C) 2022 Pufferfish Studios LLC
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+diff --git a/build.gradle.kts b/build.gradle.kts
+index 540fe7e2c110e79c3742f229b3ed8c54b101d260..07945418e95cbe07c45bfa815d828fa311c7f033 100644
+--- a/build.gradle.kts
++++ b/build.gradle.kts
+@@ -52,6 +52,7 @@ dependencies {
+     apiAndDocs("net.kyori:adventure-text-logger-slf4j")
+     api("org.apache.logging.log4j:log4j-api:$log4jVersion")
+     api("org.slf4j:slf4j-api:$slf4jVersion")
++    api("io.sentry:sentry:5.4.0") // Pufferfish
+ 
+     implementation("org.ow2.asm:asm:9.7")
+     implementation("org.ow2.asm:asm-commons:9.7")
+@@ -130,6 +131,13 @@ val generateApiVersioningFile by tasks.registering {
+     }
+ }
+ 
++// Pufferfish Start
++tasks.withType<JavaCompile> {
++    val compilerArgs = options.compilerArgs
++    compilerArgs.add("--add-modules=jdk.incubator.vector")
++}
++// Pufferfish End
++
+ tasks.jar {
+     from(generateApiVersioningFile.map { it.outputs.files.singleFile }) {
+         into("META-INF/maven/${project.group}/${project.name}")
+diff --git a/src/main/java/gg/pufferfish/pufferfish/sentry/SentryContext.java b/src/main/java/gg/pufferfish/pufferfish/sentry/SentryContext.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..10310fdd53de28efb8a8250f6d3b0c8eb08fb68a
+--- /dev/null
++++ b/src/main/java/gg/pufferfish/pufferfish/sentry/SentryContext.java
+@@ -0,0 +1,161 @@
++package gg.pufferfish.pufferfish.sentry;
++
++import com.google.gson.Gson;
++import java.lang.reflect.Field;
++import java.lang.reflect.Modifier;
++import java.util.Map;
++import java.util.TreeMap;
++import org.apache.logging.log4j.ThreadContext;
++import org.bukkit.command.Command;
++import org.bukkit.command.CommandSender;
++import org.bukkit.entity.Player;
++import org.bukkit.event.Event;
++import org.bukkit.event.player.PlayerEvent;
++import org.bukkit.plugin.Plugin;
++import org.bukkit.plugin.RegisteredListener;
++import org.jetbrains.annotations.Nullable;
++
++public class SentryContext {
++	
++	private static final Gson GSON = new Gson();
++	
++	public static void setPluginContext(@Nullable Plugin plugin) {
++		if (plugin != null) {
++			ThreadContext.put("pufferfishsentry_pluginname", plugin.getName());
++			ThreadContext.put("pufferfishsentry_pluginversion", plugin.getDescription().getVersion());
++		}
++	}
++	
++	public static void removePluginContext() {
++		ThreadContext.remove("pufferfishsentry_pluginname");
++		ThreadContext.remove("pufferfishsentry_pluginversion");
++	}
++	
++	public static void setSenderContext(@Nullable CommandSender sender) {
++		if (sender != null) {
++			ThreadContext.put("pufferfishsentry_playername", sender.getName());
++			if (sender instanceof Player player) {
++				ThreadContext.put("pufferfishsentry_playerid", player.getUniqueId().toString());
++			}
++		}
++	}
++	
++	public static void removeSenderContext() {
++		ThreadContext.remove("pufferfishsentry_playername");
++		ThreadContext.remove("pufferfishsentry_playerid");
++	}
++	
++	public static void setEventContext(Event event, RegisteredListener registration) {
++		setPluginContext(registration.getPlugin());
++		
++		try {
++			// Find the player that was involved with this event
++			Player player = null;
++			if (event instanceof PlayerEvent) {
++				player = ((PlayerEvent) event).getPlayer();
++			} else {
++				Class<? extends Event> eventClass = event.getClass();
++				
++				Field playerField = null;
++				
++				for (Field field : eventClass.getDeclaredFields()) {
++					if (field.getType().equals(Player.class)) {
++						playerField = field;
++						break;
++					}
++				}
++				
++				if (playerField != null) {
++					playerField.setAccessible(true);
++					player = (Player) playerField.get(event);
++				}
++			}
++			
++			if (player != null) {
++				setSenderContext(player);
++			}
++		} catch (Exception e) {} // We can't really safely log exceptions.
++		
++		ThreadContext.put("pufferfishsentry_eventdata", GSON.toJson(serializeFields(event)));
++	}
++	
++	public static void removeEventContext() {
++		removePluginContext();
++		removeSenderContext();
++		ThreadContext.remove("pufferfishsentry_eventdata");
++	}
++	
++	private static Map<String, String> serializeFields(Object object) {
++		Map<String, String> fields = new TreeMap<>();
++		fields.put("_class", object.getClass().getName());
++		for (Field declaredField : object.getClass().getDeclaredFields()) {
++			try {
++				if (Modifier.isStatic(declaredField.getModifiers())) {
++					continue;
++				}
++				
++				String fieldName = declaredField.getName();
++				if (fieldName.equals("handlers")) {
++					continue;
++				}
++				declaredField.setAccessible(true);
++				Object value = declaredField.get(object);
++				if (value != null) {
++					fields.put(fieldName, value.toString());
++				} else {
++					fields.put(fieldName, "<null>");
++				}
++			} catch (Exception e) {} // We can't really safely log exceptions.
++		}
++		return fields;
++	}
++	
++	public static class State {
++		
++		private Plugin plugin;
++		private Command command;
++		private String commandLine;
++		private Event event;
++		private RegisteredListener registeredListener;
++		
++		public Plugin getPlugin() {
++			return plugin;
++		}
++		
++		public void setPlugin(Plugin plugin) {
++			this.plugin = plugin;
++		}
++		
++		public Command getCommand() {
++			return command;
++		}
++		
++		public void setCommand(Command command) {
++			this.command = command;
++		}
++		
++		public String getCommandLine() {
++			return commandLine;
++		}
++		
++		public void setCommandLine(String commandLine) {
++			this.commandLine = commandLine;
++		}
++		
++		public Event getEvent() {
++			return event;
++		}
++		
++		public void setEvent(Event event) {
++			this.event = event;
++		}
++		
++		public RegisteredListener getRegisteredListener() {
++			return registeredListener;
++		}
++		
++		public void setRegisteredListener(RegisteredListener registeredListener) {
++			this.registeredListener = registeredListener;
++		}
++	}
++}
+diff --git a/src/main/java/gg/pufferfish/pufferfish/simd/SIMDChecker.java b/src/main/java/gg/pufferfish/pufferfish/simd/SIMDChecker.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..3441cdad70da1bd523c5933b1a914688718c2657
+--- /dev/null
++++ b/src/main/java/gg/pufferfish/pufferfish/simd/SIMDChecker.java
+@@ -0,0 +1,40 @@
++package gg.pufferfish.pufferfish.simd;
++
++import java.util.logging.Level;
++import java.util.logging.Logger;
++import jdk.incubator.vector.FloatVector;
++import jdk.incubator.vector.IntVector;
++import jdk.incubator.vector.VectorSpecies;
++
++/**
++ * Basically, java is annoying and we have to push this out to its own class.
++ */
++@Deprecated
++public class SIMDChecker {
++	
++	@Deprecated
++	public static boolean canEnable(Logger logger) {
++		try {
++			if (SIMDDetection.getJavaVersion() < 17 || SIMDDetection.getJavaVersion() > 21) {
++				return false;
++			} else {
++				SIMDDetection.testRun = true;
++				
++				VectorSpecies<Integer> ISPEC = IntVector.SPECIES_PREFERRED;
++				VectorSpecies<Float> FSPEC = FloatVector.SPECIES_PREFERRED;
++				
++				logger.log(Level.INFO, "Max SIMD vector size on this system is " + ISPEC.vectorBitSize() + " bits (int)");
++				logger.log(Level.INFO, "Max SIMD vector size on this system is " + FSPEC.vectorBitSize() + " bits (float)");
++				
++				if (ISPEC.elementSize() < 2 || FSPEC.elementSize() < 2) {
++					logger.log(Level.WARNING, "SIMD is not properly supported on this system!");
++					return false;
++				}
++
++				return true;
++			}
++		} catch (NoClassDefFoundError | Exception ignored) {} // Basically, we don't do anything. This lets us detect if it's not functional and disable it.
++		return false;
++	}
++	
++}
+diff --git a/src/main/java/gg/pufferfish/pufferfish/simd/SIMDDetection.java b/src/main/java/gg/pufferfish/pufferfish/simd/SIMDDetection.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..a84889d3e9cfc4d7ab5f867820a6484c6070711b
+--- /dev/null
++++ b/src/main/java/gg/pufferfish/pufferfish/simd/SIMDDetection.java
+@@ -0,0 +1,35 @@
++package gg.pufferfish.pufferfish.simd;
++
++import java.util.logging.Logger;
++
++@Deprecated
++public class SIMDDetection {
++	
++	public static boolean isEnabled = false;
++	public static boolean versionLimited = false;
++	public static boolean testRun = false;
++	
++	@Deprecated
++	public static boolean canEnable(Logger logger) {
++		try {
++			return SIMDChecker.canEnable(logger);
++		} catch (NoClassDefFoundError | Exception ignored) {
++			return false;
++		}
++	}
++	
++	@Deprecated
++	public static int getJavaVersion() {
++		// https://stackoverflow.com/a/2591122
++		String version = System.getProperty("java.version");
++		if(version.startsWith("1.")) {
++			version = version.substring(2, 3);
++		} else {
++			int dot = version.indexOf(".");
++			if(dot != -1) { version = version.substring(0, dot); }
++		}
++		version = version.split("-")[0]; // Azul is stupid
++		return Integer.parseInt(version);
++	}
++	
++}
+diff --git a/src/main/java/gg/pufferfish/pufferfish/simd/VectorMapPalette.java b/src/main/java/gg/pufferfish/pufferfish/simd/VectorMapPalette.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..ae2464920c9412ac90b819a540ee58be0741465f
+--- /dev/null
++++ b/src/main/java/gg/pufferfish/pufferfish/simd/VectorMapPalette.java
+@@ -0,0 +1,83 @@
++package gg.pufferfish.pufferfish.simd;
++
++import java.awt.Color;
++import jdk.incubator.vector.FloatVector;
++import jdk.incubator.vector.IntVector;
++import jdk.incubator.vector.VectorMask;
++import jdk.incubator.vector.VectorSpecies;
++import org.bukkit.map.MapPalette;
++
++@Deprecated
++public class VectorMapPalette {
++	
++	private static final VectorSpecies<Integer> I_SPEC = IntVector.SPECIES_PREFERRED;
++	private static final VectorSpecies<Float> F_SPEC = FloatVector.SPECIES_PREFERRED;
++	
++	@Deprecated
++	public static void matchColorVectorized(int[] in, byte[] out) {
++		int speciesLength = I_SPEC.length();
++		int i;
++		for (i = 0; i < in.length - speciesLength; i += speciesLength) {
++			float[] redsArr = new float[speciesLength];
++			float[] bluesArr = new float[speciesLength];
++			float[] greensArr = new float[speciesLength];
++			int[] alphasArr = new int[speciesLength];
++			
++			for (int j = 0; j < speciesLength; j++) {
++				alphasArr[j] = (in[i + j] >> 24) & 0xFF;
++				redsArr[j] = (in[i + j] >> 16) & 0xFF;
++				greensArr[j] = (in[i + j] >> 8) & 0xFF;
++				bluesArr[j] = (in[i + j] >> 0) & 0xFF;
++			}
++			
++			IntVector alphas = IntVector.fromArray(I_SPEC, alphasArr, 0);
++			FloatVector reds = FloatVector.fromArray(F_SPEC, redsArr, 0);
++			FloatVector greens = FloatVector.fromArray(F_SPEC, greensArr, 0);
++			FloatVector blues = FloatVector.fromArray(F_SPEC, bluesArr, 0);
++			IntVector resultIndex = IntVector.zero(I_SPEC);
++			VectorMask<Integer> modificationMask = VectorMask.fromLong(I_SPEC, 0xffffffff);
++			
++			modificationMask = modificationMask.and(alphas.lt(128).not());
++			FloatVector bestDistances = FloatVector.broadcast(F_SPEC, Float.MAX_VALUE);
++			
++			for (int c = 4; c < MapPalette.colors.length; c++) {
++				// We're using 32-bit floats here because it's 2x faster and nobody will know the difference.
++				// For correctness, the original algorithm uses 64-bit floats instead. Completely unnecessary.
++				FloatVector compReds = FloatVector.broadcast(F_SPEC, MapPalette.colors[c].getRed());
++				FloatVector compGreens = FloatVector.broadcast(F_SPEC, MapPalette.colors[c].getGreen());
++				FloatVector compBlues = FloatVector.broadcast(F_SPEC, MapPalette.colors[c].getBlue());
++				
++				FloatVector rMean = reds.add(compReds).div(2.0f);
++				FloatVector rDiff = reds.sub(compReds);
++				FloatVector gDiff = greens.sub(compGreens);
++				FloatVector bDiff = blues.sub(compBlues);
++				
++				FloatVector weightR = rMean.div(256.0f).add(2);
++				FloatVector weightG = FloatVector.broadcast(F_SPEC, 4.0f);
++				FloatVector weightB = FloatVector.broadcast(F_SPEC, 255.0f).sub(rMean).div(256.0f).add(2.0f);
++				
++				FloatVector distance = weightR.mul(rDiff).mul(rDiff).add(weightG.mul(gDiff).mul(gDiff)).add(weightB.mul(bDiff).mul(bDiff));
++				
++				// Now we compare to the best distance we've found.
++				// This mask contains a "1" if better, and a "0" otherwise.
++				VectorMask<Float> bestDistanceMask = distance.lt(bestDistances);
++				bestDistances = bestDistances.blend(distance, bestDistanceMask); // Update the best distances
++				
++				// Update the result array
++				// We also AND with the modification mask because we don't want to interfere if the alpha value isn't large enough.
++				resultIndex = resultIndex.blend(c, bestDistanceMask.cast(I_SPEC).and(modificationMask)); // Update the results
++			}
++			
++			for (int j = 0; j < speciesLength; j++) {
++				int index = resultIndex.lane(j);
++				out[i + j] = (byte) (index < 128 ? index : -129 + (index - 127));
++			}
++		}
++		
++		// For the final ones, fall back to the regular method
++		for (; i < in.length; i++) {
++			out[i] = MapPalette.matchColor(new Color(in[i], true));
++		}
++	}
++	
++}
+diff --git a/src/main/java/org/bukkit/map/MapPalette.java b/src/main/java/org/bukkit/map/MapPalette.java
+index c80faa079eca1564847070f0338fc98024639829..e632d51d3487eb4807243b6705999ad124466bf5 100644
+--- a/src/main/java/org/bukkit/map/MapPalette.java
++++ b/src/main/java/org/bukkit/map/MapPalette.java
+@@ -1,6 +1,7 @@
+ package org.bukkit.map;
+ 
+ import com.google.common.base.Preconditions;
++import gg.pufferfish.pufferfish.simd.SIMDDetection; // Pufferfish
+ import java.awt.Color;
+ import java.awt.Graphics2D;
+ import java.awt.Image;
+@@ -40,7 +41,7 @@ public final class MapPalette {
+     }
+ 
+     @NotNull
+-    static final Color[] colors = {
++    public static final Color[] colors = { // Pufferfish - public access
+         c(0, 0, 0, 0), c(0, 0, 0, 0), c(0, 0, 0, 0), c(0, 0, 0, 0),
+         c(89, 125, 39), c(109, 153, 48), c(127, 178, 56), c(67, 94, 29),
+         c(174, 164, 115), c(213, 201, 140), c(247, 233, 163), c(130, 123, 86),
+@@ -211,9 +212,15 @@ public final class MapPalette {
+         temp.getRGB(0, 0, temp.getWidth(), temp.getHeight(), pixels, 0, temp.getWidth());
+ 
+         byte[] result = new byte[temp.getWidth() * temp.getHeight()];
++        // Pufferfish start
++        if (!SIMDDetection.isEnabled) {
+         for (int i = 0; i < pixels.length; i++) {
+             result[i] = matchColor(new Color(pixels[i], true));
+         }
++        } else {
++            gg.pufferfish.pufferfish.simd.VectorMapPalette.matchColorVectorized(pixels, result);
++        }
++        // Pufferfish end
+         return result;
+     }
+ 
+diff --git a/src/main/java/org/bukkit/plugin/SimplePluginManager.java b/src/main/java/org/bukkit/plugin/SimplePluginManager.java
+index 003bece642b682985625db93cad93026352bfc66..e8ba4f1108f2548a487877027e37d81fc150e042 100644
+--- a/src/main/java/org/bukkit/plugin/SimplePluginManager.java
++++ b/src/main/java/org/bukkit/plugin/SimplePluginManager.java
+@@ -597,7 +597,9 @@ public final class SimplePluginManager implements PluginManager {
+ 
+     // Paper start
+     private void handlePluginException(String msg, Throwable ex, Plugin plugin) {
++        gg.pufferfish.pufferfish.sentry.SentryContext.setPluginContext(plugin); // Pufferfish
+         server.getLogger().log(Level.SEVERE, msg, ex);
++        gg.pufferfish.pufferfish.sentry.SentryContext.removePluginContext(); // Pufferfish
+         callEvent(new com.destroystokyo.paper.event.server.ServerExceptionEvent(new com.destroystokyo.paper.exception.ServerPluginEnableDisableException(msg, ex, plugin)));
+     }
+     // Paper end
+@@ -667,9 +669,11 @@ public final class SimplePluginManager implements PluginManager {
+                             ));
+                 }
+             } catch (Throwable ex) {
++                gg.pufferfish.pufferfish.sentry.SentryContext.setEventContext(event, registration); // Pufferfish
+                 // Paper start - error reporting
+                 String msg = "Could not pass event " + event.getEventName() + " to " + registration.getPlugin().getDescription().getFullName();
+                 server.getLogger().log(Level.SEVERE, msg, ex);
++                gg.pufferfish.pufferfish.sentry.SentryContext.removeEventContext(); // Pufferfish
+                 if (!(event instanceof com.destroystokyo.paper.event.server.ServerExceptionEvent)) { // We don't want to cause an endless event loop
+                     callEvent(new com.destroystokyo.paper.event.server.ServerExceptionEvent(new com.destroystokyo.paper.exception.ServerEventException(msg, ex, registration.getPlugin(), registration.getListener(), event)));
+                 }
+diff --git a/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java b/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java
+index eaefbb00e9993d54906cc8cf35cf753c0d6c7707..301e82369603f3dd6e6c1bd380da4bacacd7ef6c 100644
+--- a/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java
++++ b/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java
+@@ -336,7 +336,13 @@ public final class JavaPluginLoader implements PluginLoader {
+             try {
+                 jPlugin.setEnabled(true);
+             } catch (Throwable ex) {
++                gg.pufferfish.pufferfish.sentry.SentryContext.setPluginContext(plugin); // Pufferfish
+                 server.getLogger().log(Level.SEVERE, "Error occurred while enabling " + plugin.getDescription().getFullName() + " (Is it up to date?)", ex);
++                gg.pufferfish.pufferfish.sentry.SentryContext.removePluginContext(); // Pufferfish
++                // Paper start - Disable plugins that fail to load
++                this.server.getPluginManager().disablePlugin(jPlugin);
++                return;
++                // Paper end
+             }
+ 
+             // Perhaps abort here, rather than continue going, but as it stands,
+@@ -361,7 +367,9 @@ public final class JavaPluginLoader implements PluginLoader {
+             try {
+                 jPlugin.setEnabled(false);
+             } catch (Throwable ex) {
++                gg.pufferfish.pufferfish.sentry.SentryContext.setPluginContext(plugin); // Pufferfish
+                 server.getLogger().log(Level.SEVERE, "Error occurred while disabling " + plugin.getDescription().getFullName() + " (Is it up to date?)", ex);
++                gg.pufferfish.pufferfish.sentry.SentryContext.removePluginContext(); // Pufferfish
+             }
+ 
+             if (cloader instanceof PluginClassLoader) {
+diff --git a/src/main/java/org/bukkit/plugin/java/PluginClassLoader.java b/src/main/java/org/bukkit/plugin/java/PluginClassLoader.java
+index 7e4f7cb2afbc145e532285c793573ad107bc3033..12449e18180d604e9cbbc744da74a8b222a18e1f 100644
+--- a/src/main/java/org/bukkit/plugin/java/PluginClassLoader.java
++++ b/src/main/java/org/bukkit/plugin/java/PluginClassLoader.java
+@@ -50,6 +50,8 @@ public final class PluginClassLoader extends URLClassLoader implements io.paperm
+     private io.papermc.paper.plugin.provider.classloader.PluginClassLoaderGroup classLoaderGroup; // Paper
+     public io.papermc.paper.plugin.provider.entrypoint.DependencyContext dependencyContext; // Paper
+ 
++    private boolean closed = false; // Pufferfish
++
+     static {
+         ClassLoader.registerAsParallelCapable();
+     }
+@@ -197,6 +199,7 @@ public final class PluginClassLoader extends URLClassLoader implements io.paperm
+         throw new ClassNotFoundException(name);
+     }
+ 
++    public boolean _airplane_hasClass(@NotNull String name) { return this.classes.containsKey(name); } // Pufferfish
+     @Override
+     protected Class<?> findClass(String name) throws ClassNotFoundException {
+         if (name.startsWith("org.bukkit.") || name.startsWith("net.minecraft.")) {
+@@ -204,7 +207,7 @@ public final class PluginClassLoader extends URLClassLoader implements io.paperm
+         }
+         Class<?> result = classes.get(name);
+ 
+-        if (result == null) {
++        if (result == null && !this.closed) { // Pufferfish
+             String path = name.replace('.', '/').concat(".class");
+             JarEntry entry = jar.getJarEntry(path);
+ 
+@@ -251,6 +254,7 @@ public final class PluginClassLoader extends URLClassLoader implements io.paperm
+             this.setClass(name, result); // Paper
+         }
+ 
++        if (result == null) throw new ClassNotFoundException(name); // Pufferfish
+         return result;
+     }
+ 
+@@ -265,6 +269,7 @@ public final class PluginClassLoader extends URLClassLoader implements io.paperm
+             // Paper end
+             super.close();
+         } finally {
++            this.closed = true; // Pufferfish
+             jar.close();
+         }
+     }

patches/api/0002-Fix-pufferfish-issues.patch

@@ -0,0 +1,39 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: BillyGalbreath <Blake.Galbreath@Gmail.com>
+Date: Tue, 4 Jan 2022 23:05:41 -0600
+Subject: [PATCH] Fix pufferfish issues
+
+
+diff --git a/src/main/java/io/papermc/paper/ServerBuildInfo.java b/src/main/java/io/papermc/paper/ServerBuildInfo.java
+index 9df9d09aa477d4cd3c496ba0933c816df1ef0964..2655f98322bcab8622e5f84db1085c3b1f5174b7 100644
+--- a/src/main/java/io/papermc/paper/ServerBuildInfo.java
++++ b/src/main/java/io/papermc/paper/ServerBuildInfo.java
+@@ -18,6 +18,13 @@ public interface ServerBuildInfo {
+      */
+     Key BRAND_PAPER_ID = Key.key("papermc", "paper");
+ 
++    // Purpur start
++    /**
++     * The brand id for Pufferfish.
++     */
++    Key BRAND_PUFFERFISH_ID = Key.key("pufferfish", "pufferfish");
++    // Purpur end
++
+     /**
+      * Gets the {@code ServerBuildInfo}.
+      *
+diff --git a/src/test/java/org/bukkit/AnnotationTest.java b/src/test/java/org/bukkit/AnnotationTest.java
+index b82f07a2879412f6b30643ca93a97439aa49a98a..6369124775f8b51b10476a6819969fd075cb61e1 100644
+--- a/src/test/java/org/bukkit/AnnotationTest.java
++++ b/src/test/java/org/bukkit/AnnotationTest.java
+@@ -47,6 +47,10 @@ public class AnnotationTest {
+         "org/bukkit/plugin/java/PluginClassLoader",
+         // Generic functional interface
+         "org/bukkit/util/Consumer",
++        // Purpur start
++        "gg/pufferfish/pufferfish/sentry/SentryContext",
++        "gg/pufferfish/pufferfish/sentry/SentryContext$State",
++        // Purpur end
+         // Paper start
+         "io/papermc/paper/util/TransformingRandomAccessList",
+         "io/papermc/paper/util/TransformingRandomAccessList$TransformedListIterator",

patches/api/0003-Rebrand.patch

@@ -5,12 +5,12 @@ Subject: [PATCH] Rebrand
 
 
 diff --git a/src/main/java/io/papermc/paper/ServerBuildInfo.java b/src/main/java/io/papermc/paper/ServerBuildInfo.java
-index 9df9d09aa477d4cd3c496ba0933c816df1ef0964..7107eabf02d9d9b69d97c978ba421ad52031ec3f 100644
+index 2655f98322bcab8622e5f84db1085c3b1f5174b7..8c2c5ea14a839c8767bbf120ae5512f65475cbb0 100644
 --- a/src/main/java/io/papermc/paper/ServerBuildInfo.java
 +++ b/src/main/java/io/papermc/paper/ServerBuildInfo.java
-@@ -18,6 +18,13 @@ public interface ServerBuildInfo {
-      */
-     Key BRAND_PAPER_ID = Key.key("papermc", "paper");
+@@ -25,6 +25,13 @@ public interface ServerBuildInfo {
+     Key BRAND_PUFFERFISH_ID = Key.key("pufferfish", "pufferfish");
+     // Purpur end
  
 +    // Purpur start
 +    /**

patches/api/0005-Build-System-Changes.patch

@@ -5,10 +5,10 @@ Subject: [PATCH] Build System Changes
 
 
 diff --git a/build.gradle.kts b/build.gradle.kts
-index fd39ed209b20c927054b8482c400beeeeab460a3..6aef83558a5ef7e84873b127c3bb43a6468c9a24 100644
+index 07945418e95cbe07c45bfa815d828fa311c7f033..b7d584c8b96eb7699e5df90ed04bf22ee256d571 100644
 --- a/build.gradle.kts
 +++ b/build.gradle.kts
-@@ -142,6 +142,8 @@ tasks.jar {
+@@ -150,6 +150,8 @@ tasks.jar {
  }
  
  tasks.withType<Javadoc> {

patches/api/0017-ItemStack-convenience-methods.patch

@@ -50,7 +50,7 @@ index 54704da43cf9c429f3914f0580246dde99aa93c0..e1a677cfde05aba487a09e34e170fea6
 +    // Purpur end
  }
 diff --git a/src/main/java/org/bukkit/inventory/ItemStack.java b/src/main/java/org/bukkit/inventory/ItemStack.java
-index 8bbd98ea729755e7666403b96f277fd419560951..cb37a8af9e54349fc8a3eb70bbe2fddaaa3767d6 100644
+index b3abe3bde05d4a360e31e490bff8a859dc2bd4a6..9b8b958ce181b60eb5db89d4720380153152a2ac 100644
 --- a/src/main/java/org/bukkit/inventory/ItemStack.java
 +++ b/src/main/java/org/bukkit/inventory/ItemStack.java
 @@ -19,6 +19,17 @@ import org.bukkit.inventory.meta.ItemMeta;

patches/api/0042-Add-log-suppression-for-LibraryLoader.patch

@@ -5,7 +5,7 @@ Subject: [PATCH] Add log suppression for LibraryLoader
 
 
 diff --git a/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java b/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java
-index eaefbb00e9993d54906cc8cf35cf753c0d6c7707..f1e58639213be0c43cd2ff090b625e7d0a67e8be 100644
+index 301e82369603f3dd6e6c1bd380da4bacacd7ef6c..0c6ca7588fb3d6b6497ddf032fe75e5c6c9719e5 100644
 --- a/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java
 +++ b/src/main/java/org/bukkit/plugin/java/JavaPluginLoader.java
 @@ -55,6 +55,7 @@ public final class JavaPluginLoader implements PluginLoader {