diff --git a/pom.xml b/pom.xml
index 71290718c..056ea0489 100644
--- a/pom.xml
+++ b/pom.xml
@@ -133,8 +133,8 @@
 	<properties>
 		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 		<maven.test.failure.ignore>true</maven.test.failure.ignore>
-		<maven.compiler.source>16</maven.compiler.source>
-		<maven.compiler.target>16</maven.compiler.target>
+		<maven.compiler.source>21</maven.compiler.source>
+		<maven.compiler.target>21</maven.compiler.target>
 	</properties>
 	<repositories>
 		<repository>
@@ -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>
@@ -489,7 +494,7 @@
 				<version>3.12.1</version>
 				<configuration>
 					<showDeprecation>true</showDeprecation>
-					<release>16</release>
+					<release>21</release>
 					<compilerArgs>
 						<arg>-XDignore.symbol.file</arg>
 						<arg>-parameters</arg>
@@ -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/Common/RSAEncrypt.java b/src/main/java/com/laytonsmith/PureUtilities/Common/RSAEncrypt.java
index 4c8dd5f76..c9f84e2b8 100644
--- a/src/main/java/com/laytonsmith/PureUtilities/Common/RSAEncrypt.java
+++ b/src/main/java/com/laytonsmith/PureUtilities/Common/RSAEncrypt.java
@@ -1,17 +1,20 @@
 package com.laytonsmith.PureUtilities.Common;
 
-import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
+import java.io.DataOutputStream;
 import java.io.IOException;
-import java.io.ObjectInputStream;
-import java.io.ObjectOutputStream;
+import java.nio.ByteBuffer;
 import java.security.InvalidKeyException;
 import java.security.Key;
+import java.security.KeyFactory;
 import java.security.KeyPair;
 import java.security.KeyPairGenerator;
 import java.security.NoSuchAlgorithmException;
 import java.security.PrivateKey;
 import java.security.PublicKey;
+import java.security.interfaces.RSAPublicKey;
+import java.security.spec.InvalidKeySpecException;
+import java.security.spec.PKCS8EncodedKeySpec;
 import java.util.Objects;
 import javax.crypto.BadPaddingException;
 import javax.crypto.Cipher;
@@ -21,82 +24,113 @@
 
 /**
  * Given a public/private key pair, this class uses RSA to encrypt/decrypt data.
+ *
+ * <p>Keys are stored in standard formats:
+ * <ul>
+ *   <li>Private key: PKCS#8 PEM ({@code -----BEGIN PRIVATE KEY-----})</li>
+ *   <li>Public key: OpenSSH format ({@code ssh-rsa <base64> <label>})</li>
+ * </ul>
+ * These formats are interoperable with OpenSSH, Node.js crypto, and other standard tools.
  */
 public class RSAEncrypt {
 
-	/**
-	 * The RSA algorithm key.
-	 */
 	private static final String ALGORITHM = "RSA";
+	private static final int KEY_SIZE = 2048;
 
 	/**
-	 * Generates a new key, and stores the value in the RSA
+	 * Generates a new RSA key pair.
 	 *
 	 * @param label The label that will be associated with the public key
-	 * @return
+	 *     (e.g. "user@host")
+	 * @return A new RSAEncrypt instance with both keys
 	 */
 	public static RSAEncrypt generateKey(String label) {
 		KeyPairGenerator keyGen;
 		try {
 			keyGen = KeyPairGenerator.getInstance(ALGORITHM);
-		} catch (NoSuchAlgorithmException ex) {
+		} catch(NoSuchAlgorithmException ex) {
 			throw new RuntimeException(ex);
 		}
-		keyGen.initialize(1024);
+		keyGen.initialize(KEY_SIZE);
 		KeyPair key = keyGen.generateKeyPair();
-		RSAEncrypt enc = new RSAEncrypt(toString(key.getPrivate()), toString(key.getPublic(), label));
+		RSAEncrypt enc = new RSAEncrypt(
+				privateKeyToPem(key.getPrivate()),
+				publicKeyToSsh(key.getPublic(), label));
 		return enc;
 	}
 
 	/**
-	 * Given a public key and a label, produces an ssh compatible rsa public key string.
-	 *
-	 * @param key
-	 * @param label
-	 * @return
+	 * Encodes a private key as a PKCS#8 PEM string.
+	 */
+	private static String privateKeyToPem(PrivateKey key) {
+		String base64 = Base64.encodeBase64String(key.getEncoded());
+		StringBuilder sb = new StringBuilder();
+		sb.append("-----BEGIN PRIVATE KEY-----");
+		for(int i = 0; i < base64.length(); i++) {
+			if(i % 64 == 0) {
+				sb.append(StringUtils.nl());
+			}
+			sb.append(base64.charAt(i));
+		}
+		sb.append(StringUtils.nl()).append("-----END PRIVATE KEY-----").append(StringUtils.nl());
+		return sb.toString();
+	}
+
+	/**
+	 * Encodes a public key in OpenSSH format: {@code ssh-rsa <base64> <label>}.
+	 * The base64 payload uses the SSH wire format (RFC 4253):
+	 * string "ssh-rsa", mpint e, mpint n.
 	 */
-	public static String toString(PublicKey key, String label) {
+	private static String publicKeyToSsh(PublicKey key, String label) {
 		Objects.requireNonNull(label);
-		ByteArrayOutputStream pubBOS = new ByteArrayOutputStream();
+		RSAPublicKey rsaKey = (RSAPublicKey) key;
 		try {
-			ObjectOutputStream publicKeyOS = new ObjectOutputStream(pubBOS);
-			publicKeyOS.writeObject(key);
-		} catch (IOException ex) {
+			ByteArrayOutputStream buf = new ByteArrayOutputStream();
+			DataOutputStream dos = new DataOutputStream(buf);
+			byte[] typeBytes = "ssh-rsa".getBytes("UTF-8");
+			dos.writeInt(typeBytes.length);
+			dos.write(typeBytes);
+			byte[] eBytes = rsaKey.getPublicExponent().toByteArray();
+			dos.writeInt(eBytes.length);
+			dos.write(eBytes);
+			byte[] nBytes = rsaKey.getModulus().toByteArray();
+			dos.writeInt(nBytes.length);
+			dos.write(nBytes);
+			dos.flush();
+			return "ssh-rsa " + Base64.encodeBase64String(buf.toByteArray()) + " " + label;
+		} catch(IOException ex) {
 			throw new RuntimeException(ex);
 		}
-		String publicKey = Base64.encodeBase64String(pubBOS.toByteArray());
-		publicKey = "ssh-rsa " + publicKey + " " + label;
-		return publicKey;
 	}
 
 	/**
-	 * Given a private key, produces an ssh compatible rsa private key string.
-	 *
-	 * @param key
-	 * @return
+	 * Parses an OpenSSH public key string and returns the PublicKey.
+	 * Reads the SSH wire format: string "ssh-rsa", mpint e, mpint n.
 	 */
-	private static String toString(PrivateKey key) {
-		ByteArrayOutputStream privBOS = new ByteArrayOutputStream();
-		ObjectOutputStream privateKeyOS;
+	private static PublicKey sshToPublicKey(String base64Part) {
+		byte[] decoded = Base64.decodeBase64(base64Part);
+		ByteBuffer bb = ByteBuffer.wrap(decoded);
+		// Read key type string
+		int typeLen = bb.getInt();
+		byte[] typeBytes = new byte[typeLen];
+		bb.get(typeBytes);
+		// Read exponent
+		int eLen = bb.getInt();
+		byte[] eBytes = new byte[eLen];
+		bb.get(eBytes);
+		java.math.BigInteger e = new java.math.BigInteger(eBytes);
+		// Read modulus
+		int nLen = bb.getInt();
+		byte[] nBytes = new byte[nLen];
+		bb.get(nBytes);
+		java.math.BigInteger n = new java.math.BigInteger(nBytes);
 		try {
-			privateKeyOS = new ObjectOutputStream(privBOS);
-			privateKeyOS.writeObject(key);
-		} catch (IOException ex) {
+			java.security.spec.RSAPublicKeySpec spec = new java.security.spec.RSAPublicKeySpec(n, e);
+			KeyFactory kf = KeyFactory.getInstance(ALGORITHM);
+			return kf.generatePublic(spec);
+		} catch(NoSuchAlgorithmException | InvalidKeySpecException ex) {
 			throw new RuntimeException(ex);
 		}
-		String privateKey = Base64.encodeBase64String(privBOS.toByteArray());
-
-		StringBuilder privBuilder = new StringBuilder();
-		privBuilder.append("-----BEGIN RSA PRIVATE KEY-----");
-		for(int i = 0; i < privateKey.length(); i++) {
-			if(i % 64 == 0) {
-				privBuilder.append(StringUtils.nl());
-			}
-			privBuilder.append(privateKey.charAt(i));
-		}
-		privBuilder.append(StringUtils.nl()).append("-----END RSA PRIVATE KEY-----").append(StringUtils.nl());
-		privateKey = privBuilder.toString();
-		return privateKey;
 	}
 
 	private PublicKey publicKey;
@@ -104,57 +138,52 @@ private static String toString(PrivateKey key) {
 	private String label;
 
 	/**
-	 * Creates a new RSAEncrypt object, based on the ssh compatible private/public key pair. Only one key needs to be
-	 * provided. If so, only those methods for the key provided will work.
+	 * Creates a new RSAEncrypt object from PEM/SSH key strings. Only one key needs to be
+	 * provided. If so, only the methods for that key will work.
+	 *
+	 * <p>The private key should be PKCS#8 PEM format ({@code -----BEGIN PRIVATE KEY-----}).
+	 * The public key should be OpenSSH format ({@code ssh-rsa <base64> <label>}).
 	 *
-	 * @param privateKey
-	 * @param publicKey
-	 * @throws IllegalArgumentException If the keys are not the correct type. They must be ssh compatible.
+	 * @param privateKey The private key PEM string, or null
+	 * @param publicKey The public key SSH string, or null
+	 * @throws IllegalArgumentException If a key string cannot be parsed
 	 */
 	public RSAEncrypt(String privateKey, String publicKey) throws IllegalArgumentException {
 		if(privateKey != null) {
-			//private key processing
-			//replace all newlines with nothing
 			privateKey = privateKey.replaceAll("\r", "");
 			privateKey = privateKey.replaceAll("\n", "");
-			//Remove the BEGIN/END tags
+			privateKey = privateKey.replace("-----BEGIN PRIVATE KEY-----", "");
+			privateKey = privateKey.replace("-----END PRIVATE KEY-----", "");
+			// Also strip PKCS#1 headers for compatibility with ssh-keygen keys
 			privateKey = privateKey.replace("-----BEGIN RSA PRIVATE KEY-----", "");
 			privateKey = privateKey.replace("-----END RSA PRIVATE KEY-----", "");
-			ObjectInputStream privOIS;
 			try {
-				privOIS = new ObjectInputStream(new ByteArrayInputStream(Base64.decodeBase64(privateKey)));
-				this.privateKey = (PrivateKey) privOIS.readObject();
-			} catch (IOException | ClassNotFoundException ex) {
-				throw new RuntimeException(ex);
+				byte[] keyBytes = Base64.decodeBase64(privateKey);
+				PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(keyBytes);
+				KeyFactory kf = KeyFactory.getInstance(ALGORITHM);
+				this.privateKey = kf.generatePrivate(spec);
+			} catch(NoSuchAlgorithmException | InvalidKeySpecException ex) {
+				throw new IllegalArgumentException("Failed to parse private key", ex);
 			}
 		}
 
 		if(publicKey != null) {
-			//public key processing
-			String[] split = publicKey.split(" ");
-			if(split.length != 3) {
-				throw new IllegalArgumentException("Invalid public key passed in.");
+			String[] split = publicKey.trim().split("\\s+");
+			if(split.length < 2) {
+				throw new IllegalArgumentException("Invalid public key format.");
 			}
 			if(!"ssh-rsa".equals(split[0])) {
-				throw new IllegalArgumentException("Invalid public key type. Expecting ssh-rsa, but found \"" + split[0] + "\"");
-			}
-			this.label = split[2];
-			ObjectInputStream pubOIS;
-			try {
-				pubOIS = new ObjectInputStream(new ByteArrayInputStream(Base64.decodeBase64(split[1])));
-				this.publicKey = (PublicKey) pubOIS.readObject();
-			} catch (IOException | ClassNotFoundException ex) {
-				throw new RuntimeException(ex);
+				throw new IllegalArgumentException(
+						"Invalid public key type. Expecting ssh-rsa, but found \""
+						+ split[0] + "\"");
 			}
+			this.label = split.length >= 3 ? split[2] : "";
+			this.publicKey = sshToPublicKey(split[1]);
 		}
 	}
 
 	/**
-	 * Encrypts the data with the public key, which can be decrypted with the private key. This is only valid if the
-	 * public key was provided.
-	 *
-	 * @param data
-	 * @return
+	 * Encrypts the data with the public key, which can be decrypted with the private key.
 	 */
 	public byte[] encryptWithPublic(byte[] data) {
 		Objects.requireNonNull(publicKey);
@@ -162,12 +191,7 @@ public byte[] encryptWithPublic(byte[] data) {
 	}
 
 	/**
-	 * Encrypts the data with the private key, which can be decrypted with the public key. This is only valid if the
-	 * private key was provided.
-	 *
-	 * @param data
-	 * @return
-	 * @throws InvalidKeyException
+	 * Encrypts the data with the private key, which can be decrypted with the public key.
 	 */
 	public byte[] encryptWithPrivate(byte[] data) throws InvalidKeyException {
 		Objects.requireNonNull(privateKey);
@@ -175,11 +199,7 @@ public byte[] encryptWithPrivate(byte[] data) throws InvalidKeyException {
 	}
 
 	/**
-	 * Decrypts the data with the public key, which will have been encrypted with the private key. This is only valid if
-	 * the public key was provided.
-	 *
-	 * @param data
-	 * @return
+	 * Decrypts the data with the public key, which will have been encrypted with the private key.
 	 */
 	public byte[] decryptWithPublic(byte[] data) {
 		Objects.requireNonNull(publicKey);
@@ -187,60 +207,40 @@ public byte[] decryptWithPublic(byte[] data) {
 	}
 
 	/**
-	 * Decrypts the data with the private key, which will have been encrypted with the public key. This is only valid if
-	 * the private key was provided.
-	 *
-	 * @param data
-	 * @return
+	 * Decrypts the data with the private key, which will have been encrypted with the public key.
 	 */
 	public byte[] decryptWithPrivate(byte[] data) {
 		Objects.requireNonNull(privateKey);
 		return crypt(data, privateKey, Cipher.DECRYPT_MODE);
 	}
 
-	/**
-	 * Utility method that actually does the de/encrypting.
-	 *
-	 * @param data
-	 * @param key
-	 * @param cryptMode
-	 * @return
-	 */
 	private byte[] crypt(byte[] data, Key key, int cryptMode) {
-		byte[] cipherValue = null;
-		Cipher cipher;
 		try {
-			cipher = Cipher.getInstance(ALGORITHM);
+			Cipher cipher = Cipher.getInstance(ALGORITHM);
 			cipher.init(cryptMode, key);
-			cipherValue = cipher.doFinal(data);
-		} catch (InvalidKeyException | IllegalBlockSizeException | BadPaddingException | NoSuchAlgorithmException | NoSuchPaddingException ex) {
+			return cipher.doFinal(data);
+		} catch(InvalidKeyException | IllegalBlockSizeException | BadPaddingException
+				| NoSuchAlgorithmException | NoSuchPaddingException ex) {
 			throw new RuntimeException(ex);
 		}
-		return cipherValue;
 	}
 
 	/**
-	 * Returns the private key string.
-	 *
-	 * @return
+	 * Returns the private key as a PKCS#8 PEM string.
 	 */
 	public String getPrivateKey() {
-		return toString(privateKey);
+		return privateKeyToPem(privateKey);
 	}
 
 	/**
-	 * Returns the public key string.
-	 *
-	 * @return
+	 * Returns the public key as an OpenSSH format string.
 	 */
 	public String getPublicKey() {
-		return toString(publicKey, label);
+		return publicKeyToSsh(publicKey, label);
 	}
 
 	/**
 	 * Returns the label on the public key.
-	 *
-	 * @return
 	 */
 	public String getLabel() {
 		return label;
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/commandhelper/CommandHelperFileLocations.java b/src/main/java/com/laytonsmith/commandhelper/CommandHelperFileLocations.java
index c1fdb789b..16d65c584 100644
--- a/src/main/java/com/laytonsmith/commandhelper/CommandHelperFileLocations.java
+++ b/src/main/java/com/laytonsmith/commandhelper/CommandHelperFileLocations.java
@@ -31,4 +31,13 @@ public File getUpgradeLogFile() {
 		return new File(getCacheDirectory(), "upgradeLog.json");
 	}
 
+	/**
+	 * Returns the location of the authorized_debug_keys file.
+	 * @return
+	 */
+	@Override
+	public File getAuthorizedDebugKeysFile() {
+		return new File(getConfigDirectory(), "authorized_debug_keys");
+	}
+
 }
diff --git a/src/main/java/com/laytonsmith/commandhelper/CommandHelperPlugin.java b/src/main/java/com/laytonsmith/commandhelper/CommandHelperPlugin.java
index f82f7e120..c7840f2ba 100644
--- a/src/main/java/com/laytonsmith/commandhelper/CommandHelperPlugin.java
+++ b/src/main/java/com/laytonsmith/commandhelper/CommandHelperPlugin.java
@@ -66,9 +66,15 @@
 import com.laytonsmith.core.UpgradeLog;
 import com.laytonsmith.core.apps.AppsApiUtil;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.environments.DebugContext;
+import com.laytonsmith.core.environments.Environment;
+import com.laytonsmith.core.environments.GlobalEnv;
+import com.laytonsmith.core.environments.RuntimeMode;
 import com.laytonsmith.core.extensions.ExtensionManager;
 import com.laytonsmith.core.telemetry.DefaultTelemetry;
 import com.laytonsmith.core.telemetry.Telemetry;
+import com.laytonsmith.tools.debugger.DebugSecurity;
+import com.laytonsmith.tools.debugger.MSDebugServer;
 import org.bukkit.Bukkit;
 import org.bukkit.command.BlockCommandSender;
 import org.bukkit.command.Command;
@@ -93,6 +99,7 @@
 import java.io.File;
 import java.io.IOException;
 import java.lang.reflect.InvocationTargetException;
+import java.util.EnumSet;
 import java.util.List;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
@@ -113,6 +120,7 @@ public class CommandHelperPlugin extends JavaPlugin {
 	private static int hostnameThreadPoolID = 0;
 	private boolean firstLoad = true;
 	private long interpreterUnlockedUntil = 0;
+	private MSDebugServer debugServer;
 
 	/**
 	 * Listener for the plugin system.
@@ -385,6 +393,12 @@ public void onEnable() {
 			StreamUtils.GetSystemOut().println("\n\n" + Static.Logo());
 		}
 		ac = new AliasCore(CommandHelperFileLocations.getDefault());
+
+		String debugMode = Prefs.prefS(Prefs.PNames.DEBUG_SERVER_MODE);
+		if("on".equalsIgnoreCase(debugMode)) {
+			startDebugServer();
+		}
+
 		ac.reload(null, null, this.firstLoad);
 
 		//Clear out our hostname cache
@@ -429,6 +443,13 @@ public static AliasCore getCore() {
 	 */
 	@Override
 	public void onDisable() {
+		if(debugServer != null) {
+			debugServer.shutdown();
+			if(ac != null) {
+				ac.setDebugContext(null);
+			}
+			debugServer = null;
+		}
 		//free up some memory
 		StaticLayer.GetConvertor().runShutdownHooks();
 		if(ac.getStaticRuntimeEnv() != null) {
@@ -615,10 +636,150 @@ public boolean onCommand(CommandSender sender, Command cmd, String commandLabel,
 						+ " line by itself to exit, >>> to enter multiline mode, and ~ to clear the environment.");
 			}
 			return true;
+		} else if(cmdName.equalsIgnoreCase("debug-server")) {
+			if(!(sender instanceof ConsoleCommandSender)) {
+				sender.sendMessage(MCChatColor.RED
+						+ "This command can only be run from the console.");
+				return true;
+			}
+			if(args.length == 0) {
+				sender.sendMessage("Usage: /debug-server <start|stop|status>");
+				return true;
+			}
+			String action = args[0].toLowerCase();
+			if("start".equals(action)) {
+				String debugMode = Prefs.prefS(Prefs.PNames.DEBUG_SERVER_MODE);
+				if("off".equalsIgnoreCase(debugMode)) {
+					sender.sendMessage("Debug server is disabled in preferences. "
+							+ "Set debug-server-mode to 'manual' or 'on' to enable it.");
+					return true;
+				}
+				if(debugServer != null) {
+					sender.sendMessage("Debug server is already running on port "
+							+ debugServer.getPort());
+					return true;
+				}
+				startDebugServer();
+				if(debugServer != null) {
+					sender.sendMessage("Debug server started on port "
+							+ debugServer.getPort());
+				} else {
+					sender.sendMessage("Failed to start debug server. "
+							+ "Check the server log for details.");
+				}
+			} else if("stop".equals(action)) {
+				if(debugServer == null) {
+					sender.sendMessage("Debug server is not running.");
+				} else {
+					debugServer.shutdown();
+					ac.setDebugContext(null);
+					debugServer = null;
+					sender.sendMessage("Debug server stopped.");
+				}
+			} else if("status".equals(action)) {
+				if(debugServer == null) {
+					sender.sendMessage("Debug server is not running.");
+				} else {
+					sender.sendMessage("Debug server is running on port "
+							+ debugServer.getPort());
+				}
+			} else {
+				sender.sendMessage("Usage: /debug-server <start|stop|status>");
+			}
+			return true;
 		} else {
 			MCCommandSender mcsender = BukkitConvertor.BukkitGetCorrectSender(sender);
 			MCCommand mccmd = new BukkitMCCommand(cmd);
 			return mccmd.handleCustomCommand(mcsender, commandLabel, args);
 		}
 	}
+
+	private void startDebugServer() {
+		int port = Prefs.prefI(Prefs.PNames.DEBUG_SERVER_PORT);
+		String securityStr = Prefs.prefS(Prefs.PNames.DEBUG_SERVER_SECURITY);
+		String bindAddress = Prefs.prefS(Prefs.PNames.DEBUG_SERVER_BIND_ADDRESS);
+		String threadingStr = Prefs.prefS(Prefs.PNames.DEBUG_SERVER_THREADING);
+		String debugMode = Prefs.prefS(Prefs.PNames.DEBUG_SERVER_MODE);
+		boolean suspend = false;
+
+		DebugSecurity security;
+		try {
+			security = DebugSecurity.valueOf(securityStr.toUpperCase());
+		} catch(IllegalArgumentException e) {
+			getLogger().log(Level.SEVERE,
+					"Invalid debug-server-security value: " + securityStr
+					+ ". Must be NONE or KEYPAIR.");
+			return;
+		}
+
+		DebugContext.ThreadingMode threading;
+		if("async".equalsIgnoreCase(threadingStr)) {
+			threading = DebugContext.ThreadingMode.ASYNCHRONOUS;
+		} else if("sync".equalsIgnoreCase(threadingStr)) {
+			threading = DebugContext.ThreadingMode.SYNCHRONOUS;
+		} else {
+			getLogger().log(Level.SEVERE,
+					"Invalid debug-server-threading value: " + threadingStr
+					+ ". Must be 'async' or 'sync'.");
+			return;
+		}
+
+		File authorizedKeysFile = security == DebugSecurity.KEYPAIR
+				? MethodScriptFileLocations.getDefault().getAuthorizedDebugKeysFile()
+				: null;
+
+		debugServer = new MSDebugServer();
+		try {
+			GlobalEnv gEnv = new GlobalEnv(
+					MethodScriptFileLocations.getDefault().getConfigDirectory(),
+					EnumSet.of(RuntimeMode.EMBEDDED));
+			Environment env = Environment.createEnvironment(gEnv);
+			env = debugServer.startListening(port, bindAddress, env, suspend,
+					threading, security, authorizedKeysFile);
+			ac.setDebugContext(env.getEnv(DebugContext.class));
+			if("manual".equalsIgnoreCase(debugMode)) {
+				int timeout = Prefs.prefI(Prefs.PNames.DEBUG_SERVER_TIMEOUT);
+				if(timeout > 0) {
+					startDebugServerTimeout(timeout);
+				}
+			}
+		} catch(IOException e) {
+			getLogger().log(Level.SEVERE, "Failed to start debug server", e);
+			debugServer = null;
+		}
+	}
+
+	private void startDebugServerTimeout(int timeoutMinutes) {
+		final MSDebugServer ds = debugServer;
+		java.lang.Thread timeoutThread = new java.lang.Thread(() -> {
+			long remaining = timeoutMinutes * 60_000L;
+			final long checkInterval = 10_000L;
+			try {
+				while(remaining > 0) {
+					java.lang.Thread.sleep(checkInterval);
+					if(ds != debugServer) {
+						return;
+					}
+					if(ds.isClientConnected()) {
+						remaining = timeoutMinutes * 60_000L;
+					} else {
+						remaining -= checkInterval;
+					}
+				}
+				if(ds == debugServer) {
+					getLogger().info("Debug server timed out after "
+							+ timeoutMinutes
+							+ (timeoutMinutes == 1 ? " minute" : " minutes")
+							+ " with no connected client. Shutting down.");
+					ds.shutdown();
+					ac.setDebugContext(null);
+					debugServer = null;
+				}
+			} catch(InterruptedException e) {
+				// Shutting down
+			}
+		}, "DebugServerTimeout");
+		timeoutThread.setDaemon(true);
+		timeoutThread.start();
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/AliasCore.java b/src/main/java/com/laytonsmith/core/AliasCore.java
index c355db85e..91b70ca43 100644
--- a/src/main/java/com/laytonsmith/core/AliasCore.java
+++ b/src/main/java/com/laytonsmith/core/AliasCore.java
@@ -29,6 +29,7 @@
 import com.laytonsmith.core.constructs.Target;
 import com.laytonsmith.core.constructs.Variable;
 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.RuntimeMode;
@@ -90,6 +91,17 @@ public class AliasCore {
 	private StaticRuntimeEnv staticRuntimeEnv;
 	private List<Script> scripts;
 	private boolean lastCompileFailed = false;
+	private volatile DebugContext debugContext;
+
+	/**
+	 * Sets the DebugContext to inject into all script execution environments.
+	 * Pass {@code null} to disable debugging.
+	 *
+	 * @param ctx The DebugContext from the debug server, or null.
+	 */
+	public void setDebugContext(DebugContext ctx) {
+		this.debugContext = ctx;
+	}
 
 	/**
 	 * This constructor accepts the constant file locations object for MethodScript.
@@ -187,6 +199,13 @@ public boolean alias(String command, final MCCommandSender sender) {
 		cEnv.SetCommandSender(sender);
 		cEnv.SetCommand(command);
 		Environment env = Environment.createEnvironment(gEnv, staticRuntimeEnv, cEnv, compilerEnv);
+		if(debugContext != null && !debugContext.isDisconnected()) {
+			try {
+				env = env.cloneAndAdd(debugContext);
+			} catch(Exception e) {
+				Static.getLogger().log(Level.WARNING, "Failed to add debug context", e);
+			}
+		}
 
 		this.addPlayerReference(sender);
 		ProfilePoint alias = env.getEnv(StaticRuntimeEnv.class).GetProfiler().start("Alias - \"" + command + "\"",
@@ -353,6 +372,13 @@ public final void reload(MCPlayer player, String[] settings, final boolean first
 			CommandHelperEnvironment commandHelperEnv = new CommandHelperEnvironment();
 			CompilerEnvironment compilerEnv = new CompilerEnvironment();
 			env = Environment.createEnvironment(globalEnv, newStaticRuntimeEnv, commandHelperEnv, compilerEnv);
+			if(debugContext != null && !debugContext.isDisconnected()) {
+				try {
+					env = env.cloneAndAdd(debugContext);
+				} catch(Exception e) {
+					Static.getLogger().log(Level.WARNING, "Failed to add debug context", e);
+				}
+			}
 
 			File aliasConfig = new File(fileLocations.getConfigDirectory(), Prefs.ScriptName());
 			if(!aliasConfig.exists()) {
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/Installer.java b/src/main/java/com/laytonsmith/core/Installer.java
index d6fbef1a4..7f90be548 100644
--- a/src/main/java/com/laytonsmith/core/Installer.java
+++ b/src/main/java/com/laytonsmith/core/Installer.java
@@ -61,6 +61,15 @@ public static void Install(File root) {
 				Logger.getLogger(Installer.class.getName()).log(Level.SEVERE, null, ex);
 			}
 		}
+
+		File authorizedDebugKeys = new File(root, "authorized_debug_keys");
+		if(!authorizedDebugKeys.exists()) {
+			try {
+				authorizedDebugKeys.createNewFile();
+			} catch (IOException ex) {
+				Logger.getLogger(Installer.class.getName()).log(Level.SEVERE, null, ex);
+			}
+		}
 	}
 
 	public static void InstallCmdlineInterpreter() {
diff --git a/src/main/java/com/laytonsmith/core/Main.java b/src/main/java/com/laytonsmith/core/Main.java
index ee7b32859..74f74f162 100644
--- a/src/main/java/com/laytonsmith/core/Main.java
+++ b/src/main/java/com/laytonsmith/core/Main.java
@@ -27,6 +27,7 @@
 import com.laytonsmith.core.compiler.OptimizationUtilities;
 import com.laytonsmith.core.constructs.CString;
 import com.laytonsmith.core.constructs.Target;
+import com.laytonsmith.core.environments.DebugContext;
 import com.laytonsmith.core.environments.Environment;
 import com.laytonsmith.core.environments.GlobalEnv;
 import com.laytonsmith.core.environments.RuntimeMode;
@@ -53,6 +54,8 @@
 import com.laytonsmith.tools.ProfilerSummary;
 import com.laytonsmith.tools.SyntaxHighlighters;
 import com.laytonsmith.tools.UILauncher;
+import com.laytonsmith.tools.debugger.DebugSecurity;
+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 +767,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 +1078,134 @@ 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"))
+					.addArgument(new ArgumentBuilder()
+						.setDescription("The security mode for the debug server."
+								+ " Required when --debug is set."
+								+ " NONE: no authentication (localhost only)."
+								+ " KEYPAIR: SSH-style key authentication with TLS.")
+						.setUsageName("mode")
+						.setOptional()
+						.setName("debug-security")
+						.setArgType(ArgumentBuilder.BuilderTypeNonFlag.STRING))
+					.addArgument(new ArgumentBuilder()
+						.setDescription("The address to bind the debug server to."
+								+ " Defaults to " + MSDebugServer.DEFAULT_BIND_ADDRESS + ".")
+						.setUsageName("address")
+						.setOptional()
+						.setName("debug-bind-address")
+						.setArgType(ArgumentBuilder.BuilderTypeNonFlag.STRING))
+					.addArgument(new ArgumentBuilder()
+						.setDescription("Convenience shorthand that sets --debug-security NONE"
+								+ " and --debug-bind-address 0.0.0.0. For quick testing only.")
+						.asFlag()
+						.setName("debug-insecure"))
+					.addArgument(new ArgumentBuilder()
+						.setDescription("The threading mode for the debug server."
+								+ " sync: blocks the executing thread at breakpoints."
+								+ " async: snapshots state without blocking."
+								+ " Defaults to sync.")
+						.setUsageName("mode")
+						.setOptional()
+						.setName("debug-threading-mode")
+						.setArgType(ArgumentBuilder.BuilderTypeNonFlag.STRING));
 		}
 
 		@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");
+			boolean debugInsecure = parsedArgs.isFlagSet("debug-insecure");
+			String debugSecurityStr = parsedArgs.getStringArgument("debug-security");
+			String debugBindAddress = parsedArgs.getStringArgument("debug-bind-address");
+			String debugThreadingModeStr = parsedArgs.getStringArgument("debug-threading-mode");
+
+			// --debug-insecure changes defaults but explicit values take priority
+			String defaultSecurity = debugInsecure
+					? DebugSecurity.NONE.name() : null;
+			String defaultBindAddress = debugInsecure ? "0.0.0.0"
+					: MSDebugServer.DEFAULT_BIND_ADDRESS;
+
+			DebugSecurity debugSecurity;
+			String securityValue = debugSecurityStr != null ? debugSecurityStr : defaultSecurity;
+			if(securityValue != null) {
+				try {
+					debugSecurity = DebugSecurity.valueOf(securityValue.toUpperCase());
+				} catch(IllegalArgumentException e) {
+					StreamUtils.GetSystemErr().println("Invalid --debug-security value: "
+							+ securityValue + ". Must be one of "
+							+ StringUtils.Join(DebugSecurity.values(),
+									", ", ", or "));
+					System.exit(1);
+					return;
+				}
+			} else if(debug) {
+				StreamUtils.GetSystemErr().println("--debug-security is required when"
+						+ " --debug is set. Must be one of "
+						+ StringUtils.Join(DebugSecurity.values(),
+								", ", ", or "));
+				System.exit(1);
+				return;
+			} else {
+				debugSecurity = DebugSecurity.KEYPAIR;
+			}
+			if(debugBindAddress == null) {
+				debugBindAddress = defaultBindAddress;
+			}
+
 			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;
+				DebugContext.ThreadingMode threadingMode = DebugContext.ThreadingMode.SYNCHRONOUS;
+				if("async".equals(debugThreadingModeStr)) {
+					threadingMode = DebugContext.ThreadingMode.ASYNCHRONOUS;
+				}
+				debugServer = new MSDebugServer();
+				File authorizedKeysFile = debugSecurity == DebugSecurity.KEYPAIR
+						? MethodScriptFileLocations.getDefault().getAuthorizedDebugKeysFile()
+						: null;
+				env = debugServer.startListening(port, debugBindAddress, env,
+						debugSuspend, threadingMode,
+						debugSecurity, authorizedKeysFile);
+				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 +1337,101 @@ 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;
+			String debugSecurityStr = null;
+			String debugBindAddress = null;
+			boolean debugInsecure = false;
+			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();
+					}
+				} else if("--debug-security".equals(arg)) {
+					it.remove();
+					if(it.hasNext()) {
+						debugSecurityStr = it.next();
+						it.remove();
+					}
+				} else if("--debug-bind-address".equals(arg)) {
+					it.remove();
+					if(it.hasNext()) {
+						debugBindAddress = it.next();
+						it.remove();
+					}
+				} else if("--debug-insecure".equals(arg)) {
+					debugInsecure = true;
+					it.remove();
+				}
+			}
+
+			// Resolve security and bind address.
+			// --debug-insecure changes defaults; explicit values take priority.
+			String defaultSecurity = debugInsecure
+					? DebugSecurity.NONE.name() : null;
+			String defaultBindAddress = debugInsecure ? "0.0.0.0"
+					: MSDebugServer.DEFAULT_BIND_ADDRESS;
+
+			DebugSecurity debugSecurity;
+			String securityValue = debugSecurityStr != null
+					? debugSecurityStr : defaultSecurity;
+			if(securityValue != null) {
+				try {
+					debugSecurity = DebugSecurity.valueOf(
+							securityValue.toUpperCase());
+				} catch(IllegalArgumentException e) {
+					StreamUtils.GetSystemErr().println(
+							"Invalid --debug-security value: "
+							+ securityValue + ". Must be one of "
+							+ StringUtils.Join(DebugSecurity.values(),
+									", ", ", or "));
+					System.exit(1);
+					return;
+				}
+			} else if(debug) {
+				StreamUtils.GetSystemErr().println(
+						"--debug-security is required when --debug is"
+						+ " set. Must be one of "
+						+ StringUtils.Join(DebugSecurity.values(),
+								", ", ", or "));
+				System.exit(1);
+				return;
+			} else {
+				debugSecurity = DebugSecurity.KEYPAIR;
+			}
+			if(debugBindAddress == null) {
+				debugBindAddress = defaultBindAddress;
+			}
+
 			String fileName = allArgs.get(0);
 			allArgs.remove(0);
 			try {
-				Interpreter.startWithTTY(fileName, allArgs);
+				Interpreter.startWithTTY(fileName, allArgs, true,
+						debug, debugPort, debugSuspend, debugThreadingMode,
+						debugSecurity, debugBindAddress);
 			} catch (Profiles.InvalidProfileException ex) {
 				StreamUtils.GetSystemErr().println("Invalid profile file at " + MethodScriptFileLocations.getDefault()
 						.getProfilesFile()
@@ -1324,8 +1529,9 @@ public static class RSAKeyGenMode extends AbstractCommandLineTool {
 		@Override
 		public ArgumentParser getArgumentParser() {
 			return ArgumentParser.GetParser()
-				.addDescription("Creates an ssh compatible rsa key pair. This is used with the Federation system, but"
-						+ " is useful with other tools as well.")
+				.addDescription("Creates an ssh compatible rsa key pair, suitable for use with the"
+						+ " MethodScript debugger's KEYPAIR security mode, or other tools that"
+						+ " require RSA key authentication.")
 				.addArgument(new ArgumentBuilder()
 						.setDescription("Output file for the keys. For instance, \"/home/user/.ssh/id_rsa\"."
 							+ " The public key will have the same name, with \".pub\" appended.")
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/MethodScriptFileLocations.java b/src/main/java/com/laytonsmith/core/MethodScriptFileLocations.java
index 4d446d92f..10bcea602 100644
--- a/src/main/java/com/laytonsmith/core/MethodScriptFileLocations.java
+++ b/src/main/java/com/laytonsmith/core/MethodScriptFileLocations.java
@@ -251,4 +251,12 @@ public File getNativeDirectory() {
 			return getLinuxNativeDirectory();
 		}
 	}
+
+	/**
+	 * Returns the location of the authorized_debug_keys file.
+	 * @return
+	 */
+	public File getAuthorizedDebugKeysFile() {
+		return new File(new File(getUserHome(), ".mscript"), "authorized_debug_keys");
+	}
 }
diff --git a/src/main/java/com/laytonsmith/core/Prefs.java b/src/main/java/com/laytonsmith/core/Prefs.java
index ca7bc7341..8cdbdc201 100644
--- a/src/main/java/com/laytonsmith/core/Prefs.java
+++ b/src/main/java/com/laytonsmith/core/Prefs.java
@@ -82,7 +82,13 @@ public static enum PNames {
 		TELEMETRY_ON("telemetry-on", Preferences.Type.STRING),
 		TELEMETRY_PREF_DEFAULT_COLLECT("telemetry-pref-default-collect", Preferences.Type.BOOLEAN),
 		TELEMETRY_AUDIT("telemetry-audit", Preferences.Type.BOOLEAN),
-		CHECK_FOR_UPDATES("check-for-updates", Preferences.Type.BOOLEAN);
+		CHECK_FOR_UPDATES("check-for-updates", Preferences.Type.BOOLEAN),
+		DEBUG_SERVER_MODE("debug-server-mode", Preferences.Type.STRING),
+		DEBUG_SERVER_PORT("debug-server-port", Preferences.Type.INT),
+		DEBUG_SERVER_SECURITY("debug-server-security", Preferences.Type.STRING),
+		DEBUG_SERVER_BIND_ADDRESS("debug-server-bind-address", Preferences.Type.STRING),
+		DEBUG_SERVER_THREADING("debug-server-threading", Preferences.Type.STRING),
+		DEBUG_SERVER_TIMEOUT("debug-server-timeout", Preferences.Type.INT);
 		private final String name;
 		private final Preferences.Type type;
 
@@ -239,6 +245,29 @@ public static void init(final File f) throws IOException {
 				+ " execution context, so in all cases, you can check for updates manually with the check-update"
 				+ " command.",
 				UPDATE_GROUP));
+		a.add(new Preference(PNames.DEBUG_SERVER_MODE.config(), "off", Preferences.Type.STRING,
+				"Controls the DAP debug server. 'off' disables it entirely (default), 'on' starts "
+				+ "it automatically when the plugin loads, 'manual' allows starting it via "
+				+ "/debug-server start.", DEBUG_GROUP));
+		a.add(new Preference(PNames.DEBUG_SERVER_PORT.config(), "6732", Preferences.Type.INT,
+				"The TCP port for the DAP debug server.", DEBUG_GROUP));
+		a.add(new Preference(PNames.DEBUG_SERVER_SECURITY.config(), "KEYPAIR", Preferences.Type.STRING,
+				"The security mode for the debug server. 'KEYPAIR' requires SSH-style "
+				+ "authentication and enables TLS encryption (recommended). 'NONE' allows "
+				+ "unauthenticated connections and is restricted to localhost only.",
+				DEBUG_GROUP));
+		a.add(new Preference(PNames.DEBUG_SERVER_BIND_ADDRESS.config(), "127.0.0.1", Preferences.Type.STRING,
+				"The address the debug server binds to. Use '0.0.0.0' to accept remote "
+				+ "connections (requires KEYPAIR security).", DEBUG_GROUP));
+		a.add(new Preference(PNames.DEBUG_SERVER_THREADING.config(), "async", Preferences.Type.STRING,
+				"The threading mode for the debug server. 'async' snapshots state without "
+				+ "blocking the server thread (recommended for Minecraft). 'sync' blocks "
+				+ "the executing thread when a breakpoint is hit.", DEBUG_GROUP));
+		a.add(new Preference(PNames.DEBUG_SERVER_TIMEOUT.config(), "15", Preferences.Type.INT,
+				"Sets the time (in minutes) that the debug server will remain running "
+				+ "without a connected client before automatically shutting down. Set to "
+				+ "0 (or a negative number) to disable the timeout. Only applies when "
+				+ "debug-server-mode is 'manual'.", DEBUG_GROUP));
 		prefs = new Preferences("CommandHelper", Static.getLogger(), a);
 		prefs.init(f);
 	}
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..7f8db578d 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,85 @@ 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) {
+		List<PausedState.StepInTargetInfo> stepInTargets = findStepInTargets(stack, pauseTarget);
+		debugCtx.setPaused(true, pauseTarget);
+		if(debugCtx.shouldUseSyncMode()) {
+			LivePausedState state = new LivePausedState(env, pauseTarget,
+					pendingFlowControl, stepInTargets);
+			debugCtx.prepareAwait();
+			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,
+					stepInTargets);
+			debugCtx.getListener().onPaused(snapshot);
+			return DEBUGGER_PAUSED;
+		}
+	}
+
+	/**
+	 * Walks the parse tree at the top of the eval stack to find steppable function
+	 * calls on the same line as the pause target. These are the "step into targets"
+	 * that the user can choose to step into specifically (e.g. procs, closures).
+	 */
+	private static List<PausedState.StepInTargetInfo> findStepInTargets(
+			EvalStack stack, Target pauseTarget) {
+		List<PausedState.StepInTargetInfo> targets = new ArrayList<>();
+		if(stack.isEmpty() || pauseTarget == null) {
+			return targets;
+		}
+		StackFrame frame = stack.peek();
+		ParseTree node = frame.getNode();
+		if(node == null) {
+			return targets;
+		}
+		collectSteppableTargets(node, pauseTarget.line(), targets);
+		return targets;
+	}
+
+	/**
+	 * Recursively collects steppable function calls (procs) on the given line.
+	 */
+	private static void collectSteppableTargets(ParseTree node, int line,
+			List<PausedState.StepInTargetInfo> targets) {
+		if(node.getData() instanceof CFunction cf) {
+			if(cf.getTarget().line() == line && cf.val().startsWith("_")) {
+				targets.add(new PausedState.StepInTargetInfo(cf.val(), cf.getTarget().col()));
+			}
+		}
+		for(ParseTree child : node.getChildren()) {
+			collectSteppableTargets(child, line, targets);
+		}
+	}
+
 	/**
 	 * Given the parse tree and environment, executes the tree.
 	 *
@@ -979,4 +1274,134 @@ 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 final List<PausedState.StepInTargetInfo> stepInTargets;
+
+		private DebugSnapshot(EvalStack stack, Mixed lastResult, boolean hasResult,
+				StepAction.FlowControl pendingFlowControl, Environment env, Target pauseTarget,
+				List<PausedState.StepInTargetInfo> stepInTargets) {
+			this.stack = stack;
+			this.lastResult = lastResult;
+			this.hasResult = hasResult;
+			this.pendingFlowControl = pendingFlowControl;
+			this.env = env;
+			this.pauseTarget = pauseTarget;
+			this.stepInTargets = stepInTargets;
+		}
+
+		/**
+		 * 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 List<StepInTargetInfo> getStepInTargets() {
+			return stepInTargets;
+		}
+
+		@Override
+		public String toString() {
+			return "DebugSnapshot{target=" + pauseTarget + ", depth=" + getUserCallDepth()
+					+ ", vars=" + getVariables().size() + ", hasResult=" + hasResult + "}";
+		}
+	}
+
 }
diff --git a/src/main/java/com/laytonsmith/core/constructs/CClosure.java b/src/main/java/com/laytonsmith/core/constructs/CClosure.java
index 713b42d8b..a9a1afbdb 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,13 +268,14 @@ 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}
+	 * @deprecated Use {@link #executeCallable(Environment, Target, Mixed...)} instead, which
+	 * provides the caller's environment and target for proper error reporting.
+	 * Functions that call closures should also consider extending {@link CallbackYield}
 	 * instead of calling this directly, which re-enters eval() and defeats the iterative interpreter.
 	 */
 	@Deprecated
@@ -285,14 +287,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>
+	 *
+	 * <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>
 	 *
-	 * A typical execution will include the following code:
+	 * <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
 	 * }
@@ -322,78 +330,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 +370,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..184e5d972
--- /dev/null
+++ b/src/main/java/com/laytonsmith/core/environments/DebugContext.java
@@ -0,0 +1,840 @@
+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.exceptions.StackTraceFrame;
+import com.laytonsmith.core.exceptions.StackTraceManager;
+import com.laytonsmith.core.natives.interfaces.Mixed;
+
+import java.io.File;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+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;
+
+	// Reconnect support: when the debugger disconnects with suspend mode,
+	// execution threads block in shouldPause() until a new client connects.
+	private volatile boolean awaitingReconnect = false;
+	private final Object reconnectMonitor = new Object();
+
+	// Suspend-on-start support: when true, execution threads block in
+	// shouldPause() until the debugger connects and sends configurationDone.
+	private volatile boolean awaitingInitialConnection = false;
+
+	// 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 with fully configured breakpoints
+	 * (including conditions, hit counts, and log messages).
+	 *
+	 * @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.
+	 * When targetCol >= 0, step-into will only enter the function at that column.
+	 */
+	public void setStepMode(int dapThreadId, StepMode mode, int currentDepth,
+			Target currentTarget, int targetCol) {
+		Thread t = getThreadByDapId(dapThreadId);
+		if(t != null) {
+			getThreadState(t).setStepMode(mode, currentDepth, currentTarget, targetCol);
+		}
+	}
+
+	/**
+	 * 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;
+		synchronized(reconnectMonitor) {
+			awaitingReconnect = false;
+			awaitingInitialConnection = false;
+			reconnectMonitor.notifyAll();
+		}
+		for(ThreadDebugState state : threadStates.values()) {
+			state.setPaused(false, null);
+			state.setStepMode(StepMode.NONE, 0, null, -1);
+			state.resume();
+		}
+		threadStates.clear();
+	}
+
+	/**
+	 * Enters reconnect-wait mode. Execution threads that call
+	 * {@link #shouldPause} will block until {@link #reconnect()} is called.
+	 * This is used when the debugger disconnects while suspend mode is active,
+	 * so that execution pauses until a new client attaches.
+	 */
+	public void awaitReconnect() {
+		synchronized(reconnectMonitor) {
+			awaitingReconnect = true;
+		}
+		// Resume any threads that are paused on debug latches so they can
+		// reach shouldPause() and block on the reconnect monitor instead.
+		for(ThreadDebugState state : threadStates.values()) {
+			state.setPaused(false, null);
+			state.resume();
+		}
+	}
+
+	/**
+	 * Signals that a new debugger has connected. Unblocks any execution
+	 * threads that are waiting in {@link #shouldPause} for a reconnection.
+	 */
+	public void reconnect() {
+		synchronized(reconnectMonitor) {
+			disconnected = false;
+			awaitingReconnect = false;
+			awaitingInitialConnection = false;
+			reconnectMonitor.notifyAll();
+		}
+	}
+
+	/**
+	 * Returns true if execution threads are blocked waiting for a debugger
+	 * to reconnect.
+	 */
+	public boolean isAwaitingReconnect() {
+		return awaitingReconnect;
+	}
+
+	/**
+	 * Sets the awaiting-initial-connection flag. When true, execution threads
+	 * will block in {@link #shouldPause} until a debugger connects and calls
+	 * {@link #reconnect()}. This is used for suspend-on-start in contexts
+	 * where the calling thread cannot be blocked (e.g. Minecraft server startup).
+	 */
+	public void setAwaitingInitialConnection(boolean awaiting) {
+		synchronized(reconnectMonitor) {
+			awaitingInitialConnection = awaiting;
+		}
+	}
+
+	/**
+	 * 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 the debugger disconnected with suspend mode, or we're awaiting
+		// the initial debugger connection (suspend-on-start), block until
+		// a debugger connects. The thread will appear stopped at whatever
+		// line it was executing when the disconnect happened.
+		if(awaitingReconnect || awaitingInitialConnection) {
+			synchronized(reconnectMonitor) {
+				while(awaitingReconnect || awaitingInitialConnection) {
+					try {
+						reconnectMonitor.wait();
+					} catch(InterruptedException e) {
+						Thread.currentThread().interrupt();
+						return false;
+					}
+				}
+			}
+			// A new debugger just connected - pause so it can inspect state.
+			return true;
+		}
+
+		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:
+					if(state.getStepIntoTargetCol() >= 0) {
+						// Targeted step-into: only step into the function at the target column
+						if(sameSourceLine(source, state.getStepReferenceTarget())) {
+							// Still on the paused line, haven't entered anything yet
+							break;
+						}
+						if(userCallDepth > state.getStepReferenceDepth()) {
+							// Entered a function — check if it's the target
+							StackTraceManager stm = env.getEnv(GlobalEnv.class)
+									.peekStackTraceManager();
+							if(stm != null) {
+								List<StackTraceFrame> frames = stm.getCurrentStackTrace();
+								if(!frames.isEmpty()) {
+									Target callSite = frames.get(0).getCallSite();
+									if(callSite.col() == state.getStepIntoTargetCol()) {
+										shouldStop = true;
+										break;
+									}
+								}
+							}
+							// Not the target — don't pause (step over this call)
+						} else {
+							// Moved to a different line at same/lower depth (safety fallback)
+							shouldStop = true;
+						}
+					} else {
+						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();
+		}
+
+		// When doing targeted step-into, suppress breakpoint re-fires on the
+		// reference line. We may return to this line between stepping over
+		// non-target functions and entering the target.
+		if(shouldStop && state.getStepMode() == StepMode.INTO
+				&& state.getStepIntoTargetCol() >= 0
+				&& sameSourceLine(source, state.getStepReferenceTarget())
+				&& userCallDepth <= state.getStepReferenceDepth()) {
+			shouldStop = false;
+		}
+
+		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;
+	}
+
+	/**
+	 * Creates the latch that {@link #awaitResume()} will block on. Must be
+	 * called before notifying the listener of a pause, so that a resume()
+	 * arriving before awaitResume() is not lost.
+	 */
+	public void prepareAwait() {
+		getThreadState().prepareAwait();
+	}
+
+	/**
+	 * 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.
+	 * {@link #prepareAwait()} must have been called first.
+	 *
+	 * @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
+	 * @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();
+		});
+	}
+
+	/**
+	 * Registers a thread and transfers the {@link ThreadDebugState} from a
+	 * source thread. This is used in embedded async mode where the main
+	 * thread's step mode and other debug state need to carry over to a
+	 * spawned execution thread without changing the main thread identity.
+	 *
+	 * @param t The thread to register
+	 * @param displayName The user-visible name
+	 * @param stateSource The thread whose debug state should be transferred
+	 * @return The assigned DAP thread ID
+	 */
+	public int registerThread(Thread t, String displayName, Thread stateSource) {
+		int dapId = registerThread(t, displayName);
+		ThreadDebugState state = threadStates.remove(stateSource);
+		if(state != null) {
+			threadStates.put(t, state);
+		}
+		return dapId;
+	}
+
+	/**
+	 * 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..9539de86e 100644
--- a/src/main/java/com/laytonsmith/core/environments/GlobalEnv.java
+++ b/src/main/java/com/laytonsmith/core/environments/GlobalEnv.java
@@ -406,6 +406,40 @@ public StackTraceManager GetStackTraceManager() {
 		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..8161e61da
--- /dev/null
+++ b/src/main/java/com/laytonsmith/core/environments/LivePausedState.java
@@ -0,0 +1,108 @@
+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;
+	private final List<PausedState.StepInTargetInfo> stepInTargets;
+
+	public LivePausedState(Environment env, Target pauseTarget,
+			StepAction.FlowControl pendingFlowControl,
+			List<PausedState.StepInTargetInfo> stepInTargets) {
+		this.env = env;
+		this.pauseTarget = pauseTarget;
+		this.pendingFlowControl = pendingFlowControl;
+		this.stepInTargets = stepInTargets;
+	}
+
+	@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 List<StepInTargetInfo> getStepInTargets() {
+		return stepInTargets;
+	}
+
+	@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..b853e6405
--- /dev/null
+++ b/src/main/java/com/laytonsmith/core/environments/PausedState.java
@@ -0,0 +1,79 @@
+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.Collections;
+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();
+
+	/**
+	 * Returns the available step-in targets for the current paused location.
+	 * Each target represents a function call on the current line that could be
+	 * stepped into (procs, closures, includes). Default returns empty.
+	 */
+	default List<StepInTargetInfo> getStepInTargets() {
+		return Collections.emptyList();
+	}
+
+	/**
+	 * A step-in target: a function call on the paused line that the user can choose
+	 * to step into.
+	 *
+	 * @param name The function name as it appears in source
+	 * @param column The column position of the call, used as a unique identifier
+	 */
+	record StepInTargetInfo(String name, int column) {
+	}
+}
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..1c92fc5e4
--- /dev/null
+++ b/src/main/java/com/laytonsmith/core/environments/ThreadDebugState.java
@@ -0,0 +1,98 @@
+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 int stepIntoTargetCol = -1;
+	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,
+			int targetCol) {
+		this.stepMode = mode;
+		this.stepReferenceDepth = currentDepth;
+		this.stepReferenceTarget = currentTarget;
+		this.stepIntoTargetCol = targetCol;
+	}
+
+	public int getStepIntoTargetCol() {
+		return stepIntoTargetCol;
+	}
+
+	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;
+	}
+
+	/**
+	 * Creates the latch that {@link #awaitResume()} will block on. Must be
+	 * called before any listener notification that might trigger a
+	 * {@link #resume()} call, to avoid the race where resume() fires before
+	 * the latch exists.
+	 */
+	public void prepareAwait() {
+		pauseLatch = new CountDownLatch(1);
+	}
+
+	/**
+	 * Blocks the calling thread until {@link #resume()} is called.
+	 * {@link #prepareAwait()} must have been called first.
+	 */
+	public void awaitResume() throws InterruptedException {
+		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..8020ba3aa 100644
--- a/src/main/java/com/laytonsmith/core/natives/interfaces/Callable.java
+++ b/src/main/java/com/laytonsmith/core/natives/interfaces/Callable.java
@@ -22,11 +22,17 @@ 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
diff --git a/src/main/java/com/laytonsmith/tools/Interpreter.java b/src/main/java/com/laytonsmith/tools/Interpreter.java
index ad5f2443a..bf466e7a1 100644
--- a/src/main/java/com/laytonsmith/tools/Interpreter.java
+++ b/src/main/java/com/laytonsmith/tools/Interpreter.java
@@ -95,6 +95,9 @@
 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.DebugSecurity;
+import com.laytonsmith.tools.debugger.MSDebugServer;
 import com.laytonsmith.tools.docgen.DocGen;
 import com.laytonsmith.tools.docgen.DocGenTemplates;
 import jline.console.ConsoleReader;
@@ -174,17 +177,109 @@ 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, DebugSecurity.KEYPAIR,
+				MSDebugServer.DEFAULT_BIND_ADDRESS);
+	}
+
+	/**
+	 * 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.
+	 * @param debugSecurity The security mode for incoming debug connections.
+	 * @param debugBindAddress The address to bind the debug server to.
+	 */
+	public static void startWithTTY(String file, List<String> args, boolean systemExitOnFailure,
+			boolean debug, int debugPort, boolean debugSuspend, String debugThreadingMode,
+			DebugSecurity debugSecurity, String debugBindAddress) throws IOException,
+			DataSourceException, URISyntaxException, Profiles.InvalidProfileException {
 		File fromFile = new File(file).getCanonicalFile();
 		Interpreter interpreter = new Interpreter(args, fromFile.getParentFile().getPath(), true);
+
+		if(debug) {
+			if(!fromFile.exists()) {
+				StreamUtils.GetSystemErr().println("Error: File '" + fromFile.getAbsolutePath()
+						+ "' does not exist");
+				if(systemExitOnFailure) {
+					System.exit(1);
+				}
+				return;
+			}
+			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();
+			File authorizedKeysFile = debugSecurity == DebugSecurity.KEYPAIR
+					? MethodScriptFileLocations.getDefault().getAuthorizedDebugKeysFile()
+					: null;
+			interpreter.env = debugServer.startListening(port, debugBindAddress,
+					interpreter.env, debugSuspend, threadingMode, debugSecurity,
+					authorizedKeysFile);
+
+			// Install a signal handler so Ctrl+C cleanly shuts down the debug
+			// server and exits, even when running with -Xrs.
+			SignalHandler.addStopHandlers((type) -> {
+				debugServer.shutdown();
+				System.exit(130);
+				return true;
+			});
+
+			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(IOException ex) {
+				StreamUtils.GetSystemErr().println("Error: " + ex.getMessage());
+				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 +874,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 +966,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/DebugAuthenticator.java b/src/main/java/com/laytonsmith/tools/debugger/DebugAuthenticator.java
new file mode 100644
index 000000000..22730656a
--- /dev/null
+++ b/src/main/java/com/laytonsmith/tools/debugger/DebugAuthenticator.java
@@ -0,0 +1,208 @@
+package com.laytonsmith.tools.debugger;
+
+import com.laytonsmith.PureUtilities.Common.RSAEncrypt;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.security.SecureRandom;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Handles the pre-DAP KEYPAIR authentication handshake for the debug server.
+ *
+ * <p>The handshake occurs on the raw TCP socket before any DAP traffic. The protocol is:
+ * <ol>
+ *   <li>Server sends: magic bytes ({@code MSDBG\1}), then a 32-byte random nonce</li>
+ *   <li>Client sends: the nonce signed with its private key, plus its public key string</li>
+ *   <li>Server verifies: (a) the public key is in the authorized keys file,
+ *       (b) the signature decrypts to the original nonce</li>
+ *   <li>Server sends: a result byte (1 = success, 0 = failure) and an error message on failure</li>
+ * </ol>
+ *
+ * <p>All multi-byte integers are sent as big-endian (network byte order) via {@link DataInputStream}
+ * and {@link DataOutputStream}.
+ */
+public class DebugAuthenticator {
+
+	/**
+	 * Protocol magic bytes sent by the server to identify this as a MethodScript debug connection.
+	 * Format: "MSDBG" + protocol version byte (currently 1).
+	 */
+	public static final byte[] MAGIC = {'M', 'S', 'D', 'B', 'G', 0x01};
+
+	/**
+	 * Size of the random nonce in bytes.
+	 */
+	private static final int NONCE_SIZE = 32;
+
+	/**
+	 * Maximum allowed size for a signature or public key payload, to prevent denial of service
+	 * from a malicious client sending enormous data.
+	 */
+	private static final int MAX_PAYLOAD_SIZE = 8192;
+
+	private static final byte AUTH_SUCCESS = 0x01;
+	private static final byte AUTH_FAILURE = 0x00;
+
+	private final List<String> authorizedKeys;
+
+	/**
+	 * Creates an authenticator that verifies clients against the given authorized keys file.
+	 * The file contains one SSH-format public key per line ({@code ssh-rsa <base64> <label>}).
+	 * Empty lines and lines starting with {@code #} are ignored.
+	 *
+	 * @param authorizedKeysFile The file containing authorized public keys.
+	 * @throws IOException If the file cannot be read.
+	 * @throws IllegalArgumentException If the file does not exist.
+	 */
+	public DebugAuthenticator(File authorizedKeysFile) throws IOException {
+		if(!authorizedKeysFile.exists()) {
+			throw new IllegalArgumentException("Authorized keys file does not exist: "
+					+ authorizedKeysFile.getAbsolutePath());
+		}
+		this.authorizedKeys = loadKeys(authorizedKeysFile);
+		if(authorizedKeys.isEmpty()) {
+			System.err.println("WARNING: Authorized keys file is empty: "
+					+ authorizedKeysFile.getAbsolutePath());
+			System.err.println("No clients will be able to authenticate.");
+		}
+	}
+
+	/**
+	 * Creates an authenticator with a pre-loaded list of authorized public key strings.
+	 * Primarily for testing.
+	 *
+	 * @param authorizedKeys The list of SSH-format public key strings.
+	 */
+	DebugAuthenticator(List<String> authorizedKeys) {
+		this.authorizedKeys = new ArrayList<>(authorizedKeys);
+	}
+
+	/**
+	 * Performs the server-side authentication handshake on the given socket streams.
+	 * This must be called before handing the streams to the DAP launcher.
+	 *
+	 * @param in The socket input stream.
+	 * @param out The socket output stream.
+	 * @return {@code true} if the client authenticated successfully.
+	 * @throws IOException If a communication error occurs.
+	 */
+	public boolean authenticate(InputStream in, OutputStream out) throws IOException {
+		DataInputStream dataIn = new DataInputStream(in);
+		DataOutputStream dataOut = new DataOutputStream(out);
+
+		// Step 1: Generate and send nonce
+		byte[] nonce = new byte[NONCE_SIZE];
+		new SecureRandom().nextBytes(nonce);
+
+		dataOut.write(MAGIC);
+		dataOut.writeInt(nonce.length);
+		dataOut.write(nonce);
+		dataOut.flush();
+
+		// Step 2: Read client's signature and public key
+		int sigLen = dataIn.readInt();
+		if(sigLen <= 0 || sigLen > MAX_PAYLOAD_SIZE) {
+			sendFailure(dataOut, "Invalid signature length");
+			return false;
+		}
+		byte[] signature = new byte[sigLen];
+		dataIn.readFully(signature);
+
+		int keyLen = dataIn.readInt();
+		if(keyLen <= 0 || keyLen > MAX_PAYLOAD_SIZE) {
+			sendFailure(dataOut, "Invalid public key length");
+			return false;
+		}
+		byte[] keyBytes = new byte[keyLen];
+		dataIn.readFully(keyBytes);
+		String clientPublicKey = new String(keyBytes, StandardCharsets.UTF_8).trim();
+
+		// Step 3: Verify the public key is authorized
+		if(!isAuthorized(clientPublicKey)) {
+			sendFailure(dataOut, "Public key is not authorized");
+			return false;
+		}
+
+		// Step 4: Verify the signature
+		try {
+			RSAEncrypt rsa = new RSAEncrypt(null, clientPublicKey);
+			byte[] decrypted = rsa.decryptWithPublic(signature);
+			if(!Arrays.equals(nonce, decrypted)) {
+				sendFailure(dataOut, "Signature verification failed");
+				return false;
+			}
+		} catch(RuntimeException e) {
+			sendFailure(dataOut, "Signature verification failed: " + e.getMessage());
+			return false;
+		}
+
+		// Step 5: Send success
+		dataOut.writeByte(AUTH_SUCCESS);
+		dataOut.flush();
+		return true;
+	}
+
+	private void sendFailure(DataOutputStream dataOut, String message) throws IOException {
+		dataOut.writeByte(AUTH_FAILURE);
+		byte[] msgBytes = message.getBytes(StandardCharsets.UTF_8);
+		dataOut.writeInt(msgBytes.length);
+		dataOut.write(msgBytes);
+		dataOut.flush();
+	}
+
+	private boolean isAuthorized(String clientPublicKey) {
+		// Compare the key type and key data, ignoring the label (third field)
+		String clientKeyData = extractKeyData(clientPublicKey);
+		if(clientKeyData == null) {
+			return false;
+		}
+		for(String authorizedKey : authorizedKeys) {
+			String authorizedKeyData = extractKeyData(authorizedKey);
+			if(clientKeyData.equals(authorizedKeyData)) {
+				return true;
+			}
+		}
+		return false;
+	}
+
+	/**
+	 * Extracts the key type and base64 key data from an SSH public key string,
+	 * ignoring the label. Returns {@code "ssh-rsa <base64>"} or {@code null} if invalid.
+	 */
+	private static String extractKeyData(String sshPublicKey) {
+		if(sshPublicKey == null) {
+			return null;
+		}
+		String[] parts = sshPublicKey.trim().split("\\s+");
+		if(parts.length < 2) {
+			return null;
+		}
+		return parts[0] + " " + parts[1];
+	}
+
+	private static List<String> loadKeys(File keyFile) throws IOException {
+		byte[] raw = Files.readAllBytes(keyFile.toPath());
+		boolean isUtf16 = raw.length >= 2
+				&& ((raw[0] & 0xFF) == 0xFF && (raw[1] & 0xFF) == 0xFE
+				|| (raw[0] & 0xFF) == 0xFE && (raw[1] & 0xFF) == 0xFF);
+		String content = new String(raw,
+				isUtf16 ? StandardCharsets.UTF_16 : StandardCharsets.UTF_8);
+		List<String> keys = new ArrayList<>();
+		for(String line : content.split("\\r?\\n")) {
+			line = line.trim();
+			if(!line.isEmpty() && !line.startsWith("#")) {
+				keys.add(line);
+			}
+		}
+		return keys;
+	}
+}
diff --git a/src/main/java/com/laytonsmith/tools/debugger/DebugSecurity.java b/src/main/java/com/laytonsmith/tools/debugger/DebugSecurity.java
new file mode 100644
index 000000000..b72230887
--- /dev/null
+++ b/src/main/java/com/laytonsmith/tools/debugger/DebugSecurity.java
@@ -0,0 +1,17 @@
+package com.laytonsmith.tools.debugger;
+
+/**
+ * Specifies the security mode for the DAP debug server.
+ */
+public enum DebugSecurity {
+	/**
+	 * No authentication. Suitable for localhost-only debugging.
+	 */
+	NONE,
+
+	/**
+	 * SSH-style keypair authentication with TLS transport encryption.
+	 * Required for remote debugging.
+	 */
+	KEYPAIR
+}
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..b9b27c09a
--- /dev/null
+++ b/src/main/java/com/laytonsmith/tools/debugger/MSDebugServer.java
@@ -0,0 +1,1203 @@
+package com.laytonsmith.tools.debugger;
+
+import com.laytonsmith.PureUtilities.CommandExecutor;
+import com.laytonsmith.PureUtilities.Common.FileUtil;
+import com.laytonsmith.PureUtilities.Common.StreamUtils;
+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.constructs.CArray;
+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.ExitedEventArguments;
+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.StepInTarget;
+import org.eclipse.lsp4j.debug.StepInTargetsArguments;
+import org.eclipse.lsp4j.debug.StepInTargetsResponse;
+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.InputStream;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.io.OutputStream;
+import java.io.PrintStream;
+import java.net.InetAddress;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.nio.charset.StandardCharsets;
+import java.security.KeyStore;
+import java.security.SecureRandom;
+import java.util.ArrayList;
+import javax.net.ssl.KeyManagerFactory;
+import javax.net.ssl.SSLContext;
+import javax.net.ssl.SSLSocket;
+import javax.net.ssl.SSLSocketFactory;
+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 static final int COMPOUND_REF_START = 100;
+
+	/** Default bind address for the DAP TCP listener. */
+	public static final String DEFAULT_BIND_ADDRESS = "127.0.0.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 Socket clientSocket;
+	private final CountDownLatch suspendLatch = new CountDownLatch(1);
+	private final CountDownLatch completionLatch = new CountDownLatch(1);
+	private boolean suspendOnStart = false;
+	private boolean managedExecution = false;
+	private volatile boolean scriptCompleted = false;
+	private PrintStream originalOut;
+	private PrintStream originalErr;
+	private DebugSecurity securityMode = DebugSecurity.KEYPAIR;
+	private DebugAuthenticator authenticator;
+	private SSLContext sslContext;
+	private final ConcurrentHashMap<Integer, Mixed> compoundVariableRefs = new ConcurrentHashMap<>();
+	private int nextCompoundRef = COMPOUND_REF_START;
+
+	/**
+	 * Starts a DAP TCP listener on the given port with an explicit threading mode.
+	 *
+	 * @param port The TCP port to listen on.
+	 * @param bindAddress The address to bind to (e.g. "127.0.0.1" or "0.0.0.0").
+	 * @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.
+	 * @param security The security mode for incoming connections.
+	 * @param authorizedKeysFile The file containing authorized public keys (required
+	 *     when security is KEYPAIR, ignored when NONE).
+	 * @return The Environment, which may have been cloned to include the DebugContext.
+	 * @throws IOException If the server socket cannot be opened or the authorized keys
+	 *     file cannot be read.
+	 */
+	public Environment startListening(int port, String bindAddress, Environment environment,
+			boolean suspend, DebugContext.ThreadingMode threadingMode,
+			DebugSecurity security, File authorizedKeysFile) throws IOException {
+		this.env = environment;
+		this.suspendOnStart = suspend;
+		this.managedExecution = true;
+		this.securityMode = security;
+
+		if(security == DebugSecurity.KEYPAIR) {
+			if(authorizedKeysFile == null) {
+				throw new IOException("KEYPAIR security requires an authorized keys file");
+			}
+			this.authenticator = new DebugAuthenticator(authorizedKeysFile);
+			try {
+				this.sslContext = createEphemeralSSLContext();
+			} catch(Exception e) {
+				throw new IOException("Failed to create TLS context", e);
+			}
+		}
+
+		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);
+			}
+		}
+
+		if(security == DebugSecurity.NONE && !"127.0.0.1".equals(bindAddress)
+				&& !"localhost".equals(bindAddress)) {
+			throw new IOException("NONE security mode can only bind to localhost (127.0.0.1). "
+					+ "Use KEYPAIR security for remote connections.");
+		}
+
+		serverSocket = new ServerSocket();
+		serverSocket.setReuseAddress(true);
+		serverSocket.bind(new java.net.InetSocketAddress(
+				InetAddress.getByName(bindAddress), port), 1);
+		StreamUtils.GetSystemErr().println("MethodScript debugger listening on " + bindAddress + ":"
+				+ serverSocket.getLocalPort() + " (security: " + security + ")");
+		if(suspend) {
+			StreamUtils.GetSystemErr().println("Waiting for debugger to connect before execution...");
+		}
+
+		java.lang.Thread acceptThread = new java.lang.Thread(() -> {
+			while(!serverSocket.isClosed()) {
+				try {
+					Socket socket = serverSocket.accept();
+					socket.setKeepAlive(true);
+					clientSocket = socket;
+					InputStream in = socket.getInputStream();
+					OutputStream out = socket.getOutputStream();
+
+					if(securityMode == DebugSecurity.KEYPAIR && authenticator != null) {
+						if(!authenticator.authenticate(in, out)) {
+							StreamUtils.GetSystemErr().println("Debug client authentication failed, "
+									+ "closing connection.");
+							socket.close();
+							StreamUtils.GetSystemErr().println("Waiting for another connection...");
+							continue;
+						}
+						StreamUtils.GetSystemErr().println("Debug client authenticated successfully.");
+
+						SSLSocketFactory sslFactory = sslContext.getSocketFactory();
+						SSLSocket sslSocket = (SSLSocket) sslFactory.createSocket(
+								socket,
+								socket.getInetAddress().getHostAddress(),
+								socket.getPort(),
+								true);
+						sslSocket.setUseClientMode(false);
+						sslSocket.startHandshake();
+						StreamUtils.GetSystemErr().println("TLS handshake completed.");
+						clientSocket = sslSocket;
+						in = sslSocket.getInputStream();
+						out = sslSocket.getOutputStream();
+					}
+
+					Launcher<IDebugProtocolClient> launcher
+							= DSPLauncher.createServerLauncher(this, in, out);
+					client = launcher.getRemoteProxy();
+					launcher.startListening().get();
+
+					// DAP session ended (client disconnected or crashed).
+					client = null;
+					if(serverSocket.isClosed()) {
+						break;
+					}
+					if(scriptCompleted) {
+						// Script is done - no point accepting more connections.
+						completionLatch.countDown();
+						break;
+					}
+					if(suspendOnStart && debugCtx != null) {
+						debugCtx.awaitReconnect();
+						StreamUtils.GetSystemErr().println("Debug client disconnected. Execution "
+								+ "suspended. Waiting for another connection...");
+					} else {
+						StreamUtils.GetSystemErr().println("Debug client disconnected. "
+								+ "Waiting for another connection...");
+					}
+				} catch(IOException e) {
+					if(!serverSocket.isClosed()) {
+						StreamUtils.GetSystemErr().println("Debug server accept failed: "
+								+ e.getMessage());
+					}
+				} catch(Exception e) {
+					if(!serverSocket.isClosed()) {
+						StreamUtils.GetSystemErr().println("Debug session error: " + e.getMessage());
+					}
+				}
+			}
+		}, "ms-debug-accept");
+		acceptThread.setDaemon(true);
+		acceptThread.start();
+
+		Runtime.getRuntime().addShutdownHook(new java.lang.Thread(() -> {
+			shutdown();
+		}, "ms-debug-shutdown"));
+
+		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();
+		}
+	}
+
+	/**
+	 * Returns true if a debugger has connected and sent the configurationDone request.
+	 */
+	public boolean isConfigurationDone() {
+		return configurationDone;
+	}
+
+	/**
+	 * 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");
+		if(managedExecution) {
+			// Embedded mode: keep the host's main thread as the debug main
+			// thread. Register the execution thread as a background thread
+			// with its own DAP ID so it can safely block on breakpoints.
+			// Transfer the main thread's debug state (step mode, etc.) to
+			// the execution thread.
+			int dapId = debugCtx.registerThread(executionThread, "execution",
+					debugCtx.getMainThread());
+			if(client != null) {
+				ThreadEventArguments tea = new ThreadEventArguments();
+				tea.setThreadId(dapId);
+				tea.setReason(ThreadEventArgumentsReason.STARTED);
+				client.thread(tea);
+			}
+		} else {
+			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
+	 * exited and terminated events to the client. The client is expected to
+	 * respond with a disconnect request, which releases the completion latch.
+	 */
+	private void executionCompleted() {
+		if(!managedExecution) {
+			// CLI mode: the script is the entire program, so signal termination.
+			scriptCompleted = true;
+			restoreOutputRedirect();
+			if(client != null) {
+				ExitedEventArguments exitArgs = new ExitedEventArguments();
+				exitArgs.setExitCode(0);
+				client.exited(exitArgs);
+				client.terminated(new TerminatedEventArguments());
+			} else {
+				completionLatch.countDown();
+			}
+		}
+		// Embedded mode (managedExecution=true): script completion is normal.
+		// The debug session stays alive for the next script execution.
+	}
+
+	/**
+	 * 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;
+	}
+
+	/**
+	 * Returns true if a DAP client is currently connected.
+	 */
+	public boolean isClientConnected() {
+		return client != null;
+	}
+
+	/**
+	 * Shuts down the debug server, closing the TCP listener and unblocking
+	 * any threads waiting for a debugger reconnection.
+	 */
+	public void shutdown() {
+		if(debugCtx != null) {
+			debugCtx.disconnect();
+		}
+		// Notify the client of termination before closing sockets, so
+		// the DAP framework doesn't throw SocketExceptions mid-response.
+		if(client != null) {
+			try {
+				client.terminated(new TerminatedEventArguments());
+			} catch(Exception e) {
+				// Client may already be gone
+			}
+			client = null;
+		}
+		completionLatch.countDown();
+		try {
+			if(clientSocket != null && !clientSocket.isClosed()) {
+				clientSocket.close();
+			}
+		} catch(IOException e) {
+			// Ignore close errors
+		}
+		try {
+			if(serverSocket != null && !serverSocket.isClosed()) {
+				serverSocket.close();
+			}
+		} catch(IOException e) {
+			// Ignore close errors
+		}
+	}
+
+	/**
+	 * Creates an ephemeral SSLContext with a self-signed certificate for
+	 * encrypting DAP traffic after KEYPAIR authentication.
+	 */
+	private static SSLContext createEphemeralSSLContext() throws Exception {
+		File tempKeystore = File.createTempFile("ms-debug-", ".p12");
+		tempKeystore.delete(); // keytool requires the file not exist
+		tempKeystore.deleteOnExit();
+		String password = Long.toHexString(new SecureRandom().nextLong());
+		String keytool = System.getProperty("java.home") + File.separator
+				+ "bin" + File.separator + "keytool";
+
+		java.io.ByteArrayOutputStream errStream = new java.io.ByteArrayOutputStream();
+		int exitCode = new CommandExecutor(keytool,
+				"-genkeypair",
+				"-alias", "debug",
+				"-keyalg", "RSA",
+				"-keysize", "2048",
+				"-validity", "1",
+				"-dname", "CN=MethodScript Debug Server",
+				"-keystore", tempKeystore.getAbsolutePath(),
+				"-storepass", password,
+				"-keypass", password,
+				"-storetype", "PKCS12")
+				.setSystemErr(errStream)
+				.start().waitFor();
+		if(exitCode != 0) {
+			throw new IOException("keytool failed (exit " + exitCode + "): "
+					+ errStream.toString("UTF-8").trim());
+		}
+
+		KeyStore keyStore = KeyStore.getInstance("PKCS12");
+		try(InputStream fis = Files.newInputStream(tempKeystore.toPath())) {
+			keyStore.load(fis, password.toCharArray());
+		} finally {
+			tempKeystore.delete();
+		}
+
+		KeyManagerFactory kmf = KeyManagerFactory.getInstance(
+				KeyManagerFactory.getDefaultAlgorithm());
+		kmf.init(keyStore, password.toCharArray());
+
+		SSLContext ctx = SSLContext.getInstance("TLS");
+		ctx.init(kmf.getKeyManagers(), null, new SecureRandom());
+		return ctx;
+	}
+
+	@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);
+		caps.setSupportsStepInTargetsRequest(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> attach(Map<String, Object> args) {
+		// In attach mode, the environment and debug context were already
+		// set up by startListening(). Just signal that we're ready.
+		client.initialized();
+		return CompletableFuture.completedFuture(null);
+	}
+
+	@Override
+	public CompletableFuture<Void> configurationDone(ConfigurationDoneArguments args) {
+		configurationDone = true;
+		suspendLatch.countDown();
+		if(debugCtx != null) {
+			debugCtx.reconnect();
+		}
+		if(programPath != null && !managedExecution) {
+			startExecution();
+		}
+		return CompletableFuture.completedFuture(null);
+	}
+
+	@Override
+	public CompletableFuture<Void> disconnect(DisconnectArguments args) {
+		if(debugCtx != null) {
+			if(managedExecution) {
+				// Embedded mode: the server stays alive for reconnection.
+				// Don't mark as disconnected, just release any paused threads.
+			} else if(suspendOnStart && !scriptCompleted) {
+				// Suspend mode: pause execution until a new debugger connects.
+				// awaitReconnect() releases paused threads so they can block
+				// in shouldPause() on the reconnect monitor.
+				debugCtx.awaitReconnect();
+			} else {
+				debugCtx.disconnect();
+			}
+			if(!pausedStates.isEmpty()) {
+				for(int threadId : pausedStates.keySet()) {
+					resumeExecution(threadId);
+				}
+			}
+		}
+		suspendLatch.countDown();
+		if(!suspendOnStart || scriptCompleted) {
+			completionLatch.countDown();
+		}
+		// Don't call shutdown() - the accept loop will handle reconnection.
+		// The Interpreter's finally block calls shutdown() when the main
+		// thread is done.
+		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, -1);
+			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(), -1);
+			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) {
+			Integer targetId = args.getTargetId();
+			int targetCol = (targetId != null && targetId >= 0) ? targetId : -1;
+			debugCtx.setStepMode(threadId, DebugContext.StepMode.INTO,
+					state.getUserCallDepth(), state.getPauseTarget(), targetCol);
+			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(), -1);
+			resumeExecution(threadId);
+		}
+		return CompletableFuture.completedFuture(null);
+	}
+
+	@Override
+	public CompletableFuture<StepInTargetsResponse> stepInTargets(StepInTargetsArguments args) {
+		StepInTargetsResponse response = new StepInTargetsResponse();
+		// Find the paused state — stepInTargets provides frameId, but all frames share
+		// the same paused state, so we use lastInspectedState (set by the most recent
+		// stackTrace request, which VS Code always sends before stepInTargets).
+		PausedState state = lastInspectedState;
+		if(state != null) {
+			List<PausedState.StepInTargetInfo> infos = state.getStepInTargets();
+			StepInTarget[] targets = new StepInTarget[infos.size()];
+			for(int i = 0; i < infos.size(); i++) {
+				PausedState.StepInTargetInfo info = infos.get(i);
+				StepInTarget sit = new StepInTarget();
+				sit.setId(info.column());
+				sit.setLabel(info.name());
+				targets[i] = sit;
+			}
+			response.setTargets(targets);
+		} else {
+			response.setTargets(new StepInTarget[0]);
+		}
+		return CompletableFuture.completedFuture(response);
+	}
+
+	@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;
+		int ref = args.getVariablesReference();
+
+		if(inspected == null) {
+			response.setVariables(new Variable[0]);
+			return CompletableFuture.completedFuture(response);
+		}
+
+		Environment stateEnv = inspected.getEnvironment();
+		List<Variable> result = new ArrayList<>();
+
+		if(ref == LOCALS_REF) {
+			compoundVariableRefs.clear();
+			nextCompoundRef = COMPOUND_REF_START;
+			Map<String, Mixed> vars = inspected.getVariables();
+			for(Map.Entry<String, Mixed> entry : vars.entrySet()) {
+				result.add(buildVariable(entry.getKey(), entry.getValue(), stateEnv));
+			}
+		} else if(compoundVariableRefs.containsKey(ref)) {
+			Mixed compound = compoundVariableRefs.get(ref);
+			if(compound instanceof CArray arr) {
+				for(Mixed key : arr.keySet()) {
+					Mixed value = arr.get(key, Target.UNKNOWN);
+					result.add(buildVariable(key.val(), value, stateEnv));
+				}
+			}
+		}
+
+		response.setVariables(result.toArray(new Variable[0]));
+		return CompletableFuture.completedFuture(response);
+	}
+
+	private Variable buildVariable(String name, Mixed value, Environment stateEnv) {
+		Variable v = new Variable();
+		v.setName(name);
+		v.setType(value.typeof(stateEnv).val());
+		if(value instanceof CArray arr) {
+			int refId = nextCompoundRef++;
+			compoundVariableRefs.put(refId, value);
+			v.setVariablesReference(refId);
+			if(arr.inAssociativeMode()) {
+				v.setValue("array (associative, length: " + arr.size(stateEnv) + ")");
+			} else {
+				v.setValue("array (length: " + arr.size(stateEnv) + ")");
+			}
+		} else {
+			v.setVariablesReference(0);
+			v.setValue(value.val());
+		}
+		return v;
+	}
+
+	@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/main/resources/docs/Debugging b/src/main/resources/docs/Debugging
index 56915eb84..8d5d83fb9 100644
--- a/src/main/resources/docs/Debugging
+++ b/src/main/resources/docs/Debugging
@@ -4,15 +4,165 @@ you write the code as cleverly as possible, you are, by definition, not smart
 enough to debug it." --Brian Kernighan
 
 Debugging your code is an important, but challenging part of writing working code.
-Currently, MethodScript does not have an interactive debugger (though this is planned
-in the future) however, this does not stop you from debugging scripts anyways.
-When debugging, there are several key concepts
+MethodScript has an interactive debugger, offered through the official VS Code
+extension, which supports breakpoints, step execution, variable inspection,
+and more. This page covers how to set up and use the debugger, as well as
+general debugging techniques.
+
+== VS Code Debugger ==
+
+The recommended way to debug MethodScript is with the official VS Code extension.
+It provides a full-featured debugging experience using the
+[[https://microsoft.github.io/debug-adapter-protocol/|Debug Adapter Protocol (DAP)]],
+including:
+
+* Breakpoints (line and conditional)
+* Step over, step into, step out
+* Variable inspection (locals and closure variables)
+* Call stack inspection
+* Log points (output a message without stopping)
+
+=== Installation ===
+
+Install the
+[[https://marketplace.visualstudio.com/items?itemName=MethodScriptVSC.methodscriptvsc|MethodScript VS Code extension]]
+from the VS Code Marketplace by searching for
+"MethodScript" in the Extensions panel, or install it from the command line:
+
+<%PRE|
+code --install-extension MethodScriptVSC.methodscriptvsc
+%>
+
+=== Command Line Debugging ===
+
+To debug a standalone <code>.ms</code> script, open it in VS Code and press
+F5, then "Launch". The extension will launch the script with the debug server enabled and
+automatically connect.
+
+You can also launch the debugger manually from the command line:
+
+<%PRE|
+java -jar CommandHelper.jar cmdline --debug --debug-security NONE script.ms
+%>
+
+This starts the debug server on port 6732 (the default). You can then attach
+VS Code to it by pressing F5 and choosing "Attach". The following command line
+flags are available:
+
+{| class="wiki-table"
+|-
+! Flag !! Description
+|-
+| <code>--debug</code> || Enable the DAP debug server.
+|-
+| <code>--debug-port &lt;port&gt;</code> || The port for the debug server. Defaults to 6732.
+|-
+| <code>--debug-suspend</code> || Wait for a debugger to connect before executing the script.
+|-
+| <code>--debug-security &lt;mode&gt;</code> || Security mode: <code>NONE</code> (localhost only, no auth) or <code>KEYPAIR</code> (SSH-style auth + TLS).
+|-
+| <code>--debug-threading-mode &lt;mode&gt;</code> || Threading mode: <code>sync</code> (default) blocks the executing thread at breakpoints, <code>async</code> snapshots state without blocking.
+|-
+| <code>--debug-bind-address &lt;address&gt;</code> || Address to bind to. Defaults to 127.0.0.1.
+|-
+| <code>--debug-insecure</code> || Shorthand for <code>--debug-security NONE --debug-bind-address 0.0.0.0</code>. For quick local testing only.
+|}
+
+=== Minecraft Server Debugging ===
+
+To debug scripts running inside a Minecraft server, configure the debug
+server in <code>plugins/CommandHelper/preferences.ini</code>:
+
+{| class="wiki-table"
+|-
+! Preference !! Default !! Description
+|-
+| <code>debug-server-mode</code> || <code>off</code> || <code>off</code> disables the debug server. <code>on</code> starts it automatically when the plugin loads. <code>manual</code> allows starting it with <code>/debug-server start</code>.
+|-
+| <code>debug-server-port</code> || <code>6732</code> || The TCP port for the debug server.
+|-
+| <code>debug-server-security</code> || <code>KEYPAIR</code> || <code>KEYPAIR</code> requires SSH-style authentication and enables TLS (recommended). <code>NONE</code> allows unauthenticated connections, restricted to localhost.
+|-
+| <code>debug-server-bind-address</code> || <code>127.0.0.1</code> || The address the debug server binds to. Use <code>0.0.0.0</code> for remote connections (requires KEYPAIR security).
+|-
+| <code>debug-server-threading</code> || <code>async</code> || <code>async</code> snapshots state without blocking the server thread (default, recommended). <code>sync</code> blocks the executing thread at breakpoints.
+|-
+| <code>debug-server-timeout</code> || <code>15</code> || Minutes before the debug server shuts down with no connected client. Set to 0 to disable. Only applies to manual mode.
+|}
+
+Once the debug server is running, press F5 in VS Code, choose "Attach", and
+enter the host and port. If using keypair security, you will also need to
+provide your private key. By default, this looks for ´~/.ssh/id_rsa`.
+
+To debug startup scripts (e.g. <code>main.ms</code>), connect the debugger
+first, then use <code>/recompile</code> to re-run the startup scripts with
+the debugger attached.
+
+==== Manual Mode ====
+
+Manual mode (<code>debug-server-mode=manual</code>) lets you start and stop
+the debug server on demand from the server console:
+
+<%PRE|
+/debug-server start
+/debug-server stop
+/debug-server status
+%>
+
+The server will automatically shut down after the configured timeout
+(default 15 minutes) if no client connects.
+
+=== Keypair Security ===
+
+For remote debugging keypair security is required, but can also be used locally.
+It uses SSH-style key authentication and TLS encryption.
+
+To set it up:
+
+# Generate an SSH key pair if you don't have one: <code>ssh-keygen -t ed25519</code> (or <code>mscript -- key-gen</code>).
+# Copy your public key to the authorized debug keys file at <code>~/.mscript/authorized_debug_keys</code> (for command line) or <code>plugins/CommandHelper/authorized_debug_keys</code> (for CommandHelper). One public key per line, same format as <code>~/.ssh/authorized_keys</code>.
+# From command line, use <code>--debug-security KEYPAIR</code>. For CommandHelper, set <code>debug-server-security</code> to <code>KEYPAIR</code> in preferences.ini.
+# When attaching from VS Code, select "Keypair" security and provide your private key (or leave blank to auto-detect from <code>~/.ssh/</code>).
+
+=== Using the Debugger ===
+
+==== Breakpoints ====
+
+Click in the gutter next to a line number in VS Code to set a breakpoint.
+When execution reaches that line, the debugger will pause and let you
+inspect the current state.
+
+Right-click a breakpoint to add a condition (the breakpoint only fires when
+the condition is true) or convert it to a log point (outputs a message
+without pausing).
+
+==== Stepping ====
+
+Once paused at a breakpoint, use the debug toolbar to control execution:
+
+* '''Step Over''' (F10) - Execute the current line and pause at the next line.
+* '''Step Into''' (F11) - If the current line calls a procedure, step into it.
+* '''Step Out''' (Shift+F11) - Run until the current procedure returns.
+* '''Continue''' (F5) - Resume execution until the next breakpoint.
+
+When stepping into a line that calls multiple procedures, VS Code will show
+step-into targets so you can choose which procedure to enter.
+
+==== Variable Inspection ====
+
+While paused, the Variables panel shows all variables in the current scope.
+You can expand arrays to inspect their contents.
+
+== General Debugging Techniques ==
+
+Regardless of whether you use the VS Code debugger, there are some key
+concepts to keep in mind when debugging.
 
 * Understand code flow
 * Understand variable's values
 * Know the assumptions you are making, and test assumptions that matter
 
-== Understand code flow ==
+=== Understand code flow ===
 
 The most important thing for you to know is how the code is supposed to work. Granted, there
 may be a problem with how it is actually working, but if you don't know what the code
@@ -20,7 +170,7 @@ is supposed to do, you can't know what is wrong with it. This includes usages of
 builtin API, as well as your own code. Stack traces are important to understand as well.
 Lets examine the components of a stack trace, given the following source code:
 
-%%CODE|
+<%CODE|
 #!/usr/local/bin/mscript
 proc(_proc1, @a,
         return(_proc2(@a))
@@ -31,16 +181,16 @@ proc(_proc2, @b,
 )
 
 msg(_proc1(0))
-%%
+%>
 
 When we run this script, we get the following error:
 
-%%PRE|
+<%PRE|
 RangeException: Division by 0!
         proc _proc2:Interpreter:8
         proc _proc1:Interpreter:4
         <<main code>>:Interpreter:11
-%%
+%>
 
 This is our ''stack trace''. The problem is that we are dividing by zero. The first
 line of the stack trace tells us what the error type was, and gives us the exception
@@ -53,60 +203,62 @@ will contain a file path. The important information is the code description and
 number. The code description tells us that this is code defined in the procedure "_proc2",
 and the error is on line 8.
 
-%%PRE|
+<%PRE|
 8          return(1 / @b)
-%%
+%>
 
 If @b is zero, then this would certainly cause the error. However, there is more to the
 stack trace, which is useful, because this line may not be where we actually want to fix
 the error. The next element in the stack trace tells us that _proc2 was called from _proc1,
 on line 4.
 
-%%PRE|
+<%PRE|
 4          return(_proc2(@a))
-%%
+%>
 
 Ok, so this still doesn't help us much, because we don't know where @a came from,
 so lets dig down again into the stack trace. The last element is &lt;&lt;main code&gt;&gt;, which
 means that this is the "top level" of the execution unit. In this case, it means that
 the code is "loose" code, that is, it is not contained inside a procedure. 
 
-%%PRE|
+<%PRE|
 11 msg(_proc1(0))
-%%
+%>
 
 Aha! Now we see where the 0 is coming from, it is hard coded in at this point. Sometimes
 your code is more complicated though, and it's not so obvious where a value is coming from,
 which leads us to our next section:
 
-== Understand variable's values ==
+=== Understand variable's values ===
 
-Sometimes it's not obvious where a variable's values come from. In this case, you can use
+Sometimes it's not obvious where a variable's values come from. If you are using the
+VS Code debugger, you can simply set a breakpoint and inspect variables in the
+Variables panel. Without a debugger, you can use
 runtime checks to gather the value of variables. The simplest way to do this is to use
 {{function|msg}} or {{function|console}} to output the value of the variable at that moment
 in time. Say you have a value that is brought in from storage:
 
-%%CODE|
+<%CODE|
 @value = get_value('my.value')
-%%
+%>
 
 We don't know offhand what @value is, so it may be useful to output the value before we use
 it, especially if it's involved in part of the stack trace chain.
 
-%%CODE|
+<%CODE|
 msg(@value)
-%%
+%>
 
 You can also use {{function|trace}} for a more detailed output, which includes the
 variable name. So, assuming @value contained 'string', then <code>trace(@value)</code>
 would output: <code>@value: string</code>.
 
-== Know the assumptions you are making, and test assumptions that matter ==
+=== Know the assumptions you are making, and test assumptions that matter ===
 
 As you look at the problem code, it is likely that you won't test all your assumptions. Sometimes,
 it's obvious what a particular value is, for instance, given this code:
 
-%%CODE|
+<%CODE|
 @value1 = $value
 @value2 = 1
 if(@value1 == 'test1'){
@@ -114,7 +266,7 @@ if(@value1 == 'test1'){
 }
 trace(@value1)
 _problem_code(@value2)
-%%
+%>
 
 If when we trace(@value1), we see that it is "test1", then we can safely assume that
 @value2 is 0. However, if we did not have that trace() present, (allowing us to know
@@ -122,24 +274,24 @@ the value of @value1 for sure) we must be aware that we have two assumptions her
 assumptions matter, that is, they are involved in the code that is having problems, we
 would be wise to test those assumptions, in order to rule out the problem.
 
-== Syntax errors ==
+=== Syntax errors ===
 
 These debugging techniques do not help with syntax errors. There is a difference between
 compiler errors and runtime errors. Syntax errors do not require testing values or anything,
 because they are a problem with your syntax, not your logic. For instance, in the following
 code, we are missing a parenthesis.
 
-%%CODE|
+<%CODE|
 if(@a == 2{
 	msg('a is 2')
 }
-%%
+%>
 
 These types of errors are usually more straightforward to fix, since the compiler can usually
 point us right at the code in question. Regardless, the code isn't actually running
 at this point, so our runtime debugging techniques aren't applicable here.
 
-== Bugs in MethodScript itself ==
+=== Bugs in MethodScript itself ===
 
 MethodScript is itself written in code, and is prone to bugs as well. These debugging
 techniques are not meant to be useful when you get a java stack trace, and in fact,
@@ -148,13 +300,13 @@ cases, you may be able to find a workaround which prevents the error, but in ALL
 cases if you get a Java stack trace, this is a bug which should be reported. An example
 Java stack trace looks like this:
 
-%%PRE|
+<%PRE|
 java.io.FileNotFoundException: test.txt
         at java.io.FileInputStream.<init>(FileInputStream.java)
         at java.io.FileInputStream.<init>(FileInputStream.java)
         at com.example.Example.readFile(Example.java:19)
         at com.example.Example.main(Example.java:7)
-%%
+%>
 
 If you can determine what was done to cause this error, please include that information
 in the bug report, but often times, this error can be fixed without any information
diff --git a/src/main/resources/docs/LLVM_Development b/src/main/resources/docs/LLVM_Development
index 9e26f692c..eb86c3968 100644
--- a/src/main/resources/docs/LLVM_Development
+++ b/src/main/resources/docs/LLVM_Development
@@ -329,4 +329,4 @@ Now %1 is a pointer to memory, which contains the value 0. To get 0 back, we hav
 for the various IR commands. Note that this is not necessarily the authoritative source though, reverse engineering \
 clang output is.
 * [https://borretti.me/article/compiling-llvm-ir-binary Compiling hand written LLVM, for test purposes.]
-* [https://mapping-high-level-constructs-to-llvm-ir.readthedocs.io/en/latest/README.html Guide for mapping high level language concepts to LLVM.]
\ No newline at end of file
+* [https://mapping-high-level-constructs-to-llvm-ir.readthedocs.io/en/latest/ Guide for mapping high level language concepts to LLVM.]
\ No newline at end of file
diff --git a/src/main/resources/plugin.yml b/src/main/resources/plugin.yml
index c93059f44..96c098789 100644
--- a/src/main/resources/plugin.yml
+++ b/src/main/resources/plugin.yml
@@ -24,6 +24,10 @@ commands:
         description: Turns on the interpreter for however long is specified in the preferences option "interpreter-timeout". This only does something if run from console.
         usage: /<command>
         permission: this.command.can.only.be.run.from.console
+    debug-server:
+        description: Controls the DAP debug server. Console only.
+        usage: /<command> <start|stop|status>
+        permission: this.command.can.only.be.run.from.console
 permissions:
     ch.reloadaliases:
         description: Permission alias for commandhelper.reloadaliases
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..6ed713a95
--- /dev/null
+++ b/src/test/java/com/laytonsmith/core/DebugInfrastructureTest.java
@@ -0,0 +1,809 @@
+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.DebugSecurity;
+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.MAIN_THREAD_DAP_ID,
+				DebugContext.StepMode.NONE, 0, Target.UNKNOWN, -1);
+		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.MAIN_THREAD_DAP_ID,
+				DebugContext.StepMode.NONE, 0, Target.UNKNOWN, -1);
+		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.MAIN_THREAD_DAP_ID,
+				DebugContext.StepMode.NONE, 0, Target.UNKNOWN, -1);
+		Script.resumeEval(listener.snapshot(0));
+
+		assertEquals(2, listener.pauses.size());
+		assertEquals(3, listener.pauses.get(1).getPauseTarget().line());
+
+		// Continue to completion
+		debugCtx.setStepMode(DebugContext.MAIN_THREAD_DAP_ID,
+				DebugContext.StepMode.NONE, 0, Target.UNKNOWN, -1);
+		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.MAIN_THREAD_DAP_ID, DebugContext.StepMode.INTO,
+				pause1.getUserCallDepth(), pause1.getPauseTarget(), -1);
+		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.MAIN_THREAD_DAP_ID,
+				DebugContext.StepMode.NONE, 0, Target.UNKNOWN, -1);
+		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.MAIN_THREAD_DAP_ID, DebugContext.StepMode.OVER,
+				pause1.getUserCallDepth(), pause1.getPauseTarget(), -1);
+		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.MAIN_THREAD_DAP_ID,
+				DebugContext.StepMode.NONE, 0, Target.UNKNOWN, -1);
+		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.MAIN_THREAD_DAP_ID, DebugContext.StepMode.OUT,
+				depthInside, pause1.getPauseTarget(), -1);
+		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.MAIN_THREAD_DAP_ID,
+				DebugContext.StepMode.NONE, 0, Target.UNKNOWN, -1);
+		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.MAIN_THREAD_DAP_ID,
+				DebugContext.StepMode.NONE, 0, Target.UNKNOWN, -1);
+		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.MAIN_THREAD_DAP_ID,
+				DebugContext.StepMode.NONE, 0, Target.UNKNOWN, -1);
+		Script.resumeEval(listener.snapshot(0));
+		assertEquals(1, listener.resumeCount);
+
+		debugCtx.setStepMode(DebugContext.MAIN_THREAD_DAP_ID,
+				DebugContext.StepMode.NONE, 0, Target.UNKNOWN, -1);
+		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, -1);
+		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, -1);
+		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, MSDebugServer.DEFAULT_BIND_ADDRESS,
+					env, false, mode, DebugSecurity.NONE, null);
+			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);
+	}
+
+	@Test
+	public void testStepIntoTargetSkipsEarlierCall() throws Exception {
+		String script = "proc _bar() {\n"
+				+ "\treturn(10)\n"
+				+ "}\n"
+				+ "proc _foo() {\n"
+				+ "\treturn(20)\n"
+				+ "}\n"
+				+ "@result = _bar() + _foo()";
+		TestDebugListener listener = new TestDebugListener();
+		DebugContext debugCtx = new DebugContext(listener, DebugContext.ThreadingMode.ASYNCHRONOUS,
+				Thread.currentThread());
+		debugCtx.addBreakpoint(new Breakpoint(TEST_FILE, 7));
+
+		executeWithDebugger(script, debugCtx);
+
+		// Should pause at line 7
+		assertEquals(1, listener.pauses.size());
+		PausedState pause1 = listener.pauses.get(0);
+		assertEquals(7, pause1.getPauseTarget().line());
+
+		// Check step-in targets include both procs
+		List<PausedState.StepInTargetInfo> targets = pause1.getStepInTargets();
+		PausedState.StepInTargetInfo fooTarget = null;
+		for(PausedState.StepInTargetInfo t : targets) {
+			if("_foo".equals(t.name())) {
+				fooTarget = t;
+			}
+		}
+		assertNotNull("Should find _foo as step-in target", fooTarget);
+
+		// Step into _foo specifically — should skip _bar entirely
+		debugCtx.getThreadState().setStepMode(DebugContext.StepMode.INTO,
+				pause1.getUserCallDepth(), pause1.getPauseTarget(), fooTarget.column());
+		Script.resumeEval(listener.snapshot(0));
+
+		// Should pause inside _foo (line 5), NOT _bar (line 2)
+		assertEquals(2, listener.pauses.size());
+		PausedState pause2 = listener.pauses.get(1);
+		assertEquals(5, pause2.getPauseTarget().line());
+
+		// Continue to completion
+		debugCtx.setStepMode(DebugContext.MAIN_THREAD_DAP_ID,
+				DebugContext.StepMode.NONE, 0, Target.UNKNOWN, -1);
+		Script.resumeEval(listener.snapshot(1));
+		assertTrue(listener.completed);
+	}
+
+	@Test
+	public void testStepIntoTargetThenBreakpointRefires() throws Exception {
+		String script = "proc _bar() {\n"
+				+ "\treturn(10)\n"
+				+ "}\n"
+				+ "proc _foo() {\n"
+				+ "\treturn(20)\n"
+				+ "}\n"
+				+ "@result = _bar() + _foo()";
+		TestDebugListener listener = new TestDebugListener();
+		DebugContext debugCtx = new DebugContext(listener, DebugContext.ThreadingMode.ASYNCHRONOUS,
+				Thread.currentThread());
+		debugCtx.addBreakpoint(new Breakpoint(TEST_FILE, 7));
+
+		executeWithDebugger(script, debugCtx);
+
+		// Pause 1: line 7 breakpoint
+		assertEquals(1, listener.pauses.size());
+		PausedState pause1 = listener.pauses.get(0);
+
+		// Find _bar target and step into it
+		List<PausedState.StepInTargetInfo> targets = pause1.getStepInTargets();
+		PausedState.StepInTargetInfo barTarget = null;
+		for(PausedState.StepInTargetInfo t : targets) {
+			if("_bar".equals(t.name())) {
+				barTarget = t;
+			}
+		}
+		assertNotNull("Should find _bar as step-in target", barTarget);
+
+		debugCtx.getThreadState().setStepMode(DebugContext.StepMode.INTO,
+				pause1.getUserCallDepth(), pause1.getPauseTarget(), barTarget.column());
+		Script.resumeEval(listener.snapshot(0));
+
+		// Pause 2: inside _bar (line 2)
+		assertEquals(2, listener.pauses.size());
+		assertEquals(2, listener.pauses.get(1).getPauseTarget().line());
+
+		// Continue from _bar — breakpoint on line 7 should re-fire
+		// (targeted step-into is complete, normal breakpoint behavior resumes)
+		debugCtx.setStepMode(DebugContext.MAIN_THREAD_DAP_ID,
+				DebugContext.StepMode.NONE, 0, Target.UNKNOWN, -1);
+		Script.resumeEval(listener.snapshot(1));
+
+		// Pause 3: breakpoint at line 7 fires again (back from _bar, _foo not yet called)
+		assertEquals(3, listener.pauses.size());
+		assertEquals(7, listener.pauses.get(2).getPauseTarget().line());
+
+		// Now step into _foo
+		PausedState pause3 = listener.pauses.get(2);
+		targets = pause3.getStepInTargets();
+		PausedState.StepInTargetInfo fooTarget = null;
+		for(PausedState.StepInTargetInfo t : targets) {
+			if("_foo".equals(t.name())) {
+				fooTarget = t;
+			}
+		}
+		assertNotNull("Should find _foo as step-in target", fooTarget);
+
+		debugCtx.getThreadState().setStepMode(DebugContext.StepMode.INTO,
+				pause3.getUserCallDepth(), pause3.getPauseTarget(), fooTarget.column());
+		Script.resumeEval(listener.snapshot(2));
+
+		// Pause 4: inside _foo (line 5)
+		assertEquals(4, listener.pauses.size());
+		assertEquals(5, listener.pauses.get(3).getPauseTarget().line());
+
+		// Continue to completion
+		debugCtx.setStepMode(DebugContext.MAIN_THREAD_DAP_ID,
+				DebugContext.StepMode.NONE, 0, Target.UNKNOWN, -1);
+		Script.resumeEval(listener.snapshot(3));
+		assertTrue(listener.completed);
+	}
+}