From af79781d317d67463e7e7f7600aef2cfada58eb9 Mon Sep 17 00:00:00 2001
From: Patrick Miller <apickledwalrus@icloud.com>
Date: Wed, 5 Aug 2026 15:57:49 -0400
Subject: [PATCH 1/2] Add scripts loading/unloading events

---
 .../java/ch/njol/skript/ScriptLoader.java     |  44 ++++++
 .../classes/data/BukkitEventValues.java       |   3 -
 .../java/ch/njol/skript/events/EvtScript.java |  77 ---------
 .../skript/events/bukkit/ScriptEvent.java     |   4 +-
 .../skript/common/CommonModule.java           |   4 +-
 .../skript/common/script/ScriptModule.java    |  32 ++++
 .../script/elements/events/EvtScript.java     |  98 ++++++++++++
 .../script/elements/events/EvtScripts.java    | 146 ++++++++++++++++++
 .../expressions/ExprLoadingScripts.java       |  67 ++++++++
 .../expressions/ExprUnloadingScripts.java     |  67 ++++++++
 10 files changed, 460 insertions(+), 82 deletions(-)
 delete mode 100644 src/main/java/ch/njol/skript/events/EvtScript.java
 create mode 100644 src/main/java/org/skriptlang/skript/common/script/ScriptModule.java
 create mode 100644 src/main/java/org/skriptlang/skript/common/script/elements/events/EvtScript.java
 create mode 100644 src/main/java/org/skriptlang/skript/common/script/elements/events/EvtScripts.java
 create mode 100644 src/main/java/org/skriptlang/skript/common/script/elements/expressions/ExprLoadingScripts.java
 create mode 100644 src/main/java/org/skriptlang/skript/common/script/elements/expressions/ExprUnloadingScripts.java

diff --git a/src/main/java/ch/njol/skript/ScriptLoader.java b/src/main/java/ch/njol/skript/ScriptLoader.java
index 09c38602bf3..89d5af9f4ed 100644
--- a/src/main/java/ch/njol/skript/ScriptLoader.java
+++ b/src/main/java/ch/njol/skript/ScriptLoader.java
@@ -23,6 +23,7 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.jetbrains.annotations.UnknownNullability;
+import org.jetbrains.annotations.Unmodifiable;
 import org.skriptlang.skript.bukkit.text.TextComponentParser;
 import org.skriptlang.skript.lang.script.Script;
 import org.skriptlang.skript.lang.script.ScriptWarning;
@@ -635,6 +636,11 @@ record LoadingStructure (LoadingScriptInfo loadingScriptInfo, Structure structur
 					parser.setInactive();
 
 					// trigger events
+					List<Script> eventScripts = scripts.stream()
+						.map(LoadingScriptInfo::script)
+						.toList();
+					ScriptLoader.eventRegistry().events(ScriptsLoadEvent.class)
+							.forEach(event -> event.onLoad(parser, eventScripts));
 					scripts.forEach(loadingInfo -> {
 						Script script = loadingInfo.script;
 
@@ -900,6 +906,9 @@ record UnloadingStructure (Script script, Structure structure) {}
 			.collect(Collectors.toCollection(ArrayList::new));
 
 		// trigger unload event before unloading scripts
+		Set<Script> finalScripts = scripts;
+		eventRegistry().events(ScriptsUnloadEvent.class)
+			.forEach(event -> event.onUnload(parser, Collections.unmodifiableSet(finalScripts)));
 		for (Script script : scripts) {
 			eventRegistry().events(ScriptUnloadEvent.class)
 				.forEach(event -> event.onUnload(parser, script));
@@ -1272,6 +1281,24 @@ public interface ScriptInitEvent extends LoaderEvent {
 
 	}
 
+	/**
+	 * Called when a batch of {@link Script}s are loaded in the {@link ScriptLoader}.
+	 * This event will trigger <b>after</b> the scripts are completely loaded ({@link Structure} initialization finished).
+	 * @see #loadScripts(File, OpenCloseable)
+	 * @see #loadScripts(Set, OpenCloseable)
+	 */
+	@FunctionalInterface
+	public interface ScriptsLoadEvent extends LoaderEvent {
+
+		/**
+		 * The method that is called when this event triggers.
+		 * @param parser The ParserInstance handling the loading of <code>script</code>.
+		 * @param scripts The Scripts being loaded.
+		 */
+		void onLoad(ParserInstance parser, @Unmodifiable Collection<Script> scripts);
+
+	}
+
 	/**
 	 * Called when a {@link Script} is loaded in the {@link ScriptLoader}.
 	 * This event will trigger <b>after</b> the script is completely loaded ({@link Structure} initialization finished).
@@ -1290,6 +1317,23 @@ public interface ScriptLoadEvent extends LoaderEvent, Script.Event {
 
 	}
 
+	/**
+	 * Called when a batch of {@link Script}s are unloaded in the {@link ScriptLoader}.
+	 * This event will trigger <b>before</b> the scripts are unloaded.
+	 * @see #unloadScript(Script)
+	 */
+	@FunctionalInterface
+	public interface ScriptsUnloadEvent extends LoaderEvent {
+
+		/**
+		 * The method that is called when this event triggers.
+		 * @param parser The ParserInstance handling the unloading of <code>script</code>.
+		 * @param scripts The Scripts being unloaded.
+		 */
+		void onUnload(ParserInstance parser, @Unmodifiable Collection<Script> scripts);
+
+	}
+
 	/**
 	 * Called when a {@link Script} is unloaded in the {@link ScriptLoader}.
 	 * This event will trigger <b>before</b> the script is unloaded.
diff --git a/src/main/java/ch/njol/skript/classes/data/BukkitEventValues.java b/src/main/java/ch/njol/skript/classes/data/BukkitEventValues.java
index 8f615650611..bf246e3963f 100644
--- a/src/main/java/ch/njol/skript/classes/data/BukkitEventValues.java
+++ b/src/main/java/ch/njol/skript/classes/data/BukkitEventValues.java
@@ -6,7 +6,6 @@
 import ch.njol.skript.classes.Changer.ChangeMode;
 import ch.njol.skript.command.CommandEvent;
 import ch.njol.skript.entity.EntityData;
-import ch.njol.skript.events.bukkit.ScriptEvent;
 import ch.njol.skript.events.bukkit.SkriptStartEvent;
 import ch.njol.skript.events.bukkit.SkriptStopEvent;
 import ch.njol.skript.util.*;
@@ -434,8 +433,6 @@ else if (hand == EquipmentSlot.OFF_HAND)
 		registry.register(EventValue.simple(CommandEvent.class, Block.class, event -> event.getSender() instanceof BlockCommandSender sender ? sender.getBlock() : null));
 
 		// === ServerEvents ===
-		// Script load/unload event
-		registry.register(EventValue.simple(ScriptEvent.class, CommandSender.class, event -> Bukkit.getConsoleSender()));
 		// Server load event
 		registry.register(EventValue.simple(SkriptStartEvent.class, CommandSender.class, event -> Bukkit.getConsoleSender()));
 		// Server stop event
diff --git a/src/main/java/ch/njol/skript/events/EvtScript.java b/src/main/java/ch/njol/skript/events/EvtScript.java
deleted file mode 100644
index 347e7ee1d44..00000000000
--- a/src/main/java/ch/njol/skript/events/EvtScript.java
+++ /dev/null
@@ -1,77 +0,0 @@
-package ch.njol.skript.events;
-
-import ch.njol.skript.Skript;
-import ch.njol.skript.events.bukkit.ScriptEvent;
-import ch.njol.skript.lang.Literal;
-import ch.njol.skript.lang.SkriptEvent;
-import ch.njol.skript.lang.SkriptParser.ParseResult;
-import ch.njol.skript.lang.Trigger;
-import org.bukkit.Bukkit;
-import org.bukkit.event.Event;
-import org.jetbrains.annotations.Nullable;
-
-public class EvtScript extends SkriptEvent {
-	
-	static {
-		Skript.registerEvent("Script Load/Unload", EvtScript.class, ScriptEvent.class,
-			"[:async] [script] (load|init|enable)",
-			"[:async] [script] (unload|stop|disable)"
-			).description(
-				"Called directly after the trigger is loaded, or directly before the whole script is unloaded.",
-				"The keyword 'async' indicates the trigger can be ran asynchronously, "
-			).examples(
-				"on load:",
-				"\tset {running::%script%} to true",
-				"on unload:",
-				"\tset {running::%script%} to false"
-			).since("2.0");
-	}
-	
-	private boolean async;
-	private boolean load;
-	
-	@Override
-	public boolean init(Literal<?>[] args, int matchedPattern, ParseResult parseResult) {
-		async = parseResult.hasTag("async");
-		load = matchedPattern == 0;
-		return true;
-	}
-
-	@Override
-	public boolean postLoad() {
-		if (load)
-			runTrigger(trigger, new ScriptEvent());
-		return true;
-	}
-
-	@Override
-	public void unload() {
-		if (!load)
-			runTrigger(trigger, new ScriptEvent());
-	}
-
-	@Override
-	public boolean check(Event event) {
-		throw new UnsupportedOperationException();
-	}
-
-	@Override
-	public boolean isEventPrioritySupported() {
-		return false;
-	}
-	
-	@Override
-	public String toString(@Nullable Event event, boolean debug) {
-		return (async ? "async " : "") + "script " + (load ? "" : "un") + "load";
-	}
-
-	private void runTrigger(Trigger trigger, Event event) {
-		if (async || Bukkit.isPrimaryThread()) {
-			trigger.execute(event);
-		} else {
-			if (Skript.getInstance().isEnabled())
-				Bukkit.getScheduler().scheduleSyncDelayedTask(Skript.getInstance(), () -> trigger.execute(event));
-		}
-	}
-	
-}
diff --git a/src/main/java/ch/njol/skript/events/bukkit/ScriptEvent.java b/src/main/java/ch/njol/skript/events/bukkit/ScriptEvent.java
index 7222af52693..b706ea9c3f8 100644
--- a/src/main/java/ch/njol/skript/events/bukkit/ScriptEvent.java
+++ b/src/main/java/ch/njol/skript/events/bukkit/ScriptEvent.java
@@ -4,8 +4,10 @@
 import org.bukkit.event.HandlerList;
 
 /**
- * @author Peter Güttinger
+ * @deprecated This event was never actually called.
+ * It is only used as a context holder for certain events.
  */
+@Deprecated(since = "INSERT VERSION", forRemoval = true)
 public class ScriptEvent extends Event {
 	
 	public ScriptEvent() {}
diff --git a/src/main/java/org/skriptlang/skript/common/CommonModule.java b/src/main/java/org/skriptlang/skript/common/CommonModule.java
index 762ec04c158..87e5d93fe7e 100644
--- a/src/main/java/org/skriptlang/skript/common/CommonModule.java
+++ b/src/main/java/org/skriptlang/skript/common/CommonModule.java
@@ -6,6 +6,7 @@
 import org.skriptlang.skript.addon.SkriptAddon;
 import org.skriptlang.skript.common.elements.expressions.*;
 import org.skriptlang.skript.common.properties.PropertiesModule;
+import org.skriptlang.skript.common.script.ScriptModule;
 import org.skriptlang.skript.common.types.*;
 
 import java.util.List;
@@ -15,7 +16,8 @@ public class CommonModule extends HierarchicalAddonModule {
 	@Override
 	public Iterable<AddonModule> children() {
 		return List.of(
-			new PropertiesModule(this)
+			new PropertiesModule(this),
+			new ScriptModule(this)
 		);
 	}
 
diff --git a/src/main/java/org/skriptlang/skript/common/script/ScriptModule.java b/src/main/java/org/skriptlang/skript/common/script/ScriptModule.java
new file mode 100644
index 00000000000..a34f77bfd17
--- /dev/null
+++ b/src/main/java/org/skriptlang/skript/common/script/ScriptModule.java
@@ -0,0 +1,32 @@
+package org.skriptlang.skript.common.script;
+
+import org.skriptlang.skript.addon.AddonModule;
+import org.skriptlang.skript.addon.HierarchicalAddonModule;
+import org.skriptlang.skript.addon.SkriptAddon;
+import org.skriptlang.skript.bukkit.lang.eventvalue.EventValueRegistry;
+import org.skriptlang.skript.common.script.elements.events.*;
+import org.skriptlang.skript.common.script.elements.expressions.*;
+
+public class ScriptModule extends HierarchicalAddonModule {
+
+	public ScriptModule(AddonModule parentModule) {
+		super(parentModule);
+	}
+
+	@Override
+	protected void loadSelf(SkriptAddon addon) {
+		EventValueRegistry eventValueRegistry = addon.registry(EventValueRegistry.class);
+		register(addon,
+			syntaxRegistry -> EvtScript.register(syntaxRegistry, eventValueRegistry),
+			EvtScripts::register,
+			ExprLoadingScripts::register,
+			ExprUnloadingScripts::register
+		);
+	}
+
+	@Override
+	public String name() {
+		return "script";
+	}
+
+}
diff --git a/src/main/java/org/skriptlang/skript/common/script/elements/events/EvtScript.java b/src/main/java/org/skriptlang/skript/common/script/elements/events/EvtScript.java
new file mode 100644
index 00000000000..5ba48ddf498
--- /dev/null
+++ b/src/main/java/org/skriptlang/skript/common/script/elements/events/EvtScript.java
@@ -0,0 +1,98 @@
+package org.skriptlang.skript.common.script.elements.events;
+
+import ch.njol.skript.Skript;
+import ch.njol.skript.lang.Literal;
+import ch.njol.skript.lang.SkriptEvent;
+import ch.njol.skript.lang.SkriptParser.ParseResult;
+import ch.njol.skript.lang.Trigger;
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandSender;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.skriptlang.skript.bukkit.lang.eventvalue.EventValue;
+import org.skriptlang.skript.bukkit.lang.eventvalue.EventValueRegistry;
+import org.skriptlang.skript.bukkit.registration.BukkitSyntaxInfos;
+import org.skriptlang.skript.registration.SyntaxRegistry;
+
+public class EvtScript extends SkriptEvent {
+
+	private static class ScriptEvent extends Event {
+		@Override
+		public @NotNull HandlerList getHandlers() {
+			throw new UnsupportedOperationException();
+		}
+	}
+
+	public static void register(SyntaxRegistry syntaxRegistry, EventValueRegistry eventValueRegistry) {
+		syntaxRegistry.register(BukkitSyntaxInfos.Event.KEY, BukkitSyntaxInfos.Event.builder(EvtScript.class, "Script Load/Unload")
+			.supplier(EvtScript::new)
+			.addEvent(ScriptEvent.class)
+			.addPatterns("[:async] [script] (load|init|enable)",
+				"[:async] [script] (unload|stop|disable)")
+			.addDescription("""
+				Called directly after the trigger is loaded, or directly before the whole script is unloaded. \
+				The keyword 'async' indicates the trigger can be executed asynchronously.
+				""")
+			.addExample("""
+				on load:
+					set {running::%script%} to true
+				on unload:
+					set {running::%script%} to false
+				""")
+			.addSince("2.0")
+			.build());
+		eventValueRegistry.register(EventValue.simple(ScriptEvent.class, CommandSender.class,
+			ignored -> Bukkit.getConsoleSender()));
+	}
+
+	private boolean async;
+	private boolean load;
+
+	@Override
+	public boolean init(Literal<?>[] args, int matchedPattern, ParseResult parseResult) {
+		async = parseResult.hasTag("async");
+		load = matchedPattern == 0;
+		return true;
+	}
+
+	@Override
+	public boolean postLoad() {
+		if (load) {
+			runTrigger(trigger, new ScriptEvent());
+		}
+		return true;
+	}
+
+	@Override
+	public void unload() {
+		if (!load) {
+			runTrigger(trigger, new ScriptEvent());
+		}
+	}
+
+	@Override
+	public boolean check(Event event) {
+		throw new UnsupportedOperationException();
+	}
+
+	@Override
+	public boolean isEventPrioritySupported() {
+		return false;
+	}
+
+	@Override
+	public String toString(@Nullable Event event, boolean debug) {
+		return (async ? "async " : "") + "script " + (load ? "" : "un") + "load";
+	}
+
+	private void runTrigger(Trigger trigger, Event event) {
+		if (async || Bukkit.isPrimaryThread()) {
+			trigger.execute(event);
+		} else if (Skript.getInstance().isEnabled()) {
+			Bukkit.getScheduler().scheduleSyncDelayedTask(Skript.getInstance(), () -> trigger.execute(event));
+		}
+	}
+
+}
diff --git a/src/main/java/org/skriptlang/skript/common/script/elements/events/EvtScripts.java b/src/main/java/org/skriptlang/skript/common/script/elements/events/EvtScripts.java
new file mode 100644
index 00000000000..c16ac2f4f67
--- /dev/null
+++ b/src/main/java/org/skriptlang/skript/common/script/elements/events/EvtScripts.java
@@ -0,0 +1,146 @@
+package org.skriptlang.skript.common.script.elements.events;
+
+import ch.njol.skript.ScriptLoader;
+import ch.njol.skript.Skript;
+import ch.njol.skript.lang.Literal;
+import ch.njol.skript.lang.SkriptEvent;
+import ch.njol.skript.lang.SkriptParser.ParseResult;
+import ch.njol.skript.lang.Trigger;
+import org.bukkit.Bukkit;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+import org.jetbrains.annotations.ApiStatus;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.skriptlang.skript.bukkit.registration.BukkitSyntaxInfos;
+import org.skriptlang.skript.lang.script.Script;
+import org.skriptlang.skript.registration.SyntaxRegistry;
+
+import java.util.Collection;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class EvtScripts extends SkriptEvent {
+
+	@ApiStatus.Internal
+	public static class ScriptsEvent extends Event {
+
+		public Collection<Script> scripts;
+
+		private ScriptsEvent(Collection<Script> scripts) {
+			this.scripts = scripts;
+		}
+
+		@Override
+		public @NotNull HandlerList getHandlers() {
+			throw new UnsupportedOperationException();
+		}
+	}
+
+	@ApiStatus.Internal
+	public static class ScriptsLoadEvent extends ScriptsEvent {
+
+		private ScriptsLoadEvent(Collection<Script> scripts) {
+			super(scripts);
+		}
+
+	}
+
+	@ApiStatus.Internal
+	public static class ScriptsUnloadEvent extends ScriptsEvent {
+
+		private ScriptsUnloadEvent(Collection<Script> scripts) {
+			super(scripts);
+		}
+
+	}
+
+	public static void register(SyntaxRegistry syntaxRegistry) {
+		syntaxRegistry.register(BukkitSyntaxInfos.Event.KEY, BukkitSyntaxInfos.Event.builder(EvtScripts.class, "Scripts Loading")
+			.supplier(() -> new EvtScripts(true))
+			.addEvent(ScriptsLoadEvent.class)
+			.addPattern("scripts (loading|initializing|enabling)")
+			.addDescription("Called directly after a batch of scripts is loaded.")
+			.addExample("""
+				""")
+			.addSince("INSERT VERSION")
+			.build());
+		syntaxRegistry.register(BukkitSyntaxInfos.Event.KEY, BukkitSyntaxInfos.Event.builder(EvtScripts.class, "Scripts Unloading")
+			.supplier(() -> new EvtScripts(false))
+			.addEvent(ScriptsUnloadEvent.class)
+			.addPattern("scripts (unloading|stopping|disabling)")
+			.addDescription("Called directly before a batch of scripts is unloaded.")
+			.addExample("""
+				""")
+			.addSince("INSERT VERSION")
+			.build());
+
+		ScriptLoader.eventRegistry().register(ScriptLoader.ScriptsLoadEvent.class, (ignored, scripts) -> {
+			ScriptsEvent event = new ScriptsLoadEvent(scripts);
+			if (Bukkit.isPrimaryThread()) {
+				LOAD_TRIGGERS.forEach(trigger -> trigger.execute(event));
+			} else {
+				Bukkit.getScheduler().scheduleSyncDelayedTask(Skript.getInstance(),
+					() -> LOAD_TRIGGERS.forEach(trigger -> trigger.execute(event)));
+			}
+		});
+		ScriptLoader.eventRegistry().register(ScriptLoader.ScriptsUnloadEvent.class, (ignored, scripts) -> {
+			ScriptsEvent event = new ScriptsUnloadEvent(scripts);
+			if (Bukkit.isPrimaryThread()) {
+				UNLOAD_TRIGGERS.forEach(trigger -> trigger.execute(event));
+			} else {
+				Bukkit.getScheduler().scheduleSyncDelayedTask(Skript.getInstance(),
+					() -> UNLOAD_TRIGGERS.forEach(trigger -> trigger.execute(event)));
+			}
+		});
+	}
+
+	private static final Set<Trigger> LOAD_TRIGGERS = ConcurrentHashMap.newKeySet();
+	private static final Set<Trigger> UNLOAD_TRIGGERS = ConcurrentHashMap.newKeySet();
+
+	private final boolean load;
+
+	private EvtScripts(boolean load) {
+		this.load = load;
+	}
+
+	@Override
+	public boolean init(Literal<?>[] args, int matchedPattern, ParseResult parseResult) {
+		return true;
+	}
+
+	@Override
+	public boolean postLoad() {
+		if (load) {
+			LOAD_TRIGGERS.add(trigger);
+		} else {
+			UNLOAD_TRIGGERS.add(trigger);
+		}
+		return true;
+	}
+
+	@Override
+	public void unload() {
+		if (load) {
+			LOAD_TRIGGERS.remove(trigger);
+		} else {
+			UNLOAD_TRIGGERS.remove(trigger);
+		}
+	}
+
+	@Override
+	public boolean check(Event event) {
+		throw new UnsupportedOperationException();
+	}
+
+	@Override
+	public boolean isEventPrioritySupported() {
+		return false;
+	}
+
+	@Override
+	public String toString(@Nullable Event event, boolean debug) {
+		return "scripts " + (load ? "" : "un") + "loading";
+	}
+
+}
diff --git a/src/main/java/org/skriptlang/skript/common/script/elements/expressions/ExprLoadingScripts.java b/src/main/java/org/skriptlang/skript/common/script/elements/expressions/ExprLoadingScripts.java
new file mode 100644
index 00000000000..a1f4fcc322f
--- /dev/null
+++ b/src/main/java/org/skriptlang/skript/common/script/elements/expressions/ExprLoadingScripts.java
@@ -0,0 +1,67 @@
+package org.skriptlang.skript.common.script.elements.expressions;
+
+import ch.njol.skript.doc.Description;
+import ch.njol.skript.doc.Events;
+import ch.njol.skript.doc.Example;
+import ch.njol.skript.doc.Name;
+import ch.njol.skript.doc.Since;
+import ch.njol.skript.lang.EventRestrictedSyntax;
+import ch.njol.skript.lang.Expression;
+import ch.njol.skript.lang.SkriptParser.ParseResult;
+import ch.njol.skript.lang.util.SimpleExpression;
+import ch.njol.skript.registrations.experiments.ReflectionExperimentSyntax;
+import ch.njol.util.Kleenean;
+import org.bukkit.event.Event;
+import org.jetbrains.annotations.Nullable;
+import org.skriptlang.skript.common.script.elements.events.EvtScripts.ScriptsLoadEvent;
+import org.skriptlang.skript.lang.script.Script;
+import org.skriptlang.skript.registration.SyntaxInfo;
+import org.skriptlang.skript.registration.SyntaxRegistry;
+
+@Name("Loading Scripts")
+@Description("The scripts loading in a 'scripts loading' event.")
+@Example("""
+	on scripts loading:
+		broadcast "%the size of the loading scripts% scripts were just loaded!"
+	""")
+@Since("INSERT VERSION")
+@Events("Scripts Loading/Unloading")
+public class ExprLoadingScripts extends SimpleExpression<Script> implements EventRestrictedSyntax, ReflectionExperimentSyntax {
+
+	public static void register(SyntaxRegistry syntaxRegistry) {
+		syntaxRegistry.register(SyntaxRegistry.EXPRESSION,
+			SyntaxInfo.Expression.simple(ExprLoadingScripts.class, ExprLoadingScripts::new, Script.class,
+				"[all [[of] the]|the] (loading|initializing|enabling) scripts"));
+	}
+	@Override
+	public boolean init(Expression<?>[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) {
+		return true;
+	}
+
+	@Override
+	public Class<? extends Event>[] supportedEvents() {
+		//noinspection unchecked
+		return new Class[]{ScriptsLoadEvent.class};
+	}
+
+	@Override
+	protected Script @Nullable [] get(Event event) {
+		return ((ScriptsLoadEvent) event).scripts.toArray(new Script[0]);
+	}
+
+	@Override
+	public boolean isSingle() {
+		return false;
+	}
+
+	@Override
+	public Class<? extends Script> getReturnType() {
+		return Script.class;
+	}
+
+	@Override
+	public String toString(@Nullable Event event, boolean debug) {
+		return "the loading scripts";
+	}
+
+}
diff --git a/src/main/java/org/skriptlang/skript/common/script/elements/expressions/ExprUnloadingScripts.java b/src/main/java/org/skriptlang/skript/common/script/elements/expressions/ExprUnloadingScripts.java
new file mode 100644
index 00000000000..05468a59eb8
--- /dev/null
+++ b/src/main/java/org/skriptlang/skript/common/script/elements/expressions/ExprUnloadingScripts.java
@@ -0,0 +1,67 @@
+package org.skriptlang.skript.common.script.elements.expressions;
+
+import ch.njol.skript.doc.Description;
+import ch.njol.skript.doc.Events;
+import ch.njol.skript.doc.Example;
+import ch.njol.skript.doc.Name;
+import ch.njol.skript.doc.Since;
+import ch.njol.skript.lang.EventRestrictedSyntax;
+import ch.njol.skript.lang.Expression;
+import ch.njol.skript.lang.SkriptParser.ParseResult;
+import ch.njol.skript.lang.util.SimpleExpression;
+import ch.njol.skript.registrations.experiments.ReflectionExperimentSyntax;
+import ch.njol.util.Kleenean;
+import org.bukkit.event.Event;
+import org.jetbrains.annotations.Nullable;
+import org.skriptlang.skript.common.script.elements.events.EvtScripts.ScriptsUnloadEvent;
+import org.skriptlang.skript.lang.script.Script;
+import org.skriptlang.skript.registration.SyntaxInfo;
+import org.skriptlang.skript.registration.SyntaxRegistry;
+
+@Name("Unloading Scripts")
+@Description("The scripts unloading in a 'scripts unloading' event.")
+@Example("""
+	on scripts unloading:
+		broadcast "%the size of the unloading scripts% scripts were just unloaded!"
+	""")
+@Since("INSERT VERSION")
+@Events("Scripts Loading/Unloading")
+public class ExprUnloadingScripts extends SimpleExpression<Script> implements EventRestrictedSyntax, ReflectionExperimentSyntax {
+
+	public static void register(SyntaxRegistry syntaxRegistry) {
+		syntaxRegistry.register(SyntaxRegistry.EXPRESSION,
+			SyntaxInfo.Expression.simple(ExprUnloadingScripts.class, ExprUnloadingScripts::new, Script.class,
+				"[all [[of] the]|the] (unloading|stopping|disabling) scripts"));
+	}
+	@Override
+	public boolean init(Expression<?>[] expressions, int matchedPattern, Kleenean isDelayed, ParseResult parseResult) {
+		return true;
+	}
+
+	@Override
+	public Class<? extends Event>[] supportedEvents() {
+		//noinspection unchecked
+		return new Class[]{ScriptsUnloadEvent.class};
+	}
+
+	@Override
+	protected Script @Nullable [] get(Event event) {
+		return ((ScriptsUnloadEvent) event).scripts.toArray(new Script[0]);
+	}
+
+	@Override
+	public boolean isSingle() {
+		return false;
+	}
+
+	@Override
+	public Class<? extends Script> getReturnType() {
+		return Script.class;
+	}
+
+	@Override
+	public String toString(@Nullable Event event, boolean debug) {
+		return "the unloading scripts";
+	}
+
+}

From fb0f2ff68bdc310807aaa800a5d72977ca665558 Mon Sep 17 00:00:00 2001
From: Patrick Miller <apickledwalrus@icloud.com>
Date: Wed, 5 Aug 2026 16:13:23 -0400
Subject: [PATCH 2/2] Add small test

---
 src/test/skript/tests/common/script/EvtScripts.sk | 7 +++++++
 1 file changed, 7 insertions(+)
 create mode 100644 src/test/skript/tests/common/script/EvtScripts.sk

diff --git a/src/test/skript/tests/common/script/EvtScripts.sk b/src/test/skript/tests/common/script/EvtScripts.sk
new file mode 100644
index 00000000000..ee31977d844
--- /dev/null
+++ b/src/test/skript/tests/common/script/EvtScripts.sk
@@ -0,0 +1,7 @@
+using reflection
+
+on scripts loading:
+	add the loading scripts to {-EvtScripts::*}
+
+test "EvtScripts":
+	assert {-EvtScripts::*} contains the current script with "loading scripts did not contain current script"