diff --git a/pom.xml b/pom.xml
index 71290718c..c45a46c49 100644
--- a/pom.xml
+++ b/pom.xml
@@ -376,6 +376,11 @@
 			<artifactId>org.eclipse.lsp4j</artifactId>
 			<version>0.22.0</version>
 		</dependency>
+		<dependency>
+			<groupId>org.eclipse.lsp4j</groupId>
+			<artifactId>org.eclipse.lsp4j.debug</artifactId>
+			<version>0.22.0</version>
+		</dependency>
 		<dependency>
 			<groupId>io.swagger.core.v3</groupId>
 			<artifactId>swagger-annotations</artifactId>
@@ -569,6 +574,8 @@
 									<include>org.brotli:dec:jar:*</include>
 									<include>org.eclipse.lsp4j:org.eclipse.lsp4j:jar:*</include>
 									<include>org.eclipse.lsp4j:org.eclipse.lsp4j.jsonrpc:jar:*</include>
+									<include>org.eclipse.lsp4j:org.eclipse.lsp4j.debug:jar:*</include>
+									<include>org.eclipse.lsp4j:org.eclipse.lsp4j.jsonrpc.debug:jar:*</include>
 									<!-- We don't currently actually depend on these 2, but lsp4j does, so we
 									need to shade it in. In the future, we may rip out org.json:json,
 									and replace it with this, however, in which case we only need to
@@ -842,6 +849,24 @@
 										<exclude>META-INF/**</exclude>
 									</excludes>
 								</filter>
+								<filter>
+									<artifact>org.eclipse.lsp4j:org.eclipse.lsp4j.debug:jar:*</artifact>
+									<includes>
+										<include>**</include>
+									</includes>
+									<excludes>
+										<exclude>META-INF/**</exclude>
+									</excludes>
+								</filter>
+								<filter>
+									<artifact>org.eclipse.lsp4j:org.eclipse.lsp4j.jsonrpc.debug:jar:*</artifact>
+									<includes>
+										<include>**</include>
+									</includes>
+									<excludes>
+										<exclude>META-INF/**</exclude>
+									</excludes>
+								</filter>
 								<filter>
 									<artifact>com.google.code.gson:gson:jar:*</artifact>
 									<includes>
diff --git a/src/main/java/com/laytonsmith/PureUtilities/DaemonManager.java b/src/main/java/com/laytonsmith/PureUtilities/DaemonManager.java
index a54fd7182..9a0db3c23 100644
--- a/src/main/java/com/laytonsmith/PureUtilities/DaemonManager.java
+++ b/src/main/java/com/laytonsmith/PureUtilities/DaemonManager.java
@@ -1,6 +1,8 @@
 package com.laytonsmith.PureUtilities;
 
+import java.util.ArrayList;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Set;
 
 /**
@@ -10,10 +12,51 @@
  */
 public class DaemonManager {
 
+	/**
+	 * Listener interface for thread lifecycle events.
+	 */
+	public interface ThreadLifecycleListener {
+		/**
+		 * Called when a thread is activated (registered as active).
+		 * @param t The thread that was activated
+		 * @param displayName A user-facing display name for the thread, or null
+		 *     if no explicit name was provided (in which case the thread's Java
+		 *     name should be used as a fallback).
+		 */
+		void onActivated(Thread t, String displayName);
+
+		/**
+		 * Called when a thread is deactivated (no longer active).
+		 * @param t The thread that was deactivated
+		 */
+		void onDeactivated(Thread t);
+	}
+
 	private final Object lock = new Object();
 	private final Set<Thread> threads = new HashSet<>();
+	private final List<ThreadLifecycleListener> listeners = new ArrayList<>();
 	private int count = 0;
 
+	/**
+	 * Adds a listener that will be notified when threads are activated or deactivated.
+	 * @param listener The listener to add
+	 */
+	public void addThreadLifecycleListener(ThreadLifecycleListener listener) {
+		synchronized(lock) {
+			listeners.add(listener);
+		}
+	}
+
+	/**
+	 * Removes a previously added lifecycle listener.
+	 * @param listener The listener to remove
+	 */
+	public void removeThreadLifecycleListener(ThreadLifecycleListener listener) {
+		synchronized(lock) {
+			listeners.remove(listener);
+		}
+	}
+
 	/**
 	 * Sets a thread to "daemon" mode, meaning it is currently active. Null may be sent, in which case the current
 	 * thread is used. You should always put a deactivateThread call for every activateThread call.
@@ -21,13 +64,27 @@ public class DaemonManager {
 	 * @param t The thread to activate
 	 */
 	public void activateThread(Thread t) {
+		activateThread(t, null);
+	}
+
+	/**
+	 * Sets a thread to "daemon" mode with an explicit display name. Null may be sent for the thread,
+	 * in which case the current thread is used.
+	 *
+	 * @param t The thread to activate
+	 * @param displayName A user-facing name for the thread, or null to use the Java thread name
+	 */
+	public void activateThread(Thread t, String displayName) {
+		Thread resolved;
+		List<ThreadLifecycleListener> snapshot;
 		synchronized(lock) {
-			if(t != null) {
-				threads.add(t);
-			} else {
-				threads.add(Thread.currentThread());
-			}
+			resolved = t != null ? t : Thread.currentThread();
+			threads.add(resolved);
 			++count;
+			snapshot = new ArrayList<>(listeners);
+		}
+		for(ThreadLifecycleListener listener : snapshot) {
+			listener.onActivated(resolved, displayName);
 		}
 	}
 
@@ -37,14 +94,17 @@ public void activateThread(Thread t) {
 	 * @param t The thread to deactivate
 	 */
 	public void deactivateThread(Thread t) {
+		Thread resolved;
+		List<ThreadLifecycleListener> snapshot;
 		synchronized(lock) {
-			if(t != null) {
-				threads.remove(t);
-			} else {
-				threads.remove(Thread.currentThread());
-			}
+			resolved = t != null ? t : Thread.currentThread();
+			threads.remove(resolved);
 			--count;
 			lock.notify();
+			snapshot = new ArrayList<>(listeners);
+		}
+		for(ThreadLifecycleListener listener : snapshot) {
+			listener.onDeactivated(resolved);
 		}
 	}
 
diff --git a/src/main/java/com/laytonsmith/core/CallbackYield.java b/src/main/java/com/laytonsmith/core/CallbackYield.java
index d1e1b9f3b..800915abd 100644
--- a/src/main/java/com/laytonsmith/core/CallbackYield.java
+++ b/src/main/java/com/laytonsmith/core/CallbackYield.java
@@ -191,7 +191,7 @@ private void cleanupCurrentStep(CallbackState state, Environment env) {
 		if(step != null) {
 			if(step.preparedEnv != null) {
 				// Pop the stack trace element that prepareExecution pushed
-				step.preparedEnv.getEnv(GlobalEnv.class).GetStackTraceManager().popStackTraceElement();
+				step.preparedEnv.getEnv(GlobalEnv.class).GetStackTraceManager().popStackTraceFrame();
 				step.preparedEnv = null;
 			}
 			if(step.cleanupAction != null) {
diff --git a/src/main/java/com/laytonsmith/core/FlowFunction.java b/src/main/java/com/laytonsmith/core/FlowFunction.java
index 79f26dd17..1888a57f3 100644
--- a/src/main/java/com/laytonsmith/core/FlowFunction.java
+++ b/src/main/java/com/laytonsmith/core/FlowFunction.java
@@ -2,6 +2,7 @@
 
 import com.laytonsmith.core.StepAction.StepResult;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.exceptions.ConfigRuntimeException;
 import com.laytonsmith.core.natives.interfaces.Mixed;
 import com.laytonsmith.core.environments.Environment;
 
@@ -94,4 +95,21 @@ default StepResult<S> childInterrupted(Target t, S state, StepAction.FlowControl
 	 */
 	default void cleanup(Target t, S state, Environment env) {
 	}
+
+	/**
+	 * Returns whether the given exception would be caught by this function,
+	 * given the current per-call state. The default returns false. Override in
+	 * exception-catching functions (e.g. try/catch) to inspect the state and
+	 * determine if the exception matches a catch clause.
+	 *
+	 * <p>This is used by the debugger to determine if an exception is "uncaught"
+	 * by inspecting the eval stack without actually propagating the exception.</p>
+	 *
+	 * @param state The per-call state from the stack frame
+	 * @param exception The exception to check
+	 * @return true if this function would catch the exception in its current state
+	 */
+	default boolean wouldCatch(S state, ConfigRuntimeException exception) {
+		return false;
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/Main.java b/src/main/java/com/laytonsmith/core/Main.java
index ee7b32859..8b3841c98 100644
--- a/src/main/java/com/laytonsmith/core/Main.java
+++ b/src/main/java/com/laytonsmith/core/Main.java
@@ -53,6 +53,7 @@
 import com.laytonsmith.tools.ProfilerSummary;
 import com.laytonsmith.tools.SyntaxHighlighters;
 import com.laytonsmith.tools.UILauncher;
+import com.laytonsmith.tools.debugger.MSDebugServer;
 import com.laytonsmith.tools.docgen.DocGen;
 import com.laytonsmith.tools.docgen.DocGenExportTool;
 import com.laytonsmith.tools.docgen.DocGenTemplates;
@@ -764,6 +765,9 @@ public void execute(ArgumentParser.ArgumentParserResults parsedArgs) throws Exce
 				modules = modules.replaceAll("(.*)\n", "--add-opens $1=ALL-UNNAMED ");
 				args += " " + modules;
 			}
+			if(JavaVersion.GetMajorVersion() >= 16) {
+				args += "--enable-native-access=ALL-UNNAMED ";
+			}
 			args += "-Xrs ";
 			StreamUtils.GetSystemOut().println(args.trim());
 		}
@@ -1072,21 +1076,58 @@ public ArgumentParser getArgumentParser() {
 					.addArgument(new ArgumentBuilder()
 						.setDescription("The code to run")
 						.setUsageName("methodscript code")
-						.setRequiredAndDefault());
+						.setRequiredAndDefault())
+					.addArgument(new ArgumentBuilder()
+						.setDescription("Enable the DAP debug server.")
+						.asFlag()
+						.setName("debug"))
+					.addArgument(new ArgumentBuilder()
+						.setDescription("The port for the debug server. Defaults to "
+								+ MSDebugServer.DEFAULT_PORT + ".")
+						.setUsageName("port")
+						.setOptional()
+						.setName("debug-port")
+						.setArgType(ArgumentBuilder.BuilderTypeNonFlag.NUMBER))
+					.addArgument(new ArgumentBuilder()
+						.setDescription("Wait for the debugger to connect before executing.")
+						.asFlag()
+						.setName("debug-suspend"));
 		}
 
 		@Override
 		public void execute(ArgumentParser.ArgumentParserResults parsedArgs) throws Exception {
 			ClassDiscovery.getDefaultInstance().addThisJar();
 
+			boolean debug = parsedArgs.isFlagSet("debug");
+			int debugPort = 0;
+			if(parsedArgs.getNumberArgument("debug-port") != null) {
+				debugPort = parsedArgs.getNumberArgument("debug-port").intValue();
+			}
+			boolean debugSuspend = parsedArgs.isFlagSet("debug-suspend");
+
 			String script = parsedArgs.getStringArgument();
 			File file = new File("Interpreter");
 			Environment env = Static.GenerateStandaloneEnvironment(true,
 					EnumSet.of(RuntimeMode.CMDLINE, RuntimeMode.INTERPRETER));
 			Set<Class<? extends Environment.EnvironmentImpl>> envs = Environment.getDefaultEnvClasses();
-			MethodScriptCompiler.execute(script, file, true, env, envs, (s) -> {
-				System.out.println(s);
-			}, null, null);
+
+			MSDebugServer debugServer = null;
+			if(debug) {
+				int port = debugPort == 0 ? MSDebugServer.DEFAULT_PORT : debugPort;
+				debugServer = new MSDebugServer();
+				env = debugServer.startListening(port, env, debugSuspend);
+				debugServer.awaitConfiguration();
+			}
+
+			try {
+				MethodScriptCompiler.execute(script, file, true, env, envs, (s) -> {
+					System.out.println(s);
+				}, null, null);
+			} finally {
+				if(debugServer != null) {
+					debugServer.shutdown();
+				}
+			}
 		}
 	}
 
@@ -1218,15 +1259,44 @@ public void execute(ArgumentParser.ArgumentParserResults parsedArgs) throws Exce
 			//We actually can't use the parsedArgs, because there may be cmdline switches in
 			//the arguments that we want to ignore here, but otherwise pass through. parsedArgs
 			//will prevent us from seeing those, however.
-			List<String> allArgs = parsedArgs.getRawArguments();
+			List<String> allArgs = new ArrayList<>(parsedArgs.getRawArguments());
 			if(allArgs.isEmpty()) {
 				StreamUtils.GetSystemErr().println("Usage: path/to/file.ms [arg1 arg2]");
 				System.exit(1);
 			}
+
+			boolean debug = false;
+			int debugPort = 0;
+			boolean debugSuspend = false;
+			String debugThreadingMode = null;
+			for(java.util.Iterator<String> it = allArgs.iterator(); it.hasNext();) {
+				String arg = it.next();
+				if("--debug".equals(arg)) {
+					debug = true;
+					it.remove();
+				} else if("--debug-port".equals(arg)) {
+					it.remove();
+					if(it.hasNext()) {
+						debugPort = Integer.parseInt(it.next());
+						it.remove();
+					}
+				} else if("--debug-suspend".equals(arg)) {
+					debugSuspend = true;
+					it.remove();
+				} else if("--debug-threading-mode".equals(arg)) {
+					it.remove();
+					if(it.hasNext()) {
+						debugThreadingMode = it.next();
+						it.remove();
+					}
+				}
+			}
+
 			String fileName = allArgs.get(0);
 			allArgs.remove(0);
 			try {
-				Interpreter.startWithTTY(fileName, allArgs);
+				Interpreter.startWithTTY(fileName, allArgs, true,
+						debug, debugPort, debugSuspend, debugThreadingMode);
 			} catch (Profiles.InvalidProfileException ex) {
 				StreamUtils.GetSystemErr().println("Invalid profile file at " + MethodScriptFileLocations.getDefault()
 						.getProfilesFile()
diff --git a/src/main/java/com/laytonsmith/core/MethodScriptCompiler.java b/src/main/java/com/laytonsmith/core/MethodScriptCompiler.java
index 136b3b164..a2e68b739 100644
--- a/src/main/java/com/laytonsmith/core/MethodScriptCompiler.java
+++ b/src/main/java/com/laytonsmith/core/MethodScriptCompiler.java
@@ -3064,7 +3064,7 @@ public static Mixed execute(ParseTree root, Environment env, MethodScriptComplet
 			}
 			result = script.eval(root, env);
 		}
-		if(done != null) {
+		if(done != null && !Script.isDebuggerPaused(result)) {
 			done.done(result.val().trim());
 		}
 		return result;
diff --git a/src/main/java/com/laytonsmith/core/Procedure.java b/src/main/java/com/laytonsmith/core/Procedure.java
index d04fdd009..1faf47c9d 100644
--- a/src/main/java/com/laytonsmith/core/Procedure.java
+++ b/src/main/java/com/laytonsmith/core/Procedure.java
@@ -10,6 +10,7 @@
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Construct;
 import com.laytonsmith.core.constructs.IVariable;
+import com.laytonsmith.core.constructs.IVariableList;
 import com.laytonsmith.core.constructs.InstanceofUtil;
 import com.laytonsmith.core.constructs.Target;
 import com.laytonsmith.core.environments.Environment;
@@ -20,6 +21,7 @@
 import com.laytonsmith.core.exceptions.CRE.CREStackOverflowError;
 import com.laytonsmith.core.exceptions.ConfigCompileException;
 import com.laytonsmith.core.exceptions.ConfigRuntimeException;
+import com.laytonsmith.core.exceptions.StackTraceFrame;
 import com.laytonsmith.core.exceptions.StackTraceManager;
 import com.laytonsmith.core.exceptions.UnhandledFlowControlException;
 import com.laytonsmith.core.functions.ControlFlow;
@@ -198,7 +200,7 @@ public Mixed execute(List<Mixed> args, Environment oldEnv, Target t) {
 
 		Script fakeScript = Script.GenerateScript(tree, env.getEnv(GlobalEnv.class).GetLabel(), null);
 		StackTraceManager stManager = env.getEnv(GlobalEnv.class).GetStackTraceManager();
-		stManager.addStackTraceElement(new ConfigRuntimeException.StackTraceElement("proc " + name, getTarget()));
+		stManager.addStackTraceFrame(new StackTraceFrame("proc " + name, getTarget()));
 		try {
 			Mixed result = fakeScript.eval(tree, env);
 			if(result == null) {
@@ -223,7 +225,7 @@ public Mixed execute(List<Mixed> args, Environment oldEnv, Target t) {
 		} catch(StackOverflowError e) {
 			throw new CREStackOverflowError(null, t, e);
 		} finally {
-			stManager.popStackTraceElement();
+			stManager.popStackTraceFrame();
 		}
 	}
 
@@ -261,8 +263,8 @@ public void definitelyNotConstant() {
 	public Callable.PreparedCallable prepareCall(List<Mixed> args, Environment callerEnv, Target callTarget) {
 		Environment env = prepareEnvironment(args, callerEnv, callTarget);
 		StackTraceManager stManager = env.getEnv(GlobalEnv.class).GetStackTraceManager();
-		stManager.addStackTraceElement(
-				new ConfigRuntimeException.StackTraceElement("proc " + name, getTarget()));
+		stManager.addStackTraceFrame(
+				new StackTraceFrame("proc " + name, getTarget()));
 		return new Callable.PreparedCallable(tree, env);
 	}
 
@@ -287,7 +289,9 @@ private Environment prepareEnvironment(List<Mixed> args, Environment oldEnv, Tar
 		}
 		oldEnv.getEnv(GlobalEnv.class).setCloneVars(prev);
 
+		IVariableList varList = env.getEnv(GlobalEnv.class).GetVarList();
 		CArray arguments = new CArray(Target.UNKNOWN, this.varIndex.size());
+		IVariable lastParam = this.varIndex.isEmpty() ? null : this.varIndex.get(this.varIndex.size() - 1);
 
 		int varInd;
 		CArray vararg = null;
@@ -295,17 +299,17 @@ private Environment prepareEnvironment(List<Mixed> args, Environment oldEnv, Tar
 			Mixed c = args.get(varInd);
 			arguments.push(c, callTarget);
 			if(this.varIndex.size() > varInd
-					|| (!this.varIndex.isEmpty()
-						&& this.varIndex.get(this.varIndex.size() - 1).getDefinedType().isVariadicType())) {
+					|| (lastParam != null
+						&& lastParam.getDefinedType().isVariadicType())) {
 				IVariable var;
 				if(varInd < this.varIndex.size() - 1
-						|| !this.varIndex.get(this.varIndex.size() - 1).getDefinedType().isVariadicType()) {
+						|| !lastParam.getDefinedType().isVariadicType()) {
 					var = this.varIndex.get(varInd);
 				} else {
-					var = this.varIndex.get(this.varIndex.size() - 1);
+					var = lastParam;
 					if(vararg == null) {
 						vararg = new CArray(callTarget);
-						env.getEnv(GlobalEnv.class).GetVarList().set(new IVariable(CArray.TYPE,
+						varList.set(new IVariable(CArray.TYPE,
 								var.getVariableName(), vararg, c.getTarget()));
 					}
 				}
@@ -329,7 +333,7 @@ private Environment prepareEnvironment(List<Mixed> args, Environment oldEnv, Tar
 				}
 
 				if(InstanceofUtil.isInstanceof(c.typeof(env), var.getDefinedType(), env)) {
-					env.getEnv(GlobalEnv.class).GetVarList().set(new IVariable(var.getDefinedType(),
+					varList.set(new IVariable(var.getDefinedType(),
 							var.getVariableName(), c, c.getTarget()));
 					continue;
 				} else {
@@ -343,11 +347,11 @@ private Environment prepareEnvironment(List<Mixed> args, Environment oldEnv, Tar
 		while(varInd < this.varIndex.size()) {
 			String varName = this.varIndex.get(varInd++).getVariableName();
 			Mixed defVal = this.originals.get(varName);
-			env.getEnv(GlobalEnv.class).GetVarList().set(new IVariable(Auto.TYPE, varName, defVal, defVal.getTarget()));
+			varList.set(new IVariable(Auto.TYPE, varName, defVal, defVal.getTarget()));
 			arguments.push(defVal, callTarget);
 		}
 
-		env.getEnv(GlobalEnv.class).GetVarList().set(new IVariable(CArray.TYPE, "@arguments", arguments, callTarget));
+		varList.set(new IVariable(CArray.TYPE, "@arguments", arguments, callTarget));
 		return env;
 	}
 
@@ -469,14 +473,14 @@ private StepAction startBody(Environment callerEnv) {
 			bodyStarted = true;
 			procEnv = prepareEnvironment(evaluatedArgs, callerEnv, callTarget);
 			StackTraceManager stManager = procEnv.getEnv(GlobalEnv.class).GetStackTraceManager();
-			stManager.addStackTraceElement(
-					new ConfigRuntimeException.StackTraceElement("proc " + name, getTarget()));
+			stManager.addStackTraceFrame(
+					new StackTraceFrame("proc " + name, getTarget(), callTarget));
 			return new StepAction.Evaluate(tree, procEnv);
 		}
 
 		private void popStackTrace() {
 			if(procEnv != null) {
-				procEnv.getEnv(GlobalEnv.class).GetStackTraceManager().popStackTraceElement();
+				procEnv.getEnv(GlobalEnv.class).GetStackTraceManager().popStackTraceFrame();
 			}
 		}
 	}
diff --git a/src/main/java/com/laytonsmith/core/Script.java b/src/main/java/com/laytonsmith/core/Script.java
index 6df42b33d..9806761f5 100644
--- a/src/main/java/com/laytonsmith/core/Script.java
+++ b/src/main/java/com/laytonsmith/core/Script.java
@@ -5,11 +5,13 @@
 import com.laytonsmith.PureUtilities.SimpleVersion;
 import com.laytonsmith.PureUtilities.SmartComment;
 import com.laytonsmith.PureUtilities.TermColors;
+import com.laytonsmith.PureUtilities.Version;
 import com.laytonsmith.abstraction.MCCommandSender;
 import com.laytonsmith.abstraction.MCPlayer;
 import com.laytonsmith.core.compiler.FileOptions;
 import com.laytonsmith.core.compiler.TokenStream;
 import com.laytonsmith.core.compiler.analysis.StaticAnalysis;
+import com.laytonsmith.core.constructs.CClassType;
 import com.laytonsmith.core.constructs.CFunction;
 import com.laytonsmith.core.constructs.CString;
 import com.laytonsmith.core.constructs.CVoid;
@@ -17,13 +19,19 @@
 import com.laytonsmith.core.constructs.Construct;
 import com.laytonsmith.core.constructs.Construct.ConstructType;
 import com.laytonsmith.core.constructs.IVariable;
+import com.laytonsmith.core.constructs.IVariableList;
 import com.laytonsmith.core.constructs.Target;
 import com.laytonsmith.core.constructs.Token;
 import com.laytonsmith.core.constructs.Token.TType;
 import com.laytonsmith.core.constructs.Variable;
+import com.laytonsmith.core.constructs.generics.GenericParameters;
+import com.laytonsmith.core.constructs.generics.LeftHandGenericUse;
 import com.laytonsmith.core.environments.CommandHelperEnvironment;
+import com.laytonsmith.core.environments.DebugContext;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.environments.GlobalEnv;
+import com.laytonsmith.core.environments.LivePausedState;
+import com.laytonsmith.core.environments.PausedState;
 import com.laytonsmith.core.environments.StaticRuntimeEnv;
 import com.laytonsmith.core.exceptions.CRE.CREInsufficientPermissionException;
 import com.laytonsmith.core.exceptions.CRE.CREInvalidProcedureException;
@@ -31,16 +39,24 @@
 import com.laytonsmith.core.exceptions.ConfigCompileException;
 import com.laytonsmith.core.exceptions.ConfigCompileGroupException;
 import com.laytonsmith.core.exceptions.ConfigRuntimeException;
+import com.laytonsmith.core.exceptions.StackTraceFrame;
+import com.laytonsmith.core.exceptions.StackTraceManager;
 import com.laytonsmith.core.exceptions.UnhandledFlowControlException;
 import com.laytonsmith.core.functions.ControlFlow;
 import com.laytonsmith.core.functions.Exceptions;
 import com.laytonsmith.core.functions.Function;
 import com.laytonsmith.core.natives.interfaces.Mixed;
+import com.laytonsmith.core.objects.AccessModifier;
+import com.laytonsmith.core.objects.ObjectModifier;
+import com.laytonsmith.core.objects.ObjectType;
+import java.net.URL;
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.IdentityHashMap;
+import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
@@ -59,6 +75,131 @@
  */
 public class Script {
 
+	/**
+	 * Sentinel value returned by eval/evalLoop when the debugger pauses execution.
+	 * Callers should check with {@link #isDebuggerPaused(Mixed)} before using the result.
+	 */
+	private static final Mixed DEBUGGER_PAUSED
+// <editor-fold defaultstate="collapsed" desc="DEBUGGER_PAUSED implementation">
+			= new Mixed() {
+		@Override
+		public String val() {
+			throw new UnsupportedOperationException("Not supported yet.");
+		}
+
+		@Override
+		public void setTarget(Target target) {
+			throw new UnsupportedOperationException("Not supported yet.");
+		}
+
+		@Override
+		public Target getTarget() {
+			throw new UnsupportedOperationException("Not supported yet.");
+		}
+
+		@Override
+		public Mixed clone() throws CloneNotSupportedException {
+			throw new UnsupportedOperationException("Not supported yet.");
+		}
+
+		@Override
+		public String getName() {
+			throw new UnsupportedOperationException("Not supported yet.");
+		}
+
+		@Override
+		public String docs() {
+			throw new UnsupportedOperationException("Not supported yet.");
+		}
+
+		@Override
+		public Version since() {
+			throw new UnsupportedOperationException("Not supported yet.");
+		}
+
+		@Override
+		public CClassType[] getSuperclasses() {
+			throw new UnsupportedOperationException("Not supported yet.");
+		}
+
+		@Override
+		public CClassType[] getInterfaces() {
+			throw new UnsupportedOperationException("Not supported yet.");
+		}
+
+		@Override
+		public ObjectType getObjectType() {
+			throw new UnsupportedOperationException("Not supported yet.");
+		}
+
+		@Override
+		public Set<ObjectModifier> getObjectModifiers() {
+			throw new UnsupportedOperationException("Not supported yet.");
+		}
+
+		@Override
+		public AccessModifier getAccessModifier() {
+			throw new UnsupportedOperationException("Not supported yet.");
+		}
+
+		@Override
+		public CClassType getContainingClass() {
+			throw new UnsupportedOperationException("Not supported yet.");
+		}
+
+		@Override
+		public boolean isInstanceOf(CClassType type) {
+			throw new UnsupportedOperationException("Not supported yet.");
+		}
+
+		@Override
+		public boolean isInstanceOf(CClassType type, LeftHandGenericUse lhsGenericParameters, Environment env) {
+			throw new UnsupportedOperationException("Not supported yet.");
+		}
+
+		@Override
+		public boolean isInstanceOf(Class<? extends Mixed> type) {
+			throw new UnsupportedOperationException("Not supported yet.");
+		}
+
+		@Override
+		public CClassType typeof() {
+			throw new UnsupportedOperationException("Not supported yet.");
+		}
+
+		@Override
+		public CClassType typeof(Environment env) {
+			throw new UnsupportedOperationException("Not supported yet.");
+		}
+
+		@Override
+		public GenericParameters getGenericParameters() {
+			throw new UnsupportedOperationException("Not supported yet.");
+		}
+
+		@Override
+		public URL getSourceJar() {
+			throw new UnsupportedOperationException("Not supported yet.");
+		}
+
+		@Override
+		public Class<? extends Documentation>[] seeAlso() {
+			throw new UnsupportedOperationException("Not supported yet.");
+		}
+	};
+// </editor-fold>
+
+	/**
+	 * Returns true if the given result indicates the debugger paused execution
+	 * rather than completing normally.
+	 *
+	 * @param result The return value from eval or execute
+	 * @return true if execution was paused by the debugger
+	 */
+	public static boolean isDebuggerPaused(Mixed result) {
+		return result == DEBUGGER_PAUSED;
+	}
+
 	// See set_debug_output()
 	public static boolean debugOutput = false;
 
@@ -289,13 +430,53 @@ public Mixed seval(ParseTree c, final Environment env) {
 	 * @param env The environment
 	 * @return The result of evaluation
 	 */
-	@SuppressWarnings("unchecked")
 	private Mixed iterativeEval(ParseTree root, Environment env) {
 		EvalStack stack = new EvalStack();
 		stack.push(new StackFrame(root, env, null, null));
-		Mixed lastResult = null;
-		boolean hasResult = false;
-		StepAction.FlowControl pendingFlowControl = null;
+		Mixed result = evalLoop(stack, null, false, null, env);
+		DebugContext debugCtx = env.hasEnv(DebugContext.class)
+				? env.getEnv(DebugContext.class) : null;
+		if(debugCtx != null && !isDebuggerPaused(result)) {
+			debugCtx.getListener().onCompleted();
+		}
+		return result;
+	}
+
+	/**
+	 * Resumes execution from a previously frozen {@link DebugSnapshot}. The snapshot is
+	 * created by the interpreter when a debug pause is triggered, and is passed to the
+	 * {@link DebugListener#onPaused} callback. The caller must set the desired
+	 * {@link DebugContext.StepMode} on the DebugContext before calling this method.
+	 *
+	 * @param snapshot The frozen state to resume from
+	 * @return The result of evaluation, or null if execution pauses again
+	 */
+	public static Mixed resumeEval(DebugSnapshot snapshot) {
+		DebugContext debugCtx = snapshot.env.hasEnv(DebugContext.class)
+				? snapshot.env.getEnv(DebugContext.class) : null;
+		if(debugCtx != null) {
+			debugCtx.setPaused(false, null);
+			debugCtx.getListener().onResumed();
+		}
+		// Re-associate the StackTraceManager with the current thread. Since
+		// resumeOnThread spawns a new thread each time, the thread identity
+		// changes, but the StackTraceManager state must carry over. All cloned
+		// GlobalEnvs (from proc calls) share the same StackTraceManager
+		// reference, so adopting once on the top-level env suffices.
+		snapshot.env.getEnv(GlobalEnv.class).adoptStackTraceManager();
+		Mixed result = evalLoop(snapshot.stack, snapshot.lastResult, snapshot.hasResult,
+				snapshot.pendingFlowControl, snapshot.env);
+		if(debugCtx != null && !isDebuggerPaused(result)) {
+			debugCtx.getListener().onCompleted();
+		}
+		return result;
+	}
+
+	@SuppressWarnings("unchecked")
+	private static Mixed evalLoop(EvalStack stack, Mixed lastResult, boolean hasResult,
+			StepAction.FlowControl pendingFlowControl, Environment env) {
+		DebugContext debugCtx = env.hasEnv(DebugContext.class)
+				? env.getEnv(DebugContext.class) : null;
 
 		while(!stack.isEmpty()) {
 			GlobalEnv gEnv = env.getEnv(GlobalEnv.class);
@@ -349,6 +530,21 @@ private Mixed iterativeEval(ParseTree root, Environment env) {
 			ParseTree node = frame.getNode();
 			Mixed data = node.getData();
 
+			// Debug pause check (after flow control is resolved, only on first visit to function nodes)
+			if(debugCtx != null && !debugCtx.isDisconnected()
+					&& data instanceof CFunction
+					&& !frame.hasBegun()) {
+				Target currentTarget = node.getTarget();
+				int userDepth = gEnv.GetStackTraceManager().getDepth();
+				if(debugCtx.shouldPause(currentTarget, userDepth, frame.getEnv())) {
+					Mixed pauseResult = debugPause(debugCtx, stack, lastResult, hasResult,
+							pendingFlowControl, frame.getEnv(), currentTarget);
+					if(pauseResult != null) {
+						return pauseResult;
+					}
+				}
+			}
+
 			// Literal / variable nodes (no children)
 			if(data instanceof Construct co && co.getCType() != Construct.ConstructType.FUNCTION
 					&& node.numberOfChildren() == 0) {
@@ -454,6 +650,17 @@ private Mixed iterativeEval(ParseTree root, Environment env) {
 				} else if(action instanceof StepAction.FlowControl fc) {
 					pendingFlowControl = fc;
 					cleanupAndPop(stack, frame);
+					// Exception breakpoint check for FlowFunction-originated throws
+					if(debugCtx != null && !debugCtx.isDisconnected()
+							&& fc.getAction()
+									instanceof Exceptions.ThrowAction ta
+							&& debugCtx.shouldBreakOnException(ta.getException(), stack)) {
+						Mixed pauseResult = debugPause(debugCtx, stack, lastResult, hasResult,
+								pendingFlowControl, frame.getEnv(), ta.getException().getTarget());
+						if(pauseResult != null) {
+							return pauseResult;
+						}
+					}
 				}
 				continue;
 			}
@@ -495,7 +702,16 @@ private Mixed iterativeEval(ParseTree root, Environment env) {
 						// Convert MethodScript exceptions to FlowControl(ThrowAction)
 						stack.pop();
 						pendingFlowControl = new StepAction.FlowControl(
-								new com.laytonsmith.core.functions.Exceptions.ThrowAction(e));
+								new Exceptions.ThrowAction(e));
+						// Exception breakpoint check
+						if(debugCtx != null && !debugCtx.isDisconnected()
+								&& debugCtx.shouldBreakOnException(e, stack)) {
+							Mixed pauseResult = debugPause(debugCtx, stack, lastResult, hasResult,
+									pendingFlowControl, frame.getEnv(), e.getTarget());
+							if(pauseResult != null) {
+								return pauseResult;
+							}
+						}
 					}
 				}
 			}
@@ -517,6 +733,46 @@ private static void cleanupAndPop(EvalStack stack, StackFrame frame) {
 		stack.pop();
 	}
 
+	/**
+	 * Handles the debug pause at a breakpoint or step condition. In synchronous mode,
+	 * blocks the interpreter thread until the DAP server calls resume, then returns
+	 * {@code null} to indicate execution should continue. In asynchronous mode,
+	 * creates a snapshot and returns {@link #DEBUGGER_PAUSED} to indicate the caller
+	 * should return that sentinel value.
+	 *
+	 * @param debugCtx The debug context
+	 * @param stack The eval stack (used for async snapshot)
+	 * @param lastResult The last result (used for async snapshot)
+	 * @param hasResult Whether there is a pending result (used for async snapshot)
+	 * @param pendingFlowControl The pending flow control (used for exception state)
+	 * @param env The current frame's environment
+	 * @param pauseTarget The source location where execution is pausing
+	 * @return {@link #DEBUGGER_PAUSED} if the caller should return (async mode),
+	 *     or null if execution should continue (sync mode resumed or interrupted)
+	 */
+	private static Mixed debugPause(DebugContext debugCtx, EvalStack stack,
+			Mixed lastResult, boolean hasResult,
+			StepAction.FlowControl pendingFlowControl, Environment env, Target pauseTarget) {
+		debugCtx.setPaused(true, pauseTarget);
+		if(debugCtx.shouldUseSyncMode()) {
+			LivePausedState state = new LivePausedState(env, pauseTarget, pendingFlowControl);
+			debugCtx.getListener().onPaused(state);
+			try {
+				debugCtx.awaitResume();
+			} catch(InterruptedException e) {
+				java.lang.Thread.currentThread().interrupt();
+			}
+			debugCtx.setPaused(false, null);
+			debugCtx.getListener().onResumed();
+			return null;
+		} else {
+			DebugSnapshot snapshot = new DebugSnapshot(
+					stack, lastResult, hasResult, pendingFlowControl, env, pauseTarget);
+			debugCtx.getListener().onPaused(snapshot);
+			return DEBUGGER_PAUSED;
+		}
+	}
+
 	/**
 	 * Given the parse tree and environment, executes the tree.
 	 *
@@ -979,4 +1235,126 @@ public boolean doLog() {
 		return !nolog;
 	}
 
+	/**
+	 * A frozen snapshot of the interpreter's execution state, created when the debugger pauses.
+	 * Contains everything needed to inspect the current state (variables, call stack, source
+	 * location) and to resume execution later.
+	 *
+	 * <p>The raw interpreter state (eval stack, pending flow control, etc.) is private and
+	 * accessible only to {@link Script}. External callers (e.g. a DAP server) can use the
+	 * public inspection methods to read variables, call stack, and source location.</p>
+	 */
+	public static final class DebugSnapshot implements PausedState {
+
+		private final EvalStack stack;
+		private final Mixed lastResult;
+		private final boolean hasResult;
+		private final StepAction.FlowControl pendingFlowControl;
+		private final Environment env;
+		private final Target pauseTarget;
+
+		private DebugSnapshot(EvalStack stack, Mixed lastResult, boolean hasResult,
+				StepAction.FlowControl pendingFlowControl, Environment env, Target pauseTarget) {
+			this.stack = stack;
+			this.lastResult = lastResult;
+			this.hasResult = hasResult;
+			this.pendingFlowControl = pendingFlowControl;
+			this.env = env;
+			this.pauseTarget = pauseTarget;
+		}
+
+		/**
+		 * Returns the source location where execution paused.
+		 */
+		@Override
+		public Target getPauseTarget() {
+			return pauseTarget;
+		}
+
+		/**
+		 * Returns the environment at the point of the pause.
+		 */
+		@Override
+		public Environment getEnvironment() {
+			return env;
+		}
+
+		/**
+		 * Returns the user-visible call stack (proc/closure/include frames) at the point
+		 * of the pause. The list is ordered from innermost (most recent) to outermost.
+		 *
+		 * @return A list of stack trace frames
+		 */
+		@Override
+		public List<StackTraceFrame> getCallStack() {
+			StackTraceManager stm = env.getEnv(GlobalEnv.class).peekStackTraceManager();
+			if(stm == null) {
+				return Collections.emptyList();
+			}
+			return stm.getCurrentStackTrace();
+		}
+
+		/**
+		 * Returns the user-visible call depth at the point of the pause. This is the
+		 * count of proc/closure/include frames, not the raw eval stack size.
+		 *
+		 * @return The user-visible call depth
+		 */
+		@Override
+		public int getUserCallDepth() {
+			StackTraceManager stm = env.getEnv(GlobalEnv.class).peekStackTraceManager();
+			if(stm == null) {
+				return 0;
+			}
+			return stm.getDepth();
+		}
+
+		/**
+		 * Returns the variables visible at the point of the pause as a name-to-value map.
+		 * The map preserves insertion order.
+		 *
+		 * @return A map from variable name (including the @ prefix) to its current value
+		 */
+		@Override
+		public Map<String, Mixed> getVariables() {
+			IVariableList varList = env.getEnv(GlobalEnv.class).GetVarList();
+			Map<String, Mixed> result = new LinkedHashMap<>();
+			for(String name : varList.keySet()) {
+				IVariable iv = varList.get(name);
+				if(iv != null) {
+					result.put(name, iv.ival());
+				}
+			}
+			return result;
+		}
+
+		/**
+		 * Returns true if this pause was caused by an exception breakpoint.
+		 */
+		@Override
+		public boolean isExceptionPause() {
+			return pendingFlowControl != null
+					&& pendingFlowControl.getAction() instanceof Exceptions.ThrowAction;
+		}
+
+		/**
+		 * If this is an exception pause, returns the exception that caused the pause.
+		 * Otherwise returns null.
+		 */
+		@Override
+		public ConfigRuntimeException getPauseException() {
+			if(pendingFlowControl != null
+					&& pendingFlowControl.getAction() instanceof Exceptions.ThrowAction ta) {
+				return ta.getException();
+			}
+			return null;
+		}
+
+		@Override
+		public String toString() {
+			return "DebugSnapshot{target=" + pauseTarget + ", depth=" + getUserCallDepth()
+					+ ", vars=" + getVariables().size() + ", hasResult=" + hasResult + "}";
+		}
+	}
+
 }
diff --git a/src/main/java/com/laytonsmith/core/StackFrame.java b/src/main/java/com/laytonsmith/core/StackFrame.java
index 09d952c7d..4bf852642 100644
--- a/src/main/java/com/laytonsmith/core/StackFrame.java
+++ b/src/main/java/com/laytonsmith/core/StackFrame.java
@@ -29,7 +29,7 @@ public class StackFrame {
 	private final Environment env;
 	private final Function function;
 	private final FlowFunction<?> flowFunction;
-	private final List<Mixed> args;
+	private List<Mixed> args;
 	private int childIndex;
 	private boolean begun;
 	private Object functionState;
@@ -48,7 +48,6 @@ public StackFrame(ParseTree node, Environment env, Function function, FlowFuncti
 		this.env = env;
 		this.function = function;
 		this.flowFunction = flowFunction;
-		this.args = new ArrayList<>();
 		this.childIndex = 0;
 		this.begun = false;
 		this.functionState = null;
@@ -158,6 +157,9 @@ public ParseTree nextChild() {
 	 * Adds an evaluated child result to the args list (for simple mode).
 	 */
 	public void addArg(Mixed result) {
+		if(args == null) {
+			args = new ArrayList<>();
+		}
 		args.add(result);
 	}
 
@@ -165,6 +167,9 @@ public void addArg(Mixed result) {
 	 * Returns the accumulated evaluated arguments (for simple mode).
 	 */
 	public Mixed[] getArgs() {
+		if(args == null) {
+			return new Mixed[0];
+		}
 		return args.toArray(new Mixed[0]);
 	}
 
diff --git a/src/main/java/com/laytonsmith/core/constructs/CClosure.java b/src/main/java/com/laytonsmith/core/constructs/CClosure.java
index 713b42d8b..b7f8a1a01 100644
--- a/src/main/java/com/laytonsmith/core/constructs/CClosure.java
+++ b/src/main/java/com/laytonsmith/core/constructs/CClosure.java
@@ -22,6 +22,7 @@
 import com.laytonsmith.core.exceptions.CRE.CREStackOverflowError;
 import com.laytonsmith.core.exceptions.CancelCommandException;
 import com.laytonsmith.core.exceptions.ConfigRuntimeException;
+import com.laytonsmith.core.exceptions.StackTraceFrame;
 import com.laytonsmith.core.exceptions.StackTraceManager;
 import com.laytonsmith.core.exceptions.UnhandledFlowControlException;
 import com.laytonsmith.core.functions.Exceptions;
@@ -125,7 +126,7 @@ public ParseTree getNode() {
 	 * instead of recursing into a new eval() call.
 	 *
 	 * <p>The caller is responsible for evaluating the body (via {@link #getNode()}) in the
-	 * returned environment, and for calling {@link StackTraceManager#popStackTraceElement()}
+	 * returned environment, and for calling {@link StackTraceManager#popStackTraceFrame()}
 	 * when done (or ensuring it's done via a cleanup mechanism).</p>
 	 *
 	 * @param values The argument values to bind, or null for no arguments
@@ -146,7 +147,7 @@ public PreparedExecution prepareExecution(Mixed... values) throws ConfigRuntimeE
 			return null;
 		}
 		StackTraceManager stManager = env.getEnv(GlobalEnv.class).GetStackTraceManager();
-		stManager.addStackTraceElement(new ConfigRuntimeException.StackTraceElement("<<closure>>", getTarget()));
+		stManager.addStackTraceFrame(new StackTraceFrame("<<closure>>", getTarget()));
 
 		CArray arguments = new CArray(node.getData().getTarget());
 		CArray vararg = null;
@@ -267,14 +268,13 @@ public synchronized Environment getEnv() {
 	 * Shorthand for calling
 	 * {@link #executeCallable(com.laytonsmith.core.environments.Environment,
 	 * com.laytonsmith.core.constructs.Target, com.laytonsmith.core.natives.interfaces.Mixed...)}
-	 * with a null environment, and Target.UNKNOWN. Since closures don't need these parameters,
-	 * this is easier, however, Callables do not have this.
+	 * with a null environment, and Target.UNKNOWN.
 	 * @param values
 	 * @return
 	 * @throws ConfigRuntimeException
 	 * @throws CancelCommandException
-	 * @deprecated Functions that call closures should extend {@link CallbackYield}
-	 * instead of calling this directly, which re-enters eval() and defeats the iterative interpreter.
+	 * @deprecated Use {@link #executeCallable(Environment, Target, Mixed...)} instead, which
+	 * provides the caller's environment and target for proper error reporting.
 	 */
 	@Deprecated
 	public Mixed executeCallable(Mixed... values) {
@@ -285,14 +285,20 @@ public Mixed executeCallable(Mixed... values) {
 	 * Executes the closure, giving it the supplied arguments. {@code values} may be null, which means that no arguments
 	 * are being sent.
 	 *
-	 * ConfigRuntimeExceptions will bubble up past this, since an execution mechanism may need to do custom handling.
+	 * <p>ConfigRuntimeExceptions will bubble up past this, since an execution mechanism may need to do custom
+	 * handling.</p>
 	 *
-	 * A typical execution will include the following code:
+	 * <p>Note: This method starts a fresh top-level evaluation, which is correct for callers that run the
+	 * closure on a new thread (e.g., x_new_thread). However, callers that execute the closure on the
+	 * <em>same</em> thread within an already-running eval loop should extend {@link CallbackYield} and use
+	 * {@link #prepareForStack} instead, to avoid re-entering eval() and defeating the iterative interpreter.</p>
+	 *
+	 * <p>A typical execution will include the following code:</p>
 	 * <pre>
 	 * try {
-	 *	closure.execute();
+	 *	closure.executeCallable(env, t);
 	 * } catch (ConfigRuntimeException e){
-	 *	ConfigRuntimeException.HandleUncaughtException(e);
+	 *	ConfigRuntimeException.HandleUncaughtException(e, env);
 	 * } catch (CancelCommandException e){
 	 *	// Ignored
 	 * }
@@ -305,10 +311,7 @@ public Mixed executeCallable(Mixed... values) {
 	 * @return The return value of the closure, or VOID if nothing was returned
 	 * @throws ConfigRuntimeException If any call inside the closure causes a CRE
 	 * @throws CancelCommandException If die() is called within the closure
-	 * @deprecated Functions that call closures should extend {@link CallbackYield}
-	 * instead of calling this directly, which re-enters eval() and defeats the iterative interpreter.
 	 */
-	@Deprecated
 	@Override
 	public Mixed executeCallable(Environment env, Target t, Mixed... values)
 			throws ConfigRuntimeException, CancelCommandException {
@@ -322,78 +325,13 @@ public Mixed executeCallable(Environment env, Target t, Mixed... values)
 	 */
 	protected Mixed execute(Mixed... values) throws ConfigRuntimeException,
 			CancelCommandException {
-		if(node == null) {
-			return CVoid.VOID;
-		}
-		Environment env;
-		try {
-			synchronized(this) {
-				env = this.env.clone();
-			}
-		} catch (CloneNotSupportedException ex) {
-			Logger.getLogger(CClosure.class.getName()).log(Level.SEVERE, null, ex);
+		PreparedExecution prep = prepareExecution(values);
+		if(prep == null) {
 			return CVoid.VOID;
 		}
+		Environment env = prep.getEnv();
 		StackTraceManager stManager = env.getEnv(GlobalEnv.class).GetStackTraceManager();
-		stManager.addStackTraceElement(new ConfigRuntimeException.StackTraceElement("<<closure>>", getTarget()));
 		try {
-			CArray arguments = new CArray(node.getData().getTarget());
-			CArray vararg = null;
-			CClassType varargType = null;
-			if(values != null) {
-				for(int i = 0; i < Math.max(values.length, names.length); i++) {
-					Mixed value;
-					if(i < values.length) {
-						value = values[i];
-					} else {
-						value = defaults[i].clone();
-					}
-					arguments.push(value, node.getData().getTarget());
-					boolean isVarArg = false;
-					if(this.names.length > i
-						|| (this.names.length != 0
-							&& this.types[this.names.length - 1].isVariadicType())) {
-						String name;
-						if(i < this.names.length - 1
-								|| !this.types[this.types.length - 1].isVariadicType()) {
-							name = names[i];
-						} else {
-							name = this.names[this.names.length - 1];
-							if(vararg == null) {
-								// TODO: Once generics are added, add the type
-								vararg = new CArray(value.getTarget());
-								env.getEnv(GlobalEnv.class).GetVarList().set(new IVariable(CArray.TYPE,
-										name, vararg, value.getTarget()));
-								varargType = this.types[this.types.length - 1];
-							}
-							isVarArg = true;
-						}
-						if(isVarArg) {
-							if(!InstanceofUtil.isInstanceof(value.typeof(env), varargType.getVarargsBaseType(), env)) {
-								throw new CRECastException("Expected type " + varargType + " but found " + value.typeof(env),
-										getTarget());
-							}
-							vararg.push(value, value.getTarget());
-						} else {
-							IVariable var = new IVariable(types[i], name, value, getTarget(), env);
-							env.getEnv(GlobalEnv.class).GetVarList().set(var);
-						}
-					}
-				}
-			}
-			boolean hasArgumentsParam = false;
-			for(String pName : this.names) {
-				if(pName.equals("@arguments")) {
-					hasArgumentsParam = true;
-					break;
-				}
-			}
-
-			if(!hasArgumentsParam) {
-				env.getEnv(GlobalEnv.class).GetVarList().set(new IVariable(CArray.TYPE, "@arguments", arguments,
-						node.getData().getTarget()));
-			}
-
 			Script script = env.getEnv(GlobalEnv.class).GetScript();
 			if(script == null) {
 				script = Script.GenerateScript(node, env.getEnv(GlobalEnv.class).GetLabel(), null);
@@ -427,11 +365,8 @@ protected Mixed execute(Mixed... values) throws ConfigRuntimeException,
 						result.getTarget());
 			}
 			return result;
-		} catch (CloneNotSupportedException ex) {
-			Logger.getLogger(CClosure.class.getName()).log(Level.SEVERE, null, ex);
-			return CVoid.VOID;
 		} finally {
-			stManager.popStackTraceElement();
+			stManager.popStackTraceFrame();
 		}
 	}
 
diff --git a/src/main/java/com/laytonsmith/core/environments/Breakpoint.java b/src/main/java/com/laytonsmith/core/environments/Breakpoint.java
new file mode 100644
index 000000000..bf2a1bb72
--- /dev/null
+++ b/src/main/java/com/laytonsmith/core/environments/Breakpoint.java
@@ -0,0 +1,177 @@
+package com.laytonsmith.core.environments;
+
+import com.laytonsmith.PureUtilities.ObjectHelpers;
+import com.laytonsmith.PureUtilities.ObjectHelpers.StandardField;
+import com.laytonsmith.core.MethodScriptCompiler;
+import com.laytonsmith.core.ParseTree;
+import com.laytonsmith.core.exceptions.ConfigCompileException;
+import com.laytonsmith.core.exceptions.ConfigCompileGroupException;
+
+import java.io.File;
+
+/**
+ * A breakpoint at a specific file and line. Used for O(1) lookup in
+ * {@link DebugContext}'s breakpoint set via {@link #equals(Object)} and {@link #hashCode()}.
+ *
+ * <p>Line numbers are 1-indexed, matching {@link com.laytonsmith.core.constructs.Target#line()}.
+ * Identity is based on file+line only; condition and hit count are not part of equality.</p>
+ */
+public class Breakpoint {
+
+	@StandardField
+	private final File file;
+
+	@StandardField
+	private final int line;
+
+	private final String condition;
+	private final ParseTree compiledCondition;
+	private final int hitCountThreshold;
+	private int hitCount;
+	private final String logMessage;
+
+	/**
+	 * Creates an unconditional breakpoint at the given file and line.
+	 *
+	 * @param file The source file. Must not be null.
+	 * @param line The 1-indexed line number. Must be positive.
+	 */
+	public Breakpoint(File file, int line) {
+		this(file, line, null, 0, null);
+	}
+
+	/**
+	 * Creates a breakpoint with optional condition and hit count threshold.
+	 * If a condition is provided, it is compiled immediately so that syntax
+	 * errors are caught early.
+	 *
+	 * @param file The source file. Must not be null.
+	 * @param line The 1-indexed line number. Must be positive.
+	 * @param condition A MethodScript expression to evaluate, or null for unconditional.
+	 * @param hitCountThreshold Number of times the breakpoint must be hit before pausing
+	 *                          (0 means pause on first hit).
+	 */
+	public Breakpoint(File file, int line, String condition, int hitCountThreshold) {
+		this(file, line, condition, hitCountThreshold, null);
+	}
+
+	/**
+	 * Creates a breakpoint with optional condition, hit count threshold, and log message.
+	 * If a condition is provided, it is compiled immediately so that syntax
+	 * errors are caught early. If a logMessage is provided, this breakpoint
+	 * acts as a log point: instead of pausing, it logs the message and continues.
+	 * Expressions in {@code {braces}} within the log message are evaluated at hit time.
+	 *
+	 * @param file The source file. Must not be null.
+	 * @param line The 1-indexed line number. Must be positive.
+	 * @param condition A MethodScript expression to evaluate, or null for unconditional.
+	 * @param hitCountThreshold Number of times the breakpoint must be hit before pausing
+	 *                          (0 means pause on first hit).
+	 * @param logMessage A message to log instead of pausing, or null for a normal breakpoint.
+	 * @throws IllegalArgumentException if the condition cannot be compiled
+	 */
+	public Breakpoint(File file, int line, String condition, int hitCountThreshold, String logMessage) {
+		if(file == null) {
+			throw new IllegalArgumentException("Breakpoint file must not be null");
+		}
+		if(line <= 0) {
+			throw new IllegalArgumentException("Breakpoint line must be positive, got " + line);
+		}
+		this.file = file;
+		this.line = line;
+		this.condition = condition;
+		this.hitCountThreshold = hitCountThreshold;
+		this.hitCount = 0;
+		if(condition != null && !condition.isEmpty()) {
+			try {
+				this.compiledCondition = MethodScriptCompiler.compile(
+						MethodScriptCompiler.lex(condition, null, null, true),
+						null, Environment.getDefaultEnvClasses());
+			} catch(ConfigCompileException | ConfigCompileGroupException e) {
+				throw new IllegalArgumentException("Invalid breakpoint condition: " + e.getMessage(), e);
+			}
+		} else {
+			this.compiledCondition = null;
+		}
+		this.logMessage = logMessage;
+	}
+
+	/**
+	 * Returns the log message template, or null if this is a normal breakpoint.
+	 */
+	public String logMessage() {
+		return logMessage;
+	}
+
+	/**
+	 * Returns true if this is a log point (logs instead of pausing).
+	 */
+	public boolean isLogPoint() {
+		return logMessage != null && !logMessage.isEmpty();
+	}
+
+	/**
+	 * Returns the source file.
+	 */
+	public File file() {
+		return file;
+	}
+
+	/**
+	 * Returns the 1-indexed line number.
+	 */
+	public int line() {
+		return line;
+	}
+
+	/**
+	 * Returns the condition expression source, or null if unconditional.
+	 */
+	public String condition() {
+		return condition;
+	}
+
+	/**
+	 * Returns the pre-compiled condition parse tree, or null if unconditional.
+	 */
+	public ParseTree compiledCondition() {
+		return compiledCondition;
+	}
+
+	/**
+	 * Returns the hit count threshold (0 means always pause).
+	 */
+	public int hitCountThreshold() {
+		return hitCountThreshold;
+	}
+
+	/**
+	 * Returns true if this breakpoint has a condition or hit count threshold.
+	 */
+	public boolean isConditional() {
+		return compiledCondition != null || hitCountThreshold > 0;
+	}
+
+	/**
+	 * Increments and returns the current hit count.
+	 */
+	public int incrementHitCount() {
+		return ++hitCount;
+	}
+
+	@Override
+	@SuppressWarnings("EqualsWhichDoesntCheckParameterClass")
+	public boolean equals(Object obj) {
+		return ObjectHelpers.DoEquals(this, obj);
+	}
+
+	@Override
+	public int hashCode() {
+		return ObjectHelpers.DoHashCode(this);
+	}
+
+	@Override
+	public String toString() {
+		return file.getName() + ":" + line;
+	}
+}
diff --git a/src/main/java/com/laytonsmith/core/environments/DebugContext.java b/src/main/java/com/laytonsmith/core/environments/DebugContext.java
new file mode 100644
index 000000000..e1f1f66da
--- /dev/null
+++ b/src/main/java/com/laytonsmith/core/environments/DebugContext.java
@@ -0,0 +1,734 @@
+package com.laytonsmith.core.environments;
+
+import com.laytonsmith.core.ArgumentValidation;
+import com.laytonsmith.core.EvalStack;
+import com.laytonsmith.core.FlowFunction;
+import com.laytonsmith.core.MethodScriptCompiler;
+import com.laytonsmith.core.ParseTree;
+import com.laytonsmith.core.StackFrame;
+import com.laytonsmith.core.constructs.IVariable;
+import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.exceptions.ConfigRuntimeException;
+import com.laytonsmith.core.natives.interfaces.Mixed;
+
+import java.io.File;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+
+/**
+ * An {@link Environment.EnvironmentImpl} that holds debugger state. When present in the
+ * environment, the interpreter loop checks it at the top of each iteration to determine
+ * whether execution should pause (breakpoint hit or step condition met).
+ *
+ * <p>Two threading modes are supported:</p>
+ * <ul>
+ *   <li><b>SYNCHRONOUS</b>: The interpreter thread blocks on a latch when paused.
+ *       The Java call stack is preserved, and resume releases the latch. This is
+ *       the default for command-line execution.</li>
+ *   <li><b>ASYNCHRONOUS</b>: The interpreter freezes its state into a
+ *       {@link com.laytonsmith.core.Script.DebugSnapshot DebugSnapshot}, calls
+ *       {@link DebugListener#onPaused}, and returns. The caller decides whether
+ *       to block or return control. This is the default for embedded mode where
+ *       the main thread cannot be blocked.</li>
+ * </ul>
+ */
+public class DebugContext implements Environment.EnvironmentImpl {
+
+	/**
+	 * Controls how the interpreter thread behaves when paused.
+	 */
+	public enum ThreadingMode {
+		/** Block the interpreter thread in place. Java call stack preserved. */
+		SYNCHRONOUS,
+		/** Snapshot state and return control to the caller. */
+		ASYNCHRONOUS
+	}
+
+	/**
+	 * The step mode determines when the interpreter next pauses.
+	 */
+	public enum StepMode {
+		/** Running freely - only pause on breakpoints. */
+		NONE,
+		/** Step Into - pause on the very next frame with a source location. */
+		INTO,
+		/** Step Over - pause on the next frame at the same or lower stack depth. */
+		OVER,
+		/** Step Out - pause when the stack depth drops below the reference depth. */
+		OUT
+	}
+
+	/**
+	 * Determines when exceptions cause the debugger to break.
+	 */
+	public enum ExceptionBreakMode {
+		/** Never break on exceptions. */
+		NONE,
+		/** Break only on uncaught exceptions (no matching try/catch on the stack). */
+		UNCAUGHT,
+		/** Break on all thrown exceptions, whether caught or not. */
+		ALL
+	}
+
+	private final Map<File, TreeMap<Integer, Breakpoint>> breakpoints = new HashMap<>();
+	private ExceptionBreakMode exceptionBreakMode = ExceptionBreakMode.NONE;
+	private boolean disconnected = false;
+	private DebugListener listener;
+	private ThreadingMode threadingMode;
+	private volatile Thread mainThread;
+
+	// Log point deduplication: tracks last fired log point to avoid firing
+	// multiple times for different AST nodes on the same source line.
+	private File lastLogPointFile;
+	private int lastLogPointLine = -1;
+
+	// Per-thread debug state (step mode, pause latch, etc.)
+	private final ConcurrentHashMap<Thread, ThreadDebugState> threadStates = new ConcurrentHashMap<>();
+
+	// Thread registry: Thread → DAP thread ID and Thread → name
+	public static final int MAIN_THREAD_DAP_ID = 1;
+	private final AtomicInteger nextDapThreadId = new AtomicInteger(MAIN_THREAD_DAP_ID + 1);
+	private final ConcurrentHashMap<Thread, Integer> threadDapIds = new ConcurrentHashMap<>();
+	private final ConcurrentHashMap<Thread, String> threadNames = new ConcurrentHashMap<>();
+
+	/**
+	 * Creates a new DebugContext with no breakpoints, the given listener, and
+	 * the specified threading mode.
+	 *
+	 * @param listener The listener to notify when execution pauses or resumes.
+	 *     Must not be null.
+	 * @param threadingMode The threading mode (SYNCHRONOUS or ASYNCHRONOUS).
+	 *     The caller must choose the appropriate mode for its execution context.
+	 * @param mainThread The main execution thread. Non-main threads (e.g. from
+	 *     x_new_thread) always use synchronous mode regardless of the configured
+	 *     threading mode. Must not be null.
+	 */
+	public DebugContext(DebugListener listener, ThreadingMode threadingMode, Thread mainThread) {
+		if(listener == null) {
+			throw new IllegalArgumentException("DebugListener must not be null");
+		}
+		if(mainThread == null) {
+			throw new IllegalArgumentException("mainThread must not be null");
+		}
+		this.listener = listener;
+		this.threadingMode = threadingMode;
+		this.mainThread = mainThread;
+		threadDapIds.put(mainThread, MAIN_THREAD_DAP_ID);
+		threadNames.put(mainThread, "main");
+	}
+
+	/**
+	 * Adds a breakpoint. If a breakpoint at the same file+line exists, it is replaced.
+	 *
+	 * @param bp The breakpoint to add
+	 */
+	public void addBreakpoint(Breakpoint bp) {
+		breakpoints.computeIfAbsent(bp.file(), k -> new TreeMap<>()).put(bp.line(), bp);
+	}
+
+	/**
+	 * Removes a breakpoint. If the breakpoint doesn't exist, this is a no-op.
+	 *
+	 * @param bp The breakpoint to remove
+	 */
+	public void removeBreakpoint(Breakpoint bp) {
+		TreeMap<Integer, Breakpoint> lines = breakpoints.get(bp.file());
+		if(lines != null) {
+			lines.remove(bp.line());
+			if(lines.isEmpty()) {
+				breakpoints.remove(bp.file());
+			}
+		}
+	}
+
+	/**
+	 * Replaces all breakpoints for a given file. Used by DAP's setBreakpoints
+	 * which sends the full set of breakpoints for a file at once.
+	 *
+	 * @param file The file whose breakpoints to replace
+	 * @param lines The new set of line numbers
+	 */
+	public void setBreakpointsForFile(File file, Set<Integer> lines) {
+		TreeMap<Integer, Breakpoint> map = new TreeMap<>();
+		for(int line : lines) {
+			Breakpoint bp = new Breakpoint(file, line);
+			map.put(line, bp);
+		}
+		if(map.isEmpty()) {
+			breakpoints.remove(file);
+		} else {
+			breakpoints.put(file, map);
+		}
+	}
+
+	/**
+	 * Replaces all breakpoints for a given file with fully configured breakpoints
+	 * (including conditions and hit counts).
+	 *
+	 * @param file The file whose breakpoints to replace
+	 * @param newBreakpoints The new breakpoints for this file
+	 */
+	public void setBreakpointsForFile(File file, java.util.List<Breakpoint> newBreakpoints) {
+		TreeMap<Integer, Breakpoint> map = new TreeMap<>();
+		for(Breakpoint bp : newBreakpoints) {
+			map.put(bp.line(), bp);
+		}
+		if(map.isEmpty()) {
+			breakpoints.remove(file);
+		} else {
+			breakpoints.put(file, map);
+		}
+	}
+
+	/**
+	 * Looks up the breakpoint at the given file and line, or returns null if none exists.
+	 * O(log n) in the number of breakpoints for that file.
+	 */
+	public Breakpoint getBreakpoint(File file, int line) {
+		TreeMap<Integer, Breakpoint> lines = breakpoints.get(file);
+		if(lines == null) {
+			return null;
+		}
+		return lines.get(line);
+	}
+
+	/**
+	 * Clears all breakpoints.
+	 */
+	public void clearBreakpoints() {
+		breakpoints.clear();
+	}
+
+	/**
+	 * Gets or creates the {@link ThreadDebugState} for the calling thread.
+	 */
+	public ThreadDebugState getThreadState() {
+		return threadStates.computeIfAbsent(Thread.currentThread(), k -> new ThreadDebugState());
+	}
+
+	/**
+	 * Gets or creates the {@link ThreadDebugState} for the specified thread.
+	 */
+	public ThreadDebugState getThreadState(Thread t) {
+		return threadStates.computeIfAbsent(t, k -> new ThreadDebugState());
+	}
+
+	/**
+	 * Returns the current step mode for the calling thread.
+	 */
+	public StepMode getStepMode() {
+		return getThreadState().getStepMode();
+	}
+
+	/**
+	 * Sets the step mode and reference depth for the calling thread. Called when the user
+	 * issues a step command (into/over/out) or continue.
+	 *
+	 * @param mode The new step mode
+	 * @param currentDepth The user-visible call depth at the time of the command
+	 *     (count of proc/closure/include frames, not raw eval stack size)
+	 * @param currentTarget The source target at the time of the command
+	 */
+	public void setStepMode(StepMode mode, int currentDepth, Target currentTarget) {
+		getThreadState().setStepMode(mode, currentDepth, currentTarget);
+	}
+
+	/**
+	 * Sets the step mode for a specific thread, identified by DAP thread ID.
+	 */
+	public void setStepMode(int dapThreadId, StepMode mode, int currentDepth, Target currentTarget) {
+		Thread t = getThreadByDapId(dapThreadId);
+		if(t != null) {
+			getThreadState(t).setStepMode(mode, currentDepth, currentTarget);
+		}
+	}
+
+	/**
+	 * Returns the stack depth when the current step command was issued, for the calling thread.
+	 */
+	public int getStepReferenceDepth() {
+		return getThreadState().getStepReferenceDepth();
+	}
+
+	/**
+	 * Returns true if the calling thread is currently in a paused state.
+	 */
+	public boolean isPaused() {
+		return getThreadState().isPaused();
+	}
+
+	/**
+	 * Sets the paused state for the calling thread. Called by the interpreter when it freezes.
+	 * When pausing, also records the pause location so that on resume,
+	 * the breakpoint check can be skipped until the interpreter moves
+	 * past the pause point.
+	 *
+	 * @param paused true if pausing, false if resuming
+	 * @param pauseTarget The source location where execution paused,
+	 *     or null when resuming
+	 */
+	public void setPaused(boolean paused, Target pauseTarget) {
+		getThreadState().setPaused(paused, pauseTarget);
+	}
+
+	/**
+	 * Marks the debugger as disconnected. The interpreter will clear the
+	 * DebugContext and run to completion.
+	 */
+	public void disconnect() {
+		this.disconnected = true;
+		for(ThreadDebugState state : threadStates.values()) {
+			state.setPaused(false, null);
+			state.setStepMode(StepMode.NONE, 0, null);
+			state.resume();
+		}
+		threadStates.clear();
+	}
+
+	/**
+	 * Returns true if the debugger has been disconnected.
+	 */
+	public boolean isDisconnected() {
+		return disconnected;
+	}
+
+	/**
+	 * Returns the debug listener.
+	 */
+	public DebugListener getListener() {
+		return listener;
+	}
+
+	/**
+	 * Determines whether the interpreter should pause at the given source location
+	 * and user-visible call depth. This is called at the top of each interpreter loop
+	 * iteration.
+	 *
+	 * <p>The {@code userCallDepth} is <b>not</b> the raw eval stack size. It is the count
+	 * of user-visible call boundaries on the stack - proc calls, closure calls, and includes.
+	 * Internal functions (if, for, array_push, etc.) do not count. This matches the call
+	 * stack a user would see in a debugger's stack trace panel.</p>
+	 *
+	 * @param source The source location of the current frame
+	 * @param userCallDepth The user-visible call depth (proc/closure/include nesting)
+	 * @param env The current environment, used for evaluating conditional breakpoints
+	 * @return true if the interpreter should pause
+	 */
+	public boolean shouldPause(Target source, int userCallDepth, Environment env) {
+		if(disconnected) {
+			return false;
+		}
+
+		if(source == null || source == Target.UNKNOWN
+				|| source.file() == null || source.line() <= 0) {
+			return false;
+		}
+
+		ThreadDebugState state = getThreadState();
+
+		// Check if we would normally pause here (breakpoint or step condition).
+		boolean shouldStop = false;
+
+		Breakpoint bp = getBreakpoint(source.file(), source.line());
+		if(bp != null) {
+			if(bp.isConditional()) {
+				shouldStop = evaluateBreakpointCondition(bp, env);
+			} else {
+				shouldStop = true;
+			}
+			if(shouldStop && bp.isLogPoint()) {
+				// Deduplicate: only fire once per visit to a source line.
+				// Resets when execution moves to a different line.
+				if(!source.file().equals(lastLogPointFile) || source.line() != lastLogPointLine) {
+					lastLogPointFile = source.file();
+					lastLogPointLine = source.line();
+					String msg = interpolateLogMessage(bp.logMessage(), env);
+					listener.onLogPoint(msg);
+				}
+				return false;
+			}
+		}
+
+		// Clear log point dedup when we move to a different line
+		if(lastLogPointLine != -1
+				&& (!source.file().equals(lastLogPointFile) || source.line() != lastLogPointLine)) {
+			lastLogPointFile = null;
+			lastLogPointLine = -1;
+		}
+
+		if(!shouldStop) {
+			switch(state.getStepMode()) {
+				case NONE:
+					break;
+				case INTO:
+					shouldStop = !sameSourceLine(source, state.getStepReferenceTarget());
+					break;
+				case OVER:
+					shouldStop = userCallDepth <= state.getStepReferenceDepth()
+							&& !sameSourceLine(source, state.getStepReferenceTarget());
+					break;
+				case OUT:
+					shouldStop = userCallDepth < state.getStepReferenceDepth();
+					break;
+				default:
+					break;
+			}
+		}
+
+		// After resuming, suppress pauses while still at the resume source line.
+		// This prevents breakpoints and step conditions from re-firing before
+		// the interpreter has advanced. Once we move to a different source line,
+		// the flag is unconditionally cleared so it doesn't interfere with later
+		// pause checks (e.g. step-over returning from a deeper call).
+		if(state.isSkippingResume()) {
+			if(sameSourceLine(source, state.getResumeTarget())) {
+				return false;
+			}
+			state.clearSkippingResume();
+		}
+
+		return shouldStop;
+	}
+
+	/**
+	 * Evaluates a conditional breakpoint's condition and hit count.
+	 * Returns true if the breakpoint should cause a pause.
+	 */
+	private boolean evaluateBreakpointCondition(Breakpoint bp, Environment env) {
+		// Check hit count first (cheap)
+		if(bp.hitCountThreshold() > 0) {
+			if(bp.incrementHitCount() < bp.hitCountThreshold()) {
+				return false;
+			}
+		}
+		// Evaluate condition expression
+		ParseTree compiled = bp.compiledCondition();
+		if(compiled != null && env != null) {
+			try {
+				Mixed result = MethodScriptCompiler.execute(compiled, env, null, null);
+				while(result instanceof IVariable iv) {
+					result = env.getEnv(GlobalEnv.class).GetVarList()
+							.get(iv.getVariableName(), iv.getTarget(), env).ival();
+				}
+				return ArgumentValidation.getBooleanish(result, Target.UNKNOWN, env);
+			} catch(Exception e) {
+				// If condition evaluation fails, pause anyway so the user sees the error
+				return true;
+			}
+		}
+		return true;
+	}
+
+	/**
+	 * Interpolates a DAP log message template. Expressions in {@code {braces}} are
+	 * evaluated as MethodScript and their string value substituted in.
+	 */
+	private String interpolateLogMessage(String template, Environment env) {
+		StringBuilder sb = new StringBuilder();
+		int i = 0;
+		while(i < template.length()) {
+			char c = template.charAt(i);
+			if(c == '{') {
+				int end = template.indexOf('}', i + 1);
+				if(end == -1) {
+					sb.append(c);
+					i++;
+				} else {
+					String expr = template.substring(i + 1, end);
+					try {
+						Mixed result = MethodScriptCompiler.execute(
+								MethodScriptCompiler.compile(
+										MethodScriptCompiler.lex(expr, null, null, true),
+										null, Environment.getDefaultEnvClasses()),
+								env, null, null);
+						while(result instanceof IVariable iv) {
+							result = env.getEnv(GlobalEnv.class).GetVarList()
+									.get(iv.getVariableName(), iv.getTarget(), env).ival();
+						}
+						sb.append(result.val());
+					} catch(Exception e) {
+						sb.append("{").append(expr).append("}");
+					}
+					i = end + 1;
+				}
+			} else {
+				sb.append(c);
+				i++;
+			}
+		}
+		return sb.toString();
+	}
+
+	/**
+	 * Sets the exception break mode.
+	 *
+	 * @param mode The new exception break mode
+	 */
+	public void setExceptionBreakMode(ExceptionBreakMode mode) {
+		this.exceptionBreakMode = mode;
+	}
+
+	/**
+	 * Returns the current exception break mode.
+	 */
+	public ExceptionBreakMode getExceptionBreakMode() {
+		return exceptionBreakMode;
+	}
+
+	/**
+	 * Determines whether the debugger should break on the given exception, based
+	 * on the current {@link ExceptionBreakMode} and the eval stack state.
+	 *
+	 * <p>For {@link ExceptionBreakMode#ALL}, always returns true. For
+	 * {@link ExceptionBreakMode#UNCAUGHT}, walks the eval stack looking for
+	 * {@code try} frames whose catch type list would match the exception. If no
+	 * matching catch is found, the exception is considered uncaught.</p>
+	 *
+	 * @param exception The exception that was thrown
+	 * @param stack The current eval stack at the point of the throw
+	 * @return true if the debugger should pause
+	 */
+	public boolean shouldBreakOnException(ConfigRuntimeException exception, EvalStack stack) {
+		if(disconnected || exceptionBreakMode == ExceptionBreakMode.NONE) {
+			return false;
+		}
+		if(exceptionBreakMode == ExceptionBreakMode.ALL) {
+			return true;
+		}
+		// UNCAUGHT: walk the stack looking for a frame that would catch this exception
+		for(StackFrame frame : stack) {
+			if(frame.hasFlowFunction() && frame.hasBegun()) {
+				@SuppressWarnings("unchecked")
+				FlowFunction<Object> ff = (FlowFunction<Object>) frame.getFlowFunction();
+				if(ff.wouldCatch(frame.getFunctionState(), exception)) {
+					return false;
+				}
+			}
+		}
+		return true;
+	}
+
+	private static boolean sameSourceLine(Target a, Target b) {
+		if(a == b) {
+			return true;
+		}
+		if(a == null || b == null) {
+			return false;
+		}
+		if(a.line() != b.line()) {
+			return false;
+		}
+		if(a.file() == null || b.file() == null) {
+			return a.file() == b.file();
+		}
+		return a.file().equals(b.file());
+	}
+
+	/**
+	 * Returns the threading mode for this debug context.
+	 */
+	public ThreadingMode getThreadingMode() {
+		return threadingMode;
+	}
+
+	/**
+	 * Returns the main execution thread. This is the thread that uses the
+	 * configured threading mode; all other threads use synchronous mode.
+	 */
+	public Thread getMainThread() {
+		return mainThread;
+	}
+
+	/**
+	 * Updates the main execution thread. This is needed in asynchronous mode
+	 * when resuming from a snapshot creates a new thread that becomes the
+	 * continuation of the main execution.
+	 */
+	public void setMainThread(Thread mainThread) {
+		if(this.mainThread != null && this.mainThread != mainThread) {
+			// Transfer debug state from old main thread to new one so that
+			// step mode settings survive the thread switch in async mode.
+			ThreadDebugState oldState = threadStates.remove(this.mainThread);
+			if(oldState != null) {
+				threadStates.put(mainThread, oldState);
+			}
+			threadDapIds.remove(this.mainThread);
+			threadNames.remove(this.mainThread);
+		}
+		this.mainThread = mainThread;
+		threadDapIds.put(mainThread, MAIN_THREAD_DAP_ID);
+		threadNames.put(mainThread, "main");
+	}
+
+	/**
+	 * Returns true if the calling thread should use synchronous debugging
+	 * (block in place). This is true when:
+	 * <ul>
+	 * <li>The configured threading mode is SYNCHRONOUS, or</li>
+	 * <li>The calling thread is not the main execution thread (e.g. a thread
+	 *     spawned by x_new_thread, which can always safely block)</li>
+	 * </ul>
+	 */
+	public boolean shouldUseSyncMode() {
+		return threadingMode == ThreadingMode.SYNCHRONOUS
+				|| Thread.currentThread() != mainThread;
+	}
+
+	/**
+	 * Blocks the calling thread until {@link #resume(int)} is called from the DAP thread.
+	 * Used by the interpreter loop in synchronous mode to pause in place.
+	 *
+	 * @throws InterruptedException if the waiting thread is interrupted
+	 */
+	public void awaitResume() throws InterruptedException {
+		getThreadState().awaitResume();
+	}
+
+	/**
+	 * Releases the thread with the given DAP thread ID that is blocked in
+	 * {@link #awaitResume()}. Called from the DAP server thread when a
+	 * continue/step command is received.
+	 *
+	 * @param dapThreadId The DAP thread ID to resume
+	 */
+	public void resume(int dapThreadId) {
+		Thread t = getThreadByDapId(dapThreadId);
+		if(t != null) {
+			getThreadState(t).resume();
+		}
+	}
+
+	/**
+	 * Releases the calling thread's latch. Used internally (e.g. during disconnect).
+	 */
+	public void resume() {
+		getThreadState().resume();
+	}
+
+	// ---- Thread registry ----
+
+	/**
+	 * Registers a thread with the debug context, assigning it a DAP thread ID
+	 * and capturing its name. The main thread is registered automatically at
+	 * construction time; this is for background threads.
+	 *
+	 * @param t The thread to register
+	 * @return The assigned DAP thread ID
+	 */
+	public int registerThread(Thread t) {
+		return registerThread(t, null);
+	}
+
+	/**
+	 * Registers a thread with an explicit display name.
+	 *
+	 * @param t The thread to register
+	 * @param displayName The user-visible name, or null to use the Java thread name
+	 * @return The assigned DAP thread ID
+	 */
+	public int registerThread(Thread t, String displayName) {
+		return threadDapIds.computeIfAbsent(t, k -> {
+			threadNames.put(t, displayName != null ? displayName : t.getName());
+			return nextDapThreadId.getAndIncrement();
+		});
+	}
+
+	/**
+	 * Unregisters a thread, removing its DAP ID, name, and debug state.
+	 *
+	 * @param t The thread to unregister
+	 */
+	public void unregisterThread(Thread t) {
+		threadDapIds.remove(t);
+		threadNames.remove(t);
+		ThreadDebugState state = threadStates.remove(t);
+		if(state != null) {
+			state.resume();
+		}
+	}
+
+	/**
+	 * Returns the DAP thread ID for the given thread, or -1 if not registered.
+	 */
+	public int getDapThreadId(Thread t) {
+		Integer id = threadDapIds.get(t);
+		return id != null ? id : -1;
+	}
+
+	/**
+	 * Returns the DAP thread ID for the calling thread, or -1 if not registered.
+	 */
+	public int getCurrentDapThreadId() {
+		return getDapThreadId(Thread.currentThread());
+	}
+
+	/**
+	 * Returns the thread associated with the given DAP thread ID, or null if not found.
+	 */
+	public Thread getThreadByDapId(int dapThreadId) {
+		for(java.util.Map.Entry<Thread, Integer> entry : threadDapIds.entrySet()) {
+			if(entry.getValue() == dapThreadId) {
+				return entry.getKey();
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * Returns a snapshot of all registered threads as a map of DAP thread ID to thread name.
+	 */
+	public java.util.Map<Integer, String> getRegisteredThreads() {
+		java.util.Map<Integer, String> result = new java.util.LinkedHashMap<>();
+		for(java.util.Map.Entry<Thread, Integer> entry : threadDapIds.entrySet()) {
+			String name = threadNames.getOrDefault(entry.getKey(), entry.getKey().getName());
+			result.put(entry.getValue(), name);
+		}
+		return result;
+	}
+
+	/**
+	 * Registers this DebugContext as a {@link com.laytonsmith.PureUtilities.DaemonManager.ThreadLifecycleListener}
+	 * on the given DaemonManager, so that threads activated/deactivated through the
+	 * DaemonManager are automatically registered/unregistered for debugging.
+	 *
+	 * @param dm The DaemonManager to listen to
+	 */
+	public void registerWithDaemonManager(com.laytonsmith.PureUtilities.DaemonManager dm) {
+		dm.addThreadLifecycleListener(new com.laytonsmith.PureUtilities.DaemonManager.ThreadLifecycleListener() {
+			@Override
+			public void onActivated(Thread thread, String displayName) {
+				int dapId = registerThread(thread, displayName);
+				String name = displayName != null ? displayName : thread.getName();
+				if(listener != null) {
+					listener.onThreadStarted(dapId, name);
+				}
+			}
+
+			@Override
+			public void onDeactivated(Thread thread) {
+				int dapId = getDapThreadId(thread);
+				unregisterThread(thread);
+				if(listener != null && dapId >= 0) {
+					listener.onThreadExited(dapId);
+				}
+			}
+		});
+	}
+
+	@Override
+	public Environment.EnvironmentImpl clone() throws CloneNotSupportedException {
+		// Debug context is shared across environment clones - all frames in a single
+		// execution unit share the same debugger state.
+		return this;
+	}
+
+	@Override
+	public String toString() {
+		return "DebugContext{threads=" + threadStates.size()
+				+ ", breakpoints=" + breakpoints.size() + ", disconnected=" + disconnected + "}";
+	}
+}
diff --git a/src/main/java/com/laytonsmith/core/environments/DebugListener.java b/src/main/java/com/laytonsmith/core/environments/DebugListener.java
new file mode 100644
index 000000000..03abb5d9a
--- /dev/null
+++ b/src/main/java/com/laytonsmith/core/environments/DebugListener.java
@@ -0,0 +1,64 @@
+package com.laytonsmith.core.environments;
+
+/**
+ * Callback interface for debugger events. Implementations control what happens when
+ * the interpreter pauses (e.g., blocking on a latch for cmdline mode, or returning
+ * control to the host application in embedded mode).
+ */
+public interface DebugListener {
+
+	/**
+	 * Called when the interpreter has paused at a breakpoint or step condition.
+	 * The paused state provides access to the frozen (async) or live (sync)
+	 * execution state for variable inspection and stack traces.
+	 *
+	 * <p>For cmdline mode, this method typically blocks until the DAP server
+	 * sends a continue/step command. For embedded mode, this method returns
+	 * immediately and the state is stored for later resumption.</p>
+	 *
+	 * @param state The paused execution state
+	 */
+	void onPaused(PausedState state);
+
+	/**
+	 * Called when the interpreter resumes execution after being paused.
+	 */
+	void onResumed();
+
+	/**
+	 * Called when script execution completes (normally or via exception)
+	 * while a debugger is attached.
+	 */
+	void onCompleted();
+
+	/**
+	 * Called when a new MethodScript thread becomes active in the debugger.
+	 * Default implementation does nothing.
+	 *
+	 * @param dapThreadId The DAP thread ID assigned to this thread
+	 * @param name The display name of the thread
+	 */
+	default void onThreadStarted(int dapThreadId, String name) {
+		// no-op by default
+	}
+
+	/**
+	 * Called when a MethodScript thread exits. Default implementation does nothing.
+	 *
+	 * @param dapThreadId The DAP thread ID of the exiting thread
+	 */
+	default void onThreadExited(int dapThreadId) {
+		// no-op by default
+	}
+
+	/**
+	 * Called when a log point breakpoint is hit. The message has already been
+	 * interpolated (expressions in {@code {braces}} evaluated).
+	 * Default implementation does nothing.
+	 *
+	 * @param message The interpolated log message
+	 */
+	default void onLogPoint(String message) {
+		// no-op by default
+	}
+}
diff --git a/src/main/java/com/laytonsmith/core/environments/GlobalEnv.java b/src/main/java/com/laytonsmith/core/environments/GlobalEnv.java
index 484409343..ed06840a7 100644
--- a/src/main/java/com/laytonsmith/core/environments/GlobalEnv.java
+++ b/src/main/java/com/laytonsmith/core/environments/GlobalEnv.java
@@ -399,13 +399,48 @@ public List<Iterator> GetArrayAccessIteratorsFor(ArrayAccess array) {
 	 */
 	public StackTraceManager GetStackTraceManager() {
 		Thread currentThread = Thread.currentThread();
-		if(this.stackTraceManager == null || currentThread != this.stackTraceManagerThread) {
+		if(this.stackTraceManager == null
+				|| currentThread != this.stackTraceManagerThread) {
 			this.stackTraceManager = new StackTraceManager(this);
 			this.stackTraceManagerThread = currentThread;
 		}
 		return this.stackTraceManager;
 	}
 
+	/**
+	 * Re-associates the existing StackTraceManager with the current thread, without
+	 * creating a new one. This is used by the debugger when resuming execution on a
+	 * new thread after a breakpoint pause — the StackTraceManager state must carry
+	 * over from the previous execution thread.
+	 *
+	 * <p>After calling this method, {@link #GetStackTraceManager()} will return the
+	 * existing StackTraceManager when called from the current thread. Other threads
+	 * (e.g. background threads from x_new_thread) will still get their own fresh
+	 * StackTraceManager, which is the correct behavior — they should not share
+	 * the main thread's call depth tracking.</p>
+	 *
+	 * <p>If no StackTraceManager exists yet, this is a no-op (the next call to
+	 * {@link #GetStackTraceManager()} will create one normally).</p>
+	 */
+	public void adoptStackTraceManager() {
+		if(this.stackTraceManager != null) {
+			this.stackTraceManagerThread = Thread.currentThread();
+		}
+	}
+
+	/**
+	 * Returns the existing StackTraceManager without performing the thread-affinity
+	 * check. Unlike {@link #GetStackTraceManager()}, this will never create a new
+	 * StackTraceManager or change the thread association. Returns null if no
+	 * StackTraceManager has been created yet.
+	 *
+	 * <p>This is intended for read-only access from threads other than the execution
+	 * thread, such as the debugger's DAP handler thread reading a frozen snapshot.</p>
+	 */
+	public StackTraceManager peekStackTraceManager() {
+		return this.stackTraceManager;
+	}
+
 	/**
 	 * Returns the runtime setting for a particular value. Runtime settings are a collection of free settings, which
 	 * individual functions can define setting names and values, though in general, to prevent stepping over each other,
diff --git a/src/main/java/com/laytonsmith/core/environments/LivePausedState.java b/src/main/java/com/laytonsmith/core/environments/LivePausedState.java
new file mode 100644
index 000000000..6db0595a7
--- /dev/null
+++ b/src/main/java/com/laytonsmith/core/environments/LivePausedState.java
@@ -0,0 +1,100 @@
+package com.laytonsmith.core.environments;
+
+import com.laytonsmith.core.constructs.IVariable;
+import com.laytonsmith.core.constructs.IVariableList;
+import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.exceptions.ConfigRuntimeException;
+import com.laytonsmith.core.exceptions.StackTraceFrame;
+import com.laytonsmith.core.exceptions.StackTraceManager;
+import com.laytonsmith.core.functions.Exceptions;
+import com.laytonsmith.core.StepAction;
+import com.laytonsmith.core.natives.interfaces.Mixed;
+
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * A {@link PausedState} backed by the live interpreter state. Used in synchronous
+ * debugging mode where the interpreter thread is blocked and its state is read
+ * directly rather than from a snapshot copy.
+ *
+ * <p>This class does NOT own or copy any of the state it references. The interpreter
+ * thread must remain blocked while this object is being read.</p>
+ */
+public class LivePausedState implements PausedState {
+
+	private final Environment env;
+	private final Target pauseTarget;
+	private final StepAction.FlowControl pendingFlowControl;
+
+	public LivePausedState(Environment env, Target pauseTarget,
+			StepAction.FlowControl pendingFlowControl) {
+		this.env = env;
+		this.pauseTarget = pauseTarget;
+		this.pendingFlowControl = pendingFlowControl;
+	}
+
+	@Override
+	public Target getPauseTarget() {
+		return pauseTarget;
+	}
+
+	@Override
+	public Environment getEnvironment() {
+		return env;
+	}
+
+	@Override
+	public List<StackTraceFrame> getCallStack() {
+		StackTraceManager stm = env.getEnv(GlobalEnv.class).peekStackTraceManager();
+		if(stm == null) {
+			return Collections.emptyList();
+		}
+		return stm.getCurrentStackTrace();
+	}
+
+	@Override
+	public int getUserCallDepth() {
+		StackTraceManager stm = env.getEnv(GlobalEnv.class).peekStackTraceManager();
+		if(stm == null) {
+			return 0;
+		}
+		return stm.getDepth();
+	}
+
+	@Override
+	public Map<String, Mixed> getVariables() {
+		IVariableList varList = env.getEnv(GlobalEnv.class).GetVarList();
+		Map<String, Mixed> result = new LinkedHashMap<>();
+		for(String name : varList.keySet()) {
+			IVariable iv = varList.get(name);
+			if(iv != null) {
+				result.put(name, iv.ival());
+			}
+		}
+		return result;
+	}
+
+	@Override
+	public boolean isExceptionPause() {
+		return pendingFlowControl != null
+				&& pendingFlowControl.getAction() instanceof Exceptions.ThrowAction;
+	}
+
+	@Override
+	public ConfigRuntimeException getPauseException() {
+		if(pendingFlowControl != null
+				&& pendingFlowControl.getAction() instanceof Exceptions.ThrowAction ta) {
+			return ta.getException();
+		}
+		return null;
+	}
+
+	@Override
+	public String toString() {
+		return "LivePausedState{target=" + pauseTarget + ", depth=" + getUserCallDepth()
+				+ ", vars=" + getVariables().size() + "}";
+	}
+}
diff --git a/src/main/java/com/laytonsmith/core/environments/PausedState.java b/src/main/java/com/laytonsmith/core/environments/PausedState.java
new file mode 100644
index 000000000..526838a4b
--- /dev/null
+++ b/src/main/java/com/laytonsmith/core/environments/PausedState.java
@@ -0,0 +1,59 @@
+package com.laytonsmith.core.environments;
+
+import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.exceptions.ConfigRuntimeException;
+import com.laytonsmith.core.exceptions.StackTraceFrame;
+import com.laytonsmith.core.natives.interfaces.Mixed;
+
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Provides read-only access to the interpreter's state when paused at a breakpoint or
+ * step condition. Two implementations exist:
+ * <ul>
+ *   <li><b>Async mode</b>: Backed by a frozen {@link com.laytonsmith.core.Script.DebugSnapshot
+ *       DebugSnapshot} — the interpreter has returned and the state is a copy.</li>
+ *   <li><b>Sync mode</b>: Backed by the live interpreter state — the interpreter thread
+ *       is blocked, and reads go directly to the live stack and environment.</li>
+ * </ul>
+ */
+public interface PausedState {
+
+	/**
+	 * Returns the source location where execution paused.
+	 */
+	Target getPauseTarget();
+
+	/**
+	 * Returns the environment at the point of the pause.
+	 */
+	Environment getEnvironment();
+
+	/**
+	 * Returns the user-visible call stack (proc/closure/include frames) at the point
+	 * of the pause. Ordered from innermost (most recent) to outermost.
+	 */
+	List<StackTraceFrame> getCallStack();
+
+	/**
+	 * Returns the user-visible call depth at the point of the pause. This is the
+	 * count of proc/closure/include frames, not the raw eval stack size.
+	 */
+	int getUserCallDepth();
+
+	/**
+	 * Returns the variables visible at the point of the pause as a name-to-value map.
+	 */
+	Map<String, Mixed> getVariables();
+
+	/**
+	 * Returns true if this pause was caused by an exception breakpoint.
+	 */
+	boolean isExceptionPause();
+
+	/**
+	 * If this is an exception pause, returns the exception. Otherwise returns null.
+	 */
+	ConfigRuntimeException getPauseException();
+}
diff --git a/src/main/java/com/laytonsmith/core/environments/ThreadDebugState.java b/src/main/java/com/laytonsmith/core/environments/ThreadDebugState.java
new file mode 100644
index 000000000..7b6c77773
--- /dev/null
+++ b/src/main/java/com/laytonsmith/core/environments/ThreadDebugState.java
@@ -0,0 +1,81 @@
+package com.laytonsmith.core.environments;
+
+import com.laytonsmith.core.constructs.Target;
+
+import java.util.concurrent.CountDownLatch;
+
+/**
+ * Per-thread debug state, extracted from DebugContext so that multiple threads can be
+ * independently paused, stepped, and resumed. Each MethodScript thread gets its own
+ * instance, stored in DebugContext's thread registry.
+ */
+public class ThreadDebugState {
+
+	private volatile DebugContext.StepMode stepMode = DebugContext.StepMode.NONE;
+	private volatile int stepReferenceDepth = 0;
+	private volatile Target stepReferenceTarget = Target.UNKNOWN;
+	private volatile Target resumeTarget = Target.UNKNOWN;
+	private volatile boolean paused = false;
+	private volatile boolean skippingResume = false;
+	private volatile CountDownLatch pauseLatch;
+
+	public DebugContext.StepMode getStepMode() {
+		return stepMode;
+	}
+
+	public void setStepMode(DebugContext.StepMode mode, int currentDepth, Target currentTarget) {
+		this.stepMode = mode;
+		this.stepReferenceDepth = currentDepth;
+		this.stepReferenceTarget = currentTarget;
+	}
+
+	public int getStepReferenceDepth() {
+		return stepReferenceDepth;
+	}
+
+	public Target getStepReferenceTarget() {
+		return stepReferenceTarget;
+	}
+
+	public boolean isPaused() {
+		return paused;
+	}
+
+	public void setPaused(boolean paused, Target pauseTarget) {
+		this.paused = paused;
+		if(paused && pauseTarget != null) {
+			this.resumeTarget = pauseTarget;
+			this.skippingResume = true;
+		}
+	}
+
+	public Target getResumeTarget() {
+		return resumeTarget;
+	}
+
+	public boolean isSkippingResume() {
+		return skippingResume;
+	}
+
+	public void clearSkippingResume() {
+		this.skippingResume = false;
+	}
+
+	/**
+	 * Blocks the calling thread until {@link #resume()} is called.
+	 */
+	public void awaitResume() throws InterruptedException {
+		pauseLatch = new CountDownLatch(1);
+		pauseLatch.await();
+	}
+
+	/**
+	 * Releases the thread blocked in {@link #awaitResume()}.
+	 */
+	public void resume() {
+		CountDownLatch latch = pauseLatch;
+		if(latch != null) {
+			latch.countDown();
+		}
+	}
+}
diff --git a/src/main/java/com/laytonsmith/core/exceptions/CRE/AbstractCREException.java b/src/main/java/com/laytonsmith/core/exceptions/CRE/AbstractCREException.java
index 1a6693491..03cf1c4ab 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/CRE/AbstractCREException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/CRE/AbstractCREException.java
@@ -18,6 +18,7 @@
 import com.laytonsmith.core.constructs.generics.LeftHandGenericUse;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.exceptions.ConfigRuntimeException;
+import com.laytonsmith.core.exceptions.StackTraceFrame;
 import com.laytonsmith.core.exceptions.StackTraceManager;
 import com.laytonsmith.core.natives.interfaces.ArrayAccess;
 import com.laytonsmith.core.natives.interfaces.Mixed;
@@ -37,7 +38,7 @@ public abstract class AbstractCREException extends ConfigRuntimeException implem
 
 	private static final Class[] EMPTY_CLASS = new Class[0];
 
-	private List<StackTraceElement> stackTrace = null;
+	private List<StackTraceFrame> stackTrace = null;
 
 	public AbstractCREException(String msg, Target t) {
 		super(msg, t);
@@ -120,7 +121,7 @@ public CArray getExceptionObject() {
 		ret.set("message", this.getMessage());
 		CArray stackTrace = new CArray(Target.UNKNOWN);
 		ret.set("stackTrace", stackTrace, Target.UNKNOWN);
-		for(StackTraceElement e : this.getCREStackTrace()) {
+		for(StackTraceFrame e : this.getCREStackTrace()) {
 			CArray element = e.getObjectFor();
 			stackTrace.push(element, Target.UNKNOWN);
 		}
@@ -140,13 +141,13 @@ public static AbstractCREException getFromCArray(CArray exception, Target t, Env
 			cause = new CRECausedByWrapper((CArray) exception.get("causedBy", t));
 		}
 		String message = exception.get("message", t).val();
-		List<StackTraceElement> st = new ArrayList<>();
+		List<StackTraceFrame> st = new ArrayList<>();
 		for(Mixed consStElement : ArgumentValidation.getArray(exception.get("stackTrace", t), t).asList()) {
 			CArray stElement = ArgumentValidation.getArray(consStElement, t);
 			int line = ArgumentValidation.getInt32(stElement.get("line", t), t);
 			File f = new File(stElement.get("file", t).val());
 			int col = ArgumentValidation.getInt32(stElement.get("col", t), t);
-			st.add(new StackTraceElement(stElement.get("id", t).val(), new Target(line, f, col)));
+			st.add(new StackTraceFrame(stElement.get("id", t).val(), new Target(line, f, col)));
 		}
 		// Now we have parsed everything into POJOs
 		Class[] types = new Class[]{String.class, Target.class, Throwable.class};
@@ -297,14 +298,14 @@ public void freezeStackTraceElements(StackTraceManager manager) {
 	 * If the stacktrace was already set, this is an Error, because this should never happen in the usual case.
 	 * @param st
 	 */
-	public void setStackTraceElements(List<StackTraceElement> st) {
+	public void setStackTraceElements(List<StackTraceFrame> st) {
 		if(this.stackTrace != null) {
 			throw new RuntimeException("The stacktrace was already set, and it cannot be set again");
 		}
 		this.stackTrace = st;
 	}
 
-	public List<StackTraceElement> getCREStackTrace() {
+	public List<StackTraceFrame> getCREStackTrace() {
 		if(this.stackTrace == null) {
 			return new ArrayList<>();
 		}
diff --git a/src/main/java/com/laytonsmith/core/exceptions/ConfigRuntimeException.java b/src/main/java/com/laytonsmith/core/exceptions/ConfigRuntimeException.java
index 02e315dd0..02782c235 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/ConfigRuntimeException.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/ConfigRuntimeException.java
@@ -14,7 +14,6 @@
 import com.laytonsmith.core.Static;
 import com.laytonsmith.core.constructs.CArray;
 import com.laytonsmith.core.constructs.CClosure;
-import com.laytonsmith.core.constructs.CInt;
 import com.laytonsmith.core.constructs.CNull;
 import com.laytonsmith.core.constructs.CVoid;
 import com.laytonsmith.core.constructs.Target;
@@ -25,7 +24,6 @@
 import com.laytonsmith.core.exceptions.CRE.CRECausedByWrapper;
 import com.laytonsmith.core.natives.interfaces.Mixed;
 import java.io.File;
-import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -191,14 +189,14 @@ private static void HandleUncaughtException(ConfigRuntimeException e, Environmen
 		}
 	}
 
-	private static void PrintMessage(StringBuilder log, StringBuilder console, StringBuilder player, String type, String message, Throwable ex, List<StackTraceElement> st, Target top) {
+	private static void PrintMessage(StringBuilder log, StringBuilder console, StringBuilder player, String type, String message, Throwable ex, List<StackTraceFrame> st, Target top) {
 		log.append(type).append(message).append("\n");
 		console.append(TermColors.RED).append(type).append(TermColors.WHITE).append(message).append("\n");
 		player.append(MCChatColor.RED).append(type).append(MCChatColor.WHITE).append(message).append("\n");
 		if(st.isEmpty()) {
-			st.add(new StackTraceElement("<<main code>>", top));
+			st.add(new StackTraceFrame("<<main code>>", top));
 		}
-		for(StackTraceElement e : st) {
+		for(StackTraceFrame e : st) {
 			Target t = e.getDefinedAt();
 			String proc = e.getProcedureName();
 			File file = t.file();
@@ -239,12 +237,12 @@ private static void PrintMessage(StringBuilder log, StringBuilder console, Strin
 	 * @param optionalMessage
 	 */
 	@SuppressWarnings("ThrowableResultIgnored")
-	private static void DoReport(String message, String exceptionType, ConfigRuntimeException ex, List<StackTraceElement> stacktrace, MCPlayer currentPlayer) {
+	private static void DoReport(String message, String exceptionType, ConfigRuntimeException ex, List<StackTraceFrame> stacktrace, MCPlayer currentPlayer) {
 		String type = exceptionType;
 		if(exceptionType == null) {
 			type = "FATAL";
 		}
-		List<StackTraceElement> st = new ArrayList<>(stacktrace);
+		List<StackTraceFrame> st = new ArrayList<>(stacktrace);
 		if(message == null) {
 			message = "";
 		}
@@ -256,7 +254,7 @@ private static void DoReport(String message, String exceptionType, ConfigRuntime
 		if(ex != null) {
 			top = ex.getTarget();
 		}
-		for(StackTraceElement e : st) {
+		for(StackTraceFrame e : st) {
 			Target t = e.getDefinedAt();
 			if(top == Target.UNKNOWN) {
 				top = t;
@@ -279,14 +277,14 @@ private static void DoReport(String message, String exceptionType, ConfigRuntime
 				player.append(MCChatColor.AQUA).append("Caused by:\n");
 				CArray exception = ((CRECausedByWrapper) ex).getException();
 				CArray stackTrace = ArgumentValidation.getArray(exception.get("stackTrace", t), t);
-				List<StackTraceElement> newSt = new ArrayList<>();
+				List<StackTraceFrame> newSt = new ArrayList<>();
 				for(Mixed consElement : stackTrace.asList()) {
 					CArray element = ArgumentValidation.getArray(consElement, t);
 					int line = ArgumentValidation.getInt32(element.get("line", t), t);
 					File file = new File(element.get("file", t).val());
 					int col = ArgumentValidation.getInt32(element.get("col", t), t);
 					Target stElementTarget = new Target(line, file, col);
-					newSt.add(new StackTraceElement(element.get("id", t).val(), stElementTarget));
+					newSt.add(new StackTraceFrame(element.get("id", t).val(), stElementTarget));
 				}
 
 				String nType = exception.get("classType", t).val();
@@ -316,7 +314,7 @@ private static void DoReport(ConfigRuntimeException e, Environment env) {
 				&& e.getEnv().getEnv(CommandHelperEnvironment.class).GetPlayer() != null) {
 			p = e.getEnv().getEnv(CommandHelperEnvironment.class).GetPlayer();
 		}
-		List<StackTraceElement> st = new ArrayList<>();
+		List<StackTraceFrame> st = new ArrayList<>();
 		if(e instanceof AbstractCREException) {
 			st = ((AbstractCREException) e).getCREStackTrace();
 		}
@@ -339,8 +337,8 @@ private static void DoReport(ConfigRuntimeException e, Environment env) {
 	}
 
 	private static void DoReport(ConfigCompileException e, MCPlayer player) {
-		List<StackTraceElement> st = new ArrayList<StackTraceElement>();
-		st.add(0, new StackTraceElement("", e.getTarget()));
+		List<StackTraceFrame> st = new ArrayList<StackTraceFrame>();
+		st.add(0, new StackTraceFrame("", e.getTarget()));
 		DoReport(e.getMessage(), "COMPILE ERROR", null, st, player);
 	}
 
@@ -465,81 +463,4 @@ public String getSimpleFile() {
 			return null;
 		}
 	}
-
-	/**
-	 * A stacktrace contains 1 or more stack trace elements. A new stacktrace element is added each time an exception
-	 * bubbles up past a procedure.
-	 */
-	public static class StackTraceElement {
-
-		private final String procedureName;
-		private Target definedAt;
-
-		/**
-		 * Creates a new StackTraceElement.
-		 *
-		 * @param procedureName The name of the procedure
-		 * @param definedAt The code target where the procedure is defined at.
-		 */
-		public StackTraceElement(String procedureName, Target definedAt) {
-			this.procedureName = procedureName;
-			this.definedAt = definedAt;
-		}
-
-		/**
-		 * Gets the name of the procedure.
-		 *
-		 * @return
-		 */
-		public String getProcedureName() {
-			return procedureName;
-		}
-
-		/**
-		 * Gets the code target where the procedure is defined at.
-		 *
-		 * @return
-		 */
-		public Target getDefinedAt() {
-			return definedAt;
-		}
-
-		@Override
-		public String toString() {
-			return procedureName + " (Defined at " + definedAt + ")";
-		}
-
-		public CArray getObjectFor() {
-			CArray element = CArray.GetAssociativeArray(Target.UNKNOWN);
-			element.set("id", getProcedureName());
-			try {
-				String name = "Unknown file";
-				if(getDefinedAt().file() != null) {
-					name = getDefinedAt().file().getCanonicalPath();
-				}
-				element.set("file", name);
-			} catch (IOException ex) {
-				// This shouldn't happen, but if it does, we want to fall back to something marginally useful
-				String name = "Unknown file";
-				if(getDefinedAt().file() != null) {
-					name = getDefinedAt().file().getAbsolutePath();
-				}
-				element.set("file", name);
-			}
-			element.set("line", new CInt(getDefinedAt().line(), Target.UNKNOWN), Target.UNKNOWN);
-			element.set("col", new CInt(getDefinedAt().col(), Target.UNKNOWN), Target.UNKNOWN);
-			return element;
-		}
-
-		/**
-		 * In general, only the core elements should change this
-		 *
-		 * @param target
-		 */
-		void setDefinedAt(Target target) {
-			definedAt = target;
-		}
-
-	}
-
 }
diff --git a/src/main/java/com/laytonsmith/core/exceptions/StackTraceFrame.java b/src/main/java/com/laytonsmith/core/exceptions/StackTraceFrame.java
new file mode 100644
index 000000000..e33a16189
--- /dev/null
+++ b/src/main/java/com/laytonsmith/core/exceptions/StackTraceFrame.java
@@ -0,0 +1,113 @@
+package com.laytonsmith.core.exceptions;
+
+import com.laytonsmith.core.constructs.CArray;
+import com.laytonsmith.core.constructs.CInt;
+import com.laytonsmith.core.constructs.Target;
+
+import java.io.IOException;
+
+/**
+ * A single frame in a MethodScript stack trace. Each frame corresponds to a user-visible
+ * call boundary, such as a procedure call, closure call, or include. Internal function calls
+ * (if, for, array_push, etc.) do not produce stack trace frames.
+ */
+public class StackTraceFrame {
+
+	private final String procedureName;
+	private Target definedAt;
+	private final Target callSite;
+
+	/**
+	 * Creates a new StackTraceFrame.
+	 *
+	 * @param procedureName The name of the procedure
+	 * @param definedAt The code target where the procedure is defined at.
+	 */
+	public StackTraceFrame(String procedureName, Target definedAt) {
+		this(procedureName, definedAt, Target.UNKNOWN);
+	}
+
+	/**
+	 * Creates a new StackTraceFrame with a call site.
+	 *
+	 * @param procedureName The name of the procedure
+	 * @param definedAt The code target where the procedure is defined at.
+	 * @param callSite The code target of the call expression in the caller's code.
+	 */
+	public StackTraceFrame(String procedureName, Target definedAt, Target callSite) {
+		this.procedureName = procedureName;
+		this.definedAt = definedAt;
+		this.callSite = callSite;
+	}
+
+	/**
+	 * Gets the name of the procedure.
+	 *
+	 * @return
+	 */
+	public String getProcedureName() {
+		return procedureName;
+	}
+
+	/**
+	 * Gets the code target where the procedure is defined at.
+	 *
+	 * @return
+	 */
+	public Target getDefinedAt() {
+		return definedAt;
+	}
+
+	/**
+	 * Gets the code target of the call expression in the caller's code. For example,
+	 * if {@code <main>} calls {@code _foo()}, the call site is where {@code _foo()}
+	 * appears in {@code <main>}. Returns {@link Target#UNKNOWN} if not available.
+	 *
+	 * @return The call site target
+	 */
+	public Target getCallSite() {
+		return callSite;
+	}
+
+	@Override
+	public String toString() {
+		return procedureName + " (Defined at " + definedAt + ")";
+	}
+
+	/**
+	 * Returns a CArray representation of this stack trace frame,
+	 * suitable for use in MethodScript code.
+	 *
+	 * @return
+	 */
+	public CArray getObjectFor() {
+		CArray element = CArray.GetAssociativeArray(Target.UNKNOWN);
+		element.set("id", getProcedureName());
+		try {
+			String name = "Unknown file";
+			if(getDefinedAt().file() != null) {
+				name = getDefinedAt().file().getCanonicalPath();
+			}
+			element.set("file", name);
+		} catch(IOException ex) {
+			// This shouldn't happen, but if it does, we want to fall back to something marginally useful
+			String name = "Unknown file";
+			if(getDefinedAt().file() != null) {
+				name = getDefinedAt().file().getAbsolutePath();
+			}
+			element.set("file", name);
+		}
+		element.set("line", new CInt(getDefinedAt().line(), Target.UNKNOWN), Target.UNKNOWN);
+		element.set("col", new CInt(getDefinedAt().col(), Target.UNKNOWN), Target.UNKNOWN);
+		return element;
+	}
+
+	/**
+	 * In general, only the core elements should change this.
+	 *
+	 * @param target
+	 */
+	void setDefinedAt(Target target) {
+		definedAt = target;
+	}
+}
diff --git a/src/main/java/com/laytonsmith/core/exceptions/StackTraceManager.java b/src/main/java/com/laytonsmith/core/exceptions/StackTraceManager.java
index 74258ae09..709ac127c 100644
--- a/src/main/java/com/laytonsmith/core/exceptions/StackTraceManager.java
+++ b/src/main/java/com/laytonsmith/core/exceptions/StackTraceManager.java
@@ -30,7 +30,7 @@ public class StackTraceManager {
 	private static final CInt DEFAULT_MAX_DEPTH_MIXED
 			= new CInt(DEFAULT_MAX_CALL_DEPTH, Target.UNKNOWN);
 
-	private final Stack<ConfigRuntimeException.StackTraceElement> elements = new Stack<>();
+	private final Stack<StackTraceFrame> elements = new Stack<>();
 	private final GlobalEnv gEnv;
 
 	/**
@@ -48,7 +48,7 @@ public StackTraceManager(GlobalEnv gEnv) {
 	 *
 	 * @param element The element to be pushed on
 	 */
-	public void addStackTraceElement(ConfigRuntimeException.StackTraceElement element) {
+	public void addStackTraceFrame(StackTraceFrame element) {
 		elements.add(element);
 		Mixed setting = gEnv.GetRuntimeSetting(MAX_CALL_DEPTH_SETTING, DEFAULT_MAX_DEPTH_MIXED);
 		int maxDepth = ArgumentValidation.getInt32(setting, element.getDefinedAt(), null);
@@ -60,7 +60,7 @@ public void addStackTraceElement(ConfigRuntimeException.StackTraceElement elemen
 	/**
 	 * Pops the top stack trace trail element off.
 	 */
-	public void popStackTraceElement() {
+	public void popStackTraceFrame() {
 		elements.pop();
 	}
 
@@ -69,8 +69,8 @@ public void popStackTraceElement() {
 	 *
 	 * @return
 	 */
-	public List<ConfigRuntimeException.StackTraceElement> getCurrentStackTrace() {
-		List<ConfigRuntimeException.StackTraceElement> l = new ArrayList<>(elements);
+	public List<StackTraceFrame> getCurrentStackTrace() {
+		List<StackTraceFrame> l = new ArrayList<>(elements);
 		Collections.reverse(l);
 		return l;
 	}
@@ -113,4 +113,5 @@ public void setCurrentTarget(Target target) {
 		}
 	}
 
+
 }
diff --git a/src/main/java/com/laytonsmith/core/functions/DataHandling.java b/src/main/java/com/laytonsmith/core/functions/DataHandling.java
index 6522a8f12..66925f911 100644
--- a/src/main/java/com/laytonsmith/core/functions/DataHandling.java
+++ b/src/main/java/com/laytonsmith/core/functions/DataHandling.java
@@ -97,6 +97,7 @@
 import com.laytonsmith.core.exceptions.ConfigCompileException;
 import com.laytonsmith.core.exceptions.ConfigCompileGroupException;
 import com.laytonsmith.core.exceptions.ConfigRuntimeException;
+import com.laytonsmith.core.exceptions.StackTraceFrame;
 import com.laytonsmith.core.exceptions.StackTraceManager;
 import com.laytonsmith.core.functions.ArrayHandling.array_get;
 import com.laytonsmith.core.functions.ArrayHandling.array_push;
@@ -2347,9 +2348,8 @@ public StepResult<IncludeState> childCompleted(Target t, IncludeState state,
 					if(include != null) {
 						StackTraceManager stManager
 								= env.getEnv(GlobalEnv.class).GetStackTraceManager();
-						stManager.addStackTraceElement(
-								new ConfigRuntimeException.StackTraceElement(
-								"<<include " + result.val() + ">>", t));
+						stManager.addStackTraceFrame(
+								new StackTraceFrame("<<include " + result.val() + ">>", t));
 						state.phase = IncludeState.Phase.EVAL_INCLUDE;
 						return new StepResult<>(new Evaluate(include.getChildAt(0)), state);
 					}
@@ -2382,7 +2382,7 @@ public StepResult<IncludeState> childInterrupted(Target t, IncludeState state,
 		public void cleanup(Target t, IncludeState state, Environment env) {
 			if(state != null
 					&& state.phase == IncludeState.Phase.EVAL_INCLUDE) {
-				env.getEnv(GlobalEnv.class).GetStackTraceManager().popStackTraceElement();
+				env.getEnv(GlobalEnv.class).GetStackTraceManager().popStackTraceFrame();
 			}
 		}
 
diff --git a/src/main/java/com/laytonsmith/core/functions/Exceptions.java b/src/main/java/com/laytonsmith/core/functions/Exceptions.java
index a6e263260..f5eaac14c 100644
--- a/src/main/java/com/laytonsmith/core/functions/Exceptions.java
+++ b/src/main/java/com/laytonsmith/core/functions/Exceptions.java
@@ -198,14 +198,13 @@ public StepResult<TryState> childInterrupted(Target t, TryState state,
 				if(!(e instanceof AbstractCREException)) {
 					return null;
 				}
-				FullyQualifiedClassName name
-						= ((AbstractCREException) e).getExceptionType().getFQCN();
+				CClassType exType = ((AbstractCREException) e).getExceptionType();
 				if(Prefs.DebugMode()) {
 					StreamUtils.GetSystemOut().println("[" + Implementation.GetServerType().getBranding() + "]:"
-							+ " Exception thrown (debug mode on) -> " + e.getMessage() + " :: " + name + ":"
+							+ " Exception thrown (debug mode on) -> " + e.getMessage() + " :: " + exType.getFQCN() + ":"
 							+ e.getTarget().file() + ":" + e.getTarget().line());
 				}
-				if(state.interest.isEmpty() || state.interest.contains(name)) {
+				if(matchesInterest(exType, state.interest)) {
 					if(state.catchIndex >= 0) {
 						CArray ex = ObjectGenerator.GetGenerator().exception(e, env, t);
 						if(state.ivar != null) {
@@ -223,6 +222,38 @@ public StepResult<TryState> childInterrupted(Target t, TryState state,
 			return null;
 		}
 
+		@Override
+		public boolean wouldCatch(TryState state, ConfigRuntimeException exception) {
+			if(state.phase != Phase.TRY_BODY) {
+				return false;
+			}
+			if(!(exception instanceof AbstractCREException ace)) {
+				return false;
+			}
+			return matchesInterest(ace.getExceptionType(), state.interest);
+		}
+
+		/**
+		 * Returns true if the given exception type matches the interest list,
+		 * using {@code doesExtend} for proper subtype checking. An empty interest
+		 * list matches all exception types.
+		 */
+		private static boolean matchesInterest(CClassType exType, List<FullyQualifiedClassName> interest) {
+			if(interest.isEmpty()) {
+				return true;
+			}
+			for(FullyQualifiedClassName interestFqcn : interest) {
+				try {
+					if(exType.doesExtend(CClassType.get(interestFqcn))) {
+						return true;
+					}
+				} catch(ClassNotFoundException e) {
+					// Unknown type can't match
+				}
+			}
+			return false;
+		}
+
 		@Override
 		public String getName() {
 			return NAME;
@@ -671,6 +702,25 @@ public StepResult<ComplexTryState> childInterrupted(Target t, ComplexTryState st
 			}
 		}
 
+		@Override
+		public boolean wouldCatch(ComplexTryState state, ConfigRuntimeException exception) {
+			if(state.phase != Phase.TRY_BODY) {
+				return false;
+			}
+			if(!(exception instanceof AbstractCREException ace)) {
+				return false;
+			}
+			CClassType exceptionType = ace.getExceptionType();
+			for(int i = 1; i < state.children.length - 1; i += 2) {
+				ParseTree assign = state.children[i];
+				CClassType clauseType = ((CClassType) assign.getChildAt(0).getData());
+				if(exceptionType.doesExtend(clauseType)) {
+					return true;
+				}
+			}
+			return false;
+		}
+
 		@Override
 		public String getName() {
 			return NAME;
@@ -768,8 +818,8 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 						&& (cf.getFunction().getName().equals(DataHandling.assign.NAME)
 								|| cf.getFunction().getName().equals(Compiler.__unsafe_assign__.NAME)))
 						|| assign.numberOfChildren() != 3) {
-					throw new ConfigCompileException("Expecting a variable declaration, but instead "
-						+ assign.getData().val() + " was found", t);
+					throw new ConfigCompileException("catch clause requires a type and a variable,"
+						+ " e.g. catch(Exception @e)", assign.getData().getTarget());
 				}
 
 				// Validate that the first argument of the assign is a valid type.
@@ -863,9 +913,9 @@ public Boolean runAsync() {
 		@Override
 		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args) throws ConfigRuntimeException {
 			StackTraceManager stManager = env.getEnv(GlobalEnv.class).GetStackTraceManager();
-			List<ConfigRuntimeException.StackTraceElement> elements = stManager.getCurrentStackTrace();
+			List<com.laytonsmith.core.exceptions.StackTraceFrame> elements = stManager.getCurrentStackTrace();
 			CArray ret = new CArray(t);
-			for(ConfigRuntimeException.StackTraceElement e : elements) {
+			for(com.laytonsmith.core.exceptions.StackTraceFrame e : elements) {
 				ret.push(e.getObjectFor(), Target.UNKNOWN);
 			}
 			return ret;
diff --git a/src/main/java/com/laytonsmith/core/functions/Meta.java b/src/main/java/com/laytonsmith/core/functions/Meta.java
index e9ee6399b..e5f27e132 100644
--- a/src/main/java/com/laytonsmith/core/functions/Meta.java
+++ b/src/main/java/com/laytonsmith/core/functions/Meta.java
@@ -48,6 +48,7 @@
 import com.laytonsmith.core.constructs.Variable;
 import com.laytonsmith.core.constructs.generics.GenericParameters;
 import com.laytonsmith.core.environments.CommandHelperEnvironment;
+import com.laytonsmith.core.environments.DebugContext;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.environments.GlobalEnv;
 import com.laytonsmith.core.exceptions.CRE.CRECastException;
@@ -1901,4 +1902,54 @@ public Version since() {
 		}
 
 	}
+
+	@api
+	public static class debugger_attached extends AbstractFunction {
+
+		public static final String NAME = "debugger_attached";
+
+		@Override
+		public String getName() {
+			return NAME;
+		}
+
+		@Override
+		public Integer[] numArgs() {
+			return new Integer[]{0};
+		}
+
+		@Override
+		public Class<? extends CREThrowable>[] thrown() {
+			return null;
+		}
+
+		@Override
+		public boolean isRestricted() {
+			return false;
+		}
+
+		@Override
+		public Boolean runAsync() {
+			return null;
+		}
+
+		@Override
+		public Mixed exec(Target t, Environment env, GenericParameters generics, Mixed... args)
+				throws ConfigRuntimeException {
+			return CBoolean.get(env.hasEnv(DebugContext.class)
+					&& !env.getEnv(DebugContext.class).isDisconnected());
+		}
+
+		@Override
+		public String docs() {
+			return "boolean {} Returns true if a debugger is currently attached to this execution environment."
+					+ " This can be used to conditionally enable debug logging or other diagnostic behavior.";
+		}
+
+		@Override
+		public Version since() {
+			return MSVersion.V3_3_5;
+		}
+
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/functions/StringHandling.java b/src/main/java/com/laytonsmith/core/functions/StringHandling.java
index 0a56ab308..0c134f6ad 100644
--- a/src/main/java/com/laytonsmith/core/functions/StringHandling.java
+++ b/src/main/java/com/laytonsmith/core/functions/StringHandling.java
@@ -257,7 +257,7 @@ public ParseTree optimizeDynamic(Target t, Environment env,
 					// sconcat only returns a string (except in the special case above) so we need to
 					// return the string value if it's not already a string
 					try {
-						if(InstanceofUtil.isInstanceof(child.getData(), CString.TYPE, env)) {
+						if(child.isConst() && InstanceofUtil.isInstanceof(child.getData(), CString.TYPE, env)) {
 							return child;
 						}
 					} catch (IllegalArgumentException ex) {
diff --git a/src/main/java/com/laytonsmith/core/functions/Threading.java b/src/main/java/com/laytonsmith/core/functions/Threading.java
index af91b46c6..3653e9c66 100644
--- a/src/main/java/com/laytonsmith/core/functions/Threading.java
+++ b/src/main/java/com/laytonsmith/core/functions/Threading.java
@@ -90,11 +90,10 @@ public Mixed exec(final Target t, final Environment env, GenericParameters gener
 			final String threadId = args[0].val();
 			final com.laytonsmith.core.natives.interfaces.Callable closure
 					= ArgumentValidation.getObject(args[1], t, com.laytonsmith.core.natives.interfaces.Callable.class);
+			DaemonManager dm = env.getEnv(StaticRuntimeEnv.class).GetDaemonManager();
 			Thread th = new Thread("(" + Implementation.GetServerType().getBranding() + ") " + threadId) {
 				@Override
 				public void run() {
-					DaemonManager dm = env.getEnv(StaticRuntimeEnv.class).GetDaemonManager();
-					dm.activateThread(Thread.currentThread());
 					try {
 						closure.executeCallable(env, t);
 					} catch (ConfigRuntimeException ex) {
@@ -113,6 +112,7 @@ public void run() {
 					}
 				}
 			};
+			dm.activateThread(th, threadId);
 			th.start();
 			synchronized(THREAD_ID_MAP) {
 				THREAD_ID_MAP.put(threadId, th);
diff --git a/src/main/java/com/laytonsmith/core/functions/Web.java b/src/main/java/com/laytonsmith/core/functions/Web.java
index 8d84f4c75..21286b9a0 100644
--- a/src/main/java/com/laytonsmith/core/functions/Web.java
+++ b/src/main/java/com/laytonsmith/core/functions/Web.java
@@ -48,6 +48,7 @@
 import com.laytonsmith.core.exceptions.CancelCommandException;
 import com.laytonsmith.core.exceptions.ConfigCompileException;
 import com.laytonsmith.core.exceptions.ConfigRuntimeException;
+import com.laytonsmith.core.exceptions.StackTraceFrame;
 import com.laytonsmith.core.natives.interfaces.ArrayAccess;
 import com.laytonsmith.core.natives.interfaces.Mixed;
 import com.laytonsmith.tools.docgen.DocGenTemplates;
@@ -447,7 +448,7 @@ public Mixed exec(final Target t, final Environment env, GenericParameters gener
 				settings.setAuthenticationDetails(username, password);
 			}
 
-			List<ConfigRuntimeException.StackTraceElement> st
+			List<StackTraceFrame> st
 					= env.getEnv(GlobalEnv.class).GetStackTraceManager().getCurrentStackTrace();
 			env.getEnv(StaticRuntimeEnv.class).GetDaemonManager().activateThread(null);
 			Runnable task = new Runnable() {
diff --git a/src/main/java/com/laytonsmith/core/natives/interfaces/Callable.java b/src/main/java/com/laytonsmith/core/natives/interfaces/Callable.java
index de8872b96..96c704e19 100644
--- a/src/main/java/com/laytonsmith/core/natives/interfaces/Callable.java
+++ b/src/main/java/com/laytonsmith/core/natives/interfaces/Callable.java
@@ -22,18 +22,21 @@ public interface Callable extends Mixed {
 	 * Executes the callable, giving it the supplied arguments. {@code values} may be null, which means that no
 	 * arguments are being sent.
 	 *
-	 * ConfigRuntimeExceptions will bubble up past this, since an execution mechanism may need to do custom handling.
+	 * <p>ConfigRuntimeExceptions will bubble up past this, since an execution mechanism may need to do custom
+	 * handling.</p>
 	 *
-	 * @param env
+	 * <p>Note: This method starts a fresh top-level evaluation, which is correct for callers that run the
+	 * callable on a new thread (e.g., x_new_thread). However, callers that execute the callable on the
+	 * <em>same</em> thread within an already-running eval loop should extend {@link CallbackYield} and use
+	 * {@link #prepareForStack} instead, to avoid re-entering eval() and defeating the iterative interpreter.</p>
+	 *
+	 * @param env The caller's environment (may be ignored by implementations that capture their own)
 	 * @param values The values to be passed to the callable
-	 * @param t
+	 * @param t The call site target
 	 * @return The return value of the callable, or VOID if nothing was returned
 	 * @throws ConfigRuntimeException If any call inside the callable causes a CRE
 	 * @throws CancelCommandException If die() is called within the callable
-	 * @deprecated Functions that call closures should extend {@link CallbackYield}
-	 * instead of calling this directly, which re-enters eval() and defeats the iterative interpreter.
 	 */
-	@Deprecated
 	Mixed executeCallable(Environment env, Target t, Mixed... values)
 			throws ConfigRuntimeException, CancelCommandException;
 
diff --git a/src/main/java/com/laytonsmith/tools/Interpreter.java b/src/main/java/com/laytonsmith/tools/Interpreter.java
index ad5f2443a..9f971cf4c 100644
--- a/src/main/java/com/laytonsmith/tools/Interpreter.java
+++ b/src/main/java/com/laytonsmith/tools/Interpreter.java
@@ -95,6 +95,8 @@
 import com.laytonsmith.core.functions.FunctionList;
 import com.laytonsmith.core.profiler.ProfilePoint;
 import com.laytonsmith.persistence.DataSourceException;
+import com.laytonsmith.core.environments.DebugContext;
+import com.laytonsmith.tools.debugger.MSDebugServer;
 import com.laytonsmith.tools.docgen.DocGen;
 import com.laytonsmith.tools.docgen.DocGenTemplates;
 import jline.console.ConsoleReader;
@@ -174,17 +176,77 @@ public static void startWithTTY(String file, List<String> args) throws Profiles.
 	}
 
 	public static void startWithTTY(String file, List<String> args, boolean systemExitOnFailure) throws IOException, DataSourceException, URISyntaxException, Profiles.InvalidProfileException {
+		startWithTTY(file, args, systemExitOnFailure, false, 0, false, null);
+	}
+
+	/**
+	 * Starts execution of a script file in TTY mode, optionally with a debugger.
+	 *
+	 * @param file The script file path.
+	 * @param args Arguments passed to the script.
+	 * @param systemExitOnFailure If true, calls System.exit on compile errors.
+	 * @param debug If true, starts a DAP debug server on the given port.
+	 * @param debugPort The port for the DAP TCP listener. If 0, uses
+	 *     {@link MSDebugServer#DEFAULT_PORT}.
+	 * @param debugSuspend If true, waits for the debugger to connect before executing.
+	 * @param debugThreadingMode The threading mode override: "sync", "async", or null for default.
+	 */
+	public static void startWithTTY(String file, List<String> args, boolean systemExitOnFailure,
+			boolean debug, int debugPort, boolean debugSuspend, String debugThreadingMode) throws IOException,
+			DataSourceException, URISyntaxException, Profiles.InvalidProfileException {
 		File fromFile = new File(file).getCanonicalFile();
 		Interpreter interpreter = new Interpreter(args, fromFile.getParentFile().getPath(), true);
+
+		if(debug) {
+			int port = debugPort == 0 ? MSDebugServer.DEFAULT_PORT : debugPort;
+			DebugContext.ThreadingMode threadingMode = DebugContext.ThreadingMode.SYNCHRONOUS;
+			if("async".equals(debugThreadingMode)) {
+				threadingMode = DebugContext.ThreadingMode.ASYNCHRONOUS;
+			}
+			MSDebugServer debugServer = new MSDebugServer();
+			interpreter.env = debugServer.startListening(port, interpreter.env, debugSuspend, threadingMode);
+			try {
+				debugServer.awaitConfiguration();
+			} catch(InterruptedException e) {
+				Thread.currentThread().interrupt();
+				debugServer.shutdown();
+				return;
+			}
+
+			try {
+				ParseTree tree = interpreter.compile(FileUtil.read(fromFile), args, fromFile);
+				debugServer.runScript(tree, interpreter.env,
+						interpreter.buildVars(args, fromFile));
+				debugServer.awaitCompletion();
+			} catch(ConfigCompileException ex) {
+				ConfigRuntimeException.HandleUncaughtException(ex, null, null);
+				StreamUtils.GetSystemOut().println(TermColors.reset());
+				if(systemExitOnFailure) {
+					System.exit(1);
+				}
+			} catch(ConfigCompileGroupException ex) {
+				ConfigRuntimeException.HandleUncaughtException(ex, null);
+				StreamUtils.GetSystemOut().println(TermColors.reset());
+				if(systemExitOnFailure) {
+					System.exit(1);
+				}
+			} catch(InterruptedException e) {
+				Thread.currentThread().interrupt();
+			} finally {
+				debugServer.shutdown();
+			}
+			return;
+		}
+
 		try {
 			interpreter.execute(FileUtil.read(fromFile), args, fromFile);
-		} catch (ConfigCompileException ex) {
+		} catch(ConfigCompileException ex) {
 			ConfigRuntimeException.HandleUncaughtException(ex, null, null);
 			StreamUtils.GetSystemOut().println(TermColors.reset());
 			if(systemExitOnFailure) {
 				System.exit(1);
 			}
-		} catch (ConfigCompileGroupException ex) {
+		} catch(ConfigCompileGroupException ex) {
 			ConfigRuntimeException.HandleUncaughtException(ex, null);
 			StreamUtils.GetSystemOut().println(TermColors.reset());
 			if(systemExitOnFailure) {
@@ -779,54 +841,8 @@ public void execute(String script, List<String> args, File fromFile) throws Conf
 					+ ");";
 		}
 		isExecuting = true;
-		if(args != null) {
-			staticAnalysis.getStartScope().addDeclaration(
-					new Declaration(Namespace.IVARIABLE, "@arguments", CArray.TYPE, null, Target.UNKNOWN));
-		}
-		ProfilePoint compile = env.getEnv(StaticRuntimeEnv.class).GetProfiler().start("Compilation", LogLevel.VERBOSE);
-		final ParseTree tree;
-		try {
-			TokenStream stream = MethodScriptCompiler.lex(script, env, fromFile, true);
-			tree = MethodScriptCompiler.compile(stream, env, env.getEnvClasses(), staticAnalysis);
-			staticAnalysis = new StaticAnalysis(staticAnalysis.getEndScope(), true); // Continue analysis in end scope.
-		} finally {
-			compile.stop();
-		}
-		//Environment env = Environment.createEnvironment(this.env.getEnv(GlobalEnv.class));
-		final List<Variable> vars = new ArrayList<>();
-		if(args != null) {
-			//Build the @arguments variable, the $ vars, and $ itself. Note that
-			//we have special handling for $0, that is the script name, like bash.
-			//However, it doesn't get added to either $ or @arguments, due to the
-			//uncommon use of it.
-			StringBuilder finalArgument = new StringBuilder();
-			CArray arguments = new CArray(Target.UNKNOWN);
-			{
-				//Set the $0 argument
-				Variable v = new Variable("$0", "", Target.UNKNOWN);
-				v.setVal(fromFile.toString());
-				v.setDefault(fromFile.toString());
-				vars.add(v);
-			}
-			for(int i = 0; i < args.size(); i++) {
-				String arg = args.get(i);
-				if(i > 0) {
-					finalArgument.append(" ");
-				}
-				Variable v = new Variable("$" + Integer.toString(i + 1), "", Target.UNKNOWN);
-				v.setVal(new CString(arg, Target.UNKNOWN));
-				v.setDefault(arg);
-				vars.add(v);
-				finalArgument.append(arg);
-				arguments.push(new CString(arg, Target.UNKNOWN), Target.UNKNOWN);
-			}
-			Variable v = new Variable("$", "", false, true, Target.UNKNOWN);
-			v.setVal(new CString(finalArgument.toString(), Target.UNKNOWN));
-			v.setDefault(finalArgument.toString());
-			vars.add(v);
-			env.getEnv(GlobalEnv.class).GetVarList().set(new IVariable(CArray.TYPE, "@arguments", arguments,
-					Target.UNKNOWN));
-		}
+		final ParseTree tree = compile(script, args, fromFile);
+		final List<Variable> vars = buildVars(args, fromFile);
 		try {
 			ProfilePoint p = this.env.getEnv(StaticRuntimeEnv.class)
 					.GetProfiler().start("Interpreter Script", LogLevel.ERROR);
@@ -917,6 +933,68 @@ public void execute(File script, List<String> args) throws ConfigCompileExceptio
 		execute(scriptString, args, script);
 	}
 
+	/**
+	 * Compiles a script, returning the parse tree.
+	 */
+	private ParseTree compile(String script, List<String> args, File fromFile)
+			throws ConfigCompileException, ConfigCompileGroupException {
+		if(args != null) {
+			staticAnalysis.getStartScope().addDeclaration(
+					new Declaration(Namespace.IVARIABLE, "@arguments", CArray.TYPE, null, Target.UNKNOWN));
+		}
+		ProfilePoint compile = env.getEnv(StaticRuntimeEnv.class).GetProfiler()
+				.start("Compilation", LogLevel.VERBOSE);
+		try {
+			TokenStream stream = MethodScriptCompiler.lex(script, env, fromFile, true);
+			ParseTree tree = MethodScriptCompiler.compile(stream, env, env.getEnvClasses(), staticAnalysis);
+			staticAnalysis = new StaticAnalysis(staticAnalysis.getEndScope(), true);
+			return tree;
+		} finally {
+			compile.stop();
+		}
+	}
+
+	/**
+	 * Builds the argument variables ($0, $1, ..., $, @arguments) for a script execution.
+	 */
+	private List<Variable> buildVars(List<String> args, File fromFile) {
+		List<Variable> vars = new ArrayList<>();
+		if(args != null) {
+			//Build the @arguments variable, the $ vars, and $ itself. Note that
+			//we have special handling for $0, that is the script name, like bash.
+			//However, it doesn't get added to either $ or @arguments, due to the
+			//uncommon use of it.
+			StringBuilder finalArgument = new StringBuilder();
+			CArray arguments = new CArray(Target.UNKNOWN);
+			{
+				//Set the $0 argument
+				Variable v = new Variable("$0", "", Target.UNKNOWN);
+				v.setVal(fromFile.toString());
+				v.setDefault(fromFile.toString());
+				vars.add(v);
+			}
+			for(int i = 0; i < args.size(); i++) {
+				String arg = args.get(i);
+				if(i > 0) {
+					finalArgument.append(" ");
+				}
+				Variable v = new Variable("$" + Integer.toString(i + 1), "", Target.UNKNOWN);
+				v.setVal(new CString(arg, Target.UNKNOWN));
+				v.setDefault(arg);
+				vars.add(v);
+				finalArgument.append(arg);
+				arguments.push(new CString(arg, Target.UNKNOWN), Target.UNKNOWN);
+			}
+			Variable v = new Variable("$", "", false, true, Target.UNKNOWN);
+			v.setVal(new CString(finalArgument.toString(), Target.UNKNOWN));
+			v.setDefault(finalArgument.toString());
+			vars.add(v);
+			env.getEnv(GlobalEnv.class).GetVarList().set(new IVariable(CArray.TYPE, "@arguments", arguments,
+					Target.UNKNOWN));
+		}
+		return vars;
+	}
+
 	public boolean doBuiltin(String script) {
 		List<String> args = StringUtils.ArgParser(script);
 		if(!args.isEmpty()) {
diff --git a/src/main/java/com/laytonsmith/tools/debugger/MSDebugServer.java b/src/main/java/com/laytonsmith/tools/debugger/MSDebugServer.java
new file mode 100644
index 000000000..4192b2762
--- /dev/null
+++ b/src/main/java/com/laytonsmith/tools/debugger/MSDebugServer.java
@@ -0,0 +1,914 @@
+package com.laytonsmith.tools.debugger;
+
+import com.laytonsmith.PureUtilities.Common.FileUtil;
+import com.laytonsmith.core.MethodScriptCompiler;
+import com.laytonsmith.core.ParseTree;
+import com.laytonsmith.core.Script;
+import com.laytonsmith.core.Static;
+import com.laytonsmith.core.compiler.analysis.StaticAnalysis;
+import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.constructs.IVariable;
+import com.laytonsmith.core.environments.DebugContext;
+import com.laytonsmith.core.environments.DebugListener;
+import com.laytonsmith.core.environments.Environment;
+import com.laytonsmith.core.environments.GlobalEnv;
+import com.laytonsmith.core.environments.PausedState;
+import com.laytonsmith.core.environments.RuntimeMode;
+import com.laytonsmith.core.environments.StaticRuntimeEnv;
+import com.laytonsmith.core.exceptions.StackTraceFrame;
+import com.laytonsmith.core.natives.interfaces.Mixed;
+import com.laytonsmith.core.environments.Breakpoint;
+import org.eclipse.lsp4j.debug.Capabilities;
+import org.eclipse.lsp4j.debug.ConfigurationDoneArguments;
+import org.eclipse.lsp4j.debug.ContinueArguments;
+import org.eclipse.lsp4j.debug.ContinueResponse;
+import org.eclipse.lsp4j.debug.ContinuedEventArguments;
+import org.eclipse.lsp4j.debug.DisconnectArguments;
+import org.eclipse.lsp4j.debug.EvaluateArguments;
+import org.eclipse.lsp4j.debug.EvaluateResponse;
+import org.eclipse.lsp4j.debug.ExceptionBreakpointsFilter;
+import org.eclipse.lsp4j.debug.InitializeRequestArguments;
+import org.eclipse.lsp4j.debug.OutputEventArguments;
+import org.eclipse.lsp4j.debug.Scope;
+import org.eclipse.lsp4j.debug.ScopesArguments;
+import org.eclipse.lsp4j.debug.ScopesResponse;
+import org.eclipse.lsp4j.debug.SetBreakpointsArguments;
+import org.eclipse.lsp4j.debug.SetBreakpointsResponse;
+import org.eclipse.lsp4j.debug.SetExceptionBreakpointsArguments;
+import org.eclipse.lsp4j.debug.SetExceptionBreakpointsResponse;
+import org.eclipse.lsp4j.debug.Source;
+import org.eclipse.lsp4j.debug.SourceBreakpoint;
+import org.eclipse.lsp4j.debug.StackFrame;
+import org.eclipse.lsp4j.debug.StackTraceArguments;
+import org.eclipse.lsp4j.debug.StackTraceResponse;
+import org.eclipse.lsp4j.debug.StepInArguments;
+import org.eclipse.lsp4j.debug.StepOutArguments;
+import org.eclipse.lsp4j.debug.StoppedEventArguments;
+import org.eclipse.lsp4j.debug.StoppedEventArgumentsReason;
+import org.eclipse.lsp4j.debug.TerminatedEventArguments;
+import org.eclipse.lsp4j.debug.Thread;
+import org.eclipse.lsp4j.debug.ThreadsResponse;
+import org.eclipse.lsp4j.debug.Variable;
+import org.eclipse.lsp4j.debug.VariablesArguments;
+import org.eclipse.lsp4j.debug.VariablesResponse;
+import org.eclipse.lsp4j.debug.launch.DSPLauncher;
+import org.eclipse.lsp4j.debug.services.IDebugProtocolClient;
+import org.eclipse.lsp4j.debug.services.IDebugProtocolServer;
+import org.eclipse.lsp4j.jsonrpc.Launcher;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.PrintStream;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.EnumSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CountDownLatch;
+import org.eclipse.lsp4j.debug.NextArguments;
+import org.eclipse.lsp4j.debug.ThreadEventArguments;
+import org.eclipse.lsp4j.debug.ThreadEventArgumentsReason;
+
+/**
+ * A Debug Adapter Protocol (DAP) server for MethodScript. This server can be started
+ * alongside any MethodScript execution mode (cmdline, eval, embedded) to enable
+ * debugging via VS Code or any DAP-compatible client.
+ *
+ * <p>The server opens a TCP listener and waits for a debugger to connect. It supports
+ * two usage patterns:</p>
+ * <ul>
+ *   <li><b>Launch mode</b> (cmdline/eval): The server compiles and executes a script
+ *       file, with optional suspend-before-execution.</li>
+ *   <li><b>Attach mode</b> (embedded or pre-running): The caller provides an Environment
+ *       with a DebugContext already wired in. The server bridges DAP requests to that
+ *       existing debug context.</li>
+ * </ul>
+ */
+public class MSDebugServer implements IDebugProtocolServer {
+
+	/** Default port for the DAP TCP listener (MSDB on a phone keypad). */
+	public static final int DEFAULT_PORT = 6732;
+
+	private static final int LOCALS_REF = 1;
+
+	private IDebugProtocolClient client;
+	private DebugContext debugCtx;
+	private final ConcurrentHashMap<Integer, PausedState> pausedStates = new ConcurrentHashMap<>();
+	private final ConcurrentHashMap<Integer, Script.DebugSnapshot> asyncSnapshots = new ConcurrentHashMap<>();
+	/** The paused state most recently requested via stackTrace, used by scopes/variables. */
+	private volatile PausedState lastInspectedState;
+	private java.lang.Thread executionThread;
+	private Environment env;
+	private boolean configurationDone = false;
+	private String programPath;
+	private ServerSocket serverSocket;
+	private final CountDownLatch suspendLatch = new CountDownLatch(1);
+	private final CountDownLatch completionLatch = new CountDownLatch(1);
+	private boolean suspendOnStart = false;
+	private boolean managedExecution = false;
+	private PrintStream originalOut;
+	private PrintStream originalErr;
+
+	/**
+	 * Starts a DAP TCP listener on the given port. This method starts accepting
+	 * connections on a background thread and returns immediately. When a client
+	 * connects, the DAP JSON-RPC protocol handler starts automatically.
+	 *
+	 * @param port The TCP port to listen on.
+	 * @param environment The Environment to debug. If it does not already contain a
+	 *     DebugContext, one will be created and added.
+	 * @param suspend If true, script execution will not begin until the debugger sends
+	 *     configurationDone (analogous to Java's suspend=y).
+	 * @return The Environment, which may have been cloned to include the DebugContext.
+	 * @throws IOException If the server socket cannot be opened.
+	 */
+	public Environment startListening(int port, Environment environment, boolean suspend) throws IOException {
+		return startListening(port, environment, suspend, DebugContext.ThreadingMode.SYNCHRONOUS);
+	}
+
+	/**
+	 * Starts a DAP TCP listener on the given port with an explicit threading mode.
+	 *
+	 * @param port The TCP port to listen on.
+	 * @param environment The Environment to debug.
+	 * @param suspend If true, waits for configurationDone before execution.
+	 * @param threadingMode The threading mode for the main execution thread.
+	 * @return The Environment, which may have been cloned to include the DebugContext.
+	 * @throws IOException If the server socket cannot be opened.
+	 */
+	public Environment startListening(int port, Environment environment, boolean suspend,
+			DebugContext.ThreadingMode threadingMode) throws IOException {
+		this.env = environment;
+		this.suspendOnStart = suspend;
+		this.managedExecution = true;
+
+		if(env.hasEnv(DebugContext.class)) {
+			debugCtx = env.getEnv(DebugContext.class);
+		} else {
+			debugCtx = new DebugContext(new DAPDebugListener(),
+					threadingMode, java.lang.Thread.currentThread());
+			try {
+				env = env.cloneAndAdd(debugCtx);
+			} catch(Exception e) {
+				throw new IOException("Failed to add debug context to environment", e);
+			}
+		}
+
+		serverSocket = new ServerSocket(port);
+		System.err.println("MethodScript debugger listening on port " + port);
+		if(suspend) {
+			System.err.println("Waiting for debugger to connect before execution...");
+		}
+
+		java.lang.Thread acceptThread = new java.lang.Thread(() -> {
+			try {
+				Socket socket = serverSocket.accept();
+				socket.setKeepAlive(true);
+				Launcher<IDebugProtocolClient> launcher
+						= DSPLauncher.createServerLauncher(this, socket.getInputStream(), socket.getOutputStream());
+				client = launcher.getRemoteProxy();
+				launcher.startListening();
+			} catch(IOException e) {
+				if(!serverSocket.isClosed()) {
+					System.err.println("Debug server accept failed: " + e.getMessage());
+				}
+			}
+		}, "ms-debug-accept");
+		acceptThread.setDaemon(true);
+		acceptThread.start();
+
+		return env;
+	}
+
+	/**
+	 * If suspend mode is active, blocks until the debugger has connected and sent
+	 * configurationDone. Call this before starting script execution to implement
+	 * suspend-on-start behavior.
+	 */
+	public void awaitConfiguration() throws InterruptedException {
+		if(suspendOnStart) {
+			suspendLatch.await();
+		}
+	}
+
+	/**
+	 * Blocks until the debug session is fully complete. This is signalled when the
+	 * debugger disconnects or the script runs to completion without hitting any more
+	 * breakpoints. Call this after script execution returns to prevent premature
+	 * shutdown while the debugger is still paused on a breakpoint.
+	 */
+	public void awaitCompletion() throws InterruptedException {
+		completionLatch.await();
+	}
+
+	/**
+	 * Runs the given compiled script on a background thread. This method returns
+	 * immediately. The debug server manages the full execution lifecycle: if a
+	 * breakpoint is hit, execution pauses and the thread exits; when the debugger
+	 * sends continue/step, {@link #resumeOnThread()} picks up from the snapshot.
+	 * When execution completes (no more breakpoints), the terminated event is sent
+	 * to the client and the completion latch is released.
+	 *
+	 * <p>Call {@link #awaitCompletion()} after this to block until the debug
+	 * session fully ends.</p>
+	 *
+	 * @param tree The compiled parse tree
+	 * @param env The environment (must already contain DebugContext)
+	 * @param vars Script argument variables (may be null)
+	 */
+	public void runScript(ParseTree tree, Environment env, List<com.laytonsmith.core.constructs.Variable> vars) {
+		this.env = env;
+		wireUpDaemonManager(env);
+		installOutputRedirect();
+		spawnExecutionThread(() -> MethodScriptCompiler.execute(tree, env, null, null, vars));
+	}
+
+	/**
+	 * Spawns a new execution thread that runs the given task and handles the full
+	 * debug lifecycle. If the task returns {@link Script#isDebuggerPaused(Mixed)},
+	 * the thread waits for background threads (DaemonManager) to keep the process
+	 * alive. If it completes normally, the thread signals the main thread exit,
+	 * waits for daemons, and then signals session completion.
+	 *
+	 * @param task A callable that performs the script execution and returns the result
+	 */
+	private void spawnExecutionThread(java.util.concurrent.Callable<Mixed> task) {
+		executionThread = new java.lang.Thread(() -> {
+			try {
+				Mixed result = task.call();
+				if(!Script.isDebuggerPaused(result)) {
+					mainThreadFinished();
+				}
+				awaitDaemonManager(env);
+				if(!Script.isDebuggerPaused(result)) {
+					executionCompleted();
+				}
+			} catch(Exception e) {
+				sendOutput("error", "Script error: " + e.getMessage());
+				executionCompleted();
+			}
+		}, "ms-debug-execution");
+		debugCtx.setMainThread(executionThread);
+		executionThread.start();
+	}
+
+	/**
+	 * Called when the main script thread finishes executing user code but before
+	 * waiting for background threads. Unregisters the main thread from the
+	 * DebugContext and sends a thread-exited event so VS Code removes it from
+	 * the Call Stack panel.
+	 */
+	private void mainThreadFinished() {
+		int mainDapId = debugCtx.getDapThreadId(java.lang.Thread.currentThread());
+		debugCtx.unregisterThread(java.lang.Thread.currentThread());
+		if(client != null && mainDapId >= 0) {
+			ThreadEventArguments tea = new ThreadEventArguments();
+			tea.setThreadId(mainDapId);
+			tea.setReason(ThreadEventArgumentsReason.EXITED);
+			client.thread(tea);
+		}
+	}
+
+	/**
+	 * Called when script execution completes normally (not paused). Sends the
+	 * terminated event to the client and releases the completion latch.
+	 */
+	private void executionCompleted() {
+		restoreOutputRedirect();
+		if(client != null) {
+			client.terminated(new TerminatedEventArguments());
+		}
+		completionLatch.countDown();
+	}
+
+	/**
+	 * Returns the port the server is currently listening on, or -1 if the
+	 * server is not yet listening or has been shut down.
+	 */
+	public int getPort() {
+		return serverSocket != null && !serverSocket.isClosed()
+				? serverSocket.getLocalPort() : -1;
+	}
+
+	/**
+	 * Shuts down the debug server, closing the TCP listener.
+	 */
+	public void shutdown() {
+		try {
+			if(serverSocket != null && !serverSocket.isClosed()) {
+				serverSocket.close();
+			}
+		} catch(IOException e) {
+			// Ignore close errors
+		}
+	}
+
+	@Override
+	public CompletableFuture<Capabilities> initialize(InitializeRequestArguments args) {
+		Capabilities caps = new Capabilities();
+		caps.setSupportsConfigurationDoneRequest(true);
+		caps.setSupportsEvaluateForHovers(true);
+		caps.setSupportsConditionalBreakpoints(true);
+		caps.setSupportsHitConditionalBreakpoints(true);
+		caps.setSupportsLogPoints(true);
+
+		ExceptionBreakpointsFilter allFilter = new ExceptionBreakpointsFilter();
+		allFilter.setFilter("all");
+		allFilter.setLabel("All Exceptions");
+		allFilter.setDescription("Break on all thrown exceptions");
+
+		ExceptionBreakpointsFilter uncaughtFilter = new ExceptionBreakpointsFilter();
+		uncaughtFilter.setFilter("uncaught");
+		uncaughtFilter.setLabel("Uncaught Exceptions");
+		uncaughtFilter.setDescription("Break on exceptions not caught by a try block");
+		uncaughtFilter.setDefault_(true);
+
+		caps.setExceptionBreakpointFilters(
+				new ExceptionBreakpointsFilter[]{allFilter, uncaughtFilter});
+		return CompletableFuture.completedFuture(caps);
+	}
+
+	@Override
+	public CompletableFuture<Void> launch(Map<String, Object> args) {
+		programPath = (String) args.get("program");
+		if(programPath == null) {
+			sendOutput("error", "No 'program' specified in launch configuration");
+			return CompletableFuture.completedFuture(null);
+		}
+
+		File scriptFile = new File(programPath);
+		if(!scriptFile.exists()) {
+			sendOutput("error", "Script file not found: " + programPath);
+			return CompletableFuture.completedFuture(null);
+		}
+
+		if(env == null) {
+			try {
+				env = Static.GenerateStandaloneEnvironment(false,
+						EnumSet.of(RuntimeMode.CMDLINE));
+				debugCtx = new DebugContext(new DAPDebugListener(),
+						DebugContext.ThreadingMode.SYNCHRONOUS, java.lang.Thread.currentThread());
+				env = env.cloneAndAdd(debugCtx);
+			} catch(Exception e) {
+				sendOutput("error", "Failed to create environment: " + e.getMessage());
+				return CompletableFuture.completedFuture(null);
+			}
+		}
+
+		client.initialized();
+		return CompletableFuture.completedFuture(null);
+	}
+
+	@Override
+	public CompletableFuture<Void> configurationDone(ConfigurationDoneArguments args) {
+		configurationDone = true;
+		suspendLatch.countDown();
+		if(programPath != null && !managedExecution) {
+			startExecution();
+		}
+		return CompletableFuture.completedFuture(null);
+	}
+
+	@Override
+	public CompletableFuture<Void> disconnect(DisconnectArguments args) {
+		if(debugCtx != null) {
+			debugCtx.disconnect();
+			if(!pausedStates.isEmpty()) {
+				for(int threadId : pausedStates.keySet()) {
+					resumeExecution(threadId);
+				}
+			}
+		}
+		suspendLatch.countDown();
+		completionLatch.countDown();
+		shutdown();
+		return CompletableFuture.completedFuture(null);
+	}
+
+	@Override
+	public CompletableFuture<SetBreakpointsResponse> setBreakpoints(SetBreakpointsArguments args) {
+		SetBreakpointsResponse response = new SetBreakpointsResponse();
+		Source source = args.getSource();
+		if(source == null || source.getPath() == null || debugCtx == null) {
+			response.setBreakpoints(new org.eclipse.lsp4j.debug.Breakpoint[0]);
+			return CompletableFuture.completedFuture(response);
+		}
+
+		File file = new File(source.getPath());
+		SourceBreakpoint[] sourceBreakpoints = args.getBreakpoints();
+		List<Breakpoint> debugBps = new ArrayList<>();
+		List<org.eclipse.lsp4j.debug.Breakpoint> verified = new ArrayList<>();
+
+		if(sourceBreakpoints != null) {
+			for(SourceBreakpoint sbp : sourceBreakpoints) {
+				String condition = sbp.getCondition();
+				String hitCondition = sbp.getHitCondition();
+				String logMessage = sbp.getLogMessage();
+				int hitThreshold = 0;
+				if(hitCondition != null && !hitCondition.isEmpty()) {
+					try {
+						hitThreshold = Integer.parseInt(hitCondition.trim());
+					} catch(NumberFormatException e) {
+						// Ignore invalid hit condition
+					}
+				}
+
+				org.eclipse.lsp4j.debug.Breakpoint bp = new org.eclipse.lsp4j.debug.Breakpoint();
+				bp.setLine(sbp.getLine());
+				bp.setSource(source);
+				try {
+					debugBps.add(new Breakpoint(file, sbp.getLine(), condition, hitThreshold, logMessage));
+					bp.setVerified(true);
+				} catch(IllegalArgumentException e) {
+					bp.setVerified(false);
+					bp.setMessage(e.getMessage());
+				}
+				verified.add(bp);
+			}
+		}
+
+		debugCtx.setBreakpointsForFile(file, debugBps);
+		response.setBreakpoints(verified.toArray(new org.eclipse.lsp4j.debug.Breakpoint[0]));
+		return CompletableFuture.completedFuture(response);
+	}
+
+	@Override
+	public CompletableFuture<SetExceptionBreakpointsResponse> setExceptionBreakpoints(
+			SetExceptionBreakpointsArguments args) {
+		DebugContext.ExceptionBreakMode mode = DebugContext.ExceptionBreakMode.NONE;
+		String[] filters = args.getFilters();
+		if(filters != null) {
+			for(String filter : filters) {
+				if("all".equals(filter)) {
+					mode = DebugContext.ExceptionBreakMode.ALL;
+					break;
+				} else if("uncaught".equals(filter)) {
+					mode = DebugContext.ExceptionBreakMode.UNCAUGHT;
+				}
+			}
+		}
+		if(debugCtx != null) {
+			debugCtx.setExceptionBreakMode(mode);
+		}
+		return CompletableFuture.completedFuture(new SetExceptionBreakpointsResponse());
+	}
+
+	@Override
+	public CompletableFuture<ContinueResponse> continue_(ContinueArguments args) {
+		int threadId = args.getThreadId();
+		if(pausedStates.containsKey(threadId)) {
+			debugCtx.setStepMode(threadId,
+					DebugContext.StepMode.NONE, 0, Target.UNKNOWN);
+			resumeExecution(threadId);
+		}
+		ContinueResponse response = new ContinueResponse();
+		response.setAllThreadsContinued(false);
+		return CompletableFuture.completedFuture(response);
+	}
+
+	@Override
+	public CompletableFuture<Void> next(NextArguments args) {
+		int threadId = args.getThreadId();
+		PausedState state = pausedStates.get(threadId);
+		if(state != null) {
+			debugCtx.setStepMode(threadId, DebugContext.StepMode.OVER,
+					state.getUserCallDepth(), state.getPauseTarget());
+			resumeExecution(threadId);
+		}
+		return CompletableFuture.completedFuture(null);
+	}
+
+	@Override
+	public CompletableFuture<Void> stepIn(StepInArguments args) {
+		int threadId = args.getThreadId();
+		PausedState state = pausedStates.get(threadId);
+		if(state != null) {
+			debugCtx.setStepMode(threadId, DebugContext.StepMode.INTO,
+					state.getUserCallDepth(), state.getPauseTarget());
+			resumeExecution(threadId);
+		}
+		return CompletableFuture.completedFuture(null);
+	}
+
+	@Override
+	public CompletableFuture<Void> stepOut(StepOutArguments args) {
+		int threadId = args.getThreadId();
+		PausedState state = pausedStates.get(threadId);
+		if(state != null) {
+			debugCtx.setStepMode(threadId, DebugContext.StepMode.OUT,
+					state.getUserCallDepth(), state.getPauseTarget());
+			resumeExecution(threadId);
+		}
+		return CompletableFuture.completedFuture(null);
+	}
+
+	@Override
+	public CompletableFuture<ThreadsResponse> threads() {
+		ThreadsResponse response = new ThreadsResponse();
+		if(debugCtx != null) {
+			Map<Integer, String> registered = debugCtx.getRegisteredThreads();
+			Thread[] threads = new Thread[registered.size()];
+			int i = 0;
+			for(Map.Entry<Integer, String> entry : registered.entrySet()) {
+				Thread t = new Thread();
+				t.setId(entry.getKey());
+				t.setName(entry.getValue());
+				threads[i++] = t;
+			}
+			response.setThreads(threads);
+		} else {
+			response.setThreads(new Thread[0]);
+		}
+		return CompletableFuture.completedFuture(response);
+	}
+
+	@Override
+	public CompletableFuture<StackTraceResponse> stackTrace(StackTraceArguments args) {
+		StackTraceResponse response = new StackTraceResponse();
+		PausedState pausedState = pausedStates.get(args.getThreadId());
+		if(pausedState == null) {
+			response.setStackFrames(new StackFrame[0]);
+			response.setTotalFrames(0);
+			return CompletableFuture.completedFuture(response);
+		}
+		lastInspectedState = pausedState;
+
+		List<StackTraceFrame> callStack = pausedState.getCallStack();
+		List<StackFrame> frames = new ArrayList<>();
+		Target pauseTarget = pausedState.getPauseTarget();
+
+		if(callStack.isEmpty()) {
+			// At top level — only a <main> frame
+			StackFrame mainFrame = new StackFrame();
+			mainFrame.setId(0);
+			mainFrame.setName("<main>");
+			mainFrame.setLine(pauseTarget.line());
+			mainFrame.setColumn(pauseTarget.col());
+			setSource(mainFrame, pauseTarget);
+			frames.add(mainFrame);
+		} else {
+			// Inside proc/closure calls. callStack is innermost-first.
+			// The first entry is the current frame — use pauseTarget for its location.
+			// Each subsequent frame shows the call site of the frame above it.
+			for(int i = 0; i < callStack.size(); i++) {
+				StackTraceFrame stf = callStack.get(i);
+				StackFrame frame = new StackFrame();
+				frame.setId(i);
+				frame.setName(stf.getProcedureName());
+				Target t;
+				if(i == 0) {
+					t = pauseTarget;
+				} else {
+					// Show where this frame called the child (i.e. the child's call site)
+					t = callStack.get(i - 1).getCallSite();
+				}
+				frame.setLine(t.line());
+				frame.setColumn(t.col());
+				setSource(frame, t);
+				frames.add(frame);
+			}
+			// Add the outermost <main> frame at the bottom, showing where
+			// the outermost proc was called from
+			StackFrame mainFrame = new StackFrame();
+			mainFrame.setId(callStack.size());
+			mainFrame.setName("<main>");
+			Target outerCallSite = callStack.get(callStack.size() - 1).getCallSite();
+			mainFrame.setLine(outerCallSite.line());
+			mainFrame.setColumn(outerCallSite.col());
+			setSource(mainFrame, outerCallSite);
+			frames.add(mainFrame);
+		}
+
+		response.setStackFrames(frames.toArray(new StackFrame[0]));
+		response.setTotalFrames(frames.size());
+		return CompletableFuture.completedFuture(response);
+	}
+
+	private void setSource(StackFrame frame, Target t) {
+		if(t.file() != null) {
+			Source src = new Source();
+			src.setPath(t.file().getAbsolutePath());
+			src.setName(t.file().getName());
+			frame.setSource(src);
+		}
+	}
+
+	@Override
+	public CompletableFuture<ScopesResponse> scopes(ScopesArguments args) {
+		ScopesResponse response = new ScopesResponse();
+		Scope locals = new Scope();
+		locals.setName("Locals");
+		locals.setVariablesReference(LOCALS_REF);
+		locals.setExpensive(false);
+		response.setScopes(new Scope[]{locals});
+		return CompletableFuture.completedFuture(response);
+	}
+
+	@Override
+	public CompletableFuture<VariablesResponse> variables(VariablesArguments args) {
+		VariablesResponse response = new VariablesResponse();
+		PausedState inspected = lastInspectedState;
+		if(inspected == null || args.getVariablesReference() != LOCALS_REF) {
+			response.setVariables(new Variable[0]);
+			return CompletableFuture.completedFuture(response);
+		}
+
+		Map<String, Mixed> vars = inspected.getVariables();
+		List<Variable> result = new ArrayList<>();
+		Environment stateEnv = inspected.getEnvironment();
+		for(Map.Entry<String, Mixed> entry : vars.entrySet()) {
+			Variable v = new Variable();
+			v.setName(entry.getKey());
+			v.setValue(entry.getValue().val());
+			v.setType(entry.getValue().typeof(stateEnv).val());
+			v.setVariablesReference(0);
+			result.add(v);
+		}
+
+		response.setVariables(result.toArray(new Variable[0]));
+		return CompletableFuture.completedFuture(response);
+	}
+
+	@Override
+	public CompletableFuture<EvaluateResponse> evaluate(EvaluateArguments args) {
+		EvaluateResponse response = new EvaluateResponse();
+		PausedState inspected = lastInspectedState;
+		if(inspected == null) {
+			response.setResult("Not paused");
+			response.setVariablesReference(0);
+			return CompletableFuture.completedFuture(response);
+		}
+
+		String expression = args.getExpression();
+		DAPTeeOutputStream.setSuppressOutput(true);
+		try {
+			Environment evalEnv = inspected.getEnvironment();
+			GlobalEnv gEnv = evalEnv.getEnv(GlobalEnv.class);
+			gEnv.SetFlag(GlobalEnv.FLAG_NO_CHECK_UNDEFINED, true);
+			try {
+				Set<Class<? extends Environment.EnvironmentImpl>> envClasses
+						= evalEnv.getEnvClasses();
+				Mixed result = MethodScriptCompiler.execute(expression, null, true,
+						evalEnv, envClasses, null, null, null);
+				while(result instanceof IVariable iv) {
+					result = gEnv.GetVarList()
+							.get(iv.getVariableName(), iv.getTarget(), evalEnv).ival();
+				}
+				response.setResult(result.val());
+				response.setType(result.typeof(evalEnv).val());
+			} finally {
+				gEnv.ClearFlag(GlobalEnv.FLAG_NO_CHECK_UNDEFINED);
+			}
+		} catch(Exception e) {
+			response.setResult(e.getMessage());
+		} finally {
+			DAPTeeOutputStream.setSuppressOutput(false);
+		}
+		response.setVariablesReference(0);
+		return CompletableFuture.completedFuture(response);
+	}
+
+	private void startExecution() {
+		if(!configurationDone || programPath == null) {
+			return;
+		}
+		wireUpDaemonManager(env);
+
+		spawnExecutionThread(() -> {
+			File scriptFile = new File(programPath);
+			String script = FileUtil.read(scriptFile);
+			Set<Class<? extends Environment.EnvironmentImpl>> envClasses
+					= Environment.getDefaultEnvClasses();
+			StaticAnalysis analysis = new StaticAnalysis(true);
+			analysis.setLocalEnable(false);
+			ParseTree tree = MethodScriptCompiler.compile(
+					MethodScriptCompiler.lex(script, env, scriptFile, true),
+					env, envClasses, analysis);
+			return MethodScriptCompiler.execute(tree, env, null, null);
+		});
+	}
+
+	/**
+	 * Resumes execution of the specified thread after a debug pause. In synchronous
+	 * mode, releases the thread's latch so it continues in place. In asynchronous mode
+	 * (main thread only), spawns a new thread to resume from the saved snapshot.
+	 *
+	 * @param threadId The DAP thread ID to resume
+	 */
+	private void resumeExecution(int threadId) {
+		pausedStates.remove(threadId);
+		if(debugCtx.getThreadingMode() == DebugContext.ThreadingMode.SYNCHRONOUS
+				|| threadId != DebugContext.MAIN_THREAD_DAP_ID) {
+			// Sync mode or background thread: thread is blocked on the latch — release it
+			asyncSnapshots.remove(threadId);
+			debugCtx.resume(threadId);
+		} else {
+			// Async mode, main thread: spawn a new thread to resume from snapshot
+			Script.DebugSnapshot snapshot = asyncSnapshots.remove(threadId);
+			spawnExecutionThread(() -> Script.resumeEval(snapshot));
+		}
+	}
+
+	/**
+	 * Registers the DebugContext with the environment's DaemonManager so that
+	 * background threads (e.g. x_new_thread) are automatically tracked and
+	 * reported as DAP thread events.
+	 */
+	private void wireUpDaemonManager(Environment env) {
+		if(env.hasEnv(StaticRuntimeEnv.class)) {
+			com.laytonsmith.PureUtilities.DaemonManager dm
+					= env.getEnv(StaticRuntimeEnv.class).GetDaemonManager();
+			debugCtx.registerWithDaemonManager(dm);
+		}
+	}
+
+	/**
+	 * Waits for all background threads tracked by the DaemonManager to finish.
+	 * This ensures the debug session stays alive while background threads
+	 * (e.g. x_new_thread) are still running.
+	 */
+	private void awaitDaemonManager(Environment env) {
+		if(env.hasEnv(StaticRuntimeEnv.class)) {
+			try {
+				env.getEnv(StaticRuntimeEnv.class).GetDaemonManager().waitForThreads();
+			} catch(InterruptedException e) {
+				// Interrupted — let the session end
+			}
+		}
+	}
+
+	private void installOutputRedirect() {
+		originalOut = System.out;
+		originalErr = System.err;
+		System.setOut(new PrintStream(new DAPTeeOutputStream(originalOut, "stdout"), true, StandardCharsets.UTF_8));
+		System.setErr(new PrintStream(new DAPTeeOutputStream(originalErr, "stderr"), true, StandardCharsets.UTF_8));
+	}
+
+	private void restoreOutputRedirect() {
+		if(originalOut != null) {
+			System.setOut(originalOut);
+			originalOut = null;
+		}
+		if(originalErr != null) {
+			System.setErr(originalErr);
+			originalErr = null;
+		}
+	}
+
+	/**
+	 * An OutputStream that tees output to both the original stream and the DAP client
+	 * as OutputEvents. Bytes are buffered until a newline is seen, then sent as a
+	 * single output event to avoid splitting multi-byte characters or sending
+	 * partial lines.
+	 *
+	 * <p>Output can be suppressed on a per-thread basis using {@link #setSuppressOutput(boolean)}.
+	 * When suppressed, output is silently discarded (not sent to the original stream or the
+	 * DAP client). This is used during watch expression evaluation to prevent side effects.</p>
+	 */
+	private class DAPTeeOutputStream extends OutputStream {
+		private static final ThreadLocal<Boolean> SUPPRESS_OUTPUT = ThreadLocal.withInitial(() -> false);
+
+		private final OutputStream original;
+		private final String category;
+		private final StringBuilder lineBuffer = new StringBuilder();
+
+		DAPTeeOutputStream(OutputStream original, String category) {
+			this.original = original;
+			this.category = category;
+		}
+
+		static void setSuppressOutput(boolean suppress) {
+			SUPPRESS_OUTPUT.set(suppress);
+		}
+
+		@Override
+		public void write(int b) throws IOException {
+			if(SUPPRESS_OUTPUT.get()) {
+				return;
+			}
+			original.write(b);
+			char c = (char) b;
+			lineBuffer.append(c);
+			if(c == '\n') {
+				flushBuffer();
+			}
+		}
+
+		@Override
+		public void write(byte[] buf, int off, int len) throws IOException {
+			if(SUPPRESS_OUTPUT.get()) {
+				return;
+			}
+			original.write(buf, off, len);
+			String s = new String(buf, off, len, StandardCharsets.UTF_8);
+			lineBuffer.append(s);
+			if(s.contains("\n")) {
+				flushBuffer();
+			}
+		}
+
+		@Override
+		public void flush() throws IOException {
+			if(SUPPRESS_OUTPUT.get()) {
+				return;
+			}
+			original.flush();
+			if(lineBuffer.length() > 0) {
+				flushBuffer();
+			}
+		}
+
+		private void flushBuffer() {
+			if(client != null && lineBuffer.length() > 0) {
+				OutputEventArguments output = new OutputEventArguments();
+				output.setCategory(category);
+				output.setOutput(lineBuffer.toString());
+				client.output(output);
+			}
+			lineBuffer.setLength(0);
+		}
+	}
+
+	private void sendOutput(String category, String text) {
+		if(client != null) {
+			OutputEventArguments output = new OutputEventArguments();
+			output.setCategory(category);
+			output.setOutput(text + "\n");
+			client.output(output);
+		}
+	}
+
+	/**
+	 * Bridges the DebugListener interface to DAP client events.
+	 */
+	private final class DAPDebugListener implements DebugListener {
+
+		@Override
+		public void onPaused(PausedState state) {
+			int dapId = debugCtx.getCurrentDapThreadId();
+			pausedStates.put(dapId, state);
+			if(state instanceof Script.DebugSnapshot snapshot) {
+				asyncSnapshots.put(dapId, snapshot);
+			}
+			StoppedEventArguments stopped = new StoppedEventArguments();
+			stopped.setThreadId(dapId);
+			if(state.isExceptionPause()) {
+				stopped.setReason(StoppedEventArgumentsReason.EXCEPTION);
+				stopped.setText(state.getPauseException().getMessage());
+			} else if(debugCtx.getStepMode() != DebugContext.StepMode.NONE) {
+				stopped.setReason(StoppedEventArgumentsReason.STEP);
+			} else {
+				stopped.setReason(StoppedEventArgumentsReason.BREAKPOINT);
+			}
+			client.stopped(stopped);
+		}
+
+		@Override
+		public void onResumed() {
+			int dapId = debugCtx.getCurrentDapThreadId();
+			ContinuedEventArguments continued = new ContinuedEventArguments();
+			continued.setThreadId(dapId);
+			continued.setAllThreadsContinued(false);
+			client.continued(continued);
+		}
+
+		@Override
+		public void onCompleted() {
+			// Completion is handled by executionCompleted(), called from
+			// runScript/resumeOnThread when they detect eval finished.
+		}
+
+		@Override
+		public void onThreadStarted(int dapThreadId, String name) {
+			if(client != null) {
+				ThreadEventArguments args = new ThreadEventArguments();
+				args.setThreadId(dapThreadId);
+				args.setReason(ThreadEventArgumentsReason.STARTED);
+				client.thread(args);
+			}
+		}
+
+		@Override
+		public void onThreadExited(int dapThreadId) {
+			pausedStates.remove(dapThreadId);
+			asyncSnapshots.remove(dapThreadId);
+			if(client != null) {
+				ThreadEventArguments args = new ThreadEventArguments();
+				args.setThreadId(dapThreadId);
+				args.setReason(ThreadEventArgumentsReason.EXITED);
+				client.thread(args);
+			}
+		}
+
+		@Override
+		public void onLogPoint(String message) {
+			sendOutput("console", message + "\n");
+		}
+	}
+}
diff --git a/src/main/java/com/laytonsmith/tools/langserv/LangServ.java b/src/main/java/com/laytonsmith/tools/langserv/LangServ.java
index 4bfbaca67..812f88a48 100644
--- a/src/main/java/com/laytonsmith/tools/langserv/LangServ.java
+++ b/src/main/java/com/laytonsmith/tools/langserv/LangServ.java
@@ -60,6 +60,7 @@
 import org.eclipse.lsp4j.CompletionOptions;
 import org.eclipse.lsp4j.CompletionParams;
 import org.eclipse.lsp4j.DeclarationParams;
+import org.eclipse.lsp4j.DefinitionParams;
 import org.eclipse.lsp4j.DiagnosticSeverity;
 import org.eclipse.lsp4j.DidChangeConfigurationParams;
 import org.eclipse.lsp4j.DidChangeTextDocumentParams;
@@ -397,6 +398,7 @@ public CompletableFuture<InitializeResult> initialize(InitializeParams params) {
 
 		sc.setDocumentSymbolProvider(true);
 		sc.setDeclarationProvider(true);
+		sc.setDefinitionProvider(true);
 		sc.setHoverProvider(true);
 //		sc.setTypeDefinitionProvider(true);
 
@@ -677,6 +679,14 @@ public CompletableFuture<Either<List<? extends Location>, List<? extends Locatio
 		return result;
 	}
 
+	@Override
+	public CompletableFuture<Either<List<? extends Location>, List<? extends LocationLink>>> definition(DefinitionParams params) {
+		logv(this.getClass().getName() + "." + StackTraceUtils.currentMethod() + " called");
+		logv(() -> params.toString());
+		DeclarationParams dp = new DeclarationParams(params.getTextDocument(), params.getPosition());
+		return declaration(dp);
+	}
+
 	@Override
 	public CompletableFuture<Either<List<? extends Location>, List<? extends LocationLink>>> typeDefinition(TypeDefinitionParams params) {
 		logv(this.getClass().getName() + "." + StackTraceUtils.currentMethod() + " called");
diff --git a/src/main/java/com/laytonsmith/tools/langserv/LangServModel.java b/src/main/java/com/laytonsmith/tools/langserv/LangServModel.java
index 26b7a2434..dbbb055f6 100644
--- a/src/main/java/com/laytonsmith/tools/langserv/LangServModel.java
+++ b/src/main/java/com/laytonsmith/tools/langserv/LangServModel.java
@@ -248,8 +248,10 @@ private void syncRebuild() {
 			// Cmdline mode disables things like security checks and whatnot.
 			// These may be present in the runtime environment,
 			// but it's not possible for us to tell that at this point.
+			StaticAnalysis envSa = new StaticAnalysis(true);
+			envSa.setLocalEnable(true);
 			env = Static.GenerateStandaloneEnvironment(false, EnumSet.of(RuntimeMode.CMDLINE), includeCache,
-					new StaticAnalysis(true));
+					envSa);
 			// Make this configurable at some point. For now, however, we need this so we can get
 			// correct handling on minecraft functions.
 			env = env.cloneAndAdd(new CommandHelperEnvironment());
@@ -289,7 +291,8 @@ private void syncRebuild() {
 		for(File f2 : mainFiles) {
 			String uri = f2.toURI().toString();
 			StaticAnalysis staticAnalysis = new StaticAnalysis(true);
-			parseTrees.put(uri, doCompilation(uri, new StaticAnalysis(true), env, exceptions));
+			staticAnalysis.setLocalEnable(true);
+			parseTrees.put(uri, doCompilation(uri, staticAnalysis, env, exceptions));
 			staticAnalysisMap.put(uri, staticAnalysis);
 		}
 
@@ -304,6 +307,7 @@ private void syncRebuild() {
 					// This was not included, was dynamically included, or there was a compile exception.
 					// Can only treat it as an isolated script at this point.
 					StaticAnalysis staticAnalysis = new StaticAnalysis(true);
+					staticAnalysis.setLocalEnable(true);
 					parseTrees.put(uri, doCompilation(uri, staticAnalysis, env, exceptions));
 					staticAnalysisMap.put(uri, staticAnalysis);
 				}
diff --git a/src/test/java/com/laytonsmith/core/DebugInfrastructureTest.java b/src/test/java/com/laytonsmith/core/DebugInfrastructureTest.java
new file mode 100644
index 000000000..15d92558c
--- /dev/null
+++ b/src/test/java/com/laytonsmith/core/DebugInfrastructureTest.java
@@ -0,0 +1,675 @@
+package com.laytonsmith.core;
+
+import com.laytonsmith.abstraction.Implementation;
+import com.laytonsmith.core.compiler.TokenStream;
+import com.laytonsmith.core.compiler.analysis.StaticAnalysis;
+import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.environments.Breakpoint;
+import com.laytonsmith.core.environments.CommandHelperEnvironment;
+import com.laytonsmith.core.environments.DebugContext;
+import com.laytonsmith.core.environments.DebugListener;
+import com.laytonsmith.core.environments.Environment;
+import com.laytonsmith.core.environments.GlobalEnv;
+import com.laytonsmith.core.environments.PausedState;
+import com.laytonsmith.core.exceptions.StackTraceFrame;
+import com.laytonsmith.core.natives.interfaces.Mixed;
+import com.laytonsmith.testing.StaticTest;
+import com.laytonsmith.tools.debugger.MSDebugServer;
+import org.eclipse.lsp4j.debug.InitializeRequestArguments;
+import org.eclipse.lsp4j.debug.NextArguments;
+import org.eclipse.lsp4j.debug.ContinueArguments;
+import org.eclipse.lsp4j.debug.SetBreakpointsArguments;
+import org.eclipse.lsp4j.debug.Source;
+import org.eclipse.lsp4j.debug.SourceBreakpoint;
+import org.eclipse.lsp4j.debug.StoppedEventArguments;
+import org.eclipse.lsp4j.debug.services.IDebugProtocolClient;
+import org.eclipse.lsp4j.debug.services.IDebugProtocolServer;
+import org.eclipse.lsp4j.debug.launch.DSPLauncher;
+import org.eclipse.lsp4j.jsonrpc.Launcher;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.File;
+import java.net.Socket;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.atomic.AtomicReference;
+
+import static org.junit.Assert.*;
+
+/**
+ * Tests for the debug infrastructure: breakpoints, step modes, variable inspection,
+ * call stack inspection, and disconnect.
+ */
+public class DebugInfrastructureTest {
+
+	private static Environment baseEnv;
+	private static Set<Class<? extends Environment.EnvironmentImpl>> envs;
+	private static final File TEST_FILE = new File("test.ms");
+
+	@BeforeClass
+	public static void setUpClass() throws Exception {
+		Implementation.setServerType(Implementation.Type.TEST);
+		StaticTest.InstallFakeServerFrontend();
+		baseEnv = Static.GenerateStandaloneEnvironment();
+		baseEnv = baseEnv.cloneAndAdd(new CommandHelperEnvironment());
+		envs = Environment.getDefaultEnvClasses();
+		envs.add(CommandHelperEnvironment.class);
+	}
+
+	@AfterClass
+	public static void tearDownClass() {
+		Implementation.forceServerType(null);
+	}
+
+	@Before
+	public void setUp() {
+		baseEnv.getEnv(GlobalEnv.class).GetVarList().clear();
+	}
+
+	/**
+	 * Compiles and executes a script with the given DebugContext attached.
+	 * Returns null if the debugger paused execution.
+	 */
+	private Mixed executeWithDebugger(String script, DebugContext debugCtx) throws Exception {
+		Environment testEnv = baseEnv.cloneAndAdd(debugCtx);
+		testEnv.getEnv(GlobalEnv.class).GetVarList().clear();
+		StaticAnalysis analysis = new StaticAnalysis(true);
+		analysis.setLocalEnable(false);
+		TokenStream tokens = MethodScriptCompiler.lex(script, testEnv, TEST_FILE, true);
+		ParseTree tree = MethodScriptCompiler.compile(tokens, testEnv, envs, analysis);
+		return MethodScriptCompiler.execute(tree, testEnv, null, null);
+	}
+
+	/**
+	 * Test DebugListener that records all events for later assertion.
+	 */
+	private static class TestDebugListener implements DebugListener {
+		final List<PausedState> pauses = new ArrayList<>();
+		final List<String> logMessages = new ArrayList<>();
+		boolean completed = false;
+		int resumeCount = 0;
+
+		@Override
+		public void onPaused(PausedState state) {
+			pauses.add(state);
+		}
+
+		@Override
+		public void onResumed() {
+			resumeCount++;
+		}
+
+		@Override
+		public void onCompleted() {
+			completed = true;
+		}
+
+		@Override
+		public void onLogPoint(String message) {
+			logMessages.add(message);
+		}
+
+		Script.DebugSnapshot snapshot(int index) {
+			return (Script.DebugSnapshot) pauses.get(index);
+		}
+	}
+
+	@Test
+	public void testBreakpointHitAndContinue() throws Exception {
+		String script = "@x = 1\n@y = @x + 1\n@z = @y + 1";
+		TestDebugListener listener = new TestDebugListener();
+		DebugContext debugCtx = new DebugContext(listener, DebugContext.ThreadingMode.ASYNCHRONOUS,
+				Thread.currentThread());
+		debugCtx.addBreakpoint(new Breakpoint(TEST_FILE, 2));
+
+		Mixed result = executeWithDebugger(script, debugCtx);
+
+		// Should have paused
+		assertTrue(Script.isDebuggerPaused(result));
+		assertEquals(1, listener.pauses.size());
+		assertEquals(2, listener.pauses.get(0).getPauseTarget().line());
+
+		// Resume with continue (NONE = run freely)
+		debugCtx.setStepMode(DebugContext.StepMode.NONE, 0, Target.UNKNOWN);
+		Script.resumeEval(listener.snapshot(0));
+
+		assertTrue(listener.completed);
+		assertEquals(1, listener.pauses.size());
+	}
+
+	@Test
+	public void testVariableInspection() throws Exception {
+		String script = "@x = 42\n@y = 'hello'\n@z = true";
+		TestDebugListener listener = new TestDebugListener();
+		DebugContext debugCtx = new DebugContext(listener, DebugContext.ThreadingMode.ASYNCHRONOUS,
+				Thread.currentThread());
+		debugCtx.addBreakpoint(new Breakpoint(TEST_FILE, 3));
+
+		executeWithDebugger(script, debugCtx);
+
+		assertEquals(1, listener.pauses.size());
+		Map<String, Mixed> vars = listener.pauses.get(0).getVariables();
+		// @x and @y should be set; @z has not executed yet
+		assertEquals("42", vars.get("@x").val());
+		assertEquals("hello", vars.get("@y").val());
+
+		// Clean up: continue to completion
+		debugCtx.setStepMode(DebugContext.StepMode.NONE, 0, Target.UNKNOWN);
+		Script.resumeEval(listener.snapshot(0));
+		assertTrue(listener.completed);
+	}
+
+	@Test
+	public void testMultipleBreakpoints() throws Exception {
+		String script = "@x = 1\n@y = 2\n@z = 3";
+		TestDebugListener listener = new TestDebugListener();
+		DebugContext debugCtx = new DebugContext(listener, DebugContext.ThreadingMode.ASYNCHRONOUS,
+				Thread.currentThread());
+		debugCtx.addBreakpoint(new Breakpoint(TEST_FILE, 1));
+		debugCtx.addBreakpoint(new Breakpoint(TEST_FILE, 3));
+
+		executeWithDebugger(script, debugCtx);
+
+		// First breakpoint
+		assertEquals(1, listener.pauses.size());
+		assertEquals(1, listener.pauses.get(0).getPauseTarget().line());
+
+		// Continue to next breakpoint
+		debugCtx.setStepMode(DebugContext.StepMode.NONE, 0, Target.UNKNOWN);
+		Script.resumeEval(listener.snapshot(0));
+
+		assertEquals(2, listener.pauses.size());
+		assertEquals(3, listener.pauses.get(1).getPauseTarget().line());
+
+		// Continue to completion
+		debugCtx.setStepMode(DebugContext.StepMode.NONE, 0, Target.UNKNOWN);
+		Script.resumeEval(listener.snapshot(1));
+		assertTrue(listener.completed);
+	}
+
+	@Test
+	public void testDisconnect() throws Exception {
+		String script = "@x = 1\n@y = 2\n@z = 3";
+		TestDebugListener listener = new TestDebugListener();
+		DebugContext debugCtx = new DebugContext(listener, DebugContext.ThreadingMode.ASYNCHRONOUS,
+				Thread.currentThread());
+		debugCtx.addBreakpoint(new Breakpoint(TEST_FILE, 1));
+		debugCtx.addBreakpoint(new Breakpoint(TEST_FILE, 2));
+		debugCtx.addBreakpoint(new Breakpoint(TEST_FILE, 3));
+
+		executeWithDebugger(script, debugCtx);
+
+		// Hit first breakpoint
+		assertEquals(1, listener.pauses.size());
+
+		// Disconnect and resume - should run to completion without more pauses
+		debugCtx.disconnect();
+		Script.resumeEval(listener.snapshot(0));
+
+		assertTrue(listener.completed);
+		assertEquals(1, listener.pauses.size());
+	}
+
+	@Test
+	public void testStepIntoProc() throws Exception {
+		String script = "proc _foo() {\n\t@a = 10\n\treturn(@a)\n}\n@result = _foo()\n@done = true";
+		TestDebugListener listener = new TestDebugListener();
+		DebugContext debugCtx = new DebugContext(listener, DebugContext.ThreadingMode.ASYNCHRONOUS,
+				Thread.currentThread());
+		debugCtx.addBreakpoint(new Breakpoint(TEST_FILE, 5));
+
+		executeWithDebugger(script, debugCtx);
+
+		// Should pause at line 5 (_foo() call)
+		assertEquals(1, listener.pauses.size());
+		PausedState pause1 = listener.pauses.get(0);
+		assertEquals(5, pause1.getPauseTarget().line());
+
+		// Step into
+		debugCtx.setStepMode(DebugContext.StepMode.INTO,
+				pause1.getUserCallDepth(), pause1.getPauseTarget());
+		Script.resumeEval(listener.snapshot(0));
+
+		// Should pause inside the proc body (line 2)
+		assertEquals(2, listener.pauses.size());
+		PausedState pause2 = listener.pauses.get(1);
+		assertEquals(2, pause2.getPauseTarget().line());
+
+		// Continue to completion
+		debugCtx.setStepMode(DebugContext.StepMode.NONE, 0, Target.UNKNOWN);
+		Script.resumeEval(listener.snapshot(1));
+		assertTrue(listener.completed);
+	}
+
+	@Test
+	public void testStepOverProc() throws Exception {
+		String script = "proc _foo() {\n\t@a = 10\n\treturn(@a)\n}\n@result = _foo()\n@done = true";
+		TestDebugListener listener = new TestDebugListener();
+		DebugContext debugCtx = new DebugContext(listener, DebugContext.ThreadingMode.ASYNCHRONOUS,
+				Thread.currentThread());
+		debugCtx.addBreakpoint(new Breakpoint(TEST_FILE, 5));
+
+		executeWithDebugger(script, debugCtx);
+
+		PausedState pause1 = listener.pauses.get(0);
+		assertEquals(5, pause1.getPauseTarget().line());
+
+		// Step over
+		debugCtx.setStepMode(DebugContext.StepMode.OVER,
+				pause1.getUserCallDepth(), pause1.getPauseTarget());
+		Script.resumeEval(listener.snapshot(0));
+
+		// Should pause at line 6, having skipped into the proc
+		assertEquals(2, listener.pauses.size());
+		PausedState pause2 = listener.pauses.get(1);
+		assertEquals(6, pause2.getPauseTarget().line());
+
+		// Continue to completion
+		debugCtx.setStepMode(DebugContext.StepMode.NONE, 0, Target.UNKNOWN);
+		Script.resumeEval(listener.snapshot(1));
+		assertTrue(listener.completed);
+	}
+
+	@Test
+	public void testStepOut() throws Exception {
+		String script = "proc _foo() {\n\t@a = 10\n\treturn(@a)\n}\n@result = _foo()\n@done = true";
+		TestDebugListener listener = new TestDebugListener();
+		DebugContext debugCtx = new DebugContext(listener, DebugContext.ThreadingMode.ASYNCHRONOUS,
+				Thread.currentThread());
+		debugCtx.addBreakpoint(new Breakpoint(TEST_FILE, 2));
+
+		executeWithDebugger(script, debugCtx);
+
+		// Should pause inside proc at line 2
+		assertEquals(1, listener.pauses.size());
+		PausedState pause1 = listener.pauses.get(0);
+		assertEquals(2, pause1.getPauseTarget().line());
+		int depthInside = pause1.getUserCallDepth();
+		assertTrue("Should be inside proc (depth > 0)", depthInside > 0);
+
+		// Step out
+		debugCtx.setStepMode(DebugContext.StepMode.OUT,
+				depthInside, pause1.getPauseTarget());
+		Script.resumeEval(listener.snapshot(0));
+
+		// Should pause after returning from the proc
+		assertEquals(2, listener.pauses.size());
+		PausedState pause2 = listener.pauses.get(1);
+		assertTrue("Should be at lower depth after step out",
+				pause2.getUserCallDepth() < depthInside);
+
+		// Continue to completion
+		debugCtx.setStepMode(DebugContext.StepMode.NONE, 0, Target.UNKNOWN);
+		Script.resumeEval(listener.snapshot(1));
+		assertTrue(listener.completed);
+	}
+
+	@Test
+	public void testCallStackInspection() throws Exception {
+		String script = "proc _foo() {\n\t@a = 10\n\treturn(@a)\n}\n@result = _foo()";
+		TestDebugListener listener = new TestDebugListener();
+		DebugContext debugCtx = new DebugContext(listener, DebugContext.ThreadingMode.ASYNCHRONOUS,
+				Thread.currentThread());
+		debugCtx.addBreakpoint(new Breakpoint(TEST_FILE, 2));
+
+		executeWithDebugger(script, debugCtx);
+
+		assertEquals(1, listener.pauses.size());
+		PausedState pause = listener.pauses.get(0);
+		List<StackTraceFrame> callStack = pause.getCallStack();
+		assertFalse("Call stack should not be empty inside proc", callStack.isEmpty());
+		// Procedure names in the stack trace include the "proc " prefix
+		assertTrue("Expected proc name to contain _foo",
+				callStack.get(0).getProcedureName().contains("_foo"));
+
+		// Clean up
+		debugCtx.setStepMode(DebugContext.StepMode.NONE, 0, Target.UNKNOWN);
+		Script.resumeEval(listener.snapshot(0));
+	}
+
+	@Test
+	public void testResumeCount() throws Exception {
+		String script = "@x = 1\n@y = 2\n@z = 3";
+		TestDebugListener listener = new TestDebugListener();
+		DebugContext debugCtx = new DebugContext(listener, DebugContext.ThreadingMode.ASYNCHRONOUS,
+				Thread.currentThread());
+		debugCtx.addBreakpoint(new Breakpoint(TEST_FILE, 1));
+		debugCtx.addBreakpoint(new Breakpoint(TEST_FILE, 3));
+
+		executeWithDebugger(script, debugCtx);
+		assertEquals(0, listener.resumeCount);
+
+		debugCtx.setStepMode(DebugContext.StepMode.NONE, 0, Target.UNKNOWN);
+		Script.resumeEval(listener.snapshot(0));
+		assertEquals(1, listener.resumeCount);
+
+		debugCtx.setStepMode(DebugContext.StepMode.NONE, 0, Target.UNKNOWN);
+		Script.resumeEval(listener.snapshot(1));
+		assertEquals(2, listener.resumeCount);
+		assertTrue(listener.completed);
+	}
+
+	@Test
+	public void testSyncModeKeepsSameThread() throws Exception {
+		String script = "@x = 1\n@y = 2\n@z = 3";
+
+		// Track which thread hits the breakpoint callback
+		AtomicLong pausedThreadId = new AtomicLong(-1);
+		AtomicReference<Thread> pausedThread = new AtomicReference<>();
+		CountDownLatch pauseReached = new CountDownLatch(1);
+		CountDownLatch resumeReached = new CountDownLatch(1);
+
+		TestDebugListener listener = new TestDebugListener() {
+			@Override
+			public void onPaused(PausedState state) {
+				super.onPaused(state);
+				pausedThreadId.set(Thread.currentThread().getId());
+				pausedThread.set(Thread.currentThread());
+				pauseReached.countDown();
+			}
+
+			@Override
+			public void onResumed() {
+				super.onResumed();
+				resumeReached.countDown();
+			}
+		};
+
+		DebugContext debugCtx = new DebugContext(listener, DebugContext.ThreadingMode.SYNCHRONOUS,
+				Thread.currentThread());
+		debugCtx.addBreakpoint(new Breakpoint(TEST_FILE, 2));
+
+		// Run the script on a dedicated thread (sync mode blocks, so we can't
+		// run it on the test thread).
+		AtomicLong executionThreadId = new AtomicLong(-1);
+		AtomicReference<Mixed> resultRef = new AtomicReference<>();
+		AtomicReference<Exception> errorRef = new AtomicReference<>();
+		Thread execThread = new Thread(() -> {
+			executionThreadId.set(Thread.currentThread().getId());
+			try {
+				resultRef.set(executeWithDebugger(script, debugCtx));
+			} catch(Exception e) {
+				errorRef.set(e);
+			}
+		});
+		debugCtx.setMainThread(execThread);
+		execThread.start();
+
+		// Wait for the breakpoint to be hit
+		assertTrue("Breakpoint was not hit within timeout",
+				pauseReached.await(10, TimeUnit.SECONDS));
+
+		// The onPaused callback should have been called ON the execution thread
+		// (sync mode blocks in place, so the callback runs on the interpreter thread)
+		assertEquals("onPaused should run on the interpreter thread",
+				executionThreadId.get(), pausedThreadId.get());
+
+		// Resume the paused thread (not the test thread)
+		debugCtx.getThreadState(pausedThread.get())
+				.setStepMode(DebugContext.StepMode.NONE, 0, Target.UNKNOWN);
+		debugCtx.getThreadState(pausedThread.get()).resume();
+		assertTrue("Resume was not processed within timeout",
+				resumeReached.await(10, TimeUnit.SECONDS));
+
+		execThread.join(10_000);
+		assertFalse("Execution thread should have finished", execThread.isAlive());
+		if(errorRef.get() != null) {
+			throw errorRef.get();
+		}
+
+		// In sync mode the script runs to completion and returns a real result, not DEBUGGER_PAUSED
+		assertFalse("Sync mode should not return DEBUGGER_PAUSED",
+				Script.isDebuggerPaused(resultRef.get()));
+		assertTrue(listener.completed);
+		assertEquals(1, listener.resumeCount);
+	}
+
+	@Test
+	public void testBackgroundThreadUsesSyncMode() throws Exception {
+		// In ASYNCHRONOUS mode, the main thread uses async behavior, but threads
+		// spawned by x_new_thread should use sync mode (block in place) since
+		// they are not the main execution thread.
+		String script = "x_new_thread('bg', closure() {\n\t@a = 1\n\t@b = 2\n})";
+
+		AtomicLong pausedThreadId = new AtomicLong(-1);
+		AtomicReference<Thread> pausedThread = new AtomicReference<>();
+		CountDownLatch pauseReached = new CountDownLatch(1);
+		CountDownLatch resumeReached = new CountDownLatch(1);
+
+		TestDebugListener listener = new TestDebugListener() {
+			@Override
+			public void onPaused(PausedState state) {
+				super.onPaused(state);
+				pausedThreadId.set(Thread.currentThread().getId());
+				pausedThread.set(Thread.currentThread());
+				pauseReached.countDown();
+			}
+
+			@Override
+			public void onResumed() {
+				super.onResumed();
+				resumeReached.countDown();
+			}
+		};
+
+		DebugContext debugCtx = new DebugContext(listener, DebugContext.ThreadingMode.ASYNCHRONOUS,
+				Thread.currentThread());
+		// Breakpoint inside the closure (line 2 = @a = 1, runs on background thread)
+		debugCtx.addBreakpoint(new Breakpoint(TEST_FILE, 2));
+
+		// Main thread runs x_new_thread and returns without hitting breakpoints
+		Mixed result = executeWithDebugger(script, debugCtx);
+		assertFalse("Main thread should not be paused",
+				Script.isDebuggerPaused(result));
+
+		// Wait for the background thread to hit the breakpoint
+		assertTrue("Background thread breakpoint was not hit within timeout",
+				pauseReached.await(10, TimeUnit.SECONDS));
+
+		// onPaused was called ON the background thread (sync mode blocks in place),
+		// not on the main/test thread
+		assertNotEquals("onPaused should run on the background thread",
+				Thread.currentThread().getId(), pausedThreadId.get());
+
+		// Resume the background thread (must target the actual paused thread, not the test thread)
+		debugCtx.getThreadState(pausedThread.get())
+				.setStepMode(DebugContext.StepMode.NONE, 0, Target.UNKNOWN);
+		debugCtx.getThreadState(pausedThread.get()).resume();
+		assertTrue("Resume was not processed within timeout",
+				resumeReached.await(10, TimeUnit.SECONDS));
+
+		assertEquals(1, listener.resumeCount);
+	}
+
+	// ---- DAP integration test helpers ----
+
+	/**
+	 * Helper that sets up a DAP server, connects a mock client, compiles a script,
+	 * sets breakpoints, and returns everything needed to drive a DAP test scenario.
+	 */
+	private static class DAPTestHarness implements AutoCloseable {
+		final MSDebugServer server;
+		final IDebugProtocolServer proxy;
+		final Socket clientSocket;
+		final AtomicInteger stopCount = new AtomicInteger(0);
+		final List<CountDownLatch> stopLatches = new ArrayList<>();
+		final CountDownLatch terminated = new CountDownLatch(1);
+		final AtomicReference<StoppedEventArguments> lastStopArgs = new AtomicReference<>();
+		private boolean closed = false;
+
+		DAPTestHarness(String script, int[] breakpointLines,
+				DebugContext.ThreadingMode mode) throws Exception {
+			// Create enough latches for expected stops
+			for(int i = 0; i < 10; i++) {
+				stopLatches.add(new CountDownLatch(1));
+			}
+
+			IDebugProtocolClient mockClient = new IDebugProtocolClient() {
+				@Override
+				public void stopped(StoppedEventArguments args) {
+					lastStopArgs.set(args);
+					int idx = stopCount.getAndIncrement();
+					if(idx < stopLatches.size()) {
+						stopLatches.get(idx).countDown();
+					}
+				}
+
+				@Override
+				public void terminated(org.eclipse.lsp4j.debug.TerminatedEventArguments args) {
+					terminated.countDown();
+				}
+			};
+
+			server = new MSDebugServer();
+			Environment env = Static.GenerateStandaloneEnvironment();
+			env = env.cloneAndAdd(new CommandHelperEnvironment());
+			env = server.startListening(0, env, false, mode);
+			int port = server.getPort();
+			assertTrue("Server should be listening", port > 0);
+
+			clientSocket = new Socket("localhost", port);
+			Launcher<IDebugProtocolServer> clientLauncher = DSPLauncher.createClientLauncher(
+					mockClient, clientSocket.getInputStream(), clientSocket.getOutputStream());
+			proxy = clientLauncher.getRemoteProxy();
+			clientLauncher.startListening();
+
+			proxy.initialize(new InitializeRequestArguments()).get(5, TimeUnit.SECONDS);
+
+			// Set breakpoints
+			SetBreakpointsArguments bpArgs = new SetBreakpointsArguments();
+			Source source = new Source();
+			source.setPath(TEST_FILE.getPath());
+			bpArgs.setSource(source);
+			SourceBreakpoint[] sbps = new SourceBreakpoint[breakpointLines.length];
+			for(int i = 0; i < breakpointLines.length; i++) {
+				sbps[i] = new SourceBreakpoint();
+				sbps[i].setLine(breakpointLines[i]);
+			}
+			bpArgs.setBreakpoints(sbps);
+			proxy.setBreakpoints(bpArgs).get(5, TimeUnit.SECONDS);
+
+			// Compile and run
+			StaticAnalysis analysis = new StaticAnalysis(true);
+			analysis.setLocalEnable(false);
+			TokenStream tokens = MethodScriptCompiler.lex(script, env, TEST_FILE, true);
+			ParseTree tree = MethodScriptCompiler.compile(tokens, env, envs, analysis);
+			server.runScript(tree, env, null);
+		}
+
+		boolean awaitStop(int index, long seconds) throws InterruptedException {
+			return stopLatches.get(index).await(seconds, TimeUnit.SECONDS);
+		}
+
+		void stepOver() throws Exception {
+			NextArguments args = new NextArguments();
+			args.setThreadId(1);
+			proxy.next(args).get(5, TimeUnit.SECONDS);
+		}
+
+		void continue_() throws Exception {
+			ContinueArguments args = new ContinueArguments();
+			args.setThreadId(1);
+			proxy.continue_(args).get(5, TimeUnit.SECONDS);
+		}
+
+		@Override
+		public void close() throws Exception {
+			if(!closed) {
+				closed = true;
+				clientSocket.close();
+				server.shutdown();
+			}
+		}
+	}
+
+	// ---- DAP integration tests (each runs in both sync and async modes) ----
+
+	/**
+	 * Step-over a simple 3-line script: hit breakpoint at line 1, step over to
+	 * line 2, then continue to completion.
+	 */
+	@Test
+	public void testDAPStepOverSync() throws Exception {
+		dapStepOverSimple(DebugContext.ThreadingMode.SYNCHRONOUS);
+	}
+
+	@Test
+	public void testDAPStepOverAsync() throws Exception {
+		dapStepOverSimple(DebugContext.ThreadingMode.ASYNCHRONOUS);
+	}
+
+	private void dapStepOverSimple(DebugContext.ThreadingMode mode) throws Exception {
+		String script = "@x = 1\n@y = 2\n@z = 3";
+		try(DAPTestHarness h = new DAPTestHarness(script, new int[]{1}, mode)) {
+			assertTrue("Breakpoint at line 1 was not hit",
+					h.awaitStop(0, 5));
+			h.stepOver();
+			assertTrue("Step-over should pause at next line",
+					h.awaitStop(1, 5));
+			h.continue_();
+			assertTrue("Script should complete",
+					h.terminated.await(5, TimeUnit.SECONDS));
+		}
+	}
+
+	/**
+	 * Step-over a line that spawns a new thread (x_new_thread). The debugger
+	 * should pause at the next line after x_new_thread, not run to completion.
+	 */
+	@Test
+	public void testDAPStepOverNewThreadSync() throws Exception {
+		dapStepOverNewThread(DebugContext.ThreadingMode.SYNCHRONOUS);
+	}
+
+	@Test
+	public void testDAPStepOverNewThreadAsync() throws Exception {
+		dapStepOverNewThread(DebugContext.ThreadingMode.ASYNCHRONOUS);
+	}
+
+	private void dapStepOverNewThread(DebugContext.ThreadingMode mode) throws Exception {
+		String script = "sys_out('before')\n"
+				+ "x_new_thread('bg', closure() {\n"
+				+ "  while(true) {\n"
+				+ "    sleep(0.1)\n"
+				+ "  }\n"
+				+ "})\n"
+				+ "sys_out('after')";
+		try(DAPTestHarness h = new DAPTestHarness(script, new int[]{1}, mode)) {
+			assertTrue("Breakpoint at line 1 was not hit",
+					h.awaitStop(0, 5));
+			h.stepOver();
+			assertTrue("Step-over should pause at x_new_thread line",
+					h.awaitStop(1, 5));
+			h.stepOver();
+			assertTrue("Step-over x_new_thread should pause at next line",
+					h.awaitStop(2, 5));
+		}
+	}
+
+	@Test
+	public void testLogPoint() throws Exception {
+		String script = "@x = 42\n@y = @x + 1\n@z = @y + 1";
+		TestDebugListener listener = new TestDebugListener();
+		DebugContext debugCtx = new DebugContext(listener, DebugContext.ThreadingMode.ASYNCHRONOUS,
+				Thread.currentThread());
+		debugCtx.addBreakpoint(new Breakpoint(TEST_FILE, 2, null, 0, "x is {@x}"));
+
+		executeWithDebugger(script, debugCtx);
+
+		// Log point should not cause a pause
+		assertEquals(0, listener.pauses.size());
+		// But should have logged the message
+		assertEquals(1, listener.logMessages.size());
+		assertEquals("x is 42", listener.logMessages.get(0));
+		assertTrue(listener.completed);
+	}
+}